@ai-setting/roy-agent-core 1.4.13 → 1.4.14

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

@@ -0,0 +1,442 @@
+import {
+  AskUserError,
+  init_workflow_hil
+} from "./roy-agent-core-8dvbn7tw.js";
+import {
+  envKeyToConfigKey,
+  toEnvKey
+} from "./roy-agent-core-jv3b7v9w.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-m2x48hw6.js";
+import {
+  ToolHookPoints,
+  globalHookManager
+} from "./roy-agent-core-w75rafhy.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-yn761yve.js";
+import {
+  __require
+} from "./roy-agent-core-fs0mn2jk.js";
+// packages/core/src/env/tool/tool-component.ts
+import { z } from "zod";
+
+// packages/core/src/env/tool/registry.ts
+class ToolRegistry {
+  tools = new Map;
+  register(tool, registration) {
+    this.tools.set(tool.name, registration);
+  }
+  unregister(name) {
+    return this.tools.delete(name);
+  }
+  getTool(name) {
+    return this.tools.get(name);
+  }
+  getAllTools() {
+    return Array.from(this.tools.values());
+  }
+  listTools(filter) {
+    let tools = this.getAllTools();
+    if (!filter) {
+      return tools.map((r) => r.tool);
+    }
+    if (filter.name) {
+      const names = Array.isArray(filter.name) ? filter.name : [filter.name];
+      tools = tools.filter((r) => names.some((pattern) => this.matchGlob(r.tool.name, pattern)));
+    }
+    if (filter.category) {
+      tools = tools.filter((r) => r.tool.metadata?.category === filter.category);
+    }
+    if (filter.tags && filter.tags.length > 0) {
+      tools = tools.filter((r) => filter.tags.some((tag) => r.tool.metadata?.tags?.includes(tag)));
+    }
+    if (filter.source) {
+      tools = tools.filter((r) => r.source === filter.source);
+    }
+    if (filter.enabledOnly) {
+      tools = tools.filter((r) => r.enabled);
+    }
+    if (filter.exclude && filter.exclude.length > 0) {
+      tools = tools.filter((r) => !filter.exclude.includes(r.tool.name));
+    }
+    return tools.map((r) => r.tool);
+  }
+  has(name) {
+    return this.tools.has(name);
+  }
+  getCount() {
+    return this.tools.size;
+  }
+  enable(name) {
+    const reg = this.tools.get(name);
+    if (reg) {
+      reg.enabled = true;
+      return true;
+    }
+    return false;
+  }
+  disable(name) {
+    const reg = this.tools.get(name);
+    if (reg) {
+      reg.enabled = false;
+      return true;
+    }
+    return false;
+  }
+  clear() {
+    this.tools.clear();
+  }
+  snapshot() {
+    return this.getAllTools();
+  }
+  restore(snapshot) {
+    this.clear();
+    for (const reg of snapshot) {
+      this.tools.set(reg.tool.name, reg);
+    }
+  }
+  matchGlob(str, pattern) {
+    if (pattern === "*")
+      return true;
+    if (!pattern.includes("*"))
+      return str === pattern;
+    const regexPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    return new RegExp(`^${regexPattern}$`).test(str);
+  }
+}
+
+// packages/core/src/env/tool/validator.ts
+import { ZodError } from "zod";
+
+class ToolValidator {
+  async validate(tool, args) {
+    try {
+      const parsed = await tool.parameters.parseAsync(args);
+      return {
+        success: true,
+        data: parsed
+      };
+    } catch (error) {
+      if (error instanceof ZodError) {
+        const errorMessage = tool.formatValidationError ? tool.formatValidationError(error) : this.formatError(error);
+        return {
+          success: false,
+          error: `Invalid arguments for tool '${tool.name}': ${errorMessage}`
+        };
+      }
+      return {
+        success: false,
+        error: `Validation error: ${error}`
+      };
+    }
+  }
+  formatError(error) {
+    return error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ");
+  }
+}
+
+// packages/core/src/env/tool/tool-component.ts
+init_logger();
+
+// packages/core/src/env/tool/tool-config-registration.ts
+var TOOL_DEFAULTS = {
+  "tool.toolsDir": ".roy/tools",
+  "tool.builtInTools.enabled": true,
+  "tool.builtInTools.loadAll": true,
+  "tool.sandbox.enabled": false,
+  "tool.sandbox.type": "native",
+  "tool.execution.timeout": 30000,
+  "tool.execution.maxConcurrency": 5
+};
+var TOOL_CONFIG_REGISTRATION = {
+  name: "tool",
+  sources: [
+    { type: "env", envPrefix: "TOOL", priority: 20, watch: false }
+  ],
+  keys: [
+    { key: "tool.toolsDir", sources: ["env", "file"] },
+    { key: "tool.builtInTools.enabled", sources: ["env", "file"] },
+    { key: "tool.builtInTools.loadAll", sources: ["env", "file"] },
+    { key: "tool.sandbox.enabled", sources: ["env", "file"] },
+    { key: "tool.sandbox.type", sources: ["env", "file"] },
+    { key: "tool.execution.timeout", sources: ["env", "file"] },
+    { key: "tool.execution.maxConcurrency", sources: ["env", "file"] }
+  ]
+};
+
+// packages/core/src/env/tool/tool-component.ts
+init_workflow_hil();
+var logger = createLogger("tool");
+
+class ToolComponent extends BaseComponent {
+  name = "tool";
+  version = "1.0.0";
+  registry;
+  validator;
+  config;
+  configComponent;
+  configWatcher;
+  constructor() {
+    super();
+    this.registry = new ToolRegistry;
+    this.validator = new ToolValidator;
+  }
+  async init(config) {
+    await super.init(config);
+    const options = config?.options;
+    if (!options?.configComponent) {
+      throw new Error("ConfigComponent is required for ToolComponent initialization");
+    }
+    this.configComponent = options.configComponent;
+    await this.registerConfig(options);
+    if (this.config?.builtInTools?.enabled !== false) {
+      await this.loadBuiltInTools();
+    }
+    logger.info(`ToolComponent initialized with ${this.getToolCount()} tools`);
+  }
+  async registerConfig(options) {
+    const configComponent = options.configComponent;
+    if (!configComponent)
+      return;
+    const { configPath, envPrefix, config } = options;
+    const prefix = envPrefix !== undefined ? envPrefix : "TOOL";
+    configComponent.registerComponent(TOOL_CONFIG_REGISTRATION);
+    if (configPath) {
+      configComponent.registerSource({
+        type: "file",
+        relativePath: configPath,
+        optional: true,
+        watch: false
+      });
+    }
+    await configComponent.load("tool");
+    const toolKeys = [
+      "tool.toolsDir",
+      "tool.builtInTools.enabled",
+      "tool.builtInTools.loadAll",
+      "tool.builtInTools.names",
+      "tool.sandbox.enabled",
+      "tool.sandbox.type",
+      "tool.sandbox.defaultConfig",
+      "tool.execution.timeout",
+      "tool.execution.maxConcurrency"
+    ];
+    for (const key of toolKeys) {
+      const envKey = toEnvKey(key, prefix);
+      const value = process.env[envKey];
+      if (value !== undefined) {
+        await configComponent.set(key, value);
+      }
+    }
+    const envPrefixUpper = prefix.toUpperCase();
+    for (const envKey of Object.keys(process.env)) {
+      if (!envKey.startsWith(envPrefixUpper + "_"))
+        continue;
+      const configKey = envKeyToConfigKey(envKey, prefix, "tool");
+      if (configKey && !toolKeys.includes(configKey)) {
+        const value = process.env[envKey];
+        if (value !== undefined) {
+          await configComponent.set(configKey, value);
+        }
+      }
+    }
+    for (const [key, value] of Object.entries(TOOL_DEFAULTS)) {
+      if (configComponent.get(key) === undefined) {
+        await configComponent.set(key, value);
+      }
+    }
+    if (config) {
+      const flatConfig = this.flattenConfig(config);
+      for (const [key, value] of Object.entries(flatConfig)) {
+        await configComponent.set(key, value);
+      }
+    }
+    this.registerConfigWatcher(configComponent);
+    const configData = {};
+    for (const key of toolKeys) {
+      const value = configComponent.get(key);
+      if (value !== undefined) {
+        configData[key.replace(/^tool\./, "")] = value;
+      }
+    }
+    if (config) {
+      Object.assign(configData, config);
+    }
+    const parsed = ToolComponentConfigSchema.safeParse(configData);
+    if (parsed.success) {
+      this.config = parsed.data;
+    } else {
+      this.config = config || {};
+    }
+  }
+  flattenConfig(obj, prefix = "tool") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const fullKey = `${prefix}.${key}`;
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        Object.assign(result, this.flattenConfig(value, fullKey));
+      } else {
+        result[fullKey] = value;
+      }
+    }
+    return result;
+  }
+  registerConfigWatcher(configComponent) {
+    if (typeof configComponent.watch !== "function") {
+      return;
+    }
+    this.configWatcher = configComponent.watch("tool.*", (event) => {
+      this.onConfigChange(event);
+    });
+  }
+  onConfigChange(event) {
+    logger.info(`Tool config changed: ${event.key}`, {
+      oldValue: event.oldValue,
+      newValue: event.newValue
+    });
+  }
+  async onStop() {
+    this.configWatcher?.();
+    this.configWatcher = undefined;
+    this.setStatus("stopped");
+  }
+  register(tool, source = "dynamic") {
+    globalHookManager.execute(ToolHookPoints.BEFORE_REGISTER, { tool });
+    this.registry.register(tool, {
+      tool,
+      registeredAt: Date.now(),
+      source,
+      enabled: true
+    });
+    logger.debug(`Registered tool: ${tool.name}`);
+    globalHookManager.execute(ToolHookPoints.AFTER_REGISTER, { tool });
+  }
+  registerMany(tools, source = "dynamic") {
+    for (const tool of tools) {
+      this.register(tool, source);
+    }
+  }
+  unregister(name) {
+    return this.registry.unregister(name);
+  }
+  getTool(name) {
+    return this.registry.getTool(name)?.tool;
+  }
+  listTools(filter) {
+    return this.registry.listTools(filter);
+  }
+  getToolCount() {
+    return this.registry.getCount();
+  }
+  hasTool(name) {
+    return this.registry.has(name);
+  }
+  getToolsByCategory(category) {
+    return this.listTools({ category });
+  }
+  async execute(request) {
+    const { name, args, context, skipHooks } = request;
+    const registration = this.registry.getTool(name);
+    if (!registration) {
+      return {
+        success: false,
+        output: "",
+        error: `Tool not found: ${name}`
+      };
+    }
+    if (!registration.enabled) {
+      return {
+        success: false,
+        output: "",
+        error: `Tool disabled: ${name}`
+      };
+    }
+    const tool = registration.tool;
+    if (!skipHooks) {
+      await globalHookManager.execute(ToolHookPoints.BEFORE_EXECUTE, { tool, args, context }, { toolName: tool.name });
+    }
+    const startTime = Date.now();
+    try {
+      const validationResult = await this.validator.validate(tool, args);
+      if (!validationResult.success) {
+        return {
+          success: false,
+          output: "",
+          error: validationResult.error,
+          metadata: {
+            execution_time_ms: Date.now() - startTime
+          }
+        };
+      }
+      const result = await tool.execute(validationResult.data, context);
+      if (!result.metadata) {
+        result.metadata = { execution_time_ms: Date.now() - startTime };
+      } else {
+        result.metadata.execution_time_ms = Date.now() - startTime;
+      }
+      if (!skipHooks) {
+        await globalHookManager.execute(ToolHookPoints.AFTER_EXECUTE, { tool, args, context, result }, { toolName: tool.name });
+      }
+      return result;
+    } catch (error) {
+      if (error instanceof AskUserError) {
+        throw error;
+      }
+      const errorResult = {
+        success: false,
+        output: "",
+        error: error instanceof Error ? error.message : String(error),
+        metadata: {
+          execution_time_ms: Date.now() - startTime
+        }
+      };
+      if (!skipHooks) {
+        await globalHookManager.execute(ToolHookPoints.AFTER_EXECUTE, { tool, args, context, result: errorResult }, { toolName: tool.name });
+      }
+      if (!skipHooks) {
+        await globalHookManager.execute(ToolHookPoints.ON_ERROR, { tool, args, context, error }, { toolName: tool.name });
+      }
+      return errorResult;
+    }
+  }
+  async loadBuiltInTools() {
+    try {
+      const { getAllBuiltInTools } = await import("../../packages/core/src/env/tool/built-in/index.js");
+      const tools = getAllBuiltInTools();
+      this.registerMany(tools, "built-in");
+      logger.info(`Loaded ${tools.length} built-in tools`);
+    } catch (err) {
+      logger.warn(`Failed to load built-in tools: ${err.message}`);
+    }
+  }
+  getHookPoints() {
+    return [
+      ToolHookPoints.BEFORE_EXECUTE,
+      ToolHookPoints.AFTER_EXECUTE,
+      ToolHookPoints.BEFORE_REGISTER,
+      ToolHookPoints.AFTER_REGISTER,
+      ToolHookPoints.ON_ERROR
+    ];
+  }
+}
+var ToolComponentConfigSchema = z.object({
+  toolsDir: z.string().optional(),
+  builtInTools: z.object({
+    enabled: z.boolean().default(true),
+    loadAll: z.boolean().default(true),
+    names: z.array(z.string()).optional()
+  }).default({}),
+  sandbox: z.object({
+    enabled: z.boolean().default(false),
+    type: z.enum(["native", "docker"]).default("native"),
+    defaultConfig: z.record(z.unknown()).optional()
+  }).default({}),
+  execution: z.object({
+    timeout: z.number().int().positive().default(60000),
+    maxConcurrency: z.number().int().positive().default(4)
+  }).default({})
+});
+export { ToolRegistry, ToolValidator, ToolComponent };

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

@@ -0,0 +1,57 @@
+// packages/core/src/config/env-key.ts
+function toEnvKey(key, prefix) {
+  let keyNormalized = key.replace(/[.-]/g, "_");
+  keyNormalized = keyNormalized.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/_+/g, "_").toUpperCase();
+  if (prefix) {
+    const separator = prefix.endsWith("_") ? "" : "_";
+    return `${prefix}${separator}${keyNormalized}`;
+  }
+  return keyNormalized;
+}
+function fromEnvKey(envKey, prefix) {
+  if (!prefix) {
+    return envKey;
+  }
+  if (envKey.startsWith(prefix)) {
+    const afterPrefix = envKey.slice(prefix.length);
+    if (afterPrefix.startsWith("_")) {
+      return afterPrefix.slice(1);
+    }
+    return afterPrefix;
+  }
+  return envKey;
+}
+function envKeyToConfigKey(envKey, prefix, componentName) {
+  const prefixUpper = prefix.toUpperCase();
+  if (!envKey.startsWith(prefixUpper)) {
+    return;
+  }
+  const componentUpperNormalized = componentName.replace(/-/g, "_").toUpperCase();
+  let keyPart = envKey.slice(prefixUpper.length);
+  if (keyPart.startsWith("_")) {
+    keyPart = keyPart.slice(1);
+  }
+  if (!keyPart) {
+    return;
+  }
+  const firstUnderscore = keyPart.indexOf("_");
+  let restPart;
+  if (firstUnderscore === -1) {
+    restPart = keyPart;
+  } else {
+    const firstPart = keyPart.slice(0, firstUnderscore);
+    const remaining = keyPart.slice(firstUnderscore + 1);
+    if (firstPart === componentUpperNormalized) {
+      restPart = remaining;
+    } else {
+      restPart = keyPart;
+    }
+  }
+  if (!restPart) {
+    return;
+  }
+  const restPartConverted = restPart.replace(/_/g, ".");
+  return `${componentName}.${restPartConverted.toLowerCase()}`;
+}
+
+export { toEnvKey, fromEnvKey, envKeyToConfigKey };