@nebulaos/core 0.2.4 → 0.2.5

package/dist/agent/Agent.d.ts

@@ -1,4 +1,4 @@
-import { IModel, Message, ToolCall, StreamChunk, ProviderResponse, ContentPart } from "./provider/index.js";
+import { IModel, Message, ToolCall, TokenUsage, StreamChunk, ProviderResponse, ContentPart } from "./provider/index.js";
 import { IMemory, MemoryExecutionContext } from "./memory/index.js";
 import { Tool, ToolExecution } from "./tools/index.js";
 import { ISkill } from "./skills/index.js";
@@ -51,6 +51,7 @@ export type AgentResult = {
     llmCalls: number;
     totalDurationMs: number;
     truncated: boolean;
+    usage?: TokenUsage;
 };
 export type AgentStreamChunk = StreamChunk | {
     type: "tool_result";

package/dist/agent/Agent.js

@@ -8,6 +8,7 @@ const agent_logger_js_1 = require("../logger/agent-logger.js");
 const index_js_3 = require("../tracing/index.js");
 const BaseAgent_js_1 = require("./BaseAgent.js");
 const index_js_4 = require("../execution-context/index.js");
+const types_1 = require("@nebulaos/types");
 function generateCorrelationId() {
     return `exec_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
 }
@@ -155,262 +156,272 @@ class Agent extends BaseAgent_js_1.BaseAgent {
         let llmCalls = 0;
         let truncated = false;
         let totalUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
-        const runWithExecutionContext = async () => index_js_3.Tracing.withSpan({
-            kind: "agent",
-            name: `agent:${this.name}`,
-            correlationId,
-            executionId: options.executionId,
-            data: { agentName: this.name, input },
-        }, async (agentSpan) => {
-            this.emit("agent:execution:start", {
+        const runWithExecutionContext = async () => {
+            const agentStart = {
+                agentName: this.name,
+                input,
+            };
+            return index_js_3.Tracing.withSpan({
+                kind: types_1.SpanType.agent,
+                name: `agent:${this.name}`,
                 correlationId,
                 executionId: options.executionId,
-                data: {
-                    agentId: this.id,
-                    agentName: this.name,
-                    input,
-                },
-            });
-            try {
-                // Initialize skills if not already initialized
-                await this.initializeSkills();
-                if (input) {
-                    await this.addMessage({ role: "user", content: input }, memoryCtx);
-                }
-                let step = 0;
-                while (step < maxSteps) {
-                    step++;
+                data: agentStart,
+            }, async (agentSpan) => {
+                this.emit("agent:execution:start", {
+                    correlationId,
+                    executionId: options.executionId,
+                    data: {
+                        agentId: this.id,
+                        agentName: this.name,
+                        input,
+                    },
+                });
+                try {
+                    // Initialize skills if not already initialized
+                    await this.initializeSkills();
+                    if (input) {
+                        await this.addMessage({ role: "user", content: input }, memoryCtx);
+                    }
+                    let step = 0;
+                    while (step < maxSteps) {
+                        step++;
+                        llmCalls++;
+                        let messages = await this.getMessagesWithContext(memoryCtx);
+                        let tools = !options.disableTools && this.config.tools ? [...this.config.tools] : [];
+                        // Apply Request Interceptors
+                        let context = { messages, tools };
+                        for (const interceptor of this.requestInterceptors) {
+                            context = await interceptor(context);
+                        }
+                        messages = context.messages;
+                        tools = context.tools;
+                        this.validateMessagesForModel(messages, {
+                            maxFileBytes: MAX_MESSAGE_FILE_BYTES_DEFAULT,
+                            providerName: this.config.model.providerName,
+                            modelName: this.config.model.modelName,
+                            capabilities: this.config.model.capabilities,
+                        });
+                        const llmTools = tools.length > 0
+                            ? tools.map(t => t.toLLMDefinition())
+                            : undefined;
+                        this.emit("agent:llm:call", {
+                            correlationId,
+                            executionId: options.executionId,
+                            data: {
+                                agentId: this.id,
+                                agentName: this.name,
+                                step,
+                                messages,
+                                tools: llmTools,
+                                responseFormat: options.responseFormat,
+                                model: {
+                                    provider: this.config.model.providerName,
+                                    model: this.config.model.modelName,
+                                },
+                            },
+                        });
+                        // No SDK-side LLM span: the LLM Gateway creates its own span
+                        // with richer data. We just call generate under the agent span so
+                        // the provider can read the current trace context (traceparent).
+                        const rawResponse = await this.config.model.generate(messages, llmTools, {
+                            responseFormat: options.responseFormat,
+                        });
+                        let response = rawResponse;
+                        this.emit("agent:llm:response", {
+                            correlationId,
+                            executionId: options.executionId,
+                            data: {
+                                agentId: this.id,
+                                agentName: this.name,
+                                step,
+                                content: response.content,
+                                toolCalls: response.toolCalls,
+                                usage: response.usage,
+                                model: {
+                                    provider: this.config.model.providerName,
+                                    model: this.config.model.modelName,
+                                },
+                            },
+                        });
+                        // Accumulate token usage
+                        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) {
+                            // Apply Response Interceptors (Final Answer)
+                            for (const interceptor of this.responseInterceptors) {
+                                response = await interceptor(response);
+                            }
+                            await this.addMessage({ role: "assistant", content: response.content }, memoryCtx);
+                            const agentEnd = {
+                                output: options.responseFormat?.type === "json"
+                                    ? this.safeParseJson(response.content)
+                                    : response.content,
+                                usage: totalUsage,
+                            };
+                            await agentSpan.end({
+                                status: "success",
+                                data: agentEnd,
+                            });
+                            return this.finishResult({
+                                correlationId,
+                                executionId: options.executionId,
+                                content: options.responseFormat?.type === "json"
+                                    ? this.safeParseJson(response.content)
+                                    : response.content,
+                                toolExecutions,
+                                toolCalls: options.disableTools ? response.toolCalls : undefined,
+                                llmCalls,
+                                totalDurationMs: Date.now() - startTime,
+                                truncated: false,
+                                totalUsage,
+                            });
+                        }
+                        // Add assistant message with tool calls before executing tools
+                        await this.addMessage({
+                            role: "assistant",
+                            content: response.content,
+                            tool_calls: response.toolCalls
+                        }, memoryCtx);
+                        for (const toolCall of response.toolCalls) {
+                            const parentExec = index_js_4.ExecutionContext.getOrUndefined();
+                            const toolExecutionId = parentExec?.executionId || options.executionId ? (0, node_crypto_1.randomUUID)() : undefined;
+                            const toolStart = {
+                                toolName: toolCall.function.name,
+                                toolCallId: toolCall.id,
+                                args: toolCall.function.arguments,
+                            };
+                            await index_js_3.Tracing.withSpan({
+                                kind: types_1.SpanType.tool,
+                                name: `tool:${toolCall.function.name}`,
+                                correlationId,
+                                executionId: toolExecutionId ?? options.executionId,
+                                data: toolStart,
+                            }, async (toolSpan) => {
+                                this.emit("agent:tool:call", {
+                                    correlationId,
+                                    executionId: options.executionId,
+                                    data: {
+                                        agentId: this.id,
+                                        agentName: this.name,
+                                        toolName: toolCall.function.name,
+                                        toolCallId: toolCall.id,
+                                        args: toolCall.function.arguments,
+                                    },
+                                });
+                                const execution = await this.executeToolCall(toolCall, toolExecutionId);
+                                toolExecutions.push(execution);
+                                collectedToolCalls.push(toolCall);
+                                this.emit("agent:tool:result", {
+                                    correlationId,
+                                    executionId: options.executionId,
+                                    data: {
+                                        agentId: this.id,
+                                        agentName: this.name,
+                                        toolName: toolCall.function.name,
+                                        toolCallId: toolCall.id,
+                                        output: execution.output,
+                                        error: execution.error,
+                                        durationMs: execution.durationMs,
+                                    },
+                                });
+                                const toolEnd = execution.error
+                                    ? { error: execution.error }
+                                    : { output: execution.output };
+                                await toolSpan.end({
+                                    status: execution.error ? "error" : "success",
+                                    data: toolEnd,
+                                });
+                                await this.addMessage({
+                                    role: "tool",
+                                    tool_call_id: toolCall.id,
+                                    content: execution.error ? `Error: ${execution.error}` : JSON.stringify(execution.output),
+                                }, memoryCtx);
+                            });
+                        }
+                    }
+                    truncated = true;
                     llmCalls++;
-                    let messages = await this.getMessagesWithContext(memoryCtx);
-                    let tools = !options.disableTools && this.config.tools ? [...this.config.tools] : [];
-                    // Apply Request Interceptors
-                    let context = { messages, tools };
+                    // Final run after max steps (force answer)
+                    let finalMessages = await this.getMessagesWithContext(memoryCtx);
+                    let finalTools = !options.disableTools && this.config.tools ? [...this.config.tools] : [];
+                    // Interceptors for final run
+                    let context = { messages: finalMessages, tools: finalTools };
                     for (const interceptor of this.requestInterceptors) {
                         context = await interceptor(context);
                     }
-                    messages = context.messages;
-                    tools = context.tools;
-                    this.validateMessagesForModel(messages, {
+                    finalMessages = context.messages;
+                    // We ignore tools for final run usually, but keep consistency
+                    this.validateMessagesForModel(finalMessages, {
                         maxFileBytes: MAX_MESSAGE_FILE_BYTES_DEFAULT,
                         providerName: this.config.model.providerName,
                         modelName: this.config.model.modelName,
                         capabilities: this.config.model.capabilities,
                     });
-                    const llmTools = tools.length > 0
-                        ? tools.map(t => t.toLLMDefinition())
-                        : undefined;
-                    this.emit("agent:llm:call", {
+                    let finalResponse = await this.config.model.generate(finalMessages);
+                    // Response interceptors for final run
+                    for (const interceptor of this.responseInterceptors) {
+                        finalResponse = await interceptor(finalResponse);
+                    }
+                    await this.addMessage({ role: "assistant", content: finalResponse.content }, memoryCtx);
+                    const agentEndTruncated = {
+                        output: finalResponse.content,
+                        usage: totalUsage,
+                    };
+                    await agentSpan.end({
+                        status: truncated ? "cancelled" : "success",
+                        data: agentEndTruncated,
+                    });
+                    return this.finishResult({
                         correlationId,
                         executionId: options.executionId,
-                        data: {
-                            agentId: this.id,
-                            agentName: this.name,
-                            step,
-                            messages,
-                            tools: llmTools,
-                            responseFormat: options.responseFormat,
-                            model: {
-                                provider: this.config.model.providerName,
-                                model: this.config.model.modelName,
-                            },
-                        },
-                    });
-                    // No SDK-side LLM span: the LLM Gateway creates its own span
-                    // with richer data. We just call generate under the agent span so
-                    // the provider can read the current trace context (traceparent).
-                    const rawResponse = await this.config.model.generate(messages, llmTools, {
-                        responseFormat: options.responseFormat,
+                        content: finalResponse.content,
+                        toolExecutions,
+                        toolCalls: collectedToolCalls,
+                        llmCalls,
+                        totalDurationMs: Date.now() - startTime,
+                        truncated,
+                        totalUsage,
                     });
-                    let response = rawResponse;
-                    this.emit("agent:llm:response", {
+                }
+                catch (err) {
+                    const error = err instanceof Error ? err : new Error(String(err));
+                    this.emit("agent:execution:error", {
                         correlationId,
                         executionId: options.executionId,
                         data: {
                             agentId: this.id,
                             agentName: this.name,
-                            step,
-                            content: response.content,
-                            toolCalls: response.toolCalls,
-                            usage: response.usage,
-                            model: {
-                                provider: this.config.model.providerName,
-                                model: this.config.model.modelName,
+                            error: {
+                                message: error.message,
+                                stack: error.stack,
+                                name: error.name,
                             },
+                            durationMs: Date.now() - startTime,
                         },
                     });
-                    // Accumulate token usage
-                    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) {
-                        // Apply Response Interceptors (Final Answer)
-                        for (const interceptor of this.responseInterceptors) {
-                            response = await interceptor(response);
-                        }
-                        await this.addMessage({ role: "assistant", content: response.content }, memoryCtx);
-                        await agentSpan.end({
-                            status: "success",
-                            data: {
-                                output: options.responseFormat?.type === "json"
-                                    ? this.safeParseJson(response.content)
-                                    : response.content,
-                                usage: totalUsage,
-                            },
-                        });
-                        return this.finishResult({
-                            correlationId,
-                            executionId: options.executionId,
-                            content: options.responseFormat?.type === "json"
-                                ? this.safeParseJson(response.content)
-                                : response.content,
-                            toolExecutions,
-                            toolCalls: options.disableTools ? response.toolCalls : undefined,
-                            llmCalls,
-                            totalDurationMs: Date.now() - startTime,
-                            truncated: false,
-                            totalUsage,
-                        });
-                    }
-                    // Add assistant message with tool calls before executing tools
-                    await this.addMessage({
-                        role: "assistant",
-                        content: response.content,
-                        tool_calls: response.toolCalls
-                    }, memoryCtx);
-                    for (const toolCall of response.toolCalls) {
-                        const parentExec = index_js_4.ExecutionContext.getOrUndefined();
-                        const toolExecutionId = parentExec?.executionId || options.executionId ? (0, node_crypto_1.randomUUID)() : undefined;
-                        await index_js_3.Tracing.withSpan({
-                            kind: "tool",
-                            name: `tool:${toolCall.function.name}`,
-                            correlationId,
-                            executionId: toolExecutionId ?? options.executionId,
-                            data: {
-                                toolName: toolCall.function.name,
-                                toolCallId: toolCall.id,
-                                args: toolCall.function.arguments,
-                            },
-                        }, async (toolSpan) => {
-                            this.emit("agent:tool:call", {
-                                correlationId,
-                                executionId: options.executionId,
-                                data: {
-                                    agentId: this.id,
-                                    agentName: this.name,
-                                    toolName: toolCall.function.name,
-                                    toolCallId: toolCall.id,
-                                    args: toolCall.function.arguments,
-                                },
-                            });
-                            const execution = await this.executeToolCall(toolCall, toolExecutionId);
-                            toolExecutions.push(execution);
-                            collectedToolCalls.push(toolCall);
-                            this.emit("agent:tool:result", {
-                                correlationId,
-                                executionId: options.executionId,
-                                data: {
-                                    agentId: this.id,
-                                    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),
-                            }, memoryCtx);
-                        });
-                    }
-                }
-                truncated = true;
-                llmCalls++;
-                // Final run after max steps (force answer)
-                let finalMessages = await this.getMessagesWithContext(memoryCtx);
-                let finalTools = !options.disableTools && this.config.tools ? [...this.config.tools] : [];
-                // Interceptors for final run
-                let context = { messages: finalMessages, tools: finalTools };
-                for (const interceptor of this.requestInterceptors) {
-                    context = await interceptor(context);
-                }
-                finalMessages = context.messages;
-                // We ignore tools for final run usually, but keep consistency
-                this.validateMessagesForModel(finalMessages, {
-                    maxFileBytes: MAX_MESSAGE_FILE_BYTES_DEFAULT,
-                    providerName: this.config.model.providerName,
-                    modelName: this.config.model.modelName,
-                    capabilities: this.config.model.capabilities,
-                });
-                let finalResponse = await this.config.model.generate(finalMessages);
-                // Response interceptors for final run
-                for (const interceptor of this.responseInterceptors) {
-                    finalResponse = await interceptor(finalResponse);
-                }
-                await this.addMessage({ role: "assistant", content: finalResponse.content }, memoryCtx);
-                await agentSpan.end({
-                    status: truncated ? "cancelled" : "success",
-                    data: {
-                        output: finalResponse.content,
-                        usage: totalUsage,
-                    },
-                });
-                return this.finishResult({
-                    correlationId,
-                    executionId: options.executionId,
-                    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,
-                    executionId: options.executionId,
-                    data: {
-                        agentId: this.id,
-                        agentName: this.name,
-                        error: {
-                            message: error.message,
-                            stack: error.stack,
-                            name: error.name,
-                        },
-                        durationMs: Date.now() - startTime,
-                    },
-                });
-                await agentSpan.end({
-                    status: "error",
-                    data: {
+                    const agentEndError = {
                         error: {
                             message: error.message,
                             name: error.name,
                             code: error.code,
                             status: error.status,
                         },
-                    },
-                });
-                throw err;
-            }
-        });
+                    };
+                    await agentSpan.end({
+                        status: "error",
+                        data: agentEndError,
+                    });
+                    throw err;
+                }
+            });
+        };
         // Ensure execution hierarchy is available for tool sub-executions.
         // IMPORTANT: Do NOT override an existing ExecutionContext (e.g. when this agent is a sub-execution inside a workflow).
         const existingExecContext = index_js_4.ExecutionContext.getOrUndefined();
@@ -560,16 +571,17 @@ class Agent extends BaseAgent_js_1.BaseAgent {
                 }
                 await this.addMessage({ role: "assistant", content: fullContent || null, tool_calls: toolCalls }, memoryCtx);
                 for (const toolCall of toolCalls) {
+                    const toolStartStream = {
+                        toolName: toolCall.function.name,
+                        toolCallId: toolCall.id,
+                        args: toolCall.function.arguments,
+                    };
                     const execution = await index_js_3.Tracing.withSpan({
-                        kind: "tool",
+                        kind: types_1.SpanType.tool,
                         name: `tool:${toolCall.function.name}`,
                         correlationId,
                         executionId: options.executionId,
-                        data: {
-                            toolName: toolCall.function.name,
-                            toolCallId: toolCall.id,
-                            args: toolCall.function.arguments,
-                        },
+                        data: toolStartStream,
                     }, async (toolSpan) => {
                         this.emit("agent:tool:call", {
                             correlationId,
@@ -598,9 +610,12 @@ class Agent extends BaseAgent_js_1.BaseAgent {
                                 durationMs: exec.durationMs,
                             },
                         });
+                        const toolEndStream = exec.error
+                            ? { error: exec.error }
+                            : { output: exec.output };
                         await toolSpan.end({
                             status: exec.error ? "error" : "success",
-                            data: { output: exec.output, error: exec.error },
+                            data: toolEndStream,
                         });
                         return exec;
                     });
@@ -870,6 +885,7 @@ class Agent extends BaseAgent_js_1.BaseAgent {
             llmCalls: params.llmCalls,
             totalDurationMs: params.totalDurationMs,
             truncated: params.truncated,
+            usage: params.totalUsage,
         };
         this.emit("agent:execution:end", {
             correlationId: params.correlationId,

package/dist/multi-agent/committee-team/CommitteeTeam.js

@@ -21,12 +21,16 @@ class CommitteeTeam extends BaseAgent_js_1.BaseAgent {
     async execute(input, options) {
         const correlationId = `committee_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
         const startTime = Date.now();
+        const startData = {
+            agentName: this.name,
+            input,
+        };
         return index_js_1.Tracing.withSpan({
             kind: "agent",
             name: `team:committee:${this.name}`,
             correlationId,
             executionId: options?.executionId,
-            data: { agentName: this.name, input },
+            data: startData,
         }, async (teamSpan) => {
             this.emit("agent:execution:start", {
                 correlationId,
@@ -73,9 +77,10 @@ class CommitteeTeam extends BaseAgent_js_1.BaseAgent {
                         durationMs: Date.now() - startTime,
                     },
                 });
+                const endData = { output: result.content };
                 await teamSpan.end({
                     status: result.truncated ? "cancelled" : "success",
-                    data: { output: result.content },
+                    data: endData,
                 });
                 return result;
             }
@@ -95,7 +100,8 @@ class CommitteeTeam extends BaseAgent_js_1.BaseAgent {
                         durationMs: Date.now() - startTime,
                     },
                 });
-                await teamSpan.end({ status: "error" });
+                const errorData = { error: { message: err.message, name: err.name } };
+                await teamSpan.end({ status: "error", data: errorData });
                 throw error;
             }
         });

package/dist/multi-agent/handoff-team/HandoffTeam.js

@@ -23,12 +23,16 @@ class HandoffTeam extends BaseAgent_js_1.BaseAgent {
     async execute(input, options) {
         const correlationId = `handoff_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
         const startTime = Date.now();
+        const startData = {
+            agentName: this.name,
+            input,
+        };
         return index_js_2.Tracing.withSpan({
             kind: "agent",
             name: `team:handoff:${this.name}`,
             correlationId,
             executionId: options?.executionId,
-            data: { agentName: this.name, input },
+            data: startData,
         }, async (teamSpan) => {
             this.emit("agent:execution:start", {
                 correlationId,
@@ -84,9 +88,10 @@ class HandoffTeam extends BaseAgent_js_1.BaseAgent {
                                     durationMs: Date.now() - startTime,
                                 },
                             });
+                            const endData = { output: result.content };
                             await teamSpan.end({
                                 status: result.truncated ? "cancelled" : "success",
-                                data: { output: result.content },
+                                data: endData,
                             });
                             return result;
                         }
@@ -132,7 +137,8 @@ class HandoffTeam extends BaseAgent_js_1.BaseAgent {
                         durationMs: Date.now() - startTime,
                     },
                 });
-                await teamSpan.end({ status: "error" });
+                const errorData = { error: { message: err.message, name: err.name } };
+                await teamSpan.end({ status: "error", data: errorData });
                 throw error;
             }
         });

package/dist/multi-agent/hierarchical-team/HierarchicalTeam.js

@@ -26,12 +26,16 @@ class HierarchicalTeam extends BaseAgent_js_1.BaseAgent {
     async execute(input, options) {
         const correlationId = `hierarchical_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
         const startTime = Date.now();
+        const startData = {
+            agentName: this.name,
+            input,
+        };
         return index_js_1.Tracing.withSpan({
             kind: "agent",
             name: `team:hierarchical:${this.name}`,
             correlationId,
             executionId: options?.executionId,
-            data: { agentName: this.name, input },
+            data: startData,
         }, async (teamSpan) => {
             this.emit("agent:execution:start", {
                 correlationId,
@@ -57,9 +61,10 @@ class HierarchicalTeam extends BaseAgent_js_1.BaseAgent {
                         durationMs: Date.now() - startTime,
                     },
                 });
+                const endData = { output: result.content };
                 await teamSpan.end({
                     status: result.truncated ? "cancelled" : "success",
-                    data: { output: result.content },
+                    data: endData,
                 });
                 return result;
             }
@@ -79,7 +84,8 @@ class HierarchicalTeam extends BaseAgent_js_1.BaseAgent {
                         durationMs: Date.now() - startTime,
                     },
                 });
-                await teamSpan.end({ status: "error" });
+                const errorData = { error: { message: err.message, name: err.name } };
+                await teamSpan.end({ status: "error", data: errorData });
                 throw error;
             }
         });

package/dist/multi-agent/pipeline-team/PipelineTeam.js

@@ -18,12 +18,16 @@ class PipelineTeam extends BaseAgent_js_1.BaseAgent {
     async execute(input, options) {
         const correlationId = `pipeline_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
         const startTime = Date.now();
+        const startData = {
+            agentName: this.name,
+            input,
+        };
         return index_js_1.Tracing.withSpan({
             kind: "agent",
             name: `team:pipeline:${this.name}`,
             correlationId,
             executionId: options?.executionId,
-            data: { agentName: this.name, input },
+            data: startData,
         }, async (teamSpan) => {
             this.emit("agent:execution:start", {
                 correlationId,
@@ -61,9 +65,10 @@ class PipelineTeam extends BaseAgent_js_1.BaseAgent {
                         durationMs: Date.now() - startTime,
                     },
                 });
+                const endData = { output: result.content };
                 await teamSpan.end({
                     status: result.truncated ? "cancelled" : "success",
-                    data: { output: result.content },
+                    data: endData,
                 });
                 return result;
             }
@@ -83,7 +88,8 @@ class PipelineTeam extends BaseAgent_js_1.BaseAgent {
                         durationMs: Date.now() - startTime,
                     },
                 });
-                await teamSpan.end({ status: "error" });
+                const errorData = { error: { message: err.message, name: err.name } };
+                await teamSpan.end({ status: "error", data: errorData });
                 throw error;
             }
         });

package/dist/multi-agent/router-team/RouterTeam.js

@@ -19,12 +19,16 @@ class RouterTeam extends BaseAgent_js_1.BaseAgent {
     async execute(input, options) {
         const correlationId = `router_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
         const startTime = Date.now();
+        const startData = {
+            agentName: this.name,
+            input,
+        };
         return index_js_1.Tracing.withSpan({
             kind: "agent",
             name: `team:router:${this.name}`,
             correlationId,
             executionId: options?.executionId,
-            data: { agentName: this.name, input },
+            data: startData,
         }, async (teamSpan) => {
             this.emit("agent:execution:start", {
                 correlationId,
@@ -59,9 +63,10 @@ class RouterTeam extends BaseAgent_js_1.BaseAgent {
                         // Usage? Ideally aggregated, but for now passing result content is key
                     },
                 });
+                const endData = { output: result.content, usage: result.usage };
                 await teamSpan.end({
                     status: result.truncated ? "cancelled" : "success",
-                    data: { output: result.content },
+                    data: endData
                 });
                 return result;
             }
@@ -81,7 +86,13 @@ class RouterTeam extends BaseAgent_js_1.BaseAgent {
                         durationMs: Date.now() - startTime,
                     },
                 });
-                await teamSpan.end({ status: "error" });
+                const errorData = {
+                    error: { message: err.message, name: err.name, code: err.code, status: err.status }
+                };
+                await teamSpan.end({
+                    status: "error",
+                    data: errorData
+                });
                 throw error;
             }
         });

package/dist/tracing/index.js

@@ -45,8 +45,6 @@ class ActiveSpan {
             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,
             },
         };

package/dist/workflow/execution/WorkflowTelemetry.js

@@ -11,8 +11,12 @@ class WorkflowTelemetry {
             data: { workflowId: input.workflowId, input: input.workflowInput },
         }, async (span) => {
             const result = await fn();
+            const endData = { output: result };
             if (!span.isEnded)
-                await span.end({ status: "success" });
+                await span.end({
+                    status: "success",
+                    data: endData
+                });
             return result;
         });
     }
@@ -30,11 +34,17 @@ class WorkflowTelemetry {
         }, async (span) => {
             try {
                 const result = await fn();
-                await span.end({ status: "success", data: { output: result } });
+                const successData = { output: result };
+                await span.end({ status: "success", data: successData });
                 return result;
             }
             catch (e) {
-                await span.end({ status: "error" });
+                const err = e instanceof Error ? e : new Error(String(e));
+                const errorData = { error: { message: err.message, name: err.name } };
+                await span.end({
+                    status: "error",
+                    data: errorData
+                });
                 throw e;
             }
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nebulaos/core",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "Core primitives for NebulaOS (Agent, Workflow, Providers)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -33,7 +33,7 @@
     "uuid": "^9.0.1",
     "zod": "^3.0.0",
     "zod-to-json-schema": "^3.0.0",
-    "@nebulaos/types": "^0.1.3"
+    "@nebulaos/types": "^0.1.4"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",
@@ -44,8 +44,8 @@
     "ts-jest": "^29.4.6",
     "typescript": "^5.0.0",
     "@nebulaos/oci": "0.0.1",
-    "@nebulaos/google-gemini": "0.0.1",
-    "@nebulaos/openai": "0.1.0"
+    "@nebulaos/openai": "0.1.0",
+    "@nebulaos/google-gemini": "0.0.1"
   },
   "scripts": {
     "build": "tsc",