@sixb/core 0.1.8 → 0.1.9

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

@@ -1,19 +1,16 @@
 // @bun
 import {
-  isModelReasoning,
-  normalizeModelProviderIds
-} from "./chunk-trxxmgnf.js";
+  normalizeAiModelCallUsage2,
+  aggregateAiModelCallUsage2,
+  normalizeAiModelCallRecord2,
+  assertAiUsageExecutionId2
+} from "./chunk-s3csryxe.js";
 import {
-  normalizeRequesterGroupIds
-} from "./chunk-4a849fr1.js";
-import {
-  assertJsonObject,
-  assertJsonValue,
-  isPlainRecord
-} from "./chunk-n6jxh8sw.js";
+  assertJsonObject2
+} from "./chunk-wy0qdqfm.js";
 
 // src/storage/ai-usage/errors.ts
-class AiUsageStorageError extends Error {
+class AiUsageStorageError2 extends Error {
   code;
   name = "AiUsageStorageError";
   constructor(code, message) {
@@ -22,144 +19,8 @@ class AiUsageStorageError extends Error {
   }
 }
 
-// src/storage/ai-usage/usage.ts
-var USAGE_FIELDS = [
-  "inputTokens",
-  "outputTokens",
-  "uncachedInputTokens",
-  "cacheReadInputTokens",
-  "cacheWriteInputTokens",
-  "textOutputTokens",
-  "reasoningOutputTokens"
-];
-function normalizeAiModelCallUsage(input) {
-  for (const field of USAGE_FIELDS) {
-    assertUsageCount(input[field], field);
-  }
-  const totalTokens = input.inputTokens === undefined || input.outputTokens === undefined ? undefined : addUsageCounts(input.inputTokens, input.outputTokens, "totalTokens");
-  const reportingStatus = input.inputTokens !== undefined && input.outputTokens !== undefined ? "complete" : USAGE_FIELDS.some((field) => input[field] !== undefined) ? "partial" : "unavailable";
-  return {
-    ...input.inputTokens === undefined ? {} : { inputTokens: input.inputTokens },
-    ...input.outputTokens === undefined ? {} : { outputTokens: input.outputTokens },
-    ...totalTokens === undefined ? {} : { totalTokens },
-    ...input.uncachedInputTokens === undefined ? {} : { uncachedInputTokens: input.uncachedInputTokens },
-    ...input.cacheReadInputTokens === undefined ? {} : { cacheReadInputTokens: input.cacheReadInputTokens },
-    ...input.cacheWriteInputTokens === undefined ? {} : { cacheWriteInputTokens: input.cacheWriteInputTokens },
-    ...input.textOutputTokens === undefined ? {} : { textOutputTokens: input.textOutputTokens },
-    ...input.reasoningOutputTokens === undefined ? {} : { reasoningOutputTokens: input.reasoningOutputTokens },
-    reportingStatus
-  };
-}
-function aggregateAiModelCallUsage(usages) {
-  const normalized = Array.from(usages, normalizeAiModelCallUsage);
-  const fields = Object.fromEntries(USAGE_FIELDS.map((field) => [field, sumUsageField(normalized, field)]));
-  const aggregate = normalizeAiModelCallUsage(fields);
-  if (aggregate.reportingStatus === "unavailable" && normalized.some((usage) => usage.reportingStatus !== "unavailable")) {
-    return { ...aggregate, reportingStatus: "partial" };
-  }
-  return aggregate;
-}
-function sumUsageField(usages, field) {
-  if (usages.length === 0)
-    return;
-  let total = 0;
-  for (const usage of usages) {
-    const value = usage[field];
-    if (value === undefined)
-      return;
-    total = addUsageCounts(total, value, `aggregate ${field}`);
-  }
-  return total;
-}
-function assertUsageCount(value, field) {
-  if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {
-    throw new TypeError(`[Sixb] AI model-call usage ${field} must be a non-negative safe integer.`);
-  }
-}
-function addUsageCounts(left, right, field) {
-  const result = left + right;
-  if (!Number.isSafeInteger(result)) {
-    throw new TypeError(`[Sixb] AI model-call usage ${field} exceeds the safe integer range.`);
-  }
-  return result;
-}
-
-// src/storage/ai-usage/record.ts
-function normalizeAiModelCallRecord(input) {
-  assertNonBlank(input.id, "id");
-  assertNonBlank(input.projectId, "projectId");
-  assertAiUsageExecutionId(input.executionId);
-  assertPositiveSafeInteger(input.attempt, "attempt");
-  assertNonBlank(input.callId, "callId");
-  assertNonBlank(input.providerId, "providerId");
-  assertNonBlank(input.requestedModelId, "requestedModelId");
-  if (input.responseModelId !== undefined) {
-    assertNonBlank(input.responseModelId, "responseModelId");
-  }
-  assertNonBlank(input.responseId, "responseId");
-  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,
-    projectId: input.projectId,
-    executionId: input.executionId,
-    attempt: input.attempt,
-    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),
-    ...rawUsage === undefined ? {} : { rawUsage },
-    occurredAt,
-    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");
-}
-function cloneRawUsage(rawUsage) {
-  if (rawUsage === undefined)
-    return;
-  if (!isPlainRecord(rawUsage)) {
-    throw new TypeError("[Sixb] AI usage rawUsage must be a JSON object.");
-  }
-  assertJsonValue(rawUsage, "AI usage rawUsage");
-  return structuredClone(rawUsage);
-}
-function assertNonBlank(value, field) {
-  if (typeof value !== "string" || value.trim().length === 0) {
-    throw new TypeError(`[Sixb] AI usage ${field} must be nonblank.`);
-  }
-}
-function assertPositiveSafeInteger(value, field) {
-  if (!Number.isSafeInteger(value) || value <= 0) {
-    throw new TypeError(`[Sixb] AI usage ${field} must be a positive safe integer.`);
-  }
-}
-function cloneValidDate(value, field) {
-  if (!(value instanceof Date) || !Number.isFinite(value.getTime())) {
-    throw new TypeError(`[Sixb] AI usage ${field} must be a valid Date.`);
-  }
-  return new Date(value);
-}
-
 // src/storage/ai-usage/in-memory.ts
-class InMemoryAiUsageStorage {
+class InMemoryAiUsageStorage2 {
   executions;
   records = new Map;
   recordKeysByIdempotencyKey = new Map;
@@ -168,7 +29,7 @@ class InMemoryAiUsageStorage {
     this.executions = executions;
   }
   async recordModelCall(input) {
-    const record = normalizeAiModelCallRecord(input);
+    const record = normalizeAiModelCallRecord2(input);
     await this.assertExecutionExists(record.projectId, record.executionId);
     const idempotencyKey = modelCallIdempotencyKey(record);
     const existingRecordKey = this.recordKeysByIdempotencyKey.get(idempotencyKey);
@@ -181,7 +42,7 @@ class InMemoryAiUsageStorage {
     }
     const recordKey = modelCallRecordKey(record.projectId, record.id);
     if (this.records.has(recordKey)) {
-      throw new AiUsageStorageError("duplicate_id", `[Sixb] AI usage record '${record.id}' already exists for project '${record.projectId}'.`);
+      throw new AiUsageStorageError2("duplicate_id", `[Sixb] AI usage record '${record.id}' already exists for project '${record.projectId}'.`);
     }
     this.records.set(recordKey, structuredClone(record));
     this.recordKeysByIdempotencyKey.set(idempotencyKey, recordKey);
@@ -197,7 +58,7 @@ class InMemoryAiUsageStorage {
     return { record: structuredClone(record), created: true };
   }
   async getLatestForExecution(input) {
-    assertAiUsageExecutionId(input.executionId);
+    assertAiUsageExecutionId2(input.executionId);
     if (typeof input.projectId !== "string" || input.projectId.trim().length === 0) {
       throw new TypeError("[Sixb] AI usage projectId must be nonblank.");
     }
@@ -224,7 +85,7 @@ class InMemoryAiUsageStorage {
     }
     const usageByExecutionId = new Map;
     for (const executionId of input.executionIds) {
-      assertAiUsageExecutionId(executionId);
+      assertAiUsageExecutionId2(executionId);
       usageByExecutionId.set(executionId, []);
     }
     if (usageByExecutionId.size === 0)
@@ -238,7 +99,7 @@ class InMemoryAiUsageStorage {
       const usages = usageByExecutionId.get(executionId) ?? [];
       return {
         modelCallCount: usages.length,
-        usage: aggregateAiModelCallUsage(usages)
+        usage: aggregateAiModelCallUsage2(usages)
       };
     });
   }
@@ -265,7 +126,7 @@ class InMemoryAiUsageStorage {
     const execution = await this.executions.getById({ projectId, id: executionId });
     if (execution)
       return;
-    throw new AiUsageStorageError("missing_execution", `[Sixb] AI usage execution '${executionId}' does not exist in project '${projectId}'.`);
+    throw new AiUsageStorageError2("missing_execution", `[Sixb] AI usage execution '${executionId}' does not exist in project '${projectId}'.`);
   }
 }
 function modelCallRecordKey(projectId, id) {
@@ -293,17 +154,17 @@ function replaceMap(target, source) {
 var DEFAULT_MODEL_CALL_PAGE_SIZE = 50;
 var MAX_MODEL_CALL_PAGE_SIZE = 200;
 var MAX_CHART_BUCKETS = 1e4;
-function normalizeAiAccountingQuery(input) {
-  assertNonBlank2(input.projectId, "accounting projectId");
+function normalizeAiAccountingQuery2(input) {
+  assertNonBlank(input.projectId, "accounting projectId");
   assertDate(input.from, "accounting from");
   assertDate(input.to, "accounting to");
   if (input.from.getTime() >= input.to.getTime()) {
     throw new TypeError("[Sixb] AI accounting from must be before to.");
   }
   if (input.providerId !== undefined)
-    assertNonBlank2(input.providerId, "accounting providerId");
+    assertNonBlank(input.providerId, "accounting providerId");
   if (input.modelId !== undefined)
-    assertNonBlank2(input.modelId, "accounting modelId");
+    assertNonBlank(input.modelId, "accounting modelId");
   return {
     projectId: input.projectId,
     from: new Date(input.from),
@@ -312,10 +173,10 @@ function normalizeAiAccountingQuery(input) {
     ...input.modelId === undefined ? {} : { modelId: input.modelId }
   };
 }
-function normalizeAiModelCallAccountingQuery(input) {
-  const query = normalizeAiAccountingQuery(input);
+function normalizeAiModelCallAccountingQuery2(input) {
+  const query = normalizeAiAccountingQuery2(input);
   if (input.executionId !== undefined) {
-    assertNonBlank2(input.executionId, "accounting executionId");
+    assertNonBlank(input.executionId, "accounting executionId");
   }
   const { limit, offset } = normalizePage(input.limit, input.offset);
   return {
@@ -331,7 +192,7 @@ function aiAccountingItemMatchesQuery(item, query) {
   return item.usage.projectId === query.projectId && occurredAt >= query.from.getTime() && occurredAt < query.to.getTime() && (query.providerId === undefined || item.usage.providerId === query.providerId) && (query.modelId === undefined || item.usage.requestedModelId === query.modelId);
 }
 function buildAiAccountingOverview(input, source) {
-  const query = normalizeAiAccountingQuery(input);
+  const query = normalizeAiAccountingQuery2(input);
   assertAiAccountingBucket(input.bucket);
   const items = Array.from(source).filter((item) => aiAccountingItemMatchesQuery(item, query));
   const periods = accountingPeriods(query.from, query.to, input.bucket);
@@ -352,7 +213,7 @@ function buildAiAccountingOverview(input, source) {
         item.attribution.agentStepId
       ]), item);
     }
-    if (item.attribution?.kind === "workflowAgent") {
+    if (item.attribution?.kind === "workflowAgent" || item.attribution?.kind === "workflow") {
       appendGrouped(workflowItems, item.attribution.workflowId, item);
     }
   }
@@ -384,8 +245,8 @@ function buildAiAccountingOverview(input, source) {
     workflows
   });
 }
-function buildAiAccountingOverviewFromFragments(input, fragments) {
-  const query = normalizeAiAccountingQuery(input);
+function buildAiAccountingOverviewFromFragments2(input, fragments) {
+  const query = normalizeAiAccountingQuery2(input);
   const periods = accountingPeriods(query.from, query.to, input.bucket);
   const totals = aggregateFragmentAccumulator();
   const series = new Map(periods.map((period) => [period.start.getTime(), aggregateFragmentAccumulator()]));
@@ -451,9 +312,9 @@ function buildAiAccountingOverviewFromFragments(input, fragments) {
   });
 }
 function buildAiModelCallAccountingList(input, source) {
-  const query = normalizeAiModelCallAccountingQuery(input);
+  const query = normalizeAiModelCallAccountingQuery2(input);
   const { limit, offset } = query;
-  const items = Array.from(source).filter((item) => aiAccountingItemMatchesQuery(item, query)).map(toAccountingItem).filter((item) => (input.executionId === undefined || item.usage.executionId === input.executionId) && (input.valuationStatus === undefined || item.valuationStatus === input.valuationStatus)).sort(compareAccountingItems);
+  const items = Array.from(source).filter((item) => aiAccountingItemMatchesQuery(item, query)).map(toAccountingItem2).filter((item) => (input.executionId === undefined || item.usage.executionId === input.executionId) && (input.valuationStatus === undefined || item.valuationStatus === input.valuationStatus)).sort(compareAccountingItems);
   const page = items.slice(offset, offset + limit);
   return structuredClone({
     items: page,
@@ -461,7 +322,7 @@ function buildAiModelCallAccountingList(input, source) {
     total: items.length
   });
 }
-function toAccountingItem(item) {
+function toAccountingItem2(item) {
   return {
     usage: item.usage,
     ...item.attribution === undefined ? {} : { attribution: item.attribution },
@@ -486,7 +347,7 @@ function aiAccountingBucketStart(at, bucket) {
 function aggregateAccountingItems(items) {
   return {
     modelCallCount: items.length,
-    usage: aggregateAiModelCallUsage(items.map((item) => item.usage.usage)),
+    usage: aggregateAiModelCallUsage2(items.map((item) => item.usage.usage)),
     costs: aggregateCosts(items)
   };
 }
@@ -575,7 +436,7 @@ function finishAggregateFragment(value) {
       }
     }
   }
-  let usage = normalizeAiModelCallUsage(usageInput);
+  let usage = normalizeAiModelCallUsage2(usageInput);
   if (usage.reportingStatus === "unavailable" && value.reportedUsageCallCount > 0n) {
     usage = { ...usage, reportingStatus: "partial" };
   }
@@ -683,15 +544,28 @@ function assertDate(value, label) {
     throw new TypeError(`[Sixb] AI ${label} must be a valid Date.`);
   }
 }
-function assertNonBlank2(value, label) {
+function assertNonBlank(value, label) {
   if (typeof value !== "string" || value.trim().length === 0) {
     throw new TypeError(`[Sixb] AI ${label} must be nonblank.`);
   }
 }
 
+// src/storage/ai-cost/attribution.ts
+function directModelCallAttribution2(kind, id, primitiveId) {
+  if (!id)
+    return;
+  if (kind === "request")
+    return { kind, requestId: id };
+  if (kind === "action" && primitiveId)
+    return { kind, actionId: primitiveId, actionRunId: id };
+  if (kind === "workflow" && primitiveId)
+    return { kind, workflowId: primitiveId, workflowRunId: id };
+  return;
+}
+
 // src/storage/ai-cost/groups.ts
-function aiModelCallGroupFragmentFromRow(row) {
-  let attribution;
+function aiModelCallGroupFragmentFromRow2(row) {
+  let attribution = directModelCallAttribution2(row.executor_kind, row.executor_id, row.primitive_id);
   if (row.root_agent_run_id && row.root_thread_id) {
     attribution = {
       kind: "agent",
@@ -726,7 +600,7 @@ function aiModelCallGroupFragmentFromRow(row) {
     }
   };
 }
-function buildAiModelCallGroupsFromFragments(fragments) {
+function buildAiModelCallGroupsFromFragments2(fragments) {
   const roots = new Map;
   for (const fragment of fragments)
     append(roots, fragment.root.executionId, fragment);
@@ -751,7 +625,7 @@ function buildAiModelCallGroupsFromFragments(fragments) {
   }).sort((a, b) => b.lastCallAt.getTime() - a.lastCallAt.getTime() || compareText(a.executionId, b.executionId));
 }
 function buildAiModelCallGroups(input, source) {
-  const query = normalizeAiModelCallAccountingQuery(input);
+  const query = normalizeAiModelCallAccountingQuery2(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 },
@@ -764,7 +638,7 @@ function buildAiModelCallGroups(input, source) {
     valuationStatus: item.cost?.status ?? "unvalued",
     ...item.cost && item.cost.status !== "unpriceable" ? { money: item.cost.money } : {}
   }));
-  const groups = buildAiModelCallGroupsFromFragments(fragments);
+  const groups = buildAiModelCallGroupsFromFragments2(fragments);
   const items = groups.slice(query.offset, query.offset + query.limit);
   return structuredClone({
     items,
@@ -858,7 +732,7 @@ var CONTEXT_STRING_FIELDS = [
   "inferenceProfileId",
   "mode"
 ];
-function normalizeAiPricingContext(input) {
+function normalizeAiPricingContext2(input) {
   if (typeof input !== "object" || input === null || Array.isArray(input)) {
     throw new TypeError("[Sixb] AI pricing context must be an object.");
   }
@@ -866,7 +740,7 @@ function normalizeAiPricingContext(input) {
   for (const field of CONTEXT_STRING_FIELDS) {
     const value = input[field];
     if (value !== undefined) {
-      assertNonBlank3(value, `pricingContext.${field}`);
+      assertNonBlank2(value, `pricingContext.${field}`);
       result[field] = value;
     }
   }
@@ -884,14 +758,14 @@ function normalizeAiPricingContext(input) {
   }
   return result;
 }
-function normalizeAiModelCallCostRecord(input) {
-  assertNonBlank3(input.projectId, "cost record projectId");
-  assertNonBlank3(input.usageRecordId, "cost record usageRecordId");
+function normalizeAiModelCallCostRecord2(input) {
+  assertNonBlank2(input.projectId, "cost record projectId");
+  assertNonBlank2(input.usageRecordId, "cost record usageRecordId");
   const base = {
     ...input.estimate === undefined ? {} : { estimate: normalizeAiCostEstimate(input.estimate) },
     projectId: input.projectId,
     usageRecordId: input.usageRecordId,
-    pricingContext: normalizeAiPricingContext(input.pricingContext),
+    pricingContext: normalizeAiPricingContext2(input.pricingContext),
     ratedAt: cloneDate(input.ratedAt, "cost record ratedAt")
   };
   if (input.status === "rated") {
@@ -908,14 +782,14 @@ function normalizeAiModelCallCostRecord(input) {
   }
   throw new TypeError("[Sixb] AI cost status is invalid.");
 }
-function aiModelCallCostMatchesUsage(record, usageRecord) {
+function aiModelCallCostMatchesUsage2(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))
+    const usage = normalizeAiModelCallUsage2(usageRecord.usage);
+    const components = new Map(record.estimate.components.map((component) => [component.meter, component]));
+    if (!inputComponentsMatchUsage(components, usage) || !outputComponentsMatchUsage(components, usage))
       return false;
   }
   if (record.status === "unpriceable")
@@ -923,7 +797,7 @@ function aiModelCallCostMatchesUsage(record, usageRecord) {
   if (record.components.length === 0 && isExternalValuationSource(record.priceSource.sourceId)) {
     return true;
   }
-  const usage = normalizeAiModelCallUsage(usageRecord.usage);
+  const usage = normalizeAiModelCallUsage2(usageRecord.usage);
   const components = new Map(record.components.map((component) => [component.meter, component]));
   return inputComponentsMatchUsage(components, usage) && outputComponentsMatchUsage(components, usage);
 }
@@ -1014,15 +888,15 @@ function normalizeRatedCost(input, base) {
   };
 }
 function normalizeAiCostEstimate(value) {
-  assertJsonObject(value, "AI cost estimate");
+  assertJsonObject2(value, "AI cost estimate");
   if (value.status === "rated") {
-    assertJsonObject(value.money, "estimate money");
+    assertJsonObject2(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);
+      assertJsonObject2(component, "estimate component");
+      const meter = [...METERS].find((meter) => meter === 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({
@@ -1040,7 +914,7 @@ function normalizeAiCostEstimate(value) {
       components
     };
   }
-  const reason = [...UNPRICEABLE_REASONS].find((reason2) => reason2 === value.reason);
+  const reason = [...UNPRICEABLE_REASONS].find((reason) => reason === value.reason);
   if (value.status !== "unpriceable" || !reason)
     throw new TypeError("[Sixb] Invalid cost estimate status or reason.");
   let missingMeters;
@@ -1048,7 +922,7 @@ function normalizeAiCostEstimate(value) {
     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);
+      const meter = [...METERS].find((meter) => meter === input);
       if (!meter)
         throw new TypeError("[Sixb] Invalid estimate missing meter.");
       return meter;
@@ -1111,11 +985,11 @@ function calculateComponent(meter, quantity, rateAmountNanosPerMillion) {
   };
 }
 function normalizePriceSource(input) {
-  assertNonBlank3(input.sourceId, "price sourceId");
-  assertNonBlank3(input.sourceEntryId, "price sourceEntryId");
-  assertNonBlank3(input.sourceVersion, "price sourceVersion");
+  assertNonBlank2(input.sourceId, "price sourceId");
+  assertNonBlank2(input.sourceEntryId, "price sourceEntryId");
+  assertNonBlank2(input.sourceVersion, "price sourceVersion");
   if (input.sourceUrl !== undefined)
-    assertNonBlank3(input.sourceUrl, "price sourceUrl");
+    assertNonBlank2(input.sourceUrl, "price sourceUrl");
   return {
     sourceId: input.sourceId,
     sourceEntryId: input.sourceEntryId,
@@ -1125,8 +999,8 @@ function normalizePriceSource(input) {
   };
 }
 function normalizeBillingIdentity(input) {
-  assertNonBlank3(input.providerId, "billingIdentity.providerId");
-  assertNonBlank3(input.modelId, "billingIdentity.modelId");
+  assertNonBlank2(input.providerId, "billingIdentity.providerId");
+  assertNonBlank2(input.modelId, "billingIdentity.modelId");
   return { providerId: input.providerId, modelId: input.modelId };
 }
 function normalizeMissingMeters(input) {
@@ -1178,7 +1052,7 @@ function assertSignedInt64(value, field) {
     throw new TypeError(`[Sixb] AI ${field} exceeds the signed 64-bit range.`);
   }
 }
-function assertNonBlank3(value, field) {
+function assertNonBlank2(value, field) {
   if (typeof value !== "string" || value.trim().length === 0) {
     throw new TypeError(`[Sixb] AI ${field} must be nonblank.`);
   }
@@ -1190,6 +1064,6 @@ function cloneDate(value, field) {
   return new Date(value);
 }
 
-export { AiUsageStorageError, normalizeAiModelCallUsage, aggregateAiModelCallUsage, normalizeAiModelCallRecord, assertAiUsageExecutionId, InMemoryAiUsageStorage, normalizeAiAccountingQuery, normalizeAiModelCallAccountingQuery, buildAiAccountingOverview, buildAiAccountingOverviewFromFragments, buildAiModelCallAccountingList, toAccountingItem, aiModelCallGroupFragmentFromRow, buildAiModelCallGroupsFromFragments, buildAiModelCallGroups, normalizeAiPricingContext, normalizeAiModelCallCostRecord, aiModelCallCostMatchesUsage, normalizeAiCostEstimate };
+export { AiUsageStorageError2, InMemoryAiUsageStorage2, normalizeAiAccountingQuery2, normalizeAiModelCallAccountingQuery2, buildAiAccountingOverview, buildAiAccountingOverviewFromFragments2, buildAiModelCallAccountingList, toAccountingItem2, directModelCallAttribution2, aiModelCallGroupFragmentFromRow2, buildAiModelCallGroupsFromFragments2, buildAiModelCallGroups, normalizeAiPricingContext2, normalizeAiModelCallCostRecord2, aiModelCallCostMatchesUsage2, normalizeAiCostEstimate };
 
-//# debugId=EFFF98F246C92D1864756E2164756E21
+//# debugId=3EFE5C3CDFF5349664756E2164756E21