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

package/dist/env/llm/index.js

@@ -1,2736 +0,0 @@
-// @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/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/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/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/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/log-trace/decorator.ts
-function Traced(options) {
-  return function(target, propertyKey, descriptor) {
-    const originalFn = descriptor.value;
-    const spanName = options?.name || propertyKey;
-    descriptor.value = wrapFunction(originalFn, spanName, {
-      recordParams: options?.recordParams ?? true,
-      recordResult: options?.recordResult ?? false,
-      recordError: options?.recordError ?? true,
-      log: options?.log ?? false,
-      maxLogSize: options?.maxLogSize,
-      paramFilter: options?.paramFilter
-    });
-    return descriptor;
-  };
-}
-function TracedAs(name, options) {
-  return Traced({ name, ...options });
-}
-function TracedLightweight(options) {
-  return Traced({ recordParams: false, recordResult: false, log: options?.log ?? false, maxLogSize: options?.maxLogSize });
-}
-function wrapFunction(fn, name, options) {
-  const shouldLog = options?.log ?? false;
-  const getMaxLogSize = () => {
-    if (options?.maxLogSize !== undefined) {
-      return options.maxLogSize;
-    }
-    const configMaxOutput = getMaxOutput();
-    return configMaxOutput !== undefined ? configMaxOutput : 500;
-  };
-  const truncate = (obj) => {
-    if (obj === undefined)
-      return;
-    if (obj === null)
-      return null;
-    const maxLogSize = getMaxLogSize();
-    let str;
-    try {
-      str = typeof obj === "string" ? obj : JSON.stringify(obj, null, 0).replace(/\n/g, "");
-    } catch (e) {
-      str = `[Object with circular reference: ${e instanceof Error ? e.message : String(e)}]`;
-    }
-    if (maxLogSize > 0 && str.length > maxLogSize) {
-      return str.slice(0, maxLogSize) + " [TRUNCATED]";
-    }
-    try {
-      return JSON.parse(str);
-    } catch {
-      return str;
-    }
-  };
-  const truncateString = (obj) => {
-    if (obj === undefined)
-      return "undefined";
-    if (obj === null)
-      return "null";
-    const maxLogSize = getMaxLogSize();
-    let str;
-    try {
-      str = typeof obj === "string" ? obj : JSON.stringify(obj, null, 0).replace(/\n/g, "");
-    } catch (e) {
-      str = `[Object with circular reference: ${e instanceof Error ? e.message : String(e)}]`;
-    }
-    return maxLogSize > 0 && str.length > maxLogSize ? str.slice(0, maxLogSize) + " [TRUNCATED]" : str;
-  };
-  const TRACE_LOG_PREFIX = "[TRACE]";
-  const getCallerLocation = () => {
-    const originalLimit = Error.stackTraceLimit;
-    Error.stackTraceLimit = 15;
-    const err = new Error;
-    Error.captureStackTrace(err, getCallerLocation);
-    const stack = err.stack?.split(`
-`) || [];
-    Error.stackTraceLimit = originalLimit;
-    for (let i = 1;i < stack.length; i++) {
-      const line = stack[i];
-      if (line.includes("decorator.ts") || line.includes("decorator.js") || line.includes("logFn") || line.includes("getCallerLocation"))
-        continue;
-      const match = line.match(/at\s+.+\s+\((.+):(\d+):\d+\)/) || line.match(/at\s+(.+):(\d+):\d+/);
-      if (match) {
-        const filePath = match[1];
-        if (!filePath || filePath === "native")
-          continue;
-        const relativePath = simplifyFilePath(filePath);
-        return `${relativePath}:${match[2]}`;
-      }
-    }
-    return "";
-  };
-  const logFn = (event, argsOrData, callerLocation) => {
-    if (!shouldLog)
-      return;
-    const logger2 = createLogger("traced:" + name);
-    const tag = event === "enter" ? ">>>" : event === "quit" ? "<<<" : "!!!";
-    const prefix = `${TRACE_LOG_PREFIX} ${tag} ${name}`;
-    const originalFnLocation = callerLocation || getCallerLocation();
-    const logMessage = (msg, data) => {
-      if (data !== undefined) {
-        logger2.info(`${prefix} ${msg}: ${truncateString(data)}`, { callerLocation: originalFnLocation });
-      } else {
-        logger2.info(`${prefix} ${msg}`, { callerLocation: originalFnLocation });
-      }
-    };
-    if (event === "enter") {
-      logMessage("enter", argsOrData);
-    } else if (event === "quit") {
-      logMessage("quit", options?.recordResult ? argsOrData : undefined);
-    } else {
-      logMessage("error", argsOrData);
-    }
-  };
-  return function(...args) {
-    const tracer = getTracerProvider().getTracer("roy-tracer");
-    const attributes = {};
-    if (options?.recordParams !== false) {
-      if (options?.paramFilter) {
-        attributes["params"] = truncate(options.paramFilter(args));
-      } else {
-        attributes["params"] = truncate(args);
-      }
-    }
-    const callerLocation = getCallerLocation();
-    logFn("enter", args, callerLocation);
-    const span = tracer.startSpan(name, { attributes });
-    try {
-      const result = fn.call(this, ...args);
-      if (result && typeof result === "object" && typeof result.then === "function") {
-        return result.then((resolved) => {
-          span.setAttribute("result", JSON.stringify(truncate(resolved)));
-          span.end(resolved);
-          logFn("quit", options?.recordResult ? resolved : undefined, callerLocation);
-          return resolved;
-        }, (rejected) => {
-          span.setAttribute("error", String(rejected));
-          span.end(undefined, rejected instanceof Error ? rejected : new Error(String(rejected)));
-          logFn("error", rejected.message, callerLocation);
-          throw rejected;
-        });
-      }
-      span.setAttribute("result", JSON.stringify(truncate(result)));
-      span.end(result);
-      logFn("quit", options?.recordResult ? result : undefined, callerLocation);
-      return result;
-    } catch (error) {
-      span.setAttribute("error", String(error));
-      span.end(undefined, error instanceof Error ? error : new Error(String(error)));
-      logFn("error", error.message, callerLocation);
-      throw error;
-    }
-  };
-}
-var init_decorator = __esm(() => {
-  init_tracer_provider();
-  init_logger();
-});
-
-// 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/llm/types.ts
-import { z } from "zod";
-var ProviderCapabilitiesSchema = z.object({
-  reasoning: z.boolean().optional(),
-  toolcall: z.boolean().optional(),
-  interleaved: z.object({
-    field: z.string()
-  }).optional(),
-  thinkingInText: z.object({
-    enabled: z.boolean().optional(),
-    tags: z.array(z.string()).optional(),
-    removeFromOutput: z.boolean().optional()
-  }).optional()
-});
-var ModelLimitsSchema = z.object({
-  contextWindow: z.number().int().positive(),
-  compactionThreshold: z.number().min(0).max(1).optional(),
-  maxOutputTokens: z.number().int().positive().optional()
-});
-var ProviderConfigSchema = z.object({
-  provider: z.string(),
-  name: z.string().optional(),
-  description: z.string().optional(),
-  apiKey: z.string(),
-  baseURL: z.string().optional(),
-  models: z.array(z.string()).optional(),
-  defaultModel: z.string().optional(),
-  temperature: z.number().min(0).max(2).optional(),
-  maxTokens: z.number().int().positive().optional(),
-  capabilities: ProviderCapabilitiesSchema.optional(),
-  limits: z.record(z.string(), ModelLimitsSchema).optional(),
-  providerOptions: z.record(z.unknown()).optional(),
-  options: z.record(z.unknown()).optional()
-});
-var LLMDefaultConfigSchema = z.object({
-  temperature: z.number().min(0).max(2).optional(),
-  maxTokens: z.number().int().positive().optional()
-});
-var LLMConfigSchema = z.object({
-  default: LLMDefaultConfigSchema.optional(),
-  defaultModel: z.string().optional(),
-  providers: z.record(z.string(), ProviderConfigSchema),
-  defaultProvider: z.string(),
-  temperature: z.number().min(0).max(2).default(0.7),
-  maxTokens: z.number().int().positive().optional(),
-  topP: z.number().min(0).max(1).optional(),
-  stream: z.boolean().default(true),
-  options: z.record(z.unknown()).optional()
-});
-// packages/core/src/env/llm/provider.ts
-class ProviderManager {
-  providers = new Map;
-  async initialize(config) {
-    this.providers.clear();
-    for (const [id, providerConfig] of Object.entries(config.providers)) {
-      const resolvedConfig = await this.resolveProviderConfig(providerConfig);
-      const provider = this.createProvider(id, resolvedConfig);
-      this.providers.set(id, provider);
-    }
-  }
-  getProvider(id) {
-    return this.providers.get(id);
-  }
-  listProviders() {
-    return Array.from(this.providers.values());
-  }
-  async resolveProviderConfig(config) {
-    return {
-      ...config,
-      apiKey: await this.resolveEnvVar(config.apiKey),
-      baseURL: config.baseURL ? await this.resolveEnvVar(config.baseURL) : undefined
-    };
-  }
-  async resolveEnvVar(value) {
-    const envVarPattern = /\$\{([^}]+)\}/g;
-    const matches = [...value.matchAll(envVarPattern)];
-    if (matches.length === 0) {
-      return value;
-    }
-    let result = value;
-    for (const match of matches) {
-      const varName = match[1];
-      const envValue = process.env[varName];
-      if (envValue === undefined) {
-        throw new Error(`Environment variable ${varName} is not set`);
-      }
-      result = result.replace(match[0], envValue);
-    }
-    return result;
-  }
-  createProvider(id, config) {
-    return {
-      id,
-      provider: null,
-      models: config.models || []
-    };
-  }
-  createAIProvider(id, config, createFn) {
-    const providerInstance = createFn(config.apiKey, config.baseURL);
-    return {
-      id,
-      provider: providerInstance,
-      models: config.models || []
-    };
-  }
-}
-// packages/core/src/env/llm/transform.ts
-class LLMTransform {
-  normalizeMessages(messages, providerType) {
-    return messages.map((msg) => {
-      switch (providerType) {
-        case "anthropic":
-          return this.normalizeForAnthropic(msg);
-        case "openai":
-        case "openai-compatible":
-        default:
-          return this.normalizeForOpenAI(msg);
-      }
-    });
-  }
-  normalizeForOpenAI(msg) {
-    return {
-      role: msg.role,
-      content: msg.content,
-      toolCalls: msg.toolCalls,
-      toolCallId: msg.toolCallId
-    };
-  }
-  normalizeForAnthropic(msg) {
-    if (msg.role === "tool") {
-      return {
-        role: "user",
-        content: msg.content,
-        toolCallId: msg.toolCallId
-      };
-    }
-    return msg;
-  }
-  extractToolSchema(tool) {
-    return {
-      name: tool.name,
-      description: tool.description,
-      parameters: tool.parameters
-    };
-  }
-  zodToJsonSchema(schema) {
-    return this.extractZodSchema(schema);
-  }
-  extractZodSchema(schema) {
-    const def = schema._def;
-    if (!def)
-      return {};
-    const typeName = def.typeName || "";
-    const type = def.type || "";
-    const isV3 = typeName.startsWith("Zod");
-    const isV4 = !isV3 && type !== "";
-    if (isV3 && typeName === "ZodObject" || isV4 && type === "object") {
-      let shape;
-      if (isV3) {
-        const shapeFn = def.shape;
-        shape = shapeFn ? shapeFn() : undefined;
-      } else {
-        shape = def.shape;
-      }
-      const properties = {};
-      const required = [];
-      if (shape) {
-        for (const [key, value] of Object.entries(shape)) {
-          properties[key] = this.extractZodSchema(value);
-          let isOptional = false;
-          if (isV3) {
-            const zodType = value;
-            isOptional = typeof zodType.isOptional === "function" ? zodType.isOptional() : false;
-          } else {
-            const innerDef = value._def;
-            isOptional = innerDef?.defaultValue !== undefined;
-          }
-          if (!isOptional) {
-            required.push(key);
-          }
-        }
-      }
-      return {
-        type: "object",
-        properties,
-        ...required.length > 0 ? { required } : {}
-      };
-    }
-    if (isV3 && typeName === "ZodEnum" || isV4 && type === "enum") {
-      const zodV3Enum = def;
-      const zodV4Enum = def;
-      const values = zodV3Enum.values || Object.values(zodV4Enum.entries || {});
-      return {
-        enum: values
-      };
-    }
-    if (isV3 && typeName === "ZodNativeEnum") {
-      const enumDef = def;
-      const values = Object.values(enumDef.values || {});
-      return {
-        enum: values
-      };
-    }
-    if (isV3 && typeName === "ZodString" || isV4 && type === "string") {
-      return { type: "string" };
-    }
-    if (isV3 && (typeName === "ZodNumber" || typeName === "ZodBigInt") || isV4 && (type === "number" || type === "bigint")) {
-      return { type: "number" };
-    }
-    if (isV3 && typeName === "ZodBoolean" || isV4 && type === "boolean") {
-      return { type: "boolean" };
-    }
-    if (isV3 && typeName === "ZodArray" || isV4 && type === "array") {
-      if (isV3) {
-        const itemsType = def.type;
-        if (itemsType) {
-          return {
-            type: "array",
-            items: this.extractZodSchema(itemsType)
-          };
-        }
-      }
-      const shape = def.shape;
-      if (shape) {
-        const itemKey = Object.keys(shape)[0];
-        const items = this.extractZodSchema(shape[itemKey]);
-        return {
-          type: "array",
-          items
-        };
-      }
-      return {
-        type: "array",
-        items: {}
-      };
-    }
-    if (isV3 && typeName === "ZodOptional" || isV4 && type === "optional") {
-      if (isV3) {
-        const innerType = def.innerType;
-        if (innerType) {
-          return this.extractZodSchema(innerType);
-        }
-      }
-      const shape = def.shape;
-      if (shape) {
-        const innerKey = Object.keys(shape).find((k) => k !== "undefinedType");
-        if (innerKey) {
-          return this.extractZodSchema(shape[innerKey]);
-        }
-      }
-      return {};
-    }
-    if (isV3 && typeName === "ZodNullable") {
-      const innerType = def.innerType;
-      if (innerType) {
-        return this.extractZodSchema(innerType);
-      }
-    }
-    return {};
-  }
-  formatToolResult(result) {
-    return {
-      role: "tool",
-      tool_call_id: result.toolCallId,
-      content: result.result,
-      ...result.isError ? { isError: true } : {}
-    };
-  }
-  parseToolArguments(args) {
-    if (!args || args.trim() === "") {
-      return {};
-    }
-    try {
-      return JSON.parse(args);
-    } catch {
-      return {};
-    }
-  }
-  serializeToolArguments(args) {
-    return JSON.stringify(args);
-  }
-}
-// packages/core/src/env/llm/invoke.ts
-init_logger();
-import { randomUUID } from "crypto";
-import { streamText, jsonSchema } from "ai";
-import { createOpenAI } from "@ai-sdk/openai";
-import { createAnthropic } from "@ai-sdk/anthropic";
-import { createGoogleGenerativeAI } from "@ai-sdk/google";
-import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
-import { zodToJsonSchema } from "zod-to-json-schema";
-var logger = createLogger("llm:invoke");
-var MAX_RETRIES = 3;
-function parseModelString(model) {
-  if (!model) {
-    return { providerId: "openai", modelId: "gpt-4o" };
-  }
-  const parts = model.split("/");
-  if (parts.length >= 2) {
-    return { providerId: parts[0], modelId: parts.slice(1).join("/") };
-  }
-  return { providerId: "openai", modelId: model };
-}
-function extractUsageInfo(usage) {
-  if (!usage)
-    return;
-  if (usage.inputTokens && typeof usage.inputTokens === "object") {
-    return {
-      promptTokens: usage.inputTokens.total ?? 0,
-      completionTokens: usage.outputTokens?.total ?? 0,
-      totalTokens: usage.totalTokens ?? 0
-    };
-  }
-  if (typeof usage.promptTokens === "number") {
-    return {
-      promptTokens: usage.promptTokens,
-      completionTokens: usage.completionTokens ?? 0,
-      totalTokens: usage.totalTokens ?? 0
-    };
-  }
-  if (usage.inputTokenDetails || usage.outputTokenDetails) {
-    return {
-      promptTokens: usage.inputTokenDetails?.tokens ?? 0,
-      completionTokens: usage.outputTokenDetails?.tokens ?? 0,
-      totalTokens: usage.totalTokens ?? 0
-    };
-  }
-  if (usage.raw && typeof usage.raw.total_tokens === "number") {
-    return {
-      promptTokens: 0,
-      completionTokens: 0,
-      totalTokens: usage.raw.total_tokens
-    };
-  }
-  return;
-}
-function convertToSDKMessages(messages) {
-  return messages.map((msg) => {
-    if (msg.role === "assistant" && msg.toolCalls && msg.toolCalls.length > 0) {
-      const toolCallParts = msg.toolCalls.map((tc) => {
-        let input = {};
-        if (tc.function?.arguments) {
-          if (typeof tc.function.arguments === "string") {
-            try {
-              input = JSON.parse(tc.function.arguments);
-            } catch {
-              input = tc.function.arguments;
-            }
-          } else {
-            input = tc.function.arguments;
-          }
-        } else if (tc.arguments) {
-          if (typeof tc.arguments === "string") {
-            try {
-              input = JSON.parse(tc.arguments);
-            } catch {
-              input = tc.arguments;
-            }
-          } else {
-            input = tc.arguments;
-          }
-        }
-        return {
-          type: "tool-call",
-          toolCallId: tc.id,
-          toolName: tc.function?.name || tc.name || "unknown",
-          input
-        };
-      });
-      return {
-        role: "assistant",
-        content: toolCallParts
-      };
-    }
-    if (msg.role === "tool") {
-      if (!msg.toolCallId) {
-        logger.warn("Tool message missing toolCallId", { msg });
-      }
-      let outputValue = "";
-      const content = msg.content;
-      if (typeof content === "string") {
-        outputValue = content;
-      } else if (Array.isArray(content)) {
-        const toolResultPart = content.find((p) => p?.type === "tool-result");
-        if (toolResultPart) {
-          outputValue = typeof toolResultPart.output === "string" ? toolResultPart.output : JSON.stringify(toolResultPart.output);
-        } else {
-          outputValue = JSON.stringify(content);
-        }
-      } else {
-        outputValue = JSON.stringify(content);
-      }
-      const converted = {
-        role: "tool",
-        content: [{
-          type: "tool-result",
-          toolCallId: msg.toolCallId || "unknown",
-          toolName: msg.name || "unknown",
-          output: {
-            type: "text",
-            value: outputValue
-          }
-        }]
-      };
-      return converted;
-    }
-    return msg;
-  });
-}
-function convertToolsToSDK(tools) {
-  const result = {};
-  for (const tool of tools) {
-    const jsonSchemaObj = extractToolSchema(tool.parameters);
-    result[tool.name] = {
-      description: tool.description || "",
-      inputSchema: jsonSchema(jsonSchemaObj)
-    };
-  }
-  return result;
-}
-function extractToolSchema(parameters) {
-  if (parameters && typeof parameters === "object" && "_def" in parameters) {
-    const zodSchema = parameters;
-    const schema = zodToJsonSchema(zodSchema, "zod");
-    if ("$ref" in schema && schema.definitions) {
-      const def = schema.definitions.zod;
-      if (def && def.type === "object" && def.properties) {
-        return {
-          type: "object",
-          properties: def.properties,
-          required: def.required,
-          additionalProperties: true
-        };
-      }
-    }
-    return schema;
-  }
-  return parameters;
-}
-function generateProviderOptions(providerType, options) {
-  const result = {
-    providerOptions: {}
-  };
-  if (options.temperature !== undefined) {
-    result.temperature = options.temperature;
-  }
-  if (options.maxTokens !== undefined) {
-    result.maxTokens = options.maxTokens;
-  }
-  switch (providerType) {
-    case "anthropic":
-      break;
-    case "openai-compatible":
-      result.providerOptions.includeUsage = true;
-      break;
-  }
-  return result;
-}
-function createEnvEventEmitter(env, context) {
-  if (!env) {
-    return null;
-  }
-  return (event) => {
-    try {
-      env.pushEnvEvent({
-        id: randomUUID(),
-        type: `llm.${event.type}`,
-        timestamp: Date.now(),
-        metadata: {
-          source: "llm.invoke",
-          sessionId: context?.sessionId,
-          messageId: context?.messageId
-        },
-        payload: event
-      });
-    } catch (err) {
-      logger.warn("Failed to push env event", { error: String(err), eventType: event.type });
-    }
-  };
-}
-function processThinkingStream(textDelta, config, state) {
-  if (!config.enabled || !textDelta) {
-    return {
-      cleanedText: textDelta,
-      isThinkingTagOpen: state.isOpen,
-      currentThinkingContent: state.content,
-      reasoningEvents: []
-    };
-  }
-  const tags = config.tags || ["thinking"];
-  let remainingText = textDelta;
-  const reasoningEvents = [];
-  let isOpen = state.isOpen;
-  let currentContent = state.content;
-  for (const tag of tags) {
-    const openTag = `<${tag}>`;
-    const closeTag = `</${tag}>`;
-    let text = remainingText;
-    let result = "";
-    const openIndex = text.toLowerCase().indexOf(openTag.toLowerCase());
-    const closeIndex = text.toLowerCase().indexOf(closeTag.toLowerCase());
-    if (openIndex !== -1 && (closeIndex === -1 || openIndex < closeIndex)) {
-      const beforeOpen = text.substring(0, openIndex);
-      const afterOpen = text.substring(openIndex + openTag.length);
-      if (!isOpen) {
-        isOpen = true;
-        currentContent = "";
-        reasoningEvents.push("");
-      }
-      result += beforeOpen;
-      const innerCloseIndex = afterOpen.toLowerCase().indexOf(closeTag.toLowerCase());
-      if (innerCloseIndex !== -1) {
-        const thinkingContent = afterOpen.substring(0, innerCloseIndex);
-        const afterClose = afterOpen.substring(innerCloseIndex + closeTag.length);
-        currentContent += thinkingContent;
-        reasoningEvents.push(currentContent);
-        isOpen = false;
-        currentContent = "";
-        result += afterClose;
-      } else {
-        currentContent += afterOpen;
-        reasoningEvents.push(currentContent);
-        result += "";
-      }
-      remainingText = result;
-    } else if (closeIndex !== -1) {
-      const beforeClose = text.substring(0, closeIndex);
-      const afterClose = text.substring(closeIndex + closeTag.length);
-      if (isOpen) {
-        currentContent += beforeClose;
-        reasoningEvents.push(currentContent);
-        isOpen = false;
-        currentContent = "";
-        result = afterClose;
-      } else {
-        result = text;
-      }
-      remainingText = result;
-    }
-  }
-  return {
-    cleanedText: remainingText,
-    isThinkingTagOpen: isOpen,
-    currentThinkingContent: currentContent,
-    reasoningEvents
-  };
-}
-async function invoke(config, options, ctx) {
-  try {
-    const emitToEnv = createEnvEventEmitter(options.env, options.context);
-    const { providerId, modelId } = parseModelString(options.model || config.model);
-    const provider = createProviderInstance(providerId, config.apiKey, config.baseURL);
-    if (!provider) {
-      throw new Error(`Failed to create provider for ${providerId}`);
-    }
-    const messages = convertToSDKMessages(options.messages);
-    const toolCallIds = new Set;
-    const assistantToolCalls = [];
-    const toolResultIds = [];
-    for (const msg of messages) {
-      if (msg.role === "assistant") {
-        const assistantContent = Array.isArray(msg.content) ? msg.content : [];
-        for (const part of assistantContent) {
-          if (part && typeof part === "object" && part.type === "tool-call") {
-            const tc = part.toolCall || part;
-            assistantToolCalls.push({ id: tc.id, name: tc.name || tc.function && tc.function.name });
-            toolCallIds.add(tc.id);
-          }
-        }
-      }
-      if (msg.role === "tool") {
-        const toolContent = Array.isArray(msg.content) ? msg.content : [];
-        for (const part of toolContent) {
-          if (part && typeof part === "object" && part.type === "tool-result") {
-            toolResultIds.push(part.toolCallId);
-          }
-        }
-      }
-    }
-    const missingToolResults = assistantToolCalls.filter((tc) => !toolResultIds.includes(tc.id));
-    const orphanedToolResults = toolResultIds.filter((id) => !toolCallIds.has(id));
-    if (assistantToolCalls.length > 0 || toolResultIds.length > 0) {
-      logger.debug("[invoke] ToolCallId matching analysis:", {
-        assistantToolCalls,
-        toolResultIds,
-        missingToolResults: missingToolResults.length > 0 ? missingToolResults : "none",
-        orphanedToolResults: orphanedToolResults.length > 0 ? orphanedToolResults : "none"
-      });
-    }
-    const tools = options.tools && options.tools.length > 0 ? convertToolsToSDK(options.tools) : undefined;
-    const providerOptions = generateProviderOptions(providerId, {
-      temperature: options.temperature,
-      maxTokens: options.maxTokens
-    });
-    const model = `${providerId}/${modelId}`;
-    if (emitToEnv) {
-      emitToEnv({ type: "start", metadata: { model } });
-    }
-    const streamTextOptions = {
-      model: provider.languageModel(modelId),
-      messages,
-      tools,
-      temperature: providerOptions.temperature,
-      maxTokens: providerOptions.maxTokens,
-      abortSignal: ctx.abort,
-      maxRetries: MAX_RETRIES,
-      streamOptions: {
-        includeUsage: true
-      },
-      allowSystemInMessages: true
-    };
-    const result = await streamText(streamTextOptions);
-    let fullContent = "";
-    let reasoningContent = "";
-    const toolCalls = [];
-    let usageInfo;
-    let isThinkingTagOpen = false;
-    let currentThinkingContent = "";
-    for await (const part of result.fullStream) {
-      const streamPart = part;
-      switch (streamPart.type) {
-        case "text-delta":
-          const textDelta = streamPart.text;
-          const thinkingConfig = config.options?.thinkingInText;
-          if (thinkingConfig?.enabled) {
-            const thinkingResult = processThinkingStream(textDelta, thinkingConfig, {
-              isOpen: isThinkingTagOpen,
-              content: currentThinkingContent
-            });
-            isThinkingTagOpen = thinkingResult.isThinkingTagOpen;
-            currentThinkingContent = thinkingResult.currentThinkingContent;
-            fullContent += thinkingResult.cleanedText;
-            for (const reasoningDelta2 of thinkingResult.reasoningEvents) {
-              reasoningContent = reasoningDelta2;
-              if (emitToEnv) {
-                emitToEnv({ type: "reasoning", content: reasoningContent });
-              }
-            }
-            if (emitToEnv) {
-              emitToEnv({ type: "text", content: fullContent, delta: thinkingResult.cleanedText });
-            }
-          } else {
-            fullContent += textDelta;
-            if (emitToEnv) {
-              emitToEnv({ type: "text", content: fullContent, delta: textDelta });
-            }
-          }
-          break;
-        case "reasoning-delta":
-          const reasoningDelta = streamPart.text;
-          reasoningContent += reasoningDelta;
-          if (emitToEnv) {
-            emitToEnv({ type: "reasoning", content: reasoningContent });
-          }
-          break;
-        case "tool-call":
-          const toolInput = streamPart.input;
-          const toolCallId = streamPart.toolCallId;
-          const toolName = streamPart.toolName;
-          toolCalls.push({
-            id: toolCallId,
-            name: toolName,
-            args: toolInput
-          });
-          if (emitToEnv) {
-            emitToEnv({
-              type: "tool_call",
-              toolCall: {
-                id: toolCallId,
-                name: toolName,
-                arguments: JSON.stringify(toolInput)
-              }
-            });
-          }
-          break;
-        case "finish-step":
-          const stepUsage = extractUsageInfo(streamPart.usage);
-          if (stepUsage) {
-            usageInfo = stepUsage;
-          }
-          break;
-        case "error":
-          throw streamPart.error;
-        case "finish":
-          usageInfo = extractUsageInfo(streamPart.totalUsage);
-          if (!usageInfo && streamPart.usage) {
-            usageInfo = extractUsageInfo(streamPart.usage);
-          }
-          break;
-      }
-    }
-    if (emitToEnv) {
-      emitToEnv({
-        type: "completed",
-        content: fullContent,
-        metadata: {
-          model,
-          usage: usageInfo
-        }
-      });
-    }
-    if (toolCalls.length > 0) {
-      const firstToolCall = toolCalls[0];
-      return {
-        toolCallId: firstToolCall.id,
-        result: JSON.stringify({
-          content: fullContent,
-          reasoning: reasoningContent || undefined,
-          tool_calls: toolCalls.map((tc) => ({
-            id: tc.id,
-            function: {
-              name: tc.name,
-              arguments: JSON.stringify(tc.args)
-            }
-          }))
-        })
-      };
-    }
-    return {
-      toolCallId: "invoke-" + Date.now(),
-      result: JSON.stringify({
-        content: fullContent,
-        reasoning: reasoningContent || undefined,
-        usage: usageInfo,
-        model
-      })
-    };
-  } catch (error) {
-    logger.error("Error during invocation", {
-      error: error instanceof Error ? error.message : String(error),
-      stack: error instanceof Error ? error.stack : undefined
-    });
-    return {
-      toolCallId: "error-" + Date.now(),
-      result: error instanceof Error ? error.message : String(error),
-      isError: true
-    };
-  }
-}
-function createProviderInstance(providerId, apiKey, baseURL) {
-  try {
-    if (providerId === "openai") {
-      const openai = createOpenAI({
-        apiKey,
-        baseURL
-      });
-      return openai;
-    }
-    if (providerId === "anthropic") {
-      const anthropic = createAnthropic({
-        apiKey
-      });
-      return anthropic;
-    }
-    if (providerId === "google") {
-      const google = createGoogleGenerativeAI({
-        apiKey
-      });
-      return google;
-    }
-    const defaultProvider = createOpenAICompatible({
-      name: providerId,
-      apiKey,
-      baseURL: baseURL || "",
-      includeUsage: true
-    });
-    return defaultProvider;
-  } catch (error) {
-    logger.error(`Failed to create provider ${providerId}`, { error: String(error) });
-    return null;
-  }
-}
-async function invokeNonStream(config, options, ctx) {
-  const { providerId, modelId } = parseModelString(options.model || config.model);
-  const provider = createProviderInstance(providerId, config.apiKey, config.baseURL);
-  if (!provider) {
-    throw new Error(`Failed to create provider for ${providerId}`);
-  }
-  const messages = convertToSDKMessages(options.messages);
-  const tools = options.tools && options.tools.length > 0 ? convertToolsToSDK(options.tools) : undefined;
-  const providerOptions = generateProviderOptions(providerId, {
-    temperature: options.temperature,
-    maxTokens: options.maxTokens
-  });
-  const { generateText } = await import("ai");
-  const genTextFn = generateText;
-  const result = await genTextFn({
-    model: provider.languageModel(modelId),
-    messages,
-    tools,
-    temperature: providerOptions.temperature,
-    maxTokens: providerOptions.maxTokens,
-    abortSignal: ctx.abort,
-    allowSystemInMessages: true
-  });
-  const usage = result.usage;
-  const usageInfo = usage ? {
-    promptTokens: usage.promptTokens ?? 0,
-    completionTokens: usage.completionTokens ?? 0,
-    totalTokens: usage.totalTokens ?? 0
-  } : undefined;
-  if (options.env) {
-    options.env.pushEnvEvent({
-      id: randomUUID(),
-      type: "llm.completed",
-      timestamp: Date.now(),
-      metadata: {
-        source: "llm.invokeNonStream",
-        sessionId: options.context?.sessionId,
-        messageId: options.context?.messageId
-      },
-      payload: {
-        type: "completed",
-        content: result.text,
-        metadata: {
-          model: `${providerId}/${modelId}`,
-          usage: usageInfo
-        }
-      }
-    });
-  }
-  return {
-    content: result.text,
-    finishReason: result.finishReason === "stop" ? "stop" : "tool-calls",
-    model: `${providerId}/${modelId}`,
-    usage: usageInfo
-  };
-}
-function createInvokeConfig(model, apiKey, baseURL) {
-  return {
-    model,
-    apiKey,
-    baseURL
-  };
-}
-// packages/core/src/env/llm/hooks.ts
-class LLMHookManager {
-  registrations = [];
-  register(type, handler, name) {
-    const registration = {
-      type,
-      name
-    };
-    switch (type) {
-      case "before-invoke":
-        registration.beforeInvoke = handler;
-        break;
-      case "after-invoke":
-        registration.afterInvoke = handler;
-        break;
-      case "stream":
-        registration.stream = handler;
-        break;
-    }
-    this.registrations.push(registration);
-    this.registerToGlobal(registration);
-  }
-  registerToGlobal(reg) {
-    const hookName = `llm:${reg.name || `anon-${reg.type}-${this.registrations.indexOf(reg)}`}`;
-    if (reg.beforeInvoke) {
-      globalHookManager.register(LLMHookPoints.BEFORE_INVOKE, {
-        name: hookName,
-        priority: 0,
-        execute: async (ctx) => {
-          await reg.beforeInvoke(ctx.data);
-        }
-      });
-    }
-    if (reg.afterInvoke) {
-      globalHookManager.register(LLMHookPoints.AFTER_INVOKE, {
-        name: hookName,
-        priority: 0,
-        execute: async (ctx) => {
-          const { request, providerId, model, metadata, result } = ctx.data;
-          await reg.afterInvoke({ request, providerId, model, metadata }, result);
-        }
-      });
-    }
-    if (reg.stream) {
-      globalHookManager.register(LLMHookPoints.ON_STREAM, {
-        name: hookName,
-        priority: 0,
-        execute: async (ctx) => {
-          const { request, providerId, model, metadata, event } = ctx.data;
-          await reg.stream({ request, providerId, model, metadata }, event);
-        }
-      });
-    }
-  }
-  unregister(hook) {
-    const index = this.registrations.findIndex((h) => {
-      return h.beforeInvoke === hook || h.afterInvoke === hook || h.stream === hook;
-    });
-    if (index !== -1) {
-      const reg = this.registrations[index];
-      this.unregisterFromGlobal(reg);
-      this.registrations.splice(index, 1);
-    }
-  }
-  unregisterFromGlobal(reg) {
-    const hookName = `llm:${reg.name || `anon-${reg.type}`}`;
-    globalHookManager.unregister(LLMHookPoints.BEFORE_INVOKE, hookName);
-    globalHookManager.unregister(LLMHookPoints.AFTER_INVOKE, hookName);
-    globalHookManager.unregister(LLMHookPoints.ON_STREAM, hookName);
-  }
-  unregisterByName(name) {
-    const hookName = `llm:${name}`;
-    globalHookManager.unregister(LLMHookPoints.BEFORE_INVOKE, hookName);
-    globalHookManager.unregister(LLMHookPoints.AFTER_INVOKE, hookName);
-    globalHookManager.unregister(LLMHookPoints.ON_STREAM, hookName);
-    this.registrations = this.registrations.filter((h) => h.name !== name);
-  }
-  unregisterByType(type) {
-    const filtered = this.registrations.filter((h) => h.type === type);
-    for (const reg of filtered) {
-      this.unregisterFromGlobal(reg);
-    }
-    this.registrations = this.registrations.filter((h) => h.type !== type);
-  }
-  clear() {
-    for (const reg of this.registrations) {
-      this.unregisterFromGlobal(reg);
-    }
-    this.registrations = [];
-  }
-  getHooks() {
-    return [...this.registrations];
-  }
-  getHooksByType(type) {
-    return this.registrations.filter((h) => h.type === type);
-  }
-}
-
-class LLMHooks {
-  hookManager = new LLMHookManager;
-  register(type, handler, name) {
-    this.hookManager.register(type, handler, name);
-  }
-  unregister(hook) {
-    this.hookManager.unregister(hook);
-  }
-  unregisterByName(name) {
-    this.hookManager.unregisterByName(name);
-  }
-  unregisterByType(type) {
-    this.hookManager.unregisterByType(type);
-  }
-  clear() {
-    this.hookManager.clear();
-  }
-  getHooks() {
-    return this.hookManager.getHooks();
-  }
-  getHooksByType(type) {
-    return this.hookManager.getHooksByType(type);
-  }
-  async executeBeforeInvoke(context) {
-    await globalHookManager.execute(LLMHookPoints.BEFORE_INVOKE, context);
-  }
-  async executeAfterInvoke(context, result) {
-    await globalHookManager.execute(LLMHookPoints.AFTER_INVOKE, { ...context, result });
-  }
-  async executeStream(context, event) {
-    await globalHookManager.execute(LLMHookPoints.ON_STREAM, { ...context, event });
-  }
-}
-// 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/llm/llm.ts
-init_logger();
-init_decorator();
-
-// 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/errors.ts
-var ErrorCodes = {
-  AGENT_NOT_FOUND: "AGENT_001",
-  AGENT_RUN_FAILED: "AGENT_002",
-  AGENT_TIMEOUT: "AGENT_003",
-  AGENT_CONFIG_INVALID: "AGENT_004",
-  TOOL_NOT_FOUND: "TOOL_001",
-  TOOL_DISABLED: "TOOL_002",
-  TOOL_EXECUTION_FAILED: "TOOL_003",
-  TOOL_VALIDATION_FAILED: "TOOL_004",
-  LLM_PROVIDER_NOT_FOUND: "LLM_001",
-  LLM_INVOCATION_FAILED: "LLM_002",
-  LLM_TIMEOUT: "LLM_003",
-  LLM_CONFIG_INVALID: "LLM_004",
-  COMPONENT_NOT_FOUND: "COMP_001",
-  COMPONENT_INIT_FAILED: "COMP_002",
-  COMPONENT_NOT_RUNNING: "COMP_003",
-  CONFIG_NOT_FOUND: "CONFIG_001",
-  CONFIG_INVALID: "CONFIG_002",
-  CONFIG_SOURCE_ERROR: "CONFIG_003",
-  CONTEXT_THRESHOLD_EXCEEDED: "CTX_001",
-  CONTEXT_COMPACTION_FAILED: "CTX_002",
-  MCP_INIT_FAILED: "MCP_001",
-  MCP_SERVER_ERROR: "MCP_002",
-  MCP_TOOL_ERROR: "MCP_003"
-};
-
-class RoyError extends Error {
-  code;
-  details;
-  constructor(message, code, details) {
-    super(message);
-    this.code = code;
-    this.details = details;
-    this.name = this.constructor.name;
-    Error.captureStackTrace(this, this.constructor);
-  }
-}
-
-class AgentError extends RoyError {
-  constructor(message, code = ErrorCodes.AGENT_NOT_FOUND, details) {
-    super(message, code, details);
-  }
-}
-
-class ToolError extends RoyError {
-  toolName;
-  constructor(message, code = ErrorCodes.TOOL_NOT_FOUND, toolName, details) {
-    super(message, code, details);
-    this.toolName = toolName;
-  }
-}
-
-class LLMError extends RoyError {
-  provider;
-  constructor(message, code = ErrorCodes.LLM_INVOCATION_FAILED, provider, details) {
-    super(message, code, details);
-    this.provider = provider;
-  }
-}
-
-class ComponentError extends RoyError {
-  componentName;
-  constructor(message, code = ErrorCodes.COMPONENT_NOT_FOUND, componentName, details) {
-    super(message, code, details);
-    this.componentName = componentName;
-  }
-}
-
-class ContextError extends RoyError {
-  sessionId;
-  usage;
-  contextWindow;
-  constructor(message, code = ErrorCodes.CONTEXT_THRESHOLD_EXCEEDED, sessionId, usage, contextWindow, details) {
-    super(message, code, details);
-    this.sessionId = sessionId;
-    this.usage = usage;
-    this.contextWindow = contextWindow;
-  }
-}
-function isRoyError(error) {
-  return error instanceof RoyError;
-}
-function getErrorCode(error) {
-  if (error instanceof RoyError) {
-    return error.code;
-  }
-  return;
-}
-
-// packages/core/src/env/llm/llm.ts
-var logger2 = createLogger("llm");
-
-class LLMComponent extends BaseComponent {
-  name = "llm";
-  version = "2.0.0";
-  configComponent;
-  configWatcher;
-  constructor() {
-    super();
-  }
-  async init(config) {
-    await super.init(config);
-    const options = config.options;
-    if (!options?.configComponent) {
-      throw new Error("ConfigComponent is required for LLMComponent initialization");
-    }
-    this.configComponent = options.configComponent;
-    await this.registerConfig(options);
-    this.setStatus("running");
-  }
-  async registerConfig(options) {
-    const configComponent = options.configComponent;
-    if (!configComponent)
-      return;
-    const { configPath, envPrefix, config } = options;
-    const prefix = envPrefix !== undefined ? envPrefix : "LLM";
-    const llmKeys = [
-      "llm.defaultModel",
-      "llm.defaultProvider",
-      "llm.temperature",
-      "llm.maxTokens",
-      "llm.topP",
-      "llm.stream",
-      "llm.providers",
-      "llm.limits",
-      "llm.capabilities"
-    ];
-    let fileSource = null;
-    if (configPath) {
-      configComponent.registerSource({
-        type: "file",
-        relativePath: configPath,
-        optional: true,
-        watch: false
-      });
-      configComponent.ensureSourcesCreated?.();
-      const sources = configComponent.getSources?.() || [];
-      fileSource = sources.find((s) => s.name === "file");
-      if (fileSource) {
-        for (const key of llmKeys) {
-          const value = fileSource.read?.(key);
-          if (value !== undefined) {
-            await configComponent.set(key, value);
-          }
-        }
-      }
-    }
-    configComponent.registerSource({
-      type: "env",
-      envPrefix: prefix,
-      priority: 20,
-      watch: false
-    });
-    configComponent.ensureSourcesCreated?.();
-    const sourcesAfterEnv = configComponent.getSources?.() || [];
-    const envSource = sourcesAfterEnv.find((s) => s.name === "env");
-    if (envSource) {
-      for (const key of llmKeys) {
-        const value = envSource.read?.(key);
-        if (value !== undefined) {
-          await configComponent.set(key, value);
-        }
-      }
-    }
-    for (const key of llmKeys) {
-      const envKey = toEnvKey(key, prefix);
-      const value = process.env[envKey];
-      if (value !== undefined) {
-        await configComponent.set(key, value);
-      }
-    }
-    const loadedKeys = new Set(llmKeys);
-    for (const envKey of Object.keys(process.env)) {
-      const configKey = envKeyToConfigKey(envKey, prefix, "llm");
-      if (!configKey)
-        continue;
-      if (loadedKeys.has(configKey))
-        continue;
-      loadedKeys.add(configKey);
-      const value = process.env[envKey];
-      if (value !== undefined) {
-        await configComponent.set(configKey, value);
-      }
-    }
-    if (config) {
-      const flatConfig = this.flattenConfig(config);
-      for (const [key, value] of Object.entries(flatConfig)) {
-        await configComponent.set(key, value);
-      }
-    }
-    this.registerConfigWatcher(configComponent);
-  }
-  flattenConfig(obj, prefix = "llm") {
-    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") {
-      logger2.debug("ConfigComponent does not support watch, hot reload disabled");
-      return;
-    }
-    this.configWatcher = configComponent.watch("llm.*", (event) => {
-      this.onConfigChange(event);
-    });
-    logger2.debug("Config hot reload watcher registered for llm.*");
-  }
-  onConfigChange(event) {
-    logger2.info(`LLM config changed: ${event.key}`);
-    if (event.key === "llm.providers" || event.key.startsWith("llm.providers.")) {
-      logger2.info(`LLM provider config changed, will use new config on next call`);
-    } else if (event.key === "llm.defaultModel") {
-      logger2.info(`LLM default model changed to: ${event.newValue}`);
-    } else if (event.key === "llm.defaultProvider") {
-      logger2.info(`LLM default provider changed to: ${event.newValue}`);
-    } else {
-      logger2.debug(`LLM config updated: ${event.key}`);
-    }
-  }
-  async onStart() {
-    if (this._status === "stopped") {
-      this.setStatus("running");
-    }
-  }
-  async onStop() {
-    this.configWatcher?.();
-    this.configWatcher = undefined;
-    this.setStatus("stopped");
-  }
-  getLLMConfig(key, defaultValue) {
-    if (this.configComponent) {
-      const value = this.configComponent.get(key);
-      if (value !== undefined) {
-        return value;
-      }
-    }
-    return defaultValue;
-  }
-  resolveRequest(request) {
-    const defaultModel = this.getLLMConfig("llm.defaultModel", "gpt-4o");
-    const defaultProvider = this.getLLMConfig("llm.defaultProvider", "openai");
-    const defaultTemperature = this.getLLMConfig("llm.temperature", 0.7);
-    const defaultMaxTokens = this.getLLMConfig("llm.maxTokens", 4096);
-    const defaultTopP = this.getLLMConfig("llm.topP", 1);
-    const model = request.model || defaultModel;
-    const providerId = request.providerId || defaultProvider;
-    const apiKey = this.getApiKey(providerId);
-    if (!apiKey) {
-      throw new Error(`API key not found for provider ${providerId}. Set providers.${providerId}.apiKey in config, or use \${env://...} protocol in config file.`);
-    }
-    const messages = request.messages.map((msg) => ({
-      role: msg.role,
-      content: msg.content,
-      name: msg.name,
-      toolCallId: msg.toolCallId,
-      toolCalls: msg.toolCalls
-    }));
-    return {
-      providerId,
-      model,
-      invokeConfig: {
-        model: `${providerId}/${model}`,
-        apiKey,
-        baseURL: this.getProvider(providerId)?.baseURL
-      },
-      messages,
-      temperature: request.temperature ?? defaultTemperature,
-      maxTokens: request.maxTokens ?? defaultMaxTokens,
-      topP: request.topP ?? defaultTopP,
-      abortSignal: request.abortSignal
-    };
-  }
-  async invoke(request) {
-    const startTime = Date.now();
-    if (this._status !== "running") {
-      throw new Error("LLMComponent is not running");
-    }
-    const ctx = this.resolveRequest(request);
-    let output = {
-      content: "",
-      reasoning: undefined,
-      finishReason: "stop"
-    };
-    let finishUsage;
-    const result = await invoke(ctx.invokeConfig, {
-      messages: ctx.messages,
-      model: ctx.invokeConfig.model,
-      temperature: ctx.temperature,
-      maxTokens: ctx.maxTokens,
-      tools: request.tools,
-      env: this.env,
-      context: {
-        sessionId: request.context?.sessionId,
-        messageId: request.context?.messageId
-      }
-    }, { abort: ctx.abortSignal });
-    if (result.isError) {
-      throw new Error(result.result);
-    }
-    try {
-      const parsed = JSON.parse(result.result);
-      output.content = parsed.content || "";
-      output.reasoning = parsed.reasoning || undefined;
-      output.finishReason = parsed.tool_calls?.length ? "tool-calls" : "stop";
-      output.toolCalls = parsed.tool_calls || [];
-      if (parsed.usage) {
-        finishUsage = {
-          promptTokens: parsed.usage.promptTokens ?? parsed.usage.inputTokens ?? 0,
-          completionTokens: parsed.usage.completionTokens ?? parsed.usage.outputTokens ?? 0,
-          totalTokens: parsed.usage.totalTokens ?? 0
-        };
-      }
-      output.usage = finishUsage;
-    } catch {
-      output.content = result.result;
-      output.finishReason = "stop";
-    }
-    const latencyMs = Date.now() - startTime;
-    if (!request.skipThresholdCheck) {
-      const sessionId = request.context?.sessionId;
-      const contextError = this.checkContextThreshold(finishUsage, ctx.providerId, ctx.model, sessionId);
-      if (contextError) {
-        throw contextError;
-      }
-    }
-    return {
-      output,
-      providerId: ctx.providerId,
-      model: ctx.model,
-      latencyMs
-    };
-  }
-  getApiKey(providerId) {
-    const providers = this.getLLMConfig("llm.providers", {});
-    return providers?.[providerId]?.apiKey;
-  }
-  getProvider(id) {
-    const providers = this.getLLMConfig("llm.providers", {});
-    return providers?.[id];
-  }
-  listProviders() {
-    const providers = this.getLLMConfig("llm.providers", {});
-    return Object.keys(providers || {});
-  }
-  getModelLimits(providerId, modelId) {
-    const provider = this.getProvider(providerId);
-    if (!provider?.limits)
-      return;
-    const targetModel = modelId || provider.defaultModel;
-    if (!targetModel)
-      return;
-    return provider.limits[targetModel];
-  }
-  getContextThresholdConfig(providerId, modelId) {
-    const defaults = {
-      contextWindow: 128000,
-      thresholdRatio: 0.9
-    };
-    const limits = this.getModelLimits(providerId, modelId);
-    if (!limits)
-      return defaults;
-    return {
-      contextWindow: limits.contextWindow || defaults.contextWindow,
-      thresholdRatio: limits.compactionThreshold ?? defaults.thresholdRatio
-    };
-  }
-  checkContextThreshold(usage, providerId, modelId, sessionId) {
-    if (!usage)
-      return;
-    const config = this.getContextThresholdConfig(providerId, modelId);
-    const threshold = config.contextWindow * config.thresholdRatio;
-    if (usage.totalTokens >= threshold) {
-      return new ContextError(`Context threshold exceeded: ${usage.totalTokens}/${config.contextWindow} (${(usage.totalTokens / config.contextWindow * 100).toFixed(1)}%)`, ErrorCodes.CONTEXT_THRESHOLD_EXCEEDED, sessionId, {
-        promptTokens: usage.promptTokens ?? 0,
-        completionTokens: usage.completionTokens ?? 0,
-        totalTokens: usage.totalTokens
-      }, config.contextWindow);
-    }
-    return;
-  }
-}
-__legacyDecorateClassTS([
-  TracedAs("llm.component.invoke", { recordParams: true, recordResult: true, log: true })
-], LLMComponent.prototype, "invoke", null);
-export {
-  parseModelString,
-  invokeNonStream,
-  invoke,
-  createInvokeConfig,
-  ProviderManager,
-  ProviderConfigSchema,
-  ProviderCapabilitiesSchema,
-  ModelLimitsSchema,
-  LLMTransform,
-  LLMHooks,
-  LLMDefaultConfigSchema,
-  LLMConfigSchema,
-  LLMComponent
-};