@thinkhive/sdk 2.0.0 → 3.0.0

package/dist/instrumentation/langchain.d.ts

@@ -0,0 +1,194 @@
+/**
+ * ThinkHive SDK v3.0 - LangChain/LangGraph Instrumentation
+ *
+ * Auto-instrumentation for LangChain and LangGraph:
+ * - Chains
+ * - Agents
+ * - LangGraph workflows
+ * - Retrievers
+ * - Tool calls
+ */
+import type { ConversationMessage, SpanData } from '../core/types';
+/**
+ * LangChain callback handler for ThinkHive tracing
+ *
+ * @example
+ * ```typescript
+ * import { ChatOpenAI } from '@langchain/openai';
+ * import { ThinkHiveCallbackHandler } from '@thinkhive/sdk/instrumentation/langchain';
+ *
+ * const handler = new ThinkHiveCallbackHandler();
+ *
+ * const chat = new ChatOpenAI({
+ *   callbacks: [handler],
+ * });
+ *
+ * await chat.invoke('Hello!');
+ *
+ * // Get collected spans
+ * const spans = handler.getSpans();
+ * ```
+ */
+export declare class ThinkHiveCallbackHandler {
+    private spans;
+    private spanStack;
+    private tracer;
+    /**
+     * Called when a chain starts
+     */
+    handleChainStart(chain: {
+        name?: string;
+        id?: string[];
+    }, inputs: Record<string, unknown>): void;
+    /**
+     * Called when a chain ends
+     */
+    handleChainEnd(outputs: Record<string, unknown>): void;
+    /**
+     * Called when a chain errors
+     */
+    handleChainError(error: Error): void;
+    /**
+     * Called when an LLM starts
+     */
+    handleLLMStart(llm: {
+        name?: string;
+        id?: string[];
+    }, prompts: string[]): void;
+    /**
+     * Called when an LLM ends
+     */
+    handleLLMEnd(output: {
+        generations?: Array<Array<{
+            text?: string;
+        }>>;
+        llmOutput?: {
+            tokenUsage?: {
+                promptTokens?: number;
+                completionTokens?: number;
+            };
+        };
+    }): void;
+    /**
+     * Called when an LLM errors
+     */
+    handleLLMError(error: Error): void;
+    /**
+     * Called when a tool starts
+     */
+    handleToolStart(tool: {
+        name?: string;
+        id?: string[];
+    }, input: string): void;
+    /**
+     * Called when a tool ends
+     */
+    handleToolEnd(output: string): void;
+    /**
+     * Called when a tool errors
+     */
+    handleToolError(error: Error): void;
+    /**
+     * Called when a retriever starts
+     */
+    handleRetrieverStart(retriever: {
+        name?: string;
+        id?: string[];
+    }, query: string): void;
+    /**
+     * Called when a retriever ends
+     */
+    handleRetrieverEnd(documents: Array<{
+        pageContent?: string;
+        metadata?: Record<string, unknown>;
+    }>): void;
+    /**
+     * Called when a retriever errors
+     */
+    handleRetrieverError(error: Error): void;
+    /**
+     * Get collected spans
+     */
+    getSpans(): SpanData[];
+    /**
+     * Clear collected spans
+     */
+    clearSpans(): void;
+    /**
+     * Get spans as a tree (parent-child relationships)
+     */
+    getSpanTree(): SpanData[];
+}
+/**
+ * LangGraph node wrapper for tracing
+ *
+ * @example
+ * ```typescript
+ * import { StateGraph } from '@langchain/langgraph';
+ * import { wrapLangGraphNode } from '@thinkhive/sdk/instrumentation/langchain';
+ *
+ * const workflow = new StateGraph({ ... });
+ *
+ * workflow.addNode('agent', wrapLangGraphNode('agent', async (state) => {
+ *   // Your agent logic
+ *   return { messages: [...state.messages, response] };
+ * }));
+ * ```
+ */
+export declare function wrapLangGraphNode<TState, TResult>(nodeName: string, fn: (state: TState) => Promise<TResult>): (state: TState) => Promise<TResult>;
+/**
+ * Wrap a LangGraph workflow execution
+ *
+ * @example
+ * ```typescript
+ * import { wrapLangGraphExecution } from '@thinkhive/sdk/instrumentation/langchain';
+ *
+ * const result = await wrapLangGraphExecution(
+ *   'customer_support',
+ *   () => compiledGraph.invoke({ messages: [...] })
+ * );
+ * ```
+ */
+export declare function wrapLangGraphExecution<T>(workflowName: string, fn: () => Promise<T>, options?: {
+    input?: unknown;
+    config?: Record<string, unknown>;
+}): Promise<T>;
+/**
+ * Extract conversation messages from LangChain format
+ */
+export declare function extractMessagesFromLangChain(messages: Array<{
+    _getType?: () => string;
+    content: string;
+    additional_kwargs?: Record<string, unknown>;
+}>): ConversationMessage[];
+/**
+ * Extract spans from LangSmith run tree (if available)
+ */
+export declare function extractSpansFromRunTree(runTree: {
+    name: string;
+    run_type: string;
+    start_time?: number;
+    end_time?: number;
+    inputs?: Record<string, unknown>;
+    outputs?: Record<string, unknown>;
+    error?: string;
+    child_runs?: any[];
+}): SpanData;
+/**
+ * Create a callback handler and return it with a cleanup function
+ *
+ * @example
+ * ```typescript
+ * const { handler, getSpans, cleanup } = createThinkHiveCallback();
+ *
+ * await chain.invoke(input, { callbacks: [handler] });
+ *
+ * const spans = getSpans();
+ * cleanup();
+ * ```
+ */
+export declare function createThinkHiveCallback(): {
+    handler: ThinkHiveCallbackHandler;
+    getSpans: () => SpanData[];
+    cleanup: () => void;
+};

package/dist/instrumentation/langchain.js

@@ -0,0 +1,429 @@
+"use strict";
+/**
+ * ThinkHive SDK v3.0 - LangChain/LangGraph Instrumentation
+ *
+ * Auto-instrumentation for LangChain and LangGraph:
+ * - Chains
+ * - Agents
+ * - LangGraph workflows
+ * - Retrievers
+ * - Tool calls
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThinkHiveCallbackHandler = void 0;
+exports.wrapLangGraphNode = wrapLangGraphNode;
+exports.wrapLangGraphExecution = wrapLangGraphExecution;
+exports.extractMessagesFromLangChain = extractMessagesFromLangChain;
+exports.extractSpansFromRunTree = extractSpansFromRunTree;
+exports.createThinkHiveCallback = createThinkHiveCallback;
+const api_1 = require("@opentelemetry/api");
+const config_1 = require("../core/config");
+// ============================================================================
+// LANGCHAIN CALLBACK HANDLER
+// ============================================================================
+/**
+ * LangChain callback handler for ThinkHive tracing
+ *
+ * @example
+ * ```typescript
+ * import { ChatOpenAI } from '@langchain/openai';
+ * import { ThinkHiveCallbackHandler } from '@thinkhive/sdk/instrumentation/langchain';
+ *
+ * const handler = new ThinkHiveCallbackHandler();
+ *
+ * const chat = new ChatOpenAI({
+ *   callbacks: [handler],
+ * });
+ *
+ * await chat.invoke('Hello!');
+ *
+ * // Get collected spans
+ * const spans = handler.getSpans();
+ * ```
+ */
+class ThinkHiveCallbackHandler {
+    constructor() {
+        this.spans = [];
+        this.spanStack = [];
+        this.tracer = api_1.trace.getTracer('thinkhive', '3.0.0');
+    }
+    /**
+     * Called when a chain starts
+     */
+    handleChainStart(chain, inputs) {
+        const span = {
+            name: chain.name || 'chain',
+            type: 'chain',
+            input: inputs,
+            status: 'ok',
+        };
+        this.spanStack.push({ span, startTime: Date.now() });
+        (0, config_1.debugLog)('Chain started:', chain.name);
+    }
+    /**
+     * Called when a chain ends
+     */
+    handleChainEnd(outputs) {
+        const entry = this.spanStack.pop();
+        if (entry) {
+            entry.span.durationMs = Date.now() - entry.startTime;
+            entry.span.output = outputs;
+            this.spans.push(entry.span);
+            (0, config_1.debugLog)('Chain ended:', entry.span.name);
+        }
+    }
+    /**
+     * Called when a chain errors
+     */
+    handleChainError(error) {
+        const entry = this.spanStack.pop();
+        if (entry) {
+            entry.span.durationMs = Date.now() - entry.startTime;
+            entry.span.status = 'error';
+            entry.span.error = error.message;
+            this.spans.push(entry.span);
+            (0, config_1.debugLog)('Chain error:', entry.span.name, error.message);
+        }
+    }
+    /**
+     * Called when an LLM starts
+     */
+    handleLLMStart(llm, prompts) {
+        const span = {
+            name: llm.name || 'llm',
+            type: 'llm',
+            input: prompts,
+            status: 'ok',
+        };
+        this.spanStack.push({ span, startTime: Date.now() });
+        (0, config_1.debugLog)('LLM started:', llm.name);
+    }
+    /**
+     * Called when an LLM ends
+     */
+    handleLLMEnd(output) {
+        const entry = this.spanStack.pop();
+        if (entry) {
+            entry.span.durationMs = Date.now() - entry.startTime;
+            entry.span.output = output.generations?.[0]?.[0]?.text;
+            if (output.llmOutput?.tokenUsage) {
+                entry.span.promptTokens = output.llmOutput.tokenUsage.promptTokens;
+                entry.span.completionTokens = output.llmOutput.tokenUsage.completionTokens;
+            }
+            this.spans.push(entry.span);
+            (0, config_1.debugLog)('LLM ended:', entry.span.name);
+        }
+    }
+    /**
+     * Called when an LLM errors
+     */
+    handleLLMError(error) {
+        const entry = this.spanStack.pop();
+        if (entry) {
+            entry.span.durationMs = Date.now() - entry.startTime;
+            entry.span.status = 'error';
+            entry.span.error = error.message;
+            this.spans.push(entry.span);
+            (0, config_1.debugLog)('LLM error:', entry.span.name, error.message);
+        }
+    }
+    /**
+     * Called when a tool starts
+     */
+    handleToolStart(tool, input) {
+        let parsedInput;
+        try {
+            parsedInput = JSON.parse(input);
+        }
+        catch {
+            parsedInput = input;
+        }
+        const span = {
+            name: tool.name || 'tool',
+            type: 'tool',
+            toolName: tool.name,
+            input: parsedInput,
+            status: 'ok',
+        };
+        this.spanStack.push({ span, startTime: Date.now() });
+        (0, config_1.debugLog)('Tool started:', tool.name);
+    }
+    /**
+     * Called when a tool ends
+     */
+    handleToolEnd(output) {
+        const entry = this.spanStack.pop();
+        if (entry) {
+            entry.span.durationMs = Date.now() - entry.startTime;
+            try {
+                entry.span.output = JSON.parse(output);
+            }
+            catch {
+                entry.span.output = output;
+            }
+            this.spans.push(entry.span);
+            (0, config_1.debugLog)('Tool ended:', entry.span.name);
+        }
+    }
+    /**
+     * Called when a tool errors
+     */
+    handleToolError(error) {
+        const entry = this.spanStack.pop();
+        if (entry) {
+            entry.span.durationMs = Date.now() - entry.startTime;
+            entry.span.status = 'error';
+            entry.span.error = error.message;
+            this.spans.push(entry.span);
+            (0, config_1.debugLog)('Tool error:', entry.span.name, error.message);
+        }
+    }
+    /**
+     * Called when a retriever starts
+     */
+    handleRetrieverStart(retriever, query) {
+        const span = {
+            name: retriever.name || 'retriever',
+            type: 'retrieval',
+            query,
+            status: 'ok',
+        };
+        this.spanStack.push({ span, startTime: Date.now() });
+        (0, config_1.debugLog)('Retriever started:', retriever.name);
+    }
+    /**
+     * Called when a retriever ends
+     */
+    handleRetrieverEnd(documents) {
+        const entry = this.spanStack.pop();
+        if (entry) {
+            entry.span.durationMs = Date.now() - entry.startTime;
+            entry.span.documentCount = documents.length;
+            entry.span.sources = documents
+                .map((d) => d.metadata?.source)
+                .filter(Boolean);
+            entry.span.output = documents.map((d) => d.pageContent?.substring(0, 500));
+            this.spans.push(entry.span);
+            (0, config_1.debugLog)('Retriever ended:', entry.span.name, `${documents.length} docs`);
+        }
+    }
+    /**
+     * Called when a retriever errors
+     */
+    handleRetrieverError(error) {
+        const entry = this.spanStack.pop();
+        if (entry) {
+            entry.span.durationMs = Date.now() - entry.startTime;
+            entry.span.status = 'error';
+            entry.span.error = error.message;
+            this.spans.push(entry.span);
+            (0, config_1.debugLog)('Retriever error:', entry.span.name, error.message);
+        }
+    }
+    /**
+     * Get collected spans
+     */
+    getSpans() {
+        return [...this.spans];
+    }
+    /**
+     * Clear collected spans
+     */
+    clearSpans() {
+        this.spans = [];
+        this.spanStack = [];
+    }
+    /**
+     * Get spans as a tree (parent-child relationships)
+     */
+    getSpanTree() {
+        // Build tree from flat list based on timing
+        // This is a simplified version - real implementation would use run IDs
+        return this.spans;
+    }
+}
+exports.ThinkHiveCallbackHandler = ThinkHiveCallbackHandler;
+// ============================================================================
+// LANGGRAPH TRACING
+// ============================================================================
+/**
+ * LangGraph node wrapper for tracing
+ *
+ * @example
+ * ```typescript
+ * import { StateGraph } from '@langchain/langgraph';
+ * import { wrapLangGraphNode } from '@thinkhive/sdk/instrumentation/langchain';
+ *
+ * const workflow = new StateGraph({ ... });
+ *
+ * workflow.addNode('agent', wrapLangGraphNode('agent', async (state) => {
+ *   // Your agent logic
+ *   return { messages: [...state.messages, response] };
+ * }));
+ * ```
+ */
+function wrapLangGraphNode(nodeName, fn) {
+    const tracer = api_1.trace.getTracer('thinkhive', '3.0.0');
+    return async (state) => {
+        return tracer.startActiveSpan(`langgraph.node.${nodeName}`, {
+            attributes: {
+                'openinference.span.kind': 'CHAIN',
+                'langgraph.node_name': nodeName,
+                'langgraph.state_keys': Object.keys(state).join(','),
+            },
+        }, async (span) => {
+            const startTime = Date.now();
+            try {
+                const result = await fn(state);
+                span.setAttribute('langgraph.result_keys', Object.keys(result).join(','));
+                span.setStatus({ code: api_1.SpanStatusCode.OK });
+                return result;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                span.setStatus({ code: api_1.SpanStatusCode.ERROR, message });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.setAttribute('duration_ms', Date.now() - startTime);
+                span.end();
+            }
+        });
+    };
+}
+/**
+ * Wrap a LangGraph workflow execution
+ *
+ * @example
+ * ```typescript
+ * import { wrapLangGraphExecution } from '@thinkhive/sdk/instrumentation/langchain';
+ *
+ * const result = await wrapLangGraphExecution(
+ *   'customer_support',
+ *   () => compiledGraph.invoke({ messages: [...] })
+ * );
+ * ```
+ */
+async function wrapLangGraphExecution(workflowName, fn, options = {}) {
+    const tracer = api_1.trace.getTracer('thinkhive', '3.0.0');
+    return tracer.startActiveSpan(`langgraph.workflow.${workflowName}`, {
+        attributes: {
+            'openinference.span.kind': 'AGENT',
+            'langgraph.workflow_name': workflowName,
+            'langgraph.input': options.input
+                ? JSON.stringify(options.input).substring(0, 10000)
+                : undefined,
+        },
+    }, async (span) => {
+        const startTime = Date.now();
+        try {
+            const result = await fn();
+            span.setAttribute('langgraph.output', JSON.stringify(result).substring(0, 10000));
+            span.setStatus({ code: api_1.SpanStatusCode.OK });
+            return result;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            span.setStatus({ code: api_1.SpanStatusCode.ERROR, message });
+            span.recordException(error);
+            throw error;
+        }
+        finally {
+            span.setAttribute('duration_ms', Date.now() - startTime);
+            span.end();
+        }
+    });
+}
+// ============================================================================
+// EXTRACTION HELPERS
+// ============================================================================
+/**
+ * Extract conversation messages from LangChain format
+ */
+function extractMessagesFromLangChain(messages) {
+    return messages.map((m) => {
+        const type = m._getType?.() || 'unknown';
+        let role = 'user';
+        switch (type) {
+            case 'human':
+                role = 'user';
+                break;
+            case 'ai':
+                role = 'assistant';
+                break;
+            case 'system':
+                role = 'system';
+                break;
+            case 'tool':
+                role = 'tool';
+                break;
+        }
+        return {
+            role,
+            content: m.content,
+            metadata: m.additional_kwargs,
+        };
+    });
+}
+/**
+ * Extract spans from LangSmith run tree (if available)
+ */
+function extractSpansFromRunTree(runTree) {
+    const span = {
+        name: runTree.name,
+        type: mapRunTypeToSpanType(runTree.run_type),
+        input: runTree.inputs,
+        output: runTree.outputs,
+        durationMs: runTree.start_time && runTree.end_time
+            ? runTree.end_time - runTree.start_time
+            : undefined,
+        status: runTree.error ? 'error' : 'ok',
+        error: runTree.error,
+    };
+    if (runTree.child_runs && runTree.child_runs.length > 0) {
+        span.children = runTree.child_runs.map(extractSpansFromRunTree);
+    }
+    return span;
+}
+function mapRunTypeToSpanType(runType) {
+    switch (runType) {
+        case 'llm':
+            return 'llm';
+        case 'tool':
+            return 'tool';
+        case 'retriever':
+            return 'retrieval';
+        case 'embedding':
+            return 'embedding';
+        case 'chain':
+        case 'agent':
+        default:
+            return 'chain';
+    }
+}
+// ============================================================================
+// CONVENIENCE FUNCTIONS
+// ============================================================================
+/**
+ * Create a callback handler and return it with a cleanup function
+ *
+ * @example
+ * ```typescript
+ * const { handler, getSpans, cleanup } = createThinkHiveCallback();
+ *
+ * await chain.invoke(input, { callbacks: [handler] });
+ *
+ * const spans = getSpans();
+ * cleanup();
+ * ```
+ */
+function createThinkHiveCallback() {
+    const handler = new ThinkHiveCallbackHandler();
+    return {
+        handler,
+        getSpans: () => handler.getSpans(),
+        cleanup: () => handler.clearSpans(),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"langchain.js","sourceRoot":"","sources":["../../src/instrumentation/langchain.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ThinkHive SDK v3.0 - LangChain/LangGraph Instrumentation\n *\n * Auto-instrumentation for LangChain and LangGraph:\n * - Chains\n * - Agents\n * - LangGraph workflows\n * - Retrievers\n * - Tool calls\n */\n\nimport { trace, SpanStatusCode } from '@opentelemetry/api';\nimport { debugLog } from '../core/config';\nimport type { ConversationMessage, SpanData } from '../core/types';\n\n// ============================================================================\n// LANGCHAIN CALLBACK HANDLER\n// ============================================================================\n\n/**\n * LangChain callback handler for ThinkHive tracing\n *\n * @example\n * ```typescript\n * import { ChatOpenAI } from '@langchain/openai';\n * import { ThinkHiveCallbackHandler } from '@thinkhive/sdk/instrumentation/langchain';\n *\n * const handler = new ThinkHiveCallbackHandler();\n *\n * const chat = new ChatOpenAI({\n *   callbacks: [handler],\n * });\n *\n * await chat.invoke('Hello!');\n *\n * // Get collected spans\n * const spans = handler.getSpans();\n * ```\n */\nexport class ThinkHiveCallbackHandler {\n  private spans: SpanData[] = [];\n  private spanStack: Array<{ span: SpanData; startTime: number }> = [];\n  private tracer = trace.getTracer('thinkhive', '3.0.0');\n\n  /**\n   * Called when a chain starts\n   */\n  handleChainStart(\n    chain: { name?: string; id?: string[] },\n    inputs: Record<string, unknown>\n  ): void {\n    const span: SpanData = {\n      name: chain.name || 'chain',\n      type: 'chain',\n      input: inputs,\n      status: 'ok',\n    };\n    this.spanStack.push({ span, startTime: Date.now() });\n    debugLog('Chain started:', chain.name);\n  }\n\n  /**\n   * Called when a chain ends\n   */\n  handleChainEnd(outputs: Record<string, unknown>): void {\n    const entry = this.spanStack.pop();\n    if (entry) {\n      entry.span.durationMs = Date.now() - entry.startTime;\n      entry.span.output = outputs;\n      this.spans.push(entry.span);\n      debugLog('Chain ended:', entry.span.name);\n    }\n  }\n\n  /**\n   * Called when a chain errors\n   */\n  handleChainError(error: Error): void {\n    const entry = this.spanStack.pop();\n    if (entry) {\n      entry.span.durationMs = Date.now() - entry.startTime;\n      entry.span.status = 'error';\n      entry.span.error = error.message;\n      this.spans.push(entry.span);\n      debugLog('Chain error:', entry.span.name, error.message);\n    }\n  }\n\n  /**\n   * Called when an LLM starts\n   */\n  handleLLMStart(\n    llm: { name?: string; id?: string[] },\n    prompts: string[]\n  ): void {\n    const span: SpanData = {\n      name: llm.name || 'llm',\n      type: 'llm',\n      input: prompts,\n      status: 'ok',\n    };\n    this.spanStack.push({ span, startTime: Date.now() });\n    debugLog('LLM started:', llm.name);\n  }\n\n  /**\n   * Called when an LLM ends\n   */\n  handleLLMEnd(output: {\n    generations?: Array<Array<{ text?: string }>>;\n    llmOutput?: { tokenUsage?: { promptTokens?: number; completionTokens?: number } };\n  }): void {\n    const entry = this.spanStack.pop();\n    if (entry) {\n      entry.span.durationMs = Date.now() - entry.startTime;\n      entry.span.output = output.generations?.[0]?.[0]?.text;\n      if (output.llmOutput?.tokenUsage) {\n        entry.span.promptTokens = output.llmOutput.tokenUsage.promptTokens;\n        entry.span.completionTokens = output.llmOutput.tokenUsage.completionTokens;\n      }\n      this.spans.push(entry.span);\n      debugLog('LLM ended:', entry.span.name);\n    }\n  }\n\n  /**\n   * Called when an LLM errors\n   */\n  handleLLMError(error: Error): void {\n    const entry = this.spanStack.pop();\n    if (entry) {\n      entry.span.durationMs = Date.now() - entry.startTime;\n      entry.span.status = 'error';\n      entry.span.error = error.message;\n      this.spans.push(entry.span);\n      debugLog('LLM error:', entry.span.name, error.message);\n    }\n  }\n\n  /**\n   * Called when a tool starts\n   */\n  handleToolStart(\n    tool: { name?: string; id?: string[] },\n    input: string\n  ): void {\n    let parsedInput: unknown;\n    try {\n      parsedInput = JSON.parse(input);\n    } catch {\n      parsedInput = input;\n    }\n\n    const span: SpanData = {\n      name: tool.name || 'tool',\n      type: 'tool',\n      toolName: tool.name,\n      input: parsedInput,\n      status: 'ok',\n    };\n    this.spanStack.push({ span, startTime: Date.now() });\n    debugLog('Tool started:', tool.name);\n  }\n\n  /**\n   * Called when a tool ends\n   */\n  handleToolEnd(output: string): void {\n    const entry = this.spanStack.pop();\n    if (entry) {\n      entry.span.durationMs = Date.now() - entry.startTime;\n      try {\n        entry.span.output = JSON.parse(output);\n      } catch {\n        entry.span.output = output;\n      }\n      this.spans.push(entry.span);\n      debugLog('Tool ended:', entry.span.name);\n    }\n  }\n\n  /**\n   * Called when a tool errors\n   */\n  handleToolError(error: Error): void {\n    const entry = this.spanStack.pop();\n    if (entry) {\n      entry.span.durationMs = Date.now() - entry.startTime;\n      entry.span.status = 'error';\n      entry.span.error = error.message;\n      this.spans.push(entry.span);\n      debugLog('Tool error:', entry.span.name, error.message);\n    }\n  }\n\n  /**\n   * Called when a retriever starts\n   */\n  handleRetrieverStart(\n    retriever: { name?: string; id?: string[] },\n    query: string\n  ): void {\n    const span: SpanData = {\n      name: retriever.name || 'retriever',\n      type: 'retrieval',\n      query,\n      status: 'ok',\n    };\n    this.spanStack.push({ span, startTime: Date.now() });\n    debugLog('Retriever started:', retriever.name);\n  }\n\n  /**\n   * Called when a retriever ends\n   */\n  handleRetrieverEnd(\n    documents: Array<{ pageContent?: string; metadata?: Record<string, unknown> }>\n  ): void {\n    const entry = this.spanStack.pop();\n    if (entry) {\n      entry.span.durationMs = Date.now() - entry.startTime;\n      entry.span.documentCount = documents.length;\n      entry.span.sources = documents\n        .map((d) => d.metadata?.source as string)\n        .filter(Boolean);\n      entry.span.output = documents.map((d) => d.pageContent?.substring(0, 500));\n      this.spans.push(entry.span);\n      debugLog('Retriever ended:', entry.span.name, `${documents.length} docs`);\n    }\n  }\n\n  /**\n   * Called when a retriever errors\n   */\n  handleRetrieverError(error: Error): void {\n    const entry = this.spanStack.pop();\n    if (entry) {\n      entry.span.durationMs = Date.now() - entry.startTime;\n      entry.span.status = 'error';\n      entry.span.error = error.message;\n      this.spans.push(entry.span);\n      debugLog('Retriever error:', entry.span.name, error.message);\n    }\n  }\n\n  /**\n   * Get collected spans\n   */\n  getSpans(): SpanData[] {\n    return [...this.spans];\n  }\n\n  /**\n   * Clear collected spans\n   */\n  clearSpans(): void {\n    this.spans = [];\n    this.spanStack = [];\n  }\n\n  /**\n   * Get spans as a tree (parent-child relationships)\n   */\n  getSpanTree(): SpanData[] {\n    // Build tree from flat list based on timing\n    // This is a simplified version - real implementation would use run IDs\n    return this.spans;\n  }\n}\n\n// ============================================================================\n// LANGGRAPH TRACING\n// ============================================================================\n\n/**\n * LangGraph node wrapper for tracing\n *\n * @example\n * ```typescript\n * import { StateGraph } from '@langchain/langgraph';\n * import { wrapLangGraphNode } from '@thinkhive/sdk/instrumentation/langchain';\n *\n * const workflow = new StateGraph({ ... });\n *\n * workflow.addNode('agent', wrapLangGraphNode('agent', async (state) => {\n *   // Your agent logic\n *   return { messages: [...state.messages, response] };\n * }));\n * ```\n */\nexport function wrapLangGraphNode<TState, TResult>(\n  nodeName: string,\n  fn: (state: TState) => Promise<TResult>\n): (state: TState) => Promise<TResult> {\n  const tracer = trace.getTracer('thinkhive', '3.0.0');\n\n  return async (state: TState): Promise<TResult> => {\n    return tracer.startActiveSpan(\n      `langgraph.node.${nodeName}`,\n      {\n        attributes: {\n          'openinference.span.kind': 'CHAIN',\n          'langgraph.node_name': nodeName,\n          'langgraph.state_keys': Object.keys(state as object).join(','),\n        },\n      },\n      async (span) => {\n        const startTime = Date.now();\n        try {\n          const result = await fn(state);\n          span.setAttribute(\n            'langgraph.result_keys',\n            Object.keys(result as object).join(',')\n          );\n          span.setStatus({ code: SpanStatusCode.OK });\n          return result;\n        } catch (error: unknown) {\n          const message = error instanceof Error ? error.message : String(error);\n          span.setStatus({ code: SpanStatusCode.ERROR, message });\n          span.recordException(error as Error);\n          throw error;\n        } finally {\n          span.setAttribute('duration_ms', Date.now() - startTime);\n          span.end();\n        }\n      }\n    );\n  };\n}\n\n/**\n * Wrap a LangGraph workflow execution\n *\n * @example\n * ```typescript\n * import { wrapLangGraphExecution } from '@thinkhive/sdk/instrumentation/langchain';\n *\n * const result = await wrapLangGraphExecution(\n *   'customer_support',\n *   () => compiledGraph.invoke({ messages: [...] })\n * );\n * ```\n */\nexport async function wrapLangGraphExecution<T>(\n  workflowName: string,\n  fn: () => Promise<T>,\n  options: {\n    input?: unknown;\n    config?: Record<string, unknown>;\n  } = {}\n): Promise<T> {\n  const tracer = trace.getTracer('thinkhive', '3.0.0');\n\n  return tracer.startActiveSpan(\n    `langgraph.workflow.${workflowName}`,\n    {\n      attributes: {\n        'openinference.span.kind': 'AGENT',\n        'langgraph.workflow_name': workflowName,\n        'langgraph.input': options.input\n          ? JSON.stringify(options.input).substring(0, 10000)\n          : undefined,\n      },\n    },\n    async (span) => {\n      const startTime = Date.now();\n      try {\n        const result = await fn();\n        span.setAttribute(\n          'langgraph.output',\n          JSON.stringify(result).substring(0, 10000)\n        );\n        span.setStatus({ code: SpanStatusCode.OK });\n        return result;\n      } catch (error: unknown) {\n        const message = error instanceof Error ? error.message : String(error);\n        span.setStatus({ code: SpanStatusCode.ERROR, message });\n        span.recordException(error as Error);\n        throw error;\n      } finally {\n        span.setAttribute('duration_ms', Date.now() - startTime);\n        span.end();\n      }\n    }\n  );\n}\n\n// ============================================================================\n// EXTRACTION HELPERS\n// ============================================================================\n\n/**\n * Extract conversation messages from LangChain format\n */\nexport function extractMessagesFromLangChain(\n  messages: Array<{\n    _getType?: () => string;\n    content: string;\n    additional_kwargs?: Record<string, unknown>;\n  }>\n): ConversationMessage[] {\n  return messages.map((m) => {\n    const type = m._getType?.() || 'unknown';\n    let role: ConversationMessage['role'] = 'user';\n\n    switch (type) {\n      case 'human':\n        role = 'user';\n        break;\n      case 'ai':\n        role = 'assistant';\n        break;\n      case 'system':\n        role = 'system';\n        break;\n      case 'tool':\n        role = 'tool';\n        break;\n    }\n\n    return {\n      role,\n      content: m.content,\n      metadata: m.additional_kwargs,\n    };\n  });\n}\n\n/**\n * Extract spans from LangSmith run tree (if available)\n */\nexport function extractSpansFromRunTree(\n  runTree: {\n    name: string;\n    run_type: string;\n    start_time?: number;\n    end_time?: number;\n    inputs?: Record<string, unknown>;\n    outputs?: Record<string, unknown>;\n    error?: string;\n    child_runs?: any[];\n  }\n): SpanData {\n  const span: SpanData = {\n    name: runTree.name,\n    type: mapRunTypeToSpanType(runTree.run_type),\n    input: runTree.inputs,\n    output: runTree.outputs,\n    durationMs:\n      runTree.start_time && runTree.end_time\n        ? runTree.end_time - runTree.start_time\n        : undefined,\n    status: runTree.error ? 'error' : 'ok',\n    error: runTree.error,\n  };\n\n  if (runTree.child_runs && runTree.child_runs.length > 0) {\n    span.children = runTree.child_runs.map(extractSpansFromRunTree);\n  }\n\n  return span;\n}\n\nfunction mapRunTypeToSpanType(runType: string): SpanData['type'] {\n  switch (runType) {\n    case 'llm':\n      return 'llm';\n    case 'tool':\n      return 'tool';\n    case 'retriever':\n      return 'retrieval';\n    case 'embedding':\n      return 'embedding';\n    case 'chain':\n    case 'agent':\n    default:\n      return 'chain';\n  }\n}\n\n// ============================================================================\n// CONVENIENCE FUNCTIONS\n// ============================================================================\n\n/**\n * Create a callback handler and return it with a cleanup function\n *\n * @example\n * ```typescript\n * const { handler, getSpans, cleanup } = createThinkHiveCallback();\n *\n * await chain.invoke(input, { callbacks: [handler] });\n *\n * const spans = getSpans();\n * cleanup();\n * ```\n */\nexport function createThinkHiveCallback(): {\n  handler: ThinkHiveCallbackHandler;\n  getSpans: () => SpanData[];\n  cleanup: () => void;\n} {\n  const handler = new ThinkHiveCallbackHandler();\n\n  return {\n    handler,\n    getSpans: () => handler.getSpans(),\n    cleanup: () => handler.clearSpans(),\n  };\n}\n"]}