@deepstrike/sdk 0.1.12 → 0.1.14

package/dist/providers/ollama.js

@@ -1,4 +1,18 @@
-import { normalizeToolCall } from "./base.js";
+import { normalizeToolCall, omitExtensionKeys } from "./base.js";
+// Prefix-based policy for local models (first match wins)
+const OLLAMA_PREFIX_POLICIES = [
+    ["deepseek-r1", { maxTurns: 40 }],
+    ["qwq", { maxTurns: 35 }],
+    ["llama3.3", { maxTurns: 25 }],
+    ["llama3.2", { maxTurns: 20 }],
+    ["llama3.1", { maxTurns: 20 }],
+    ["llama3", { maxTurns: 20 }],
+    ["mistral", { maxTurns: 20 }],
+    ["gemma2", { maxTurns: 20 }],
+    ["phi4", { maxTurns: 20 }],
+    ["phi3", { maxTurns: 15 }],
+    ["codellama", { maxTurns: 20 }],
+];
 export class OllamaProvider {
     model;
     baseUrl;
@@ -6,6 +20,14 @@ export class OllamaProvider {
         this.model = model;
         this.baseUrl = baseUrl;
     }
+    runtimePolicy() {
+        const m = this.model.toLowerCase();
+        for (const [prefix, policy] of OLLAMA_PREFIX_POLICIES) {
+            if (m.startsWith(prefix))
+                return policy;
+        }
+        return { maxTurns: 20 };
+    }
     toOllamaMessages(context) {
         const result = [];
         if (context.systemText)
@@ -22,11 +44,26 @@ export class OllamaProvider {
         }
         return result;
     }
-    async complete(context, tools) {
+    buildTools(tools) {
+        return tools.map(t => ({
+            type: "function",
+            function: { name: t.name, description: t.description, parameters: JSON.parse(t.parameters) },
+        }));
+    }
+    requestExtensions(extensions) {
+        return omitExtensionKeys(extensions, ["model", "messages", "tools", "stream"]);
+    }
+    async complete(context, tools, extensions) {
         const resp = await fetch(`${this.baseUrl}/api/chat`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ model: this.model, messages: this.toOllamaMessages(context), stream: false }),
+            body: JSON.stringify({
+                ...this.requestExtensions(extensions),
+                model: this.model,
+                messages: this.toOllamaMessages(context),
+                ...(tools.length ? { tools: this.buildTools(tools) } : {}),
+                stream: false,
+            }),
         });
         if (!resp.ok)
             throw new Error(`Ollama error: ${resp.status}`);
@@ -37,13 +74,20 @@ export class OllamaProvider {
         const resp = await fetch(`${this.baseUrl}/api/chat`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ model: this.model, messages: this.toOllamaMessages(context), stream: true }),
+            body: JSON.stringify({
+                ...this.requestExtensions(extensions),
+                model: this.model,
+                messages: this.toOllamaMessages(context),
+                ...(tools.length ? { tools: this.buildTools(tools) } : {}),
+                stream: true,
+            }),
         });
         if (!resp.ok)
             throw new Error(`Ollama error: ${resp.status}`);
         const reader = resp.body.getReader();
         const decoder = new TextDecoder();
         let buf = "";
+        const pendingToolCalls = new Map();
         while (true) {
             const { done, value } = await reader.read();
             if (done)
@@ -59,13 +103,25 @@ export class OllamaProvider {
                     if (chunk.message?.content)
                         yield { type: "text_delta", delta: chunk.message.content };
                     for (const tc of chunk.message?.tool_calls ?? []) {
-                        const norm = normalizeToolCall(crypto.randomUUID(), tc.function.name, tc.function.arguments);
-                        if (norm)
-                            yield { type: "tool_call", id: norm.id, name: norm.name, arguments: JSON.parse(norm.arguments) };
+                        const norm = normalizeToolCall("", tc.function.name, tc.function.arguments);
+                        if (!norm)
+                            continue;
+                        const args = JSON.parse(norm.arguments);
+                        const key = `${norm.name}:${norm.arguments}`;
+                        if (!pendingToolCalls.has(key)) {
+                            pendingToolCalls.set(key, {
+                                id: `call_${pendingToolCalls.size + 1}`,
+                                name: norm.name,
+                                arguments: args,
+                            });
+                        }
                     }
                 }
                 catch { /* skip malformed lines */ }
             }
         }
+        for (const tc of pendingToolCalls.values()) {
+            yield { type: "tool_call", id: tc.id, name: tc.name, arguments: tc.arguments };
+        }
     }
 }

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

@@ -35,8 +35,10 @@ export declare class OpenAIResponsesProvider implements LLMProvider {
         maxRetries: number;
         baseDelay: number;
     }, baseURL?: string);
+    runtimePolicy(): import("../types.js").RuntimePolicy;
     createRunState(): OpenAIResponsesRunState;
-    complete(context: RenderedContext, tools: ToolSchema[]): Promise<Message>;
-    stream(context: RenderedContext, tools: ToolSchema[], _extensions?: Record<string, unknown>, state?: ProviderRunState): AsyncIterable<StreamEvent>;
+    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;
     private asRunState;
 }

package/dist/providers/openai-responses.js

@@ -1,6 +1,6 @@
 import OpenAI from "openai";
 import { withServerRuntimeGuard } from "../runtime/server.js";
-import { CircuitBreaker } from "./base.js";
+import { CircuitBreaker, omitExtensionKeys } from "./base.js";
 import { normalizeToolCall } from "./base.js";
 export class OpenAIResponsesAdapter {
     buildTools(tools) {
@@ -113,10 +113,23 @@ export class OpenAIResponsesProvider {
         this.maxRetries = retry.maxRetries;
         this.baseDelay = retry.baseDelay;
     }
+    runtimePolicy() {
+        const table = {
+            "gpt-4.1": { maxTurns: 35 },
+            "gpt-4.1-mini": { maxTurns: 20 },
+            "gpt-4.1-nano": { maxTurns: 15 },
+            "gpt-5": { maxTurns: 50 },
+            "gpt-5-mini": { maxTurns: 25 },
+            "o3": { maxTurns: 50 },
+            "o3-mini": { maxTurns: 25 },
+            "o4-mini": { maxTurns: 25 },
+        };
+        return table[this.model] ?? {};
+    }
     createRunState() {
         return { coveredMessageCount: 0 };
     }
-    async complete(context, tools) {
+    async complete(context, tools, extensions) {
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");
         let lastErr;
@@ -124,6 +137,7 @@ export class OpenAIResponsesProvider {
             try {
                 const instructions = this.responses.buildInstructions(context);
                 const resp = await this.client.responses.create({
+                    ...this.requestExtensions(extensions),
                     model: this.model,
                     input: this.responses.buildInput(context),
                     ...(instructions ? { instructions } : {}),
@@ -147,11 +161,12 @@ export class OpenAIResponsesProvider {
         }
         throw lastErr;
     }
-    async *stream(context, tools, _extensions, state) {
+    async *stream(context, tools, extensions, state) {
         const runState = this.asRunState(state);
         const functionCalls = new Map();
         const instructions = this.responses.buildInstructions(context);
         const stream = await this.client.responses.create({
+            ...this.requestExtensions(extensions),
             model: this.model,
             input: this.responses.buildInput(context, runState),
             ...(instructions ? { instructions } : {}),
@@ -204,6 +219,11 @@ export class OpenAIResponsesProvider {
             }
         }
     }
+    requestExtensions(extensions) {
+        return omitExtensionKeys(extensions, [
+            "model", "input", "instructions", "tools", "stream", "previous_response_id",
+        ]);
+    }
     asRunState(state) {
         if (!state)
             return this.createRunState();

package/dist/providers/openai.d.ts

@@ -1,5 +1,5 @@
 import OpenAI from "openai";
-import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider } from "../types.js";
+import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
 import { CircuitBreaker } from "./base.js";
 import { OpenAIChatAdapter } from "./openai-chat.js";
 export declare class OpenAIChatProvider implements LLMProvider {
@@ -13,7 +13,9 @@ export declare class OpenAIChatProvider implements LLMProvider {
         maxRetries: number;
         baseDelay: number;
     }, baseURL?: string);
-    complete(context: RenderedContext, tools: ToolSchema[]): Promise<Message>;
+    runtimePolicy(): RuntimePolicy;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    protected requestExtensions(extensions?: Record<string, unknown>): Record<string, unknown>;
 }
 export { OpenAIChatProvider as OpenAIProvider };

package/dist/providers/openai.js

@@ -1,7 +1,21 @@
 import OpenAI from "openai";
 import { withServerRuntimeGuard } from "../runtime/server.js";
-import { CircuitBreaker } from "./base.js";
+import { CircuitBreaker, omitExtensionKeys } from "./base.js";
 import { OpenAIChatAdapter } from "./openai-chat.js";
+const OPENAI_POLICIES = {
+    "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-mini": { maxTurns: 25 },
+    "o1": { maxTurns: 50 },
+    "o1-mini": { maxTurns: 25 },
+    "o3": { maxTurns: 50 },
+    "o3-mini": { maxTurns: 25 },
+    "o4-mini": { maxTurns: 25 },
+};
 export class OpenAIChatProvider {
     model;
     client;
@@ -16,7 +30,10 @@ export class OpenAIChatProvider {
         this.maxRetries = retry.maxRetries;
         this.baseDelay = retry.baseDelay;
     }
-    async complete(context, tools) {
+    runtimePolicy() {
+        return OPENAI_POLICIES[this.model] ?? {};
+    }
+    async complete(context, tools, extensions) {
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");
         const msgs = this.chat.buildMessages(context);
@@ -24,6 +41,7 @@ export class OpenAIChatProvider {
         for (let i = 0; i < this.maxRetries; i++) {
             try {
                 const resp = await this.client.chat.completions.create({
+                    ...this.requestExtensions(extensions),
                     model: this.model,
                     messages: msgs,
                     ...(tools.length ? { tools: this.chat.buildTools(tools) } : {}),
@@ -45,7 +63,9 @@ export class OpenAIChatProvider {
     async *stream(context, tools, extensions) {
         const msgs = this.chat.buildMessages(context);
         const toolCallBufs = {};
+        const emittedToolCallIndexes = new Set();
         const stream = await this.client.chat.completions.create({
+            ...this.requestExtensions(extensions),
             model: this.model,
             messages: msgs,
             ...(tools.length ? { tools: this.chat.buildTools(tools) } : {}),
@@ -73,7 +93,10 @@ export class OpenAIChatProvider {
                 toolCallBufs[idx].argsBuf += tc.function?.arguments ?? "";
             }
             if (choice.finish_reason === "tool_calls") {
-                for (const tb of Object.values(toolCallBufs)) {
+                for (const [index, tb] of Object.entries(toolCallBufs)) {
+                    const idx = Number(index);
+                    if (emittedToolCallIndexes.has(idx))
+                        continue;
                     let args = {};
                     try {
                         args = JSON.parse(tb.argsBuf || "{}");
@@ -81,12 +104,30 @@ export class OpenAIChatProvider {
                     catch {
                         args = {};
                     }
+                    emittedToolCallIndexes.add(idx);
                     yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
                 }
             }
         }
+        for (const [index, tb] of Object.entries(toolCallBufs)) {
+            const idx = Number(index);
+            if (emittedToolCallIndexes.has(idx))
+                continue;
+            let args = {};
+            try {
+                args = JSON.parse(tb.argsBuf || "{}");
+            }
+            catch {
+                args = {};
+            }
+            emittedToolCallIndexes.add(idx);
+            yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
+        }
         if (totalTokens > 0)
             yield { type: "usage", totalTokens };
     }
+    requestExtensions(extensions) {
+        return omitExtensionKeys(extensions, ["model", "messages", "tools", "stream", "stream_options"]);
+    }
 }
 export { OpenAIChatProvider as OpenAIProvider };