@wrongstack/providers 0.1.0

package/dist/index.js

@@ -0,0 +1,1206 @@
+import { safeParse, ProviderError, sanitizeJsonString } from '@wrongstack/core';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/aggregate.ts
+var aggregate_exports = {};
+__export(aggregate_exports, {
+  aggregateStream: () => aggregateStream
+});
+async function aggregateStream(stream, onEvent) {
+  let model = "";
+  let stopReason = "end_turn";
+  let usage = { input: 0, output: 0 };
+  const textBuffers = [];
+  let currentTextIndex = -1;
+  const toolBuffers = /* @__PURE__ */ new Map();
+  const blockOrder = [];
+  for await (const ev of stream) {
+    if (onEvent) onEvent(ev);
+    switch (ev.type) {
+      case "message_start":
+        model = ev.model;
+        break;
+      case "text_delta":
+        if (currentTextIndex === -1) {
+          currentTextIndex = textBuffers.length;
+          textBuffers.push("");
+          blockOrder.push({ kind: "text", idx: currentTextIndex });
+        }
+        textBuffers[currentTextIndex] = (textBuffers[currentTextIndex] ?? "") + ev.text;
+        break;
+      case "tool_use_start":
+        currentTextIndex = -1;
+        toolBuffers.set(ev.id, { name: ev.name, partial: "" });
+        blockOrder.push({ kind: "tool", id: ev.id });
+        break;
+      case "tool_use_input_delta": {
+        const b = toolBuffers.get(ev.id);
+        if (b) b.partial += ev.partial;
+        break;
+      }
+      case "tool_use_stop": {
+        const b = toolBuffers.get(ev.id);
+        if (b) {
+          if (ev.input !== void 0) {
+            b.input = ev.input;
+          } else if (b.partial) {
+            const parsed = safeParse(b.partial);
+            b.input = parsed.ok ? parsed.value : { _raw: b.partial };
+          } else {
+            b.input = {};
+          }
+        }
+        currentTextIndex = -1;
+        break;
+      }
+      case "message_stop":
+        stopReason = ev.stopReason;
+        usage = ev.usage;
+        break;
+    }
+  }
+  const content = [];
+  for (const b of blockOrder) {
+    if (b.kind === "text") {
+      const text = textBuffers[b.idx] ?? "";
+      if (text) content.push({ type: "text", text });
+    } else {
+      const tb = toolBuffers.get(b.id);
+      if (tb) {
+        content.push({
+          type: "tool_use",
+          id: b.id,
+          name: tb.name,
+          input: tb.input ?? {}
+        });
+      }
+    }
+  }
+  if (content.length === 0) content.push({ type: "text", text: "" });
+  return { content, stopReason, usage, model };
+}
+var init_aggregate = __esm({
+  "src/aggregate.ts"() {
+  }
+});
+function parseProviderHttpError(providerId, status, rawText) {
+  const body = parseBody(rawText);
+  const retryable = isRetryable(status, body.type);
+  const message = `${providerId} HTTP ${status}`;
+  return new ProviderError(message, status, retryable, providerId, { body });
+}
+function parseBody(rawText) {
+  const raw = rawText.slice(0, 2e3);
+  const body = { raw };
+  if (!rawText.trim()) return body;
+  let parsed;
+  try {
+    parsed = JSON.parse(rawText);
+  } catch {
+    return body;
+  }
+  if (!isRecord(parsed)) return body;
+  const errField = parsed["error"];
+  if (isRecord(errField)) {
+    const t = stringOf(errField["type"]) ?? stringOf(errField["status"]);
+    const m = stringOf(errField["message"]);
+    if (t) body.type = t;
+    if (m) body.message = m;
+  } else if (typeof errField === "string") {
+    body.message = errField;
+  }
+  if (!body.type) {
+    const t = stringOf(parsed["type"]);
+    if (t && t !== "error") body.type = t;
+  }
+  if (!body.message) {
+    const m = stringOf(parsed["message"]);
+    if (m) body.message = m;
+  }
+  const reqId = stringOf(parsed["request_id"]) ?? stringOf(parsed["requestId"]) ?? stringOf(parsed["id"]);
+  if (reqId) body.requestId = reqId;
+  return body;
+}
+function isRetryable(status, type) {
+  if (status === 0) return true;
+  if (status === 408 || status === 429 || status === 529) return true;
+  if (status >= 500 && status < 600) return true;
+  if (type === "overloaded_error" || type === "rate_limit_error") return true;
+  return false;
+}
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function stringOf(v) {
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+
+// src/tool-format/to-anthropic.ts
+function toolsToAnthropic(tools) {
+  return tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    input_schema: t.inputSchema ?? {
+      type: "object",
+      properties: {}
+    }
+  }));
+}
+
+// src/stop-reason.ts
+function normalizeAnthropic(stop) {
+  switch (stop) {
+    case "end_turn":
+      return "end_turn";
+    case "tool_use":
+      return "tool_use";
+    case "max_tokens":
+      return "max_tokens";
+    case "stop_sequence":
+      return "stop_sequence";
+    case "refusal":
+      return "refusal";
+    default:
+      return "end_turn";
+  }
+}
+function normalizeOpenAI(stop) {
+  switch (stop) {
+    case "stop":
+      return "end_turn";
+    case "tool_calls":
+    case "function_call":
+      return "tool_use";
+    case "length":
+      return "max_tokens";
+    case "content_filter":
+      return "refusal";
+    default:
+      return "end_turn";
+  }
+}
+function normalizeGemini(stop) {
+  switch (stop) {
+    case "SAFETY":
+    case "RECITATION":
+    case "hallucination":
+      return "refusal";
+    case "stop":
+    case "STOP":
+      return "end_turn";
+    case "max_tokens":
+    case "MAX_TOKENS":
+      return "max_tokens";
+    case "tool_use":
+    case "TOOL_USE":
+      return "tool_use";
+    default:
+      return "end_turn";
+  }
+}
+
+// src/sse.ts
+async function* parseSSE(body) {
+  if (!body) return;
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  let event = "message";
+  const dataLines = [];
+  const flush = () => {
+    if (dataLines.length === 0 && event === "message") return void 0;
+    const data = dataLines.join("\n");
+    const msg = { event, data };
+    event = "message";
+    dataLines.length = 0;
+    return msg;
+  };
+  const processLine = (line) => {
+    if (line === "") return flush();
+    if (line.startsWith(":")) return void 0;
+    const colonIdx = line.indexOf(":");
+    let field;
+    let value;
+    if (colonIdx === -1) {
+      field = line;
+      value = "";
+    } else {
+      field = line.slice(0, colonIdx);
+      value = line.slice(colonIdx + 1);
+      if (value.startsWith(" ")) value = value.slice(1);
+    }
+    if (field === "event") event = value || "message";
+    else if (field === "data") dataLines.push(value);
+    return void 0;
+  };
+  if (isNodeReadable(body)) {
+    for await (const chunk of body) {
+      buffer += typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true });
+      const lines = splitBuffer(buffer);
+      buffer = lines.tail;
+      for (const line of lines.lines) {
+        const msg = processLine(line);
+        if (msg) yield msg;
+      }
+    }
+  } else {
+    const reader = body.getReader();
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = splitBuffer(buffer);
+        buffer = lines.tail;
+        for (const line of lines.lines) {
+          const msg = processLine(line);
+          if (msg) yield msg;
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  if (buffer.length > 0) {
+    const msg = processLine(buffer);
+    if (msg) yield msg;
+  }
+  const final = flush();
+  if (final) yield final;
+}
+function splitBuffer(buf) {
+  const norm = buf.replace(/\r\n/g, "\n");
+  const parts = norm.split("\n");
+  const tail = parts.pop() ?? "";
+  return { lines: parts, tail };
+}
+function isNodeReadable(b) {
+  return !!b && typeof b === "object" && typeof b.pipe === "function" && typeof b.on === "function";
+}
+async function safeText(res) {
+  try {
+    return await res.text();
+  } catch {
+    return "";
+  }
+}
+var WireAdapter = class {
+  constructor(apiKey, baseUrl, fetchImpl = fetch) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+    this.fetchImpl = fetchImpl;
+    if (!apiKey) throw new Error(`${this.constructor.name}: apiKey required`);
+  }
+  apiKey;
+  baseUrl;
+  fetchImpl;
+  async complete(req, opts) {
+    const { aggregateStream: aggregateStream2 } = await Promise.resolve().then(() => (init_aggregate(), aggregate_exports));
+    return aggregateStream2(this.stream(req, opts));
+  }
+  async *stream(req, opts) {
+    const url = this.buildUrl(req);
+    const headers = this.buildHeaders(req);
+    const body = this.buildBody(req);
+    let httpRes;
+    try {
+      httpRes = await this.fetchImpl(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        signal: opts.signal
+      });
+    } catch (err) {
+      if (opts.signal.aborted) throw err;
+      throw new ProviderError(
+        err instanceof Error ? err.message : String(err),
+        0,
+        true,
+        this.id,
+        { cause: err, body: { message: err instanceof Error ? err.message : String(err) } }
+      );
+    }
+    if (!httpRes.ok) {
+      const text = await safeText(httpRes);
+      throw this.translateError(httpRes.status, text);
+    }
+    yield* this.parseStream(httpRes.body, req.model);
+  }
+  /** Per-request headers. `apiKey` is already in scope — call `super.buildHeaders` first. */
+  buildHeaders(_req) {
+    return {
+      "content-type": "application/json",
+      accept: "text/event-stream"
+    };
+  }
+  /** Build a ProviderError from an HTTP failure response. */
+  translateError(status, body) {
+    return parseProviderHttpError(this.id, status, body);
+  }
+};
+
+// src/anthropic.ts
+var DEFAULT_BASE = "https://api.anthropic.com";
+var DEFAULT_VERSION = "2023-06-01";
+var AnthropicProvider = class extends WireAdapter {
+  id = "anthropic";
+  capabilities = {
+    tools: true,
+    parallelTools: true,
+    vision: true,
+    streaming: true,
+    promptCache: true,
+    systemPrompt: true,
+    jsonMode: false,
+    maxContext: 2e5,
+    cacheControl: "native"
+  };
+  opts;
+  constructor(opts) {
+    super(opts.apiKey, opts.baseUrl ?? DEFAULT_BASE, opts.fetchImpl);
+    this.opts = opts;
+  }
+  buildUrl(_req) {
+    const base = this.baseUrl.replace(/\/+$/, "");
+    if (/\/v\d+\/messages$/.test(base)) return base;
+    if (/\/v\d+$/.test(base)) return `${base}/messages`;
+    return `${base}/v1/messages`;
+  }
+  buildHeaders(req) {
+    const headers = {
+      ...super.buildHeaders(req),
+      "x-api-key": this.apiKey,
+      "anthropic-version": this.opts.apiVersion ?? DEFAULT_VERSION
+    };
+    if (this.opts.beta && this.opts.beta.length > 0) {
+      headers["anthropic-beta"] = this.opts.beta.join(",");
+    }
+    return headers;
+  }
+  buildBody(req) {
+    const body = {
+      model: req.model,
+      max_tokens: req.maxTokens,
+      messages: req.messages.map((m) => this.normalizeMessage(m)),
+      stream: true
+    };
+    if (req.system && req.system.length > 0) body["system"] = req.system;
+    if (req.tools && req.tools.length > 0) body["tools"] = toolsToAnthropic(req.tools);
+    if (req.temperature !== void 0) body["temperature"] = req.temperature;
+    if (req.topP !== void 0) body["top_p"] = req.topP;
+    if (req.stopSequences) body["stop_sequences"] = req.stopSequences;
+    if (req.toolChoice) body["tool_choice"] = req.toolChoice;
+    return body;
+  }
+  parseStream(body, fallbackModel) {
+    return parseAnthropicStream(body, fallbackModel);
+  }
+  translateError(status, text) {
+    return parseProviderHttpError(this.id, status, text);
+  }
+  normalizeMessage(m) {
+    return {
+      role: m.role === "system" ? "user" : m.role,
+      content: typeof m.content === "string" ? m.content : m.content
+    };
+  }
+};
+async function* parseAnthropicStream(body, fallbackModel) {
+  const blocks = /* @__PURE__ */ new Map();
+  let model = fallbackModel;
+  let usage = { input: 0, output: 0 };
+  let stopReason = "end_turn";
+  let started = false;
+  for await (const msg of parseSSE(body)) {
+    if (!msg.data || msg.data === "[DONE]") continue;
+    const parsed = safeParse(msg.data);
+    if (!parsed.ok || !parsed.value) continue;
+    const ev = parsed.value;
+    const type = String(ev["type"] ?? msg.event);
+    switch (type) {
+      case "message_start": {
+        const message = ev["message"];
+        if (message?.model) model = message.model;
+        usage = {
+          input: message?.usage?.input_tokens ?? 0,
+          output: 0,
+          cacheRead: message?.usage?.cache_read_input_tokens,
+          cacheWrite: message?.usage?.cache_creation_input_tokens
+        };
+        if (!started) {
+          started = true;
+          yield { type: "message_start", model };
+        }
+        break;
+      }
+      case "content_block_start": {
+        const index = Number(ev["index"] ?? 0);
+        const cb = ev["content_block"];
+        if (cb?.type === "tool_use") {
+          blocks.set(index, { kind: "tool_use", id: cb.id, name: cb.name, partial: "" });
+          if (cb.id && cb.name) {
+            yield { type: "tool_use_start", id: cb.id, name: cb.name };
+          }
+        } else if (cb?.type === "text") {
+          blocks.set(index, { kind: "text", partial: "" });
+        } else {
+          blocks.set(index, { kind: "unknown", partial: "" });
+        }
+        break;
+      }
+      case "content_block_delta": {
+        const index = Number(ev["index"] ?? 0);
+        const delta = ev["delta"];
+        const block = blocks.get(index);
+        if (!block || !delta) break;
+        if (delta.type === "text_delta" && typeof delta.text === "string") {
+          yield { type: "text_delta", text: delta.text };
+        } else if (delta.type === "input_json_delta" && typeof delta.partial_json === "string") {
+          if (block.id) {
+            block.partial += delta.partial_json;
+            yield { type: "tool_use_input_delta", id: block.id, partial: delta.partial_json };
+          }
+        }
+        break;
+      }
+      case "content_block_stop": {
+        const index = Number(ev["index"] ?? 0);
+        const block = blocks.get(index);
+        if (block?.kind === "tool_use" && block.id) {
+          const input = block.partial ? safeParse(block.partial).value ?? {} : {};
+          yield { type: "tool_use_stop", id: block.id, input };
+        }
+        break;
+      }
+      case "message_delta": {
+        const delta = ev["delta"];
+        const u = ev["usage"];
+        if (delta?.stop_reason !== void 0) {
+          stopReason = normalizeAnthropic(delta.stop_reason);
+        }
+        if (u?.output_tokens !== void 0) usage = { ...usage, output: u.output_tokens };
+        break;
+      }
+      case "message_stop":
+        yield { type: "message_stop", stopReason, usage };
+        break;
+      case "error": {
+        const err = ev["error"];
+        throw new ProviderError(
+          err?.message ?? "Anthropic stream error",
+          0,
+          false,
+          "anthropic",
+          { body: { type: err?.type, message: err?.message } }
+        );
+      }
+    }
+  }
+  if (started) {
+    yield { type: "message_stop", stopReason, usage };
+  }
+}
+
+// src/tool-format/to-openai.ts
+function toolsToOpenAI(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.inputSchema ?? {
+        type: "object",
+        properties: {}
+      }
+    }
+  }));
+}
+function messagesToOpenAI(system, messages, opts = {}) {
+  const out = [];
+  if (system && system.length > 0) {
+    const sysText = system.map((b) => b.text).join("\n\n");
+    if (opts.systemAsMessage) {
+      out.push({ role: "user", content: sysText });
+    } else {
+      out.push({ role: "system", content: sysText });
+    }
+  }
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      const blocks = normalizeContent(msg.content);
+      const toolResults = blocks.filter((b) => b.type === "tool_result");
+      const others = blocks.filter((b) => b.type !== "tool_result");
+      if (others.length > 0) {
+        out.push({
+          role: "user",
+          content: opts.flattenContentToString ? blocksToString(others) : blocksToContentArray(others)
+        });
+      }
+      for (const r of toolResults) {
+        const content = typeof r.content === "string" ? r.content : JSON.stringify(r.content);
+        out.push({
+          role: "tool",
+          tool_call_id: r.tool_use_id,
+          content
+        });
+      }
+    } else if (msg.role === "assistant") {
+      const blocks = normalizeContent(msg.content);
+      const textBlocks = blocks.filter((b) => b.type === "text");
+      const toolUses = blocks.filter((b) => b.type === "tool_use");
+      const text = textBlocks.map((b) => b.text).join("");
+      const toolCalls = toolUses.map((u) => ({
+        id: u.id,
+        type: "function",
+        function: { name: u.name, arguments: JSON.stringify(u.input) }
+      }));
+      const message = { role: "assistant" };
+      if (toolCalls.length > 0) {
+        message.tool_calls = toolCalls;
+        if (text) {
+          message.content = text;
+        } else if (opts.emptyToolCallContent === "empty_string") {
+          message.content = "";
+        }
+      } else {
+        message.content = text;
+      }
+      out.push(message);
+    }
+  }
+  return out;
+}
+function normalizeContent(content) {
+  return typeof content === "string" ? [{ type: "text", text: content }] : content;
+}
+function blocksToString(blocks) {
+  return blocks.map((b) => {
+    if (b.type === "text") return b.text;
+    if (b.type === "image") return "[image]";
+    return "";
+  }).join("");
+}
+function blocksToContentArray(blocks) {
+  const hasImage = blocks.some((b) => b.type === "image");
+  if (!hasImage) {
+    return blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
+  }
+  return blocks.map((b) => {
+    if (b.type === "text") return { type: "text", text: b.text };
+    if (b.type === "image") {
+      const url = b.source.type === "url" ? b.source.url ?? "" : `data:${b.source.media_type ?? "image/png"};base64,${b.source.data ?? ""}`;
+      return { type: "image_url", image_url: { url } };
+    }
+    return null;
+  }).filter((c) => c !== null);
+}
+
+// src/openai.ts
+var DEFAULT_BASE2 = "https://api.openai.com/v1";
+var OpenAIProvider = class extends WireAdapter {
+  id;
+  capabilities;
+  opts;
+  constructor(opts) {
+    super(opts.apiKey, opts.baseUrl ?? DEFAULT_BASE2, opts.fetchImpl);
+    this.opts = opts;
+    this.id = opts.id ?? "openai";
+    this.capabilities = {
+      tools: true,
+      parallelTools: !opts.quirks?.parallelToolsDisabled,
+      vision: true,
+      streaming: true,
+      promptCache: false,
+      systemPrompt: !opts.quirks?.systemAsMessage,
+      jsonMode: true,
+      maxContext: 128e3,
+      cacheControl: "auto",
+      ...opts.capabilities
+    };
+  }
+  buildUrl(_req) {
+    const base = this.baseUrl.replace(/\/+$/, "");
+    if (/\/chat\/completions$/.test(base)) return base;
+    if (/\/v\d+(\/[a-z0-9_-]+)*$/i.test(base)) return `${base}/chat/completions`;
+    return `${base}/v1/chat/completions`;
+  }
+  buildHeaders(req) {
+    const headers = {
+      ...super.buildHeaders(req),
+      authorization: `Bearer ${this.apiKey}`
+    };
+    if (this.opts.organization) {
+      headers["openai-organization"] = this.opts.organization;
+    }
+    return headers;
+  }
+  buildBody(req) {
+    const body = {
+      model: req.model,
+      messages: messagesToOpenAI(this.stripCacheControl(req), req.messages, {
+        ...this.opts.quirks
+      }),
+      max_tokens: req.maxTokens,
+      stream: true,
+      stream_options: { include_usage: true }
+    };
+    if (req.tools && req.tools.length > 0) {
+      body["tools"] = toolsToOpenAI(req.tools);
+      if (req.toolChoice) {
+        if (typeof req.toolChoice === "string") {
+          body["tool_choice"] = req.toolChoice === "required" ? "required" : req.toolChoice;
+        } else {
+          body["tool_choice"] = {
+            type: "function",
+            function: { name: req.toolChoice.name }
+          };
+        }
+      }
+    }
+    if (req.temperature !== void 0) body["temperature"] = req.temperature;
+    if (req.topP !== void 0) body["top_p"] = req.topP;
+    if (req.stopSequences) body["stop"] = req.stopSequences;
+    return body;
+  }
+  parseStream(body, fallbackModel) {
+    return parseOpenAIStream(body, fallbackModel);
+  }
+  translateError(status, text) {
+    return parseProviderHttpError(this.id, status, text);
+  }
+  stripCacheControl(req) {
+    if (!req.system) return void 0;
+    return req.system.map((b) => {
+      const { cache_control: _cc, ...rest } = b;
+      return rest;
+    });
+  }
+};
+async function* parseOpenAIStream(body, fallbackModel) {
+  let model = fallbackModel;
+  let usage = { input: 0, output: 0 };
+  let stopReason = "end_turn";
+  let started = false;
+  const toolByIndex = /* @__PURE__ */ new Map();
+  for await (const msg of parseSSE(body)) {
+    if (!msg.data || msg.data === "[DONE]") continue;
+    const parsed = safeParse(msg.data);
+    if (!parsed.ok || !parsed.value) continue;
+    const obj = parsed.value;
+    if (typeof obj["model"] === "string") model = obj["model"];
+    if (!started) {
+      started = true;
+      yield { type: "message_start", model };
+    }
+    const choices = obj["choices"];
+    const choice = choices?.[0];
+    if (choice?.delta?.content) {
+      yield { type: "text_delta", text: choice.delta.content };
+    }
+    if (choice?.delta?.tool_calls) {
+      for (const tc of choice.delta.tool_calls) {
+        const idx = tc.index ?? 0;
+        let entry = toolByIndex.get(idx);
+        if (!entry && tc.id && tc.function?.name) {
+          entry = { id: tc.id, name: tc.function.name, argBuf: "" };
+          toolByIndex.set(idx, entry);
+          yield { type: "tool_use_start", id: entry.id, name: entry.name };
+        }
+        if (entry && tc.function?.arguments) {
+          entry.argBuf += tc.function.arguments;
+          yield {
+            type: "tool_use_input_delta",
+            id: entry.id,
+            partial: tc.function.arguments
+          };
+        }
+      }
+    }
+    if (choice?.finish_reason) {
+      stopReason = normalizeOpenAI(choice.finish_reason);
+    }
+    const u = obj["usage"];
+    if (u) {
+      usage = {
+        input: u.prompt_tokens ?? usage.input,
+        output: u.completion_tokens ?? usage.output,
+        cacheRead: u.prompt_tokens_details?.cached_tokens ?? usage.cacheRead
+      };
+    }
+  }
+  for (const entry of toolByIndex.values()) {
+    const input = entry.argBuf ? safeParse(entry.argBuf).value ?? { _raw: entry.argBuf } : {};
+    yield { type: "tool_use_stop", id: entry.id, input };
+  }
+  if (started) {
+    yield { type: "message_stop", stopReason, usage };
+  }
+}
+
+// src/openai-compatible.ts
+var OpenAICompatibleProvider = class extends OpenAIProvider {
+  extraHeaders;
+  urlOverride;
+  constructor(opts) {
+    super({
+      apiKey: opts.apiKey,
+      baseUrl: opts.baseUrl,
+      fetchImpl: opts.fetchImpl,
+      id: opts.id,
+      capabilities: opts.capabilities,
+      quirks: {
+        ...opts.quirks,
+        parallelToolsDisabled: opts.quirks?.parallelToolsDisabled,
+        jsonArgumentsBuggy: opts.quirks?.jsonArgumentsBuggy
+      }
+    });
+    this.extraHeaders = opts.headers;
+    this.urlOverride = opts.urlOverride;
+  }
+  buildUrl(req) {
+    if (this.urlOverride) {
+      return this.urlOverride(this.baseUrl, req);
+    }
+    return super.buildUrl(req);
+  }
+  buildHeaders(req) {
+    return {
+      ...super.buildHeaders(req),
+      ...this.extraHeaders
+    };
+  }
+};
+var DEFAULT_BASE3 = "https://generativelanguage.googleapis.com/v1beta";
+var GoogleProvider = class extends WireAdapter {
+  id;
+  capabilities;
+  opts;
+  constructor(opts) {
+    super(opts.apiKey, opts.baseUrl ?? DEFAULT_BASE3, opts.fetchImpl);
+    this.opts = opts;
+    this.id = opts.id ?? "google";
+    this.capabilities = {
+      tools: true,
+      parallelTools: true,
+      vision: true,
+      streaming: true,
+      promptCache: false,
+      systemPrompt: true,
+      jsonMode: true,
+      maxContext: 1e6,
+      cacheControl: "none",
+      ...opts.capabilities
+    };
+  }
+  buildUrl(req) {
+    return `${this.baseUrl}/models/${encodeURIComponent(req.model)}:streamGenerateContent?alt=sse`;
+  }
+  buildHeaders(req) {
+    return {
+      ...super.buildHeaders(req),
+      "x-goog-api-key": this.apiKey
+    };
+  }
+  buildBody(req) {
+    const body = {
+      contents: messagesToGemini(req.messages),
+      generationConfig: this.buildGenConfig(req)
+    };
+    if (req.system && req.system.length > 0) {
+      body["systemInstruction"] = {
+        parts: req.system.map((b) => ({ text: b.text }))
+      };
+    }
+    if (req.tools && req.tools.length > 0) {
+      body["tools"] = [{ functionDeclarations: toolsToGemini(req.tools) }];
+    }
+    return body;
+  }
+  parseStream(body, fallbackModel) {
+    return parseGoogleStream(body, fallbackModel);
+  }
+  translateError(status, text) {
+    return parseProviderHttpError(this.id, status, text);
+  }
+  buildGenConfig(req) {
+    const cfg = { maxOutputTokens: req.maxTokens };
+    if (req.temperature !== void 0) cfg["temperature"] = req.temperature;
+    if (req.topP !== void 0) cfg["topP"] = req.topP;
+    if (req.stopSequences) cfg["stopSequences"] = req.stopSequences;
+    return cfg;
+  }
+};
+function toolsToGemini(tools) {
+  return tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    parameters: t.inputSchema ?? { type: "object", properties: {} }
+  }));
+}
+function messagesToGemini(messages) {
+  const out = [];
+  for (const m of messages) {
+    if (m.role === "system") continue;
+    const blocks = typeof m.content === "string" ? [{ type: "text", text: m.content }] : m.content;
+    if (m.role === "assistant") {
+      const parts = [];
+      for (const b of blocks) {
+        if (b.type === "text" && b.text) parts.push({ text: b.text });
+        else if (b.type === "tool_use") {
+          parts.push({ functionCall: { name: b.name, args: b.input } });
+        }
+      }
+      if (parts.length > 0) out.push({ role: "model", parts });
+      continue;
+    }
+    const textParts = [];
+    const functionParts = [];
+    for (const b of blocks) {
+      if (b.type === "text" && b.text) textParts.push({ text: b.text });
+      else if (b.type === "tool_result") {
+        const responseText = typeof b.content === "string" ? b.content : JSON.stringify(b.content);
+        const fnName = b.name ?? b.tool_use_id;
+        functionParts.push({
+          functionResponse: {
+            name: fnName,
+            response: { content: responseText }
+          }
+        });
+      } else if (b.type === "image" && b.source.type === "base64") {
+        textParts.push({
+          inlineData: {
+            mimeType: b.source.media_type ?? "image/png",
+            data: b.source.data ?? ""
+          }
+        });
+      }
+    }
+    if (textParts.length > 0) out.push({ role: "user", parts: textParts });
+    if (functionParts.length > 0) out.push({ role: "function", parts: functionParts });
+  }
+  return out;
+}
+async function* parseGoogleStream(body, fallbackModel) {
+  let model = fallbackModel;
+  let usage = { input: 0, output: 0 };
+  let stopReason = "end_turn";
+  let started = false;
+  for await (const msg of parseSSE(body)) {
+    if (!msg.data || msg.data === "[DONE]") continue;
+    const parsed = safeParse(msg.data);
+    if (!parsed.ok || !parsed.value) continue;
+    const obj = parsed.value;
+    if (obj.modelVersion) model = obj.modelVersion;
+    if (!started) {
+      started = true;
+      yield { type: "message_start", model };
+    }
+    const candidate = obj.candidates?.[0];
+    for (const part of candidate?.content?.parts ?? []) {
+      if (typeof part.text === "string" && part.text.length > 0) {
+        yield { type: "text_delta", text: part.text };
+      } else if (part.functionCall) {
+        const id = `${part.functionCall.name}_${Math.random().toString(36).slice(2, 10)}`;
+        yield { type: "tool_use_start", id, name: part.functionCall.name };
+        yield {
+          type: "tool_use_stop",
+          id,
+          input: part.functionCall.args ?? {}
+        };
+      }
+    }
+    if (candidate?.finishReason) {
+      stopReason = normalizeGemini(candidate.finishReason);
+    }
+    const u = obj.usageMetadata;
+    if (u) {
+      usage = {
+        input: u.promptTokenCount ?? usage.input,
+        output: u.candidatesTokenCount ?? usage.output,
+        cacheRead: u.cachedContentTokenCount ?? usage.cacheRead
+      };
+    }
+  }
+  if (started) {
+    yield { type: "message_stop", stopReason, usage };
+  }
+}
+
+// src/capabilities.ts
+var BASE_BY_FAMILY = {
+  anthropic: {
+    tools: true,
+    parallelTools: true,
+    vision: true,
+    streaming: true,
+    promptCache: true,
+    systemPrompt: true,
+    jsonMode: false,
+    maxContext: 2e5,
+    cacheControl: "native"
+  },
+  openai: {
+    tools: true,
+    parallelTools: true,
+    vision: true,
+    streaming: true,
+    promptCache: false,
+    systemPrompt: true,
+    jsonMode: true,
+    maxContext: 128e3,
+    cacheControl: "auto"
+  },
+  "openai-compatible": {
+    tools: true,
+    parallelTools: true,
+    vision: false,
+    streaming: true,
+    promptCache: false,
+    systemPrompt: true,
+    jsonMode: false,
+    maxContext: 32e3,
+    cacheControl: "none"
+  },
+  google: {
+    tools: true,
+    parallelTools: true,
+    vision: true,
+    streaming: true,
+    promptCache: false,
+    systemPrompt: true,
+    jsonMode: true,
+    maxContext: 1e6,
+    cacheControl: "none"
+  },
+  unsupported: {
+    tools: false,
+    parallelTools: false,
+    vision: false,
+    streaming: false,
+    promptCache: false,
+    systemPrompt: false,
+    jsonMode: false,
+    maxContext: 0,
+    cacheControl: "none"
+  }
+};
+function baseFor(family) {
+  return BASE_BY_FAMILY[family] ?? BASE_BY_FAMILY.unsupported;
+}
+async function capabilitiesFor(registry, providerId, modelId) {
+  const provider = await registry.getProvider(providerId);
+  const base = baseFor(provider?.family ?? "unsupported");
+  const model = await registry.getModel(providerId, modelId);
+  if (!model) return { ...base };
+  return {
+    ...base,
+    tools: model.capabilities.tools && base.tools,
+    vision: model.capabilities.vision && base.vision,
+    maxContext: model.capabilities.maxContext || base.maxContext
+  };
+}
+
+// src/tool-format/from-anthropic.ts
+function contentFromAnthropic(blocks, opts = {}) {
+  const out = [];
+  for (const b of blocks) {
+    if (b.type === "text" && typeof b.text === "string") {
+      out.push({ type: "text", text: b.text });
+    } else if (b.type === "tool_use" && b.id && b.name) {
+      const input = isPlainObject(b.input) ? b.input : {};
+      out.push({ type: "tool_use", id: b.id, name: b.name, input });
+    } else if (b.type === "tool_result" && b.tool_use_id) {
+      out.push({
+        type: "tool_result",
+        tool_use_id: b.tool_use_id,
+        content: normalizeToolResultContent(b.content, opts),
+        is_error: b.is_error
+      });
+    } else if (b.type === "image" && b.source) {
+      const src = b.source;
+      const kind = src.type === "url" ? "url" : "base64";
+      out.push({
+        type: "image",
+        source: {
+          type: kind,
+          ...src.media_type ? { media_type: src.media_type } : {},
+          ...src.data ? { data: src.data } : {},
+          ...src.url ? { url: src.url } : {}
+        }
+      });
+    } else if (b.type) {
+      opts.onUnsupported?.(b.type, b);
+    }
+  }
+  return out;
+}
+function normalizeToolResultContent(raw, opts) {
+  if (typeof raw === "string") return raw;
+  if (Array.isArray(raw)) {
+    const blocks = contentFromAnthropic(raw, opts);
+    return blocks.map((b) => b.type === "text" ? b.text : `[${b.type}]`).join("");
+  }
+  if (raw === void 0 || raw === null) return "";
+  return JSON.stringify(raw);
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function contentFromOpenAI(choice, opts = {}) {
+  const out = [];
+  const text = choice.message.content;
+  if (typeof text === "string" && text.length > 0) {
+    out.push({ type: "text", text });
+  }
+  for (const tc of choice.message.tool_calls ?? []) {
+    const raw = tc.function.arguments ?? "{}";
+    const input = parseToolArguments(raw, tc.function.name, tc.id, opts);
+    const block = {
+      type: "tool_use",
+      id: tc.id,
+      name: tc.function.name,
+      input
+    };
+    out.push(block);
+  }
+  if (out.length === 0) {
+    out.push({ type: "text", text: "" });
+  }
+  return out;
+}
+function parseToolArguments(raw, toolName, toolCallId, opts) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    opts.onParseFailure?.({ toolName, toolCallId, raw });
+    return { __raw_arguments: raw };
+  } catch {
+    try {
+      const sanitized = JSON.parse(sanitizeJsonString(raw));
+      if (sanitized && typeof sanitized === "object" && !Array.isArray(sanitized)) {
+        return sanitized;
+      }
+    } catch {
+    }
+    opts.onParseFailure?.({ toolName, toolCallId, raw });
+    return { __raw_arguments: raw };
+  }
+}
+
+// src/index.ts
+async function buildProviderFactoriesFromRegistry(opts) {
+  const providers = await opts.registry.listProviders();
+  const factories = [];
+  const unsupported = [];
+  for (const p of providers) {
+    if (p.family === "unsupported") {
+      unsupported.push(p);
+      continue;
+    }
+    factories.push({
+      type: p.id,
+      family: p.family,
+      create: (cfg) => makeProvider(p, cfg)
+    });
+  }
+  factories.push({
+    type: "openai-compatible",
+    family: "openai-compatible",
+    create: (cfg) => new OpenAICompatibleProvider({
+      id: "openai-compatible",
+      apiKey: requireKey(cfg),
+      baseUrl: cfg.baseUrl ?? "",
+      headers: cfg.headers,
+      quirks: cfg.quirks
+    })
+  });
+  if (unsupported.length > 0 && opts.log) {
+    opts.log.info(
+      `${unsupported.length} provider(s) need a plugin (unsupported wire family): ` + unsupported.map((p) => p.id).join(", ")
+    );
+  }
+  return factories;
+}
+function makeProvider(p, cfg) {
+  const family = cfg.family ?? p.family;
+  const envVars = cfg.envVars && cfg.envVars.length > 0 ? cfg.envVars : p.envVars;
+  const apiKey = cfg.apiKey ?? readFromEnv(envVars);
+  if (!apiKey && family !== "unsupported") {
+    throw new Error(
+      `Provider "${p.id}" requires an API key. Set ${envVars.join(" or ") || "apiKey in config"} or run \`wstack auth ${p.id}\`.`
+    );
+  }
+  const baseUrl = cfg.baseUrl ?? p.apiBase;
+  if (!family || family === "unsupported") {
+    if (family === "unsupported") {
+      throw new Error(
+        `Provider "${p.id}" uses an unsupported wire family (${p.npm ?? "unknown"}). Register a custom factory via a plugin to enable it.`
+      );
+    }
+    throw new Error(
+      `Provider "${p.id}" has no wire family configured. Set an explicit family ("anthropic" | "openai" | "openai-compatible" | "google") in config or the models.dev catalog.`
+    );
+  }
+  switch (family) {
+    case "anthropic":
+      return new AnthropicProvider({ apiKey, baseUrl });
+    case "openai":
+      return new OpenAIProvider({
+        apiKey,
+        baseUrl,
+        id: p.id,
+        quirks: cfg.quirks
+      });
+    case "openai-compatible":
+      return new OpenAICompatibleProvider({
+        id: p.id,
+        apiKey,
+        baseUrl: baseUrl ?? "",
+        headers: cfg.headers,
+        quirks: cfg.quirks
+      });
+    case "google":
+      return new GoogleProvider({ id: p.id, apiKey, baseUrl });
+  }
+}
+function makeProviderFromConfig(id, cfg) {
+  if (!cfg.family) {
+    throw new Error(
+      `Provider "${id}" needs an explicit family ("anthropic" | "openai" | "openai-compatible" | "google") when not in the models.dev catalog.`
+    );
+  }
+  const synthetic = {
+    id,
+    family: cfg.family,
+    apiBase: cfg.baseUrl,
+    envVars: cfg.envVars ?? [],
+    models: (cfg.models ?? []).map((m) => ({ id: m, name: m })),
+    npm: void 0
+  };
+  return makeProvider(synthetic, cfg);
+}
+function readFromEnv(vars) {
+  for (const v of vars) {
+    const val = process.env[v];
+    if (val) return val;
+  }
+  return void 0;
+}
+function requireKey(cfg) {
+  if (cfg.apiKey) return cfg.apiKey;
+  throw new Error("Provider config requires apiKey (or set the corresponding env var).");
+}
+
+export { AnthropicProvider, GoogleProvider, OpenAICompatibleProvider, OpenAIProvider, WireAdapter, buildProviderFactoriesFromRegistry, capabilitiesFor, contentFromAnthropic, contentFromOpenAI, makeProviderFromConfig, messagesToOpenAI, normalizeAnthropic, normalizeOpenAI, parseProviderHttpError, toolsToAnthropic, toolsToOpenAI };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map