@nebulaos/core 0.1.1

package/dist/logger/agent-logger.d.ts

@@ -0,0 +1,16 @@
+import { Agent } from "../agent/Agent.js";
+import { ILogger } from "./index.js";
+/**
+ * AgentLogger binds to Agent events and formats them for logging
+ *
+ * This class is responsible for:
+ * - Listening to agent lifecycle events
+ * - Formatting event data into structured logs
+ * - Delegating actual logging to an ILogger implementation
+ */
+export declare class AgentLogger {
+    private agent;
+    private logger;
+    constructor(agent: Agent, logger: ILogger);
+    private bindEvents;
+}

package/dist/logger/agent-logger.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentLogger = void 0;
+/**
+ * AgentLogger binds to Agent events and formats them for logging
+ *
+ * This class is responsible for:
+ * - Listening to agent lifecycle events
+ * - Formatting event data into structured logs
+ * - Delegating actual logging to an ILogger implementation
+ */
+class AgentLogger {
+    agent;
+    logger;
+    constructor(agent, logger) {
+        this.agent = agent;
+        this.logger = logger;
+        this.bindEvents();
+    }
+    bindEvents() {
+        // Debug Events (Verbose details)
+        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,
+            };
+            // Show content if present
+            if (data.content) {
+                meta["Content"] = data.content;
+            }
+            // Show tool calls details if present
+            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 ? "❌ Failed" : "✓ Success";
+            const meta = {
+                Duration: `${data.durationMs}ms`,
+            };
+            // Show output or error
+            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);
+        });
+        // Info Events (High Level Flow)
+        this.agent.on("agent:execution:start", (event) => {
+            const { data, trace, correlationId } = event;
+            // Note: provider/model info is now in llm:call, but we can log generic start
+            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 / 1000).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" ? "✓" : data.status === "truncated" ? "⚠" : "❌"}`, {
+                Duration: duration,
+                Usage: usage,
+            }, data.agentName, "agent", trace);
+        });
+        this.agent.on("agent:tool:call", (event) => {
+            const { data, trace } = event;
+            // Parse input if it's a JSON string for better readability
+            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);
+        });
+        // Error Events
+        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);
+        });
+    }
+}
+exports.AgentLogger = AgentLogger;

package/dist/logger/formatters.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Logging formatters module
+ *
+ * Contains pure functions for formatting log messages.
+ * Each formatter is composable and testable.
+ */
+import type { LogLevel } from "./index.js";
+import type { TraceContext } from "../events/schemas.js";
+/**
+ * Formats a complete log line.
+ *
+ * New standard:
+ * - timestamp first
+ * - then source/context
+ *
+ * Examples:
+ * - 2026-01-13 14:58:46.188 [nebulaos/core | Workflow: Test Agent Workflow] DEBUG Execution Started
+ * - 2026-01-13 14:58:46.188 [nebulaos/client] DEBUG HTTP telemetry sent
+ */
+export declare function formatLogLine(level: LogLevel, entityName: string | null, message: string, entityType?: "agent" | "workflow" | null, trace?: TraceContext, source?: string): string;
+/**
+ * Formats metadata as nested tree structure
+ *
+ * @param meta - Object with key-value pairs
+ * @param isLastGroup - If true, uses └─ for last item, otherwise ├─
+ * @returns Array of formatted lines
+ */
+export declare function formatMetadata(meta: Record<string, any>, isLastGroup?: boolean): string[];
+/**
+ * Formats an error with stack trace
+ */
+export declare function formatError(error: Error | any): string[];

package/dist/logger/formatters.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Logging formatters module
+ *
+ * Contains pure functions for formatting log messages.
+ * Each formatter is composable and testable.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatLogLine = formatLogLine;
+exports.formatMetadata = formatMetadata;
+exports.formatError = formatError;
+const styles_js_1 = require("./styles.js");
+/**
+ * Formats a complete log line.
+ *
+ * New standard:
+ * - timestamp first
+ * - then source/context
+ *
+ * Examples:
+ * - 2026-01-13 14:58:46.188 [nebulaos/core | Workflow: Test Agent Workflow] DEBUG Execution Started
+ * - 2026-01-13 14:58:46.188 [nebulaos/client] DEBUG HTTP telemetry sent
+ */
+function formatLogLine(level, entityName, message, entityType = null, trace, source = "nebulaos/core") {
+    const timestamp = new Date().toISOString().replace("T", " ").replace("Z", "");
+    const levelColor = (level === "none" ? styles_js_1.COLORS.reset : styles_js_1.LOG_LEVEL_COLORS[level]) || styles_js_1.COLORS.reset;
+    const levelUpper = level.toUpperCase();
+    // timestamp first
+    const timestampStr = `${styles_js_1.COLORS.dim}${timestamp}${styles_js_1.COLORS.reset}`;
+    // Build the bracketed scope/context
+    let scope = source;
+    if (entityName) {
+        const entityLabel = entityType === "workflow" ? "Workflow" : "Agent";
+        scope = `${source} | ${entityLabel}: ${entityName}`;
+    }
+    const scopeStr = `${styles_js_1.COLORS.bold}[${scope}]${styles_js_1.COLORS.reset}`;
+    // Keep level visible (and colored), but do not bake it into the bracket.
+    const levelStr = `${levelColor}${styles_js_1.COLORS.bold}${levelUpper}${styles_js_1.COLORS.reset}`;
+    return `${timestampStr} ${scopeStr} ${levelStr} ${message}${styles_js_1.COLORS.reset}`;
+}
+/**
+ * Formats metadata as nested tree structure
+ *
+ * @param meta - Object with key-value pairs
+ * @param isLastGroup - If true, uses └─ for last item, otherwise ├─
+ * @returns Array of formatted lines
+ */
+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 ? styles_js_1.TREE_CHARS.last : styles_js_1.TREE_CHARS.branch;
+        const formattedValue = formatValue(value);
+        return `  ${styles_js_1.COLORS.dim}${char}${styles_js_1.COLORS.reset} ${styles_js_1.COLORS.bold}${key}:${styles_js_1.COLORS.reset} ${formattedValue}`;
+    });
+}
+/**
+ * Formats a single value for display
+ * Handles different types appropriately
+ */
+function formatValue(value) {
+    if (value === null)
+        return `${styles_js_1.COLORS.dim}null${styles_js_1.COLORS.reset}`;
+    if (value === undefined)
+        return `${styles_js_1.COLORS.dim}undefined${styles_js_1.COLORS.reset}`;
+    if (typeof value === "string") {
+        // Highlight important values
+        if (value.includes("✓") || value.includes("Success")) {
+            return `${styles_js_1.COLORS.green}${value}${styles_js_1.COLORS.reset}`;
+        }
+        if (value.includes("❌") || value.includes("Error")) {
+            return `${styles_js_1.COLORS.red}${value}${styles_js_1.COLORS.reset}`;
+        }
+        return value;
+    }
+    if (typeof value === "number") {
+        return `${styles_js_1.COLORS.yellow}${value}${styles_js_1.COLORS.reset}`;
+    }
+    if (typeof value === "boolean") {
+        return value
+            ? `${styles_js_1.COLORS.green}${value}${styles_js_1.COLORS.reset}`
+            : `${styles_js_1.COLORS.red}${value}${styles_js_1.COLORS.reset}`;
+    }
+    // Objects and arrays
+    try {
+        return `${styles_js_1.COLORS.dim}${JSON.stringify(value)}${styles_js_1.COLORS.reset}`;
+    }
+    catch {
+        return `${styles_js_1.COLORS.dim}[Object]${styles_js_1.COLORS.reset}`;
+    }
+}
+/**
+ * Formats an error with stack trace
+ */
+function formatError(error) {
+    const lines = [];
+    const pushMessageAndStack = (message, stack) => {
+        lines.push(`  ${styles_js_1.TREE_CHARS.branch} ${styles_js_1.COLORS.red}${message}${styles_js_1.COLORS.reset}`);
+        if (stack) {
+            const stackLines = stack.split("\n").slice(0, 4); // keep it short
+            // If the stack already contains the message on line 0, skip it.
+            const trimmed = stackLines[0]?.includes(message) ? stackLines.slice(1) : stackLines;
+            trimmed.slice(0, 3).forEach((line, index) => {
+                const isLast = index === Math.min(2, trimmed.length - 1);
+                const char = isLast ? styles_js_1.TREE_CHARS.last : styles_js_1.TREE_CHARS.branch;
+                lines.push(`  ${styles_js_1.COLORS.dim}${char} ${line.trim()}${styles_js_1.COLORS.reset}`);
+            });
+        }
+    };
+    // 1) Native Error
+    if (error instanceof Error) {
+        pushMessageAndStack(error.message, error.stack);
+        return lines;
+    }
+    // 2) Sanitized error objects (common in our event payloads): { message, stack, name, code, ... }
+    if (error && typeof error === "object") {
+        const maybeMessage = typeof error.message === "string"
+            ? error.message
+            : typeof error.error === "string"
+                ? error.error
+                : undefined;
+        const maybeStack = typeof error.stack === "string" ? error.stack : undefined;
+        const maybeCode = typeof error.code === "string" ? error.code : undefined;
+        const maybeName = typeof error.name === "string" ? error.name : undefined;
+        if (maybeMessage) {
+            const prefix = maybeCode ? `[${maybeCode}] ` : "";
+            const namePrefix = maybeName && maybeName !== "Error" ? `${maybeName}: ` : "";
+            pushMessageAndStack(`${prefix}${namePrefix}${maybeMessage}`, maybeStack);
+            return lines;
+        }
+        // If it's an object but has no message, JSON stringify for debugging.
+        try {
+            lines.push(`  ${styles_js_1.TREE_CHARS.last} ${styles_js_1.COLORS.red}${JSON.stringify(error)}${styles_js_1.COLORS.reset}`);
+            return lines;
+        }
+        catch {
+            lines.push(`  ${styles_js_1.TREE_CHARS.last} ${styles_js_1.COLORS.red}[Object]${styles_js_1.COLORS.reset}`);
+            return lines;
+        }
+    }
+    // 3) Fallback (string, number, boolean, null/undefined)
+    lines.push(`  ${styles_js_1.TREE_CHARS.last} ${styles_js_1.COLORS.red}${String(error)}${styles_js_1.COLORS.reset}`);
+    return lines;
+}

package/dist/logger/index.d.ts

@@ -0,0 +1,30 @@
+import type { TraceContext } from "../events/schemas.js";
+export type LogLevel = "debug" | "info" | "warn" | "error" | "none";
+export * from "./formatters.js";
+export * from "./styles.js";
+export { AgentLogger } from "./agent-logger.js";
+export { WorkflowLogger } from "./workflow-logger.js";
+/**
+ * Logger interface
+ * All loggers must implement these methods
+ */
+export interface ILogger {
+    debug(message: string, meta?: any, entityName?: string, entityType?: "agent" | "workflow", trace?: TraceContext): void;
+    info(message: string, meta?: any, entityName?: string, entityType?: "agent" | "workflow", trace?: TraceContext): void;
+    warn(message: string, meta?: any, entityName?: string, entityType?: "agent" | "workflow", trace?: TraceContext): void;
+    error(message: string, error?: any, entityName?: string, entityType?: "agent" | "workflow", trace?: TraceContext): void;
+}
+/**
+ * Console-based logger implementation
+ * Formats logs with colors, tree structure, and proper timestamps
+ */
+export declare class ConsoleLogger implements ILogger {
+    private minLevel;
+    private readonly source;
+    constructor(minLevel?: LogLevel, source?: string);
+    private shouldLog;
+    debug(message: string, meta?: any, entityName?: string, entityType?: "agent" | "workflow", trace?: TraceContext): void;
+    info(message: string, meta?: any, entityName?: string, entityType?: "agent" | "workflow", trace?: TraceContext): void;
+    warn(message: string, meta?: any, entityName?: string, entityType?: "agent" | "workflow", trace?: TraceContext): void;
+    error(message: string, error?: any, entityName?: string, entityType?: "agent" | "workflow", trace?: TraceContext): void;
+}

package/dist/logger/index.js

@@ -0,0 +1,88 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLogger = exports.WorkflowLogger = exports.AgentLogger = void 0;
+const formatters_js_1 = require("./formatters.js");
+// Re-export formatters and styles for extensibility
+__exportStar(require("./formatters.js"), exports);
+__exportStar(require("./styles.js"), exports);
+var agent_logger_js_1 = require("./agent-logger.js");
+Object.defineProperty(exports, "AgentLogger", { enumerable: true, get: function () { return agent_logger_js_1.AgentLogger; } });
+var workflow_logger_js_1 = require("./workflow-logger.js");
+Object.defineProperty(exports, "WorkflowLogger", { enumerable: true, get: function () { return workflow_logger_js_1.WorkflowLogger; } });
+const LEVEL_WEIGHTS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+    none: 4,
+};
+/**
+ * Console-based logger implementation
+ * Formats logs with colors, tree structure, and proper timestamps
+ */
+class ConsoleLogger {
+    minLevel;
+    source;
+    constructor(minLevel = "info", source = "nebulaos/core") {
+        this.minLevel = minLevel;
+        this.source = source;
+    }
+    shouldLog(level) {
+        return LEVEL_WEIGHTS[level] >= LEVEL_WEIGHTS[this.minLevel];
+    }
+    debug(message, meta, entityName, entityType, trace) {
+        if (!this.shouldLog("debug"))
+            return;
+        const mainLine = (0, formatters_js_1.formatLogLine)("debug", entityName || null, message, entityType || null, trace, this.source);
+        console.debug(mainLine);
+        if (meta && typeof meta === "object" && Object.keys(meta).length > 0) {
+            const metaLines = (0, formatters_js_1.formatMetadata)(meta);
+            metaLines.forEach(line => console.debug(line));
+        }
+    }
+    info(message, meta, entityName, entityType, trace) {
+        if (!this.shouldLog("info"))
+            return;
+        const mainLine = (0, formatters_js_1.formatLogLine)("info", entityName || null, message, entityType || null, trace, this.source);
+        console.info(mainLine);
+        if (meta && typeof meta === "object" && Object.keys(meta).length > 0) {
+            const metaLines = (0, formatters_js_1.formatMetadata)(meta);
+            metaLines.forEach(line => console.info(line));
+        }
+    }
+    warn(message, meta, entityName, entityType, trace) {
+        if (!this.shouldLog("warn"))
+            return;
+        const mainLine = (0, formatters_js_1.formatLogLine)("warn", entityName || null, message, entityType || null, trace, this.source);
+        console.warn(mainLine);
+        if (meta && typeof meta === "object" && Object.keys(meta).length > 0) {
+            const metaLines = (0, formatters_js_1.formatMetadata)(meta);
+            metaLines.forEach(line => console.warn(line));
+        }
+    }
+    error(message, error, entityName, entityType, trace) {
+        if (!this.shouldLog("error"))
+            return;
+        const mainLine = (0, formatters_js_1.formatLogLine)("error", entityName || null, message, entityType || null, trace, this.source);
+        console.error(mainLine);
+        if (error) {
+            const errorLines = (0, formatters_js_1.formatError)(error);
+            errorLines.forEach(line => console.error(line));
+        }
+    }
+}
+exports.ConsoleLogger = ConsoleLogger;

package/dist/logger/styles.d.ts

@@ -0,0 +1,46 @@
+/**
+ * ANSI escape codes for terminal styling
+ * Separated for maintainability and reusability
+ */
+export declare const COLORS: {
+    readonly black: "\u001B[30m";
+    readonly red: "\u001B[31m";
+    readonly green: "\u001B[32m";
+    readonly yellow: "\u001B[33m";
+    readonly blue: "\u001B[34m";
+    readonly magenta: "\u001B[35m";
+    readonly cyan: "\u001B[36m";
+    readonly white: "\u001B[37m";
+    readonly gray: "\u001B[90m";
+    readonly brightRed: "\u001B[91m";
+    readonly brightGreen: "\u001B[92m";
+    readonly brightYellow: "\u001B[93m";
+    readonly brightBlue: "\u001B[94m";
+    readonly brightMagenta: "\u001B[95m";
+    readonly brightCyan: "\u001B[96m";
+    readonly pink: "\u001B[38;5;213m";
+    readonly reset: "\u001B[0m";
+    readonly bold: "\u001B[1m";
+    readonly dim: "\u001B[2m";
+    readonly italic: "\u001B[3m";
+    readonly underline: "\u001B[4m";
+};
+/**
+ * Predefined color schemes for different log levels
+ * Using bright variants for better visibility
+ */
+export declare const LOG_LEVEL_COLORS: {
+    readonly debug: "\u001B[38;5;213m";
+    readonly info: "\u001B[92m";
+    readonly warn: "\u001B[93m";
+    readonly error: "\u001B[91m";
+};
+/**
+ * Tree characters for nested log lines
+ */
+export declare const TREE_CHARS: {
+    readonly branch: "├─";
+    readonly last: "└─";
+    readonly vertical: "│ ";
+    readonly space: "  ";
+};

package/dist/logger/styles.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * ANSI escape codes for terminal styling
+ * Separated for maintainability and reusability
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TREE_CHARS = exports.LOG_LEVEL_COLORS = exports.COLORS = void 0;
+exports.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",
+};
+/**
+ * Predefined color schemes for different log levels
+ * Using bright variants for better visibility
+ */
+exports.LOG_LEVEL_COLORS = {
+    debug: exports.COLORS.pink, // Rosa/Pink (NestJS style)
+    info: exports.COLORS.brightGreen, // Verde (success/positive)
+    warn: exports.COLORS.brightYellow, // Amarelo (warning)
+    error: exports.COLORS.brightRed, // Vermelho (error)
+};
+/**
+ * Tree characters for nested log lines
+ */
+exports.TREE_CHARS = {
+    branch: "├─",
+    last: "└─",
+    vertical: "│ ",
+    space: "  ",
+};

package/dist/logger/workflow-logger.d.ts

@@ -0,0 +1,16 @@
+import { Workflow } from "../workflow/Workflow.js";
+import { ILogger } from "./index.js";
+/**
+ * WorkflowLogger binds to Workflow events and formats them for logging
+ *
+ * This class is responsible for:
+ * - Listening to workflow lifecycle events
+ * - Formatting event data into structured logs
+ * - Delegating actual logging to an ILogger implementation
+ */
+export declare class WorkflowLogger {
+    private workflow;
+    private logger;
+    constructor(workflow: Workflow, logger: ILogger);
+    private bindEvents;
+}

package/dist/logger/workflow-logger.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowLogger = void 0;
+/**
+ * WorkflowLogger binds to Workflow events and formats them for logging
+ *
+ * This class is responsible for:
+ * - Listening to workflow lifecycle events
+ * - Formatting event data into structured logs
+ * - Delegating actual logging to an ILogger implementation
+ */
+class WorkflowLogger {
+    workflow;
+    logger;
+    constructor(workflow, logger) {
+        this.workflow = workflow;
+        this.logger = logger;
+        this.bindEvents();
+    }
+    bindEvents() {
+        const workflowName = this.workflow.name || this.workflow.id;
+        // Debug Events (Verbose details)
+        this.workflow.on("workflow:node:start", (event) => {
+            const { data, trace, executionId } = event;
+            this.logger.debug(`Node Started: ${data.nodeId}`, {
+                "Node ID": data.nodeId,
+                "Node Type": data.nodeType,
+                "Attempt": data.attempt,
+                "Execution ID": executionId,
+            }, workflowName, "workflow", trace);
+        });
+        this.workflow.on("workflow:node:end", (event) => {
+            const { data, trace, executionId } = event;
+            const duration = (data.durationMs / 1000).toFixed(2) + "s";
+            if (data.status === "success") {
+                this.logger.debug(`Node Completed: ${data.nodeId}`, {
+                    "Node Type": data.nodeType,
+                    "Attempt": data.attempt,
+                    "Duration": duration,
+                    "Execution ID": executionId,
+                }, workflowName, "workflow", trace);
+                return;
+            }
+            this.logger.warn(`Node Failed: ${data.nodeId}`, {
+                "Node Type": data.nodeType,
+                "Attempt": data.attempt,
+                "Duration": duration,
+                "Execution ID": executionId,
+                "Error": data.error?.message,
+            }, workflowName, "workflow", trace);
+        });
+        // Info Events (High Level Flow)
+        this.workflow.on("workflow:run:start", (event) => {
+            const { data, trace, executionId } = event;
+            this.logger.info(`Execution Started`, {
+                "Workflow ID": data.workflowId,
+                "Execution ID": executionId,
+                "Definition Version": data.definitionVersion,
+                "Input": typeof data.input === "string" ? data.input : JSON.stringify(data.input),
+            }, workflowName, "workflow", trace);
+        });
+        this.workflow.on("workflow:run:end", (event) => {
+            const { data, trace } = event;
+            const duration = (data.durationMs / 1000).toFixed(2) + "s";
+            this.logger.info(`Execution Completed ${data.status === "success" ? "✓" : "❌"}`, {
+                "Duration": duration,
+                "Status": data.status,
+                "Definition Version": data.definitionVersion,
+                "Output": typeof data.output === "string" ? data.output : JSON.stringify(data.output),
+            }, workflowName, "workflow", trace);
+        });
+        // Error Events
+        this.workflow.on("workflow:run:error", (event) => {
+            const { data, trace } = event;
+            this.logger.error(`Execution Error`, data.error, workflowName, "workflow", trace);
+        });
+    }
+}
+exports.WorkflowLogger = WorkflowLogger;

package/dist/multi-agent/agent-as-tool/AgentAsTool.d.ts

@@ -0,0 +1,16 @@
+import type { IMemory } from "../../agent/memory/index.js";
+import { Tool } from "../../agent/tools/index.js";
+import type { AgentAsToolConfig } from "../types/index.js";
+export declare class AgentAsTool extends Tool {
+    private callingMemory?;
+    private readonly target;
+    private readonly memoryConfig?;
+    private readonly extraPrompt?;
+    constructor(config: AgentAsToolConfig);
+    /**
+     * Allows orchestrators to set the calling agent/team memory when using
+     * `memory: { type: "shared" }`.
+     */
+    setCallingMemory(memory?: IMemory): void;
+    private runDelegated;
+}