@gt-fe/eap-runtime 0.0.8

package/dist/graph/nodes/tool-node.js

@@ -0,0 +1,324 @@
+/**
+ * ToolNode — Tool 执行节点
+ *
+ * 在 StateGraph 中作为 node function 注册，负责：
+ * 1. 从 state 中提取最后一条 assistant 消息的 toolCalls
+ * 2. 通过 ToolOrchestrator.executeAll() 并行执行所有 Tool 调用
+ * 3. 通过 ToolResultInjector 将执行结果注入 state
+ *
+ * @see design.md §1.4 ToolNode: LangGraph的ToolNode封装
+ * @see requirements.md Requirement 8 AC1, AC3, AC5
+ */
+import { isHitlDecision, unwrapHitlPaused } from '../hitl/hitl-handler.js';
+import { ToolConfirmationInterceptor } from '../../tool/tool-confirmation.js';
+import { resolveCheckpointThreadId } from '../../session/persist-turn-messages.js';
+import { resolveTraceId } from '../../common/trace-id.js';
+export class ToolNode {
+    orchestrator;
+    injector;
+    defaultAuthContext;
+    onProgress;
+    hitlHandler;
+    nodeId;
+    constructor(orchestrator, injector, defaultAuthContext, onProgress, hitlHandler, nodeId) {
+        this.orchestrator = orchestrator;
+        this.injector = injector;
+        this.defaultAuthContext = defaultAuthContext;
+        this.onProgress = onProgress;
+        this.hitlHandler = hitlHandler;
+        this.nodeId = nodeId;
+    }
+    /**
+     * execute — StateGraph 节点函数
+     *
+     * 提取 pending tool_calls → 并行执行 → 注入结果 → 返回更新 state
+     *
+     * @param state - 当前 LangGraph State
+     * @returns 包含 Tool 结果消息的更新 state
+     */
+    async execute(state) {
+        // 1. 从 state 中提取 messages
+        const messages = this.extractMessages(state);
+        // 2. 找到最后一条 assistant 消息
+        const lastAssistantMessage = this.findLastAssistantMessage(messages);
+        // 3. 边界情况：无 tool calls → 原样返回
+        if (!lastAssistantMessage?.toolCalls || lastAssistantMessage.toolCalls.length === 0) {
+            return state;
+        }
+        const loadedTools = state['loadedTools'];
+        // 4. 转换为 ToolCallRequest[]（附带 manifest 路由字段）
+        const requests = lastAssistantMessage.toolCalls.map((tc) => {
+            const loaded = loadedTools?.[tc.name];
+            const correlationId = String(state['correlationId'] ?? tc.id);
+            const taskId = String(state['taskId'] ?? state['correlationId'] ?? tc.id);
+            return {
+                toolCallId: tc.id,
+                toolName: tc.name,
+                arguments: tc.arguments,
+                authContext: this.buildAuthContext(state),
+                forceServer: this.shouldForceServer(state, tc.name),
+                toolType: loaded?.manifest.type,
+                toolRuntime: loaded?.manifest.toolRuntime,
+                dataScope: loaded?.manifest.dataScope,
+                // dev 上下文 DevMcpExecutor 直连所需；server 上下文会忽略
+                execution: loaded?.manifest.execution,
+                correlationId,
+                taskId,
+            };
+        });
+        const executionContext = state['executionContext'];
+        const traceCollector = state['traceCollector'];
+        const traceId = resolveTraceId(state);
+        const agentCode = String(state['agentCode'] ?? state['agentId'] ?? '');
+        const nodeId = this.nodeId ?? 'tool-node';
+        const skillId = typeof state['activatedSkill'] === 'string' && state['activatedSkill']
+            ? state['activatedSkill']
+            : undefined;
+        const emitProgress = (data) => {
+            this.onProgress?.({ ...data, node: nodeId, ...(skillId ? { skillId } : {}) });
+        };
+        // 5. 并行执行所有 Tool 调用（附 Trace span）
+        const spanIds = await Promise.all(requests.map(async (req) => {
+            if (!traceCollector || !traceId)
+                return null;
+            try {
+                const parentNodeId = typeof state['skillSpanId'] === 'string' && state['skillSpanId']
+                    ? state['skillSpanId']
+                    : undefined;
+                return await traceCollector.createNode({
+                    traceId,
+                    name: req.toolName,
+                    type: 'tool',
+                    parentNodeId,
+                    toolRuntime: req.toolRuntime === 'both' ? 'both' : req.toolRuntime,
+                    agentCode: agentCode || undefined,
+                    input: req.arguments,
+                    metadata: {
+                        toolCallId: req.toolCallId,
+                        toolType: req.toolType,
+                        taskId: req.taskId,
+                        correlationId: req.correlationId,
+                        skillId,
+                    },
+                });
+            }
+            catch {
+                return null;
+            }
+        }));
+        // 并行执行，但各自独立计时（避免共用 startedAt 导致时长不准/看起来像“写死”）
+        // require_confirmation 工具走 HITL 拦截：改为顺序执行，thread_id 与 Checkpoint 对齐
+        const confirmationTools = new Set(Object.entries(loadedTools ?? {})
+            .filter(([, def]) => Boolean(def?.manifest.requireConfirmation))
+            .map(([name]) => name));
+        const needsHitl = Boolean(this.hitlHandler) &&
+            requests.some((req) => confirmationTools.has(req.toolName));
+        const runOne = async (req, i) => {
+            const resumingHitl = isHitlDecision(state['hitlChoice']);
+            if (!resumingHitl) {
+                emitProgress({
+                    toolCallId: req.toolCallId,
+                    toolName: req.toolName,
+                    status: 'started',
+                    arguments: req.arguments,
+                });
+            }
+            const startedAt = Date.now();
+            try {
+                let result;
+                if (needsHitl && this.hitlHandler && confirmationTools.has(req.toolName)) {
+                    const interceptor = new ToolConfirmationInterceptor(confirmationTools, this.hitlHandler, {
+                        execute: (r) => this.orchestrator.executeSingle(r, executionContext),
+                    });
+                    const graphState = this.toGraphState(state);
+                    const threadId = resolveCheckpointThreadId({
+                        sessionId: typeof state['sessionId'] === 'string' ? state['sessionId'] : undefined,
+                        taskId: req.taskId,
+                    });
+                    const confirmed = await interceptor.executeWithConfirmation(req, graphState, req.taskId ?? String(state['taskId'] ?? req.toolCallId), threadId, {
+                        toolSpanId: spanIds[i] ?? undefined,
+                        skillSpanId: typeof state['skillSpanId'] === 'string' ? state['skillSpanId'] : undefined,
+                    });
+                    result =
+                        confirmed ??
+                            {
+                                toolCallId: req.toolCallId,
+                                toolName: req.toolName,
+                                content: `用户拒绝执行工具 ${req.toolName}`,
+                                success: false,
+                                error: 'hitl_rejected',
+                            };
+                }
+                else {
+                    result = await this.orchestrator.executeSingle(req, executionContext);
+                }
+                const executionTime = Date.now() - startedAt;
+                if (result.success) {
+                    emitProgress({
+                        toolCallId: result.toolCallId,
+                        toolName: result.toolName,
+                        status: 'completed',
+                        content: result.content,
+                        executionTime,
+                    });
+                }
+                else {
+                    emitProgress({
+                        toolCallId: result.toolCallId,
+                        toolName: result.toolName,
+                        status: 'error',
+                        error: result.error ?? 'unknown error',
+                        executionTime,
+                    });
+                }
+                const nodeId = spanIds[i];
+                if (traceCollector && nodeId) {
+                    try {
+                        await traceCollector.completeNode(nodeId, {
+                            status: result.success ? 'completed' : 'failed',
+                            output: result.content,
+                            error: result.error,
+                        });
+                    }
+                    catch {
+                        // Trace 失败不影响主路径
+                    }
+                }
+                return result;
+            }
+            catch (err) {
+                // HITL 暂停必须向上抛出，供 invoke/stream 返回 waiting_hitl（不可降级为 tool failure）
+                const hitlPaused = unwrapHitlPaused(err);
+                if (hitlPaused) {
+                    hitlPaused.toolSpanId = hitlPaused.toolSpanId ?? spanIds[i] ?? undefined;
+                    hitlPaused.skillSpanId =
+                        hitlPaused.skillSpanId ??
+                            (typeof state['skillSpanId'] === 'string' ? state['skillSpanId'] : undefined);
+                    throw hitlPaused;
+                }
+                const executionTime = Date.now() - startedAt;
+                const message = err instanceof Error ? err.message : String(err);
+                emitProgress({
+                    toolCallId: req.toolCallId,
+                    toolName: req.toolName,
+                    status: 'error',
+                    error: message,
+                    executionTime,
+                });
+                return {
+                    toolCallId: req.toolCallId,
+                    toolName: req.toolName,
+                    content: '',
+                    success: false,
+                    error: message,
+                };
+            }
+        };
+        const execResults = needsHitl
+            ? await (async () => {
+                const out = [];
+                for (let i = 0; i < requests.length; i++) {
+                    out.push(await runOne(requests[i], i));
+                }
+                return out;
+            })()
+            : await Promise.all(requests.map((req, i) => runOne(req, i)));
+        // 6. 将 tool results 转换为 ToolMessage[]（不再注入到 graphState.messages，避免重复）
+        //
+        // 重要：messages channel 的 reducer 是 **append 语义**（[...current, ...update]），
+        // ToolNode 只返回 **新增的 toolMessage 数组**，reducer 自动追加到 current。
+        // 若返回 [...currentMessages, ...toolMessages]，会导致所有消息被追加两次
+        // （这也是早期版本里 user / assistant / tool 消息重复的根因）。
+        const toolMessages = execResults.map((result) => ({
+            role: 'tool',
+            content: result.success
+                ? result.content
+                : `[Tool Error] ${result.error ?? 'unknown error'}`,
+            // 以下字段符合 LLM function-calling 协议（ToolMessage 接口）
+            toolCallId: result.toolCallId,
+            toolName: result.toolName,
+            success: result.success,
+            ...('file' in result && result.file ? { file: result.file } : {}),
+        }));
+        // 7. 返回更新后的 state（仅含新增 messages + currentNode）
+        return {
+            messages: toolMessages,
+            currentNode: nodeId,
+        };
+    }
+    // ─────────────────────────────────────────────
+    // Private methods
+    // ─────────────────────────────────────────────
+    /**
+     * 从 state 中提取 messages 数组
+     */
+    extractMessages(state) {
+        const raw = state['messages'];
+        if (!Array.isArray(raw)) {
+            return [];
+        }
+        return raw.map((msg) => {
+            if (typeof msg === 'object' && msg !== null) {
+                const m = msg;
+                return {
+                    role: m['role'] ?? 'user',
+                    content: m['content'] ?? '',
+                    toolCalls: m['toolCalls'],
+                };
+            }
+            return { role: 'user', content: String(msg) };
+        });
+    }
+    /**
+     * 从 messages 中找到最后一条 assistant 消息
+     */
+    findLastAssistantMessage(messages) {
+        for (let i = messages.length - 1; i >= 0; i--) {
+            if (messages[i].role === 'assistant') {
+                return messages[i];
+            }
+        }
+        return undefined;
+    }
+    buildAuthContext(state) {
+        const executionContext = state['executionContext'];
+        // 旧 Checkpoint / 历史调用方兼容：agentId 仅作读兜底
+        const agentCode = String(state['agentCode'] ??
+            state['agentId'] ??
+            this.defaultAuthContext.agentCode ??
+            this.defaultAuthContext.agentId);
+        // 优先 ExecutionContext（invoke Token.sub），保证所有 Tool/MCP 出站同一身份
+        const userId = String(executionContext?.userId ?? state['userId'] ?? this.defaultAuthContext.userId);
+        const delegationToken = String(executionContext?.delegationToken ??
+            state['delegationToken'] ??
+            this.defaultAuthContext.delegationToken);
+        return {
+            userId,
+            delegationToken,
+            agentCode,
+        };
+    }
+    shouldForceServer(state, toolName) {
+        const forceList = state['forceToolServer'];
+        return Array.isArray(forceList) && forceList.includes(toolName);
+    }
+    /**
+     * 将 LangGraphState 转换为 GraphState（供 injector 使用）
+     */
+    toGraphState(state) {
+        const messages = this.extractMessages(state);
+        return {
+            ...state,
+            messages,
+            userId: state['userId'] ?? '',
+            delegationToken: state['delegationToken'],
+            loadedTools: state['loadedTools'],
+            forceToolServer: state['forceToolServer'],
+            executionContext: state['executionContext'],
+            agentCode: (state['agentCode'] ?? state['agentId']),
+            correlationId: state['correlationId'],
+            taskId: state['taskId'],
+            sessionId: state['sessionId'],
+        };
+    }
+}

package/dist/graph/resolve-graph-prompt.d.ts

@@ -0,0 +1,5 @@
+export interface ResolveGraphPromptOptions {
+    allowAbsolute?: boolean;
+}
+export declare function isGraphPromptPath(value: string): boolean;
+export declare function resolveGraphPrompt(raw: string | undefined, roots: string[], options?: ResolveGraphPromptOptions): string | undefined;

package/dist/graph/resolve-graph-prompt.js

@@ -0,0 +1,75 @@
+/**
+ * 图节点提示词：内联正文，或文件路径。
+ * - `./prompts/agent.md`：相对 promptRoots（agentDir / 工程根）
+ * - `/abs/path/agent.md`：绝对路径；dev/desktop 可读，server 仅当落在 promptRoots 内
+ */
+import { readFileSync, statSync } from 'node:fs';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
+const REL_RE = /^\.\/[A-Za-z0-9._/-]+\.(md|txt)$/;
+const ABS_RE = /^(?:\/|[A-Za-z]:[\\/])[^\r\n]+\.(md|txt)$/i;
+export function isGraphPromptPath(value) {
+    const trimmed = value.trim();
+    return REL_RE.test(trimmed) || ABS_RE.test(trimmed);
+}
+export function resolveGraphPrompt(raw, roots, options = {}) {
+    if (typeof raw !== 'string')
+        return undefined;
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return undefined;
+    if (!isGraphPromptPath(trimmed))
+        return raw;
+    if (REL_RE.test(trimmed)) {
+        return readRelative(trimmed, roots);
+    }
+    return readAbsolute(trimmed, roots, options.allowAbsolute ?? defaultAllowAbsolute());
+}
+function defaultAllowAbsolute() {
+    const ctx = (process.env.EAP_DEPLOYMENT_CONTEXT ?? '').toLowerCase();
+    return ctx === 'dev' || ctx === 'desktop';
+}
+function readRelative(spec, roots) {
+    const relativePath = spec.slice(2).replace(/\\/g, '/');
+    if (relativePath.split('/').some((part) => part === '' || part === '.' || part === '..')) {
+        throw new Error(`Graph prompt path is not portable: ${spec}`);
+    }
+    for (const root of roots) {
+        if (!root)
+            continue;
+        const candidate = resolve(root, relativePath);
+        if (!isInside(root, candidate))
+            continue;
+        const text = readIfFile(candidate);
+        if (text !== undefined)
+            return text;
+    }
+    throw new Error(`Graph prompt file not found: ${spec}`);
+}
+function readAbsolute(spec, roots, allowAbsolute) {
+    const candidate = resolve(spec);
+    if (!isAbsolute(candidate) || candidate.includes(`..${sep}`) || /(?:^|[\\/])\.\.(?:[\\/]|$)/.test(spec)) {
+        throw new Error(`Graph prompt path is not portable: ${spec}`);
+    }
+    const underRoot = roots.some((root) => root && isInside(root, candidate));
+    if (!underRoot && !allowAbsolute) {
+        throw new Error(`Absolute graph prompt path is not allowed outside the Agent directory: ${spec}`);
+    }
+    const text = readIfFile(candidate);
+    if (text === undefined)
+        throw new Error(`Graph prompt file not found: ${spec}`);
+    return text;
+}
+function readIfFile(candidate) {
+    try {
+        if (!statSync(candidate).isFile())
+            return undefined;
+        return readFileSync(candidate, 'utf8').replace(/^\uFEFF/, '');
+    }
+    catch {
+        return undefined;
+    }
+}
+function isInside(root, target) {
+    const relativePath = relative(resolve(root), resolve(target));
+    return relativePath === '' || (!relativePath.startsWith(`..${sep}`) && relativePath !== '..');
+}

package/dist/graph/retry/budget-aware-retry.d.ts

@@ -0,0 +1,91 @@
+/**
+ * BudgetAwareRetryExecutor — Token Budget 感知的重试执行器
+ *
+ * 扩展 NodeRetryExecutor，在重试时检查 Token Budget：
+ * - 重试产生的 Token 消耗计入配额
+ * - 配额耗尽时不再重试
+ *
+ * @see node-retry.ts 基础重试逻辑
+ * @see token/token-budget.service.ts Token Budget 控制
+ * @see requirements.md Requirement 12.4
+ */
+import { NodeRetryExecutor } from './node-retry.js';
+import type { NodeRetryConfig } from '../contracts/executable-graph.js';
+/**
+ * Token 消耗回调接口
+ *
+ * 由外部注入，用于报告重试过程中的 Token 消耗。
+ */
+export interface TokenConsumptionCallback {
+    /**
+     * 报告 Token 消耗
+     *
+     * @param nodeId - 节点 ID
+     * @param tokens - 消耗的 Token 数
+     * @returns 是否还有剩余配额（false 表示配额耗尽）
+     */
+    reportConsumption(nodeId: string, tokens: number): Promise<boolean>;
+}
+/**
+ * BudgetAwareRetryConfig — 带预算感知的重试配置
+ */
+export interface BudgetAwareRetryConfig extends NodeRetryConfig {
+    /** 每次重试预估的 Token 消耗 */
+    estimatedTokensPerRetry?: number;
+    /** Token 消耗回调 */
+    tokenCallback?: TokenConsumptionCallback;
+}
+/**
+ * BudgetExhaustedError — Token 预算耗尽错误
+ *
+ * 当重试过程中 Token 预算耗尽时抛出。
+ */
+export declare class BudgetExhaustedError extends Error {
+    readonly nodeId: string;
+    readonly consumedTokens: number;
+    readonly attempt: number;
+    constructor(opts: {
+        nodeId: string;
+        consumedTokens: number;
+        attempt: number;
+    });
+}
+/**
+ * BudgetAwareRetryExecutor — Token Budget 感知的重试执行器
+ *
+ * 在重试前检查 Token Budget，配额耗尽时停止重试。
+ */
+export declare class BudgetAwareRetryExecutor extends NodeRetryExecutor {
+    private readonly estimatedTokensPerRetry;
+    private readonly tokenCallback?;
+    private totalConsumedTokens;
+    constructor(nodeId: string, config?: BudgetAwareRetryConfig);
+    /**
+     * 带预算检查的重试执行
+     *
+     * @param fn - 要执行的异步函数
+     * @param config - 可选覆盖重试配置
+     * @param abortSignal - 可选 AbortSignal
+     * @returns RetryResult 包含结果和观测数据
+     * @throws RetryExhaustedError 当所有重试用尽
+     * @throws BudgetExhaustedError 当 Token 预算耗尽
+     */
+    executeWithBudgetCheck<T>(fn: () => Promise<T>, config?: BudgetAwareRetryConfig, abortSignal?: AbortSignal): Promise<{
+        result: T;
+        totalConsumedTokens: number;
+    }>;
+    /**
+     * 获取已消耗的 Token 数
+     */
+    getTotalConsumedTokens(): number;
+}
+/**
+ * withBudgetRetry — 将节点函数包装为带预算检查的重试版本
+ *
+ * @param nodeId - 节点标识
+ * @param nodeFn - 原始节点函数
+ * @param config - 重试配置（含 Token Budget 回调）
+ * @param abortSignal - 可选 AbortSignal
+ * @returns 包装后的节点函数
+ */
+export declare function withBudgetRetry(nodeId: string, nodeFn: (state: Record<string, unknown>) => Promise<Record<string, unknown>>, config: BudgetAwareRetryConfig, abortSignal?: AbortSignal): (state: Record<string, unknown>) => Promise<Record<string, unknown>>;

package/dist/graph/retry/budget-aware-retry.js

@@ -0,0 +1,126 @@
+/**
+ * BudgetAwareRetryExecutor — Token Budget 感知的重试执行器
+ *
+ * 扩展 NodeRetryExecutor，在重试时检查 Token Budget：
+ * - 重试产生的 Token 消耗计入配额
+ * - 配额耗尽时不再重试
+ *
+ * @see node-retry.ts 基础重试逻辑
+ * @see token/token-budget.service.ts Token Budget 控制
+ * @see requirements.md Requirement 12.4
+ */
+import { NodeRetryExecutor } from './node-retry.js';
+// ─────────────────────────────────────────────
+// BudgetExhaustedError
+// ─────────────────────────────────────────────
+/**
+ * BudgetExhaustedError — Token 预算耗尽错误
+ *
+ * 当重试过程中 Token 预算耗尽时抛出。
+ */
+export class BudgetExhaustedError extends Error {
+    nodeId;
+    consumedTokens;
+    attempt;
+    constructor(opts) {
+        super(`Node "${opts.nodeId}" retry aborted: Token budget exhausted after ${opts.attempt} attempts (${opts.consumedTokens} tokens consumed)`);
+        this.name = 'BudgetExhaustedError';
+        this.nodeId = opts.nodeId;
+        this.consumedTokens = opts.consumedTokens;
+        this.attempt = opts.attempt;
+    }
+}
+// ─────────────────────────────────────────────
+// BudgetAwareRetryExecutor
+// ─────────────────────────────────────────────
+/**
+ * BudgetAwareRetryExecutor — Token Budget 感知的重试执行器
+ *
+ * 在重试前检查 Token Budget，配额耗尽时停止重试。
+ */
+export class BudgetAwareRetryExecutor extends NodeRetryExecutor {
+    estimatedTokensPerRetry;
+    tokenCallback;
+    totalConsumedTokens = 0;
+    constructor(nodeId, config) {
+        super(nodeId, config);
+        this.estimatedTokensPerRetry = config?.estimatedTokensPerRetry ?? 1000;
+        this.tokenCallback = config?.tokenCallback;
+    }
+    /**
+     * 带预算检查的重试执行
+     *
+     * @param fn - 要执行的异步函数
+     * @param config - 可选覆盖重试配置
+     * @param abortSignal - 可选 AbortSignal
+     * @returns RetryResult 包含结果和观测数据
+     * @throws RetryExhaustedError 当所有重试用尽
+     * @throws BudgetExhaustedError 当 Token 预算耗尽
+     */
+    async executeWithBudgetCheck(fn, config, abortSignal) {
+        const effectiveConfig = {
+            maxRetries: config?.maxRetries ?? this.getConfig().maxRetries,
+            backoff: config?.backoff ?? this.getConfig().backoff,
+            estimatedTokensPerRetry: config?.estimatedTokensPerRetry ?? this.estimatedTokensPerRetry,
+            tokenCallback: config?.tokenCallback ?? this.tokenCallback,
+        };
+        this.totalConsumedTokens = 0;
+        try {
+            const { result, totalAttempts } = await this.executeWithRetry(async () => {
+                // 执行前检查 Token Budget
+                if (effectiveConfig.tokenCallback) {
+                    const hasBudget = await effectiveConfig.tokenCallback.reportConsumption(this.getNodeId(), effectiveConfig.estimatedTokensPerRetry);
+                    if (!hasBudget) {
+                        throw new BudgetExhaustedError({
+                            nodeId: this.getNodeId(),
+                            consumedTokens: this.totalConsumedTokens,
+                            attempt: totalAttempts,
+                        });
+                    }
+                }
+                // 执行函数
+                const result = await fn();
+                // 记录 Token 消耗
+                this.totalConsumedTokens += effectiveConfig.estimatedTokensPerRetry;
+                return result;
+            }, config, abortSignal);
+            return {
+                result,
+                totalConsumedTokens: this.totalConsumedTokens,
+            };
+        }
+        catch (error) {
+            // 如果是 BudgetExhaustedError，直接抛出
+            if (error instanceof BudgetExhaustedError) {
+                throw error;
+            }
+            // 其他错误重新抛出
+            throw error;
+        }
+    }
+    /**
+     * 获取已消耗的 Token 数
+     */
+    getTotalConsumedTokens() {
+        return this.totalConsumedTokens;
+    }
+}
+// ─────────────────────────────────────────────
+// withBudgetRetry — 高阶包装函数
+// ─────────────────────────────────────────────
+/**
+ * withBudgetRetry — 将节点函数包装为带预算检查的重试版本
+ *
+ * @param nodeId - 节点标识
+ * @param nodeFn - 原始节点函数
+ * @param config - 重试配置（含 Token Budget 回调）
+ * @param abortSignal - 可选 AbortSignal
+ * @returns 包装后的节点函数
+ */
+export function withBudgetRetry(nodeId, nodeFn, config, abortSignal) {
+    const executor = new BudgetAwareRetryExecutor(nodeId, config);
+    return async (state) => {
+        const { result } = await executor.executeWithBudgetCheck(() => nodeFn(state), undefined, abortSignal);
+        return result;
+    };
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Retry Module — 节点级重试
+ *
+ * 导出通用重试执行器、错误类型和高阶包装函数。
+ */
+export { NodeRetryExecutor, RetryExhaustedError, withRetry, DEFAULT_LLM_RETRY_CONFIG, DEFAULT_NODE_RETRY_CONFIG, } from './node-retry.js';
+export type { NodeFunction, RetryAttemptInfo, RetryResult, } from './node-retry.js';
+export { BudgetAwareRetryExecutor, BudgetExhaustedError, withBudgetRetry, } from './budget-aware-retry.js';
+export type { BudgetAwareRetryConfig, TokenConsumptionCallback, } from './budget-aware-retry.js';

package/dist/graph/retry/index.js

@@ -0,0 +1,8 @@
+/**
+ * Retry Module — 节点级重试
+ *
+ * 导出通用重试执行器、错误类型和高阶包装函数。
+ */
+export { NodeRetryExecutor, RetryExhaustedError, withRetry, DEFAULT_LLM_RETRY_CONFIG, DEFAULT_NODE_RETRY_CONFIG, } from './node-retry.js';
+// Token Budget 感知的重试
+export { BudgetAwareRetryExecutor, BudgetExhaustedError, withBudgetRetry, } from './budget-aware-retry.js';