addisai 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1465 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// src/core/env.ts
+var DEFAULT_BASE_URL = "https://api.addisassistant.com";
+var API_KEY_ENV_VAR = "ADDIS_API_KEY";
+function readEnv(name) {
+  if (typeof process !== "undefined" && process.env && name in process.env) {
+    const value = process.env[name];
+    return value == null || value === "" ? void 0 : value;
+  }
+  const deno = globalThis.Deno;
+  if (deno?.env?.get) {
+    try {
+      const value = deno.env.get(name);
+      return value ? value : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function isBrowserLike() {
+  return typeof globalThis.window !== "undefined" && typeof globalThis.document !== "undefined";
+}
+var BLOCKED_HOST_SUFFIXES = [".supabase.co", ".supabase.in"];
+function resolveBaseURL(baseURL) {
+  const raw = (baseURL ?? DEFAULT_BASE_URL).trim().replace(/\/+$/, "");
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new Error(`addisai: invalid baseURL "${raw}".`);
+  }
+  const host = url.hostname.toLowerCase();
+  const isLocal = host === "localhost" || host === "127.0.0.1";
+  if (url.protocol !== "https:" && !isLocal) {
+    throw new Error(
+      `addisai: baseURL must use https (got "${url.protocol}//${host}").`
+    );
+  }
+  if (BLOCKED_HOST_SUFFIXES.some((suffix) => host.endsWith(suffix))) {
+    throw new Error(
+      `addisai: pointing the SDK at a raw *.supabase.co host is not allowed. Use the Addis AI API at ${DEFAULT_BASE_URL}.`
+    );
+  }
+  return raw;
+}
+function detectRuntime() {
+  const g = globalThis;
+  if (g.Deno?.version?.deno) return `Deno/${g.Deno.version.deno}`;
+  if (g.Bun?.version) return `Bun/${g.Bun.version}`;
+  if (typeof process !== "undefined" && process.versions?.node) {
+    return `Node/${process.versions.node}`;
+  }
+  if (isBrowserLike()) return "Browser";
+  return "Unknown";
+}
+
+// src/core/errors.ts
+var AddisAIError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var NotSupportedError = class extends AddisAIError {
+};
+var APIConnectionError = class extends AddisAIError {
+  constructor(message = "Connection error.", cause) {
+    super(message);
+    this.cause = cause;
+  }
+};
+var APIConnectionTimeoutError = class extends APIConnectionError {
+  constructor(message = "Request timed out.") {
+    super(message);
+  }
+};
+var APIError = class extends AddisAIError {
+  constructor(status, message, opts = {}) {
+    super(message);
+    this.status = status;
+    this.code = opts.code ?? null;
+    this.details = opts.details ?? [];
+    this.requestId = opts.requestId ?? null;
+    this.headers = opts.headers ?? {};
+  }
+};
+var BadRequestError = class extends APIError {
+};
+var AuthenticationError = class extends APIError {
+};
+var InsufficientCreditsError = class extends APIError {
+  // 402
+  get availableBalance() {
+    return numericDetail(this, "balance_too_low") ?? null;
+  }
+};
+var PermissionDeniedError = class extends APIError {
+};
+var NotFoundError = class extends APIError {
+};
+var ConflictError = class extends APIError {
+};
+var IdempotencyConflictError = class extends ConflictError {
+};
+var GenerationInProgressError = class extends ConflictError {
+  // 409 GENERATION_IN_PROGRESS
+  get retryAfter() {
+    return headerNumber(this.headers, "retry-after");
+  }
+};
+var UnprocessableEntityError = class extends APIError {
+};
+var RateLimitError = class extends APIError {
+  // 429
+  get retryAfter() {
+    return headerNumber(this.headers, "retry-after");
+  }
+  get limit() {
+    return headerNumber(this.headers, "x-ratelimit-limit");
+  }
+  get remaining() {
+    return headerNumber(this.headers, "x-ratelimit-remaining");
+  }
+  get reset() {
+    return headerNumber(this.headers, "x-ratelimit-reset");
+  }
+};
+var InternalServerError = class extends APIError {
+};
+function headerNumber(headers, name) {
+  const raw = headers[name.toLowerCase()];
+  if (!raw) return null;
+  const n = Number(raw);
+  return Number.isFinite(n) ? n : null;
+}
+function numericDetail(err, code) {
+  const detail = err.details.find((d) => d.code === code);
+  const match = detail?.message?.match(/([\d]+(?:\.\d+)?)/g);
+  if (!match) return null;
+  const n = Number(match[match.length - 1]);
+  return Number.isFinite(n) ? n : null;
+}
+function parseEnvelope(status, body, rawText) {
+  if (body && typeof body === "object") {
+    const obj = body;
+    const err = obj.error;
+    if (err && typeof err === "object") {
+      return {
+        message: typeof err.message === "string" && err.message ? err.message : `Request failed with status ${status}.`,
+        code: typeof err.code === "string" ? err.code : typeof err.type === "string" ? err.type : null,
+        details: Array.isArray(err.details) ? err.details : []
+      };
+    }
+    if (typeof obj.message === "string" && obj.message) {
+      return { message: obj.message, code: typeof obj.code === "string" ? obj.code : null, details: [] };
+    }
+  }
+  return {
+    message: rawText?.slice(0, 500) || `Request failed with status ${status}.`,
+    code: null,
+    details: []
+  };
+}
+function makeAPIError(status, body, rawText, headers) {
+  const { message, code, details } = parseEnvelope(status, body, rawText);
+  const requestId = headers["x-request-id"] ?? headers["cf-ray"] ?? null;
+  const opts = { code, details, requestId, headers };
+  const upper = (code ?? "").toUpperCase();
+  switch (status) {
+    case 400:
+      return new BadRequestError(status, message, opts);
+    case 401:
+      return new AuthenticationError(status, message, opts);
+    case 402:
+      return new InsufficientCreditsError(status, message, opts);
+    case 403:
+      return new PermissionDeniedError(status, message, opts);
+    case 404:
+      return new NotFoundError(status, message, opts);
+    case 409:
+      if (upper === "IDEMPOTENCY_CONFLICT") return new IdempotencyConflictError(status, message, opts);
+      if (upper === "GENERATION_IN_PROGRESS") return new GenerationInProgressError(status, message, opts);
+      return new ConflictError(status, message, opts);
+    case 413:
+    case 422:
+      return new UnprocessableEntityError(status, message, opts);
+    case 429:
+      return new RateLimitError(status, message, opts);
+    default:
+      if (status >= 500) return new InternalServerError(status, message, opts);
+      return new APIError(status, message, opts);
+  }
+}
+
+// src/version.ts
+var VERSION = "0.1.0";
+
+// src/core/request.ts
+var LOG_ORDER = {
+  off: 0,
+  error: 1,
+  warn: 2,
+  info: 3,
+  debug: 4
+};
+var Transport = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /** The configured fetch implementation, for direct asset downloads. */
+  get fetch() {
+    return this.config.fetch;
+  }
+  log(level, ...args) {
+    if (LOG_ORDER[this.config.logLevel] >= LOG_ORDER[level]) {
+      console[level === "debug" ? "log" : level]("[addisai]", ...args);
+    }
+  }
+  buildURL(path, query) {
+    const url = new URL(this.config.baseURL + path);
+    const merged = { ...this.config.defaultQuery, ...query ?? {} };
+    for (const [key, value] of Object.entries(merged)) {
+      if (value == null) continue;
+      url.searchParams.set(key, String(value));
+    }
+    return url.toString();
+  }
+  buildHeaders(req, opts) {
+    const headers = new Headers();
+    headers.set("Accept", "application/json");
+    headers.set("User-Agent", `addisai-node/${VERSION} (${detectRuntime()})`);
+    headers.set("X-Addis-Client", `addisai-node/${VERSION}`);
+    if (looksLikeJwt(this.config.apiKey)) {
+      headers.set("Authorization", `Bearer ${this.config.apiKey}`);
+    } else {
+      headers.set("x-api-key", this.config.apiKey);
+    }
+    for (const [k, v] of Object.entries(this.config.defaultHeaders)) headers.set(k, v);
+    for (const [k, v] of Object.entries(opts.headers ?? {})) headers.set(k, v);
+    if (opts.idempotencyKey) headers.set("Idempotency-Key", opts.idempotencyKey);
+    if (req.body !== void 0 && !req.form) headers.set("Content-Type", "application/json");
+    return headers;
+  }
+  isRetryable(status, headers) {
+    if (status === 408 || status === 425 || status === 429) return true;
+    if (status === 409) return headers.has("retry-after");
+    return status >= 500;
+  }
+  retryDelayMs(attempt, headers) {
+    const retryAfter = headers.get("retry-after");
+    if (retryAfter) {
+      const seconds = Number(retryAfter);
+      if (Number.isFinite(seconds)) return Math.min(seconds * 1e3, 6e4);
+    }
+    const base = Math.min(500 * 2 ** attempt, 8e3);
+    return base * (0.5 + Math.random() * 0.5);
+  }
+  async request(req, opts = {}) {
+    const maxRetries = opts.maxRetries ?? this.config.maxRetries;
+    let timeout = opts.timeout ?? this.config.timeout;
+    if (req.timeoutFloor && timeout < req.timeoutFloor && opts.timeout === void 0) {
+      timeout = req.timeoutFloor;
+    }
+    const url = this.buildURL(req.path, { ...req.query, ...opts.query });
+    const headers = this.buildHeaders(req, opts);
+    const bodyInit = req.form ? req.form : req.body !== void 0 ? JSON.stringify(req.body) : void 0;
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      const controller = new AbortController();
+      const onAbort = () => controller.abort(opts.signal?.reason);
+      if (opts.signal) {
+        if (opts.signal.aborted) controller.abort(opts.signal.reason);
+        else opts.signal.addEventListener("abort", onAbort, { once: true });
+      }
+      const timer = setTimeout(() => controller.abort(new DOMExceptionLike("timeout")), timeout);
+      let response;
+      try {
+        this.log("debug", `${req.method} ${url} (attempt ${attempt + 1}/${maxRetries + 1})`);
+        response = await this.config.fetch(url, {
+          method: req.method,
+          headers,
+          body: bodyInit,
+          signal: controller.signal
+        });
+      } catch (err) {
+        clearTimeout(timer);
+        opts.signal?.removeEventListener("abort", onAbort);
+        if (opts.signal?.aborted) throw err;
+        const timedOut = isAbortError(err);
+        lastError = timedOut ? new APIConnectionTimeoutError(`Request timed out after ${timeout}ms.`) : new APIConnectionError("Connection error.", err);
+        if (attempt < maxRetries) {
+          await sleep(this.retryDelayMs(attempt, new Headers()));
+          continue;
+        }
+        throw lastError;
+      } finally {
+        clearTimeout(timer);
+        opts.signal?.removeEventListener("abort", onAbort);
+      }
+      if (response.ok) {
+        if (req.raw) return response;
+        return await this.parseJSON(response);
+      }
+      if (attempt < maxRetries && this.isRetryable(response.status, response.headers)) {
+        const delay = this.retryDelayMs(attempt, response.headers);
+        this.log("warn", `Retrying after ${Math.round(delay)}ms (status ${response.status}).`);
+        await sleep(delay);
+        continue;
+      }
+      throw await this.toError(response);
+    }
+    throw lastError instanceof Error ? lastError : new APIConnectionError();
+  }
+  /**
+   * Open a streaming request: a single fetch (streams are not retried once
+   * started), with the timeout guarding only the initial response. The returned
+   * controller stays live so the caller can cancel the body mid-stream.
+   */
+  async openStream(req, opts = {}) {
+    const controller = new AbortController();
+    if (opts.signal) {
+      if (opts.signal.aborted) controller.abort(opts.signal.reason);
+      else opts.signal.addEventListener("abort", () => controller.abort(opts.signal?.reason), { once: true });
+    }
+    const timeout = opts.timeout ?? this.config.timeout;
+    const url = this.buildURL(req.path, { ...req.query, ...opts.query });
+    const headers = this.buildHeaders(req, opts);
+    const bodyInit = req.form ? req.form : req.body !== void 0 ? JSON.stringify(req.body) : void 0;
+    const timer = setTimeout(() => controller.abort(new DOMExceptionLike("timeout")), timeout);
+    let response;
+    try {
+      response = await this.config.fetch(url, {
+        method: req.method,
+        headers,
+        body: bodyInit,
+        signal: controller.signal
+      });
+    } catch (err) {
+      clearTimeout(timer);
+      if (opts.signal?.aborted) throw err;
+      throw isAbortError(err) ? new APIConnectionTimeoutError(`Request timed out after ${timeout}ms.`) : new APIConnectionError("Connection error.", err);
+    }
+    clearTimeout(timer);
+    if (!response.ok) throw await this.toError(response);
+    return { response, controller };
+  }
+  async parseJSON(response) {
+    const text = await response.text();
+    if (!text) return {};
+    try {
+      return JSON.parse(text);
+    } catch {
+      return { raw: text };
+    }
+  }
+  async toError(response) {
+    const text = await response.text().catch(() => "");
+    let body = void 0;
+    try {
+      body = text ? JSON.parse(text) : void 0;
+    } catch {
+      body = void 0;
+    }
+    const headers = {};
+    response.headers.forEach((value, key) => headers[key.toLowerCase()] = value);
+    return makeAPIError(response.status, body, text, headers);
+  }
+};
+var DOMExceptionLike = class extends Error {
+  constructor(name) {
+    super(name);
+    this.name = name;
+  }
+};
+function looksLikeJwt(key) {
+  return key.startsWith("ey") && key.split(".").length === 3;
+}
+function isAbortError(err) {
+  return err instanceof Error && (err.name === "AbortError" || err.name === "timeout" || err.name === "TimeoutError");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function unwrapData(body) {
+  if (body && typeof body === "object" && "data" in body) {
+    return body.data;
+  }
+  return body;
+}
+
+// src/core/redact.ts
+function redactApiKey(key) {
+  if (!key) return "(none)";
+  if (key.length <= 8) return "\u2022\u2022\u2022\u2022";
+  return `${key.slice(0, 4)}\u2022\u2022\u2022\u2022${key.slice(-2)}`;
+}
+
+// src/core/sse.ts
+async function* parseSSE(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let eventName = null;
+  let dataLines = [];
+  const flush = () => {
+    if (dataLines.length === 0 && eventName === null) return null;
+    const evt = { event: eventName, data: dataLines.join("\n") };
+    eventName = null;
+    dataLines = [];
+    return evt;
+  };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let nl;
+      while ((nl = buffer.indexOf("\n")) >= 0) {
+        let line = buffer.slice(0, nl);
+        buffer = buffer.slice(nl + 1);
+        if (line.endsWith("\r")) line = line.slice(0, -1);
+        if (line === "") {
+          const evt2 = flush();
+          if (evt2) yield evt2;
+          continue;
+        }
+        if (line.startsWith(":")) continue;
+        const colon = line.indexOf(":");
+        const field = colon === -1 ? line : line.slice(0, colon);
+        let val = colon === -1 ? "" : line.slice(colon + 1);
+        if (val.startsWith(" ")) val = val.slice(1);
+        if (field === "event") eventName = val;
+        else if (field === "data") dataLines.push(val);
+      }
+    }
+    const evt = flush();
+    if (evt) yield evt;
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function* parseNDJSON(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let nl;
+      while ((nl = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, nl).trim();
+        buffer = buffer.slice(nl + 1);
+        if (line) yield safeParse(line);
+      }
+    }
+    const tail = buffer.trim();
+    if (tail) yield safeParse(tail);
+  } finally {
+    reader.releaseLock();
+  }
+}
+function safeParse(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/lib/chat-stream.ts
+var ADDIS_CHAT_MODEL = "addis-1-alef";
+var ChatStream = class {
+  constructor(response, controller) {
+    this.response = response;
+    this.controller = controller;
+    this.id = `chatcmpl-${cryptoRandom()}`;
+    this.created = Math.floor(Date.now() / 1e3);
+    this.consumed = false;
+  }
+  /** Cancel the stream and underlying request. */
+  abort() {
+    this.controller?.abort();
+  }
+  async *[Symbol.asyncIterator]() {
+    if (this.consumed) {
+      throw new AddisAIError("This stream has already been consumed.");
+    }
+    this.consumed = true;
+    if (!this.response.body) return;
+    for await (const evt of parseSSE(this.response.body)) {
+      const raw = evt.data.trim();
+      if (!raw || raw === "[DONE]") {
+        if (raw === "[DONE]") return;
+        continue;
+      }
+      let payload;
+      try {
+        payload = JSON.parse(raw);
+      } catch {
+        continue;
+      }
+      if (payload.type === "metadata") {
+        this.transcription = {
+          raw: payload.transcription_raw,
+          clean: payload.transcription_clean
+        };
+        continue;
+      }
+      const usage = payload.usage_metadata;
+      if (usage) {
+        this.finalUsage = {
+          prompt_tokens: usage.prompt_token_count ?? usage.promptTokenCount ?? 0,
+          completion_tokens: usage.candidates_token_count ?? usage.candidatesTokenCount ?? 0,
+          total_tokens: usage.total_token_count ?? usage.totalTokenCount ?? 0
+        };
+      }
+      const content = payload.text ?? payload.response_text ?? payload.delta?.content ?? "";
+      const finishReason = payload.finish_reason ?? (payload.is_last_chunk ? "stop" : null);
+      if (!content && !finishReason) continue;
+      yield {
+        id: this.id,
+        object: "chat.completion.chunk",
+        created: this.created,
+        model: ADDIS_CHAT_MODEL,
+        choices: [{ index: 0, delta: { content }, finish_reason: normalizeFinish(finishReason) }]
+      };
+    }
+  }
+  /** Consume the stream and return the concatenated assistant text. */
+  async finalText() {
+    let text = "";
+    for await (const chunk of this) text += chunk.choices[0]?.delta?.content ?? "";
+    return text;
+  }
+  /** Consume the stream and return an assembled non-streaming completion. */
+  async finalCompletion() {
+    let content = "";
+    let finishReason = "stop";
+    for await (const chunk of this) {
+      content += chunk.choices[0]?.delta?.content ?? "";
+      if (chunk.choices[0]?.finish_reason) finishReason = chunk.choices[0].finish_reason;
+    }
+    const completion = {
+      id: this.id,
+      object: "chat.completion",
+      created: this.created,
+      model: ADDIS_CHAT_MODEL,
+      choices: [{ index: 0, message: { role: "assistant", content }, finish_reason: finishReason }],
+      usage: this.finalUsage
+    };
+    if (this.transcription) completion.transcription = this.transcription;
+    return completion;
+  }
+  /** Re-encode the stream as a byte ReadableStream of SSE chunks (for piping). */
+  toReadableStream() {
+    const encoder = new TextEncoder();
+    const iterator = this[Symbol.asyncIterator]();
+    return new ReadableStream({
+      async pull(controller) {
+        const { value, done } = await iterator.next();
+        if (done) {
+          controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+          controller.close();
+          return;
+        }
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(value)}
+
+`));
+      }
+    });
+  }
+};
+function normalizeFinish(reason) {
+  if (!reason) return null;
+  switch (reason.toUpperCase()) {
+    case "STOP":
+      return "stop";
+    case "MAX_TOKENS":
+      return "length";
+    case "SAFETY":
+    case "RECITATION":
+      return "content_filter";
+    case "TOOL_CALLS":
+      return "tool_calls";
+    default:
+      return reason.toLowerCase();
+  }
+}
+function cryptoRandom() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID) return c.randomUUID();
+  return Math.random().toString(36).slice(2);
+}
+
+// src/core/uploads.ts
+function isFileInput(value) {
+  return typeof value === "object" && value !== null && "data" in value;
+}
+function toBlob(input, fallbackType = "application/octet-stream") {
+  if (isFileInput(input)) {
+    const type = input.contentType ?? fallbackType;
+    const blob = input.data instanceof Blob ? input.contentType ? new Blob([input.data], { type }) : input.data : new Blob([input.data], { type });
+    return { blob, filename: input.filename ?? "file" };
+  }
+  if (input instanceof Blob) {
+    return { blob: input, filename: input.name || "file" };
+  }
+  return { blob: new Blob([input], { type: fallbackType }), filename: "file" };
+}
+async function fileFromPath(path, contentType) {
+  const fs = await import('fs/promises');
+  const data = await fs.readFile(path);
+  const filename = path.split(/[\\/]/).pop() || "file";
+  return {
+    data: new Uint8Array(data),
+    filename,
+    contentType: contentType ?? guessContentType(filename)
+  };
+}
+function guessContentType(filename) {
+  const ext = filename.toLowerCase().split(".").pop();
+  switch (ext) {
+    case "wav":
+      return "audio/wav";
+    case "mp3":
+      return "audio/mpeg";
+    case "m4a":
+      return "audio/m4a";
+    case "mp4":
+      return "audio/mp4";
+    case "ogg":
+      return "audio/ogg";
+    case "webm":
+      return "audio/webm";
+    case "flac":
+      return "audio/flac";
+    case "png":
+      return "image/png";
+    case "jpg":
+    case "jpeg":
+      return "image/jpeg";
+    case "pdf":
+      return "application/pdf";
+    default:
+      return void 0;
+  }
+}
+
+// src/resources/chat.ts
+var ADDIS_CHAT_MODEL2 = "addis-1-alef";
+var Chat = class {
+  constructor(transport) {
+    this.transport = transport;
+    this.completions = new Completions(transport);
+  }
+  /**
+   * Run an automatic tool-calling loop: the model requests tools, the SDK
+   * executes your local implementations, feeds results back, and repeats until
+   * the model produces a final answer.
+   */
+  async runTools(params, opts) {
+    const { maxToolRoundtrips = 5, tools, ...rest } = params;
+    const impls = /* @__PURE__ */ new Map();
+    const wireTools = tools.map((t) => {
+      impls.set(t.function.name, t.function.function);
+      return { type: "function", function: { name: t.function.name, description: t.function.description, parameters: t.function.parameters } };
+    });
+    const messages = [...rest.messages];
+    for (let i = 0; i <= maxToolRoundtrips; i++) {
+      const completion = await this.completions.create(
+        { ...rest, messages, tools: wireTools, stream: false },
+        opts
+      );
+      const choice = completion.choices[0];
+      const calls = choice?.message.tool_calls ?? [];
+      if (!calls.length || choice?.finish_reason !== "tool_calls") {
+        return completion;
+      }
+      if (i === maxToolRoundtrips) {
+        throw new AddisAIError(
+          `runTools exceeded maxToolRoundtrips (${maxToolRoundtrips}) without a final answer.`
+        );
+      }
+      messages.push(choice.message);
+      for (const call of calls) {
+        const impl = impls.get(call.function.name);
+        if (!impl) {
+          throw new AddisAIError(`No implementation provided for tool "${call.function.name}".`);
+        }
+        let args = {};
+        try {
+          args = call.function.arguments ? JSON.parse(call.function.arguments) : {};
+        } catch {
+          args = call.function.arguments;
+        }
+        const result = await impl(args);
+        messages.push({
+          role: "tool",
+          tool_call_id: call.id,
+          name: call.function.name,
+          content: typeof result === "string" ? result : JSON.stringify(result)
+        });
+      }
+    }
+    throw new AddisAIError("runTools terminated unexpectedly.");
+  }
+};
+var Completions = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async create(params, opts = {}) {
+    const hasTools = Boolean(params.tools?.length) || params.messages.some((m) => m.role === "tool" || m.tool_calls);
+    const language = params.language ?? "am";
+    if (params.stream) {
+      if (hasTools) {
+        throw new AddisAIError("Streaming is not supported with tool calling. Use non-streaming mode for tools.");
+      }
+      return this.createStream(params, language, opts);
+    }
+    if (params.attachments?.length || params.audio) {
+      return this.createMultipart(params, language, opts);
+    }
+    const envelope = await this.transport.request(
+      { method: "POST", path: "/api/v1/chat_generate", body: buildNativeBody(params, language) },
+      opts
+    );
+    return nativeToOpenAICompletion(envelope.data);
+  }
+  async createStream(params, language, opts) {
+    const { response, controller } = await this.transport.openStream(
+      { method: "POST", path: "/api/v1/chat_generate", body: buildNativeBody(params, language, { stream: true }) },
+      opts
+    );
+    return new ChatStream(response, controller);
+  }
+  async createMultipart(params, language, opts) {
+    const form = new FormData();
+    const attachmentFieldNames = [];
+    (params.attachments ?? []).forEach((att, i) => {
+      const field = att.name ?? `attachment_${i}`;
+      const { blob, filename } = toBlob(att.file);
+      form.append(field, blob, filename);
+      attachmentFieldNames.push(field);
+    });
+    if (params.audio) {
+      const { blob, filename } = toBlob(params.audio, "audio/wav");
+      form.append("chat_audio_input", blob, filename || "audio.wav");
+    }
+    const requestData = buildNativeBody(params, language);
+    if (attachmentFieldNames.length) requestData.attachment_field_names = attachmentFieldNames;
+    form.append(
+      "request_data",
+      new Blob([JSON.stringify(requestData)], { type: "application/json" })
+    );
+    const envelope = await this.transport.request(
+      { method: "POST", path: "/api/v1/chat_generate", form },
+      opts
+    );
+    return nativeToOpenAICompletion(envelope.data);
+  }
+};
+function buildNativeBody(params, language, opts = {}) {
+  const systemParts = [];
+  if (params.system) systemParts.push(params.system);
+  const nonSystem = [];
+  for (const m of params.messages) {
+    if (m.role === "system" || m.role === "developer") {
+      if (typeof m.content === "string" && m.content.trim()) systemParts.push(m.content);
+    } else {
+      nonSystem.push(m);
+    }
+  }
+  let lastUser = -1;
+  for (let i = nonSystem.length - 1; i >= 0; i--) {
+    const m = nonSystem[i];
+    if (m.role === "user" && typeof m.content === "string" && m.content.trim()) {
+      lastUser = i;
+      break;
+    }
+  }
+  const prompt = lastUser >= 0 ? nonSystem[lastUser].content : void 0;
+  const historySource = lastUser >= 0 ? nonSystem.slice(0, lastUser) : nonSystem;
+  const conversationHistory = historySource.map((m) => ({
+    role: m.role === "assistant" ? "assistant" : m.role === "tool" ? "assistant" : "user",
+    content: typeof m.content === "string" ? m.content : ""
+  })).filter((m) => m.content);
+  const body = { target_language: language };
+  if (prompt !== void 0) body.prompt = prompt;
+  if (conversationHistory.length) body.conversation_history = conversationHistory;
+  if (systemParts.length) body.system = systemParts.join("\n\n");
+  if (params.persona) body.persona = params.persona;
+  if (params.tools) body.tools = params.tools;
+  if (params.tool_choice !== void 0) body.tool_choice = params.tool_choice;
+  const gen = {};
+  if (params.temperature !== void 0) gen.temperature = params.temperature;
+  if (params.max_tokens !== void 0) gen.maxOutputTokens = params.max_tokens;
+  if (opts.stream) gen.stream = true;
+  if (Object.keys(gen).length) body.generation_config = gen;
+  return body;
+}
+function nativeToOpenAICompletion(data) {
+  const toolCalls = data.tool_calls?.length ? data.tool_calls : void 0;
+  const message = toolCalls ? { role: "assistant", content: data.response_text || null, tool_calls: toolCalls } : { role: "assistant", content: data.response_text ?? "" };
+  const completion = {
+    id: `chatcmpl-${cryptoRandom2()}`,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1e3),
+    model: ADDIS_CHAT_MODEL2,
+    choices: [
+      {
+        index: 0,
+        message,
+        finish_reason: toolCalls ? "tool_calls" : normalizeFinishReason(data.finish_reason)
+      }
+    ],
+    usage: data.usage_metadata ? {
+      prompt_tokens: data.usage_metadata.prompt_token_count ?? 0,
+      completion_tokens: data.usage_metadata.candidates_token_count ?? 0,
+      total_tokens: data.usage_metadata.total_token_count ?? 0
+    } : void 0
+  };
+  if (data.transcription_raw || data.transcription_clean) {
+    completion.transcription = { raw: data.transcription_raw, clean: data.transcription_clean };
+  }
+  if (data.uploaded_attachments?.length) {
+    completion.uploaded_attachments = data.uploaded_attachments;
+  }
+  return completion;
+}
+function normalizeFinishReason(reason) {
+  if (typeof reason !== "string" || !reason) return "stop";
+  switch (reason.toUpperCase()) {
+    case "STOP":
+      return "stop";
+    case "MAX_TOKENS":
+      return "length";
+    case "SAFETY":
+    case "RECITATION":
+      return "content_filter";
+    case "TOOL_CALLS":
+      return "tool_calls";
+    default:
+      return reason.toLowerCase();
+  }
+}
+function cryptoRandom2() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID) return c.randomUUID();
+  return Math.random().toString(36).slice(2);
+}
+
+// src/core/camelize.ts
+function toCamel(key) {
+  return key.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function camelize(input) {
+  if (Array.isArray(input)) {
+    return input.map((item) => camelize(item));
+  }
+  if (input && typeof input === "object") {
+    const out = {};
+    for (const [key, value] of Object.entries(input)) {
+      out[toCamel(key)] = camelize(value);
+    }
+    return out;
+  }
+  return input;
+}
+
+// src/core/idempotency.ts
+var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var TIME_LEN = 10;
+var RANDOM_LEN = 16;
+function randomBytes(n) {
+  const buf = new Uint8Array(n);
+  const c = globalThis.crypto;
+  if (c?.getRandomValues) {
+    c.getRandomValues(buf);
+    return buf;
+  }
+  for (let i = 0; i < n; i++) buf[i] = Math.floor(Math.random() * 256);
+  return buf;
+}
+function encodeTime(now) {
+  let out = "";
+  for (let i = TIME_LEN - 1; i >= 0; i--) {
+    const mod = now % 32;
+    out = ENCODING[mod] + out;
+    now = (now - mod) / 32;
+  }
+  return out;
+}
+function encodeRandom() {
+  const bytes = randomBytes(RANDOM_LEN);
+  let out = "";
+  for (let i = 0; i < RANDOM_LEN; i++) {
+    out += ENCODING[bytes[i] % 32];
+  }
+  return out;
+}
+function ulid() {
+  return encodeTime(Date.now()) + encodeRandom();
+}
+
+// src/core/pagination.ts
+var CursorPage = class {
+  constructor(firstPage, fetchPage) {
+    this.firstPage = firstPage;
+    this.fetchPage = fetchPage;
+  }
+  /** Items on the first page only. */
+  get data() {
+    return this.firstPage.data;
+  }
+  get nextCursor() {
+    return this.firstPage.nextCursor;
+  }
+  async *[Symbol.asyncIterator]() {
+    let page = this.firstPage;
+    while (true) {
+      for (const item of page.data) yield item;
+      if (!page.nextCursor) return;
+      page = await this.fetchPage(page.nextCursor);
+    }
+  }
+};
+var CursorPagePromise = class {
+  constructor(load) {
+    this.load = load;
+  }
+  get inner() {
+    return this.promise ??= this.load();
+  }
+  then(onfulfilled, onrejected) {
+    return this.inner.then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.inner.catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.inner.finally(onfinally);
+  }
+  async *[Symbol.asyncIterator]() {
+    const page = await this.inner;
+    yield* page;
+  }
+};
+
+// src/lib/clip.ts
+var AddisClip = class {
+  constructor(data, fetchImpl) {
+    this.fetchImpl = fetchImpl;
+    Object.assign(this, data);
+  }
+  /** Fetch the audio bytes from the signed playback URL. */
+  async arrayBuffer() {
+    if (!this.audioUrl) throw new AddisAIError("This clip has no audioUrl to download.");
+    const res = await this.fetchImpl(this.audioUrl);
+    if (!res.ok) {
+      throw new AddisAIError(`Failed to download clip ${this.id}: HTTP ${res.status}.`);
+    }
+    return res.arrayBuffer();
+  }
+  /** Write the audio to a file on disk (Node/Bun/Deno). */
+  async toFile(path) {
+    const buffer = await this.arrayBuffer();
+    const fs = await import('fs/promises');
+    await fs.writeFile(path, Buffer.from(buffer));
+  }
+};
+
+// src/resources/voice.ts
+var VOICE_TIMEOUT_FLOOR_MS = 95e3;
+var Voice = class {
+  constructor(transport) {
+    this.transport = transport;
+    this.clips = new Clips(transport);
+  }
+  /** Synthesize speech and return the generated clip. */
+  async generate(params, opts = {}) {
+    const clientRequestId = params.clientRequestId ?? ulid();
+    const body = {
+      text: params.text,
+      language: params.language,
+      voice_id: params.voiceId,
+      output_format: params.outputFormat ?? "mp3_44100",
+      voice_settings: params.voiceSettings,
+      stream: false,
+      client_request_id: clientRequestId
+    };
+    const data = unwrapData(
+      await this.transport.request(
+        { method: "POST", path: "/api/v1/voice/generations", body, timeoutFloor: VOICE_TIMEOUT_FLOOR_MS },
+        opts
+      )
+    );
+    return new AddisClip({ ...mapClip(data), clientRequestId }, this.transport.fetch);
+  }
+  /**
+   * Streaming synthesis. The surface is stable for when the API enables it;
+   * until then it raises NotSupportedError. Use {@link Voice.generate} today.
+   */
+  async stream(_params, _opts) {
+    throw new NotSupportedError(
+      "Streaming voice synthesis is not yet available. Use voice.generate()."
+    );
+  }
+  /** Pre-flight cost estimate (and whether the wallet can cover it). */
+  async estimate(params, opts = {}) {
+    const body = {
+      text: params.text,
+      language: params.language,
+      voice_id: params.voiceId,
+      output_format: params.outputFormat ?? "mp3_44100"
+    };
+    const data = unwrapData(
+      await this.transport.request({ method: "POST", path: "/api/v1/voice/estimate", body }, opts)
+    );
+    return camelize(data);
+  }
+  /** Wallet balance and pricing for voice generation. */
+  async usage(opts = {}) {
+    const data = unwrapData(
+      await this.transport.request({ method: "GET", path: "/api/v1/voice/usage" }, opts)
+    );
+    return camelize(data);
+  }
+};
+var Clips = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  /**
+   * List generated clips. The returned value is both awaitable
+   * (`const page = await clips.list()`) and async-iterable
+   * (`for await (const clip of clips.list())` walks every page).
+   */
+  list(params = {}, opts = {}) {
+    const fetchPage = async (cursor) => {
+      const query = {
+        limit: params.limit,
+        cursor,
+        language: params.language,
+        voice_id: params.voiceId
+      };
+      const body = await this.transport.request(
+        { method: "GET", path: "/api/v1/voice/clips", query },
+        opts
+      );
+      return {
+        data: (body.data ?? []).map((c) => new AddisClip(mapClip(c), this.transport.fetch)),
+        nextCursor: body.meta?.next_cursor ?? null,
+        limit: body.meta?.limit ?? null
+      };
+    };
+    return new CursorPagePromise(async () => {
+      const first = await fetchPage(params.cursor);
+      return new CursorPage(first, (cursor) => fetchPage(cursor));
+    });
+  }
+  /** Fetch one clip by ID. */
+  async get(clipId, opts = {}) {
+    const data = unwrapData(
+      await this.transport.request({ method: "GET", path: `/api/v1/voice/clips/${encodeURIComponent(clipId)}` }, opts)
+    );
+    return new AddisClip(mapClip(data), this.transport.fetch);
+  }
+  /** Download the audio bytes for a clip. */
+  async download(clipId, opts = {}) {
+    const clip = await this.get(clipId, opts);
+    return clip.arrayBuffer();
+  }
+  /** Delete a clip. */
+  async delete(clipId, opts = {}) {
+    await this.transport.request(
+      { method: "DELETE", path: `/api/v1/voice/clips/${encodeURIComponent(clipId)}`, raw: true },
+      opts
+    );
+  }
+};
+function mapClip(raw) {
+  return {
+    id: raw.id,
+    text: raw.text ?? raw.text_preview ?? "",
+    textPreview: raw.text_preview ?? "",
+    voiceId: raw.voice_id,
+    voiceName: raw.voice_name,
+    voiceDescriptor: raw.voice_descriptor,
+    language: raw.language,
+    outputFormat: raw.output_format,
+    audioUrl: raw.audio_url ?? raw.playback?.url ?? "",
+    mimeType: raw.mime_type,
+    durationSeconds: raw.duration_seconds ?? null,
+    characterCount: raw.character_count ?? 0,
+    billableCharacters: raw.billable_characters ?? 0,
+    downloadName: raw.download_name ?? "",
+    createdAt: raw.created_at,
+    usage: raw.usage ? {
+      pricingUnit: raw.usage.pricing_unit ?? "character",
+      pricePer1000Characters: raw.usage.price_per_1000_characters ?? 0,
+      creditsUsed: raw.usage.credits_used ?? null,
+      creditsRemaining: raw.usage.credits_remaining ?? null,
+      currency: raw.usage.currency ?? "ETB"
+    } : void 0,
+    meta: raw.meta ? {
+      ignoredVoiceSettings: raw.meta.ignored_voice_settings ?? [],
+      idempotentReplay: Boolean(raw.meta.idempotent_replay)
+    } : void 0
+  };
+}
+
+// src/resources/voices.ts
+var Voices = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  /** List the voice catalog. */
+  async list(params = {}, opts = {}) {
+    const query = {
+      language: params.language,
+      gender: params.gender,
+      search: params.search,
+      include_unavailable: params.includeUnavailable
+    };
+    const data = unwrapData(
+      await this.transport.request({ method: "GET", path: "/api/v1/voice/voices", query }, opts)
+    );
+    return camelize(data);
+  }
+  /** Fetch a single voice's preview clip metadata. */
+  async preview(voiceId, opts = {}) {
+    const data = unwrapData(
+      await this.transport.request(
+        { method: "GET", path: `/api/v1/voice/voices/${encodeURIComponent(voiceId)}/preview` },
+        opts
+      )
+    );
+    return camelize(data);
+  }
+};
+
+// src/resources/speech.ts
+var Speech = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  /** Transcribe speech to text. */
+  async transcribe(params, opts = {}) {
+    const form = new FormData();
+    const { blob, filename } = toBlob(params.audio, "audio/wav");
+    form.append("audio", blob, filename || "audio.wav");
+    form.append(
+      "request_data",
+      new Blob([JSON.stringify({ language_code: params.language })], { type: "application/json" })
+    );
+    const data = unwrapData(
+      await this.transport.request({ method: "POST", path: "/api/v2/stt", form }, opts)
+    );
+    return {
+      text: data.transcription ?? "",
+      confidence: data.confidence ?? null,
+      usage: data.usage_metadata ?? null
+    };
+  }
+};
+
+// src/resources/translate.ts
+var Translate = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  /** Translate text between Amharic, Afan Oromo, and English. */
+  async create(params, opts = {}) {
+    const body = {
+      text: params.text,
+      source_language: params.from,
+      target_language: params.to
+    };
+    const data = unwrapData(await this.transport.request({ method: "POST", path: "/api/v1/translate", body }, opts));
+    return {
+      text: data.translation ?? "",
+      sourceLanguage: data.source_language ?? params.from,
+      targetLanguage: data.target_language ?? params.to,
+      quality: data.quality ?? null,
+      usage: data.usage_metadata ?? null
+    };
+  }
+};
+
+// src/resources/text-to-speech.ts
+var TextToSpeech = class {
+  constructor(voice) {
+    this.voice = voice;
+  }
+  /** Synthesize speech for a voice. Mirrors ElevenLabs `textToSpeech.convert`. */
+  convert(voiceId, params, opts) {
+    return this.voice.generate({ voiceId, ...params }, opts);
+  }
+};
+
+// src/lib/audio-stream.ts
+var AudioStream = class _AudioStream {
+  constructor(response, mode, controller) {
+    this.response = response;
+    this.mode = mode;
+    this.controller = controller;
+    this.consumed = false;
+  }
+  static fromResponse(response, controller) {
+    const contentType = (response.headers.get("content-type") || "").toLowerCase();
+    const mode = contentType.includes("ndjson") || contentType.includes("json") ? "ndjson" : "raw";
+    return new _AudioStream(response, mode, controller);
+  }
+  /** Cancel the stream and underlying request. */
+  abort() {
+    this.controller?.abort();
+  }
+  async *[Symbol.asyncIterator]() {
+    if (this.consumed) throw new AddisAIError("This stream has already been consumed.");
+    this.consumed = true;
+    if (!this.response.body) return;
+    if (this.mode === "raw") {
+      const reader = this.response.body.getReader();
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          if (value) yield value;
+        }
+      } finally {
+        reader.releaseLock();
+      }
+      return;
+    }
+    for await (const obj of parseNDJSON(this.response.body)) {
+      if (!obj) continue;
+      if (obj.status === "error" || obj.error) {
+        const message = obj.error?.message || "Audio stream failed.";
+        throw new AddisAIError(message);
+      }
+      const b64 = obj.audio_chunk ?? obj.audio;
+      if (typeof b64 === "string" && b64) yield decodeBase64(b64);
+    }
+  }
+  /** Collect every chunk into a single ArrayBuffer. */
+  async arrayBuffer() {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of this) {
+      chunks.push(chunk);
+      total += chunk.byteLength;
+    }
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const c of chunks) {
+      out.set(c, offset);
+      offset += c.byteLength;
+    }
+    return out.buffer;
+  }
+  /** Stream the audio to a file on disk (Node/Bun/Deno). */
+  async toFile(path) {
+    const fs = await import('fs');
+    const handle = fs.createWriteStream(path);
+    try {
+      for await (const chunk of this) {
+        await new Promise((resolve, reject) => {
+          handle.write(Buffer.from(chunk), (err) => err ? reject(err) : resolve());
+        });
+      }
+    } finally {
+      await new Promise((resolve) => handle.end(resolve));
+    }
+  }
+};
+function decodeBase64(b64) {
+  if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(b64, "base64"));
+  const binary = atob(b64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+
+// src/resources/legacy.ts
+var warned = false;
+function warnOnce() {
+  if (warned) return;
+  warned = true;
+  console.warn(
+    "[addisai] addis.legacy.audio is DEPRECATED. Migrate to addis.voice.generate(), which uses the current, more capable voice model. The legacy /audio endpoint may be removed in a future release."
+  );
+}
+function decodeBase642(b64) {
+  if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(b64, "base64"));
+  const binary = atob(b64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+var LegacyAudio = class {
+  constructor(audio) {
+    this.audio = audio;
+  }
+  /** Decode the base64 audio into bytes. */
+  arrayBuffer() {
+    const bytes = decodeBase642(this.audio);
+    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+  }
+  /** Write the decoded audio to disk (Node/Bun/Deno). */
+  async toFile(path) {
+    const fs = await import('fs/promises');
+    await fs.writeFile(path, Buffer.from(this.arrayBuffer()));
+  }
+};
+var LegacyAudioResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  /**
+   * @deprecated Use `addis.voice.generate(...)`.
+   * Synthesize speech via the legacy endpoint (non-streaming).
+   */
+  async generate(params, opts = {}) {
+    warnOnce();
+    const body = await this.transport.request(
+      { method: "POST", path: "/api/v1/audio", body: { text: params.text, language: params.language, stream: false } },
+      opts
+    );
+    const audio = body.audio ?? body.audio_chunk;
+    if (!audio) throw new AddisAIError("Legacy audio response did not contain audio data.");
+    return new LegacyAudio(audio);
+  }
+  /**
+   * @deprecated Use `addis.voice.generate(...)`.
+   * Stream synthesis via the legacy endpoint. Returns an {@link AudioStream} of
+   * audio byte chunks. The SDK normalizes the two legacy encodings (Amharic
+   * newline-delimited base64 JSON, Afan Oromo raw `audio/wav`) into one byte
+   * stream. New code should not depend on this.
+   */
+  async stream(params, opts = {}) {
+    warnOnce();
+    const { response, controller } = await this.transport.openStream(
+      { method: "POST", path: "/api/v1/audio", body: { text: params.text, language: params.language, stream: true } },
+      opts
+    );
+    return AudioStream.fromResponse(response, controller);
+  }
+};
+var Legacy = class {
+  constructor(transport) {
+    this.audio = new LegacyAudioResource(transport);
+  }
+};
+
+// src/client.ts
+var AddisAI = class {
+  constructor(options = {}) {
+    const apiKey = options.apiKey ?? readEnv(API_KEY_ENV_VAR);
+    if (!apiKey) {
+      throw new AddisAIError(
+        `Missing API key. Pass { apiKey } or set the ${API_KEY_ENV_VAR} environment variable.`
+      );
+    }
+    if (isBrowserLike() && !options.dangerouslyAllowBrowser) {
+      throw new AddisAIError(
+        "It looks like you're running in a browser. Exposing an Addis AI API key in client-side code is a security risk. Call the SDK from your server, or pass { dangerouslyAllowBrowser: true } if you understand the risk."
+      );
+    }
+    const resolvedFetch = options.fetch ?? globalThis.fetch;
+    if (!resolvedFetch) {
+      throw new AddisAIError(
+        `No fetch implementation found in this runtime (${detectRuntime()}). Upgrade to Node 18+ or pass a custom fetch via { fetch }.`
+      );
+    }
+    this._apiKey = apiKey;
+    this._transport = new Transport({
+      apiKey,
+      baseURL: resolveBaseURL(options.baseURL),
+      timeout: options.timeout ?? 6e4,
+      maxRetries: options.maxRetries ?? 3,
+      defaultHeaders: options.defaultHeaders ?? {},
+      defaultQuery: options.defaultQuery ?? {},
+      fetch: resolvedFetch,
+      logLevel: options.logLevel ?? "warn"
+    });
+    this.chat = new Chat(this._transport);
+    this.voice = new Voice(this._transport);
+    this.voices = new Voices(this._transport);
+    this.speech = new Speech(this._transport);
+    this.translate = new Translate(this._transport);
+    this.textToSpeech = new TextToSpeech(this.voice);
+    this.legacy = new Legacy(this._transport);
+  }
+  /** Redacted representation; never exposes the API key. */
+  toString() {
+    return `AddisAI { apiKey: "${redactApiKey(this._apiKey)}" }`;
+  }
+};
+
+// src/lib/play.ts
+async function play(audio) {
+  const bytes = audio instanceof AddisClip ? new Uint8Array(await audio.arrayBuffer()) : audio instanceof ArrayBuffer ? new Uint8Array(audio) : audio;
+  const { spawn } = await import('child_process');
+  const tryPlayer = (command, args) => new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(command, args, { stdio: ["pipe", "ignore", "ignore"] });
+    } catch {
+      return resolve(false);
+    }
+    child.on("error", () => resolve(false));
+    child.on("close", (code) => resolve(code === 0));
+    child.stdin?.on("error", () => {
+    });
+    child.stdin?.write(Buffer.from(bytes));
+    child.stdin?.end();
+  });
+  if (await tryPlayer("ffplay", ["-autoexit", "-nodisp", "-loglevel", "quiet", "-"])) return;
+  if (await tryPlayer("mpv", ["--really-quiet", "-"])) return;
+  throw new Error(
+    "play() requires ffplay (ffmpeg) or mpv on PATH. Save the clip with clip.toFile() instead."
+  );
+}
+
+// src/index.ts
+var index_default = AddisAI;
+
+exports.ADDIS_CHAT_MODEL = ADDIS_CHAT_MODEL2;
+exports.APIConnectionError = APIConnectionError;
+exports.APIConnectionTimeoutError = APIConnectionTimeoutError;
+exports.APIError = APIError;
+exports.AddisAI = AddisAI;
+exports.AddisAIError = AddisAIError;
+exports.AddisClip = AddisClip;
+exports.AudioStream = AudioStream;
+exports.AuthenticationError = AuthenticationError;
+exports.BadRequestError = BadRequestError;
+exports.ChatStream = ChatStream;
+exports.ConflictError = ConflictError;
+exports.CursorPage = CursorPage;
+exports.CursorPagePromise = CursorPagePromise;
+exports.GenerationInProgressError = GenerationInProgressError;
+exports.IdempotencyConflictError = IdempotencyConflictError;
+exports.InsufficientCreditsError = InsufficientCreditsError;
+exports.InternalServerError = InternalServerError;
+exports.LegacyAudio = LegacyAudio;
+exports.NotFoundError = NotFoundError;
+exports.NotSupportedError = NotSupportedError;
+exports.PermissionDeniedError = PermissionDeniedError;
+exports.RateLimitError = RateLimitError;
+exports.UnprocessableEntityError = UnprocessableEntityError;
+exports.default = index_default;
+exports.fileFromPath = fileFromPath;
+exports.play = play;
+exports.ulid = ulid;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map