@lobehub/chat 1.92.3 → 1.93.0

package/src/libs/model-runtime/utils/streams/openai/responsesStream.ts

@@ -0,0 +1,166 @@
+import OpenAI from 'openai';
+import type { Stream } from 'openai/streaming';
+
+import { ChatMessageError } from '@/types/message';
+
+import { AgentRuntimeErrorType } from '../../../error';
+import { convertResponseUsage } from '../../usageConverter';
+import {
+  FIRST_CHUNK_ERROR_KEY,
+  StreamContext,
+  StreamProtocolChunk,
+  StreamProtocolToolCallChunk,
+  StreamToolCallChunkData,
+  convertIterableToStream,
+  createCallbacksTransformer,
+  createFirstErrorHandleTransformer,
+  createSSEProtocolTransformer,
+  createTokenSpeedCalculator,
+} from '../protocol';
+import { OpenAIStreamOptions } from './openai';
+
+const transformOpenAIStream = (
+  chunk: OpenAI.Responses.ResponseStreamEvent,
+  streamContext: StreamContext,
+): StreamProtocolChunk | StreamProtocolChunk[] => {
+  // handle the first chunk error
+  if (FIRST_CHUNK_ERROR_KEY in chunk) {
+    delete chunk[FIRST_CHUNK_ERROR_KEY];
+    // @ts-ignore
+    delete chunk['name'];
+    // @ts-ignore
+    delete chunk['stack'];
+
+    const errorData = {
+      body: chunk,
+      type: 'errorType' in chunk ? chunk.errorType : AgentRuntimeErrorType.ProviderBizError,
+    } as ChatMessageError;
+    return { data: errorData, id: 'first_chunk_error', type: 'error' };
+  }
+
+  try {
+    switch (chunk.type) {
+      case 'response.created': {
+        streamContext.id = chunk.response.id;
+
+        return { data: chunk.response.status, id: streamContext.id, type: 'data' };
+      }
+
+      case 'response.output_item.added': {
+        switch (chunk.item.type) {
+          case 'function_call': {
+            streamContext.toolIndex =
+              typeof streamContext.toolIndex === 'undefined' ? 0 : streamContext.toolIndex + 1;
+            streamContext.tool = {
+              id: chunk.item.call_id,
+              index: streamContext.toolIndex,
+              name: chunk.item.name,
+            };
+
+            return {
+              data: [
+                {
+                  function: { arguments: chunk.item.arguments, name: chunk.item.name },
+                  id: chunk.item.call_id,
+                  index: streamContext.toolIndex!,
+                  type: 'function',
+                } satisfies StreamToolCallChunkData,
+              ],
+              id: streamContext.id,
+              type: 'tool_calls',
+            } satisfies StreamProtocolToolCallChunk;
+          }
+        }
+
+        return { data: chunk.item, id: streamContext.id, type: 'data' };
+      }
+
+      case 'response.function_call_arguments.delta': {
+        return {
+          data: [
+            {
+              function: { arguments: chunk.delta, name: streamContext.tool?.name },
+              id: streamContext.tool?.id,
+              index: streamContext.toolIndex!,
+              type: 'function',
+            } satisfies StreamToolCallChunkData,
+          ],
+          id: streamContext.id,
+          type: 'tool_calls',
+        } satisfies StreamProtocolToolCallChunk;
+      }
+      case 'response.output_text.delta': {
+        return { data: chunk.delta, id: chunk.item_id, type: 'text' };
+      }
+
+      case 'response.reasoning_summary_part.added': {
+        if (!streamContext.startReasoning) {
+          streamContext.startReasoning = true;
+          return { data: '', id: chunk.item_id, type: 'reasoning' };
+        } else {
+          return { data: '\n', id: chunk.item_id, type: 'reasoning' };
+        }
+      }
+
+      case 'response.reasoning_summary_text.delta': {
+        return { data: chunk.delta, id: chunk.item_id, type: 'reasoning' };
+      }
+
+      case 'response.completed': {
+        if (chunk.response.usage) {
+          return {
+            data: convertResponseUsage(chunk.response.usage),
+            id: chunk.response.id,
+            type: 'usage',
+          };
+        }
+
+        return { data: chunk, id: streamContext.id, type: 'data' };
+      }
+
+      default: {
+        return { data: chunk, id: streamContext.id, type: 'data' };
+      }
+    }
+  } catch (e) {
+    const errorName = 'StreamChunkError';
+    console.error(`[${errorName}]`, e);
+    console.error(`[${errorName}] raw chunk:`, chunk);
+
+    const err = e as Error;
+
+    /* eslint-disable sort-keys-fix/sort-keys-fix */
+    const errorData = {
+      body: {
+        message:
+          'chat response streaming chunk parse error, please contact your API Provider to fix it.',
+        context: { error: { message: err.message, name: err.name }, chunk },
+      },
+      type: errorName,
+    } as ChatMessageError;
+    /* eslint-enable */
+
+    return { data: errorData, id: streamContext.id, type: 'error' };
+  }
+};
+
+export const OpenAIResponsesStream = (
+  stream: Stream<OpenAI.Responses.ResponseStreamEvent> | ReadableStream,
+  { callbacks, provider, bizErrorTypeTransformer, inputStartAt }: OpenAIStreamOptions = {},
+) => {
+  const streamStack: StreamContext = { id: '' };
+
+  const readableStream =
+    stream instanceof ReadableStream ? stream : convertIterableToStream(stream);
+
+  return (
+    readableStream
+      // 1. handle the first error if exist
+      // provider like huggingface or minimax will return error in the stream,
+      // so in the first Transformer, we need to handle the error
+      .pipeThrough(createFirstErrorHandleTransformer(bizErrorTypeTransformer, provider))
+      .pipeThrough(createTokenSpeedCalculator(transformOpenAIStream, { inputStartAt, streamStack }))
+      .pipeThrough(createSSEProtocolTransformer((c) => c, streamStack))
+      .pipeThrough(createCallbacksTransformer(callbacks))
+  );
+};

package/src/libs/model-runtime/utils/streams/protocol.ts

@@ -23,6 +23,10 @@ export interface StreamContext {
    * This array accumulates all citation items received during the streaming response.
    */
   returnedCitationArray?: CitationItem[];
+  /**
+   * O series models need a condition to separate part
+   */
+  startReasoning?: boolean;
   thinking?: {
     id: string;
     name: string;
@@ -78,7 +82,6 @@ export interface StreamToolCallChunkData {
 export interface StreamProtocolToolCallChunk {
   data: StreamToolCallChunkData[];
   id: string;
-  index: number;
   type: 'tool_calls';
 }
 

package/src/libs/model-runtime/utils/streams/utils.ts

@@ -0,0 +1,20 @@
+export const createReadableStream = <T>(chunks: T[]) =>
+  new ReadableStream({
+    start(controller) {
+      chunks.forEach((chunk) => controller.enqueue(chunk));
+
+      controller.close();
+    },
+  });
+
+export const readStreamChunk = async (stream: ReadableStream) => {
+  const decoder = new TextDecoder();
+  const chunks = [];
+
+  // @ts-ignore
+  for await (const chunk of stream) {
+    chunks.push(decoder.decode(chunk, { stream: true }));
+  }
+
+  return chunks;
+};

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

@@ -48,3 +48,62 @@ export const convertUsage = (usage: OpenAI.Completions.CompletionUsage): ModelTo
 
   return finalData;
 };
+
+export const convertResponseUsage = (usage: OpenAI.Responses.ResponseUsage): ModelTokensUsage => {
+  // 1. Extract and default primary values
+  const totalInputTokens = usage.input_tokens || 0;
+  const inputCachedTokens = usage.input_tokens_details?.cached_tokens || 0;
+
+  const totalOutputTokens = usage.output_tokens || 0;
+  const outputReasoningTokens = usage.output_tokens_details?.reasoning_tokens || 0;
+
+  const overallTotalTokens = usage.total_tokens || 0;
+
+  // 2. Calculate derived values
+  const inputCacheMissTokens = totalInputTokens - inputCachedTokens;
+
+  // For ResponseUsage, inputTextTokens is effectively totalInputTokens as no further breakdown is given.
+  const inputTextTokens = totalInputTokens;
+
+  // For ResponseUsage, outputTextTokens is totalOutputTokens minus reasoning, as no audio output tokens are specified.
+  const outputTextTokens = totalOutputTokens - outputReasoningTokens;
+
+  // 3. Construct the comprehensive data object (matching ModelTokensUsage structure)
+  const data = {
+    // Fields from ModelTokensUsage that are not in ResponseUsage will be undefined or 0
+    // and potentially filtered out later.
+    acceptedPredictionTokens: undefined, // Not in ResponseUsage
+    inputAudioTokens: undefined, // Not in ResponseUsage
+    inputCacheMissTokens: inputCacheMissTokens,
+    inputCachedTokens: inputCachedTokens,
+    inputCitationTokens: undefined, // Not in ResponseUsage
+    inputTextTokens: inputTextTokens,
+    outputAudioTokens: undefined, // Not in ResponseUsage
+    outputReasoningTokens: outputReasoningTokens,
+    outputTextTokens: outputTextTokens,
+    rejectedPredictionTokens: undefined, // Not in ResponseUsage
+    totalInputTokens: totalInputTokens,
+    totalOutputTokens: totalOutputTokens,
+    totalTokens: overallTotalTokens,
+  } satisfies ModelTokensUsage; // This helps ensure all keys of ModelTokensUsage are considered
+
+  // 4. Filter out zero/falsy values, as done in the reference implementation
+  const finalData: Partial<ModelTokensUsage> = {}; // Use Partial for type safety during construction
+  Object.entries(data).forEach(([key, value]) => {
+    if (
+      value !== undefined &&
+      value !== null &&
+      (typeof value !== 'number' || value !== 0) && // A more explicit check than `!!value` if we want to be very specific about
+      // keeping non-numeric truthy values, but the reference uses `!!value`.
+      // `!!value` will filter out 0, which is often desired for token counts.
+      // Let's stick to the reference's behavior:
+      !!value
+    ) {
+      // @ts-ignore - We are building an object that will conform to ModelTokensUsage
+      // by selectively adding properties.
+      finalData[key as keyof ModelTokensUsage] = value as number;
+    }
+  });
+
+  return finalData as ModelTokensUsage; // Cast because we've built it to match
+};

package/src/locales/default/modelProvider.ts

@@ -210,6 +210,10 @@ export default {
         title: '使用客户端请求模式',
       },
       helpDoc: '配置教程',
+      responsesApi: {
+        desc: '采用 OpenAI 新一代请求格式规范，解锁思维链等进阶特性',
+        title: '使用 Responses API 规范',
+      },
       waitingForMore: '更多模型正在 <1>计划接入</1> 中，敬请期待',
     },
     createNew: {

package/src/services/__tests__/chat.test.ts

@@ -618,6 +618,32 @@ describe('ChatService', () => {
         stream: true,
         ...DEFAULT_AGENT_CONFIG.params,
         ...params,
+        apiMode: 'responses',
+      };
+
+      await chatService.getChatCompletion(params, options);
+
+      expect(global.fetch).toHaveBeenCalledWith(expect.any(String), {
+        body: JSON.stringify(expectedPayload),
+        headers: expect.any(Object),
+        method: 'POST',
+      });
+    });
+    it('should make a POST request without response in non-openai provider payload', async () => {
+      const params: Partial<ChatStreamPayload> = {
+        model: 'deepseek-reasoner',
+        provider: 'deepseek',
+        messages: [],
+      };
+
+      const options = {};
+
+      const expectedPayload = {
+        model: 'deepseek-reasoner',
+        stream: true,
+        ...DEFAULT_AGENT_CONFIG.params,
+        messages: [],
+        provider: undefined,
       };
 
       await chatService.getChatCompletion(params, options);
@@ -656,6 +682,7 @@ describe('ChatService', () => {
         stream: true,
         ...DEFAULT_AGENT_CONFIG.params,
         ...params,
+        apiMode: 'responses',
       };
 
       const result = await chatService.getChatCompletion(params, options);

package/src/services/chat.ts

@@ -37,11 +37,11 @@ import { ChatErrorType } from '@/types/fetch';
 import { ChatMessage, MessageToolCall } from '@/types/message';
 import type { ChatStreamPayload, OpenAIChatMessage } from '@/types/openai/chat';
 import { UserMessageContentPart } from '@/types/openai/chat';
+import { parsePlaceholderVariablesMessages } from '@/utils/client/parserPlaceholder';
 import { createErrorResponse } from '@/utils/errorResponse';
 import { FetchSSEOptions, fetchSSE, getMessageError } from '@/utils/fetch';
 import { genToolCallingName } from '@/utils/toolCall';
 import { createTraceHeader, getTraceId } from '@/utils/trace';
-import { parsePlaceholderVariablesMessages } from '@/utils/client/parserPlaceholder';
 
 import { createHeaderWithAuth, createPayloadWithKeyVaults } from './_auth';
 import { API_ENDPOINTS } from './_url';
@@ -315,9 +315,15 @@ class ChatService {
       model = findDeploymentName(model, provider);
     }
 
+    const apiMode = aiProviderSelectors.isProviderEnableResponseApi(provider)(
+      getAiInfraStoreState(),
+    )
+      ? 'responses'
+      : undefined;
+
     const payload = merge(
       { model: DEFAULT_AGENT_CONFIG.model, stream: true, ...DEFAULT_AGENT_CONFIG.params },
-      { ...res, model },
+      { ...res, apiMode, model },
     );
 
     /**

package/src/store/aiInfra/slices/aiProvider/selectors.ts

@@ -99,6 +99,16 @@ const isProviderHasBuiltinSearchConfig = (id: string) => (s: AIProviderStoreStat
   return !!providerCfg?.settings.searchMode && providerCfg?.settings.searchMode !== 'internal';
 };
 
+const isProviderEnableResponseApi = (id: string) => (s: AIProviderStoreState) => {
+  const providerCfg = providerConfigById(id)(s);
+
+  const enableResponseApi = providerCfg?.config?.enableResponseApi;
+
+  if (typeof enableResponseApi === 'boolean') return enableResponseApi;
+
+  return id === 'openai';
+};
+
 export const aiProviderSelectors = {
   activeProviderConfig,
   disabledAiProviderList,
@@ -107,6 +117,7 @@ export const aiProviderSelectors = {
   isActiveProviderEndpointNotEmpty,
   isAiProviderConfigLoading,
   isProviderConfigUpdating,
+  isProviderEnableResponseApi,
   isProviderEnabled,
   isProviderFetchOnClient,
   isProviderHasBuiltinSearch,

package/src/types/aiProvider.ts

@@ -79,6 +79,7 @@ export interface AiProviderSettings {
    * whether to smoothing the output
    */
   smoothing?: SmoothingParams;
+  supportResponsesApi?: boolean;
 }
 
 const AiProviderSettingsSchema = z.object({
@@ -106,8 +107,13 @@ const AiProviderSettingsSchema = z.object({
       toolsCalling: z.boolean().optional(),
     })
     .optional(),
+  supportResponsesApi: z.boolean().optional(),
 });
 
+export interface AiProviderConfig {
+  enableResponseApi?: boolean;
+}
+
 // create
 export const CreateAiProviderSchema = z.object({
   config: z.object({}).passthrough().optional(),
@@ -206,8 +212,13 @@ export type UpdateAiProviderParams = z.infer<typeof UpdateAiProviderSchema>;
 
 export const UpdateAiProviderConfigSchema = z.object({
   checkModel: z.string().optional(),
+  config: z
+    .object({
+      enableResponseApi: z.boolean().optional(),
+    })
+    .optional(),
   fetchOnClient: z.boolean().nullable().optional(),
-  keyVaults: z.object({}).passthrough().optional(),
+  keyVaults: z.record(z.string(), z.string().optional()).optional(),
 });
 
 export type UpdateAiProviderConfigParams = z.infer<typeof UpdateAiProviderConfigSchema>;
@@ -235,6 +246,7 @@ export interface EnabledProviderWithModels {
 }
 
 export interface AiProviderRuntimeConfig {
+  config: AiProviderConfig;
   fetchOnClient?: boolean;
   keyVaults: Record<string, string>;
   settings: AiProviderSettings;