nolo-cli 0.1.29 → 0.1.31

package/ai/token/billingAdminAuditEvent.ts

@@ -0,0 +1,68 @@
+export type BillingAdminAuditAction =
+  | "dry_run_viewed"
+  | "reconciliation_dry_run"
+  | "reconciliation_committed"
+  | "plan_marked_reviewed"
+  | "plan_abandoned";
+
+export type BillingAdminAuditEvent = {
+  schemaVersion: 1;
+  recordType: "billing_admin_audit_event";
+  eventId: string;
+  actorId: string;
+  action: BillingAdminAuditAction;
+  anomalyId: string;
+  planId: string;
+  inputSetHash: string;
+  createdAt: string;
+  reason?: string;
+};
+
+export const buildBillingAdminAuditEventKey = (eventId: string) =>
+  `billing-admin-audit-event-${eventId}`;
+
+function assertIsoTimestamp(name: string, value: string) {
+  const time = Date.parse(value);
+  if (!Number.isFinite(time)) {
+    throw new Error(`${name} must be an ISO timestamp`);
+  }
+}
+
+export function createBillingAdminAuditEvent({
+  eventId,
+  actorId,
+  action,
+  anomalyId,
+  planId,
+  inputSetHash,
+  createdAt,
+  reason,
+}: {
+  eventId: string;
+  actorId: string;
+  action: BillingAdminAuditAction;
+  anomalyId: string;
+  planId: string;
+  inputSetHash: string;
+  createdAt: string;
+  reason?: string | null;
+}): BillingAdminAuditEvent {
+  if (!eventId.trim()) throw new Error("eventId is required");
+  if (!actorId.trim()) throw new Error("actorId is required");
+  if (!anomalyId.trim()) throw new Error("anomalyId is required");
+  if (!planId.trim()) throw new Error("planId is required");
+  if (!inputSetHash.trim()) throw new Error("inputSetHash is required");
+  assertIsoTimestamp("createdAt", createdAt);
+  return {
+    schemaVersion: 1,
+    recordType: "billing_admin_audit_event",
+    eventId: eventId.trim(),
+    actorId: actorId.trim(),
+    action,
+    anomalyId: anomalyId.trim(),
+    planId: planId.trim(),
+    inputSetHash: inputSetHash.trim(),
+    createdAt,
+    ...(reason?.trim() ? { reason: reason.trim() } : {}),
+  };
+}

package/ai/token/billingAdminAuditEventWriter.ts

@@ -0,0 +1,41 @@
+import {
+  buildBillingAdminAuditEventKey,
+  type BillingAdminAuditEvent,
+} from "./billingAdminAuditEvent";
+
+export type BillingAdminAuditEventStore = {
+  get(key: string): Promise<unknown>;
+  put(key: string, value: unknown): Promise<void>;
+};
+
+const isMissingRecordError = (error: unknown) => {
+  if (!error || typeof error !== "object") return false;
+  const code = (error as { code?: unknown }).code;
+  const message = (error as { message?: unknown }).message;
+  return (
+    code === "LEVEL_NOT_FOUND" ||
+    code === "NOT_FOUND" ||
+    message === "NotFound"
+  );
+};
+
+export async function writeBillingAdminAuditEvent({
+  store,
+  event,
+}: {
+  store: BillingAdminAuditEventStore;
+  event: BillingAdminAuditEvent;
+}): Promise<{ key: string }> {
+  const key = buildBillingAdminAuditEventKey(event.eventId);
+  let existing: unknown;
+  try {
+    existing = await store.get(key);
+  } catch (error) {
+    if (!isMissingRecordError(error)) throw error;
+  }
+  if (existing) {
+    throw new Error(`billing admin audit event already exists: ${key}`);
+  }
+  await store.put(key, event);
+  return { key };
+}

package/ai/token/billingAnomaly.ts

@@ -0,0 +1,90 @@
+export type BillingAnomalyKind =
+  | "provider_call_write_failed"
+  | "provider_credential_revoked_blocked"
+  | "provider_credential_revoked_used"
+  | "billable_event_write_failed"
+  | "rating_failed"
+  | "ledger_failed"
+  | "provider_call_pending_timeout"
+  | "provider_call_sent_unknown"
+  | "provider_reconciliation_diff"
+  | "usage_missing"
+  | "aggregate_usage_unallocated"
+  | "pricing_missing";
+
+export type BillingAnomalySeverity = "low" | "medium" | "high" | "critical";
+
+export type BillingAnomalyStage =
+  | "provider_call"
+  | "billable_event"
+  | "rating"
+  | "ledger"
+  | "usage"
+  | "pricing"
+  | "reconciliation";
+
+export type BillingAnomalyStatus = "open" | "acknowledged" | "resolved" | "ignored";
+
+export type BillingAnomaly = {
+  id: string;
+  kind: BillingAnomalyKind;
+  severity: BillingAnomalySeverity;
+  stage: BillingAnomalyStage;
+  status: BillingAnomalyStatus;
+  userId: string;
+  dialogId?: string;
+  agentId?: string;
+  provider: string;
+  model: string;
+  providerCallId?: string;
+  billableEventId?: string;
+  ratingResultId?: string;
+  riskPlatformCredits?: number;
+  message: string;
+  evidence: Record<string, unknown>;
+  createdAt: string;
+};
+
+export type CreateBillingAnomalyInput = {
+  anomalyId: string;
+  kind: BillingAnomalyKind;
+  severity: BillingAnomalySeverity;
+  stage: BillingAnomalyStage;
+  userId: string;
+  dialogId?: string;
+  agentId?: string;
+  provider: string;
+  model: string;
+  providerCallId?: string;
+  billableEventId?: string;
+  ratingResultId?: string;
+  riskPlatformCredits?: number;
+  message: string;
+  evidence: Record<string, unknown>;
+  createdAt: string;
+};
+
+export const buildBillingAnomalyKey = (anomalyId: string) =>
+  `billing-anomaly-${anomalyId}`;
+
+export const createBillingAnomaly = (
+  input: CreateBillingAnomalyInput
+): BillingAnomaly => ({
+  id: input.anomalyId,
+  kind: input.kind,
+  severity: input.severity,
+  stage: input.stage,
+  status: "open",
+  userId: input.userId,
+  dialogId: input.dialogId,
+  agentId: input.agentId,
+  provider: input.provider,
+  model: input.model,
+  providerCallId: input.providerCallId,
+  billableEventId: input.billableEventId,
+  ratingResultId: input.ratingResultId,
+  riskPlatformCredits: input.riskPlatformCredits,
+  message: input.message,
+  evidence: { ...input.evidence },
+  createdAt: input.createdAt,
+});

package/ai/token/billingAnomalyLifecycle.ts

@@ -0,0 +1,54 @@
+import type { BillingAnomalyStatus } from "./billingAnomaly";
+
+export type BillingAnomalyLifecycleEvent = {
+  schemaVersion: 1;
+  recordType: "billing_anomaly_lifecycle_event";
+  anomalyId: string;
+  eventId: string;
+  status: BillingAnomalyStatus;
+  createdAt: string;
+  actorId?: string;
+  reason?: string;
+};
+
+export const buildBillingAnomalyLifecycleEventKey = (
+  anomalyId: string,
+  eventId: string
+) => `billing-anomaly-lifecycle-${anomalyId}-event-${eventId}`;
+
+function assertIsoTimestamp(name: string, value: string) {
+  const time = Date.parse(value);
+  if (!Number.isFinite(time)) {
+    throw new Error(`${name} must be an ISO timestamp`);
+  }
+}
+
+export function createBillingAnomalyLifecycleEvent({
+  anomalyId,
+  eventId,
+  status,
+  createdAt,
+  actorId,
+  reason,
+}: {
+  anomalyId: string;
+  eventId: string;
+  status: BillingAnomalyStatus;
+  createdAt: string;
+  actorId?: string | null;
+  reason?: string | null;
+}): BillingAnomalyLifecycleEvent {
+  if (!anomalyId.trim()) throw new Error("anomalyId is required");
+  if (!eventId.trim()) throw new Error("eventId is required");
+  assertIsoTimestamp("createdAt", createdAt);
+  return {
+    schemaVersion: 1,
+    recordType: "billing_anomaly_lifecycle_event",
+    anomalyId: anomalyId.trim(),
+    eventId: eventId.trim(),
+    status,
+    createdAt,
+    ...(actorId?.trim() ? { actorId: actorId.trim() } : {}),
+    ...(reason?.trim() ? { reason: reason.trim() } : {}),
+  };
+}

package/ai/token/billingAnomalyLifecycleWriter.ts

@@ -0,0 +1,44 @@
+import {
+  buildBillingAnomalyLifecycleEventKey,
+  type BillingAnomalyLifecycleEvent,
+} from "./billingAnomalyLifecycle";
+
+export type BillingAnomalyLifecycleStore = {
+  get(key: string): Promise<unknown>;
+  put(key: string, value: unknown): Promise<void>;
+};
+
+const isMissingRecordError = (error: unknown) => {
+  if (!error || typeof error !== "object") return false;
+  const code = (error as { code?: unknown }).code;
+  const message = (error as { message?: unknown }).message;
+  return (
+    code === "LEVEL_NOT_FOUND" ||
+    code === "NOT_FOUND" ||
+    message === "NotFound"
+  );
+};
+
+export async function writeBillingAnomalyLifecycleEvent({
+  store,
+  event,
+}: {
+  store: BillingAnomalyLifecycleStore;
+  event: BillingAnomalyLifecycleEvent;
+}): Promise<{ key: string }> {
+  const key = buildBillingAnomalyLifecycleEventKey(
+    event.anomalyId,
+    event.eventId
+  );
+  let existing: unknown;
+  try {
+    existing = await store.get(key);
+  } catch (error) {
+    if (!isMissingRecordError(error)) throw error;
+  }
+  if (existing) {
+    throw new Error(`billing anomaly lifecycle event already exists: ${key}`);
+  }
+  await store.put(key, event);
+  return { key };
+}

package/ai/token/billingAnomalyWriter.ts

@@ -0,0 +1,41 @@
+import {
+  buildBillingAnomalyKey,
+  type BillingAnomaly,
+} from "./billingAnomaly";
+
+export type BillingAnomalyStore = {
+  get(key: string): Promise<unknown>;
+  put(key: string, value: unknown): Promise<void>;
+};
+
+const isMissingRecordError = (error: unknown) => {
+  if (!error || typeof error !== "object") return false;
+  const code = (error as { code?: unknown }).code;
+  const message = (error as { message?: unknown }).message;
+  return (
+    code === "LEVEL_NOT_FOUND" ||
+    code === "NOT_FOUND" ||
+    message === "NotFound"
+  );
+};
+
+export async function writeBillingAnomaly({
+  store,
+  anomaly,
+}: {
+  store: BillingAnomalyStore;
+  anomaly: BillingAnomaly;
+}): Promise<{ key: string }> {
+  const key = buildBillingAnomalyKey(anomaly.id);
+  let existing: unknown;
+  try {
+    existing = await store.get(key);
+  } catch (error) {
+    if (!isMissingRecordError(error)) throw error;
+  }
+  if (existing) {
+    throw new Error(`billing anomaly already exists: ${key}`);
+  }
+  await store.put(key, anomaly);
+  return { key };
+}

package/ai/token/calculatePrice.ts

@@ -9,6 +9,7 @@ import {
   type OpenAIServiceTier,
   resolveOpenAIServiceTier,
 } from "../../integrations/openai/flexTier";
+import { DEFAULT_COMMERCIAL_MULTIPLIER } from "../policy/commercialMultiplier";
 
 // ==================== 接口定义 ====================
 
@@ -369,8 +370,8 @@ const calculateOpenRouterFallbackCost = (
 };
 
 // OpenRouter usage.cost 是按其账户 credit（USD 基准）返回，
-// 本平台统一按 1 USD = 8 credits 记账，因此这里仍需做一次换算。
-const OPENROUTER_COST_MULTIPLIER = 8;
+// Provider USD cost converts to platform credits at the default *8 rule.
+const OPENROUTER_COST_MULTIPLIER = DEFAULT_COMMERCIAL_MULTIPLIER;
 
 const calculateOpenRouterCost = (usage: Usage): CostBreakdown => {
   if (!usage || typeof usage.cost !== "number" || usage.cost <= 0) {

package/ai/token/deepinfraReconciliation.ts

@@ -0,0 +1,153 @@
+import type { ProviderReconciliationBucketTotals } from "./providerReconciliation";
+
+export type NormalizedOfficialProviderBucket = {
+  provider: string;
+  model?: string;
+  endpoint?: string;
+  bucketStart: string;
+  bucketEnd: string;
+  official: ProviderReconciliationBucketTotals;
+  evidence: Record<string, unknown>;
+};
+
+type DeepInfraUsageResponse = {
+  months?: Array<{
+    period?: string;
+    interval?: { fr?: number; to?: number };
+    items?: Array<{
+      model?: {
+        provider?: string;
+        model_name?: string;
+        task?: string;
+      };
+      units?: number;
+      rate?: number;
+      cost?: number;
+      pricing_type?: string;
+      interval?: { fr?: number; to?: number };
+    }>;
+    total_cost?: number;
+    invoice_id?: string;
+  }>;
+  initial_month?: string;
+};
+
+type DeepInfraRequestCostsResponse = {
+  requests?: Array<{
+    requestId?: string;
+    model?: string;
+    costNanoUsd?: number;
+    createdAt?: string;
+  }>;
+};
+
+const unixSecondsToIso = (value: unknown) => {
+  const seconds = typeof value === "number" ? value : NaN;
+  if (!Number.isFinite(seconds)) return undefined;
+  return new Date(seconds * 1000).toISOString();
+};
+
+export function normalizeDeepInfraUsageResponse(
+  response: DeepInfraUsageResponse
+): NormalizedOfficialProviderBucket[] {
+  const buckets: NormalizedOfficialProviderBucket[] = [];
+  for (const month of response.months ?? []) {
+    for (const item of month.items ?? []) {
+      const bucketStart = unixSecondsToIso(item.interval?.fr ?? month.interval?.fr);
+      const bucketEnd = unixSecondsToIso(item.interval?.to ?? month.interval?.to);
+      if (!bucketStart || !bucketEnd) continue;
+      buckets.push({
+        provider: "deepinfra",
+        model: item.model?.model_name,
+        endpoint: item.model?.task,
+        bucketStart,
+        bucketEnd,
+        official: {
+          requestCount: 0,
+          inputTokens: 0,
+          outputTokens: 0,
+          rawProviderCostUsd:
+            typeof item.cost === "number" && Number.isFinite(item.cost)
+              ? item.cost
+              : 0,
+        },
+        evidence: {
+          period: month.period,
+          pricingType: item.pricing_type,
+          units: item.units,
+          rate: item.rate,
+          invoiceId: month.invoice_id,
+        },
+      });
+    }
+  }
+  return buckets;
+}
+
+const startOfUtcDay = (iso: string) => {
+  const date = new Date(iso);
+  if (!Number.isFinite(date.getTime())) return undefined;
+  return new Date(
+    Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate())
+  );
+};
+
+export function normalizeDeepInfraRequestCostsResponse(
+  response: DeepInfraRequestCostsResponse
+): NormalizedOfficialProviderBucket[] {
+  const grouped = new Map<
+    string,
+    {
+      provider: "deepinfra";
+      model?: string;
+      bucketStart: string;
+      bucketEnd: string;
+      requestCount: number;
+      rawProviderCostUsd: number;
+      requestIds: string[];
+    }
+  >();
+
+  for (const request of response.requests ?? []) {
+    if (!request.createdAt) continue;
+    const start = startOfUtcDay(request.createdAt);
+    if (!start) continue;
+    const bucketStart = start.toISOString();
+    const bucketEnd = new Date(start.getTime() + 24 * 60 * 60 * 1000).toISOString();
+    const key = ["deepinfra", request.model ?? "", bucketStart, bucketEnd].join("\u0000");
+    const existing =
+      grouped.get(key) ??
+      {
+        provider: "deepinfra" as const,
+        model: request.model,
+        bucketStart,
+        bucketEnd,
+        requestCount: 0,
+        rawProviderCostUsd: 0,
+        requestIds: [],
+      };
+    existing.requestCount += 1;
+    if (typeof request.costNanoUsd === "number" && Number.isFinite(request.costNanoUsd)) {
+      existing.rawProviderCostUsd += request.costNanoUsd / 1_000_000_000;
+    }
+    if (request.requestId) existing.requestIds.push(request.requestId);
+    grouped.set(key, existing);
+  }
+
+  return [...grouped.values()].map((bucket) => ({
+    provider: bucket.provider,
+    model: bucket.model,
+    bucketStart: bucket.bucketStart,
+    bucketEnd: bucket.bucketEnd,
+    official: {
+      requestCount: bucket.requestCount,
+      inputTokens: 0,
+      outputTokens: 0,
+      rawProviderCostUsd: Number(bucket.rawProviderCostUsd.toFixed(12)),
+    },
+    evidence: {
+      source: "deepinfra_request_costs",
+      requestIds: bucket.requestIds,
+    },
+  }));
+}

package/ai/token/deepinfraRequestIdQuery.ts

@@ -0,0 +1,92 @@
+export type DeepInfraRequestIdStore = {
+  iterator(options: { gte?: string; lte?: string }): AsyncIterable<[string, unknown]>;
+};
+
+export type DeepInfraRequestIdQueryResult = {
+  requestIds: string[];
+  responseIds: string[];
+  scannedTokenRecords: number;
+  matchedTokenRecords: number;
+};
+
+const TOKEN_PREFIX = "token-";
+const TOKEN_RANGE_END = `${TOKEN_PREFIX}\uffff`;
+
+const isTokenRecordLike = (value: unknown) =>
+  Boolean(
+    value &&
+      typeof value === "object" &&
+      typeof (value as { provider?: unknown }).provider === "string" &&
+      typeof (value as { createdAt?: unknown }).createdAt === "number"
+  );
+
+const pushStrings = (target: Set<string>, value: unknown) => {
+  if (!Array.isArray(value)) return;
+  for (const item of value) {
+    if (typeof item !== "string") continue;
+    const trimmed = item.trim();
+    if (trimmed) target.add(trimmed);
+  }
+};
+
+export async function collectDeepInfraRequestIds({
+  store,
+  bucketStart,
+  bucketEnd,
+}: {
+  store: DeepInfraRequestIdStore;
+  bucketStart: string;
+  bucketEnd: string;
+}): Promise<DeepInfraRequestIdQueryResult> {
+  return collectProviderRequestIds({
+    store,
+    provider: "deepinfra",
+    bucketStart,
+    bucketEnd,
+  });
+}
+
+export async function collectProviderRequestIds({
+  store,
+  provider,
+  bucketStart,
+  bucketEnd,
+}: {
+  store: DeepInfraRequestIdStore;
+  provider: string;
+  bucketStart: string;
+  bucketEnd: string;
+}): Promise<DeepInfraRequestIdQueryResult> {
+  const startMs = Date.parse(bucketStart);
+  const endMs = Date.parse(bucketEnd);
+  const requestIds = new Set<string>();
+  const responseIds = new Set<string>();
+  let scannedTokenRecords = 0;
+  let matchedTokenRecords = 0;
+
+  for await (const [, value] of store.iterator({
+    gte: TOKEN_PREFIX,
+    lte: TOKEN_RANGE_END,
+  })) {
+    if (!isTokenRecordLike(value)) continue;
+    scannedTokenRecords += 1;
+    const record = value as {
+      provider: string;
+      createdAt: number;
+      provider_request_ids?: unknown;
+      provider_response_ids?: unknown;
+    };
+    if (record.provider !== provider) continue;
+    if (record.createdAt < startMs || record.createdAt >= endMs) continue;
+    matchedTokenRecords += 1;
+    pushStrings(requestIds, record.provider_request_ids);
+    pushStrings(responseIds, record.provider_response_ids);
+  }
+
+  return {
+    requestIds: [...requestIds],
+    responseIds: [...responseIds],
+    scannedTokenRecords,
+    matchedTokenRecords,
+  };
+}