@deepstrike/sdk 0.1.7 → 0.1.9

package/dist/providers/kimi.d.ts

@@ -0,0 +1,7 @@
+import { OpenAIChatProvider } from "./openai.js";
+export declare class KimiProvider extends OpenAIChatProvider {
+    constructor(apiKey: string, model?: "kimi-k2.5" | "kimi-k2.6", retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    }, baseURL?: string);
+}

package/dist/providers/kimi.js

@@ -0,0 +1,8 @@
+import { OpenAIChatProvider } from "./openai.js";
+import { endpointProfiles } from "./profiles.js";
+const MOONSHOT_BASE = endpointProfiles["kimi.openai"].baseURL;
+export class KimiProvider extends OpenAIChatProvider {
+    constructor(apiKey, model = "kimi-k2.6", retry, baseURL = MOONSHOT_BASE) {
+        super(apiKey, model, retry, baseURL);
+    }
+}

package/dist/providers/minimax.d.ts

@@ -0,0 +1,7 @@
+import { AnthropicProvider } from "./anthropic.js";
+export declare class MiniMaxProvider extends AnthropicProvider {
+    constructor(apiKey: string, model?: "MiniMax-M2.7" | "MiniMax-M2.5", retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    }, baseURL?: string);
+}

package/dist/providers/minimax.js

@@ -0,0 +1,10 @@
+import { AnthropicProvider } from "./anthropic.js";
+import { endpointProfiles } from "./profiles.js";
+export class MiniMaxProvider extends AnthropicProvider {
+    constructor(apiKey, model = "MiniMax-M2.7", retry, baseURL = endpointProfiles["minimax.anthropic"].baseURL) {
+        super(apiKey, model, retry, {
+            baseURL,
+            authMode: "api-key",
+        });
+    }
+}

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

@@ -0,0 +1,27 @@
+import type OpenAI from "openai";
+import type { Message, ToolSchema } from "../types.js";
+export declare class OpenAIChatAdapter {
+    private replayFields;
+    buildTools(tools: ToolSchema[]): {
+        type: "function";
+        function: {
+            name: string;
+            description: string;
+            parameters: any;
+        };
+    }[];
+    buildMessages(messages: Message[]): OpenAI.ChatCompletionMessageParam[];
+    normalizeToolCalls(toolCalls?: Array<{
+        id: string;
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>): Array<{
+        id: string;
+        name: string;
+        arguments: string;
+    }>;
+    rememberReplayFields(message: Pick<Message, "content" | "toolCalls">, fields: Record<string, unknown>): void;
+    private assistantReplayKey;
+}

package/dist/providers/openai-chat.js

@@ -0,0 +1,41 @@
+import { normalizeToolCall, toOpenAIMessageParams } from "./base.js";
+export class OpenAIChatAdapter {
+    replayFields = new Map();
+    buildTools(tools) {
+        return tools.map(t => ({
+            type: "function",
+            function: { name: t.name, description: t.description, parameters: JSON.parse(t.parameters) },
+        }));
+    }
+    buildMessages(messages) {
+        const serialized = toOpenAIMessageParams(messages);
+        let cursor = 0;
+        for (const source of messages) {
+            if (source.role === "tool") {
+                cursor += (source.contentParts ?? []).filter(p => p.type === "tool_result").length;
+                continue;
+            }
+            if (source.role === "assistant") {
+                const replay = this.replayFields.get(this.assistantReplayKey(source));
+                if (replay)
+                    serialized[cursor] = { ...serialized[cursor], ...replay };
+            }
+            cursor += 1;
+        }
+        return serialized;
+    }
+    normalizeToolCalls(toolCalls = []) {
+        return toolCalls
+            .map(tc => normalizeToolCall(tc.id, tc.function.name, tc.function.arguments))
+            .filter(Boolean);
+    }
+    rememberReplayFields(message, fields) {
+        this.replayFields.set(this.assistantReplayKey(message), fields);
+    }
+    assistantReplayKey(message) {
+        return JSON.stringify({
+            content: message.content,
+            toolCalls: message.toolCalls ?? [],
+        });
+    }
+}

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

@@ -0,0 +1,42 @@
+import OpenAI from "openai";
+import type { Message, ProviderRunState, StreamEvent, ToolSchema, LLMProvider } 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(messages: Message[]): string | undefined;
+    buildInput(messages: Message[], state?: OpenAIResponsesRunState): Array<Record<string, unknown>>;
+    decodeOutput(output: Array<Record<string, unknown>>): {
+        content: string;
+        toolCalls: Array<{
+            id: string;
+            name: string;
+            arguments: string;
+        }>;
+    };
+    private buildMessageContent;
+}
+export declare class OpenAIResponsesProvider implements LLMProvider {
+    protected readonly model: string;
+    protected client: OpenAI;
+    protected circuit: CircuitBreaker;
+    protected maxRetries: number;
+    protected baseDelay: number;
+    protected readonly responses: OpenAIResponsesAdapter;
+    constructor(apiKey: string, model?: string, retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    }, baseURL?: string);
+    createRunState(): OpenAIResponsesRunState;
+    complete(messages: Message[], tools: ToolSchema[]): Promise<Message>;
+    stream(messages: Message[], tools: ToolSchema[], _extensions?: Record<string, unknown>, state?: ProviderRunState): AsyncIterable<StreamEvent>;
+    private asRunState;
+}

package/dist/providers/openai-responses.js

@@ -0,0 +1,220 @@
+import OpenAI from "openai";
+import { withServerRuntimeGuard } from "../runtime/server.js";
+import { CircuitBreaker } from "./base.js";
+import { normalizeToolCall } from "./base.js";
+export class OpenAIResponsesAdapter {
+    buildTools(tools) {
+        return tools.map(t => ({
+            type: "function",
+            name: t.name,
+            description: t.description,
+            parameters: JSON.parse(t.parameters),
+        }));
+    }
+    buildInstructions(messages) {
+        const instructions = messages
+            .filter(message => message.role === "system")
+            .map(message => message.content)
+            .filter(Boolean);
+        return instructions.length ? instructions.join("\n\n") : undefined;
+    }
+    buildInput(messages, state) {
+        const input = [];
+        const uncoveredMessages = state?.previousResponseId
+            ? messages.slice(state.coveredMessageCount)
+            : messages;
+        for (const message of uncoveredMessages) {
+            if (message.role === "system") {
+                continue;
+            }
+            if (message.role === "assistant" && message.toolCalls?.length) {
+                if (message.content || message.contentParts?.length) {
+                    input.push({
+                        role: "assistant",
+                        content: this.buildMessageContent(message),
+                    });
+                }
+                for (const tc of message.toolCalls) {
+                    input.push({
+                        type: "function_call",
+                        call_id: tc.id,
+                        name: tc.name,
+                        arguments: tc.arguments,
+                    });
+                }
+                continue;
+            }
+            if (message.role === "tool") {
+                for (const part of message.contentParts ?? []) {
+                    if (part.type !== "tool_result")
+                        continue;
+                    input.push({
+                        type: "function_call_output",
+                        call_id: part.callId,
+                        output: part.output,
+                    });
+                }
+                continue;
+            }
+            input.push({
+                role: message.role,
+                content: this.buildMessageContent(message),
+            });
+        }
+        return input;
+    }
+    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 toolCall = normalizeToolCall(String(item.call_id ?? item.id ?? ""), String(item.name ?? ""), item.arguments ?? "{}");
+                if (toolCall)
+                    toolCalls.push(toolCall);
+            }
+        }
+        return { content, toolCalls };
+    }
+    buildMessageContent(message) {
+        if (!message.contentParts?.length)
+            return message.content;
+        const content = [];
+        for (const part of message.contentParts) {
+            if (part.type === "text") {
+                content.push({ type: "input_text", text: part.text });
+                continue;
+            }
+            if (part.type === "image") {
+                const imageUrl = part.url ?? (part.data && part.mediaType
+                    ? `data:${part.mediaType};base64,${part.data}`
+                    : undefined);
+                if (imageUrl)
+                    content.push({
+                        type: "input_image",
+                        detail: part.detail ?? "auto",
+                        image_url: imageUrl,
+                    });
+            }
+        }
+        return content;
+    }
+}
+export class OpenAIResponsesProvider {
+    model;
+    client;
+    circuit;
+    maxRetries;
+    baseDelay;
+    responses = new OpenAIResponsesAdapter();
+    constructor(apiKey, model = "gpt-4.1", retry = { maxRetries: 3, baseDelay: 1000 }, baseURL = "https://api.openai.com/v1") {
+        this.model = model;
+        this.client = withServerRuntimeGuard(() => new OpenAI({ apiKey, baseURL }));
+        this.circuit = new CircuitBreaker();
+        this.maxRetries = retry.maxRetries;
+        this.baseDelay = retry.baseDelay;
+    }
+    createRunState() {
+        return { coveredMessageCount: 0 };
+    }
+    async complete(messages, tools) {
+        if (this.circuit.isOpen())
+            throw new Error("Circuit breaker open");
+        let lastErr;
+        for (let i = 0; i < this.maxRetries; i++) {
+            try {
+                const instructions = this.responses.buildInstructions(messages);
+                const resp = await this.client.responses.create({
+                    model: this.model,
+                    input: this.responses.buildInput(messages),
+                    ...(instructions ? { instructions } : {}),
+                    ...(tools.length ? { tools: this.responses.buildTools(tools) } : {}),
+                });
+                this.circuit.recordSuccess();
+                const decoded = this.responses.decodeOutput(resp.output);
+                return {
+                    role: "assistant",
+                    content: decoded.content,
+                    toolCalls: decoded.toolCalls,
+                    tokenCount: resp.usage?.total_tokens,
+                };
+            }
+            catch (err) {
+                lastErr = err;
+                this.circuit.recordFailure();
+                if (i < this.maxRetries - 1)
+                    await new Promise(r => setTimeout(r, this.baseDelay * 2 ** i));
+            }
+        }
+        throw lastErr;
+    }
+    async *stream(messages, tools, _extensions, state) {
+        const runState = this.asRunState(state);
+        const functionCalls = new Map();
+        const instructions = this.responses.buildInstructions(messages);
+        const stream = await this.client.responses.create({
+            model: this.model,
+            input: this.responses.buildInput(messages, runState),
+            ...(instructions ? { instructions } : {}),
+            ...(runState.previousResponseId ? { previous_response_id: runState.previousResponseId } : {}),
+            ...(tools.length ? { tools: this.responses.buildTools(tools) } : {}),
+            stream: true,
+        });
+        for await (const evt of stream) {
+            if (evt.type === "response.output_text.delta") {
+                yield { type: "text_delta", delta: evt.delta };
+            }
+            else if (evt.type === "response.output_item.added" && evt.item.type === "function_call") {
+                functionCalls.set(evt.output_index, {
+                    id: evt.item.call_id,
+                    name: evt.item.name,
+                    argsBuf: evt.item.arguments ?? "",
+                });
+            }
+            else if (evt.type === "response.function_call_arguments.delta") {
+                const call = functionCalls.get(evt.output_index);
+                if (call)
+                    call.argsBuf += evt.delta;
+            }
+            else if (evt.type === "response.function_call_arguments.done") {
+                const call = functionCalls.get(evt.output_index);
+                if (call)
+                    call.argsBuf = evt.arguments;
+            }
+            else if (evt.type === "response.output_item.done" && evt.item.type === "function_call") {
+                const call = functionCalls.get(evt.output_index) ?? {
+                    id: evt.item.call_id,
+                    name: evt.item.name,
+                    argsBuf: evt.item.arguments ?? "{}",
+                };
+                let args = {};
+                try {
+                    args = JSON.parse(call.argsBuf || "{}");
+                }
+                catch {
+                    args = {};
+                }
+                yield { type: "tool_call", id: call.id, name: call.name, arguments: args };
+            }
+            else if (evt.type === "response.completed") {
+                runState.previousResponseId = evt.response.id;
+                runState.coveredMessageCount = messages.length + 1;
+                if (evt.response.usage?.total_tokens) {
+                    yield { type: "usage", totalTokens: evt.response.usage.total_tokens };
+                }
+            }
+        }
+    }
+    asRunState(state) {
+        if (!state)
+            return this.createRunState();
+        if (typeof state.coveredMessageCount !== "number")
+            state.coveredMessageCount = 0;
+        return state;
+    }
+}

package/dist/providers/openai.d.ts

@@ -1,51 +1,19 @@
 import OpenAI from "openai";
 import type { Message, ToolSchema, StreamEvent, LLMProvider } from "../types.js";
 import { CircuitBreaker } from "./base.js";
-export declare class OpenAIProvider implements LLMProvider {
+import { OpenAIChatAdapter } from "./openai-chat.js";
+export declare class OpenAIChatProvider implements LLMProvider {
     protected readonly model: string;
     protected client: OpenAI;
     protected circuit: CircuitBreaker;
     protected maxRetries: number;
     protected baseDelay: number;
+    protected readonly chat: OpenAIChatAdapter;
     constructor(apiKey: string, model?: string, retry?: {
         maxRetries: number;
         baseDelay: number;
     }, baseURL?: string);
-    protected buildTools(tools: ToolSchema[]): {
-        type: "function";
-        function: {
-            name: string;
-            description: string;
-            parameters: any;
-        };
-    }[];
     complete(messages: Message[], tools: ToolSchema[]): Promise<Message>;
     stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
 }
-export declare class QwenProvider extends OpenAIProvider {
-    constructor(apiKey: string, model?: string, retry?: {
-        maxRetries: number;
-        baseDelay: number;
-    });
-    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
-}
-export declare class DeepSeekProvider extends OpenAIProvider {
-    constructor(apiKey: string, model?: string, retry?: {
-        maxRetries: number;
-        baseDelay: number;
-    });
-    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
-}
-export declare class MiniMaxProvider extends OpenAIProvider {
-    constructor(apiKey: string, model?: string, retry?: {
-        maxRetries: number;
-        baseDelay: number;
-    });
-    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
-}
-export declare class KimiProvider extends OpenAIProvider {
-    constructor(apiKey: string, model?: string, retry?: {
-        maxRetries: number;
-        baseDelay: number;
-    });
-}
+export { OpenAIChatProvider as OpenAIProvider };

package/dist/providers/openai.js

@@ -1,39 +1,36 @@
 import OpenAI from "openai";
-import { CircuitBreaker, normalizeToolCall, toOpenAIContent } from "./base.js";
-export class OpenAIProvider {
+import { withServerRuntimeGuard } from "../runtime/server.js";
+import { CircuitBreaker } from "./base.js";
+import { OpenAIChatAdapter } from "./openai-chat.js";
+export class OpenAIChatProvider {
     model;
     client;
     circuit;
     maxRetries;
     baseDelay;
+    chat = new OpenAIChatAdapter();
     constructor(apiKey, model = "gpt-4o", retry = { maxRetries: 3, baseDelay: 1000 }, baseURL = "https://api.openai.com/v1") {
         this.model = model;
-        this.client = new OpenAI({ apiKey, baseURL });
+        this.client = withServerRuntimeGuard(() => new OpenAI({ apiKey, baseURL }));
         this.circuit = new CircuitBreaker();
         this.maxRetries = retry.maxRetries;
         this.baseDelay = retry.baseDelay;
     }
-    buildTools(tools) {
-        return tools.map(t => ({
-            type: "function",
-            function: { name: t.name, description: t.description, parameters: JSON.parse(t.parameters) },
-        }));
-    }
     async complete(messages, tools) {
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");
-        const msgs = messages.map(m => ({ role: m.role, content: toOpenAIContent(m) }));
+        const msgs = this.chat.buildMessages(messages);
         let lastErr;
         for (let i = 0; i < this.maxRetries; i++) {
             try {
                 const resp = await this.client.chat.completions.create({
                     model: this.model,
                     messages: msgs,
-                    ...(tools.length ? { tools: this.buildTools(tools) } : {}),
+                    ...(tools.length ? { tools: this.chat.buildTools(tools) } : {}),
                 });
                 this.circuit.recordSuccess();
                 const choice = resp.choices[0].message;
-                const toolCalls = (choice.tool_calls ?? []).map(tc => normalizeToolCall(tc.id, tc.function.name, tc.function.arguments)).filter(Boolean);
+                const toolCalls = this.chat.normalizeToolCalls(choice.tool_calls ?? []);
                 return { role: "assistant", content: choice.content ?? "", tokenCount: resp.usage?.total_tokens, toolCalls };
             }
             catch (err) {
@@ -46,12 +43,12 @@ export class OpenAIProvider {
         throw lastErr;
     }
     async *stream(messages, tools, extensions) {
-        const msgs = messages.map(m => ({ role: m.role, content: toOpenAIContent(m) }));
+        const msgs = this.chat.buildMessages(messages);
         const toolCallBufs = {};
         const stream = await this.client.chat.completions.create({
             model: this.model,
             messages: msgs,
-            ...(tools.length ? { tools: this.buildTools(tools) } : {}),
+            ...(tools.length ? { tools: this.chat.buildTools(tools) } : {}),
             stream: true,
             stream_options: { include_usage: true },
         });
@@ -92,110 +89,4 @@ export class OpenAIProvider {
             yield { type: "usage", totalTokens };
     }
 }
-const DASHSCOPE_BASE = "https://dashscope.aliyuncs.com/compatible-mode/v1";
-const DEEPSEEK_BASE = "https://api.deepseek.com/v1";
-const MINIMAX_BASE = "https://api.minimax.chat/v1";
-const MOONSHOT_BASE = "https://api.moonshot.cn/v1";
-const DEEPSEEK_REASONERS = new Set(["deepseek-reasoner", "deepseek-r1"]);
-const MINIMAX_REASONERS = new Set(["MiniMax-M1", "minimax-m1"]);
-export class QwenProvider extends OpenAIProvider {
-    constructor(apiKey, model = "qwen-max", retry) {
-        super(apiKey, model, retry, DASHSCOPE_BASE);
-    }
-    async *stream(messages, tools, extensions) {
-        const enableThinking = Boolean(extensions?.enableThinking);
-        const thinkingBudget = extensions?.thinkingBudget;
-        const msgs = messages.map(m => ({ role: m.role, content: toOpenAIContent(m) }));
-        const toolCallBufs = {};
-        const stream = await this.client.chat.completions.create({
-            model: this.model,
-            messages: msgs,
-            ...(tools.length ? { tools: this.buildTools(tools) } : {}),
-            stream: true,
-            ...(enableThinking ? { extra_body: { enable_thinking: true, ...(thinkingBudget ? { thinking_budget: thinkingBudget } : {}) } } : {}),
-        });
-        for await (const chunk of stream) {
-            const choice = chunk.choices[0];
-            if (!choice)
-                continue;
-            const delta = choice.delta;
-            if (delta.reasoning_content)
-                yield { type: "thinking_delta", delta: delta.reasoning_content };
-            if (delta.content)
-                yield { type: "text_delta", delta: delta.content };
-            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") {
-                for (const tb of Object.values(toolCallBufs)) {
-                    let args = {};
-                    try {
-                        args = JSON.parse(tb.argsBuf || "{}");
-                    }
-                    catch {
-                        args = {};
-                    }
-                    yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
-                }
-            }
-        }
-    }
-}
-export class DeepSeekProvider extends OpenAIProvider {
-    constructor(apiKey, model = "deepseek-chat", retry) {
-        super(apiKey, model, retry, DEEPSEEK_BASE);
-    }
-    async *stream(messages, tools, extensions) {
-        const exposeReasoning = extensions?.exposeReasoning ?? false;
-        const msgs = messages.map(m => ({ role: m.role, content: toOpenAIContent(m) }));
-        const isReasoner = DEEPSEEK_REASONERS.has(this.model);
-        const stream = await this.client.chat.completions.create({
-            model: this.model,
-            messages: msgs,
-            ...(!isReasoner && tools.length ? { tools: this.buildTools(tools) } : {}),
-            stream: true,
-        });
-        for await (const chunk of stream) {
-            const delta = chunk.choices[0]?.delta;
-            if (exposeReasoning && delta.reasoning_content) {
-                yield { type: "thinking_delta", delta: delta.reasoning_content };
-            }
-            if (delta.content)
-                yield { type: "text_delta", delta: delta.content };
-        }
-    }
-}
-export class MiniMaxProvider extends OpenAIProvider {
-    constructor(apiKey, model = "MiniMax-Text-01", retry) {
-        super(apiKey, model, retry, MINIMAX_BASE);
-    }
-    async *stream(messages, tools, extensions) {
-        const exposeReasoning = extensions?.exposeReasoning ?? false;
-        const msgs = messages.map(m => ({ role: m.role, content: toOpenAIContent(m) }));
-        const isReasoner = MINIMAX_REASONERS.has(this.model);
-        const stream = await this.client.chat.completions.create({
-            model: this.model,
-            messages: msgs,
-            ...(!isReasoner && tools.length ? { tools: this.buildTools(tools) } : {}),
-            stream: true,
-        });
-        for await (const chunk of stream) {
-            const delta = chunk.choices[0]?.delta;
-            if (exposeReasoning && delta.reasoning_content) {
-                yield { type: "thinking_delta", delta: delta.reasoning_content };
-            }
-            if (delta.content)
-                yield { type: "text_delta", delta: delta.content };
-        }
-    }
-}
-export class KimiProvider extends OpenAIProvider {
-    constructor(apiKey, model = "moonshot-v1-8k", retry) {
-        super(apiKey, model, retry, MOONSHOT_BASE);
-    }
-}
+export { OpenAIChatProvider as OpenAIProvider };