chatccc 0.2.204 → 0.2.206

package/src/agent-activity.ts

@@ -0,0 +1,170 @@
+import type { UnifiedBlock } from "./adapters/adapter-interface.ts";
+
+export type AgentActivityKind =
+  | "starting"
+  | "thinking"
+  | "tool"
+  | "processing"
+  | "responding"
+  | "searching"
+  | "compacting";
+
+/** The user-visible activity of a running Agent turn. */
+export interface AgentActivity {
+  kind: AgentActivityKind;
+  /** Time when the current activity began, used for truthful elapsed time. */
+  startedAt: number;
+  toolName?: string;
+  toolCount?: number;
+}
+
+interface ActiveTool {
+  id: string;
+  name: string;
+  startedAt: number;
+}
+
+export interface AgentActivityTracker {
+  activity: AgentActivity;
+  activeTools: Map<string, ActiveTool>;
+  nextAnonymousToolId: number;
+}
+
+export function createAgentActivityTracker(now = Date.now()): AgentActivityTracker {
+  return {
+    activity: { kind: "starting", startedAt: now },
+    activeTools: new Map(),
+    nextAnonymousToolId: 1,
+  };
+}
+
+function sameVisibleActivity(left: AgentActivity, right: AgentActivity): boolean {
+  return left.kind === right.kind
+    && left.toolName === right.toolName
+    && left.toolCount === right.toolCount;
+}
+
+function setActivity(tracker: AgentActivityTracker, next: AgentActivity): boolean {
+  if (sameVisibleActivity(tracker.activity, next)) return false;
+  tracker.activity = next;
+  return true;
+}
+
+function refreshToolActivity(tracker: AgentActivityTracker): boolean {
+  const tools = [...tracker.activeTools.values()];
+  const first = tools[0];
+  if (!first) return false;
+  return setActivity(tracker, {
+    kind: "tool",
+    startedAt: first.startedAt,
+    toolName: first.name,
+    toolCount: tools.length,
+  });
+}
+
+function removeCompletedTool(tracker: AgentActivityTracker, toolUseId: string): void {
+  if (toolUseId && tracker.activeTools.delete(toolUseId)) return;
+
+  // Older adapters did not always include a tool ID. Prefer an anonymous entry;
+  // if there is only one active call, it is still safe to match that result.
+  const anonymousId = [...tracker.activeTools.keys()].find((id) => id.startsWith("anonymous:"));
+  if (anonymousId) {
+    tracker.activeTools.delete(anonymousId);
+  } else if (tracker.activeTools.size === 1) {
+    const onlyId = tracker.activeTools.keys().next().value as string | undefined;
+    if (onlyId) tracker.activeTools.delete(onlyId);
+  }
+}
+
+/**
+ * Applies one normalized Agent event and returns whether the persisted activity
+ * changed. Tool activity takes precedence while a tool call is still active.
+ */
+export function updateAgentActivity(
+  tracker: AgentActivityTracker,
+  block: UnifiedBlock,
+  now = Date.now(),
+): boolean {
+  if (block.type === "tool_use") {
+    const id = block.id || `anonymous:${tracker.nextAnonymousToolId++}`;
+    const existing = tracker.activeTools.get(id);
+    tracker.activeTools.set(id, {
+      id,
+      name: block.name || "未知工具",
+      startedAt: existing?.startedAt ?? now,
+    });
+    return refreshToolActivity(tracker);
+  }
+
+  if (block.type === "tool_result") {
+    removeCompletedTool(tracker, block.tool_use_id);
+    if (tracker.activeTools.size > 0) return refreshToolActivity(tracker);
+    return setActivity(tracker, { kind: "processing", startedAt: now });
+  }
+
+  if (tracker.activeTools.size > 0) return false;
+
+  switch (block.type) {
+    case "thinking":
+    case "redacted_thinking":
+      return setActivity(tracker, { kind: "thinking", startedAt: now });
+    case "text":
+    case "text_final":
+      return setActivity(tracker, { kind: "responding", startedAt: now });
+    case "search_result":
+      return setActivity(tracker, { kind: "searching", startedAt: now });
+    case "compact_boundary":
+      return setActivity(tracker, { kind: "compacting", startedAt: now });
+  }
+}
+
+function formatElapsed(startedAt: number, now: number): string {
+  const totalSeconds = Math.max(0, Math.floor((now - startedAt) / 1000));
+  if (totalSeconds < 60) return `${totalSeconds}秒`;
+  const totalMinutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (totalMinutes < 60) return `${totalMinutes}分${seconds}秒`;
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  return `${hours}小时${minutes}分`;
+}
+
+function displayToolName(name: string | undefined): string {
+  const normalized = (name || "未知工具").replace(/\s+/g, " ").trim();
+  return normalized.length > 24 ? `${normalized.slice(0, 23)}…` : normalized;
+}
+
+export function formatAgentActivityTitle(
+  activity: AgentActivity | undefined,
+  now = Date.now(),
+): string {
+  if (!activity) return "正在处理";
+
+  let label: string;
+  switch (activity.kind) {
+    case "starting":
+      label = "正在启动 Agent";
+      break;
+    case "thinking":
+      label = "思考中";
+      break;
+    case "tool": {
+      const count = Math.max(1, activity.toolCount ?? 1);
+      label = `正在执行 ${displayToolName(activity.toolName)}${count > 1 ? ` 等 ${count} 项` : ""}`;
+      break;
+    }
+    case "processing":
+      label = "正在处理工具结果";
+      break;
+    case "responding":
+      label = "正在生成回复";
+      break;
+    case "searching":
+      label = "正在处理搜索结果";
+      break;
+    case "compacting":
+      label = "正在整理上下文";
+      break;
+  }
+  return `${label} · ${formatElapsed(activity.startedAt, now)}`;
+}

package/src/response-stall.ts

@@ -0,0 +1,28 @@
+/** A snapshot of response output progress while the Agent is generating a reply. */
+export interface ResponseProgressObservation {
+  totalChars: number;
+  unchangedSince: number;
+}
+
+/**
+ * Tracks how long the displayed response character count has remained unchanged.
+ * Leaving the responding phase clears the window; returning starts a fresh one.
+ */
+export function observeResponseProgress(
+  previous: ResponseProgressObservation | undefined,
+  isResponding: boolean,
+  totalChars: number,
+  now = Date.now(),
+): ResponseProgressObservation | undefined {
+  if (!isResponding) return undefined;
+  if (previous?.totalChars === totalChars) return previous;
+  return { totalChars, unchangedSince: now };
+}
+
+export function hasResponseStalled(
+  observation: ResponseProgressObservation | undefined,
+  now: number,
+  timeoutMs: number,
+): boolean {
+  return observation !== undefined && now - observation.unchangedSince >= timeoutMs;
+}

package/src/session-chat-binding.ts

@@ -5,7 +5,8 @@
 // 由 session.ts 在初始化时调用 rebuildSessionChatsFromRegistry 重建
 // ---------------------------------------------------------------------------
 
-import type { PlatformAdapter } from "./platform-adapter.ts";
+import type { PlatformAdapter } from "./platform-adapter.ts";
+import type { ResponseProgressObservation } from "./response-stall.ts";
 
 const sessionChatsMap = new Map<string, Set<string>>();
 
@@ -66,8 +67,14 @@ export interface ActivePrompt {
   stopped: boolean;
   startTime: number;
   /** Root PID for the CLI process currently serving this prompt, if the adapter exposes one. */
-  processPid?: number;
-  processMonitor?: ReturnType<typeof setInterval>;
+  processPid?: number;
+  processMonitor?: ReturnType<typeof setInterval>;
+  responseStallMonitor?: ReturnType<typeof setInterval>;
+  /** Character-count progress observed only while the activity is "responding". */
+  responseProgress?: ResponseProgressObservation;
+  /** Set before a response-stall auto-end begins so competing monitors cannot win the race. */
+  autoEnded?: boolean;
+  autoEndedAt?: number;
   /** Set when the watchdog detects that the CLI process disappeared before stream finalization. */
   abnormalExit?: boolean;
   abnormalExitNotified?: boolean;
@@ -139,8 +146,10 @@ export interface DisplayCardState {
   cardId: string;
   sequence: number;
   cardBusy: boolean;
-  cardCreatedAt: number;
-  lastSentContent: string;
+  cardCreatedAt: number;
+  lastSentContent: string;
+  /** Last rendered activity header; elapsed time can change without body output. */
+  lastSentHeaderTitle?: string;
   streamErrorNotified: boolean;
   /** 所属 session */
   sessionId: string;
@@ -153,8 +162,8 @@ export interface DisplayCardState {
   lastSentAccLen?: number;
   /** WeChat delta: 上次发送时的 finalReply */
   lastSentFinalReply?: string;
-  /** 点点点动画计数器（统一 display loop 每个卡片独立计数） */
-  dotCount: number;
+  /** Liveness animation counter; the explicit activity header conveys Agent state. */
+  dotCount: number;
 }
 
 export const displayCards = new Map<string, DisplayCardState>();
@@ -218,9 +227,10 @@ export function consumeQueuedMessage(platform: PlatformAdapter, msg: QueuedMessa
 export function resetBindingState(): void {
   sessionChatsMap.clear();
   lastActiveChatMap.clear();
-  for (const prompt of activePrompts.values()) {
-    if (prompt.processMonitor) clearInterval(prompt.processMonitor);
-  }
+  for (const prompt of activePrompts.values()) {
+    if (prompt.processMonitor) clearInterval(prompt.processMonitor);
+    if (prompt.responseStallMonitor) clearInterval(prompt.responseStallMonitor);
+  }
   activePrompts.clear();
   queuedMessages.clear();
   displayCards.clear();