nolo-cli 0.1.39 → 0.1.41

package/ai/token/normalizeUsage.ts

@@ -0,0 +1,124 @@
+// 文件路径: ai/token/normalizeUsage.ts
+
+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 数据
+ */
+export const normalizeUsage = (usage: RawUsage): NormalizedUsage => {
+  const inputTokens =
+    "input_tokens" in usage
+      ? usage.input_tokens
+      : "prompt_tokens" in usage
+        ? usage.prompt_tokens
+        : 0;
+
+  const outputTokens =
+    "output_tokens" in usage
+      ? usage.output_tokens
+      : "completion_tokens" in usage
+        ? usage.completion_tokens
+        : 0;
+
+  const cacheCreationInputTokens =
+    "cache_creation_input_tokens" in usage
+      ? usage.cache_creation_input_tokens
+      : "prompt_cache_miss_tokens" in usage
+        ? usage.prompt_cache_miss_tokens
+        : 0;
+
+  const cacheReadInputTokens =
+    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 的账单单位再做换算。
+  let cost = 0;
+  if ("cost" in usage && typeof (usage as any).cost === "number") {
+    cost = (usage as any).cost;
+  }
+
+  const billingProvider =
+    "billing_provider" in usage && typeof usage.billing_provider === "string"
+      ? usage.billing_provider.trim() || undefined
+      : undefined;
+
+  const billingModel =
+    "billing_model" in usage && typeof usage.billing_model === "string"
+      ? usage.billing_model.trim() || undefined
+      : undefined;
+
+  const billingServiceTier =
+    "billing_service_tier" in usage &&
+    typeof usage.billing_service_tier === "string"
+      ? usage.billing_service_tier.trim() || undefined
+      : undefined;
+  const billingEstimated =
+    "billing_estimated" in usage && usage.billing_estimated === true;
+  const imageGenerationCount =
+    "image_generation_count" in usage &&
+    typeof usage.image_generation_count === "number" &&
+    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,
+    output_tokens: outputTokens,
+    cache_creation_input_tokens: cacheCreationInputTokens,
+    cache_read_input_tokens: cacheReadInputTokens,
+    cost,
+    ...(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
+      ? { billing_service_tier: billingServiceTier }
+      : {}),
+    ...(billingEstimated ? { billing_estimated: true } : {}),
+  };
+};

package/ai/token/openaiImageGenerationUsage.ts

@@ -0,0 +1,56 @@
+import { getModelInfo } from "../llm/getModelContextWindow";
+import { countImageParts } from "../../chat/messages/messageContract";
+
+type AgentLike = {
+  provider?: string | null;
+  model?: string | null;
+  imageConfig?: { enabled?: boolean } | null;
+};
+
+type UsageLike = Record<string, any> | null | undefined;
+
+type TraceMessageLike = {
+  role?: string;
+  content?: string | any[] | null;
+};
+
+export const isOpenAIBuiltInImageGenerationAgent = (
+  agentConfig: AgentLike | null | undefined
+): boolean =>
+  String(agentConfig?.provider || "").toLowerCase() === "openai" &&
+  !getModelInfo(String(agentConfig?.model || ""))?.hasImageOutput &&
+  !!agentConfig?.imageConfig?.enabled;
+
+export const withImageGenerationCount = <T extends UsageLike>(
+  usage: T,
+  imageGenerationCount: number
+): T => {
+  if (!usage || !Number.isFinite(imageGenerationCount) || imageGenerationCount <= 0) {
+    return usage;
+  }
+
+  const existingCount =
+    typeof usage.image_generation_count === "number" &&
+    Number.isFinite(usage.image_generation_count)
+      ? usage.image_generation_count
+      : 0;
+
+  return {
+    ...usage,
+    image_generation_count: Math.max(existingCount, imageGenerationCount),
+  };
+};
+
+export const countAssistantImageGenerationOutputs = (
+  trace: TraceMessageLike[] | null | undefined
+): number => {
+  if (!Array.isArray(trace)) return 0;
+  return trace.reduce((total, message) => {
+    if (message?.role !== "assistant") return total;
+    return total + countImageParts(message.content ?? null);
+  }, 0);
+};
+
+export const countImageGenerationOutputsInContent = (
+  content: string | any[] | null | undefined
+): number => countImageParts(content);

package/ai/token/prepareTokenUsageData.ts

@@ -0,0 +1,93 @@
+import { extractUserId } from "../../core/prefix";
+import { calculatePrice } from "./calculatePrice";
+import { normalizeUsage } from "./normalizeUsage";
+import { resolveBillingTarget } from "./resolveBillingTarget";
+import type { RawUsage, TokenUsageData } from "./types";
+
+type SharingLevel = "default" | "split" | "full";
+
+interface BillingAgentConfig {
+  model: string;
+  provider?: string;
+  apiSource?: string;
+  inputPrice?: number;
+  outputPrice?: number;
+  sharingLevel?: SharingLevel;
+  id?: string;
+  userId?: string;
+}
+
+interface PrepareTokenUsageDataParams {
+  rawUsage: RawUsage;
+  agentConfig: BillingAgentConfig;
+  userId?: string;
+  username?: string;
+  cybotId: string;
+  dialogId: string;
+  timestamp?: number;
+}
+
+export interface PreparedTokenUsageData {
+  usage: ReturnType<typeof normalizeUsage>;
+  billedProvider?: string;
+  billedModel: string;
+  billedServiceTier?: string;
+  recordProvider: string;
+  tokenData: TokenUsageData;
+}
+
+export const prepareTokenUsageData = ({
+  rawUsage,
+  agentConfig,
+  userId,
+  username,
+  cybotId,
+  dialogId,
+  timestamp = Date.now(),
+}: PrepareTokenUsageDataParams): PreparedTokenUsageData => {
+  const usage = normalizeUsage(rawUsage);
+  const billingTarget = resolveBillingTarget({
+    usage,
+    fallbackProvider: agentConfig.provider,
+    fallbackModel: agentConfig.model,
+  });
+  const billedProvider = billingTarget.provider;
+  const billedModel = billingTarget.model;
+  const billedServiceTier = billingTarget.serviceTier;
+  const recordProvider = billedProvider ?? agentConfig.provider ?? "unknown";
+  const { cost, pay } = calculatePrice({
+    provider: billedProvider,
+    modelName: billedModel,
+    billingServiceTier: billedServiceTier,
+    usage,
+    externalPrice: agentConfig.id
+      ? {
+          input: agentConfig.inputPrice ?? 0,
+          output: agentConfig.outputPrice ?? 0,
+          creatorId: agentConfig.userId ?? extractUserId(agentConfig.id),
+        }
+      : undefined,
+    sharingLevel: agentConfig.sharingLevel,
+  });
+
+  return {
+    usage,
+    billedProvider,
+    billedModel,
+    billedServiceTier,
+    recordProvider,
+    tokenData: {
+      ...usage,
+      userId,
+      username,
+      cybotId,
+      model: billedModel,
+      provider: recordProvider,
+      billing_service_tier: billedServiceTier,
+      dialogId,
+      cost,
+      pay,
+      timestamp,
+    },
+  };
+};

package/ai/token/resolveBillingTarget.ts

@@ -0,0 +1,52 @@
+import { resolveOpenAIServiceTier } from "../../integrations/openai/flexTier";
+import type { NormalizedUsage, RawUsage } from "./types";
+
+type BillingUsage = Pick<
+  RawUsage | NormalizedUsage,
+  "billing_provider" | "billing_model" | "billing_service_tier"
+>;
+
+const normalizeString = (value?: string) => {
+  const trimmed = typeof value === "string" ? value.trim() : "";
+  return trimmed || undefined;
+};
+
+const resolveBillingModel = (
+  usageModel?: string,
+  fallbackModel?: string
+) => {
+  const model = normalizeString(usageModel) ?? normalizeString(fallbackModel);
+  if (!model) {
+    throw new Error("Billing model is required");
+  }
+  return model;
+};
+
+export const resolveBillingTarget = ({
+  usage,
+  fallbackProvider,
+  fallbackModel,
+}: {
+  usage?: BillingUsage | null;
+  fallbackProvider?: string;
+  fallbackModel: string;
+}) => {
+  const provider =
+    normalizeString(usage?.billing_provider) ?? normalizeString(fallbackProvider);
+  const model = resolveBillingModel(usage?.billing_model, fallbackModel);
+  const requestedServiceTier = normalizeString(usage?.billing_service_tier);
+  const serviceTier =
+    provider === "google"
+      ? requestedServiceTier
+      : resolveOpenAIServiceTier({
+          providerName: provider,
+          model,
+          requestedServiceTier,
+        });
+
+  return {
+    provider,
+    model,
+    serviceTier,
+  };
+};

package/ai/token/saveTokenRecord.ts

@@ -0,0 +1,53 @@
+import { TokenUsageData, TokenRecord } from "../token/types";
+import { DataType } from "../../create/types";
+import { createTokenKey } from "../../database/keys";
+import { write } from "../../database/dbSlice";
+import { toast } from "../../app/utils/toast";
+import { pino } from "pino";
+
+const logger = pino({ name: "token-record", level: "info" });
+
+type TokenCount = { input: number; output: number };
+
+export interface ModelStats {
+  count: number;
+  tokens: TokenCount;
+  cost: number;
+}
+
+export const createTokenRecord = (
+  data: TokenUsageData,
+  { cost, inputPrice, outputPrice }: Partial<TokenRecord> = {}
+): TokenRecord => ({
+  ...data,
+  cost: cost || data.cost,
+  inputPrice,
+  outputPrice,
+});
+
+export const saveTokenRecord = async (
+  tokenData: TokenUsageData,
+  record: TokenRecord,
+  thunkApi
+) => {
+  const key = createTokenKey.record(tokenData.userId, tokenData.timestamp);
+  try {
+    await thunkApi.dispatch(
+      write({
+        data: { ...record, id: key, type: DataType.TOKEN },
+        customKey: key,
+      })
+    );
+  } catch (error) {
+    logger.error(
+      {
+        key,
+        userId: tokenData.userId,
+        error: error.message,
+      },
+      "Failed to save token record"
+    );
+    toast.error("Failed to save token record");
+    throw error;
+  }
+};

package/ai/token/types.ts

@@ -0,0 +1,103 @@
+// ai/token/types.ts
+
+export const DEFAULT_QUERY_LIMIT = 100;
+
+export const TOKEN_PERIODS = {
+  DAY: "day",
+  WEEK: "week",
+  MONTH: "month",
+} as const;
+
+export const TOKEN_SCOPES = {
+  USER: "user",
+  CYBOT: "cybot",
+  SITE: "site",
+} as const;
+
+interface BillingUsageMetadata {
+  cost?: number;
+  billing_provider?: string;
+  billing_model?: string;
+  billing_service_tier?: string;
+  billing_estimated?: boolean;
+  image_generation_count?: number;
+  provider_response_ids?: string[];
+  provider_request_ids?: string[];
+}
+
+// 原始用量类型
+export interface RawUsageType1 extends BillingUsageMetadata {
+  output_tokens?: number;
+  input_tokens?: number;
+  cache_creation_input_tokens?: number;
+  cache_read_input_tokens?: number;
+  input_tokens_details?: {
+    cached_tokens?: number;
+  };
+}
+
+export interface RawUsageType2 extends BillingUsageMetadata {
+  prompt_tokens: number;
+  completion_tokens: number;
+  total_tokens: number;
+  prompt_cache_hit_tokens: number;
+  prompt_cache_miss_tokens: number;
+  prompt_tokens_details?: {
+    cached_tokens?: number;
+  };
+}
+
+export type RawUsage = RawUsageType1 | RawUsageType2;
+
+// 标准化后的用量数据
+export interface NormalizedUsage extends BillingUsageMetadata {
+  input_tokens: number;
+  output_tokens: number;
+  cache_creation_input_tokens: number;
+  cache_read_input_tokens: number;
+  cost: number;
+}
+
+// Token使用数据
+export interface TokenUsageData extends NormalizedUsage {
+  userId?: string;
+  cybotId: string;
+  model: string;
+  provider: string;
+  dialogId: string;
+  pay: any; // TODO: 明确支付数据类型
+}
+
+// Token记录
+export interface TokenRecord {
+  id: string;
+  userId: string;
+  username: string;
+  cybotId: string;
+  model: string;
+  provider: string;
+  dialogId: string;
+  cache_creation_input_tokens: number;
+  cache_read_input_tokens: number;
+  output_tokens: number;
+  input_tokens: number;
+  cost: number;
+  image_generation_count?: number;
+  provider_response_ids?: string[];
+  provider_request_ids?: string[];
+  pay: any;
+  createdAt: number; // UTC timestamp
+  type: string;
+}
+
+// Token统计数据
+export interface TokenStats {
+  total: number;
+  date: string; // YYYY-MM-DD in UTC
+  inputTokens: number;
+  outputTokens: number;
+  cost: number;
+  userId: string;
+  createdAt: number; // UTC timestamp
+  type: string;
+}