@deepstrike/wasm 0.2.50 → 0.2.51

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

@@ -18,68 +18,13 @@ interface SkillMetadata {
      *  `stable-core ∪ allowedTools`. Absent ⇒ no narrowing (back-compat). */
     allowedTools?: string[];
 }
-export declare const KERNEL_ABI_VERSION = 2;
-export interface KernelRuntimeHandle {
-    step(inputJson: string): string;
-    prepareStep(inputJson: string): string;
-    commitPrepared(prepareToken: string): string;
-    abortPrepared(prepareToken: string): void;
-    snapshot(): string;
-    restore(snapshotJson: string): void;
-    diagnostics(): string;
-    isTerminal(): boolean;
-    turn(): number;
-    recoveryContentBytes(): number;
-    render(): RenderedContext;
-    drainNewMessages(): Message[];
-    preservedRefs(): string[];
-}
-export type KernelPreparationStatus = "prepared" | "replayed" | "rejected";
-export interface KernelPreparedStep {
-    status: KernelPreparationStatus;
-    base_generation: number;
-    prepare_token?: string;
-    input: Record<string, unknown>;
-    step: KernelStepJson;
-}
-export interface KernelDiagnostics {
-    lifecycle: string;
-    next_step_seq: number;
-    accepted_input_count: number;
-    accepted_input_bytes: number;
-    snapshot_input_limit: number;
-    snapshot_journal_bytes_limit: number;
-    max_input_bytes: number;
-    snapshot_overflowed: boolean;
-    recorded_event_count: number;
-    completed_effect_count: number;
-    pending_effect_count: number;
-}
-export declare function readKernelDiagnostics(runtime: KernelRuntimeHandle): KernelDiagnostics;
-export interface KernelSnapshot {
-    snapshot_version: 2;
-    abi_version: 2;
-    initial_policy: {
-        max_tokens: number;
-        max_turns: number;
-        max_total_tokens: string;
-        max_wall_ms?: string;
-    };
-    lifecycle: string;
-    operation_id?: string;
-    next_step_seq: number;
-    snapshot_input_limit: number;
-    max_input_bytes: number;
-    snapshot_journal_bytes_limit: number;
-    accepted_input_bytes: number;
-    accepted_inputs: Array<{
-        event_id: string;
-        [key: string]: unknown;
-    }>;
-    last_step?: Record<string, unknown>;
-}
-export declare function snapshotKernelRuntime(runtime: KernelRuntimeHandle): KernelSnapshot;
-export declare function restoreKernelRuntime(runtime: KernelRuntimeHandle, snapshot: KernelSnapshot): void;
+export declare const CANONICAL_CONTENT_PARTS_PREFIX = "[[deepstrike-content-parts:v1]]";
+/**
+ * Browser/worker-safe transport for typed content. `btoa` and `atob` operate on
+ * binary strings, so explicitly bridge UTF-8 bytes rather than assuming Latin-1.
+ */
+export declare function encodeCanonicalContentParts(parts: unknown[]): string;
+export declare function decodeCanonicalContentParts(content: string): Array<Record<string, unknown>> | undefined;
 export interface PaceDecision {
     action: "continue" | "sleep" | "stop";
     delayMs?: number;
@@ -91,6 +36,7 @@ export interface KernelLoopResult {
     termination: string;
     turnsUsed: number;
     totalTokensUsed: number;
+    finalMessage?: Message;
     /** ③ loop-agent: the kernel-adjudicated after-round decision (absent on non-loop runs). */
     paceDecision?: PaceDecision;
 }
@@ -121,6 +67,10 @@ export type KernelRunnerAction = {
     kind: "preempt_sub_agents";
     effectId: string;
     agentIds: string[];
+    attempts?: Array<{
+        task_id: string;
+        attempt_id: string;
+    }>;
     reason: string;
 } | {
     kind: "persist_memory";
@@ -131,28 +81,36 @@ export type KernelRunnerAction = {
     effectId: string;
     query: Record<string, unknown>;
     requestedK: number;
-} | {
-    kind: "spool_large_result";
-    effectId: string;
-    callId: string;
-    tool: string;
-    output: string;
-    originalSize: number;
-    previewSize: number;
 } | {
     kind: "archive_page_out";
     effectId: string;
-    turn: number;
-    action: string;
+    turn?: number;
+    action?: string;
     summary?: string;
     archived: Message[];
-    tier: string;
+    tier?: string;
+    handleId?: string;
+    payload?: {
+        content: string;
+        digest: string;
+        original_size: string;
+        preview?: string;
+    };
+} | {
+    kind: "load_payload";
+    effectId: string;
+    handleId: string;
+    payloadRef: string;
 } | {
     kind: "evaluate_milestone";
     effectId: string;
     phaseId: string;
     criteria: string[];
     requiredEvidence?: string[];
+} | {
+    kind: "unsupported_effect";
+    effectId: string;
+    effectKind: string;
 } | {
     kind: "done";
     effectId: string;
@@ -181,7 +139,7 @@ export interface KernelObservation {
     evidence?: string[];
     reason?: RollbackReason | string;
     agent_id?: string;
-    parent_session_id?: string;
+    parent_task_id?: string;
     role?: string;
     isolation?: string;
     context_inheritance?: string;
@@ -210,7 +168,6 @@ export interface KernelObservation {
     tier?: string;
     message_count?: number;
     archive_ref?: string;
-    spool_ref?: string;
     record_id?: string;
     scope?: {
         tenant_id: string;
@@ -249,16 +206,6 @@ export interface KernelObservation {
     window_turns?: number;
     threshold?: number;
 }
-interface KernelStepJson {
-    version: number;
-    actions: Array<Record<string, unknown>>;
-    observations: KernelObservation[];
-    faults?: Array<{
-        code?: string;
-        message?: string;
-        effect_id?: string;
-    }>;
-}
 export declare function toolSchemaToKernel(schema: ToolSchema): Record<string, unknown>;
 export declare function skillMetadataToKernel(skill: SkillMetadata): Record<string, unknown>;
 export declare function messageToKernelMessage(message: Message): Record<string, unknown>;
@@ -267,8 +214,6 @@ export declare function taskUpdateToKernel(update: TaskUpdate): Record<string, u
 export declare function capabilityTool(schema: ToolSchema): Record<string, unknown>;
 export declare function capabilitySkill(skill: SkillMetadata): Record<string, unknown>;
 export declare function capabilityMarker(kind: string, id: string, description: string): Record<string, unknown>;
-export declare function kernelApply(runtime: KernelRuntimeHandle, pending: KernelObservation[], event: Record<string, unknown>): KernelObservation[];
-export declare function kernelAction(runtime: KernelRuntimeHandle, pending: KernelObservation[], event: Record<string, unknown>): KernelRunnerAction;
-/** Like kernelAction but tolerates zero-action steps (e.g. queued signals). */
-export declare function kernelMaybeAction(runtime: KernelRuntimeHandle, pending: KernelObservation[], event: Record<string, unknown>): KernelRunnerAction | null;
+export declare function kernelMessageToSdk(raw: Record<string, unknown>): Message;
+export declare function renderedContextToSdk(raw: Record<string, unknown>): RenderedContext;
 export {};

package/dist/runtime/kernel-step.js

@@ -1,24 +1,30 @@
-export const KERNEL_ABI_VERSION = 2;
-export function readKernelDiagnostics(runtime) {
-    return JSON.parse(runtime.diagnostics());
-}
-export function snapshotKernelRuntime(runtime) {
-    return JSON.parse(runtime.snapshot());
-}
-export function restoreKernelRuntime(runtime, snapshot) {
-    runtime.restore(JSON.stringify(snapshot));
-    const operationId = snapshot.operation_id;
-    if (!operationId) {
-        kernelWireStates.delete(runtime);
-        return;
+export const CANONICAL_CONTENT_PARTS_PREFIX = "[[deepstrike-content-parts:v1]]";
+/**
+ * Browser/worker-safe transport for typed content. `btoa` and `atob` operate on
+ * binary strings, so explicitly bridge UTF-8 bytes rather than assuming Latin-1.
+ */
+export function encodeCanonicalContentParts(parts) {
+    const bytes = new TextEncoder().encode(JSON.stringify(parts));
+    let binary = "";
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return `${CANONICAL_CONTENT_PARTS_PREFIX}${btoa(binary)}`;
+}
+export function decodeCanonicalContentParts(content) {
+    if (!content.startsWith(CANONICAL_CONTENT_PARTS_PREFIX))
+        return undefined;
+    try {
+        const binary = atob(content.slice(CANONICAL_CONTENT_PARTS_PREFIX.length));
+        const bytes = Uint8Array.from(binary, character => character.charCodeAt(0));
+        const decoded = JSON.parse(new TextDecoder().decode(bytes));
+        return Array.isArray(decoded)
+            ? decoded.filter((part) => Boolean(part) && typeof part === "object")
+            : undefined;
+    }
+    catch {
+        return undefined;
     }
-    const nextEventSequence = snapshot.accepted_inputs.reduce((next, input) => {
-        const match = input.event_id.match(/-event-(\d+)$/);
-        return match ? Math.max(next, Number(match[1]) + 1) : next;
-    }, 1);
-    kernelWireStates.set(runtime, { operationId, nextEventSequence });
 }
-const kernelWireStates = new WeakMap();
 function tryParseJson(s) {
     try {
         return JSON.parse(s);
@@ -126,10 +132,7 @@ export function capabilitySkill(skill) {
 export function capabilityMarker(kind, id, description) {
     return { id, kind, description };
 }
-function parseStep(raw) {
-    return JSON.parse(raw);
-}
-function kernelMessageToSdk(raw) {
+export function kernelMessageToSdk(raw) {
     const content = raw.content;
     const message = {
         role: raw.role,
@@ -152,9 +155,49 @@ function kernelMessageToSdk(raw) {
     if (typeof raw.token_count === "number") {
         message.tokenCount = raw.token_count;
     }
+    if (typeof content === "string") {
+        const parts = decodeCanonicalContentParts(content);
+        if (parts) {
+            const contentParts = [];
+            for (const part of parts) {
+                switch (part.type) {
+                    case "text":
+                        contentParts.push({ type: "text", text: String(part.text ?? "") });
+                        break;
+                    case "tool_result":
+                        contentParts.push({
+                            type: "tool_result",
+                            callId: String(part.call_id ?? ""),
+                            output: String(part.output ?? ""),
+                            isError: Boolean(part.is_error),
+                        });
+                        break;
+                    case "image":
+                        contentParts.push({
+                            type: "image",
+                            ...(part.url ? { url: String(part.url) } : {}),
+                            ...(part.data ? { data: String(part.data) } : {}),
+                            ...(part.media_type ? { mediaType: String(part.media_type) } : {}),
+                            ...(part.detail === "auto" || part.detail === "low" || part.detail === "high"
+                                ? { detail: part.detail }
+                                : {}),
+                        });
+                        break;
+                    case "audio":
+                        contentParts.push({
+                            type: "audio",
+                            data: String(part.data ?? ""),
+                            ...(part.media_type ? { mediaType: String(part.media_type) } : {}),
+                        });
+                        break;
+                }
+            }
+            message.contentParts = contentParts;
+        }
+    }
     return message;
 }
-function renderedContextToSdk(raw) {
+export function renderedContextToSdk(raw) {
     const rawStateTurn = (raw.state_turn ?? raw.stateTurn);
     const frozenLen = (raw.frozen_prefix_len ?? raw.frozenPrefixLen);
     const ctx = {
@@ -169,146 +212,3 @@ function renderedContextToSdk(raw) {
         ctx.frozenPrefixLen = frozenLen;
     return ctx;
 }
-function mapKernelAction(raw) {
-    const effectId = String(raw.effect_id ?? "");
-    if (!effectId)
-        throw new Error(`kernel action ${String(raw.kind)} is missing effect_id`);
-    switch (raw.kind) {
-        case "call_provider":
-            return {
-                kind: "call_provider",
-                effectId,
-                context: renderedContextToSdk(raw.context ?? {}),
-                tools: (raw.tools ?? []).map(t => ({
-                    name: String(t.name ?? ""),
-                    description: String(t.description ?? ""),
-                    parameters: JSON.stringify(t.parameters ?? {}),
-                })),
-            };
-        case "execute_tool":
-            return {
-                kind: "execute_tool",
-                effectId,
-                calls: (raw.calls ?? []).map(c => ({
-                    id: String(c.id ?? ""),
-                    name: String(c.name ?? ""),
-                    arguments: JSON.stringify(c.arguments ?? {}),
-                })),
-            };
-        case "request_approval":
-            return {
-                kind: "request_approval", effectId,
-                requests: (raw.requests ?? []).map(request => ({
-                    callId: String(request.call_id ?? ""), tool: String(request.tool ?? ""),
-                    arguments: JSON.stringify(request.arguments ?? {}), reason: String(request.reason ?? ""),
-                })),
-            };
-        case "spawn_workflow":
-            return {
-                kind: "spawn_workflow", effectId,
-                nodes: raw.nodes ?? [],
-                ...(raw.budget && typeof raw.budget === "object" ? { budget: raw.budget } : {}),
-            };
-        case "preempt_sub_agents":
-            return { kind: "preempt_sub_agents", effectId, agentIds: raw.agent_ids ?? [], reason: String(raw.reason ?? "") };
-        case "persist_memory":
-            return { kind: "persist_memory", effectId, memory: raw.memory ?? {} };
-        case "query_memory":
-            return { kind: "query_memory", effectId, query: raw.query ?? {}, requestedK: Number(raw.requested_k ?? 0) };
-        case "spool_large_result":
-            return {
-                kind: "spool_large_result", effectId, callId: String(raw.call_id ?? ""), tool: String(raw.tool ?? ""),
-                output: String(raw.output ?? ""), originalSize: Number(raw.original_size ?? 0), previewSize: Number(raw.preview_size ?? 0),
-            };
-        case "archive_page_out":
-            return {
-                kind: "archive_page_out", effectId, turn: Number(raw.turn ?? 0), action: String(raw.action ?? "auto_compact"),
-                ...(typeof raw.summary === "string" ? { summary: raw.summary } : {}),
-                archived: (raw.archived ?? []).map(kernelMessageToSdk),
-                tier: String(raw.tier ?? "durable"),
-            };
-        case "evaluate_milestone":
-            return {
-                kind: "evaluate_milestone",
-                effectId,
-                phaseId: String(raw.phase_id ?? ""),
-                criteria: raw.criteria ?? [],
-                requiredEvidence: raw.required_evidence ?? [],
-            };
-        case "done": {
-            const result = raw.result ?? {};
-            const pace = result.pace_decision;
-            return {
-                kind: "done",
-                effectId,
-                result: {
-                    termination: String(result.termination ?? "error"),
-                    turnsUsed: Number(result.turns_used ?? 0),
-                    totalTokensUsed: Number(result.total_tokens_used ?? 0),
-                    // ③ loop-agent: the kernel-adjudicated after-round decision (absent on non-loop runs).
-                    ...(pace
-                        ? {
-                            paceDecision: {
-                                action: (pace.action ?? "stop"),
-                                delayMs: pace.delay_ms,
-                                reason: pace.reason ?? "",
-                                coercedFrom: pace.coerced_from,
-                            },
-                        }
-                        : {}),
-                },
-            };
-        }
-        default:
-            throw new Error(`unknown KernelAction kind: ${String(raw.kind)}`);
-    }
-}
-function stepInput(runtime, event) {
-    let state = kernelWireStates.get(runtime);
-    if (!state) {
-        // Globally unique, never a process-local counter: durable session logs key the kernel
-        // genesis/transaction chains by (sessionId, operationId) and outlive this isolate, so a
-        // counter that restarts at 1 collides with a prior chain on the same session.
-        state = { operationId: `wasm-operation-${crypto.randomUUID()}`, nextEventSequence: 1 };
-        kernelWireStates.set(runtime, state);
-    }
-    const correlatedEvent = event.kind === "cancel_operation"
-        ? { ...event, operation_id: state.operationId }
-        : event;
-    return JSON.stringify({
-        version: KERNEL_ABI_VERSION,
-        operation_id: state.operationId,
-        event_id: `${state.operationId}-event-${state.nextEventSequence++}`,
-        observed_at_ms: Date.now(),
-        event: correlatedEvent,
-    });
-}
-export function kernelApply(runtime, pending, event) {
-    const step = parseStep(runtime.step(stepInput(runtime, event)));
-    const fault = step.faults?.[0];
-    if (fault)
-        throw new Error(`${fault.code ?? "kernel_fault"}: ${fault.message ?? "kernel transition failed"}`);
-    pending.push(...step.observations);
-    return step.observations;
-}
-export function kernelAction(runtime, pending, event) {
-    const step = parseStep(runtime.step(stepInput(runtime, event)));
-    const fault = step.faults?.[0];
-    if (fault)
-        throw new Error(`${fault.code ?? "kernel_fault"}: ${fault.message ?? "kernel transition failed"}`);
-    pending.push(...step.observations);
-    const raw = step.actions[0];
-    if (!raw)
-        throw new Error("kernel transition must return one action");
-    return mapKernelAction(raw);
-}
-/** Like kernelAction but tolerates zero-action steps (e.g. queued signals). */
-export function kernelMaybeAction(runtime, pending, event) {
-    const step = parseStep(runtime.step(stepInput(runtime, event)));
-    const fault = step.faults?.[0];
-    if (fault)
-        throw new Error(`${fault.code ?? "kernel_fault"}: ${fault.message ?? "kernel transition failed"}`);
-    pending.push(...step.observations);
-    const raw = step.actions[0];
-    return raw ? mapKernelAction(raw) : null;
-}

package/dist/runtime/os-snapshot.d.ts

@@ -9,7 +9,8 @@ export interface OsSnapshot {
     processByAgent: Array<{
         turn: number;
         agent_id: string;
-        parent_session_id: string;
+        parent_task_id?: string;
+        parent_session_id?: string;
         state: string;
     }>;
     budgetExceeded: Array<{
@@ -43,7 +44,6 @@ export interface OsSnapshot {
     }>;
     pageOutCount: number;
     pageInCount: number;
-    spoolCount: number;
     toolGatedCount: number;
 }
 export declare function rebuildOsSnapshotFromSessionEvents(events: SessionEvent[]): OsSnapshot;

package/dist/runtime/os-snapshot.js

@@ -2,7 +2,6 @@ const KERNEL_KINDS = new Set([
     "compressed",
     "page_out",
     "page_in",
-    "large_result_spooled",
     "capability_changed",
     "context_renewed",
     "suspended",
@@ -27,7 +26,6 @@ export function rebuildOsSnapshotFromSessionEvents(events) {
         signals: [],
         pageOutCount: 0,
         pageInCount: 0,
-        spoolCount: 0,
         toolGatedCount: 0,
     };
     const index = new Map();
@@ -53,7 +51,8 @@ export function rebuildOsSnapshotFromSessionEvents(events) {
                 const record = {
                     turn: event.turn,
                     agent_id: event.agent_id,
-                    parent_session_id: event.parent_session_id,
+                    ...(event.parent_task_id ? { parent_task_id: event.parent_task_id } : {}),
+                    ...(event.parent_session_id ? { parent_session_id: event.parent_session_id } : {}),
                     state: event.state ?? "running",
                 };
                 const idx = index.get(event.agent_id);
@@ -91,9 +90,6 @@ export function rebuildOsSnapshotFromSessionEvents(events) {
             case "page_in":
                 snap.pageInCount += 1;
                 break;
-            case "large_result_spooled":
-                snap.spoolCount += 1;
-                break;
             default:
                 break;
         }

package/dist/runtime/payload-store.d.ts

@@ -0,0 +1,30 @@
+export interface PayloadStorageDriver {
+    write(key: string, content: string): Promise<void> | void;
+    read(key: string): Promise<string | undefined> | string | undefined;
+    delete(key: string): Promise<void> | void;
+    list(): Promise<string[]> | string[];
+    mtime?(key: string): Promise<number> | number;
+}
+export declare class MemoryPayloadDriver implements PayloadStorageDriver {
+    private readonly values;
+    write(key: string, content: string): Promise<void>;
+    read(key: string): Promise<string | undefined>;
+    delete(key: string): Promise<void>;
+    list(): Promise<string[]>;
+    mtime(key: string): Promise<number>;
+}
+export interface PayloadStoreConfig {
+    driver?: PayloadStorageDriver;
+    maxAgeMs?: number;
+}
+/** Driver-backed storage for canonical opaque payload locators. */
+export declare class PayloadStore {
+    private readonly driver;
+    private readonly maxAgeMs?;
+    private readonly activeWrites;
+    constructor(config?: PayloadStoreConfig);
+    private key;
+    persistPayload(sessionId: string, payloadRef: string, content: string): Promise<void>;
+    loadPayload(sessionId: string, payloadRef: string): Promise<string | undefined>;
+    cleanup(maxAgeMs?: number): Promise<number>;
+}

package/dist/runtime/payload-store.js

@@ -0,0 +1,66 @@
+export class MemoryPayloadDriver {
+    values = new Map();
+    async write(key, content) {
+        this.values.set(key, { content, mtime: Date.now() });
+    }
+    async read(key) {
+        return this.values.get(key)?.content;
+    }
+    async delete(key) {
+        this.values.delete(key);
+    }
+    async list() {
+        return [...this.values.keys()];
+    }
+    async mtime(key) {
+        return this.values.get(key)?.mtime ?? 0;
+    }
+}
+async function sha256(value) {
+    const digest = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
+    return [...new Uint8Array(digest)]
+        .map(byte => byte.toString(16).padStart(2, "0"))
+        .join("");
+}
+/** Driver-backed storage for canonical opaque payload locators. */
+export class PayloadStore {
+    driver;
+    maxAgeMs;
+    activeWrites = new Map();
+    constructor(config = {}) {
+        this.driver = config.driver ?? new MemoryPayloadDriver();
+        this.maxAgeMs = config.maxAgeMs;
+    }
+    async key(sessionId, payloadRef) {
+        return `payload/${await sha256(`${sessionId}\u0000${payloadRef}`)}`;
+    }
+    async persistPayload(sessionId, payloadRef, content) {
+        const key = await this.key(sessionId, payloadRef);
+        let write = this.activeWrites.get(key);
+        if (!write) {
+            write = Promise.resolve(this.driver.write(key, content)).finally(() => {
+                this.activeWrites.delete(key);
+            });
+            this.activeWrites.set(key, write);
+        }
+        await write;
+    }
+    async loadPayload(sessionId, payloadRef) {
+        return await this.driver.read(await this.key(sessionId, payloadRef));
+    }
+    async cleanup(maxAgeMs = this.maxAgeMs ?? 7 * 24 * 60 * 60 * 1000) {
+        if (!this.driver.mtime)
+            return 0;
+        const now = Date.now();
+        let removed = 0;
+        for (const key of await this.driver.list()) {
+            if (!key.startsWith("payload/"))
+                continue;
+            if (now - await this.driver.mtime(key) > maxAgeMs) {
+                await this.driver.delete(key);
+                removed += 1;
+            }
+        }
+        return removed;
+    }
+}