@ai-setting/roy-agent-core 1.4.11 → 1.4.12

package/dist/env/tool/index.js

@@ -0,0 +1,2284 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// packages/core/src/env/log-trace/opentelemetry/propagation.ts
+function padLeft(str, length) {
+  return str.padStart(length, "0");
+}
+function isValidHex(str) {
+  return /^[0-9a-f]+$/i.test(str);
+}
+function serialize(context) {
+  const traceId = padLeft(context.traceId.toLowerCase(), TRACE_ID_LENGTH);
+  const spanId = padLeft(context.spanId.toLowerCase(), PARENT_SPAN_ID_LENGTH);
+  const parts = [
+    TRACE_CONTEXT_VERSION,
+    traceId,
+    spanId,
+    TRACE_FLAGS_SAMPLED
+  ];
+  return parts.join("-");
+}
+function parse(traceparent) {
+  if (!traceparent || typeof traceparent !== "string") {
+    return;
+  }
+  const trimmed = traceparent.trim();
+  const parts = trimmed.split("-");
+  if (parts.length !== 4) {
+    return;
+  }
+  const [version, traceId, senderSpanId, flags] = parts;
+  if (version !== TRACE_CONTEXT_VERSION) {
+    if (version > TRACE_CONTEXT_VERSION) {
+      return;
+    }
+  }
+  if (traceId.length !== TRACE_ID_LENGTH || !isValidHex(traceId)) {
+    return;
+  }
+  if (senderSpanId.length !== PARENT_SPAN_ID_LENGTH || !isValidHex(senderSpanId)) {
+    return;
+  }
+  if (flags.length !== FLAGS_LENGTH || !isValidHex(flags)) {
+    return;
+  }
+  return {
+    traceId: traceId.toLowerCase(),
+    spanId: senderSpanId.toLowerCase()
+  };
+}
+var TRACE_CONTEXT_VERSION = "00", TRACE_FLAGS_SAMPLED = "01", TRACEPARENT_HEADER = "TRACEPARENT", TRACE_ID_LENGTH = 32, PARENT_SPAN_ID_LENGTH = 16, FLAGS_LENGTH = 2, propagation;
+var init_propagation = __esm(() => {
+  propagation = {
+    inject(carrier, context) {
+      carrier[TRACEPARENT_HEADER] = serialize(context);
+    },
+    extract(carrier) {
+      const traceparent = carrier[TRACEPARENT_HEADER];
+      if (!traceparent) {
+        return;
+      }
+      return parse(traceparent);
+    },
+    getTraceparentHeader() {
+      return TRACEPARENT_HEADER;
+    }
+  };
+});
+
+// packages/core/src/env/log-trace/span-storage.ts
+var exports_span_storage = {};
+__export(exports_span_storage, {
+  SQLiteSpanStorage: () => SQLiteSpanStorage
+});
+
+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 { Database } = __require("bun:sqlite");
+    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 = new Database(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;
+  }
+}
+
+// packages/core/src/env/log-trace/types.ts
+var SpanKind, SpanStatus;
+var init_types = __esm(() => {
+  ((SpanKind2) => {
+    SpanKind2["CLIENT"] = "client";
+    SpanKind2["SERVER"] = "server";
+    SpanKind2["INTERNAL"] = "internal";
+  })(SpanKind ||= {});
+  ((SpanStatus2) => {
+    SpanStatus2["OK"] = "ok";
+    SpanStatus2["ERROR"] = "error";
+  })(SpanStatus ||= {});
+});
+
+// packages/core/src/env/log-trace/opentelemetry/tracer-provider.ts
+var exports_tracer_provider = {};
+__export(exports_tracer_provider, {
+  resetTracerProvider: () => resetTracerProvider,
+  getTracerProvider: () => getTracerProvider,
+  OTelTracerProvider: () => OTelTracerProvider
+});
+
+class OTelSpanImpl {
+  name;
+  kind;
+  spanContext;
+  attributes = {};
+  startTime;
+  endTime;
+  error;
+  storage;
+  parentSpanContext;
+  onEnd;
+  constructor(name, spanContext, storage, parentSpanContext, onEnd) {
+    this.name = name;
+    this.kind = "internal";
+    this.spanContext = spanContext;
+    this.parentSpanContext = parentSpanContext;
+    this.startTime = Date.now();
+    this.storage = storage;
+    this.onEnd = onEnd;
+  }
+  setAttribute(key, value) {
+    this.attributes[key] = value;
+  }
+  addEvent(name, attributes) {
+    const events = this.attributes._events || [];
+    events.push({ name, attributes });
+    this.attributes._events = events;
+  }
+  end(result, error) {
+    this.endTime = Date.now();
+    if (error) {
+      this.error = error.message;
+    }
+    this.storage.save({
+      traceId: this.spanContext.traceId,
+      spanId: this.spanContext.spanId,
+      parentSpanId: this.spanContext.parentSpanId,
+      name: this.name,
+      kind: this.kind,
+      status: error ? "error" /* ERROR */ : "ok" /* OK */,
+      startTime: this.startTime,
+      endTime: this.endTime,
+      attributes: this.attributes,
+      result,
+      error: this.error
+    });
+    this.onEnd?.();
+  }
+}
+
+class OTelTracerImpl {
+  name;
+  version;
+  storage;
+  currentContext;
+  activeSpans = new Map;
+  onSpanEndCallback;
+  provider;
+  constructor(name, version, storage, provider) {
+    this.name = name;
+    this.version = version;
+    this.storage = storage;
+    this.provider = provider;
+  }
+  setOnSpanEndCallback(callback) {
+    this.onSpanEndCallback = callback;
+  }
+  getActiveSpanCount() {
+    return this.activeSpans.size;
+  }
+  startSpan(name, options) {
+    const parentFromOptions = options?.parent;
+    const hasExplicitParent = options && "parent" in options;
+    const globalContext = this.provider.getGlobalContext();
+    let effectiveParentContext;
+    if (hasExplicitParent) {
+      effectiveParentContext = parentFromOptions;
+    } else if (this.currentContext) {
+      effectiveParentContext = this.currentContext;
+    } else if (globalContext) {
+      effectiveParentContext = globalContext;
+    }
+    const traceId = effectiveParentContext?.traceId || this.generateTraceId();
+    const spanId = this.generateSpanId();
+    let parentSpanId;
+    if (hasExplicitParent && parentFromOptions) {
+      parentSpanId = parentFromOptions.parentSpanId || parentFromOptions.spanId;
+    } else if (this.currentContext) {
+      parentSpanId = this.currentContext.spanId;
+    } else if (globalContext) {
+      parentSpanId = globalContext.spanId;
+    }
+    const spanContext = {
+      traceId,
+      spanId,
+      parentSpanId
+    };
+    this.currentContext = {
+      traceId,
+      spanId,
+      parentSpanId
+    };
+    const span = new OTelSpanImpl(name, spanContext, this.storage, effectiveParentContext, () => this.handleSpanEnd(spanContext.spanId, effectiveParentContext?.spanId));
+    if (options?.attributes) {
+      for (const [key, value] of Object.entries(options.attributes)) {
+        span.setAttribute(key, value);
+      }
+    }
+    this.activeSpans.set(spanId, span);
+    return span;
+  }
+  injectToEnv(env) {
+    if (this.currentContext) {
+      propagation.inject(env, this.currentContext);
+    }
+  }
+  getCurrentContext() {
+    return this.currentContext;
+  }
+  setCurrentContext(context) {
+    this.currentContext = context;
+  }
+  endSpan(span) {
+    const spanContext = span.spanContext;
+    this.activeSpans.delete(spanContext.spanId);
+    const currentTraceId = this.currentContext?.traceId;
+    if (spanContext.parentSpanId) {
+      const parentSpan = this.activeSpans.get(spanContext.parentSpanId);
+      if (parentSpan) {
+        const parentContext = {
+          traceId: spanContext.traceId,
+          spanId: parentSpan.spanContext.spanId,
+          parentSpanId: parentSpan.spanContext.parentSpanId
+        };
+        this.currentContext = parentContext;
+        return parentContext;
+      }
+      if (currentTraceId) {
+        const parentContext = {
+          traceId: currentTraceId,
+          spanId: spanContext.parentSpanId,
+          parentSpanId: undefined
+        };
+        this.currentContext = parentContext;
+        return parentContext;
+      }
+    }
+    this.currentContext = undefined;
+    return;
+  }
+  generateTraceId() {
+    const timestamp = Date.now().toString(16).padStart(12, "0");
+    const random = Array.from({ length: 5 }, () => Math.floor(Math.random() * 4294967295).toString(16).padStart(8, "0")).join("");
+    return (timestamp + random).slice(0, 32).padStart(32, "0");
+  }
+  generateSpanId() {
+    return Math.floor(Math.random() * 18446744073709552000).toString(16).padStart(16, "0");
+  }
+  handleSpanEnd(spanId, parentSpanId) {
+    this.activeSpans.delete(spanId);
+    const currentTraceId = this.currentContext?.traceId;
+    if (parentSpanId) {
+      const parentSpan = this.activeSpans.get(parentSpanId);
+      if (parentSpan) {
+        this.currentContext = {
+          traceId: parentSpan.spanContext.traceId,
+          spanId: parentSpan.spanContext.spanId,
+          parentSpanId: parentSpan.spanContext.parentSpanId
+        };
+        return;
+      }
+      if (currentTraceId) {
+        this.currentContext = {
+          traceId: currentTraceId,
+          spanId: parentSpanId,
+          parentSpanId: undefined
+        };
+        return;
+      }
+    }
+    this.currentContext = undefined;
+  }
+}
+
+class OTelTracerProvider {
+  tracers = new Map;
+  storage;
+  initialized = false;
+  globalContext;
+  constructor(storage, dbPath) {
+    this.storage = storage || new SQLiteSpanStorage(dbPath || getDefaultDbPath());
+  }
+  async initialize() {
+    if (this.initialized)
+      return;
+    await this.storage.initialize();
+    this.initialized = true;
+  }
+  isInitialized() {
+    return this.initialized;
+  }
+  getGlobalContext() {
+    return this.globalContext;
+  }
+  setGlobalContext(context) {
+    this.globalContext = context;
+  }
+  getTracer(name, version) {
+    const key = `${name}@${version || "0.0.0"}`;
+    let tracer = this.tracers.get(key);
+    if (!tracer) {
+      tracer = new OTelTracerImpl(name, version, this.storage, this);
+      this.tracers.set(key, tracer);
+      if (this.initialized) {
+        this.restoreFromEnv(tracer);
+      }
+    }
+    return tracer;
+  }
+  restoreFromEnv(tracer) {
+    const extracted = propagation.extract(process.env);
+    if (extracted) {
+      tracer.setCurrentContext({
+        traceId: extracted.traceId,
+        spanId: extracted.spanId,
+        parentSpanId: undefined
+      });
+    }
+  }
+  shutdown() {
+    for (const tracer of this.tracers.values()) {}
+    this.tracers.clear();
+    this.storage.close();
+    this.initialized = false;
+    this.globalContext = undefined;
+    delete process.env["TRACEPARENT"];
+    delete process.env["TRACE_ID"];
+    delete process.env["LOG_TRACE_REQUEST_ID"];
+  }
+  getStorage() {
+    return this.storage;
+  }
+}
+function getTracerProvider() {
+  if (!providerInstance) {
+    providerInstance = new OTelTracerProvider;
+  }
+  return providerInstance;
+}
+function resetTracerProvider() {
+  if (providerInstance) {
+    providerInstance.shutdown();
+    providerInstance = null;
+  }
+}
+function getDefaultDbPath() {
+  const os = __require("os");
+  const path = __require("path");
+  const home = os.homedir();
+  const dataHome = process.env.XDG_DATA_HOME || path.join(home, ".local", "share");
+  return path.join(dataHome, "roy-agent", "traces.db");
+}
+var providerInstance = null;
+var init_tracer_provider = __esm(() => {
+  init_propagation();
+  init_types();
+});
+
+// packages/core/src/env/tool/built-in/bash.ts
+import { z } from "zod";
+import { exec } from "child_process";
+import { promisify } from "util";
+function getCurrentSpanContext() {
+  try {
+    const { getTracerProvider: getTracerProvider2 } = (init_tracer_provider(), __toCommonJS(exports_tracer_provider));
+    const provider = getTracerProvider2();
+    if (!provider.isInitialized()) {
+      throw new Error("Provider not initialized");
+    }
+    const tracer = provider.getTracer("roy-tracer");
+    const ctx = tracer.getCurrentContext();
+    if (ctx && ctx.traceId && ctx.spanId) {
+      return ctx;
+    }
+  } catch {}
+  return;
+}
+function getCurrentTraceId() {
+  const ctx = getCurrentSpanContext();
+  if (ctx) {
+    return ctx.traceId;
+  }
+  return process.env.TRACE_ID;
+}
+var execAsync, bashTool;
+var init_bash = __esm(() => {
+  init_propagation();
+  execAsync = promisify(exec);
+  bashTool = {
+    name: "bash",
+    description: "Execute shell commands in the terminal. Use this to run system commands, scripts, or interact with the file system.",
+    parameters: z.object({
+      command: z.string().describe("The shell command to execute"),
+      workdir: z.string().optional().describe("Working directory for the command"),
+      timeout: z.number().int().positive().optional().describe("Timeout in milliseconds"),
+      env: z.record(z.string()).optional().describe("Additional environment variables")
+    }),
+    sandbox: {
+      enabled: true,
+      config: {
+        filesystem: {
+          denyRead: ["/etc/shadow", "/etc/sudoers", "/etc/sudoers.d/*"],
+          denyWrite: ["/etc", "/usr/bin", "/usr/sbin", "/bin", "/sbin"]
+        }
+      }
+    },
+    permission: {
+      requireConfirmation: true,
+      level: "dangerous"
+    },
+    metadata: {
+      category: "system",
+      tags: ["shell", "command", "terminal", "exec"],
+      version: "1.2.0"
+    },
+    execute: async (args, ctx) => {
+      const startTime = Date.now();
+      const { command, workdir, timeout = 60000, env } = args;
+      const currentSpanCtx = getCurrentSpanContext();
+      const traceId = currentSpanCtx?.traceId || getCurrentTraceId();
+      const options = {
+        timeout
+      };
+      if (workdir || ctx.workdir) {
+        options.cwd = workdir || ctx.workdir;
+      }
+      const childEnv = {};
+      for (const [key, value] of Object.entries(process.env)) {
+        if (value !== undefined) {
+          childEnv[key] = value;
+        }
+      }
+      if (currentSpanCtx) {
+        const carrier = {};
+        propagation.inject(carrier, currentSpanCtx);
+        if (carrier["TRACEPARENT"]) {
+          childEnv["TRACEPARENT"] = carrier["TRACEPARENT"];
+        }
+        childEnv["TRACE_ID"] = currentSpanCtx.traceId;
+        childEnv["PARENT_SPAN_ID"] = currentSpanCtx.spanId;
+      } else if (traceId) {
+        const spanId2 = Math.floor(Math.random() * 18446744073709552000).toString(16).padStart(16, "0");
+        childEnv["TRACEPARENT"] = `00-${traceId}-${spanId2}-01`;
+        childEnv["TRACE_ID"] = traceId;
+      }
+      if (env) {
+        Object.assign(childEnv, env);
+      }
+      options.env = childEnv;
+      let otelSpan = undefined;
+      try {
+        const { getTracerProvider: getTracerProvider2 } = (init_tracer_provider(), __toCommonJS(exports_tracer_provider));
+        const provider = getTracerProvider2();
+        const tracer = provider.getTracer("roy-tracer");
+        otelSpan = tracer.startSpan(`bash: ${command.slice(0, 50)}${command.length > 50 ? "..." : ""}`, {
+          attributes: {
+            "bash.command": command.slice(0, 200),
+            "bash.workdir": workdir || ctx.workdir || "",
+            "bash.timeout": timeout
+          }
+        });
+      } catch {}
+      const spanId = otelSpan?.spanContext?.spanId;
+      try {
+        const { stdout, stderr } = await execAsync(command, options);
+        if (otelSpan) {
+          otelSpan.end({ stdout, stderr });
+        }
+        return {
+          success: true,
+          output: stdout || "(no output)",
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            stdout,
+            stderr,
+            exit_code: 0,
+            trace_id: traceId,
+            parent_span_id: currentSpanCtx?.spanId,
+            span_id: spanId
+          }
+        };
+      } catch (error) {
+        const exitCode = error.code || 1;
+        const stdout = error.stdout || "";
+        const stderr = error.stderr || error.message;
+        const execError = new Error(stderr);
+        execError.name = "BashExecutionError";
+        if (otelSpan) {
+          otelSpan.end(undefined, execError);
+        }
+        return {
+          success: exitCode === 0,
+          output: stdout || "(no output)",
+          error: stderr,
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            stdout,
+            stderr,
+            exit_code: exitCode,
+            trace_id: traceId,
+            parent_span_id: currentSpanCtx?.spanId,
+            span_id: spanId
+          }
+        };
+      }
+    }
+  };
+});
+
+// packages/core/src/env/tool/built-in/echo.ts
+var echoTool;
+var init_echo = __esm(() => {
+  echoTool = {
+    name: "echo",
+    description: "Echo a message to the console. Useful for logging in workflows.",
+    parameters: {
+      name: "message",
+      schema: {
+        type: "string",
+        description: "The message to echo"
+      }
+    },
+    execute: async (args, _ctx) => {
+      const message = args?.message || "(no message)";
+      return {
+        success: true,
+        output: message,
+        metadata: {
+          execution_time_ms: 0
+        }
+      };
+    }
+  };
+});
+
+// packages/core/src/env/tool/built-in/glob.ts
+import { z as z2 } from "zod";
+import { glob as globAsync } from "glob";
+var globTool;
+var init_glob = __esm(() => {
+  globTool = {
+    name: "glob",
+    description: "Search for files matching a glob pattern. Use this to find files by name patterns like **/*.ts or **/*.md.",
+    parameters: z2.object({
+      pattern: z2.string().describe("Glob pattern to match (e.g., **/*.ts, **/*.md)"),
+      cwd: z2.string().optional().describe("Working directory to search in"),
+      maxResults: z2.number().int().positive().optional().describe("Maximum number of results to return"),
+      ignore: z2.array(z2.string()).optional().describe("Patterns to ignore")
+    }),
+    sandbox: {
+      enabled: true
+    },
+    metadata: {
+      category: "file",
+      tags: ["search", "file", "glob", "pattern"],
+      version: "1.0.0"
+    },
+    execute: async (args, ctx) => {
+      const startTime = Date.now();
+      const { pattern, cwd, maxResults = 100, ignore } = args;
+      const searchDir = cwd || ctx.workdir || process.cwd();
+      try {
+        const files = await globAsync(pattern, {
+          cwd: searchDir,
+          ignore: ignore || ["**/node_modules/**", "**/.git/**"],
+          maxDepth: 20
+        });
+        const limitedFiles = files.slice(0, maxResults);
+        const output = limitedFiles.join(`
+`);
+        return {
+          success: true,
+          output,
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            output_size: output.length,
+            total_matches: files.length,
+            returned_matches: limitedFiles.length
+          }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: {
+            execution_time_ms: Date.now() - startTime
+          }
+        };
+      }
+    }
+  };
+});
+
+// packages/core/src/env/tool/built-in/read-file.ts
+import { z as z3 } from "zod";
+import { readFile } from "fs/promises";
+var readFileTool;
+var init_read_file = __esm(() => {
+  readFileTool = {
+    name: "read_file",
+    description: "Read the contents of a file. Use this to read source code, configuration files, or any text files.",
+    parameters: z3.object({
+      path: z3.string().describe("The file path to read"),
+      offset: z3.number().int().nonnegative().optional().describe("Line offset to start reading from"),
+      limit: z3.number().int().positive().optional().describe("Number of lines to read"),
+      encoding: z3.enum(["utf-8", "base64"]).default("utf-8").optional().describe("File encoding")
+    }),
+    sandbox: {
+      enabled: true,
+      config: {
+        filesystem: {
+          denyRead: ["/etc/shadow", "/etc/sudoers", "/root/.ssh"]
+        }
+      }
+    },
+    permission: {
+      level: "safe"
+    },
+    metadata: {
+      category: "file",
+      tags: ["read", "file", "io"],
+      version: "1.0.0"
+    },
+    execute: async (args, ctx) => {
+      const startTime = Date.now();
+      const { path: filePath, offset, limit, encoding = "utf-8" } = args;
+      try {
+        const content = await readFile(filePath, encoding);
+        let output;
+        const contentBuffer = content;
+        const contentStr = typeof contentBuffer === "string" ? contentBuffer : contentBuffer.toString(encoding);
+        if (offset !== undefined || limit !== undefined) {
+          const lines = contentStr.split(`
+`);
+          const startLine = offset || 0;
+          const endLine = limit ? startLine + limit : lines.length;
+          output = lines.slice(startLine, endLine).join(`
+`);
+        } else {
+          output = contentStr;
+        }
+        return {
+          success: true,
+          output,
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            output_size: output.length,
+            file_path: filePath
+          }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: {
+            execution_time_ms: Date.now() - startTime
+          }
+        };
+      }
+    }
+  };
+});
+
+// packages/core/src/env/tool/built-in/write-file.ts
+import { z as z4 } from "zod";
+import { writeFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+var writeFileTool;
+var init_write_file = __esm(() => {
+  writeFileTool = {
+    name: "write_file",
+    description: "Write content to a file. Use this to create new files or overwrite existing ones.",
+    parameters: z4.object({
+      path: z4.string().describe("The file path to write to"),
+      content: z4.string().describe("The content to write"),
+      createDirs: z4.boolean().default(false).optional().describe("Create parent directories if they don't exist"),
+      append: z4.boolean().default(false).optional().describe("Append to file instead of overwrite")
+    }),
+    sandbox: {
+      enabled: true,
+      config: {
+        filesystem: {
+          denyWrite: ["/etc", "/usr", "/bin", "/sbin", "/boot", "/sys"]
+        }
+      }
+    },
+    permission: {
+      requireConfirmation: true,
+      level: "dangerous"
+    },
+    metadata: {
+      category: "file",
+      tags: ["write", "file", "io", "create"],
+      version: "1.0.0"
+    },
+    execute: async (args, ctx) => {
+      const startTime = Date.now();
+      const { path: filePath, content, createDirs = false, append = false } = args;
+      try {
+        if (createDirs) {
+          await mkdir(dirname(filePath), { recursive: true });
+        }
+        const flags = append ? "a" : "w";
+        await writeFile(filePath, content, { flag: flags });
+        return {
+          success: true,
+          output: append ? `Content appended to: ${filePath}` : `File written: ${filePath}`,
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            output_size: content.length,
+            file_path: filePath
+          }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: {
+            execution_time_ms: Date.now() - startTime
+          }
+        };
+      }
+    }
+  };
+});
+
+// packages/core/src/env/tool/built-in/edit-file.ts
+import { z as z5 } from "zod";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var editFileTool;
+var init_edit_file = __esm(() => {
+  editFileTool = {
+    name: "edit_file",
+    description: "Edit a file by replacing specific text. Use this to make targeted changes to files by specifying what to find and what to replace.",
+    parameters: z5.object({
+      path: z5.string().describe("The file path to edit"),
+      oldString: z5.string().describe("The text to find and replace"),
+      newString: z5.string().describe("The replacement text"),
+      replaceAll: z5.boolean().default(false).optional().describe("Replace all occurrences instead of just the first")
+    }),
+    sandbox: {
+      enabled: true,
+      config: {
+        filesystem: {
+          denyWrite: ["/etc", "/usr/bin", "/usr/sbin", "/bin", "/sbin"]
+        }
+      }
+    },
+    permission: {
+      requireConfirmation: true,
+      level: "dangerous"
+    },
+    metadata: {
+      category: "file",
+      tags: ["edit", "file", "replace", "modify"],
+      version: "1.0.0"
+    },
+    execute: async (args, ctx) => {
+      const startTime = Date.now();
+      const { path: filePath, oldString, newString, replaceAll = false } = args;
+      try {
+        const content = await readFile2(filePath, "utf-8");
+        const searchPattern = replaceAll ? new RegExp(escapeRegExp(oldString), "g") : new RegExp(escapeRegExp(oldString));
+        if (!searchPattern.test(content)) {
+          return {
+            success: false,
+            output: "",
+            error: `Could not find "${oldString}" in file ${filePath}`,
+            metadata: {
+              execution_time_ms: Date.now() - startTime
+            }
+          };
+        }
+        const newContent = replaceAll ? content.replace(new RegExp(escapeRegExp(oldString), "g"), newString) : content.replace(oldString, newString);
+        await writeFile2(filePath, newContent, "utf-8");
+        return {
+          success: true,
+          output: replaceAll ? `Replaced all occurrences in: ${filePath}` : `Replaced text in: ${filePath}`,
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            file_path: filePath
+          }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: {
+            execution_time_ms: Date.now() - startTime
+          }
+        };
+      }
+    }
+  };
+});
+
+// packages/core/src/env/tool/built-in/grep.ts
+import { z as z6 } from "zod";
+import { readFile as readFile3 } from "fs/promises";
+import { glob as globAsync2 } from "glob";
+var grepTool;
+var init_grep = __esm(() => {
+  grepTool = {
+    name: "grep",
+    description: "Search for text patterns in files. Use this to find specific strings, code patterns, or content across multiple files.",
+    parameters: z6.object({
+      pattern: z6.string().describe("The pattern to search for"),
+      path: z6.string().optional().describe("File or directory path to search in"),
+      include: z6.string().optional().describe("Glob pattern for files to include (e.g., *.ts, *.js)"),
+      caseSensitive: z6.boolean().default(true).optional().describe("Whether the search should be case sensitive"),
+      maxResults: z6.number().int().positive().default(50).optional().describe("Maximum number of results"),
+      showLineNumbers: z6.boolean().default(true).optional().describe("Show line numbers in results")
+    }),
+    sandbox: {
+      enabled: true
+    },
+    metadata: {
+      category: "file",
+      tags: ["search", "grep", "find", "pattern"],
+      version: "1.0.0"
+    },
+    execute: async (args, ctx) => {
+      const startTime = Date.now();
+      const {
+        pattern,
+        path: searchPath,
+        include,
+        caseSensitive = true,
+        maxResults = 50,
+        showLineNumbers = true
+      } = args;
+      const basePath = searchPath || ctx.workdir || process.cwd();
+      try {
+        let files = [];
+        if (include) {
+          files = await globAsync2(include, {
+            cwd: basePath,
+            ignore: ["**/node_modules/**", "**/.git/**"],
+            maxDepth: 10
+          });
+        } else {
+          files = await globAsync2("**/*", {
+            cwd: basePath,
+            ignore: ["**/node_modules/**", "**/.git/**"],
+            maxDepth: 10
+          });
+        }
+        const results = [];
+        const regexFlags = caseSensitive ? "" : "i";
+        const regex = new RegExp(pattern, regexFlags);
+        for (const file of files) {
+          if (results.length >= maxResults)
+            break;
+          try {
+            const content = await readFile3(`${basePath}/${file}`, "utf-8");
+            const lines = content.split(`
+`);
+            for (let i = 0;i < lines.length; i++) {
+              if (regex.test(lines[i])) {
+                const lineNum = showLineNumbers ? `${i + 1}:` : "";
+                results.push(`${file}:${lineNum}${lines[i]}`);
+                if (results.length >= maxResults)
+                  break;
+              }
+            }
+          } catch {}
+        }
+        const output = results.join(`
+`) || "(no matches found)";
+        return {
+          success: true,
+          output,
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            output_size: output.length,
+            matches_count: results.length,
+            files_searched: files.length
+          }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: {
+            execution_time_ms: Date.now() - startTime
+          }
+        };
+      }
+    }
+  };
+});
+
+// packages/core/src/env/tool/built-in/index.ts
+var exports_built_in = {};
+__export(exports_built_in, {
+  writeFileTool: () => writeFileTool,
+  readFileTool: () => readFileTool,
+  grepTool: () => grepTool,
+  globTool: () => globTool,
+  getBuiltInTool: () => getBuiltInTool,
+  getAllBuiltInTools: () => getAllBuiltInTools,
+  editFileTool: () => editFileTool,
+  echoTool: () => echoTool,
+  bashTool: () => bashTool
+});
+function getAllBuiltInTools() {
+  return [
+    bashTool,
+    echoTool,
+    globTool,
+    readFileTool,
+    writeFileTool,
+    editFileTool,
+    grepTool
+  ];
+}
+function getBuiltInTool(name) {
+  const tools = getAllBuiltInTools();
+  return tools.find((t) => t.name === name);
+}
+var init_built_in = __esm(() => {
+  init_bash();
+  init_echo();
+  init_glob();
+  init_read_file();
+  init_write_file();
+  init_edit_file();
+  init_grep();
+});
+
+// packages/core/src/env/log-trace/logger.ts
+import { appendFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+function simplifyFilePath(fullPath) {
+  let path = fullPath.replace(/\\/g, "/");
+  const bunfsMatch = path.match(/\/\$bunfs\/root\/(.+)$/);
+  if (bunfsMatch) {
+    const virtualPath = bunfsMatch[1];
+    const packagesMatch = virtualPath.match(/(packages\/[^/]+\/src\/[^/]+\/.+)$/);
+    if (packagesMatch) {
+      return packagesMatch[1];
+    }
+    return virtualPath;
+  }
+  const fileProtocolMatch = path.match(/@roy-agent\+core@file\+([^/]+)\/node_modules\/@roy-agent\/core\/(.+)$/);
+  if (fileProtocolMatch) {
+    const rootPkg = fileProtocolMatch[1].replace(/\+/g, "/");
+    const remaining = fileProtocolMatch[2];
+    const prefix = rootPkg;
+    const suffix = remaining.startsWith("src/") ? remaining : `src/${remaining}`;
+    return `${prefix}/${suffix}`;
+  }
+  const packagesRootMatch = path.match(/(packages\/[^/]+\/src\/[^/]+\/.+)$/);
+  if (packagesRootMatch) {
+    return packagesRootMatch[1];
+  }
+  const rootMarkers = ["packages/core/src", "packages/core", "packages"];
+  for (const marker of rootMarkers) {
+    const idx = path.indexOf(marker);
+    if (idx !== -1) {
+      return path.substring(idx);
+    }
+  }
+  return path;
+}
+function getDefaultLogDir() {
+  const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+  try {
+    const xdg = __require("xdg-basedir");
+    if (xdg.xdgData) {
+      return join(xdg.xdgData, "roy-agent", "logs");
+    }
+  } catch {}
+  return join(home, ".local", "share", "roy-agent", "logs");
+}
+function isQuietMode() {
+  return quietMode;
+}
+function setQuietMode(enabled) {
+  quietMode = enabled;
+}
+function setConfigComponent(component) {
+  configComponentInstance = component;
+}
+function getLogLevel() {
+  if (configComponentInstance) {
+    const level = configComponentInstance.get("log_trace.logging.level");
+    if (level && ["debug", "info", "warn", "error"].includes(level)) {
+      return level;
+    }
+  }
+  const envLevel = process.env.LOG_LEVEL;
+  if (envLevel && ["debug", "info", "warn", "error"].includes(envLevel)) {
+    return envLevel;
+  }
+  return "info";
+}
+function getCategoryLogLevel(category) {
+  if (configComponentInstance) {
+    const levels = configComponentInstance.get("log_trace.logging.levels");
+    if (levels && typeof levels === "object") {
+      const categoryLevel = levels[category];
+      if (categoryLevel && ["debug", "info", "warn", "error"].includes(categoryLevel)) {
+        return categoryLevel;
+      }
+    }
+    const directLevel = configComponentInstance.get(`log_trace.logging.levels.${category}`);
+    if (directLevel && ["debug", "info", "warn", "error"].includes(directLevel)) {
+      return directLevel;
+    }
+  }
+  const envKey = `LOG_LEVEL_${category.toUpperCase().replace(/:/g, "_")}`;
+  const envLevel = process.env[envKey];
+  if (envLevel && ["debug", "info", "warn", "error"].includes(envLevel)) {
+    return envLevel;
+  }
+  return getLogLevel();
+}
+function isAbsolutePath(path) {
+  if (path.startsWith("/")) {
+    return true;
+  }
+  if (/^[a-zA-Z]:[/\\]/.test(path)) {
+    return true;
+  }
+  return false;
+}
+function expandHomeDir(path) {
+  if (path.startsWith("~")) {
+    const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+    return join(home, path.slice(1));
+  }
+  return path;
+}
+function getLogFile() {
+  if (configComponentInstance) {
+    const file = configComponentInstance.get("log_trace.logging.file");
+    if (file) {
+      return file;
+    }
+  }
+  return "app.log";
+}
+function getLogDir() {
+  if (configComponentInstance) {
+    const dir = configComponentInstance.get("log_trace.logging.dir");
+    if (dir) {
+      return dir;
+    }
+  }
+  return getDefaultLogDir();
+}
+function getMaxOutput() {
+  if (configComponentInstance) {
+    const maxOutput = configComponentInstance.get("log-trace.logging.maxOutput");
+    if (typeof maxOutput === "number") {
+      return maxOutput;
+    }
+  }
+  return;
+}
+function setLogDirOverride(dir) {
+  logDirOverride = dir;
+}
+function getLogDirOverride() {
+  return logDirOverride;
+}
+
+class Logger {
+  prefix;
+  constructor(prefix) {
+    this.prefix = prefix;
+  }
+  shouldLog(level) {
+    const categoryLevel = getCategoryLogLevel(this.prefix);
+    return levelPriority[level] >= levelPriority[categoryLevel];
+  }
+  ensureLogDirectory(dir) {
+    if (!existsSync(dir)) {
+      try {
+        mkdirSync(dir, { recursive: true });
+      } catch (err) {
+        console.error("[Logger] Failed to create log directory:", dir, err);
+      }
+    }
+  }
+  getCallerLocation() {
+    const originalLimit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 10;
+    const err = new Error;
+    Error.captureStackTrace(err, this.formatMessage);
+    const stack = err.stack?.split(`
+`) || [];
+    Error.stackTraceLimit = originalLimit;
+    for (let i = 1;i < stack.length; i++) {
+      const line = stack[i];
+      if (line.includes("at ") && !line.includes("logger.ts") && !line.includes("formatMessage")) {
+        const match = line.match(/at\s+.+\s+\((.+):(\d+):\d+\)/) || line.match(/at\s+(.+):(\d+):\d+/);
+        if (match) {
+          const filePath = match[1];
+          const relativePath = this.getRelativePath(filePath);
+          return {
+            file: relativePath,
+            line: parseInt(match[2], 10)
+          };
+        }
+      }
+    }
+    return null;
+  }
+  getRelativePath(fullPath) {
+    return simplifyFilePath(fullPath);
+  }
+  formatMessage(level, message, data) {
+    const now = new Date;
+    const timestamp = now.toLocaleString("zh-CN", {
+      timeZone: "Asia/Shanghai",
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hour12: false
+    }).replace(/\//g, "-") + "." + String(now.getMilliseconds()).padStart(3, "0");
+    const prefix = this.prefix ? `[${this.prefix}]` : "";
+    let traceIdStr = "";
+    try {
+      const provider = getTracerProvider();
+      const tracer = provider.getTracer("roy-tracer");
+      const context = tracer.getCurrentContext();
+      if (context?.traceId) {
+        traceIdStr = `[traceId=${context.traceId}]`;
+      }
+    } catch {}
+    let locationStr = "";
+    if (data && typeof data === "object" && "callerLocation" in data) {
+      const logData = data;
+      locationStr = logData.callerLocation ? ` [${logData.callerLocation}]` : "";
+      const { callerLocation: _callerLocation, ...rest } = logData;
+      data = Object.keys(rest).length > 0 ? rest : undefined;
+    } else {
+      const location = this.getCallerLocation();
+      if (location) {
+        locationStr = ` [${location.file}:${location.line}]`;
+      }
+    }
+    let formatted = `${timestamp} [${level.toUpperCase()}]${traceIdStr}${locationStr}${prefix} ${message}`;
+    if (data !== undefined) {
+      if (typeof data === "object") {
+        formatted += " " + JSON.stringify(data).replace(/\n/g, "");
+      } else {
+        formatted += " " + String(data);
+      }
+    }
+    const maxOutput = getMaxOutput();
+    if (maxOutput && maxOutput > 0 && formatted.length > maxOutput) {
+      formatted = formatted.substring(0, maxOutput) + " [TRUNCATED]";
+    }
+    return formatted;
+  }
+  writeToFile(message) {
+    try {
+      const dir = getLogDir();
+      const filename = getLogFile();
+      const expandedDir = expandHomeDir(dir);
+      const resolvedDir = isAbsolutePath(expandedDir) ? expandedDir : join(process.cwd(), expandedDir);
+      this.ensureLogDirectory(resolvedDir);
+      const logFile = join(resolvedDir, filename);
+      appendFileSync(logFile, message + `
+`, "utf-8");
+    } catch (err) {
+      console.error("[Logger] Failed to write to log file:", err);
+    }
+  }
+  log(level, message, data) {
+    if (!this.shouldLog(level))
+      return;
+    const formatted = this.formatMessage(level, message, data);
+    this.writeToFile(formatted);
+    if (!isQuietMode()) {
+      const consoleMethod = level === "error" ? console.error : level === "warn" ? console.warn : level === "info" ? console.log : console.debug;
+      consoleMethod(formatted);
+    }
+  }
+  debug(message, data) {
+    this.log("debug", message, data);
+  }
+  info(message, data) {
+    this.log("info", message, data);
+  }
+  warn(message, data) {
+    this.log("warn", message, data);
+  }
+  error(message, data) {
+    this.log("error", message, data);
+  }
+}
+function createLogger(prefix) {
+  if (!loggerCache.has(prefix)) {
+    loggerCache.set(prefix, new Logger(prefix));
+  }
+  return loggerCache.get(prefix);
+}
+function getLogLevels() {
+  return ["debug", "info", "warn", "error"];
+}
+var configComponentInstance = null, quietMode = false, logDirOverride, levelPriority, loggerCache;
+var init_logger = __esm(() => {
+  init_tracer_provider();
+  levelPriority = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3
+  };
+  loggerCache = new Map;
+});
+
+// packages/core/src/env/workflow/types/workflow-hil.ts
+function createNodeInterruptEvent(runId, nodeId, nodeType, query, agentSessionId) {
+  return {
+    type: "node.interrupt",
+    run_id: runId,
+    timestamp: Date.now(),
+    node_id: nodeId,
+    node_type: nodeType,
+    query,
+    ...agentSessionId ? { agent_session_id: agentSessionId } : {}
+  };
+}
+function createWorkflowAskUserEvent(runId, sessionId, nodeId, nodeType, query) {
+  return {
+    type: "workflow.ask-user",
+    run_id: runId,
+    timestamp: Date.now(),
+    session_id: sessionId,
+    node_id: nodeId,
+    node_type: nodeType,
+    query
+  };
+}
+var AskUserError;
+var init_workflow_hil = __esm(() => {
+  AskUserError = class AskUserError extends Error {
+    runId;
+    sessionId;
+    nodeId;
+    nodeType;
+    query;
+    agentSessionId;
+    timestamp;
+    type = "ask-user";
+    name = "AskUserError";
+    constructor(runId, sessionId, nodeId, nodeType, query, agentSessionId, timestamp = Date.now()) {
+      super(`[${nodeType}:${nodeId}] Ask user: ${query}`);
+      this.runId = runId;
+      this.sessionId = sessionId;
+      this.nodeId = nodeId;
+      this.nodeType = nodeType;
+      this.query = query;
+      this.agentSessionId = agentSessionId;
+      this.timestamp = timestamp;
+    }
+    toEvent() {
+      return {
+        type: "workflow.ask-user",
+        run_id: this.runId,
+        timestamp: this.timestamp,
+        session_id: this.sessionId,
+        node_id: this.nodeId,
+        node_type: this.nodeType,
+        query: this.query
+      };
+    }
+  };
+});
+
+// packages/core/src/env/hook/types.ts
+function createHook(meta, fn) {
+  return {
+    ...meta,
+    execute: fn
+  };
+}
+function createPriorityHook(name, fn, priority) {
+  return createHook({ name, priority }, fn);
+}
+// packages/core/src/env/hook/hook-manager.ts
+class HookManager {
+  _hooks = new Map;
+  componentName;
+  componentVersion;
+  defaultPriority;
+  constructor(options = {}) {
+    this.componentName = options.componentName ?? "unknown";
+    this.componentVersion = options.componentVersion ?? "0.0.0";
+    this.defaultPriority = options.defaultPriority ?? 0;
+  }
+  register(hookPoint, hook) {
+    const hooks = this.getOrCreateHooks(hookPoint);
+    hooks.push(hook);
+  }
+  registerMany(hookPoint, hooks) {
+    const hookList = this.getOrCreateHooks(hookPoint);
+    hookList.push(...hooks);
+  }
+  unregister(hookPoint, name) {
+    const hooks = this._hooks.get(hookPoint);
+    if (!hooks)
+      return false;
+    const index = hooks.findIndex((h) => h.name === name);
+    if (index === -1)
+      return false;
+    hooks.splice(index, 1);
+    return true;
+  }
+  unregisterAll(hookPoint) {
+    this._hooks.delete(hookPoint);
+  }
+  async execute(hookPoint, data, metadata = {}) {
+    const hooks = this._hooks.get(hookPoint);
+    if (!hooks || hooks.length === 0)
+      return;
+    const sortedHooks = this.sortHooks(hooks);
+    const ctx = this.createContext(hookPoint, data, metadata, "before");
+    for (const hook of sortedHooks) {
+      await this.safeExecute(hook, ctx);
+    }
+  }
+  async executeAndCollect(hookPoint, data, metadata = {}) {
+    const hooks = this._hooks.get(hookPoint);
+    if (!hooks || hooks.length === 0)
+      return [];
+    const sortedHooks = this.sortHooks(hooks);
+    const ctx = this.createContext(hookPoint, data, metadata, "before");
+    const results = [];
+    for (const hook of sortedHooks) {
+      const result = await this.safeExecuteAndReturn(hook, ctx);
+      if (result !== undefined) {
+        results.push(result);
+      }
+    }
+    return results;
+  }
+  count(hookPoint) {
+    return this._hooks.get(hookPoint)?.length ?? 0;
+  }
+  clear() {
+    this._hooks.clear();
+  }
+  getHookPoints() {
+    return Array.from(this._hooks.keys());
+  }
+  hasHooks(hookPoint) {
+    return this.count(hookPoint) > 0;
+  }
+  setComponentInfo(name, version) {
+    this.componentName = name;
+    this.componentVersion = version;
+  }
+  get hooks() {
+    return this._hooks;
+  }
+  async executeWithIntervention(hookPoint, data, metadata = {}) {
+    const hooks = this._hooks.get(hookPoint);
+    if (!hooks || hooks.length === 0) {
+      return { stopped: false, results: [] };
+    }
+    const sortedHooks = this.sortHooks(hooks);
+    const ctx = this.createContext(hookPoint, data, metadata, "before");
+    const results = [];
+    let stopped = false;
+    let action;
+    for (const hook of sortedHooks) {
+      if (stopped)
+        break;
+      const result = await this.safeExecuteAndReturn(hook, ctx);
+      results.push(result);
+      if (result && typeof result === "object" && "stopped" in result) {
+        const hookResult = result;
+        if (hookResult.stopped) {
+          stopped = true;
+          action = hookResult.action;
+        }
+      }
+    }
+    return { stopped, action, results };
+  }
+  getOrCreateHooks(hookPoint) {
+    let hooks = this._hooks.get(hookPoint);
+    if (!hooks) {
+      hooks = [];
+      this._hooks.set(hookPoint, hooks);
+    }
+    return hooks;
+  }
+  sortHooks(hooks) {
+    return [...hooks].sort((a, b) => {
+      const priorityA = a.priority ?? this.defaultPriority;
+      const priorityB = b.priority ?? this.defaultPriority;
+      return priorityA - priorityB;
+    });
+  }
+  createContext(hookPoint, data, metadata, phase) {
+    return {
+      component: {
+        name: this.componentName,
+        version: this.componentVersion
+      },
+      data,
+      metadata,
+      phase,
+      hookPoint
+    };
+  }
+  async safeExecute(hook, ctx) {
+    try {
+      await hook.execute(ctx);
+    } catch (error) {
+      console.error(`Hook "${hook.name}" failed:`, error);
+    }
+  }
+  async safeExecuteAndReturn(hook, ctx) {
+    try {
+      return await hook.execute(ctx);
+    } catch (error) {
+      console.error(`Hook "${hook.name}" failed:`, error);
+      return;
+    }
+  }
+}
+// packages/core/src/env/hook/global-hook-manager.ts
+var globalHookManager = new HookManager;
+var AgentHookPoints = {
+  BEFORE_START: "agent:before.start",
+  BEFORE_LLM: "agent:before.llm",
+  AFTER_LLM: "agent:after.llm",
+  BEFORE_TOOL: "agent:before.tool",
+  AFTER_TOOL: "agent:after.tool",
+  ON_ITERATION: "agent:on.iteration",
+  ON_THRESHOLD: "agent:on.threshold",
+  AFTER_COMPLETE: "agent:after.complete",
+  ON_ERROR: "agent:on.error"
+};
+var LLMHookPoints = {
+  BEFORE_INVOKE: "llm:before.invoke",
+  AFTER_INVOKE: "llm:after.invoke",
+  ON_STREAM: "llm:on.stream"
+};
+var ToolHookPoints = {
+  BEFORE_EXECUTE: "tool:before.execute",
+  AFTER_EXECUTE: "tool:after.execute",
+  BEFORE_REGISTER: "tool:before.register",
+  AFTER_REGISTER: "tool:after.register",
+  ON_ERROR: "tool:on.error"
+};
+var hookPointAliases = {
+  "before.tool": "tool:before.execute",
+  "after.tool": "tool:after.execute",
+  "llm.before-invoke": "llm:before.invoke",
+  "llm.after-invoke": "llm:after.invoke",
+  "llm.stream": "llm:on.stream"
+};
+function setupAliasHooks() {
+  const originalRegister = globalHookManager.register.bind(globalHookManager);
+  globalHookManager.register = function(hookPoint, hook) {
+    originalRegister(hookPoint, hook);
+    const alias = hookPointAliases[hookPoint];
+    if (alias) {
+      originalRegister(alias, hook);
+    }
+  };
+}
+setupAliasHooks();
+async function executeAgentHook(hookPoint, data, metadata = {}) {
+  await globalHookManager.execute(hookPoint, data, metadata);
+}
+async function executeAgentHookWithIntervention(hookPoint, data, metadata = {}) {
+  return globalHookManager.executeWithIntervention(hookPoint, data, metadata);
+}
+async function executeLLMHook(hookPoint, data, metadata = {}) {
+  await globalHookManager.execute(hookPoint, data, metadata);
+}
+async function executeToolHook(hookPoint, data, metadata = {}) {
+  await globalHookManager.execute(hookPoint, data, metadata);
+}
+// packages/core/src/env/tool/tool-component.ts
+import { z as z7 } from "zod";
+
+// packages/core/src/env/component.ts
+class BaseComponent {
+  _status = "created";
+  _enabled = true;
+  env;
+  hookManager;
+  constructor() {
+    this.hookManager = new HookManager;
+  }
+  getStatus() {
+    return this._status;
+  }
+  getConfig() {
+    return {
+      name: this.name,
+      version: this.version,
+      enabled: this._enabled,
+      env: this.env
+    };
+  }
+  isEnvInitialized() {
+    return this._status !== "created";
+  }
+  setStatus(status) {
+    this._status = status;
+  }
+  getEnv() {
+    return this.env;
+  }
+  async init(config) {
+    if (config?.env) {
+      this.env = config.env;
+    }
+    this.setStatus("initializing");
+    try {
+      if (config?.name)
+        Object.defineProperty(this, "name", { value: config.name, writable: false });
+      if (config?.version)
+        Object.defineProperty(this, "version", { value: config.version, writable: false });
+    } catch {}
+    if (config?.enabled !== undefined)
+      this._enabled = config.enabled;
+    this.hookManager.setComponentInfo(this.name, this.version);
+    await this.onInit();
+    this.setStatus("running");
+  }
+  async start() {
+    if (this._started)
+      return;
+    this._started = true;
+    await this.onStart();
+    this.setStatus("running");
+  }
+  async stop() {
+    this.setStatus("stopping");
+    this.hookManager.clear();
+    await this.onStop();
+    this.setStatus("stopped");
+  }
+  async onInit() {}
+  async onStart() {}
+  async onStop() {}
+  registerHook(hookPoint, hook) {
+    this.hookManager.register(hookPoint, hook);
+  }
+  addHook(hookPoint, name, fn, priority) {
+    this.hookManager.register(hookPoint, createHook({ name, priority }, fn));
+  }
+  removeHook(hookPoint, name) {
+    return this.hookManager.unregister(hookPoint, name);
+  }
+  async executeHooks(hookPoint, data, metadata) {
+    await this.hookManager.execute(hookPoint, data, metadata);
+  }
+  getConfigComponent() {
+    return this.env?.getComponent("config");
+  }
+  getRuntimeConfig(key, defaultValue) {
+    const configComponent = this.getConfigComponent();
+    if (configComponent) {
+      const value = configComponent.get(key);
+      if (value !== undefined) {
+        return value;
+      }
+    }
+    return defaultValue;
+  }
+}
+
+// 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/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()}`;
+}
+
+// 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: getAllBuiltInTools2 } = await Promise.resolve().then(() => (init_built_in(), exports_built_in));
+      const tools = getAllBuiltInTools2();
+      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 = z7.object({
+  toolsDir: z7.string().optional(),
+  builtInTools: z7.object({
+    enabled: z7.boolean().default(true),
+    loadAll: z7.boolean().default(true),
+    names: z7.array(z7.string()).optional()
+  }).default({}),
+  sandbox: z7.object({
+    enabled: z7.boolean().default(false),
+    type: z7.enum(["native", "docker"]).default("native"),
+    defaultConfig: z7.record(z7.unknown()).optional()
+  }).default({}),
+  execution: z7.object({
+    timeout: z7.number().int().positive().default(60000),
+    maxConcurrency: z7.number().int().positive().default(4)
+  }).default({})
+});
+
+// packages/core/src/env/tool/index.ts
+init_built_in();
+init_bash();
+init_echo();
+init_glob();
+init_read_file();
+init_write_file();
+init_edit_file();
+init_grep();
+export {
+  writeFileTool,
+  readFileTool,
+  grepTool,
+  globTool,
+  getBuiltInTool,
+  getAllBuiltInTools,
+  editFileTool,
+  echoTool,
+  bashTool,
+  ToolValidator,
+  ToolRegistry,
+  ToolComponent
+};