codai-sdk 0.1.0 → 0.3.1

package/dist/index.js

@@ -1,248 +1,1534 @@
-// src/index.ts
+// src/http.ts
 var CodaiError = class extends Error {
-  constructor(message, status, body) {
+  constructor(message, status, body, meta = {}) {
     super(message);
     this.status = status;
     this.body = body;
     this.name = "CodaiError";
+    this.code = meta.code ?? extractCode(body);
+    this.requestId = meta.requestId ?? null;
+    this.retryAfter = meta.retryAfter ?? null;
   }
   status;
   body;
+  /** Stable gateway error code (`invalid_api_key`, `rate_limit_exceeded`, …) when the body was an error envelope. */
+  code;
+  /** `x-codai-trace-id` (or `x-request-id`) of the failed response, when present. */
+  requestId;
+  /** Seconds to wait before retrying, from `Retry-After` on 429s. */
+  retryAfter;
 };
+function extractCode(body) {
+  if (body && typeof body === "object") {
+    const err = body.error;
+    if (err && typeof err === "object" && typeof err.code === "string")
+      return err.code;
+  }
+  return null;
+}
+function extractMessage(body) {
+  if (body && typeof body === "object") {
+    const err = body.error;
+    if (err && typeof err === "object" && typeof err.message === "string") return err.message;
+  }
+  return null;
+}
 var RETRYABLE = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
-var Codai = class {
+var EXTENSION_HEADERS = {
+  sessionId: "x-codai-session-id",
+  requestId: "x-request-id",
+  effort: "x-codai-effort",
+  thinking: "x-codai-thinking",
+  thinkingBudget: "x-codai-thinking-budget",
+  thinkingPin: "x-codai-thinking-pin",
+  cache: "x-codai-cache",
+  noTask: "x-codai-no-task",
+  taskId: "x-codai-task-id",
+  taskOutcome: "x-codai-task-outcome",
+  taskEvidence: "x-codai-task-evidence",
+  client: "x-codai-client",
+  incognito: "x-codai-incognito",
+  noRecall: "x-codai-no-recall",
+  provenOnly: "x-codai-proven-only",
+  newSession: "x-codai-new-session",
+  repo: "x-codai-repo",
+  agentId: "x-codai-agent-id",
+  disableSubagents: "x-codai-disable-subagents",
+  mode: "x-codai-mode",
+  serverTools: "x-codai-server-tools",
+  orchestrate: "x-codai-orchestrate",
+  cascade: "x-codai-cascade",
+  bestOf: "x-codai-best-of",
+  bestOfDepth: "x-codai-best-of-depth",
+  reflect: "x-codai-reflect",
+  stepVerify: "x-codai-step-verify",
+  plan: "x-codai-plan",
+  consensus: "x-codai-consensus",
+  compact: "x-codai-compact",
+  retrieval: "x-codai-retrieval",
+  heuristics: "x-codai-heuristics",
+  identity: "x-codai-identity",
+  playbook: "x-codai-playbook",
+  noPlaybook: "x-codai-no-playbook",
+  debug: "x-codai-debug",
+  device: "x-codai-device",
+  deviceName: "x-codai-device-name",
+  devicePlatform: "x-codai-device-platform",
+  pushToken: "x-codai-push-token",
+  shareToken: "x-codai-share-token"
+};
+function extensionHeaders(ext) {
+  const out = {};
+  if (!ext) return out;
+  for (const [key, header] of Object.entries(EXTENSION_HEADERS)) {
+    const value = ext[key];
+    if (value === void 0 || value === null) continue;
+    if (typeof value === "boolean") out[header] = value ? "1" : "0";
+    else if (key === "compact" && value === "auto") out[header] = "1";
+    else out[header] = String(value);
+  }
+  if (ext.headers) Object.assign(out, ext.headers);
+  return out;
+}
+var HttpClient = class {
   apiKey;
   baseUrl;
-  sessionId;
   timeoutMs;
   maxRetries;
+  defaults;
+  fetchImpl;
   constructor(opts) {
-    if (!opts.apiKey) throw new Error("Codai: apiKey is required");
     this.apiKey = opts.apiKey;
-    this.baseUrl = (opts.baseUrl ?? "https://ai.codai.ro").replace(/\/$/, "");
-    this.sessionId = opts.sessionId;
-    this.timeoutMs = opts.timeoutMs ?? 12e4;
-    this.maxRetries = opts.maxRetries ?? 2;
-  }
-  // ---------------------------------------------------------------- chat
-  async chat(opts) {
-    const res = await this.request("/v1/chat/completions", this.chatBody(opts, false), {
-      signal: opts.signal,
-      headers: this.chatHeaders(opts)
+    this.baseUrl = opts.baseUrl.replace(/\/$/, "");
+    this.timeoutMs = opts.timeoutMs;
+    this.maxRetries = opts.maxRetries;
+    this.defaults = opts.defaults ?? {};
+    this.fetchImpl = opts.fetch ?? ((input, init) => fetch(input, init));
+  }
+  url(path, query) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (query) {
+      for (const [k, v] of Object.entries(query)) {
+        if (v === void 0 || v === null) continue;
+        url.searchParams.set(k, typeof v === "boolean" ? v ? "1" : "0" : String(v));
+      }
+    }
+    return url.toString();
+  }
+  headers(ext, json = true) {
+    return {
+      Authorization: `Bearer ${this.apiKey}`,
+      ...json ? { "Content-Type": "application/json" } : {},
+      ...extensionHeaders(this.defaults),
+      ...extensionHeaders(ext)
+    };
+  }
+  /** Perform a request; throws `CodaiError` on non-2xx (after retries on 429/5xx). */
+  async request(path, init = {}) {
+    const url = this.url(path, init.query);
+    const hasJson = init.body !== void 0;
+    const headers = this.headers(init.ext, hasJson);
+    const method = init.method ?? (hasJson || init.rawBody !== void 0 ? "POST" : "GET");
+    const retries = init.noRetry || init.rawBody !== void 0 ? 0 : this.maxRetries;
+    const timeout = init.timeoutMs ?? this.timeoutMs;
+    const accept = new Set(init.acceptStatus ?? []);
+    let lastErr;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      const signal = init.signal ?? (timeout > 0 ? AbortSignal.timeout(timeout) : void 0);
+      try {
+        const res = await this.fetchImpl(url, {
+          method,
+          headers,
+          ...hasJson ? { body: JSON.stringify(init.body) } : {},
+          ...init.rawBody !== void 0 ? { body: init.rawBody } : {},
+          ...signal ? { signal } : {}
+        });
+        if (res.ok || accept.has(res.status)) return res;
+        if (RETRYABLE.has(res.status) && attempt < retries) {
+          await sleep(500 * 2 ** attempt + Math.random() * 250);
+          continue;
+        }
+        throw await this.toError(path, res);
+      } catch (err) {
+        if (err instanceof CodaiError) throw err;
+        lastErr = err;
+        if (init.signal?.aborted) throw err;
+        if (attempt < retries) {
+          await sleep(500 * 2 ** attempt);
+          continue;
+        }
+      }
+    }
+    throw new CodaiError(`codai ${path} failed after retries: ${String(lastErr)}`, 0, null);
+  }
+  async json(path, init = {}) {
+    const res = await this.request(path, init);
+    return await res.json();
+  }
+  /**
+   * Open a `text/event-stream` and iterate parsed frames. Frames are
+   * `\n\n`-separated blocks; each yields `{ event, data }` where `event`
+   * defaults to `message` and `data` is the joined `data:` payload (raw
+   * string — the caller decides whether it is JSON or `[DONE]`). Comment
+   * lines (`: ping`) are skipped. The stream is retried like any request
+   * up to the first byte; after that errors propagate.
+   */
+  async *sse(path, init = {}) {
+    const res = await this.request(path, {
+      ...init,
+      timeoutMs: init.timeoutMs ?? 0,
+      noRetry: true
+    });
+    yield* readSse(res, init.signal);
+    return res;
+  }
+  async toError(path, res) {
+    let body = null;
+    try {
+      body = await res.json();
+    } catch {
+    }
+    const retryAfterRaw = res.headers.get("retry-after");
+    const retryAfter = retryAfterRaw && /^\d+$/.test(retryAfterRaw) ? Number(retryAfterRaw) : null;
+    const message = extractMessage(body);
+    return new CodaiError(
+      message ? `codai ${path} \u2192 ${res.status}: ${message}` : `codai ${path} \u2192 ${res.status}`,
+      res.status,
+      body,
+      {
+        requestId: res.headers.get("x-codai-trace-id") ?? res.headers.get("x-request-id"),
+        retryAfter
+      }
+    );
+  }
+};
+async function* readSse(res, signal) {
+  const reader = res.body?.getReader();
+  if (!reader) throw new CodaiError("no response body", res.status, null);
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const onAbort = () => void reader.cancel().catch(() => {
+  });
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      buffer = buffer.replace(/\r\n/g, "\n");
+      const blocks = buffer.split("\n\n");
+      buffer = blocks.pop() ?? "";
+      for (const block of blocks) {
+        const frame = parseSseBlock(block);
+        if (frame) yield frame;
+      }
+    }
+    const tail = buffer.trim() ? parseSseBlock(buffer) : null;
+    if (tail) yield tail;
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    reader.releaseLock?.();
+  }
+}
+function parseSseBlock(block) {
+  let event = "message";
+  const data = [];
+  for (const line of block.split("\n")) {
+    if (!line || line.startsWith(":")) continue;
+    if (line.startsWith("event:")) event = line.slice(6).trim();
+    else if (line.startsWith("data:")) data.push(line.slice(5).replace(/^ /, ""));
+  }
+  if (data.length === 0) return null;
+  return { event, data: data.join("\n") };
+}
+function frameJson(frame) {
+  if (frame.data === "[DONE]") return null;
+  try {
+    return JSON.parse(frame.data);
+  } catch {
+    return null;
+  }
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/resources/account.ts
+var Account = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** `GET /v1/account` — the full account card. */
+  get(opts = {}) {
+    return this.http.json("/v1/account", { ext: opts.ext, signal: opts.signal });
+  }
+  /** `PATCH /v1/account` — consents, username, referral (at least one field). */
+  update(body, opts = {}) {
+    return this.http.json("/v1/account", {
+      method: "PATCH",
+      body,
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+};
+var Receipts = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * `GET /v1/receipt` — spend receipt. `sessionId` wins over `since`; with
+   * neither, the last 24 hours.
+   */
+  get(query = {}, opts = {}) {
+    return this.http.json("/v1/receipt", {
+      query: {
+        session_id: query.sessionId,
+        since: query.since instanceof Date ? query.since.toISOString() : query.since
+      },
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+};
+var Feedback = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * `POST /v1/feedback` — rate one turn. Exactly one of `event_id`,
+   * `session_id`, `client_request_id` must be present.
+   */
+  submit(body, opts = {}) {
+    return this.http.json("/v1/feedback", {
+      body,
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+};
+var PhoneModels = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** `GET /v1/phone/models` — on-device model catalog with signed URLs. */
+  async list(opts = {}) {
+    const raw = await this.http.json("/v1/phone/models", {
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    return [...raw.models ?? []];
+  }
+};
+
+// src/resources/agents.ts
+var AgentRuns = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** `POST /v1/agents/runs` — returns 202 with the run id. */
+  create(body, opts = {}) {
+    return this.http.json("/v1/agents/runs", {
+      body,
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+  /** `GET /v1/agents/runs/{id}` */
+  get(id, opts = {}) {
+    return this.http.json(`/v1/agents/runs/${encodeURIComponent(id)}`, {
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+  /** `GET /v1/agents/runs/{id}/steps` — newest first. */
+  async steps(id, opts = {}) {
+    const raw = await this.http.json(
+      `/v1/agents/runs/${encodeURIComponent(id)}/steps`,
+      { ext: opts.ext, signal: opts.signal }
+    );
+    return [...raw.steps ?? []];
+  }
+  /** `GET /v1/agents/runs/stats?days=` */
+  stats(days, opts = {}) {
+    return this.http.json("/v1/agents/runs/stats", {
+      query: { days },
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+  /** `POST /v1/agents/runs/{id}/cancel` */
+  cancel(id, opts = {}) {
+    return this.http.json(
+      `/v1/agents/runs/${encodeURIComponent(id)}/cancel`,
+      { method: "POST", body: {}, ext: opts.ext, signal: opts.signal }
+    );
+  }
+  /**
+   * `GET /v1/agents/runs/{id}/stream` — async iterator over `step` / `done` /
+   * `timeout` events. The iterator ends after `done`; on `timeout` (30 min)
+   * it also ends and you may reconnect (full replay from seq 0).
+   */
+  async *stream(id, opts = {}) {
+    const frames = this.http.sse(`/v1/agents/runs/${encodeURIComponent(id)}/stream`, {
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    for await (const frame of frames) {
+      const data = frameJson(frame);
+      if (!data) continue;
+      const ev = { event: frame.event, data };
+      yield ev;
+      if (ev.event === "done" || ev.event === "timeout") return;
+    }
+  }
+};
+var Agents = class {
+  constructor(http) {
+    this.http = http;
+    this.runs = new AgentRuns(http);
+  }
+  http;
+  runs;
+  /** `POST /v1/agents/run` — blocks until the agent loop finishes. */
+  async run(body, opts = {}) {
+    const res = await this.http.request("/v1/agents/run", {
+      body,
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    const raw = await res.json();
+    return {
+      result: String(raw.result ?? ""),
+      model: String(raw.model ?? ""),
+      eventId: raw.event_id ?? res.headers.get("x-codai-event-id"),
+      usage: raw.usage ?? null,
+      raw,
+      headers: res.headers
+    };
+  }
+};
+
+// src/resources/audio.ts
+var Audio = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Speech-to-text (multipart upload; never retried). Returns the transcript (0.2.x shape). */
+  async transcribe(opts) {
+    return (await this.transcribeDetailed(opts)).text;
+  }
+  /** Speech-to-text with the raw upstream JSON and routing headers. */
+  async transcribeDetailed(opts) {
+    const form = new FormData();
+    const blob = opts.file instanceof Blob ? opts.file : new Blob([opts.file]);
+    form.append("file", blob, opts.filename ?? "audio.webm");
+    form.append("model", opts.model ?? "codai-transcribe");
+    if (opts.language) form.append("language", opts.language);
+    if (opts.prompt) form.append("prompt", opts.prompt);
+    if (opts.responseFormat) form.append("response_format", opts.responseFormat);
+    if (opts.temperature !== void 0) form.append("temperature", String(opts.temperature));
+    const res = await this.http.request("/v1/audio/transcriptions", {
+      method: "POST",
+      rawBody: form,
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    const raw = await res.json();
+    return {
+      text: typeof raw.text === "string" ? raw.text : "",
+      raw,
+      routedTo: res.headers.get("x-codai-routed-to"),
+      headers: res.headers
+    };
+  }
+  /** Text-to-speech. Returns the raw audio bytes (0.2.x shape); see `speechDetailed()` for headers. */
+  async speech(body, opts = {}) {
+    return (await this.speechDetailed(body, opts)).audio;
+  }
+  /** Text-to-speech with the upstream `content-type` and routing headers. */
+  async speechDetailed(body, opts = {}) {
+    const res = await this.http.request("/v1/audio/speech", {
+      body: { ...body, model: body.model ?? "codai-tts", voice: body.voice ?? "alloy" },
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    return {
+      audio: await res.arrayBuffer(),
+      contentType: res.headers.get("content-type") ?? "audio/mpeg",
+      routedTo: res.headers.get("x-codai-routed-to"),
+      headers: res.headers
+    };
+  }
+};
+
+// src/resources/chat.ts
+function toUsage(u) {
+  if (!u) return null;
+  const cached = u.prompt_tokens_details?.cached_tokens;
+  return {
+    promptTokens: u.prompt_tokens ?? 0,
+    completionTokens: u.completion_tokens ?? 0,
+    ...cached !== void 0 ? { cachedTokens: cached } : {}
+  };
+}
+function mergeToolCall(acc, index, fragment) {
+  const existing = acc.get(index) ?? { index };
+  for (const [key, val] of Object.entries(fragment)) {
+    if (key === "index") continue;
+    if (key === "function" && val && typeof val === "object") {
+      const fn = existing.function ?? {};
+      for (const [fk, fv] of Object.entries(val)) {
+        if (fk === "arguments") fn.arguments = String(fn.arguments ?? "") + String(fv ?? "");
+        else fn[fk] = fv;
+      }
+      existing.function = fn;
+    } else {
+      existing[key] = val;
+    }
+  }
+  acc.set(index, existing);
+}
+var ChatCompletions = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * Non-streaming completion. `stream` is forced to `false`; use
+   * `stream()` for SSE.
+   */
+  async create(body, opts = {}) {
+    const res = await this.http.request("/v1/chat/completions", {
+      body: { ...body, model: body.model ?? "codai", stream: false },
+      ext: opts.ext,
+      signal: opts.signal
     });
     const raw = await res.json();
-    const choices = raw.choices;
+    const first = raw.choices?.[0];
     const usage = raw.usage;
     return {
-      content: String(choices?.[0]?.message?.content ?? ""),
+      content: typeof first?.message?.content === "string" ? first.message.content : "",
+      toolCalls: [...first?.message?.tool_calls ?? []],
       raw,
-      requestId: res.headers.get("x-request-id"),
+      requestId: res.headers.get("x-codai-trace-id") ?? res.headers.get("x-request-id"),
+      eventId: res.headers.get("x-codai-event-id"),
       routedTo: res.headers.get("x-codai-routed-to"),
       execVerify: res.headers.get("x-codai-exec-verify"),
-      usage: usage ? {
-        promptTokens: usage.prompt_tokens ?? 0,
-        completionTokens: usage.completion_tokens ?? 0
-      } : null
+      usage: toUsage(usage),
+      headers: res.headers
     };
   }
-  /** Streaming chat: async-iterate text deltas; `final` resolves afterwards. */
-  async *chatStream(opts) {
-    const res = await this.request("/v1/chat/completions", this.chatBody(opts, true), {
+  /** Streaming completion (`stream: true`). */
+  stream(body, opts = {}) {
+    const requestPromise = this.http.request("/v1/chat/completions", {
+      body: { ...body, model: body.model ?? "codai", stream: true },
+      ext: opts.ext,
       signal: opts.signal,
-      headers: this.chatHeaders(opts)
+      timeoutMs: 0,
+      noRetry: true
     });
-    const reader = res.body?.getReader();
-    if (!reader) throw new CodaiError("no response body", res.status, null);
-    const decoder = new TextDecoder();
-    let buffer = "";
-    for (; ; ) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const frames = buffer.split("\n\n");
-      buffer = frames.pop() ?? "";
-      for (const frame of frames) {
-        for (const line of frame.split("\n")) {
-          if (!line.startsWith("data:")) continue;
-          const data = line.slice(5).trim();
-          if (data === "[DONE]") return;
-          try {
-            const chunk = JSON.parse(data);
-            const delta = chunk.choices?.[0]?.delta?.content;
-            if (delta) yield delta;
-          } catch {
+    let resolveFinal;
+    let rejectFinal;
+    const final = new Promise((resolve, reject) => {
+      resolveFinal = resolve;
+      rejectFinal = reject;
+    });
+    final.catch(() => {
+    });
+    const toolCallsByIndex = /* @__PURE__ */ new Map();
+    let content = "";
+    let usage = null;
+    let finishReason = null;
+    let res = null;
+    const buildResult = () => ({
+      content,
+      toolCalls: [...toolCallsByIndex.values()],
+      requestId: res?.headers.get("x-codai-trace-id") ?? res?.headers.get("x-request-id") ?? null,
+      routedTo: res?.headers.get("x-codai-routed-to") ?? null,
+      execVerify: res?.headers.get("x-codai-exec-verify") ?? null,
+      usage,
+      finishReason,
+      headers: res?.headers ?? null
+    });
+    async function* chunks() {
+      try {
+        res = await requestPromise;
+        for await (const frame of readSse(res, opts.signal)) {
+          if (frame.data === "[DONE]") break;
+          const chunk = frameJson(frame);
+          if (!chunk) continue;
+          if (chunk.usage) usage = toUsage(chunk.usage);
+          const choice = chunk.choices?.[0];
+          if (choice?.finish_reason) finishReason = choice.finish_reason;
+          const delta = choice?.delta;
+          if (delta?.tool_calls) {
+            for (const tc of delta.tool_calls) {
+              mergeToolCall(toolCallsByIndex, typeof tc.index === "number" ? tc.index : 0, tc);
+            }
           }
+          if (delta?.content) content += delta.content;
+          yield chunk;
         }
+        resolveFinal(buildResult());
+      } catch (err) {
+        rejectFinal(err);
+        throw err;
       }
     }
-  }
-  // -------------------------------------------------------------- agents
-  agents = {
-    run: async (opts) => {
-      const res = await this.request(
-        "/v1/agents/run",
-        {
-          task: opts.task,
-          ...opts.context ? { context: opts.context } : {},
-          ...opts.system ? { system: opts.system } : {},
-          ...opts.model ? { model: opts.model } : {}
-        },
-        { signal: opts.signal }
-      );
-      const body = await res.json();
-      return {
-        result: String(body.result ?? ""),
-        model: String(body.model ?? ""),
-        eventId: body.event_id ?? null,
-        usage: body.usage ?? null
-      };
+    async function* text() {
+      for await (const chunk of chunks()) {
+        const delta = chunk.choices?.[0]?.delta?.content;
+        if (delta) yield delta;
+      }
     }
-  };
-  // ------------------------------------------------------------ feedback
-  /** Rate a completed request: +1 (helpful) or -1 (not helpful). */
-  async feedback(requestId, rating, comment) {
-    await this.request("/v1/feedback", {
-      event_id: requestId,
-      rating,
-      ...comment ? { comment } : {}
-    });
-  }
-  // -------------------------------------------------------------- models
-  async models() {
-    const res = await this.request("/v1/models", null, { method: "GET" });
-    const body = await res.json();
-    return body.data ?? [];
+    return {
+      [Symbol.asyncIterator]: () => text(),
+      chunks: () => ({ [Symbol.asyncIterator]: () => chunks() }),
+      final
+    };
+  }
+};
+var Chat = class {
+  completions;
+  constructor(http) {
+    this.completions = new ChatCompletions(http);
+  }
+};
+
+// src/resources/devices.ts
+var Devices = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** `GET /v1/devices` — most recently seen first. */
+  async list(opts = {}) {
+    const raw = await this.http.json("/v1/devices", {
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    return [...raw.devices ?? []];
+  }
+  /** `PATCH /v1/devices/{id}` — push token and/or capabilities. */
+  update(id, body, opts = {}) {
+    return this.http.json(`/v1/devices/${encodeURIComponent(id)}`, {
+      method: "PATCH",
+      body,
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+  /** `DELETE /v1/devices/{id}` */
+  delete(id, opts = {}) {
+    return this.http.json(`/v1/devices/${encodeURIComponent(id)}`, {
+      method: "DELETE",
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+  /**
+   * `GET /v1/devices/me/dispatch?limit=` — pending controls dispatched at the
+   * calling device (`x-codai-device` required) across all owned sessions.
+   */
+  dispatchInbox(query = {}, opts = {}) {
+    return this.http.json("/v1/devices/me/dispatch", {
+      query: { limit: query.limit },
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+};
+
+// src/resources/embeddings.ts
+var Embeddings = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  async create(body, opts = {}) {
+    const res = await this.http.request("/v1/embeddings", {
+      body: { ...body, model: body.model ?? "codai-embed" },
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    const raw = await res.json();
+    return {
+      embeddings: (raw.data ?? []).map((d) => [...d.embedding]),
+      raw,
+      routedTo: res.headers.get("x-codai-routed-to"),
+      fallback: res.headers.get("x-codai-embed-fallback"),
+      headers: res.headers
+    };
+  }
+};
+
+// src/resources/health.ts
+var Health = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Liveness probe. */
+  get(opts = {}) {
+    return this.http.json("/health", { signal: opts.signal, noRetry: true });
   }
-  // -------------------------------------------------------------- tokens
   /**
-   * Mint a short-lived scoped token (60–3600s) for browser/webview clients.
-   * The token authenticates only its scope's surface; chat is not mintable.
+   * Deep readiness probe. A 503 is returned as `{ ok: false, ... }` rather
+   * than thrown, so callers can read the failing check.
    */
-  async mintToken(scope, ttlSeconds) {
-    const res = await this.request("/v1/tokens", {
-      scope,
-      ...ttlSeconds !== void 0 ? { ttl_seconds: ttlSeconds } : {}
+  async ready(opts = {}) {
+    const res = await this.http.request("/health/ready", {
+      signal: opts.signal,
+      noRetry: true,
+      acceptStatus: [503]
     });
     const body = await res.json();
-    return { token: body.token, expiresAt: body.expires_at, scope: body.scope };
+    return { ...body, httpStatus: res.status };
   }
-  // ---------------------------------------------------------- embeddings
-  async embeddings(opts) {
-    const res = await this.request(
-      "/v1/embeddings",
-      {
-        model: opts.model ?? "codai-embed",
-        input: opts.input,
-        ...opts.dimensions !== void 0 ? { dimensions: opts.dimensions } : {}
+  /** Registry snapshot (aliases + provider health). */
+  status(opts = {}) {
+    return this.http.json("/status", { signal: opts.signal, noRetry: true });
+  }
+};
+
+// src/resources/hosts.ts
+var Hosts = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** `GET /v1/hosts` — your devices currently connected as hosts. */
+  async list(opts = {}) {
+    const raw = await this.http.json("/v1/hosts", {
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    return [...raw.hosts ?? []];
+  }
+  /**
+   * `POST /v1/hosts/{deviceId}/exec` — run one op on a connected host and
+   * block until it answers (or `timeout_ms`, default 60 s).
+   */
+  exec(deviceId, op, args = {}, extra = {}) {
+    const body = {
+      op,
+      args,
+      ...extra.timeoutMs !== void 0 ? { timeout_ms: extra.timeoutMs } : {},
+      ...extra.label !== void 0 ? { label: extra.label } : {}
+    };
+    return this.http.json(`/v1/hosts/${encodeURIComponent(deviceId)}/exec`, {
+      body,
+      ext: extra.ext,
+      signal: extra.signal,
+      // The gateway itself waits up to timeout_ms + 2 s; give the HTTP layer headroom.
+      timeoutMs: (extra.timeoutMs ?? 6e4) + 1e4,
+      noRetry: true
+    });
+  }
+  /** `POST /v1/hosts/exec/{reqId}/result` — host side: deliver an exec result. */
+  postResult(reqId, body, opts = {}) {
+    return this.http.json(
+      `/v1/hosts/exec/${encodeURIComponent(reqId)}/result`,
+      { body, ext: opts.ext, signal: opts.signal }
+    );
+  }
+  /**
+   * `GET /v1/hosts/stream?os=&hostname=&roots=` — host side: announce this
+   * device and receive `hello` / `ping` / `exec` events. Closed by the server
+   * after 6 h; reconnect to re-announce presence.
+   */
+  async *stream(query = {}, opts = {}) {
+    const frames = this.http.sse("/v1/hosts/stream", {
+      query: {
+        os: query.os,
+        hostname: query.hostname,
+        roots: query.roots?.length ? query.roots.join(",") : void 0
       },
-      { signal: opts.signal }
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    for await (const frame of frames) {
+      const data = frameJson(frame);
+      if (!data) continue;
+      yield { event: frame.event, data };
+    }
+  }
+};
+
+// src/resources/messages.ts
+var Messages = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  async create(body, opts = {}) {
+    const res = await this.http.request("/v1/messages", {
+      body: { ...body, model: body.model ?? "codai", stream: false },
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    const raw = await res.json();
+    const text = (raw.content ?? []).map((b) => b.type === "text" && typeof b.text === "string" ? b.text : "").join("");
+    return {
+      text,
+      raw,
+      requestId: res.headers.get("x-codai-trace-id") ?? res.headers.get("x-request-id"),
+      routedTo: res.headers.get("x-codai-routed-to"),
+      headers: res.headers
+    };
+  }
+  stream(body, opts = {}) {
+    const requestPromise = this.http.request("/v1/messages", {
+      body: { ...body, model: body.model ?? "codai", stream: true },
+      ext: opts.ext,
+      signal: opts.signal,
+      timeoutMs: 0,
+      noRetry: true
+    });
+    let resolveFinal;
+    let rejectFinal;
+    const final = new Promise((resolve, reject) => {
+      resolveFinal = resolve;
+      rejectFinal = reject;
+    });
+    final.catch(() => {
+    });
+    let text = "";
+    let stopReason = null;
+    let inputTokens = null;
+    let outputTokens = null;
+    let res = null;
+    async function* events() {
+      try {
+        res = await requestPromise;
+        for await (const frame of readSse(res, opts.signal)) {
+          const ev = frameJson(frame);
+          if (!ev) continue;
+          if (typeof ev.type !== "string") ev.type = frame.event;
+          if (ev.type === "message_start") {
+            const usage = ev.message?.usage;
+            if (usage?.input_tokens !== void 0) inputTokens = usage.input_tokens;
+          } else if (ev.type === "content_block_delta") {
+            const delta = ev.delta;
+            if (delta?.type === "text_delta" && typeof delta.text === "string") text += delta.text;
+          } else if (ev.type === "message_delta") {
+            const delta = ev.delta;
+            if (delta?.stop_reason) stopReason = delta.stop_reason;
+            const usage = ev.usage;
+            if (usage?.output_tokens !== void 0) outputTokens = usage.output_tokens;
+          }
+          yield ev;
+          if (ev.type === "message_stop") break;
+        }
+        resolveFinal({
+          text,
+          stopReason,
+          usage: inputTokens !== null || outputTokens !== null ? { inputTokens: inputTokens ?? 0, outputTokens: outputTokens ?? 0 } : null,
+          requestId: res.headers.get("x-codai-trace-id") ?? res.headers.get("x-request-id") ?? null,
+          routedTo: res.headers.get("x-codai-routed-to"),
+          headers: res.headers
+        });
+      } catch (err) {
+        rejectFinal(err);
+        throw err;
+      }
+    }
+    async function* textOnly() {
+      for await (const ev of events()) {
+        if (ev.type !== "content_block_delta") continue;
+        const delta = ev.delta;
+        if (delta?.type === "text_delta" && delta.text) yield delta.text;
+      }
+    }
+    return {
+      [Symbol.asyncIterator]: () => events(),
+      text: () => ({ [Symbol.asyncIterator]: () => textOnly() }),
+      final
+    };
+  }
+};
+
+// src/resources/models.ts
+var Models = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Every model the calling key may address (OpenAI list shape, `data[]`). */
+  async list(opts = {}) {
+    const raw = await this.http.json("/v1/models", {
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    return [...raw.data ?? []];
+  }
+};
+
+// src/resources/orgs.ts
+var OrgMembers = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** `GET /v1/orgs/{id}/members` */
+  async list(orgId, opts = {}) {
+    const raw = await this.http.json(
+      `/v1/orgs/${encodeURIComponent(orgId)}/members`,
+      { ext: opts.ext, signal: opts.signal }
     );
-    const body = await res.json();
-    return { embeddings: (body.data ?? []).map((d) => d.embedding), raw: body };
-  }
-  // --------------------------------------------------------------- audio
-  audio = {
-    /** Speech-to-text (multipart upload, max 25 MB). Returns the transcript. */
-    transcribe: async (opts) => {
-      const form = new FormData();
-      const blob = opts.file instanceof Blob ? opts.file : new Blob([opts.file]);
-      form.append("file", blob, opts.filename ?? "audio.webm");
-      form.append("model", opts.model ?? "codai-transcribe");
-      const res = await fetch(`${this.baseUrl}/v1/audio/transcriptions`, {
-        method: "POST",
-        headers: { Authorization: `Bearer ${this.apiKey}` },
-        body: form,
-        signal: opts.signal ?? AbortSignal.timeout(this.timeoutMs)
-      });
-      if (!res.ok) {
-        let errBody = null;
-        try {
-          errBody = await res.json();
-        } catch {
+    return [...raw.members ?? []];
+  }
+  /** `POST /v1/orgs/{id}/members` — add or re-role (owner/admin). */
+  add(orgId, body, opts = {}) {
+    return this.http.json(
+      `/v1/orgs/${encodeURIComponent(orgId)}/members`,
+      { body, ext: opts.ext, signal: opts.signal }
+    );
+  }
+  /** `DELETE /v1/orgs/{id}/members/{userId}` */
+  remove(orgId, userId, opts = {}) {
+    return this.http.json(
+      `/v1/orgs/${encodeURIComponent(orgId)}/members/${encodeURIComponent(userId)}`,
+      { method: "DELETE", ext: opts.ext, signal: opts.signal }
+    );
+  }
+};
+var Orgs = class {
+  constructor(http) {
+    this.http = http;
+    this.members = new OrgMembers(http);
+  }
+  http;
+  members;
+  /** `POST /v1/orgs` */
+  create(name, opts = {}) {
+    return this.http.json("/v1/orgs", { body: { name }, ext: opts.ext, signal: opts.signal });
+  }
+  /** `GET /v1/orgs` */
+  async list(opts = {}) {
+    const raw = await this.http.json("/v1/orgs", {
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    return [...raw.orgs ?? []];
+  }
+};
+
+// src/resources/responses.ts
+var Responses = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  async create(body, opts = {}) {
+    const res = await this.http.request("/v1/responses", {
+      body: { ...body, model: body.model ?? "codai", stream: false },
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    const raw = await res.json();
+    return {
+      outputText: typeof raw.output_text === "string" ? raw.output_text : "",
+      raw,
+      requestId: res.headers.get("x-codai-trace-id") ?? res.headers.get("x-request-id"),
+      routedTo: res.headers.get("x-codai-routed-to"),
+      headers: res.headers
+    };
+  }
+  stream(body, opts = {}) {
+    const requestPromise = this.http.request("/v1/responses", {
+      body: { ...body, model: body.model ?? "codai", stream: true },
+      ext: opts.ext,
+      signal: opts.signal,
+      timeoutMs: 0,
+      noRetry: true
+    });
+    let resolveFinal;
+    let rejectFinal;
+    const final = new Promise((resolve, reject) => {
+      resolveFinal = resolve;
+      rejectFinal = reject;
+    });
+    final.catch(() => {
+    });
+    let outputText = "";
+    let response = null;
+    let res = null;
+    async function* events() {
+      try {
+        res = await requestPromise;
+        for await (const frame of readSse(res, opts.signal)) {
+          const ev = frameJson(frame);
+          if (!ev) continue;
+          if (typeof ev.type !== "string") ev.type = frame.event;
+          if (ev.type === "response.output_text.delta" && typeof ev.delta === "string") {
+            outputText += ev.delta;
+          } else if (ev.type === "response.completed" && ev.response) {
+            response = ev.response;
+          }
+          yield ev;
+          if (ev.type === "response.completed") break;
         }
-        throw new CodaiError(`codai /v1/audio/transcriptions \u2192 ${res.status}`, res.status, errBody);
+        resolveFinal({
+          outputText,
+          response,
+          requestId: res.headers.get("x-codai-trace-id") ?? res.headers.get("x-request-id") ?? null,
+          routedTo: res.headers.get("x-codai-routed-to"),
+          headers: res.headers
+        });
+      } catch (err) {
+        rejectFinal(err);
+        throw err;
+      }
+    }
+    async function* textOnly() {
+      for await (const ev of events()) {
+        if (ev.type === "response.output_text.delta" && typeof ev.delta === "string")
+          yield ev.delta;
       }
-      const body = await res.json();
-      return body.text ?? "";
-    },
-    /** Text-to-speech. Returns the audio bytes (default mp3). */
-    speech: async (opts) => {
-      const res = await this.request(
-        "/v1/audio/speech",
-        {
-          model: opts.model ?? "codai-tts",
-          input: opts.input,
-          voice: opts.voice ?? "alloy"
-        },
-        { signal: opts.signal }
-      );
-      return res.arrayBuffer();
     }
-  };
-  // ------------------------------------------------------------ internal
-  chatBody(opts, stream) {
+    return {
+      [Symbol.asyncIterator]: () => events(),
+      text: () => ({ [Symbol.asyncIterator]: () => textOnly() }),
+      final
+    };
+  }
+};
+
+// src/resources/sessions.ts
+var enc = encodeURIComponent;
+var SessionLease = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** `POST /v1/sessions/{id}/lease` — CAS claim; `force: true` takes over a live lease. */
+  acquire(sessionId, body = {}, opts = {}) {
+    return this.http.json(`/v1/sessions/${enc(sessionId)}/lease`, {
+      method: "POST",
+      body,
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+  /** `PUT /v1/sessions/{id}/lease` — heartbeat every 10 s (TTL 30 s). */
+  renew(sessionId, opts = {}) {
+    return this.http.json(`/v1/sessions/${enc(sessionId)}/lease`, {
+      method: "PUT",
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+  /** `DELETE /v1/sessions/{id}/lease` */
+  release(sessionId, opts = {}) {
+    return this.http.json(`/v1/sessions/${enc(sessionId)}/lease`, {
+      method: "DELETE",
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+};
+var SessionEvents = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** `GET /v1/sessions/{id}/events?after=&limit=` */
+  list(sessionId, query = {}, opts = {}) {
+    return this.http.json(`/v1/sessions/${enc(sessionId)}/events`, {
+      query: { after: query.after, limit: query.limit },
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+  /** `POST /v1/sessions/{id}/events` — executor only (needs the live lease). */
+  append(sessionId, body, opts = {}) {
+    return this.http.json(`/v1/sessions/${enc(sessionId)}/events`, {
+      body,
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+};
+var SessionControls = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** `GET /v1/sessions/{id}/controls?applied=&target=` — drain the control queue. */
+  async list(sessionId, query = {}, opts = {}) {
+    const raw = await this.http.json(
+      `/v1/sessions/${enc(sessionId)}/controls`,
+      {
+        query: { applied: query.applied, target: query.target },
+        ext: opts.ext,
+        signal: opts.signal
+      }
+    );
+    return [...raw.controls ?? []];
+  }
+  /** `POST /v1/sessions/{id}/control` — send a control to the executor (editor+). */
+  submit(sessionId, body, opts = {}) {
+    return this.http.json(`/v1/sessions/${enc(sessionId)}/control`, {
+      body,
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+  /** `POST /v1/sessions/{id}/control/{cid}/applied` — executor only. */
+  markApplied(sessionId, controlId, opts = {}) {
+    return this.http.json(
+      `/v1/sessions/${enc(sessionId)}/control/${enc(controlId)}/applied`,
+      { method: "POST", ext: opts.ext, signal: opts.signal }
+    );
+  }
+};
+var SessionShares = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** `GET /v1/sessions/{id}/shares` — owner only. */
+  async list(sessionId, opts = {}) {
+    const raw = await this.http.json(
+      `/v1/sessions/${enc(sessionId)}/shares`,
+      { ext: opts.ext, signal: opts.signal }
+    );
+    return [...raw.shares ?? []];
+  }
+  /** `POST /v1/sessions/{id}/shares` — `token` is returned once for link shares. */
+  create(sessionId, body, opts = {}) {
+    return this.http.json(`/v1/sessions/${enc(sessionId)}/shares`, {
+      body,
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+  /** `DELETE /v1/sessions/{id}/shares/{shareId}` */
+  delete(sessionId, shareId, opts = {}) {
+    return this.http.json(
+      `/v1/sessions/${enc(sessionId)}/shares/${enc(shareId)}`,
+      { method: "DELETE", ext: opts.ext, signal: opts.signal }
+    );
+  }
+  /** `GET /v1/sessions/shared-with-me` */
+  async sharedWithMe(query = {}, opts = {}) {
+    const raw = await this.http.json(
+      "/v1/sessions/shared-with-me",
+      {
+        query: { archived: query.archived ? "1" : void 0 },
+        ext: opts.ext,
+        signal: opts.signal
+      }
+    );
+    return [...raw.sessions ?? []];
+  }
+};
+var Sessions = class {
+  constructor(http) {
+    this.http = http;
+    this.events = new SessionEvents(http);
+    this.controls = new SessionControls(http);
+    this.lease = new SessionLease(http);
+    this.shares = new SessionShares(http);
+  }
+  http;
+  events;
+  controls;
+  lease;
+  shares;
+  /** `POST /v1/sessions` — idempotent on `session_key` (200 existing / 201 created). */
+  async create(body = {}, opts = {}) {
+    const res = await this.http.request("/v1/sessions", {
+      body,
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    const session = await res.json();
+    return { ...session, created: res.status === 201 };
+  }
+  /** `GET /v1/sessions?limit=&archived=` — own sessions first, then shared. */
+  async list(query = {}, opts = {}) {
+    const raw = await this.http.json("/v1/sessions", {
+      query: { limit: query.limit, archived: query.archived ? "1" : void 0, v: "2" },
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    return [...raw.sessions ?? []];
+  }
+  /** `GET /v1/sessions/{id}` — detail with members, lease and presence. */
+  get(sessionId, query = {}, opts = {}) {
+    return this.http.json(`/v1/sessions/${enc(sessionId)}`, {
+      query: { share: query.share, v: "2" },
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+  /** `PATCH /v1/sessions/{id}` — rename / archive (owner). */
+  update(sessionId, body, opts = {}) {
+    return this.http.json(`/v1/sessions/${enc(sessionId)}`, {
+      method: "PATCH",
+      body,
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+  /** `DELETE /v1/sessions/{id}` — irreversible (owner). */
+  delete(sessionId, opts = {}) {
+    return this.http.json(`/v1/sessions/${enc(sessionId)}`, {
+      method: "DELETE",
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+  /** `POST /v1/sessions/{id}/dispatch` — queue a `send` for one device and wake it over FCM. */
+  dispatch(sessionId, body, opts = {}) {
+    return this.http.json(`/v1/sessions/${enc(sessionId)}/dispatch`, {
+      body,
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+  /**
+   * `GET /v1/sessions/{id}/stream?after=` — live SSE of `event` / `control` /
+   * `lease` / `presence` frames. `: ping` heartbeats are skipped. The server
+   * closes after 30 min; reconnect with `after` = highest `seq` seen.
+   */
+  async *stream(sessionId, query = {}, opts = {}) {
+    const frames = this.http.sse(`/v1/sessions/${enc(sessionId)}/stream`, {
+      query: { after: query.after, share: query.share },
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    for await (const frame of frames) {
+      const data = frameJson(frame);
+      if (!data) continue;
+      yield { event: frame.event, data };
+    }
+  }
+};
+
+// src/resources/tasks.ts
+var Tasks = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** `GET /v1/tasks` — newest first; page with `cursor` = previous `next_cursor`. */
+  list(query = {}, opts = {}) {
+    return this.http.json("/v1/tasks", {
+      query: { outcome: query.outcome, limit: query.limit, cursor: query.cursor },
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+  /** `GET /v1/tasks/pending` — tasks awaiting your confirmation (max 100). */
+  async pending(opts = {}) {
+    const raw = await this.http.json("/v1/tasks/pending", {
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    return [...raw.tasks ?? []];
+  }
+  /** `GET /v1/tasks/stats?since=` */
+  stats(since, opts = {}) {
+    return this.http.json("/v1/tasks/stats", {
+      query: { since: since instanceof Date ? since.toISOString() : since },
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+  /** `GET /v1/tasks/{id}` */
+  get(id, opts = {}) {
+    return this.http.json(`/v1/tasks/${encodeURIComponent(id)}`, {
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+  /** `POST /v1/tasks/{id}/confirm` — answer "Did codai solve it?". */
+  confirm(id, body, opts = {}) {
+    return this.http.json(`/v1/tasks/${encodeURIComponent(id)}/confirm`, {
+      body,
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+};
+
+// src/resources/tokens.ts
+var Tokens = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * Mint a short-lived token (60–3600 s, default 600) bound to one surface.
+   * Only a real `codai_` key may mint.
+   */
+  async create(scope, ttlSeconds, opts = {}) {
+    const raw = await this.http.json("/v1/tokens", {
+      body: { scope, ...ttlSeconds !== void 0 ? { ttl_seconds: ttlSeconds } : {} },
+      ext: opts.ext,
+      signal: opts.signal
+    });
+    return { token: raw.token, expiresAt: raw.expires_at, scope: raw.scope, raw };
+  }
+};
+
+// src/resources/tools.ts
+var Tools = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** `POST /v1/tools/search` — verified web search (never falls back to an unverified provider). */
+  search(body, opts = {}) {
+    return this.http.json("/v1/tools/search", {
+      body,
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+  /** `POST /v1/tools/fetch` — fetch + extract a public page (SSRF-guarded). */
+  fetch(body, opts = {}) {
+    return this.http.json("/v1/tools/fetch", {
+      body,
+      ext: opts.ext,
+      signal: opts.signal
+    });
+  }
+};
+
+// src/operations.ts
+var OPERATION_METHODS = {
+  // Chat & Completions
+  createChatCompletion: "chat.completions.create",
+  createResponse: "responses.create",
+  createMessage: "messages.create",
+  // Embeddings & Audio
+  createEmbeddings: "embeddings.create",
+  createTranscription: "audio.transcribe",
+  createSpeech: "audio.speech",
+  createEphemeralToken: "tokens.create",
+  // Models
+  listModels: "models.list",
+  // Health
+  getHealth: "health.get",
+  getHealthReady: "health.ready",
+  getStatus: "health.status",
+  // Agents
+  runAgentSync: "agents.run",
+  createAgentRun: "agents.runs.create",
+  getAgentRunStats: "agents.runs.stats",
+  getAgentRun: "agents.runs.get",
+  listAgentRunSteps: "agents.runs.steps",
+  streamAgentRun: "agents.runs.stream",
+  cancelAgentRun: "agents.runs.cancel",
+  // Tools
+  toolsSearch: "tools.search",
+  toolsFetch: "tools.fetch",
+  // Tasks
+  listTasks: "tasks.list",
+  listPendingTasks: "tasks.pending",
+  getTaskStats: "tasks.stats",
+  getTask: "tasks.get",
+  confirmTask: "tasks.confirm",
+  // Sessions
+  createSession: "sessions.create",
+  listSessions: "sessions.list",
+  getSession: "sessions.get",
+  updateSession: "sessions.update",
+  deleteSession: "sessions.delete",
+  listSessionEvents: "sessions.events.list",
+  appendSessionEvents: "sessions.events.append",
+  listSessionControls: "sessions.controls.list",
+  submitSessionControl: "sessions.controls.submit",
+  markSessionControlApplied: "sessions.controls.markApplied",
+  dispatchToDevice: "sessions.dispatch",
+  claimSessionLease: "sessions.lease.acquire",
+  heartbeatSessionLease: "sessions.lease.renew",
+  releaseSessionLease: "sessions.lease.release",
+  streamSession: "sessions.stream",
+  // Devices
+  getMyDispatchInbox: "devices.dispatchInbox",
+  listDevices: "devices.list",
+  updateDevice: "devices.update",
+  deleteDevice: "devices.delete",
+  // Hosts
+  listHosts: "hosts.list",
+  streamHost: "hosts.stream",
+  execOnHost: "hosts.exec",
+  postHostExecResult: "hosts.postResult",
+  // Orgs & Sharing
+  listSessionsSharedWithMe: "sessions.shares.sharedWithMe",
+  listSessionShares: "sessions.shares.list",
+  createSessionShare: "sessions.shares.create",
+  deleteSessionShare: "sessions.shares.delete",
+  createOrg: "orgs.create",
+  listOrgs: "orgs.list",
+  listOrgMembers: "orgs.members.list",
+  addOrgMember: "orgs.members.add",
+  removeOrgMember: "orgs.members.remove",
+  // Account
+  getAccount: "account.get",
+  patchAccount: "account.update",
+  getReceipt: "receipt.get",
+  submitFeedback: "feedback.submit",
+  listPhoneModels: "phoneModels.list"
+};
+var STREAMING_OPERATIONS = /* @__PURE__ */ new Set([
+  "streamAgentRun",
+  "streamSession",
+  "streamHost"
+]);
+
+// src/index.ts
+var Codai = class {
+  http;
+  /** Resource group (`chat.completions.create/stream`) that is also callable with the 0.2.x `chat({ messages })` shape. */
+  chat;
+  messages;
+  responses;
+  embeddings;
+  audio;
+  tokens;
+  models;
+  health;
+  agents;
+  tools;
+  tasks;
+  sessions;
+  devices;
+  hosts;
+  orgs;
+  account;
+  receipt;
+  feedback;
+  phoneModels;
+  constructor(opts) {
+    if (!opts.apiKey) throw new Error("Codai: apiKey is required");
+    this.http = new HttpClient({
+      apiKey: opts.apiKey,
+      baseUrl: opts.baseUrl ?? "https://ai.codai.ro",
+      timeoutMs: opts.timeoutMs ?? 12e4,
+      maxRetries: opts.maxRetries ?? 2,
+      fetch: opts.fetch,
+      defaults: {
+        ...opts.defaults,
+        ...opts.sessionId ? { sessionId: opts.sessionId } : {},
+        ...opts.device ? { device: opts.device } : {},
+        ...opts.deviceName ? { deviceName: opts.deviceName } : {},
+        ...opts.devicePlatform ? { devicePlatform: opts.devicePlatform } : {},
+        ...opts.client ? { client: opts.client } : {}
+      }
+    });
+    const http = this.http;
+    this.messages = new Messages(http);
+    this.responses = new Responses(http);
+    this.audio = new Audio(http);
+    this.tokens = new Tokens(http);
+    this.health = new Health(http);
+    this.agents = new Agents(http);
+    this.tools = new Tools(http);
+    this.tasks = new Tasks(http);
+    this.sessions = new Sessions(http);
+    this.devices = new Devices(http);
+    this.hosts = new Hosts(http);
+    this.orgs = new Orgs(http);
+    this.account = new Account(http);
+    this.receipt = new Receipts(http);
+    this.phoneModels = new PhoneModels(http);
+    this.chat = callable(
+      new Chat(http),
+      (o) => this.chat.completions.create(this.legacyBody(o), {
+        ext: this.legacyExt(o),
+        signal: o.signal
+      })
+    );
+    this.embeddings = callable(new Embeddings(http), async (o) => {
+      const r = await this.embeddings.create(
+        { input: o.input, model: o.model, dimensions: o.dimensions },
+        { signal: o.signal }
+      );
+      return { embeddings: r.embeddings, raw: r.raw };
+    });
+    this.models = callable(
+      new Models(http),
+      async () => (await this.models.list()).map((m) => ({ id: m.id }))
+    );
+    this.feedback = callable(
+      new Feedback(http),
+      async (requestId, rating, comment) => {
+        await this.feedback.submit({
+          event_id: requestId,
+          rating,
+          ...comment ? { comment } : {}
+        });
+      }
+    );
+  }
+  // ------------------------------------------------- 0.2.x compatibility aliases
+  /** Alias of `chat.completions.stream()` with the 0.2.x option names. */
+  chatStream(opts) {
+    return this.chat.completions.stream(this.legacyBody(opts), {
+      ext: this.legacyExt(opts),
+      signal: opts.signal
+    });
+  }
+  /** Alias of `tokens.create()`. */
+  mintToken(scope, ttlSeconds) {
+    return this.tokens.create(scope, ttlSeconds);
+  }
+  legacyBody(opts) {
     return {
       model: opts.model ?? "codai",
       messages: opts.messages,
-      stream,
       ...opts.temperature !== void 0 ? { temperature: opts.temperature } : {},
       ...opts.maxTokens !== void 0 ? { max_tokens: opts.maxTokens } : {},
       ...opts.tools ? { tools: opts.tools } : {}
     };
   }
-  chatHeaders(opts) {
-    const h = {};
-    const session = opts.sessionId ?? this.sessionId;
-    if (session) h["x-codai-session-id"] = session;
-    if (opts.agentMode) h["x-codai-mode"] = "agent";
-    if (opts.compact) h["x-codai-compact"] = opts.compact;
-    if (opts.bestOf !== void 0) h["x-codai-best-of"] = String(opts.bestOf);
-    if (opts.agentId) h["x-codai-agent-id"] = opts.agentId;
-    return h;
-  }
-  async request(path, body, init = {}) {
-    const url = `${this.baseUrl}${path}`;
-    let lastErr;
-    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
-      try {
-        const res = await fetch(url, {
-          method: init.method ?? "POST",
-          headers: {
-            Authorization: `Bearer ${this.apiKey}`,
-            ...body !== null ? { "Content-Type": "application/json" } : {},
-            ...init.headers
-          },
-          ...body !== null ? { body: JSON.stringify(body) } : {},
-          signal: init.signal ?? AbortSignal.timeout(this.timeoutMs)
-        });
-        if (res.ok) return res;
-        if (RETRYABLE.has(res.status) && attempt < this.maxRetries) {
-          await sleep(500 * 2 ** attempt + Math.random() * 250);
-          continue;
-        }
-        let errBody = null;
-        try {
-          errBody = await res.json();
-        } catch {
-        }
-        throw new CodaiError(`codai ${path} \u2192 ${res.status}`, res.status, errBody);
-      } catch (err) {
-        if (err instanceof CodaiError) throw err;
-        lastErr = err;
-        if (attempt < this.maxRetries) {
-          await sleep(500 * 2 ** attempt);
-          continue;
-        }
-      }
-    }
-    throw new CodaiError(`codai ${path} failed after retries: ${String(lastErr)}`, 0, null);
+  legacyExt(opts) {
+    return {
+      ...opts.ext,
+      ...opts.sessionId ? { sessionId: opts.sessionId } : {},
+      ...opts.agentMode ? { mode: "agent" } : {},
+      ...opts.compact ? { compact: opts.compact } : {},
+      ...opts.bestOf !== void 0 ? { bestOf: opts.bestOf } : {},
+      ...opts.agentId ? { agentId: opts.agentId } : {}
+    };
   }
 };
-function sleep(ms) {
-  return new Promise((r) => setTimeout(r, ms));
+function callable(target, fn) {
+  const f = ((...args) => fn(...args));
+  for (const key of allKeys(target)) {
+    const value = target[key];
+    Object.defineProperty(f, key, {
+      value: typeof value === "function" ? value.bind(target) : value,
+      enumerable: true,
+      writable: false
+    });
+  }
+  return f;
+}
+function allKeys(obj) {
+  const keys = /* @__PURE__ */ new Set();
+  let cur = obj;
+  while (cur && cur !== Object.prototype) {
+    for (const k of Object.getOwnPropertyNames(cur)) if (k !== "constructor") keys.add(k);
+    cur = Object.getPrototypeOf(cur);
+  }
+  return [...keys];
 }
 var index_default = Codai;
 
-export { Codai, CodaiError, index_default as default };
+export { Account, AgentRuns, Agents, Audio, Chat, ChatCompletions, Codai, CodaiError, Devices, Embeddings, Feedback, Health, Hosts, HttpClient, Messages, Models, OPERATION_METHODS, OrgMembers, Orgs, PhoneModels, Receipts, Responses, STREAMING_OPERATIONS, SessionControls, SessionEvents, SessionLease, SessionShares, Sessions, Tasks, Tokens, Tools, index_default as default, extensionHeaders, frameJson, mergeToolCall, readSse };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map