@downcity/agent 1.1.228 → 1.1.232

package/src/session/runtime/SessionPromptRuntime.ts

@@ -16,6 +16,7 @@ import type {
 import type { SessionMutation } from "@/types/session/SessionMutation.js";
 import type { AgentSessionPromptInput } from "@/types/sdk/AgentSessionPrompt.js";
 import type { AgentSessionStopResult } from "@/types/sdk/AgentSessionStop.js";
+import type { SessionRuntimeConfigMutation } from "@/types/session/SessionConfigMutation.js";
 import type {
   AgentSessionTurnHandle,
   AgentSessionTurnResult,
@@ -26,6 +27,9 @@ const QUEUED_PROMPT_CANCELLED_MESSAGE =
   "Prompt cancelled because session was stopped";
 
 type QueuedPrompt = {
+  /** 当前队列项固定为 prompt。 */
+  type: "prompt";
+
   /**
    * 当前排队中的 prompt 输入。
    */
@@ -37,6 +41,22 @@ type QueuedPrompt = {
   deferredHandle: Deferred<AgentSessionTurnHandle>;
 };
 
+/**
+ * 等待在模型 turn 边界提交的配置队列项。
+ */
+type QueuedConfigMutation = {
+  /** 当前队列项固定为配置 mutation。 */
+  type: "config";
+
+  /** 当前待提交的配置 mutation。 */
+  mutation: SessionRuntimeConfigMutation;
+};
+
+/**
+ * Session actor 的统一有序输入。
+ */
+type QueuedSessionInput = QueuedPrompt | QueuedConfigMutation;
+
 /**
  * Promise 延迟控制器。
  */
@@ -75,6 +95,9 @@ interface ActiveTurnState {
    * 当前 turn 的取消控制器。
    */
   abortController: AbortController;
+
+  /** 当前公开 turn 已开始的模型 turn 数量。 */
+  model_turn_index: number;
 }
 
 /**
@@ -139,7 +162,7 @@ export class SessionPromptRuntime {
   private readonly appendErrorMessage: SessionPromptRuntimeOptions["appendErrorMessage"];
   private readonly executeTurn: SessionPromptRuntimeOptions["executeTurn"];
   private readonly stopTurn: SessionPromptRuntimeOptions["stopTurn"];
-  private readonly queue: QueuedPrompt[] = [];
+  private readonly queue: QueuedSessionInput[] = [];
   private processingPromise: Promise<void> | null = null;
   private activeTurn: ActiveTurnState | null = null;
 
@@ -161,6 +184,7 @@ export class SessionPromptRuntime {
   prompt(input: AgentSessionPromptInput): Promise<AgentSessionTurnHandle> {
     const deferredHandle = createDeferred<AgentSessionTurnHandle>();
     this.queue.push({
+      type: "prompt",
       input,
       deferredHandle,
     });
@@ -168,6 +192,23 @@ export class SessionPromptRuntime {
     return deferredHandle.promise;
   }
 
+  /**
+   * 把一次已成功写入 configured state 的配置修改加入统一输入队列。
+   */
+  enqueue_config(mutation: SessionRuntimeConfigMutation): void {
+    this.queue.push({
+      type: "config",
+      mutation,
+    });
+  }
+
+  /**
+   * 判断是否存在等待并入模型 turn 的 prompt。
+   */
+  has_pending_prompt(): boolean {
+    return this.queue.some((item) => item.type === "prompt");
+  }
+
   /**
    * 返回当前 actor prompt 调度器是否仍处于活跃态。
    *
@@ -176,7 +217,7 @@ export class SessionPromptRuntime {
    * - Session 会用它阻止内部 direct execution 与 actor 模式并发混用。
    */
   isActive(): boolean {
-    return this.processingPromise !== null || this.queue.length > 0;
+    return this.processingPromise !== null || this.has_pending_prompt();
   }
 
   /**
@@ -211,16 +252,19 @@ export class SessionPromptRuntime {
     if (this.processingPromise) return;
     this.processingPromise = this.processLoop().finally(() => {
       this.processingPromise = null;
-      if (this.queue.length > 0) {
+      if (this.has_pending_prompt()) {
         this.ensureProcessing();
       }
     });
   }
 
   private async processLoop(): Promise<void> {
-    while (this.queue.length > 0) {
+    while (this.has_pending_prompt()) {
+      const prompt_index = this.queue.findIndex((item) => item.type === "prompt");
+      if (prompt_index < 0) break;
+      const queued_before_prompt = this.queue.splice(0, prompt_index);
       const current = this.queue.shift();
-      if (!current) break;
+      if (!current || current.type !== "prompt") break;
 
       const turnId = `turn:${this.sessionId}:${Date.now()}:${nanoid(6)}`;
       const activeTurn = createActiveTurnState(turnId);
@@ -237,12 +281,18 @@ export class SessionPromptRuntime {
       current.deferredHandle.resolve(createTurnHandle(activeTurn));
 
       try {
+        await this.apply_config_mutations(
+          queued_before_prompt.filter(
+            (item): item is QueuedConfigMutation => item.type === "config",
+          ),
+          activeTurn,
+        );
         await this.createAndPersistUserMessage(current.input, turnId, "prompt");
         const result = await this.executeTurn({
           turnId,
           promptInput: current.input,
           onStepMerge: async () => {
-            return await this.drainQueuedPromptsAsMessages(activeTurn);
+            return await this.drain_queued_inputs(activeTurn);
           },
           abortSignal: activeTurn.abortController.signal,
         });
@@ -317,8 +367,12 @@ export class SessionPromptRuntime {
   }
 
   private cancelQueuedPrompts(): number {
-    if (this.queue.length <= 0) return 0;
-    const cancelled = this.queue.splice(0, this.queue.length);
+    const cancelled = this.queue.filter(
+      (item): item is QueuedPrompt => item.type === "prompt",
+    );
+    if (cancelled.length <= 0) return 0;
+    const retained = this.queue.filter((item) => item.type === "config");
+    this.queue.splice(0, this.queue.length, ...retained);
     for (const item of cancelled) {
       const turnId = `turn:${this.sessionId}:cancelled:${Date.now()}:${nanoid(6)}`;
       const cancelledTurn = createActiveTurnState(turnId);
@@ -359,15 +413,30 @@ export class SessionPromptRuntime {
     return cancelled.length;
   }
 
-  private async drainQueuedPromptsAsMessages(
+  /**
+   * 在下一模型 turn 开始前按入队顺序提交配置并持久化 steer。
+   */
+  private async drain_queued_inputs(
     activeTurn: ActiveTurnState,
   ): Promise<SessionUserMessageV1[]> {
+    activeTurn.model_turn_index += 1;
     if (this.queue.length <= 0) return [];
     const drained = this.queue.splice(0, this.queue.length);
     const merged: SessionUserMessageV1[] = [];
 
     for (let index = 0; index < drained.length; index += 1) {
       const item = drained[index];
+      if (item.type === "config") {
+        try {
+          await item.mutation.apply({
+            turn_id: activeTurn.turnId,
+            model_turn_index: activeTurn.model_turn_index,
+          });
+        } catch {
+          // 配置实现负责写 failed action；单条失败不能吞掉后续 steer 或配置。
+        }
+        continue;
+      }
       try {
         const message = await this.createAndPersistUserMessage(
           item.input,
@@ -386,6 +455,27 @@ export class SessionPromptRuntime {
 
     return merged;
   }
+
+  /**
+   * 提交一组已经从统一队列截取的配置 mutation。
+   */
+  private async apply_config_mutations(
+    mutations: QueuedConfigMutation[],
+    active_turn: ActiveTurnState,
+  ): Promise<void> {
+    if (mutations.length <= 0) return;
+    active_turn.model_turn_index += 1;
+    for (const item of mutations) {
+      try {
+        await item.mutation.apply({
+          turn_id: active_turn.turnId,
+          model_turn_index: active_turn.model_turn_index,
+        });
+      } catch {
+        // 配置实现负责写 failed action；单条失败不能阻断当前 prompt。
+      }
+    }
+  }
 }
 
 function buildPromptRuntimeErrorAssistantMessage(input: {
@@ -426,6 +516,7 @@ function createActiveTurnState(turnId: string): ActiveTurnState {
     result: null,
     deferredFinished: createDeferred<AgentSessionTurnResult>(),
     abortController: new AbortController(),
+    model_turn_index: 0,
   };
 }
 

package/src/session/services/SessionStateService.ts

@@ -10,6 +10,7 @@
 import {
   inferAgentModelLabel,
   normalizeAgentModel,
+  read_agent_model_context_window,
 } from "@/model/CityModelAdapter.js";
 import {
   patchSessionModelLabel,
@@ -36,6 +37,7 @@ import type {
   SessionUserMessageV1,
 } from "@/executor/types/SessionRecords.js";
 import type { SessionLocalState } from "@/types/session/SessionLocalState.js";
+import type { SessionRuntimeConfigMutation } from "@/types/session/SessionConfigMutation.js";
 import { generateId } from "@/utils/Id.js";
 import type { Logger } from "@/utils/logger/Logger.js";
 import type { AgentModel } from "@/model/CityModelAdapter.js";
@@ -46,8 +48,6 @@ import {
   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 = {
@@ -116,6 +116,20 @@ type SessionSetOptions = {
 
 type EmitActionInput = SessionActionRecordInputV1 | SessionActionRecordV1;
 
+/**
+ * Session 配置成功写入后的队列提交结果。
+ */
+export interface SessionConfiguredMutationResult {
+  /**
+   * 等待在下一模型 turn 提交的 mutation。
+   *
+   * 说明（中文）
+   * - 输入未产生实际配置变化时为空。
+   * - fork 等内部初始化路径可以选择立即提交而不返回 mutation。
+   */
+  mutation?: SessionRuntimeConfigMutation;
+}
+
 /**
  * 本地 Session 状态与持久化服务。
  */
@@ -209,6 +223,9 @@ export class SessionStateService {
         ...(metadata.modelId ? { modelId: metadata.modelId } : {}),
       };
       await this.restore_persisted_model();
+      this.state.effective_session_config = {
+        ...this.state.sessionConfig,
+      };
     })();
     await this.state.initializePromise;
   }
@@ -247,7 +264,10 @@ export class SessionStateService {
   /**
    * 写入当前 session 配置。
    */
-  async set(input: AgentSessionSetInput, options?: SessionSetOptions): Promise<void> {
+  async set(
+    input: AgentSessionSetInput,
+    options?: SessionSetOptions,
+  ): Promise<SessionConfiguredMutationResult> {
     const should_emit_action = options?.emit_action !== false;
     const previous_model_label = this.state.sessionConfig.modelLabel;
     const previous_model_id = String(
@@ -273,47 +293,71 @@ export class SessionStateService {
     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 from ${previous_model_name} to ${next_model_name}`,
-        state: "running",
-      });
-    }
-
     try {
+      const next_config: AgentSessionConfigSnapshot = {
+        ...this.state.sessionConfig,
+      };
       if (next_model) {
-        this.state.sessionConfig.model = normalizeAgentModel(next_model);
-        this.state.sessionConfig.modelLabel = next_model_label;
+        next_config.model = normalizeAgentModel(next_model);
+        next_config.modelLabel = next_model_label;
+        next_config.model_context_window =
+          read_agent_model_context_window(next_model);
       }
       if (next_model_id) {
-        this.state.sessionConfig.modelId = next_model_id;
+        next_config.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,
+        model: next_config.model,
+        modelId: next_config.modelId,
       });
-    } catch (error) {
-      if (should_emit_model_switch_action) {
+      this.state.sessionConfig = next_config;
+
+      const apply_effective_config = async (turn_id?: string): Promise<void> => {
+        this.state.effective_session_config = {
+          ...next_config,
+        };
+        if (!should_emit_model_switch_action) return;
         await this.emit_action_event({
           id: action_id,
-          title: `Session model switch from ${previous_model_name} to ${next_model_name} failed`,
-          description: error instanceof Error ? error.message : String(error),
-          state: "failed",
+          title: `Session model switched from ${previous_model_name} to ${next_model_name}`,
+          state: "completed",
+          ...(turn_id ? { turnId: turn_id } : {}),
         });
+      };
+
+      if (options?.emit_action === false) {
+        await apply_effective_config();
+        return {};
       }
-      throw error;
-    }
 
-    if (should_emit_model_switch_action) {
-      await this.emit_action_event({
-        id: action_id,
-        title: `Session model switched from ${previous_model_name} to ${next_model_name}`,
-        state: "completed",
-      });
+      const mutation_id = generateId();
+      return {
+        mutation: {
+          mutation_id,
+          scope: "session",
+          apply: async ({ turn_id }) => {
+            try {
+              await apply_effective_config(turn_id);
+            } catch (error) {
+              if (should_emit_model_switch_action) {
+                await this.emit_action_event({
+                  id: action_id,
+                  title: `Session model switch from ${previous_model_name} to ${next_model_name} failed`,
+                  description: error instanceof Error ? error.message : String(error),
+                  state: "failed",
+                  turnId: turn_id,
+                });
+              }
+              throw error;
+            }
+          },
+        },
+      };
+    } catch (error) {
+      throw error;
     }
   }
 
@@ -324,6 +368,8 @@ export class SessionStateService {
     const model = await this.resolve_model_by_id(model_id);
     this.state.sessionConfig.model = normalizeAgentModel(model);
     this.state.sessionConfig.modelLabel = inferAgentModelLabel(model);
+    this.state.sessionConfig.model_context_window =
+      read_agent_model_context_window(model);
   }
 
   /** 使用宿主 resolver 解析稳定模型 ID。 */
@@ -384,28 +430,17 @@ 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 stats = await this.recorder.storage_stats();
     const preview_text = resolve_message_preview(
-      message_page.items[message_page.items.length - 1],
+      stats.latest_message || undefined,
     ).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,
+      message_count: stats.message_count,
+      history_bytes: stats.history_bytes,
       ...(preview_text ? { preview_text } : {}),
     });
   }

package/src/session/services/SessionTurnService.ts

@@ -22,6 +22,7 @@ import type {
 import { SessionEventHub } from "@/session/runtime/SessionEventHub.js";
 import { SessionPromptRuntime } from "@/session/runtime/SessionPromptRuntime.js";
 import type { SessionRunContext } from "@/types/executor/SessionRunContext.js";
+import type { SessionRuntimeConfigMutation } from "@/types/session/SessionConfigMutation.js";
 import { SessionStateService } from "@/session/services/SessionStateService.js";
 import {
   SessionAssistantMessageWriter,
@@ -136,6 +137,13 @@ export class SessionTurnService {
     return await this.prompt_runtime.prompt(input);
   }
 
+  /**
+   * 把 configured state 修改加入当前 Session 的统一输入队列。
+   */
+  enqueue_config(mutation: SessionRuntimeConfigMutation): void {
+    this.prompt_runtime.enqueue_config(mutation);
+  }
+
   /**
    * 停止当前 turn，并取消尚未被吸收的排队 prompt。
    */
@@ -182,6 +190,7 @@ export class SessionTurnService {
         }
         return merged;
       },
+      hasPendingStepInput: () => this.prompt_runtime.has_pending_prompt(),
       onUiMessageChunkCallback: async (chunk) => {
         if (!is_assistant_content_chunk(chunk.type)) return;
         const writer = await ensure_assistant_writer();
@@ -201,8 +210,16 @@ export class SessionTurnService {
       query: executor_query,
       runContext: run_context,
     });
+    const final_assistant_parts = result.assistantMessage
+      ? from_ui_assistant_parts(result.assistantMessage.parts)
+      : [];
     const final_assistant_writer = assistant_writer_ref.current;
     if (final_assistant_writer) {
+      for (const part of final_assistant_parts) {
+        if (part.type === "file") {
+          await final_assistant_writer.append_file_part(part);
+        }
+      }
       if (input.abortSignal?.aborted) {
         await final_assistant_writer.stop();
       } else if (result.success) {
@@ -211,14 +228,13 @@ export class SessionTurnService {
         await final_assistant_writer.fail(result.error);
       }
     } else if (result.assistantMessage) {
-      const parts = from_ui_assistant_parts(result.assistantMessage.parts);
-      if (parts.length > 0) {
+      if (final_assistant_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);
+        for (const part of final_assistant_parts) await fallback_writer.upsert_part(part);
         if (result.success) await fallback_writer.complete();
         else await fallback_writer.fail(result.error);
       }

package/src/session/services/SessionViewService.ts

@@ -8,12 +8,7 @@
  */
 
 import { nanoid } from "nanoid";
-import {
-  buildSessionRecordsPage,
-  buildSessionInfo,
-  loadSessionArchiveMessagesFromPath,
-} from "@/session/browse/Browse.js";
-import { getSdkAgentSessionArchiveFilePath } from "@/session/storage/Paths.js";
+import { buildSessionInfo } from "@/session/browse/Browse.js";
 import { ensureSessionTitle } from "@/session/SessionTitle.js";
 import { readSessionMetadata } from "@/session/storage/Metadata.js";
 import { buildSessionSystemBlocks } from "@/session/SessionSystemBuilder.js";
@@ -21,8 +16,6 @@ import type { SessionHistoryStore } from "@/executor/store/history/SessionHistor
 import type { SessionSystemComposer } from "@/executor/composer/system/SessionSystemComposer.js";
 import type {
   AgentSessionForkInput,
-  AgentSessionRecordsInput,
-  AgentSessionRecordsPage,
   AgentSessionInfo,
   AgentSessionSystemBlock,
   AgentSessionSystemSnapshot,
@@ -192,42 +185,6 @@ export class SessionViewService<TSession extends Pick<AgentSession, "set">> {
     });
   }
 
-  /**
-   * 读取当前 session records 分页。
-   */
-  async records(
-    input?: AgentSessionRecordsInput,
-  ): Promise<AgentSessionRecordsPage> {
-    const archive_id = String(input?.archive_id || "").trim();
-    const [metadata, current_messages] = await Promise.all([
-      readSessionMetadata({
-        projectRoot: this.project_root,
-        agentId: this.agent_id,
-        sessionId: this.session_id,
-      }),
-      this.history_store.list_records(),
-    ]);
-    const page_messages = archive_id
-      ? await loadSessionArchiveMessagesFromPath(
-          getSdkAgentSessionArchiveFilePath(
-            this.project_root,
-            this.agent_id,
-            this.session_id,
-            archive_id,
-          ),
-        )
-      : current_messages;
-    const session = await this.build_info({
-      metadata,
-      messages: current_messages,
-    });
-    return buildSessionRecordsPage({
-      session,
-      messages: page_messages,
-      input,
-    });
-  }
-
   /**
    * 读取当前 session 生效的 system 快照。
    */
@@ -290,14 +247,11 @@ export class SessionViewService<TSession extends Pick<AgentSession, "set">> {
       typeof input === "string"
         ? String(input || "").trim() || undefined
         : String(input?.messageId || "").trim() || undefined;
-    const message_page = await this.recorder.list_messages({
-      limit: 500,
-      include_internal: true,
-    });
+    const messages = await this.recorder.list_history_messages();
     const fork_messages =
       !message_id
-        ? message_page.items
-        : this.resolve_fork_messages(message_page.items, message_id);
+        ? messages
+        : this.resolve_fork_messages(messages, message_id);
     const action_id = `history-forking:${this.session_id}:${Date.now()}:${nanoid(8)}`;
 
     await this.state_service.emit_action_event({

package/src/session/storage/Paths.ts

@@ -88,7 +88,7 @@ export function getSdkAgentArchivedSessionMessagesDirPath(
 }
 
 /**
- * 单个已归档 session 的消息 JSONL 文件路径。
+ * 单个已归档 session 的 Active JSONL 文件路径。
  */
 export function getSdkAgentArchivedSessionMessagesPath(
   projectRoot: string,
@@ -97,7 +97,7 @@ export function getSdkAgentArchivedSessionMessagesPath(
 ): string {
   return path.join(
     getSdkAgentArchivedSessionMessagesDirPath(projectRoot, agentId, sessionId),
-    "messages.jsonl",
+    "active.jsonl",
   );
 }
 
@@ -144,7 +144,7 @@ export function getSdkAgentSessionMessagesDirPath(
 }
 
 /**
- * 单个 session 的消息 JSONL 文件路径。
+ * 单个 session 的 Active JSONL 文件路径。
  */
 export function getSdkAgentSessionMessagesPath(
   projectRoot: string,
@@ -153,7 +153,7 @@ export function getSdkAgentSessionMessagesPath(
 ): string {
   return path.join(
     getSdkAgentSessionMessagesDirPath(projectRoot, agentId, sessionId),
-    "messages.jsonl",
+    "active.jsonl",
   );
 }
 
@@ -171,46 +171,13 @@ export function getSdkAgentSessionMetaPath(
   );
 }
 
-/**
- * 单个 session 的 archive 目录路径。
- */
-export function getSdkAgentSessionArchiveDirPath(
-  projectRoot: string,
-  agentId: string,
-  sessionId: string,
-): string {
-  return path.join(
-    getSdkAgentSessionMessagesDirPath(projectRoot, agentId, sessionId),
-    "archive",
-  );
-}
-
-/**
- * 单个 session 的 compact archive JSON 文件路径。
- *
- * 关键点（中文）
- * - `archiveId` 来自 compact summary metadata，不由调用方拼接扩展名。
- * - 这里统一 encode，避免 archiveId 中的特殊字符影响文件路径。
- */
-export function getSdkAgentSessionArchiveFilePath(
-  projectRoot: string,
-  agentId: string,
-  sessionId: string,
-  archiveId: string,
-): string {
-  return path.join(
-    getSdkAgentSessionArchiveDirPath(projectRoot, agentId, sessionId),
-    `${encodeURIComponent(String(archiveId || "").trim())}.json`,
-  );
-}
-
 /**
  * 单个 session 的 inflight assistant 路径。
  *
  * 关键点（中文）
  * - 运行中的 assistant 只保留一份增量快照。
  * - step / tool 过程会持续重写这个文件，避免中途中断后过程完全丢失。
- * - 完成后再把最终 assistant 合并进 `messages.jsonl`，并清理该文件。
+ * - 完成后再把最终 assistant 合并进 `active.jsonl`，并清理该文件。
  */
 export function getSdkAgentSessionAssistantMessagePath(
   projectRoot: string,