plugin-agent-orchestrator 1.0.13 → 1.0.14

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

@@ -0,0 +1,124 @@
+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 } from '@nocobase/client';
+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="Total Executions (Recent)" value={metrics.total} prefix={<SyncOutlined />} />
+          </Card>
+        </Col>
+        <Col span={6}>
+          <Card size="small">
+            <Statistic title="Succeeded" value={metrics.succeeded} valueStyle={{ color: '#3f8600' }} prefix={<CheckCircleOutlined />} />
+          </Card>
+        </Col>
+        <Col span={6}>
+          <Card size="small">
+            <Statistic title="Failed" value={metrics.failed} valueStyle={{ color: '#cf1322' }} prefix={<CloseCircleOutlined />} />
+          </Card>
+        </Col>
+        <Col span={6}>
+          <Card size="small">
+            <Statistic title="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" 
+        />
+      </Card>
+    </Space>
+  );
+};

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

@@ -0,0 +1,144 @@
+import React, { useState } from 'react';
+import { Modal, Input, Button, Alert, Typography, Space, Spin } from 'antd';
+import { useAPIClient, Upload } from '@nocobase/client';
+import { useT } from '../locale';
+import { parseJsonText } from '../utils/jsonFields';
+
+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 }}>
+                  <Upload.ReadPretty 
+                    value={result.files.map((f: any, i: number) => ({
+                      id: `test-${f.name}-${i}`,
+                      title: f.name,
+                      filename: f.name,
+                      extname: f.name.includes('.') ? `.${f.name.split('.').pop()}` : '',
+                      url: f.downloadUrl,
+                      status: 'done'
+                    }))} 
+                    multiple={true} 
+                    showFileName={true} 
+                  />
+                </div>
+              </div>
+            )}
+          </>
+        )}
+      </Space>
+    </Modal>
+  );
+};

package/src/client/skill-hub/index.tsx

@@ -0,0 +1,75 @@
+import { Plugin } from '@nocobase/client';
+import { SkillManager } from './components/SkillManager';
+import { ExecutionHistory } from './components/ExecutionHistory';
+
+import { SkillMetrics } from './components/SkillMetrics';
+import { InteractionSchemasProvider } from './tools/InteractionSchemasProvider';
+import { SkillHubCard } from './tools/SkillHubCard';
+import { parseJsonText } from './utils/jsonFields';
+
+const sanitize = (name: string) =>
+  name
+    .toLowerCase()
+    .replace(/[^a-z0-9_]/g, '_')
+    .replace(/_+/g, '_')
+    .replace(/^_|_$/g, '');
+
+export class PluginSkillHubClient extends Plugin {
+  async load() {
+    this.app.use(InteractionSchemasProvider);
+
+    this.app.pluginSettingsManager.add('skill-hub', {
+      title: this.t('Skill Hub'),
+      icon: 'CodeOutlined',
+    });
+
+    this.app.pluginSettingsManager.add('skill-hub.definitions', {
+      title: this.t('Skill Definitions'),
+      Component: SkillManager,
+      aclSnippet: 'pm.skill-hub',
+    });
+
+    this.app.pluginSettingsManager.add('skill-hub.executions', {
+      title: this.t('Execution History'),
+      Component: ExecutionHistory,
+      aclSnippet: 'pm.skill-hub',
+    });
+
+    this.app.pluginSettingsManager.add('skill-hub.metrics', {
+      title: this.t('Dashboard Metrics'),
+      Component: SkillMetrics,
+      aclSnippet: 'pm.skill-hub',
+    });
+
+
+
+    await this.registerSkillUiCards();
+  }
+
+  private async registerSkillUiCards() {
+    const toolsManager = this.app.aiManager?.toolsManager;
+    if (!toolsManager) return;
+
+    try {
+      const { data } = await this.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 { SkillManager, ExecutionHistory, SkillMetrics };
+export default PluginSkillHubClient;

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

@@ -0,0 +1,16 @@
+import { useApp } from '@nocobase/client';
+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]
+  );
+}
+
+export function tStr(key: string) {
+  return `{{t(${JSON.stringify(key)}, { ns: ['${namespace}', 'client'], nsMode: 'fallback' })}}`;
+}

package/src/client/skill-hub/tools/InteractionSchemasProvider.tsx

@@ -0,0 +1,59 @@
+import React, { createContext, useContext, useEffect, useState } from 'react';
+import { useAPIClient } from '@nocobase/client';
+import { parseJsonText } from '../utils/jsonFields';
+
+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[] }>;
+};
+
+const Ctx = createContext<Map<string, InteractionSchema>>(new Map());
+
+export const useInteractionSchemas = () => useContext(Ctx);
+
+const sanitize = (name: string) =>
+  name
+    .toLowerCase()
+    .replace(/[^a-z0-9_]/g, '_')
+    .replace(/_+/g, '_')
+    .replace(/^_|_$/g, '');
+
+export const InteractionSchemasProvider: React.FC<{ children?: React.ReactNode }> = ({ children }) => {
+  const api = useAPIClient();
+  const [map, setMap] = useState<Map<string, InteractionSchema>>(new Map());
+
+  useEffect(() => {
+    let cancelled = false;
+    api
+      .request({
+        url: 'skillDefinitions:list',
+        params: {
+          filter: { enabled: true },
+          fields: ['name', 'autoCall', 'interactionSchema'],
+          pageSize: 200,
+        },
+      })
+      .then(({ data }) => {
+        if (cancelled) return;
+        const next = new Map<string, InteractionSchema>();
+        const list = data?.data ?? [];
+        for (const s of list) {
+          if (s.autoCall) continue;
+          const schema = parseJsonText<InteractionSchema | null>(s.interactionSchema, null);
+          if (!schema) continue;
+          next.set(sanitize(s.name), schema);
+        }
+        setMap(next);
+      })
+      .catch(() => {
+        // silently ignore — user may lack permission to list definitions
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [api]);
+
+  return <Ctx.Provider value={map}>{children}</Ctx.Provider>;
+};

package/src/client/skill-hub/tools/SkillHubCard.tsx

@@ -0,0 +1,78 @@
+import React from 'react';
+import { Form, Input, Select, Radio, InputNumber, Button, Space, Card, Typography } from 'antd';
+import { ToolsUIProperties } from '@nocobase/client';
+import { useInteractionSchemas } from './InteractionSchemasProvider';
+
+export const SkillHubCard: React.FC<ToolsUIProperties> = ({ toolCall, decisions }) => {
+  const schemas = useInteractionSchemas();
+  const [form] = Form.useForm();
+
+  const skillKey = toolCall.name.replace(/^skill_hub_/, '');
+  const schema = schemas.get(skillKey);
+
+  const interrupted = toolCall.invokeStatus === 'init' || toolCall.invokeStatus === 'interrupted';
+  if (!schema || !interrupted) {
+    return null;
+  }
+
+  const onSubmit = async () => {
+    const values = await form.validateFields();
+    const args = schema.type === 'select' ? values : { ...(toolCall.args as any), ...values };
+    await decisions.edit(args);
+  };
+
+  const renderField = (key: string, f: any) => {
+    if (f?.enum) {
+      return <Select options={f.enum.map((v: any) => ({ value: v, label: String(v) }))} />;
+    }
+    if (f?.type === 'number' || f?.type === 'integer') {
+      return <InputNumber style={{ width: '100%' }} />;
+    }
+    return <Input />;
+  };
+
+  return (
+    <Card size="small" style={{ marginTop: 8 }}>
+      <Typography.Paragraph style={{ marginBottom: 12 }}>{schema.prompt}</Typography.Paragraph>
+
+      {schema.type !== 'confirm' && (
+        <Form
+          form={form}
+          layout="vertical"
+          initialValues={(toolCall.args as Record<string, any>) || {}}
+          style={{ marginBottom: 8 }}
+        >
+          {schema.type === 'select' && (
+            <Form.Item name="choice" rules={[{ required: true }]}>
+              <Radio.Group>
+                {(schema.options ?? []).map((o) => (
+                  <Radio key={String(o.value)} value={o.value}>
+                    {o.label}
+                  </Radio>
+                ))}
+              </Radio.Group>
+            </Form.Item>
+          )}
+          {schema.type === 'form' &&
+            Object.entries(schema.fields ?? {}).map(([key, f]) => (
+              <Form.Item
+                key={key}
+                name={key}
+                label={f.title || key}
+                rules={[{ required: !!f.required }]}
+              >
+                {renderField(key, f)}
+              </Form.Item>
+            ))}
+        </Form>
+      )}
+
+      <Space>
+        <Button type="primary" onClick={schema.type === 'confirm' ? () => decisions.approve() : onSubmit}>
+          Run
+        </Button>
+        <Button onClick={() => decisions.reject('user_cancel')}>Cancel</Button>
+      </Space>
+    </Card>
+  );
+};

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

@@ -0,0 +1,37 @@
+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 {}
+    }
+    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/server/collections/agent-execution-spans.ts

@@ -0,0 +1,129 @@
+import { defineCollection } from '@nocobase/database';
+
+/**
+ * Unified execution graph for agent orchestration.
+ *
+ * A root run can contain sub-agent spans and child tool/skill spans. Skill Hub
+ * keeps its own sandbox execution records; this collection stores the flow
+ * relationship and links to those records when applicable.
+ */
+export default defineCollection({
+  name: 'agentExecutionSpans',
+  title: 'Agent Execution Spans',
+  fields: [
+    {
+      name: 'id',
+      type: 'bigInt',
+      autoIncrement: true,
+      primaryKey: true,
+    },
+    {
+      name: 'rootRunId',
+      type: 'string',
+      length: 100,
+      allowNull: false,
+    },
+    {
+      name: 'parentSpanId',
+      type: 'string',
+      length: 100,
+    },
+    {
+      name: 'type',
+      type: 'string',
+      length: 30,
+      comment: 'sub_agent, tool, skill, dispatch',
+    },
+    {
+      name: 'status',
+      type: 'string',
+      length: 20,
+      comment: 'running, success, error, canceled, timeout',
+    },
+    {
+      name: 'leaderUsername',
+      type: 'string',
+      length: 100,
+    },
+    {
+      name: 'employeeUsername',
+      type: 'string',
+      length: 100,
+      comment: 'The AI Employee currently executing this span',
+    },
+    {
+      name: 'toolName',
+      type: 'string',
+      length: 200,
+    },
+    {
+      name: 'title',
+      type: 'string',
+      length: 500,
+    },
+    {
+      name: 'input',
+      type: 'json',
+      defaultValue: {},
+    },
+    {
+      name: 'output',
+      type: 'text',
+    },
+    {
+      name: 'error',
+      type: 'text',
+    },
+    {
+      name: 'durationMs',
+      type: 'integer',
+    },
+    {
+      name: 'startedAt',
+      type: 'date',
+    },
+    {
+      name: 'endedAt',
+      type: 'date',
+    },
+    {
+      name: 'orchestratorLogId',
+      type: 'bigInt',
+    },
+    {
+      name: 'skillExecutionId',
+      type: 'bigInt',
+    },
+    {
+      name: 'metadata',
+      type: 'json',
+      defaultValue: {},
+    },
+    {
+      name: 'userId',
+      type: 'bigInt',
+    },
+    {
+      name: 'createdAt',
+      type: 'date',
+    },
+    {
+      name: 'updatedAt',
+      type: 'date',
+    },
+  ],
+  indexes: [
+    {
+      fields: ['rootRunId'],
+    },
+    {
+      fields: ['parentSpanId'],
+    },
+    {
+      fields: ['type'],
+    },
+    {
+      fields: ['status'],
+    },
+  ],
+});

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

@@ -39,6 +39,13 @@ export default defineCollection({
       defaultValue: 120000,
       comment: 'Timeout in ms for sub-agent execution',
     },
+    {
+      name: 'recursionLimit',
+      type: 'integer',
+      defaultValue: 50,
+      comment:
+        'Max LangGraph reasoning steps (tool-call + LLM-step iterations) per delegation. Lower = safer; higher = more complex multi-step tasks. Default 50.',
+    },
     {
       name: 'llmService',
       type: 'string',