nolo-cli 0.1.29 → 0.1.31

package/ai/token/externalToolCost.ts

@@ -4,7 +4,7 @@
  * 外部 API 工具（OCR、搜索、浏览器等）的统一计费抽象。
  *
  * 价格单位：credits / 1M tokens（token 类），或 credits / 次调用（perCall 类）。
- * 换算关系：1 USD = 8 credits（与 fireworks/openrouter 一致）。
+ * 换算关系按模型/服务家族维护：默认 *8，DeepInfra 托管的 Claude *9。
  *
  * 如何添加新工具：
  *   在 EXTERNAL_TOOL_PRICING 中增加一条记录，然后在 handler 里调用
@@ -13,14 +13,17 @@
 
 import { ulid } from "ulid";
 import { format } from "date-fns";
-import serverDb from "../../database/server/db";
+import { getServerAuthorityStore } from "../../database/server/db";
 import { createKey, createTokenKey, createTokenStatsKey } from "../../database/keys";
 import { chargeTokenUsageWithLedger } from "../../auth/server/tokenUsageBilling";
 import { DataType } from "../../create/types";
 import pino from "pino";
-import { applyServerDialogProjectionDelta } from "./serverDialogProjection";
+import { applyServerDialogProjectionDelta } from "./serverDialogProjection";
+import { DEFAULT_COMMERCIAL_MULTIPLIER } from "../policy/commercialMultiplier";
 
-const logger = pino({ name: "external-tool-cost" });
+const logger = pino({ name: "external-tool-cost" });
+const DEFAULT_TOOL_MULTIPLIER = DEFAULT_COMMERCIAL_MULTIPLIER;
+const getExternalToolCostStore = () => getServerAuthorityStore();
 
 // ─────────────────────────────────────────
 //  价格注册表（所有外部工具）
@@ -28,9 +31,9 @@ const logger = pino({ name: "external-tool-cost" });
 
 type TokenPrice = {
   type: "token";
-  /** credits / 1M input tokens  (USD/1M × 8) */
+  /** credits / 1M input tokens */
   input: number;
-  /** credits / 1M output tokens (USD/1M × 8) */
+  /** credits / 1M output tokens */
   output: number;
   provider: string;
 };
@@ -58,34 +61,40 @@ type ToolPrice = TokenPrice | PerCallPrice | PerMinutePrice;
  * OCR 价格来自 DeepInfra 官网（截图，2026-03）：
  *   olmOCR     $0.09/$0.19 /1M → ×8
  *   DeepSeek   $0.03/$0.10 /1M → ×8
- *
- * Exa 价格：$0.01/次（含 contents）× 8
+ *
+ * Exa 价格：$0.01/次（含 contents）× 8
  */
 export const EXTERNAL_TOOL_PRICING: Record<string, ToolPrice> = {
   // ── OCR (DeepInfra, token-based) ──────────────────────
   "allenai/olmOCR-2-7B-1025": {
     type: "token",
-    input: 0.09 * 8,   // 0.72
-    output: 0.19 * 8,  // 1.52
-    provider: "deepinfra",
-  },
-
-  // ── Web Search ────────────────────────────────────────
-  "exa_search": {
+    input: 0.09 * DEFAULT_TOOL_MULTIPLIER,
+    output: 0.19 * DEFAULT_TOOL_MULTIPLIER,
+    provider: "deepinfra",
+  },
+  "deepseek-ai/DeepSeek-OCR": {
+    type: "token",
+    input: 0.03 * DEFAULT_TOOL_MULTIPLIER,
+    output: 0.10 * DEFAULT_TOOL_MULTIPLIER,
+    provider: "deepinfra",
+  },
+
+  // ── Web Search ────────────────────────────────────────
+  "exa_search": {
     type: "perCall",
-    cost: 0.01 * 8,   // 0.08
+    cost: 0.01 * DEFAULT_TOOL_MULTIPLIER,
     provider: "exa",
   },
 
   // ── ASR / Whisper (DeepInfra, per-minute) ─────────────
   "openai/whisper-large-v3-turbo": {
     type: "perMinute",
-    cost: 0.00020 * 8,  // 0.0016 credits/min
+    cost: 0.00020 * DEFAULT_TOOL_MULTIPLIER,
     provider: "deepinfra",
   },
   "openai/whisper-large-v3": {
     type: "perMinute",
-    cost: 0.00045 * 8,  // 0.0036 credits/min
+    cost: 0.00045 * DEFAULT_TOOL_MULTIPLIER,
     provider: "deepinfra",
   },
 
@@ -94,7 +103,7 @@ export const EXTERNAL_TOOL_PRICING: Record<string, ToolPrice> = {
   // 保守取 $0.25/run 作为默认基准，建议高消耗 Actor 单独定价
   "apify_actor_run": {
     type: "perCall",
-    cost: 0.25 * 8,   // 2.0 credits/run
+    cost: 0.25 * DEFAULT_TOOL_MULTIPLIER,
     provider: "apify",
   },
 
@@ -103,36 +112,36 @@ export const EXTERNAL_TOOL_PRICING: Record<string, ToolPrice> = {
   // 3 Pro Image Preview: ~$0.15/image（Pro 系列，多图编辑）
   "gemini-2.5-flash-image": {
     type: "perCall",
-    cost: 0.04 * 8,   // 0.32 credits/image
+    cost: 0.04 * DEFAULT_TOOL_MULTIPLIER,
     provider: "google",
   },
   // OpenAI image generation currently goes through the images API instead of
   // token accounting, so register a per-image fallback price here.
   "gpt-image-1.5": {
     type: "perCall",
-    cost: 0.04 * 8,   // 0.32 credits/image
+    cost: 0.04 * DEFAULT_TOOL_MULTIPLIER,   // 0.32 credits/image
     provider: "openai",
   },
   "gpt-image-2": {
     type: "perCall",
-    cost: 0.04 * 8,   // 0.32 credits/image placeholder
+    cost: 0.04 * DEFAULT_TOOL_MULTIPLIER,   // 0.32 credits/image placeholder
     provider: "openai",
   },
   "gemini-3-pro-image-preview": {
     type: "perCall",
-    cost: 0.15 * 8,   // 1.2 credits/image
+    cost: 0.15 * DEFAULT_TOOL_MULTIPLIER,
     provider: "google",
   },
   "gemini-3.1-flash-image-preview": {
     type: "perCall",
-    cost: 0.067 * 8,   // fallback only; Gemini handler overrides by image size
+    cost: 0.067 * DEFAULT_TOOL_MULTIPLIER,   // fallback only; Gemini handler overrides by image size
     provider: "google",
   },
 
   // ── Cloudflare Browser Rendering (per-minute) ─────────
   "cf_browser_rendering": {
     type: "perMinute",
-    cost: 0.001 * 8,  // $0.008/min
+    cost: 0.001 * DEFAULT_TOOL_MULTIPLIER,
     provider: "cloudflare",
   },
 
@@ -140,12 +149,12 @@ export const EXTERNAL_TOOL_PRICING: Record<string, ToolPrice> = {
   // @cf/openai/whisper，价格与 DeepInfra whisper-large-v3 相近
   "@cf/openai/whisper": {
     type: "perMinute",
-    cost: 0.00045 * 8,  // $0.0036 credits/min
+    cost: 0.00045 * DEFAULT_TOOL_MULTIPLIER,
     provider: "cloudflare",
   },
   "@cf/myshell-ai/melotts": {
     type: "perMinute",
-    cost: 0.00020 * 8,  // $0.0016 credits/min
+    cost: 0.00020 * DEFAULT_TOOL_MULTIPLIER,
     provider: "cloudflare",
   },
 };
@@ -183,11 +192,12 @@ export interface ChargeResult {
  * 计算费用、扣余额、写 usage 记录，三步合一。
  * 若 toolId 未注册，跳过扣费并打 warn 日志。
  */
-export async function chargeExternalTool(
-  opts: ChargeExternalToolOpts
-): Promise<ChargeResult> {
-  const {
-    userId,
+export async function chargeExternalTool(
+  opts: ChargeExternalToolOpts
+): Promise<ChargeResult> {
+  const store = getExternalToolCostStore();
+  const {
+    userId,
     toolId,
     dialogId,
     inputTokens = 0,
@@ -223,6 +233,7 @@ export async function chargeExternalTool(
   const deductReason = reason ?? toolId;
   // 写 usage 记录（与 LLM token 记录同格式，显示在 Usage 页面）
   const usageRecord = await writeUsageRecord({
+    store,
     userId,
     toolId,
     dialogId,
@@ -233,7 +244,7 @@ export async function chargeExternalTool(
   });
 
   const chargeResult = await chargeTokenUsageWithLedger({
-    store: serverDb,
+    store,
     userId,
     tokenKey: usageRecord.recordKey,
     tokenRecord: usageRecord.tokenRecord,
@@ -280,15 +291,17 @@ export async function chargeExternalTool(
 // ─────────────────────────────────────────
 
 async function writeUsageRecord(opts: {
-  userId: string;
-  toolId: string;
-  dialogId?: string;
+  store: ReturnType<typeof getServerAuthorityStore>;
+  userId: string;
+  toolId: string;
+  dialogId?: string;
   inputTokens: number;
   outputTokens: number;
   cost: number;
   provider: string;
 }): Promise<{ recordKey: string; tokenRecord: any }> {
-  const { userId, toolId, dialogId, inputTokens, outputTokens, cost, provider } = opts;
+  const { store, userId, toolId, dialogId, inputTokens, outputTokens, cost, provider } =
+    opts;
   const timestamp = Date.now();
   const dateKey = format(timestamp, "yyyy-MM-dd");
   const recordKey = createTokenKey.record(userId, timestamp);
@@ -314,9 +327,9 @@ async function writeUsageRecord(opts: {
     dateKey,
   };
 
-  const statsKey = createTokenStatsKey(userId, dateKey);
-  let stats: any = null;
-  try { stats = await serverDb.get(statsKey); } catch { /* init below */ }
+  const statsKey = createTokenStatsKey(userId, dateKey);
+  let stats: any = null;
+  try { stats = await store.get(statsKey); } catch { /* init below */ }
 
   const inc = (s: any = { count: 0, tokens: { input: 0, output: 0 }, cost: 0 }) => ({
     count: s.count + 1,
@@ -333,7 +346,7 @@ async function writeUsageRecord(opts: {
     models: { ...base.models, [toolId]: inc(base.models?.[toolId]) },
     providers: { ...base.providers, [provider]: inc(base.providers?.[provider]) },
   };
-  await serverDb.batch([
+  await store.batchWrite([
     { type: "put", key: recordKey, value: record },
     { type: "put", key: statsKey, value: newStats },
   ]);

package/ai/token/missingUsageEstimate.ts

@@ -21,19 +21,28 @@ const stringifyContent = (content: unknown): string => {
 
 export const estimateMissingUsage = ({
   content,
+  inputContent,
+  minimumInputTokens = 1,
   minimumOutputTokens = 1,
 }: {
   content: unknown;
+  inputContent?: unknown;
+  minimumInputTokens?: number;
   minimumOutputTokens?: number;
 }): RawUsage => {
-  const text = stringifyContent(content);
+  const outputText = stringifyContent(content);
+  const inputText = stringifyContent(inputContent);
+  const estimatedInputTokens = Math.max(
+    minimumInputTokens,
+    Math.ceil(inputText.length / APPROX_CHARS_PER_TOKEN)
+  );
   const estimatedOutputTokens = Math.max(
     minimumOutputTokens,
-    Math.ceil(text.length / APPROX_CHARS_PER_TOKEN)
+    Math.ceil(outputText.length / APPROX_CHARS_PER_TOKEN)
   );
 
   return {
-    input_tokens: 1,
+    input_tokens: estimatedInputTokens,
     output_tokens: estimatedOutputTokens,
     cache_creation_input_tokens: 0,
     cache_read_input_tokens: 0,

package/ai/token/normalizeUsage.ts

@@ -2,6 +2,36 @@
 
 import { RawUsage, NormalizedUsage } from "./types";
 
+const normalizeStringArray = (value: unknown): string[] | undefined => {
+  if (!Array.isArray(value)) return undefined;
+  const normalized = Array.from(
+    new Set(
+      value
+        .filter((item): item is string => typeof item === "string")
+        .map((item) => item.trim())
+        .filter(Boolean)
+    )
+  );
+  return normalized.length > 0 ? normalized : undefined;
+};
+
+const finiteTokenCount = (value: unknown): number | undefined => {
+  if (typeof value !== "number" || !Number.isFinite(value)) return undefined;
+  return Math.max(0, Math.floor(value));
+};
+
+const readNestedTokenCount = (
+  value: unknown,
+  path: readonly string[]
+): number | undefined => {
+  let cursor = value;
+  for (const key of path) {
+    if (!cursor || typeof cursor !== "object") return undefined;
+    cursor = (cursor as Record<string, unknown>)[key];
+  }
+  return finiteTokenCount(cursor);
+};
+
 /**
  * 规范化 usage 数据
  */
@@ -28,11 +58,11 @@ export const normalizeUsage = (usage: RawUsage): NormalizedUsage => {
         : 0;
 
   const cacheReadInputTokens =
-    "cache_read_input_tokens" in usage
-      ? usage.cache_read_input_tokens
-      : "prompt_cache_hit_tokens" in usage
-        ? usage.prompt_cache_hit_tokens
-        : 0;
+    finiteTokenCount((usage as any).cache_read_input_tokens) ??
+    finiteTokenCount((usage as any).prompt_cache_hit_tokens) ??
+    readNestedTokenCount(usage, ["input_tokens_details", "cached_tokens"]) ??
+    readNestedTokenCount(usage, ["prompt_tokens_details", "cached_tokens"]) ??
+    0;
 
   // ✅ 如果 provider 返回 usage.cost，则先原样透传；
   // 后续由 calculatePrice 按各 provider 的账单单位再做换算。
@@ -64,6 +94,12 @@ export const normalizeUsage = (usage: RawUsage): NormalizedUsage => {
     Number.isFinite(usage.image_generation_count)
       ? usage.image_generation_count
       : undefined;
+  const providerResponseIds = normalizeStringArray(
+    (usage as any).provider_response_ids
+  );
+  const providerRequestIds = normalizeStringArray(
+    (usage as any).provider_request_ids
+  );
 
   return {
     input_tokens: inputTokens,
@@ -74,6 +110,10 @@ export const normalizeUsage = (usage: RawUsage): NormalizedUsage => {
     ...(typeof imageGenerationCount === "number"
       ? { image_generation_count: imageGenerationCount }
       : {}),
+    ...(providerResponseIds
+      ? { provider_response_ids: providerResponseIds }
+      : {}),
+    ...(providerRequestIds ? { provider_request_ids: providerRequestIds } : {}),
     ...(billingProvider ? { billing_provider: billingProvider } : {}),
     ...(billingModel ? { billing_model: billingModel } : {}),
     ...(billingServiceTier

package/ai/token/openaiReconciliation.ts

@@ -0,0 +1,188 @@
+import type { NormalizedOfficialProviderBucket } from "./deepinfraReconciliation";
+
+type OpenAICompletionsUsageResponse = {
+  data?: Array<{
+    start_time?: number;
+    end_time?: number;
+    results?: Array<{
+      model?: string;
+      num_model_requests?: number;
+      input_tokens?: number;
+      output_tokens?: number;
+      input_cached_tokens?: number;
+    }>;
+  }>;
+};
+
+type OpenAICostsResponse = {
+  data?: Array<{
+    start_time?: number;
+    end_time?: number;
+    results?: Array<{
+      amount?: {
+        value?: number | string;
+        currency?: string;
+      };
+      line_item?: string;
+      project_id?: string;
+      organization_id?: string;
+    }>;
+  }>;
+};
+
+const unixSecondsToIso = (value: unknown) => {
+  const seconds = typeof value === "number" ? value : NaN;
+  if (!Number.isFinite(seconds)) return undefined;
+  return new Date(seconds * 1000).toISOString();
+};
+
+const numberOrZero = (value: unknown) =>
+  typeof value === "number" && Number.isFinite(value) ? value : 0;
+
+const decimalNumberOrZero = (value: unknown) => {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value !== "string") return 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+};
+
+const normalizeCostLineItemModel = (lineItem: string | undefined) =>
+  lineItem?.replace(/,\s*(input|output)$/i, "");
+
+export function normalizeOpenAICompletionsUsageResponse(
+  response: OpenAICompletionsUsageResponse
+): NormalizedOfficialProviderBucket[] {
+  const buckets: NormalizedOfficialProviderBucket[] = [];
+  for (const bucket of response.data ?? []) {
+    const bucketStart = unixSecondsToIso(bucket.start_time);
+    const bucketEnd = unixSecondsToIso(bucket.end_time);
+    if (!bucketStart || !bucketEnd) continue;
+    for (const result of bucket.results ?? []) {
+      buckets.push({
+        provider: "openai",
+        model: result.model,
+        bucketStart,
+        bucketEnd,
+        official: {
+          requestCount: numberOrZero(result.num_model_requests),
+          inputTokens: numberOrZero(result.input_tokens),
+          outputTokens: numberOrZero(result.output_tokens),
+          rawProviderCostUsd: 0,
+        },
+        evidence: {
+          inputCachedTokens: numberOrZero(result.input_cached_tokens),
+          source: "openai_completions_usage",
+        },
+      });
+    }
+  }
+  return buckets;
+}
+
+export function normalizeOpenAICostsResponse(
+  response: OpenAICostsResponse
+): NormalizedOfficialProviderBucket[] {
+  const buckets: NormalizedOfficialProviderBucket[] = [];
+  for (const bucket of response.data ?? []) {
+    const bucketStart = unixSecondsToIso(bucket.start_time);
+    const bucketEnd = unixSecondsToIso(bucket.end_time);
+    if (!bucketStart || !bucketEnd) continue;
+    for (const result of bucket.results ?? []) {
+      const currency = result.amount?.currency;
+      buckets.push({
+        provider: "openai",
+        model: normalizeCostLineItemModel(result.line_item),
+        bucketStart,
+        bucketEnd,
+        official: {
+          requestCount: 0,
+          inputTokens: 0,
+          outputTokens: 0,
+          rawProviderCostUsd:
+            currency?.toLowerCase() === "usd"
+              ? decimalNumberOrZero(result.amount?.value)
+              : 0,
+        },
+        evidence: {
+          source: "openai_costs",
+          currency,
+          lineItem: result.line_item,
+        },
+      });
+    }
+  }
+  return buckets;
+}
+
+const mergeKey = (bucket: NormalizedOfficialProviderBucket) =>
+  [
+    bucket.provider,
+    bucket.model ?? "",
+    bucket.bucketStart,
+    bucket.bucketEnd,
+  ].join("\u0000");
+
+export function mergeOpenAIUsageAndCostBuckets(
+  usageBuckets: NormalizedOfficialProviderBucket[],
+  costBuckets: NormalizedOfficialProviderBucket[]
+): NormalizedOfficialProviderBucket[] {
+  const costByKey = new Map<string, NormalizedOfficialProviderBucket>();
+  for (const bucket of costBuckets) {
+    const key = mergeKey(bucket);
+    const existing = costByKey.get(key);
+    if (!existing) {
+      costByKey.set(key, bucket);
+      continue;
+    }
+    costByKey.set(key, {
+      ...existing,
+      official: {
+        ...existing.official,
+        rawProviderCostUsd:
+          existing.official.rawProviderCostUsd +
+          bucket.official.rawProviderCostUsd,
+      },
+      evidence: {
+        ...existing.evidence,
+        costEvidenceItems: [
+          ...(Array.isArray(existing.evidence.costEvidenceItems)
+            ? existing.evidence.costEvidenceItems
+            : [existing.evidence]),
+          bucket.evidence,
+        ],
+      },
+    });
+  }
+  const merged: NormalizedOfficialProviderBucket[] = [];
+  const usedCostKeys = new Set<string>();
+
+  for (const usageBucket of usageBuckets) {
+    const key = mergeKey(usageBucket);
+    const costBucket = costByKey.get(key);
+    if (!costBucket) {
+      merged.push(usageBucket);
+      continue;
+    }
+    usedCostKeys.add(key);
+    merged.push({
+      ...usageBucket,
+      official: {
+        ...usageBucket.official,
+        rawProviderCostUsd: costBucket.official.rawProviderCostUsd,
+      },
+      evidence: {
+        ...usageBucket.evidence,
+        source: `${usageBucket.evidence.source}+openai_costs`,
+        costEvidence: costBucket.evidence,
+      },
+    });
+  }
+
+  for (const costBucket of costBuckets) {
+    if (!usedCostKeys.has(mergeKey(costBucket))) {
+      merged.push(costBucket);
+    }
+  }
+
+  return merged;
+}

package/ai/token/providerBillableEvent.ts

@@ -0,0 +1,84 @@
+export type ProviderBillableEventKind =
+  | "llm_tokens"
+  | "external_tool_tokens"
+  | "image_generation"
+  | "hosted_tool"
+  | "storage";
+
+export type ProviderBillableEventStatus = "unrated" | "rated" | "void";
+
+export type ProviderBillableUsage = {
+  inputTokens: number;
+  outputTokens: number;
+  cacheCreationInputTokens: number;
+  cacheReadInputTokens: number;
+  imageCount?: number;
+  toolUnits?: number;
+};
+
+export type ProviderBillableEvent = {
+  id: string;
+  operationId: string;
+  sourceProviderCallIds: string[];
+  userId: string;
+  dialogId?: string;
+  agentId?: string;
+  provider: string;
+  model: string;
+  endpoint?: string;
+  kind: ProviderBillableEventKind;
+  toolId?: string;
+  usage: ProviderBillableUsage;
+  estimated: boolean;
+  estimateReason?: string;
+  needsReconciliation: boolean;
+  status: ProviderBillableEventStatus;
+  createdAt: string;
+};
+
+export type CreateProviderBillableEventInput = {
+  eventId: string;
+  operationId: string;
+  sourceProviderCallIds: string[];
+  userId: string;
+  dialogId?: string;
+  agentId?: string;
+  provider: string;
+  model: string;
+  endpoint?: string;
+  kind: ProviderBillableEventKind;
+  toolId?: string;
+  usage: ProviderBillableUsage;
+  estimated?: boolean;
+  estimateReason?: string;
+  needsReconciliation?: boolean;
+  createdAt: string;
+};
+
+export const buildProviderBillableEventKey = (eventId: string) =>
+  `provider-billable-event-${eventId}`;
+
+export const createProviderBillableEvent = (
+  input: CreateProviderBillableEventInput
+): ProviderBillableEvent => {
+  const estimated = input.estimated === true;
+  return {
+    id: input.eventId,
+    operationId: input.operationId,
+    sourceProviderCallIds: [...input.sourceProviderCallIds],
+    userId: input.userId,
+    dialogId: input.dialogId,
+    agentId: input.agentId,
+    provider: input.provider,
+    model: input.model,
+    endpoint: input.endpoint,
+    kind: input.kind,
+    toolId: input.toolId,
+    usage: { ...input.usage },
+    estimated,
+    estimateReason: input.estimateReason,
+    needsReconciliation: estimated || input.needsReconciliation === true,
+    status: "unrated",
+    createdAt: input.createdAt,
+  };
+};

package/ai/token/providerBillableEventWriter.ts

@@ -0,0 +1,36 @@
+import {
+  buildProviderBillableEventKey,
+  type ProviderBillableEvent,
+} from "./providerBillableEvent";
+
+export type ProviderBillableEventStore = {
+  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;
+  return code === "LEVEL_NOT_FOUND" || code === "NOT_FOUND";
+};
+
+export async function writeProviderBillableEvent({
+  store,
+  event,
+}: {
+  store: ProviderBillableEventStore;
+  event: ProviderBillableEvent;
+}): Promise<{ key: string }> {
+  const key = buildProviderBillableEventKey(event.id);
+  let existing: unknown;
+  try {
+    existing = await store.get(key);
+  } catch (error) {
+    if (!isMissingRecordError(error)) throw error;
+  }
+  if (existing) {
+    throw new Error(`provider billable event already exists: ${key}`);
+  }
+  await store.put(key, event);
+  return { key };
+}