@deepstrike/wasm 0.1.10 → 0.1.14

package/README.md

@@ -1,6 +1,6 @@
 # DeepStrike WASM SDK
 
-Agent framework built on a Rust kernel compiled to WebAssembly. Runs in browsers, Cloudflare Workers, Deno Deploy, and Vercel Edge — anywhere that supports `fetch` and WASM.
+Runtime framework built on a Rust kernel compiled to WebAssembly. Runs in browsers, Cloudflare Workers, Deno Deploy, and Vercel Edge — anywhere that supports `fetch` and WASM.
 
 ## Install
 
@@ -15,7 +15,14 @@ The Rust kernel is distributed as a pre-built `.wasm` binary (`@deepstrike/wasm-
 ## Quick start
 
 ```typescript
-import { Agent, AnthropicProvider, tool } from "@deepstrike/wasm"
+import {
+  RuntimeRunner,
+  collectText,
+  InMemorySessionLog,
+  LocalExecutionPlane,
+  AnthropicProvider,
+  tool,
+} from "@deepstrike/wasm"
 
 const add = tool("add", "Add two numbers.", {
   type: "object",
@@ -23,20 +30,25 @@ const add = tool("add", "Add two numbers.", {
   required: ["x", "y"],
 }, async ({ x, y }) => String((x as number) + (y as number)))
 
-const agent = new Agent(
-  new AnthropicProvider(apiKey),
-  { maxTokens: 32_000, maxTurns: 10 },
-)
-agent.register(add)
+const plane = new LocalExecutionPlane()
+plane.register(add)
 
-const answer = await agent.run("What is 2 + 3?")
+const runner = new RuntimeRunner({
+  provider: new AnthropicProvider(apiKey),
+  sessionLog: new InMemorySessionLog(),
+  executionPlane: plane,
+  maxTokens: 32_000,
+  maxTurns: 10,
+})
+
+const answer = await collectText(runner.run({ sessionId: "demo", goal: "What is 2 + 3?" }))
 console.log(answer) // "5"
 ```
 
 Streaming:
 
 ```typescript
-for await (const event of agent.runStreaming("Summarize this page")) {
+for await (const event of runner.run({ sessionId: "demo", goal: "Summarize this page" })) {
   if (event.type === "text_delta") process.stdout.write(event.delta)
   else if (event.type === "tool_call") console.log(`\n[→ ${event.name}]`)
   else if (event.type === "done") console.log(`\ndone in ${event.iterations} turns (${event.status})`)
@@ -50,13 +62,13 @@ for await (const event of agent.runStreaming("Summarize this page")) {
 ```
 src/
 ├── index.ts          # Public exports
-├── agent.ts          # Agent — top-level entry point
+├── runtime/          # RuntimeRunner, SessionLog, ExecutionPlane
 ├── types.ts          # Shared type definitions
 ├── providers/        # LLM adapters (fetch-based SSE)
 ├── tools/            # tool() helper, executeTools (no fs/shell)
-├── memory/           # WorkingMemory + MemorySource/Extractor interfaces
+├── memory/           # WorkingMemory + DreamStore interfaces
 ├── knowledge/        # KnowledgeSource interface
-├── harness/          # SinglePassHarness, EvalLoopHarness, QualityGate
+├── harness/          # SinglePassHarness, HarnessLoop
 ├── signals/          # RuntimeSignal, SignalSource, ScheduledPrompt
 └── safety/           # PermissionManager
 ```
@@ -76,7 +88,7 @@ The kernel (`@deepstrike/wasm-kernel`, Rust/wasm-bindgen) owns:
 | Long-term storage | IndexedDB | KV / D1 | SQLite |
 | External signals | `postMessage` | event | any |
 
-The WASM SDK ships **no `readFile` built-in**. Tools must be pure JS / serializable data. Skill loading is delegated to the host (fetch from a URL, read from IndexedDB, etc.).
+The WASM SDK ships **no `readFile` built-in**. Tools must be pure JS / serializable data. Skills use `skillContentMap` on `RuntimeOptions` (no filesystem).
 
 ---
 
@@ -101,7 +113,11 @@ const provider = new AnthropicProvider("sk-...", "claude-opus-4-7")
 Thinking / reasoning:
 
 ```typescript
-for await (const event of agent.runStreaming("...", undefined, { enable_thinking: true })) {
+for await (const event of runner.run({
+  sessionId: "demo",
+  goal: "...",
+  extensions: { enable_thinking: true },
+})) {
   if (event.type === "thinking_delta") console.log(event.delta)
 }
 ```
@@ -113,7 +129,7 @@ for await (const event of agent.runStreaming("...", undefined, { enable_thinking
 Tools must be pure functions — no shell, no filesystem.
 
 ```typescript
-import { tool, Agent } from "@deepstrike/wasm"
+import { tool, LocalExecutionPlane } from "@deepstrike/wasm"
 
 const fetchUrl = tool("fetch_url", "Fetch a URL and return its text.", {
   type: "object",
@@ -124,7 +140,8 @@ const fetchUrl = tool("fetch_url", "Fetch a URL and return its text.", {
   return resp.text()
 })
 
-agent.register(fetchUrl)
+const plane = new LocalExecutionPlane()
+plane.register(fetchUrl)
 ```
 
 ---
@@ -132,12 +149,15 @@ agent.register(fetchUrl)
 ## Governance
 
 ```typescript
-import { Agent, AnthropicProvider, Governance } from "@deepstrike/wasm"
+import { RuntimeRunner, AnthropicProvider, Governance } from "@deepstrike/wasm"
 
 const gov = new Governance()
 gov.blockTool("dangerous_tool")
 
-const agent = new Agent(provider, {
+const runner = new RuntimeRunner({
+  provider: new AnthropicProvider(apiKey),
+  sessionLog: new InMemorySessionLog(),
+  executionPlane: new LocalExecutionPlane(),
   maxTokens: 32_000,
   governance: gov,
 })
@@ -171,7 +191,10 @@ class VectorSearch implements KnowledgeSource {
   }
 }
 
-const agent = new Agent(provider, {
+const runner = new RuntimeRunner({
+  provider,
+  sessionLog: new InMemorySessionLog(),
+  executionPlane: new LocalExecutionPlane(),
   maxTokens: 32_000,
   maxTurns: 10,
   knowledgeSource: new VectorSearch(),
@@ -186,12 +209,12 @@ const agent = new Agent(provider, {
 import { SinglePassHarness, HarnessLoop } from "@deepstrike/wasm"
 
 // Single pass — always passes
-const harness = new SinglePassHarness(agent)
+const harness = new SinglePassHarness(runner)
 const outcome = await harness.run({ goal: "Write a haiku" })
 console.log(outcome.result)
 
 // Eval loop — LLM-judges the output; retries up to 3 times
-const loop = new HarnessLoop(agent, evalProvider, { maxAttempts: 3 })
+const loop = new HarnessLoop(runner, evalProvider, { maxAttempts: 3 })
 for await (const event of loop.runStreaming({
   goal: "Write a haiku",
   criteria: [
@@ -212,7 +235,7 @@ import { ScheduledPrompt } from "@deepstrike/wasm"
 import type { SignalSource, RuntimeSignal } from "@deepstrike/wasm"
 
 // Interrupt from a UI button
-document.getElementById("stop")!.onclick = () => agent.interrupt()
+document.getElementById("stop")!.onclick = () => runner.interrupt()
 
 // Convert a scheduled prompt to a RuntimeSignal
 const prompt = new ScheduledPrompt("Daily standup summary", 1_700_000_000_000)
@@ -260,14 +283,29 @@ Modes: `DEFAULT` (evaluate grants), `PLAN` (block all), `AUTO` (allow all).
 
 ```typescript
 import init from "@deepstrike/wasm-kernel"
-import { Agent, AnthropicProvider } from "@deepstrike/wasm"
+import {
+  RuntimeRunner,
+  collectText,
+  InMemorySessionLog,
+  LocalExecutionPlane,
+  AnthropicProvider,
+} from "@deepstrike/wasm"
 import wasmBinary from "@deepstrike/wasm-kernel/deepstrike_wasm_bg.wasm"
 
 export default {
   async fetch(request: Request, env: Env): Promise<Response> {
     await init(wasmBinary)
-    const agent = new Agent(new AnthropicProvider(env.ANTHROPIC_KEY), { maxTokens: 32_000, maxTurns: 10 })
-    const result = await agent.run(await request.text())
+    const runner = new RuntimeRunner({
+      provider: new AnthropicProvider(env.ANTHROPIC_KEY),
+      sessionLog: new InMemorySessionLog(),
+      executionPlane: new LocalExecutionPlane(),
+      maxTokens: 32_000,
+      maxTurns: 10,
+    })
+    const result = await collectText(runner.run({
+      sessionId: crypto.randomUUID(),
+      goal: await request.text(),
+    }))
     return new Response(result)
   },
 }
@@ -277,10 +315,16 @@ export default {
 
 ```typescript
 import init from "@deepstrike/wasm-kernel"
-import { Agent, AnthropicProvider } from "@deepstrike/wasm"
+import { RuntimeRunner, InMemorySessionLog, LocalExecutionPlane, AnthropicProvider } from "@deepstrike/wasm"
 
 await init()
-const agent = new Agent(new AnthropicProvider(import.meta.env.VITE_ANTHROPIC_KEY), { maxTokens: 32_000, maxTurns: 10 })
+const runner = new RuntimeRunner({
+  provider: new AnthropicProvider(import.meta.env.VITE_ANTHROPIC_KEY),
+  sessionLog: new InMemorySessionLog(),
+  executionPlane: new LocalExecutionPlane(),
+  maxTokens: 32_000,
+  maxTurns: 10,
+})
 ```
 
 ---
@@ -291,6 +335,7 @@ const agent = new Agent(new AnthropicProvider(import.meta.env.VITE_ANTHROPIC_KEY
 |------------|--------|
 | `text_delta` | `delta: string` |
 | `thinking_delta` | `delta: string` |
+| `usage` | `totalTokens: number` |
 | `tool_call` | `id, name, arguments` |
 | `tool_result` | `callId, name, content, isError` |
 | `done` | `iterations, totalTokens, status` |

package/dist/harness/index.d.ts

@@ -1,4 +1,4 @@
-import type { Agent } from "../agent.js";
+import type { RuntimeRunner } from "../runtime/runner.js";
 export interface Criterion {
     text: string;
     required: boolean;
@@ -58,17 +58,17 @@ export type HarnessEvent = {
     type: "max_attempts_reached";
 };
 export declare class SinglePassHarness {
-    private agent;
-    constructor(agent: Agent);
+    private runner;
+    constructor(runner: RuntimeRunner);
     run(request: HarnessRequest): Promise<HarnessOutcome>;
 }
 export interface HarnessLoopOptions {
     maxAttempts?: number;
 }
 export declare class HarnessLoop {
-    private agent;
+    private runner;
     private evalProvider;
     private maxAttempts;
-    constructor(agent: Agent, evalProvider: import("../types.js").LLMProvider, options?: HarnessLoopOptions);
+    constructor(runner: RuntimeRunner, evalProvider: import("../types.js").LLMProvider, options?: HarnessLoopOptions);
     runStreaming(request: HarnessRequest): AsyncIterable<HarnessEvent>;
 }

package/dist/harness/index.js

@@ -1,7 +1,8 @@
-async function runOnce(agent, goal, req) {
+async function runOnce(runner, req) {
     let text = "";
     let done;
-    for await (const evt of agent.runStreaming(goal, (req.criteria ?? []).map(c => c.text), req.extensions)) {
+    const sessionId = crypto.randomUUID();
+    for await (const evt of runner.run({ sessionId, goal: req.goal, criteria: req.criteria?.map(c => c.text), extensions: req.extensions })) {
         if (evt.type === "text_delta")
             text += evt.delta;
         else if (evt.type === "done")
@@ -10,20 +11,20 @@ async function runOnce(agent, goal, req) {
     return { result: text, passed: false, iterations: done?.iterations ?? 0, totalTokens: done?.totalTokens ?? 0, status: done?.status ?? "error" };
 }
 export class SinglePassHarness {
-    agent;
-    constructor(agent) {
-        this.agent = agent;
+    runner;
+    constructor(runner) {
+        this.runner = runner;
     }
     async run(request) {
-        return { ...await runOnce(this.agent, request.goal, request), passed: true };
+        return { ...await runOnce(this.runner, request), passed: true };
     }
 }
 export class HarnessLoop {
-    agent;
+    runner;
     evalProvider;
     maxAttempts;
-    constructor(agent, evalProvider, options = {}) {
-        this.agent = agent;
+    constructor(runner, evalProvider, options = {}) {
+        this.runner = runner;
         this.evalProvider = evalProvider;
         this.maxAttempts = options.maxAttempts ?? 3;
     }
@@ -36,8 +37,9 @@ export class HarnessLoop {
         let lastTotalTokens = 0;
         let lastStatus = "error";
         let lastResult = "";
+        const sessionId = crypto.randomUUID();
         for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
-            for await (const evt of this.agent.runStreaming(currentGoal, criteria.map(c => c.text), request.extensions)) {
+            for await (const evt of this.runner.run({ sessionId, goal: currentGoal, criteria: criteria.map(c => c.text), extensions: request.extensions })) {
                 if (evt.type === "text_delta") {
                     lastResult += evt.delta;
                     yield { type: "token", text: evt.delta };
@@ -64,7 +66,11 @@ export class HarnessLoop {
             if (evalAction.kind !== "evaluate")
                 break;
             let evalText = "";
-            for await (const evt of this.evalProvider.stream((evalAction.messages ?? []), [], undefined)) {
+            const evalContext = {
+                systemText: "",
+                turns: (evalAction.messages ?? []),
+            };
+            for await (const evt of this.evalProvider.stream(evalContext, [], undefined)) {
                 if (evt.type === "text_delta")
                     evalText += evt.delta;
             }
@@ -75,7 +81,7 @@ export class HarnessLoop {
                 passed: doneAction.passed ?? false,
                 overallScore: doneAction.overallScore ?? 0,
                 feedback: doneAction.feedback ?? "",
-                details: doneAction.details ?? [],
+                details: (doneAction.details ?? []),
             };
             if (verdict.passed) {
                 yield { type: "done", verdict, iterations: lastIterations, totalTokens: lastTotalTokens, status: lastStatus };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export { Agent } from "./agent.js";
-export type { AgentOptions, SkillMetadata } from "./agent.js";
+export { RuntimeRunner, collectText, InMemorySessionLog, LocalExecutionPlane, } from "./runtime/index.js";
+export type { RuntimeOptions, SessionEvent, SessionLog, RunContext, ExecutionPlane, } from "./runtime/index.js";
 export { Governance } from "./governance.js";
 export type { GovernanceVerdict } from "./governance.js";
 export { AnthropicProvider } from "./providers/anthropic.js";
@@ -7,7 +7,7 @@ export { OpenAIProvider, QwenProvider, DeepSeekProvider, MiniMaxProvider, KimiPr
 export { tool, executeTools } from "./tools/index.js";
 export type { RegisteredTool } from "./tools/index.js";
 export { WorkingMemory } from "./memory/index.js";
-export type { DreamStore, DreamResult, SessionData, SessionMessage, MemoryEntry, CurationResult, CurationStats, } from "./memory/index.js";
+export type { DreamStore, DreamResult, SessionStore, SessionData, SessionMessage, MemoryEntry, CurationResult, CurationStats, } from "./memory/index.js";
 export type { KnowledgeSource } from "./knowledge/index.js";
 export { SinglePassHarness, HarnessLoop } from "./harness/index.js";
 export type { HarnessRequest, HarnessOutcome, HarnessLoopOptions } from "./harness/index.js";
@@ -15,4 +15,4 @@ export { ScheduledPrompt } from "./signals/index.js";
 export type { RuntimeSignal, SignalSource } from "./signals/index.js";
 export { PermissionManager, PermissionMode } from "./safety/index.js";
 export type { PermissionDecision } from "./safety/index.js";
-export type { Message, ToolCall, ToolResult, ToolSchema, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, LLMProvider, } from "./types.js";
+export type { Message, ToolCall, ToolResult, ToolSchema, RenderedContext, ProviderRunState, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, LLMProvider, } from "./types.js";

package/dist/index.js

@@ -1,4 +1,4 @@
-export { Agent } from "./agent.js";
+export { RuntimeRunner, collectText, InMemorySessionLog, LocalExecutionPlane, } from "./runtime/index.js";
 export { Governance } from "./governance.js";
 export { AnthropicProvider } from "./providers/anthropic.js";
 export { OpenAIProvider, QwenProvider, DeepSeekProvider, MiniMaxProvider, KimiProvider } from "./providers/openai.js";

package/dist/memory/index.d.ts

@@ -54,3 +54,7 @@ export interface DreamStore {
     /** Persist a completed session for future consolidation via `Agent.dream()`. */
     saveSession(data: SessionData): Promise<void>;
 }
+export interface SessionStore {
+    loadSession(sessionId: string): Promise<SessionData | undefined>;
+    saveSession(data: SessionData): Promise<void>;
+}

package/dist/providers/anthropic.d.ts

@@ -1,8 +1,9 @@
-import type { Message, ToolSchema, StreamEvent, LLMProvider } from "../types.js";
+import type { RenderedContext, ToolSchema, StreamEvent, LLMProvider, Message } from "../types.js";
 export declare class AnthropicProvider implements LLMProvider {
     private readonly apiKey;
     private readonly model;
     private readonly maxTokens;
     constructor(apiKey: string, model?: string, maxTokens?: number);
-    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>;
 }

package/dist/providers/anthropic.js

@@ -1,3 +1,4 @@
+import { collectStreamMessage, toAnthropicMessages } from "./base.js";
 function buildAnthropicTools(tools) {
     return tools.map(t => ({ name: t.name, description: t.description, input_schema: JSON.parse(t.parameters) }));
 }
@@ -10,9 +11,12 @@ export class AnthropicProvider {
         this.model = model;
         this.maxTokens = maxTokens;
     }
-    async *stream(messages, tools, extensions) {
-        const system = messages.filter(m => m.role === "system").map(m => m.content).join("\n\n");
-        const msgs = messages.filter(m => m.role !== "system").map(m => ({ role: m.role, content: m.content }));
+    async complete(context, tools, extensions) {
+        return collectStreamMessage(this.stream(context, tools, extensions));
+    }
+    async *stream(context, tools, extensions) {
+        const system = context.systemText || undefined;
+        const msgs = toAnthropicMessages(context);
         const body = {
             model: this.model,
             max_tokens: this.maxTokens,
@@ -54,7 +58,16 @@ export class AnthropicProvider {
                     return;
                 try {
                     const evt = JSON.parse(data);
-                    if (evt.type === "content_block_start") {
+                    if (evt.type === "message_start" || evt.type === "message_delta") {
+                        const usage = (evt.usage ?? evt.message?.usage);
+                        if (usage?.input_tokens != null) {
+                            yield {
+                                type: "usage",
+                                totalTokens: usage.input_tokens + (usage.output_tokens ?? 0),
+                            };
+                        }
+                    }
+                    else if (evt.type === "content_block_start") {
                         const cb = evt.content_block;
                         if (cb.type === "tool_use")
                             toolBlocks[evt.index] = { id: cb.id, name: cb.name, argsBuf: "" };

package/dist/providers/base.d.ts

@@ -0,0 +1,16 @@
+import type { Message, RenderedContext } from "../types.js";
+/** Build OpenAI-compatible chat messages from a RenderedContext. */
+export declare function toOpenAIMessages(context: RenderedContext): Array<Record<string, unknown>>;
+/** Anthropic messages array (system is a separate top-level param). */
+export declare function toAnthropicMessages(context: RenderedContext): Array<{
+    role: string;
+    content: string;
+}>;
+/** Collect a non-streaming assistant Message from stream events. */
+export declare function collectStreamMessage(stream: AsyncIterable<{
+    type: string;
+    delta?: string;
+    id?: string;
+    name?: string;
+    arguments?: Record<string, unknown>;
+}>): Promise<Message>;

package/dist/providers/base.js

@@ -0,0 +1,42 @@
+/** Build OpenAI-compatible chat messages from a RenderedContext. */
+export function toOpenAIMessages(context) {
+    const messages = [];
+    if (context.systemText) {
+        messages.push({ role: "system", content: context.systemText });
+    }
+    for (const msg of context.turns) {
+        if (msg.role === "tool") {
+            messages.push({ role: "tool", content: msg.content });
+            continue;
+        }
+        const next = { role: msg.role, content: msg.content };
+        if (msg.role === "assistant" && msg.toolCalls?.length) {
+            next.tool_calls = msg.toolCalls.map(tc => ({
+                id: tc.id,
+                type: "function",
+                function: { name: tc.name, arguments: tc.arguments },
+            }));
+        }
+        messages.push(next);
+    }
+    return messages;
+}
+/** Anthropic messages array (system is a separate top-level param). */
+export function toAnthropicMessages(context) {
+    return context.turns
+        .filter(m => m.role !== "system")
+        .map(m => ({ role: m.role, content: m.content }));
+}
+/** Collect a non-streaming assistant Message from stream events. */
+export async function collectStreamMessage(stream) {
+    let content = "";
+    const toolCalls = [];
+    for await (const evt of stream) {
+        if (evt.type === "text_delta" && evt.delta)
+            content += evt.delta;
+        else if (evt.type === "tool_call" && evt.id && evt.name) {
+            toolCalls.push({ id: evt.id, name: evt.name, arguments: JSON.stringify(evt.arguments ?? {}) });
+        }
+    }
+    return { role: "assistant", content, ...(toolCalls.length ? { toolCalls } : {}) };
+}

package/dist/providers/openai.d.ts

@@ -1,4 +1,4 @@
-import type { Message, ToolSchema, StreamEvent, LLMProvider } from "../types.js";
+import type { RenderedContext, ToolSchema, StreamEvent, LLMProvider, Message } from "../types.js";
 export declare class OpenAIProvider implements LLMProvider {
     protected readonly apiKey: string;
     protected readonly model: string;
@@ -12,20 +12,21 @@ export declare class OpenAIProvider implements LLMProvider {
             parameters: any;
         };
     }[];
-    protected streamInner(messages: Message[], tools: ToolSchema[], extraBody: Record<string, unknown>, exposeReasoning?: boolean): AsyncIterable<StreamEvent>;
-    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
+    protected streamInner(context: RenderedContext, tools: ToolSchema[], extraBody: Record<string, unknown>, exposeReasoning?: boolean): AsyncIterable<StreamEvent>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
 }
 export declare class QwenProvider extends OpenAIProvider {
     constructor(apiKey: string, model?: string);
-    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
 }
 export declare class DeepSeekProvider extends OpenAIProvider {
     constructor(apiKey: string, model?: string);
-    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
 }
 export declare class MiniMaxProvider extends OpenAIProvider {
     constructor(apiKey: string, model?: string);
-    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
 }
 export declare class KimiProvider extends OpenAIProvider {
     constructor(apiKey: string, model?: string);

package/dist/providers/openai.js

@@ -1,3 +1,4 @@
+import { collectStreamMessage, toOpenAIMessages } from "./base.js";
 const DEEPSEEK_REASONERS = new Set(["deepseek-reasoner", "deepseek-r1"]);
 const MINIMAX_REASONERS = new Set(["MiniMax-M1", "minimax-m1"]);
 // OpenAI-compatible provider — works for OpenAI, Qwen (DashScope), DeepSeek, MiniMax, Kimi
@@ -13,11 +14,13 @@ export class OpenAIProvider {
     buildTools(tools) {
         return tools.map(t => ({ type: "function", function: { name: t.name, description: t.description, parameters: JSON.parse(t.parameters) } }));
     }
-    async *streamInner(messages, tools, extraBody, exposeReasoning = false) {
-        const msgs = messages.map(m => ({ role: m.role, content: m.content }));
+    async complete(context, tools, extensions) {
+        return collectStreamMessage(this.stream(context, tools, extensions));
+    }
+    async *streamInner(context, tools, extraBody, exposeReasoning = false) {
         const body = {
             model: this.model,
-            messages: msgs,
+            messages: toOpenAIMessages(context),
             stream: true,
             ...(tools.length ? { tools: this.buildTools(tools) } : {}),
             ...extraBody,
@@ -76,16 +79,16 @@ export class OpenAIProvider {
             yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
         }
     }
-    async *stream(messages, tools, extensions) {
+    async *stream(context, tools, extensions) {
         const { expose_reasoning: _, exposeReasoning: __, ...passthrough } = extensions ?? {};
-        yield* this.streamInner(messages, tools, passthrough);
+        yield* this.streamInner(context, tools, passthrough);
     }
 }
 export class QwenProvider extends OpenAIProvider {
     constructor(apiKey, model = "qwen-max") {
         super(apiKey, model, "https://dashscope.aliyuncs.com/compatible-mode/v1");
     }
-    async *stream(messages, tools, extensions) {
+    async *stream(context, tools, extensions) {
         const enableThinking = Boolean(extensions?.enableThinking);
         const thinkingBudget = extensions?.thinkingBudget;
         const { enableThinking: _, thinkingBudget: __, expose_reasoning: ___, exposeReasoning: ____, ...passthrough } = extensions ?? {};
@@ -93,31 +96,31 @@ export class QwenProvider extends OpenAIProvider {
             ...passthrough,
             ...(enableThinking ? { enable_thinking: true, ...(thinkingBudget ? { thinking_budget: thinkingBudget } : {}) } : {}),
         };
-        yield* this.streamInner(messages, tools, extra, enableThinking);
+        yield* this.streamInner(context, tools, extra, enableThinking);
     }
 }
 export class DeepSeekProvider extends OpenAIProvider {
     constructor(apiKey, model = "deepseek-chat") {
         super(apiKey, model, "https://api.deepseek.com/v1");
     }
-    async *stream(messages, tools, extensions) {
+    async *stream(context, tools, extensions) {
         const exposeReasoning = Boolean(extensions?.exposeReasoning);
         const isReasoner = DEEPSEEK_REASONERS.has(this.model);
         const filteredTools = isReasoner ? [] : tools;
         const { exposeReasoning: _, expose_reasoning: __, ...passthrough } = extensions ?? {};
-        yield* this.streamInner(messages, filteredTools, passthrough, exposeReasoning);
+        yield* this.streamInner(context, filteredTools, passthrough, exposeReasoning);
     }
 }
 export class MiniMaxProvider extends OpenAIProvider {
     constructor(apiKey, model = "MiniMax-Text-01") {
         super(apiKey, model, "https://api.minimax.chat/v1");
     }
-    async *stream(messages, tools, extensions) {
+    async *stream(context, tools, extensions) {
         const exposeReasoning = Boolean(extensions?.exposeReasoning);
         const isReasoner = MINIMAX_REASONERS.has(this.model);
         const filteredTools = isReasoner ? [] : tools;
         const { exposeReasoning: _, expose_reasoning: __, ...passthrough } = extensions ?? {};
-        yield* this.streamInner(messages, filteredTools, passthrough, exposeReasoning);
+        yield* this.streamInner(context, filteredTools, passthrough, exposeReasoning);
     }
 }
 export class KimiProvider extends OpenAIProvider {

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

@@ -0,0 +1,33 @@
+import type { ToolCall, ToolSchema, StreamEvent } from "../types.js";
+import type { RegisteredTool } from "../tools/index.js";
+import type { DreamStore } from "../memory/index.js";
+import type { KnowledgeSource } from "../knowledge/index.js";
+import type { Governance } from "../governance.js";
+export interface ToolSuspendEvent {
+    type: "tool_suspend";
+    callId: string;
+    name: string;
+    suspensionId: string;
+    payload?: unknown;
+}
+export interface RunContext {
+    agentId?: string;
+    skillContentMap?: Map<string, string>;
+    dreamStore?: DreamStore;
+    knowledgeSource?: KnowledgeSource;
+    governance?: Governance;
+    onToolSuspend?: (event: ToolSuspendEvent) => Promise<unknown> | unknown;
+}
+export interface ExecutionPlane {
+    register(...tools: RegisteredTool[]): this;
+    unregister(name: string): this;
+    schemas(): ToolSchema[];
+    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>;
+}