@deepstrike/sdk 0.1.13 → 0.1.14

package/dist/providers/profiles.js

@@ -1,4 +1,10 @@
 export const endpointProfiles = {
+    "anthropic.messages": {
+        id: "anthropic.messages",
+        providerId: "anthropic",
+        protocol: "anthropic-messages",
+        baseURL: "https://api.anthropic.com",
+    },
     "openai.chat": {
         id: "openai.chat",
         providerId: "openai",
@@ -43,146 +49,283 @@ export const endpointProfiles = {
     },
 };
 export const modelProfiles = {
-    "openai/gpt-4o": {
-        id: "openai/gpt-4o",
-        providerId: "openai",
-        defaultEndpointId: "openai.chat",
-        contextWindow: 128_000,
+    "anthropic/claude-opus-4-7": {
+        id: "anthropic/claude-opus-4-7",
+        providerId: "anthropic",
+        defaultEndpointId: "anthropic.messages",
+        contextWindow: 200_000,
+        modalities: { input: ["text", "image"], output: ["text"] },
+        tools: { supported: true },
+        reasoning: { supported: true, preserveAcrossToolTurns: true },
+        policy: { maxTurns: 50 },
+    },
+    "anthropic/claude-opus-4-6": {
+        id: "anthropic/claude-opus-4-6",
+        providerId: "anthropic",
+        defaultEndpointId: "anthropic.messages",
+        contextWindow: 200_000,
+        modalities: { input: ["text", "image"], output: ["text"] },
+        tools: { supported: true },
+        reasoning: { supported: true, preserveAcrossToolTurns: true },
+        policy: { maxTurns: 50 },
+    },
+    "anthropic/claude-sonnet-4-6": {
+        id: "anthropic/claude-sonnet-4-6",
+        providerId: "anthropic",
+        defaultEndpointId: "anthropic.messages",
+        contextWindow: 200_000,
+        modalities: { input: ["text", "image"], output: ["text"] },
+        tools: { supported: true },
+        reasoning: { supported: true, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 25 },
+    },
+    "anthropic/claude-haiku-4-5": {
+        id: "anthropic/claude-haiku-4-5",
+        providerId: "anthropic",
+        defaultEndpointId: "anthropic.messages",
+        contextWindow: 200_000,
         modalities: { input: ["text", "image"], output: ["text"] },
         tools: { supported: true },
         reasoning: { supported: false, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 15 },
+    },
+    // ── OpenAI ─────────────────────────────────────────────────────────────────
+    "openai/gpt-4o": {
+        id: "openai/gpt-4o", providerId: "openai", defaultEndpointId: "openai.chat",
+        contextWindow: 128_000,
+        modalities: { input: ["text", "image"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: false, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 25 },
     },
     "openai/gpt-4o-mini": {
-        id: "openai/gpt-4o-mini",
-        providerId: "openai",
-        defaultEndpointId: "openai.chat",
+        id: "openai/gpt-4o-mini", providerId: "openai", defaultEndpointId: "openai.chat",
         contextWindow: 128_000,
         modalities: { input: ["text", "image"], output: ["text"] },
-        tools: { supported: true },
-        reasoning: { supported: false, preserveAcrossToolTurns: false },
+        tools: { supported: true }, reasoning: { supported: false, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 15 },
+    },
+    "openai/gpt-4.1": {
+        id: "openai/gpt-4.1", providerId: "openai", defaultEndpointId: "openai.responses",
+        contextWindow: 1_047_576,
+        modalities: { input: ["text", "image"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: false, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 35 },
+    },
+    "openai/gpt-4.1-mini": {
+        id: "openai/gpt-4.1-mini", providerId: "openai", defaultEndpointId: "openai.responses",
+        contextWindow: 1_047_576,
+        modalities: { input: ["text", "image"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: false, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 20 },
+    },
+    "openai/gpt-4.1-nano": {
+        id: "openai/gpt-4.1-nano", providerId: "openai", defaultEndpointId: "openai.responses",
+        contextWindow: 1_047_576,
+        modalities: { input: ["text", "image"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: false, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 15 },
     },
     "openai/gpt-5": {
-        id: "openai/gpt-5",
-        providerId: "openai",
-        defaultEndpointId: "openai.responses",
+        id: "openai/gpt-5", providerId: "openai", defaultEndpointId: "openai.responses",
         modalities: { input: ["text", "image"], output: ["text"] },
-        tools: { supported: true },
-        reasoning: { supported: true, preserveAcrossToolTurns: true },
+        tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: true },
+        policy: { maxTurns: 50 },
     },
     "openai/gpt-5-mini": {
-        id: "openai/gpt-5-mini",
-        providerId: "openai",
-        defaultEndpointId: "openai.responses",
+        id: "openai/gpt-5-mini", providerId: "openai", defaultEndpointId: "openai.responses",
         modalities: { input: ["text", "image"], output: ["text"] },
-        tools: { supported: true },
-        reasoning: { supported: true, preserveAcrossToolTurns: true },
+        tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: true },
+        policy: { maxTurns: 25 },
     },
+    "openai/o3": {
+        id: "openai/o3", providerId: "openai", defaultEndpointId: "openai.responses",
+        modalities: { input: ["text", "image"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: true },
+        policy: { maxTurns: 50 },
+    },
+    "openai/o3-mini": {
+        id: "openai/o3-mini", providerId: "openai", defaultEndpointId: "openai.responses",
+        modalities: { input: ["text"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: true },
+        policy: { maxTurns: 25 },
+    },
+    "openai/o4-mini": {
+        id: "openai/o4-mini", providerId: "openai", defaultEndpointId: "openai.responses",
+        modalities: { input: ["text", "image"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: true },
+        policy: { maxTurns: 25 },
+    },
+    // ── MiniMax ────────────────────────────────────────────────────────────────
     "minimax/MiniMax-M2.7": {
-        id: "minimax/MiniMax-M2.7",
-        providerId: "minimax",
-        defaultEndpointId: "minimax.anthropic",
+        id: "minimax/MiniMax-M2.7", providerId: "minimax", defaultEndpointId: "minimax.anthropic",
         contextWindow: 204_800,
         modalities: { input: ["text"], output: ["text"] },
-        tools: { supported: true },
-        reasoning: { supported: true, preserveAcrossToolTurns: true },
+        tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: true },
+        policy: { maxTurns: 35 },
     },
     "minimax/MiniMax-M2.5": {
-        id: "minimax/MiniMax-M2.5",
-        providerId: "minimax",
-        defaultEndpointId: "minimax.anthropic",
+        id: "minimax/MiniMax-M2.5", providerId: "minimax", defaultEndpointId: "minimax.anthropic",
         contextWindow: 204_800,
         modalities: { input: ["text"], output: ["text"] },
-        tools: { supported: true },
-        reasoning: { supported: true, preserveAcrossToolTurns: true },
+        tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: true },
+        policy: { maxTurns: 25 },
+    },
+    "minimax/MiniMax-Text-01": {
+        id: "minimax/MiniMax-Text-01", providerId: "minimax", defaultEndpointId: "minimax.anthropic",
+        contextWindow: 1_000_000,
+        modalities: { input: ["text"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: false, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 20 },
+    },
+    // ── DeepSeek ───────────────────────────────────────────────────────────────
+    "deepseek/deepseek-chat": {
+        id: "deepseek/deepseek-chat", providerId: "deepseek", defaultEndpointId: "deepseek.openai",
+        contextWindow: 64_000,
+        modalities: { input: ["text"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: false, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 25 },
+    },
+    "deepseek/deepseek-reasoner": {
+        id: "deepseek/deepseek-reasoner", providerId: "deepseek", defaultEndpointId: "deepseek.openai",
+        contextWindow: 64_000,
+        modalities: { input: ["text"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: true },
+        policy: { maxTurns: 50 },
     },
     "deepseek/deepseek-v4-flash": {
-        id: "deepseek/deepseek-v4-flash",
-        providerId: "deepseek",
-        defaultEndpointId: "deepseek.openai",
+        id: "deepseek/deepseek-v4-flash", providerId: "deepseek", defaultEndpointId: "deepseek.openai",
         contextWindow: 1_000_000,
         modalities: { input: ["text"], output: ["text"] },
-        tools: { supported: true },
-        reasoning: { supported: true, preserveAcrossToolTurns: true },
+        tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: true },
+        policy: { maxTurns: 20 },
     },
     "deepseek/deepseek-v4-pro": {
-        id: "deepseek/deepseek-v4-pro",
-        providerId: "deepseek",
-        defaultEndpointId: "deepseek.openai",
+        id: "deepseek/deepseek-v4-pro", providerId: "deepseek", defaultEndpointId: "deepseek.openai",
         contextWindow: 1_000_000,
         modalities: { input: ["text"], output: ["text"] },
-        tools: { supported: true },
-        reasoning: { supported: true, preserveAcrossToolTurns: true },
+        tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: true },
+        policy: { maxTurns: 35 },
+    },
+    // ── Kimi ───────────────────────────────────────────────────────────────────
+    "kimi/moonshot-v1-8k": {
+        id: "kimi/moonshot-v1-8k", providerId: "kimi", defaultEndpointId: "kimi.openai",
+        contextWindow: 8_000,
+        modalities: { input: ["text"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: false, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 15 },
+    },
+    "kimi/moonshot-v1-32k": {
+        id: "kimi/moonshot-v1-32k", providerId: "kimi", defaultEndpointId: "kimi.openai",
+        contextWindow: 32_000,
+        modalities: { input: ["text"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: false, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 20 },
+    },
+    "kimi/moonshot-v1-128k": {
+        id: "kimi/moonshot-v1-128k", providerId: "kimi", defaultEndpointId: "kimi.openai",
+        contextWindow: 128_000,
+        modalities: { input: ["text", "image"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: false, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 30 },
     },
     "kimi/kimi-k2.5": {
-        id: "kimi/kimi-k2.5",
-        providerId: "kimi",
-        defaultEndpointId: "kimi.openai",
+        id: "kimi/kimi-k2.5", providerId: "kimi", defaultEndpointId: "kimi.openai",
         contextWindow: 256_000,
         modalities: { input: ["text", "image"], output: ["text"] },
-        tools: { supported: true },
-        reasoning: { supported: true, preserveAcrossToolTurns: false },
+        tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 30 },
     },
     "kimi/kimi-k2.6": {
-        id: "kimi/kimi-k2.6",
-        providerId: "kimi",
-        defaultEndpointId: "kimi.openai",
+        id: "kimi/kimi-k2.6", providerId: "kimi", defaultEndpointId: "kimi.openai",
         modalities: { input: ["text"], output: ["text"] },
-        tools: { supported: true },
-        reasoning: { supported: true, preserveAcrossToolTurns: false },
+        tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 35 },
     },
+    // ── Qwen ───────────────────────────────────────────────────────────────────
     "qwen/qwen-max": {
-        id: "qwen/qwen-max",
-        providerId: "qwen",
-        defaultEndpointId: "qwen.dashscope",
+        id: "qwen/qwen-max", providerId: "qwen", defaultEndpointId: "qwen.dashscope",
         contextWindow: 32_768,
         modalities: { input: ["text", "image"], output: ["text"] },
-        tools: { supported: true },
-        reasoning: { supported: false, preserveAcrossToolTurns: false },
+        tools: { supported: true }, reasoning: { supported: false, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 25 },
     },
     "qwen/qwen-plus": {
-        id: "qwen/qwen-plus",
-        providerId: "qwen",
-        defaultEndpointId: "qwen.dashscope",
+        id: "qwen/qwen-plus", providerId: "qwen", defaultEndpointId: "qwen.dashscope",
         contextWindow: 131_072,
         modalities: { input: ["text", "image"], output: ["text"] },
-        tools: { supported: true },
-        reasoning: { supported: false, preserveAcrossToolTurns: false },
+        tools: { supported: true }, reasoning: { supported: false, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 20 },
     },
     "qwen/qwq-plus": {
-        id: "qwen/qwq-plus",
-        providerId: "qwen",
-        defaultEndpointId: "qwen.dashscope",
+        id: "qwen/qwq-plus", providerId: "qwen", defaultEndpointId: "qwen.dashscope",
         contextWindow: 131_072,
         modalities: { input: ["text"], output: ["text"] },
-        tools: { supported: true },
-        reasoning: { supported: true, preserveAcrossToolTurns: false },
+        tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 40 },
     },
-    "gemini/gemini-2.0-flash": {
-        id: "gemini/gemini-2.0-flash",
-        providerId: "gemini",
-        defaultEndpointId: "gemini.google",
+    "qwen/qwen3-235b-a22b": {
+        id: "qwen/qwen3-235b-a22b", providerId: "qwen", defaultEndpointId: "qwen.dashscope",
+        contextWindow: 131_072,
+        modalities: { input: ["text"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 35 },
+    },
+    "qwen/qwen3-72b": {
+        id: "qwen/qwen3-72b", providerId: "qwen", defaultEndpointId: "qwen.dashscope",
+        contextWindow: 131_072,
+        modalities: { input: ["text"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 25 },
+    },
+    "qwen/qwen3-32b": {
+        id: "qwen/qwen3-32b", providerId: "qwen", defaultEndpointId: "qwen.dashscope",
+        contextWindow: 131_072,
+        modalities: { input: ["text"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 20 },
+    },
+    // ── Gemini ─────────────────────────────────────────────────────────────────
+    "gemini/gemini-2.5-pro": {
+        id: "gemini/gemini-2.5-pro", providerId: "gemini", defaultEndpointId: "gemini.google",
         contextWindow: 1_048_576,
         modalities: { input: ["text", "image", "audio"], output: ["text"] },
-        tools: { supported: true },
-        reasoning: { supported: false, preserveAcrossToolTurns: false },
+        tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 35 },
     },
     "gemini/gemini-2.5-flash": {
-        id: "gemini/gemini-2.5-flash",
-        providerId: "gemini",
-        defaultEndpointId: "gemini.google",
+        id: "gemini/gemini-2.5-flash", providerId: "gemini", defaultEndpointId: "gemini.google",
         contextWindow: 1_048_576,
         modalities: { input: ["text", "image", "audio"], output: ["text"] },
-        tools: { supported: true },
-        reasoning: { supported: true, preserveAcrossToolTurns: false },
+        tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 20 },
     },
-    "gemini/gemini-2.5-pro": {
-        id: "gemini/gemini-2.5-pro",
-        providerId: "gemini",
-        defaultEndpointId: "gemini.google",
+    "gemini/gemini-2.0-flash": {
+        id: "gemini/gemini-2.0-flash", providerId: "gemini", defaultEndpointId: "gemini.google",
         contextWindow: 1_048_576,
         modalities: { input: ["text", "image", "audio"], output: ["text"] },
-        tools: { supported: true },
-        reasoning: { supported: true, preserveAcrossToolTurns: false },
+        tools: { supported: true }, reasoning: { supported: false, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 15 },
+    },
+    "gemini/gemini-2.0-flash-lite": {
+        id: "gemini/gemini-2.0-flash-lite", providerId: "gemini", defaultEndpointId: "gemini.google",
+        contextWindow: 1_048_576,
+        modalities: { input: ["text", "image", "audio"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: false, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 10 },
+    },
+    "gemini/gemini-1.5-pro": {
+        id: "gemini/gemini-1.5-pro", providerId: "gemini", defaultEndpointId: "gemini.google",
+        contextWindow: 2_097_152,
+        modalities: { input: ["text", "image", "audio"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: false, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 30 },
+    },
+    "gemini/gemini-1.5-flash": {
+        id: "gemini/gemini-1.5-flash", providerId: "gemini", defaultEndpointId: "gemini.google",
+        contextWindow: 1_048_576,
+        modalities: { input: ["text", "image", "audio"], output: ["text"] },
+        tools: { supported: true }, reasoning: { supported: false, preserveAcrossToolTurns: false },
+        policy: { maxTurns: 15 },
     },
 };
 export function getModelProfile(id) {

package/dist/providers/qwen.d.ts

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

package/dist/providers/qwen.js

@@ -4,6 +4,18 @@ import { CircuitBreaker, omitExtensionKeys } from "./base.js";
 import { OpenAIChatAdapter } from "./openai-chat.js";
 import { endpointProfiles } from "./profiles.js";
 const QWEN_BASE = endpointProfiles["qwen.dashscope"].baseURL;
+const QWEN_POLICIES = {
+    "qwen-max": { maxTurns: 25 },
+    "qwen-plus": { maxTurns: 20 },
+    "qwen-turbo": { maxTurns: 15 },
+    "qwq-plus": { maxTurns: 40 },
+    "qwq-32b": { maxTurns: 35 },
+    "qwen3-235b-a22b": { maxTurns: 35 },
+    "qwen3-72b": { maxTurns: 25 },
+    "qwen3-32b": { maxTurns: 20 },
+    "qwen3-14b": { maxTurns: 15 },
+    "qwen3-8b": { maxTurns: 15 },
+};
 export class QwenProvider {
     model;
     client;
@@ -18,6 +30,9 @@ export class QwenProvider {
         this.maxRetries = retry.maxRetries;
         this.baseDelay = retry.baseDelay;
     }
+    runtimePolicy() {
+        return QWEN_POLICIES[this.model] ?? {};
+    }
     async complete(context, tools, extensions) {
         if (this.circuit.isOpen())
             throw new Error("Circuit breaker open");

package/dist/runtime/credential-vault.d.ts

@@ -0,0 +1,18 @@
+export interface CredentialVault {
+    get(key: string): Promise<string | undefined>;
+}
+export declare class EnvCredentialVault implements CredentialVault {
+    get(key: string): Promise<string | undefined>;
+}
+export declare class InMemoryCredentialVault implements CredentialVault {
+    private store;
+    constructor(init?: Record<string, string>);
+    set(key: string, value: string): this;
+    get(key: string): Promise<string | undefined>;
+}
+/** Tries each vault in order, returning the first defined value. */
+export declare class ChainedCredentialVault implements CredentialVault {
+    private readonly vaults;
+    constructor(vaults: CredentialVault[]);
+    get(key: string): Promise<string | undefined>;
+}

package/dist/runtime/credential-vault.js

@@ -0,0 +1,33 @@
+export class EnvCredentialVault {
+    async get(key) {
+        return process.env[key];
+    }
+}
+export class InMemoryCredentialVault {
+    store;
+    constructor(init) {
+        this.store = new Map(Object.entries(init ?? {}));
+    }
+    set(key, value) {
+        this.store.set(key, value);
+        return this;
+    }
+    async get(key) {
+        return this.store.get(key);
+    }
+}
+/** Tries each vault in order, returning the first defined value. */
+export class ChainedCredentialVault {
+    vaults;
+    constructor(vaults) {
+        this.vaults = vaults;
+    }
+    async get(key) {
+        for (const vault of this.vaults) {
+            const val = await vault.get(key);
+            if (val !== undefined)
+                return val;
+        }
+        return undefined;
+    }
+}

package/dist/runtime/execution-plane.d.ts

@@ -0,0 +1,38 @@
+import type { ToolCall, ToolSchema, StreamEvent, ToolSuspendEvent } from "../types.js";
+import type { RegisteredTool } from "../tools/index.js";
+import type { DreamStore } from "../memory/protocols.js";
+import type { KnowledgeSource } from "../knowledge/source.js";
+export interface RunContext {
+    agentId?: string;
+    skillDir?: string;
+    dreamStore?: DreamStore;
+    knowledgeSource?: KnowledgeSource;
+    governance?: {
+        setTime?(nowMs: bigint): void;
+        evaluate(name: string, argsJson: string): {
+            kind: string;
+            reason?: string;
+            retryAfterMs?: number;
+        };
+    };
+    onToolSuspend?: (event: ToolSuspendEvent) => Promise<unknown> | unknown;
+}
+export interface ExecutionPlane {
+    register(...tools: RegisteredTool[]): this;
+    unregister(name: string): this;
+    schemas(): ToolSchema[];
+    /**
+     * Execute a batch of calls. Yields StreamEvents during execution.
+     * Guarantees exactly one `tool_result` event per call in `calls`.
+     * The runner collects those events to build ToolResult[] for the kernel.
+     */
+    executeAll(calls: ToolCall[], ctx: RunContext): AsyncIterable<StreamEvent>;
+}
+export declare class LocalExecutionPlane implements ExecutionPlane {
+    private tools;
+    register(...tools: RegisteredTool[]): this;
+    unregister(name: string): this;
+    schemas(): ToolSchema[];
+    executeAll(calls: ToolCall[], ctx: RunContext): AsyncIterable<StreamEvent>;
+    private executeSingle;
+}

package/dist/runtime/execution-plane.js

@@ -0,0 +1,146 @@
+import { isAsyncIterable, normalizeToolChunk, toolChunkText, validateToolArguments } from "../tools/index.js";
+import { readSkillFile } from "../skills/loader.js";
+export class LocalExecutionPlane {
+    tools = new Map();
+    register(...tools) {
+        for (const t of tools)
+            this.tools.set(t.schema.name, t);
+        return this;
+    }
+    unregister(name) {
+        this.tools.delete(name);
+        return this;
+    }
+    schemas() {
+        return Array.from(this.tools.values()).map(t => t.schema);
+    }
+    async *executeAll(calls, ctx) {
+        // Governance pass — denied calls get an immediate tool_result so the kernel always
+        // receives a result for every call it dispatched.
+        const permitted = [];
+        for (const c of calls) {
+            if (ctx.governance) {
+                ctx.governance.setTime?.(BigInt(Date.now()));
+                const v = ctx.governance.evaluate(c.name, c.arguments);
+                if (v.kind === "deny") {
+                    yield { type: "error", message: `permission denied: ${c.name} — ${v.reason ?? ""}` };
+                    yield { type: "tool_result", callId: c.id, name: c.name, content: `permission denied: ${v.reason ?? ""}`, isError: true };
+                    continue;
+                }
+                if (v.kind === "rate_limited") {
+                    yield { type: "error", message: `rate limited: ${c.name}` };
+                    yield { type: "tool_result", callId: c.id, name: c.name, content: "rate limited", isError: true };
+                    continue;
+                }
+                if (v.kind === "ask_user") {
+                    yield { type: "permission_request", callId: c.id, toolName: c.name, arguments: c.arguments, reason: v.reason ?? "" };
+                    yield { type: "tool_result", callId: c.id, name: c.name, content: "awaiting user approval", isError: true };
+                    continue;
+                }
+            }
+            permitted.push(c);
+        }
+        const skillCalls = permitted.filter(c => c.name === "skill");
+        const memoryCalls = permitted.filter(c => c.name === "memory");
+        const knowledgeCalls = permitted.filter(c => c.name === "knowledge");
+        const regularCalls = permitted.filter(c => !["skill", "memory", "knowledge"].includes(c.name));
+        for (const c of skillCalls) {
+            const name = String(tryParseJson(c.arguments)?.name ?? "");
+            const content = ctx.skillDir ? await readSkillFile(ctx.skillDir, name) : null;
+            yield { type: "tool_result", callId: c.id, name: c.name, content: content ?? `Skill "${name}" not found.`, isError: !content };
+        }
+        for (const c of memoryCalls) {
+            const args = tryParseJson(c.arguments);
+            const topK = typeof args?.top_k === "number" ? args.top_k : 5;
+            const entries = (ctx.dreamStore && ctx.agentId)
+                ? await ctx.dreamStore.search(ctx.agentId, String(args?.query ?? ""), topK)
+                : [];
+            const content = entries.length
+                ? entries.map((e) => `[score=${e.score.toFixed(3)}] ${e.text}`).join("\n---\n")
+                : "No relevant memories found.";
+            yield { type: "tool_result", callId: c.id, name: c.name, content, isError: false };
+        }
+        for (const c of knowledgeCalls) {
+            const args = tryParseJson(c.arguments);
+            const topK = typeof args?.top_k === "number" ? args.top_k : 5;
+            const snippets = ctx.knowledgeSource
+                ? await ctx.knowledgeSource.retrieve(String(args?.query ?? ""), topK)
+                : [];
+            const content = snippets.length ? snippets.join("\n---\n") : "No relevant knowledge found.";
+            yield { type: "tool_result", callId: c.id, name: c.name, content, isError: false };
+        }
+        // Regular tools run concurrently; intermediate stream events (delta, suspend) are
+        // yielded as they arrive; the final tool_result is emitted when each call finishes.
+        if (regularCalls.length > 0) {
+            const active = regularCalls.map(call => {
+                const gen = this.executeSingle(call, ctx);
+                return { call, gen, pending: gen.next() };
+            });
+            while (active.length > 0) {
+                const { index, result } = await Promise.race(active.map((task, i) => task.pending.then(r => ({ index: i, result: r }))));
+                const task = active[index];
+                if (result.done) {
+                    const r = result.value;
+                    yield { type: "tool_result", callId: r.callId, name: task.call.name, content: r.output, isError: r.isError };
+                    active.splice(index, 1);
+                    continue;
+                }
+                yield result.value;
+                task.pending = task.gen.next();
+            }
+        }
+    }
+    async *executeSingle(call, ctx) {
+        const registered = this.tools.get(call.name);
+        if (!registered)
+            return { callId: call.id, output: `unknown tool: ${call.name}`, isError: true };
+        try {
+            const args = JSON.parse(call.arguments || "{}");
+            const err = validateToolArguments(registered.schema.parameters, args);
+            if (err)
+                return { callId: call.id, output: `invalid arguments: ${err}`, isError: true };
+            const output = await registered.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 chunk = normalizeToolChunk(next.value);
+                    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 (!ctx.onToolSuspend) {
+                            return { callId: call.id, output: `tool suspended without resume handler: ${chunk.suspensionId}`, isError: true };
+                        }
+                        resumeValue = await ctx.onToolSuspend(event);
+                        continue;
+                    }
+                    const delta = toolChunkText(next.value);
+                    combined += delta;
+                    yield { type: "tool_delta", callId: call.id, name: call.name, ...(delta ? { delta } : {}), 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 };
+        }
+    }
+}
+function tryParseJson(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return null;
+    }
+}