Integration Guides

// Before
baseURL: 'https://api.openai.com/v1'

// After — everything else stays the same
baseURL: 'https://api.stratus.run/v1'

// Before
const client = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY
});

// After
const client = new OpenAI({
  baseURL: 'https://api.stratus.run/v1',
  apiKey: process.env.STRATUS_API_KEY
});

// Before
const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY
});

// After
const client = new Anthropic({
  baseURL: 'https://api.stratus.run',
  apiKey: process.env.STRATUS_API_KEY
});

import OpenAI from 'openai';
import 'dotenv/config';

const client = new OpenAI({
  baseURL: 'https://api.stratus.run/v1',
  apiKey: process.env.STRATUS_API_KEY
});

const response = await client.chat.completions.create({
  model: 'stratus-x1ac-base-gpt-4o',
  messages: [
    {
      role: 'system',
      content: 'Current state: User on homepage, search box visible.'
    },
    {
      role: 'user',
      content: 'Search for "best laptops 2024"'
    }
  ]
});

console.log(response.choices[0].message.content);
console.log(response.stratus.overall_confidence);       // X1 confidence score
console.log(response.stratus.planning_time_ms); // planning overhead

const stream = await client.chat.completions.create({
  model: 'stratus-x1ac-base-gpt-4o',
  messages: [{ role: 'user', content: 'Navigate to checkout' }],
  stream: true
});

for await (const chunk of stream) {
  const content = chunk.choices[0]?.delta?.content;
  if (content) process.stdout.write(content);
}

try {
  const response = await client.chat.completions.create({
    model: 'stratus-x1ac-base-gpt-4o',
    messages: [...]
  });
} catch (error) {
  if (error.status === 401) console.error('Invalid API key');
  else if (error.status === 402) console.error('Insufficient credits');
  else if (error.status === 429) console.error('Rate limit exceeded');
  else console.error('API error:', error.message);
}

import Anthropic from '@anthropic-ai/sdk';
import 'dotenv/config';

const client = new Anthropic({
  baseURL: 'https://api.stratus.run',
  apiKey: process.env.STRATUS_API_KEY
});

const response = await client.messages.create({
  model: 'stratus-x1ac-base-claude-sonnet-4-5',
  max_tokens: 1024,
  messages: [
    {
      role: 'user',
      content: 'Current state: Amazon product page. Goal: Add to cart and proceed to checkout.'
    }
  ]
});

console.log(response.content[0].text);

const stream = await client.messages.create({
  model: 'stratus-x1ac-base-claude-sonnet-4-5',
  max_tokens: 1024,
  messages: [{ role: 'user', content: 'Navigate to settings' }],
  stream: true
});

for await (const event of stream) {
  if (event.type === 'content_block_delta') {
    process.stdout.write(event.delta.text);
  }
}

import { ChatOpenAI } from '@langchain/openai';
import 'dotenv/config';

const model = new ChatOpenAI({
  openAIApiKey: process.env.STRATUS_API_KEY,
  configuration: { baseURL: 'https://api.stratus.run/v1' },
  modelName: 'stratus-x1ac-base-gpt-4o'
});

const response = await model.invoke([
  { role: 'system', content: 'Current state: Google search results for "restaurants near me"' },
  { role: 'user', content: 'Click on the first result' }
]);

console.log(response.content);

import { AgentExecutor, createOpenAIFunctionsAgent } from 'langchain/agents';
import { pull } from 'langchain/hub';

const model = new ChatOpenAI({
  openAIApiKey: process.env.STRATUS_API_KEY,
  configuration: { baseURL: 'https://api.stratus.run/v1' },
  modelName: 'stratus-x1ac-base-gpt-4o'
});

const prompt = await pull('hwchase17/openai-functions-agent');
const agent = await createOpenAIFunctionsAgent({ llm: model, tools: yourTools, prompt });
const executor = new AgentExecutor({ agent, tools: yourTools });

const result = await executor.invoke({
  input: 'Navigate to the checkout page and fill in shipping details'
});

console.log(result.output);

import { PromptTemplate } from '@langchain/core/prompts';
import { RunnableSequence } from '@langchain/core/runnables';

const chain = RunnableSequence.from([
  PromptTemplate.fromTemplate('Current state: {state}\nGoal: {goal}\nWhat should I do next?'),
  model
]);

const result = await chain.invoke({
  state: 'Amazon homepage',
  goal: 'Find and purchase wireless headphones under $100'
});

console.log(result.content);

// app/actions.ts
'use server';

import { openai } from '@ai-sdk/openai';
import { streamText } from 'ai';
import { createStreamableValue } from 'ai/rsc';

const model = openai('stratus-x1ac-base-gpt-4o', {
  baseURL: 'https://api.stratus.run/v1',
  apiKey: process.env.STRATUS_API_KEY
});

export async function navigateAction(state: string, goal: string) {
  const stream = createStreamableValue('');

  (async () => {
    const { textStream } = await streamText({
      model,
      messages: [
        { role: 'system', content: `Current state: ${state}` },
        { role: 'user', content: goal }
      ]
    });

    for await (const delta of textStream) stream.update(delta);
    stream.done();
  })();

  return { output: stream.value };
}

// app/page.tsx
'use client';

import { useState } from 'react';
import { readStreamableValue } from 'ai/rsc';
import { navigateAction } from './actions';

export default function Page() {
  const [response, setResponse] = useState('');

  const handleNavigate = async () => {
    const { output } = await navigateAction('Amazon homepage', 'Search for wireless headphones');
    for await (const delta of readStreamableValue(output)) {
      setResponse(prev => prev + delta);
    }
  };

  return (
    <div>
      <button onClick={handleNavigate}>Navigate</button>
      <div>{response}</div>
    </div>
  );
}

// app/api/navigate/route.ts
import { openai } from '@ai-sdk/openai';
import { streamText } from 'ai';

const model = openai('stratus-x1ac-base-gpt-4o', {
  baseURL: 'https://api.stratus.run/v1',
  apiKey: process.env.STRATUS_API_KEY
});

export async function POST(req: Request) {
  const { state, goal } = await req.json();

  const result = await streamText({
    model,
    messages: [
      { role: 'system', content: `Current state: ${state}` },
      { role: 'user', content: goal }
    ]
  });

  return result.toDataStreamResponse();
}

curl https://api.stratus.run/v1/chat/completions \
  -H "Authorization: Bearer $STRATUS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "stratus-x1ac-base-gpt-4o",
    "messages": [
      {"role": "system", "content": "Current state: Google homepage. Search box visible."},
      {"role": "user", "content": "Search for best laptops 2024"}
    ]
  }'

curl https://api.stratus.run/v1/chat/completions \
  -H "Authorization: Bearer $STRATUS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"stratus-x1ac-base-gpt-4o","messages":[{"role":"user","content":"Navigate to checkout"}],"stream":true}'

# Just the response text
curl -s https://api.stratus.run/v1/chat/completions \
  -H "Authorization: Bearer $STRATUS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"stratus-x1ac-base-gpt-4o","messages":[{"role":"user","content":"Test"}]}' \
  | jq -r '.choices[0].message.content'

# X1 planning metadata
  ... | jq '.stratus'