plugin-agent-orchestrator 1.0.6 → 1.0.13

package/src/client/RulesTab.tsx

@@ -13,6 +13,10 @@ import {
   Tag,
   Typography,
   Alert,
+  Collapse,
+  Empty,
+  Input,
+  Select,
 } from 'antd';
 import { PlusOutlined, EditOutlined, DeleteOutlined, SwapRightOutlined } from '@ant-design/icons';
 import { useAPIClient, useRequest } from '@nocobase/client';
@@ -34,8 +38,39 @@ export const RulesTab: React.FC = () => {
     },
   });
 
+  const { data: llmServicesData, loading: llmLoading } = useRequest({
+    url: 'llmServices:list',
+    params: {
+      filter: { enabled: true },
+    },
+  });
+
+  const llmServices = React.useMemo(() => {
+    return (llmServicesData as any)?.data || [];
+  }, [llmServicesData]);
+
   // P3 FIX: Use shared context instead of duplicate API call
   const { employeeMap } = useAIEmployees();
+  const rules = React.useMemo(() => {
+    const rows = (data as any)?.data;
+    return Array.isArray(rows) ? rows : [];
+  }, [data]);
+
+  const groupedRules = React.useMemo(() => {
+    const groups = new Map<string, any[]>();
+    for (const rule of rules) {
+      const key = rule.leaderUsername || 'unknown';
+      if (!groups.has(key)) {
+        groups.set(key, []);
+      }
+      groups.get(key)!.push(rule);
+    }
+
+    return Array.from(groups.entries()).map(([leaderUsername, items]) => ({
+      leaderUsername,
+      items,
+    }));
+  }, [rules]);
 
   const handleOpen = (record?: any) => {
     setEditingRecord(record);
@@ -136,6 +171,24 @@ export const RulesTab: React.FC = () => {
       width: 100,
       render: (v: number) => `${((v ?? 120000) / 1000).toFixed(0)}s`,
     },
+    {
+      title: 'LLM Override',
+      key: 'llmOverride',
+      width: 140,
+      render: (_: any, record: any) => {
+        if (record.llmService && record.model) {
+          const svc = llmServices.find((s: any) => s.name === record.llmService);
+          const svcName = svc ? svc.title : record.llmService;
+          return (
+            <Space direction="vertical" size={0}>
+              <Text style={{ fontSize: 12 }}>{svcName}</Text>
+              <Text type="secondary" style={{ fontSize: 12 }}>{record.model}</Text>
+            </Space>
+          );
+        }
+        return <Text type="secondary" style={{ fontSize: 12 }}>Inherited</Text>;
+      },
+    },
     {
       title: 'Enabled',
       dataIndex: 'enabled',
@@ -199,14 +252,41 @@ export const RulesTab: React.FC = () => {
             New Rule
           </Button>
         </div>
-        <Table
-          rowKey="id"
-          loading={loading}
-          dataSource={(data as any)?.data || []}
-          columns={columns}
-          pagination={{ hideOnSinglePage: true, pageSize: 20 }}
-          size="middle"
-        />
+        {groupedRules.length ? (
+          <Collapse
+            bordered={false}
+            defaultActiveKey={groupedRules.map((group) => group.leaderUsername)}
+            items={groupedRules.map((group) => ({
+              key: group.leaderUsername,
+              label: (
+                <Space>
+                  <Tag color="blue">{employeeMap.get(group.leaderUsername) || group.leaderUsername}</Tag>
+                  <Text type="secondary">{group.items.length} sub-agent{group.items.length > 1 ? 's' : ''}</Text>
+                </Space>
+              ),
+              children: (
+                <Table
+                  rowKey="id"
+                  loading={loading}
+                  dataSource={group.items}
+                  columns={columns}
+                  pagination={false}
+                  size="middle"
+                />
+              ),
+            }))}
+          />
+        ) : (
+          <Table
+            rowKey="id"
+            loading={loading}
+            dataSource={[]}
+            columns={columns}
+            pagination={false}
+            size="middle"
+            locale={{ emptyText: <Empty description="No orchestration rules yet" /> }}
+          />
+        )}
       </Card>
 
       <Drawer
@@ -262,6 +342,52 @@ export const RulesTab: React.FC = () => {
             <InputNumber min={10000} max={600000} step={10000} style={{ width: '100%' }} />
           </Form.Item>
 
+          <Form.Item
+            name="llmService"
+            label="Override LLM Service"
+            tooltip="Optional: Provider name. Leave empty to inherit from Leader."
+          >
+            <Select
+              allowClear
+              placeholder="Inherit from Leader"
+              options={llmServices.map((svc: any) => ({
+                label: svc.title || svc.name,
+                value: svc.name,
+              }))}
+              onChange={() => form.setFieldValue('model', undefined)}
+            />
+          </Form.Item>
+
+          <Form.Item
+            noStyle
+            shouldUpdate={(prevValues, currentValues) => prevValues.llmService !== currentValues.llmService}
+          >
+            {() => {
+              const selectedServiceId = form.getFieldValue('llmService');
+              const selectedService = llmServices.find((s: any) => s.name === selectedServiceId);
+              const availableModels = selectedService?.enabledModels?.models || [];
+              
+              return (
+                <Form.Item
+                  name="model"
+                  label="Override Model"
+                  tooltip="Optional: Model name. Leave empty to inherit from Leader."
+                  rules={[{ required: !!selectedServiceId, message: 'Please select a model' }]}
+                >
+                  <Select
+                    allowClear
+                    placeholder={selectedServiceId ? 'Select a model' : 'Inherit from Leader'}
+                    disabled={!selectedServiceId}
+                    options={availableModels.map((m: any) => ({
+                      label: m.label,
+                      value: m.value,
+                    }))}
+                  />
+                </Form.Item>
+              );
+            }}
+          </Form.Item>
+
           <Form.Item name="enabled" label="Enabled" valuePropName="checked">
             <Switch />
           </Form.Item>

package/src/client/TracingTab.tsx

@@ -9,19 +9,25 @@ import {
   Alert,
   Button,
   Empty,
+  Space,
+  Timeline,
+  Collapse,
+  Spin,
 } from 'antd';
 import {
   EyeOutlined,
   CheckCircleOutlined,
   CloseCircleOutlined,
 } from '@ant-design/icons';
-import { useRequest } from '@nocobase/client';
+import { useAPIClient, useRequest } from '@nocobase/client';
 import { useAIEmployees } from './AIEmployeesContext';
 
 const { Text, Paragraph } = Typography;
 
 export const TracingTab: React.FC = () => {
+  const api = useAPIClient();
   const [selectedLog, setSelectedLog] = useState<any>(null);
+  const [detailLoading, setDetailLoading] = useState(false);
 
   const { data, loading, refresh } = useRequest({
     url: 'orchestratorTracing:list',
@@ -32,6 +38,48 @@ export const TracingTab: React.FC = () => {
   });
 
   const { employeeMap } = useAIEmployees();
+  const logs = React.useMemo(() => {
+    let rows = (data as any)?.data;
+    // Handle double-wrapped NocoBase response data
+    if (rows && !Array.isArray(rows) && Array.isArray(rows.data)) {
+      rows = rows.data;
+    }
+    return Array.isArray(rows) ? rows : Array.isArray(data) ? data : [];
+  }, [data]);
+
+  const groupedLogs = React.useMemo(() => {
+    const groups = new Map<string, any[]>();
+    for (const log of logs) {
+      const key = log.leaderUsername || 'unknown';
+      if (!groups.has(key)) {
+        groups.set(key, []);
+      }
+      groups.get(key)!.push(log);
+    }
+    return Array.from(groups.entries()).map(([leaderUsername, items]) => ({
+      leaderUsername,
+      items,
+    }));
+  }, [logs]);
+
+  const formatDuration = (ms: number) => {
+    if (!ms) return '-';
+    return ms >= 1000 ? `${(ms / 1000).toFixed(1)}s` : `${ms}ms`;
+  };
+
+  const handleOpenLog = async (record: any) => {
+    setSelectedLog(record);
+    setDetailLoading(true);
+    try {
+      const res = await api.request({
+        url: 'orchestratorTracing:get',
+        params: { filterByTk: record.id },
+      });
+      setSelectedLog((res as any)?.data?.data || (res as any)?.data || record);
+    } finally {
+      setDetailLoading(false);
+    }
+  };
 
   const columns = [
     {
@@ -41,6 +89,14 @@ export const TracingTab: React.FC = () => {
       width: 170,
       render: (v: string) => v ? new Date(v).toLocaleString() : '-',
     },
+    {
+      title: 'Leader',
+      dataIndex: 'leaderUsername',
+      key: 'leaderUsername',
+      render: (username: string) => (
+        <Tag color="blue">{employeeMap.get(username) || username}</Tag>
+      ),
+    },
     {
       title: 'Sub-Agent',
       dataIndex: 'subAgentUsername',
@@ -78,10 +134,7 @@ export const TracingTab: React.FC = () => {
       dataIndex: 'durationMs',
       key: 'durationMs',
       width: 90,
-      render: (ms: number) => {
-        if (!ms) return '-';
-        return ms >= 1000 ? `${(ms / 1000).toFixed(1)}s` : `${ms}ms`;
-      },
+      render: formatDuration,
     },
     {
       title: 'Depth',
@@ -99,7 +152,7 @@ export const TracingTab: React.FC = () => {
           type="link"
           size="small"
           icon={<EyeOutlined />}
-          onClick={() => setSelectedLog(record)}
+          onClick={() => handleOpenLog(record)}
         >
           Detail
         </Button>
@@ -126,24 +179,51 @@ export const TracingTab: React.FC = () => {
         <div style={{ marginBottom: 16, display: 'flex', justifyContent: 'flex-end' }}>
           <Button onClick={refresh}>Refresh</Button>
         </div>
-        <Table
-          rowKey="id"
-          loading={loading}
-          dataSource={Array.isArray((data as any)?.data) ? (data as any).data : (Array.isArray(data) ? data : [])}
-          columns={columns}
-          pagination={{ hideOnSinglePage: true, pageSize: 20 }}
-          size="middle"
-          locale={{ emptyText: <Empty description="No delegation executions yet" /> }}
-        />
+        {groupedLogs.length ? (
+          <Collapse
+            bordered={false}
+            defaultActiveKey={groupedLogs.map((group) => group.leaderUsername)}
+            items={groupedLogs.map((group) => ({
+              key: group.leaderUsername,
+              label: (
+                <Space>
+                  <Tag color="blue">{employeeMap.get(group.leaderUsername) || group.leaderUsername}</Tag>
+                  <Text type="secondary">{group.items.length} execution{group.items.length > 1 ? 's' : ''}</Text>
+                </Space>
+              ),
+              children: (
+                <Table
+                  rowKey="id"
+                  loading={loading}
+                  dataSource={group.items}
+                  columns={columns}
+                  pagination={{ hideOnSinglePage: true, pageSize: 20 }}
+                  size="middle"
+                />
+              ),
+            }))}
+          />
+        ) : (
+          <Table
+            rowKey="id"
+            loading={loading}
+            dataSource={[]}
+            columns={columns}
+            pagination={false}
+            size="middle"
+            locale={{ emptyText: <Empty description="No delegation executions yet" /> }}
+          />
+        )}
       </Card>
 
       <Drawer
         title="Delegation Detail"
-        width={640}
+        width={760}
         onClose={() => setSelectedLog(null)}
         open={!!selectedLog}
       >
         {selectedLog && (
+          <Spin spinning={detailLoading}>
           <>
             <Descriptions column={1} bordered size="small" style={{ marginBottom: 16 }}>
               <Descriptions.Item label="Status">
@@ -154,6 +234,11 @@ export const TracingTab: React.FC = () => {
                   {selectedLog.status}
                 </Tag>
               </Descriptions.Item>
+              <Descriptions.Item label="Leader">
+                <Tag color="blue">
+                  {employeeMap.get(selectedLog.leaderUsername) || selectedLog.leaderUsername}
+                </Tag>
+              </Descriptions.Item>
               <Descriptions.Item label="Sub-Agent">
                 <Tag color="green">
                   {employeeMap.get(selectedLog.subAgentUsername) || selectedLog.subAgentUsername}
@@ -166,11 +251,7 @@ export const TracingTab: React.FC = () => {
                 {selectedLog.depth ?? 0}
               </Descriptions.Item>
               <Descriptions.Item label="Duration">
-                {selectedLog.durationMs
-                  ? selectedLog.durationMs >= 1000
-                    ? `${(selectedLog.durationMs / 1000).toFixed(1)}s`
-                    : `${selectedLog.durationMs}ms`
-                  : '-'}
+                {formatDuration(selectedLog.durationMs)}
               </Descriptions.Item>
               <Descriptions.Item label="Time">
                 {selectedLog.createdAt ? new Date(selectedLog.createdAt).toLocaleString() : '-'}
@@ -183,6 +264,74 @@ export const TracingTab: React.FC = () => {
               </Paragraph>
             </Card>
 
+            {selectedLog.context && (
+              <Card title="Context" size="small" style={{ marginBottom: 16 }}>
+                <Paragraph style={{ whiteSpace: 'pre-wrap', margin: 0, fontSize: 13 }}>
+                  {selectedLog.context}
+                </Paragraph>
+              </Card>
+            )}
+
+            <Card title="Sub-Agent Flow" size="small" style={{ marginBottom: 16 }}>
+              {Array.isArray(selectedLog.trace) && selectedLog.trace.length ? (
+                <Timeline
+                  items={selectedLog.trace.map((item: any, index: number) => ({
+                    key: index,
+                    color: item.status === 'error' ? 'red' : item.type === 'tool_call' ? 'blue' : 'green',
+                    children: (
+                      <div>
+                        <Space direction="vertical" size={2} style={{ width: '100%' }}>
+                          <Text strong>{item.title || item.type}</Text>
+                          <Text type="secondary">{item.at ? new Date(item.at).toLocaleString() : ''}</Text>
+                          {item.toolName && <Text code>{item.toolName}</Text>}
+                          {item.content && (
+                            <Paragraph style={{ whiteSpace: 'pre-wrap', margin: 0, fontSize: 13 }}>
+                              {item.content}
+                            </Paragraph>
+                          )}
+                          {item.args && (
+                            <Paragraph style={{ whiteSpace: 'pre-wrap', margin: 0, fontSize: 12 }}>
+                              {JSON.stringify(item.args, null, 2)}
+                            </Paragraph>
+                          )}
+                        </Space>
+                      </div>
+                    ),
+                  }))}
+                />
+              ) : (
+                <Empty description="No flow trace captured" />
+              )}
+            </Card>
+
+            {Array.isArray(selectedLog.messages) && selectedLog.messages.length > 0 && (
+              <Collapse
+                style={{ marginBottom: 16 }}
+                items={[
+                  {
+                    key: 'messages',
+                    label: `Raw messages (${selectedLog.messages.length})`,
+                    children: (
+                      <Space direction="vertical" style={{ width: '100%' }}>
+                        {selectedLog.messages.map((message: any) => (
+                          <Card key={message.index} size="small" title={`${message.index + 1}. ${message.type}`}>
+                            <Paragraph style={{ whiteSpace: 'pre-wrap', margin: 0, fontSize: 12 }}>
+                              {message.content || JSON.stringify(message.toolCalls || message, null, 2)}
+                            </Paragraph>
+                            {message.toolCalls?.length > 0 && (
+                              <Paragraph style={{ whiteSpace: 'pre-wrap', margin: '8px 0 0', fontSize: 12 }}>
+                                {JSON.stringify(message.toolCalls, null, 2)}
+                              </Paragraph>
+                            )}
+                          </Card>
+                        ))}
+                      </Space>
+                    ),
+                  },
+                ]}
+              />
+            )}
+
             <Card
               title="Result"
               size="small"
@@ -210,6 +359,7 @@ export const TracingTab: React.FC = () => {
               </Card>
             )}
           </>
+          </Spin>
         )}
       </Drawer>
     </div>

package/src/server/collections/orchestrator-config.ts

@@ -39,6 +39,16 @@ export default defineCollection({
       defaultValue: 120000,
       comment: 'Timeout in ms for sub-agent execution',
     },
+    {
+      name: 'llmService',
+      type: 'string',
+      comment: 'Optional overridden LLM provider for the sub-agent',
+    },
+    {
+      name: 'model',
+      type: 'string',
+      comment: 'Optional overridden model for the sub-agent',
+    },
   ],
   indexes: [
     {

package/src/server/collections/orchestrator-logs.ts

@@ -31,7 +31,12 @@ export default defineCollection({
     {
       name: 'toolName',
       type: 'string',
-      comment: 'The tool name used for delegation (e.g., delegate_to_sql_expert)',
+      comment: 'The tool name used for delegation (e.g., delegate_pm_to_sql_expert)',
+    },
+    {
+      name: 'context',
+      type: 'text',
+      comment: 'Optional context sent with the delegated task',
     },
     {
       name: 'task',
@@ -46,7 +51,7 @@ export default defineCollection({
     {
       name: 'status',
       type: 'string',
-      comment: 'success or error',
+      comment: 'running, success, or error',
     },
     {
       name: 'depth',
@@ -64,6 +69,18 @@ export default defineCollection({
       type: 'text',
       comment: 'Error message if status is error',
     },
+    {
+      name: 'trace',
+      type: 'json',
+      defaultValue: [],
+      comment: 'Structured timeline of sub-agent execution and tool calls',
+    },
+    {
+      name: 'messages',
+      type: 'json',
+      defaultValue: [],
+      comment: 'Serialized LangChain messages from the sub-agent run',
+    },
     {
       name: 'userId',
       type: 'bigInt',

package/src/server/migrations/20260427000000-add-tracing-detail-fields.ts

@@ -0,0 +1,41 @@
+import { Migration } from '@nocobase/server';
+
+export default class AddTracingDetailFieldsMigration extends Migration {
+  on = 'afterLoad';
+  appVersion = '<=2.x';
+
+  async up() {
+    const queryInterface = this.db.sequelize.getQueryInterface();
+    const DataTypes = this.db.sequelize.constructor['DataTypes'];
+    const tableName = `${this.db.options.tablePrefix || ''}orchestratorLogs`;
+
+    const tableExists = await queryInterface
+      .describeTable(tableName)
+      .then(() => true)
+      .catch(() => false);
+
+    if (!tableExists) {
+      return;
+    }
+
+    const columns = await queryInterface.describeTable(tableName);
+    const addIfMissing = async (name: string, definition: any) => {
+      if (!columns[name]) {
+        await queryInterface.addColumn(tableName, name, definition);
+      }
+    };
+
+    await addIfMissing('context', { type: DataTypes.TEXT, allowNull: true });
+    await addIfMissing('trace', { type: DataTypes.JSON, allowNull: true, defaultValue: [] });
+    await addIfMissing('messages', { type: DataTypes.JSON, allowNull: true, defaultValue: [] });
+  }
+
+  async down() {
+    const queryInterface = this.db.sequelize.getQueryInterface();
+    const tableName = `${this.db.options.tablePrefix || ''}orchestratorLogs`;
+
+    for (const column of ['context', 'trace', 'messages']) {
+      await queryInterface.removeColumn(tableName, column).catch(() => {});
+    }
+  }
+}

package/src/server/migrations/20260429000000-add-llm-fields.ts

@@ -0,0 +1,37 @@
+import { Migration } from '@nocobase/server';
+
+export default class AddLlmFieldsToOrchestratorConfig extends Migration {
+  on = 'afterLoad';
+  appVersion = '>=0.1.0';
+
+  async up() {
+    const queryInterface = this.db.sequelize.getQueryInterface();
+    const tablePrefix = this.db.options.tablePrefix || '';
+    const tableName = `${tablePrefix}orchestratorConfig`;
+
+    const tableExists = await queryInterface.tableExists(tableName);
+    if (!tableExists) return;
+
+    const tableDesc = await queryInterface.describeTable(tableName);
+
+    if (!tableDesc['llmService']) {
+      await queryInterface.addColumn(tableName, 'llmService', {
+        type: 'VARCHAR(255)',
+        allowNull: true,
+      });
+      console.log(`[AgentOrchestrator] Added llmService column to ${tableName}`);
+    }
+
+    if (!tableDesc['model']) {
+      await queryInterface.addColumn(tableName, 'model', {
+        type: 'VARCHAR(255)',
+        allowNull: true,
+      });
+      console.log(`[AgentOrchestrator] Added model column to ${tableName}`);
+    }
+  }
+
+  async down() {
+    // No rollback
+  }
+}

package/src/server/resources/tracing.ts

@@ -16,10 +16,11 @@ export function registerTracingResource(plugin: Plugin) {
        */
       async list(ctx, next) {
         const repo = ctx.db.getRepository('orchestratorLogs');
-        const { page = 1, pageSize = 50, sort = ['-createdAt'] } = ctx.action.params;
+        const { page = 1, pageSize = 50, sort = ['-createdAt'], filter = {} } = ctx.action.params;
 
         try {
           const [rows, count] = await repo.findAndCount({
+            filter,
             sort,
             offset: (Number(page) - 1) * Number(pageSize),
             limit: Number(pageSize),
@@ -32,6 +33,7 @@ export function registerTracingResource(plugin: Plugin) {
               subAgentUsername: row.subAgentUsername,
               toolName: row.toolName,
               task: row.task,
+              context: row.context,
               result: row.result,
               status: row.status,
               depth: row.depth,
@@ -39,6 +41,8 @@ export function registerTracingResource(plugin: Plugin) {
               error: row.error,
               userId: row.userId,
               createdAt: row.createdAt,
+              traceCount: Array.isArray(row.trace) ? row.trace.length : 0,
+              messageCount: Array.isArray(row.messages) ? row.messages.length : 0,
             })),
             meta: {
               count,
@@ -72,7 +76,7 @@ export function registerTracingResource(plugin: Plugin) {
             filter: { id: filterByTk },
           });
 
-          ctx.body = { data: log };
+          ctx.body = { data: log?.toJSON?.() || log || null };
         } catch (e) {
           ctx.log.error('[AgentOrchestrator] Tracing get error', e);
           ctx.body = { data: null };