@deepstrike/sdk 0.2.52 → 0.2.61

package/dist/providers/openai.js

@@ -1,39 +1,12 @@
 import OpenAI from "openai";
+import { assistantReplayKey } from "../runtime/provider-replay.js";
 import { withServerRuntimeGuard } from "../runtime/server.js";
-import { CircuitBreaker, omitExtensionKeys, openAICachedPromptTokens, stablePromptCacheKey, ThinkingTagStreamExtractor } from "./base.js";
-import { OpenAIChatAdapter } from "./openai-chat.js";
-const OPENAI_POLICIES = {
-    "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-4o": { maxTurns: 25 },
-    "gpt-4o-mini": { maxTurns: 15 },
-    "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 },
-    "o1": { maxTurns: 50 },
-    "o1-mini": { maxTurns: 25 },
-    "o3": { maxTurns: 50 },
-    "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 || "{}" },
-    }));
-}
+import { CircuitBreaker, omitExtensionKeys, stablePromptCacheKey } from "./base.js";
+import { normalizeCanonicalAdapterInput, } from "./content-normalization.js";
+import { endpointProfiles } from "./endpoints.js";
+import { OpenAIChatAdapter, } from "./openai-chat.js";
+import { openAIChatDialects, } from "./openai-chat-dialects.js";
+import { circuitOpenError, classifyProviderError } from "./provider-error.js";
 export class OpenAIChatProvider {
     client;
     circuit;
@@ -41,302 +14,232 @@ export class OpenAIChatProvider {
     baseDelay;
     model;
     chat = new OpenAIChatAdapter();
-    // Accepts either the options object (`new OpenAIProvider({ apiKey, model, baseURL })`) or the legacy
-    // positional form (still used by the backend subclasses' `super(...)` calls).
-    constructor(apiKeyOrOptions, model = "gpt-4o", retry = { maxRetries: 3, baseDelay: 1000 }, baseURL = "https://api.openai.com/v1") {
-        const o = typeof apiKeyOrOptions === "string"
-            ? { apiKey: apiKeyOrOptions, model, retry, baseURL }
-            : { model: "gpt-4o", retry: { maxRetries: 3, baseDelay: 1000 }, baseURL: "https://api.openai.com/v1", ...apiKeyOrOptions };
-        this.model = o.model;
-        this.client = withServerRuntimeGuard(() => new OpenAI({ apiKey: o.apiKey, baseURL: o.baseURL }));
+    dialect;
+    replayStore = new Map();
+    resolvedRuntimePolicy;
+    resolvedRuntime;
+    constructor(options) {
+        const resolved = {
+            apiKey: options.apiKey,
+            model: options.model ?? "gpt-4o",
+            retry: options.retry ?? { maxRetries: 3, baseDelay: 1000 },
+            baseURL: options.baseURL ?? endpointProfiles["openai.chat"].baseURL,
+            runtimePolicy: options.runtimePolicy ?? {},
+            dialect: options.dialect ?? openAIChatDialects.openai,
+            authMode: options.authMode ?? "api_key",
+        };
+        this.model = resolved.model;
+        this.client = withServerRuntimeGuard(() => new OpenAI({
+            apiKey: resolved.apiKey,
+            baseURL: resolved.baseURL,
+            ...(resolved.authMode === "bearer" ? { defaultHeaders: { Authorization: `Bearer ${resolved.apiKey}` } } : {}),
+        }));
         this.circuit = new CircuitBreaker();
-        this.maxRetries = o.retry.maxRetries;
-        this.baseDelay = o.retry.baseDelay;
+        this.maxRetries = resolved.retry.maxRetries;
+        this.baseDelay = resolved.retry.baseDelay;
+        this.resolvedRuntimePolicy = resolved.runtimePolicy;
+        this.dialect = resolved.dialect;
     }
     runtimePolicy() {
-        return OPENAI_POLICIES[this.model] ?? {};
+        return this.resolvedRuntimePolicy;
     }
     descriptor() {
         return {
-            provider: "openai",
+            provider: this.dialect.providerId,
             protocol: "openai-chat",
             model: this.model,
-            reasoning: {
-                supported: true,
-                preserveAcrossToolTurns: false,
-            },
-            toolCalls: {
-                supported: true,
-                requiresStrictPairing: true,
-            },
+            reasoning: this.dialect.descriptor.reasoning,
+            toolCalls: { supported: true, requiresStrictPairing: true },
         };
     }
-    requireNonEmptyReasoningReplayForToolTurns(_extensions) {
-        return false;
-    }
-    degradeMissingReasoningReplay(extensions) {
-        return extensions?.degradeMissingReasoningReplay === true;
-    }
-    buildChatMessages(context, extensions) {
-        return this.chat.buildMessages(context, {
-            descriptor: this.descriptor(),
-            requireNonEmptyReasoningForToolCalls: this.requireNonEmptyReasoningReplayForToolTurns(extensions),
-            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 });
+    bindResolvedRuntime(resolved) {
+        if (resolved.identity.protocol !== "openai-chat"
+            || resolved.identity.providerId !== this.dialect.providerId
+            || resolved.identity.modelId !== this.model) {
+            throw new Error("OpenAIChatProvider received a mismatched resolved runtime");
         }
+        this.resolvedRuntime = resolved;
     }
-    /**
-     * 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, extensions) {
-        if (!this.requireNonEmptyReasoningReplayForToolTurns(extensions)) {
+        const prepared = this.dialect.prepareExtensions(extensions ?? {});
+        if (!this.dialect.requireReasoningReplay(prepared)) {
             return { ok: true, offendingCallIds: [] };
         }
-        return this.chat.assessReasoning(context);
+        const offendingCallIds = context.turns.flatMap(message => {
+            if (message.role !== "assistant" || !message.toolCalls?.length)
+                return [];
+            const replay = this.peekProviderReplay(message);
+            return typeof replay?.reasoning_content === "string" && replay.reasoning_content.trim()
+                ? []
+                : message.toolCalls.map(call => call.id);
+        });
+        return { ok: offendingCallIds.length === 0, offendingCallIds };
     }
     peekProviderReplay(message) {
-        const fields = this.chat.peekReplayFields(message);
-        if (!fields || !("reasoning_content" in fields || "reasoning_details" in fields))
+        const replay = this.replayStore.get(assistantReplayKey(message));
+        if (!replay || !("reasoning_content" in replay || "reasoning_details" in replay))
             return undefined;
-        return fields;
+        if (this.dialect.id === "qwen" && replay.reasoning_content !== undefined) {
+            return { protocol: "openai-chat", reasoning_content: String(replay.reasoning_content ?? "") };
+        }
+        return replay;
     }
     seedProviderReplay(message, replay) {
-        if (replay.reasoning_content !== undefined || replay.reasoning_details !== undefined) {
-            this.chat.rememberReplayFields(message, replay);
-        }
+        if (replay.protocol !== "openai-chat"
+            || (replay.reasoning_content === undefined && replay.reasoning_details === undefined))
+            return;
+        this.replayStore.set(assistantReplayKey(message), this.dialect.id === "qwen"
+            ? { protocol: "openai-chat", reasoning_content: replay.reasoning_content }
+            : replay);
+    }
+    rememberReplay(message, replay) {
+        if (replay)
+            this.replayStore.set(assistantReplayKey(message), replay);
+    }
+    adapterInput(context, tools, extensions) {
+        const endpoint = endpointProfiles[this.dialect.endpointId];
+        const resolved = this.resolvedRuntime ?? {
+            identity: {
+                providerId: this.dialect.providerId,
+                modelId: this.model,
+                endpointId: this.dialect.endpointId,
+                protocol: "openai-chat",
+            },
+            model: {
+                id: `${this.dialect.providerId}/${this.model}`,
+                providerId: this.dialect.providerId,
+                kind: "generation",
+                intrinsic: {},
+            },
+            endpoint,
+            adapter: this,
+            effectiveCapabilities: compatibilityCapabilities(),
+        };
+        return normalizeCanonicalAdapterInput({
+            context,
+            tools,
+            resolved,
+            extensions,
+            replayForMessage: message => this.peekProviderReplay(message),
+        });
     }
     async complete(context, tools, extensions) {
-        const prepared = this.prepareExtensions(extensions);
+        const provider = this.dialect.providerId;
         if (this.circuit.isOpen())
-            throw new Error("Circuit breaker open");
-        const msgs = this.buildChatMessages(context, prepared);
-        let lastErr;
-        for (let i = 0; i < this.maxRetries; i++) {
+            throw circuitOpenError(provider);
+        let input;
+        let plan;
+        try {
+            input = this.adapterInput(context, tools, extensions);
+            plan = this.chat.buildRequest(input, this.dialect);
+        }
+        catch (error) {
+            throw classifyProviderError(provider, error);
+        }
+        let lastError;
+        for (let attempt = 0; attempt < this.maxRetries; attempt++) {
             try {
-                const resp = await this.client.chat.completions.create({
-                    ...this.cacheKeyParams(context, tools),
-                    ...this.requestExtensions(prepared),
-                    ...this.requestBodyExtras(extensions),
-                    model: this.model,
-                    messages: msgs,
-                    ...((t => t ? { tools: t } : {})(this.assembleTools(tools, extensions))),
-                });
+                const response = await this.client.chat.completions.create(plan.params);
                 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.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 };
+                const decoded = this.chat.decodeComplete(response, { input }, this.dialect);
+                this.rememberReplay(decoded.message, decoded.replay);
+                return decoded.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(provider, lastError);
     }
     async *stream(context, tools, extensions, _state, signal) {
-        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({
-            ...this.cacheKeyParams(context, tools),
-            ...this.requestExtensions(prepared),
-            ...this.requestBodyExtras(extensions),
-            model: this.model,
-            messages: msgs,
-            ...((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;
-        let cacheReadTokens = 0;
-        // Phase 4: OpenAI signals an output-cap truncation via finish_reason="length", which arrives on
-        // a `choices` frame separate from the trailing `usage` frame — so capture it and attach it to the
-        // usage event the runner reads. The kernel treats "length" as a truncation (== Anthropic
-        // "max_tokens"); other reasons ("stop"/"tool_calls") pass through harmlessly.
-        let finishReason;
-        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;
-            if (choice.finish_reason)
-                finishReason = choice.finish_reason;
-            const delta = choice.delta;
-            if (!delta)
-                continue;
-            if (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) {
-                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 };
+        const provider = this.dialect.providerId;
+        try {
+            const input = this.adapterInput(context, tools, extensions);
+            const plan = this.chat.buildRequest(input, this.dialect);
+            const state = this.chat.createStreamState({ input }, this.dialect);
+            const stream = await this.client.chat.completions.create({
+                ...plan.params,
+                stream: true,
+                stream_options: { include_usage: true },
+            }, signal ? { signal } : undefined);
+            for await (const chunk of stream) {
+                const output = this.chat.pushStreamChunk(chunk, state);
+                if (output.replay) {
+                    this.rememberReplay({
+                        content: state.accumulatedContent,
+                        toolCalls: Object.values(state.toolCallBuffers).map(call => ({
+                            id: call.id,
+                            name: call.name,
+                            arguments: call.argsBuffer || "{}",
+                        })),
+                    }, output.replay);
                 }
+                for (const event of output.events)
+                    yield event;
             }
-            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") {
-                rememberStream();
-                yield* emitPendingToolCalls();
-            }
+            const final = this.chat.finishStream(state);
+            for (const event of final.events)
+                yield event;
+            this.rememberReplay({
+                content: state.accumulatedContent,
+                toolCalls: Object.values(state.toolCallBuffers).map(call => ({
+                    id: call.id,
+                    name: call.name,
+                    arguments: call.argsBuffer || "{}",
+                })),
+            }, final.replay);
         }
-        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 };
-                }
-            }
+        catch (error) {
+            throw classifyProviderError(provider, error);
         }
-        rememberStream();
-        yield* emitPendingToolCalls();
-        if (totalTokens > 0)
-            yield { type: "usage", totalTokens, inputTokens, outputTokens, ...(cacheReadTokens > 0 ? { cacheReadInputTokens: cacheReadTokens } : {}), ...(finishReason ? { stopReason: finishReason } : {}) };
     }
-    /**
-     * 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.
-     */
-    promptCacheKey(context, tools) {
-        return stablePromptCacheKey([context.systemText, tools.map(t => t.name).join(",")]);
+    // White-box test seams. Runtime request shaping uses the dialect through the adapter.
+    prepareExtensions(extensions) {
+        return this.dialect.prepareExtensions(extensions ?? {});
+    }
+    requestBodyExtras(extensions) {
+        const prepared = this.dialect.prepareExtensions(extensions ?? {});
+        return Object.fromEntries(Object.entries(prepared).filter(([key]) => key === "extra_body" || key === "reasoning_effort" || key === "reasoning_split"));
+    }
+    serverTools(extensions) {
+        return this.dialect.serverTools?.(extensions ?? {}) ?? [];
     }
     requestExtensions(extensions) {
-        return omitExtensionKeys(extensions, ["model", "messages", "tools", "stream", "stream_options", "__deepstrikeThinkingEnabled"]);
+        const prepared = this.dialect.prepareExtensions(extensions ?? {});
+        return omitExtensionKeys(prepared, [
+            "model", "messages", "tools", "stream", "stream_options", "extra_body",
+            "reasoning_effort", "reasoning_split", "__deepstrikeThinkingEnabled",
+        ]);
     }
+    promptCacheKey(context, tools) {
+        return stablePromptCacheKey([context.systemText, tools.map(tool => tool.name).join(",")]);
+    }
+    rememberCompleteReplay(_content, _toolCalls, _reasoning) { }
+    rememberStreamReplay(_content, _toolCalls, _reasoning) { }
+}
+function compatibilityCapabilities() {
+    const unknown = { state: "unknown", evidence: [] };
+    const unsupported = { state: "unsupported", evidence: ["protocol"] };
+    return {
+        inputModalities: { text: unknown, image: unknown, audio: unknown, video: unsupported, file: unsupported },
+        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: unsupported,
+            audioUrl: unsupported,
+            audioBase64: unknown,
+        },
+    };
 }
 export { OpenAIChatProvider as OpenAIProvider };

package/dist/providers/protocol-adapter.d.ts

@@ -0,0 +1,39 @@
+import type { Message, ProviderReplay, ProviderRunState, ProviderUsage, StreamEvent } from "../types.js";
+import type { CanonicalAdapterInput } from "./content-normalization.js";
+import type { GenerationProtocol, ProtocolRuntimeCapabilities } from "./protocol-capabilities.js";
+export { GEMINI_PROTOCOL_CAPABILITIES, OLLAMA_PROTOCOL_CAPABILITIES, } from "./protocol-capabilities.js";
+export type CanonicalStopReason = "end_turn" | "tool_use" | "max_tokens" | "stop_sequence" | "content_filter" | "other";
+export interface AdapterOutput {
+    events: StreamEvent[];
+    replay?: ProviderReplay;
+    runStatePatch?: Partial<ProviderRunState>;
+}
+export interface AdapterDecodeInput {
+    input: CanonicalAdapterInput;
+}
+export interface AdapterStreamInput {
+    input: CanonicalAdapterInput;
+}
+export interface ProtocolAdapter<TRequest, TCompleteResponse, TStreamChunk, TStreamState, TStreamFinal = undefined> {
+    readonly protocol: GenerationProtocol;
+    readonly protocolCapabilities: ProtocolRuntimeCapabilities;
+    buildRequest(input: CanonicalAdapterInput): TRequest;
+    decodeComplete(raw: TCompleteResponse, input: AdapterDecodeInput): {
+        message: Message;
+        replay?: ProviderReplay;
+    };
+    createStreamState(input: AdapterStreamInput): TStreamState;
+    pushStreamChunk(chunk: TStreamChunk, state: TStreamState): AdapterOutput;
+    finishStream(state: TStreamState, final: TStreamFinal): AdapterOutput | Promise<AdapterOutput>;
+    normalizeUsage(raw: unknown): ProviderUsage | undefined;
+    normalizeStopReason(raw: string | undefined): CanonicalStopReason | undefined;
+}
+export declare class ProtocolResponseError extends Error {
+    readonly protocol: GenerationProtocol;
+    readonly providerCode?: string;
+    readonly retryable?: boolean;
+    constructor(protocol: GenerationProtocol, message: string, options?: {
+        providerCode?: string;
+        retryable?: boolean;
+    });
+}

package/dist/providers/protocol-adapter.js

@@ -0,0 +1,13 @@
+export { GEMINI_PROTOCOL_CAPABILITIES, OLLAMA_PROTOCOL_CAPABILITIES, } from "./protocol-capabilities.js";
+export class ProtocolResponseError extends Error {
+    protocol;
+    providerCode;
+    retryable;
+    constructor(protocol, message, options = {}) {
+        super(options.providerCode ? message : `${protocol} protocol response error: ${message}`);
+        this.name = "ProtocolResponseError";
+        this.protocol = protocol;
+        this.providerCode = options.providerCode;
+        this.retryable = options.retryable;
+    }
+}

package/dist/providers/protocol-capabilities.d.ts

@@ -0,0 +1,34 @@
+export type InputModality = "text" | "image" | "audio" | "video" | "file";
+export type OutputModality = "text" | "image" | "audio" | "embedding";
+export type GenerationProtocol = "anthropic-messages" | "openai-chat" | "openai-responses" | "gemini" | "ollama-chat";
+export interface ProtocolRuntimeCapabilities {
+    acceptedInputModalities: readonly InputModality[];
+    emittedOutputModalities: readonly OutputModality[];
+    tools: boolean;
+    parallelToolCalls?: boolean;
+    structuredOutput?: boolean;
+    reasoningReplay: "none" | "optional" | "required";
+    promptCaching?: boolean;
+    mediaForms: {
+        imageUrl?: boolean;
+        imageBase64?: boolean;
+        fileId?: boolean;
+        audioUrl?: boolean;
+        audioBase64?: boolean;
+    };
+}
+export interface ProtocolRuntimeCapabilityOverrides {
+    acceptedInputModalities?: readonly InputModality[];
+    emittedOutputModalities?: readonly OutputModality[];
+    tools?: boolean;
+    parallelToolCalls?: boolean;
+    structuredOutput?: boolean;
+    reasoningReplay?: ProtocolRuntimeCapabilities["reasoningReplay"];
+    promptCaching?: boolean;
+    mediaForms?: Partial<ProtocolRuntimeCapabilities["mediaForms"]>;
+}
+export declare const ANTHROPIC_PROTOCOL_CAPABILITIES: ProtocolRuntimeCapabilities;
+export declare const GEMINI_PROTOCOL_CAPABILITIES: ProtocolRuntimeCapabilities;
+export declare const OLLAMA_PROTOCOL_CAPABILITIES: ProtocolRuntimeCapabilities;
+export declare const OPENAI_RESPONSES_PROTOCOL_CAPABILITIES: ProtocolRuntimeCapabilities;
+export declare const OPENAI_CHAT_PROTOCOL_CAPABILITIES: ProtocolRuntimeCapabilities;