@downcity/agent 1.1.228 → 1.1.236

package/scripts/session-config-turn-boundary.test.mjs

@@ -0,0 +1,278 @@
+/**
+ * @file 验证 Agent 配置与 steer 在 Session step 检查点统一生效。
+ *
+ * 关键点（中文）
+ * - 第一次 provider 请求保持阻塞，用来制造真实的运行中配置修改窗口。
+ * - instruction、env 与 plugin registry 修改不能改变已经开始的请求。
+ * - config 与 steer 在同一个 Session step 检查点提交，并继续使用同一个 turn id。
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { MockLanguageModelV3 } from "ai/test";
+import { Agent } from "../bin/index.js";
+import {
+  createAction,
+  createPlugin,
+} from "../bin/plugin/core/PluginActionFactory.js";
+
+function create_deferred() {
+  let resolve;
+  const promise = new Promise((inner_resolve) => {
+    resolve = inner_resolve;
+  });
+  return { promise, resolve };
+}
+
+function create_stream_text_result(text) {
+  return {
+    stream: new ReadableStream({
+      start(controller) {
+        controller.enqueue({ type: "stream-start", warnings: [] });
+        controller.enqueue({ type: "text-start", id: "text_1" });
+        controller.enqueue({ type: "text-delta", id: "text_1", delta: text });
+        controller.enqueue({ type: "text-end", id: "text_1" });
+        controller.enqueue({
+          type: "finish",
+          finishReason: { unified: "stop", raw: "stop" },
+          usage: {
+            inputTokens: {
+              total: 0,
+              noCache: 0,
+              cacheRead: 0,
+              cacheWrite: 0,
+            },
+            outputTokens: {
+              total: 0,
+              text: 0,
+              reasoning: 0,
+            },
+          },
+        });
+        controller.close();
+      },
+    }),
+  };
+}
+
+test("running Agent config changes and steer apply at the same Session step checkpoint", async () => {
+  const agent_path = await fs.mkdtemp(
+    path.join(os.tmpdir(), "downcity-agent-config-turn-boundary-"),
+  );
+  const first_provider_request_started = create_deferred();
+  const release_first_provider_request = create_deferred();
+  const provider_prompts = [];
+  let provider_request_count = 0;
+  let plugin_stop_count = 0;
+
+  const model = new MockLanguageModelV3({
+    modelId: "config-turn-boundary-model",
+    doStream: async (options) => {
+      const has_tools = Array.isArray(options.tools) && options.tools.length > 0;
+      if (!has_tools) return create_stream_text_result("Session title");
+      provider_request_count += 1;
+      provider_prompts.push(JSON.stringify(options.prompt));
+      if (provider_request_count === 1) {
+        first_provider_request_started.resolve();
+        await release_first_provider_request.promise;
+      }
+      return create_stream_text_result(`done:${String(provider_request_count)}`);
+    },
+  });
+  const runtime_plugin = createPlugin({
+    name: "runtime-config",
+    title: "Runtime Config",
+    description: "Provides a system block for turn-boundary tests",
+    lifecycle: {
+      stop: async () => {
+        plugin_stop_count += 1;
+      },
+    },
+    system: (context) => `plugin-env:${context.env.TURN_ENV || "missing"}`,
+    actions: {
+      ping: createAction({
+        description: "Ping",
+        execute: async () => ({ success: true, data: { ok: true } }),
+      }),
+    },
+  });
+  const agent = new Agent({
+    id: "config_turn_boundary_agent",
+    path: agent_path,
+    model,
+    instruction: ["instruction:old"],
+    env: { TURN_ENV: "old" },
+    plugins: [runtime_plugin],
+  });
+
+  try {
+    const session = await agent.sessions.create({
+      sessionId: "config_turn_boundary_session",
+    });
+    const first_turn = await session.prompt({ query: "first" });
+    await first_provider_request_started.promise;
+
+    agent.setInstruction(["instruction:new"]);
+    agent.patchEnv({ TURN_ENV: "new" });
+    await agent.plugins.unregister("runtime-config");
+    const steer_turn_promise = session.prompt({ query: "steer" });
+
+    assert.equal(plugin_stop_count, 0);
+    assert.equal(provider_prompts.length, 1);
+    assert.match(provider_prompts[0], /instruction:old/);
+    assert.match(provider_prompts[0], /plugin-env:old/);
+    assert.doesNotMatch(provider_prompts[0], /instruction:new/);
+
+    release_first_provider_request.resolve();
+    const steer_turn = await steer_turn_promise;
+    assert.equal((await first_turn.finished).success, true);
+    assert.equal(steer_turn.id, first_turn.id);
+    assert.equal((await steer_turn.finished).success, true);
+    assert.equal(plugin_stop_count, 1);
+    assert.equal(provider_prompts.length, 2);
+    assert.match(provider_prompts[1], /instruction:new/);
+    assert.doesNotMatch(provider_prompts[1], /instruction:old/);
+    assert.doesNotMatch(provider_prompts[1], /plugin-env:old/);
+
+    const messages = await session.messages();
+    const completed_actions = messages.items
+      .filter((message) => message.type === "action" && message.status === "completed")
+      .map((message) => message.title);
+    assert.deepEqual(completed_actions, [
+      "Agent instruction updated",
+      "Agent environment updated",
+      "Agent plugin runtime-config unregistered",
+    ]);
+  } finally {
+    release_first_provider_request.resolve();
+    await agent.dispose();
+  }
+});
+
+test("running session model changes apply with steer at the next Session step", async () => {
+  const agent_path = await fs.mkdtemp(
+    path.join(os.tmpdir(), "downcity-session-step-boundary-"),
+  );
+  const old_model_started = create_deferred();
+  const release_old_model = create_deferred();
+  const model_calls = [];
+
+  const old_model = new MockLanguageModelV3({
+    modelId: "old-model",
+    doStream: async (options) => {
+      const has_tools = Array.isArray(options.tools) && options.tools.length > 0;
+      if (!has_tools) return create_stream_text_result("Old title");
+      model_calls.push("old-model");
+      old_model_started.resolve();
+      await release_old_model.promise;
+      return create_stream_text_result("old response");
+    },
+  });
+  const new_model = new MockLanguageModelV3({
+    modelId: "new-model",
+    doStream: async (options) => {
+      const has_tools = Array.isArray(options.tools) && options.tools.length > 0;
+      if (!has_tools) return create_stream_text_result("New title");
+      model_calls.push("new-model");
+      return create_stream_text_result("new response");
+    },
+  });
+  const runtime_plugin = createPlugin({
+    name: "model-boundary",
+    title: "Model Boundary",
+    description: "Ensures the main provider request has tools",
+    actions: {
+      ping: createAction({
+        description: "Ping",
+        execute: async () => ({ success: true, data: { ok: true } }),
+      }),
+    },
+  });
+  const agent = new Agent({
+    id: "session_step_boundary_agent",
+    path: agent_path,
+    model: old_model,
+    plugins: [runtime_plugin],
+  });
+
+  try {
+    const session = await agent.sessions.create({
+      sessionId: "session_step_boundary_session",
+    });
+    const first_turn = await session.prompt({ query: "first" });
+    await old_model_started.promise;
+
+    await session.set({ model: new_model });
+    const steer_turn_promise = session.prompt({ query: "continue" });
+    assert.deepEqual(model_calls, ["old-model"]);
+
+    release_old_model.resolve();
+    const steer_turn = await steer_turn_promise;
+    assert.equal((await first_turn.finished).success, true);
+    assert.equal(steer_turn.id, first_turn.id);
+    assert.equal((await steer_turn.finished).success, true);
+    assert.deepEqual(model_calls, ["old-model", "new-model"]);
+
+    const messages = await session.messages();
+    const model_actions = messages.items.filter(
+      (message) =>
+        message.type === "action" &&
+        message.title === "Session model switched from old-model to new-model",
+    );
+    assert.deepEqual(
+      model_actions.map((message) => message.status),
+      ["completed"],
+    );
+  } finally {
+    release_old_model.resolve();
+    await agent.dispose();
+  }
+});
+
+test("config remains effective when its action message cannot be persisted", async () => {
+  const agent_path = await fs.mkdtemp(
+    path.join(os.tmpdir(), "downcity-config-action-observability-"),
+  );
+  const model_calls = [];
+  const old_model = new MockLanguageModelV3({
+    modelId: "old-observability-model",
+    doStream: async () => {
+      model_calls.push("old");
+      return create_stream_text_result("old");
+    },
+  });
+  const new_model = new MockLanguageModelV3({
+    modelId: "new-observability-model",
+    doStream: async () => {
+      model_calls.push("new");
+      return create_stream_text_result("new");
+    },
+  });
+  const agent = new Agent({
+    id: "config_action_observability_agent",
+    path: agent_path,
+    model: old_model,
+  });
+
+  try {
+    const session = await agent.sessions.create({
+      sessionId: "config_action_observability_session",
+    });
+    session.stateService.emit_action_event = async () => {
+      throw new Error("action store unavailable");
+    };
+
+    await session.set({ model: new_model });
+    const turn = await session.prompt({ query: "use configured model" });
+    assert.equal((await turn.finished).success, true);
+    assert.deepEqual(model_calls, ["new", "new"]);
+
+    const messages = await session.messages();
+    assert.equal(messages.items.some((message) => message.type === "action"), false);
+  } finally {
+    await agent.dispose();
+  }
+});

package/scripts/session-list-title.test.mjs

@@ -118,7 +118,7 @@ test("list_sessions returns persisted title from active session metadata", async
         "sessions",
         encodeURIComponent(session.id),
         "messages",
-        "messages.jsonl",
+        "active.jsonl",
       ),
     );
     assert.equal(meta.historyBytes, history_stat.size);
@@ -158,23 +158,41 @@ test("list_sessions reflects canonical Recorder history changes", async () => {
     encodeURIComponent(session.id),
     "messages",
   );
-  const messages_path = path.join(messages_dir, "messages.jsonl");
+  const messages_path = path.join(messages_dir, "active.jsonl");
   const meta_path = path.join(messages_dir, "meta.json");
 
   try {
     await session.append_assistant_message({
       text: "Recorder appended history",
     });
+    await session.recorder.compact_active({
+      through_sequence: 1,
+      summary: {
+        record_type: "summary",
+        session_id: session.id,
+        summary_id: "summary-through-1",
+        through_sequence: 1,
+        text: "Initial history was compacted.",
+        created_at: Date.now(),
+      },
+    });
 
     const page = await collection.list();
+    const info = await session.get_info();
     const repaired_meta = JSON.parse(await fs.readFile(meta_path, "utf8"));
     const history_stat = await fs.stat(messages_path);
+    const segment_stat = await fs.stat(path.join(
+      messages_dir,
+      "segments",
+      "000000000001-000000000001.jsonl",
+    ));
 
     assert.equal(page.items[0].messageCount, 2);
+    assert.equal(info.messageCount, 2);
     assert.equal(page.items[0].previewText, "Recorder appended history");
     assert.equal(repaired_meta.messageCount, 2);
     assert.equal(repaired_meta.previewText, "Recorder appended history");
-    assert.equal(repaired_meta.historyBytes, history_stat.size);
+    assert.equal(repaired_meta.historyBytes, history_stat.size + segment_stat.size);
   } finally {
     await agent.dispose();
   }

package/scripts/session-prompt-runtime.test.mjs

@@ -139,6 +139,99 @@ test("SessionPromptRuntime merges queued prompts at the next step boundary", asy
   );
 });
 
+test("SessionPromptRuntime applies config and steer in queue order at the same step checkpoint", async () => {
+  const lifecycle = [];
+  const applied_turn_ids = [];
+  const execution_finished = createDeferred();
+  let step_merge = null;
+
+  const runtime = new SessionPromptRuntime({
+    sessionId: "test",
+    publish: () => {},
+    createAndPersistUserMessage: async (input, _turn_id, input_type) => {
+      lifecycle.push(`${input_type}:${input.query}`);
+      return createUserMessage(input.query, lifecycle.length);
+    },
+    appendErrorMessage: async () => {},
+    executeTurn: async (input) => {
+      step_merge = input.onStepMerge;
+      await execution_finished.promise;
+      return {
+        text: "done",
+        success: true,
+        assistantMessage: createAssistantMessage("done", 1),
+      };
+    },
+    stopTurn: () => false,
+  });
+
+  runtime.enqueue_command({
+    type: "command",
+    command_id: "config-1",
+    scope: "agent",
+    execute: async ({ turn_id }) => {
+      applied_turn_ids.push(turn_id);
+      lifecycle.push("config:1");
+    },
+  });
+  const first_turn = await runtime.prompt({ query: "first" });
+  const merge = await waitUntil(() => step_merge);
+  runtime.enqueue_command({
+    type: "command",
+    command_id: "config-2",
+    scope: "session",
+    execute: async ({ turn_id }) => {
+      applied_turn_ids.push(turn_id);
+      lifecycle.push("config:2");
+    },
+  });
+  const second_turn_promise = runtime.prompt({ query: "second" });
+
+  const messages = await merge();
+  const second_turn = await second_turn_promise;
+
+  assert.equal(second_turn.id, first_turn.id);
+  assert.deepEqual(
+    messages.map((message) => message.parts[0]?.text),
+    ["second"],
+  );
+  assert.deepEqual(lifecycle, [
+    "config:1",
+    "prompt:first",
+    "config:2",
+    "steer:second",
+  ]);
+  assert.deepEqual(applied_turn_ids, [first_turn.id, first_turn.id]);
+
+  execution_finished.resolve();
+  await first_turn.finished;
+});
+
+test("SessionPromptRuntime keeps command queued without starting a turn", async () => {
+  let apply_count = 0;
+  const runtime = new SessionPromptRuntime({
+    sessionId: "test",
+    publish: () => {},
+    createAndPersistUserMessage: async (input) => createUserMessage(input.query, 1),
+    appendErrorMessage: async () => {},
+    executeTurn: async () => ({ text: "done", success: true }),
+    stopTurn: () => false,
+  });
+
+  runtime.enqueue_command({
+    type: "command",
+    command_id: "config-only",
+    scope: "agent",
+    execute: async () => {
+      apply_count += 1;
+    },
+  });
+
+  assert.equal(runtime.isActive(), false);
+  assert.equal(runtime.has_pending_command(), true);
+  assert.equal(apply_count, 0);
+});
+
 test("SessionPromptRuntime moves unmerged prompts into the next turn", async () => {
   const events = [];
   const finishQueue = [];