@deepstrike/sdk 0.2.30 → 0.2.32

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,44 @@ 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>;
+    /** Vendor server tools (e.g. web search) injected into the `tools[]` array alongside the function
+     *  tools, driven by caller `extensions`. These run server-side — the model invokes them and the
+     *  results come back inline, with no client tool-loop round-trip. Default: none. Vendors that ship
+     *  built-in tools (GLM web_search, …) override this and strip the consumed key in `prepareExtensions`
+     *  so it does not also leak into the request body. */
+    protected serverTools(_extensions?: Record<string, unknown>): unknown[];
+    /** Merge function tools + vendor server tools into the wire `tools[]` (undefined when empty). Server
+     *  tools (e.g. web_search) are non-standard wire entries, so the array is cast to the SDK tool type. */
+    protected assembleTools(tools: ToolSchema[], extensions?: Record<string, unknown>): OpenAI.Chat.Completions.ChatCompletionTool[] | undefined;
+    /** 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

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,61 @@ 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 {};
+    }
+    /** Vendor server tools (e.g. web search) injected into the `tools[]` array alongside the function
+     *  tools, driven by caller `extensions`. These run server-side — the model invokes them and the
+     *  results come back inline, with no client tool-loop round-trip. Default: none. Vendors that ship
+     *  built-in tools (GLM web_search, …) override this and strip the consumed key in `prepareExtensions`
+     *  so it does not also leak into the request body. */
+    serverTools(_extensions) {
+        return [];
+    }
+    /** Merge function tools + vendor server tools into the wire `tools[]` (undefined when empty). Server
+     *  tools (e.g. web_search) are non-standard wire entries, so the array is cast to the SDK tool type. */
+    assembleTools(tools, extensions) {
+        const fnTools = tools.length ? this.chat.buildTools(tools) : [];
+        const all = [...fnTools, ...this.serverTools(extensions)];
+        return all.length ? all : undefined;
+    }
+    /** 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 +164,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) } : {}),
+                    ...((t => t ? { tools: t } : {})(this.assembleTools(tools, extensions))),
                 });
                 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,22 +201,51 @@ 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) } : {}),
+            ...((t => t ? { tools: t } : {})(this.assembleTools(tools, extensions))),
             stream: true,
             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 +265,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 +298,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 };
-                }
+                rememberStream();
+                yield* emitPendingToolCalls();
             }
         }
-        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 };
-            }
-        }
-        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/profiles.d.ts

@@ -729,6 +729,46 @@ export declare const modelProfiles: {
             readonly preserveAcrossToolTurns: false;
         };
     };
+    readonly "minimax/MiniMax-M3": {
+        readonly id: "minimax/MiniMax-M3";
+        readonly providerId: "minimax";
+        readonly defaultEndpointId: "minimax.anthropic";
+        readonly contextWindow: 204800;
+        readonly modalities: {
+            readonly input: ["text", "image"];
+            readonly output: ["text"];
+        };
+        readonly tools: {
+            readonly supported: true;
+        };
+        readonly reasoning: {
+            readonly supported: true;
+            readonly preserveAcrossToolTurns: true;
+        };
+        readonly policy: {
+            readonly maxTurns: 35;
+        };
+    };
+    readonly "minimax/MiniMax-M3-highspeed": {
+        readonly id: "minimax/MiniMax-M3-highspeed";
+        readonly providerId: "minimax";
+        readonly defaultEndpointId: "minimax.anthropic";
+        readonly contextWindow: 204800;
+        readonly modalities: {
+            readonly input: ["text", "image"];
+            readonly output: ["text"];
+        };
+        readonly tools: {
+            readonly supported: true;
+        };
+        readonly reasoning: {
+            readonly supported: true;
+            readonly preserveAcrossToolTurns: true;
+        };
+        readonly policy: {
+            readonly maxTurns: 35;
+        };
+    };
     readonly "minimax/MiniMax-M2.7": {
         readonly id: "minimax/MiniMax-M2.7";
         readonly providerId: "minimax";
@@ -1650,6 +1690,26 @@ export declare const modelProfiles: {
             readonly preserveAcrossToolTurns: false;
         };
     };
+    readonly "glm/glm-5.2": {
+        readonly id: "glm/glm-5.2";
+        readonly providerId: "glm";
+        readonly defaultEndpointId: "glm.anthropic";
+        readonly contextWindow: 200000;
+        readonly modalities: {
+            readonly input: ["text"];
+            readonly output: ["text"];
+        };
+        readonly tools: {
+            readonly supported: true;
+        };
+        readonly reasoning: {
+            readonly supported: true;
+            readonly preserveAcrossToolTurns: true;
+        };
+        readonly policy: {
+            readonly maxTurns: 50;
+        };
+    };
     readonly "glm/glm-5.1": {
         readonly id: "glm/glm-5.1";
         readonly providerId: "glm";

package/dist/providers/profiles.js

@@ -341,6 +341,21 @@ export const modelProfiles = {
         tools: { supported: false }, reasoning: { supported: false, preserveAcrossToolTurns: false },
     },
     // ── MiniMax ────────────────────────────────────────────────────────────────
+    "minimax/MiniMax-M3": {
+        id: "minimax/MiniMax-M3", providerId: "minimax", defaultEndpointId: "minimax.anthropic",
+        contextWindow: 204_800,
+        // Natively multimodal — image input verified live via the Anthropic image-block path.
+        modalities: { input: ["text", "image"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: true },
+        policy: { maxTurns: 35 },
+    },
+    "minimax/MiniMax-M3-highspeed": {
+        id: "minimax/MiniMax-M3-highspeed", providerId: "minimax", defaultEndpointId: "minimax.anthropic",
+        contextWindow: 204_800,
+        modalities: { input: ["text", "image"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: true },
+        policy: { maxTurns: 35 },
+    },
     "minimax/MiniMax-M2.7": {
         id: "minimax/MiniMax-M2.7", providerId: "minimax", defaultEndpointId: "minimax.anthropic",
         contextWindow: 204_800,
@@ -668,6 +683,13 @@ export const modelProfiles = {
         tools: { supported: false }, reasoning: { supported: false, preserveAcrossToolTurns: false },
     },
     // ── GLM ────────────────────────────────────────────────────────────────────
+    "glm/glm-5.2": {
+        id: "glm/glm-5.2", providerId: "glm", defaultEndpointId: "glm.anthropic",
+        contextWindow: 200_000,
+        modalities: { input: ["text"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: true },
+        policy: { maxTurns: 50 },
+    },
     "glm/glm-5.1": {
         id: "glm/glm-5.1", providerId: "glm", defaultEndpointId: "glm.anthropic",
         contextWindow: 200_000,

package/dist/providers/qwen.d.ts

@@ -1,37 +1,38 @@
-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>;
+    private searchExtraBody;
     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;
 }