nolo-cli 0.1.13 → 0.1.15

package/ai/token/externalToolCost.ts

@@ -0,0 +1,321 @@
+/**
+ * externalToolCost.ts
+ *
+ * 外部 API 工具（OCR、搜索、浏览器等）的统一计费抽象。
+ *
+ * 价格单位：credits / 1M tokens（token 类），或 credits / 次调用（perCall 类）。
+ * 换算关系：1 USD = 8 credits（与 fireworks/openrouter 一致）。
+ *
+ * 如何添加新工具：
+ *   在 EXTERNAL_TOOL_PRICING 中增加一条记录，然后在 handler 里调用
+ *   chargeExternalTool({ userId, toolId, ... })。
+ */
+
+import { ulid } from "ulid";
+import { format } from "date-fns";
+import serverDb from "database/server/db";
+import { createKey, createTokenKey, createTokenStatsKey } from "database/keys";
+import { deductUserBalance } from "auth/server/deduct";
+import { DataType } from "create/types";
+import pino from "pino";
+import { applyServerDialogProjectionDelta } from "./serverDialogProjection";
+
+const logger = pino({ name: "external-tool-cost" });
+
+// ─────────────────────────────────────────
+//  价格注册表（所有外部工具）
+// ─────────────────────────────────────────
+
+type TokenPrice = {
+  type: "token";
+  /** credits / 1M input tokens  (USD/1M × 8) */
+  input: number;
+  /** credits / 1M output tokens (USD/1M × 8) */
+  output: number;
+  provider: string;
+};
+
+type PerCallPrice = {
+  type: "perCall";
+  /** credits / 次调用 */
+  cost: number;
+  provider: string;
+};
+
+type PerMinutePrice = {
+  type: "perMinute";
+  /** credits / 分钟 */
+  cost: number;
+  provider: string;
+};
+
+type ToolPrice = TokenPrice | PerCallPrice | PerMinutePrice;
+
+/**
+ * 外部工具价格表。
+ * 修改价格只需改这里，无需改动任何 handler。
+ *
+ * OCR 价格来自 DeepInfra 官网（截图，2026-03）：
+ *   olmOCR     $0.09/$0.19 /1M → ×8
+ *   DeepSeek   $0.03/$0.10 /1M → ×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": {
+    type: "perCall",
+    cost: 0.01 * 8,   // 0.08
+    provider: "exa",
+  },
+
+  // ── ASR / Whisper (DeepInfra, per-minute) ─────────────
+  "openai/whisper-large-v3-turbo": {
+    type: "perMinute",
+    cost: 0.00020 * 8,  // 0.0016 credits/min
+    provider: "deepinfra",
+  },
+  "openai/whisper-large-v3": {
+    type: "perMinute",
+    cost: 0.00045 * 8,  // 0.0036 credits/min
+    provider: "deepinfra",
+  },
+
+  // ── Apify Actors (per-run) ─────────────────────────────
+  // Apify 按 compute unit 计费，轻量爬虫 ~0.05–0.5 CU，$0.50/CU
+  // 保守取 $0.25/run 作为默认基准，建议高消耗 Actor 单独定价
+  "apify_actor_run": {
+    type: "perCall",
+    cost: 0.25 * 8,   // 2.0 credits/run
+    provider: "apify",
+  },
+
+  // ── Gemini Image Generation (per-image) ───────────────
+  // 2.5 Flash Image: ~$0.04/image（Flash 系列，文生图）
+  // 3 Pro Image Preview: ~$0.15/image（Pro 系列，多图编辑）
+  "gemini-2.5-flash-image": {
+    type: "perCall",
+    cost: 0.04 * 8,   // 0.32 credits/image
+    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
+    provider: "openai",
+  },
+  "gpt-image-2": {
+    type: "perCall",
+    cost: 0.04 * 8,   // 0.32 credits/image placeholder
+    provider: "openai",
+  },
+  "gemini-3-pro-image-preview": {
+    type: "perCall",
+    cost: 0.15 * 8,   // 1.2 credits/image
+    provider: "google",
+  },
+  "gemini-3.1-flash-image-preview": {
+    type: "perCall",
+    cost: 0.067 * 8,   // 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
+    provider: "cloudflare",
+  },
+
+  // ── Cloudflare Workers AI Whisper (per-minute) ────────
+  // @cf/openai/whisper，价格与 DeepInfra whisper-large-v3 相近
+  "@cf/openai/whisper": {
+    type: "perMinute",
+    cost: 0.00045 * 8,  // $0.0036 credits/min
+    provider: "cloudflare",
+  },
+  "@cf/myshell-ai/melotts": {
+    type: "perMinute",
+    cost: 0.00020 * 8,  // $0.0016 credits/min
+    provider: "cloudflare",
+  },
+};
+
+// ─────────────────────────────────────────
+//  计费入口
+// ─────────────────────────────────────────
+
+export interface ChargeExternalToolOpts {
+  userId: string;
+  /** 工具 ID，对应 EXTERNAL_TOOL_PRICING 的 key */
+  toolId: string;
+  /** 若工具调用发生在某个对话内，则回写到该 dialog 的累计成本 */
+  dialogId?: string;
+  /** token 类工具：来自 API 响应的 prompt_tokens / completion_tokens */
+  inputTokens?: number;
+  outputTokens?: number;
+  /** perMinute 类工具：音频实际时长（分钟） */
+  durationMinutes?: number;
+  /** perCall 类工具：调用次数（如按图片数量计费时传 imageCount），默认 1 */
+  count?: number;
+  /** 已由调用方基于模型配置算好的总费用（credits）。 */
+  costOverride?: number;
+  /** 扣费原因（用于事务日志） */
+  reason?: string;
+}
+
+export interface ChargeResult {
+  cost: number;
+  skipped: boolean;
+  reason?: string;
+}
+
+/**
+ * 计算费用、扣余额、写 usage 记录，三步合一。
+ * 若 toolId 未注册，跳过扣费并打 warn 日志。
+ */
+export async function chargeExternalTool(
+  opts: ChargeExternalToolOpts
+): Promise<ChargeResult> {
+  const {
+    userId,
+    toolId,
+    dialogId,
+    inputTokens = 0,
+    outputTokens = 0,
+    durationMinutes = 0,
+    count = 1,
+    costOverride,
+    reason,
+  } = opts;
+
+  const pricing = EXTERNAL_TOOL_PRICING[toolId];
+  if (!pricing) {
+    logger.warn({ toolId }, "Unknown external tool, skipping charge");
+    return { cost: 0, skipped: true, reason: "unknown_tool" };
+  }
+
+  // 计算 cost
+  let cost: number;
+  if (typeof costOverride === "number" && Number.isFinite(costOverride)) {
+    cost = costOverride;
+  } else if (pricing.type === "token") {
+    cost =
+      (inputTokens * pricing.input + outputTokens * pricing.output) / 1_000_000;
+  } else if (pricing.type === "perMinute") {
+    cost = durationMinutes * pricing.cost;
+  } else {
+    cost = pricing.cost * count;
+  }
+
+  cost = Number(cost.toFixed(6));
+  if (cost <= 0) return { cost: 0, skipped: true, reason: "zero_cost" };
+
+  // 扣余额
+  const deductReason = reason ?? toolId;
+  await deductUserBalance(userId, cost, deductReason);
+
+  // 写 usage 记录（与 LLM token 记录同格式，显示在 Usage 页面）
+  await writeUsageRecord({
+    userId,
+    toolId,
+    dialogId,
+    inputTokens,
+    outputTokens,
+    cost,
+    provider: pricing.provider,
+  });
+
+  if (dialogId) {
+    try {
+      await applyServerDialogProjectionDelta({
+        userId,
+        dialogId,
+        inputTokensDelta: inputTokens,
+        outputTokensDelta: outputTokens,
+        costDelta: cost,
+      });
+    } catch (error) {
+      logger.warn(
+        { err: error, userId, toolId, dialogId, cost },
+        "External tool charge persisted but dialog projection update failed",
+      );
+    }
+  }
+
+  logger.info({ userId, toolId, inputTokens, outputTokens, cost }, "External tool charged");
+  return { cost, skipped: false };
+}
+
+// ─────────────────────────────────────────
+//  内部：写 usage 记录到 LevelDB
+// ─────────────────────────────────────────
+
+async function writeUsageRecord(opts: {
+  userId: string;
+  toolId: string;
+  dialogId?: string;
+  inputTokens: number;
+  outputTokens: number;
+  cost: number;
+  provider: string;
+}): Promise<void> {
+  const { 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);
+  const tokenId = ulid(timestamp);
+
+  const record = {
+    id: tokenId,
+    type: DataType.TOKEN,
+    userId,
+    username: "",
+    cybotId: "external_tool",
+    model: toolId,
+    provider,
+    dialogId: dialogId ?? `tool-${tokenId}`,
+    input_tokens: inputTokens,
+    output_tokens: outputTokens,
+    cache_creation_input_tokens: 0,
+    cache_read_input_tokens: 0,
+    cost,
+    pay: null,
+    createdAt: timestamp,
+    timestamp,
+    dateKey,
+  };
+
+  const statsKey = createTokenStatsKey(userId, dateKey);
+  let stats: any = null;
+  try { stats = await serverDb.get(statsKey); } catch { /* init below */ }
+
+  const inc = (s: any = { count: 0, tokens: { input: 0, output: 0 }, cost: 0 }) => ({
+    count: s.count + 1,
+    tokens: { input: s.tokens.input + inputTokens, output: s.tokens.output + outputTokens },
+    cost: s.cost + cost,
+  });
+
+  const base = stats ?? { userId, period: "day", timeKey: dateKey, total: { count: 0, tokens: { input: 0, output: 0 }, cost: 0 }, models: {}, providers: {} };
+  const newStats = {
+    ...base,
+    id: statsKey,
+    type: DataType.TOKEN,
+    total: inc(base.total),
+    models: { ...base.models, [toolId]: inc(base.models?.[toolId]) },
+    providers: { ...base.providers, [provider]: inc(base.providers?.[provider]) },
+  };
+  await serverDb.batch([
+    { type: "put", key: recordKey, value: record },
+    { type: "put", key: statsKey, value: newStats },
+  ]);
+}

package/ai/token/hooks/useRecords.ts

@@ -0,0 +1,65 @@
+import { useState, useCallback, useEffect } from "react";
+import { useAppDispatch } from "app/store";
+import { queryUserTokensThunk } from "ai/token/tokenThunks";
+import { TokenRecord } from "ai/token/types";
+import { startOfDay, parseISO } from "date-fns";
+
+const ITEMS_PER_PAGE = 10;
+
+export interface RecordsFilter {
+  date: string; // 格式: YYYY-MM-DD
+  model: string;
+  currentPage: number;
+}
+
+interface UseRecordsReturn {
+  records: TokenRecord[];
+  loading: boolean;
+  totalCount: number; // 现在使用后端返回的总数
+}
+
+export const useRecords = (
+  userId: string,
+  filter: RecordsFilter
+): UseRecordsReturn => {
+  const dispatch = useAppDispatch();
+  const [records, setRecords] = useState<TokenRecord[]>([]);
+  const [totalCount, setTotalCount] = useState(0);
+  const [loading, setLoading] = useState(false);
+
+  const fetchRecords = useCallback(async () => {
+    try {
+      setLoading(true);
+      // 将日期字符串解析为UTC时间
+      const date = parseISO(filter.date);
+      // 获取UTC日期的开始时间
+      const startTime = startOfDay(date).getTime();
+
+      const result = await dispatch(queryUserTokensThunk({
+        userId,
+        startTime,
+        model: filter.model === "全部模型" ? undefined : filter.model,
+        offset: ITEMS_PER_PAGE * (filter.currentPage - 1),
+        pageSize: ITEMS_PER_PAGE,
+      })).unwrap();
+
+      setRecords(result.records);
+      setTotalCount(result.total);
+    } catch (err) {
+      // 移除日志记录
+    } finally {
+      setLoading(false);
+    }
+  }, [userId, filter, dispatch]);
+
+  useEffect(() => {
+    fetchRecords();
+  }, [fetchRecords]);
+
+  return {
+    records,
+    loading,
+    totalCount,
+  };
+};
+

package/ai/token/missingUsageEstimate.ts

@@ -0,0 +1,42 @@
+import type { RawUsage } from "./types";
+
+const APPROX_CHARS_PER_TOKEN = 4;
+
+const stringifyContent = (content: unknown): string => {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => {
+        if (typeof part === "string") return part;
+        if (part && typeof part === "object" && "text" in part) {
+          return String((part as any).text ?? "");
+        }
+        return "";
+      })
+      .join("\n");
+  }
+  if (content == null) return "";
+  return String(content);
+};
+
+export const estimateMissingUsage = ({
+  content,
+  minimumOutputTokens = 1,
+}: {
+  content: unknown;
+  minimumOutputTokens?: number;
+}): RawUsage => {
+  const text = stringifyContent(content);
+  const estimatedOutputTokens = Math.max(
+    minimumOutputTokens,
+    Math.ceil(text.length / APPROX_CHARS_PER_TOKEN)
+  );
+
+  return {
+    input_tokens: 1,
+    output_tokens: estimatedOutputTokens,
+    cache_creation_input_tokens: 0,
+    cache_read_input_tokens: 0,
+    billing_estimated: true,
+  };
+};

package/ai/token/modelUsageQuery.ts

@@ -0,0 +1,252 @@
+import { createKey, createTokenKey } from "database/keys";
+import { DataType } from "create/types";
+
+type UsageScope = "user" | "all" | "space";
+
+export type ModelUsageQueryParams = {
+  requestUserId: string;
+  isAdmin?: boolean;
+  scope?: UsageScope;
+  userId?: string;
+  spaceId?: string;
+  provider?: string;
+  model?: string;
+  serviceTier?: string;
+  startDate?: string;
+  endDate?: string;
+  currency?: string;
+  creditsPerUsd?: number;
+  thresholdCredits?: number;
+  thresholdUsd?: number;
+};
+
+type TokenRecordLike = {
+  type?: string;
+  userId?: string;
+  timestamp?: number;
+  createdAt?: number | string;
+  dateKey?: string;
+  provider?: string;
+  model?: string;
+  billing_service_tier?: string;
+  input_tokens?: number;
+  output_tokens?: number;
+  cache_creation_input_tokens?: number;
+  cache_read_input_tokens?: number;
+  cost?: number;
+};
+
+export type UsageBucket = {
+  count: number;
+  inputTokens: number;
+  outputTokens: number;
+  cacheCreationInputTokens: number;
+  cacheReadInputTokens: number;
+  costCredits: number;
+  costUsd: number;
+};
+
+export type ModelUsageQueryResult = {
+  scope: Exclude<UsageScope, "space">;
+  userId: string | null;
+  startDate: string;
+  endDate: string;
+  currency: string;
+  filters: {
+    provider: string | null;
+    model: string | null;
+    serviceTier: string | null;
+  };
+  total: UsageBucket;
+  providers: Record<string, UsageBucket>;
+  models: Record<string, UsageBucket>;
+  serviceTiers: Record<string, UsageBucket>;
+  threshold: {
+    costCredits: number | null;
+    costUsd: number | null;
+    exceeded: boolean;
+  };
+};
+
+const emptyBucket = (): UsageBucket => ({
+  count: 0,
+  inputTokens: 0,
+  outputTokens: 0,
+  cacheCreationInputTokens: 0,
+  cacheReadInputTokens: 0,
+  costCredits: 0,
+  costUsd: 0,
+});
+
+const toNumber = (value: unknown): number =>
+  typeof value === "number" && Number.isFinite(value) ? value : 0;
+
+const round6 = (value: number): number => Number(value.toFixed(6));
+
+const normalizeDateKey = (value: unknown): string | null => {
+  if (typeof value !== "string" || !value.trim()) return null;
+  const trimmed = value.trim();
+  if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) return trimmed;
+  const parsed = Date.parse(trimmed);
+  if (!Number.isFinite(parsed)) return null;
+  return new Date(parsed).toISOString().slice(0, 10);
+};
+
+const todayDateKey = (): string => new Date().toISOString().slice(0, 10);
+
+const recordDateKey = (record: TokenRecordLike): string | null => {
+  const explicit = normalizeDateKey(record.dateKey);
+  if (explicit) return explicit;
+  const timestamp = toNumber(record.timestamp);
+  if (timestamp > 0) return new Date(timestamp).toISOString().slice(0, 10);
+  if (typeof record.createdAt === "number" && record.createdAt > 0) {
+    return new Date(record.createdAt).toISOString().slice(0, 10);
+  }
+  return normalizeDateKey(record.createdAt);
+};
+
+const normalizeScope = (scope: unknown): UsageScope =>
+  scope === "all" || scope === "space" || scope === "user" ? scope : "user";
+
+const normalizeCreditsPerUsd = (value: unknown): number => {
+  const numeric = toNumber(value);
+  return numeric > 0 ? numeric : 8;
+};
+
+const addToBucket = (
+  bucket: UsageBucket,
+  record: TokenRecordLike,
+  creditsPerUsd: number,
+) => {
+  const costCredits = toNumber(record.cost);
+  bucket.count += 1;
+  bucket.inputTokens += toNumber(record.input_tokens);
+  bucket.outputTokens += toNumber(record.output_tokens);
+  bucket.cacheCreationInputTokens += toNumber(record.cache_creation_input_tokens);
+  bucket.cacheReadInputTokens += toNumber(record.cache_read_input_tokens);
+  bucket.costCredits = round6(bucket.costCredits + costCredits);
+  bucket.costUsd = round6(bucket.costCredits / creditsPerUsd);
+};
+
+const addNamedBucket = (
+  buckets: Record<string, UsageBucket>,
+  name: string | undefined,
+  record: TokenRecordLike,
+  creditsPerUsd: number,
+) => {
+  const key = typeof name === "string" && name.trim() ? name.trim() : "unknown";
+  buckets[key] ??= emptyBucket();
+  addToBucket(buckets[key], record, creditsPerUsd);
+};
+
+const tokenRecordRange = (scope: "user" | "all", userId: string | null) => {
+  if (scope === "user" && userId) {
+    const { start, end } = createTokenKey.rangeOfUser(userId);
+    return { gte: start, lte: end };
+  }
+  return { gte: createKey("token", ""), lte: createKey("token", "\uffff") };
+};
+
+const isTokenRecordKey = (key: string): boolean =>
+  key.startsWith(createKey("token", "")) &&
+  !key.startsWith(createKey("token", "stats", ""));
+
+const matchesFilter = (
+  record: TokenRecordLike,
+  params: ModelUsageQueryParams,
+  startDate: string,
+  endDate: string,
+): boolean => {
+  if (record.type !== DataType.TOKEN) return false;
+  const dateKey = recordDateKey(record);
+  if (!dateKey || dateKey < startDate || dateKey > endDate) return false;
+  if (params.provider && record.provider !== params.provider) return false;
+  if (params.model && record.model !== params.model) return false;
+  if (params.serviceTier && record.billing_service_tier !== params.serviceTier) {
+    return false;
+  }
+  return true;
+};
+
+export async function queryModelUsage(
+  db: any,
+  params: ModelUsageQueryParams,
+): Promise<ModelUsageQueryResult> {
+  const requestUserId = params.requestUserId?.trim();
+  if (!requestUserId) {
+    throw new Error("MODEL_USAGE_FORBIDDEN: missing request user");
+  }
+
+  const scope = normalizeScope(params.scope);
+  if (scope === "space") {
+    // TODO(space): implement usage ownership by space once token records reliably carry spaceId.
+    throw new Error("MODEL_USAGE_SPACE_SCOPE_TODO");
+  }
+
+  if (scope === "all" && !params.isAdmin) {
+    throw new Error("MODEL_USAGE_FORBIDDEN: all-site usage requires admin");
+  }
+
+  const targetUserId = scope === "all" ? null : (params.userId || requestUserId).trim();
+  if (targetUserId && targetUserId !== requestUserId && !params.isAdmin) {
+    throw new Error("MODEL_USAGE_FORBIDDEN: cannot query another user");
+  }
+
+  const startDate = normalizeDateKey(params.startDate) ?? todayDateKey();
+  const endDate = normalizeDateKey(params.endDate) ?? startDate;
+  const creditsPerUsd = normalizeCreditsPerUsd(params.creditsPerUsd);
+  const currency = typeof params.currency === "string" && params.currency.trim()
+    ? params.currency.trim().toUpperCase()
+    : "CREDITS";
+
+  const total = emptyBucket();
+  const providers: Record<string, UsageBucket> = {};
+  const models: Record<string, UsageBucket> = {};
+  const serviceTiers: Record<string, UsageBucket> = {};
+  const range = tokenRecordRange(scope, targetUserId);
+
+  for await (const [key, value] of db.iterator(range)) {
+    if (typeof key !== "string" || !isTokenRecordKey(key)) continue;
+    const record = value as TokenRecordLike;
+    if (!matchesFilter(record, params, startDate, endDate)) continue;
+    addToBucket(total, record, creditsPerUsd);
+    addNamedBucket(providers, record.provider, record, creditsPerUsd);
+    addNamedBucket(models, record.model, record, creditsPerUsd);
+    addNamedBucket(serviceTiers, record.billing_service_tier, record, creditsPerUsd);
+  }
+
+  const thresholdCredits =
+    typeof params.thresholdCredits === "number" && Number.isFinite(params.thresholdCredits)
+      ? params.thresholdCredits
+      : typeof params.thresholdUsd === "number" && Number.isFinite(params.thresholdUsd)
+        ? round6(params.thresholdUsd * creditsPerUsd)
+        : null;
+  const thresholdUsd =
+    typeof params.thresholdUsd === "number" && Number.isFinite(params.thresholdUsd)
+      ? params.thresholdUsd
+      : thresholdCredits == null
+        ? null
+        : round6(thresholdCredits / creditsPerUsd);
+
+  return {
+    scope,
+    userId: targetUserId,
+    startDate,
+    endDate,
+    currency,
+    filters: {
+      provider: params.provider ?? null,
+      model: params.model ?? null,
+      serviceTier: params.serviceTier ?? null,
+    },
+    total,
+    providers,
+    models,
+    serviceTiers,
+    threshold: {
+      costCredits: thresholdCredits,
+      costUsd: thresholdUsd,
+      exceeded: thresholdCredits == null ? false : total.costCredits > thresholdCredits,
+    },
+  };
+}