@canarycoders/ai 0.3.0

package/dist/index.js

@@ -0,0 +1,1638 @@
+// src/compat.ts
+function v1(baseURL) {
+  return `${baseURL.replace(/\/+$/, "")}/v1`;
+}
+function openaiTarget(baseURL, apiKey) {
+  return { baseURL: v1(baseURL), apiKey };
+}
+function anthropicTarget(baseURL, apiKey) {
+  return { baseURL: v1(baseURL), apiKey };
+}
+
+// src/core/errors.ts
+var APIError = class extends Error {
+  status;
+  code;
+  requestId;
+  headers;
+  details;
+  raw;
+  constructor(message, init = {}) {
+    super(message);
+    this.name = new.target.name;
+    this.status = init.status;
+    this.code = init.code;
+    this.requestId = init.requestId;
+    this.headers = init.headers;
+    this.details = init.details;
+    this.raw = init.raw;
+  }
+};
+var BadRequestError = class extends APIError {
+  /** parsed Zod issues from the server, when present */
+  validationIssues;
+  constructor(message, init = {}) {
+    super(message, init);
+    this.validationIssues = extractIssues(init.details);
+  }
+};
+var AuthenticationError = class extends APIError {
+};
+var PermissionError = class extends APIError {
+};
+var NotFoundError = class extends APIError {
+};
+var ConflictError = class extends APIError {
+};
+var UnprocessableEntityError = class extends APIError {
+};
+var RateLimitError = class extends APIError {
+  /** remaining request budget; only sent by the server in development */
+  remaining;
+  retryAfterMs;
+  constructor(message, init = {}) {
+    super(message, init);
+    const d = init.details;
+    this.remaining = d?.remaining;
+    this.retryAfterMs = parseRetryAfter(init.headers?.get("retry-after"));
+  }
+};
+var InternalServerError = class extends APIError {
+};
+var APIConnectionError = class extends APIError {
+};
+var APIConnectionTimeoutError = class extends APIConnectionError {
+  phase;
+};
+function extractIssues(details) {
+  if (details && typeof details === "object" && "issues" in details) {
+    return details.issues;
+  }
+  if (Array.isArray(details)) return details;
+  return void 0;
+}
+function parseRetryAfter(value) {
+  if (!value) return void 0;
+  const secs = Number(value);
+  if (!Number.isNaN(secs)) return Math.max(0, secs * 1e3);
+  const date = Date.parse(value);
+  if (!Number.isNaN(date)) return Math.max(0, date - Date.now());
+  return void 0;
+}
+async function safeBody(response) {
+  const text = await response.text().catch(() => "");
+  if (!text) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+async function toAPIError(response) {
+  const body = await safeBody(response);
+  return buildError(response.status, body, response.headers);
+}
+function buildError(status, body, headers) {
+  const requestId = headers?.get("x-request-id") ?? headers?.get("x-canary-request-id") ?? void 0;
+  let message = `HTTP ${status ?? "error"}`;
+  let code;
+  let details;
+  if (body && typeof body === "object") {
+    const b = body;
+    if ("success" in b && typeof b.error === "string") {
+      message = b.error;
+      code = b.code;
+      details = b.details;
+    } else if (b.error && typeof b.error === "object" && typeof b.error.message === "string") {
+      const e = b.error;
+      message = e.message;
+      code = e.code ?? e.type;
+    } else if (b.type === "error" && b.error && typeof b.error.message === "string") {
+      const e = b.error;
+      message = e.message;
+      code = e.type;
+    } else if (typeof b.message === "string") {
+      message = b.message;
+      code = b.code;
+    }
+  } else if (typeof body === "string" && body) {
+    message = body;
+  }
+  return errorFromStatus(status, message, {
+    status,
+    code,
+    requestId,
+    headers,
+    details,
+    raw: body
+  });
+}
+function errorFromStatus(status, message, init) {
+  switch (true) {
+    case status === 400:
+      return new BadRequestError(message, init);
+    case status === 401:
+      return new AuthenticationError(message, init);
+    case status === 403:
+      return new PermissionError(message, init);
+    case status === 404:
+      return new NotFoundError(message, init);
+    case status === 409:
+      return new ConflictError(message, init);
+    case status === 422:
+      return new UnprocessableEntityError(message, init);
+    case status === 429:
+      return new RateLimitError(message, init);
+    case (typeof status === "number" && status >= 500):
+      return new InternalServerError(message, init);
+    default:
+      return new APIError(message, init);
+  }
+}
+function statusFromCode(code) {
+  if (typeof code === "number") return code;
+  switch (code) {
+    case "RATE_LIMIT_EXCEEDED":
+    case "RATE_LIMITED":
+      return 429;
+    case "INVALID_API_KEY":
+    case "MISSING_API_KEY":
+    case "EXPIRED_KEY":
+    case "INACTIVE_KEY":
+      return 401;
+    case "INSUFFICIENT_PERMISSIONS":
+    case "ADMIN_REQUIRED":
+      return 403;
+    case "VALIDATION_ERROR":
+      return 400;
+    case "NOT_FOUND":
+    case "TASK_NOT_FOUND":
+      return 404;
+    default:
+      return void 0;
+  }
+}
+function streamError(data) {
+  if (data && typeof data === "object") {
+    const d = data;
+    if (typeof d.error === "string") {
+      return buildError(statusFromCode(d.code), {
+        success: false,
+        error: d.error,
+        code: d.code
+      });
+    }
+    if (d.error && typeof d.error === "object") {
+      const e = d.error;
+      return buildError(statusFromCode(e.code), data);
+    }
+  }
+  return new APIError("Stream error", { raw: data });
+}
+
+// src/core/fetch.ts
+function resolveFetch(custom) {
+  if (custom) return custom;
+  if (typeof globalThis.fetch === "function") {
+    return globalThis.fetch.bind(globalThis);
+  }
+  throw new Error(
+    "No global fetch found. Run on Node >= 18 or Bun, or pass a `fetch` implementation in the client options."
+  );
+}
+function detectRuntime() {
+  if (typeof globalThis.Bun !== "undefined") return "bun";
+  if (typeof process !== "undefined" && typeof process.versions?.node === "string") {
+    return "node";
+  }
+  return "unknown";
+}
+
+// src/core/retry.ts
+var DEFAULT_RETRY_POLICY = {
+  maxRetries: 2,
+  baseDelayMs: 500,
+  maxDelayMs: 8e3,
+  factor: 2
+};
+var RETRY_IDEMPOTENT = {
+  onStatus: true,
+  on429: true,
+  onConnect: true,
+  onTimeout: true
+};
+var RETRY_SUBMIT = {
+  onStatus: false,
+  on429: true,
+  onConnect: true,
+  onTimeout: false
+};
+var RETRY_NONE = {
+  onStatus: false,
+  on429: false,
+  onConnect: false,
+  onTimeout: false
+};
+function shouldRetry(err, flags) {
+  if (err instanceof RateLimitError) return flags.on429;
+  if (err instanceof APIConnectionTimeoutError) return flags.onTimeout;
+  if (err instanceof APIConnectionError) return flags.onConnect;
+  if (err instanceof APIError && typeof err.status === "number") {
+    return flags.onStatus && (err.status === 408 || err.status >= 500);
+  }
+  if (err instanceof TypeError) return flags.onConnect;
+  return false;
+}
+function backoffDelay(attempt, policy, retryAfterMs) {
+  if (retryAfterMs !== void 0) return retryAfterMs;
+  const ceiling = Math.min(
+    policy.maxDelayMs,
+    policy.baseDelayMs * Math.pow(policy.factor, attempt)
+  );
+  return Math.random() * ceiling;
+}
+
+// src/utils/sleep.ts
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        reject(signal.reason);
+      },
+      { once: true }
+    );
+  });
+}
+
+// src/core/http.ts
+var RETRY_FLAGS = {
+  idempotent: RETRY_IDEMPOTENT,
+  submit: RETRY_SUBMIT,
+  none: RETRY_NONE
+};
+var Transport = class {
+  baseURL;
+  timeoutMs;
+  maxRetries;
+  apiKey;
+  authStyle;
+  fetchImpl;
+  defaultHeaders;
+  defaultTag;
+  userAgent;
+  retryPolicy;
+  constructor(config) {
+    this.baseURL = config.baseURL.replace(/\/+$/, "");
+    this.apiKey = config.apiKey;
+    this.authStyle = config.authStyle;
+    this.timeoutMs = config.timeoutMs;
+    this.maxRetries = config.maxRetries;
+    this.fetchImpl = resolveFetch(config.fetch);
+    this.defaultHeaders = config.defaultHeaders ?? {};
+    this.defaultTag = config.defaultTag;
+    this.userAgent = config.userAgent ?? `canaryllm-sdk (${detectRuntime()})`;
+    this.retryPolicy = { ...DEFAULT_RETRY_POLICY, maxRetries: config.maxRetries };
+  }
+  async json(method, path, opts = {}) {
+    const res = await this.send(method, path, opts);
+    if (!res.ok) throw await toAPIError(res);
+    if (res.status === 204) return void 0;
+    const body = await res.json().catch(() => void 0);
+    return this.maybeUnwrap(body, opts.unwrap);
+  }
+  /** Perform the request and return the Response without throwing on non-2xx. */
+  async raw(method, path, opts = {}) {
+    return this.send(method, path, opts);
+  }
+  /** Perform the request and return the raw text body (CSV, YAML, …). */
+  async text(method, path, opts = {}) {
+    const res = await this.send(method, path, opts);
+    if (!res.ok) throw await toAPIError(res);
+    return res.text();
+  }
+  /** Open a streaming response. Throws if the initial response is an error. */
+  async stream(method, path, opts = {}) {
+    const res = await this.send(method, path, {
+      ...opts,
+      timeoutMs: opts.timeoutMs ?? 0
+    });
+    if (!res.ok) throw await toAPIError(res);
+    return res;
+  }
+  maybeUnwrap(body, unwrap) {
+    if (unwrap === false) return body;
+    if (body && typeof body === "object" && "success" in body && "data" in body) {
+      return body.data;
+    }
+    return body;
+  }
+  async send(method, path, opts) {
+    const url = this.buildUrl(path, opts.query);
+    const hasBody = opts.body !== void 0;
+    const isForm = hasBody && isFormData(opts.body);
+    const headers = this.buildHeaders(opts.headers, hasBody && !isForm);
+    const payload = !hasBody ? void 0 : isForm ? opts.body : JSON.stringify(this.withDefaultTag(opts.body));
+    const flags = RETRY_FLAGS[opts.retry ?? "idempotent"];
+    const timeoutMs = opts.timeoutMs ?? this.timeoutMs;
+    return this.withRetry(
+      () => this.execute(method, url, headers, payload, opts.signal, timeoutMs),
+      flags,
+      opts.signal
+    );
+  }
+  withDefaultTag(body) {
+    if (this.defaultTag && body && typeof body === "object" && !Array.isArray(body) && body.tag === void 0) {
+      return { ...body, tag: this.defaultTag };
+    }
+    return body;
+  }
+  async withRetry(fn, flags, signal) {
+    let attempt = 0;
+    for (; ; ) {
+      try {
+        const res = await fn();
+        if (!res.ok && attempt < this.maxRetries) {
+          const candidate = await toAPIError(res.clone());
+          if (shouldRetry(candidate, flags)) {
+            const retryAfter = candidate instanceof RateLimitError ? candidate.retryAfterMs : void 0;
+            await sleep(backoffDelay(attempt, this.retryPolicy, retryAfter), signal);
+            attempt++;
+            continue;
+          }
+        }
+        return res;
+      } catch (err) {
+        if (attempt < this.maxRetries && shouldRetry(err, flags)) {
+          await sleep(backoffDelay(attempt, this.retryPolicy), signal);
+          attempt++;
+          continue;
+        }
+        throw err;
+      }
+    }
+  }
+  async execute(method, url, headers, body, signal, timeoutMs) {
+    const { signal: composite, cleanup } = linkedSignal(signal, timeoutMs);
+    try {
+      return await this.fetchImpl(url, {
+        method,
+        headers,
+        body,
+        signal: composite
+      });
+    } catch (err) {
+      if (signal?.aborted) {
+        throw signal.reason ?? new APIConnectionError("Request aborted");
+      }
+      if (isTimeoutAbort(err)) {
+        const e = new APIConnectionTimeoutError("Request timed out");
+        e.phase = "total";
+        throw e;
+      }
+      if (err instanceof APIError) throw err;
+      throw new APIConnectionError(
+        err instanceof Error ? err.message : "Connection error"
+      );
+    } finally {
+      cleanup();
+    }
+  }
+  buildHeaders(extra, hasBody) {
+    const h = {
+      Accept: "application/json",
+      ...this.defaultHeaders,
+      ...extra ?? {}
+    };
+    if (hasBody && !("Content-Type" in h)) {
+      h["Content-Type"] = "application/json";
+    }
+    if (this.apiKey) {
+      if (this.authStyle === "x-api-key") h["X-API-Key"] = this.apiKey;
+      else h["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    if (!("User-Agent" in h)) h["User-Agent"] = this.userAgent;
+    return h;
+  }
+  buildUrl(path, query) {
+    let url = /^https?:\/\//.test(path) ? path : `${this.baseURL}${path.startsWith("/") ? "" : "/"}${path}`;
+    if (query) {
+      const qs = new URLSearchParams();
+      for (const [k, v] of Object.entries(query)) {
+        if (v !== void 0) qs.set(k, String(v));
+      }
+      const s = qs.toString();
+      if (s) url += (url.includes("?") ? "&" : "?") + s;
+    }
+    return url;
+  }
+};
+function isTimeoutAbort(err) {
+  return err instanceof Error && err.name === "TimeoutError";
+}
+function isFormData(v) {
+  return typeof FormData !== "undefined" && v instanceof FormData;
+}
+function linkedSignal(userSignal, timeoutMs) {
+  const controller = new AbortController();
+  const cleanups = [];
+  if (userSignal) {
+    if (userSignal.aborted) {
+      controller.abort(userSignal.reason);
+    } else {
+      const onAbort = () => controller.abort(userSignal.reason);
+      userSignal.addEventListener("abort", onAbort, { once: true });
+      cleanups.push(() => userSignal.removeEventListener("abort", onAbort));
+    }
+  }
+  if (timeoutMs && timeoutMs > 0) {
+    const timer = setTimeout(
+      () => controller.abort(new DOMException("Request timed out", "TimeoutError")),
+      timeoutMs
+    );
+    cleanups.push(() => clearTimeout(timer));
+  }
+  return {
+    signal: controller.signal,
+    cleanup: () => {
+      for (const c of cleanups) c();
+    }
+  };
+}
+
+// src/core/poller.ts
+var DEFAULT_MAX_WAIT_MS = {
+  completion: 35 * 6e4,
+  image: 6 * 6e4,
+  video: 65 * 6e4,
+  tts: 6 * 6e4,
+  stt: 12 * 6e4,
+  "sound-effect": 6 * 6e4,
+  music: 17 * 6e4,
+  dialogue: 6 * 6e4,
+  vision: 6 * 6e4,
+  embedding: 6 * 6e4
+};
+async function pollOnce(transport, queueId, signal) {
+  const res = await transport.raw("POST", "/api/llm/queue/result", {
+    body: { queueId },
+    signal,
+    retry: "idempotent"
+  });
+  if (res.status === 202) {
+    const body = await res.json().catch(() => ({}));
+    return {
+      kind: "processing",
+      status: body.data?.status ?? "processing",
+      position: body.data?.position
+    };
+  }
+  if (res.ok) {
+    const body = await res.json().catch(() => ({}));
+    return { kind: "completed", result: body.data?.result };
+  }
+  return { kind: "failed", error: await toAPIError(res) };
+}
+async function pollToResult(transport, queueId, taskKind, opts = {}) {
+  const initial = opts.initialIntervalMs ?? 500;
+  const factor = opts.backoffFactor ?? 1.5;
+  const maxInterval = opts.maxIntervalMs ?? 5e3;
+  const jitter = opts.jitter ?? 0.2;
+  const maxWait = opts.maxWaitMs ?? DEFAULT_MAX_WAIT_MS[taskKind];
+  const signal = opts.signal;
+  const start = Date.now();
+  const deadline = start + maxWait;
+  let interval = initial;
+  for (; ; ) {
+    signal?.throwIfAborted();
+    let outcome;
+    try {
+      outcome = await pollOnce(transport, queueId, signal);
+    } catch (err) {
+      if (signal?.aborted) throw err;
+      if (err instanceof APIConnectionError) {
+        outcome = { kind: "processing", status: "processing" };
+      } else {
+        throw err;
+      }
+    }
+    if (outcome.kind === "completed") return outcome.result;
+    if (outcome.kind === "failed") throw outcome.error;
+    opts.onPoll?.({
+      status: outcome.status,
+      position: outcome.position,
+      elapsedMs: Date.now() - start
+    });
+    const now = Date.now();
+    if (now >= deadline) {
+      const err = new APIConnectionTimeoutError(
+        `Queue task ${queueId} did not complete within ${maxWait}ms (last status: ${outcome.status})`
+      );
+      err.phase = "total";
+      throw err;
+    }
+    const base = Math.min(maxInterval, interval);
+    const jittered = base * (1 - jitter * Math.random());
+    const wait = Math.min(jittered, deadline - now);
+    await sleep(Math.max(0, wait), signal);
+    interval *= factor;
+  }
+}
+
+// src/core/sse.ts
+async function* iterateSSE(body, options = {}) {
+  const { signal, idleMs } = options;
+  const reader = body.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  let idleFired = false;
+  let userAborted = false;
+  const onAbort = () => {
+    userAborted = true;
+    void reader.cancel(signal?.reason).catch(() => {
+    });
+  };
+  if (signal) {
+    if (signal.aborted) {
+      reader.releaseLock();
+      throw signal.reason ?? new APIConnectionError("Stream aborted");
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+  }
+  try {
+    for (; ; ) {
+      let timer;
+      if (idleMs && idleMs > 0) {
+        timer = setTimeout(() => {
+          idleFired = true;
+          void reader.cancel().catch(() => {
+          });
+        }, idleMs);
+      }
+      let done = false;
+      let chunk;
+      try {
+        const r = await reader.read();
+        done = r.done;
+        chunk = r.value;
+      } finally {
+        if (timer) clearTimeout(timer);
+      }
+      if (done) break;
+      if (!chunk) continue;
+      buffer += decoder.decode(chunk, { stream: true });
+      buffer = buffer.replace(/\r\n/g, "\n");
+      let sep;
+      while ((sep = buffer.indexOf("\n\n")) !== -1) {
+        const rawFrame = buffer.slice(0, sep);
+        buffer = buffer.slice(sep + 2);
+        const frame = parseFrame(rawFrame);
+        if (frame) yield frame;
+      }
+    }
+    buffer += decoder.decode();
+    if (buffer.trim()) {
+      const frame = parseFrame(buffer);
+      if (frame) yield frame;
+    }
+  } finally {
+    if (signal) signal.removeEventListener("abort", onAbort);
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+  if (userAborted) {
+    throw signal?.reason ?? new APIConnectionError("Stream aborted");
+  }
+  if (idleFired) {
+    const err = new APIConnectionTimeoutError("Stream idle timeout");
+    err.phase = "read";
+    throw err;
+  }
+}
+function parseFrame(raw) {
+  let event;
+  let id;
+  const dataLines = [];
+  let sawData = false;
+  for (const line of raw.split("\n")) {
+    if (line === "") continue;
+    if (line.startsWith(":")) continue;
+    const idx = line.indexOf(":");
+    const field = idx === -1 ? line : line.slice(0, idx);
+    let value = idx === -1 ? "" : line.slice(idx + 1);
+    if (value.startsWith(" ")) value = value.slice(1);
+    if (field === "event") event = value;
+    else if (field === "id") id = value;
+    else if (field === "data") {
+      dataLines.push(value);
+      sawData = true;
+    }
+  }
+  if (!sawData && event === void 0) return null;
+  return { event, id, data: dataLines.join("\n") };
+}
+
+// src/core/stream-adapters.ts
+function tryParse(data) {
+  try {
+    return JSON.parse(data);
+  } catch {
+    return void 0;
+  }
+}
+function streamResponse(response, protocol, options = {}) {
+  if (!response.body) {
+    throw new APIError("Response has no body to stream", {
+      status: response.status
+    });
+  }
+  const frames = iterateSSE(response.body, options);
+  const includeRaw = options.includeRaw ?? false;
+  switch (protocol) {
+    case "openai":
+      return openAIAdapter(frames, includeRaw);
+    case "anthropic":
+      return anthropicAdapter(frames, includeRaw);
+    case "responses":
+      return responsesAdapter(frames, includeRaw);
+    case "native":
+    default:
+      return nativeQueueAdapter(frames, includeRaw);
+  }
+}
+async function* nativeQueueAdapter(frames, includeRaw) {
+  const raw = (v) => includeRaw ? v : void 0;
+  let lastUsage;
+  let lastFinish;
+  for await (const frame of frames) {
+    switch (frame.event) {
+      case "start":
+        yield { type: "start", raw: raw(frame.data) };
+        break;
+      case "error":
+        throw streamError(tryParse(frame.data));
+      case "done":
+        yield { type: "done", finishReason: lastFinish, usage: lastUsage };
+        return;
+      case "chunk": {
+        const chunk = tryParse(frame.data);
+        if (!chunk) break;
+        if (chunk.usage) {
+          lastUsage = chunk.usage;
+          yield { type: "usage", usage: chunk.usage, raw: raw(chunk) };
+        }
+        if (chunk.finishReason) lastFinish = chunk.finishReason;
+        if (chunk.toolCallDeltas) {
+          for (const d of chunk.toolCallDeltas) {
+            yield {
+              type: "tool_call",
+              index: d.index,
+              id: d.id,
+              name: d.function?.name,
+              argsDelta: d.function?.arguments,
+              raw: raw(d)
+            };
+          }
+        }
+        if (chunk.delta) {
+          const isThinking = Boolean(
+            chunk.metadata?.isThinking
+          );
+          yield isThinking ? { type: "thinking", delta: chunk.delta, raw: raw(chunk) } : { type: "text", delta: chunk.delta, raw: raw(chunk) };
+        }
+        break;
+      }
+    }
+  }
+  yield { type: "done", finishReason: lastFinish, usage: lastUsage };
+}
+async function* openAIAdapter(frames, includeRaw) {
+  const raw = (v) => includeRaw ? v : void 0;
+  let started = false;
+  let lastUsage;
+  let lastFinish;
+  for await (const frame of frames) {
+    const data = frame.data.trim();
+    if (data === "[DONE]") {
+      yield { type: "done", finishReason: lastFinish, usage: lastUsage };
+      return;
+    }
+    const chunk = tryParse(data);
+    if (!chunk) continue;
+    if (chunk.error) throw streamError(chunk);
+    if (!started) {
+      started = true;
+      yield { type: "start", raw: raw(chunk) };
+    }
+    const choice = chunk.choices?.[0];
+    if (choice) {
+      const delta = choice.delta ?? {};
+      if (delta.reasoning_content) {
+        yield { type: "thinking", delta: delta.reasoning_content, raw: raw(chunk) };
+      }
+      if (typeof delta.content === "string" && delta.content) {
+        yield { type: "text", delta: delta.content, raw: raw(chunk) };
+      }
+      if (Array.isArray(delta.tool_calls)) {
+        for (const tc of delta.tool_calls) {
+          yield {
+            type: "tool_call",
+            index: tc.index ?? 0,
+            id: tc.id,
+            name: tc.function?.name,
+            argsDelta: tc.function?.arguments,
+            raw: raw(tc)
+          };
+        }
+      }
+      if (choice.finish_reason) lastFinish = choice.finish_reason;
+    }
+    if (chunk.usage) {
+      lastUsage = mapOpenAIUsage(chunk.usage);
+      yield { type: "usage", usage: lastUsage, raw: raw(chunk) };
+    }
+  }
+  yield { type: "done", finishReason: lastFinish, usage: lastUsage };
+}
+async function* anthropicAdapter(frames, includeRaw) {
+  const raw = (v) => includeRaw ? v : void 0;
+  let lastUsage;
+  let lastFinish;
+  for await (const frame of frames) {
+    if (frame.event === "ping") continue;
+    const data = tryParse(frame.data);
+    if (frame.event === "error") {
+      throw streamError(data ?? { error: { message: "stream error" } });
+    }
+    switch (frame.event) {
+      case "message_start":
+        yield { type: "start", raw: raw(data) };
+        break;
+      case "content_block_start": {
+        const cb = data?.content_block;
+        if (cb?.type === "tool_use") {
+          yield {
+            type: "tool_call",
+            index: data?.index ?? 0,
+            id: cb.id,
+            name: cb.name,
+            raw: raw(data)
+          };
+        }
+        break;
+      }
+      case "content_block_delta": {
+        const d = data?.delta;
+        if (d?.type === "text_delta" && d.text) {
+          yield { type: "text", delta: d.text, raw: raw(data) };
+        } else if (d?.type === "thinking_delta" && d.thinking) {
+          yield { type: "thinking", delta: d.thinking, raw: raw(data) };
+        } else if (d?.type === "input_json_delta" && d.partial_json) {
+          yield {
+            type: "tool_call",
+            index: data?.index ?? 0,
+            argsDelta: d.partial_json,
+            raw: raw(data)
+          };
+        }
+        break;
+      }
+      case "message_delta":
+        if (data?.delta?.stop_reason) lastFinish = data.delta.stop_reason;
+        if (data?.usage) lastUsage = mapAnthropicUsage(data.usage);
+        break;
+      case "message_stop":
+        yield { type: "done", finishReason: lastFinish, usage: lastUsage };
+        return;
+    }
+  }
+  yield { type: "done", finishReason: lastFinish, usage: lastUsage };
+}
+async function* responsesAdapter(frames, includeRaw) {
+  const raw = (v) => includeRaw ? v : void 0;
+  let started = false;
+  let lastUsage;
+  for await (const frame of frames) {
+    const data = tryParse(frame.data);
+    if (frame.event === "error") throw streamError(data ?? {});
+    switch (frame.event) {
+      case "response.created":
+      case "response.in_progress":
+        if (!started) {
+          started = true;
+          yield { type: "start", raw: raw(data) };
+        }
+        break;
+      case "response.output_text.delta":
+        if (typeof data?.delta === "string") {
+          yield { type: "text", delta: data.delta, raw: raw(data) };
+        }
+        break;
+      case "response.reasoning_summary_text.delta":
+      case "response.reasoning_text.delta":
+        if (typeof data?.delta === "string") {
+          yield { type: "thinking", delta: data.delta, raw: raw(data) };
+        }
+        break;
+      case "response.function_call_arguments.delta":
+        yield {
+          type: "tool_call",
+          index: data?.output_index ?? 0,
+          argsDelta: typeof data?.delta === "string" ? data.delta : void 0,
+          raw: raw(data)
+        };
+        break;
+      case "response.completed":
+        if (data?.response?.usage) lastUsage = mapResponsesUsage(data.response.usage);
+        yield { type: "done", finishReason: "stop", usage: lastUsage };
+        return;
+      case "response.failed":
+        throw streamError(
+          data?.response?.error ? { error: data.response.error } : {}
+        );
+      default:
+        yield { type: "raw", event: frame.event, data };
+    }
+  }
+  yield { type: "done", usage: lastUsage };
+}
+function mapOpenAIUsage(u) {
+  const input = u.prompt_tokens ?? 0;
+  const output = u.completion_tokens ?? 0;
+  return {
+    inputTokens: input,
+    outputTokens: output,
+    totalTokens: u.total_tokens ?? input + output,
+    cachedTokens: u.prompt_tokens_details?.cached_tokens,
+    reasoningTokens: u.completion_tokens_details?.reasoning_tokens
+  };
+}
+function mapAnthropicUsage(u) {
+  const input = u.input_tokens ?? 0;
+  const output = u.output_tokens ?? 0;
+  return {
+    inputTokens: input,
+    outputTokens: output,
+    totalTokens: input + output,
+    cachedTokens: u.cache_read_input_tokens
+  };
+}
+function mapResponsesUsage(u) {
+  const input = u.input_tokens ?? 0;
+  const output = u.output_tokens ?? 0;
+  return {
+    inputTokens: input,
+    outputTokens: output,
+    totalTokens: u.total_tokens ?? input + output,
+    cachedTokens: u.input_tokens_details?.cached_tokens,
+    reasoningTokens: u.output_tokens_details?.reasoning_tokens
+  };
+}
+
+// src/core/job.ts
+var Job = class {
+  id;
+  transport;
+  taskKind;
+  defaultPoll;
+  cachedValue;
+  constructor(id, transport, taskKind, defaultPoll) {
+    this.id = id;
+    this.transport = transport;
+    this.taskKind = taskKind;
+    this.defaultPoll = defaultPoll;
+  }
+  /** One-shot status probe. Throws `NotFoundError` unless `allowMissing`. */
+  async status(opts = {}) {
+    const res = await this.transport.raw("POST", "/api/llm/queue/status", {
+      body: { queueId: this.id },
+      signal: opts.signal
+    });
+    if (!res.ok) throw await toAPIError(res);
+    const body = await res.json().catch(() => ({}));
+    const data = body.data ?? {};
+    const snapshot = {
+      id: this.id,
+      status: data.status ?? "not_found",
+      position: data.position,
+      createdAt: data.createdAt,
+      startedAt: data.startedAt,
+      completedAt: data.completedAt,
+      provider: data.provider,
+      model: data.model,
+      error: data.error
+    };
+    if (snapshot.status === "not_found" && !opts.allowMissing) {
+      throw new NotFoundError(`Queue task ${this.id} not found`, {
+        status: 404,
+        code: "TASK_NOT_FOUND"
+      });
+    }
+    return snapshot;
+  }
+  /** Poll to completion and resolve the typed result (cached after success). */
+  async result(opts = {}) {
+    if (this.cachedValue) return this.cachedValue.value;
+    const merged = { ...this.defaultPoll, ...opts };
+    const cancelOnAbort = merged.cancelServerOnAbort ?? true;
+    try {
+      const value = await pollToResult(
+        this.transport,
+        this.id,
+        this.taskKind,
+        merged
+      );
+      this.cachedValue = { value };
+      return value;
+    } catch (err) {
+      if (cancelOnAbort && merged.signal?.aborted) {
+        void this.cancel().catch(() => {
+        });
+      }
+      throw err;
+    }
+  }
+  /** Stream the task's chunks via `/queue/stream` (for `stream: true` tasks). */
+  stream(opts = {}) {
+    const transport = this.transport;
+    const id = this.id;
+    return (async function* () {
+      const res = await transport.stream("POST", "/api/llm/queue/stream", {
+        body: { queueId: id },
+        signal: opts.signal
+      });
+      yield* streamResponse(res, "native", {
+        signal: opts.signal,
+        includeRaw: opts.includeRaw,
+        idleMs: opts.idleMs ?? 6e4
+      });
+    })();
+  }
+  /** Best-effort server cancel. Safe to call more than once. */
+  async cancel(opts = {}) {
+    await this.transport.raw("POST", "/api/llm/queue/cancel", {
+      body: { queueId: this.id },
+      signal: opts.signal
+    });
+  }
+};
+async function submitJob(transport, path, body, taskKind, signal, defaultPoll) {
+  const data = await transport.json("POST", path, {
+    body,
+    signal,
+    retry: "submit"
+  });
+  return new Job(data.queueId, transport, taskKind, defaultPoll);
+}
+
+// src/resources/base.ts
+var BaseResource = class {
+  transport;
+  defaultPoll;
+  constructor(transport, defaultPoll) {
+    this.transport = transport;
+    this.defaultPoll = defaultPoll;
+  }
+  submitQueued(path, body, kind, signal) {
+    return submitJob(this.transport, path, body, kind, signal, this.defaultPoll);
+  }
+  async runQueued(path, body, kind, poll) {
+    const job = await this.submitQueued(path, body, kind, poll?.signal);
+    return job.result(poll);
+  }
+};
+
+// src/resources/agents.ts
+var AgentsResource = class extends BaseResource {
+  /** Mint a short-lived signed URL for an ElevenLabs agent. */
+  signedUrl(params, signal) {
+    return this.transport.json("POST", "/api/agents/signed-url", {
+      body: params,
+      signal,
+      retry: "submit"
+    });
+  }
+};
+
+// src/resources/audio.ts
+var AudioResource = class extends BaseResource {
+  /** Text-to-speech. */
+  speech(params, poll) {
+    return this.runQueued(
+      "/api/llm/generate-audio",
+      params,
+      "tts",
+      poll
+    );
+  }
+  speechJob(params, signal) {
+    return this.submitQueued(
+      "/api/llm/generate-audio",
+      params,
+      "tts",
+      signal
+    );
+  }
+  /** Speech-to-text. */
+  transcribe(params, poll) {
+    return this.runQueued(
+      "/api/llm/transcribe",
+      params,
+      "stt",
+      poll
+    );
+  }
+  transcribeJob(params, signal) {
+    return this.submitQueued(
+      "/api/llm/transcribe",
+      params,
+      "stt",
+      signal
+    );
+  }
+  soundEffect(params, poll) {
+    return this.runQueued(
+      "/api/llm/generate-sound-effect",
+      params,
+      "sound-effect",
+      poll
+    );
+  }
+  soundEffectJob(params, signal) {
+    return this.submitQueued(
+      "/api/llm/generate-sound-effect",
+      params,
+      "sound-effect",
+      signal
+    );
+  }
+  music(params, poll) {
+    return this.runQueued(
+      "/api/llm/generate-music",
+      params,
+      "music",
+      poll
+    );
+  }
+  musicJob(params, signal) {
+    return this.submitQueued(
+      "/api/llm/generate-music",
+      params,
+      "music",
+      signal
+    );
+  }
+  dialogue(params, poll) {
+    return this.runQueued(
+      "/api/llm/generate-dialogue",
+      params,
+      "dialogue",
+      poll
+    );
+  }
+  dialogueJob(params, signal) {
+    return this.submitQueued(
+      "/api/llm/generate-dialogue",
+      params,
+      "dialogue",
+      signal
+    );
+  }
+};
+
+// src/resources/chat.ts
+var ChatResource = class extends BaseResource {
+  /** Submit a completion and poll until the final result is ready. */
+  complete(params, poll) {
+    return this.runQueued(
+      "/api/llm/complete",
+      params,
+      "completion",
+      poll
+    );
+  }
+  /** Submit a completion and return the `Job` handle without waiting. */
+  submit(params, signal) {
+    return this.submitQueued(
+      "/api/llm/complete",
+      params,
+      "completion",
+      signal
+    );
+  }
+  /** Stream a completion as normalized chat events. */
+  stream(params, opts = {}) {
+    const transport = this.transport;
+    const defaultPoll = this.defaultPoll;
+    return (async function* () {
+      const job = await submitJob(
+        transport,
+        "/api/llm/complete",
+        { ...params, stream: true },
+        "completion",
+        opts.signal,
+        defaultPoll
+      );
+      yield* job.stream({ signal: opts.signal, includeRaw: opts.includeRaw });
+    })();
+  }
+};
+
+// src/resources/conversations.ts
+var TemplatesAPI = class extends BaseResource {
+  create(params, signal) {
+    return this.transport.json("POST", "/api/convagents/templates", {
+      body: params,
+      signal,
+      retry: "submit"
+    });
+  }
+  list(signal) {
+    return this.transport.json("GET", "/api/convagents/templates", { signal });
+  }
+  async get(id, signal) {
+    const data = await this.transport.json("GET", `/api/convagents/templates/${id}`, { signal });
+    return data.template;
+  }
+  update(id, params, signal) {
+    return this.transport.json("PUT", `/api/convagents/templates/${id}`, {
+      body: params,
+      signal,
+      retry: "submit"
+    });
+  }
+  delete(id, signal) {
+    return this.transport.json("DELETE", `/api/convagents/templates/${id}`, {
+      signal
+    });
+  }
+};
+var SessionsAPI = class extends BaseResource {
+  create(params, signal) {
+    return this.transport.json("POST", "/api/convagents/sessions", {
+      body: params,
+      signal,
+      retry: "submit"
+    });
+  }
+  list(opts = {}, signal) {
+    return this.transport.json("GET", "/api/convagents/sessions", {
+      query: { templateId: opts.templateId },
+      signal
+    });
+  }
+  async get(id, signal) {
+    const data = await this.transport.json("GET", `/api/convagents/sessions/${id}`, { signal });
+    return data.session;
+  }
+};
+var ConversationsResource = class extends BaseResource {
+  templates = new TemplatesAPI(this.transport, this.defaultPoll);
+  sessions = new SessionsAPI(this.transport, this.defaultPoll);
+};
+
+// src/resources/discovery.ts
+var DiscoveryResource = class extends BaseResource {
+  async providers(signal) {
+    const data = await this.transport.json(
+      "GET",
+      "/api/llm/providers",
+      { signal }
+    );
+    return data.providers;
+  }
+  async models(provider, signal) {
+    const data = await this.transport.json(
+      "GET",
+      "/api/llm/models",
+      { query: { provider }, signal }
+    );
+    return data.models;
+  }
+  async voices(provider, signal) {
+    const data = await this.transport.json(
+      "GET",
+      "/api/llm/voices",
+      { query: { provider }, signal }
+    );
+    return data.voices;
+  }
+  capabilities(signal) {
+    return this.transport.json("GET", "/api/llm/capabilities", { signal });
+  }
+  concurrency(signal) {
+    return this.transport.json("GET", "/api/llm/concurrency", { signal });
+  }
+  concurrencyFor(provider, signal) {
+    return this.transport.json(
+      "GET",
+      `/api/llm/concurrency/${encodeURIComponent(provider)}`,
+      { signal }
+    );
+  }
+};
+
+// src/resources/embeddings.ts
+var EmbeddingsResource = class extends BaseResource {
+  /**
+   * Embed one or more text inputs into vectors via a local embedding model
+   * (LM Studio). Submits to the queue and resolves with the vectors. Content is
+   * processed transiently by the gateway and never stored — intended for
+   * customer-side RAG ingestion and retrieval.
+   */
+  create(params, poll) {
+    return this.runQueued(
+      "/api/llm/embeddings",
+      params,
+      "embedding",
+      poll
+    );
+  }
+  /** Handle form: returns a {@link Job} you can poll or cancel yourself. */
+  createJob(params, signal) {
+    return this.submitQueued(
+      "/api/llm/embeddings",
+      params,
+      "embedding",
+      signal
+    );
+  }
+};
+
+// src/resources/images.ts
+var ImagesResource = class extends BaseResource {
+  /** Generate one or more images and wait for the result. */
+  generate(params, poll) {
+    return this.runQueued(
+      "/api/llm/generate-image",
+      params,
+      "image",
+      poll
+    );
+  }
+  /** Submit an image generation and return the `Job` handle. */
+  generateJob(params, signal) {
+    return this.submitQueued(
+      "/api/llm/generate-image",
+      params,
+      "image",
+      signal
+    );
+  }
+};
+
+// src/resources/keys.ts
+var KeysResource = class extends BaseResource {
+  /** Info about the key the client is authenticated with. */
+  info(signal) {
+    return this.transport.json("GET", "/api/keys/info", { signal });
+  }
+  /** Validate an API key. Returns `{ valid: false }` rather than throwing. */
+  validate(apiKey, signal) {
+    return this.transport.json("POST", "/api/keys/validate", {
+      body: { apiKey },
+      signal,
+      unwrap: false
+    });
+  }
+};
+
+// src/resources/portal.ts
+var PortalResource = class extends BaseResource {
+  info(signal) {
+    return this.transport.json("GET", "/api/portal/info", { signal });
+  }
+  overview(period = {}, signal) {
+    return this.transport.json("GET", "/api/portal/overview", {
+      query: { year: period.year, month: period.month },
+      signal
+    });
+  }
+  usageDaily(period = {}, signal) {
+    return this.transport.json("GET", "/api/portal/usage/daily", {
+      query: { year: period.year, month: period.month },
+      signal
+    });
+  }
+  usageByModel(period = {}, signal) {
+    return this.transport.json("GET", "/api/portal/usage/by-model", {
+      query: { year: period.year, month: period.month },
+      signal
+    });
+  }
+  /** Export a month of usage as CSV text. */
+  exportUsage(params, signal) {
+    return this.transport.text("GET", "/api/portal/export/usage", {
+      query: { month: params.month, year: params.year },
+      signal
+    });
+  }
+};
+
+// src/resources/public.ts
+var PublicResource = class extends BaseResource {
+  /** All providers with their models and public pricing. */
+  models(signal) {
+    return this.transport.json("GET", "/api/public/models", { signal });
+  }
+  /** Available voices per provider. */
+  voices(signal) {
+    return this.transport.json("GET", "/api/public/voices", { signal });
+  }
+  /** A short spoken preview of a voice (base64 audio). */
+  voicePreview(params, signal) {
+    return this.transport.json("POST", "/api/public/voices/preview", {
+      body: params,
+      signal
+    });
+  }
+  /** The raw OpenAPI specification (YAML). */
+  openapi(signal) {
+    return this.transport.text("GET", "/api/public/openapi.yaml", { signal });
+  }
+};
+
+// src/resources/queue.ts
+var QueueResource = class extends BaseResource {
+  /** Reconstruct a `Job` handle from a known queue id. */
+  job(queueId, taskKind = "completion") {
+    return new Job(queueId, this.transport, taskKind, this.defaultPoll);
+  }
+  status(queueId, opts) {
+    return this.job(queueId).status(opts);
+  }
+  result(queueId, opts) {
+    return this.job(queueId).result(opts);
+  }
+  stream(queueId, opts) {
+    return this.job(queueId).stream(opts);
+  }
+  cancel(queueId, opts) {
+    return this.job(queueId).cancel(opts);
+  }
+};
+
+// src/resources/realtime.ts
+var RealtimeSessionsAPI = class extends BaseResource {
+  /** Mint an ephemeral realtime credential. The response is NOT enveloped. */
+  create(params, signal) {
+    return this.transport.json("POST", "/api/realtime/sessions", {
+      body: params,
+      signal,
+      retry: "submit",
+      unwrap: false
+    });
+  }
+  async get(id, signal) {
+    const data = await this.transport.json(
+      "GET",
+      `/api/realtime/sessions/${id}`,
+      { signal }
+    );
+    return data.session;
+  }
+  async end(id, params = {}, signal) {
+    const data = await this.transport.json(
+      "POST",
+      `/api/realtime/sessions/${id}/end`,
+      { body: params, signal }
+    );
+    return data.session;
+  }
+};
+var RealtimeResource = class extends BaseResource {
+  sessions = new RealtimeSessionsAPI(this.transport, this.defaultPoll);
+};
+function toBrokeredCredential(session) {
+  if ("clientSecret" in session) {
+    return {
+      kind: "openai-realtime",
+      sessionId: session.sessionId,
+      token: session.clientSecret,
+      url: session.webrtcUrl,
+      expiresAt: session.expiresAt,
+      expiresInMs: Math.max(0, Date.parse(session.expiresAt) - Date.now())
+    };
+  }
+  const expiresInMs = session.expiresIn * 1e3;
+  return {
+    kind: "elevenlabs-convai",
+    sessionId: session.session.id,
+    url: session.signedUrl,
+    expiresAt: new Date(Date.now() + expiresInMs).toISOString(),
+    expiresInMs
+  };
+}
+
+// src/resources/usage.ts
+var UsageResource = class extends BaseResource {
+  /** Current-month usage summary. */
+  current(signal) {
+    return this.transport.json("GET", "/api/llm/usage", { signal });
+  }
+  /** Monthly usage broken down by model/provider. */
+  monthly(signal) {
+    return this.transport.json("GET", "/api/llm/usage/monthly", { signal });
+  }
+  /** Daily usage breakdown. */
+  daily(signal) {
+    return this.transport.json("GET", "/api/llm/usage/daily", { signal });
+  }
+};
+
+// src/resources/video.ts
+var VideoResource = class extends BaseResource {
+  generate(params, poll) {
+    return this.runQueued(
+      "/api/llm/generate-video",
+      params,
+      "video",
+      poll
+    );
+  }
+  generateJob(params, signal) {
+    return this.submitQueued(
+      "/api/llm/generate-video",
+      params,
+      "video",
+      signal
+    );
+  }
+  /** Upload a seed video for image/video-to-video; returns a `fileId`. */
+  async upload(file, opts = {}) {
+    const form = new FormData();
+    const blob = file instanceof Blob ? file : new Blob([file], { type: opts.mimeType });
+    form.append("video", blob, opts.filename ?? "video");
+    return this.transport.json(
+      "POST",
+      "/api/llm/upload-video",
+      { body: form, signal: opts.signal, retry: "submit" }
+    );
+  }
+};
+
+// src/resources/vision.ts
+var VisionResource = class extends BaseResource {
+  detect(params, poll) {
+    return this.runQueued("/api/vision/detect", params, "vision", poll);
+  }
+  detectJob(params, signal) {
+    return this.submitQueued("/api/vision/detect", params, "vision", signal);
+  }
+  zeroShot(params, poll) {
+    return this.runQueued(
+      "/api/vision/detect/zero-shot",
+      params,
+      "vision",
+      poll
+    );
+  }
+  zeroShotJob(params, signal) {
+    return this.submitQueued(
+      "/api/vision/detect/zero-shot",
+      params,
+      "vision",
+      signal
+    );
+  }
+  faces(params, poll) {
+    return this.runQueued("/api/vision/detect/faces", params, "vision", poll);
+  }
+  facesJob(params, signal) {
+    return this.submitQueued(
+      "/api/vision/detect/faces",
+      params,
+      "vision",
+      signal
+    );
+  }
+  web(params, poll) {
+    return this.runQueued("/api/vision/detect/web", params, "vision", poll);
+  }
+  webJob(params, signal) {
+    return this.submitQueued("/api/vision/detect/web", params, "vision", signal);
+  }
+  autoLabel(params, poll) {
+    return this.runQueued("/api/vision/auto-label", params, "vision", poll);
+  }
+  autoLabelJob(params, signal) {
+    return this.submitQueued("/api/vision/auto-label", params, "vision", signal);
+  }
+  autoTrain(params, poll) {
+    return this.runQueued("/api/vision/auto-train", params, "vision", poll);
+  }
+  autoTrainJob(params, signal) {
+    return this.submitQueued("/api/vision/auto-train", params, "vision", signal);
+  }
+  /** Start a dataset training run (synchronous; returns a job record). */
+  train(params, signal) {
+    return this.transport.json("POST", "/api/vision/train", {
+      body: params,
+      signal,
+      retry: "submit"
+    });
+  }
+  getTraining(jobId, signal) {
+    return this.transport.json(
+      "GET",
+      `/api/vision/train/${encodeURIComponent(jobId)}`,
+      { signal }
+    );
+  }
+  listTraining(signal) {
+    return this.transport.json("GET", "/api/vision/train", {
+      signal
+    });
+  }
+  models(signal) {
+    return this.transport.json("GET", "/api/vision/models", {
+      signal
+    });
+  }
+  deleteModel(modelId, signal) {
+    return this.transport.json(
+      "DELETE",
+      `/api/vision/models/${encodeURIComponent(modelId)}`,
+      { signal }
+    );
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.ai.canarycoders.es";
+function readEnv(key) {
+  if (typeof process !== "undefined" && process.env) return process.env[key];
+  return void 0;
+}
+var CanaryLLM = class {
+  chat;
+  queue;
+  images;
+  video;
+  audio;
+  embeddings;
+  vision;
+  conversations;
+  agents;
+  realtime;
+  discovery;
+  usage;
+  portal;
+  keys;
+  public;
+  transport;
+  baseURL;
+  apiKey;
+  constructor(options = {}) {
+    this.apiKey = options.apiKey ?? readEnv("CANARY_AI_API_KEY") ?? readEnv("CANARYLLM_API_KEY");
+    this.baseURL = options.baseURL ?? readEnv("CANARY_AI_BASE_URL") ?? readEnv("CANARYLLM_BASE_URL") ?? DEFAULT_BASE_URL;
+    this.transport = new Transport({
+      apiKey: this.apiKey,
+      baseURL: this.baseURL,
+      authStyle: options.authStyle ?? "bearer",
+      timeoutMs: options.timeoutMs ?? 6e4,
+      maxRetries: options.maxRetries ?? 2,
+      fetch: options.fetch,
+      defaultHeaders: options.defaultHeaders,
+      defaultTag: options.defaultTag
+    });
+    const poll = options.poll;
+    this.chat = new ChatResource(this.transport, poll);
+    this.queue = new QueueResource(this.transport, poll);
+    this.images = new ImagesResource(this.transport, poll);
+    this.video = new VideoResource(this.transport, poll);
+    this.audio = new AudioResource(this.transport, poll);
+    this.embeddings = new EmbeddingsResource(this.transport, poll);
+    this.vision = new VisionResource(this.transport, poll);
+    this.conversations = new ConversationsResource(this.transport, poll);
+    this.agents = new AgentsResource(this.transport, poll);
+    this.realtime = new RealtimeResource(this.transport, poll);
+    this.discovery = new DiscoveryResource(this.transport, poll);
+    this.usage = new UsageResource(this.transport, poll);
+    this.portal = new PortalResource(this.transport, poll);
+    this.keys = new KeysResource(this.transport, poll);
+    this.public = new PublicResource(this.transport, poll);
+  }
+  /** Targets to plug into the official `openai` / `@anthropic-ai/sdk` clients. */
+  get compat() {
+    return {
+      openai: () => openaiTarget(this.baseURL, this.apiKey ?? ""),
+      anthropic: () => anthropicTarget(this.baseURL, this.apiKey ?? "")
+    };
+  }
+};
+
+// src/index.ts
+var src_default = CanaryLLM;
+
+export { APIConnectionError, APIConnectionTimeoutError, APIError, AuthenticationError, BadRequestError, CanaryLLM, ConflictError, InternalServerError, Job, NotFoundError, PermissionError, RateLimitError, UnprocessableEntityError, anthropicTarget, src_default as default, openaiTarget, toBrokeredCredential };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map