@deepstrike/wasm 0.2.27 → 0.2.30

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { RuntimeRunner, collectText, InMemorySessionLog, LocalExecutionPlane, DEFAULT_NATIVE_ATTENTION_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, DEFAULT_SANDBOX_POLICY, assertNativeProfile, osProfile, validateDeclarativePolicy, ReplayProvider, extractRecordedMessages, judge, buildEvalMessages, parseVerdict, verdictOutputSchema, } from "./runtime/index.js";
+export { RuntimeRunner, collectText, runAgent, runFanout, InMemorySessionLog, LocalExecutionPlane, DEFAULT_NATIVE_ATTENTION_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, DEFAULT_SANDBOX_POLICY, assertNativeProfile, osProfile, validateDeclarativePolicy, ReplayProvider, extractRecordedMessages, judge, buildEvalMessages, parseVerdict, verdictOutputSchema, } from "./runtime/index.js";
 export type { ReplayProviderOpts, Criterion, Verdict, VerdictDetail, JudgeArgs, } from "./runtime/index.js";
 export type { NativeOsProfile, OsProfileId, MemoryPolicy, MemoryWriteRateLimit, ResourceQuota, RuntimeOptions, SchedulerBudget, SessionEvent, SessionLog, RunContext, ExecutionPlane, } from "./runtime/index.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";

package/dist/index.js

@@ -1,4 +1,4 @@
-export { RuntimeRunner, collectText, InMemorySessionLog, LocalExecutionPlane, DEFAULT_NATIVE_ATTENTION_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, DEFAULT_SANDBOX_POLICY, assertNativeProfile, osProfile, validateDeclarativePolicy, ReplayProvider, extractRecordedMessages, judge, buildEvalMessages, parseVerdict, verdictOutputSchema, } from "./runtime/index.js";
+export { RuntimeRunner, collectText, runAgent, runFanout, InMemorySessionLog, LocalExecutionPlane, DEFAULT_NATIVE_ATTENTION_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, DEFAULT_SANDBOX_POLICY, assertNativeProfile, osProfile, validateDeclarativePolicy, ReplayProvider, extractRecordedMessages, judge, buildEvalMessages, parseVerdict, verdictOutputSchema, } from "./runtime/index.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
 export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesToKernel, submitWorkflowToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, verifyRules } from "./runtime/types/agent.js";

package/dist/runtime/facade.d.ts

@@ -0,0 +1,35 @@
+import type { ExecutionPlane } from "./execution-plane.js";
+import type { SessionLog } from "./session-log.js";
+import type { LLMProvider } from "../types.js";
+import type { RegisteredTool } from "../tools/index.js";
+import type { WorkflowTaskSpec, KernelAgentRole } from "./types/agent.js";
+export interface RunAgentOptions {
+    provider: LLMProvider;
+    goal: string;
+    systemPrompt?: string;
+    tools?: RegisteredTool[];
+    sessionId?: string;
+    maxTokens?: number;
+    maxTurns?: number;
+    sessionLog?: SessionLog;
+    executionPlane?: ExecutionPlane;
+}
+/** Run a single agent to completion and return its final text. */
+export declare function runAgent(opts: RunAgentOptions): Promise<string>;
+export interface RunFanoutOptions {
+    provider: LLMProvider;
+    tasks: WorkflowTaskSpec[];
+    synthesize: string;
+    workerRole?: KernelAgentRole;
+    synthesisRole?: KernelAgentRole;
+    sessionId?: string;
+    maxTokens?: number;
+    maxTurns?: number;
+    sessionLog?: SessionLog;
+    executionPlane?: ExecutionPlane;
+}
+/** Parallel fan-out → synthesize over the kernel-gated DAG (standalone runWorkflow). */
+export declare function runFanout(opts: RunFanoutOptions): Promise<{
+    synthesis: string;
+    outputs: Record<string, string>;
+}>;

package/dist/runtime/facade.js

@@ -0,0 +1,41 @@
+// High-level facades (parity with the Node SDK's runAgent/runFanout) so the common cases don't require
+// assembling RuntimeRunner + session log + execution plane + collectText by hand. Browser/edge-friendly.
+import { RuntimeRunner, collectText } from "./runner.js";
+import { LocalExecutionPlane } from "./execution-plane.js";
+import { InMemorySessionLog } from "./session-log.js";
+/** Run a single agent to completion and return its final text. */
+export async function runAgent(opts) {
+    const plane = opts.executionPlane ??
+        (opts.tools ?? []).reduce((p, t) => p.register(t), new LocalExecutionPlane());
+    const runner = new RuntimeRunner({
+        provider: opts.provider,
+        executionPlane: plane,
+        sessionLog: opts.sessionLog ?? new InMemorySessionLog(),
+        maxTokens: opts.maxTokens ?? 32_000,
+        ...(opts.maxTurns !== undefined ? { maxTurns: opts.maxTurns } : {}),
+        ...(opts.systemPrompt !== undefined ? { systemPrompt: opts.systemPrompt } : {}),
+    });
+    return collectText(runner.run({ sessionId: opts.sessionId ?? `agent-${crypto.randomUUID()}`, goal: opts.goal }));
+}
+/** Parallel fan-out → synthesize over the kernel-gated DAG (standalone runWorkflow). */
+export async function runFanout(opts) {
+    const runner = new RuntimeRunner({
+        provider: opts.provider,
+        executionPlane: opts.executionPlane ?? new LocalExecutionPlane(),
+        sessionLog: opts.sessionLog ?? new InMemorySessionLog(),
+        maxTokens: opts.maxTokens ?? 32_000,
+        ...(opts.maxTurns !== undefined ? { maxTurns: opts.maxTurns } : {}),
+    });
+    const workerRole = opts.workerRole ?? "explore";
+    const spec = {
+        nodes: [
+            ...opts.tasks.map(task => ({ task, role: workerRole })),
+            { task: opts.synthesize, role: opts.synthesisRole ?? "plan", dependsOn: opts.tasks.map((_, i) => i) },
+        ],
+    };
+    const outcome = await runner.runWorkflow(spec, opts.sessionId ? { sessionId: opts.sessionId } : undefined);
+    const synthesisId = `wf-node${opts.tasks.length}`;
+    const lastCompleted = outcome.completed[outcome.completed.length - 1];
+    const synthesis = outcome.outputs[synthesisId] ?? (lastCompleted ? outcome.outputs[lastCompleted] : undefined) ?? "";
+    return { synthesis, outputs: outcome.outputs };
+}

package/dist/runtime/index.d.ts

@@ -4,6 +4,8 @@ export type { RunContext, ExecutionPlane } from "./execution-plane.js";
 export { LocalExecutionPlane } from "./execution-plane.js";
 export type { MemoryPolicy, MemoryWriteRateLimit, ResourceQuota, RuntimeOptions, SchedulerBudget } from "./runner.js";
 export { RuntimeRunner, collectText } from "./runner.js";
+export { runAgent, runFanout } from "./facade.js";
+export type { RunAgentOptions, RunFanoutOptions } from "./facade.js";
 export { builtinReducers, resolveReducer } from "./reducers.js";
 export type { Reducer, ReducerRegistry, ReducerInput } from "./reducers.js";
 export { getKernel } from "./kernel.js";

package/dist/runtime/index.js

@@ -1,6 +1,7 @@
 export { InMemorySessionLog } from "./session-log.js";
 export { LocalExecutionPlane } from "./execution-plane.js";
 export { RuntimeRunner, collectText } from "./runner.js";
+export { runAgent, runFanout } from "./facade.js";
 export { builtinReducers, resolveReducer } from "./reducers.js";
 export { getKernel } from "./kernel.js";
 export { ReplayProvider } from "./replay-provider.js";

package/dist/runtime/runner.d.ts

@@ -186,9 +186,25 @@ export declare class RuntimeRunner {
      * through the syscall trap; this driver runs each kernel-emitted batch of nodes in parallel,
      * feeds their results back, and loops until the kernel reports the workflow complete.
      */
+    /**
+     * Lower the declarative governance / attention / scheduler-budget / resource-quota / memory policies
+     * into a freshly-created kernel. Shared by `execute()` (full run) and `bootstrapWorkflowKernel()`
+     * (standalone workflow) so a DAG's node spawns are gated and quota'd exactly as a mid-run spawn.
+     * Must run BEFORE `start_run`. No config ⇒ native-profile defaults.
+     */
+    private applyKernelPolicies;
+    /**
+     * Bootstrap a standalone kernel for a host-driven workflow with no active parent run — the path a
+     * stateless handler (browser/edge worker) takes when it calls `runWorkflow(spec)` directly. Mirrors
+     * `execute()`'s pre-run setup (policies via `applyKernelPolicies`, then `start_run`) and records a
+     * best-effort `run_started` so the run is resumable. `runWorkflow` tears the kernel down afterward.
+     */
+    private bootstrapWorkflowKernel;
     runWorkflow(spec: WorkflowSpec, opts?: {
         resumedCompleted?: string[];
         resumedSubmissions?: Record<string, unknown>[][];
+        /** Standalone session id when bootstrapping (no active parent run). Defaults to a fresh uuid. */
+        sessionId?: string;
     }): Promise<{
         completed: string[];
         failed: string[];
@@ -233,7 +249,9 @@ export declare class RuntimeRunner {
      * Reads the session log, extracts completed workflow node agent_ids, and
      * calls runWorkflow with resumedCompleted so the kernel skips those nodes.
      */
-    resumeWorkflow(spec: WorkflowSpec): Promise<{
+    resumeWorkflow(spec: WorkflowSpec, opts?: {
+        sessionId?: string;
+    }): Promise<{
         completed: string[];
         failed: string[];
     }>;

package/dist/runtime/runner.js

@@ -385,56 +385,7 @@ export class RuntimeRunner {
                 : baseSpec;
             startPayload.run_spec = agentRunSpecToKernel(spec);
         }
-        const osProfile = assertNativeProfile(this.opts.osProfile ?? "native");
-        const attentionPolicy = this.opts.attentionPolicy ?? osProfile.attentionPolicy;
-        const governancePolicy = this.opts.governancePolicy ?? osProfile.governancePolicy;
-        kernelApply(runtime, this.pendingObservations, governancePolicyToKernelEvent(governancePolicy));
-        kernelApply(runtime, this.pendingObservations, {
-            kind: "set_attention_policy",
-            ...(attentionPolicy.maxQueueSize !== undefined
-                ? { max_queue_size: attentionPolicy.maxQueueSize }
-                : {}),
-        });
-        if (this.opts.schedulerBudget) {
-            kernelApply(runtime, this.pendingObservations, {
-                kind: "set_scheduler_budget",
-                ...(this.opts.schedulerBudget.maxWallMs !== undefined
-                    ? { max_wall_ms: this.opts.schedulerBudget.maxWallMs }
-                    : {}),
-            });
-        }
-        if (this.opts.resourceQuota) {
-            const q = this.opts.resourceQuota;
-            kernelApply(runtime, this.pendingObservations, {
-                kind: "set_resource_quota",
-                quota: {
-                    ...(q.maxConcurrentSubagents !== undefined
-                        ? { max_concurrent_subagents: q.maxConcurrentSubagents }
-                        : {}),
-                    ...(q.maxSpawnDepth !== undefined ? { max_spawn_depth: q.maxSpawnDepth } : {}),
-                    ...(q.memoryWritesPerWindow !== undefined
-                        ? {
-                            memory_writes_per_window: [
-                                q.memoryWritesPerWindow.maxWrites,
-                                q.memoryWritesPerWindow.windowMs,
-                            ],
-                        }
-                        : {}),
-                },
-            });
-        }
-        if (this.opts.memoryPolicy) {
-            const m = this.opts.memoryPolicy;
-            kernelApply(runtime, this.pendingObservations, {
-                kind: "set_memory_policy",
-                ...(m.memoryPath !== undefined ? { memory_path: m.memoryPath } : {}),
-                ...(m.staleWarningDays !== undefined ? { stale_warning_days: m.staleWarningDays } : {}),
-                ...(m.retrievalTopK !== undefined ? { retrieval_top_k: m.retrievalTopK } : {}),
-                ...(m.validationEnabled !== undefined ? { validation_enabled: m.validationEnabled } : {}),
-                ...(m.maxContentBytes !== undefined ? { max_content_bytes: m.maxContentBytes } : {}),
-                ...(m.maxNameLength !== undefined ? { max_name_length: m.maxNameLength } : {}),
-            });
-        }
+        this.applyKernelPolicies(runtime);
         // I4: pre-fetch memory into the knowledge partition before the first LLM turn (mirrors Node).
         if (!resumeMidRun && this.opts.preQueryMemory && this.opts.dreamStore && this.opts.agentId) {
             try {
@@ -1007,22 +958,112 @@ export class RuntimeRunner {
      * through the syscall trap; this driver runs each kernel-emitted batch of nodes in parallel,
      * feeds their results back, and loops until the kernel reports the workflow complete.
      */
+    /**
+     * Lower the declarative governance / attention / scheduler-budget / resource-quota / memory policies
+     * into a freshly-created kernel. Shared by `execute()` (full run) and `bootstrapWorkflowKernel()`
+     * (standalone workflow) so a DAG's node spawns are gated and quota'd exactly as a mid-run spawn.
+     * Must run BEFORE `start_run`. No config ⇒ native-profile defaults.
+     */
+    applyKernelPolicies(runtime) {
+        const osProfile = assertNativeProfile(this.opts.osProfile ?? "native");
+        const attentionPolicy = this.opts.attentionPolicy ?? osProfile.attentionPolicy;
+        const governancePolicy = this.opts.governancePolicy ?? osProfile.governancePolicy;
+        // K2: lower governance / attention / scheduler / quota in ONE `configure_run` event (the 0.2.30
+        // core applies each present field via its granular path). `set_memory_policy` stays separate below.
+        const { kind: _govKind, ...governance } = governancePolicyToKernelEvent(governancePolicy);
+        const config = { governance };
+        if (attentionPolicy.maxQueueSize !== undefined) {
+            config.attention_max_queue_size = attentionPolicy.maxQueueSize;
+        }
+        if (this.opts.schedulerBudget?.maxWallMs !== undefined) {
+            config.scheduler_max_wall_ms = this.opts.schedulerBudget.maxWallMs;
+        }
+        if (this.opts.resourceQuota) {
+            const q = this.opts.resourceQuota;
+            config.resource_quota = {
+                ...(q.maxConcurrentSubagents !== undefined ? { max_concurrent_subagents: q.maxConcurrentSubagents } : {}),
+                ...(q.maxSpawnDepth !== undefined ? { max_spawn_depth: q.maxSpawnDepth } : {}),
+                ...(q.memoryWritesPerWindow !== undefined
+                    ? { memory_writes_per_window: [q.memoryWritesPerWindow.maxWrites, q.memoryWritesPerWindow.windowMs] }
+                    : {}),
+            };
+        }
+        kernelApply(runtime, this.pendingObservations, { kind: "configure_run", config });
+        if (this.opts.memoryPolicy) {
+            const m = this.opts.memoryPolicy;
+            kernelApply(runtime, this.pendingObservations, {
+                kind: "set_memory_policy",
+                ...(m.memoryPath !== undefined ? { memory_path: m.memoryPath } : {}),
+                ...(m.staleWarningDays !== undefined ? { stale_warning_days: m.staleWarningDays } : {}),
+                ...(m.retrievalTopK !== undefined ? { retrieval_top_k: m.retrievalTopK } : {}),
+                ...(m.validationEnabled !== undefined ? { validation_enabled: m.validationEnabled } : {}),
+                ...(m.maxContentBytes !== undefined ? { max_content_bytes: m.maxContentBytes } : {}),
+                ...(m.maxNameLength !== undefined ? { max_name_length: m.maxNameLength } : {}),
+            });
+        }
+    }
+    /**
+     * Bootstrap a standalone kernel for a host-driven workflow with no active parent run — the path a
+     * stateless handler (browser/edge worker) takes when it calls `runWorkflow(spec)` directly. Mirrors
+     * `execute()`'s pre-run setup (policies via `applyKernelPolicies`, then `start_run`) and records a
+     * best-effort `run_started` so the run is resumable. `runWorkflow` tears the kernel down afterward.
+     */
+    async bootstrapWorkflowKernel(sessionId, spec) {
+        this.interrupted = false;
+        this.pendingObservations = [];
+        this.pendingSpoolOutputs.clear();
+        this.currentSessionId = sessionId;
+        const kernel = await getKernel();
+        const runtime = new kernel.KernelRuntime({
+            maxTokens: this.opts.maxTokens,
+            maxTurns: this.opts.maxTurns ?? 25,
+            ...(this.opts.maxTotalTokens !== undefined ? { maxTotalTokens: this.opts.maxTotalTokens } : {}),
+            timeoutMs: this.opts.timeoutMs !== undefined ? BigInt(this.opts.timeoutMs) : undefined,
+        });
+        this.activeKernel = runtime;
+        const goal = `workflow:${spec.nodes.length} nodes`;
+        void Promise.resolve(this.opts.sessionLog.append(sessionId, {
+            kind: "run_started",
+            run_id: crypto.randomUUID(),
+            goal,
+            criteria: [],
+            ...(this.opts.agentId ? { agent_id: this.opts.agentId } : {}),
+        })).catch(() => { });
+        this.applyKernelPolicies(runtime);
+        // K1: no explicit `start_run` — the host `load_workflow` (fired next by `runWorkflow`) self-bootstraps
+        // the run on the 0.2.30 core, matching the agent-reachable `submit_workflow` path.
+        void goal;
+        return runtime;
+    }
     async runWorkflow(spec, opts) {
-        if (!this.activeKernel || !this.currentSessionId) {
-            throw new Error("runWorkflow requires an active parent run");
+        // Standalone entry: with no active parent run, auto-bootstrap a kernel that owns the DAG (same
+        // governance/quota policies a full run gets), drive it, then tear it down so the runner is reusable.
+        // Mid-run callers keep the original in-place behavior with no teardown.
+        const bootstrapped = !this.activeKernel || !this.currentSessionId;
+        if (bootstrapped) {
+            await this.bootstrapWorkflowKernel(opts?.sessionId ?? `wf-${crypto.randomUUID()}`, spec);
         }
         const parentSessionId = this.currentSessionId;
         const runtime = this.activeKernel;
-        const observations = kernelApply(runtime, this.pendingObservations, {
-            kind: "load_workflow",
-            spec: workflowSpecToKernel(spec),
-            parent_session_id: parentSessionId,
-            // W0-ABI resume: skip nodes already completed before an interruption.
-            ...(opts?.resumedCompleted && opts.resumedCompleted.length ? { resumed_completed: opts.resumedCompleted } : {}),
-            // R3-1: re-apply recorded runtime submissions so dynamically-appended nodes are reconstructed.
-            ...(opts?.resumedSubmissions && opts.resumedSubmissions.length ? { resumed_submissions: opts.resumedSubmissions } : {}),
-        });
-        return this.driveWorkflow(observations, parentSessionId, runtime);
+        try {
+            const observations = kernelApply(runtime, this.pendingObservations, {
+                kind: "load_workflow",
+                spec: workflowSpecToKernel(spec),
+                parent_session_id: parentSessionId,
+                // W0-ABI resume: skip nodes already completed before an interruption.
+                ...(opts?.resumedCompleted && opts.resumedCompleted.length ? { resumed_completed: opts.resumedCompleted } : {}),
+                // R3-1: re-apply recorded runtime submissions so dynamically-appended nodes are reconstructed.
+                ...(opts?.resumedSubmissions && opts.resumedSubmissions.length ? { resumed_submissions: opts.resumedSubmissions } : {}),
+            });
+            return await this.driveWorkflow(observations, parentSessionId, runtime);
+        }
+        finally {
+            if (bootstrapped) {
+                this.activeKernel = null;
+                this.currentSessionId = null;
+                this.pendingObservations = [];
+            }
+        }
     }
     /**
      * M5/G1: bootstrap an **agent-authored** workflow ("the model writes its own harness"). Routes the
@@ -1169,14 +1210,16 @@ export class RuntimeRunner {
      * Reads the session log, extracts completed workflow node agent_ids, and
      * calls runWorkflow with resumedCompleted so the kernel skips those nodes.
      */
-    async resumeWorkflow(spec) {
-        if (!this.currentSessionId) {
-            throw new Error("resumeWorkflow requires an active parent run");
+    async resumeWorkflow(spec, opts) {
+        // Standalone resume: a stateless handler passes the prior `sessionId`; mid-run callers omit it.
+        const sessionId = opts?.sessionId ?? this.currentSessionId;
+        if (!sessionId) {
+            throw new Error("resumeWorkflow requires an active parent run or an explicit sessionId");
         }
-        const events = await this.opts.sessionLog.read(this.currentSessionId);
+        const events = await this.opts.sessionLog.read(sessionId);
         const resumedCompleted = recoverCompletedWorkflowNodes(events);
         const resumedSubmissions = recoverSubmittedWorkflowNodes(events);
-        return this.runWorkflow(spec, { resumedCompleted, resumedSubmissions });
+        return this.runWorkflow(spec, { resumedCompleted, resumedSubmissions, sessionId });
     }
     async appendObservations(sessionId, runtime, nextArchiveStart) {
         const turn = runtime.turn();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/wasm",
-  "version": "0.2.27",
+  "version": "0.2.30",
   "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.2.27"
+    "@deepstrike/wasm-kernel": "0.2.30"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",