@gt-fe/eap-runtime 0.0.33 → 0.0.34

package/dist/api/handlers/invoke.handler.d.ts

@@ -81,7 +81,6 @@ export declare class InvokeOrchestrator {
     execute(req: InvokeRequest, userId: string): Promise<InvokeResponse>;
     private buildResponse;
     private buildErrorResponse;
-    private isTimeoutError;
     private persistInvokeUsages;
 }
 /** @deprecated 请直接从 `graph/hitl/hitl-handler` 导入；此处保留 re-export 兼容旧测试引用 */

package/dist/api/handlers/invoke.handler.js

@@ -26,6 +26,7 @@ import { AppError, ErrorCodes } from '@gt-fe/eap-contracts';
 import { classifyRuntimeError } from '../../utils/http-error.js';
 import { DEFAULT_GRAPH_TIMEOUT_MS } from '../../common/types.js';
 import { resolveTaskTimeoutMs } from '../../task/resolve-task-timeout.js';
+import { taskAbortKindOf } from '../../task/task-abort.js';
 import { runWithExecutionTrace } from '../../graph/execution-trace-context.js';
 import { resolveAgentDisplayNameFromLoader, resolveAgentSystemPromptFromLoader, } from '../../registry/graph-loader.js';
 import { toLoadedToolMap } from '../../tool/loaded-tool-definition.js';
@@ -313,8 +314,8 @@ export class InvokeOrchestrator {
                     status: 'token_exhausted',
                 });
             }
-            // ─── 错误处理：Timeout ───
-            if (this.isTimeoutError(error)) {
+            const abortKind = taskAbortKindOf(error, abortSignal);
+            if (abortKind === 'timeout') {
                 await this.taskService.tryUpdateStatus(task.id, 'running', 'timeout');
                 return this.buildResponse(traceId, {
                     taskId: task.id,
@@ -325,6 +326,25 @@ export class InvokeOrchestrator {
                     status: 'timeout',
                 });
             }
+            if (abortKind === 'cancelled') {
+                const moved = await this.taskService.tryUpdateStatus(task.id, 'running', 'cancelled');
+                if (!moved) {
+                    await this.taskService.tryUpdateStatus(task.id, 'waiting_hitl', 'cancelled');
+                }
+                // @gt-fe/eap-contracts 的 InvokeStatus 还没有 cancelled。这次不改包，响应体仍写 cancelled。
+                return {
+                    code: 'runtime.task.cancelled',
+                    data: {
+                        taskId: task.id,
+                        sessionId,
+                        output: 'Task cancelled',
+                        tokenUsage,
+                        duration: Date.now() - startTime,
+                        status: 'cancelled',
+                    },
+                    traceId,
+                };
+            }
             // ─── 错误处理：通用错误 ───
             const classified = classifyRuntimeError(error);
             const fuse = classified.code === ErrorCodes.GRAPH_MAX_ITERATIONS ? classified : undefined;
@@ -432,9 +452,6 @@ export class InvokeOrchestrator {
         }
         return { code: 'runtime.graph.execution_error', data, traceId };
     }
-    isTimeoutError(error) {
-        return error instanceof Error && /timed out/i.test(error.message);
-    }
     async persistInvokeUsages(taskId, sessionId) {
         if (!this.checkpointSaver)
             return [];

package/dist/api/handlers/stream.handler.d.ts

@@ -98,5 +98,4 @@ export declare class StreamOrchestrator {
      * 发射错误事件并关闭连接
      */
     private emitErrorAndClose;
-    private isTimeoutError;
 }

package/dist/api/handlers/stream.handler.js

@@ -19,7 +19,7 @@
  * @see design.md §1.5 /stream 内部执行逻辑
  * @see requirements.md Requirement 11 AC2
  */
-import { buildHitlWaitingTaskOutput, buildTurnTranscriptFromStreamEvents, loadModelFacingHistory, turnGraphMessagesAfterCompression, extractStreamReasoning, applyStreamTextDelta, createStreamAssistantBuckets, visibleStreamAssistantText, streamAssistantTexts, messageRecordsToGraphMessages, persistHitlWaitingPlaceholder, persistTurnTranscript, persistUserTurnMessage, appendTerminalToolResult, } from '../../session/persist-turn-messages.js';
+import { buildHitlWaitingTaskOutput, buildTurnTranscriptFromStreamEvents, loadModelFacingHistory, turnGraphMessagesAfterCompression, applyStreamReasoningEvent, applyStreamTextDelta, createStreamAssistantBuckets, createStreamReasoningState, resolvedStreamReasoning, visibleStreamAssistantText, streamAssistantTexts, messageRecordsToGraphMessages, persistHitlWaitingPlaceholder, persistTurnTranscript, persistUserTurnMessage, appendTerminalToolResult, } from '../../session/persist-turn-messages.js';
 import { collectPublicArtifactLinks, collectPublicArtifactLinksFromEvent, injectPublicArtifactLinks, mergeArtifactLinks, } from '../../tool/inject-public-artifact-links.js';
 import { SessionBudgetExhaustedError } from '../../token/session-budget-checker.js';
 import { TokenBudgetExhaustedError } from '../../token/token-budget-guard.js';
@@ -42,6 +42,7 @@ import { buildHitlWaitedPayload } from '../../graph/hitl/hitl-handler.js';
 import { resolveTraceId } from '../../common/trace-id.js';
 import { DEFAULT_GRAPH_TIMEOUT_MS } from '../../common/types.js';
 import { resolveTaskTimeoutMs } from '../../task/resolve-task-timeout.js';
+import { taskAbortKindOf } from '../../task/task-abort.js';
 import { runWithExecutionTrace } from '../../graph/execution-trace-context.js';
 // ─────────────────────────────────────────────
 // Placeholder Graph DSL (Agent Registry 接入前)
@@ -266,8 +267,8 @@ export class StreamOrchestrator {
         });
         const skillInput = resolveSkillInputFromInvokeInput(req.input);
         const assistantBuckets = createStreamAssistantBuckets();
+        const reasoningState = createStreamReasoningState();
         let toolCallReasoningContent;
-        let assistantReasoningContent;
         const pendingToolCalls = [];
         const toolResults = [];
         const artifactLinks = [];
@@ -325,15 +326,11 @@ export class StreamOrchestrator {
                             arguments: p.arguments ?? {},
                         });
                     }
-                    if (typeof p.reasoningContent === 'string' && p.reasoningContent) {
-                        toolCallReasoningContent = p.reasoningContent;
-                    }
+                    toolCallReasoningContent = resolvedStreamReasoning(reasoningState);
                 }
                 appendTerminalToolResult(runtimeEvent.type, runtimeEvent.payload, toolResults);
                 collectPublicArtifactLinksFromEvent(runtimeEvent.type, runtimeEvent.payload, artifactLinks);
-                const streamedReasoning = extractStreamReasoning(runtimeEvent.type, runtimeEvent.payload);
-                if (streamedReasoning)
-                    assistantReasoningContent = streamedReasoning;
+                applyStreamReasoningEvent(reasoningState, runtimeEvent.type, runtimeEvent.payload);
                 applyStreamTextDelta(assistantBuckets, runtimeEvent.type, runtimeEvent.payload);
                 if (shouldEmitTokenSse(tokenDetail, runtimeEvent.type)) {
                     emitter.emit(this.runtimeEventToSSE(runtimeEvent, correlationId, taskId));
@@ -369,13 +366,21 @@ export class StreamOrchestrator {
                 this.emitErrorAndClose(emitter, correlationId, taskId, error);
                 return;
             }
-            // ─── 错误处理：Timeout ───
-            if (this.isTimeoutError(error)) {
+            const abortKind = taskAbortKindOf(error, abortSignal);
+            if (abortKind === 'timeout' || abortKind === 'cancelled') {
                 await recordTaskTokenUsages(this.taskService, taskId, this.tokenStatsService.list(taskId));
-                await this.taskService.tryUpdateStatus(taskId, 'running', 'timeout');
+                if (abortKind === 'timeout') {
+                    await this.taskService.tryUpdateStatus(taskId, 'running', 'timeout');
+                }
+                else {
+                    const moved = await this.taskService.tryUpdateStatus(taskId, 'running', 'cancelled');
+                    if (!moved) {
+                        await this.taskService.tryUpdateStatus(taskId, 'waiting_hitl', 'cancelled');
+                    }
+                }
                 emitter.emit(this.buildSSEEvent('task.error', correlationId, taskId, {
-                    code: ErrorCodes.TASK_TIMEOUT,
-                    message: 'Task execution timed out',
+                    code: abortKind === 'timeout' ? ErrorCodes.TASK_TIMEOUT : 'runtime.task.cancelled',
+                    message: abortKind === 'timeout' ? 'Task execution timed out' : 'Task cancelled',
                     recoverable: false,
                 }));
                 emitter.close();
@@ -441,7 +446,7 @@ export class StreamOrchestrator {
                 assistantText: injected,
                 finishPoints: graph.finishPoints,
                 toolCallReasoningContent,
-                assistantReasoningContent,
+                assistantReasoningContent: resolvedStreamReasoning(reasoningState),
             }),
             assistantTokenCount: tokenStats.total.output ?? 0,
             assistantDurationMs: duration,
@@ -489,7 +494,4 @@ export class StreamOrchestrator {
         }));
         emitter.close();
     }
-    isTimeoutError(error) {
-        return error instanceof Error && /timed out/i.test(error.message);
-    }
 }

package/dist/common/types.d.ts

@@ -58,11 +58,12 @@ export interface RuntimeRunContext {
 /**
  * Task 执行状态（Runtime 内部使用）
  *
- * 状态流转：pending → running → success | failed | timeout | token_exhausted | waiting_hitl
+ * 状态流转：pending → running → success | failed | timeout | token_exhausted | cancelled | waiting_hitl
  *
- * waiting_hitl：等待人工介入确认，可通过 HITL API 恢复为 running
+ * waiting_hitl：等待人工介入确认，可通过 HITL API 恢复为 running。
+ * cancelled：调用方停止这一轮（Hosting `POST /tasks/:id/cancel`），不是超时。
  */
-export type TaskStatus = 'pending' | 'running' | 'waiting_hitl' | 'success' | 'failed' | 'timeout' | 'token_exhausted';
+export type TaskStatus = 'pending' | 'running' | 'waiting_hitl' | 'success' | 'failed' | 'timeout' | 'token_exhausted' | 'cancelled';
 /**
  * Runtime 执行上下文绑定状态（非平台 Session 生命周期）
  *

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

@@ -23,7 +23,7 @@ import { ToolResultInjector } from '../../tool/tool-result-injector.js';
 import { fileArtifactFromToolOutput } from '../../tool/file-artifact.js';
 import { EchoLLMProvider } from '../../providers/echo-llm-provider.js';
 import { ConditionEvaluator } from '../condition-evaluator.js';
-import { SystemPromptBuilder, buildSkillCatalog, buildToolCatalog, loadedToolsToApiTools, resolveLlmPromptInputs, spokenName } from '../../tool/system-prompt-builder.js';
+import { SystemPromptBuilder, buildSkillCatalog, loadedToolsToApiTools, resolveLlmPromptInputs, spokenName } from '../../tool/system-prompt-builder.js';
 import { resolveJailFromState, resolveJailRoots } from '../../tool/harness-primitives.js';
 import os from 'node:os';
 import { bindSelectedSkill } from '../nodes/skill-bind-node.js';
@@ -39,6 +39,81 @@ import { recordSkillEntrySpan, skillEntryInvocationFromTool } from './skill-entr
 import { llmSpanInput, llmSpanOutputFromResult, withGraphSpan } from '../trace-span.js';
 import { executionTraceFromState, getExecutionStream, getExecutionTrace, runWithExecutionTrace, } from '../execution-trace-context.js';
 import { isRetryableToolFailure, resolveToolRetryConfig, sleepToolRetry, toolRetryDelayMs, } from '../../tool/tool-retry.js';
+function emitReasoningStartedIfNeeded(live, model, timestamp) {
+    if (live.reasoningStartedThisTurn)
+        return;
+    live.reasoningStartedThisTurn = true;
+    live.iteration += 1;
+    live.sink({
+        type: 'reasoning.started',
+        taskId: undefined,
+        correlationId: undefined,
+        timestamp,
+        payload: {
+            iterationCount: live.iteration,
+            model,
+        },
+    });
+}
+function nodeGraphExtra(live, nodeId) {
+    return {
+        node: nodeId,
+        ...(live.graphId ? { graphId: live.graphId } : {}),
+    };
+}
+function emitLlmStreamDelta(live, nodeId, model, delta) {
+    const timestamp = new Date().toISOString();
+    const extra = nodeGraphExtra(live, nodeId);
+    if (delta.reasoningContent) {
+        emitReasoningStartedIfNeeded(live, model, timestamp);
+        live.sink({
+            type: 'reasoning.chunk',
+            taskId: undefined,
+            correlationId: undefined,
+            timestamp,
+            payload: {
+                content: delta.reasoningContent,
+                index: live.reasoningChunkIndex++,
+                ...extra,
+            },
+        });
+    }
+    if (delta.content) {
+        emitReasoningStartedIfNeeded(live, model, timestamp);
+        live.streamedTextThisTurn = true;
+        live.sink({
+            type: 'response.chunk',
+            taskId: undefined,
+            correlationId: undefined,
+            timestamp,
+            payload: {
+                content: delta.content,
+                index: live.chunkIndex++,
+                ...extra,
+            },
+        });
+    }
+}
+function emitReasoningCompletedIfAny(live, nodeId, next) {
+    if (!live)
+        return;
+    const added = Array.isArray(next.messages) ? next.messages[0] : undefined;
+    const reasoning = added && typeof added === 'object' && typeof added.reasoningContent === 'string'
+        ? added.reasoningContent
+        : '';
+    if (!reasoning)
+        return;
+    live.sink({
+        type: 'reasoning.completed',
+        taskId: undefined,
+        correlationId: undefined,
+        timestamp: new Date().toISOString(),
+        payload: {
+            content: reasoning,
+            ...nodeGraphExtra(live, nodeId),
+        },
+    });
+}
 /**
  * 传给 LangGraph 的 `recursionLimit`：一轮调度（superstep）+1。
  * 同一步里并行的多个节点只 +1。ReAct 的 llm 再 tool 大约 +2。
@@ -596,15 +671,25 @@ export class LangGraphAdapter {
             sink: enqueue,
             eventContext: { taskId: state.taskId, correlationId: state.correlationId },
             chunkIndex: 0,
+            reasoningChunkIndex: 0,
             iteration: 0,
             reasoningStartedThisTurn: false,
             streamedTextThisTurn: false,
+            graphId: graph.id,
         };
         const traceCtx = executionTraceFromState(state);
         const graphSignal = graphAbortSignal(state);
+        let graphIterator;
+        const stopGraphIterator = () => {
+            const iterator = graphIterator;
+            if (!iterator?.return)
+                return;
+            void iterator.return().catch(() => undefined);
+        };
         const onGraphAbort = () => {
             failure = graphSignal ? abortReason(graphSignal) : new Error('aborted');
             finished = true;
+            stopGraphIterator();
             signal();
         };
         graphSignal?.addEventListener('abort', onGraphAbort, { once: true });
@@ -619,9 +704,19 @@ export class LangGraphAdapter {
                 const streamIterator = await withGraphAbort(Promise.resolve(ref.compiled.stream(input, langGraphRunOptions({
                     configurable: this.checkpointConfigurable(state, graph),
                     streamMode: 'updates',
+                    ...(graphSignal ? { signal: graphSignal } : {}),
                 }))), graphSignal);
-                for await (const update of streamIterator) {
-                    for (const event of this.convertUpdatesToEvents(update, graph.id, () => streamBag.chunkIndex++, ref.silentNodeIds, ref.subgraphNodeIds)) {
+                const iterator = streamIterator[Symbol.asyncIterator]();
+                graphIterator = iterator;
+                while (true) {
+                    if (graphSignal?.aborted) {
+                        failure = failure ?? abortReason(graphSignal);
+                        break;
+                    }
+                    const next = await iterator.next();
+                    if (next.done)
+                        break;
+                    for (const event of this.convertUpdatesToEvents(next.value, graph.id, () => streamBag.chunkIndex++, ref.silentNodeIds, ref.subgraphNodeIds)) {
                         enqueue(event);
                     }
                 }
@@ -667,6 +762,7 @@ export class LangGraphAdapter {
                 abortDeadlineMs,
             }, () => ref.compiled.invoke(input, langGraphRunOptions({
                 configurable: this.checkpointConfigurable(state, graph),
+                ...(abortSignal ? { signal: abortSignal } : {}),
             }))), abortSignal);
         }
         catch (error) {
@@ -1082,7 +1178,6 @@ export class LangGraphAdapter {
                 console.log(`[LLM-DEBUG] node=${node.id} loadedTools=${toolNames.length}:`, toolNames);
             }
             const catalog = includeSkillCatalog ? buildSkillCatalog(skillDefs) : undefined;
-            const toolCatalog = disableTools ? undefined : buildToolCatalog(loadedTools);
             const jail = resolveJailFromState({
                 agentDir: state['agentDir'],
                 userId,
@@ -1111,7 +1206,6 @@ export class LangGraphAdapter {
                 agentPrompt: promptInputs.agentPrompt,
                 nodePrompt: promptInputs.nodePrompt,
                 skillCatalog: catalog,
-                toolCatalog,
                 agentName,
                 agentCode,
                 userId,
@@ -1141,39 +1235,14 @@ export class LangGraphAdapter {
             if (stream) {
                 stream.reasoningStartedThisTurn = false;
                 stream.streamedTextThisTurn = false;
+                stream.reasoningChunkIndex = 0;
             }
             const llmNode = new LLMNode(node.id, finalConfig, this.llmProvider, enableStream, enableStream
-                ? (text) => {
+                ? (delta) => {
                     const live = getExecutionStream();
-                    if (!live || !text)
+                    if (!live)
                         return;
-                    const timestamp = new Date().toISOString();
-                    if (!live.reasoningStartedThisTurn) {
-                        live.reasoningStartedThisTurn = true;
-                        live.iteration += 1;
-                        live.sink({
-                            type: 'reasoning.started',
-                            taskId: undefined,
-                            correlationId: undefined,
-                            timestamp,
-                            payload: {
-                                iterationCount: live.iteration,
-                                model: finalConfig.model,
-                            },
-                        });
-                    }
-                    live.streamedTextThisTurn = true;
-                    live.sink({
-                        type: 'response.chunk',
-                        taskId: undefined,
-                        correlationId: undefined,
-                        timestamp,
-                        payload: {
-                            content: text,
-                            index: live.chunkIndex++,
-                            node: node.id,
-                        },
-                    });
+                    emitLlmStreamDelta(live, node.id, finalConfig.model, delta);
                 }
                 : undefined, this.interceptors);
             const toolsForSpan = disableTools || !loadedTools
@@ -1197,6 +1266,9 @@ export class LangGraphAdapter {
                 },
             }, async () => {
                 const next = await llmNode.execute(state);
+                if (enableStream) {
+                    emitReasoningCompletedIfAny(getExecutionStream(), node.id, next);
+                }
                 const hydratedUpdate = loadedTools && loadedTools !== loadedToolsBase ? { loadedTools } : {};
                 if (!silent)
                     return { ...next, ...hydratedUpdate };
@@ -1542,23 +1614,17 @@ export class LangGraphAdapter {
                         continue;
                     }
                     const hasText = typeof msg.content === 'string' && msg.content.trim().length > 0;
-                    if ((hasText || msg.reasoningContent) &&
-                        (!streamedTextThisTurn || msg.reasoningContent)) {
-                        if (streamedTextThisTurn && !msg.reasoningContent)
-                            continue;
+                    if (hasText && !streamedTextThisTurn) {
                         yield {
                             type: 'response.chunk',
                             taskId: undefined,
                             correlationId: undefined,
                             timestamp,
                             payload: {
-                                content: streamedTextThisTurn ? '' : (msg.content ?? ''),
+                                content: msg.content ?? '',
                                 index: nextChunkIndex(),
                                 node: nodeId,
                                 graphId,
-                                ...(msg.reasoningContent
-                                    ? { reasoningContent: msg.reasoningContent }
-                                    : {}),
                             },
                         };
                     }
@@ -1569,26 +1635,8 @@ export class LangGraphAdapter {
                         continue;
                     if (subgraphNodeIds.has(nodeId) && streamedTextThisTurn)
                         continue;
-                    // 已通过 onChunk 推送过 token，避免整段重复
-                    if (streamedTextThisTurn) {
-                        // token 已流过：仍补发一条带 reasoning 的标记 chunk（空 content），供落库回传
-                        if (msg.reasoningContent) {
-                            yield {
-                                type: 'response.chunk',
-                                taskId: undefined,
-                                correlationId: undefined,
-                                timestamp,
-                                payload: {
-                                    content: '',
-                                    index: nextChunkIndex(),
-                                    node: nodeId,
-                                    graphId,
-                                    reasoningContent: msg.reasoningContent,
-                                },
-                            };
-                        }
+                    if (streamedTextThisTurn)
                         continue;
-                    }
                     yield {
                         type: 'response.chunk',
                         taskId: undefined,
@@ -1599,9 +1647,6 @@ export class LangGraphAdapter {
                             index: nextChunkIndex(),
                             node: nodeId,
                             graphId,
-                            ...(msg.reasoningContent
-                                ? { reasoningContent: msg.reasoningContent }
-                                : {}),
                         },
                     };
                     continue;

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

@@ -8,9 +8,12 @@ export interface ExecutionStreamBag {
         correlationId?: string;
     };
     chunkIndex: number;
+    /** 本轮 reasoning.chunk 序号，与 chunkIndex 分开从 0 计 */
+    reasoningChunkIndex: number;
     iteration: number;
     reasoningStartedThisTurn: boolean;
     streamedTextThisTurn: boolean;
+    graphId?: string;
 }
 export interface ExecutionRunContext {
     collector?: ITraceCollector;

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

@@ -107,6 +107,11 @@ export interface LLMChunk {
     /** thinking 增量；最终聚合后写入 assistant 消息 */
     reasoningContent?: string;
 }
+/** 流式旁路增量：思考与正文分字段，空字段不传 */
+export type LLMStreamDelta = {
+    content?: string;
+    reasoningContent?: string;
+};
 /**
  * ILLMProvider — LLM 调用提供者接口
  *
@@ -145,9 +150,9 @@ export declare class LLMNode {
      * @param config - LLM 节点配置
      * @param provider - LLM 调用提供者
      * @param streaming - 是否启用流式输出（默认 false）
-     * @param onChunk - 流式模式下每个文本片段回调（用于 SSE response.chunk）
+     * @param onChunk - 流式旁路：思考走 reasoningContent，正文走 content
      */
-    constructor(nodeId: string, config: LLMNodeConfig, provider: ILLMProvider, streaming?: boolean, onChunk?: (chunk: string) => void, interceptors?: Pick<ExecutionInterceptors, "beforeModel" | "afterModel"> | undefined);
+    constructor(nodeId: string, config: LLMNodeConfig, provider: ILLMProvider, streaming?: boolean, onChunk?: (delta: LLMStreamDelta) => void, interceptors?: Pick<ExecutionInterceptors, "beforeModel" | "afterModel"> | undefined);
     /**
      * execute — StateGraph 节点函数
      *

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

@@ -52,7 +52,7 @@ export class LLMNode {
      * @param config - LLM 节点配置
      * @param provider - LLM 调用提供者
      * @param streaming - 是否启用流式输出（默认 false）
-     * @param onChunk - 流式模式下每个文本片段回调（用于 SSE response.chunk）
+     * @param onChunk - 流式旁路：思考走 reasoningContent，正文走 content
      */
     constructor(nodeId, config, provider, streaming = false, onChunk, interceptors) {
         this.interceptors = interceptors;
@@ -247,8 +247,13 @@ export class LLMNode {
         let toolCalls;
         const iterator = this.provider.stream(messages, this.config);
         for await (const chunk of iterator) {
-            if (chunk.content && this.onChunk) {
-                this.onChunk(chunk.content);
+            const content = chunk.content || '';
+            const reasoningContent = chunk.reasoningContent || '';
+            if (this.onChunk && (content || reasoningContent)) {
+                this.onChunk({
+                    ...(content ? { content } : {}),
+                    ...(reasoningContent ? { reasoningContent } : {}),
+                });
             }
             chunks.push(chunk.content);
             if (chunk.reasoningContent) {

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

@@ -119,7 +119,7 @@ export class HttpLLMProvider {
                 });
             }
             catch (err) {
-                throwIfGraphTimedOut();
+                throwIfGraphAborted();
                 throw new Error(this.formatNetworkError(url, err));
             }
             if (!response.ok) {
@@ -170,6 +170,7 @@ export class HttpLLMProvider {
             return result;
         }
         catch (err) {
+            const propagated = graphAbortOr(err);
             await this.writeTurn({
                 url,
                 messages,
@@ -180,10 +181,10 @@ export class HttpLLMProvider {
                     inputTokens: 0,
                     outputTokens: 0,
                     finishReason: 'error',
-                    error: err instanceof Error ? err.message : String(err),
+                    error: propagated instanceof Error ? propagated.message : String(propagated),
                 },
             });
-            throw err;
+            throw propagated;
         }
         finally {
             clearTimeout(timeout);
@@ -244,7 +245,7 @@ export class HttpLLMProvider {
                 });
             }
             catch (err) {
-                throwIfGraphTimedOut();
+                throwIfGraphAborted();
                 throw new Error(this.formatNetworkError(url, err));
             }
             if (!response.ok) {
@@ -397,6 +398,7 @@ export class HttpLLMProvider {
             });
         }
         catch (err) {
+            const propagated = graphAbortOr(err);
             await this.writeTurn({
                 url,
                 messages,
@@ -411,10 +413,10 @@ export class HttpLLMProvider {
                     inputTokens,
                     outputTokens,
                     finishReason: 'error',
-                    error: err instanceof Error ? err.message : String(err),
+                    error: propagated instanceof Error ? propagated.message : String(propagated),
                 },
             });
-            throw err;
+            throw propagated;
         }
         finally {
             clearTimeout(timeout);
@@ -528,11 +530,26 @@ function linkGraphAbort(controller) {
     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)) {
+/** 这一轮 signal 已 abort 就抛出 reason。超时和用户停止都走这里，不再只认 timed out。 */
+function throwIfGraphAborted() {
+    const reason = graphAbortReason();
+    if (reason)
         throw reason;
-    }
+}
+/** 流式 read 抛出的 DOMException 换成这一轮 signal 上的 reason。 */
+function graphAbortOr(err) {
+    return graphAbortReason() ?? err;
+}
+function graphAbortReason() {
+    const signal = getExecutionTrace()?.abortSignal;
+    if (!signal?.aborted)
+        return undefined;
+    const reason = signal.reason;
+    if (reason instanceof Error)
+        return reason;
+    const err = new Error(reason == null ? 'Task aborted' : String(reason));
+    err.name = 'AbortError';
+    return err;
 }
 function formatNetworkDetail(error, depth = 0) {
     if (depth > 5)

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

@@ -11,6 +11,7 @@ import type { ICheckpointSaver } from '../checkpoint/contracts/checkpoint-saver.
 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 { type TaskAbortKind } from '../task/task-abort.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';
@@ -88,6 +89,12 @@ export interface ConversationDetail {
 export declare class AgentRuntime {
     private readonly deps;
     constructor(deps: AgentRuntimeDeps);
+    /**
+     * 停止这一轮。超时和用户停止共用 timeoutManager 上的那条 AbortSignal。
+     * 计时器还没启动时先记下，startTimer 会返回已 abort 的 signal，且不调用 onTimeout。
+     * @returns 已 abort 或已记下。没有 timeoutManager 时返回 false。
+     */
+    abort(taskId: string, kind?: TaskAbortKind): boolean;
     /** 从 GraphLoader 解析 tool manifest 映射（invoke/stream/resume/fork 共用） */
     private resolveLoadedTools;
     /** 从预装重载 Skill 定义（HITL/Fork 时 ephemeral 字段可能丢失） */