@deepstrike/wasm 0.2.66 → 0.2.69

package/dist/index.d.ts

@@ -5,6 +5,8 @@ export { CANONICAL_CONTENT_PARTS_PREFIX, encodeCanonicalContentParts, decodeCano
 export type { ReplayProviderOpts, Criterion, Verdict, VerdictDetail, JudgeArgs, } from "./runtime/index.js";
 export type { NativeOsProfile, OsProfileId, MemoryPolicy, MemoryWriteRateLimit, ResourceQuota, RuntimeOptions, PromptBudget, SchedulerPolicy, SignalPolicy, SessionEvent, SessionEventKind, SessionLog, RunContext, ExecutionPlane, KernelEventCategory, KernelPrimitive, } from "./runtime/index.js";
 export { primitiveForCategory, primitiveForKind } from "./runtime/index.js";
+export { VERIFIABLE_REPORT_SCHEMA, VERIFIABLE_FORK_SCHEMA, assertVerifiableReportSchema, createVerifiableRuntimeAdapter, createNativeVerifiableRuntimeAdapter, VerifiableOperation, } from "./runtime/verifiable-report.js";
+export type { VerifiableCommand, CheckVerdict, VerifiableForkManifest, ForkPlan, VerifiableEvidence, VerifyOptions, ReplayOptions, VerifiableRuntimeAdapter, VerifiableReport, VerifiableOperationJson, } from "./runtime/verifiable-report.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
 export type { SubAgentRunContext } from "./runtime/sub-agent-orchestrator.js";

package/dist/index.js

@@ -4,6 +4,7 @@ export { DriverKernelJournal, InMemoryJournalDriver, InMemoryKernelJournal, Jour
 // ── content-parts-v1 registered encoding (F14/B5; byte-pinned by sdk-conformance) ──
 export { CANONICAL_CONTENT_PARTS_PREFIX, encodeCanonicalContentParts, decodeCanonicalContentParts, } from "./runtime/kernel-step.js";
 export { primitiveForCategory, primitiveForKind } from "./runtime/index.js";
+export { VERIFIABLE_REPORT_SCHEMA, VERIFIABLE_FORK_SCHEMA, assertVerifiableReportSchema, createVerifiableRuntimeAdapter, createNativeVerifiableRuntimeAdapter, VerifiableOperation, } from "./runtime/verifiable-report.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
 export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, genEval, verifyRules } from "./runtime/types/agent.js";

package/dist/memory/index.d.ts

@@ -9,7 +9,6 @@ export declare class WorkingMemory {
 export interface SessionMessage {
     role: "system" | "user" | "assistant" | "tool";
     content: string;
-    tokenCount?: number;
     toolCalls?: Array<{
         id: string;
         name: string;

package/dist/providers/base.js

@@ -31,16 +31,16 @@ function openaiAudioFormat(mediaType) {
 function openAIPartsContent(parts) {
     return parts.map(p => {
         if (p.type === "image") {
-            const url = p.data ? `data:${p.mediaType ?? "image/png"};base64,${p.data}` : (p.url ?? "");
+            const url = p.source?.kind === "base64" ? `data:${p.mediaType ?? "image/png"};base64,${p.source.data}` : p.source?.kind === "url" ? p.source.url : "";
             return { type: "image_url", image_url: { url, ...(p.detail ? { detail: p.detail } : {}) } };
         }
         if (p.type === "audio") {
             // OpenAI audio has no URL form — a part without base64 data cannot be sent.
-            if (!p.data)
-                throw new UnsupportedModalityError("audio (no data)", "openai");
+            if (p.source?.kind !== "base64")
+                throw new UnsupportedModalityError("audio (no durable base64 source)", "openai");
             return {
                 type: "input_audio",
-                input_audio: { data: p.data, format: openaiAudioFormat(p.mediaType) },
+                input_audio: { data: p.source.data, format: openaiAudioFormat(p.mediaType) },
             };
         }
         return { type: "text", text: p.text ?? p.output ?? "" };
@@ -50,9 +50,9 @@ function openAIPartsContent(parts) {
 function anthropicPartsContent(parts) {
     return parts.map(p => {
         if (p.type === "image") {
-            const source = p.data
-                ? { type: "base64", media_type: p.mediaType ?? "image/png", data: p.data }
-                : { type: "url", url: p.url ?? "" };
+            const source = p.source?.kind === "base64"
+                ? { type: "base64", media_type: p.mediaType ?? "image/png", data: p.source.data }
+                : { type: "url", url: p.source?.kind === "url" ? p.source.url : "" };
             return { type: "image", source };
         }
         if (p.type === "audio") {
@@ -139,7 +139,6 @@ export function toAnthropicMessages(context, nativeReplay) {
 export async function collectStreamMessage(stream) {
     let content = "";
     const toolCalls = [];
-    let outputTokens;
     for await (const evt of stream) {
         if (evt.type === "text_delta" && evt.delta)
             content += evt.delta;
@@ -147,9 +146,8 @@ export async function collectStreamMessage(stream) {
             toolCalls.push({ id: evt.id, name: evt.name, arguments: JSON.stringify(evt.arguments ?? {}) });
         }
         else if (evt.type === "usage") {
-            outputTokens = evt.outputTokens ?? evt.totalTokens;
         }
     }
-    return { role: "assistant", content, ...(outputTokens ? { tokenCount: outputTokens } : {}), ...(toolCalls.length ? { toolCalls } : {}) };
+    return { role: "assistant", content, ...(toolCalls.length ? { toolCalls } : {}) };
 }
 export { assistantReplayKey };

package/dist/runtime/kernel-step.js

@@ -85,9 +85,6 @@ export function messageToKernelMessage(message) {
             arguments: tryParseJson(tc.arguments) ?? {},
         })),
     };
-    if (message.tokenCount !== undefined) {
-        out.token_count = message.tokenCount;
-    }
     // Multimodal: serialize typed content parts to the kernel `Content::Parts` shape when present
     // (image/audio must survive the reconstruction→preload path, not just live ingress).
     if (message.contentParts && message.contentParts.length > 0) {
@@ -98,10 +95,10 @@ export function messageToKernelMessage(message) {
                 return { type: "tool_result", call_id: part.callId, output: part.output, is_error: part.isError };
             }
             if (part.type === "image") {
-                return { type: "image", url: part.url, data: part.data, media_type: part.mediaType, detail: part.detail };
+                return { type: "image", source: part.source, media_type: part.mediaType, detail: part.detail };
             }
             if (part.type === "audio") {
-                return { type: "audio", data: part.data, media_type: part.mediaType };
+                return { type: "audio", source: part.source, media_type: part.mediaType };
             }
             return { type: "text", text: message.content };
         });
@@ -112,12 +109,12 @@ export function messageToKernelMessage(message) {
     return out;
 }
 export function toolResultToKernel(result) {
+    // Usage evidence enters through the host event contract; content alone cannot establish usage.
     const out = {
         call_id: result.callId,
         output: result.output,
         is_error: result.isError,
         is_fatal: result.isFatal ?? false,
-        token_count: result.tokenCount ?? null,
     };
     if (result.errorKind !== undefined) {
         out.error_kind = result.errorKind;
@@ -173,9 +170,6 @@ export function kernelMessageToSdk(raw) {
             arguments: JSON.stringify(tc.arguments ?? {}),
         })),
     };
-    if (typeof raw.token_count === "number") {
-        message.tokenCount = raw.token_count;
-    }
     if (typeof content === "string") {
         const parts = decodeCanonicalContentParts(content);
         if (parts) {
@@ -196,8 +190,7 @@ export function kernelMessageToSdk(raw) {
                     case "image":
                         contentParts.push({
                             type: "image",
-                            ...(part.url ? { url: String(part.url) } : {}),
-                            ...(part.data ? { data: String(part.data) } : {}),
+                            ...(part.source ? { source: part.source } : {}),
                             ...(part.media_type ? { mediaType: String(part.media_type) } : {}),
                             ...(part.detail === "auto" || part.detail === "low" || part.detail === "high"
                                 ? { detail: part.detail }
@@ -207,7 +200,7 @@ export function kernelMessageToSdk(raw) {
                     case "audio":
                         contentParts.push({
                             type: "audio",
-                            data: String(part.data ?? ""),
+                            source: part.source,
                             ...(part.media_type ? { mediaType: String(part.media_type) } : {}),
                         });
                         break;

package/dist/runtime/replay-fixture.d.ts

@@ -14,9 +14,8 @@ import type { SessionEvent } from "./session-log.js";
  * Walks `llm_completed` events (which is what the runner appends for every LLM call) and produces
  * one Message per event. Pass the result directly to `new ReplayProvider(messages)`.
  *
- * Accepts both wire shapes the SDK uses interchangeably:
- *   - in-memory: `{ toolCalls, tokenCount, providerReplay }` (camelCase)
- *   - serialised session-log: `{ tool_calls, token_count, provider_replay }` (snake_case)
+ * Accepts both camelCase and snake_case tool-call wire shapes. Token usage remains session
+ * evidence; the returned public Message mirror carries no token projection.
  *
  * @param events Session events, in original order. Accepts both `{ event, seq }` (the shape
  *               `SessionLog.read()` returns) and a bare `SessionEvent[]`.

package/dist/runtime/replay-fixture.js

@@ -12,9 +12,8 @@
  * Walks `llm_completed` events (which is what the runner appends for every LLM call) and produces
  * one Message per event. Pass the result directly to `new ReplayProvider(messages)`.
  *
- * Accepts both wire shapes the SDK uses interchangeably:
- *   - in-memory: `{ toolCalls, tokenCount, providerReplay }` (camelCase)
- *   - serialised session-log: `{ tool_calls, token_count, provider_replay }` (snake_case)
+ * Accepts both camelCase and snake_case tool-call wire shapes. Token usage remains session
+ * evidence; the returned public Message mirror carries no token projection.
  *
  * @param events Session events, in original order. Accepts both `{ event, seq }` (the shape
  *               `SessionLog.read()` returns) and a bare `SessionEvent[]`.
@@ -27,14 +26,12 @@ export function extractRecordedMessages(events) {
             continue;
         const e = event;
         const tcRaw = (e.toolCalls ?? e.tool_calls);
-        const tokenCount = (e.tokenCount ?? e.token_count);
         out.push({
             role: "assistant",
             content: typeof e.content === "string" ? e.content : "",
             ...(Array.isArray(tcRaw) && tcRaw.length > 0
                 ? { toolCalls: normalizeToolCalls(tcRaw) }
                 : {}),
-            ...(tokenCount !== undefined ? { tokenCount } : {}),
         });
     }
     return out;

package/dist/runtime/replay-provider.d.ts

@@ -16,8 +16,7 @@
  *   - `inputTokens` is ESTIMATED from the rendered context this call carries (NOT a recorded value
  *     from the original run). That's the point of replay-for-benchmarking: prompt may differ across
  *     variants, response is pinned, so a cost Δ purely reflects the prompt change.
- *   - `outputTokens` is taken from `message.tokenCount` when present; otherwise estimated from
- *     `message.content.length / 4`.
+ *   - `outputTokens` is estimated from `message.content.length / 4`.
  *   - `cacheReadInputTokens` / `cacheCreationInputTokens` are emitted as 0 — replay has no real
  *     cache state. Mechanisms whose Δ depends on cache behavior must validate with a live A/B too.
  *

package/dist/runtime/replay-provider.js

@@ -16,8 +16,7 @@
  *   - `inputTokens` is ESTIMATED from the rendered context this call carries (NOT a recorded value
  *     from the original run). That's the point of replay-for-benchmarking: prompt may differ across
  *     variants, response is pinned, so a cost Δ purely reflects the prompt change.
- *   - `outputTokens` is taken from `message.tokenCount` when present; otherwise estimated from
- *     `message.content.length / 4`.
+ *   - `outputTokens` is estimated from `message.content.length / 4`.
  *   - `cacheReadInputTokens` / `cacheCreationInputTokens` are emitted as 0 — replay has no real
  *     cache state. Mechanisms whose Δ depends on cache behavior must validate with a live A/B too.
  *
@@ -68,13 +67,12 @@ export class ReplayProvider {
             role: "assistant",
             content: msg.content,
             ...(msg.toolCalls ? { toolCalls: msg.toolCalls } : {}),
-            ...(msg.tokenCount !== undefined ? { tokenCount: msg.tokenCount } : {}),
         };
     }
     async *stream(context, tools, _extensions, _state, _signal) {
         const msg = this.pull();
         const inputTokens = this.estimateInputTokens(context, tools);
-        const outputTokens = msg.tokenCount !== undefined ? msg.tokenCount : this.tokenizer(msg.content || "");
+        const outputTokens = this.tokenizer(msg.content || "");
         const usage = {
             type: "usage",
             totalTokens: inputTokens + outputTokens,

package/dist/runtime/runner.js

@@ -869,7 +869,6 @@ export class RuntimeRunner {
                         role: "assistant",
                         content: finalText,
                         toolCalls: finalToolCalls,
-                        tokenCount: turnOutputTokens || turnTokens || undefined,
                     };
                     // P4 §2: assemble the measurement from the exact numbers that cross the boundary today
                     // (input/output turn counters + the cache split). An invalid frame degrades to no
@@ -919,7 +918,6 @@ export class RuntimeRunner {
                     await this.opts.sessionLog.append(sessionId, buildLlmCompletedEvent({
                         turn: runtime.turn(),
                         content: finalText,
-                        tokenCount: turnOutputTokens || turnTokens || undefined,
                         toolCalls: finalToolCalls,
                         providerReplay,
                         effectId: providerEffectId,
@@ -1213,7 +1211,6 @@ export class RuntimeRunner {
                             call_id: r.callId,
                             output: r.output,
                             is_error: r.isError,
-                            token_count: r.tokenCount,
                             content: { blocks: toolOutputBlocksToDurable(r.contentParts?.length ? r.contentParts : [{ type: "text", text: r.output }]) },
                         })),
                     });
@@ -1390,7 +1387,6 @@ export class RuntimeRunner {
             const newMsgs = runtime.drainNewMessages().map(m => ({
                 role: m.role,
                 content: m.content,
-                tokenCount: m.tokenCount,
                 toolCalls: m.toolCalls?.length ? m.toolCalls : undefined,
             }));
             if (newMsgs.length > 0) {
@@ -2027,7 +2023,6 @@ export async function replayMessages(events, maxBytes, archiveStore) {
                 content: userText,
                 ...(contentParts ? { contentParts } : {}),
                 toolCalls: [],
-                tokenCount: Math.max(1, Math.ceil(userText.length / 4)),
             });
         }
         else if (e.kind === "compressed") {
@@ -2040,7 +2035,6 @@ export async function replayMessages(events, maxBytes, archiveStore) {
                     role: "system",
                     content: systemText,
                     toolCalls: [],
-                    tokenCount: Math.max(1, Math.ceil(systemText.length / 4)),
                 });
             }
         }
@@ -2057,7 +2051,6 @@ export async function replayMessages(events, maxBytes, archiveStore) {
                     const systemText = `[Compressed context: turn ${e.turn}]\n${e.summary}`;
                     messages.push({
                         role: "system", content: systemText, toolCalls: [],
-                        tokenCount: Math.max(1, Math.ceil(systemText.length / 4)),
                     });
                 }
             }
@@ -2067,7 +2060,6 @@ export async function replayMessages(events, maxBytes, archiveStore) {
                 role: "assistant",
                 content: sanitizeReplayText(e.content, maxBytes),
                 toolCalls: e.tool_calls ?? [],
-                tokenCount: e.token_count,
             });
         }
         else if (e.kind === "tool_completed") {
@@ -2082,7 +2074,6 @@ export async function replayMessages(events, maxBytes, archiveStore) {
                     content: "",
                     toolCalls: [],
                     contentParts: [{ type: "tool_result", callId: durable.call_id, output: sanitizeReplayText(r.output, maxBytes), isError: durable.is_error, ...(durable.blocks.length ? { contentParts: durableBlocksToToolOutput(durable.blocks) } : {}) }],
-                    tokenCount: r.token_count,
                 });
             }
         }
@@ -2183,14 +2174,13 @@ function attachmentsToKernelMessage(parts) {
         if (p.type === "image") {
             return {
                 type: "image",
-                ...(p.url ? { url: p.url } : {}),
-                ...(p.data ? { data: p.data } : {}),
+                ...(p.source ? { source: p.source } : {}),
                 ...(p.mediaType ? { media_type: p.mediaType } : {}),
                 ...(p.detail ? { detail: p.detail } : {}),
             };
         }
         if (p.type === "audio")
-            return { type: "audio", data: p.data, media_type: p.mediaType };
+            return { type: "audio", source: p.source, media_type: p.mediaType };
         if (p.type === "text")
             return { type: "text", text: p.text };
         return { type: "text", text: "" };

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

@@ -4,7 +4,7 @@ import type { WorkflowNodeStatus } from "./types/agent.js";
 export { REPLAY_CONTENT_MAX_BYTES as RECOVERY_CONTENT_MAX_BYTES } from "./replay-sanitize.js";
 /**
  * Normalize a persisted llm_completed event for recovery. Content is sanitized
- * and token_count backfilled, but the stored `provider_replay` envelope is
+ * and any existing token_count remains raw evidence, but the stored `provider_replay` envelope is
  * passed through verbatim — this layer is provider-neutral and never
  * synthesizes protocol-specific replay shapes. Canonical replay seeding is the
  * responsibility of the target provider's `seedProviderReplay`.

package/dist/runtime/session-repair.js

@@ -1,11 +1,8 @@
 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));
-}
 /**
  * Normalize a persisted llm_completed event for recovery. Content is sanitized
- * and token_count backfilled, but the stored `provider_replay` envelope is
+ * and any existing token_count remains raw evidence, but the stored `provider_replay` envelope is
  * passed through verbatim — this layer is provider-neutral and never
  * synthesizes protocol-specific replay shapes. Canonical replay seeding is the
  * responsibility of the target provider's `seedProviderReplay`.
@@ -19,7 +16,7 @@ export function normalizeLlmCompleted(event, maxBytes) {
         turn: event.turn,
         content,
         tool_calls: toolCalls,
-        token_count: event.token_count ?? estimateTokenCount(content),
+        ...(event.token_count !== undefined ? { token_count: event.token_count } : {}),
         ...(providerReplay ? { provider_replay: providerReplay } : {}),
         // P4 §3: the evidence-plane fields ride along verbatim — recovery never reads them
         // (SessionLog is evidence, not authority), so normalize must neither synthesize nor drop them.

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

@@ -218,7 +218,6 @@ export interface KernelWorkflowNodeOutcome {
             name: string;
             arguments?: Record<string, unknown>;
         }>;
-        token_count?: number;
     };
 }
 export interface WorkflowNodeOutcome {

package/dist/runtime/types/agent.js

@@ -92,7 +92,6 @@ export function subAgentResultToKernel(result) {
                         name: tc.name,
                         arguments: safeParseToolArgs(tc.arguments),
                     })),
-                    ...(finalMessage.tokenCount !== undefined ? { token_count: finalMessage.tokenCount } : {}),
                 }
                 : null,
             turns_used: result.result.turnsUsed,
@@ -146,7 +145,6 @@ export function workflowNodeOutcomeFromKernel(raw) {
                         name: call.name,
                         arguments: JSON.stringify(call.arguments ?? {}),
                     })),
-                    ...(output.token_count != null ? { tokenCount: output.token_count } : {}),
                 },
             }
             : {}),

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/v1";
+export declare const VERIFIABLE_FORK_SCHEMA: "verifiable-fork/v1";
+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/v1";
+export const VERIFIABLE_FORK_SCHEMA = "verifiable-fork/v1";
+/** 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/types.d.ts

@@ -2,10 +2,7 @@ import type { WorkflowNodeSpec } from "./runtime/types/agent.js";
 export interface ContentPart {
     type: "text" | "image" | "audio" | "tool_result";
     text?: string;
-    /** Remote image URL (mutually exclusive with `data`). */
-    url?: string;
-    /** Raw base64-encoded bytes (image/audio). */
-    data?: string;
+    source?: MediaSource;
     /** MIME type, e.g. `"image/png"`. */
     mediaType?: string;
     /** OpenAI vision detail level. */
@@ -45,7 +42,6 @@ export type ToolOutputBlock = {
 export interface Message {
     role: "system" | "user" | "assistant" | "tool";
     content: string;
-    tokenCount?: number;
     toolCalls?: ToolCall[];
     /** Multimodal parts (text + image/audio). When present, providers render these
      *  instead of the plain `content` string. */
@@ -63,7 +59,6 @@ export interface ToolResult {
     isError: boolean;
     isFatal?: boolean;
     errorKind?: ToolErrorKind;
-    tokenCount?: number;
     contentParts?: ToolOutputBlock[];
 }
 export interface ToolSchema {

package/package.json

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