@downcity/agent 1.1.216 → 1.1.222

package/src/session/services/SessionStateService.ts

@@ -19,10 +19,9 @@ import {
 } from "@/session/storage/Metadata.js";
 import { touchSessionMetadata } from "@/session/storage/Persistence.js";
 import { ensureSessionTitle } from "@/session/SessionTitle.js";
-import { persistSdkAssistantResult } from "@/session/storage/Persistence.js";
 import { hydrateUserPromptFileParts } from "@executor/messages/SessionAttachmentMapper.js";
 import type { Executor } from "@executor/Executor.js";
-import type { JsonlSessionHistoryStore } from "@/executor/store/history/jsonl/JsonlSessionHistoryStore.js";
+import type { SessionHistoryStore } from "@/executor/store/history/SessionHistoryStore.js";
 import type {
   AgentSessionConfigSnapshot,
   AgentSessionSetInput,
@@ -38,10 +37,20 @@ import type {
   SessionMessageRecordV1,
   SessionUserMessageV1,
 } from "@/executor/types/SessionRecords.js";
-import { to_session_action_record } from "@/executor/types/SessionRecords.js";
 import type { SessionLocalState } from "@/types/session/SessionLocalState.js";
 import { generateId } from "@/utils/Id.js";
 import type { Logger } from "@/utils/logger/Logger.js";
+import type { AgentModel } from "@/model/CityModelAdapter.js";
+import { SessionRecorder } from "@/session/recorder/SessionRecorder.js";
+import { normalize_session_user_parts } from "@/session/recorder/SessionRecorder.js";
+import {
+  from_ui_assistant_parts,
+  from_ui_user_parts,
+  to_executor_ui_message,
+} from "@/session/recorder/SessionMessageCodec.js";
+import fs from "fs-extra";
+import { getSdkAgentSessionMessagesPath } from "@/session/storage/Paths.js";
+import type { SessionMessage } from "@/types/session/SessionMessage.js";
 
 type SessionStateServiceOptions = {
   /**
@@ -62,7 +71,10 @@ type SessionStateServiceOptions = {
   /**
    * 当前 session 历史事实源。
    */
-  history_store: JsonlSessionHistoryStore;
+  history_store: SessionHistoryStore;
+
+  /** 当前 Session Message Recorder。 */
+  recorder: SessionRecorder;
 
   /**
    * 当前 session 执行器。
@@ -84,6 +96,9 @@ type SessionStateServiceOptions = {
    */
   ensure_configured_hook?: () => Promise<void>;
 
+  /** 按稳定 ID 解析当前 Session 的运行时模型。 */
+  resolve_model?: (model_id: string) => Promise<AgentModel>;
+
   /**
    * 发布 session 事件。
    */
@@ -110,11 +125,13 @@ export class SessionStateService {
   private readonly agent_id: string;
   private readonly project_root: string;
   private readonly session_id: string;
-  private readonly history_store: JsonlSessionHistoryStore;
+  private readonly history_store: SessionHistoryStore;
+  private readonly recorder: SessionRecorder;
   private readonly executor: Executor;
   private readonly state: SessionLocalState;
   private readonly logger: Logger;
   private readonly ensure_configured_hook?: SessionStateServiceOptions["ensure_configured_hook"];
+  private readonly resolve_model?: SessionStateServiceOptions["resolve_model"];
   private readonly publish_event: SessionStateServiceOptions["publish_event"];
 
   constructor(options: SessionStateServiceOptions) {
@@ -122,10 +139,12 @@ export class SessionStateService {
     this.project_root = options.project_root;
     this.session_id = options.session_id;
     this.history_store = options.history_store;
+    this.recorder = options.recorder;
     this.executor = options.executor;
     this.state = options.state;
     this.logger = options.logger;
     this.ensure_configured_hook = options.ensure_configured_hook;
+    this.resolve_model = options.resolve_model;
     this.publish_event = options.publish_event;
   }
 
@@ -189,7 +208,9 @@ export class SessionStateService {
         ...(metadata.modelLabel
           ? { modelLabel: metadata.modelLabel }
           : {}),
+        ...(metadata.modelId ? { modelId: metadata.modelId } : {}),
       };
+      await this.restore_persisted_model();
     })();
     await this.state.initializePromise;
   }
@@ -231,46 +252,57 @@ export class SessionStateService {
   async set(input: AgentSessionSetInput, options?: SessionSetOptions): Promise<void> {
     const should_emit_action = options?.emit_action !== false;
     const previous_model_label = this.state.sessionConfig.modelLabel;
-    const next_model_label = input.model
-      ? inferAgentModelLabel(input.model)
+    const previous_model_id = String(
+      this.state.sessionConfig.modelId || previous_model_label || "",
+    ).trim();
+    const requested_model_id = String(input.modelId || "").trim();
+    const next_model = input.model || (requested_model_id
+      ? await this.resolve_model_by_id(requested_model_id)
+      : undefined);
+    const next_model_label = next_model
+      ? inferAgentModelLabel(next_model)
       : undefined;
+    const next_model_id = requested_model_id || next_model_label || "";
     const should_emit_model_switch_action = Boolean(
-      input.model &&
+      next_model &&
         should_emit_action &&
         this.state.sessionConfig.model &&
-        previous_model_label &&
-        next_model_label &&
-        previous_model_label !== next_model_label,
+        previous_model_id &&
+        next_model_id &&
+        previous_model_id !== next_model_id,
     );
+    const previous_model_name = previous_model_label || previous_model_id;
+    const next_model_name = next_model_label || next_model_id;
     const action_id = `model-switching:${this.session_id}:${Date.now()}:${generateId()}`;
 
     if (should_emit_model_switch_action) {
       await this.emit_action_event({
         id: action_id,
-        title: "Switching session model",
-        description: next_model_label
-          ? `Switching to ${next_model_label}.`
-          : undefined,
+        title: `Switching session model from ${previous_model_name} to ${next_model_name}`,
         state: "running",
       });
     }
 
     try {
-      if (input.model) {
-        this.state.sessionConfig.model = normalizeAgentModel(input.model);
+      if (next_model) {
+        this.state.sessionConfig.model = normalizeAgentModel(next_model);
         this.state.sessionConfig.modelLabel = next_model_label;
       }
+      if (next_model_id) {
+        this.state.sessionConfig.modelId = next_model_id;
+      }
       await patchSessionModelLabel({
         projectRoot: this.project_root,
         agentId: this.agent_id,
         sessionId: this.session_id,
         model: this.state.sessionConfig.model,
+        modelId: this.state.sessionConfig.modelId,
       });
     } catch (error) {
       if (should_emit_model_switch_action) {
         await this.emit_action_event({
           id: action_id,
-          title: "Session model switch failed",
+          title: `Session model switch from ${previous_model_name} to ${next_model_name} failed`,
           description: error instanceof Error ? error.message : String(error),
           state: "failed",
         });
@@ -281,15 +313,29 @@ export class SessionStateService {
     if (should_emit_model_switch_action) {
       await this.emit_action_event({
         id: action_id,
-        title: "Session model switched",
-        description: this.state.sessionConfig.modelLabel
-          ? `Using ${this.state.sessionConfig.modelLabel}.`
-          : undefined,
+        title: `Session model switched from ${previous_model_name} to ${next_model_name}`,
         state: "completed",
       });
     }
   }
 
+  /** 恢复 metadata 中持久化的模型覆盖。 */
+  private async restore_persisted_model(): Promise<void> {
+    const model_id = String(this.state.sessionConfig.modelId || "").trim();
+    if (!model_id || this.state.sessionConfig.model) return;
+    const model = await this.resolve_model_by_id(model_id);
+    this.state.sessionConfig.model = normalizeAgentModel(model);
+    this.state.sessionConfig.modelLabel = inferAgentModelLabel(model);
+  }
+
+  /** 使用宿主 resolver 解析稳定模型 ID。 */
+  private async resolve_model_by_id(model_id: string): Promise<AgentModel> {
+    if (!this.resolve_model) {
+      throw new Error("Session model resolver is not configured.");
+    }
+    return await this.resolve_model(model_id);
+  }
+
   /**
    * 追加一条 user 消息并刷新标题与 metadata。
    */
@@ -297,7 +343,20 @@ export class SessionStateService {
     message?: SessionRecordV1 | null;
     text?: string;
   }): Promise<void> {
-    await this.executor.append_user_message(params);
+    const parts = params.message && "role" in params.message
+      ? from_ui_user_parts(params.message.parts)
+      : [{
+          part_id: `external-user-text:${Date.now()}`,
+          type: "text" as const,
+          text: String(params.text || "").trim(),
+          state: "done" as const,
+        }];
+    if (parts.length === 0) return;
+    await this.recorder.append_user_message({
+      turn_id: `external:${this.session_id}:${Date.now()}`,
+      input_type: "prompt",
+      parts,
+    });
     await this.ensure_title_from_history({ generate: true });
     await this.touch_metadata();
   }
@@ -309,7 +368,16 @@ export class SessionStateService {
     message?: SessionRecordV1 | null;
     fallbackText?: string;
   }): Promise<void> {
-    await this.executor.append_assistant_message(params);
+    const parts = params.message && "role" in params.message
+      ? from_ui_assistant_parts(params.message.parts)
+      : [{
+          part_id: `external-assistant-text:${Date.now()}`,
+          type: "text" as const,
+          text: String(params.fallbackText || "").trim(),
+          state: "done" as const,
+        }];
+    if (parts.length === 0) return;
+    await this.recorder.append_completed_assistant_message({ parts });
     await this.touch_metadata();
   }
 
@@ -317,11 +385,29 @@ export class SessionStateService {
    * 仅刷新当前 session metadata。
    */
   async touch_metadata(): Promise<void> {
+    const message_page = await this.recorder.list_messages({
+      limit: 500,
+      include_internal: true,
+    });
+    const messages_path = getSdkAgentSessionMessagesPath(
+      this.project_root,
+      this.agent_id,
+      this.session_id,
+    );
+    const history_bytes = await fs.stat(messages_path)
+      .then((file_stat) => file_stat.size)
+      .catch(() => 0);
+    const preview_text = resolve_message_preview(
+      message_page.items[message_page.items.length - 1],
+    ).slice(0, 180);
     await touchSessionMetadata({
       projectRoot: this.project_root,
       agentId: this.agent_id,
       sessionId: this.session_id,
       sessionConfig: this.state.sessionConfig,
+      message_count: message_page.total,
+      history_bytes,
+      ...(preview_text ? { preview_text } : {}),
     });
   }
 
@@ -368,14 +454,8 @@ export class SessionStateService {
   async persist_assistant_result(
     assistant_message?: SessionMessageRecordV1 | null,
   ): Promise<void> {
-    await persistSdkAssistantResult({
-      projectRoot: this.project_root,
-      agentId: this.agent_id,
-      sessionId: this.session_id,
-      sessionConfig: this.state.sessionConfig,
-      executor: this.executor,
-      assistantMessage: assistant_message,
-    });
+    void assistant_message;
+    await this.touch_metadata();
   }
 
   /**
@@ -384,8 +464,23 @@ export class SessionStateService {
   async persist_action_event(
     event: SessionActionRecordV1,
   ): Promise<void> {
-    const message = to_session_action_record(event, this.session_id);
-    await this.history_store.write_record(message);
+    const existing = this.recorder.get_message(event.id);
+    if (!existing) {
+      const writer = await this.recorder.open_action_message({
+        message_id: event.id,
+        turn_id: event.metadata.turnId,
+        action_type: infer_action_type(event.id),
+        title: event.title,
+        description: event.description,
+      });
+      if (event.state === "completed") await writer.complete();
+      if (event.state === "failed") await writer.fail(event.description || event.title);
+    } else if (existing.type === "action" && event.state !== "running") {
+      await this.recorder.update_action_message(event.id, event.state, {
+        title: event.title,
+        description: event.description,
+      });
+    }
     await this.touch_metadata();
   }
 
@@ -393,21 +488,26 @@ export class SessionStateService {
    * 写入并发布一条 action。
    */
   async emit_action_event(input: EmitActionInput): Promise<void> {
-    const event = to_session_action_record(
-      {
-        ...input,
-        id:
-          String(input.id || "").trim() ||
-          `action:${this.session_id}:${Date.now()}:${generateId()}`,
+    const action_id = String(input.id || "").trim() ||
+      `action:${this.session_id}:${Date.now()}`;
+    const turn_id = "turnId" in input
+      ? input.turnId
+      : input.metadata?.turnId;
+    await this.persist_action_event({
+      type: "action",
+      id: action_id,
+      title: input.title,
+      ...(input.description ? { description: input.description } : {}),
+      state: input.state,
+      metadata: {
+        v: 1,
+        ts: input.metadata?.ts || Date.now(),
+        sessionId: this.session_id,
+        ...(turn_id
+          ? { turnId: turn_id }
+          : {}),
       },
-      this.session_id,
-    );
-    try {
-      await this.persist_action_event(event);
-    } catch {
-      // action 持久化失败不应阻断宿主操作。
-    }
-    this.publish_event(event);
+    });
   }
 
   /**
@@ -415,43 +515,22 @@ export class SessionStateService {
    */
   async create_and_persist_user_prompt_message(
     input: AgentSessionPromptInput,
+    turn_id: string,
+    input_type: "prompt" | "steer" = "prompt",
   ): Promise<SessionUserMessageV1> {
     const query = input.query;
-    if (typeof query === "string") {
-      const message = this.history_store.userText({
-        text: query.trim(),
-        metadata: {
-          sessionId: this.session_id,
-        },
-      }) as SessionUserMessageV1;
-      await this.executor.append_user_message({
-        message,
-      });
-      await this.ensure_title_from_history({ generate: true });
-      await this.touch_metadata();
-      return message;
-    }
-
-    // query 是 parts 数组，先把本地图片附件转换为模型可消费的 data URL。
-    const parts = await hydrateUserPromptFileParts(
-      Array.isArray(query) ? query : [],
-      this.project_root,
-    );
-    const message: SessionUserMessageV1 = {
-      id: `u:${this.session_id}:${generateId()}`,
-      role: "user",
-      parts,
-      metadata: {
-        v: 1,
-        ts: Date.now(),
-        sessionId: this.session_id,
-        source: "ingress",
-        kind: "normal",
-      },
-    };
-    await this.executor.append_user_message({
-      message,
+    const ui_parts = typeof query === "string"
+      ? [{ type: "text" as const, text: query.trim() }]
+      : await hydrateUserPromptFileParts(
+          Array.isArray(query) ? query : [],
+          this.project_root,
+        );
+    const canonical = await this.recorder.append_user_message({
+      turn_id,
+      input_type,
+      parts: normalize_session_user_parts(ui_parts),
     });
+    const message = to_executor_ui_message(canonical) as SessionUserMessageV1;
     await this.ensure_title_from_history({ generate: true });
     await this.touch_metadata();
     return message;
@@ -468,10 +547,36 @@ export class SessionStateService {
       : [];
     if (normalized_messages.length <= 0) return;
     for (const message of normalized_messages) {
-      await this.executor.append_user_message({
-        message,
+      await this.recorder.append_user_message({
+        turn_id: String(message.metadata?.turnId || `deferred:${this.session_id}:${Date.now()}`),
+        input_type: "steer",
+        parts: from_ui_user_parts(message.parts),
       });
     }
     await this.touch_metadata();
   }
 }
+
+function resolve_message_preview(message: SessionMessage | undefined): string {
+  if (!message) return "";
+  if (message.type === "user") {
+    return message.parts
+      .flatMap((part) => part.type === "text" ? [part.text] : [])
+      .join("")
+      .trim();
+  }
+  if (message.type === "assistant") {
+    return message.parts
+      .flatMap((part) => part.type === "text" ? [part.text] : [])
+      .join("")
+      .trim();
+  }
+  if (message.type === "action") {
+    return [message.title, message.description].filter(Boolean).join("\n");
+  }
+  return message.message.trim();
+}
+
+function infer_action_type(message_id: string): string {
+  return String(message_id || "").split(":")[0] || "action";
+}

package/src/session/services/SessionTurnService.ts

@@ -23,11 +23,15 @@ import type {
   SessionMessageRecordV1,
   SessionUserMessageV1,
 } from "@/executor/types/SessionRecords.js";
-import { mapAgentEventToSessionEvent, mapUiMessageChunkToAgentEvent } from "@/session/SessionEventMapper.js";
 import { SessionEventHub } from "@/session/runtime/SessionEventHub.js";
 import { SessionPromptRuntime } from "@/session/runtime/SessionPromptRuntime.js";
 import type { SessionRunContext } from "@/types/executor/SessionRunContext.js";
 import { SessionStateService } from "@/session/services/SessionStateService.js";
+import {
+  SessionAssistantMessageWriter,
+  SessionRecorder,
+} from "@/session/recorder/SessionRecorder.js";
+import { from_ui_assistant_parts } from "@/session/recorder/SessionMessageCodec.js";
 
 type SessionTurnServiceOptions = {
   /**
@@ -54,6 +58,9 @@ type SessionTurnServiceOptions = {
    * 当前 session 共享事件总线。
    */
   event_hub: SessionEventHub;
+
+  /** 当前 Session Message Recorder。 */
+  recorder: SessionRecorder;
 };
 
 /**
@@ -65,6 +72,7 @@ export class SessionTurnService {
   private readonly executor: Executor;
   private readonly state_service: SessionStateService;
   private readonly event_hub: SessionEventHub;
+  private readonly recorder: SessionRecorder;
   private readonly prompt_runtime: SessionPromptRuntime;
 
   constructor(options: SessionTurnServiceOptions) {
@@ -73,23 +81,26 @@ export class SessionTurnService {
     this.executor = options.executor;
     this.state_service = options.state_service;
     this.event_hub = options.event_hub;
+    this.recorder = options.recorder;
     this.prompt_runtime = new SessionPromptRuntime({
       sessionId: this.session_id,
       publish: (event) => {
         this.publish_event(event);
       },
-      createAndPersistUserMessage: async (input) => {
+      createAndPersistUserMessage: async (input, turn_id, input_type) => {
         return await this.state_service.create_and_persist_user_prompt_message(
           input,
+          turn_id,
+          input_type,
         );
       },
-      emit_steer_action: async ({ turn_id, message }) => {
-        await this.state_service.emit_action_event({
-          id: `steer-message:${message.id}`,
-          title: "Session steer message sent",
-          description: "Merged a new user message into the active turn.",
-          state: "completed",
-          turnId: turn_id,
+      appendErrorMessage: async ({ turn_id, message }) => {
+        await this.recorder.append_error_message({
+          scope: "turn",
+          turn_id,
+          code: "turn_execution_failed",
+          message,
+          recoverable: true,
         });
       },
       executeTurn: async ({ turnId, promptInput, onStepMerge, abortSignal }) => {
@@ -157,64 +168,38 @@ export class SessionTurnService {
     assistantMessage?: SessionMessageRecordV1 | null;
     error?: string;
   }> {
-    const tool_name_by_call_id = new Map<string, string>();
+    const assistant_writer_ref: {
+      current: SessionAssistantMessageWriter | null;
+    } = { current: null };
+    let assistant_segment_index = 0;
+    const ensure_assistant_writer = async (): Promise<SessionAssistantMessageWriter> => {
+      if (assistant_writer_ref.current) return assistant_writer_ref.current;
+      assistant_segment_index += 1;
+      assistant_writer_ref.current = await this.recorder.open_assistant_message({
+        turn_id: input.turnId,
+        segment_index: assistant_segment_index,
+      });
+      return assistant_writer_ref.current;
+    };
     const run_context: SessionRunContext = {
       turnId: input.turnId,
       sessionId: this.session_id,
       projectRoot: this.project_root,
-      onStepCallback: input.onStepMerge,
-      onAssistantStepCallback: async (step) => {
-        this.publish_event({
-          type: "assistant-step",
-          turnId: input.turnId,
-          text: step.text,
-          stepIndex: step.stepIndex,
-          ...(step.visibility ? { visibility: step.visibility } : {}),
-        });
+      onStepCallback: async () => {
+        const merged = await input.onStepMerge();
+        if (merged.length > 0 && assistant_writer_ref.current) {
+          await assistant_writer_ref.current.complete();
+          assistant_writer_ref.current = null;
+        }
+        return merged;
       },
       onUiMessageChunkCallback: async (chunk) => {
-        if (chunk.type === "tool-input-start") {
-          tool_name_by_call_id.set(chunk.toolCallId, chunk.toolName);
-          return;
-        }
-        const event = mapUiMessageChunkToAgentEvent(chunk);
-        if (!event) return;
-        const resolved_event =
-          (
-            event.type === "tool-result" ||
-            event.type === "tool-error"
-          ) &&
-          event.toolName === "unknown"
-            ? {
-                ...event,
-                toolName:
-                  tool_name_by_call_id.get(event.toolCallId) || event.toolName,
-              }
-            : event;
-        if (
-          resolved_event.type === "tool-call" ||
-          resolved_event.type === "tool-error"
-        ) {
-          tool_name_by_call_id.set(
-            resolved_event.toolCallId,
-            resolved_event.toolName,
-          );
-        }
-        const session_event = mapAgentEventToSessionEvent({
-          event: resolved_event,
-          turnId: input.turnId,
-        });
-        if (session_event) {
-          this.publish_event(session_event);
-        }
+        if (!is_assistant_content_chunk(chunk.type)) return;
+        const writer = await ensure_assistant_writer();
+        await writer.apply_chunk(chunk);
       },
       onActionCallback: async (event) => {
-        try {
-          await this.state_service.persist_action_event(event);
-        } catch {
-          // action 持久化失败不应阻断当前 turn。
-        }
-        this.publish_event(event);
+        await this.state_service.persist_action_event(event);
       },
       injectedUserMessages: [],
       deferredPersistedUserMessages: [],
@@ -227,6 +212,37 @@ export class SessionTurnService {
       query: executor_query,
       runContext: run_context,
     });
+    const final_assistant_writer = assistant_writer_ref.current;
+    if (final_assistant_writer) {
+      if (input.abortSignal?.aborted) {
+        await final_assistant_writer.stop();
+      } else if (result.success) {
+        await final_assistant_writer.complete();
+      } else {
+        await final_assistant_writer.fail(result.error);
+      }
+    } else if (result.assistantMessage) {
+      const parts = from_ui_assistant_parts(result.assistantMessage.parts);
+      if (parts.length > 0) {
+        assistant_segment_index += 1;
+        const fallback_writer = await this.recorder.open_assistant_message({
+          turn_id: input.turnId,
+          segment_index: assistant_segment_index,
+        });
+        for (const part of parts) await fallback_writer.upsert_part(part);
+        if (result.success) await fallback_writer.complete();
+        else await fallback_writer.fail(result.error);
+      }
+    }
+    if (!result.success && !input.abortSignal?.aborted && result.error) {
+      await this.recorder.append_error_message({
+        scope: "turn",
+        turn_id: input.turnId,
+        code: "turn_execution_failed",
+        message: result.error,
+        recoverable: true,
+      });
+    }
     await this.state_service.persist_assistant_result(result.assistantMessage);
     await this.state_service.persist_deferred_user_messages(
       result.deferredPersistedUserMessages,
@@ -243,3 +259,16 @@ export class SessionTurnService {
     };
   }
 }
+
+function is_assistant_content_chunk(type: string): boolean {
+  return (
+    type === "text-start" ||
+    type === "text-delta" ||
+    type === "text-end" ||
+    type === "reasoning-start" ||
+    type === "reasoning-delta" ||
+    type === "reasoning-end" ||
+    type.startsWith("tool-") ||
+    type === "file"
+  );
+}