@gt-fe/eap-runtime 0.0.32 → 0.0.34

package/dist/graph/adapters/subgraph-compiler.js

@@ -13,7 +13,7 @@ import { LangGraphAdapter } from './langgraph.adapter.js';
 import { assertSkillGraphHasNoSubgraphNodes } from './graph-nesting.js';
 import { resolveExecutionTrace, warnTraceSpanFailure, } from '../execution-trace-context.js';
 import { skillSpanFields, skillTraceIdentity } from './skill-entry-span.js';
-import { filterLoadedToolsForSkill, } from '../../tool/system-prompt-builder.js';
+import { filterLoadedToolsForSkill, spokenName, } from '../../tool/system-prompt-builder.js';
 import { unwrapHitlPaused } from '../hitl/hitl-handler.js';
 import { pickContextFields } from '../../token/context-window.js';
 import { assertSkillIoIfEnabled, coerceSkillInputFromMessages, } from '../../registry/skill-io-guard.js';
@@ -65,11 +65,14 @@ export class SubGraphCompiler {
                 ? state['skillSpanId']
                 : '';
             const resuming = Boolean(existingSpanId);
+            const identity = skillTraceIdentity(state, resolvedSkillId);
+            const spanName = resolvedSkillId || dsl.name || 'skill';
+            const skillName = spokenName(identity.skillName, resolvedSkillId) ?? spanName;
             const auditCtx = resuming
                 ? undefined
                 : this.skillAuditRecorder?.startInvocation({
                     skillId: resolvedSkillId,
-                    skillName: dsl.name,
+                    skillName,
                     agentCode: (state['agentCode'] ?? state['agentId']),
                     userId: state['userId'] ?? '',
                     taskId: state['taskId'],
@@ -77,8 +80,6 @@ export class SubGraphCompiler {
                 });
             // 用父图这次调用上的 collector；内层 invoke 只补 collector/traceId，沿用外层流式袋。
             const { collector: traceCollector, traceId } = resolveExecutionTrace(state);
-            const skillName = dsl.name || resolvedSkillId;
-            const identity = skillTraceIdentity(state, resolvedSkillId);
             if (!resuming) {
                 adapter.emitStreamEvent({
                     type: 'skill.started',
@@ -87,7 +88,7 @@ export class SubGraphCompiler {
                     timestamp: new Date().toISOString(),
                     payload: {
                         skillId: resolvedSkillId,
-                        skillName: identity.skillName || skillName,
+                        skillName,
                         ...(identity.skillSpace ? { skillSpace: identity.skillSpace } : {}),
                         ...(identity.skillVersion ? { skillVersion: identity.skillVersion } : {}),
                     },
@@ -99,7 +100,7 @@ export class SubGraphCompiler {
                     const fields = skillSpanFields(identity, { source: 'subgraph' });
                     skillSpanId = await traceCollector.createNode({
                         traceId,
-                        name: resolvedSkillId || dsl.name || 'skill',
+                        name: spanName,
                         type: 'skill',
                         agentCode: state['agentCode'] ?? state['agentId'],
                         ...(fields.version ? { version: fields.version } : {}),
@@ -111,7 +112,7 @@ export class SubGraphCompiler {
                     });
                 }
                 catch (err) {
-                    warnTraceSpanFailure('createNode', { type: 'skill', name: resolvedSkillId || dsl.name || 'skill', traceId }, err);
+                    warnTraceSpanFailure('createNode', { type: 'skill', name: spanName, traceId }, err);
                     skillSpanId = null;
                 }
             }
@@ -154,6 +155,7 @@ export class SubGraphCompiler {
                     userId,
                     delegationToken,
                     agentCode,
+                    agentName: typeof state['agentName'] === 'string' ? state['agentName'] : undefined,
                     taskId: state['taskId'],
                     correlationId: state['correlationId'],
                     sessionId: state['sessionId'],
@@ -194,7 +196,7 @@ export class SubGraphCompiler {
                         });
                     }
                     catch (err) {
-                        warnTraceSpanFailure('completeNode', { type: 'skill', name: skillName, traceId, spanId: skillSpanId }, err);
+                        warnTraceSpanFailure('completeNode', { type: 'skill', name: spanName, traceId, spanId: skillSpanId }, err);
                     }
                 }
                 // 4. 只回写子图本步新增消息（含内部 tool 回合），禁止把入口历史再 append
@@ -269,7 +271,7 @@ export class SubGraphCompiler {
                         });
                     }
                     catch (completeErr) {
-                        warnTraceSpanFailure('completeNode', { type: 'skill', name: skillName, traceId, spanId: skillSpanId }, completeErr);
+                        warnTraceSpanFailure('completeNode', { type: 'skill', name: spanName, traceId, spanId: skillSpanId }, completeErr);
                     }
                 }
                 adapter.emitStreamEvent({

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

@@ -181,6 +181,8 @@ export interface GraphState {
     agentId?: string;
     /** Agent 对外主键 */
     agentCode?: string;
+    /** Agent 展示名（manifest.name）；身份段对用户说话用，缺省回退 agentCode */
+    agentName?: string;
     /** Hosting 路由选定的预装版本（AR-3b；写入 Checkpoint 供 HITL/Fork 恢复） */
     agentVersion?: string;
     correlationId?: string;

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/graph/nodes/skill-bind-node.d.ts

@@ -2,7 +2,7 @@
  * 可选图胶水：把 silent LLM 的结构化输出写成 skillRoute / activatedSkill。
  * 不是 Graph 节点类型。技能正文走短目录 + read_file，不灌 system。
  */
-import type { LoadedSkillInfo, LoadedSkillMap } from '../../tool/system-prompt-builder.js';
+import { type LoadedSkillInfo, type LoadedSkillMap } from '../../tool/system-prompt-builder.js';
 export type SkillRoute = 'skill' | 'clarify' | 'none';
 export interface SkillBindPatch {
     skillRoute: SkillRoute;

package/dist/graph/nodes/skill-bind-node.js

@@ -1,3 +1,8 @@
+/**
+ * 可选图胶水：把 silent LLM 的结构化输出写成 skillRoute / activatedSkill。
+ * 不是 Graph 节点类型。技能正文走短目录 + read_file，不灌 system。
+ */
+import { spokenName } from '../../tool/system-prompt-builder.js';
 function lastAssistantText(messages) {
     for (let i = messages.length - 1; i >= 0; i--) {
         const msg = messages[i];
@@ -89,7 +94,7 @@ export function bindSelectedSkill(state) {
     return {
         skillRoute: 'skill',
         activatedSkill: skill.skillId,
-        skillName: skill.name || skill.skillId,
+        skillName: spokenName(skill.name, skill.skillId),
         skillInput: params,
         messages: nextMessages(),
     };

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

@@ -203,6 +203,7 @@ export class ToolNode {
                         correlationId: req.correlationId,
                         skillId,
                         ...(identity.toolset ? { toolset: identity.toolset } : {}),
+                        ...(identity.toolDisplayName ? { toolDisplayName: identity.toolDisplayName } : {}),
                     },
                 });
             }

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/registry/graph-loader.d.ts

@@ -20,8 +20,13 @@ export interface LoadAgentOptions {
 export declare function resolveAgentSystemPromptFromLoader(loader: {
     resolveAgentSystemPrompt?: (agentCode: string, version?: string) => Promise<string | undefined>;
 } | undefined, agentCode: string, version?: string): Promise<string | undefined>;
+export declare function resolveAgentDisplayNameFromLoader(loader: {
+    resolveAgentDisplayName?: (agentCode: string, version?: string) => Promise<string | undefined>;
+} | undefined, agentCode: string, version?: string): Promise<string | undefined>;
 /** manifest.prompts.system；空白视为缺省。 */
 export declare function extractAgentSystemPrompt(manifest: unknown): string | undefined;
+/** manifest.name；空白视为缺省。身份段对用户说话用，不当路由键。 */
+export declare function extractAgentDisplayName(manifest: unknown): string | undefined;
 export interface GraphLoaderConfig {
     registryClient?: AgentRegistryClient;
     deploymentContext?: DeploymentContext;
@@ -116,6 +121,12 @@ export declare class GraphLoader {
      * 每轮 execute/stream 注入 GraphState.agentSystemPrompt；不写进节点 config。
      */
     resolveAgentSystemPrompt(agentCode: string, version?: string): Promise<string | undefined>;
+    /**
+     * Agent 展示名（manifest.name）。
+     * 每轮 execute/stream 注入 GraphState.agentName；身份段对用户说话用。
+     */
+    resolveAgentDisplayName(agentCode: string, version?: string): Promise<string | undefined>;
+    private fromAgentManifest;
     /**
      * 解析 agent tools[] + graph tool 节点 union；
      * server+预装：以预装 manifest 为准；desktop 合并 ILocalToolInstallStore。

package/dist/registry/graph-loader.js

@@ -64,6 +64,11 @@ export async function resolveAgentSystemPromptFromLoader(loader, agentCode, vers
         return undefined;
     return loader.resolveAgentSystemPrompt(agentCode, version);
 }
+export async function resolveAgentDisplayNameFromLoader(loader, agentCode, version) {
+    if (!loader || typeof loader.resolveAgentDisplayName !== 'function')
+        return undefined;
+    return loader.resolveAgentDisplayName(agentCode, version);
+}
 /** manifest.prompts.system；空白视为缺省。 */
 export function extractAgentSystemPrompt(manifest) {
     if (!manifest || typeof manifest !== 'object' || Array.isArray(manifest))
@@ -77,6 +82,16 @@ export function extractAgentSystemPrompt(manifest) {
     const trimmed = system.trim();
     return trimmed ? trimmed : undefined;
 }
+/** manifest.name；空白视为缺省。身份段对用户说话用，不当路由键。 */
+export function extractAgentDisplayName(manifest) {
+    if (!manifest || typeof manifest !== 'object' || Array.isArray(manifest))
+        return undefined;
+    const name = manifest.name;
+    if (typeof name !== 'string')
+        return undefined;
+    const trimmed = name.trim();
+    return trimmed ? trimmed : undefined;
+}
 function extractSkillPrompt(manifest) {
     const prompt = manifest.prompt;
     if (typeof prompt === 'string' && prompt.trim())
@@ -769,18 +784,27 @@ export class GraphLoader {
      * 每轮 execute/stream 注入 GraphState.agentSystemPrompt；不写进节点 config。
      */
     async resolveAgentSystemPrompt(agentCode, version) {
+        return this.fromAgentManifest(agentCode, version, extractAgentSystemPrompt);
+    }
+    /**
+     * Agent 展示名（manifest.name）。
+     * 每轮 execute/stream 注入 GraphState.agentName；身份段对用户说话用。
+     */
+    async resolveAgentDisplayName(agentCode, version) {
+        return this.fromAgentManifest(agentCode, version, extractAgentDisplayName);
+    }
+    async fromAgentManifest(agentCode, version, extract) {
         if (this.deploymentSnapshot) {
             const snap = await this.deploymentSnapshot.loadAgentSnapshot(agentCode, version);
-            if (snap) {
-                return extractAgentSystemPrompt(snap.manifest);
-            }
+            if (snap)
+                return extract(snap.manifest);
             if (this.blockRegistryDefinitions)
                 return undefined;
         }
         if (this.blockRegistryDefinitions || !this.registryClient)
             return undefined;
         const record = await this.registryClient.getAgent(agentCode);
-        return extractAgentSystemPrompt(record?.manifest);
+        return extract(record?.manifest);
     }
     /**
      * 解析 agent tools[] + graph tool 节点 union；

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 字段可能丢失） */

package/dist/runtime/agent-runtime.js

@@ -9,13 +9,14 @@
 import { randomUUID } from 'node:crypto';
 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 { 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 { resolveAgentDisplayNameFromLoader, resolveAgentSystemPromptFromLoader, } from '../registry/graph-loader.js';
 import { toLoadedSkillMap } from '../tool/system-prompt-builder.js';
 import { assembleLoadedTools } from '../tool/harness-primitives.js';
 import { createFileLlmTurnLogFromEnv, } from '../debug/llm-turn-log.js';
-import { buildHitlWaitingTaskOutput, buildTurnTranscriptFromStreamEvents, loadModelFacingHistory, turnGraphMessagesAfterCompression, extractHitlThreadId, extractStreamReasoning, applyStreamTextDelta, createStreamAssistantBuckets, visibleStreamAssistantText, streamAssistantTexts, messageRecordsToGraphMessages, persistHitlWaitingPlaceholder, persistTurnTranscript, persistUserTurnMessage, resolveCheckpointThreadId, appendTerminalToolResult, } from '../session/persist-turn-messages.js';
+import { buildHitlWaitingTaskOutput, buildTurnTranscriptFromStreamEvents, loadModelFacingHistory, turnGraphMessagesAfterCompression, extractHitlThreadId, applyStreamReasoningEvent, applyStreamTextDelta, createStreamAssistantBuckets, createStreamReasoningState, resolvedStreamReasoning, visibleStreamAssistantText, streamAssistantTexts, messageRecordsToGraphMessages, persistHitlWaitingPlaceholder, persistTurnTranscript, persistUserTurnMessage, resolveCheckpointThreadId, appendTerminalToolResult, } from '../session/persist-turn-messages.js';
 import { collectPublicArtifactLinks, collectPublicArtifactLinksFromEvent, injectPublicArtifactLinks, mergeArtifactLinks, } from '../tool/inject-public-artifact-links.js';
 import { iterSessionCompression, withCompressionSummaryModel, } from '../session/apply-session-compression.js';
 import { applySessionMemory } from '../session/apply-session-memory.js';
@@ -33,7 +34,33 @@ const HITL_TERMINAL_STATUSES = [
     'failed',
     'timeout',
     'token_exhausted',
+    'cancelled',
 ];
+const TASK_CANCELLED_SSE_CODE = 'runtime.task.cancelled';
+function taskAbortSseData(kind) {
+    if (kind === 'timeout') {
+        return {
+            code: ErrorCodes.TASK_TIMEOUT,
+            message: 'Task execution timed out',
+            recoverable: false,
+        };
+    }
+    return {
+        code: TASK_CANCELLED_SSE_CODE,
+        message: 'Task cancelled',
+        recoverable: false,
+    };
+}
+async function settleAbortedTask(taskService, taskId, kind) {
+    if (kind === 'timeout') {
+        await taskService.tryUpdateStatus(taskId, 'running', 'timeout');
+        return;
+    }
+    const moved = await taskService.tryUpdateStatus(taskId, 'running', 'cancelled');
+    if (!moved) {
+        await taskService.tryUpdateStatus(taskId, 'waiting_hitl', 'cancelled');
+    }
+}
 const DEFAULT_GRAPH_DSL = {
     name: 'default-graph',
     version: '1.0.0',
@@ -57,6 +84,17 @@ export class AgentRuntime {
         }
         this.deps.hitlHandler.setTraceCollector?.(this.deps.traceCollector);
     }
+    /**
+     * 停止这一轮。超时和用户停止共用 timeoutManager 上的那条 AbortSignal。
+     * 计时器还没启动时先记下，startTimer 会返回已 abort 的 signal，且不调用 onTimeout。
+     * @returns 已 abort 或已记下。没有 timeoutManager 时返回 false。
+     */
+    abort(taskId, kind = 'cancelled') {
+        const manager = this.deps.timeoutManager;
+        if (!manager || !taskId.trim())
+            return false;
+        return manager.abort(taskId, kind);
+    }
     /** 从 GraphLoader 解析 tool manifest 映射（invoke/stream/resume/fork 共用） */
     async resolveLoadedTools(agentCode, agentVersion) {
         if (!this.deps.graphLoader)
@@ -330,6 +368,7 @@ export class AgentRuntime {
             ? (await this.deps.graphLoader.resolveAgentDir(agentCode, params.agentVersion)) ?? undefined
             : undefined;
         const agentSystemPrompt = await resolveAgentSystemPromptFromLoader(this.deps.graphLoader, agentCode, params.agentVersion);
+        const agentName = await resolveAgentDisplayNameFromLoader(this.deps.graphLoader, agentCode, params.agentVersion);
         const facing = await loadModelFacingHistory({
             sessionHistory: messageRecordsToGraphMessages(sessionContext.messages),
             checkpointSaver: this.deps.checkpointSaver,
@@ -375,8 +414,8 @@ export class AgentRuntime {
         });
         const startTime = Date.now();
         const assistantBuckets = createStreamAssistantBuckets();
+        const reasoningState = createStreamReasoningState();
         let toolCallReasoningContent;
-        let assistantReasoningContent;
         const pendingToolCalls = [];
         const toolResults = [];
         const artifactLinks = [];
@@ -402,6 +441,7 @@ export class AgentRuntime {
                 promptRoots,
                 agentDir,
                 agentSystemPrompt,
+                agentName,
                 skillInput: resolveSkillInputFromInvokeInput(params.input),
                 traceId: resolveTraceId(params),
                 traceCollector: this.deps.traceCollector,
@@ -417,16 +457,12 @@ export class AgentRuntime {
                             arguments: p.arguments ?? {},
                         });
                     }
-                    if (typeof p.reasoningContent === 'string' && p.reasoningContent) {
-                        toolCallReasoningContent = p.reasoningContent;
-                    }
+                    toolCallReasoningContent = resolvedStreamReasoning(reasoningState);
                 }
                 // 终态 tool.result / tool.error 回填历史；willRetry 的 error 不进 transcript
                 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);
                 collectStreamNodeTokenUsage(runtimeEvent, nodeTokenUsages);
                 if (shouldEmitTokenSse(tokenDetail, runtimeEvent.type)) {
@@ -460,7 +496,7 @@ export class AgentRuntime {
                     assistantText: injected,
                     finishPoints: graph.finishPoints,
                     toolCallReasoningContent,
-                    assistantReasoningContent,
+                    assistantReasoningContent: resolvedStreamReasoning(reasoningState),
                 }),
                 assistantTokenCount: tokenSummary.total.output,
                 assistantDurationMs: Date.now() - startTime,
@@ -493,15 +529,11 @@ 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) {
+            const abortKind = taskAbortKindOf(err, abortSignal);
+            if (abortKind) {
                 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,
-                });
+                await settleAbortedTask(this.deps.taskService, task.id, abortKind);
+                yield this.toSSE('task.error', correlationId, task.id, taskAbortSseData(abortKind));
                 return;
             }
             const message = err instanceof Error ? err.message : 'Unknown error';
@@ -617,6 +649,9 @@ export class AgentRuntime {
             agentSystemPrompt: (await resolveAgentSystemPromptFromLoader(this.deps.graphLoader, agentCode, agentVersion)) ?? (typeof resumedState.agentSystemPrompt === 'string'
                 ? resumedState.agentSystemPrompt
                 : undefined),
+            agentName: (await resolveAgentDisplayNameFromLoader(this.deps.graphLoader, agentCode, agentVersion)) ?? (typeof resumedState.agentName === 'string' && resumedState.agentName.trim()
+                ? resumedState.agentName.trim()
+                : undefined),
             activatedSkill: resumedState.activatedSkill,
             skillRoute: resumedState.skillRoute ??
                 (typeof resumedState.activatedSkill === 'string' && resumedState.activatedSkill
@@ -633,8 +668,8 @@ export class AgentRuntime {
         };
         const startTime = Date.now();
         const assistantBuckets = createStreamAssistantBuckets();
+        const reasoningState = createStreamReasoningState();
         let toolCallReasoningContent;
-        let assistantReasoningContent;
         const pendingToolCalls = [];
         const toolResults = [];
         const artifactLinks = [];
@@ -650,15 +685,11 @@ export class AgentRuntime {
                             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);
                 collectStreamNodeTokenUsage(runtimeEvent, nodeTokenUsages);
                 if (shouldEmitTokenSse(tokenDetail, runtimeEvent.type)) {
@@ -693,7 +724,7 @@ export class AgentRuntime {
                         assistantText: injected,
                         finishPoints: graph.finishPoints,
                         toolCallReasoningContent,
-                        assistantReasoningContent,
+                        assistantReasoningContent: resolvedStreamReasoning(reasoningState),
                     }),
                     assistantTokenCount: tokenSummary.total.output,
                     assistantDurationMs: Date.now() - startTime,
@@ -729,15 +760,11 @@ 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) {
+            const abortKind = taskAbortKindOf(err, abortSignal);
+            if (abortKind) {
                 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,
-                });
+                await settleAbortedTask(this.deps.taskService, taskId, abortKind);
+                yield this.toSSE('task.error', correlationId, taskId, taskAbortSseData(abortKind));
                 return;
             }
             const appErr = err instanceof AppError ? err : AppError.fromUnknown(err);
@@ -814,6 +841,9 @@ export class AgentRuntime {
         const agentSystemPrompt = (await resolveAgentSystemPromptFromLoader(this.deps.graphLoader, agentCode, agentVersion)) ?? (typeof forkedCheckpoint.state.agentSystemPrompt === 'string'
             ? forkedCheckpoint.state.agentSystemPrompt
             : undefined);
+        const agentName = (await resolveAgentDisplayNameFromLoader(this.deps.graphLoader, agentCode, agentVersion)) ?? (typeof forkedCheckpoint.state.agentName === 'string' && forkedCheckpoint.state.agentName.trim()
+            ? forkedCheckpoint.state.agentName.trim()
+            : undefined);
         const abortDeadlineMs = Date.now() + timeout;
         try {
             const forkState = { ...forkedCheckpoint.state };
@@ -827,6 +857,7 @@ export class AgentRuntime {
                 agentVersion,
                 agentDir,
                 agentSystemPrompt,
+                agentName,
                 userId,
                 delegationToken: overrides.executionContext?.delegationToken,
                 executionContext: overrides.executionContext,
@@ -896,15 +927,15 @@ 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');
+            const abortKind = taskAbortKindOf(err, abortSignal);
+            if (abortKind) {
+                await settleAbortedTask(this.deps.taskService, task.id, abortKind);
                 return {
                     newTraceId: traceId,
                     originalTraceId,
                     newTaskId: task.id,
                     checkpointId,
-                    status: 'timeout',
+                    status: abortKind === 'timeout' ? 'timeout' : 'cancelled',
                     output: message,
                     tokenUsage: {
                         input_tokens,

package/dist/runtime/types.d.ts

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