@arnilo/prism 0.0.14 → 0.0.16

package/dist/node/agent-definitions.js

@@ -1,13 +1,12 @@
+import { readdir, readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
-import { readFile } from "node:fs/promises";
-import { readdir, stat } from "node:fs/promises";
-import { parseSkillFile, splitFrontmatter } from "../contribution-parsing.js";
 import { resolveAgentDefinition } from "../agent-definitions.js";
+import { parseSkillFile, splitFrontmatter } from "../contribution-parsing.js";
 import { assertPermission, isTrusted } from "../security.js";
-import { isPathInsideReal } from "./trust.js";
-import { readOptionalFile } from "./contribution-discovery.js";
 import { createSkillRegistry } from "../skills.js";
 import { isNodeErrorCode } from "./config.js";
+import { readOptionalFile } from "./contribution-discovery.js";
+import { isPathInsideReal } from "./trust.js";
 const defaultInclude = {
     systemPrompt: true,
     agentPrompt: true,
@@ -288,7 +287,13 @@ function resolveSkillContexts(skills, contextProviders) {
 function collectMetadata(front) {
     const metadata = {};
     for (const [key, value] of front) {
-        if (key !== "name" && key !== "description" && key !== "model" && key !== "tools" && key !== "skills" && key !== "context" && key !== "instructions") {
+        if (key !== "name" &&
+            key !== "description" &&
+            key !== "model" &&
+            key !== "tools" &&
+            key !== "skills" &&
+            key !== "context" &&
+            key !== "instructions") {
             metadata[key] = value;
         }
     }
@@ -305,7 +310,10 @@ function getStringList(front, key) {
     if (Array.isArray(value))
         return value.map(String);
     if (typeof value === "string")
-        return value.split(",").map((s) => s.trim()).filter(Boolean);
+        return value
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean);
     return undefined;
 }
 function bodyAsInstructions(text, path) {
@@ -348,7 +356,7 @@ async function readOptional(read, path) {
 const NAME_RE = /^[A-Za-z0-9 _-]+$/;
 function parentDirName(path) {
     const parts = path.split(/[/\\]+/).filter(Boolean);
-    return parts.length >= 2 ? parts[parts.length - 2] : parts[parts.length - 1] ?? "";
+    return parts.length >= 2 ? parts[parts.length - 2] : (parts[parts.length - 1] ?? "");
 }
 /** Parse a `CONTEXT.md` into a static {@link ContextProvider}. The markdown
  *  body becomes the context block content; frontmatter `name` overrides the

package/dist/node/contribution-discovery.d.ts

@@ -1,6 +1,5 @@
 import type { ContributionFileKind, DiscoveredContribution } from "../contracts.js";
-import type { PermissionPolicy } from "../security.js";
-import type { TrustPolicy } from "../security.js";
+import type { PermissionPolicy, TrustPolicy } from "../security.js";
 export interface DiscoveryOptions {
     readonly kinds: readonly ContributionFileKind[];
     /** Workspace root. Scans `<root>/.agents/<kind>s/<name>/`. Gated by `trust`. */

package/dist/node/contribution-discovery.js

@@ -1,10 +1,10 @@
 import { readdir, readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { isJsonObject } from "../config.js";
-import { assertPermission } from "../security.js";
-import { isPathInsideReal } from "./trust.js";
 import { parseSkillFile } from "../contribution-parsing.js";
+import { assertPermission } from "../security.js";
 import { isNodeErrorCode } from "./config.js";
+import { isPathInsideReal } from "./trust.js";
 /**
  * Discover contributions on disk. Scans the workspace `.agents/` tree only;
  * no global root. One `readdir` per kind-root; no `import()`. Inert output —
@@ -72,7 +72,7 @@ async function readEntry(dir, fallbackName, kind, origin) {
             return readManifestEntry(dir, fallbackName, kind, origin);
     }
 }
-async function readSkillEntry(dir, fallbackName, origin) {
+async function readSkillEntry(dir, _fallbackName, origin) {
     const path = join(dir, "SKILL.md");
     if (!(await isPathInsideReal(dir, path)))
         return undefined;

package/dist/node/session-store-jsonl.js

@@ -1,6 +1,6 @@
-import { mkdir, readFile, appendFile } from "node:fs/promises";
+import { appendFile, mkdir, readFile } from "node:fs/promises";
 import { dirname } from "node:path";
-import { SESSION_APPEND_CONFLICT_CODE, SessionAppendConflictError, SessionSearchUnsupportedError, isSessionEntryKind, SESSION_ENTRY_SCHEMA_VERSION, } from "../contracts.js";
+import { isSessionEntryKind, SESSION_APPEND_CONFLICT_CODE, SESSION_ENTRY_SCHEMA_VERSION, SessionAppendConflictError, SessionSearchUnsupportedError, } from "../contracts.js";
 import { isNodeErrorCode } from "./config.js";
 export function createJsonlSessionStore(pathOrOptions) {
     const options = typeof pathOrOptions === "string" ? { path: pathOrOptions, createDirectory: true } : pathOrOptions;
@@ -93,7 +93,10 @@ function parseEntry(line, lineNumber) {
 }
 function validateSessionEntry(value, lineNumber, raw) {
     if (!isBasicSessionEntry(value)) {
-        return { ok: false, error: { line: lineNumber, message: "Invalid session entry: expected object with id, sessionId, timestamp, and kind", raw } };
+        return {
+            ok: false,
+            error: { line: lineNumber, message: "Invalid session entry: expected object with id, sessionId, timestamp, and kind", raw },
+        };
     }
     const entry = value;
     if (entry.parentId !== undefined && typeof entry.parentId !== "string") {
@@ -149,10 +152,10 @@ function isBasicSessionEntry(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return false;
     const entry = value;
-    return typeof entry.id === "string"
-        && typeof entry.sessionId === "string"
-        && typeof entry.timestamp === "string"
-        && typeof entry.kind === "string";
+    return (typeof entry.id === "string" &&
+        typeof entry.sessionId === "string" &&
+        typeof entry.timestamp === "string" &&
+        typeof entry.kind === "string");
 }
 function isMessage(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))

package/dist/node/settings.d.ts

@@ -1,6 +1,6 @@
 import { type ConfigLayer } from "../config.js";
-import { type NodeConfigFile } from "./config.js";
 import type { SettingsProvider } from "../contracts.js";
+import { type NodeConfigFile } from "./config.js";
 export type NodeSettingsFile = NodeConfigFile;
 export declare function defaultUserSettingsPath(appName?: string): string;
 export declare function readSettingsFile(path: string): Promise<ConfigLayer["config"]>;

package/dist/node/settings.js

@@ -1,8 +1,8 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { mergeConfigLayers } from "../config.js";
-import { readConfigFile, isNodeErrorCode } from "./config.js";
 import { createStaticSettingsProvider } from "../settings.js";
+import { isNodeErrorCode, readConfigFile } from "./config.js";
 export function defaultUserSettingsPath(appName = "prism") {
     return join(homedir(), ".config", appName, "settings.json");
 }

package/dist/node/system-project-prompts.js

@@ -14,10 +14,8 @@ import { readOptionalFile } from "./contribution-discovery.js";
  *  singletons don't fit `discoverContributions`' named-subdir scanner, so this is a
  *  sibling loader mirroring `src/node/instruction-injectors.ts`'s per-concern adapter shape. */
 export async function loadSystemPromptFiles(options) {
-    const agentsPath = options.agentsMdPath
-        ?? (options.workspaceRoot !== undefined ? join(options.workspaceRoot, "AGENTS.md") : undefined);
-    const systemPath = options.systemMdPath
-        ?? (options.globalRoot !== undefined ? join(options.globalRoot, ".prism", "agent", "SYSTEM.md") : undefined);
+    const agentsPath = options.agentsMdPath ?? (options.workspaceRoot !== undefined ? join(options.workspaceRoot, "AGENTS.md") : undefined);
+    const systemPath = options.systemMdPath ?? (options.globalRoot !== undefined ? join(options.globalRoot, ".prism", "agent", "SYSTEM.md") : undefined);
     const out = [];
     if (systemPath !== undefined) {
         const layer = await readSystemFile(systemPath, options.permission);

package/dist/node/trust.js

@@ -1,5 +1,5 @@
-import { isAbsolute, relative, resolve, dirname, basename, join } from "node:path";
 import { realpath } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { isNodeErrorCode } from "./config.js";
 export function isPathInside(root, target) {
     const from = resolve(root);

package/dist/persistence-lifecycle.js

@@ -64,9 +64,7 @@ export function createMemoryPersistenceLifecycle() {
         async applyRetention(input) {
             throwIfAborted(input.signal);
             assertOwnership(input);
-            const held = new Set([...holds.values()]
-                .filter((hold) => sameOwnership(input, hold) && hold.resourceKind === "session")
-                .map((hold) => hold.resourceId));
+            const held = new Set([...holds.values()].filter((hold) => sameOwnership(input, hold) && hold.resourceKind === "session").map((hold) => hold.resourceId));
             const candidates = input.candidates ?? [];
             const deletedIds = [];
             const skippedHeld = [];

package/dist/provider-events.d.ts

@@ -10,6 +10,7 @@ export declare function providerToolCallDelta(delta: {
     readonly argumentsText?: string;
 }): ProviderEvent;
 export declare function providerToolCallDeltaContent(delta: Omit<ToolCallDeltaContent, "type">): ToolCallDeltaContent;
+export declare function providerContinuationRequired(cursor: string, reason?: string): ProviderEvent;
 export declare function reconstructToolCallDeltas(events: readonly ProviderEvent[]): readonly ToolCallContent[];
 export declare function providerUsage(usage: Usage): ProviderEvent;
 export declare function providerDone(usage?: Usage): ProviderEvent;

package/dist/provider-events.js

@@ -18,6 +18,9 @@ export function providerToolCallDelta(delta) {
 export function providerToolCallDeltaContent(delta) {
     return { type: "tool_call_delta", ...delta };
 }
+export function providerContinuationRequired(cursor, reason) {
+    return { type: "continuation_required", cursor, reason };
+}
 export function reconstructToolCallDeltas(events) {
     const partials = new Map();
     for (const event of events) {
@@ -32,7 +35,9 @@ export function reconstructToolCallDeltas(events) {
             partial.argumentsText += event.argumentsText;
         partials.set(event.index, partial);
     }
-    return [...partials.entries()].sort(([a], [b]) => a - b).map(([index, partial]) => {
+    return [...partials.entries()]
+        .sort(([a], [b]) => a - b)
+        .map(([index, partial]) => {
         if (!partial.id || !partial.name) {
             throw new ProviderTransportError("incomplete_delta", `Incomplete tool call delta at index ${index}`);
         }

package/dist/provider-request-policy.js

@@ -50,10 +50,9 @@ export function mergeProviderRequestOptions(base, patch) {
         cache: {
             ...base.cache,
             ...patch.cache,
-            breakpoints: base.cache?.breakpoints || patch.cache?.breakpoints ? [
-                ...(base.cache?.breakpoints ?? []),
-                ...(patch.cache?.breakpoints ?? []),
-            ] : undefined,
+            breakpoints: base.cache?.breakpoints || patch.cache?.breakpoints
+                ? [...(base.cache?.breakpoints ?? []), ...(patch.cache?.breakpoints ?? [])]
+                : undefined,
         },
     };
 }

package/dist/providers/media.d.ts

@@ -1,5 +1,5 @@
+import { type MediaContentBlock, type ModelInputCapability, type ResolvedMediaContent, type ResolveMediaContentOptions } from "../content.js";
 import type { AudioContent, ContentBlock, DocumentContent, FileContent, JsonObject, Message, ModelCapabilities, ModelConfig } from "../contracts.js";
-import { type MediaContentBlock, type ModelInputCapability, type ResolveMediaContentOptions, type ResolvedMediaContent } from "../content.js";
 /** Default upload-cache entry cap per provider media session. */
 export declare const DEFAULT_PROVIDER_UPLOAD_CACHE_ENTRIES = 32;
 /** Inline OpenAI file_data ceiling before preferring Files API upload. */

package/dist/providers/openai-compatible.js

@@ -1,8 +1,8 @@
 import { resolveCredentialValue } from "../credentials.js";
 import { providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, toolCallFromArgumentsText, } from "../provider-events.js";
-import { assertOpenAIChatMessage, applyOpenAIChatStructuredOutput, mapOpenAIChatUsage, serializeOpenAIChatMessage, serializeOpenAITool, } from "./openai-primitives.js";
-import { ProviderTransportError, readBoundedResponseText, readSseData, } from "./transport.js";
 import { assertStructuredOutputRequestSupported } from "../structured-output.js";
+import { applyOpenAIChatStructuredOutput, assertOpenAIChatMessage, mapOpenAIChatUsage, serializeOpenAIChatMessage, serializeOpenAITool, } from "./openai-primitives.js";
+import { ProviderTransportError, readBoundedResponseText, readSseData } from "./transport.js";
 export function createOpenAICompatibleProvider(options) {
     const providerId = options.id ?? "openai-compatible";
     return {
@@ -18,8 +18,7 @@ export function createOpenAICompatibleProvider(options) {
             try {
                 const url = typeof options.chatCompletionsUrl === "function"
                     ? options.chatCompletionsUrl(request)
-                    : options.chatCompletionsUrl
-                        ?? `${options.baseUrl.replace(/\/$/, "")}/chat/completions`;
+                    : (options.chatCompletionsUrl ?? `${options.baseUrl.replace(/\/$/, "")}/chat/completions`);
                 const authStyle = options.authStyle ?? "bearer";
                 const headers = {
                     ...Object.fromEntries(Object.entries(request.options?.headers ?? {}).filter((entry) => typeof entry[1] === "string")),

package/dist/providers/openai-primitives.js

@@ -110,13 +110,13 @@ export function mapOpenAIChatUsage(usage) {
     if (!usage || typeof usage !== "object" || Array.isArray(usage))
         return undefined;
     const wire = usage;
-    if (wire.prompt_tokens === undefined
-        && wire.completion_tokens === undefined
-        && wire.total_tokens === undefined
-        && wire.prompt_cache_hit_tokens === undefined
-        && wire.prompt_tokens_details?.cached_tokens === undefined
-        && wire.prompt_tokens_details?.cache_write_tokens === undefined
-        && wire.prompt_tokens_details?.cache_creation_input_tokens === undefined) {
+    if (wire.prompt_tokens === undefined &&
+        wire.completion_tokens === undefined &&
+        wire.total_tokens === undefined &&
+        wire.prompt_cache_hit_tokens === undefined &&
+        wire.prompt_tokens_details?.cached_tokens === undefined &&
+        wire.prompt_tokens_details?.cache_write_tokens === undefined &&
+        wire.prompt_tokens_details?.cache_creation_input_tokens === undefined) {
         return undefined;
     }
     return {

package/dist/redaction.d.ts

@@ -8,5 +8,6 @@ export declare function redactAgentEvent(event: AgentEvent, redactor?: SecretRed
 export declare function redactSessionEntry(entry: SessionEntry, redactor?: SecretRedactor): SessionEntry;
 export declare function redactProviderRequest(request: ProviderRequest, redactor?: SecretRedactor): ProviderRequest;
 export declare function redactRunLedgerRecord<T extends RunLedgerRecord>(record: T, redactor?: SecretRedactor): T;
+export declare function resolveRedactor(redactor?: SecretRedactor, secrets?: readonly (string | undefined)[]): SecretRedactor | undefined;
 export declare function redactSecrets<T>(value: T, secrets: readonly (string | undefined)[]): T;
 export declare function errorToErrorInfo(error: unknown, secrets?: readonly (string | undefined)[]): ErrorInfo;

package/dist/redaction.js

@@ -17,6 +17,9 @@ export function redactProviderRequest(request, redactor) {
 export function redactRunLedgerRecord(record, redactor) {
     return redactor?.redact(record) ?? record;
 }
+export function resolveRedactor(redactor, secrets) {
+    return redactor ?? (secrets?.some((secret) => Boolean(secret)) ? createSecretRedactor(secrets) : undefined);
+}
 export function redactSecrets(value, secrets) {
     const needles = secrets.filter((secret) => Boolean(secret));
     if (needles.length === 0)
@@ -28,12 +31,12 @@ export function redactSecrets(value, secrets) {
         return String(key);
     };
     const assignKey = (target, key, value) => {
-        if (!Object.prototype.hasOwnProperty.call(target, key)) {
+        if (!Object.hasOwn(target, key)) {
             target[key] = value;
             return;
         }
         let suffix = 2;
-        while (Object.prototype.hasOwnProperty.call(target, `${key}__${suffix}`))
+        while (Object.hasOwn(target, `${key}__${suffix}`))
             suffix += 1;
         target[`${key}__${suffix}`] = value;
     };

package/dist/resources.d.ts

@@ -1,6 +1,6 @@
-import { type PrismManifest } from "./manifests.js";
-import type { JsonObject, ResourceLoader, ResourceLoadContext } from "./contracts.js";
 import { type MediaContentBounds } from "./content.js";
+import type { JsonObject, ResourceLoadContext, ResourceLoader } from "./contracts.js";
+import { type PrismManifest } from "./manifests.js";
 export declare function loadTextResource(loader: ResourceLoader, uri: string, context?: ResourceLoadContext): Promise<string>;
 export declare function loadJsonResource(loader: ResourceLoader, uri: string, context?: ResourceLoadContext): Promise<JsonObject>;
 export declare function loadManifestResource(loader: ResourceLoader, uri: string, context?: ResourceLoadContext): Promise<PrismManifest>;

package/dist/resources.js

@@ -1,6 +1,6 @@
-import { parsePrismManifest } from "./manifests.js";
 import { assertJsonObject } from "./config.js";
-import { DEFAULT_MAX_MEDIA_ITEM_BYTES, loadBoundedBinaryResource, } from "./content.js";
+import { DEFAULT_MAX_MEDIA_ITEM_BYTES, loadBoundedBinaryResource } from "./content.js";
+import { parsePrismManifest } from "./manifests.js";
 import { assertPermission, assertTrusted } from "./security.js";
 export async function loadTextResource(loader, uri, context) {
     await assertTrusted(context?.trust, { kind: "resource", target: uri, capability: "load", metadata: context?.metadata });

package/dist/rpc.js

@@ -1,6 +1,6 @@
 import { createInterface } from "node:readline";
-import { errorToErrorInfo } from "./redaction.js";
 import { resolveInstructionInjectors } from "./instruction-injection.js";
+import { errorToErrorInfo } from "./redaction.js";
 export async function runRpcServer(options) {
     const first = options.createSession();
     const state = {
@@ -58,7 +58,11 @@ async function handleRequest(request, state, stdout, activeRuns) {
             const session = state.current;
             const existing = activeRuns.get(session.id);
             if (existing) {
-                write(stdout, { id: request.id, ok: false, error: errorToErrorInfo(new Error(`Session ${session.id} already has an active run for request ${existing.requestId}`)) });
+                write(stdout, {
+                    id: request.id,
+                    ok: false,
+                    error: errorToErrorInfo(new Error(`Session ${session.id} already has an active run for request ${existing.requestId}`)),
+                });
                 return;
             }
             // ponytail: Phase 30 — resolve run options (incl. instructionInjectors names) BEFORE opening the
@@ -74,9 +78,11 @@ async function handleRequest(request, state, stdout, activeRuns) {
                     await events;
                 }
                 write(stdout, { id: request.id, ok: true, result: { sessionId: session.id } });
-            })().catch((error) => {
+            })()
+                .catch((error) => {
                 write(stdout, { id: request.id, ok: false, error: errorToErrorInfo(error) });
-            }).finally(() => {
+            })
+                .finally(() => {
                 activeRuns.delete(session.id);
             });
             activeRuns.set(session.id, { requestId: request.id, promise });
@@ -100,16 +106,24 @@ async function handleRequest(request, state, stdout, activeRuns) {
             write(stdout, { id: request.id, ok: true, result: { sessionId: state.current.id } });
             break;
         case "state":
-            write(stdout, { id: request.id, ok: true, result: {
+            write(stdout, {
+                id: request.id,
+                ok: true,
+                result: {
                     sessionId: state.current.id,
                     leafId: state.current.leafId,
                     handleId: state.currentHandleId,
                     // ponytail: `sessions` kept as a backward-compatible handle-id string list (== sessionId
                     // for the initial session and clones); `handles` is the branch-handle detail view.
                     sessions: [...state.sessions.keys()],
-                    handles: [...state.sessions.entries()].map(([handleId, session]) => ({ handleId, sessionId: session.id, leafId: session.leafId })),
+                    handles: [...state.sessions.entries()].map(([handleId, session]) => ({
+                        handleId,
+                        sessionId: session.id,
+                        leafId: session.leafId,
+                    })),
                     model: state.model,
-                } });
+                },
+            });
             break;
         case "messages":
             write(stdout, { id: request.id, ok: true, result: { sessionId: state.current.id, entries: await state.current.entries() } });
@@ -152,7 +166,11 @@ async function handleRequest(request, state, stdout, activeRuns) {
             if (!leafId)
                 throw new Error("checkout requires params.leafId");
             await state.current.checkout(leafId);
-            write(stdout, { id: request.id, ok: true, result: { sessionId: state.current.id, leafId: state.current.leafId, handleId: state.currentHandleId } });
+            write(stdout, {
+                id: request.id,
+                ok: true,
+                result: { sessionId: state.current.id, leafId: state.current.leafId, handleId: state.currentHandleId },
+            });
             break;
         }
         case "command": {
@@ -245,7 +263,22 @@ function isObject(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function isCommand(value) {
-    return typeof value === "string" && ["prompt", "steer", "followUp", "abort", "state", "messages", "setModel", "compact", "switchSession", "forkSession", "cloneSession", "checkout", "command"].includes(value);
+    return (typeof value === "string" &&
+        [
+            "prompt",
+            "steer",
+            "followUp",
+            "abort",
+            "state",
+            "messages",
+            "setModel",
+            "compact",
+            "switchSession",
+            "forkSession",
+            "cloneSession",
+            "checkout",
+            "command",
+        ].includes(value));
 }
 function readRequestId(value) {
     return isObject(value) && (typeof value.id === "string" || typeof value.id === "number") ? value.id : null;

package/dist/run-ledger.js

@@ -32,12 +32,18 @@ export function createBatchedRunLedger(target, options = {}) {
     let flushChain = Promise.resolve();
     let disposed = false;
     const status = () => ({ accepted, flushed, buffered: queue.length });
-    const cancelTimer = () => { if (timer)
-        clearTimeout(timer); timer = undefined; };
+    const cancelTimer = () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = undefined;
+    };
     const schedule = () => {
         if (timer || disposed || queue.length === 0)
             return;
-        timer = setTimeout(() => { timer = undefined; void flush().catch(() => undefined); }, maxDelayMs);
+        timer = setTimeout(() => {
+            timer = undefined;
+            void flush().catch(() => undefined);
+        }, maxDelayMs);
         timer.unref?.();
     };
     const write = (item) => {
@@ -83,7 +89,10 @@ export function createBatchedRunLedger(target, options = {}) {
         queue.push({ ...item, bytes });
         bufferedBytes += bytes;
         accepted += 1;
-        if (durability === "write_through" || queue.length >= maxBatchEntries || bufferedBytes >= maxBatchBytes || (item.kind === "run" && terminal(item.record) && durability === "flush_on_terminal"))
+        if (durability === "write_through" ||
+            queue.length >= maxBatchEntries ||
+            bufferedBytes >= maxBatchBytes ||
+            (item.kind === "run" && terminal(item.record) && durability === "flush_on_terminal"))
             await flush();
         else
             schedule();

package/dist/run-limits.js

@@ -58,9 +58,23 @@ export function resolveRunLimits(agent, run) {
             resolved[name] = base ? Math.min(resolved[name], override[name]) : override[name];
     }
     const maxCost = override?.maxCost ?? base?.maxCost;
-    return Object.freeze({ ...resolved, ...(maxCost ? { maxCost: base?.maxCost && override?.maxCost ? { amount: Math.min(base.maxCost.amount, override.maxCost.amount), currency: base.maxCost.currency === override.maxCost.currency ? base.maxCost.currency : failCurrency() } : maxCost } : {}) });
+    return Object.freeze({
+        ...resolved,
+        ...(maxCost
+            ? {
+                maxCost: base?.maxCost && override?.maxCost
+                    ? {
+                        amount: Math.min(base.maxCost.amount, override.maxCost.amount),
+                        currency: base.maxCost.currency === override.maxCost.currency ? base.maxCost.currency : failCurrency(),
+                    }
+                    : maxCost,
+            }
+            : {}),
+    });
+}
+function failCurrency() {
+    throw new TypeError("Run limit currencies must match when narrowed");
 }
-function failCurrency() { throw new TypeError("Run limit currencies must match when narrowed"); }
 function validateLimits(input) {
     for (const name of LIMIT_NAMES) {
         const value = input[name];
@@ -88,7 +102,20 @@ export class RunLimitTracker {
     constructor(limits, options = {}) {
         this.options = options;
         this.limits = limits;
-        this.counters = { turns: 0, providerAttempts: 0, toolRounds: 0, toolCalls: 0, wallTimeMs: 0, requestBytes: 0, responseBytes: 0, inputTokens: 0, outputTokens: 0, totalTokens: 0, cost: 0, ...options.snapshot };
+        this.counters = {
+            turns: 0,
+            providerAttempts: 0,
+            toolRounds: 0,
+            toolCalls: 0,
+            wallTimeMs: 0,
+            requestBytes: 0,
+            responseBytes: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            totalTokens: 0,
+            cost: 0,
+            ...options.snapshot,
+        };
         for (const [key, value] of Object.entries(this.counters)) {
             if (!Number.isFinite(value) || value < 0 || (key !== "cost" && !Number.isSafeInteger(value))) {
                 throw new TypeError("Run limit snapshot must contain finite non-negative counters");
@@ -104,10 +131,17 @@ export class RunLimitTracker {
         if (remaining === 0)
             this.exceed("maxWallTimeMs", limits.maxWallTimeMs);
     }
-    get breach() { return this.exceeded; }
-    snapshot() { return { ...this.counters, wallTimeMs: Math.min(this.limits.maxWallTimeMs, Math.ceil(performance.now() - this.startedAt)) }; }
-    dispose() { if (this.timer)
-        clearTimeout(this.timer); this.timer = undefined; }
+    get breach() {
+        return this.exceeded;
+    }
+    snapshot() {
+        return { ...this.counters, wallTimeMs: Math.min(this.limits.maxWallTimeMs, Math.ceil(performance.now() - this.startedAt)) };
+    }
+    dispose() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+    }
     charge(limit, delta = 1) {
         if (!Number.isSafeInteger(delta) || delta < 0)
             throw new TypeError("Run limit delta must be a non-negative safe integer");
@@ -130,7 +164,7 @@ export class RunLimitTracker {
             if (value !== undefined && (!Number.isSafeInteger(value) || value < 0))
                 throw new TypeError(`Provider usage ${key} must be a non-negative safe integer`);
         }
-        const total = usage.totalTokens ?? ((usage.inputTokens ?? 0) + (usage.outputTokens ?? 0));
+        const total = usage.totalTokens ?? (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0);
         if (!Number.isSafeInteger(total))
             throw new TypeError("Provider usage totalTokens is invalid");
         this.charge("maxInputTokens", usage.inputTokens ?? 0);
@@ -149,8 +183,13 @@ export class RunLimitTracker {
     }
     exceed(limit, observed) {
         if (!this.exceeded) {
-            const maximum = limit === "maxCost" ? this.limits.maxCost?.amount ?? 0 : this.limits[limit];
-            this.exceeded = { limit, maximum, observed, ...(limit === "maxCost" && this.limits.maxCost ? { currency: this.limits.maxCost.currency } : {}) };
+            const maximum = limit === "maxCost" ? (this.limits.maxCost?.amount ?? 0) : this.limits[limit];
+            this.exceeded = {
+                limit,
+                maximum,
+                observed,
+                ...(limit === "maxCost" && this.limits.maxCost ? { currency: this.limits.maxCost.currency } : {}),
+            };
             this.options.onExceeded?.(this.exceeded);
         }
         if (limit !== "maxWallTimeMs")

package/dist/secure-agent.js

@@ -1,5 +1,5 @@
-import { createAgent } from "./agents.js";
 import { validateRunStateOptions } from "./agent-run-state.js";
+import { createAgent } from "./agents.js";
 import { assertIdentityActive, assertIdentityMatchesOwnership } from "./identity.js";
 import { resolveRunLimits } from "./run-limits.js";
 import { createToolParameterValidator, createToolRegistry } from "./tools.js";

package/dist/security.js

@@ -50,11 +50,16 @@ export function createStaticPermissionPolicy(options) {
             const key = `${request.kind}:${request.target}:${request.action}`;
             if (deny.has(key))
                 return { allowed: false, reason: `Permission denied: ${key}` };
-            return { allowed: allow.size === 0 || allow.has(key), reason: allow.size && !allow.has(key) ? `Permission not allowed: ${key}` : undefined };
+            return {
+                allowed: allow.size === 0 || allow.has(key),
+                reason: allow.size && !allow.has(key) ? `Permission not allowed: ${key}` : undefined,
+            };
         },
     };
 }
 export function denialToErrorInfo(error) {
-    return error instanceof Error ? { name: error.name, message: error.message, code: error.code } : { message: String(error) };
+    return error instanceof Error
+        ? { name: error.name, message: error.message, code: error.code }
+        : { message: String(error) };
 }
 //# sourceMappingURL=security.js.map

package/dist/session-stores.d.ts

@@ -1,4 +1,4 @@
-import { type Message, type SessionBranchRead, type BranchReader, type SessionEntry, type SessionStore } from "./contracts.js";
+import { type BranchReader, type Message, type SessionBranchRead, type SessionEntry, type SessionStore } from "./contracts.js";
 export interface CreateSessionEntryOptions extends Omit<SessionEntry, "id" | "timestamp"> {
     readonly id?: string;
     readonly timestamp?: string;