plugin-agent-orchestrator 1.0.17 → 1.0.18

package/src/client/HarnessProfilesTab.tsx

@@ -0,0 +1,247 @@
+import React from 'react';
+import { Button, Card, Drawer, Form, Input, Popconfirm, Space, Switch, Table, Tag, Typography, message } from 'antd';
+import { DeleteOutlined, EditOutlined, PlusOutlined } from '@ant-design/icons';
+import { useAPIClient, useRequest } from '@nocobase/client';
+
+const { Text } = Typography;
+
+const parseSettings = (value: string) => {
+  const text = String(value || '').trim();
+  if (!text) return {};
+  return JSON.parse(text);
+};
+
+export const HarnessProfilesTab: React.FC = () => {
+  const api = useAPIClient();
+  const [open, setOpen] = React.useState(false);
+  const [editingRecord, setEditingRecord] = React.useState<any>(null);
+  const [form] = Form.useForm();
+
+  const { data, loading, refresh } = useRequest({
+    url: 'agentHarnessProfiles:list',
+    params: {
+      sort: ['tag'],
+      pageSize: 100,
+    },
+  });
+
+  const rows = React.useMemo(() => {
+    const raw = (data as any)?.data;
+    return Array.isArray(raw) ? raw : [];
+  }, [data]);
+
+  const openDrawer = (record?: any) => {
+    setEditingRecord(record || null);
+    form.resetFields();
+    form.setFieldsValue(
+      record
+        ? {
+            ...record,
+            settingsText: JSON.stringify(record.settings || {}, null, 2),
+          }
+        : {
+            tag: '',
+            title: '',
+            description: '',
+            enabled: true,
+            settingsText: JSON.stringify(
+              {
+                requirePlanApproval: true,
+                allowSubAgents: true,
+                allowToolCalls: true,
+                maxParallelSubAgents: 3,
+                maxControllerSteps: 100,
+              },
+              null,
+              2,
+            ),
+          },
+    );
+    setOpen(true);
+  };
+
+  const closeDrawer = () => {
+    setOpen(false);
+    setEditingRecord(null);
+  };
+
+  const saveProfile = async (values: any) => {
+    let settings: any;
+    try {
+      settings = parseSettings(values.settingsText);
+    } catch (error: any) {
+      message.error(`Settings JSON is invalid: ${error?.message || error}`);
+      return;
+    }
+
+    const payload = {
+      tag: String(values.tag || '').trim(),
+      title: values.title,
+      description: values.description,
+      enabled: values.enabled !== false,
+      settings,
+    };
+
+    try {
+      if (editingRecord) {
+        await api.request({
+          url: 'agentHarnessProfiles:update',
+          method: 'put',
+          params: { filterByTk: editingRecord.id },
+          data: payload,
+        });
+        message.success('Harness profile updated');
+      } else {
+        await api.request({
+          url: 'agentHarnessProfiles:create',
+          method: 'post',
+          data: payload,
+        });
+        message.success('Harness profile created');
+      }
+      closeDrawer();
+      refresh();
+    } catch (error: any) {
+      const msg = error?.response?.data?.errors?.[0]?.message || error?.message || 'unknown error';
+      message.error(`Save failed: ${msg}`);
+    }
+  };
+
+  const deleteProfile = async (id: string | number) => {
+    try {
+      await api.request({
+        url: 'agentHarnessProfiles:destroy',
+        method: 'delete',
+        params: { filterByTk: id },
+      });
+      message.success('Harness profile deleted');
+      refresh();
+    } catch (error: any) {
+      message.error(`Delete failed: ${error?.message || 'unknown error'}`);
+    }
+  };
+
+  const columns = [
+    {
+      title: 'Tag',
+      dataIndex: 'tag',
+      key: 'tag',
+      width: 140,
+      render: (tag: string) => <Tag color="blue">{tag}</Tag>,
+    },
+    {
+      title: 'Title',
+      dataIndex: 'title',
+      key: 'title',
+      render: (title: string, record: any) => title || record.tag,
+    },
+    {
+      title: 'Enabled',
+      dataIndex: 'enabled',
+      key: 'enabled',
+      width: 90,
+      render: (enabled: boolean, record: any) => (
+        <Switch
+          size="small"
+          checked={enabled !== false}
+          onChange={async (checked) => {
+            await api.request({
+              url: 'agentHarnessProfiles:update',
+              method: 'put',
+              params: { filterByTk: record.id },
+              data: { enabled: checked },
+            });
+            refresh();
+          }}
+        />
+      ),
+    },
+    {
+      title: 'Settings',
+      key: 'settings',
+      render: (_: any, record: any) => (
+        <Space size={4} wrap>
+          {Object.entries(record.settings || {})
+            .slice(0, 5)
+            .map(([key, value]) => (
+              <Tag key={key}>
+                {key}: {String(value)}
+              </Tag>
+            ))}
+        </Space>
+      ),
+    },
+    {
+      title: 'Actions',
+      key: 'actions',
+      width: 150,
+      render: (_: any, record: any) => (
+        <Space>
+          <Button type="link" size="small" icon={<EditOutlined />} onClick={() => openDrawer(record)}>
+            Edit
+          </Button>
+          <Popconfirm title="Delete this profile?" onConfirm={() => deleteProfile(record.id)}>
+            <Button type="link" size="small" danger icon={<DeleteOutlined />}>
+              Delete
+            </Button>
+          </Popconfirm>
+        </Space>
+      ),
+    },
+  ];
+
+  return (
+    <div>
+      <Card bordered={false}>
+        <Space direction="vertical" size={16} style={{ width: '100%' }}>
+          <div style={{ display: 'flex', justifyContent: 'space-between', gap: 16 }}>
+            <Text type="secondary">
+              Harness profiles are selected by orchestration rules through the harnessTag field.
+            </Text>
+            <Button type="primary" icon={<PlusOutlined />} onClick={() => openDrawer()}>
+              New Profile
+            </Button>
+          </div>
+          <Table rowKey="id" loading={loading} dataSource={rows} columns={columns} pagination={false} />
+        </Space>
+      </Card>
+
+      <Drawer
+        title={editingRecord ? 'Edit Harness Profile' : 'New Harness Profile'}
+        width={560}
+        open={open}
+        onClose={closeDrawer}
+        extra={
+          <Space>
+            <Button onClick={closeDrawer}>Cancel</Button>
+            <Button type="primary" onClick={() => form.submit()}>
+              Save
+            </Button>
+          </Space>
+        }
+      >
+        <Form form={form} layout="vertical" onFinish={saveProfile}>
+          <Form.Item name="tag" label="Tag" rules={[{ required: true, message: 'Tag is required' }]}>
+            <Input placeholder="default" disabled={editingRecord?.tag === 'default'} />
+          </Form.Item>
+          <Form.Item name="title" label="Title">
+            <Input />
+          </Form.Item>
+          <Form.Item name="description" label="Description">
+            <Input.TextArea rows={3} />
+          </Form.Item>
+          <Form.Item
+            name="settingsText"
+            label="Settings JSON"
+            rules={[{ required: true, message: 'Settings JSON is required' }]}
+          >
+            <Input.TextArea rows={12} spellCheck={false} />
+          </Form.Item>
+          <Form.Item name="enabled" label="Enabled" valuePropName="checked">
+            <Switch />
+          </Form.Item>
+        </Form>
+      </Drawer>
+    </div>
+  );
+};

package/src/client/OrchestratorSettings.tsx

@@ -1,10 +1,21 @@
 import React from 'react';
 import { Tabs } from 'antd';
-import { ApartmentOutlined, BarChartOutlined, CodeOutlined, HistoryOutlined, MonitorOutlined } from '@ant-design/icons';
+import {
+  ApartmentOutlined,
+  BarChartOutlined,
+  CheckCircleOutlined,
+  CodeOutlined,
+  HistoryOutlined,
+  MonitorOutlined,
+  ProfileOutlined,
+  SettingOutlined,
+} from '@ant-design/icons';
 import { RulesTab } from './RulesTab';
 import { TracingTab } from './TracingTab';
+import { AgentRunsTab } from './AgentRunsTab';
+import { HarnessProfilesTab } from './HarnessProfilesTab';
 import { AIEmployeesProvider } from './AIEmployeesContext';
-import { SkillManager, ExecutionHistory, SkillMetrics } from './skill-hub';
+import { SkillManager, ExecutionHistory, SkillMetrics, LoopSettings } from './skill-hub';
 
 const OrchestratorSettings: React.FC = () => {
   return (
@@ -31,6 +42,24 @@ const OrchestratorSettings: React.FC = () => {
               ),
               children: <TracingTab />,
             },
+            {
+              key: 'agent-runs',
+              label: (
+                <span>
+                  <ProfileOutlined /> Agent Runs
+                </span>
+              ),
+              children: <AgentRunsTab />,
+            },
+            {
+              key: 'harness-profiles',
+              label: (
+                <span>
+                  <SettingOutlined /> Harness Profiles
+                </span>
+              ),
+              children: <HarnessProfilesTab />,
+            },
             {
               key: 'skill-definitions',
               label: (
@@ -49,6 +78,15 @@ const OrchestratorSettings: React.FC = () => {
               ),
               children: <ExecutionHistory />,
             },
+            {
+              key: 'skill-loop-settings',
+              label: (
+                <span>
+                  <CheckCircleOutlined /> Skill Review Settings
+                </span>
+              ),
+              children: <LoopSettings />,
+            },
             {
               key: 'skill-metrics',
               label: (

package/src/client/RulesTab.tsx

@@ -40,6 +40,12 @@ const sanitizeToolPart = (value: string) => (value || '').replace(/[^a-zA-Z0-9_-
 const expectedDelegateToolName = (leader: string, sub: string) =>
   `delegate_${sanitizeToolPart(leader)}_to_${sanitizeToolPart(sub)}`;
 const expectedDispatchToolName = (leader: string) => `dispatch_subagents_${sanitizeToolPart(leader)}`;
+const controllerToolNames = [
+  'orchestrator_plan_goal',
+  'orchestrator_execute_plan',
+  'orchestrator_status',
+  'orchestrator_cancel',
+];
 
 export const RulesTab: React.FC = () => {
   const api = useAPIClient();
@@ -58,12 +64,27 @@ export const RulesTab: React.FC = () => {
     url: 'ai:listAllEnabledModels',
   });
 
+  const { data: harnessProfilesData, loading: harnessLoading } = useRequest({
+    url: 'agentHarnessProfiles:list',
+    params: {
+      filter: { enabled: true },
+      sort: ['tag'],
+      pageSize: 100,
+    },
+  });
+
   const llmServices = React.useMemo(() => {
     const raw = (llmServicesData as any)?.data ?? llmServicesData;
     if (Array.isArray(raw)) return raw;
     return Array.isArray(raw?.data) ? raw.data : [];
   }, [llmServicesData]);
 
+  const harnessProfiles = React.useMemo(() => {
+    const raw = (harnessProfilesData as any)?.data ?? harnessProfilesData;
+    if (Array.isArray(raw)) return raw;
+    return Array.isArray(raw?.data) ? raw.data : [];
+  }, [harnessProfilesData]);
+
   // P3 FIX: Use shared context instead of duplicate API call
   const { employeeMap, skillsMap, refresh: refreshEmployees } = useAIEmployees();
   const rules = React.useMemo(() => {
@@ -71,7 +92,7 @@ export const RulesTab: React.FC = () => {
     return Array.isArray(rows) ? rows : [];
   }, [data]);
 
-  const handleAddSkillToEmployee = async (employeeUsername: string, toolName: string) => {
+  const handleAddSkillsToEmployee = async (employeeUsername: string, toolNames: string[]) => {
     try {
       // Re-fetch the leader to merge its current skills (skillsMap may be stale).
       const leaderResp = await api.request({
@@ -84,25 +105,31 @@ export const RulesTab: React.FC = () => {
         return;
       }
       const existing = Array.isArray(leader.skillSettings?.skills) ? leader.skillSettings.skills : [];
-      if (existing.some((s: any) => (typeof s === 'string' ? s : s?.name) === toolName)) {
-        message.info('Skill already present.');
+      const existingNames = new Set(existing.map((s: any) => (typeof s === 'string' ? s : s?.name)));
+      const missing = toolNames.filter((toolName) => !existingNames.has(toolName));
+      if (!missing.length) {
+        message.info('Skills already present.');
         await refreshEmployees();
         return;
       }
-      const nextSkills = [...existing, { name: toolName, autoCall: false }];
+      const nextSkills = [...existing, ...missing.map((name) => ({ name, autoCall: false }))];
       await api.request({
         url: 'aiEmployees:update',
         method: 'put',
         params: { filterByTk: employeeUsername },
         data: { skillSettings: { ...(leader.skillSettings || {}), skills: nextSkills } },
       });
-      message.success(`Added "${toolName}" to ${employeeUsername}'s skills.`);
+      message.success(`Added ${missing.length} skill${missing.length > 1 ? 's' : ''} to ${employeeUsername}.`);
       await refreshEmployees();
     } catch (e: any) {
       message.error(`Auto-assign failed: ${e?.message || 'unknown error'}`);
     }
   };
 
+  const handleAddSkillToEmployee = async (employeeUsername: string, toolName: string) => {
+    await handleAddSkillsToEmployee(employeeUsername, [toolName]);
+  };
+
   const handleAutoAssignSkill = async (record: any) => {
     await handleAddSkillToEmployee(
       record.leaderUsername,
@@ -154,7 +181,7 @@ export const RulesTab: React.FC = () => {
       form.setFieldsValue(record);
     } else {
       form.resetFields();
-      form.setFieldsValue({ enabled: true, maxDepth: 1, timeout: 120000, recursionLimit: 50 });
+      form.setFieldsValue({ enabled: true, maxDepth: 1, timeout: 120000, recursionLimit: 50, harnessTag: 'default' });
     }
     setVisible(true);
   };
@@ -229,6 +256,13 @@ export const RulesTab: React.FC = () => {
       key: 'subAgentUsername',
       render: (username: string) => <Tag color="green">{employeeMap.get(username) || username}</Tag>,
     },
+    {
+      title: 'Harness',
+      dataIndex: 'harnessTag',
+      key: 'harnessTag',
+      width: 120,
+      render: (tag: string) => <Tag color="purple">{tag || 'default'}</Tag>,
+    },
     {
       title: 'Max Depth',
       dataIndex: 'maxDepth',
@@ -366,6 +400,17 @@ export const RulesTab: React.FC = () => {
       .filter(Boolean) as Array<{ leaderUsername: string; toolName: string; count: number }>;
   }, [groupedRules, skillsMap]);
 
+  const missingControllerSkills = React.useMemo(() => {
+    return groupedRules
+      .map((group) => {
+        const leaderSkills = skillsMap.get(group.leaderUsername);
+        if (!leaderSkills) return null;
+        const missing = controllerToolNames.filter((toolName) => !leaderSkills.has(toolName));
+        return missing.length ? { leaderUsername: group.leaderUsername, missing } : null;
+      })
+      .filter(Boolean) as Array<{ leaderUsername: string; missing: string[] }>;
+  }, [groupedRules, skillsMap]);
+
   return (
     <div>
       <Alert
@@ -397,6 +442,39 @@ export const RulesTab: React.FC = () => {
         />
       )}
 
+      {missingControllerSkills.length > 0 && (
+        <Alert
+          type="warning"
+          showIcon
+          style={{ marginBottom: 16 }}
+          message={`${missingControllerSkills.length} leader${
+            missingControllerSkills.length > 1 ? 's' : ''
+          } missing orchestrator controller tools`}
+          description={
+            <Space direction="vertical" size={6}>
+              <Text type="secondary">
+                Leaders need the orchestrator controller tools to create an approval-first plan and execute it after
+                the user accepts the card.
+              </Text>
+              {missingControllerSkills.map(({ leaderUsername, missing }) => (
+                <Space key={leaderUsername} size={8} wrap>
+                  <Tag color="blue">{employeeMap.get(leaderUsername) || leaderUsername}</Tag>
+                  <Text type="secondary">{missing.length} missing</Text>
+                  <Button
+                    type="link"
+                    size="small"
+                    icon={<ThunderboltOutlined />}
+                    onClick={() => handleAddSkillsToEmployee(leaderUsername, missing)}
+                  >
+                    Auto-add
+                  </Button>
+                </Space>
+              ))}
+            </Space>
+          }
+        />
+      )}
+
       {missingDispatchSkills.length > 0 && (
         <Alert
           type="warning"
@@ -560,6 +638,25 @@ export const RulesTab: React.FC = () => {
             <InputNumber min={5} max={200} step={5} style={{ width: '100%' }} />
           </Form.Item>
 
+          <Form.Item
+            name="harnessTag"
+            label="Harness Profile"
+            tooltip="Profile tag used by plan approval, controller limits, and orchestration policy."
+          >
+            <Select
+              loading={harnessLoading}
+              options={[
+                { label: 'default', value: 'default' },
+                ...harnessProfiles
+                  .filter((profile: any) => profile.tag !== 'default')
+                  .map((profile: any) => ({
+                    label: profile.title ? `${profile.tag} - ${profile.title}` : profile.tag,
+                    value: profile.tag,
+                  })),
+              ]}
+            />
+          </Form.Item>
+
           <Form.Item
             name="llmService"
             label="Override LLM Service"

package/src/client/plugin.tsx

@@ -1,54 +1,27 @@
-import { Plugin } from '@nocobase/client';
-import { OrchestratorSettings } from './OrchestratorSettings';
-
-import { InteractionSchemasProvider } from './skill-hub/tools/InteractionSchemasProvider';
-import { SkillHubCard } from './skill-hub/tools/SkillHubCard';
-import { parseJsonText } from './skill-hub/utils/jsonFields';
-
-const sanitize = (name: string) =>
-  name
-    .toLowerCase()
-    .replace(/[^a-z0-9_]/g, '_')
-    .replace(/_+/g, '_')
-    .replace(/^_|_$/g, '');
-
-export class PluginAgentOrchestratorClient extends Plugin {
-  async load() {
-    (this as any).app.use(InteractionSchemasProvider);
-
-    // Register under the "AI" settings group for consistency with other AI plugins
-    (this as any).app.pluginSettingsManager.add('ai.orchestrator', {
-      title: 'Agent Orchestrator',
-      icon: 'ApartmentOutlined',
-      Component: OrchestratorSettings,
-    });
-
-    await this.registerSkillUiCards();
-  }
-
-  private async registerSkillUiCards() {
-    const toolsManager = (this as any).app.aiManager?.toolsManager;
-    if (!toolsManager) return;
-
-    try {
-      const { data } = await (this as any).app.apiClient.request({
-        url: 'skillDefinitions:list',
-        params: {
-          filter: { enabled: true },
-          fields: ['name', 'autoCall', 'interactionSchema'],
-          pageSize: 200,
-        },
-      });
-      const list = (data as any)?.data ?? [];
-      for (const s of list) {
-        if (s.autoCall) continue;
-        if (!parseJsonText(s.interactionSchema, null)) continue;
-        toolsManager.registerTools(`skill_hub_${sanitize(s.name)}`, { ui: { card: SkillHubCard } });
-      }
-    } catch {
-      // user without ACL or backend unavailable — skip silently
-    }
-  }
-}
-
-export default PluginAgentOrchestratorClient;
+import { Plugin } from '@nocobase/client';
+import { OrchestratorSettings } from './OrchestratorSettings';
+import { InteractionSchemasProvider } from './skill-hub/tools/InteractionSchemasProvider';
+import { registerSkillLoopCards } from './skill-hub/tools/registerSkillLoopCards';
+import { registerOrchestratorCards } from './tools/registerOrchestratorCards';
+
+export class PluginAgentOrchestratorClient extends Plugin {
+  async load() {
+    (this as any).app.use(InteractionSchemasProvider);
+
+    // Register under the "AI" settings group for consistency with other AI plugins
+    (this as any).app.pluginSettingsManager.add('ai.orchestrator', {
+      title: 'Agent Orchestrator',
+      icon: 'ApartmentOutlined',
+      Component: OrchestratorSettings,
+    });
+
+    await this.registerSkillUiCards();
+  }
+
+  private async registerSkillUiCards() {
+    await registerOrchestratorCards((this as any).app);
+    await registerSkillLoopCards((this as any).app);
+  }
+}
+
+export default PluginAgentOrchestratorClient;