TypeScript

pnpm add codai-sdk

import { Codai } from 'codai-sdk';

const codai = new Codai({
  apiKey: process.env.CODAI_API_KEY!, // required
  baseUrl: 'https://ai.codai.ro',      // default
  sessionId: 'my-project',             // optional — enables session memory + sticky routing
  device: '<uuid>',                    // optional — x-codai-device for shared sessions / hosts
  client: 'my-app/1.2.0',              // optional — x-codai-client surface tag
  timeoutMs: 120_000,                  // default
  maxRetries: 2,                       // retries on 429 / 5xx with exponential backoff
});

await codai.chat.completions.create(
  { messages, model: 'codai' },
  { ext: { effort: 'high', thinking: true, thinkingBudget: 8192 } },
);

// codai-native SSE streams are async iterators of { event, data } frames
const { id } = await codai.agents.runs.create({ task: 'Summarise the repo README.' });
for await (const ev of codai.agents.runs.stream(id)) {
  if (ev.event === 'done') console.log(ev.data.status, ev.data.result);
}

// shared sessions need a device id on the client
const session = await codai.sessions.create({ session_key: 'desktop-main' });
await codai.sessions.lease.acquire(session.id);
for await (const frame of codai.sessions.stream(session.id, { after: 0 })) {
  // frame.event ∈ 'event' | 'control' | 'lease' | 'presence'
}

const res = await codai.chat({
  messages: [{ role: 'user', content: 'Explain async iterators in one line.' }],
});

res.content;    // assistant text (first choice)
res.toolCalls;  // tool calls on the first choice (empty array if none)
res.routedTo;   // upstream model that served — from x-codai-routed-to
res.requestId;  // from x-codai-trace-id / x-request-id
res.eventId;    // from x-codai-event-id — exact target for feedback()
res.usage;      // { promptTokens, completionTokens } | null
res.execVerify; // 'passed' | 'refined' | … on codai-labs, else null
res.raw;        // the full OpenAI-shaped response
res.headers;    // every x-codai-* response header

const res = await codai.chat({
  messages: [{ role: 'user', content: 'Weather in Cluj?' }],
  tools: [
    {
      type: 'function',
      function: {
        name: 'get_weather',
        parameters: { type: 'object', properties: { city: { type: 'string' } }, required: ['city'] },
      },
    },
  ],
});

const call = (res.raw.choices as any[])[0].message.tool_calls?.[0];
if (call) {
  const result = await getWeather(JSON.parse(call.function.arguments).city);
  const followUp = await codai.chat({
    messages: [
      { role: 'user', content: 'Weather in Cluj?' },
      { role: 'assistant', content: '', ...(res.raw.choices as any[])[0].message },
      { role: 'tool', tool_call_id: call.id, content: JSON.stringify(result) },
    ],
  });
}

const stream = codai.chatStream({
  messages: [{ role: 'user', content: 'Write a haiku about TypeScript.' }],
});

for await (const delta of stream) {
  process.stdout.write(delta);
}

const { content, requestId, usage, routedTo, toolCalls } = await stream.final;
if (requestId) await codai.feedback(requestId, 1);

const run = await codai.agents.run({
  task: 'Summarize the key points of the provided text.',
  context: '…your input…',   // optional, ≤ 256 000 chars
  system: 'Answer in Romanian.', // optional, ≤ 32 000 chars
  model: 'codai',            // optional
});

run.result;  // string
run.model;   // upstream that served
run.eventId; // usage row id — pass to feedback()
run.usage;   // raw usage object | null

const res = await codai.chat({ messages: [{ role: 'user', content: 'hi' }] });
if (res.requestId) await codai.feedback(res.requestId, 1, 'exactly right');

const { embeddings, raw } = await codai.embeddings({
  input: ['hello', 'world'],
  model: 'codai-embed', // default
  dimensions: 512,      // optional
});
embeddings[0]; // number[]

import { readFile, writeFile } from 'node:fs/promises';

// Speech-to-text — multipart upload, max 25 MB. Returns the transcript string.
const text = await codai.audio.transcribe({
  file: await readFile('clip.webm'), // Blob | Uint8Array | ArrayBuffer
  filename: 'clip.webm',             // extension drives format detection
  model: 'codai-transcribe',         // default
});

// Text-to-speech — returns the audio bytes (mp3 by default).
const audio = await codai.audio.speech({ input: 'Hello from codai.', voice: 'alloy' });
await writeFile('hello.mp3', Buffer.from(audio));

const { token, expiresAt, scope } = await codai.mintToken('realtime', 600);
// hand `token` to the client; it works only on the realtime surface, for ≤ ttl seconds

const ids = await codai.models();        // Array<{ id: string }> — 0.2.x shape
const full = await codai.models.list();  // CoreModel[] with the `codai` capability object

import { Codai, CodaiError } from 'codai-sdk';

try {
  await codai.chat({ messages: [{ role: 'user', content: 'hi' }] });
} catch (err) {
  if (err instanceof CodaiError) {
    console.error(err.status, err.code, err.requestId, err.message);
    if (err.code === 'quota_exceeded') {
      /* plan task allowance used up — back off for err.retryAfter seconds */
    }
  }
}

// before
import OpenAI from 'openai';
const openai = new OpenAI({ apiKey, baseURL: 'https://ai.codai.ro/v1' });
const r = await openai.chat.completions.create({ model: 'codai', messages });
r.choices[0].message.content;

// after
import { Codai } from 'codai-sdk';
const codai = new Codai({ apiKey });
const res = await codai.chat({ messages });
res.content;