@deepstrike/sdk 0.2.71 → 0.2.73

package/dist/evals/public.d.ts

@@ -0,0 +1,57 @@
+/** Public evaluation language. Runtime evidence remains available through the runtime subpath. */
+export { judge, buildEvalMessages, parseVerdict, verdictOutputSchema } from "../runtime/eval.js";
+export type { Criterion, Verdict, VerdictDetail, JudgeArgs } from "../runtime/eval.js";
+export interface DatasetCase {
+    id: string;
+    input: string;
+    expected?: unknown;
+    metadata?: Record<string, unknown>;
+}
+export interface Dataset {
+    name?: string;
+    cases: DatasetCase[];
+}
+export interface Evaluator {
+    name: string;
+    evaluate(input: {
+        testCase: DatasetCase;
+        output: string;
+    }): Promise<number> | number;
+}
+export interface EvalResult {
+    caseId: string;
+    output: string;
+    scores: Record<string, number>;
+}
+export interface ExecutionEvidence {
+    contextBinding?: unknown;
+    route?: unknown;
+    measurement?: unknown;
+    artifactSet?: unknown;
+}
+/** Optional execution evidence kept separate from the stable score/result contract. */
+export interface EvalTrace {
+    caseId: string;
+    executedInput: string;
+    contextBinding?: unknown;
+    route?: unknown;
+    measurement?: unknown;
+    artifactSet?: unknown;
+}
+export interface EvalRun {
+    runId: string;
+    results: EvalResult[];
+    completed: boolean;
+    traces?: EvalTrace[];
+}
+export declare function evaluate(agent: {
+    run(input: string): Promise<{
+        output: string;
+        evidence?: ExecutionEvidence;
+    }>;
+}, options: {
+    dataset: Dataset;
+    evaluators: Evaluator[];
+    runId?: string;
+    includeTrace?: boolean;
+}): Promise<EvalRun>;

package/dist/evals/public.js

@@ -0,0 +1,24 @@
+/** Public evaluation language. Runtime evidence remains available through the runtime subpath. */
+export { judge, buildEvalMessages, parseVerdict, verdictOutputSchema } from "../runtime/eval.js";
+export async function evaluate(agent, options) {
+    const results = [];
+    const traces = [];
+    for (const testCase of options.dataset.cases) {
+        const output = await agent.run(testCase.input);
+        const scores = {};
+        for (const evaluator of options.evaluators)
+            scores[evaluator.name] = await evaluator.evaluate({ testCase, output: output.output });
+        results.push({ caseId: testCase.id, output: output.output, scores });
+        if (options.includeTrace) {
+            traces.push({
+                caseId: testCase.id,
+                executedInput: testCase.input,
+                ...(output.evidence?.contextBinding !== undefined ? { contextBinding: output.evidence.contextBinding } : {}),
+                ...(output.evidence?.route !== undefined ? { route: output.evidence.route } : {}),
+                ...(output.evidence?.measurement !== undefined ? { measurement: output.evidence.measurement } : {}),
+                ...(output.evidence?.artifactSet !== undefined ? { artifactSet: output.evidence.artifactSet } : {}),
+            });
+        }
+    }
+    return { runId: options.runId ?? crypto.randomUUID(), results, completed: true, ...(options.includeTrace ? { traces } : {}) };
+}

package/dist/guardrail.d.ts

@@ -1,6 +1,9 @@
-/** Public guardrail declaration. Execution/lowering belongs to a later governance card. */
+import type { GovernancePolicy } from "./governance.js";
+/** Public guardrail declaration. A policy-bearing guardrail lowers into host governance. */
 export interface Guardrail {
     name: string;
     description?: string;
     metadata?: Record<string, unknown>;
+    /** Optional executable governance policy. A descriptive guardrail without this field is inert. */
+    policy?: GovernancePolicy;
 }

package/dist/handoff-target.d.ts

@@ -3,6 +3,8 @@ import type { JsonSchema } from "./runtime/output-schema.js";
 export type AgentRef = string | {
     name: string;
 };
+/** Canonical lowering primitive shared by handoff authorization and workflow nodes. */
+export declare function agentRefName(ref: AgentRef): string;
 export interface Handoff {
     agent: AgentRef;
     description?: string;

package/dist/handoff-target.js

@@ -1 +1,7 @@
-export {};
+/** Canonical lowering primitive shared by handoff authorization and workflow nodes. */
+export function agentRefName(ref) {
+    const name = typeof ref === "string" ? ref : ref.name;
+    if (!name)
+        throw new Error("agent reference requires a non-empty name");
+    return name;
+}

package/dist/index.d.ts

@@ -1,29 +1,6 @@
 export { createAgent } from "./agent-facade.js";
-export type { AgentDefinition, AgentRunOptions, AgentSession, DelegationRequest, DelegationResult, ExecutableAgent, MemoryInput, RecallOptions, RunResult, SessionRef, } from "./agent-facade.js";
-export { collectText } from "./runtime/runner.js";
-export type { InstructionProfile, NudgeRule, NudgeTrigger } from "./harness/public.js";
-export type { SignalPolicy } from "./runtime/os-profile.js";
-export { DEFAULT_CONTEXT_POLICY, PPM_SCALE, contextPolicy, normalizeContextPolicy, ratioToPpm, } from "./runtime/context-policy.js";
-export type { ContextPolicyOverrides, ContextPolicy, ContextPolicyWire, ContextPressureThresholds, } from "./runtime/context-policy.js";
-export type { SessionEvent, SessionEventKind } from "./runtime/session-log.js";
-export { SESSION_EVENT_KINDS } from "./runtime/session-log.js";
-export { CANONICAL_CONTENT_PARTS_PREFIX, encodeCanonicalContentParts, decodeCanonicalContentParts, } from "./runtime/kernel-step.js";
-export { FileKernelJournal, InMemoryKernelJournal, JournalCasConflictError, JournalIntegrityError, JournalIoError, } from "./runtime/kernel-journal.js";
-export type { CheckpointCandidate, InstalledCheckpoint, JournalAppendReceipt, JournalEntry, JournalHead, JournalPruneReceipt, JournalRecordInput, KernelJournal, } from "./runtime/kernel-journal.js";
-export { diagnoseKernelJournal } from "./runtime/kernel-doctor.js";
-export type { KernelJournalDiagnosis } from "./runtime/kernel-doctor.js";
-export { InMemoryGroupBudgetStore, GroupBudgetScope } from "./runtime/run-group.js";
-export type { RunGroup, GroupBudgetStore, GroupLedger, GroupCharge, GroupMember, GroupBudgetRequest, GroupBudgetReservation, } from "./runtime/run-group.js";
-export { InMemoryEventStream, isVisibleTo } from "./runtime/event-stream.js";
-export type { EventStream, EventStreamOptions, BlackboardEvent, EventViewer } from "./runtime/event-stream.js";
-export type { ObserverFailure, ObserverErrorHandler } from "./runtime/reliability.js";
-export type { OperationContext, BackgroundTaskFailure, BackgroundTaskErrorHandler } from "./runtime/reliability.js";
-export { reactByMention, directorDriven, roundRobin, firstNonEmpty, union } from "./runtime/turn-policy.js";
-export type { TurnPolicy, PeerView } from "./runtime/turn-policy.js";
-export { ReactiveSession, readRecentTool } from "./runtime/reactive-session.js";
-export type { ReactiveSessionOptions, ReactivePeerSpec, EmitEvent, Reaction, ReactorTurn, ReactorContext } from "./runtime/reactive-session.js";
-export { InMemoryReactionCheckpointStore, ReactionInProgressError } from "./runtime/reaction-checkpoint.js";
-export type { ReactionCheckpointClaim, ReactionCheckpointClaimResult, ReactionCheckpointReceipt, ReactionCheckpointStore, ReactionRecord, } from "./runtime/reaction-checkpoint.js";
+export type { AgentRunOptions, AgentSession, DelegationRequest, DelegationResult, MemoryInput, RecallOptions, RunResult, SessionRef, } from "./agent-facade.js";
+export type { Agent } from "./agent-facade.js";
 export { tool, streamingTool } from "./tools/index.js";
 export type { RegisteredTool, ToolExecContext } from "./tools/index.js";
 export { safeTool, ok, fail, ToolError, formatToolError } from "./tools/errors.js";
@@ -36,29 +13,18 @@ export { OpenAIResponsesProvider } from "./providers/openai-responses.js";
 export { createProvider, createProviderAsync, resolveProviderRuntime, resolveProviderRuntimeAsync } from "./providers/catalog.js";
 export { UnsupportedModalityError } from "./providers/base.js";
 export type { CreateProviderOptions, EndpointProfileId } from "./providers/catalog.js";
-export { createProviderRequestPlan, createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, normalizeProviderUsage, priceProviderUsage, recordPromptMeasurement, resolveProviderRoute } from "./providers/request-plan.js";
-export type { CostObservation, NormalizedProviderUsage, PricingSnapshot, ProviderRequestEndpoint, ProviderRequestPlan, RecordedPromptMeasurement, ResolvedProviderRoute } from "./providers/request-plan.js";
-export { FULL_FOOTPRINT_USAGE_ACCOUNTING_POLICY, providerAttemptToRecord } from "./runtime/execution-evidence.js";
-export type { InvocationOutcome, ModelInvocation, ProviderAttempt, ProviderAttemptRecord, ProviderAttemptStatus, UsageAccountingPolicy, ModelUsageSettlement } from "./runtime/execution-evidence.js";
-export { VERIFIABLE_REPORT_SCHEMA, VERIFIABLE_FORK_SCHEMA, assertVerifiableReportSchema, createVerifiableRuntimeAdapter, createNativeVerifiableRuntimeAdapter, VerifiableOperation, } from "./runtime/verifiable-report.js";
-export type { VerifiableCommand, CheckVerdict, VerifiableForkManifest, ForkPlan, VerifiableEvidence, VerifyOptions, ReplayOptions, VerifiableRuntimeAdapter, VerifiableReport, VerifiableOperationJson, } from "./runtime/verifiable-report.js";
-export { 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 { Agent } from "./agent.js";
-export type { AgentOptions, AgentMemory, MemoryReference, ModelRef, ModelRequirement } from "./agent.js";
-export { lowerAgent, normalizeAgent } from "./agent-ir.js";
-export type { AgentCapabilityIR, AgentLoweringInputs, AgentMemoryIR, AgentSpec, AgentToolDefinition, AgentToolIR } from "./agent-ir.js";
+export type { SessionEvent, SessionEventKind } from "./session-events.js";
+export { SESSION_EVENT_KINDS } from "./session-events.js";
+export { InMemoryReactionCheckpointStore } from "./reactions.js";
+export type { ReactionCheckpointClaim, ReactionCheckpointClaimResult, ReactionCheckpointReceipt, ReactionCheckpointStore, InMemoryReactionCheckpointStoreOptions, } from "./reactions.js";
+export type { ModelRef, ModelRequirement } from "./agent.js";
 export type { Guardrail } from "./guardrail.js";
 export type { MCPServer, McpTransport } from "./mcp-server.js";
 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 { 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";
+export { createWorkflow } from "./workflow/definition.js";
+export type { WorkflowDefinition, WorkflowStep, WorkflowResult } from "./workflow/definition.js";
+export { evaluate } from "./evals/public.js";
+export type { Dataset, DatasetCase, Evaluator, EvalResult, EvalRun, EvalTrace, ExecutionEvidence } from "./evals/public.js";
+export type { ModelMessage, RuntimeMessage, StoredMessage, WireMessage, 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";

package/dist/index.js

@@ -1,5 +1,5 @@
 // ╔══════════════════════════════════════════════════════════════════════════╗
-// ║ @deepstrike/sdk — root surface (v0.2.30).                                      ║
+// ║ @deepstrike/sdk — root surface (v0.2.73).                                      ║
 // ║                                                                            ║
 // ║ This is the intent layer: run an agent, run a workflow, author a tool,     ║
 // ║ pick a provider. Advanced machinery lives behind subpaths:                 ║
@@ -13,20 +13,6 @@
 // ── Start here: the canonical entry points ─────────────────────────────────
 // ③ dynamic loop agents: self-pacing rounds over the kernel pacing trap.
 export { createAgent } from "./agent-facade.js";
-export { collectText } from "./runtime/runner.js";
-export { DEFAULT_CONTEXT_POLICY, PPM_SCALE, contextPolicy, normalizeContextPolicy, ratioToPpm, } from "./runtime/context-policy.js";
-// Registered session-event vocabulary (F9/S3; manifest-pinned by sdk-conformance, P7-S4)
-export { SESSION_EVENT_KINDS } from "./runtime/session-log.js";
-// ── content-parts-v1 registered encoding (F14/B5; byte-pinned by sdk-conformance) ──
-export { CANONICAL_CONTENT_PARTS_PREFIX, encodeCanonicalContentParts, decodeCanonicalContentParts, } from "./runtime/kernel-step.js";
-// ── Durable transaction capability (Canonical Kernel ABI §9.1) ──────────────
-export { FileKernelJournal, InMemoryKernelJournal, JournalCasConflictError, JournalIntegrityError, JournalIoError, } from "./runtime/kernel-journal.js";
-export { diagnoseKernelJournal } from "./runtime/kernel-doctor.js";
-export { InMemoryGroupBudgetStore, GroupBudgetScope } from "./runtime/run-group.js";
-export { InMemoryEventStream, isVisibleTo } from "./runtime/event-stream.js";
-export { reactByMention, directorDriven, roundRobin, firstNonEmpty, union } from "./runtime/turn-policy.js";
-export { ReactiveSession, readRecentTool } from "./runtime/reactive-session.js";
-export { InMemoryReactionCheckpointStore, ReactionInProgressError } from "./runtime/reaction-checkpoint.js";
 // ── Tool authoring ──────────────────────────────────────────────────────────
 export { tool, streamingTool } from "./tools/index.js";
 export { safeTool, ok, fail, ToolError, formatToolError } from "./tools/errors.js";
@@ -38,14 +24,7 @@ export { OpenAIProvider } from "./providers/openai.js";
 export { OpenAIResponsesProvider } from "./providers/openai-responses.js";
 export { createProvider, createProviderAsync, resolveProviderRuntime, resolveProviderRuntimeAsync } from "./providers/catalog.js";
 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`.
-// ── Ecosystem Surface Contract (spc_001) ────────────────────────────────────
-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";
+export { SESSION_EVENT_KINDS } from "./session-events.js";
+export { InMemoryReactionCheckpointStore } from "./reactions.js";
+export { createWorkflow } from "./workflow/definition.js";
+export { evaluate } from "./evals/public.js";

package/dist/kernel.d.ts

@@ -1,4 +1,4 @@
-import type { ProviderMessage } from "./types.js";
+import type { ModelMessage } from "./types.js";
 /**
  * M2 资源配额 — declarative resource limits enforced at the kernel's single syscall trap.
  *
@@ -150,7 +150,7 @@ export interface CanonicalKernelInstance {
 interface KernelModule {
     CanonicalKernel: new () => CanonicalKernelInstance;
     SignalRouter: new (maxQueueSize: number) => SignalRouterInstance;
-    buildEvalMessages(goal: string, criteria: NativeCriterion[], result: string, attempt: number, extractSkillOnPass: boolean): ProviderMessage[];
+    buildEvalMessages(goal: string, criteria: NativeCriterion[], result: string, attempt: number, extractSkillOnPass: boolean): ModelMessage[];
     parseVerdict(content: string): Verdict;
     verdictOutputSchema(extractSkillOnPass: boolean): string;
     verifiableOperationJson(request: string): string;

package/dist/knowledge/public.d.ts

@@ -27,3 +27,5 @@ export interface Knowledge {
     metadata?: Record<string, unknown>;
     providerOptions?: Record<string, unknown>;
 }
+export { createTextKnowledgeSource } from "./source.js";
+export type { TextKnowledgeDocument } from "./source.js";

package/dist/knowledge/public.js

@@ -1 +1 @@
-export {};
+export { createTextKnowledgeSource } from "./source.js";

package/dist/knowledge/source.d.ts

@@ -3,3 +3,10 @@ export interface KnowledgeSource {
     /** One-time warmup called before the first run (load index, open connection, etc.). */
     init(): Promise<void>;
 }
+export interface TextKnowledgeDocument {
+    id?: string;
+    name?: string;
+    content: string;
+}
+/** Deterministic local retrieval for inline text knowledge; external sources keep explicit bindings. */
+export declare function createTextKnowledgeSource(documents: TextKnowledgeDocument[]): KnowledgeSource;

package/dist/knowledge/source.js

@@ -1 +1,20 @@
-export {};
+/** Deterministic local retrieval for inline text knowledge; external sources keep explicit bindings. */
+export function createTextKnowledgeSource(documents) {
+    const prepared = documents.filter(document => document.content.trim()).map((document, index) => ({
+        ...document,
+        key: document.id ?? document.name ?? `text-${index}`,
+        terms: new Set(document.content.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? []),
+    }));
+    return {
+        async init() { },
+        async retrieve(goal, topK = 5) {
+            const queryTerms = new Set(goal.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? []);
+            return prepared
+                .map(document => ({ document, score: [...queryTerms].reduce((score, term) => score + (document.terms.has(term) ? 1 : 0), 0) }))
+                .sort((left, right) => right.score - left.score || left.document.key.localeCompare(right.document.key))
+                .filter(item => item.score > 0 || queryTerms.size === 0)
+                .slice(0, Math.max(0, topK))
+                .map(({ document }) => document.name ? `[Knowledge: ${document.name}]\n${document.content}` : document.content);
+        },
+    };
+}

package/dist/memory/protocols.d.ts

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

package/dist/projection-pairs.d.ts

@@ -0,0 +1,43 @@
+/** SPC-028-09: registered authority/projection relationships. */
+export interface ProjectionPair {
+    readonly authority: string;
+    readonly projection: string;
+    readonly crossingFunction: string;
+}
+export declare const PROJECTION_PAIRS: {
+    readonly Message: {
+        readonly authority: "ModelMessage";
+        readonly projection: "WireMessage";
+        readonly crossingFunction: "adapter.encode/decode";
+    };
+    readonly Content: {
+        readonly authority: "ContentPart[]";
+        readonly projection: "string";
+        readonly crossingFunction: "projectContentToText";
+    };
+    readonly ToolResult: {
+        readonly authority: "contentParts";
+        readonly projection: "output";
+        readonly crossingFunction: "projectToolOutputToText";
+    };
+    readonly StopReason: {
+        readonly authority: "GenerationProtocol stop reason";
+        readonly projection: "CanonicalStopReason";
+        readonly crossingFunction: "normalizeStopReason";
+    };
+    readonly ToolCall: {
+        readonly authority: "ToolCall";
+        readonly projection: "ToolCallEvent";
+        readonly crossingFunction: "decodeToolCall";
+    };
+    readonly ResourceQuota: {
+        readonly authority: "ResourceQuota";
+        readonly projection: "QuotaSnapshot";
+        readonly crossingFunction: "projectQuota";
+    };
+    readonly TerminationReason: {
+        readonly authority: "Kernel terminal fact";
+        readonly projection: "RunResult.status";
+        readonly crossingFunction: "statusFromDone";
+    };
+};

package/dist/projection-pairs.js

@@ -0,0 +1,9 @@
+export const PROJECTION_PAIRS = {
+    Message: { authority: "ModelMessage", projection: "WireMessage", crossingFunction: "adapter.encode/decode" },
+    Content: { authority: "ContentPart[]", projection: "string", crossingFunction: "projectContentToText" },
+    ToolResult: { authority: "contentParts", projection: "output", crossingFunction: "projectToolOutputToText" },
+    StopReason: { authority: "GenerationProtocol stop reason", projection: "CanonicalStopReason", crossingFunction: "normalizeStopReason" },
+    ToolCall: { authority: "ToolCall", projection: "ToolCallEvent", crossingFunction: "decodeToolCall" },
+    ResourceQuota: { authority: "ResourceQuota", projection: "QuotaSnapshot", crossingFunction: "projectQuota" },
+    TerminationReason: { authority: "Kernel terminal fact", projection: "RunResult.status", crossingFunction: "statusFromDone" },
+};

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

@@ -1,4 +1,4 @@
-import type { ProviderMessage, ProviderReplay, ProviderUsage, ToolCall } from "../types.js";
+import type { ModelMessage, 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: ProviderMessage;
+        message: ModelMessage;
         replay?: ProviderReplay;
     };
     createStreamState(input: AdapterStreamInput): AnthropicStreamState;

package/dist/providers/anthropic.d.ts

@@ -1,5 +1,5 @@
 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 { LLMProvider, ModelMessage, PromptMeasurement, ProviderDescriptor, ProviderReplay, ProviderTransportTelemetry, RenderedContext, RuntimePolicy, StreamEvent, ToolSchema } from "../types.js";
 import { type CanonicalAdapterInput } from "./content-normalization.js";
 export interface AnthropicProviderConfig {
     apiKey: string;
@@ -35,11 +35,11 @@ export declare class AnthropicProvider implements LLMProvider {
     private lastTelemetry;
     peekTransportTelemetry(): ProviderTransportTelemetry | undefined;
     bindResolvedRuntime(resolved: ResolvedAnthropicRuntime): void;
-    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 adapterInput;
     private buildPlan;
-    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<ProviderMessage>;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<ModelMessage>;
     /** Native measurement belongs to the verified official endpoint, not the wire protocol. */
     countTokens(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<PromptMeasurement>;
     private countPlan;

package/dist/providers/base.d.ts

@@ -1,4 +1,4 @@
-import type { ProviderMessage, RenderedContext } from "../types.js";
+import type { ModelMessage, 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: ProviderMessage): string | Array<Record<string, unknown>>;
+export declare function toAnthropicContent(msg: ModelMessage): 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: ProviderMessage): string | Array
  * 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): ProviderMessage[];
+export declare function turnsWithStateAppended(context: RenderedContext): ModelMessage[];
 /** Convert RenderedContext.turns to Anthropic messages array.
  *  `turns` contains only user / assistant / tool roles — no system filtering needed. */
-export declare function toAnthropicMessages(turns: ProviderMessage[], nativeReplay?: (message: ProviderMessage) => Array<Record<string, unknown>> | undefined): Array<Record<string, unknown>>;
+export declare function toAnthropicMessages(turns: ModelMessage[], nativeReplay?: (message: ModelMessage) => 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: ProviderMessage): string | Array<Record<string, unknown>>;
+export declare function toOpenAIContent(msg: ModelMessage): 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 { 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. */