@deepstrike/sdk 0.2.71 → 0.2.72

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)

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 ProviderMessage mirror.
+ *     the session measurement plane, never to the public ModelMessage 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, ProviderMessage, ProviderDescriptor, ProviderRunState, RenderedContext, StreamEvent, ToolSchema } from "../types.js";
+import type { LLMProvider, ModelMessage, 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<ProviderMessage>, opts?: ReplayProviderOpts);
+    constructor(messages: ReadonlyArray<ModelMessage>, 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<ProviderMessage>;
+    complete(_context: RenderedContext, _tools: ToolSchema[]): Promise<ModelMessage>;
     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 ProviderMessage mirror.
+ *     the session measurement plane, never to the public ModelMessage 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,6 +1,8 @@
-import type { LLMProvider, ProviderMessage, ContentPart, ToolSchema, StreamEvent, ToolSuspendEvent, PermissionRequestEvent, PermissionResponse, AsyncSummarizer, MemorySummarizer, EntropySample, EntropyWatchOptions } from "../types.js";
+import type { LLMProvider, ModelMessage, 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 { Skill } from "../skill.js";
+import type { ContextManager } from "./context-manager.js";
 import type { RuntimeSignalUrgency, SignalSource } from "../signals/types.js";
 import type { SessionLog, SessionEvent } from "./session-log.js";
 import type { KernelJournal } from "./kernel-journal.js";
@@ -9,6 +11,7 @@ import type { ExecutionPlane } from "./execution-plane.js";
 import type { RunGroup } from "./run-group.js";
 import { type MemoryPolicy, type ResourceQuota } from "../kernel.js";
 import type { AgentRunSpec, MilestoneCheckResult, MilestoneContract, MilestonePolicy, WorkflowSpec, WorkflowOutcome } from "../types/agent.js";
+import type { AgentCapabilityFilter } from "../types/agent.js";
 export declare function stableSemanticArchiveName(effectId: string): string;
 import { type SubAgentOrchestrator } from "./sub-agent-orchestrator.js";
 import { type ReducerRegistry } from "./reducers.js";
@@ -95,6 +98,8 @@ export interface KernelReliabilityOptions {
 export type OperationCancellationReason = "user" | "deadline" | "lease_lost" | "host_shutdown";
 export interface RuntimeOptions {
     provider: LLMProvider;
+    /** Host-owned capability ceiling applied to the root run before skills or run profiles narrow it further. */
+    capabilityFilter?: AgentCapabilityFilter;
     /** 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
@@ -150,7 +155,11 @@ export interface RuntimeOptions {
      *  behavior difference. */
     nudges?: NudgeRule[];
     initialMemory?: string[];
+    /** Optional host ledger that admits dynamic context before kernel insertion. */
+    contextManager?: ContextManager;
     skillDir?: string;
+    /** Inline skill catalog. Metadata is exposed at run start; content is loaded only on activation. */
+    skillCatalog?: Skill[];
     /** Host-layer allowlist over the `skillDir` catalog by skill NAME. When set, only scanned skills
      *  whose name is listed are fed to the kernel via `set_available_skills` (the manifest layer
      *  intersects onto this host baseline in `applyManifest`). Absent ⇒ zero behavior difference (all
@@ -398,6 +407,8 @@ export declare class RuntimeRunner {
      *  run — guards against re-pushing a duplicate entry if the model calls `skill(name)` again for
      *  an already-active skill (loading is idempotent; the knowledge push should be too). */
     private knowledgePushedSkills;
+    /** Host mirror of kernel skill lease expiry, used only to clear ContextManager overlays. */
+    private skillLeaseExpirations;
     private nextArchiveStart;
     private pendingPageOutArchives;
     private activePageOutArchive;
@@ -488,7 +499,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: ProviderMessage, tokens?: number, opts?: {
+    pushKnowledge(message: ModelMessage, tokens?: number, opts?: {
         key?: string;
         pinned?: boolean;
     }): Promise<void>;
@@ -500,6 +511,7 @@ export declare class RuntimeRunner {
      *  drops at the next compaction/renewal boundary. A later `skill(name)` call re-activates and
      *  re-pins fresh content. Errs-open: not-active is a kernel-side no-op. */
     deactivateSkill(name: string): Promise<void>;
+    private expireSkillContext;
     /**
      * G3: run one workflow node, enforcing its `output_schema` (if any). Without a schema this is a
      * plain `orchestrator.run`. With one, the node's agent is instructed to emit conforming JSON, its
@@ -603,14 +615,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: ProviderMessage[]): ProviderMessage[];
+export declare function pairOrphanToolCalls(messages: ModelMessage[]): ModelMessage[];
 export declare function replayMessages(events: Array<{
     seq: number;
     event: SessionEvent;
-}>, maxBytes?: number): ProviderMessage[];
+}>, maxBytes?: number): ModelMessage[];
 export declare function replayMessagesAsync(events: Array<{
     seq: number;
     event: SessionEvent;
-}>, maxBytes?: number, loadArchive?: (archiveRef: string) => Promise<ProviderMessage[]>): Promise<ProviderMessage[]>;
+}>, maxBytes?: number, loadArchive?: (archiveRef: string) => Promise<ModelMessage[]>): Promise<ModelMessage[]>;
 /** Collect all text_delta events from a run into a single string. */
 export declare function collectText(stream: AsyncIterable<StreamEvent>): Promise<string>;