@deepstrike/wasm 0.2.73 → 0.2.75

package/dist/memory/authority.js

@@ -0,0 +1,34 @@
+import { getKernel } from "../runtime/kernel.js";
+async function ask(request) {
+    const kernel = await getKernel();
+    return JSON.parse(kernel.memoryAuthorityJson(JSON.stringify(request)));
+}
+/** Would the kernel admit this write? Resolves to the refusal reason, or `undefined` when admitted. */
+export async function checkMemoryWrite(policy, name, content) {
+    const answer = await ask({
+        op: "check_write",
+        ...(policy ? { policy } : {}),
+        name,
+        content_bytes: new TextEncoder().encode(content).byteLength,
+    });
+    return answer.admitted === true ? undefined : String(answer.error ?? "memory write refused");
+}
+/** Derive one recall's lifecycle from the counts the store reported it held. */
+export async function deriveMemoryRecall(policy, recalledAt, hits) {
+    if (hits.length === 0)
+        return { recalls: [], promotions: [] };
+    const answer = await ask({
+        op: "derive_recall",
+        ...(policy ? { policy } : {}),
+        recalled_at: Math.max(0, Math.trunc(recalledAt)),
+        recalls: hits.map(hit => ({
+            record_id: hit.record.record_id,
+            recall_count: Math.max(0, Math.trunc(hit.record.recall_count ?? 0)),
+            ...(hit.record.pinned ? { pinned: true } : {}),
+        })),
+    });
+    return {
+        recalls: (answer.recalls ?? []),
+        promotions: (answer.promotions ?? []),
+    };
+}

package/dist/memory/durable.d.ts

@@ -3,8 +3,8 @@ import type { Memory, MemoryRecord, MemoryScope, MemorySearchOptions, MemoryStor
 export declare class DurableMemory implements Memory {
     private readonly store;
     private readonly agentId;
-    private readonly scope;
     readonly namespace: string;
+    readonly scope: MemoryScope;
     constructor(store: MemoryStore, agentId: string, scope: MemoryScope);
     search(query: string, options?: MemorySearchOptions): Promise<MemoryRecord[]>;
     get(recordId: string): Promise<MemoryRecord | null>;

package/dist/memory/durable.js

@@ -2,13 +2,13 @@
 export class DurableMemory {
     store;
     agentId;
-    scope;
     namespace;
+    scope;
     constructor(store, agentId, scope) {
         this.store = store;
         this.agentId = agentId;
-        this.scope = scope;
         this.namespace = scope.namespace;
+        this.scope = scope;
     }
     async search(query, options = {}) {
         const request = {

package/dist/providers/anthropic.js

@@ -1,5 +1,6 @@
 import { requestSnapshot } from "./prepared-request.js";
 import { assistantReplayKey, collectStreamMessage, toAnthropicMessages } from "./base.js";
+import { malformedToolArguments, toolArgumentsText } from "../runtime/tool-arguments.js";
 /** Anthropic accepts at most this many cache_control breakpoints per request. */
 const MAX_CACHE_BREAKPOINTS = 4;
 /** Rolling cache breakpoints reserved for the message history (system uses ≤2). */
@@ -317,8 +318,8 @@ export class AnthropicProvider {
                                 args = {};
                             }
                             nativeBlocks[idx] = { ...nativeBlocks[idx], input: args };
-                            finalToolCalls.push({ id: tb.id, name: tb.name, arguments: JSON.stringify(args) });
-                            yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
+                            finalToolCalls.push({ id: tb.id, name: tb.name, arguments: toolArgumentsText(tb.argsBuf) });
+                            yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args, ...malformedToolArguments(tb.argsBuf) };
                         }
                     }
                 }

package/dist/providers/openai.js

@@ -1,5 +1,6 @@
 import { requestSnapshot } from "./prepared-request.js";
 import { collectStreamMessage, toOpenAIMessages } from "./base.js";
+import { malformedToolArguments } from "../runtime/tool-arguments.js";
 const DEEPSEEK_REASONERS = new Set(["deepseek-reasoner", "deepseek-r1"]);
 const MINIMAX_REASONERS = new Set(["MiniMax-M1", "minimax-m1"]);
 // OpenAI-compatible provider — works for OpenAI, Qwen (DashScope), DeepSeek, MiniMax, Kimi
@@ -107,7 +108,7 @@ export class OpenAIProvider {
             catch {
                 args = {};
             }
-            yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
+            yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args, ...malformedToolArguments(tb.argsBuf) };
         }
     }
     prepareRequest(context, tools, extensions, state) {

package/dist/runtime/canonical-kernel-step.d.ts

@@ -43,6 +43,12 @@ export declare class CanonicalKernelRejectedError extends Error {
     readonly fault: Record<string, unknown>;
     constructor(faultJson: string);
 }
+/**
+ * Whether a run-loop failure was the kernel refusing a malformed input (`invalid_arg`) rather than
+ * any other error. Decided by the fault the kernel named, or a binding's argument-conversion
+ * status — never by searching the message text.
+ */
+export declare function isInvalidInputError(error: unknown): boolean;
 /**
  * A record is already authoritative once the journal append returns. A later native commit failure
  * is therefore a rebuild boundary, never an abort boundary.
@@ -68,6 +74,13 @@ export declare class CanonicalKernelHost {
     readonly journal: KernelJournal;
     readonly operationId: string;
     constructor(kernel: CanonicalKernelInstance, journal: KernelJournal, operationId: string);
+    /**
+     * The journal holds one outbound envelope slot per operation, so two transitions of the same
+     * operation must never overlap: the second would overwrite the first's staged bytes before its
+     * append was acknowledged. Every entry point that stages or drains goes through this queue.
+     */
+    private exclusiveTail;
+    private exclusive;
     transition(input: CanonicalKernelInput, options?: CanonicalTransitionOptions): Promise<CanonicalTransition>;
     /** Restore the latest installed checkpoint and its authoritative record tail in place. */
     restore(): Promise<CanonicalRestoreCost>;
@@ -94,6 +107,10 @@ export interface CanonicalRunnerRuntimeOptions {
         preview: string;
     }>;
 }
+/** Positional ids for anonymous appended nodes. A known DAG size yields `wf-node{base+i}`, the same
+ *  id the kernel gives the node internally; an unknown size (after a restore) yields a batch-scoped
+ *  id that cannot collide with anything already declared. */
+export type WorkflowNodeIdBase = number | string;
 export declare function sha256(value: string): string;
 /**
  * Canonical operation runtime used by the WASM host.
@@ -108,9 +125,17 @@ export declare class CanonicalRunnerRuntime {
     private started;
     private turns;
     private lastAction;
+    /** Live policy revision (§13.2): 0 at genesis, then each `live_policy_changed`. Unknown after a
+     *  restore, when a patch must name the revision it expects explicitly. */
+    private policyRevision;
+    /** Kernel-minted attempt per launched task, learned from each launch acknowledgement. */
+    private readonly taskAttempts;
     private readonly newMessages;
     private readonly hostObservations;
     private spawnedTasks;
+    /** Nodes in the active workflow DAG, mirrored from committed facts so anonymous appended nodes get
+     *  unique positional ids. `undefined` after a restore until the next committed submission. */
+    private workflowNodeCount;
     private readonly memoryBindingId;
     private payloadInlineThreshold;
     private payloadPreviewBytes;
@@ -119,6 +144,8 @@ export declare class CanonicalRunnerRuntime {
     get journal(): KernelJournal;
     turn(): number;
     isTerminal(): boolean;
+    /** Whether the operation has a root — the precondition for any live host control command. */
+    hasStarted(): boolean;
     recoveryContentBytes(): number;
     preservedRefs(): string[];
     drainNewMessages(): ModelMessage[];
@@ -129,11 +156,16 @@ export declare class CanonicalRunnerRuntime {
     resumeAction(): KernelRunnerAction | null;
     startAgent(taskValue: Record<string, unknown>, runSpecValue?: Record<string, unknown>): Promise<KernelRunnerAction | null>;
     startWorkflow(specValue: Record<string, unknown>): Promise<KernelRunnerAction | null>;
+    private appendBase;
     applyHostEvent(event: Record<string, unknown>): Promise<KernelRunnerAction | null>;
     private ensureConfigured;
     private commit;
+    /** Record what a committed transition tells the host: its observations and published effects. */
+    private absorbTransition;
     private currentAction;
     private pendingEffects;
+    /** One list field of the pending effect `effectId`, which must be of kind `kind`. */
+    private pendingEffectPayload;
     private succeededEffect;
     private failedEffect;
     private pageOutResolution;