/**
 * 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;
};