plugin-agent-orchestrator 1.0.16 → 1.0.18

package/dist/server/services/AgentPlannerService.js

@@ -0,0 +1,119 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AgentPlannerService_exports = {};
+__export(AgentPlannerService_exports, {
+  AgentPlannerService: () => AgentPlannerService
+});
+module.exports = __toCommonJS(AgentPlannerService_exports);
+function normalizeStepType(value) {
+  return ["reasoning", "skill", "tool", "sub_agent", "verification"].includes(value) ? value : "tool";
+}
+function normalizePlanKey(step, index) {
+  return String(step.planKey || step.key || step.id || `step_${index + 1}`);
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function asObject(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    try {
+      const parsed = JSON.parse(value);
+      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+class AgentPlannerService {
+  buildPlan(goal, plan, options) {
+    var _a;
+    if (Array.isArray(plan) && plan.length > 0) {
+      return plan.map((step, index) => {
+        var _a2;
+        return {
+          ...step,
+          planKey: normalizePlanKey(step, index),
+          type: normalizeStepType(step.type),
+          dependsOn: asArray(step.dependsOn).map(String),
+          metadata: {
+            ...asObject(step.metadata),
+            harnessTag: options.harnessTag || ((_a2 = options.metadata) == null ? void 0 : _a2.harnessTag) || "default"
+          }
+        };
+      });
+    }
+    const harnessTag = options.harnessTag || ((_a = options.metadata) == null ? void 0 : _a.harnessTag) || "default";
+    const steps = [
+      {
+        planKey: "prepare_context",
+        title: "Prepare execution context",
+        description: "Review the user goal, available context, and constraints before execution.",
+        type: "reasoning",
+        input: { goal },
+        metadata: { harnessTag }
+      }
+    ];
+    if (options.targetAgent) {
+      steps.push({
+        planKey: "delegate_execution",
+        title: `Delegate execution to ${options.targetAgent}`,
+        description: goal,
+        type: "sub_agent",
+        target: options.targetAgent,
+        input: { goal },
+        dependsOn: ["prepare_context"],
+        metadata: { harnessTag }
+      });
+    } else {
+      steps.push({
+        planKey: "execute_goal",
+        title: "Execute approved goal",
+        description: "Execute the user goal in the leader harness using the available approved tools.",
+        type: "reasoning",
+        input: { goal },
+        dependsOn: ["prepare_context"],
+        metadata: { harnessTag, controllerOnly: true }
+      });
+    }
+    steps.push({
+      planKey: "verify_result",
+      title: "Verify result",
+      description: "Check that the completed work matches the approved goal and report evidence.",
+      type: "verification",
+      input: { goal },
+      dependsOn: [steps[steps.length - 1].planKey || "execute_goal"],
+      metadata: { harnessTag }
+    });
+    return steps;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentPlannerService
+});

package/dist/server/services/AgentRegistryService.d.ts

@@ -0,0 +1,13 @@
+export declare class AgentRegistryService {
+    private readonly plugin;
+    constructor(plugin: any);
+    get db(): any;
+    getHarnessProfile(tag: string): Promise<any>;
+    getOrchestratorConfig(leaderUsername: string, subAgentUsername: string): Promise<any>;
+    getAIEmployee(username: string): Promise<any>;
+    resolveModelSettings(subAgentUsername: string, leaderUsername?: string, dynamicValues?: any): Promise<{
+        llmService: string;
+        model: string;
+    }>;
+    isRegisteredDelegationTool(toolName: string): Promise<boolean>;
+}

package/dist/server/services/AgentRegistryService.js

@@ -0,0 +1,178 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AgentRegistryService_exports = {};
+__export(AgentRegistryService_exports, {
+  AgentRegistryService: () => AgentRegistryService
+});
+module.exports = __toCommonJS(AgentRegistryService_exports);
+function toPlain(record) {
+  var _a;
+  return ((_a = record == null ? void 0 : record.toJSON) == null ? void 0 : _a.call(record)) || record;
+}
+function asObject(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    try {
+      const parsed = JSON.parse(value);
+      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+function normalizeEmployeeUsername(raw) {
+  if (!raw) return null;
+  if (typeof raw === "string") return raw;
+  return raw.username || raw.aiEmployeeUsername || raw.name || null;
+}
+class AgentRegistryService {
+  constructor(plugin) {
+    this.plugin = plugin;
+  }
+  get db() {
+    return this.plugin.db;
+  }
+  async getHarnessProfile(tag) {
+    try {
+      const repo = this.db.getRepository("agentHarnessProfiles");
+      if (!repo) return null;
+      const profile = await repo.findOne({
+        filter: {
+          tag: tag || "default",
+          enabled: true
+        }
+      });
+      return profile ? toPlain(profile) : null;
+    } catch {
+      return null;
+    }
+  }
+  async getOrchestratorConfig(leaderUsername, subAgentUsername) {
+    try {
+      const repo = this.db.getRepository("orchestratorConfig");
+      if (!repo) return null;
+      const config = await repo.findOne({
+        filter: {
+          leaderUsername,
+          subAgentUsername,
+          enabled: true
+        }
+      });
+      return config ? toPlain(config) : null;
+    } catch {
+      return null;
+    }
+  }
+  async getAIEmployee(username) {
+    try {
+      const repo = this.db.getRepository("aiEmployees");
+      if (!repo) return null;
+      const employee = await repo.findOne({
+        filter: { username }
+      });
+      return employee ? toPlain(employee) : null;
+    } catch {
+      return null;
+    }
+  }
+  async resolveModelSettings(subAgentUsername, leaderUsername, dynamicValues) {
+    const subAgent = await this.getAIEmployee(subAgentUsername);
+    if (!subAgent) {
+      throw new Error(`Sub-agent "${subAgentUsername}" was not found.`);
+    }
+    const hasModelSettings = (val) => {
+      return Boolean((val == null ? void 0 : val.llmService) && (val == null ? void 0 : val.model));
+    };
+    let modelSettings = hasModelSettings(dynamicValues) ? dynamicValues : void 0;
+    if (!modelSettings) {
+      if (hasModelSettings(subAgent.modelSettings)) {
+        modelSettings = subAgent.modelSettings;
+      }
+    }
+    if (!modelSettings && leaderUsername) {
+      const leader = await this.getAIEmployee(leaderUsername);
+      if (leader && hasModelSettings(leader.modelSettings)) {
+        modelSettings = leader.modelSettings;
+      }
+    }
+    return modelSettings;
+  }
+  async isRegisteredDelegationTool(toolName) {
+    if (!toolName || typeof toolName !== "string") return false;
+    if (!toolName.startsWith("delegate_") && !toolName.startsWith("dispatch_subagents_")) {
+      return false;
+    }
+    try {
+      const configRepo = this.db.getRepository("orchestratorConfig");
+      if (!configRepo) return false;
+      if (toolName.startsWith("dispatch_subagents_")) {
+        const leader = toolName.substring("dispatch_subagents_".length);
+        const count = await configRepo.count({
+          filter: {
+            leaderUsername: leader,
+            enabled: true
+          }
+        });
+        return count > 0;
+      }
+      if (toolName.startsWith("delegate_") && toolName.includes("_to_")) {
+        const parts = toolName.substring("delegate_".length).split("_to_");
+        if (parts.length === 2) {
+          const [leader, subAgent] = parts;
+          const count = await configRepo.count({
+            filter: {
+              leaderUsername: leader,
+              subAgentUsername: subAgent,
+              enabled: true
+            }
+          });
+          if (count > 0) return true;
+        }
+      }
+      if (toolName.startsWith("delegate_to_")) {
+        const subAgent = toolName.substring("delegate_to_".length);
+        const configs = await configRepo.find({
+          filter: {
+            subAgentUsername: subAgent,
+            enabled: true
+          }
+        });
+        if ((configs == null ? void 0 : configs.length) === 1) {
+          return true;
+        }
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentRegistryService
+});

package/dist/server/services/ExecutionSpanService.d.ts

@@ -7,6 +7,8 @@ export type OrchestratorTraceContext = {
     leaderUsername?: string;
     employeeUsername?: string;
     toolName?: string;
+    agentLoopRunId?: string;
+    agentLoopStepId?: string;
 };
 type SpanValues = {
     rootRunId: string;

package/dist/server/skill-hub/plugin.d.ts

@@ -40,6 +40,9 @@ export declare class SkillHubSubFeature {
      * When a worker finishes init, auto-update the DB with status.
      */
     private subscribeInitEnvDone;
+    private getSkillRecordId;
+    private resolveLoopInteractionSchema;
+    private getLoopConfigsBySkillId;
     private registerAITools;
     private startCleanupInterval;
     beforeStop(): Promise<void>;

package/dist/server/skill-hub/plugin.js

@@ -53,6 +53,7 @@ var import_McpController = require("./mcp/McpController");
 var import_SkillRepositoryService = require("../services/SkillRepositoryService");
 var import_git_import = require("./actions/git-import");
 var import_json_fields = require("./utils/json-fields");
+var import_ExecutionSpanService = require("../services/ExecutionSpanService");
 class RateLimiter {
   constructor(maxExecutions = 10, windowMs = 60 * 1e3) {
     this.maxExecutions = maxExecutions;
@@ -77,9 +78,7 @@ class RateLimiter {
   /** Get remaining executions for a user */
   remaining(userId) {
     const now = Date.now();
-    const executions = (this.userExecutions.get(userId) || []).filter(
-      (t) => now - t < this.windowMs
-    );
+    const executions = (this.userExecutions.get(userId) || []).filter((t) => now - t < this.windowMs);
     return Math.max(0, this.maxExecutions - executions.length);
   }
   /** Periodically clean up expired entries (call from interval) */
@@ -152,7 +151,9 @@ class SkillHubSubFeature {
           require("fs").rmSync(dir, { recursive: true, force: true });
         }
       } catch (err) {
-        this.app.logger.error(`[skill-hub] Failed to cleanup physical storage for execId ${execId}`, { error: err });
+        this.app.logger.error(`[skill-hub] Failed to cleanup physical storage for execId ${execId}`, {
+          error: err
+        });
       }
     });
     this.db.on("skillDefinitions.afterSave", async (model, options) => {
@@ -170,29 +171,39 @@ class SkillHubSubFeature {
             }
             const streamData = await fileManager.getFileStream(attachment);
             if (!streamData || !streamData.stream) {
-              this.app.logger.warn(`[skill-hub] Could not get file stream for attachment ${attachment.get("id")}`);
+              this.app.logger.warn(
+                `[skill-hub] Could not get file stream for attachment ${attachment.get("id")}`
+              );
               return;
             }
             const tempZipPath = (0, import_path.resolve)(os.tmpdir(), `skill_${Date.now()}_${model.get("id")}.zip`);
-            await new Promise((resolvePipe, rejectPipe) => {
+            await new Promise((resolve2, reject) => {
               const writeStream = (0, import_fs.createWriteStream)(tempZipPath);
               streamData.stream.pipe(writeStream);
-              writeStream.on("finish", resolvePipe);
-              writeStream.on("error", rejectPipe);
-              streamData.stream.on("error", rejectPipe);
+              writeStream.on("finish", resolve2);
+              writeStream.on("error", reject);
+              streamData.stream.on("error", reject);
             });
             if (require("fs").existsSync(tempZipPath)) {
               const skillName = model.get("name");
-              const { metadata, instructions } = await this.skillRepoService.extractSkillPackage(skillName, tempZipPath);
+              const { metadata, instructions } = await this.skillRepoService.extractSkillPackage(
+                skillName,
+                tempZipPath
+              );
               const code = this.skillRepoService.getSkillCode(skillName);
-              const updateValues = { storageType: attachment.get("storageId") ? `storage-${attachment.get("storageId")}` : "local" };
+              const updateValues = {
+                storageType: attachment.get("storageId") ? `storage-${attachment.get("storageId")}` : "local"
+              };
               if (code) updateValues.codeTemplate = code;
               if (metadata.description) updateValues.description = metadata.description;
               if (metadata.title) updateValues.title = metadata.title;
               if (metadata.language) updateValues.language = metadata.language;
-              if (metadata.inputSchema) updateValues.inputSchema = (0, import_json_fields.stringifyJsonText)((0, import_json_fields.parseJsonLike)(metadata.inputSchema, null));
-              if (metadata.interactionSchema) updateValues.interactionSchema = (0, import_json_fields.stringifyJsonText)((0, import_json_fields.parseJsonLike)(metadata.interactionSchema, null));
-              if (metadata.packages) updateValues.packages = (0, import_json_fields.stringifyJsonText)((0, import_json_fields.parseJsonLike)(metadata.packages, []), []);
+              if (metadata.inputSchema)
+                updateValues.inputSchema = (0, import_json_fields.stringifyJsonText)((0, import_json_fields.parseJsonLike)(metadata.inputSchema, null));
+              if (metadata.interactionSchema)
+                updateValues.interactionSchema = (0, import_json_fields.stringifyJsonText)((0, import_json_fields.parseJsonLike)(metadata.interactionSchema, null));
+              if (metadata.packages)
+                updateValues.packages = (0, import_json_fields.stringifyJsonText)((0, import_json_fields.parseJsonLike)(metadata.packages, []), []);
               if (metadata.timeoutSeconds) updateValues.timeoutSeconds = metadata.timeoutSeconds;
               if (instructions) updateValues.instructions = instructions;
               await this.db.getRepository("skillDefinitions").update({
@@ -262,12 +273,19 @@ class SkillHubSubFeature {
         );
       }
     }
+    const traceContext = (0, import_ExecutionSpanService.getOrchestratorTraceContext)(ctx);
     const execution = await this.db.getRepository("skillExecutions").create({
       values: {
         skillId: skill.id,
         status: "pending",
         inputArgs: (0, import_json_fields.stringifyJsonText)(inputArgs, {}),
         sessionId: (_c = ctx == null ? void 0 : ctx.state) == null ? void 0 : _c.sessionId,
+        orchestratorRootRunId: traceContext == null ? void 0 : traceContext.rootRunId,
+        orchestratorSpanId: traceContext == null ? void 0 : traceContext.spanId,
+        orchestratorParentSpanId: traceContext == null ? void 0 : traceContext.parentSpanId,
+        orchestratorToolCallId: traceContext == null ? void 0 : traceContext.toolCallId,
+        agentLoopRunId: traceContext == null ? void 0 : traceContext.agentLoopRunId,
+        agentLoopStepId: traceContext == null ? void 0 : traceContext.agentLoopStepId,
         triggeredById: (_e = (_d = ctx == null ? void 0 : ctx.state) == null ? void 0 : _d.currentUser) == null ? void 0 : _e.id
       }
     });
@@ -340,7 +358,13 @@ class SkillHubSubFeature {
         downloadUrl: `/api/skillHub:download?execId=${execId}&f=${b64name}`
       };
     });
-    return { ...result, files: filesWithUrls, execId };
+    return {
+      ...result,
+      files: filesWithUrls,
+      execId,
+      agentLoopRunId: traceContext == null ? void 0 : traceContext.agentLoopRunId,
+      agentLoopStepId: traceContext == null ? void 0 : traceContext.agentLoopStepId
+    };
   }
   async handleDownload(ctx, next) {
     var _a, _b;
@@ -455,6 +479,49 @@ class SkillHubSubFeature {
     await this.app.pubSubManager.subscribe("skill-hub.init-env.done", this.initEnvDoneCallback);
     await this.app.pubSubManager.subscribe("skill-hub.init-env.progress", this.initEnvProgressCallback);
   }
+  getSkillRecordId(skill) {
+    return String(skill.get ? skill.get("id") : skill.id);
+  }
+  resolveLoopInteractionSchema(loopConfig) {
+    if (!loopConfig) return null;
+    const schema = (0, import_json_fields.parseJsonText)(loopConfig.get ? loopConfig.get("schema") : loopConfig.schema, null);
+    const prompt = loopConfig.get ? loopConfig.get("prompt") : loopConfig.prompt;
+    if (schema && typeof schema === "object") {
+      return prompt && !schema.prompt ? { ...schema, prompt } : schema;
+    }
+    if (prompt) {
+      return {
+        type: "confirm",
+        prompt
+      };
+    }
+    return null;
+  }
+  async getLoopConfigsBySkillId(skillIds) {
+    const ids = Array.from(new Set(skillIds.map((id) => String(id)).filter(Boolean)));
+    const configsBySkillId = /* @__PURE__ */ new Map();
+    if (!ids.length) return configsBySkillId;
+    try {
+      const configs = await this.db.getRepository("skillLoopConfigs").find({
+        filter: {
+          enabled: true,
+          skillId: {
+            $in: ids
+          }
+        },
+        sort: ["-updatedAt"]
+      });
+      for (const config of configs || []) {
+        const skillId = String(config.get ? config.get("skillId") : config.skillId);
+        if (!configsBySkillId.has(skillId)) {
+          configsBySkillId.set(skillId, config);
+        }
+      }
+    } catch (err) {
+      this.app.logger.warn("[skill-hub] Failed to load loop configs", err);
+    }
+    return configsBySkillId;
+  }
   registerAITools() {
     var _a;
     try {
@@ -470,45 +537,56 @@ class SkillHubSubFeature {
             filter: { enabled: true }
           });
           if (!skills || skills.length === 0) return;
-          const tools = await Promise.all(skills.map(async (skill) => {
-            const sanitizedToolName = skill.get("name").toLowerCase().replace(/[^a-z0-9_]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
-            const autoCall = !!skill.get("autoCall");
-            const interactionSchema = (0, import_json_fields.parseJsonText)(skill.get("interactionSchema"), null);
-            const fullDescription = await this.getSkillDescriptionForAI(skill);
-            const baseDescription = `${fullDescription || skill.get("description")}
-Language: ${skill.get("language")}`;
-            const description = !autoCall && interactionSchema ? `${baseDescription}
+          const loopConfigsBySkillId = await this.getLoopConfigsBySkillId(
+            skills.map((skill) => this.getSkillRecordId(skill))
+          );
+          const tools = await Promise.all(
+            skills.map(async (skill) => {
+              const sanitizedToolName = skill.get("name").toLowerCase().replace(/[^a-z0-9_]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+              const autoCall = !!skill.get("autoCall");
+              const loopConfig = loopConfigsBySkillId.get(this.getSkillRecordId(skill));
+              const loopInteractionSchema = this.resolveLoopInteractionSchema(loopConfig);
+              const skillInteractionSchema = (0, import_json_fields.parseJsonText)(skill.get("interactionSchema"), null);
+              const interactionSchema = loopInteractionSchema || skillInteractionSchema;
+              const requiresHumanReview = !!interactionSchema;
+              const fullDescription = await this.getSkillDescriptionForAI(skill);
+              const baseDescription = `${fullDescription || skill.get("description")}
+Language: ${skill.get(
+                "language"
+              )}`;
+              const description = requiresHumanReview ? `${baseDescription}
 
-IMPORTANT: This skill requires human confirmation. Pass best-effort args; the user will adjust them in UI before execution.` : baseDescription;
-            return {
-              scope: "CUSTOM",
-              execution: "backend",
-              defaultPermission: autoCall ? "ALLOW" : "ASK",
-              introduction: {
-                title: `Skill Hub: ${skill.get("title")}`,
-                about: skill.get("description") || `Th\u1EF1c thi k\u1EF9 n\u0103ng ${skill.get("title")}`
-              },
-              definition: {
-                name: `skill_hub_${sanitizedToolName}`,
-                description,
-                schema: (0, import_json_fields.parseJsonText)(skill.get("inputSchema"), { type: "object", properties: {} })
-              },
-              invoke: async (toolCtx, args) => {
-                const latestSkill = await this.db.getRepository("skillDefinitions").findOne({
-                  filter: { id: skill.get("id"), enabled: true }
-                });
-                if (!latestSkill) {
-                  return { status: "error", content: `Skill "${skill.get("name")}" is no longer available` };
+IMPORTANT: This skill is bound to a Skill Hub human-in-the-loop review template. Pass best-effort args; the user can approve, edit, or reject them before execution.` : baseDescription;
+              return {
+                scope: "CUSTOM",
+                execution: "backend",
+                defaultPermission: requiresHumanReview ? "ASK" : autoCall ? "ALLOW" : "ASK",
+                introduction: {
+                  title: `Skill Hub: ${skill.get("title")}`,
+                  about: skill.get("description") || `Th\u1EF1c thi k\u1EF9 n\u0103ng ${skill.get("title")}`
+                },
+                definition: {
+                  name: `skill_hub_${sanitizedToolName}`,
+                  description,
+                  schema: (0, import_json_fields.parseJsonText)(skill.get("inputSchema"), { type: "object", properties: {} })
+                },
+                invoke: async (toolCtx, args) => {
+                  const latestSkill = await this.db.getRepository("skillDefinitions").findOne({
+                    filter: { id: skill.get("id"), enabled: true }
+                  });
+                  if (!latestSkill) {
+                    return { status: "error", content: `Skill "${skill.get("name")}" is no longer available` };
+                  }
+                  const result = await this.executeSkill(latestSkill, args, toolCtx);
+                  return {
+                    status: result.status === "succeeded" ? "success" : "error",
+                    result
+                    // Attach raw result
+                  };
                 }
-                const result = await this.executeSkill(latestSkill, args, toolCtx);
-                return {
-                  status: result.status === "succeeded" ? "success" : "error",
-                  result
-                  // Attach raw result
-                };
-              }
-            };
-          }));
+              };
+            })
+          );
           register.registerTools(tools);
         } catch (err) {
           this.app.logger.warn("[skill-hub] Failed to provide dynamic tools", err);
@@ -616,7 +694,9 @@ IMPORTANT: This skill requires human confirmation. Pass best-effort args; the us
    */
   registerSkillTemplate(pluginName, skillDef) {
     this.skillTemplates.set(skillDef.name, this.hydrateSkillTemplate(pluginName, skillDef));
-    this.app.logger.info(`[skill-hub] Registered skill template "${skillDef.name}" from plugin "${pluginName}"`);
+    this.app.logger.info(
+      `[skill-hub] Registered skill template "${skillDef.name}" from plugin "${pluginName}"`
+    );
   }
   resolveSkillTemplate(templateName) {
     if (!templateName) return null;
@@ -644,7 +724,10 @@ IMPORTANT: This skill requires human confirmation. Pass best-effort args; the us
     const description = skill.get ? skill.get("description") : skill.description;
     const instructions = await this.getSkillInstructions(skill);
     const maxInlineInstructionChars = 24e3;
-    const inlineInstructions = instructions && instructions.length > maxInlineInstructionChars ? `${instructions.slice(0, maxInlineInstructionChars)}
+    const inlineInstructions = instructions && instructions.length > maxInlineInstructionChars ? `${instructions.slice(
+      0,
+      maxInlineInstructionChars
+    )}
 
 [Instructions truncated in tool description. Call skill_hub_execute with action="describe" and this skillName to load the complete workflow.]` : instructions;
     return [description, inlineInstructions ? `Instructions: