@deepstrike/sdk 0.1.11 → 0.1.13

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,14 +16,15 @@ export class OpenAIChatProvider {
         this.maxRetries = retry.maxRetries;
         this.baseDelay = retry.baseDelay;
     }
-    async complete(messages, tools) {
+    async complete(context, tools, extensions) {
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");
-        const msgs = this.chat.buildMessages(messages);
+        const msgs = this.chat.buildMessages(context);
         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) } : {}),
@@ -42,10 +43,12 @@ export class OpenAIChatProvider {
         }
         throw lastErr;
     }
-    async *stream(messages, tools, extensions) {
-        const msgs = this.chat.buildMessages(messages);
+    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

@@ -1,5 +1,5 @@
 import OpenAI from "openai";
-import type { LLMProvider, Message, StreamEvent, ToolSchema } from "../types.js";
+import type { LLMProvider, Message, RenderedContext, StreamEvent, ToolSchema } from "../types.js";
 import { CircuitBreaker } from "./base.js";
 import { OpenAIChatAdapter } from "./openai-chat.js";
 export declare class QwenProvider implements LLMProvider {
@@ -13,6 +13,8 @@ export declare class QwenProvider implements LLMProvider {
         maxRetries: number;
         baseDelay: number;
     }, baseURL?: string);
-    complete(messages: Message[], tools: ToolSchema[]): Promise<Message>;
-    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    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(messages, tools) {
+    async complete(context, tools, extensions) {
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");
-        const msgs = this.chat.buildMessages(messages);
+        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;
@@ -44,23 +47,19 @@ export class QwenProvider {
         }
         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);
+    async *stream(context, tools, extensions) {
+        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;
@@ -117,8 +152,18 @@ export interface RetryConfig {
  * Responses `previous_response_id` without leaking those semantics into the kernel.
  */
 export type ProviderRunState = Record<string, unknown>;
+/** Structured render output produced by the kernel for each LLM call. */
+export interface RenderedContext {
+    /** Combined system text: system partition + dashboard (when non-empty).
+     *  Anthropic → `system` param · OpenAI → messages[0] system role ·
+     *  Gemini → `systemInstruction`. */
+    systemText: string;
+    /** Strictly alternating user / assistant / tool turns.
+     *  Working-partition signals are already folded into the first user turn. */
+    turns: Message[];
+}
 export interface LLMProvider {
     createRunState?(): ProviderRunState;
-    complete(messages: Message[], tools: ToolSchema[]): Promise<Message>;
-    stream(messages: Message[], 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>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/sdk",
-  "version": "0.1.11",
+  "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.11",
+    "@deepstrike/core": "0.1.13",
     "@google/generative-ai": "^0.24.1",
     "openai": "^4.77.0"
   },