@deepstrike/sdk 0.2.70 → 0.2.72

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

@@ -1,4 +1,4 @@
-import type { ProviderMessage, RenderedContext, ToolOutputBlock, ToolResultPart, ToolSchema, ToolCall, ProviderReplay } from "../types.js";
+import type { ModelMessage, 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: ProviderMessage["role"];
+    readonly role: ModelMessage["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: ProviderMessage) => ProviderReplay | undefined): CanonicalRenderedContext;
+export declare function normalizeCanonicalContext(context: RenderedContext, replayForMessage?: (message: ModelMessage) => 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: ProviderMessage) => ProviderReplay | undefined;
+    replayForMessage?: (message: ModelMessage) => 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 { ProviderMessage, ProviderUsage } from "../types.js";
+import type { ModelMessage, 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: ProviderMessage;
+        message: ModelMessage;
     };
     createStreamState(input: AdapterStreamInput): GeminiStreamState;
     pushStreamChunk(chunk: GenerateContentResponse, state: GeminiStreamState): AdapterOutput;

package/dist/providers/gemini.d.ts

@@ -1,9 +1,9 @@
 import type { PreparedProviderRequest, ProviderRunState as PreparedRunState } from "../types.js";
 import { type Content } from "@google/generative-ai";
-import type { ProviderMessage, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy, PromptMeasurement, ProviderTransportTelemetry } from "../types.js";
+import type { ModelMessage, 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: ProviderMessage[]): Content[];
+export declare function buildContents(turns: ModelMessage[]): Content[];
 export declare class GeminiProvider implements LLMProvider {
     private readonly model;
     private resolvedRuntime?;
@@ -24,7 +24,7 @@ export declare class GeminiProvider implements LLMProvider {
     runtimePolicy(): RuntimePolicy;
     bindResolvedRuntime(resolved: ResolvedGeminiRuntime): void;
     private adapterInput;
-    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<ProviderMessage>;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<ModelMessage>;
     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;

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

@@ -1,4 +1,4 @@
-import type { ProviderMessage, ProviderUsage } from "../types.js";
+import type { ModelMessage, 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: ProviderMessage;
+        message: ModelMessage;
     };
     createStreamState(input: AdapterStreamInput): OllamaStreamState;
     pushStreamChunk(chunk: OllamaChunk, state: OllamaStreamState): AdapterOutput;

package/dist/providers/ollama.d.ts

@@ -1,5 +1,5 @@
 import type { PreparedProviderRequest, ProviderRunState as PreparedRunState } from "../types.js";
-import type { ProviderMessage, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy, ProviderTransportTelemetry } from "../types.js";
+import type { ModelMessage, 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 {
@@ -15,7 +15,7 @@ export declare class OllamaProvider implements LLMProvider {
     runtimePolicy(): RuntimePolicy;
     bindResolvedRuntime(resolved: ResolvedOllamaRuntime): void;
     private adapterInput;
-    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<ProviderMessage>;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<ModelMessage>;
     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;

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

@@ -1,5 +1,5 @@
 import type OpenAI from "openai";
-import type { ProviderMessage, ProviderDescriptor, ProviderReplay, ProviderUsage, RenderedContext, ToolCall, ToolSchema } from "../types.js";
+import type { ModelMessage, 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: ProviderMessage;
+        message: ModelMessage;
         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<ProviderMessage, "content" | "toolCalls">, fields: Record<string, unknown>): void;
-    peekReplayFields(message: Pick<ProviderMessage, "content" | "toolCalls">): Record<string, unknown> | undefined;
+    rememberReplayFields(message: Pick<ModelMessage, "content" | "toolCalls">, fields: Record<string, unknown>): void;
+    peekReplayFields(message: Pick<ModelMessage, "content" | "toolCalls">): Record<string, unknown> | undefined;
 }

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

@@ -1,4 +1,4 @@
-import type { ProviderMessage, ProviderUsage, RenderedContext, ToolCall, ToolSchema } from "../types.js";
+import type { ModelMessage, 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: ProviderMessage;
+        message: ModelMessage;
     };
     createStreamState(input: AdapterStreamInput, _state?: OpenAIResponsesRunState): OpenAIResponsesStreamState;
     pushStreamChunk(chunk: OpenAIResponsesStreamChunk, state: OpenAIResponsesStreamState): AdapterOutput;

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

@@ -1,6 +1,6 @@
 import type { PreparedProviderRequest, ProviderRunState as PreparedRunState } from "../types.js";
 import OpenAI from "openai";
-import type { LLMProvider, ProviderMessage, PromptMeasurement, ProviderRunState, ProviderTransportTelemetry, RenderedContext, RuntimePolicy, StreamEvent, ToolSchema } from "../types.js";
+import type { LLMProvider, ModelMessage, 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";
@@ -25,7 +25,7 @@ export declare class OpenAIResponsesProvider implements LLMProvider {
     bindResolvedRuntime(resolved: ResolvedOpenAIResponsesRuntime): void;
     createRunState(): OpenAIResponsesRunState;
     private adapterInput;
-    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<ProviderMessage>;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<ModelMessage>;
     /** 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. */

package/dist/providers/openai.d.ts

@@ -1,6 +1,6 @@
 import type { PreparedProviderRequest, ProviderRunState as PreparedRunState } from "../types.js";
 import OpenAI from "openai";
-import type { LLMProvider, ProviderMessage, ProviderDescriptor, ProviderReplay, ProviderTransportTelemetry, RenderedContext, ReplayabilityAssessment, RuntimePolicy, StreamEvent, ToolSchema } from "../types.js";
+import type { LLMProvider, ModelMessage, 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";
@@ -39,11 +39,11 @@ 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<ProviderMessage, "content" | "toolCalls">): ProviderReplay | undefined;
-    seedProviderReplay(message: Pick<ProviderMessage, "content" | "toolCalls">, replay: ProviderReplay): void;
+    peekProviderReplay(message: Pick<ModelMessage, "content" | "toolCalls">): ProviderReplay | undefined;
+    seedProviderReplay(message: Pick<ModelMessage, "content" | "toolCalls">, replay: ProviderReplay): void;
     private rememberReplay;
     private adapterInput;
-    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<ProviderMessage>;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<ModelMessage>;
     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;

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

@@ -1,4 +1,4 @@
-import type { ProviderMessage, ProviderReplay, ProviderRunState, ProviderUsage, StreamEvent } from "../types.js";
+import type { ModelMessage, ProviderReplay, ProviderRunState, ProviderUsage, StreamEvent } from "../types.js";
 import type { CanonicalAdapterInput } from "./content-normalization.js";
 import type { GenerationProtocol, ProtocolRuntimeCapabilities } from "./protocol-capabilities.js";
 export { GEMINI_PROTOCOL_CAPABILITIES, OLLAMA_PROTOCOL_CAPABILITIES, } from "./protocol-capabilities.js";
@@ -19,7 +19,7 @@ export interface ProtocolAdapter<TRequest, TCompleteResponse, TStreamChunk, TStr
     readonly protocolCapabilities: ProtocolRuntimeCapabilities;
     buildRequest(input: CanonicalAdapterInput): TRequest;
     decodeComplete(raw: TCompleteResponse, input: AdapterDecodeInput): {
-        message: ProviderMessage;
+        message: ModelMessage;
         replay?: ProviderReplay;
     };
     createStreamState(input: AdapterStreamInput): TStreamState;

package/dist/providers/protocol-capabilities.d.ts

@@ -1,6 +1,7 @@
 export type InputModality = "text" | "image" | "audio" | "video" | "file";
 export type OutputModality = "text" | "image" | "audio" | "embedding";
 export type GenerationProtocol = "anthropic-messages" | "openai-chat" | "openai-responses" | "gemini" | "ollama-chat";
+export declare const GENERATION_PROTOCOLS: readonly GenerationProtocol[];
 export interface ProtocolRuntimeCapabilities {
     acceptedInputModalities: readonly InputModality[];
     emittedOutputModalities: readonly OutputModality[];

package/dist/providers/protocol-capabilities.js

@@ -1,3 +1,6 @@
+export const GENERATION_PROTOCOLS = [
+    "anthropic-messages", "openai-chat", "openai-responses", "gemini", "ollama-chat",
+];
 export const ANTHROPIC_PROTOCOL_CAPABILITIES = {
     acceptedInputModalities: ["text", "image"],
     emittedOutputModalities: ["text"],

package/dist/providers/public.d.ts

@@ -20,8 +20,10 @@ export { ContentPolicyError, contentDispositionFor } from "./content-policy.js";
 export type { ContentDisposition, ContentPlacement } from "./content-policy.js";
 export { CapabilityRouter } from "./capability-router.js";
 export type { CapabilityRequirement, CapabilityRouteResult } from "./capability-router.js";
-export { createProviderRequestPlan, createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, normalizeProviderUsage, priceProviderUsage, recordPromptMeasurement } from "./request-plan.js";
-export type { CostObservation, NormalizedProviderUsage, PricingSnapshot, ProviderRequestEndpoint, ProviderRequestPlan, RecordedPromptMeasurement } from "./request-plan.js";
+export { createProviderRequestPlan, createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, normalizeProviderUsage, priceProviderUsage, recordPromptMeasurement, resolveProviderRoute } from "./request-plan.js";
+export type { CostObservation, NormalizedProviderUsage, PricingSnapshot, ProviderRequestEndpoint, ProviderRequestPlan, RecordedPromptMeasurement, ResolvedProviderRoute } from "./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 { CredentialResolutionError, OAuthCredentialResolver, redactCredential, resolveCredential } from "./credentials.js";
 export type { CredentialOptions, CredentialRequest, CredentialResolver, OAuthAccessToken, OAuthCredentialResolverOptions, OAuthRefreshRequest, ProviderCredential, } from "./credentials.js";
 export { DynamicModelCatalog, StaticModelCatalog } from "./model-catalog.js";

package/dist/providers/public.js

@@ -16,7 +16,8 @@ export { ProviderError, classifyProviderError, } from "./provider-error.js";
 export { endpointProfiles } from "./endpoints.js";
 export { ContentPolicyError, contentDispositionFor } from "./content-policy.js";
 export { CapabilityRouter } from "./capability-router.js";
-export { createProviderRequestPlan, createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, normalizeProviderUsage, priceProviderUsage, recordPromptMeasurement } from "./request-plan.js";
+export { createProviderRequestPlan, createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, normalizeProviderUsage, priceProviderUsage, recordPromptMeasurement, resolveProviderRoute } from "./request-plan.js";
+export { FULL_FOOTPRINT_USAGE_ACCOUNTING_POLICY, providerAttemptToRecord } from "../runtime/execution-evidence.js";
 export { CredentialResolutionError, OAuthCredentialResolver, redactCredential, resolveCredential } from "./credentials.js";
 export { DynamicModelCatalog, StaticModelCatalog } from "./model-catalog.js";
 export { modelRegistry, resolveEffectiveCapability } from "./model-registry.js";

package/dist/providers/replay-validator.d.ts

@@ -1,4 +1,4 @@
-import type { ProviderMessage, ProviderDescriptor, ProviderReplay, RenderedContext, ReplayabilityAssessment } from "../types.js";
+import type { ModelMessage, ProviderDescriptor, ProviderReplay, RenderedContext, ReplayabilityAssessment } from "../types.js";
 export type { ReplayabilityAssessment };
 export declare class ProviderReplayValidationError extends Error {
     constructor(message: string);
@@ -20,7 +20,7 @@ export interface OpenAIChatReplayValidationOptions {
      * rather than fail outright.
      */
     degradeMissingReasoning?: boolean;
-    replayForAssistant?: (message: Pick<ProviderMessage, "content" | "toolCalls">) => ProviderReplay | Record<string, unknown> | undefined;
+    replayForAssistant?: (message: Pick<ModelMessage, "content" | "toolCalls">) => ProviderReplay | Record<string, unknown> | undefined;
 }
 export declare function validateOpenAIChatReplay(context: RenderedContext, options?: OpenAIChatReplayValidationOptions): void;
 /**
@@ -29,4 +29,4 @@ export declare function validateOpenAIChatReplay(context: RenderedContext, optio
  * embedder decide per-candidate whether to keep thinking on, disable it, or
  * skip the candidate — before sending.
  */
-export declare function assessReasoningReplay(turns: ProviderMessage[], options: Pick<OpenAIChatReplayValidationOptions, "replayForAssistant">): ReplayabilityAssessment;
+export declare function assessReasoningReplay(turns: ModelMessage[], options: Pick<OpenAIChatReplayValidationOptions, "replayForAssistant">): ReplayabilityAssessment;

package/dist/runtime/archive.d.ts

@@ -1,15 +1,15 @@
-import type { ProviderMessage } from "../types.js";
+import type { ModelMessage } from "../types.js";
 export interface ArchiveStore {
-    write(sessionId: string, seq: number, messages: ProviderMessage[]): Promise<string>;
-    read(archiveRef: string): Promise<ProviderMessage[]>;
+    write(sessionId: string, seq: number, messages: ModelMessage[]): Promise<string>;
+    read(archiveRef: string): Promise<ModelMessage[]>;
 }
 export declare class NullArchiveStore implements ArchiveStore {
-    write(_sessionId: string, _seq: number, _messages: ProviderMessage[]): Promise<string>;
-    read(_archiveRef: string): Promise<ProviderMessage[]>;
+    write(_sessionId: string, _seq: number, _messages: ModelMessage[]): Promise<string>;
+    read(_archiveRef: string): Promise<ModelMessage[]>;
 }
 export declare class FileArchiveStore implements ArchiveStore {
     private readonly root;
     constructor(root: string);
-    write(sessionId: string, seq: number, messages: ProviderMessage[]): Promise<string>;
-    read(archiveRef: string): Promise<ProviderMessage[]>;
+    write(sessionId: string, seq: number, messages: ModelMessage[]): Promise<string>;
+    read(archiveRef: string): Promise<ModelMessage[]>;
 }

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

@@ -1,5 +1,5 @@
 import type { CanonicalKernelInstance, CanonicalRestoreCost } from "../kernel.js";
-import type { ProviderMessage } from "../types.js";
+import type { ModelMessage } from "../types.js";
 import { type InstalledCheckpoint, type KernelJournal } from "./kernel-journal.js";
 import { type KernelObservation, type KernelRunnerAction } from "./kernel-step.js";
 export declare const MAX_CHAIN_POSITION = 1000000000000;
@@ -120,7 +120,7 @@ export declare class CanonicalRunnerRuntime {
     isTerminal(): boolean;
     recoveryContentBytes(): number;
     preservedRefs(): string[];
-    drainNewMessages(): ProviderMessage[];
+    drainNewMessages(): ModelMessage[];
     drainHostObservations(): KernelObservationLike[];
     terminal(): Record<string, unknown> | undefined;
     localSubagentsSpawned(): number;

package/dist/runtime/context-manager.d.ts

@@ -0,0 +1,56 @@
+export type ContextItemKind = "core" | "task" | "skill" | "memory" | "knowledge" | "workflow";
+export type ContextItemScope = "run" | "session" | "step" | "turn";
+export interface ContextItem {
+    id: string;
+    kind: ContextItemKind;
+    content: string;
+    scope: ContextItemScope;
+    priority: number;
+    tokenCost?: number;
+    confidence?: number;
+    expiresAt?: number;
+    pinned?: boolean;
+    source: {
+        type: string;
+        id?: string;
+    };
+}
+export interface ContextManagerOptions {
+    maxTokens: number;
+    responseReserveTokens?: number;
+    now?: () => number;
+    onEvent?: (event: ContextLedgerEvent) => void;
+}
+export type ContextLedgerEventKind = "context_added" | "context_removed" | "context_expired" | "context_selected";
+export interface ContextLedgerEvent {
+    kind: ContextLedgerEventKind;
+    itemId?: string;
+    source?: ContextItem["source"];
+    fingerprint: string;
+    at: number;
+}
+export interface ContextSnapshot {
+    items: ContextItem[];
+    selected: ContextItem[];
+    usedTokens: number;
+    availableTokens: number;
+    fingerprint: string;
+}
+export declare function estimateContextTokens(content: string): number;
+/** Host-side context budget and lifecycle manager. Kernel context remains the execution authority. */
+export declare class ContextManager {
+    private readonly items;
+    private readonly now;
+    private readonly budget;
+    private readonly onEvent?;
+    constructor(options: ContextManagerOptions);
+    upsert(item: ContextItem): void;
+    remove(id: string): void;
+    expire(now?: number): string[];
+    select(now?: number): ContextItem[];
+    snapshot(now?: number): ContextSnapshot;
+    fingerprint(now?: number): string;
+    private selectWithoutEvents;
+    private emit;
+    private fingerprintOf;
+}

package/dist/runtime/context-manager.js

@@ -0,0 +1,112 @@
+import { createHash } from "node:crypto";
+export function estimateContextTokens(content) {
+    return Math.max(1, Math.ceil(content.length / 4));
+}
+/** Host-side context budget and lifecycle manager. Kernel context remains the execution authority. */
+export class ContextManager {
+    items = new Map();
+    now;
+    budget;
+    onEvent;
+    constructor(options) {
+        if (!Number.isSafeInteger(options.maxTokens) || options.maxTokens < 1)
+            throw new RangeError("maxTokens must be a safe integer >= 1");
+        const reserve = options.responseReserveTokens ?? 0;
+        if (!Number.isSafeInteger(reserve) || reserve < 0 || reserve >= options.maxTokens)
+            throw new RangeError("responseReserveTokens must be >= 0 and lower than maxTokens");
+        this.budget = options.maxTokens - reserve;
+        this.now = options.now ?? Date.now;
+        this.onEvent = options.onEvent;
+    }
+    upsert(item) {
+        const tokenCost = item.tokenCost ?? estimateContextTokens(item.content);
+        if (!Number.isSafeInteger(tokenCost) || tokenCost < 1)
+            throw new RangeError(`context item "${item.id}" has invalid tokenCost`);
+        this.items.set(item.id, { ...item, tokenCost });
+        this.emit({ kind: "context_added", itemId: item.id, source: item.source });
+    }
+    remove(id) {
+        const item = this.items.get(id);
+        if (!item)
+            return;
+        this.items.delete(id);
+        this.emit({ kind: "context_removed", itemId: id, source: item.source });
+    }
+    expire(now = this.now()) {
+        const removed = [];
+        for (const [id, item] of this.items) {
+            if (item.expiresAt !== undefined && item.expiresAt <= now && !item.pinned) {
+                this.items.delete(id);
+                removed.push(id);
+                this.emit({ kind: "context_expired", itemId: id, source: item.source });
+            }
+        }
+        return removed;
+    }
+    select(now = this.now()) {
+        this.expire(now);
+        const selected = this.selectWithoutEvents();
+        this.emit({ kind: "context_selected" });
+        return selected;
+    }
+    snapshot(now = this.now()) {
+        this.expire(now);
+        const items = [...this.items.values()];
+        const selected = this.select(now);
+        const usedTokens = selected.reduce((sum, item) => sum + (item.tokenCost ?? estimateContextTokens(item.content)), 0);
+        return {
+            items,
+            selected,
+            usedTokens,
+            availableTokens: Math.max(0, this.budget - usedTokens),
+            fingerprint: this.fingerprint(now),
+        };
+    }
+    fingerprint(now = this.now()) {
+        this.expire(now);
+        return this.fingerprintOf(this.selectWithoutEvents());
+    }
+    selectWithoutEvents() {
+        const candidates = [...this.items.values()].sort((left, right) => Number(Boolean(right.pinned)) - Number(Boolean(left.pinned))
+            || right.priority - left.priority
+            || (right.confidence ?? 0) - (left.confidence ?? 0)
+            || left.id.localeCompare(right.id));
+        const selected = [];
+        let usedTokens = 0;
+        for (const item of candidates) {
+            const cost = item.tokenCost ?? estimateContextTokens(item.content);
+            if (usedTokens + cost > this.budget && !item.pinned)
+                continue;
+            selected.push(item);
+            usedTokens += cost;
+        }
+        return selected;
+    }
+    emit(event) {
+        try {
+            this.onEvent?.({ ...event, fingerprint: this.fingerprintOf(this.selectWithoutEvents()), at: this.now() });
+        }
+        catch {
+            // Ledger observers are diagnostic only; a faulty sink must never reject context admission.
+        }
+    }
+    fingerprintOf(selected) {
+        const hash = createHash("sha256");
+        for (const item of selected) {
+            hash.update(JSON.stringify({
+                id: item.id,
+                kind: item.kind,
+                content: item.content,
+                scope: item.scope,
+                priority: item.priority,
+                tokenCost: item.tokenCost ?? estimateContextTokens(item.content),
+                confidence: item.confidence ?? null,
+                expiresAt: item.expiresAt ?? null,
+                pinned: Boolean(item.pinned),
+                source: { type: item.source.type, id: item.source.id ?? null },
+            }));
+            hash.update("\n");
+        }
+        return `ctx-${hash.digest("hex")}`;
+    }
+}

package/dist/runtime/eval.d.ts

@@ -9,7 +9,7 @@
  * The judge is a single LLM call: build the eval prompt → stream → parse verdict. No retry loop,
  * no skill extraction, no loop state. Use `AttemptLoop` if you want the retry/refine flow.
  */
-import type { LLMProvider, ProviderMessage } from "../types.js";
+import type { LLMProvider, ModelMessage } from "../types.js";
 export interface Criterion {
     /** The criterion text the judge evaluates against. */
     text: string;
@@ -52,7 +52,7 @@ export interface JudgeArgs {
  * Exposed in case a caller wants to render the prompt without calling the LLM (e.g., dry-run cost
  * estimation, fixture generation). For the common case, use `judge()`.
  */
-export declare function buildEvalMessages(goal: string, criteria: Criterion[], result: string): ProviderMessage[];
+export declare function buildEvalMessages(goal: string, criteria: Criterion[], result: string): ModelMessage[];
 /** Parse a Verdict from raw judge-LLM text. Throws on schema mismatch. */
 export declare function parseVerdict(text: string): Verdict;
 /** The JSON Schema the kernel expects judge output to conform to. */

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

@@ -1,4 +1,4 @@
-import type { EntropySample, ProviderMessage, RenderedContext, TaskUpdate, ToolCall, ToolExecutionResult, ToolSchema } from "../types.js";
+import type { EntropySample, ModelMessage, 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?: ProviderMessage;
+    finalMessage?: ModelMessage;
     /** ③ loop-agent: the kernel-adjudicated after-round decision (absent on non-loop runs). */
     paceDecision?: PaceDecision;
 }
@@ -76,7 +76,7 @@ export type KernelRunnerAction = {
 } | {
     kind: "archive_page_out";
     effectId: string;
-    archived?: ProviderMessage[];
+    archived?: ModelMessage[];
     handleId?: string;
     payload?: {
         content: string;
@@ -213,7 +213,7 @@ 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: ProviderMessage): Record<string, unknown>;
+export declare function messageToKernelMessage(message: ModelMessage): 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>;
@@ -223,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>): ProviderMessage;
+export declare function kernelMessageToSdk(raw: Record<string, unknown>): ModelMessage;
 export declare function renderedContextToSdk(raw: Record<string, unknown>): RenderedContext;

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

@@ -1,10 +1,10 @@
-import type { LLMProvider, ProviderMessage, ProviderDescriptor, ProviderReplay, RenderedContext, ReplayabilityAssessment, ToolCall } from "../types.js";
+import type { LLMProvider, ModelMessage, 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<ProviderMessage, "content" | "toolCalls">): string;
+export declare function assistantReplayKey(message: Pick<ModelMessage, "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/public.d.ts

@@ -0,0 +1,22 @@
+/** Runtime subpath: host execution primitives intentionally outside the root quick-start API. */
+export { RuntimeRunner, collectText } from "./runner.js";
+export { ContextManager, estimateContextTokens } from "./context-manager.js";
+export type { ContextItem, ContextItemKind, ContextItemScope, ContextLedgerEvent, ContextLedgerEventKind, ContextManagerOptions, ContextSnapshot, } from "./context-manager.js";
+export type { RuntimeOptions } from "./runner.js";
+export { runAgent, runFanout } from "./facade.js";
+export type { RunAgentOptions, RunFanoutOptions } from "./facade.js";
+export { InMemorySessionLog, FileSessionLog } from "./session-log.js";
+export type { SessionLog, SessionEvent, SessionEventKind } from "./session-log.js";
+export { projectAgentRun, projectAgentContext, projectAgentCapabilities, projectAgentGovernance, projectAgentDelegation } from "../agent-ir.js";
+export type { AgentDescriptor } from "../agent-ir.js";
+export { FileKernelJournal, InMemoryKernelJournal, JournalCasConflictError, JournalIntegrityError, JournalIoError, } from "./kernel-journal.js";
+export type { CheckpointCandidate, InstalledCheckpoint, JournalAppendReceipt, JournalEntry, JournalHead, JournalPruneReceipt, JournalRecordInput, KernelJournal, } from "./kernel-journal.js";
+export { diagnoseKernelJournal } from "./kernel-doctor.js";
+export type { KernelJournalDiagnosis } from "./kernel-doctor.js";
+export type { ContextPrepared } from "./context.js";
+export { createContextPreparationAdapter, createNativeContextPreparationAdapter } from "./context.js";
+export type { ContextPrepareJson, ContextVerifyJson, ContextProviderPreparationRequest } from "./context.js";
+export { createEvolutionRuntimeAdapter, createNativeEvolutionRuntimeAdapter, EvolutionRuntime } from "./evolution.js";
+export type { EvolutionStore } from "./evolution.js";
+export { FULL_FOOTPRINT_USAGE_ACCOUNTING_POLICY, providerAttemptToRecord } from "./execution-evidence.js";
+export type { InvocationOutcome, ModelInvocation, ProviderAttempt, ProviderAttemptRecord, ProviderAttemptStatus, UsageAccountingPolicy, ModelUsageSettlement } from "./execution-evidence.js";

package/dist/runtime/public.js

@@ -0,0 +1,11 @@
+/** Runtime subpath: host execution primitives intentionally outside the root quick-start API. */
+export { RuntimeRunner, collectText } from "./runner.js";
+export { ContextManager, estimateContextTokens } from "./context-manager.js";
+export { runAgent, runFanout } from "./facade.js";
+export { InMemorySessionLog, FileSessionLog } from "./session-log.js";
+export { projectAgentRun, projectAgentContext, projectAgentCapabilities, projectAgentGovernance, projectAgentDelegation } from "../agent-ir.js";
+export { FileKernelJournal, InMemoryKernelJournal, JournalCasConflictError, JournalIntegrityError, JournalIoError, } from "./kernel-journal.js";
+export { diagnoseKernelJournal } from "./kernel-doctor.js";
+export { createContextPreparationAdapter, createNativeContextPreparationAdapter } from "./context.js";
+export { createEvolutionRuntimeAdapter, createNativeEvolutionRuntimeAdapter, EvolutionRuntime } from "./evolution.js";
+export { FULL_FOOTPRINT_USAGE_ACCOUNTING_POLICY, providerAttemptToRecord } from "./execution-evidence.js";

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

@@ -6,13 +6,13 @@
  * 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 { ProviderMessage } from "../types.js";
+import type { ModelMessage } 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 ProviderMessage per event. Pass the result directly to `new ReplayProvider(messages)`.
+ * one ModelMessage per event. Pass the result directly to `new ReplayProvider(messages)`.
  *
  * Accepts both wire shapes the SDK uses interchangeably:
  *   - in-memory: `{ toolCalls }` (camelCase)
@@ -23,4 +23,4 @@ import type { SessionEvent } from "./session-log.js";
  */
 export declare function extractRecordedMessages(events: Array<{
     event: SessionEvent;
-} | SessionEvent>): ProviderMessage[];
+} | SessionEvent>): ModelMessage[];

package/dist/runtime/replay-fixture.js

@@ -10,7 +10,7 @@
  * 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 ProviderMessage per event. Pass the result directly to `new ReplayProvider(messages)`.
+ * one ModelMessage per event. Pass the result directly to `new ReplayProvider(messages)`.
  *
  * Accepts both wire shapes the SDK uses interchangeably:
  *   - in-memory: `{ toolCalls }` (camelCase)