TypeScript

pnpm add codai-sdk

import { Codai } from 'codai-sdk';

const codai = new Codai({
  apiKey: process.env.CODAI_API_KEY!, // obligatoriu
  baseUrl: 'https://ai.codai.ro',      // implicit
  sessionId: 'my-project',             // opțional — activează memoria de sesiune + sticky routing
  device: '<uuid>',                    // opțional — x-codai-device pentru sesiuni partajate / host-uri
  client: 'my-app/1.2.0',              // opțional — eticheta x-codai-client a suprafeței
  timeoutMs: 120_000,                  // implicit
  maxRetries: 2,                       // reîncercări pe 429 / 5xx cu backoff exponențial
});

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

// stream-urile SSE native codai sunt iteratoare async de frame-uri { event, data }
const { id } = await codai.agents.runs.create({ task: 'Rezumă README-ul repo-ului.' });
for await (const ev of codai.agents.runs.stream(id)) {
  if (ev.event === 'done') console.log(ev.data.status, ev.data.result);
}

// sesiunile partajate au nevoie de un id de dispozitiv pe 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: 'Explică iteratorii async într-o linie.' }],
});

res.content;    // textul asistentului (prima alegere)
res.toolCalls;  // tool calls pe prima alegere (array gol dacă nu există)
res.routedTo;   // modelul upstream care a servit — din x-codai-routed-to
res.requestId;  // din x-codai-trace-id / x-request-id
res.eventId;    // din x-codai-event-id — ținta exactă pentru feedback()
res.usage;      // { promptTokens, completionTokens } | null
res.execVerify; // 'passed' | 'refined' | … pe codai-labs, altfel null
res.raw;        // răspunsul complet de formă OpenAI
res.headers;    // toate header-ele de răspuns x-codai-*

const res = await codai.chat({
  messages: [{ role: 'user', content: 'Vremea la 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: 'Vremea la 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: 'Scrie un haiku despre 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: 'Rezumă punctele cheie ale textului furnizat.',
  context: '…input-ul tău…',    // opțional, ≤ 256 000 caractere
  system: 'Răspunde în română.', // opțional, ≤ 32 000 caractere
  model: 'codai',              // opțional
});

run.result;  // string
run.model;   // upstream-ul care a servit
run.eventId; // id-ul rândului de usage — îl trimiți la feedback()
run.usage;   // obiect usage brut | null

const res = await codai.chat({ messages: [{ role: 'user', content: 'salut' }] });
if (res.requestId) await codai.feedback(res.requestId, 1, 'exact ce trebuia');

const { embeddings, raw } = await codai.embeddings({
  input: ['salut', 'lume'],
  model: 'codai-embed', // implicit
  dimensions: 512,      // opțional
});
embeddings[0]; // number[]

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

// Speech-to-text — încărcare multipart, maximum 25 MB. Returnează string-ul transcris.
const text = await codai.audio.transcribe({
  file: await readFile('clip.webm'), // Blob | Uint8Array | ArrayBuffer
  filename: 'clip.webm',             // extensia determină detecția formatului
  model: 'codai-transcribe',         // implicit
});

// Text-to-speech — returnează byte-ii audio (mp3 implicit).
const audio = await codai.audio.speech({ input: 'Salut de la codai.', voice: 'alloy' });
await writeFile('salut.mp3', Buffer.from(audio));

const { token, expiresAt, scope } = await codai.mintToken('realtime', 600);
// dai `token` clientului; funcționează doar pe suprafața realtime, cel mult ttl secunde

const ids = await codai.models();        // Array<{ id: string }> — forma din 0.2.x
const full = await codai.models.list();  // CoreModel[] cu obiectul de capabilități `codai`

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

try {
  await codai.chat({ messages: [{ role: 'user', content: 'salut' }] });
} catch (err) {
  if (err instanceof CodaiError) {
    console.error(err.status, err.code, err.requestId, err.message);
    if (err.code === 'quota_exceeded') {
      /* alocarea de task-uri a planului consumată — aștepți err.retryAfter secunde */
    }
  }
}

// înainte
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;

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