plugin-agent-orchestrator 1.0.21 → 1.0.23

package/src/client-v2/skill-hub/components/SkillMetrics.tsx

@@ -0,0 +1,157 @@
+import React, { useState, useEffect, useCallback, useMemo } from 'react';
+import { Card, Table, Typography, Space, Row, Col, Statistic, Progress } from 'antd';
+import { SyncOutlined, CheckCircleOutlined, CloseCircleOutlined, ClockCircleOutlined } from '@ant-design/icons';
+import { useApiClient as useAPIClient } from '../../hooks/useApiRequest';
+import { useT } from '../locale';
+
+const { Title, Text } = Typography;
+
+export const SkillMetrics: React.FC = () => {
+  const api = useAPIClient();
+  const t = useT();
+  const [executions, setExecutions] = useState<any[]>([]);
+  const [loading, setLoading] = useState(false);
+
+  const fetchExecutions = useCallback(async () => {
+    setLoading(true);
+    try {
+      // Fetch up to 1000 recent executions to calculate basic metrics
+      const { data } = await api.request({
+        url: 'skillExecutions:list',
+        params: {
+          pageSize: 1000,
+          sort: ['-createdAt'],
+          appends: ['skill'],
+        },
+      });
+      const rawData = data?.data?.data ?? data?.data ?? [];
+      setExecutions(Array.isArray(rawData) ? rawData : []);
+    } catch {
+      // ignore
+    } finally {
+      setLoading(false);
+    }
+  }, [api]);
+
+  useEffect(() => {
+    fetchExecutions();
+  }, [fetchExecutions]);
+
+  const metrics = useMemo(() => {
+    const total = executions.length;
+    const succeeded = executions.filter((e) => e.status === 'succeeded').length;
+    const failed = executions.filter((e) => e.status === 'failed').length;
+    const timeout = executions.filter((e) => e.status === 'timeout').length;
+    const canceled = executions.filter((e) => e.status === 'canceled').length;
+
+    // Group by skill
+    const bySkill: Record<string, any> = {};
+    executions.forEach((e) => {
+      const skillName = e.skill?.title || e.skill?.name || 'Unknown';
+      if (!bySkill[skillName]) {
+        bySkill[skillName] = {
+          name: skillName,
+          total: 0,
+          succeeded: 0,
+          failed: 0,
+          timeout: 0,
+          canceled: 0,
+          totalDuration: 0,
+          durationCount: 0,
+        };
+      }
+      bySkill[skillName].total += 1;
+      bySkill[skillName][e.status] = (bySkill[skillName][e.status] || 0) + 1;
+      if (e.durationMs) {
+        bySkill[skillName].totalDuration += e.durationMs;
+        bySkill[skillName].durationCount += 1;
+      }
+    });
+
+    const skillData = Object.values(bySkill)
+      .map((s) => ({
+        ...s,
+        successRate: s.total > 0 ? (s.succeeded / s.total) * 100 : 0,
+        avgDuration: s.durationCount > 0 ? (s.totalDuration / s.durationCount / 1000).toFixed(2) : 0,
+      }))
+      .sort((a: any, b: any) => b.total - a.total);
+
+    return { total, succeeded, failed, timeout, canceled, skillData };
+  }, [executions]);
+
+  const columns = [
+    { title: t('Skill'), dataIndex: 'name', key: 'name', width: 200 },
+    { title: t('Total Runs'), dataIndex: 'total', key: 'total', width: 100 },
+    {
+      title: t('Success Rate'),
+      dataIndex: 'successRate',
+      key: 'successRate',
+      width: 150,
+      render: (val: number) => (
+        <Progress
+          percent={Math.round(val)}
+          size="small"
+          status={val === 100 ? 'success' : val > 50 ? 'active' : 'exception'}
+        />
+      ),
+    },
+    { title: t('Success'), dataIndex: 'succeeded', key: 'succeeded', width: 100 },
+    { title: t('Failed'), dataIndex: 'failed', key: 'failed', width: 100 },
+    { title: t('Timeout'), dataIndex: 'timeout', key: 'timeout', width: 100 },
+    { title: t('Avg Duration (s)'), dataIndex: 'avgDuration', key: 'avgDuration', width: 120 },
+  ];
+
+  return (
+    <Space direction="vertical" size="large" style={{ width: '100%', padding: '0 16px' }}>
+      <Row gutter={16}>
+        <Col span={6}>
+          <Card size="small">
+            <Statistic title={t('Total Executions (Recent)')} value={metrics.total} prefix={<SyncOutlined />} />
+          </Card>
+        </Col>
+        <Col span={6}>
+          <Card size="small">
+            <Statistic
+              title={t('Succeeded')}
+              value={metrics.succeeded}
+              valueStyle={{ color: '#3f8600' }}
+              prefix={<CheckCircleOutlined />}
+            />
+          </Card>
+        </Col>
+        <Col span={6}>
+          <Card size="small">
+            <Statistic
+              title={t('Failed')}
+              value={metrics.failed}
+              valueStyle={{ color: '#cf1322' }}
+              prefix={<CloseCircleOutlined />}
+            />
+          </Card>
+        </Col>
+        <Col span={6}>
+          <Card size="small">
+            <Statistic
+              title={t('Timeout/Canceled')}
+              value={metrics.timeout + metrics.canceled}
+              valueStyle={{ color: '#faad14' }}
+              prefix={<ClockCircleOutlined />}
+            />
+          </Card>
+        </Col>
+      </Row>
+
+      <Card title={t('Metrics by Skill (Recent)')}>
+        <Table
+          dataSource={metrics.skillData}
+          columns={columns}
+          rowKey="name"
+          loading={loading}
+          pagination={false}
+          size="middle"
+          scroll={{ x: 'max-content' }}
+        />
+      </Card>
+    </Space>
+  );
+};

package/src/client-v2/skill-hub/components/SkillTestPanel.tsx

@@ -0,0 +1,135 @@
+import React, { useState } from 'react';
+import { Modal, Input, Button, Alert, Typography, Space, Spin } from 'antd';
+import { useApiClient as useAPIClient } from '../../hooks/useApiRequest';
+import { useT } from '../locale';
+import { parseJsonText } from '../utils/jsonFields';
+import { FileLinkList } from './FileLinkList';
+
+const { TextArea } = Input;
+
+interface SkillTestPanelProps {
+  skill: any;
+  onClose: () => void;
+}
+
+export const SkillTestPanel: React.FC<SkillTestPanelProps> = ({ skill, onClose }) => {
+  const api = useAPIClient();
+  const t = useT();
+  const inputSchema = parseJsonText(skill.inputSchema, null);
+  const [input, setInput] = useState(
+    inputSchema?.properties
+      ? JSON.stringify(Object.fromEntries(Object.keys(inputSchema.properties).map((k) => [k, ''])), null, 2)
+      : '{}',
+  );
+  const [running, setRunning] = useState(false);
+  const [result, setResult] = useState<any>(null);
+  const [error, setError] = useState('');
+
+  const handleRun = async () => {
+    setRunning(true);
+    setResult(null);
+    setError('');
+
+    let parsedInput;
+    try {
+      parsedInput = JSON.parse(input);
+    } catch {
+      setError(t('Invalid JSON input'));
+      setRunning(false);
+      return;
+    }
+
+    try {
+      const { data } = await api.request({
+        url: 'skillHub:test',
+        method: 'POST',
+        data: { skillId: skill.id, input: parsedInput },
+      });
+      const responseData = data?.data?.data || data?.data || data;
+      setResult(responseData);
+    } catch (err: any) {
+      setError(err?.response?.data?.errors?.[0]?.message || err.message || t('Execution failed'));
+    } finally {
+      setRunning(false);
+    }
+  };
+
+  return (
+    <Modal
+      open
+      title={`${t('Test Skill')}: ${skill.title}`}
+      onCancel={onClose}
+      footer={[
+        <Button key="close" onClick={onClose}>
+          {t('Close')}
+        </Button>,
+        <Button key="run" type="primary" onClick={handleRun} loading={running}>
+          {t('Run')}
+        </Button>,
+      ]}
+      width={640}
+      destroyOnClose
+    >
+      <Space direction="vertical" style={{ width: '100%' }} size="middle">
+        <div>
+          <Typography.Text strong>{t('Input (JSON)')}</Typography.Text>
+          <TextArea
+            rows={6}
+            value={input}
+            onChange={(e) => setInput(e.target.value)}
+            style={{ fontFamily: 'monospace', fontSize: 13, marginTop: 4 }}
+          />
+        </div>
+
+        {running && <Spin tip={t('Running skill on worker...')} />}
+
+        {error && <Alert type="error" message={error} showIcon />}
+
+        {result && (
+          <>
+            <Alert
+              type={result.status === 'succeeded' ? 'success' : 'error'}
+              message={result.status === 'succeeded' ? t('Succeeded') : t('Failed')}
+              description={`Duration: ${result.durationMs || 0}ms`}
+              showIcon
+            />
+
+            {result.stdout && (
+              <div>
+                <Typography.Text strong>stdout:</Typography.Text>
+                <pre style={{ background: '#f5f5f5', padding: 8, maxHeight: 200, overflow: 'auto', fontSize: 12 }}>
+                  {result.stdout}
+                </pre>
+              </div>
+            )}
+
+            {result.stderr && (
+              <div>
+                <Typography.Text strong type="danger">
+                  stderr:
+                </Typography.Text>
+                <pre style={{ background: '#fff2f0', padding: 8, maxHeight: 200, overflow: 'auto', fontSize: 12 }}>
+                  {result.stderr}
+                </pre>
+              </div>
+            )}
+
+            {result.files?.length > 0 && (
+              <div>
+                <Typography.Text strong>{t('Output Files')}:</Typography.Text>
+                <div style={{ marginTop: 8 }}>
+                  <FileLinkList
+                    files={result.files.map((f: any) => ({
+                      name: f.name,
+                      url: f.downloadUrl,
+                    }))}
+                  />
+                </div>
+              </div>
+            )}
+          </>
+        )}
+      </Space>
+    </Modal>
+  );
+};

package/src/client-v2/skill-hub/locale.ts

@@ -0,0 +1,13 @@
+import { useApp } from '@nocobase/client-v2';
+import { useCallback } from 'react';
+
+export const namespace = 'plugin-agent-orchestrator';
+
+export function useT() {
+  const app = useApp();
+  return useCallback(
+    (str: string, options?: any): string =>
+      app.i18n.t(str, { ns: [namespace, 'client'], ...options }) as unknown as string,
+    [app.i18n],
+  );
+}

package/src/client-v2/skill-hub/tools/loopTemplates.ts

@@ -0,0 +1,52 @@
+export type InteractionSchema = {
+  type: 'form' | 'select' | 'confirm';
+  prompt: string;
+  options?: { label: string; value: string | number }[];
+  fields?: Record<string, { type?: string; title?: string; required?: boolean; enum?: any[] }>;
+};
+
+export type LoopTemplate = {
+  key: string;
+  title: string;
+  description: string;
+  schema: InteractionSchema;
+};
+
+export const LOOP_TEMPLATES: LoopTemplate[] = [
+  {
+    key: 'confirm',
+    title: 'Confirm before run',
+    description: 'Ask the user to approve or cancel the skill call.',
+    schema: {
+      type: 'confirm',
+      prompt: 'Review this skill call before execution.',
+    },
+  },
+  {
+    key: 'review-input',
+    title: 'Review editable input',
+    description: 'Show selected input fields so the user can edit them before running.',
+    schema: {
+      type: 'form',
+      prompt: 'Review and edit the skill input before execution.',
+      fields: {},
+    },
+  },
+  {
+    key: 'choose-option',
+    title: 'Choose one option',
+    description: 'Ask the user to choose one option before running.',
+    schema: {
+      type: 'select',
+      prompt: 'Choose how to run this skill.',
+      options: [
+        { label: 'Default', value: 'default' },
+        { label: 'Careful', value: 'careful' },
+      ],
+    },
+  },
+];
+
+export function getLoopTemplate(key?: string) {
+  return LOOP_TEMPLATES.find((template) => template.key === key) || LOOP_TEMPLATES[0];
+}

package/src/client-v2/skill-hub/utils/jsonFields.ts

@@ -0,0 +1,41 @@
+export function parseJsonText<T = any>(value: any, fallback: T): T {
+  if (value === undefined || value === null || value === '') return fallback;
+  if (typeof value !== 'string') return value;
+
+  const trimmed = value.trim();
+  const fenced = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+  const json = fenced ? fenced[1].trim() : trimmed;
+
+  try {
+    let parsed = JSON.parse(json);
+    if (typeof parsed === 'string') {
+      const innerTrimmed = parsed.trim();
+      const innerFenced = innerTrimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+      const innerJson = innerFenced ? innerFenced[1].trim() : innerTrimmed;
+      try {
+        parsed = JSON.parse(innerJson);
+      } catch {
+        // keep the string form if the inner payload is not JSON
+      }
+    }
+    return parsed;
+  } catch {
+    return fallback;
+  }
+}
+
+export function formatJsonText(value: any, fallback: any = null): string {
+  const parsed = parseJsonText(value, undefined);
+  const normalized =
+    parsed === undefined ? (value === undefined || value === null || value === '' ? fallback : value) : parsed;
+  if (normalized === undefined || normalized === null) return '';
+  if (typeof normalized === 'string') return normalized;
+  return JSON.stringify(normalized, null, 2);
+}
+
+export function stringifyJsonText(value: any, fallback: any = null): string {
+  const parsed = parseJsonText(value, undefined);
+  const normalized =
+    parsed === undefined ? (value === undefined || value === null || value === '' ? fallback : value) : parsed;
+  return `\`\`\`json\n${JSON.stringify(normalized, null, 2)}\n\`\`\``;
+}

package/src/client-v2/utils/jsonFields.ts

@@ -0,0 +1,41 @@
+export function parseJsonText<T = any>(value: any, fallback: T): T {
+  if (value === undefined || value === null || value === '') return fallback;
+  if (typeof value !== 'string') return value;
+
+  const trimmed = value.trim();
+  const fenced = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+  const json = fenced ? fenced[1].trim() : trimmed;
+
+  try {
+    let parsed = JSON.parse(json);
+    if (typeof parsed === 'string') {
+      const innerTrimmed = parsed.trim();
+      const innerFenced = innerTrimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+      const innerJson = innerFenced ? innerFenced[1].trim() : innerTrimmed;
+      try {
+        parsed = JSON.parse(innerJson);
+      } catch {
+        // keep the string form if the inner payload is not JSON
+      }
+    }
+    return parsed;
+  } catch {
+    return fallback;
+  }
+}
+
+export function formatJsonText(value: any, fallback: any = null): string {
+  const parsed = parseJsonText(value, undefined);
+  const normalized =
+    parsed === undefined ? (value === undefined || value === null || value === '' ? fallback : value) : parsed;
+  if (normalized === undefined || normalized === null) return '';
+  if (typeof normalized === 'string') return normalized;
+  return JSON.stringify(normalized, null, 2);
+}
+
+export function stringifyJsonText(value: any, fallback: any = null): string {
+  const parsed = parseJsonText(value, undefined);
+  const normalized =
+    parsed === undefined ? (value === undefined || value === null || value === '' ? fallback : value) : parsed;
+  return `\`\`\`json\n${JSON.stringify(normalized, null, 2)}\n\`\`\``;
+}

package/src/locale/en-US.json

@@ -1,6 +1,13 @@
 {
   "Agent Orchestrator": "Agent Orchestrator",
   "Orchestration Rules": "Orchestration Rules",
+  "Execution Tracing": "Execution Tracing",
+  "Agent Runs": "Agent Runs",
+  "Harness Profiles": "Harness Profiles",
+  "Skill Hub Definitions": "Skill Hub Definitions",
+  "Execution History": "Execution History",
+  "Skill Review Settings": "Skill Review Settings",
+  "Metrics": "Metrics",
   "Swarm Tracing": "Swarm Tracing",
   "Leader (Orchestrator)": "Leader (Orchestrator)",
   "Sub-Agent": "Sub-Agent",

package/src/locale/vi-VN.json

@@ -1,6 +1,13 @@
 {
   "Agent Orchestrator": "Điều phối Agent",
   "Orchestration Rules": "Quy tắc điều phối",
+  "Execution Tracing": "Truy vết thực thi",
+  "Agent Runs": "Lượt chạy Agent",
+  "Harness Profiles": "Hồ sơ Harness",
+  "Skill Hub Definitions": "Định nghĩa Skill Hub",
+  "Execution History": "Lịch sử thực thi",
+  "Skill Review Settings": "Cài đặt duyệt Skill",
+  "Metrics": "Số liệu",
   "Swarm Tracing": "Truy vết Swarm",
   "Leader (Orchestrator)": "Leader (Điều phối viên)",
   "Sub-Agent": "Agent con",

package/src/locale/zh-CN.json

@@ -0,0 +1,27 @@
+{
+  "Agent Orchestrator": "智能体编排",
+  "Orchestration Rules": "编排规则",
+  "Execution Tracing": "执行追踪",
+  "Agent Runs": "智能体运行",
+  "Harness Profiles": "Harness 配置",
+  "Skill Hub Definitions": "技能中心定义",
+  "Execution History": "执行历史",
+  "Skill Review Settings": "技能审核设置",
+  "Metrics": "指标",
+  "Swarm Tracing": "集群追踪",
+  "Leader (Orchestrator)": "主控（编排者）",
+  "Sub-Agent": "子智能体",
+  "Max Delegation Depth": "最大委派深度",
+  "Timeout (ms)": "超时时间（毫秒）",
+  "Enabled": "已启用",
+  "New Rule": "新建规则",
+  "Edit Orchestration Rule": "编辑编排规则",
+  "New Orchestration Rule": "新建编排规则",
+  "Rule created": "规则已创建",
+  "Rule updated": "规则已更新",
+  "Rule deleted": "规则已删除",
+  "Sub-Agent Conversation": "子智能体对话",
+  "Task Summary": "任务摘要",
+  "Parent Session": "父会话",
+  "No sub-agent executions yet": "暂无子智能体执行记录"
+}

package/src/server/__tests__/agent-registry-service.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, it, vi } from 'vitest';
+import { AgentRegistryService } from '../services/AgentRegistryService';
+
+function createService(configs: Array<{ leaderUsername: string; subAgentUsername: string }>) {
+  const find = vi.fn(async () => configs);
+  const service = new AgentRegistryService({
+    db: {
+      getRepository: vi.fn(() => ({ find })),
+    },
+  });
+  return { service, find };
+}
+
+function createServiceWithEmployees(employees: Record<string, any>) {
+  const findOne = vi.fn(async ({ filter }: { filter: { username: string } }) => employees[filter.username] ?? null);
+  const service = new AgentRegistryService({
+    db: {
+      getRepository: vi.fn(() => ({ findOne })),
+    },
+  });
+  return { service, findOne };
+}
+
+describe('AgentRegistryService', () => {
+  describe('isRegisteredDelegationTool', () => {
+    it('matches sanitized delegate tool names without parsing username delimiters', async () => {
+      const { service } = createService([
+        {
+          leaderUsername: 'lead.to_team',
+          subAgentUsername: 'qa_to_review',
+        },
+      ]);
+
+      await expect(service.isRegisteredDelegationTool('delegate_lead_to_team_to_qa_to_review')).resolves.toBe(true);
+    });
+
+    it('matches dispatch tools by generated sanitized name', async () => {
+      const { service } = createService([
+        {
+          leaderUsername: 'lead.to team',
+          subAgentUsername: 'researcher',
+        },
+      ]);
+
+      await expect(service.isRegisteredDelegationTool('dispatch_subagents_lead_to_team')).resolves.toBe(true);
+    });
+
+    it('keeps legacy alias valid only when one enabled config matches the sub-agent', async () => {
+      const single = createService([
+        {
+          leaderUsername: 'lead-a',
+          subAgentUsername: 'qa.to review',
+        },
+      ]);
+      await expect(single.service.isRegisteredDelegationTool('delegate_to_qa_to_review')).resolves.toBe(true);
+
+      const ambiguous = createService([
+        {
+          leaderUsername: 'lead-a',
+          subAgentUsername: 'qa.to review',
+        },
+        {
+          leaderUsername: 'lead-b',
+          subAgentUsername: 'qa.to review',
+        },
+      ]);
+      await expect(ambiguous.service.isRegisteredDelegationTool('delegate_to_qa_to_review')).resolves.toBe(false);
+    });
+  });
+
+  describe('resolveModelSettings', () => {
+    it('reads the dedicated models[] array shape saved by the admin UI', async () => {
+      const { service } = createServiceWithEmployees({
+        sub: {
+          username: 'sub',
+          modelSettings: {
+            enabled: true,
+            llmService: undefined,
+            model: undefined,
+            models: [{ llmService: 'openai', model: 'gpt-4o' }],
+          },
+        },
+      });
+
+      await expect(service.resolveModelSettings('sub')).resolves.toEqual({
+        llmService: 'openai',
+        model: 'gpt-4o',
+      });
+    });
+
+    it('falls back to the flat legacy { llmService, model } shape', async () => {
+      const { service } = createServiceWithEmployees({
+        sub: {
+          username: 'sub',
+          modelSettings: { llmService: 'anthropic', model: 'claude-3-5' },
+        },
+      });
+
+      await expect(service.resolveModelSettings('sub')).resolves.toEqual({
+        llmService: 'anthropic',
+        model: 'claude-3-5',
+      });
+    });
+
+    it('inherits the leader model when the sub-agent has none configured', async () => {
+      const { service } = createServiceWithEmployees({
+        sub: { username: 'sub', modelSettings: { enabled: false, models: [] } },
+        lead: {
+          username: 'lead',
+          modelSettings: {
+            enabled: true,
+            models: [{ llmService: 'openai', model: 'gpt-4o-mini' }],
+          },
+        },
+      });
+
+      await expect(service.resolveModelSettings('sub', 'lead')).resolves.toEqual({
+        llmService: 'openai',
+        model: 'gpt-4o-mini',
+      });
+    });
+
+    it('prefers an explicit per-rule override over employee settings', async () => {
+      const { service } = createServiceWithEmployees({
+        sub: {
+          username: 'sub',
+          modelSettings: { enabled: true, models: [{ llmService: 'openai', model: 'gpt-4o' }] },
+        },
+      });
+
+      await expect(
+        service.resolveModelSettings('sub', undefined, { llmService: 'anthropic', model: 'claude-3-5' }),
+      ).resolves.toEqual({ llmService: 'anthropic', model: 'claude-3-5' });
+    });
+
+    it('ignores dedicated models when not enabled and returns undefined with no fallback', async () => {
+      const { service } = createServiceWithEmployees({
+        sub: {
+          username: 'sub',
+          modelSettings: { enabled: false, models: [{ llmService: 'openai', model: 'gpt-4o' }] },
+        },
+      });
+
+      await expect(service.resolveModelSettings('sub')).resolves.toBeUndefined();
+    });
+  });
+});