@arnilo/prism 0.0.96 → 0.1.0

package/dist/providers/openai-primitives.js

@@ -110,12 +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) {
+    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 {
@@ -123,7 +124,9 @@ export function mapOpenAIChatUsage(usage) {
         outputTokens: wire.completion_tokens,
         totalTokens: wire.total_tokens,
         cacheReadTokens: wire.prompt_tokens_details?.cached_tokens ?? wire.prompt_cache_hit_tokens,
-        cacheWriteTokens: wire.prompt_tokens_details?.cache_write_tokens,
+        // Some OpenAI-compatible vendors report cache writes as `cache_write_tokens`,
+        // others as the `cache_creation_input_tokens` variant; accept both.
+        cacheWriteTokens: wire.prompt_tokens_details?.cache_write_tokens ?? wire.prompt_tokens_details?.cache_creation_input_tokens,
     };
 }
 //# sourceMappingURL=openai-primitives.js.map

package/dist/providers/transport.d.ts

@@ -20,6 +20,12 @@ export declare class ProviderTransportError extends Error {
     readonly limitBytes?: number;
     constructor(code: ProviderTransportErrorCode, message: string, limitBytes?: number);
 }
+/** HTTP failure error carrying the status as numeric `code` plus any `Retry-After`
+ *  hint as `retryAfterMs`, so retry policies classify transience and pace retries
+ *  without parsing message text. Both fields flow into `ErrorInfo` via errorToErrorInfo. */
+export declare function httpStatusError(prefix: string, response: Response, bodyText: string): Error;
+/** Parse a `Retry-After` header (delay-seconds or HTTP-date) into milliseconds. */
+export declare function parseRetryAfterMs(value: string | null, now?: number): number | undefined;
 export interface ReadSseEventsOptions extends BoundedStreamLimits {
     readonly signal?: AbortSignal;
 }

package/dist/providers/transport.js

@@ -13,6 +13,27 @@ export class ProviderTransportError extends Error {
         this.limitBytes = limitBytes;
     }
 }
+/** HTTP failure error carrying the status as numeric `code` plus any `Retry-After`
+ *  hint as `retryAfterMs`, so retry policies classify transience and pace retries
+ *  without parsing message text. Both fields flow into `ErrorInfo` via errorToErrorInfo. */
+export function httpStatusError(prefix, response, bodyText) {
+    const error = new Error(`${prefix}: ${response.status} ${bodyText}`);
+    error.code = response.status;
+    const hint = parseRetryAfterMs(response.headers.get("retry-after"));
+    if (hint !== undefined)
+        error.retryAfterMs = hint;
+    return error;
+}
+/** Parse a `Retry-After` header (delay-seconds or HTTP-date) into milliseconds. */
+export function parseRetryAfterMs(value, now = Date.now()) {
+    if (!value)
+        return undefined;
+    const seconds = Number(value);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return seconds * 1000;
+    const date = Date.parse(value);
+    return Number.isNaN(date) ? undefined : Math.max(0, date - now);
+}
 function resolveLimits(options) {
     return {
         maxEventBytes: options?.maxEventBytes ?? DEFAULT_MAX_EVENT_BYTES,

package/dist/providers.d.ts

@@ -2,6 +2,8 @@ import type { AIProvider, ModelConfig, ProviderResolver } from "./contracts.js";
 import { type DuplicateRegistrationOptions } from "./registry-options.js";
 export interface ProviderRegistry {
     register(provider: AIProvider): void;
+    /** Remove a provider; returns false when the id was not registered. */
+    unregister(id: string): boolean;
     get(id: string): AIProvider | undefined;
     resolve(model: Pick<ModelConfig, "provider"> | string): AIProvider;
     list(): readonly AIProvider[];

package/dist/providers.js

@@ -6,6 +6,9 @@ export function createProviderRegistry(providers = [], options = {}) {
             assertCanRegister(byId, provider.id, "provider", provider.id, options.duplicate);
             byId.set(provider.id, provider);
         },
+        unregister(id) {
+            return byId.delete(id);
+        },
         get(id) {
             return byId.get(id);
         },

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

@@ -1,4 +1,7 @@
 const REDACTED = "[REDACTED]";
+// Depth bound matching agent-run-state.ts; hostile deep structures yield a placeholder
+// instead of a stack overflow.
+const MAX_REDACT_DEPTH = 32;
 export function createSecretRedactor(secrets) {
     return { redact: (value) => redactSecrets(value, secrets) };
 }
@@ -17,6 +20,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,23 +34,25 @@ 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;
     };
     // ponytail: active-path WeakSet marks only ancestor cycles as [Circular]; shared
     // references (diamonds) are visited again on separate branches. Map/Set normalize
     // to JSON-shaped output; string keys are redacted like values.
-    const redact = (input, active = new WeakSet()) => {
+    const redact = (input, active = new WeakSet(), depth = 0) => {
         if (typeof input === "string")
             return redactString(input);
         if (input === null || typeof input !== "object")
             return input;
+        if (depth >= MAX_REDACT_DEPTH)
+            return "[MaxDepth]";
         if (input instanceof Date || input instanceof RegExp)
             return input;
         if (ArrayBuffer.isView(input) || input instanceof ArrayBuffer)
@@ -54,18 +62,18 @@ export function redactSecrets(value, secrets) {
         active.add(input);
         try {
             if (Array.isArray(input))
-                return input.map((item) => redact(item, active));
+                return input.map((item) => redact(item, active, depth + 1));
             if (input instanceof Map) {
                 const out = {};
                 for (const [key, item] of input)
-                    assignKey(out, redactKey(key), redact(item, active));
+                    assignKey(out, redactKey(key), redact(item, active, depth + 1));
                 return out;
             }
             if (input instanceof Set)
-                return [...input].map((item) => redact(item, active));
+                return [...input].map((item) => redact(item, active, depth + 1));
             const out = {};
             for (const [key, item] of Object.entries(input))
-                assignKey(out, redactKey(key), redact(item, active));
+                assignKey(out, redactKey(key), redact(item, active, depth + 1));
             return out;
         }
         finally {
@@ -76,18 +84,21 @@ export function redactSecrets(value, secrets) {
 }
 export function errorToErrorInfo(error, secrets = []) {
     const code = readErrorCode(error);
+    const retry = readRetryAfterMs(error);
+    const retryAfter = retry !== undefined ? { retryAfterMs: retry } : {};
     if (error instanceof Error) {
         return {
             name: error.name,
             message: redactSecrets(error.message, secrets),
             code,
+            ...retryAfter,
             cause: error.cause ? redactSecrets(String(error.cause), secrets) : undefined,
         };
     }
     if (error && typeof error === "object" && "message" in error) {
-        return { message: redactSecrets(String(error.message), secrets), code };
+        return { message: redactSecrets(String(error.message), secrets), code, ...retryAfter };
     }
-    return { message: redactSecrets(String(error), secrets), code };
+    return { message: redactSecrets(String(error), secrets), code, ...retryAfter };
 }
 function readErrorCode(error) {
     if (!error || typeof error !== "object" || !("code" in error))
@@ -95,4 +106,10 @@ function readErrorCode(error) {
     const code = error.code;
     return typeof code === "string" || typeof code === "number" ? code : undefined;
 }
+function readRetryAfterMs(error) {
+    if (!error || typeof error !== "object" || !("retryAfterMs" in error))
+        return undefined;
+    const value = error.retryAfterMs;
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
 //# sourceMappingURL=redaction.js.map

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/retry.d.ts

@@ -5,6 +5,11 @@ export interface DefaultRetryPolicyOptions {
     readonly baseDelayMs?: number;
     readonly maxDelayMs?: number;
     readonly transientCodes?: readonly (string | number)[];
+    /** Symmetric jitter fraction applied to computed delays (default 0.25 → ±25%).
+     *  Prevents thundering-herd retries under a shared outage. Set 0 to disable. */
+    readonly jitter?: number;
+    /** Random source for jitter (tests); defaults to Math.random. */
+    readonly random?: () => number;
 }
 export declare function createDefaultRetryPolicy(options?: DefaultRetryPolicyOptions): RetryPolicy;
 export declare function isTransientErrorInfo(error: ErrorInfo, transientCodes?: ReadonlySet<string | number>): boolean;

package/dist/retry.js

@@ -22,13 +22,20 @@ export function createDefaultRetryPolicy(options = {}) {
     const maxAttempts = Math.max(1, options.maxAttempts ?? 3);
     const baseDelayMs = Math.max(0, options.baseDelayMs ?? 100);
     const maxDelayMs = Math.max(baseDelayMs, options.maxDelayMs ?? 1000);
+    const jitter = Math.min(1, Math.max(0, options.jitter ?? 0.25));
+    const random = options.random ?? Math.random;
     const transientCodes = new Set([...TRANSIENT_CODES, ...(options.transientCodes ?? [])]);
     return {
         name: options.name ?? "default-retry",
         decide(context) {
             if (context.signal?.aborted || context.attempt >= maxAttempts || !isTransientErrorInfo(context.error, transientCodes))
                 return { retry: false };
-            return { retry: true, delayMs: Math.min(maxDelayMs, baseDelayMs * 2 ** Math.max(0, context.attempt - 1)) };
+            // Provider backpressure hint (Retry-After) wins over computed backoff, always
+            // capped at maxDelayMs so a hostile/huge hint cannot pin a run.
+            const hint = context.error.retryAfterMs;
+            const base = Math.min(hint !== undefined && Number.isFinite(hint) && hint >= 0 ? hint : baseDelayMs * 2 ** Math.max(0, context.attempt - 1), maxDelayMs);
+            const delayMs = jitter > 0 ? Math.round(base * (1 - jitter + random() * 2 * jitter)) : base;
+            return { retry: true, delayMs };
         },
     };
 }

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,31 +78,52 @@ 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 });
             break;
         }
-        case "steer":
-            throw new Error("steer is not supported by the current AgentSession runtime");
+        case "steer": {
+            const input = stringParam(request.params, "input") ?? stringParam(request.params, "prompt");
+            if (!input)
+                throw new Error("steer requires params.input");
+            const softInterrupt = request.params?.softInterrupt === true;
+            state.current.steer(input, softInterrupt ? { softInterrupt: true } : undefined);
+            write(stdout, {
+                id: request.id,
+                ok: true,
+                result: { sessionId: state.current.id },
+            });
+            break;
+        }
         case "abort":
             state.current.abort(stringParam(request.params, "reason"));
             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() } });
@@ -141,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": {
@@ -234,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.d.ts

@@ -6,9 +6,15 @@ export declare const HARD_LEDGER_BATCH_BYTES: number;
 export declare const DEFAULT_LEDGER_BATCH_DELAY_MS = 25;
 export declare const HARD_LEDGER_BATCH_DELAY_MS = 60000;
 export interface BatchedRunLedgerOptions {
+    /** Flush triggers, not write grouping: a pending flush fires once the buffer reaches
+     *  this many entries. Writes still go to the target one at a time (RunLedger has no
+     *  batch append); these bounds shape flush *timing*, not per-write coalescing. */
     readonly maxBatchEntries?: number;
+    /** Flush trigger: pending flush fires once buffered bytes reach this bound. */
     readonly maxBatchBytes?: number;
+    /** Backpressure bound: enqueue flushes synchronously before exceeding this. */
     readonly maxBufferedEntries?: number;
+    /** Backpressure bound (bytes): enqueue flushes synchronously before exceeding this. */
     readonly maxBufferedBytes?: number;
     readonly maxDelayMs?: number;
     readonly durability?: RunLedgerDurability;

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) => {
@@ -52,20 +58,14 @@ export function createBatchedRunLedger(target, options = {}) {
     const flush = () => {
         cancelTimer();
         const operation = flushChain.then(async () => {
-            let entries = 0;
-            let bytes = 0;
+            // One write per record — RunLedger has no batch append API. maxBatchEntries/
+            // maxBatchBytes only decide when a flush fires (see enqueue), never how writes group.
             while (queue.length) {
                 const item = queue[0];
-                if (entries && (entries >= maxBatchEntries || bytes + item.bytes > maxBatchBytes)) {
-                    entries = 0;
-                    bytes = 0;
-                }
-                await write(item);
+                await write(item); // shifts only after success — a failed write stays buffered for retry
                 queue.shift();
                 bufferedBytes -= item.bytes;
                 flushed += 1;
-                entries += 1;
-                bytes += item.bytes;
             }
             return status();
         });
@@ -83,7 +83,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,6 @@
-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";
 /** Build an opt-in agent whose security-critical defaults cannot be replaced per run. */
@@ -27,6 +28,10 @@ export function createSecureAgent(options) {
             throw new TypeError(`Secure agent tool ${tool.name} requires a non-empty parameters schema`);
     }
     resolveRunLimits(options.limits);
+    if (options.identity) {
+        assertIdentityActive(options.identity);
+        assertIdentityMatchesOwnership(options.identity, options.ownership);
+    }
     const runState = Object.freeze({ ...options.runState, definitionRevision: options.definitionRevision, interruptBeforeTool: true });
     validateRunStateOptions(runState);
     const config = Object.freeze({
@@ -38,6 +43,7 @@ export function createSecureAgent(options) {
         permission: options.permission,
         trust: options.trust,
         ownership: Object.freeze({ ...options.ownership }),
+        ...(options.identity ? { identity: Object.freeze({ ...options.identity, scopes: Object.freeze([...options.identity.scopes]) }) } : {}),
         limits: Object.freeze({ ...options.limits }),
         guardrails: freezeGuardrails(options.guardrails),
         runState,
@@ -46,7 +52,7 @@ export function createSecureAgent(options) {
     return createAgent(config);
 }
 function withoutSecureFields(options) {
-    const { tools: _tools, toolArgumentValidator: _validator, redactor: _redactor, permission: _permission, trust: _trust, ownership: _ownership, limits: _limits, guardrails: _guardrails, definitionRevision: _revision, runState: _runState, ...config } = options;
+    const { tools: _tools, toolArgumentValidator: _validator, redactor: _redactor, permission: _permission, trust: _trust, ownership: _ownership, identity: _identity, limits: _limits, guardrails: _guardrails, definitionRevision: _revision, runState: _runState, ...config } = options;
     return config;
 }
 function freezeGuardrails(guardrails) {

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, SessionBranchRead, BranchReader, SessionEntry, 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;
@@ -24,4 +24,9 @@ export declare function getSessionBranchEntries(entries: readonly SessionEntry[]
 export declare function listSessionBranches(entries: readonly SessionEntry[]): readonly SessionBranch[];
 export declare function rebuildSessionContext(reader: BranchReader, query: SessionBranchRead): Promise<SessionContextSnapshot>;
 export declare function rebuildSessionContext(entries: readonly SessionEntry[], options?: SessionBranchOptions): SessionContextSnapshot;
-export declare function createMemorySessionStore(initialEntries?: readonly SessionEntry[]): SessionStore;
+export type MemorySessionSearchMode = "linear" | "unsupported";
+export interface CreateMemorySessionStoreOptions {
+    /** Default `"linear"`: capped in-process scan. `"unsupported"`: typed throw. */
+    readonly sessionSearchMode?: MemorySessionSearchMode;
+}
+export declare function createMemorySessionStore(initialEntries?: readonly SessionEntry[], options?: CreateMemorySessionStoreOptions): SessionStore;