@gt-fe/eap-runtime 0.0.8

package/dist/graph/hitl/hitl-handler.js

@@ -0,0 +1,480 @@
+/**
+ * HITL (Human-In-The-Loop) Handler
+ *
+ * 实现人工介入的中断、恢复、超时逻辑。
+ * 当 Graph 到达 HITL 节点时暂停执行，等待人工确认后继续。
+ *
+ * 超时不得在 setTimeout 回调里 throw（会变成未捕获异常）；
+ * 由 AgentRuntime 监听器关 Task / Span。deadline 写入 Checkpoint，冷恢复可校验。
+ *
+ * @see design.md §1.6 hitl.waiting / hitl.resumed 事件
+ * @see tasks.md Task 14
+ */
+// ─────────────────────────────────────────────
+// Types
+// ─────────────────────────────────────────────
+/** HITL 默认等待时长（毫秒）= 300 秒。SSE `hitl.waited.timeout` 对外用秒。 */
+export const DEFAULT_HITL_TIMEOUT_MS = 300_000;
+/** HITL 超时错误（保留类型；timer 不再 throw，resume 逾期改走 AppError） */
+export class HitlTimeoutError extends Error {
+    taskId;
+    timeoutMs;
+    constructor(taskId, timeoutMs) {
+        super(`HITL timeout: task ${taskId} exceeded ${timeoutMs}ms wait`);
+        this.taskId = taskId;
+        this.timeoutMs = timeoutMs;
+        this.name = 'HitlTimeoutError';
+    }
+}
+/** Checkpoint 已标记超时，禁止再 resume */
+export class HitlAlreadyTimedOutError extends Error {
+    taskId;
+    constructor(taskId) {
+        super(`HITL already timed out: task ${taskId}`);
+        this.taskId = taskId;
+        this.name = 'HitlAlreadyTimedOutError';
+    }
+}
+/** 内存与 Checkpoint 都没有等待态（已被 resume/timeout 抢走） */
+export class HitlNotWaitingError extends Error {
+    taskId;
+    constructor(taskId) {
+        super(`No HITL waiting state for task: ${taskId}`);
+        this.taskId = taskId;
+        this.name = 'HitlNotWaitingError';
+    }
+}
+export function isHitlDecision(choice) {
+    return choice === 'confirm' || choice === 'reject';
+}
+/** 最后一条 assistant 仍有未配对的 toolCalls（HITL 暂停后尚未 result/error） */
+export function lastAssistantHasUnansweredToolCalls(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (!msg || msg.role !== 'assistant')
+            continue;
+        const toolCalls = msg.toolCalls;
+        if (!Array.isArray(toolCalls) || toolCalls.length === 0)
+            return false;
+        const pending = new Set(toolCalls.map((tc) => tc.id).filter((id) => Boolean(id)));
+        for (let j = i + 1; j < messages.length; j++) {
+            const later = messages[j];
+            if (later?.role === 'tool' && later.toolCallId) {
+                pending.delete(later.toolCallId);
+            }
+        }
+        return pending.size > 0;
+    }
+    return false;
+}
+/**
+ * HITL 已中断、等待外部 resume（非阻塞）
+ *
+ * Tool 确认节点 interrupt 后抛出本错误，由 invoke/stream 捕获并返回 waiting_hitl，
+ * 客户端再通过 POST .../hitl 或 streamResumeHitl 继续。
+ */
+export class HitlPausedError extends Error {
+    taskId;
+    threadId;
+    question;
+    options;
+    toolCallId;
+    toolName;
+    timeoutMs;
+    toolSpanId;
+    skillSpanId;
+    constructor(taskId, threadId, question, options, toolCallId, toolName, timeoutMs = DEFAULT_HITL_TIMEOUT_MS) {
+        super(`HITL paused: task ${taskId} waiting for confirmation`);
+        this.taskId = taskId;
+        this.threadId = threadId;
+        this.question = question;
+        this.options = options;
+        this.toolCallId = toolCallId;
+        this.toolName = toolName;
+        this.timeoutMs = timeoutMs;
+        this.name = 'HitlPausedError';
+    }
+}
+/**
+ * 向上解包 HitlPausedError（LangGraph / Promise 可能挂在 `.cause`）
+ */
+export function unwrapHitlPaused(error) {
+    let current = error;
+    const seen = new Set();
+    while (current && typeof current === 'object' && !seen.has(current)) {
+        seen.add(current);
+        if (current instanceof HitlPausedError)
+            return current;
+        current = current.cause;
+    }
+    return null;
+}
+/** Checkpoint state 中持久化的 HITL 等待元数据（进程重启 / 无内存 Map 时冷恢复） */
+export const HITL_WAITING_STATE_KEY = '__hitlWaiting';
+export function toHitlTimeoutMs(timeoutMs) {
+    if (typeof timeoutMs !== 'number' || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        return DEFAULT_HITL_TIMEOUT_MS;
+    }
+    return timeoutMs;
+}
+/** SSE `hitl.waited.data.timeout`：秒 */
+export function toHitlTimeoutSeconds(timeoutMs) {
+    return Math.max(1, Math.round(toHitlTimeoutMs(timeoutMs) / 1000));
+}
+export function isHitlDeadlinePassed(persisted, now = Date.now()) {
+    if (!persisted?.deadlineAt)
+        return false;
+    const t = Date.parse(persisted.deadlineAt);
+    return Number.isFinite(t) && now >= t;
+}
+export function readPersistedHitlWaiting(state) {
+    if (!state || typeof state !== 'object')
+        return undefined;
+    const raw = state[HITL_WAITING_STATE_KEY];
+    if (!raw || typeof raw !== 'object')
+        return undefined;
+    return raw;
+}
+/** 门面 stream / HTTP StreamOrchestrator / streamResumeHitl 共用 */
+export function buildHitlWaitedPayload(paused) {
+    return {
+        question: paused.question,
+        options: paused.options,
+        threadId: paused.threadId,
+        timeout: toHitlTimeoutSeconds(paused.timeoutMs),
+        ...(paused.toolCallId ? { toolCallId: paused.toolCallId } : {}),
+        ...(paused.toolName ? { toolName: paused.toolName } : {}),
+    };
+}
+/**
+ * 确保 HITL checkpoint 持久化运行期上下文字段（loadedTools 等）
+ */
+function prepareHitlCheckpointState(state) {
+    const raw = state;
+    return {
+        ...state,
+        userId: state.userId ?? raw.userId ?? '',
+        loadedTools: state.loadedTools ?? raw.loadedTools,
+        forceToolServer: state.forceToolServer ?? raw.forceToolServer,
+        executionContext: state.executionContext ?? raw.executionContext,
+        agentCode: state.agentCode ?? raw.agentCode ?? state.agentId ?? raw.agentId,
+        correlationId: state.correlationId ?? raw.correlationId,
+        delegationToken: state.delegationToken ?? raw.delegationToken,
+        skillSpanId: state.skillSpanId ?? raw.skillSpanId,
+        traceId: state.traceId ?? (typeof raw.traceId === 'string' ? raw.traceId : undefined),
+    };
+}
+function toTimeoutEvent(waiting) {
+    const timeoutMs = toHitlTimeoutMs(waiting.config.timeout);
+    const behavior = waiting.config.timeoutBehavior ?? 'error';
+    return {
+        taskId: waiting.taskId,
+        threadId: waiting.threadId,
+        behavior,
+        timeoutMs,
+        question: waiting.config.question,
+        options: waiting.config.options,
+        defaultChoice: waiting.config.defaultOption ?? waiting.config.options[0] ?? 'confirm',
+        toolCallId: waiting.toolCallId,
+        toolName: waiting.toolName,
+        toolSpanId: waiting.toolSpanId,
+        skillSpanId: waiting.skillSpanId,
+    };
+}
+function waitingFromPersisted(persisted, taskId) {
+    return {
+        taskId,
+        threadId: persisted.threadId,
+        config: persisted.config,
+        timer: null,
+        interruptedAt: persisted.interruptedAt,
+        deadlineAt: persisted.deadlineAt,
+        toolCallId: persisted.toolCallId,
+        toolName: persisted.toolName,
+        toolSpanId: persisted.toolSpanId,
+        skillSpanId: persisted.skillSpanId,
+    };
+}
+// ─────────────────────────────────────────────
+// HitlHandler
+// ─────────────────────────────────────────────
+/**
+ * HitlHandler — 管理 HITL 中断/恢复/超时
+ *
+ * 职责：
+ * - interrupt: 保存 checkpoint + 发射 hitl.waiting + 启动超时计时
+ * - resume: 加载 checkpoint + 注入用户选择 + 发射 hitl.resumed
+ * - handleTimeout: 不 throw；回调 listener（error/cancel 收口，auto-confirm 续跑）
+ */
+export class HitlHandler {
+    checkpointSaver;
+    sseEmitter;
+    /** taskId → waiting state */
+    waitingTasks = new Map();
+    /** resume 后暂存的用户选择（供 ToolConfirmationInterceptor 轮询读取） */
+    resolvedChoices = new Map();
+    timeoutListener;
+    /** 同一 taskId 上串行化 resume 与 timeout，避免双边占用 */
+    taskLocks = new Map();
+    constructor(checkpointSaver, sseEmitter, timeoutListener) {
+        this.checkpointSaver = checkpointSaver;
+        this.sseEmitter = sseEmitter;
+        this.timeoutListener = timeoutListener;
+    }
+    setTimeoutListener(listener) {
+        this.timeoutListener = listener;
+    }
+    /**
+     * 中断 Graph 执行，等待人工确认
+     *
+     * 写入 `__hitlWaiting`（含 deadlineAt）到同一 thread 的 Checkpoint。
+     * 不保留 LangGraph `engineSnapshot`：子图与父图共用 session thread，
+     * resume 时用 GraphState 从父图入口重入（skillSpanId / hitlChoice 防重复 span）。
+     */
+    async interrupt(taskId, threadId, state, config, extras = {}) {
+        const now = new Date().toISOString();
+        const timeoutMs = toHitlTimeoutMs(config.timeout);
+        const deadlineAt = new Date(Date.now() + timeoutMs).toISOString();
+        const skillSpanId = extras.skillSpanId ??
+            (typeof state.skillSpanId === 'string' ? state.skillSpanId : undefined);
+        const persisted = {
+            taskId,
+            threadId,
+            config: { ...config, timeout: timeoutMs },
+            interruptedAt: now,
+            deadlineAt,
+            toolCallId: extras.toolCallId,
+            toolName: extras.toolName,
+            toolSpanId: extras.toolSpanId,
+            skillSpanId,
+        };
+        const existing = await this.checkpointSaver.load(threadId);
+        const persistedState = {
+            ...(existing?.state ?? {}),
+            ...prepareHitlCheckpointState(state),
+            [HITL_WAITING_STATE_KEY]: persisted,
+        };
+        const checkpointData = {
+            checkpointId: existing?.checkpointId ?? `hitl-${taskId}-${Date.now()}`,
+            threadId,
+            currentNodeId: existing?.currentNodeId ?? '__hitl_waiting__',
+            historyPath: existing?.historyPath ?? [],
+            state: persistedState,
+            createdBy: existing?.createdBy ?? 'system',
+            createdAt: existing?.createdAt ?? now,
+            updatedBy: 'system',
+            updatedAt: now,
+            isDeleted: false,
+        };
+        await this.checkpointSaver.save(threadId, checkpointData);
+        const event = {
+            type: 'hitl.waiting',
+            data: {
+                question: config.question,
+                options: config.options,
+                timeout: toHitlTimeoutSeconds(timeoutMs),
+            },
+            correlationId: threadId,
+            taskId,
+            timestamp: now,
+        };
+        this.sseEmitter.emit(event);
+        const previous = this.waitingTasks.get(taskId);
+        if (previous?.timer) {
+            clearTimeout(previous.timer);
+        }
+        const timer = setTimeout(() => {
+            void this.handleTimeoutAsync(taskId).catch(() => undefined);
+        }, timeoutMs);
+        if (typeof timer.unref === 'function') {
+            timer.unref();
+        }
+        this.waitingTasks.set(taskId, {
+            taskId,
+            threadId,
+            config: persisted.config,
+            timer,
+            interruptedAt: now,
+            deadlineAt,
+            toolCallId: extras.toolCallId,
+            toolName: extras.toolName,
+            toolSpanId: extras.toolSpanId,
+            skillSpanId,
+        });
+    }
+    /**
+     * 用户响应后恢复执行
+     *
+     * 优先用进程内 waitingTasks；若进程重启丢失，可用 threadId 从 Checkpoint 冷恢复
+     *（interrupt 时已写入 `__hitlWaiting`）。
+     *
+     * @returns 注入用户选择后的 GraphState
+     */
+    async resume(taskId, choice, userId, threadIdHint) {
+        return this.withTaskLock(taskId, async () => {
+            let waiting = this.waitingTasks.get(taskId);
+            const threadId = waiting?.threadId ?? threadIdHint;
+            if (!threadId) {
+                throw new HitlNotWaitingError(taskId);
+            }
+            const checkpoint = await this.checkpointSaver.load(threadId);
+            if (!checkpoint) {
+                throw new Error(`Checkpoint not found for thread: ${threadId}`);
+            }
+            const persisted = readPersistedHitlWaiting(checkpoint.state);
+            if (persisted?.timedOut) {
+                this.clearWaiting(taskId);
+                throw new HitlAlreadyTimedOutError(taskId);
+            }
+            if (!waiting && !persisted) {
+                throw new HitlNotWaitingError(taskId);
+            }
+            if (!waiting && persisted) {
+                waiting = waitingFromPersisted(persisted, taskId);
+            }
+            if (!waiting) {
+                throw new HitlNotWaitingError(taskId);
+            }
+            this.clearWaiting(taskId);
+            this.resolvedChoices.set(taskId, choice);
+            const baseState = prepareHitlCheckpointState(checkpoint.state);
+            const cleaned = { ...baseState };
+            delete cleaned[HITL_WAITING_STATE_KEY];
+            const resumedState = {
+                ...cleaned,
+                hitlChoice: choice,
+                hitlRespondedBy: userId,
+            };
+            const now = new Date().toISOString();
+            await this.checkpointSaver.save(waiting.threadId, {
+                ...checkpoint,
+                engineSnapshot: undefined,
+                state: resumedState,
+                updatedBy: userId,
+                updatedAt: now,
+            });
+            const event = {
+                type: 'hitl.resumed',
+                data: { choice, userId },
+                correlationId: waiting.threadId,
+                taskId,
+                timestamp: now,
+            };
+            this.sseEmitter.emit(event);
+            return resumedState;
+        });
+    }
+    /**
+     * 超时处理入口（同步包装）。timer 回调不得 throw。
+     */
+    handleTimeout(taskId) {
+        void this.handleTimeoutAsync(taskId);
+    }
+    async handleTimeoutAsync(taskId) {
+        let event;
+        try {
+            event = await this.withTaskLock(taskId, async () => {
+                const waiting = this.waitingTasks.get(taskId);
+                if (!waiting)
+                    return undefined;
+                const checkpoint = await this.checkpointSaver.load(waiting.threadId);
+                const persisted = readPersistedHitlWaiting(checkpoint?.state);
+                if (!persisted || persisted.timedOut) {
+                    this.clearWaiting(taskId);
+                    return undefined;
+                }
+                const timeoutEvent = toTimeoutEvent({
+                    ...waiting,
+                    toolCallId: waiting.toolCallId ?? persisted.toolCallId,
+                    toolName: waiting.toolName ?? persisted.toolName,
+                    toolSpanId: waiting.toolSpanId ?? persisted.toolSpanId,
+                    skillSpanId: waiting.skillSpanId ?? persisted.skillSpanId,
+                });
+                this.clearWaiting(taskId);
+                if (timeoutEvent.behavior !== 'auto-confirm' && checkpoint) {
+                    const marked = {
+                        ...checkpoint.state,
+                        [HITL_WAITING_STATE_KEY]: {
+                            ...persisted,
+                            timedOut: true,
+                            timeoutBehavior: timeoutEvent.behavior,
+                        },
+                    };
+                    await this.checkpointSaver.save(waiting.threadId, {
+                        ...checkpoint,
+                        engineSnapshot: undefined,
+                        state: marked,
+                        updatedAt: new Date().toISOString(),
+                    });
+                }
+                return timeoutEvent;
+            });
+        }
+        catch {
+            return;
+        }
+        if (!event)
+            return;
+        if (this.timeoutListener) {
+            try {
+                await this.timeoutListener(event);
+            }
+            catch {
+                // listener 错误不得冒泡到 timer
+            }
+            return;
+        }
+        if (event.behavior === 'auto-confirm') {
+            try {
+                await this.resume(taskId, event.defaultChoice ?? 'confirm', '__system_timeout__', event.threadId);
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    clearWaiting(taskId) {
+        const waiting = this.waitingTasks.get(taskId);
+        if (waiting?.timer) {
+            clearTimeout(waiting.timer);
+        }
+        this.waitingTasks.delete(taskId);
+    }
+    async withTaskLock(taskId, fn) {
+        const prev = this.taskLocks.get(taskId) ?? Promise.resolve();
+        let release;
+        const held = new Promise((resolve) => {
+            release = resolve;
+        });
+        const next = prev.then(() => held);
+        this.taskLocks.set(taskId, next);
+        await prev;
+        try {
+            return await fn();
+        }
+        finally {
+            release();
+            if (this.taskLocks.get(taskId) === next) {
+                this.taskLocks.delete(taskId);
+            }
+        }
+    }
+    /** 查询某 task 是否在等待 HITL */
+    isWaiting(taskId) {
+        return this.waitingTasks.has(taskId);
+    }
+    /** 获取等待状态（测试/调试用） */
+    getWaitingState(taskId) {
+        return this.waitingTasks.get(taskId);
+    }
+    /**
+     * 取出并清除 resume 写入的用户选择（确认拦截器轮询用）
+     */
+    consumeResolvedChoice(taskId) {
+        const choice = this.resolvedChoices.get(taskId);
+        if (choice !== undefined) {
+            this.resolvedChoices.delete(taskId);
+        }
+        return choice;
+    }
+}

package/dist/graph/hitl/index.d.ts

@@ -0,0 +1 @@
+export * from './hitl-handler.js';

package/dist/graph/hitl/index.js

@@ -0,0 +1 @@
+export * from './hitl-handler.js';

package/dist/graph/index.d.ts

@@ -0,0 +1,7 @@
+export * from './contracts/index.js';
+export * from './adapters/index.js';
+export * from './nodes/index.js';
+export * from './retry/index.js';
+export * from './hitl/index.js';
+export { ConditionEvaluator, type ConditionEvaluatorFn } from './condition-evaluator.js';
+export { SkillAuditRecorder, SkillInvocationContext, InMemorySkillAuditStore, type SkillInvocationRecord, type ISkillAuditStore, } from './skill-audit-recorder.js';

package/dist/graph/index.js

@@ -0,0 +1,7 @@
+export * from './contracts/index.js';
+export * from './adapters/index.js';
+export * from './nodes/index.js';
+export * from './retry/index.js';
+export * from './hitl/index.js';
+export { ConditionEvaluator } from './condition-evaluator.js';
+export { SkillAuditRecorder, SkillInvocationContext, InMemorySkillAuditStore, } from './skill-audit-recorder.js';

package/dist/graph/nodes/index.d.ts

@@ -0,0 +1,2 @@
+export { LLMNode, type LLMNodeConfig, type LLMResponse, type LLMNodeToolCall, type LLMChunk, type ILLMProvider, type LLMToolDefinition, } from './llm-node.js';
+export { ToolNode, type ToolNodeProgress } from './tool-node.js';

package/dist/graph/nodes/index.js

@@ -0,0 +1,2 @@
+export { LLMNode, } from './llm-node.js';
+export { ToolNode } from './tool-node.js';

package/dist/graph/nodes/llm-node.d.ts

@@ -0,0 +1,182 @@
+/**
+ * LLM Node — LLM 执行节点
+ *
+ * 代表 Graph 中的 LLM 推理节点，支持：
+ * - 流式输出（逐 token 推送）
+ * - Token 计数（inputTokens/outputTokens）
+ * - 重试 + 指数退避（默认 3 次）
+ *
+ * @see design.md §1.2 LLM 节点执行流程
+ * @see requirements.md Requirement 1 AC6, Requirement 9
+ */
+import type { NodeRetryConfig, GraphMessage } from '../contracts/executable-graph.js';
+/**
+ * LLMNodeConfig — LLM 节点配置
+ */
+/**
+ * LLMToolDefinition — 传给 LLM 的 Tool 定义（OpenAI function-calling 格式）
+ */
+export interface LLMToolDefinition {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+    };
+}
+export interface LLMNodeConfig {
+    /** 模型名称（如 gpt-4o, claude-3-sonnet） */
+    model: string;
+    /** 系统提示词 */
+    systemPrompt?: string;
+    /** 温度参数 (0-2) */
+    temperature?: number;
+    /** 最大输出 Token 数 */
+    maxTokens?: number;
+    /** 重试配置（默认 3 次 + 指数退避） */
+    retry?: NodeRetryConfig;
+    /** 可用 Tool 定义列表（function-calling） */
+    tools?: LLMToolDefinition[];
+    /** 强制 LLM 调用指定 Tool（auto=默认, none=禁用, required=强制） */
+    toolChoice?: 'auto' | 'none' | 'required' | {
+        type: 'function';
+        function: {
+            name: string;
+        };
+    };
+}
+/**
+ * LLMResponse — LLM 完整响应
+ */
+export interface LLMResponse {
+    /** 生成的文本内容 */
+    content: string;
+    /** Tool 调用列表（function-calling） */
+    toolCalls?: LLMNodeToolCall[];
+    /** thinking 模式 reasoning（需多轮回传） */
+    reasoningContent?: string;
+    /** 输入 Token 数 */
+    inputTokens: number;
+    /** 输出 Token 数 */
+    outputTokens: number;
+    /** 实际使用的模型标识 */
+    model: string;
+}
+/**
+ * LLMNodeToolCall — LLM 节点中返回的 Tool 调用（扁平格式）
+ *
+ * 与 tool-orchestrator 中的 LLMToolCall (OpenAI 格式) 互补，
+ * 此类型用于 LLMNode 内部状态流转。
+ */
+export interface LLMNodeToolCall {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+}
+/**
+ * LLMChunk — 流式输出的单个 chunk
+ */
+export interface LLMChunk {
+    /** chunk 文本内容 */
+    content: string;
+    /** 是否为最后一个 chunk */
+    isEnd: boolean;
+    /** 最终 chunk 携带的输入 Token 数 */
+    inputTokens?: number;
+    /** 最终 chunk 携带的输出 Token 数 */
+    outputTokens?: number;
+    /** 流式 tool_calls 增量（最终 chunk 携带） */
+    toolCalls?: LLMNodeToolCall[];
+    /** thinking 增量；最终聚合后写入 assistant 消息 */
+    reasoningContent?: string;
+}
+/**
+ * ILLMProvider — LLM 调用提供者接口
+ *
+ * 抽象 LLM 调用层，使 LLMNode 不依赖具体 LLM SDK。
+ */
+export interface ILLMProvider {
+    /** 同步调用 LLM，返回完整响应 */
+    invoke(messages: GraphMessage[], config: LLMNodeConfig): Promise<LLMResponse>;
+    /** 流式调用 LLM，逐 chunk 返回 */
+    stream(messages: GraphMessage[], config: LLMNodeConfig): AsyncIterableIterator<LLMChunk>;
+}
+/**
+ * LangGraphState — LangGraph 内部状态（与 adapter 对齐）
+ */
+type LangGraphState = Record<string, unknown>;
+/**
+ * LLMNode — LLM 执行节点
+ *
+ * 在 StateGraph 中作为 node function 注册，负责：
+ * 1. 从 state 中提取 messages
+ * 2. 调用 ILLMProvider 执行推理（支持 invoke / stream 模式）
+ * 3. 统计 Token 消耗
+ * 4. 失败时按 NodeRetryConfig 重试
+ * 5. 将 LLM 响应追加到 state.messages 并返回
+ */
+export declare class LLMNode {
+    private readonly config;
+    private readonly provider;
+    private readonly retryConfig;
+    private readonly nodeId;
+    private readonly streaming;
+    private readonly onChunk?;
+    /**
+     * @param nodeId - 节点唯一标识
+     * @param config - LLM 节点配置
+     * @param provider - LLM 调用提供者
+     * @param streaming - 是否启用流式输出（默认 false）
+     * @param onChunk - 流式模式下每个文本片段回调（用于 SSE response.chunk）
+     */
+    constructor(nodeId: string, config: LLMNodeConfig, provider: ILLMProvider, streaming?: boolean, onChunk?: (chunk: string) => void);
+    /**
+     * execute — StateGraph 节点函数
+     *
+     * 从 state 提取 messages → 调用 LLM → 处理重试 → 返回更新后的 state
+     */
+    execute(state: LangGraphState): Promise<LangGraphState>;
+    /**
+     * 获取节点 ID
+     */
+    getNodeId(): string;
+    /**
+     * 获取节点配置
+     */
+    getConfig(): LLMNodeConfig;
+    /**
+     * 从 state 中提取 messages 并转换为 GraphMessage[]
+     */
+    private extractMessages;
+    /**
+     * 在 messages 前追加 system prompt（兑底注入）
+     *
+     * 设计说明：
+     * - 当 config.systemPrompt 已设置时，HttpLLMProvider.buildRequestBody 已基于
+     *   config.systemPrompt 注入过 system message，此处**不再重复添加**，避免 messages
+     *   里出现两条相同的 system。
+     * - 仅当 config.systemPrompt 未设置、且 messages 首条不是 system 时，才兑底加一条
+     *   空 system 占位（某些上游调用可能不通过 HttpLLMProvider，保留此兑底安全）。
+     */
+    private prependSystemPrompt;
+    /**
+     * 带重试逻辑的 LLM 调用
+     *
+     * 根据 streaming 配置选择 invoke 或 stream 模式。
+     * 失败时按 backoff 策略重试，最多重试 maxRetries 次。
+     */
+    private invokeWithRetry;
+    /**
+     * 流式调用 LLM 并聚合为完整 LLMResponse
+     */
+    private invokeStreaming;
+    /**
+     * 计算退避延迟（支持 exponential / linear / fixed）
+     */
+    private calculateBackoffDelay;
+    /**
+     * 延迟等待
+     */
+    private sleep;
+}
+export {};