@downcity/agent 1.1.226 → 1.1.232

package/scripts/session-recorder.test.mjs

@@ -11,11 +11,12 @@ import path from "node:path";
 import { JsonlSessionMessageStore } from "../bin/session/recorder/JsonlSessionMessageStore.js";
 import { SessionRecorder } from "../bin/session/recorder/SessionRecorder.js";
 import { SessionRecorderHistoryStore } from "../bin/session/recorder/SessionRecorderHistoryStore.js";
+import { SessionViewService } from "../bin/session/services/SessionViewService.js";
 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 file_path = path.join(root_path, "messages.jsonl");
+  const file_path = path.join(root_path, "active.jsonl");
   const assistant_message_file_path = path.join(root_path, "assistant_message.json");
   const events = [];
   const recorder = new SessionRecorder({
@@ -32,7 +33,45 @@ async function read_jsonl(file_path) {
   return raw.split("\n").filter(Boolean).map((line) => JSON.parse(line));
 }
 
-test("delta 只更新 Assistant 草稿，完成后才写入 messages.jsonl", async () => {
+async function create_seeded_recorder(session_id, messages) {
+  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-session-seeded-"));
+  const file_path = path.join(root_path, "active.jsonl");
+  await fs.writeFile(
+    file_path,
+    `${messages.map((message) => JSON.stringify(message)).join("\n")}\n`,
+    "utf8",
+  );
+  const recorder = new SessionRecorder({
+    session_id,
+    store: new JsonlSessionMessageStore({ session_id, file_path }),
+    publish: () => {},
+  });
+  await recorder.initialize();
+  return { recorder, file_path };
+}
+
+function create_seeded_user_message(session_id, sequence) {
+  return {
+    message_id: `user-${String(sequence)}`,
+    session_id,
+    turn_id: `turn-${String(sequence)}`,
+    sequence,
+    revision: 1,
+    visibility: "visible",
+    created_at: sequence,
+    updated_at: sequence,
+    type: "user",
+    input_type: "prompt",
+    parts: [{
+      part_id: `user-text-${String(sequence)}`,
+      type: "text",
+      text: `message ${String(sequence)}`,
+      state: "done",
+    }],
+  };
+}
+
+test("delta 只更新 Assistant 草稿，完成后才写入 active.jsonl", async () => {
   const { recorder, events, file_path, assistant_message_file_path } = await create_recorder();
   await recorder.append_user_message({
     turn_id: "turn-1",
@@ -110,6 +149,45 @@ test("Tool Part 在文本中间创建后，输入、审批和输出都保持原
   );
 });
 
+test("不同模型 step 重复使用 Text chunk ID 时仍保持真实 Part 顺序", async () => {
+  const { recorder, file_path } = await create_recorder("reused-text-id-order-test");
+  const writer = await recorder.open_assistant_message({ turn_id: "turn-1", segment_index: 1 });
+
+  await writer.apply_chunk({ type: "text-start", id: "txt-0" });
+  await writer.apply_chunk({ type: "text-delta", id: "txt-0", delta: "first" });
+  await writer.apply_chunk({ type: "text-end", id: "txt-0" });
+  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: "first" },
+  });
+  await writer.apply_chunk({ type: "tool-output-available", toolCallId: "call-1", output: "one" });
+
+  await writer.apply_chunk({ type: "text-start", id: "txt-0" });
+  await writer.apply_chunk({ type: "text-delta", id: "txt-0", delta: "second" });
+  await writer.apply_chunk({ type: "text-end", id: "txt-0" });
+  await writer.apply_chunk({ type: "tool-input-start", toolCallId: "call-2", toolName: "search" });
+  await writer.apply_chunk({
+    type: "tool-input-available",
+    toolCallId: "call-2",
+    toolName: "search",
+    input: { query: "second" },
+  });
+  await writer.apply_chunk({ type: "tool-output-available", toolCallId: "call-2", output: "two" });
+  await writer.complete();
+
+  const assistant = (await read_jsonl(file_path))[0];
+  assert.deepEqual(assistant.parts.map((part) => part.type), ["text", "tool", "text", "tool"]);
+  assert.deepEqual(assistant.parts.map((part) => part.sequence), [1, 2, 3, 4]);
+  assert.deepEqual(
+    assistant.parts.filter((part) => part.type === "text").map((part) => part.text),
+    ["first", "second"],
+  );
+  assert.notEqual(assistant.parts[0].part_id, assistant.parts[2].part_id);
+});
+
 test("空 Text Start 不会抢占后续 Tool 的真实顺序", async () => {
   const { recorder, events, file_path } = await create_recorder("deferred-text-order-test");
   const writer = await recorder.open_assistant_message({ turn_id: "turn-1", segment_index: 1 });
@@ -177,7 +255,7 @@ test("重启时将 Assistant 草稿收口为 stopped，并将运行中 Action
   });
   await recovered.initialize();
 
-  const page = await recovered.list_messages({ limit: 10 });
+  const page = await recovered.list_messages();
   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");
@@ -205,7 +283,7 @@ test("Action revision 追加完整快照，读取时只返回最新版本", asyn
   assert.equal(page.items[0].title, "Compacted");
 });
 
-test("compact 追加 internal summary 且不重写已有 Message 快照", async () => {
+test("compact 把 Active 前缀关闭为带累计 Summary 的 Segment", async () => {
   const { recorder, file_path } = await create_recorder("compact-test");
   for (let index = 1; index <= 6; index += 1) {
     await recorder.append_user_message({
@@ -214,7 +292,6 @@ test("compact 追加 internal summary 且不重写已有 Message 快照", async
       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 model = new MockLanguageModelV3({
     modelId: "compact-model",
@@ -233,14 +310,305 @@ test("compact 追加 internal summary 且不重写已有 Message 快照", async
     system: [],
     keepLastMessages: 2,
     maxInputTokensApprox: 1,
-    archiveOnCompact: false,
     compactRatio: 0.5,
   });
   assert.equal(result.compacted, true);
-  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.parts[0].sequence, 1);
+  assert.equal((await fs.readFile(file_path, "utf8")).includes("message 1"), false);
+  const active = await recorder.list_messages({ include_internal: true });
+  assert.deepEqual(active.items.map((message) => message.sequence), [4, 5, 6]);
+  assert.equal(active.source, "active");
+  assert.equal(active.has_more, true);
+  const segment = await recorder.list_messages({
+    before_sequence: active.start_sequence,
+    include_internal: true,
+  });
+  assert.deepEqual(segment.items.map((message) => message.sequence), [1, 2, 3]);
+  assert.equal(segment.source, "segment");
   assert.equal((await history_store.list_records()).length, 4);
+  await assert.rejects(
+    recorder.list_messages({ before_sequence: 0 }),
+    /before_sequence must be a positive integer/,
+  );
+});
+
+test("重启后从最新 Segment Summary 与 Active 恢复模型上下文", async () => {
+  const session_id = "compact-restart-test";
+  const { recorder, file_path } = await create_recorder(session_id);
+  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",
+      }],
+    });
+  }
+  await recorder.compact_active({
+    through_sequence: 4,
+    summary: {
+      record_type: "summary",
+      session_id,
+      summary_id: "summary-through-4",
+      through_sequence: 4,
+      text: "summary through 4",
+      created_at: 7,
+    },
+  });
+
+  const restarted = new SessionRecorder({
+    session_id,
+    store: new JsonlSessionMessageStore({ session_id, file_path }),
+    publish: () => {},
+  });
+  await restarted.initialize();
+  const context_store = new SessionRecorderHistoryStore({ session_id, recorder: restarted });
+  const context = await context_store.list_records();
+  assert.deepEqual(
+    context.map((message) => message.parts[0]?.text),
+    ["summary through 4", "message 5", "message 6"],
+  );
+  const segment = await restarted.list_messages({ before_sequence: 5 });
+  assert.deepEqual(segment.items.map((message) => message.sequence), [1, 2, 3, 4]);
+});
+
+test("Compact 两步提交中断后会清理 Active 与 Segment 的重叠前缀", async () => {
+  const session_id = "compact-overlap-recovery-test";
+  const { recorder, file_path } = await create_recorder(session_id);
+  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",
+      }],
+    });
+  }
+  await recorder.compact_active({
+    through_sequence: 4,
+    summary: {
+      record_type: "summary",
+      session_id,
+      summary_id: "summary-through-4",
+      through_sequence: 4,
+      text: "summary through 4",
+      created_at: 7,
+    },
+  });
+
+  const segment_path = path.join(
+    path.dirname(file_path),
+    "segments",
+    "000000000001-000000000004.jsonl",
+  );
+  const segment_rows = await read_jsonl(segment_path);
+  const active_rows = await read_jsonl(file_path);
+  await fs.writeFile(
+    file_path,
+    `${[...segment_rows.slice(0, -1), ...active_rows]
+      .map((message) => JSON.stringify(message))
+      .join("\n")}\n`,
+    "utf8",
+  );
+
+  const restarted = new SessionRecorder({
+    session_id,
+    store: new JsonlSessionMessageStore({ session_id, file_path }),
+    publish: () => {},
+  });
+  await restarted.initialize();
+  const active = await restarted.list_messages();
+  assert.deepEqual(active.items.map((message) => message.sequence), [5, 6]);
+  assert.deepEqual(
+    (await read_jsonl(file_path)).map((message) => message.sequence),
+    [5, 6],
+  );
+});
+
+test("连续 Compact 生成按 sequence 连续的 Segment 与累计 Summary", async () => {
+  const session_id = "cumulative-compact-test";
+  const { recorder } = await create_recorder(session_id);
+  const prompts = [];
+  let generation_count = 0;
+  const model = new MockLanguageModelV3({
+    modelId: "cumulative-compact-model",
+    doGenerate: async (options) => {
+      prompts.push(JSON.stringify(options.prompt));
+      generation_count += 1;
+      return {
+        content: [{ type: "text", text: `Summary ${String(generation_count)}` }],
+        finishReason: { unified: "stop", raw: "stop" },
+        usage: {
+          inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
+          outputTokens: { total: 0, text: 0, reasoning: 0 },
+        },
+        warnings: [],
+      };
+    },
+  });
+  const history_store = new SessionRecorderHistoryStore({ session_id, recorder });
+  const append_messages = async (start, end) => {
+    for (let index = start; index <= end; 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",
+        }],
+      });
+    }
+  };
+  const compact = async () => await history_store.compact({
+    model,
+    system: [],
+    keepLastMessages: 2,
+    maxInputTokensApprox: 1,
+    compactRatio: 0.5,
+  });
+
+  await append_messages(1, 8);
+  assert.equal((await compact()).compacted, true);
+  await append_messages(9, 12);
+  assert.equal((await compact()).compacted, true);
+
+  assert.equal(prompts.length, 2);
+  assert.equal(prompts[1].includes("<previous-summary>"), true);
+  assert.equal(prompts[1].includes("Summary 1"), true);
+  const active = await recorder.list_messages();
+  assert.deepEqual(active.items.map((message) => message.sequence), [9, 10, 11, 12]);
+  const latest_segment = await recorder.list_messages({ before_sequence: 9 });
+  assert.deepEqual(latest_segment.items.map((message) => message.sequence), [5, 6, 7, 8]);
+  assert.equal(latest_segment.has_more, true);
+  const earliest_segment = await recorder.list_messages({
+    before_sequence: latest_segment.start_sequence,
+  });
+  assert.deepEqual(earliest_segment.items.map((message) => message.sequence), [1, 2, 3, 4]);
+  const context = await history_store.list_records();
+  assert.equal(context[0].parts[0]?.text, "Summary 2");
+});
+
+test("Summary 生成失败时保留完整 Active 且不创建 Segment", async () => {
+  const session_id = "compact-summary-failure-test";
+  const { recorder, file_path } = await create_recorder(session_id);
+  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",
+      }],
+    });
+  }
+  const model = new MockLanguageModelV3({
+    modelId: "failed-compact-model",
+    doGenerate: async () => {
+      throw new Error("summary unavailable");
+    },
+  });
+  const history_store = new SessionRecorderHistoryStore({ session_id, recorder });
+  const result = await history_store.compact({
+    model,
+    system: [],
+    keepLastMessages: 2,
+    maxInputTokensApprox: 1,
+    compactRatio: 0.5,
+  });
+
+  assert.deepEqual(result, { compacted: false, reason: "summary_failed" });
+  assert.deepEqual(
+    (await recorder.list_messages()).items.map((message) => message.sequence),
+    [1, 2, 3, 4, 5, 6],
+  );
+  const segment_entries = await fs.readdir(path.join(path.dirname(file_path), "segments"));
+  assert.deepEqual(segment_entries, []);
+});
+
+test("内部上下文读取完整快照并保留第 500 条之后的最新消息", async () => {
+  const session_id = "complete-context-snapshot-test";
+  const messages = Array.from(
+    { length: 501 },
+    (_, index) => create_seeded_user_message(session_id, index + 1),
+  );
+  const { recorder } = await create_seeded_recorder(session_id, messages);
+  await recorder.compact_active({
+    through_sequence: 499,
+    summary: {
+      record_type: "summary",
+      session_id,
+      summary_id: "summary-through-499",
+      through_sequence: 499,
+      text: "summary through 499",
+      created_at: 502,
+    },
+  });
+
+  const active = await recorder.list_messages();
+  assert.deepEqual(active.items.map((message) => message.sequence), [500, 501]);
+  assert.equal(active.source, "active");
+  assert.equal(active.next_before_sequence, 500);
+  const previous = await recorder.list_messages({ before_sequence: 500 });
+  assert.equal(previous.source, "segment");
+  assert.equal(previous.items.length, 499);
+  assert.equal(previous.start_sequence, 1);
+  assert.equal(previous.end_sequence, 499);
+
+  const history_store = new SessionRecorderHistoryStore({ session_id, recorder });
+  const context = await history_store.list_records();
+  assert.deepEqual(
+    context.map((message) => message.parts[0]?.text),
+    ["summary through 499", "message 500", "message 501"],
+  );
+});
+
+test("Session fork 可以选择并复制第 500 条之后的消息", async () => {
+  const session_id = "complete-fork-snapshot-test";
+  const messages = Array.from(
+    { length: 501 },
+    (_, index) => create_seeded_user_message(session_id, index + 1),
+  );
+  const { recorder } = await create_seeded_recorder(session_id, messages);
+  let imported_messages = [];
+  const state_service = {
+    emit_action_event: async () => {},
+    get_config: () => ({}),
+  };
+  const view_service = new SessionViewService({
+    agent_id: "fork-agent",
+    project_root: os.tmpdir(),
+    session_id,
+    history_store: new SessionRecorderHistoryStore({ session_id, recorder }),
+    recorder,
+    state_service,
+    logger: { log: async () => {} },
+    is_executing: () => false,
+    get_instruction_system_blocks: () => [],
+    get_managed_plugin_system_blocks: async () => [],
+    get_plugin_system_blocks: async () => [],
+    create_fork_session: async () => ({
+      session: { id: "forked-session", set: async () => {} },
+      history_store: {},
+      recorder: {
+        import_messages: async (input) => {
+          imported_messages = input;
+        },
+      },
+      state_service: { set: async () => {} },
+    }),
+  });
+
+  await view_service.fork("user-501");
+
+  assert.equal(imported_messages.length, 501);
+  assert.equal(imported_messages[500].message_id, "user-501");
 });

package/src/agent/local/Agent.ts

@@ -25,6 +25,8 @@ import {
 } from "@/agent/local/services/AgentAssemblyService.js";
 import { AgentSessions as LocalAgentSessions } from "@/agent/local/services/AgentSessions.js";
 import { AgentBackgroundService } from "@/agent/local/services/AgentBackgroundService.js";
+import { generateId } from "@/utils/Id.js";
+import { PluginRegistry } from "@/plugin/core/PluginRegistry.js";
 
 /**
  * SDK 本地 Agent。
@@ -46,6 +48,7 @@ export class Agent {
   private readonly SessionClass: AgentOptions["Session"];
   private readonly backgroundService: AgentBackgroundService;
   private readonly shell?: AgentOptions["shell"];
+  private readonly local_sessions: LocalAgentSessions;
 
   private instruction: string[];
 
@@ -91,7 +94,19 @@ export class Agent {
     });
     const sessions = this.create_sessions(assembly);
     this.sessions = sessions;
+    this.local_sessions = sessions;
     sessions_ref = sessions;
+    if (this.plugins instanceof PluginRegistry) {
+      const plugin_registry = this.plugins;
+      plugin_registry.set_change_listener(({ type, plugin_name }) => {
+        const verb = type === "register" ? "registered" : "unregistered";
+        this.local_sessions.broadcast_plugins({
+          mutation_id: generateId(),
+          title: `Agent plugin ${plugin_name} ${verb}`,
+          plugins: plugin_registry.execution_view(),
+        });
+      });
+    }
   }
 
   /**
@@ -120,7 +135,9 @@ export class Agent {
    * 更新当前 SDK Agent 的静态基础指令。
    */
   setInstruction(input: string | string[]): void {
-    this.instruction = normalizeInstructionInput(input);
+    const next_instruction = normalizeInstructionInput(input);
+    this.instruction.splice(0, this.instruction.length, ...next_instruction);
+    this.local_sessions.broadcast_instruction(this.instruction, generateId());
   }
 
   /**
@@ -145,7 +162,8 @@ export class Agent {
     for (const key of Object.keys(this.env)) {
       delete this.env[key];
     }
-    this.patchEnv(next);
+    this.apply_env_patch(next);
+    this.local_sessions.broadcast_env(this.env, generateId());
   }
 
   /**
@@ -153,9 +171,19 @@ export class Agent {
    *
    * 关键点（中文）
    * - `null` / `undefined` 表示删除该 key；其他值会强制转字符串后写入。
-   * - 修改原地生效，所有持有 `context.env` 引用的模块立即可见。
+   * - configured env 原地更新；已有 Session 在下一模型 turn 提交 effective env。
    */
   patchEnv(patch: Record<string, string | null | undefined>): void {
+    this.apply_env_patch(patch);
+    this.local_sessions.broadcast_env(this.env, generateId());
+  }
+
+  /**
+   * 原地应用一次 env patch，不触发重复广播。
+   */
+  private apply_env_patch(
+    patch: Record<string, string | null | undefined>,
+  ): void {
     if (!patch || typeof patch !== "object") return;
     for (const [raw_key, raw_value] of Object.entries(patch)) {
       const key = String(raw_key || "").trim();
@@ -207,6 +235,9 @@ export class Agent {
       get_agent_context: () => this.agentContext ?? assembly.agent_context,
       get_shell: () => this.shell,
       get_instruction: () => this.instruction,
+      get_agent_env: () => this.getEnv(),
+      get_agent_plugins: () =>
+        (this.plugins as PluginRegistry).execution_view(),
       ensure_agent_ready: async () => {
         await this.backgroundService.ready();
       },

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

@@ -41,6 +41,7 @@ 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";
+import type { AgentPluginExecutionRuntime } from "@/types/plugin/PluginRuntime.js";
 
 function decodeMaybe(input: string): string {
   try {
@@ -87,6 +88,12 @@ type AgentSessionsOptions = {
    */
   get_instruction: () => string[];
 
+  /** 延迟读取当前 Agent configured env。 */
+  get_agent_env: () => Record<string, string>;
+
+  /** 创建当前 configured Plugin registry 的模型 turn 执行视图。 */
+  get_agent_plugins: () => AgentPluginExecutionRuntime;
+
   /**
    * 等待当前 Agent 后台能力启动完成。
    */
@@ -120,6 +127,8 @@ export class AgentSessions implements AgentSessionsApi<AgentSession> {
   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 get_agent_env: AgentSessionsOptions["get_agent_env"];
+  private readonly get_agent_plugins: AgentSessionsOptions["get_agent_plugins"];
   private readonly ensure_agent_ready: AgentSessionsOptions["ensure_agent_ready"];
   private readonly default_model?: AgentModel;
   private readonly default_model_id?: string;
@@ -136,6 +145,8 @@ export class AgentSessions implements AgentSessionsApi<AgentSession> {
     this.get_agent_context = options.get_agent_context;
     this.get_shell = options.get_shell;
     this.get_instruction = options.get_instruction;
+    this.get_agent_env = options.get_agent_env;
+    this.get_agent_plugins = options.get_agent_plugins;
     this.ensure_agent_ready = options.ensure_agent_ready;
     this.default_model = options.default_model;
     this.default_model_id = options.default_model_id;
@@ -150,6 +161,54 @@ export class AgentSessions implements AgentSessionsApi<AgentSession> {
     return [...this.sessions_by_id.values()];
   }
 
+  /**
+   * 把 Agent instruction 修改广播到已有 Session 的统一输入队列。
+   */
+  broadcast_instruction(instruction: string[], mutation_id: string): void {
+    const instruction_blocks = createInstructionSystemBlocks(
+      instruction,
+      this.project_root,
+    );
+    for (const session of this.sessions_by_id.values()) {
+      session.enqueue_agent_config({
+        type: "instruction",
+        mutation_id,
+        instruction_blocks,
+      });
+    }
+  }
+
+  /**
+   * 把 Agent env 修改广播到已有 Session 的统一输入队列。
+   */
+  broadcast_env(env: Record<string, string>, mutation_id: string): void {
+    for (const session of this.sessions_by_id.values()) {
+      session.enqueue_agent_config({
+        type: "env",
+        mutation_id,
+        env: { ...env },
+      });
+    }
+  }
+
+  /**
+   * 把 Plugin registry 修改广播到已有 Session 的统一输入队列。
+   */
+  broadcast_plugins(input: {
+    mutation_id: string;
+    title: string;
+    plugins: AgentPluginExecutionRuntime;
+  }): void {
+    for (const session of this.sessions_by_id.values()) {
+      session.enqueue_agent_config({
+        type: "plugins",
+        mutation_id: input.mutation_id,
+        title: input.title,
+        plugins: input.plugins,
+      });
+    }
+  }
+
   /**
    * 获取或创建一个 session runtime port。
    */
@@ -348,6 +407,8 @@ export class AgentSessions implements AgentSessionsApi<AgentSession> {
       tools: this.tools,
       logger: this.logger,
       getInstructionSystemBlocks: () => this.load_instruction_system_blocks(),
+      getAgentEnv: () => this.get_agent_env(),
+      get_agent_plugins: () => this.get_agent_plugins(),
       getManagedPluginSystemBlocks: async () => [],
       getPluginSystemBlocks: async () => await this.load_plugin_system_blocks(),
       ensureConfigured: async (session) => {

package/src/agent/remote/transports/HttpRemoteAgentTransport.ts

@@ -219,15 +219,10 @@ export class HttpRemoteAgentTransport implements RemoteAgentTransport {
     input?: ListSessionMessagesInput,
   ): Promise<SessionMessagePage> {
     const query = new URLSearchParams();
-    if (input?.limit !== undefined) query.set("limit", String(input.limit));
-    if (input?.cursor) query.set("cursor", input.cursor);
     if (input?.before_sequence !== undefined) {
       query.set("before_sequence", String(input.before_sequence));
     }
     if (input?.include_internal) query.set("include_internal", "true");
-    if (input?.through_sequence !== undefined) {
-      query.set("through_sequence", String(input.through_sequence));
-    }
     const payload = await read_http_json<{
       success?: boolean;
       error?: string;