@ai-setting/roy-agent-core 1.5.41 → 1.5.43

package/dist/shared/@ai-setting/roy-agent-core-fg3j215p.js

@@ -0,0 +1,313 @@
+import {
+  getXDGPath
+} from "./roy-agent-core-qxnbvgwe.js";
+import {
+  TracedAs,
+  init_decorator
+} from "./roy-agent-core-q5qj0fes.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-10n2jh7p.js";
+import {
+  __legacyDecorateClassTS
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/agent/agent-registry.ts
+import { readdir, readFile, writeFile, mkdir, unlink } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { z } from "zod";
+import yaml from "yaml";
+init_logger();
+init_decorator();
+var logger = createLogger("agent:registry");
+var AgentConfigSchema = z.object({
+  name: z.string(),
+  type: z.enum(["primary", "sub"]),
+  description: z.string().optional(),
+  systemPromptRef: z.string().optional(),
+  systemPrompt: z.string().optional(),
+  model: z.string().optional(),
+  maxIterations: z.number().optional(),
+  maxErrorRetries: z.number().optional(),
+  allowedTools: z.array(z.string()).optional(),
+  deniedTools: z.array(z.string()).optional(),
+  toolTimeout: z.number().optional(),
+  toolRetries: z.number().optional(),
+  doomLoopThreshold: z.number().optional(),
+  filterHistory: z.boolean().optional()
+});
+
+class AgentRegistry {
+  agents = new Map;
+  configDir;
+  configComponent;
+  promptComponent;
+  resolvePromptComponent;
+  constructor(options) {
+    this.configComponent = options.configComponent;
+    this.promptComponent = options.promptComponent ?? null;
+    this.resolvePromptComponent = options.resolvePromptComponent;
+    const customDir = this.configComponent?.get?.("agent.configDir");
+    if (customDir && typeof customDir === "string" && customDir.length > 0) {
+      this.configDir = customDir;
+    } else if (options.baseDir) {
+      this.configDir = join(options.baseDir, "agents");
+    } else {
+      this.configDir = join(getXDGPath("data"), "agents");
+    }
+    logger.debug(`[AgentRegistry] Config dir: ${this.configDir}`);
+  }
+  getConfigDir() {
+    return this.configDir;
+  }
+  hasAgent(name) {
+    return this.agents.has(name);
+  }
+  get(name) {
+    return this.agents.get(name);
+  }
+  list() {
+    return Array.from(this.agents.values());
+  }
+  listAgentsByType(type) {
+    return this.list().filter((agent) => agent.type === type);
+  }
+  register(agent) {
+    if (!agent.name) {
+      throw new Error("Agent name is required");
+    }
+    this.agents.set(agent.name, { ...agent });
+    logger.info(`[AgentRegistry] Registered agent: ${agent.name}`, { type: agent.type });
+  }
+  unregister(name) {
+    const deleted = this.agents.delete(name);
+    if (deleted) {
+      logger.info(`[AgentRegistry] Unregistered agent: ${name}`);
+    }
+    return deleted;
+  }
+  clear() {
+    this.agents.clear();
+    logger.info("[AgentRegistry] Cleared all agents");
+  }
+  async getSystemPrompt(name) {
+    const agent = this.agents.get(name);
+    if (!agent) {
+      return;
+    }
+    const promptComponent = this.getActivePromptComponent();
+    if (agent.systemPromptRef) {
+      try {
+        const prompt = promptComponent?.get?.(agent.systemPromptRef);
+        if (prompt) {
+          logger.debug(`[AgentRegistry] Resolved systemPromptRef: ${agent.systemPromptRef}`);
+          return prompt;
+        }
+        if (promptComponent?.getPrompt) {
+          const rendered = await promptComponent.getPrompt(agent.systemPromptRef);
+          if (rendered) {
+            return rendered;
+          }
+        }
+        if (agent.systemPrompt) {
+          logger.debug(`[AgentRegistry] systemPromptRef not found, falling back to inline`);
+          return agent.systemPrompt;
+        }
+        return;
+      } catch (error) {
+        logger.warn(`[AgentRegistry] Failed to resolve systemPromptRef: ${agent.systemPromptRef}`, { error });
+        return agent.systemPrompt;
+      }
+    }
+    return agent.systemPrompt;
+  }
+  getActivePromptComponent() {
+    return this.resolvePromptComponent?.() ?? this.promptComponent;
+  }
+  getInlineSystemPrompt(name) {
+    const agent = this.agents.get(name);
+    if (!agent) {
+      return;
+    }
+    return agent.systemPrompt;
+  }
+  async load() {
+    try {
+      return await this.loadFromDirectory(this.configDir);
+    } catch (error) {
+      logger.warn(`[AgentRegistry] Failed to load agents: ${error}`);
+      return 0;
+    }
+  }
+  async loadFromDirectory(directory) {
+    let loaded = 0;
+    try {
+      if (!existsSync(directory)) {
+        logger.debug(`[AgentRegistry] Config directory does not exist: ${directory}`);
+        return 0;
+      }
+      const files = await readdir(directory, { withFileTypes: true });
+      for (const file of files) {
+        const fullPath = join(directory, file.name);
+        if (file.isDirectory()) {
+          continue;
+        }
+        if (!isAgentConfigFile(file.name)) {
+          continue;
+        }
+        try {
+          const content = await readFile(fullPath, "utf-8");
+          const agent = this.parseAgentConfig(content, fullPath);
+          if (agent) {
+            this.agents.set(agent.name, agent);
+            logger.info(`[AgentRegistry] Loaded agent: ${agent.name} from ${file.name}`);
+            loaded++;
+          }
+        } catch (error) {
+          logger.warn(`[AgentRegistry] Failed to load agent from ${file.name}: ${error}`);
+        }
+      }
+      logger.info(`[AgentRegistry] Loaded ${loaded} agents from ${directory}`);
+    } catch (error) {
+      logger.warn(`[AgentRegistry] Error reading config directory: ${error}`);
+    }
+    return loaded;
+  }
+  parseAgentConfig(content, source) {
+    try {
+      const parsed = yaml.parse(content);
+      const result = AgentConfigSchema.safeParse(parsed);
+      if (!result.success) {
+        logger.warn(`[AgentRegistry] Invalid agent config: ${source}`, {
+          errors: result.error.errors
+        });
+        return null;
+      }
+      return result.data;
+    } catch (error) {
+      logger.error(`[AgentRegistry] Failed to parse agent config: ${source}`, { error });
+      return null;
+    }
+  }
+  async saveAgent(agent) {
+    try {
+      await this.ensureConfigDir();
+      const yamlContent = this.agentToYaml(agent);
+      const filePath = join(this.configDir, `${agent.name}.yaml`);
+      await writeFile(filePath, yamlContent, "utf-8");
+      this.agents.set(agent.name, agent);
+      logger.info(`[AgentRegistry] Saved agent: ${agent.name} to ${filePath}`);
+      return true;
+    } catch (error) {
+      logger.error(`[AgentRegistry] Failed to save agent: ${agent.name}`, { error });
+      return false;
+    }
+  }
+  async ensureConfigDir() {
+    if (!existsSync(this.configDir)) {
+      await mkdir(this.configDir, { recursive: true });
+      logger.debug(`[AgentRegistry] Created config directory: ${this.configDir}`);
+    }
+  }
+  agentToYaml(agent) {
+    const config = {
+      name: agent.name,
+      type: agent.type,
+      ...agent.description !== undefined ? { description: agent.description } : {},
+      ...agent.systemPromptRef !== undefined ? { systemPromptRef: agent.systemPromptRef } : {},
+      ...agent.systemPrompt !== undefined ? { systemPrompt: agent.systemPrompt } : {},
+      ...agent.model !== undefined ? { model: agent.model } : {},
+      ...agent.maxIterations !== undefined ? { maxIterations: agent.maxIterations } : {},
+      ...agent.maxErrorRetries !== undefined ? { maxErrorRetries: agent.maxErrorRetries } : {},
+      ...agent.allowedTools !== undefined ? { allowedTools: agent.allowedTools } : {},
+      ...agent.deniedTools !== undefined ? { deniedTools: agent.deniedTools } : {},
+      ...agent.toolTimeout !== undefined ? { toolTimeout: agent.toolTimeout } : {},
+      ...agent.toolRetries !== undefined ? { toolRetries: agent.toolRetries } : {},
+      ...agent.doomLoopThreshold !== undefined ? { doomLoopThreshold: agent.doomLoopThreshold } : {},
+      ...agent.filterHistory !== undefined ? { filterHistory: agent.filterHistory } : {}
+    };
+    return yaml.stringify(config).trimEnd() + `
+`;
+  }
+  async deleteAgent(name) {
+    const agent = this.agents.get(name);
+    if (!agent) {
+      logger.warn(`[AgentRegistry] Agent not found: ${name}`);
+      return false;
+    }
+    try {
+      const filePath = join(this.configDir, `${name}.yaml`);
+      if (existsSync(filePath)) {
+        await unlink(filePath);
+        logger.info(`[AgentRegistry] Deleted agent file: ${filePath}`);
+      }
+      this.agents.delete(name);
+      return true;
+    } catch (error) {
+      logger.error(`[AgentRegistry] Failed to delete agent: ${name}`, { error });
+      return false;
+    }
+  }
+  exportAgents(options = {}) {
+    const agents = this.list();
+    if (options.format === "json") {
+      return agents;
+    }
+    return agents;
+  }
+  exportAgentsAsJson() {
+    return JSON.stringify(this.list(), null, 2);
+  }
+  size() {
+    return this.agents.size;
+  }
+  configDirExists() {
+    return existsSync(this.configDir);
+  }
+  getAgentFilePath(name) {
+    return join(this.configDir, `${name}.yaml`);
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("agent.registry.register", { recordParams: true, recordResult: true, log: true })
+], AgentRegistry.prototype, "register", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.registry.unregister", { recordParams: true, recordResult: true, log: true })
+], AgentRegistry.prototype, "unregister", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.registry.clear", { recordParams: false, recordResult: true, log: true })
+], AgentRegistry.prototype, "clear", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.registry.getSystemPrompt", { recordParams: true, recordResult: true, log: true })
+], AgentRegistry.prototype, "getSystemPrompt", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.registry.load", { recordParams: false, recordResult: true, log: true })
+], AgentRegistry.prototype, "load", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.registry.loadFromDirectory", { recordParams: true, recordResult: true, log: true })
+], AgentRegistry.prototype, "loadFromDirectory", null);
+function isAgentConfigFile(fileName) {
+  return fileName.endsWith(".yaml") || fileName.endsWith(".yml");
+}
+var DEFAULT_SUBAGENT_PROMPT = `You are a subagent created by the main agent to handle a specific task.
+
+## Your Role
+- You were created to handle: {task_description}
+- Complete this task. That's your entire purpose.
+- You are NOT the main agent. Don't try to be.
+
+## Rules
+1. **Stay focused** - Do your assigned task, nothing else
+2. **Complete the task** - Your final message will be automatically reported to the main agent
+3. **Don't initiate** - No heartbeats, no proactive actions, no side quests
+4. **Be ephemeral** - You may be terminated after task completion. That's fine.
+5. **No nested delegation** - Do NOT use delegate_task or stop_task tools. Complete the task yourself.
+
+## Execution
+- Use the available tools to complete the task
+- If you need more information, ask the main agent through the result
+- Return a clear summary of what you did and the results`;
+
+export { AgentRegistry, DEFAULT_SUBAGENT_PROMPT };

package/dist/shared/@ai-setting/{roy-agent-core-frx4p6d1.js → roy-agent-core-nj8yerg9.js}

@@ -1048,6 +1048,14 @@ class ConfigComponent extends BaseComponent {
     }
     this.sourceUnwatchFns.clear();
   }
+  shutdown() {
+    this.unwatchAll();
+    this.persistQueue.clear();
+  }
+  async onStop() {
+    this.shutdown();
+    await super.onStop();
+  }
   getSources() {
     return [...this.sources];
   }

package/dist/shared/@ai-setting/{roy-agent-core-c8f2hync.js → roy-agent-core-r6rwsr54.js}

@@ -2,6 +2,9 @@ import {
   AskUserError,
   init_workflow_hil
 } from "./roy-agent-core-e25xkv53.js";
+import {
+  AgentRegistry
+} from "./roy-agent-core-fg3j215p.js";
 import {
   ContextError
 } from "./roy-agent-core-ctdhjv68.js";
@@ -166,6 +169,7 @@ class AgentComponent extends BaseComponent {
   configWatcher;
   messageConverter = new SessionMessageConverter;
   _constructorConfig;
+  registry;
   runCounter = 0;
   constructor(options = {}) {
     super();
@@ -185,6 +189,7 @@ class AgentComponent extends BaseComponent {
     }
     this.configComponent = options.configComponent;
     await this.registerConfig(options);
+    await this.initRegistry(options.configComponent);
     this.setStatus("running");
   }
   async registerConfig(options) {
@@ -271,6 +276,70 @@ class AgentComponent extends BaseComponent {
       newValue: event.newValue
     });
   }
+  async initRegistry(configComponent) {
+    try {
+      this.registry = new AgentRegistry({
+        configComponent,
+        resolvePromptComponent: () => this.env?.getComponent?.("prompt") ?? null
+      });
+      const loadedCount = await this.registry.load();
+      logger.info(`[AgentComponent] Loaded ${loadedCount} agents from config directory`);
+      for (const agentDef of this.registry.list()) {
+        if (!this.agents.has(agentDef.name)) {
+          const systemPrompt = await this.registry.getSystemPrompt(agentDef.name);
+          this.registerAgent(agentDef.name, {
+            type: agentDef.type,
+            systemPrompt,
+            systemPromptRef: agentDef.systemPromptRef,
+            allowedTools: agentDef.allowedTools,
+            deniedTools: agentDef.deniedTools,
+            model: agentDef.model,
+            maxIterations: agentDef.maxIterations
+          });
+          logger.debug(`[AgentComponent] Registered agent from config: ${agentDef.name}`);
+        }
+      }
+    } catch (error) {
+      logger.warn(`[AgentComponent] Failed to initialize AgentRegistry: ${error}`);
+    }
+  }
+  async syncRegistryAgentsFromConfig() {
+    if (!this.registry) {
+      return;
+    }
+    for (const agentDef of this.registry.list()) {
+      const systemPrompt = await this.registry.getSystemPrompt(agentDef.name);
+      const existing = this.agents.get(agentDef.name);
+      if (existing) {
+        if (systemPrompt !== undefined) {
+          existing.config.systemPrompt = systemPrompt;
+        }
+        if (agentDef.systemPromptRef) {
+          existing.config.systemPromptRef = agentDef.systemPromptRef;
+        }
+      } else {
+        this.registerAgent(agentDef.name, {
+          type: agentDef.type,
+          systemPrompt,
+          systemPromptRef: agentDef.systemPromptRef,
+          allowedTools: agentDef.allowedTools,
+          deniedTools: agentDef.deniedTools,
+          model: agentDef.model,
+          maxIterations: agentDef.maxIterations
+        });
+      }
+      logger.debug(`[AgentComponent] Synced registry agent: ${agentDef.name}`);
+    }
+  }
+  getRegistry() {
+    return this.registry;
+  }
+  getAgentFromRegistry(name) {
+    return this.registry?.get(name);
+  }
+  listAgentsFromRegistry() {
+    return this.registry?.list() ?? [];
+  }
   async onStop() {
     logger.info("[AgentComponent] Stopping and cleaning up resources...");
     for (const [name, agent] of this.agents) {
@@ -301,6 +370,27 @@ class AgentComponent extends BaseComponent {
       });
     }
   }
+  async resolveSystemPrompt(agent, agentName) {
+    if (agent.config.systemPrompt) {
+      return;
+    }
+    if (!agent.config.systemPromptRef) {
+      return;
+    }
+    if (!this.registry) {
+      logger.debug(`[resolveSystemPrompt] No registry available for ${agentName}`);
+      return;
+    }
+    try {
+      const resolvedPrompt = await this.registry.getSystemPrompt(agentName);
+      if (resolvedPrompt) {
+        agent.config.systemPrompt = resolvedPrompt;
+        logger.debug(`[AgentComponent] Resolved systemPrompt for agent: ${agentName}`);
+      }
+    } catch (error) {
+      logger.warn(`[AgentComponent] Failed to resolve systemPrompt for agent ${agentName}: ${error}`);
+    }
+  }
   getAgent(agentName) {
     return this.agents.get(agentName);
   }
@@ -331,7 +421,8 @@ class AgentComponent extends BaseComponent {
       doomLoopThreshold: config.doomLoopThreshold ?? this.config.defaultAgent.doomLoopThreshold,
       toolTimeout: config.toolTimeout ?? this.config.defaultAgent.toolTimeout,
       toolRetries: config.toolRetries ?? this.config.defaultAgent.toolRetries,
-      systemPrompt: config.systemPrompt ?? this.config.defaultAgent.systemPrompt,
+      systemPrompt: config.systemPrompt ?? (config.systemPromptRef ? undefined : this.config.defaultAgent.systemPrompt),
+      systemPromptRef: config.systemPromptRef,
       model: config.model ?? this.config.defaultAgent.model,
       behaviorSpecId: config.behaviorSpecId ?? this.config.defaultAgent.behaviorSpecId,
       allowedTools: config.allowedTools ?? this.config.defaultAgent.allowedTools,
@@ -433,6 +524,7 @@ class AgentComponent extends BaseComponent {
     if (!this.doomLoopCaches.has(runId)) {
       this.doomLoopCaches.set(runId, new Map);
     }
+    await this.resolveSystemPrompt(agent, agentName);
     const effectiveContext = {
       ...context,
       agentType: agent.config.type,
@@ -1138,6 +1230,15 @@ ${ctx.context.additionInfo}`
     return messages;
   }
 }
+__legacyDecorateClassTS([
+  TracedAs("agent.component.initRegistry", { recordParams: true, recordResult: true, log: true })
+], AgentComponent.prototype, "initRegistry", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.component.syncRegistryAgentsFromConfig", { recordParams: false, recordResult: true, log: true })
+], AgentComponent.prototype, "syncRegistryAgentsFromConfig", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.component.resolveSystemPrompt", { recordParams: true, recordResult: true, log: true })
+], AgentComponent.prototype, "resolveSystemPrompt", null);
 __legacyDecorateClassTS([
   TracedAs("agent.component.run", { recordParams: true, recordResult: true, log: true })
 ], AgentComponent.prototype, "_run", null);

package/dist/shared/@ai-setting/{roy-agent-core-ycg9rk6z.js → roy-agent-core-xkb264a8.js}

@@ -318,10 +318,25 @@ class McpLoader {
       return;
     try {
       await entry.client.close();
-      this.clients.delete(name);
-      logger2.info(`[McpLoader] Disconnected from ${name}`);
     } catch (error) {
-      logger2.warn(`[McpLoader] Error disconnecting from ${name}`, { error });
+      logger2.warn(`[McpLoader] Error closing client for ${name}`, { error });
+    }
+    await this.closeTransport(entry.transport, name);
+    this.clients.delete(name);
+    logger2.info(`[McpLoader] Disconnected from ${name}`);
+  }
+  async closeTransport(transport, name) {
+    try {
+      const transportAny = transport;
+      if (typeof transportAny.close === "function") {
+        await transportAny.close();
+      }
+      const child = transportAny._process ?? transportAny.process;
+      if (child?.pid && !child.killed) {
+        child.kill?.("SIGTERM");
+      }
+    } catch (error) {
+      logger2.warn(`[McpLoader] Error closing transport for ${name}`, { error });
     }
   }
   async disconnectAll() {