import type { Thread, Message, Assistant, Command } from "@langchain/langgraph-sdk";
import { EventEmitter } from "eventemitter3";
import { ToolManager } from "./ToolManager.js";
import { CallToolResult } from "./tool/createTool.js";
import { HumanInTheLoopDecision, HumanInTheLoopState } from "./humanInTheLoop.js";
import { type ILangGraphClient } from "@langgraph-js/pure-graph/dist/types.js";
import { RevertChatToOptions } from "./time-travel/index.js";
export type RenderMessage = Message & {
    /** 对于 AIMessage 来说是节点名称，对于工具节点来说是工具名称 */
    name?: string;
    /** 工具节点的触发节点名称 */
    node_name?: string;
    /** 工具入参 ，聚合而来*/
    tool_input?: string;
    additional_kwargs?: {
        create_time: string;
        update_time: string;
        done?: boolean;
        tool_calls?: {
            function: {
                arguments: string;
            };
        }[];
    };
    usage_metadata?: {
        total_tokens: number;
        input_tokens: number;
        output_tokens: number;
    };
    tool_call_id?: string;
    sub_messages?: RenderMessage[];
    /** 耗时 */
    spend_time?: number;
    /** 渲染时的唯一 id，聚合而来*/
    unique_id?: string;
    /** 工具调用是否完成 */
    done?: boolean;
    /** 标记工具消息的原始 ai 消息 */
    source_ai_message_id?: string;
};
export type SendMessageOptions = {
    extraParams?: Record<string, any>;
    _debug?: {
        streamResponse?: any;
    };
    command?: Command;
    joinRunId?: string;
    metadata?: Record<string, any>;
};
export interface LangGraphClientConfig {
    apiUrl?: string;
    apiKey?: string;
    callerOptions?: {
        /**
         * The maximum number of concurrent calls that can be made.
         * Defaults to `Infinity`, which means no limit.
         */
        maxConcurrency?: number;
        /**
         * The maximum number of retries that can be made for a single call,
         * with an exponential backoff between each attempt. Defaults to 6.
         */
        maxRetries?: number;
        onFailedResponseHook?: any;
        /**
         * Specify a custom fetch implementation.
         *
         * By default we expect the `fetch` is available in the global scope.
         */
        fetch?: typeof fetch | ((...args: any[]) => any);
    };
    timeoutMs?: number;
    defaultHeaders?: Record<string, string | null | undefined>;
    /** 自定义客户端实现，如果不提供则使用官方 Client */
    client: ILangGraphClient<any>;
    /** 是否使用 legacy 模式，默认 false */
    legacyMode?: boolean;
}
export interface LangGraphEvents {
    /** 流开始事件 */
    start: {
        event: "start";
    };
    /** 消息部分更新事件 */
    message: {
        event: "messages/partial";
        data: Message[];
    };
    /** 值更新事件 */
    value: {
        event: "messages/partial" | "values";
        data: {
            messages?: Message[];
        };
    };
    /** 错误事件 */
    error: {
        event: "error";
        data: any;
    };
    /** Thread 创建事件 */
    thread: {
        event: "thread/create";
        data: {
            thread: Thread;
        };
    };
    /** 流完成事件 */
    done: {
        event: "done";
    };
    /** 中断事件 */
    interruptChange: {
        event: "interruptChange";
    };
}
/**
 * @zh LangGraphClient 类是与 LangGraph 后端交互的主要客户端。
 * @en The LangGraphClient class is the main client for interacting with the LangGraph backend.
 */
export declare class LangGraphClient<TStateType = unknown> extends EventEmitter<LangGraphEvents> {
    private client;
    private currentAssistant;
    private currentThread;
    tools: ToolManager;
    availableAssistants: Assistant[];
    graphState: any;
    currentRun?: {
        run_id: string;
    };
    stopController: AbortController | null;
    /** Message 处理器 */
    private messageProcessor;
    private legacyMode;
    /** 当前流式状态 */
    private _status;
    constructor(config: LangGraphClientConfig);
    /** 代理 assistants 属性到内部 client */
    get assistants(): {
        search(query?: {
            graphId?: string;
            metadata?: import("@langchain/langgraph-sdk").Metadata;
            limit?: number;
            offset?: number;
            sortBy?: import("@langgraph-js/pure-graph/dist/types.js").AssistantSortBy;
            sortOrder?: import("@langgraph-js/pure-graph/dist/types.js").SortOrder;
        }): Promise<Assistant[]>;
        getGraph(assistantId: string, options?: {
            xray?: boolean | number;
        }): Promise<import("@langchain/langgraph-sdk").AssistantGraph>;
    };
    /** 代理 threads 属性到内部 client */
    get threads(): {
        create(payload?: {
            metadata?: import("@langchain/langgraph-sdk").Metadata;
            threadId?: string;
            ifExists?: import("@langchain/langgraph-sdk").OnConflictBehavior;
            graphId?: string;
        }): Promise<Thread<TStateType, unknown>>;
        search(query?: {
            metadata?: import("@langchain/langgraph-sdk").Metadata;
            limit?: number;
            offset?: number;
            status?: import("@langchain/langgraph-sdk").ThreadStatus;
            sortBy?: import("@langgraph-js/pure-graph/dist/types.js").ThreadSortBy;
            sortOrder?: import("@langgraph-js/pure-graph/dist/types.js").SortOrder;
        }): Promise<Thread<TStateType, unknown>[]>;
        get(threadId: string): Promise<Thread<TStateType, unknown>>;
        delete(threadId: string): Promise<void>;
        updateState(threadId: string, thread: Partial<Thread<TStateType, unknown>>): Promise<Pick<import("@langchain/langgraph-sdk").Config, "configurable">>;
    };
    /** 代理 runs 属性到内部 client */
    get runs(): ILangGraphClient["runs"];
    /** 获取当前流式状态 */
    get status(): "error" | "idle" | "busy" | "interrupted";
    private listAssistants;
    /**
     * @zh 初始化 Assistant。
     * @en Initializes the Assistant.
     */
    initAssistant(agentName?: string, config?: {
        fallbackToAvailableAssistants?: boolean;
    }): Promise<Assistant | undefined>;
    /**
     * @zh 创建一个新的 Thread。
     * @en Creates a new Thread.
     */
    createThread({ threadId, graphId, metadata }?: {
        threadId?: string;
        graphId?: string;
        metadata?: Record<string, any>;
    }): Promise<Thread<TStateType, unknown>>;
    graphVisualize(): Promise<import("@langchain/langgraph-sdk").AssistantGraph>;
    /**
     * @zh 列出所有的 Thread。
     * @en Lists all Threads.
     */
    listThreads(options?: {
        ids?: string[];
        metadata?: Record<string, any>;
        status?: "idle" | "busy" | "interrupted" | "error";
        values?: any;
        limit?: number;
        offset?: number;
        sortBy?: "thread_id" | "status" | "created_at" | "updated_at";
        sortOrder?: "asc" | "desc";
        select?: Array<"thread_id" | "created_at" | "updated_at" | "metadata" | "config" | "context" | "status" | "values" | "interrupts">;
        withoutDetails?: boolean;
    }): Promise<Thread<TStateType, unknown>[]>;
    deleteThread(threadId: string): Promise<void>;
    /**
     * @zh 从历史中恢复 Thread 数据。
     * @en Resets the Thread data from history.
     */
    resetThread(agent: string, threadId: string): Promise<Thread<TStateType, unknown>>;
    resetStream(): Promise<void>;
    cloneMessage(message: Message): Message;
    /**
     * @zh 用于 UI 中的流式渲染中的消息。
     * @en Messages used for streaming rendering in the UI.
     */
    get renderMessage(): RenderMessage[];
    /**
     * @zh 获取 Token 计数器信息。
     * @en Gets the Token counter information.
     */
    get tokenCounter(): {
        total_tokens: number;
        input_tokens: number;
        output_tokens: number;
    };
    /** 前端工具人机交互时，锁住面板 */
    isFELocking(messages: RenderMessage[]): boolean | undefined;
    /**
     * @zh 取消当前的 Run。
     * @en Cancels the current Run.
     */
    cancelRun(): void;
    /**
     * @zh 回滚到指定的消息。但是不会触发数据的重新更新
     * @en Reverts to the specified message.
     */
    revertChatTo(messageId: string, options: RevertChatToOptions): Promise<{
        messages: Message[];
    }>;
    messagesMetadata: {};
    humanInTheLoop: HumanInTheLoopState | null;
    /** 此 interruptData 不包括 humanInTheLoop 的数据 */
    interruptData: any | null;
    /**
     * @zh 发送消息到 LangGraph 后端。
     * @en Sends a message to the LangGraph backend.
     */
    sendMessage(input: string | Message[], { joinRunId, extraParams, _debug, command, metadata }?: SendMessageOptions): Promise<any[]>;
    /** 当前子图位置，但是依赖 stream，不太适合稳定使用*/
    private graphPosition;
    getGraphPosition(): {
        id: string;
        name: string;
    }[];
    getGraphNodeNow(): {
        id: string;
        name: string;
    };
    /**
     * @zh 处理流式响应的单个 chunk。
     * @en Processes a single chunk from the stream response.
     * @returns 是否需要跳过后续处理 (continue)
     */
    private processStreamChunk;
    private runFETool;
    private getHumanInTheLoopData;
    private responseHumanInTheLoop;
    private callFETool;
    extraParams: Record<string, any>;
    /**
     * @zh 继续被前端工具中断的流程。
     * @en Resumes a process interrupted by a frontend tool.
     */
    resume(result: CallToolResult): Promise<any[]>;
    /**
     * @zh 标记前端工具等待已完成。
     * @en Marks the frontend tool waiting as completed.
     * @deprecated 请使用 doneHumanInTheLoopWaiting 和规范的 humanInTheLoop 协议定义状态
     */
    doneFEToolWaiting(id: string, result: CallToolResult): void;
    /** 尝试强制跳过工具调用 */
    private forceSkipToolLock?;
    /**
     * @zh 标记人机交互等待已完成。
     * @en Marks the human in the loop waiting as completed.
     */
    doneHumanInTheLoopWaiting(tool_id: string, action_request_id: string, result: HumanInTheLoopDecision): void;
    /**
     * @zh 获取当前的 Thread。
     * @en Gets the current Thread.
     */
    getCurrentThread(): Thread<TStateType, unknown> | null;
    /**
     * @zh 获取当前的 Assistant。
     * @en Gets the current Assistant.
     */
    getCurrentAssistant(): Assistant | null;
    /**
     * @zh 重置客户端状态。
     * @en Resets the client state.
     */
    reset(): Promise<void>;
}