@gt-fe/eap-runtime 0.0.22 → 0.0.24

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

@@ -16,7 +16,7 @@ import { inferHarnessSkillDir } from '../../tool/skill-dir-infer.js';
 import { isHitlDecision, unwrapHitlPaused } from '../hitl/hitl-handler.js';
 import { ToolConfirmationInterceptor } from '../../tool/tool-confirmation.js';
 import { resolveCheckpointThreadId } from '../../session/persist-turn-messages.js';
-import { toolTraceIdentity } from '../../tool/mcp-list.js';
+import { mcpToolsetCode, toolTraceIdentity } from '../../tool/mcp-list.js';
 import { resolveExecutionTrace, warnTraceSpanFailure, } from '../execution-trace-context.js';
 import { emitRuntimeLog } from '../../common/logger.js';
 import { decideBeforeTool, } from '../../execution/interceptors.js';
@@ -92,6 +92,7 @@ export class ToolNode {
         // 4. 转换为 ToolCallRequest[]（附带 manifest 路由字段）
         const requests = lastAssistantMessage.toolCalls.map((tc) => {
             const loaded = loadedTools?.[tc.name];
+            const toolsetCode = mcpToolsetCode(loaded);
             const correlationId = String(state['correlationId'] ?? tc.id);
             const taskId = String(state['taskId'] ?? state['correlationId'] ?? tc.id);
             const command = typeof tc.arguments?.command === 'string' ? tc.arguments.command : undefined;
@@ -114,6 +115,7 @@ export class ToolNode {
                 // dev 上下文 DevMcpExecutor 直连所需；server 上下文会忽略
                 execution: loaded?.manifest.execution,
                 ...(loaded?.manifest.version ? { toolVersion: loaded.manifest.version } : {}),
+                ...(toolsetCode ? { toolsetCode } : {}),
                 correlationId,
                 taskId,
                 ...(jail.workdir ? { jailWorkdir: jail.workdir } : {}),
@@ -506,10 +508,17 @@ export class ToolNode {
         const delegationToken = String(executionContext?.delegationToken ??
             state['delegationToken'] ??
             this.defaultAuthContext.delegationToken);
+        const fromState = typeof state['agentVersion'] === 'string' ? state['agentVersion'].trim() : '';
+        const agentDir = typeof state['agentDir'] === 'string' ? state['agentDir'].trim() : '';
+        const fromDir = agentDir
+            ? agentDir.split(/[/\\]/).filter(Boolean).pop()
+            : undefined;
+        const agentVersion = fromState || fromDir;
         return {
             userId,
             delegationToken,
             agentCode,
+            ...(agentVersion ? { agentVersion } : {}),
         };
     }
     shouldForceServer(state, toolName) {

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,7 +4,8 @@
  * 生产（server + EAP_PREINSTALL_ROOT）：以预装为准，缺失则失败（04 Req 8.1）。
  * 开发态：Registry + 可选 ./tools 本地 manifest。
  */
-import { readFile } from 'node:fs/promises';
+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';
 import { DEFAULT_HTTP_TOOL_TIMEOUT_SEC, DEFAULT_TOOL_TIMEOUT_SEC } from '../tool/timeout.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)) {
@@ -463,16 +464,71 @@ function fromInlineToolDeclaration(tool) {
         inputSchema: tool.input,
     };
 }
+const DEV_LOCAL_MANIFEST_FILES = [
+    'toolset.manifest.json',
+    'tool.manifest.json',
+    'manifest.json',
+];
+async function readJsonObject(filePath) {
+    try {
+        const raw = await readFile(filePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function loadedToolFromDevDir(dir, toolName, doc, toolsetOnly) {
+    const tools = doc.tools;
+    if (Array.isArray(tools) && tools.length > 0 && typeof tools[0] === 'object') {
+        const pre = {
+            toolId: String(doc.code ?? path.basename(dir)),
+            name: String(doc.name ?? path.basename(dir)),
+            version: String(doc.version ?? '0.0.0'),
+            manifest: doc,
+            bundlePath: dir,
+        };
+        const expanded = expandPreinstallToolset(pre);
+        return expanded.find((d) => d.name === toolName) ?? null;
+    }
+    if (toolsetOnly)
+        return null;
+    return fromLocalManifestFile(toolName, doc);
+}
+async function loadDevLocalManifestFromDir(dir, toolName, toolsetOnly) {
+    const files = toolsetOnly ? ['toolset.manifest.json'] : DEV_LOCAL_MANIFEST_FILES;
+    for (const file of files) {
+        const doc = await readJsonObject(path.join(dir, file));
+        if (!doc)
+            continue;
+        const hit = loadedToolFromDevDir(dir, toolName, doc, toolsetOnly);
+        if (hit)
+            return hit;
+    }
+    return null;
+}
 async function loadDevLocalManifest(toolName, toolsDir) {
-    const manifestPath = path.join(toolsDir, toolName, 'tool.manifest.json');
+    const direct = await loadDevLocalManifestFromDir(path.join(toolsDir, toolName), toolName, false);
+    if (direct)
+        return direct;
+    let entries;
     try {
-        const raw = await readFile(manifestPath, 'utf-8');
-        const manifest = JSON.parse(raw);
-        return fromLocalManifestFile(toolName, manifest);
+        entries = await readdir(toolsDir, { withFileTypes: true });
     }
     catch {
         return null;
     }
+    for (const ent of entries) {
+        if (!ent.isDirectory() || ent.name === toolName)
+            continue;
+        const hit = await loadDevLocalManifestFromDir(path.join(toolsDir, ent.name), toolName, true);
+        if (hit)
+            return hit;
+    }
+    return null;
 }
 function fromLocalInstall(install) {
     return {
@@ -703,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';
@@ -51,6 +52,8 @@ export interface AgentRuntimeDeps {
     sessionCompression?: SessionCompressionOptions;
     /** 长期记忆注入；默认关。见 EAP_RUNTIME_MEMORY */
     sessionMemory?: import('../session/apply-session-memory.js').SessionMemoryOptions;
+    /** 未注入时不启动整图超时（测试桩） */
+    timeoutManager?: TaskTimeoutManager;
 }
 /** 一次对话详情：消息 + 每步 LLM 入参/响应。File / 内存 / Postgres 同一套结构。 */
 export interface ConversationDetail {

package/dist/runtime/agent-runtime.js

@@ -7,6 +7,9 @@
  * @see 04-runtime-core/design.md §1.5 / §1.7
  */
 import { randomUUID } from 'node:crypto';
+import { DEFAULT_GRAPH_TIMEOUT_MS } from '../common/types.js';
+import { resolveTaskTimeoutMs } from '../task/resolve-task-timeout.js';
+import { runWithExecutionTrace } from '../graph/execution-trace-context.js';
 import { HITL_TIMEOUT_ERROR_CODE, HITL_TIMEOUT_MESSAGE, HitlAlreadyTimedOutError, HitlNotWaitingError, buildHitlWaitedPayload, isHitlDeadlinePassed, loadHitlCheckpoint, readPersistedHitlWaiting, unwrapHitlPaused, } from '../graph/hitl/hitl-handler.js';
 import { resolveAgentSystemPromptFromLoader } from '../registry/graph-loader.js';
 import { toLoadedSkillMap } from '../tool/system-prompt-builder.js';
@@ -37,7 +40,7 @@ const DEFAULT_GRAPH_DSL = {
         { from: '__start__', to: 'llm' },
         { from: 'llm', to: '__end__' },
     ],
-    config: { timeout: 60000 },
+    config: { timeout: DEFAULT_GRAPH_TIMEOUT_MS },
 };
 /**
  * AgentRuntime — 管理 Graph 执行的 SDK 门面
@@ -214,6 +217,14 @@ export class AgentRuntime {
             ragScope: params.ragScope,
             ragSources: params.ragSources,
         }, userId);
+        if (response.code !== 'ok') {
+            const output = typeof response.data?.output === 'string' && response.data.output
+                ? response.data.output
+                : response.code;
+            throw new AppError(response.code, output, {
+                exposeMessage: true,
+            });
+        }
         return response.data;
     }
     /**
@@ -241,6 +252,11 @@ export class AgentRuntime {
                 userId,
             });
         }
+        const loadOpts = { agentVersion: params.agentVersion };
+        const graphDsl = this.deps.graphLoader
+            ? await this.deps.graphLoader.loadGraph(agentCode, loadOpts)
+            : DEFAULT_GRAPH_DSL;
+        const timeout = resolveTaskTimeoutMs(params.config?.timeout, graphDsl.config?.timeout);
         const task = await this.deps.taskService.create({
             id: params.taskId,
             agentId: agentCode,
@@ -248,9 +264,12 @@ export class AgentRuntime {
             userId,
             correlationId,
             input: params.input,
-            timeout: params.config?.timeout ?? 60_000,
+            timeout,
         });
         await this.deps.taskService.updateStatus(task.id, 'running');
+        const abortSignal = this.deps.timeoutManager?.startTimer(task.id, timeout, async () => {
+            await this.deps.taskService.tryUpdateStatus(task.id, 'running', 'timeout', 'Task execution timed out');
+        });
         await persistUserTurnMessage(this.deps.messageService, {
             sessionId,
             taskId: task.id,
@@ -258,10 +277,6 @@ export class AgentRuntime {
             content: params.input,
         });
         yield this.toSSE('task.started', correlationId, task.id, { taskId: task.id, sessionId });
-        const loadOpts = { agentVersion: params.agentVersion };
-        const graphDsl = this.deps.graphLoader
-            ? await this.deps.graphLoader.loadGraph(agentCode, loadOpts)
-            : DEFAULT_GRAPH_DSL;
         const graph = await this.deps.graphEngine.buildGraph(graphDsl);
         const loadedToolsBase = await this.resolveLoadedTools(agentCode, params.agentVersion);
         const loadedSkills = this.deps.graphLoader
@@ -321,7 +336,7 @@ export class AgentRuntime {
         const toolResults = [];
         const nodeTokenUsages = [];
         try {
-            for await (const runtimeEvent of this.deps.graphEngine.stream(graph, {
+            for await (const runtimeEvent of runWithExecutionTrace({ abortSignal }, () => this.deps.graphEngine.stream(graph, {
                 messages,
                 userId,
                 delegationToken: ctx.delegationToken,
@@ -343,7 +358,9 @@ export class AgentRuntime {
                 skillInput: resolveSkillInputFromInvokeInput(params.input),
                 traceId: resolveTraceId(params),
                 traceCollector: this.deps.traceCollector,
-            })) {
+                abortSignal,
+                abortDeadlineMs: Date.now() + timeout,
+            }))) {
                 if (runtimeEvent.type === 'tool.called') {
                     const p = runtimeEvent.payload;
                     if (p.toolCallId && p.toolName) {
@@ -415,6 +432,17 @@ export class AgentRuntime {
                 yield this.toSSE('hitl.waited', correlationId, task.id, buildHitlWaitedPayload(hitlPaused));
                 return;
             }
+            const timedOut = err instanceof Error && /timed out/i.test(err.message);
+            if (timedOut) {
+                await recordTaskTokenUsages(this.deps.taskService, task.id, nodeTokenUsages);
+                await this.deps.taskService.tryUpdateStatus(task.id, 'running', 'timeout');
+                yield this.toSSE('task.error', correlationId, task.id, {
+                    code: ErrorCodes.TASK_TIMEOUT,
+                    message: 'Task execution timed out',
+                    recoverable: false,
+                });
+                return;
+            }
             const message = err instanceof Error ? err.message : 'Unknown error';
             await recordTaskTokenUsages(this.deps.taskService, task.id, nodeTokenUsages);
             await this.deps.taskService.updateStatus(task.id, 'failed', message);
@@ -425,6 +453,9 @@ export class AgentRuntime {
             });
             throw err;
         }
+        finally {
+            this.deps.timeoutManager?.clearTimer(task.id);
+        }
     }
     /**
      * HITL 用户响应后继续执行（同步结果）。
@@ -483,6 +514,9 @@ export class AgentRuntime {
         if (!claimed) {
             throw new AppError(ErrorCodes.TASK_HITL_INVALID_STATE, `Task ${taskId} is no longer waiting for HITL`, { exposeMessage: true });
         }
+        const abortSignal = this.deps.timeoutManager?.startTimer(taskId, resolveTaskTimeoutMs(task.timeout), async () => {
+            await this.deps.taskService.tryUpdateStatus(taskId, 'running', 'timeout', 'Task execution timed out');
+        });
         const tokenDetail = resolveTokenDetail(response.tokenDetail);
         yield this.toSSE('hitl.resumed', correlationId, taskId, {
             choice: response.choice,
@@ -507,6 +541,8 @@ export class AgentRuntime {
             : await this.resolveLoadedSkills(agentCode, response.userId, agentVersion);
         const continueState = {
             ...resumedState,
+            abortSignal,
+            abortDeadlineMs: Date.now() + resolveTaskTimeoutMs(task.timeout),
             messages: resumedState.messages ?? [],
             replaceCheckpointMessages: true,
             sessionId: resumedState.sessionId ?? sessionId,
@@ -542,7 +578,7 @@ export class AgentRuntime {
         const toolResults = [];
         const nodeTokenUsages = [];
         try {
-            for await (const runtimeEvent of this.deps.graphEngine.stream(graph, continueState)) {
+            for await (const runtimeEvent of runWithExecutionTrace({ abortSignal, abortDeadlineMs: continueState.abortDeadlineMs }, () => this.deps.graphEngine.stream(graph, continueState))) {
                 if (runtimeEvent.type === 'tool.called') {
                     const p = runtimeEvent.payload;
                     if (p.toolCallId && p.toolName) {
@@ -617,6 +653,17 @@ export class AgentRuntime {
                 yield this.toSSE('hitl.waited', correlationId, taskId, buildHitlWaitedPayload(hitlPaused));
                 return;
             }
+            const timedOut = err instanceof Error && /timed out/i.test(err.message);
+            if (timedOut) {
+                await recordTaskTokenUsages(this.deps.taskService, taskId, nodeTokenUsages);
+                await this.deps.taskService.tryUpdateStatus(taskId, 'running', 'timeout');
+                yield this.toSSE('task.error', correlationId, taskId, {
+                    code: ErrorCodes.TASK_TIMEOUT,
+                    message: 'Task execution timed out',
+                    recoverable: false,
+                });
+                return;
+            }
             const appErr = err instanceof AppError ? err : AppError.fromUnknown(err);
             const failMsg = appErr.exposeMessage ? appErr.message : '系统内部错误';
             await recordTaskTokenUsages(this.deps.taskService, taskId, nodeTokenUsages);
@@ -628,6 +675,9 @@ export class AgentRuntime {
             });
             throw err instanceof AppError ? err : appErr;
         }
+        finally {
+            this.deps.timeoutManager?.clearTimer(taskId);
+        }
     }
     /**
      * 从 Checkpoint Fork 并真实重新执行。
@@ -658,6 +708,12 @@ export class AgentRuntime {
         const newThreadId = randomUUID();
         const forkedCheckpoint = await this.deps.checkpointSaver.fork(checkpointId, newThreadId, overrides);
         const correlationId = overrides.executionContext?.correlationId ?? randomUUID();
+        const agentVersion = overrides.agentVersion ??
+            (typeof source.state.agentVersion === 'string' ? source.state.agentVersion : undefined);
+        const graphDsl = this.deps.graphLoader && typeof this.deps.graphLoader.loadGraph === 'function'
+            ? await this.deps.graphLoader.loadGraph(agentCode, { agentVersion })
+            : DEFAULT_GRAPH_DSL;
+        const timeout = resolveTaskTimeoutMs(undefined, graphDsl.config?.timeout);
         const task = await this.deps.taskService.create({
             id: taskId,
             agentId: agentCode,
@@ -665,12 +721,13 @@ export class AgentRuntime {
             userId,
             correlationId,
             input: { forkFrom: checkpointId, overrides },
-            timeout: 600_000,
+            timeout,
         });
         await this.deps.taskService.updateStatus(task.id, 'running');
-        const agentVersion = overrides.agentVersion ??
-            (typeof source.state.agentVersion === 'string' ? source.state.agentVersion : undefined);
-        const graph = await this.rebuildExecutableGraph(agentCode, agentVersion);
+        const abortSignal = this.deps.timeoutManager?.startTimer(task.id, timeout, async () => {
+            await this.deps.taskService.tryUpdateStatus(task.id, 'running', 'timeout', 'Task execution timed out');
+        });
+        const graph = await this.deps.graphEngine.buildGraph(graphDsl);
         const loadedToolsBase = await this.resolveLoadedTools(agentCode, agentVersion);
         const skillBundle = await this.resolveLoadedSkills(agentCode, userId, agentVersion);
         const loadedTools = assembleLoadedTools(loadedToolsBase);
@@ -681,11 +738,12 @@ export class AgentRuntime {
         const agentSystemPrompt = (await resolveAgentSystemPromptFromLoader(this.deps.graphLoader, agentCode, agentVersion)) ?? (typeof forkedCheckpoint.state.agentSystemPrompt === 'string'
             ? forkedCheckpoint.state.agentSystemPrompt
             : undefined);
+        const abortDeadlineMs = Date.now() + timeout;
         try {
             const forkState = { ...forkedCheckpoint.state };
             delete forkState.toolSpanId;
             delete forkState.hitlToolCallId;
-            const result = await this.deps.graphEngine.invoke(graph, {
+            const result = await runWithExecutionTrace({ abortSignal, abortDeadlineMs }, () => this.deps.graphEngine.invoke(graph, {
                 messages: Array.isArray(forkState.messages)
                     ? forkState.messages
                     : [],
@@ -701,7 +759,9 @@ export class AgentRuntime {
                 taskId: task.id,
                 traceId,
                 traceCollector: this.deps.traceCollector,
-            });
+                abortSignal,
+                abortDeadlineMs,
+            }));
             if (result.tokenUsage.perNode && result.tokenUsage.perNode.length > 0) {
                 await recordTaskTokenUsages(this.deps.taskService, task.id, result.tokenUsage.perNode);
             }
@@ -760,6 +820,23 @@ export class AgentRuntime {
             await recordTaskTokenUsages(this.deps.taskService, task.id, usages);
             const input_tokens = usages.reduce((sum, row) => sum + row.inputTokens, 0);
             const output_tokens = usages.reduce((sum, row) => sum + row.outputTokens, 0);
+            const timedOut = err instanceof Error && /timed out/i.test(err.message);
+            if (timedOut) {
+                await this.deps.taskService.tryUpdateStatus(task.id, 'running', 'timeout');
+                return {
+                    newTraceId: traceId,
+                    originalTraceId,
+                    newTaskId: task.id,
+                    checkpointId,
+                    status: 'timeout',
+                    output: message,
+                    tokenUsage: {
+                        input_tokens,
+                        output_tokens,
+                        total_tokens: input_tokens + output_tokens,
+                    },
+                };
+            }
             await this.deps.taskService.updateStatus(task.id, 'failed', message);
             return {
                 newTraceId: traceId,
@@ -775,6 +852,9 @@ export class AgentRuntime {
                 },
             };
         }
+        finally {
+            this.deps.timeoutManager?.clearTimer(task.id);
+        }
     }
     async prepareHitlResume(taskId, response) {
         const task = await this.deps.taskService.getTask(taskId);

package/dist/runtime/dev-runtime.js

@@ -31,7 +31,7 @@ import { createToolExecutor } from '../tool/create-tool-executor.js';
 import { DevToolExecutor } from '../tool/dev-tool-executor.js';
 import { captureOverlayJailOptions, withHarnessPrimitives } from '../tool/harness-primitives.js';
 import { AllowAllGovernanceClient, HttpGovernanceClient, } from '../governance/index.js';
-import { InvokeOrchestrator, StreamOrchestrator, SessionService, MessageService, SessionContextService, TaskService, LangGraphAdapter, HitlHandler, TokenBudgetService, TokenStatsService, TokenBudgetGuard, SessionBudgetChecker, createAgentRegistryClient, GraphLoader, } from '../index.js';
+import { InvokeOrchestrator, StreamOrchestrator, SessionService, MessageService, SessionContextService, TaskService, TaskTimeoutManager, LangGraphAdapter, HitlHandler, TokenBudgetService, TokenStatsService, TokenBudgetGuard, SessionBudgetChecker, createAgentRegistryClient, GraphLoader, } from '../index.js';
 import { createAgentRuntime } from './agent-runtime.js';
 import { assembleRuntimeStorage } from './storage-profile.js';
 import { createDevRagNodeDeps } from './dev-rag-deps.js';
@@ -139,6 +139,7 @@ export function createDevRuntime(options) {
     const sessionContextService = new SessionContextService(sessionService, messageService);
     // ── Task / Token ──
     const taskService = new TaskService();
+    const timeoutManager = new TaskTimeoutManager();
     const budgetService = new TokenBudgetService(storage.tokenBudgetRepository);
     const tokenStatsService = new TokenStatsService();
     const tokenBudgetGuard = new TokenBudgetGuard(budgetService);
@@ -202,6 +203,7 @@ export function createDevRuntime(options) {
         checkpointSaver: storage.checkpointSaver,
         sessionCompression,
         sessionMemory,
+        timeoutManager,
     });
     const streamOrchestrator = new StreamOrchestrator({
         sessionContextService,
@@ -215,6 +217,7 @@ export function createDevRuntime(options) {
         checkpointSaver: storage.checkpointSaver,
         sessionCompression,
         sessionMemory,
+        timeoutManager,
     });
     const agentRuntime = createAgentRuntime({
         invokeOrchestrator,
@@ -229,6 +232,7 @@ export function createDevRuntime(options) {
         turnLog,
         sessionCompression,
         sessionMemory,
+        timeoutManager,
     });
     return {
         invokeOrchestrator,
@@ -243,7 +247,10 @@ export function createDevRuntime(options) {
         taskService,
         tokenStatsService,
         graphLoader,
-        dispose: stopSkillWatch,
+        dispose: () => {
+            stopSkillWatch();
+            timeoutManager.dispose();
+        },
         diagnostics: {
             packageVersion: RUNTIME_PACKAGE_VERSION,
             deploymentContext,

package/dist/runtime/types.d.ts

@@ -78,7 +78,7 @@ export interface ForkResult {
     originalTraceId: string;
     newTaskId: string;
     checkpointId: string;
-    status: 'completed' | 'failed';
+    status: 'completed' | 'failed' | 'timeout';
     output: unknown;
     tokenUsage: {
         input_tokens: number;

package/dist/sse/events/response-events.d.ts

@@ -5,7 +5,7 @@
  * - response.final
  *
  * 可选事件：
- * - response.max_iterations_reached
+ * - response.max_iterations_reached（契约保留；调度步上限走 task.error / runtime.graph.max_iterations，不发本事件）
  *
  * @see design.md §1.6 SSE事件协议定义
  */
@@ -16,7 +16,7 @@ export interface ResponseFinalPayload {
     /** 回复格式（如 text, markdown, json） */
     format: string;
 }
-/** 达到最大迭代次数 */
+/** 契约保留。整图调度步上限不发此事件。 */
 export interface ResponseMaxIterationsReachedPayload {
     /** 最大迭代次数 */
     maxIterations: number;

package/dist/sse/events/response-events.js

@@ -5,7 +5,7 @@
  * - response.final
  *
  * 可选事件：
- * - response.max_iterations_reached
+ * - response.max_iterations_reached（契约保留；调度步上限走 task.error / runtime.graph.max_iterations，不发本事件）
  *
  * @see design.md §1.6 SSE事件协议定义
  */

package/dist/task/contracts/task-manager.contract.d.ts

@@ -46,6 +46,8 @@ export interface TaskRecord {
     correlationId: string;
     /** 用户输入 */
     input: unknown;
+    /** 整图超时（毫秒）。未写入旧记录时 resume 用平台缺省 */
+    timeout?: number;
     /** 执行输出 */
     output: unknown | null;
     /** 当前状态 */

package/dist/task/index.d.ts

@@ -3,5 +3,6 @@ export { TaskService, InMemoryTaskRepository } from './task.service.js';
 export type { ITaskRepository } from './task.service.js';
 export { TaskTimeoutManager } from './task-timeout.js';
 export type { TaskTimeoutManagerOptions } from './task-timeout.js';
+export { resolveTaskTimeoutMs } from './resolve-task-timeout.js';
 export { TaskProgressTracker } from './task-progress-tracker.js';
 export type { TaskProgressInfo } from './task-progress-tracker.js';

package/dist/task/index.js

@@ -2,4 +2,5 @@
 export * from './contracts/index.js';
 export { TaskService, InMemoryTaskRepository } from './task.service.js';
 export { TaskTimeoutManager } from './task-timeout.js';
+export { resolveTaskTimeoutMs } from './resolve-task-timeout.js';
 export { TaskProgressTracker } from './task-progress-tracker.js';

package/dist/task/resolve-task-timeout.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 整图超时：请求 config.timeout，否则图 config.timeout，否则平台缺省 1200000 毫秒（20 分钟）。
+ * 官方模板图上不写 timeout，用平台缺省。LLM HTTP 超时、HITL 等待另算。
+ */
+/** 请求显式值优先，否则图配置，否则 {@link DEFAULT_GRAPH_TIMEOUT_MS}。 */
+export declare function resolveTaskTimeoutMs(requestTimeout?: number, graphTimeout?: number): number;

package/dist/task/resolve-task-timeout.js

@@ -0,0 +1,16 @@
+/**
+ * 整图超时：请求 config.timeout，否则图 config.timeout，否则平台缺省 1200000 毫秒（20 分钟）。
+ * 官方模板图上不写 timeout，用平台缺省。LLM HTTP 超时、HITL 等待另算。
+ */
+import { DEFAULT_GRAPH_TIMEOUT_MS } from '../common/types.js';
+function positiveMs(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0)
+        return undefined;
+    return Math.trunc(value);
+}
+/** 请求显式值优先，否则图配置，否则 {@link DEFAULT_GRAPH_TIMEOUT_MS}。 */
+export function resolveTaskTimeoutMs(requestTimeout, graphTimeout) {
+    return (positiveMs(requestTimeout) ??
+        positiveMs(graphTimeout) ??
+        DEFAULT_GRAPH_TIMEOUT_MS);
+}

package/dist/task/task-timeout.d.ts

@@ -13,7 +13,7 @@
  * TaskTimeoutManager 配置选项
  */
 export interface TaskTimeoutManagerOptions {
-    /** 默认超时时间（毫秒），默认 60000 (60s) */
+    /** 默认超时时间（毫秒），默认 {@link DEFAULT_GRAPH_TIMEOUT_MS} */
     defaultTimeoutMs?: number;
 }
 /**