@arnilo/prism 0.0.1 → 0.0.2

package/dist/agents.js

@@ -1,11 +1,14 @@
+import { resolveLoop } from "./agent-loops.js";
 import { createDefaultCompactionStrategy, isCompactionEntryData } from "./compaction.js";
 import { assembleProviderInput } from "./input.js";
+import { providerToolCallDeltaContent, reconstructToolCallDeltas } from "./provider-events.js";
 import { createProviderRequestPolicyChain, mergeProviderRequestOptions, normalizeProviderRequestPolicyResult } from "./provider-request-policy.js";
-import { errorToErrorInfo, redactAgentEvent, redactProviderRequest, redactSecrets, redactSessionEntry } from "./redaction.js";
+import { errorToErrorInfo, redactAgentEvent, redactProviderRequest, redactRunLedgerRecord, redactSecrets, redactSessionEntry } from "./redaction.js";
 import { composeSystemPrompt, mergeSystemPromptConfig } from "./system-prompts.js";
 import { createDefaultRetryPolicy, waitForRetry } from "./retry.js";
 import { createMemorySessionStore, createSessionEntry, getSessionBranchEntries, rebuildSessionContext } from "./session-stores.js";
 import { createToolRegistry, dispatchToolCall } from "./tools.js";
+import { resolveActiveSkills } from "./skills.js";
 export function createAgent(config) {
     return {
         config,
@@ -27,6 +30,11 @@ class RuntimeAgentSession {
     history = [];
     activeRun;
     activeRedactor;
+    activeProvider;
+    activeLedger;
+    activeOwnership;
+    activeIdempotencyKey;
+    ledgerPromises = [];
     constructor(config) {
         this.id = config.id ?? randomId("session");
         this.agent = config.agent;
@@ -34,8 +42,11 @@ class RuntimeAgentSession {
         this.store = config.store ?? config.agent.config.store ?? createMemorySessionStore();
         this.currentLeafId = config.leafId;
     }
-    subscribe() {
-        const subscriber = new EventSubscriber(() => this.subscribers.delete(subscriber));
+    get leafId() {
+        return this.currentLeafId;
+    }
+    subscribe(options = {}) {
+        const subscriber = new EventSubscriber(this.id, options, () => this.subscribers.delete(subscriber));
         this.subscribers.add(subscriber);
         return subscriber;
     }
@@ -46,16 +57,35 @@ class RuntimeAgentSession {
             this.emit({ type: "error", sessionId: this.id, runId, error: errorToErrorInfo(error) });
             throw error;
         }
-        let usage;
         const controller = new AbortController();
         const cleanupSignal = bridgeAbort(options.signal, controller);
         this.activeRun = controller;
         this.activeRedactor = options.redactor ?? this.agent.config.redactor;
+        this.activeLedger = options.runLedger ?? this.agent.config.runLedger;
+        this.activeOwnership = options.ownership ?? this.agent.config.ownership;
+        this.activeIdempotencyKey = options.idempotencyKey ?? this.agent.config.idempotencyKey;
+        const model = options.model ?? this.agent.config.model;
+        const startedAt = new Date().toISOString();
+        let runError;
         try {
-            this.requireProvider();
+            this.resolveRunProvider(options);
             throwIfAborted(controller.signal);
             this.emit({ type: "agent_started", sessionId: this.id, runId });
+            const startRecord = {
+                id: runId,
+                sessionId: this.id,
+                branchId: this.currentLeafId,
+                model,
+                provider: model.provider,
+                idempotencyKey: this.activeIdempotencyKey,
+                status: "running",
+                startedAt,
+                ...this.activeOwnership,
+            };
+            await this.activeLedger?.appendRun(redactRunLedgerRecord(startRecord, this.activeRedactor));
             await this.rebuildHistory();
+            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 }));
             }
@@ -64,80 +94,127 @@ class RuntimeAgentSession {
                 await this.appendMessage(message, runId);
             await this.autoCompact(runId, options, controller.signal, inputMessages);
             const metadata = { ...this.agent.config.metadata, ...this.metadata, ...options.metadata };
-            const { registry, tools } = activeTools(this.agent.config.tools);
             const maxToolRounds = options.maxToolRounds ?? 1;
-            const toolResults = [];
-            let toolRounds = 0;
-            let nextInput = input;
-            for (let turn = 1;; turn += 1) {
-                throwIfAborted(controller.signal);
-                this.emit({ type: "turn_started", sessionId: this.id, runId, turn });
-                const request = await assembleProviderInput({
+            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.
+                ...activeSkills.flatMap((skill) => skill.context ?? []),
+            ];
+            const providerOptions = mergeProviderRequestOptions(this.agent.config.providerOptions, options.providerOptions);
+            const validate = options.validate ?? this.agent.config.validator;
+            // ponytail: RunOptions.instructionInjectors overrides AgentConfig.instructionInjectors (mirrors validate/loop).
+            const instructionInjectors = options.instructionInjectors ?? this.agent.config.instructionInjectors ?? [];
+            const inputLayout = options.inputLayout ?? this.agent.config.inputLayout;
+            const loop = resolveLoop(options, this.agent.config);
+            // ponytail: LoopContext binds existing private helpers; loop orchestrates only.
+            const ctx = {
+                sessionId: this.id,
+                runId,
+                metadata,
+                signal: controller.signal,
+                history: this.history,
+                input,
+                inputMessages,
+                maxToolRounds,
+                assemble: async (nextInput, toolResults, turn) => assembleProviderInput({
                     model: options.model ?? this.agent.config.model,
                     input: nextInput,
                     history: this.history,
                     summaries: (await this.snapshot()).summaries,
-                    toolResults,
-                    systemInstructions: composeSystemPrompt(mergeSystemPromptConfig(this.agent.config.systemPrompt, options.systemPrompt), { base: this.agent.config.instructions }),
+                    toolResults: toolResults ?? [],
+                    turn,
+                    instructionInjectors,
+                    inputLayout,
+                    systemInstructions,
                     inputBuilder: this.agent.config.inputBuilder,
                     promptBuilder: this.agent.config.promptBuilder,
-                    contextProviders: this.agent.config.context,
-                    skills: this.agent.config.skills ? ("list" in this.agent.config.skills ? this.agent.config.skills.list() : this.agent.config.skills) : undefined,
+                    contextProviders,
+                    skills: activeSkills,
                     tools,
                     resourceLoader: this.agent.config.resourceLoader,
-                    providerOptions: mergeProviderRequestOptions(this.agent.config.providerOptions, options.providerOptions),
+                    providerOptions,
+                    redactor: this.activeRedactor,
                     middleware: this.agent.config.middleware,
                     sessionId: this.id,
                     runId,
                     metadata,
                     signal: controller.signal,
-                });
-                throwIfAborted(controller.signal);
-                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 { content, calls, messageId, started, usage: turnUsage } = await this.generateWithRetry(this.redactProviderRequest(middlewareRequest), runId, options, controller.signal, policyResult.secrets);
-                usage = turnUsage ?? usage;
-                if (turn === 1)
-                    this.history.push(...inputMessages);
-                if (started) {
-                    const message = { id: messageId, role: "assistant", content };
-                    this.history.push(message);
-                    await this.appendMessage(message, runId);
-                    this.emit({ type: "message_finished", sessionId: this.id, runId, message });
-                }
-                this.emit({ type: "turn_finished", sessionId: this.id, runId, turn });
-                if (calls.length === 0 || toolRounds >= maxToolRounds)
-                    break;
-                toolRounds += 1;
-                for (const call of calls) {
-                    const result = await dispatchToolCall({
-                        call,
-                        registry,
-                        context: { sessionId: this.id, runId, toolCallId: call.id, signal: controller.signal, metadata },
-                        middleware: this.agent.config.middleware,
-                        emit: (event) => this.emit(event),
-                        permission: this.agent.config.permission,
-                        redactor: this.activeRedactor,
-                    });
-                    toolResults.push(result);
-                    await this.appendMessage(toolResultMessage(result), runId);
-                    throwIfAborted(controller.signal);
-                }
-                nextInput = [];
+                }),
+                generate: async (request) => {
+                    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;
+                    return this.generateWithRetry(this.redactProviderRequest(middlewareRequest), runId, options, controller.signal, policyResult.secrets);
+                },
+                dispatchToolCall: (call) => dispatchToolCall({
+                    call,
+                    registry,
+                    context: { sessionId: this.id, runId, toolCallId: call.id, signal: controller.signal, metadata },
+                    middleware: this.agent.config.middleware,
+                    emit: (event) => this.emit(event),
+                    permission: this.agent.config.permission,
+                    redactor: this.activeRedactor,
+                    ledger: this.activeLedger,
+                    ownership: this.activeOwnership,
+                    // ponytail: RunOptions wins; array-compose deferred (roadmap: compose-later).
+                    validate,
+                }),
+                appendMessage: (message) => this.appendMessage(message, runId),
+                emit: (event) => this.emit(event),
+            };
+            const usage = await loop.run(ctx);
+            if (usage && this.activeLedger) {
+                const usageRecord = {
+                    id: randomId("usage"),
+                    sessionId: this.id,
+                    runId,
+                    usage,
+                    recordedAt: new Date().toISOString(),
+                    ...this.activeOwnership,
+                };
+                await this.activeLedger.appendUsage(redactRunLedgerRecord(usageRecord, this.activeRedactor));
             }
+            await this.drainLedger();
             this.emit({ type: "agent_finished", sessionId: this.id, runId, usage });
         }
         catch (error) {
-            const info = errorToErrorInfo(error);
-            this.emit({ type: "error", sessionId: this.id, runId, error: info });
+            runError = errorToErrorInfo(error);
+            this.emit({ type: "error", sessionId: this.id, runId, error: runError });
             throw error;
         }
         finally {
             if (this.activeRun === controller)
                 this.activeRun = undefined;
-            this.activeRedactor = undefined;
-            cleanupSignal();
-            this.closeSubscribers();
+            try {
+                await this.drainLedger();
+                if (this.activeLedger) {
+                    const status = controller.signal.aborted ? "aborted" : runError ? "failed" : "succeeded";
+                    const finishRecord = {
+                        id: runId,
+                        sessionId: this.id,
+                        branchId: this.currentLeafId,
+                        model,
+                        provider: model.provider,
+                        idempotencyKey: this.activeIdempotencyKey,
+                        status,
+                        startedAt,
+                        finishedAt: new Date().toISOString(),
+                        abortReason: controller.signal.aborted ? String(controller.signal.reason) : undefined,
+                        error: runError,
+                        ...this.activeOwnership,
+                    };
+                    await this.activeLedger.appendRun(redactRunLedgerRecord(finishRecord, this.activeRedactor));
+                }
+            }
+            finally {
+                this.activeLedger = undefined;
+                this.activeOwnership = undefined;
+                this.activeIdempotencyKey = undefined;
+                this.activeRedactor = undefined;
+                this.activeProvider = undefined;
+                cleanupSignal();
+                this.closeSubscribers();
+            }
         }
     }
     prompt(input, options) {
@@ -152,7 +229,10 @@ class RuntimeAgentSession {
         this.activeRun?.abort(reason);
     }
     async entries() {
-        return getSessionBranchEntries(await this.store.list(this.id), { leafId: this.currentLeafId });
+        const reader = this.branchReader();
+        return reader
+            ? getSessionBranchEntries(reader, { sessionId: this.id, leafId: this.currentLeafId })
+            : getSessionBranchEntries(await this.store.list(this.id), { leafId: this.currentLeafId });
     }
     async checkout(leafId) {
         this.currentLeafId = leafId;
@@ -163,7 +243,11 @@ class RuntimeAgentSession {
     }
     async clone(options = {}) {
         const id = options.id ?? randomId("session");
-        const branch = getSessionBranchEntries(await this.store.list(this.id), { leafId: options.leafId ?? this.currentLeafId });
+        const leafId = options.leafId ?? this.currentLeafId;
+        const reader = this.branchReader();
+        const branch = reader
+            ? await getSessionBranchEntries(reader, { sessionId: this.id, leafId })
+            : getSessionBranchEntries(await this.store.list(this.id), { leafId });
         const remap = new Map();
         for (const entry of branch) {
             const nextId = randomId("entry");
@@ -173,20 +257,65 @@ class RuntimeAgentSession {
         }
         return createAgentSession({ agent: this.agent, id, store: this.store, leafId: branch.length ? remap.get(branch[branch.length - 1].id) : undefined, metadata: this.metadata });
     }
-    requireProvider() {
-        if (!this.agent.config.provider)
-            throw new Error(`Unknown provider: ${this.agent.config.model.provider}`);
+    branchReader() {
+        // ponytail: prefer the store's readBranchPath (one ancestor-chain query) when present so a
+        // DB-backed store never loads the full session; else fall back to list() + in-memory walk.
+        const read = this.store.readBranchPath;
+        return read ? (query) => read.call(this.store, query) : undefined;
+    }
+    resolveRunProvider(options) {
+        const model = options.model ?? this.agent.config.model;
+        // Provider precedence: an explicit `AgentConfig.provider` wins and bypasses
+        // 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);
+        if (!provider)
+            throw new Error(`Unknown provider: ${model.provider}`);
+        this.activeProvider = provider;
+    }
+    resolveRunSkills(options, tools) {
+        const configured = this.agent.config.skills;
+        if (configured && typeof configured === "object" && "list" in configured) {
+            if (options.activeSkills)
+                return resolveActiveSkills({ registry: configured, names: options.activeSkills, tools });
+            return configured.list();
+        }
+        const arr = options.skills ?? (Array.isArray(configured) ? configured : []);
+        return arr;
     }
     emit(event) {
         const redacted = redactAgentEvent(event, this.activeRedactor);
         for (const subscriber of this.subscribers)
             subscriber.push(redacted);
+        if (this.activeLedger) {
+            const record = {
+                id: randomId("event"),
+                sessionId: event.sessionId ?? this.id,
+                runId: event.runId,
+                type: event.type,
+                timestamp: new Date().toISOString(),
+                event: redacted,
+                redacted: Boolean(this.activeRedactor),
+                ...this.activeOwnership,
+            };
+            this.ledgerPromises.push(this.activeLedger.appendEvent(redactRunLedgerRecord(record, this.activeRedactor)));
+        }
     }
     closeSubscribers() {
         for (const subscriber of this.subscribers)
             subscriber.close();
         this.subscribers.clear();
     }
+    async drainLedger() {
+        if (this.ledgerPromises.length === 0)
+            return;
+        const pending = this.ledgerPromises;
+        this.ledgerPromises = [];
+        await Promise.all(pending);
+    }
     async generateWithRetry(request, runId, options, signal, requestSecrets = []) {
         const retry = mergeRetry(this.agent.config.retry, options.retry);
         const secrets = [...requestSecrets, ...(retry?.secrets ?? [])];
@@ -215,16 +344,29 @@ class RuntimeAgentSession {
     async generateProviderTurn(request, runId, signal, secrets = []) {
         const content = [];
         const calls = [];
+        const toolDeltas = [];
         let messageId;
         let started = false;
         let usage;
         try {
-            for await (const event of this.agent.config.provider.generate(request)) {
+            for await (const event of this.activeProvider.generate(request)) {
                 throwIfAborted(signal);
                 if (event.type === "error")
                     throw new ProviderTurnFailure(event.error, started);
-                if (event.type === "usage")
+                if (event.type === "usage") {
                     usage = event.usage;
+                    if (this.activeLedger) {
+                        const usageRecord = {
+                            id: randomId("usage"),
+                            sessionId: this.id,
+                            runId,
+                            usage: event.usage,
+                            recordedAt: new Date().toISOString(),
+                            ...this.activeOwnership,
+                        };
+                        await this.activeLedger.appendUsage(redactRunLedgerRecord(usageRecord, this.activeRedactor));
+                    }
+                }
                 if (event.type === "done") {
                     usage = event.usage ?? usage;
                     break;
@@ -235,11 +377,16 @@ class RuntimeAgentSession {
                     this.emit({ type: "message_started", sessionId: this.id, runId, message: { id: messageId, role: "assistant", content: [] } });
                     continue;
                 }
-                if (event.type === "content_delta" || event.type === "tool_call") {
+                if (event.type === "content_delta" || event.type === "tool_call" || event.type === "tool_call_delta") {
                     if (!started) {
                         started = true;
                         this.emit({ type: "message_started", sessionId: this.id, runId, message: { role: "assistant", content: [] } });
                     }
+                    if (event.type === "tool_call_delta") {
+                        toolDeltas.push(event);
+                        this.emit({ type: "message_delta", sessionId: this.id, runId, content: providerToolCallDeltaContent(event) });
+                        continue;
+                    }
                     const block = providerContent(event);
                     content.push(block);
                     if (block.type === "tool_call")
@@ -247,6 +394,11 @@ class RuntimeAgentSession {
                     this.emit({ type: "message_delta", sessionId: this.id, runId, content: block });
                 }
             }
+            for (const call of reconstructMissingToolCalls(toolDeltas, calls)) {
+                content.push(call);
+                calls.push(call);
+                this.emit({ type: "message_delta", sessionId: this.id, runId, content: call });
+            }
             return { content, calls, messageId, started, usage };
         }
         catch (error) {
@@ -298,7 +450,10 @@ class RuntimeAgentSession {
     }
     async appendEntry(entry) {
         const redacted = redactSessionEntry(entry, this.activeRedactor);
-        await this.store.append(redacted);
+        await this.store.append(redacted, {
+            expectedParentId: this.currentLeafId,
+            idempotencyKey: this.activeIdempotencyKey,
+        });
         this.currentLeafId = redacted.id;
     }
     redact(value) {
@@ -311,16 +466,26 @@ class RuntimeAgentSession {
         this.history = (await this.snapshot()).messages.slice();
     }
     async snapshot() {
-        return rebuildSessionContext(await this.store.list(this.id), { leafId: this.currentLeafId });
+        const reader = this.branchReader();
+        return reader
+            ? rebuildSessionContext(reader, { sessionId: this.id, leafId: this.currentLeafId })
+            : rebuildSessionContext(await this.store.list(this.id), { leafId: this.currentLeafId });
     }
 }
 class EventSubscriber {
+    sessionId;
     onClose;
     queue = [];
     waiters = [];
+    maxQueuedEvents;
+    overflow;
     closed = false;
-    constructor(onClose) {
+    constructor(sessionId, options, onClose) {
+        this.sessionId = sessionId;
         this.onClose = onClose;
+        const maxQueuedEvents = options.maxQueuedEvents ?? 1024;
+        this.maxQueuedEvents = Number.isFinite(maxQueuedEvents) ? Math.max(1, Math.floor(maxQueuedEvents)) : 1024;
+        this.overflow = options.overflow ?? "close";
     }
     [Symbol.asyncIterator]() {
         return this;
@@ -340,10 +505,33 @@ class EventSubscriber {
     }
     push(event) {
         const waiter = this.waiters.shift();
-        if (waiter)
+        if (waiter) {
             waiter({ value: event, done: false });
-        else if (!this.closed)
+            return;
+        }
+        if (this.closed)
+            return;
+        if (this.queue.length < this.maxQueuedEvents) {
             this.queue.push(event);
+            return;
+        }
+        if (this.overflow === "drop_oldest") {
+            this.queue.shift();
+            this.queue.push(event);
+            return;
+        }
+        if (this.overflow === "drop_newest")
+            return;
+        const droppedEvents = this.queue.length + 1;
+        this.queue.splice(0, this.queue.length, {
+            type: "event_subscriber_overflow",
+            sessionId: this.sessionId,
+            droppedEvents,
+            maxQueuedEvents: this.maxQueuedEvents,
+            overflow: this.overflow,
+        });
+        this.close();
+        this.onClose();
     }
     close() {
         this.closed = true;
@@ -354,6 +542,12 @@ class EventSubscriber {
 function providerContent(event) {
     return event.type === "content_delta" ? event.content : event.call;
 }
+function reconstructMissingToolCalls(deltas, calls) {
+    if (deltas.length === 0)
+        return [];
+    const seen = new Set(calls.map((call) => call.id));
+    return reconstructToolCallDeltas(deltas).filter((call) => !seen.has(call.id));
+}
 function inputToMessages(input) {
     if (typeof input === "string")
         return [{ role: "user", content: [{ type: "text", text: input }] }];
@@ -361,13 +555,6 @@ function inputToMessages(input) {
         return [input];
     return [...input];
 }
-function toolResultMessage(result) {
-    return {
-        role: "tool",
-        content: [{ type: "tool_result", toolCallId: result.toolCallId, name: result.name, result: result.value, error: result.error }, ...(result.content ?? [])],
-        metadata: result.metadata,
-    };
-}
 function activeTools(tools) {
     if (!tools)
         return { registry: createToolRegistry(), tools: [] };

package/dist/cache-helpers.d.ts

@@ -0,0 +1,28 @@
+import type { CacheRetention, ContentBlock, Message, ModelConfig, PromptCacheBreakpoint, Usage } from "./contracts.js";
+export interface CacheControlValue {
+    readonly type: "ephemeral";
+    readonly ttl?: "1h";
+}
+export interface ApplyCacheControlOptions {
+    readonly ttl?: "1h";
+    readonly maxBreakpoints?: number;
+}
+export type CacheControlledContentBlock = ContentBlock & {
+    readonly cache_control?: CacheControlValue;
+};
+export type CacheControlledMessage = Omit<Message, "content"> & {
+    readonly content: readonly CacheControlledContentBlock[];
+};
+export interface CacheUsageReport {
+    readonly cacheReadTokens: number;
+    readonly cacheWriteTokens: number;
+    readonly hitRate?: number;
+    readonly estimatedSavings?: number;
+    readonly currency?: string;
+}
+export declare function sanitizeCacheKey(value: string | undefined, maxLength: number): string | undefined;
+export declare function mapCacheRetention(retention: CacheRetention | undefined, model: ModelConfig): "short" | "long" | undefined;
+export declare function applyCacheControl(messages: readonly Message[], breakpoints: readonly PromptCacheBreakpoint[], options?: ApplyCacheControlOptions): readonly CacheControlledMessage[];
+export declare function cacheHitRate(usage: Usage | undefined): number | undefined;
+export declare function cacheSavings(usage: Usage | undefined, model: ModelConfig): number | undefined;
+export declare function cacheUsageReport(usage: Usage | undefined, model?: ModelConfig): CacheUsageReport | undefined;

package/dist/cache-helpers.js

@@ -0,0 +1,73 @@
+export function sanitizeCacheKey(value, 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) {
+    if (!retention || retention === "none" || model.cache?.kind === "none")
+        return undefined;
+    return retention === "long" && model.cache?.longRetention === false ? "short" : retention;
+}
+export function applyCacheControl(messages, breakpoints, options = {}) {
+    const selected = new Set();
+    for (const breakpoint of breakpoints) {
+        const index = resolveBreakpoint(messages, breakpoint);
+        if (index >= 0)
+            selected.add(index);
+        if (options.maxBreakpoints && selected.size >= options.maxBreakpoints)
+            break;
+    }
+    if (!selected.size)
+        return messages;
+    const cache_control = options.ttl ? { type: "ephemeral", ttl: options.ttl } : { type: "ephemeral" };
+    return messages.map((message, index) => {
+        if (!selected.has(index) || !message.content.length)
+            return message;
+        const content = message.content.map((block, blockIndex) => blockIndex === message.content.length - 1 ? { ...block, cache_control } : block);
+        return { ...message, content };
+    });
+}
+export function cacheHitRate(usage) {
+    const read = usage?.cacheReadTokens;
+    const input = usage?.inputTokens;
+    return read === undefined || !input ? undefined : read / input;
+}
+export function cacheSavings(usage, model) {
+    const read = usage?.cacheReadTokens;
+    const input = model.cost?.input;
+    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);
+}
+export function cacheUsageReport(usage, model) {
+    if (!usage)
+        return undefined;
+    const estimatedSavings = model ? cacheSavings(usage, model) : undefined;
+    return {
+        cacheReadTokens: usage.cacheReadTokens ?? 0,
+        cacheWriteTokens: usage.cacheWriteTokens ?? 0,
+        hitRate: cacheHitRate(usage),
+        estimatedSavings,
+        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);
+    }
+}
+function findLastIndex(items, predicate) {
+    for (let index = items.length - 1; index >= 0; index--)
+        if (predicate(items[index]))
+            return index;
+    return -1;
+}
+function costUnitDivisor(unit) {
+    return unit && /(?:1m|million)/i.test(unit) ? 1_000_000 : 1;
+}
+//# sourceMappingURL=cache-helpers.js.map