@lobehub/lobehub 2.0.0-next.201 → 2.0.0-next.202

package/src/features/Conversation/Messages/AssistantGroup/Tool/Render/index.tsx

@@ -53,8 +53,28 @@ const Render = memo<RenderProps>(
     toolMessageId,
     isArgumentsStreaming,
   }) => {
+    if (toolMessageId && intervention?.status === 'pending') {
+      return (
+        <Intervention
+          apiName={apiName}
+          id={toolMessageId}
+          identifier={identifier}
+          requestArgs={requestArgs || ''}
+          toolCallId={toolCallId}
+        />
+      );
+    }
+
+    if (intervention?.status === 'rejected') {
+      return <RejectedResponse reason={intervention.rejectedReason} />;
+    }
+
+    if (intervention?.status === 'aborted') {
+      return <AbortResponse />;
+    }
+
     // Handle arguments streaming state
-    if (isArgumentsStreaming) {
+    if (isArgumentsStreaming || !result) {
       // Check if there's a custom streaming renderer for this tool
       const StreamingRenderer = getBuiltinStreaming(identifier, apiName);
 
@@ -76,28 +96,6 @@ const Render = memo<RenderProps>(
       return null;
     }
 
-    if (toolMessageId && intervention?.status === 'pending') {
-      return (
-        <Intervention
-          apiName={apiName}
-          id={toolMessageId}
-          identifier={identifier}
-          requestArgs={requestArgs || ''}
-          toolCallId={toolCallId}
-        />
-      );
-    }
-
-    if (intervention?.status === 'rejected') {
-      return <RejectedResponse reason={intervention.rejectedReason} />;
-    }
-
-    if (intervention?.status === 'aborted') {
-      return <AbortResponse />;
-    }
-
-    if (!result) return null;
-
     // Handle error state
     if (result.error) {
       return (

package/src/features/Conversation/Messages/AssistantGroup/components/ContentBlock.tsx

@@ -1,4 +1,4 @@
-import { Flexbox } from '@lobehub/ui';
+import { Flexbox, Highlighter } from '@lobehub/ui';
 import { memo, useCallback } from 'react';
 
 import { LOADING_FLAT } from '@/const/message';
@@ -33,18 +33,31 @@ const ContentBlock = memo<ContentBlockProps>(
       continueGeneration(assistantId);
     }, [id]);
 
-    if (error && (content === LOADING_FLAT || !content))
+    if (error && (content === LOADING_FLAT || !content)) {
       return (
         <ErrorContent
           error={
             errorContent && error && (content === LOADING_FLAT || !content)
-              ? errorContent
+              ? {
+                  ...errorContent,
+                  extra: error?.body && (
+                    <Highlighter
+                      actionIconSize={'small'}
+                      language={'json'}
+                      padding={8}
+                      variant={'borderless'}
+                    >
+                      {JSON.stringify(error?.body, null, 2)}
+                    </Highlighter>
+                  ),
+                }
               : undefined
           }
           id={id}
           onRegenerate={handleRegenerate}
         />
       );
+    }
 
     return (
       <Flexbox gap={8} id={id}>

package/src/features/Conversation/Messages/Task/TaskDetailPanel/index.tsx

@@ -1,6 +1,5 @@
 'use client';
 
-import { Block, Text } from '@lobehub/ui';
 import { memo } from 'react';
 
 import { type TaskDetail } from '@/types/index';
@@ -17,25 +16,23 @@ interface TaskDetailPanelProps {
   taskDetail?: TaskDetail;
 }
 
-const TaskDetailPanel = memo<TaskDetailPanelProps>(
-  ({ taskDetail, instruction, content, messageId }) => {
-    return (
-      <>
-        {/* Instruction Header */}
-        {instruction && (
-          <Block padding={12}>
-            <Text fontSize={13} type={'secondary'}>
-              {instruction}
-            </Text>
-          </Block>
-        )}
-
-        {/* Status Content */}
-        <StatusContent content={content} messageId={messageId} taskDetail={taskDetail} />
-      </>
-    );
-  },
-);
+const TaskDetailPanel = memo<TaskDetailPanelProps>(({ taskDetail, content, messageId }) => {
+  return (
+    <>
+      {/* Instruction Header */}
+      {/*{instruction && (*/}
+      {/*  <Block padding={12}>*/}
+      {/*    <Text fontSize={13} type={'secondary'}>*/}
+      {/*      {instruction}*/}
+      {/*    </Text>*/}
+      {/*  </Block>*/}
+      {/*)}*/}
+
+      {/* Status Content */}
+      <StatusContent content={content} messageId={messageId} taskDetail={taskDetail} />
+    </>
+  );
+});
 
 TaskDetailPanel.displayName = 'TaskDetailPanel';
 

package/src/features/Conversation/Messages/Tasks/shared/ErrorState.tsx

@@ -1,6 +1,6 @@
 'use client';
 
-import { Alert, Flexbox } from '@lobehub/ui';
+import { Alert, Flexbox, Highlighter } from '@lobehub/ui';
 import { createStaticStyles } from 'antd-style';
 import { MessageSquare, Timer, Wrench } from 'lucide-react';
 import { memo, useMemo } from 'react';
@@ -49,23 +49,28 @@ const ErrorState = memo<ErrorStateProps>(({ taskDetail }) => {
   const formattedDuration = useMemo(() => formatDuration(duration), [duration]);
   const formattedCost = useMemo(() => formatCost(totalCost), [totalCost]);
 
-  const hasMetrics = formattedDuration || totalToolCalls || totalMessages || formattedCost;
+  const hasMetrics = !!(formattedDuration || totalToolCalls || totalMessages || formattedCost);
 
   return (
     <Flexbox gap={12}>
       {/* Error Content */}
       <Alert
-        description={error}
-        title={
-          isCancelled
-            ? t('task.status.cancelled', { defaultValue: 'Cancelled' })
-            : t('task.status.failed', { defaultValue: 'Failed' })
+        extra={
+          error?.error?.body && (
+            <Highlighter
+              actionIconSize={'small'}
+              language={'json'}
+              padding={8}
+              variant={'borderless'}
+            >
+              {JSON.stringify(error?.error?.body, null, 2)}
+            </Highlighter>
+          )
         }
+        title={isCancelled ? t('task.status.cancelled') : t('task.status.failed')}
         type={'secondary'}
       />
-
-      {/* Footer with metrics */}
-      {hasMetrics && (
+      {hasMetrics ? (
         <Flexbox align="center" gap={12} horizontal wrap="wrap">
           {/* Duration */}
           {formattedDuration && <MetricItem icon={Timer} value={formattedDuration} />}
@@ -102,7 +107,7 @@ const ErrorState = memo<ErrorStateProps>(({ taskDetail }) => {
             </>
           )}
         </Flexbox>
-      )}
+      ) : null}
     </Flexbox>
   );
 });

package/src/features/Conversation/Messages/Tasks/shared/InitializingState.tsx

@@ -2,10 +2,12 @@
 
 import { Flexbox, Text } from '@lobehub/ui';
 import { createStaticStyles, keyframes } from 'antd-style';
-import { Loader2 } from 'lucide-react';
 import { memo } from 'react';
 import { useTranslation } from 'react-i18next';
 
+import NeuralNetworkLoading from '@/components/NeuralNetworkLoading';
+import { shinyTextStyles } from '@/styles';
+
 const shimmer = keyframes`
   0% {
     transform: translateX(-100%);
@@ -16,20 +18,9 @@ const shimmer = keyframes`
   }
 `;
 
-const spin = keyframes`
-  from {
-    transform: rotate(0deg);
-  }
-
-  to {
-    transform: rotate(360deg);
-  }
-`;
-
 const styles = createStaticStyles(({ css, cssVar }) => ({
   container: css`
     padding-block: 12px;
-    padding-inline: 16px;
   `,
   progress: css`
     position: relative;
@@ -53,9 +44,6 @@ const styles = createStaticStyles(({ css, cssVar }) => ({
 
     animation: ${shimmer} 2s infinite;
   `,
-  spin: css`
-    animation: ${spin} 1s linear infinite;
-  `,
 }));
 
 const InitializingState = memo(() => {
@@ -63,15 +51,13 @@ const InitializingState = memo(() => {
 
   return (
     <Flexbox className={styles.container} gap={12}>
-      {/* Status Row */}
       <Flexbox align="center" gap={8} horizontal>
-        <Loader2 className={styles.spin} size={14} />
-        <Text fontSize={13} type={'secondary'} weight={500}>
-          {t('task.status.initializing', { defaultValue: 'Starting task...' })}
+        <NeuralNetworkLoading size={14} />
+        <Text className={shinyTextStyles.shinyText} weight={500}>
+          {t('task.status.initializing')}
         </Text>
       </Flexbox>
 
-      {/* Progress Bar (indeterminate) */}
       <div className={styles.progress}>
         <div className={styles.progressShimmer} />
       </div>

package/src/features/Conversation/Messages/Tasks/shared/ProcessingState.tsx

@@ -3,10 +3,11 @@
 import { type TaskDetail } from '@lobechat/types';
 import { Flexbox, Text } from '@lobehub/ui';
 import { createStaticStyles, keyframes } from 'antd-style';
-import { Footprints, Loader2, Timer, Wrench } from 'lucide-react';
+import { Footprints, Timer, Wrench } from 'lucide-react';
 import { memo, useEffect, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 
+import NeuralNetworkLoading from '@/components/NeuralNetworkLoading';
 import { useChatStore } from '@/store/chat';
 
 import { MAX_PROGRESS, PROGRESS_INCREMENT, PROGRESS_INTERVAL } from './constants';
@@ -22,16 +23,6 @@ const shimmer = keyframes`
   }
 `;
 
-const spin = keyframes`
-  from {
-    transform: rotate(0deg);
-  }
-
-  to {
-    transform: rotate(360deg);
-  }
-`;
-
 const styles = createStaticStyles(({ css, cssVar }) => ({
   activityRow: css`
     display: flex;
@@ -52,7 +43,7 @@ const styles = createStaticStyles(({ css, cssVar }) => ({
 
     height: 3px;
     margin-block: 12px;
-    margin-inline: 16px;
+    margin-inline: 8px;
     border-radius: 2px;
 
     background: ${cssVar.colorFillSecondary};
@@ -97,9 +88,6 @@ const styles = createStaticStyles(({ css, cssVar }) => ({
     border-radius: 50%;
     background: ${cssVar.colorTextQuaternary};
   `,
-  spin: css`
-    animation: ${spin} 1s linear infinite;
-  `,
 }));
 
 export type ProcessingStateVariant = 'detail' | 'compact';
@@ -215,10 +203,12 @@ const ProcessingState = memo<ProcessingStateProps>(
           {/* Current Activity */}
           {currentActivity && (
             <div className={styles.activityRow}>
-              <Text as={'span'} fontSize={12} type={'secondary'}>
-                <Loader2 className={styles.spin} size={12} />
-                <span>{renderActivityText()}</span>
-              </Text>
+              <Flexbox align={'center'} gap={4} horizontal>
+                <NeuralNetworkLoading size={14} />
+                <Text as={'span'} fontSize={12} type={'secondary'}>
+                  {renderActivityText()}
+                </Text>
+              </Flexbox>
               {currentActivity.contentPreview && (
                 <Text
                   as={'span'}
@@ -297,7 +287,7 @@ const ProcessingState = memo<ProcessingStateProps>(
         {/* Current Activity */}
         {currentActivity && (
           <Flexbox align="center" gap={8} horizontal>
-            <Loader2 className={styles.spin} size={12} />
+            <NeuralNetworkLoading size={14} />
             <Text
               as={'span'}
               ellipsis

package/src/features/User/DataStatistics.tsx

@@ -1,13 +1,13 @@
 'use client';
 
-import { Flexbox, type FlexboxProps, Icon, Tooltip } from '@lobehub/ui';
+import { Flexbox, type FlexboxProps, Tooltip } from '@lobehub/ui';
 import { Badge } from 'antd';
 import { createStaticStyles, cssVar } from 'antd-style';
 import { isUndefined } from 'es-toolkit/compat';
-import { LoaderCircle } from 'lucide-react';
-import { memo, useMemo } from 'react';
+import { memo } from 'react';
 import { useTranslation } from 'react-i18next';
 
+import NeuralNetworkLoading from '@/components/NeuralNetworkLoading';
 import { useClientDataSWR } from '@/libs/swr';
 import { messageService } from '@/services/message';
 import { sessionService } from '@/services/session';
@@ -65,7 +65,7 @@ const DataStatistics = memo<Omit<FlexboxProps, 'children'>>(({ style, ...rest })
 
   const { t } = useTranslation('common');
 
-  const loading = useMemo(() => <Icon icon={LoaderCircle} spin />, []);
+  const loading = <NeuralNetworkLoading size={20} />;
 
   const items = [
     {

package/src/hooks/useQueryParam.ts

@@ -103,8 +103,6 @@ export function useQueryParam<T>(
               newSearchParams.set(key, serialized);
             }
 
-            console.log('updateParams', newSearchParams.toString());
-
             return newSearchParams;
           },
           { replace: currentHistory === 'replace' },

package/src/libs/trpc/async/asyncAuth.ts

@@ -43,11 +43,9 @@ export const asyncAuth = asyncTrpc.middleware(async (opts) => {
     }
 
     log('User authentication successful: %s', ctx.userId);
-    log('Passing jwtPayload keys: %O', Object.keys(ctx.jwtPayload || {}));
 
     return opts.next({
       ctx: {
-        jwtPayload: ctx.jwtPayload,
         userId: ctx.userId,
       },
     });

package/src/libs/trpc/async/context.ts

@@ -1,5 +1,4 @@
 import { type LobeChatDatabase } from '@lobechat/database';
-import { type ClientSecretPayload } from '@lobechat/types';
 import debug from 'debug';
 import { type NextRequest } from 'next/server';
 
@@ -10,7 +9,6 @@ const log = debug('lobe-async:context');
 
 export interface AsyncAuthContext {
   authorizationToken?: string;
-  jwtPayload: ClientSecretPayload;
   serverDB?: LobeChatDatabase;
   userId?: string | null;
 }
@@ -21,11 +19,9 @@ export interface AsyncAuthContext {
  */
 export const createAsyncContextInner = async (params?: {
   authorizationToken?: string;
-  jwtPayload?: ClientSecretPayload;
   userId?: string | null;
 }): Promise<AsyncAuthContext> => ({
   authorizationToken: params?.authorizationToken,
-  jwtPayload: params?.jwtPayload || {},
   userId: params?.userId,
 });
 
@@ -60,15 +56,11 @@ export const createAsyncRouteContext = async (request: NextRequest): Promise<Asy
     const { plaintext } = await gateKeeper.decrypt(lobeChatAuthorization);
 
     log('Parsing decrypted authorization data');
-    const { userId, payload } = JSON.parse(plaintext);
+    const { userId } = JSON.parse(plaintext);
 
-    log(
-      'Successfully parsed authorization data - userId: %s, payload keys: %O',
-      userId,
-      Object.keys(payload || {}),
-    );
+    log('Successfully parsed authorization data - userId: %s', userId);
 
-    return createAsyncContextInner({ authorizationToken: authorization, jwtPayload: payload, userId });
+    return createAsyncContextInner({ authorizationToken: authorization, userId });
   } catch (error) {
     log('Error creating async route context: %O', error);
     throw error;

package/src/locales/default/chat.ts

@@ -322,6 +322,8 @@ export default {
   'task.batchTasks': '{{count}} Batch Subtasks',
   'task.metrics.stepsShort': 'steps',
   'task.metrics.toolCallsShort': 'tool uses',
+  'task.status.cancelled': 'Task Cancelled',
+  'task.status.failed': 'Task Failed',
   'task.status.initializing': 'Initializing task...',
   'task.subtask': 'Subtask',
   'thread.divider': 'Subtopic',

package/src/locales/default/plugin.ts

@@ -63,7 +63,8 @@ export default {
   'builtins.lobe-gtd.apiName.createPlan.result': 'Create plan: <goal>{{goal}}</goal>',
   'builtins.lobe-gtd.apiName.createTodos': 'Create todos',
   'builtins.lobe-gtd.apiName.execTask': 'Execute task',
-  'builtins.lobe-gtd.apiName.execTask.result': 'Execute: <desc>{{description}}</desc>',
+  'builtins.lobe-gtd.apiName.execTask.completed': 'Task created: ',
+  'builtins.lobe-gtd.apiName.execTask.loading': 'Creating task: ',
   'builtins.lobe-gtd.apiName.execTasks': 'Execute tasks',
   'builtins.lobe-gtd.apiName.removeTodos': 'Delete todos',
   'builtins.lobe-gtd.apiName.updatePlan': 'Update plan',

package/src/server/modules/AgentRuntime/RuntimeExecutors.ts

@@ -8,12 +8,13 @@ import {
 } from '@lobechat/agent-runtime';
 import { ToolNameResolver } from '@lobechat/context-engine';
 import { consumeStreamUntilDone } from '@lobechat/model-runtime';
-import { type ChatToolPayload, type ClientSecretPayload, type MessageToolCall } from '@lobechat/types';
+import { type ChatToolPayload, type MessageToolCall } from '@lobechat/types';
 import { serializePartsForStorage } from '@lobechat/utils';
 import debug from 'debug';
 
 import { type MessageModel } from '@/database/models/message';
-import { initModelRuntimeWithUserPayload } from '@/server/modules/ModelRuntime';
+import { type LobeChatDatabase } from '@/database/type';
+import { initModelRuntimeFromDB } from '@/server/modules/ModelRuntime';
 import { type ToolExecutionService } from '@/server/services/toolExecution';
 
 import type { IStreamEventManager } from './types';
@@ -31,11 +32,11 @@ export interface RuntimeExecutorContext {
   fileService?: any;
   messageModel: MessageModel;
   operationId: string;
+  serverDB: LobeChatDatabase;
   stepIndex: number;
   streamManager: IStreamEventManager;
   toolExecutionService: ToolExecutionService;
   userId?: string;
-  userPayload?: ClientSecretPayload;
 }
 
 export const createRuntimeExecutors = (
@@ -120,8 +121,8 @@ export const createRuntimeExecutors = (
       let hasContentImages = false;
       let hasReasoningImages = false;
 
-      // 初始化 ModelRuntime
-      const modelRuntime = initModelRuntimeWithUserPayload(provider, ctx.userPayload || {});
+      // 初始化 ModelRuntime (从数据库读取用户的 keyVaults)
+      const modelRuntime = await initModelRuntimeFromDB(ctx.serverDB, ctx.userId!, provider);
 
       // 构造 ChatStreamPayload
       const chatPayload = {
@@ -467,7 +468,6 @@ export const createRuntimeExecutors = (
       const executionResult = await toolExecutionService.executeTool(chatToolPayload, {
         toolManifestMap: state.toolManifestMap,
         userId: ctx.userId,
-        userPayload: ctx.userPayload,
       });
 
       const executionTime = executionResult.executionTime;

package/src/server/modules/AgentRuntime/__tests__/RuntimeExecutors.test.ts

@@ -5,13 +5,13 @@ import { RuntimeExecutorContext, createRuntimeExecutors } from '../RuntimeExecut
 
 // Mock dependencies
 vi.mock('@/server/modules/ModelRuntime', () => ({
-  initModelRuntimeWithUserPayload: vi.fn(() => ({
+  initModelRuntimeFromDB: vi.fn().mockResolvedValue({
     chat: vi.fn().mockResolvedValue({
       [Symbol.asyncIterator]: async function* () {
         yield { type: 'text', text: 'Hello' };
       },
     }),
-  })),
+  }),
 }));
 
 vi.mock('@lobechat/model-runtime', () => ({
@@ -50,11 +50,11 @@ describe('RuntimeExecutors', () => {
     ctx = {
       messageModel: mockMessageModel,
       operationId: 'op-123',
+      serverDB: {} as any, // Mock serverDB
       stepIndex: 0,
       streamManager: mockStreamManager,
       toolExecutionService: mockToolExecutionService,
       userId: 'user-123',
-      userPayload: {},
     };
   });
 

package/src/server/modules/AgentRuntime/factory.ts

@@ -1,10 +1,10 @@
 import debug from 'debug';
 
+import { appEnv } from '@/envs/app';
+
 import { AgentStateManager } from './AgentStateManager';
 import { inMemoryAgentStateManager } from './InMemoryAgentStateManager';
-import {
-  inMemoryStreamEventManager,
-} from './InMemoryStreamEventManager';
+import { inMemoryStreamEventManager } from './InMemoryStreamEventManager';
 import { StreamEventManager } from './StreamEventManager';
 import { getAgentRuntimeRedisClient } from './redis';
 import type { IAgentStateManager, IStreamEventManager } from './types';
@@ -19,33 +19,52 @@ export const isRedisAvailable = (): boolean => {
 };
 
 /**
- * Create AgentStateManager based on Redis availability
- *
- * - Redis available: RedisAgentStateManager
- * - Redis not available: InMemoryAgentStateManager (for local development)
+ * Check if queue-based agent runtime is enabled
+ * When disabled (default), use InMemory implementations for local/simple deployments
+ */
+const isQueueModeEnabled = (): boolean => {
+  return appEnv.enableQueueAgentRuntime === true;
+};
+
+/**
+ * Create AgentStateManager based on configuration
  */
 export const createAgentStateManager = (): IAgentStateManager => {
-  if (isRedisAvailable()) {
-    log('Creating Redis-based AgentStateManager');
-    return new AgentStateManager();
+  // When queue mode is disabled, always use InMemory for simplicity
+  if (!isQueueModeEnabled()) {
+    log('Queue mode disabled, using InMemoryAgentStateManager');
+    return inMemoryAgentStateManager;
+  }
+
+  // Queue mode enabled, Redis is required
+  if (!isRedisAvailable()) {
+    throw new Error(
+      'Redis is required when AGENT_RUNTIME_MODE=queue. Please configure `REDIS_URL`.',
+    );
   }
 
-  log('Redis not available, using InMemoryAgentStateManager for local development');
-  return inMemoryAgentStateManager;
+  return new AgentStateManager();
 };
 
 /**
- * Create StreamEventManager based on Redis availability
+ * Create StreamEventManager based on configuration
  *
- * - Redis available: RedisStreamEventManager
- * - Redis not available: InMemoryStreamEventManager (for local development)
+ * - If enableQueueAgentRuntime=false (default): InMemoryStreamEventManager
+ * - If enableQueueAgentRuntime=true: RedisStreamEventManager (requires Redis)
  */
 export const createStreamEventManager = (): IStreamEventManager => {
-  if (isRedisAvailable()) {
-    log('Creating Redis-based StreamEventManager');
-    return new StreamEventManager();
+  // When queue mode is disabled, always use InMemory for simplicity
+  if (!isQueueModeEnabled()) {
+    log('Queue mode disabled, using InMemoryStreamEventManager');
+    return inMemoryStreamEventManager;
+  }
+
+  // Queue mode enabled, Redis is required
+  if (!isRedisAvailable()) {
+    throw new Error(
+      'Redis is required when AGENT_RUNTIME_MODE=queue. Please configure `REDIS_URL`.',
+    );
   }
 
-  log('Redis not available, using InMemoryStreamEventManager for local development');
-  return inMemoryStreamEventManager;
+  return new StreamEventManager();
 };