@deepstrike/sdk 0.2.69 → 0.2.70

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

@@ -1,4 +1,4 @@
-import type { EntropySample, Message, RenderedContext, TaskUpdate, ToolCall, ToolResult, ToolSchema } from "../types.js";
+import type { EntropySample, ProviderMessage, RenderedContext, TaskUpdate, ToolCall, ToolExecutionResult, ToolSchema } from "../types.js";
 import type { SkillMetadata } from "../skills/loader.js";
 import type { RollbackReason } from "./session-log.js";
 export declare const CANONICAL_CONTENT_PARTS_PREFIX = "[[deepstrike-content-parts]]";
@@ -15,7 +15,7 @@ export interface KernelLoopResult {
     termination: string;
     turnsUsed: number;
     totalTokensUsed: number;
-    finalMessage?: Message;
+    finalMessage?: ProviderMessage;
     /** ③ loop-agent: the kernel-adjudicated after-round decision (absent on non-loop runs). */
     paceDecision?: PaceDecision;
 }
@@ -36,6 +36,7 @@ export type KernelRunnerAction = {
     effectId: string;
     context: RenderedContext;
     tools: ToolSchema[];
+    contextEffect: Record<string, unknown>;
 } | {
     kind: "execute_tool";
     effectId: string;
@@ -75,7 +76,7 @@ export type KernelRunnerAction = {
 } | {
     kind: "archive_page_out";
     effectId: string;
-    archived?: Message[];
+    archived?: ProviderMessage[];
     handleId?: string;
     payload?: {
         content: string;
@@ -212,8 +213,8 @@ export declare function archivePresentationFromObservations(observations: readon
 };
 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>;
-export declare function toolResultToKernel(result: ToolResult): Record<string, unknown>;
+export declare function messageToKernelMessage(message: ProviderMessage): Record<string, unknown>;
+export declare function toolResultToKernel(result: ToolExecutionResult): Record<string, unknown>;
 export declare function taskUpdateToKernel(update: TaskUpdate): Record<string, unknown>;
 export declare function capabilityTool(schema: ToolSchema): Record<string, unknown>;
 export declare function capabilitySkill(skill: SkillMetadata): Record<string, unknown>;
@@ -222,5 +223,5 @@ export declare function capabilityCommandMount(capability: Record<string, unknow
 export declare function capabilityCommandUnmount(capabilityKind: string, id: string): Record<string, unknown>;
 /** Camel-case an `entropy_sample` kernel observation into the SDK's `EntropySample`. */
 export declare function entropySampleFromObservation(obs: KernelObservation): EntropySample;
-export declare function kernelMessageToSdk(raw: Record<string, unknown>): Message;
+export declare function kernelMessageToSdk(raw: Record<string, unknown>): ProviderMessage;
 export declare function renderedContextToSdk(raw: Record<string, unknown>): RenderedContext;

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

@@ -1,10 +1,10 @@
-import type { LLMProvider, Message, ProviderDescriptor, ProviderReplay, RenderedContext, ReplayabilityAssessment, ToolCall } from "../types.js";
+import type { LLMProvider, ProviderMessage, ProviderDescriptor, ProviderReplay, RenderedContext, ReplayabilityAssessment, ToolCall } from "../types.js";
 import type { SessionEvent } from "./session-log.js";
 export declare class ProviderReplayProtocolMismatchError extends Error {
     readonly code: "provider_replay_protocol_mismatch";
     constructor(provider: string, storedProtocol: string, resolvedProtocol: string);
 }
-export declare function assistantReplayKey(message: Pick<Message, "content" | "toolCalls">): string;
+export declare function assistantReplayKey(message: Pick<ProviderMessage, "content" | "toolCalls">): string;
 /**
  * A stored replay may only be seeded into a provider speaking the same wire
  * protocol. On a cross-protocol fallback (provider A -> provider B) the

package/dist/runtime/provider-replay.js

@@ -67,7 +67,7 @@ export function seedProviderReplayFromEvents(provider, events) {
         if (event.kind !== "llm_completed")
             continue;
         const toolCalls = event.tool_calls ?? [];
-        const stored = event.provider_replay;
+        const stored = event.wire_evidence?.replay_state;
         if (!stored)
             continue;
         if (!isReplayCompatibleWithProvider(stored, descriptor)) {

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

@@ -6,21 +6,21 @@
  * pulls the assistant turns in order, so the fixture is just "a prior session log + the messages
  * the LLM produced". No new on-disk format.
  */
-import type { Message } from "../types.js";
+import type { ProviderMessage } from "../types.js";
 import type { SessionEvent } from "./session-log.js";
 /**
  * Extract the ordered list of assistant Messages from a recorded session log.
  *
  * 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)`.
+ * one ProviderMessage per event. Pass the result directly to `new ReplayProvider(messages)`.
  *
  * Accepts both wire shapes the SDK uses interchangeably:
- *   - in-memory: `{ toolCalls, providerReplay }` (camelCase)
- *   - serialised session-log: `{ tool_calls, token_count, provider_replay }` (snake_case; token_count is wire evidence)
+ *   - in-memory: `{ toolCalls }` (camelCase)
+ *   - serialised session-log: `{ tool_calls, token_count, wire_evidence }` (snake_case; token_count is wire evidence)
  *
  * @param events Session events, in original order. Accepts both `{ event, seq }` (the shape
  *               `SessionLog.read()` returns) and a bare `SessionEvent[]`.
  */
 export declare function extractRecordedMessages(events: Array<{
     event: SessionEvent;
-} | SessionEvent>): Message[];
+} | SessionEvent>): ProviderMessage[];

package/dist/runtime/replay-fixture.js

@@ -10,11 +10,11 @@
  * Extract the ordered list of assistant Messages from a recorded session log.
  *
  * 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)`.
+ * one ProviderMessage per event. Pass the result directly to `new ReplayProvider(messages)`.
  *
  * Accepts both wire shapes the SDK uses interchangeably:
- *   - in-memory: `{ toolCalls, providerReplay }` (camelCase)
- *   - serialised session-log: `{ tool_calls, token_count, provider_replay }` (snake_case; token_count is wire evidence)
+ *   - in-memory: `{ toolCalls }` (camelCase)
+ *   - serialised session-log: `{ tool_calls, token_count, wire_evidence }` (snake_case; token_count is wire evidence)
  *
  * @param events Session events, in original order. Accepts both `{ event, seq }` (the shape
  *               `SessionLog.read()` returns) and a bare `SessionEvent[]`.

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

@@ -17,14 +17,14 @@
  *     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 estimated from `message.content.length / 4`; provider usage belongs to
- *     the session measurement plane, never to the public Message mirror.
+ *     the session measurement plane, never to the public ProviderMessage mirror.
  *   - `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.
  *
  * Tokenizer: by default a `chars/4` estimator (±20% for English; worse for code/JSON). For tighter
  * numbers plug `opts.tokenizer = tiktokenEncoder` or similar.
  */
-import type { LLMProvider, Message, ProviderDescriptor, ProviderRunState, RenderedContext, StreamEvent, ToolSchema } from "../types.js";
+import type { LLMProvider, ProviderMessage, ProviderDescriptor, ProviderRunState, RenderedContext, StreamEvent, ToolSchema } from "../types.js";
 export interface ReplayProviderOpts {
     /**
      * Maps a rendered-context text payload to a token count. Defaults to `chars / 4`.
@@ -54,7 +54,7 @@ export declare class ReplayProvider implements LLMProvider {
      * @param messages Ordered list of assistant messages to replay (one per LLM call).
      * @param opts Optional tokenizer / descriptor / wrap-around behavior.
      */
-    constructor(messages: ReadonlyArray<Message>, opts?: ReplayProviderOpts);
+    constructor(messages: ReadonlyArray<ProviderMessage>, opts?: ReplayProviderOpts);
     descriptor(): ProviderDescriptor;
     /** Number of messages consumed so far. */
     consumed(): number;
@@ -62,7 +62,7 @@ export declare class ReplayProvider implements LLMProvider {
     remaining(): number;
     /** Reset the cursor — useful for re-running the same fixture in a fresh session. */
     reset(): void;
-    complete(_context: RenderedContext, _tools: ToolSchema[]): Promise<Message>;
+    complete(_context: RenderedContext, _tools: ToolSchema[]): Promise<ProviderMessage>;
     stream(context: RenderedContext, tools: ToolSchema[], _extensions?: Record<string, unknown>, _state?: ProviderRunState, _signal?: AbortSignal): AsyncIterable<StreamEvent>;
     private pull;
     private estimateInputTokens;

package/dist/runtime/replay-provider.js

@@ -17,7 +17,7 @@
  *     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 estimated from `message.content.length / 4`; provider usage belongs to
- *     the session measurement plane, never to the public Message mirror.
+ *     the session measurement plane, never to the public ProviderMessage mirror.
  *   - `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/runner.d.ts

@@ -1,4 +1,4 @@
-import type { LLMProvider, Message, ContentPart, ToolSchema, StreamEvent, ToolSuspendEvent, PermissionRequestEvent, PermissionResponse, AsyncSummarizer, MemorySummarizer, EntropySample, EntropyWatchOptions } from "../types.js";
+import type { LLMProvider, ProviderMessage, ContentPart, ToolSchema, StreamEvent, ToolSuspendEvent, PermissionRequestEvent, PermissionResponse, AsyncSummarizer, MemorySummarizer, EntropySample, EntropyWatchOptions } from "../types.js";
 import type { MemoryStore, MemoryRecord, MemoryRecall, MemoryScope, MemoryQuery } from "../memory/protocols.js";
 import type { KnowledgeSource } from "../knowledge/source.js";
 import type { RuntimeSignalUrgency, SignalSource } from "../signals/types.js";
@@ -95,6 +95,8 @@ export interface KernelReliabilityOptions {
 export type OperationCancellationReason = "user" | "deadline" | "lease_lost" | "host_shutdown";
 export interface RuntimeOptions {
     provider: LLMProvider;
+    /** Host-owned artifact set identity captured in operation genesis. */
+    artifactSetDigest?: string;
     /** M4/G5: cumulative token cap for this run (the kernel's `max_total_tokens`). A workflow node's
      *  `tokenBudget` flows here for its child run, so an expensive node self-terminates at the cap.
      *  Undefined ⇒ the kernel default. */
@@ -109,7 +111,7 @@ export interface RuntimeOptions {
      *  Undefined ⇒ worktree nodes fall back to the inherited plane (no isolation). */
     worktreeManager?: import("./worktree-plane.js").WorktreeManager;
     sessionLog: SessionLog;
-    /** ABI v3 transaction capability. Default session logs expose one; custom logs pass it explicitly. */
+    /** ABI transaction capability. Default session logs expose one; custom logs pass it explicitly. */
     kernelJournal?: KernelJournal;
     executionPlane: ExecutionPlane;
     /** Receives failures from run-owned best-effort tasks after their semantic owner has committed. */
@@ -486,7 +488,7 @@ export declare class RuntimeRunner {
      *  K1: `opts.key` gives the entry identity — a same-key push upserts (applied at the next
      *  compaction/renewal boundary, where the cached system[1] block is rewritten anyway) instead
      *  of appending a duplicate. `opts.pinned` exempts the entry from the knowledge-budget sweep. */
-    pushKnowledge(message: Message, tokens?: number, opts?: {
+    pushKnowledge(message: ProviderMessage, tokens?: number, opts?: {
         key?: string;
         pinned?: boolean;
     }): Promise<void>;
@@ -601,14 +603,14 @@ export declare class RuntimeRunner {
  *  message exists. A tail assistant tool_call with nothing after it is a genuinely PENDING tool the
  *  run stopped in front of (the wake/recovery case), which must stay unpaired so wake executes it.
  *  Pure. */
-export declare function pairOrphanToolCalls(messages: Message[]): Message[];
+export declare function pairOrphanToolCalls(messages: ProviderMessage[]): ProviderMessage[];
 export declare function replayMessages(events: Array<{
     seq: number;
     event: SessionEvent;
-}>, maxBytes?: number): Message[];
+}>, maxBytes?: number): ProviderMessage[];
 export declare function replayMessagesAsync(events: Array<{
     seq: number;
     event: SessionEvent;
-}>, maxBytes?: number, loadArchive?: (archiveRef: string) => Promise<Message[]>): Promise<Message[]>;
+}>, maxBytes?: number, loadArchive?: (archiveRef: string) => Promise<ProviderMessage[]>): Promise<ProviderMessage[]>;
 /** Collect all text_delta events from a run into a single string. */
 export declare function collectText(stream: AsyncIterable<StreamEvent>): Promise<string>;

package/dist/runtime/runner.js

@@ -1,3 +1,5 @@
+import { prepareProviderRequest } from "../providers/prepared-request.js";
+import { createNativeContextPreparationAdapter } from "./context.js";
 import { createHash } from "node:crypto";
 import { extractSessionMemories } from "../memory/extraction.js";
 import { resolvePermissionRequest } from "./execution-plane.js";
@@ -389,6 +391,7 @@ export class RuntimeRunner {
             maxTurns: this.opts.maxTurns,
             maxTotalTokens: this.opts.maxTotalTokens,
             maxWallMs: this.opts.timeoutMs,
+            artifactSetDigest: this.opts.artifactSetDigest,
             memoryBindingId: `node-memory-${this.opts.agentId ?? "root"}`,
             persistPayload: async (callId, content, previewBytes) => {
                 const digest = `sha256:${createHash("sha256").update(content).digest("hex")}`;
@@ -1077,7 +1080,7 @@ export class RuntimeRunner {
                 else if (completionAction) {
                     throw new Error(`workflow completion returned unexpected effect: ${completionAction.kind}`);
                 }
-                // ABI v3: child-authored DAG additions ride on ChildCompleted.parent_requests. Admission is
+                // ABI: child-authored DAG additions ride on ChildCompleted.parent_requests. Admission is
                 // independent of the completion fact; only an admitted request emits this observation.
                 if (result.submittedNodes?.length) {
                     const submitted = obs.find(o => o.kind === "workflow_nodes_submitted");
@@ -1636,13 +1639,16 @@ export class RuntimeRunner {
                         // P4 §2: the raw postflight provider usage frame, kept whole so the attempt's
                         // measurement carries full fields (only the settlement crosses the kernel boundary, B4).
                         let turnProviderUsage;
-                        const providerPlan = createProviderRequestPlanForProvider(this.opts.provider, context, tools, ext);
+                        const preparedRequest = prepareProviderRequest(this.opts.provider, context, tools, ext, providerState);
+                        const providerPlan = createProviderRequestPlanForProvider(this.opts.provider, context, tools, ext, {
+                            scope: preparedRequest.scope, request: preparedRequest.request, state: preparedRequest.state,
+                        });
                         const recorded = measurementForPlan(providerPlan, recordedMeasurements.get(providerPlan.fingerprint));
                         let promptMeasurement = recorded;
                         if (!promptMeasurement && !context.budgetOverflow) {
                             try {
-                                const count = this.opts.provider.countTokens
-                                    ? await withTimeout(this.opts.provider.countTokens(context, tools, Object.keys(ext).length ? ext : undefined), 5_000)
+                                const count = preparedRequest.countTokens
+                                    ? await withTimeout(preparedRequest.countTokens(), 5_000)
                                     : undefined;
                                 promptMeasurement = recordPromptMeasurement(providerPlan, count ?? {
                                     inputTokens: estimateProviderPromptTokens(context, tools),
@@ -1702,9 +1708,21 @@ export class RuntimeRunner {
                             this.providerRetryPending = action.kind === "call_provider";
                             continue;
                         }
+                        if (!promptMeasurement)
+                            throw new Error("context preparation requires prompt measurement");
+                        const contextAdapter = createNativeContextPreparationAdapter();
+                        const preparation = contextAdapter.prepare({
+                            effect: action.contextEffect,
+                            request_fingerprint: providerPlan.fingerprint,
+                            provider_route: { ...this.providerRoute, request_fingerprint_scope: preparedRequest.scope },
+                            prompt_measurement: promptMeasurement,
+                        });
+                        await this.opts.sessionLog.append(sessionId, {
+                            kind: "context_prepared", turn: runtime.turn(), effect_id: providerEffectId, preparation,
+                        });
                         const abortSignal = this.abortController?.signal;
                         try {
-                            for await (const evt of this.opts.provider.stream(context, tools, Object.keys(ext).length ? ext : undefined, providerState, abortSignal)) {
+                            for await (const evt of preparedRequest.stream(abortSignal)) {
                                 // #2-B-ii: a preempting `interrupt()` fires `abortController` — stop consuming the live
                                 // stream immediately (providers that forward `signal` also abort the socket; the rest at
                                 // least stop here at the next event). The loop-top `interrupted` check then ends the run.
@@ -1959,7 +1977,6 @@ export class RuntimeRunner {
                             content: finalText,
                             tokenCount: turnOutputTokens || turnTokens || undefined,
                             toolCalls: finalToolCalls,
-                            providerReplay,
                             effectId: providerEffectId,
                             invocationId,
                             wireEvidence,

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

@@ -1,5 +1,6 @@
+import type { ContextPrepared } from "./context.js";
 import type { KernelPrimitive } from "./kernel-event-log.js";
-import type { ContentPart, ProviderReplay, ProviderWireEvidence, ToolCall, ToolErrorKind } from "../types.js";
+import type { ContentPart, ProviderWireEvidence, ToolCall, ToolErrorKind } from "../types.js";
 import type { RecordedPromptMeasurement, ResolvedProviderRoute } from "../providers/request-plan.js";
 import type { ProviderAttemptRecord } from "./execution-evidence.js";
 import type { MemoryRecall, MemoryScope } from "../memory/protocols.js";
@@ -38,10 +39,14 @@ export type SessionEvent = {
     content: string;
     token_count?: number;
     tool_calls: ToolCall[];
-    provider_replay?: ProviderReplay;
     effect_id?: string;
     invocation_id?: string;
     wire_evidence?: ProviderWireEvidence;
+} | {
+    kind: "context_prepared";
+    turn: number;
+    effect_id: string;
+    preparation: ContextPrepared;
 } | {
     kind: "prompt_measured";
     turn: number;
@@ -274,7 +279,7 @@ export type SessionEvent = {
     classify_branch?: string;
     tournament_winner?: string;
     loop_continue?: boolean;
-    output?: import("../types.js").Message;
+    output?: import("../types.js").ProviderMessage;
 } | {
     kind: "workflow_nodes_submitted";
     turn: number;
@@ -342,7 +347,7 @@ export type SessionEventKind = SessionEvent["kind"];
  * `tests/fixtures/sdk-conformance/canonical/session-event-vocabulary.json` and the python/wasm
  * vocabularies turns cross-SDK conformance red. Declared in `SessionEvent` union order.
  */
-export declare const SESSION_EVENT_KINDS: readonly ["run_started", "llm_completed", "prompt_measured", "provider_attempt", "tool_requested", "tool_completed", "tool_argument_repaired", "tool_denied", "permission_requested", "permission_resolved", "compressed", "page_out", "semantic_archive_pending", "semantic_archive_completed", "semantic_archive_failed", "page_in", "rollbacked", "capability_changed", "context_renewed", "suspended", "resumed", "tool_gated", "signal_delivery_disposed", "budget_exceeded", "budget_usage_reported", "operation_cancelled", "milestone_advanced", "milestone_blocked", "checkpoint_taken", "entropy_sample", "entropy_alert", "agent_process_changed", "memory_written", "memory_queried", "memory_validation_failed", "memory_write_failed", "memory_query_failed", "memory_retrieval_result", "workflow_node_completed", "workflow_nodes_submitted", "workflow_batch_spawned", "workflow_completed", "kernel_observation", "run_terminal", "summary_upgraded", "group_member_joined", "group_budget_charged", "round_started", "round_paced"];
+export declare const SESSION_EVENT_KINDS: readonly ["run_started", "llm_completed", "prompt_measured", "context_prepared", "provider_attempt", "tool_requested", "tool_completed", "tool_argument_repaired", "tool_denied", "permission_requested", "permission_resolved", "compressed", "page_out", "semantic_archive_pending", "semantic_archive_completed", "semantic_archive_failed", "page_in", "rollbacked", "capability_changed", "context_renewed", "suspended", "resumed", "tool_gated", "signal_delivery_disposed", "budget_exceeded", "budget_usage_reported", "operation_cancelled", "milestone_advanced", "milestone_blocked", "checkpoint_taken", "entropy_sample", "entropy_alert", "agent_process_changed", "memory_written", "memory_queried", "memory_validation_failed", "memory_write_failed", "memory_query_failed", "memory_retrieval_result", "workflow_node_completed", "workflow_nodes_submitted", "workflow_batch_spawned", "workflow_completed", "kernel_observation", "run_terminal", "summary_upgraded", "group_member_joined", "group_budget_charged", "round_started", "round_paced"];
 /**
  * The business-projection log (spec §9.2): run started/terminal, stream events, observations,
  * provider/tool presentation, audit metadata.

package/dist/runtime/session-log.js

@@ -16,6 +16,7 @@ export const SESSION_EVENT_KINDS = [
     "run_started",
     "llm_completed",
     "prompt_measured",
+    "context_prepared",
     "provider_attempt",
     "tool_requested",
     "tool_completed",
@@ -214,8 +215,8 @@ function decodePersistedSessionRecord(value) {
     if (!record.event || typeof record.event !== "object" || Array.isArray(record.event))
         throw new Error("session record event must be an object");
     const event = record.event;
-    if (event.kind === "llm_completed" && event.provider_replay !== undefined) {
-        assertCanonicalProviderReplay(event.provider_replay);
+    if (event.kind === "llm_completed" && "provider_replay" in event) {
+        throw new Error("llm_completed has removed provider_replay field; use wire_evidence.replay_state");
     }
     if (event.kind === "llm_completed" && event.wire_evidence !== undefined) {
         assertCanonicalWireEvidence(event.wire_evidence);

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

@@ -1,4 +1,4 @@
-import type { Message, ProviderReplay, ProviderWireEvidence, ToolCall } from "../types.js";
+import type { ProviderMessage, ProviderWireEvidence, ToolCall } from "../types.js";
 import type { SessionEvent } from "./session-log.js";
 import type { WorkflowNodeStatus } from "../types/agent.js";
 export { REPLAY_CONTENT_MAX_BYTES as RECOVERY_CONTENT_MAX_BYTES } from "./replay-sanitize.js";
@@ -6,7 +6,7 @@ export { REPLAY_CONTENT_MAX_BYTES as RECOVERY_CONTENT_MAX_BYTES } from "./replay
  * Normalize a persisted llm_completed event for recovery.
  *
  * Content is sanitized while any existing token_count remains raw evidence, but the stored
- * `provider_replay` envelope is passed through verbatim — this layer is
+ * `wire_evidence.replay_state` is passed through verbatim — this layer is
  * provider-neutral and must never synthesize protocol-specific replay shapes
  * (e.g. Anthropic `native_blocks`). Canonical replay seeding for a given protocol
  * is the responsibility of that provider's `seedProviderReplay`.
@@ -34,7 +34,6 @@ export declare function buildLlmCompletedEvent(input: {
     content: string;
     tokenCount?: number;
     toolCalls: ToolCall[];
-    providerReplay?: ProviderReplay;
     effectId?: string;
     invocationId?: string;
     wireEvidence?: ProviderWireEvidence;
@@ -58,7 +57,7 @@ export declare function buildWorkflowNodeCompletedEvent(input: {
     classifyBranch?: string;
     tournamentWinner?: string;
     loopContinue?: boolean;
-    output?: Message;
+    output?: ProviderMessage;
 }): Extract<SessionEvent, {
     kind: "workflow_node_completed";
 }>;

package/dist/runtime/session-repair.js

@@ -4,7 +4,7 @@ export { REPLAY_CONTENT_MAX_BYTES as RECOVERY_CONTENT_MAX_BYTES } from "./replay
  * Normalize a persisted llm_completed event for recovery.
  *
  * Content is sanitized while any existing token_count remains raw evidence, but the stored
- * `provider_replay` envelope is passed through verbatim — this layer is
+ * `wire_evidence.replay_state` is passed through verbatim — this layer is
  * provider-neutral and must never synthesize protocol-specific replay shapes
  * (e.g. Anthropic `native_blocks`). Canonical replay seeding for a given protocol
  * is the responsibility of that provider's `seedProviderReplay`.
@@ -16,14 +16,12 @@ export { REPLAY_CONTENT_MAX_BYTES as RECOVERY_CONTENT_MAX_BYTES } from "./replay
 export function normalizeLlmCompleted(event, maxBytes) {
     const content = sanitizeReplayText(event.content ?? "", maxBytes);
     const toolCalls = event.tool_calls ?? [];
-    const providerReplay = event.provider_replay;
     return {
         kind: "llm_completed",
         turn: event.turn,
         content,
         tool_calls: toolCalls,
         ...(event.token_count !== undefined ? { token_count: event.token_count } : {}),
-        ...(providerReplay ? { provider_replay: providerReplay } : {}),
         ...(event.effect_id !== undefined ? { effect_id: event.effect_id } : {}),
         ...(event.invocation_id !== undefined ? { invocation_id: event.invocation_id } : {}),
         ...(event.wire_evidence !== undefined ? { wire_evidence: event.wire_evidence } : {}),
@@ -45,7 +43,6 @@ export function buildLlmCompletedEvent(input) {
         content: sanitizeReplayText(input.content),
         tool_calls: input.toolCalls ?? [],
         token_count: input.tokenCount,
-        provider_replay: input.providerReplay,
         ...(input.effectId !== undefined ? { effect_id: input.effectId } : {}),
         ...(input.invocationId !== undefined ? { invocation_id: input.invocationId } : {}),
         ...(input.wireEvidence !== undefined ? { wire_evidence: input.wireEvidence } : {}),

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

@@ -1,6 +1,6 @@
 /** 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 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";

package/dist/runtime/verifiable-report.js

@@ -1,7 +1,7 @@
 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";
+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 = {}) => {

package/dist/skills/loader.d.ts

@@ -9,7 +9,7 @@ export interface SkillMetadata {
     capabilityGrants?: Array<Record<string, unknown>>;
     /** P1-B tool gating: tool ids this skill needs. When the skill is active, the kernel narrows the
      *  exposed toolset to `stable-core ∪ allowedTools`. Parsed from `allowed_tools:` frontmatter
-     *  (comma-separated or `[a, b]`). Absent ⇒ the skill does not narrow (back-compat). */
+     *  (comma-separated or `[a, b]`). Absent ⇒ the skill does not narrow. */
     allowedTools?: string[];
 }
 /** Read one skill file and return its body (frontmatter stripped). */

package/dist/tools/index.d.ts

@@ -1,4 +1,4 @@
-import type { ToolChunk, ToolSchema, ToolResult } from "../types.js";
+import type { ToolChunk, ToolSchema, ToolExecutionResult } from "../types.js";
 import type { OperationContext } from "../runtime/reliability.js";
 /** M3/G4: the runtime context a tool may read when executing. Carries the working directory the tool
  *  should operate in — set to a sub-agent's git worktree for `isolation: "worktree"` nodes. A narrow,
@@ -35,6 +35,6 @@ export declare function executeTools(calls: {
     id: string;
     name: string;
     arguments: string;
-}[], registry: Map<string, RegisteredTool>): Promise<ToolResult[]>;
+}[], registry: Map<string, RegisteredTool>): Promise<ToolExecutionResult[]>;
 export declare function maybeWarnFailureShapedChunk(toolName: string, deltaText: string): void;
 export declare const readFile: RegisteredTool;

package/dist/types/agent.d.ts

@@ -1,4 +1,4 @@
-import type { Message, ToolSchema } from "../types.js";
+import type { ProviderMessage, ToolSchema } 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";
@@ -86,7 +86,7 @@ export interface AgentProcessChangedObservation {
 }
 export interface LoopResult {
     termination: TerminationReason | string;
-    finalMessage?: Message;
+    finalMessage?: ProviderMessage;
     turnsUsed: number;
     totalTokensUsed: number;
     /** loop-control loop stop signal: a loop iteration sets `false` to end the loop before `max_iters`.
@@ -228,7 +228,7 @@ export interface KernelWorkflowNodeOutcome {
     status: WorkflowNodeStatus;
     termination?: TerminationReason;
     output?: {
-        role: Message["role"];
+        role: ProviderMessage["role"];
         content: string;
         tool_calls?: Array<{
             id: string;
@@ -241,7 +241,7 @@ export interface WorkflowNodeOutcome {
     nodeId: string;
     status: WorkflowNodeStatus;
     termination?: TerminationReason;
-    output?: Message;
+    output?: ProviderMessage;
 }
 /** A control-plane request rejected before any workflow effect started. */
 export interface ControlRequestRejection {
@@ -308,7 +308,7 @@ export interface WorkflowBudget {
     tokens_used?: number;
     tokens_max?: number;
     tokens_remaining?: number;
-    /** Canonical ABI v3 publishes immutable caps rather than a host-authored remaining snapshot. */
+    /** Canonical ABI publishes immutable caps rather than a host-authored remaining snapshot. */
     max_total_tokens?: string | number;
     max_turns?: number;
     max_concurrency?: number;

package/dist/types.d.ts

@@ -81,10 +81,10 @@ export interface ContentBlockFile {
     mediaType?: string;
     providerOptions?: Record<string, unknown>;
 }
-/** Legal content returned by a tool. Deliberately excludes ToolResult, so nesting is
+/** Legal content returned by a tool. Deliberately excludes ToolExecutionResult, so nesting is
  * unrepresentable in the canonical type. */
 export type ToolOutputBlock = ContentBlockText | ContentBlockImage | ContentBlockAudio | ContentBlockVideo | ContentBlockFile;
-export interface Message {
+export interface ProviderMessage {
     role: "system" | "user" | "assistant" | "tool";
     /** Plain-text content. When `contentParts` is present, this holds only the text segments. */
     content: string;
@@ -98,7 +98,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;
@@ -450,7 +450,7 @@ export interface ProviderWireEvidence {
     response_id?: string;
     /** BoundedJson semantics: producers truncate to ≤4KB before landing it here. */
     raw_usage?: unknown;
-    /** The former `llm_completed.provider_replay` field, carried verbatim (P3-S2 migration). */
+    /** Provider-native replay state carried inside the wire evidence bundle. */
     replay_state?: ProviderReplay;
 }
 /**
@@ -478,7 +478,7 @@ export interface RenderedContext {
     /** Knowledge (memory retrievals, skill definitions, artifacts). Anthropic system[1] with cache_control. */
     systemKnowledge?: string;
     /** History turns only — the stable, cacheable message prefix. */
-    turns: Message[];
+    turns: ProviderMessage[];
     /**
      * Volatile State turn (task_state + signals), rebuilt every call. Providers
      * render it after the cacheable history (Anthropic: after the cache breakpoint;
@@ -486,7 +486,7 @@ export interface RenderedContext {
      * older binding that has not been rebuilt — then the State turn is still inside
      * `turns[0]` and providers render `turns` as-is.
      */
-    stateTurn?: Message;
+    stateTurn?: ProviderMessage;
     /**
      * P1-E: count of leading `turns` forming the frozen prefix — byte-stable until the next
      * compaction. The Anthropic provider pins a deep cache breakpoint at this boundary (a long-lived
@@ -512,7 +512,16 @@ export interface RuntimePolicy {
     /** Per-run wall-clock timeout in ms. */
     timeoutMs?: number;
 }
+/** 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;
     descriptor?(): ProviderDescriptor;
     /**
@@ -522,7 +531,7 @@ export interface LLMProvider {
      */
     runtimePolicy?(): RuntimePolicy;
     /** Read provider-native replay fields captured after the most recent assistant turn. */
-    peekProviderReplay?(message: Pick<Message, "content" | "toolCalls">): ProviderReplay | undefined;
+    peekProviderReplay?(message: Pick<ProviderMessage, "content" | "toolCalls">): ProviderReplay | undefined;
     /**
      * P4-S1: read the transport facts captured during the most recent execution (HTTP rung count,
      * wire response id). Optional — a provider without it simply omits the telemetry and the
@@ -531,7 +540,7 @@ export interface LLMProvider {
      */
     peekTransportTelemetry?(): ProviderTransportTelemetry | undefined;
     /** Restore provider-native replay fields when rebuilding history from SessionLog. */
-    seedProviderReplay?(message: Pick<Message, "content" | "toolCalls">, replay: ProviderReplay): void;
+    seedProviderReplay?(message: Pick<ProviderMessage, "content" | "toolCalls">, replay: ProviderReplay): void;
     /**
      * Pre-flight query: would this history validate against this provider with the
      * given extensions, without sending the request? Returns the tool-call ids
@@ -551,7 +560,7 @@ export interface LLMProvider {
      * fingerprinting and durable measurement semantics are defined.
      */
     countTokens?(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState): Promise<PromptMeasurement>;
-    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
+    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 preempting `InterruptNow` (or `interrupt()`) aborts the in-flight
      *  request. SDK-client providers should forward it to the client (`{ signal }`); the runner also
@@ -564,14 +573,14 @@ export interface LLMProvider {
  * Produces a richer LLM-generated summary that replaces the rule-based one on next wake.
  */
 export interface AsyncSummarizer {
-    summarize(archived: Message[], action: string): Promise<string>;
+    summarize(archived: ProviderMessage[], action: string): Promise<string>;
 }
 /**
  * Durable-memory summarizer for semantic `page_out` events (Layer 5 contract).
  * The kernel emits `page_out { tier_hint: "semantic" }`; the SDK persists an LLM summary to MemoryStore.
  */
 export interface MemorySummarizer {
-    summarize(archived: Message[], context: {
+    summarize(archived: ProviderMessage[], context: {
         action?: string;
     }): Promise<string>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/sdk",
-  "version": "0.2.69",
+  "version": "0.2.70",
   "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.69",
+    "@deepstrike/core": "0.2.70",
     "@google/generative-ai": "^0.24.1",
     "openai": "^7.5.0"
   },