nolo-cli 0.1.30 → 0.1.31

package/ai/token/providerBillingAnomalyDrilldown.ts

@@ -0,0 +1,308 @@
+import { createHash } from "node:crypto";
+
+import {
+  buildBillingAnomalyKey,
+  type BillingAnomaly,
+  type BillingAnomalyKind,
+} from "./billingAnomaly";
+import type { BillingAdminAuditEvent } from "./billingAdminAuditEvent";
+import {
+  buildProviderBillingDrilldown,
+  type ProviderBillingDrilldown,
+  type ProviderBillingDrilldownStore,
+} from "./providerBillingDrilldown";
+
+export type BillingAnomalyRepairDryRunAction =
+  | "none"
+  | "wait_provider_delay"
+  | "repair_evidence"
+  | "provider_call_debit_dry_run"
+  | "manual_reconciliation_review"
+  | "platform_absorb_review";
+
+export type BillingAnomalyRepairDryRun = {
+  mode: "dry-run";
+  executable: false;
+  recommendedAction: BillingAnomalyRepairDryRunAction;
+  affectedUserCount: number;
+  providerCallCount: number;
+  estimatedPlatformCredits: number;
+  maxSingleUserImpact: number;
+  wouldIncreaseNegativeBalance: boolean;
+  inputSetHash: string;
+  notes: string[];
+  actionPlan: BillingAnomalyRepairActionPlan;
+};
+
+export type BillingAnomalyRepairActionPlan = {
+  planId: string;
+  inputSetHash: string;
+  executionSupported: false;
+  proposedLifecycleStatus: "acknowledged";
+  options: Array<{
+    kind: BillingAnomalyRepairDryRunAction;
+    label: string;
+    estimatedPlatformCredits: number;
+  }>;
+  affectedUsers: Array<{
+    userId: string;
+    estimatedImpactCredits: number;
+  }>;
+  affectedProviderCallIds: string[];
+  proposedLedgerEntries: [];
+};
+
+export type ProviderBillingAnomalyDrilldown = {
+  anomaly: BillingAnomaly;
+  evidenceChain: {
+    bucketId?: string;
+    providerCallIds: string[];
+    billableEventIds: string[];
+    ratingResultIds: string[];
+    tokenRecordKeys: string[];
+    ledgerTransactionKeys: string[];
+    bucketDrilldown?: ProviderBillingDrilldown;
+  };
+  repairDryRun: BillingAnomalyRepairDryRun;
+  adminAuditTrail: BillingAdminAuditEvent[];
+};
+
+export type ProviderBillingAnomalyDrilldownStore =
+  ProviderBillingDrilldownStore;
+
+const isObject = (value: unknown): value is Record<string, unknown> =>
+  Boolean(value && typeof value === "object" && !Array.isArray(value));
+
+const isBillingAnomaly = (value: unknown): value is BillingAnomaly =>
+  isObject(value) &&
+  typeof value.id === "string" &&
+  typeof value.kind === "string" &&
+  typeof value.status === "string" &&
+  typeof value.createdAt === "string";
+
+const numberOrZero = (value: unknown) =>
+  typeof value === "number" && Number.isFinite(value) ? value : 0;
+
+const stringFromEvidence = (
+  evidence: Record<string, unknown>,
+  key: string
+) => {
+  const value = evidence[key];
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+};
+
+const uniqueStrings = (values: Array<string | undefined>) => [
+  ...new Set(values.filter((value): value is string => Boolean(value))),
+];
+
+const actionForKind = (
+  kind: BillingAnomalyKind
+): BillingAnomalyRepairDryRunAction => {
+  if (kind === "ledger_failed") return "provider_call_debit_dry_run";
+  if (
+    kind === "billable_event_write_failed" ||
+    kind === "rating_failed" ||
+    kind === "pricing_missing" ||
+    kind === "usage_missing" ||
+    kind === "aggregate_usage_unallocated"
+  ) {
+    return "repair_evidence";
+  }
+  if (
+    kind === "provider_call_pending_timeout" ||
+    kind === "provider_call_sent_unknown"
+  ) {
+    return "wait_provider_delay";
+  }
+  if (kind === "provider_reconciliation_diff") {
+    return "manual_reconciliation_review";
+  }
+  if (
+    kind === "provider_credential_revoked_blocked" ||
+    kind === "provider_credential_revoked_used"
+  ) {
+    return "platform_absorb_review";
+  }
+  return "none";
+};
+
+const labelForAction = (action: BillingAnomalyRepairDryRunAction) => {
+  if (action === "provider_call_debit_dry_run") return "Provider call debit dry-run";
+  if (action === "manual_reconciliation_review") return "Manual reconciliation review";
+  if (action === "repair_evidence") return "Repair local billing evidence";
+  if (action === "wait_provider_delay") return "Wait for provider billing delay";
+  if (action === "platform_absorb_review") return "Platform absorb review";
+  return "No repair action";
+};
+
+const inputHash = (value: unknown) =>
+  `sha256:${createHash("sha256")
+    .update(JSON.stringify(value))
+    .digest("hex")}`;
+
+const ADMIN_AUDIT_PREFIX = "billing-admin-audit-event-";
+const ADMIN_AUDIT_RANGE_END = `${ADMIN_AUDIT_PREFIX}\uffff`;
+
+const isBillingAdminAuditEvent = (
+  value: unknown
+): value is BillingAdminAuditEvent =>
+  isObject(value) &&
+  value.recordType === "billing_admin_audit_event" &&
+  typeof value.eventId === "string" &&
+  typeof value.actorId === "string" &&
+  typeof value.action === "string" &&
+  typeof value.anomalyId === "string" &&
+  typeof value.planId === "string" &&
+  typeof value.inputSetHash === "string" &&
+  typeof value.createdAt === "string";
+
+async function listAdminAuditTrail({
+  store,
+  anomalyId,
+  limit,
+}: {
+  store: ProviderBillingAnomalyDrilldownStore;
+  anomalyId: string;
+  limit: number;
+}) {
+  const events: BillingAdminAuditEvent[] = [];
+  for await (const [, value] of store.iterator({
+    gte: ADMIN_AUDIT_PREFIX,
+    lte: ADMIN_AUDIT_RANGE_END,
+  })) {
+    if (!isBillingAdminAuditEvent(value)) continue;
+    if (value.anomalyId !== anomalyId) continue;
+    events.push(value);
+  }
+  return events
+    .sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt))
+    .slice(0, limit);
+}
+
+export async function buildProviderBillingAnomalyDrilldown({
+  store,
+  anomalyId,
+  limit = 50,
+}: {
+  store: ProviderBillingAnomalyDrilldownStore;
+  anomalyId: string;
+  limit?: number;
+}): Promise<ProviderBillingAnomalyDrilldown> {
+  const anomalyValue = await store.get(buildBillingAnomalyKey(anomalyId));
+  if (!isBillingAnomaly(anomalyValue)) {
+    throw new Error(`billing anomaly not found: ${anomalyId}`);
+  }
+  const anomaly = anomalyValue;
+  const adminAuditTrail = await listAdminAuditTrail({
+    store,
+    anomalyId: anomaly.id,
+    limit,
+  });
+  const bucketId = stringFromEvidence(anomaly.evidence, "bucketId");
+  const bucketDrilldown = bucketId
+    ? await buildProviderBillingDrilldown({ store, bucketId, limit })
+    : undefined;
+
+  const providerCallIds = uniqueStrings([
+    anomaly.providerCallId,
+    stringFromEvidence(anomaly.evidence, "providerCallId"),
+    ...(bucketDrilldown?.providerCalls.map((call) => call.providerCallId) ?? []),
+  ]);
+  const billableEventIds = uniqueStrings([
+    anomaly.billableEventId,
+    stringFromEvidence(anomaly.evidence, "billableEventId"),
+    ...(bucketDrilldown?.billableEvents.map((event) => event.id) ?? []),
+  ]);
+  const ratingResultIds = uniqueStrings([
+    anomaly.ratingResultId,
+    stringFromEvidence(anomaly.evidence, "ratingResultId"),
+    ...(bucketDrilldown?.ratingResults.map((rating) => rating.id) ?? []),
+  ]);
+  const tokenRecordKeys = uniqueStrings(
+    bucketDrilldown?.tokenRecords.map((record) => record.key) ?? []
+  );
+  const ledgerTransactionKeys = uniqueStrings(
+    bucketDrilldown?.ledgerTransactions.map((tx) => tx.key) ?? []
+  );
+  const affectedUsers = new Set<string>();
+  if (anomaly.userId && anomaly.userId !== "provider-reconciliation") {
+    affectedUsers.add(anomaly.userId);
+  }
+  for (const call of bucketDrilldown?.providerCalls ?? []) {
+    if (call.userId) affectedUsers.add(call.userId);
+  }
+  for (const record of bucketDrilldown?.tokenRecords ?? []) {
+    if (record.userId) affectedUsers.add(record.userId);
+  }
+
+  const estimatedPlatformCredits = numberOrZero(anomaly.riskPlatformCredits);
+  const maxSingleUserImpact =
+    affectedUsers.size <= 1 ? estimatedPlatformCredits : estimatedPlatformCredits;
+  const recommendedAction = actionForKind(anomaly.kind);
+  const notes = [
+    "dry-run only; no ledger, balance, recharge, or anomaly lifecycle record is written",
+    bucketId
+      ? "linked through provider reconciliation bucket evidence"
+    : "linked through anomaly direct evidence only",
+  ];
+  const inputSetHash = inputHash({
+    anomalyId: anomaly.id,
+    kind: anomaly.kind,
+    bucketId,
+    providerCallIds,
+    billableEventIds,
+    ratingResultIds,
+    tokenRecordKeys,
+    ledgerTransactionKeys,
+    estimatedPlatformCredits,
+  });
+  const affectedUserList = [...affectedUsers].sort().map((userId) => ({
+    userId,
+    estimatedImpactCredits:
+      affectedUsers.size <= 1
+        ? estimatedPlatformCredits
+        : estimatedPlatformCredits / affectedUsers.size,
+  }));
+
+  return {
+    anomaly,
+    evidenceChain: {
+      bucketId,
+      providerCallIds,
+      billableEventIds,
+      ratingResultIds,
+      tokenRecordKeys,
+      ledgerTransactionKeys,
+      bucketDrilldown,
+    },
+    repairDryRun: {
+      mode: "dry-run",
+      executable: false,
+      recommendedAction,
+      affectedUserCount: affectedUsers.size,
+      providerCallCount: providerCallIds.length,
+      estimatedPlatformCredits,
+      maxSingleUserImpact,
+      wouldIncreaseNegativeBalance: false,
+      inputSetHash,
+      notes,
+      actionPlan: {
+        planId: `billing-repair-plan:${inputSetHash}`,
+        inputSetHash,
+        executionSupported: false,
+        proposedLifecycleStatus: "acknowledged",
+        options: [
+          {
+            kind: recommendedAction,
+            label: labelForAction(recommendedAction),
+            estimatedPlatformCredits,
+          },
+        ],
+        affectedUsers: affectedUserList,
+        affectedProviderCallIds: providerCallIds,
+        proposedLedgerEntries: [],
+      },
+    },
+    adminAuditTrail,
+  };
+}

package/ai/token/providerBillingDrilldown.ts

@@ -0,0 +1,361 @@
+import type { ProviderBillableEvent } from "./providerBillableEvent";
+import type {
+  ProviderCallCompletedEvent,
+  ProviderCallEvent,
+} from "./providerCall";
+import {
+  buildProviderReconciliationBucketKey,
+  type ProviderReconciliationBucket,
+} from "./providerReconciliation";
+import type { RatingResult } from "./ratingResult";
+
+export type ProviderBillingDrilldownStore = {
+  get(key: string): Promise<unknown>;
+  iterator(options: { gte?: string; lte?: string }): AsyncIterable<[string, unknown]>;
+};
+
+export type ProviderBillingDrilldownTokenRecord = {
+  key: string;
+  userId?: string;
+  dialogId?: string;
+  agentId?: string;
+  provider?: string;
+  model?: string;
+  inputTokens: number;
+  outputTokens: number;
+  cost: number;
+  timestamp: number;
+  providerRequestIds: string[];
+  providerResponseIds: string[];
+};
+
+export type ProviderBillingDrilldownLedgerTransaction = {
+  key: string;
+  txId?: string;
+  idempotencyKey?: string;
+  type?: string;
+  createdAt?: number;
+  metadata?: Record<string, unknown>;
+};
+
+export type ProviderBillingDrilldown = {
+  bucket: ProviderReconciliationBucket;
+  matchMode: "bucket_window" | "official_request_id";
+  officialEvidence?: Record<string, unknown>;
+  officialRequestIds: string[];
+  officialResponseIds: string[];
+  unmatchedOfficialRequestIds: string[];
+  summary: {
+    providerCallCount: number;
+    billableEventCount: number;
+    ratingResultCount: number;
+    tokenRecordCount: number;
+    ledgerTransactionCount: number;
+  };
+  providerCalls: ProviderCallCompletedEvent[];
+  billableEvents: ProviderBillableEvent[];
+  ratingResults: RatingResult[];
+  tokenRecords: ProviderBillingDrilldownTokenRecord[];
+  ledgerTransactions: ProviderBillingDrilldownLedgerTransaction[];
+};
+
+const PROVIDER_CALL_PREFIX = "provider-call-";
+const PROVIDER_CALL_RANGE_END = `${PROVIDER_CALL_PREFIX}\uffff`;
+const BILLABLE_EVENT_PREFIX = "provider-billable-event-";
+const BILLABLE_EVENT_RANGE_END = `${BILLABLE_EVENT_PREFIX}\uffff`;
+const RATING_RESULT_PREFIX = "rating-result-";
+const RATING_RESULT_RANGE_END = `${RATING_RESULT_PREFIX}\uffff`;
+const TOKEN_PREFIX = "token-";
+const TOKEN_RANGE_END = `${TOKEN_PREFIX}\uffff`;
+const TOKEN_STATS_PREFIX = "token-stats-";
+const LEDGER_TX_PREFIX = "ledger-tx-";
+const LEDGER_TX_RANGE_END = `${LEDGER_TX_PREFIX}\uffff`;
+
+const isObject = (value: unknown): value is Record<string, unknown> =>
+  Boolean(value && typeof value === "object" && !Array.isArray(value));
+
+const isCompletedProviderCall = (
+  value: unknown
+): value is ProviderCallCompletedEvent =>
+  isObject(value) &&
+  (value as ProviderCallEvent).status === "completed" &&
+  typeof value.providerCallId === "string" &&
+  typeof value.provider === "string" &&
+  typeof value.model === "string" &&
+  typeof value.completedAt === "string" &&
+  isObject(value.usage);
+
+const isProviderBillableEvent = (
+  value: unknown
+): value is ProviderBillableEvent =>
+  isObject(value) &&
+  typeof value.id === "string" &&
+  Array.isArray(value.sourceProviderCallIds) &&
+  typeof value.provider === "string" &&
+  typeof value.model === "string";
+
+const isRatingResult = (value: unknown): value is RatingResult =>
+  isObject(value) &&
+  typeof value.id === "string" &&
+  typeof value.billableEventId === "string" &&
+  typeof value.provider === "string" &&
+  typeof value.model === "string";
+
+const isWithinWindow = (iso: string, startMs: number, endMs: number) => {
+  const time = Date.parse(iso);
+  return Number.isFinite(time) && time >= startMs && time < endMs;
+};
+
+const numberOrZero = (value: unknown) =>
+  typeof value === "number" && Number.isFinite(value) ? value : 0;
+
+const stringArray = (value: unknown) =>
+  Array.isArray(value)
+    ? value.filter((item): item is string => typeof item === "string" && item.length > 0)
+    : [];
+
+const extractEvidenceIds = (
+  evidence: Record<string, unknown> | undefined,
+  keys: string[]
+) => {
+  const values: string[] = [];
+  for (const key of keys) {
+    values.push(...stringArray(evidence?.[key]));
+  }
+  return [...new Set(values)];
+};
+
+const tokenTimestamp = (value: Record<string, unknown>) => {
+  if (typeof value.timestamp === "number" && Number.isFinite(value.timestamp)) {
+    return value.timestamp;
+  }
+  if (typeof value.createdAt === "string") {
+    const parsed = Date.parse(value.createdAt);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return undefined;
+};
+
+const matchesBucket = (
+  bucket: ProviderReconciliationBucket,
+  value: { provider?: string; model?: string }
+) => {
+  if (value.provider !== bucket.provider) return false;
+  if (bucket.model && value.model !== bucket.model) return false;
+  return true;
+};
+
+const normalizeTokenRecord = (
+  key: string,
+  value: Record<string, unknown>
+): ProviderBillingDrilldownTokenRecord | undefined => {
+  const timestamp = tokenTimestamp(value);
+  if (typeof timestamp !== "number") return undefined;
+  return {
+    key,
+    userId: typeof value.userId === "string" ? value.userId : undefined,
+    dialogId: typeof value.dialogId === "string" ? value.dialogId : undefined,
+    agentId:
+      typeof value.cybotId === "string"
+        ? value.cybotId
+        : typeof value.agentId === "string"
+          ? value.agentId
+          : undefined,
+    provider: typeof value.provider === "string" ? value.provider : undefined,
+    model: typeof value.model === "string" ? value.model : undefined,
+    inputTokens: numberOrZero(value.input_tokens),
+    outputTokens: numberOrZero(value.output_tokens),
+    cost: numberOrZero(value.cost),
+    timestamp,
+    providerRequestIds: stringArray(value.provider_request_ids),
+    providerResponseIds: stringArray(value.provider_response_ids),
+  };
+};
+
+const normalizeLedgerTransaction = (
+  key: string,
+  value: Record<string, unknown>
+): ProviderBillingDrilldownLedgerTransaction => ({
+  key,
+  txId: typeof value.txId === "string" ? value.txId : undefined,
+  idempotencyKey:
+    typeof value.idempotencyKey === "string" ? value.idempotencyKey : undefined,
+  type: typeof value.type === "string" ? value.type : undefined,
+  createdAt: typeof value.createdAt === "number" ? value.createdAt : undefined,
+  metadata: isObject(value.metadata) ? value.metadata : undefined,
+});
+
+const providerCallIdFromIdempotencyKey = (value: string | undefined) => {
+  const match = value?.match(/^provider-call:(.+):charge:v1$/);
+  return match?.[1];
+};
+
+const intersects = (left: string[], right: Set<string>) =>
+  left.some((item) => right.has(item));
+
+export async function buildProviderBillingDrilldown({
+  store,
+  bucketId,
+  limit = 50,
+}: {
+  store: ProviderBillingDrilldownStore;
+  bucketId: string;
+  limit?: number;
+}): Promise<ProviderBillingDrilldown> {
+  const bucketValue = await store.get(buildProviderReconciliationBucketKey(bucketId));
+  if (!isObject(bucketValue) || typeof bucketValue.id !== "string") {
+    throw new Error(`provider reconciliation bucket not found: ${bucketId}`);
+  }
+  const bucket = bucketValue as ProviderReconciliationBucket;
+  const startMs = Date.parse(bucket.bucketStart);
+  const endMs = Date.parse(bucket.bucketEnd);
+  if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || endMs <= startMs) {
+    throw new Error(`provider reconciliation bucket has invalid window: ${bucketId}`);
+  }
+
+  const maxRows = Math.min(Math.max(Math.floor(limit), 1), 200);
+  const officialEvidence = bucket.officialEvidence;
+  const officialRequestIds = extractEvidenceIds(officialEvidence, [
+    "requestIds",
+    "providerRequestIds",
+  ]);
+  const officialResponseIds = extractEvidenceIds(officialEvidence, [
+    "responseIds",
+    "providerResponseIds",
+  ]);
+  const officialRequestIdSet = new Set(officialRequestIds);
+  const officialResponseIdSet = new Set(officialResponseIds);
+  const hasOfficialRequestEvidence =
+    officialRequestIdSet.size > 0 || officialResponseIdSet.size > 0;
+
+  const tokenRecords: ProviderBillingDrilldownTokenRecord[] = [];
+  const tokenKeys = new Set<string>();
+  const matchedOfficialRequestIds = new Set<string>();
+  for await (const [key, value] of store.iterator({
+    gte: TOKEN_PREFIX,
+    lte: TOKEN_RANGE_END,
+  })) {
+    if (key.startsWith(TOKEN_STATS_PREFIX) || !isObject(value)) continue;
+    if (value.type !== "token") continue;
+    const tokenRecord = normalizeTokenRecord(key, value);
+    if (!tokenRecord) continue;
+    if (!matchesBucket(bucket, tokenRecord)) continue;
+    if (tokenRecord.timestamp < startMs || tokenRecord.timestamp >= endMs) continue;
+    const requestMatch = intersects(tokenRecord.providerRequestIds, officialRequestIdSet);
+    const responseMatch = intersects(
+      tokenRecord.providerResponseIds,
+      officialResponseIdSet
+    );
+    if (hasOfficialRequestEvidence && !requestMatch && !responseMatch) continue;
+    if (requestMatch) {
+      for (const requestId of tokenRecord.providerRequestIds) {
+        if (officialRequestIdSet.has(requestId)) matchedOfficialRequestIds.add(requestId);
+      }
+    }
+    tokenRecords.push(tokenRecord);
+    tokenKeys.add(key);
+  }
+
+  const allLedgerTransactions: ProviderBillingDrilldownLedgerTransaction[] = [];
+  for await (const [key, value] of store.iterator({
+    gte: LEDGER_TX_PREFIX,
+    lte: LEDGER_TX_RANGE_END,
+  })) {
+    if (!isObject(value)) continue;
+    allLedgerTransactions.push(normalizeLedgerTransaction(key, value));
+  }
+
+  const exactProviderCallIds = new Set<string>();
+  for (const tx of allLedgerTransactions) {
+    const tokenKey =
+      typeof tx.metadata?.tokenKey === "string" ? tx.metadata.tokenKey : "";
+    if (!tokenKeys.has(tokenKey)) continue;
+    const providerCallId = providerCallIdFromIdempotencyKey(tx.idempotencyKey);
+    if (providerCallId) exactProviderCallIds.add(providerCallId);
+  }
+
+  const providerCalls: ProviderCallCompletedEvent[] = [];
+  const providerCallIds = new Set<string>();
+  for await (const [, value] of store.iterator({
+    gte: PROVIDER_CALL_PREFIX,
+    lte: PROVIDER_CALL_RANGE_END,
+  })) {
+    if (!isCompletedProviderCall(value)) continue;
+    if (!matchesBucket(bucket, value)) continue;
+    if (!isWithinWindow(value.completedAt, startMs, endMs)) continue;
+    if (
+      hasOfficialRequestEvidence &&
+      (exactProviderCallIds.size === 0 ||
+        !exactProviderCallIds.has(value.providerCallId))
+    ) {
+      continue;
+    }
+    providerCalls.push(value);
+    providerCallIds.add(value.providerCallId);
+  }
+
+  const billableEvents: ProviderBillableEvent[] = [];
+  const billableEventIds = new Set<string>();
+  for await (const [, value] of store.iterator({
+    gte: BILLABLE_EVENT_PREFIX,
+    lte: BILLABLE_EVENT_RANGE_END,
+  })) {
+    if (!isProviderBillableEvent(value)) continue;
+    if (!matchesBucket(bucket, value)) continue;
+    if (
+      !value.sourceProviderCallIds.some((providerCallId) =>
+        providerCallIds.has(providerCallId)
+      )
+    ) {
+      continue;
+    }
+    billableEvents.push(value);
+    billableEventIds.add(value.id);
+  }
+
+  const ratingResults: RatingResult[] = [];
+  for await (const [, value] of store.iterator({
+    gte: RATING_RESULT_PREFIX,
+    lte: RATING_RESULT_RANGE_END,
+  })) {
+    if (!isRatingResult(value)) continue;
+    if (!matchesBucket(bucket, value)) continue;
+    if (!billableEventIds.has(value.billableEventId)) continue;
+    ratingResults.push(value);
+  }
+
+  const ledgerTransactions: ProviderBillingDrilldownLedgerTransaction[] = [];
+  for (const tx of allLedgerTransactions) {
+    const tokenKey =
+      typeof tx.metadata?.tokenKey === "string" ? tx.metadata.tokenKey : "";
+    const providerCallId = providerCallIdFromIdempotencyKey(tx.idempotencyKey);
+    const linkedToProviderCall = [...providerCallIds].some(
+      (candidateProviderCallId) => providerCallId === candidateProviderCallId
+    );
+    if (!linkedToProviderCall && !tokenKeys.has(tokenKey)) continue;
+    ledgerTransactions.push(tx);
+  }
+
+  return {
+    bucket,
+    matchMode: hasOfficialRequestEvidence ? "official_request_id" : "bucket_window",
+    officialEvidence,
+    officialRequestIds,
+    officialResponseIds,
+    unmatchedOfficialRequestIds: officialRequestIds.filter(
+      (requestId) => !matchedOfficialRequestIds.has(requestId)
+    ),
+    summary: {
+      providerCallCount: providerCalls.length,
+      billableEventCount: billableEvents.length,
+      ratingResultCount: ratingResults.length,
+      tokenRecordCount: tokenRecords.length,
+      ledgerTransactionCount: ledgerTransactions.length,
+    },
+    providerCalls: providerCalls.slice(0, maxRows),
+    billableEvents: billableEvents.slice(0, maxRows),
+    ratingResults: ratingResults.slice(0, maxRows),
+    tokenRecords: tokenRecords.slice(0, maxRows),
+    ledgerTransactions: ledgerTransactions.slice(0, maxRows),
+  };
+}