@sixb/core 0.1.6 → 0.1.8

package/dist/{chunk-drjqm1aa.js → chunk-p03r0h5s.js}

@@ -1,11 +1,16 @@
 // @bun
+import {
+  isModelReasoning,
+  normalizeModelProviderIds
+} from "./chunk-trxxmgnf.js";
 import {
   normalizeRequesterGroupIds
-} from "./chunk-rhrbz7d4.js";
+} from "./chunk-4a849fr1.js";
 import {
+  assertJsonObject,
   assertJsonValue,
   isPlainRecord
-} from "./chunk-t8t39h7v.js";
+} from "./chunk-n6jxh8sw.js";
 
 // src/storage/ai-usage/errors.ts
 class AiUsageStorageError extends Error {
@@ -95,6 +100,7 @@ function normalizeAiModelCallRecord(input) {
   const occurredAt = cloneValidDate(input.occurredAt, "occurredAt");
   const recordedAt = cloneValidDate(input.recordedAt ?? new Date, "recordedAt");
   const requesterGroupIds = normalizeRequesterGroupIds(input.requesterGroupIds);
+  const requestedReasoning = cloneRequestedReasoning(input.requestedReasoning);
   const rawUsage = cloneRawUsage(input.rawUsage);
   return {
     id: input.id,
@@ -104,7 +110,9 @@ function normalizeAiModelCallRecord(input) {
     callId: input.callId,
     requesterGroupIds,
     providerId: input.providerId,
+    ...input.providerIds === undefined ? {} : { providerIds: normalizeModelProviderIds(input.providerIds) },
     requestedModelId: input.requestedModelId,
+    ...requestedReasoning === undefined ? {} : { requestedReasoning },
     ...input.responseModelId === undefined ? {} : { responseModelId: input.responseModelId },
     responseId: input.responseId,
     usage: normalizeAiModelCallUsage(input.usage),
@@ -113,6 +121,14 @@ function normalizeAiModelCallRecord(input) {
     recordedAt
   };
 }
+function cloneRequestedReasoning(reasoning) {
+  if (reasoning === undefined)
+    return;
+  if (!isModelReasoning(reasoning)) {
+    throw new TypeError("[Sixb] AI usage requestedReasoning is invalid.");
+  }
+  return typeof reasoning === "string" ? reasoning : { budgetTokens: reasoning.budgetTokens };
+}
 function assertAiUsageExecutionId(executionId) {
   assertNonBlank(executionId, "executionId");
 }
@@ -238,6 +254,13 @@ class InMemoryAiUsageStorage {
     replaceMap(this.recordKeysByIdempotencyKey, snapshot.recordKeysByIdempotencyKey);
     replaceMap(this.groupRows, snapshot.groupRows);
   }
+  getRecord(projectId, id) {
+    const record = this.records.get(modelCallRecordKey(projectId, id));
+    return record ? structuredClone(record) : null;
+  }
+  listRecords(projectId) {
+    return [...this.records.values()].filter((record) => record.projectId === projectId).map((record) => structuredClone(record));
+  }
   async assertExecutionExists(projectId, executionId) {
     const execution = await this.executions.getById({ projectId, id: executionId });
     if (execution)
@@ -320,8 +343,15 @@ function buildAiAccountingOverview(input, source) {
     const periodStart = aiAccountingBucketStart(item.usage.occurredAt, input.bucket).getTime();
     periodItems.get(periodStart)?.push(item);
     appendGrouped(modelItems, JSON.stringify([item.usage.providerId, item.usage.requestedModelId]), item);
-    if (item.attribution)
-      appendGrouped(agentItems, item.attribution.agentId, item);
+    if (item.attribution?.kind === "agent") {
+      appendGrouped(agentItems, JSON.stringify(["agent"]), item);
+    } else if (item.attribution?.kind === "workflowAgent") {
+      appendGrouped(agentItems, JSON.stringify([
+        "workflowAgent",
+        item.attribution.workflowId,
+        item.attribution.agentStepId
+      ]), item);
+    }
     if (item.attribution?.kind === "workflowAgent") {
       appendGrouped(workflowItems, item.attribution.workflowId, item);
     }
@@ -334,7 +364,15 @@ function buildAiAccountingOverview(input, source) {
     const [providerId, modelId] = JSON.parse(key);
     return { providerId, modelId, ...aggregateAccountingItems(grouped) };
   }).sort(compareModelBreakdowns);
-  const agents = [...agentItems].map(([agentId, grouped]) => ({ agentId, ...aggregateAccountingItems(grouped) })).sort(compareAgentBreakdowns);
+  const agents = [...agentItems].map(([key, grouped]) => {
+    const [kind, workflowId, agentStepId] = JSON.parse(key);
+    return kind === "agent" ? { kind, ...aggregateAccountingItems(grouped) } : {
+      kind,
+      workflowId: requiredFragmentString(workflowId, "workflowId"),
+      agentStepId: requiredFragmentString(agentStepId, "agentStepId"),
+      ...aggregateAccountingItems(grouped)
+    };
+  }).sort(compareAgentBreakdowns);
   const workflows = [...workflowItems].map(([workflowId, grouped]) => ({ workflowId, ...aggregateAccountingItems(grouped) })).sort(compareWorkflowBreakdowns);
   return structuredClone({
     range: { from: query.from, to: query.to },
@@ -376,7 +414,11 @@ function buildAiAccountingOverviewFromFragments(input, fragments) {
         ]));
         break;
       case "agent":
-        target = getFragmentAccumulator(agents, requiredFragmentString(fragment.agentId, "agentId"));
+        target = getFragmentAccumulator(agents, JSON.stringify([
+          requiredFragmentString(fragment.agentKind, "agentKind"),
+          fragment.workflowId,
+          fragment.agentStepId
+        ]));
         break;
       case "workflow":
         target = getFragmentAccumulator(workflows, requiredFragmentString(fragment.workflowId, "workflowId"));
@@ -396,7 +438,15 @@ function buildAiAccountingOverviewFromFragments(input, fragments) {
       const [providerId, modelId] = JSON.parse(key);
       return { providerId, modelId, ...finishAggregateFragment(value) };
     }).sort(compareModelBreakdowns),
-    agents: [...agents].map(([agentId, value]) => ({ agentId, ...finishAggregateFragment(value) })).sort(compareAgentBreakdowns),
+    agents: [...agents].map(([key, value]) => {
+      const [kind, workflowId, agentStepId] = JSON.parse(key);
+      return kind === "agent" ? { kind, ...finishAggregateFragment(value) } : {
+        kind,
+        workflowId: requiredFragmentString(workflowId, "workflowId"),
+        agentStepId: requiredFragmentString(agentStepId, "agentStepId"),
+        ...finishAggregateFragment(value)
+      };
+    }).sort(compareAgentBreakdowns),
     workflows: [...workflows].map(([workflowId, value]) => ({ workflowId, ...finishAggregateFragment(value) })).sort(compareWorkflowBreakdowns)
   });
 }
@@ -612,7 +662,10 @@ function compareAccountingItems(left, right) {
   return right.usage.occurredAt.getTime() - left.usage.occurredAt.getTime() || left.usage.id.localeCompare(right.usage.id);
 }
 function compareAgentBreakdowns(left, right) {
-  return right.modelCallCount - left.modelCallCount || left.agentId.localeCompare(right.agentId);
+  return right.modelCallCount - left.modelCallCount || agentBreakdownKey(left).localeCompare(agentBreakdownKey(right));
+}
+function agentBreakdownKey(value) {
+  return value.kind === "agent" ? "agent" : JSON.stringify(["workflowAgent", value.workflowId, value.agentStepId]);
 }
 function compareWorkflowBreakdowns(left, right) {
   return right.modelCallCount - left.modelCallCount || left.workflowId.localeCompare(right.workflowId);
@@ -636,6 +689,141 @@ function assertNonBlank2(value, label) {
   }
 }
 
+// src/storage/ai-cost/groups.ts
+function aiModelCallGroupFragmentFromRow(row) {
+  let attribution;
+  if (row.root_agent_run_id && row.root_thread_id) {
+    attribution = {
+      kind: "agent",
+      agentRunId: row.root_agent_run_id,
+      threadId: row.root_thread_id
+    };
+  } else if (row.workflow_agent_step_id && row.workflow_node_run_id && row.workflow_id && row.workflow_run_id) {
+    attribution = {
+      kind: "workflowAgent",
+      agentStepId: row.workflow_agent_step_id,
+      nodeRunId: row.workflow_node_run_id,
+      workflowId: row.workflow_id,
+      workflowRunId: row.workflow_run_id
+    };
+  }
+  const executionAttribution = row.direct_kind === "subagent" && row.direct_run_id && row.parent_run_id ? { kind: "subagent", subagentRunId: row.direct_run_id, parentRunId: row.parent_run_id } : attribution;
+  return {
+    root: { executionId: row.root_execution_id, attribution },
+    execution: { executionId: row.execution_id, attribution: executionAttribution },
+    model: { providerId: row.provider_id, modelId: row.requested_model_id },
+    firstCallAt: new Date(row.first_call_at),
+    lastCallAt: new Date(row.last_call_at),
+    callCount: row.call_count,
+    tokenCount: row.token_count,
+    totalTokens: row.total_tokens,
+    valuationStatus: row.valuation_status,
+    ...row.amount_currency === null ? {} : {
+      money: {
+        currency: row.amount_currency,
+        amountNanos: (BigInt(row.amount_high ?? "0") * 1000000000000n + BigInt(row.amount_middle ?? "0") * 1000000n + BigInt(row.amount_low ?? "0")).toString()
+      }
+    }
+  };
+}
+function buildAiModelCallGroupsFromFragments(fragments) {
+  const roots = new Map;
+  for (const fragment of fragments)
+    append(roots, fragment.root.executionId, fragment);
+  return [...roots.values()].map((rootFragments) => {
+    const first = rootFragments[0];
+    const executions = new Map;
+    for (const fragment of rootFragments)
+      append(executions, fragment.execution.executionId, fragment);
+    return {
+      ...first.root,
+      ...summarize(rootFragments),
+      ...timeRange(rootFragments),
+      executions: [...executions.values()].map((items) => ({
+        ...items[0].execution,
+        ...summarize(items),
+        ...timeRange(items),
+        models: [
+          ...new Map(items.map(({ model }) => [JSON.stringify(model), model])).values()
+        ].sort((a, b) => compareText(a.providerId, b.providerId) || compareText(a.modelId, b.modelId))
+      })).sort((a, b) => a.firstCallAt.getTime() - b.firstCallAt.getTime() || compareText(a.executionId, b.executionId))
+    };
+  }).sort((a, b) => b.lastCallAt.getTime() - a.lastCallAt.getTime() || compareText(a.executionId, b.executionId));
+}
+function buildAiModelCallGroups(input, source) {
+  const query = normalizeAiModelCallAccountingQuery(input);
+  const fragments = source.filter((item) => aiAccountingItemMatchesQuery(item, query) && (query.valuationStatus === undefined || (item.cost?.status ?? "unvalued") === query.valuationStatus)).map((item) => ({
+    root: item.root,
+    execution: { executionId: item.usage.executionId, attribution: item.attribution },
+    model: { providerId: item.usage.providerId, modelId: item.usage.requestedModelId },
+    firstCallAt: item.usage.occurredAt,
+    lastCallAt: item.usage.occurredAt,
+    callCount: "1",
+    tokenCount: item.usage.usage.totalTokens === undefined ? "0" : "1",
+    totalTokens: item.usage.usage.totalTokens?.toString() ?? null,
+    valuationStatus: item.cost?.status ?? "unvalued",
+    ...item.cost && item.cost.status !== "unpriceable" ? { money: item.cost.money } : {}
+  }));
+  const groups = buildAiModelCallGroupsFromFragments(fragments);
+  const items = groups.slice(query.offset, query.offset + query.limit);
+  return structuredClone({
+    items,
+    total: groups.length,
+    hasMore: query.offset + items.length < groups.length
+  });
+}
+function summarize(items) {
+  let calls = 0n;
+  let tokenCount = 0n;
+  let tokens = 0n;
+  const counts = { rated: 0n, unpriceable: 0n, unvalued: 0n };
+  const money = new Map;
+  for (const item of items) {
+    const count = BigInt(item.callCount);
+    calls += count;
+    tokenCount += BigInt(item.tokenCount);
+    tokens += BigInt(item.totalTokens ?? "0");
+    counts[item.valuationStatus] += count;
+    if (item.money)
+      money.set(item.money.currency, (money.get(item.money.currency) ?? 0n) + BigInt(item.money.amountNanos));
+  }
+  const costs = {
+    amounts: [...money].sort(([a], [b]) => a.localeCompare(b)).map(([currency, amount]) => ({ currency, amountNanos: amount.toString() })),
+    ratedCallCount: safeCount(counts.rated),
+    unpriceableCallCount: safeCount(counts.unpriceable),
+    unvaluedCallCount: safeCount(counts.unvalued)
+  };
+  return {
+    modelCallCount: safeCount(calls),
+    ...calls === tokenCount ? { totalTokens: safeCount(tokens) } : {},
+    costs
+  };
+}
+function timeRange(items) {
+  let first = items[0].firstCallAt.getTime();
+  let last = items[0].lastCallAt.getTime();
+  for (const item of items) {
+    first = Math.min(first, item.firstCallAt.getTime());
+    last = Math.max(last, item.lastCallAt.getTime());
+  }
+  return { firstCallAt: new Date(first), lastCallAt: new Date(last) };
+}
+function compareText(a, b) {
+  return a === b ? 0 : a < b ? -1 : 1;
+}
+function safeCount(value) {
+  if (value < 0n || value > BigInt(Number.MAX_SAFE_INTEGER))
+    throw new RangeError("[Sixb] AI accounting group count exceeds the safe integer range.");
+  return Number(value);
+}
+function append(map, key, item) {
+  const items = map.get(key);
+  if (items)
+    items.push(item);
+  else
+    map.set(key, [item]);
+}
+
 // src/storage/ai-cost/validation.ts
 var SIGNED_INT64_MAX = 9223372036854775807n;
 var TOKENS_PER_MILLION = 1000000n;
@@ -646,14 +834,16 @@ var METER_ORDER = {
   "tokens.input.uncached": 1,
   "tokens.input.cacheRead": 2,
   "tokens.input.cacheWrite": 3,
-  "tokens.output.total": 4,
-  "tokens.output.text": 5,
-  "tokens.output.reasoning": 6
+  "tokens.input.cacheWrite5m": 4,
+  "tokens.input.cacheWrite1h": 5,
+  "tokens.output.total": 6,
+  "tokens.output.text": 7,
+  "tokens.output.reasoning": 8
 };
 var METERS = new Set(Object.keys(METER_ORDER));
 var UNPRICEABLE_REASONS = new Set([
   "missingBillingIdentity",
-  "missingCatalogEntry",
+  "missingRateCard",
   "missingUsageMeter",
   "unsupportedPricingDimension",
   "invalidUsageForFormula"
@@ -663,6 +853,7 @@ var CONTEXT_STRING_FIELDS = [
   "region",
   "inferenceGeo",
   "routedProviderId",
+  "routedModelId",
   "deploymentId",
   "inferenceProfileId",
   "mode"
@@ -697,24 +888,41 @@ function normalizeAiModelCallCostRecord(input) {
   assertNonBlank3(input.projectId, "cost record projectId");
   assertNonBlank3(input.usageRecordId, "cost record usageRecordId");
   const base = {
+    ...input.estimate === undefined ? {} : { estimate: normalizeAiCostEstimate(input.estimate) },
     projectId: input.projectId,
     usageRecordId: input.usageRecordId,
     pricingContext: normalizeAiPricingContext(input.pricingContext),
-    priceSource: normalizePriceSource(input.priceSource),
     ratedAt: cloneDate(input.ratedAt, "cost record ratedAt")
   };
-  if (input.status === "rated")
-    return normalizeRatedCost(input, base);
-  if (input.status === "unpriceable")
-    return normalizeUnpriceableCost(input, base);
+  if (input.status === "rated") {
+    return normalizeRatedCost(input, {
+      ...base,
+      priceSource: normalizePriceSource(input.priceSource)
+    });
+  }
+  if (input.status === "unpriceable") {
+    return normalizeUnpriceableCost(input, {
+      ...base,
+      ...input.priceSource === undefined ? {} : { priceSource: normalizePriceSource(input.priceSource) }
+    });
+  }
   throw new TypeError("[Sixb] AI cost status is invalid.");
 }
 function aiModelCallCostMatchesUsage(record, usageRecord) {
   if (record.projectId !== usageRecord.projectId || record.usageRecordId !== usageRecord.id) {
     return false;
   }
+  if (record.estimate?.status === "rated") {
+    const usage2 = normalizeAiModelCallUsage(usageRecord.usage);
+    const components2 = new Map(record.estimate.components.map((component) => [component.meter, component]));
+    if (!inputComponentsMatchUsage(components2, usage2) || !outputComponentsMatchUsage(components2, usage2))
+      return false;
+  }
   if (record.status === "unpriceable")
     return true;
+  if (record.components.length === 0 && isExternalValuationSource(record.priceSource.sourceId)) {
+    return true;
+  }
   const usage = normalizeAiModelCallUsage(usageRecord.usage);
   const components = new Map(record.components.map((component) => [component.meter, component]));
   return inputComponentsMatchUsage(components, usage) && outputComponentsMatchUsage(components, usage);
@@ -723,19 +931,25 @@ function inputComponentsMatchUsage(components, usage) {
   if (usage.inputTokens === undefined)
     return false;
   const total = components.get("tokens.input.total");
-  const partitions = [
+  const directPartitions = [
     ["tokens.input.uncached", usage.uncachedInputTokens],
     ["tokens.input.cacheRead", usage.cacheReadInputTokens],
     ["tokens.input.cacheWrite", usage.cacheWriteInputTokens]
   ];
-  const presentPartitions = partitions.filter(([meter]) => components.has(meter));
+  const presentDirect = directPartitions.filter(([meter]) => components.has(meter));
+  const specificWrites = [
+    components.get("tokens.input.cacheWrite5m"),
+    components.get("tokens.input.cacheWrite1h")
+  ].filter((component) => component !== undefined);
   if (total) {
-    return presentPartitions.length === 0 && BigInt(total.quantity) === BigInt(usage.inputTokens);
+    return presentDirect.length === 0 && specificWrites.length === 0 && BigInt(total.quantity) === BigInt(usage.inputTokens);
   }
-  if (presentPartitions.length === 0)
+  if (presentDirect.length === 0 && specificWrites.length === 0)
+    return false;
+  if (components.has("tokens.input.cacheWrite") && specificWrites.length > 0)
     return false;
   let quantity = 0n;
-  for (const [meter, expected] of presentPartitions) {
+  for (const [meter, expected] of presentDirect) {
     if (expected === undefined)
       return false;
     const component = components.get(meter);
@@ -743,6 +957,14 @@ function inputComponentsMatchUsage(components, usage) {
       return false;
     quantity += BigInt(component.quantity);
   }
+  if (specificWrites.length > 0) {
+    if (usage.cacheWriteInputTokens === undefined)
+      return false;
+    const specificWriteQuantity = specificWrites.reduce((sum, component) => sum + BigInt(component.quantity), 0n);
+    if (specificWriteQuantity !== BigInt(usage.cacheWriteInputTokens))
+      return false;
+    quantity += specificWriteQuantity;
+  }
   return quantity === BigInt(usage.inputTokens);
 }
 function outputComponentsMatchUsage(components, usage) {
@@ -773,13 +995,14 @@ function outputComponentsMatchUsage(components, usage) {
 function normalizeRatedCost(input, base) {
   const billingIdentity = normalizeBillingIdentity(input.billingIdentity);
   const components = input.components.map(normalizeCostComponent).sort(compareComponents);
-  if (components.length === 0)
+  if (components.length === 0 && !isExternalValuationSource(base.priceSource.sourceId)) {
     throw new TypeError("[Sixb] AI rated cost requires components.");
+  }
   if (new Set(components.map((component) => component.meter)).size !== components.length) {
     throw new TypeError("[Sixb] AI rated cost cannot contain duplicate meters.");
   }
   const amountNanos = parseNonnegativeInt64(input.money.amountNanos, "money amountNanos").toString();
-  if (amountNanos !== sumComponents(components)) {
+  if (components.length > 0 && amountNanos !== sumComponents(components)) {
     throw new TypeError("[Sixb] AI cost total does not equal its component charges.");
   }
   return {
@@ -790,6 +1013,58 @@ function normalizeRatedCost(input, base) {
     components
   };
 }
+function normalizeAiCostEstimate(value) {
+  assertJsonObject(value, "AI cost estimate");
+  if (value.status === "rated") {
+    assertJsonObject(value.money, "estimate money");
+    const { currency, amountNanos } = value.money;
+    if (typeof currency !== "string" || typeof amountNanos !== "string" || !Array.isArray(value.components))
+      throw new TypeError("[Sixb] Invalid cost estimate money or components.");
+    const components = value.components.map((component) => {
+      assertJsonObject(component, "estimate component");
+      const meter = [...METERS].find((meter2) => meter2 === component.meter);
+      if (!meter || typeof component.quantity !== "string" || typeof component.rateAmountNanosPerMillion !== "string" || typeof component.chargeAmountNanos !== "string")
+        throw new TypeError("[Sixb] Invalid cost estimate component.");
+      return normalizeCostComponent({
+        meter,
+        quantity: component.quantity,
+        rateAmountNanosPerMillion: component.rateAmountNanosPerMillion,
+        chargeAmountNanos: component.chargeAmountNanos
+      });
+    }).sort(compareComponents);
+    if (!components.length || new Set(components.map((c) => c.meter)).size !== components.length || parseNonnegativeInt64(amountNanos, "estimate amountNanos").toString() !== sumComponents(components))
+      throw new TypeError("[Sixb] Estimate must contain unique meters whose charges equal its total.");
+    return {
+      status: "rated",
+      money: { currency: normalizeCurrency(currency), amountNanos },
+      components
+    };
+  }
+  const reason = [...UNPRICEABLE_REASONS].find((reason2) => reason2 === value.reason);
+  if (value.status !== "unpriceable" || !reason)
+    throw new TypeError("[Sixb] Invalid cost estimate status or reason.");
+  let missingMeters;
+  if (value.missingMeters !== undefined) {
+    if (!Array.isArray(value.missingMeters))
+      throw new TypeError("[Sixb] Invalid estimate missing meters.");
+    missingMeters = normalizeMissingMeters(value.missingMeters.map((input) => {
+      const meter = [...METERS].find((meter2) => meter2 === input);
+      if (!meter)
+        throw new TypeError("[Sixb] Invalid estimate missing meter.");
+      return meter;
+    }));
+  }
+  if (reason === "missingUsageMeter" && !missingMeters)
+    throw new TypeError("[Sixb] Missing usage estimate requires missingMeters.");
+  return {
+    status: "unpriceable",
+    reason,
+    ...missingMeters === undefined ? {} : { missingMeters }
+  };
+}
+function isExternalValuationSource(sourceId) {
+  return sourceId === "provider-reported";
+}
 function normalizeUnpriceableCost(input, base) {
   if (!UNPRICEABLE_REASONS.has(input.reason)) {
     throw new TypeError(`[Sixb] AI unpriceable reason '${String(input.reason)}' is invalid.`);
@@ -839,8 +1114,15 @@ function normalizePriceSource(input) {
   assertNonBlank3(input.sourceId, "price sourceId");
   assertNonBlank3(input.sourceEntryId, "price sourceEntryId");
   assertNonBlank3(input.sourceVersion, "price sourceVersion");
-  assertNonBlank3(input.sourceUrl, "price sourceUrl");
-  return { ...input, observedAt: cloneDate(input.observedAt, "price source observedAt") };
+  if (input.sourceUrl !== undefined)
+    assertNonBlank3(input.sourceUrl, "price sourceUrl");
+  return {
+    sourceId: input.sourceId,
+    sourceEntryId: input.sourceEntryId,
+    sourceVersion: input.sourceVersion,
+    ...input.sourceUrl === undefined ? {} : { sourceUrl: input.sourceUrl },
+    observedAt: cloneDate(input.observedAt, "price source observedAt")
+  };
 }
 function normalizeBillingIdentity(input) {
   assertNonBlank3(input.providerId, "billingIdentity.providerId");
@@ -908,6 +1190,6 @@ function cloneDate(value, field) {
   return new Date(value);
 }
 
-export { AiUsageStorageError, normalizeAiModelCallUsage, aggregateAiModelCallUsage, normalizeAiModelCallRecord, assertAiUsageExecutionId, InMemoryAiUsageStorage, normalizeAiAccountingQuery, normalizeAiModelCallAccountingQuery, buildAiAccountingOverview, buildAiAccountingOverviewFromFragments, buildAiModelCallAccountingList, toAccountingItem, normalizeAiPricingContext, normalizeAiModelCallCostRecord, aiModelCallCostMatchesUsage };
+export { AiUsageStorageError, normalizeAiModelCallUsage, aggregateAiModelCallUsage, normalizeAiModelCallRecord, assertAiUsageExecutionId, InMemoryAiUsageStorage, normalizeAiAccountingQuery, normalizeAiModelCallAccountingQuery, buildAiAccountingOverview, buildAiAccountingOverviewFromFragments, buildAiModelCallAccountingList, toAccountingItem, aiModelCallGroupFragmentFromRow, buildAiModelCallGroupsFromFragments, buildAiModelCallGroups, normalizeAiPricingContext, normalizeAiModelCallCostRecord, aiModelCallCostMatchesUsage, normalizeAiCostEstimate };
 
-//# debugId=084861E374895B3F64756E2164756E21
+//# debugId=EFFF98F246C92D1864756E2164756E21