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

package/dist/env/agent/index.js

@@ -0,0 +1,3035 @@
+// @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 logger = 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) {
+        logger.info(`${prefix} ${msg}: ${truncateString(data)}`, { callerLocation: originalFnLocation });
+      } else {
+        logger.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/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/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/agent/agent-component.ts
+init_logger();
+import { z } from "zod";
+
+// 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/agent/agent-config-registration.ts
+var AGENT_DEFAULTS = {
+  "agent.defaultAgent.maxIterations": 200,
+  "agent.defaultAgent.temperature": 0,
+  "agent.defaultAgent.timeout": 300000,
+  "agent.defaultAgent.streaming": false,
+  "agent.defaultAgent.filterHistory": false
+};
+var AGENT_CONFIG_REGISTRATION = {
+  name: "agent",
+  sources: [
+    { type: "env", envPrefix: "AGENT", priority: 20, watch: false }
+  ],
+  keys: [
+    { key: "agent.defaultAgent.model", sources: ["env", "file"] },
+    { key: "agent.defaultAgent.maxIterations", sources: ["env", "file"] },
+    { key: "agent.defaultAgent.temperature", sources: ["env", "file"] },
+    { key: "agent.defaultAgent.timeout", sources: ["env", "file"] },
+    { key: "agent.defaultAgent.systemPrompt", sources: ["env", "file"] },
+    { key: "agent.defaultAgent.streaming", sources: ["env", "file"] },
+    { key: "agent.defaultAgent.tools", sources: ["env", "file"] },
+    { key: "agent.defaultAgent.maxErrorRetries", sources: ["env", "file"] },
+    { key: "agent.defaultAgent.filterHistory", sources: ["env", "file"] }
+  ]
+};
+
+// packages/core/src/env/agent/agent-component.ts
+init_decorator();
+
+// packages/core/src/env/session/session-message-converter.ts
+init_decorator();
+import { randomUUID } from "crypto";
+var DEFAULT_REASONING_BUDGET_TOKENS = 1e4;
+
+class SessionMessageConverter {
+  toModelMessage(msg) {
+    if (msg.role === "assistant") {
+      const content = [];
+      for (const part of msg.parts || []) {
+        if (part.type === "text") {
+          const textPart = part;
+          content.push({
+            type: "text",
+            text: textPart.content,
+            ...textPart.synthetic !== undefined && { synthetic: textPart.synthetic }
+          });
+        } else if (part.type === "reasoning") {
+          const reasoningPart = part;
+          content.push({
+            type: "reasoning",
+            text: reasoningPart.content,
+            reasoningType: reasoningPart.reasoningType
+          });
+        } else if (part.type === "tool-call") {
+          const toolPart = part;
+          let parsedArgs = {};
+          if (typeof toolPart.arguments === "string") {
+            try {
+              parsedArgs = JSON.parse(toolPart.arguments);
+            } catch {
+              parsedArgs = { _raw: toolPart.arguments };
+            }
+          } else {
+            parsedArgs = toolPart.arguments;
+          }
+          content.push({
+            type: "tool-call",
+            toolCallId: toolPart.toolCallId,
+            toolName: toolPart.toolName,
+            input: parsedArgs
+          });
+        } else if (part.type === "file") {
+          const filePart = part;
+          content.push({
+            type: "file",
+            url: filePart.url,
+            mimeType: filePart.mime,
+            filename: filePart.filename
+          });
+        } else if (part.type === "tool-result" || part.type === "checkpoint") {} else {
+          console.debug(`[session-message-converter] Skipping unsupported part type in assistant: ${part.type}`);
+        }
+      }
+      if (content.length === 0 && msg.content) {
+        return { role: "assistant", content: msg.content };
+      }
+      return { role: "assistant", content };
+    }
+    if (msg.role === "tool") {
+      const toolPart = msg.parts?.find((p) => p.type === "tool-result");
+      return {
+        role: "tool",
+        content: [{
+          type: "tool-result",
+          toolCallId: toolPart?.toolCallId || "",
+          toolName: toolPart?.toolName || "",
+          output: toolPart?.output || msg.content || ""
+        }]
+      };
+    }
+    return {
+      role: msg.role,
+      content: msg.content || ""
+    };
+  }
+  fromModelMessage(aiMsg, options) {
+    const parts = [];
+    const content = typeof aiMsg.content === "string" || Array.isArray(aiMsg.content) ? aiMsg.content : "";
+    let hasToolCallPart = false;
+    let hasToolResultPart = false;
+    if (typeof content === "string") {
+      parts.push({ type: "text", content });
+    } else if (Array.isArray(content)) {
+      for (const part of content) {
+        const p = part;
+        if (p.type === "text") {
+          parts.push({ type: "text", content: p.text || "" });
+        } else if (p.type === "reasoning") {
+          parts.push({
+            type: "reasoning",
+            content: p.text || "",
+            reasoningType: p.reasoningType,
+            state: "completed"
+          });
+        } else if (p.type === "tool-call") {
+          hasToolCallPart = true;
+          parts.push({
+            type: "tool-call",
+            toolCallId: p.toolCallId,
+            toolName: p.toolName,
+            arguments: p.input,
+            state: "pending"
+          });
+        } else if (p.type === "tool-result") {
+          hasToolResultPart = true;
+          parts.push({
+            type: "tool-result",
+            toolCallId: p.toolCallId,
+            toolName: p.toolName,
+            output: typeof p.output === "string" ? p.output : JSON.stringify(p.output),
+            state: "completed"
+          });
+        } else if (p.type === "file") {
+          parts.push({
+            type: "file",
+            mime: p.mimeType || "application/octet-stream",
+            url: p.url,
+            filename: p.filename
+          });
+        } else {
+          console.debug(`[session-message-converter] Unknown part type: ${p.type}`);
+        }
+      }
+    }
+    let metadataType;
+    if (aiMsg.role === "assistant" && hasToolCallPart) {
+      metadataType = "tool_call";
+    } else if (aiMsg.role === "tool") {
+      metadataType = "tool_result";
+    }
+    const result = {
+      id: options?.messageID || `msg_${randomUUID()}`,
+      sessionID: options?.sessionID || "",
+      role: aiMsg.role,
+      timestamp: Date.now(),
+      parts,
+      content: typeof content === "string" ? content : ""
+    };
+    if (metadataType) {
+      result.metadata = { type: metadataType };
+    }
+    return result;
+  }
+  sessionToHistory(messages) {
+    return messages.filter((msg) => !msg.metadata?.isArchived && !msg.isArchived).map((msg) => this.toModelMessage(msg));
+  }
+  extractProviderOptions(msg) {
+    const options = {};
+    const reasoningParts = msg.parts?.filter((p) => p.type === "reasoning");
+    if (reasoningParts && reasoningParts.length > 0) {
+      const firstReasoning = reasoningParts[0];
+      if (firstReasoning.reasoningType) {
+        options.openai = {
+          thinking: {
+            type: firstReasoning.reasoningType === "effort" ? "extended" : "core"
+          }
+        };
+        if (firstReasoning.reasoningType === "effort") {
+          const budgetTokens = firstReasoning.metadata?.tokenCount || DEFAULT_REASONING_BUDGET_TOKENS;
+          options.anthropic = {
+            thinking: {
+              type: "enabled",
+              budgetTokens
+            }
+          };
+        }
+      }
+    }
+    return options;
+  }
+  migrateMessage(oldMsg) {
+    if (oldMsg.parts && oldMsg.parts.length > 0) {
+      const firstPart = oldMsg.parts[0];
+      if (firstPart && typeof firstPart.type === "string" && firstPart.type.length > 0) {
+        return {
+          ...oldMsg,
+          content: oldMsg.content || ""
+        };
+      }
+    }
+    return {
+      ...oldMsg,
+      content: oldMsg.content || "",
+      parts: oldMsg.content ? [{ type: "text", content: oldMsg.content }] : []
+    };
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("session-message-converter.toModelMessage", { recordParams: true, recordResult: true, log: true })
+], SessionMessageConverter.prototype, "toModelMessage", null);
+__legacyDecorateClassTS([
+  TracedAs("session-message-converter.fromModelMessage", { recordParams: true, recordResult: true, log: true })
+], SessionMessageConverter.prototype, "fromModelMessage", null);
+
+// packages/core/src/env/agent/agent-component.ts
+init_workflow_hil();
+var logger = createLogger("agent:component");
+function toLLMMessage(msg) {
+  let content;
+  let toolCallId;
+  let toolName;
+  let toolCalls;
+  if (typeof msg.content === "string") {
+    content = msg.content;
+    if (msg.role === "tool") {
+      toolCallId = msg.toolCallId;
+      toolName = msg.toolName;
+    }
+    if (msg.role === "assistant" && msg.toolCalls) {
+      toolCalls = msg.toolCalls;
+    }
+  } else if (Array.isArray(msg.content)) {
+    if (msg.role === "tool") {
+      const toolResult = msg.content.find((part) => part.type === "tool-result");
+      const output = toolResult?.output;
+      if (typeof output === "string") {
+        content = output;
+      } else if (output && typeof output === "object" && "value" in output) {
+        content = output.value?.toString() || "";
+      } else {
+        content = JSON.stringify(output) || "";
+      }
+      toolCallId = toolResult?.toolCallId;
+      toolName = toolResult?.toolName;
+    } else {
+      const textParts = msg.content.filter((part) => part.type === "text");
+      const toolCallParts = msg.content.filter((part) => part.type === "tool-call");
+      content = textParts.map((part) => part.text || "").join("");
+      if (msg.role === "assistant" && toolCallParts.length > 0) {
+        toolCalls = toolCallParts.map((part) => {
+          const argsString = typeof part.input === "string" ? part.input : JSON.stringify(part.input || {});
+          const toolName2 = part.toolName || "unknown";
+          return {
+            id: part.toolCallId,
+            name: toolName2,
+            arguments: argsString,
+            function: {
+              name: toolName2,
+              arguments: argsString
+            }
+          };
+        });
+      }
+    }
+  } else {
+    content = "";
+  }
+  return {
+    role: msg.role,
+    content,
+    ...toolCallId ? { toolCallId } : {},
+    ...toolName ? { name: toolName } : {},
+    ...toolCalls && toolCalls.length > 0 ? { toolCalls } : {}
+  };
+}
+var DEFAULT_AGENT_CONFIG = {
+  type: "primary",
+  maxIterations: 200,
+  maxErrorRetries: 3,
+  doomLoopThreshold: 5,
+  toolTimeout: 60000,
+  toolRetries: 3,
+  filterHistory: false
+};
+var AgentInstanceSchema = z.object({
+  type: z.enum(["primary", "sub"]).default("primary"),
+  systemPrompt: z.string().optional(),
+  behaviorSpecId: z.string().optional(),
+  model: z.string().optional(),
+  maxIterations: z.number().default(200),
+  maxErrorRetries: z.number().default(3),
+  doomLoopThreshold: z.number().default(5),
+  allowedTools: z.array(z.string()).optional(),
+  deniedTools: z.array(z.string()).optional(),
+  toolTimeout: z.number().default(60000),
+  toolRetries: z.number().default(3),
+  filterHistory: z.boolean().default(false)
+});
+var AgentComponentConfigSchema = z.object({
+  defaultAgent: AgentInstanceSchema
+});
+
+class AgentComponent extends BaseComponent {
+  name = "agent";
+  version = "1.0.0";
+  agents = new Map;
+  config;
+  llmComponent = null;
+  toolComponent = null;
+  aborted = new Map;
+  abortControllers = new Map;
+  defaultTools = [];
+  doomLoopCaches = new Map;
+  configComponent;
+  configWatcher;
+  messageConverter = new SessionMessageConverter;
+  _constructorConfig;
+  runCounter = 0;
+  constructor(options = {}) {
+    super();
+    this._constructorConfig = options.config;
+    this.config = {
+      defaultAgent: {
+        ...DEFAULT_AGENT_CONFIG,
+        ...options.config?.defaultAgent
+      }
+    };
+  }
+  async init(config) {
+    await super.init(config);
+    const options = config.options;
+    if (!options?.configComponent) {
+      throw new Error("ConfigComponent is required for AgentComponent 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 ?? "AGENT";
+    configComponent.registerComponent(AGENT_CONFIG_REGISTRATION);
+    if (configPath) {
+      configComponent.registerSource({
+        type: "file",
+        relativePath: configPath,
+        optional: true,
+        watch: false
+      });
+    }
+    configComponent.registerSource({
+      type: "env",
+      envPrefix: prefix,
+      priority: 20,
+      watch: false
+    });
+    await configComponent.load("agent");
+    for (const envKey of Object.keys(process.env)) {
+      const configKey = envKeyToConfigKey(envKey, prefix, "agent");
+      if (!configKey)
+        continue;
+      const value = process.env[envKey];
+      if (value !== undefined) {
+        await configComponent.set(configKey, value);
+      }
+    }
+    for (const [key, value] of Object.entries(AGENT_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);
+      }
+    }
+    const constructorDefaultAgent = this._constructorConfig?.defaultAgent;
+    this.config.defaultAgent = {
+      maxIterations: constructorDefaultAgent?.maxIterations ?? configComponent.get("agent.defaultAgent.maxIterations") ?? 200,
+      maxErrorRetries: constructorDefaultAgent?.maxErrorRetries ?? configComponent.get("agent.defaultAgent.maxErrorRetries") ?? 3,
+      doomLoopThreshold: constructorDefaultAgent?.doomLoopThreshold ?? configComponent.get("agent.defaultAgent.doomLoopThreshold") ?? 5,
+      toolTimeout: constructorDefaultAgent?.toolTimeout ?? configComponent.get("agent.defaultAgent.toolTimeout") ?? 60000,
+      toolRetries: constructorDefaultAgent?.toolRetries ?? configComponent.get("agent.defaultAgent.toolRetries") ?? 3,
+      filterHistory: constructorDefaultAgent?.filterHistory ?? configComponent.get("agent.defaultAgent.filterHistory") ?? false,
+      type: constructorDefaultAgent?.type ?? configComponent.get("agent.defaultAgent.type") ?? "primary",
+      systemPrompt: constructorDefaultAgent?.systemPrompt ?? configComponent.get("agent.defaultAgent.systemPrompt"),
+      model: constructorDefaultAgent?.model ?? configComponent.get("agent.defaultAgent.model"),
+      behaviorSpecId: constructorDefaultAgent?.behaviorSpecId ?? configComponent.get("agent.defaultAgent.behaviorSpecId")
+    };
+    logger.info(`[registerConfig] Synced config from ConfigComponent: maxIterations=${this.config.defaultAgent.maxIterations}`);
+    this.registerConfigWatcher(configComponent);
+  }
+  flattenConfig(obj, prefix = "agent") {
+    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("agent.*", (event) => {
+      this.onConfigChange(event);
+    });
+  }
+  onConfigChange(event) {
+    logger.info(`Agent config changed: ${event.key}`, {
+      oldValue: event.oldValue,
+      newValue: event.newValue
+    });
+  }
+  async onStop() {
+    logger.info("[AgentComponent] Stopping and cleaning up resources...");
+    for (const [name, agent] of this.agents) {
+      if (agent.status === "running" || agent.status === "idle") {
+        this.abort(name);
+        logger.debug(`[AgentComponent] Aborted agent: ${name}`);
+      }
+    }
+    this.abortControllers.clear();
+    this.doomLoopCaches.clear();
+    if (this.configWatcher) {
+      this.configWatcher();
+      this.configWatcher = undefined;
+    }
+    this.agents.clear();
+    this.setStatus("stopped");
+    logger.info("[AgentComponent] Cleanup completed");
+  }
+  refreshDependencies() {
+    if (this.env) {
+      const llm = this.env.getComponent("llm");
+      const tool = this.env.getComponent("tool");
+      this.llmComponent = llm ? llm : null;
+      this.toolComponent = tool ? tool : null;
+      logger.debug("[refreshDependencies] AgentComponent refreshed", {
+        hasLLM: !!this.llmComponent,
+        hasTool: !!this.toolComponent
+      });
+    }
+  }
+  getAgent(agentName) {
+    return this.agents.get(agentName);
+  }
+  listAgents() {
+    return Array.from(this.agents.values());
+  }
+  addRemainingToolResults(ctx, allToolCalls, processedCount, reason) {
+    const remainingToolCalls = allToolCalls.slice(processedCount);
+    for (const tc of remainingToolCalls) {
+      const tcName = tc.function?.name || tc.name || "unknown";
+      this.pushMessage(ctx, {
+        role: "tool",
+        content: [{
+          type: "tool-result",
+          toolCallId: tc.id,
+          toolName: tcName,
+          output: JSON.stringify({ error: reason })
+        }]
+      });
+    }
+  }
+  registerAgent(name, config) {
+    const mergedConfig = {
+      type: config.type ?? this.config.defaultAgent.type,
+      name,
+      maxIterations: config.maxIterations ?? this.config.defaultAgent.maxIterations,
+      maxErrorRetries: config.maxErrorRetries ?? this.config.defaultAgent.maxErrorRetries,
+      doomLoopThreshold: config.doomLoopThreshold ?? this.config.defaultAgent.doomLoopThreshold,
+      toolTimeout: config.toolTimeout ?? this.config.defaultAgent.toolTimeout,
+      toolRetries: config.toolRetries ?? this.config.defaultAgent.toolRetries,
+      systemPrompt: config.systemPrompt ?? this.config.defaultAgent.systemPrompt,
+      model: config.model ?? this.config.defaultAgent.model,
+      behaviorSpecId: config.behaviorSpecId ?? this.config.defaultAgent.behaviorSpecId,
+      allowedTools: config.allowedTools ?? this.config.defaultAgent.allowedTools,
+      deniedTools: config.deniedTools ?? this.config.defaultAgent.deniedTools,
+      filterHistory: config.filterHistory ?? this.config.defaultAgent.filterHistory
+    };
+    const instance = {
+      name,
+      config: mergedConfig,
+      status: "idle",
+      plugins: new Map
+    };
+    this.agents.set(name, instance);
+    logger.info(`Agent registered: ${name}`, { type: instance.config.type });
+    return instance;
+  }
+  unregisterAgent(name) {
+    const deleted = this.agents.delete(name);
+    if (deleted) {
+      logger.info(`Agent unregistered: ${name}`);
+    }
+    return deleted;
+  }
+  registerPlugin(agentName, plugin) {
+    const agent = this.agents.get(agentName);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentName}`);
+    }
+    agent.plugins.set(plugin.name, plugin);
+    logger.info(`Plugin registered: ${plugin.name} to ${agentName}`, {
+      hooks: plugin.hooks.map((h) => h.point)
+    });
+  }
+  unregisterPlugin(agentName, pluginName) {
+    const agent = this.agents.get(agentName);
+    if (!agent) {
+      return false;
+    }
+    const deleted = agent.plugins.delete(pluginName);
+    if (deleted) {
+      logger.info(`Plugin unregistered: ${pluginName} from ${agentName}`);
+    }
+    return deleted;
+  }
+  setDefaultTools(tools) {
+    this.defaultTools = tools;
+  }
+  getAvailableTools(agent, context) {
+    let tools = [...this.defaultTools];
+    logger.debug(`[getAvailableTools] After defaultTools: ${tools.length} tools`, {
+      toolNames: tools.map((t) => t.name)
+    });
+    if (this.toolComponent?.listTools) {
+      const componentTools = this.toolComponent.listTools();
+      tools = [...tools, ...componentTools];
+      logger.debug(`[getAvailableTools] After adding componentTools: ${tools.length} tools`, {
+        componentToolNames: componentTools.map((t) => t.name)
+      });
+    }
+    const allowedTools = context?.allowedTools ?? agent.config.allowedTools;
+    const deniedTools = context?.deniedTools ?? agent.config.deniedTools;
+    logger.debug(`[getAvailableTools] Filtering: allowed=${allowedTools}, denied=${deniedTools}`);
+    if (allowedTools?.length) {
+      tools = tools.filter((t) => allowedTools.includes(t.name));
+      logger.debug(`[getAvailableTools] After allowedTools filter: ${tools.length} tools`, {
+        toolNames: tools.map((t) => t.name)
+      });
+    }
+    if (deniedTools?.length) {
+      tools = tools.filter((t) => !deniedTools.includes(t.name));
+      logger.debug(`[getAvailableTools] After deniedTools filter: ${tools.length} tools`, {
+        toolNames: tools.map((t) => t.name)
+      });
+    }
+    logger.debug(`[getAvailableTools] Final tools: ${tools.length}`, {
+      toolNames: tools.map((t) => t.name)
+    });
+    return tools;
+  }
+  async run(agentName, query, context) {
+    return this._run(agentName, query, context);
+  }
+  pushMessage(hookCtx, message) {
+    hookCtx.messages.push(message);
+    this.notifyMessageAdded(message);
+  }
+  async _run(agentName, query, context) {
+    this.refreshDependencies();
+    const agent = this.getAgent(agentName);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentName}`);
+    }
+    const runId = `${agentName}:${++this.runCounter}`;
+    logger.info(`Starting agent run: ${agentName} (runId=${runId})`, { query: query.substring(0, 100) });
+    agent.status = "running";
+    this.aborted.set(runId, false);
+    const abortController = new AbortController;
+    this.abortControllers.set(runId, abortController);
+    if (!this.doomLoopCaches.has(runId)) {
+      this.doomLoopCaches.set(runId, new Map);
+    }
+    const effectiveContext = {
+      ...context,
+      agentType: agent.config.type,
+      model: agent.config.model,
+      abort: abortController.signal
+    };
+    const result = {
+      iterations: 0,
+      toolCalls: []
+    };
+    const hookCtx = {
+      agent,
+      iteration: 0,
+      maxIterations: agent.config.maxIterations,
+      messages: [],
+      tools: this.getAvailableTools(agent, effectiveContext),
+      systemPrompt: agent.config.systemPrompt || "You are a helpful assistant.",
+      context: effectiveContext
+    };
+    let historyMessageCount = 0;
+    if (effectiveContext.sessionId) {
+      try {
+        const sessionComponent = this.env.getComponent("session");
+        if (sessionComponent) {
+          const filterHistory = effectiveContext.filterHistory ?? agent.config.filterHistory ?? false;
+          const messages = await this.getConversationHistory(sessionComponent, effectiveContext.sessionId, { minUserMessages: 100, filterHistory });
+          hookCtx.messages = messages.map((msg) => this.messageConverter.toModelMessage(msg));
+          historyMessageCount = hookCtx.messages.length;
+        }
+      } catch (err) {
+        logger.warn(`Failed to load session history: ${err}`);
+      }
+    }
+    this.pushEnvEvent({
+      type: "agent.start",
+      payload: {
+        sessionId: effectiveContext.sessionId,
+        model: effectiveContext.model
+      }
+    });
+    this.pushMessage(hookCtx, {
+      role: "user",
+      content: query
+    });
+    await this.executePluginHooks(agent, "agent:before.start", hookCtx);
+    if (hookCtx._stopped) {
+      return this.finalizeResult(result, hookCtx);
+    }
+    let iteration = 0;
+    let finalText;
+    while (iteration < agent.config.maxIterations) {
+      if (hookCtx._stopped) {
+        break;
+      }
+      if (this.aborted.get(runId)) {
+        hookCtx._stopped = true;
+        hookCtx._stopReason = "aborted";
+        break;
+      }
+      if (effectiveContext.abort?.aborted) {
+        hookCtx._stopped = true;
+        hookCtx._stopReason = "abort_signal";
+        break;
+      }
+      iteration++;
+      hookCtx.iteration = iteration;
+      result.iterations = iteration;
+      logger.debug(`Iteration ${iteration} started`);
+      this.doomLoopCaches.set(runId, new Map);
+      hookCtx.maxIterations = agent.config.maxIterations;
+      try {
+        logger.debug(`[ReAct] Iteration ${iteration} buildMessages result: ${hookCtx.messages.length} messages`);
+        await this.executePluginHooks(agent, "agent:before.llm", hookCtx);
+        if (hookCtx._stopped)
+          break;
+        const llmOutput = await this.invokeLLM(hookCtx);
+        hookCtx.llmOutput = llmOutput;
+        if (this.aborted.get(runId) || effectiveContext.abort?.aborted) {
+          hookCtx._stopped = true;
+          hookCtx._stopReason = "aborted";
+          break;
+        }
+        await this.executePluginHooks(agent, "agent:after.llm", hookCtx);
+        if (hookCtx._stopped)
+          break;
+        if (llmOutput.content && !llmOutput.toolCalls?.length) {
+          if (this.aborted.get(runId) || effectiveContext.abort?.aborted) {
+            hookCtx._stopped = true;
+            hookCtx._stopReason = "aborted";
+            break;
+          }
+          finalText = llmOutput.content;
+          this.pushMessage(hookCtx, {
+            role: "assistant",
+            content: llmOutput.content
+          });
+          break;
+        }
+        if (llmOutput.toolCalls?.length) {
+          const assistantParts = [];
+          if (llmOutput.content) {
+            assistantParts.push({
+              type: "text",
+              text: llmOutput.content
+            });
+          }
+          if (llmOutput.reasoning) {
+            assistantParts.push({
+              type: "reasoning",
+              text: llmOutput.reasoning,
+              reasoningType: "core"
+            });
+          }
+          for (const tc of llmOutput.toolCalls) {
+            let argsStr = "";
+            let argsObj = {};
+            if (tc.function?.arguments) {
+              if (typeof tc.function.arguments === "string") {
+                argsStr = tc.function.arguments;
+                try {
+                  argsObj = JSON.parse(argsStr);
+                } catch {
+                  argsObj = { _raw: argsStr };
+                }
+              } else {
+                argsObj = tc.function.arguments;
+                argsStr = JSON.stringify(argsObj);
+              }
+            } else if (tc.arguments) {
+              if (typeof tc.arguments === "string") {
+                argsStr = tc.arguments;
+                try {
+                  argsObj = JSON.parse(argsStr);
+                } catch {
+                  argsObj = { _raw: argsStr };
+                }
+              } else {
+                argsObj = tc.arguments;
+                argsStr = JSON.stringify(argsObj);
+              }
+            }
+            assistantParts.push({
+              type: "tool-call",
+              toolCallId: tc.id,
+              toolName: tc.function?.name || tc.name || "unknown",
+              input: argsObj,
+              toolCall: {
+                name: tc.function?.name || tc.name || "unknown",
+                arguments: argsStr
+              }
+            });
+          }
+          const assistantContent = llmOutput.content?.substring(0, 80) || "(no text)";
+          const toolCallNames = llmOutput.toolCalls?.map((tc) => tc.function?.name || tc.name).join(", ") || "none";
+          logger.debug(`[ReAct] Iteration ${iteration} Adding assistant message: text="${assistantContent}" toolCalls=[${toolCallNames}]`);
+          this.pushMessage(hookCtx, {
+            role: "assistant",
+            content: assistantParts
+          });
+          const allToolCalls = llmOutput.toolCalls;
+          let processedCount = 0;
+          for (const toolCall of allToolCalls) {
+            if (this.aborted.get(runId) || effectiveContext.abort?.aborted) {
+              hookCtx._stopped = true;
+              hookCtx._stopReason = "aborted";
+              this.addRemainingToolResults(hookCtx, allToolCalls, processedCount, "Execution aborted");
+              break;
+            }
+            const func = toolCall.function;
+            const tcName = func?.name || toolCall.name || "unknown";
+            const tcArgs = func?.arguments ? typeof func.arguments === "string" ? JSON.parse(func.arguments) : func.arguments : toolCall.arguments;
+            hookCtx.currentToolCall = {
+              id: toolCall.id,
+              name: tcName,
+              arguments: tcArgs
+            };
+            const doomKey = `${tcName}:${JSON.stringify(tcArgs)}`;
+            const agentCache = this.doomLoopCaches.get(runId) || new Map;
+            const doomCount = agentCache.get(doomKey) || 0;
+            if (doomCount >= agent.config.doomLoopThreshold) {
+              hookCtx.error = new Error(`Doom loop detected: ${tcName}`);
+              await this.executePluginHooks(agent, "on.error", hookCtx);
+              result.error = hookCtx.error.message;
+              this.addRemainingToolResults(hookCtx, allToolCalls, processedCount, "Execution aborted: Doom loop detected");
+              break;
+            }
+            agentCache.set(doomKey, doomCount + 1);
+            this.doomLoopCaches.set(runId, agentCache);
+            await this.executePluginHooks(agent, "agent:before.tool", hookCtx);
+            if (hookCtx._stopped) {
+              this.addRemainingToolResults(hookCtx, allToolCalls, processedCount, "Execution aborted by plugin hook");
+              break;
+            }
+            const toolResult = await this.executeTool(hookCtx);
+            hookCtx.toolResult = toolResult;
+            await this.executePluginHooks(agent, "agent:after.tool", hookCtx);
+            if (hookCtx._stopped) {
+              this.addRemainingToolResults(hookCtx, allToolCalls, processedCount + 1, "Execution aborted by plugin hook");
+              break;
+            }
+            const toolOutput = toolResult.success ? toolResult.result.output || "" : toolResult.result.error || "Unknown error";
+            const toolOutputPreview = typeof toolOutput === "string" ? toolOutput.substring(0, 50) : JSON.stringify(toolOutput).substring(0, 50);
+            logger.debug(`[ReAct] Iteration ${iteration} Adding tool message: tool=${toolResult.name} output="${toolOutputPreview}..."`);
+            this.pushMessage(hookCtx, {
+              role: "tool",
+              content: [{
+                type: "tool-result",
+                toolCallId: hookCtx.currentToolCall.id,
+                toolName: toolResult.name,
+                output: toolOutput
+              }]
+            });
+            result.toolCalls.push(hookCtx.currentToolCall);
+            processedCount++;
+          }
+          await this.executePluginHooks(agent, "agent:on.iteration", hookCtx);
+        }
+      } catch (error) {
+        logger.error(`Iteration ${iteration} error`, { error });
+        hookCtx.error = error instanceof Error ? error : new Error(String(error));
+        await this.executePluginHooks(agent, "agent:on.error", hookCtx);
+        if (!hookCtx._stopped) {
+          hookCtx._stopped = true;
+          if (error instanceof AskUserError) {
+            hookCtx._stopReason = "ask-user";
+            if (hookCtx.currentToolCall) {
+              this.pushMessage(hookCtx, {
+                role: "tool",
+                content: [{
+                  type: "tool-result",
+                  toolCallId: hookCtx.currentToolCall.id,
+                  toolName: "ask_user",
+                  output: JSON.stringify({
+                    error: "AskUserError",
+                    query: error.query,
+                    message: error.message
+                  })
+                }]
+              });
+            }
+            const errorInfo = {
+              query: error.query,
+              sessionId: error.sessionId,
+              nodeId: error.nodeId,
+              nodeType: error.nodeType
+            };
+            result.error = `__ASK_USER_ERROR__:${JSON.stringify(errorInfo)}`;
+          } else {
+            result.error = hookCtx.error.message;
+            if (error?.name === "AbortError") {
+              hookCtx._stopReason = hookCtx._stopReason || "aborted";
+            } else {
+              hookCtx._stopReason = "error";
+            }
+            if (hookCtx.currentToolCall) {
+              this.pushMessage(hookCtx, {
+                role: "tool",
+                content: [{
+                  type: "tool-result",
+                  toolCallId: hookCtx.currentToolCall.id,
+                  toolName: hookCtx.currentToolCall.name,
+                  output: JSON.stringify({ error: hookCtx.error.message })
+                }]
+              });
+            }
+          }
+        } else {
+          result.error = hookCtx.error.message;
+          if (hookCtx.currentToolCall) {
+            const errorMsg = hookCtx.error?.message || "Execution interrupted";
+            this.pushMessage(hookCtx, {
+              role: "tool",
+              content: [{
+                type: "tool-result",
+                toolCallId: hookCtx.currentToolCall.id,
+                toolName: hookCtx.currentToolCall.name,
+                output: JSON.stringify({ error: errorMsg })
+              }]
+            });
+          }
+        }
+        break;
+      }
+    }
+    result.finalText = finalText;
+    if (iteration >= agent.config.maxIterations && !result.finalText) {
+      result.finalText = "Maximum iterations reached.";
+    }
+    const reactContext = {
+      messages: hookCtx.messages,
+      sessionId: effectiveContext.sessionId,
+      summary: result.finalText
+    };
+    await this.executePluginHooks(agent, "agent:after.react", {
+      ...hookCtx,
+      ...reactContext
+    });
+    await this.executePluginHooks(agent, "agent:after.complete", hookCtx);
+    if (this.aborted.get(runId) === true || hookCtx._stopped) {
+      agent.status = "stopped";
+    } else {
+      agent.status = "idle";
+    }
+    this.aborted.delete(runId);
+    this.abortControllers.delete(runId);
+    if (result.error) {
+      this.pushEnvEvent({
+        type: "agent.error",
+        payload: {
+          error: result.error,
+          iterations: result.iterations,
+          stopReason: result.stopReason
+        }
+      });
+    } else {
+      this.pushEnvEvent({
+        type: "agent.completed",
+        payload: {
+          finalText: result.finalText,
+          iterations: result.iterations,
+          stopReason: result.stopReason
+        }
+      });
+    }
+    let newMessages = hookCtx.messages.slice(historyMessageCount);
+    logger.info(`Agent run completed: ${agentName}`, {
+      iterations: result.iterations,
+      hasError: !!result.error,
+      hookCtxMessages: hookCtx.messages.length,
+      historyMessageCount,
+      sessionId: effectiveContext.sessionId
+    });
+    await this.recordSessionMessages(effectiveContext.sessionId, newMessages);
+    return this.finalizeResult(result, hookCtx);
+  }
+  abort(agentName) {
+    for (const key of this.aborted.keys()) {
+      if (key.startsWith(agentName + ":")) {
+        this.aborted.set(key, true);
+      }
+    }
+    for (const [key, controller] of this.abortControllers) {
+      if (key.startsWith(agentName + ":")) {
+        controller.abort();
+        logger.debug(`[abort] AbortController.abort() called for run: ${key}`);
+      }
+    }
+    logger.info(`Agent aborted: ${agentName}`);
+  }
+  async buildMessages(ctx) {
+    const messages = [];
+    if (ctx.systemPrompt) {
+      messages.push({
+        role: "system",
+        content: ctx.systemPrompt
+      });
+    }
+    if (ctx.additionInfo) {
+      messages.push({
+        role: "user",
+        content: `\u989D\u5916\u4FE1\u606F\uFF1A
+${ctx.additionInfo}`
+      });
+    }
+    messages.push(...ctx.messages);
+    return messages;
+  }
+  async invokeLLM(ctx) {
+    logger.debug("[invokeLLM] Starting LLM invocation");
+    if (this.llmComponent?.invoke) {
+      const messages = await this.buildMessages(ctx);
+      const convertedMessages = messages.map(toLLMMessage);
+      logger.debug(`[invokeLLM] Calling LLMComponent.invoke with ${convertedMessages.length} messages`);
+      try {
+        const result = await this.llmComponent.invoke({
+          messages: convertedMessages,
+          tools: ctx.tools.map((t) => ({
+            name: t.name,
+            description: t.description || "",
+            parameters: t.parameters ?? {}
+          })),
+          model: ctx.context.model,
+          context: {
+            sessionId: ctx.context.sessionId,
+            messageId: ctx.context.messageId
+          },
+          abortSignal: ctx.context.abort
+        });
+        logger.debug("[invokeLLM] LLMComponent.invoke returned successfully");
+        return {
+          content: result.output?.content || "",
+          reasoning: result.output?.reasoning,
+          toolCalls: result.output?.toolCalls?.map((tc) => ({
+            id: tc.id,
+            function: tc.function ? {
+              name: tc.function.name,
+              arguments: typeof tc.function.arguments === "string" ? tc.function.arguments : JSON.stringify(tc.function.arguments)
+            } : undefined,
+            name: tc.name,
+            arguments: tc.arguments
+          })),
+          finishReason: result.output?.finishReason
+        };
+      } catch (error) {
+        logger.error("[invokeLLM] LLMComponent.invoke threw an error:", error);
+        throw error;
+      }
+    }
+    logger.warn("[invokeLLM] No LLMComponent available, using mock");
+    return {
+      content: "Mock response: Hello!",
+      finishReason: "stop"
+    };
+  }
+  async executeTool(ctx) {
+    const toolCall = ctx.currentToolCall;
+    const toolName = toolCall.function?.name || toolCall.name || "unknown";
+    logger.debug(`[executeTool] Looking for tool: "${toolName}"`);
+    logger.debug(`[executeTool] Available tools: [${ctx.tools.map((t) => t.name).join(", ")}]`);
+    const tool = ctx.tools.find((t) => t.name === toolName);
+    if (!tool) {
+      this.pushEnvEvent({
+        type: "tool.error",
+        payload: {
+          error: `Tool not found: ${toolName}`,
+          toolName
+        }
+      });
+      return {
+        id: toolCall.id,
+        name: toolName,
+        success: false,
+        result: {
+          success: false,
+          output: "",
+          error: `Tool not found: ${toolName}`
+        }
+      };
+    }
+    try {
+      const toolContext = {
+        session_id: ctx.context.sessionId,
+        message_id: ctx.context.messageId,
+        abort: ctx.context.abort,
+        workdir: ctx.context.metadata?.workdir,
+        metadata: ctx.context.metadata
+      };
+      const request = {
+        name: toolName,
+        args: toolCall.arguments,
+        context: toolContext
+      };
+      let result;
+      if (this.toolComponent?.execute) {
+        result = await this.toolComponent.execute(request);
+      } else {
+        logger.debug(`[executeTool] No ToolComponent available, executing tool directly`);
+        result = await tool.execute(toolCall.arguments, toolContext);
+      }
+      this.pushEnvEvent({
+        type: "tool.result",
+        payload: {
+          id: toolCall.id,
+          name: toolName,
+          result,
+          success: result.success
+        }
+      });
+      return {
+        id: toolCall.id,
+        name: toolName,
+        success: result.success,
+        result
+      };
+    } catch (error) {
+      if (error instanceof AskUserError) {
+        throw error;
+      }
+      this.pushEnvEvent({
+        type: "tool.error",
+        payload: {
+          error: error instanceof Error ? error.message : String(error),
+          toolName
+        }
+      });
+      return {
+        id: toolCall.id,
+        name: toolName,
+        success: false,
+        result: {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error)
+        }
+      };
+    }
+  }
+  async executePluginHooks(agent, point, ctx) {
+    const hooks = [];
+    for (const [name, plugin] of agent.plugins) {
+      for (const hook of plugin.hooks) {
+        if (hook.point === point) {
+          hooks.push({
+            plugin,
+            priority: hook.priority ?? 0,
+            execute: plugin.execute
+          });
+        }
+      }
+    }
+    hooks.sort((a, b) => b.priority - a.priority);
+    for (const { plugin, execute } of hooks) {
+      try {
+        const result = await execute(ctx);
+        if (!result.continue) {
+          ctx._stopped = true;
+          ctx._stopReason = `Plugin ${plugin.name} stopped execution`;
+          logger.info(`Hook ${point} stopped by plugin ${plugin.name}`);
+          break;
+        }
+        if (result.action) {
+          await this.handleHookAction(result.action, ctx);
+        }
+      } catch (error) {
+        logger.error(`Hook ${point} error in plugin ${plugin.name}`, { error });
+        ctx._errors = ctx._errors || [];
+        ctx._errors.push({
+          plugin: plugin.name,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+  async handleHookAction(action, ctx) {
+    switch (action.type) {
+      case "stop":
+        ctx._stopped = true;
+        ctx._stopReason = "stopped_by_hook";
+        break;
+      case "inject_message":
+        if (action.payload && typeof action.payload === "object") {
+          const msg = action.payload;
+          ctx.messages.push(msg);
+        }
+        break;
+      case "skip_tool":
+        ctx._pendingAction = action;
+        break;
+    }
+  }
+  notifyMessageAdded(message) {
+    logger.debug(`Message added: ${message.role}`);
+  }
+  finalizeResult(result, ctx) {
+    return {
+      ...result,
+      stopped: ctx._stopped,
+      stopReason: ctx._stopReason
+    };
+  }
+  async recordSessionMessages(sessionId, allMessages = []) {
+    if (!sessionId) {
+      return;
+    }
+    try {
+      const sessionComponent = this.env.getComponent("session");
+      if (!sessionComponent) {
+        logger.warn("SessionComponent not found, skipping session recording");
+        return;
+      }
+      for (const msg of allMessages) {
+        if (msg.role === "system") {
+          continue;
+        }
+        if (msg.role === "assistant" || msg.role === "tool") {
+          if (this.isEmptyMessage(msg.content)) {
+            continue;
+          }
+        }
+        await sessionComponent.addMessage(sessionId, this.messageConverter.fromModelMessage(msg, { sessionID: sessionId }));
+      }
+    } catch (err) {
+      logger.warn(`Failed to record session messages: ${err}`);
+    }
+  }
+  isEmptyMessage(content) {
+    if (content === null || content === undefined) {
+      return true;
+    }
+    if (typeof content === "string" && content.trim() === "") {
+      return true;
+    }
+    if (Array.isArray(content) && content.length === 0) {
+      return true;
+    }
+    return false;
+  }
+  pushEnvEvent(event) {
+    if (this.env && "pushEnvEvent" in this.env) {
+      try {
+        const fullEvent = {
+          id: `evt_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+          type: event.type,
+          timestamp: Date.now(),
+          metadata: {
+            source: "agent",
+            agent_name: this.name
+          },
+          payload: event.payload
+        };
+        this.env?.pushEnvEvent(fullEvent);
+      } catch (err) {
+        logger.warn(`[pushEnvEvent] Failed to push event: ${err}`);
+      }
+    }
+  }
+  async getConversationHistory(sessionComponent, sessionId, options = {}) {
+    const minUserMessages = options.minUserMessages ?? 100;
+    const filterHistory = options.filterHistory ?? false;
+    const ctx = await sessionComponent.getContext(sessionId, {
+      fullHistory: false,
+      minUserMessages
+    });
+    let messages = ctx.messages;
+    if (filterHistory) {
+      messages = messages.filter((msg) => {
+        if (msg.metadata?.type === "tool_call" || msg.metadata?.type === "tool_result") {
+          return false;
+        }
+        return msg.role === "user" || msg.role === "assistant";
+      });
+    }
+    return messages;
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("agent.component.run", { recordParams: true, recordResult: true, log: true })
+], AgentComponent.prototype, "_run", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.component.invokeLLM", { recordParams: true, recordResult: true, log: true })
+], AgentComponent.prototype, "invokeLLM", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.component.executeTool", { recordParams: true, recordResult: true, log: true })
+], AgentComponent.prototype, "executeTool", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.component.recordSessionMessages", { recordParams: true, recordResult: true, log: true })
+], AgentComponent.prototype, "recordSessionMessages", null);
+__legacyDecorateClassTS([
+  TracedAs("agent.component.getConversationHistory", { recordParams: true, recordResult: true, log: true })
+], AgentComponent.prototype, "getConversationHistory", null);
+// packages/core/src/env/agent/summary-agent.ts
+init_logger();
+init_decorator();
+var logger2 = createLogger("agent:summary");
+
+class SummaryAgent {
+  promptComponent;
+  llmComponent;
+  config;
+  constructor(promptComponent, llmComponent, config) {
+    this.promptComponent = promptComponent;
+    this.llmComponent = llmComponent;
+    this.config = {
+      type: "summary",
+      promptName: "session/compact",
+      maxIterations: 1,
+      model: undefined,
+      ...config
+    };
+  }
+  async generateCompactHint(options) {
+    const { messages, sessionContext } = options;
+    logger2.info("[SummaryAgent] Generating compact hint for session");
+    const formattedMessages = this.formatMessages(messages);
+    const systemPrompt = this.getHintGenerationSystemPrompt();
+    const userPrompt = this.buildHintGenerationUserPrompt(formattedMessages, sessionContext);
+    let response;
+    try {
+      response = await this.llmComponent.invoke({
+        messages: [
+          { role: "system", content: systemPrompt },
+          { role: "user", content: userPrompt }
+        ],
+        skipThresholdCheck: true
+      });
+    } catch (error) {
+      logger2.error(`[SummaryAgent] Hint generation LLM invoke failed: ${error}`);
+      throw new Error(`LLM invoke failed: ${error}`);
+    }
+    const responseContent = response.output?.content || response.content || "";
+    const hint = this.parseHintResponse(responseContent);
+    logger2.info("[SummaryAgent] Compact hint generated", { hint: hint.substring(0, 100) });
+    return {
+      hint,
+      rawResponse: responseContent
+    };
+  }
+  async run(options) {
+    const { messages, userContext, outputFormat, scenarioHint } = options;
+    logger2.info("[SummaryAgent] Starting checkpoint generation", {
+      hasScenarioHint: !!scenarioHint
+    });
+    const formattedMessages = this.formatMessages(messages);
+    const systemPrompt = this.getSystemPrompt(scenarioHint);
+    const userPrompt = this.buildUserPrompt(formattedMessages, userContext);
+    let response;
+    try {
+      response = await this.llmComponent.invoke({
+        messages: [
+          { role: "system", content: systemPrompt },
+          { role: "user", content: userPrompt }
+        ],
+        model: this.config.model,
+        skipThresholdCheck: true
+      });
+    } catch (error) {
+      logger2.error(`[SummaryAgent] LLM invoke failed: ${error}`);
+      throw new Error(`LLM invoke failed: ${error}`);
+    }
+    const responseContent = response.output?.content || response.content || "";
+    if (outputFormat === "json") {
+      const result = this.parseJsonResponse(responseContent);
+      logger2.info(`[SummaryAgent] Checkpoint generated: "${result.title}"`);
+      return {
+        title: result.title || "Untitled Checkpoint",
+        processKeyPoints: result.processKeyPoints || [],
+        currentState: result.currentState || "",
+        nextSteps: result.nextSteps || [],
+        userIntents: result.userIntents || [],
+        rawResponse: responseContent
+      };
+    }
+    throw new Error(`Unsupported output format: ${outputFormat}`);
+  }
+  getSystemPrompt(scenarioHint) {
+    let prompt = `You are a professional session analyst assistant. Your task is to extract key information from a conversation and generate a structured checkpoint.
+
+A checkpoint captures the progress and state of a session at a point in time. It should contain:
+
+1. **Process Key Points**: The key steps, discoveries, or decisions made during this part of the conversation
+2. **Current State**: The current progress and status at the end of the conversation
+3. **Next Steps**: Follow-up items and what needs to be done next
+4. **User Intents**: The underlying goals and intentions of the user (what they want to accomplish)
+
+Be concise and accurate. Avoid redundancy. Each section should be appropriately sized - not too long.`;
+    if (scenarioHint && scenarioHint.trim()) {
+      prompt += `
+
+## Scenario Context
+
+${scenarioHint.trim()}`;
+    }
+    return prompt;
+  }
+  getHintGenerationSystemPrompt() {
+    return `You are a compact guidance prompt engineer. Your task is to analyze a conversation and generate a "compact guidance prompt" that will instruct the checkpoint generator on what information to extract and preserve during session compression.
+
+**Purpose**: The guidance prompt will be used by the checkpoint generator to understand:
+1. What work is currently in progress
+2. What progress has been made
+3. What information MUST be preserved during compression (this is critical for task continuation)
+4. What information should be the focus of extraction
+
+**Key Principle**: The preserved information should enable seamless task continuation. If critical details are lost during compression, the user will have to re-explain context when continuing this work later.
+
+**Output Format**: A structured guidance prompt (3-4 sentences) covering:
+1. Current work type and what the user is trying to accomplish
+2. Current progress and key achievements
+3. CRITICAL information that MUST be preserved (decisions, findings, remaining issues)
+4. What the checkpoint generator should focus on when extracting information
+
+**Example good outputs**:
+1. "Bug investigation: User is debugging LSP diagnostics not updating after file edits. Progress: identified root cause (getDiagnostics needs to read latest file content and trigger didChange notification), implemented fix, CI verified. CRITICAL to preserve: the fix implementation details (file path, code changes), that 2 agent-node-integration tests still fail due to test assertion timing issue (expects 'running' but completes in ~78ms) - this is unrelated to LSP work. Focus extraction on: root cause analysis, fix implementation, known remaining test issues."
+2. "Feature development: User is implementing JWT authentication for auth-service. Progress: designed auth flow, implemented token refresh logic, middleware partially done. CRITICAL to preserve: auth flow decisions (token storage, refresh strategy), completed middleware components, modules pending implementation. Focus extraction on: architectural decisions, completed components, pending work."
+3. "Refactoring: User is migrating data layer to repository pattern. Progress: migrated UserRepository and OrderRepository, 3 more pending. CRITICAL to preserve: pattern decisions (interface definitions, dependency injection approach), completed repositories, modules pending migration. Focus extraction on: pattern implementation details, completed vs pending modules."`;
+  }
+  buildHintGenerationUserPrompt(messages, sessionContext) {
+    let prompt = `Analyze the following conversation and generate a compact guidance prompt for checkpoint generation.
+
+## Your Task
+Generate a structured guidance prompt (3-4 sentences) that will help the checkpoint generator understand:
+1. What work is currently in progress
+2. What progress has been made
+3. What information MUST be preserved during compression (critical for task continuation)
+4. What the checkpoint generator should focus on when extracting information
+
+`;
+    if (sessionContext) {
+      const ctxLines = ["## Session Context"];
+      if (sessionContext.activeTaskTitle) {
+        ctxLines.push(`- Active Task: ${sessionContext.activeTaskTitle}`);
+      }
+      if (sessionContext.workingDirectory) {
+        ctxLines.push(`- Working Directory: ${sessionContext.workingDirectory}`);
+      }
+      if (sessionContext.recentActions && sessionContext.recentActions.length > 0) {
+        ctxLines.push(`- Recent Actions: ${sessionContext.recentActions.slice(-3).join(" \u2192 ")}`);
+      }
+      if (ctxLines.length > 1) {
+        prompt += ctxLines.join(`
+`) + `
+
+`;
+      }
+    }
+    prompt += `## Conversation to Analyze
+
+${messages}
+
+`;
+    prompt += `---
+
+`;
+    prompt += `## Output Format
+
+`;
+    prompt += `Generate a structured guidance prompt covering:
+`;
+    prompt += `1. Current work type and what the user is trying to accomplish
+`;
+    prompt += `2. Current progress and key achievements
+`;
+    prompt += `3. CRITICAL information that MUST be preserved (decisions, findings, remaining issues)
+`;
+    prompt += `4. What to focus on during extraction
+
+`;
+    prompt += `Wrap the output in a JSON object with a \`guidance_prompt\` key:
+
+`;
+    prompt += `\`\`\`json
+`;
+    prompt += `{
+`;
+    prompt += `  "guidance_prompt": "Work type: ... Progress: ... CRITICAL to preserve: ... Focus extraction on: ..."
+`;
+    prompt += `}
+`;
+    prompt += `\`\`\`
+
+`;
+    prompt += `IMPORTANT: The preserved information should enable seamless task continuation. If critical details are lost, the user will need to re-explain context when continuing this work.`;
+    return prompt;
+  }
+  buildUserPrompt(messages, userContext) {
+    let prompt = `Please analyze the following conversation and generate a checkpoint:
+
+`;
+    if (userContext && userContext !== "\u65E0\u989D\u5916\u4E0A\u4E0B\u6587") {
+      prompt += `## Context
+${userContext}
+
+`;
+    }
+    prompt += `## Conversation Content
+
+${messages}
+
+`;
+    prompt += `---
+
+`;
+    prompt += `## Output Format
+
+Please output in the following JSON format:
+
+\`\`\`json
+{
+  "title": "Brief checkpoint title (max 30 characters)",
+  "processKeyPoints": [
+    "Point 1: Description of key discovery or decision",
+    "Point 2: Description of important step or conclusion",
+    "Point 3: ..."
+  ],
+  "currentState": "Current state description explaining progress and status (50-100 characters)",
+  "nextSteps": [
+    "Next follow-up item 1",
+    "Next follow-up item 2"
+  ],
+  "userIntents": [
+    "User intent 1: what the user wants to accomplish",
+    "User intent 2: another goal or request",
+    "User intent 3: ..."
+  ]
+}
+\`\`\`
+
+`;
+    prompt += `## Intent Extraction Guidelines
+
+`;
+    prompt += `- Extract user intents from the ENTIRE conversation flow (both user and assistant messages)
+`;
+    prompt += `- Focus on what the user WANTS to accomplish, not just what was discussed
+`;
+    prompt += `- Include both explicit requests and inferred goals
+`;
+    prompt += `- Aim for 2-5 intents, prioritize the most important ones
+`;
+    prompt += `- Be concise and specific in intent descriptions
+`;
+    prompt += `- Examples: "Fix authentication bug", "Optimize database performance", "Add unit tests for auth module"
+
+`;
+    prompt += `Make sure the JSON output is valid and can be parsed.`;
+    return prompt;
+  }
+  formatMessages(messages) {
+    return messages.map((m, i) => `[${i}] ${m.role}: ${m.content}`).join(`
+
+`);
+  }
+  parseJsonResponse(content) {
+    const jsonMatch = content.match(/```json\s*([\s\S]*?)\s*```/) || content.match(/```\s*([\s\S]*?)\s*```/) || [null, content];
+    const jsonStr = jsonMatch[1] || content;
+    try {
+      return JSON.parse(jsonStr.trim());
+    } catch {
+      const fixed = jsonStr.replace(/,\s*}/g, "}").replace(/,\s*]/g, "]").replace(/'/g, '"').trim();
+      try {
+        return JSON.parse(fixed);
+      } catch (e) {
+        logger2.error(`[SummaryAgent] Failed to parse JSON: ${content}`);
+        throw new Error(`Failed to parse checkpoint JSON: ${e}`);
+      }
+    }
+  }
+  parseHintResponse(content) {
+    return parseCompactHintResponse(content);
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("summary-agent.generateCompactHint")
+], SummaryAgent.prototype, "generateCompactHint", null);
+__legacyDecorateClassTS([
+  TracedAs("summary-agent.run", { recordParams: true, recordResult: true })
+], SummaryAgent.prototype, "run", null);
+__legacyDecorateClassTS([
+  TracedAs("summary-agent.getHintGenerationSystemPrompt")
+], SummaryAgent.prototype, "getHintGenerationSystemPrompt", null);
+__legacyDecorateClassTS([
+  TracedAs("summary-agent.buildHintGenerationUserPrompt")
+], SummaryAgent.prototype, "buildHintGenerationUserPrompt", null);
+__legacyDecorateClassTS([
+  TracedAs("summary-agent.parseHintResponse")
+], SummaryAgent.prototype, "parseHintResponse", null);
+function parseCompactHintResponse(content) {
+  const jsonResult = extractGuidanceFromJson(content);
+  if (jsonResult !== null) {
+    const trimmed = jsonResult.trim();
+    if (!trimmed) {
+      return "[Hint extraction failed]";
+    }
+    if (trimmed.length > 500) {
+      return trimmed.substring(0, 500) + "...";
+    }
+    return trimmed;
+  }
+  let text = content.replace(/```json\s*([\s\S]*?)\s*```/g, "$1").replace(/```markdown\s*([\s\S]*?)\s*```/g, "$1").replace(/```\s*([\s\S]*?)\s*```/g, "$1").trim();
+  if (!text) {
+    return "[Hint extraction failed]";
+  }
+  if (text.length > 500) {
+    return text.substring(0, 500) + "...";
+  }
+  return text;
+}
+function extractGuidanceFromJson(content) {
+  const jsonBlockMatch = content.match(/```json\s*([\s\S]*?)\s*```/);
+  if (jsonBlockMatch) {
+    const parsed2 = tryParseJson(jsonBlockMatch[1]);
+    const guidancePrompt2 = parsed2?.guidance_prompt;
+    if (typeof guidancePrompt2 === "string") {
+      return guidancePrompt2;
+    }
+  }
+  const plainBlockMatch = content.match(/```\s*([\s\S]*?)\s*```/);
+  if (plainBlockMatch) {
+    const parsed2 = tryParseJson(plainBlockMatch[1]);
+    const guidancePrompt2 = parsed2?.guidance_prompt;
+    if (typeof guidancePrompt2 === "string") {
+      return guidancePrompt2;
+    }
+  }
+  const jsonMatch = content.match(/\{[\s\S]*"guidance_prompt"[\s\S]*\}/);
+  if (jsonMatch) {
+    const parsed2 = tryParseJson(jsonMatch[0]);
+    const guidancePrompt2 = parsed2?.guidance_prompt;
+    if (typeof guidancePrompt2 === "string") {
+      return guidancePrompt2;
+    }
+  }
+  const parsed = tryParseJson(content.trim());
+  const guidancePrompt = parsed?.guidance_prompt;
+  if (typeof guidancePrompt === "string") {
+    return guidancePrompt;
+  }
+  return null;
+}
+function tryParseJson(str) {
+  if (!str || !str.trim()) {
+    return null;
+  }
+  try {
+    return JSON.parse(str.trim());
+  } catch {
+    try {
+      const fixed = str.replace(/,\s*}/g, "}").replace(/,\s*]/g, "]").trim();
+      return JSON.parse(fixed);
+    } catch {
+      return null;
+    }
+  }
+}
+export {
+  SummaryAgent,
+  AgentComponentConfigSchema,
+  AgentComponent
+};