@lobehub/lobehub 2.0.0-next.194 → 2.0.0-next.195

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 # Changelog
 
+## [Version 2.0.0-next.195](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.194...v2.0.0-next.195)
+
+<sup>Released on **2026-01-03**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Fix tool call message content missing.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Fix tool call message content missing, closes [#11116](https://github.com/lobehub/lobe-chat/issues/11116) ([885964e](https://github.com/lobehub/lobe-chat/commit/885964e))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 2.0.0-next.194](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.193...v2.0.0-next.194)
 
 <sup>Released on **2026-01-03**</sup>

package/changelog/v1.json

@@ -1,4 +1,13 @@
 [
+  {
+    "children": {
+      "fixes": [
+        "Fix tool call message content missing."
+      ]
+    },
+    "date": "2026-01-03",
+    "version": "2.0.0-next.195"
+  },
   {
     "children": {
       "improvements": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.194",
+  "version": "2.0.0-next.195",
   "description": "LobeHub - an open-source,comprehensive AI Agent 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",

package/packages/database/src/models/user.ts

@@ -165,6 +165,14 @@ export class UserModel {
     return this.db.query.userSettings.findFirst({ where: eq(userSettings.id, this.userId) });
   };
 
+  getUserPreference = async (): Promise<UserPreference | undefined> => {
+    const user = await this.db.query.users.findFirst({
+      columns: { preference: true },
+      where: eq(users.id, this.userId),
+    });
+    return user?.preference as UserPreference | undefined;
+  };
+
   getUserSettingsDefaultAgentConfig = async () => {
     const result = await this.db
       .select({ defaultAgent: userSettings.defaultAgent })

package/packages/database/src/repositories/aiInfra/index.test.ts

@@ -6,10 +6,10 @@ import type {
 } from '@lobechat/types';
 import { AiProviderModelListItem, EnabledAiModel } from 'model-bank';
 import { DEFAULT_MODEL_PROVIDER_LIST } from 'model-bank/modelProviders';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { clientDB, initializeDB } from '@/database/client/db';
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 
+import { getTestDB } from '../../models/__tests__/_util';
+import { LobeChatDatabase } from '../../type';
 import { AiInfraRepos } from './index';
 
 const userId = 'test-user-id';
@@ -18,15 +18,18 @@ const mockProviderConfigs = {
   anthropic: { enabled: false },
 };
 
+let serverDB: LobeChatDatabase;
 let repo: AiInfraRepos;
 
-beforeEach(async () => {
-  await initializeDB();
-  vi.clearAllMocks();
-
-  repo = new AiInfraRepos(clientDB as any, userId, mockProviderConfigs);
+beforeAll(async () => {
+  serverDB = await getTestDB();
 }, 30000);
 
+beforeEach(() => {
+  vi.clearAllMocks();
+  repo = new AiInfraRepos(serverDB, userId, mockProviderConfigs);
+});
+
 describe('AiInfraRepos', () => {
   describe('getAiProviderList', () => {
     it('should merge builtin and user providers correctly', async () => {

package/packages/database/src/repositories/dataExporter/index.test.ts

@@ -1,7 +1,6 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { clientDB, initializeDB } from '@/database/client/db';
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 
+import { getTestDB } from '../../models/__tests__/_util';
 import {
   agents,
   agentsKnowledgeBases,
@@ -21,7 +20,7 @@ import {
 import { LobeChatDatabase } from '../../type';
 import { DATA_EXPORT_CONFIG, DataExporterRepos } from './index';
 
-let db = clientDB as LobeChatDatabase;
+let db: LobeChatDatabase;
 
 // 设置测试数据
 describe('DataExporterRepos', () => {
@@ -38,7 +37,11 @@ describe('DataExporterRepos', () => {
   };
 
   // 设置测试环境
-  let userId: string = testIds.userId;
+  const userId: string = testIds.userId;
+
+  beforeAll(async () => {
+    db = await getTestDB();
+  }, 30000);
 
   const setupTestData = async () => {
     await db.transaction(async (trx) => {
@@ -152,10 +155,9 @@ describe('DataExporterRepos', () => {
   };
 
   beforeEach(async () => {
-    // 创建内存数据库
-    await initializeDB();
-
-    // 插入测试数据
+    // 清理并插入测试数据
+    await db.delete(users);
+    await db.delete(globalFiles);
     await setupTestData();
   }, 30000);
 

package/packages/database/src/repositories/tableViewer/index.test.ts

@@ -1,11 +1,10 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { clientDB, initializeDB } from '@/database/client/db';
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 
+import { getTestDB } from '../../models/__tests__/_util';
+import { LobeChatDatabase } from '../../type';
 import { TableViewerRepo } from './index';
 
 const userId = 'user-table-viewer';
-const repo = new TableViewerRepo(clientDB as any, userId);
 
 // Mock database execution
 const mockExecute = vi.fn();
@@ -13,20 +12,20 @@ const mockDB = {
   execute: mockExecute,
 };
 
-beforeEach(async () => {
-  await initializeDB();
-  vi.clearAllMocks();
+let serverDB: LobeChatDatabase;
+let repo: TableViewerRepo;
+
+beforeAll(async () => {
+  serverDB = await getTestDB();
+  repo = new TableViewerRepo(serverDB, userId);
 }, 30000);
 
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
 describe('TableViewerRepo', () => {
   describe('getAllTables', () => {
-    it('should return all tables with counts', async () => {
-      const result = await repo.getAllTables();
-
-      expect(result.length).toEqual(73);
-      expect(result[0]).toEqual({ name: 'accounts', count: 0, type: 'BASE TABLE' });
-    });
-
     it('should handle custom schema', async () => {
       const result = await repo.getAllTables('custom_schema');
       expect(result).toBeDefined();

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

@@ -29,7 +29,7 @@ export const params = {
               type: 'web_search',
               web_search: {
                 enable: true,
-                result_sequence: 'before', // 将搜索结果返回顺序更改为 before 适配最小化 OpenAIStream 改动
+                result_sequence: 'before', // Change search result return sequence to 'before' to minimize OpenAIStream modifications
                 search_engine: process.env.ZHIPU_SEARCH_ENGINE || 'search_std', // search_std, search_pro
                 search_result: true,
               },
@@ -69,16 +69,16 @@ export const params = {
       const readableStream =
         stream instanceof ReadableStream ? stream : convertIterableToStream(stream);
 
-      // GLM-4.5 系列模型在 tool_calls 中返回的 index 为 -1，需要在进入 OpenAIStream 之前修正
-      // 因为 OpenAIStream 内部会过滤掉 index < 0 的 tool_calls (openai.ts:58-60)
+      // GLM-4.5 series models return index -1 in tool_calls, needs to be fixed before entering OpenAIStream
+      // because OpenAIStream internally filters out tool_calls with index < 0 (openai.ts:58-60)
       const preprocessedStream = readableStream.pipeThrough(
         new TransformStream({
           transform(chunk, controller) {
-            // 处理原始的 OpenAI ChatCompletionChunk 格式
+            // Handle raw OpenAI ChatCompletionChunk format
             if (chunk.choices && chunk.choices[0]) {
               const choice = chunk.choices[0];
               if (choice.delta?.tool_calls && Array.isArray(choice.delta.tool_calls)) {
-                // 修正负数 index，将 -1 转换为基于数组位置的正数 index
+                // Fix negative index, convert -1 to positive index based on array position
                 const fixedToolCalls = choice.delta.tool_calls.map(
                   (toolCall: any, globalIndex: number) => ({
                     ...toolCall,
@@ -86,7 +86,7 @@ export const params = {
                   }),
                 );
 
-                // 创建修正后的 chunk
+                // Create fixed chunk
                 const fixedChunk = {
                   ...chunk,
                   choices: [

package/src/envs/app.ts

@@ -82,6 +82,7 @@ export const getAppConfig = () => {
        * @default false
        */
       enableQueueAgentRuntime: z.boolean().optional(),
+      TELEMETRY_DISABLED: z.boolean().optional(),
     },
     runtimeEnv: {
       // Sentry
@@ -121,6 +122,7 @@ export const getAppConfig = () => {
       MARKET_TRUSTED_CLIENT_ID: process.env.MARKET_TRUSTED_CLIENT_ID,
 
       enableQueueAgentRuntime: process.env.AGENT_RUNTIME_MODE === 'queue',
+      TELEMETRY_DISABLED: process.env.TELEMETRY_DISABLED === '1',
     },
   });
 };

package/src/libs/trpc/lambda/middleware/index.ts

@@ -1,3 +1,4 @@
 export * from './keyVaults';
 export * from './marketUserInfo';
 export * from './serverDatabase';
+export * from './telemetry';

package/src/libs/trpc/lambda/middleware/telemetry.test.ts

@@ -0,0 +1,237 @@
+// @vitest-environment node
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { appEnv } from '@/envs/app';
+
+import { TelemetryContext, checkTelemetryEnabled } from './telemetry';
+
+const { mockGetUserSettings, mockGetUserPreference, MockUserModel } = vi.hoisted(() => {
+  const mockGetUserSettings = vi.fn();
+  const mockGetUserPreference = vi.fn();
+  const MockUserModel = vi.fn().mockImplementation(() => ({
+    getUserPreference: mockGetUserPreference,
+    getUserSettings: mockGetUserSettings,
+  })) as any;
+  return { MockUserModel, mockGetUserPreference, mockGetUserSettings };
+});
+
+vi.mock('@/envs/app', () => ({
+  appEnv: {
+    TELEMETRY_DISABLED: false,
+  },
+}));
+
+vi.mock('@/database/models/user', () => ({
+  UserModel: MockUserModel,
+}));
+
+describe('checkTelemetryEnabled', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Reset appEnv mock
+    vi.mocked(appEnv).TELEMETRY_DISABLED = false;
+    // Default mock returns
+    mockGetUserSettings.mockResolvedValue(null);
+    mockGetUserPreference.mockResolvedValue(null);
+  });
+
+  describe('environment variable priority (highest)', () => {
+    it('should return telemetryEnabled: false when TELEMETRY_DISABLED=true', async () => {
+      vi.mocked(appEnv).TELEMETRY_DISABLED = true;
+
+      const result = await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      expect(result).toEqual({ telemetryEnabled: false });
+      // Should not call database
+      expect(mockGetUserSettings).not.toHaveBeenCalled();
+    });
+
+    it('should check database when TELEMETRY_DISABLED is false', async () => {
+      await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      expect(mockGetUserSettings).toHaveBeenCalled();
+    });
+
+    it('should check database when TELEMETRY_DISABLED is undefined', async () => {
+      vi.mocked(appEnv).TELEMETRY_DISABLED = undefined;
+
+      await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      expect(mockGetUserSettings).toHaveBeenCalled();
+    });
+  });
+
+  describe('user_settings.general.telemetry', () => {
+    it('should return telemetryEnabled: true when settings.general.telemetry is true and preference is not set', async () => {
+      mockGetUserSettings.mockResolvedValue({
+        general: { telemetry: true },
+      });
+      mockGetUserPreference.mockResolvedValue(null);
+
+      const result = await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      expect(result).toEqual({ telemetryEnabled: true });
+    });
+
+    it('should return telemetryEnabled: false from settings.general', async () => {
+      mockGetUserSettings.mockResolvedValue({
+        general: { telemetry: false },
+      });
+
+      const result = await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      expect(result).toEqual({ telemetryEnabled: false });
+    });
+
+    it('should check preference when settings.general.telemetry is not set', async () => {
+      mockGetUserSettings.mockResolvedValue({
+        general: { fontSize: 14 }, // no telemetry field
+      });
+      mockGetUserPreference.mockResolvedValue({ telemetry: true });
+
+      const result = await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      // Should fall back to preference.telemetry
+      expect(result).toEqual({ telemetryEnabled: true });
+      expect(mockGetUserPreference).toHaveBeenCalled();
+    });
+  });
+
+  describe('users.preference.telemetry (deprecated, fallback)', () => {
+    it('should return telemetryEnabled: true from preference.telemetry', async () => {
+      mockGetUserSettings.mockResolvedValue(null);
+      mockGetUserPreference.mockResolvedValue({ telemetry: true });
+
+      const result = await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      expect(result).toEqual({ telemetryEnabled: true });
+    });
+
+    it('should return telemetryEnabled: false from preference.telemetry', async () => {
+      mockGetUserSettings.mockResolvedValue(null);
+      mockGetUserPreference.mockResolvedValue({ telemetry: false });
+
+      const result = await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      expect(result).toEqual({ telemetryEnabled: false });
+    });
+
+    it('should use preference.telemetry when settings.general.telemetry is not false', async () => {
+      mockGetUserSettings.mockResolvedValue({
+        general: { telemetry: true },
+      });
+      mockGetUserPreference.mockResolvedValue({ telemetry: false });
+
+      const result = await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      // preference.telemetry is checked when settings.general.telemetry is not false
+      expect(result).toEqual({ telemetryEnabled: false });
+      expect(mockGetUserPreference).toHaveBeenCalled();
+    });
+
+    it('should not call getUserPreference when settings.general.telemetry is explicitly false', async () => {
+      mockGetUserSettings.mockResolvedValue({
+        general: { telemetry: false },
+      });
+      mockGetUserPreference.mockResolvedValue({ telemetry: true });
+
+      const result = await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      expect(result).toEqual({ telemetryEnabled: false });
+      expect(mockGetUserPreference).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('default value', () => {
+    it('should default to true when settings is null', async () => {
+      mockGetUserSettings.mockResolvedValue(null);
+
+      const result = await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      // Default to true (enabled) unless explicitly disabled
+      expect(result).toEqual({ telemetryEnabled: true });
+    });
+
+    it('should default to true when general is null', async () => {
+      mockGetUserSettings.mockResolvedValue({
+        general: null,
+      });
+
+      const result = await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      // Default to true (enabled) unless explicitly disabled
+      expect(result).toEqual({ telemetryEnabled: true });
+    });
+  });
+
+  describe('missing context', () => {
+    it('should return telemetryEnabled: false when userId is missing', async () => {
+      const result = await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: null,
+      });
+
+      expect(result).toEqual({ telemetryEnabled: false });
+      expect(mockGetUserSettings).not.toHaveBeenCalled();
+    });
+
+    it('should return telemetryEnabled: false when serverDB is missing', async () => {
+      const result = await checkTelemetryEnabled({
+        serverDB: undefined,
+        userId: 'test-user',
+      });
+
+      expect(result).toEqual({ telemetryEnabled: false });
+      expect(mockGetUserSettings).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('error handling', () => {
+    it('should return telemetryEnabled: false when getUserSettings fails', async () => {
+      mockGetUserSettings.mockRejectedValue(new Error('Database error'));
+
+      const result = await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      expect(result).toEqual({ telemetryEnabled: false });
+    });
+  });
+});

package/src/libs/trpc/lambda/middleware/telemetry.ts

@@ -0,0 +1,74 @@
+import type { LobeChatDatabase } from '@lobechat/database';
+import type { UserGeneralConfig } from '@lobechat/types';
+
+import { UserModel } from '@/database/models/user';
+import { appEnv } from '@/envs/app';
+
+import { trpc } from '../init';
+
+export interface TelemetryContext {
+  serverDB?: LobeChatDatabase;
+  userId?: string | null;
+}
+
+export interface TelemetryResult {
+  telemetryEnabled: boolean;
+}
+
+/**
+ * Check if telemetry is enabled for the current user
+ *
+ * Priority:
+ * 1. Environment variable TELEMETRY_DISABLED=1 → telemetryEnabled: false (highest priority)
+ * 2. User settings from database user_settings.general.telemetry (new location)
+ * 3. User preference from database users.preference.telemetry (old location, deprecated)
+ * 4. Default to true if not explicitly set
+ */
+export const checkTelemetryEnabled = async (ctx: TelemetryContext): Promise<TelemetryResult> => {
+  // Priority 1: Check environment variable (highest priority)
+  if (appEnv.TELEMETRY_DISABLED) {
+    return { telemetryEnabled: false };
+  }
+
+  // If userId or serverDB is not available, default to disabled
+  if (!ctx.userId || !ctx.serverDB) {
+    return { telemetryEnabled: false };
+  }
+
+  try {
+    const userModel = new UserModel(ctx.serverDB, ctx.userId);
+
+    // Priority 2: Check user settings (new location: settings.general.telemetry)
+    const settings = await userModel.getUserSettings();
+    const generalConfig = settings?.general as UserGeneralConfig | null | undefined;
+
+    if (generalConfig?.telemetry === false) {
+      return { telemetryEnabled: false };
+    }
+
+    // Priority 3: Check user preference (old location: preference.telemetry)
+    const preference = await userModel.getUserPreference();
+
+    if (typeof preference?.telemetry === 'boolean') {
+      return { telemetryEnabled: preference?.telemetry };
+    }
+
+    // Priority 4: Default to true if not explicitly set
+    return { telemetryEnabled: true };
+  } catch {
+    // If fetching user settings fails, default to disabled
+    return { telemetryEnabled: false };
+  }
+};
+
+/**
+ * Middleware that checks if telemetry is enabled for the current user
+ * and adds telemetryEnabled to the context
+ *
+ * Requires serverDatabase middleware to be applied first
+ */
+export const telemetry = trpc.middleware(async (opts) => {
+  const result = await checkTelemetryEnabled(opts.ctx as TelemetryContext);
+
+  return opts.next({ ctx: result });
+});

package/src/server/routers/lambda/market/index.ts

@@ -4,15 +4,9 @@ import { serialize } from 'cookie';
 import debug from 'debug';
 import { z } from 'zod';
 
-import { type ToolCallContent } from '@/libs/mcp';
-import { authedProcedure, publicProcedure, router } from '@/libs/trpc/lambda';
+import { publicProcedure, router } from '@/libs/trpc/lambda';
 import { marketUserInfo, serverDatabase } from '@/libs/trpc/lambda/middleware';
 import { DiscoverService } from '@/server/services/discover';
-import { FileService } from '@/server/services/file';
-import {
-  contentBlocksToString,
-  processContentBlocks,
-} from '@/server/services/mcp/contentProcessor';
 import {
   AssistantSorts,
   McpConnectionType,
@@ -41,93 +35,7 @@ const marketProcedure = publicProcedure
     });
   });
 
-// Procedure with user authentication for operations requiring user access token
-const authedMarketProcedure = authedProcedure
-  .use(serverDatabase)
-  .use(marketUserInfo)
-  .use(async ({ ctx, next }) => {
-    const { UserModel } = await import('@/database/models/user');
-    const userModel = new UserModel(ctx.serverDB, ctx.userId);
-
-    return next({
-      ctx: {
-        discoverService: new DiscoverService({
-          accessToken: ctx.marketAccessToken,
-          userInfo: ctx.marketUserInfo,
-        }),
-        fileService: new FileService(ctx.serverDB, ctx.userId),
-        userModel,
-      },
-    });
-  });
-
 export const marketRouter = router({
-  // ============================== Cloud MCP Gateway ==============================
-  callCloudMcpEndpoint: authedMarketProcedure
-    .input(
-      z.object({
-        apiParams: z.record(z.any()),
-        identifier: z.string(),
-        toolName: z.string(),
-      }),
-    )
-    .mutation(async ({ input, ctx }) => {
-      log('callCloudMcpEndpoint input: %O', input);
-
-      try {
-        // Query user_settings to get market.accessToken
-        const userState = await ctx.userModel.getUserState(async () => ({}));
-        const userAccessToken = userState.settings?.market?.accessToken;
-
-        log('callCloudMcpEndpoint: userAccessToken exists=%s', !!userAccessToken);
-
-        if (!userAccessToken) {
-          throw new TRPCError({
-            code: 'UNAUTHORIZED',
-            message: 'User access token not found. Please sign in to Market first.',
-          });
-        }
-
-        const cloudResult = await ctx.discoverService.callCloudMcpEndpoint({
-          apiParams: input.apiParams,
-          identifier: input.identifier,
-          toolName: input.toolName,
-          userAccessToken,
-        });
-        const cloudResultContent = (cloudResult?.content ?? []) as ToolCallContent[];
-
-        // Format the cloud result to MCPToolCallResult format
-        // Process content blocks (upload images, etc.)
-        const newContent =
-          cloudResult?.isError || !ctx.fileService
-            ? cloudResultContent
-            : // FIXME: the type assertion here is a temporary solution, need to remove it after refactoring
-              await processContentBlocks(cloudResultContent, ctx.fileService);
-
-        // Convert content blocks to string
-        const content = contentBlocksToString(newContent);
-        const state = { ...cloudResult, content: newContent };
-
-        if (cloudResult?.isError) {
-          return { content, state, success: true };
-        }
-
-        return { content, state, success: true };
-      } catch (error) {
-        log('Error calling cloud MCP endpoint: %O', error);
-
-        // Re-throw TRPCError as-is
-        if (error instanceof TRPCError) {
-          throw error;
-        }
-
-        throw new TRPCError({
-          code: 'INTERNAL_SERVER_ERROR',
-          message: 'Failed to call cloud MCP endpoint',
-        });
-      }
-    }),
-
   // ============================== Assistant Market ==============================
   getAssistantCategories: marketProcedure
     .input(