@ai-setting/roy-agent-core 1.5.13-test → 1.5.15-test

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

@@ -1,176 +0,0 @@
-import {
-  __esm,
-  __require
-} from "./roy-agent-core-fs0mn2jk.js";
-
-// src/env/log-trace/span-storage.ts
-function getDatabaseClass() {
-  if (typeof Bun !== "undefined") {
-    const { Database } = __require("bun:sqlite");
-    return Database;
-  } else {
-    return __require("better-sqlite3");
-  }
-}
-function createCompatibleDatabase(path) {
-  const Database = getDatabaseClass();
-  const db = new Database(path);
-  if (typeof db.run !== "function") {
-    db.run = function(sql, ...params) {
-      if (params.length > 0) {
-        return this.prepare(sql).run(...params);
-      } else {
-        return this.exec(sql);
-      }
-    };
-  }
-  return db;
-}
-
-class SQLiteSpanStorage {
-  db = null;
-  dbPath;
-  initialized = false;
-  constructor(dbPath) {
-    if (!dbPath) {
-      throw new Error("SQLiteSpanStorage requires a valid dbPath parameter");
-    }
-    if (dbPath === ":memory:") {
-      throw new Error("SQLiteSpanStorage does not support :memory: mode. Use a file path instead.");
-    }
-    this.dbPath = dbPath;
-  }
-  async initialize() {
-    if (this.initialized)
-      return;
-    const fs = __require("fs");
-    const path = __require("path");
-    const dir = path.dirname(this.dbPath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    this.db = createCompatibleDatabase(this.dbPath);
-    this.db.run("PRAGMA journal_mode=WAL");
-    this.db.run("PRAGMA busy_timeout=5000");
-    this.db.run("PRAGMA synchronous=NORMAL");
-    this.db.run(`
-      CREATE TABLE IF NOT EXISTS span (
-        span_id TEXT PRIMARY KEY,
-        trace_id TEXT NOT NULL,
-        parent_span_id TEXT,
-        name TEXT NOT NULL,
-        kind TEXT NOT NULL,
-        status TEXT NOT NULL,
-        start_time INTEGER NOT NULL,
-        end_time INTEGER,
-        attributes TEXT,
-        result TEXT,
-        error TEXT,
-        time_created INTEGER NOT NULL
-      )
-    `);
-    this.db.run("CREATE INDEX IF NOT EXISTS idx_span_trace ON span(trace_id)");
-    this.db.run("CREATE INDEX IF NOT EXISTS idx_span_parent ON span(parent_span_id)");
-    this.initialized = true;
-  }
-  save(span) {
-    if (!this.db)
-      return;
-    const stmt = this.db.prepare(`
-      INSERT OR REPLACE INTO span 
-      (span_id, trace_id, parent_span_id, name, kind, status, start_time, end_time, attributes, result, error, time_created)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-    const resultValue = span.result !== undefined && span.result !== null ? typeof span.result === "string" ? span.result : JSON.stringify(span.result) : null;
-    stmt.run(span.spanId, span.traceId, span.parentSpanId || null, span.name, span.kind, span.status, span.startTime, span.endTime || null, JSON.stringify(span.attributes), resultValue, span.error || null, Date.now());
-  }
-  saveBatch(spans) {
-    for (const span of spans) {
-      this.save(span);
-    }
-  }
-  findByTraceId(traceId) {
-    if (!this.db)
-      return [];
-    const rows = this.db.prepare("SELECT * FROM span WHERE trace_id = ?").all(traceId);
-    return this.buildTree(rows.map(this.rowToSpan));
-  }
-  findBySpanId(spanId) {
-    if (!this.db)
-      return;
-    const row = this.db.prepare("SELECT * FROM span WHERE span_id = ?").get(spanId);
-    return row ? this.rowToSpan(row) : undefined;
-  }
-  listTraces(limit = 10) {
-    if (!this.db)
-      return [];
-    const rows = this.db.prepare(`
-      SELECT trace_id, 
-             MIN(start_time) as start_time,
-             MAX(end_time) as end_time,
-             COUNT(*) as span_count
-      FROM span 
-      GROUP BY trace_id 
-      ORDER BY start_time DESC 
-      LIMIT ?
-    `).all(limit);
-    return rows.map((row) => ({
-      traceId: row.trace_id,
-      rootSpanName: "unknown",
-      startTime: row.start_time,
-      endTime: row.end_time,
-      duration: row.end_time - row.start_time,
-      spanCount: row.span_count,
-      status: "ok"
-    }));
-  }
-  deleteByTraceId(traceId) {
-    if (this.db) {
-      this.db.prepare("DELETE FROM span WHERE trace_id = ?").run(traceId);
-    }
-  }
-  close() {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-    }
-  }
-  rowToSpan(row) {
-    return {
-      traceId: row.trace_id,
-      spanId: row.span_id,
-      parentSpanId: row.parent_span_id,
-      name: row.name,
-      kind: row.kind,
-      status: row.status,
-      startTime: row.start_time,
-      endTime: row.end_time,
-      attributes: row.attributes ? JSON.parse(row.attributes) : {},
-      result: row.result || undefined,
-      error: row.error || undefined
-    };
-  }
-  buildTree(spans) {
-    const spanMap = new Map;
-    const roots = [];
-    for (const span of spans) {
-      spanMap.set(span.spanId, { ...span, children: [] });
-    }
-    for (const span of spanMap.values()) {
-      if (span.parentSpanId) {
-        const parent = spanMap.get(span.parentSpanId);
-        if (parent) {
-          parent.children.push(span);
-        } else {
-          roots.push(span);
-        }
-      } else {
-        roots.push(span);
-      }
-    }
-    return roots;
-  }
-}
-var init_span_storage = () => {};
-
-export { SQLiteSpanStorage, init_span_storage };

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

@@ -1,60 +0,0 @@
-// src/env/skill/types.ts
-import { z } from "zod";
-var SkillToolSchema = z.object({
-  skill: z.string().describe("Skill name to load")
-});
-
-// src/env/skill/tool/skill-tool.ts
-function buildSkillDescription(items) {
-  const lines = [
-    "Load a skill by name. Available skills:",
-    "",
-    "## Available Skills",
-    ""
-  ];
-  if (items.length === 0) {
-    lines.push("No skills available.");
-  } else {
-    for (const item of items) {
-      lines.push(`- **${item.name}**: "${item.description}"`);
-    }
-  }
-  lines.push("");
-  lines.push("Use the 'skill' parameter to specify which skill to load.");
-  return lines.join(`
-`);
-}
-function createSkillTool(getSkillList, getSkill) {
-  return {
-    name: "skill",
-    description: buildSkillDescription(getSkillList()),
-    parameters: SkillToolSchema,
-    execute: async (args, ctx) => {
-      const params = SkillToolSchema.parse(args);
-      try {
-        const entry = getSkill(params.skill);
-        if (!entry) {
-          return {
-            success: false,
-            output: "",
-            error: `Skill not found: ${params.skill}`,
-            metadata: { execution_time_ms: 0 }
-          };
-        }
-        return {
-          success: true,
-          output: entry.content,
-          metadata: { execution_time_ms: 0 }
-        };
-      } catch (error) {
-        return {
-          success: false,
-          output: "",
-          error: error instanceof Error ? error.message : String(error),
-          metadata: { execution_time_ms: 0 }
-        };
-      }
-    }
-  };
-}
-export { SkillToolSchema, buildSkillDescription, createSkillTool };

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

@@ -1,442 +0,0 @@
-import {
-  AskUserError,
-  init_workflow_hil
-} from "./roy-agent-core-e25xkv53.js";
-import {
-  envKeyToConfigKey,
-  toEnvKey
-} from "./roy-agent-core-qxhq8ven.js";
-import {
-  BaseComponent
-} from "./roy-agent-core-kkbwepqb.js";
-import {
-  ToolHookPoints,
-  globalHookManager
-} from "./roy-agent-core-gjq1yk68.js";
-import {
-  createLogger,
-  init_logger
-} from "./roy-agent-core-44hnfb02.js";
-import {
-  __require
-} from "./roy-agent-core-fs0mn2jk.js";
-// src/env/tool/tool-component.ts
-import { z } from "zod";
-
-// 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);
-  }
-}
-
-// 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("; ");
-  }
-}
-
-// src/env/tool/tool-component.ts
-init_logger();
-
-// 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"] }
-  ]
-};
-
-// 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("../../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 };