@lobehub/chat 1.111.1 → 1.111.3

package/src/utils/__snapshots__/parseModels.test.ts.snap

@@ -112,8 +112,20 @@ exports[`transformToChatModelCards > should have file with builtin models like g
     "enabled": true,
     "id": "gpt-4-0125-preview",
     "pricing": {
-      "input": 10,
-      "output": 30,
+      "units": [
+        {
+          "name": "textInput",
+          "rate": 10,
+          "strategy": "fixed",
+          "unit": "millionTokens",
+        },
+        {
+          "name": "textOutput",
+          "rate": 30,
+          "strategy": "fixed",
+          "unit": "millionTokens",
+        },
+      ],
     },
     "providerId": "openai",
     "releasedAt": "2024-01-25",
@@ -132,8 +144,20 @@ exports[`transformToChatModelCards > should have file with builtin models like g
     "enabled": true,
     "id": "gpt-4-turbo-2024-04-09",
     "pricing": {
-      "input": 10,
-      "output": 30,
+      "units": [
+        {
+          "name": "textInput",
+          "rate": 10,
+          "strategy": "fixed",
+          "unit": "millionTokens",
+        },
+        {
+          "name": "textOutput",
+          "rate": 30,
+          "strategy": "fixed",
+          "unit": "millionTokens",
+        },
+      ],
     },
     "providerId": "openai",
     "releasedAt": "2024-04-09",

package/src/utils/_deprecated/__snapshots__/parseModels.test.ts.snap

@@ -89,10 +89,6 @@ exports[`transformToChatModelCards > should have file with builtin models like g
     "files": true,
     "functionCall": true,
     "id": "gpt-4-0125-preview",
-    "pricing": {
-      "input": 10,
-      "output": 30,
-    },
   },
   {
     "contextWindowTokens": 128000,
@@ -102,10 +98,6 @@ exports[`transformToChatModelCards > should have file with builtin models like g
     "files": true,
     "functionCall": true,
     "id": "gpt-4-turbo-2024-04-09",
-    "pricing": {
-      "input": 10,
-      "output": 30,
-    },
     "vision": true,
   },
 ]

package/src/utils/parseModels.test.ts

@@ -732,9 +732,26 @@ describe('transformToChatModelCards', () => {
         id: 'gpt-4o',
         maxOutput: 4096,
         pricing: {
-          cachedInput: 1.25,
-          input: 2.5,
-          output: 10,
+          units: [
+            {
+              name: 'textInput_cacheRead',
+              rate: 1.25,
+              strategy: 'fixed',
+              unit: 'millionTokens',
+            },
+            {
+              name: 'textInput',
+              rate: 2.5,
+              strategy: 'fixed',
+              unit: 'millionTokens',
+            },
+            {
+              name: 'textOutput',
+              rate: 10,
+              strategy: 'fixed',
+              unit: 'millionTokens',
+            },
+          ],
         },
         providerId: 'azure',
         releasedAt: '2024-05-13',
@@ -753,9 +770,26 @@ describe('transformToChatModelCards', () => {
         id: 'gpt-4o-mini',
         maxOutput: 4096,
         pricing: {
-          cachedInput: 0.075,
-          input: 0.15,
-          output: 0.6,
+          units: [
+            {
+              name: 'textInput_cacheRead',
+              rate: 0.075,
+              strategy: 'fixed',
+              unit: 'millionTokens',
+            },
+            {
+              name: 'textInput',
+              rate: 0.15,
+              strategy: 'fixed',
+              unit: 'millionTokens',
+            },
+            {
+              name: 'textOutput',
+              rate: 0.6,
+              strategy: 'fixed',
+              unit: 'millionTokens',
+            },
+          ],
         },
         type: 'chat',
       },
@@ -772,9 +806,26 @@ describe('transformToChatModelCards', () => {
         id: 'o1-mini',
         maxOutput: 65536,
         pricing: {
-          cachedInput: 0.55,
-          input: 1.1,
-          output: 4.4,
+          units: [
+            {
+              name: 'textInput_cacheRead',
+              rate: 0.55,
+              strategy: 'fixed',
+              unit: 'millionTokens',
+            },
+            {
+              name: 'textInput',
+              rate: 1.1,
+              strategy: 'fixed',
+              unit: 'millionTokens',
+            },
+            {
+              name: 'textOutput',
+              rate: 4.4,
+              strategy: 'fixed',
+              unit: 'millionTokens',
+            },
+          ],
         },
         releasedAt: '2024-09-12',
         type: 'chat',

package/src/utils/pricing.test.ts

@@ -0,0 +1,183 @@
+import { describe, expect, it } from 'vitest';
+
+import { Pricing } from '@/types/aiModel';
+
+import {
+  getAudioInputUnitRate,
+  getAudioOutputUnitRate,
+  getCachedAudioInputUnitRate,
+  getCachedTextInputUnitRate,
+  getTextInputUnitRate,
+  getTextOutputUnitRate,
+  getUnitRateByName,
+  getWriteCacheInputUnitRate,
+} from './pricing';
+
+describe('pricing utilities (new)', () => {
+  describe('getUnitRateByName', () => {
+    it('returns undefined when pricing or unitName is missing', () => {
+      expect(getUnitRateByName()).toBeUndefined();
+      const p = { units: [] } as Pricing;
+      expect(getUnitRateByName(p)).toBeUndefined();
+    });
+
+    it('returns undefined when unit not found', () => {
+      const pricing: Pricing = {
+        units: [{ name: 'textOutput', strategy: 'fixed', unit: 'millionTokens', rate: 0.002 }],
+      };
+      expect(getUnitRateByName(pricing, 'textInput')).toBeUndefined();
+    });
+
+    it('handles fixed strategy', () => {
+      const pricing: Pricing = {
+        units: [{ name: 'textInput', strategy: 'fixed', unit: 'millionTokens', rate: 0.001 }],
+      };
+      expect(getUnitRateByName(pricing, 'textInput')).toBe(0.001);
+    });
+
+    it('handles tiered strategy (first tier)', () => {
+      const pricing: Pricing = {
+        units: [
+          {
+            name: 'audioInput',
+            strategy: 'tiered',
+            unit: 'second',
+            tiers: [
+              { rate: 0.01, upTo: 3600 },
+              { rate: 0.008, upTo: 'infinity' },
+            ],
+          },
+        ],
+      };
+      expect(getUnitRateByName(pricing, 'audioInput')).toBe(0.01);
+    });
+
+    it('returns undefined when tiered.tiers is absent or empty', () => {
+      const noTiers: Pricing = {
+        units: [
+          { name: 'textInput', strategy: 'tiered', unit: 'millionTokens', tiers: undefined as any },
+        ],
+      };
+      const emptyTiers: Pricing = {
+        units: [{ name: 'textInput', strategy: 'tiered', unit: 'millionTokens', tiers: [] }],
+      };
+      expect(getUnitRateByName(noTiers, 'textInput')).toBeUndefined();
+      expect(getUnitRateByName(emptyTiers, 'textInput')).toBeUndefined();
+    });
+
+    it('handles lookup strategy (first price value)', () => {
+      const pricing: Pricing = {
+        units: [
+          {
+            name: 'textInput',
+            strategy: 'lookup',
+            unit: 'millionTokens',
+            lookup: {
+              pricingParams: ['model'],
+              prices: { a: 0.001, b: 0.03 },
+            },
+          },
+        ],
+      };
+      expect(getUnitRateByName(pricing, 'textInput')).toBe(0.001);
+    });
+
+    it('returns undefined when lookup missing or has no prices', () => {
+      const missingLookup: Pricing = {
+        units: [
+          {
+            name: 'textInput',
+            strategy: 'lookup',
+            unit: 'millionTokens',
+            lookup: undefined as any,
+          },
+        ],
+      } as any;
+      const emptyPrices: Pricing = {
+        units: [
+          {
+            name: 'textInput',
+            strategy: 'lookup',
+            unit: 'millionTokens',
+            lookup: { pricingParams: ['model'], prices: {} },
+          },
+        ],
+      };
+      expect(getUnitRateByName(missingLookup, 'textInput')).toBeUndefined();
+      expect(getUnitRateByName(emptyPrices, 'textInput')).toBeUndefined();
+    });
+
+    it('works with multiple units', () => {
+      const pricing: Pricing = {
+        units: [
+          { name: 'textInput', strategy: 'fixed', unit: 'millionTokens', rate: 0.001 },
+          { name: 'textOutput', strategy: 'fixed', unit: 'millionTokens', rate: 0.002 },
+          {
+            name: 'audioInput',
+            strategy: 'tiered',
+            unit: 'second',
+            tiers: [
+              { rate: 0.01, upTo: 3600 },
+              { rate: 0.008, upTo: 'infinity' },
+            ],
+          },
+        ],
+      };
+      expect(getUnitRateByName(pricing, 'textInput')).toBe(0.001);
+      expect(getUnitRateByName(pricing, 'textOutput')).toBe(0.002);
+      expect(getUnitRateByName(pricing, 'audioInput')).toBe(0.01);
+    });
+  });
+
+  describe('wrapper helpers', () => {
+    it('return the same values as getUnitRateByName for each unit', () => {
+      const pricing: Pricing = {
+        units: [
+          { name: 'textInput', strategy: 'fixed', unit: 'millionTokens', rate: 0.001 },
+          { name: 'textOutput', strategy: 'fixed', unit: 'millionTokens', rate: 0.002 },
+          {
+            name: 'audioInput',
+            strategy: 'tiered',
+            unit: 'second',
+            tiers: [
+              { rate: 0.01, upTo: 3600 },
+              { rate: 0.008, upTo: 'infinity' },
+            ],
+          },
+          { name: 'audioOutput', strategy: 'fixed', unit: 'second', rate: 0.015 },
+          { name: 'textInput_cacheRead', strategy: 'fixed', unit: 'millionTokens', rate: 0.0005 },
+          {
+            name: 'textInput_cacheWrite',
+            strategy: 'lookup',
+            unit: 'millionTokens',
+            lookup: { pricingParams: ['ttl'], prices: { '5': 0.2, '60': 0.6 } },
+          },
+          { name: 'audioInput_cacheRead', strategy: 'fixed', unit: 'second', rate: 0.005 },
+        ],
+      };
+
+      expect(getTextInputUnitRate(pricing)).toBe(getUnitRateByName(pricing, 'textInput'));
+      expect(getTextOutputUnitRate(pricing)).toBe(getUnitRateByName(pricing, 'textOutput'));
+      expect(getAudioInputUnitRate(pricing)).toBe(getUnitRateByName(pricing, 'audioInput'));
+      expect(getAudioOutputUnitRate(pricing)).toBe(getUnitRateByName(pricing, 'audioOutput'));
+      expect(getCachedTextInputUnitRate(pricing)).toBe(
+        getUnitRateByName(pricing, 'textInput_cacheRead'),
+      );
+      expect(getWriteCacheInputUnitRate(pricing)).toBe(
+        getUnitRateByName(pricing, 'textInput_cacheWrite'),
+      );
+      expect(getCachedAudioInputUnitRate(pricing)).toBe(
+        getUnitRateByName(pricing, 'audioInput_cacheRead'),
+      );
+
+      // also validate expected concrete values for clarity
+      expect(getTextInputUnitRate(pricing)).toBe(0.001);
+      expect(getTextOutputUnitRate(pricing)).toBe(0.002);
+      expect(getAudioInputUnitRate(pricing)).toBe(0.01);
+      expect(getAudioOutputUnitRate(pricing)).toBe(0.015);
+      expect(getCachedTextInputUnitRate(pricing)).toBe(0.0005);
+      expect(getWriteCacheInputUnitRate(pricing)).toBe(0.2);
+      expect(getCachedAudioInputUnitRate(pricing)).toBe(0.005);
+    });
+  });
+});

package/src/utils/pricing.ts

@@ -0,0 +1,90 @@
+import { Pricing, PricingUnit, PricingUnitName } from '@/types/aiModel';
+
+/**
+ * Internal helper to extract the displayed unit rate from a pricing unit by strategy
+ * - fixed → rate
+ * - tiered → tiers[0].rate
+ * - lookup → first price value
+ */
+const getRateFromUnit = (unit: PricingUnit): number | undefined => {
+  switch (unit.strategy) {
+    case 'fixed': {
+      return unit.rate;
+    }
+    case 'tiered': {
+      return unit.tiers?.[0]?.rate;
+    }
+    case 'lookup': {
+      const prices = Object.values(unit.lookup?.prices || {});
+      return prices[0];
+    }
+    default: {
+      return undefined;
+    }
+  }
+};
+
+/**
+ * Get unit rate by unit name, used to deduplicate logic across helpers
+ */
+export const getUnitRateByName = (
+  pricing?: Pricing,
+  unitName?: PricingUnitName,
+): number | undefined => {
+  if (!pricing?.units || !unitName) return undefined;
+  const unit = pricing.units.find((u) => u.name === unitName);
+  if (!unit) return undefined;
+  return getRateFromUnit(unit);
+};
+
+/**
+ * Get text input unit rate from pricing
+ * - fixed → rate
+ * - tiered → tiers[0].rate
+ * - lookup → Object.values(lookup.prices)[0]
+ */
+export function getTextInputUnitRate(pricing?: Pricing): number | undefined {
+  return getUnitRateByName(pricing, 'textInput');
+}
+
+/**
+ * Get text output unit rate from pricing
+ */
+export function getTextOutputUnitRate(pricing?: Pricing): number | undefined {
+  return getUnitRateByName(pricing, 'textOutput');
+}
+
+/**
+ * Get audio input unit rate from pricing
+ */
+export function getAudioInputUnitRate(pricing?: Pricing): number | undefined {
+  return getUnitRateByName(pricing, 'audioInput');
+}
+
+/**
+ * Get audio output unit rate from pricing
+ */
+export function getAudioOutputUnitRate(pricing?: Pricing): number | undefined {
+  return getUnitRateByName(pricing, 'audioOutput');
+}
+
+/**
+ * Get cached text input unit rate from pricing
+ */
+export function getCachedTextInputUnitRate(pricing?: Pricing): number | undefined {
+  return getUnitRateByName(pricing, 'textInput_cacheRead');
+}
+
+/**
+ * Get write cache input unit rate from pricing (TextInputCacheWrite)
+ */
+export function getWriteCacheInputUnitRate(pricing?: Pricing): number | undefined {
+  return getUnitRateByName(pricing, 'textInput_cacheWrite');
+}
+
+/**
+ * Get cached audio input unit rate from pricing
+ */
+export function getCachedAudioInputUnitRate(pricing?: Pricing): number | undefined {
+  return getUnitRateByName(pricing, 'audioInput_cacheRead');
+}