@broberg/ai-sdk 0.2.0 → 0.3.0

package/dist/index.js

@@ -81,6 +81,51 @@ async function subprocessTransport(req) {
   return parseClaudeCliJson(stdout);
 }
 
+// src/transport/stream.ts
+var StreamHttpError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "StreamHttpError";
+    this.status = status;
+  }
+};
+async function* streamTransport(req) {
+  if (!req.http) throw new Error("streamTransport: req.http is required for http transport");
+  const { url, method = "POST", headers, body } = req.http;
+  const fetchImpl = req.fetch ?? fetch;
+  const res = await fetchImpl(url, {
+    method,
+    headers,
+    body: body === void 0 ? void 0 : typeof body === "string" ? body : JSON.stringify(body)
+  });
+  if (!res.ok || !res.body) {
+    const text = await res.text().catch(() => "");
+    throw new StreamHttpError(`stream ${res.status}: ${text.slice(0, 300)}`, res.status);
+  }
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    for (; ; ) {
+      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).replace(/\r$/, "");
+        buffer = buffer.slice(nl + 1);
+        if (!line.startsWith("data:")) continue;
+        const data = line.slice(5).trim();
+        if (data === "[DONE]") return;
+        if (data) yield data;
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
 // src/providers/tools.ts
 function family(provider) {
   if (provider === "gemini" || provider === "google") return "gemini";
@@ -274,9 +319,7 @@ function flattenForSubprocess(messages) {
 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)");
+  function buildBody(req) {
     const system = [];
     const messages = [];
     for (const m of req.messages) {
@@ -295,6 +338,16 @@ function anthropicAdapter(config = {}) {
     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;
+    return body;
+  }
+  function apiKeyOrThrow() {
+    const apiKey = config.apiKey ?? process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) throw new Error("anthropic adapter: API key not set (env ANTHROPIC_API_KEY)");
+    return apiKey;
+  }
+  async function chatHttp(req) {
+    const apiKey = apiKeyOrThrow();
+    const body = buildBody(req);
     const res = await httpTransport({
       spec: req.spec,
       http: {
@@ -345,7 +398,110 @@ function anthropicAdapter(config = {}) {
   async function chat(req) {
     return req.spec.transport === "subprocess" ? chatSubprocess(req) : chatHttp(req);
   }
-  return { name: "anthropic", chat, vision: chat };
+  async function* chatStream(req) {
+    if (req.spec.transport === "subprocess") {
+      throw new Error("anthropic adapter: streaming is not supported over the subprocess transport");
+    }
+    const apiKey = apiKeyOrThrow();
+    const body = { ...buildBody(req), stream: true };
+    const stream = streamTransport({
+      spec: req.spec,
+      fetch: config.fetch,
+      http: {
+        url: `${baseUrl}/v1/messages`,
+        headers: {
+          "content-type": "application/json",
+          "x-api-key": apiKey,
+          "anthropic-version": version
+        },
+        body
+      }
+    });
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheReadTokens = 0;
+    let cacheCreationTokens = 0;
+    let stopReason = null;
+    const toolBlocks = /* @__PURE__ */ new Map();
+    for await (const data of stream) {
+      let ev;
+      try {
+        ev = JSON.parse(data);
+      } catch {
+        continue;
+      }
+      switch (ev.type) {
+        case "message_start": {
+          const u = ev.message?.usage;
+          inputTokens = u?.input_tokens ?? 0;
+          cacheReadTokens = u?.cache_read_input_tokens ?? 0;
+          cacheCreationTokens = u?.cache_creation_input_tokens ?? 0;
+          break;
+        }
+        case "content_block_start": {
+          if (ev.content_block?.type === "tool_use" && ev.index !== void 0) {
+            toolBlocks.set(ev.index, {
+              id: ev.content_block.id ?? "",
+              name: ev.content_block.name ?? "",
+              json: ""
+            });
+          }
+          break;
+        }
+        case "content_block_delta": {
+          const d = ev.delta;
+          if (d?.type === "text_delta" && d.text) {
+            yield { type: "text", delta: d.text };
+          } else if (d?.type === "input_json_delta" && d.partial_json && ev.index !== void 0) {
+            const b = toolBlocks.get(ev.index);
+            if (b) b.json += d.partial_json;
+          }
+          break;
+        }
+        case "message_delta": {
+          if (ev.delta?.stop_reason) stopReason = ev.delta.stop_reason;
+          if (ev.usage?.output_tokens !== void 0) outputTokens = ev.usage.output_tokens;
+          break;
+        }
+        default:
+          break;
+      }
+    }
+    for (const [, b] of [...toolBlocks.entries()].sort((a, c) => a[0] - c[0])) {
+      let args = {};
+      try {
+        args = b.json ? JSON.parse(b.json) : {};
+      } catch {
+        args = {};
+      }
+      yield { type: "tool_call", id: b.id, name: b.name, args };
+    }
+    const usage = freshUsage({
+      provider: "anthropic",
+      model: req.spec.model,
+      transport: "http",
+      capability: "chat",
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheCreationTokens
+    });
+    yield { type: "usage", costUsd: usage.costUsd, model: usage.model, usage };
+    yield { type: "finish", reason: mapAnthropicStop(stopReason) };
+  }
+  return { name: "anthropic", chat, chatStream, vision: chat };
+}
+function mapAnthropicStop(reason) {
+  switch (reason) {
+    case "tool_use":
+      return "tool_calls";
+    case "max_tokens":
+      return "length";
+    case "stop_sequence":
+      return "stop";
+    default:
+      return "end_turn";
+  }
 }
 
 // src/providers/openai-compatible.ts
@@ -353,6 +509,13 @@ 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;
+    if (m.toolCalls && m.toolCalls.length > 0) {
+      base.tool_calls = m.toolCalls.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: { name: tc.name, arguments: JSON.stringify(tc.arguments) }
+      }));
+    }
     return base;
   }
   const content = m.content.map((p) => {
@@ -375,6 +538,8 @@ function makeOpenAICompatibleAdapter(config) {
     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;
+    if (req.responseFormat === "json") body.response_format = { type: "json_object" };
+    if (config.costFromResponseField) body.usage = { include: true };
     const res = await httpTransport({
       spec: req.spec,
       http: {
@@ -404,17 +569,113 @@ function makeOpenAICompatibleAdapter(config) {
       inputTokens: data.usage?.prompt_tokens ?? 0,
       outputTokens: data.usage?.completion_tokens ?? 0
     });
+    if (config.costFromResponseField && typeof data.usage?.cost === "number") {
+      usage.costUsd = data.usage.cost;
+    }
     const result = { text, usage };
     if (toolCalls && toolCalls.length > 0) result.toolCalls = toolCalls;
     return result;
   }
+  async function* chatStream(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),
+      stream: true,
+      stream_options: { include_usage: true }
+    };
+    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;
+    if (req.responseFormat === "json") body.response_format = { type: "json_object" };
+    if (config.costFromResponseField) body.usage = { include: true };
+    const stream = streamTransport({
+      spec: req.spec,
+      fetch: config.fetch,
+      http: {
+        url: `${config.baseUrl}/chat/completions`,
+        headers: {
+          "content-type": "application/json",
+          Authorization: `Bearer ${apiKey}`,
+          ...config.extraHeaders
+        },
+        body
+      }
+    });
+    const toolAcc = /* @__PURE__ */ new Map();
+    let finishReason = null;
+    for await (const data of stream) {
+      let chunk;
+      try {
+        chunk = JSON.parse(data);
+      } catch {
+        continue;
+      }
+      const choice = chunk.choices?.[0];
+      if (choice) {
+        const delta = choice.delta ?? {};
+        if (typeof delta.content === "string" && delta.content.length > 0) {
+          yield { type: "text", delta: delta.content };
+        }
+        for (const tc of delta.tool_calls ?? []) {
+          const idx = tc.index ?? 0;
+          const cur = toolAcc.get(idx) ?? { id: "", name: "", args: "" };
+          if (tc.id) cur.id = tc.id;
+          if (tc.function?.name) cur.name = tc.function.name;
+          if (tc.function?.arguments) cur.args += tc.function.arguments;
+          toolAcc.set(idx, cur);
+        }
+        if (choice.finish_reason) finishReason = choice.finish_reason;
+      }
+      if (chunk.usage) {
+        const usage = freshUsage({
+          provider: config.name,
+          model: req.spec.model,
+          transport: "http",
+          capability: "chat",
+          inputTokens: chunk.usage.prompt_tokens ?? 0,
+          outputTokens: chunk.usage.completion_tokens ?? 0
+        });
+        if (config.costFromResponseField && typeof chunk.usage.cost === "number") {
+          usage.costUsd = chunk.usage.cost;
+        }
+        yield { type: "usage", costUsd: usage.costUsd, model: usage.model, usage };
+      }
+    }
+    for (const [, t] of [...toolAcc.entries()].sort((a, b) => a[0] - b[0])) {
+      let args = {};
+      try {
+        args = t.args ? JSON.parse(t.args) : {};
+      } catch {
+        args = {};
+      }
+      yield { type: "tool_call", id: t.id, name: t.name, args };
+    }
+    yield { type: "finish", reason: mapFinishReason(finishReason) };
+  }
   return {
     name: config.name,
     chat,
+    chatStream,
     // gpt-4o-class models are multimodal — vision shares the chat path.
     vision: chat
   };
 }
+function mapFinishReason(reason) {
+  switch (reason) {
+    case "tool_calls":
+      return "tool_calls";
+    case "length":
+      return "length";
+    case "stop":
+      return "stop";
+    default:
+      return "end_turn";
+  }
+}
 
 // src/providers/openai.ts
 var WHISPER_PRICE_PER_MIN = {
@@ -495,11 +756,12 @@ function partsFrom(content) {
 }
 function geminiAdapter(config = {}) {
   const baseUrl = config.baseUrl ?? "https://generativelanguage.googleapis.com/v1beta";
-  async function chat(req) {
+  function resolveKey() {
     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)");
-    }
+    if (!apiKey) throw new Error("gemini adapter: API key not set (env GOOGLE_API_KEY)");
+    return apiKey;
+  }
+  function buildBody(req) {
     const systemParts = [];
     const contents = [];
     for (const m of req.messages) {
@@ -519,6 +781,11 @@ function geminiAdapter(config = {}) {
     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;
+    return body;
+  }
+  async function chat(req) {
+    const apiKey = resolveKey();
+    const body = buildBody(req);
     const res = await httpTransport({
       spec: req.spec,
       http: {
@@ -546,7 +813,71 @@ function geminiAdapter(config = {}) {
     if (toolCalls.length > 0) result.toolCalls = toolCalls;
     return result;
   }
-  return { name: "gemini", chat, vision: chat };
+  async function* chatStream(req) {
+    const apiKey = resolveKey();
+    const body = buildBody(req);
+    const stream = streamTransport({
+      spec: req.spec,
+      fetch: config.fetch,
+      http: {
+        url: `${baseUrl}/models/${req.spec.model}:streamGenerateContent?alt=sse&key=${encodeURIComponent(apiKey)}`,
+        headers: { "content-type": "application/json" },
+        body
+      }
+    });
+    const toolCalls = [];
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let finishReason = null;
+    for await (const data of stream) {
+      let chunk;
+      try {
+        chunk = JSON.parse(data);
+      } catch {
+        continue;
+      }
+      const candidate = chunk.candidates?.[0];
+      for (const p of candidate?.content?.parts ?? []) {
+        if (typeof p.text === "string" && p.text.length > 0) {
+          yield { type: "text", delta: p.text };
+        } else if (p.functionCall) {
+          toolCalls.push(fromProviderToolCall({ functionCall: p.functionCall }, "gemini"));
+        }
+      }
+      if (candidate?.finishReason) finishReason = candidate.finishReason;
+      if (chunk.usageMetadata) {
+        inputTokens = chunk.usageMetadata.promptTokenCount ?? inputTokens;
+        outputTokens = chunk.usageMetadata.candidatesTokenCount ?? outputTokens;
+      }
+    }
+    for (const tc of toolCalls) {
+      yield { type: "tool_call", id: tc.id, name: tc.name, args: tc.arguments };
+    }
+    const usage = freshUsage({
+      provider: "gemini",
+      model: req.spec.model,
+      transport: "http",
+      capability: "chat",
+      inputTokens,
+      outputTokens
+    });
+    yield { type: "usage", costUsd: usage.costUsd, model: usage.model, usage };
+    yield {
+      type: "finish",
+      reason: toolCalls.length > 0 ? "tool_calls" : mapGeminiFinish(finishReason)
+    };
+  }
+  return { name: "gemini", chat, chatStream, vision: chat };
+}
+function mapGeminiFinish(reason) {
+  switch (reason) {
+    case "MAX_TOKENS":
+      return "length";
+    case "STOP":
+      return "end_turn";
+    default:
+      return reason ? "stop" : "end_turn";
+  }
 }
 
 // src/providers/deepinfra.ts
@@ -567,7 +898,10 @@ function openrouterAdapter(config = {}) {
     extraHeaders: {
       "HTTP-Referer": config.referer ?? "https://broberg.ai",
       "X-Title": config.title ?? "@broberg/ai-sdk"
-    }
+    },
+    // OpenRouter returns ground-truth usage.cost (USD) when usage:{include:true}
+    // is set — use it over the local pricing-table estimate (F010).
+    costFromResponseField: true
   });
 }
 
@@ -911,6 +1245,8 @@ var chatInputSchema = z.object({
   tools: z.array(toolSchema).optional(),
   maxTokens: z.number().int().positive().optional(),
   temperature: z.number().min(0).max(2).optional(),
+  /** "json" requests JSON-object output (OpenAI-compatible response_format). */
+  responseFormat: z.enum(["json", "text"]).optional(),
   ...callOptions
 });
 var visionInputSchema = z.object({
@@ -1029,6 +1365,73 @@ function createAI(config = {}) {
     }
     throw lastErr;
   }
+  function eligibleForFallback(e) {
+    const status = e?.status;
+    if (status === void 0) return true;
+    return status === 429 || status >= 500;
+  }
+  function errorEvent(e) {
+    const ev = {
+      type: "error",
+      message: e instanceof Error ? e.message : String(e)
+    };
+    const status = e?.status;
+    if (status !== void 0) ev.status = status;
+    return ev;
+  }
+  async function* chatStreamImpl(input) {
+    input = chatInputSchema.parse(input);
+    const tier = input.tier ?? "smart";
+    const messages = toMessages(input);
+    const estIn = messages.reduce(
+      (n, m) => n + estTokens(typeof m.content === "string" ? m.content : JSON.stringify(m.content)),
+      0
+    );
+    const estOut = input.maxTokens ?? 512;
+    const routes = [
+      resolveTier(tier, input.override, cfg.defaults),
+      ...(input.fallback ?? []).map(
+        (f) => typeof f === "string" ? resolveTier(f, void 0, cfg.defaults) : f
+      )
+    ];
+    let lastErr;
+    for (let i = 0; i < routes.length; i++) {
+      const spec = routes[i];
+      await preflight(spec, estIn, estOut);
+      const adapter = pickProvider(spec.provider);
+      if (!adapter.chatStream) {
+        throw new Error(`createAI: provider "${spec.provider}" does not support streaming`);
+      }
+      const t0 = performance.now();
+      let emitted = false;
+      try {
+        for await (const ev of adapter.chatStream({
+          messages,
+          spec,
+          tools: input.tools,
+          maxTokens: input.maxTokens,
+          temperature: input.temperature,
+          responseFormat: input.responseFormat
+        })) {
+          if (ev.type === "text" || ev.type === "tool_call") emitted = true;
+          if (ev.type === "usage") {
+            enrich(ev.usage, "chat", i === 0 ? tier : void 0, input.purpose, performance.now() - t0);
+            await settle(ev.usage);
+            await report(ev.usage);
+          }
+          yield ev;
+        }
+        return;
+      } catch (e) {
+        lastErr = e;
+        if (emitted || !eligibleForFallback(e)) {
+          yield errorEvent(e);
+          return;
+        }
+      }
+    }
+    yield errorEvent(lastErr);
+  }
   const client = {
     async chat(input) {
       input = chatInputSchema.parse(input);
@@ -1049,10 +1452,11 @@ function createAI(config = {}) {
         invoke: async (spec) => {
           const adapter = pickProvider(spec.provider);
           if (!adapter.chat) throw new Error(`createAI: provider "${spec.provider}" does not support chat`);
-          return adapter.chat({ messages, spec, tools: input.tools, maxTokens: input.maxTokens, temperature: input.temperature });
+          return adapter.chat({ messages, spec, tools: input.tools, maxTokens: input.maxTokens, temperature: input.temperature, responseFormat: input.responseFormat });
         }
       });
     },
+    chatStream: chatStreamImpl,
     async vision(input) {
       input = visionInputSchema.parse(input);
       const tier = input.tier ?? VISION_DEFAULT_TIER;
@@ -1235,8 +1639,8 @@ var stubProviders = {
 };
 
 // src/version.ts
-var VERSION = "0.2.0";
-var SDK_TAG = "@broberg/ai-sdk@0.2.0";
+var VERSION = "0.3.0";
+var SDK_TAG = "@broberg/ai-sdk@0.3.0";
 
 // src/cost/budget-store.ts
 function sqliteBudgetStore(config) {
@@ -1465,6 +1869,7 @@ export {
   BudgetGuard,
   DEFAULT_TIER_MAP,
   SDK_TAG,
+  StreamHttpError,
   VERSION,
   aiConfigSchema,
   anthropicAdapter,
@@ -1499,6 +1904,7 @@ export {
   resolveTier,
   sqliteBudgetStore,
   sqliteSink,
+  streamTransport,
   stubProviders,
   subprocessTransport,
   tierSpecSchema,