@eggjs/agent-tracing 3.73.0-beta.1

package/dist/src/ClaudeAgentTracer.js

@@ -0,0 +1,448 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeAgentTracer = exports.TraceSession = void 0;
+const node_crypto_1 = require("node:crypto");
+const core_decorator_1 = require("@eggjs/core-decorator");
+const tegg_types_1 = require("@eggjs/tegg-types");
+const types_1 = require("./types");
+/**
+ * TraceSession - Manages state for a single agent execution with streaming support.
+ * Allows processing messages one-by-one and logging them immediately.
+ */
+class TraceSession {
+    constructor(tracer, sessionId) {
+        this.rootRun = null;
+        this.executionOrder = 2; // Start at 2, root is 1
+        this.pendingToolUses = new Map();
+        this.tracer = tracer;
+        this.traceId = sessionId || (0, node_crypto_1.randomUUID)();
+        this.rootRunId = (0, node_crypto_1.randomUUID)();
+        this.startTime = Date.now();
+    }
+    /**
+     * Process a single SDK message and log it immediately.
+     * Non-tracing message types (tool_progress, stream_event, status, etc.) are automatically ignored.
+     */
+    async processMessage(message) {
+        try {
+            const converted = this.tracer.convertSDKMessage(message);
+            if (!converted)
+                return;
+            if (converted.type === 'system' && converted.subtype === 'init') {
+                this.handleInit(converted);
+            }
+            else if (converted.type === 'assistant') {
+                this.handleAssistant(converted);
+            }
+            else if (converted.type === 'user') {
+                this.handleUser(converted);
+            }
+            else if (converted.type === 'result') {
+                this.handleResult(converted);
+            }
+        }
+        catch (e) {
+            this.tracer.logger.warn('[ClaudeAgentTracer] processMessage error:', e);
+        }
+    }
+    handleInit(message) {
+        this.traceId = message.session_id || this.traceId;
+        this.rootRun = this.tracer.createRootRunInternal(message, this.startTime, this.traceId, this.rootRunId);
+        this.tracer.logTrace(this.rootRun, types_1.RunStatus.START);
+    }
+    handleAssistant(message) {
+        var _a;
+        if (!this.rootRun) {
+            this.tracer.logger.warn('[ClaudeAgentTracer] Received assistant message before init');
+            return;
+        }
+        const content = ((_a = message.message) === null || _a === void 0 ? void 0 : _a.content) || [];
+        const hasToolUse = content.some(c => c.type === 'tool_use');
+        const hasText = content.some(c => c.type === 'text');
+        if (hasToolUse) {
+            const eventTime = Date.now();
+            // Create LLM run that initiated tool calls
+            const llmRun = this.tracer.createLLMRunInternal(message, this.rootRunId, this.traceId, this.executionOrder++, eventTime, true);
+            this.rootRun.child_runs.push(llmRun);
+            this.tracer.logTrace(llmRun, types_1.RunStatus.END);
+            // Create tool runs (will be completed when tool_result arrives)
+            for (const block of content) {
+                if (block.type === 'tool_use') {
+                    const toolRun = this.tracer.createToolRunStartInternal(block, this.rootRunId, this.traceId, this.executionOrder++, eventTime);
+                    this.rootRun.child_runs.push(toolRun);
+                    this.pendingToolUses.set(block.id, toolRun);
+                    this.tracer.logTrace(toolRun, types_1.RunStatus.START);
+                }
+            }
+        }
+        else if (hasText) {
+            // Text-only response
+            const llmRun = this.tracer.createLLMRunInternal(message, this.rootRunId, this.traceId, this.executionOrder++, Date.now(), false);
+            this.rootRun.child_runs.push(llmRun);
+            this.tracer.logTrace(llmRun, types_1.RunStatus.END);
+        }
+    }
+    handleUser(message) {
+        var _a;
+        if (!((_a = message.message) === null || _a === void 0 ? void 0 : _a.content))
+            return;
+        for (const block of message.message.content) {
+            if (block.type === 'tool_result') {
+                const toolRun = this.pendingToolUses.get(block.tool_use_id);
+                if (toolRun) {
+                    this.tracer.completeToolRunInternal(toolRun, block, Date.now());
+                    const status = block.is_error ? types_1.RunStatus.ERROR : types_1.RunStatus.END;
+                    this.tracer.logTrace(toolRun, status);
+                    this.pendingToolUses.delete(block.tool_use_id);
+                }
+            }
+        }
+    }
+    handleResult(message) {
+        if (!this.rootRun) {
+            this.tracer.logger.warn('[ClaudeAgentTracer] Received result message before init');
+            return;
+        }
+        // Complete any pending tool runs
+        for (const [toolUseId, toolRun] of this.pendingToolUses) {
+            this.tracer.logger.warn(`[ClaudeAgentTracer] Tool run ${toolUseId} did not receive result`);
+            toolRun.end_time = Date.now();
+            this.tracer.logTrace(toolRun, types_1.RunStatus.ERROR);
+        }
+        this.pendingToolUses.clear();
+        // Update and log root run end
+        this.rootRun.end_time = this.startTime + (message.duration_ms || 0);
+        this.rootRun.outputs = {
+            result: message.result,
+            is_error: message.is_error,
+            num_turns: message.num_turns,
+        };
+        if (message.usage || message.modelUsage) {
+            const cost = this.tracer.createRunCostInternal(message);
+            if (this.rootRun.outputs) {
+                this.rootRun.outputs.llmOutput = cost;
+            }
+        }
+        if (message.is_error) {
+            this.rootRun.error = message.result;
+        }
+        this.rootRun.child_execution_order = this.executionOrder - 1;
+        const status = message.is_error ? types_1.RunStatus.ERROR : types_1.RunStatus.END;
+        this.tracer.logTrace(this.rootRun, status);
+    }
+    /**
+     * Get current trace ID
+     */
+    getTraceId() {
+        return this.traceId;
+    }
+}
+exports.TraceSession = TraceSession;
+/**
+ * ClaudeAgentTracer - Converts Claude SDK messages to LangChain Run format
+ * and logs them to the same remote logging system as LangGraphTracer.
+ *
+ * Supports both batch processing (processMessages) and streaming (createSession).
+ */
+let ClaudeAgentTracer = class ClaudeAgentTracer {
+    constructor() {
+        this.name = 'ClaudeAgentTracer';
+        this.agentName = '';
+    }
+    /**
+     * Configure the tracer with agent name and service credentials.
+     */
+    configure(config) {
+        (0, types_1.applyTracerConfig)(this, config);
+    }
+    /**
+     * Create a new trace session for streaming message processing.
+     * Use this for real-time tracing where messages arrive one-by-one.
+     *
+     * @example
+     * const session = claudeTracer.createSession();
+     * for await (const message of agent.run('task')) {
+     *   await session.processMessage(message);
+     * }
+     */
+    createSession(sessionId) {
+        return new TraceSession(this, sessionId);
+    }
+    /**
+     * Main entry point - convert SDK messages to Run trees and log them.
+     * Use this when you have all messages collected (batch processing).
+     * For real-time streaming, use createSession() instead.
+     *
+     * Non-tracing message types (tool_progress, stream_event, status, etc.) are automatically filtered out.
+     */
+    async processMessages(sdkMessages) {
+        try {
+            if (!sdkMessages || sdkMessages.length === 0) {
+                this.logger.warn('[ClaudeAgentTracer] No messages to process');
+                return;
+            }
+            // Pre-validate: ensure there is an init message before creating session
+            const hasInit = sdkMessages.some(m => m.type === 'system' && 'subtype' in m && m.subtype === 'init');
+            if (!hasInit) {
+                this.logger.warn('[ClaudeAgentTracer] No system/init message found');
+                return;
+            }
+            // Delegate to TraceSession for message processing
+            const session = this.createSession();
+            for (const msg of sdkMessages) {
+                await session.processMessage(msg);
+            }
+        }
+        catch (e) {
+            this.logger.warn('[ClaudeAgentTracer] processMessages error:', e);
+        }
+    }
+    /**
+     * @internal
+     * Convert an SDKMessage to internal ClaudeMessage format.
+     * Returns null for message types that are not relevant to tracing.
+     */
+    convertSDKMessage(msg) {
+        var _a;
+        // SDKSystemMessage (init)
+        if (msg.type === 'system' && 'subtype' in msg && msg.subtype === 'init') {
+            return msg;
+        }
+        // SDKAssistantMessage
+        if (msg.type === 'assistant' && 'message' in msg && 'parent_tool_use_id' in msg) {
+            return {
+                type: 'assistant',
+                uuid: msg.uuid,
+                session_id: msg.session_id,
+                message: msg.message,
+                parent_tool_use_id: msg.parent_tool_use_id,
+            };
+        }
+        // SDKUserMessage (tool results, not replay)
+        if (msg.type === 'user' && 'message' in msg && !('isReplay' in msg && msg.isReplay)) {
+            return {
+                type: 'user',
+                uuid: msg.uuid || (0, node_crypto_1.randomUUID)(),
+                session_id: msg.session_id,
+                message: msg.message,
+                parent_tool_use_id: msg.parent_tool_use_id,
+            };
+        }
+        // SDKResultMessage (success or error)
+        if (msg.type === 'result') {
+            const resultMsg = msg;
+            const isSuccess = resultMsg.subtype === 'success';
+            return {
+                type: 'result',
+                subtype: isSuccess ? 'success' : 'error',
+                is_error: resultMsg.is_error,
+                duration_ms: resultMsg.duration_ms,
+                duration_api_ms: resultMsg.duration_api_ms,
+                num_turns: resultMsg.num_turns,
+                result: isSuccess ? resultMsg.result : ((_a = resultMsg.errors) === null || _a === void 0 ? void 0 : _a.join('; ')) || 'Unknown error',
+                session_id: resultMsg.session_id,
+                total_cost_usd: resultMsg.total_cost_usd,
+                usage: resultMsg.usage,
+                modelUsage: resultMsg.modelUsage,
+                uuid: resultMsg.uuid,
+            };
+        }
+        // Ignore all other SDK message types (tool_progress, stream_event, status, hook, etc.)
+        return null;
+    }
+    /**
+     * @internal
+     * Create root run from init message (used by TraceSession)
+     */
+    createRootRunInternal(initMsg, startTime, traceId, rootRunId) {
+        const runId = rootRunId || initMsg.uuid || (0, node_crypto_1.randomUUID)();
+        return {
+            id: runId,
+            name: this.name,
+            run_type: 'chain',
+            inputs: {
+                tools: initMsg.tools || [],
+                model: initMsg.model,
+                session_id: initMsg.session_id,
+                mcp_servers: initMsg.mcp_servers,
+                agents: initMsg.agents,
+                slash_commands: initMsg.slash_commands,
+            },
+            outputs: undefined,
+            start_time: startTime,
+            end_time: undefined,
+            execution_order: 1,
+            child_execution_order: 1,
+            child_runs: [],
+            events: [],
+            trace_id: traceId,
+            parent_run_id: undefined,
+            tags: [],
+            extra: {
+                metadata: {
+                    thread_id: initMsg.session_id,
+                },
+                apiKeySource: initMsg.apiKeySource,
+                claude_code_version: initMsg.claude_code_version,
+                output_style: initMsg.output_style,
+                permissionMode: initMsg.permissionMode,
+            },
+        };
+    }
+    /**
+     * @internal
+     * Create LLM run from assistant message (used by TraceSession)
+     */
+    createLLMRunInternal(msg, rootRunId, traceId, order, startTime, isToolCall) {
+        var _a, _b, _c;
+        const runId = msg.uuid || (0, node_crypto_1.randomUUID)();
+        const content = ((_a = msg.message) === null || _a === void 0 ? void 0 : _a.content) || [];
+        const textBlocks = content.filter(c => c.type === 'text');
+        const toolBlocks = content.filter(c => c.type === 'tool_use');
+        const inputs = {
+            messages: textBlocks.map(c => c.text).filter(Boolean),
+        };
+        const outputs = {};
+        if (isToolCall) {
+            outputs.tool_calls = toolBlocks.map(c => ({
+                id: c.id,
+                name: c.name,
+                input: c.input,
+            }));
+        }
+        else {
+            outputs.content = textBlocks.map(c => c.text).join('');
+        }
+        if ((_b = msg.message) === null || _b === void 0 ? void 0 : _b.usage) {
+            outputs.llmOutput = this.extractTokenUsage(msg.message.usage);
+        }
+        return {
+            id: runId,
+            name: 'LLM',
+            run_type: 'llm',
+            inputs,
+            outputs,
+            start_time: startTime,
+            end_time: startTime,
+            execution_order: order,
+            child_execution_order: order,
+            child_runs: [],
+            events: [],
+            trace_id: traceId,
+            parent_run_id: rootRunId,
+            tags: [],
+            extra: {
+                model: (_c = msg.message) === null || _c === void 0 ? void 0 : _c.model,
+            },
+        };
+    }
+    /**
+     * @internal
+     * Create tool run at start (before result, used by TraceSession)
+     */
+    createToolRunStartInternal(toolUseBlock, rootRunId, traceId, order, startTime) {
+        const toolUse = toolUseBlock;
+        const runId = (0, node_crypto_1.randomUUID)();
+        return {
+            id: runId,
+            name: toolUse.name || 'Tool',
+            run_type: 'tool',
+            inputs: {
+                tool_use_id: toolUse.id,
+                ...toolUse.input,
+            },
+            outputs: undefined,
+            start_time: startTime,
+            end_time: undefined,
+            execution_order: order,
+            child_execution_order: order,
+            child_runs: [],
+            events: [],
+            trace_id: traceId,
+            parent_run_id: rootRunId,
+            tags: [],
+            extra: {
+                tool_use_id: toolUse.id,
+            },
+        };
+    }
+    /**
+     * @internal
+     * Complete tool run with result (used by TraceSession)
+     */
+    completeToolRunInternal(toolRun, toolResultBlock, startTime) {
+        const result = toolResultBlock;
+        toolRun.end_time = startTime;
+        toolRun.outputs = {
+            content: result.content,
+        };
+        if (result.is_error) {
+            toolRun.error = typeof result.content === 'string' ? result.content : JSON.stringify(result.content);
+        }
+    }
+    /**
+     * Extract token usage from Claude SDK usage object into IRunCost format.
+     */
+    extractTokenUsage(usage) {
+        const result = {};
+        if (usage.input_tokens !== undefined) {
+            result.promptTokens = usage.input_tokens;
+        }
+        if (usage.output_tokens !== undefined) {
+            result.completionTokens = usage.output_tokens;
+        }
+        if (usage.cache_creation_input_tokens !== undefined) {
+            result.cacheCreationInputTokens = usage.cache_creation_input_tokens;
+        }
+        if (usage.cache_read_input_tokens !== undefined) {
+            result.cacheReadInputTokens = usage.cache_read_input_tokens;
+        }
+        const totalTokens = (usage.input_tokens || 0) + (usage.output_tokens || 0);
+        if (totalTokens > 0) {
+            result.totalTokens = totalTokens;
+        }
+        return result;
+    }
+    /**
+     * @internal
+     * Create run cost from result message (used by TraceSession)
+     */
+    createRunCostInternal(resultMsg) {
+        const cost = resultMsg.usage ? this.extractTokenUsage(resultMsg.usage) : {};
+        if (resultMsg.total_cost_usd !== undefined) {
+            cost.totalCost = resultMsg.total_cost_usd;
+        }
+        return cost;
+    }
+    /**
+     * @internal
+     * Log trace - delegates to TracingService (used by TraceSession)
+     */
+    logTrace(run, status) {
+        this.tracingService.logTrace(run, status, this.name, this.agentName);
+    }
+};
+exports.ClaudeAgentTracer = ClaudeAgentTracer;
+__decorate([
+    (0, core_decorator_1.Inject)(),
+    __metadata("design:type", Object)
+], ClaudeAgentTracer.prototype, "logger", void 0);
+__decorate([
+    (0, core_decorator_1.Inject)(),
+    __metadata("design:type", Function)
+], ClaudeAgentTracer.prototype, "tracingService", void 0);
+exports.ClaudeAgentTracer = ClaudeAgentTracer = __decorate([
+    (0, core_decorator_1.SingletonProto)({
+        accessLevel: tegg_types_1.AccessLevel.PUBLIC,
+    })
+], ClaudeAgentTracer);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ClaudeAgentTracer.js","sourceRoot":"","sources":["../../src/ClaudeAgentTracer.ts"],"names":[],"mappings":"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"}

package/dist/src/LangGraphTracer.d.ts

@@ -0,0 +1,28 @@
+import { BaseTracer } from '@langchain/core/tracers/base';
+import type { Run } from '@langchain/core/tracers/base';
+import { type TracerConfig } from './types';
+export declare class LangGraphTracer extends BaseTracer {
+    private tracingService;
+    name: string;
+    agentName: string;
+    /**
+     * Configure the tracer with agent name and service credentials.
+     */
+    configure(config: TracerConfig): void;
+    protected persistRun(_: Run): Promise<void>;
+    private logTrace;
+    onChainStart(run: Run): void | Promise<void>;
+    onChainEnd(run: Run): void | Promise<void>;
+    onChainError(run: Run): void | Promise<void>;
+    onToolStart(run: Run): void | Promise<void>;
+    onToolEnd(run: Run): void | Promise<void>;
+    onToolError(run: Run): void | Promise<void>;
+    onLLMStart(run: Run): void | Promise<void>;
+    onLLMEnd(run: Run): void | Promise<void>;
+    onLLMError(run: Run): void | Promise<void>;
+    onRetrieverStart(run: Run): void | Promise<void>;
+    onRetrieverEnd(run: Run): void | Promise<void>;
+    onRetrieverError(run: Run): void | Promise<void>;
+    onAgentAction(run: Run): void | Promise<void>;
+    onAgentEnd(run: Run): void | Promise<void>;
+}

package/dist/src/LangGraphTracer.js

@@ -0,0 +1,89 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LangGraphTracer = void 0;
+const core_decorator_1 = require("@eggjs/core-decorator");
+const tegg_types_1 = require("@eggjs/tegg-types");
+const base_1 = require("@langchain/core/tracers/base");
+const types_1 = require("./types");
+let LangGraphTracer = class LangGraphTracer extends base_1.BaseTracer {
+    constructor() {
+        super(...arguments);
+        this.name = 'LangGraphTracer';
+        this.agentName = '';
+    }
+    /**
+     * Configure the tracer with agent name and service credentials.
+     */
+    configure(config) {
+        (0, types_1.applyTracerConfig)(this, config);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    persistRun(_) {
+        return Promise.resolve(undefined);
+    }
+    logTrace(run, status) {
+        this.tracingService.logTrace(run, status, this.name, this.agentName);
+    }
+    onChainStart(run) {
+        this.logTrace(run, types_1.RunStatus.START);
+    }
+    onChainEnd(run) {
+        this.logTrace(run, types_1.RunStatus.END);
+    }
+    onChainError(run) {
+        this.logTrace(run, types_1.RunStatus.ERROR);
+    }
+    onToolStart(run) {
+        this.logTrace(run, types_1.RunStatus.START);
+    }
+    onToolEnd(run) {
+        this.logTrace(run, types_1.RunStatus.END);
+    }
+    onToolError(run) {
+        this.logTrace(run, types_1.RunStatus.ERROR);
+    }
+    onLLMStart(run) {
+        this.logTrace(run, types_1.RunStatus.START);
+    }
+    onLLMEnd(run) {
+        this.logTrace(run, types_1.RunStatus.END);
+    }
+    onLLMError(run) {
+        this.logTrace(run, types_1.RunStatus.ERROR);
+    }
+    onRetrieverStart(run) {
+        this.logTrace(run, types_1.RunStatus.START);
+    }
+    onRetrieverEnd(run) {
+        this.logTrace(run, types_1.RunStatus.END);
+    }
+    onRetrieverError(run) {
+        this.logTrace(run, types_1.RunStatus.ERROR);
+    }
+    onAgentAction(run) {
+        this.logTrace(run, types_1.RunStatus.START);
+    }
+    onAgentEnd(run) {
+        this.logTrace(run, types_1.RunStatus.END);
+    }
+};
+exports.LangGraphTracer = LangGraphTracer;
+__decorate([
+    (0, core_decorator_1.Inject)(),
+    __metadata("design:type", Function)
+], LangGraphTracer.prototype, "tracingService", void 0);
+exports.LangGraphTracer = LangGraphTracer = __decorate([
+    (0, core_decorator_1.SingletonProto)({
+        accessLevel: tegg_types_1.AccessLevel.PUBLIC,
+    })
+], LangGraphTracer);
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/TracingService.d.ts

@@ -0,0 +1,39 @@
+import type { Logger } from '@eggjs/tegg-types';
+import type { Run } from '@langchain/core/tracers/base';
+import { RunStatus } from './types';
+/**
+ * TracingService - Shared service for common tracing operations.
+ * Used by both LangGraphTracer and ClaudeAgentTracer to avoid code duplication.
+ */
+export declare class TracingService {
+    readonly logger: Logger;
+    private backgroundTaskHelper;
+    private readonly ossClient;
+    private readonly logServiceClient;
+    /**
+     * Get the current environment (local, pre, prod, gray)
+     */
+    getEnv(): string;
+    /**
+     * Check if running in online environment (prod, pre, gray)
+     */
+    isOnlineEnv(): boolean;
+    /**
+     * Generate log info prefix for a run
+     */
+    getLogInfoPrefix(run: Run, status: RunStatus, name: string): string;
+    /**
+     * Upload content to OSS using the injected AbstractOssClient implementation.
+     * Gracefully skips if no AbstractOssClient is provided.
+     */
+    uploadToOss(key: string, fileContent: string): Promise<void>;
+    /**
+     * Sync local tracing logs to the injected AbstractLogServiceClient implementation.
+     * Silently skips if no AbstractLogServiceClient is registered.
+     */
+    syncLocalToLogService(log: string, agentName: string): Promise<void>;
+    /**
+     * Log trace run data with OSS upload for large fields
+     */
+    logTrace(run: Run, status: RunStatus, name: string, agentName: string): void;
+}