@deepstrike/sdk 0.2.52 → 0.2.61

package/dist/providers/openai-responses-adapter.js

@@ -0,0 +1,343 @@
+import { normalizeCanonicalContext } from "./content-normalization.js";
+import { normalizeToolCall, UnsupportedModalityError } from "./base.js";
+import { normalizeOpenAIUsage } from "./usage-normalizer.js";
+import { ProtocolResponseError, } from "./protocol-adapter.js";
+import { OPENAI_RESPONSES_PROTOCOL_CAPABILITIES } from "./protocol-capabilities.js";
+function numberField(raw, field) {
+    const value = raw[field];
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        throw new ProtocolResponseError("openai-responses", `usage.${field} must be a non-negative safe integer`);
+    }
+    return value;
+}
+function cacheReadTokens(usage) {
+    const inputDetails = usage.input_tokens_details;
+    if (inputDetails === undefined)
+        return undefined;
+    if (!inputDetails || typeof inputDetails !== "object" || Array.isArray(inputDetails)) {
+        throw new ProtocolResponseError("openai-responses", "usage.input_tokens_details must be an object");
+    }
+    return numberField(inputDetails, "cached_tokens");
+}
+function toolResultOutput(result) {
+    const output = [];
+    for (const block of result.blocks) {
+        if (block.type === "text") {
+            output.push({ type: "input_text", text: block.text });
+        }
+        else if (block.type === "image") {
+            if (block.source.kind === "base64") {
+                output.push({
+                    type: "input_image",
+                    image_url: `data:${block.mediaType ?? "image/png"};base64,${block.source.data}`,
+                });
+            }
+            else if (block.source.kind === "url") {
+                output.push({ type: "input_image", image_url: block.source.url });
+            }
+            else {
+                output.push({ type: "input_text", text: "[image]" });
+            }
+        }
+        else {
+            output.push({ type: "input_text", text: `[${block.type}]` });
+        }
+    }
+    return result.contentForm !== "blocks" && output.length === 1 && output[0].type === "input_text"
+        ? String(output[0].text ?? "")
+        : output;
+}
+function messageContent(message) {
+    const content = [];
+    for (const block of message.blocks) {
+        if (block.type === "tool_result")
+            continue;
+        if (block.type === "text") {
+            content.push({ type: "input_text", text: block.text });
+        }
+        else if (block.type === "image") {
+            const imageUrl = block.source.kind === "url"
+                ? block.source.url
+                : block.source.kind === "base64"
+                    ? `data:${block.mediaType ?? "image/png"};base64,${block.source.data}`
+                    : undefined;
+            if (imageUrl) {
+                content.push({
+                    type: "input_image",
+                    detail: String(block.providerOptions?.openai_detail ?? "auto"),
+                    image_url: imageUrl,
+                });
+            }
+        }
+        else if (block.type === "file") {
+            if (block.source.kind === "fileId") {
+                content.push({ type: "input_file", file_id: block.source.id });
+            }
+            else {
+                throw new UnsupportedModalityError("file source", "openai-responses");
+            }
+        }
+        else if (block.type === "audio") {
+            throw new UnsupportedModalityError("audio", "openai-responses");
+        }
+    }
+    return message.contentForm !== "blocks" && content.length === 1 && content[0].type === "input_text"
+        ? String(content[0].text ?? "")
+        : content;
+}
+function hasMessageContent(message) {
+    return message.blocks.some(block => block.type !== "tool_result" && (block.type !== "text" || block.text.length > 0));
+}
+function appendMessage(input, message) {
+    if (message.role === "assistant" && message.toolCalls?.length) {
+        if (hasMessageContent(message)) {
+            input.push({ role: "assistant", content: messageContent(message) });
+        }
+        for (const call of message.toolCalls) {
+            input.push({
+                type: "function_call",
+                call_id: call.id,
+                name: call.name,
+                arguments: call.arguments,
+            });
+        }
+        return;
+    }
+    if (message.role === "tool") {
+        for (const block of message.blocks) {
+            if (block.type !== "tool_result")
+                continue;
+            input.push({
+                type: "function_call_output",
+                call_id: block.callId,
+                output: toolResultOutput(block),
+            });
+        }
+        return;
+    }
+    input.push({ role: message.role, content: messageContent(message) });
+}
+function canonicalInputItems(context, state) {
+    const input = [];
+    const turns = state?.previousResponseId
+        ? context.turns.slice(state.coveredMessageCount)
+        : context.turns;
+    for (const message of turns)
+        appendMessage(input, message);
+    if (context.stateTurn)
+        appendMessage(input, context.stateTurn);
+    return input;
+}
+function requestExtensions(extensions) {
+    const blocked = new Set([
+        "model", "input", "instructions", "tools", "stream", "previous_response_id",
+        "web_search", "builtin_tools", "__deepstrikeThinkingEnabled", "degradeMissingReasoningReplay",
+    ]);
+    return Object.fromEntries(Object.entries(extensions).filter(([key]) => !blocked.has(key)));
+}
+function builtinTools(extensions) {
+    const output = [];
+    if (extensions.web_search) {
+        output.push(typeof extensions.web_search === "object"
+            ? { type: "web_search", ...extensions.web_search }
+            : { type: "web_search" });
+    }
+    if (Array.isArray(extensions.builtin_tools)) {
+        output.push(...extensions.builtin_tools);
+    }
+    return output;
+}
+function 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 call = normalizeToolCall(String(item.call_id ?? item.id ?? ""), String(item.name ?? ""), item.arguments ?? "{}");
+            if (call)
+                toolCalls.push(call);
+        }
+    }
+    return { content, toolCalls };
+}
+export class OpenAIResponsesAdapter {
+    protocol = "openai-responses";
+    protocolCapabilities = OPENAI_RESPONSES_PROTOCOL_CAPABILITIES;
+    buildRequest(input, state) {
+        const functionTools = this.buildTools(input.tools);
+        const tools = [...functionTools, ...builtinTools(input.extensions)];
+        return {
+            params: {
+                ...requestExtensions(input.extensions),
+                model: input.resolved.identity.modelId,
+                input: canonicalInputItems(input.context, state),
+                ...(input.context.systemText ? { instructions: input.context.systemText } : {}),
+                ...(state?.previousResponseId ? { previous_response_id: state.previousResponseId } : {}),
+                ...(tools.length ? { tools } : {}),
+            },
+        };
+    }
+    decodeComplete(raw, _input) {
+        const decoded = decodeOutput(raw.output ?? []);
+        const usage = raw.usage && typeof raw.usage === "object"
+            ? raw.usage
+            : undefined;
+        if (usage)
+            this.normalizeUsage(usage);
+        const tokenCount = usage
+            ? numberField(usage, "output_tokens") ?? numberField(usage, "total_tokens")
+            : undefined;
+        return {
+            message: {
+                role: "assistant",
+                content: decoded.content,
+                toolCalls: decoded.toolCalls,
+                ...(tokenCount !== undefined ? { tokenCount } : {}),
+            },
+        };
+    }
+    createStreamState(input, _state) {
+        return { input: input.input, functionCalls: new Map() };
+    }
+    pushStreamChunk(chunk, state) {
+        const events = [];
+        let runStatePatch;
+        if (chunk.type === "response.output_text.delta") {
+            events.push({ type: "text_delta", delta: chunk.delta });
+        }
+        else if (chunk.type === "response.output_item.added" && chunk.item.type === "function_call") {
+            state.functionCalls.set(chunk.output_index, {
+                id: chunk.item.call_id,
+                name: chunk.item.name,
+                argsBuffer: chunk.item.arguments ?? "",
+            });
+        }
+        else if (chunk.type === "response.function_call_arguments.delta") {
+            const call = state.functionCalls.get(chunk.output_index);
+            if (call)
+                call.argsBuffer += chunk.delta;
+        }
+        else if (chunk.type === "response.function_call_arguments.done") {
+            const call = state.functionCalls.get(chunk.output_index);
+            if (call)
+                call.argsBuffer = chunk.arguments;
+        }
+        else if (chunk.type === "response.output_item.done" && chunk.item.type === "function_call") {
+            const call = state.functionCalls.get(chunk.output_index) ?? {
+                id: chunk.item.call_id,
+                name: chunk.item.name,
+                argsBuffer: chunk.item.arguments ?? "{}",
+            };
+            let args = {};
+            try {
+                args = JSON.parse(call.argsBuffer || "{}");
+            }
+            catch {
+                args = {};
+            }
+            events.push({ type: "tool_call", id: call.id, name: call.name, arguments: args });
+        }
+        else if (chunk.type === "response.completed" || chunk.type === "response.incomplete") {
+            const response = chunk.response;
+            runStatePatch = {
+                previousResponseId: String(response.id),
+                coveredMessageCount: state.input.context.turns.length + 1,
+            };
+            const usage = response.usage;
+            if (usage) {
+                const totalTokens = numberField(usage, "total_tokens");
+                const providerUsage = this.normalizeUsage(usage);
+                const cacheReadInputTokens = cacheReadTokens(usage);
+                const inputTokens = numberField(usage, "input_tokens");
+                const outputTokens = numberField(usage, "output_tokens");
+                const rawStopReason = typeof response.incomplete_details?.reason === "string"
+                    ? response.incomplete_details.reason
+                    : undefined;
+                const stopReason = this.normalizeStopReason(rawStopReason);
+                if (totalTokens && totalTokens > 0) {
+                    events.push({
+                        type: "usage",
+                        totalTokens,
+                        ...(inputTokens ? { inputTokens } : {}),
+                        ...(outputTokens ? { outputTokens } : {}),
+                        ...(cacheReadInputTokens ? { cacheReadInputTokens } : {}),
+                        ...(providerUsage?.cacheTelemetryStatus
+                            ? { cacheTelemetryStatus: providerUsage.cacheTelemetryStatus }
+                            : {}),
+                        ...(providerUsage?.cacheTelemetrySource
+                            ? { cacheTelemetrySource: providerUsage.cacheTelemetrySource }
+                            : {}),
+                        ...(providerUsage && (inputTokens || outputTokens) ? { providerUsage } : {}),
+                        ...(stopReason ? { stopReason } : {}),
+                        ...(rawStopReason ? { rawStopReason } : {}),
+                    });
+                }
+            }
+        }
+        return { events, ...(runStatePatch ? { runStatePatch } : {}) };
+    }
+    finishStream(_state) {
+        return { events: [] };
+    }
+    normalizeUsage(raw) {
+        if (raw === undefined || raw === null)
+            return undefined;
+        if (typeof raw !== "object" || Array.isArray(raw)) {
+            throw new ProtocolResponseError("openai-responses", "usage must be an object");
+        }
+        const usage = raw;
+        const inputTokens = numberField(usage, "input_tokens");
+        const outputTokens = numberField(usage, "output_tokens");
+        numberField(usage, "total_tokens");
+        const outputDetails = usage.output_tokens_details;
+        if (outputDetails !== undefined && (!outputDetails || typeof outputDetails !== "object" || Array.isArray(outputDetails))) {
+            throw new ProtocolResponseError("openai-responses", "usage.output_tokens_details must be an object");
+        }
+        cacheReadTokens(usage);
+        if (outputDetails)
+            numberField(outputDetails, "reasoning_tokens");
+        if (inputTokens === undefined && outputTokens === undefined)
+            return undefined;
+        return normalizeOpenAIUsage(usage);
+    }
+    normalizeStopReason(raw) {
+        if (raw === undefined)
+            return undefined;
+        if (raw === "max_output_tokens")
+            return "max_tokens";
+        if (raw === "content_filter")
+            return "content_filter";
+        return "other";
+    }
+    // Published compatibility helpers retained while internally routing through canonical input.
+    buildTools(tools) {
+        return tools.map(tool => ({
+            type: "function",
+            name: tool.name,
+            description: tool.description,
+            parameters: JSON.parse(tool.parameters),
+        }));
+    }
+    buildInstructions(context) {
+        return context.systemText || undefined;
+    }
+    buildInput(context, state) {
+        return canonicalInputItems(normalizeCanonicalContext(context), state);
+    }
+    decodeOutput(output) {
+        return decodeOutput(output);
+    }
+    builtinTools(extensions) {
+        return builtinTools(extensions ?? {});
+    }
+    requestExtensions(extensions) {
+        return requestExtensions(extensions ?? {});
+    }
+}

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

@@ -1,29 +1,11 @@
 import OpenAI from "openai";
-import type { Message, ProviderRunState, RenderedContext, StreamEvent, ToolSchema, LLMProvider } from "../types.js";
+import type { LLMProvider, Message, PromptMeasurement, ProviderRunState, RenderedContext, RuntimePolicy, StreamEvent, ToolSchema } from "../types.js";
 import { CircuitBreaker } from "./base.js";
-export interface OpenAIResponsesRunState extends ProviderRunState {
-    previousResponseId?: string;
-    coveredMessageCount: number;
-}
-export declare class OpenAIResponsesAdapter {
-    buildTools(tools: ToolSchema[]): {
-        type: "function";
-        name: string;
-        description: string;
-        parameters: any;
-    }[];
-    buildInstructions(context: RenderedContext): string | undefined;
-    buildInput(context: RenderedContext, state?: OpenAIResponsesRunState): Array<Record<string, unknown>>;
-    decodeOutput(output: Array<Record<string, unknown>>): {
-        content: string;
-        toolCalls: Array<{
-            id: string;
-            name: string;
-            arguments: string;
-        }>;
-    };
-    private buildMessageContent;
-}
+import { type CanonicalAdapterInput } from "./content-normalization.js";
+import { OpenAIResponsesAdapter, type OpenAIResponsesRunState } from "./openai-responses-adapter.js";
+export { OpenAIResponsesAdapter } from "./openai-responses-adapter.js";
+export type { OpenAIResponsesRequestPlan, OpenAIResponsesRunState, OpenAIResponsesStreamState, } from "./openai-responses-adapter.js";
+type ResolvedOpenAIResponsesRuntime = CanonicalAdapterInput["resolved"];
 export declare class OpenAIResponsesProvider implements LLMProvider {
     protected readonly model: string;
     protected client: OpenAI;
@@ -31,20 +13,24 @@ export declare class OpenAIResponsesProvider implements LLMProvider {
     protected maxRetries: number;
     protected baseDelay: number;
     protected readonly responses: OpenAIResponsesAdapter;
+    private readonly resolvedRuntimePolicy;
+    private readonly directNativeTokenCounting;
+    private resolvedRuntime?;
     constructor(apiKey: string, model?: string, retry?: {
         maxRetries: number;
         baseDelay: number;
-    }, baseURL?: string);
-    runtimePolicy(): import("../types.js").RuntimePolicy;
+    }, baseURL?: string, runtimePolicy?: RuntimePolicy, authMode?: "api_key" | "bearer");
+    runtimePolicy(): RuntimePolicy;
+    bindResolvedRuntime(resolved: ResolvedOpenAIResponsesRuntime): void;
     createRunState(): OpenAIResponsesRunState;
+    private adapterInput;
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
-    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState): AsyncIterable<StreamEvent>;
-    private requestExtensions;
-    /** 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. */
+    /** 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. */
+    countTokens(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState): Promise<PromptMeasurement>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState, signal?: AbortSignal): AsyncIterable<StreamEvent>;
     private builtinTools;
-    /** Function tools + built-in server tools merged into the wire tools[] (undefined when empty). */
-    private allTools;
+    private requestExtensions;
     private asRunState;
 }