@deepstrike/wasm 0.2.68 → 0.2.70

package/dist/runtime/verifiable-report.d.ts

@@ -0,0 +1,59 @@
+/** Framework-facing API plus the Rust verifiable-runtime report ABI. */
+export declare const VERIFIABLE_REPORT_SCHEMA: "verifiable-report/v2";
+export declare const VERIFIABLE_FORK_SCHEMA: "verifiable-fork/v2";
+export type VerifiableCommand = "inspect" | "verify" | "replay" | "fork";
+export type CheckVerdict = "pass" | "degraded" | "fail" | "unavailable";
+export type ReplayVerdict = "pass" | "fail" | "unavailable";
+export type VerifiableReport = {
+    readonly schema: typeof VERIFIABLE_REPORT_SCHEMA;
+    readonly command: VerifiableCommand;
+    readonly operation_id: string;
+    readonly [key: string]: unknown;
+};
+export interface VerifiableEvidence {
+    readonly journal: ReadonlyArray<Uint8Array>;
+    readonly sessionLogs?: ReadonlyArray<ReadonlyArray<Uint8Array>>;
+    readonly checkpoints?: ReadonlyArray<Uint8Array>;
+}
+export interface VerifyOptions {
+    readonly strict?: boolean;
+    readonly requireComplete?: boolean;
+}
+export interface ReplayOptions {
+    readonly strict?: boolean;
+    readonly atStep?: number;
+}
+export interface VerifiableForkManifest {
+    schema: typeof VERIFIABLE_FORK_SCHEMA;
+    operation_id: string;
+    at_step: string;
+    parent_record_digest: string;
+    parent_input_id: string;
+    source_records: number;
+}
+export type ForkPlan = VerifiableForkManifest;
+export interface VerifiableRuntimeAdapter {
+    inspect(operationId: string, evidence: VerifiableEvidence, strict: boolean): VerifiableReport;
+    verify(operationId: string, evidence: VerifiableEvidence, options: VerifyOptions): VerifiableReport;
+    replay(operationId: string, evidence: VerifiableEvidence, options: ReplayOptions): VerifiableReport;
+    prepareFork(operationId: string, evidence: VerifiableEvidence, atStep: number, strict: boolean): ForkPlan;
+}
+export type VerifiableOperationJson = (request: string) => string;
+/** Create the SDK adapter backed by the Rust core JSON bridge. */
+export declare function createVerifiableRuntimeAdapter(operationJson: VerifiableOperationJson): VerifiableRuntimeAdapter;
+/** Create the adapter from the lazily loaded WASM binding. */
+export declare function createNativeVerifiableRuntimeAdapter(): Promise<VerifiableRuntimeAdapter>;
+/** Storage-neutral framework handle. Store access remains in the host adapter. */
+export declare class VerifiableOperation {
+    readonly operationId: string;
+    readonly evidence: VerifiableEvidence;
+    private readonly adapter;
+    constructor(operationId: string, evidence: VerifiableEvidence, adapter: VerifiableRuntimeAdapter);
+    inspect(strict?: boolean): VerifiableReport;
+    verify(options?: VerifyOptions): VerifiableReport;
+    replay(options?: ReplayOptions): VerifiableReport;
+    prepareFork(atStep: number, strict?: boolean): ForkPlan;
+}
+export declare function assertVerifiableReportSchema(value: {
+    schema?: unknown;
+}): void;

package/dist/runtime/verifiable-report.js

@@ -0,0 +1,64 @@
+import { getKernel } from "./kernel.js";
+/** Framework-facing API plus the Rust verifiable-runtime report ABI. */
+export const VERIFIABLE_REPORT_SCHEMA = "verifiable-report/v2";
+export const VERIFIABLE_FORK_SCHEMA = "verifiable-fork/v2";
+/** Create the SDK adapter backed by the Rust core JSON bridge. */
+export function createVerifiableRuntimeAdapter(operationJson) {
+    const call = (operationId, evidence, command, options = {}) => {
+        const result = JSON.parse(operationJson(JSON.stringify({
+            operation_id: operationId,
+            command,
+            evidence: {
+                journal: evidence.journal.map((bytes) => Array.from(bytes)),
+                session_logs: (evidence.sessionLogs ?? []).map((stream) => stream.map((bytes) => Array.from(bytes))),
+                checkpoints: (evidence.checkpoints ?? []).map((bytes) => Array.from(bytes)),
+            },
+            strict: options.strict ?? false,
+            require_complete: "requireComplete" in options ? options.requireComplete ?? false : false,
+            at_step: "atStep" in options ? options.atStep : undefined,
+        })));
+        if (command === "fork")
+            return result;
+        assertVerifiableReportSchema(result);
+        return result;
+    };
+    return {
+        inspect: (operationId, evidence, strict) => call(operationId, evidence, "inspect", { strict }),
+        verify: (operationId, evidence, options) => call(operationId, evidence, "verify", options),
+        replay: (operationId, evidence, options) => call(operationId, evidence, "replay", options),
+        prepareFork: (operationId, evidence, atStep, strict) => call(operationId, evidence, "fork", { atStep, strict }),
+    };
+}
+/** Create the adapter from the lazily loaded WASM binding. */
+export async function createNativeVerifiableRuntimeAdapter() {
+    const kernel = await getKernel();
+    return createVerifiableRuntimeAdapter(kernel.verifiableOperationJson);
+}
+/** Storage-neutral framework handle. Store access remains in the host adapter. */
+export class VerifiableOperation {
+    operationId;
+    evidence;
+    adapter;
+    constructor(operationId, evidence, adapter) {
+        this.operationId = operationId;
+        this.evidence = evidence;
+        this.adapter = adapter;
+    }
+    inspect(strict = false) {
+        return this.adapter.inspect(this.operationId, this.evidence, strict);
+    }
+    verify(options = {}) {
+        return this.adapter.verify(this.operationId, this.evidence, options);
+    }
+    replay(options = {}) {
+        return this.adapter.replay(this.operationId, this.evidence, options);
+    }
+    prepareFork(atStep, strict = false) {
+        return this.adapter.prepareFork(this.operationId, this.evidence, atStep, strict);
+    }
+}
+export function assertVerifiableReportSchema(value) {
+    if (value.schema !== VERIFIABLE_REPORT_SCHEMA) {
+        throw new Error(`unsupported verifiable report schema: ${String(value.schema)}`);
+    }
+}

package/dist/tools/index.d.ts

@@ -1,4 +1,4 @@
-import type { ToolSchema, ToolResult } from "../types.js";
+import type { ToolSchema, ToolExecutionResult } 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
@@ -22,4 +22,4 @@ export declare function executeTools(calls: {
     id: string;
     name: string;
     arguments: string;
-}[], registry: Map<string, RegisteredTool>): Promise<ToolResult[]>;
+}[], registry: Map<string, RegisteredTool>): Promise<ToolExecutionResult[]>;

package/dist/types.d.ts

@@ -39,7 +39,7 @@ export type ToolOutputBlock = {
     mediaType?: string;
     providerOptions?: Record<string, unknown>;
 };
-export interface Message {
+export interface ProviderMessage {
     role: "system" | "user" | "assistant" | "tool";
     content: string;
     toolCalls?: ToolCall[];
@@ -53,7 +53,7 @@ export interface ToolCall {
     arguments: string;
 }
 export type ToolErrorKind = "recoverable" | "fatal" | "governance_denied" | "provider_failure" | "timeout" | "user_interrupt";
-export interface ToolResult {
+export interface ToolExecutionResult {
     callId: string;
     output: string;
     isError: boolean;
@@ -71,11 +71,11 @@ export interface RenderedContext {
     systemText: string;
     systemStable?: string;
     systemKnowledge?: string;
-    turns: Message[];
+    turns: ProviderMessage[];
     /** Volatile State turn (task_state + signals), rendered after the cacheable
      *  history. Absent on un-rebuilt bindings — then it's still inside turns[0]. */
-    stateTurn?: Message;
-    /** Message count of the frozen history prefix (compaction boundary). When set,
+    stateTurn?: ProviderMessage;
+    /** ProviderMessage count of the frozen history prefix (compaction boundary). When set,
      *  Anthropic pins a deep cache breakpoint here instead of the rolling pair. */
     frozenPrefixLen?: number;
     budgetOverflow?: ContextBudgetOverflow;
@@ -283,7 +283,16 @@ export interface ProviderTransportTelemetry {
     rungs: number;
     responseId?: string;
 }
+/** Frozen host request; scope distinguishes encoded body from a custom adapter input. */
+export interface PreparedProviderRequest {
+    readonly scope: "encoded_body" | "adapter_input";
+    readonly request: unknown;
+    readonly state: unknown;
+    stream(signal?: AbortSignal): AsyncIterable<StreamEvent>;
+    countTokens?(): Promise<PromptMeasurement>;
+}
 export interface LLMProvider {
+    prepareRequest?(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState): PreparedProviderRequest;
     createRunState?(): ProviderRunState;
     runtimePolicy?(): {
         maxTurns?: number;
@@ -299,12 +308,12 @@ export interface LLMProvider {
             baseURL?: string;
         };
     };
-    peekProviderReplay?(message: Pick<Message, "content" | "toolCalls">): ProviderReplay | undefined;
-    seedProviderReplay?(message: Pick<Message, "content" | "toolCalls">, replay: ProviderReplay): void;
+    peekProviderReplay?(message: Pick<ProviderMessage, "content" | "toolCalls">): ProviderReplay | undefined;
+    seedProviderReplay?(message: Pick<ProviderMessage, "content" | "toolCalls">, replay: ProviderReplay): void;
     /** P4-S1 mirror: transport facts of the most recent execution (host evidence only, B7). */
     peekTransportTelemetry?(): ProviderTransportTelemetry | undefined;
-    countTokens?(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<PromptMeasurement>;
-    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
+    countTokens?(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState): Promise<PromptMeasurement>;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<ProviderMessage>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState, 
     /** #2-B-ii: when provided, a preempt (`interrupt()`) aborts the in-flight request. SDK-client
      *  providers forward it via `{ signal }`; the runner also breaks the consume loop on abort, so
@@ -312,7 +321,7 @@ export interface LLMProvider {
     signal?: AbortSignal): AsyncIterable<StreamEvent>;
 }
 export interface MemorySummarizer {
-    summarize(archived: Message[], context: {
+    summarize(archived: ProviderMessage[], context: {
         action?: string;
     }): Promise<string>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/wasm",
-  "version": "0.2.68",
+  "version": "0.2.70",
   "description": "DeepStrike WASM SDK — browser, Cloudflare Workers, Deno Deploy",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",
@@ -17,7 +17,7 @@
     "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"
   },
   "dependencies": {
-    "@deepstrike/wasm-kernel": "0.2.68"
+    "@deepstrike/wasm-kernel": "0.2.70"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",