@deepstrike/wasm 0.1.11 → 0.1.15

package/dist/runtime/runner.js

@@ -0,0 +1,362 @@
+import { getKernel } from "./kernel.js";
+import { peekProviderReplay, seedProviderReplayFromEvents } from "./provider-replay.js";
+export class RuntimeRunner {
+    opts;
+    interrupted = false;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    interrupt() { this.interrupted = true; }
+    async *run(req) {
+        const prior = await this.opts.sessionLog.read(req.sessionId);
+        const midRun = isMidRun(prior);
+        if (!midRun) {
+            await this.opts.sessionLog.append(req.sessionId, {
+                kind: "run_started",
+                run_id: crypto.randomUUID(),
+                goal: req.goal,
+                criteria: req.criteria ?? [],
+                agent_id: this.opts.agentId,
+                system_prompt: this.opts.systemPrompt,
+            });
+        }
+        yield* this.execute(req.sessionId, req.goal, req.criteria ?? [], req.extensions, prior.length > 0 ? prior : undefined, midRun);
+    }
+    async *wake(sessionId, extensions) {
+        const events = await this.opts.sessionLog.read(sessionId);
+        if (events.some(e => e.event.kind === "run_terminal"))
+            return;
+        const startEntry = [...events].reverse().find(e => e.event.kind === "run_started");
+        if (!startEntry)
+            throw new Error(`No run_started event for session: ${sessionId}`);
+        const start = startEntry.event;
+        yield* this.execute(sessionId, start.goal, start.criteria, extensions, events, true);
+    }
+    async dream(agentId, nowMs = Date.now()) {
+        if (!this.opts.dreamStore)
+            throw new Error("dreamStore not configured");
+        const kernel = await getKernel();
+        this.opts.governance?._attach(kernel);
+        const sessions = await this.opts.dreamStore.loadSessions(agentId);
+        const existingMemories = await this.opts.dreamStore.loadMemories(agentId);
+        if (!sessions.length)
+            return { sessionsProcessed: 0, insightsExtracted: 0, entriesAdded: 0, entriesRemoved: 0 };
+        const pipeline = new kernel.IdlePipeline(agentId);
+        const action1 = pipeline.feedTrigger(sessions.map(s => ({
+            sessionId: s.sessionId, agentId: s.agentId,
+            messages: s.messages.map(m => ({
+                role: m.role, content: m.content, tokenCount: m.tokenCount,
+                toolCalls: (m.toolCalls ?? []).map(tc => ({ id: tc.id, name: tc.name, arguments: tc.arguments })),
+            })),
+            metadata: JSON.stringify(s.metadata ?? null),
+            createdAtMs: s.createdAtMs, updatedAtMs: s.updatedAtMs,
+        })), existingMemories.map(e => ({ text: e.text, score: e.score, metadata: JSON.stringify(e.metadata ?? null) })), nowMs);
+        if (action1.kind === "noop" || action1.kind === "aborted") {
+            return { sessionsProcessed: 0, insightsExtracted: 0, entriesAdded: 0, entriesRemoved: 0 };
+        }
+        if (action1.kind !== "synthesize_insights")
+            throw new Error(`unexpected: ${action1.kind}`);
+        let synthesisText = "";
+        const providerState = this.opts.provider.createRunState?.();
+        const synthMsgs = (action1.messages ?? []);
+        const synthContext = {
+            systemText: synthMsgs.filter(m => m.role === "system").map(m => m.content).join("\n\n"),
+            turns: synthMsgs.filter(m => m.role !== "system"),
+        };
+        for await (const evt of this.opts.provider.stream(synthContext, [], undefined, providerState)) {
+            if (evt.type === "text_delta")
+                synthesisText += evt.delta;
+        }
+        const action2 = pipeline.feedSynthesisResult(synthesisText);
+        if (action2.kind !== "commit_memories")
+            throw new Error(`unexpected: ${action2.kind}`);
+        const cr = action2.curationResult;
+        const rr = action2.runResult;
+        const dsResult = {
+            toAdd: (cr.toAdd ?? []).map((e) => ({
+                text: e.text, score: e.score, metadata: tryParseJson(e.metadata),
+            })),
+            toRemoveIndices: (cr.toRemoveIndices ?? []).map(Number),
+            stats: {
+                insightsProcessed: cr.stats?.insightsProcessed ?? 0,
+                duplicatesRemoved: cr.stats?.duplicatesRemoved ?? 0,
+                conflictsResolved: cr.stats?.conflictsResolved ?? 0,
+                entriesAdded: cr.stats?.entriesAdded ?? 0,
+            },
+        };
+        await this.opts.dreamStore.commit(agentId, dsResult, existingMemories);
+        return {
+            sessionsProcessed: rr.sessionsProcessed,
+            insightsExtracted: rr.insightsExtracted,
+            entriesAdded: cr.stats?.entriesAdded ?? 0,
+            entriesRemoved: (cr.toRemoveIndices ?? []).length,
+        };
+    }
+    async *execute(sessionId, goal, criteria, extensions, priorEvents, resumeMidRun = false) {
+        this.interrupted = false;
+        const kernel = await getKernel();
+        this.opts.governance?._attach(kernel);
+        const ext = { ...this.opts.extensions, ...(extensions ?? {}) };
+        const providerState = this.opts.provider.createRunState?.();
+        let nextCompressedArchiveStart = nextArchivedSeqStart(priorEvents);
+        const providerPolicy = this.opts.provider.runtimePolicy?.() ?? {};
+        const effectiveMaxTurns = this.opts.maxTurns ?? providerPolicy.maxTurns ?? 25;
+        const effectiveTimeoutMs = this.opts.timeoutMs ?? providerPolicy.timeoutMs;
+        const sm = new kernel.LoopStateMachine({
+            maxTokens: this.opts.maxTokens,
+            maxTurns: effectiveMaxTurns,
+            timeoutMs: effectiveTimeoutMs !== undefined ? BigInt(effectiveTimeoutMs) : undefined,
+        });
+        const router = new kernel.SignalRouter(256);
+        sm.setTools(this.opts.executionPlane.schemas());
+        if (this.opts.systemPrompt) {
+            sm.addSystemMessage(this.opts.systemPrompt, Math.max(1, Math.ceil(this.opts.systemPrompt.length / 4)));
+        }
+        if (this.opts.initialMemory) {
+            for (const mem of this.opts.initialMemory) {
+                sm.addMemoryMessage(mem, Math.max(1, Math.ceil(mem.length / 4)));
+            }
+        }
+        if (this.opts.skillContentMap && this.opts.skillContentMap.size > 0) {
+            const metas = [...this.opts.skillContentMap.keys()].map(name => ({
+                name,
+                description: "",
+                estimatedTokens: 0,
+            }));
+            sm.setAvailableSkills(metas);
+        }
+        if (this.opts.dreamStore && this.opts.agentId)
+            sm.setMemoryEnabled(true);
+        if (this.opts.knowledgeSource)
+            sm.setKnowledgeEnabled(true);
+        if (priorEvents && priorEvents.length > 0) {
+            seedProviderReplayFromEvents(this.opts.provider, priorEvents);
+            sm.preloadHistory(replayMessages(priorEvents));
+        }
+        const sessionStart = Date.now();
+        let action = resumeMidRun
+            ? sm.resumeAfterPreload()
+            : sm.start({ goal, criteria });
+        while (!sm.isTerminal()) {
+            nextCompressedArchiveStart = await this.appendObservations(sessionId, sm, nextCompressedArchiveStart);
+            if (this.interrupted) {
+                sm.feedTimeout();
+                break;
+            }
+            if (this.opts.signalSource) {
+                const sig = await this.opts.signalSource.nextSignal();
+                if (sig) {
+                    const kernelSig = {
+                        id: crypto.randomUUID(),
+                        source: sig.source ?? "custom",
+                        signalType: sig.signalType ?? "event",
+                        urgency: sig.urgency ?? "normal",
+                        summary: String(sig.payload?.goal ?? "signal"),
+                        payload: JSON.stringify(sig.payload ?? {}),
+                        dedupeKey: sig.dedupeKey,
+                        timestampMs: Date.now(),
+                    };
+                    const disposition = router.ingest(kernelSig, action.kind === "execute_tools");
+                    if (disposition === "interrupt_now") {
+                        sm.feedTimeout();
+                        break;
+                    }
+                }
+            }
+            let queued = router.next();
+            while (queued) {
+                if (queued.urgency === "critical") {
+                    sm.feedTimeout();
+                    break;
+                }
+                queued = router.next();
+            }
+            if (sm.isTerminal())
+                break;
+            if (action.kind === "call_llm") {
+                const finalToolCalls = [];
+                let finalText = "";
+                const context = action.context;
+                const tools = (action.tools ?? []);
+                let turnTokens = 0;
+                try {
+                    for await (const evt of this.opts.provider.stream(context, tools, Object.keys(ext).length ? ext : undefined, providerState)) {
+                        if (evt.type === "usage") {
+                            turnTokens = evt.totalTokens;
+                            continue;
+                        }
+                        yield evt;
+                        if (evt.type === "text_delta")
+                            finalText += evt.delta;
+                        else if (evt.type === "tool_call") {
+                            const tc = evt;
+                            finalToolCalls.push({ id: tc.id, name: tc.name, arguments: JSON.stringify(tc.arguments) });
+                        }
+                    }
+                }
+                catch (err) {
+                    yield { type: "error", message: String(err) };
+                    sm.feedTimeout();
+                    break;
+                }
+                action = sm.feedLlmResponse({
+                    role: "assistant",
+                    content: finalText,
+                    toolCalls: finalToolCalls,
+                    tokenCount: turnTokens || undefined,
+                });
+                const providerReplay = peekProviderReplay(this.opts.provider, finalText, finalToolCalls);
+                await this.opts.sessionLog.append(sessionId, {
+                    kind: "llm_completed",
+                    turn: sm.turn,
+                    content: finalText,
+                    token_count: turnTokens || undefined,
+                    tool_calls: finalToolCalls,
+                    ...(providerReplay ? { provider_replay: providerReplay } : {}),
+                });
+            }
+            else if (action.kind === "execute_tools") {
+                const allCalls = (action.calls ?? []);
+                await this.opts.sessionLog.append(sessionId, { kind: "tool_requested", turn: sm.turn, calls: allCalls });
+                const runCtx = {
+                    agentId: this.opts.agentId,
+                    skillContentMap: this.opts.skillContentMap,
+                    dreamStore: this.opts.dreamStore,
+                    knowledgeSource: this.opts.knowledgeSource,
+                    governance: this.opts.governance,
+                    onToolSuspend: this.opts.onToolSuspend,
+                };
+                const toolResults = [];
+                for await (const evt of this.opts.executionPlane.executeAll(allCalls, runCtx)) {
+                    yield evt;
+                    if (evt.type === "tool_result") {
+                        const tre = evt;
+                        toolResults.push({ callId: tre.callId, output: tre.content, isError: tre.isError });
+                    }
+                }
+                await this.opts.sessionLog.append(sessionId, {
+                    kind: "tool_completed",
+                    turn: sm.turn,
+                    results: toolResults.map(r => ({
+                        call_id: r.callId,
+                        output: r.output,
+                        is_error: r.isError,
+                        token_count: r.tokenCount,
+                    })),
+                });
+                action = sm.feedToolResults(toolResults);
+            }
+            else if (action.kind === "done") {
+                break;
+            }
+        }
+        const result = action.result;
+        const status = result?.termination ?? "error";
+        const turnsUsed = result ? Math.max(1, result.turnsUsed ?? 0) : 0;
+        const totalTokens = result?.totalTokensUsed ? Number(result.totalTokensUsed) : 0;
+        nextCompressedArchiveStart = await this.appendObservations(sessionId, sm, nextCompressedArchiveStart);
+        await this.opts.sessionLog.append(sessionId, { kind: "run_terminal", reason: status, turns_used: turnsUsed, total_tokens: totalTokens });
+        if (this.opts.dreamStore && this.opts.agentId) {
+            const newMsgs = sm.drainNewMessages().map(m => ({
+                role: m.role,
+                content: m.content,
+                tokenCount: m.tokenCount,
+                toolCalls: m.toolCalls?.length ? m.toolCalls : undefined,
+            }));
+            if (newMsgs.length > 0) {
+                try {
+                    await this.opts.dreamStore.saveSession({
+                        sessionId: crypto.randomUUID(),
+                        agentId: this.opts.agentId,
+                        messages: newMsgs,
+                        metadata: null,
+                        createdAtMs: sessionStart,
+                        updatedAtMs: Date.now(),
+                    });
+                }
+                catch { /* non-fatal */ }
+            }
+        }
+        yield { type: "done", iterations: turnsUsed, totalTokens, status };
+    }
+    async appendObservations(sessionId, sm, nextArchiveStart) {
+        const observations = sm.takeObservations();
+        for (const obs of observations) {
+            if (obs.kind !== "compressed")
+                continue;
+            const latest = await this.opts.sessionLog.latestSeq(sessionId);
+            if (latest < nextArchiveStart)
+                continue;
+            const end = latest;
+            const compressedSeq = await this.opts.sessionLog.append(sessionId, {
+                kind: "compressed",
+                turn: sm.turn,
+                archived_seq_range: [nextArchiveStart, end],
+            });
+            nextArchiveStart = compressedSeq + 1;
+        }
+        return nextArchiveStart;
+    }
+}
+function isMidRun(events) {
+    return events.length > 0 && !events.some(e => e.event.kind === "run_terminal");
+}
+function replayMessages(events) {
+    const messages = [];
+    for (const { event: e } of events) {
+        if (e.kind === "run_started") {
+            const userText = e.criteria.length
+                ? `${e.goal}\n\nCriteria:\n${e.criteria.map((c, i) => `${i + 1}. ${c}`).join("\n")}`
+                : e.goal;
+            messages.push({
+                role: "user",
+                content: userText,
+                toolCalls: [],
+                tokenCount: Math.max(1, Math.ceil(userText.length / 4)),
+            });
+        }
+        else if (e.kind === "llm_completed") {
+            messages.push({
+                role: "assistant",
+                content: e.content,
+                toolCalls: e.tool_calls ?? [],
+                tokenCount: e.token_count,
+            });
+        }
+        else if (e.kind === "tool_completed") {
+            for (const r of e.results) {
+                messages.push({
+                    role: "tool",
+                    content: r.output,
+                    toolCalls: [],
+                    tokenCount: r.token_count,
+                });
+            }
+        }
+    }
+    return messages;
+}
+function nextArchivedSeqStart(events) {
+    let next = 0;
+    for (const { event } of events ?? []) {
+        if (event.kind === "compressed")
+            next = Math.max(next, event.archived_seq_range[1] + 1);
+    }
+    return next;
+}
+function tryParseJson(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return null;
+    }
+}
+export async function collectText(stream) {
+    let text = "";
+    for await (const evt of stream) {
+        if (evt.type === "text_delta")
+            text += evt.delta;
+    }
+    return text;
+}

package/dist/runtime/session-log.d.ts

@@ -0,0 +1,55 @@
+import type { ProviderReplay, ToolCall } from "../types.js";
+export type SessionEvent = {
+    kind: "run_started";
+    run_id: string;
+    goal: string;
+    criteria: string[];
+    agent_id?: string;
+    system_prompt?: string;
+} | {
+    kind: "llm_completed";
+    turn: number;
+    content: string;
+    token_count?: number;
+    tool_calls: ToolCall[];
+    provider_replay?: ProviderReplay;
+} | {
+    kind: "tool_requested";
+    turn: number;
+    calls: ToolCall[];
+} | {
+    kind: "tool_completed";
+    turn: number;
+    results: Array<{
+        call_id: string;
+        output: string;
+        is_error?: boolean;
+        token_count?: number;
+    }>;
+} | {
+    kind: "compressed";
+    turn: number;
+    archived_seq_range: [number, number];
+} | {
+    kind: "run_terminal";
+    reason: string;
+    turns_used: number;
+    total_tokens: number;
+};
+export interface SessionLog {
+    append(sessionId: string, event: SessionEvent): Promise<number>;
+    read(sessionId: string, fromSeq?: number): Promise<Array<{
+        seq: number;
+        event: SessionEvent;
+    }>>;
+    latestSeq(sessionId: string): Promise<number>;
+}
+export declare class InMemorySessionLog implements SessionLog {
+    private store;
+    append(sessionId: string, event: SessionEvent): Promise<number>;
+    read(sessionId: string, fromSeq?: number): Promise<Array<{
+        seq: number;
+        event: SessionEvent;
+    }>>;
+    latestSeq(sessionId: string): Promise<number>;
+}

package/dist/runtime/session-log.js

@@ -0,0 +1,18 @@
+export class InMemorySessionLog {
+    store = new Map();
+    async append(sessionId, event) {
+        if (!this.store.has(sessionId))
+            this.store.set(sessionId, []);
+        const entries = this.store.get(sessionId);
+        const seq = entries.length;
+        entries.push({ seq, event });
+        return seq;
+    }
+    async read(sessionId, fromSeq = 0) {
+        return (this.store.get(sessionId) ?? []).filter(e => e.seq >= fromSeq);
+    }
+    async latestSeq(sessionId) {
+        const entries = this.store.get(sessionId);
+        return entries ? entries.length - 1 : -1;
+    }
+}

package/dist/types.d.ts

@@ -20,6 +20,11 @@ export interface ToolSchema {
     description: string;
     parameters: string;
 }
+/** Structured provider context from the kernel (`call_llm` action). */
+export interface RenderedContext {
+    systemText: string;
+    turns: Message[];
+}
 export interface StreamEvent {
     type: string;
 }
@@ -27,6 +32,10 @@ export interface TextDelta extends StreamEvent {
     type: "text_delta";
     delta: string;
 }
+export interface UsageEvent extends StreamEvent {
+    type: "usage";
+    totalTokens: number;
+}
 export interface ThinkingDelta extends StreamEvent {
     type: "thinking_delta";
     delta: string;
@@ -61,6 +70,23 @@ export interface PermissionRequestEvent extends StreamEvent {
     arguments: string;
     reason: string;
 }
+/**
+ * Opaque per-run state owned by the provider (e.g. OpenAI Responses continuation).
+ * The framework creates and threads this object; providers may read/write it.
+ */
+export type ProviderRunState = Record<string, unknown>;
+export interface ProviderReplay {
+    native_blocks?: Array<Record<string, unknown>>;
+    reasoning_content?: string;
+}
 export interface LLMProvider {
-    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    createRunState?(): ProviderRunState;
+    runtimePolicy?(): {
+        maxTurns?: number;
+        timeoutMs?: number;
+    };
+    peekProviderReplay?(message: Pick<Message, "content" | "toolCalls">): ProviderReplay | undefined;
+    seedProviderReplay?(message: Pick<Message, "content" | "toolCalls">, replay: ProviderReplay): void;
+    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/wasm",
-  "version": "0.1.11",
+  "version": "0.1.15",
   "description": "DeepStrike WASM SDK — browser, Cloudflare Workers, Deno Deploy",
   "type": "module",
   "main": "dist/index.js",
@@ -15,7 +15,7 @@
     "test": "node --experimental-vm-modules node_modules/.bin/jest"
   },
   "dependencies": {
-    "@deepstrike/wasm-kernel": "0.1.11"
+    "@deepstrike/wasm-kernel": "0.1.15"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",

package/dist/agent.d.ts

@@ -1,57 +0,0 @@
-import type { LLMProvider, StreamEvent } from "./types.js";
-import type { RegisteredTool } from "./tools/index.js";
-import type { KnowledgeSource } from "./knowledge/index.js";
-import type { SignalSource } from "./signals/index.js";
-import type { DreamStore } from "./memory/index.js";
-import { Governance } from "./governance.js";
-export interface SkillMetadata {
-    name: string;
-    description: string;
-    whenToUse?: string;
-    allowedTools?: string[];
-    effort?: number;
-    estimatedTokens?: number;
-}
-export interface AgentOptions {
-    maxTokens: number;
-    maxTurns?: number;
-    timeoutMs?: number;
-    extensions?: Record<string, unknown>;
-    /**
-     * System-level instructions prepended to every context render.
-     * Passed to the kernel's `system` partition before the first LLM call.
-     */
-    systemPrompt?: string;
-    /**
-     * Long-term memory snippets pre-seeded into the context before the first LLM call.
-     * Each string is pushed to the kernel's `memory` partition.
-     */
-    initialMemory?: string[];
-    skillDir?: string;
-    knowledgeSource?: KnowledgeSource;
-    signalSource?: SignalSource;
-    dreamStore?: DreamStore;
-    agentId?: string;
-    governance?: Governance;
-    /** Host-provided skill content map (name → markdown body). WASM has no fs access. */
-    skillContentMap?: Map<string, string>;
-}
-export declare class Agent {
-    private readonly provider;
-    private readonly options;
-    private tools;
-    private blockedTools;
-    private extensions;
-    private interrupted;
-    private pendingInterrupt;
-    private _pendingSkills;
-    constructor(provider: LLMProvider, options: AgentOptions);
-    register(...tools: RegisteredTool[]): this;
-    unregister(name: string): this;
-    blockTool(name: string): this;
-    interrupt(): void;
-    run(goal: string, criteria?: string[], extensions?: Record<string, unknown>): Promise<string>;
-    runStreaming(goal: string, criteria?: string[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
-    /** Register available skills from host-provided metadata (WASM has no fs access). */
-    setAvailableSkills(skills: SkillMetadata[]): void;
-}