@downcity/agent 1.1.315 → 1.1.320

package/src/session/Session.ts

@@ -21,6 +21,7 @@ import type {
   AgentSessionInfo,
   AgentSessionStatus,
   AgentSessionSetInput,
+  AgentSessionSetOptions,
   AgentSessionSystemBlock,
   AgentSessionSystemSnapshot,
 } from "@/types/agent/SessionTypes.js";
@@ -93,8 +94,6 @@ export class Session implements AgentSession {
   private readonly events: SessionEventHub;
   private readonly session_interactions: SessionInteractions;
   private readonly shell_approval_adapter: SessionShellApprovalAdapter;
-  /** 已被 Session 接受、等待或已经在 Step 检查点提交的审批模式。 */
-  private configured_approval_mode: SessionApprovalMode = "ask";
   private readonly local_state: SessionLocalState;
   private readonly get_workspace_env: SessionOptions["get_workspace_env"];
   private readonly get_agent_model: SessionOptions["get_agent_model"];
@@ -102,6 +101,8 @@ export class Session implements AgentSession {
   private readonly get_instruction_system_blocks:
     SessionOptions["get_instruction_system_blocks"];
   private effective_instruction_system_blocks: AgentSessionSystemBlock[];
+  /** 当前 Session 的一次性初始化任务，避免缓存实例被重复恢复运行时状态。 */
+  private initialize_promise: Promise<void> | null = null;
   private instruction_initialize_promise: Promise<void> | null = null;
   private effective_workspace_env: Record<string, string>;
   private effective_agent_plugins: AgentPluginExecutionRuntime;
@@ -199,11 +200,19 @@ export class Session implements AgentSession {
    * 初始化当前 session。
    */
   async initialize(): Promise<this> {
-    await Promise.all([
-      this.initialize_instruction(),
-      this.session_messages.initialize(),
-      this.state.initialize(),
-    ]);
+    if (!this.initialize_promise) {
+      this.initialize_promise = (async () => {
+        await Promise.all([
+          this.initialize_instruction(),
+          this.session_messages.initialize(),
+          this.state.initialize(),
+        ]);
+        this.shell_approval_adapter.set_effective_mode(
+          this.state.get_approval_mode(),
+        );
+      })();
+    }
+    await this.initialize_promise;
     return this;
   }
 
@@ -257,7 +266,10 @@ export class Session implements AgentSession {
   /**
    * 写入当前 session 默认配置。
    */
-  async set(input: AgentSessionSetInput): Promise<void> {
+  async set(
+    input: AgentSessionSetInput,
+    options?: AgentSessionSetOptions,
+  ): Promise<void> {
     if (!input.model && !input.security) {
       throw new Error("session.set requires model or security");
     }
@@ -269,38 +281,49 @@ export class Session implements AgentSession {
     ) {
       throw new Error("security.approval_mode must be ask or always-allow");
     }
-    const model_config = input.model
+    const persist_action = options?.persist_action !== false;
+    const publish_mutation =
+      options?.publish_mutation === undefined
+        ? persist_action
+        : options.publish_mutation;
+    if (!persist_action && publish_mutation) {
+      throw new Error(
+        "session.set publish_mutation requires persist_action",
+      );
+    }
+    const model_result = input.model
       ? await this.state.set_model(input.model)
       : undefined;
     const next_approval_mode = requested_approval_mode;
-    const security_changed = Boolean(
-      next_approval_mode && next_approval_mode !== this.configured_approval_mode,
-    );
-    if (next_approval_mode !== undefined) {
-      this.configured_approval_mode = next_approval_mode;
-    }
-    if (!model_config && !security_changed) return;
+    const security_changed = next_approval_mode !== undefined
+      ? await this.state.set_approval_mode(next_approval_mode)
+      : false;
+    if (!model_result && !security_changed) return;
     const changed_fields = [
-      ...(model_config
-        ? [`model: ${String(model_config.model_label || "configured")}`]
+      ...(model_result?.changed
+        ? [`model: ${String(model_result.config.model_label || "configured")}`]
         : []),
       ...(security_changed
         ? [`security.approval_mode: ${String(next_approval_mode)}`]
         : []),
     ];
+    const completion = changed_fields.length > 0 && persist_action
+      ? {
+          type: "action" as const,
+          id: `session-config:${this.id}:${Date.now()}:${generate_id()}`,
+          title: "Session configuration updated",
+          description: changed_fields.join("; "),
+          publish_mutation,
+        }
+      : undefined;
     this.enqueue_command({
       execute: async () => {
-        if (model_config) this.state.apply_model_config(model_config);
+        if (model_result) this.state.apply_model_config(model_result.config);
         if (security_changed && next_approval_mode) {
           this.shell_approval_adapter.set_effective_mode(next_approval_mode);
         }
       },
-      completion: {
-        type: "action",
-        id: `session-config:${this.id}:${Date.now()}:${generate_id()}`,
-        title: "Session configuration updated",
-        description: changed_fields.join("; "),
-      },
+      ...(completion ? { completion } : {}),
     });
   }
 
@@ -432,7 +455,7 @@ export class Session implements AgentSession {
       state: active_turn_id || this.executor.is_executing() ? "running" : "idle",
       ...(active_turn_id ? { active_turn_id } : {}),
       security: {
-        approval_mode: this.configured_approval_mode,
+        approval_mode: this.state.get_approval_mode(),
         effective_approval_mode: this.shell_approval_adapter.get_effective_mode(),
       },
     };
@@ -555,9 +578,12 @@ export class Session implements AgentSession {
       await forked.initialize();
       const session_config = this.state.get_config();
       if (session_config.model) {
-        const forked_config = await forked.state.set_model(session_config.model);
-        forked.state.apply_model_config(forked_config);
+        const forked_model = await forked.state.set_model(session_config.model);
+        forked.state.apply_model_config(forked_model.config);
       }
+      const approval_mode = this.state.get_approval_mode();
+      await forked.state.set_approval_mode(approval_mode);
+      forked.shell_approval_adapter.set_effective_mode(approval_mode);
       await forked.session_messages.import_messages(fork_messages);
       await this.emit_action_event({
         id: action_id,
@@ -710,6 +736,7 @@ export class Session implements AgentSession {
     return {
       session_config: {},
       effective_session_config: {},
+      configured_approval_mode: "ask",
       created_at: Date.now(),
       timezone: resolve_system_timezone(),
       initialize_promise: null,

package/src/session/SessionLoop.ts

@@ -279,6 +279,8 @@ export class SessionLoop {
           session_id: this.session_id,
           turn_id,
         },
+      }, {
+        publish_mutation: completion.publish_mutation !== false,
       });
     } catch (error) {
       try {
@@ -599,8 +601,9 @@ export class SessionLoop {
   /** 持久化 Executor Action，并同步刷新 Session metadata。 */
   private async persist_action_event(
     event: SessionActionRecordV1,
+    options?: { publish_mutation?: boolean },
   ): Promise<void> {
-    await this.messages.persist_action_record(event);
+    await this.messages.persist_action_record(event, options);
     await this.state.touch_metadata();
   }
 

package/src/session/SessionMessages.ts

@@ -315,7 +315,11 @@ export class SessionMessages {
   }
 
   /** 按稳定 Action ID 创建或更新 canonical Action Message。 */
-  async persist_action_record(event: SessionActionRecordV1): Promise<void> {
+  async persist_action_record(
+    event: SessionActionRecordV1,
+    options?: { publish_mutation?: boolean },
+  ): Promise<void> {
+    const publish_mutation = options?.publish_mutation !== false;
     const existing = this.get_message(event.id);
     if (!existing) {
       const writer = await this.open_action_message({
@@ -324,6 +328,7 @@ export class SessionMessages {
         action_type: infer_action_type(event.id),
         title: event.title,
         description: event.description,
+        publish_mutation,
       });
       if (event.state === "completed") await writer.complete();
       if (event.state === "failed") {
@@ -335,7 +340,7 @@ export class SessionMessages {
       await this.update_action_message(event.id, event.state, {
         title: event.title,
         description: event.description,
-      });
+      }, { publish_mutation });
     }
   }
 
@@ -360,8 +365,12 @@ export class SessionMessages {
       title: input.title,
       ...(input.description ? { description: input.description } : {}),
       ...(input.data ? { data: structuredClone(input.data) } : {}),
-    }))) as SessionActionMessage;
-    return new SessionActionMessageWriter(this, message.message_id);
+    }), false, input.publish_mutation !== false)) as SessionActionMessage;
+    return new SessionActionMessageWriter(
+      this,
+      message.message_id,
+      input.publish_mutation !== false,
+    );
   }
 
   /** 更新 Action 状态，同时保持 message_id 与 sequence 不变。 */
@@ -369,6 +378,7 @@ export class SessionMessages {
     message_id: string,
     status: "running" | "completed" | "failed",
     changes?: { title?: string; description?: string; data?: JsonObject },
+    options?: { publish_mutation?: boolean },
   ): Promise<SessionActionMessage> {
     const message = await this.store.append_message((state) => {
       const current = require_message(state.messages, message_id, "action");
@@ -385,7 +395,7 @@ export class SessionMessages {
         updated_at: created_at,
       } satisfies SessionActionMessage;
     });
-    this.accept_message(message);
+    this.accept_message(message, options?.publish_mutation !== false);
     return message as SessionActionMessage;
   }
 
@@ -576,6 +586,59 @@ export class SessionMessages {
     }, message);
   }
 
+  /** @internal 写入 Assistant Tool 输入原始 delta。 */
+  async append_assistant_tool_input_delta(
+    message_id: string,
+    part_id: string,
+    tool_call_id: string,
+    delta: string,
+  ): Promise<void> {
+    if (!delta) return;
+    await this.enqueue_assistant_write(message_id, async () => {
+      const current = require_message(
+        [...this.messages_by_id.values()],
+        message_id,
+        "assistant",
+      );
+      require_streaming_assistant(current);
+      const part = current.parts.find((item) => item.part_id === part_id);
+      if (!part || part.type !== "tool") {
+        throw new Error(`Tool input Delta target Part does not exist: ${part_id}`);
+      }
+      if (part.tool_call_id !== tool_call_id) {
+        throw new Error(`Tool input Delta tool_call_id changed for Part: ${part_id}`);
+      }
+      if (part.state !== "input-streaming") {
+        throw new Error(`Tool input Delta cannot update ${part.state} Part: ${part_id}`);
+      }
+      const created_at = Date.now();
+      const message: SessionAssistantMessage = {
+        ...current,
+        revision: current.revision + 1,
+        updated_at: created_at,
+        parts: current.parts.map((item) =>
+          item.part_id === part_id && item.type === "tool"
+            ? { ...item, input_text: `${item.input_text || ""}${delta}` }
+            : item,
+        ),
+      };
+      await this.store.write_assistant_message(message);
+      this.accept_mutation({
+        mutation_id: generate_id(),
+        variant: "delta",
+        type: "tool_input",
+        message_id,
+        revision: message.revision,
+        session_id: this.session_id,
+        turn_id: message.turn_id,
+        created_at,
+        part_id,
+        tool_call_id,
+        delta,
+      }, message);
+    });
+  }
+
   /** @internal 写入 Assistant 完整 part。 */
   async update_assistant_part(
     message_id: string,
@@ -723,6 +786,7 @@ export class SessionMessages {
   private async create_message(
     factory: (sequence: number, created_at: number) => SessionMessage,
     draft = false,
+    publish_mutation = true,
   ): Promise<SessionMessage> {
     await this.ensure_initialized();
     if (draft) {
@@ -733,13 +797,13 @@ export class SessionMessages {
         }
         return candidate;
       });
-      this.accept_message(message);
+      this.accept_message(message, publish_mutation);
       return message;
     }
     const message = await this.store.append_message((state) =>
       factory(state.message_sequence, Date.now()),
     );
-    this.accept_message(message);
+    this.accept_message(message, publish_mutation);
     return message;
   }
 
@@ -870,7 +934,11 @@ export class SessionMessages {
     } as SessionMessageSnapshotMutation;
   }
 
-  private accept_message(message: SessionMessage): void {
+  private accept_message(message: SessionMessage, publish_mutation = true): void {
+    if (!publish_mutation) {
+      this.messages_by_id.set(message.message_id, structuredClone(message));
+      return;
+    }
     this.accept_mutation(this.build_message_mutation(message), message);
   }
 
@@ -888,26 +956,42 @@ export class SessionMessages {
 export class SessionActionMessageWriter {
   readonly message_id: string;
   private readonly messages: SessionMessages;
+  private readonly publish_mutation: boolean;
   private closed = false;
 
-  constructor(messages: SessionMessages, message_id: string) {
+  constructor(
+    messages: SessionMessages,
+    message_id: string,
+    publish_mutation = true,
+  ) {
     this.messages = messages;
     this.message_id = message_id;
+    this.publish_mutation = publish_mutation;
   }
 
   /** 把 Action 更新为 completed。 */
   async complete(input?: { title?: string; description?: string; data?: JsonObject }): Promise<void> {
     if (this.closed) return;
-    await this.messages.update_action_message(this.message_id, "completed", input);
+    await this.messages.update_action_message(
+      this.message_id,
+      "completed",
+      input,
+      { publish_mutation: this.publish_mutation },
+    );
     this.closed = true;
   }
 
   /** 把 Action 更新为 failed。 */
   async fail(error: unknown): Promise<void> {
     if (this.closed) return;
-    await this.messages.update_action_message(this.message_id, "failed", {
-      description: error instanceof Error ? error.message : String(error),
-    });
+    await this.messages.update_action_message(
+      this.message_id,
+      "failed",
+      {
+        description: error instanceof Error ? error.message : String(error),
+      },
+      { publish_mutation: this.publish_mutation },
+    );
     this.closed = true;
   }
 }

package/src/session/SessionState.ts

@@ -25,6 +25,15 @@ import { to_executor_history } from "@/session/messages/SessionMessageCodec.js";
 import type { SessionMessage } from "@/types/session/SessionMessage.js";
 import type { SessionStateOptions } from "@/types/session/SessionState.js";
 import type { SessionStore } from "@/types/store/SessionStore.js";
+import type { SessionApprovalMode } from "@/types/session/SessionInteraction.js";
+
+/** Session 模型配置写入结果。 */
+export interface SessionModelSetResult {
+  /** 已包含最新运行时模型实例的 configured 快照。 */
+  config: AgentSessionConfigSnapshot;
+  /** 持久化模型身份是否发生真实变化。 */
+  changed: boolean;
+}
 
 /**
  * 本地 Session 配置与 Metadata 状态管理器。
@@ -61,6 +70,11 @@ export class SessionState {
     };
   }
 
+  /** 读取当前 Session 已接受的 Shell 审批模式。 */
+  get_approval_mode(): SessionApprovalMode {
+    return this.state.configured_approval_mode;
+  }
+
   /**
    * 读取当前 session 创建时间。
    */
@@ -99,10 +113,13 @@ export class SessionState {
       });
       this.state.created_at = created_at;
       this.state.timezone = timezone;
-      this.state.session_config = {};
+      this.state.session_config = {
+        ...(metadata.model_label ? { model_label: metadata.model_label } : {}),
+      };
       this.state.effective_session_config = {
         ...this.state.session_config,
       };
+      this.state.configured_approval_mode = metadata.approval_mode || "ask";
     })();
     await this.state.initialize_promise;
   }
@@ -141,23 +158,40 @@ export class SessionState {
   /**
    * 写入当前 session 配置。
    */
-  async set_model(model: AgentModel): Promise<AgentSessionConfigSnapshot> {
+  async set_model(model: AgentModel): Promise<SessionModelSetResult> {
     const next_model_label = infer_agent_model_label(model);
+    const changed = next_model_label !== this.state.session_config.model_label;
     const next_config: AgentSessionConfigSnapshot = {
       ...this.state.session_config,
       model,
       model_label: next_model_label,
       model_context_window: read_agent_model_context_window(model),
     };
+    if (changed) {
+      const metadata = await this.store.read_metadata();
+      await this.store.write_metadata({
+        ...metadata,
+        agent_id: this.agent_id,
+        updated_at: Date.now(),
+        ...(next_model_label ? { model_label: next_model_label } : {}),
+      });
+    }
+    this.state.session_config = next_config;
+    return { config: next_config, changed };
+  }
+
+  /** 接受并持久化当前 Session 的 Shell 审批模式。 */
+  async set_approval_mode(mode: SessionApprovalMode): Promise<boolean> {
+    if (mode === this.state.configured_approval_mode) return false;
     const metadata = await this.store.read_metadata();
     await this.store.write_metadata({
       ...metadata,
       agent_id: this.agent_id,
       updated_at: Date.now(),
-      ...(next_model_label ? { model_label: next_model_label } : {}),
+      approval_mode: mode,
     });
-    this.state.session_config = next_config;
-    return next_config;
+    this.state.configured_approval_mode = mode;
+    return true;
   }
 
   /** 在 Session Step 检查点提交模型配置。 */

package/src/session/messages/SessionAssistantMessageWriter.ts

@@ -217,13 +217,20 @@ export class SessionAssistantMessageWriter {
         return;
       }
       case "tool-input-delta": {
+        if (chunk.inputTextDelta.length === 0) return;
         const tool = this.find_tool(chunk.toolCallId);
-        if (tool && tool.state !== "input-streaming") return;
-        await this.upsert_tool(chunk.toolCallId, {
-          tool_name: tool?.tool_name || "unknown",
-          state: "input-streaming",
-          input_text: `${tool?.input_text || ""}${chunk.inputTextDelta}`,
-        });
+        if (!tool) {
+          throw new Error(
+            `Assistant canonical Tool Part not found: ${chunk.toolCallId}`,
+          );
+        }
+        if (tool.state !== "input-streaming") return;
+        await this.recorder.append_assistant_tool_input_delta(
+          this.message_id,
+          tool.part_id,
+          chunk.toolCallId,
+          chunk.inputTextDelta,
+        );
         return;
       }
       case "tool-input-available": {

package/src/session/storage/Metadata.ts

@@ -14,6 +14,13 @@ function normalizeModelLabel(input: unknown): string | undefined {
   return label || undefined;
 }
 
+/** 归一化 Session Shell 审批模式。 */
+function normalize_approval_mode(
+  input: unknown,
+): "ask" | "always-allow" | undefined {
+  return input === "ask" || input === "always-allow" ? input : undefined;
+}
+
 /**
  * 归一化 session 标题。
  */
@@ -106,6 +113,9 @@ export function normalize_session_metadata(
     ...(normalizeModelLabel(raw.model_label)
       ? { model_label: normalizeModelLabel(raw.model_label) }
       : {}),
+    ...(normalize_approval_mode(raw.approval_mode)
+      ? { approval_mode: normalize_approval_mode(raw.approval_mode) }
+      : {}),
     ...(normalize_message_count(raw.message_count) !== undefined
       ? { message_count: normalize_message_count(raw.message_count) }
       : {}),

package/src/types/agent/SessionActor.ts

@@ -18,6 +18,7 @@ import type {
   AgentSessionForkInput,
   AgentSessionInfo,
   AgentSessionSetInput,
+  AgentSessionSetOptions,
   AgentSessionStatus,
   AgentSessionSummaryPage,
   AgentSessionSystemSnapshot,
@@ -121,7 +122,7 @@ export interface AgentSession extends AgentSessionActor {
   readonly config: AgentSessionConfigSnapshot;
 
   /** 写入当前 session 默认配置。 */
-  set(input: AgentSessionSetInput): Promise<void>;
+  set(input: AgentSessionSetInput, options?: AgentSessionSetOptions): Promise<void>;
 
   /** 把当前 Session 首次生成后固定的完整 system 显式固化到 instruction.md。 */
   snapshot(): Promise<void>;
@@ -138,7 +139,7 @@ export interface AgentSession extends AgentSessionActor {
  */
 export interface RemoteAgentSession extends AgentSessionActor {
   /** 写入当前远程 Session 的可序列化动态配置。 */
-  set(input: RemoteSessionSetInput): Promise<void>;
+  set(input: RemoteSessionSetInput, options?: AgentSessionSetOptions): Promise<void>;
 
   /** 从当前远程 session 创建一个分叉会话。 */
   fork(input?: AgentSessionForkInput | string): Promise<RemoteAgentSession>;

package/src/types/agent/SessionTypes.ts

@@ -80,6 +80,28 @@ export interface AgentSessionSetInput {
   security?: AgentSessionSecurityConfig;
 }
 
+/** Session 配置提交后的 Action 可观测性选项。 */
+export interface AgentSessionSetOptions {
+  /**
+   * 是否把真实配置变化持久化为 completed Action Message。
+   *
+   * 关键点（中文）
+   * - 默认值为 true。
+   * - 设为 false 只关闭 Action Message，不影响配置写入与检查点提交。
+   * - 适用于 Session 初始化、恢复与其他不应进入时间线的宿主装配流程。
+   */
+  persist_action?: boolean;
+
+  /**
+   * 是否在 Action Message 持久化成功后发布对应 Session Mutation。
+   *
+   * 关键点（中文）
+   * - 默认跟随 `persist_action`。
+   * - 只有 `persist_action=true` 时才允许设为 true，避免发布不存在于 canonical Message 历史中的事件。
+   */
+  publish_mutation?: boolean;
+}
+
 /** 可通过本地或远程 Session 动态更新的安全策略。 */
 export interface AgentSessionSecurityConfig {
   /** 高风险操作是否需要用户逐次审批。 */

package/src/types/rpc/RpcProtocol.ts

@@ -15,6 +15,7 @@ import type {
   AgentArchiveSessionResult,
   AgentArchiveSessionsResult,
   AgentCleanArchiveResult,
+  AgentSessionSetOptions,
   RemoteSessionSetInput,
   AgentSessionSystemSnapshot,
 } from "@/types/agent/SessionTypes.js";
@@ -155,7 +156,11 @@ export type RpcRequest =
       /** 更新指定 Session 的可序列化动态配置。 */
       method: "sdk.sessions.set";
       /** Session 与动态配置参数。 */
-      params: { session_id: string; input: RemoteSessionSetInput };
+      params: {
+        session_id: string;
+        input: RemoteSessionSetInput;
+        options?: AgentSessionSetOptions;
+      };
     }
   | {
       /** 请求 id，用于匹配响应。 */

package/src/types/session/SessionCommand.ts

@@ -24,4 +24,6 @@ export interface SessionCommandCompletion {
   title: string;
   /** Action Message 展示的可选结果说明。 */
   description?: string;
+  /** Action Message 持久化后是否发布对应 Session Mutation。 */
+  publish_mutation?: boolean;
 }

package/src/types/session/SessionLocalState.ts

@@ -8,6 +8,7 @@
  */
 
 import type { AgentSessionConfigSnapshot } from "@/types/agent/SessionTypes.js";
+import type { SessionApprovalMode } from "@/types/session/SessionInteraction.js";
 
 /**
  * 本地 Session 内存状态。
@@ -27,6 +28,9 @@ export interface SessionLocalState {
    */
   effective_session_config: AgentSessionConfigSnapshot;
 
+  /** 当前 Session 已接受并持久化的 Shell 审批模式。 */
+  configured_approval_mode: SessionApprovalMode;
+
   /**
    * 当前 session 创建时间（毫秒时间戳）。
    */

package/src/types/session/SessionMessages.ts

@@ -80,6 +80,8 @@ export interface OpenSessionActionMessageInput {
   description?: string;
   /** 当前 Action 附加数据。 */
   data?: JsonObject;
+  /** Action 创建或更新后是否发布对应 Session Mutation。 */
+  publish_mutation?: boolean;
 }
 
 /** Error Message 创建参数。 */

package/src/types/session/SessionMutation.ts

@@ -56,12 +56,10 @@ export type SessionPartMutation = {
   };
 }[SessionAssistantMessagePart["type"]];
 
-/** Assistant 文本或推理的原始增量 Mutation。 */
-export interface SessionDeltaMutation extends SessionMutationBase {
+/** Assistant Part 原始增量 Mutation 的公共字段。 */
+interface SessionDeltaMutationBase extends SessionMutationBase {
   /** Mutation 层级固定为 delta。 */
   variant: "delta";
-  /** Delta 只允许可见文本或推理文本。 */
-  type: "text" | "reasoning";
   /** 当前 Delta 所属 Message 标识。 */
   message_id: string;
   /** 当前 Mutation 所属 Turn 标识。 */
@@ -74,6 +72,25 @@ export interface SessionDeltaMutation extends SessionMutationBase {
   delta: string;
 }
 
+/** Assistant 文本或推理的原始增量 Mutation。 */
+interface SessionTextDeltaMutation extends SessionDeltaMutationBase {
+  /** Delta 属于可见文本或推理文本。 */
+  type: "text" | "reasoning";
+}
+
+/** Assistant Tool 输入的原始增量 Mutation。 */
+interface SessionToolInputDeltaMutation extends SessionDeltaMutationBase {
+  /** Delta 属于 Tool 输入参数原文。 */
+  type: "tool_input";
+  /** 当前 Delta 所属 Tool Call 标识。 */
+  tool_call_id: string;
+}
+
+/** Assistant 文本、推理或 Tool 输入的原始增量 Mutation。 */
+export type SessionDeltaMutation =
+  | SessionTextDeltaMutation
+  | SessionToolInputDeltaMutation;
+
 /** Turn 生命周期 Mutation。 */
 export type SessionTurnMutation = SessionMutationBase & {
   /** Mutation 层级固定为 turn。 */