@deepstrike/sdk 0.1.7 → 0.1.9

package/dist/providers/profiles.d.ts

@@ -0,0 +1,342 @@
+export type ProviderId = "openai" | "minimax" | "deepseek" | "kimi" | "qwen" | "gemini";
+export type EndpointProtocol = "anthropic-messages" | "openai-chat" | "openai-responses" | "gemini";
+export interface EndpointProfile {
+    id: string;
+    providerId: ProviderId;
+    protocol: EndpointProtocol;
+    baseURL: string;
+}
+export interface ModelProfile {
+    id: string;
+    providerId: ProviderId;
+    defaultEndpointId: string;
+    contextWindow?: number;
+    modalities: {
+        input: Array<"text" | "image" | "audio">;
+        output: Array<"text">;
+    };
+    tools: {
+        supported: boolean;
+    };
+    reasoning: {
+        supported: boolean;
+        preserveAcrossToolTurns: boolean;
+    };
+}
+export declare const endpointProfiles: {
+    readonly "openai.chat": {
+        readonly id: "openai.chat";
+        readonly providerId: "openai";
+        readonly protocol: "openai-chat";
+        readonly baseURL: "https://api.openai.com/v1";
+    };
+    readonly "openai.responses": {
+        readonly id: "openai.responses";
+        readonly providerId: "openai";
+        readonly protocol: "openai-responses";
+        readonly baseURL: "https://api.openai.com/v1";
+    };
+    readonly "minimax.anthropic": {
+        readonly id: "minimax.anthropic";
+        readonly providerId: "minimax";
+        readonly protocol: "anthropic-messages";
+        readonly baseURL: "https://api.minimaxi.com/anthropic";
+    };
+    readonly "deepseek.openai": {
+        readonly id: "deepseek.openai";
+        readonly providerId: "deepseek";
+        readonly protocol: "openai-chat";
+        readonly baseURL: "https://api.deepseek.com";
+    };
+    readonly "kimi.openai": {
+        readonly id: "kimi.openai";
+        readonly providerId: "kimi";
+        readonly protocol: "openai-chat";
+        readonly baseURL: "https://api.moonshot.cn/v1";
+    };
+    readonly "qwen.dashscope": {
+        readonly id: "qwen.dashscope";
+        readonly providerId: "qwen";
+        readonly protocol: "openai-chat";
+        readonly baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1";
+    };
+    readonly "gemini.google": {
+        readonly id: "gemini.google";
+        readonly providerId: "gemini";
+        readonly protocol: "gemini";
+        readonly baseURL: "https://generativelanguage.googleapis.com";
+    };
+};
+export declare const modelProfiles: {
+    readonly "openai/gpt-4o": {
+        readonly id: "openai/gpt-4o";
+        readonly providerId: "openai";
+        readonly defaultEndpointId: "openai.chat";
+        readonly contextWindow: 128000;
+        readonly modalities: {
+            readonly input: ["text", "image"];
+            readonly output: ["text"];
+        };
+        readonly tools: {
+            readonly supported: true;
+        };
+        readonly reasoning: {
+            readonly supported: false;
+            readonly preserveAcrossToolTurns: false;
+        };
+    };
+    readonly "openai/gpt-4o-mini": {
+        readonly id: "openai/gpt-4o-mini";
+        readonly providerId: "openai";
+        readonly defaultEndpointId: "openai.chat";
+        readonly contextWindow: 128000;
+        readonly modalities: {
+            readonly input: ["text", "image"];
+            readonly output: ["text"];
+        };
+        readonly tools: {
+            readonly supported: true;
+        };
+        readonly reasoning: {
+            readonly supported: false;
+            readonly preserveAcrossToolTurns: false;
+        };
+    };
+    readonly "openai/gpt-5": {
+        readonly id: "openai/gpt-5";
+        readonly providerId: "openai";
+        readonly defaultEndpointId: "openai.responses";
+        readonly modalities: {
+            readonly input: ["text", "image"];
+            readonly output: ["text"];
+        };
+        readonly tools: {
+            readonly supported: true;
+        };
+        readonly reasoning: {
+            readonly supported: true;
+            readonly preserveAcrossToolTurns: true;
+        };
+    };
+    readonly "openai/gpt-5-mini": {
+        readonly id: "openai/gpt-5-mini";
+        readonly providerId: "openai";
+        readonly defaultEndpointId: "openai.responses";
+        readonly modalities: {
+            readonly input: ["text", "image"];
+            readonly output: ["text"];
+        };
+        readonly tools: {
+            readonly supported: true;
+        };
+        readonly reasoning: {
+            readonly supported: true;
+            readonly preserveAcrossToolTurns: true;
+        };
+    };
+    readonly "minimax/MiniMax-M2.7": {
+        readonly id: "minimax/MiniMax-M2.7";
+        readonly providerId: "minimax";
+        readonly defaultEndpointId: "minimax.anthropic";
+        readonly contextWindow: 204800;
+        readonly modalities: {
+            readonly input: ["text"];
+            readonly output: ["text"];
+        };
+        readonly tools: {
+            readonly supported: true;
+        };
+        readonly reasoning: {
+            readonly supported: true;
+            readonly preserveAcrossToolTurns: true;
+        };
+    };
+    readonly "minimax/MiniMax-M2.5": {
+        readonly id: "minimax/MiniMax-M2.5";
+        readonly providerId: "minimax";
+        readonly defaultEndpointId: "minimax.anthropic";
+        readonly contextWindow: 204800;
+        readonly modalities: {
+            readonly input: ["text"];
+            readonly output: ["text"];
+        };
+        readonly tools: {
+            readonly supported: true;
+        };
+        readonly reasoning: {
+            readonly supported: true;
+            readonly preserveAcrossToolTurns: true;
+        };
+    };
+    readonly "deepseek/deepseek-v4-flash": {
+        readonly id: "deepseek/deepseek-v4-flash";
+        readonly providerId: "deepseek";
+        readonly defaultEndpointId: "deepseek.openai";
+        readonly contextWindow: 1000000;
+        readonly modalities: {
+            readonly input: ["text"];
+            readonly output: ["text"];
+        };
+        readonly tools: {
+            readonly supported: true;
+        };
+        readonly reasoning: {
+            readonly supported: true;
+            readonly preserveAcrossToolTurns: true;
+        };
+    };
+    readonly "deepseek/deepseek-v4-pro": {
+        readonly id: "deepseek/deepseek-v4-pro";
+        readonly providerId: "deepseek";
+        readonly defaultEndpointId: "deepseek.openai";
+        readonly contextWindow: 1000000;
+        readonly modalities: {
+            readonly input: ["text"];
+            readonly output: ["text"];
+        };
+        readonly tools: {
+            readonly supported: true;
+        };
+        readonly reasoning: {
+            readonly supported: true;
+            readonly preserveAcrossToolTurns: true;
+        };
+    };
+    readonly "kimi/kimi-k2.5": {
+        readonly id: "kimi/kimi-k2.5";
+        readonly providerId: "kimi";
+        readonly defaultEndpointId: "kimi.openai";
+        readonly contextWindow: 256000;
+        readonly modalities: {
+            readonly input: ["text", "image"];
+            readonly output: ["text"];
+        };
+        readonly tools: {
+            readonly supported: true;
+        };
+        readonly reasoning: {
+            readonly supported: true;
+            readonly preserveAcrossToolTurns: false;
+        };
+    };
+    readonly "kimi/kimi-k2.6": {
+        readonly id: "kimi/kimi-k2.6";
+        readonly providerId: "kimi";
+        readonly defaultEndpointId: "kimi.openai";
+        readonly modalities: {
+            readonly input: ["text"];
+            readonly output: ["text"];
+        };
+        readonly tools: {
+            readonly supported: true;
+        };
+        readonly reasoning: {
+            readonly supported: true;
+            readonly preserveAcrossToolTurns: false;
+        };
+    };
+    readonly "qwen/qwen-max": {
+        readonly id: "qwen/qwen-max";
+        readonly providerId: "qwen";
+        readonly defaultEndpointId: "qwen.dashscope";
+        readonly contextWindow: 32768;
+        readonly modalities: {
+            readonly input: ["text", "image"];
+            readonly output: ["text"];
+        };
+        readonly tools: {
+            readonly supported: true;
+        };
+        readonly reasoning: {
+            readonly supported: false;
+            readonly preserveAcrossToolTurns: false;
+        };
+    };
+    readonly "qwen/qwen-plus": {
+        readonly id: "qwen/qwen-plus";
+        readonly providerId: "qwen";
+        readonly defaultEndpointId: "qwen.dashscope";
+        readonly contextWindow: 131072;
+        readonly modalities: {
+            readonly input: ["text", "image"];
+            readonly output: ["text"];
+        };
+        readonly tools: {
+            readonly supported: true;
+        };
+        readonly reasoning: {
+            readonly supported: false;
+            readonly preserveAcrossToolTurns: false;
+        };
+    };
+    readonly "qwen/qwq-plus": {
+        readonly id: "qwen/qwq-plus";
+        readonly providerId: "qwen";
+        readonly defaultEndpointId: "qwen.dashscope";
+        readonly contextWindow: 131072;
+        readonly modalities: {
+            readonly input: ["text"];
+            readonly output: ["text"];
+        };
+        readonly tools: {
+            readonly supported: true;
+        };
+        readonly reasoning: {
+            readonly supported: true;
+            readonly preserveAcrossToolTurns: false;
+        };
+    };
+    readonly "gemini/gemini-2.0-flash": {
+        readonly id: "gemini/gemini-2.0-flash";
+        readonly providerId: "gemini";
+        readonly defaultEndpointId: "gemini.google";
+        readonly contextWindow: 1048576;
+        readonly modalities: {
+            readonly input: ["text", "image", "audio"];
+            readonly output: ["text"];
+        };
+        readonly tools: {
+            readonly supported: true;
+        };
+        readonly reasoning: {
+            readonly supported: false;
+            readonly preserveAcrossToolTurns: false;
+        };
+    };
+    readonly "gemini/gemini-2.5-flash": {
+        readonly id: "gemini/gemini-2.5-flash";
+        readonly providerId: "gemini";
+        readonly defaultEndpointId: "gemini.google";
+        readonly contextWindow: 1048576;
+        readonly modalities: {
+            readonly input: ["text", "image", "audio"];
+            readonly output: ["text"];
+        };
+        readonly tools: {
+            readonly supported: true;
+        };
+        readonly reasoning: {
+            readonly supported: true;
+            readonly preserveAcrossToolTurns: false;
+        };
+    };
+    readonly "gemini/gemini-2.5-pro": {
+        readonly id: "gemini/gemini-2.5-pro";
+        readonly providerId: "gemini";
+        readonly defaultEndpointId: "gemini.google";
+        readonly contextWindow: 1048576;
+        readonly modalities: {
+            readonly input: ["text", "image", "audio"];
+            readonly output: ["text"];
+        };
+        readonly tools: {
+            readonly supported: true;
+        };
+        readonly reasoning: {
+            readonly supported: true;
+            readonly preserveAcrossToolTurns: false;
+        };
+    };
+};
+export type ModelProfileId = keyof typeof modelProfiles;
+export declare function getModelProfile(id: ModelProfileId): ModelProfile;

package/dist/providers/profiles.js

@@ -0,0 +1,190 @@
+export const endpointProfiles = {
+    "openai.chat": {
+        id: "openai.chat",
+        providerId: "openai",
+        protocol: "openai-chat",
+        baseURL: "https://api.openai.com/v1",
+    },
+    "openai.responses": {
+        id: "openai.responses",
+        providerId: "openai",
+        protocol: "openai-responses",
+        baseURL: "https://api.openai.com/v1",
+    },
+    "minimax.anthropic": {
+        id: "minimax.anthropic",
+        providerId: "minimax",
+        protocol: "anthropic-messages",
+        baseURL: "https://api.minimaxi.com/anthropic",
+    },
+    "deepseek.openai": {
+        id: "deepseek.openai",
+        providerId: "deepseek",
+        protocol: "openai-chat",
+        baseURL: "https://api.deepseek.com",
+    },
+    "kimi.openai": {
+        id: "kimi.openai",
+        providerId: "kimi",
+        protocol: "openai-chat",
+        baseURL: "https://api.moonshot.cn/v1",
+    },
+    "qwen.dashscope": {
+        id: "qwen.dashscope",
+        providerId: "qwen",
+        protocol: "openai-chat",
+        baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+    },
+    "gemini.google": {
+        id: "gemini.google",
+        providerId: "gemini",
+        protocol: "gemini",
+        baseURL: "https://generativelanguage.googleapis.com",
+    },
+};
+export const modelProfiles = {
+    "openai/gpt-4o": {
+        id: "openai/gpt-4o",
+        providerId: "openai",
+        defaultEndpointId: "openai.chat",
+        contextWindow: 128_000,
+        modalities: { input: ["text", "image"], output: ["text"] },
+        tools: { supported: true },
+        reasoning: { supported: false, preserveAcrossToolTurns: false },
+    },
+    "openai/gpt-4o-mini": {
+        id: "openai/gpt-4o-mini",
+        providerId: "openai",
+        defaultEndpointId: "openai.chat",
+        contextWindow: 128_000,
+        modalities: { input: ["text", "image"], output: ["text"] },
+        tools: { supported: true },
+        reasoning: { supported: false, preserveAcrossToolTurns: false },
+    },
+    "openai/gpt-5": {
+        id: "openai/gpt-5",
+        providerId: "openai",
+        defaultEndpointId: "openai.responses",
+        modalities: { input: ["text", "image"], output: ["text"] },
+        tools: { supported: true },
+        reasoning: { supported: true, preserveAcrossToolTurns: true },
+    },
+    "openai/gpt-5-mini": {
+        id: "openai/gpt-5-mini",
+        providerId: "openai",
+        defaultEndpointId: "openai.responses",
+        modalities: { input: ["text", "image"], output: ["text"] },
+        tools: { supported: true },
+        reasoning: { supported: true, preserveAcrossToolTurns: true },
+    },
+    "minimax/MiniMax-M2.7": {
+        id: "minimax/MiniMax-M2.7",
+        providerId: "minimax",
+        defaultEndpointId: "minimax.anthropic",
+        contextWindow: 204_800,
+        modalities: { input: ["text"], output: ["text"] },
+        tools: { supported: true },
+        reasoning: { supported: true, preserveAcrossToolTurns: true },
+    },
+    "minimax/MiniMax-M2.5": {
+        id: "minimax/MiniMax-M2.5",
+        providerId: "minimax",
+        defaultEndpointId: "minimax.anthropic",
+        contextWindow: 204_800,
+        modalities: { input: ["text"], output: ["text"] },
+        tools: { supported: true },
+        reasoning: { supported: true, preserveAcrossToolTurns: true },
+    },
+    "deepseek/deepseek-v4-flash": {
+        id: "deepseek/deepseek-v4-flash",
+        providerId: "deepseek",
+        defaultEndpointId: "deepseek.openai",
+        contextWindow: 1_000_000,
+        modalities: { input: ["text"], output: ["text"] },
+        tools: { supported: true },
+        reasoning: { supported: true, preserveAcrossToolTurns: true },
+    },
+    "deepseek/deepseek-v4-pro": {
+        id: "deepseek/deepseek-v4-pro",
+        providerId: "deepseek",
+        defaultEndpointId: "deepseek.openai",
+        contextWindow: 1_000_000,
+        modalities: { input: ["text"], output: ["text"] },
+        tools: { supported: true },
+        reasoning: { supported: true, preserveAcrossToolTurns: true },
+    },
+    "kimi/kimi-k2.5": {
+        id: "kimi/kimi-k2.5",
+        providerId: "kimi",
+        defaultEndpointId: "kimi.openai",
+        contextWindow: 256_000,
+        modalities: { input: ["text", "image"], output: ["text"] },
+        tools: { supported: true },
+        reasoning: { supported: true, preserveAcrossToolTurns: false },
+    },
+    "kimi/kimi-k2.6": {
+        id: "kimi/kimi-k2.6",
+        providerId: "kimi",
+        defaultEndpointId: "kimi.openai",
+        modalities: { input: ["text"], output: ["text"] },
+        tools: { supported: true },
+        reasoning: { supported: true, preserveAcrossToolTurns: false },
+    },
+    "qwen/qwen-max": {
+        id: "qwen/qwen-max",
+        providerId: "qwen",
+        defaultEndpointId: "qwen.dashscope",
+        contextWindow: 32_768,
+        modalities: { input: ["text", "image"], output: ["text"] },
+        tools: { supported: true },
+        reasoning: { supported: false, preserveAcrossToolTurns: false },
+    },
+    "qwen/qwen-plus": {
+        id: "qwen/qwen-plus",
+        providerId: "qwen",
+        defaultEndpointId: "qwen.dashscope",
+        contextWindow: 131_072,
+        modalities: { input: ["text", "image"], output: ["text"] },
+        tools: { supported: true },
+        reasoning: { supported: false, preserveAcrossToolTurns: false },
+    },
+    "qwen/qwq-plus": {
+        id: "qwen/qwq-plus",
+        providerId: "qwen",
+        defaultEndpointId: "qwen.dashscope",
+        contextWindow: 131_072,
+        modalities: { input: ["text"], output: ["text"] },
+        tools: { supported: true },
+        reasoning: { supported: true, preserveAcrossToolTurns: false },
+    },
+    "gemini/gemini-2.0-flash": {
+        id: "gemini/gemini-2.0-flash",
+        providerId: "gemini",
+        defaultEndpointId: "gemini.google",
+        contextWindow: 1_048_576,
+        modalities: { input: ["text", "image", "audio"], output: ["text"] },
+        tools: { supported: true },
+        reasoning: { supported: false, preserveAcrossToolTurns: false },
+    },
+    "gemini/gemini-2.5-flash": {
+        id: "gemini/gemini-2.5-flash",
+        providerId: "gemini",
+        defaultEndpointId: "gemini.google",
+        contextWindow: 1_048_576,
+        modalities: { input: ["text", "image", "audio"], output: ["text"] },
+        tools: { supported: true },
+        reasoning: { supported: true, preserveAcrossToolTurns: false },
+    },
+    "gemini/gemini-2.5-pro": {
+        id: "gemini/gemini-2.5-pro",
+        providerId: "gemini",
+        defaultEndpointId: "gemini.google",
+        contextWindow: 1_048_576,
+        modalities: { input: ["text", "image", "audio"], output: ["text"] },
+        tools: { supported: true },
+        reasoning: { supported: true, preserveAcrossToolTurns: false },
+    },
+};
+export function getModelProfile(id) {
+    return modelProfiles[id];
+}

package/dist/providers/qwen.d.ts

@@ -0,0 +1,18 @@
+import OpenAI from "openai";
+import type { LLMProvider, Message, StreamEvent, ToolSchema } from "../types.js";
+import { CircuitBreaker } from "./base.js";
+import { OpenAIChatAdapter } from "./openai-chat.js";
+export declare class QwenProvider 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);
+    complete(messages: Message[], tools: ToolSchema[]): Promise<Message>;
+    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+}

package/dist/providers/qwen.js

@@ -0,0 +1,103 @@
+import OpenAI from "openai";
+import { withServerRuntimeGuard } from "../runtime/server.js";
+import { CircuitBreaker } from "./base.js";
+import { OpenAIChatAdapter } from "./openai-chat.js";
+import { endpointProfiles } from "./profiles.js";
+const QWEN_BASE = endpointProfiles["qwen.dashscope"].baseURL;
+export class QwenProvider {
+    model;
+    client;
+    circuit;
+    maxRetries;
+    baseDelay;
+    chat = new OpenAIChatAdapter();
+    constructor(apiKey, model = "qwen-max", retry = { maxRetries: 3, baseDelay: 1000 }, baseURL = QWEN_BASE) {
+        this.model = model;
+        this.client = withServerRuntimeGuard(() => new OpenAI({ apiKey, baseURL }));
+        this.circuit = new CircuitBreaker();
+        this.maxRetries = retry.maxRetries;
+        this.baseDelay = retry.baseDelay;
+    }
+    async complete(messages, tools) {
+        if (this.circuit.isOpen())
+            throw new Error("Circuit breaker open");
+        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.chat.buildTools(tools) } : {}),
+                });
+                this.circuit.recordSuccess();
+                const choice = resp.choices[0].message;
+                const toolCalls = this.chat.normalizeToolCalls(choice.tool_calls ?? []);
+                return { role: "assistant", content: choice.content ?? "", tokenCount: resp.usage?.total_tokens, toolCalls };
+            }
+            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) {
+        const enableThinking = Boolean(extensions?.enableThinking ?? extensions?.enable_thinking);
+        const thinkingBudget = extensions?.thinkingBudget ?? extensions?.thinking_budget;
+        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.chat.buildTools(tools) } : {}),
+            stream: true,
+            stream_options: { include_usage: true },
+            ...(enableThinking ? {
+                extra_body: {
+                    enable_thinking: true,
+                    ...(typeof thinkingBudget === "number" ? { thinking_budget: thinkingBudget } : {}),
+                },
+            } : {}),
+        });
+        let totalTokens = 0;
+        for await (const chunk of stream) {
+            if (chunk.usage) {
+                totalTokens = chunk.usage.total_tokens;
+                continue;
+            }
+            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 };
+                }
+            }
+        }
+        if (totalTokens > 0)
+            yield { type: "usage", totalTokens };
+    }
+}

package/dist/runtime/server.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Some server-side tools install browser globals into Node for DOM work. SDKs
+ * that probe those globals during construction can then misclassify the host as
+ * a browser, so hide them only for the synchronous server-only bootstrap and
+ * restore the process exactly as we found it afterward.
+ */
+export declare function withServerRuntimeGuard<T>(fn: () => T): T;