@wrongstack/providers 0.1.4 → 0.1.8

package/README.md

@@ -0,0 +1,101 @@
+# @wrongstack/providers
+
+LLM provider adapters for WrongStack: Anthropic, OpenAI, Google, OpenAI-compatible (Mistral, Groq, DeepSeek, Together, Fireworks, OpenRouter, …).
+
+Most providers ride a single declarative `WireFormatConfig` adapter; only the three majors (Anthropic / OpenAI / Google) have hand-written classes. Adding a new provider is usually a 20-line preset, not a new file.
+
+## Install
+
+```bash
+pnpm add @wrongstack/providers @wrongstack/core
+```
+
+`@wrongstack/core` is a peer of every provider — providers depend on the core `Provider` interface, message types, and tool format.
+
+## What's in here
+
+```
+src/
+  anthropic.ts             native Anthropic Messages API
+  openai.ts                native OpenAI Chat Completions API
+  google.ts                native Google Gemini generateContent API
+  openai-compatible.ts     drop-in for any /v1/chat/completions endpoint
+  wire-adapter.ts          declarative adapter — pass a WireFormatConfig
+  presets/                 wire configs for anthropic / openai / google / mistral
+  sse.ts                   SSE parser with 256 KB buffer cap
+  aggregate.ts             tool_use stream-event aggregator
+  tool-format/             tools ↔ Anthropic / OpenAI converters
+  stop-reason.ts           normalize provider stop_reason → canonical
+  error-parse.ts           parse provider HTTP error envelopes
+  capabilities.ts          map models.dev capability strings → bool flags
+```
+
+## Quick example
+
+```ts
+import { AnthropicProvider } from '@wrongstack/providers';
+
+const provider = new AnthropicProvider({
+  apiKey: process.env.ANTHROPIC_API_KEY!,
+  modelId: 'claude-sonnet-4-6',
+});
+
+const stream = provider.stream({
+  messages: [{ role: 'user', content: 'hello' }],
+  tools: [],
+});
+
+for await (const event of stream) {
+  if (event.type === 'text_delta') process.stdout.write(event.text);
+}
+```
+
+## Using a preset (OpenAI-compatible service)
+
+```ts
+import { OpenAICompatibleProvider } from '@wrongstack/providers';
+
+const groq = new OpenAICompatibleProvider({
+  id: 'groq',
+  apiKey: process.env.GROQ_API_KEY!,
+  baseURL: 'https://api.groq.com/openai/v1',
+  modelId: 'llama-3.3-70b-versatile',
+  capabilities: { tools: true, vision: false, maxContext: 128_000 },
+});
+```
+
+## Wire-format adapter (declarative)
+
+For a new provider that doesn't fit one of the existing presets, write a `WireFormatConfig` and plug it into `WireAdapter`. See [docs/provider-author-guide.md](../../docs/provider-author-guide.md) for the full spec.
+
+```ts
+import { WireAdapter } from '@wrongstack/providers';
+import type { WireFormatConfig } from '@wrongstack/core';
+
+const myWire: WireFormatConfig = {
+  family: 'openai',
+  endpoint: 'https://api.myprovider.com/v1/chat/completions',
+  authHeader: (key) => ({ 'Authorization': `Bearer ${key}` }),
+  // tool format, message shape, stream parsing — see WireFormatConfig type
+};
+
+const provider = new WireAdapter({
+  id: 'myprovider',
+  apiKey: '…',
+  modelId: 'my-model-1',
+  wire: myWire,
+  capabilities: { tools: true, maxContext: 32_000 },
+});
+```
+
+## Tool input parsing (`parseToolInput`)
+
+All four stream parsers (anthropic / openai / aggregate + the three OpenAI-compatible presets) run tool-call JSON through one canonical helper: [`_tool-input.ts`](src/_tool-input.ts). It guarantees the agent always receives a `Record<string, unknown>` for `tool_use.input`, never a parse-error or `null`. Invalid or non-object inputs are wrapped under `{ __raw: ... }` instead of crashing the provider runner.
+
+## Capabilities
+
+The capability flags on each provider come from [models.dev](https://models.dev) catalog data, mapped by `capabilitiesFor()`. The agent uses them to pick adaptive context-management thresholds, gate vision/reasoning features, and refuse tools on models that don't support tool calls.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -360,6 +360,9 @@ declare const googleWireFormat: WireFormatConfig<GoogleStreamState>;
  */
 declare function capabilitiesFor(registry: ModelsRegistry, providerId: string, modelId: string): Promise<Capabilities>;
 
+declare const CAPABILITIES_BY_FAMILY: Record<WireFamily, Capabilities>;
+declare function capabilitiesForFamily(family: WireFamily, overrides?: Partial<Capabilities>): Capabilities;
+
 /**
  * Provider HTTP error bodies come in three or four shapes depending on
  * vendor. Rather than dump the raw JSON into the error message (which is
@@ -459,4 +462,4 @@ declare function buildProviderFactoriesFromRegistry(opts: BuildFactoriesOptions)
  */
 declare function makeProviderFromConfig(id: string, cfg: ProviderConfig): Provider;
 
-export { AnthropicProvider, type AnthropicProviderOptions, type BuildFactoriesOptions, type CompatibilityQuirks, type ConvertOptions, GoogleProvider, type GoogleProviderOptions, type OpenAIChoice, type OpenAICompatibleOptions, OpenAICompatibleProvider, type OpenAIMessage, OpenAIProvider, type OpenAIProviderOptions, type OpenAIToolCall, WireAdapter, type WireFactoryOptions, type WireFormatConfig, WireFormatProvider, anthropicWireFormat, buildProviderFactoriesFromRegistry, capabilitiesFor, contentFromAnthropic, contentFromOpenAI, createWireFormatFactory, defineWireFormat, googleWireFormat, makeProviderFromConfig, messagesToOpenAI, mistralWireFormat, normalizeAnthropic, normalizeOpenAI, openaiWireFormat, parseProviderHttpError, toolsToAnthropic, toolsToOpenAI };
+export { AnthropicProvider, type AnthropicProviderOptions, type BuildFactoriesOptions, CAPABILITIES_BY_FAMILY, type CompatibilityQuirks, type ConvertOptions, GoogleProvider, type GoogleProviderOptions, type OpenAIChoice, type OpenAICompatibleOptions, OpenAICompatibleProvider, type OpenAIMessage, OpenAIProvider, type OpenAIProviderOptions, type OpenAIToolCall, WireAdapter, type WireFactoryOptions, type WireFormatConfig, WireFormatProvider, anthropicWireFormat, buildProviderFactoriesFromRegistry, capabilitiesFor, capabilitiesForFamily, contentFromAnthropic, contentFromOpenAI, createWireFormatFactory, defineWireFormat, googleWireFormat, makeProviderFromConfig, messagesToOpenAI, mistralWireFormat, normalizeAnthropic, normalizeOpenAI, openaiWireFormat, parseProviderHttpError, toolsToAnthropic, toolsToOpenAI };

package/dist/index.js

@@ -1,4 +1,5 @@
-import { safeParse, ProviderError, sanitizeJsonString } from '@wrongstack/core';
+import { ProviderError, safeParse, sanitizeJsonString } from '@wrongstack/core';
+import { randomUUID } from 'crypto';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -9,6 +10,20 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+function parseToolInput(raw) {
+  if (!raw) return {};
+  const parsed = safeParse(raw);
+  if (!parsed.ok) return { __raw: raw };
+  const v = parsed.value;
+  if (v && typeof v === "object" && !Array.isArray(v)) {
+    return v;
+  }
+  return { __raw: v ?? raw };
+}
+var init_tool_input = __esm({
+  "src/_tool-input.ts"() {
+  }
+});
 
 // src/aggregate.ts
 var aggregate_exports = {};
@@ -50,13 +65,14 @@ async function aggregateStream(stream, onEvent) {
       case "tool_use_stop": {
         const b = toolBuffers.get(ev.id);
         if (b) {
-          if (ev.input !== void 0) {
+          if (ev.input === void 0) {
+            b.input = parseToolInput(b.partial);
+          } else if (typeof ev.input === "string") {
+            b.input = parseToolInput(ev.input);
+          } else if (ev.input && typeof ev.input === "object" && !Array.isArray(ev.input)) {
             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 = {};
+            b.input = { __raw: ev.input };
           }
         }
         currentTextIndex = -1;
@@ -80,7 +96,7 @@ async function aggregateStream(stream, onEvent) {
           type: "tool_use",
           id: b.id,
           name: tb.name,
-          input: tb.input ?? {}
+          input: tb.input && typeof tb.input === "object" && !Array.isArray(tb.input) ? tb.input : {}
         });
       }
     }
@@ -90,6 +106,7 @@ async function aggregateStream(stream, onEvent) {
 }
 var init_aggregate = __esm({
   "src/aggregate.ts"() {
+    init_tool_input();
   }
 });
 function parseProviderHttpError(providerId, status, rawText) {
@@ -98,9 +115,10 @@ function parseProviderHttpError(providerId, status, rawText) {
   const message = `${providerId} HTTP ${status}`;
   return new ProviderError(message, status, retryable, providerId, { body });
 }
+var RAW_TRUNCATE_AT = 2e3;
 function parseBody(rawText) {
-  const raw = rawText.slice(0, 2e3);
-  const body = { raw };
+  const raw = rawText.slice(0, RAW_TRUNCATE_AT);
+  const body = rawText.length > RAW_TRUNCATE_AT ? { raw, truncated: true, rawLength: rawText.length } : { raw };
   if (!rawText.trim()) return body;
   let parsed;
   try {
@@ -144,6 +162,9 @@ function stringOf(v) {
   return typeof v === "string" && v.length > 0 ? v : void 0;
 }
 
+// src/anthropic.ts
+init_tool_input();
+
 // src/tool-format/to-anthropic.ts
 function toolsToAnthropic(tools) {
   return tools.map((t) => ({
@@ -209,6 +230,7 @@ function normalizeGemini(stop) {
 }
 
 // src/sse.ts
+var MAX_BUFFER_BYTES = 256 * 1024;
 async function* parseSSE(body) {
   if (!body) return;
   const decoder = new TextDecoder("utf-8");
@@ -241,12 +263,23 @@ async function* parseSSE(body) {
     else if (field === "data") dataLines.push(value);
     return void 0;
   };
+  const appendChunk = (chunkStr) => {
+    if (chunkStr.length === 0) return;
+    buffer += chunkStr;
+    if (buffer.length > MAX_BUFFER_BYTES) {
+      throw new Error(
+        `SSE: pending line exceeds ${MAX_BUFFER_BYTES} bytes \u2014 upstream is not framing events`
+      );
+    }
+  };
   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) {
+      appendChunk(
+        typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true })
+      );
+      const split = splitBuffer(buffer);
+      buffer = split.tail;
+      for (const line of split.lines) {
         const msg = processLine(line);
         if (msg) yield msg;
       }
@@ -257,10 +290,10 @@ async function* parseSSE(body) {
       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) {
+        appendChunk(decoder.decode(value, { stream: true }));
+        const split = splitBuffer(buffer);
+        buffer = split.tail;
+        for (const line of split.lines) {
           const msg = processLine(line);
           if (msg) yield msg;
         }
@@ -270,17 +303,17 @@ async function* parseSSE(body) {
     }
   }
   if (buffer.length > 0) {
-    const msg = processLine(buffer);
+    const msg = processLine(buffer.replace(/\r$/, ""));
     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 parts = buf.split("\n");
   const tail = parts.pop() ?? "";
-  return { lines: parts, tail };
+  const lines = parts.map((p) => p.endsWith("\r") ? p.slice(0, -1) : p);
+  return { lines, tail };
 }
 function isNodeReadable(b) {
   return !!b && typeof b === "object" && typeof b.pipe === "function" && typeof b.on === "function";
@@ -347,12 +380,9 @@ var WireAdapter = class {
   }
 };
 
-// src/anthropic.ts
-var DEFAULT_BASE = "https://api.anthropic.com";
-var DEFAULT_VERSION = "2023-06-01";
-var AnthropicProvider = class extends WireAdapter {
-  id = "anthropic";
-  capabilities = {
+// src/family-capabilities.ts
+var CAPABILITIES_BY_FAMILY = {
+  anthropic: {
     tools: true,
     parallelTools: true,
     vision: true,
@@ -362,7 +392,65 @@ var AnthropicProvider = class extends WireAdapter {
     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 capabilitiesForFamily(family, overrides = {}) {
+  return {
+    ...CAPABILITIES_BY_FAMILY[family] ?? CAPABILITIES_BY_FAMILY.unsupported,
+    ...overrides
   };
+}
+
+// src/anthropic.ts
+var DEFAULT_BASE = "https://api.anthropic.com";
+var DEFAULT_VERSION = "2023-06-01";
+var AnthropicProvider = class extends WireAdapter {
+  id = "anthropic";
+  capabilities = capabilitiesForFamily("anthropic");
   opts;
   constructor(opts) {
     super(opts.apiKey, opts.baseUrl ?? DEFAULT_BASE, opts.fetchImpl);
@@ -475,7 +563,7 @@ async function* parseAnthropicStream(body, fallbackModel) {
         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 ?? {} : {};
+          const input = parseToolInput(block.partial);
           yield { type: "tool_use_stop", id: block.id, input };
         }
         break;
@@ -508,6 +596,7 @@ async function* parseAnthropicStream(body, fallbackModel) {
     yield { type: "message_stop", stopReason, usage };
   }
 }
+init_tool_input();
 
 // src/tool-format/to-openai.ts
 function toolsToOpenAI(tools) {
@@ -613,18 +702,11 @@ var OpenAIProvider = class extends WireAdapter {
     super(opts.apiKey, opts.baseUrl ?? DEFAULT_BASE2, opts.fetchImpl);
     this.opts = opts;
     this.id = opts.id ?? "openai";
-    this.capabilities = {
-      tools: true,
+    this.capabilities = capabilitiesForFamily("openai", {
       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(/\/+$/, "");
@@ -737,7 +819,7 @@ async function* parseOpenAIStream(body, fallbackModel) {
     }
   }
   for (const entry of toolByIndex.values()) {
-    const input = entry.argBuf ? safeParse(entry.argBuf).value ?? { _raw: entry.argBuf } : {};
+    const input = parseToolInput(entry.argBuf);
     yield { type: "tool_use_stop", id: entry.id, input };
   }
   if (started) {
@@ -755,12 +837,12 @@ var OpenAICompatibleProvider = class extends OpenAIProvider {
       baseUrl: opts.baseUrl,
       fetchImpl: opts.fetchImpl,
       id: opts.id,
-      capabilities: opts.capabilities,
-      quirks: {
-        ...opts.quirks,
-        parallelToolsDisabled: opts.quirks?.parallelToolsDisabled,
-        jsonArgumentsBuggy: opts.quirks?.jsonArgumentsBuggy
-      }
+      capabilities: capabilitiesForFamily("openai-compatible", {
+        parallelTools: !opts.quirks?.parallelToolsDisabled,
+        systemPrompt: !opts.quirks?.systemAsMessage,
+        ...opts.capabilities
+      }),
+      quirks: opts.quirks
     });
     this.extraHeaders = opts.headers;
     this.urlOverride = opts.urlOverride;
@@ -787,18 +869,9 @@ var GoogleProvider = class extends WireAdapter {
     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",
+    this.capabilities = capabilitiesForFamily("google", {
       ...opts.capabilities
-    };
+    });
   }
   buildUrl(req) {
     return `${this.baseUrl}/models/${encodeURIComponent(req.model)}:streamGenerateContent?alt=sse`;
@@ -945,8 +1018,9 @@ function messagesToGemini(messages) {
         });
       }
     }
-    if (textParts.length > 0) out.push({ role: "user", parts: textParts });
-    if (functionParts.length > 0) out.push({ role: "function", parts: functionParts });
+    const userParts = [...textParts];
+    if (functionParts.length > 0) userParts.push(...functionParts);
+    if (userParts.length > 0) out.push({ role: "user", parts: userParts });
   }
   return out;
 }
@@ -972,7 +1046,7 @@ async function* parseGoogleStream(body, fallbackModel) {
         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)}`;
+        const id = randomUUID();
         yield { type: "tool_use_start", id, name: part.functionCall.name };
         const providerMeta = typeof part.thoughtSignature === "string" ? { "google.thoughtSignature": part.thoughtSignature } : void 0;
         yield {
@@ -1064,20 +1138,16 @@ function createWireFormatFactory(cfg, opts = {}) {
     }
   };
 }
+
+// src/presets/mistral.ts
+init_tool_input();
 var mistralWireFormat = defineWireFormat({
   id: "mistral",
   family: "openai-compatible",
-  capabilities: {
-    tools: true,
-    parallelTools: true,
-    vision: false,
-    streaming: true,
-    promptCache: false,
-    systemPrompt: true,
+  capabilities: capabilitiesForFamily("openai-compatible", {
     jsonMode: true,
-    maxContext: 128e3,
-    cacheControl: "none"
-  },
+    maxContext: 128e3
+  }),
   defaultBaseUrl: "https://api.mistral.ai/v1",
   buildUrl: (base) => `${base.replace(/\/+$/, "")}/chat/completions`,
   buildHeaders: (apiKey) => ({ authorization: `Bearer ${apiKey}` }),
@@ -1133,11 +1203,10 @@ var mistralWireFormat = defineWireFormat({
     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 : {}
+            input: parseToolInput(block.partial)
           });
         }
       }
@@ -1165,21 +1234,14 @@ function mapStopReason(reason) {
       return "end_turn";
   }
 }
+
+// src/presets/anthropic.ts
+init_tool_input();
 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"
-  },
+  capabilities: capabilitiesForFamily("anthropic"),
   defaultBaseUrl: "https://api.anthropic.com",
   buildUrl: (base) => {
     const b = base.replace(/\/+$/, "");
@@ -1273,7 +1335,7 @@ var anthropicWireFormat = defineWireFormat({
         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 ?? {} : {};
+          const input = parseToolInput(block.partial);
           out.push({ type: "tool_use_stop", id: block.id, input });
         }
         break;
@@ -1312,20 +1374,13 @@ var anthropicWireFormat = defineWireFormat({
     return [];
   }
 });
+
+// src/presets/openai.ts
+init_tool_input();
 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"
-  },
+  capabilities: capabilitiesForFamily("openai"),
   defaultBaseUrl: "https://api.openai.com/v1",
   buildUrl: (base) => {
     const b = base.replace(/\/+$/, "");
@@ -1424,7 +1479,7 @@ var openaiWireFormat = defineWireFormat({
     state.finalEmitted = true;
     const out = [];
     for (const entry of state.toolByIndex.values()) {
-      const input = entry.argBuf ? safeParse(entry.argBuf).value ?? { _raw: entry.argBuf } : {};
+      const input = parseToolInput(entry.argBuf);
       out.push({ type: "tool_use_stop", id: entry.id, input });
     }
     if (state.started) {
@@ -1443,17 +1498,7 @@ function stripCacheControl(system) {
 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"
-  },
+  capabilities: capabilitiesForFamily("google"),
   defaultBaseUrl: "https://generativelanguage.googleapis.com/v1beta",
   buildUrl: (base, req) => `${base}/models/${encodeURIComponent(req.model)}:streamGenerateContent?alt=sse`,
   buildHeaders: (apiKey) => ({ "x-goog-api-key": apiKey }),
@@ -1650,74 +1695,15 @@ function messagesToGemini2(messages) {
 }
 
 // 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 base = capabilitiesForFamily(provider?.family ?? "unsupported");
   const model = await registry.getModel(providerId, modelId);
   if (!model) return { ...base };
   return {
     ...base,
     tools: model.capabilities.tools && base.tools,
+    parallelTools: model.capabilities.tools && base.parallelTools,
     vision: model.capabilities.vision && base.vision,
     maxContext: model.capabilities.maxContext || base.maxContext
   };
@@ -1800,12 +1786,15 @@ function parseToolArguments(raw, toolName, toolCallId, opts) {
     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;
+    const sanitized = sanitizeJsonString(raw);
+    if (sanitized !== null) {
+      try {
+        const parsed = JSON.parse(sanitized);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          return parsed;
+        }
+      } catch {
       }
-    } catch {
     }
     opts.onParseFailure?.({ toolName, toolCallId, raw });
     return { __raw_arguments: raw };
@@ -1916,6 +1905,6 @@ function requireKey(cfg) {
   throw new Error("Provider config requires apiKey (or set the corresponding env var).");
 }
 
-export { AnthropicProvider, GoogleProvider, OpenAICompatibleProvider, OpenAIProvider, WireAdapter, WireFormatProvider, anthropicWireFormat, buildProviderFactoriesFromRegistry, capabilitiesFor, contentFromAnthropic, contentFromOpenAI, createWireFormatFactory, defineWireFormat, googleWireFormat, makeProviderFromConfig, messagesToOpenAI, mistralWireFormat, normalizeAnthropic, normalizeOpenAI, openaiWireFormat, parseProviderHttpError, toolsToAnthropic, toolsToOpenAI };
+export { AnthropicProvider, CAPABILITIES_BY_FAMILY, GoogleProvider, OpenAICompatibleProvider, OpenAIProvider, WireAdapter, WireFormatProvider, anthropicWireFormat, buildProviderFactoriesFromRegistry, capabilitiesFor, capabilitiesForFamily, contentFromAnthropic, contentFromOpenAI, createWireFormatFactory, defineWireFormat, googleWireFormat, makeProviderFromConfig, messagesToOpenAI, mistralWireFormat, normalizeAnthropic, normalizeOpenAI, openaiWireFormat, parseProviderHttpError, toolsToAnthropic, toolsToOpenAI };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map