@lobehub/chat 1.68.8 → 1.68.10

package/src/libs/agent-runtime/utils/streams/openai.test.ts

@@ -348,94 +348,198 @@ describe('OpenAIStream', () => {
     ]);
   });
 
-  it('should streaming token usage', async () => {
-    const data = [
-      {
-        id: 'chatcmpl-B7CcnaeK3jqWBMOhxg7SSKFwlk7dC',
-        object: 'chat.completion.chunk',
-        created: 1741056525,
-        model: 'gpt-4o-mini-2024-07-18',
-        choices: [{ index: 0, delta: { role: 'assistant', content: '' } }],
-        service_tier: 'default',
-        system_fingerprint: 'fp_06737a9306',
-      },
-      {
-        id: 'chatcmpl-B7CcnaeK3jqWBMOhxg7SSKFwlk7dC',
-        object: 'chat.completion.chunk',
-        created: 1741056525,
-        model: 'gpt-4o-mini-2024-07-18',
-        choices: [{ index: 0, delta: { content: '你好！' } }],
-        service_tier: 'default',
-        system_fingerprint: 'fp_06737a9306',
-      },
-      {
-        id: 'chatcmpl-B7CcnaeK3jqWBMOhxg7SSKFwlk7dC',
-        object: 'chat.completion.chunk',
-        created: 1741056525,
-        model: 'gpt-4o-mini-2024-07-18',
-        choices: [{ index: 0, delta: {}, finish_reason: 'stop' }],
-        service_tier: 'default',
-        system_fingerprint: 'fp_06737a9306',
-      },
-      {
-        id: 'chatcmpl-B7CcnaeK3jqWBMOhxg7SSKFwlk7dC',
-        object: 'chat.completion.chunk',
-        created: 1741056525,
-        model: 'gpt-4o-mini-2024-07-18',
-        choices: [],
-        service_tier: 'default',
-        system_fingerprint: 'fp_06737a9306',
-        usage: {
-          prompt_tokens: 1646,
-          completion_tokens: 11,
-          total_tokens: 1657,
-          prompt_tokens_details: { audio_tokens: 0, cached_tokens: 0 },
-          completion_tokens_details: {
-            accepted_prediction_tokens: 0,
-            audio_tokens: 0,
-            reasoning_tokens: 0,
-            rejected_prediction_tokens: 0,
+  describe('token usage', () => {
+    it('should streaming token usage', async () => {
+      const data = [
+        {
+          id: 'chatcmpl-B7CcnaeK3jqWBMOhxg7SSKFwlk7dC',
+          object: 'chat.completion.chunk',
+          created: 1741056525,
+          model: 'gpt-4o-mini-2024-07-18',
+          choices: [{ index: 0, delta: { role: 'assistant', content: '' } }],
+          service_tier: 'default',
+          system_fingerprint: 'fp_06737a9306',
+        },
+        {
+          id: 'chatcmpl-B7CcnaeK3jqWBMOhxg7SSKFwlk7dC',
+          object: 'chat.completion.chunk',
+          created: 1741056525,
+          model: 'gpt-4o-mini-2024-07-18',
+          choices: [{ index: 0, delta: { content: '你好！' } }],
+          service_tier: 'default',
+          system_fingerprint: 'fp_06737a9306',
+        },
+        {
+          id: 'chatcmpl-B7CcnaeK3jqWBMOhxg7SSKFwlk7dC',
+          object: 'chat.completion.chunk',
+          created: 1741056525,
+          model: 'gpt-4o-mini-2024-07-18',
+          choices: [{ index: 0, delta: {}, finish_reason: 'stop' }],
+          service_tier: 'default',
+          system_fingerprint: 'fp_06737a9306',
+        },
+        {
+          id: 'chatcmpl-B7CcnaeK3jqWBMOhxg7SSKFwlk7dC',
+          object: 'chat.completion.chunk',
+          created: 1741056525,
+          model: 'gpt-4o-mini-2024-07-18',
+          choices: [],
+          service_tier: 'default',
+          system_fingerprint: 'fp_06737a9306',
+          usage: {
+            prompt_tokens: 1646,
+            completion_tokens: 11,
+            total_tokens: 1657,
+            prompt_tokens_details: { audio_tokens: 0, cached_tokens: 0 },
+            completion_tokens_details: {
+              accepted_prediction_tokens: 0,
+              audio_tokens: 0,
+              reasoning_tokens: 0,
+              rejected_prediction_tokens: 0,
+            },
           },
         },
-      },
-    ];
+      ];
 
-    const mockOpenAIStream = new ReadableStream({
-      start(controller) {
-        data.forEach((chunk) => {
-          controller.enqueue(chunk);
-        });
+      const mockOpenAIStream = new ReadableStream({
+        start(controller) {
+          data.forEach((chunk) => {
+            controller.enqueue(chunk);
+          });
 
-        controller.close();
-      },
+          controller.close();
+        },
+      });
+
+      const protocolStream = OpenAIStream(mockOpenAIStream);
+
+      const decoder = new TextDecoder();
+      const chunks = [];
+
+      // @ts-ignore
+      for await (const chunk of protocolStream) {
+        chunks.push(decoder.decode(chunk, { stream: true }));
+      }
+
+      expect(chunks).toEqual(
+        [
+          'id: chatcmpl-B7CcnaeK3jqWBMOhxg7SSKFwlk7dC',
+          'event: text',
+          `data: ""\n`,
+          'id: chatcmpl-B7CcnaeK3jqWBMOhxg7SSKFwlk7dC',
+          'event: text',
+          `data: "你好！"\n`,
+          'id: chatcmpl-B7CcnaeK3jqWBMOhxg7SSKFwlk7dC',
+          'event: stop',
+          `data: "stop"\n`,
+          'id: chatcmpl-B7CcnaeK3jqWBMOhxg7SSKFwlk7dC',
+          'event: usage',
+          `data: {"inputCacheMissTokens":1646,"inputTextTokens":1646,"outputTextTokens":11,"totalInputTokens":1646,"totalOutputTokens":11,"totalTokens":1657}\n`,
+        ].map((i) => `${i}\n`),
+      );
     });
 
-    const protocolStream = OpenAIStream(mockOpenAIStream);
+    it('should streaming litellm token usage', async () => {
+      const data = [
+        {
+          id: 'chatcmpl-c1f6a6a6-fcf8-463a-96bf-cf634d3e98a5',
+          created: 1741188058,
+          model: 'gpt-4o-mini',
+          object: 'chat.completion.chunk',
+          system_fingerprint: 'fp_06737a9306',
+          choices: [{ index: 0, delta: { content: ' #' } }],
+          stream_options: { include_usage: true },
+        },
+        {
+          id: 'chatcmpl-c1f6a6a6-fcf8-463a-96bf-cf634d3e98a5',
+          created: 1741188068,
+          model: 'gpt-4o-mini',
+          object: 'chat.completion.chunk',
+          system_fingerprint: 'fp_06737a9306',
+          choices: [{ index: 0, delta: { content: '.' } }],
+          stream_options: { include_usage: true },
+        },
+        {
+          id: 'chatcmpl-c1f6a6a6-fcf8-463a-96bf-cf634d3e98a5',
+          created: 1741188068,
+          model: 'gpt-4o-mini',
+          object: 'chat.completion.chunk',
+          system_fingerprint: 'fp_06737a9306',
+          choices: [{ finish_reason: 'stop', index: 0, delta: {} }],
+          stream_options: { include_usage: true },
+        },
+        {
+          id: 'chatcmpl-c1f6a6a6-fcf8-463a-96bf-cf634d3e98a5',
+          created: 1741188068,
+          model: 'gpt-4o-mini',
+          object: 'chat.completion.chunk',
+          system_fingerprint: 'fp_06737a9306',
+          choices: [{ index: 0, delta: {} }],
+          stream_options: { include_usage: true },
+        },
+        {
+          id: 'chatcmpl-c1f6a6a6-fcf8-463a-96bf-cf634d3e98a5',
+          created: 1741188068,
+          model: 'gpt-4o-mini',
+          object: 'chat.completion.chunk',
+          system_fingerprint: 'fp_06737a9306',
+          choices: [{ index: 0, delta: {} }],
+          stream_options: { include_usage: true },
+          usage: {
+            completion_tokens: 1720,
+            prompt_tokens: 1797,
+            total_tokens: 3517,
+            completion_tokens_details: {
+              accepted_prediction_tokens: 0,
+              audio_tokens: 0,
+              reasoning_tokens: 0,
+              rejected_prediction_tokens: 0,
+            },
+            prompt_tokens_details: { audio_tokens: 0, cached_tokens: 0 },
+          },
+        },
+      ];
 
-    const decoder = new TextDecoder();
-    const chunks = [];
+      const mockOpenAIStream = new ReadableStream({
+        start(controller) {
+          data.forEach((chunk) => {
+            controller.enqueue(chunk);
+          });
 
-    // @ts-ignore
-    for await (const chunk of protocolStream) {
-      chunks.push(decoder.decode(chunk, { stream: true }));
-    }
+          controller.close();
+        },
+      });
 
-    expect(chunks).toEqual(
-      [
-        'id: chatcmpl-B7CcnaeK3jqWBMOhxg7SSKFwlk7dC',
-        'event: text',
-        `data: ""\n`,
-        'id: chatcmpl-B7CcnaeK3jqWBMOhxg7SSKFwlk7dC',
-        'event: text',
-        `data: "你好！"\n`,
-        'id: chatcmpl-B7CcnaeK3jqWBMOhxg7SSKFwlk7dC',
-        'event: stop',
-        `data: "stop"\n`,
-        'id: chatcmpl-B7CcnaeK3jqWBMOhxg7SSKFwlk7dC',
-        'event: usage',
-        `data: {"acceptedPredictionTokens":0,"cachedTokens":0,"inputAudioTokens":0,"inputTokens":1646,"outputAudioTokens":0,"outputTokens":11,"reasoningTokens":0,"rejectedPredictionTokens":0,"totalTokens":1657}\n`,
-      ].map((i) => `${i}\n`),
-    );
+      const protocolStream = OpenAIStream(mockOpenAIStream);
+
+      const decoder = new TextDecoder();
+      const chunks = [];
+
+      // @ts-ignore
+      for await (const chunk of protocolStream) {
+        chunks.push(decoder.decode(chunk, { stream: true }));
+      }
+
+      expect(chunks).toEqual(
+        [
+          'id: chatcmpl-c1f6a6a6-fcf8-463a-96bf-cf634d3e98a5',
+          'event: text',
+          `data: " #"\n`,
+          'id: chatcmpl-c1f6a6a6-fcf8-463a-96bf-cf634d3e98a5',
+          'event: text',
+          `data: "."\n`,
+          'id: chatcmpl-c1f6a6a6-fcf8-463a-96bf-cf634d3e98a5',
+          'event: stop',
+          `data: "stop"\n`,
+          'id: chatcmpl-c1f6a6a6-fcf8-463a-96bf-cf634d3e98a5',
+          'event: data',
+          `data: {"delta":{},"id":"chatcmpl-c1f6a6a6-fcf8-463a-96bf-cf634d3e98a5","index":0}\n`,
+          'id: chatcmpl-c1f6a6a6-fcf8-463a-96bf-cf634d3e98a5',
+          'event: usage',
+          `data: {"inputCacheMissTokens":1797,"inputTextTokens":1797,"outputTextTokens":1720,"totalInputTokens":1797,"totalOutputTokens":1720,"totalTokens":3517}\n`,
+        ].map((i) => `${i}\n`),
+      );
+    });
   });
 
   describe('Tools Calling', () => {
@@ -840,7 +944,7 @@ describe('OpenAIStream', () => {
           `data: "帮助。"\n`,
           'id: 1',
           'event: usage',
-          `data: {"cachedTokens":0,"inputCacheMissTokens":6,"inputTokens":6,"outputTokens":104,"reasoningTokens":70,"totalTokens":110}\n`,
+          `data: {"inputCacheMissTokens":6,"inputTextTokens":6,"outputReasoningTokens":70,"outputTextTokens":34,"totalInputTokens":6,"totalOutputTokens":104,"totalTokens":110}\n`,
         ].map((i) => `${i}\n`),
       );
     });
@@ -1059,7 +1163,7 @@ describe('OpenAIStream', () => {
           `data: "帮助。"\n`,
           'id: 1',
           'event: usage',
-          `data: {"cachedTokens":0,"inputCacheMissTokens":6,"inputTokens":6,"outputTokens":104,"reasoningTokens":70,"totalTokens":110}\n`,
+          `data: {"inputCacheMissTokens":6,"inputTextTokens":6,"outputReasoningTokens":70,"outputTextTokens":34,"totalInputTokens":6,"totalOutputTokens":104,"totalTokens":110}\n`,
         ].map((i) => `${i}\n`),
       );
     });
@@ -1260,7 +1364,7 @@ describe('OpenAIStream', () => {
           `data: "帮助。"\n`,
           'id: 1',
           'event: usage',
-          `data: {"cachedTokens":0,"inputCacheMissTokens":6,"inputTokens":6,"outputTokens":104,"reasoningTokens":70,"totalTokens":110}\n`,
+          `data: {"inputCacheMissTokens":6,"inputTextTokens":6,"outputReasoningTokens":70,"outputTextTokens":34,"totalInputTokens":6,"totalOutputTokens":104,"totalTokens":110}\n`,
         ].map((i) => `${i}\n`),
       );
     });
@@ -1461,7 +1565,7 @@ describe('OpenAIStream', () => {
           `data: "帮助。"\n`,
           'id: 1',
           'event: usage',
-          `data: {"cachedTokens":0,"inputCacheMissTokens":6,"inputTokens":6,"outputTokens":104,"reasoningTokens":70,"totalTokens":110}\n`,
+          `data: {"inputCacheMissTokens":6,"inputTextTokens":6,"outputReasoningTokens":70,"outputTextTokens":34,"totalInputTokens":6,"totalOutputTokens":104,"totalTokens":110}\n`,
         ].map((i) => `${i}\n`),
       );
     });
@@ -1662,7 +1766,7 @@ describe('OpenAIStream', () => {
           `data: "帮助。"\n`,
           'id: 1',
           'event: usage',
-          `data: {"cachedTokens":0,"inputCacheMissTokens":6,"inputTokens":6,"outputTokens":104,"reasoningTokens":70,"totalTokens":110}\n`,
+          `data: {"inputCacheMissTokens":6,"inputTextTokens":6,"outputReasoningTokens":70,"outputTextTokens":34,"totalInputTokens":6,"totalOutputTokens":104,"totalTokens":110}\n`,
         ].map((i) => `${i}\n`),
       );
     });

package/src/libs/agent-runtime/utils/streams/openai.ts

@@ -1,10 +1,11 @@
 import OpenAI from 'openai';
 import type { Stream } from 'openai/streaming';
 
-import { ChatMessageError, CitationItem, ModelTokensUsage } from '@/types/message';
+import { ChatMessageError, CitationItem } from '@/types/message';
 
 import { AgentRuntimeErrorType, ILobeAgentRuntimeErrorType } from '../../error';
 import { ChatStreamCallbacks } from '../../types';
+import { convertUsage } from '../usageConverter';
 import {
   FIRST_CHUNK_ERROR_KEY,
   StreamContext,
@@ -18,22 +19,6 @@ import {
   generateToolCallId,
 } from './protocol';
 
-const convertUsage = (usage: OpenAI.Completions.CompletionUsage): ModelTokensUsage => {
-  return {
-    acceptedPredictionTokens: usage.completion_tokens_details?.accepted_prediction_tokens,
-    cachedTokens:
-      (usage as any).prompt_cache_hit_tokens || usage.prompt_tokens_details?.cached_tokens,
-    inputAudioTokens: usage.prompt_tokens_details?.audio_tokens,
-    inputCacheMissTokens: (usage as any).prompt_cache_miss_tokens,
-    inputTokens: usage.prompt_tokens,
-    outputAudioTokens: usage.completion_tokens_details?.audio_tokens,
-    outputTokens: usage.completion_tokens,
-    reasoningTokens: usage.completion_tokens_details?.reasoning_tokens,
-    rejectedPredictionTokens: usage.completion_tokens_details?.rejected_prediction_tokens,
-    totalTokens: usage.total_tokens,
-  };
-};
-
 export const transformOpenAIStream = (
   chunk: OpenAI.ChatCompletionChunk,
   streamContext: StreamContext,
@@ -193,6 +178,12 @@ export const transformOpenAIStream = (
       return { data: item.delta, id: chunk.id, type: 'data' };
     }
 
+    // litellm 的返回结果中，存在 delta 为空，但是有 usage 的情况
+    if (chunk.usage) {
+      const usage = chunk.usage;
+      return { data: convertUsage(usage), id: chunk.id, type: 'usage' };
+    }
+
     // 其余情况下，返回 delta 和 index
     return {
       data: { delta: item.delta, id: chunk.id, index: item.index },

package/src/libs/agent-runtime/utils/usageConverter.test.ts

@@ -0,0 +1,249 @@
+import OpenAI from 'openai';
+import { describe, expect, it } from 'vitest';
+
+import { convertUsage } from './usageConverter';
+
+describe('convertUsage', () => {
+  it('should convert basic OpenAI usage data correctly', () => {
+    // Arrange
+    const openaiUsage: OpenAI.Completions.CompletionUsage = {
+      prompt_tokens: 100,
+      completion_tokens: 50,
+      total_tokens: 150,
+    };
+
+    // Act
+    const result = convertUsage(openaiUsage);
+
+    // Assert
+    expect(result).toEqual({
+      inputTextTokens: 100,
+      totalInputTokens: 100,
+      totalOutputTokens: 50,
+      outputTextTokens: 50,
+      totalTokens: 150,
+    });
+  });
+
+  it('should handle PPLX citation tokens correctly', () => {
+    // Arrange
+    const pplxUsage = {
+      prompt_tokens: 80,
+      citation_tokens: 20,
+      completion_tokens: 50,
+      total_tokens: 150,
+    } as OpenAI.Completions.CompletionUsage;
+
+    // Act
+    const result = convertUsage(pplxUsage);
+
+    // Assert
+    expect(result).toEqual({
+      inputTextTokens: 80,
+      inputCitationTokens: 20,
+      totalInputTokens: 100,
+      totalOutputTokens: 50,
+      outputTextTokens: 50,
+      totalTokens: 170, // 150 + 20 (citation tokens)
+    });
+  });
+
+  it('should handle cached tokens correctly', () => {
+    // Arrange
+    const usageWithCache = {
+      prompt_tokens: 100,
+      prompt_cache_hit_tokens: 30,
+      prompt_cache_miss_tokens: 70,
+      completion_tokens: 50,
+      total_tokens: 150,
+    } as OpenAI.Completions.CompletionUsage;
+
+    // Act
+    const result = convertUsage(usageWithCache);
+
+    // Assert
+    expect(result).toEqual({
+      inputTextTokens: 100,
+      inputCachedTokens: 30,
+      inputCacheMissTokens: 70,
+      totalInputTokens: 100,
+      totalOutputTokens: 50,
+      outputTextTokens: 50,
+      totalTokens: 150,
+    });
+  });
+
+  it('should handle cached tokens using prompt_tokens_details', () => {
+    // Arrange
+    const usageWithTokenDetails = {
+      prompt_tokens: 100,
+      prompt_tokens_details: {
+        cached_tokens: 30,
+      },
+      completion_tokens: 50,
+      total_tokens: 150,
+    } as OpenAI.Completions.CompletionUsage;
+
+    // Act
+    const result = convertUsage(usageWithTokenDetails);
+
+    // Assert
+    expect(result).toEqual({
+      inputTextTokens: 100,
+      inputCachedTokens: 30,
+      inputCacheMissTokens: 70, // 100 - 30
+      totalInputTokens: 100,
+      totalOutputTokens: 50,
+      outputTextTokens: 50,
+      totalTokens: 150,
+    });
+  });
+
+  it('should handle audio tokens in input correctly', () => {
+    // Arrange
+    const usageWithAudioInput = {
+      prompt_tokens: 100,
+      prompt_tokens_details: {
+        audio_tokens: 20,
+      },
+      completion_tokens: 50,
+      total_tokens: 150,
+    } as OpenAI.Completions.CompletionUsage;
+
+    // Act
+    const result = convertUsage(usageWithAudioInput);
+
+    // Assert
+    expect(result).toEqual({
+      inputTextTokens: 100,
+      inputAudioTokens: 20,
+      totalInputTokens: 100,
+      totalOutputTokens: 50,
+      outputTextTokens: 50,
+      totalTokens: 150,
+    });
+  });
+
+  it('should handle detailed output tokens correctly', () => {
+    // Arrange
+    const usageWithOutputDetails = {
+      prompt_tokens: 100,
+      completion_tokens: 100,
+      completion_tokens_details: {
+        reasoning_tokens: 30,
+        audio_tokens: 20,
+      },
+      total_tokens: 200,
+    } as OpenAI.Completions.CompletionUsage;
+
+    // Act
+    const result = convertUsage(usageWithOutputDetails);
+
+    // Assert
+    expect(result).toEqual({
+      inputTextTokens: 100,
+      totalInputTokens: 100,
+      totalOutputTokens: 100,
+      outputReasoningTokens: 30,
+      outputAudioTokens: 20,
+      outputTextTokens: 50, // 100 - 30 - 20
+      totalTokens: 200,
+    });
+  });
+
+  it('should handle prediction tokens correctly', () => {
+    // Arrange
+    const usageWithPredictions = {
+      prompt_tokens: 100,
+      completion_tokens: 80,
+      completion_tokens_details: {
+        accepted_prediction_tokens: 30,
+        rejected_prediction_tokens: 10,
+      },
+      total_tokens: 180,
+    } as OpenAI.Completions.CompletionUsage;
+
+    // Act
+    const result = convertUsage(usageWithPredictions);
+
+    // Assert
+    expect(result).toEqual({
+      inputTextTokens: 100,
+      totalInputTokens: 100,
+      totalOutputTokens: 80,
+      outputTextTokens: 80,
+      acceptedPredictionTokens: 30,
+      rejectedPredictionTokens: 10,
+      totalTokens: 180,
+    });
+  });
+
+  it('should handle complex usage with all fields correctly', () => {
+    // Arrange
+    const complexUsage = {
+      prompt_tokens: 150,
+      prompt_tokens_details: {
+        audio_tokens: 50,
+        cached_tokens: 40,
+      },
+      citation_tokens: 30,
+      completion_tokens: 120,
+      completion_tokens_details: {
+        reasoning_tokens: 40,
+        audio_tokens: 30,
+        accepted_prediction_tokens: 20,
+        rejected_prediction_tokens: 5,
+      },
+      total_tokens: 300,
+    } as OpenAI.Completions.CompletionUsage;
+
+    // Act
+    const result = convertUsage(complexUsage);
+
+    // Assert
+    expect(result).toEqual({
+      inputTextTokens: 150,
+      inputAudioTokens: 50,
+      inputCachedTokens: 40,
+      inputCacheMissTokens: 140, // 180 - 40 (totalInputTokens - cachedTokens)
+      inputCitationTokens: 30,
+      totalInputTokens: 180, // 150 + 30
+      outputTextTokens: 50, // 120 - 40 - 30
+      outputReasoningTokens: 40,
+      outputAudioTokens: 30,
+      totalOutputTokens: 120,
+      acceptedPredictionTokens: 20,
+      rejectedPredictionTokens: 5,
+      totalTokens: 330, // 300 + 30 (citation_tokens)
+    });
+  });
+
+  it('should omit zero or undefined values in the final output', () => {
+    // Arrange
+    const usageWithZeros = {
+      prompt_tokens: 100,
+      completion_tokens: 50,
+      total_tokens: 150,
+      completion_tokens_details: {
+        reasoning_tokens: 0,
+        audio_tokens: undefined,
+      },
+    } as OpenAI.Completions.CompletionUsage;
+
+    // Act
+    const result = convertUsage(usageWithZeros);
+
+    // Assert
+    expect(result).toEqual({
+      inputTextTokens: 100,
+      totalInputTokens: 100,
+      totalOutputTokens: 50,
+      outputTextTokens: 50,
+      totalTokens: 150,
+    });
+
+    // These should not be present in the result
+    expect(result).not.toHaveProperty('outputReasoningTokens');
+    expect(result).not.toHaveProperty('outputAudioTokens');
+  });
+});

package/src/libs/agent-runtime/utils/usageConverter.ts

@@ -0,0 +1,50 @@
+import OpenAI from 'openai';
+
+import { ModelTokensUsage } from '@/types/message';
+
+export const convertUsage = (usage: OpenAI.Completions.CompletionUsage): ModelTokensUsage => {
+  // 目前只有 pplx 才有 citation_tokens
+  const inputTextTokens = usage.prompt_tokens || 0;
+  const inputCitationTokens = (usage as any).citation_tokens || 0;
+  const totalInputTokens = inputCitationTokens + inputTextTokens;
+
+  const cachedTokens =
+    (usage as any).prompt_cache_hit_tokens || usage.prompt_tokens_details?.cached_tokens;
+
+  const inputCacheMissTokens =
+    (usage as any).prompt_cache_miss_tokens || totalInputTokens - cachedTokens;
+
+  const totalOutputTokens = usage.completion_tokens;
+  const outputReasoning = usage.completion_tokens_details?.reasoning_tokens || 0;
+  const outputAudioTokens = usage.completion_tokens_details?.audio_tokens || 0;
+  const outputTextTokens = totalOutputTokens - outputReasoning - outputAudioTokens;
+
+  const totalTokens = inputCitationTokens + usage.total_tokens;
+
+  const data = {
+    acceptedPredictionTokens: usage.completion_tokens_details?.accepted_prediction_tokens,
+    inputAudioTokens: usage.prompt_tokens_details?.audio_tokens,
+    inputCacheMissTokens: inputCacheMissTokens,
+    inputCachedTokens: cachedTokens,
+    inputCitationTokens: inputCitationTokens,
+    inputTextTokens: inputTextTokens,
+    outputAudioTokens: outputAudioTokens,
+    outputReasoningTokens: outputReasoning,
+    outputTextTokens: outputTextTokens,
+    rejectedPredictionTokens: usage.completion_tokens_details?.rejected_prediction_tokens,
+    totalInputTokens,
+    totalOutputTokens: totalOutputTokens,
+    totalTokens,
+  } satisfies ModelTokensUsage;
+
+  const finalData = {};
+
+  Object.entries(data).forEach(([key, value]) => {
+    if (!!value) {
+      // @ts-ignore
+      finalData[key] = value;
+    }
+  });
+
+  return finalData;
+};