@downcity/agent 1.1.232 → 1.1.236

package/scripts/multi-agent-plugin-isolation.test.mjs

@@ -0,0 +1,289 @@
+/**
+ * @file 验证多个 Agent 经 session.prompt 执行 plugin_call 时保持 registry 隔离。
+ *
+ * 关键点（中文）
+ * - 先创建 Agent A，再创建 Agent B，锁住历史全局 runtime 的覆盖顺序。
+ * - 两个 Session 并发进入模型 tool loop，验证异步作用域不会造成 registry 串线。
+ * - 第二次模型请求必须收到各自 plugin action 返回的 owner。
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import http from "node:http";
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs/promises";
+
+import { Agent } from "../bin/index.js";
+import {
+  createAction,
+  createPlugin,
+} from "../bin/plugin/core/PluginActionFactory.js";
+import { CITY_MODEL_INVOKER, CITY_MODEL_KIND } from "@downcity/type";
+
+/**
+ * 写入一组 OpenAI-compatible SSE chunk。
+ */
+function write_openai_sse(response, chunks) {
+  response.writeHead(200, {
+    "content-type": "text/event-stream; charset=utf-8",
+    "cache-control": "no-cache",
+    connection: "keep-alive",
+  });
+  for (const chunk of chunks) {
+    const payload = typeof chunk === "string" ? chunk : JSON.stringify(chunk);
+    response.write(`data: ${payload}\n\n`);
+  }
+  response.end();
+}
+
+/**
+ * 读取 HTTP JSON 请求体。
+ */
+async function read_json_body(request) {
+  const raw = await new Promise((resolve, reject) => {
+    let data = "";
+    request.on("data", (chunk) => {
+      data += chunk;
+    });
+    request.on("end", () => resolve(data));
+    request.on("error", reject);
+  });
+  return JSON.parse(String(raw || "{}"));
+}
+
+/**
+ * 返回普通文本模型流。
+ */
+function write_text_response(response, input) {
+  write_openai_sse(response, [
+    {
+      id: input.id,
+      object: "chat.completion.chunk",
+      created: 1,
+      model: input.model,
+      choices: [
+        {
+          index: 0,
+          delta: { role: "assistant", content: input.text },
+          finish_reason: null,
+        },
+      ],
+    },
+    {
+      id: input.id,
+      object: "chat.completion.chunk",
+      created: 1,
+      model: input.model,
+      choices: [
+        {
+          index: 0,
+          delta: {},
+          finish_reason: "stop",
+        },
+      ],
+    },
+    "[DONE]",
+  ]);
+}
+
+/**
+ * 返回一次 plugin_call tool call。
+ */
+function write_plugin_call_response(response, model) {
+  write_openai_sse(response, [
+    {
+      id: `chatcmpl_${model}_tool`,
+      object: "chat.completion.chunk",
+      created: 1,
+      model,
+      choices: [
+        {
+          index: 0,
+          delta: { role: "assistant" },
+          finish_reason: null,
+        },
+      ],
+    },
+    {
+      id: `chatcmpl_${model}_tool`,
+      object: "chat.completion.chunk",
+      created: 1,
+      model,
+      choices: [
+        {
+          index: 0,
+          delta: {
+            tool_calls: [
+              {
+                index: 0,
+                id: `call_${model}`,
+                type: "function",
+                function: {
+                  name: "plugin_call",
+                  arguments: JSON.stringify({
+                    plugin: "skill",
+                    action: "lookup",
+                    payload: {},
+                  }),
+                },
+              },
+            ],
+          },
+          finish_reason: null,
+        },
+      ],
+    },
+    {
+      id: `chatcmpl_${model}_tool`,
+      object: "chat.completion.chunk",
+      created: 1,
+      model,
+      choices: [
+        {
+          index: 0,
+          delta: {},
+          finish_reason: "tool_calls",
+        },
+      ],
+    },
+    "[DONE]",
+  ]);
+}
+
+/**
+ * 创建绑定测试 HTTP 服务的 CityModel。
+ */
+function create_test_model(base_url, model_id) {
+  return Object.freeze({
+    id: model_id,
+    name: model_id,
+    description: "Multi-agent plugin isolation model",
+    modalities: ["text", "stream"],
+    tags: [],
+    meta: {},
+    kind: CITY_MODEL_KIND,
+    [CITY_MODEL_INVOKER]: {
+      connection: () => ({
+        base_url,
+        api_key: "test_key",
+        model_id,
+      }),
+    },
+  });
+}
+
+/**
+ * 创建返回固定 owner 的 skill plugin。
+ */
+function create_owner_plugin(owner, executed_owners) {
+  return createPlugin({
+    name: "skill",
+    title: `Skill ${owner}`,
+    description: "Return the owning Agent id",
+    actions: {
+      lookup: createAction({
+        description: "Return registry owner",
+        execute: async () => {
+          executed_owners.push(owner);
+          return {
+            success: true,
+            data: { owner },
+            message: owner,
+          };
+        },
+      }),
+    },
+  });
+}
+
+test("multiple session prompts use only their owning Agent plugin registry", async () => {
+  const model_requests = new Map();
+  const executed_owners = [];
+  const server = http.createServer(async (request, response) => {
+    const url = new URL(String(request.url || "/"), "http://127.0.0.1");
+    if (
+      request.method !== "POST" ||
+      url.pathname !== "/v1/ai/chat/completions"
+    ) {
+      response.writeHead(404);
+      response.end("not found");
+      return;
+    }
+
+    const body = await read_json_body(request);
+    const model = String(body.model || "");
+    if (!Array.isArray(body.tools)) {
+      write_text_response(response, {
+        id: `chatcmpl_${model}_title`,
+        model,
+        text: `Title ${model}`,
+      });
+      return;
+    }
+
+    const requests = model_requests.get(model) || [];
+    requests.push(body);
+    model_requests.set(model, requests);
+    if (requests.length === 1) {
+      write_plugin_call_response(response, model);
+      return;
+    }
+    write_text_response(response, {
+      id: `chatcmpl_${model}_done`,
+      model,
+      text: "done",
+    });
+  });
+
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const address = server.address();
+  assert.ok(address && typeof address === "object");
+  const base_url = `http://127.0.0.1:${String(address.port)}/v1/ai`;
+  const root_a = await fs.mkdtemp(
+    path.join(os.tmpdir(), "downcity-plugin-isolation-a-"),
+  );
+  const root_b = await fs.mkdtemp(
+    path.join(os.tmpdir(), "downcity-plugin-isolation-b-"),
+  );
+  const agent_a = new Agent({
+    id: "agent_a",
+    path: root_a,
+    plugins: [create_owner_plugin("agent_a", executed_owners)],
+    model: create_test_model(base_url, "model_a"),
+  });
+  const agent_b = new Agent({
+    id: "agent_b",
+    path: root_b,
+    plugins: [create_owner_plugin("agent_b", executed_owners)],
+    model: create_test_model(base_url, "model_b"),
+  });
+
+  try {
+    const session_a = await agent_a.sessions.create({ sessionId: "session_a" });
+    const session_b = await agent_b.sessions.create({ sessionId: "session_b" });
+    const [turn_a, turn_b] = await Promise.all([
+      session_a.prompt({ query: "Call your skill plugin" }),
+      session_b.prompt({ query: "Call your skill plugin" }),
+    ]);
+    const [result_a, result_b] = await Promise.all([
+      turn_a.finished,
+      turn_b.finished,
+    ]);
+
+    assert.equal(result_a.success, true);
+    assert.equal(result_b.success, true);
+    assert.deepEqual([...executed_owners].sort(), ["agent_a", "agent_b"]);
+    for (const [model, owner] of [
+      ["model_a", "agent_a"],
+      ["model_b", "agent_b"],
+    ]) {
+      const requests = model_requests.get(model) || [];
+      assert.equal(requests.length, 2);
+      assert.match(JSON.stringify(requests[1].messages), new RegExp(owner));
+    }
+  } finally {
+    await Promise.all([agent_a.dispose(), agent_b.dispose()]);
+    await new Promise((resolve) => server.close(() => resolve()));
+  }
+});

package/scripts/plugin-tool-bridge.test.mjs

@@ -313,3 +313,55 @@ test("PluginRegistry keeps plugin ready after action business failure", async ()
   assert.equal(retry.data.loaded, true);
   assert.equal(registry.status("skill").status, "ready");
 });
+
+test("PluginRegistry delays lifecycle stop until the active execution lease is released", async () => {
+  let lifecycle_active = false;
+  let stop_count = 0;
+  const plugin = createPlugin({
+    name: "leased-plugin",
+    title: "Leased Plugin",
+    description: "Keeps runtime resources alive for an active Session step",
+    lifecycle: {
+      start: async () => {
+        lifecycle_active = true;
+      },
+      stop: async () => {
+        lifecycle_active = false;
+        stop_count += 1;
+      },
+    },
+    actions: {
+      status: createAction({
+        description: "Read lifecycle state",
+        execute: async () => ({
+          success: lifecycle_active,
+          data: { lifecycle_active },
+        }),
+      }),
+    },
+  });
+  const registry = createAgentPluginRegistry({
+    plugins: [plugin],
+    plugin_instances: new Map(),
+    get_context: () => ({ rootPath: process.cwd() }),
+  });
+  await registry.startAll();
+  const lease = registry.execution_view().acquire();
+
+  assert.equal(await registry.unregister("leased-plugin"), true);
+  assert.equal(registry.has("leased-plugin"), false);
+  assert.equal(lifecycle_active, true);
+  assert.equal(stop_count, 0);
+
+  const result = await lease.runAction({
+    plugin: "leased-plugin",
+    action: "status",
+  });
+  assert.equal(result.success, true);
+  assert.equal(result.data.lifecycle_active, true);
+
+  await lease.release();
+  await lease.release();
+  assert.equal(lifecycle_active, false);
+  assert.equal(stop_count, 1);
+});

package/scripts/remote-session-reconnect.test.mjs

@@ -102,3 +102,21 @@ test("RemoteSession switches models by stable id without local model instances",
     /does not accept a local model instance/,
   );
 });
+
+test("RemoteSession queues compact through its transport", async () => {
+  const compacted_session_ids = [];
+  const transport = {
+    async compact(session_id) {
+      compacted_session_ids.push(session_id);
+    },
+  };
+  const session = new RemoteSession(transport, {
+    agentId: "agent_test",
+    sessionId: "session_test",
+    messageCount: 0,
+  });
+
+  await session.compact();
+
+  assert.deepEqual(compacted_session_ids, ["session_test"]);
+});

package/scripts/session-compaction-context-window.test.mjs

@@ -1,10 +1,10 @@
 /**
- * @file 验证 CityModel 上下文窗口会驱动默认 session compact 预算。
+ * @file 验证 CityModel 上下文窗口元数据与 compact 的明确触发语义。
  *
  * 关键点（中文）
  * - CityModel 目录元数据需要在归一化前读取。
- * - 默认 compact 使用模型总窗口的 80%，并随重试次数收紧。
- * - 显式 maxInputTokensApprox 始终优先于模型目录配置。
+ * - compact 不再根据字符/token 预估自动触发。
+ * - 只有明确 force 或超限恢复才会调用 history store。
  */
 
 import assert from "node:assert/strict";
@@ -53,6 +53,7 @@ async function capture_compact_input(options = {}) {
     model: {},
     system: [],
     retryCount: options.retry_count ?? 0,
+    force: true,
     ...(options.context_window !== undefined
       ? { context_window: options.context_window }
       : {}),
@@ -68,28 +69,28 @@ test("CityModel exposes its configured context window to Agent", () => {
   );
 })
 
-test("default compact budget uses 80 percent of the model context window", async () => {
-  const first_attempt = await capture_compact_input({
-    context_window: 256000,
-  });
-  assert.equal(first_attempt.maxInputTokensApprox, 204800);
-
-  const retry = await capture_compact_input({
-    context_window: 256000,
-    retry_count: 1,
-  });
-  assert.equal(retry.maxInputTokensApprox, 102400);
-})
+test("compact input carries only an explicit force request", async () => {
+  const compact_input = await capture_compact_input({ context_window: 256000 });
+  assert.equal(compact_input.force, true);
+  assert.equal("maxInputTokensApprox" in compact_input, false);
+  assert.equal("compactRatio" in compact_input, false);
+  assert.equal("keepLastMessages" in compact_input, false);
+});
 
-test("explicit compact budget overrides the model context window", async () => {
-  const compact_input = await capture_compact_input({
-    context_window: 256000,
-    composer_options: { maxInputTokensApprox: 64000 },
+test("normal composer run does not call history store without force", async () => {
+  let called = false;
+  const composer = new JsonlSessionCompactionComposer();
+  const result = await composer.run({
+    historyStore: {
+      compact: async () => {
+        called = true;
+        return { compacted: true };
+      },
+    },
+    model: {},
+    system: [],
+    retryCount: 0,
   });
-  assert.equal(compact_input.maxInputTokensApprox, 64000);
-})
-
-test("compact keeps the existing 128k fallback without model metadata", async () => {
-  const compact_input = await capture_compact_input();
-  assert.equal(compact_input.maxInputTokensApprox, 128000);
-})
+  assert.deepEqual(result, { compacted: false, reason: "not_requested" });
+  assert.equal(called, false);
+});

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

@@ -1,10 +1,10 @@
 /**
- * @file 验证 Agent 配置在运行中修改后统一于下一模型 turn 生效。
+ * @file 验证 Agent 配置与 steer 在 Session step 检查点统一生效。
  *
  * 关键点（中文）
- * - 第一轮 provider 请求保持阻塞，用来制造真实的运行中配置修改窗口。
+ * - 第一次 provider 请求保持阻塞，用来制造真实的运行中配置修改窗口。
  * - instruction、env 与 plugin registry 修改不能改变已经开始的请求。
- * - 下一模型 turn 统一提交配置，并通过 Session action message 表达生效。
+ * - config 与 steer 在同一个 Session step 检查点提交，并继续使用同一个 turn id。
  */
 
 import test from "node:test";
@@ -58,33 +58,39 @@ function create_stream_text_result(text) {
   };
 }
 
-test("running Agent config changes become effective together at the next model turn", async () => {
+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_model_turn_started = create_deferred();
-  const release_first_model_turn = create_deferred();
+  const first_provider_request_started = create_deferred();
+  const release_first_provider_request = create_deferred();
   const provider_prompts = [];
-  let provider_turn_count = 0;
+  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_turn_count += 1;
+      provider_request_count += 1;
       provider_prompts.push(JSON.stringify(options.prompt));
-      if (provider_turn_count === 1) {
-        first_model_turn_started.resolve();
-        await release_first_model_turn.promise;
+      if (provider_request_count === 1) {
+        first_provider_request_started.resolve();
+        await release_first_provider_request.promise;
       }
-      return create_stream_text_result(`done:${String(provider_turn_count)}`);
+      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({
@@ -107,22 +113,25 @@ test("running Agent config changes become effective together at the next model t
       sessionId: "config_turn_boundary_session",
     });
     const first_turn = await session.prompt({ query: "first" });
-    await first_model_turn_started.promise;
+    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_model_turn.resolve();
+    release_first_provider_request.resolve();
+    const steer_turn = await steer_turn_promise;
     assert.equal((await first_turn.finished).success, true);
-
-    const second_turn = await session.prompt({ query: "second" });
-    assert.equal((await second_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/);
@@ -138,14 +147,14 @@ test("running Agent config changes become effective together at the next model t
       "Agent plugin runtime-config unregistered",
     ]);
   } finally {
-    release_first_model_turn.resolve();
+    release_first_provider_request.resolve();
     await agent.dispose();
   }
 });
 
-test("running session model changes keep the current provider and switch the next model turn", async () => {
+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-model-turn-boundary-"),
+    path.join(os.tmpdir(), "downcity-session-step-boundary-"),
   );
   const old_model_started = create_deferred();
   const release_old_model = create_deferred();
@@ -183,7 +192,7 @@ test("running session model changes keep the current provider and switch the nex
     },
   });
   const agent = new Agent({
-    id: "session_model_turn_boundary_agent",
+    id: "session_step_boundary_agent",
     path: agent_path,
     model: old_model,
     plugins: [runtime_plugin],
@@ -191,20 +200,20 @@ test("running session model changes keep the current provider and switch the nex
 
   try {
     const session = await agent.sessions.create({
-      sessionId: "session_model_turn_boundary_session",
+      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.deepEqual(model_calls, ["old-model"]);
-
-    const second_turn = await session.prompt({ query: "second" });
-    assert.equal((await second_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();
@@ -222,3 +231,48 @@ test("running session model changes keep the current provider and switch the nex
     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();
+  }
+});