@nebulaos/core 0.1.1

package/dist/index.cjs

@@ -0,0 +1,2958 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  ActiveSpan: () => ActiveSpan,
+  Agent: () => Agent,
+  AgentAsTool: () => AgentAsTool,
+  AgentExecutionEndSchema: () => AgentExecutionEndSchema,
+  AgentExecutionErrorSchema: () => AgentExecutionErrorSchema,
+  AgentExecutionStartSchema: () => AgentExecutionStartSchema,
+  AgentLLMCallSchema: () => AgentLLMCallSchema,
+  AgentLLMResponseSchema: () => AgentLLMResponseSchema,
+  AgentLogger: () => AgentLogger,
+  AgentToolCallSchema: () => AgentToolCallSchema,
+  AgentToolResultSchema: () => AgentToolResultSchema,
+  BaseAgent: () => BaseAgent,
+  COLORS: () => COLORS,
+  CommitteeTeam: () => CommitteeTeam,
+  ConsoleLogger: () => ConsoleLogger,
+  ErrorSchema: () => ErrorSchema,
+  EventCommonSchema: () => EventCommonSchema,
+  GuardrailError: () => GuardrailError,
+  HandoffTeam: () => HandoffTeam,
+  HierarchicalTeam: () => HierarchicalTeam,
+  InMemory: () => InMemory,
+  KeywordScorer: () => KeywordScorer,
+  LOG_LEVEL_COLORS: () => LOG_LEVEL_COLORS,
+  ModelSchema: () => ModelSchema,
+  NebulaEventSchema: () => NebulaEventSchema,
+  PipelineTeam: () => PipelineTeam,
+  RegexPIIMasker: () => RegexPIIMasker,
+  RouterTeam: () => RouterTeam,
+  TREE_CHARS: () => TREE_CHARS,
+  Tool: () => Tool,
+  TraceContextSchema: () => TraceContextSchema,
+  Tracing: () => Tracing,
+  UsageSchema: () => UsageSchema,
+  Workflow: () => Workflow,
+  WorkflowExecutionEndSchema: () => WorkflowExecutionEndSchema,
+  WorkflowExecutionErrorSchema: () => WorkflowExecutionErrorSchema,
+  WorkflowExecutionStartSchema: () => WorkflowExecutionStartSchema,
+  WorkflowLogger: () => WorkflowLogger,
+  WorkflowStepSchema: () => WorkflowStepSchema,
+  agentAsToolConfigSchema: () => agentAsToolConfigSchema,
+  aggregationStrategySchema: () => aggregationStrategySchema,
+  buildHandoffSystemPrompt: () => buildHandoffSystemPrompt,
+  buildRouterSystemPrompt: () => buildRouterSystemPrompt,
+  calculateRetryDelay: () => calculateRetryDelay,
+  committeeTeamConfigSchema: () => committeeTeamConfigSchema,
+  delegationMemorySchema: () => delegationMemorySchema,
+  enforceAllowedTransition: () => enforceAllowedTransition,
+  enforceMaxTransfers: () => enforceMaxTransfers,
+  enforceTimeout: () => enforceTimeout,
+  formatError: () => formatError,
+  formatLogLine: () => formatLogLine,
+  formatMetadata: () => formatMetadata,
+  handoffEdgeSchema: () => handoffEdgeSchema,
+  handoffTeamConfigSchema: () => handoffTeamConfigSchema,
+  hierarchicalTeamConfigSchema: () => hierarchicalTeamConfigSchema,
+  isRetryableError: () => isRetryableError,
+  overrideAgentMemory: () => overrideAgentMemory,
+  pipelineTeamConfigSchema: () => pipelineTeamConfigSchema,
+  resolveDelegationMemory: () => resolveDelegationMemory,
+  routerTeamConfigSchema: () => routerTeamConfigSchema,
+  schemaToZod: () => schemaToZod,
+  z: () => import_zod4.z
+});
+module.exports = __toCommonJS(index_exports);
+
+// agent/BaseAgent.ts
+var import_events = require("events");
+
+// tracing/index.ts
+var import_node_async_hooks = require("async_hooks");
+var import_node_crypto = require("crypto");
+var ActiveSpan = class {
+  constructor(traceId, spanId, parentSpanId, kind, name, correlationId, runId, exporter) {
+    this.traceId = traceId;
+    this.spanId = spanId;
+    this.parentSpanId = parentSpanId;
+    this.kind = kind;
+    this.name = name;
+    this.correlationId = correlationId;
+    this.runId = runId;
+    this.exporter = exporter;
+  }
+  ended = false;
+  async end(input) {
+    if (this.ended) return;
+    this.ended = true;
+    const event = {
+      v: 1,
+      type: "telemetry:span:end",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      trace: {
+        traceId: this.traceId,
+        spanId: this.spanId,
+        parentSpanId: this.parentSpanId
+      },
+      correlationId: this.correlationId,
+      runId: this.runId,
+      status: input.status,
+      span: {
+        kind: this.kind,
+        name: this.name,
+        // The contract expects a kind-specific shape, but we keep this generic here.
+        // The callers are responsible for providing kind-specific keys.
+        data: input.data
+      }
+    };
+    try {
+      await this.exporter.exportBatch([event]);
+    } catch {
+    }
+  }
+  get isEnded() {
+    return this.ended;
+  }
+};
+var storage = new import_node_async_hooks.AsyncLocalStorage();
+var NoopTelemetryExporter = class {
+  async exportBatch(_events) {
+  }
+};
+var Tracing = class {
+  static exporter = new NoopTelemetryExporter();
+  static setExporter(exporter) {
+    this.exporter = exporter;
+  }
+  /**
+   * Gets the current trace context.
+   * Returns undefined if called outside of a traced execution.
+   */
+  static getContext() {
+    return storage.getStore();
+  }
+  /**
+   * Gets the current trace context or creates a dummy one if none exists.
+   * Useful for logging where you always want *some* ID.
+   */
+  static getContextOrDummy() {
+    const context = storage.getStore();
+    if (context) return context;
+    return {
+      traceId: "no-trace",
+      spanId: "no-span"
+    };
+  }
+  /**
+   * Runs a function inside a new telemetry span and exports span lifecycle events.
+   */
+  static async withSpan(input, fn) {
+    const parent = storage.getStore();
+    const traceId = parent?.traceId ?? (0, import_node_crypto.randomUUID)();
+    const parentSpanId = parent?.spanId;
+    const spanId = (0, import_node_crypto.randomUUID)();
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const startEvent = {
+      v: 1,
+      type: "telemetry:span:start",
+      timestamp: startedAt,
+      trace: {
+        traceId,
+        spanId,
+        parentSpanId
+      },
+      correlationId: input.correlationId,
+      runId: input.runId,
+      span: {
+        kind: input.kind,
+        name: input.name,
+        data: input.data ?? {}
+      }
+    };
+    try {
+      await this.exporter.exportBatch([startEvent]);
+    } catch {
+    }
+    const context = {
+      traceId,
+      spanId,
+      parentId: parentSpanId
+    };
+    const activeSpan = new ActiveSpan(
+      traceId,
+      spanId,
+      parentSpanId,
+      input.kind,
+      input.name,
+      input.correlationId,
+      input.runId,
+      this.exporter
+    );
+    return storage.run(context, async () => {
+      try {
+        const result = await fn(activeSpan);
+        if (!activeSpan.isEnded) await activeSpan.end({ status: "success" });
+        return result;
+      } catch (error) {
+        await activeSpan.end({ status: "error" });
+        throw error;
+      }
+    });
+  }
+};
+
+// agent/BaseAgent.ts
+var BaseAgent = class {
+  name;
+  emitter = new import_events.EventEmitter();
+  piiMasker;
+  memory;
+  constructor(name, piiMasker, memory) {
+    this.name = name;
+    this.piiMasker = piiMasker;
+    this.memory = memory;
+  }
+  /**
+   * Adds a message to this agent's memory (if configured).
+   * Multi-agent teams MUST provide a memory implementation if they expect to be used
+   * through standardized execution surfaces (e.g., HTTP gateways).
+   */
+  async addMessage(message) {
+    if (!this.memory) {
+      throw new Error(`Agent '${this.name}' does not have memory configured`);
+    }
+    await this.memory.addMessage(message);
+  }
+  // ==========================================================================
+  // Typed Event Emitter Methods
+  // ==========================================================================
+  /**
+   * Emits a typed event with automatic context injection (trace, timestamp).
+   * 
+   * @param event The event name (e.g., 'agent:execution:start')
+   * @param payload The event payload containing 'data' and optional context like 'correlationId'
+   */
+  emit(event, payload) {
+    const traceContext = Tracing.getContext();
+    let fullEvent = {
+      type: event,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      trace: {
+        traceId: traceContext?.traceId || `fallback-${Date.now()}`,
+        spanId: traceContext?.spanId || `fallback-${Date.now()}`,
+        parentSpanId: traceContext?.parentId
+      },
+      correlationId: payload.correlationId,
+      runId: payload.runId,
+      data: payload.data
+    };
+    if (this.piiMasker) {
+      fullEvent = this.maskEventData(fullEvent);
+    }
+    return this.emitter.emit(event, fullEvent);
+  }
+  on(event, listener) {
+    this.emitter.on(event, listener);
+    return this;
+  }
+  once(event, listener) {
+    this.emitter.once(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    this.emitter.off(event, listener);
+    return this;
+  }
+  /**
+   * Recursively masks PII in the event payload
+   */
+  maskEventData(data) {
+    if (!this.piiMasker) return data;
+    if (typeof data === "string") {
+      return this.piiMasker.mask(data);
+    }
+    if (Array.isArray(data)) {
+      return data.map((item) => this.maskEventData(item));
+    }
+    if (typeof data === "object" && data !== null) {
+      if (data instanceof Date) return data;
+      if (data instanceof Error) {
+        const maskedError = {
+          name: data.name,
+          message: this.maskEventData(data.message),
+          stack: data.stack
+        };
+        return maskedError;
+      }
+      const maskedObj = {};
+      for (const key in data) {
+        if (Object.prototype.hasOwnProperty.call(data, key)) {
+          maskedObj[key] = this.maskEventData(data[key]);
+        }
+      }
+      return maskedObj;
+    }
+    return data;
+  }
+};
+
+// logger/styles.ts
+var COLORS = {
+  // Foreground colors
+  black: "\x1B[30m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m",
+  // Bright variants
+  brightRed: "\x1B[91m",
+  brightGreen: "\x1B[92m",
+  brightYellow: "\x1B[93m",
+  brightBlue: "\x1B[94m",
+  brightMagenta: "\x1B[95m",
+  brightCyan: "\x1B[96m",
+  // Custom colors (256-color mode)
+  pink: "\x1B[38;5;213m",
+  // Rosa/Pink - estilo NestJS
+  // Styles
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  italic: "\x1B[3m",
+  underline: "\x1B[4m"
+};
+var LOG_LEVEL_COLORS = {
+  debug: COLORS.pink,
+  // Rosa/Pink (NestJS style)
+  info: COLORS.brightGreen,
+  // Verde (success/positive)
+  warn: COLORS.brightYellow,
+  // Amarelo (warning)
+  error: COLORS.brightRed
+  // Vermelho (error)
+};
+var TREE_CHARS = {
+  branch: "\u251C\u2500",
+  last: "\u2514\u2500",
+  vertical: "\u2502 ",
+  space: "  "
+};
+
+// logger/formatters.ts
+function formatLogLine(level, entityName, message, entityType = null, trace) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").split(".")[0];
+  const levelColor = (level === "none" ? COLORS.reset : LOG_LEVEL_COLORS[level]) || COLORS.reset;
+  const levelUpper = level.toUpperCase();
+  let prefix;
+  if (entityName) {
+    const entityLabel = entityType === "workflow" ? "Workflow" : "Agent";
+    const entityColor = entityType === "workflow" ? COLORS.brightBlue : COLORS.green;
+    prefix = `${COLORS.bold}[Nebula ${levelUpper} | ${entityColor}${COLORS.italic}${entityLabel} ${entityName}${COLORS.reset}${levelColor}${COLORS.bold}]${COLORS.reset}`;
+  } else {
+    prefix = `${COLORS.bold}[Nebula ${levelUpper}]${COLORS.reset}`;
+  }
+  const timestampStr = `${COLORS.dim}${timestamp}${COLORS.reset}`;
+  return `${levelColor}${prefix} ${timestampStr} ${message}${COLORS.reset}`;
+}
+function formatMetadata(meta, isLastGroup = true) {
+  const entries = Object.entries(meta);
+  if (entries.length === 0) return [];
+  return entries.map(([key, value], index) => {
+    const isLast = index === entries.length - 1;
+    const char = isLast && isLastGroup ? TREE_CHARS.last : TREE_CHARS.branch;
+    const formattedValue = formatValue(value);
+    return `  ${COLORS.dim}${char}${COLORS.reset} ${COLORS.bold}${key}:${COLORS.reset} ${formattedValue}`;
+  });
+}
+function formatValue(value) {
+  if (value === null) return `${COLORS.dim}null${COLORS.reset}`;
+  if (value === void 0) return `${COLORS.dim}undefined${COLORS.reset}`;
+  if (typeof value === "string") {
+    if (value.includes("\u2713") || value.includes("Success")) {
+      return `${COLORS.green}${value}${COLORS.reset}`;
+    }
+    if (value.includes("\u274C") || value.includes("Error")) {
+      return `${COLORS.red}${value}${COLORS.reset}`;
+    }
+    return value;
+  }
+  if (typeof value === "number") {
+    return `${COLORS.yellow}${value}${COLORS.reset}`;
+  }
+  if (typeof value === "boolean") {
+    return value ? `${COLORS.green}${value}${COLORS.reset}` : `${COLORS.red}${value}${COLORS.reset}`;
+  }
+  try {
+    return `${COLORS.dim}${JSON.stringify(value)}${COLORS.reset}`;
+  } catch {
+    return `${COLORS.dim}[Object]${COLORS.reset}`;
+  }
+}
+function formatError(error) {
+  const lines = [];
+  if (error instanceof Error) {
+    lines.push(`  ${TREE_CHARS.branch} ${COLORS.red}${error.message}${COLORS.reset}`);
+    if (error.stack) {
+      const stackLines = error.stack.split("\n").slice(1, 4);
+      stackLines.forEach((line, index) => {
+        const isLast = index === stackLines.length - 1;
+        const char = isLast ? TREE_CHARS.last : TREE_CHARS.branch;
+        lines.push(`  ${COLORS.dim}${char} ${line.trim()}${COLORS.reset}`);
+      });
+    }
+  } else {
+    lines.push(`  ${TREE_CHARS.last} ${COLORS.red}${String(error)}${COLORS.reset}`);
+  }
+  return lines;
+}
+
+// logger/agent-logger.ts
+var AgentLogger = class {
+  constructor(agent, logger) {
+    this.agent = agent;
+    this.logger = logger;
+    this.bindEvents();
+  }
+  bindEvents() {
+    this.agent.on("agent:llm:call", (event) => {
+      const { data, trace } = event;
+      this.logger.debug(`LLM Call #${data.step}`, {
+        "Messages": data.messages.length,
+        "Tools Available": data.tools?.length || 0
+      }, data.agentName, "agent", trace);
+    });
+    this.agent.on("agent:llm:response", (event) => {
+      const { data, trace } = event;
+      const usage = data.usage ? `${data.usage.promptTokens} prompt + ${data.usage.completionTokens} completion = ${data.usage.totalTokens} total` : "N/A";
+      const meta = {
+        "Tokens": usage,
+        "Tool Calls": data.toolCalls?.length || 0
+      };
+      if (data.content) {
+        meta["Content"] = data.content;
+      }
+      if (data.toolCalls && data.toolCalls.length > 0) {
+        data.toolCalls.forEach((tc, idx) => {
+          meta[`Tool ${idx + 1}`] = `${tc.function.name}(${tc.function.arguments})`;
+        });
+      }
+      this.logger.debug(`LLM Response (Step ${data.step})`, meta, data.agentName, "agent", trace);
+    });
+    this.agent.on("agent:tool:result", (event) => {
+      const { data, trace } = event;
+      const status = data.error ? "\u274C Failed" : "\u2713 Success";
+      const meta = {
+        "Duration": `${data.durationMs}ms`
+      };
+      if (data.error) {
+        meta["Error"] = data.error;
+      } else {
+        meta["Output"] = typeof data.output === "string" ? data.output : JSON.stringify(data.output);
+      }
+      this.logger.debug(`Tool Result: ${data.toolName} ${status}`, meta, data.agentName, "agent", trace);
+    });
+    this.agent.on("agent:execution:start", (event) => {
+      const { data, trace, correlationId } = event;
+      this.logger.info(`Execution Started`, {
+        "CorrelationId": correlationId,
+        "Input": data.input
+      }, data.agentName, "agent", trace);
+    });
+    this.agent.on("agent:execution:end", (event) => {
+      const { data, trace } = event;
+      const duration = (data.durationMs / 1e3).toFixed(2) + "s";
+      const usage = data.usage ? `${data.usage.totalTokens} tokens (${data.usage.promptTokens} prompt + ${data.usage.completionTokens} completion${data.usage.reasoningTokens ? ` + ${data.usage.reasoningTokens} reasoning` : ""})` : "N/A";
+      this.logger.info(`Execution Finished ${data.status === "success" ? "\u2713" : data.status === "truncated" ? "\u26A0" : "\u274C"}`, {
+        "Duration": duration,
+        "Usage": usage
+      }, data.agentName, "agent", trace);
+    });
+    this.agent.on("agent:tool:call", (event) => {
+      const { data, trace } = event;
+      let parsedInput = data.args;
+      if (typeof data.args === "string") {
+        try {
+          parsedInput = JSON.parse(data.args);
+        } catch {
+          parsedInput = data.args;
+        }
+      }
+      this.logger.info(`Tool Call: ${data.toolName}`, {
+        "Input": typeof parsedInput === "string" ? parsedInput : JSON.stringify(parsedInput)
+      }, data.agentName, "agent", trace);
+    });
+    this.agent.on("agent:execution:error", (event) => {
+      const { data, trace } = event;
+      this.logger.error(
+        `Execution Error`,
+        data.error,
+        // Pass the sanitized error object
+        data.agentName,
+        "agent",
+        trace
+      );
+    });
+  }
+};
+
+// logger/workflow-logger.ts
+var WorkflowLogger = class {
+  constructor(workflow, logger) {
+    this.workflow = workflow;
+    this.logger = logger;
+    this.bindEvents();
+  }
+  bindEvents() {
+    const workflowName = this.workflow.name || this.workflow.id;
+    this.workflow.on("workflow:step", (event) => {
+      const { data, trace } = event;
+      if (data.status === "running") {
+        this.logger.debug(`Step Started: ${data.stepName || data.nodeId}`, {
+          "Node ID": data.nodeId
+        }, workflowName, "workflow", trace);
+      } else if (data.status === "success") {
+        const duration = data.durationMs ? (data.durationMs / 1e3).toFixed(2) + "s" : "N/A";
+        this.logger.debug(`Step Completed: ${data.stepName || data.nodeId}`, {
+          "Duration": duration
+        }, workflowName, "workflow", trace);
+      } else if (data.status === "error") {
+        const duration = data.durationMs ? (data.durationMs / 1e3).toFixed(2) + "s" : "N/A";
+        this.logger.warn(`Step Failed: ${data.stepName || data.nodeId}`, {
+          "Duration": duration,
+          "Error": data.error?.message
+        }, workflowName, "workflow", trace);
+      }
+    });
+    this.workflow.on("workflow:execution:start", (event) => {
+      const { data, trace, runId } = event;
+      this.logger.info(`Execution Started`, {
+        "Workflow ID": data.workflowId,
+        "Execution ID": runId,
+        "Input": typeof data.input === "string" ? data.input : JSON.stringify(data.input)
+      }, workflowName, "workflow", trace);
+    });
+    this.workflow.on("workflow:execution:end", (event) => {
+      const { data, trace } = event;
+      const duration = (data.durationMs / 1e3).toFixed(2) + "s";
+      this.logger.info(`Execution Completed ${data.status === "success" ? "\u2713" : "\u274C"}`, {
+        "Duration": duration,
+        "Status": data.status,
+        "Output": typeof data.output === "string" ? data.output : JSON.stringify(data.output)
+      }, workflowName, "workflow", trace);
+    });
+    this.workflow.on("workflow:execution:error", (event) => {
+      const { data, trace } = event;
+      this.logger.error(
+        `Execution Error`,
+        data.error,
+        workflowName,
+        "workflow",
+        trace
+      );
+    });
+  }
+};
+
+// logger/index.ts
+var LEVEL_WEIGHTS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  none: 4
+};
+var ConsoleLogger = class {
+  constructor(minLevel = "info") {
+    this.minLevel = minLevel;
+  }
+  shouldLog(level) {
+    return LEVEL_WEIGHTS[level] >= LEVEL_WEIGHTS[this.minLevel];
+  }
+  debug(message, meta, entityName, entityType, trace) {
+    if (!this.shouldLog("debug")) return;
+    const mainLine = formatLogLine("debug", entityName || null, message, entityType || null, trace);
+    console.debug(mainLine);
+    if (meta && typeof meta === "object" && Object.keys(meta).length > 0) {
+      const metaLines = formatMetadata(meta);
+      metaLines.forEach((line) => console.debug(line));
+    }
+  }
+  info(message, meta, entityName, entityType, trace) {
+    if (!this.shouldLog("info")) return;
+    const mainLine = formatLogLine("info", entityName || null, message, entityType || null, trace);
+    console.info(mainLine);
+    if (meta && typeof meta === "object" && Object.keys(meta).length > 0) {
+      const metaLines = formatMetadata(meta);
+      metaLines.forEach((line) => console.info(line));
+    }
+  }
+  warn(message, meta, entityName, entityType, trace) {
+    if (!this.shouldLog("warn")) return;
+    const mainLine = formatLogLine("warn", entityName || null, message, entityType || null, trace);
+    console.warn(mainLine);
+    if (meta && typeof meta === "object" && Object.keys(meta).length > 0) {
+      const metaLines = formatMetadata(meta);
+      metaLines.forEach((line) => console.warn(line));
+    }
+  }
+  error(message, error, entityName, entityType, trace) {
+    if (!this.shouldLog("error")) return;
+    const mainLine = formatLogLine("error", entityName || null, message, entityType || null, trace);
+    console.error(mainLine);
+    if (error) {
+      const errorLines = formatError(error);
+      errorLines.forEach((line) => console.error(line));
+    }
+  }
+};
+
+// agent/Agent.ts
+function generateCorrelationId() {
+  return `exec_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+var Agent = class extends BaseAgent {
+  constructor(config) {
+    super(config.name, config.piiMasker, config.memory);
+    this.config = config;
+    this.requestInterceptors = config.interceptors?.request || [];
+    this.responseInterceptors = config.interceptors?.response || [];
+    const logger = config.logger || new ConsoleLogger(config.logLevel || "error");
+    this.loggerAdapter = new AgentLogger(this, logger);
+  }
+  resolvedInstructions;
+  requestInterceptors = [];
+  responseInterceptors = [];
+  // @ts-ignore: used for side-effects (binding events)
+  loggerAdapter;
+  // ==========================================================================
+  // Instructions
+  // ==========================================================================
+  async resolveInstructions() {
+    if (this.resolvedInstructions !== void 0) return this.resolvedInstructions;
+    if (typeof this.config.instructions === "string") {
+      this.resolvedInstructions = this.config.instructions;
+      return this.resolvedInstructions;
+    }
+    if (this.isInstruction(this.config.instructions)) {
+      this.resolvedInstructions = await this.config.instructions.resolve();
+      return this.resolvedInstructions;
+    }
+    return "";
+  }
+  isInstruction(obj) {
+    return obj && typeof obj.resolve === "function";
+  }
+  clearInstructionsCache() {
+    this.resolvedInstructions = void 0;
+  }
+  // ==========================================================================
+  // Memory
+  // ==========================================================================
+  async addMessage(message) {
+    this.memory = this.config.memory;
+    await this.config.memory.addMessage(message);
+  }
+  async getMessages() {
+    const instructions = await this.resolveInstructions();
+    const msgs = await this.config.memory.getMessages();
+    if (instructions && !msgs.some((m) => m.role === "system")) {
+      msgs.unshift({ role: "system", content: instructions });
+    }
+    return msgs;
+  }
+  async execute(arg1 = {}, arg2 = {}) {
+    const input = typeof arg1 === "string" ? arg1 : void 0;
+    const options = typeof arg1 === "string" ? arg2 ?? {} : arg1 ?? {};
+    const startTime = Date.now();
+    const correlationId = generateCorrelationId();
+    const maxSteps = options.maxSteps ?? this.config.maxSteps ?? 10;
+    const toolExecutions = [];
+    const collectedToolCalls = [];
+    let llmCalls = 0;
+    let truncated = false;
+    let totalUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+    return Tracing.withSpan(
+      {
+        kind: "agent",
+        name: `agent:${this.name}`,
+        correlationId,
+        data: { agentName: this.name, input }
+      },
+      async (agentSpan) => {
+        this.emit("agent:execution:start", {
+          correlationId,
+          data: {
+            agentName: this.name,
+            input
+          }
+        });
+        try {
+          if (input) {
+            await this.addMessage({ role: "user", content: input });
+          }
+          let step = 0;
+          while (step < maxSteps) {
+            step++;
+            llmCalls++;
+            let messages = await this.getMessages();
+            let tools = !options.disableTools && this.config.tools ? [...this.config.tools] : [];
+            let context2 = { messages, tools };
+            for (const interceptor of this.requestInterceptors) {
+              context2 = await interceptor(context2);
+            }
+            messages = context2.messages;
+            tools = context2.tools;
+            const llmTools = tools.length > 0 ? tools.map((t) => t.toLLMDefinition()) : void 0;
+            this.emit("agent:llm:call", {
+              correlationId,
+              data: {
+                agentName: this.name,
+                step,
+                messages,
+                tools: llmTools,
+                responseFormat: options.responseFormat,
+                model: {
+                  provider: this.config.model.providerName,
+                  model: this.config.model.modelName
+                }
+              }
+            });
+            const rawResponse = await Tracing.withSpan(
+              {
+                kind: "llm",
+                name: `llm:step${step}`,
+                correlationId,
+                data: {
+                  provider: this.config.model.providerName,
+                  model: this.config.model.modelName,
+                  step,
+                  messagesCount: messages.length,
+                  toolsCount: llmTools?.length ?? 0,
+                  responseFormat: options.responseFormat
+                }
+              },
+              async (llmSpan) => {
+                try {
+                  const resp = await this.config.model.generate(messages, llmTools, {
+                    responseFormat: options.responseFormat
+                  });
+                  await llmSpan.end({
+                    status: "success",
+                    data: {
+                      usage: resp.usage,
+                      toolCallsCount: resp.toolCalls?.length ?? 0,
+                      outputPreview: typeof resp.content === "string" ? resp.content.substring(0, 200) : "json_content"
+                    }
+                  });
+                  return resp;
+                } catch (e) {
+                  await llmSpan.end({ status: "error" });
+                  throw e;
+                }
+              }
+            );
+            let response = rawResponse;
+            this.emit("agent:llm:response", {
+              correlationId,
+              data: {
+                agentName: this.name,
+                step,
+                content: response.content,
+                toolCalls: response.toolCalls,
+                usage: response.usage,
+                model: {
+                  provider: this.config.model.providerName,
+                  model: this.config.model.modelName
+                }
+              }
+            });
+            if (response.usage) {
+              totalUsage.promptTokens += response.usage.promptTokens;
+              totalUsage.completionTokens += response.usage.completionTokens;
+              totalUsage.totalTokens += response.usage.totalTokens;
+              if (response.usage.reasoningTokens) {
+                totalUsage.reasoningTokens = (totalUsage.reasoningTokens || 0) + response.usage.reasoningTokens;
+              }
+            }
+            if (!response.toolCalls || response.toolCalls.length === 0 || options.disableTools) {
+              for (const interceptor of this.responseInterceptors) {
+                response = await interceptor(response);
+              }
+              await this.addMessage({ role: "assistant", content: response.content });
+              await agentSpan.end({
+                status: "success",
+                data: {
+                  output: options.responseFormat?.type === "json" ? this.safeParseJson(response.content) : response.content,
+                  usage: totalUsage
+                }
+              });
+              return this.finishResult({
+                correlationId,
+                content: options.responseFormat?.type === "json" ? this.safeParseJson(response.content) : response.content,
+                toolExecutions,
+                toolCalls: options.disableTools ? response.toolCalls : void 0,
+                llmCalls,
+                totalDurationMs: Date.now() - startTime,
+                truncated: false,
+                totalUsage
+              });
+            }
+            await this.addMessage({
+              role: "assistant",
+              content: response.content,
+              tool_calls: response.toolCalls
+            });
+            for (const toolCall of response.toolCalls) {
+              await Tracing.withSpan(
+                {
+                  kind: "tool",
+                  name: `tool:${toolCall.function.name}`,
+                  correlationId,
+                  data: {
+                    toolName: toolCall.function.name,
+                    toolCallId: toolCall.id,
+                    args: toolCall.function.arguments
+                  }
+                },
+                async (toolSpan) => {
+                  this.emit("agent:tool:call", {
+                    correlationId,
+                    data: {
+                      agentName: this.name,
+                      toolName: toolCall.function.name,
+                      toolCallId: toolCall.id,
+                      args: toolCall.function.arguments
+                    }
+                  });
+                  const execution = await this.executeToolCall(toolCall);
+                  toolExecutions.push(execution);
+                  collectedToolCalls.push(toolCall);
+                  this.emit("agent:tool:result", {
+                    correlationId,
+                    data: {
+                      agentName: this.name,
+                      toolName: toolCall.function.name,
+                      toolCallId: toolCall.id,
+                      output: execution.output,
+                      error: execution.error,
+                      durationMs: execution.durationMs
+                    }
+                  });
+                  await toolSpan.end({
+                    status: execution.error ? "error" : "success",
+                    data: {
+                      output: execution.output,
+                      error: execution.error
+                    }
+                  });
+                  await this.addMessage({
+                    role: "tool",
+                    tool_call_id: toolCall.id,
+                    content: execution.error ? `Error: ${execution.error}` : JSON.stringify(execution.output)
+                  });
+                }
+              );
+            }
+          }
+          truncated = true;
+          llmCalls++;
+          let finalMessages = await this.getMessages();
+          let finalTools = !options.disableTools && this.config.tools ? [...this.config.tools] : [];
+          let context = { messages: finalMessages, tools: finalTools };
+          for (const interceptor of this.requestInterceptors) {
+            context = await interceptor(context);
+          }
+          finalMessages = context.messages;
+          let finalResponse = await this.config.model.generate(finalMessages);
+          for (const interceptor of this.responseInterceptors) {
+            finalResponse = await interceptor(finalResponse);
+          }
+          await this.addMessage({ role: "assistant", content: finalResponse.content });
+          await agentSpan.end({
+            status: truncated ? "cancelled" : "success",
+            data: {
+              output: finalResponse.content,
+              usage: totalUsage
+            }
+          });
+          return this.finishResult({
+            correlationId,
+            content: finalResponse.content,
+            toolExecutions,
+            toolCalls: collectedToolCalls,
+            llmCalls,
+            totalDurationMs: Date.now() - startTime,
+            truncated,
+            totalUsage
+          });
+        } catch (err) {
+          const error = err instanceof Error ? err : new Error(String(err));
+          this.emit("agent:execution:error", {
+            correlationId,
+            data: {
+              agentName: this.name,
+              error: {
+                message: error.message,
+                stack: error.stack,
+                name: error.name
+              },
+              durationMs: Date.now() - startTime
+            }
+          });
+          await agentSpan.end({ status: "error" });
+          throw err;
+        }
+      }
+    );
+  }
+  async *executeStream(options = {}) {
+    const startTime = Date.now();
+    const correlationId = generateCorrelationId();
+    const maxSteps = options.maxSteps ?? this.config.maxSteps ?? 10;
+    const toolExecutions = [];
+    const collectedToolCalls = [];
+    let llmCalls = 0;
+    let truncated = false;
+    let totalUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+    this.emit("agent:execution:start", {
+      correlationId,
+      data: {
+        agentName: this.name,
+        input: void 0
+      }
+    });
+    try {
+      let step = 0;
+      while (step < maxSteps) {
+        step++;
+        llmCalls++;
+        let messages = await this.getMessages();
+        let tools = !options.disableTools && this.config.tools ? [...this.config.tools] : [];
+        let context = { messages, tools };
+        for (const interceptor of this.requestInterceptors) {
+          context = await interceptor(context);
+        }
+        messages = context.messages;
+        tools = context.tools;
+        const llmTools = tools.length > 0 ? tools.map((t) => t.toLLMDefinition()) : void 0;
+        this.emit("agent:llm:call", {
+          correlationId,
+          data: {
+            agentName: this.name,
+            step,
+            messages,
+            tools: llmTools,
+            responseFormat: options.responseFormat,
+            model: {
+              provider: this.config.model.providerName,
+              model: this.config.model.modelName
+            }
+          }
+        });
+        const stream = this.config.model.generateStream(messages, llmTools, { responseFormat: options.responseFormat });
+        let fullContent = "";
+        let toolCallsBuffer = {};
+        let chunkUsage;
+        for await (const chunk of stream) {
+          yield chunk;
+          if (chunk.type === "content_delta") {
+            fullContent += chunk.delta;
+          } else if (chunk.type === "tool_call_start") {
+            toolCallsBuffer[chunk.index] = { id: chunk.id, name: chunk.name, args: "" };
+          } else if (chunk.type === "tool_call_delta") {
+            if (toolCallsBuffer[chunk.index]) {
+              toolCallsBuffer[chunk.index].args += chunk.args;
+            }
+          } else if (chunk.type === "finish") {
+            chunkUsage = chunk.usage;
+          }
+        }
+        if (chunkUsage) {
+          totalUsage.promptTokens += chunkUsage.promptTokens;
+          totalUsage.completionTokens += chunkUsage.completionTokens;
+          totalUsage.totalTokens += chunkUsage.totalTokens;
+          if (chunkUsage.reasoningTokens) {
+            totalUsage.reasoningTokens = (totalUsage.reasoningTokens || 0) + chunkUsage.reasoningTokens;
+          }
+        }
+        const toolCalls = Object.values(toolCallsBuffer).map((tc) => ({
+          id: tc.id,
+          type: "function",
+          function: { name: tc.name, arguments: tc.args }
+        }));
+        this.emit("agent:llm:response", {
+          correlationId,
+          data: {
+            agentName: this.name,
+            step,
+            content: fullContent,
+            toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+            usage: chunkUsage,
+            model: {
+              provider: this.config.model.providerName,
+              model: this.config.model.modelName
+            }
+          }
+        });
+        if (toolCalls.length === 0 || options.disableTools) {
+          await this.addMessage({ role: "assistant", content: fullContent });
+          this.emit("agent:execution:end", {
+            correlationId,
+            data: {
+              agentName: this.name,
+              status: "success",
+              output: options.responseFormat?.type === "json" ? this.safeParseJson(fullContent) : fullContent,
+              durationMs: Date.now() - startTime,
+              usage: totalUsage
+            }
+          });
+          return;
+        }
+        await this.addMessage({ role: "assistant", content: fullContent || null, tool_calls: toolCalls });
+        for (const toolCall of toolCalls) {
+          const execution = await Tracing.withSpan(
+            {
+              kind: "tool",
+              name: `tool:${toolCall.function.name}`,
+              correlationId,
+              data: {
+                toolName: toolCall.function.name,
+                toolCallId: toolCall.id,
+                args: toolCall.function.arguments
+              }
+            },
+            async (toolSpan) => {
+              this.emit("agent:tool:call", {
+                correlationId,
+                data: {
+                  agentName: this.name,
+                  toolName: toolCall.function.name,
+                  toolCallId: toolCall.id,
+                  args: toolCall.function.arguments
+                }
+              });
+              const exec = await this.executeToolCall(toolCall);
+              toolExecutions.push(exec);
+              collectedToolCalls.push(toolCall);
+              this.emit("agent:tool:result", {
+                correlationId,
+                data: {
+                  agentName: this.name,
+                  toolName: toolCall.function.name,
+                  toolCallId: toolCall.id,
+                  output: exec.output,
+                  error: exec.error,
+                  durationMs: exec.durationMs
+                }
+              });
+              await toolSpan.end({
+                status: exec.error ? "error" : "success",
+                data: { output: exec.output, error: exec.error }
+              });
+              return exec;
+            }
+          );
+          yield {
+            type: "tool_result",
+            toolCallId: toolCall.id,
+            result: execution.output
+          };
+          await this.addMessage({
+            role: "tool",
+            tool_call_id: toolCall.id,
+            content: execution.error ? `Error: ${execution.error}` : JSON.stringify(execution.output)
+          });
+        }
+      }
+      truncated = true;
+      llmCalls++;
+      let finalMessages = await this.getMessages();
+      let finalTools = !options.disableTools && this.config.tools ? [...this.config.tools] : [];
+      let finalContext = { messages: finalMessages, tools: finalTools };
+      for (const interceptor of this.requestInterceptors) {
+        finalContext = await interceptor(finalContext);
+      }
+      finalMessages = finalContext.messages;
+      const finalResponse = await this.config.model.generate(finalMessages);
+      if (finalResponse.usage) {
+        totalUsage.promptTokens += finalResponse.usage.promptTokens;
+        totalUsage.completionTokens += finalResponse.usage.completionTokens;
+        totalUsage.totalTokens += finalResponse.usage.totalTokens;
+        if (finalResponse.usage.reasoningTokens) {
+          totalUsage.reasoningTokens = (totalUsage.reasoningTokens || 0) + finalResponse.usage.reasoningTokens;
+        }
+      }
+      await this.addMessage({ role: "assistant", content: finalResponse.content });
+      this.emit("agent:execution:end", {
+        correlationId,
+        data: {
+          agentName: this.name,
+          status: truncated ? "truncated" : "success",
+          output: finalResponse.content,
+          durationMs: Date.now() - startTime,
+          usage: totalUsage
+        }
+      });
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.emit("agent:execution:error", {
+        correlationId,
+        data: {
+          agentName: this.name,
+          error: {
+            message: error.message,
+            stack: error.stack,
+            name: error.name
+          },
+          durationMs: Date.now() - startTime
+        }
+      });
+      yield { type: "error", error };
+    }
+  }
+  // ==========================================================================
+  // Tools Execution
+  // ==========================================================================
+  async executeToolCall(toolCall) {
+    const startTime = Date.now();
+    const toolName = toolCall.function.name;
+    const tool = this.config.tools?.find((t) => t.id === toolName);
+    if (!tool) {
+      return {
+        id: toolCall.id,
+        name: toolName,
+        input: toolCall.function.arguments,
+        output: null,
+        durationMs: Date.now() - startTime,
+        error: `Tool '${toolName}' not found`
+      };
+    }
+    try {
+      const output = await tool.execute({}, toolCall.function.arguments);
+      return {
+        id: toolCall.id,
+        name: toolName,
+        input: toolCall.function.arguments,
+        output,
+        durationMs: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        id: toolCall.id,
+        name: toolName,
+        input: toolCall.function.arguments,
+        output: null,
+        durationMs: Date.now() - startTime,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  // ==========================================================================
+  // Helpers
+  // ==========================================================================
+  safeParseJson(content) {
+    if (!content) return null;
+    try {
+      return JSON.parse(content);
+    } catch {
+      return content;
+    }
+  }
+  finishResult(params) {
+    const result = {
+      content: params.content,
+      toolExecutions: params.toolExecutions,
+      toolCalls: params.toolCalls,
+      llmCalls: params.llmCalls,
+      totalDurationMs: params.totalDurationMs,
+      truncated: params.truncated
+    };
+    this.emit("agent:execution:end", {
+      correlationId: params.correlationId,
+      data: {
+        agentName: this.name,
+        status: params.truncated ? "truncated" : "success",
+        output: result.content,
+        usage: params.totalUsage,
+        durationMs: params.totalDurationMs
+      }
+    });
+    return result;
+  }
+};
+
+// agent/memory/in-memory.ts
+var InMemory = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  messages = [];
+  async addMessage(message) {
+    this.messages.push(message);
+    if (this.options.maxMessages && this.messages.length > this.options.maxMessages) {
+      const systemMessage = this.messages.find((m) => m.role === "system");
+      const removeCount = this.messages.length - this.options.maxMessages;
+      this.messages.splice(0, removeCount);
+      if (systemMessage && !this.messages.includes(systemMessage)) {
+        this.messages.unshift(systemMessage);
+      }
+    }
+  }
+  async getMessages() {
+    return [...this.messages];
+  }
+  async clear() {
+    this.messages = [];
+  }
+};
+
+// agent/tools/index.ts
+var import_zod_to_json_schema = require("zod-to-json-schema");
+function toJsonSchema(input) {
+  const defaultSchema = { type: "object", properties: {}, required: [] };
+  if (input && typeof input === "object" && "_def" in input) {
+    try {
+      const schema = (0, import_zod_to_json_schema.zodToJsonSchema)(input, {
+        $refStrategy: "none",
+        target: "openApi3"
+      });
+      return {
+        type: "object",
+        properties: schema.properties ?? {},
+        required: schema.required ?? []
+      };
+    } catch {
+      return defaultSchema;
+    }
+  }
+  if (input && typeof input === "object" && "type" in input) {
+    const obj = input;
+    return {
+      type: "object",
+      properties: obj.properties ?? {},
+      required: obj.required ?? []
+    };
+  }
+  return defaultSchema;
+}
+var Tool = class {
+  id;
+  description;
+  inputSchema;
+  handler;
+  constructor(config) {
+    this.id = config.id;
+    this.description = config.description;
+    this.inputSchema = config.inputSchema;
+    this.handler = config.handler;
+  }
+  /**
+   * Converte a tool para o formato esperado pelo LLM
+   */
+  toLLMDefinition() {
+    return {
+      type: "function",
+      function: {
+        name: this.id,
+        description: this.description,
+        parameters: this.inputSchema ? toJsonSchema(this.inputSchema) : void 0
+      }
+    };
+  }
+  /**
+   * Executa a tool com validação de input
+   */
+  async execute(context, input) {
+    let parsedInput = input;
+    if (this.inputSchema) {
+      if (typeof input === "string") {
+        try {
+          parsedInput = JSON.parse(input);
+        } catch {
+          throw new Error(`Invalid JSON input for tool ${this.id}`);
+        }
+      }
+      const result = this.inputSchema.safeParse(parsedInput);
+      if (!result.success) {
+        throw new Error(`Invalid input for tool ${this.id}: ${result.error.message}`);
+      }
+      parsedInput = result.data;
+    }
+    if (this.handler) {
+      return this.handler(context, parsedInput);
+    }
+    throw new Error(`Tool ${this.id} has no handler implementation.`);
+  }
+};
+
+// workflow/Workflow.ts
+var import_uuid = require("uuid");
+var import_promises = require("timers/promises");
+var import_events2 = require("events");
+
+// workflow/adapters.ts
+function calculateRetryDelay(policy, attempt) {
+  const { backoff, initialDelay, maxDelay = 6e4 } = policy;
+  let delay;
+  switch (backoff) {
+    case "exponential":
+      delay = initialDelay * Math.pow(2, attempt - 1);
+      break;
+    case "linear":
+      delay = initialDelay * attempt;
+      break;
+    case "fixed":
+    default:
+      delay = initialDelay;
+  }
+  return Math.min(delay, maxDelay);
+}
+function isRetryableError(error, policy) {
+  if (!policy.retryableErrors || policy.retryableErrors.length === 0) {
+    return true;
+  }
+  return policy.retryableErrors.some(
+    (pattern) => error.message.includes(pattern) || error.name.includes(pattern)
+  );
+}
+
+// workflow/Workflow.ts
+var Workflow = class _Workflow {
+  id;
+  name;
+  description;
+  config;
+  steps = [];
+  hasStartStep = false;
+  hasFinishStep = false;
+  emitter = new import_events2.EventEmitter();
+  /**
+   * Construtor compatível com assinatura antiga (string) e nova (config)
+   */
+  constructor(idOrConfig) {
+    if (typeof idOrConfig === "string") {
+      this.config = { id: idOrConfig };
+    } else {
+      this.config = idOrConfig;
+    }
+    this.id = this.config.id;
+    this.name = this.config.name;
+    this.description = this.config.description;
+    if (this.config.logLevel && this.config.logLevel !== "none") {
+      const logger = new ConsoleLogger(this.config.logLevel);
+      new WorkflowLogger(this, logger);
+    }
+  }
+  /**
+   * start() - obrigatório se inputSchema existir
+   */
+  start(handler) {
+    if (this.hasStartStep) throw new Error("Workflow already has a start step");
+    if (this.steps.length > 0) throw new Error("start() deve ser chamado antes dos steps");
+    this.hasStartStep = true;
+    this.steps.push({ id: (0, import_uuid.v4)(), name: "__start__", handler, type: "start" });
+    return this;
+  }
+  /**
+   * step() - step linear
+   */
+  step(name, handler) {
+    if (this.config.inputSchema && !this.hasStartStep) {
+      throw new Error("start() deve ser chamado antes de step() quando h\xE1 inputSchema");
+    }
+    if (this.hasFinishStep) throw new Error("N\xE3o \xE9 poss\xEDvel adicionar steps ap\xF3s finish()");
+    this.steps.push({ id: (0, import_uuid.v4)(), name, handler, type: "standard" });
+    return this;
+  }
+  then(name, handler) {
+    return this.step(name, handler);
+  }
+  /**
+   * branch() - retorna chave do branch
+   */
+  branch(name, handler, branches) {
+    if (this.hasFinishStep) throw new Error("N\xE3o \xE9 poss\xEDvel adicionar steps ap\xF3s finish()");
+    const branchWorkflows = {};
+    for (const [key, config] of Object.entries(branches)) {
+      const branchWf = new _Workflow({ id: `${this.id}-branch-${key}` });
+      config(branchWf);
+      branchWorkflows[key] = branchWf;
+    }
+    this.steps.push({
+      id: (0, import_uuid.v4)(),
+      name,
+      handler,
+      type: "branch",
+      branches: branchWorkflows
+    });
+    return this;
+  }
+  /**
+   * parallel() - executa workflows em paralelo
+   */
+  parallel(name, workflows) {
+    if (this.hasFinishStep) throw new Error("N\xE3o \xE9 poss\xEDvel adicionar steps ap\xF3s finish()");
+    const parallelWfs = workflows.map((config, index) => {
+      const wf = new _Workflow({ id: `${this.id}-parallel-${index}` });
+      config(wf);
+      return wf;
+    });
+    this.steps.push({
+      id: (0, import_uuid.v4)(),
+      name,
+      handler: async ({ input }) => input,
+      type: "parallel",
+      parallelWorkflows: parallelWfs
+    });
+    return this;
+  }
+  /**
+   * finish() - obrigatório se outputSchema existir
+   */
+  finish(handler) {
+    if (this.hasFinishStep) throw new Error("Workflow already has a finish step");
+    this.hasFinishStep = true;
+    this.steps.push({ id: (0, import_uuid.v4)(), name: "__finish__", handler, type: "finish" });
+    return this;
+  }
+  // =============================================================================
+  // Event Methods (Composition over Inheritance)
+  // =============================================================================
+  on(event, listener) {
+    this.emitter.on(event, listener);
+    return this;
+  }
+  once(event, listener) {
+    this.emitter.once(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    this.emitter.off(event, listener);
+    return this;
+  }
+  emit(event, payload) {
+    const traceContext = Tracing.getContext();
+    const fullEvent = {
+      type: event,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      trace: {
+        traceId: traceContext?.traceId || `fallback-${Date.now()}`,
+        spanId: traceContext?.spanId || `fallback-${Date.now()}`,
+        parentSpanId: traceContext?.parentId
+      },
+      correlationId: payload.correlationId,
+      runId: payload.runId,
+      data: payload.data
+    };
+    this.emitter.emit(event, fullEvent);
+  }
+  // =============================================================================
+  // Execution
+  // =============================================================================
+  /**
+   * Execução síncrona
+   */
+  async run(input, options) {
+    if (this.config.outputSchema && !this.hasFinishStep) {
+      throw new Error("finish() deve ser chamado quando h\xE1 outputSchema");
+    }
+    if (this.config.inputSchema) {
+      const parsed = this.config.inputSchema.safeParse(input);
+      if (!parsed.success) {
+        throw new Error(`Input validation failed: ${parsed.error.message}`);
+      }
+    }
+    const executionId = options?.executionId || (0, import_uuid.v4)();
+    const startTime = Date.now();
+    let currentInput = input;
+    const state = {};
+    return Tracing.withSpan(
+      {
+        kind: "workflow",
+        name: `workflow:${this.id}`,
+        runId: executionId,
+        data: { workflowId: this.id, input }
+      },
+      async (workflowSpan) => {
+        this.emit("workflow:execution:start", {
+          runId: executionId,
+          data: {
+            workflowId: this.id,
+            input
+          }
+        });
+        if (this.config.stateStore) {
+          await this.saveState(executionId, {
+            workflowId: this.id,
+            executionId,
+            status: "running",
+            currentStep: 0,
+            stepStates: {},
+            input,
+            startedAt: /* @__PURE__ */ new Date(),
+            updatedAt: /* @__PURE__ */ new Date()
+          });
+        }
+        try {
+          let stepIndex = 0;
+          for (const step of this.steps) {
+            const result = await Tracing.withSpan(
+              {
+                kind: "workflow",
+                name: `workflow:step:${step.name}`,
+                runId: executionId,
+                data: { workflowId: this.id, input: currentInput, stepName: step.name }
+              },
+              async (stepSpan) => {
+                try {
+                  const out = await this.executeStepWithRetry(executionId, step, currentInput, state);
+                  await stepSpan.end({ status: "success", data: { output: out } });
+                  return out;
+                } catch (e) {
+                  await stepSpan.end({ status: "error" });
+                  throw e;
+                }
+              }
+            );
+            if (step.type === "start" || step.type === "standard") {
+              currentInput = result;
+              state[step.name] = result;
+            } else if (step.type === "branch") {
+              const branchKey = result;
+              const branchWf = step.branches?.[branchKey];
+              if (branchWf) {
+                const branchResult = await branchWf.run(currentInput);
+                currentInput = branchResult;
+                state[step.name] = branchKey;
+                state[branchKey] = branchResult;
+              }
+            } else if (step.type === "parallel") {
+              if (step.parallelWorkflows) {
+                const results = await Promise.all(step.parallelWorkflows.map((wf) => wf.run(currentInput)));
+                currentInput = results;
+                state[step.name] = results;
+              }
+            } else if (step.type === "finish") {
+              currentInput = result;
+            }
+            if (this.config.stateStore) {
+              await this.saveState(executionId, {
+                workflowId: this.id,
+                executionId,
+                status: "running",
+                currentStep: stepIndex,
+                stepStates: { ...state },
+                input,
+                startedAt: /* @__PURE__ */ new Date(),
+                updatedAt: /* @__PURE__ */ new Date()
+              });
+            }
+            stepIndex++;
+          }
+          const output = currentInput;
+          if (this.config.outputSchema) {
+            const parsed = this.config.outputSchema.safeParse(output);
+            if (!parsed.success) {
+              throw new Error(`Output validation failed: ${parsed.error.message}`);
+            }
+          }
+          if (this.config.stateStore) {
+            await this.saveState(executionId, {
+              workflowId: this.id,
+              executionId,
+              status: "completed",
+              currentStep: this.steps.length,
+              stepStates: state,
+              input,
+              output,
+              startedAt: /* @__PURE__ */ new Date(),
+              updatedAt: /* @__PURE__ */ new Date(),
+              completedAt: /* @__PURE__ */ new Date()
+            });
+          }
+          this.emit("workflow:execution:end", {
+            runId: executionId,
+            data: {
+              workflowId: this.id,
+              status: "success",
+              output,
+              durationMs: Date.now() - startTime
+            }
+          });
+          await workflowSpan.end({ status: "success", data: { output } });
+          return output;
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          this.emit("workflow:execution:error", {
+            runId: executionId,
+            data: {
+              workflowId: this.id,
+              error: {
+                message: err.message,
+                stack: err.stack,
+                name: err.name
+              },
+              durationMs: Date.now() - startTime
+            }
+          });
+          if (this.config.stateStore) {
+            await this.saveState(executionId, {
+              workflowId: this.id,
+              executionId,
+              status: "failed",
+              currentStep: 0,
+              stepStates: state,
+              input,
+              startedAt: /* @__PURE__ */ new Date(),
+              updatedAt: /* @__PURE__ */ new Date(),
+              completedAt: /* @__PURE__ */ new Date(),
+              error: error instanceof Error ? error.message : String(error)
+            });
+          }
+          await workflowSpan.end({ status: "error" });
+          throw error;
+        }
+      }
+    );
+  }
+  async executeStepWithRetry(executionId, step, currentInput, state) {
+    const stepStartTime = Date.now();
+    this.emit("workflow:step", {
+      runId: executionId,
+      data: {
+        workflowId: this.id,
+        nodeId: step.id,
+        stepName: step.name,
+        status: "running"
+      }
+    });
+    const policy = this.config.retryPolicy;
+    if (!policy) {
+      try {
+        const result = await step.handler({ input: currentInput, state });
+        this.emit("workflow:step", {
+          runId: executionId,
+          data: {
+            workflowId: this.id,
+            nodeId: step.id,
+            stepName: step.name,
+            status: "success",
+            durationMs: Date.now() - stepStartTime
+          }
+        });
+        return result;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        this.emit("workflow:step", {
+          runId: executionId,
+          data: {
+            workflowId: this.id,
+            nodeId: step.id,
+            stepName: step.name,
+            status: "error",
+            error: {
+              message: error.message,
+              stack: error.stack,
+              name: error.name
+            },
+            durationMs: Date.now() - stepStartTime
+          }
+        });
+        throw error;
+      }
+    }
+    let lastError;
+    for (let attempt = 1; attempt <= policy.maxAttempts; attempt++) {
+      try {
+        const result = await step.handler({ input: currentInput, state });
+        this.emit("workflow:step", {
+          runId: executionId,
+          data: {
+            workflowId: this.id,
+            nodeId: step.id,
+            stepName: step.name,
+            status: "success",
+            durationMs: Date.now() - stepStartTime
+          }
+        });
+        return result;
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (!isRetryableError(lastError, policy) || attempt >= policy.maxAttempts) {
+          this.emit("workflow:step", {
+            runId: executionId,
+            data: {
+              workflowId: this.id,
+              nodeId: step.id,
+              stepName: step.name,
+              status: "error",
+              error: {
+                message: lastError.message,
+                stack: lastError.stack,
+                name: lastError.name
+              },
+              durationMs: Date.now() - stepStartTime
+            }
+          });
+          throw lastError;
+        }
+        const delay = calculateRetryDelay(policy, attempt);
+        await (0, import_promises.setTimeout)(delay);
+      }
+    }
+    throw lastError;
+  }
+  async saveState(executionId, state) {
+    if (this.config.stateStore) {
+      await this.config.stateStore.save(executionId, state);
+    }
+  }
+  /**
+   * Enfileira execução assíncrona (requer queueAdapter)
+   */
+  async enqueue(input) {
+    if (!this.config.queueAdapter) {
+      throw new Error("Queue adapter n\xE3o configurado. N\xE3o \xE9 poss\xEDvel enfileirar.");
+    }
+    if (this.config.inputSchema) {
+      const parsed = this.config.inputSchema.safeParse(input);
+      if (!parsed.success) {
+        throw new Error(`Input validation failed: ${parsed.error.message}`);
+      }
+    }
+    const executionId = (0, import_uuid.v4)();
+    if (this.config.stateStore) {
+      await this.saveState(executionId, {
+        workflowId: this.id,
+        executionId,
+        status: "pending",
+        currentStep: 0,
+        stepStates: {},
+        input,
+        startedAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      });
+    }
+    const firstStep = this.steps[0];
+    if (firstStep) {
+      await this.config.queueAdapter.enqueue({
+        executionId,
+        workflowId: this.id,
+        stepId: firstStep.id,
+        stepName: firstStep.name,
+        input,
+        attempt: 1,
+        createdAt: /* @__PURE__ */ new Date()
+      });
+    }
+    return { executionId };
+  }
+  /**
+   * Consulta status (requer queueAdapter ou stateStore)
+   */
+  async getStatus(executionId) {
+    if (this.config.queueAdapter?.getStatus) {
+      return this.config.queueAdapter.getStatus(executionId);
+    }
+    if (this.config.stateStore) {
+      const state = await this.config.stateStore.load(executionId);
+      if (!state) throw new Error(`Execution ${executionId} not found`);
+      return {
+        status: state.status,
+        currentStep: this.steps[state.currentStep]?.name,
+        progress: this.steps.length ? state.currentStep / this.steps.length : 0
+      };
+    }
+    throw new Error("Queue adapter ou state store necess\xE1rio para getStatus()");
+  }
+};
+
+// events/schemas.ts
+var import_zod = require("zod");
+var TraceContextSchema = import_zod.z.object({
+  traceId: import_zod.z.string().describe("Unique identifier for the trace"),
+  spanId: import_zod.z.string().describe("Unique identifier for the current span"),
+  parentSpanId: import_zod.z.string().optional().describe("Identifier of the parent span, if any")
+});
+var EventCommonSchema = import_zod.z.object({
+  type: import_zod.z.string().describe("Event type identifier (e.g., 'agent:execution:start')"),
+  timestamp: import_zod.z.string().datetime().describe("ISO 8601 timestamp of when the event occurred"),
+  trace: TraceContextSchema,
+  correlationId: import_zod.z.string().optional().describe("Optional external correlation ID"),
+  runId: import_zod.z.string().optional().describe("Logical execution run ID")
+});
+var UsageSchema = import_zod.z.object({
+  promptTokens: import_zod.z.number(),
+  completionTokens: import_zod.z.number(),
+  totalTokens: import_zod.z.number(),
+  reasoningTokens: import_zod.z.number().optional()
+});
+var ErrorSchema = import_zod.z.object({
+  name: import_zod.z.string().optional(),
+  message: import_zod.z.string(),
+  code: import_zod.z.string().optional(),
+  stack: import_zod.z.string().optional(),
+  details: import_zod.z.any().optional()
+});
+var ModelSchema = import_zod.z.object({
+  provider: import_zod.z.string(),
+  model: import_zod.z.string(),
+  temperature: import_zod.z.number().optional(),
+  maxTokens: import_zod.z.number().optional(),
+  topP: import_zod.z.number().optional(),
+  frequencyPenalty: import_zod.z.number().optional(),
+  presencePenalty: import_zod.z.number().optional()
+}).passthrough();
+var AgentExecutionStartSchema = EventCommonSchema.extend({
+  type: import_zod.z.literal("agent:execution:start"),
+  data: import_zod.z.object({
+    agentName: import_zod.z.string(),
+    input: import_zod.z.any().optional().describe("Input arguments for the execution"),
+    metadata: import_zod.z.record(import_zod.z.any()).optional()
+  })
+});
+var AgentExecutionEndSchema = EventCommonSchema.extend({
+  type: import_zod.z.literal("agent:execution:end"),
+  data: import_zod.z.object({
+    agentName: import_zod.z.string(),
+    status: import_zod.z.enum(["success", "error", "truncated"]),
+    output: import_zod.z.any().optional().describe("Final output of the execution"),
+    durationMs: import_zod.z.number(),
+    usage: UsageSchema.optional().describe("Total token usage for this execution")
+  })
+});
+var AgentExecutionErrorSchema = EventCommonSchema.extend({
+  type: import_zod.z.literal("agent:execution:error"),
+  data: import_zod.z.object({
+    agentName: import_zod.z.string(),
+    error: ErrorSchema,
+    durationMs: import_zod.z.number().optional()
+  })
+});
+var AgentLLMCallSchema = EventCommonSchema.extend({
+  type: import_zod.z.literal("agent:llm:call"),
+  data: import_zod.z.object({
+    agentName: import_zod.z.string(),
+    step: import_zod.z.number().int().positive().describe("Current execution step"),
+    model: ModelSchema,
+    messages: import_zod.z.array(import_zod.z.any()).describe("Messages sent to the LLM"),
+    tools: import_zod.z.array(import_zod.z.any()).optional().describe("Tools definitions sent to the LLM"),
+    responseFormat: import_zod.z.any().optional()
+  })
+});
+var AgentLLMResponseSchema = EventCommonSchema.extend({
+  type: import_zod.z.literal("agent:llm:response"),
+  data: import_zod.z.object({
+    agentName: import_zod.z.string(),
+    step: import_zod.z.number().int().positive(),
+    model: ModelSchema,
+    content: import_zod.z.any().describe("Content returned by the LLM"),
+    toolCalls: import_zod.z.array(import_zod.z.any()).optional(),
+    finishReason: import_zod.z.string().optional(),
+    usage: UsageSchema.optional(),
+    durationMs: import_zod.z.number().optional()
+  })
+});
+var AgentToolCallSchema = EventCommonSchema.extend({
+  type: import_zod.z.literal("agent:tool:call"),
+  data: import_zod.z.object({
+    agentName: import_zod.z.string(),
+    toolName: import_zod.z.string(),
+    toolCallId: import_zod.z.string(),
+    args: import_zod.z.any().describe("Arguments passed to the tool")
+  })
+});
+var AgentToolResultSchema = EventCommonSchema.extend({
+  type: import_zod.z.literal("agent:tool:result"),
+  data: import_zod.z.object({
+    agentName: import_zod.z.string(),
+    toolName: import_zod.z.string(),
+    toolCallId: import_zod.z.string(),
+    output: import_zod.z.any().optional().describe("Result returned by the tool"),
+    error: import_zod.z.string().optional().describe("Error message if tool failed"),
+    durationMs: import_zod.z.number().optional()
+  })
+});
+var WorkflowExecutionStartSchema = EventCommonSchema.extend({
+  type: import_zod.z.literal("workflow:execution:start"),
+  data: import_zod.z.object({
+    workflowId: import_zod.z.string(),
+    input: import_zod.z.any().optional(),
+    metadata: import_zod.z.record(import_zod.z.any()).optional()
+  })
+});
+var WorkflowExecutionEndSchema = EventCommonSchema.extend({
+  type: import_zod.z.literal("workflow:execution:end"),
+  data: import_zod.z.object({
+    workflowId: import_zod.z.string(),
+    status: import_zod.z.enum(["success", "error", "truncated"]),
+    output: import_zod.z.any().optional(),
+    durationMs: import_zod.z.number()
+  })
+});
+var WorkflowExecutionErrorSchema = EventCommonSchema.extend({
+  type: import_zod.z.literal("workflow:execution:error"),
+  data: import_zod.z.object({
+    workflowId: import_zod.z.string(),
+    error: ErrorSchema,
+    durationMs: import_zod.z.number().optional()
+  })
+});
+var WorkflowStepSchema = EventCommonSchema.extend({
+  type: import_zod.z.literal("workflow:step"),
+  data: import_zod.z.object({
+    workflowId: import_zod.z.string(),
+    stepName: import_zod.z.string().optional(),
+    nodeId: import_zod.z.string().optional(),
+    status: import_zod.z.enum(["running", "success", "error"]),
+    durationMs: import_zod.z.number().optional(),
+    output: import_zod.z.any().optional(),
+    error: ErrorSchema.optional()
+  })
+});
+var NebulaEventSchema = import_zod.z.discriminatedUnion("type", [
+  AgentExecutionStartSchema,
+  AgentExecutionEndSchema,
+  AgentExecutionErrorSchema,
+  AgentLLMCallSchema,
+  AgentLLMResponseSchema,
+  AgentToolCallSchema,
+  AgentToolResultSchema,
+  WorkflowExecutionStartSchema,
+  WorkflowExecutionEndSchema,
+  WorkflowExecutionErrorSchema,
+  WorkflowStepSchema
+]);
+
+// lgpd/index.ts
+var RegexPIIMasker = class _RegexPIIMasker {
+  // Regex padrões para dados sensíveis brasileiros
+  static PATTERNS = {
+    CPF: /\b\d{3}\.?\d{3}\.?\d{3}-?\d{2}\b/g,
+    CNPJ: /\b\d{2}\.?\d{3}\.?\d{3}\/?\d{4}-?\d{2}\b/g,
+    EMAIL: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g,
+    PHONE: /\b(\(?\d{2}\)?\s?)?(\d{4,5}-?\d{4})\b/g
+  };
+  mask(text) {
+    let masked = text;
+    masked = masked.replace(_RegexPIIMasker.PATTERNS.CPF, "[CPF]");
+    masked = masked.replace(_RegexPIIMasker.PATTERNS.CNPJ, "[CNPJ]");
+    masked = masked.replace(_RegexPIIMasker.PATTERNS.EMAIL, "[EMAIL]");
+    masked = masked.replace(_RegexPIIMasker.PATTERNS.PHONE, "[PHONE]");
+    return masked;
+  }
+};
+
+// eval/index.ts
+var KeywordScorer = class {
+  constructor(keywords) {
+    this.keywords = keywords;
+  }
+  name = "KeywordScorer";
+  async evaluate(input, output) {
+    const lowerOutput = output.toLowerCase();
+    const found = this.keywords.filter((k) => lowerOutput.includes(k.toLowerCase()));
+    const score = found.length / this.keywords.length;
+    return {
+      score,
+      passed: score === 1,
+      reason: `Found ${found.length}/${this.keywords.length} keywords: ${found.join(", ")}`
+    };
+  }
+};
+
+// utils/schema-to-zod.ts
+var import_zod2 = require("zod");
+function schemaToZod(shape) {
+  const zodShape = {};
+  for (const [key, value] of Object.entries(shape)) {
+    if (typeof value === "string") {
+      let schema = import_zod2.z.any();
+      const isOptional = value.endsWith("?");
+      const type = isOptional ? value.slice(0, -1) : value;
+      switch (type) {
+        case "string":
+          schema = import_zod2.z.string();
+          break;
+        case "number":
+          schema = import_zod2.z.number();
+          break;
+        case "boolean":
+          schema = import_zod2.z.boolean();
+          break;
+        case "array":
+          schema = import_zod2.z.array(import_zod2.z.any());
+          break;
+        // Simplificado
+        default:
+          schema = import_zod2.z.any();
+      }
+      if (isOptional) schema = schema.optional();
+      zodShape[key] = schema;
+    } else {
+      zodShape[key] = value;
+    }
+  }
+  return import_zod2.z.object(zodShape);
+}
+
+// index.ts
+var import_zod4 = require("zod");
+
+// multi-agent/types/index.ts
+var import_zod3 = require("zod");
+var agentRef = import_zod3.z.any();
+var memoryRef = import_zod3.z.any();
+var delegationMemorySchema = import_zod3.z.union([
+  import_zod3.z.object({ type: import_zod3.z.literal("shared") }),
+  import_zod3.z.object({ type: import_zod3.z.literal("isolated") }),
+  import_zod3.z.object({
+    type: import_zod3.z.literal("custom"),
+    memory: memoryRef
+  })
+]);
+var handoffEdgeSchema = import_zod3.z.object({
+  from: agentRef,
+  to: agentRef,
+  toolId: import_zod3.z.string(),
+  description: import_zod3.z.string().optional()
+});
+var routerTeamConfigSchema = import_zod3.z.object({
+  model: import_zod3.z.any(),
+  children: import_zod3.z.array(agentRef).min(1),
+  fallback: agentRef.optional(),
+  memory: memoryRef.optional(),
+  additionalPrompt: import_zod3.z.string().optional(),
+  maxRetries: import_zod3.z.number().int().positive().optional(),
+  timeoutMs: import_zod3.z.number().int().positive().optional()
+});
+var handoffTeamConfigSchema = import_zod3.z.object({
+  agents: import_zod3.z.array(agentRef).min(1),
+  edges: import_zod3.z.array(handoffEdgeSchema).min(1),
+  initialAgent: agentRef,
+  memory: memoryRef.optional(),
+  additionalPrompt: import_zod3.z.string().optional(),
+  maxTransfers: import_zod3.z.number().int().positive().optional(),
+  timeoutMs: import_zod3.z.number().int().positive().optional(),
+  tokenBudget: import_zod3.z.number().positive().optional(),
+  allowedTransitions: import_zod3.z.record(import_zod3.z.array(import_zod3.z.string())).optional(),
+  onTransfer: import_zod3.z.function().optional()
+});
+var agentAsToolConfigSchema = import_zod3.z.object({
+  agent: agentRef,
+  id: import_zod3.z.string().optional(),
+  description: import_zod3.z.string().optional(),
+  additionalPrompt: import_zod3.z.string().optional(),
+  memory: delegationMemorySchema.optional(),
+  inputSchema: import_zod3.z.custom().optional()
+});
+var hierarchicalTeamConfigSchema = import_zod3.z.object({
+  manager: agentRef,
+  workers: import_zod3.z.array(agentRef).min(1),
+  memory: memoryRef.optional(),
+  additionalPrompt: import_zod3.z.string().optional(),
+  allowHandoff: import_zod3.z.boolean().optional(),
+  workerCollaboration: import_zod3.z.boolean().optional()
+});
+var pipelineTeamConfigSchema = import_zod3.z.object({
+  stages: import_zod3.z.array(agentRef).min(1),
+  memory: memoryRef.optional(),
+  additionalPrompt: import_zod3.z.string().optional()
+});
+var committeeTeamConfigSchema = import_zod3.z.object({
+  coordinator: agentRef,
+  members: import_zod3.z.array(agentRef).min(1),
+  strategy: import_zod3.z.enum(["vote", "summarize", "confidence", "first"]),
+  memory: memoryRef.optional(),
+  additionalPrompt: import_zod3.z.string().optional(),
+  parallel: import_zod3.z.boolean().optional()
+});
+var aggregationStrategySchema = import_zod3.z.enum([
+  "vote",
+  "summarize",
+  "confidence",
+  "first"
+]);
+
+// multi-agent/utils/memory.ts
+function overrideAgentMemory(agent, memory) {
+  const original = agent.config.memory;
+  if (memory) {
+    agent.config.memory = memory;
+  }
+  return () => {
+    agent.config.memory = original;
+  };
+}
+async function resolveDelegationMemory(agent, config, callingMemory) {
+  const original = agent.config.memory;
+  if (!config) {
+    return { memory: original, restore: () => {
+    } };
+  }
+  if (config.type === "shared") {
+    const memory = original;
+    if (callingMemory) {
+      const msgs = await callingMemory.getMessages();
+      for (const msg of msgs) {
+        await memory.addMessage(msg);
+      }
+    }
+    agent.config.memory = memory;
+    return { memory, restore: () => agent.config.memory = original };
+  }
+  if (config.type === "custom") {
+    agent.config.memory = config.memory;
+    return { memory: config.memory, restore: () => agent.config.memory = original };
+  }
+  const isolated = new InMemory();
+  agent.config.memory = isolated;
+  return { memory: isolated, restore: () => agent.config.memory = original };
+}
+
+// multi-agent/agent-as-tool/AgentAsTool.ts
+var AgentAsTool = class extends Tool {
+  callingMemory;
+  target;
+  memoryConfig;
+  extraPrompt;
+  constructor(config) {
+    const toolId = config.id ?? `delegate_${config.agent.name.toLowerCase().replace(/\s+/g, "_")}`;
+    const description = config.description ?? `Delegate to specialist agent: ${config.agent.name}`;
+    super({
+      id: toolId,
+      description,
+      inputSchema: config.inputSchema,
+      handler: async (_, input) => {
+        return this.runDelegated(input);
+      }
+    });
+    this.target = config.agent;
+    this.memoryConfig = config.memory;
+    this.extraPrompt = config.additionalPrompt;
+  }
+  /**
+   * Allows orchestrators to set the calling agent/team memory when using
+   * `memory: { type: "shared" }`.
+   */
+  setCallingMemory(memory) {
+    this.callingMemory = memory;
+  }
+  async runDelegated(input) {
+    const { restore } = await resolveDelegationMemory(
+      this.target,
+      this.memoryConfig,
+      this.callingMemory
+    );
+    try {
+      const formattedInput = typeof input === "string" ? input : JSON.stringify(input);
+      const userContent = this.extraPrompt ? `${this.extraPrompt}
+Input: ${formattedInput}` : formattedInput;
+      await this.target.config.memory.addMessage({
+        role: "user",
+        content: userContent
+      });
+      const result = await this.target.execute();
+      return result.content;
+    } finally {
+      restore();
+    }
+  }
+};
+
+// multi-agent/utils/prompts.ts
+function buildRouterSystemPrompt(agents, additionalPrompt) {
+  const lines = agents.map(
+    (a) => `- ${a.name}: ${a.config?.instructions ?? a.name}`
+  );
+  return [
+    "You are a routing controller.",
+    "Choose the best agent for the user request.",
+    'Respond ONLY with JSON: {"agent": "<name>"}.',
+    additionalPrompt ? `Guidance: ${additionalPrompt}` : "",
+    "Available agents:",
+    ...lines
+  ].filter(Boolean).join("\n");
+}
+function buildHandoffSystemPrompt(additionalPrompt) {
+  return [
+    "You are coordinating handoffs between agents.",
+    additionalPrompt ? `Guidance: ${additionalPrompt}` : ""
+  ].filter(Boolean).join("\n");
+}
+
+// multi-agent/utils/guardrails.ts
+var GuardrailError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GuardrailError";
+  }
+};
+function enforceMaxTransfers(current, max) {
+  if (max !== void 0 && current >= max) {
+    throw new GuardrailError(`Max transfers exceeded (${max})`);
+  }
+}
+function enforceAllowedTransition(from, to, allowed) {
+  if (!allowed) return;
+  const allowedTargets = allowed[from];
+  if (allowedTargets && !allowedTargets.includes(to)) {
+    throw new GuardrailError(`Transition from '${from}' to '${to}' is not allowed`);
+  }
+}
+function enforceTimeout(promise, timeoutMs, label = "operation") {
+  if (!timeoutMs) return promise;
+  return Promise.race([
+    promise,
+    new Promise(
+      (_, reject) => setTimeout(() => reject(new GuardrailError(`${label} timed out after ${timeoutMs}ms`)), timeoutMs)
+    )
+  ]);
+}
+
+// multi-agent/router-team/RouterTeam.ts
+var RouterTeam = class extends BaseAgent {
+  constructor(config) {
+    super(
+      config.name,
+      void 0,
+      config.memory ?? config.children?.[0]?.config?.memory
+    );
+    this.config = config;
+  }
+  /**
+   * Execute routing: choose an agent via model classification, then delegate execution.
+   */
+  async execute(input, _options) {
+    const correlationId = `router_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    const startTime = Date.now();
+    return Tracing.withSpan(
+      {
+        kind: "agent",
+        name: `team:router:${this.name}`,
+        correlationId,
+        data: { agentName: this.name, input }
+      },
+      async (teamSpan) => {
+        this.emit("agent:execution:start", {
+          correlationId,
+          data: {
+            agentName: this.name,
+            input
+          }
+        });
+        try {
+          const selected = await this.selectAgent(input);
+          const memoryToUse = this.config.memory ?? selected.config.memory;
+          const restoreMemory = overrideAgentMemory(selected, memoryToUse);
+          if (input) {
+            await this.addMessage({ role: "user", content: input });
+          }
+          const result = await selected.execute();
+          restoreMemory();
+          this.emit("agent:execution:end", {
+            correlationId,
+            data: {
+              agentName: this.name,
+              status: result.truncated ? "truncated" : "success",
+              output: result.content,
+              durationMs: Date.now() - startTime
+              // Usage? Ideally aggregated, but for now passing result content is key
+            }
+          });
+          await teamSpan.end({
+            status: result.truncated ? "cancelled" : "success",
+            data: { output: result.content }
+          });
+          return result;
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          this.emit("agent:execution:error", {
+            correlationId,
+            data: {
+              agentName: this.name,
+              error: {
+                message: err.message,
+                stack: err.stack,
+                name: err.name
+              },
+              durationMs: Date.now() - startTime
+            }
+          });
+          await teamSpan.end({ status: "error" });
+          throw error;
+        }
+      }
+    );
+  }
+  async selectAgent(userInput) {
+    const system = buildRouterSystemPrompt(
+      this.config.children,
+      this.config.additionalPrompt
+    );
+    const messages = [
+      { role: "system", content: system },
+      { role: "user", content: userInput ?? "" }
+    ];
+    const routerResponseSchema = {
+      type: "object",
+      properties: {
+        agent: {
+          type: "string",
+          description: "The name of the agent to route to"
+        }
+      },
+      required: ["agent"],
+      additionalProperties: false
+    };
+    const response = await enforceTimeout(
+      Tracing.withSpan(
+        {
+          kind: "llm",
+          name: "llm:router-selection",
+          data: {
+            provider: this.config.model.providerName,
+            model: this.config.model.modelName,
+            messagesCount: messages.length,
+            toolsCount: 0,
+            responseFormat: { type: "json", schema: routerResponseSchema }
+          }
+        },
+        async (llmSpan) => {
+          const resp = await this.config.model.generate(messages, void 0, {
+            responseFormat: { type: "json", schema: routerResponseSchema }
+          });
+          await llmSpan.end({
+            status: "success",
+            data: {
+              usage: resp.usage,
+              outputPreview: typeof resp.content === "string" ? resp.content.substring(0, 200) : "json_content"
+            }
+          });
+          return resp;
+        }
+      ),
+      this.config.timeoutMs,
+      "router-selection"
+    );
+    const agentName = this.extractAgentName(response.content);
+    const found = this.config.children.find(
+      (c) => c.name.toLowerCase() === agentName?.toLowerCase()
+    ) ?? this.config.fallback ?? this.config.children[0];
+    return found;
+  }
+  extractAgentName(content) {
+    if (!content) return void 0;
+    const trimmed = content.trim();
+    if (!trimmed) return void 0;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed.agent === "string") {
+        return parsed.agent;
+      }
+    } catch {
+    }
+    return trimmed.split("\n")[0];
+  }
+};
+
+// multi-agent/handoff-team/HandoffTeam.ts
+var HandoffTeam = class extends BaseAgent {
+  constructor(config) {
+    super(config.name, void 0, config.memory ?? config.initialAgent.config.memory);
+    this.config = config;
+    this.edgeMap = this.buildEdgeMap(config.edges);
+    this.agentByName = new Map(
+      config.agents.map((a) => [a.name.toLowerCase(), a])
+    );
+  }
+  edgeMap;
+  agentByName;
+  async execute(input, _options) {
+    const correlationId = `handoff_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    const startTime = Date.now();
+    return Tracing.withSpan(
+      {
+        kind: "agent",
+        name: `team:handoff:${this.name}`,
+        correlationId,
+        data: { agentName: this.name, input }
+      },
+      async (teamSpan) => {
+        this.emit("agent:execution:start", {
+          correlationId,
+          data: {
+            agentName: this.name,
+            input
+          }
+        });
+        try {
+          const teamMemory = this.config.memory ?? this.config.initialAgent.config.memory;
+          let current = this.config.initialAgent;
+          let transfers = 0;
+          if (input) {
+            await this.addMessage({ role: "user", content: input });
+          }
+          let lastResult;
+          while (true) {
+            enforceMaxTransfers(transfers, this.config.maxTransfers);
+            const { tools, restoreTools } = this.attachHandoffTools(current);
+            const restoreMemory = overrideAgentMemory(current, teamMemory);
+            try {
+              const result = await enforceTimeout(
+                current.execute(),
+                this.config.timeoutMs,
+                "handoff-execution"
+              );
+              lastResult = result;
+              const handoff = this.findHandoffSignal(result, tools);
+              if (!handoff) {
+                this.emit("agent:execution:end", {
+                  correlationId,
+                  data: {
+                    agentName: this.name,
+                    status: result.truncated ? "truncated" : "success",
+                    output: result.content,
+                    durationMs: Date.now() - startTime
+                  }
+                });
+                await teamSpan.end({
+                  status: result.truncated ? "cancelled" : "success",
+                  data: { output: result.content }
+                });
+                return result;
+              }
+              transfers++;
+              enforceAllowedTransition(
+                current.name,
+                handoff.to,
+                this.config.allowedTransitions
+              );
+              if (this.config.onTransfer) {
+                const target = this.agentByName.get(handoff.to.toLowerCase());
+                if (target) {
+                  await this.config.onTransfer(current, target);
+                }
+              }
+              const next = this.agentByName.get(handoff.to.toLowerCase());
+              if (!next) {
+                throw new Error(`Handoff target not found: ${handoff.to}`);
+              }
+              current = next;
+              continue;
+            } finally {
+              restoreTools();
+              restoreMemory();
+            }
+          }
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          this.emit("agent:execution:error", {
+            correlationId,
+            data: {
+              agentName: this.name,
+              error: {
+                message: err.message,
+                stack: err.stack,
+                name: err.name
+              },
+              durationMs: Date.now() - startTime
+            }
+          });
+          await teamSpan.end({ status: "error" });
+          throw error;
+        }
+      }
+    );
+  }
+  buildEdgeMap(edges) {
+    const map = /* @__PURE__ */ new Map();
+    edges.forEach((edge) => {
+      const list = map.get(edge.from) ?? [];
+      list.push(edge);
+      map.set(edge.from, list);
+    });
+    return map;
+  }
+  attachHandoffTools(agent) {
+    const edges = this.edgeMap.get(agent) ?? [];
+    const newTools = edges.map(
+      (edge) => new Tool({
+        id: edge.toolId,
+        description: edge.description ?? `Transfer control to ${edge.to.name} (${edge.to.config.instructions})`,
+        handler: async () => ({
+          handoff: true,
+          to: edge.to.name
+        })
+      })
+    );
+    const originalTools = agent.config.tools ?? [];
+    agent.config.tools = [...originalTools, ...newTools];
+    return {
+      tools: newTools,
+      restoreTools: () => {
+        agent.config.tools = originalTools;
+      }
+    };
+  }
+  findHandoffSignal(result, tools) {
+    if (!result.toolExecutions?.length) return void 0;
+    const toolIds = new Set(tools.map((t) => t.id));
+    for (const exec of result.toolExecutions) {
+      if (toolIds.has(exec.name) && exec.output && exec.output.handoff) {
+        return exec.output;
+      }
+    }
+    return void 0;
+  }
+};
+
+// multi-agent/hierarchical-team/HierarchicalTeam.ts
+var HierarchicalTeam = class extends BaseAgent {
+  constructor(config) {
+    super(config.name, void 0, config.memory ?? config.manager.config.memory);
+    this.config = config;
+    this.manager = config.manager;
+    this.workers = config.workers;
+    this.teamMemory = config.memory;
+    this.allowHandoff = config.allowHandoff ?? false;
+    this.workerCollaboration = config.workerCollaboration ?? false;
+  }
+  manager;
+  workers;
+  teamMemory;
+  allowHandoff;
+  workerCollaboration;
+  async execute(input, _options) {
+    const correlationId = `hierarchical_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    const startTime = Date.now();
+    return Tracing.withSpan(
+      {
+        kind: "agent",
+        name: `team:hierarchical:${this.name}`,
+        correlationId,
+        data: { agentName: this.name, input }
+      },
+      async (teamSpan) => {
+        this.emit("agent:execution:start", {
+          correlationId,
+          data: {
+            agentName: this.name,
+            input
+          }
+        });
+        try {
+          const result = this.allowHandoff ? await this.executeWithHandoff(input) : await this.executeDelegationOnly(input);
+          this.emit("agent:execution:end", {
+            correlationId,
+            data: {
+              agentName: this.name,
+              status: result.truncated ? "truncated" : "success",
+              output: result.content,
+              durationMs: Date.now() - startTime
+            }
+          });
+          await teamSpan.end({
+            status: result.truncated ? "cancelled" : "success",
+            data: { output: result.content }
+          });
+          return result;
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          this.emit("agent:execution:error", {
+            correlationId,
+            data: {
+              agentName: this.name,
+              error: {
+                message: err.message,
+                stack: err.stack,
+                name: err.name
+              },
+              durationMs: Date.now() - startTime
+            }
+          });
+          await teamSpan.end({ status: "error" });
+          throw error;
+        }
+      }
+    );
+  }
+  async executeDelegationOnly(input) {
+    const teamMemory = this.teamMemory ?? this.manager.config.memory;
+    const tools = this.buildWorkerTools(teamMemory);
+    const originalTools = this.manager.config.tools ?? [];
+    this.manager.config.tools = [...originalTools, ...tools];
+    const restoreMemory = overrideAgentMemory(this.manager, teamMemory);
+    try {
+      if (input) {
+        await this.addMessage({ role: "user", content: input });
+      }
+      return await this.manager.execute();
+    } finally {
+      this.manager.config.tools = originalTools;
+      restoreMemory();
+      tools.forEach((t) => t.setCallingMemory(void 0));
+    }
+  }
+  async executeWithHandoff(input) {
+    const teamMemory = this.teamMemory ?? this.manager.config.memory;
+    if (this.workerCollaboration) {
+      this.workers.forEach((worker) => {
+        const originalTools = worker.config.tools ?? [];
+        const peerTools = this.workers.filter((w) => w !== worker).map(
+          (w) => new AgentAsTool({
+            agent: w,
+            memory: { type: "shared" },
+            additionalPrompt: "Use this to consult another specialist."
+          })
+        );
+        worker.config.tools = [...originalTools, ...peerTools];
+      });
+    }
+    const team = new HandoffTeam({
+      name: `${this.config.name}-internal-handoff`,
+      agents: [this.manager, ...this.workers],
+      edges: [
+        ...this.workers.map((w) => ({
+          from: this.manager,
+          to: w,
+          toolId: `handoff_to_${w.name.toLowerCase()}`,
+          description: `Pass control to worker ${w.name}`
+        })),
+        ...this.workers.map((w) => ({
+          from: w,
+          to: this.manager,
+          toolId: `back_to_manager`,
+          description: `Return control to manager`
+        }))
+      ],
+      initialAgent: this.manager,
+      memory: teamMemory,
+      additionalPrompt: this.config.additionalPrompt,
+      maxTransfers: 10
+    });
+    return team.execute(input);
+  }
+  buildWorkerTools(teamMemory) {
+    return this.workers.map((worker) => {
+      const tool = new AgentAsTool({
+        agent: worker,
+        id: `delegate_${worker.name.toLowerCase()}`,
+        memory: { type: "shared" },
+        additionalPrompt: "Delegate a subtask to this specialist."
+      });
+      tool.setCallingMemory(teamMemory);
+      return tool;
+    });
+  }
+};
+
+// multi-agent/pipeline-team/PipelineTeam.ts
+var PipelineTeam = class extends BaseAgent {
+  constructor(config) {
+    super(config.name, void 0, config.memory ?? config.stages?.[0]?.config?.memory);
+    this.config = config;
+    this.stages = config.stages;
+    this.teamMemory = config.memory;
+  }
+  stages;
+  teamMemory;
+  async execute(input, _options) {
+    const correlationId = `pipeline_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    const startTime = Date.now();
+    return Tracing.withSpan(
+      {
+        kind: "agent",
+        name: `team:pipeline:${this.name}`,
+        correlationId,
+        data: { agentName: this.name, input }
+      },
+      async (teamSpan) => {
+        this.emit("agent:execution:start", {
+          correlationId,
+          data: {
+            agentName: this.name,
+            input
+          }
+        });
+        try {
+          const edges = this.buildEdges();
+          const team = new HandoffTeam({
+            name: `${this.config.name}-internal-handoff`,
+            agents: this.stages,
+            edges,
+            initialAgent: this.stages[0],
+            memory: this.teamMemory,
+            additionalPrompt: this.config.additionalPrompt,
+            maxTransfers: edges.length + 2
+          });
+          const result = await team.execute(input);
+          this.emit("agent:execution:end", {
+            correlationId,
+            data: {
+              agentName: this.name,
+              status: result.truncated ? "truncated" : "success",
+              output: result.content,
+              durationMs: Date.now() - startTime
+            }
+          });
+          await teamSpan.end({
+            status: result.truncated ? "cancelled" : "success",
+            data: { output: result.content }
+          });
+          return result;
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          this.emit("agent:execution:error", {
+            correlationId,
+            data: {
+              agentName: this.name,
+              error: {
+                message: err.message,
+                stack: err.stack,
+                name: err.name
+              },
+              durationMs: Date.now() - startTime
+            }
+          });
+          await teamSpan.end({ status: "error" });
+          throw error;
+        }
+      }
+    );
+  }
+  buildEdges() {
+    const edges = this.stages.slice(0, -1).map((from, idx) => {
+      const to = this.stages[idx + 1];
+      return {
+        from,
+        to,
+        toolId: `next_${to.name.toLowerCase()}`,
+        description: `Pass work to ${to.name}`
+      };
+    });
+    return edges;
+  }
+};
+
+// multi-agent/committee-team/CommitteeTeam.ts
+var CommitteeTeam = class extends BaseAgent {
+  constructor(config) {
+    super(config.name, void 0, config.memory ?? config.coordinator.config.memory);
+    this.config = config;
+    this.coordinator = config.coordinator;
+    this.members = config.members;
+    this.strategy = config.strategy;
+    this.teamMemory = config.memory;
+  }
+  coordinator;
+  members;
+  strategy;
+  teamMemory;
+  async execute(input, _options) {
+    const correlationId = `committee_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    const startTime = Date.now();
+    return Tracing.withSpan(
+      {
+        kind: "agent",
+        name: `team:committee:${this.name}`,
+        correlationId,
+        data: { agentName: this.name, input }
+      },
+      async (teamSpan) => {
+        this.emit("agent:execution:start", {
+          correlationId,
+          data: {
+            agentName: this.name,
+            input
+          }
+        });
+        try {
+          const teamMemory = this.teamMemory ?? this.coordinator.config.memory;
+          const opinions = await this.collectOpinions(teamMemory, input);
+          const aggregated = this.aggregate(opinions);
+          const restoreMemory = overrideAgentMemory(this.coordinator, teamMemory);
+          let result;
+          try {
+            await this.addMessage({
+              role: "user",
+              content: `Members opinions:
+${opinions.map((o) => `- ${o.agent}: ${o.content}`).join("\n")}
+Strategy: ${this.strategy}`
+            });
+            if (input) {
+              await this.addMessage({ role: "user", content: input });
+            }
+            const coordinatorResult = await this.coordinator.execute();
+            result = coordinatorResult ?? this.buildResult(aggregated);
+          } finally {
+            restoreMemory();
+          }
+          this.emit("agent:execution:end", {
+            correlationId,
+            data: {
+              agentName: this.name,
+              status: result.truncated ? "truncated" : "success",
+              output: result.content,
+              durationMs: Date.now() - startTime
+            }
+          });
+          await teamSpan.end({
+            status: result.truncated ? "cancelled" : "success",
+            data: { output: result.content }
+          });
+          return result;
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          this.emit("agent:execution:error", {
+            correlationId,
+            data: {
+              agentName: this.name,
+              error: {
+                message: err.message,
+                stack: err.stack,
+                name: err.name
+              },
+              durationMs: Date.now() - startTime
+            }
+          });
+          await teamSpan.end({ status: "error" });
+          throw error;
+        }
+      }
+    );
+  }
+  async collectOpinions(memory, input) {
+    const opinions = [];
+    for (const member of this.members) {
+      const restoreMemory = overrideAgentMemory(member, memory);
+      try {
+        if (input) {
+          await memory.addMessage({ role: "user", content: input });
+        }
+        const result = await member.execute();
+        opinions.push({ agent: member.name, content: result.content });
+      } finally {
+        restoreMemory();
+      }
+    }
+    return opinions;
+  }
+  aggregate(opinions) {
+    if (this.strategy === "first") {
+      return opinions[0]?.content;
+    }
+    if (this.strategy === "vote") {
+      const counts = opinions.reduce((acc, o) => {
+        const key = String(o.content);
+        acc[key] = (acc[key] || 0) + 1;
+        return acc;
+      }, {});
+      return Object.entries(counts).sort((a, b) => b[1] - a[1])[0]?.[0];
+    }
+    if (this.strategy === "confidence") {
+      return opinions[0]?.content;
+    }
+    return opinions.map((o) => `${o.agent}: ${o.content}`).join(" | ");
+  }
+  buildResult(content) {
+    return {
+      content,
+      toolExecutions: [],
+      llmCalls: 0,
+      totalDurationMs: 0,
+      truncated: false
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActiveSpan,
+  Agent,
+  AgentAsTool,
+  AgentExecutionEndSchema,
+  AgentExecutionErrorSchema,
+  AgentExecutionStartSchema,
+  AgentLLMCallSchema,
+  AgentLLMResponseSchema,
+  AgentLogger,
+  AgentToolCallSchema,
+  AgentToolResultSchema,
+  BaseAgent,
+  COLORS,
+  CommitteeTeam,
+  ConsoleLogger,
+  ErrorSchema,
+  EventCommonSchema,
+  GuardrailError,
+  HandoffTeam,
+  HierarchicalTeam,
+  InMemory,
+  KeywordScorer,
+  LOG_LEVEL_COLORS,
+  ModelSchema,
+  NebulaEventSchema,
+  PipelineTeam,
+  RegexPIIMasker,
+  RouterTeam,
+  TREE_CHARS,
+  Tool,
+  TraceContextSchema,
+  Tracing,
+  UsageSchema,
+  Workflow,
+  WorkflowExecutionEndSchema,
+  WorkflowExecutionErrorSchema,
+  WorkflowExecutionStartSchema,
+  WorkflowLogger,
+  WorkflowStepSchema,
+  agentAsToolConfigSchema,
+  aggregationStrategySchema,
+  buildHandoffSystemPrompt,
+  buildRouterSystemPrompt,
+  calculateRetryDelay,
+  committeeTeamConfigSchema,
+  delegationMemorySchema,
+  enforceAllowedTransition,
+  enforceMaxTransfers,
+  enforceTimeout,
+  formatError,
+  formatLogLine,
+  formatMetadata,
+  handoffEdgeSchema,
+  handoffTeamConfigSchema,
+  hierarchicalTeamConfigSchema,
+  isRetryableError,
+  overrideAgentMemory,
+  pipelineTeamConfigSchema,
+  resolveDelegationMemory,
+  routerTeamConfigSchema,
+  schemaToZod,
+  z
+});
+//# sourceMappingURL=index.cjs.map