@ai-setting/roy-agent-core 1.7.66 → 1.7.68

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

@@ -1,654 +0,0 @@
-import {
-  createAutoTaskPlugin,
-  createLayaDecisionPlugin
-} from "./roy-agent-core-v8bz7d8x.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_complete",
-        "task_operation_create",
-        "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}`);
-    }
-    const result = await agentComponent.run(agent.name, query, context);
-    if (result.error) {
-      if (result.originalError instanceof ContextError) {
-        throw result.originalError;
-      }
-      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");
-    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 };