@wrongstack/providers 0.3.3 → 0.3.7

package/README.md

@@ -10,7 +10,7 @@ Most providers ride a single declarative `WireFormatConfig` adapter; only the th
 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.
+`@wrongstack/core` provides the shared `Provider` interface, message types, and tool format.
 
 ## What's in here
 
@@ -37,13 +37,16 @@ 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: [],
-});
+const stream = provider.stream(
+  {
+    model: 'claude-sonnet-4-6',
+    messages: [{ role: 'user', content: 'hello' }],
+    maxTokens: 512,
+  },
+  { signal: new AbortController().signal },
+);
 
 for await (const event of stream) {
   if (event.type === 'text_delta') process.stdout.write(event.text);
@@ -58,39 +61,48 @@ 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',
+  baseUrl: 'https://api.groq.com/openai/v1',
   capabilities: { tools: true, vision: false, maxContext: 128_000 },
 });
+
+const result = await groq.complete(
+  {
+    model: 'llama-3.3-70b-versatile',
+    messages: [{ role: 'user', content: 'hello' }],
+    maxTokens: 512,
+  },
+  { signal: new AbortController().signal },
+);
 ```
 
 ## 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.
+For a new provider that doesn't fit one of the existing presets, write a `WireFormatConfig` and plug it into `WireFormatProvider`. 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';
+import { WireFormatProvider, type WireFormatConfig } from '@wrongstack/providers';
 
 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
+  id: 'myprovider',
+  family: 'openai-compatible',
+  capabilities: { tools: true, parallelTools: true, vision: false, streaming: true, promptCache: false, systemPrompt: true, jsonMode: false, maxContext: 32_000, cacheControl: 'none' },
+  defaultBaseUrl: 'https://api.myprovider.com/v1',
+  buildUrl: (baseUrl) => `${baseUrl.replace(/\/+$/, '')}/chat/completions`,
+  buildHeaders: (apiKey) => ({ authorization: `Bearer ${apiKey}` }),
+  buildBody: (req) => ({ model: req.model, messages: req.messages, max_tokens: req.maxTokens, stream: true }),
+  createStreamState: (fallbackModel) => ({ model: fallbackModel, started: false }),
+  parseStreamEvent: () => [],
+  finalizeStream: () => [{ type: 'message_stop', stopReason: 'end_turn', usage: { input: 0, output: 0 } }],
 };
 
-const provider = new WireAdapter({
-  id: 'myprovider',
+const provider = new WireFormatProvider(myWire, {
   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.
+Anthropic/OpenAI-style stream parsers and the aggregate path 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
 

package/dist/index.d.ts

@@ -320,16 +320,18 @@ interface MistralStreamState {
         name?: string;
         partial: string;
         emittedStart: boolean;
+        emittedArgLength: number;
     }>;
 }
 declare const mistralWireFormat: WireFormatConfig<MistralStreamState>;
 
-type BlockKind = 'text' | 'tool_use' | 'unknown';
+type BlockKind = 'text' | 'tool_use' | 'thinking' | 'unknown';
 interface AnthropicStreamState {
     model: string;
     usage: Usage;
     stopReason: StopReason;
     started: boolean;
+    stopped: boolean;
     blocks: Map<number, {
         kind: BlockKind;
         id?: string;
@@ -347,9 +349,11 @@ interface OpenAIStreamState {
     textOpen: boolean;
     thinkingOpen: boolean;
     toolByIndex: Map<number, {
-        id: string;
-        name: string;
+        id?: string;
+        name?: string;
         argBuf: string;
+        emittedStart: boolean;
+        emittedArgLength: number;
     }>;
     finalEmitted: boolean;
 }

package/dist/index.js

@@ -433,6 +433,18 @@ function toolsToAnthropic(tools) {
     }
   }));
 }
+function validateResponse(res) {
+  const r = res;
+  if (r === void 0 || typeof r.ok !== "boolean" || typeof r.status !== "number") {
+    throw new Error("fetchImpl returned invalid response shape \u2014 expected { ok, status, text, body }");
+  }
+  if (!("body" in r) || r.body === void 0) {
+    const proto = Object.getPrototypeOf(r);
+    if (proto === Object.prototype || proto === null) {
+      r.body = null;
+    }
+  }
+}
 async function safeText(res) {
   try {
     return await res.text();
@@ -460,12 +472,14 @@ var WireAdapter = class {
     const body = this.buildBody(req);
     let httpRes;
     try {
-      httpRes = await this.fetchImpl(url, {
+      const raw = await this.fetchImpl(url, {
         method: "POST",
         headers,
         body: JSON.stringify(body),
         signal: opts.signal
       });
+      validateResponse(raw);
+      httpRes = raw;
     } catch (err) {
       if (opts.signal.aborted) throw err;
       throw new ProviderError(err instanceof Error ? err.message : String(err), 0, true, this.id, {
@@ -554,6 +568,7 @@ async function* parseAnthropicStream(body, fallbackModel) {
   let usage = { input: 0, output: 0 };
   let stopReason = "end_turn";
   let started = false;
+  let stopped = false;
   for await (const msg of parseSSE(body)) {
     if (!msg.data || msg.data === "[DONE]") continue;
     const parsed = safeParse(msg.data);
@@ -634,6 +649,7 @@ async function* parseAnthropicStream(body, fallbackModel) {
         break;
       }
       case "message_stop":
+        stopped = true;
         yield { type: "message_stop", stopReason, usage };
         break;
       case "error": {
@@ -644,7 +660,7 @@ async function* parseAnthropicStream(body, fallbackModel) {
       }
     }
   }
-  if (started) {
+  if (started && !stopped) {
     yield { type: "message_stop", stopReason, usage };
   }
 }
@@ -1086,17 +1102,33 @@ async function* parseOpenAIStream(body, fallbackModel) {
       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: "" };
+        if (!entry) {
+          entry = {
+            id: tc.id,
+            name: tc.function?.name,
+            argBuf: "",
+            emittedStart: false,
+            emittedArgLength: 0
+          };
           toolByIndex.set(idx, entry);
-          yield { type: "tool_use_start", id: entry.id, name: entry.name };
+        } else {
+          if (tc.id && !entry.id) entry.id = tc.id;
+          if (tc.function?.name && !entry.name) entry.name = tc.function.name;
         }
-        if (entry && tc.function?.arguments) {
+        if (tc.function?.arguments) {
           entry.argBuf += tc.function.arguments;
+        }
+        if (!entry.emittedStart && entry.id && entry.name) {
+          entry.emittedStart = true;
+          yield { type: "tool_use_start", id: entry.id, name: entry.name };
+        }
+        if (entry.emittedStart && entry.id && entry.emittedArgLength < entry.argBuf.length) {
+          const partial = entry.argBuf.slice(entry.emittedArgLength);
+          entry.emittedArgLength = entry.argBuf.length;
           yield {
             type: "tool_use_input_delta",
             id: entry.id,
-            partial: tc.function.arguments
+            partial
           };
         }
       }
@@ -1106,10 +1138,11 @@ async function* parseOpenAIStream(body, fallbackModel) {
     }
     const u = obj["usage"];
     if (u) {
-      const cached = u.prompt_tokens_details?.cached_tokens ?? 0;
-      const promptTotal = u.prompt_tokens ?? usage.input + cached;
+      const hasDeepSeekCacheFields = u.prompt_cache_hit_tokens !== void 0 || u.prompt_cache_miss_tokens !== void 0;
+      const cached = u.prompt_tokens_details?.cached_tokens ?? u.prompt_cache_hit_tokens ?? 0;
+      const promptTotal = u.prompt_tokens ?? (hasDeepSeekCacheFields ? (u.prompt_cache_hit_tokens ?? 0) + (u.prompt_cache_miss_tokens ?? 0) : usage.input + cached);
       usage = {
-        input: Math.max(0, promptTotal - cached),
+        input: u.prompt_cache_miss_tokens ?? Math.max(0, promptTotal - cached),
         output: u.completion_tokens ?? usage.output,
         cacheRead: cached || usage.cacheRead
       };
@@ -1119,6 +1152,10 @@ async function* parseOpenAIStream(body, fallbackModel) {
     yield { type: "thinking_stop" };
   }
   for (const entry of toolByIndex.values()) {
+    if (!entry.id || !entry.name) continue;
+    if (!entry.emittedStart) {
+      yield { type: "tool_use_start", id: entry.id, name: entry.name };
+    }
     const input = parseToolInput(entry.argBuf);
     yield { type: "tool_use_stop", id: entry.id, input };
   }
@@ -1237,16 +1274,31 @@ var mistralWireFormat = defineWireFormat({
   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
-  }),
+  buildBody: (req) => {
+    const body = {
+      model: req.model,
+      messages: messagesToOpenAI(stripCacheControl(req.system), req.messages, {}),
+      max_tokens: req.maxTokens,
+      stream: 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,
     started: false,
@@ -1270,25 +1322,38 @@ var mistralWireFormat = defineWireFormat({
     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 };
+        block = {
+          id: tc.id,
+          name: tc.function?.name,
+          partial: "",
+          emittedStart: false,
+          emittedArgLength: 0
+        };
         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;
       }
+      const arg = tc.function?.arguments;
+      if (arg) {
+        block.partial += arg;
+      }
       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 (block.emittedStart && block.id && block.emittedArgLength < block.partial.length) {
+        const partial = block.partial.slice(block.emittedArgLength);
+        block.emittedArgLength = block.partial.length;
+        out.push({ type: "tool_use_input_delta", id: block.id, partial });
       }
     }
     if (choice?.finish_reason) {
       for (const block of state.toolCalls.values()) {
-        if (block.id) {
+        if (block.id && block.name) {
+          if (!block.emittedStart) {
+            out.push({ type: "tool_use_start", id: block.id, name: block.name });
+          }
           out.push({
             type: "tool_use_stop",
             id: block.id,
@@ -1313,13 +1378,21 @@ function mapStopReason(reason) {
     case "tool_calls":
       return "tool_use";
     case "length":
+    case "model_length":
       return "max_tokens";
     case "stop":
-      return "stop_sequence";
+      return "end_turn";
     default:
       return "end_turn";
   }
 }
+function stripCacheControl(system) {
+  if (!system) return void 0;
+  return system.map((b) => {
+    const { cache_control: _cc, ...rest } = b;
+    return rest;
+  });
+}
 
 // src/presets/anthropic.ts
 init_tool_input();
@@ -1362,6 +1435,7 @@ var anthropicWireFormat = defineWireFormat({
     usage: { input: 0, output: 0 },
     stopReason: "end_turn",
     started: false,
+    stopped: false,
     blocks: /* @__PURE__ */ new Map()
   }),
   parseStreamEvent: (msg, state) => {
@@ -1397,6 +1471,9 @@ var anthropicWireFormat = defineWireFormat({
           }
         } else if (cb?.type === "text") {
           state.blocks.set(index, { kind: "text", partial: "" });
+        } else if (cb?.type === "thinking" || cb?.type === "redacted_thinking") {
+          state.blocks.set(index, { kind: "thinking", partial: "" });
+          out.push({ type: "thinking_start" });
         } else {
           state.blocks.set(index, { kind: "unknown", partial: "" });
         }
@@ -1414,6 +1491,10 @@ var anthropicWireFormat = defineWireFormat({
             block.partial += delta.partial_json;
             out.push({ type: "tool_use_input_delta", id: block.id, partial: delta.partial_json });
           }
+        } else if (delta.type === "thinking_delta" && typeof delta.thinking === "string") {
+          out.push({ type: "thinking_delta", text: delta.thinking });
+        } else if (delta.type === "signature_delta" && typeof delta.signature === "string") {
+          out.push({ type: "thinking_signature", signature: delta.signature });
         }
         break;
       }
@@ -1423,6 +1504,8 @@ var anthropicWireFormat = defineWireFormat({
         if (block?.kind === "tool_use" && block.id) {
           const input = parseToolInput(block.partial);
           out.push({ type: "tool_use_stop", id: block.id, input });
+        } else if (block?.kind === "thinking") {
+          out.push({ type: "thinking_stop" });
         }
         break;
       }
@@ -1438,6 +1521,7 @@ var anthropicWireFormat = defineWireFormat({
         break;
       }
       case "message_stop":
+        state.stopped = true;
         out.push({ type: "message_stop", stopReason: state.stopReason, usage: state.usage });
         break;
       case "error": {
@@ -1450,7 +1534,7 @@ var anthropicWireFormat = defineWireFormat({
     return out;
   },
   finalizeStream: (state) => {
-    if (state.started) {
+    if (state.started && !state.stopped) {
       return [{ type: "message_stop", stopReason: state.stopReason, usage: state.usage }];
     }
     return [];
@@ -1474,7 +1558,7 @@ var openaiWireFormat = defineWireFormat({
   buildBody: (req) => {
     const body = {
       model: req.model,
-      messages: messagesToOpenAI(stripCacheControl(req.system), req.messages, {}),
+      messages: messagesToOpenAI(stripCacheControl2(req.system), req.messages, {}),
       max_tokens: req.maxTokens,
       stream: true,
       stream_options: { include_usage: true }
@@ -1544,18 +1628,34 @@ var openaiWireFormat = defineWireFormat({
       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: "" };
+        if (!entry) {
+          entry = {
+            id: tc.id,
+            name: tc.function?.name,
+            argBuf: "",
+            emittedStart: false,
+            emittedArgLength: 0
+          };
           state.toolByIndex.set(idx, entry);
+        } else {
+          if (tc.id && !entry.id) entry.id = tc.id;
+          if (tc.function?.name && !entry.name) entry.name = tc.function.name;
+        }
+        if (tc.function?.arguments) {
+          entry.argBuf += tc.function.arguments;
+        }
+        if (!entry.emittedStart && entry.id && entry.name) {
+          entry.emittedStart = true;
           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;
+        if (entry.emittedStart && entry.id && entry.emittedArgLength < entry.argBuf.length) {
+          const partial = entry.argBuf.slice(entry.emittedArgLength);
+          entry.emittedArgLength = entry.argBuf.length;
           out.push({
             type: "tool_use_input_delta",
             id: entry.id,
-            partial: tc.function.arguments
+            partial
           });
         }
       }
@@ -1565,10 +1665,11 @@ var openaiWireFormat = defineWireFormat({
     }
     const u = obj["usage"];
     if (u) {
-      const cached = u.prompt_tokens_details?.cached_tokens ?? 0;
-      const promptTotal = u.prompt_tokens ?? state.usage.input + cached;
+      const hasDeepSeekCacheFields = u.prompt_cache_hit_tokens !== void 0 || u.prompt_cache_miss_tokens !== void 0;
+      const cached = u.prompt_tokens_details?.cached_tokens ?? u.prompt_cache_hit_tokens ?? 0;
+      const promptTotal = u.prompt_tokens ?? (hasDeepSeekCacheFields ? (u.prompt_cache_hit_tokens ?? 0) + (u.prompt_cache_miss_tokens ?? 0) : state.usage.input + cached);
       state.usage = {
-        input: Math.max(0, promptTotal - cached),
+        input: u.prompt_cache_miss_tokens ?? Math.max(0, promptTotal - cached),
         output: u.completion_tokens ?? state.usage.output,
         cacheRead: cached || state.usage.cacheRead
       };
@@ -1584,6 +1685,10 @@ var openaiWireFormat = defineWireFormat({
       out.push({ type: "thinking_stop" });
     }
     for (const entry of state.toolByIndex.values()) {
+      if (!entry.id || !entry.name) continue;
+      if (!entry.emittedStart) {
+        out.push({ type: "tool_use_start", id: entry.id, name: entry.name });
+      }
       const input = parseToolInput(entry.argBuf);
       out.push({ type: "tool_use_stop", id: entry.id, input });
     }
@@ -1593,7 +1698,7 @@ var openaiWireFormat = defineWireFormat({
     return out;
   }
 });
-function stripCacheControl(system) {
+function stripCacheControl2(system) {
   if (!system) return void 0;
   return system.map((b) => {
     const { cache_control: _cc, ...rest } = b;