@deepstrike/sdk 0.2.52 → 0.2.60

package/dist/providers/openai-chat.js

@@ -1,12 +1,404 @@
 import { assistantReplayKey } from "../runtime/provider-replay.js";
-import { normalizeToolCall, toOpenAIMessageParams } from "./base.js";
+import { openAICachedPromptTokens, stablePromptCacheKey, ThinkingTagStreamExtractor, } from "./base.js";
+import { normalizeCanonicalContext, projectToolOutputToText } from "./content-normalization.js";
+import { normalizeToolCall } from "./base.js";
 import { DEGRADED_REASONING_PLACEHOLDER, assessReasoningReplay, validateOpenAIChatReplay, } from "./replay-validator.js";
+import { ProtocolResponseError, } from "./protocol-adapter.js";
+import { OPENAI_CHAT_PROTOCOL_CAPABILITIES } from "./protocol-capabilities.js";
+import { openAIChatDialects, replayForTurn, } from "./openai-chat-dialects.js";
+const COMPATIBILITY_REPLAY = new WeakMap();
+function compatibilityReplayStore(adapter) {
+    let store = COMPATIBILITY_REPLAY.get(adapter);
+    if (!store) {
+        store = new Map();
+        COMPATIBILITY_REPLAY.set(adapter, store);
+    }
+    return store;
+}
+function wireReplay(replay) {
+    if (!replay)
+        return undefined;
+    const fields = {};
+    if (typeof replay.reasoning_content === "string")
+        fields.reasoning_content = replay.reasoning_content;
+    if (replay.reasoning_details !== undefined)
+        fields.reasoning_details = replay.reasoning_details;
+    return Object.keys(fields).length ? fields : undefined;
+}
+function blockContent(message) {
+    const content = [];
+    for (const block of message.blocks) {
+        if (block.type === "tool_result")
+            continue;
+        if (block.type === "text")
+            content.push({ type: "text", text: block.text });
+        else if (block.type === "image") {
+            const url = block.source.kind === "url"
+                ? block.source.url
+                : block.source.kind === "base64"
+                    ? `data:${block.mediaType ?? "image/png"};base64,${block.source.data}`
+                    : undefined;
+            if (url)
+                content.push({
+                    type: "image_url",
+                    image_url: {
+                        url,
+                        ...(block.providerOptions?.openai_detail
+                            ? { detail: block.providerOptions.openai_detail }
+                            : {}),
+                    },
+                });
+        }
+        else if (block.type === "audio" && block.source.kind === "base64") {
+            const subtype = (block.mediaType ?? "audio/wav").split("/")[1] ?? "wav";
+            content.push({
+                type: "input_audio",
+                input_audio: {
+                    data: block.source.data,
+                    format: subtype === "mpeg" ? "mp3" : subtype,
+                },
+            });
+        }
+    }
+    return message.contentForm !== "blocks" && content.length === 1 && content[0].type === "text"
+        ? String(content[0].text ?? "")
+        : content;
+}
+function validateCanonicalReplay(input, dialect, prepared) {
+    let pending;
+    let completed = new Set();
+    const assertComplete = () => {
+        const missing = pending ? [...pending].filter(id => !completed.has(id)) : [];
+        if (missing.length)
+            throw new Error(`OpenAI-compatible replay has assistant tool_calls with no tool result for ${missing.join(", ")}`);
+    };
+    for (const message of input.context.turns) {
+        if (message.role === "assistant") {
+            assertComplete();
+            pending = message.toolCalls?.length ? new Set(message.toolCalls.map(call => call.id)) : undefined;
+            completed = new Set();
+        }
+        else if (message.role === "tool") {
+            for (const block of message.blocks) {
+                if (block.type !== "tool_result")
+                    continue;
+                if (!pending?.has(block.callId))
+                    throw new Error(`OpenAI-compatible replay has orphan tool result ${block.callId}`);
+                if (completed.has(block.callId))
+                    throw new Error(`OpenAI-compatible replay has duplicate tool result ${block.callId}`);
+                completed.add(block.callId);
+            }
+        }
+        else {
+            assertComplete();
+            pending = undefined;
+            completed = new Set();
+        }
+    }
+    assertComplete();
+    if (dialect.requireReasoningReplay(prepared) && prepared.degradeMissingReasoningReplay !== true) {
+        const missing = input.context.turns.flatMap(message => message.role === "assistant" && message.toolCalls?.length
+            && !(typeof message.providerReplay?.reasoning_content === "string" && message.providerReplay.reasoning_content.trim())
+            ? message.toolCalls.map(call => call.id)
+            : []);
+        if (missing.length) {
+            throw new Error(`${dialect.providerId}/${input.resolved.identity.modelId} replay requires non-empty reasoning_content for assistant tool call turn ${missing.join(", ")}`);
+        }
+    }
+}
+function messages(input, dialect, prepared) {
+    validateCanonicalReplay(input, dialect, prepared);
+    const output = [];
+    if (input.context.systemText)
+        output.push({ role: "system", content: input.context.systemText });
+    const turns = input.context.stateTurn
+        ? [...input.context.turns, input.context.stateTurn]
+        : input.context.turns;
+    for (const message of turns) {
+        if (message.role === "tool") {
+            for (const block of message.blocks) {
+                if (block.type !== "tool_result")
+                    continue;
+                output.push({
+                    role: "tool",
+                    tool_call_id: block.callId,
+                    content: projectToolOutputToText(block.blocks),
+                });
+            }
+            continue;
+        }
+        const next = { role: message.role, content: blockContent(message) };
+        if (message.role === "assistant" && message.toolCalls?.length) {
+            next.tool_calls = message.toolCalls.map(call => ({
+                id: call.id,
+                type: "function",
+                function: { name: call.name, arguments: call.arguments },
+            }));
+            const replay = wireReplay(message.providerReplay)
+                ?? (dialect.requireReasoningReplay(prepared) && prepared.degradeMissingReasoningReplay === true
+                    ? { reasoning_content: DEGRADED_REASONING_PLACEHOLDER }
+                    : undefined);
+            if (replay)
+                Object.assign(next, replay);
+        }
+        output.push(next);
+    }
+    return output;
+}
+function nativeToolCalls(buffers) {
+    return Object.values(buffers).map(call => ({
+        id: call.id,
+        type: "function",
+        function: { name: call.name, arguments: call.argsBuffer || "{}" },
+    }));
+}
+function finalToolCalls(state) {
+    return Object.values(state.toolCallBuffers).map(call => ({
+        id: call.id,
+        name: call.name,
+        arguments: call.argsBuffer || "{}",
+    }));
+}
+function streamReplay(state) {
+    return replayForTurn(state.dialect, "stream", state.input.resolved.identity.modelId, state.accumulatedContent, finalToolCalls(state), {
+        reasoningContent: state.accumulatedReasoning,
+        reasoningDetails: state.accumulatedReasoningDetails,
+        nativeToolCalls: nativeToolCalls(state.toolCallBuffers),
+    });
+}
+function pendingToolEvents(state) {
+    const events = [];
+    for (const [rawIndex, call] of Object.entries(state.toolCallBuffers)) {
+        const index = Number(rawIndex);
+        if (state.emittedToolCallIndexes.has(index))
+            continue;
+        let args = {};
+        try {
+            args = JSON.parse(call.argsBuffer || "{}");
+        }
+        catch {
+            args = {};
+        }
+        state.emittedToolCallIndexes.add(index);
+        events.push({ type: "tool_call", id: call.id, name: call.name, arguments: args });
+    }
+    return events;
+}
+function numberField(raw, key) {
+    const value = raw[key];
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+        throw new ProtocolResponseError("openai-chat", `usage.${key} must be a non-negative finite number`);
+    }
+    return value;
+}
 export class OpenAIChatAdapter {
-    replayFields = new Map();
+    // Responses are decoded from the official Chat Completions message/chunk shapes. The adapter
+    // preserves pre-A-09 raw finish reasons; canonical stop mapping is exposed separately.
+    // Source: https://platform.openai.com/docs/api-reference/chat/create
+    protocol = "openai-chat";
+    protocolCapabilities = OPENAI_CHAT_PROTOCOL_CAPABILITIES;
+    buildRequest(input, dialect = openAIChatDialects.openai) {
+        const prepared = dialect.prepareExtensions(input.extensions);
+        const tools = [
+            ...this.buildTools(input.tools),
+            ...(dialect.serverTools?.(input.extensions) ?? []),
+        ];
+        const cache = dialect.cacheKey === "openai"
+            ? { prompt_cache_key: stablePromptCacheKey([
+                    input.context.systemText,
+                    input.tools.map(tool => tool.name).join(","),
+                ]) }
+            : {};
+        return {
+            dialect,
+            preparedExtensions: prepared,
+            params: {
+                ...cache,
+                ...Object.fromEntries(Object.entries(prepared).filter(([key]) => key !== "__deepstrikeThinkingEnabled" && key !== "degradeMissingReasoningReplay")),
+                model: input.resolved.identity.modelId,
+                messages: messages(input, dialect, prepared),
+                ...(tools.length ? { tools } : {}),
+            },
+        };
+    }
+    decodeComplete(raw, input, dialect = openAIChatDialects.openai) {
+        const choice = raw.choices?.[0]?.message ?? {};
+        const nativeCalls = choice.tool_calls ?? [];
+        const toolCalls = this.normalizeToolCalls(nativeCalls);
+        const content = choice.content ?? "";
+        const usage = raw.usage;
+        if (usage)
+            this.normalizeUsage(usage);
+        const message = {
+            role: "assistant",
+            content,
+            ...(usage ? {
+                tokenCount: numberField(usage, "completion_tokens") ?? numberField(usage, "total_tokens"),
+            } : {}),
+            toolCalls,
+        };
+        const replay = replayForTurn(dialect, "complete", input.input.resolved.identity.modelId, content, toolCalls, {
+            reasoningContent: typeof choice.reasoning_content === "string" ? choice.reasoning_content : "",
+            reasoningDetails: choice.reasoning_details,
+            nativeToolCalls: nativeCalls,
+        });
+        return { message, ...(replay ? { replay } : {}) };
+    }
+    createStreamState(input, dialect = openAIChatDialects.openai) {
+        return {
+            input: input.input,
+            dialect,
+            toolCallBuffers: {},
+            emittedToolCallIndexes: new Set(),
+            extractor: new ThinkingTagStreamExtractor(),
+            accumulatedReasoning: "",
+            accumulatedContent: "",
+            totalTokens: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheReadTokens: 0,
+        };
+    }
+    pushStreamChunk(chunk, state) {
+        if (chunk.usage) {
+            state.totalTokens = chunk.usage.total_tokens;
+            state.inputTokens = chunk.usage.prompt_tokens ?? 0;
+            state.outputTokens = chunk.usage.completion_tokens ?? 0;
+            state.cacheReadTokens = openAICachedPromptTokens(chunk.usage);
+            state.rawUsage = chunk.usage;
+            return { events: [] };
+        }
+        const choice = chunk.choices?.[0];
+        if (!choice)
+            return { events: [] };
+        if (choice.finish_reason)
+            state.finishReason = choice.finish_reason;
+        const delta = choice.delta;
+        if (!delta)
+            return { events: [] };
+        const events = [];
+        if (delta.reasoning_content) {
+            state.accumulatedReasoning += String(delta.reasoning_content);
+            if (state.dialect.exposeReasoning(state.input.extensions)) {
+                events.push({ type: "thinking_delta", delta: String(delta.reasoning_content) });
+            }
+        }
+        if (delta.reasoning_details !== undefined && delta.reasoning_details !== null) {
+            state.accumulatedReasoningDetails = delta.reasoning_details;
+        }
+        if (delta.content) {
+            if (state.dialect.inlineThinkingTags) {
+                for (const part of state.extractor.feed(String(delta.content))) {
+                    if (part.type === "thinking") {
+                        state.accumulatedReasoning += part.content;
+                        events.push({ type: "thinking_delta", delta: part.content });
+                    }
+                    else {
+                        state.accumulatedContent += part.content;
+                        events.push({ type: "text_delta", delta: part.content });
+                    }
+                }
+            }
+            else {
+                state.accumulatedContent += String(delta.content);
+                events.push({ type: "text_delta", delta: String(delta.content) });
+            }
+        }
+        for (const call of delta.tool_calls ?? []) {
+            const index = call.index;
+            if (!state.toolCallBuffers[index]) {
+                state.toolCallBuffers[index] = { id: call.id ?? "", name: "", argsBuffer: "" };
+            }
+            if (call.function?.name)
+                state.toolCallBuffers[index].name += call.function.name;
+            state.toolCallBuffers[index].argsBuffer += call.function?.arguments ?? "";
+        }
+        if (choice.finish_reason === "tool_calls") {
+            events.push(...pendingToolEvents(state));
+            const replay = streamReplay(state);
+            return { events, ...(replay ? { replay } : {}) };
+        }
+        return { events };
+    }
+    finishStream(state) {
+        const events = [];
+        if (state.dialect.inlineThinkingTags) {
+            for (const part of state.extractor.flush()) {
+                if (part.type === "thinking") {
+                    state.accumulatedReasoning += part.content;
+                    events.push({ type: "thinking_delta", delta: part.content });
+                }
+                else {
+                    state.accumulatedContent += part.content;
+                    events.push({ type: "text_delta", delta: part.content });
+                }
+            }
+        }
+        events.push(...pendingToolEvents(state));
+        if (state.totalTokens > 0) {
+            const providerUsage = this.normalizeUsage(state.rawUsage);
+            const stopReason = this.normalizeStopReason(state.finishReason);
+            events.push({
+                type: "usage",
+                totalTokens: state.totalTokens,
+                inputTokens: state.inputTokens,
+                outputTokens: state.outputTokens,
+                ...(state.cacheReadTokens > 0 ? { cacheReadInputTokens: state.cacheReadTokens } : {}),
+                ...(stopReason ? { stopReason } : {}),
+                ...(state.finishReason ? { rawStopReason: state.finishReason } : {}),
+                ...(providerUsage ? { providerUsage } : {}),
+            });
+        }
+        const replay = streamReplay(state);
+        return { events, ...(replay ? { replay } : {}) };
+    }
+    normalizeUsage(raw) {
+        if (raw === undefined || raw === null)
+            return undefined;
+        if (typeof raw !== "object" || Array.isArray(raw)) {
+            throw new ProtocolResponseError("openai-chat", "usage must be an object");
+        }
+        const usage = raw;
+        const inputTokens = numberField(usage, "prompt_tokens");
+        const outputTokens = numberField(usage, "completion_tokens");
+        numberField(usage, "total_tokens");
+        if (inputTokens === undefined && outputTokens === undefined)
+            return undefined;
+        const cacheReadInputTokens = openAICachedPromptTokens(usage);
+        const details = usage.completion_tokens_details;
+        const reasoningTokens = details && typeof details === "object"
+            ? numberField(details, "reasoning_tokens")
+            : undefined;
+        return {
+            inputTokens: inputTokens ?? 0,
+            outputTokens: outputTokens ?? 0,
+            ...(cacheReadInputTokens > 0 ? { cacheReadInputTokens } : {}),
+            ...(reasoningTokens !== undefined ? { reasoningTokens } : {}),
+        };
+    }
+    normalizeStopReason(raw) {
+        if (raw === undefined)
+            return undefined;
+        if (raw === "length")
+            return "max_tokens";
+        if (raw === "stop")
+            return "end_turn";
+        if (raw === "tool_calls" || raw === "function_call")
+            return "tool_use";
+        if (raw === "content_filter")
+            return "content_filter";
+        return "other";
+    }
     buildTools(tools) {
-        return tools.map(t => ({
+        return tools.map(tool => ({
             type: "function",
-            function: { name: t.name, description: t.description, parameters: JSON.parse(t.parameters) },
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: JSON.parse(tool.parameters),
+            },
         }));
     }
     buildMessages(context, options = {}) {
@@ -14,64 +406,39 @@ export class OpenAIChatAdapter {
             descriptor: options.descriptor,
             requireNonEmptyReasoningForToolCalls: options.requireNonEmptyReasoningForToolCalls,
             degradeMissingReasoning: options.degradeMissingReasoning,
-            replayForAssistant: message => this.replayFields.get(assistantReplayKey(message)),
+            replayForAssistant: message => compatibilityReplayStore(this).get(assistantReplayKey(message)),
         });
-        const degradeReasoning = Boolean(options.requireNonEmptyReasoningForToolCalls && options.degradeMissingReasoning);
-        // toOpenAIMessageParams emits [system?, ...history, stateTurn?] — the State
-        // turn is APPENDED last, so the cursor only skips the system message to align
-        // with context.turns (history) when writing reasoning-replay fields.
-        const serialized = toOpenAIMessageParams(context);
-        let cursor = context.systemText ? 1 : 0;
-        for (const source of context.turns) {
-            if (source.role === "tool") {
-                cursor += (source.contentParts ?? []).filter(p => p.type === "tool_result").length;
-                continue;
-            }
-            if (source.role === "assistant") {
-                const replay = this.replayFields.get(assistantReplayKey(source));
-                let wireReplay = openAIChatWireReplayFields(replay);
-                if (!wireReplay && degradeReasoning && source.toolCalls?.length) {
-                    // Reasoning-requiring provider, no stored reasoning for this tool-call
-                    // turn, caller opted into degradation: inject a placeholder so the
-                    // wire message stays well-formed instead of failing the whole request.
-                    wireReplay = { reasoning_content: DEGRADED_REASONING_PLACEHOLDER };
-                }
-                if (wireReplay)
-                    serialized[cursor] = { ...serialized[cursor], ...wireReplay };
-            }
-            cursor += 1;
-        }
-        return serialized;
+        const canonical = normalizeCanonicalContext(context, message => compatibilityReplayStore(this).get(assistantReplayKey(message)));
+        const dialect = {
+            ...openAIChatDialects.openai,
+            descriptor: { reasoning: options.descriptor?.reasoning ?? openAIChatDialects.openai.descriptor.reasoning },
+            requireReasoningReplay: () => options.requireNonEmptyReasoningForToolCalls === true,
+        };
+        return messages({
+            context: canonical,
+            tools: [],
+            resolved: { identity: { modelId: options.descriptor?.model ?? "compat" } },
+            extensions: options.degradeMissingReasoning ? { degradeMissingReasoningReplay: true } : {},
+        }, dialect, options.degradeMissingReasoning ? { degradeMissingReasoningReplay: true } : {});
     }
-    /**
-     * 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) {
         return assessReasoningReplay(context.turns, {
-            replayForAssistant: message => this.replayFields.get(assistantReplayKey(message)),
+            replayForAssistant: message => compatibilityReplayStore(this).get(assistantReplayKey(message)),
         });
     }
     normalizeToolCalls(toolCalls = []) {
         return toolCalls
-            .filter((tc) => tc.type === "function")
-            .map(tc => normalizeToolCall(tc.id, tc.function.name, tc.function.arguments))
-            .filter(Boolean);
+            .filter((call) => call.type === "function")
+            .map(call => normalizeToolCall(call.id, call.function.name, call.function.arguments))
+            .filter((call) => call !== null);
     }
     rememberReplayFields(message, fields) {
-        this.replayFields.set(assistantReplayKey(message), fields);
+        compatibilityReplayStore(this).set(assistantReplayKey(message), {
+            protocol: "openai-chat",
+            ...fields,
+        });
     }
     peekReplayFields(message) {
-        return this.replayFields.get(assistantReplayKey(message));
+        return compatibilityReplayStore(this).get(assistantReplayKey(message));
     }
 }
-function openAIChatWireReplayFields(replay) {
-    if (!replay)
-        return undefined;
-    const fields = {};
-    if (typeof replay.reasoning_content === "string")
-        fields.reasoning_content = replay.reasoning_content;
-    if (replay.reasoning_details !== undefined)
-        fields.reasoning_details = replay.reasoning_details;
-    return Object.keys(fields).length ? fields : undefined;
-}

package/dist/providers/openai-responses-adapter.d.ts

@@ -0,0 +1,42 @@
+import type { Message, ProviderUsage, RenderedContext, ToolCall, ToolSchema } from "../types.js";
+import type { CanonicalAdapterInput } from "./content-normalization.js";
+import { type AdapterDecodeInput, type AdapterOutput, type AdapterStreamInput, type CanonicalStopReason, type ProtocolAdapter } from "./protocol-adapter.js";
+export interface OpenAIResponsesRunState {
+    previousResponseId?: string;
+    coveredMessageCount: number;
+    [key: string]: unknown;
+}
+export interface OpenAIResponsesRequestPlan {
+    params: Record<string, unknown>;
+}
+export type OpenAIResponsesStreamChunk = Record<string, any>;
+export interface OpenAIResponsesStreamState {
+    readonly input: CanonicalAdapterInput;
+    readonly functionCalls: Map<number, {
+        id: string;
+        name: string;
+        argsBuffer: string;
+    }>;
+}
+export declare class OpenAIResponsesAdapter implements ProtocolAdapter<OpenAIResponsesRequestPlan, Record<string, any>, OpenAIResponsesStreamChunk, OpenAIResponsesStreamState, undefined> {
+    readonly protocol: "openai-responses";
+    readonly protocolCapabilities: import("./protocol-capabilities.js").ProtocolRuntimeCapabilities;
+    buildRequest(input: CanonicalAdapterInput, state?: OpenAIResponsesRunState): OpenAIResponsesRequestPlan;
+    decodeComplete(raw: Record<string, any>, _input: AdapterDecodeInput): {
+        message: Message;
+    };
+    createStreamState(input: AdapterStreamInput, _state?: OpenAIResponsesRunState): OpenAIResponsesStreamState;
+    pushStreamChunk(chunk: OpenAIResponsesStreamChunk, state: OpenAIResponsesStreamState): AdapterOutput;
+    finishStream(_state: OpenAIResponsesStreamState): AdapterOutput;
+    normalizeUsage(raw: unknown): ProviderUsage | undefined;
+    normalizeStopReason(raw: string | undefined): CanonicalStopReason | undefined;
+    buildTools(tools: readonly ToolSchema[]): Array<Record<string, unknown>>;
+    buildInstructions(context: RenderedContext): string | undefined;
+    buildInput(context: RenderedContext, state?: OpenAIResponsesRunState): Array<Record<string, unknown>>;
+    decodeOutput(output: Array<Record<string, unknown>>): {
+        content: string;
+        toolCalls: ToolCall[];
+    };
+    builtinTools(extensions?: Record<string, unknown>): Record<string, unknown>[];
+    requestExtensions(extensions?: Record<string, unknown>): Record<string, unknown>;
+}