@keyou007/agent-bot 0.1.24-alpha.2 → 0.1.24-alpha.4

package/src/presentation/OutboundRouter.ts

@@ -7,6 +7,8 @@ import type {
   MergedForwardContent,
   MessageReplyTarget,
   ReferencedMessageContent,
+  RecentContextMessage,
+  RecentMessageRequest,
 } from "../feishu/types.js";
 
 export interface TurnPresenter {
@@ -17,8 +19,9 @@ export interface TurnPresenter {
     projectCwd?: string,
     agentLabel?: string,
     model?: string,
+    modelProvider?: string,
   ): void;
-  updateSessionModel(sessionId: string, model?: string): void;
+  updateSessionModel(sessionId: string, model?: string, modelProvider?: string): void;
   updateSessionTitle(sessionId: string, taskTitle: string): void;
   unregisterSession(sessionId: string): void;
   startPendingTurn(
@@ -27,6 +30,7 @@ export interface TurnPresenter {
     taskTitle?: string,
     replyTarget?: MessageReplyTarget,
     prompt?: string,
+    localImagePaths?: string[],
   ): Promise<string | undefined>;
   failPendingTurn(
     sessionId: string,
@@ -34,9 +38,10 @@ export interface TurnPresenter {
     replacementCard?: Record<string, unknown>,
   ): Promise<boolean>;
   interruptTurnForRecovery(sessionId: string, contextKey: string, turnId: string, message: string): Promise<void>;
-  appendSteerMessage(sessionId: string, turnId: string, text: string, messageId?: string): Promise<void>;
+  appendSteerMessage(sessionId: string, turnId: string, text: string, messageId?: string, localImagePaths?: string[]): Promise<void>;
   onEvent(event: AgentEvent): Promise<void>;
   showDetails(contextKey: string, turnId: string): Promise<void>;
+  getTurnPreviewUrl?(turnId: string): string | undefined;
   showActivityPage(
     contextKey: string,
     turnId: string,
@@ -70,12 +75,13 @@ export class OutboundRouter {
     projectCwd?: string,
     agentLabel?: string,
     model?: string,
+    modelProvider?: string,
   ): void {
     const route = this.route(contextKey);
     this.sessionRoutes.set(sessionId, route);
     this.sessionContextKeys.set(sessionId, contextKey);
     route.presenter.registerSession(sessionId, contextKey, taskTitle, projectCwd, agentLabel);
-    if (model) route.presenter.updateSessionModel(sessionId, model);
+    if (model || modelProvider) route.presenter.updateSessionModel(sessionId, model, modelProvider);
   }
 
   getSessionContextKey(sessionId: string): string | undefined {
@@ -94,8 +100,8 @@ export class OutboundRouter {
     this.sessionRoutes.get(sessionId)?.presenter.updateSessionTitle(sessionId, taskTitle);
   }
 
-  updateSessionModel(sessionId: string, model?: string): void {
-    this.sessionRoutes.get(sessionId)?.presenter.updateSessionModel(sessionId, model);
+  updateSessionModel(sessionId: string, model?: string, modelProvider?: string): void {
+    this.sessionRoutes.get(sessionId)?.presenter.updateSessionModel(sessionId, model, modelProvider);
   }
 
   unregisterSession(sessionId: string): void {
@@ -112,13 +118,14 @@ export class OutboundRouter {
     taskTitle?: string,
     replyTarget?: MessageReplyTarget,
     prompt?: string,
+    localImagePaths?: string[],
   ): Promise<string | undefined> {
     const route = this.route(contextKey);
     this.sessionRoutes.set(sessionId, route);
     this.sessionContextKeys.set(sessionId, contextKey);
     if (replyTarget) this.sessionReplyTargets.set(sessionId, replyTarget);
     else this.sessionReplyTargets.delete(sessionId);
-    return route.presenter.startPendingTurn(sessionId, contextKey, taskTitle, replyTarget, prompt);
+    return route.presenter.startPendingTurn(sessionId, contextKey, taskTitle, replyTarget, prompt, ...(localImagePaths ? [localImagePaths] : []));
   }
 
   async failPendingTurn(
@@ -147,8 +154,13 @@ export class OutboundRouter {
     turnId: string,
     text: string,
     messageId?: string,
+    localImagePaths?: string[],
   ): Promise<void> {
-    await this.sessionRoutes.get(sessionId)?.presenter.appendSteerMessage(sessionId, turnId, text, messageId);
+    await this.sessionRoutes.get(sessionId)?.presenter.appendSteerMessage(sessionId, turnId, text, messageId, ...(localImagePaths ? [localImagePaths] : []));
+  }
+
+  getTurnPreviewUrl(contextKey: string, turnId: string): string | undefined {
+    return this.route(contextKey).presenter.getTurnPreviewUrl?.(turnId);
   }
 
   async onEvent(event: AgentEvent): Promise<void> {
@@ -206,6 +218,12 @@ export class OutboundRouter {
     return read.call(outbound, messageId);
   }
 
+  async readRecentMessages(contextKey: string, request: RecentMessageRequest): Promise<RecentContextMessage[]> {
+    const outbound = this.route(contextKey).outbound;
+    if (!outbound.readRecentMessages) throw new Error("当前消息通道不支持读取近期群消息。");
+    return outbound.readRecentMessages(request);
+  }
+
   async readReferencedMessage(contextKey: string, messageId: string): Promise<ReferencedMessageContent> {
     const outbound = this.route(contextKey).outbound;
     const read = outbound.readReferencedMessage;

package/src/presentation/TurnStateReducer.ts

@@ -1,8 +1,9 @@
-import type { AgentEvent, ToolState } from "../runtime/types.js";
+import type { AgentEvent, RemoteTurnDetails, ToolState } from "../runtime/types.js";
 import { appendGeneratedImageMarkdown } from "../utils/generatedImageMarkdown.js";
 import type { MessageReplyTarget } from "../feishu/types.js";
 import { formatStorageSize } from "../utils/formatStorageSize.js";
-import type { FileSummary, TurnActivity, TurnViewState } from "./turnViewTypes.js";
+import type { FileSummary, TurnActivity, TurnReasoningItem, TurnViewState } from "./turnViewTypes.js";
+import { turnReasoningItems } from "./turnReasoning.js";
 
 const MAX_TEXT = 6_000;
 const MAX_COMPLETED_TOOLS = 20;
@@ -19,17 +20,22 @@ export function createTurnViewState(
   prompt?: string,
   agentLabel?: string,
   model?: string,
+  promptImagePaths?: string[],
+  modelProvider?: string,
 ): TurnViewState {
   return {
     sessionId,
     turnId,
     agentLabel,
     model,
+    modelProvider,
     taskTitle,
     prompt,
+    ...(promptImagePaths?.length ? { promptImagePaths: [...new Set(promptImagePaths)] } : {}),
     projectCwd,
     replyTarget,
     status: "starting",
+    historyDetail: "full",
     startedAt,
     assistantText: "",
     plan: [],
@@ -46,7 +52,84 @@ export function createTurnViewState(
   };
 }
 
-export function reduceTurnEvent(state: TurnViewState, event: AgentEvent): TurnViewState {
+export function hydrateTurnViewState(summary: TurnViewState, details: RemoteTurnDetails): TurnViewState {
+  let state: TurnViewState = {
+    ...summary,
+    ...createTurnViewState(summary.sessionId, summary.turnId, details.startedAt ?? summary.startedAt,
+      summary.taskTitle, summary.replyTarget, summary.projectCwd, summary.prompt,
+      summary.agentLabel, summary.model, summary.promptImagePaths, summary.modelProvider),
+    historyDetail: "full",
+    historyDetailError: undefined,
+  };
+  let hasPrompt = false;
+  const identity = { sessionId: state.sessionId, turnId: state.turnId };
+  for (const item of details.items) {
+    if (item.kind === "message") {
+      if (item.role === "user") {
+        if (!hasPrompt) {
+          state = { ...state, prompt: item.text, promptImagePaths: item.localImagePaths };
+          hasPrompt = true;
+        } else {
+          state = { ...state, activities: [...state.activities, {
+            kind: "user", id: item.id, text: item.text, localImagePaths: item.localImagePaths,
+          }] };
+        }
+      } else {
+        state = reduceTurnEvent(state, { ...identity, type: "progress", activityId: `commentary:${item.id}`, text: item.text });
+      }
+    } else if (item.kind === "tool") {
+      state = reduceToolUpdate(state, item.tool, undefined, true);
+      state.activities = state.activities.map((a) => a.kind === "tool" && a.id === item.tool.id ? { ...a, tool: item.tool } : a);
+    } else if (item.kind === "reasoning") {
+      for (const [summaryIndex, text] of item.summary.entries()) {
+        state = reduceTurnEvent(state, { ...identity, type: "progress", text,
+          activityId: `reasoning:${item.id}:${summaryIndex}`, reasoning: { itemId: item.id, summaryIndex } });
+      }
+      state = reduceTurnEvent(state, { ...identity, type: "reasoning_completed", itemId: item.id,
+        summary: item.summary, content: item.content });
+    } else {
+      state = reduceTurnEvent(state, { ...identity, type: "plan_updated", steps: item.steps });
+    }
+  }
+  const completedAt = details.completedAt ?? (details.durationMs === undefined || details.startedAt === undefined
+    ? undefined : details.startedAt + details.durationMs);
+  return {
+    ...state,
+    status: details.status,
+    completedAt,
+    durationMs: details.durationMs ?? (completedAt === undefined || details.startedAt === undefined
+      ? undefined : Math.max(0, completedAt - details.startedAt)),
+    activeTool: undefined,
+    approval: undefined,
+    finalResponse: details.finalResponse,
+    error: details.error,
+  };
+}
+
+export function reduceTurnEvent(state: TurnViewState, event: AgentEvent, complete = false): TurnViewState {
+  if (event.sessionId !== state.sessionId || event.turnId !== state.turnId) return state;
+  const next = reduceEvent(state, event);
+  if (!complete) return next;
+  if (event.type === "turn_completed") next.finalResponse = event.finalResponse;
+  if (event.type === "agent_text_delta") next.assistantText = state.assistantText + event.text;
+  if (event.type === "plan_updated") next.plan = event.steps;
+  if (event.type === "progress") {
+    const id = event.activityId ?? "progress";
+    const old = state.activities.find((a) => a.id === id);
+    next.activities = next.activities.map((a) => a.id === id && a.kind !== "tool"
+      ? { ...a, text: (event.append && old && old.kind !== "tool" ? old.text : "") + event.text } : a);
+  }
+  if (event.type === "tool_started" || event.type === "tool_updated") {
+    next.activities = next.activities.map((a) => a.kind === "tool" && a.id === event.tool.id
+      ? { ...a, tool: { ...a.tool, ...event.tool } } : a);
+    const files = new Map(state.fileSummary.map((f) => [f.path, f]));
+    for (const file of event.tool.files ?? []) files.set(file.path, file);
+    next.fileSummary = [...files.values()];
+  }
+  return next;
+}
+
+function reduceEvent(state: TurnViewState, event: AgentEvent): TurnViewState {
   if (event.sessionId !== state.sessionId || event.turnId !== state.turnId) return state;
 
   switch (event.type) {
@@ -173,7 +256,27 @@ export function reduceTurnEvent(state: TurnViewState, event: AgentEvent): TurnVi
         activitiesTruncated: state.activitiesTruncated || activityUpdate.truncated,
       };
     }
+    case "reasoning_delta":
+      return updateReasoningItem(state, event.itemId, (item) => {
+        if (item.completed) return item;
+        const content = [...item.content];
+        content[event.contentIndex] = (content[event.contentIndex] ?? "") + event.text;
+        return { ...item, content };
+      });
+    case "reasoning_completed":
+      return updateReasoningItem(state, event.itemId, (item) => ({
+        ...item, summary: [...event.summary], content: [...event.content], completed: true,
+      }));
     case "progress": {
+      const previewState = event.reasoning
+        ? updateReasoningItem(state, event.reasoning.itemId, (item) => {
+          if (item.completed) return item;
+          const summary = [...item.summary];
+          summary[event.reasoning!.summaryIndex] = event.append
+            ? (summary[event.reasoning!.summaryIndex] ?? "") + event.text : event.text;
+          return { ...item, summary };
+        })
+        : state;
       const activities = state.activities ?? [];
       const warning = event.severity === "warning";
       const activityUpdate = upsertReasoningActivity(
@@ -186,6 +289,7 @@ export function reduceTurnEvent(state: TurnViewState, event: AgentEvent): TurnVi
       return {
         ...state,
         progressText: bound(event.text),
+        ...(previewState.reasoningItems ? { reasoningItems: previewState.reasoningItems } : {}),
         activities: activityUpdate.activities,
         activitiesTruncated: state.activitiesTruncated || activityUpdate.truncated,
       };
@@ -258,15 +362,18 @@ export function reduceTurnEvent(state: TurnViewState, event: AgentEvent): TurnVi
   }
 }
 
-export function appendSteerMessage(state: TurnViewState, id: string, text: string): TurnViewState {
+export function appendSteerMessage(state: TurnViewState, id: string, text: string, localImagePaths?: string[]): TurnViewState {
   const normalized = text.trim();
-  if (!normalized) return state;
+  if (!normalized && !localImagePaths?.length) return state;
   const activities = state.activities ?? [];
   const index = activities.findIndex((activity) => activity.id === id);
+  const previous = activities[index];
+  const images = localImagePaths ?? (previous?.kind === "user" ? previous.localImagePaths : undefined);
   const activityUpdate = upsertActivity(activities, index, {
     kind: "user",
     id,
     text: bound(normalized),
+    ...(images?.length ? { localImagePaths: [...new Set(images)] } : {}),
   });
   return {
     ...state,
@@ -312,8 +419,8 @@ function appendBoundedOutput(previous: string | undefined, delta: string): strin
   return `…${combined.slice(-(MAX_TEXT - 1))}`;
 }
 
-function reduceToolUpdate(state: TurnViewState, tool: ToolState, fullOutput?: string): TurnViewState {
-  tool = withToolTiming(state, tool);
+function reduceToolUpdate(state: TurnViewState, tool: ToolState, fullOutput?: string, historical = false): TurnViewState {
+  if (!historical) tool = withToolTiming(state, tool);
   const nextFullOutput = fullOutput ?? tool.output;
   const fullToolOutputs = nextFullOutput === undefined
     ? state.fullToolOutputs
@@ -411,6 +518,23 @@ function legacyToolStatuses(state: TurnViewState): Record<string, ToolState["sta
   return statuses;
 }
 
+function updateReasoningItem(
+  state: TurnViewState,
+  itemId: string,
+  update: (item: TurnReasoningItem) => TurnReasoningItem,
+): TurnViewState {
+  const items = [...(state.reasoningItems ?? [])];
+  const index = items.findIndex((item) => item.itemId === itemId);
+  const item = index >= 0 ? items[index]! : turnReasoningItems(state).find((item) => item.itemId === itemId) ?? {
+    itemId, afterActivityId: state.activities.at(-1)?.id, summary: [], content: [],
+  };
+  const next = update(item);
+  if (next === item) return state;
+  if (index >= 0) items[index] = next;
+  else items.push(next);
+  return { ...state, reasoningItems: items };
+}
+
 function upsertReasoningActivity(
   activities: TurnActivity[],
   id: string,
@@ -573,3 +697,23 @@ function formatCompactionDuration(durationMs: number): string {
 function formatInteger(value: number): string {
   return normalizeTokenCount(value).toLocaleString("en-US");
 }
+
+/** Bound the hot card projection, never the journal or final-delivery payload. */
+export function compactTurnView(state: TurnViewState): TurnViewState {
+  const recent = state.activities.slice(-77);
+  const commentary = state.activities.slice(0, -77).filter((a) => a.kind === "assistant").slice(-3);
+  const retained = state.activities.length > 80 ? [...commentary, ...recent] : state.activities;
+  const activities = retained.map((a) => a.kind === "tool"
+    ? { ...a, tool: boundTool(a.tool) } : { ...a, text: bound(a.text) });
+  const ids = new Set(activities.filter((a) => a.kind === "tool").map((a) => a.id));
+  return { ...state, previewJournal: true, previewCursor: undefined, activities,
+    assistantText: bound(state.assistantText), progressText: state.progressText === undefined ? undefined : bound(state.progressText),
+    plan: state.plan.slice(0, 30).map((step) => ({ ...step, text: bound(step.text) })),
+    activeTool: state.activeTool ? boundTool(state.activeTool) : undefined,
+    completedTools: state.completedTools.slice(-20).map(boundTool), failedTools: state.failedTools.slice(-5).map(boundTool),
+    fileSummary: state.fileSummary.slice(-30),
+    activitiesTruncated: state.activitiesTruncated || state.activities.length > 80,
+    reasoningItems: [], fullToolOutputs: {}, fullToolErrors: {},
+    toolStatuses: Object.fromEntries(Object.entries(state.toolStatuses ?? {}).filter(([id]) => ids.has(id))),
+  };
+}

package/src/presentation/turnReasoning.ts

@@ -0,0 +1,21 @@
+import type { TurnReasoningItem, TurnViewState } from "./turnViewTypes.js";
+
+export function turnReasoningItems(state: TurnViewState): TurnReasoningItem[] {
+  const items = new Map((state.reasoningItems ?? []).map((item) => [item.itemId, item]));
+  const saved = new Set(items.keys());
+  for (const [index, activity] of state.activities.entries()) {
+    if (activity.kind !== "reasoning" || activity.id.startsWith("commentary:")) continue;
+    const match = /^reasoning:(.+):(\d+)$/u.exec(activity.id);
+    const itemId = match?.[1] ?? activity.id;
+    if (saved.has(itemId)) continue;
+    const section = match ? Number(match[2]) : 0;
+    if (!Number.isSafeInteger(section) || section < 0 || section >= 10_000) continue;
+    const item = items.get(itemId) ?? {
+      itemId, afterActivityId: state.activities[index - 1]?.id, summary: [], content: [],
+    };
+    const summary = [...item.summary];
+    summary[section] = activity.text;
+    items.set(itemId, { ...item, summary });
+  }
+  return [...items.values()];
+}

package/src/presentation/turnViewTypes.ts

@@ -18,17 +18,32 @@ export interface FileSummary {
 
 export type TurnActivity =
   | { kind: "assistant"; id: string; text: string }
-  | { kind: "user"; id: string; text: string }
+  | { kind: "user"; id: string; text: string; localImagePaths?: string[] }
   | { kind: "reasoning"; id: string; text: string }
   | { kind: "tool"; id: string; tool: ToolState };
 
+export interface TurnReasoningItem {
+  previewRevision?: number;
+  itemId: string;
+  afterActivityId?: string;
+  summary: string[];
+  content: string[];
+  completed?: boolean;
+}
+
 export interface TurnViewState {
+  /** Full execution content is stored in the append-only preview journal. */
+  previewJournal?: boolean;
+  /** Byte cursor for the on-demand preview, never needed for recovery. */
+  previewCursor?: number;
   sessionId: string;
   turnId: string;
   agentLabel?: string;
   model?: string;
+  modelProvider?: string;
   taskTitle?: string;
   prompt?: string;
+  promptImagePaths?: string[];
   projectCwd?: string;
   replyTarget?: MessageReplyTarget;
   status: TurnViewStatus;
@@ -55,6 +70,7 @@ export interface TurnViewState {
   assistantText: string;
   plan: PlanStep[];
   activities: TurnActivity[];
+  reasoningItems?: TurnReasoningItem[];
   fullToolOutputs?: Record<string, string>;
   fullToolErrors?: Record<string, string>;
   activitiesTruncated?: boolean;
@@ -69,4 +85,6 @@ export interface TurnViewState {
   approval?: ApprovalRequest;
   finalResponse?: string;
   error?: string;
+  historyDetail?: "summary" | "full";
+  historyDetailError?: string;
 }