@gt-fe/eap-runtime 0.0.23 → 0.0.25

package/dist/graph/adapters/langgraph.adapter.js

@@ -37,14 +37,34 @@ import { isHitlDecision, lastAssistantHasUnansweredToolCalls } from '../hitl/hit
 import { classifySkillRead } from './skill-read.js';
 import { skillEntryInvocationFromTool } from './skill-entry-span.js';
 import { withGraphSpan } from '../trace-span.js';
-import { executionTraceFromState, getExecutionStream, runWithExecutionTrace, } from '../execution-trace-context.js';
+import { executionTraceFromState, getExecutionStream, getExecutionTrace, runWithExecutionTrace, } from '../execution-trace-context.js';
 import { isRetryableToolFailure, resolveToolRetryConfig, sleepToolRetry, toolRetryDelayMs, } from '../../tool/tool-retry.js';
-/** 图未写 `config.maxIterations` 时的 recursionLimit。`agent ⇄ tools` 一圈约 2，50 ≈ 24 次工具往返。 */
-export const DEFAULT_GRAPH_RECURSION_LIMIT = 50;
 /**
- * LangGraph `recursionLimit` 计 superstep（每进一个节点 +1），不是 ReAct 圈数。
- * 图上 `config.maxIterations` 优先；缺省 {@link DEFAULT_GRAPH_RECURSION_LIMIT}。
+ * 传给 LangGraph 的 `recursionLimit`：一轮调度（superstep）+1。
+ * 同一步里并行的多个节点只 +1。ReAct 的 llm 再 tool 大约 +2。
+ * 不读图级 / 请求级 `maxIterations`。整图运行时长用 `timeout`。
+ * 配了 Token 配额才会因预算停止。
  */
+export const DEFAULT_GRAPH_RECURSION_LIMIT = 5000;
+const GRAPH_RECURSION_LIMIT_MESSAGE = '图执行超过平台调度步上限。整图限长请用 config.timeout。';
+export function isGraphRecursionError(error) {
+    if (!(error instanceof Error))
+        return false;
+    if (error.name === 'GraphRecursionError')
+        return true;
+    return /Recursion limit of \d+/i.test(error.message);
+}
+function rethrowGraphRunError(error) {
+    if (error instanceof AppError)
+        throw error;
+    if (isGraphRecursionError(error)) {
+        throw new AppError(ErrorCodes.GRAPH_MAX_ITERATIONS, GRAPH_RECURSION_LIMIT_MESSAGE, {
+            exposeMessage: true,
+            cause: error,
+        });
+    }
+    throw error;
+}
 /** 并行节点各自返回 [id] 时合并进同一路径；末项相同不重复。 */
 export function mergeHistoryPath(current, update) {
     const path = Array.isArray(current)
@@ -63,16 +83,54 @@ export function mergeHistoryPath(current, update) {
     }
     return path.length > 1000 ? path.slice(path.length - 1000) : path;
 }
-function langGraphRunOptions(dsl, extra) {
-    const raw = dsl.config?.maxIterations;
-    const recursionLimit = typeof raw === 'number' && Number.isFinite(raw) && raw > 0
-        ? Math.trunc(raw)
-        : DEFAULT_GRAPH_RECURSION_LIMIT;
+function langGraphRunOptions(extra) {
     return {
         ...extra,
-        recursionLimit,
+        recursionLimit: DEFAULT_GRAPH_RECURSION_LIMIT,
     };
 }
+function graphAbortSignal(state) {
+    const fromState = state?.abortSignal;
+    if (fromState instanceof AbortSignal)
+        return fromState;
+    return getExecutionTrace()?.abortSignal;
+}
+function abortReason(signal) {
+    return signal.reason instanceof Error
+        ? signal.reason
+        : new Error(String(signal.reason ?? 'aborted'));
+}
+function graphAbortDeadlineMs(state) {
+    const fromState = state?.abortDeadlineMs;
+    if (typeof fromState === 'number' && Number.isFinite(fromState))
+        return fromState;
+    return getExecutionTrace()?.abortDeadlineMs;
+}
+function throwIfGraphAborted(state) {
+    const deadline = graphAbortDeadlineMs(state);
+    if (deadline !== undefined && Date.now() >= deadline) {
+        const signal = graphAbortSignal(state);
+        throw signal?.aborted
+            ? abortReason(signal)
+            : new Error('Task timed out after graph deadline');
+    }
+    const signal = graphAbortSignal(state);
+    if (signal?.aborted)
+        throw abortReason(signal);
+}
+function withGraphAbort(promise, signal) {
+    if (!signal)
+        return promise;
+    if (signal.aborted)
+        return Promise.reject(abortReason(signal));
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(abortReason(signal));
+        signal.addEventListener('abort', onAbort, { once: true });
+        promise.then(resolve, reject).finally(() => {
+            signal.removeEventListener('abort', onAbort);
+        });
+    });
+}
 // ─────────────────────────────────────────────
 // LangGraphAdapter
 // ─────────────────────────────────────────────
@@ -532,12 +590,25 @@ export class LangGraphAdapter {
             streamedTextThisTurn: false,
         };
         const traceCtx = executionTraceFromState(state);
-        const producer = runWithExecutionTrace({ ...traceCtx, stream: streamBag }, () => (async () => {
+        const graphSignal = graphAbortSignal(state);
+        const onGraphAbort = () => {
+            failure = graphSignal ? abortReason(graphSignal) : new Error('aborted');
+            finished = true;
+            signal();
+        };
+        graphSignal?.addEventListener('abort', onGraphAbort, { once: true });
+        const producer = runWithExecutionTrace({
+            ...traceCtx,
+            stream: streamBag,
+            abortSignal: graphSignal,
+            abortDeadlineMs: graphAbortDeadlineMs(state),
+        }, () => (async () => {
             try {
-                const streamIterator = await ref.compiled.stream(input, langGraphRunOptions(ref.dsl, {
+                throwIfGraphAborted(state);
+                const streamIterator = await withGraphAbort(Promise.resolve(ref.compiled.stream(input, langGraphRunOptions({
                     configurable: this.checkpointConfigurable(state, graph),
                     streamMode: 'updates',
-                }));
+                }))), graphSignal);
                 for await (const update of streamIterator) {
                     for (const event of this.convertUpdatesToEvents(update, graph.id, () => streamBag.chunkIndex++, ref.silentNodeIds, ref.subgraphNodeIds)) {
                         enqueue(event);
@@ -562,8 +633,9 @@ export class LangGraphAdapter {
             yield queue.shift();
         }
         await producer;
+        graphSignal?.removeEventListener('abort', onGraphAbort);
         if (failure)
-            throw failure;
+            rethrowGraphRunError(failure);
     }
     /**
      * 同步调用图执行，返回完整结果
@@ -573,10 +645,22 @@ export class LangGraphAdapter {
         const input = this.graphStateToLangGraphInput(this.applyDeclaredSearchFace(state, ref.dsl));
         const startTime = Date.now();
         const traceCtx = executionTraceFromState(state);
+        const abortSignal = graphAbortSignal(state);
+        const abortDeadlineMs = graphAbortDeadlineMs(state);
         // 只补 collector/traceId。子图套娃时外层 stream 袋经 ?? 保留。
-        const result = await runWithExecutionTrace(traceCtx, () => ref.compiled.invoke(input, langGraphRunOptions(ref.dsl, {
-            configurable: this.checkpointConfigurable(state, graph),
-        })));
+        let result;
+        try {
+            result = await withGraphAbort(runWithExecutionTrace({
+                ...traceCtx,
+                abortSignal,
+                abortDeadlineMs,
+            }, () => ref.compiled.invoke(input, langGraphRunOptions({
+                configurable: this.checkpointConfigurable(state, graph),
+            }))), abortSignal);
+        }
+        catch (error) {
+            rethrowGraphRunError(error);
+        }
         const duration = Date.now() - startTime;
         const messages = Array.isArray(result['messages']) ? result['messages'] : [];
         const lastMessage = messages[messages.length - 1];
@@ -684,6 +768,7 @@ export class LangGraphAdapter {
     createNodeFunction(node) {
         const impl = this.createNodeFunctionBody(node);
         return async (state) => {
+            throwIfGraphAborted(state);
             const update = await impl(state);
             const patch = update && typeof update === 'object' ? { ...update } : {};
             const currentNode = typeof patch['currentNode'] === 'string' && String(patch['currentNode']).trim()

package/dist/graph/contracts/executable-graph.d.ts

@@ -239,10 +239,19 @@ export interface GraphState {
     /** 最近一次 createNode 的 span id；Checkpoint 引用挂在此 Span 上 */
     lastSpanId?: string;
     /**
-     * HITL 续跑：入口 messages 以 __set 覆盖 checkpoint 历史，避免 append 重复。
-     * 仅 stream/invoke 入口使用，不入持久化语义。
+     * 入口 messages 以 __set 覆盖 checkpoint 历史，避免 append 重复。
+     * HITL 续跑与会话压缩写回最新 Checkpoint 使用。不入持久化语义。
      */
     replaceCheckpointMessages?: boolean;
+    /**
+     * 整图超时用的 AbortSignal。不入 Checkpoint。不传给 LangGraph。
+     */
+    abortSignal?: AbortSignal;
+    /**
+     * 整图超时截止（`Date.now()`）。不入 Checkpoint。
+     * 节点入口检查，避免同步循环占满事件循环导致 timer 不能触发。
+     */
+    abortDeadlineMs?: number;
     /**
      * 子图 invoke 写入 LangGraph `checkpoint_ns`。
      * 父图为空；子图为父节点 id。存储槽与父 thread 分开，不覆盖父 latest。

package/dist/graph/execution-trace-context.d.ts

@@ -16,6 +16,10 @@ export interface ExecutionRunContext {
     collector?: ITraceCollector;
     traceId?: string;
     stream?: ExecutionStreamBag;
+    /** 整图超时 AbortSignal；不入 Checkpoint；不传给 LangGraph */
+    abortSignal?: AbortSignal;
+    /** 整图超时截止（Date.now()）；不入 Checkpoint */
+    abortDeadlineMs?: number;
 }
 /** 入口从本次入参取出可绑定的 collector+traceId；缺一则不算。 */
 export declare function executionTraceFromState(state: GraphState | Record<string, unknown> | undefined): {

package/dist/graph/execution-trace-context.js

@@ -33,8 +33,10 @@ export function runWithExecutionTrace(patch, fn) {
         collector: patch.collector ?? outer?.collector,
         traceId: patch.traceId ?? outer?.traceId,
         stream: patch.stream ?? outer?.stream,
+        abortSignal: patch.abortSignal ?? outer?.abortSignal,
+        abortDeadlineMs: patch.abortDeadlineMs ?? outer?.abortDeadlineMs,
     };
-    if (!next.collector && !next.traceId && !next.stream)
+    if (!next.collector && !next.traceId && !next.stream && !next.abortSignal && next.abortDeadlineMs === undefined)
         return fn();
     return storage.run(next, fn);
 }

package/dist/graph/nodes/rag/types.d.ts

@@ -173,7 +173,10 @@ export interface RagNodeConfig {
     model?: string;
     /** 融合后总条数，缺省 10 */
     totalK?: number;
-    /** ReAct 决策轮硬上限（按决策轮计次，同轮并发多个 tool_call 只计 1），缺省 5 */
+    /**
+     * 本节点检索轮次上限（同轮并发多个 tool_call 只计 1），缺省 5。
+     * 到上限该节点带着已有结果正常结束，后续图节点继续。不是整图停止。
+     */
     maxIterations?: number;
     /** 近重判定阈值（字符 n-gram Jaccard，M4 启用），缺省 0.8 */
     nearDupThreshold?: number;

package/dist/providers/http-llm-provider.js

@@ -9,6 +9,7 @@
 import { resolveLlmModelName } from './resolve-llm-model.js';
 import { createFileLlmTurnLogFromEnv, maskApiKey } from '../debug/llm-turn-log.js';
 import { buildContextUsage, turnSectionChars } from '../token/context-window.js';
+import { getExecutionTrace } from '../graph/execution-trace-context.js';
 export const DEFAULT_LLM_HTTP_TIMEOUT_MS = 180_000;
 export class HttpLLMProvider {
     apiKey;
@@ -101,6 +102,7 @@ export class HttpLLMProvider {
         }
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+        const unlinkGraphAbort = linkGraphAbort(controller);
         const url = `${this.baseUrl}/chat/completions`;
         const startedAt = Date.now();
         try {
@@ -117,6 +119,7 @@ export class HttpLLMProvider {
                 });
             }
             catch (err) {
+                throwIfGraphTimedOut();
                 throw new Error(this.formatNetworkError(url, err));
             }
             if (!response.ok) {
@@ -184,6 +187,7 @@ export class HttpLLMProvider {
         }
         finally {
             clearTimeout(timeout);
+            unlinkGraphAbort();
         }
     }
     async *stream(messages, config) {
@@ -217,6 +221,7 @@ export class HttpLLMProvider {
         }
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+        const unlinkGraphAbort = linkGraphAbort(controller);
         const url = `${this.baseUrl}/chat/completions`;
         const startedAt = Date.now();
         const contentChunks = [];
@@ -239,6 +244,7 @@ export class HttpLLMProvider {
                 });
             }
             catch (err) {
+                throwIfGraphTimedOut();
                 throw new Error(this.formatNetworkError(url, err));
             }
             if (!response.ok) {
@@ -412,6 +418,7 @@ export class HttpLLMProvider {
         }
         finally {
             clearTimeout(timeout);
+            unlinkGraphAbort();
         }
     }
     // ─────────────────────────────────────────────
@@ -509,6 +516,24 @@ export class HttpLLMProvider {
         return `LLM network error calling ${url}: ${detail}`;
     }
 }
+function linkGraphAbort(controller) {
+    const graphSignal = getExecutionTrace()?.abortSignal;
+    if (!graphSignal)
+        return () => undefined;
+    if (graphSignal.aborted) {
+        controller.abort(graphSignal.reason);
+        return () => undefined;
+    }
+    const onAbort = () => controller.abort(graphSignal.reason);
+    graphSignal.addEventListener('abort', onAbort, { once: true });
+    return () => graphSignal.removeEventListener('abort', onAbort);
+}
+function throwIfGraphTimedOut() {
+    const reason = getExecutionTrace()?.abortSignal?.reason;
+    if (reason instanceof Error && /timed out/i.test(reason.message)) {
+        throw reason;
+    }
+}
 function formatNetworkDetail(error, depth = 0) {
     if (depth > 5)
         return '...';

package/dist/registry/graph-loader.js

@@ -4,6 +4,7 @@
  * 生产（server + EAP_PREINSTALL_ROOT）：以预装为准，缺失则失败（04 Req 8.1）。
  * 开发态：Registry + 可选 ./tools 本地 manifest。
  */
+import { DEFAULT_GRAPH_TIMEOUT_MS } from '../common/types.js';
 import { readdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { resolveAgentModelAllowlist, resolveAgentDefaultModel } from './agent-models.js';
@@ -142,7 +143,7 @@ const DEFAULT_GRAPH_DSL = {
     ],
     entryPoint: 'llm',
     finishPoints: ['__end__'],
-    config: { timeout: 60000 },
+    config: { timeout: DEFAULT_GRAPH_TIMEOUT_MS },
 };
 /** 源图有非空字符串则保留；缺省或空数组为 `['__end__']`。预装 graph.json 与清单内嵌图同一收口。 */
 function finishPointsFromGraphDocument(graph) {
@@ -155,8 +156,8 @@ function finishPointsFromGraphDocument(graph) {
         .filter((id) => id.length > 0);
     return ids.length > 0 ? ids : ['__end__'];
 }
-const DEFAULT_LOADED_GRAPH_CONFIG = { timeout: 60000 };
-/** 默认 timeout 60000；源图 `config` 覆盖。缺 `maxIterations` 时由引擎用 50。 */
+const DEFAULT_LOADED_GRAPH_CONFIG = { timeout: DEFAULT_GRAPH_TIMEOUT_MS };
+/** 默认 timeout {@link DEFAULT_GRAPH_TIMEOUT_MS}；源图 `config` 覆盖。`maxIterations` 可留在 DSL 上，引擎忽略。 */
 function configFromGraphDocument(graph) {
     const raw = graph.config;
     if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
@@ -758,7 +759,7 @@ export class GraphLoader {
                 },
             ],
             config: {
-                timeout: manifest.config?.timeout ?? 60000,
+                timeout: manifest.config?.timeout ?? DEFAULT_GRAPH_TIMEOUT_MS,
                 maxRetries: manifest.config?.retryCount,
             },
         };

package/dist/runtime/agent-runtime.d.ts

@@ -10,6 +10,7 @@ import type { InvokeOrchestrator } from '../api/handlers/invoke.handler.js';
 import type { ICheckpointSaver } from '../checkpoint/contracts/checkpoint-saver.contract.js';
 import type { ITraceCollector } from '../contracts/trace-collector.js';
 import type { IStateGraphEngine } from '../graph/contracts/state-graph.contract.js';
+import type { TaskTimeoutManager } from '../task/task-timeout.js';
 import { HitlHandler } from '../graph/hitl/hitl-handler.js';
 import { type GraphLoader } from '../registry/graph-loader.js';
 import type { SessionContextService } from '../session/session-context.service.js';
@@ -47,10 +48,12 @@ export interface AgentRuntimeDeps {
      */
     traceCollector?: ITraceCollector;
     recordForkRelation?: RecordForkRelation;
-    /** 历史压缩；默认关。见 EAP_RUNTIME_COMPRESSION */
+    /** 历史压缩；默认开。EAP_RUNTIME_COMPRESSION=0 关闭 */
     sessionCompression?: SessionCompressionOptions;
     /** 长期记忆注入；默认关。见 EAP_RUNTIME_MEMORY */
     sessionMemory?: import('../session/apply-session-memory.js').SessionMemoryOptions;
+    /** 未注入时不启动整图超时（测试桩） */
+    timeoutManager?: TaskTimeoutManager;
 }
 /** 一次对话详情：消息 + 每步 LLM 入参/响应。File / 内存 / Postgres 同一套结构。 */
 export interface ConversationDetail {