@lobehub/lobehub 2.0.0-next.355 → 2.0.0-next.357

package/packages/model-runtime/src/core/contextBuilders/anthropic.test.ts

@@ -281,6 +281,62 @@ describe('anthropicHelpers', () => {
       const result = await buildAnthropicMessage(message);
       expect(result).toBeUndefined();
     });
+
+    it('should handle assistant message with tool_calls but null content', async () => {
+      const message: OpenAIChatMessage = {
+        content: null as any,
+        role: 'assistant',
+        tool_calls: [
+          {
+            id: 'call1',
+            type: 'function',
+            function: {
+              name: 'search_people',
+              arguments: '{"location":"Singapore"}',
+            },
+          },
+        ],
+      };
+      const result = await buildAnthropicMessage(message);
+      expect(result!.role).toBe('assistant');
+      // null content should be filtered out, only tool_use remains
+      expect(result!.content).toEqual([
+        {
+          id: 'call1',
+          input: { location: 'Singapore' },
+          name: 'search_people',
+          type: 'tool_use',
+        },
+      ]);
+    });
+
+    it('should handle assistant message with tool_calls but empty string content', async () => {
+      const message: OpenAIChatMessage = {
+        content: '',
+        role: 'assistant',
+        tool_calls: [
+          {
+            id: 'call1',
+            type: 'function',
+            function: {
+              name: 'search_people',
+              arguments: '{"location":"Singapore"}',
+            },
+          },
+        ],
+      };
+      const result = await buildAnthropicMessage(message);
+      expect(result!.role).toBe('assistant');
+      // empty string content should be filtered out, only tool_use remains
+      expect(result!.content).toEqual([
+        {
+          id: 'call1',
+          input: { location: 'Singapore' },
+          name: 'search_people',
+          type: 'tool_use',
+        },
+      ]);
+    });
   });
 
   describe('buildAnthropicMessages', () => {
@@ -526,6 +582,320 @@ describe('anthropicHelpers', () => {
         ]);
       });
 
+      it('should handle tool message with null content', async () => {
+        const messages: OpenAIChatMessage[] = [
+          {
+            content: '搜索人员',
+            role: 'user',
+          },
+          {
+            content: '正在搜索...',
+            role: 'assistant',
+            tool_calls: [
+              {
+                function: {
+                  arguments: '{"location": "Singapore"}',
+                  name: 'search_people',
+                },
+                id: 'toolu_01CnXPcBEqsGGbvRriem3Rth',
+                type: 'function',
+              },
+            ],
+          },
+          {
+            content: null as any,
+            name: 'search_people',
+            role: 'tool',
+            tool_call_id: 'toolu_01CnXPcBEqsGGbvRriem3Rth',
+          },
+        ];
+
+        const contents = await buildAnthropicMessages(messages);
+
+        expect(contents).toEqual([
+          { content: '搜索人员', role: 'user' },
+          {
+            content: [
+              { text: '正在搜索...', type: 'text' },
+              {
+                id: 'toolu_01CnXPcBEqsGGbvRriem3Rth',
+                input: { location: 'Singapore' },
+                name: 'search_people',
+                type: 'tool_use',
+              },
+            ],
+            role: 'assistant',
+          },
+          {
+            content: [
+              {
+                content: [{ text: '<empty_content>', type: 'text' }],
+                tool_use_id: 'toolu_01CnXPcBEqsGGbvRriem3Rth',
+                type: 'tool_result',
+              },
+            ],
+            role: 'user',
+          },
+        ]);
+      });
+
+      it('should handle tool message with empty string content', async () => {
+        const messages: OpenAIChatMessage[] = [
+          {
+            content: '搜索人员',
+            role: 'user',
+          },
+          {
+            content: '正在搜索...',
+            role: 'assistant',
+            tool_calls: [
+              {
+                function: {
+                  arguments: '{"location": "Singapore"}',
+                  name: 'search_people',
+                },
+                id: 'toolu_01CnXPcBEqsGGbvRriem3Rth',
+                type: 'function',
+              },
+            ],
+          },
+          {
+            content: '',
+            name: 'search_people',
+            role: 'tool',
+            tool_call_id: 'toolu_01CnXPcBEqsGGbvRriem3Rth',
+          },
+        ];
+
+        const contents = await buildAnthropicMessages(messages);
+
+        expect(contents).toEqual([
+          { content: '搜索人员', role: 'user' },
+          {
+            content: [
+              { text: '正在搜索...', type: 'text' },
+              {
+                id: 'toolu_01CnXPcBEqsGGbvRriem3Rth',
+                input: { location: 'Singapore' },
+                name: 'search_people',
+                type: 'tool_use',
+              },
+            ],
+            role: 'assistant',
+          },
+          {
+            content: [
+              {
+                content: [{ text: '<empty_content>', type: 'text' }],
+                tool_use_id: 'toolu_01CnXPcBEqsGGbvRriem3Rth',
+                type: 'tool_result',
+              },
+            ],
+            role: 'user',
+          },
+        ]);
+      });
+
+      it('should handle tool message with array content', async () => {
+        const messages: OpenAIChatMessage[] = [
+          {
+            content: '搜索人员',
+            role: 'user',
+          },
+          {
+            content: '正在搜索...',
+            role: 'assistant',
+            tool_calls: [
+              {
+                function: {
+                  arguments: '{"location": "Singapore"}',
+                  name: 'search_people',
+                },
+                id: 'toolu_01CnXPcBEqsGGbvRriem3Rth',
+                type: 'function',
+              },
+            ],
+          },
+          {
+            content: [
+              { type: 'text', text: 'Found 5 candidates' },
+              { type: 'text', text: 'Result details here' },
+            ] as any,
+            name: 'search_people',
+            role: 'tool',
+            tool_call_id: 'toolu_01CnXPcBEqsGGbvRriem3Rth',
+          },
+        ];
+
+        const contents = await buildAnthropicMessages(messages);
+
+        expect(contents).toEqual([
+          { content: '搜索人员', role: 'user' },
+          {
+            content: [
+              { text: '正在搜索...', type: 'text' },
+              {
+                id: 'toolu_01CnXPcBEqsGGbvRriem3Rth',
+                input: { location: 'Singapore' },
+                name: 'search_people',
+                type: 'tool_use',
+              },
+            ],
+            role: 'assistant',
+          },
+          {
+            content: [
+              {
+                content: [
+                  { type: 'text', text: 'Found 5 candidates' },
+                  { type: 'text', text: 'Result details here' },
+                ],
+                tool_use_id: 'toolu_01CnXPcBEqsGGbvRriem3Rth',
+                type: 'tool_result',
+              },
+            ],
+            role: 'user',
+          },
+        ]);
+      });
+
+      it('should handle tool message with array content containing image', async () => {
+        vi.mocked(parseDataUri).mockReturnValueOnce({
+          mimeType: 'image/png',
+          base64: 'screenshotBase64Data',
+          type: 'base64',
+        });
+
+        const messages: OpenAIChatMessage[] = [
+          {
+            content: '截图分析',
+            role: 'user',
+          },
+          {
+            content: '正在截图...',
+            role: 'assistant',
+            tool_calls: [
+              {
+                function: {
+                  arguments: '{"url": "https://example.com"}',
+                  name: 'screenshot',
+                },
+                id: 'toolu_screenshot_123',
+                type: 'function',
+              },
+            ],
+          },
+          {
+            content: [
+              { type: 'text', text: 'Screenshot captured' },
+              {
+                type: 'image_url',
+                image_url: { url: 'data:image/png;base64,screenshotBase64Data' },
+              },
+            ] as any,
+            name: 'screenshot',
+            role: 'tool',
+            tool_call_id: 'toolu_screenshot_123',
+          },
+        ];
+
+        const contents = await buildAnthropicMessages(messages);
+
+        expect(contents).toEqual([
+          { content: '截图分析', role: 'user' },
+          {
+            content: [
+              { text: '正在截图...', type: 'text' },
+              {
+                id: 'toolu_screenshot_123',
+                input: { url: 'https://example.com' },
+                name: 'screenshot',
+                type: 'tool_use',
+              },
+            ],
+            role: 'assistant',
+          },
+          {
+            content: [
+              {
+                content: [
+                  { type: 'text', text: 'Screenshot captured' },
+                  {
+                    type: 'image',
+                    source: {
+                      type: 'base64',
+                      media_type: 'image/png',
+                      data: 'screenshotBase64Data',
+                    },
+                  },
+                ],
+                tool_use_id: 'toolu_screenshot_123',
+                type: 'tool_result',
+              },
+            ],
+            role: 'user',
+          },
+        ]);
+      });
+
+      it('should handle orphan tool message with null content', async () => {
+        // Tool message without corresponding assistant tool_call
+        const messages: OpenAIChatMessage[] = [
+          {
+            content: null as any,
+            name: 'some_tool',
+            role: 'tool',
+            tool_call_id: 'orphan_tool_call_id',
+          },
+          {
+            content: 'Continue',
+            role: 'user',
+          },
+        ];
+
+        const contents = await buildAnthropicMessages(messages);
+
+        expect(contents).toEqual([
+          {
+            content: '<empty_content>',
+            role: 'user',
+          },
+          {
+            content: 'Continue',
+            role: 'user',
+          },
+        ]);
+      });
+
+      it('should handle orphan tool message with empty string content', async () => {
+        // Tool message without corresponding assistant tool_call
+        const messages: OpenAIChatMessage[] = [
+          {
+            content: '',
+            name: 'some_tool',
+            role: 'tool',
+            tool_call_id: 'orphan_tool_call_id',
+          },
+          {
+            content: 'Continue',
+            role: 'user',
+          },
+        ];
+
+        const contents = await buildAnthropicMessages(messages);
+
+        expect(contents).toEqual([
+          {
+            content: '<empty_content>',
+            role: 'user',
+          },
+          {
+            content: 'Continue',
+            role: 'user',
+          },
+        ]);
+      });
+
       it('should work well starting with tool message', async () => {
         const messages: OpenAIChatMessage[] = [
           {

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

@@ -114,10 +114,13 @@ export const buildAnthropicMessage = async (
       // if there is tool_calls , we need to covert the tool_calls to tool_use content block
       // refs: https://docs.anthropic.com/claude/docs/tool-use#tool-use-and-tool-result-content-blocks
       if (message.tool_calls && message.tool_calls.length > 0) {
+        // Handle content: string with text, array, null/undefined/empty -> filter out
         const rawContent =
-          typeof content === 'string'
-            ? ([{ text: message.content, type: 'text' }] as UserMessageContentPart[])
-            : content;
+          typeof content === 'string' && content.trim()
+            ? ([{ text: content, type: 'text' }] as UserMessageContentPart[])
+            : Array.isArray(content)
+              ? content
+              : []; // null/undefined/empty string -> empty array (will be filtered)
 
         const messageContent = await buildArrayContent(rawContent);
 
@@ -180,10 +183,17 @@ export const buildAnthropicMessages = async (
 
     // refs: https://docs.anthropic.com/claude/docs/tool-use#tool-use-and-tool-result-content-blocks
     if (message.role === 'tool') {
+      // Handle different content types in tool messages
+      const toolResultContent = Array.isArray(message.content)
+        ? await buildArrayContent(message.content)
+        : !message.content
+          ? [{ text: '<empty_content>', type: 'text' as const }]
+          : [{ text: message.content, type: 'text' as const }];
+
       // 检查这个工具消息是否有对应的 assistant 工具调用
       if (message.tool_call_id && validToolCallIds.has(message.tool_call_id)) {
         pendingToolResults.push({
-          content: [{ text: message.content as string, type: 'text' }],
+          content: toolResultContent as Anthropic.ToolResultBlockParam['content'],
           tool_use_id: message.tool_call_id,
           type: 'tool_result',
         });
@@ -198,8 +208,11 @@ export const buildAnthropicMessages = async (
         }
       } else {
         // 如果工具消息没有对应的 assistant 工具调用，则作为普通文本处理
+        const fallbackContent = Array.isArray(message.content)
+          ? JSON.stringify(message.content)
+          : message.content || '<empty_content>';
         messages.push({
-          content: message.content as string,
+          content: fallbackContent,
           role: 'user',
         });
       }

package/packages/utils/src/server/__tests__/auth.test.ts

@@ -2,29 +2,6 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { extractBearerToken, getUserAuth } from '../auth';
 
-// Mock auth constants
-let mockEnableBetterAuth = false;
-let mockEnableNextAuth = false;
-
-vi.mock('@/envs/auth', () => ({
-  get enableBetterAuth() {
-    return mockEnableBetterAuth;
-  },
-  get enableNextAuth() {
-    return mockEnableNextAuth;
-  },
-}));
-
-vi.mock('@/libs/next-auth', () => ({
-  default: {
-    auth: vi.fn().mockResolvedValue({
-      user: {
-        id: 'next-auth-user-id',
-      },
-    }),
-  },
-}));
-
 vi.mock('next/headers', () => ({
   headers: vi.fn(() => new Headers()),
 }));
@@ -44,48 +21,9 @@ vi.mock('@/auth', () => ({
 describe('getUserAuth', () => {
   beforeEach(() => {
     vi.clearAllMocks();
-    mockEnableBetterAuth = false;
-    mockEnableNextAuth = false;
   });
 
-  it('should throw error when no auth method is enabled', async () => {
-    await expect(getUserAuth()).rejects.toThrow('Auth method is not enabled');
-  });
-
-  it('should return next auth when next auth is enabled', async () => {
-    mockEnableNextAuth = true;
-
-    const auth = await getUserAuth();
-
-    expect(auth).toEqual({
-      nextAuth: {
-        user: {
-          id: 'next-auth-user-id',
-        },
-      },
-      userId: 'next-auth-user-id',
-    });
-  });
-
-  it('should return better auth when better auth is enabled', async () => {
-    mockEnableBetterAuth = true;
-
-    const auth = await getUserAuth();
-
-    expect(auth).toEqual({
-      betterAuth: {
-        user: {
-          id: 'better-auth-user-id',
-        },
-      },
-      userId: 'better-auth-user-id',
-    });
-  });
-
-  it('should prioritize better auth over next auth when both are enabled', async () => {
-    mockEnableBetterAuth = true;
-    mockEnableNextAuth = true;
-
+  it('should return better auth session', async () => {
     const auth = await getUserAuth();
 
     expect(auth).toEqual({

package/packages/utils/src/server/auth.ts

@@ -1,34 +1,18 @@
 import { headers } from 'next/headers';
 
-import { enableBetterAuth, enableNextAuth } from '@/envs/auth';
+import { auth } from '@/auth';
 
 export const getUserAuth = async () => {
-  if (enableBetterAuth) {
-    const { auth: betterAuth } = await import('@/auth');
+  const currentHeaders = await headers();
+  const requestHeaders = Object.fromEntries(currentHeaders.entries());
 
-    const currentHeaders = await headers();
-    const requestHeaders = Object.fromEntries(currentHeaders.entries());
+  const session = await auth.api.getSession({
+    headers: requestHeaders,
+  });
 
-    const session = await betterAuth.api.getSession({
-      headers: requestHeaders,
-    });
+  const userId = session?.user?.id;
 
-    const userId = session?.user?.id;
-
-    return { betterAuth: session, userId };
-  }
-
-  if (enableNextAuth) {
-    const { default: NextAuth } = await import('@/libs/next-auth');
-
-    const session = await NextAuth.auth();
-
-    const userId = session?.user.id;
-
-    return { nextAuth: session, userId };
-  }
-
-  throw new Error('Auth method is not enabled');
+  return { betterAuth: session, userId };
 };
 
 /**

package/scripts/_shared/checkDeprecatedAuth.js

@@ -0,0 +1,99 @@
+/**
+ * Shared utility to check for deprecated authentication environment variables.
+ * Used by both prebuild.mts (build time) and startServer.js (Docker runtime).
+ *
+ * IMPORTANT: Keep this file as CommonJS (.js) for compatibility with startServer.js
+ */
+
+const MIGRATION_DOC_BASE = 'https://lobehub.com/docs/self-hosting/advanced/auth';
+
+/**
+ * Deprecated environment variable checks configuration
+ * @type {Array<{
+ *   name: string;
+ *   getVars: () => string[];
+ *   message: string;
+ *   docUrl?: string;
+ *   formatVar?: (envVar: string) => string;
+ * }>}
+ */
+const DEPRECATED_CHECKS = [
+  {
+    docUrl: `${MIGRATION_DOC_BASE}/nextauth-to-betterauth`,
+    getVars: () =>
+      Object.keys(process.env).filter(
+        (key) => key.startsWith('NEXT_AUTH') || key.startsWith('NEXTAUTH'),
+      ),
+    message: 'NextAuth has been removed from LobeChat. Please migrate to Better Auth.',
+    name: 'NextAuth',
+  },
+  {
+    docUrl: `${MIGRATION_DOC_BASE}/clerk-to-betterauth`,
+    getVars: () =>
+      ['NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY', 'CLERK_SECRET_KEY', 'CLERK_WEBHOOK_SECRET'].filter(
+        (key) => process.env[key],
+      ),
+    message: 'Clerk has been removed from LobeChat. Please migrate to Better Auth.',
+    name: 'Clerk',
+  },
+  {
+    formatVar: (envVar) => {
+      const mapping = {
+        NEXT_PUBLIC_AUTH_EMAIL_VERIFICATION: 'AUTH_EMAIL_VERIFICATION',
+        NEXT_PUBLIC_ENABLE_MAGIC_LINK: 'ENABLE_MAGIC_LINK',
+      };
+      return `${envVar} → Please use ${mapping[envVar]} instead`;
+    },
+    getVars: () =>
+      ['NEXT_PUBLIC_AUTH_EMAIL_VERIFICATION', 'NEXT_PUBLIC_ENABLE_MAGIC_LINK'].filter(
+        (key) => process.env[key],
+      ),
+    message: 'Please update to the new environment variable names.',
+    name: 'Deprecated Auth',
+  },
+];
+
+/**
+ * Print error message and exit
+ */
+function printErrorAndExit(name, vars, message, action, docUrl, formatVar) {
+  console.error('\n' + '═'.repeat(70));
+  console.error(`❌ ERROR: ${name} environment variables are deprecated!`);
+  console.error('═'.repeat(70));
+  console.error('\nDetected deprecated environment variables:');
+  for (const envVar of vars) {
+    console.error(`  • ${formatVar ? formatVar(envVar) : envVar}`);
+  }
+  console.error(`\n${message}`);
+  if (docUrl) {
+    console.error(`\n📖 Migration guide: ${docUrl}`);
+  }
+  console.error(`\nPlease update your environment variables and ${action}.`);
+  console.error('═'.repeat(70) + '\n');
+  process.exit(1);
+}
+
+/**
+ * Check for deprecated authentication environment variables and exit if found
+ * @param {object} options
+ * @param {string} [options.action='redeploy'] - Action hint in error message ('redeploy' or 'restart')
+ */
+function checkDeprecatedAuth(options = {}) {
+  const { action = 'redeploy' } = options;
+
+  for (const check of DEPRECATED_CHECKS) {
+    const foundVars = check.getVars();
+    if (foundVars.length > 0) {
+      printErrorAndExit(
+        check.name,
+        foundVars,
+        check.message,
+        action,
+        check.docUrl,
+        check.formatVar,
+      );
+    }
+  }
+}
+
+module.exports = { checkDeprecatedAuth };

package/scripts/clerk-to-betterauth/index.ts

@@ -13,6 +13,11 @@ const IS_DRY_RUN =
   process.argv.includes('--dry-run') || process.env.CLERK_TO_BETTERAUTH_DRY_RUN === '1';
 const formatDuration = (ms: number) => `${(ms / 1000).toFixed(1)}s`;
 
+// ANSI color codes
+const GREEN_BOLD = '\u001B[1;32m';
+const RED_BOLD = '\u001B[1;31m';
+const RESET = '\u001B[0m';
+
 function chunk<T>(items: T[], size: number): T[][] {
   if (!Number.isFinite(size) || size <= 0) return [items];
   const result: T[][] = [];
@@ -241,7 +246,7 @@ async function migrateFromClerk() {
   }
 
   console.log(
-    `[clerk-to-betterauth] completed users=${processed}, skipped=${skipped}, accounts attempted=${accountAttempts}, 2fa attempted=${twoFactorAttempts}, dryRun=${IS_DRY_RUN}, elapsed=${formatDuration(Date.now() - startedAt)}`,
+    `[clerk-to-betterauth] completed users=${GREEN_BOLD}${processed}${RESET}, skipped=${skipped}, accounts attempted=${accountAttempts}, 2fa attempted=${twoFactorAttempts}, dryRun=${IS_DRY_RUN}, elapsed=${formatDuration(Date.now() - startedAt)}`,
   );
 
   const accountCountsText = Object.entries(accountCounts)
@@ -301,10 +306,10 @@ async function main() {
   try {
     await migrateFromClerk();
     console.log('');
-    console.log(`✅ Migration success! (${formatDuration(Date.now() - startedAt)})`);
+    console.log(`${GREEN_BOLD}✅ Migration success!${RESET} (${formatDuration(Date.now() - startedAt)})`);
   } catch (error) {
     console.log('');
-    console.error(`❌ Migration failed (${formatDuration(Date.now() - startedAt)}):`, error);
+    console.error(`${RED_BOLD}❌ Migration failed${RESET} (${formatDuration(Date.now() - startedAt)}):`, error);
     process.exitCode = 1;
   } finally {
     await pool.end();