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

package/packages/agent-runtime/src/core/__tests__/InterventionChecker.test.ts

@@ -12,43 +12,16 @@ describe('InterventionChecker', () => {
 
     it('should return the policy when config is a simple string', () => {
       expect(InterventionChecker.shouldIntervene({ config: 'never', toolArgs: {} })).toBe('never');
-      expect(InterventionChecker.shouldIntervene({ config: 'always', toolArgs: {} })).toBe(
-        'always',
+      expect(InterventionChecker.shouldIntervene({ config: 'require', toolArgs: {} })).toBe(
+        'require',
       );
-      expect(InterventionChecker.shouldIntervene({ config: 'first', toolArgs: {} })).toBe('first');
-    });
-
-    it('should handle "first" policy with confirmed history', () => {
-      const toolKey = 'web-browsing/crawlSinglePage';
-      const confirmedHistory = [toolKey];
-
-      const result = InterventionChecker.shouldIntervene({
-        config: 'first',
-        toolArgs: {},
-        confirmedHistory,
-        toolKey,
-      });
-      expect(result).toBe('never');
-    });
-
-    it('should require intervention for "first" policy without confirmation', () => {
-      const toolKey = 'web-browsing/crawlSinglePage';
-      const confirmedHistory: string[] = [];
-
-      const result = InterventionChecker.shouldIntervene({
-        config: 'first',
-        toolArgs: {},
-        confirmedHistory,
-        toolKey,
-      });
-      expect(result).toBe('first');
     });
 
     it('should match rules in order and return first match', () => {
       const config: HumanInterventionConfig = [
         { match: { command: 'ls:*' }, policy: 'never' },
-        { match: { command: 'git commit:*' }, policy: 'first' },
-        { policy: 'always' }, // Default rule
+        { match: { command: 'git commit:*' }, policy: 'require' },
+        { policy: 'require' }, // Default rule
       ];
 
       expect(InterventionChecker.shouldIntervene({ config, toolArgs: { command: 'ls:' } })).toBe(
@@ -56,20 +29,20 @@ describe('InterventionChecker', () => {
       );
       expect(
         InterventionChecker.shouldIntervene({ config, toolArgs: { command: 'git commit:' } }),
-      ).toBe('first');
+      ).toBe('require');
       expect(
         InterventionChecker.shouldIntervene({ config, toolArgs: { command: 'rm -rf /' } }),
-      ).toBe('always');
+      ).toBe('require');
     });
 
-    it('should return always as default when no rule matches', () => {
+    it('should return require as default when no rule matches', () => {
       const config: HumanInterventionConfig = [{ match: { command: 'ls:*' }, policy: 'never' }];
 
       const result = InterventionChecker.shouldIntervene({
         config,
         toolArgs: { command: 'rm -rf /' },
       });
-      expect(result).toBe('always');
+      expect(result).toBe('require');
     });
 
     it('should handle multiple parameter matching', () => {
@@ -81,7 +54,7 @@ describe('InterventionChecker', () => {
           },
           policy: 'never',
         },
-        { policy: 'always' },
+        { policy: 'require' },
       ];
 
       // Both match
@@ -104,20 +77,20 @@ describe('InterventionChecker', () => {
             path: '/tmp/file.ts',
           },
         }),
-      ).toBe('always');
+      ).toBe('require');
     });
 
     it('should handle default rule without match', () => {
       const config: HumanInterventionConfig = [
         { match: { command: 'ls:*' }, policy: 'never' },
-        { policy: 'first' }, // Default rule
+        { policy: 'require' }, // Default rule
       ];
 
       const result = InterventionChecker.shouldIntervene({
         config,
         toolArgs: { command: 'anything' },
       });
-      expect(result).toBe('first');
+      expect(result).toBe('require');
     });
   });
 
@@ -249,10 +222,10 @@ describe('InterventionChecker', () => {
     it('should handle Bash tool scenario', () => {
       const config: HumanInterventionConfig = [
         { match: { command: 'ls:*' }, policy: 'never' },
-        { match: { command: 'git add:*' }, policy: 'first' },
-        { match: { command: 'git commit:*' }, policy: 'first' },
-        { match: { command: 'rm:*' }, policy: 'always' },
-        { policy: 'always' },
+        { match: { command: 'git add:*' }, policy: 'require' },
+        { match: { command: 'git commit:*' }, policy: 'require' },
+        { match: { command: 'rm:*' }, policy: 'require' },
+        { policy: 'require' },
       ];
 
       // Safe commands - never
@@ -260,27 +233,27 @@ describe('InterventionChecker', () => {
         'never',
       );
 
-      // Git commands - first
+      // Git commands - require
       expect(
         InterventionChecker.shouldIntervene({ config, toolArgs: { command: 'git add:.' } }),
-      ).toBe('first');
+      ).toBe('require');
       expect(
         InterventionChecker.shouldIntervene({ config, toolArgs: { command: 'git commit:-m' } }),
-      ).toBe('first');
+      ).toBe('require');
 
-      // Dangerous commands - always
+      // Dangerous commands - require
       expect(InterventionChecker.shouldIntervene({ config, toolArgs: { command: 'rm:-rf' } })).toBe(
-        'always',
+        'require',
       );
       expect(
         InterventionChecker.shouldIntervene({ config, toolArgs: { command: 'npm install' } }),
-      ).toBe('always');
+      ).toBe('require');
     });
 
     it('should handle LocalSystem tool scenario', () => {
       const config: HumanInterventionConfig = [
         { match: { path: '/Users/project/*' }, policy: 'never' },
-        { policy: 'first' },
+        { policy: 'require' },
       ];
 
       // Project directory - never
@@ -291,44 +264,18 @@ describe('InterventionChecker', () => {
         }),
       ).toBe('never');
 
-      // Outside project - first
+      // Outside project - require
       expect(
         InterventionChecker.shouldIntervene({ config, toolArgs: { path: '/tmp/file.ts' } }),
-      ).toBe('first');
+      ).toBe('require');
     });
 
     it('should handle Web Browsing tool with simple policy', () => {
-      const config: HumanInterventionConfig = 'always';
+      const config: HumanInterventionConfig = 'require';
 
       expect(
         InterventionChecker.shouldIntervene({ config, toolArgs: { url: 'https://example.com' } }),
-      ).toBe('always');
-    });
-
-    it('should handle first policy with confirmation history', () => {
-      const config: HumanInterventionConfig = [
-        { match: { command: 'git add:*' }, policy: 'first' },
-        { policy: 'always' },
-      ];
-
-      const toolKey = 'bash/bash#abc123';
-      const args = { command: 'git add:.' };
-
-      // First time - requires intervention
-      expect(
-        InterventionChecker.shouldIntervene({
-          config,
-          toolArgs: args,
-          confirmedHistory: [],
-          toolKey,
-        }),
-      ).toBe('first');
-
-      // After confirmation - never
-      const confirmedHistory = [toolKey];
-      expect(
-        InterventionChecker.shouldIntervene({ config, toolArgs: args, confirmedHistory, toolKey }),
-      ).toBe('never');
+      ).toBe('require');
     });
   });
 });

package/packages/agent-runtime/src/core/__tests__/runtime.test.ts

@@ -1,3 +1,4 @@
+import { ChatToolPayload } from '@lobechat/types';
 import { describe, expect, it, vi } from 'vitest';
 
 import {
@@ -344,9 +345,11 @@ describe('AgentRuntime', () => {
             type: 'request_human_approve',
             pendingToolsCalling: [
               {
+                apiName: 'test_tool',
+                arguments: '{}',
                 id: 'call_123',
-                type: 'function',
-                function: { name: 'test_tool', arguments: '{}' },
+                identifier: 'test_tool',
+                type: 'default',
               },
             ],
           }),
@@ -357,14 +360,11 @@ describe('AgentRuntime', () => {
 
         const result = await runtime.step(state);
 
-        expect(result.events).toHaveLength(2);
+        expect(result.events).toHaveLength(1);
         expect(result.events[0]).toMatchObject({
           type: 'human_approve_required',
           sessionId: 'test-session',
         });
-        expect(result.events[1]).toMatchObject({
-          type: 'tool_pending',
-        });
 
         expect(result.newState.status).toBe('waiting_for_human');
         expect(result.newState.pendingToolsCalling).toBeDefined();
@@ -947,12 +947,29 @@ describe('AgentRuntime', () => {
             case 'llm_result':
               const llmPayload = context.payload as { result: any; hasToolCalls: boolean };
               if (llmPayload.hasToolCalls) {
+                // Convert OpenAI format tool_calls to ChatToolPayload format
+                const pendingToolsCalling = llmPayload.result.tool_calls.map((tc: any) => ({
+                  apiName: tc.function.name,
+                  arguments: tc.function.arguments,
+                  id: tc.id,
+                  identifier: tc.function.name,
+                  type: 'default' as const,
+                }));
                 return Promise.resolve({
+                  pendingToolsCalling,
                   type: 'request_human_approve',
-                  pendingToolsCalling: llmPayload.result.tool_calls,
                 });
               }
               return Promise.resolve({ type: 'finish', reason: 'completed', reasonDetail: 'Done' });
+            case 'human_approved_tool':
+              const approvedPayload = context.payload as { approvedToolCall: ChatToolPayload };
+              return Promise.resolve({
+                payload: {
+                  parentMessageId: 'user-msg-id',
+                  toolCalling: approvedPayload.approvedToolCall,
+                },
+                type: 'call_tool',
+              });
             case 'tool_result':
               return Promise.resolve({ type: 'call_llm', payload: { messages: state.messages } });
             default:
@@ -1021,10 +1038,10 @@ describe('AgentRuntime', () => {
       // Step 2: Approve and execute tool call
       const pendingToolCall = result.newState.pendingToolsCalling![0];
       const toolCall = {
+        apiName: pendingToolCall.apiName,
+        arguments: pendingToolCall.arguments,
         id: pendingToolCall.id,
-        apiName: pendingToolCall.function.name,
-        identifier: pendingToolCall.function.name,
-        arguments: pendingToolCall.function.arguments,
+        identifier: pendingToolCall.identifier,
         type: 'default' as const,
       };
       result = await runtime.approveToolCall(result.newState, toolCall);
@@ -1203,9 +1220,11 @@ describe('AgentRuntime', () => {
               {
                 pendingToolsCalling: [
                   {
+                    apiName: 'danger_tool',
+                    arguments: '{}',
                     id: 'call_danger',
-                    type: 'function' as const,
-                    function: { name: 'danger_tool', arguments: '{}' },
+                    identifier: 'danger_tool',
+                    type: 'default' as const,
                   },
                 ],
                 type: 'request_human_approve' as const,
@@ -1233,7 +1252,7 @@ describe('AgentRuntime', () => {
 
       // Should have pending tool calls
       expect(result.newState.pendingToolsCalling).toHaveLength(1);
-      expect(result.newState.pendingToolsCalling![0].function.name).toBe('danger_tool');
+      expect(result.newState.pendingToolsCalling![0].apiName).toBe('danger_tool');
 
       // Should have both tool_result and human_approve_required events
       expect(result.events).toContainEqual(expect.objectContaining({ type: 'tool_result' }));

package/packages/agent-runtime/src/core/runtime.ts

@@ -85,12 +85,17 @@ export class AgentRuntime {
 
       // Handle human approved tool calls
       if (runtimeContext.phase === 'human_approved_tool') {
-        const approvedPayload = runtimeContext.payload as { approvedToolCall: ChatToolPayload };
+        const approvedPayload = runtimeContext.payload as {
+          approvedToolCall: ChatToolPayload;
+          parentMessageId: string;
+          skipCreateToolMessage: boolean;
+        };
         const toolCalling = approvedPayload.approvedToolCall;
 
         rawInstructions = {
           payload: {
-            parentMessageId: '', // Not required for approval flow
+            parentMessageId: approvedPayload.parentMessageId,
+            skipCreateToolMessage: approvedPayload.skipCreateToolMessage,
             toolCalling,
           },
           type: 'call_tool',
@@ -538,7 +543,6 @@ export class AgentRuntime {
           sessionId: newState.sessionId,
           type: 'human_approve_required',
         },
-        { toolCalls: pendingToolsCalling, type: 'tool_pending' },
       ];
 
       return { events, newState };

package/packages/agent-runtime/src/types/event.ts

@@ -1,5 +1,6 @@
 /* eslint-disable sort-keys-fix/sort-keys-fix, typescript-sort-keys/interface */
 import type { AgentState, ToolsCalling } from './state';
+import { ChatToolPayload } from '@/types/message';
 
 export interface AgentEventInit {
   type: 'init';
@@ -33,7 +34,7 @@ export interface AgentEventToolResult {
 
 export interface AgentEventHumanApproveRequired {
   type: 'human_approve_required';
-  pendingToolsCalling: ToolsCalling[];
+  pendingToolsCalling: ChatToolPayload[];
   sessionId: string;
 }
 

package/packages/agent-runtime/src/types/generalAgent.ts

@@ -18,6 +18,7 @@ export interface GeneralAgentCallLLMResultPayload {
 
 export interface GeneralAgentCallingToolInstructionPayload {
   parentMessageId: string;
+  skipCreateToolMessage?: boolean;
   toolCalling: ChatToolPayload;
 }
 

package/packages/agent-runtime/src/types/instruction.ts

@@ -1,7 +1,7 @@
 import { ChatToolPayload, ModelUsage } from '@lobechat/types';
 
 import type { FinishReason } from './event';
-import { AgentState, ToolRegistry, ToolsCalling } from './state';
+import { AgentState, ToolRegistry } from './state';
 import type { Cost, CostCalculationContext, Usage } from './usage';
 
 /**
@@ -137,8 +137,9 @@ export interface AgentInstructionRequestHumanSelect {
 }
 
 export interface AgentInstructionRequestHumanApprove {
-  pendingToolsCalling: ToolsCalling[];
+  pendingToolsCalling: ChatToolPayload[];
   reason?: string;
+  skipCreateToolMessage?: boolean;
   type: 'request_human_approve';
 }
 

package/packages/agent-runtime/src/types/state.ts

@@ -1,4 +1,6 @@
 /* eslint-disable sort-keys-fix/sort-keys-fix, typescript-sort-keys/interface */
+import { ChatToolPayload } from '@/types/message';
+
 import type { Cost, CostLimit, Usage } from './usage';
 
 /**
@@ -49,7 +51,7 @@ export interface AgentState {
    * When status is 'waiting_for_human', this stores pending requests
    * for human-in-the-loop operations.
    */
-  pendingToolsCalling?: ToolsCalling[];
+  pendingToolsCalling?: ChatToolPayload[];
   pendingHumanPrompt?: { metadata?: Record<string, unknown>; prompt: string };
   pendingHumanSelect?: {
     metadata?: Record<string, unknown>;

package/packages/conversation-flow/src/transformation/FlatListBuilder.ts

@@ -427,11 +427,14 @@ export class FlatListBuilder {
             if (toolMsg.error) result.error = toolMsg.error;
             if (toolMsg.pluginState) result.state = toolMsg.pluginState;
 
-            return {
+            const toolWithResult: ChatToolPayloadWithResult = {
               ...tool,
+              intervention: toolMsg.pluginIntervention,
               result,
               result_msg_id: toolMsg.id,
             };
+
+            return toolWithResult;
           }
           return tool;
         }) || [];

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

@@ -97,6 +97,7 @@ export class MessageModel {
           type: messagePlugins.type,
         },
         pluginError: messagePlugins.error,
+        pluginIntervention: messagePlugins.intervention,
         pluginState: messagePlugins.state,
 
         translate: {
@@ -462,6 +463,7 @@ export class MessageModel {
       provider: fromProvider,
       files,
       plugin,
+      pluginIntervention,
       pluginState,
       fileChunks,
       ragQueryId,
@@ -496,6 +498,7 @@ export class MessageModel {
           arguments: plugin?.arguments,
           id,
           identifier: plugin?.identifier,
+          intervention: pluginIntervention,
           state: pluginState,
           toolCallId: message.tool_call_id,
           type: plugin?.type,

package/packages/obervability-otel/src/node.ts

@@ -8,6 +8,7 @@ import { resourceFromAttributes } from '@opentelemetry/resources';
 import { PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';
 import { NodeSDK } from '@opentelemetry/sdk-node';
 import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from '@opentelemetry/semantic-conventions';
+import { env } from 'node:process';
 
 export function register(options?: { debug?: true | DiagLogLevel; version?: string }) {
   const attributes: Record<string, string> = {
@@ -23,13 +24,26 @@ export function register(options?: { debug?: true | DiagLogLevel; version?: stri
     );
   }
 
+  let metricsExporterInterval = 1000;
+  if (env.OTEL_METRICS_EXPORTER_INTERVAL) {
+    const parsed = parseInt(env.OTEL_METRICS_EXPORTER_INTERVAL, 10);
+    if (!isNaN(parsed)) {
+      metricsExporterInterval = parsed;
+    }
+  }
+
   const sdk = new NodeSDK({
     instrumentations: [
       new PgInstrumentation(),
       new HttpInstrumentation(),
       getNodeAutoInstrumentations(),
     ],
-    metricReaders: [new PeriodicExportingMetricReader({ exporter: new OTLPMetricExporter() })],
+    metricReaders: [
+      new PeriodicExportingMetricReader({
+        exportIntervalMillis: metricsExporterInterval,
+        exporter: new OTLPMetricExporter(),
+      }),
+    ],
     resource: resourceFromAttributes(attributes),
     traceExporter: new OTLPTraceExporter(),
   });

package/packages/types/src/message/common/base.ts

@@ -9,13 +9,13 @@ import { ErrorType } from '../../fetch';
  */
 export interface ChatMessageError {
   body?: any;
-  message: string;
+  message?: string;
   type: ErrorType | IPluginErrorType | ILobeAgentRuntimeErrorType;
 }
 
 export const ChatMessageErrorSchema = z.object({
   body: z.any().optional(),
-  message: z.string(),
+  message: z.string().optional(),
   type: z.union([z.string(), z.number()]),
 });
 

package/packages/types/src/message/common/tools.ts

@@ -4,10 +4,22 @@ import { z } from 'zod';
 
 import { LobeToolRenderType } from '../../tool';
 
+// ToolIntervention must be defined first to avoid circular dependency
+export interface ToolIntervention {
+  rejectedReason?: string;
+  status?: 'pending' | 'approved' | 'rejected' | 'none';
+}
+
+export const ToolInterventionSchema = z.object({
+  rejectedReason: z.string().optional(),
+  status: z.enum(['pending', 'approved', 'rejected', 'none']).optional(),
+});
+
 export interface ChatPluginPayload {
   apiName: string;
   arguments: string;
   identifier: string;
+  intervention?: ToolIntervention;
   type: LobeToolRenderType;
 }
 
@@ -16,6 +28,7 @@ export interface ChatToolPayload {
   arguments: string;
   id: string;
   identifier: string;
+  intervention?: ToolIntervention;
   result_msg_id?: string;
   type: LobeToolRenderType;
 }
@@ -34,7 +47,9 @@ export interface ChatToolResult {
  * Chat tool payload with merged execution result
  */
 export interface ChatToolPayloadWithResult extends ChatToolPayload {
+  intervention?: ToolIntervention;
   result?: ChatToolResult;
+  result_msg_id?: string;
 }
 
 export interface ToolsCallingContext {
@@ -91,6 +106,7 @@ export const ChatToolPayloadSchema = z.object({
   arguments: z.string(),
   id: z.string(),
   identifier: z.string(),
+  intervention: ToolInterventionSchema.optional(),
   result_msg_id: z.string().optional(),
   type: z.string(),
 });
@@ -103,13 +119,3 @@ export interface ChatMessagePluginError {
   message: string;
   type: IPluginErrorType;
 }
-
-export interface ToolIntervention {
-  rejectedReason?: string;
-  status?: 'pending' | 'approved' | 'rejected' | 'none';
-}
-
-export const ToolInterventionSchema = z.object({
-  rejectedReason: z.string().optional(),
-  status: z.enum(['pending', 'approved', 'rejected', 'none']).optional(),
-});

package/packages/types/src/message/ui/chat.ts

@@ -8,7 +8,12 @@ import {
   ModelReasoning,
   ModelUsage,
 } from '../common';
-import { ChatPluginPayload, ChatToolPayload, ChatToolPayloadWithResult } from '../common/tools';
+import {
+  ChatPluginPayload,
+  ChatToolPayload,
+  ChatToolPayloadWithResult,
+  ToolIntervention,
+} from '../common/tools';
 import { ChatMessageExtra } from './extra';
 import { ChatFileChunk } from './rag';
 import { ChatVideoItem } from './video';
@@ -95,6 +100,7 @@ export interface UIChatMessage {
   performance?: ModelPerformance;
   plugin?: ChatPluginPayload;
   pluginError?: any;
+  pluginIntervention?: ToolIntervention;
   pluginState?: any;
   provider?: string | null;
   /**

package/packages/types/src/tool/intervention.ts

@@ -5,10 +5,9 @@ import { z } from 'zod';
  */
 export type HumanInterventionPolicy =
   | 'never' // Never intervene, auto-execute
-  | 'always' // Always require intervention
-  | 'first'; // Require intervention on first call only
+  | 'require'; // Always require intervention
 
-export const HumanInterventionPolicySchema = z.enum(['never', 'always', 'first']);
+export const HumanInterventionPolicySchema = z.enum(['never', 'require']);
 
 /**
  * Argument Matcher for parameter-level filtering

package/packages/types/src/user/settings/tool.ts

@@ -1,42 +1,29 @@
-import type { HumanInterventionConfig } from '../../tool';
-
 export interface UserToolConfig {
+  /**
+   * Tool approval mode
+   * - auto-run: Automatically approve all tools without user consent
+   * - allow-list: Only approve tools in the allow list
+   * - manual: Require manual approval for each tool execution
+   */
+  approvalMode?: 'auto-run' | 'allow-list' | 'manual';
+
   dalle: {
     autoGenerate: boolean;
   };
+
   /**
-   * Human intervention configuration
+   * Tool intervention configuration
    */
   humanIntervention?: {
     /**
-     * List of confirmed tool calls (for 'once' policy)
-     * Format: "identifier/apiName" or "identifier/apiName#argsHash"
+     * Allow list of approved tools (used in 'allow-list' mode)
+     * Format: "identifier/apiName"
      *
      * Examples:
      * - "web-browsing/crawlSinglePage"
-     * - "bash/bash#a1b2c3d4"
-     */
-    confirmed?: string[];
-
-    /**
-     * Whether human intervention is enabled globally
-     * @default true
-     */
-    enabled: boolean;
-
-    /**
-     * Per-tool intervention policy overrides
-     * Key format: "identifier/apiName"
-     *
-     * Example:
-     * {
-     *   "web-browsing/crawlSinglePage": "confirm",
-     *   "bash/bash": [
-     *     { match: { command: "git add:*" }, policy: "auto" },
-     *     { policy: "confirm" }
-     *   ]
-     * }
+     * - "bash/bash"
+     * - "search/search"
      */
-    overrides?: Record<string, HumanInterventionConfig>;
+    allowList?: string[];
   };
 }