@deepstrike/sdk 0.2.30 → 0.2.31

package/dist/providers/openai.js

@@ -25,6 +25,15 @@ const OPENAI_POLICIES = {
     "o3-mini": { maxTurns: 25 },
     "o4-mini": { maxTurns: 25 },
 };
+/** Rebuild OpenAI-native `tool_calls` blocks from the streamed buffers — needed by reasoning
+ *  vendors (DeepSeek/MiniMax) that persist the native blocks in their replay envelope. */
+export function nativeToolCallsFromBuffers(toolCallBufs) {
+    return Object.values(toolCallBufs).map(tb => ({
+        id: tb.id,
+        type: "function",
+        function: { name: tb.name, arguments: tb.argsBuf || "{}" },
+    }));
+}
 export class OpenAIChatProvider {
     client;
     circuit;
@@ -75,6 +84,46 @@ export class OpenAIChatProvider {
             degradeMissingReasoning: this.degradeMissingReasoningReplay(extensions),
         });
     }
+    // ── Template-Method hooks ───────────────────────────────────────────────────
+    // Defaults reproduce the plain OpenAI-chat behavior; reasoning vendors
+    // (DeepSeek/MiniMax) override these instead of duplicating complete()/stream().
+    /** Pre-process caller extensions before they reach buildChatMessages + the wire request
+     *  (e.g. set `__deepstrikeThinkingEnabled`). Default: pass through unchanged. */
+    prepareExtensions(extensions) {
+        return extensions;
+    }
+    /** Extra top-level request-body fields merged into the chat.completions call (vendor thinking
+     *  knobs like `reasoning_effort`, `extra_body`, `reasoning_split`). Default: none. */
+    requestBodyExtras(_extensions) {
+        return {};
+    }
+    /** Request-body params controlling prompt caching. Default sends OpenAI's `prompt_cache_key`;
+     *  vendors whose endpoints reject unknown params (e.g. DeepSeek 400s) override to `{}`. */
+    cacheKeyParams(context, tools) {
+        return { prompt_cache_key: this.promptCacheKey(context, tools) };
+    }
+    /** Whether streamed `content` may carry inline `<thinking>…</thinking>` tags to split out.
+     *  Default true (OpenAI). Reasoning vendors emit reasoning out-of-band, so they return false. */
+    usesInlineThinkingTags() {
+        return true;
+    }
+    /** Whether to surface streamed `reasoning_content` as thinking_delta events. Default true;
+     *  vendors gate this behind an `exposeReasoning` extension. */
+    exposeReasoningDelta(_extensions) {
+        return true;
+    }
+    /** Persist replay after a non-streaming turn. Default: nothing (plain OpenAI has no reasoning
+     *  to replay). Reasoning vendors override to store their envelope. */
+    rememberCompleteReplay(_content, _toolCalls, _reasoning) {
+        /* no-op */
+    }
+    /** Persist replay after a streamed turn. Default: store `{ reasoning_content }` when there is a
+     *  tool-call turn or captured reasoning (the prior base behavior). Vendors override. */
+    rememberStreamReplay(content, toolCalls, reasoning) {
+        if (toolCalls.length || reasoning.reasoningContent) {
+            this.chat.rememberReplayFields({ content, toolCalls }, { reasoning_content: reasoning.reasoningContent });
+        }
+    }
     /**
      * Pre-flight query: would this history validate against this provider with the
      * given extensions, without sending the request? Lets an embedder route around
@@ -100,23 +149,32 @@ export class OpenAIChatProvider {
         }
     }
     async complete(context, tools, extensions) {
+        const prepared = this.prepareExtensions(extensions);
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");
-        const msgs = this.buildChatMessages(context, extensions);
+        const msgs = this.buildChatMessages(context, prepared);
         let lastErr;
         for (let i = 0; i < this.maxRetries; i++) {
             try {
                 const resp = await this.client.chat.completions.create({
-                    prompt_cache_key: this.promptCacheKey(context, tools),
-                    ...this.requestExtensions(extensions),
+                    ...this.cacheKeyParams(context, tools),
+                    ...this.requestExtensions(prepared),
+                    ...this.requestBodyExtras(extensions),
                     model: this.model,
                     messages: msgs,
                     ...(tools.length ? { tools: this.chat.buildTools(tools) } : {}),
                 });
                 this.circuit.recordSuccess();
                 const choice = resp.choices[0].message;
-                const toolCalls = this.chat.normalizeToolCalls(choice.tool_calls ?? []);
-                return { role: "assistant", content: choice.content ?? "", tokenCount: resp.usage?.completion_tokens ?? resp.usage?.total_tokens, toolCalls };
+                const nativeToolCalls = choice.tool_calls ?? [];
+                const toolCalls = this.chat.normalizeToolCalls(nativeToolCalls);
+                const content = choice.content ?? "";
+                this.rememberCompleteReplay(content, toolCalls, {
+                    reasoningContent: typeof choice.reasoning_content === "string" ? choice.reasoning_content : "",
+                    reasoningDetails: choice.reasoning_details,
+                    nativeToolCalls: nativeToolCalls,
+                });
+                return { role: "assistant", content, tokenCount: resp.usage?.completion_tokens ?? resp.usage?.total_tokens, toolCalls };
             }
             catch (err) {
                 lastErr = err;
@@ -128,15 +186,20 @@ export class OpenAIChatProvider {
         throw lastErr;
     }
     async *stream(context, tools, extensions, _state, signal) {
-        const msgs = this.buildChatMessages(context, extensions);
+        const prepared = this.prepareExtensions(extensions);
+        const msgs = this.buildChatMessages(context, prepared);
         const toolCallBufs = {};
         const emittedToolCallIndexes = new Set();
+        const useTags = this.usesInlineThinkingTags();
+        const exposeReasoning = this.exposeReasoningDelta(extensions);
         const extractor = new ThinkingTagStreamExtractor();
         let accumulatedReasoning = "";
+        let accumulatedReasoningDetails;
         let accumulatedContent = "";
         const stream = await this.client.chat.completions.create({
-            prompt_cache_key: this.promptCacheKey(context, tools),
-            ...this.requestExtensions(extensions),
+            ...this.cacheKeyParams(context, tools),
+            ...this.requestExtensions(prepared),
+            ...this.requestBodyExtras(extensions),
             model: this.model,
             messages: msgs,
             ...(tools.length ? { tools: this.chat.buildTools(tools) } : {}),
@@ -144,6 +207,30 @@ export class OpenAIChatProvider {
             stream_options: { include_usage: true },
             // #2-B-ii: forward the abort signal so a preempt cancels the in-flight HTTP request.
         }, signal ? { signal } : undefined);
+        const rememberStream = () => {
+            const toolCalls = Object.values(toolCallBufs).map(tb => ({ id: tb.id, name: tb.name, arguments: tb.argsBuf || "{}" }));
+            this.rememberStreamReplay(accumulatedContent, toolCalls, {
+                reasoningContent: accumulatedReasoning,
+                reasoningDetails: accumulatedReasoningDetails,
+                nativeToolCalls: nativeToolCallsFromBuffers(toolCallBufs),
+            });
+        };
+        const emitPendingToolCalls = function* () {
+            for (const [index, tb] of Object.entries(toolCallBufs)) {
+                const idx = Number(index);
+                if (emittedToolCallIndexes.has(idx))
+                    continue;
+                let args = {};
+                try {
+                    args = JSON.parse(tb.argsBuf || "{}");
+                }
+                catch {
+                    args = {};
+                }
+                emittedToolCallIndexes.add(idx);
+                yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
+            }
+        };
         let totalTokens = 0;
         let inputTokens = 0;
         let outputTokens = 0;
@@ -163,20 +250,29 @@ export class OpenAIChatProvider {
             if (!delta)
                 continue;
             if (delta.reasoning_content) {
-                accumulatedReasoning += delta.reasoning_content;
-                yield { type: "thinking_delta", delta: delta.reasoning_content };
+                accumulatedReasoning += String(delta.reasoning_content);
+                if (exposeReasoning)
+                    yield { type: "thinking_delta", delta: String(delta.reasoning_content) };
             }
+            if (delta.reasoning_details !== undefined && delta.reasoning_details !== null)
+                accumulatedReasoningDetails = delta.reasoning_details;
             if (delta.content) {
-                for (const part of extractor.feed(delta.content)) {
-                    if (part.type === "thinking") {
-                        accumulatedReasoning += part.content;
-                        yield { type: "thinking_delta", delta: part.content };
-                    }
-                    else {
-                        accumulatedContent += part.content;
-                        yield { type: "text_delta", delta: part.content };
+                if (useTags) {
+                    for (const part of extractor.feed(String(delta.content))) {
+                        if (part.type === "thinking") {
+                            accumulatedReasoning += part.content;
+                            yield { type: "thinking_delta", delta: part.content };
+                        }
+                        else {
+                            accumulatedContent += part.content;
+                            yield { type: "text_delta", delta: part.content };
+                        }
                     }
                 }
+                else {
+                    accumulatedContent += String(delta.content);
+                    yield { type: "text_delta", delta: delta.content };
+                }
             }
             for (const tc of delta.tool_calls ?? []) {
                 const idx = tc.index;
@@ -187,56 +283,24 @@ export class OpenAIChatProvider {
                 toolCallBufs[idx].argsBuf += tc.function?.arguments ?? "";
             }
             if (choice.finish_reason === "tool_calls") {
-                const toolCalls = Object.values(toolCallBufs).map(tb => ({
-                    id: tb.id, name: tb.name, arguments: tb.argsBuf || "{}",
-                }));
-                this.chat.rememberReplayFields({ content: accumulatedContent, toolCalls }, { reasoning_content: accumulatedReasoning });
-                for (const [index, tb] of Object.entries(toolCallBufs)) {
-                    const idx = Number(index);
-                    if (emittedToolCallIndexes.has(idx))
-                        continue;
-                    let args = {};
-                    try {
-                        args = JSON.parse(tb.argsBuf || "{}");
-                    }
-                    catch {
-                        args = {};
-                    }
-                    emittedToolCallIndexes.add(idx);
-                    yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
-                }
-            }
-        }
-        for (const part of extractor.flush()) {
-            if (part.type === "thinking") {
-                accumulatedReasoning += part.content;
-                yield { type: "thinking_delta", delta: part.content };
+                rememberStream();
+                yield* emitPendingToolCalls();
             }
-            else {
-                accumulatedContent += part.content;
-                yield { type: "text_delta", delta: part.content };
-            }
-        }
-        const toolCalls = Object.values(toolCallBufs).map(tb => ({
-            id: tb.id, name: tb.name, arguments: tb.argsBuf || "{}",
-        }));
-        if (toolCalls.length || accumulatedReasoning) {
-            this.chat.rememberReplayFields({ content: accumulatedContent, toolCalls }, { reasoning_content: accumulatedReasoning });
         }
-        for (const [index, tb] of Object.entries(toolCallBufs)) {
-            const idx = Number(index);
-            if (emittedToolCallIndexes.has(idx))
-                continue;
-            let args = {};
-            try {
-                args = JSON.parse(tb.argsBuf || "{}");
-            }
-            catch {
-                args = {};
+        if (useTags) {
+            for (const part of extractor.flush()) {
+                if (part.type === "thinking") {
+                    accumulatedReasoning += part.content;
+                    yield { type: "thinking_delta", delta: part.content };
+                }
+                else {
+                    accumulatedContent += part.content;
+                    yield { type: "text_delta", delta: part.content };
+                }
             }
-            emittedToolCallIndexes.add(idx);
-            yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
         }
+        rememberStream();
+        yield* emitPendingToolCalls();
         if (totalTokens > 0)
             yield { type: "usage", totalTokens, inputTokens, outputTokens, ...(cacheReadTokens > 0 ? { cacheReadInputTokens: cacheReadTokens } : {}) };
     }

package/dist/providers/qwen.d.ts

@@ -1,37 +1,37 @@
-import OpenAI from "openai";
-import type { LLMProvider, Message, ProviderDescriptor, RenderedContext, StreamEvent, ToolSchema, RuntimePolicy, ProviderReplay } from "../types.js";
-import { AnthropicProvider } from "./anthropic.js";
-import { CircuitBreaker } from "./base.js";
-import { OpenAIChatAdapter } from "./openai-chat.js";
+import type { Message, ProviderDescriptor, ProviderReplay, RuntimePolicy } from "../types.js";
+import { OpenAIChatProvider } from "./openai.js";
+import { AnthropicCompatibleProvider } from "./anthropic-compatible.js";
 /**
  * Qwen over its Anthropic-compatible endpoint.
+ * @deprecated Prefer `qwen({ protocol: "anthropic" })`. Behavior is now fully
+ * data-driven via `anthropicVendorProfiles.qwen`; this thin shim is kept for
+ * backward compatibility and `instanceof` checks.
  */
-export declare class QwenAnthropicProvider extends AnthropicProvider {
+export declare class QwenAnthropicProvider extends AnthropicCompatibleProvider {
     constructor(apiKey: string, model?: string, retry?: {
         maxRetries: number;
         baseDelay: number;
     }, baseURL?: string);
-    protected providerName(): string;
-    runtimePolicy(): RuntimePolicy;
 }
-export declare class QwenProvider implements LLMProvider {
-    protected readonly model: string;
-    protected client: OpenAI;
-    protected circuit: CircuitBreaker;
-    protected maxRetries: number;
-    protected baseDelay: number;
-    protected readonly chat: OpenAIChatAdapter;
+/**
+ * Qwen / DashScope over its OpenAI-compatible (DashScope) endpoint. Reasoning is carried
+ * out-of-band as `reasoning_content`; thinking is opted into via `enable_thinking` /
+ * `thinking_budget` (sent under `extra_body`). The streaming / tool-call machinery and the
+ * default `{ reasoning_content }` replay are inherited from OpenAIChatProvider; only request
+ * shaping and the (string-coerced) replay peek differ, supplied via the Template-Method hooks.
+ */
+export declare class QwenProvider extends OpenAIChatProvider {
     constructor(apiKey: string, model?: string, retry?: {
         maxRetries: number;
         baseDelay: number;
     }, baseURL?: string);
     runtimePolicy(): RuntimePolicy;
     descriptor(): ProviderDescriptor;
-    private buildChatMessages;
+    protected cacheKeyParams(): Record<string, unknown>;
+    protected usesInlineThinkingTags(): boolean;
+    protected requestBodyExtras(extensions?: Record<string, unknown>): Record<string, unknown>;
+    protected requestExtensions(extensions?: Record<string, unknown>): Record<string, unknown>;
     peekProviderReplay(message: Pick<Message, "content" | "toolCalls">): ProviderReplay | undefined;
     seedProviderReplay(message: Pick<Message, "content" | "toolCalls">, replay: ProviderReplay): void;
-    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
-    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
     private thinkingExtraBody;
-    private requestExtensions;
 }

package/dist/providers/qwen.js

@@ -1,54 +1,29 @@
-import OpenAI from "openai";
-import { withServerRuntimeGuard } from "../runtime/server.js";
-import { AnthropicProvider } from "./anthropic.js";
-import { CircuitBreaker, omitExtensionKeys, openAICachedPromptTokens } from "./base.js";
-import { OpenAIChatAdapter } from "./openai-chat.js";
+import { OpenAIChatProvider } from "./openai.js";
+import { AnthropicCompatibleProvider } from "./anthropic-compatible.js";
+import { omitExtensionKeys } from "./base.js";
 import { endpointProfiles } from "./profiles.js";
-const QWEN_POLICIES = {
-    "qwen3.7-max-preview": { maxTurns: 45 },
-    "qwen3.7-plus-preview": { maxTurns: 40 },
-    "qwen3.6-max-preview": { maxTurns: 40 },
-    "qwen3.6-plus": { maxTurns: 35 },
-    "qwen3.6-flash": { maxTurns: 20 },
-    "qwen3.6-35b-a3b": { maxTurns: 25 },
-    "qwen3.6-27b": { maxTurns: 25 },
-    "qwen3.5-plus": { maxTurns: 35 },
-    "qwen3.5-flash": { maxTurns: 20 },
-    "qwen3.5-397b-a17b": { maxTurns: 35 },
-    "qwen3.5-122b-a10b": { maxTurns: 25 },
-    "qwen3.5-35b-a3b": { maxTurns: 20 },
-    "qwen3.5-27b": { maxTurns: 20 },
-};
+import { QWEN_POLICIES, anthropicVendorProfiles } from "./vendor-profiles.js";
 /**
  * Qwen over its Anthropic-compatible endpoint.
+ * @deprecated Prefer `qwen({ protocol: "anthropic" })`. Behavior is now fully
+ * data-driven via `anthropicVendorProfiles.qwen`; this thin shim is kept for
+ * backward compatibility and `instanceof` checks.
  */
-export class QwenAnthropicProvider extends AnthropicProvider {
-    constructor(apiKey, model = "qwen3.6-plus", retry, baseURL = endpointProfiles["qwen.anthropic"].baseURL) {
-        super(apiKey, model, retry, {
-            baseURL,
-            authMode: "api-key",
-        });
-    }
-    providerName() {
-        return "qwen";
-    }
-    runtimePolicy() {
-        return QWEN_POLICIES[this.model] ?? {};
+export class QwenAnthropicProvider extends AnthropicCompatibleProvider {
+    constructor(apiKey, model, retry, baseURL) {
+        super(anthropicVendorProfiles.qwen, apiKey, model, retry, baseURL);
     }
 }
-export class QwenProvider {
-    model;
-    client;
-    circuit;
-    maxRetries;
-    baseDelay;
-    chat = new OpenAIChatAdapter();
-    constructor(apiKey, model = "qwen3.6-plus", retry = { maxRetries: 3, baseDelay: 1000 }, baseURL = endpointProfiles["qwen.dashscope"].baseURL) {
-        this.model = model;
-        this.client = withServerRuntimeGuard(() => new OpenAI({ apiKey, baseURL }));
-        this.circuit = new CircuitBreaker();
-        this.maxRetries = retry.maxRetries;
-        this.baseDelay = retry.baseDelay;
+/**
+ * Qwen / DashScope over its OpenAI-compatible (DashScope) endpoint. Reasoning is carried
+ * out-of-band as `reasoning_content`; thinking is opted into via `enable_thinking` /
+ * `thinking_budget` (sent under `extra_body`). The streaming / tool-call machinery and the
+ * default `{ reasoning_content }` replay are inherited from OpenAIChatProvider; only request
+ * shaping and the (string-coerced) replay peek differ, supplied via the Template-Method hooks.
+ */
+export class QwenProvider extends OpenAIChatProvider {
+    constructor(apiKey, model = "qwen3.6-plus", retry, baseURL = endpointProfiles["qwen.dashscope"].baseURL) {
+        super(apiKey, model, retry, baseURL);
     }
     runtimePolicy() {
         return QWEN_POLICIES[this.model] ?? {};
@@ -68,8 +43,23 @@ export class QwenProvider {
             },
         };
     }
-    buildChatMessages(context) {
-        return this.chat.buildMessages(context, { descriptor: this.descriptor() });
+    // DashScope auto prefix-caches and does not accept OpenAI's `prompt_cache_key`; omit it.
+    cacheKeyParams() {
+        return {};
+    }
+    // Reasoning arrives out-of-band as `reasoning_content`, never as inline <thinking> tags.
+    usesInlineThinkingTags() {
+        return false;
+    }
+    requestBodyExtras(extensions) {
+        const extraBody = this.thinkingExtraBody(extensions);
+        return extraBody ? { extra_body: extraBody } : {};
+    }
+    requestExtensions(extensions) {
+        return omitExtensionKeys(extensions, [
+            "model", "messages", "tools", "stream", "stream_options", "extra_body",
+            "enableThinking", "enable_thinking", "thinkingBudget", "thinking_budget",
+        ]);
     }
     peekProviderReplay(message) {
         const fields = this.chat.peekReplayFields(message);
@@ -82,129 +72,6 @@ export class QwenProvider {
             this.chat.rememberReplayFields(message, { reasoning_content: replay.reasoning_content });
         }
     }
-    async complete(context, tools, extensions) {
-        if (this.circuit.isOpen())
-            throw new Error("Circuit breaker open");
-        const msgs = this.buildChatMessages(context);
-        const extraBody = this.thinkingExtraBody(extensions);
-        let lastErr;
-        for (let i = 0; i < this.maxRetries; i++) {
-            try {
-                const resp = await this.client.chat.completions.create({
-                    ...this.requestExtensions(extensions),
-                    model: this.model,
-                    messages: msgs,
-                    ...(tools.length ? { tools: this.chat.buildTools(tools) } : {}),
-                    ...(extraBody ? { extra_body: extraBody } : {}),
-                });
-                this.circuit.recordSuccess();
-                const choice = resp.choices[0].message;
-                const toolCalls = this.chat.normalizeToolCalls(choice.tool_calls ?? []);
-                return { role: "assistant", content: choice.content ?? "", tokenCount: resp.usage?.completion_tokens ?? resp.usage?.total_tokens, toolCalls };
-            }
-            catch (err) {
-                lastErr = err;
-                this.circuit.recordFailure();
-                if (i < this.maxRetries - 1)
-                    await new Promise(r => setTimeout(r, this.baseDelay * 2 ** i));
-            }
-        }
-        throw lastErr;
-    }
-    async *stream(context, tools, extensions) {
-        const msgs = this.buildChatMessages(context);
-        const toolCallBufs = {};
-        const emittedToolCallIndexes = new Set();
-        let reasoningContent = "";
-        let finalText = "";
-        const extraBody = this.thinkingExtraBody(extensions);
-        const stream = await this.client.chat.completions.create({
-            ...this.requestExtensions(extensions),
-            model: this.model,
-            messages: msgs,
-            ...(tools.length ? { tools: this.chat.buildTools(tools) } : {}),
-            stream: true,
-            stream_options: { include_usage: true },
-            ...(extraBody ? { extra_body: extraBody } : {}),
-        });
-        let totalTokens = 0;
-        let inputTokens = 0;
-        let outputTokens = 0;
-        let cacheReadTokens = 0;
-        for await (const chunk of stream) {
-            if (chunk.usage) {
-                totalTokens = chunk.usage.total_tokens;
-                inputTokens = chunk.usage.prompt_tokens ?? 0;
-                outputTokens = chunk.usage.completion_tokens ?? 0;
-                cacheReadTokens = openAICachedPromptTokens(chunk.usage);
-                continue;
-            }
-            const choice = chunk.choices[0];
-            if (!choice)
-                continue;
-            const delta = choice.delta;
-            if (!delta)
-                continue;
-            if (delta.reasoning_content) {
-                reasoningContent += String(delta.reasoning_content);
-                yield { type: "thinking_delta", delta: delta.reasoning_content };
-            }
-            if (delta.content) {
-                finalText += String(delta.content);
-                yield { type: "text_delta", delta: delta.content };
-            }
-            for (const tc of delta.tool_calls ?? []) {
-                const idx = tc.index;
-                if (!toolCallBufs[idx])
-                    toolCallBufs[idx] = { id: tc.id ?? "", name: "", argsBuf: "" };
-                if (tc.function?.name)
-                    toolCallBufs[idx].name += tc.function.name;
-                toolCallBufs[idx].argsBuf += tc.function?.arguments ?? "";
-            }
-            if (choice.finish_reason === "tool_calls") {
-                const toolCalls = Object.values(toolCallBufs).map(tb => ({
-                    id: tb.id, name: tb.name, arguments: tb.argsBuf || "{}",
-                }));
-                this.chat.rememberReplayFields({ content: finalText, toolCalls }, { reasoning_content: reasoningContent });
-                for (const [index, tb] of Object.entries(toolCallBufs)) {
-                    const idx = Number(index);
-                    if (emittedToolCallIndexes.has(idx))
-                        continue;
-                    let args = {};
-                    try {
-                        args = JSON.parse(tb.argsBuf || "{}");
-                    }
-                    catch {
-                        args = {};
-                    }
-                    emittedToolCallIndexes.add(idx);
-                    yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
-                }
-            }
-        }
-        const toolCalls = Object.values(toolCallBufs).map(tb => ({
-            id: tb.id, name: tb.name, arguments: tb.argsBuf || "{}",
-        }));
-        if (toolCalls.length || reasoningContent) {
-            this.chat.rememberReplayFields({ content: finalText, toolCalls }, { reasoning_content: reasoningContent });
-        }
-        for (const [index, tb] of Object.entries(toolCallBufs)) {
-            const idx = Number(index);
-            if (emittedToolCallIndexes.has(idx))
-                continue;
-            let args = {};
-            try {
-                args = JSON.parse(tb.argsBuf || "{}");
-            }
-            catch {
-                args = {};
-            }
-            emittedToolCallIndexes.add(idx);
-            yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
-        }
-        if (totalTokens > 0)
-            yield { type: "usage", totalTokens, inputTokens, outputTokens, ...(cacheReadTokens > 0 ? { cacheReadInputTokens: cacheReadTokens } : {}) };
-    }
     thinkingExtraBody(extensions) {
         const enableThinking = Boolean(extensions?.enableThinking ?? extensions?.enable_thinking);
         const thinkingBudget = extensions?.thinkingBudget ?? extensions?.thinking_budget;
@@ -215,10 +82,4 @@ export class QwenProvider {
             ...(typeof thinkingBudget === "number" ? { thinking_budget: thinkingBudget } : {}),
         };
     }
-    requestExtensions(extensions) {
-        return omitExtensionKeys(extensions, [
-            "model", "messages", "tools", "stream", "stream_options", "extra_body",
-            "enableThinking", "enable_thinking", "thinkingBudget", "thinking_budget",
-        ]);
-    }
 }

package/dist/providers/registry.d.ts

@@ -0,0 +1,18 @@
+import type { LLMProvider } from "../types.js";
+export type ProviderRetry = {
+    maxRetries: number;
+    baseDelay: number;
+};
+/** Constructs a provider for one `(providerId, endpointProtocol)` pair. The lambda absorbs the
+ *  per-class constructor-shape differences (e.g. AnthropicProvider takes a `{ baseURL }` options
+ *  object, the rest take a positional `baseURL` string). */
+export type ProviderMaker = (apiKey: string, model: string | undefined, retry: ProviderRetry | undefined, baseURL: string | undefined) => LLMProvider;
+/** Build the registry key for a `(providerId, endpointProtocol)` pair. */
+export declare function providerRegistryKey(providerId: string, protocol: string): string;
+/**
+ * Single source of truth for which provider class backs each `(vendor, wire)` pair. Consumed by
+ * both `createProvider` (catalog) and the per-backend factory functions, so the two can no longer
+ * drift. Adding a vendor/wire = add a row here (+ its `vendor-profiles` / `endpointProfiles` data) —
+ * no dispatch branch to edit. Values are the same named classes as before, so `instanceof` holds.
+ */
+export declare const PROVIDER_REGISTRY: Record<string, ProviderMaker>;

package/dist/providers/registry.js

@@ -0,0 +1,35 @@
+import { AnthropicProvider } from "./anthropic.js";
+import { OpenAIChatProvider } from "./openai.js";
+import { OpenAIResponsesProvider } from "./openai-responses.js";
+import { DeepSeekProvider, DeepSeekAnthropicProvider } from "./deepseek.js";
+import { KimiProvider, KimiAnthropicProvider } from "./kimi.js";
+import { QwenProvider, QwenAnthropicProvider } from "./qwen.js";
+import { GLMProvider, GLMAnthropicProvider } from "./glm.js";
+import { MiniMaxOpenAIProvider, MiniMaxAnthropicProvider } from "./minimax.js";
+import { GeminiProvider } from "./gemini.js";
+/** Build the registry key for a `(providerId, endpointProtocol)` pair. */
+export function providerRegistryKey(providerId, protocol) {
+    return `${providerId}:${protocol}`;
+}
+/**
+ * Single source of truth for which provider class backs each `(vendor, wire)` pair. Consumed by
+ * both `createProvider` (catalog) and the per-backend factory functions, so the two can no longer
+ * drift. Adding a vendor/wire = add a row here (+ its `vendor-profiles` / `endpointProfiles` data) —
+ * no dispatch branch to edit. Values are the same named classes as before, so `instanceof` holds.
+ */
+export const PROVIDER_REGISTRY = {
+    "anthropic:anthropic-messages": (k, m, r, b) => new AnthropicProvider(k, m, r, { baseURL: b }),
+    "openai:openai-chat": (k, m, r, b) => new OpenAIChatProvider(k, m, r, b),
+    "openai:openai-responses": (k, m, r, b) => new OpenAIResponsesProvider(k, m, r, b),
+    "deepseek:openai-chat": (k, m, r, b) => new DeepSeekProvider(k, m, r, b),
+    "deepseek:anthropic-messages": (k, m, r, b) => new DeepSeekAnthropicProvider(k, m, r, b),
+    "kimi:openai-chat": (k, m, r, b) => new KimiProvider(k, m, r, b),
+    "kimi:anthropic-messages": (k, m, r, b) => new KimiAnthropicProvider(k, m, r, b),
+    "qwen:openai-chat": (k, m, r, b) => new QwenProvider(k, m, r, b),
+    "qwen:anthropic-messages": (k, m, r, b) => new QwenAnthropicProvider(k, m, r, b),
+    "glm:openai-chat": (k, m, r, b) => new GLMProvider(k, m, r, b),
+    "glm:anthropic-messages": (k, m, r, b) => new GLMAnthropicProvider(k, m, r, b),
+    "minimax:openai-chat": (k, m, r, b) => new MiniMaxOpenAIProvider(k, m, r, b),
+    "minimax:anthropic-messages": (k, m, r, b) => new MiniMaxAnthropicProvider(k, m, r, b),
+    "gemini:gemini": (k, m, r, b) => new GeminiProvider(k, m, r, b),
+};