@deepstrike/sdk 0.2.68 → 0.2.69

package/dist/index.d.ts

@@ -49,6 +49,8 @@ export { createProviderRequestPlan, createProviderRequestPlanForProvider, estima
 export type { CostObservation, NormalizedProviderUsage, PricingSnapshot, ProviderRequestEndpoint, ProviderRequestPlan, RecordedPromptMeasurement, ResolvedProviderRoute } from "./providers/request-plan.js";
 export { FULL_FOOTPRINT_USAGE_ACCOUNTING_POLICY, providerAttemptToRecord } from "./runtime/execution-evidence.js";
 export type { InvocationOutcome, ModelInvocation, ProviderAttempt, ProviderAttemptRecord, ProviderAttemptStatus, UsageAccountingPolicy, ModelUsageSettlement } from "./runtime/execution-evidence.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 type { GovernancePolicy, GovernanceConstraint } from "./governance.js";
 export { AgentPool } from "./collaboration/pool.js";
 export { Agent } from "./agent.js";

package/dist/index.js

@@ -46,6 +46,7 @@ export { createProvider, createProviderAsync, resolveProviderRuntime, resolvePro
 export { UnsupportedModalityError } from "./providers/base.js";
 export { createProviderRequestPlan, createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, normalizeProviderUsage, priceProviderUsage, recordPromptMeasurement, resolveProviderRoute } from "./providers/request-plan.js";
 export { FULL_FOOTPRINT_USAGE_ACCOUNTING_POLICY, providerAttemptToRecord } from "./runtime/execution-evidence.js";
+export { VERIFIABLE_REPORT_SCHEMA, VERIFIABLE_FORK_SCHEMA, assertVerifiableReportSchema, createVerifiableRuntimeAdapter, createNativeVerifiableRuntimeAdapter, VerifiableOperation, } from "./runtime/verifiable-report.js";
 // ── Multi-agent primitive ───────────────────────────────────────────────────
 // Parallel fan-out / sub-agent delegation. The full orchestration layer is in `@deepstrike/sdk/workflow`.
 export { AgentPool } from "./collaboration/pool.js";

package/dist/kernel.d.ts

@@ -153,6 +153,7 @@ interface KernelModule {
     buildEvalMessages(goal: string, criteria: NativeCriterion[], result: string, attempt: number, extractSkillOnPass: boolean): Message[];
     parseVerdict(content: string): Verdict;
     verdictOutputSchema(extractSkillOnPass: boolean): string;
+    verifiableOperationJson(request: string): string;
 }
 export declare function getKernel(): KernelModule;
 export {};

package/dist/os/public.d.ts

@@ -17,3 +17,5 @@ export { extractRecordedMessages } from "../runtime/replay-fixture.js";
 export { ProviderReplayValidationError, DEGRADED_REASONING_PLACEHOLDER } from "../providers/replay-validator.js";
 export { ProviderReplayProtocolMismatchError, assessProviderReplayability, peekProviderReplay, seedProviderReplayFromEvents, isReplayCompatibleWithProvider, } from "../runtime/provider-replay.js";
 export type { ReplayabilityAssessment } from "../types.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";

package/dist/os/public.js

@@ -13,3 +13,4 @@ export { ReplayProvider } from "../runtime/replay-provider.js";
 export { extractRecordedMessages } from "../runtime/replay-fixture.js";
 export { ProviderReplayValidationError, DEGRADED_REASONING_PLACEHOLDER } from "../providers/replay-validator.js";
 export { ProviderReplayProtocolMismatchError, assessProviderReplayability, peekProviderReplay, seedProviderReplayFromEvents, isReplayCompatibleWithProvider, } from "../runtime/provider-replay.js";
+export { VERIFIABLE_REPORT_SCHEMA, VERIFIABLE_FORK_SCHEMA, assertVerifiableReportSchema, createVerifiableRuntimeAdapter, createNativeVerifiableRuntimeAdapter, VerifiableOperation, } from "../runtime/verifiable-report.js";

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

@@ -0,0 +1,64 @@
+/** 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 ForkPlan extends VerifiableForkManifest {
+    readonly at_step: string;
+}
+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 installed native Node binding. */
+export declare function createNativeVerifiableRuntimeAdapter(): VerifiableRuntimeAdapter;
+/**
+ * Storage-neutral framework handle. The adapter is the single semantic bridge to Rust core;
+ * filesystem, database, and browser stores implement evidence loading outside this class.
+ */
+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 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 declare function assertVerifiableReportSchema(value: {
+    schema?: unknown;
+}): void;

package/dist/runtime/verifiable-report.js

@@ -0,0 +1,66 @@
+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 installed native Node binding. */
+export function createNativeVerifiableRuntimeAdapter() {
+    return createVerifiableRuntimeAdapter(getKernel().verifiableOperationJson);
+}
+/**
+ * Storage-neutral framework handle. The adapter is the single semantic bridge to Rust core;
+ * filesystem, database, and browser stores implement evidence loading outside this class.
+ */
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/sdk",
-  "version": "0.2.68",
+  "version": "0.2.69",
   "description": "DeepStrike Node.js SDK",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",
@@ -73,7 +73,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.99.0",
-    "@deepstrike/core": "0.2.68",
+    "@deepstrike/core": "0.2.69",
     "@google/generative-ai": "^0.24.1",
     "openai": "^7.5.0"
   },