TypeScript SDK

import { Kuiper } from '@kuiper-sh/sdk';

const kuiper = new Kuiper({ apiKey: 'kgw_…' });

const { text } = await kuiper.models.chat({ model: 'claude-sonnet-5-5', prompt: 'Say hello' });

const session = await kuiper.browsers.create();        // connect Playwright to session.websocketUrl
const sandbox = await kuiper.sandboxes.create();       // run commands with sandbox.exec(…)

import { Sandboxes } from '@kuiper-sh/sandboxes';

const sandboxes = new Sandboxes({ apiKey: 'kgw_…' });

new Kuiper({ apiKey, region: 'eu-fsn' });                          // gateway.eu-fsn.kuiper.sh
new Kuiper({ apiKey, gatewayUrl: 'https://gateway.example.com' }); // your own Kuiper's gateway

const r = await kuiper.models.chat({
  model: 'claude-sonnet-5-5',
  system: 'You answer in one sentence.',
  prompt: 'What is a sandbox?',
});
r.text;          // the answer
r.usage;         // tokens, as the provider counted them
r.callId;        // the call in the dashboard's Models page, or kuiper.models.call(r.callId)

const stream = kuiper.models.stream({ model: 'gpt-5-mini', prompt: 'Write a haiku about comets' });
for await (const text of stream) process.stdout.write(text);
const { usage, toolCalls } = await stream.result();

await kuiper.models.chat({ model: 'claude-sonnet-5-5', fallbacks: ['openai/gpt-5'], prompt: '…' });

const run = kuiper.models.withSession(runId);   // every call of one agent run in one conversation
await run.chat({ model: 'gpt-5', messages });

const { embeddings } = await kuiper.models.embed({ model: 'text-embedding-3-small', input: ['a', 'b'] });

import OpenAI from 'openai';
import Anthropic from '@anthropic-ai/sdk';
import { GoogleGenAI } from '@google/genai';
import { createAdapter } from 'glove-core/models/providers';
import { createOpenAI } from '@ai-sdk/openai';
import { createAnthropic } from '@ai-sdk/anthropic';
import { createGoogleGenerativeAI } from '@ai-sdk/google';

const openai = new OpenAI(kuiper.models.openai());
const anthropic = new Anthropic(kuiper.models.anthropic());
const gemini = new GoogleGenAI(kuiper.models.google());

const kimi = createAdapter({ provider: 'kimi', model: 'kimi-k2.5', ...kuiper.models.glove('kimi') });
const claude = createAdapter({ provider: 'anthropic', model: 'claude-sonnet-5-5', ...kuiper.models.glove('anthropic') });

const aiOpenAI = createOpenAI(kuiper.models.aiSdk.openai());
const aiAnthropic = createAnthropic(kuiper.models.aiSdk.anthropic());
const aiGoogle = createGoogleGenerativeAI(kuiper.models.aiSdk.google());

import { chromium } from 'playwright';

const session = await kuiper.browsers.create({ timeout: 15 * 60_000 });
const browser = await chromium.connectOverCDP(session.websocketUrl);
const page = browser.contexts()[0].pages()[0];
await page.goto('https://example.com');
await browser.close();
await session.release();

const title = await kuiper.browsers.use({}, async (session) => {
  const browser = await chromium.connectOverCDP(session.websocketUrl);
  const page = browser.contexts()[0].pages()[0];
  await page.goto('https://example.com');
  return page.title();
});

const sandbox = await kuiper.sandboxes.create({ image: 'kuiper/coding', timeoutMs: 30 * 60_000 });

await sandbox.files.write('/workspace/hello.py', 'print("hello")');
const r = await sandbox.exec('python3 /workspace/hello.py');
r.stdout;    // "hello\n"
r.exitCode;  // 0

await sandbox.release();

await sandbox.exec(['npm', 'test'], { cwd: '/workspace', env: { CI: '1' }, timeoutMs: 600_000 });

// Output as it comes; nothing is cut at 4 MiB.
await sandbox.exec('npm install', { onStdout: (d) => process.stdout.write(d) });

// Every event: start, stdout, stderr, exit.
for await (const ev of sandbox.stream('make build')) console.log(ev);

// In the background, for servers.
const dev = await sandbox.start('npm run dev -- --host', { cwd: '/workspace/app' });
await dev.status();   // { running, exitCode }

const term = await sandbox.terminal({ cols: 120, rows: 40 });   // bash, or sh
term.onData((data) => process.stdout.write(data));
term.write('ls -la\r');
term.resize(100, 30);
const { exitCode } = await term.exited;

import { isKuiperError } from '@kuiper-sh/sdk';

try {
  await kuiper.sandboxes.create({ size: 'large' });
} catch (err) {
  if (isKuiperError(err, 'no_capacity')) {
    // the region is full: try again, or a smaller size
  } else if (isKuiperError(err, 'budget_exceeded')) {
    // a budget ran out
  } else throw err;
}