@hmj-ai/cflow 1.3.7 → 1.3.9

package/dist/src/proposal.js

@@ -14,13 +14,15 @@ const capabilitySchema = (grounded) => ({
     type: 'object',
     additionalProperties: false,
     required: grounded
-        ? ['kind', 'name', 'does', 'cfId', 'sourceQuote']
-        : ['kind', 'name', 'does', 'cfId'],
+        ? ['kind', 'name', 'does', 'cfId', 'cond', 'routes', 'sourceQuote']
+        : ['kind', 'name', 'does', 'cfId', 'cond', 'routes'],
     properties: {
         kind: { type: 'string', enum: ['cf-call'] },
         name: { type: 'string' },
         does: { type: 'string' },
         cfId: { type: ['string', 'null'] },
+        cond: { type: 'null' },
+        routes: { type: 'array', maxItems: 0 },
         input: { type: ['string', 'null'] },
         output: { type: ['string', 'null'] },
         process: { type: ['string', 'null'] },
@@ -39,51 +41,53 @@ export const flowRevisionOutputSchema = (grounded = false) => ({
         stages: {
             type: 'array',
             maxItems: MAX_STAGES,
-            items: capabilitySchema(grounded),
+            items: stageSchema(grounded),
         },
     },
 });
-const stageSchema = (grounded) => ({
-    type: 'object',
-    additionalProperties: false,
-    required: grounded
-        ? ['kind', 'name', 'does', 'cfId', 'cond', 'routes', 'sourceQuote']
-        : ['kind', 'name', 'does', 'cfId', 'cond', 'routes'],
-    properties: {
-        kind: { type: 'string', enum: ['cf-call', 'branch'] },
-        name: { type: 'string' },
-        does: { type: ['string', 'null'] },
-        cfId: { type: ['string', 'null'] },
-        cond: { type: ['string', 'null'] },
-        routes: {
-            type: 'array',
-            items: {
-                type: 'object',
-                additionalProperties: false,
-                required: grounded
-                    ? ['caseId', 'condition', 'endsFlow', 'stages', 'sourceQuote']
-                    : ['caseId', 'condition', 'endsFlow', 'stages'],
-                properties: {
-                    caseId: { type: 'string' },
-                    condition: { type: 'string' },
-                    endsFlow: { type: 'boolean' },
-                    sourceQuote: { type: ['string', 'null'] },
-                    stages: {
-                        type: 'array',
-                        minItems: 0,
-                        maxItems: 6,
-                        items: capabilitySchema(grounded),
+function stageSchema(grounded) {
+    return {
+        type: 'object',
+        additionalProperties: false,
+        required: grounded
+            ? ['kind', 'name', 'does', 'cfId', 'cond', 'routes', 'sourceQuote']
+            : ['kind', 'name', 'does', 'cfId', 'cond', 'routes'],
+        properties: {
+            kind: { type: 'string', enum: ['cf-call', 'branch'] },
+            name: { type: 'string' },
+            does: { type: ['string', 'null'] },
+            cfId: { type: ['string', 'null'] },
+            cond: { type: ['string', 'null'] },
+            routes: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: grounded
+                        ? ['caseId', 'condition', 'endsFlow', 'stages', 'sourceQuote']
+                        : ['caseId', 'condition', 'endsFlow', 'stages'],
+                    properties: {
+                        caseId: { type: 'string' },
+                        condition: { type: 'string' },
+                        endsFlow: { type: 'boolean' },
+                        sourceQuote: { type: ['string', 'null'] },
+                        stages: {
+                            type: 'array',
+                            minItems: 0,
+                            maxItems: 6,
+                            items: capabilitySchema(grounded),
+                        },
                     },
                 },
             },
+            input: { type: ['string', 'null'] },
+            output: { type: ['string', 'null'] },
+            process: { type: ['string', 'null'] },
+            sourceQuote: { type: ['string', 'null'] },
+            effects: { type: 'array', items: { type: 'object' } },
         },
-        input: { type: ['string', 'null'] },
-        output: { type: ['string', 'null'] },
-        process: { type: ['string', 'null'] },
-        sourceQuote: { type: ['string', 'null'] },
-        effects: { type: 'array', items: { type: 'object' } },
-    },
-});
+    };
+}
 /**
  * `grounded` mirrors attachment mode: when a skill document is uploaded every
  * stage must carry a `sourceQuote`, so the schema demands it rather than only
@@ -360,11 +364,7 @@ const textOf = (value, fallback, max) => {
     const trimmed = value.trim();
     return trimmed ? trimmed.slice(0, max) : fallback;
 };
-/**
- * Rebuilds the current draft as a linear cf-call spine. The runtime may only
- * emit capability stages; branch/join/approval/onError are stripped here so a
- * revision cannot smuggle control structure into an existing Flow.
- */
+/** Rebuilds the current draft from bounded capabilities and top-level branches. */
 export function applyFlowRevision(current, currentCfDrafts, rawStages, options) {
     const stages = (Array.isArray(rawStages) ? rawStages : []).slice(0, MAX_STAGES);
     if (!stages.length)
@@ -382,6 +382,7 @@ export function applyFlowRevision(current, currentCfDrafts, rawStages, options)
     const nodes = [];
     const edges = [];
     const cfDrafts = [];
+    const terminalRoutes = [];
     const allocateId = (preferred, fallback) => {
         let id = preferred && !claimed.has(preferred) ? preferred : fallback;
         let suffix = 2;
@@ -400,9 +401,7 @@ export function applyFlowRevision(current, currentCfDrafts, rawStages, options)
                 return true;
             return cfById.get(node.cfRef.cfId)?.name?.trim() === name;
         });
-    const capability = (stage, index) => {
-        if (stage?.kind && stage.kind !== 'cf-call')
-            throw new Error(`RUNTIME_REVISION_CONTROL_FORBIDDEN:${index}`);
+    const capability = (stage, fallback) => {
         const name = String(stage?.name ?? '')
             .trim()
             .slice(0, 80);
@@ -410,15 +409,15 @@ export function applyFlowRevision(current, currentCfDrafts, rawStages, options)
             .trim()
             .slice(0, 500);
         if (!name || !does)
-            throw new Error(`RUNTIME_REVISION_STAGE_INVALID:${index}`);
+            throw new Error(`RUNTIME_REVISION_STAGE_INVALID:${fallback}`);
         const requestedId = stage?.cfId ? String(stage.cfId) : '';
         if (requestedId && !allowedIds.has(requestedId))
             throw new Error(`RUNTIME_REVISION_CF_UNKNOWN:${requestedId}`);
         const knownId = requestedId;
         const published = knownId ? catalog.find((item) => item.cfId === knownId) : undefined;
         const candidate = knownId ? cfById.get(knownId) : undefined;
-        const matched = matchExisting(knownId || `unmatched-${index}`, name);
-        const id = allocateId(matched?.id, `step-${index + 1}`);
+        const matched = matchExisting(knownId || `unmatched-${fallback}`, name);
+        const id = allocateId(matched?.id, fallback);
         const executor = matched?.kind === 'cf-call' ? matched.executor : runtimeId;
         const withMeta = (cfId, version) => ({
             id,
@@ -459,21 +458,72 @@ export function applyFlowRevision(current, currentCfDrafts, rawStages, options)
         });
         return withMeta(cfId, '1.0.0');
     };
-    let previous = '$entry';
+    const connect = (from, to, when) => {
+        edges.push({ id: `edge-${edges.length + 1}`, from, to, ...(when ? { when } : {}) });
+    };
+    let frontier = ['$entry'];
     for (const [index, stage] of stages.entries()) {
-        const node = capability(stage, index);
-        nodes.push(node);
-        edges.push({
-            id: `edge-${edges.length + 1}`,
-            from: previous,
-            to: node.id,
+        if (!frontier.length)
+            throw new Error('RUNTIME_REVISION_AFTER_TERMINAL_BRANCH');
+        if (stage?.kind !== 'branch') {
+            const node = capability(stage, `step-${index + 1}`);
+            nodes.push(node);
+            frontier.forEach((from) => connect(from, node.id));
+            frontier = [node.id];
+            continue;
+        }
+        const routes = Array.isArray(stage.routes) ? stage.routes.slice(0, 8) : [];
+        if (routes.length < 2)
+            throw new Error('RUNTIME_REVISION_BRANCH_ROUTES_INVALID');
+        const cases = [];
+        const caseConditions = {};
+        const branchId = allocateId(undefined, `branch-${index + 1}`);
+        const branch = {
+            id: branchId,
+            kind: 'branch',
+            cond: { $get: String(stage.cond ?? 'route').trim() || 'route' },
+            cases,
+            caseConditions,
+        };
+        nodes.push(branch);
+        frontier.forEach((from) => connect(from, branch.id));
+        const tails = [];
+        routes.forEach((route, routeIndex) => {
+            const caseId = String(route?.caseId ?? `case-${routeIndex + 1}`).trim();
+            const condition = String(route?.condition ?? '')
+                .trim()
+                .slice(0, 500);
+            if (!caseId || !condition || cases.includes(caseId))
+                throw new Error('RUNTIME_REVISION_BRANCH_CASE_INVALID');
+            cases.push(caseId);
+            caseConditions[caseId] = condition;
+            const routeStages = Array.isArray(route?.stages) ? route.stages.slice(0, MAX_STAGES) : [];
+            if (typeof route?.endsFlow !== 'boolean')
+                throw new Error('RUNTIME_REVISION_BRANCH_ROUTE_END_INVALID');
+            if (route.endsFlow && routeStages.length)
+                throw new Error('RUNTIME_REVISION_BRANCH_ROUTE_TERMINAL_WITH_STAGES');
+            if (!routeStages.length && !route.endsFlow)
+                throw new Error('RUNTIME_REVISION_BRANCH_ROUTE_EMPTY');
+            if (!routeStages.length) {
+                terminalRoutes.push({ branchId: branch.id, caseId });
+                return;
+            }
+            let previous = branch.id;
+            routeStages.forEach((routeStage, stageIndex) => {
+                const node = capability(routeStage, `step-${index + 1}-${routeIndex + 1}-${stageIndex + 1}`);
+                nodes.push(node);
+                connect(previous, node.id, stageIndex === 0 ? { outcome: 'branch-case', caseId } : undefined);
+                previous = node.id;
+            });
+            tails.push(previous);
         });
-        previous = node.id;
+        frontier = tails;
     }
     const previousOutput = current.nodes.find((node) => node.kind === 'output');
     const output = previousOutput ?? { id: 'output', kind: 'output', outputId: 'result' };
     nodes.push(output);
-    edges.push({ id: `edge-${edges.length + 1}`, from: previous, to: output.id });
+    frontier.forEach((from) => connect(from, output.id));
+    terminalRoutes.forEach(({ branchId, caseId }) => connect(branchId, output.id, { outcome: 'branch-case', caseId }));
     const flowDraft = {
         ...current,
         revision: current.revision + 1,

package/dist/src/runtime.js

@@ -393,7 +393,7 @@ export class RuntimeManager {
         }
         const executor = (id) => registry.register({
             id,
-            execute: (task, input, signal, resources, effects, context) => this.executeProfile(profile, task, input, signal, resources, undefined, effects, context),
+            execute: (task, input, signal, resources, effects, context, trace) => this.executeProfile(profile, task, input, signal, resources, undefined, effects, context, undefined, trace),
         });
         executor(`${profile.id}@${profile.profileVersion}`);
         if (!exactOnly)
@@ -483,21 +483,27 @@ export class RuntimeManager {
         }
         throw new Error(`RUNTIME_BACKEND_UNSUPPORTED:${profile.backend}`);
     }
-    async execute(id, task, input, signal, resources = [], outputSchema, context) {
+    async execute(id, task, input, signal, resources = [], outputSchema, context, trace) {
         const profile = this.profile(id);
         if (!profile)
             throw new Error(`UNKNOWN_EXECUTOR:${id}`);
-        return this.executeProfile(profile, task, input, signal, resources, outputSchema, [], context);
+        return this.executeProfile(profile, task, input, signal, resources, outputSchema, [], context, undefined, trace);
     }
-    async executeAnalysis(id, task, input, signal, options, outputSchema) {
+    async executeAnalysis(id, task, input, signal, options, outputSchema, trace) {
         const profile = this.profile(id);
         if (!profile)
             throw new Error(`UNKNOWN_EXECUTOR:${id}`);
-        return this.executeProfile(profile, task, input, signal, [], outputSchema, [], undefined, options);
+        return this.executeProfile(profile, task, input, signal, [], outputSchema, [], undefined, options, trace);
     }
-    async executeProfile(profile, task, input, signal, resources = [], outputSchema, effects = [], context, analysis) {
+    async executeProfile(profile, task, input, signal, resources = [], outputSchema, effects = [], context, analysis, trace) {
         if (!profile.enabled)
             throw new Error(`RUNTIME_DISABLED:${profile.id}`);
+        trace?.({
+            kind: 'stage',
+            title: '已准备 Agent 请求',
+            status: 'completed',
+            detail: `${profile.name} · ${profile.backend.toUpperCase()}`,
+        });
         if (profile.backend === 'builtin')
             return { task, input };
         const prompt = [
@@ -520,9 +526,9 @@ export class RuntimeManager {
             .filter(Boolean)
             .join('\n\n');
         const text = profile.backend === 'acp'
-            ? await this.runAcp(profile, prompt, signal, effects, context, analysis)
+            ? await this.runAcp(profile, prompt, signal, effects, context, analysis, trace)
             : profile.backend === 'cli'
-                ? await this.runCli(profile, prompt, signal, effects, context, analysis)
+                ? await this.runCli(profile, prompt, signal, effects, context, analysis, trace)
                 : await Promise.reject(new Error(`RUNTIME_BACKEND_UNSUPPORTED:${profile.backend}`));
         return profile.outputMode === 'json' ? parseJsonOutput(text) : { content: text.trim() };
     }
@@ -742,7 +748,7 @@ export class RuntimeManager {
         const mode = canRun ? 'full' : canWrite ? 'write' : canRead ? 'read' : 'none';
         return profile.permissionArgs?.[mode] ?? [];
     }
-    async runCli(profile, prompt, signal, effects = [], context, analysis) {
+    async runCli(profile, prompt, signal, effects = [], context, analysis, trace) {
         const cwd = analysis?.cwd ?? context?.workspaceRoot ?? profile.workingDirectory ?? process.cwd();
         const args = [
             ...profile.args,
@@ -751,6 +757,7 @@ export class RuntimeManager {
         ];
         const spec = this.launchSpec(profile, args, cwd, ['pipe', 'pipe', 'pipe'], effects);
         const child = launchProcess(spec);
+        trace?.({ kind: 'stage', title: '正在等待 Agent 响应', status: 'running' });
         const output = [];
         const errors = [];
         let outputBytes = 0;
@@ -796,6 +803,7 @@ export class RuntimeManager {
             const stderr = Buffer.concat(errors).toString('utf8').trim().slice(-800);
             if (result.code !== 0)
                 throw new Error(`AGENT_CLI_EXITED:${result.code ?? result.childSignal ?? 'unknown'}${stderr ? `:${stderr}` : ''}`);
+            trace?.({ kind: 'stage', title: 'Agent 已返回结果', status: 'completed' });
             return Buffer.concat(output).toString('utf8');
         }
         finally {
@@ -803,7 +811,7 @@ export class RuntimeManager {
             terminate();
         }
     }
-    async runAcp(profile, prompt, signal, effects = [], context, analysis) {
+    async runAcp(profile, prompt, signal, effects = [], context, analysis, trace) {
         const cwd = analysis?.cwd ?? context?.workspaceRoot ?? profile.workingDirectory ?? process.cwd();
         const spec = this.launchSpec(profile, profile.args, cwd, ['pipe', 'pipe', 'pipe'], effects);
         const child = launchProcess(spec);
@@ -824,6 +832,7 @@ export class RuntimeManager {
                 throw new Error('ACP_SERVER_STDIO_UNAVAILABLE');
             const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
             let permissionDenied = false;
+            trace?.({ kind: 'stage', title: '正在连接 Agent 会话', status: 'running' });
             return await acpClient({ name: 'CFlow' })
                 .onRequest(methods.client.session.requestPermission, async (ctx) => {
                 const tool = ctx?.params?.toolCall ?? ctx?.toolCall ?? {};
@@ -851,7 +860,45 @@ export class RuntimeManager {
                 });
                 return ctx.buildSession(cwd).withSession(async (session) => {
                     const promptResult = session.prompt(prompt);
-                    const text = await session.readText();
+                    let text = '';
+                    let analysisReported = false;
+                    while (true) {
+                        const update = await session.nextUpdate();
+                        if (update.kind === 'stop')
+                            break;
+                        const item = update.update;
+                        const tag = item?.sessionUpdate;
+                        if (tag === 'agent_message_chunk' && item.content?.type === 'text')
+                            text += item.content.text;
+                        else if (tag === 'agent_thought_chunk' && !analysisReported) {
+                            analysisReported = true;
+                            trace?.({ kind: 'stage', title: 'Agent 正在分析', status: 'running' });
+                        }
+                        else if (tag === 'plan')
+                            trace?.({
+                                kind: 'plan',
+                                title: 'Agent 制定了执行计划',
+                                detail: item.entries?.map((entry) => entry.content).join('；'),
+                                technical: item,
+                            });
+                        else if (tag === 'tool_call' || tag === 'tool_call_update')
+                            trace?.({
+                                kind: 'tool',
+                                title: item.title ?? item.name ?? 'Agent 工具调用',
+                                detail: item.status ? `状态：${item.status}` : undefined,
+                                status: item.status === 'failed'
+                                    ? 'failed'
+                                    : item.status === 'completed'
+                                        ? 'completed'
+                                        : 'running',
+                                technical: {
+                                    toolCallId: item.toolCallId,
+                                    input: item.rawInput,
+                                    output: item.rawOutput,
+                                    locations: item.locations,
+                                },
+                            });
+                    }
                     const response = await promptResult;
                     if (response.stopReason !== 'end_turn') {
                         const reason = String(response.stopReason).toUpperCase();
@@ -869,6 +916,7 @@ export class RuntimeManager {
                     }
                     if (Buffer.byteLength(text, 'utf8') > profile.maxOutputBytes)
                         throw new Error('RUNTIME_OUTPUT_LIMIT_EXCEEDED');
+                    trace?.({ kind: 'stage', title: 'Agent 已完成处理', status: 'completed' });
                     return text;
                 });
             });

package/dist/src/server.js

@@ -4,6 +4,7 @@ import fastifyStatic from '@fastify/static';
 import fastifyMultipart from '@fastify/multipart';
 import { fileURLToPath } from 'node:url';
 import { existsSync, realpathSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
 import { cp, mkdir, rm } from 'node:fs/promises';
 import { dirname, join, sep } from 'node:path';
 import { Store } from './db.js';
@@ -29,6 +30,21 @@ export function createApp(store = new Store(), requestedWorkspaceRoot = process.
         ...[...testCatalogs.values()].flat(),
     ]);
     const scopeFlowDraft = (draft) => ({ ...draft, workspaceRoot });
+    const startInvocation = (input) => {
+        const id = input.id?.trim() || `agent-${randomUUID()}`;
+        const existing = store.agentInvocation(id);
+        if (!existing)
+            store.createAgentInvocation({
+                id,
+                kind: input.kind,
+                status: 'running',
+                runtimeId: input.runtimeId,
+                flowId: input.flowId,
+                messageId: input.messageId,
+            });
+        return id;
+    };
+    const traceFor = (id) => (event) => store.appendAgentTrace(id, event);
     const app = Fastify({ logger: true });
     app.register(fastifyMultipart, {
         // Do not silently truncate large skill bundles; files are streamed to disk.
@@ -249,6 +265,7 @@ export function createApp(store = new Store(), requestedWorkspaceRoot = process.
         const result = store.db.prepare('DELETE FROM flow_drafts WHERE id=?').run(req.params.id);
         if (!result.changes)
             return reply.code(404).send({ error: 'FLOW_DRAFT_NOT_FOUND' });
+        store.deleteAgentInvocationsForFlow(req.params.id);
         return { deleted: true };
     });
     const deletePublishedFlow = async (id, reply) => {
@@ -335,6 +352,9 @@ export function createApp(store = new Store(), requestedWorkspaceRoot = process.
         const runtimeId = body.runtimeId?.trim();
         const profile = runtimeId ? runtimes.profile(runtimeId) : undefined;
         const runtimeUsable = Boolean(runtimeId) && profile?.backend !== 'builtin';
+        const invocationId = runtimeUsable
+            ? startInvocation({ id: body.invocationId, kind: 'flow-proposal', runtimeId })
+            : undefined;
         // Attachment analysis needs a real agent runtime; the keyword fallback
         // below can only match already published capabilities.
         if (multipart && !runtimeUsable)
@@ -396,16 +416,21 @@ export function createApp(store = new Store(), requestedWorkspaceRoot = process.
             let response;
             try {
                 response = multipart
-                    ? await runtimes.executeAnalysis(runtimeId, prompt, input, deadline, { cwd: multipart.root, allowedRoot: multipart.root }, flowProposalOutputSchema(true))
-                    : await runtimes.execute(runtimeId, prompt, input, deadline, [], flowProposalOutputSchema(false), { workspaceRoot });
+                    ? await runtimes.executeAnalysis(runtimeId, prompt, input, deadline, { cwd: multipart.root, allowedRoot: multipart.root }, flowProposalOutputSchema(true), invocationId ? traceFor(invocationId) : undefined)
+                    : await runtimes.execute(runtimeId, prompt, input, deadline, [], flowProposalOutputSchema(false), { workspaceRoot }, invocationId ? traceFor(invocationId) : undefined);
             }
             catch (error) {
                 await discard();
+                if (invocationId)
+                    store.setAgentInvocation(invocationId, 'failed', undefined, error instanceof Error ? error.message : String(error));
                 throw error;
             }
             const proposal = response;
-            if (!proposal || typeof proposal !== 'object' || !Array.isArray(proposal.stages))
+            if (!proposal || typeof proposal !== 'object' || !Array.isArray(proposal.stages)) {
+                if (invocationId)
+                    store.setAgentInvocation(invocationId, 'failed', undefined, 'RUNTIME_PROPOSAL_INVALID');
                 throw await failing('RUNTIME_PROPOSAL_INVALID');
+            }
             if (multipart) {
                 const failures = collectGroundingFailures(proposal, multipart.contents);
                 if (failures.length) {
@@ -418,11 +443,17 @@ export function createApp(store = new Store(), requestedWorkspaceRoot = process.
                         })),
                     }, 'flow proposal rejected: stages not grounded in the uploaded source');
                     await discard();
-                    throw groundingError(failures, proposal);
+                    const error = groundingError(failures, proposal);
+                    if (invocationId)
+                        store.setAgentInvocation(invocationId, 'failed', undefined, error.message);
+                    throw error;
                 }
             }
             const graph = buildProposalGraph(proposal.stages, { catalog, runtimeId });
-            return asProposal(graph, String(proposal.flowName ?? objective), String(proposal.summary ?? 'Runtime 已生成可审阅的 Flow 草案。').slice(0, 1000));
+            const result = await asProposal(graph, String(proposal.flowName ?? objective), String(proposal.summary ?? 'Runtime 已生成可审阅的 Flow 草案。').slice(0, 1000), invocationId ? { invocationId } : {});
+            if (invocationId)
+                store.setAgentInvocation(invocationId, 'completed', result);
+            return result;
         }
         const matched = matchPublishedCapabilities(objective, catalog);
         if (!matched.length)
@@ -454,6 +485,13 @@ export function createApp(store = new Store(), requestedWorkspaceRoot = process.
         const health = await runtimes.health(runtimeId);
         if (health.status !== 'available')
             return { ...fallback, fallback: true };
+        const invocationId = startInvocation({
+            id: req.body.invocationId,
+            kind: 'flow-assistant',
+            runtimeId,
+            flowId: request.flowDraft.flowId,
+            messageId: req.body.messageId,
+        });
         const availableRuntimes = [];
         for (const item of runtimes.profiles()) {
             if (!item.enabled)
@@ -463,19 +501,48 @@ export function createApp(store = new Store(), requestedWorkspaceRoot = process.
                 availableRuntimes.push({ id: item.id, name: item.name });
         }
         const grounded = Boolean(req.body.attachments?.length);
-        const response = await runtimes.execute(runtimeId, flowAgentPrompt(message, grounded), flowAgentContext({ ...request, message }, availableRuntimes, catalog), AbortSignal.timeout(runtimes.settings().testTimeoutMs), [], flowAgentOutputSchema(grounded), { workspaceRoot });
-        const normalized = normalizeAgentResponse(response);
-        if (normalized.intent === 'answer')
-            return { ...normalized, runtimeId };
-        if (grounded)
-            assertAttachmentGrounding(normalized, req.body.attachments ?? []);
-        const revised = applyFlowRevision(request.flowDraft, request.cfDrafts ?? [], normalized.stages, { catalog, runtimeId });
+        let response;
+        try {
+            response = await runtimes.execute(runtimeId, flowAgentPrompt(message, grounded), flowAgentContext({ ...request, message }, availableRuntimes, catalog), AbortSignal.timeout(runtimes.settings().testTimeoutMs), [], flowAgentOutputSchema(grounded), { workspaceRoot }, traceFor(invocationId));
+        }
+        catch (error) {
+            store.setAgentInvocation(invocationId, 'failed', undefined, error instanceof Error ? error.message : String(error));
+            throw error;
+        }
+        let normalized;
+        try {
+            normalized = normalizeAgentResponse(response);
+        }
+        catch (error) {
+            store.setAgentInvocation(invocationId, 'failed', undefined, error instanceof Error ? error.message : String(error));
+            throw error;
+        }
+        if (normalized.intent === 'answer') {
+            const result = { ...normalized, runtimeId, invocationId };
+            store.setAgentInvocation(invocationId, 'completed', result);
+            return result;
+        }
+        let revised;
+        try {
+            if (grounded)
+                assertAttachmentGrounding(normalized, req.body.attachments ?? []);
+            revised = applyFlowRevision(request.flowDraft, request.cfDrafts ?? [], normalized.stages, {
+                catalog,
+                runtimeId,
+            });
+        }
+        catch (error) {
+            store.setAgentInvocation(invocationId, 'failed', undefined, error instanceof Error ? error.message : String(error));
+            throw error;
+        }
         store.db.transaction(() => {
             for (const draft of revised.cfDrafts)
                 store.save('cf_drafts', draft.cfId, draft);
             store.save('flow_drafts', revised.flowDraft.flowId, revised.flowDraft);
         })();
-        return { ...normalized, ...revised, runtimeId };
+        const result = { ...normalized, ...revised, runtimeId, invocationId };
+        store.setAgentInvocation(invocationId, 'completed', result);
+        return result;
     });
     app.get('/api/runs', async () => store.runs());
     app.get('/api/resources', async () => store.resourceProfiles());
@@ -584,7 +651,48 @@ export function createApp(store = new Store(), requestedWorkspaceRoot = process.
         const run = store.getRun(req.params.id);
         if (!run)
             return reply.code(404).send({ error: 'RUN_NOT_FOUND' });
-        return { run, events: store.events(req.params.id) };
+        return {
+            run,
+            events: store.events(req.params.id),
+            invocations: store.agentInvocationsForRun(req.params.id),
+        };
+    });
+    app.get('/api/agent-invocations/:id', async (req, reply) => {
+        const invocation = store.agentInvocation(req.params.id);
+        if (!invocation)
+            return reply.code(404).send({ error: 'AGENT_INVOCATION_NOT_FOUND' });
+        return { invocation, events: store.agentTraceEvents(req.params.id) };
+    });
+    app.get('/api/agent-invocations/:id/events', async (req, reply) => {
+        if (!store.agentInvocation(req.params.id))
+            return reply.code(404).send({ error: 'AGENT_INVOCATION_NOT_FOUND' });
+        reply.raw.writeHead(200, {
+            'content-type': 'text/event-stream',
+            'cache-control': 'no-cache',
+            connection: 'keep-alive',
+        });
+        let sent = Number(req.headers['last-event-id'] ?? 0);
+        const flush = () => {
+            for (const event of store.agentTraceEvents(req.params.id).filter((item) => item.seq > sent)) {
+                reply.raw.write(`id: ${event.seq}\ndata: ${JSON.stringify(event)}\n\n`);
+                sent = event.seq;
+            }
+            const invocation = store.agentInvocation(req.params.id);
+            if (invocation && !['queued', 'running'].includes(invocation.status)) {
+                reply.raw.write(`event: complete\ndata: ${JSON.stringify(invocation)}\n\n`);
+                return true;
+            }
+            return false;
+        };
+        if (flush())
+            return reply.raw.end();
+        const timer = setInterval(() => {
+            if (flush()) {
+                clearInterval(timer);
+                reply.raw.end();
+            }
+        }, 100);
+        req.raw.on('close', () => clearInterval(timer));
     });
     app.get('/api/runs/:id/events', async (req, reply) => {
         reply.raw.writeHead(200, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hmj-ai/cflow",
-  "version": "1.3.7",
+  "version": "1.3.9",
   "description": "以 Flow 为核心的本机多 Agent 编排工作台",
   "main": "dist/src/server.js",
   "bin": {