@lobehub/chat 1.133.1 → 1.133.3

package/packages/model-runtime/src/core/usageConverters/utils/computeChatCost.ts

@@ -0,0 +1,293 @@
+/* eslint-disable sort-keys-fix/sort-keys-fix */
+import { CREDITS_PER_DOLLAR } from '@lobechat/const/currency';
+import debug from 'debug';
+import {
+  FixedPricingUnit,
+  LookupPricingUnit,
+  Pricing,
+  PricingUnit,
+  PricingUnitName,
+  TieredPricingUnit,
+} from 'model-bank';
+
+import { ModelTokensUsage } from '@/types/message';
+
+const log = debug('lobe-cost:computeChatPricing');
+
+export interface PricingUnitBreakdown {
+  cost: number;
+  credits: number;
+  /**
+   * For lookup strategies we expose the resolved key.
+   */
+  lookupKey?: string;
+  quantity: number;
+  /**
+   * Extra details for tiered strategies to help consumers render ladders.
+   */
+  segments?: Array<{ credits: number; quantity: number; rate: number }>;
+  unit: PricingUnit;
+}
+
+export interface PricingComputationIssue {
+  reason: string;
+  unit: PricingUnit;
+}
+
+export interface ComputeChatCostOptions {
+  /**
+   * Input parameters used by lookup strategies (e.g. ttl, thinkingMode).
+   */
+  lookupParams?: Record<string, string | number | boolean>;
+}
+
+export interface PricingComputationResult {
+  breakdown: PricingUnitBreakdown[];
+  issues: PricingComputationIssue[];
+  totalCost: number;
+  totalCredits: number;
+}
+
+type UnitQuantityResolver = (usage: ModelTokensUsage) => number | undefined;
+
+const UNIT_QUANTITY_RESOLVERS: Partial<Record<PricingUnitName, UnitQuantityResolver>> = {
+  textInput: (usage) => {
+    if (usage.inputCacheMissTokens !== undefined) {
+      return usage.inputCacheMissTokens;
+    }
+
+    if (typeof usage.inputCachedTokens === 'number' && typeof usage.totalInputTokens === 'number') {
+      throw new Error(
+        'Missing inputCacheMissTokens! You can set it by inputCacheMissTokens = totalInputTokens - inputCachedTokens',
+      );
+    }
+
+    return usage.inputTextTokens ?? usage.totalInputTokens;
+  },
+  textInput_cacheRead: (usage) => usage.inputCachedTokens,
+  textInput_cacheWrite: (usage) => usage.inputWriteCacheTokens,
+  // reasoning tokens cost within output tokens
+  textOutput: (usage) => {
+    const { outputTextTokens, totalOutputTokens, outputReasoningTokens = 0 } = usage;
+    const reasoningTokens = outputReasoningTokens;
+
+    if (typeof outputTextTokens === 'number') {
+      return outputTextTokens + reasoningTokens;
+    }
+
+    if (typeof totalOutputTokens === 'number') {
+      return totalOutputTokens;
+    }
+
+    if (typeof usage.outputReasoningTokens === 'number') {
+      return usage.outputReasoningTokens;
+    }
+
+    return undefined;
+  },
+
+  imageInput: (usage) => usage.inputImageTokens,
+  imageInput_cacheRead: () => undefined,
+  imageOutput: (usage) => usage.outputImageTokens,
+
+  imageGeneration: () => undefined,
+
+  audioInput: (usage) => usage.inputAudioTokens,
+  // TODO: Support this when ModelTokensUsage includes this data
+  audioInput_cacheRead: () => undefined,
+  audioOutput: (usage) => usage.outputAudioTokens,
+};
+
+const creditsToUSD = (credits: number) => credits / CREDITS_PER_DOLLAR;
+
+/**
+ * Returns raw credits, which will be rounded up uniformly at the final aggregation stage.
+ */
+const computeFixedCredits = (unit: FixedPricingUnit, quantity: number) => quantity * unit.rate;
+
+/**
+ * Google provider uses new pricing for entire input and output when exceeding threshold, not tiered calculation
+ * TODO: Some providers do use tiered calculation, such as Zhipu
+ */
+const computeTieredCredits = (
+  unit: TieredPricingUnit,
+  quantity: number,
+): { credits: number; segments: Array<{ credits: number; quantity: number; rate: number }> } => {
+  if (quantity <= 0) return { credits: 0, segments: [] };
+
+  const segments: Array<{ credits: number; quantity: number; rate: number }> = [];
+  const tiers = unit.tiers ?? [];
+  if (tiers.length === 0) return { credits: 0, segments };
+
+  // Google and other providers charge the entire quantity at the new rate when exceeding threshold
+  const matchedTier =
+    tiers.find((tier) => {
+      const limit = tier.upTo === 'infinity' ? Number.POSITIVE_INFINITY : tier.upTo;
+      return quantity <= limit;
+    }) ?? tiers.at(-1);
+
+  if (!matchedTier) return { credits: 0, segments };
+
+  const credits = quantity * matchedTier.rate;
+  segments.push({ credits, quantity, rate: matchedTier.rate });
+
+  return { credits, segments };
+};
+
+const resolveLookupKey = (
+  unit: LookupPricingUnit,
+  options: ComputeChatCostOptions | undefined,
+): { key?: string; missingParams?: string[] } => {
+  if (!unit.lookup?.pricingParams?.length) return { key: undefined };
+
+  const missingParams: string[] = [];
+  const params = unit.lookup.pricingParams.map((param) => {
+    const source = options?.lookupParams?.[param];
+    if (source === undefined || source === null) {
+      missingParams.push(param);
+      return 'undefined';
+    }
+
+    if (typeof source === 'boolean') return String(source);
+    return String(source);
+  });
+
+  if (missingParams.length > 0) return { key: undefined, missingParams };
+
+  return { key: params.join('_') };
+};
+
+const computeLookupCredits = (
+  unit: LookupPricingUnit,
+  quantity: number,
+  options: ComputeChatCostOptions | undefined,
+): { credits: number; issues?: PricingComputationIssue; key?: string } => {
+  const { key, missingParams } = resolveLookupKey(unit, options);
+
+  if (missingParams && missingParams.length > 0) {
+    return {
+      credits: 0,
+      issues: {
+        reason: `Missing lookup params: ${missingParams.join(', ')}`,
+        unit,
+      },
+    };
+  }
+
+  if (!key) {
+    return {
+      credits: 0,
+      issues: {
+        reason: 'Lookup key could not be resolved',
+        unit,
+      },
+    };
+  }
+
+  const lookupRate = unit.lookup.prices?.[key];
+  if (typeof lookupRate !== 'number') {
+    return {
+      credits: 0,
+      issues: {
+        reason: `Lookup price not found for key "${key}"`,
+        unit,
+      },
+      key,
+    };
+  }
+
+  return {
+    credits: quantity * lookupRate,
+    key,
+  };
+};
+
+const resolveQuantity = (unit: PricingUnit, usage: ModelTokensUsage) => {
+  const resolver = UNIT_QUANTITY_RESOLVERS[unit.name as PricingUnitName];
+  const quantity = resolver?.(usage);
+  return typeof quantity === 'number' ? quantity : undefined;
+};
+
+/**
+ * 1. Keep raw credits for each item (may be decimal)
+ * 2. Round up uniformly at the totals stage to prevent cost undercounting
+ */
+export const computeChatCost = (
+  pricing: Pricing | undefined,
+  usage: ModelTokensUsage,
+  options?: ComputeChatCostOptions,
+): PricingComputationResult | undefined => {
+  if (!pricing) return undefined;
+
+  const breakdown: PricingUnitBreakdown[] = [];
+  const issues: PricingComputationIssue[] = [];
+
+  for (const unit of pricing.units) {
+    const quantity = resolveQuantity(unit, usage);
+    if (quantity === undefined) continue;
+
+    if (unit.strategy === 'fixed') {
+      if (unit.unit !== 'millionTokens')
+        throw new Error(`Unsupported chat pricing unit: ${unit.unit}`);
+
+      const fixedUnit = unit as FixedPricingUnit;
+      const credits = computeFixedCredits(fixedUnit, quantity);
+      breakdown.push({
+        cost: creditsToUSD(credits),
+        credits,
+        quantity,
+        unit,
+      });
+      continue;
+    }
+
+    if (unit.strategy === 'tiered') {
+      const tieredUnit = unit as TieredPricingUnit;
+      const { credits, segments } = computeTieredCredits(tieredUnit, quantity);
+      breakdown.push({
+        cost: creditsToUSD(credits),
+        credits,
+        quantity,
+        segments,
+        unit,
+      });
+      continue;
+    }
+
+    if (unit.strategy === 'lookup') {
+      const lookupUnit = unit as LookupPricingUnit;
+      const {
+        credits,
+        key,
+        issues: lookupIssue,
+      } = computeLookupCredits(lookupUnit, quantity, options);
+
+      if (lookupIssue) issues.push(lookupIssue);
+
+      breakdown.push({
+        cost: creditsToUSD(credits),
+        credits,
+        lookupKey: key,
+        quantity,
+        unit,
+      });
+      continue;
+    }
+
+    issues.push({ reason: 'Unsupported pricing strategy', unit });
+  }
+
+  const rawTotalCredits = breakdown.reduce((sum, item) => sum + item.credits, 0);
+  const totalCredits = Math.ceil(rawTotalCredits);
+  // !: totalCredits has been uniformly rounded up to integer credits, divided by CREDITS_PER_DOLLAR naturally retains only 6 decimal places, no additional processing needed
+  const totalCost = creditsToUSD(totalCredits);
+
+  log(`computeChatPricing breakdown: ${JSON.stringify(breakdown, null, 2)}`);
+
+  return {
+    breakdown,
+    issues,
+    totalCost,
+    totalCredits,
+  };
+};

package/packages/model-runtime/src/core/usageConverters/utils/computeImageCost.test.ts

@@ -0,0 +1,47 @@
+import type { Pricing } from 'model-bank';
+import { describe, expect, it } from 'vitest';
+
+import { ImageGenerationParams, computeImageCost } from './computeImageCost';
+
+describe('computeImageCost', () => {
+  it('should compute dall-e-3 lookup pricing correctly', () => {
+    // Arrange - Based on actual production logs
+    const pricing: Pricing = {
+      units: [
+        {
+          name: 'imageGeneration',
+          strategy: 'lookup',
+          unit: 'image',
+          lookup: {
+            pricingParams: ['quality', 'size'],
+            prices: {
+              standard_1024x1024: 0.04,
+              standard_1024x1792: 0.08,
+              standard_1792x1024: 0.08,
+              hd_1024x1024: 0.08,
+              hd_1024x1792: 0.12,
+              hd_1792x1024: 0.12,
+            },
+          },
+        },
+      ],
+    };
+
+    const params: ImageGenerationParams = {
+      quality: 'standard',
+      size: '1024x1024',
+      prompt: '一条边牧',
+    };
+
+    // Act
+    const result = computeImageCost(pricing, params, 1);
+
+    // Assert - Match the production log output
+    expect(result).toBeDefined();
+    expect(result?.totalCost).toBe(0.04);
+    expect(result?.totalCredits).toBe(40000); // $0.04 * 100000 credits per dollar
+    expect(result?.breakdown?.lookupKey).toBe('standard_1024x1024');
+    expect(result?.breakdown?.pricePerImage).toBe(0.04);
+    expect(result?.breakdown?.imageCount).toBe(1);
+  });
+});

package/packages/model-runtime/src/core/usageConverters/utils/computeImageCost.ts

@@ -0,0 +1,121 @@
+import { CREDITS_PER_DOLLAR } from '@lobechat/const/currency';
+import debug from 'debug';
+import { FixedPricingUnit, LookupPricingUnit, Pricing } from 'model-bank';
+
+const log = debug('lobe-cost:computeImagePricing');
+
+export interface ImageGenerationParams {
+  // Other possible parameters for future extensions
+  [key: string]: any;
+  quality?: 'standard' | 'hd';
+  size?: string;
+}
+
+export interface ImageCostResult {
+  breakdown?: {
+    imageCount: number;
+    lookupKey?: string;
+    pricePerImage: number; // Price per image in USD
+  };
+  totalCost: number; // Total cost in USD
+  totalCredits: number; // Total credits (USD * CREDITS_PER_DOLLAR)
+}
+
+/**
+ * Compute the cost for image generation based on pricing configuration
+ * @param pricing - The pricing configuration for the model
+ * @param params - Image generation parameters (quality, size, etc.)
+ * @param imageNum - Number of images to generate
+ * @returns ImageCostResult with total cost in USD and credits, or undefined if pricing not found
+ */
+export const computeImageCost = (
+  pricing: Pricing,
+  params: ImageGenerationParams,
+  imageNum: number,
+): ImageCostResult | undefined => {
+  // Find imageGeneration pricing unit
+  const imageGenUnit = pricing.units.find((unit) => unit.name === 'imageGeneration');
+  if (!imageGenUnit) {
+    log('No imageGeneration unit found in pricing configuration');
+    return undefined;
+  }
+
+  let pricePerImageInUSD = 0;
+  let lookupKey: string | undefined;
+
+  switch (imageGenUnit.strategy) {
+    case 'fixed': {
+      const fixedUnit = imageGenUnit as FixedPricingUnit;
+      if (fixedUnit.unit !== 'image') {
+        log(`Unsupported unit type for fixed pricing: ${fixedUnit.unit}`);
+        return undefined;
+      }
+      pricePerImageInUSD = fixedUnit.rate;
+      log(`Fixed pricing: $${pricePerImageInUSD} per image`);
+
+      break;
+    }
+    case 'lookup': {
+      const lookupUnit = imageGenUnit as LookupPricingUnit;
+
+      // Build lookup key from params
+      const lookupParams: string[] = [];
+
+      // Check required pricing params
+      if (lookupUnit.lookup?.pricingParams) {
+        for (const paramName of lookupUnit.lookup.pricingParams) {
+          const paramValue = params[paramName];
+          if (paramValue === undefined || paramValue === null) {
+            log(`Missing required lookup param: ${paramName}`);
+            return undefined;
+          }
+          lookupParams.push(String(paramValue));
+        }
+        lookupKey = lookupParams.join('_');
+      } else {
+        log('No pricing params defined for lookup strategy');
+        return undefined;
+      }
+
+      // Find price for the lookup key
+      const lookupPrice = lookupUnit.lookup?.prices?.[lookupKey];
+      if (typeof lookupPrice !== 'number') {
+        log(`No price found for lookup key: ${lookupKey}`);
+        return undefined;
+      }
+
+      pricePerImageInUSD = lookupPrice;
+      log(`Lookup pricing for key "${lookupKey}": $${pricePerImageInUSD} per image`);
+
+      break;
+    }
+    case 'tiered': {
+      // TODO: Implement tiered pricing when needed
+      log('Tiered pricing strategy not yet implemented for image generation');
+      return undefined;
+    }
+    default: {
+      // @ts-expect-error - PricingUnit strategy may have unsupported values
+      log(`Unsupported pricing strategy: ${imageGenUnit.strategy}`);
+      return undefined;
+    }
+  }
+
+  // Calculate total cost in USD first, then convert to credits
+  const totalCost = pricePerImageInUSD * imageNum;
+  const totalCredits = Math.ceil(totalCost * CREDITS_PER_DOLLAR);
+
+  log(
+    `Image cost calculation: ${imageNum} images × $${pricePerImageInUSD} = $${totalCost} (${totalCredits} credits)`,
+  );
+
+  return {
+    breakdown: {
+      imageCount: imageNum,
+      lookupKey,
+      pricePerImage: pricePerImageInUSD,
+    },
+    totalCost,
+    totalCredits,
+  };
+};

package/packages/model-runtime/src/core/usageConverters/utils/index.ts

@@ -0,0 +1,11 @@
+export {
+  computeChatCost,
+  type ComputeChatCostOptions,
+  type PricingComputationResult,
+} from './computeChatCost';
+export {
+  computeImageCost,
+  type ImageCostResult,
+  type ImageGenerationParams,
+} from './computeImageCost';
+export { withUsageCost } from './withUsageCost';

package/packages/model-runtime/src/core/usageConverters/utils/withUsageCost.ts

@@ -0,0 +1,19 @@
+import type { Pricing } from 'model-bank';
+
+import type { ModelUsage } from '@/types/message';
+
+import { computeChatCost } from './computeChatCost';
+import type { ComputeChatCostOptions } from './computeChatCost';
+
+export const withUsageCost = (
+  usage: ModelUsage,
+  pricing?: Pricing,
+  options?: ComputeChatCostOptions,
+): ModelUsage => {
+  if (!pricing) return usage;
+
+  const pricingResult = computeChatCost(pricing, usage, options);
+  if (!pricingResult) return usage;
+
+  return { ...usage, cost: pricingResult.totalCost };
+};

package/packages/model-runtime/src/index.ts

@@ -2,6 +2,7 @@ export * from './core/BaseAI';
 export { ModelRuntime } from './core/ModelRuntime';
 export { createOpenAICompatibleRuntime } from './core/openaiCompatibleFactory';
 export * from './core/RouterRuntime';
+export * from './core/usageConverters';
 export * from './helpers';
 export { LobeAkashChatAI } from './providers/akashchat';
 export { LobeAnthropicAI } from './providers/anthropic';
@@ -33,5 +34,6 @@ export * from './types';
 export * from './types/error';
 export { AgentRuntimeError } from './utils/createError';
 export { getModelPropertyWithFallback } from './utils/getFallbackModelProperty';
+export { getModelPricing } from './utils/getModelPricing';
 export { pruneReasoningPayload } from './utils/openaiHelpers';
 export { parseDataUri } from './utils/uriParser';

package/packages/model-runtime/src/providers/anthropic/index.ts

@@ -15,6 +15,7 @@ import { buildAnthropicMessages, buildAnthropicTools } from '../../utils/anthrop
 import { AgentRuntimeError } from '../../utils/createError';
 import { debugStream } from '../../utils/debugStream';
 import { desensitizeUrl } from '../../utils/desensitizeUrl';
+import { getModelPricing } from '../../utils/getModelPricing';
 import { MODEL_LIST_CONFIGS, processModelList } from '../../utils/modelParse';
 import { StreamingResponse } from '../../utils/response';
 import { createAnthropicGenerateObject } from './generateObject';
@@ -38,6 +39,44 @@ const modelsWithTempAndTopPConflict = new Set([
 ]);
 
 const DEFAULT_BASE_URL = 'https://api.anthropic.com';
+const DEFAULT_CACHE_TTL = '5m' as const;
+
+type CacheTTL = Anthropic.Messages.CacheControlEphemeral['ttl'];
+
+/**
+ * Resolves cache TTL from Anthropic payload or request settings
+ * Returns the first valid TTL found in system messages or content blocks
+ */
+const resolveCacheTTL = (
+  requestPayload: ChatStreamPayload,
+  anthropicPayload: Anthropic.MessageCreateParams,
+): CacheTTL | undefined => {
+  // Check system messages for cache TTL
+  if (Array.isArray(anthropicPayload.system)) {
+    for (const block of anthropicPayload.system) {
+      const ttl = block.cache_control?.ttl;
+      if (ttl) return ttl;
+    }
+  }
+
+  // Check message content blocks for cache TTL
+  for (const message of anthropicPayload.messages ?? []) {
+    if (!Array.isArray(message.content)) continue;
+
+    for (const block of message.content) {
+      // Message content blocks might have cache_control property
+      const ttl = ('cache_control' in block && block.cache_control?.ttl) as CacheTTL | undefined;
+      if (ttl) return ttl;
+    }
+  }
+
+  // Use default TTL if context caching is enabled
+  if (requestPayload.enabledContextCaching) {
+    return DEFAULT_CACHE_TTL;
+  }
+
+  return undefined;
+};
 
 interface AnthropicAIParams extends ClientOptions {
   id?: string;
@@ -103,8 +142,16 @@ export class LobeAnthropicAI implements LobeRuntimeAI {
         debugStream(debug.toReadableStream()).catch(console.error);
       }
 
+      const pricing = await getModelPricing(payload.model, this.id);
+      const cacheTTL = resolveCacheTTL(payload, anthropicPayload);
+      const pricingOptions = cacheTTL ? { lookupParams: { ttl: cacheTTL } } : undefined;
+
       return StreamingResponse(
-        AnthropicStream(prod, { callbacks: options?.callback, inputStartAt }),
+        AnthropicStream(prod, {
+          callbacks: options?.callback,
+          inputStartAt,
+          payload: { model: payload.model, pricing, pricingOptions, provider: this.id },
+        }),
         {
           headers: options?.headers,
         },

package/packages/model-runtime/src/providers/google/createImage.ts

@@ -1,7 +1,9 @@
 import { Content, GoogleGenAI, Part } from '@google/genai';
 
+import { convertGoogleAIUsage } from '../../core/usageConverters/google-ai';
 import { CreateImagePayload, CreateImageResponse } from '../../types/image';
 import { AgentRuntimeError } from '../../utils/createError';
+import { getModelPricing } from '../../utils/getModelPricing';
 import { parseGoogleErrorMessage } from '../../utils/googleErrorParser';
 import { imageUrlToBase64 } from '../../utils/imageToBase64';
 import { parseDataUri } from '../../utils/uriParser';
@@ -101,6 +103,7 @@ async function generateByImageModel(
 async function generateImageByChatModel(
   client: GoogleGenAI,
   payload: CreateImagePayload,
+  provider: string,
 ): Promise<CreateImageResponse> {
   const { model, params } = payload;
   const actualModel = model.replace(':image', '');
@@ -146,7 +149,13 @@ async function generateImageByChatModel(
     model: actualModel,
   });
 
-  return extractImageFromResponse(response);
+  const imageResponse = extractImageFromResponse(response);
+  if (response.usageMetadata) {
+    const pricing = await getModelPricing(model, provider);
+    imageResponse.modelUsage = convertGoogleAIUsage(response.usageMetadata, pricing);
+  }
+
+  return imageResponse;
 }
 
 /**
@@ -162,7 +171,7 @@ export async function createGoogleImage(
 
     // Handle Gemini 2.5 Flash Image models that use generateContent
     if (model.endsWith(':image')) {
-      return await generateImageByChatModel(client, payload);
+      return await generateImageByChatModel(client, payload, provider);
     }
 
     // Handle traditional Imagen models that use generateImages

package/packages/model-runtime/src/providers/google/index.ts

@@ -27,6 +27,7 @@ import { AgentRuntimeErrorType } from '../../types/error';
 import { CreateImagePayload, CreateImageResponse } from '../../types/image';
 import { AgentRuntimeError } from '../../utils/createError';
 import { debugStream } from '../../utils/debugStream';
+import { getModelPricing } from '../../utils/getModelPricing';
 import { parseGoogleErrorMessage } from '../../utils/googleErrorParser';
 import { imageUrlToBase64 } from '../../utils/imageToBase64';
 import { StreamingResponse } from '../../utils/response';
@@ -244,8 +245,14 @@ export class LobeGoogleAI implements LobeRuntimeAI {
       }
 
       // Convert the response into a friendly text-stream
+      const pricing = await getModelPricing(model, this.provider);
+
       const Stream = this.isVertexAi ? VertexAIStream : GoogleGenerativeAIStream;
-      const stream = Stream(prod, { callbacks: options?.callback, inputStartAt });
+      const stream = Stream(prod, {
+        callbacks: options?.callback,
+        inputStartAt,
+        payload: { model, pricing, provider: this.provider },
+      });
 
       // Respond with the stream
       return StreamingResponse(stream, { headers: options?.headers });

package/packages/model-runtime/src/providers/openai/__snapshots__/index.test.ts.snap

@@ -268,6 +268,13 @@ exports[`LobeOpenAI > models > should get models 1`] = `
       "prompt": {
         "default": "",
       },
+      "quality": {
+        "default": "standard",
+        "enum": [
+          "standard",
+          "hd",
+        ],
+      },
       "size": {
         "default": "1024x1024",
         "enum": [

package/packages/model-runtime/src/providers/zhipu/index.ts

@@ -108,7 +108,9 @@ export const LobeZhipuAI = createOpenAICompatibleRuntime({
       return OpenAIStream(preprocessedStream, {
         callbacks,
         inputStartAt,
-        provider: 'zhipu',
+        payload: {
+          provider: 'zhipu',
+        },
       });
     },
   },