@deepstrike/sdk 0.2.69 → 0.2.70

package/dist/index.d.ts

@@ -51,6 +51,8 @@ export { FULL_FOOTPRINT_USAGE_ACCOUNTING_POLICY, providerAttemptToRecord } from
 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 { createEvolutionRuntimeAdapter, createNativeEvolutionRuntimeAdapter, EvolutionRuntime } from "./runtime/evolution.js";
+export type { ActivationBinding, ArtifactKind, ArtifactManifest, ArtifactRef, ArtifactSet, ArtifactVersion, ContextEntryRef, ContextEntrySource, ContextExecutionInput, ContextPreparationRequest, ContextPlan, ContextPlanAction, ContextSelection, ContextState, EvaluationContextBinding, EvaluationFact, EvaluationGate, EvaluationMetric, EvaluationRun, EvolutionBundle, EvolutionProposal, EvolutionReport, EvolutionVerdict, EvolutionViolation, PromotionDecision, PromotionOutcome, EvolutionStore, } from "./runtime/evolution.js";
 export type { GovernancePolicy, GovernanceConstraint } from "./governance.js";
 export { AgentPool } from "./collaboration/pool.js";
 export { Agent } from "./agent.js";
@@ -63,7 +65,10 @@ export type { Knowledge, KnowledgeSourceRef } from "./knowledge/public.js";
 export type { AgentRef, Handoff } from "./handoff-target.js";
 export type { Session } from "./session.js";
 export type { RuntimeSignal, SignalClaim, SignalDeliveryReceipt, SignalSource, } from "./signals/types.js";
-export type { Message, ToolCall, ToolResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, MediaSource, ContentBlockText, ContentBlockImage, ContentBlockAudio, ContentBlockVideo, ContentBlockFile, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolChunk, ToolDeltaEvent, ToolSuspendEvent, ToolResultEvent, ToolAuditFailedEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, PermissionResolvedEvent, PermissionResponse, EntropySample, EntropySampleEvent, EntropyAlertEvent, EntropyWatchOptions, LLMProvider, RetryConfig, TokenUsage, ProviderWireEvidence, ProviderTransportTelemetry, } from "./types.js";
+export type { ProviderMessage, ToolCall, ToolExecutionResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, MediaSource, ContentBlockText, ContentBlockImage, ContentBlockAudio, ContentBlockVideo, ContentBlockFile, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolChunk, ToolDeltaEvent, ToolSuspendEvent, ToolResultEvent, ToolAuditFailedEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, PermissionResolvedEvent, PermissionResponse, EntropySample, EntropySampleEvent, EntropyAlertEvent, EntropyWatchOptions, LLMProvider, RetryConfig, TokenUsage, ProviderWireEvidence, ProviderTransportTelemetry, } from "./types.js";
 export { DurableContentError, decodeDurableContent, decodeDurableToolResult, encodeDurableContent, encodeDurableToolResult, toolOutputBlocksToDurable, durableBlocksToToolOutput, } from "./runtime/durable-content.js";
 export type { DurableContent, DurableContentBlock, DurableSource, DurableToolResult } from "./runtime/durable-content.js";
 export type { WorkflowSpec, WorkflowNodeSpec, SchedulingFactors, WorkflowDependencyPolicy, WorkflowNodeStatus, WorkflowNodeOutcome, WorkflowOutcome, } from "./types/agent.js";
+export { createContextPreparationAdapter, createNativeContextPreparationAdapter } from "./runtime/context.js";
+export type { ContextPrepareJson, ContextVerifyJson, ContextPrepared, ContextProviderPreparationRequest } from "./runtime/context.js";
+export type { PreparedProviderRequest } from "./types.js";

package/dist/index.js

@@ -47,6 +47,7 @@ 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";
+export { createEvolutionRuntimeAdapter, createNativeEvolutionRuntimeAdapter, EvolutionRuntime } from "./runtime/evolution.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";
@@ -54,3 +55,4 @@ export { AgentPool } from "./collaboration/pool.js";
 export { Agent } from "./agent.js";
 export { lowerAgent, normalizeAgent } from "./agent-ir.js";
 export { DurableContentError, decodeDurableContent, decodeDurableToolResult, encodeDurableContent, encodeDurableToolResult, toolOutputBlocksToDurable, durableBlocksToToolOutput, } from "./runtime/durable-content.js";
+export { createContextPreparationAdapter, createNativeContextPreparationAdapter } from "./runtime/context.js";

package/dist/kernel.d.ts

@@ -1,4 +1,4 @@
-import type { Message } from "./types.js";
+import type { ProviderMessage } from "./types.js";
 /**
  * M2 资源配额 — declarative resource limits enforced at the kernel's single syscall trap.
  *
@@ -141,8 +141,8 @@ export interface CanonicalKernelInstance {
     restore(checkpointBytes: Buffer | undefined, recordBytes: Buffer[]): CanonicalRestoreCost;
     lifecycle(): "created" | "configured" | "running" | "suspended" | "completed" | "cancelled" | "failed";
     pendingEffectsJson(): string;
-    /** Canonical core projection; additive during the 0.2.62 migration. */
-    currentProjectionJson(): string;
+    /** Canonical host projection selected by the core transaction. */
+    projectionJson(): string;
     projectPlannedStepJson(plannedStepJson: string): string;
     publishedEffectsManifestJson(plannedStepJson: string): string;
     terminalJson(): string | undefined;
@@ -150,10 +150,13 @@ export interface CanonicalKernelInstance {
 interface KernelModule {
     CanonicalKernel: new () => CanonicalKernelInstance;
     SignalRouter: new (maxQueueSize: number) => SignalRouterInstance;
-    buildEvalMessages(goal: string, criteria: NativeCriterion[], result: string, attempt: number, extractSkillOnPass: boolean): Message[];
+    buildEvalMessages(goal: string, criteria: NativeCriterion[], result: string, attempt: number, extractSkillOnPass: boolean): ProviderMessage[];
     parseVerdict(content: string): Verdict;
     verdictOutputSchema(extractSkillOnPass: boolean): string;
     verifiableOperationJson(request: string): string;
+    evolutionValidateJson(request: string): string;
+    contextPrepareJson(request: string): string;
+    contextVerifyJson(request: string): string;
 }
 export declare function getKernel(): KernelModule;
 export {};

package/dist/memory/protocols.d.ts

@@ -1,6 +1,6 @@
-import type { Message, ContentPart } from "../types.js";
+import type { ProviderMessage, ContentPart } from "../types.js";
 export interface SessionMessage {
-    role: Message["role"];
+    role: ProviderMessage["role"];
     content: string;
     /** Structured multimodal parts. Preserved for round-trip fidelity (e.g. tool result messages). */
     contentParts?: ContentPart[];

package/dist/providers/anthropic-adapter.d.ts

@@ -1,4 +1,4 @@
-import type { Message, ProviderReplay, ProviderUsage, ToolCall } from "../types.js";
+import type { ProviderMessage, ProviderReplay, ProviderUsage, ToolCall } from "../types.js";
 import type { CanonicalAdapterInput } from "./content-normalization.js";
 import { type AdapterDecodeInput, type AdapterOutput, type AdapterStreamInput, type CanonicalStopReason, type ProtocolAdapter } from "./protocol-adapter.js";
 export declare const ANTHROPIC_TEXTUAL_TOOL_CALL_START_MARKER = "<\uFF5C\uFF5CDSML\uFF5C\uFF5Ctool_calls>";
@@ -47,7 +47,7 @@ export declare class AnthropicMessagesAdapter implements ProtocolAdapter<Anthrop
     readonly protocolCapabilities: import("./protocol-capabilities.js").ProtocolRuntimeCapabilities;
     buildRequest(input: CanonicalAdapterInput): AnthropicRequestPlan;
     decodeComplete(raw: Record<string, any>, decodeInput: AdapterDecodeInput): {
-        message: Message;
+        message: ProviderMessage;
         replay?: ProviderReplay;
     };
     createStreamState(input: AdapterStreamInput): AnthropicStreamState;

package/dist/providers/anthropic.d.ts

@@ -1,4 +1,5 @@
-import type { LLMProvider, Message, PromptMeasurement, ProviderDescriptor, ProviderReplay, ProviderRunState, ProviderTransportTelemetry, RenderedContext, RuntimePolicy, StreamEvent, ToolSchema } from "../types.js";
+import type { PreparedProviderRequest, ProviderRunState as PreparedRunState } from "../types.js";
+import type { LLMProvider, ProviderMessage, PromptMeasurement, ProviderDescriptor, ProviderReplay, ProviderTransportTelemetry, RenderedContext, RuntimePolicy, StreamEvent, ToolSchema } from "../types.js";
 import { type CanonicalAdapterInput } from "./content-normalization.js";
 export interface AnthropicProviderConfig {
     apiKey: string;
@@ -34,14 +35,17 @@ export declare class AnthropicProvider implements LLMProvider {
     private lastTelemetry;
     peekTransportTelemetry(): ProviderTransportTelemetry | undefined;
     bindResolvedRuntime(resolved: ResolvedAnthropicRuntime): void;
-    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;
     private adapterInput;
     private buildPlan;
-    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<ProviderMessage>;
     /** Native measurement belongs to the verified official endpoint, not the wire protocol. */
     countTokens(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<PromptMeasurement>;
-    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, _state?: ProviderRunState, signal?: AbortSignal): AsyncIterable<StreamEvent>;
+    private countPlan;
+    prepareRequest(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: PreparedRunState): PreparedProviderRequest;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: PreparedRunState, signal?: AbortSignal): AsyncIterable<StreamEvent>;
+    private streamPlan;
     private createMessage;
     private streamMessage;
     private buildSystem;

package/dist/providers/anthropic.js

@@ -1,3 +1,4 @@
+import { requestSnapshot } from "./prepared-request.js";
 import Anthropic from "@anthropic-ai/sdk";
 import { assistantReplayKey } from "../runtime/provider-replay.js";
 import { withServerRuntimeGuard } from "../runtime/server.js";
@@ -167,30 +168,44 @@ export class AnthropicProvider {
     }
     /** Native measurement belongs to the verified official endpoint, not the wire protocol. */
     async countTokens(context, tools, extensions) {
+        return this.countPlan(this.buildPlan(context, tools, extensions).plan);
+    }
+    async countPlan(plan) {
         const enabled = this.resolvedRuntime
             ? this.resolvedRuntime.effectiveCapabilities.nativeTokenCounting.state === "supported"
             : this.providerName() === "anthropic" && this.directNativeTokenCounting;
         if (!enabled) {
             throw new Error(`Native token counting is unavailable on ${this.providerName()} Anthropic-compatible endpoint`);
         }
-        const { plan } = this.buildPlan(context, tools, extensions);
         const { model, system, messages, tools: requestTools } = plan.params;
-        const response = await this.client.messages.countTokens({
+        const response = await this.client.messages.countTokens(requestSnapshot({
             model,
             ...(system ? { system } : {}),
             messages,
             ...(requestTools ? { tools: requestTools } : {}),
-        });
+        }));
         return {
             inputTokens: response.input_tokens,
             source: { kind: "native", provider: "anthropic" },
             confidence: "exact",
         };
     }
-    async *stream(context, tools, extensions, _state, signal) {
+    prepareRequest(context, tools, extensions, state) {
+        const { input, plan: built } = this.buildPlan(context, tools, extensions);
+        const plan = requestSnapshot(built);
+        plan.params.stream = true;
+        return {
+            scope: "encoded_body", request: requestSnapshot({ body: plan.params, transport: plan.transport }), state: requestSnapshot(state ?? null),
+            stream: signal => this.streamPlan(input, plan, signal),
+            countTokens: () => this.countPlan(plan),
+        };
+    }
+    async *stream(context, tools, extensions, state, signal) {
+        yield* this.prepareRequest(context, tools, extensions, state).stream(signal);
+    }
+    async *streamPlan(input, plan, signal) {
         const provider = this.providerName();
         try {
-            const { input, plan } = this.buildPlan(context, tools, extensions);
             const state = this.adapter.createStreamState({ input });
             this.lastTelemetry = { rungs: 1 };
             for await (const chunk of this.streamMessage(plan.params, plan.transport, signal)) {

package/dist/providers/base.d.ts

@@ -1,4 +1,4 @@
-import type { Message, RenderedContext } from "../types.js";
+import type { ProviderMessage, RenderedContext } from "../types.js";
 export declare class CircuitBreaker {
     private readonly openAfter;
     private readonly resetAfter;
@@ -53,7 +53,7 @@ export declare class UnsupportedModalityError extends Error {
     readonly provider: string;
     constructor(modality: string, provider: string);
 }
-export declare function toAnthropicContent(msg: Message): string | Array<Record<string, unknown>>;
+export declare function toAnthropicContent(msg: ProviderMessage): string | Array<Record<string, unknown>>;
 /**
  * History turns with the volatile State turn appended as the latest turn, for
  * providers that render it inline (OpenAI-family, Gemini, Ollama). Appending
@@ -64,14 +64,14 @@ export declare function toAnthropicContent(msg: Message): string | Array<Record<
  * AnthropicProvider.buildMessages). When `stateTurn` is absent (un-rebuilt
  * binding) the State turn is still inside `turns`, so this returns `turns` as-is.
  */
-export declare function turnsWithStateAppended(context: RenderedContext): Message[];
+export declare function turnsWithStateAppended(context: RenderedContext): ProviderMessage[];
 /** Convert RenderedContext.turns to Anthropic messages array.
  *  `turns` contains only user / assistant / tool roles — no system filtering needed. */
-export declare function toAnthropicMessages(turns: Message[], nativeReplay?: (message: Message) => Array<Record<string, unknown>> | undefined): Array<Record<string, unknown>>;
+export declare function toAnthropicMessages(turns: ProviderMessage[], nativeReplay?: (message: ProviderMessage) => Array<Record<string, unknown>> | undefined): Array<Record<string, unknown>>;
 /** Map an audio MIME type to OpenAI's `input_audio.format` (accepts "mp3" | "wav").
  *  `audio/mpeg` must become "mp3", not the raw "mpeg" subtype. */
 export declare function openaiAudioFormat(mediaType: string | undefined): string;
-export declare function toOpenAIContent(msg: Message): string | Array<Record<string, unknown>>;
+export declare function toOpenAIContent(msg: ProviderMessage): string | Array<Record<string, unknown>>;
 /** Build the full OpenAI messages array from a RenderedContext.
  *  Prepends systemText as the first system message, then converts turns. */
 export declare function toOpenAIMessageParams(context: RenderedContext): Array<Record<string, unknown>>;

package/dist/providers/content-normalization.d.ts

@@ -1,4 +1,4 @@
-import type { Message, RenderedContext, ToolOutputBlock, ToolResultPart, ToolSchema, ToolCall, ProviderReplay } from "../types.js";
+import type { ProviderMessage, RenderedContext, ToolOutputBlock, ToolResultPart, ToolSchema, ToolCall, ProviderReplay } from "../types.js";
 import type { ResolvedProviderRuntime } from "./model-registry.js";
 export declare class ContentValidationError extends Error {
     constructor(message: string);
@@ -16,7 +16,7 @@ export interface CanonicalToolResult {
 }
 export type CanonicalMessageBlock = ToolOutputBlock | CanonicalToolResult;
 export interface CanonicalMessage {
-    readonly role: Message["role"];
+    readonly role: ProviderMessage["role"];
     readonly blocks: readonly CanonicalMessageBlock[];
     /** `blocks` remains authoritative; this only preserves an observable wire-shape distinction. */
     readonly contentForm?: "text" | "blocks";
@@ -43,7 +43,7 @@ export declare function projectToolOutputToText(blocks: readonly ToolOutputBlock
 export declare function normalizeToolResultPart(part: ToolResultPart): CanonicalToolResult;
 /** Attach process-local blocks only within the operation that produced them. */
 export declare function attachToolOutputOverlay(context: RenderedContext, overlay: ReadonlyMap<string, readonly ToolOutputBlock[]>): RenderedContext;
-export declare function normalizeCanonicalContext(context: RenderedContext, replayForMessage?: (message: Message) => ProviderReplay | undefined): CanonicalRenderedContext;
+export declare function normalizeCanonicalContext(context: RenderedContext, replayForMessage?: (message: ProviderMessage) => ProviderReplay | undefined): CanonicalRenderedContext;
 /** Full-tree validation uses the resolved operation capabilities. Unknown stays unknown/fail-open. */
 export declare function validateCanonicalAdapterInput(input: CanonicalAdapterInput): void;
 export declare function normalizeCanonicalAdapterInput(input: {
@@ -51,6 +51,6 @@ export declare function normalizeCanonicalAdapterInput(input: {
     tools: readonly ToolSchema[];
     resolved: ResolvedProviderRuntime<unknown>;
     extensions?: Readonly<Record<string, unknown>>;
-    replayForMessage?: (message: Message) => ProviderReplay | undefined;
+    replayForMessage?: (message: ProviderMessage) => ProviderReplay | undefined;
 }): CanonicalAdapterInput;
 export declare function normalizeToolResultContent(callId: string, output: string, isError: boolean, contentParts: readonly ToolOutputBlock[] | undefined): CanonicalToolResult;

package/dist/providers/gemini-adapter.d.ts

@@ -1,5 +1,5 @@
 import type { Content, GenerateContentRequest, GenerateContentResponse, ModelParams, Tool } from "@google/generative-ai";
-import type { Message, ProviderUsage } from "../types.js";
+import type { ProviderMessage, ProviderUsage } from "../types.js";
 import type { CanonicalAdapterInput } from "./content-normalization.js";
 import { type AdapterDecodeInput, type AdapterOutput, type AdapterStreamInput, type CanonicalStopReason, type ProtocolAdapter } from "./protocol-adapter.js";
 export interface GeminiRequestPlan {
@@ -23,7 +23,7 @@ export declare class GeminiAdapter implements ProtocolAdapter<GeminiRequestPlan,
     readonly protocolCapabilities: import("./protocol-capabilities.js").ProtocolRuntimeCapabilities;
     buildRequest(input: CanonicalAdapterInput): GeminiRequestPlan;
     decodeComplete(raw: GenerateContentResponse, _input: AdapterDecodeInput): {
-        message: Message;
+        message: ProviderMessage;
     };
     createStreamState(input: AdapterStreamInput): GeminiStreamState;
     pushStreamChunk(chunk: GenerateContentResponse, state: GeminiStreamState): AdapterOutput;

package/dist/providers/gemini.d.ts

@@ -1,8 +1,9 @@
+import type { PreparedProviderRequest, ProviderRunState as PreparedRunState } from "../types.js";
 import { type Content } from "@google/generative-ai";
-import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy, PromptMeasurement, ProviderTransportTelemetry } from "../types.js";
+import type { ProviderMessage, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy, PromptMeasurement, ProviderTransportTelemetry } from "../types.js";
 import { type CanonicalAdapterInput } from "./content-normalization.js";
 type ResolvedGeminiRuntime = CanonicalAdapterInput["resolved"];
-export declare function buildContents(turns: Message[]): Content[];
+export declare function buildContents(turns: ProviderMessage[]): Content[];
 export declare class GeminiProvider implements LLMProvider {
     private readonly model;
     private resolvedRuntime?;
@@ -23,14 +24,17 @@ export declare class GeminiProvider implements LLMProvider {
     runtimePolicy(): RuntimePolicy;
     bindResolvedRuntime(resolved: ResolvedGeminiRuntime): void;
     private adapterInput;
-    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
-    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<ProviderMessage>;
+    prepareRequest(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: PreparedRunState): PreparedProviderRequest;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: PreparedRunState, signal?: AbortSignal): AsyncIterable<StreamEvent>;
+    private streamPlan;
     /**
      * spc_011-C-05: preflight native token count via `GenerativeModel.countTokens` — reuses the
      * same contents/tools/vendorConfig construction `complete()` uses so the counted request and
      * the sent request never diverge.
      */
     countTokens(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<PromptMeasurement>;
+    private countPlan;
     /**
      * Gemini vendor features from extensions, mapped to the Node SDK shape (mirrors the Python provider's
      * extension keys for a consistent cross-SDK API):

package/dist/providers/gemini.js

@@ -1,3 +1,4 @@
+import { requestSnapshot } from "./prepared-request.js";
 import { GoogleGenerativeAI } from "@google/generative-ai";
 import { withServerRuntimeGuard } from "../runtime/server.js";
 import { CircuitBreaker } from "./base.js";
@@ -46,8 +47,8 @@ export class GeminiProvider {
     }
     adapterInput(context, tools, extensions) {
         if (!this.resolvedRuntime) {
-            // Direct class construction is a published compatibility path. A-07 replaces it with
-            // injected runtime profiles; until then this local descriptor contains no Registry lookup.
+            // Direct construction uses a local resolved profile when no registry binding was injected;
+            // this descriptor intentionally performs no Registry lookup.
             const resolved = {
                 identity: {
                     providerId: "gemini",
@@ -112,10 +113,20 @@ export class GeminiProvider {
         }
         throw classifyProviderError("gemini", lastErr);
     }
-    async *stream(context, tools, extensions) {
+    prepareRequest(context, tools, extensions, state) {
+        const input = this.adapterInput(context, tools, extensions);
+        const plan = requestSnapshot(this.adapter.buildRequest(input));
+        return {
+            scope: "encoded_body", request: requestSnapshot(plan), state: requestSnapshot(state ?? null),
+            stream: signal => this.streamPlan(input, plan),
+            countTokens: () => this.countPlan(plan),
+        };
+    }
+    async *stream(context, tools, extensions, state, signal) {
+        yield* this.prepareRequest(context, tools, extensions, state).stream(signal);
+    }
+    async *streamPlan(input, plan) {
         try {
-            const input = this.adapterInput(context, tools, extensions);
-            const plan = this.adapter.buildRequest(input);
             const m = this.genAI.getGenerativeModel(plan.modelParams, this.requestOptions);
             const result = await m.generateContentStream(plan.request);
             const state = this.adapter.createStreamState({ input });
@@ -141,9 +152,11 @@ export class GeminiProvider {
      * the sent request never diverge.
      */
     async countTokens(context, tools, extensions) {
-        const plan = this.adapter.buildRequest(this.adapterInput(context, tools, extensions));
+        return this.countPlan(this.adapter.buildRequest(this.adapterInput(context, tools, extensions)));
+    }
+    async countPlan(plan) {
         const m = this.genAI.getGenerativeModel(plan.modelParams, this.requestOptions);
-        const resp = await m.countTokens(plan.request);
+        const resp = await m.countTokens(requestSnapshot(plan.request));
         return {
             inputTokens: resp.totalTokens,
             source: { kind: "native", provider: "gemini" },

package/dist/providers/ollama-adapter.d.ts

@@ -1,4 +1,4 @@
-import type { Message, ProviderUsage } from "../types.js";
+import type { ProviderMessage, ProviderUsage } from "../types.js";
 import type { CanonicalAdapterInput } from "./content-normalization.js";
 import { type AdapterDecodeInput, type AdapterOutput, type AdapterStreamInput, type CanonicalStopReason, type ProtocolAdapter } from "./protocol-adapter.js";
 export interface OllamaMessage {
@@ -54,7 +54,7 @@ export declare class OllamaAdapter implements ProtocolAdapter<OllamaRequest, Oll
     readonly protocolCapabilities: import("./protocol-capabilities.js").ProtocolRuntimeCapabilities;
     buildRequest(input: CanonicalAdapterInput): OllamaRequest;
     decodeComplete(raw: OllamaChunk, _input: AdapterDecodeInput): {
-        message: Message;
+        message: ProviderMessage;
     };
     createStreamState(input: AdapterStreamInput): OllamaStreamState;
     pushStreamChunk(chunk: OllamaChunk, state: OllamaStreamState): AdapterOutput;

package/dist/providers/ollama.d.ts

@@ -1,4 +1,5 @@
-import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy, ProviderTransportTelemetry } from "../types.js";
+import type { PreparedProviderRequest, ProviderRunState as PreparedRunState } from "../types.js";
+import type { ProviderMessage, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy, ProviderTransportTelemetry } from "../types.js";
 import { type CanonicalAdapterInput } from "./content-normalization.js";
 type ResolvedOllamaRuntime = CanonicalAdapterInput["resolved"];
 export declare class OllamaProvider implements LLMProvider {
@@ -14,7 +15,9 @@ export declare class OllamaProvider implements LLMProvider {
     runtimePolicy(): RuntimePolicy;
     bindResolvedRuntime(resolved: ResolvedOllamaRuntime): void;
     private adapterInput;
-    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
-    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<ProviderMessage>;
+    prepareRequest(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: PreparedRunState): PreparedProviderRequest;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: PreparedRunState, signal?: AbortSignal): AsyncIterable<StreamEvent>;
+    private streamPlan;
 }
 export {};

package/dist/providers/ollama.js

@@ -1,3 +1,4 @@
+import { requestSnapshot } from "./prepared-request.js";
 import { normalizeCanonicalAdapterInput, } from "./content-normalization.js";
 import { endpointProfiles } from "./endpoints.js";
 import { OllamaAdapter } from "./ollama-adapter.js";
@@ -73,10 +74,20 @@ export class OllamaProvider {
             throw classifyProviderError("ollama", error);
         }
     }
-    async *stream(context, tools, extensions) {
+    prepareRequest(context, tools, extensions, state) {
+        const input = this.adapterInput(context, tools, extensions);
+        const plan = requestSnapshot({ ...this.adapter.buildRequest(input), stream: true });
+        return {
+            scope: "encoded_body", request: requestSnapshot(plan), state: requestSnapshot(state ?? null),
+            stream: signal => this.streamPlan(input, plan),
+        };
+    }
+    async *stream(context, tools, extensions, state, signal) {
+        yield* this.prepareRequest(context, tools, extensions, state).stream(signal);
+    }
+    async *streamPlan(input, plan) {
         try {
-            const input = this.adapterInput(context, tools, extensions);
-            const body = { ...this.adapter.buildRequest(input), stream: true };
+            const body = plan;
             this.lastTelemetry = { rungs: 1 };
             const resp = await fetch(`${this.baseUrl}/api/chat`, {
                 method: "POST",

package/dist/providers/openai-chat.d.ts

@@ -1,5 +1,5 @@
 import type OpenAI from "openai";
-import type { Message, ProviderDescriptor, ProviderReplay, ProviderUsage, RenderedContext, ToolCall, ToolSchema } from "../types.js";
+import type { ProviderMessage, ProviderDescriptor, ProviderReplay, ProviderUsage, RenderedContext, ToolCall, ToolSchema } from "../types.js";
 import { ThinkingTagStreamExtractor } from "./base.js";
 import type { CanonicalAdapterInput } from "./content-normalization.js";
 import { type ReplayabilityAssessment } from "./replay-validator.js";
@@ -41,7 +41,7 @@ export declare class OpenAIChatAdapter implements ProtocolAdapter<OpenAIChatRequ
     readonly protocolCapabilities: import("./protocol-capabilities.js").ProtocolRuntimeCapabilities;
     buildRequest(input: CanonicalAdapterInput, dialect?: OpenAIChatWireDialect): OpenAIChatRequestPlan;
     decodeComplete(raw: Record<string, any>, input: AdapterDecodeInput, dialect?: OpenAIChatWireDialect): {
-        message: Message;
+        message: ProviderMessage;
         replay?: ProviderReplay;
     };
     createStreamState(input: AdapterStreamInput, dialect?: OpenAIChatWireDialect): OpenAIChatStreamState;
@@ -60,6 +60,6 @@ export declare class OpenAIChatAdapter implements ProtocolAdapter<OpenAIChatRequ
     buildMessages(context: RenderedContext, options?: OpenAIChatBuildMessageOptions): OpenAI.ChatCompletionMessageParam[];
     assessReasoning(context: RenderedContext): ReplayabilityAssessment;
     normalizeToolCalls(toolCalls?: OpenAI.ChatCompletionMessageToolCall[]): ToolCall[];
-    rememberReplayFields(message: Pick<Message, "content" | "toolCalls">, fields: Record<string, unknown>): void;
-    peekReplayFields(message: Pick<Message, "content" | "toolCalls">): Record<string, unknown> | undefined;
+    rememberReplayFields(message: Pick<ProviderMessage, "content" | "toolCalls">, fields: Record<string, unknown>): void;
+    peekReplayFields(message: Pick<ProviderMessage, "content" | "toolCalls">): Record<string, unknown> | undefined;
 }

package/dist/providers/openai-responses-adapter.d.ts

@@ -1,4 +1,4 @@
-import type { Message, ProviderUsage, RenderedContext, ToolCall, ToolSchema } from "../types.js";
+import type { ProviderMessage, ProviderUsage, RenderedContext, ToolCall, ToolSchema } from "../types.js";
 import type { CanonicalAdapterInput } from "./content-normalization.js";
 import { type AdapterDecodeInput, type AdapterOutput, type AdapterStreamInput, type CanonicalStopReason, type ProtocolAdapter } from "./protocol-adapter.js";
 export interface OpenAIResponsesRunState {
@@ -23,7 +23,7 @@ export declare class OpenAIResponsesAdapter implements ProtocolAdapter<OpenAIRes
     readonly protocolCapabilities: import("./protocol-capabilities.js").ProtocolRuntimeCapabilities;
     buildRequest(input: CanonicalAdapterInput, state?: OpenAIResponsesRunState): OpenAIResponsesRequestPlan;
     decodeComplete(raw: Record<string, any>, _input: AdapterDecodeInput): {
-        message: Message;
+        message: ProviderMessage;
     };
     createStreamState(input: AdapterStreamInput, _state?: OpenAIResponsesRunState): OpenAIResponsesStreamState;
     pushStreamChunk(chunk: OpenAIResponsesStreamChunk, state: OpenAIResponsesStreamState): AdapterOutput;

package/dist/providers/openai-responses-adapter.js

@@ -312,7 +312,7 @@ export class OpenAIResponsesAdapter {
             return "content_filter";
         return "other";
     }
-    // Published compatibility helpers retained while internally routing through canonical input.
+    // Framework adapter primitives used by the canonical request path.
     buildTools(tools) {
         return tools.map(tool => ({
             type: "function",

package/dist/providers/openai-responses.d.ts

@@ -1,5 +1,6 @@
+import type { PreparedProviderRequest, ProviderRunState as PreparedRunState } from "../types.js";
 import OpenAI from "openai";
-import type { LLMProvider, Message, PromptMeasurement, ProviderRunState, ProviderTransportTelemetry, RenderedContext, RuntimePolicy, StreamEvent, ToolSchema } from "../types.js";
+import type { LLMProvider, ProviderMessage, PromptMeasurement, ProviderRunState, ProviderTransportTelemetry, RenderedContext, RuntimePolicy, StreamEvent, ToolSchema } from "../types.js";
 import { CircuitBreaker } from "./base.js";
 import { type CanonicalAdapterInput } from "./content-normalization.js";
 import { OpenAIResponsesAdapter, type OpenAIResponsesRunState } from "./openai-responses-adapter.js";
@@ -24,12 +25,15 @@ export declare class OpenAIResponsesProvider implements LLMProvider {
     bindResolvedRuntime(resolved: ResolvedOpenAIResponsesRuntime): void;
     createRunState(): OpenAIResponsesRunState;
     private adapterInput;
-    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<ProviderMessage>;
     /** spc_024-05: native preflight via the official Responses input-token count endpoint. Counts
      * the exact create request plan (stateful `previous_response_id` continuation included) —
      * native measurement belongs to the verified official endpoint, not the wire protocol. */
     countTokens(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState): Promise<PromptMeasurement>;
-    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState, signal?: AbortSignal): AsyncIterable<StreamEvent>;
+    private countPlan;
+    prepareRequest(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: PreparedRunState): PreparedProviderRequest;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: PreparedRunState, signal?: AbortSignal): AsyncIterable<StreamEvent>;
+    private streamPlan;
     private builtinTools;
     private requestExtensions;
     /** P4-S1: transport facts of the most recent execution. Host evidence only (B7). */

package/dist/providers/openai-responses.js

@@ -1,3 +1,4 @@
+import { requestSnapshot } from "./prepared-request.js";
 import OpenAI from "openai";
 import { withServerRuntimeGuard } from "../runtime/server.js";
 import { CircuitBreaker } from "./base.js";
@@ -108,6 +109,9 @@ export class OpenAIResponsesProvider {
      * the exact create request plan (stateful `previous_response_id` continuation included) —
      * native measurement belongs to the verified official endpoint, not the wire protocol. */
     async countTokens(context, tools, extensions, state) {
+        return this.countPlan(this.responses.buildRequest(this.adapterInput(context, tools, extensions), this.asRunState(state)));
+    }
+    async countPlan(plan) {
         const enabled = this.resolvedRuntime
             ? this.resolvedRuntime.effectiveCapabilities.nativeTokenCounting.state === "supported"
             : this.directNativeTokenCounting;
@@ -115,23 +119,32 @@ export class OpenAIResponsesProvider {
         if (!enabled || typeof inputTokens?.count !== "function") {
             throw new Error("Native token counting is unavailable on this OpenAI-compatible endpoint");
         }
-        const input = this.adapterInput(context, tools, extensions);
-        const plan = this.responses.buildRequest(input, this.asRunState(state));
         const body = Object.fromEntries(INPUT_TOKEN_COUNT_PARAM_KEYS
             .filter(key => key in plan.params)
             .map(key => [key, plan.params[key]]));
-        const response = await inputTokens.count(body);
+        const response = await inputTokens.count(requestSnapshot(body));
         return {
             inputTokens: response.input_tokens,
             source: { kind: "native", provider: "openai" },
             confidence: "exact",
         };
     }
+    prepareRequest(context, tools, extensions, state) {
+        const runState = requestSnapshot(this.asRunState(state));
+        const input = this.adapterInput(context, tools, extensions);
+        const plan = requestSnapshot(this.responses.buildRequest(input, runState));
+        plan.params.stream = true;
+        return {
+            scope: "encoded_body", request: requestSnapshot(plan.params), state: requestSnapshot(state ?? null),
+            stream: signal => this.streamPlan(input, plan, runState, state, signal),
+            countTokens: () => this.countPlan(plan),
+        };
+    }
     async *stream(context, tools, extensions, state, signal) {
+        yield* this.prepareRequest(context, tools, extensions, state).stream(signal);
+    }
+    async *streamPlan(input, plan, runState, state, signal) {
         try {
-            const runState = this.asRunState(state);
-            const input = this.adapterInput(context, tools, extensions);
-            const plan = this.responses.buildRequest(input, runState);
             const streamState = this.responses.createStreamState({ input }, runState);
             const stream = await this.client.responses.create({ ...plan.params, stream: true }, signal ? { signal } : undefined);
             this.lastTelemetry = { rungs: 1 };

package/dist/providers/openai.d.ts

@@ -1,5 +1,6 @@
+import type { PreparedProviderRequest, ProviderRunState as PreparedRunState } from "../types.js";
 import OpenAI from "openai";
-import type { LLMProvider, Message, ProviderDescriptor, ProviderReplay, ProviderRunState, ProviderTransportTelemetry, RenderedContext, ReplayabilityAssessment, RuntimePolicy, StreamEvent, ToolSchema } from "../types.js";
+import type { LLMProvider, ProviderMessage, ProviderDescriptor, ProviderReplay, ProviderTransportTelemetry, RenderedContext, ReplayabilityAssessment, RuntimePolicy, StreamEvent, ToolSchema } from "../types.js";
 import { CircuitBreaker } from "./base.js";
 import { type CanonicalAdapterInput } from "./content-normalization.js";
 import { OpenAIChatAdapter } from "./openai-chat.js";
@@ -38,12 +39,14 @@ export declare class OpenAIChatProvider implements LLMProvider {
     /** P4-S1: transport facts of the most recent execution. Host evidence only (B7). */
     private lastTelemetry;
     peekTransportTelemetry(): ProviderTransportTelemetry | undefined;
-    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;
     private rememberReplay;
     private adapterInput;
-    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
-    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, _state?: ProviderRunState, signal?: AbortSignal): AsyncIterable<StreamEvent>;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<ProviderMessage>;
+    prepareRequest(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: PreparedRunState): PreparedProviderRequest;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: PreparedRunState, signal?: AbortSignal): AsyncIterable<StreamEvent>;
+    private streamPlan;
     protected prepareExtensions(extensions?: Record<string, unknown>): Record<string, unknown>;
     protected requestBodyExtras(extensions?: Record<string, unknown>): Record<string, unknown>;
     protected serverTools(extensions?: Record<string, unknown>): unknown[];

package/dist/providers/openai.js

@@ -1,3 +1,4 @@
+import { requestSnapshot } from "./prepared-request.js";
 import OpenAI from "openai";
 import { assistantReplayKey } from "../runtime/provider-replay.js";
 import { withServerRuntimeGuard } from "../runtime/server.js";
@@ -164,11 +165,21 @@ export class OpenAIChatProvider {
         }
         throw classifyProviderError(provider, lastError);
     }
-    async *stream(context, tools, extensions, _state, signal) {
+    prepareRequest(context, tools, extensions, state) {
+        const input = this.adapterInput(context, tools, extensions);
+        const plan = requestSnapshot(this.chat.buildRequest(input, this.dialect));
+        Object.assign(plan.params, { stream: true, stream_options: { include_usage: true } });
+        return {
+            scope: "encoded_body", request: requestSnapshot(plan.params), state: requestSnapshot(state ?? null),
+            stream: signal => this.streamPlan(input, plan, signal),
+        };
+    }
+    async *stream(context, tools, extensions, state, signal) {
+        yield* this.prepareRequest(context, tools, extensions, state).stream(signal);
+    }
+    async *streamPlan(input, plan, signal) {
         const provider = this.dialect.providerId;
         try {
-            const input = this.adapterInput(context, tools, extensions);
-            const plan = this.chat.buildRequest(input, this.dialect);
             const state = this.chat.createStreamState({ input }, this.dialect);
             const stream = await this.client.chat.completions.create({
                 ...plan.params,

package/dist/providers/prepared-request.d.ts

@@ -0,0 +1,4 @@
+import type { LLMProvider, PreparedProviderRequest, ProviderRunState, RenderedContext, ToolSchema } from "../types.js";
+/** JSON value snapshots sever aliases to mutable provider replay and continuation state. */
+export declare function requestSnapshot<T>(value: T): T;
+export declare function prepareProviderRequest(provider: LLMProvider, context: RenderedContext, tools: ToolSchema[], options?: Record<string, unknown>, state?: ProviderRunState): PreparedProviderRequest;