@downcity/agent 1.1.228 → 1.1.236

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 { SessionQueueCommand } from "@/types/session/SessionQueueCommand.js";
 import type {
   AgentSessionTurnHandle,
   AgentSessionTurnResult,
@@ -25,7 +26,10 @@ const TURN_STOPPED_MESSAGE = "Turn stopped";
 const QUEUED_PROMPT_CANCELLED_MESSAGE =
   "Prompt cancelled because session was stopped";
 
-type QueuedPrompt = {
+type SessionQueuePrompt = {
+  /** 当前队列项固定为 prompt。 */
+  type: "prompt";
+
   /**
    * 当前排队中的 prompt 输入。
    */
@@ -37,6 +41,11 @@ type QueuedPrompt = {
   deferredHandle: Deferred<AgentSessionTurnHandle>;
 };
 
+/**
+ * Session queue 的统一有序输入。
+ */
+type SessionQueueInput = SessionQueuePrompt | SessionQueueCommand;
+
 /**
  * Promise 延迟控制器。
  */
@@ -139,7 +148,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: SessionQueueInput[] = [];
   private processingPromise: Promise<void> | null = null;
   private activeTurn: ActiveTurnState | null = null;
 
@@ -161,6 +170,7 @@ export class SessionPromptRuntime {
   prompt(input: AgentSessionPromptInput): Promise<AgentSessionTurnHandle> {
     const deferredHandle = createDeferred<AgentSessionTurnHandle>();
     this.queue.push({
+      type: "prompt",
       input,
       deferredHandle,
     });
@@ -168,6 +178,27 @@ export class SessionPromptRuntime {
     return deferredHandle.promise;
   }
 
+  /**
+   * 把一次已成功创建的 command 加入统一输入队列。
+   */
+  enqueue_command(command: SessionQueueCommand): void {
+    this.queue.push(command);
+  }
+
+  /**
+   * 判断是否存在等待并入下一 Session step 的 prompt。
+   */
+  has_pending_prompt(): boolean {
+    return this.queue.some((item) => item.type === "prompt");
+  }
+
+  /**
+   * 判断是否存在等待在下一 Session step 检查点执行的 command。
+   */
+  has_pending_command(): boolean {
+    return this.queue.some((item) => item.type === "command");
+  }
+
   /**
    * 返回当前 actor prompt 调度器是否仍处于活跃态。
    *
@@ -176,7 +207,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 +242,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 +271,18 @@ export class SessionPromptRuntime {
       current.deferredHandle.resolve(createTurnHandle(activeTurn));
 
       try {
+        await this.execute_commands(
+          queued_before_prompt.filter(
+            (item): item is SessionQueueCommand => item.type === "command",
+          ),
+          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 +357,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 SessionQueuePrompt => item.type === "prompt",
+    );
+    if (cancelled.length <= 0) return 0;
+    const retained = this.queue.filter((item) => item.type === "command");
+    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,7 +403,10 @@ export class SessionPromptRuntime {
     return cancelled.length;
   }
 
-  private async drainQueuedPromptsAsMessages(
+  /**
+   * 在下一 Session step 检查点按入队顺序提交配置并持久化 steer。
+   */
+  private async drain_queued_inputs(
     activeTurn: ActiveTurnState,
   ): Promise<SessionUserMessageV1[]> {
     if (this.queue.length <= 0) return [];
@@ -368,6 +415,16 @@ export class SessionPromptRuntime {
 
     for (let index = 0; index < drained.length; index += 1) {
       const item = drained[index];
+      if (item.type === "command") {
+        try {
+          await item.execute({
+            turn_id: activeTurn.turnId,
+          });
+        } catch {
+          // command 自己负责失败观测；单条失败不能吞掉后续 steer 或 command。
+        }
+        continue;
+      }
       try {
         const message = await this.createAndPersistUserMessage(
           item.input,
@@ -386,6 +443,25 @@ export class SessionPromptRuntime {
 
     return merged;
   }
+
+  /**
+   * 执行一组已经从统一队列截取的 command。
+   */
+  private async execute_commands(
+    commands: SessionQueueCommand[],
+    active_turn: ActiveTurnState,
+  ): Promise<void> {
+    if (commands.length <= 0) return;
+    for (const command of commands) {
+      try {
+        await command.execute({
+          turn_id: active_turn.turnId,
+        });
+      } catch {
+        // command 自己负责失败观测；单条失败不能阻断当前 prompt。
+      }
+    }
+  }
 }
 
 function buildPromptRuntimeErrorAssistantMessage(input: {

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 { SessionQueueCommand } from "@/types/session/SessionQueueCommand.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 SessionConfiguredCommandResult {
+  /**
+   * 等待在下一 Session step 检查点执行的 command。
+   *
+   * 说明（中文）
+   * - 输入未产生实际配置变化时为空。
+   * - fork 等内部初始化路径可以选择立即提交而不返回 command。
+   */
+  command?: SessionQueueCommand;
+}
+
 /**
  * 本地 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<SessionConfiguredCommandResult> {
     const should_emit_action = options?.emit_action !== false;
     const previous_model_label = this.state.sessionConfig.modelLabel;
     const previous_model_id = String(
@@ -273,47 +293,59 @@ 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) {
-        await this.emit_action_event({
+      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_config_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 command_id = generateId();
+      return {
+        command: {
+          type: "command",
+          command_id,
+          scope: "session",
+          execute: async ({ turn_id }) => {
+            await apply_effective_config(turn_id);
+          },
+        },
+      };
+    } catch (error) {
+      throw error;
     }
   }
 
@@ -324,6 +356,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 +418,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 } : {}),
     });
   }
@@ -512,6 +535,27 @@ export class SessionStateService {
     });
   }
 
+  /**
+   * 尽力写入配置生效 action，不让 timeline 故障改变 effective state。
+   */
+  async emit_config_action_event(input: EmitActionInput): Promise<boolean> {
+    try {
+      await this.emit_action_event(input);
+      return true;
+    } catch (error) {
+      try {
+        await this.logger.log("warn", "[agent] config action persistence failed", {
+          sessionId: this.session_id,
+          actionId: String(input.id || ""),
+          error: error instanceof Error ? error.message : String(error),
+        });
+      } catch {
+        // 配置已经提交，日志失败也不能反向改变 effective state。
+      }
+      return false;
+    }
+  }
+
   /**
    * 构造并持久化一条 prompt user 消息。
    */

package/src/session/services/SessionTurnService.ts

@@ -14,6 +14,7 @@ import { isAgentSessionPromptInputEmpty } from "@/types/sdk/AgentSessionPrompt.j
 import type { AgentSessionPromptInput } from "@/types/sdk/AgentSessionPrompt.js";
 import type { AgentSessionStopResult } from "@/types/sdk/AgentSessionStop.js";
 import type { AgentSessionTurnHandle } from "@/types/sdk/AgentSessionTurn.js";
+import type { SessionRunResult } from "@/executor/types/SessionRun.js";
 import type {
   SessionRecordV1,
   SessionMessageRecordV1,
@@ -22,12 +23,14 @@ 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 { SessionQueueCommand } from "@/types/session/SessionQueueCommand.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";
+import { generateId } from "@/utils/Id.js";
 
 type SessionTurnServiceOptions = {
   /**
@@ -70,6 +73,8 @@ export class SessionTurnService {
   private readonly event_hub: SessionEventHub;
   private readonly recorder: SessionRecorder;
   private readonly prompt_runtime: SessionPromptRuntime;
+  private active_run_context: SessionRunContext | null = null;
+  private request_active_history_reload: (() => void) | null = null;
 
   constructor(options: SessionTurnServiceOptions) {
     this.session_id = options.session_id;
@@ -136,6 +141,52 @@ export class SessionTurnService {
     return await this.prompt_runtime.prompt(input);
   }
 
+  /**
+   * 把 configured state command 加入当前 Session 的统一输入队列。
+   */
+  enqueue_command(command: SessionQueueCommand): void {
+    this.prompt_runtime.enqueue_command(command);
+  }
+
+  /**
+   * 把一次显式历史压缩加入当前 Session 的统一输入队列。
+   */
+  async compact(): Promise<void> {
+    await this.state_service.ensure_runnable();
+    const command_id = generateId();
+    this.enqueue_command({
+      type: "command",
+      command_id,
+      scope: "session",
+      execute: async ({ turn_id }) => {
+        const active_run_context = this.active_run_context;
+        const run_context = active_run_context ||
+          this.create_compaction_run_context(turn_id);
+        const result = await this.executor.compact_history(run_context);
+        if (
+          result.compacted &&
+          active_run_context !== null &&
+          active_run_context === this.active_run_context
+        ) {
+          this.request_active_history_reload?.();
+        }
+        await this.state_service.touch_metadata();
+        if (result.compacted) {
+          return;
+        }
+        if (!result.compacted && result.reason === "nothing_to_compact") {
+          await this.state_service.emit_action_event({
+            id: `compacting:${this.session_id}:${command_id}`,
+            title: "Session records already compact",
+            description: "The Session has no active records to compact.",
+            state: "completed",
+            turnId: turn_id,
+          });
+        }
+      },
+    });
+  }
+
   /**
    * 停止当前 turn，并取消尚未被吸收的排队 prompt。
    */
@@ -161,6 +212,7 @@ export class SessionTurnService {
       current: SessionAssistantMessageWriter | null;
     } = { current: null };
     let assistant_segment_index = 0;
+    let history_reload_requested = false;
     const ensure_assistant_writer = async (): Promise<SessionAssistantMessageWriter> => {
       if (assistant_writer_ref.current) return assistant_writer_ref.current;
       assistant_segment_index += 1;
@@ -175,6 +227,13 @@ export class SessionTurnService {
       sessionId: this.session_id,
       projectRoot: this.project_root,
       onStepCallback: async () => {
+        if (
+          this.prompt_runtime.has_pending_command() &&
+          assistant_writer_ref.current
+        ) {
+          await assistant_writer_ref.current.complete();
+          assistant_writer_ref.current = null;
+        }
         const merged = await input.onStepMerge();
         if (merged.length > 0 && assistant_writer_ref.current) {
           await assistant_writer_ref.current.complete();
@@ -182,6 +241,12 @@ export class SessionTurnService {
         }
         return merged;
       },
+      hasPendingStepInput: () => this.prompt_runtime.has_pending_prompt(),
+      consume_history_reload: () => {
+        const requested = history_reload_requested;
+        history_reload_requested = false;
+        return requested;
+      },
       onUiMessageChunkCallback: async (chunk) => {
         if (!is_assistant_content_chunk(chunk.type)) return;
         const writer = await ensure_assistant_writer();
@@ -197,12 +262,32 @@ export class SessionTurnService {
     };
     const query = input.promptInput.query;
     const executor_query = typeof query === "string" ? query : extractTextFromParts(query);
-    const result = await this.executor.run({
-      query: executor_query,
-      runContext: run_context,
-    });
+    this.active_run_context = run_context;
+    this.request_active_history_reload = () => {
+      history_reload_requested = true;
+    };
+    let result: SessionRunResult;
+    try {
+      result = await this.executor.run({
+        query: executor_query,
+        runContext: run_context,
+      });
+    } finally {
+      if (this.active_run_context === run_context) {
+        this.active_run_context = null;
+        this.request_active_history_reload = null;
+      }
+    }
+    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 +296,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);
       }
@@ -236,6 +320,10 @@ export class SessionTurnService {
     await this.state_service.persist_deferred_user_messages(
       result.deferredPersistedUserMessages,
     );
+    if (result.compact_required) {
+      await this.executor.compact_history(run_context);
+      await this.state_service.touch_metadata();
+    }
     return {
       text: result.assistantMessage
         ? extractTextFromUiMessage(result.assistantMessage)
@@ -247,6 +335,23 @@ export class SessionTurnService {
       ...(result.error ? { error: result.error } : {}),
     };
   }
+
+  /**
+   * 为 turn 开始前执行的 compact command 构造最小运行上下文。
+   */
+  private create_compaction_run_context(turn_id: string): SessionRunContext {
+    return {
+      turnId: turn_id,
+      sessionId: this.session_id,
+      projectRoot: this.project_root,
+      onActionCallback: async (event) => {
+        await this.state_service.persist_action_event(event);
+      },
+      injectedUserMessages: [],
+      deferredPersistedUserMessages: [],
+      pendingAssistantFileParts: [],
+    };
+  }
 }
 
 function is_assistant_content_chunk(type: string): boolean {