@downcity/agent 1.1.228 → 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-action-message.test.mjs

@@ -17,6 +17,48 @@ import { JsonlSessionHistoryStore } from "../bin/executor/store/history/jsonl/Js
 import { JsonlSessionHistoryComposer } from "../bin/executor/composer/history/jsonl/JsonlSessionHistoryComposer.js";
 import { toSessionTimelineEvents } from "../bin/session/browse/Browse.js";
 import { Agent } from "../bin/index.js";
+import { MockLanguageModelV3 } from "ai/test";
+
+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();
+      },
+    }),
+  };
+}
+
+function create_model(model_id, calls) {
+  return new MockLanguageModelV3({
+    modelId: model_id,
+    doStream: async () => {
+      calls.push(model_id);
+      return create_stream_text_result("done");
+    },
+  });
+}
 
 test("action record is upserted but filtered from LLM history", async () => {
   const root_path = await fs.mkdtemp(
@@ -107,6 +149,7 @@ test("session.set only persists and publishes model-switching actions when model
     id: "model_switching_agent",
     path: agent_path,
   });
+  const model_calls = [];
   try {
     const session = await agent.sessions.create({
       sessionId: "model_switching_session",
@@ -120,37 +163,40 @@ test("session.set only persists and publishes model-switching actions when model
 
     await session.set({
       modelId: "test-model",
-      model: {
-        modelId: "test-model-label-v1",
-        provider: "test",
-      },
+      model: create_model("test-model-label-v1", model_calls),
     });
 
     assert.deepEqual(events, []);
 
     await session.set({
       modelId: "test-model",
-      model: {
-        modelId: "test-model-label-v2",
-        provider: "test",
-      },
+      model: create_model("test-model-label-v2", model_calls),
     });
 
     assert.deepEqual(events, []);
 
     await session.set({
       modelId: "next-test-model",
-      model: {
-        modelId: "next-test-model-label",
-        provider: "test",
-      },
+      model: create_model("next-test-model-label", model_calls),
     });
+
+    assert.deepEqual(events, []);
+    assert.deepEqual(model_calls, []);
+
+    const turn = await session.prompt({ query: "apply queued config" });
+    const result = await turn.finished;
     unsubscribe();
 
+    assert.equal(result.success, true);
+    assert.deepEqual(model_calls, [
+      "next-test-model-label",
+      "next-test-model-label",
+    ]);
+
     assert.deepEqual(
       events.map((event) => `${event.title}:${event.status}`),
       [
-        "Switching session model from test-model-label-v2 to next-test-model-label:running",
+        "Session model switched from test-model-label-v2 to next-test-model-label:running",
         "Session model switched from test-model-label-v2 to next-test-model-label:completed",
       ],
     );

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

@@ -0,0 +1,96 @@
+/**
+ * @file 验证 CityModel 上下文窗口元数据与 compact 的明确触发语义。
+ *
+ * 关键点（中文）
+ * - CityModel 目录元数据需要在归一化前读取。
+ * - compact 不再根据字符/token 预估自动触发。
+ * - 只有明确 force 或超限恢复才会调用 history store。
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  JsonlSessionCompactionComposer,
+  read_agent_model_context_window,
+} from "../bin/index.js";
+import {
+  CITY_MODEL_INVOKER,
+  CITY_MODEL_KIND,
+} from "@downcity/type";
+
+/** 创建仅用于读取公开目录元数据的 CityModel。 */
+function create_city_model(context_window) {
+  return {
+    id: "context-model",
+    name: "Context Model",
+    description: "Context window test model",
+    context_window,
+    modalities: ["text"],
+    tags: [],
+    meta: {},
+    kind: CITY_MODEL_KIND,
+    [CITY_MODEL_INVOKER]: {
+      connection: () => ({
+        base_url: "https://example.com/v1/ai",
+        model_id: "context-model",
+      }),
+    },
+  };
+}
+
+/** 执行一次策略并返回传给 history store 的 compact 参数。 */
+async function capture_compact_input(options = {}) {
+  let compact_input;
+  const composer = new JsonlSessionCompactionComposer(options.composer_options);
+  await composer.run({
+    historyStore: {
+      compact: async (input) => {
+        compact_input = input;
+        return { compacted: false, reason: "captured" };
+      },
+    },
+    model: {},
+    system: [],
+    retryCount: options.retry_count ?? 0,
+    force: true,
+    ...(options.context_window !== undefined
+      ? { context_window: options.context_window }
+      : {}),
+  });
+  assert.ok(compact_input);
+  return compact_input;
+}
+
+test("CityModel exposes its configured context window to Agent", () => {
+  assert.equal(
+    read_agent_model_context_window(create_city_model(256000)),
+    256000,
+  );
+})
+
+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("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.deepEqual(result, { compacted: false, reason: "not_requested" });
+  assert.equal(called, false);
+});