@arnilo/prism 0.0.14 → 0.0.16

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [0.0.16] - 2026-07-26
+
+### Added
+- Phase 11 simplification/readiness: new public export `resolveRedactor` from `@arnilo/prism` (single survivor of four private copies across evals/memory/rag/workflows) and a new internal `@arnilo/prism-session-store-codecs` package (shared SQLite/Postgres row codecs, not enrolled in any profile family), bringing the exact graph to **44 publishable manifests**.
+- Offline pre-publish release gates: `npm run release:gate` (API-surface `.d.ts` diff vs `scripts/compat-baseline/`, tarball deny-list, exact version ranges), wired into `npm run sdk:ready`.
+- Performance budgets in `scripts/budgets.json`, enforced by `scripts/budget-gate.test.mjs` (in `npm test`) and `scripts/benchmark-0.0.16.mjs`.
+
+### Changed
+- Dropped historical `docs/review-coverage-*.md` from the root tarball (11 files, ~283 KB): packed size 659,478 → ≈575,680 bytes, 281 → 270 files.
+- All six profiles (`prism-all`, `prism-base`, `prism-code`, `prism-compaction`, `prism-providers`, `prism-sdk`) retained on adoption evidence; zero retirements. No runtime behavior changes.
+
+## [0.0.15] - 2026-07-26
+
+### Added
+
+- Phase 10 provider, memory, and RAG parity: OpenAI hosted-tool attribution, bounded Responses continuation and Realtime seam; exact AI SDK V4 mapping; bounded RAG source lifecycle, document adapters, reranking, citation provenance, content trust, and ingestion status; memory export/rebuild with production-store conformance.
+
+### Changed
+
+- Versioned all **43** publishable manifests, exact internal ranges, and lockfile entries to `0.0.15`; no package was added.
+- Added network-free Phase 10 evidence: `scripts/benchmark-0.0.15.mjs`.
+
 ## [0.0.14] - 2026-07-26
 
 ### Added
@@ -28,8 +50,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 All notable changes to this project will be documented in this file.
 
-## [Unreleased]
-
 ## [0.0.12] - 2026-07-22
 
 ### Added

package/README.md

@@ -34,10 +34,11 @@ packages. Prism defines contracts, not apps.
 - **Config, settings, security**: layered config merge, settings providers,
   credential resolvers, trust/permission policies, and secret redaction.
 - **CLI/RPC/server**: `prism --mode print|json|rpc`, `prism init`, optional framework-free authorized Web agent/workflow routes, and explicit MCP server exposure.
-- **Co-work contracts (0.0.14)**: conversation thread and artifact/review types, a
-  deny-by-default device-adapter contract (`resolveDevicePolicy`/`assertDeviceAdmit`),
-  and OAuth refresh/revoke helpers; services ship in `@arnilo/prism-server` and
-  `@arnilo/prism-credentials-node`.
+- **Ecosystem parity (0.0.15)**: OpenAI hosted-tool attribution, bounded Responses
+  continuation/Realtime, exact AI SDK V4 mapping, bounded RAG lifecycle/reranking/trust,
+  and consent-bound memory export/rebuild; provider, RAG, and memory packages remain optional.
+- **Co-work contracts (0.0.14)**: conversation/artifact review types, deny-by-default device
+  contracts, and OAuth refresh/revoke helpers; services stay in optional packages.
 
 ## Install
 

package/dist/agent-definitions.js

@@ -1,5 +1,5 @@
 import { createAgent } from "./agents.js";
-import { resolveActiveSkills, createSkillRegistry } from "./skills.js";
+import { createSkillRegistry, resolveActiveSkills } from "./skills.js";
 import { createToolRegistry } from "./tools.js";
 /** Resolve an {@link AgentDefinition} into a runnable {@link Agent}.
  *
@@ -96,8 +96,7 @@ function hasList(value) {
     return typeof value === "object" && value !== null && "list" in value && typeof value.list === "function";
 }
 function resolveSkills(names, tools, context) {
-    const registry = context.skillsRegistry ??
-        (context.registries?.skills ? createSkillRegistry(context.registries.skills.list()) : undefined);
+    const registry = context.skillsRegistry ?? (context.registries?.skills ? createSkillRegistry(context.registries.skills.list()) : undefined);
     if (!names && !context.activateAllCapabilities)
         return undefined;
     if (!registry) {

package/dist/agent-loops.d.ts

@@ -14,6 +14,10 @@ export declare function resolveToolConcurrency(options: {
 }, config: {
     loop?: AgentLoopStrategy | AgentLoopOptions;
 }): number;
+/** Calls the host must dispatch. Provider-hosted calls (`authority: "provider-hosted"`)
+ *  were already executed server-side; the assistant response text carries their effect, so
+ *  the host neither dispatches them nor appends a `tool_result`. */
+export declare function dispatchableToolCalls(calls: readonly ToolCallContent[]): readonly ToolCallContent[];
 /** Dispatch tool calls with bounded concurrency; append transcript rows in call order. */
 export declare function dispatchToolCallsInOrder(calls: readonly ToolCallContent[], ctx: LoopContext): Promise<void>;
 export declare function resolveLoop(options: {

package/dist/agent-loops.js

@@ -1,5 +1,5 @@
-import { inputMessages } from "./input.js";
 import { createId } from "./ids.js";
+import { inputMessages } from "./input.js";
 import { artifactStructuredOutputRequest, withoutStructuredOutput } from "./structured-output.js";
 function throwIfAborted(signal) {
     if (signal.aborted)
@@ -8,7 +8,10 @@ function throwIfAborted(signal) {
 function toolResultMessage(result) {
     return {
         role: "tool",
-        content: [{ type: "tool_result", toolCallId: result.toolCallId, name: result.name, result: result.value, error: result.error }, ...(result.content ?? [])],
+        content: [
+            { type: "tool_result", toolCallId: result.toolCallId, name: result.name, result: result.value, error: result.error },
+            ...(result.content ?? []),
+        ],
         metadata: result.metadata,
     };
 }
@@ -39,7 +42,8 @@ export const singleShotLoop = {
                 ctx.emit({ type: "message_finished", sessionId: ctx.sessionId, runId: ctx.runId, message });
             }
             ctx.emit({ type: "turn_finished", sessionId: ctx.sessionId, runId: ctx.runId, turn });
-            if (calls.length === 0 || toolRounds >= ctx.maxToolRounds) {
+            const dispatchable = dispatchableToolCalls(calls);
+            if (dispatchable.length === 0 || toolRounds >= ctx.maxToolRounds) {
                 // Soft-interrupt / late steer: keep same run going when queue still has text.
                 if (await ctx.applyPendingSteers?.()) {
                     nextInput = [];
@@ -48,7 +52,7 @@ export const singleShotLoop = {
                 break;
             }
             toolRounds += 1;
-            await dispatchToolCallsInOrder(calls, ctx);
+            await dispatchToolCallsInOrder(dispatchable, ctx);
             nextInput = [];
         }
         return usage;
@@ -113,13 +117,23 @@ export function generateValidateReviseLoop(opts) {
                 }
                 ctx.emit({ type: "turn_finished", sessionId: ctx.sessionId, runId: ctx.runId, turn });
                 if (opts.toolCalls === "bounded" && calls.length > 0) {
+                    const dispatchable = dispatchableToolCalls(calls);
+                    if (dispatchable.length === 0) {
+                        // Only provider-hosted calls; no host tool to run. Continue without charging a round.
+                        nextInput = [];
+                        continue;
+                    }
                     if (toolRounds >= ctx.maxToolRounds) {
-                        const result = { ok: false, errors: [{ message: "maximum tool rounds exceeded" }], metadata: { reason: "tool_round_limit" } };
+                        const result = {
+                            ok: false,
+                            errors: [{ message: "maximum tool rounds exceeded" }],
+                            metadata: { reason: "tool_round_limit" },
+                        };
                         ctx.emit({ type: "artifact_failed", sessionId: ctx.sessionId, runId: ctx.runId, turn, attempt: attempts + 1, result });
                         return usage;
                     }
                     toolRounds += 1;
-                    await dispatchToolCallsInOrder(calls, { ...ctx, toolConcurrency: 1 });
+                    await dispatchToolCallsInOrder(dispatchable, { ...ctx, toolConcurrency: 1 });
                     nextInput = [];
                     continue;
                 }
@@ -159,7 +173,7 @@ export function generateValidateReviseLoop(opts) {
                     : undefined;
                 const attempt = ++attempts;
                 ctx.emit({ type: "artifact_validation_started", sessionId: ctx.sessionId, runId: ctx.runId, turn, attempt });
-                const result = parseFailure ?? await opts.validator(parsed.value, artifactCtx);
+                const result = parseFailure ?? (await opts.validator(parsed.value, artifactCtx));
                 ctx.emit({ type: "artifact_validation_finished", sessionId: ctx.sessionId, runId: ctx.runId, turn, attempt, result });
                 if (result.ok) {
                     ctx.emit({ type: "artifact_finished", sessionId: ctx.sessionId, runId: ctx.runId, turn, attempt, result });
@@ -195,14 +209,18 @@ export function resolveToolConcurrency(options, config) {
         return 1;
     return Math.floor(value);
 }
+/** Calls the host must dispatch. Provider-hosted calls (`authority: "provider-hosted"`)
+ *  were already executed server-side; the assistant response text carries their effect, so
+ *  the host neither dispatches them nor appends a `tool_result`. */
+export function dispatchableToolCalls(calls) {
+    return calls.filter((call) => call.authority !== "provider-hosted");
+}
 /** Dispatch tool calls with bounded concurrency; append transcript rows in call order. */
 export async function dispatchToolCallsInOrder(calls, ctx) {
     if (calls.length === 0)
         return;
     ctx.chargeToolRound?.(calls);
-    const concurrency = calls.some((call) => ctx.isToolCallExclusive?.(call))
-        ? 1
-        : Math.max(1, Math.min(ctx.toolConcurrency, calls.length));
+    const concurrency = calls.some((call) => ctx.isToolCallExclusive?.(call)) ? 1 : Math.max(1, Math.min(ctx.toolConcurrency, calls.length));
     if (concurrency === 1) {
         for (const call of calls) {
             const result = await ctx.dispatchToolCall(call);

package/dist/agent-run-lifecycle.d.ts

@@ -1,5 +1,4 @@
-import type { Agent, AgentEvent, AgentRunRef, AgentRunResult, AgentRunResume, AgentRunStatusResult, OwnershipScope, SubscribeOptions } from "./contracts.js";
-import type { CheckpointStore } from "./contracts.js";
+import type { Agent, AgentEvent, AgentRunRef, AgentRunResult, AgentRunResume, AgentRunStatusResult, CheckpointStore, OwnershipScope, SubscribeOptions } from "./contracts.js";
 export interface AgentRunLifecycleAgent {
     readonly agent: Agent;
     /** Current host-authored revision; it must match the stored revision. */

package/dist/agent-run-lifecycle.js

@@ -1,6 +1,6 @@
-import { AgentRunStateError } from "./contracts.js";
 import { loadAgentRunState, publicState } from "./agent-run-state.js";
 import { resumeAgentRun, resumeAgentRunStream } from "./agents.js";
+import { AgentRunStateError } from "./contracts.js";
 function assertAgentId(actual, expected) {
     if (expected !== undefined && actual !== expected)
         throw new AgentRunStateError("Agent run capability mismatch");

package/dist/agent-run-state.js

@@ -21,7 +21,9 @@ export function agentFingerprint(agent, revision) {
         model: config.model,
         tools: tools.map((tool) => ({ name: tool.name, parameters: tool.parameters, exclusive: tool.exclusive })),
         guardrails: guardrails.map((guardrail) => ({ name: guardrail.name, stage: guardrail.stage, revision: guardrail.revision })),
-        loop: typeof config.loop === "object" && config.loop && "strategy" in config.loop ? config.loop.strategy : config.loop?.name ?? "single-shot",
+        loop: typeof config.loop === "object" && config.loop && "strategy" in config.loop
+            ? config.loop.strategy
+            : (config.loop?.name ?? "single-shot"),
     });
     return createHash("sha256").update(value).digest("hex");
 }
@@ -43,7 +45,10 @@ export async function loadAgentRunState(checkpoints, ref, ownership) {
     const record = await checkpoints.loadCheckpoint({ namespace: AGENT_RUN_STATE_NAMESPACE, key: ref.runId, ...ownership });
     if (!record)
         throw new AgentRunStateError(`No durable agent run ${ref.runId}`);
-    if (ref.sessionId && record.value && typeof record.value === "object" && record.value.sessionId !== ref.sessionId) {
+    if (ref.sessionId &&
+        record.value &&
+        typeof record.value === "object" &&
+        record.value.sessionId !== ref.sessionId) {
         throw new AgentRunStateError("Agent run session mismatch");
     }
     return { record, state: parseAgentRunState(record.value, record.version) };
@@ -95,7 +100,15 @@ export function parseAgentRunState(value, version) {
     const state = value;
     if (state.schemaVersion !== AGENT_RUN_STATE_SCHEMA_VERSION)
         throw new AgentRunStateError(`Unsupported agent run state schemaVersion ${String(state.schemaVersion)}`);
-    if (!state.agentId || !state.definitionRevision || !state.fingerprint || !state.runId || !state.sessionId || !state.model || !state.status || !state.counters || !state.deadlineAt) {
+    if (!state.agentId ||
+        !state.definitionRevision ||
+        !state.fingerprint ||
+        !state.runId ||
+        !state.sessionId ||
+        !state.model ||
+        !state.status ||
+        !state.counters ||
+        !state.deadlineAt) {
         throw new AgentRunStateError("Malformed agent run state");
     }
     return boundState({ ...state, version }, DEFAULT_MAX_AGENT_RUN_STATE_BYTES);

package/dist/agents.d.ts

@@ -1,4 +1,4 @@
-import type { Agent, AgentConfig, AgentEvent, AgentRunResult, AgentRunResume, AgentRunResumeOptions, AgentRunResumeStreamOptions, AgentRunRef, AgentSession, AgentSessionConfig } from "./contracts.js";
+import type { Agent, AgentConfig, AgentEvent, AgentRunRef, AgentRunResult, AgentRunResume, AgentRunResumeOptions, AgentRunResumeStreamOptions, AgentSession, AgentSessionConfig } from "./contracts.js";
 export declare function createAgent(config: AgentConfig): Agent;
 export declare function createAgentSession(config: AgentSessionConfig & {
     readonly agent: Agent;

package/dist/agents.js

@@ -1,23 +1,23 @@
-import { AgentRunError, AgentRunStateError, DEFAULT_MAX_PENDING_STEER_BYTES, DEFAULT_MAX_PENDING_STEERS, } from "./contracts.js";
 import { resolveLoop, resolveToolConcurrency } from "./agent-loops.js";
-import { createId } from "./ids.js";
-import { assertGuardrailsAllowed, GuardrailError, runGuardrails } from "./guardrails.js";
-import { createProviderTurnMetadata, readProviderHttpStatus } from "./observability.js";
+import { agentFingerprint, initialAgentRunState, loadAgentRunState, publicState, saveAgentRunState, validateRunStateOptions, } from "./agent-run-state.js";
 import { createDefaultCompactionStrategy, isCompactionEntryData } from "./compaction.js";
+import { AgentRunError, AgentRunStateError, DEFAULT_MAX_PENDING_STEER_BYTES, DEFAULT_MAX_PENDING_STEERS } from "./contracts.js";
+import { assertGuardrailsAllowed, GuardrailError, runGuardrails } from "./guardrails.js";
+import { identityTelemetryAttributes, ownershipFromIdentity, resolveRunIdentity } from "./identity.js";
+import { createId } from "./ids.js";
 import { assembleProviderInput } from "./input.js";
+import { createProviderTurnMetadata, readProviderHttpStatus } from "./observability.js";
 import { providerToolCallDeltaContent, reconstructToolCallDeltas } from "./provider-events.js";
 import { createProviderRequestPolicyChain, normalizeProviderRequestPolicyResult } from "./provider-request-policy.js";
-import { assertStructuredOutputRequestSupported, resolveRunProviderOptions } from "./structured-output.js";
-import { errorToErrorInfo, redactAgentEvent, redactProviderRequest, redactRunLedgerRecord, redactSecrets, redactSessionEntry } from "./redaction.js";
-import { composeSystemPrompt, mergeSystemPromptConfig } from "./system-prompts.js";
+import { errorToErrorInfo, redactAgentEvent, redactProviderRequest, redactRunLedgerRecord, redactSecrets, redactSessionEntry, } from "./redaction.js";
 import { createDefaultRetryPolicy, waitForRetry } from "./retry.js";
-import { createMemorySessionStore, createSessionEntry, getSessionBranchEntries, rebuildSessionContext } from "./session-stores.js";
 import { isFlushableRunLedger } from "./run-ledger.js";
-import { createToolRegistry, dispatchToolCall } from "./tools.js";
 import { RunLimitError, RunLimitTracker, resolveRunLimits } from "./run-limits.js";
-import { agentFingerprint, initialAgentRunState, loadAgentRunState, publicState, saveAgentRunState, validateRunStateOptions } from "./agent-run-state.js";
+import { createMemorySessionStore, createSessionEntry, getSessionBranchEntries, rebuildSessionContext, } from "./session-stores.js";
 import { resolveActiveSkills } from "./skills.js";
-import { identityTelemetryAttributes, ownershipFromIdentity, resolveRunIdentity, } from "./identity.js";
+import { assertStructuredOutputRequestSupported, resolveRunProviderOptions } from "./structured-output.js";
+import { composeSystemPrompt, mergeSystemPromptConfig } from "./system-prompts.js";
+import { createToolRegistry, dispatchToolCall } from "./tools.js";
 export function createAgent(config) {
     return {
         config,
@@ -39,7 +39,9 @@ export async function* resumeAgentRunStream(agent, ref, resume, options) {
     const prepared = await prepareAgentRunResume(agent, ref, resume, options, options.signal);
     const subscription = prepared.session.subscribe(options);
     let settled = false;
-    const runPromise = executePreparedAgentRunResume(prepared, options.signal).finally(() => { settled = true; });
+    const runPromise = executePreparedAgentRunResume(prepared, options.signal).finally(() => {
+        settled = true;
+    });
     try {
         for await (const event of subscription) {
             if ("runId" in event && event.runId !== ref.runId)
@@ -58,7 +60,9 @@ export async function* resumeAgentRunStream(agent, ref, resume, options) {
 async function prepareAgentRunResume(agent, ref, resume, options, signal) {
     throwIfAbortedSignal(signal);
     const { record, state } = await loadAgentRunState(options.checkpoints, ref, options.ownership);
-    if (state.definitionRevision !== options.definitionRevision || state.agentId !== (agent.config.id ?? agent.config.name) || state.fingerprint !== agentFingerprint(agent, options.definitionRevision)) {
+    if (state.definitionRevision !== options.definitionRevision ||
+        state.agentId !== (agent.config.id ?? agent.config.name) ||
+        state.fingerprint !== agentFingerprint(agent, options.definitionRevision)) {
         throw new AgentRunStateError("Agent definition revision or fingerprint mismatch on resume");
     }
     if (record.version !== resume.expectedVersion || state.status !== "suspended") {
@@ -211,7 +215,11 @@ class RuntimeAgentSession {
         }
     }
     async resumeDurable(state, runState, ownership, signal) {
-        return this.runInternal(state.input ?? [], { runState, ownership, signal }, state.runId, { options: runState, state, version: state.version });
+        return this.runInternal(state.input ?? [], { runState, ownership, signal }, state.runId, {
+            options: runState,
+            state,
+            version: state.version,
+        });
     }
     async recordDurableDenial(runId, interruption, version, ownership) {
         this.activeLedger = this.agent.config.runLedger;
@@ -229,7 +237,11 @@ class RuntimeAgentSession {
         }
     }
     async runInternal(input, options, runId, resumed) {
-        if (this.agent.config.secure && (options.redactor !== undefined || options.ownership !== undefined || options.validate !== undefined || options.runState !== undefined)) {
+        if (this.agent.config.secure &&
+            (options.redactor !== undefined ||
+                options.ownership !== undefined ||
+                options.validate !== undefined ||
+                options.runState !== undefined)) {
             throw new AgentRunStateError("Secure agent defaults cannot be replaced per run");
         }
         const requestedLimits = options.maxToolRounds === undefined
@@ -316,7 +328,14 @@ class RuntimeAgentSession {
             const { registry, tools } = activeTools(this.agent.config.tools);
             const activeSkills = this.resolveRunSkills(options, tools);
             if (options.model && JSON.stringify(options.model) !== JSON.stringify(this.agent.config.model)) {
-                await this.appendEntry(createSessionEntry({ sessionId: this.id, parentId: this.currentLeafId, runId, kind: "model_change", previousModel: this.agent.config.model, model: options.model }));
+                await this.appendEntry(createSessionEntry({
+                    sessionId: this.id,
+                    parentId: this.currentLeafId,
+                    runId,
+                    kind: "model_change",
+                    previousModel: this.agent.config.model,
+                    model: options.model,
+                }));
             }
             const inputMessages = inputToMessages(input).map((message) => this.redact(message));
             const inputGuardrails = await runGuardrails({
@@ -340,7 +359,9 @@ class RuntimeAgentSession {
                 await this.appendMessage(message, runId);
             await this.autoCompact(runId, options, controller.signal, inputMessages);
             const maxToolRounds = resolvedLimits.maxToolRounds;
-            const systemInstructions = composeSystemPrompt(mergeSystemPromptConfig(this.agent.config.systemPrompt, options.systemPrompt), { base: this.agent.config.instructions });
+            const systemInstructions = composeSystemPrompt(mergeSystemPromptConfig(this.agent.config.systemPrompt, options.systemPrompt), {
+                base: this.agent.config.instructions,
+            });
             const contextProviders = [
                 ...(this.agent.config.context ?? []),
                 // ponytail: skill context after host context; no per-skill token budget yet.
@@ -429,7 +450,7 @@ class RuntimeAgentSession {
                         limits.charge("maxTurns");
                     assembledTurn = false;
                     const policyResult = await this.applyProviderRequestPolicies(request, runId, options, metadata, controller.signal);
-                    const middlewareRequest = await this.agent.config.middleware?.run("provider_request", policyResult.request) ?? policyResult.request;
+                    const middlewareRequest = (await this.agent.config.middleware?.run("provider_request", policyResult.request)) ?? policyResult.request;
                     try {
                         return await this.generateWithRetry(this.redactProviderRequest(middlewareRequest), runId, options, controller.signal, policyResult.secrets, this.activeLoopTurn, recordProviderUsage);
                     }
@@ -468,12 +489,22 @@ class RuntimeAgentSession {
                             return;
                         const pending = durable.state?.pending;
                         if (pending?.call.id === mediatedCall.id && pending.status === "ready") {
-                            await this.persistDurable({ ...durable.state, status: "running", pending: { ...pending, status: "dispatched" }, interruption: undefined });
+                            await this.persistDurable({
+                                ...durable.state,
+                                status: "running",
+                                pending: { ...pending, status: "dispatched" },
+                                interruption: undefined,
+                            });
                             return;
                         }
                         if (!durable.options.interruptBeforeTool)
                             return;
-                        const interruption = { kind: "tool_approval", reason: "Tool side effect requires approval", toolCallId: mediatedCall.id, toolName: mediatedCall.name };
+                        const interruption = {
+                            kind: "tool_approval",
+                            reason: "Tool side effect requires approval",
+                            toolCallId: mediatedCall.id,
+                            toolName: mediatedCall.name,
+                        };
                         throw new AgentRunSuspended(await this.suspendDurable({
                             runId,
                             model,
@@ -508,13 +539,19 @@ class RuntimeAgentSession {
                 const result = await ctx.dispatchToolCall(resumed.state.pending.call);
                 await ctx.appendMessage({
                     role: "tool",
-                    content: [{ type: "tool_result", toolCallId: result.toolCallId, name: result.name, result: result.value, error: result.error }, ...(result.content ?? [])],
+                    content: [
+                        { type: "tool_result", toolCallId: result.toolCallId, name: result.name, result: result.value, error: result.error },
+                        ...(result.content ?? []),
+                    ],
                     metadata: result.metadata,
                 });
             }
             const loopUsage = await loop.run(ctx);
             if (loop.name === "generate-validate-revise" && !artifactFinished) {
-                throw Object.assign(new Error(artifactFailedInfo?.message ?? "artifact loop ended without a validated artifact"), { name: "ArtifactFailed", code: artifactFailedInfo?.code ?? "artifact_failed" });
+                throw Object.assign(new Error(artifactFailedInfo?.message ?? "artifact loop ended without a validated artifact"), {
+                    name: "ArtifactFailed",
+                    code: artifactFailedInfo?.code ?? "artifact_failed",
+                });
             }
             usage = runUsage.value() ?? loopUsage;
             if (usage && this.activeLedger) {
@@ -661,21 +698,22 @@ class RuntimeAgentSession {
         const durable = this.activeDurable;
         if (!durable)
             throw new AgentRunStateError("Durable interruption is not configured");
-        const state = durable.state ?? initialAgentRunState({
-            agent: this.agent,
-            options: durable.options,
-            runId: input.runId,
-            sessionId: this.id,
-            leafId: this.currentLeafId,
-            model: input.model,
-            counters: input.limits.snapshot(),
-            deadlineAt: input.limits.deadlineAt,
-            status: "suspended",
-            interruption: input.interruption,
-            messages: input.messages,
-            pending: input.pending,
-            interruptBeforeTool: durable.options.interruptBeforeTool,
-        });
+        const state = durable.state ??
+            initialAgentRunState({
+                agent: this.agent,
+                options: durable.options,
+                runId: input.runId,
+                sessionId: this.id,
+                leafId: this.currentLeafId,
+                model: input.model,
+                counters: input.limits.snapshot(),
+                deadlineAt: input.limits.deadlineAt,
+                status: "suspended",
+                interruption: input.interruption,
+                messages: input.messages,
+                pending: input.pending,
+                interruptBeforeTool: durable.options.interruptBeforeTool,
+            });
         return this.persistDurable({
             ...state,
             leafId: this.currentLeafId,
@@ -723,7 +761,13 @@ class RuntimeAgentSession {
         await this.rebuildHistory();
     }
     fork(options = {}) {
-        return createAgentSession({ agent: this.agent, id: this.id, store: this.store, leafId: options.leafId ?? this.currentLeafId, metadata: this.metadata });
+        return createAgentSession({
+            agent: this.agent,
+            id: this.id,
+            store: this.store,
+            leafId: options.leafId ?? this.currentLeafId,
+            metadata: this.metadata,
+        });
     }
     async clone(options = {}) {
         const id = options.id ?? randomId("session");
@@ -739,7 +783,13 @@ class RuntimeAgentSession {
             const { id: _oldId, parentId: _oldParentId, sessionId: _oldSessionId, ...rest } = entry;
             await this.store.append({ ...rest, id: nextId, parentId: entry.parentId ? remap.get(entry.parentId) : undefined, sessionId: id });
         }
-        return createAgentSession({ agent: this.agent, id, store: this.store, leafId: branch.length ? remap.get(branch[branch.length - 1].id) : undefined, metadata: this.metadata });
+        return createAgentSession({
+            agent: this.agent,
+            id,
+            store: this.store,
+            leafId: branch.length ? remap.get(branch[branch.length - 1].id) : undefined,
+            metadata: this.metadata,
+        });
     }
     branchReader() {
         // ponytail: prefer the store's readBranchPath (one ancestor-chain query) when present so a
@@ -753,9 +803,7 @@ class RuntimeAgentSession {
         // the resolver entirely; otherwise `RunOptions.providerSource` overrides
         // `AgentConfig.providerSource` for this run. A miss on every source fails
         // closed with `Unknown provider: ${model.provider}` before any provider turn.
-        const provider = this.agent.config.provider ??
-            options.providerSource?.(model) ??
-            this.agent.config.providerSource?.(model);
+        const provider = this.agent.config.provider ?? options.providerSource?.(model) ?? this.agent.config.providerSource?.(model);
         if (!provider)
             throw new Error(`Unknown provider: ${model.provider}`);
         this.activeProvider = provider;
@@ -828,7 +876,10 @@ class RuntimeAgentSession {
                     throw errorFromInfo(info);
                 const context = { sessionId: this.id, runId, attempt, error: info, metadata: retry?.metadata, signal };
                 let decision = await policy.decide(context);
-                const payload = await this.agent.config.middleware?.run("retry", { context, decision }) ?? { context, decision };
+                const payload = (await this.agent.config.middleware?.run("retry", { context, decision })) ?? {
+                    context,
+                    decision,
+                };
                 decision = payload.decision;
                 if (!decision.retry)
                     throw errorFromInfo(info);
@@ -1029,16 +1080,35 @@ class RuntimeAgentSession {
         throwIfAbortedSignal(signal);
         const entries = await this.entries();
         const secrets = options.secrets ?? [];
-        const strategy = options.strategy ?? createDefaultCompactionStrategy({ keepRecentEntries: options.keepRecentEntries, maxSummaryChars: options.maxSummaryChars, secrets });
-        const context = { sessionId: this.id, entries, keepRecentEntries: options.keepRecentEntries, trigger, secrets, metadata: options.metadata, signal };
+        const strategy = options.strategy ??
+            createDefaultCompactionStrategy({ keepRecentEntries: options.keepRecentEntries, maxSummaryChars: options.maxSummaryChars, secrets });
+        const context = {
+            sessionId: this.id,
+            entries,
+            keepRecentEntries: options.keepRecentEntries,
+            trigger,
+            secrets,
+            metadata: options.metadata,
+            signal,
+        };
         this.emit({ type: "compaction_started", sessionId: this.id, runId });
         let result = await strategy.compact(context);
         result = { ...result, summary: redactSecrets(result.summary, secrets) };
-        const payload = await this.agent.config.middleware?.run("compaction", { context, result }) ?? { context, result };
+        const payload = (await this.agent.config.middleware?.run("compaction", { context, result })) ?? {
+            context,
+            result,
+        };
         result = { ...payload.result, summary: redactSecrets(payload.result.summary, secrets) };
         const source = result.entries?.find((entry) => entry.kind === "compaction");
         const data = isCompactionEntryData(source?.data) ? source.data : undefined;
-        const entry = createSessionEntry({ sessionId: this.id, parentId: this.currentLeafId, runId, kind: "compaction", summary: result.summary, data });
+        const entry = createSessionEntry({
+            sessionId: this.id,
+            parentId: this.currentLeafId,
+            runId,
+            kind: "compaction",
+            summary: result.summary,
+            data,
+        });
         await this.appendEntry(entry);
         const finalResult = { ...result, entries: [entry] };
         this.emit({ type: "compaction_finished", sessionId: this.id, runId, summary: finalResult.summary });
@@ -1181,8 +1251,8 @@ class SteerSoftInterrupt extends Error {
     }
 }
 function isSteerSoftInterrupt(error) {
-    return error instanceof SteerSoftInterrupt
-        || (typeof error === "object" && error !== null && error.code === STEER_SOFT_INTERRUPT_CODE);
+    return (error instanceof SteerSoftInterrupt ||
+        (typeof error === "object" && error !== null && error.code === STEER_SOFT_INTERRUPT_CODE));
 }
 function finalAssistantMessage(history) {
     for (let index = history.length - 1; index >= 0; index -= 1) {
@@ -1295,8 +1365,8 @@ function createUsageAccumulator() {
                 if (value !== undefined)
                     sums.set(key, (sums.get(key) ?? 0) + value);
             }
-            const total = usage.totalTokens
-                ?? (usage.inputTokens !== undefined || usage.outputTokens !== undefined
+            const total = usage.totalTokens ??
+                (usage.inputTokens !== undefined || usage.outputTokens !== undefined
                     ? (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0)
                     : undefined);
             if (total !== undefined)

package/dist/cache-helpers.js

@@ -1,5 +1,8 @@
 export function sanitizeCacheKey(value, maxLength) {
-    const key = value?.replace(/[^A-Za-z0-9_.:-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, Math.max(0, maxLength));
+    const key = value
+        ?.replace(/[^A-Za-z0-9_.:-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, Math.max(0, maxLength));
     return key || undefined;
 }
 export function mapCacheRetention(retention, model) {
@@ -37,7 +40,7 @@ export function cacheSavings(usage, model) {
     const cacheRead = model.cost?.cacheRead;
     if (read === undefined || input === undefined || cacheRead === undefined)
         return undefined;
-    return read * Math.max(0, input - cacheRead) / costUnitDivisor(model.cost?.unit);
+    return (read * Math.max(0, input - cacheRead)) / costUnitDivisor(model.cost?.unit);
 }
 export function cacheUsageReport(usage, model) {
     if (!usage)
@@ -48,17 +51,23 @@ export function cacheUsageReport(usage, model) {
         cacheWriteTokens: usage.cacheWriteTokens ?? 0,
         hitRate: cacheHitRate(usage),
         estimatedSavings,
-        currency: estimatedSavings === undefined ? usage.currency : model?.cost?.currency ?? usage.currency,
+        currency: estimatedSavings === undefined ? usage.currency : (model?.cost?.currency ?? usage.currency),
     };
 }
 function resolveBreakpoint(messages, breakpoint) {
     switch (breakpoint.location) {
-        case "system_prompt": return messages.findIndex((message) => message.role === "system");
-        case "tools": return messages.findIndex((message) => message.role === "tool" || message.content.some((block) => block.type === "tool_call" || block.type === "tool_result"));
-        case "stable_context": return messages.findIndex((message) => message.role !== "system");
-        case "last_stable_message": return messages.length > 1 ? messages.length - 2 : messages.length - 1;
-        case "last_user_message": return findLastIndex(messages, (message) => message.role === "user");
-        case "message_id": return messages.findIndex((message) => message.id === breakpoint.messageId);
+        case "system_prompt":
+            return messages.findIndex((message) => message.role === "system");
+        case "tools":
+            return messages.findIndex((message) => message.role === "tool" || message.content.some((block) => block.type === "tool_call" || block.type === "tool_result"));
+        case "stable_context":
+            return messages.findIndex((message) => message.role !== "system");
+        case "last_stable_message":
+            return messages.length > 1 ? messages.length - 2 : messages.length - 1;
+        case "last_user_message":
+            return findLastIndex(messages, (message) => message.role === "user");
+        case "message_id":
+            return messages.findIndex((message) => message.id === breakpoint.messageId);
     }
 }
 function findLastIndex(items, predicate) {

package/dist/checkpoints.js

@@ -61,9 +61,7 @@ export function createMemoryCheckpointStore(options = {}) {
             throwIfAborted(query.signal);
             const offset = decodeCursor(query.cursor);
             const limit = Math.min(Math.max(1, query.limit ?? 100), maxPageSize);
-            const categories = query.category === undefined
-                ? undefined
-                : new Set(Array.isArray(query.category) ? query.category : [query.category]);
+            const categories = query.category === undefined ? undefined : new Set(Array.isArray(query.category) ? query.category : [query.category]);
             const items = [...records.values()]
                 .filter((record) => query.namespace === undefined || record.namespace === query.namespace)
                 .filter((record) => query.keyPrefix === undefined || record.key.startsWith(query.keyPrefix))
@@ -104,14 +102,12 @@ function ownership(input) {
     };
 }
 function ownershipMatches(expected, actual) {
-    return expected.tenantId === actual.tenantId
-        && expected.accountId === actual.accountId
-        && expected.userId === actual.userId;
+    return expected.tenantId === actual.tenantId && expected.accountId === actual.accountId && expected.userId === actual.userId;
 }
 function ownershipFilterMatches(expected, actual) {
-    return (expected.tenantId === undefined || expected.tenantId === actual.tenantId)
-        && (expected.accountId === undefined || expected.accountId === actual.accountId)
-        && (expected.userId === undefined || expected.userId === actual.userId);
+    return ((expected.tenantId === undefined || expected.tenantId === actual.tenantId) &&
+        (expected.accountId === undefined || expected.accountId === actual.accountId) &&
+        (expected.userId === undefined || expected.userId === actual.userId));
 }
 function assertOwnership(expected, actual) {
     if (!ownershipMatches(expected, actual)) {