@deepstrike/sdk 0.2.30 → 0.2.32

package/dist/providers/factories.js

@@ -1,43 +1,31 @@
-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";
+import { PROVIDER_REGISTRY } from "./registry.js";
 import { OllamaProvider } from "./ollama.js";
+function build(providerId, protocol, o) {
+    return PROVIDER_REGISTRY[`${providerId}:${protocol}`](o.apiKey, o.model, o.retry, o.baseURL);
+}
 /** DeepSeek. Defaults to the OpenAI-compatible wire (richer reasoning-replay handling). */
 export function deepseek(o) {
-    return o.protocol === "anthropic"
-        ? new DeepSeekAnthropicProvider(o.apiKey, o.model, o.retry, o.baseURL)
-        : new DeepSeekProvider(o.apiKey, o.model, o.retry, o.baseURL);
+    return build("deepseek", o.protocol === "anthropic" ? "anthropic-messages" : "openai-chat", o);
 }
 /** Moonshot Kimi. Defaults to the OpenAI-compatible wire. */
 export function kimi(o) {
-    return o.protocol === "anthropic"
-        ? new KimiAnthropicProvider(o.apiKey, o.model, o.retry, o.baseURL)
-        : new KimiProvider(o.apiKey, o.model, o.retry, o.baseURL);
+    return build("kimi", o.protocol === "anthropic" ? "anthropic-messages" : "openai-chat", o);
 }
 /** Alibaba Qwen / DashScope. Defaults to the OpenAI-compatible (DashScope) wire. */
 export function qwen(o) {
-    return o.protocol === "anthropic"
-        ? new QwenAnthropicProvider(o.apiKey, o.model, o.retry, o.baseURL)
-        : new QwenProvider(o.apiKey, o.model, o.retry, o.baseURL);
+    return build("qwen", o.protocol === "anthropic" ? "anthropic-messages" : "openai-chat", o);
 }
 /** Zhipu GLM. Defaults to the OpenAI-compatible wire. */
 export function glm(o) {
-    return o.protocol === "anthropic"
-        ? new GLMAnthropicProvider(o.apiKey, o.model, o.retry, o.baseURL)
-        : new GLMProvider(o.apiKey, o.model, o.retry, o.baseURL);
+    return build("glm", o.protocol === "anthropic" ? "anthropic-messages" : "openai-chat", o);
 }
 /** MiniMax. Defaults to the Anthropic-compatible wire (the primary M2.x path). */
 export function minimax(o) {
-    return o.protocol === "openai"
-        ? new MiniMaxOpenAIProvider(o.apiKey, o.model, o.retry, o.baseURL)
-        : new MiniMaxAnthropicProvider(o.apiKey, o.model, o.retry, o.baseURL);
+    return build("minimax", o.protocol === "openai" ? "openai-chat" : "anthropic-messages", o);
 }
 /** Google Gemini (single wire). */
 export function gemini(o) {
-    return new GeminiProvider(o.apiKey, o.model, o.retry, o.baseURL);
+    return PROVIDER_REGISTRY["gemini:gemini"](o.apiKey, o.model, o.retry, o.baseURL);
 }
 /** Local Ollama (single wire, no API key). */
 export function ollama(o = {}) {

package/dist/providers/gemini.d.ts

@@ -16,4 +16,16 @@ export declare class GeminiProvider implements LLMProvider {
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
     private modelExtensions;
+    /**
+     * Gemini vendor features from extensions, mapped to the Node SDK shape (mirrors the Python provider's
+     * extension keys for a consistent cross-SDK API):
+     *  - `google_search` (truthy → default, object → config): Google Search grounding server tool
+     *    (gemini-2.0+), appended to tools[].
+     *  - `response_mime_type` / `response_schema`: structured output → `generationConfig` (the API rejects
+     *    pairing this with google_search).
+     */
+    vendorConfig(extensions?: Record<string, unknown>): {
+        tools?: unknown[];
+        generationConfig?: Record<string, unknown>;
+    };
 }

package/dist/providers/gemini.js

@@ -116,11 +116,14 @@ export class GeminiProvider {
         let lastErr;
         for (let i = 0; i < this.maxRetries; i++) {
             try {
+                const vc = this.vendorConfig(extensions);
+                const allTools = [...geminiTools, ...(vc.tools ?? [])];
                 const m = this.genAI.getGenerativeModel({
                     ...this.modelExtensions(extensions),
                     model: this.model,
                     ...(system ? { systemInstruction: system } : {}),
-                    ...(geminiTools.length ? { tools: geminiTools } : {}),
+                    ...(allTools.length ? { tools: allTools } : {}),
+                    ...(vc.generationConfig ? { generationConfig: vc.generationConfig } : {}),
                 }, this.requestOptions);
                 const resp = await m.generateContent({ contents });
                 this.circuit.recordSuccess();
@@ -157,11 +160,14 @@ export class GeminiProvider {
         const system = context.systemText || undefined;
         const contents = buildContents(turnsWithStateAppended(context));
         const geminiTools = buildTools(tools);
+        const vc = this.vendorConfig(extensions);
+        const allTools = [...geminiTools, ...(vc.tools ?? [])];
         const m = this.genAI.getGenerativeModel({
             ...this.modelExtensions(extensions),
             model: this.model,
             ...(system ? { systemInstruction: system } : {}),
-            ...(geminiTools.length ? { tools: geminiTools } : {}),
+            ...(allTools.length ? { tools: allTools } : {}),
+            ...(vc.generationConfig ? { generationConfig: vc.generationConfig } : {}),
         }, this.requestOptions);
         const result = await m.generateContentStream({ contents });
         const toolCalls = [];
@@ -195,7 +201,36 @@ export class GeminiProvider {
     modelExtensions(extensions) {
         if (!extensions)
             return {};
-        const { model: _model, systemInstruction: _systemInstruction, tools: _tools, ...rest } = extensions;
+        // Strip keys handled explicitly elsewhere (incl. the vendor server-tool / structured-output keys
+        // consumed by `vendorConfig`) so they never leak raw into getGenerativeModel.
+        // Strip keys handled explicitly: the SDK fields set below + the named vendor keys consumed by
+        // `vendorConfig`. A caller-provided raw `generationConfig` still passes through (and is merged with
+        // any structured-output config at the call site).
+        const { model: _model, systemInstruction: _systemInstruction, tools: _tools, google_search: _gs, response_mime_type: _rmt, response_schema: _rs, ...rest } = extensions;
         return rest;
     }
+    /**
+     * Gemini vendor features from extensions, mapped to the Node SDK shape (mirrors the Python provider's
+     * extension keys for a consistent cross-SDK API):
+     *  - `google_search` (truthy → default, object → config): Google Search grounding server tool
+     *    (gemini-2.0+), appended to tools[].
+     *  - `response_mime_type` / `response_schema`: structured output → `generationConfig` (the API rejects
+     *    pairing this with google_search).
+     */
+    vendorConfig(extensions) {
+        const ext = extensions ?? {};
+        const tools = [];
+        if (ext.google_search)
+            tools.push({ googleSearch: typeof ext.google_search === "object" ? ext.google_search : {} });
+        // Seed from any caller-provided raw generationConfig, then layer the named structured-output keys.
+        const gc = { ...ext.generationConfig };
+        if (ext.response_mime_type != null)
+            gc.responseMimeType = ext.response_mime_type;
+        if (ext.response_schema != null)
+            gc.responseSchema = ext.response_schema;
+        return {
+            ...(tools.length ? { tools } : {}),
+            ...(Object.keys(gc).length ? { generationConfig: gc } : {}),
+        };
+    }
 }

package/dist/providers/glm.d.ts

@@ -1,16 +1,17 @@
 import type { ProviderDescriptor, RuntimePolicy } from "../types.js";
-import { AnthropicProvider } from "./anthropic.js";
 import { OpenAIChatProvider } from "./openai.js";
+import { AnthropicCompatibleProvider } from "./anthropic-compatible.js";
 /**
  * GLM over its Anthropic-compatible endpoint.
+ * @deprecated Prefer `glm({ protocol: "anthropic" })`. Behavior is now fully
+ * data-driven via `anthropicVendorProfiles.glm`; this thin shim is kept for
+ * backward compatibility and `instanceof` checks.
  */
-export declare class GLMAnthropicProvider extends AnthropicProvider {
+export declare class GLMAnthropicProvider extends AnthropicCompatibleProvider {
     constructor(apiKey: string, model?: string, retry?: {
         maxRetries: number;
         baseDelay: number;
     }, baseURL?: string);
-    protected providerName(): string;
-    runtimePolicy(): RuntimePolicy;
 }
 export declare class GLMProvider extends OpenAIChatProvider {
     constructor(apiKey: string, model?: string, retry?: {
@@ -19,4 +20,6 @@ export declare class GLMProvider extends OpenAIChatProvider {
     }, baseURL?: string);
     runtimePolicy(): RuntimePolicy;
     descriptor(): ProviderDescriptor;
+    protected serverTools(extensions?: Record<string, unknown>): unknown[];
+    protected prepareExtensions(extensions?: Record<string, unknown>): Record<string, unknown> | undefined;
 }

package/dist/providers/glm.js

@@ -1,35 +1,20 @@
-import { AnthropicProvider } from "./anthropic.js";
 import { OpenAIChatProvider } from "./openai.js";
+import { AnthropicCompatibleProvider } from "./anthropic-compatible.js";
 import { endpointProfiles } from "./profiles.js";
-const GLM_POLICIES = {
-    "glm-5.1": { maxTurns: 50 },
-    "glm/glm-5.1": { maxTurns: 50 },
-    "glm-4-plus": { maxTurns: 35 },
-    "glm/glm-4-plus": { maxTurns: 35 },
-    "glm-4-flash": { maxTurns: 15 },
-    "glm/glm-4-flash": { maxTurns: 15 },
-    "glm-4-air": { maxTurns: 20 },
-    "glm/glm-4-air": { maxTurns: 20 },
-};
+import { GLM_POLICIES, anthropicVendorProfiles } from "./vendor-profiles.js";
 /**
  * GLM over its Anthropic-compatible endpoint.
+ * @deprecated Prefer `glm({ protocol: "anthropic" })`. Behavior is now fully
+ * data-driven via `anthropicVendorProfiles.glm`; this thin shim is kept for
+ * backward compatibility and `instanceof` checks.
  */
-export class GLMAnthropicProvider extends AnthropicProvider {
-    constructor(apiKey, model = "glm-5.1", retry, baseURL = endpointProfiles["glm.anthropic"].baseURL) {
-        super(apiKey, model, retry, {
-            baseURL,
-            authMode: "api-key",
-        });
-    }
-    providerName() {
-        return "glm";
-    }
-    runtimePolicy() {
-        return GLM_POLICIES[this.model] ?? {};
+export class GLMAnthropicProvider extends AnthropicCompatibleProvider {
+    constructor(apiKey, model, retry, baseURL) {
+        super(anthropicVendorProfiles.glm, apiKey, model, retry, baseURL);
     }
 }
 export class GLMProvider extends OpenAIChatProvider {
-    constructor(apiKey, model = "glm-5.1", retry, baseURL = endpointProfiles["glm.openai"].baseURL) {
+    constructor(apiKey, model = "glm-5.2", retry, baseURL = endpointProfiles["glm.openai"].baseURL) {
         super(apiKey, model, retry, baseURL);
     }
     runtimePolicy() {
@@ -42,4 +27,22 @@ export class GLMProvider extends OpenAIChatProvider {
             model: this.model,
         };
     }
+    // ── GLM web_search (Zhipu vendor server tool; OpenAI-wire only) ──────────────
+    // Enable with `extensions={ web_search: true }` (default config) or `{ web_search: {...} }`
+    // (passthrough: search_engine, search_recency_filter, search_domain_filter, count, …). Injected as a
+    // `{ type: "web_search", web_search: {...} }` entry in tools[]; the model searches server-side and
+    // the results come back inline (no client tool-loop). Mirrors the Python GLM provider.
+    serverTools(extensions) {
+        const ws = extensions?.web_search;
+        if (!ws)
+            return [];
+        return [{ type: "web_search", web_search: typeof ws === "object" ? ws : {} }];
+    }
+    // Strip `web_search` from the passthrough so it shapes tools[] only, never leaks as a body field.
+    prepareExtensions(extensions) {
+        if (!extensions || !("web_search" in extensions))
+            return extensions;
+        const { web_search: _omit, ...rest } = extensions;
+        return rest;
+    }
 }

package/dist/providers/kimi.d.ts

@@ -1,16 +1,17 @@
 import type { ProviderDescriptor, RuntimePolicy } from "../types.js";
-import { AnthropicProvider } from "./anthropic.js";
 import { OpenAIChatProvider } from "./openai.js";
+import { AnthropicCompatibleProvider } from "./anthropic-compatible.js";
 /**
  * Kimi over its Anthropic-compatible endpoint.
+ * @deprecated Prefer `kimi({ protocol: "anthropic" })`. Behavior is now fully
+ * data-driven via `anthropicVendorProfiles.kimi`; this thin shim is kept for
+ * backward compatibility and `instanceof` checks.
  */
-export declare class KimiAnthropicProvider extends AnthropicProvider {
+export declare class KimiAnthropicProvider extends AnthropicCompatibleProvider {
     constructor(apiKey: string, model?: string, retry?: {
         maxRetries: number;
         baseDelay: number;
     }, baseURL?: string);
-    protected providerName(): string;
-    runtimePolicy(): RuntimePolicy;
 }
 export declare class KimiProvider extends OpenAIChatProvider {
     constructor(apiKey: string, model?: string, retry?: {

package/dist/providers/kimi.js

@@ -1,30 +1,16 @@
-import { AnthropicProvider } from "./anthropic.js";
 import { OpenAIChatProvider } from "./openai.js";
+import { AnthropicCompatibleProvider } from "./anthropic-compatible.js";
 import { endpointProfiles } from "./profiles.js";
-const KIMI_POLICIES = {
-    "moonshot-v1-8k": { maxTurns: 15 },
-    "moonshot-v1-32k": { maxTurns: 20 },
-    "moonshot-v1-128k": { maxTurns: 30 },
-    "kimi-k2.5": { maxTurns: 30 },
-    "kimi-k2.6": { maxTurns: 35 },
-    "kimi-k2-thinking": { maxTurns: 50 },
-    "kimi-k2-thinking-turbo": { maxTurns: 40 },
-};
+import { KIMI_POLICIES, anthropicVendorProfiles } from "./vendor-profiles.js";
 /**
  * Kimi over its Anthropic-compatible endpoint.
+ * @deprecated Prefer `kimi({ protocol: "anthropic" })`. Behavior is now fully
+ * data-driven via `anthropicVendorProfiles.kimi`; this thin shim is kept for
+ * backward compatibility and `instanceof` checks.
  */
-export class KimiAnthropicProvider extends AnthropicProvider {
-    constructor(apiKey, model = "kimi-k2.6", retry, baseURL = endpointProfiles["kimi.anthropic"].baseURL) {
-        super(apiKey, model, retry, {
-            baseURL,
-            authMode: "api-key",
-        });
-    }
-    providerName() {
-        return "kimi";
-    }
-    runtimePolicy() {
-        return KIMI_POLICIES[this.model] ?? {};
+export class KimiAnthropicProvider extends AnthropicCompatibleProvider {
+    constructor(apiKey, model, retry, baseURL) {
+        super(anthropicVendorProfiles.kimi, apiKey, model, retry, baseURL);
     }
 }
 export class KimiProvider extends OpenAIChatProvider {

package/dist/providers/minimax.d.ts

@@ -1,24 +1,27 @@
-import type { Message, ProviderDescriptor, RenderedContext, RuntimePolicy, StreamEvent, ToolSchema } from "../types.js";
-import { AnthropicProvider } from "./anthropic.js";
-import { OpenAIChatProvider } from "./openai.js";
+import type { ProviderDescriptor, RuntimePolicy } from "../types.js";
+import { OpenAIChatProvider, type OpenAIChatTurnReasoning } from "./openai.js";
+import { AnthropicCompatibleProvider } from "./anthropic-compatible.js";
 /**
  * MiniMax over its Anthropic-compatible endpoint. Replay is carried as Anthropic
  * `native_blocks` (thinking/text/tool_use), identical to the first-party
  * Anthropic provider.
+ * @deprecated Prefer `minimax({ protocol: "anthropic" })`. Behavior is now fully
+ * data-driven via `anthropicVendorProfiles.minimax`; this thin shim is kept for
+ * backward compatibility and `instanceof` checks.
  */
-export declare class MiniMaxAnthropicProvider extends AnthropicProvider {
+export declare class MiniMaxAnthropicProvider extends AnthropicCompatibleProvider {
     constructor(apiKey: string, model?: string, retry?: {
         maxRetries: number;
         baseDelay: number;
     }, baseURL?: string);
-    protected providerName(): string;
-    runtimePolicy(): RuntimePolicy;
 }
 /**
  * MiniMax over its OpenAI-compatible endpoint. Replay is carried as
- * `reasoning_content` / `reasoning_details` (split reasoning), and requests
- * default to `reasoning_split: true` so reasoning is returned out-of-band rather
- * than embedded in the message content.
+ * `reasoning_content` / `reasoning_details` (split reasoning) in a schema_version-2
+ * envelope; requests default to `reasoning_split: true` so reasoning is returned
+ * out-of-band rather than embedded in the message content. Request shaping and replay
+ * are supplied via the OpenAIChatProvider Template-Method hooks; the streaming /
+ * tool-call machinery is inherited from the base class.
  */
 export declare class MiniMaxOpenAIProvider extends OpenAIChatProvider {
     constructor(apiKey: string, model?: string, retry?: {
@@ -28,8 +31,19 @@ export declare class MiniMaxOpenAIProvider extends OpenAIChatProvider {
     runtimePolicy(): RuntimePolicy;
     descriptor(): ProviderDescriptor;
     protected requireNonEmptyReasoningReplayForToolTurns(extensions?: Record<string, unknown>): boolean;
-    private buildRequestExtensions;
-    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
-    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    protected cacheKeyParams(): Record<string, unknown>;
+    protected usesInlineThinkingTags(): boolean;
+    protected exposeReasoningDelta(extensions?: Record<string, unknown>): boolean;
+    protected prepareExtensions(extensions?: Record<string, unknown>): Record<string, unknown>;
+    protected rememberCompleteReplay(content: string, toolCalls: Array<{
+        id: string;
+        name: string;
+        arguments: string;
+    }>, r: OpenAIChatTurnReasoning): void;
+    protected rememberStreamReplay(content: string, toolCalls: Array<{
+        id: string;
+        name: string;
+        arguments: string;
+    }>, r: OpenAIChatTurnReasoning): void;
     private rememberMiniMaxReplay;
 }

package/dist/providers/minimax.js

@@ -1,44 +1,31 @@
-import { AnthropicProvider } from "./anthropic.js";
 import { OpenAIChatProvider } from "./openai.js";
+import { AnthropicCompatibleProvider } from "./anthropic-compatible.js";
 import { endpointProfiles } from "./profiles.js";
-import { omitExtensionKeys, openAICachedPromptTokens } from "./base.js";
-const MINIMAX_POLICIES = {
-    "MiniMax-M2.7": { maxTurns: 35 },
-    "MiniMax-M2.7-highspeed": { maxTurns: 35 },
-    "MiniMax-M2.5": { maxTurns: 25 },
-    "MiniMax-M2.5-highspeed": { maxTurns: 25 },
-    "MiniMax-M2.1": { maxTurns: 25 },
-    "MiniMax-M2.1-highspeed": { maxTurns: 25 },
-    "MiniMax-M2": { maxTurns: 20 },
-    "MiniMax-Text-01": { maxTurns: 20 },
-};
+import { omitExtensionKeys } from "./base.js";
+import { MINIMAX_POLICIES, anthropicVendorProfiles } from "./vendor-profiles.js";
 /**
  * MiniMax over its Anthropic-compatible endpoint. Replay is carried as Anthropic
  * `native_blocks` (thinking/text/tool_use), identical to the first-party
  * Anthropic provider.
+ * @deprecated Prefer `minimax({ protocol: "anthropic" })`. Behavior is now fully
+ * data-driven via `anthropicVendorProfiles.minimax`; this thin shim is kept for
+ * backward compatibility and `instanceof` checks.
  */
-export class MiniMaxAnthropicProvider extends AnthropicProvider {
-    constructor(apiKey, model = "MiniMax-M2.7", retry, baseURL = endpointProfiles["minimax.anthropic"].baseURL) {
-        super(apiKey, model, retry, {
-            baseURL,
-            authMode: "api-key",
-        });
-    }
-    providerName() {
-        return "minimax";
-    }
-    runtimePolicy() {
-        return MINIMAX_POLICIES[this.model] ?? {};
+export class MiniMaxAnthropicProvider extends AnthropicCompatibleProvider {
+    constructor(apiKey, model, retry, baseURL) {
+        super(anthropicVendorProfiles.minimax, apiKey, model, retry, baseURL);
     }
 }
 /**
  * MiniMax over its OpenAI-compatible endpoint. Replay is carried as
- * `reasoning_content` / `reasoning_details` (split reasoning), and requests
- * default to `reasoning_split: true` so reasoning is returned out-of-band rather
- * than embedded in the message content.
+ * `reasoning_content` / `reasoning_details` (split reasoning) in a schema_version-2
+ * envelope; requests default to `reasoning_split: true` so reasoning is returned
+ * out-of-band rather than embedded in the message content. Request shaping and replay
+ * are supplied via the OpenAIChatProvider Template-Method hooks; the streaming /
+ * tool-call machinery is inherited from the base class.
  */
 export class MiniMaxOpenAIProvider extends OpenAIChatProvider {
-    constructor(apiKey, model = "MiniMax-M2.7", retry, baseURL = endpointProfiles["minimax.openai"].baseURL) {
+    constructor(apiKey, model = "MiniMax-M3", retry, baseURL = endpointProfiles["minimax.openai"].baseURL) {
         super(apiKey, model, retry, baseURL);
     }
     runtimePolicy() {
@@ -65,139 +52,33 @@ export class MiniMaxOpenAIProvider extends OpenAIChatProvider {
             return false;
         return extensions?.reasoning_split !== false;
     }
-    buildRequestExtensions(extensions) {
+    // MiniMax auto prefix-caches and does not accept OpenAI's `prompt_cache_key`; omit it.
+    cacheKeyParams() {
+        return {};
+    }
+    // Reasoning arrives out-of-band (reasoning_content / reasoning_details), never inline tags.
+    usesInlineThinkingTags() {
+        return false;
+    }
+    exposeReasoningDelta(extensions) {
+        return (extensions?.exposeReasoning ?? false);
+    }
+    prepareExtensions(extensions) {
         const reasoningSplit = extensions?.reasoning_split !== false;
         return {
             ...omitExtensionKeys(extensions, ["reasoning_split", "exposeReasoning"]),
             __deepstrikeThinkingEnabled: reasoningSplit,
-            // Re-thread the degrade control flag (omitExtensionKeys strips internal
-            // keys) so buildChatMessages can honor it; the wire-request omit drops it.
+            // Re-thread the degrade control flag (omitExtensionKeys strips internal keys) so
+            // buildChatMessages can honor it; the wire-request omit drops it.
             ...(extensions?.degradeMissingReasoningReplay === true ? { degradeMissingReasoningReplay: true } : {}),
             reasoning_split: reasoningSplit,
         };
     }
-    async complete(context, tools, extensions) {
-        const requestExtensions = this.buildRequestExtensions(extensions);
-        if (this.circuit.isOpen())
-            throw new Error("Circuit breaker open");
-        const msgs = this.buildChatMessages(context, requestExtensions);
-        let lastErr;
-        for (let i = 0; i < this.maxRetries; i++) {
-            try {
-                const resp = await this.client.chat.completions.create({
-                    ...this.requestExtensions(requestExtensions),
-                    model: this.model,
-                    messages: msgs,
-                    ...(tools.length ? { tools: this.chat.buildTools(tools) } : {}),
-                });
-                this.circuit.recordSuccess();
-                const choice = resp.choices[0].message;
-                const nativeToolCalls = choice.tool_calls ?? [];
-                const toolCalls = this.chat.normalizeToolCalls(nativeToolCalls);
-                const content = choice.content ?? "";
-                this.rememberMiniMaxReplay(content, toolCalls, choice.reasoning_content, choice.reasoning_details, nativeToolCalls);
-                return { role: "assistant", 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;
+    rememberCompleteReplay(content, toolCalls, r) {
+        this.rememberMiniMaxReplay(content, toolCalls, r.reasoningContent, r.reasoningDetails, r.nativeToolCalls);
     }
-    async *stream(context, tools, extensions) {
-        const exposeReasoning = extensions?.exposeReasoning ?? false;
-        const requestExtensions = this.buildRequestExtensions(extensions);
-        const msgs = this.buildChatMessages(context, requestExtensions);
-        const toolCallBufs = {};
-        const emittedToolCallIndexes = new Set();
-        let reasoningContent = "";
-        let reasoningDetails;
-        let finalText = "";
-        const stream = await this.client.chat.completions.create({
-            ...this.requestExtensions(requestExtensions),
-            model: this.model,
-            messages: msgs,
-            ...(tools.length ? { tools: this.chat.buildTools(tools) } : {}),
-            stream: true,
-            stream_options: { include_usage: true },
-        });
-        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 (exposeReasoning && delta.reasoning_content) {
-                yield { type: "thinking_delta", delta: String(delta.reasoning_content) };
-            }
-            if (delta.reasoning_content)
-                reasoningContent += String(delta.reasoning_content);
-            if (delta.reasoning_details !== undefined && delta.reasoning_details !== null)
-                reasoningDetails = delta.reasoning_details;
-            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.rememberMiniMaxReplay(finalText, toolCalls, reasoningContent, reasoningDetails, nativeToolCallsFromBuffers(toolCallBufs));
-                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 || "{}" }));
-        this.rememberMiniMaxReplay(finalText, toolCalls, reasoningContent, reasoningDetails, nativeToolCallsFromBuffers(toolCallBufs));
-        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 } : {}) };
+    rememberStreamReplay(content, toolCalls, r) {
+        this.rememberMiniMaxReplay(content, toolCalls, r.reasoningContent, r.reasoningDetails, r.nativeToolCalls);
     }
     rememberMiniMaxReplay(content, toolCalls, reasoningContent, reasoningDetails, nativeToolCalls) {
         const hasReasoning = typeof reasoningContent === "string" && reasoningContent.trim().length > 0;
@@ -215,10 +96,3 @@ export class MiniMaxOpenAIProvider extends OpenAIChatProvider {
         });
     }
 }
-function nativeToolCallsFromBuffers(toolCallBufs) {
-    return Object.values(toolCallBufs).map(tb => ({
-        id: tb.id,
-        type: "function",
-        function: { name: tb.name, arguments: tb.argsBuf || "{}" },
-    }));
-}

package/dist/providers/openai-responses.d.ts

@@ -40,5 +40,11 @@ export declare class OpenAIResponsesProvider implements LLMProvider {
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState): AsyncIterable<StreamEvent>;
     private requestExtensions;
+    /** Responses API built-in server tools from extensions (live in the same tools[] as function tools):
+     *  `web_search: true` (or a config object), plus a `builtin_tools` list passed through verbatim for
+     *  file_search / code_interpreter. They run server-side; results return inline. Mirrors py. */
+    private builtinTools;
+    /** Function tools + built-in server tools merged into the wire tools[] (undefined when empty). */
+    private allTools;
     private asRunState;
 }

package/dist/providers/openai-responses.js

@@ -176,7 +176,7 @@ export class OpenAIResponsesProvider {
                     model: this.model,
                     input: this.responses.buildInput(context),
                     ...(instructions ? { instructions } : {}),
-                    ...(tools.length ? { tools: this.responses.buildTools(tools) } : {}),
+                    ...((t => t ? { tools: t } : {})(this.allTools(tools, extensions))),
                 });
                 this.circuit.recordSuccess();
                 const decoded = this.responses.decodeOutput(resp.output);
@@ -206,7 +206,7 @@ export class OpenAIResponsesProvider {
             input: this.responses.buildInput(context, runState),
             ...(instructions ? { instructions } : {}),
             ...(runState.previousResponseId ? { previous_response_id: runState.previousResponseId } : {}),
-            ...(tools.length ? { tools: this.responses.buildTools(tools) } : {}),
+            ...((t => t ? { tools: t } : {})(this.allTools(tools, extensions))),
             stream: true,
         });
         for await (const evt of stream) {
@@ -266,8 +266,28 @@ export class OpenAIResponsesProvider {
     requestExtensions(extensions) {
         return omitExtensionKeys(extensions, [
             "model", "input", "instructions", "tools", "stream", "previous_response_id",
+            "web_search", "builtin_tools",
         ]);
     }
+    /** Responses API built-in server tools from extensions (live in the same tools[] as function tools):
+     *  `web_search: true` (or a config object), plus a `builtin_tools` list passed through verbatim for
+     *  file_search / code_interpreter. They run server-side; results return inline. Mirrors py. */
+    builtinTools(extensions) {
+        const ext = extensions ?? {};
+        const out = [];
+        const ws = ext.web_search;
+        if (ws)
+            out.push(typeof ws === "object" ? { type: "web_search", ...ws } : { type: "web_search" });
+        if (Array.isArray(ext.builtin_tools))
+            out.push(...ext.builtin_tools);
+        return out;
+    }
+    /** Function tools + built-in server tools merged into the wire tools[] (undefined when empty). */
+    allTools(tools, extensions) {
+        const fnTools = tools.length ? this.responses.buildTools(tools) : [];
+        const all = [...fnTools, ...this.builtinTools(extensions)];
+        return all.length ? all : undefined;
+    }
     asRunState(state) {
         if (!state)
             return this.createRunState();