plugin-agent-orchestrator 1.0.14 → 1.0.16

package/src/server/skill-hub/tasks/SkillExecutionTask.ts

@@ -1,8 +1,10 @@
 import Application from '@nocobase/server';
-import { resolve } from 'path';
+import { cpSync, existsSync, readFileSync, rmSync } from 'fs';
+import { resolve, sep } from 'path';
 import { SandboxRunner } from '../../services/SandboxRunner';
 import { FileManager } from '../../services/FileManager';
 import { SkillRepositoryService } from '../../services/SkillRepositoryService';
+import { CodeValidator } from '../../services/CodeValidator';
 import { parseJsonText, stringifyJsonText } from '../utils/json-fields';
 
 /**
@@ -62,13 +64,13 @@ export class SkillExecutionTask {
     const abortController = new TaskAbortController();
     const abortChannel = `skill-hub.abort.${execId}`;
     const abortCallback = async () => {
-      this.app.logger.info(`[skill-hub] Task ${execId}: received abort signal`);
+      (this as any).app.logger.info(`[skill-hub] Task ${execId}: received abort signal`);
       abortController.abort();
     };
 
     try {
       // Subscribe to abort channel before starting execution
-      await this.app.pubSubManager.subscribe(abortChannel, abortCallback);
+      await (this as any).app.pubSubManager.subscribe(abortChannel, abortCallback);
 
       // Render code template with input args
       const inputArgs = parseJsonText(this.execution.get('inputArgs'), {});
@@ -84,7 +86,7 @@ export class SkillExecutionTask {
 
       if (storageType === 'plugin') {
         const pluginSkillName = (skill.get ? skill.get('pluginSource') : skill.pluginSource) || skillName;
-        const orchestratorPlugin = this.app.pm.get('plugin-agent-orchestrator') as any;
+        const orchestratorPlugin = (this as any).app.pm.get('plugin-agent-orchestrator') as any;
         const skillHub = orchestratorPlugin?.skillHub;
         let pluginTemplate = typeof skillHub?.resolveSkillTemplate === 'function'
           ? skillHub.resolveSkillTemplate(pluginSkillName)
@@ -92,7 +94,7 @@ export class SkillExecutionTask {
 
         // Fallback: discover dynamically if not cached (e.g. executed in worker before UI was loaded)
         if (!pluginTemplate && skillHub) {
-          const allPlugins = this.app.pm.getPlugins();
+          const allPlugins = (this as any).app.pm.getPlugins();
           for (const [, pInstance] of allPlugins) {
             if (typeof (pInstance as any).getSkillTemplates === 'function') {
               const pluginSkills = (pInstance as any).getSkillTemplates();
@@ -148,7 +150,7 @@ export class SkillExecutionTask {
       // Load package whitelist for import validation
       let packageWhitelist: string[] = [];
       try {
-        const workerConfig = await this.app.db.getRepository('skillWorkerConfigs').findOne();
+        const workerConfig = await (this as any).app.db.getRepository('skillWorkerConfigs').findOne();
         if (workerConfig) {
           const wl = parseJsonText(
             workerConfig.get ? workerConfig.get('packageWhitelist') : workerConfig.packageWhitelist,
@@ -167,8 +169,8 @@ export class SkillExecutionTask {
 
       // In multi-node setups, local cache might be missing on this specific worker node. Re-download from S3 if needed.
       if (!require('fs').existsSync(this.skillRepoService.getSkillPath(skillName)) && fileId) {
-        const fmPlugin = this.app.pm.get('@nocobase/plugin-file-manager') as any;
-        const attachment = await this.app.db.getRepository('attachments').findOne({ filter: { id: fileId } });
+        const fmPlugin = (this as any).app.pm.get('@nocobase/plugin-file-manager') as any;
+        const attachment = await (this as any).app.db.getRepository('attachments').findOne({ filter: { id: fileId } });
         if (fmPlugin && attachment) {
           try {
             const streamData = await fmPlugin.getFileStream(attachment);
@@ -183,12 +185,12 @@ export class SkillExecutionTask {
               });
               await this.skillRepoService.extractSkillPackage(skillName, tempZipPath);
               require('fs').unlinkSync(tempZipPath);
-              this.app.logger.info(
+              (this as any).app.logger.info(
                 `[skill-hub] Task ${execId}: Auto-restored skill package ${skillName} from S3/Storage`,
               );
             }
           } catch (fetchErr) {
-            this.app.logger.warn(
+            (this as any).app.logger.warn(
               `[skill-hub] Task ${execId}: Failed to fetch skill package ${skillName} from storage`,
               { error: fetchErr },
             );
@@ -212,10 +214,17 @@ export class SkillExecutionTask {
         packageWhitelist,
         onProgress: (progress) => {
           // Worker → PubSub → Main Server → runtime.writer → SSE → Client
-          this.app.pubSubManager.publish(`skill-hub.progress.${execId}`, progress);
+          (this as any).app.pubSubManager.publish(`skill-hub.progress.${execId}`, progress);
         },
       });
 
+      if (result.success) {
+        const installMessage = await this.installGeneratedSkillIfRequested(execId);
+        if (installMessage) {
+          result.stdout = [result.stdout, installMessage].filter(Boolean).join('\n');
+        }
+      }
+
       // Determine final status
       let status: string;
       if (result.canceled) {
@@ -235,7 +244,7 @@ export class SkillExecutionTask {
       });
 
       // Notify main server: task completed
-      await this.app.pubSubManager.publish(`skill-hub.done.${execId}`, {
+      await (this as any).app.pubSubManager.publish(`skill-hub.done.${execId}`, {
         status,
         stdout: result.stdout?.slice(0, 3000),
         stderr: result.stderr?.slice(0, 1000),
@@ -244,7 +253,7 @@ export class SkillExecutionTask {
       });
 
       // Log execution metrics
-      this.app.logger.info(
+      (this as any).app.logger.info(
         `[skill-hub] Execution ${execId} ${status}: ` +
           `skill=${skill.get ? skill.get('name') : skill.name}, ` +
           `language=${language}, ` +
@@ -260,18 +269,18 @@ export class SkillExecutionTask {
         stderr: errorMessage,
       });
 
-      await this.app.pubSubManager.publish(`skill-hub.done.${execId}`, {
+      await (this as any).app.pubSubManager.publish(`skill-hub.done.${execId}`, {
         status: 'failed',
         stderr: errorMessage,
         files: [],
         durationMs: 0,
       });
 
-      this.app.logger.error(`[skill-hub] Execution ${execId} error: ${errorMessage}`);
+      (this as any).app.logger.error(`[skill-hub] Execution ${execId} error: ${errorMessage}`);
     } finally {
       // Always cleanup abort subscription
       try {
-        await this.app.pubSubManager.unsubscribe(abortChannel, abortCallback);
+        await (this as any).app.pubSubManager.unsubscribe(abortChannel, abortCallback);
       } catch {
         // ignore cleanup errors
       }
@@ -294,4 +303,141 @@ export class SkillExecutionTask {
     code = code.replaceAll('{{skillDir}}', (skillDir || '').replace(/\\/g, '/'));
     return code;
   }
+
+  private async installGeneratedSkillIfRequested(execId: string): Promise<string | null> {
+    const manifestPath = this.fileManager.getOutputFilePath(execId, 'skill-hub-install.json');
+    if (!manifestPath) return null;
+
+    let manifest: any;
+    try {
+      manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+    } catch (error) {
+      throw new Error(`Generated skill install manifest is invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+
+    if (!manifest?.autoInstall) return null;
+
+    const skill = manifest.skill || {};
+    const name = String(skill.name || '').trim();
+    if (!/^[a-z0-9][a-z0-9-]{0,63}$/.test(name)) {
+      throw new Error(`Generated skill name "${name}" is invalid. Use lowercase letters, numbers, and hyphens.`);
+    }
+
+    const language = skill.language;
+    if (language !== 'python' && language !== 'node') {
+      throw new Error(`Generated skill "${name}" has unsupported language "${language}".`);
+    }
+
+    if (!skill.codeTemplate) {
+      throw new Error(`Generated skill "${name}" is missing codeTemplate.`);
+    }
+
+    const validator = new CodeValidator();
+    validator.validate(skill.codeTemplate, language);
+    await this.validateGeneratedSkillPackages(name, language, skill.packages);
+
+    const outputDir = this.fileManager.getOutputDir(execId);
+    const outputRoot = resolve(outputDir);
+    const packageDirName = String(manifest.packageDir || name);
+    const packageDir = resolve(outputRoot, packageDirName);
+    if ((packageDir !== outputRoot && !packageDir.startsWith(outputRoot + sep)) || !existsSync(packageDir)) {
+      throw new Error(`Generated skill package directory "${packageDirName}" was not found in output.`);
+    }
+
+    if (manifest.testInput && Object.keys(manifest.testInput).length > 0) {
+      const verifyExecId = `${execId}-verify-${name}`;
+      const verifyCode = this.renderTemplate(skill.codeTemplate, manifest.testInput, verifyExecId, packageDir);
+      const verifyResult = await this.sandboxRunner.execute({
+        language,
+        code: verifyCode,
+        execId: verifyExecId,
+        timeoutSeconds: Math.min(Number(skill.timeoutSeconds || 60), 30),
+        maxOutputSizeMb: Math.min(Number(skill.maxOutputSizeMb || 50), 10),
+        skillDir: packageDir,
+      });
+
+      if (!verifyResult.success) {
+        throw new Error(
+          `Generated skill "${name}" failed smoke verification: ${verifyResult.stderr || verifyResult.stdout || 'unknown error'}`,
+        );
+      }
+    }
+
+    const skillRepoDir = this.skillRepoService.getSkillPath(name);
+    if (existsSync(skillRepoDir)) {
+      rmSync(skillRepoDir, { recursive: true, force: true });
+    }
+    cpSync(packageDir, skillRepoDir, {
+      recursive: true,
+      force: true,
+      filter: (src) => {
+        const leaf = src.split(/[\\/]/).pop();
+        return !['node_modules', '.git', '__pycache__'].includes(leaf || '') && !src.endsWith('.pyc');
+      },
+    });
+
+    const values: any = {
+      name,
+      title: skill.title || name,
+      description: skill.description || '',
+      instructions: skill.instructions || '',
+      language,
+      codeTemplate: skill.codeTemplate,
+      inputSchema: stringifyJsonText(skill.inputSchema || { type: 'object', properties: {} }),
+      packages: stringifyJsonText(skill.packages || [], []),
+      timeoutSeconds: skill.timeoutSeconds || 60,
+      maxOutputSizeMb: skill.maxOutputSizeMb || 50,
+      enabled: skill.enabled !== false,
+      toolScope: skill.toolScope || 'CUSTOM',
+      autoCall: !!skill.autoCall,
+      storageType: 'local',
+      storageUrl: `local://generated/${name}`,
+    };
+
+    if (skill.interactionSchema) {
+      values.interactionSchema = stringifyJsonText(skill.interactionSchema);
+    }
+
+    const repo = (this as any).app.db.getRepository('skillDefinitions');
+    const existing = await repo.findOne({ filter: { name } });
+    if (existing) {
+      if (manifest.overwrite === false) {
+        throw new Error(`Skill "${name}" already exists and overwrite=false.`);
+      }
+      await repo.update({ filter: { name }, values });
+      return `[skill-hub] Updated generated skill "${name}" in Skill Hub.`;
+    }
+
+    await repo.create({ values });
+    return `[skill-hub] Installed generated skill "${name}" in Skill Hub.`;
+  }
+
+  private async validateGeneratedSkillPackages(name: string, language: 'python' | 'node', packages: any) {
+    if (!Array.isArray(packages) || packages.length === 0) return;
+    if (!packages.every((pkg) => typeof pkg === 'string' && pkg.trim())) {
+      throw new Error(`Generated skill "${name}" has invalid packages. Use an array of package names.`);
+    }
+
+    const workerConfig = await (this as any).app.db.getRepository('skillWorkerConfigs').findOne();
+    if (!workerConfig) return;
+
+    const whitelist = parseJsonText(
+      workerConfig.get ? workerConfig.get('packageWhitelist') : workerConfig.packageWhitelist,
+      null,
+    );
+    const allowed = whitelist?.[language];
+    if (!Array.isArray(allowed) || allowed.length === 0) return;
+
+    const allowedSet = new Set(allowed.map((pkg: string) => pkg.toLowerCase()));
+    const missing = packages
+      .map((pkg: string) => pkg.trim())
+      .filter((pkg: string) => !allowedSet.has(pkg.toLowerCase()));
+
+    if (missing.length > 0) {
+      throw new Error(
+        `Generated skill "${name}" requires ${language} package(s) not available in the Skill Hub worker environment: ` +
+          `${missing.join(', ')}. Add them to the worker environment and refresh/init Skill Hub before installing this skill.`,
+      );
+    }
+  }
 }

package/src/server/tools/delegate-task.ts

@@ -1046,13 +1046,37 @@ async function invokeDelegateTask(
     });
 
     // --- Step 4: Construct messages ---
-    const systemPrompt =
+    let systemPrompt =
       subAgentEmployee.chatSettings?.systemPrompt ||
       subAgentEmployee.bio ||
       `You are an AI assistant named "${subAgentEmployee.nickname || subAgentUsername}". ${
         subAgentEmployee.about || ''
       }`;
 
+    // --- Step 4b: Inject shared context from Knowledge Base (soft dependency) ---
+    // If plugin-knowledge-base is installed, inject the session context summary
+    // so the sub-agent is aware of findings from previous agents in this run.
+    try {
+      const kbPlugin = ctx.app.pm.get('plugin-knowledge-base') as any;
+      if (kbPlugin?.sessionContext) {
+        const sessionId =
+          ctx.action?.params?.values?.sessionId ||
+          ctx.action?.params?.sessionId ||
+          ctx.state?.sessionId;
+
+        const contextSummary = await kbPlugin.sessionContext.buildSummary(
+          { rootRunId, ...(sessionId ? { sessionId } : {}) },
+          6000,
+        );
+        if (contextSummary) {
+          systemPrompt += `\n\n<shared_context>\nThe following context was shared by other agents in this workflow. Use it to avoid redundant work:\n${contextSummary}\n</shared_context>`;
+        }
+      }
+    } catch (e: any) {
+      // Graceful fallback — never block delegation due to context injection failure.
+      ctx.app.log?.debug?.(`[AgentOrchestrator] Shared context injection skipped: ${e.message}`);
+    }
+
     const combinedTask = context ? `Task: ${task}\n\nContext Provided:\n${context}` : `Task: ${task}`;
 
     // --- Step 5: Execute with timeout + abort ---

package/src/server/tools/external-rag-search.ts

@@ -0,0 +1,128 @@
+import { z } from 'zod';
+
+const TOOL_NAME = 'external_rag_search';
+const MAX_CONTENT_LENGTH = 4000;
+
+function truncate(value: unknown, max = MAX_CONTENT_LENGTH) {
+  const text = typeof value === 'string' ? value : value == null ? '' : String(value);
+  return text.length > max ? `${text.slice(0, max)}...` : text;
+}
+
+function firstString(...values: unknown[]) {
+  for (const value of values) {
+    if (typeof value === 'string' && value.trim()) {
+      return value.trim();
+    }
+    if (typeof value === 'number' && Number.isFinite(value)) {
+      return String(value);
+    }
+  }
+  return undefined;
+}
+
+function normalizeResult(result: any) {
+  const metadata = result?.metadata ?? {};
+  const sourceId = firstString(
+    result?.id,
+    metadata.id,
+    metadata.sourceId,
+    metadata.documentId,
+    metadata.docId,
+    metadata.fileId,
+    metadata.recordId,
+  );
+  const filename = firstString(metadata.filename, metadata.fileName, metadata.name, metadata.title, metadata.source);
+
+  return {
+    content: truncate(result?.content),
+    score: Number(result?.rerankScore ?? result?.score ?? result?.vectorScore ?? 0),
+    knowledgeBaseId: result?.knowledgeBaseId,
+    knowledgeBaseName: result?.knowledgeBaseName,
+    source: {
+      id: sourceId,
+      filename,
+      url: firstString(metadata.url, metadata.fileUrl, metadata.sourceUrl),
+      collection: firstString(metadata.collection, metadata.collectionName),
+      recordId: firstString(metadata.recordId, metadata.rowId),
+    },
+    metadata,
+  };
+}
+
+export function createExternalRagSearchTool(plugin: any) {
+  return {
+    scope: 'CUSTOM' as const,
+    execution: 'backend' as const,
+    defaultPermission: 'ALLOW' as const,
+
+    introduction: {
+      title: 'External RAG Search',
+      about:
+        'Search NocoBase knowledge bases through plugin-knowledge-base, including EXTERNAL_RAG services that own chunking, embedding, and retrieval.',
+    },
+
+    definition: {
+      name: TOOL_NAME,
+      description: `Search configured knowledge bases for relevant context. Use this before answering questions that require documents, files, or datasource-backed knowledge.
+
+The search may be served by an external RAG service. Results include content plus source identifiers such as id, filename, collection, and recordId when the external service provides them.`,
+      schema: z.object({
+        query: z.string().min(1).describe('Natural-language search query.'),
+        knowledgeBaseIds: z
+          .array(z.string().min(1))
+          .optional()
+          .describe(
+            'Optional list of NocoBase knowledge base IDs to search. If omitted, all accessible KBs are searched.',
+          ),
+        topK: z.number().int().min(1).max(20).optional().describe('Maximum results to return. Default 5, max 20.'),
+        scoreThreshold: z
+          .number()
+          .min(0)
+          .max(1)
+          .optional()
+          .describe('Minimum relevance score. Default is controlled by plugin-knowledge-base.'),
+      }),
+    },
+
+    invoke: async (
+      ctx: any,
+      args: { query?: string; knowledgeBaseIds?: string[]; topK?: number; scoreThreshold?: number },
+    ) => {
+      const query = typeof args?.query === 'string' ? args.query.trim() : '';
+      if (!query) {
+        return { status: 'error' as const, content: 'Missing required field: query.' };
+      }
+
+      const kbPlugin = ctx?.app?.pm?.get?.('plugin-knowledge-base');
+      if (!kbPlugin?.searchKnowledgeBases) {
+        return {
+          status: 'error' as const,
+          content: 'plugin-knowledge-base is not installed or does not expose searchKnowledgeBases().',
+        };
+      }
+
+      try {
+        const results = await kbPlugin.searchKnowledgeBases(ctx, query, {
+          knowledgeBaseIds: Array.isArray(args.knowledgeBaseIds) ? args.knowledgeBaseIds.map(String) : undefined,
+          topK: args.topK,
+          scoreThreshold: args.scoreThreshold,
+          rerank: true,
+        });
+
+        return {
+          status: 'success' as const,
+          content: JSON.stringify({
+            query,
+            results: (results ?? []).map(normalizeResult),
+          }),
+        };
+      } catch (error: any) {
+        plugin.app.log?.error?.('[AgentOrchestrator] external_rag_search failed', error);
+        return {
+          status: 'error' as const,
+          content: `External RAG search failed: ${error?.message || String(error)}`,
+        };
+      }
+    },
+  };
+}

package/src/server/tools/skill-execute.ts

@@ -42,8 +42,7 @@ IMPORTANT: If the skill returns file download URLs, you MUST format them as clic
       },
     },
 
-    async invoke(args: Record<string, any>, options?: any) {
-      const ctx = options?.context;
+    async invoke(ctx: any, args: Record<string, any>, _id?: string) {
       plugin.app.logger.info(`[skill-execute] Tool invoked with action: ${args.action}, skillName: ${args.skillName}`);
       
       // Action: list available skills