@broberg/ai-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1416 @@
+// src/routing/tier-map.ts
+var DEFAULT_TIER_MAP = {
+  fast: { provider: "anthropic", model: "claude-haiku-4-5", transport: "http" },
+  smart: { provider: "anthropic", model: "claude-sonnet-4-6", transport: "http" },
+  powerful: { provider: "anthropic", model: "claude-opus-4-8", transport: "http" },
+  cheap: { provider: "anthropic", model: "claude-haiku-4-5", transport: "subprocess" },
+  vision: { provider: "anthropic", model: "claude-sonnet-4-6", transport: "http" },
+  embedding: { provider: "openai", model: "text-embedding-3-small", transport: "http" }
+};
+function resolveTier(tier, override, configMap) {
+  const base = configMap?.[tier] ?? DEFAULT_TIER_MAP[tier];
+  return { ...base, ...override };
+}
+
+// src/transport/http.ts
+async function httpTransport(req) {
+  if (!req.http) {
+    throw new Error("httpTransport: req.http is required for http transport");
+  }
+  const { url, method = "POST", headers, body } = req.http;
+  const res = await fetch(url, {
+    method,
+    headers,
+    body: body === void 0 ? void 0 : typeof body === "string" ? body : JSON.stringify(body)
+  });
+  const json = await res.json().catch(() => void 0);
+  return { ok: res.ok, status: res.status, json };
+}
+
+// src/transport/subprocess.ts
+function parseClaudeCliJson(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(
+      `subprocessTransport: could not parse claude -p JSON output: ${raw.slice(0, 200)}`
+    );
+  }
+  const u = parsed.usage ?? {};
+  return {
+    text: parsed.result ?? "",
+    inputTokens: u.input_tokens ?? 0,
+    outputTokens: u.output_tokens ?? 0,
+    cacheReadTokens: u.cache_read_input_tokens ?? 0,
+    cacheCreationTokens: u.cache_creation_input_tokens ?? 0,
+    costUsd: 0,
+    subprocess: true
+  };
+}
+async function subprocessTransport(req) {
+  if (!req.subprocess) {
+    throw new Error("subprocessTransport: req.subprocess is required for subprocess transport");
+  }
+  const { prompt, systemPrompt } = req.subprocess;
+  const cmd = ["claude", "-p", "--output-format", "json", "--model", req.spec.model];
+  if (systemPrompt) cmd.push("--system-prompt", systemPrompt);
+  const proc = (() => {
+    try {
+      return Bun.spawn(cmd, {
+        stdin: new Blob([prompt]),
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+    } catch (err) {
+      throw new Error(
+        `subprocessTransport: failed to spawn 'claude' \u2014 is the CLI installed and on PATH? (${String(err)})`
+      );
+    }
+  })();
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited
+  ]);
+  if (exitCode !== 0) {
+    throw new Error(
+      `subprocessTransport: claude -p exited ${exitCode}: ${stderr.slice(0, 300) || stdout.slice(0, 300)}`
+    );
+  }
+  return parseClaudeCliJson(stdout);
+}
+
+// src/providers/tools.ts
+function family(provider) {
+  if (provider === "gemini" || provider === "google") return "gemini";
+  if (provider === "anthropic") return "anthropic";
+  return "openai";
+}
+function toProviderTools(tools, provider) {
+  switch (family(provider)) {
+    case "openai":
+      return tools.map((t) => ({
+        type: "function",
+        function: { name: t.name, description: t.description, parameters: t.parameters }
+      }));
+    case "gemini":
+      return [
+        {
+          functionDeclarations: tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters
+          }))
+        }
+      ];
+    case "anthropic":
+      return tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        input_schema: t.parameters
+      }));
+    default:
+      throw new Error(`toProviderTools: unsupported provider family for "${provider}"`);
+  }
+}
+function fromProviderToolCall(raw, provider) {
+  const r = raw;
+  switch (family(provider)) {
+    case "openai": {
+      const fn = r.function ?? {};
+      return {
+        id: typeof r.id === "string" ? r.id : "",
+        name: fn.name ?? "",
+        arguments: parseArgs(fn.arguments)
+      };
+    }
+    case "gemini": {
+      const fc = r.functionCall ?? r;
+      return {
+        id: "",
+        // Gemini function calls have no id
+        name: fc.name ?? "",
+        arguments: fc.args ?? {}
+      };
+    }
+    case "anthropic": {
+      return {
+        id: typeof r.id === "string" ? r.id : "",
+        name: typeof r.name === "string" ? r.name : "",
+        arguments: r.input ?? {}
+      };
+    }
+    default:
+      throw new Error(`fromProviderToolCall: unsupported provider family for "${provider}"`);
+  }
+}
+function parseArgs(raw) {
+  if (raw === void 0 || raw === null) return {};
+  if (typeof raw === "object") return raw;
+  if (typeof raw === "string") {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+
+// src/cost/pricing.ts
+var V = "2026-06-02";
+var PRICING = {
+  // Anthropic (direct API). DEFAULT_TIER_MAP: fast/cheap=haiku, smart/vision=sonnet, powerful=opus.
+  "anthropic:claude-haiku-4-5": {
+    inputPer1M: 0.8,
+    outputPer1M: 4,
+    cacheReadPer1M: 0.08,
+    cacheWritePer1M: 1,
+    version: V
+  },
+  "anthropic:claude-sonnet-4-6": {
+    inputPer1M: 3,
+    outputPer1M: 15,
+    cacheReadPer1M: 0.3,
+    cacheWritePer1M: 3.75,
+    version: V
+  },
+  "anthropic:claude-opus-4-8": {
+    inputPer1M: 15,
+    outputPer1M: 75,
+    cacheReadPer1M: 1.5,
+    cacheWritePer1M: 18.75,
+    version: V
+  },
+  // OpenAI. embedding default tier = text-embedding-3-small (no output tokens).
+  "openai:text-embedding-3-small": { inputPer1M: 0.02, outputPer1M: 0, version: V },
+  "openai:text-embedding-3-large": { inputPer1M: 0.13, outputPer1M: 0, version: V },
+  "openai:gpt-4o": { inputPer1M: 2.5, outputPer1M: 10, version: V },
+  "openai:gpt-4o-mini": { inputPer1M: 0.15, outputPer1M: 0.6, version: V },
+  // Whisper is priced per minute, not per token — not representable here; transcribe
+  // (F5.6) computes its own cost. Listed as 0 so token-based compute never charges it.
+  "openai:whisper-1": { inputPer1M: 0, outputPer1M: 0, version: V },
+  // OpenRouter (meta-router — model slugs include the upstream vendor).
+  "openrouter:anthropic/claude-sonnet-4-6": { inputPer1M: 3, outputPer1M: 15, version: V },
+  "openrouter:anthropic/claude-haiku-4-5": { inputPer1M: 0.8, outputPer1M: 4, version: V },
+  "openrouter:google/gemini-2.5-flash": { inputPer1M: 0.3, outputPer1M: 2.5, version: V },
+  "openrouter:minimax/minimax-m2.7": {
+    inputPer1M: 0.3,
+    outputPer1M: 1.2,
+    version: `${V}-estimate`
+  },
+  // Google Gemini (direct). Image-gen model used by cms.
+  "google:gemini-2.5-flash": { inputPer1M: 0.3, outputPer1M: 2.5, version: V }
+};
+function getPrice(provider, model) {
+  return PRICING[`${provider}:${model}`];
+}
+
+// src/cost/usage.ts
+function computeCost(provider, model, inputTokens, outputTokens, cacheReadTokens = 0, cacheCreationTokens = 0) {
+  const price = getPrice(provider, model);
+  if (!price) return 0;
+  const perToken = (per1M) => per1M / 1e6;
+  const inRate = perToken(price.inputPer1M);
+  const outRate = perToken(price.outputPer1M);
+  const cacheReadRate = price.cacheReadPer1M !== void 0 ? perToken(price.cacheReadPer1M) : inRate;
+  const cacheWriteRate = price.cacheWritePer1M !== void 0 ? perToken(price.cacheWritePer1M) : inRate;
+  return inputTokens * inRate + outputTokens * outRate + cacheReadTokens * cacheReadRate + cacheCreationTokens * cacheWriteRate;
+}
+function freshUsage(args) {
+  const cacheReadTokens = args.cacheReadTokens ?? 0;
+  const cacheCreationTokens = args.cacheCreationTokens ?? 0;
+  const costUsd = args.subprocess ? 0 : computeCost(
+    args.provider,
+    args.model,
+    args.inputTokens,
+    args.outputTokens,
+    cacheReadTokens,
+    cacheCreationTokens
+  );
+  const usage = {
+    provider: args.provider,
+    model: args.model,
+    transport: args.transport,
+    inputTokens: args.inputTokens,
+    outputTokens: args.outputTokens,
+    cacheReadTokens,
+    cacheCreationTokens,
+    costUsd,
+    latencyMs: 0,
+    capability: args.capability,
+    ts: ""
+  };
+  if (args.subprocess) usage.subprocess = true;
+  return usage;
+}
+
+// src/providers/anthropic.ts
+function contentBlocks(content) {
+  if (typeof content === "string") return content;
+  return content.map((p) => {
+    if (p.type === "text") return { type: "text", text: p.text };
+    if (typeof p.image === "string" && /^https?:\/\//.test(p.image)) {
+      return { type: "image", source: { type: "url", url: p.image } };
+    }
+    const data = typeof p.image === "string" ? p.image.replace(/^data:[^;]+;base64,/, "") : Buffer.from(p.image).toString("base64");
+    return {
+      type: "image",
+      source: { type: "base64", media_type: p.mimeType ?? "image/png", data }
+    };
+  });
+}
+function flattenForSubprocess(messages) {
+  const sys = [];
+  const turns = [];
+  for (const m of messages) {
+    const text = typeof m.content === "string" ? m.content : m.content.map((p) => p.type === "text" ? p.text : "[image]").join(" ");
+    if (m.role === "system") sys.push(text);
+    else turns.push(`${m.role}: ${text}`);
+  }
+  return { prompt: turns.join("\n\n"), system: sys.length ? sys.join("\n") : void 0 };
+}
+function anthropicAdapter(config = {}) {
+  const baseUrl = config.baseUrl ?? "https://api.anthropic.com";
+  const version = config.anthropicVersion ?? "2023-06-01";
+  async function chatHttp(req) {
+    const apiKey = config.apiKey ?? process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) throw new Error("anthropic adapter: API key not set (env ANTHROPIC_API_KEY)");
+    const system = [];
+    const messages = [];
+    for (const m of req.messages) {
+      if (m.role === "system") {
+        system.push(typeof m.content === "string" ? m.content : "");
+      } else {
+        messages.push({ role: m.role === "assistant" ? "assistant" : "user", content: contentBlocks(m.content) });
+      }
+    }
+    const body = {
+      model: req.spec.model,
+      max_tokens: req.maxTokens ?? 1024,
+      // Anthropic requires max_tokens
+      messages
+    };
+    if (system.length > 0) body.system = system.join("\n");
+    if (req.tools) body.tools = toProviderTools(req.tools, "anthropic");
+    if (req.temperature !== void 0) body.temperature = req.temperature;
+    const res = await httpTransport({
+      spec: req.spec,
+      http: {
+        url: `${baseUrl}/v1/messages`,
+        headers: {
+          "content-type": "application/json",
+          "x-api-key": apiKey,
+          "anthropic-version": version
+        },
+        body
+      }
+    });
+    if (!res.ok) throw new Error(`anthropic ${res.status}: ${JSON.stringify(res.json).slice(0, 300)}`);
+    const data = res.json;
+    const blocks = data.content ?? [];
+    const text = blocks.filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text).join("");
+    const toolCalls = blocks.filter((b) => b.type === "tool_use").map((b) => fromProviderToolCall(b, "anthropic"));
+    const usage = freshUsage({
+      provider: "anthropic",
+      model: req.spec.model,
+      transport: "http",
+      capability: "chat",
+      inputTokens: data.usage?.input_tokens ?? 0,
+      outputTokens: data.usage?.output_tokens ?? 0,
+      cacheReadTokens: data.usage?.cache_read_input_tokens ?? 0,
+      cacheCreationTokens: data.usage?.cache_creation_input_tokens ?? 0
+    });
+    const result = { text, usage };
+    if (toolCalls.length > 0) result.toolCalls = toolCalls;
+    return result;
+  }
+  async function chatSubprocess(req) {
+    const { prompt, system } = flattenForSubprocess(req.messages);
+    const r = await subprocessTransport({ spec: req.spec, subprocess: { prompt, systemPrompt: system } });
+    const usage = freshUsage({
+      provider: "anthropic",
+      model: req.spec.model,
+      transport: "subprocess",
+      capability: "chat",
+      inputTokens: r.inputTokens,
+      outputTokens: r.outputTokens,
+      cacheReadTokens: r.cacheReadTokens,
+      cacheCreationTokens: r.cacheCreationTokens,
+      subprocess: true
+    });
+    return { text: r.text, usage };
+  }
+  async function chat(req) {
+    return req.spec.transport === "subprocess" ? chatSubprocess(req) : chatHttp(req);
+  }
+  return { name: "anthropic", chat, vision: chat };
+}
+
+// src/providers/openai-compatible.ts
+function toOpenAIMessage(m) {
+  if (typeof m.content === "string") {
+    const base = { role: m.role, content: m.content };
+    if (m.toolCallId) base.tool_call_id = m.toolCallId;
+    return base;
+  }
+  const content = m.content.map((p) => {
+    if (p.type === "text") return { type: "text", text: p.text };
+    const url = typeof p.image === "string" ? p.image : `data:${p.mimeType ?? "image/png"};base64,${Buffer.from(p.image).toString("base64")}`;
+    return { type: "image_url", image_url: { url } };
+  });
+  return { role: m.role, content };
+}
+function makeOpenAICompatibleAdapter(config) {
+  async function chat(req) {
+    const apiKey = config.apiKey ?? process.env[`${config.name.toUpperCase()}_API_KEY`];
+    if (!apiKey) {
+      throw new Error(`${config.name} adapter: API key not set (env ${config.name.toUpperCase()}_API_KEY)`);
+    }
+    const body = {
+      model: req.spec.model,
+      messages: req.messages.map(toOpenAIMessage)
+    };
+    if (req.tools) body.tools = toProviderTools(req.tools, "openai");
+    if (req.maxTokens !== void 0) body.max_tokens = req.maxTokens;
+    if (req.temperature !== void 0) body.temperature = req.temperature;
+    const res = await httpTransport({
+      spec: req.spec,
+      http: {
+        url: `${config.baseUrl}/chat/completions`,
+        headers: {
+          "content-type": "application/json",
+          Authorization: `Bearer ${apiKey}`,
+          ...config.extraHeaders
+        },
+        body
+      }
+    });
+    if (!res.ok) {
+      throw new Error(`${config.name} ${res.status}: ${JSON.stringify(res.json).slice(0, 300)}`);
+    }
+    const data = res.json;
+    const msg = data.choices?.[0]?.message;
+    const text = msg?.content ?? "";
+    const toolCalls = msg?.tool_calls?.map(
+      (tc) => fromProviderToolCall(tc, "openai")
+    );
+    const usage = freshUsage({
+      provider: config.name,
+      model: req.spec.model,
+      transport: "http",
+      capability: "chat",
+      inputTokens: data.usage?.prompt_tokens ?? 0,
+      outputTokens: data.usage?.completion_tokens ?? 0
+    });
+    const result = { text, usage };
+    if (toolCalls && toolCalls.length > 0) result.toolCalls = toolCalls;
+    return result;
+  }
+  return {
+    name: config.name,
+    chat,
+    // gpt-4o-class models are multimodal — vision shares the chat path.
+    vision: chat
+  };
+}
+
+// src/providers/openai.ts
+function openaiAdapter(config = {}) {
+  const baseUrl = config.baseUrl ?? "https://api.openai.com/v1";
+  const base = makeOpenAICompatibleAdapter({ name: "openai", baseUrl, apiKey: config.apiKey });
+  async function embedding(req) {
+    const apiKey = config.apiKey ?? process.env.OPENAI_API_KEY;
+    if (!apiKey) throw new Error("openai adapter: API key not set (env OPENAI_API_KEY)");
+    const res = await httpTransport({
+      spec: req.spec,
+      http: {
+        url: `${baseUrl}/embeddings`,
+        headers: { "content-type": "application/json", Authorization: `Bearer ${apiKey}` },
+        body: { model: req.spec.model, input: req.input }
+      }
+    });
+    if (!res.ok) {
+      throw new Error(`openai ${res.status}: ${JSON.stringify(res.json).slice(0, 300)}`);
+    }
+    const data = res.json;
+    const vectors = (data.data ?? []).map((d) => d.embedding);
+    const usage = freshUsage({
+      provider: "openai",
+      model: req.spec.model,
+      transport: "http",
+      capability: "embedding",
+      inputTokens: data.usage?.prompt_tokens ?? 0,
+      outputTokens: 0
+    });
+    return { vectors, usage };
+  }
+  async function transcribe(req) {
+    const apiKey = config.apiKey ?? process.env.OPENAI_API_KEY;
+    if (!apiKey) throw new Error("openai adapter: API key not set (env OPENAI_API_KEY)");
+    const form = new FormData();
+    form.append("file", new Blob([req.audio]), "audio");
+    form.append("model", req.spec.model);
+    if (req.language) form.append("language", req.language);
+    const fetchImpl = config.fetch ?? fetch;
+    const res = await fetchImpl(`${baseUrl}/audio/transcriptions`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${apiKey}` },
+      body: form
+    });
+    if (!res.ok) {
+      throw new Error(`openai ${res.status}: ${(await res.text().catch(() => "")).slice(0, 200)}`);
+    }
+    const data = await res.json();
+    const usage = freshUsage({
+      provider: "openai",
+      model: req.spec.model,
+      transport: "http",
+      capability: "transcribe",
+      inputTokens: 0,
+      outputTokens: 0
+      // Whisper is per-minute, not token-priced; cost stays 0 for v1.
+    });
+    return { text: data.text ?? "", usage };
+  }
+  return { ...base, embedding, transcribe };
+}
+
+// src/providers/gemini.ts
+function partsFrom(content) {
+  if (typeof content === "string") return [{ text: content }];
+  return content.map((p) => {
+    if (p.type === "text") return { text: p.text };
+    const data = typeof p.image === "string" ? p.image.replace(/^data:[^;]+;base64,/, "") : Buffer.from(p.image).toString("base64");
+    return { inlineData: { mimeType: p.mimeType ?? "image/png", data } };
+  });
+}
+function geminiAdapter(config = {}) {
+  const baseUrl = config.baseUrl ?? "https://generativelanguage.googleapis.com/v1beta";
+  async function chat(req) {
+    const apiKey = config.apiKey ?? process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY;
+    if (!apiKey) {
+      throw new Error("gemini adapter: API key not set (env GOOGLE_API_KEY)");
+    }
+    const systemParts = [];
+    const contents = [];
+    for (const m of req.messages) {
+      if (m.role === "system") {
+        systemParts.push(...partsFrom(m.content));
+      } else {
+        contents.push({
+          role: m.role === "assistant" ? "model" : "user",
+          parts: partsFrom(m.content)
+        });
+      }
+    }
+    const body = { contents };
+    if (systemParts.length > 0) body.systemInstruction = { parts: systemParts };
+    if (req.tools) body.tools = toProviderTools(req.tools, "gemini");
+    const genConfig = {};
+    if (req.maxTokens !== void 0) genConfig.maxOutputTokens = req.maxTokens;
+    if (req.temperature !== void 0) genConfig.temperature = req.temperature;
+    if (Object.keys(genConfig).length > 0) body.generationConfig = genConfig;
+    const res = await httpTransport({
+      spec: req.spec,
+      http: {
+        url: `${baseUrl}/models/${req.spec.model}:generateContent?key=${encodeURIComponent(apiKey)}`,
+        headers: { "content-type": "application/json" },
+        body
+      }
+    });
+    if (!res.ok) {
+      throw new Error(`gemini ${res.status}: ${JSON.stringify(res.json).slice(0, 300)}`);
+    }
+    const data = res.json;
+    const parts = data.candidates?.[0]?.content?.parts ?? [];
+    const text = parts.filter((p) => typeof p.text === "string").map((p) => p.text).join("");
+    const toolCalls = parts.filter((p) => p.functionCall).map((p) => fromProviderToolCall({ functionCall: p.functionCall }, "gemini"));
+    const usage = freshUsage({
+      provider: "gemini",
+      model: req.spec.model,
+      transport: "http",
+      capability: "chat",
+      inputTokens: data.usageMetadata?.promptTokenCount ?? 0,
+      outputTokens: data.usageMetadata?.candidatesTokenCount ?? 0
+    });
+    const result = { text, usage };
+    if (toolCalls.length > 0) result.toolCalls = toolCalls;
+    return result;
+  }
+  return { name: "gemini", chat, vision: chat };
+}
+
+// src/providers/deepinfra.ts
+function deepinfraAdapter(config = {}) {
+  return makeOpenAICompatibleAdapter({
+    name: "deepinfra",
+    baseUrl: config.baseUrl ?? "https://api.deepinfra.com/v1/openai",
+    apiKey: config.apiKey
+  });
+}
+
+// src/providers/openrouter.ts
+function openrouterAdapter(config = {}) {
+  return makeOpenAICompatibleAdapter({
+    name: "openrouter",
+    baseUrl: config.baseUrl ?? "https://openrouter.ai/api/v1",
+    apiKey: config.apiKey,
+    extraHeaders: {
+      "HTTP-Referer": config.referer ?? "https://broberg.ai",
+      "X-Title": config.title ?? "@broberg/ai-sdk"
+    }
+  });
+}
+
+// src/providers/fal.ts
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function falAdapter(config = {}) {
+  const doFetch = config.fetch ?? fetch;
+  const syncBase = config.syncBaseUrl ?? "https://fal.run";
+  const queueBase = config.queueBaseUrl ?? "https://queue.fal.run";
+  const pollIntervalMs = config.pollIntervalMs ?? 2e3;
+  const timeoutMs = config.timeoutMs ?? 6e4;
+  async function image(req) {
+    const apiKey = config.apiKey ?? process.env.FAL_KEY;
+    if (!apiKey) throw new Error("fal adapter: FAL_KEY not set");
+    const headers = { "content-type": "application/json", Authorization: `Key ${apiKey}` };
+    const body = { prompt: req.prompt };
+    if (req.width !== void 0 && req.height !== void 0) {
+      body.image_size = { width: req.width, height: req.height };
+    }
+    const mode = config.mode ?? "sync";
+    const url = await (mode === "sync" ? runSync(req.spec.model, headers, body) : runQueue(req.spec.model, headers, body));
+    const usage = freshUsage({
+      provider: "fal",
+      model: req.spec.model,
+      transport: "http",
+      capability: "image",
+      inputTokens: 0,
+      outputTokens: 0
+    });
+    return { url, usage };
+  }
+  async function runSync(model, headers, body) {
+    const res = await doFetch(`${syncBase}/${model}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      throw new Error(`fal ${res.status}: ${(await res.text().catch(() => "")).slice(0, 200)}`);
+    }
+    const data = await res.json();
+    const out = data.images?.[0]?.url;
+    if (!out) throw new Error(`fal: no image url in response`);
+    return out;
+  }
+  async function runQueue(model, headers, body) {
+    const submitRes = await doFetch(`${queueBase}/${model}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (!submitRes.ok) {
+      throw new Error(`fal queue submit ${submitRes.status}`);
+    }
+    const submit = await submitRes.json();
+    const statusUrl = submit.status_url;
+    const responseUrl = submit.response_url;
+    if (!statusUrl || !responseUrl) throw new Error("fal queue: missing status/response url");
+    const deadline = Date.now() + timeoutMs;
+    for (; ; ) {
+      const statusRes = await doFetch(statusUrl, { headers });
+      const status = await statusRes.json();
+      if (status.status === "COMPLETED") break;
+      if (status.status === "FAILED") throw new Error("fal queue: generation FAILED");
+      if (Date.now() >= deadline) throw new Error(`fal queue: timed out after ${timeoutMs}ms`);
+      await sleep(pollIntervalMs);
+    }
+    const resultRes = await doFetch(responseUrl, { headers });
+    const result = await resultRes.json();
+    const out = result.images?.[0]?.url;
+    if (!out) throw new Error("fal queue: no image url in result");
+    return out;
+  }
+  return { name: "fal", image };
+}
+
+// src/providers/registry.ts
+var defaultProviders = {
+  anthropic: anthropicAdapter(),
+  openai: openaiAdapter(),
+  gemini: geminiAdapter(),
+  deepinfra: deepinfraAdapter(),
+  openrouter: openrouterAdapter(),
+  fal: falAdapter()
+};
+
+// src/cost/budget.ts
+var BudgetExceededError = class extends Error {
+  kind;
+  limit;
+  spent;
+  requested;
+  constructor(kind, limit, spent, requested) {
+    super(
+      `Budget exceeded (${kind}): this call's estimated $${requested.toFixed(6)} ` + (kind === "rolling" ? `+ $${spent.toFixed(6)} already spent exceeds the $${limit.toFixed(6)} rolling ceiling` : `exceeds the $${limit.toFixed(6)} per-call ceiling`)
+    );
+    this.name = "BudgetExceededError";
+    this.kind = kind;
+    this.limit = limit;
+    this.spent = spent;
+    this.requested = requested;
+  }
+};
+var BudgetGuard = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  spentUsd = 0;
+  /** Throws BudgetExceededError if `requested` would breach the per-call ceiling
+   *  or push the rolling total past its ceiling. Call before firing the request. */
+  check(requested) {
+    const { perCallUsd, rollingUsd } = this.config;
+    if (perCallUsd !== void 0 && requested > perCallUsd) {
+      throw new BudgetExceededError("per-call", perCallUsd, this.spentUsd, requested);
+    }
+    if (rollingUsd !== void 0 && this.spentUsd + requested > rollingUsd) {
+      throw new BudgetExceededError("rolling", rollingUsd, this.spentUsd, requested);
+    }
+  }
+  /** Add an actual cost to the running total (after a successful call). */
+  record(actual) {
+    this.spentUsd += actual;
+  }
+  get totalSpent() {
+    return this.spentUsd;
+  }
+};
+
+// src/capabilities/vision.ts
+var VISION_DEFAULT_TIER = "vision";
+function buildVisionMessages(input) {
+  return [
+    {
+      role: "user",
+      content: [
+        { type: "text", text: input.prompt },
+        { type: "image", image: input.image, mimeType: input.mimeType }
+      ]
+    }
+  ];
+}
+
+// src/capabilities/translate.ts
+var TRANSLATE_DEFAULT_TIER = "fast";
+var TRANSLATE_SYSTEM = "You are a translation engine. Translate the user's text only. Return the translation and nothing else \u2014 no preamble, no quotes.";
+function buildTranslateMessages(input) {
+  const fromClause = input.from ? ` from ${input.from}` : "";
+  return [
+    { role: "system", content: TRANSLATE_SYSTEM },
+    { role: "user", content: `Translate${fromClause} to ${input.to}:
+
+${input.text}` }
+  ];
+}
+
+// src/capabilities/embedding.ts
+var EMBEDDING_DEFAULT_TIER = "embedding";
+
+// src/capabilities/transcribe.ts
+var DEFAULT_TRANSCRIBE_SPEC = {
+  provider: "openai",
+  model: "whisper-1",
+  transport: "http"
+};
+async function resolveAudio(audio, fetchImpl = fetch) {
+  if (typeof audio !== "string") return audio;
+  if (!/^https?:\/\//.test(audio)) {
+    throw new Error("transcribe: string audio must be an http(s) URL (or pass raw bytes)");
+  }
+  const res = await fetchImpl(audio);
+  if (!res.ok) throw new Error(`transcribe: failed to fetch audio (${res.status})`);
+  return new Uint8Array(await res.arrayBuffer());
+}
+
+// src/capabilities/contracts/index.ts
+function parseJsonLoose(text) {
+  const fenced = text.replace(/```(?:json)?/gi, "").trim();
+  const start = fenced.search(/[[{]/);
+  if (start === -1) throw new Error("no JSON found in model output");
+  const slice = fenced.slice(start);
+  const lastObj = slice.lastIndexOf("}");
+  const lastArr = slice.lastIndexOf("]");
+  const end = Math.max(lastObj, lastArr);
+  return JSON.parse(slice.slice(0, end + 1));
+}
+function makeContracts(client) {
+  return {
+    async mockup(input) {
+      const constraints = input.constraints ? `
+
+Constraints:
+${input.constraints}` : "";
+      const res = await client.chat({
+        system: "You are a UI mockup generator. Output a single self-contained HTML document using Tailwind CSS utility classes. Return ONLY the HTML \u2014 no markdown, no prose.",
+        prompt: `Build a UI mockup for:
+${input.description}${constraints}`,
+        tier: input.tier ?? "smart",
+        purpose: input.purpose ?? "contract:mockup"
+      });
+      return { html: res.text, usage: res.usage };
+    },
+    async design(input) {
+      const res = await client.vision({
+        image: input.screenshot,
+        prompt: `You are a design-iteration engine. Given this screenshot, apply the instructions and return a single self-contained HTML document (Tailwind), ONLY the HTML.
+
+Instructions:
+${input.instructions}`,
+        tier: input.tier ?? "powerful",
+        purpose: input.purpose ?? "contract:design"
+      });
+      return { html: res.text, usage: res.usage };
+    },
+    async extract(input) {
+      const base = "You are a structured-data extractor. Extract the requested data from the text and return ONLY valid JSON \u2014 no markdown, no prose." + (input.instructions ? `
+
+${input.instructions}` : "");
+      const run = async (reinforce) => {
+        const res2 = await client.chat({
+          system: reinforce ? `${base}
+
+Your previous output was not valid JSON. Return ONLY parseable JSON.` : base,
+          prompt: input.text,
+          tier: input.tier ?? "smart",
+          purpose: input.purpose ?? "contract:extract"
+        });
+        return res2;
+      };
+      let res = await run(false);
+      try {
+        return { data: input.schema.parse(parseJsonLoose(res.text)), usage: res.usage };
+      } catch {
+        res = await run(true);
+        return { data: input.schema.parse(parseJsonLoose(res.text)), usage: res.usage };
+      }
+    },
+    async classify(input) {
+      const res = await client.chat({
+        system: 'You are a zero-shot classifier. Choose exactly one label from the provided list. Return ONLY JSON: {"label": "<one of the labels>", "confidence": <0..1>}.',
+        prompt: `Labels: ${JSON.stringify(input.labels)}
+
+Text:
+${input.text}`,
+        tier: input.tier ?? "cheap",
+        purpose: input.purpose ?? "contract:classify"
+      });
+      const parsed = parseJsonLoose(res.text);
+      const label = input.labels.includes(parsed.label ?? "") ? parsed.label : input.labels[0] ?? "";
+      const confidence = typeof parsed.confidence === "number" ? parsed.confidence : 0;
+      return { label, confidence, usage: res.usage };
+    },
+    async rerank(input) {
+      const res = await client.chat({
+        system: 'You are a relevance reranker. Score each item 0..1 for relevance to the query and return ONLY JSON: [{"item": "<verbatim item>", "score": <0..1>}], ordered by score desc.',
+        prompt: `Query: ${input.query}
+
+Items:
+${JSON.stringify(input.items)}`,
+        tier: input.tier ?? "fast",
+        purpose: input.purpose ?? "contract:rerank"
+      });
+      const raw = parseJsonLoose(res.text);
+      const ranked = (Array.isArray(raw) ? raw : []).map((r) => ({ item: String(r.item ?? ""), score: typeof r.score === "number" ? r.score : 0 })).sort((a, b) => b.score - a.score);
+      return { ranked, usage: res.usage };
+    }
+  };
+}
+
+// src/schema/inputs.ts
+import { z } from "zod";
+var transportSchema = z.enum(["http", "subprocess"]);
+var tierSchema = z.enum([
+  "fast",
+  "smart",
+  "powerful",
+  "cheap",
+  "vision",
+  "embedding"
+]);
+var tierSpecSchema = z.object({
+  provider: z.string(),
+  model: z.string(),
+  transport: transportSchema
+});
+var toolSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  parameters: z.record(z.unknown())
+});
+var toolCallSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  arguments: z.record(z.unknown())
+});
+var contentPartSchema = z.union([
+  z.object({ type: z.literal("text"), text: z.string() }),
+  z.object({
+    type: z.literal("image"),
+    image: z.union([z.string(), z.instanceof(Uint8Array)]),
+    mimeType: z.string().optional()
+  })
+]);
+var messageSchema = z.object({
+  role: z.enum(["system", "user", "assistant", "tool"]),
+  content: z.union([z.string(), z.array(contentPartSchema)]),
+  toolCalls: z.array(toolCallSchema).optional(),
+  toolCallId: z.string().optional()
+});
+var callOptions = {
+  tier: tierSchema.optional(),
+  override: tierSpecSchema.partial().optional(),
+  fallback: z.array(z.union([tierSchema, tierSpecSchema])).optional(),
+  purpose: z.string().optional()
+};
+var chatInputSchema = z.object({
+  prompt: z.string().optional(),
+  messages: z.array(messageSchema).optional(),
+  system: z.string().optional(),
+  tools: z.array(toolSchema).optional(),
+  maxTokens: z.number().int().positive().optional(),
+  temperature: z.number().min(0).max(2).optional(),
+  ...callOptions
+});
+var visionInputSchema = z.object({
+  image: z.union([z.string(), z.instanceof(Uint8Array)]),
+  prompt: z.string(),
+  mimeType: z.string().optional(),
+  ...callOptions
+});
+var translateInputSchema = z.object({
+  text: z.string(),
+  to: z.string(),
+  from: z.string().optional(),
+  ...callOptions
+});
+var imageInputSchema = z.object({
+  prompt: z.string(),
+  width: z.number().int().positive().optional(),
+  height: z.number().int().positive().optional(),
+  ...callOptions
+});
+var embeddingInputSchema = z.object({
+  text: z.union([z.string(), z.array(z.string())]),
+  ...callOptions
+});
+var transcribeInputSchema = z.object({
+  /** Audio URL or raw bytes. */
+  audio: z.union([z.string(), z.instanceof(Uint8Array)]),
+  language: z.string().optional(),
+  ...callOptions
+});
+var budgetSchema = z.object({
+  perCallUsd: z.number().positive().optional(),
+  rollingUsd: z.number().positive().optional()
+});
+var aiConfigSchema = z.object({
+  defaults: z.record(tierSchema, tierSpecSchema).optional(),
+  // Functions can't be deeply validated — z.custom asserts the TS type and
+  // passes the value through untouched.
+  providers: z.record(z.string(), z.custom()).optional(),
+  costSink: z.custom().optional(),
+  budget: budgetSchema.optional()
+});
+
+// src/client.ts
+var DEFAULT_IMAGE_SPEC = {
+  provider: "fal",
+  model: "fal-ai/flux/schnell",
+  transport: "http"
+};
+function createAI(config = {}) {
+  const cfg = aiConfigSchema.parse(config);
+  const providers = cfg.providers ?? defaultProviders;
+  const budget = cfg.budget ? new BudgetGuard(cfg.budget) : void 0;
+  const estTokens = (s) => Math.ceil(s.length / 4);
+  function preflight(spec, estInTokens, estOutTokens) {
+    if (!budget) return;
+    budget.check(computeCost(spec.provider, spec.model, estInTokens, estOutTokens));
+  }
+  function settle(usage) {
+    if (budget) budget.record(usage.costUsd);
+  }
+  function pickProvider(name) {
+    const adapter = providers[name];
+    if (!adapter) {
+      throw new Error(
+        `createAI: no provider adapter registered for "${name}". Registered: ${Object.keys(providers).join(", ") || "(none)"}`
+      );
+    }
+    return adapter;
+  }
+  function enrich(usage, capability, tier, purpose, latencyMs) {
+    usage.capability = capability;
+    if (tier) usage.tier = tier;
+    if (purpose) usage.purpose = purpose;
+    usage.latencyMs = Math.round(latencyMs);
+    if (!usage.ts) usage.ts = (/* @__PURE__ */ new Date()).toISOString();
+    return usage;
+  }
+  async function report(usage) {
+    if (!cfg.costSink) return;
+    try {
+      await cfg.costSink.record(usage);
+    } catch {
+    }
+  }
+  function toMessages(input) {
+    if (input.messages && input.messages.length > 0) return input.messages;
+    const msgs = [];
+    if (input.system) msgs.push({ role: "system", content: input.system });
+    msgs.push({ role: "user", content: input.prompt ?? "" });
+    return msgs;
+  }
+  const client = {
+    async chat(input) {
+      input = chatInputSchema.parse(input);
+      const spec = resolveTier(input.tier ?? "smart", input.override, cfg.defaults);
+      const adapter = pickProvider(spec.provider);
+      if (!adapter.chat) {
+        throw new Error(`createAI: provider "${spec.provider}" does not support chat`);
+      }
+      const messages = toMessages(input);
+      const estIn = messages.reduce(
+        (n, m) => n + estTokens(typeof m.content === "string" ? m.content : JSON.stringify(m.content)),
+        0
+      );
+      preflight(spec, estIn, input.maxTokens ?? 512);
+      const t0 = performance.now();
+      const res = await adapter.chat({
+        messages,
+        spec,
+        tools: input.tools,
+        maxTokens: input.maxTokens,
+        temperature: input.temperature
+      });
+      enrich(res.usage, "chat", input.tier ?? "smart", input.purpose, performance.now() - t0);
+      settle(res.usage);
+      await report(res.usage);
+      return res;
+    },
+    async vision(input) {
+      input = visionInputSchema.parse(input);
+      const spec = resolveTier(input.tier ?? VISION_DEFAULT_TIER, input.override, cfg.defaults);
+      const adapter = pickProvider(spec.provider);
+      if (!adapter.vision) {
+        throw new Error(`createAI: provider "${spec.provider}" does not support vision`);
+      }
+      const messages = buildVisionMessages(input);
+      preflight(spec, estTokens(input.prompt) + 1e3, 512);
+      const t0 = performance.now();
+      const res = await adapter.vision({ messages, spec });
+      enrich(res.usage, "vision", input.tier ?? VISION_DEFAULT_TIER, input.purpose, performance.now() - t0);
+      settle(res.usage);
+      await report(res.usage);
+      return res;
+    },
+    async translate(input) {
+      input = translateInputSchema.parse(input);
+      const spec = resolveTier(input.tier ?? TRANSLATE_DEFAULT_TIER, input.override, cfg.defaults);
+      const adapter = pickProvider(spec.provider);
+      if (!adapter.chat) {
+        throw new Error(`createAI: provider "${spec.provider}" does not support chat (translate routes through chat)`);
+      }
+      const messages = buildTranslateMessages(input);
+      const estIn = estTokens(input.text) + 40;
+      preflight(spec, estIn, estIn);
+      const t0 = performance.now();
+      const res = await adapter.chat({ messages, spec });
+      enrich(res.usage, "translate", input.tier ?? TRANSLATE_DEFAULT_TIER, input.purpose, performance.now() - t0);
+      settle(res.usage);
+      await report(res.usage);
+      return { text: res.text, usage: res.usage };
+    },
+    async image(input) {
+      input = imageInputSchema.parse(input);
+      const spec = { ...DEFAULT_IMAGE_SPEC, ...input.override };
+      const adapter = pickProvider(spec.provider);
+      if (!adapter.image) {
+        throw new Error(`createAI: provider "${spec.provider}" does not support image`);
+      }
+      preflight(spec, 0, 0);
+      const t0 = performance.now();
+      const res = await adapter.image({
+        prompt: input.prompt,
+        spec,
+        width: input.width,
+        height: input.height
+      });
+      enrich(res.usage, "image", void 0, input.purpose, performance.now() - t0);
+      settle(res.usage);
+      await report(res.usage);
+      return res;
+    },
+    async embedding(input) {
+      input = embeddingInputSchema.parse(input);
+      const spec = resolveTier(input.tier ?? EMBEDDING_DEFAULT_TIER, input.override, cfg.defaults);
+      const adapter = pickProvider(spec.provider);
+      if (!adapter.embedding) {
+        throw new Error(`createAI: provider "${spec.provider}" does not support embedding`);
+      }
+      const text = Array.isArray(input.text) ? input.text : [input.text];
+      preflight(spec, text.reduce((n, t) => n + estTokens(t), 0), 0);
+      const t0 = performance.now();
+      const res = await adapter.embedding({ input: text, spec });
+      enrich(res.usage, "embedding", input.tier ?? EMBEDDING_DEFAULT_TIER, input.purpose, performance.now() - t0);
+      settle(res.usage);
+      await report(res.usage);
+      return res;
+    },
+    async transcribe(input) {
+      input = transcribeInputSchema.parse(input);
+      const spec = { ...DEFAULT_TRANSCRIBE_SPEC, ...input.override };
+      const adapter = pickProvider(spec.provider);
+      if (!adapter.transcribe) {
+        throw new Error(`createAI: provider "${spec.provider}" does not support transcribe`);
+      }
+      const audio = await resolveAudio(input.audio);
+      preflight(spec, 0, 0);
+      const t0 = performance.now();
+      const res = await adapter.transcribe({ audio, language: input.language, spec });
+      enrich(res.usage, "transcribe", void 0, input.purpose, performance.now() - t0);
+      settle(res.usage);
+      await report(res.usage);
+      return res;
+    },
+    // Replaced below with the real prompt-contracts (needs the client itself).
+    contracts: void 0
+  };
+  client.contracts = makeContracts(client);
+  return client;
+}
+
+// src/providers/stub.ts
+function stubUsage(provider, model, transport, capability) {
+  return {
+    provider,
+    model,
+    transport,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheCreationTokens: 0,
+    costUsd: 0,
+    latencyMs: 0,
+    capability,
+    // ts is supplied by the caller-side at real call time; stub uses a fixed marker
+    // ('' avoids Date.now() — keeps the stub pure/deterministic for tests).
+    ts: ""
+  };
+}
+function lastUserText(req) {
+  for (let i = req.messages.length - 1; i >= 0; i--) {
+    const m = req.messages[i];
+    if (m && m.role === "user") {
+      return typeof m.content === "string" ? m.content : m.content.map((p) => p.type === "text" ? p.text : "[image]").join(" ");
+    }
+  }
+  return "";
+}
+var anthropicApiAdapter = {
+  name: "anthropic",
+  async chat(req) {
+    return {
+      text: `[stub:anthropic-api] ${lastUserText(req)}`,
+      usage: stubUsage("anthropic", req.spec.model, "http", "chat")
+    };
+  },
+  async vision(req) {
+    return {
+      text: `[stub:anthropic-api:vision] ${lastUserText(req)}`,
+      usage: stubUsage("anthropic", req.spec.model, "http", "vision")
+    };
+  }
+};
+var anthropicSubprocessAdapter = {
+  name: "anthropic",
+  async chat(req) {
+    const usage = stubUsage("anthropic", req.spec.model, "subprocess", "chat");
+    usage.subprocess = true;
+    return { text: `[stub:anthropic-subprocess] ${lastUserText(req)}`, usage };
+  }
+};
+var openaiStubAdapter = {
+  name: "openai",
+  async chat(req) {
+    return {
+      text: `[stub:openai] ${lastUserText(req)}`,
+      usage: stubUsage("openai", req.spec.model, "http", "chat")
+    };
+  },
+  async embedding(req) {
+    return {
+      vectors: req.input.map(() => [0, 0, 0]),
+      usage: stubUsage("openai", req.spec.model, "http", "embedding")
+    };
+  }
+};
+var falStubAdapter = {
+  name: "fal",
+  async image(req) {
+    return {
+      url: `https://stub.fal/${encodeURIComponent(req.prompt).slice(0, 32)}.png`,
+      usage: stubUsage("fal", req.spec.model, "http", "image")
+    };
+  }
+};
+var stubProviders = {
+  anthropic: anthropicApiAdapter,
+  openai: openaiStubAdapter,
+  fal: falStubAdapter
+};
+
+// src/version.ts
+var VERSION = "0.1.0";
+var SDK_TAG = "@broberg/ai-sdk@0.1.0";
+
+// src/cost/sinks/noop.ts
+var noopSink = {
+  record() {
+  }
+};
+
+// src/cost/sinks/multi.ts
+function multiSink(sinks) {
+  return {
+    async record(usage) {
+      await Promise.allSettled(sinks.map(async (s) => s.record(usage)));
+    }
+  };
+}
+
+// src/cost/sinks/upmetrics.ts
+function upmetricsSink(config) {
+  const doFetch = config.fetch ?? fetch;
+  const url = `${config.baseUrl.replace(/\/$/, "")}/api/agent`;
+  return {
+    async record(usage) {
+      try {
+        const startedAt = usage.ts || (/* @__PURE__ */ new Date()).toISOString();
+        const endedAt = new Date(
+          new Date(startedAt).getTime() + (usage.latencyMs || 0)
+        ).toISOString();
+        const agentKind = config.agentKind ?? (usage.capability === "embedding" ? "embedding" : "chatbot");
+        const body = {
+          mode: "record",
+          agent_kind: agentKind,
+          agent_name: config.agentName,
+          provider: usage.provider,
+          model: usage.model,
+          status: "success",
+          input_tokens: usage.inputTokens,
+          output_tokens: usage.outputTokens,
+          cache_read_tokens: usage.cacheReadTokens,
+          cache_creation_tokens: usage.cacheCreationTokens,
+          cost_usd: usage.costUsd,
+          duration_ms: usage.latencyMs,
+          started_at: startedAt,
+          ended_at: endedAt,
+          tags: {
+            capability: usage.capability,
+            transport: usage.transport,
+            sdk: SDK_TAG
+          }
+        };
+        if (usage.tier !== void 0) body.tier = usage.tier;
+        if (usage.purpose !== void 0) body.purpose = usage.purpose;
+        if (usage.toolCalls) {
+          body.tool_calls = usage.toolCalls.map((t) => ({
+            name: t.name,
+            count: t.count,
+            error_count: t.errorCount ?? 0
+          }));
+        }
+        void config.complianceMode;
+        const res = await doFetch(url, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            "X-Upmetrics-Key": config.apiKey
+          },
+          body: JSON.stringify(body)
+        });
+        if (!res.ok) {
+          const text = await res.text().catch(() => "");
+          config.onError?.(
+            new Error(`upmetricsSink: ingest returned ${res.status}: ${text.slice(0, 200)}`)
+          );
+        }
+      } catch (err) {
+        config.onError?.(err);
+      }
+    }
+  };
+}
+
+// src/cost/sinks/discord.ts
+function discordSink(config) {
+  const doFetch = config.fetch ?? fetch;
+  const minUsd = config.minUsd ?? 0;
+  return {
+    async record(usage) {
+      try {
+        if (!usage.subprocess && usage.costUsd < minUsd) return;
+        const costLabel = usage.subprocess ? "Max plan (free)" : `$${usage.costUsd.toFixed(6)}`;
+        const embed = {
+          title: `AI call \u2014 ${usage.capability}`,
+          fields: [
+            { name: "Provider", value: usage.provider, inline: true },
+            { name: "Model", value: usage.model, inline: true },
+            { name: "Transport", value: usage.transport, inline: true },
+            { name: "Cost", value: costLabel, inline: true },
+            {
+              name: "Tokens",
+              value: `${usage.inputTokens} in / ${usage.outputTokens} out`,
+              inline: true
+            },
+            { name: "Latency", value: `${usage.latencyMs} ms`, inline: true }
+          ],
+          timestamp: usage.ts || (/* @__PURE__ */ new Date()).toISOString()
+        };
+        const res = await doFetch(config.webhookUrl, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ embeds: [embed] })
+        });
+        if (!res.ok) {
+          config.onError?.(new Error(`discordSink: webhook returned ${res.status}`));
+        }
+      } catch (err) {
+        config.onError?.(err);
+      }
+    }
+  };
+}
+
+// src/cost/sinks/sqlite.ts
+import { Database } from "bun:sqlite";
+var CREATE_TABLE = `
+CREATE TABLE IF NOT EXISTS ai_usage (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  ts TEXT NOT NULL,
+  provider TEXT NOT NULL,
+  model TEXT NOT NULL,
+  tier TEXT,
+  transport TEXT NOT NULL,
+  capability TEXT NOT NULL,
+  purpose TEXT,
+  input_tokens INTEGER NOT NULL,
+  output_tokens INTEGER NOT NULL,
+  cache_read_tokens INTEGER NOT NULL,
+  cache_creation_tokens INTEGER NOT NULL,
+  cost_usd REAL NOT NULL,
+  latency_ms INTEGER NOT NULL,
+  subprocess INTEGER NOT NULL DEFAULT 0
+)`;
+function sqliteSink(config) {
+  const db = new Database(config.dbPath);
+  db.run(CREATE_TABLE);
+  const insert = db.prepare(
+    `INSERT INTO ai_usage
+       (ts, provider, model, tier, transport, capability, purpose,
+        input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens,
+        cost_usd, latency_ms, subprocess)
+     VALUES ($ts, $provider, $model, $tier, $transport, $capability, $purpose,
+        $input, $output, $cacheRead, $cacheCreation, $cost, $latency, $subprocess)`
+  );
+  return {
+    record(usage) {
+      insert.run({
+        $ts: usage.ts || (/* @__PURE__ */ new Date()).toISOString(),
+        $provider: usage.provider,
+        $model: usage.model,
+        $tier: usage.tier ?? null,
+        $transport: usage.transport,
+        $capability: usage.capability,
+        $purpose: usage.purpose ?? null,
+        $input: usage.inputTokens,
+        $output: usage.outputTokens,
+        $cacheRead: usage.cacheReadTokens,
+        $cacheCreation: usage.cacheCreationTokens,
+        $cost: usage.costUsd,
+        $latency: usage.latencyMs,
+        $subprocess: usage.subprocess ? 1 : 0
+      });
+    }
+  };
+}
+function getCostSummary(dbPath) {
+  const db = new Database(dbPath, { readonly: true });
+  const total = db.query(`SELECT SUM(cost_usd) AS total FROM ai_usage`).get();
+  const byProvider = {};
+  for (const row of db.query(
+    `SELECT provider, SUM(cost_usd) AS sum FROM ai_usage GROUP BY provider`
+  ).all()) {
+    byProvider[row.provider] = row.sum;
+  }
+  const byCapability = {};
+  for (const row of db.query(
+    `SELECT capability, SUM(cost_usd) AS sum FROM ai_usage GROUP BY capability`
+  ).all()) {
+    byCapability[row.capability] = row.sum;
+  }
+  return { totalUsd: total?.total ?? 0, byProvider, byCapability };
+}
+export {
+  BudgetExceededError,
+  BudgetGuard,
+  DEFAULT_TIER_MAP,
+  SDK_TAG,
+  VERSION,
+  aiConfigSchema,
+  anthropicAdapter,
+  anthropicApiAdapter,
+  anthropicSubprocessAdapter,
+  chatInputSchema,
+  computeCost,
+  createAI,
+  deepinfraAdapter,
+  defaultProviders,
+  discordSink,
+  embeddingInputSchema,
+  falAdapter,
+  falStubAdapter,
+  freshUsage,
+  fromProviderToolCall,
+  geminiAdapter,
+  getCostSummary,
+  getPrice,
+  httpTransport,
+  imageInputSchema,
+  makeContracts,
+  makeOpenAICompatibleAdapter,
+  messageSchema,
+  multiSink,
+  noopSink,
+  openaiAdapter,
+  openaiStubAdapter,
+  openrouterAdapter,
+  parseClaudeCliJson,
+  parseJsonLoose,
+  resolveTier,
+  sqliteSink,
+  stubProviders,
+  subprocessTransport,
+  tierSpecSchema,
+  toProviderTools,
+  toolSchema,
+  translateInputSchema,
+  upmetricsSink,
+  visionInputSchema
+};
+//# sourceMappingURL=index.js.map