@deepstrike/sdk 0.1.12 → 0.1.13

package/README.md

@@ -88,6 +88,8 @@ for await (const event of agent.runStreaming("Summarize README.md")) {
 
 All providers accept `RetryConfig` for exponential backoff and share a `CircuitBreaker`.
 
+`extensions` are forwarded by every provider in both `complete()` and `stream()` while SDK-owned structural fields such as `model`, `messages`, `tools`, and streaming flags remain protected. Provider-specific controls still keep their native spellings: for example Anthropic `thinking` / `betas`, OpenAI Responses `reasoning`, Gemini `generationConfig`, Ollama `think` / `options`, DeepSeek `thinking` + `reasoningEffort`, and Qwen `enableThinking` + `thinkingBudget`.
+
 OpenAI can also be selected through the provider catalog:
 
 ```typescript
@@ -108,7 +110,7 @@ const agent = new Agent(provider, {
   maxTokens: 4096,            // context window size
   maxTurns: 25,               // max turns (default 25)
   timeoutMs: 60_000,          // timeout in ms
-  extensions: { temperature: 0.1 },  // pass-through to LLM
+  extensions: { temperature: 0.1 },  // provider-native controls, passed through to the LLM
   skillDir: "./skills",       // skill .md files directory
   knowledgeSource: myKS,      // KnowledgeSource implementation
   signalSource: rx,           // SignalSource for external signals
@@ -307,6 +309,8 @@ console.log(out.passed, out.feedback)
 | `text_delta` | `delta` |
 | `thinking_delta` | `delta` |
 | `tool_call` | `id`, `name`, `arguments` |
+| `tool_delta` | `callId`, `delta?`, `chunk?` |
+| `tool_suspend` | `callId`, `suspensionId`, `payload?` |
 | `tool_result` | `callId`, `content`, `isError` |
 | `permission_request` | `toolName`, `reason` |
 | `done` | `iterations`, `totalTokens`, `status` |

package/dist/agent.d.ts

@@ -1,4 +1,4 @@
-import type { LLMProvider, StreamEvent } from "./types.js";
+import type { LLMProvider, StreamEvent, ToolSuspendEvent } from "./types.js";
 import type { RegisteredTool } from "./tools/index.js";
 import type { DreamStore, DreamResult, SessionStore } from "./memory/protocols.js";
 import type { KnowledgeSource } from "./knowledge/source.js";
@@ -34,6 +34,7 @@ export interface AgentOptions {
      * `evaluate(toolName: string, argsJson: string): { kind: string; reason?: string; retryAfterMs?: number }`.
      * When provided, every tool call is evaluated through the full pipeline.
      */
+    onToolSuspend?: (event: ToolSuspendEvent) => Promise<unknown> | unknown;
     governance?: {
         setTime?(nowMs: bigint): void;
         evaluate(toolName: string, argsJson: string): {
@@ -71,6 +72,7 @@ export declare class Agent {
      */
     run(goal: string, criteria?: string[], extensions?: Record<string, unknown>, sessionId?: string): Promise<string>;
     runStreaming(goal: string, criteria?: string[], extensions?: Record<string, unknown>, sessionId?: string): AsyncIterable<StreamEvent>;
+    private runRegularTool;
     private loadSession;
     private saveSession;
     private toMessage;

package/dist/agent.js

@@ -1,4 +1,4 @@
-import { executeTools } from "./tools/index.js";
+import { isAsyncIterable, normalizeToolChunk, toolChunkText, validateToolArguments } from "./tools/index.js";
 import { readSkillFile, scanSkillDir } from "./skills/loader.js";
 import { getKernel } from "./kernel.js";
 export class Agent {
@@ -245,7 +245,22 @@ export class Agent {
                     : knowledgeCalls.map((c) => ({ callId: c.id, name: c.name, output: "Knowledge source not configured.", isError: true }));
                 for (const r of [...skillResults, ...memoryResults, ...knowledgeResults])
                     yield { type: "tool_result", callId: r.callId, name: r.name, content: r.output, isError: r.isError };
-                const results = await executeTools(regularCalls, this.tools);
+                const results = [];
+                const active = regularCalls.map(call => {
+                    const iterator = this.runRegularTool(call);
+                    return { iterator, pending: iterator.next() };
+                });
+                while (active.length) {
+                    const next = await Promise.race(active.map((task, index) => task.pending.then(result => ({ index, result }))));
+                    const task = active[next.index];
+                    if (next.result.done) {
+                        results.push(next.result.value);
+                        active.splice(next.index, 1);
+                        continue;
+                    }
+                    yield next.result.value;
+                    task.pending = task.iterator.next();
+                }
                 for (const r of results) {
                     const name = regularCalls.find((c) => c.id === r.callId)?.name ?? "";
                     yield { type: "tool_result", callId: r.callId, name, content: r.output, isError: r.isError };
@@ -299,6 +314,60 @@ export class Agent {
             status,
         };
     }
+    async *runRegularTool(call) {
+        const registeredTool = this.tools.get(call.name);
+        if (!registeredTool)
+            return { callId: call.id, output: `unknown tool: ${call.name}`, isError: true };
+        try {
+            const args = JSON.parse(call.arguments || "{}");
+            const validationError = validateToolArguments(registeredTool.schema.parameters, args);
+            if (validationError)
+                return { callId: call.id, output: `invalid arguments: ${validationError}`, isError: true };
+            const output = await registeredTool.execute(args);
+            if (isAsyncIterable(output)) {
+                let combined = "";
+                const iterator = output[Symbol.asyncIterator]();
+                let resumeValue;
+                while (true) {
+                    const next = await iterator.next(resumeValue);
+                    resumeValue = undefined;
+                    if (next.done)
+                        break;
+                    const rawChunk = next.value;
+                    const chunk = normalizeToolChunk(rawChunk);
+                    if (chunk.type === "suspend") {
+                        const event = {
+                            type: "tool_suspend",
+                            callId: call.id,
+                            name: call.name,
+                            suspensionId: chunk.suspensionId,
+                            ...(chunk.payload ? { payload: chunk.payload } : {}),
+                        };
+                        yield event;
+                        if (!this.options.onToolSuspend) {
+                            return { callId: call.id, output: `tool suspended without resume handler: ${chunk.suspensionId}`, isError: true };
+                        }
+                        resumeValue = await this.options.onToolSuspend(event);
+                        continue;
+                    }
+                    const delta = toolChunkText(rawChunk);
+                    combined += delta;
+                    yield {
+                        type: "tool_delta",
+                        callId: call.id,
+                        name: call.name,
+                        ...(delta ? { delta } : {}),
+                        ...(typeof rawChunk === "string" ? {} : { chunk }),
+                    };
+                }
+                return { callId: call.id, output: combined, isError: false };
+            }
+            return { callId: call.id, output, isError: false };
+        }
+        catch (err) {
+            return { callId: call.id, output: String(err), isError: true };
+        }
+    }
     async loadSession(sessionId) {
         return this.options.sessionStore
             ? this.options.sessionStore.loadSession(sessionId)

package/dist/harness/harness.d.ts

@@ -38,6 +38,16 @@ export type HarnessEvent = {
     type: "tool_call";
     id: string;
     name: string;
+} | {
+    type: "tool_delta";
+    callId: string;
+    delta?: string;
+    chunk?: Record<string, unknown>;
+} | {
+    type: "tool_suspend";
+    callId: string;
+    suspensionId: string;
+    payload?: Record<string, unknown>;
 } | {
     type: "tool_result";
     callId: string;

package/dist/harness/harness.js

@@ -74,6 +74,14 @@ export class HarnessLoop {
                     const tc = evt;
                     yield { type: "tool_call", id: tc.id, name: tc.name };
                 }
+                else if (evt.type === "tool_delta") {
+                    const td = evt;
+                    yield { type: "tool_delta", callId: td.callId, ...(td.delta ? { delta: td.delta } : {}), ...(td.chunk ? { chunk: td.chunk } : {}) };
+                }
+                else if (evt.type === "tool_suspend") {
+                    const ts = evt;
+                    yield { type: "tool_suspend", callId: ts.callId, suspensionId: ts.suspensionId, ...(ts.payload ? { payload: ts.payload } : {}) };
+                }
                 else if (evt.type === "tool_result") {
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     const tr = evt;

package/dist/index.d.ts

@@ -15,7 +15,7 @@ export type { OpenAIResponsesRunState } from "./providers/openai-responses.js";
 export { endpointProfiles, modelProfiles, getModelProfile } from "./providers/profiles.js";
 export { createProvider } from "./providers/catalog.js";
 export type { CreateProviderOptions, EndpointProfileId } from "./providers/catalog.js";
-export { tool, executeTools, readFile } from "./tools/index.js";
+export { tool, streamingTool, executeTools, readFile, validateToolArguments } from "./tools/index.js";
 export type { RegisteredTool } from "./tools/index.js";
 export { scanSkillDir, readSkillFile } from "./skills/loader.js";
 export type { SkillMetadata } from "./skills/loader.js";
@@ -31,7 +31,7 @@ export { PermissionManager, PermissionMode } from "./safety/permissions.js";
 export type { PermissionDecision, Permission } from "./safety/permissions.js";
 export { Governance } from "./governance.js";
 export type { GovernanceVerdict } from "./governance.js";
-export type { Message, ToolCall, ToolResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, LLMProvider, RetryConfig, TokenUsage, ProviderToolSpec, ProviderRunState, RenderedContext, } from "./types.js";
+export type { Message, ToolCall, ToolResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolChunk, ToolDeltaEvent, ToolSuspendEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, LLMProvider, RetryConfig, TokenUsage, ProviderToolSpec, ProviderRunState, RenderedContext, } from "./types.js";
 export type { AcceptanceCriterion, VerificationContract, ContractCheckResult, } from "./collaboration/contract.js";
 export { ContractBuilder, formatContractForSystemPrompt, contractToCriteriaStrings, } from "./collaboration/contract.js";
 export { AgentPool } from "./collaboration/pool.js";

package/dist/index.js

@@ -12,7 +12,7 @@ export { OpenAIChatAdapter } from "./providers/openai-chat.js";
 export { OpenAIResponsesAdapter, OpenAIResponsesProvider } from "./providers/openai-responses.js";
 export { endpointProfiles, modelProfiles, getModelProfile } from "./providers/profiles.js";
 export { createProvider } from "./providers/catalog.js";
-export { tool, executeTools, readFile } from "./tools/index.js";
+export { tool, streamingTool, executeTools, readFile, validateToolArguments } from "./tools/index.js";
 export { scanSkillDir, readSkillFile } from "./skills/loader.js";
 export { WorkingMemory } from "./memory/working.js";
 export { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "./harness/harness.js";

package/dist/providers/anthropic.d.ts

@@ -15,8 +15,12 @@ export declare class AnthropicProvider implements LLMProvider {
         baseDelay: number;
     }, options?: AnthropicProviderOptions);
     private buildTools;
-    complete(context: RenderedContext, tools: ToolSchema[]): Promise<Message>;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    private requestExtensions;
+    private hasBetas;
+    private createMessage;
+    private streamMessage;
     private buildMessages;
     private rememberNativeBlocks;
     private assistantReplayKey;

package/dist/providers/anthropic.js

@@ -1,6 +1,6 @@
 import Anthropic from "@anthropic-ai/sdk";
 import { withServerRuntimeGuard } from "../runtime/server.js";
-import { CircuitBreaker, normalizeToolCall, toAnthropicMessages } from "./base.js";
+import { CircuitBreaker, normalizeToolCall, omitExtensionKeys, toAnthropicMessages } from "./base.js";
 export class AnthropicProvider {
     model;
     client;
@@ -25,21 +25,23 @@ export class AnthropicProvider {
             input_schema: JSON.parse(t.parameters),
         }));
     }
-    async complete(context, tools) {
+    async complete(context, tools, extensions) {
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");
         const system = context.systemText || undefined;
         const msgs = this.buildMessages(context);
+        const requestExtensions = this.requestExtensions(extensions);
         let lastErr;
         for (let i = 0; i < this.maxRetries; i++) {
             try {
-                const resp = await this.client.messages.create({
+                const resp = await this.createMessage({
+                    ...requestExtensions,
                     model: this.model,
-                    max_tokens: 8096,
+                    max_tokens: typeof extensions?.max_tokens === "number" ? extensions.max_tokens : 8096,
                     ...(system ? { system } : {}),
                     messages: msgs,
                     ...(tools.length ? { tools: this.buildTools(tools) } : {}),
-                });
+                }, extensions);
                 this.circuit.recordSuccess();
                 let content = "";
                 const toolCalls = [];
@@ -68,17 +70,19 @@ export class AnthropicProvider {
     async *stream(context, tools, extensions) {
         const system = context.systemText || undefined;
         const msgs = this.buildMessages(context);
+        const requestExtensions = this.requestExtensions(extensions);
         const toolBlocks = {};
         const nativeBlocks = {};
         let finalText = "";
         const finalToolCalls = [];
-        const stream = this.client.messages.stream({
+        const stream = this.streamMessage({
+            ...requestExtensions,
             model: this.model,
-            max_tokens: 8096,
+            max_tokens: typeof extensions?.max_tokens === "number" ? extensions.max_tokens : 8096,
             ...(system ? { system } : {}),
             messages: msgs,
             ...(tools.length ? { tools: this.buildTools(tools) } : {}),
-        });
+        }, extensions);
         for await (const evt of stream) {
             if (evt.type === "content_block_start") {
                 nativeBlocks[evt.index] = { ...evt.content_block };
@@ -121,6 +125,23 @@ export class AnthropicProvider {
         }
         this.rememberNativeBlocks({ content: finalText, toolCalls: finalToolCalls }, Object.keys(nativeBlocks).map(Number).sort((a, b) => a - b).map(index => nativeBlocks[index]));
     }
+    requestExtensions(extensions) {
+        return omitExtensionKeys(extensions, ["model", "messages", "system", "tools", "max_tokens", "stream"]);
+    }
+    hasBetas(extensions) {
+        const betas = extensions?.betas;
+        return Array.isArray(betas) && betas.length > 0;
+    }
+    createMessage(params, extensions) {
+        return this.hasBetas(extensions)
+            ? this.client.beta.messages.create(params)
+            : this.client.messages.create(params);
+    }
+    streamMessage(params, extensions) {
+        return (this.hasBetas(extensions)
+            ? this.client.beta.messages.stream(params)
+            : this.client.messages.stream(params));
+    }
     buildMessages(context) {
         return toAnthropicMessages(context.turns, message => this.nativeAssistantBlocks.get(this.assistantReplayKey(message)));
     }

package/dist/providers/base.d.ts

@@ -9,6 +9,7 @@ export declare class CircuitBreaker {
     recordSuccess(): void;
     recordFailure(): void;
 }
+export declare function omitExtensionKeys(extensions: Record<string, unknown> | undefined, keys: readonly string[]): Record<string, unknown>;
 export declare function normalizeToolCall(id: string, name: string, args: unknown): {
     id: string;
     name: string;

package/dist/providers/base.js

@@ -26,6 +26,12 @@ export class CircuitBreaker {
             this.openedAt = Date.now();
     }
 }
+export function omitExtensionKeys(extensions, keys) {
+    if (!extensions)
+        return {};
+    const blocked = new Set(keys);
+    return Object.fromEntries(Object.entries(extensions).filter(([key]) => !blocked.has(key)));
+}
 export function normalizeToolCall(id, name, args) {
     const n = String(name ?? "").trim();
     if (!n)

package/dist/providers/deepseek.d.ts

@@ -1,9 +1,10 @@
-import type { RenderedContext, ToolSchema, StreamEvent } from "../types.js";
+import type { Message, RenderedContext, ToolSchema, StreamEvent } from "../types.js";
 import { OpenAIChatProvider } from "./openai.js";
 export declare class DeepSeekProvider extends OpenAIChatProvider {
     constructor(apiKey: string, model?: "deepseek-v4-flash" | "deepseek-v4-pro", retry?: {
         maxRetries: number;
         baseDelay: number;
     }, baseURL?: string);
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
 }

package/dist/providers/deepseek.js

@@ -1,19 +1,34 @@
 import { OpenAIChatProvider } from "./openai.js";
 import { endpointProfiles } from "./profiles.js";
+import { omitExtensionKeys } from "./base.js";
 const DEEPSEEK_BASE = endpointProfiles["deepseek.openai"].baseURL;
 export class DeepSeekProvider extends OpenAIChatProvider {
     constructor(apiKey, model = "deepseek-v4-flash", retry, baseURL = DEEPSEEK_BASE) {
         super(apiKey, model, retry, baseURL);
     }
+    async complete(context, tools, extensions) {
+        const thinking = extensions?.thinking === false ? "disabled" : "enabled";
+        const reasoningEffort = extensions?.reasoningEffort === "max" ? "max" : "high";
+        return super.complete(context, tools, {
+            ...omitExtensionKeys(extensions, ["thinking", "reasoningEffort", "exposeReasoning", "extra_body", "reasoning_effort"]),
+            reasoning_effort: reasoningEffort,
+            extra_body: { thinking: { type: thinking } },
+        });
+    }
     async *stream(context, tools, extensions) {
         const exposeReasoning = extensions?.exposeReasoning ?? false;
         const thinking = extensions?.thinking === false ? "disabled" : "enabled";
         const reasoningEffort = extensions?.reasoningEffort === "max" ? "max" : "high";
         const msgs = this.chat.buildMessages(context);
         const toolCallBufs = {};
+        const emittedToolCallIndexes = new Set();
         let reasoningContent = "";
         let finalText = "";
         const stream = await this.client.chat.completions.create({
+            ...omitExtensionKeys(extensions, [
+                "model", "messages", "tools", "stream", "extra_body", "reasoning_effort",
+                "exposeReasoning", "thinking", "reasoningEffort",
+            ]),
             model: this.model,
             messages: msgs,
             ...(tools.length ? { tools: this.chat.buildTools(tools) } : {}),
@@ -48,7 +63,10 @@ export class DeepSeekProvider extends OpenAIChatProvider {
                     id: tb.id, name: tb.name, arguments: tb.argsBuf || "{}",
                 }));
                 this.chat.rememberReplayFields({ content: finalText, toolCalls }, { reasoning_content: reasoningContent });
-                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 || "{}");
@@ -56,9 +74,30 @@ export class DeepSeekProvider extends OpenAIChatProvider {
                     catch {
                         args = {};
                     }
+                    emittedToolCallIndexes.add(idx);
                     yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
                 }
             }
         }
+        const toolCalls = Object.values(toolCallBufs).map(tb => ({
+            id: tb.id, name: tb.name, arguments: tb.argsBuf || "{}",
+        }));
+        if (toolCalls.length) {
+            this.chat.rememberReplayFields({ content: finalText, toolCalls }, { reasoning_content: reasoningContent });
+        }
+        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 };
+        }
     }
 }

package/dist/providers/gemini.d.ts

@@ -9,6 +9,7 @@ export declare class GeminiProvider implements LLMProvider {
         maxRetries: number;
         baseDelay: number;
     }, baseURL?: string);
-    complete(context: RenderedContext, tools: ToolSchema[]): Promise<Message>;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    private modelExtensions;
 }

package/dist/providers/gemini.js

@@ -61,7 +61,7 @@ export class GeminiProvider {
         this.maxRetries = retry.maxRetries;
         this.baseDelay = retry.baseDelay;
     }
-    async complete(context, tools) {
+    async complete(context, tools, extensions) {
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");
         const system = context.systemText || undefined;
@@ -71,6 +71,7 @@ export class GeminiProvider {
         for (let i = 0; i < this.maxRetries; i++) {
             try {
                 const m = this.genAI.getGenerativeModel({
+                    ...this.modelExtensions(extensions),
                     model: this.model,
                     ...(system ? { systemInstruction: system } : {}),
                     ...(geminiTools.length ? { tools: geminiTools } : {}),
@@ -111,27 +112,34 @@ export class GeminiProvider {
         const contents = buildContents(context.turns);
         const geminiTools = buildTools(tools);
         const m = this.genAI.getGenerativeModel({
+            ...this.modelExtensions(extensions),
             model: this.model,
             ...(system ? { systemInstruction: system } : {}),
             ...(geminiTools.length ? { tools: geminiTools } : {}),
         });
         const result = await m.generateContentStream({ contents });
-        const toolCallBufs = {};
+        const toolCalls = [];
         for await (const chunk of result.stream) {
             for (const part of chunk.candidates?.[0]?.content.parts ?? []) {
                 if (part.text)
                     yield { type: "text_delta", delta: part.text };
                 else if (part.functionCall) {
                     const { name, args } = part.functionCall;
-                    toolCallBufs[name] = { name, args: args };
+                    toolCalls.push({ id: `call_${toolCalls.length + 1}`, name, args: args });
                 }
             }
         }
-        for (const [id, tc] of Object.entries(toolCallBufs)) {
-            yield { type: "tool_call", id, name: tc.name, arguments: tc.args };
+        for (const tc of toolCalls) {
+            yield { type: "tool_call", id: tc.id, name: tc.name, arguments: tc.args };
         }
         const usage = (await result.response).usageMetadata;
         if (usage?.totalTokenCount)
             yield { type: "usage", totalTokens: usage.totalTokenCount };
     }
+    modelExtensions(extensions) {
+        if (!extensions)
+            return {};
+        const { model: _model, systemInstruction: _systemInstruction, tools: _tools, ...rest } = extensions;
+        return rest;
+    }
 }

package/dist/providers/ollama.d.ts

@@ -4,6 +4,8 @@ export declare class OllamaProvider implements LLMProvider {
     private readonly baseUrl;
     constructor(model?: string, baseUrl?: string);
     private toOllamaMessages;
-    complete(context: RenderedContext, tools: ToolSchema[]): Promise<Message>;
+    private buildTools;
+    private requestExtensions;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
 }

package/dist/providers/ollama.js

@@ -1,4 +1,4 @@
-import { normalizeToolCall } from "./base.js";
+import { normalizeToolCall, omitExtensionKeys } from "./base.js";
 export class OllamaProvider {
     model;
     baseUrl;
@@ -22,11 +22,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 +52,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 +81,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

@@ -36,7 +36,8 @@ export declare class OpenAIResponsesProvider implements LLMProvider {
         baseDelay: number;
     }, baseURL?: string);
     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) {
@@ -116,7 +116,7 @@ export class OpenAIResponsesProvider {
     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 +124,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 +148,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 +206,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

@@ -13,7 +13,8 @@ export declare class OpenAIChatProvider implements LLMProvider {
         maxRetries: number;
         baseDelay: number;
     }, baseURL?: string);
-    complete(context: RenderedContext, tools: ToolSchema[]): Promise<Message>;
+    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,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 { OpenAIChatAdapter } from "./openai-chat.js";
 export class OpenAIChatProvider {
     model;
@@ -16,7 +16,7 @@ export class OpenAIChatProvider {
         this.maxRetries = retry.maxRetries;
         this.baseDelay = retry.baseDelay;
     }
-    async complete(context, tools) {
+    async complete(context, tools, extensions) {
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");
         const msgs = this.chat.buildMessages(context);
@@ -24,6 +24,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 +46,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 +76,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 +87,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 };

package/dist/providers/qwen.d.ts

@@ -13,6 +13,8 @@ export declare class QwenProvider implements LLMProvider {
         maxRetries: number;
         baseDelay: number;
     }, baseURL?: string);
-    complete(context: RenderedContext, tools: ToolSchema[]): Promise<Message>;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    private thinkingExtraBody;
+    private requestExtensions;
 }

package/dist/providers/qwen.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 { OpenAIChatAdapter } from "./openai-chat.js";
 import { endpointProfiles } from "./profiles.js";
 const QWEN_BASE = endpointProfiles["qwen.dashscope"].baseURL;
@@ -18,17 +18,20 @@ export class QwenProvider {
         this.maxRetries = retry.maxRetries;
         this.baseDelay = retry.baseDelay;
     }
-    async complete(context, tools) {
+    async complete(context, tools, extensions) {
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");
         const msgs = this.chat.buildMessages(context);
+        const extraBody = this.thinkingExtraBody(extensions);
         let lastErr;
         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) } : {}),
+                    ...(extraBody ? { extra_body: extraBody } : {}),
                 });
                 this.circuit.recordSuccess();
                 const choice = resp.choices[0].message;
@@ -45,22 +48,18 @@ export class QwenProvider {
         throw lastErr;
     }
     async *stream(context, tools, extensions) {
-        const enableThinking = Boolean(extensions?.enableThinking ?? extensions?.enable_thinking);
-        const thinkingBudget = extensions?.thinkingBudget ?? extensions?.thinking_budget;
         const msgs = this.chat.buildMessages(context);
         const toolCallBufs = {};
+        const emittedToolCallIndexes = new Set();
+        const extraBody = this.thinkingExtraBody(extensions);
         const stream = await this.client.chat.completions.create({
+            ...this.requestExtensions(extensions),
             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 } : {}),
-                },
-            } : {}),
+            ...(extraBody ? { extra_body: extraBody } : {}),
         });
         let totalTokens = 0;
         for await (const chunk of stream) {
@@ -85,7 +84,10 @@ export class QwenProvider {
                 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 || "{}");
@@ -93,11 +95,42 @@ export class QwenProvider {
                     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 };
     }
+    thinkingExtraBody(extensions) {
+        const enableThinking = Boolean(extensions?.enableThinking ?? extensions?.enable_thinking);
+        const thinkingBudget = extensions?.thinkingBudget ?? extensions?.thinking_budget;
+        if (!enableThinking)
+            return undefined;
+        return {
+            enable_thinking: true,
+            ...(typeof thinkingBudget === "number" ? { thinking_budget: thinkingBudget } : {}),
+        };
+    }
+    requestExtensions(extensions) {
+        return omitExtensionKeys(extensions, [
+            "model", "messages", "tools", "stream", "stream_options", "extra_body",
+            "enableThinking", "enable_thinking", "thinkingBudget", "thinking_budget",
+        ]);
+    }
 }

package/dist/tools/index.d.ts

@@ -1,9 +1,14 @@
-import type { ToolSchema, ToolResult } from "../types.js";
+import type { ToolChunk, ToolSchema, ToolResult } from "../types.js";
 export interface RegisteredTool {
     schema: ToolSchema;
-    execute(args: Record<string, unknown>): Promise<string>;
+    execute(args: Record<string, unknown>): Promise<string> | AsyncIterable<ToolChunk>;
 }
 export declare function tool(name: string, description: string, parameters: Record<string, unknown>, fn: (args: Record<string, unknown>) => Promise<string> | string): RegisteredTool;
+export declare function streamingTool(name: string, description: string, parameters: Record<string, unknown>, fn: (args: Record<string, unknown>) => AsyncIterable<ToolChunk>): RegisteredTool;
+export declare function isAsyncIterable<T>(value: unknown): value is AsyncIterable<T>;
+export declare function normalizeToolChunk(chunk: ToolChunk): Exclude<ToolChunk, string>;
+export declare function toolChunkText(chunk: ToolChunk): string;
+export declare function validateToolArguments(schemaJson: string, args: Record<string, unknown>): string | undefined;
 export declare function executeTools(calls: {
     id: string;
     name: string;

package/dist/tools/index.js

@@ -4,6 +4,80 @@ export function tool(name, description, parameters, fn) {
         async execute(args) { return fn(args); },
     };
 }
+export function streamingTool(name, description, parameters, fn) {
+    return {
+        schema: { name, description, parameters: JSON.stringify(parameters) },
+        execute(args) { return fn(args); },
+    };
+}
+export function isAsyncIterable(value) {
+    return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
+}
+export function normalizeToolChunk(chunk) {
+    return typeof chunk === "string" ? { type: "text", text: chunk } : chunk;
+}
+export function toolChunkText(chunk) {
+    const normalized = normalizeToolChunk(chunk);
+    return normalized.type === "text" ? normalized.text : "";
+}
+export function validateToolArguments(schemaJson, args) {
+    let schema;
+    try {
+        schema = JSON.parse(schemaJson);
+    }
+    catch {
+        return "invalid tool schema";
+    }
+    return validateValue(schema, args, "$", true);
+}
+function validateValue(schema, value, path, isRoot = false) {
+    const expectedType = schema.type;
+    if (typeof expectedType === "string") {
+        if (expectedType === "object") {
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                return `${path} must be object`;
+            const obj = value;
+            for (const required of schema.required ?? []) {
+                if (!(required in obj))
+                    return `${path}.${required} is required`;
+            }
+            const properties = schema.properties ?? {};
+            for (const [key, child] of Object.entries(properties)) {
+                if (key in obj) {
+                    const err = validateValue(child, obj[key], `${path}.${key}`);
+                    if (err)
+                        return err;
+                }
+            }
+        }
+        else if (expectedType === "array") {
+            if (!Array.isArray(value))
+                return `${path} must be array`;
+        }
+        else if (expectedType === "string") {
+            if (typeof value !== "string")
+                return `${path} must be string`;
+        }
+        else if (expectedType === "number") {
+            if (typeof value !== "number" || Number.isNaN(value))
+                return `${path} must be number`;
+        }
+        else if (expectedType === "integer") {
+            if (!Number.isInteger(value))
+                return `${path} must be integer`;
+        }
+        else if (expectedType === "boolean") {
+            if (typeof value !== "boolean")
+                return `${path} must be boolean`;
+        }
+    }
+    else if (isRoot && (!value || typeof value !== "object" || Array.isArray(value))) {
+        return `${path} must be object`;
+    }
+    if (Array.isArray(schema.enum) && !schema.enum.includes(value))
+        return `${path} must be one of enum values`;
+    return undefined;
+}
 export async function executeTools(calls, registry) {
     return Promise.all(calls.map(async (c) => {
         const t = registry.get(c.name);
@@ -11,7 +85,16 @@ export async function executeTools(calls, registry) {
             return { callId: c.id, output: `unknown tool: ${c.name}`, isError: true };
         try {
             const args = JSON.parse(c.arguments || "{}");
+            const validationError = validateToolArguments(t.schema.parameters, args);
+            if (validationError)
+                return { callId: c.id, output: `invalid arguments: ${validationError}`, isError: true };
             const output = await t.execute(args);
+            if (isAsyncIterable(output)) {
+                let combined = "";
+                for await (const chunk of output)
+                    combined += toolChunkText(chunk);
+                return { callId: c.id, output: combined, isError: false };
+            }
             return { callId: c.id, output, isError: false };
         }
         catch (err) {

package/dist/types.d.ts

@@ -69,6 +69,41 @@ export interface ToolCallEvent extends StreamEvent {
     name: string;
     arguments: Record<string, unknown>;
 }
+export type ToolChunk = string | {
+    type: "text";
+    text: string;
+} | {
+    type: "progress";
+    progress: number;
+    message?: string;
+} | {
+    type: "artifact";
+    artifactId: string;
+    mimeType?: string;
+    label?: string;
+} | {
+    type: "json_patch";
+    patch: Record<string, unknown>;
+} | {
+    type: "suspend";
+    suspensionId: string;
+    payload?: Record<string, unknown>;
+};
+export interface ToolDeltaEvent extends StreamEvent {
+    type: "tool_delta";
+    callId: string;
+    name: string;
+    /** Backward-compatible text projection when the chunk carries text. */
+    delta?: string;
+    chunk: Exclude<ToolChunk, string>;
+}
+export interface ToolSuspendEvent extends StreamEvent {
+    type: "tool_suspend";
+    callId: string;
+    name: string;
+    suspensionId: string;
+    payload?: Record<string, unknown>;
+}
 export interface ToolResultEvent extends StreamEvent {
     type: "tool_result";
     callId: string;
@@ -129,6 +164,6 @@ export interface RenderedContext {
 }
 export interface LLMProvider {
     createRunState?(): ProviderRunState;
-    complete(context: RenderedContext, tools: ToolSchema[]): Promise<Message>;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState): AsyncIterable<StreamEvent>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/sdk",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "DeepStrike Node.js SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -16,7 +16,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
-    "@deepstrike/core": "0.1.12",
+    "@deepstrike/core": "0.1.13",
     "@google/generative-ai": "^0.24.1",
     "openai": "^4.77.0"
   },