@deepstrike/wasm 0.1.10 → 0.1.14

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/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>;

package/dist/runtime/runner.js

@@ -0,0 +1,358 @@
+import { getKernel } from "./kernel.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) {
+            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,
+                });
+                await this.opts.sessionLog.append(sessionId, {
+                    kind: "llm_completed",
+                    turn: sm.turn,
+                    content: finalText,
+                    token_count: turnTokens || undefined,
+                    tool_calls: finalToolCalls,
+                });
+            }
+            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,54 @@
+import type { 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[];
+} | {
+    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,17 @@ 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 LLMProvider {
-    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    createRunState?(): ProviderRunState;
+    runtimePolicy?(): {
+        maxTurns?: number;
+        timeoutMs?: number;
+    };
+    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.10",
+  "version": "0.1.14",
   "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.10"
+    "@deepstrike/wasm-kernel": "0.1.14"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",