@downcity/agent 1.1.222 → 1.1.224

package/scripts/session-recorder.test.mjs

@@ -1,5 +1,5 @@
 /**
- * @file 验证 SessionRecorder 单一 Mutation 日志与实时/历史一致性。
+ * @file 验证 SessionRecorder 的 Message 快照、Assistant 草稿与实时事件一致性。
  */
 
 import test from "node:test";
@@ -14,10 +14,9 @@ import { SessionRecorderHistoryStore } from "../bin/session/recorder/SessionReco
 import { MockLanguageModelV3 } from "ai/test";
 
 async function create_recorder(session_id = "session-recorder-test") {
-  const root_path = await fs.mkdtemp(
-    path.join(os.tmpdir(), "downcity-session-recorder-"),
-  );
+  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-session-recorder-"));
   const file_path = path.join(root_path, "messages.jsonl");
+  const assistant_message_file_path = path.join(root_path, "assistant_message.json");
   const events = [];
   const recorder = new SessionRecorder({
     session_id,
@@ -25,189 +24,151 @@ async function create_recorder(session_id = "session-recorder-test") {
     publish: (mutation) => events.push(mutation),
   });
   await recorder.initialize();
-  return { recorder, events, file_path };
+  return { recorder, events, file_path, assistant_message_file_path };
+}
+
+async function read_jsonl(file_path) {
+  const raw = await fs.readFile(file_path, "utf8");
+  return raw.split("\n").filter(Boolean).map((line) => JSON.parse(line));
 }
 
-test("每个 assistant delta 都先持久化为独立 Mutation 再发布", async () => {
-  const { recorder, events, file_path } = await create_recorder();
+test("delta 只更新 Assistant 草稿，完成后才写入 messages.jsonl", async () => {
+  const { recorder, events, file_path, assistant_message_file_path } = await create_recorder();
   await recorder.append_user_message({
     turn_id: "turn-1",
     input_type: "prompt",
-    parts: [{
-      part_id: "user-text-1",
-      type: "text",
-      text: "你好",
-      state: "done",
-    }],
-  });
-  const writer = await recorder.open_assistant_message({
-    turn_id: "turn-1",
-    segment_index: 1,
+    parts: [{ part_id: "user-text-1", type: "text", text: "你好", state: "done" }],
   });
+  const writer = await recorder.open_assistant_message({ turn_id: "turn-1", segment_index: 1 });
   await writer.apply_chunk({ type: "text-start", id: "text-1" });
   await writer.apply_chunk({ type: "text-delta", id: "text-1", delta: "你" });
   await writer.apply_chunk({ type: "text-delta", id: "text-1", delta: "好" });
+
+  const history_during_stream = await read_jsonl(file_path);
+  const draft = JSON.parse(await fs.readFile(assistant_message_file_path, "utf8"));
+  assert.equal(history_during_stream.length, 1);
+  assert.equal(history_during_stream[0].type, "user");
+  assert.equal(draft.type, "assistant");
+  assert.equal(draft.parts[0].text, "你好");
+  assert.equal(draft.parts[0].sequence, 1);
+
   await writer.apply_chunk({ type: "text-end", id: "text-1" });
   await writer.complete();
 
-  const changes = await recorder.list_message_changes({
-    after_commit_sequence: 0,
-  });
-  const persisted_lines = (await fs.readFile(file_path, "utf8"))
-    .trim()
-    .split("\n");
-  assert.equal(persisted_lines.length, changes.items.length);
-  assert.deepEqual(
-    changes.items.map((item) => item.commit_sequence),
-    events.map((item) => item.commit_sequence),
-  );
-  assert.deepEqual(
-    changes.items.map((item) => `${item.variant}:${item.type}`),
-    [
-      "message:user",
-      "message:assistant",
-      "part:text",
-      "delta:text",
-      "delta:text",
-      "part:text",
-      "message:assistant",
-    ],
-  );
-  assert.deepEqual(
-    changes.items
-      .filter((item) => item.variant === "delta")
-      .map((item) => item.delta),
-    ["你", "好"],
-  );
-
-  const page = await recorder.list_messages();
-  assert.deepEqual(page.items.map((item) => item.type), ["user", "assistant"]);
-  const assistant = page.items[1];
-  assert.equal(assistant.status, "completed");
-  assert.equal(assistant.parts[0].text, "你好");
+  const history = await read_jsonl(file_path);
+  assert.deepEqual(history.map((message) => message.type), ["user", "assistant"]);
+  assert.equal(history[1].parts[0].text, "你好");
+  assert.equal(await fs.stat(assistant_message_file_path).then(() => true).catch(() => false), false);
+  assert.deepEqual(events.map((event) => `${event.variant}:${event.type}`), [
+    "message:user",
+    "message:assistant",
+    "part:text",
+    "delta:text",
+    "delta:text",
+    "part:text",
+    "message:assistant",
+  ]);
+  assert.equal(history.some((value) => "variant" in value), false);
 });
 
-test("tool 与 action 在原 Message 和 part 上更新", async () => {
-  const { recorder } = await create_recorder("tool-action-test");
-  const writer = await recorder.open_assistant_message({
-    turn_id: "turn-1",
-    segment_index: 1,
-  });
-  await writer.apply_chunk({
-    type: "tool-input-start",
-    toolCallId: "call-1",
-    toolName: "search",
-  });
+test("Tool Part 在文本中间创建后，输入、审批和输出都保持原顺序", async () => {
+  const { recorder, events, file_path } = await create_recorder("tool-order-test");
+  const writer = await recorder.open_assistant_message({ turn_id: "turn-1", segment_index: 1 });
+  await writer.apply_chunk({ type: "text-start", id: "text-1" });
+  await writer.apply_chunk({ type: "text-delta", id: "text-1", delta: "before" });
+  await writer.apply_chunk({ type: "text-end", id: "text-1" });
+  await writer.apply_chunk({ type: "tool-input-start", toolCallId: "call-1", toolName: "search" });
   await writer.apply_chunk({
     type: "tool-input-available",
     toolCallId: "call-1",
     toolName: "search",
     input: { query: "downcity" },
   });
+  assert.equal(recorder.get_message(writer.message_id).parts[1].state, "ready");
   await writer.apply_chunk({
-    type: "tool-output-available",
+    type: "tool-approval-request",
     toolCallId: "call-1",
-    output: { count: 1 },
+    approvalId: "approval-1",
   });
+  assert.equal(recorder.get_message(writer.message_id).parts[1].state, "approval-required");
+  await writer.apply_chunk({ type: "text-start", id: "text-2" });
+  await writer.apply_chunk({ type: "text-delta", id: "text-2", delta: "after" });
+  await writer.apply_chunk({ type: "text-end", id: "text-2" });
+  await writer.apply_chunk({ type: "tool-output-available", toolCallId: "call-1", output: { count: 1 } });
   await writer.complete();
 
-  const action = await recorder.open_action_message({
-    message_id: "action-1",
-    action_type: "compact",
-    title: "Compacting",
-  });
-  const running = recorder.get_message("action-1");
-  await action.complete({ title: "Compacted" });
-  const completed = recorder.get_message("action-1");
-
-  const assistant = (await recorder.list_messages()).items[0];
-  assert.equal(assistant.parts.length, 1);
-  assert.equal(assistant.parts[0].state, "completed");
-  assert.deepEqual(assistant.parts[0].output, { count: 1 });
-  assert.equal(running.sequence, completed.sequence);
-  assert.equal(completed.revision, running.revision + 1);
-  assert.equal(completed.status, "completed");
+  const assistant = (await read_jsonl(file_path))[0];
+  assert.deepEqual(assistant.parts.map((part) => part.type), ["text", "tool", "text"]);
+  assert.deepEqual(assistant.parts.map((part) => part.sequence), [1, 2, 3]);
+  assert.equal(assistant.parts[1].state, "completed");
+  assert.deepEqual(assistant.parts[1].output, { count: 1 });
+  assert.deepEqual(
+    events
+      .filter((event) => event.variant === "part" && event.type === "tool")
+      .map((event) => [event.part.sequence, event.part.state]),
+    [[2, "input-streaming"], [2, "ready"], [2, "approval-required"], [2, "completed"]],
+  );
 });
 
-test("snapshot、changes 分页和重启恢复保持单调顺序", async () => {
-  const { recorder, file_path } = await create_recorder("recovery-test");
+test("重启时将 Assistant 草稿收口为 stopped，并将运行中 Action 标记失败", async () => {
+  const { recorder, file_path, assistant_message_file_path } = await create_recorder("recovery-test");
   await recorder.append_user_message({
     turn_id: "turn-1",
     input_type: "prompt",
     parts: [{ part_id: "u1", type: "text", text: "one", state: "done" }],
   });
-  await recorder.open_assistant_message({
-    turn_id: "turn-1",
-    segment_index: 1,
-  });
-  await recorder.open_action_message({
-    message_id: "running-action",
-    action_type: "fork",
-    title: "Forking",
-  });
+  const writer = await recorder.open_assistant_message({ turn_id: "turn-1", segment_index: 1 });
+  await writer.apply_chunk({ type: "text-start", id: "text-1" });
+  await writer.apply_chunk({ type: "text-delta", id: "text-1", delta: "partial" });
+  await recorder.open_action_message({ message_id: "running-action", action_type: "fork", title: "Forking" });
 
   const recovered_events = [];
   const recovered = new SessionRecorder({
     session_id: "recovery-test",
-    store: new JsonlSessionMessageStore({
-      session_id: "recovery-test",
-      file_path,
-    }),
+    store: new JsonlSessionMessageStore({ session_id: "recovery-test", file_path }),
     publish: (mutation) => recovered_events.push(mutation),
   });
   await recovered.initialize();
 
-  const first_page = await recovered.list_messages({ limit: 2 });
-  const second_page = await recovered.list_messages({
-    limit: 2,
-    cursor: first_page.next_cursor,
-  });
-  assert.equal(first_page.items.length, 2);
-  assert.equal(second_page.items.length, 1);
-  assert.ok(first_page.items[1].sequence < second_page.items[0].sequence);
-
-  const messages = [...first_page.items, ...second_page.items];
-  assert.equal(messages[1].status, "stopped");
-  assert.equal(messages[2].status, "failed");
-  assert.deepEqual(
-    recovered_events.map((item) => `${item.variant}:${item.type}`),
-    ["message:assistant", "message:action"],
-  );
+  const page = await recovered.list_messages({ limit: 10 });
+  assert.deepEqual(page.items.map((message) => message.type), ["user", "assistant", "action"]);
+  assert.equal(page.items[1].status, "stopped");
+  assert.equal(page.items[1].parts[0].text, "partial");
+  assert.equal(page.items[2].status, "failed");
+  assert.deepEqual(recovered_events.map((event) => `${event.variant}:${event.type}`), [
+    "message:assistant",
+    "message:action",
+  ]);
+  assert.equal(await fs.stat(assistant_message_file_path).then(() => true).catch(() => false), false);
+});
 
-  const first_changes = await recovered.list_message_changes({
-    after_commit_sequence: 0,
-    limit: 2,
-  });
-  const next_changes = await recovered.list_message_changes({
-    after_commit_sequence: first_changes.next_commit_sequence,
-    limit: 100,
+test("Action revision 追加完整快照，读取时只返回最新版本", async () => {
+  const { recorder, file_path } = await create_recorder("action-revision-test");
+  const action = await recorder.open_action_message({
+    message_id: "action-1",
+    action_type: "compact",
+    title: "Compacting",
   });
-  assert.equal(first_changes.has_more, true);
-  assert.ok(
-    first_changes.items.at(-1).commit_sequence <
-      next_changes.items[0].commit_sequence,
-  );
+  await action.complete({ title: "Compacted" });
+  const history = await read_jsonl(file_path);
+  assert.equal(history.length, 2);
+  assert.deepEqual(history.map((message) => message.revision), [1, 2]);
+  const page = await recorder.list_messages();
+  assert.equal(page.items.length, 1);
+  assert.equal(page.items[0].title, "Compacted");
 });
 
-test("compact 追加 internal summary 且不重写 Mutation 日志", async () => {
+test("compact 追加 internal summary 且不重写已有 Message 快照", async () => {
   const { recorder, file_path } = await create_recorder("compact-test");
   for (let index = 1; index <= 6; index += 1) {
     await recorder.append_user_message({
       turn_id: `turn-${String(index)}`,
       input_type: "prompt",
-      parts: [{
-        part_id: `user-${String(index)}`,
-        type: "text",
-        text: `message ${String(index)}`,
-        state: "done",
-      }],
+      parts: [{ part_id: `user-${String(index)}`, type: "text", text: `message ${String(index)}`, state: "done" }],
     });
   }
   const before = await fs.readFile(file_path, "utf8");
-  const history_store = new SessionRecorderHistoryStore({
-    session_id: "compact-test",
-    recorder,
-  });
+  const history_store = new SessionRecorderHistoryStore({ session_id: "compact-test", recorder });
   const model = new MockLanguageModelV3({
     modelId: "compact-model",
     doGenerate: async () => ({
@@ -229,17 +190,10 @@ test("compact 追加 internal summary 且不重写 Mutation 日志", async () =>
     compactRatio: 0.5,
   });
   assert.equal(result.compacted, true);
-
-  const after = await fs.readFile(file_path, "utf8");
-  assert.equal(after.startsWith(before), true);
-  const all = await recorder.list_messages({
-    limit: 100,
-    include_internal: true,
-  });
-  const summary = all.items.find(
-    (message) => message.type === "assistant" && message.kind === "summary",
-  );
+  assert.equal((await fs.readFile(file_path, "utf8")).startsWith(before), true);
+  const all = await recorder.list_messages({ limit: 100, include_internal: true });
+  const summary = all.items.find((message) => message.type === "assistant" && message.kind === "summary");
   assert.equal(summary.visibility, "internal");
-  assert.equal(summary.summary_through_message_id, all.items[2].message_id);
+  assert.equal(summary.parts[0].sequence, 1);
   assert.equal((await history_store.list_records()).length, 4);
 });

package/src/agent/local/Agent.ts

@@ -15,12 +15,6 @@ import type { AgentModel } from "@/model/CityModelAdapter.js";
 import type { AgentOptions } from "@/types/agent/AgentOptions.js";
 import type { AgentSessions as AgentSessionsApi } from "@/types/agent/SessionActor.js";
 import type {
-  ShellApprovalMode,
-  ShellApprovalDecisionResult,
-  ShellApprovalModeUpdateResult,
-  ShellApprovalModeOption,
-  ShellSessionApprovalModeView,
-  ShellApprovalView,
   Shell,
 } from "@downcity/shell";
 import { Logger } from "@/utils/logger/Logger.js";
@@ -122,55 +116,6 @@ export class Agent {
     await this.backgroundService.dispose();
   }
 
-  /**
-   * 列出当前 shell pending approvals。
-   */
-  approvals(): ShellApprovalView[] {
-    return this.shell?.approvals() || [];
-  }
-
-  /**
-   * 列出当前 shell 显式设置过的 approval 模式。
-   */
-  approval_modes(): ShellApprovalModeOption[] {
-    return this.shell?.approval_modes() || [];
-  }
-
-  /**
-   * 读取当前 shell 指定 session 的 approval 模式。
-   */
-  approval_mode(input: { session_id: string }): ShellSessionApprovalModeView {
-    if (!this.shell) throw new Error("Agent shell is not configured");
-    return this.shell.approval_mode(input);
-  }
-
-  /**
-   * 设置当前 shell 指定 session 的 approval 模式。
-   */
-  set_approval_mode(input: {
-    session_id: string;
-    mode: ShellApprovalMode;
-  }): ShellApprovalModeUpdateResult {
-    if (!this.shell) throw new Error("Agent shell is not configured");
-    return this.shell.set_approval_mode(input);
-  }
-
-  /**
-   * 批准当前 shell pending approval。
-   */
-  async approve(input: { approval_id: string }): Promise<ShellApprovalDecisionResult> {
-    if (!this.shell) throw new Error("Agent shell is not configured");
-    return await this.shell.approve(input);
-  }
-
-  /**
-   * 拒绝当前 shell pending approval。
-   */
-  async deny(input: { approval_id: string }): Promise<ShellApprovalDecisionResult> {
-    if (!this.shell) throw new Error("Agent shell is not configured");
-    return await this.shell.deny(input);
-  }
-
   /**
    * 更新当前 SDK Agent 的静态基础指令。
    */
@@ -260,6 +205,7 @@ export class Agent {
       tools: this.tools || assembly.tools,
       logger: this.logger || assembly.logger,
       get_agent_context: () => this.agentContext ?? assembly.agent_context,
+      get_shell: () => this.shell,
       get_instruction: () => this.instruction,
       ensure_agent_ready: async () => {
         await this.backgroundService.ready();

package/src/agent/local/services/AgentAssemblyService.ts

@@ -32,7 +32,7 @@ import {
 } from "@executor/tools/plugin/PluginToolDefinition.js";
 import type { AgentManagedSession } from "@/types/session/SessionOptions.js";
 import type { SessionPort } from "@/types/runtime/agent/AgentContext.js";
-import type { AgentSessionEvent } from "@/types/sdk/AgentSessionEvent.js";
+import type { SessionApprovalRuntimeEvent } from "@/types/session/SessionApproval.js";
 
 type AgentAssemblyServiceOptions = {
   /**
@@ -215,10 +215,12 @@ export class AgentAssemblyService {
         env,
         agent_id: id,
         logger,
-        emit_event: (event) => {
+        emit_event: async (event) => {
           const session_id = String(event.session_id || "").trim();
           if (!session_id) return;
-      agent_context!.session.get(session_id).publishEvent(event as unknown as AgentSessionEvent);
+          const approval_event = normalize_approval_runtime_event(event);
+          if (!approval_event) return;
+          await agent_context!.session.get(session_id).publishEvent(approval_event);
         },
       });
       Object.assign(tools, shell.tools);
@@ -269,3 +271,37 @@ export class AgentAssemblyService {
     return false;
   }
 }
+
+function normalize_approval_runtime_event(
+  event: Record<string, unknown>,
+): SessionApprovalRuntimeEvent | null {
+  if (event.type === "tool-approval-request") {
+    return {
+      type: "tool-approval-request",
+      turn_id: String(event.turnId || ""),
+      tool_call_id: String(event.toolCallId || ""),
+      tool_name: String(event.toolName || "unknown"),
+      approval_id: String(event.approvalId || ""),
+      command: String(event.cmd || ""),
+      cwd: String(event.cwd || ""),
+      reason: String(event.reason || ""),
+      operation:
+        event.operation === "start" || event.operation === "write"
+          ? event.operation
+          : "exec",
+    };
+  }
+  if (event.type === "tool-approval-result") {
+    const decision = event.decision === "approved" || event.decision === "denied"
+      ? event.decision
+      : "expired";
+    return {
+      type: "tool-approval-result",
+      turn_id: String(event.turnId || ""),
+      tool_call_id: String(event.toolCallId || ""),
+      approval_id: String(event.approvalId || ""),
+      decision,
+    };
+  }
+  return null;
+}

package/src/agent/local/services/AgentSessions.ts

@@ -39,6 +39,8 @@ import {
 import type { AgentContext } from "@/types/runtime/agent/AgentContext.js";
 import type { SessionPort } from "@/types/runtime/agent/AgentContext.js";
 import { createInstructionSystemBlocks } from "@/agent/local/AgentInstructions.js";
+import type { Shell } from "@downcity/shell";
+import type { SessionApproval } from "@/types/session/SessionApproval.js";
 
 function decodeMaybe(input: string): string {
   try {
@@ -77,6 +79,9 @@ type AgentSessionsOptions = {
    */
   get_agent_context: () => AgentContext;
 
+  /** 延迟读取当前 Agent 挂载的 Shell Runtime。 */
+  get_shell: () => Shell | undefined;
+
   /**
    * 当前静态 instruction 文本集合。
    */
@@ -113,6 +118,7 @@ export class AgentSessions implements AgentSessionsApi<AgentSession> {
   private readonly tools: Record<string, Tool>;
   private readonly logger: Logger;
   private readonly get_agent_context: AgentSessionsOptions["get_agent_context"];
+  private readonly get_shell: AgentSessionsOptions["get_shell"];
   private readonly get_instruction: AgentSessionsOptions["get_instruction"];
   private readonly ensure_agent_ready: AgentSessionsOptions["ensure_agent_ready"];
   private readonly default_model?: AgentModel;
@@ -128,6 +134,7 @@ export class AgentSessions implements AgentSessionsApi<AgentSession> {
     this.tools = options.tools;
     this.logger = options.logger;
     this.get_agent_context = options.get_agent_context;
+    this.get_shell = options.get_shell;
     this.get_instruction = options.get_instruction;
     this.ensure_agent_ready = options.ensure_agent_ready;
     this.default_model = options.default_model;
@@ -348,11 +355,51 @@ export class AgentSessions implements AgentSessionsApi<AgentSession> {
         await this.apply_session_defaults(session);
       },
       ...(this.resolve_model ? { resolve_model: this.resolve_model } : {}),
+      list_approvals: async (session_id) => this.list_session_approvals(session_id),
+      get_approval_mode: async (session_id) => {
+        const shell = this.require_shell();
+        return shell.approval_mode({ session_id });
+      },
+      set_approval_mode: async (session_id, { mode }) => {
+        const shell = this.require_shell();
+        return shell.set_approval_mode({ session_id, mode });
+      },
+      resolve_approval: async (session_id, { approval_id, decision }) => {
+        const approval = this.list_session_approvals(session_id)
+          .find((item) => item.approval_id === approval_id);
+        if (!approval) return { success: false, approval_id, decision };
+        return decision === "approved"
+          ? await this.require_shell().approve({ approval_id })
+          : await this.require_shell().deny({ approval_id });
+      },
     });
     this.sessions_by_id.set(resolved_session_id, created);
     return created;
   }
 
+  private require_shell(): Shell {
+    const shell = this.get_shell();
+    if (!shell) throw new Error("Session shell is not configured");
+    return shell;
+  }
+
+  private list_session_approvals(session_id: string): SessionApproval[] {
+    return (this.get_shell()?.approvals() || [])
+      .filter((approval) => approval.session_id === session_id)
+      .map((approval) => ({
+        approval_id: approval.approval_id,
+        session_id,
+        ...(approval.turn_id ? { turn_id: approval.turn_id } : {}),
+        ...(approval.tool_call_id ? { tool_call_id: approval.tool_call_id } : {}),
+        tool_name: approval.tool_name,
+        command: approval.cmd,
+        cwd: approval.cwd,
+        reason: approval.reason,
+        operation: approval.operation,
+        created_at: approval.created_at,
+      }));
+  }
+
   private async apply_session_defaults(
     session: AgentManagedSession,
   ): Promise<void> {

package/src/agent/remote/RemoteAgent.ts

@@ -23,14 +23,6 @@ import type {
   RemoteAgentPluginActionInput,
   RemoteAgentPluginActionResult,
 } from "@/types/agent/RemoteAgentPluginAction.js";
-import type {
-  ShellApprovalMode,
-  ShellApprovalDecisionResult,
-  ShellApprovalModeUpdateResult,
-  ShellApprovalModeOption,
-  ShellSessionApprovalModeView,
-  ShellApprovalView,
-} from "@downcity/shell";
 import type { RemoteAgentTransport } from "@/agent/remote/RemoteTransport.js";
 import { RemoteSession } from "@/agent/remote/RemoteSession.js";
 import { create_remote_agent_transport } from "@/agent/remote/TransportFactory.js";
@@ -57,7 +49,7 @@ export class RemoteAgent {
    *
    * 关键点（中文）
    * - 这是 RemoteAgent 顶层能力，不绑定某个 session。
-   * - Shell approval 请使用 `approvals()` / `approve()` / `deny()`。
+   * - Shell approval 通过具体 RemoteSession 处理。
    */
   async runPluginAction(
     input: RemoteAgentPluginActionInput,
@@ -77,51 +69,6 @@ export class RemoteAgent {
     });
   }
 
-  /**
-   * 列出远程 Agent 的 shell pending approvals。
-   */
-  async approvals(): Promise<ShellApprovalView[]> {
-    return await this.transport.approvals();
-  }
-
-  /**
-   * 列出远程 Agent 显式设置过的 shell approval 模式。
-   */
-  async approval_modes(): Promise<ShellApprovalModeOption[]> {
-    return await this.transport.approval_modes();
-  }
-
-  /**
-   * 读取远程 Agent 指定 session 的 shell approval 模式。
-   */
-  async approval_mode(input: { session_id: string }): Promise<ShellSessionApprovalModeView> {
-    return await this.transport.approval_mode(input);
-  }
-
-  /**
-   * 设置远程 Agent 指定 session 的 shell approval 模式。
-   */
-  async set_approval_mode(input: {
-    session_id: string;
-    mode: ShellApprovalMode;
-  }): Promise<ShellApprovalModeUpdateResult> {
-    return await this.transport.set_approval_mode(input);
-  }
-
-  /**
-   * 批准远程 Agent 的 shell approval。
-   */
-  async approve(input: { approval_id: string }): Promise<ShellApprovalDecisionResult> {
-    return await this.transport.approve(input);
-  }
-
-  /**
-   * 拒绝远程 Agent 的 shell approval。
-   */
-  async deny(input: { approval_id: string }): Promise<ShellApprovalDecisionResult> {
-    return await this.transport.deny(input);
-  }
-
   /**
    * 关闭远程 transport。
    *