@sixb/core 0.1.2 → 0.1.4

package/dist/chunk-drjqm1aa.js

@@ -0,0 +1,913 @@
+// @bun
+import {
+  normalizeRequesterGroupIds
+} from "./chunk-rhrbz7d4.js";
+import {
+  assertJsonValue,
+  isPlainRecord
+} from "./chunk-t8t39h7v.js";
+
+// src/storage/ai-usage/errors.ts
+class AiUsageStorageError extends Error {
+  code;
+  name = "AiUsageStorageError";
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+}
+
+// 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 rawUsage = cloneRawUsage(input.rawUsage);
+  return {
+    id: input.id,
+    projectId: input.projectId,
+    executionId: input.executionId,
+    attempt: input.attempt,
+    callId: input.callId,
+    requesterGroupIds,
+    providerId: input.providerId,
+    requestedModelId: input.requestedModelId,
+    ...input.responseModelId === undefined ? {} : { responseModelId: input.responseModelId },
+    responseId: input.responseId,
+    usage: normalizeAiModelCallUsage(input.usage),
+    ...rawUsage === undefined ? {} : { rawUsage },
+    occurredAt,
+    recordedAt
+  };
+}
+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 {
+  executions;
+  records = new Map;
+  recordKeysByIdempotencyKey = new Map;
+  groupRows = new Map;
+  constructor(executions) {
+    this.executions = executions;
+  }
+  async recordModelCall(input) {
+    const record = normalizeAiModelCallRecord(input);
+    await this.assertExecutionExists(record.projectId, record.executionId);
+    const idempotencyKey = modelCallIdempotencyKey(record);
+    const existingRecordKey = this.recordKeysByIdempotencyKey.get(idempotencyKey);
+    if (existingRecordKey !== undefined) {
+      const existing = this.records.get(existingRecordKey);
+      if (!existing) {
+        throw new Error("[Sixb] In-memory AI usage idempotency index is inconsistent.");
+      }
+      return { record: structuredClone(existing), created: false };
+    }
+    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}'.`);
+    }
+    this.records.set(recordKey, structuredClone(record));
+    this.recordKeysByIdempotencyKey.set(idempotencyKey, recordKey);
+    for (const groupId of record.requesterGroupIds) {
+      const row = {
+        projectId: record.projectId,
+        usageRecordId: record.id,
+        groupId,
+        occurredAt: record.occurredAt
+      };
+      this.groupRows.set(groupRowKey(row), row);
+    }
+    return { record: structuredClone(record), created: true };
+  }
+  async getLatestForExecution(input) {
+    assertAiUsageExecutionId(input.executionId);
+    if (typeof input.projectId !== "string" || input.projectId.trim().length === 0) {
+      throw new TypeError("[Sixb] AI usage projectId must be nonblank.");
+    }
+    let latest = null;
+    for (const record of this.records.values()) {
+      if (record.projectId !== input.projectId || record.executionId !== input.executionId)
+        continue;
+      if (!latest || record.occurredAt.getTime() > latest.occurredAt.getTime() || record.occurredAt.getTime() === latest.occurredAt.getTime() && record.id > latest.id) {
+        latest = record;
+      }
+    }
+    return latest ? structuredClone(latest) : null;
+  }
+  async summarizeExecution(input) {
+    const [summary] = await this.summarizeExecutions({
+      projectId: input.projectId,
+      executionIds: [input.executionId]
+    });
+    return summary;
+  }
+  async summarizeExecutions(input) {
+    if (typeof input.projectId !== "string" || input.projectId.trim().length === 0) {
+      throw new TypeError("[Sixb] AI usage projectId must be nonblank.");
+    }
+    const usageByExecutionId = new Map;
+    for (const executionId of input.executionIds) {
+      assertAiUsageExecutionId(executionId);
+      usageByExecutionId.set(executionId, []);
+    }
+    if (usageByExecutionId.size === 0)
+      return [];
+    for (const record of this.records.values()) {
+      if (record.projectId !== input.projectId)
+        continue;
+      usageByExecutionId.get(record.executionId)?.push(record.usage);
+    }
+    return input.executionIds.map((executionId) => {
+      const usages = usageByExecutionId.get(executionId) ?? [];
+      return {
+        modelCallCount: usages.length,
+        usage: aggregateAiModelCallUsage(usages)
+      };
+    });
+  }
+  snapshot() {
+    return structuredClone({
+      records: this.records,
+      recordKeysByIdempotencyKey: this.recordKeysByIdempotencyKey,
+      groupRows: this.groupRows
+    });
+  }
+  restore(snapshot) {
+    replaceMap(this.records, snapshot.records);
+    replaceMap(this.recordKeysByIdempotencyKey, snapshot.recordKeysByIdempotencyKey);
+    replaceMap(this.groupRows, snapshot.groupRows);
+  }
+  async assertExecutionExists(projectId, executionId) {
+    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}'.`);
+  }
+}
+function modelCallRecordKey(projectId, id) {
+  return JSON.stringify([projectId, id]);
+}
+function modelCallIdempotencyKey(record) {
+  return JSON.stringify([
+    record.projectId,
+    record.executionId,
+    record.attempt,
+    record.callId,
+    record.responseId
+  ]);
+}
+function groupRowKey(row) {
+  return JSON.stringify([row.projectId, row.usageRecordId, row.groupId]);
+}
+function replaceMap(target, source) {
+  target.clear();
+  for (const [key, value] of structuredClone(source)) {
+    target.set(key, value);
+  }
+}
+// src/storage/ai-cost/analytics.ts
+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");
+  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");
+  if (input.modelId !== undefined)
+    assertNonBlank2(input.modelId, "accounting modelId");
+  return {
+    projectId: input.projectId,
+    from: new Date(input.from),
+    to: new Date(input.to),
+    ...input.providerId === undefined ? {} : { providerId: input.providerId },
+    ...input.modelId === undefined ? {} : { modelId: input.modelId }
+  };
+}
+function normalizeAiModelCallAccountingQuery(input) {
+  const query = normalizeAiAccountingQuery(input);
+  if (input.executionId !== undefined) {
+    assertNonBlank2(input.executionId, "accounting executionId");
+  }
+  const { limit, offset } = normalizePage(input.limit, input.offset);
+  return {
+    ...query,
+    ...input.executionId === undefined ? {} : { executionId: input.executionId },
+    ...input.valuationStatus === undefined ? {} : { valuationStatus: input.valuationStatus },
+    limit,
+    offset
+  };
+}
+function aiAccountingItemMatchesQuery(item, query) {
+  const occurredAt = item.usage.occurredAt.getTime();
+  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);
+  assertAiAccountingBucket(input.bucket);
+  const items = Array.from(source).filter((item) => aiAccountingItemMatchesQuery(item, query));
+  const periods = accountingPeriods(query.from, query.to, input.bucket);
+  const periodItems = new Map(periods.map((period) => [period.start.getTime(), []]));
+  const modelItems = new Map;
+  const agentItems = new Map;
+  const workflowItems = new Map;
+  for (const item of items) {
+    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 === "workflowAgent") {
+      appendGrouped(workflowItems, item.attribution.workflowId, item);
+    }
+  }
+  const series = periods.map((period) => ({
+    ...period,
+    ...aggregateAccountingItems(periodItems.get(period.start.getTime()) ?? [])
+  }));
+  const models = [...modelItems].map(([key, grouped]) => {
+    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 workflows = [...workflowItems].map(([workflowId, grouped]) => ({ workflowId, ...aggregateAccountingItems(grouped) })).sort(compareWorkflowBreakdowns);
+  return structuredClone({
+    range: { from: query.from, to: query.to },
+    bucket: input.bucket,
+    totals: aggregateAccountingItems(items),
+    series,
+    models,
+    agents,
+    workflows
+  });
+}
+function buildAiAccountingOverviewFromFragments(input, fragments) {
+  const query = normalizeAiAccountingQuery(input);
+  const periods = accountingPeriods(query.from, query.to, input.bucket);
+  const totals = aggregateFragmentAccumulator();
+  const series = new Map(periods.map((period) => [period.start.getTime(), aggregateFragmentAccumulator()]));
+  const models = new Map;
+  const agents = new Map;
+  const workflows = new Map;
+  for (const fragment of fragments) {
+    let target;
+    switch (fragment.dimension) {
+      case "totals":
+        target = totals;
+        break;
+      case "series": {
+        const start = requiredFragmentDate(fragment.start, "series start");
+        const existing = series.get(start.getTime());
+        if (!existing) {
+          throw new TypeError("[Sixb] AI accounting SQL series returned an unexpected bucket.");
+        }
+        target = existing;
+        break;
+      }
+      case "model":
+        target = getFragmentAccumulator(models, JSON.stringify([
+          requiredFragmentString(fragment.providerId, "providerId"),
+          requiredFragmentString(fragment.modelId, "modelId")
+        ]));
+        break;
+      case "agent":
+        target = getFragmentAccumulator(agents, requiredFragmentString(fragment.agentId, "agentId"));
+        break;
+      case "workflow":
+        target = getFragmentAccumulator(workflows, requiredFragmentString(fragment.workflowId, "workflowId"));
+        break;
+    }
+    appendAggregateFragment(target, fragment);
+  }
+  return structuredClone({
+    range: { from: query.from, to: query.to },
+    bucket: input.bucket,
+    totals: finishAggregateFragment(totals),
+    series: periods.map((period) => ({
+      ...period,
+      ...finishAggregateFragment(series.get(period.start.getTime()))
+    })),
+    models: [...models].map(([key, value]) => {
+      const [providerId, modelId] = JSON.parse(key);
+      return { providerId, modelId, ...finishAggregateFragment(value) };
+    }).sort(compareModelBreakdowns),
+    agents: [...agents].map(([agentId, value]) => ({ agentId, ...finishAggregateFragment(value) })).sort(compareAgentBreakdowns),
+    workflows: [...workflows].map(([workflowId, value]) => ({ workflowId, ...finishAggregateFragment(value) })).sort(compareWorkflowBreakdowns)
+  });
+}
+function buildAiModelCallAccountingList(input, source) {
+  const query = normalizeAiModelCallAccountingQuery(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 page = items.slice(offset, offset + limit);
+  return structuredClone({
+    items: page,
+    hasMore: offset + page.length < items.length,
+    total: items.length
+  });
+}
+function toAccountingItem(item) {
+  return {
+    usage: item.usage,
+    ...item.attribution === undefined ? {} : { attribution: item.attribution },
+    ...item.cost === undefined ? {} : { cost: item.cost },
+    valuationStatus: item.cost?.status ?? "unvalued"
+  };
+}
+function aiAccountingBucketStart(at, bucket) {
+  assertDate(at, "accounting bucket timestamp");
+  assertAiAccountingBucket(bucket);
+  const start = new Date(at);
+  start.setUTCMinutes(0, 0, 0);
+  if (bucket === "hour")
+    return start;
+  start.setUTCHours(0);
+  if (bucket === "day")
+    return start;
+  const mondayOffset = (start.getUTCDay() + 6) % 7;
+  start.setUTCDate(start.getUTCDate() - mondayOffset);
+  return start;
+}
+function aggregateAccountingItems(items) {
+  return {
+    modelCallCount: items.length,
+    usage: aggregateAiModelCallUsage(items.map((item) => item.usage.usage)),
+    costs: aggregateCosts(items)
+  };
+}
+function aggregateCosts(items) {
+  const amounts = new Map;
+  let ratedCallCount = 0;
+  let unpriceableCallCount = 0;
+  let unvaluedCallCount = 0;
+  for (const item of items) {
+    if (item.cost?.status === "rated") {
+      ratedCallCount += 1;
+      addAmount(amounts, item.cost.money.currency, item.cost.money.amountNanos);
+    } else if (item.cost?.status === "unpriceable") {
+      unpriceableCallCount += 1;
+    } else {
+      unvaluedCallCount += 1;
+    }
+  }
+  return {
+    amounts: [...amounts].sort(([left], [right]) => left.localeCompare(right)).map(([currency, amountNanos]) => ({ currency, amountNanos: amountNanos.toString() })),
+    ratedCallCount,
+    unpriceableCallCount,
+    unvaluedCallCount
+  };
+}
+var AGGREGATE_USAGE_FIELDS = [
+  "inputTokens",
+  "outputTokens",
+  "uncachedInputTokens",
+  "cacheReadInputTokens",
+  "cacheWriteInputTokens",
+  "textOutputTokens",
+  "reasoningOutputTokens"
+];
+function aggregateFragmentAccumulator() {
+  return {
+    modelCallCount: 0n,
+    reportedUsageCallCount: 0n,
+    usage: Object.fromEntries(AGGREGATE_USAGE_FIELDS.map((field) => [field, { presentCallCount: 0n, total: 0n }])),
+    amounts: new Map,
+    ratedCallCount: 0n,
+    unpriceableCallCount: 0n,
+    unvaluedCallCount: 0n
+  };
+}
+function getFragmentAccumulator(values, key) {
+  const existing = values.get(key);
+  if (existing)
+    return existing;
+  const created = aggregateFragmentAccumulator();
+  values.set(key, created);
+  return created;
+}
+function appendAggregateFragment(target, fragment) {
+  target.modelCallCount += naturalBigInt(fragment.modelCallCount, "modelCallCount");
+  target.reportedUsageCallCount += naturalBigInt(fragment.usage.reportedCallCount, "reported usage call count");
+  for (const field of AGGREGATE_USAGE_FIELDS) {
+    const source = fragment.usage[field];
+    const presentCallCount = naturalBigInt(source.presentCallCount, `${field} call count`);
+    target.usage[field].presentCallCount += presentCallCount;
+    if (source.total !== null) {
+      target.usage[field].total += naturalBigInt(source.total, `${field} total`);
+    } else if (presentCallCount !== 0n) {
+      throw new TypeError(`[Sixb] AI accounting SQL ${field} total is missing.`);
+    }
+  }
+  target.ratedCallCount += naturalBigInt(fragment.costs.ratedCallCount, "rated call count");
+  target.unpriceableCallCount += naturalBigInt(fragment.costs.unpriceableCallCount, "unpriceable call count");
+  target.unvaluedCallCount += naturalBigInt(fragment.costs.unvaluedCallCount, "unvalued call count");
+  if (fragment.costs.amount) {
+    addAmount(target.amounts, fragment.costs.amount.currency, fragment.costs.amount.amountNanos);
+  }
+}
+function finishAggregateFragment(value) {
+  const classifiedCallCount = value.ratedCallCount + value.unpriceableCallCount + value.unvaluedCallCount;
+  if (classifiedCallCount !== value.modelCallCount || value.reportedUsageCallCount > value.modelCallCount || AGGREGATE_USAGE_FIELDS.some((field) => value.usage[field].presentCallCount > value.modelCallCount)) {
+    throw new TypeError("[Sixb] AI accounting SQL aggregate counts are inconsistent.");
+  }
+  const modelCallCount = safeAggregateNumber(value.modelCallCount, "model-call count");
+  const usageInput = {};
+  if (value.modelCallCount > 0n) {
+    for (const field of AGGREGATE_USAGE_FIELDS) {
+      const aggregate = value.usage[field];
+      if (aggregate.presentCallCount === value.modelCallCount) {
+        usageInput[field] = safeAggregateNumber(aggregate.total, field);
+      }
+    }
+  }
+  let usage = normalizeAiModelCallUsage(usageInput);
+  if (usage.reportingStatus === "unavailable" && value.reportedUsageCallCount > 0n) {
+    usage = { ...usage, reportingStatus: "partial" };
+  }
+  return {
+    modelCallCount,
+    usage,
+    costs: {
+      amounts: [...value.amounts].sort(([left], [right]) => left.localeCompare(right)).map(([currency, amountNanos]) => ({ currency, amountNanos: amountNanos.toString() })),
+      ratedCallCount: safeAggregateNumber(value.ratedCallCount, "rated call count"),
+      unpriceableCallCount: safeAggregateNumber(value.unpriceableCallCount, "unpriceable call count"),
+      unvaluedCallCount: safeAggregateNumber(value.unvaluedCallCount, "unvalued call count")
+    }
+  };
+}
+function naturalBigInt(value, field) {
+  if (!/^(0|[1-9]\d*)$/.test(value)) {
+    throw new TypeError(`[Sixb] AI accounting SQL ${field} must be a natural integer.`);
+  }
+  return BigInt(value);
+}
+function safeAggregateNumber(value, field) {
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new TypeError(`[Sixb] AI accounting ${field} exceeds the safe integer range.`);
+  }
+  return Number(value);
+}
+function requiredFragmentString(value, field) {
+  if (value === undefined || value.length === 0) {
+    throw new TypeError(`[Sixb] AI accounting SQL ${field} is missing.`);
+  }
+  return value;
+}
+function requiredFragmentDate(value, field) {
+  if (value === undefined)
+    throw new TypeError(`[Sixb] AI accounting SQL ${field} is missing.`);
+  assertDate(value, field);
+  return value;
+}
+function accountingPeriods(from, to, bucket) {
+  const result = [];
+  let cursor = aiAccountingBucketStart(from, bucket);
+  while (cursor.getTime() < to.getTime()) {
+    if (result.length >= MAX_CHART_BUCKETS) {
+      throw new RangeError(`[Sixb] AI accounting query exceeds ${MAX_CHART_BUCKETS} chart buckets.`);
+    }
+    const next = nextBucket(cursor, bucket);
+    result.push({ start: new Date(cursor), end: next });
+    cursor = next;
+  }
+  return result;
+}
+function nextBucket(start, bucket) {
+  const next = new Date(start);
+  if (bucket === "hour")
+    next.setUTCHours(next.getUTCHours() + 1);
+  else if (bucket === "day")
+    next.setUTCDate(next.getUTCDate() + 1);
+  else
+    next.setUTCDate(next.getUTCDate() + 7);
+  return next;
+}
+function appendGrouped(groups, key, item) {
+  const existing = groups.get(key);
+  if (existing)
+    existing.push(item);
+  else
+    groups.set(key, [item]);
+}
+function addAmount(amounts, currency, amountNanos) {
+  amounts.set(currency, (amounts.get(currency) ?? 0n) + BigInt(amountNanos));
+}
+function normalizePage(requestedLimit, requestedOffset) {
+  const limit = requestedLimit ?? DEFAULT_MODEL_CALL_PAGE_SIZE;
+  const offset = requestedOffset ?? 0;
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_MODEL_CALL_PAGE_SIZE) {
+    throw new TypeError(`[Sixb] AI accounting list limit must be an integer between 1 and ${MAX_MODEL_CALL_PAGE_SIZE}.`);
+  }
+  if (!Number.isSafeInteger(offset) || offset < 0) {
+    throw new TypeError("[Sixb] AI accounting list offset must be a non-negative integer.");
+  }
+  return { limit, offset };
+}
+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);
+}
+function compareWorkflowBreakdowns(left, right) {
+  return right.modelCallCount - left.modelCallCount || left.workflowId.localeCompare(right.workflowId);
+}
+function compareModelBreakdowns(left, right) {
+  return right.modelCallCount - left.modelCallCount || left.providerId.localeCompare(right.providerId) || left.modelId.localeCompare(right.modelId);
+}
+function assertAiAccountingBucket(bucket) {
+  if (bucket !== "hour" && bucket !== "day" && bucket !== "week") {
+    throw new TypeError("[Sixb] AI accounting bucket must be hour, day, or week.");
+  }
+}
+function assertDate(value, label) {
+  if (!(value instanceof Date) || !Number.isFinite(value.getTime())) {
+    throw new TypeError(`[Sixb] AI ${label} must be a valid Date.`);
+  }
+}
+function assertNonBlank2(value, label) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new TypeError(`[Sixb] AI ${label} must be nonblank.`);
+  }
+}
+
+// src/storage/ai-cost/validation.ts
+var SIGNED_INT64_MAX = 9223372036854775807n;
+var TOKENS_PER_MILLION = 1000000n;
+var HALF_MILLION = TOKENS_PER_MILLION / 2n;
+var MAX_NUMERIC_TEXT_LENGTH = 128;
+var METER_ORDER = {
+  "tokens.input.total": 0,
+  "tokens.input.uncached": 1,
+  "tokens.input.cacheRead": 2,
+  "tokens.input.cacheWrite": 3,
+  "tokens.output.total": 4,
+  "tokens.output.text": 5,
+  "tokens.output.reasoning": 6
+};
+var METERS = new Set(Object.keys(METER_ORDER));
+var UNPRICEABLE_REASONS = new Set([
+  "missingBillingIdentity",
+  "missingCatalogEntry",
+  "missingUsageMeter",
+  "unsupportedPricingDimension",
+  "invalidUsageForFormula"
+]);
+var CONTEXT_STRING_FIELDS = [
+  "serviceTier",
+  "region",
+  "inferenceGeo",
+  "routedProviderId",
+  "deploymentId",
+  "inferenceProfileId",
+  "mode"
+];
+function normalizeAiPricingContext(input) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    throw new TypeError("[Sixb] AI pricing context must be an object.");
+  }
+  const result = {};
+  for (const field of CONTEXT_STRING_FIELDS) {
+    const value = input[field];
+    if (value !== undefined) {
+      assertNonBlank3(value, `pricingContext.${field}`);
+      result[field] = value;
+    }
+  }
+  if (input.batch !== undefined) {
+    if (typeof input.batch !== "boolean") {
+      throw new TypeError("[Sixb] AI pricingContext.batch must be boolean.");
+    }
+    result.batch = input.batch;
+  }
+  if (input.cacheWriteTtlSeconds !== undefined) {
+    if (!Number.isSafeInteger(input.cacheWriteTtlSeconds) || input.cacheWriteTtlSeconds <= 0) {
+      throw new TypeError("[Sixb] AI pricingContext.cacheWriteTtlSeconds must be a positive safe integer.");
+    }
+    result.cacheWriteTtlSeconds = input.cacheWriteTtlSeconds;
+  }
+  return result;
+}
+function normalizeAiModelCallCostRecord(input) {
+  assertNonBlank3(input.projectId, "cost record projectId");
+  assertNonBlank3(input.usageRecordId, "cost record usageRecordId");
+  const base = {
+    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);
+  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.status === "unpriceable")
+    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);
+}
+function inputComponentsMatchUsage(components, usage) {
+  if (usage.inputTokens === undefined)
+    return false;
+  const total = components.get("tokens.input.total");
+  const partitions = [
+    ["tokens.input.uncached", usage.uncachedInputTokens],
+    ["tokens.input.cacheRead", usage.cacheReadInputTokens],
+    ["tokens.input.cacheWrite", usage.cacheWriteInputTokens]
+  ];
+  const presentPartitions = partitions.filter(([meter]) => components.has(meter));
+  if (total) {
+    return presentPartitions.length === 0 && BigInt(total.quantity) === BigInt(usage.inputTokens);
+  }
+  if (presentPartitions.length === 0)
+    return false;
+  let quantity = 0n;
+  for (const [meter, expected] of presentPartitions) {
+    if (expected === undefined)
+      return false;
+    const component = components.get(meter);
+    if (BigInt(component.quantity) !== BigInt(expected))
+      return false;
+    quantity += BigInt(component.quantity);
+  }
+  return quantity === BigInt(usage.inputTokens);
+}
+function outputComponentsMatchUsage(components, usage) {
+  if (usage.outputTokens === undefined)
+    return false;
+  const total = components.get("tokens.output.total");
+  const partitions = [
+    ["tokens.output.text", usage.textOutputTokens],
+    ["tokens.output.reasoning", usage.reasoningOutputTokens]
+  ];
+  const presentPartitions = partitions.filter(([meter]) => components.has(meter));
+  if (total) {
+    return presentPartitions.length === 0 && BigInt(total.quantity) === BigInt(usage.outputTokens);
+  }
+  if (presentPartitions.length === 0)
+    return false;
+  let quantity = 0n;
+  for (const [meter, expected] of presentPartitions) {
+    if (expected === undefined)
+      return false;
+    const component = components.get(meter);
+    if (BigInt(component.quantity) !== BigInt(expected))
+      return false;
+    quantity += BigInt(component.quantity);
+  }
+  return quantity === BigInt(usage.outputTokens);
+}
+function normalizeRatedCost(input, base) {
+  const billingIdentity = normalizeBillingIdentity(input.billingIdentity);
+  const components = input.components.map(normalizeCostComponent).sort(compareComponents);
+  if (components.length === 0)
+    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)) {
+    throw new TypeError("[Sixb] AI cost total does not equal its component charges.");
+  }
+  return {
+    ...base,
+    status: "rated",
+    billingIdentity,
+    money: { currency: normalizeCurrency(input.money.currency), amountNanos },
+    components
+  };
+}
+function normalizeUnpriceableCost(input, base) {
+  if (!UNPRICEABLE_REASONS.has(input.reason)) {
+    throw new TypeError(`[Sixb] AI unpriceable reason '${String(input.reason)}' is invalid.`);
+  }
+  const billingIdentity = input.billingIdentity ? normalizeBillingIdentity(input.billingIdentity) : undefined;
+  if (input.reason === "missingBillingIdentity" && billingIdentity !== undefined) {
+    throw new TypeError("[Sixb] AI missingBillingIdentity cannot contain a billing identity.");
+  }
+  if (input.reason !== "missingBillingIdentity" && billingIdentity === undefined) {
+    throw new TypeError(`[Sixb] AI ${input.reason} requires a billing identity.`);
+  }
+  const missingMeters = normalizeMissingMeters(input.missingMeters);
+  if (input.reason === "missingUsageMeter" && !missingMeters) {
+    throw new TypeError("[Sixb] AI missingUsageMeter requires missingMeters.");
+  }
+  return {
+    ...base,
+    status: "unpriceable",
+    ...billingIdentity ? { billingIdentity } : {},
+    reason: input.reason,
+    ...missingMeters ? { missingMeters } : {}
+  };
+}
+function normalizeCostComponent(input) {
+  if (!METERS.has(input.meter)) {
+    throw new TypeError(`[Sixb] AI cost meter '${String(input.meter)}' is invalid.`);
+  }
+  const expected = calculateComponent(input.meter, input.quantity, input.rateAmountNanosPerMillion);
+  if (expected.chargeAmountNanos !== input.chargeAmountNanos) {
+    throw new TypeError(`[Sixb] AI cost component '${input.meter}' charge is invalid.`);
+  }
+  return expected;
+}
+function calculateComponent(meter, quantity, rateAmountNanosPerMillion) {
+  const normalizedQuantity = parseQuantity(quantity, `${meter} quantity`);
+  const rate = parseNonnegativeInt64(rateAmountNanosPerMillion, `${meter} rate`);
+  const charge = (normalizedQuantity * rate + HALF_MILLION) / TOKENS_PER_MILLION;
+  assertSignedInt64(charge, `${meter} charge`);
+  return {
+    meter,
+    quantity: normalizedQuantity.toString(),
+    rateAmountNanosPerMillion: rate.toString(),
+    chargeAmountNanos: charge.toString()
+  };
+}
+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") };
+}
+function normalizeBillingIdentity(input) {
+  assertNonBlank3(input.providerId, "billingIdentity.providerId");
+  assertNonBlank3(input.modelId, "billingIdentity.modelId");
+  return { providerId: input.providerId, modelId: input.modelId };
+}
+function normalizeMissingMeters(input) {
+  if (!input?.length)
+    return;
+  const result = [...new Set(input)];
+  for (const meter of result) {
+    if (!METERS.has(meter))
+      throw new TypeError(`[Sixb] AI missing meter '${meter}' is invalid.`);
+  }
+  return result.sort((left, right) => METER_ORDER[left] - METER_ORDER[right]);
+}
+function sumComponents(components) {
+  let total = 0n;
+  for (const component of components) {
+    total += parseNonnegativeInt64(component.chargeAmountNanos, "component charge");
+    assertSignedInt64(total, "cost total");
+  }
+  return total.toString();
+}
+function parseQuantity(value, field) {
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value) || value < 0) {
+      throw new TypeError(`[Sixb] AI ${field} must be a non-negative safe integer.`);
+    }
+    return BigInt(value);
+  }
+  return parseNonnegativeInt64(value, field);
+}
+function parseNonnegativeInt64(value, field) {
+  if (typeof value !== "string" || value.length === 0 || value.length > MAX_NUMERIC_TEXT_LENGTH || !/^\d+$/.test(value)) {
+    throw new TypeError(`[Sixb] AI ${field} must be a non-negative integer string.`);
+  }
+  const parsed = BigInt(value);
+  assertSignedInt64(parsed, field);
+  return parsed;
+}
+function compareComponents(left, right) {
+  return METER_ORDER[left.meter] - METER_ORDER[right.meter];
+}
+function normalizeCurrency(value) {
+  if (!/^[A-Z]{3}$/.test(value)) {
+    throw new TypeError("[Sixb] AI currency must be a three-letter uppercase code.");
+  }
+  return value;
+}
+function assertSignedInt64(value, field) {
+  if (value < 0n || value > SIGNED_INT64_MAX) {
+    throw new TypeError(`[Sixb] AI ${field} exceeds the signed 64-bit range.`);
+  }
+}
+function assertNonBlank3(value, field) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new TypeError(`[Sixb] AI ${field} must be nonblank.`);
+  }
+}
+function cloneDate(value, field) {
+  if (!(value instanceof Date) || !Number.isFinite(value.getTime())) {
+    throw new TypeError(`[Sixb] AI ${field} must be a valid Date.`);
+  }
+  return new Date(value);
+}
+
+export { AiUsageStorageError, normalizeAiModelCallUsage, aggregateAiModelCallUsage, normalizeAiModelCallRecord, assertAiUsageExecutionId, InMemoryAiUsageStorage, normalizeAiAccountingQuery, normalizeAiModelCallAccountingQuery, buildAiAccountingOverview, buildAiAccountingOverviewFromFragments, buildAiModelCallAccountingList, toAccountingItem, normalizeAiPricingContext, normalizeAiModelCallCostRecord, aiModelCallCostMatchesUsage };
+
+//# debugId=084861E374895B3F64756E2164756E21