@lobehub/lobehub 2.0.0-next.48 → 2.0.0-next.49

package/src/store/chat/agents/createAgentExecutors.ts

@@ -13,6 +13,7 @@ import {
 } from '@lobechat/agent-runtime';
 import type { ChatToolPayload, CreateMessageParams } from '@lobechat/types';
 import debug from 'debug';
+import pMap from 'p-map';
 
 import type { ChatStore } from '@/store/chat/store';
 
@@ -43,6 +44,7 @@ export const createAgentExecutors = (context: {
 }) => {
   let shouldSkipCreateMessage = context.skipCreateFirstMessage;
 
+  /* eslint-disable sort-keys-fix/sort-keys-fix */
   const executors: Partial<Record<AgentInstruction['type'], InstructionExecutor>> = {
     /**
      * Custom call_llm executor
@@ -239,39 +241,56 @@ export const createAgentExecutors = (context: {
         // Find the last assistant message (should be created by call_llm)
         const assistantMessage = latestMessages.findLast((m) => m.role === 'assistant');
 
-        // Always create new tool message (following server-side pattern)
-        // This ensures consistency and avoids duplicate execution
-        log(
-          '[%s][call_tool] Creating tool message for tool_call_id: %s',
-          sessionLogId,
-          chatToolPayload.id,
-        );
+        let toolMessageId: string;
 
-        const toolMessageParams: CreateMessageParams = {
-          content: '',
-          groupId: assistantMessage?.groupId,
-          parentId: payload.parentMessageId,
-          plugin: chatToolPayload,
-          role: 'tool',
-          sessionId: context.get().activeId,
-          threadId: context.params.threadId,
-          tool_call_id: chatToolPayload.id,
-          topicId: context.get().activeTopicId,
-        };
-
-        const createResult = await context.get().optimisticCreateMessage(toolMessageParams);
+        if (payload.skipCreateToolMessage) {
+          // Reuse existing tool message (resumption mode)
+          toolMessageId = payload.parentMessageId;
+          // Check if tool message already exists (e.g., from human approval flow)
+          const existingToolMessage = latestMessages.find((m) => m.id === toolMessageId)!;
 
-        if (!createResult) {
           log(
-            '[%s][call_tool] ERROR: Failed to create tool message for tool_call_id: %s',
+            '[%s][call_tool] Resuming with existing tool message: %s (status: %s)',
+            sessionLogId,
+            toolMessageId,
+            existingToolMessage.pluginIntervention?.status,
+          );
+        } else {
+          // Create new tool message (normal mode)
+          log(
+            '[%s][call_tool] Creating tool message for tool_call_id: %s',
             sessionLogId,
             chatToolPayload.id,
           );
-          throw new Error(`Failed to create tool message for tool_call_id: ${chatToolPayload.id}`);
-        }
 
-        const toolMessageId = createResult.id;
-        log('[%s][call_tool] Created tool message, id: %s', sessionLogId, toolMessageId);
+          const toolMessageParams: CreateMessageParams = {
+            content: '',
+            groupId: assistantMessage?.groupId,
+            parentId: payload.parentMessageId,
+            plugin: chatToolPayload,
+            role: 'tool',
+            sessionId: context.get().activeId,
+            threadId: context.params.threadId,
+            tool_call_id: chatToolPayload.id,
+            topicId: context.get().activeTopicId,
+          };
+
+          const createResult = await context.get().optimisticCreateMessage(toolMessageParams);
+
+          if (!createResult) {
+            log(
+              '[%s][call_tool] ERROR: Failed to create tool message for tool_call_id: %s',
+              sessionLogId,
+              chatToolPayload.id,
+            );
+            throw new Error(
+              `Failed to create tool message for tool_call_id: ${chatToolPayload.id}`,
+            );
+          }
+
+          toolMessageId = createResult.id;
+          log('[%s][call_tool] Created tool message, id: %s', sessionLogId, toolMessageId);
+        }
 
         // Execute tool
         log('[%s][call_tool] Executing tool %s ...', sessionLogId, toolName);
@@ -371,6 +390,105 @@ export const createAgentExecutors = (context: {
       }
     },
 
+    /** Create human approve executor */
+    request_human_approve: async (instruction, state) => {
+      const { pendingToolsCalling, reason, skipCreateToolMessage } = instruction as Extract<
+        AgentInstruction,
+        { type: 'request_human_approve' }
+      >;
+      const newState = structuredClone(state);
+      const events: AgentEvent[] = [];
+      const sessionLogId = `${state.sessionId}:${state.stepCount}`;
+
+      log(
+        '[%s][request_human_approve] Executor start, pending tools count: %d, reason: %s',
+        sessionLogId,
+        pendingToolsCalling.length,
+        reason || 'human_intervention_required',
+      );
+
+      // Update state to waiting_for_human
+      newState.lastModified = new Date().toISOString();
+      newState.status = 'waiting_for_human';
+      newState.pendingToolsCalling = pendingToolsCalling;
+
+      // Get assistant message to extract groupId and parentId
+      const latestMessages = context.get().dbMessagesMap[context.messageKey] || [];
+      const assistantMessage = latestMessages.findLast((m) => m.role === 'assistant');
+
+      if (!assistantMessage) {
+        log('[%s][request_human_approve] ERROR: No assistant message found', sessionLogId);
+        throw new Error('No assistant message found for intervention');
+      }
+
+      log(
+        '[%s][request_human_approve] Found assistant message: %s',
+        sessionLogId,
+        assistantMessage.id,
+      );
+
+      if (skipCreateToolMessage) {
+        // Resumption mode: Tool messages already exist, just verify them
+        log('[%s][request_human_approve] Resuming with existing tool messages', sessionLogId);
+      } else {
+        // Create tool messages for each pending tool call with intervention status
+        await pMap(pendingToolsCalling, async (toolPayload) => {
+          const toolName = `${toolPayload.identifier}/${toolPayload.apiName}`;
+          log(
+            '[%s][request_human_approve] Creating tool message for %s with tool_call_id: %s',
+            sessionLogId,
+            toolName,
+            toolPayload.id,
+          );
+
+          const toolMessageParams: CreateMessageParams = {
+            content: '',
+            groupId: assistantMessage.groupId,
+            parentId: assistantMessage.id,
+            plugin: {
+              ...toolPayload,
+            },
+            pluginIntervention: { status: 'pending' },
+            role: 'tool',
+            sessionId: context.get().activeId,
+            threadId: context.params.threadId,
+            tool_call_id: toolPayload.id,
+            topicId: context.get().activeTopicId,
+          };
+
+          const createResult = await context.get().optimisticCreateMessage(toolMessageParams);
+
+          if (!createResult) {
+            log(
+              '[%s][request_human_approve] ERROR: Failed to create tool message for %s',
+              sessionLogId,
+              toolName,
+            );
+            throw new Error(`Failed to create tool message for ${toolName}`);
+          }
+
+          log(
+            '[%s][request_human_approve] Created tool message: %s for %s',
+            sessionLogId,
+            createResult.id,
+            toolName,
+          );
+        });
+      }
+
+      log(
+        '[%s][request_human_approve] All tool messages created, emitting human_approve_required event',
+        sessionLogId,
+      );
+
+      events.push({
+        pendingToolsCalling,
+        sessionId: newState.sessionId,
+        type: 'human_approve_required',
+      });
+
+      return { events, newState };
+    },
     /**
      * Finish executor
      * Completes the runtime execution

package/src/store/chat/agents/createToolEngine.ts

@@ -0,0 +1,22 @@
+import { WorkingModel } from '@lobechat/types';
+
+import { getSearchConfig } from '@/helpers/getSearchConfig';
+import { createToolsEngine } from '@/helpers/toolEngineering';
+import { WebBrowsingManifest } from '@/tools/web-browsing';
+
+export const createAgentToolsEngine = (workingModel: WorkingModel) =>
+  createToolsEngine({
+    // Add WebBrowsingManifest as default tool
+    defaultToolIds: [WebBrowsingManifest.identifier],
+    // Create search-aware enableChecker for this request
+    enableChecker: ({ pluginId }) => {
+      // For WebBrowsingManifest, apply search logic
+      if (pluginId === WebBrowsingManifest.identifier) {
+        const searchConfig = getSearchConfig(workingModel.model, workingModel.provider);
+        return searchConfig.useApplicationBuiltinSearchTool;
+      }
+
+      // For all other plugins, enable by default
+      return true;
+    },
+  });

package/src/store/chat/slices/aiChat/actions/conversationControl.ts

@@ -1,13 +1,19 @@
 /* eslint-disable sort-keys-fix/sort-keys-fix, typescript-sort-keys/interface */
 // Disable the auto sort key eslint rule to make the code more logic and readable
+import { AgentRuntime, type AgentRuntimeContext } from '@lobechat/agent-runtime';
 import { MESSAGE_CANCEL_FLAT } from '@lobechat/const';
 import { produce } from 'immer';
 import { StateCreator } from 'zustand/vanilla';
 
+import { getAgentStoreState } from '@/store/agent';
+import { agentSelectors } from '@/store/agent/slices/chat';
+import { createAgentToolsEngine } from '@/store/chat/agents/createToolEngine';
 import { ChatStore } from '@/store/chat/store';
 import { setNamespace } from '@/utils/storeDebug';
 
+import { displayMessageSelectors } from '../../../selectors';
 import { messageMapKey } from '../../../utils/messageMapKey';
+import { dbMessageSelectors } from '../../message/selectors';
 import { MainSendMessageOperation } from '../initialState';
 
 const n = setNamespace('ai');
@@ -32,6 +38,14 @@ export interface ConversationControlAction {
    * Switches to a different branch of a message
    */
   switchMessageBranch: (messageId: string, branchIndex: number) => Promise<void>;
+  /**
+   * Approve tool intervention
+   */
+  approveToolCalling: (toolMessageId: string, assistantGroupId: string) => Promise<void>;
+  /**
+   * Reject tool intervention
+   */
+  rejectToolCalling: (messageId: string, reason?: string) => Promise<void>;
   /**
    * Toggle sendMessage operation state
    */
@@ -131,6 +145,98 @@ export const conversationControl: StateCreator<
       return undefined;
     }
   },
+  approveToolCalling: async (toolMessageId) => {
+    const { activeId, activeTopicId, activeThreadId, internal_execAgentRuntime } = get();
+
+    // 1. Get tool message and verify it exists
+    const toolMessage = dbMessageSelectors.getDbMessageById(toolMessageId)(get());
+    if (!toolMessage) return;
+
+    // 2. Update intervention status to approved
+    await get().optimisticUpdatePlugin(toolMessageId, { intervention: { status: 'approved' } });
+
+    // 3. Get current messages for state construction
+    const currentMessages = displayMessageSelectors.mainAIChats(get());
+
+    // 4. Get agent configuration and tools information
+    const agentStoreState = getAgentStoreState();
+    const agentConfigData = agentSelectors.currentAgentConfig(agentStoreState);
+
+    const toolsEngine = createAgentToolsEngine({
+      model: agentConfigData.model,
+      provider: agentConfigData.provider!,
+    });
+    const { enabledToolIds } = toolsEngine.generateToolsDetailed({
+      model: agentConfigData.model,
+      provider: agentConfigData.provider!,
+      toolIds: agentConfigData.plugins,
+    });
+    const toolManifestMap = Object.fromEntries(
+      toolsEngine.getEnabledPluginManifests(enabledToolIds).entries(),
+    );
+
+    // 5. Construct AgentState
+    const state = AgentRuntime.createInitialState({
+      sessionId: activeId,
+      messages: currentMessages,
+      maxSteps: 400,
+      metadata: {
+        sessionId: activeId,
+        topicId: activeTopicId,
+        threadId: activeThreadId,
+      },
+      toolManifestMap,
+    });
+
+    console.log('toolMessage:', toolMessage);
+    // 6. Construct AgentRuntimeContext with 'human_approved_tool' phase
+    const context: AgentRuntimeContext = {
+      phase: 'human_approved_tool',
+      payload: {
+        approvedToolCall: toolMessage.plugin,
+        parentMessageId: toolMessageId,
+        skipCreateToolMessage: true,
+      },
+      session: {
+        sessionId: activeId,
+        messageCount: currentMessages.length,
+        status: 'running',
+        stepCount: 0,
+      },
+    };
+
+    // 7. Execute agent runtime from tool message position
+    try {
+      await internal_execAgentRuntime({
+        messages: currentMessages,
+        parentMessageId: toolMessageId, // Start from tool message
+        parentMessageType: 'tool', // Type is 'tool'
+        threadId: activeThreadId,
+        initialState: state,
+        initialContext: context,
+      });
+    } catch (error) {
+      console.error('[approveToolCalling] Error executing agent runtime:', error);
+    }
+  },
+
+  rejectToolCalling: async (messageId, reason) => {
+    const toolMessage = dbMessageSelectors.getDbMessageById(messageId)(get());
+    if (!toolMessage) return;
+
+    // Optimistic update - update status to rejected and save reason
+    const intervention = {
+      rejectedReason: reason,
+      status: 'rejected',
+    } as const;
+    await get().optimisticUpdatePlugin(toolMessage.id, { intervention });
+
+    const toolContent = !!reason
+      ? `User reject this tool calling with reason: ${reason}`
+      : 'User reject this tool calling without reason';
+
+    await get().optimisticUpdateMessageContent(messageId, toolContent);
+  },
 
   internal_updateSendMessageOperation: (key, value, actionName) => {
     const operationKey = typeof key === 'string' ? key : messageMapKey(key.sessionId, key.topicId);

package/src/store/chat/slices/aiChat/actions/streamingExecutor.ts

@@ -1,6 +1,6 @@
 /* eslint-disable sort-keys-fix/sort-keys-fix, typescript-sort-keys/interface */
 // Disable the auto sort key eslint rule to make the code more logic and readable
-import { AgentRuntime, type AgentRuntimeContext } from '@lobechat/agent-runtime';
+import { AgentRuntime, type AgentRuntimeContext, type AgentState } from '@lobechat/agent-runtime';
 import { isDesktop } from '@lobechat/const';
 import { knowledgeBaseQAPrompts } from '@lobechat/prompts';
 import {
@@ -23,6 +23,7 @@ import { agentChatConfigSelectors, agentSelectors } from '@/store/agent/selector
 import { getAgentStoreState } from '@/store/agent/store';
 import { GeneralChatAgent } from '@/store/chat/agents/GeneralChatAgent';
 import { createAgentExecutors } from '@/store/chat/agents/createAgentExecutors';
+import { createAgentToolsEngine } from '@/store/chat/agents/createToolEngine';
 import { ChatStore } from '@/store/chat/store';
 import { getFileStoreState } from '@/store/file/store';
 import { setNamespace } from '@/utils/storeDebug';
@@ -88,6 +89,14 @@ export interface StreamingExecutorAction {
     skipCreateFirstMessage?: boolean;
     traceId?: string;
     ragMetadata?: { ragQueryId: string; fileChunks: MessageSemanticSearchChunk[] };
+    /**
+     * Initial agent state (for resuming execution from a specific point)
+     */
+    initialState?: AgentState;
+    /**
+     * Initial agent runtime context (for resuming execution from a specific phase)
+     */
+    initialContext?: AgentRuntimeContext;
   }) => Promise<void>;
 }
 
@@ -397,6 +406,7 @@ export const streamingExecutor: StateCreator<
     // ===========================================
     // Step 1: RAG Preprocessing (if enabled)
     // ===========================================
+    // Skip RAG preprocessing if initialState is provided (messages already preprocessed)
     if (params.ragQuery && parentMessageType === 'user') {
       const userMessageId = parentMessageId;
       log('[internal_execAgentRuntime] RAG preprocessing start');
@@ -458,6 +468,17 @@ export const streamingExecutor: StateCreator<
         provider: provider!,
       },
     });
+
+    const toolsEngine = createAgentToolsEngine({ model: model, provider: provider! });
+    const { enabledToolIds } = toolsEngine.generateToolsDetailed({
+      model: model,
+      provider: provider!,
+      toolIds: agentConfigData.plugins,
+    });
+    const toolManifestMap = Object.fromEntries(
+      toolsEngine.getEnabledPluginManifests(enabledToolIds).entries(),
+    );
+
     const runtime = new AgentRuntime(agent, {
       executors: createAgentExecutors({
         get,
@@ -468,21 +489,24 @@ export const streamingExecutor: StateCreator<
       }),
     });
 
-    // Create initial state
-    let state = AgentRuntime.createInitialState({
-      sessionId: activeId,
-      messages,
-      // Prevent infinite loops
-      maxSteps: 400,
-      metadata: {
+    // Create initial state or use provided state
+    let state =
+      params.initialState ||
+      AgentRuntime.createInitialState({
         sessionId: activeId,
-        topicId: activeTopicId,
-        threadId: params.threadId,
-      },
-    });
+        messages,
+        // Prevent infinite loops
+        maxSteps: 400,
+        metadata: {
+          sessionId: activeId,
+          topicId: activeTopicId,
+          threadId: params.threadId,
+        },
+        toolManifestMap,
+      });
 
-    // Initial context - use 'init' phase since state already contains messages
-    let nextContext: AgentRuntimeContext = {
+    // Initial context - use provided context or create default 'init' phase
+    let nextContext: AgentRuntimeContext = params.initialContext || {
       phase: 'init',
       payload: { model, provider, parentMessageId: params.parentMessageId },
       session: {
@@ -520,20 +544,24 @@ export const streamingExecutor: StateCreator<
 
       // Handle completion and error events
       for (const event of result.events) {
-        if (event.type === 'done') {
-          log('[internal_execAgentRuntime] Received done event');
-        }
+        switch (event.type) {
+          case 'done': {
+            log('[internal_execAgentRuntime] Received done event');
+            break;
+          }
 
-        if (event.type === 'error') {
-          log('[internal_execAgentRuntime] Received error event: %o', event.error);
-          // Find the assistant message to update error
-          const currentMessages = get().messagesMap[messageKey] || [];
-          const assistantMessage = currentMessages.findLast((m) => m.role === 'assistant');
-          if (assistantMessage) {
-            await messageService.updateMessageError(assistantMessage.id, event.error);
+          case 'error': {
+            log('[internal_execAgentRuntime] Received error event: %o', event.error);
+            // Find the assistant message to update error
+            const currentMessages = get().messagesMap[messageKey] || [];
+            const assistantMessage = currentMessages.findLast((m) => m.role === 'assistant');
+            if (assistantMessage) {
+              await messageService.updateMessageError(assistantMessage.id, event.error);
+            }
+            const finalMessages = get().messagesMap[messageKey] || [];
+            get().replaceMessages(finalMessages);
+            break;
           }
-          const finalMessages = get().messagesMap[messageKey] || [];
-          get().replaceMessages(finalMessages);
         }
       }
 

package/src/store/chat/slices/message/reducer.ts

@@ -3,6 +3,7 @@ import {
   ChatPluginPayload,
   ChatToolPayload,
   CreateMessageParams,
+  MessagePluginItem,
   UIChatMessage,
 } from '@lobechat/types';
 import isEqual from 'fast-deep-equal';
@@ -47,7 +48,7 @@ interface UpdatePluginState {
 interface UpdateMessagePlugin {
   id: string;
   type: 'updateMessagePlugin';
-  value: Partial<ChatPluginPayload>;
+  value: Partial<MessagePluginItem>;
 }
 
 interface UpdateMessageTools {

package/src/store/chat/slices/plugin/actions/optimisticUpdate.ts

@@ -1,5 +1,5 @@
 /* eslint-disable sort-keys-fix/sort-keys-fix, typescript-sort-keys/interface */
-import { ChatMessageError, ChatToolPayload } from '@lobechat/types';
+import { ChatMessageError, ChatToolPayload, MessagePluginItem } from '@lobechat/types';
 import isEqual from 'fast-deep-equal';
 import { StateCreator } from 'zustand/vanilla';
 
@@ -29,6 +29,11 @@ export interface PluginOptimisticUpdateAction {
     replace?: boolean,
   ) => Promise<void>;
 
+  /**
+   * Update plugin with optimistic update (generic method for any plugin field)
+   */
+  optimisticUpdatePlugin: (id: string, value: Partial<MessagePluginItem>) => Promise<void>;
+
   /**
    * Add tool to assistant message with optimistic update
    */
@@ -119,6 +124,26 @@ export const pluginOptimisticUpdate: StateCreator<
     await refreshMessages();
   },
 
+  optimisticUpdatePlugin: async (id, value) => {
+    const { replaceMessages } = get();
+
+    // optimistic update
+    get().internal_dispatchMessage({
+      id,
+      type: 'updateMessagePlugin',
+      value,
+    });
+
+    const result = await messageService.updateMessagePlugin(id, value, {
+      sessionId: get().activeId,
+      topicId: get().activeTopicId,
+    });
+
+    if (result?.success && result.messages) {
+      replaceMessages(result.messages);
+    }
+  },
+
   optimisticAddToolToAssistantMessage: async (id, tool) => {
     const assistantMessage = displayMessageSelectors.getDisplayMessageById(id)(get());
     if (!assistantMessage) return;

package/src/store/user/slices/settings/action.ts

@@ -18,6 +18,7 @@ import { difference } from '@/utils/difference';
 import { merge } from '@/utils/merge';
 
 export interface UserSettingsAction {
+  addToolToAllowList: (toolKey: string) => Promise<void>;
   importAppSettings: (settings: UserSettings) => Promise<void>;
   importUrlShareSettings: (settingsParams: string | null) => Promise<void>;
   internal_createSignal: () => AbortController;
@@ -39,6 +40,20 @@ export const createSettingsSlice: StateCreator<
   [],
   UserSettingsAction
 > = (set, get) => ({
+  addToolToAllowList: async (toolKey) => {
+    const currentAllowList = get().settings.tool?.humanIntervention?.allowList || [];
+
+    if (currentAllowList.includes(toolKey)) return;
+
+    await get().setSettings({
+      tool: {
+        humanIntervention: {
+          allowList: [...currentAllowList, toolKey],
+        },
+      },
+    });
+  },
+
   importAppSettings: async (importAppSettings) => {
     const { setSettings } = get();