@deepstrike/sdk 0.2.52 → 0.2.61

package/dist/providers/ollama.js

@@ -1,129 +1,116 @@
-import { normalizeToolCall, omitExtensionKeys, turnsWithStateAppended, UnsupportedModalityError } from "./base.js";
-// Prefix-based policy for local models (first match wins)
-const OLLAMA_PREFIX_POLICIES = [
-    ["deepseek-r1", { maxTurns: 40 }],
-    ["qwq", { maxTurns: 35 }],
-    ["llama3.3", { maxTurns: 25 }],
-    ["llama3.2", { maxTurns: 20 }],
-    ["llama3.1", { maxTurns: 20 }],
-    ["llama3", { maxTurns: 20 }],
-    ["mistral", { maxTurns: 20 }],
-    ["gemma2", { maxTurns: 20 }],
-    ["phi4", { maxTurns: 20 }],
-    ["phi3", { maxTurns: 15 }],
-    ["codellama", { maxTurns: 20 }],
-];
+import { normalizeCanonicalAdapterInput, } from "./content-normalization.js";
+import { endpointProfiles } from "./endpoints.js";
+import { OllamaAdapter } from "./ollama-adapter.js";
+import { classifyProviderError, ProviderError } from "./provider-error.js";
 export class OllamaProvider {
     model;
     baseUrl;
-    constructor(model = "llama3", baseUrl = "http://localhost:11434") {
+    resolvedRuntimePolicy;
+    resolvedRuntime;
+    adapter = new OllamaAdapter();
+    constructor(model = "llama3", baseUrl = "http://localhost:11434", resolvedRuntimePolicy = {}, resolvedRuntime) {
         this.model = model;
         this.baseUrl = baseUrl;
+        this.resolvedRuntimePolicy = resolvedRuntimePolicy;
+        this.resolvedRuntime = resolvedRuntime;
     }
     runtimePolicy() {
-        const m = this.model.toLowerCase();
-        for (const [prefix, policy] of OLLAMA_PREFIX_POLICIES) {
-            if (m.startsWith(prefix))
-                return policy;
-        }
-        return { maxTurns: 20 };
+        return this.resolvedRuntimePolicy;
     }
-    toOllamaMessages(context) {
-        const result = [];
-        if (context.systemText)
-            result.push({ role: "system", content: context.systemText });
-        for (const m of turnsWithStateAppended(context)) {
-            const images = [];
-            if (m.contentParts?.length) {
-                for (const p of m.contentParts) {
-                    if (p.type === "image" && p.data)
-                        images.push(p.data);
-                    else if (p.type === "audio")
-                        throw new UnsupportedModalityError("audio", "ollama");
-                }
-            }
-            result.push({ role: m.role, content: m.content, ...(images.length ? { images } : {}) });
+    bindResolvedRuntime(resolved) {
+        if (resolved.identity.protocol !== "ollama-chat"
+            || resolved.identity.modelId !== this.model) {
+            throw new Error("OllamaProvider received a mismatched resolved runtime");
         }
-        return result;
+        this.resolvedRuntime = resolved;
     }
-    buildTools(tools) {
-        return tools.map(t => ({
-            type: "function",
-            function: { name: t.name, description: t.description, parameters: JSON.parse(t.parameters) },
-        }));
-    }
-    requestExtensions(extensions) {
-        return omitExtensionKeys(extensions, ["model", "messages", "tools", "stream"]);
+    adapterInput(context, tools, extensions) {
+        const resolved = this.resolvedRuntime ?? {
+            identity: {
+                providerId: "ollama",
+                modelId: this.model,
+                endpointId: "ollama.local",
+                protocol: "ollama-chat",
+            },
+            model: { id: `ollama/${this.model}`, providerId: "ollama", kind: "generation", intrinsic: {} },
+            endpoint: endpointProfiles["ollama.local"],
+            adapter: this,
+            effectiveCapabilities: {
+                inputModalities: Object.fromEntries(["text", "image", "audio", "video", "file"].map(modality => [modality, { state: modality === "audio" || modality === "video" || modality === "file" ? "unsupported" : "unknown", evidence: [] }])),
+                outputModalities: Object.fromEntries(["text", "image", "audio", "embedding"].map(modality => [modality, { state: "unknown", evidence: [] }])),
+                tools: { state: "unknown", evidence: [] },
+                reasoning: { state: "unknown", evidence: [] },
+                parallelToolCalls: { state: "unknown", evidence: [] },
+                structuredOutput: { state: "unknown", evidence: [] },
+                promptCaching: { state: "unknown", evidence: [] },
+                nativeTokenCounting: { state: "unknown", evidence: [] },
+                mediaForms: Object.fromEntries(["imageUrl", "imageBase64", "fileId", "audioUrl", "audioBase64"].map(form => [form, { state: "unknown", evidence: [] }])),
+            },
+        };
+        return normalizeCanonicalAdapterInput({ context, tools, resolved, extensions });
     }
     async complete(context, tools, extensions) {
-        const resp = await fetch(`${this.baseUrl}/api/chat`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-                ...this.requestExtensions(extensions),
-                model: this.model,
-                messages: this.toOllamaMessages(context),
-                ...(tools.length ? { tools: this.buildTools(tools) } : {}),
-                stream: false,
-            }),
-        });
-        if (!resp.ok)
-            throw new Error(`Ollama error: ${resp.status}`);
-        const data = await resp.json();
-        return { role: "assistant", content: data.message.content };
+        try {
+            const input = this.adapterInput(context, tools, extensions);
+            const body = { ...this.adapter.buildRequest(input), stream: false };
+            const resp = await fetch(`${this.baseUrl}/api/chat`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+            });
+            if (!resp.ok)
+                throw ollamaHttpError(resp.status);
+            const data = await resp.json();
+            return this.adapter.decodeComplete(data, { input }).message;
+        }
+        catch (error) {
+            throw classifyProviderError("ollama", error);
+        }
     }
     async *stream(context, tools, extensions) {
-        const resp = await fetch(`${this.baseUrl}/api/chat`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-                ...this.requestExtensions(extensions),
-                model: this.model,
-                messages: this.toOllamaMessages(context),
-                ...(tools.length ? { tools: this.buildTools(tools) } : {}),
-                stream: true,
-            }),
-        });
-        if (!resp.ok)
-            throw new Error(`Ollama error: ${resp.status}`);
-        const reader = resp.body.getReader();
-        const decoder = new TextDecoder();
-        let buf = "";
-        const pendingToolCalls = new Map();
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            buf += decoder.decode(value, { stream: true });
-            const lines = buf.split("\n");
-            buf = lines.pop() ?? "";
-            for (const line of lines) {
-                if (!line.trim())
-                    continue;
-                try {
-                    const chunk = JSON.parse(line);
-                    if (chunk.message?.content)
-                        yield { type: "text_delta", delta: chunk.message.content };
-                    for (const tc of chunk.message?.tool_calls ?? []) {
-                        const norm = normalizeToolCall("", tc.function.name, tc.function.arguments);
-                        if (!norm)
-                            continue;
-                        const args = JSON.parse(norm.arguments);
-                        const key = `${norm.name}:${norm.arguments}`;
-                        if (!pendingToolCalls.has(key)) {
-                            pendingToolCalls.set(key, {
-                                id: `call_${pendingToolCalls.size + 1}`,
-                                name: norm.name,
-                                arguments: args,
-                            });
-                        }
-                    }
+        try {
+            const input = this.adapterInput(context, tools, extensions);
+            const body = { ...this.adapter.buildRequest(input), stream: true };
+            const resp = await fetch(`${this.baseUrl}/api/chat`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+            });
+            if (!resp.ok)
+                throw ollamaHttpError(resp.status);
+            if (!resp.body) {
+                throw new ProviderError({
+                    provider: "ollama",
+                    kind: "protocol",
+                    retryable: false,
+                    message: "Ollama stream response has no body",
+                });
+            }
+            const reader = resp.body.getReader();
+            const decoder = new TextDecoder();
+            const ndjson = this.adapter.createNdjsonDecoder();
+            const state = this.adapter.createStreamState({ input });
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                for (const chunk of ndjson.push(decoder.decode(value, { stream: true }))) {
+                    for (const event of this.adapter.pushStreamChunk(chunk, state).events)
+                        yield event;
                 }
-                catch { /* skip malformed lines */ }
             }
+            for (const chunk of ndjson.finish(decoder.decode())) {
+                for (const event of this.adapter.pushStreamChunk(chunk, state).events)
+                    yield event;
+            }
+            for (const event of this.adapter.finishStream(state, state.finalChunk).events)
+                yield event;
         }
-        for (const tc of pendingToolCalls.values()) {
-            yield { type: "tool_call", id: tc.id, name: tc.name, arguments: tc.arguments };
+        catch (error) {
+            throw classifyProviderError("ollama", error);
         }
     }
 }
+function ollamaHttpError(status) {
+    return classifyProviderError("ollama", Object.assign(new Error(`Ollama error: ${status}`), { status }));
+}

package/dist/providers/openai-chat-dialects.d.ts

@@ -0,0 +1,154 @@
+import type { ProviderDescriptor, ProviderReplay, ToolCall } from "../types.js";
+import type { EndpointProfileId, ProviderId } from "./endpoints.js";
+export interface OpenAIChatTurnReasoning {
+    reasoningContent: string;
+    reasoningDetails?: unknown;
+    nativeToolCalls: unknown[];
+}
+export type OpenAIChatReplayStrategy = "none" | "generic_stream" | "deepseek" | "minimax";
+export interface OpenAIChatWireDialect {
+    readonly id: string;
+    readonly providerId: ProviderId;
+    readonly endpointId: EndpointProfileId;
+    readonly descriptor: {
+        reasoning: ProviderDescriptor["reasoning"];
+    };
+    readonly prepareExtensions: (extensions: Readonly<Record<string, unknown>>) => Record<string, unknown>;
+    readonly serverTools?: (extensions: Readonly<Record<string, unknown>>) => unknown[];
+    readonly cacheKey: "openai" | "none";
+    readonly inlineThinkingTags: boolean;
+    readonly exposeReasoning: (extensions: Readonly<Record<string, unknown>>) => boolean;
+    readonly requireReasoningReplay: (extensions: Readonly<Record<string, unknown>>) => boolean;
+    readonly replay: OpenAIChatReplayStrategy;
+}
+export declare const openAIChatDialects: {
+    readonly openai: {
+        readonly id: "openai";
+        readonly providerId: "openai";
+        readonly endpointId: "openai.chat";
+        readonly descriptor: {
+            readonly reasoning: {
+                supported: boolean;
+                preserveAcrossToolTurns: boolean;
+                requiresReplayForToolTurns?: boolean;
+            };
+        };
+        readonly prepareExtensions: (extensions: Readonly<Record<string, unknown>>) => Record<string, unknown>;
+        readonly cacheKey: "openai";
+        readonly inlineThinkingTags: true;
+        readonly exposeReasoning: () => boolean;
+        readonly requireReasoningReplay: () => boolean;
+        readonly replay: "generic_stream";
+    };
+    readonly deepseek: {
+        readonly id: "deepseek";
+        readonly providerId: "deepseek";
+        readonly endpointId: "deepseek.openai";
+        readonly descriptor: {
+            readonly reasoning: {
+                supported: boolean;
+                preserveAcrossToolTurns: boolean;
+                requiresReplayForToolTurns?: boolean;
+            };
+        };
+        readonly prepareExtensions: (extensions: Readonly<Record<string, unknown>>) => {
+            __deepstrikeThinkingEnabled: boolean;
+            reasoning_effort: string;
+            extra_body: {
+                thinking: {
+                    type: string;
+                };
+            };
+            degradeMissingReasoningReplay?: boolean | undefined;
+        };
+        readonly cacheKey: "none";
+        readonly inlineThinkingTags: false;
+        readonly exposeReasoning: (extensions: Readonly<Record<string, unknown>>) => boolean;
+        readonly requireReasoningReplay: (extensions: Readonly<Record<string, unknown>>) => boolean;
+        readonly replay: "deepseek";
+    };
+    readonly kimi: {
+        readonly id: "kimi";
+        readonly providerId: "kimi";
+        readonly endpointId: "kimi.openai";
+        readonly descriptor: {
+            readonly reasoning: {
+                supported: boolean;
+                preserveAcrossToolTurns: boolean;
+                requiresReplayForToolTurns?: boolean;
+            };
+        };
+        readonly prepareExtensions: (extensions: Readonly<Record<string, unknown>>) => Record<string, unknown>;
+        readonly cacheKey: "openai";
+        readonly inlineThinkingTags: true;
+        readonly exposeReasoning: () => boolean;
+        readonly requireReasoningReplay: () => boolean;
+        readonly replay: "generic_stream";
+    };
+    readonly qwen: {
+        readonly id: "qwen";
+        readonly providerId: "qwen";
+        readonly endpointId: "qwen.dashscope";
+        readonly descriptor: {
+            readonly reasoning: {
+                supported: boolean;
+                preserveAcrossToolTurns: boolean;
+                requiresReplayForToolTurns?: boolean;
+            };
+        };
+        readonly prepareExtensions: (extensions: Readonly<Record<string, unknown>>) => {
+            extra_body?: Record<string, unknown> | undefined;
+        };
+        readonly cacheKey: "none";
+        readonly inlineThinkingTags: false;
+        readonly exposeReasoning: () => boolean;
+        readonly requireReasoningReplay: () => boolean;
+        readonly replay: "generic_stream";
+    };
+    readonly glm: {
+        readonly id: "glm";
+        readonly providerId: "glm";
+        readonly endpointId: "glm.openai";
+        readonly descriptor: {
+            readonly reasoning: {
+                supported: boolean;
+                preserveAcrossToolTurns: boolean;
+                requiresReplayForToolTurns?: boolean;
+            };
+        };
+        readonly prepareExtensions: (extensions: Readonly<Record<string, unknown>>) => Record<string, unknown>;
+        readonly serverTools: (extensions: Readonly<Record<string, unknown>>) => {
+            type: string;
+            web_search: object;
+        }[];
+        readonly cacheKey: "openai";
+        readonly inlineThinkingTags: true;
+        readonly exposeReasoning: () => boolean;
+        readonly requireReasoningReplay: () => boolean;
+        readonly replay: "generic_stream";
+    };
+    readonly minimax: {
+        readonly id: "minimax";
+        readonly providerId: "minimax";
+        readonly endpointId: "minimax.openai";
+        readonly descriptor: {
+            readonly reasoning: {
+                supported: boolean;
+                preserveAcrossToolTurns: boolean;
+                requiresReplayForToolTurns?: boolean;
+            };
+        };
+        readonly prepareExtensions: (extensions: Readonly<Record<string, unknown>>) => {
+            __deepstrikeThinkingEnabled: boolean;
+            reasoning_split: boolean;
+            degradeMissingReasoningReplay?: boolean | undefined;
+        };
+        readonly cacheKey: "none";
+        readonly inlineThinkingTags: false;
+        readonly exposeReasoning: (extensions: Readonly<Record<string, unknown>>) => boolean;
+        readonly requireReasoningReplay: (extensions: Readonly<Record<string, unknown>>) => boolean;
+        readonly replay: "minimax";
+    };
+};
+export type OpenAIChatDialectId = keyof typeof openAIChatDialects;
+export declare function replayForTurn(dialect: OpenAIChatWireDialect, phase: "complete" | "stream", model: string, content: string, toolCalls: ToolCall[], reasoning: OpenAIChatTurnReasoning): ProviderReplay | undefined;

package/dist/providers/openai-chat-dialects.js

@@ -0,0 +1,179 @@
+function omit(extensions, keys) {
+    const blocked = new Set([
+        ...keys,
+        "model", "messages", "tools", "stream", "stream_options",
+        "__deepstrikeThinkingEnabled", "degradeMissingReasoningReplay",
+    ]);
+    return Object.fromEntries(Object.entries(extensions).filter(([key]) => !blocked.has(key)));
+}
+const portableReasoning = {
+    supported: true,
+    preserveAcrossToolTurns: false,
+};
+const outOfBandReasoning = {
+    supported: true,
+    preserveAcrossToolTurns: true,
+};
+const strictReasoning = {
+    supported: true,
+    preserveAcrossToolTurns: true,
+    requiresReplayForToolTurns: true,
+};
+const passthrough = (extensions) => omit(extensions, []);
+const never = () => false;
+const always = () => true;
+export const openAIChatDialects = {
+    openai: {
+        id: "openai",
+        providerId: "openai",
+        endpointId: "openai.chat",
+        descriptor: { reasoning: portableReasoning },
+        prepareExtensions: passthrough,
+        cacheKey: "openai",
+        inlineThinkingTags: true,
+        exposeReasoning: always,
+        requireReasoningReplay: never,
+        replay: "generic_stream",
+    },
+    deepseek: {
+        id: "deepseek",
+        providerId: "deepseek",
+        endpointId: "deepseek.openai",
+        descriptor: { reasoning: strictReasoning },
+        prepareExtensions: extensions => {
+            const thinking = extensions.thinking === false ? "disabled" : "enabled";
+            return {
+                ...omit(extensions, ["thinking", "reasoningEffort", "exposeReasoning", "extra_body", "reasoning_effort"]),
+                ...(extensions.degradeMissingReasoningReplay === true
+                    ? { degradeMissingReasoningReplay: true }
+                    : {}),
+                __deepstrikeThinkingEnabled: thinking !== "disabled",
+                reasoning_effort: extensions.reasoningEffort === "max" ? "max" : "high",
+                extra_body: { thinking: { type: thinking } },
+            };
+        },
+        cacheKey: "none",
+        inlineThinkingTags: false,
+        exposeReasoning: extensions => extensions.exposeReasoning === true,
+        requireReasoningReplay: extensions => extensions.__deepstrikeThinkingEnabled !== false && extensions.thinking !== false,
+        replay: "deepseek",
+    },
+    kimi: {
+        id: "kimi",
+        providerId: "kimi",
+        endpointId: "kimi.openai",
+        descriptor: { reasoning: portableReasoning },
+        prepareExtensions: passthrough,
+        cacheKey: "openai",
+        inlineThinkingTags: true,
+        exposeReasoning: always,
+        requireReasoningReplay: never,
+        replay: "generic_stream",
+    },
+    qwen: {
+        id: "qwen",
+        providerId: "qwen",
+        endpointId: "qwen.dashscope",
+        descriptor: { reasoning: outOfBandReasoning },
+        prepareExtensions: extensions => {
+            const enableThinking = Boolean(extensions.enableThinking ?? extensions.enable_thinking);
+            const thinkingBudget = extensions.thinkingBudget ?? extensions.thinking_budget;
+            const extraBody = {};
+            if (enableThinking) {
+                extraBody.enable_thinking = true;
+                if (typeof thinkingBudget === "number")
+                    extraBody.thinking_budget = thinkingBudget;
+            }
+            if (extensions.enable_search) {
+                extraBody.enable_search = true;
+                if (extensions.search_options != null)
+                    extraBody.search_options = extensions.search_options;
+            }
+            return {
+                ...omit(extensions, [
+                    "extra_body", "enableThinking", "enable_thinking", "thinkingBudget", "thinking_budget",
+                    "enable_search", "search_options",
+                ]),
+                ...(Object.keys(extraBody).length ? { extra_body: extraBody } : {}),
+            };
+        },
+        cacheKey: "none",
+        inlineThinkingTags: false,
+        exposeReasoning: always,
+        requireReasoningReplay: never,
+        replay: "generic_stream",
+    },
+    glm: {
+        id: "glm",
+        providerId: "glm",
+        endpointId: "glm.openai",
+        descriptor: { reasoning: portableReasoning },
+        prepareExtensions: extensions => omit(extensions, ["web_search"]),
+        serverTools: extensions => extensions.web_search
+            ? [{
+                    type: "web_search",
+                    web_search: typeof extensions.web_search === "object" ? extensions.web_search : {},
+                }]
+            : [],
+        cacheKey: "openai",
+        inlineThinkingTags: true,
+        exposeReasoning: always,
+        requireReasoningReplay: never,
+        replay: "generic_stream",
+    },
+    minimax: {
+        id: "minimax",
+        providerId: "minimax",
+        endpointId: "minimax.openai",
+        descriptor: { reasoning: strictReasoning },
+        prepareExtensions: extensions => {
+            const reasoningSplit = extensions.reasoning_split !== false;
+            return {
+                ...omit(extensions, ["reasoning_split", "exposeReasoning"]),
+                ...(extensions.degradeMissingReasoningReplay === true
+                    ? { degradeMissingReasoningReplay: true }
+                    : {}),
+                __deepstrikeThinkingEnabled: reasoningSplit,
+                reasoning_split: reasoningSplit,
+            };
+        },
+        cacheKey: "none",
+        inlineThinkingTags: false,
+        exposeReasoning: extensions => extensions.exposeReasoning === true,
+        requireReasoningReplay: extensions => extensions.__deepstrikeThinkingEnabled !== false && extensions.reasoning_split !== false,
+        replay: "minimax",
+    },
+};
+export function replayForTurn(dialect, phase, model, content, toolCalls, reasoning) {
+    switch (dialect.replay) {
+        case "none": return undefined;
+        case "generic_stream":
+            return phase === "stream" && (toolCalls.length > 0 || reasoning.reasoningContent)
+                ? { protocol: "openai-chat", reasoning_content: reasoning.reasoningContent }
+                : undefined;
+        case "deepseek":
+            if (!reasoning.reasoningContent.trim())
+                return undefined;
+            return {
+                provider: dialect.providerId,
+                protocol: "openai-chat",
+                model,
+                reasoning_content: reasoning.reasoningContent,
+                ...(reasoning.nativeToolCalls.length ? { tool_calls: reasoning.nativeToolCalls } : {}),
+            };
+        case "minimax": {
+            const hasReasoning = reasoning.reasoningContent.trim().length > 0;
+            const hasDetails = reasoning.reasoningDetails !== undefined && reasoning.reasoningDetails !== null;
+            if (!hasReasoning && !hasDetails)
+                return undefined;
+            return {
+                provider: dialect.providerId,
+                protocol: "openai-chat",
+                model,
+                ...(hasReasoning ? { reasoning_content: reasoning.reasoningContent } : {}),
+                ...(hasDetails ? { reasoning_details: reasoning.reasoningDetails } : {}),
+                ...(reasoning.nativeToolCalls.length ? { tool_calls: reasoning.nativeToolCalls } : {}),
+            };
+        }
+    }
+}

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

@@ -1,19 +1,55 @@
 import type OpenAI from "openai";
-import type { Message, ProviderDescriptor, RenderedContext, ToolSchema } from "../types.js";
+import type { Message, ProviderDescriptor, ProviderReplay, ProviderUsage, RenderedContext, ToolCall, ToolSchema } from "../types.js";
+import { ThinkingTagStreamExtractor } from "./base.js";
+import type { CanonicalAdapterInput } from "./content-normalization.js";
 import { type ReplayabilityAssessment } from "./replay-validator.js";
+import { type AdapterDecodeInput, type AdapterOutput, type AdapterStreamInput, type CanonicalStopReason, type ProtocolAdapter } from "./protocol-adapter.js";
+import { type OpenAIChatWireDialect } from "./openai-chat-dialects.js";
 export interface OpenAIChatBuildMessageOptions {
     descriptor?: ProviderDescriptor;
     requireNonEmptyReasoningForToolCalls?: boolean;
-    /**
-     * Degrade (rather than throw) when a reasoning-requiring tool-call turn has
-     * no stored reasoning replay: a placeholder reasoning is injected so the
-     * request still goes out in degraded form.
-     */
     degradeMissingReasoning?: boolean;
 }
-export declare class OpenAIChatAdapter {
-    private replayFields;
-    buildTools(tools: ToolSchema[]): {
+export interface OpenAIChatRequestPlan {
+    params: Record<string, unknown>;
+    preparedExtensions: Record<string, unknown>;
+    dialect: OpenAIChatWireDialect;
+}
+export type OpenAIChatStreamChunk = Record<string, any>;
+export interface OpenAIChatStreamState {
+    readonly input: CanonicalAdapterInput;
+    readonly dialect: OpenAIChatWireDialect;
+    readonly toolCallBuffers: Record<number, {
+        id: string;
+        name: string;
+        argsBuffer: string;
+    }>;
+    readonly emittedToolCallIndexes: Set<number>;
+    readonly extractor: ThinkingTagStreamExtractor;
+    accumulatedReasoning: string;
+    accumulatedReasoningDetails?: unknown;
+    accumulatedContent: string;
+    totalTokens: number;
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    finishReason?: string;
+    rawUsage?: unknown;
+}
+export declare class OpenAIChatAdapter implements ProtocolAdapter<OpenAIChatRequestPlan, Record<string, any>, OpenAIChatStreamChunk, OpenAIChatStreamState, undefined> {
+    readonly protocol: "openai-chat";
+    readonly protocolCapabilities: import("./protocol-capabilities.js").ProtocolRuntimeCapabilities;
+    buildRequest(input: CanonicalAdapterInput, dialect?: OpenAIChatWireDialect): OpenAIChatRequestPlan;
+    decodeComplete(raw: Record<string, any>, input: AdapterDecodeInput, dialect?: OpenAIChatWireDialect): {
+        message: Message;
+        replay?: ProviderReplay;
+    };
+    createStreamState(input: AdapterStreamInput, dialect?: OpenAIChatWireDialect): OpenAIChatStreamState;
+    pushStreamChunk(chunk: OpenAIChatStreamChunk, state: OpenAIChatStreamState): AdapterOutput;
+    finishStream(state: OpenAIChatStreamState): AdapterOutput;
+    normalizeUsage(raw: unknown): ProviderUsage | undefined;
+    normalizeStopReason(raw: string | undefined): CanonicalStopReason | undefined;
+    buildTools(tools: readonly ToolSchema[]): {
         type: "function";
         function: {
             name: string;
@@ -22,16 +58,8 @@ export declare class OpenAIChatAdapter {
         };
     }[];
     buildMessages(context: RenderedContext, options?: OpenAIChatBuildMessageOptions): OpenAI.ChatCompletionMessageParam[];
-    /**
-     * Throw-free pre-flight check: which assistant tool-call turns in `context`
-     * lack the non-empty reasoning replay a reasoning-requiring provider needs.
-     */
     assessReasoning(context: RenderedContext): ReplayabilityAssessment;
-    normalizeToolCalls(toolCalls?: OpenAI.ChatCompletionMessageToolCall[]): Array<{
-        id: string;
-        name: string;
-        arguments: string;
-    }>;
+    normalizeToolCalls(toolCalls?: OpenAI.ChatCompletionMessageToolCall[]): ToolCall[];
     rememberReplayFields(message: Pick<Message, "content" | "toolCalls">, fields: Record<string, unknown>): void;
     peekReplayFields(message: Pick<Message, "content" | "toolCalls">): Record<string, unknown> | undefined;
 }