flzxsqc-demo 1.4.21 → 1.4.23

package/agent-backend/src/main/java/com/example/agent/infrastructure/llm/DummyLlmClient.java

@@ -26,6 +26,7 @@ import org.springframework.stereotype.Component;
 import org.springframework.web.reactive.function.client.WebClient;
 import org.springframework.web.reactive.function.client.WebClientRequestException;
 import org.springframework.web.reactive.function.client.WebClientResponseException;
+import reactor.core.publisher.Flux;
 import reactor.netty.http.client.HttpClient;
 
 import java.util.ArrayList;
@@ -152,8 +153,18 @@ public class DummyLlmClient implements LlmClient {
                 .accept(MediaType.TEXT_EVENT_STREAM)
                 .headers(headers -> headers.setBearerAuth(resolvedModel.apiKey))
                 .bodyValue(body)
-                .retrieve()
-                .bodyToFlux(STRING_SSE_TYPE)
+                .exchangeToFlux(response -> {
+                    int status = response.rawStatusCode();
+                    if (status < 200 || status >= 300) {
+                        return response.bodyToMono(String.class)
+                                .defaultIfEmpty("")
+                                .flatMapMany(errorBody -> Flux.error(new LlmApiException(
+                                        resolvedModel.provider,
+                                        status,
+                                        responsePreview(errorBody))));
+                    }
+                    return response.bodyToFlux(STRING_SSE_TYPE);
+                })
                 .collectList()
                 .block();
         return assembleStreamingResponse(events == null ? Collections.<ServerSentEvent<String>>emptyList() : events);
@@ -288,6 +299,11 @@ public class DummyLlmClient implements LlmClient {
         if (!properties.getRetry().isEnabled() || attempt >= maxAttempts) {
             return false;
         }
+        if (ex instanceof LlmApiException) {
+            LlmApiException apiException = (LlmApiException) ex;
+            int status = apiException.statusCode;
+            return status == 408 || status == 409 || status == 429 || status >= 500 || isTokenRateLimit(status, apiException.responseBody);
+        }
         if (ex instanceof WebClientRequestException) {
             return true;
         }
@@ -305,7 +321,7 @@ public class DummyLlmClient implements LlmClient {
         long jitterMs = Math.max(0L, properties.getRetry().getJitterMs());
         long exponentialFactor = 1L << Math.max(0, attempt - 1);
         long backoffMs = Math.min(maxBackoffMs, initialBackoffMs * exponentialFactor);
-        if (ex instanceof WebClientResponseException && isTokenRateLimit((WebClientResponseException) ex)) {
+        if (isTokenRateLimitException(ex)) {
             backoffMs = Math.max(backoffMs, Math.max(0L, properties.getRetry().getTokenLimitBackoffMs()));
         }
         if (jitterMs <= 0L) {
@@ -318,10 +334,21 @@ public class DummyLlmClient implements LlmClient {
         if (ex == null) {
             return false;
         }
-        if (ex.getRawStatusCode() == 432) {
+        return isTokenRateLimit(ex.getRawStatusCode(), ex.getResponseBodyAsString());
+    }
+
+    private boolean isTokenRateLimitException(Exception ex) {
+        if (ex instanceof LlmApiException) {
+            LlmApiException apiException = (LlmApiException) ex;
+            return isTokenRateLimit(apiException.statusCode, apiException.responseBody);
+        }
+        return ex instanceof WebClientResponseException && isTokenRateLimit((WebClientResponseException) ex);
+    }
+
+    private boolean isTokenRateLimit(int statusCode, String body) {
+        if (statusCode == 432) {
             return true;
         }
-        String body = ex.getResponseBodyAsString();
         return body != null && (body.contains("\"returnCode\":\"0432\"")
                 || body.contains("\"returnCode\": \"0432\"")
                 || body.contains("输入Token数已达到每分钟上限"));
@@ -340,6 +367,10 @@ public class DummyLlmClient implements LlmClient {
     }
 
     private String summarizeException(Exception ex) {
+        if (ex instanceof LlmApiException) {
+            LlmApiException apiException = (LlmApiException) ex;
+            return apiException.statusCode + " " + apiException.responseBody;
+        }
         if (ex instanceof WebClientResponseException) {
             WebClientResponseException responseException = (WebClientResponseException) ex;
             return responseException.getRawStatusCode() + " " + responseException.getStatusText();
@@ -349,14 +380,18 @@ public class DummyLlmClient implements LlmClient {
 
     private List<Map<String, Object>> toApiMessages(List<ChatMessage> messages) {
         List<Map<String, Object>> list = new ArrayList<>();
-        boolean seenNonSystemMessage = false;
+        boolean emittedInitialSystemMessage = false;
         for (ChatMessage msg : messages) {
             ChatRole originalRole = msg.getRole();
             ChatRole apiRole = originalRole;
             String content = msg.getContent();
-            if (originalRole == ChatRole.SYSTEM && seenNonSystemMessage) {
-                apiRole = ChatRole.USER;
-                content = lateSystemContentAsUser(content);
+            if (originalRole == ChatRole.SYSTEM) {
+                if (list.isEmpty() && !emittedInitialSystemMessage) {
+                    emittedInitialSystemMessage = true;
+                } else {
+                    apiRole = ChatRole.USER;
+                    content = lateSystemContentAsUser(content);
+                }
             }
             Map<String, Object> m = new HashMap<>();
             m.put("role", apiRole.getCode());
@@ -382,9 +417,6 @@ public class DummyLlmClient implements LlmClient {
                 m.put("tool_calls", toolCalls);
             }
             list.add(m);
-            if (originalRole != ChatRole.SYSTEM) {
-                seenNonSystemMessage = true;
-            }
         }
         return list;
     }
@@ -527,4 +559,15 @@ public class DummyLlmClient implements LlmClient {
         StringBuilder name = new StringBuilder();
         StringBuilder arguments = new StringBuilder();
     }
+
+    private static class LlmApiException extends RuntimeException {
+        final int statusCode;
+        final String responseBody;
+
+        LlmApiException(String provider, int statusCode, String responseBody) {
+            super(provider + " API error: HTTP " + statusCode + " response=" + responseBody);
+            this.statusCode = statusCode;
+            this.responseBody = responseBody;
+        }
+    }
 }

package/agent-backend/src/test/java/com/example/agent/infrastructure/llm/DummyLlmClientTest.java

@@ -114,7 +114,7 @@ public class DummyLlmClientTest {
     }
 
     @Test
-    public void convertsSystemMessagesAfterConversationStartToUserMessages() throws Exception {
+    public void convertsAdditionalSystemMessagesToUserMessages() throws Exception {
         try (TestLlmServer server = new TestLlmServer()) {
             server.enqueue(200, "text/event-stream", streamContent("ok"));
 
@@ -129,8 +129,9 @@ public class DummyLlmClientTest {
             JsonNode messages = OBJECT_MAPPER.readTree(server.requestBody(0)).path("messages");
             assertEquals("system", messages.get(0).path("role").asText());
             assertEquals("initial system", messages.get(0).path("content").asText());
-            assertEquals("system", messages.get(1).path("role").asText());
-            assertEquals("second system", messages.get(1).path("content").asText());
+            assertEquals("user", messages.get(1).path("role").asText());
+            assertTrue(messages.get(1).path("content").asText().contains("Runtime instruction from system channel"));
+            assertTrue(messages.get(1).path("content").asText().contains("second system"));
             assertEquals("user", messages.get(2).path("role").asText());
             assertEquals("hello", messages.get(2).path("content").asText());
             assertEquals("user", messages.get(3).path("role").asText());

package/agent-front-react/doc/analysis-progress-bubble-company-migration.md

@@ -0,0 +1,394 @@
+# 分析对话临时助手气泡：公司版本迁移操作说明
+
+## 1. 文档目的
+
+本文说明如何把当前前端已经实现的“运行中临时助手气泡”迁移到公司版本。
+
+该能力用于解决分析任务执行时间较长时，用户无法判断页面是卡住还是任务仍在运行的问题。前端根据 Session 状态和 SSE 运行事件，展示与当前步骤对应的提示文案，并在同一阶段内每 8 秒轮播一次。
+
+当前工程的参考实现位于：
+
+- `src/pages/analysis-task/useAnalysisProgress.ts`：状态推导和文案轮播。
+- `src/pages/AnalysisTaskPage.tsx`：接收事件并生成进度状态。
+- `src/pages/analysis-task/TaskConversationTab.tsx`：渲染临时助手气泡。
+- `src/pages/analysis-task/analysisTaskUtils.tsx`：真实聊天消息整理，已移除旧的固定占位消息。
+- `src/styles.css`：气泡、动态圆点和无障碍降级样式。
+
+## 2. 迁移边界
+
+本次迁移应保持为前端能力：
+
+- 不修改后端接口、数据库或任务执行逻辑。
+- 不向 `session.transcript` 添加提示文案。
+- 不把提示文案保存到历史记录、报告或 DSL。
+- 不修改真实的用户消息和助手消息结构。
+- 不显示百分比、预计完成时间或“马上完成”等无法由后端保证的信息。
+
+只有在公司版本没有提供运行事件时，才需要后端补充等价事件；如果公司版本已有类似 SSE/WebSocket 事件，只需要在前端建立字段适配。
+
+## 3. 运行机制
+
+数据流如下：
+
+```text
+Session 状态 + 当前 Session 的运行事件
+                  │
+                  ▼
+     useAnalysisProgress 状态推导
+                  │
+          阶段 + 提示文案 + 标签
+                  │
+                  ▼
+       TaskConversationTab 临时气泡
+                  │
+        真实答案或终态出现后卸载
+```
+
+临时气泡是独立的 UI 状态，不是 `ChatMessage`。因此即使它显示在对话区域中，也不会被保存或回传给后端。
+
+## 4. 公司版本迁移前提
+
+迁移前先在公司版本中找到以下等价对象：
+
+| 当前工程对象 | 公司版本需要找到的等价对象 | 必需字段 |
+|---|---|---|
+| `AgentSession` | 当前分析任务或会话 | `sessionId`、`status` |
+| `RuntimeEvent` | SSE/WebSocket 运行事件 | `id`、`sessionId`、`turnId`、`eventType`、`payload` |
+| `activeSession` | 当前打开的任务 | 当前状态必须能实时刷新 |
+| `events` | 当前任务的事件列表 | 能按事件 ID 或时间排序 |
+| `TaskConversationTab` | 对话内容组件 | 可以在消息列表和输入框之间插入状态 UI |
+
+建议公司版本提供或适配以下状态：
+
+```ts
+type SessionStatus =
+  | "RUNNING"
+  | "WAITING_ASYNC_CALLBACK"
+  | "WAITING_USER_INPUT"
+  | "SUCCEEDED"
+  | "FAILED";
+```
+
+如果公司版本的名称不同，在页面层转换为以上语义即可，不要为了迁移 UI 修改后端枚举。
+
+## 5. 阶段映射规则
+
+当前实现包含以下前端展示阶段：
+
+```ts
+type AnalysisProgressPhase =
+  | "PREPARING"
+  | "PLANNING"
+  | "RETRIEVING"
+  | "ANALYZING"
+  | "AGGREGATING"
+  | "REPORTING"
+  | "WAITING_ASYNC"
+  | "PROCESSING_RESULTS"
+  | "RECOVERING"
+  | "PROCESSING";
+```
+
+事件映射规则：
+
+| 运行事件或工具名称 | 展示阶段 |
+|---|---|
+| `SESSION_STARTED`、`TURN_STARTED` | `PREPARING` |
+| `MODEL_DECISION` | `PLANNING` |
+| `query_*`、`sample_*`、`search_*` | `RETRIEVING` |
+| `analyze_*` | `ANALYZING` |
+| `aggregate_*`、`cluster_*` | `AGGREGATING` |
+| 工具名包含 `report`，或 `final_response` | `REPORTING` |
+| `WAITING_ASYNC_CALLBACK` | `WAITING_ASYNC` |
+| `TOOL_CALLBACK_RECEIVED`、`TOOL_EXECUTION_FINISHED` | `PROCESSING_RESULTS` |
+| `TOOL_EXECUTION_FAILED`，但 Session 仍为运行态 | `RECOVERING` |
+| 未识别的运行步骤 | `PROCESSING` |
+
+Harness 阶段映射：
+
+| `payload.phase` | 展示阶段 |
+|---|---|
+| `INTENT_RECOGNITION`、`SKILL_ROUTING`、`QUESTION_REQUIREMENT_VALIDATION` | `PREPARING` |
+| `PLAN_NEXT_ACTION`、`TOOL_CALL_VALIDATION`、`COMPLETION_VALIDATION` | `PLANNING` |
+| `RESULT_VALIDATION` | `PROCESSING_RESULTS` |
+| `RESULT_ASSEMBLY`、`FINALIZE` | `REPORTING` |
+| `WAITING_ASYNC_CALLBACK` | `WAITING_ASYNC` |
+| `TOOL_EXECUTION` | `PROCESSING` |
+
+公司版本如果没有 Harness 事件，可以只保留 Session、模型、工具和异步事件映射，不影响基本能力。
+
+## 6. 具体代码修改步骤
+
+### 6.1 新增状态推导 Hook
+
+在公司版本的分析任务模块中新增 `useAnalysisProgress.ts`。可以直接复制当前工程的：
+
+```text
+src/pages/analysis-task/useAnalysisProgress.ts
+```
+
+复制后只需要调整 `AgentSession`、`RuntimeEvent` 的 import 路径和字段名称。
+
+Hook 的核心处理顺序必须保留：
+
+1. 仅在 `RUNNING` 或 `WAITING_ASYNC_CALLBACK` 时生成进度状态。
+2. 过滤出当前 Session 的事件，并按事件 ID 升序排列。
+3. 找到最后一个 `TURN_STARTED`，只处理这个 Turn 之后的事件。
+4. 当前 Turn 已出现真实助手答案、等待用户输入或终态时，返回 `null`。
+5. 按最新有效事件推导展示阶段。
+6. 使用 `sessionId + turnId + phase` 作为轮播键；切换任务、Turn 或阶段时从第一条文案重新开始。
+7. 每 8 秒切换同阶段的下一条文案，并在组件卸载或阶段变化时清理定时器。
+
+关键逻辑参考：
+
+```ts
+const sessionEvents = events
+  .filter((event) => event.sessionId === session.sessionId)
+  .sort((left, right) => left.id - right.id);
+
+const lastTurnStartIndex = findLastIndex(
+  sessionEvents,
+  (event) => event.eventType === "TURN_STARTED",
+);
+
+const turnEvents = lastTurnStartIndex >= 0
+  ? sessionEvents.slice(lastTurnStartIndex)
+  : sessionEvents;
+```
+
+异步状态需要特别处理：Session 刷新可能晚于回调事件。如果 `TOOL_CALLBACK_RECEIVED` 已经出现在最近一次 `WAITING_ASYNC_CALLBACK` 之后，应显示“继续处理结果”，不能继续显示“等待后台结果”。
+
+真实结果和终态的隐藏规则参考：
+
+```ts
+if (
+  event.eventType === "ASSISTANT_MESSAGE"
+  || event.eventType === "WAITING_USER_INPUT"
+) {
+  return null;
+}
+
+// TURN_FINISHED 的 status 为以下值时也隐藏：
+// SUCCEEDED、FAILED、WAITING_USER_INPUT
+```
+
+### 6.2 保留步骤感知文案池
+
+每个阶段维护三条文案，当前实现位于 `PHASE_MESSAGES`。公司版本可以替换措辞，但需要遵循以下规则：
+
+- 描述正在执行的动作，不承诺完成时间。
+- 不暴露内部工具名称、参数、异常堆栈或敏感字段。
+- 异步阶段明确告诉用户任务仍在后台执行。
+- 恢复阶段只说明正在调整处理路径，不直接向用户展示内部失败。
+- 同阶段顺序轮播，不使用完全随机选择，避免连续重复和测试不稳定。
+
+轮播间隔保持为：
+
+```ts
+const MESSAGE_ROTATION_INTERVAL_MS = 8_000;
+```
+
+### 6.3 在分析任务页面接入 Hook
+
+在公司版本的分析任务页面引入 Hook：
+
+```ts
+import { useAnalysisProgress } from "./analysis-task/useAnalysisProgress";
+```
+
+在事件排序之后生成状态：
+
+```ts
+const sortedEvents = useMemo(
+  () => [...events].sort((a, b) => (a.id ?? 0) - (b.id ?? 0)),
+  [events],
+);
+
+const analysisProgress = useAnalysisProgress(activeSession, sortedEvents);
+```
+
+传给对话组件：
+
+```tsx
+<TaskConversationTab
+  session={activeSession}
+  messages={chatMessages}
+  progress={analysisProgress}
+  // 其他原有参数保持不变
+/>
+```
+
+公司版本必须继续把所有 SSE 事件加入本地 `events`。不要求每一种事件都触发 Session 接口刷新，因为阶段提示可以直接由本地事件更新。
+
+### 6.4 保证真实消息数组不包含临时文案
+
+聊天消息继续只从真实 transcript 和待提交用户消息生成：
+
+```ts
+const chatMessages = useMemo(
+  () => withPendingUserInputMessage(
+    activeSession,
+    visibleChatMessages(activeSession?.transcript),
+    pendingUserInputMessages,
+  ),
+  [activeSession, pendingUserInputMessages],
+);
+```
+
+如果公司版本已有类似以下逻辑，需要删除：
+
+```ts
+withStartupAssistantMessage(activeSession, chatMessages)
+```
+
+创建 Session 请求尚未返回前的固定“已收到，正在启动分析”提示可以保留。需要删除的是 Session 已创建以后、混入聊天消息数组的运行态占位消息。
+
+### 6.5 修改对话组件 Props
+
+为公司版本的对话组件增加进度参数：
+
+```ts
+interface TaskConversationTabProps {
+  session: AgentSession | null;
+  messages: ChatMessage[];
+  progress: AnalysisProgress | null;
+  // 其他原有字段
+}
+```
+
+在真实聊天列表和输入框之间渲染：
+
+```tsx
+{progress ? (
+  <div
+    className={`chat-message assistant analysis-progress-bubble${
+      progress.waitingAsync ? " waiting" : ""
+    }`}
+    role="status"
+    aria-live="polite"
+    aria-atomic="true"
+  >
+    <div className="chat-message-role analysis-progress-label">
+      <span>{progress.label}</span>
+      <span className="analysis-progress-dots" aria-hidden="true">
+        <span />
+        <span />
+        <span />
+      </span>
+    </div>
+    <div className="chat-message-content">{progress.message}</div>
+  </div>
+) : null}
+```
+
+建议把等待用户输入卡片、消息列表和临时气泡放进统一的 `conversation-content` 容器，输入框保持在容器外，避免新增气泡后破坏原 Grid 行布局。
+
+### 6.6 迁移样式
+
+从当前工程 `src/styles.css` 迁移以下样式块：
+
+- `.conversation-content`
+- `.chat-message.analysis-progress-bubble`
+- `.chat-message.analysis-progress-bubble.waiting`
+- `.analysis-progress-label`
+- `.analysis-progress-dots`
+- `@keyframes analysis-progress-enter`
+- `@keyframes analysis-progress-dot`
+- `@media (prefers-reduced-motion: reduce)` 中对应规则
+
+如果公司版本没有 `.chat-message`、`.assistant`、`.chat-message-role` 和 `.chat-message-content`，需要换成公司现有对话气泡类名。不要复制整套聊天样式，只迁移进度气泡新增部分。
+
+对话区采用 Grid 时，建议保持：
+
+```css
+.conversation-workspace {
+  display: grid;
+  grid-template-rows: minmax(0, 1fr) auto;
+  gap: 16px;
+}
+
+.conversation-content {
+  display: grid;
+  align-content: start;
+  gap: 16px;
+  min-height: 0;
+}
+```
+
+`prefers-reduced-motion` 必须保留，使关闭动画的用户看到静态圆点和文案，而不是持续动画。
+
+## 7. 公司版本字段适配建议
+
+如果公司事件结构不同，优先在 Hook 入口做一次适配，不要在每个判断分支中兼容多套字段：
+
+```ts
+interface NormalizedRuntimeEvent {
+  id: number;
+  sessionId: string;
+  turnId?: string | null;
+  eventType: string;
+  payload: Record<string, unknown>;
+}
+
+function normalizeCompanyEvent(input: CompanyRuntimeEvent): NormalizedRuntimeEvent {
+  return {
+    id: input.sequence,
+    sessionId: input.taskId,
+    turnId: input.roundId,
+    eventType: input.type,
+    payload: input.data ?? {},
+  };
+}
+```
+
+适配时需要确认：
+
+- `id` 或替代字段能够表达事件先后顺序。
+- 工具事件能够从 `payload.tool` 或等价字段读取工具名。
+- Harness 事件能够从 `payload.phase` 或等价字段读取阶段。
+- `TURN_FINISHED` 能够读取最终状态。
+- SSE 重连如果会回放历史，前端去重逻辑需要以事件 ID 为准。
+
+## 8. 验收清单
+
+### 构建检查
+
+```bash
+cd agent-front-react
+npm run build
+```
+
+### 浏览器验收
+
+- 新建分析任务后，Session 进入运行态时立即出现临时助手气泡。
+- 同一阶段持续超过 8 秒时，文案切换且不连续重复。
+- 查询、逐条分析、聚合、报告生成分别显示符合语义的文案。
+- 进入异步等待后显示“等待后台结果”，气泡保持轮播。
+- 收到工具回调后，即使 Session 接口尚未刷新，也切换为继续处理结果。
+- 收到真实 `ASSISTANT_MESSAGE` 后，临时气泡立即消失。
+- `WAITING_USER_INPUT` 时只显示原有的补充信息卡片。
+- `SUCCEEDED` 或 `FAILED` 时不显示临时气泡。
+- 切换任务、切换 Turn 或刷新页面后，没有旧文案和旧计时器残留。
+- SSE 断线重连并回放历史后，只使用最新 Turn 的事件推导状态。
+- Session 接口返回的 transcript、任务历史和 DSL 中都不存在临时文案。
+- 系统启用“减少动态效果”后，圆点不再动画，但状态和文案仍正常显示。
+
+## 9. 常见迁移错误
+
+- **把提示文案追加到 `messages` 或 transcript**：会污染历史记录，并可能被后续 LLM 当作真实上下文。
+- **只判断 Session 状态**：无法区分查询、分析、聚合等阶段，也可能在回调后继续显示异步等待。
+- **读取全部历史事件但不截取最新 Turn**：旧任务步骤会覆盖当前执行状态。
+- **每次事件到达都重启轮播计时器**：高频事件下文案永远不会切换；Effect 依赖应使用稳定的 `sessionId + turnId + phase`。
+- **显示内部工具名或异常信息**：会降低用户体验，并可能泄露内部实现。
+- **增加假进度百分比**：当前事件没有提供真实进度，不能从步骤数量推算完成比例。
+- **新增气泡后不调整 Grid 层级**：可能导致气泡占据弹性行，使消息列表或输入框位置异常。
+
+## 10. 回滚方式
+
+如果公司版本上线后需要临时回滚，只需：
+
+1. 从任务页面移除 `useAnalysisProgress()` 调用和 `progress` 参数。
+2. 从对话组件移除临时气泡 JSX。
+3. 删除新增进度样式和 Hook 文件。
+
+回滚不涉及后端、数据库、Session 数据或历史消息清理。

package/agent-front-react/src/pages/AnalysisTaskPage.tsx

@@ -51,7 +51,6 @@ import {
   normalizeManualSessionIds,
   visibleChatMessages,
   withPendingUserInputMessage,
-  withStartupAssistantMessage,
 } from "./analysis-task/analysisTaskUtils";
 import { AnalysisSampleModal } from "./analysis-task/AnalysisSampleModal";
 import { AnalysisSampleResultModal } from "./analysis-task/AnalysisSampleResultModal";
@@ -70,6 +69,7 @@ import { TaskConversationTab } from "./analysis-task/TaskConversationTab";
 import { TaskHeader } from "./analysis-task/TaskHeader";
 import { TaskReportTab } from "./analysis-task/TaskReportTab";
 import { TaskSidebar } from "./analysis-task/TaskSidebar";
+import { useAnalysisProgress } from "./analysis-task/useAnalysisProgress";
 
 const FILTER_ONLY_SOURCE_TYPE = "FILTER_ONLY";
 
@@ -253,15 +253,13 @@ export function AnalysisTaskPage() {
     () => [...events].sort((a, b) => (a.id ?? 0) - (b.id ?? 0)),
     [events],
   );
+  const analysisProgress = useAnalysisProgress(activeSession, sortedEvents);
   const chatMessages = useMemo(
     () =>
-      withStartupAssistantMessage(
+      withPendingUserInputMessage(
         activeSession,
-        withPendingUserInputMessage(
-          activeSession,
-          visibleChatMessages(activeSession?.transcript),
-          pendingUserInputMessages,
-        ),
+        visibleChatMessages(activeSession?.transcript),
+        pendingUserInputMessages,
       ),
     [activeSession, pendingUserInputMessages],
   );
@@ -814,6 +812,7 @@ export function AnalysisTaskPage() {
                     <TaskConversationTab
                       session={activeSession}
                       messages={chatMessages}
+                      progress={analysisProgress}
                       userInputText={userInputText}
                       canSubmitUserInput={canSubmitUserInput}
                       submittingUserInput={submittingUserInput}

package/agent-front-react/src/pages/analysis-task/TaskConversationTab.tsx

@@ -3,10 +3,12 @@ import type { AgentSession, ChatMessage } from "../../types";
 import { prettyJson } from "../../utils/json";
 import { ChatComposer } from "./ChatComposer";
 import { ChatMessageList } from "./ChatMessageList";
+import type { AnalysisProgress } from "./useAnalysisProgress";
 
 interface TaskConversationTabProps {
   session: AgentSession | null;
   messages: ChatMessage[];
+  progress: AnalysisProgress | null;
   userInputText: string;
   canSubmitUserInput: boolean;
   submittingUserInput: boolean;
@@ -21,6 +23,7 @@ interface TaskConversationTabProps {
 export function TaskConversationTab({
   session,
   messages,
+  progress,
   userInputText,
   canSubmitUserInput,
   submittingUserInput,
@@ -37,27 +40,48 @@ export function TaskConversationTab({
 
   return (
     <div className="conversation-workspace">
-      {session.status === "WAITING_USER_INPUT" ? (
-        <Card className="waiting-question-card" size="small">
-          <Typography.Text strong>需要你补充：</Typography.Text>
-          <div className="waiting-question-text">{session.waitingUserQuestion}</div>
-          {session.waitingUserInputContext && Object.keys(session.waitingUserInputContext).length > 0 ? (
-            <Collapse
-              ghost
-              size="small"
-              items={[
-                {
-                  key: "context",
-                  label: "查看模型提供的上下文",
-                  children: <div className="json-block">{prettyJson(session.waitingUserInputContext)}</div>,
-                },
-              ]}
-            />
-          ) : null}
-        </Card>
-      ) : null}
+      <div className="conversation-content">
+        {session.status === "WAITING_USER_INPUT" ? (
+          <Card className="waiting-question-card" size="small">
+            <Typography.Text strong>需要你补充：</Typography.Text>
+            <div className="waiting-question-text">{session.waitingUserQuestion}</div>
+            {session.waitingUserInputContext && Object.keys(session.waitingUserInputContext).length > 0 ? (
+              <Collapse
+                ghost
+                size="small"
+                items={[
+                  {
+                    key: "context",
+                    label: "查看模型提供的上下文",
+                    children: <div className="json-block">{prettyJson(session.waitingUserInputContext)}</div>,
+                  },
+                ]}
+              />
+            ) : null}
+          </Card>
+        ) : null}
 
-      <ChatMessageList messages={messages} className="workbench-chat-list" emptyDescription="暂无对话内容" />
+        <ChatMessageList messages={messages} className="workbench-chat-list" emptyDescription="暂无对话内容" />
+
+        {progress ? (
+          <div
+            className={`chat-message assistant analysis-progress-bubble${progress.waitingAsync ? " waiting" : ""}`}
+            role="status"
+            aria-live="polite"
+            aria-atomic="true"
+          >
+            <div className="chat-message-role analysis-progress-label">
+              <span>{progress.label}</span>
+              <span className="analysis-progress-dots" aria-hidden="true">
+                <span />
+                <span />
+                <span />
+              </span>
+            </div>
+            <div className="chat-message-content">{progress.message}</div>
+          </div>
+        ) : null}
+      </div>
 
       <ChatComposer
         value={userInputText}

package/agent-front-react/src/pages/analysis-task/analysisTaskUtils.tsx

@@ -8,7 +8,6 @@ import type {
   ChatMessage,
   RuntimeEvent,
 } from "../../types";
-import { ANALYSIS_STARTUP_ASSISTANT_MESSAGE } from "./analysisTaskConstants";
 import type { AnalysisFormValues } from "./analysisTaskTypes";
 
 export function mergeBatchContext(
@@ -54,27 +53,6 @@ export function visibleChatMessages(transcript?: ChatMessage[] | null): ChatMess
   );
 }
 
-export function withStartupAssistantMessage(
-  session: AgentSession | null,
-  messages: ChatMessage[],
-): ChatMessage[] {
-  if (!session || (session.status !== "RUNNING" && session.status !== "WAITING_ASYNC_CALLBACK")) {
-    return messages;
-  }
-  const hasUserMessage = messages.some((item) => item.role === "user");
-  const hasAssistantMessage = messages.some((item) => item.role === "assistant" && Boolean(item.content?.trim()));
-  if (!hasUserMessage || hasAssistantMessage) {
-    return messages;
-  }
-  return [
-    ...messages,
-    {
-      role: "assistant",
-      content: ANALYSIS_STARTUP_ASSISTANT_MESSAGE,
-    },
-  ];
-}
-
 export function withPendingUserInputMessage(
   session: AgentSession | null,
   messages: ChatMessage[],

package/agent-front-react/src/pages/analysis-task/useAnalysisProgress.ts

@@ -0,0 +1,271 @@
+import { useEffect, useMemo, useState } from "react";
+import type { AgentSession, RuntimeEvent } from "../../types";
+
+const MESSAGE_ROTATION_INTERVAL_MS = 8_000;
+
+export type AnalysisProgressPhase =
+  | "PREPARING"
+  | "PLANNING"
+  | "RETRIEVING"
+  | "ANALYZING"
+  | "AGGREGATING"
+  | "REPORTING"
+  | "WAITING_ASYNC"
+  | "PROCESSING_RESULTS"
+  | "RECOVERING"
+  | "PROCESSING";
+
+export interface AnalysisProgress {
+  phase: AnalysisProgressPhase;
+  label: string;
+  message: string;
+  waitingAsync: boolean;
+}
+
+interface AnalysisProgressContext {
+  phase: AnalysisProgressPhase;
+  turnId: string | null;
+}
+
+const PHASE_MESSAGES: Record<AnalysisProgressPhase, string[]> = {
+  PREPARING: [
+    "正在梳理你的分析目标…",
+    "正在确认数据范围和执行路径…",
+    "正在准备本次分析所需的信息…",
+  ],
+  PLANNING: [
+    "正在规划下一步分析步骤…",
+    "正在核对当前结果并安排后续处理…",
+    "正在选择合适的分析方式…",
+  ],
+  RETRIEVING: [
+    "正在筛选并核对相关会话…",
+    "正在读取命中的会话数据…",
+    "正在整理可用于分析的样本…",
+  ],
+  ANALYZING: [
+    "正在逐条分析会话中的关键信息…",
+    "正在提取意图、原因和相关依据…",
+    "正在深入核对会话内容…",
+  ],
+  AGGREGATING: [
+    "正在归纳相似问题和共同特征…",
+    "正在汇总分类结果与代表样本…",
+    "正在核对各类结果的数量和依据…",
+  ],
+  REPORTING: [
+    "正在整理分析结论和报告结构…",
+    "正在核对数据依据并组织最终结果…",
+    "正在生成便于阅读的分析报告…",
+  ],
+  WAITING_ASYNC: [
+    "分析任务仍在后台执行，结果返回后会自动继续…",
+    "后台分析仍在处理中，返回后将继续完成后续步骤…",
+    "正在等待后台结果，本页会在结果返回后自动更新…",
+  ],
+  PROCESSING_RESULTS: [
+    "后台结果已返回，正在继续处理…",
+    "正在校验返回结果并衔接后续分析…",
+    "正在把最新结果纳入本轮分析…",
+  ],
+  RECOVERING: [
+    "当前步骤未完成，正在调整分析路径…",
+    "正在根据执行反馈重新检查下一步…",
+    "正在尝试用更合适的方式继续处理…",
+  ],
+  PROCESSING: [
+    "当前分析步骤正在执行…",
+    "正在处理本轮分析所需的信息…",
+    "任务仍在继续，请稍候…",
+  ],
+};
+
+export function useAnalysisProgress(
+  session: AgentSession | null,
+  events: RuntimeEvent[],
+): AnalysisProgress | null {
+  const context = useMemo(() => deriveAnalysisProgressContext(session, events), [events, session]);
+  const rotationKey = context
+    ? `${session?.sessionId ?? ""}:${context.turnId ?? ""}:${context.phase}`
+    : "";
+  const activePhase = context?.phase;
+  const [rotation, setRotation] = useState({ key: "", index: 0 });
+
+  useEffect(() => {
+    if (!activePhase || !rotationKey) {
+      return;
+    }
+    const messageCount = PHASE_MESSAGES[activePhase].length;
+    setRotation({ key: rotationKey, index: 0 });
+    const timer = window.setInterval(() => {
+      setRotation((current) => ({
+        key: rotationKey,
+        index: current.key === rotationKey ? (current.index + 1) % messageCount : 0,
+      }));
+    }, MESSAGE_ROTATION_INTERVAL_MS);
+    return () => window.clearInterval(timer);
+  }, [activePhase, rotationKey]);
+
+  if (!context) {
+    return null;
+  }
+  const messages = PHASE_MESSAGES[context.phase];
+  const messageIndex = rotation.key === rotationKey ? rotation.index : 0;
+  const waitingAsync = context.phase === "WAITING_ASYNC";
+  return {
+    phase: context.phase,
+    label: waitingAsync ? "助手 · 等待后台结果" : "助手 · 分析中",
+    message: messages[messageIndex],
+    waitingAsync,
+  };
+}
+
+export function deriveAnalysisProgressContext(
+  session: AgentSession | null,
+  events: RuntimeEvent[],
+): AnalysisProgressContext | null {
+  if (!session || (session.status !== "RUNNING" && session.status !== "WAITING_ASYNC_CALLBACK")) {
+    return null;
+  }
+
+  const sessionEvents = events
+    .filter((event) => event.sessionId === session.sessionId)
+    .sort((left, right) => left.id - right.id);
+  const lastTurnStartIndex = findLastIndex(sessionEvents, (event) => event.eventType === "TURN_STARTED");
+  const turnEvents = lastTurnStartIndex >= 0 ? sessionEvents.slice(lastTurnStartIndex) : sessionEvents;
+  const turnId = turnEvents.find((event) => event.eventType === "TURN_STARTED")?.turnId
+    ?? turnEvents[turnEvents.length - 1]?.turnId
+    ?? null;
+
+  if (hasCompletedOrPausedTurn(turnEvents)) {
+    return null;
+  }
+
+  const lastWaitingIndex = findLastIndex(
+    turnEvents,
+    (event) => event.eventType === "WAITING_ASYNC_CALLBACK",
+  );
+  const lastCallbackIndex = findLastIndex(
+    turnEvents,
+    (event) => event.eventType === "TOOL_CALLBACK_RECEIVED",
+  );
+  if (
+    session.status === "WAITING_ASYNC_CALLBACK"
+    && (lastTurnStartIndex < 0 || (lastWaitingIndex >= 0 && lastCallbackIndex <= lastWaitingIndex))
+  ) {
+    return { phase: "WAITING_ASYNC", turnId };
+  }
+
+  for (let index = turnEvents.length - 1; index >= 0; index -= 1) {
+    const phase = phaseForEvent(turnEvents[index]);
+    if (phase) {
+      return { phase, turnId };
+    }
+  }
+  return { phase: "PREPARING", turnId };
+}
+
+function hasCompletedOrPausedTurn(events: RuntimeEvent[]): boolean {
+  if (events.some((event) => event.eventType === "ASSISTANT_MESSAGE" || event.eventType === "WAITING_USER_INPUT")) {
+    return true;
+  }
+  const lastFinished = [...events].reverse().find((event) => event.eventType === "TURN_FINISHED");
+  if (!lastFinished) {
+    return false;
+  }
+  const status = payloadString(lastFinished, "status");
+  return status === "SUCCEEDED" || status === "FAILED" || status === "WAITING_USER_INPUT";
+}
+
+function phaseForEvent(event: RuntimeEvent): AnalysisProgressPhase | null {
+  if (event.eventType === "SESSION_STARTED" || event.eventType === "TURN_STARTED") {
+    return "PREPARING";
+  }
+  if (event.eventType === "MODEL_DECISION") {
+    return "PLANNING";
+  }
+  if (event.eventType === "TOOL_CALL_REQUESTED" || event.eventType === "TOOL_EXECUTION_STARTED") {
+    return phaseForTool(payloadString(event, "tool"));
+  }
+  if (event.eventType === "TOOL_CALLBACK_RECEIVED" || event.eventType === "TOOL_EXECUTION_FINISHED") {
+    return "PROCESSING_RESULTS";
+  }
+  if (event.eventType === "TOOL_EXECUTION_FAILED") {
+    return "RECOVERING";
+  }
+  if (event.eventType === "WAITING_ASYNC_CALLBACK") {
+    return "WAITING_ASYNC";
+  }
+  if (event.eventType === "HARNESS_PHASE_STARTED" || event.eventType === "HARNESS_PHASE_FINISHED") {
+    if (event.eventType === "HARNESS_PHASE_FINISHED" && payloadString(event, "phase") === "TOOL_EXECUTION") {
+      return "PROCESSING_RESULTS";
+    }
+    return phaseForHarness(payloadString(event, "phase"));
+  }
+  return null;
+}
+
+function phaseForTool(toolName: string | null): AnalysisProgressPhase {
+  const normalized = toolName?.toLowerCase() ?? "";
+  if (
+    normalized.startsWith("query_")
+    || normalized.startsWith("sample_")
+    || normalized.startsWith("search_")
+  ) {
+    return "RETRIEVING";
+  }
+  if (normalized.startsWith("analyze_")) {
+    return "ANALYZING";
+  }
+  if (normalized.startsWith("aggregate_") || normalized.startsWith("cluster_")) {
+    return "AGGREGATING";
+  }
+  if (normalized.includes("report") || normalized === "final_response") {
+    return "REPORTING";
+  }
+  return "PROCESSING";
+}
+
+function phaseForHarness(phase: string | null): AnalysisProgressPhase | null {
+  if (
+    phase === "INTENT_RECOGNITION"
+    || phase === "SKILL_ROUTING"
+    || phase === "QUESTION_REQUIREMENT_VALIDATION"
+  ) {
+    return "PREPARING";
+  }
+  if (
+    phase === "PLAN_NEXT_ACTION"
+    || phase === "TOOL_CALL_VALIDATION"
+    || phase === "COMPLETION_VALIDATION"
+  ) {
+    return "PLANNING";
+  }
+  if (phase === "RESULT_VALIDATION") {
+    return "PROCESSING_RESULTS";
+  }
+  if (phase === "RESULT_ASSEMBLY" || phase === "FINALIZE") {
+    return "REPORTING";
+  }
+  if (phase === "WAITING_ASYNC_CALLBACK") {
+    return "WAITING_ASYNC";
+  }
+  if (phase === "TOOL_EXECUTION") {
+    return "PROCESSING";
+  }
+  return null;
+}
+
+function payloadString(event: RuntimeEvent, key: string): string | null {
+  const value = event.payload?.[key];
+  return typeof value === "string" ? value : null;
+}
+
+function findLastIndex<T>(items: T[], predicate: (item: T) => boolean): number {
+  for (let index = items.length - 1; index >= 0; index -= 1) {
+    if (predicate(items[index])) {
+      return index;
+    }
+  }
+  return -1;
+}

package/agent-front-react/src/styles.css

@@ -581,11 +581,18 @@ body {
 
 .conversation-workspace {
   display: grid;
-  grid-template-rows: auto 1fr auto;
+  grid-template-rows: minmax(0, 1fr) auto;
   gap: 16px;
   min-height: 560px;
 }
 
+.conversation-content {
+  display: grid;
+  align-content: start;
+  gap: 16px;
+  min-height: 0;
+}
+
 .draft-workspace-card {
   display: grid;
 }
@@ -627,6 +634,78 @@ body {
   padding: 4px 8px 4px 0;
 }
 
+.chat-message.analysis-progress-bubble {
+  border-color: #cbdcf7;
+  background: linear-gradient(135deg, #f5f9ff, #f8fbff);
+  box-shadow: 0 8px 24px rgba(55, 93, 154, 0.08);
+  animation: analysis-progress-enter 0.2s ease-out;
+}
+
+.chat-message.analysis-progress-bubble.waiting {
+  border-color: #f0d28c;
+  background: linear-gradient(135deg, #fff9e9, #fffdf6);
+}
+
+.analysis-progress-label {
+  display: flex;
+  align-items: center;
+  gap: 7px;
+}
+
+.analysis-progress-dots {
+  display: inline-flex;
+  align-items: center;
+  gap: 3px;
+}
+
+.analysis-progress-dots > span {
+  width: 4px;
+  height: 4px;
+  border-radius: 50%;
+  background: currentColor;
+  opacity: 0.28;
+  animation: analysis-progress-dot 1.2s ease-in-out infinite;
+}
+
+.analysis-progress-dots > span:nth-child(2) {
+  animation-delay: 0.16s;
+}
+
+.analysis-progress-dots > span:nth-child(3) {
+  animation-delay: 0.32s;
+}
+
+@keyframes analysis-progress-enter {
+  from {
+    opacity: 0;
+    transform: translateY(4px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+@keyframes analysis-progress-dot {
+  0%,
+  60%,
+  100% {
+    opacity: 0.28;
+    transform: translateY(0);
+  }
+  30% {
+    opacity: 0.9;
+    transform: translateY(-2px);
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .analysis-progress-bubble,
+  .analysis-progress-dots > span {
+    animation: none;
+  }
+}
+
 .workbench-composer {
   padding-top: 12px;
   border-top: 1px solid #e9eff7;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flzxsqc-demo",
-  "version": "1.4.21",
+  "version": "1.4.23",
   "description": "flzxsqc-demo",
   "main": "index.js",
   "scripts": {