@deepstrike/wasm 0.2.16 → 0.2.18

package/dist/harness/index.js

@@ -30,7 +30,6 @@ export class HarnessLoop {
     }
     async *runStreaming(request) {
         const kernel = await import("@deepstrike/wasm-kernel");
-        const pipeline = new kernel.EvalPipeline({ extractSkillOnPass: true });
         const criteria = request.criteria ?? [];
         let currentGoal = request.goal;
         let lastIterations = 0;
@@ -62,26 +61,23 @@ export class HarnessLoop {
                 }
             }
             yield { type: "supervising" };
-            const evalAction = pipeline.feedOutcome(request.goal, criteria, lastResult, attempt);
-            if (evalAction.kind !== "evaluate")
-                break;
+            // #6 (0.5.0): eval/verdict compute is the kernel's stateless free functions (was EvalPipeline).
+            const evalMsgs = kernel.buildEvalMessages(request.goal, criteria, lastResult, attempt, true);
             let evalText = "";
             const evalContext = {
                 systemText: "",
-                turns: (evalAction.messages ?? []),
+                turns: evalMsgs,
             };
             for await (const evt of this.evalProvider.stream(evalContext, [], undefined)) {
                 if (evt.type === "text_delta")
                     evalText += evt.delta;
             }
-            const doneAction = pipeline.feedEvalResult(evalText);
-            if (doneAction.kind !== "done")
-                break;
+            const parsed = kernel.parseVerdict(evalText);
             const verdict = {
-                passed: doneAction.passed ?? false,
-                overallScore: doneAction.overallScore ?? 0,
-                feedback: doneAction.feedback ?? "",
-                details: (doneAction.details ?? []),
+                passed: parsed.passed,
+                overallScore: parsed.overallScore,
+                feedback: parsed.feedback,
+                details: (parsed.details ?? []),
             };
             if (verdict.passed) {
                 yield { type: "done", verdict, iterations: lastIterations, totalTokens: lastTotalTokens, status: lastStatus };
@@ -90,7 +86,6 @@ export class HarnessLoop {
             yield { type: "revising", verdict };
             currentGoal = `${request.goal}\n\n[Attempt ${attempt} feedback: ${verdict.feedback}]`;
             lastResult = "";
-            pipeline.reset();
         }
         yield { type: "max_attempts_reached" };
     }

package/dist/index.d.ts

@@ -4,7 +4,8 @@ export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
 export type { SubAgentRunContext } from "./runtime/sub-agent-orchestrator.js";
 export type { AgentCapabilityFilter, AgentIdentity, AgentIsolation, AgentRunSpec, AgentProcessChangedObservation, ContextInheritance, KernelAgentRole, LoopResult, MilestoneCheckResult, MilestoneContract, MilestonePhase, MilestonePolicy, SubAgentResult, TerminationReason, WorkflowSpec, WorkflowNodeSpec, WorkflowTaskSpec, WorkflowSpawnInfo, } from "./runtime/types/agent.js";
-export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesToKernel, submitWorkflowNodesTool, fanoutSynthesize, generateAndFilter, verifyRules } from "./runtime/types/agent.js";
+export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesToKernel, submitWorkflowToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, verifyRules } from "./runtime/types/agent.js";
+export { loopInstruction, classifyInstruction, judgeGoal, extractLoopContinue, extractClassifyBranch, extractJudgeWinner, } from "./runtime/workflow-control-flow.js";
 export { Governance } from "./governance.js";
 export type { GovernanceVerdict } from "./governance.js";
 export { AnthropicProvider } from "./providers/anthropic.js";

package/dist/index.js

@@ -1,7 +1,8 @@
 export { RuntimeRunner, collectText, InMemorySessionLog, LocalExecutionPlane, DEFAULT_NATIVE_ATTENTION_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, DEFAULT_SANDBOX_POLICY, assertNativeProfile, osProfile, validateDeclarativePolicy, } 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, submitWorkflowNodesTool, fanoutSynthesize, generateAndFilter, verifyRules } from "./runtime/types/agent.js";
+export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesToKernel, submitWorkflowToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, verifyRules } from "./runtime/types/agent.js";
+export { loopInstruction, classifyInstruction, judgeGoal, extractLoopContinue, extractClassifyBranch, extractJudgeWinner, } from "./runtime/workflow-control-flow.js";
 export { Governance } from "./governance.js";
 export { AnthropicProvider } from "./providers/anthropic.js";
 export { OpenAIProvider, QwenProvider, DeepSeekProvider, MiniMaxProvider, KimiProvider } from "./providers/openai.js";

package/dist/providers/anthropic.d.ts

@@ -9,6 +9,6 @@ export declare class AnthropicProvider implements LLMProvider {
     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>): AsyncIterable<StreamEvent>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, _state?: unknown, signal?: AbortSignal): AsyncIterable<StreamEvent>;
     private rememberNativeBlocks;
 }

package/dist/providers/anthropic.js

@@ -109,7 +109,7 @@ export class AnthropicProvider {
     async complete(context, tools, extensions) {
         return collectStreamMessage(this.stream(context, tools, extensions));
     }
-    async *stream(context, tools, extensions) {
+    async *stream(context, tools, extensions, _state, signal) {
         const systemBlocks = [];
         if (context.systemStable) {
             systemBlocks.push({ type: "text", text: context.systemStable, cache_control: { type: "ephemeral" } });
@@ -150,6 +150,7 @@ export class AnthropicProvider {
                 "anthropic-beta": "prompt-caching-2024-07-31",
             },
             body: JSON.stringify(body),
+            ...(signal ? { signal } : {}), // #2-B-ii: a preempt aborts the in-flight request at the socket.
         });
         if (!resp.ok)
             throw new Error(`Anthropic ${resp.status}: ${await resp.text()}`);

package/dist/providers/openai.d.ts

@@ -13,20 +13,20 @@ export declare class OpenAIProvider implements LLMProvider {
         };
     }[];
     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>;
+    protected streamInner(context: RenderedContext, tools: ToolSchema[], extraBody: Record<string, unknown>, exposeReasoning?: boolean, signal?: AbortSignal): AsyncIterable<StreamEvent>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, _state?: unknown, signal?: AbortSignal): AsyncIterable<StreamEvent>;
 }
 export declare class QwenProvider extends OpenAIProvider {
     constructor(apiKey: string, model?: string);
-    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, _state?: unknown, signal?: AbortSignal): AsyncIterable<StreamEvent>;
 }
 export declare class DeepSeekProvider extends OpenAIProvider {
     constructor(apiKey: string, model?: string);
-    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, _state?: unknown, signal?: AbortSignal): AsyncIterable<StreamEvent>;
 }
 export declare class MiniMaxProvider extends OpenAIProvider {
     constructor(apiKey: string, model?: string);
-    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, _state?: unknown, signal?: AbortSignal): AsyncIterable<StreamEvent>;
 }
 export declare class KimiProvider extends OpenAIProvider {
     constructor(apiKey: string, model?: string);

package/dist/providers/openai.js

@@ -17,7 +17,7 @@ export class OpenAIProvider {
     async complete(context, tools, extensions) {
         return collectStreamMessage(this.stream(context, tools, extensions));
     }
-    async *streamInner(context, tools, extraBody, exposeReasoning = false) {
+    async *streamInner(context, tools, extraBody, exposeReasoning = false, signal) {
         const body = {
             model: this.model,
             messages: toOpenAIMessages(context),
@@ -29,6 +29,7 @@ export class OpenAIProvider {
             method: "POST",
             headers: { "Authorization": `Bearer ${this.apiKey}`, "Content-Type": "application/json" },
             body: JSON.stringify(body),
+            ...(signal ? { signal } : {}), // #2-B-ii: a preempt aborts the in-flight request at the socket.
         });
         if (!resp.ok)
             throw new Error(`OpenAI ${resp.status}: ${await resp.text()}`);
@@ -79,16 +80,16 @@ export class OpenAIProvider {
             yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
         }
     }
-    async *stream(context, tools, extensions) {
+    async *stream(context, tools, extensions, _state, signal) {
         const { expose_reasoning: _, exposeReasoning: __, ...passthrough } = extensions ?? {};
-        yield* this.streamInner(context, tools, passthrough);
+        yield* this.streamInner(context, tools, passthrough, false, signal);
     }
 }
 export class QwenProvider extends OpenAIProvider {
     constructor(apiKey, model = "qwen-max") {
         super(apiKey, model, "https://dashscope.aliyuncs.com/compatible-mode/v1");
     }
-    async *stream(context, tools, extensions) {
+    async *stream(context, tools, extensions, _state, signal) {
         const enableThinking = Boolean(extensions?.enableThinking);
         const thinkingBudget = extensions?.thinkingBudget;
         const { enableThinking: _, thinkingBudget: __, expose_reasoning: ___, exposeReasoning: ____, ...passthrough } = extensions ?? {};
@@ -96,31 +97,31 @@ export class QwenProvider extends OpenAIProvider {
             ...passthrough,
             ...(enableThinking ? { enable_thinking: true, ...(thinkingBudget ? { thinking_budget: thinkingBudget } : {}) } : {}),
         };
-        yield* this.streamInner(context, tools, extra, enableThinking);
+        yield* this.streamInner(context, tools, extra, enableThinking, signal);
     }
 }
 export class DeepSeekProvider extends OpenAIProvider {
     constructor(apiKey, model = "deepseek-chat") {
         super(apiKey, model, "https://api.deepseek.com/v1");
     }
-    async *stream(context, tools, extensions) {
+    async *stream(context, tools, extensions, _state, signal) {
         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(context, filteredTools, passthrough, exposeReasoning);
+        yield* this.streamInner(context, filteredTools, passthrough, exposeReasoning, signal);
     }
 }
 export class MiniMaxProvider extends OpenAIProvider {
     constructor(apiKey, model = "MiniMax-Text-01") {
         super(apiKey, model, "https://api.minimax.chat/v1");
     }
-    async *stream(context, tools, extensions) {
+    async *stream(context, tools, extensions, _state, signal) {
         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(context, filteredTools, passthrough, exposeReasoning);
+        yield* this.streamInner(context, filteredTools, passthrough, exposeReasoning, signal);
     }
 }
 export class KimiProvider extends OpenAIProvider {

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

@@ -18,6 +18,9 @@ export interface RunContext {
     onToolSuspend?: (event: ToolSuspendEvent) => Promise<unknown> | unknown;
     onPermissionRequest?: (event: PermissionRequestEvent) => Promise<PermissionResponse | boolean> | PermissionResponse | boolean;
     resultSpool?: LargeResultSpool;
+    /** M3/G4: working directory a tool should run in. WASM has no filesystem, so this is carried for
+     *  tool-ABI parity with Node/Python rather than consumed by a worktree plane. */
+    cwd?: string;
 }
 export interface ExecutionPlane {
     register(...tools: RegisteredTool[]): this;

package/dist/runtime/execution-plane.js

@@ -73,7 +73,9 @@ export class LocalExecutionPlane {
             }
             try {
                 const args = JSON.parse(call.arguments || "{}");
-                const output = await registered.execute(args);
+                // M3/G4: pass the run context for tool-ABI parity with Node/Python (`RunContext` is
+                // structurally assignable to the tool's `ToolExecContext`).
+                const output = await registered.execute(args, ctx);
                 yield { type: "tool_result", callId: call.id, name: call.name, content: String(output), isError: false };
             }
             catch (err) {

package/dist/runtime/runner.d.ts

@@ -42,6 +42,12 @@ export interface MemoryPolicy {
 }
 export interface RuntimeOptions {
     provider: LLMProvider;
+    /** M1/G3 intelligence routing: resolve a per-node provider from a workflow node's `modelHint`.
+     *  Returns undefined ⇒ fall back to `provider`. Without this hook the hint is a no-op. */
+    providerFor?: (modelHint: string) => LLMProvider | undefined;
+    /** M4/G5: cumulative token cap for this run (the kernel's `max_total_tokens`); a node's `tokenBudget`
+     *  flows here for its child run. Undefined ⇒ the kernel default. */
+    maxTotalTokens?: number;
     sessionLog: SessionLog;
     executionPlane: ExecutionPlane;
     maxTokens: number;
@@ -70,6 +76,10 @@ export interface RuntimeOptions {
     onToolSuspend?: (event: ToolSuspendEvent) => Promise<unknown> | unknown;
     onPermissionRequest?: (event: PermissionRequestEvent) => Promise<PermissionResponse | boolean> | PermissionResponse | boolean;
     subAgentOrchestrator?: SubAgentOrchestrator;
+    /** M5 v2.1: marks this runner as a workflow node (child of the workflow driver). A workflow node's
+     *  `start_workflow` FLATTENS to the parent kernel; a top-level run (unset) AUTO-PIVOTS — bootstraps +
+     *  drives the authored workflow in its own kernel, then resumes the reason loop with the outcome. */
+    isWorkflowNode?: boolean;
     /** G2: custom reducers for `NodeKind::Reduce` workflow nodes, merged over the built-ins. */
     reducers?: ReducerRegistry;
     milestonePolicy?: MilestonePolicy;
@@ -88,11 +98,16 @@ export interface RuntimeOptions {
 export declare class RuntimeRunner {
     private readonly opts;
     private interrupted;
+    /** #2-B-ii: aborts the in-flight provider stream on interrupt/preempt. Recreated per `execute`. */
+    private abortController;
     private pendingObservations;
     private activeKernel;
     private currentSessionId;
     private nextArchiveStart;
     private localPageOutCache;
+    /** M5 v2.1: sub-workflow specs a top-level agent authored via `start_workflow`, awaiting auto-drive
+     *  at the next safe point (after the tool turn resolves, kernel back in Reason). */
+    private pendingAuthoredWorkflows;
     private pendingSpoolOutputs;
     constructor(opts: RuntimeOptions);
     get hostOptions(): RuntimeOptions;
@@ -140,7 +155,42 @@ export declare class RuntimeRunner {
     }): Promise<{
         completed: string[];
         failed: string[];
+        outputs: Record<string, string>;
     }>;
+    /**
+     * M5/G1: bootstrap an **agent-authored** workflow ("the model writes its own harness"). Routes the
+     * spec through the agent-reachable `Syscall::LoadWorkflow` (`submit_workflow`): with no workflow
+     * active the kernel bootstraps the DAG, else it flattens onto the running one (bootstrap-or-flatten —
+     * one kernel, one quota). The same shared driver runs the resulting batches.
+     */
+    bootstrapWorkflow(spec: WorkflowSpec, opts?: {
+        submitterAgentId?: string;
+    }): Promise<{
+        completed: string[];
+        failed: string[];
+        outputs: Record<string, string>;
+    }>;
+    /**
+     * M5 v2.1: drive the sub-workflow(s) a top-level agent authored via `start_workflow`, at the safe
+     * point (tool turn resolved → kernel in Reason). Each runs in THIS kernel (the kernel resumes the
+     * reason loop on `workflow_completed`), then the outcome is injected as a user message and a fresh
+     * `call_provider` is synthesized from the updated context (the workflow drive consumed its own
+     * kernel actions — same re-render pattern as the reactive-compact retry path).
+     */
+    private driveAuthoredWorkflows;
+    /**
+     * #2-B-ii: while a workflow batch is in flight, poll the signal source; a Critical `InterruptNow`
+     * routes through the kernel (root in `SubAgentAwait` → preempt → `AgentPreempted` + tears the
+     * `WorkflowRun` down), and we abort the matching children's in-flight LLM calls. Returns the
+     * torn-down outcome on preemption, else `null`. No-op without a signal source.
+     */
+    private monitorWorkflowPreemption;
+    /**
+     * Shared workflow driver for `runWorkflow` (host `load_workflow`) and `bootstrapWorkflow` (agent
+     * `submit_workflow`): run each kernel-emitted batch in parallel, feed completions back (appending any
+     * agent-submitted nodes first), and loop until the kernel reports the workflow complete.
+     */
+    private driveWorkflow;
     /**
      * Resume a workflow from the parent session's completed nodes.
      * Reads the session log, extracts completed workflow node agent_ids, and