@lobehub/chat 1.128.8 → 1.128.9

package/.github/workflows/sync-database-schema.yml

@@ -13,8 +13,13 @@ jobs:
     steps:
       - uses: actions/checkout@v5
 
-      - name: Install dbdocs
-        run: sudo npm install -g dbdocs
+      - name: Install bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: ${{ secrets.BUN_VERSION }}
+
+      - name: Install deps
+        run: bun i
 
       - name: Check dbdocs
         run: dbdocs

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 # Changelog
 
+### [Version 1.128.9](https://github.com/lobehub/lobe-chat/compare/v1.128.8...v1.128.9)
+
+<sup>Released on **2025-09-15**</sup>
+
+#### 💄 Styles
+
+- **misc**: Improve error handle with agent config, support `.doc` file parse.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Styles
+
+- **misc**: Improve error handle with agent config, closes [#9263](https://github.com/lobehub/lobe-chat/issues/9263) ([6656217](https://github.com/lobehub/lobe-chat/commit/6656217))
+- **misc**: Support `.doc` file parse, closes [#8182](https://github.com/lobehub/lobe-chat/issues/8182) ([ed42753](https://github.com/lobehub/lobe-chat/commit/ed42753))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ### [Version 1.128.8](https://github.com/lobehub/lobe-chat/compare/v1.128.7...v1.128.8)
 
 <sup>Released on **2025-09-15**</sup>

package/changelog/v1.json

@@ -1,4 +1,13 @@
 [
+  {
+    "children": {
+      "improvements": [
+        "Improve error handle with agent config, support .doc file parse."
+      ]
+    },
+    "date": "2025-09-15",
+    "version": "1.128.9"
+  },
   {
     "children": {
       "improvements": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/chat",
-  "version": "1.128.8",
+  "version": "1.128.9",
   "description": "Lobe Chat - an open-source, high-performance chatbot framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",
@@ -279,6 +279,7 @@
     "url-join": "^5.0.0",
     "use-merge-value": "^1.2.0",
     "uuid": "^11.1.0",
+    "word-extractor": "^1.0.4",
     "ws": "^8.18.3",
     "yaml": "^2.8.1",
     "zod": "^3.25.76",

package/packages/file-loaders/src/loadFile.ts

@@ -37,6 +37,7 @@ const getFileType = (filePath: string): SupportedFileType | undefined => {
       log('File type identified as pdf');
       return 'pdf';
     }
+    case 'doc':
     case 'docx': {
       log('File type identified as docx');
       return 'docx';

package/packages/file-loaders/src/loaders/docx/index.ts

@@ -12,7 +12,12 @@ export class DocxLoader implements FileLoaderInterface {
   async loadPages(filePath: string): Promise<DocumentPage[]> {
     log('Loading DOCX file:', filePath);
     try {
-      const loader = new LangchainDocxLoader(filePath);
+      let loader: LangchainDocxLoader;
+      if (filePath.endsWith('.doc')) {
+        loader = new LangchainDocxLoader(filePath, { type: 'doc' });
+      } else {
+        loader = new LangchainDocxLoader(filePath, { type: 'docx' });
+      }
       log('LangChain DocxLoader created');
       const docs = await loader.load(); // Langchain DocxLoader typically loads the whole doc as one
       log('DOCX document loaded, parts:', docs.length);

package/packages/model-runtime/src/core/openaiCompatibleFactory/index.test.ts

@@ -417,6 +417,78 @@ describe('LobeOpenAICompatibleFactory', () => {
           'event: text\n',
           'data: "Hello"\n\n',
           'id: a\n',
+          'event: usage\n',
+          'data: {"inputTextTokens":5,"outputTextTokens":5,"totalInputTokens":5,"totalOutputTokens":5,"totalTokens":10}\n\n',
+          'id: output_speed\n',
+          'event: speed\n',
+          expect.stringMatching(/^data: \{.*"tps":.*,"ttft":.*}\n\n$/), // tps ttft 测试结果不一样
+          'id: a\n',
+          'event: stop\n',
+          'data: "stop"\n\n',
+        ]);
+
+        expect((await reader.read()).done).toBe(true);
+      });
+
+      it('should transform non-streaming response to stream correctly with reasoning content', async () => {
+        const mockResponse = {
+          id: 'a',
+          object: 'chat.completion',
+          created: 123,
+          model: 'deepseek/deepseek-reasoner',
+          choices: [
+            {
+              index: 0,
+              message: {
+                role: 'assistant',
+                content: 'Hello',
+                reasoning_content: 'Thinking content',
+              },
+              finish_reason: 'stop',
+              logprobs: null,
+            },
+          ],
+          usage: {
+            prompt_tokens: 5,
+            completion_tokens: 5,
+            total_tokens: 10,
+          },
+        } as unknown as OpenAI.ChatCompletion;
+        vi.spyOn(instance['client'].chat.completions, 'create').mockResolvedValue(
+          mockResponse as any,
+        );
+
+        const result = await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'deepseek/deepseek-reasoner',
+          temperature: 0,
+          stream: false,
+        });
+
+        const decoder = new TextDecoder();
+        const reader = result.body!.getReader();
+        const stream: string[] = [];
+
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) break;
+          stream.push(decoder.decode(value));
+        }
+
+        expect(stream).toEqual([
+          'id: a\n',
+          'event: reasoning\n',
+          'data: "Thinking content"\n\n',
+          'id: a\n',
+          'event: text\n',
+          'data: "Hello"\n\n',
+          'id: a\n',
+          'event: usage\n',
+          'data: {"inputTextTokens":5,"outputTextTokens":5,"totalInputTokens":5,"totalOutputTokens":5,"totalTokens":10}\n\n',
+          'id: output_speed\n',
+          'event: speed\n',
+          expect.stringMatching(/^data: \{.*"tps":.*,"ttft":.*}\n\n$/), // tps ttft 测试结果不一样
+          'id: a\n',
           'event: stop\n',
           'data: "stop"\n\n',
         ]);

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

@@ -124,6 +124,29 @@ export function transformResponseToStream(data: OpenAI.ChatCompletion) {
   return new ReadableStream({
     start(controller) {
       const choices = data.choices || [];
+      const first = choices[0];
+      // 兼容：非流式里 DeepSeek 等会把“深度思考”放在 message.reasoning_content
+      const message: any = first?.message ?? {};
+      const reasoningText =
+        typeof message.reasoning_content === 'string' && message.reasoning_content.length > 0
+          ? message.reasoning_content
+          : null;
+      if (reasoningText) {
+        controller.enqueue({
+          choices: [
+            {
+              delta: { content: null, reasoning_content: reasoningText, role: 'assistant' },
+              finish_reason: null,
+              index: first?.index ?? 0,
+              logprobs: first?.logprobs ?? null,
+            },
+          ],
+          created: data.created,
+          id: data.id,
+          model: data.model,
+          object: 'chat.completion.chunk',
+        } as unknown as OpenAI.ChatCompletionChunk);
+      }
       const chunk: OpenAI.ChatCompletionChunk = {
         choices: choices.map((choice: OpenAI.ChatCompletion.Choice) => ({
           delta: {
@@ -149,7 +172,16 @@ export function transformResponseToStream(data: OpenAI.ChatCompletion) {
       };
 
       controller.enqueue(chunk);
-
+      if (data.usage) {
+        controller.enqueue({
+          choices: [],
+          created: data.created,
+          id: data.id,
+          model: data.model,
+          object: 'chat.completion.chunk',
+          usage: data.usage,
+        } as unknown as OpenAI.ChatCompletionChunk);
+      }
       controller.enqueue({
         choices: choices.map((choice: OpenAI.ChatCompletion.Choice) => ({
           delta: {
@@ -311,7 +343,7 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
                 callbacks: streamOptions.callbacks,
                 inputStartAt,
               })
-            : OpenAIStream(stream, { ...streamOptions, inputStartAt }),
+            : OpenAIStream(stream, { ...streamOptions, enableStreaming: false, inputStartAt }),
           {
             headers: options?.headers,
           },

package/packages/model-runtime/src/core/streams/anthropic.ts

@@ -240,12 +240,13 @@ export const transformAnthropicStream = (
 
 export interface AnthropicStreamOptions {
   callbacks?: ChatStreamCallbacks;
+  enableStreaming?: boolean; // 选择 TPS 计算方式（非流式时传 false）
   inputStartAt?: number;
 }
 
 export const AnthropicStream = (
   stream: Stream<Anthropic.MessageStreamEvent> | ReadableStream,
-  { callbacks, inputStartAt }: AnthropicStreamOptions = {},
+  { callbacks, inputStartAt, enableStreaming = true }: AnthropicStreamOptions = {},
 ) => {
   const streamStack: StreamContext = { id: '' };
 
@@ -254,7 +255,11 @@ export const AnthropicStream = (
 
   return readableStream
     .pipeThrough(
-      createTokenSpeedCalculator(transformAnthropicStream, { inputStartAt, streamStack }),
+      createTokenSpeedCalculator(transformAnthropicStream, {
+        enableStreaming: enableStreaming,
+        inputStartAt,
+        streamStack,
+      }),
     )
     .pipeThrough(createSSEProtocolTransformer((c) => c, streamStack))
     .pipeThrough(createCallbacksTransformer(callbacks));

package/packages/model-runtime/src/core/streams/google-ai.ts

@@ -213,18 +213,23 @@ const transformGoogleGenerativeAIStream = (
 
 export interface GoogleAIStreamOptions {
   callbacks?: ChatStreamCallbacks;
+  enableStreaming?: boolean; // 选择 TPS 计算方式（非流式时传 false）
   inputStartAt?: number;
 }
 
 export const GoogleGenerativeAIStream = (
   rawStream: ReadableStream<GenerateContentResponse>,
-  { callbacks, inputStartAt }: GoogleAIStreamOptions = {},
+  { callbacks, inputStartAt, enableStreaming = true }: GoogleAIStreamOptions = {},
 ) => {
   const streamStack: StreamContext = { id: 'chat_' + nanoid() };
 
   return rawStream
     .pipeThrough(
-      createTokenSpeedCalculator(transformGoogleGenerativeAIStream, { inputStartAt, streamStack }),
+      createTokenSpeedCalculator(transformGoogleGenerativeAIStream, {
+        enableStreaming: enableStreaming,
+        inputStartAt,
+        streamStack,
+      }),
     )
     .pipeThrough(
       createSSEProtocolTransformer((c) => c, streamStack, { requireTerminalEvent: true }),

package/packages/model-runtime/src/core/streams/openai/openai.ts

@@ -417,13 +417,20 @@ export interface OpenAIStreamOptions {
     name: string;
   }) => ILobeAgentRuntimeErrorType | undefined;
   callbacks?: ChatStreamCallbacks;
+  enableStreaming?: boolean; // 选择 TPS 计算方式（非流式时传 false）
   inputStartAt?: number;
   provider?: string;
 }
 
 export const OpenAIStream = (
   stream: Stream<OpenAI.ChatCompletionChunk> | ReadableStream,
-  { callbacks, provider, bizErrorTypeTransformer, inputStartAt }: OpenAIStreamOptions = {},
+  {
+    callbacks,
+    provider,
+    bizErrorTypeTransformer,
+    inputStartAt,
+    enableStreaming = true,
+  }: OpenAIStreamOptions = {},
 ) => {
   const streamStack: StreamContext = { id: '' };
 
@@ -439,7 +446,13 @@ export const OpenAIStream = (
       // 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(transformWithProvider, { inputStartAt, streamStack }))
+      .pipeThrough(
+        createTokenSpeedCalculator(transformWithProvider, {
+          enableStreaming: enableStreaming,
+          inputStartAt,
+          streamStack,
+        }),
+      )
       .pipeThrough(createSSEProtocolTransformer((c) => c, streamStack))
       .pipeThrough(createCallbacksTransformer(callbacks))
   );

package/packages/model-runtime/src/core/streams/openai/responsesStream.ts

@@ -185,7 +185,13 @@ const transformOpenAIStream = (
 
 export const OpenAIResponsesStream = (
   stream: Stream<OpenAI.Responses.ResponseStreamEvent> | ReadableStream,
-  { callbacks, provider, bizErrorTypeTransformer, inputStartAt }: OpenAIStreamOptions = {},
+  {
+    callbacks,
+    provider,
+    bizErrorTypeTransformer,
+    inputStartAt,
+    enableStreaming = true,
+  }: OpenAIStreamOptions = {},
 ) => {
   const streamStack: StreamContext = { id: '' };
 
@@ -198,7 +204,13 @@ export const OpenAIResponsesStream = (
       // 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(
+        createTokenSpeedCalculator(transformOpenAIStream, {
+          enableStreaming: enableStreaming,
+          inputStartAt,
+          streamStack,
+        }),
+      )
       .pipeThrough(createSSEProtocolTransformer((c) => c, streamStack))
       .pipeThrough(createCallbacksTransformer(callbacks))
   );

package/packages/model-runtime/src/core/streams/protocol.ts

@@ -360,7 +360,11 @@ export const TOKEN_SPEED_CHUNK_ID = 'output_speed';
  */
 export const createTokenSpeedCalculator = (
   transformer: (chunk: any, stack: StreamContext) => StreamProtocolChunk | StreamProtocolChunk[],
-  { inputStartAt, streamStack }: { inputStartAt?: number; streamStack?: StreamContext } = {},
+  {
+    inputStartAt,
+    streamStack,
+    enableStreaming = true, // 选择 TPS 计算方式（非流式时传 false）
+  }: { enableStreaming?: boolean; inputStartAt?: number; streamStack?: StreamContext } = {},
 ) => {
   let outputStartAt: number | undefined;
   let outputThinking: boolean | undefined;
@@ -397,7 +401,9 @@ export const createTokenSpeedCalculator = (
           : Math.max(0, totalOutputTokens - reasoningTokens);
       result.push({
         data: {
-          tps: (outputTokens / (Date.now() - outputStartAt)) * 1000,
+          // 非流式计算 tps 从发出请求开始算
+          tps:
+            (outputTokens / (Date.now() - (enableStreaming ? outputStartAt : inputStartAt))) * 1000,
           ttft: outputStartAt - inputStartAt,
         } as ModelSpeed,
         id: TOKEN_SPEED_CHUNK_ID,

package/packages/model-runtime/src/core/streams/qwen.ts

@@ -116,7 +116,11 @@ export const QwenAIStream = (
   stream: Stream<OpenAI.ChatCompletionChunk> | ReadableStream,
   // TODO: preserve for RFC 097
   // eslint-disable-next-line @typescript-eslint/no-unused-vars, unused-imports/no-unused-vars
-  { callbacks, inputStartAt }: { callbacks?: ChatStreamCallbacks; inputStartAt?: number } = {},
+  {
+    callbacks,
+    inputStartAt,
+    enableStreaming = true,
+  }: { callbacks?: ChatStreamCallbacks; enableStreaming?: boolean; inputStartAt?: number } = {},
 ) => {
   const streamContext: StreamContext = { id: '' };
   const readableStream =
@@ -124,7 +128,11 @@ export const QwenAIStream = (
 
   return readableStream
     .pipeThrough(
-      createTokenSpeedCalculator(transformQwenStream, { inputStartAt, streamStack: streamContext }),
+      createTokenSpeedCalculator(transformQwenStream, {
+        enableStreaming: enableStreaming,
+        inputStartAt,
+        streamStack: streamContext,
+      }),
     )
     .pipeThrough(createSSEProtocolTransformer((c) => c, streamContext))
     .pipeThrough(createCallbacksTransformer(callbacks));

package/packages/model-runtime/src/core/streams/spark.test.ts

@@ -114,7 +114,7 @@ describe('SparkAIStream', () => {
       chunks.push(chunk);
     }
 
-    expect(chunks).toHaveLength(2);
+    expect(chunks).toHaveLength(3);
     expect(chunks[0].choices[0].delta.tool_calls).toEqual([
       {
         function: {
@@ -126,7 +126,7 @@ describe('SparkAIStream', () => {
         type: 'function',
       },
     ]);
-    expect(chunks[1].choices[0].finish_reason).toBeDefined();
+    expect(chunks[2].choices[0].finish_reason).toBeDefined();
   });
 
   it('should transform streaming response with tool calls', async () => {

package/packages/model-runtime/src/core/streams/spark.ts

@@ -50,7 +50,16 @@ export function transformSparkResponseToStream(data: OpenAI.ChatCompletion) {
       };
 
       controller.enqueue(chunk);
-
+      if (data.usage) {
+        controller.enqueue({
+          choices: [],
+          created: data.created,
+          id: data.id,
+          model: data.model,
+          object: 'chat.completion.chunk',
+          usage: data.usage,
+        } as unknown as OpenAI.ChatCompletionChunk);
+      }
       controller.enqueue({
         choices: choices.map((choice: OpenAI.ChatCompletion.Choice) => ({
           delta: {

package/packages/model-runtime/src/core/streams/vertex-ai.ts

@@ -143,12 +143,18 @@ const transformVertexAIStream = (
 
 export const VertexAIStream = (
   rawStream: ReadableStream<GenerateContentResponse>,
-  { callbacks, inputStartAt }: GoogleAIStreamOptions = {},
+  { callbacks, inputStartAt, enableStreaming = true }: GoogleAIStreamOptions = {},
 ) => {
   const streamStack: StreamContext = { id: 'chat_' + nanoid() };
 
   return rawStream
-    .pipeThrough(createTokenSpeedCalculator(transformVertexAIStream, { inputStartAt, streamStack }))
+    .pipeThrough(
+      createTokenSpeedCalculator(transformVertexAIStream, {
+        enableStreaming: enableStreaming,
+        inputStartAt,
+        streamStack,
+      }),
+    )
     .pipeThrough(createSSEProtocolTransformer((c) => c, streamStack))
     .pipeThrough(createCallbacksTransformer(callbacks));
 };

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

@@ -96,9 +96,12 @@ export class LobeAzureOpenAI implements LobeRuntimeAI {
         });
       } else {
         const stream = transformResponseToStream(response as OpenAI.ChatCompletion);
-        return StreamingResponse(OpenAIStream(stream, { callbacks: options?.callback }), {
-          headers: options?.headers,
-        });
+        return StreamingResponse(
+          OpenAIStream(stream, { callbacks: options?.callback, enableStreaming: false }),
+          {
+            headers: options?.headers,
+          },
+        );
       }
     } catch (e) {
       return this.handleError(e, model);

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

@@ -83,9 +83,12 @@ export class LobeAzureAI implements LobeRuntimeAI {
 
         // the azure AI inference response is openai compatible
         const stream = transformResponseToStream(res.body as OpenAI.ChatCompletion);
-        return StreamingResponse(OpenAIStream(stream, { callbacks: options?.callback }), {
-          headers: options?.headers,
-        });
+        return StreamingResponse(
+          OpenAIStream(stream, { callbacks: options?.callback, enableStreaming: false }),
+          {
+            headers: options?.headers,
+          },
+        );
       }
     } catch (e) {
       let error = e as { [key: string]: any; code: string; message: string };

package/src/services/session/server.test.ts

@@ -195,7 +195,10 @@ describe('ServerService', () => {
     await service.updateSessionConfig('123', config, signal);
     expect(lambdaClient.session.updateSessionConfig.mutate).toBeCalledWith(
       { id: '123', value: config },
-      { signal },
+      {
+        signal,
+        context: { showNotification: false },
+      },
     );
   });
 

package/src/services/session/server.ts

@@ -56,7 +56,13 @@ export class ServerService implements ISessionService {
   };
 
   updateSessionConfig: ISessionService['updateSessionConfig'] = (id, config, signal) => {
-    return lambdaClient.session.updateSessionConfig.mutate({ id, value: config }, { signal });
+    return lambdaClient.session.updateSessionConfig.mutate(
+      { id, value: config },
+      {
+        context: { showNotification: false },
+        signal,
+      },
+    );
   };
 
   updateSessionMeta: ISessionService['updateSessionMeta'] = (id, meta, signal) => {