@ai-setting/roy-agent-core 1.7.72 → 1.7.76

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

@@ -0,0 +1,662 @@
+import {
+  createAutoTaskPlugin,
+  createLayaDecisionPlugin,
+  registerLayaCompletionTaskHook
+} from "./roy-agent-core-ghnagzrh.js";
+import {
+  TaskHookPoints
+} from "./roy-agent-core-1pg0fepg.js";
+import {
+  ContextError,
+  ErrorCodes
+} from "./roy-agent-core-ctdhjv68.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-pgvcf91v.js";
+import {
+  init_hook
+} from "./roy-agent-core-ax9e9szb.js";
+import {
+  init_context
+} from "./roy-agent-core-qqaak24r.js";
+import {
+  getEnvContext,
+  init_env_context,
+  runWithEnvContextAsync
+} from "./roy-agent-core-7cbpmk4q.js";
+import {
+  TracedAs,
+  envQueryParamFilter,
+  init_decorator,
+  init_trace_filters
+} from "./roy-agent-core-qq96p0tj.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-7f7t9wwp.js";
+import {
+  __legacyDecorateClassTS
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/environment.ts
+init_logger();
+
+// src/utils/id.ts
+function generateId(prefix = "id") {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 11);
+  return `${prefix}_${timestamp}_${random}`;
+}
+function generateDescendingId(prefix = "id") {
+  const timestamp = (Number.MAX_SAFE_INTEGER - Date.now()).toString(36);
+  const random = Math.random().toString(36).substring(2, 11);
+  return `${prefix}_${timestamp}_${random}`;
+}
+
+// src/env/environment.ts
+init_decorator();
+init_trace_filters();
+init_env_context();
+import * as fsSync from "fs";
+import * as path from "path";
+var logger = createLogger("environment");
+function registerLayaDecisionTaskHook(taskComponent, options) {
+  if (!taskComponent) {
+    logger.warn("[registerLayaDecisionTaskHook] TaskComponent not available — skip (fail-open)");
+    return false;
+  }
+  try {
+    const hook = createLayaDecisionPlugin(options);
+    taskComponent.unregisterHook(TaskHookPoints.BEFORE_CREATE, hook.name);
+    taskComponent.registerHook(TaskHookPoints.BEFORE_CREATE, {
+      name: hook.name,
+      priority: hook.priority,
+      execute: async (ctx) => {
+        try {
+          const data = ctx && typeof ctx === "object" && "data" in ctx ? ctx.data : ctx;
+          await hook.execute(data);
+        } catch (err) {
+          logger.warn(`[registerLayaDecisionTaskHook] hook execution failed (ignored): ${err?.message}`);
+        }
+      }
+    });
+    logger.info(`[registerLayaDecisionTaskHook] registered hook "${hook.name}" at ${TaskHookPoints.BEFORE_CREATE} (priority=${hook.priority})`);
+    return true;
+  } catch (err) {
+    logger.warn(`[registerLayaDecisionTaskHook] registration failed (ignored): ${err?.message}`);
+    return false;
+  }
+}
+var DEFAULT_AGENT_NAME = "Roy";
+function injectAgentNamePlaceholder(prompt, context) {
+  if (!prompt.includes("{{agent_name}}")) {
+    return prompt;
+  }
+  const metadata = context?.metadata;
+  const defaultAgentName = typeof metadata?.defaultAgentName === "string" && metadata.defaultAgentName.length > 0 ? metadata.defaultAgentName : DEFAULT_AGENT_NAME;
+  return prompt.replace(/\{\{agent_name\}\}/g, defaultAgentName);
+}
+
+class BaseEnvironment extends BaseComponent {
+  name;
+  version;
+  components = new Map;
+  constructor(config) {
+    super();
+    this.name = config?.name ?? "base-environment";
+    this.version = config?.version ?? "1.0.0";
+    this.registerDefaultComponents();
+  }
+  registerDefaultComponents() {}
+  getConfig() {
+    return {
+      name: this.name,
+      version: this.version,
+      enabled: true,
+      env: this
+    };
+  }
+  registerComponent(component) {
+    this.components.set(component.name, component);
+    logger.debug(`Component registered: ${component.name}`);
+  }
+  unregisterComponent(name) {
+    const component = this.components.get(name);
+    if (component) {
+      this.components.delete(name);
+      logger.debug(`Component unregistered: ${name}`);
+    }
+  }
+  getComponent(name) {
+    return this.components.get(name);
+  }
+  listComponents() {
+    return Array.from(this.components.values());
+  }
+  async handle_query(query, context) {
+    const agentComponent = this.getComponent("agent");
+    if (!agentComponent) {
+      throw new Error("AgentComponent not found. Please register AgentComponent before calling handle_query.");
+    }
+    const agentName = context?.agentType && context.agentType !== "default" ? context.agentType : "default";
+    const registry = agentComponent.getRegistry?.();
+    if (registry) {
+      const agentDef = registry.get(agentName);
+      if (agentDef?.type === "workflow") {
+        const existingCtx = getEnvContext();
+        const workflowEnvContext = {
+          envEvent: context || { type: "workflow" },
+          sourceId: "workflow",
+          userId: context?.metadata?.userId || "",
+          replyChannel: existingCtx?.replyChannel,
+          pluginEnabled: existingCtx?.pluginEnabled,
+          agentContext: existingCtx?.agentContext ?? {}
+        };
+        return await runWithEnvContextAsync(workflowEnvContext, async () => {
+          return await this.handleWorkflowAgentQuery(agentName, query, agentComponent, context);
+        });
+      }
+    }
+    let systemPrompt = "You are a helpful assistant.";
+    let promptSource = "fallback";
+    try {
+      const promptComponent = this.getComponent("prompt");
+      if (promptComponent) {
+        const loadedPrompt = await promptComponent.getPrompt("default", {}, {
+          agentType: "primary"
+        });
+        if (loadedPrompt) {
+          systemPrompt = loadedPrompt;
+          promptSource = "PromptComponent";
+        }
+      }
+    } catch (err) {
+      logger.warn(`[handle_query] Failed to get prompt from PromptComponent: ${err}`);
+    }
+    logger.info(`[handle_query] Using system prompt from ${promptSource}, length: ${systemPrompt.length}`);
+    let finalSystemPrompt = systemPrompt;
+    if (systemPrompt.includes("{{memory}}")) {
+      try {
+        const memoryComponent = this.getComponent("memory");
+        if (memoryComponent) {
+          const memoryContent = await memoryComponent.recallMemory();
+          finalSystemPrompt = systemPrompt.replace("{{memory}}", memoryContent || "(No memory)");
+          logger.info(`[handle_query] Injected memory content, length: ${memoryContent.length}`);
+        } else {
+          finalSystemPrompt = systemPrompt.replace("{{memory}}", "(Memory component not available)");
+        }
+      } catch (err) {
+        logger.warn(`[handle_query] Failed to load memory content: ${err}`);
+        finalSystemPrompt = systemPrompt.replace("{{memory}}", "(Failed to load memory)");
+      }
+    }
+    if (finalSystemPrompt.includes("{{workspace_dir}}")) {
+      const workspaceDir = process.cwd();
+      finalSystemPrompt = finalSystemPrompt.replace("{{workspace_dir}}", workspaceDir);
+      logger.debug(`[handle_query] Injected workspace_dir: ${workspaceDir}`);
+    }
+    {
+      const prev = finalSystemPrompt;
+      finalSystemPrompt = injectAgentNamePlaceholder(finalSystemPrompt, context);
+      if (prev !== finalSystemPrompt) {
+        const metadata = context?.metadata;
+        const injectedName = typeof metadata?.defaultAgentName === "string" && metadata.defaultAgentName.length > 0 ? metadata.defaultAgentName : DEFAULT_AGENT_NAME;
+        logger.debug(`[handle_query] Injected agent_name: ${injectedName}`);
+      }
+    }
+    let agent = agentComponent.getAgent(agentName);
+    if (!agent) {
+      if (agentName !== "default") {
+        logger.warn(`[handle_query] Agent "${agentName}" not found, falling back to "default"`);
+      }
+      agent = agentComponent.getAgent("default");
+    }
+    if (!agent) {
+      const defaultDeniedTools = [
+        "echo",
+        "glob",
+        "grep",
+        "write_file",
+        "edit_file",
+        "task_create",
+        "task_update",
+        "task_delete",
+        "task_operation_update",
+        "task_operation_delete",
+        "skill",
+        "record_memory",
+        "recall_memory",
+        "search_sessions",
+        "get_session",
+        "write_memory"
+      ];
+      try {
+        const toolComponent = this.getComponent("tool");
+        if (toolComponent?.listTools) {
+          const allTools = toolComponent.listTools();
+          const mcpTools = allTools.filter((t) => t.name.startsWith("mcp_")).map((t) => t.name);
+          if (mcpTools.length > 0) {
+            defaultDeniedTools.push(...mcpTools);
+            logger.debug(`[handle_query] Dynamically denied MCP tools: ${mcpTools.join(", ")}`);
+          }
+        }
+      } catch (err) {
+        logger.warn(`[handle_query] Failed to dynamically filter MCP tools: ${err}`);
+      }
+      agent = agentComponent.registerAgent("default", {
+        type: "primary",
+        systemPrompt: finalSystemPrompt,
+        deniedTools: defaultDeniedTools
+      });
+      logger.info(`[handle_query] Created default receptionist agent with deniedTools: ${defaultDeniedTools.length} tools denied`);
+      try {
+        const autoTaskPlugin = createAutoTaskPlugin({
+          threshold: 20
+        });
+        agentComponent.registerPlugin("default", autoTaskPlugin);
+        logger.info("[handle_query] AutoTaskPlugin v5.0 registered on default agent (threshold=20)");
+      } catch (err) {
+        logger.warn(`[handle_query] Failed to register AutoTaskPlugin: ${err}`);
+      }
+    } else {
+      if (agent.config?.systemPrompt) {
+        if (agent.config.systemPrompt.includes("{{memory}}")) {
+          try {
+            const memoryComponent = this.getComponent("memory");
+            if (memoryComponent) {
+              const memoryContent = await memoryComponent.recallMemory();
+              agent.config.systemPrompt = agent.config.systemPrompt.replace("{{memory}}", memoryContent || "(No memory)");
+            } else {
+              agent.config.systemPrompt = agent.config.systemPrompt.replace("{{memory}}", "(Memory component not available)");
+            }
+          } catch (err) {
+            logger.warn(`[handle_query] Failed to inject memory for agent ${agentName}: ${err}`);
+            agent.config.systemPrompt = agent.config.systemPrompt.replace("{{memory}}", "(Failed to load memory)");
+          }
+        }
+        if (agent.config.systemPrompt.includes("{{workspace_dir}}")) {
+          agent.config.systemPrompt = agent.config.systemPrompt.replace("{{workspace_dir}}", process.cwd());
+        }
+        agent.config.systemPrompt = injectAgentNamePlaceholder(agent.config.systemPrompt, context);
+      }
+      logger.debug(`[handle_query] Injected memory/workspace_dir for existing agent: ${agentName}`);
+    }
+    try {
+      const taskComponent = this.getComponent("task");
+      registerLayaDecisionTaskHook(taskComponent);
+    } catch (err) {
+      logger.warn(`[handle_query] Failed to register LayaDecisionTaskHook: ${err}`);
+    }
+    try {
+      const taskComponent = this.getComponent("task");
+      registerLayaCompletionTaskHook(taskComponent);
+    } catch (err) {
+      logger.warn(`[handle_query] Failed to register LayaCompletionTaskHook: ${err}`);
+    }
+    const result = await agentComponent.run(agent.name, query, context);
+    if (result.error) {
+      if (result.originalError instanceof ContextError) {
+        throw result.originalError;
+      }
+      if (result.error.includes("__ASK_USER_ERROR__:")) {
+        throw new Error(result.error);
+      }
+      const errorMsg = result.error.toLowerCase();
+      if (errorMsg.includes("context") || errorMsg.includes("threshold") || errorMsg.includes("token") || result.error.includes("CTX_001")) {
+        const usageMatch = result.error.match(/(\d+)\/(\d+)\s*\(([\d.]+)%\)/);
+        let usage;
+        let contextWindow;
+        if (usageMatch) {
+          const totalTokens = parseInt(usageMatch[1], 10);
+          usage = {
+            promptTokens: totalTokens,
+            completionTokens: 0,
+            totalTokens
+          };
+          contextWindow = parseInt(usageMatch[2], 10);
+        }
+        const ctxError = new ContextError(result.error, ErrorCodes.CONTEXT_THRESHOLD_EXCEEDED, context?.sessionId, usage, contextWindow);
+        throw ctxError;
+      }
+      throw new Error(result.error, result.originalError ? { cause: result.originalError } : undefined);
+    }
+    return result.finalText || "";
+  }
+  async handleWorkflowAgentQuery(agentName, query, agentComponent, context) {
+    const registry = agentComponent.getRegistry?.();
+    if (!registry) {
+      return null;
+    }
+    const agentDef = registry.get(agentName);
+    if (!agentDef || agentDef.type !== "workflow") {
+      return null;
+    }
+    const workflowComponent = this.getComponent("workflow");
+    if (!workflowComponent) {
+      throw new Error(`WorkflowComponent not available — cannot run workflow agent "${agentName}". ` + `Ensure the workflow component is registered.`);
+    }
+    const workflowName = agentDef.workflow;
+    if (!workflowName) {
+      throw new Error(`Agent "${agentName}" has type 'workflow' but no workflow configured.`);
+    }
+    const svc = workflowComponent.getService?.();
+    if (!svc || typeof svc.getWorkflowByName !== "function") {
+      throw new Error(`WorkflowService not available. Cannot run workflow agent "${agentName}".`);
+    }
+    const workflow = svc.getWorkflowByName(workflowName);
+    if (!workflow) {
+      throw new Error(`Workflow "${workflowName}" not found. ` + `Use 'roy-agent workflow add' to register it first.`);
+    }
+    const wfResult = await workflowComponent.runWorkflow(workflow.definition, { query }, { context });
+    if (wfResult.status === "paused") {
+      return JSON.stringify({
+        status: "paused",
+        message: `Workflow "${workflowName}" paused, waiting for user input.`,
+        pendingNodeId: wfResult.pendingNodeId,
+        query: wfResult.query,
+        sessionId: wfResult.sessionId,
+        hint: `Resume with: roy-agent workflow run -s ${wfResult.sessionId} --input "your response"`
+      });
+    }
+    if (wfResult.status === "failed") {
+      throw new Error(`Workflow "${workflowName}" execution failed: ${wfResult.error || "Unknown error (status: " + wfResult.status + ")"}`);
+    }
+    if (typeof wfResult.output === "string") {
+      return wfResult.output;
+    }
+    if (wfResult.output !== undefined && wfResult.output !== null) {
+      return JSON.stringify(wfResult.output);
+    }
+    if (wfResult.error) {
+      throw new Error(`Workflow "${workflowName}" completed with error: ${wfResult.error}`);
+    }
+    return "";
+  }
+  async handle_action(action, context) {
+    throw new Error("handle_action not implemented. Override in subclass.");
+  }
+  eventHandlers = new Map;
+  wildcardHandlers = new Set;
+  subscribe(handler) {
+    this.wildcardHandlers.add(handler);
+    logger.debug(`EnvEvent handler subscribed (wildcard)`);
+    return () => {
+      this.wildcardHandlers.delete(handler);
+      logger.debug(`EnvEvent handler unsubscribed (wildcard)`);
+    };
+  }
+  subscribeTo(eventType, handler) {
+    const types = Array.isArray(eventType) ? eventType : [eventType];
+    for (const type of types) {
+      if (!this.eventHandlers.has(type)) {
+        this.eventHandlers.set(type, new Set);
+      }
+      this.eventHandlers.get(type).add(handler);
+    }
+    logger.debug(`EnvEvent handler subscribed for types: ${types.join(", ")}`);
+    return () => {
+      for (const type of types) {
+        this.eventHandlers.get(type)?.delete(handler);
+      }
+      logger.debug(`EnvEvent handler unsubscribed for types: ${types.join(", ")}`);
+    };
+  }
+  subscribeAll(handler) {
+    return this.subscribe(handler);
+  }
+  pushEnvEvent(event) {
+    const fullEvent = "id" in event && event.id ? event : {
+      id: event.id ?? generateId(),
+      type: event.type,
+      timestamp: event.timestamp ?? Date.now(),
+      metadata: {
+        ...event.metadata,
+        env_name: event.metadata?.env_name ?? this.name
+      },
+      payload: event.payload ?? {}
+    };
+    for (const handler of this.wildcardHandlers) {
+      try {
+        handler(fullEvent);
+      } catch (error) {
+        logger.error(`Error in EnvEvent handler: ${error}`);
+      }
+    }
+    const handlers = this.eventHandlers.get(fullEvent.type);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(fullEvent);
+        } catch (error) {
+          logger.error(`Error in EnvEvent handler for ${fullEvent.type}: ${error}`);
+        }
+      }
+    }
+  }
+  emit(type, payload, metadata) {
+    const event = {
+      id: generateId(),
+      type,
+      timestamp: Date.now(),
+      metadata: {
+        env_name: this.name,
+        ...metadata
+      },
+      payload
+    };
+    this.pushEnvEvent(event);
+  }
+  async initializeComponents() {
+    logger.debug(`Starting component initialization, total: ${this.components.size}`);
+    const configComp = this.components.get("config");
+    if (configComp && configComp.getStatus() === "created") {
+      logger.debug(`Initializing ConfigComponent first...`);
+      await configComp.init({
+        name: "config",
+        version: configComp.version,
+        enabled: true,
+        env: this
+      });
+      logger.debug(`ConfigComponent initialized`);
+    } else {
+      logger.debug(`No ConfigComponent found, skipping first stage`);
+    }
+    const otherComponents = Array.from(this.components.values()).filter((c) => c.getStatus() === "created");
+    if (otherComponents.length > 0) {
+      logger.debug(`Initializing ${otherComponents.length} other components...`);
+      for (const component of otherComponents) {
+        logger.debug(`Initializing component: ${component.name}`);
+        await component.init({
+          name: component.name,
+          version: component.version,
+          enabled: true,
+          env: this
+        });
+        logger.debug(`Component initialized: ${component.name}`);
+      }
+    }
+    logger.debug(`All components initialized`);
+  }
+  async startComponents() {
+    const allComponents = Array.from(this.components.values());
+    if (allComponents.length > 0) {
+      logger.debug(`Starting ${allComponents.length} components...`);
+      for (const component of allComponents) {
+        logger.debug(`Starting component: ${component.name} (current status: ${component.getStatus()})`);
+        await component.start();
+        logger.debug(`Component started: ${component.name}`);
+      }
+    }
+  }
+  async stopComponents() {
+    const componentsToStop = Array.from(this.components.values()).filter((c) => c.getStatus() !== "stopped").reverse();
+    if (componentsToStop.length > 0) {
+      logger.debug(`Stopping ${componentsToStop.length} components...`);
+      for (const component of componentsToStop) {
+        logger.debug(`Stopping component: ${component.name}`);
+        await component.stop();
+        logger.debug(`Component stopped: ${component.name}`);
+      }
+    }
+  }
+  async onInit() {
+    await this.initializeComponents();
+    logger.info(`Environment "${this.name}" initialized`);
+  }
+  async onStart() {
+    await this.startComponents();
+    logger.info(`Environment "${this.name}" started`);
+  }
+  async onStop() {
+    await this.stopComponents();
+    this.eventHandlers.clear();
+    this.wildcardHandlers.clear();
+    logger.info(`Environment "${this.name}" stopped`);
+  }
+  async init() {
+    Object.defineProperty(this, "env", {
+      value: this,
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+    this.setStatus("initializing");
+    await this.onInit();
+    this.setStatus("running");
+  }
+  async start() {
+    if (this._started)
+      return;
+    this._started = true;
+    await this.onStart();
+    this.setStatus("running");
+    logger.info(`Environment "${this.name}" started`);
+  }
+  async stop() {
+    this.setStatus("stopping");
+    await this.onStop();
+    this.setStatus("stopped");
+  }
+  async loadServiceConfig(configPath) {
+    const configComponent = this.getComponent("config");
+    if (!configComponent) {
+      throw new Error("ConfigComponent not found. Please register ConfigComponent before loading service config.");
+    }
+    const xdgDataHome = configComponent.getXdgDataHome();
+    const fullPath = path.resolve(xdgDataHome, configPath);
+    if (!fsSync.existsSync(fullPath)) {
+      throw new Error(`Service config file not found: ${fullPath}`);
+    }
+    const content = fsSync.readFileSync(fullPath, "utf-8");
+    let config;
+    try {
+      config = JSON.parse(content);
+    } catch (e) {
+      throw new Error(`Failed to parse service config: ${e}`);
+    }
+    logger.debug(`Service config loaded from: ${fullPath}`);
+    return config;
+  }
+  generateComponentOptions(componentName, configEntry) {
+    const configComponent = this.getComponent("config");
+    if (!configComponent) {
+      throw new Error("ConfigComponent not found. Please register ConfigComponent before generating component options.");
+    }
+    const options = {
+      configComponent,
+      configPath: configEntry.configPath,
+      envPrefix: configEntry.envPrefix,
+      config: configEntry.config
+    };
+    logger.debug(`Generated options for component: ${componentName}`);
+    return options;
+  }
+  async registerComponentWithConfig(component, configEntry) {
+    if (!this.components.has(component.name)) {
+      this.registerComponent(component);
+    }
+    const options = this.generateComponentOptions(component.name, configEntry);
+    if (component.getStatus() === "running") {
+      logger.debug(`Component ${component.name} already initialized, skipping`);
+      return;
+    }
+    await component.init({
+      name: component.name,
+      version: component.version,
+      enabled: configEntry.enabled ?? true,
+      env: this,
+      options
+    });
+    logger.debug(`Component ${component.name} registered and initialized with config`);
+  }
+  async initFromConfig(configPath) {
+    if (!this.env) {
+      Object.defineProperty(this, "env", {
+        value: this,
+        writable: true,
+        enumerable: false,
+        configurable: true
+      });
+    }
+    const serviceConfig = await this.loadServiceConfig(configPath);
+    if (serviceConfig.environment) {
+      if (serviceConfig.environment.name) {
+        this.name = serviceConfig.environment.name;
+      }
+      if (serviceConfig.environment.version) {
+        this.version = serviceConfig.environment.version;
+      }
+    }
+    const configComponent = this.getComponent("config");
+    if (!configComponent) {
+      throw new Error("ConfigComponent not found. Please register ConfigComponent before initFromConfig.");
+    }
+    if (configComponent.getStatus() === "created") {
+      await configComponent.init({
+        name: "config",
+        version: configComponent.version,
+        enabled: true,
+        env: this
+      });
+    }
+    const components = serviceConfig.components || {};
+    for (const [componentName, configEntry] of Object.entries(components)) {
+      if (configEntry.enabled === false) {
+        logger.debug(`Component ${componentName} is disabled, skipping`);
+        continue;
+      }
+      const component = this.getComponent(componentName);
+      if (!component) {
+        logger.warn(`Component ${componentName} not registered, skipping`);
+        continue;
+      }
+      if (component.name === "config")
+        continue;
+      await this.registerComponentWithConfig(component, configEntry);
+    }
+    this.setStatus("running");
+    logger.info(`Environment "${this.name}" initialized from config: ${configPath}`);
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("env.handle_query", {
+    paramFilter: envQueryParamFilter,
+    recordResult: false,
+    logResult: true,
+    log: true
+  })
+], BaseEnvironment.prototype, "handle_query", null);
+__legacyDecorateClassTS([
+  TracedAs("env.handle_workflow_agent_query", {
+    paramFilter: envQueryParamFilter,
+    recordResult: false,
+    logResult: true,
+    log: true
+  })
+], BaseEnvironment.prototype, "handleWorkflowAgentQuery", null);
+
+// src/env/index.ts
+init_hook();
+init_context();
+
+export { generateId, generateDescendingId, BaseEnvironment };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-setting/roy-agent-core",
-  "version": "1.7.72",
+  "version": "1.7.76",
   "type": "module",
   "description": "Core SDK for roy-agent - Environment, Components, Tools, Sessions, Tasks",
   "main": "./dist/index.js",