@wrongstack/providers 0.1.2 → 0.1.4

package/dist/index.js

@@ -842,9 +842,64 @@ function toolsToGemini(tools) {
   return tools.map((t) => ({
     name: t.name,
     description: t.description,
-    parameters: t.inputSchema ?? { type: "object", properties: {} }
+    parameters: sanitizeSchemaForGemini(t.inputSchema) ?? { type: "object", properties: {} }
   }));
 }
+var GEMINI_ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "format",
+  "description",
+  "nullable",
+  "enum",
+  "items",
+  "properties",
+  "required",
+  "anyOf",
+  "minLength",
+  "maxLength",
+  "pattern",
+  "minimum",
+  "maximum",
+  "minItems",
+  "maxItems",
+  "minProperties",
+  "maxProperties",
+  "propertyOrdering",
+  "title"
+]);
+function sanitizeSchemaForGemini(node) {
+  if (node === null || node === void 0) return void 0;
+  if (Array.isArray(node)) {
+    return void 0;
+  }
+  if (typeof node !== "object") return void 0;
+  const src = node;
+  const out = {};
+  for (const [k, v] of Object.entries(src)) {
+    if (!GEMINI_ALLOWED_KEYS.has(k)) continue;
+    if (k === "properties" && v && typeof v === "object") {
+      const props = {};
+      for (const [pname, pschema] of Object.entries(v)) {
+        const cleaned = sanitizeSchemaForGemini(pschema);
+        if (cleaned) props[pname] = cleaned;
+      }
+      out["properties"] = props;
+    } else if (k === "items") {
+      const cleaned = sanitizeSchemaForGemini(v);
+      if (cleaned) out["items"] = cleaned;
+    } else if (k === "anyOf" && Array.isArray(v)) {
+      const cleaned = v.map((s) => sanitizeSchemaForGemini(s)).filter((s) => s !== void 0);
+      if (cleaned.length > 0) out["anyOf"] = cleaned;
+    } else if (k === "required" && Array.isArray(v)) {
+      out["required"] = v.filter((s) => typeof s === "string");
+    } else if (k === "enum" && Array.isArray(v)) {
+      out["enum"] = v;
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
 function messagesToGemini(messages) {
   const out = [];
   for (const m of messages) {
@@ -855,7 +910,14 @@ function messagesToGemini(messages) {
       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 } });
+          const part = {
+            functionCall: { name: b.name, args: b.input }
+          };
+          const sig = b.providerMeta?.["google.thoughtSignature"];
+          if (typeof sig === "string" && sig.length > 0) {
+            part.thoughtSignature = sig;
+          }
+          parts.push(part);
         }
       }
       if (parts.length > 0) out.push({ role: "model", parts });
@@ -893,6 +955,7 @@ async function* parseGoogleStream(body, fallbackModel) {
   let usage = { input: 0, output: 0 };
   let stopReason = "end_turn";
   let started = false;
+  let sawFunctionCall = false;
   for await (const msg of parseSSE(body)) {
     if (!msg.data || msg.data === "[DONE]") continue;
     const parsed = safeParse(msg.data);
@@ -908,12 +971,15 @@ async function* parseGoogleStream(body, fallbackModel) {
       if (typeof part.text === "string" && part.text.length > 0) {
         yield { type: "text_delta", text: part.text };
       } else if (part.functionCall) {
+        sawFunctionCall = true;
         const id = `${part.functionCall.name}_${Math.random().toString(36).slice(2, 10)}`;
         yield { type: "tool_use_start", id, name: part.functionCall.name };
+        const providerMeta = typeof part.thoughtSignature === "string" ? { "google.thoughtSignature": part.thoughtSignature } : void 0;
         yield {
           type: "tool_use_stop",
           id,
-          input: part.functionCall.args ?? {}
+          input: part.functionCall.args ?? {},
+          ...providerMeta ? { providerMeta } : {}
         };
       }
     }
@@ -930,8 +996,657 @@ async function* parseGoogleStream(body, fallbackModel) {
     }
   }
   if (started) {
-    yield { type: "message_stop", stopReason, usage };
+    const finalStop = sawFunctionCall ? "tool_use" : stopReason;
+    yield { type: "message_stop", stopReason: finalStop, usage };
+  }
+}
+
+// src/wire-format.ts
+var WireFormatProvider = class extends WireAdapter {
+  id;
+  capabilities;
+  cfg;
+  constructor(cfg, opts) {
+    super(opts.apiKey, opts.baseUrl ?? cfg.defaultBaseUrl, opts.fetchImpl);
+    this.id = cfg.id;
+    this.capabilities = cfg.capabilities;
+    this.cfg = cfg;
+  }
+  buildUrl(req) {
+    return this.cfg.buildUrl(this.baseUrl, req);
+  }
+  buildHeaders(req) {
+    return {
+      ...super.buildHeaders(req),
+      ...this.cfg.buildHeaders(this.apiKey, req)
+    };
+  }
+  buildBody(req) {
+    return this.cfg.buildBody(req);
+  }
+  parseStream(body, fallbackModel) {
+    return this.runStream(body, fallbackModel);
+  }
+  translateError(status, body) {
+    return this.cfg.normalizeError ? this.cfg.normalizeError(status, body) : parseProviderHttpError(this.id, status, body);
+  }
+  async *runStream(body, fallbackModel) {
+    const state = this.cfg.createStreamState(fallbackModel);
+    for await (const msg of parseSSE(body)) {
+      for (const ev of this.cfg.parseStreamEvent(msg, state)) {
+        yield ev;
+      }
+    }
+    if (this.cfg.finalizeStream) {
+      for (const ev of this.cfg.finalizeStream(state)) {
+        yield ev;
+      }
+    }
+  }
+};
+function defineWireFormat(cfg) {
+  return cfg;
+}
+function createWireFormatFactory(cfg, opts = {}) {
+  return {
+    type: cfg.id,
+    family: cfg.family,
+    create: (rawCfg) => {
+      const c = rawCfg;
+      const apiKey = opts.apiKey ?? c.apiKey;
+      if (!apiKey) {
+        throw new Error(`Provider "${cfg.id}" requires an apiKey.`);
+      }
+      return new WireFormatProvider(cfg, {
+        apiKey,
+        baseUrl: opts.baseUrl ?? c.baseUrl
+      });
+    }
+  };
+}
+var mistralWireFormat = defineWireFormat({
+  id: "mistral",
+  family: "openai-compatible",
+  capabilities: {
+    tools: true,
+    parallelTools: true,
+    vision: false,
+    streaming: true,
+    promptCache: false,
+    systemPrompt: true,
+    jsonMode: true,
+    maxContext: 128e3,
+    cacheControl: "none"
+  },
+  defaultBaseUrl: "https://api.mistral.ai/v1",
+  buildUrl: (base) => `${base.replace(/\/+$/, "")}/chat/completions`,
+  buildHeaders: (apiKey) => ({ authorization: `Bearer ${apiKey}` }),
+  buildBody: (req) => ({
+    model: req.model,
+    messages: req.messages,
+    max_tokens: req.maxTokens,
+    temperature: req.temperature,
+    top_p: req.topP,
+    stop: req.stopSequences,
+    stream: true,
+    tools: req.tools
+  }),
+  createStreamState: (fallbackModel) => ({
+    model: fallbackModel,
+    started: false,
+    toolCalls: /* @__PURE__ */ new Map()
+  }),
+  parseStreamEvent: (msg, state) => {
+    if (!msg.data || msg.data === "[DONE]") return [];
+    const parsed = safeParse(msg.data);
+    if (!parsed.ok || !parsed.value) return [];
+    const ev = parsed.value;
+    const out = [];
+    if (ev.model) state.model = ev.model;
+    if (!state.started) {
+      state.started = true;
+      out.push({ type: "message_start", model: state.model });
+    }
+    const choice = ev.choices?.[0];
+    if (choice?.delta?.content) {
+      out.push({ type: "text_delta", text: choice.delta.content });
+    }
+    for (const tc of choice?.delta?.tool_calls ?? []) {
+      let block = state.toolCalls.get(tc.index);
+      if (!block) {
+        block = { id: tc.id, name: tc.function?.name, partial: "", emittedStart: false };
+        state.toolCalls.set(tc.index, block);
+      } else {
+        if (tc.id && !block.id) block.id = tc.id;
+        if (tc.function?.name && !block.name) block.name = tc.function.name;
+      }
+      if (!block.emittedStart && block.id && block.name) {
+        block.emittedStart = true;
+        out.push({ type: "tool_use_start", id: block.id, name: block.name });
+      }
+      const arg = tc.function?.arguments;
+      if (arg && block.id) {
+        block.partial += arg;
+        out.push({ type: "tool_use_input_delta", id: block.id, partial: arg });
+      }
+    }
+    if (choice?.finish_reason) {
+      for (const block of state.toolCalls.values()) {
+        if (block.id) {
+          const parsedInput = safeParse(block.partial || "{}");
+          out.push({
+            type: "tool_use_stop",
+            id: block.id,
+            input: parsedInput.ok ? parsedInput.value : {}
+          });
+        }
+      }
+      out.push({
+        type: "message_stop",
+        stopReason: mapStopReason(choice.finish_reason),
+        usage: {
+          input: ev.usage?.prompt_tokens ?? 0,
+          output: ev.usage?.completion_tokens ?? 0
+        }
+      });
+    }
+    return out;
+  }
+});
+function mapStopReason(reason) {
+  switch (reason) {
+    case "tool_calls":
+      return "tool_use";
+    case "length":
+      return "max_tokens";
+    case "stop":
+      return "stop_sequence";
+    default:
+      return "end_turn";
+  }
+}
+var DEFAULT_VERSION2 = "2023-06-01";
+var anthropicWireFormat = defineWireFormat({
+  id: "anthropic",
+  family: "anthropic",
+  capabilities: {
+    tools: true,
+    parallelTools: true,
+    vision: true,
+    streaming: true,
+    promptCache: true,
+    systemPrompt: true,
+    jsonMode: false,
+    maxContext: 2e5,
+    cacheControl: "native"
+  },
+  defaultBaseUrl: "https://api.anthropic.com",
+  buildUrl: (base) => {
+    const b = base.replace(/\/+$/, "");
+    if (/\/v\d+\/messages$/.test(b)) return b;
+    if (/\/v\d+$/.test(b)) return `${b}/messages`;
+    return `${b}/v1/messages`;
+  },
+  buildHeaders: (apiKey) => ({
+    "x-api-key": apiKey,
+    "anthropic-version": DEFAULT_VERSION2
+  }),
+  buildBody: (req) => {
+    const body = {
+      model: req.model,
+      max_tokens: req.maxTokens,
+      messages: req.messages.map((m) => ({
+        role: m.role === "system" ? "user" : m.role,
+        content: m.content
+      })),
+      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;
+  },
+  createStreamState: (fallbackModel) => ({
+    model: fallbackModel,
+    usage: { input: 0, output: 0 },
+    stopReason: "end_turn",
+    started: false,
+    blocks: /* @__PURE__ */ new Map()
+  }),
+  parseStreamEvent: (msg, state) => {
+    if (!msg.data || msg.data === "[DONE]") return [];
+    const parsed = safeParse(msg.data);
+    if (!parsed.ok || !parsed.value) return [];
+    const ev = parsed.value;
+    const type = String(ev["type"] ?? msg.event);
+    const out = [];
+    switch (type) {
+      case "message_start": {
+        const message = ev["message"];
+        if (message?.model) state.model = message.model;
+        state.usage = {
+          input: message?.usage?.input_tokens ?? 0,
+          output: 0,
+          cacheRead: message?.usage?.cache_read_input_tokens,
+          cacheWrite: message?.usage?.cache_creation_input_tokens
+        };
+        if (!state.started) {
+          state.started = true;
+          out.push({ type: "message_start", model: state.model });
+        }
+        break;
+      }
+      case "content_block_start": {
+        const index = Number(ev["index"] ?? 0);
+        const cb = ev["content_block"];
+        if (cb?.type === "tool_use") {
+          state.blocks.set(index, { kind: "tool_use", id: cb.id, name: cb.name, partial: "" });
+          if (cb.id && cb.name) {
+            out.push({ type: "tool_use_start", id: cb.id, name: cb.name });
+          }
+        } else if (cb?.type === "text") {
+          state.blocks.set(index, { kind: "text", partial: "" });
+        } else {
+          state.blocks.set(index, { kind: "unknown", partial: "" });
+        }
+        break;
+      }
+      case "content_block_delta": {
+        const index = Number(ev["index"] ?? 0);
+        const delta = ev["delta"];
+        const block = state.blocks.get(index);
+        if (!block || !delta) break;
+        if (delta.type === "text_delta" && typeof delta.text === "string") {
+          out.push({ 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;
+            out.push({ 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 = state.blocks.get(index);
+        if (block?.kind === "tool_use" && block.id) {
+          const input = block.partial ? safeParse(block.partial).value ?? {} : {};
+          out.push({ 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) {
+          state.stopReason = normalizeAnthropic(delta.stop_reason);
+        }
+        if (u?.output_tokens !== void 0) {
+          state.usage = { ...state.usage, output: u.output_tokens };
+        }
+        break;
+      }
+      case "message_stop":
+        out.push({ type: "message_stop", stopReason: state.stopReason, usage: state.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 } }
+        );
+      }
+    }
+    return out;
+  },
+  finalizeStream: (state) => {
+    if (state.started) {
+      return [{ type: "message_stop", stopReason: state.stopReason, usage: state.usage }];
+    }
+    return [];
   }
+});
+var openaiWireFormat = defineWireFormat({
+  id: "openai",
+  family: "openai",
+  capabilities: {
+    tools: true,
+    parallelTools: true,
+    vision: true,
+    streaming: true,
+    promptCache: false,
+    systemPrompt: true,
+    jsonMode: true,
+    maxContext: 128e3,
+    cacheControl: "auto"
+  },
+  defaultBaseUrl: "https://api.openai.com/v1",
+  buildUrl: (base) => {
+    const b = base.replace(/\/+$/, "");
+    if (/\/chat\/completions$/.test(b)) return b;
+    if (/\/v\d+(\/[a-z0-9_-]+)*$/i.test(b)) return `${b}/chat/completions`;
+    return `${b}/v1/chat/completions`;
+  },
+  buildHeaders: (apiKey) => ({ authorization: `Bearer ${apiKey}` }),
+  buildBody: (req) => {
+    const body = {
+      model: req.model,
+      messages: messagesToOpenAI(stripCacheControl(req.system), req.messages, {}),
+      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;
+  },
+  createStreamState: (fallbackModel) => ({
+    model: fallbackModel,
+    usage: { input: 0, output: 0 },
+    stopReason: "end_turn",
+    started: false,
+    textOpen: false,
+    toolByIndex: /* @__PURE__ */ new Map(),
+    finalEmitted: false
+  }),
+  parseStreamEvent: (msg, state) => {
+    if (!msg.data || msg.data === "[DONE]") return [];
+    const parsed = safeParse(msg.data);
+    if (!parsed.ok || !parsed.value) return [];
+    const obj = parsed.value;
+    const out = [];
+    if (typeof obj["model"] === "string") state.model = obj["model"];
+    if (!state.started) {
+      state.started = true;
+      out.push({ type: "message_start", model: state.model });
+    }
+    const choices = obj["choices"];
+    const choice = choices?.[0];
+    if (choice?.delta?.content) {
+      if (!state.textOpen) state.textOpen = true;
+      out.push({ 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 = state.toolByIndex.get(idx);
+        if (!entry && tc.id && tc.function?.name) {
+          entry = { id: tc.id, name: tc.function.name, argBuf: "" };
+          state.toolByIndex.set(idx, entry);
+          state.textOpen = false;
+          out.push({ type: "tool_use_start", id: entry.id, name: entry.name });
+        }
+        if (entry && tc.function?.arguments) {
+          entry.argBuf += tc.function.arguments;
+          out.push({
+            type: "tool_use_input_delta",
+            id: entry.id,
+            partial: tc.function.arguments
+          });
+        }
+      }
+    }
+    if (choice?.finish_reason) {
+      state.stopReason = normalizeOpenAI(choice.finish_reason);
+    }
+    const u = obj["usage"];
+    if (u) {
+      state.usage = {
+        input: u.prompt_tokens ?? state.usage.input,
+        output: u.completion_tokens ?? state.usage.output,
+        cacheRead: u.prompt_tokens_details?.cached_tokens ?? state.usage.cacheRead
+      };
+    }
+    return out;
+  },
+  finalizeStream: (state) => {
+    if (state.finalEmitted) return [];
+    state.finalEmitted = true;
+    const out = [];
+    for (const entry of state.toolByIndex.values()) {
+      const input = entry.argBuf ? safeParse(entry.argBuf).value ?? { _raw: entry.argBuf } : {};
+      out.push({ type: "tool_use_stop", id: entry.id, input });
+    }
+    if (state.started) {
+      out.push({ type: "message_stop", stopReason: state.stopReason, usage: state.usage });
+    }
+    return out;
+  }
+});
+function stripCacheControl(system) {
+  if (!system) return void 0;
+  return system.map((b) => {
+    const { cache_control: _cc, ...rest } = b;
+    return rest;
+  });
+}
+var googleWireFormat = defineWireFormat({
+  id: "google",
+  family: "google",
+  capabilities: {
+    tools: true,
+    parallelTools: true,
+    vision: true,
+    streaming: true,
+    promptCache: false,
+    systemPrompt: true,
+    jsonMode: true,
+    maxContext: 1e6,
+    cacheControl: "none"
+  },
+  defaultBaseUrl: "https://generativelanguage.googleapis.com/v1beta",
+  buildUrl: (base, req) => `${base}/models/${encodeURIComponent(req.model)}:streamGenerateContent?alt=sse`,
+  buildHeaders: (apiKey) => ({ "x-goog-api-key": apiKey }),
+  buildBody: (req) => {
+    const body = {
+      contents: messagesToGemini2(req.messages),
+      generationConfig: 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: toolsToGemini2(req.tools) }];
+    }
+    return body;
+  },
+  createStreamState: (fallbackModel) => ({
+    model: fallbackModel,
+    usage: { input: 0, output: 0 },
+    stopReason: "end_turn",
+    started: false,
+    sawFunctionCall: false,
+    finalEmitted: false
+  }),
+  parseStreamEvent: (msg, state) => {
+    if (!msg.data || msg.data === "[DONE]") return [];
+    const parsed = safeParse(msg.data);
+    if (!parsed.ok || !parsed.value) return [];
+    const obj = parsed.value;
+    const out = [];
+    if (obj.modelVersion) state.model = obj.modelVersion;
+    if (!state.started) {
+      state.started = true;
+      out.push({ type: "message_start", model: state.model });
+    }
+    const candidate = obj.candidates?.[0];
+    for (const part of candidate?.content?.parts ?? []) {
+      if (typeof part.text === "string" && part.text.length > 0) {
+        out.push({ type: "text_delta", text: part.text });
+      } else if (part.functionCall) {
+        state.sawFunctionCall = true;
+        const id = `${part.functionCall.name}_${Math.random().toString(36).slice(2, 10)}`;
+        out.push({ type: "tool_use_start", id, name: part.functionCall.name });
+        const providerMeta = typeof part.thoughtSignature === "string" ? { "google.thoughtSignature": part.thoughtSignature } : void 0;
+        out.push({
+          type: "tool_use_stop",
+          id,
+          input: part.functionCall.args ?? {},
+          ...providerMeta ? { providerMeta } : {}
+        });
+      }
+    }
+    if (candidate?.finishReason) {
+      state.stopReason = normalizeGemini(candidate.finishReason);
+    }
+    const u = obj.usageMetadata;
+    if (u) {
+      state.usage = {
+        input: u.promptTokenCount ?? state.usage.input,
+        output: u.candidatesTokenCount ?? state.usage.output,
+        cacheRead: u.cachedContentTokenCount ?? state.usage.cacheRead
+      };
+    }
+    return out;
+  },
+  finalizeStream: (state) => {
+    if (state.finalEmitted || !state.started) return [];
+    state.finalEmitted = true;
+    const finalStop = state.sawFunctionCall ? "tool_use" : state.stopReason;
+    return [{ type: "message_stop", stopReason: finalStop, usage: state.usage }];
+  }
+});
+function 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 toolsToGemini2(tools) {
+  return tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    parameters: sanitizeSchemaForGemini2(t.inputSchema) ?? {
+      type: "object",
+      properties: {}
+    }
+  }));
+}
+var GEMINI_ALLOWED_KEYS2 = /* @__PURE__ */ new Set([
+  "type",
+  "format",
+  "description",
+  "nullable",
+  "enum",
+  "items",
+  "properties",
+  "required",
+  "anyOf",
+  "minLength",
+  "maxLength",
+  "pattern",
+  "minimum",
+  "maximum",
+  "minItems",
+  "maxItems",
+  "minProperties",
+  "maxProperties",
+  "propertyOrdering",
+  "title"
+]);
+function sanitizeSchemaForGemini2(node) {
+  if (node === null || node === void 0) return void 0;
+  if (Array.isArray(node)) return void 0;
+  if (typeof node !== "object") return void 0;
+  const src = node;
+  const out = {};
+  for (const [k, v] of Object.entries(src)) {
+    if (!GEMINI_ALLOWED_KEYS2.has(k)) continue;
+    if (k === "properties" && v && typeof v === "object") {
+      const props = {};
+      for (const [pname, pschema] of Object.entries(v)) {
+        const cleaned = sanitizeSchemaForGemini2(pschema);
+        if (cleaned) props[pname] = cleaned;
+      }
+      out["properties"] = props;
+    } else if (k === "items") {
+      const cleaned = sanitizeSchemaForGemini2(v);
+      if (cleaned) out["items"] = cleaned;
+    } else if (k === "anyOf" && Array.isArray(v)) {
+      const cleaned = v.map((s) => sanitizeSchemaForGemini2(s)).filter((s) => s !== void 0);
+      if (cleaned.length > 0) out["anyOf"] = cleaned;
+    } else if (k === "required" && Array.isArray(v)) {
+      out["required"] = v.filter((s) => typeof s === "string");
+    } else if (k === "enum" && Array.isArray(v)) {
+      out["enum"] = v;
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function messagesToGemini2(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") {
+          const part = {
+            functionCall: { name: b.name, args: b.input }
+          };
+          const sig = b.providerMeta?.["google.thoughtSignature"];
+          if (typeof sig === "string" && sig.length > 0) {
+            part.thoughtSignature = sig;
+          }
+          parts.push(part);
+        }
+      }
+      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;
 }
 
 // src/capabilities.ts
@@ -1201,6 +1916,6 @@ function requireKey(cfg) {
   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 };
+export { AnthropicProvider, GoogleProvider, OpenAICompatibleProvider, OpenAIProvider, WireAdapter, WireFormatProvider, anthropicWireFormat, buildProviderFactoriesFromRegistry, capabilitiesFor, contentFromAnthropic, contentFromOpenAI, createWireFormatFactory, defineWireFormat, googleWireFormat, makeProviderFromConfig, messagesToOpenAI, mistralWireFormat, normalizeAnthropic, normalizeOpenAI, openaiWireFormat, parseProviderHttpError, toolsToAnthropic, toolsToOpenAI };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map