plugin-agent-orchestrator 1.0.6 → 1.0.13

package/src/server/tools/delegate-task.ts

@@ -13,6 +13,128 @@ import type { ToolsEntry } from '@nocobase/ai';
  */
 const ORCHESTRATOR_DEPTH_KEY = '__orchestratorDepth';
 
+type TraceEvent = {
+  type: string;
+  at: string;
+  title: string;
+  content?: string;
+  toolName?: string;
+  args?: any;
+  status?: string;
+};
+
+type AgentExecutionResult = {
+  content: string;
+  messages: any[];
+};
+
+function sanitizeToolPart(value: string) {
+  return (value || '').replace(/[^a-zA-Z0-9_-]/g, '_');
+}
+
+function buildDelegateToolName(leaderUsername: string, subAgentUsername: string) {
+  return `delegate_${sanitizeToolPart(leaderUsername)}_to_${sanitizeToolPart(subAgentUsername)}`;
+}
+
+function isDelegateToolName(toolName: string) {
+  return toolName.startsWith('delegate_to_') || (toolName.startsWith('delegate_') && toolName.includes('_to_'));
+}
+
+function createDelegateToolOptions(
+  plugin: any,
+  options: {
+    leaderUsername: string;
+    subAgentUsername: string;
+    subAgentEmployee: any;
+    maxDepth?: number;
+    timeout?: number;
+    toolName: string;
+    legacyAlias?: boolean;
+    llmService?: string;
+    model?: string;
+  },
+) {
+  const { leaderUsername, subAgentUsername, subAgentEmployee, maxDepth, timeout, toolName, legacyAlias, llmService, model } = options;
+  const toolDescription = [
+    `Delegate a task from "${leaderUsername}" to the AI Employee "${subAgentEmployee.nickname || subAgentUsername}".`,
+    legacyAlias ? 'This is a backward-compatible alias for existing skill assignments.' : '',
+    subAgentEmployee.about ? `Specialist profile: ${subAgentEmployee.about.substring(0, 200)}` : '',
+    'The sub-agent will execute the task independently and return its final answer.',
+  ].filter(Boolean).join(' ');
+
+  return {
+    scope: 'CUSTOM',
+    execution: 'backend',
+    defaultPermission: 'ALLOW',
+    silence: false,
+    introduction: {
+      title: `[${leaderUsername}] ${subAgentEmployee.nickname || subAgentUsername}${legacyAlias ? ' (legacy)' : ''}`,
+      about: toolDescription,
+    },
+    definition: {
+      name: toolName,
+      description: toolDescription,
+      schema: z.object({
+        task: z.string().describe('The detailed task description for the sub-agent to execute.'),
+        context: z.string().optional().describe('Optional additional context to help the sub-agent understand the task better.'),
+      }),
+    },
+    invoke: async (ctx: Context, args: { task: string; context?: string }, id: string) => {
+      const callingEmployee = resolveCallingEmployee(ctx);
+      if (callingEmployee && callingEmployee !== leaderUsername) {
+        await logDelegation(ctx, plugin, {
+          leaderUsername,
+          subAgentUsername,
+          toolName,
+          task: args.task,
+          context: args.context,
+          result: '',
+          status: 'error',
+          depth: (ctx as any)[ORCHESTRATOR_DEPTH_KEY] ?? 0,
+          durationMs: 0,
+          error: `Employee "${callingEmployee}" is not authorized to use this delegation rule.`,
+        });
+        return {
+          status: 'error' as const,
+          content: `Employee "${callingEmployee}" is not authorized to delegate to "${subAgentUsername}". Configure an orchestration rule first.`,
+        };
+      }
+
+      return invokeDelegateTask(ctx, plugin, {
+        leaderUsername,
+        subAgentUsername,
+        subAgentEmployee,
+        task: args.task,
+        context: args.context,
+        maxDepth: maxDepth ?? 1,
+        timeout: timeout ?? 120000,
+        toolCallId: id,
+        toolName,
+        llmService,
+        model,
+      });
+    },
+  };
+}
+
+function resolveCallingEmployee(ctx: Context) {
+  const raw =
+    (ctx as any)._currentAIEmployee ||
+    (ctx as any).state?.currentAIEmployee ||
+    (ctx as any).runtime?.context?.currentAIEmployee;
+  if (!raw) return null;
+  return typeof raw === 'string' ? raw : raw.username;
+}
+
+function truncateText(value: any, maxLen: number) {
+  const text = typeof value === 'string' ? value : value == null ? '' : JSON.stringify(value);
+  return text.length > maxLen ? `${text.slice(0, maxLen)}\n...[truncated]` : text;
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
 /**
  * Creates one dynamic tool per configured sub-agent for a given leader.
  * Uses Strategy B (Per-SubAgent Tool): each sub-agent becomes a separate tool
@@ -38,86 +160,67 @@ export function createDelegateToolsProvider(plugin: any) {
       });
       if (!configs?.length) return;
 
-      // Build a lookup: which leaders are allowed to use each delegate tool
-      // Multiple leaders may share the same sub-agent, but each leader must
-      // have an explicit rule.
-      const leadersByTool = new Map<string, Set<string>>();
+      const employeeCache = new Map<string, any>();
+      const tools = [];
+      const configsBySubAgent = new Map<string, any[]>();
       for (const config of configs) {
-        const toolName = `delegate_to_${config.subAgentUsername.replace(/[^a-zA-Z0-9_-]/g, '_')}`;
-        if (!leadersByTool.has(toolName)) {
-          leadersByTool.set(toolName, new Set());
-        }
-        leadersByTool.get(toolName)!.add(config.leaderUsername);
+        const items = configsBySubAgent.get(config.subAgentUsername) || [];
+        items.push(config);
+        configsBySubAgent.set(config.subAgentUsername, items);
       }
 
-      // De-duplicate: register one tool per sub-agent (not per config row)
-      const seenSubAgents = new Set<string>();
-
       for (const config of configs) {
         const { leaderUsername, subAgentUsername, maxDepth, timeout } = config;
 
-        // Skip if we already registered this sub-agent's tool
-        if (seenSubAgents.has(subAgentUsername)) continue;
-        seenSubAgents.add(subAgentUsername);
-
         // Fetch the sub-agent employee model for its description and LLM config
-        const subAgentEmployee = await plugin.db.getRepository('aiEmployees').findOne({
-          filter: { username: subAgentUsername },
-        });
+        let subAgentEmployee = employeeCache.get(subAgentUsername);
+        if (!subAgentEmployee) {
+          subAgentEmployee = await plugin.db.getRepository('aiEmployees').findOne({
+            filter: { username: subAgentUsername },
+          });
+          if (subAgentEmployee) {
+            employeeCache.set(subAgentUsername, subAgentEmployee);
+          }
+        }
         if (!subAgentEmployee) continue;
 
-        const toolName = `delegate_to_${subAgentUsername.replace(/[^a-zA-Z0-9_-]/g, '_')}`;
-        const toolDescription = [
-          `Delegate a task to the AI Employee "${subAgentEmployee.nickname || subAgentUsername}".`,
-          subAgentEmployee.about ? `Specialist profile: ${subAgentEmployee.about.substring(0, 200)}` : '',
-          'The sub-agent will execute the task independently and return its final answer.',
-        ].filter(Boolean).join(' ');
-
-        // Capture the allowed leaders for this tool (for invoke-time scoping)
-        const allowedLeaders = leadersByTool.get(toolName)!;
-
-        register.registerTools({
-          scope: 'CUSTOM',
-          execution: 'backend',
-          defaultPermission: 'ALLOW',
-          silence: false,
-          introduction: {
-            title: `[Sub-Agent] ${subAgentEmployee.nickname || subAgentUsername}`,
-            about: toolDescription,
-          },
-          definition: {
-            name: toolName,
-            description: toolDescription,
-            schema: z.object({
-              task: z.string().describe('The detailed task description for the sub-agent to execute.'),
-              context: z.string().optional().describe('Optional additional context to help the sub-agent understand the task better.'),
-            }),
-          },
-          invoke: async (ctx: Context, args: { task: string; context?: string }, id: string) => {
-            // --- P2 FIX: Per-leader scoping at invoke time ---
-            // Core ToolsOptions doesn't support leaderUsername field, so
-            // we enforce scoping here by checking the calling employee.
-            const callingEmployee = (ctx as any)._currentAIEmployee?.username
-              || (ctx as any).state?.currentAIEmployee;
-            if (callingEmployee && !allowedLeaders.has(callingEmployee)) {
-              return {
-                status: 'error' as const,
-                content: `Employee "${callingEmployee}" is not authorized to delegate to "${subAgentUsername}". Configure an orchestration rule first.`,
-              };
-            }
+        const toolName = buildDelegateToolName(leaderUsername, subAgentUsername);
+        tools.push(createDelegateToolOptions(plugin, {
+          leaderUsername,
+          subAgentUsername,
+          subAgentEmployee,
+          maxDepth,
+          timeout,
+          toolName,
+          llmService: config.llmService,
+          model: config.model,
+        }));
+      }
 
-            return invokeDelegateTask(ctx, plugin, {
-              leaderUsername: callingEmployee || Array.from(allowedLeaders)[0] || '',
-              subAgentUsername,
-              subAgentEmployee,
-              task: args.task,
-              context: args.context,
-              maxDepth: maxDepth ?? 1,
-              timeout: timeout ?? 120000,
-              toolCallId: id,
-            });
-          },
-        });
+      // Compatibility for existing single-parent setups that already assigned
+      // delegate_to_<sub> to the parent employee's skills.
+      for (const [subAgentUsername, items] of configsBySubAgent.entries()) {
+        if (items.length !== 1) continue;
+        const config = items[0];
+        const subAgentEmployee = employeeCache.get(subAgentUsername);
+        if (!subAgentEmployee) continue;
+        const legacyToolName = `delegate_to_${sanitizeToolPart(subAgentUsername)}`;
+        if (tools.some((tool: any) => tool.definition.name === legacyToolName)) continue;
+        tools.push(createDelegateToolOptions(plugin, {
+          leaderUsername: config.leaderUsername,
+          subAgentUsername,
+          subAgentEmployee,
+          maxDepth: config.maxDepth,
+          timeout: config.timeout,
+          toolName: legacyToolName,
+          legacyAlias: true,
+          llmService: config.llmService,
+          model: config.model,
+        }));
+      }
+
+      if (tools.length) {
+        register.registerTools(tools);
       }
     } catch (e) {
       plugin.app.log.error('[AgentOrchestrator] Failed to register delegate tools', e);
@@ -153,13 +256,28 @@ async function invokeDelegateTask(
     maxDepth: number;
     timeout: number;
     toolCallId: string;
+    toolName: string;
+    llmService?: string;
+    model?: string;
   },
 ) {
-  const { leaderUsername, subAgentUsername, subAgentEmployee, task, context, maxDepth, timeout, toolCallId } = options;
+  const { leaderUsername, subAgentUsername, subAgentEmployee, task, context, maxDepth, timeout, toolCallId, toolName, llmService, model } = options;
 
   // --- P1: Depth enforcement ---
   const currentDepth: number = (ctx as any)[ORCHESTRATOR_DEPTH_KEY] ?? 0;
   if (currentDepth >= maxDepth) {
+    await logDelegation(ctx, plugin, {
+      leaderUsername,
+      subAgentUsername,
+      toolName,
+      task,
+      context,
+      result: '',
+      status: 'error',
+      depth: currentDepth,
+      durationMs: 0,
+      error: `Delegation depth limit reached (${currentDepth}/${maxDepth}).`,
+    });
     return {
       status: 'error' as const,
       content: `Delegation depth limit reached (${currentDepth}/${maxDepth}). Sub-agent "${subAgentUsername}" cannot delegate further.`,
@@ -167,6 +285,26 @@ async function invokeDelegateTask(
   }
 
   const startTime = Date.now();
+  const trace: TraceEvent[] = [
+    {
+      type: 'start',
+      at: nowIso(),
+      title: `Delegation started: ${leaderUsername} -> ${subAgentUsername}`,
+      content: task,
+    },
+  ];
+  const logRecord = await logDelegation(ctx, plugin, {
+    leaderUsername,
+    subAgentUsername,
+    toolName,
+    task,
+    context,
+    result: '',
+    status: 'running',
+    depth: currentDepth,
+    durationMs: 0,
+    trace,
+  });
 
   try {
     const aiPlugin = ctx.app.pm.get('ai') as PluginAIServer;
@@ -175,9 +313,27 @@ async function invokeDelegateTask(
     }
 
     // --- Step 1: Resolve LLM model from sub-agent's employee config ---
-    const modelSettings = subAgentEmployee.modelSettings;
+    let modelSettings = subAgentEmployee.modelSettings;
+    
+    // Override with orchestrator config if provided
+    if (llmService && model) {
+      modelSettings = { llmService, model };
+    }
+    
     if (!modelSettings?.llmService || !modelSettings?.model) {
-      throw new Error(`Sub-agent "${subAgentUsername}" has no LLM model configured. Please configure a model in the AI Employee settings.`);
+      // Fallback to leader's LLM model if sub-agent doesn't have one
+      const leaderEmployee = await plugin.db.getRepository('aiEmployees').findOne({
+        filter: { username: leaderUsername },
+      });
+      
+      // The leader's model might be empty in the DB if it relies on the dynamic system default.
+      // In that case, we extract the dynamic `model` passed from the frontend request.
+      const dynamicModel = ctx.action?.params?.values?.model;
+      modelSettings = leaderEmployee?.modelSettings || dynamicModel;
+      
+      if (!modelSettings?.llmService || !modelSettings?.model) {
+        throw new Error(`Sub-agent "${subAgentUsername}" has no LLM model configured (and leader fallback failed). Please configure a model in the Orchestrator Config or AI Employee settings.`);
+      }
     }
 
     const { provider } = await aiPlugin.aiManager.getLLMService({
@@ -207,7 +363,7 @@ async function invokeDelegateTask(
       // Only include tools that the sub-agent employee is configured to use.
       // Also skip our own delegate_to_* tools to prevent circular delegation
       // (belt-and-suspenders with the depth check above).
-      if (!employeeSkills.includes(toolName) || toolName.startsWith('delegate_to_')) {
+      if (!employeeSkills.includes(toolName) || isDelegateToolName(toolName)) {
         continue;
       }
 
@@ -221,11 +377,39 @@ async function invokeDelegateTask(
             const invokeCtx = Object.create(ctx);
             (invokeCtx as any)[ORCHESTRATOR_DEPTH_KEY] = currentDepth + 1;
 
-            const res = await toolEntry.invoke(invokeCtx, toolArgs, `orch-${toolCallId}`);
-            if (res?.status === 'error') {
-              throw new Error(`Tool <${toolName}> failed: ${res.content}`);
+            trace.push({
+              type: 'tool_call',
+              at: nowIso(),
+              title: `Calling tool: ${toolEntry.definition.name}`,
+              toolName: toolEntry.definition.name,
+              args: toolArgs,
+            });
+
+            try {
+              const res = await toolEntry.invoke(invokeCtx, toolArgs, `orch-${toolCallId}`);
+              trace.push({
+                type: 'tool_result',
+                at: nowIso(),
+                title: `Tool finished: ${toolEntry.definition.name}`,
+                toolName: toolEntry.definition.name,
+                status: res?.status || 'success',
+                content: truncateText(res?.content ?? res, 2000),
+              });
+              if (res?.status === 'error') {
+                throw new Error(`Tool <${toolEntry.definition.name}> failed: ${res.content}`);
+              }
+              return typeof res?.content === 'string' ? res.content : JSON.stringify(res);
+            } catch (e: any) {
+              trace.push({
+                type: 'tool_error',
+                at: nowIso(),
+                title: `Tool failed: ${toolEntry.definition.name}`,
+                toolName: toolEntry.definition.name,
+                status: 'error',
+                content: e.message,
+              });
+              throw e;
             }
-            return typeof res?.content === 'string' ? res.content : JSON.stringify(res);
           },
         }),
       );
@@ -255,19 +439,31 @@ async function invokeDelegateTask(
     const result = await Promise.race([
       invokePromise,
       createTimeout(timeout, subAgentUsername, abortController),
-    ]);
+    ]) as AgentExecutionResult;
 
-    const content = (result as string) || 'Sub-agent completed the task but produced no output.';
+    const content = result.content || 'Sub-agent completed the task but produced no output.';
+    trace.push({
+      type: 'finish',
+      at: nowIso(),
+      title: `Delegation finished: ${subAgentUsername}`,
+      status: 'success',
+      content: truncateText(content, 2000),
+    });
 
     // Log successful execution for tracing
     await logDelegation(ctx, plugin, {
+      id: logRecord?.id,
       leaderUsername,
       subAgentUsername,
+      toolName,
       task,
+      context,
       result: content,
       status: 'success',
       depth: currentDepth,
       durationMs: Date.now() - startTime,
+      trace,
+      messages: result.messages,
     });
 
     return {
@@ -279,15 +475,30 @@ async function invokeDelegateTask(
 
     // Log failed execution for tracing
     await logDelegation(ctx, plugin, {
+      id: logRecord?.id,
       leaderUsername,
       subAgentUsername,
+      toolName,
       task,
+      context,
       result: '',
       status: 'error',
       depth: currentDepth,
       durationMs: Date.now() - startTime,
       error: e.message,
-    }).catch(() => {}); // Don't let logging errors mask the real error
+      trace: [
+        ...trace,
+        {
+          type: 'error',
+          at: nowIso(),
+          title: `Delegation failed: ${subAgentUsername}`,
+          status: 'error',
+          content: e.message,
+        },
+      ],
+    }).catch((logErr) => {
+      plugin.app.log.warn('[AgentOrchestrator] Failed to save error log for delegation', logErr);
+    });
 
     return {
       status: 'error' as const,
@@ -303,34 +514,68 @@ async function logDelegation(
   ctx: Context,
   plugin: any,
   data: {
+    id?: number | string;
     leaderUsername: string;
     subAgentUsername: string;
+    toolName: string;
     task: string;
+    context?: string;
     result: string;
     status: string;
     depth: number;
     durationMs: number;
     error?: string;
+    trace?: TraceEvent[];
+    messages?: any[];
   },
 ) {
   try {
     const logsRepo = plugin.db.getRepository('orchestratorLogs');
-    if (!logsRepo) return;
+    if (!logsRepo) {
+      plugin.app.log.warn('[AgentOrchestrator] orchestratorLogs repository not found — skipping log');
+      return;
+    }
+
+    // Safely resolve userId — ctx may be stale after long-running agent execution
+    let userId: number | undefined;
+    try {
+      userId = ctx.auth?.user?.id || ctx.state?.currentUser?.id;
+    } catch {
+      // ctx lifecycle ended — proceed without userId
+    }
+
+    const values = {
+      leaderUsername: data.leaderUsername,
+      subAgentUsername: data.subAgentUsername,
+      toolName: data.toolName,
+      task: truncateText(data.task, 10000),
+      context: truncateText(data.context || '', 10000),
+      result: truncateText(data.result || '', 50000),
+      status: data.status,
+      depth: data.depth,
+      durationMs: data.durationMs,
+      error: truncateText(data.error || '', 10000),
+      trace: data.trace || [],
+      messages: data.messages || [],
+      userId,
+      updatedAt: new Date(),
+    };
 
-    await logsRepo.create({
+    if (data.id) {
+      await logsRepo.update({
+        filterByTk: data.id,
+        values,
+      });
+      return { id: data.id };
+    }
+
+    const record = await logsRepo.create({
       values: {
-        leaderUsername: data.leaderUsername,
-        subAgentUsername: data.subAgentUsername,
-        toolName: `delegate_to_${data.subAgentUsername}`,
-        task: (data.task || '').substring(0, 2000),
-        result: (data.result || '').substring(0, 5000),
-        status: data.status,
-        depth: data.depth,
-        durationMs: data.durationMs,
-        error: (data.error || '').substring(0, 2000),
-        userId: ctx.auth?.user?.id || ctx.state?.currentUser?.id,
+        ...values,
+        createdAt: new Date(),
       },
     });
+    return record?.toJSON?.() || record;
   } catch (e) {
     plugin.app.log.warn('[AgentOrchestrator] Failed to log delegation event', e);
   }
@@ -346,7 +591,7 @@ async function executeAgent(
   systemPrompt: string,
   task: string,
   signal?: AbortSignal,
-): Promise<string> {
+): Promise<AgentExecutionResult> {
   const config: any = { recursionLimit: 50 };
   if (signal) {
     config.signal = signal;
@@ -366,20 +611,37 @@ async function executeAgent(
   const lastAIMessage = [...messages].reverse().find(m => m.getType() === 'ai');
 
   if (!lastAIMessage || !lastAIMessage.content) {
-    return '';
+    return { content: '', messages: serializeMessages(messages) };
   }
 
+  let content = '';
   if (typeof lastAIMessage.content === 'string') {
-    return lastAIMessage.content;
-  }
-
-  if (Array.isArray(lastAIMessage.content)) {
-    return lastAIMessage.content
+    content = lastAIMessage.content;
+  } else if (Array.isArray(lastAIMessage.content)) {
+    content = lastAIMessage.content
       .map((c: any) => c.text || JSON.stringify(c))
       .join('\n');
+  } else {
+    content = String(lastAIMessage.content);
   }
 
-  return String(lastAIMessage.content);
+  return { content, messages: serializeMessages(messages) };
+}
+
+function serializeMessages(messages: any[]) {
+  return (messages || []).map((message, index) => {
+    const type = typeof message.getType === 'function' ? message.getType() : message.type;
+    return {
+      index,
+      type,
+      name: message.name,
+      content: truncateText(message.content, 10000),
+      toolCalls: message.tool_calls || message.toolCalls || [],
+      toolCallId: message.tool_call_id,
+      additionalKwargs: message.additional_kwargs,
+      responseMetadata: message.response_metadata,
+    };
+  });
 }
 
 /**