@deepstrike/wasm 0.2.22 → 0.2.26

package/dist/runtime/types/agent.js

@@ -65,6 +65,19 @@ export function milestoneCheckResultToKernel(result) {
         ...(result.reason ? { reason: result.reason } : {}),
     };
 }
+/** Tool-call `arguments` reach us as a raw model-authored string (e.g. the OpenAIChat-family
+ *  non-streaming path passes it through verbatim via `normalizeToolCalls`). A malformed JSON
+ *  string must degrade to empty args here, never throw — otherwise one bad tool-call on a
+ *  sub-agent's final turn bricks the parent's result serialization. Mirrors the `catch→{}`
+ *  guard every provider/runtime parse site already uses. */
+function safeParseToolArgs(raw) {
+    try {
+        return JSON.parse(raw || "{}");
+    }
+    catch {
+        return {};
+    }
+}
 export function subAgentResultToKernel(result) {
     const finalMessage = result.result.finalMessage;
     return {
@@ -78,7 +91,7 @@ export function subAgentResultToKernel(result) {
                     tool_calls: (finalMessage.toolCalls ?? []).map(tc => ({
                         id: tc.id,
                         name: tc.name,
-                        arguments: JSON.parse(tc.arguments || "{}"),
+                        arguments: safeParseToolArgs(tc.arguments),
                     })),
                     ...(finalMessage.tokenCount !== undefined ? { token_count: finalMessage.tokenCount } : {}),
                 }

package/dist/tools/errors.d.ts

@@ -0,0 +1,42 @@
+import type { ToolExecContext, RegisteredTool } from "./index.js";
+/** Stable JSON shape returned to the model by `safeTool`. Same shape as the Node SDK so a tool
+ *  authored once works across both runtimes. The model can branch on `code` instead of pattern-
+ *  matching free-form strings; `hint` is the self-correcting affordance (e.g. "call document_outline
+ *  first"). */
+export interface ToolEnvelopeOk<T = unknown> {
+    success: true;
+    data?: T;
+}
+export interface ToolEnvelopeFail {
+    success: false;
+    code: string;
+    error: string;
+    hint?: string;
+}
+export type ToolEnvelope<T = unknown> = ToolEnvelopeOk<T> | ToolEnvelopeFail;
+/** Error class understood by `safeTool` and the runtime's error-aware serialization. Throwing
+ *  it produces `{success:false, code, error, hint?}`; a plain `Error` with string `.code`/`.hint`
+ *  is honored too, so existing code keeps working without migration. */
+export declare class ToolError extends Error {
+    code: string;
+    hint?: string;
+    constructor(message: string, opts?: {
+        code?: string;
+        hint?: string;
+        cause?: unknown;
+    });
+}
+export declare function ok<T>(data?: T): ToolEnvelopeOk<T>;
+export declare function fail(code: string, error: string, hint?: string): ToolEnvelopeFail;
+/** Error-aware serialization for tool-execution error paths. Replaces `String(err)` at the
+ *  sites that hand the model (or the host's stream) a failure message.
+ *
+ *  - `Error` with no extra fields → `err.message` (clean, no `"Error: "` prefix).
+ *  - `Error` carrying `code` / `hint` / `cause` → JSON `{message, name?, code?, hint?, cause?}`.
+ *  - Plain objects → `JSON.stringify(...)` (replaces the old `"[object Object]"`).
+ *  - Primitives / null / undefined → `String(...)` (unchanged). */
+export declare function formatToolError(err: unknown): string;
+/** `tool()` equivalent that wraps the body in a try/catch and returns a stable
+ *  `{success, code, error, hint?}` JSON envelope to the model. Opt-in; the classic `tool()`
+ *  factory is unchanged. See the Node SDK for the full rationale. */
+export declare function safeTool<T = unknown>(name: string, description: string, parameters: Record<string, unknown>, fn: (args: Record<string, unknown>, ctx?: ToolExecContext) => Promise<ToolEnvelope<T> | T> | ToolEnvelope<T> | T): RegisteredTool;

package/dist/tools/errors.js

@@ -0,0 +1,97 @@
+import { tool } from "./index.js";
+/** Error class understood by `safeTool` and the runtime's error-aware serialization. Throwing
+ *  it produces `{success:false, code, error, hint?}`; a plain `Error` with string `.code`/`.hint`
+ *  is honored too, so existing code keeps working without migration. */
+export class ToolError extends Error {
+    code;
+    hint;
+    constructor(message, opts = {}) {
+        super(message, opts.cause !== undefined ? { cause: opts.cause } : undefined);
+        this.name = "ToolError";
+        this.code = opts.code ?? "internal";
+        if (opts.hint !== undefined)
+            this.hint = opts.hint;
+    }
+}
+export function ok(data) {
+    return data === undefined ? { success: true } : { success: true, data };
+}
+export function fail(code, error, hint) {
+    return hint === undefined ? { success: false, code, error } : { success: false, code, error, hint };
+}
+function isEnvelope(v) {
+    return typeof v === "object" && v !== null && "success" in v &&
+        typeof v.success === "boolean";
+}
+/** Error-aware serialization for tool-execution error paths. Replaces `String(err)` at the
+ *  sites that hand the model (or the host's stream) a failure message.
+ *
+ *  - `Error` with no extra fields → `err.message` (clean, no `"Error: "` prefix).
+ *  - `Error` carrying `code` / `hint` / `cause` → JSON `{message, name?, code?, hint?, cause?}`.
+ *  - Plain objects → `JSON.stringify(...)` (replaces the old `"[object Object]"`).
+ *  - Primitives / null / undefined → `String(...)` (unchanged). */
+export function formatToolError(err) {
+    if (err == null)
+        return String(err);
+    if (typeof err === "string")
+        return err;
+    if (err instanceof Error) {
+        const anyErr = err;
+        const code = anyErr.code;
+        const hint = anyErr.hint;
+        const cause = anyErr.cause;
+        if (code === undefined && hint === undefined && cause === undefined) {
+            return err.message || err.name || "Error";
+        }
+        const payload = { message: err.message };
+        if (err.name && err.name !== "Error")
+            payload.name = err.name;
+        if (code !== undefined)
+            payload.code = code;
+        if (hint !== undefined)
+            payload.hint = hint;
+        if (cause !== undefined)
+            payload.cause = cause instanceof Error ? cause.message : cause;
+        try {
+            return JSON.stringify(payload);
+        }
+        catch {
+            return err.message || err.name || "Error";
+        }
+    }
+    if (typeof err === "object") {
+        try {
+            return JSON.stringify(err);
+        }
+        catch {
+            return Object.prototype.toString.call(err);
+        }
+    }
+    return String(err);
+}
+/** `tool()` equivalent that wraps the body in a try/catch and returns a stable
+ *  `{success, code, error, hint?}` JSON envelope to the model. Opt-in; the classic `tool()`
+ *  factory is unchanged. See the Node SDK for the full rationale. */
+export function safeTool(name, description, parameters, fn) {
+    const wrapped = async (args, ctx) => {
+        try {
+            const result = await fn(args, ctx);
+            if (isEnvelope(result))
+                return JSON.stringify(result);
+            return JSON.stringify(ok(result));
+        }
+        catch (err) {
+            if (err instanceof ToolError) {
+                return JSON.stringify(fail(err.code, err.message || err.name, err.hint));
+            }
+            if (err instanceof Error) {
+                const anyErr = err;
+                const code = typeof anyErr.code === "string" ? anyErr.code : "internal";
+                const hint = typeof anyErr.hint === "string" ? anyErr.hint : undefined;
+                return JSON.stringify(fail(code, err.message || err.name || "Error", hint));
+            }
+            return JSON.stringify(fail("internal", formatToolError(err)));
+        }
+    };
+    return tool(name, description, parameters, wrapped);
+}

package/dist/tools/index.d.ts

@@ -2,9 +2,16 @@ import type { ToolSchema, ToolResult } from "../types.js";
 /** M3/G4: the runtime context a tool may read when executing (carries the working directory). A
  *  narrow, dependency-free shape; the execution plane's `RunContext` is structurally assignable to it.
  *  (WASM has no filesystem, so worktree isolation is N/A here — this keeps the tool ABI in parity
- *  with the Node/Python ports so a tool authored once works across all of them.) */
+ *  with the Node/Python ports so a tool authored once works across all of them.)
+ *
+ *  `audit` is the best-effort post-commit side-effect channel: wrap an audit-log write or metrics
+ *  emit in `await ctx.audit(label, () => store.write(...))`. If the side-effect throws, the failure
+ *  surfaces as a `tool_audit_failed` stream event and the tool still completes successfully —
+ *  avoiding the foot-gun where a transient audit-store outage flips an already-committed write
+ *  into `isError: true` and triggers a duplicate retry. */
 export interface ToolExecContext {
     cwd?: string;
+    audit?: (label: string, fn: () => Promise<void> | void) => Promise<void>;
 }
 export interface RegisteredTool {
     schema: ToolSchema;

package/dist/tools/index.js

@@ -1,3 +1,4 @@
+import { formatToolError } from "./errors.js";
 export function tool(name, description, parameters, fn) {
     return {
         schema: { name, description, parameters: JSON.stringify(parameters) },
@@ -14,7 +15,7 @@ export async function executeTools(calls, registry) {
             return { callId: c.id, output: await t.execute(args), isError: false };
         }
         catch (err) {
-            return { callId: c.id, output: String(err), isError: true };
+            return { callId: c.id, output: formatToolError(err), isError: true };
         }
     }));
 }

package/dist/types.d.ts

@@ -69,6 +69,11 @@ export interface UsageEvent extends StreamEvent {
     outputTokens?: number;
     cacheReadInputTokens?: number;
     cacheCreationInputTokens?: number;
+    cacheReadInputTokensBySlot?: {
+        system?: number;
+        tools?: number;
+        messages?: number;
+    };
 }
 export interface ThinkingDelta extends StreamEvent {
     type: "thinking_delta";
@@ -131,6 +136,16 @@ export interface ToolDeniedEvent extends StreamEvent {
     toolName: string;
     reason: string;
 }
+/** A tool's `ctx.audit(label, fn)` best-effort side-effect threw. The tool itself completed
+ *  successfully (no isError flip, no retry); this event lets the host log / monitor that an
+ *  audit-store / metrics-emit / non-essential persistence step failed. */
+export interface ToolAuditFailedEvent extends StreamEvent {
+    type: "tool_audit_failed";
+    callId: string;
+    name: string;
+    label: string;
+    error: string;
+}
 export interface ToolArgumentRepairedEvent extends StreamEvent {
     type: "tool_argument_repaired";
     callId: string;

package/package.json

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