@deepstrike/sdk 0.2.30 → 0.2.31

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/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?: {

package/dist/providers/glm.js

@@ -1,31 +1,16 @@
-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 {

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,41 +1,28 @@
-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) {
@@ -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.d.ts

@@ -15,6 +15,20 @@ export interface OpenAIProviderOptions {
     /** Custom OpenAI-compatible endpoint (MiMo, DeepSeek, Kimi, …). Defaults to the OpenAI API. */
     baseURL?: string;
 }
+/** Reasoning captured from a single model turn, handed to the replay-remember hooks so an
+ *  OpenAI-compatible subclass can persist whatever replay envelope its wire requires. */
+export interface OpenAIChatTurnReasoning {
+    reasoningContent: string;
+    reasoningDetails?: unknown;
+    nativeToolCalls: unknown[];
+}
+/** 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 declare function nativeToolCallsFromBuffers(toolCallBufs: Record<number, {
+    id: string;
+    name: string;
+    argsBuf: string;
+}>): Array<Record<string, unknown>>;
 export declare class OpenAIChatProvider implements LLMProvider {
     protected client: OpenAI;
     protected circuit: CircuitBreaker;
@@ -31,6 +45,35 @@ export declare class OpenAIChatProvider implements LLMProvider {
     protected requireNonEmptyReasoningReplayForToolTurns(_extensions?: Record<string, unknown>): boolean;
     protected degradeMissingReasoningReplay(extensions?: Record<string, unknown>): boolean;
     protected buildChatMessages(context: RenderedContext, extensions?: Record<string, unknown>): OpenAI.Chat.Completions.ChatCompletionMessageParam[];
+    /** Pre-process caller extensions before they reach buildChatMessages + the wire request
+     *  (e.g. set `__deepstrikeThinkingEnabled`). Default: pass through unchanged. */
+    protected prepareExtensions(extensions?: Record<string, unknown>): Record<string, unknown> | undefined;
+    /** Extra top-level request-body fields merged into the chat.completions call (vendor thinking
+     *  knobs like `reasoning_effort`, `extra_body`, `reasoning_split`). Default: none. */
+    protected requestBodyExtras(_extensions?: Record<string, unknown>): Record<string, unknown>;
+    /** 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 `{}`. */
+    protected cacheKeyParams(context: RenderedContext, tools: ToolSchema[]): Record<string, unknown>;
+    /** 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. */
+    protected usesInlineThinkingTags(): boolean;
+    /** Whether to surface streamed `reasoning_content` as thinking_delta events. Default true;
+     *  vendors gate this behind an `exposeReasoning` extension. */
+    protected exposeReasoningDelta(_extensions?: Record<string, unknown>): boolean;
+    /** Persist replay after a non-streaming turn. Default: nothing (plain OpenAI has no reasoning
+     *  to replay). Reasoning vendors override to store their envelope. */
+    protected rememberCompleteReplay(_content: string, _toolCalls: Array<{
+        id: string;
+        name: string;
+        arguments: string;
+    }>, _reasoning: OpenAIChatTurnReasoning): void;
+    /** 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. */
+    protected rememberStreamReplay(content: string, toolCalls: Array<{
+        id: string;
+        name: string;
+        arguments: string;
+    }>, reasoning: OpenAIChatTurnReasoning): void;
     /**
      * Pre-flight query: would this history validate against this provider with the
      * given extensions, without sending the request? Lets an embedder route around