@deepstrike/wasm 0.2.74 → 0.2.75

package/dist/runtime/tool-arguments.d.ts

@@ -0,0 +1,24 @@
+/** Tool-call argument text is model-authored. A call whose arguments are not a JSON object (a
+ *  truncated stream, prose, an array) must reach the executor as-is so it fails as an invalid
+ *  call — rewriting it to `{}` would run the tool with empty arguments the model never wrote. */
+/** Canonical text for a model-authored argument string: re-serialized when it is a JSON object,
+ *  `{}` when empty, and the raw text verbatim otherwise. */
+export declare function toolArgumentsText(raw: string | undefined): string;
+/** Wire value handed to the kernel: the object when the text is one, the raw string otherwise
+ *  (the kernel carries arguments opaquely and hands the same value back on `execute_tools`). */
+export declare function toolArgumentsToWire(raw: string | undefined): Record<string, unknown> | string;
+/** Inverse of {@link toolArgumentsToWire}: kernel-carried arguments back to SDK text. */
+export declare function toolArgumentsFromWire(value: unknown): string;
+/** `{ rawArguments }` for a streamed `tool_call` event whose text is not a JSON object. */
+export declare function malformedToolArguments(raw: string | undefined): {
+    rawArguments?: string;
+};
+export type ParsedToolArguments = {
+    ok: true;
+    args: Record<string, unknown>;
+} | {
+    ok: false;
+    error: string;
+};
+/** Parse arguments for execution. Anything but a JSON object is an invalid call. */
+export declare function parseToolCallArguments(raw: string | undefined): ParsedToolArguments;

package/dist/runtime/tool-arguments.js

@@ -0,0 +1,61 @@
+/** Tool-call argument text is model-authored. A call whose arguments are not a JSON object (a
+ *  truncated stream, prose, an array) must reach the executor as-is so it fails as an invalid
+ *  call — rewriting it to `{}` would run the tool with empty arguments the model never wrote. */
+/** Canonical text for a model-authored argument string: re-serialized when it is a JSON object,
+ *  `{}` when empty, and the raw text verbatim otherwise. */
+export function toolArgumentsText(raw) {
+    const text = raw ?? "";
+    if (text.trim() === "")
+        return "{}";
+    const parsed = tryParse(text);
+    return isJsonObject(parsed) ? JSON.stringify(parsed) : text;
+}
+/** Wire value handed to the kernel: the object when the text is one, the raw string otherwise
+ *  (the kernel carries arguments opaquely and hands the same value back on `execute_tools`). */
+export function toolArgumentsToWire(raw) {
+    const text = raw ?? "";
+    if (text.trim() === "")
+        return {};
+    const parsed = tryParse(text);
+    return isJsonObject(parsed) ? parsed : text;
+}
+/** Inverse of {@link toolArgumentsToWire}: kernel-carried arguments back to SDK text. */
+export function toolArgumentsFromWire(value) {
+    if (typeof value === "string")
+        return value;
+    return JSON.stringify(value ?? {});
+}
+/** `{ rawArguments }` for a streamed `tool_call` event whose text is not a JSON object. */
+export function malformedToolArguments(raw) {
+    const text = raw ?? "";
+    if (text.trim() === "")
+        return {};
+    return isJsonObject(tryParse(text)) ? {} : { rawArguments: text };
+}
+/** Parse arguments for execution. Anything but a JSON object is an invalid call. */
+export function parseToolCallArguments(raw) {
+    const text = raw ?? "";
+    if (text.trim() === "")
+        return { ok: true, args: {} };
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (err) {
+        return { ok: false, error: `arguments are not valid JSON (${err.message})` };
+    }
+    if (!isJsonObject(parsed))
+        return { ok: false, error: "arguments must be a JSON object" };
+    return { ok: true, args: parsed };
+}
+function tryParse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/runtime/types/agent.d.ts

@@ -159,6 +159,8 @@ export interface SchedulingFactors {
 }
 export declare function workflowNodeStatusFromTermination(termination: TerminationReason | string): WorkflowNodeStatus;
 export interface WorkflowNodeSpec {
+    /** Caller-declared wire identity; absent ⇒ the canonical lowering assigns a positional id. */
+    nodeId?: string;
     task: WorkflowTaskSpec;
     role: KernelAgentRole;
     isolation?: AgentIsolation;
@@ -240,6 +242,8 @@ export declare function workflowNodeOutcomeFromKernel(raw: KernelWorkflowNodeOut
 /** Per-node spawn descriptor carried in the `workflow_batch_spawned` observation. */
 export interface WorkflowSpawnInfo {
     agent_id: string;
+    /** The kernel-minted attempt this launch runs as; echoed back on the node's completion. */
+    attempt_id?: string;
     goal: string;
     role: string;
     isolation: string;

package/dist/runtime/types/agent.js

@@ -203,6 +203,7 @@ export function workflowNodeSpecToKernel(n) {
     const kind = nodeKindToKernel(n);
     const schedulingFactors = schedulingFactorsToKernel(n.schedulingFactors);
     return {
+        ...(n.nodeId ? { node_id: n.nodeId } : {}),
         task: workflowTaskToKernel(n.task),
         role: n.role,
         isolation: n.isolation ?? "shared",
@@ -254,6 +255,7 @@ export function workflowSpecToKernel(spec) {
  *  (append) and `start_workflow` (workflow authoring: author a sub-workflow), so the two tools never drift. */
 const workflowNodesArraySchema = {
     type: "array",
+    description: "Workflow nodes (a DAG); each runs as a gated sub-agent. `dependsOn` is batch-relative.",
     items: {
         type: "object",
         properties: {
@@ -261,58 +263,9 @@ const workflowNodesArraySchema = {
             role: { type: "string", enum: ["explore", "plan", "implement", "verify", "custom"] },
             isolation: { type: "string", enum: ["shared", "read_only", "worktree", "remote"] },
             contextInheritance: { type: "string", enum: ["none", "system_only", "full"] },
-            trust: { type: "string", enum: ["trusted", "quarantined"] },
             outputSchema: { type: "object", description: "Optional JSON Schema the node's output must conform to." },
             modelHint: { type: "string", description: "Preferred model for this node (e.g. \"opus\"/\"sonnet\"); the host routes it." },
-            reducer: { type: "string", description: "Make this a deterministic reduce node (no LLM); names a registered reducer." },
-            loop: {
-                type: "object",
-                description: "Make this a loop node: re-run up to maxIters times, ending early when the agent reports done.",
-                properties: { maxIters: { type: "integer", description: "Hard iteration cap." } },
-                required: ["maxIters"],
-            },
-            classify: {
-                type: "object",
-                description: "Make this a classify node: pick one branch label; that branch's nodes run, the rest are pruned.",
-                properties: {
-                    branches: {
-                        type: "array",
-                        items: {
-                            type: "object",
-                            properties: {
-                                label: { type: "string" },
-                                nodes: { type: "array", items: { type: "integer" }, description: "Batch-relative node indices for this branch." },
-                            },
-                            required: ["label", "nodes"],
-                        },
-                    },
-                },
-                required: ["branches"],
-            },
-            tournament: {
-                type: "object",
-                description: "Make this a tournament controller: generate each entrant, then pairwise-judge to one winner.",
-                properties: {
-                    entrants: {
-                        type: "array",
-                        description: "≥2 candidate tasks to generate and judge.",
-                        items: {
-                            oneOf: [
-                                { type: "string" },
-                                { type: "object", properties: { goal: { type: "string" }, criteria: { type: "array", items: { type: "string" } } }, required: ["goal"] },
-                            ],
-                        },
-                    },
-                },
-                required: ["entrants"],
-            },
-            tokenBudget: { type: "integer", description: "Cap this node's child run at this many cumulative tokens." },
             dependsOn: { type: "array", items: { type: "integer" } },
-            depPolicy: {
-                type: "string",
-                enum: ["all_success", "accept_partial", "all_terminal", "optional"],
-                description: "How dependency terminal states gate this node; defaults to all_success.",
-            },
         },
         required: ["task", "role"],
     },
@@ -321,9 +274,7 @@ export const submitWorkflowNodesTool = {
     name: "submit_workflow_nodes",
     description: "Append new nodes to the running workflow DAG (dynamic fan-out / loop-until-done). Each node " +
         "spawns as a gated sub-agent. Use when you discover more work that should run as its own node. " +
-        "A node may declare ONE control-flow kind — `loop` / `classify` / `tournament` / `reducer` — " +
-        "otherwise it is a plain spawn. Within a submission, `dependsOn` and `classify.branches[].nodes` " +
-        "are batch-relative (index 0 = this batch's first node).",
+        "Within a submission, `dependsOn` is batch-relative (index 0 = this batch's first node).",
     parameters: JSON.stringify({
         type: "object",
         properties: { nodes: workflowNodesArraySchema },
@@ -335,9 +286,9 @@ export const submitWorkflowNodesTool = {
  *  (a `WorkflowSpec` is a node batch). Top-level bootstrap uses (the `LoadWorkflow` syscall). */
 export const startWorkflowTool = {
     name: "start_workflow",
-    description: "Author and run a sub-workflow: a DAG of nodes (fan-out / classify / tournament / loop / reduce) " +
-        "composed onto the current run. Use to structure a multi-step task as its own harness. The nodes " +
-        "spawn as gated sub-agents; `dependsOn` / `classify.branches[].nodes` are spec-relative.",
+    description: "Author and run a sub-workflow: a DAG of nodes (fan-out / fan-in) composed onto the current run. " +
+        "Use to structure a multi-step task as its own harness. The nodes spawn as gated sub-agents; " +
+        "`dependsOn` is spec-relative.",
     parameters: JSON.stringify({
         type: "object",
         properties: {

package/dist/types.d.ts

@@ -114,7 +114,8 @@ export interface ToolCallEvent extends StreamEvent {
     type: "tool_call";
     id: string;
     name: string;
-    arguments: Record<string, unknown>;
+    arguments: Record<string, unknown>; /** The model's argument text, present only when it was not a JSON object (then `arguments` is `{}`); executed so the call fails as invalid. */
+    rawArguments?: string;
 }
 export interface ToolResultEvent extends StreamEvent {
     type: "tool_result";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/wasm",
-  "version": "0.2.74",
+  "version": "0.2.75",
   "description": "DeepStrike WASM SDK — browser, Cloudflare Workers, Deno Deploy",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",
@@ -14,10 +14,10 @@
     "build:wasm": "wasm-pack build ../crates/deepstrike-wasm --target bundler --out-dir ../../wasm/pkg",
     "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc",
     "test": "node --experimental-vm-modules node_modules/.bin/jest",
-    "test:canonical-binding": "wasm-pack build ../crates/deepstrike-wasm --target nodejs --dev --out-dir ../../wasm/pkg-node && node tests/canonical-binding.node.cjs && node tests/golden-fixtures-sweep.node.cjs"
+    "test:canonical-binding": "wasm-pack build ../crates/deepstrike-wasm --target nodejs --dev --out-dir ../../wasm/pkg-node && node tests/canonical-binding.node.cjs && node tests/golden-fixtures-sweep.node.cjs && npm run build && node tests/boundary-p0-regressions.node.mjs && node tests/boundary-p1-regressions.node.mjs && node tests/boundary-p2-regressions.node.mjs"
   },
   "dependencies": {
-    "@deepstrike/wasm-kernel": "0.2.74"
+    "@deepstrike/wasm-kernel": "0.2.75"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",