@deepstrike/sdk 0.2.52 → 0.2.60

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;
 }