@deepstrike/sdk 0.2.52 → 0.2.61

package/dist/providers/openai-responses.js

@@ -1,137 +1,19 @@
 import OpenAI from "openai";
 import { withServerRuntimeGuard } from "../runtime/server.js";
-import { CircuitBreaker, omitExtensionKeys } from "./base.js";
-import { normalizeToolCall } from "./base.js";
-import { UnsupportedModalityError } from "./base.js";
-export class OpenAIResponsesAdapter {
-    buildTools(tools) {
-        return tools.map(t => ({
-            type: "function",
-            name: t.name,
-            description: t.description,
-            parameters: JSON.parse(t.parameters),
-        }));
-    }
-    buildInstructions(context) {
-        return context.systemText || undefined;
-    }
-    buildInput(context, state) {
-        const input = [];
-        const turns = context.turns;
-        const uncoveredMessages = state?.previousResponseId
-            ? turns.slice(state.coveredMessageCount)
-            : turns;
-        for (const message of uncoveredMessages) {
-            if (message.role === "assistant" && message.toolCalls?.length) {
-                if (message.content || message.contentParts?.length) {
-                    input.push({
-                        role: "assistant",
-                        content: this.buildMessageContent(message),
-                    });
-                }
-                for (const tc of message.toolCalls) {
-                    input.push({
-                        type: "function_call",
-                        call_id: tc.id,
-                        name: tc.name,
-                        arguments: tc.arguments,
-                    });
-                }
-                continue;
-            }
-            if (message.role === "tool") {
-                for (const part of message.contentParts ?? []) {
-                    if (part.type !== "tool_result")
-                        continue;
-                    input.push({
-                        type: "function_call_output",
-                        call_id: part.callId,
-                        output: part.output,
-                    });
-                }
-                continue;
-            }
-            input.push({
-                role: message.role,
-                content: this.buildMessageContent(message),
-            });
-        }
-        // The volatile State turn is sent every turn (it changes each call and is
-        // never "covered" by previous_response_id). Absent on un-rebuilt bindings,
-        // where the state is already inside the covered/uncovered history.
-        // Rendered through the same assistant-toolCalls / tool-result branches above
-        // so tool_use blocks are not silently dropped.
-        if (context.stateTurn) {
-            const st = context.stateTurn;
-            if (st.role === "assistant" && st.toolCalls?.length) {
-                if (st.content || st.contentParts?.length) {
-                    input.push({ role: "assistant", content: this.buildMessageContent(st) });
-                }
-                for (const tc of st.toolCalls) {
-                    input.push({ type: "function_call", call_id: tc.id, name: tc.name, arguments: tc.arguments });
-                }
-            }
-            else if (st.role === "tool") {
-                for (const part of st.contentParts ?? []) {
-                    if (part.type !== "tool_result")
-                        continue;
-                    input.push({ type: "function_call_output", call_id: part.callId, output: part.output });
-                }
-            }
-            else {
-                input.push({ role: st.role, content: this.buildMessageContent(st) });
-            }
-        }
-        return input;
-    }
-    decodeOutput(output) {
-        let content = "";
-        const toolCalls = [];
-        for (const item of output) {
-            if (item.type === "message") {
-                for (const part of item.content ?? []) {
-                    if (part.type === "output_text")
-                        content += String(part.text ?? "");
-                }
-            }
-            else if (item.type === "function_call") {
-                const toolCall = normalizeToolCall(String(item.call_id ?? item.id ?? ""), String(item.name ?? ""), item.arguments ?? "{}");
-                if (toolCall)
-                    toolCalls.push(toolCall);
-            }
-        }
-        return { content, toolCalls };
-    }
-    buildMessageContent(message) {
-        if (!message.contentParts?.length)
-            return message.content;
-        const content = [];
-        for (const part of message.contentParts) {
-            if (part.type === "text") {
-                content.push({ type: "input_text", text: part.text });
-                continue;
-            }
-            if (part.type === "image") {
-                // Default the MIME type (like every other serializer) so a data-only image is
-                // not silently dropped; only a part with neither url nor data yields undefined.
-                const imageUrl = part.url ?? (part.data
-                    ? `data:${part.mediaType ?? "image/png"};base64,${part.data}`
-                    : undefined);
-                if (imageUrl)
-                    content.push({
-                        type: "input_image",
-                        detail: part.detail ?? "auto",
-                        image_url: imageUrl,
-                    });
-                continue;
-            }
-            if (part.type === "audio") {
-                throw new UnsupportedModalityError("audio", "openai-responses");
-            }
-        }
-        return content;
-    }
-}
+import { CircuitBreaker } from "./base.js";
+import { normalizeCanonicalAdapterInput, } from "./content-normalization.js";
+import { endpointProfiles } from "./endpoints.js";
+import { OpenAIResponsesAdapter, } from "./openai-responses-adapter.js";
+import { circuitOpenError, classifyProviderError } from "./provider-error.js";
+export { OpenAIResponsesAdapter } from "./openai-responses-adapter.js";
+const OFFICIAL_OPENAI_RESPONSES_BASE_URL = "https://api.openai.com/v1";
+/** Params the official input-token count endpoint accepts (SDK `InputTokenCountParams`). The
+ * create plan is projected onto this set — remaining keys (max_output_tokens, store, …) cannot
+ * change the input token count — rather than maintaining a second serialization. */
+const INPUT_TOKEN_COUNT_PARAM_KEYS = [
+    "conversation", "input", "instructions", "model", "parallel_tool_calls",
+    "previous_response_id", "reasoning", "text", "tool_choice", "tools", "truncation",
+];
 export class OpenAIResponsesProvider {
     model;
     client;
@@ -139,167 +21,185 @@ export class OpenAIResponsesProvider {
     maxRetries;
     baseDelay;
     responses = new OpenAIResponsesAdapter();
-    constructor(apiKey, model = "gpt-4.1", retry = { maxRetries: 3, baseDelay: 1000 }, baseURL = "https://api.openai.com/v1") {
+    resolvedRuntimePolicy;
+    directNativeTokenCounting;
+    resolvedRuntime;
+    constructor(apiKey, model = "gpt-4.1", retry = { maxRetries: 3, baseDelay: 1000 }, baseURL = "https://api.openai.com/v1", runtimePolicy = {}, authMode = "api_key") {
         this.model = model;
-        this.client = withServerRuntimeGuard(() => new OpenAI({ apiKey, baseURL }));
+        this.client = withServerRuntimeGuard(() => new OpenAI({
+            apiKey,
+            baseURL,
+            ...(authMode === "bearer" ? { defaultHeaders: { Authorization: `Bearer ${apiKey}` } } : {}),
+        }));
         this.circuit = new CircuitBreaker();
         this.maxRetries = retry.maxRetries;
         this.baseDelay = retry.baseDelay;
+        this.resolvedRuntimePolicy = runtimePolicy;
+        this.directNativeTokenCounting = baseURL.replace(/\/+$/, "") === OFFICIAL_OPENAI_RESPONSES_BASE_URL;
     }
     runtimePolicy() {
-        const table = {
-            "gpt-5.5": { maxTurns: 60 },
-            "gpt-5.4": { maxTurns: 50 },
-            "gpt-5.4-mini": { maxTurns: 25 },
-            "gpt-5.4-nano": { maxTurns: 15 },
-            "gpt-5.2": { maxTurns: 50 },
-            "gpt-5.2-pro": { maxTurns: 60 },
-            "gpt-5.1": { maxTurns: 50 },
-            "gpt-4.1": { maxTurns: 35 },
-            "gpt-4.1-mini": { maxTurns: 20 },
-            "gpt-4.1-nano": { maxTurns: 15 },
-            "gpt-5": { maxTurns: 50 },
-            "gpt-5-pro": { maxTurns: 60 },
-            "gpt-5-mini": { maxTurns: 25 },
-            "gpt-5-nano": { maxTurns: 15 },
-            "o3": { maxTurns: 50 },
-            "o3-mini": { maxTurns: 25 },
-            "o4-mini": { maxTurns: 25 },
-        };
-        return table[this.model] ?? {};
+        return this.resolvedRuntimePolicy;
+    }
+    bindResolvedRuntime(resolved) {
+        if (resolved.identity.protocol !== "openai-responses"
+            || resolved.identity.providerId !== "openai"
+            || resolved.identity.modelId !== this.model) {
+            throw new Error("OpenAIResponsesProvider received a mismatched resolved runtime");
+        }
+        this.resolvedRuntime = resolved;
     }
     createRunState() {
         return { coveredMessageCount: 0 };
     }
+    adapterInput(context, tools, extensions) {
+        const resolved = this.resolvedRuntime ?? {
+            identity: {
+                providerId: "openai",
+                modelId: this.model,
+                endpointId: "openai.responses",
+                protocol: "openai-responses",
+            },
+            model: {
+                id: `openai/${this.model}`,
+                providerId: "openai",
+                kind: "generation",
+                intrinsic: {},
+            },
+            endpoint: endpointProfiles["openai.responses"],
+            adapter: this,
+            effectiveCapabilities: compatibilityCapabilities(),
+        };
+        return normalizeCanonicalAdapterInput({ context, tools, resolved, extensions });
+    }
     async complete(context, tools, extensions) {
         if (this.circuit.isOpen())
-            throw new Error("Circuit breaker open");
-        let lastErr;
-        for (let i = 0; i < this.maxRetries; i++) {
+            throw circuitOpenError("openai");
+        let input;
+        let plan;
+        try {
+            input = this.adapterInput(context, tools, extensions);
+            plan = this.responses.buildRequest(input);
+        }
+        catch (error) {
+            throw classifyProviderError("openai", error);
+        }
+        let lastError;
+        for (let attempt = 0; attempt < this.maxRetries; attempt++) {
             try {
-                const instructions = this.responses.buildInstructions(context);
-                const resp = await this.client.responses.create({
-                    ...this.requestExtensions(extensions),
-                    model: this.model,
-                    input: this.responses.buildInput(context),
-                    ...(instructions ? { instructions } : {}),
-                    ...((t => t ? { tools: t } : {})(this.allTools(tools, extensions))),
-                });
+                const response = await this.client.responses.create(plan.params);
                 this.circuit.recordSuccess();
-                const decoded = this.responses.decodeOutput(resp.output);
-                return {
-                    role: "assistant",
-                    content: decoded.content,
-                    toolCalls: decoded.toolCalls,
-                    tokenCount: resp.usage?.output_tokens ?? resp.usage?.total_tokens,
-                };
+                return this.responses.decodeComplete(response, { input }).message;
             }
-            catch (err) {
-                lastErr = err;
+            catch (error) {
+                lastError = error;
                 this.circuit.recordFailure();
-                if (i < this.maxRetries - 1)
-                    await new Promise(r => setTimeout(r, this.baseDelay * 2 ** i));
+                if (attempt < this.maxRetries - 1) {
+                    await new Promise(resolve => setTimeout(resolve, this.baseDelay * 2 ** attempt));
+                }
             }
         }
-        throw lastErr;
+        throw classifyProviderError("openai", lastError);
     }
-    async *stream(context, tools, extensions, state) {
-        const runState = this.asRunState(state);
-        const functionCalls = new Map();
-        const instructions = this.responses.buildInstructions(context);
-        const stream = await this.client.responses.create({
-            ...this.requestExtensions(extensions),
-            model: this.model,
-            input: this.responses.buildInput(context, runState),
-            ...(instructions ? { instructions } : {}),
-            ...(runState.previousResponseId ? { previous_response_id: runState.previousResponseId } : {}),
-            ...((t => t ? { tools: t } : {})(this.allTools(tools, extensions))),
-            stream: true,
-        });
-        for await (const evt of stream) {
-            if (evt.type === "response.output_text.delta") {
-                yield { type: "text_delta", delta: evt.delta };
-            }
-            else if (evt.type === "response.output_item.added" && evt.item.type === "function_call") {
-                functionCalls.set(evt.output_index, {
-                    id: evt.item.call_id,
-                    name: evt.item.name,
-                    argsBuf: evt.item.arguments ?? "",
-                });
-            }
-            else if (evt.type === "response.function_call_arguments.delta") {
-                const call = functionCalls.get(evt.output_index);
-                if (call)
-                    call.argsBuf += evt.delta;
-            }
-            else if (evt.type === "response.function_call_arguments.done") {
-                const call = functionCalls.get(evt.output_index);
-                if (call)
-                    call.argsBuf = evt.arguments;
-            }
-            else if (evt.type === "response.output_item.done" && evt.item.type === "function_call") {
-                const call = functionCalls.get(evt.output_index) ?? {
-                    id: evt.item.call_id,
-                    name: evt.item.name,
-                    argsBuf: evt.item.arguments ?? "{}",
-                };
-                let args = {};
-                try {
-                    args = JSON.parse(call.argsBuf || "{}");
-                }
-                catch {
-                    args = {};
+    /** spc_024-05: native preflight via the official Responses input-token count endpoint. Counts
+     * the exact create request plan (stateful `previous_response_id` continuation included) —
+     * native measurement belongs to the verified official endpoint, not the wire protocol. */
+    async countTokens(context, tools, extensions, state) {
+        const enabled = this.resolvedRuntime
+            ? this.resolvedRuntime.effectiveCapabilities.nativeTokenCounting.state === "supported"
+            : this.directNativeTokenCounting;
+        const inputTokens = this.client.responses.inputTokens;
+        if (!enabled || typeof inputTokens?.count !== "function") {
+            throw new Error("Native token counting is unavailable on this OpenAI-compatible endpoint");
+        }
+        const input = this.adapterInput(context, tools, extensions);
+        const plan = this.responses.buildRequest(input, this.asRunState(state));
+        const body = Object.fromEntries(INPUT_TOKEN_COUNT_PARAM_KEYS
+            .filter(key => key in plan.params)
+            .map(key => [key, plan.params[key]]));
+        const response = await inputTokens.count(body);
+        return {
+            inputTokens: response.input_tokens,
+            source: { kind: "native", provider: "openai" },
+            confidence: "exact",
+        };
+    }
+    async *stream(context, tools, extensions, state, signal) {
+        try {
+            const runState = this.asRunState(state);
+            const input = this.adapterInput(context, tools, extensions);
+            const plan = this.responses.buildRequest(input, runState);
+            const streamState = this.responses.createStreamState({ input }, runState);
+            const stream = await this.client.responses.create({ ...plan.params, stream: true }, signal ? { signal } : undefined);
+            for await (const chunk of stream) {
+                const output = this.responses.pushStreamChunk(chunk, streamState);
+                for (const event of output.events)
+                    yield event;
+                if (output.runStatePatch) {
+                    Object.assign(runState, output.runStatePatch);
+                    if (state)
+                        Object.assign(state, output.runStatePatch);
                 }
-                yield { type: "tool_call", id: call.id, name: call.name, arguments: args };
             }
-            else if (evt.type === "response.completed") {
-                runState.previousResponseId = evt.response.id;
-                runState.coveredMessageCount = context.turns.length + 1;
-                if (evt.response.usage?.total_tokens) {
-                    // Responses API reports prompt-cache hits as input_tokens_details.cached_tokens,
-                    // a subset of input_tokens (the full prompt, kept for accounting).
-                    const cachedTokens = evt.response.usage.input_tokens_details?.cached_tokens ?? 0;
-                    yield {
-                        type: "usage",
-                        totalTokens: evt.response.usage.total_tokens,
-                        ...(evt.response.usage.input_tokens ? { inputTokens: evt.response.usage.input_tokens } : {}),
-                        ...(evt.response.usage.output_tokens ? { outputTokens: evt.response.usage.output_tokens } : {}),
-                        ...(cachedTokens > 0 ? { cacheReadInputTokens: cachedTokens } : {}),
-                    };
-                }
+            const final = this.responses.finishStream(streamState);
+            for (const event of final.events)
+                yield event;
+            if (final.runStatePatch) {
+                Object.assign(runState, final.runStatePatch);
+                if (state)
+                    Object.assign(state, final.runStatePatch);
             }
         }
+        catch (error) {
+            throw classifyProviderError("openai", error);
+        }
     }
-    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. */
+    // White-box test seams. Protocol request shaping belongs to the adapter.
     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;
+        return this.responses.builtinTools(extensions);
     }
-    /** 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;
+    requestExtensions(extensions) {
+        return this.responses.requestExtensions(extensions);
     }
     asRunState(state) {
         if (!state)
             return this.createRunState();
-        if (typeof state.coveredMessageCount !== "number")
-            state.coveredMessageCount = 0;
-        return state;
+        return {
+            ...state,
+            coveredMessageCount: typeof state.coveredMessageCount === "number"
+                ? state.coveredMessageCount
+                : 0,
+        };
     }
 }
+function compatibilityCapabilities() {
+    const unknown = { state: "unknown", evidence: [] };
+    const unsupported = { state: "unsupported", evidence: ["protocol"] };
+    return {
+        inputModalities: {
+            text: unknown,
+            image: unknown,
+            audio: unsupported,
+            video: unsupported,
+            file: unknown,
+        },
+        outputModalities: {
+            text: unknown,
+            image: unsupported,
+            audio: unsupported,
+            embedding: unsupported,
+        },
+        tools: unknown,
+        reasoning: unknown,
+        parallelToolCalls: unknown,
+        structuredOutput: unknown,
+        promptCaching: unknown,
+        nativeTokenCounting: unknown,
+        mediaForms: {
+            imageUrl: unknown,
+            imageBase64: unknown,
+            fileId: unknown,
+            audioUrl: unsupported,
+            audioBase64: unsupported,
+        },
+    };
+}

package/dist/providers/openai.d.ts

@@ -1,10 +1,10 @@
 import OpenAI from "openai";
-import type { Message, ProviderDescriptor, ProviderReplay, ProviderRunState, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
+import type { LLMProvider, Message, ProviderDescriptor, ProviderReplay, ProviderRunState, RenderedContext, ReplayabilityAssessment, RuntimePolicy, StreamEvent, ToolSchema } from "../types.js";
 import { CircuitBreaker } from "./base.js";
+import { type CanonicalAdapterInput } from "./content-normalization.js";
 import { OpenAIChatAdapter } from "./openai-chat.js";
-import type { ReplayabilityAssessment } from "./replay-validator.js";
-/** Options-object form for `OpenAIProvider` — the recommended way to construct an OpenAI-compatible
- *  provider (custom `baseURL` no longer needs a positional hole). */
+import { type OpenAIChatTurnReasoning, type OpenAIChatWireDialect } from "./openai-chat-dialects.js";
+/** Canonical constructor contract for OpenAI-chat providers. */
 export interface OpenAIProviderOptions {
     apiKey: string;
     model?: string;
@@ -12,23 +12,13 @@ export interface OpenAIProviderOptions {
         maxRetries: number;
         baseDelay: number;
     };
-    /** Custom OpenAI-compatible endpoint (MiMo, DeepSeek, Kimi, …). Defaults to the OpenAI API. */
     baseURL?: string;
+    runtimePolicy?: RuntimePolicy;
+    dialect?: OpenAIChatWireDialect;
+    authMode?: "api_key" | "bearer";
 }
-/** 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 type { OpenAIChatTurnReasoning } from "./openai-chat-dialects.js";
+type ResolvedOpenAIChatRuntime = CanonicalAdapterInput["resolved"];
 export declare class OpenAIChatProvider implements LLMProvider {
     protected client: OpenAI;
     protected circuit: CircuitBreaker;
@@ -36,72 +26,35 @@ export declare class OpenAIChatProvider implements LLMProvider {
     protected baseDelay: number;
     protected readonly model: string;
     protected readonly chat: OpenAIChatAdapter;
-    constructor(apiKeyOrOptions: string | OpenAIProviderOptions, model?: string, retry?: {
-        maxRetries: number;
-        baseDelay: number;
-    }, baseURL?: string);
+    protected readonly dialect: OpenAIChatWireDialect;
+    private readonly replayStore;
+    private readonly resolvedRuntimePolicy;
+    private resolvedRuntime?;
+    constructor(options: OpenAIProviderOptions);
     runtimePolicy(): RuntimePolicy;
     descriptor(): ProviderDescriptor;
-    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. */
+    bindResolvedRuntime(resolved: ResolvedOpenAIChatRuntime): void;
+    assessReplayability(context: RenderedContext, extensions?: Record<string, unknown>): ReplayabilityAssessment;
+    peekProviderReplay(message: Pick<Message, "content" | "toolCalls">): ProviderReplay | undefined;
+    seedProviderReplay(message: Pick<Message, "content" | "toolCalls">, replay: ProviderReplay): void;
+    private rememberReplay;
+    private adapterInput;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, _state?: ProviderRunState, signal?: AbortSignal): AsyncIterable<StreamEvent>;
+    protected prepareExtensions(extensions?: Record<string, unknown>): Record<string, unknown>;
+    protected requestBodyExtras(extensions?: Record<string, unknown>): Record<string, unknown>;
+    protected serverTools(extensions?: Record<string, unknown>): unknown[];
+    protected requestExtensions(extensions?: Record<string, unknown>): Record<string, unknown>;
+    protected promptCacheKey(context: RenderedContext, tools: ToolSchema[]): string;
     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<{
+    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
-     * a reasoning-replay failure (keep thinking on, disable it, or skip this
-     * candidate) before issuing the request. `ok: true` when this provider does
-     * not require reasoning replay for the current extensions.
-     */
-    assessReplayability(context: RenderedContext, extensions?: Record<string, unknown>): ReplayabilityAssessment;
-    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>, _state?: ProviderRunState, signal?: AbortSignal): AsyncIterable<StreamEvent>;
-    /**
-     * Default `prompt_cache_key` derived from the cacheable prefix (system prompt +
-     * tool names) so requests for the same agent config route to the same cache.
-     * A caller-supplied `prompt_cache_key` in extensions overrides it (it is spread
-     * after this default). Unknown to non-OpenAI compatible endpoints, which ignore it.
-     */
-    protected promptCacheKey(context: RenderedContext, tools: ToolSchema[]): string;
-    protected requestExtensions(extensions?: Record<string, unknown>): Record<string, unknown>;
+    }>, _reasoning: OpenAIChatTurnReasoning): void;
 }
 export { OpenAIChatProvider as OpenAIProvider };