@nebulaos/core 0.2.0 → 0.2.2

package/dist/index.cjs

@@ -1,2958 +0,0 @@
-"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