@deepstrike/wasm 0.1.15 → 0.2.1

package/dist/runtime/session-log.d.ts

@@ -1,4 +1,23 @@
-import type { ProviderReplay, ToolCall } from "../types.js";
+import type { ProviderReplay, ToolCall, ToolErrorKind } from "../types.js";
+export type RollbackReason = {
+    kind: "fatal_tool_error";
+    tool_name: string;
+    error: string;
+} | {
+    kind: "governance_denied";
+    tool_name: string;
+    reason: string;
+} | {
+    kind: "provider_failure";
+    error: string;
+} | {
+    kind: "timeout";
+} | {
+    kind: "user_interrupt";
+} | {
+    kind: "malformed_replay";
+    reason: string;
+};
 export type SessionEvent = {
     kind: "run_started";
     run_id: string;
@@ -24,12 +43,85 @@ export type SessionEvent = {
         call_id: string;
         output: string;
         is_error?: boolean;
+        is_fatal?: boolean;
+        error_kind?: ToolErrorKind;
         token_count?: number;
     }>;
+} | {
+    kind: "tool_argument_repaired";
+    turn: number;
+    tool: string;
+    original_arguments: string;
+    repaired_arguments: string;
+} | {
+    kind: "tool_denied";
+    turn: number;
+    call_id: string;
+    tool_name: string;
+    reason: string;
+} | {
+    kind: "permission_requested";
+    turn: number;
+    tool: string;
+    arguments: string;
+    reason?: string;
+} | {
+    kind: "permission_resolved";
+    turn: number;
+    approved: boolean;
+    responder: string;
 } | {
     kind: "compressed";
     turn: number;
     archived_seq_range: [number, number];
+    action?: "snip_compact" | "micro_compact" | "context_collapse" | "auto_compact";
+    summary?: string;
+    summary_tokens?: number;
+    archive_ref?: string;
+    preserved_refs?: string[];
+} | {
+    kind: "rollbacked";
+    turn: number;
+    checkpoint_history_len: number;
+    reason?: RollbackReason;
+} | {
+    kind: "capability_changed";
+    turn: number;
+    added: string[];
+    removed: string[];
+    change_kind?: string;
+    capability_id?: string;
+    version?: string;
+    mounted_by?: string;
+    mount_reason?: string;
+} | {
+    kind: "milestone_advanced";
+    turn: number;
+    phase_id: string;
+    capabilities_unlocked: string[];
+} | {
+    kind: "milestone_blocked";
+    turn: number;
+    phase_id: string;
+    reason: string;
+} | {
+    kind: "milestone_evidence";
+    turn: number;
+    phase_id: string;
+    evidence: string[];
+} | {
+    kind: "checkpoint_taken";
+    turn: number;
+    history_len: number;
+} | {
+    kind: "agent_spawned";
+    turn: number;
+    agent_id: string;
+    parent_session_id: string;
+    role: string;
+    isolation: string;
+    context_inheritance: string;
+    permitted_capability_ids: string[];
 } | {
     kind: "run_terminal";
     reason: string;

package/dist/runtime/session-repair.d.ts

@@ -0,0 +1,33 @@
+import type { ProviderReplay, ToolCall } from "../types.js";
+import type { SessionEvent } from "./session-log.js";
+export { REPLAY_CONTENT_MAX_BYTES as RECOVERY_CONTENT_MAX_BYTES } from "./replay-sanitize.js";
+export declare function synthesizeProviderReplay(content: string, toolCalls: ToolCall[]): ProviderReplay | undefined;
+export declare function effectiveProviderReplay(content: string, toolCalls: ToolCall[], stored?: ProviderReplay): ProviderReplay | undefined;
+export declare function normalizeLlmCompleted(event: Extract<SessionEvent, {
+    kind: "llm_completed";
+}>, maxBytes?: number): Extract<SessionEvent, {
+    kind: "llm_completed";
+}>;
+export declare function repairEventsForRecovery(events: Array<{
+    seq: number;
+    event: SessionEvent;
+}>, maxBytes?: number): Array<{
+    seq: number;
+    event: SessionEvent;
+}>;
+export declare function buildLlmCompletedEvent(input: {
+    turn: number;
+    content: string;
+    tokenCount?: number;
+    toolCalls: ToolCall[];
+    providerReplay?: ProviderReplay;
+}): Extract<SessionEvent, {
+    kind: "llm_completed";
+}>;
+export declare function buildRunTerminalEvent(input: {
+    reason: string;
+    turnsUsed: number;
+    totalTokens: number;
+}): Extract<SessionEvent, {
+    kind: "run_terminal";
+}>;

package/dist/runtime/session-repair.js

@@ -0,0 +1,73 @@
+import { sanitizeReplayText } from "./replay-sanitize.js";
+export { REPLAY_CONTENT_MAX_BYTES as RECOVERY_CONTENT_MAX_BYTES } from "./replay-sanitize.js";
+function estimateTokenCount(text) {
+    return Math.max(1, Math.ceil(text.length / 4));
+}
+function parseToolInput(args) {
+    try {
+        return JSON.parse(args || "{}");
+    }
+    catch {
+        return {};
+    }
+}
+export function synthesizeProviderReplay(content, toolCalls) {
+    if (!toolCalls.length)
+        return undefined;
+    const blocks = [];
+    if (content)
+        blocks.push({ type: "text", text: content });
+    for (const tc of toolCalls) {
+        blocks.push({
+            type: "tool_use",
+            id: tc.id,
+            name: tc.name,
+            input: parseToolInput(tc.arguments),
+        });
+    }
+    return { native_blocks: blocks };
+}
+export function effectiveProviderReplay(content, toolCalls, stored) {
+    if (stored?.native_blocks?.length || stored?.reasoning_content != null) {
+        return stored;
+    }
+    return synthesizeProviderReplay(content, toolCalls);
+}
+export function normalizeLlmCompleted(event, maxBytes) {
+    const content = sanitizeReplayText(event.content ?? "", maxBytes);
+    const toolCalls = event.tool_calls ?? [];
+    const providerReplay = effectiveProviderReplay(content, toolCalls, event.provider_replay);
+    return {
+        kind: "llm_completed",
+        turn: event.turn,
+        content,
+        tool_calls: toolCalls,
+        token_count: event.token_count ?? estimateTokenCount(content),
+        ...(providerReplay ? { provider_replay: providerReplay } : {}),
+    };
+}
+export function repairEventsForRecovery(events, maxBytes) {
+    return events.map(entry => {
+        if (entry.event.kind !== "llm_completed")
+            return entry;
+        return { ...entry, event: normalizeLlmCompleted(entry.event, maxBytes) };
+    });
+}
+export function buildLlmCompletedEvent(input) {
+    return normalizeLlmCompleted({
+        kind: "llm_completed",
+        turn: input.turn,
+        content: sanitizeReplayText(input.content),
+        tool_calls: input.toolCalls ?? [],
+        token_count: input.tokenCount,
+        provider_replay: input.providerReplay,
+    });
+}
+export function buildRunTerminalEvent(input) {
+    return {
+        kind: "run_terminal",
+        reason: input.reason,
+        turns_used: Math.max(0, input.turnsUsed),
+        total_tokens: Math.max(0, input.totalTokens),
+    };
+}

package/dist/runtime/sub-agent-orchestrator.d.ts

@@ -0,0 +1,17 @@
+import type { AgentRunSpec, AgentSpawnedObservation, SubAgentResult } from "./types/agent.js";
+import type { RuntimeOptions } from "./runner.js";
+import type { SessionLog } from "./session-log.js";
+export interface SubAgentRunContext {
+    parentOpts: RuntimeOptions;
+    parentSessionId: string;
+    spec: AgentRunSpec;
+    manifest: AgentSpawnedObservation;
+    sessionLog: SessionLog;
+}
+/** Host-side driver for kernel-isolated sub-agent runs. */
+export declare class SubAgentOrchestrator {
+    run(ctx: SubAgentRunContext): Promise<SubAgentResult>;
+}
+export declare const defaultSubAgentOrchestrator: SubAgentOrchestrator;
+/** Kernel spawn without an active parent run loop (harness / coordinator use). */
+export declare function spawnStandalone(parentOpts: RuntimeOptions, parentSessionId: string, spec: AgentRunSpec, orchestrator?: SubAgentOrchestrator): Promise<SubAgentResult>;

package/dist/runtime/sub-agent-orchestrator.js

@@ -0,0 +1,112 @@
+import { agentRunSpecToKernel } from "./types/agent.js";
+import { FilteredExecutionPlane } from "./filtered-plane.js";
+import { kernelApply } from "./kernel-step.js";
+function terminationFromStatus(status) {
+    const normalized = status.toLowerCase();
+    if (normalized === "completed" ||
+        normalized === "max_turns" ||
+        normalized === "token_budget" ||
+        normalized === "timeout" ||
+        normalized === "user_abort" ||
+        normalized === "error" ||
+        normalized === "milestone_exceeded") {
+        return normalized;
+    }
+    return status;
+}
+/** Host-side driver for kernel-isolated sub-agent runs. */
+export class SubAgentOrchestrator {
+    async run(ctx) {
+        const permitted = new Set(ctx.manifest.permitted_capability_ids ?? []);
+        const filteredPlane = new FilteredExecutionPlane(ctx.parentOpts.executionPlane, permitted);
+        let systemPrompt = ctx.parentOpts.systemPrompt;
+        let inheritEvents;
+        if (ctx.manifest.context_inheritance === "full") {
+            inheritEvents = await ctx.sessionLog.read(ctx.parentSessionId);
+        }
+        else if (ctx.manifest.context_inheritance === "system_only") {
+            const parentEvents = await ctx.sessionLog.read(ctx.parentSessionId);
+            const started = parentEvents.find(e => e.event.kind === "run_started");
+            if (started?.event.kind === "run_started" && started.event.system_prompt) {
+                systemPrompt = started.event.system_prompt;
+            }
+        }
+        const { RuntimeRunner } = await import("./runner.js");
+        const childRunner = new RuntimeRunner({
+            ...ctx.parentOpts,
+            executionPlane: filteredPlane,
+            agentId: ctx.spec.identity.agentId,
+            systemPrompt,
+            sessionLog: ctx.sessionLog,
+        });
+        let done;
+        let finalText = "";
+        for await (const evt of childRunner.run({
+            sessionId: ctx.spec.identity.sessionId,
+            goal: ctx.spec.goal,
+        })) {
+            if (evt.type === "text_delta")
+                finalText += evt.delta;
+            if (evt.type === "done")
+                done = evt;
+        }
+        const loopResult = {
+            termination: terminationFromStatus(done?.status ?? "error"),
+            turnsUsed: done?.iterations ?? 0,
+            totalTokensUsed: done?.totalTokens ?? 0,
+            ...(finalText
+                ? { finalMessage: { role: "assistant", content: finalText, toolCalls: [] } }
+                : {}),
+        };
+        return { agentId: ctx.spec.identity.agentId, result: loopResult };
+    }
+}
+export const defaultSubAgentOrchestrator = new SubAgentOrchestrator();
+/** Kernel spawn without an active parent run loop (harness / coordinator use). */
+export async function spawnStandalone(parentOpts, parentSessionId, spec, orchestrator = defaultSubAgentOrchestrator) {
+    const kernel = await (await import("./kernel.js")).getKernel();
+    const runtime = new kernel.KernelRuntime({
+        maxTokens: parentOpts.maxTokens,
+        maxTurns: parentOpts.maxTurns ?? 25,
+        timeoutMs: parentOpts.timeoutMs !== undefined ? BigInt(parentOpts.timeoutMs) : undefined,
+    });
+    const pending = [];
+    kernelApply(runtime, pending, { kind: "start_run", task: { goal: "coordinator", criteria: [] } });
+    const observations = kernelApply(runtime, pending, {
+        kind: "spawn_sub_agent",
+        spec: agentRunSpecToKernel(spec),
+        parent_session_id: parentSessionId,
+    });
+    const spawned = observations.find(o => o.kind === "agent_spawned");
+    if (!spawned || typeof spawned.agent_id !== "string") {
+        throw new Error("spawn_sub_agent did not emit agent_spawned");
+    }
+    const turn = spawned.turn ?? 0;
+    await parentOpts.sessionLog.append(parentSessionId, {
+        kind: "agent_spawned",
+        turn,
+        agent_id: spawned.agent_id,
+        parent_session_id: spawned.parent_session_id ?? parentSessionId,
+        role: spawned.role ?? spec.role,
+        isolation: spawned.isolation ?? spec.isolation ?? "shared",
+        context_inheritance: spawned.context_inheritance ?? "none",
+        permitted_capability_ids: spawned.permitted_capability_ids ?? [],
+    });
+    const manifest = {
+        kind: "agent_spawned",
+        turn,
+        agent_id: spawned.agent_id,
+        parent_session_id: spawned.parent_session_id ?? parentSessionId,
+        role: spawned.role ?? spec.role,
+        isolation: spawned.isolation ?? spec.isolation ?? "shared",
+        context_inheritance: spawned.context_inheritance ?? "none",
+        permitted_capability_ids: spawned.permitted_capability_ids ?? [],
+    };
+    return orchestrator.run({
+        parentOpts,
+        parentSessionId,
+        spec,
+        manifest,
+        sessionLog: parentOpts.sessionLog,
+    });
+}

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

@@ -0,0 +1,68 @@
+import type { Message } from "../../types.js";
+export type KernelAgentRole = "explore" | "plan" | "implement" | "verify" | "custom";
+export type AgentIsolation = "shared" | "read_only" | "worktree" | "remote";
+export type ContextInheritance = "none" | "system_only" | "full";
+export type TerminationReason = "completed" | "max_turns" | "token_budget" | "timeout" | "user_abort" | "error" | "milestone_exceeded";
+export type MilestonePolicy = "require_verifier" | "terminate" | "auto_pass";
+export interface AgentIdentity {
+    agentId: string;
+    sessionId: string;
+    isSubAgent: boolean;
+    parentSessionId?: string;
+}
+export interface AgentCapabilityFilter {
+    allowedKinds?: string[];
+    allowedIds?: string[];
+}
+export interface AgentRunSpec {
+    identity: AgentIdentity;
+    role: KernelAgentRole;
+    isolation?: AgentIsolation;
+    goal: string;
+    verificationContractId?: string;
+    capabilityFilter?: AgentCapabilityFilter;
+    milestones?: MilestoneContract;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentSpawnedObservation {
+    kind: "agent_spawned";
+    turn?: number;
+    agent_id: string;
+    parent_session_id: string;
+    role: string;
+    isolation: string;
+    context_inheritance: string;
+    permitted_capability_ids: string[];
+}
+export interface LoopResult {
+    termination: TerminationReason | string;
+    finalMessage?: Message;
+    turnsUsed: number;
+    totalTokensUsed: number;
+}
+export interface SubAgentResult {
+    agentId: string;
+    result: LoopResult;
+}
+export interface MilestoneCheckResult {
+    phaseId: string;
+    passed: boolean;
+    reason?: string;
+}
+export interface MilestonePhase {
+    id: string;
+    criteria?: string[];
+    unlocks?: Array<Record<string, unknown>>;
+    verifier?: Record<string, unknown>;
+    requiredEvidence?: string[];
+}
+export interface MilestoneContract {
+    phases: MilestonePhase[];
+}
+export declare function agentIdentitySub(agentId: string, sessionId: string, parentSessionId?: string): AgentIdentity;
+export declare function agentRunSpecToKernel(spec: AgentRunSpec): Record<string, unknown>;
+export declare function milestoneContractToKernel(contract: MilestoneContract): Record<string, unknown>;
+export declare function milestoneCheckResultToKernel(result: MilestoneCheckResult): Record<string, unknown>;
+export declare function subAgentResultToKernel(result: SubAgentResult): Record<string, unknown>;
+export declare function milestoneCheckPass(phaseId: string): MilestoneCheckResult;
+export declare function milestoneCheckFail(phaseId: string, reason: string): MilestoneCheckResult;

package/dist/runtime/types/agent.js

@@ -0,0 +1,78 @@
+export function agentIdentitySub(agentId, sessionId, parentSessionId) {
+    return {
+        agentId,
+        sessionId,
+        isSubAgent: true,
+        ...(parentSessionId ? { parentSessionId } : {}),
+    };
+}
+export function agentRunSpecToKernel(spec) {
+    const out = {
+        identity: {
+            agent_id: spec.identity.agentId,
+            session_id: spec.identity.sessionId,
+            is_sub_agent: spec.identity.isSubAgent,
+            ...(spec.identity.parentSessionId ? { parent_session_id: spec.identity.parentSessionId } : {}),
+        },
+        role: spec.role,
+        isolation: spec.isolation ?? "shared",
+        goal: spec.goal,
+        capability_filter: {
+            allowed_kinds: spec.capabilityFilter?.allowedKinds ?? [],
+            allowed_ids: spec.capabilityFilter?.allowedIds ?? [],
+        },
+        metadata: spec.metadata ?? null,
+    };
+    if (spec.verificationContractId)
+        out.verification_contract_id = spec.verificationContractId;
+    if (spec.milestones)
+        out.milestones = milestoneContractToKernel(spec.milestones);
+    return out;
+}
+export function milestoneContractToKernel(contract) {
+    return {
+        phases: contract.phases.map(phase => ({
+            id: phase.id,
+            criteria: phase.criteria ?? [],
+            unlocks: phase.unlocks ?? [],
+            ...(phase.verifier ? { verifier: phase.verifier } : {}),
+            required_evidence: phase.requiredEvidence ?? [],
+        })),
+    };
+}
+export function milestoneCheckResultToKernel(result) {
+    return {
+        phase_id: result.phaseId,
+        passed: result.passed,
+        ...(result.reason ? { reason: result.reason } : {}),
+    };
+}
+export function subAgentResultToKernel(result) {
+    const finalMessage = result.result.finalMessage;
+    return {
+        agent_id: result.agentId,
+        result: {
+            termination: result.result.termination,
+            final_message: finalMessage
+                ? {
+                    role: finalMessage.role,
+                    content: finalMessage.content,
+                    tool_calls: (finalMessage.toolCalls ?? []).map(tc => ({
+                        id: tc.id,
+                        name: tc.name,
+                        arguments: JSON.parse(tc.arguments || "{}"),
+                    })),
+                    ...(finalMessage.tokenCount !== undefined ? { token_count: finalMessage.tokenCount } : {}),
+                }
+                : null,
+            turns_used: result.result.turnsUsed,
+            total_tokens_used: result.result.totalTokensUsed,
+        },
+    };
+}
+export function milestoneCheckPass(phaseId) {
+    return { phaseId, passed: true };
+}
+export function milestoneCheckFail(phaseId, reason) {
+    return { phaseId, passed: false, reason };
+}

package/dist/types.d.ts

@@ -9,10 +9,13 @@ export interface ToolCall {
     name: string;
     arguments: string;
 }
+export type ToolErrorKind = "recoverable" | "fatal" | "governance_denied" | "provider_failure" | "timeout" | "user_interrupt";
 export interface ToolResult {
     callId: string;
     output: string;
     isError: boolean;
+    isFatal?: boolean;
+    errorKind?: ToolErrorKind;
     tokenCount?: number;
 }
 export interface ToolSchema {
@@ -52,6 +55,8 @@ export interface ToolResultEvent extends StreamEvent {
     name: string;
     content: string;
     isError: boolean;
+    isFatal?: boolean;
+    errorKind?: ToolErrorKind;
 }
 export interface DoneEvent extends StreamEvent {
     type: "done";
@@ -70,6 +75,19 @@ export interface PermissionRequestEvent extends StreamEvent {
     arguments: string;
     reason: string;
 }
+export interface ToolDeniedEvent extends StreamEvent {
+    type: "tool_denied";
+    callId: string;
+    toolName: string;
+    reason: string;
+}
+export interface ToolArgumentRepairedEvent extends StreamEvent {
+    type: "tool_argument_repaired";
+    callId: string;
+    name: string;
+    originalArguments: string;
+    repairedArguments: string;
+}
 /**
  * Opaque per-run state owned by the provider (e.g. OpenAI Responses continuation).
  * The framework creates and threads this object; providers may read/write it.

package/package.json

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