@tangle-network/agent-eval 0.129.0 → 0.130.0

package/dist/chunk-VCZ5FQYW.js

@@ -1,928 +0,0 @@
-import {
-  estimateCost,
-  isModelPriced,
-  resolveModelPricing
-} from "./chunk-VI2UW6B6.js";
-import {
-  ValidationError
-} from "./chunk-ONWEPEDO.js";
-
-// src/cost-ledger.ts
-import { z } from "zod";
-var CostCeilingReachedError = class extends ValidationError {
-  constructor(ceilingUsd, committedAndReservedUsd, requestedUsd, phase, actor) {
-    super(
-      `CostLedger: reserving ${requestedUsd} for '${actor}' during '${phase}' would exceed ceiling ${ceilingUsd} with ${committedAndReservedUsd} already committed or reserved`
-    );
-  }
-};
-var CostAccountingIncompleteError = class extends ValidationError {
-};
-var CostReservationExceededError = class extends ValidationError {
-  constructor(actor, actualUsd, maximumUsd) {
-    super(
-      `CostLedger: '${actor}' charged ${actualUsd}, exceeding its enforced maximum ${maximumUsd}`
-    );
-  }
-};
-var CostCallConflictError = class extends ValidationError {
-  callId;
-  receipt;
-  constructor(message, options = {}) {
-    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
-    this.callId = options.callId;
-    this.receipt = options.receipt ? cloneReceipt(options.receipt) : void 0;
-  }
-};
-var CostLedgerPersistenceError = class extends ValidationError {
-  callId;
-  receipt;
-  constructor(cause, callId, receipt) {
-    super(
-      `CostLedger: failed to persist${callId ? ` call '${callId}'` : ""}: ${toError(cause).message}`,
-      { cause }
-    );
-    this.callId = callId;
-    this.receipt = receipt ? cloneReceipt(receipt) : void 0;
-  }
-};
-var CostReceiptCaptureError = class extends ValidationError {
-  callId;
-  receipt;
-  receiptError;
-  constructor(callId, cause, receiptError, receipt) {
-    super(`CostLedger: could not capture the provider receipt for call '${callId}'`, { cause });
-    this.callId = callId;
-    this.receipt = receipt ? cloneReceipt(receipt) : void 0;
-    this.receiptError = toError(receiptError);
-  }
-};
-var CostLedger = class {
-  records = /* @__PURE__ */ new Map();
-  activeCallIds = /* @__PURE__ */ new Set();
-  lateCallIds = /* @__PURE__ */ new Set();
-  idleWaiters = /* @__PURE__ */ new Set();
-  completedTasks = 0;
-  revision = "memory";
-  costLimitPersisted = false;
-  costCeilingUsd;
-  persistence;
-  constructor(input) {
-    const options = typeof input === "number" ? { costCeilingUsd: input } : input ?? {};
-    this.persistence = options.persistence;
-    if (options.costCeilingUsd !== void 0) {
-      assertNonNegative(options.costCeilingUsd, "costCeilingUsd");
-    }
-    let persistedCostCeilingUsd;
-    if (this.persistence) {
-      let stored;
-      try {
-        stored = this.persistence.read();
-      } catch (cause) {
-        throw new CostLedgerPersistenceError(cause);
-      }
-      assertString(stored.revision, "persistence revision");
-      this.revision = stored.revision;
-      const restored = parseEvents(stored.events);
-      for (const record of restored.records) this.records.set(record.callId, record);
-      this.completedTasks = restored.completedTasks;
-      persistedCostCeilingUsd = restored.costCeilingUsd;
-    }
-    if (options.costCeilingUsd !== void 0 && persistedCostCeilingUsd !== void 0 && options.costCeilingUsd !== persistedCostCeilingUsd) {
-      throw new ValidationError(
-        `CostLedger: requested cost ceiling ${options.costCeilingUsd} does not match persisted ceiling ${persistedCostCeilingUsd}`
-      );
-    }
-    this.costCeilingUsd = persistedCostCeilingUsd ?? options.costCeilingUsd;
-    this.costLimitPersisted = !this.persistence || this.costCeilingUsd === void 0 || persistedCostCeilingUsd !== void 0;
-    if (this.costCeilingUsd !== void 0 && [...this.records.values()].some(
-      (record) => record.status === "pending" && record.maximumCostUsd === void 0
-    )) {
-      throw new ValidationError("CostLedger: capped event log contains an unbounded pending call");
-    }
-    if (options.receipts?.length) {
-      const imported = options.receipts.map(
-        (receipt, index) => parseImportedReceipt(receipt, `imported receipt ${index + 1}`)
-      );
-      this.ensureCostLimitPersisted();
-      for (const receipt of imported) this.appendRecord(receipt);
-    }
-  }
-  async runPaidCall(input) {
-    let callId;
-    let pending;
-    try {
-      callId = resolveCallId(input.callId);
-      validateAttribution(input);
-      if (input.signal?.aborted) {
-        return { succeeded: false, callId, error: abortError(input.signal) };
-      }
-      if (this.records.has(callId)) {
-        return {
-          succeeded: false,
-          callId,
-          error: new CostCallConflictError(`CostLedger: callId '${callId}' already exists`)
-        };
-      }
-      this.ensureCostLimitPersisted(callId);
-      const summary = this.summary();
-      if (summary.unresolvedCalls > 0) {
-        return {
-          succeeded: false,
-          callId,
-          error: new CostAccountingIncompleteError(
-            `CostLedger: ${summary.unresolvedCalls} unresolved call(s) must be reconciled before new paid work`
-          )
-        };
-      }
-      const maximumCostUsd = this.resolveMaximum(input.maximumCharge);
-      if (this.costCeilingUsd !== void 0 && this.hasIncompleteSettledCall()) {
-        return {
-          succeeded: false,
-          callId,
-          error: new CostAccountingIncompleteError(
-            `CostLedger: accounting is incomplete; refusing paid call '${input.actor}' during '${input.phase}'`
-          )
-        };
-      }
-      if (this.costCeilingUsd !== void 0) {
-        const committedAndReserved = summary.totalCostUsd + summary.reservedCostUsd;
-        if (committedAndReserved + maximumCostUsd > this.costCeilingUsd) {
-          return {
-            succeeded: false,
-            callId,
-            error: new CostCeilingReachedError(
-              this.costCeilingUsd,
-              committedAndReserved,
-              maximumCostUsd,
-              input.phase,
-              input.actor
-            )
-          };
-        }
-      }
-      pending = {
-        status: "pending",
-        callId,
-        channel: input.channel,
-        phase: input.phase,
-        actor: input.actor,
-        model: pendingModel(input),
-        ...maximumCostUsd === void 0 ? {} : { maximumCostUsd },
-        ...input.tags ? { tags: { ...input.tags } } : {},
-        timestamp: Date.now()
-      };
-      this.appendRecord(pending);
-      this.activeCallIds.add(callId);
-    } catch (error) {
-      return { succeeded: false, ...callId ? { callId } : {}, error: toError(error) };
-    }
-    try {
-      return await this.execute(input, pending);
-    } catch (error) {
-      return { succeeded: false, callId: pending.callId, error: toError(error) };
-    } finally {
-      if (!this.lateCallIds.has(pending.callId)) this.releaseActiveCall(pending.callId);
-    }
-  }
-  /** Wait until every call started by this ledger has produced a durable outcome. */
-  async waitForIdle(options = {}) {
-    const hasActiveMatch = () => [...this.activeCallIds].some((callId) => {
-      const record = this.records.get(callId);
-      return record !== void 0 && matches(record, options.filter);
-    });
-    if (!hasActiveMatch()) return true;
-    const timeoutMs = options.timeoutMs ?? 5e3;
-    assertTimeout(timeoutMs, "waitForIdle.timeoutMs");
-    return new Promise((resolve) => {
-      let timer;
-      const finish = (settled) => {
-        this.idleWaiters.delete(onIdle);
-        if (timer !== void 0) clearTimeout(timer);
-        resolve(settled);
-      };
-      const onIdle = () => {
-        if (!hasActiveMatch()) finish(true);
-      };
-      this.idleWaiters.add(onIdle);
-      timer = setTimeout(() => finish(false), timeoutMs);
-      onIdle();
-    });
-  }
-  /** Settle a call left pending by a crashed process after reconciling with the provider. */
-  reconcile(callId, observed, options = {}) {
-    const pending = [...this.records.values()].find(
-      (record) => record.callId === callId && record.status === "pending"
-    );
-    if (!pending) throw new CostCallConflictError(`CostLedger: no pending call '${callId}'`);
-    if (this.activeCallIds.has(callId)) {
-      throw new CostCallConflictError(`CostLedger: call '${callId}' is still active`);
-    }
-    this.ensureCostLimitPersisted(callId);
-    return this.commitReceipt(pending, observed, options.error);
-  }
-  list(filter) {
-    return [...this.records.values()].filter((record) => record.status === "settled").filter((receipt) => matches(receipt, filter)).map(cloneReceipt);
-  }
-  /** Read pending calls without exposing mutable ledger state. */
-  listPending(filter) {
-    return [...this.records.values()].filter((record) => record.status === "pending").filter((record) => matches(record, filter)).map((record) => ({
-      ...clonePendingCall(record),
-      state: this.lateCallIds.has(record.callId) ? "late" : this.activeCallIds.has(record.callId) ? "active" : "interrupted"
-    }));
-  }
-  summary(filter) {
-    const records = [...this.records.values()].filter((record) => matches(record, filter));
-    const pending = records.filter(
-      (record) => record.status === "pending"
-    );
-    const receipts = records.filter((record) => record.status === "settled");
-    const byChannel = /* @__PURE__ */ new Map();
-    const unpriced = /* @__PURE__ */ new Set();
-    const incompleteReasons = pending.map(
-      (record) => `call '${record.callId}' for '${record.actor}' is pending`
-    );
-    let inputTokens = 0;
-    let outputTokens = 0;
-    let reasoningTokens = 0;
-    let cachedTokens = 0;
-    let cacheWriteTokens = 0;
-    let totalCostUsd = 0;
-    for (const receipt of receipts) {
-      inputTokens += receipt.inputTokens;
-      outputTokens += receipt.outputTokens;
-      reasoningTokens += receipt.reasoningTokens ?? 0;
-      cachedTokens += receipt.cachedTokens ?? 0;
-      cacheWriteTokens += receipt.cacheWriteTokens ?? 0;
-      totalCostUsd += receipt.costUsd;
-      if (receipt.costUnknown) {
-        unpriced.add(receipt.model);
-        incompleteReasons.push(
-          receipt.error ?? `cost unknown for '${receipt.actor}' using '${receipt.model}'`
-        );
-      }
-      if (receipt.usageUnknown) {
-        incompleteReasons.push(
-          `token usage unknown for '${receipt.actor}' using '${receipt.model}'`
-        );
-      }
-      if (receipt.maximumCostUsd !== void 0 && receipt.costUsd > receipt.maximumCostUsd) {
-        incompleteReasons.push(
-          `'${receipt.actor}' charged ${receipt.costUsd}, exceeding its enforced maximum ${receipt.maximumCostUsd}`
-        );
-      }
-      const rollup = byChannel.get(receipt.channel) ?? emptyRollup(receipt.channel);
-      rollup.calls += 1;
-      rollup.inputTokens += receipt.inputTokens;
-      rollup.outputTokens += receipt.outputTokens;
-      rollup.reasoningTokens = (rollup.reasoningTokens ?? 0) + (receipt.reasoningTokens ?? 0);
-      rollup.cachedTokens += receipt.cachedTokens ?? 0;
-      rollup.cacheWriteTokens = (rollup.cacheWriteTokens ?? 0) + (receipt.cacheWriteTokens ?? 0);
-      rollup.costUsd += receipt.costUsd;
-      if (receipt.costUnknown) rollup.unpricedCalls += 1;
-      if (receipt.usageUnknown) rollup.unknownUsageCalls += 1;
-      byChannel.set(receipt.channel, rollup);
-    }
-    return {
-      totalCalls: receipts.length,
-      pendingCalls: pending.length,
-      unresolvedCalls: pending.filter(
-        (record) => !this.activeCallIds.has(record.callId) || this.lateCallIds.has(record.callId)
-      ).length,
-      reservedCostUsd: pending.reduce((sum, record) => sum + (record.maximumCostUsd ?? 0), 0),
-      inputTokens,
-      outputTokens,
-      reasoningTokens,
-      cachedTokens,
-      cacheWriteTokens,
-      totalCostUsd,
-      byChannel: [...byChannel.values()].sort((a, b) => a.channel.localeCompare(b.channel)),
-      unpricedModels: [...unpriced].sort(),
-      fullyPriced: unpriced.size === 0,
-      usageComplete: pending.length === 0 && receipts.every((receipt) => !receipt.usageUnknown),
-      accountingComplete: incompleteReasons.length === 0,
-      incompleteReasons: [...new Set(incompleteReasons)]
-    };
-  }
-  markCompleted(count = 1) {
-    if (!Number.isInteger(count) || count < 0) {
-      throw new ValidationError(
-        `CostLedger.markCompleted: count must be a non-negative integer, got ${count}`
-      );
-    }
-    if (count === 0) return;
-    this.ensureCostLimitPersisted();
-    this.appendEvent({ version: 1, completedTasks: count });
-    this.completedTasks += count;
-  }
-  costPerCompletedTask() {
-    return this.completedTasks === 0 ? null : this.summary().totalCostUsd / this.completedTasks;
-  }
-  async execute(input, pending) {
-    const signal = input.signal ?? new AbortController().signal;
-    if (signal.aborted) {
-      return this.commitOutcome(pending, abortError(signal), {
-        model: pending.model,
-        inputTokens: 0,
-        outputTokens: 0,
-        actualCostUsd: 0
-      });
-    }
-    const operation = Promise.resolve().then(() => input.execute(signal, pending.callId));
-    const settled = await settle(operation, signal);
-    if (settled.kind === "aborted") {
-      this.lateCallIds.add(pending.callId);
-      this.captureLateOutcome(input, pending, operation);
-      return paidFailure(pending.callId, abortError(signal));
-    }
-    if (settled.kind === "error") {
-      let observed;
-      try {
-        observed = input.receiptFromError?.(settled.error);
-      } catch (receiptError) {
-        return this.captureFailure(pending, settled.error, receiptError);
-      }
-      return this.commitOutcome(pending, settled.error, observed ?? unknownReceipt(pending.model));
-    }
-    try {
-      const receipt = this.commitReceipt(pending, input.receipt(settled.value));
-      if (receipt.maximumCostUsd !== void 0 && receipt.costUsd > receipt.maximumCostUsd) {
-        return paidFailure(
-          pending.callId,
-          new CostReservationExceededError(pending.actor, receipt.costUsd, receipt.maximumCostUsd),
-          receipt
-        );
-      }
-      return { succeeded: true, callId: pending.callId, value: settled.value, receipt };
-    } catch (receiptError) {
-      if (receiptError instanceof CostLedgerPersistenceError || receiptError instanceof CostCallConflictError) {
-        return paidFailure(pending.callId, receiptError);
-      }
-      return this.captureFailure(pending, receiptError, receiptError);
-    }
-  }
-  captureLateOutcome(input, pending, operation) {
-    void operation.then(
-      (value) => {
-        if (this.records.get(pending.callId)?.status !== "pending") return;
-        try {
-          this.commitReceipt(pending, input.receipt(value));
-        } catch {
-        }
-      },
-      (cause) => {
-        if (this.records.get(pending.callId)?.status !== "pending") return;
-        const error = toError(cause);
-        try {
-          const observed = input.receiptFromError?.(error);
-          this.commitReceipt(pending, observed ?? unknownReceipt(pending.model), error.message);
-        } catch (receiptError) {
-          if (receiptError instanceof CostLedgerPersistenceError || receiptError instanceof CostCallConflictError) {
-            return;
-          }
-          this.captureFailure(pending, error, receiptError);
-        }
-      }
-    ).finally(() => {
-      this.lateCallIds.delete(pending.callId);
-      this.releaseActiveCall(pending.callId);
-    });
-  }
-  releaseActiveCall(callId) {
-    this.activeCallIds.delete(callId);
-    for (const resolve of [...this.idleWaiters]) resolve();
-  }
-  commitOutcome(pending, error, observed) {
-    try {
-      const receipt = this.commitReceipt(pending, observed, error.message);
-      return paidFailure(pending.callId, error, receipt);
-    } catch (receiptError) {
-      if (receiptError instanceof CostLedgerPersistenceError || receiptError instanceof CostCallConflictError) {
-        return paidFailure(pending.callId, receiptError);
-      }
-      return this.captureFailure(pending, error, receiptError);
-    }
-  }
-  captureFailure(pending, cause, receiptError) {
-    try {
-      const receipt = this.commitReceipt(
-        pending,
-        unknownReceipt(pending.model),
-        toError(receiptError).message
-      );
-      return paidFailure(
-        pending.callId,
-        new CostReceiptCaptureError(pending.callId, cause, receiptError, receipt),
-        receipt
-      );
-    } catch (error) {
-      const typed = error instanceof Error ? error : toError(error);
-      return paidFailure(pending.callId, typed);
-    }
-  }
-  commitReceipt(pending, observed, error) {
-    const receipt = buildReceipt(pending, observed, error);
-    if (this.records.get(pending.callId)?.status !== "pending") {
-      throw new CostCallConflictError(`CostLedger: call '${pending.callId}' is not pending`);
-    }
-    this.appendRecord(receipt);
-    return cloneReceipt(receipt);
-  }
-  resolveMaximum(maximum) {
-    if (!maximum) {
-      if (this.costCeilingUsd !== void 0) {
-        throw new CostAccountingIncompleteError(
-          "CostLedger: capped paid calls require a hard maximumCharge before execution"
-        );
-      }
-      return void 0;
-    }
-    if ("externallyEnforcedMaximumUsd" in maximum) {
-      assertNonNegative(
-        maximum.externallyEnforcedMaximumUsd,
-        "maximumCharge.externallyEnforcedMaximumUsd"
-      );
-      return maximum.externallyEnforcedMaximumUsd;
-    }
-    if ("customTokenPricing" in maximum) {
-      return costForTokenPricing(maximum.customTokenPricing, maximum);
-    }
-    const priced = costForUsage(maximum.model, maximum);
-    if (priced.costUnknown) {
-      if (this.costCeilingUsd !== void 0) {
-        throw new CostAccountingIncompleteError(
-          `CostLedger: cannot reserve unpriced model '${maximum.model}' in a capped run`
-        );
-      }
-      return void 0;
-    }
-    return priced.costUsd;
-  }
-  hasIncompleteSettledCall() {
-    return [...this.records.values()].some(
-      (record) => record.status === "settled" && (record.costUnknown || record.usageUnknown || record.maximumCostUsd !== void 0 && record.costUsd > record.maximumCostUsd)
-    );
-  }
-  appendRecord(record) {
-    const callId = record.callId;
-    const receipt = record.status === "settled" ? record : void 0;
-    validateTransition(this.records, record);
-    const event = record.status === "settled" ? { version: 2, record: cloneReceipt(record) } : { version: 1, record: clonePendingCall(record) };
-    this.appendEvent(event, callId, receipt);
-    this.records.set(callId, cloneRecord(record));
-  }
-  ensureCostLimitPersisted(callId) {
-    if (this.costLimitPersisted || this.costCeilingUsd === void 0) return;
-    this.appendEvent({ version: 1, costCeilingUsd: this.costCeilingUsd }, callId);
-    this.costLimitPersisted = true;
-  }
-  appendEvent(event, callId, receipt) {
-    try {
-      if (this.persistence) {
-        const nextRevision = this.persistence.append(this.revision, `${JSON.stringify(event)}
-`);
-        if (nextRevision === void 0) {
-          throw new CostCallConflictError(
-            `CostLedger: persisted revision changed while writing call '${callId}'`,
-            { callId, receipt }
-          );
-        }
-        assertString(nextRevision, "persistence revision");
-        this.revision = nextRevision;
-      }
-    } catch (cause) {
-      if (cause instanceof CostCallConflictError) throw cause;
-      throw new CostLedgerPersistenceError(cause, callId, receipt);
-    }
-  }
-};
-function modelPriceKey(model) {
-  return isModelPriced(model) ? model : null;
-}
-function costForUsage(model, usage) {
-  assertUsage(usage);
-  if (!resolveModelPricing(model)) return { costUsd: 0, costUnknown: true };
-  return {
-    costUsd: estimateCost(
-      usage.inputTokens + (usage.cachedTokens ?? 0) + (usage.cacheWriteTokens ?? 0),
-      usage.outputTokens,
-      model
-    ),
-    costUnknown: false
-  };
-}
-function costForTokenPricing(pricing, usage) {
-  assertTokenCount(usage.inputTokens, "usage.inputTokens");
-  assertTokenCount(usage.outputTokens, "usage.outputTokens");
-  if (usage.cachedTokens !== void 0) {
-    assertTokenCount(usage.cachedTokens, "usage.cachedTokens");
-  }
-  if (usage.cacheWriteTokens !== void 0) {
-    assertTokenCount(usage.cacheWriteTokens, "usage.cacheWriteTokens");
-  }
-  assertNonNegative(pricing.inputUsdPerMillion, "pricing.inputUsdPerMillion");
-  if (pricing.cachedInputUsdPerMillion !== void 0) {
-    assertNonNegative(pricing.cachedInputUsdPerMillion, "pricing.cachedInputUsdPerMillion");
-  }
-  if (pricing.cacheWriteUsdPerMillion !== void 0) {
-    assertNonNegative(pricing.cacheWriteUsdPerMillion, "pricing.cacheWriteUsdPerMillion");
-  }
-  assertNonNegative(pricing.outputUsdPerMillion, "pricing.outputUsdPerMillion");
-  const cachedInputRate = pricing.cachedInputUsdPerMillion ?? pricing.inputUsdPerMillion;
-  const cacheWriteRate = pricing.cacheWriteUsdPerMillion ?? pricing.inputUsdPerMillion;
-  return usage.inputTokens / 1e6 * pricing.inputUsdPerMillion + (usage.cachedTokens ?? 0) / 1e6 * cachedInputRate + (usage.cacheWriteTokens ?? 0) / 1e6 * cacheWriteRate + usage.outputTokens / 1e6 * pricing.outputUsdPerMillion;
-}
-async function settle(promise, signal) {
-  return await new Promise((resolve) => {
-    let done = false;
-    const finish = (value) => {
-      if (done) return;
-      done = true;
-      signal.removeEventListener("abort", onAbort);
-      resolve(value);
-    };
-    const onAbort = () => finish({ kind: "aborted" });
-    signal.addEventListener("abort", onAbort, { once: true });
-    if (signal.aborted) onAbort();
-    promise.then(
-      (value) => finish({ kind: "value", value }),
-      (error) => finish({ kind: "error", error: toError(error) })
-    );
-  });
-}
-function buildReceipt(pending, observed, error) {
-  assertUsage(observed);
-  assertString(observed.model, "receipt.model");
-  if (observed.actualCostUsd !== void 0 && observed.customTokenPricing !== void 0) {
-    throw new ValidationError(
-      "CostLedger: a receipt cannot have both actualCostUsd and customTokenPricing"
-    );
-  }
-  const customPricingSnapshot = observed.customTokenPricing === void 0 ? void 0 : pricingSnapshot(observed.customTokenPricing);
-  const estimated = customPricingSnapshot ? {
-    costUsd: costFromPricing(observed, customPricingSnapshot),
-    costUnknown: false
-  } : costForUsage(observed.model, observed);
-  const hasActual = observed.actualCostUsd !== void 0;
-  if (hasActual && observed.costUnknown === true) {
-    throw new ValidationError(
-      "CostLedger: a receipt cannot have both actualCostUsd and costUnknown=true"
-    );
-  }
-  if (hasActual) assertNonNegative(observed.actualCostUsd, "actualCostUsd");
-  const usageUnknown = observed.usageUnknown === true;
-  const costUnknown = observed.costUnknown === true || !hasActual && (usageUnknown || estimated.costUnknown);
-  const resolvedModelPricing = !customPricingSnapshot && !hasActual && !costUnknown ? resolveModelPricing(observed.model) : null;
-  const receiptPricing = !hasActual && !costUnknown ? customPricingSnapshot ?? (resolvedModelPricing ? {
-    inputUsdPerThousand: resolvedModelPricing.input,
-    outputUsdPerThousand: resolvedModelPricing.output
-  } : void 0) : void 0;
-  return parseReceipt(
-    {
-      status: "settled",
-      callId: pending.callId,
-      channel: pending.channel,
-      phase: pending.phase,
-      actor: pending.actor,
-      model: observed.model,
-      inputTokens: observed.inputTokens,
-      outputTokens: observed.outputTokens,
-      ...observed.reasoningTokens === void 0 ? {} : { reasoningTokens: observed.reasoningTokens },
-      ...observed.cachedTokens === void 0 ? {} : { cachedTokens: observed.cachedTokens },
-      ...observed.cacheWriteTokens === void 0 ? {} : { cacheWriteTokens: observed.cacheWriteTokens },
-      costUsd: costUnknown ? 0 : hasActual ? observed.actualCostUsd : estimated.costUsd,
-      costUnknown,
-      usageUnknown,
-      ...receiptPricing ? { pricing: receiptPricing } : {},
-      ...hasActual ? { actualCostUsd: observed.actualCostUsd } : {},
-      ...pending.maximumCostUsd === void 0 ? {} : { maximumCostUsd: pending.maximumCostUsd },
-      ...error ? { error } : {},
-      ...pending.tags ? { tags: { ...pending.tags } } : {},
-      timestamp: pending.timestamp
-    },
-    "provider receipt"
-  );
-}
-var NonEmptyString = z.string().refine((value) => value.trim().length > 0, "must be non-empty");
-var TokenCount = z.number().int().nonnegative().finite();
-var NonNegative = z.number().nonnegative().finite();
-var Tags = z.record(NonEmptyString, z.string());
-var CostPricingSchema = z.strictObject({
-  inputUsdPerThousand: NonNegative,
-  cachedInputUsdPerThousand: NonNegative.optional(),
-  cacheWriteUsdPerThousand: NonNegative.optional(),
-  outputUsdPerThousand: NonNegative
-});
-var CostCallBaseShape = {
-  callId: NonEmptyString,
-  channel: NonEmptyString,
-  phase: NonEmptyString,
-  actor: NonEmptyString,
-  model: NonEmptyString,
-  maximumCostUsd: NonNegative.optional(),
-  tags: Tags.optional(),
-  timestamp: NonNegative
-};
-var PendingCostCallSchema = z.strictObject({
-  status: z.literal("pending"),
-  ...CostCallBaseShape
-});
-var CostReceiptBaseShape = {
-  status: z.literal("settled"),
-  ...CostCallBaseShape,
-  inputTokens: TokenCount,
-  outputTokens: TokenCount,
-  cachedTokens: TokenCount.optional(),
-  costUsd: NonNegative,
-  costUnknown: z.boolean(),
-  usageUnknown: z.boolean().default(false),
-  pricing: CostPricingSchema.optional(),
-  actualCostUsd: NonNegative.optional(),
-  error: z.string().optional()
-};
-var CostReceiptSchema = z.strictObject({
-  ...CostReceiptBaseShape,
-  reasoningTokens: TokenCount.optional(),
-  cacheWriteTokens: TokenCount.optional()
-}).superRefine((receipt, ctx) => validateCostReceipt(receipt, ctx));
-function validateCostReceipt(receipt, ctx) {
-  if (receipt.reasoningTokens !== void 0 && receipt.reasoningTokens > receipt.outputTokens) {
-    ctx.addIssue({ code: "custom", message: "reasoningTokens must not exceed outputTokens" });
-  }
-  if (receipt.actualCostUsd !== void 0) {
-    if (receipt.costUnknown || receipt.costUsd !== receipt.actualCostUsd) {
-      ctx.addIssue({ code: "custom", message: "actual cost must be known and equal costUsd" });
-    }
-    if (receipt.pricing !== void 0) {
-      ctx.addIssue({ code: "custom", message: "actual cost must not include estimated pricing" });
-    }
-    return;
-  }
-  if (receipt.costUnknown) {
-    if (receipt.costUsd !== 0) {
-      ctx.addIssue({ code: "custom", message: "unknown cost must have costUsd 0" });
-    }
-    if (receipt.pricing !== void 0) {
-      ctx.addIssue({ code: "custom", message: "unknown cost must not include estimated pricing" });
-    }
-    return;
-  }
-  if (receipt.usageUnknown) {
-    ctx.addIssue({ code: "custom", message: "known estimated cost requires known usage" });
-  }
-  if (!receipt.pricing) {
-    ctx.addIssue({ code: "custom", message: "known estimated cost requires a pricing snapshot" });
-    return;
-  }
-  const expected = costFromPricing(receipt, receipt.pricing);
-  if (receipt.costUsd !== expected) {
-    ctx.addIssue({
-      code: "custom",
-      message: `estimated cost ${receipt.costUsd} does not match pricing snapshot ${expected}`
-    });
-  }
-}
-var CostLedgerEventSchema = z.union([
-  z.strictObject({
-    version: z.literal(1),
-    record: PendingCostCallSchema
-  }),
-  z.strictObject({
-    version: z.literal(2),
-    record: CostReceiptSchema
-  }),
-  z.strictObject({
-    version: z.literal(1),
-    completedTasks: TokenCount
-  }),
-  z.strictObject({
-    version: z.literal(1),
-    costCeilingUsd: NonNegative
-  })
-]);
-function parseEvents(serialized) {
-  const records = /* @__PURE__ */ new Map();
-  let completedTasks = 0;
-  let costCeilingUsd;
-  let lineNumber = 0;
-  try {
-    for (const line of serialized.split("\n")) {
-      if (!line.trim()) continue;
-      lineNumber += 1;
-      const event = CostLedgerEventSchema.parse(JSON.parse(line));
-      if ("record" in event) {
-        const record = event.record;
-        validateTransition(records, record);
-        records.set(record.callId, cloneRecord(record));
-      } else if ("completedTasks" in event) {
-        completedTasks += event.completedTasks;
-        if (!Number.isSafeInteger(completedTasks)) {
-          throw new ValidationError("CostLedger: completed task count exceeds safe integer range");
-        }
-      } else {
-        if (costCeilingUsd !== void 0) {
-          throw new ValidationError("CostLedger: duplicate persisted cost ceiling");
-        }
-        costCeilingUsd = event.costCeilingUsd;
-      }
-    }
-    return {
-      records: [...records.values()],
-      completedTasks,
-      ...costCeilingUsd === void 0 ? {} : { costCeilingUsd }
-    };
-  } catch (cause) {
-    throw new ValidationError(
-      `CostLedger: invalid persisted event ${lineNumber || 1}: ${validationMessage(cause)}`,
-      { cause }
-    );
-  }
-}
-function validateTransition(records, record) {
-  const current = records.get(record.callId);
-  if (!current) return;
-  if (record.status === "pending" || current.status === "settled") {
-    throw new CostCallConflictError(`CostLedger: duplicate callId '${record.callId}'`);
-  }
-  if (!sameAttribution(current, record)) {
-    throw new ValidationError(`CostLedger: receipt attribution changed for call '${record.callId}'`);
-  }
-}
-function sameAttribution(before, after) {
-  return before.channel === after.channel && before.phase === after.phase && before.actor === after.actor && before.maximumCostUsd === after.maximumCostUsd && before.timestamp === after.timestamp && JSON.stringify(before.tags ?? {}) === JSON.stringify(after.tags ?? {});
-}
-function parseReceipt(value, path) {
-  try {
-    return CostReceiptSchema.parse(value);
-  } catch (cause) {
-    throw new ValidationError(`CostLedger: invalid ${path}: ${validationMessage(cause)}`, { cause });
-  }
-}
-function parseImportedReceipt(value, path) {
-  if (typeof value !== "object" || value === null) return parseReceipt(value, path);
-  const candidate = { ...value };
-  if (candidate.status === "settled" && candidate.actualCostUsd === void 0 && candidate.costUnknown === false && candidate.pricing === void 0 && typeof candidate.model === "string") {
-    const pricing = resolveModelPricing(candidate.model);
-    if (pricing) {
-      candidate.pricing = {
-        inputUsdPerThousand: pricing.input,
-        outputUsdPerThousand: pricing.output
-      };
-    }
-  }
-  return parseReceipt(candidate, path);
-}
-function validateAttribution(input) {
-  assertString(input.channel, "channel");
-  assertString(input.phase, "phase");
-  assertString(input.actor, "actor");
-  if (input.model !== void 0) assertString(input.model, "model");
-  if (input.tags !== void 0) {
-    const parsed = Tags.safeParse(input.tags);
-    if (!parsed.success)
-      throw new ValidationError(`CostLedger: invalid tags: ${parsed.error.message}`);
-  }
-}
-function matches(record, filter) {
-  if (!filter) return true;
-  if (filter.channel !== void 0 && record.channel !== filter.channel) return false;
-  if (filter.phase !== void 0 && record.phase !== filter.phase) return false;
-  return Object.entries(filter.tags ?? {}).every(([key, value]) => record.tags?.[key] === value);
-}
-function cloneRecord(record) {
-  if (record.status === "settled") return cloneReceipt(record);
-  return clonePendingCall(record);
-}
-function clonePendingCall(record) {
-  const { tags, ...rest } = record;
-  return { ...rest, ...tags ? { tags: { ...tags } } : {} };
-}
-function cloneReceipt(receipt) {
-  const { pricing, tags, ...rest } = receipt;
-  return {
-    ...rest,
-    ...tags ? { tags: { ...tags } } : {},
-    ...pricing ? { pricing: { ...pricing } } : {}
-  };
-}
-function costFromPricing(usage, pricing) {
-  const cachedInputRate = pricing.cachedInputUsdPerThousand ?? pricing.inputUsdPerThousand;
-  const cacheWriteRate = pricing.cacheWriteUsdPerThousand ?? pricing.inputUsdPerThousand;
-  return usage.inputTokens / 1e3 * pricing.inputUsdPerThousand + (usage.cachedTokens ?? 0) / 1e3 * cachedInputRate + (usage.cacheWriteTokens ?? 0) / 1e3 * cacheWriteRate + usage.outputTokens / 1e3 * pricing.outputUsdPerThousand;
-}
-function pricingSnapshot(pricing) {
-  costForTokenPricing(pricing, { inputTokens: 0, outputTokens: 0 });
-  return {
-    inputUsdPerThousand: pricing.inputUsdPerMillion / 1e3,
-    ...pricing.cachedInputUsdPerMillion === void 0 ? {} : { cachedInputUsdPerThousand: pricing.cachedInputUsdPerMillion / 1e3 },
-    ...pricing.cacheWriteUsdPerMillion === void 0 ? {} : { cacheWriteUsdPerThousand: pricing.cacheWriteUsdPerMillion / 1e3 },
-    outputUsdPerThousand: pricing.outputUsdPerMillion / 1e3
-  };
-}
-function emptyRollup(channel) {
-  return {
-    channel,
-    calls: 0,
-    inputTokens: 0,
-    outputTokens: 0,
-    reasoningTokens: 0,
-    cachedTokens: 0,
-    cacheWriteTokens: 0,
-    costUsd: 0,
-    unpricedCalls: 0,
-    unknownUsageCalls: 0
-  };
-}
-function pendingModel(input) {
-  if (input.model) return input.model;
-  if (input.maximumCharge && "model" in input.maximumCharge) return input.maximumCharge.model;
-  return "unknown";
-}
-function unknownReceipt(model) {
-  return { model, inputTokens: 0, outputTokens: 0, costUnknown: true, usageUnknown: true };
-}
-function resolveCallId(input) {
-  if (input !== void 0) {
-    assertString(input, "callId");
-    return input;
-  }
-  if (typeof globalThis.crypto?.randomUUID !== "function") {
-    throw new ValidationError("CostLedger: crypto.randomUUID is required when callId is omitted");
-  }
-  return globalThis.crypto.randomUUID();
-}
-function abortError(signal) {
-  const reason = signal.reason;
-  if (reason instanceof Error) return reason;
-  const error = new Error("CostLedger: paid call aborted");
-  error.name = "AbortError";
-  return error;
-}
-function toError(value) {
-  return value instanceof Error ? value : new Error(String(value));
-}
-function paidFailure(callId, error, receipt) {
-  return {
-    succeeded: false,
-    callId,
-    error,
-    ...receipt ? { receipt: cloneReceipt(receipt) } : {}
-  };
-}
-function validationMessage(cause) {
-  return cause instanceof z.ZodError ? z.prettifyError(cause) : toError(cause).message;
-}
-function assertUsage(usage) {
-  assertTokenCount(usage.inputTokens, "inputTokens");
-  assertTokenCount(usage.outputTokens, "outputTokens");
-  if (usage.reasoningTokens !== void 0) {
-    assertTokenCount(usage.reasoningTokens, "reasoningTokens");
-    if (usage.reasoningTokens > usage.outputTokens) {
-      throw new ValidationError("CostLedger: reasoningTokens must not exceed outputTokens");
-    }
-  }
-  if (usage.cachedTokens !== void 0) assertTokenCount(usage.cachedTokens, "cachedTokens");
-  if (usage.cacheWriteTokens !== void 0) {
-    assertTokenCount(usage.cacheWriteTokens, "cacheWriteTokens");
-  }
-}
-function assertTokenCount(value, name) {
-  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
-    throw new ValidationError(
-      `CostLedger: ${name} must be a non-negative integer, got ${String(value)}`
-    );
-  }
-}
-function assertNonNegative(value, name) {
-  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
-    throw new ValidationError(
-      `CostLedger: ${name} must be a non-negative finite number, got ${String(value)}`
-    );
-  }
-}
-function assertTimeout(value, name) {
-  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0 || value > 2147483647) {
-    throw new ValidationError(
-      `CostLedger: ${name} must be a non-negative safe integer no greater than 2147483647, got ${String(value)}`
-    );
-  }
-}
-function assertString(value, name) {
-  if (typeof value !== "string" || value.trim().length === 0) {
-    throw new ValidationError(`CostLedger: ${name} must be a non-empty string`);
-  }
-}
-
-export {
-  CostCeilingReachedError,
-  CostAccountingIncompleteError,
-  CostReservationExceededError,
-  CostCallConflictError,
-  CostLedgerPersistenceError,
-  CostReceiptCaptureError,
-  CostLedger,
-  modelPriceKey,
-  costForUsage,
-  costForTokenPricing
-};
-//# sourceMappingURL=chunk-VCZ5FQYW.js.map