@deepstrike/sdk 0.1.15 → 0.2.0

package/dist/providers/catalog.js

@@ -1,3 +1,4 @@
+import { AnthropicProvider } from "./anthropic.js";
 import { OpenAIChatProvider } from "./openai.js";
 import { DeepSeekProvider } from "./deepseek.js";
 import { KimiProvider } from "./kimi.js";
@@ -5,20 +6,35 @@ import { OpenAIResponsesProvider } from "./openai-responses.js";
 import { MiniMaxProvider } from "./minimax.js";
 import { QwenProvider } from "./qwen.js";
 import { GeminiProvider } from "./gemini.js";
-import { endpointProfiles, getModelProfile } from "./profiles.js";
+import { GLMProvider } from "./glm.js";
+import { endpointProfiles, getModelProfile, modelProfiles } from "./profiles.js";
 export function createProvider(options) {
-    const profile = getModelProfile(options.model);
-    const endpointId = (options.endpoint ?? profile.defaultEndpointId);
+    const profile = isModelProfileId(options.model) ? getModelProfile(options.model) : undefined;
+    const parsedProviderId = providerPrefix(options.model);
+    const endpointId = (options.endpoint ?? profile?.defaultEndpointId ?? defaultEndpointForProvider(options.provider ?? parsedProviderId));
+    if (!endpointId) {
+        throw new Error(`Unknown model profile: ${options.model}. Pass provider or endpoint for custom model names.`);
+    }
     const endpoint = endpointProfiles[endpointId];
     if (!endpoint) {
         throw new Error(`Unknown endpoint profile: ${endpointId}`);
     }
-    if (endpoint.providerId !== profile.providerId) {
-        throw new Error(`Endpoint ${endpoint.id} does not belong to provider ${profile.providerId}`);
+    const providerId = profile?.providerId ?? options.provider ?? parsedProviderId ?? endpoint.providerId;
+    if (profile && options.provider && options.provider !== profile.providerId) {
+        throw new Error(`Model ${profile.id} belongs to provider ${profile.providerId}, not ${options.provider}`);
+    }
+    if (parsedProviderId && options.provider && parsedProviderId !== options.provider) {
+        throw new Error(`Model ${options.model} uses provider prefix ${parsedProviderId}, not ${options.provider}`);
+    }
+    if (endpoint.providerId !== providerId) {
+        throw new Error(`Endpoint ${endpoint.id} does not belong to provider ${providerId}`);
     }
-    const model = options.model.slice(`${profile.providerId}/`.length);
+    const model = modelNameForProvider(options.model, providerId);
     const baseURL = options.baseURL ?? endpoint.baseURL;
-    if (profile.providerId === "openai") {
+    if (providerId === "anthropic" && endpoint.protocol === "anthropic-messages") {
+        return new AnthropicProvider(options.apiKey, model, options.retry, { baseURL });
+    }
+    if (providerId === "openai") {
         if (endpoint.protocol === "openai-chat") {
             return new OpenAIChatProvider(options.apiKey, model, options.retry, baseURL);
         }
@@ -26,20 +42,52 @@ export function createProvider(options) {
             return new OpenAIResponsesProvider(options.apiKey, model, options.retry, baseURL);
         }
     }
-    if (profile.providerId === "minimax" && endpoint.protocol === "anthropic-messages") {
+    if (providerId === "minimax" && endpoint.protocol === "anthropic-messages") {
         return new MiniMaxProvider(options.apiKey, model, options.retry, baseURL);
     }
-    if (profile.providerId === "deepseek" && endpoint.protocol === "openai-chat") {
+    if (providerId === "deepseek" && endpoint.protocol === "openai-chat") {
         return new DeepSeekProvider(options.apiKey, model, options.retry, baseURL);
     }
-    if (profile.providerId === "kimi" && endpoint.protocol === "openai-chat") {
+    if (providerId === "kimi" && endpoint.protocol === "openai-chat") {
         return new KimiProvider(options.apiKey, model, options.retry, baseURL);
     }
-    if (profile.providerId === "qwen" && endpoint.protocol === "openai-chat") {
+    if (providerId === "qwen" && endpoint.protocol === "openai-chat") {
         return new QwenProvider(options.apiKey, model, options.retry, baseURL);
     }
-    if (profile.providerId === "gemini" && endpoint.protocol === "gemini") {
+    if (providerId === "gemini" && endpoint.protocol === "gemini") {
         return new GeminiProvider(options.apiKey, model, options.retry, baseURL);
     }
-    throw new Error(`No Node provider factory for ${profile.id} on ${endpoint.id}`);
+    if (providerId === "glm" && endpoint.protocol === "openai-chat") {
+        return new GLMProvider(options.apiKey, model, options.retry, baseURL);
+    }
+    throw new Error(`No Node provider factory for ${options.model} on ${endpoint.id}`);
+}
+function isModelProfileId(model) {
+    return Object.prototype.hasOwnProperty.call(modelProfiles, model);
+}
+function providerPrefix(model) {
+    const [prefix] = model.split("/", 1);
+    return providerIds().includes(prefix) ? prefix : undefined;
+}
+function providerIds() {
+    return Array.from(new Set(Object.values(endpointProfiles).map(endpoint => endpoint.providerId)));
+}
+function defaultEndpointForProvider(providerId) {
+    if (!providerId)
+        return undefined;
+    const defaults = {
+        anthropic: "anthropic.messages",
+        openai: "openai.chat",
+        minimax: "minimax.anthropic",
+        deepseek: "deepseek.openai",
+        kimi: "kimi.openai",
+        qwen: "qwen.dashscope",
+        gemini: "gemini.google",
+        glm: "glm.openai",
+    };
+    return defaults[providerId];
+}
+function modelNameForProvider(model, providerId) {
+    const prefix = `${providerId}/`;
+    return model.startsWith(prefix) ? model.slice(prefix.length) : model;
 }

package/dist/providers/deepseek.js

@@ -91,7 +91,7 @@ export class DeepSeekProvider extends OpenAIChatProvider {
         const toolCalls = Object.values(toolCallBufs).map(tb => ({
             id: tb.id, name: tb.name, arguments: tb.argsBuf || "{}",
         }));
-        if (toolCalls.length) {
+        if (toolCalls.length || reasoningContent) {
             this.chat.rememberReplayFields({ content: finalText, toolCalls }, { reasoning_content: reasoningContent });
         }
         for (const [index, tb] of Object.entries(toolCallBufs)) {

package/dist/providers/gemini.d.ts

@@ -1,10 +1,13 @@
+import { type Content } from "@google/generative-ai";
 import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
+export declare function buildContents(turns: Message[]): Content[];
 export declare class GeminiProvider implements LLMProvider {
     private readonly model;
     private genAI;
     private circuit;
     private maxRetries;
     private baseDelay;
+    private requestOptions;
     constructor(apiKey: string, model?: string, retry?: {
         maxRetries: number;
         baseDelay: number;

package/dist/providers/gemini.js

@@ -4,6 +4,9 @@ import { CircuitBreaker, normalizeToolCall } from "./base.js";
 import { endpointProfiles } from "./profiles.js";
 const GEMINI_BASE = endpointProfiles["gemini.google"].baseURL;
 const GEMINI_POLICIES = {
+    "gemini-3-pro-preview": { maxTurns: 50 },
+    "gemini-3-flash-preview": { maxTurns: 25 },
+    "gemini-3.5-flash": { maxTurns: 30 },
     "gemini-2.5-pro": { maxTurns: 35 },
     "gemini-2.5-flash": { maxTurns: 20 },
     "gemini-2.0-flash": { maxTurns: 15 },
@@ -11,15 +14,30 @@ const GEMINI_POLICIES = {
     "gemini-1.5-pro": { maxTurns: 30 },
     "gemini-1.5-flash": { maxTurns: 15 },
 };
-function buildContents(turns) {
+export function buildContents(turns) {
     const contents = [];
     for (const msg of turns) {
         if (msg.role === "tool") {
             const parts = (msg.contentParts ?? [])
                 .filter(p => p.type === "tool_result")
-                .map(p => p.type === "tool_result" ? ({
-                functionResponse: { name: p.callId, response: { output: p.output } },
-            }) : ({ text: "" }));
+                .map(p => {
+                if (p.type !== "tool_result")
+                    return { text: "" };
+                let toolName = p.callId;
+                for (let i = turns.length - 1; i >= 0; i--) {
+                    const turn = turns[i];
+                    if (turn.role === "assistant" && turn.toolCalls) {
+                        const matched = turn.toolCalls.find(tc => tc.id === p.callId);
+                        if (matched) {
+                            toolName = matched.name;
+                            break;
+                        }
+                    }
+                }
+                return {
+                    functionResponse: { name: toolName, response: { output: p.output } },
+                };
+            });
             if (parts.length)
                 contents.push({ role: "user", parts });
             continue;
@@ -62,12 +80,14 @@ export class GeminiProvider {
     circuit;
     maxRetries;
     baseDelay;
+    requestOptions;
     constructor(apiKey, model = "gemini-2.0-flash", retry = { maxRetries: 3, baseDelay: 1000 }, baseURL = GEMINI_BASE) {
         this.model = model;
         this.genAI = withServerRuntimeGuard(() => new GoogleGenerativeAI(apiKey));
         this.circuit = new CircuitBreaker();
         this.maxRetries = retry.maxRetries;
         this.baseDelay = retry.baseDelay;
+        this.requestOptions = { baseUrl: baseURL };
     }
     runtimePolicy() {
         return GEMINI_POLICIES[this.model] ?? {};
@@ -86,7 +106,7 @@ export class GeminiProvider {
                     model: this.model,
                     ...(system ? { systemInstruction: system } : {}),
                     ...(geminiTools.length ? { tools: geminiTools } : {}),
-                });
+                }, this.requestOptions);
                 const resp = await m.generateContent({ contents });
                 this.circuit.recordSuccess();
                 const candidate = resp.response.candidates?.[0];
@@ -127,7 +147,7 @@ export class GeminiProvider {
             model: this.model,
             ...(system ? { systemInstruction: system } : {}),
             ...(geminiTools.length ? { tools: geminiTools } : {}),
-        });
+        }, this.requestOptions);
         const result = await m.generateContentStream({ contents });
         const toolCalls = [];
         for await (const chunk of result.stream) {

package/dist/providers/glm.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimePolicy } from "../types.js";
+import { OpenAIChatProvider } from "./openai.js";
+export declare class GLMProvider extends OpenAIChatProvider {
+    constructor(apiKey: string, model?: string, retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    }, baseURL?: string);
+    runtimePolicy(): RuntimePolicy;
+}

package/dist/providers/glm.js

@@ -0,0 +1,21 @@
+import { OpenAIChatProvider } from "./openai.js";
+import { endpointProfiles } from "./profiles.js";
+const GLM_BASE = endpointProfiles["glm.openai"].baseURL;
+const GLM_POLICIES = {
+    "glm-5.1": { maxTurns: 50 },
+    "glm/glm-5.1": { maxTurns: 50 },
+    "glm-4-plus": { maxTurns: 35 },
+    "glm/glm-4-plus": { maxTurns: 35 },
+    "glm-4-flash": { maxTurns: 15 },
+    "glm/glm-4-flash": { maxTurns: 15 },
+    "glm-4-air": { maxTurns: 20 },
+    "glm/glm-4-air": { maxTurns: 20 },
+};
+export class GLMProvider extends OpenAIChatProvider {
+    constructor(apiKey, model = "glm-5.1", retry, baseURL = GLM_BASE) {
+        super(apiKey, model, retry, baseURL);
+    }
+    runtimePolicy() {
+        return GLM_POLICIES[this.model] ?? {};
+    }
+}

package/dist/providers/kimi.js

@@ -7,6 +7,8 @@ const KIMI_POLICIES = {
     "moonshot-v1-128k": { maxTurns: 30 },
     "kimi-k2.5": { maxTurns: 30 },
     "kimi-k2.6": { maxTurns: 35 },
+    "kimi-k2-thinking": { maxTurns: 50 },
+    "kimi-k2-thinking-turbo": { maxTurns: 40 },
 };
 export class KimiProvider extends OpenAIChatProvider {
     constructor(apiKey, model = "kimi-k2.6", retry, baseURL = MOONSHOT_BASE) {

package/dist/providers/minimax.js

@@ -2,7 +2,12 @@ import { AnthropicProvider } from "./anthropic.js";
 import { endpointProfiles } from "./profiles.js";
 const MINIMAX_POLICIES = {
     "MiniMax-M2.7": { maxTurns: 35 },
+    "MiniMax-M2.7-highspeed": { maxTurns: 35 },
     "MiniMax-M2.5": { maxTurns: 25 },
+    "MiniMax-M2.5-highspeed": { maxTurns: 25 },
+    "MiniMax-M2.1": { maxTurns: 25 },
+    "MiniMax-M2.1-highspeed": { maxTurns: 25 },
+    "MiniMax-M2": { maxTurns: 20 },
     "MiniMax-Text-01": { maxTurns: 20 },
 };
 export class MiniMaxProvider extends AnthropicProvider {

package/dist/providers/openai-responses.js

@@ -115,11 +115,20 @@ export class OpenAIResponsesProvider {
     }
     runtimePolicy() {
         const table = {
+            "gpt-5.5": { maxTurns: 60 },
+            "gpt-5.4": { maxTurns: 50 },
+            "gpt-5.4-mini": { maxTurns: 25 },
+            "gpt-5.4-nano": { maxTurns: 15 },
+            "gpt-5.2": { maxTurns: 50 },
+            "gpt-5.2-pro": { maxTurns: 60 },
+            "gpt-5.1": { maxTurns: 50 },
             "gpt-4.1": { maxTurns: 35 },
             "gpt-4.1-mini": { maxTurns: 20 },
             "gpt-4.1-nano": { maxTurns: 15 },
             "gpt-5": { maxTurns: 50 },
+            "gpt-5-pro": { maxTurns: 60 },
             "gpt-5-mini": { maxTurns: 25 },
+            "gpt-5-nano": { maxTurns: 15 },
             "o3": { maxTurns: 50 },
             "o3-mini": { maxTurns: 25 },
             "o4-mini": { maxTurns: 25 },

package/dist/providers/openai.js

@@ -1,15 +1,24 @@
 import OpenAI from "openai";
 import { withServerRuntimeGuard } from "../runtime/server.js";
-import { CircuitBreaker, omitExtensionKeys } from "./base.js";
+import { CircuitBreaker, omitExtensionKeys, ThinkingTagStreamExtractor } from "./base.js";
 import { OpenAIChatAdapter } from "./openai-chat.js";
 const OPENAI_POLICIES = {
+    "gpt-5.5": { maxTurns: 60 },
+    "gpt-5.4": { maxTurns: 50 },
+    "gpt-5.4-mini": { maxTurns: 25 },
+    "gpt-5.4-nano": { maxTurns: 15 },
+    "gpt-5.2": { maxTurns: 50 },
+    "gpt-5.2-pro": { maxTurns: 60 },
+    "gpt-5.1": { maxTurns: 50 },
     "gpt-4o": { maxTurns: 25 },
     "gpt-4o-mini": { maxTurns: 15 },
     "gpt-4.1": { maxTurns: 35 },
     "gpt-4.1-mini": { maxTurns: 20 },
     "gpt-4.1-nano": { maxTurns: 15 },
     "gpt-5": { maxTurns: 50 },
+    "gpt-5-pro": { maxTurns: 60 },
     "gpt-5-mini": { maxTurns: 25 },
+    "gpt-5-nano": { maxTurns: 15 },
     "o1": { maxTurns: 50 },
     "o1-mini": { maxTurns: 25 },
     "o3": { maxTurns: 50 },
@@ -35,12 +44,12 @@ export class OpenAIChatProvider {
     }
     peekProviderReplay(message) {
         const fields = this.chat.peekReplayFields(message);
-        if (!fields?.reasoning_content)
+        if (!fields || !("reasoning_content" in fields))
             return undefined;
-        return { reasoning_content: String(fields.reasoning_content) };
+        return { reasoning_content: String(fields.reasoning_content ?? "") };
     }
     seedProviderReplay(message, replay) {
-        if (replay.reasoning_content) {
+        if (replay.reasoning_content !== undefined) {
             this.chat.rememberReplayFields(message, { reasoning_content: replay.reasoning_content });
         }
     }
@@ -75,6 +84,9 @@ export class OpenAIChatProvider {
         const msgs = this.chat.buildMessages(context);
         const toolCallBufs = {};
         const emittedToolCallIndexes = new Set();
+        const extractor = new ThinkingTagStreamExtractor();
+        let accumulatedReasoning = "";
+        let accumulatedContent = "";
         const stream = await this.client.chat.completions.create({
             ...this.requestExtensions(extensions),
             model: this.model,
@@ -93,8 +105,22 @@ export class OpenAIChatProvider {
             if (!choice)
                 continue;
             const delta = choice.delta;
-            if (delta.content)
-                yield { type: "text_delta", delta: delta.content };
+            if (delta.reasoning_content) {
+                accumulatedReasoning += delta.reasoning_content;
+                yield { type: "thinking_delta", delta: delta.reasoning_content };
+            }
+            if (delta.content) {
+                for (const part of extractor.feed(delta.content)) {
+                    if (part.type === "thinking") {
+                        accumulatedReasoning += part.content;
+                        yield { type: "thinking_delta", delta: part.content };
+                    }
+                    else {
+                        accumulatedContent += part.content;
+                        yield { type: "text_delta", delta: part.content };
+                    }
+                }
+            }
             for (const tc of delta.tool_calls ?? []) {
                 const idx = tc.index;
                 if (!toolCallBufs[idx])
@@ -104,6 +130,10 @@ export class OpenAIChatProvider {
                 toolCallBufs[idx].argsBuf += tc.function?.arguments ?? "";
             }
             if (choice.finish_reason === "tool_calls") {
+                const toolCalls = Object.values(toolCallBufs).map(tb => ({
+                    id: tb.id, name: tb.name, arguments: tb.argsBuf || "{}",
+                }));
+                this.chat.rememberReplayFields({ content: accumulatedContent, toolCalls }, { reasoning_content: accumulatedReasoning });
                 for (const [index, tb] of Object.entries(toolCallBufs)) {
                     const idx = Number(index);
                     if (emittedToolCallIndexes.has(idx))
@@ -120,6 +150,22 @@ export class OpenAIChatProvider {
                 }
             }
         }
+        for (const part of extractor.flush()) {
+            if (part.type === "thinking") {
+                accumulatedReasoning += part.content;
+                yield { type: "thinking_delta", delta: part.content };
+            }
+            else {
+                accumulatedContent += part.content;
+                yield { type: "text_delta", delta: part.content };
+            }
+        }
+        const toolCalls = Object.values(toolCallBufs).map(tb => ({
+            id: tb.id, name: tb.name, arguments: tb.argsBuf || "{}",
+        }));
+        if (toolCalls.length || accumulatedReasoning) {
+            this.chat.rememberReplayFields({ content: accumulatedContent, toolCalls }, { reasoning_content: accumulatedReasoning });
+        }
         for (const [index, tb] of Object.entries(toolCallBufs)) {
             const idx = Number(index);
             if (emittedToolCallIndexes.has(idx))