plugin-agent-orchestrator 1.0.17 → 1.0.19

package/src/client/skill-hub/tools/registerSkillLoopCards.ts

@@ -0,0 +1,58 @@
+import { SkillHubCard } from './SkillHubCard';
+import { parseJsonText } from '../utils/jsonFields';
+
+const sanitize = (name: string) =>
+  name
+    .toLowerCase()
+    .replace(/[^a-z0-9_]/g, '_')
+    .replace(/_+/g, '_')
+    .replace(/^_|_$/g, '');
+
+const extractList = (data: any) => {
+  const value = data?.data?.data ?? data?.data ?? data ?? [];
+  return Array.isArray(value) ? value : [];
+};
+
+export async function registerSkillLoopCards(app: any) {
+  const toolsManager = app.aiManager?.toolsManager;
+  if (!toolsManager) return;
+
+  try {
+    const skillsResponse = await app.apiClient.request({
+      url: 'skillDefinitions:list',
+      params: {
+        filter: { enabled: true },
+        fields: ['id', 'name', 'autoCall', 'interactionSchema'],
+        pageSize: 500,
+      },
+    });
+
+    let loopSkillIds = new Set<string>();
+    try {
+      const loopConfigsResponse = await app.apiClient.request({
+        url: 'skillLoopConfigs:list',
+        params: {
+          filter: { enabled: true },
+          fields: ['skillId'],
+          pageSize: 500,
+        },
+      });
+      loopSkillIds = new Set(extractList(loopConfigsResponse.data).map((config: any) => String(config.skillId)));
+      if (loopSkillIds.size > 0) {
+        toolsManager.registerTools('skill_hub_execute', { ui: { card: SkillHubCard } });
+      }
+    } catch {
+      // Older deployments may not have the collection before migration/sync.
+    }
+
+    const skills = extractList(skillsResponse.data);
+    for (const skill of skills) {
+      const hasLoopConfig = loopSkillIds.has(String(skill.id));
+      const hasLegacySchema = !skill.autoCall && !!parseJsonText(skill.interactionSchema, null);
+      if (!hasLoopConfig && !hasLegacySchema) continue;
+      toolsManager.registerTools(`skill_hub_${sanitize(skill.name)}`, { ui: { card: SkillHubCard } });
+    }
+  } catch {
+    // user without ACL or backend unavailable - skip silently
+  }
+}

package/src/client/tools/PlanApprovalCard.tsx

@@ -0,0 +1,175 @@
+import React from 'react';
+import { Alert, Button, Card, Input, List, Space, Tag, Typography, message } from 'antd';
+import { ToolsUIProperties, useAPIClient } from '@nocobase/client';
+
+const { Paragraph, Text } = Typography;
+
+const extractData = (response: any) => response?.data?.data ?? response?.data ?? response;
+
+const summarizeArgsPlan = (plan: any[]) =>
+  (Array.isArray(plan) ? plan : []).map((step, index) => ({
+    id: step.id || step.planKey || index,
+    planKey: step.planKey || step.key || step.id || `step_${index + 1}`,
+    title: step.title || `Step ${index + 1}`,
+    description: step.description || '',
+    type: step.type || 'tool',
+    target: step.target || '',
+    dependsOn: step.dependsOn || [],
+  }));
+
+export const PlanApprovalCard: React.FC<ToolsUIProperties> = ({ toolCall, decisions }) => {
+  const api = useAPIClient();
+  const rawArgs = (toolCall.args as Record<string, any>) || {};
+  const runId = rawArgs.runId;
+  const [detail, setDetail] = React.useState<any>(null);
+  const [loading, setLoading] = React.useState(false);
+  const [submitting, setSubmitting] = React.useState(false);
+  const [feedback, setFeedback] = React.useState('');
+
+  const interrupted = toolCall.invokeStatus === 'init' || toolCall.invokeStatus === 'interrupted';
+
+  React.useEffect(() => {
+    if (!interrupted || !runId) return;
+    let mounted = true;
+    setLoading(true);
+    api
+      .request({
+        url: 'agentLoops:get',
+        params: { filterByTk: runId },
+      })
+      .then((response) => {
+        if (mounted) setDetail(extractData(response));
+      })
+      .catch(() => {
+        if (mounted) setDetail(null);
+      })
+      .finally(() => {
+        if (mounted) setLoading(false);
+      });
+    return () => {
+      mounted = false;
+    };
+  }, [api, interrupted, runId]);
+
+  if (!interrupted) {
+    return null;
+  }
+
+  const run = detail?.run || {};
+  const steps = summarizeArgsPlan(detail?.steps || rawArgs.plan || []);
+  const goal = run.goal || rawArgs.goal || '';
+
+  const rejectPlan = async () => {
+    if (!runId) {
+      await decisions.reject('missing_run_id');
+      return;
+    }
+    setSubmitting(true);
+    try {
+      await api.request({
+        url: 'agentLoops:rejectPlan',
+        method: 'post',
+        data: { runId, reason: feedback || 'Plan rejected by user.' },
+      });
+      await decisions.reject(JSON.stringify({ reason: 'plan_rejected', runId, feedback }));
+    } catch (error: any) {
+      message.error(error?.message || 'Failed to reject plan');
+    } finally {
+      setSubmitting(false);
+    }
+  };
+
+  const requestChanges = async () => {
+    if (!feedback.trim()) {
+      message.warning('Add feedback before requesting changes.');
+      return;
+    }
+    setSubmitting(true);
+    try {
+      await api.request({
+        url: 'agentLoops:requestPlanChanges',
+        method: 'post',
+        data: { runId, feedback },
+      });
+      await decisions.reject(JSON.stringify({ reason: 'changes_requested', runId, feedback }));
+    } catch (error: any) {
+      message.error(error?.message || 'Failed to request plan changes');
+    } finally {
+      setSubmitting(false);
+    }
+  };
+
+  return (
+    <Card size="small" style={{ marginTop: 8 }}>
+      <Space direction="vertical" size={12} style={{ width: '100%' }}>
+        <Alert
+          type="info"
+          showIcon
+          message="Review orchestrator plan"
+          description="Execution starts only after you approve this plan."
+        />
+
+        <Space size={8} wrap>
+          {runId && <Tag color="blue">Run #{runId}</Tag>}
+          <Tag color="purple">Plan v{run.planVersion || rawArgs.planVersion || 1}</Tag>
+          <Tag color={run.approvalStatus === 'pending' ? 'gold' : 'default'}>
+            {run.approvalStatus || 'pending'}
+          </Tag>
+          {run.metadata?.harnessTag && <Tag>{run.metadata.harnessTag}</Tag>}
+        </Space>
+
+        {goal && (
+          <Paragraph style={{ marginBottom: 0 }}>
+            <Text strong>Goal: </Text>
+            {goal}
+          </Paragraph>
+        )}
+
+        <List
+          size="small"
+          loading={loading}
+          dataSource={steps}
+          locale={{ emptyText: 'No plan steps found.' }}
+          renderItem={(step: any, index) => (
+            <List.Item>
+              <Space direction="vertical" size={2} style={{ width: '100%' }}>
+                <Space size={8} wrap>
+                  <Text strong>
+                    {index + 1}. {step.title}
+                  </Text>
+                  <Tag>{step.type}</Tag>
+                  {step.target && <Tag color="green">{step.target}</Tag>}
+                </Space>
+                {step.description && <Text type="secondary">{step.description}</Text>}
+                {step.dependsOn?.length > 0 && (
+                  <Text type="secondary" style={{ fontSize: 12 }}>
+                    Depends on: {step.dependsOn.join(', ')}
+                  </Text>
+                )}
+              </Space>
+            </List.Item>
+          )}
+        />
+
+        <Input.TextArea
+          rows={3}
+          value={feedback}
+          onChange={(event) => setFeedback(event.target.value)}
+          placeholder="Optional rejection reason or requested changes"
+        />
+
+        <Space wrap>
+          <Button type="primary" loading={submitting} onClick={() => decisions.approve()}>
+            Accept & Run
+          </Button>
+          <Button loading={submitting} onClick={requestChanges}>
+            Request changes
+          </Button>
+          <Button danger loading={submitting} onClick={rejectPlan}>
+            Reject
+          </Button>
+        </Space>
+      </Space>
+    </Card>
+  );
+};

package/src/client/tools/registerOrchestratorCards.ts

@@ -0,0 +1,7 @@
+import { PlanApprovalCard } from './PlanApprovalCard';
+
+export async function registerOrchestratorCards(app: any) {
+  const toolsManager = app.aiManager?.toolsManager;
+  if (!toolsManager) return;
+  toolsManager.registerTools('orchestrator_execute_plan', { ui: { card: PlanApprovalCard } });
+}

package/src/server/collections/agent-harness-profiles.ts

@@ -0,0 +1,59 @@
+import { defineCollection } from '@nocobase/database';
+
+export default defineCollection({
+  name: 'agentHarnessProfiles',
+  title: 'Agent Harness Profiles',
+  fields: [
+    {
+      name: 'id',
+      type: 'bigInt',
+      autoIncrement: true,
+      primaryKey: true,
+    },
+    {
+      name: 'tag',
+      type: 'string',
+      length: 100,
+      allowNull: false,
+      unique: true,
+      comment: 'Stable harness profile tag used by orchestration rules and agent loop runs.',
+    },
+    {
+      name: 'title',
+      type: 'string',
+      length: 200,
+    },
+    {
+      name: 'description',
+      type: 'text',
+    },
+    {
+      name: 'enabled',
+      type: 'boolean',
+      defaultValue: true,
+    },
+    {
+      name: 'settings',
+      type: 'json',
+      defaultValue: {},
+      comment: 'Harness limits and behavior settings such as max parallel sub-agents, approval mode, and tool policy.',
+    },
+    {
+      name: 'createdAt',
+      type: 'date',
+    },
+    {
+      name: 'updatedAt',
+      type: 'date',
+    },
+  ],
+  indexes: [
+    {
+      unique: true,
+      fields: ['tag'],
+    },
+    {
+      fields: ['enabled'],
+    },
+  ],
+});

package/src/server/collections/agent-loop-events.ts

@@ -0,0 +1,71 @@
+import { defineCollection } from '@nocobase/database';
+
+export default defineCollection({
+  name: 'agentLoopEvents',
+  title: 'Agent Loop Events',
+  fields: [
+    {
+      name: 'id',
+      type: 'bigInt',
+      autoIncrement: true,
+      primaryKey: true,
+    },
+    {
+      name: 'run',
+      type: 'belongsTo',
+      target: 'agentLoopRuns',
+      foreignKey: 'runId',
+    },
+    {
+      name: 'step',
+      type: 'belongsTo',
+      target: 'agentLoopSteps',
+      foreignKey: 'stepId',
+    },
+    {
+      name: 'type',
+      type: 'string',
+      length: 80,
+    },
+    {
+      name: 'title',
+      type: 'string',
+      length: 500,
+    },
+    {
+      name: 'content',
+      type: 'text',
+    },
+    {
+      name: 'status',
+      type: 'string',
+      length: 30,
+    },
+    {
+      name: 'payload',
+      type: 'json',
+      defaultValue: {},
+    },
+    {
+      name: 'user',
+      type: 'belongsTo',
+      target: 'users',
+      foreignKey: 'userId',
+    },
+    {
+      name: 'createdAt',
+      type: 'date',
+    },
+  ],
+  indexes: [
+    {
+      fields: ['runId'],
+    },
+    {
+      fields: ['stepId'],
+    },
+    {
+      fields: ['type'],
+    },
+  ],
+});

package/src/server/collections/agent-loop-runs.ts

@@ -0,0 +1,158 @@
+import { defineCollection } from '@nocobase/database';
+
+export default defineCollection({
+  name: 'agentLoopRuns',
+  title: 'Agent Loop Runs',
+  fields: [
+    {
+      name: 'id',
+      type: 'bigInt',
+      autoIncrement: true,
+      primaryKey: true,
+    },
+    {
+      name: 'rootRunId',
+      type: 'string',
+      length: 100,
+      allowNull: false,
+    },
+    {
+      name: 'sessionId',
+      type: 'string',
+      length: 100,
+    },
+    {
+      name: 'messageId',
+      type: 'string',
+      length: 100,
+    },
+    {
+      name: 'leaderUsername',
+      type: 'string',
+      length: 100,
+    },
+    {
+      name: 'goal',
+      type: 'text',
+    },
+    {
+      name: 'status',
+      type: 'string',
+      length: 30,
+      defaultValue: 'planning',
+      comment: 'planning, waiting_plan_approval, approved, running, waiting_user, needs_replan, succeeded, failed, rejected, canceled',
+    },
+    {
+      name: 'currentStepId',
+      type: 'bigInt',
+    },
+    {
+      name: 'policy',
+      type: 'json',
+      defaultValue: {},
+    },
+    {
+      name: 'iterationCount',
+      type: 'integer',
+      defaultValue: 0,
+    },
+    {
+      name: 'approvalStatus',
+      type: 'string',
+      length: 30,
+      defaultValue: 'none',
+      comment: 'none, pending, approved, rejected, changes_requested',
+    },
+    {
+      name: 'approvedBy',
+      type: 'belongsTo',
+      target: 'users',
+      foreignKey: 'approvedById',
+    },
+    {
+      name: 'approvedAt',
+      type: 'date',
+    },
+    {
+      name: 'rejectionReason',
+      type: 'text',
+    },
+    {
+      name: 'changeRequest',
+      type: 'text',
+    },
+    {
+      name: 'planVersion',
+      type: 'integer',
+      defaultValue: 1,
+    },
+    {
+      name: 'planSource',
+      type: 'string',
+      length: 50,
+    },
+    {
+      name: 'plannerModel',
+      type: 'string',
+      length: 100,
+    },
+    {
+      name: 'lockedBy',
+      type: 'string',
+      length: 100,
+    },
+    {
+      name: 'lockedUntil',
+      type: 'date',
+    },
+    {
+      name: 'finalAnswer',
+      type: 'text',
+    },
+    {
+      name: 'summary',
+      type: 'text',
+    },
+    {
+      name: 'metadata',
+      type: 'json',
+      defaultValue: {},
+    },
+    {
+      name: 'user',
+      type: 'belongsTo',
+      target: 'users',
+      foreignKey: 'userId',
+    },
+    {
+      name: 'startedAt',
+      type: 'date',
+    },
+    {
+      name: 'endedAt',
+      type: 'date',
+    },
+    {
+      name: 'createdAt',
+      type: 'date',
+    },
+    {
+      name: 'updatedAt',
+      type: 'date',
+    },
+  ],
+  indexes: [
+    {
+      fields: ['rootRunId'],
+    },
+    {
+      fields: ['status'],
+    },
+    {
+      fields: ['leaderUsername'],
+    },
+    {
+      fields: ['sessionId'],
+    },
+  ],
+});

package/src/server/collections/agent-loop-steps.ts

@@ -0,0 +1,144 @@
+import { defineCollection } from '@nocobase/database';
+
+export default defineCollection({
+  name: 'agentLoopSteps',
+  title: 'Agent Loop Steps',
+  fields: [
+    {
+      name: 'id',
+      type: 'bigInt',
+      autoIncrement: true,
+      primaryKey: true,
+    },
+    {
+      name: 'run',
+      type: 'belongsTo',
+      target: 'agentLoopRuns',
+      foreignKey: 'runId',
+    },
+    {
+      name: 'parentStep',
+      type: 'belongsTo',
+      target: 'agentLoopSteps',
+      foreignKey: 'parentStepId',
+    },
+    {
+      name: 'planKey',
+      type: 'string',
+      length: 100,
+    },
+    {
+      name: 'index',
+      type: 'integer',
+      defaultValue: 0,
+    },
+    {
+      name: 'title',
+      type: 'string',
+      length: 500,
+    },
+    {
+      name: 'description',
+      type: 'text',
+    },
+    {
+      name: 'type',
+      type: 'string',
+      length: 30,
+      comment: 'reasoning, skill, tool, sub_agent, verification',
+    },
+    {
+      name: 'target',
+      type: 'string',
+      length: 200,
+    },
+    {
+      name: 'input',
+      type: 'json',
+      defaultValue: {},
+    },
+    {
+      name: 'output',
+      type: 'json',
+      defaultValue: {},
+    },
+    {
+      name: 'status',
+      type: 'string',
+      length: 30,
+      defaultValue: 'pending',
+      comment: 'pending, running, waiting_user, succeeded, failed, skipped',
+    },
+    {
+      name: 'attempt',
+      type: 'integer',
+      defaultValue: 0,
+    },
+    {
+      name: 'maxAttempts',
+      type: 'integer',
+      defaultValue: 2,
+    },
+    {
+      name: 'dependsOn',
+      type: 'json',
+      defaultValue: [],
+    },
+    {
+      name: 'dependencyPolicy',
+      type: 'string',
+      length: 30,
+      defaultValue: 'require_success',
+      comment: 'require_success or allow_skipped',
+    },
+    {
+      name: 'approval',
+      type: 'json',
+      defaultValue: {},
+    },
+    {
+      name: 'error',
+      type: 'text',
+    },
+    {
+      name: 'agentExecutionSpanId',
+      type: 'bigInt',
+    },
+    {
+      name: 'skillExecutionId',
+      type: 'bigInt',
+    },
+    {
+      name: 'metadata',
+      type: 'json',
+      defaultValue: {},
+    },
+    {
+      name: 'startedAt',
+      type: 'date',
+    },
+    {
+      name: 'endedAt',
+      type: 'date',
+    },
+    {
+      name: 'createdAt',
+      type: 'date',
+    },
+    {
+      name: 'updatedAt',
+      type: 'date',
+    },
+  ],
+  indexes: [
+    {
+      fields: ['runId'],
+    },
+    {
+      fields: ['status'],
+    },
+    {
+      fields: ['planKey'],
+    },
+  ],
+});

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

@@ -46,6 +46,13 @@ export default defineCollection({
       comment:
         'Max LangGraph reasoning steps (tool-call + LLM-step iterations) per delegation. Lower = safer; higher = more complex multi-step tasks. Default 50.',
     },
+    {
+      name: 'harnessTag',
+      type: 'string',
+      length: 100,
+      defaultValue: 'default',
+      comment: 'Harness profile tag used by the orchestrator controller and approval flow.',
+    },
     {
       name: 'llmService',
       type: 'string',