@deepstrike/wasm 0.1.11 → 0.1.15

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>;
+}

package/dist/runtime/execution-plane.js

@@ -0,0 +1,108 @@
+function stripFrontmatter(content) {
+    const s = content.trimStart();
+    if (!s.startsWith("---"))
+        return s;
+    const rest = s.slice(3);
+    const end = rest.indexOf("\n---");
+    return end >= 0 ? rest.slice(end + 4).trimStart() : s;
+}
+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) {
+        const permitted = [];
+        for (const c of calls) {
+            if (ctx.governance) {
+                ctx.governance.setTime(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 args = tryParseJson(c.arguments);
+            const name = String(args?.name ?? "");
+            const raw = ctx.skillContentMap?.get(name);
+            const content = raw != null ? stripFrontmatter(raw) : null;
+            yield {
+                type: "tool_result",
+                callId: c.id,
+                name: c.name,
+                content: content ?? `Skill "${name}" not found.`,
+                isError: content == null,
+            };
+        }
+        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 };
+        }
+        for (const call of regularCalls) {
+            const registered = this.tools.get(call.name);
+            if (!registered) {
+                yield { type: "tool_result", callId: call.id, name: call.name, content: `unknown tool: ${call.name}`, isError: true };
+                continue;
+            }
+            try {
+                const args = JSON.parse(call.arguments || "{}");
+                const output = await registered.execute(args);
+                yield { type: "tool_result", callId: call.id, name: call.name, content: String(output), isError: false };
+            }
+            catch (err) {
+                yield { type: "tool_result", callId: call.id, name: call.name, content: String(err), isError: true };
+            }
+        }
+    }
+}
+function tryParseJson(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,7 @@
+export type { SessionEvent, SessionLog } from "./session-log.js";
+export { InMemorySessionLog } from "./session-log.js";
+export type { RunContext, ExecutionPlane } from "./execution-plane.js";
+export { LocalExecutionPlane } from "./execution-plane.js";
+export type { RuntimeOptions } from "./runner.js";
+export { RuntimeRunner, collectText } from "./runner.js";
+export { getKernel } from "./kernel.js";

package/dist/runtime/index.js

@@ -0,0 +1,4 @@
+export { InMemorySessionLog } from "./session-log.js";
+export { LocalExecutionPlane } from "./execution-plane.js";
+export { RuntimeRunner, collectText } from "./runner.js";
+export { getKernel } from "./kernel.js";

package/dist/runtime/kernel.d.ts

@@ -0,0 +1,4 @@
+type WasmKernel = typeof import("@deepstrike/wasm-kernel");
+/** Lazily load the WASM kernel (browser / worker safe). */
+export declare function getKernel(): Promise<WasmKernel>;
+export {};

package/dist/runtime/kernel.js

@@ -0,0 +1,8 @@
+let kernelMod = null;
+/** Lazily load the WASM kernel (browser / worker safe). */
+export async function getKernel() {
+    if (!kernelMod) {
+        kernelMod = await import("@deepstrike/wasm-kernel");
+    }
+    return kernelMod;
+}

package/dist/runtime/provider-replay.d.ts

@@ -0,0 +1,7 @@
+import type { LLMProvider, Message, ProviderReplay, ToolCall } from "../types.js";
+import type { SessionEvent } from "./session-log.js";
+export declare function assistantReplayKey(message: Pick<Message, "content" | "toolCalls">): string;
+export declare function seedProviderReplayFromEvents(provider: LLMProvider, events: Array<{
+    event: SessionEvent;
+}>): void;
+export declare function peekProviderReplay(provider: LLMProvider, content: string, toolCalls: ToolCall[]): ProviderReplay | undefined;

package/dist/runtime/provider-replay.js

@@ -0,0 +1,18 @@
+export function assistantReplayKey(message) {
+    return JSON.stringify({
+        content: message.content,
+        toolCalls: message.toolCalls ?? [],
+    });
+}
+export function seedProviderReplayFromEvents(provider, events) {
+    if (!provider.seedProviderReplay)
+        return;
+    for (const { event } of events) {
+        if (event.kind !== "llm_completed" || !event.provider_replay)
+            continue;
+        provider.seedProviderReplay({ content: event.content, toolCalls: event.tool_calls ?? [] }, event.provider_replay);
+    }
+}
+export function peekProviderReplay(provider, content, toolCalls) {
+    return provider.peekProviderReplay?.({ content, toolCalls });
+}

package/dist/runtime/runner.d.ts

@@ -0,0 +1,44 @@
+import type { LLMProvider, StreamEvent } from "../types.js";
+import type { ToolSuspendEvent } from "./execution-plane.js";
+import type { DreamStore, DreamResult } from "../memory/index.js";
+import type { KnowledgeSource } from "../knowledge/index.js";
+import type { SignalSource } from "../signals/index.js";
+import type { SessionLog } from "./session-log.js";
+import type { ExecutionPlane } from "./execution-plane.js";
+import type { Governance } from "../governance.js";
+export interface RuntimeOptions {
+    provider: LLMProvider;
+    sessionLog: SessionLog;
+    executionPlane: ExecutionPlane;
+    maxTokens: number;
+    maxTurns?: number;
+    timeoutMs?: number;
+    agentId?: string;
+    systemPrompt?: string;
+    initialMemory?: string[];
+    /** Skill name → markdown body (WASM has no filesystem). */
+    skillContentMap?: Map<string, string>;
+    dreamStore?: DreamStore;
+    knowledgeSource?: KnowledgeSource;
+    signalSource?: SignalSource;
+    extensions?: Record<string, unknown>;
+    governance?: Governance;
+    onToolSuspend?: (event: ToolSuspendEvent) => Promise<unknown> | unknown;
+}
+export declare class RuntimeRunner {
+    private readonly opts;
+    private interrupted;
+    constructor(opts: RuntimeOptions);
+    interrupt(): void;
+    run(req: {
+        sessionId: string;
+        goal: string;
+        criteria?: string[];
+        extensions?: Record<string, unknown>;
+    }): AsyncIterable<StreamEvent>;
+    wake(sessionId: string, extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    dream(agentId: string, nowMs?: number): Promise<DreamResult>;
+    private execute;
+    private appendObservations;
+}
+export declare function collectText(stream: AsyncIterable<StreamEvent>): Promise<string>;