@downcity/agent 1.1.207 → 1.1.210

package/scripts/assistant-file-resource.test.mjs

@@ -101,6 +101,45 @@ test("materializeAssistantFileParts downloads remote file URLs into resources",
   }
 });
 
+test("materializeAssistantFileParts rejects oversized remote resources before download", async () => {
+  const project_root = await fs.mkdtemp(
+    path.join(os.tmpdir(), "downcity-agent-assistant-large-resource-"),
+  );
+  const server = http.createServer((_, response) => {
+    response.writeHead(200, {
+      "content-type": "application/octet-stream",
+      "content-length": String(26 * 1024 * 1024),
+    });
+    response.end("oversized");
+  });
+
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  try {
+    const address = server.address();
+    assert.equal(typeof address, "object");
+    assert.ok(address);
+    const remote_url = `http://127.0.0.1:${address.port}/large.bin`;
+    const parts = await materializeAssistantFileParts({
+      projectRoot: project_root,
+      parts: [
+        {
+          type: "file",
+          mediaType: "application/octet-stream",
+          url: remote_url,
+        },
+      ],
+    });
+
+    assert.equal(parts[0].url, remote_url);
+    const resources_path = path.join(project_root, ".downcity", "resources");
+    await assert.rejects(fs.access(resources_path));
+  } finally {
+    await new Promise((resolve, reject) =>
+      server.close((error) => (error ? reject(error) : resolve())),
+    );
+  }
+});
+
 test("materializeAssistantFileParts resolves relative local file URLs from agent project root", async () => {
   const project_root = await fs.mkdtemp(
     path.join(os.tmpdir(), "downcity-agent-assistant-relative-resource-"),

package/scripts/city-model-tool-loop.test.mjs

@@ -2,7 +2,8 @@
  * @file 验证 CityModel 会优先走 OpenAI-compatible LanguageModel 并完成 tool loop。
  *
  * 关键点（中文）
- * - 这里直接走编译后的 Agent / City 产物，避免测试只覆盖源码级辅助函数。
+ * - 这里直接走编译后的 Agent 产物，避免测试只覆盖源码级辅助函数。
+ * - CityModel 使用 @downcity/type 的共享协议构造，避免反向依赖 City SDK 实现。
  * - 重点锁住 CityModel -> LanguageModel -> tool-call -> 本地执行 -> tool-result 回传链路。
  * - 新路径不应再调用 `/v1/ai/stream`，避免 UIMessage stream 反向适配丢失 finish 语义。
  */
@@ -15,7 +16,7 @@ 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 } from "../../city/bin/index.js";
+import { CITY_MODEL_INVOKER, CITY_MODEL_KIND } from "@downcity/type";
 import { tool } from "ai";
 import { z } from "zod";
 
@@ -45,7 +46,6 @@ async function read_json_body(req) {
 }
 
 test("CityModel uses direct LanguageModel path and sends tool result back", async () => {
-  const requests = [];
   const agent_requests = [];
   let stream_requests = 0;
   let tool_executed = false;
@@ -53,24 +53,6 @@ test("CityModel uses direct LanguageModel path and sends tool result back", asyn
   const server = http.createServer(async (req, res) => {
     const url = new URL(String(req.url || "/"), "http://127.0.0.1");
 
-    if (req.method === "GET" && url.pathname === "/v1/ai/models") {
-      res.writeHead(200, { "content-type": "application/json" });
-      res.end(JSON.stringify({
-        items: [
-          {
-            id: "mock-model",
-            name: "Mock Model",
-            description: "mock",
-            modalities: ["text", "stream"],
-            tags: [],
-            meta: {},
-            env: {},
-          },
-        ],
-      }));
-      return;
-    }
-
     if (req.method === "POST" && url.pathname === "/v1/ai/stream") {
       stream_requests += 1;
       res.writeHead(500, { "content-type": "application/json" });
@@ -80,7 +62,6 @@ test("CityModel uses direct LanguageModel path and sends tool result back", asyn
 
     if (req.method === "POST" && url.pathname === "/v1/ai/chat/completions") {
       const body = await read_json_body(req);
-      requests.push(body);
 
       if (!Array.isArray(body.tools)) {
         write_openai_sse(res, [
@@ -229,15 +210,22 @@ test("CityModel uses direct LanguageModel path and sends tool result back", asyn
   try {
     const address = server.address();
     assert.ok(address && typeof address === "object");
-    const city = new City({
-      role: "user",
-      federation_url: `http://127.0.0.1:${String(address.port)}`,
-      city_id: "city_demo",
-      user_token: "ub_test",
+    const model = Object.freeze({
+      id: "mock-model",
+      name: "Mock Model",
+      description: "mock",
+      modalities: ["text", "stream"],
+      tags: [],
+      meta: {},
+      kind: CITY_MODEL_KIND,
+      [CITY_MODEL_INVOKER]: {
+        connection: () => ({
+          base_url: `http://127.0.0.1:${String(address.port)}/v1/ai`,
+          api_key: "ub_test",
+          model_id: "mock-model",
+        }),
+      },
     });
-    const catalog = await city.ai.listModels();
-    const model = catalog.get("mock-model");
-    assert.ok(model);
 
     const agent_path = await fs.mkdtemp(
       path.join(os.tmpdir(), "downcity-agent-city-model-tool-loop-"),

package/scripts/image-plugin-job.test.mjs

@@ -38,6 +38,7 @@ function create_context(rootPath = process.cwd()) {
 function create_registry(plugin, rootPath = process.cwd()) {
   return createAgentPluginRegistry({
     plugins: [plugin],
+    plugin_instances: new Map(),
     get_context: () => create_context(rootPath),
   });
 }
@@ -67,7 +68,7 @@ test("ImagePlugin image_create returns image job", async () => {
 
   const result = await plugin.actions.image_create.execute({
     context: create_context(),
-    payload: { prompt: "draw" },
+    input: { prompt: "draw" },
     pluginName: "image",
     actionName: "image_create",
   });
@@ -104,13 +105,12 @@ test("ImagePlugin models lists image-capable models", async () => {
 
   const result = await plugin.actions.models.execute({
     context: create_context(),
-    payload: {},
+    input: {},
     pluginName: "image",
     actionName: "models",
   });
 
   assert.equal(result.success, true);
-  assert.equal(result.data.default_model_id, "image_1");
   assert.deepEqual(result.data.items.map((item) => item.id), ["image_1"]);
   assert.equal(result.data.items[0].meta.provider, "test");
 });
@@ -153,7 +153,7 @@ test("ImagePlugin image_result reads pending state once", async () => {
 
   const result = await plugin.actions.image_result.execute({
     context: create_context(),
-    payload: { job_id: "img_1" },
+    input: { job_id: "img_1" },
     pluginName: "image",
     actionName: "image_result",
   });
@@ -179,7 +179,7 @@ test("ImagePlugin image_result returns final message when succeeded", async () =
 
   const result = await plugin.actions.image_result.execute({
     context: create_context(),
-    payload: { job_id: "img_1" },
+    input: { job_id: "img_1" },
     pluginName: "image",
     actionName: "image_result",
   });
@@ -202,7 +202,7 @@ test("ImagePlugin image_result reports failed terminal job", async () => {
 
   const result = await plugin.actions.image_result.execute({
     context: create_context(),
-    payload: { job_id: "img_1" },
+    input: { job_id: "img_1" },
     pluginName: "image",
     actionName: "image_result",
   });
@@ -244,7 +244,7 @@ test("ImagePlugin image_create converts local content image paths", async () =>
 
     const result = await plugin.actions.image_create.execute({
       context: create_context(tempDir),
-      payload: {
+      input: {
         content: [
           { type: "text", text: "change background" },
           { type: "image", url: "./input.png" },
@@ -277,7 +277,7 @@ test("ImagePlugin image_create uses content instead of prompt when both exist",
 
   const result = await plugin.actions.image_create.execute({
     context: create_context(),
-    payload: {
+    input: {
       prompt: "ignore this prompt",
       content: [{ type: "text", text: "use this content" }],
     },
@@ -302,7 +302,7 @@ test("ImagePlugin image_create keeps remote content image URLs", async () => {
 
   const result = await plugin.actions.image_create.execute({
     context: create_context(),
-    payload: {
+    input: {
       content: [
         { type: "text", text: "use this style" },
         { type: "image", url: "https://example.com/input.webp", media_type: "image/webp" },
@@ -325,7 +325,7 @@ test("ImagePlugin image_create rejects legacy messages and data URLs", async ()
 
   const messages_result = await plugin.actions.image_create.execute({
     context: create_context(),
-    payload: {
+    input: {
       messages: [
         {
           role: "user",
@@ -342,7 +342,7 @@ test("ImagePlugin image_create rejects legacy messages and data URLs", async ()
 
   const data_url_result = await plugin.actions.image_create.execute({
     context: create_context(),
-    payload: {
+    input: {
       content: [
         { type: "text", text: "edit this" },
         { type: "image", url: "data:image/png;base64,cG5n" },
@@ -386,7 +386,7 @@ test("ImagePlugin image_result polls until terminal when until_done=true", async
 
   const result = await plugin.actions.image_result.execute({
     context: create_context(),
-    payload: {
+    input: {
       job_id: "img_wait",
       until_done: true,
       max_wait_ms: 500,
@@ -414,7 +414,7 @@ test("ImagePlugin image_result returns last status when max_wait_ms elapses", as
 
   const result = await plugin.actions.image_result.execute({
     context: create_context(),
-    payload: {
+    input: {
       job_id: "img_timeout",
       until_done: true,
       max_wait_ms: 30,

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

@@ -132,7 +132,6 @@ test("invokePluginReadTool returns plugin action metadata", async () => {
               payload: { prompt: "draw" },
             },
           ],
-          allow_when_disabled: false,
           has_command: false,
           has_api: false,
         },
@@ -303,7 +302,7 @@ test("PluginRegistry keeps plugin ready after action business failure", async ()
     payload: { name: "missing" },
   });
   assert.equal(failed.success, false);
-  assert.equal(registry.status("skill").state, "ready");
+  assert.equal(registry.status("skill").status, "ready");
 
   const retry = await registry.runAction({
     plugin: "skill",
@@ -312,5 +311,5 @@ test("PluginRegistry keeps plugin ready after action business failure", async ()
   });
   assert.equal(retry.success, true);
   assert.equal(retry.data.loaded, true);
-  assert.equal(registry.status("skill").state, "ready");
+  assert.equal(registry.status("skill").status, "ready");
 });

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

@@ -0,0 +1,67 @@
+/**
+ * @file 验证 RemoteSession 在事件连接断开后能够重新建立订阅。
+ *
+ * 关键点（中文）
+ * - 断流必须结束当前 pending turn，避免 finished 永久等待。
+ * - 下一次 prompt 必须重新调用 transport.subscribe。
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { RemoteSession } from "../bin/agent/remote/RemoteSession.js";
+
+test("RemoteSession reconnects the event pump after transport close", async () => {
+  const subscriptions = [];
+  let prompt_count = 0;
+  const transport = {
+    async subscribe(input) {
+      subscriptions.push(input);
+      input.on_ready();
+      return { close: async () => {} };
+    },
+    async prompt() {
+      prompt_count += 1;
+      return { id: `turn_${prompt_count}` };
+    },
+    async get_info() {
+      throw new Error("unused");
+    },
+    async stop() {
+      return { stopped: false, cancelledQueuedPrompts: 0, reason: "idle" };
+    },
+    async records() {
+      throw new Error("unused");
+    },
+    async system() {
+      throw new Error("unused");
+    },
+    async fork() {
+      throw new Error("unused");
+    },
+  };
+  const session = new RemoteSession(transport, {
+    agentId: "agent_test",
+    sessionId: "session_test",
+    messageCount: 0,
+  });
+
+  const first_turn = await session.prompt({ query: "first" });
+  subscriptions[0].on_close(new Error("stream dropped"));
+  assert.deepEqual(await first_turn.finished, {
+    turnId: "turn_1",
+    text: "",
+    success: false,
+    error: "stream dropped",
+  });
+
+  const second_turn = await session.prompt({ query: "second" });
+  assert.equal(subscriptions.length, 2);
+  subscriptions[1].on_event({
+    type: "turn-finish",
+    turnId: second_turn.id,
+    text: "done",
+    success: true,
+  });
+  assert.equal((await second_turn.finished).text, "done");
+});

package/scripts/session-history-writer-error.test.mjs

@@ -0,0 +1,57 @@
+/**
+ * @file 验证 SessionHistoryWriter 不会掩盖事实源写入失败。
+ *
+ * 关键点（中文）
+ * - user 消息写入失败必须向调用方抛出。
+ * - assistant inflight 落盘失败也必须向调用方抛出。
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { SessionHistoryWriter } from "../bin/executor/composer/history/SessionHistoryWriter.js";
+
+function create_failing_history_store() {
+  return {
+    userText() {
+      throw new Error("unused");
+    },
+    assistantText() {
+      throw new Error("unused");
+    },
+    async write_record() {
+      throw new Error("disk full");
+    },
+    async finalize_inflight() {
+      throw new Error("disk full");
+    },
+  };
+}
+
+test("append_user_message propagates history write failures", async () => {
+  const writer = new SessionHistoryWriter({
+    sessionId: "writer_error_session",
+    getHistoryStore: create_failing_history_store,
+  });
+
+  await assert.rejects(
+    writer.append_user_message({
+      message: { v: 1, id: "user_1", role: "user", parts: [] },
+    }),
+    /disk full/,
+  );
+});
+
+test("append_assistant_message propagates history write failures", async () => {
+  const writer = new SessionHistoryWriter({
+    sessionId: "writer_error_session",
+    getHistoryStore: create_failing_history_store,
+  });
+
+  await assert.rejects(
+    writer.append_assistant_message({
+      message: { v: 1, id: "assistant_1", role: "assistant", parts: [] },
+    }),
+    /disk full/,
+  );
+});

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

@@ -19,28 +19,37 @@ import { Agent } from "../bin/index.js";
 function create_mock_title_model(title_text) {
   return new MockLanguageModelV3({
     modelId: "mock-session-list-title-model",
-    doGenerate: async () => ({
-      content: [
-        {
-          type: "text",
-          text: title_text,
-        },
-      ],
-      finishReason: "stop",
-      usage: {
-        inputTokens: {
-          total: 0,
-          noCache: 0,
-          cacheRead: 0,
-          cacheWrite: 0,
+    doStream: async () => ({
+      stream: new ReadableStream({
+        start(controller) {
+          controller.enqueue({ type: "stream-start", warnings: [] });
+          controller.enqueue({ type: "text-start", id: "title" });
+          controller.enqueue({
+            type: "text-delta",
+            id: "title",
+            delta: title_text,
+          });
+          controller.enqueue({ type: "text-end", id: "title" });
+          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();
         },
-        outputTokens: {
-          total: 0,
-          text: 0,
-          reasoning: 0,
-        },
-      },
-      warnings: [],
+      }),
     }),
   });
 }
@@ -81,8 +90,38 @@ test("list_sessions returns persisted title from active session metadata", async
 
   try {
     const page = await collection.list();
+    const meta = JSON.parse(
+      await fs.readFile(
+        path.join(
+          agent.path,
+          ".downcity",
+          "agents",
+          encodeURIComponent(agent.id),
+          "sessions",
+          encodeURIComponent(session.id),
+          "messages",
+          "meta.json",
+        ),
+        "utf8",
+      ),
+    );
 
     assert.equal(page.total, 1);
+    assert.equal(meta.messageCount, 1);
+    assert.equal(meta.previewText, "Need the session list to show the generated title");
+    const history_stat = await fs.stat(
+      path.join(
+        agent.path,
+        ".downcity",
+        "agents",
+        encodeURIComponent(agent.id),
+        "sessions",
+        encodeURIComponent(session.id),
+        "messages",
+        "messages.jsonl",
+      ),
+    );
+    assert.equal(meta.historyBytes, history_stat.size);
     assert.deepEqual(
       page.items.map((item) => ({
         sessionId: item.sessionId,
@@ -93,7 +132,7 @@ test("list_sessions returns persisted title from active session metadata", async
         {
           sessionId: session.id,
           title: "列表标题",
-          messageCount: 2,
+          messageCount: 1,
         },
       ],
     );
@@ -102,6 +141,58 @@ test("list_sessions returns persisted title from active session metadata", async
   }
 });
 
+test("list_sessions rebuilds stale metadata after external history changes", async () => {
+  const { agent, collection, session } = await create_agent_with_titled_session({
+    tmp_prefix: "downcity-agent-session-summary-repair-",
+    agent_id: "summary_repair_agent",
+    session_id: "summary_repair_session",
+    title: "摘要修复",
+    first_user_text: "Initial history",
+  });
+  const messages_dir = path.join(
+    agent.path,
+    ".downcity",
+    "agents",
+    encodeURIComponent(agent.id),
+    "sessions",
+    encodeURIComponent(session.id),
+    "messages",
+  );
+  const messages_path = path.join(messages_dir, "messages.jsonl");
+  const meta_path = path.join(messages_dir, "meta.json");
+
+  try {
+    await fs.appendFile(
+      messages_path,
+      `${JSON.stringify({
+        id: "external_assistant",
+        role: "assistant",
+        metadata: {
+          v: 1,
+          ts: Date.now(),
+          sessionId: session.id,
+          source: "egress",
+          kind: "normal",
+        },
+        parts: [{ type: "text", text: "Externally appended history" }],
+      })}\n`,
+      "utf8",
+    );
+
+    const page = await collection.list();
+    const repaired_meta = JSON.parse(await fs.readFile(meta_path, "utf8"));
+    const history_stat = await fs.stat(messages_path);
+
+    assert.equal(page.items[0].messageCount, 2);
+    assert.equal(page.items[0].previewText, "Externally appended history");
+    assert.equal(repaired_meta.messageCount, 2);
+    assert.equal(repaired_meta.previewText, "Externally appended history");
+    assert.equal(repaired_meta.historyBytes, history_stat.size);
+  } finally {
+    await agent.dispose();
+  }
+});
+
 test("archive_sessions returns title from archived session metadata", async () => {
   const { agent, collection, session } = await create_agent_with_titled_session({
     tmp_prefix: "downcity-agent-archive-list-title-",
@@ -131,7 +222,7 @@ test("archive_sessions returns title from archived session metadata", async () =
         {
           sessionId: session.id,
           title: "归档标题",
-          messageCount: 2,
+          messageCount: 1,
         },
       ],
     );

package/scripts/session-system-blocks.test.mjs

@@ -0,0 +1,73 @@
+/**
+ * @file 验证 SDK session system blocks 的稳定分层顺序。
+ *
+ * 关键点（中文）
+ * - 测试编译后的 bin 输出，避免测试文件依赖 TS 源码加载器。
+ * - 自定义 instruction 不能替代 Downcity core；core 必须包含 Shell 与 plugin 总规则。
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { createInstructionSystemBlocks } from "../bin/agent/local/AgentInstructions.js";
+import { buildSessionSystemBlocks } from "../bin/session/SessionSystemBuilder.js";
+
+test("instruction blocks keep Downcity core after custom instruction", () => {
+  const blocks = createInstructionSystemBlocks(
+    ["你是这个项目的工程 agent。"],
+    "/tmp/downcity-project",
+  );
+
+  assert.deepEqual(
+    blocks.map((block) => `${block.source}:${block.name}`),
+    ["instruction:agent", "core:default"],
+  );
+  assert.match(blocks[1].content, /# Downcity Agent/);
+  assert.match(blocks[1].content, /# Harness Design/);
+  assert.match(blocks[1].content, /human-owned workspace/);
+  assert.match(blocks[1].content, /project structure is the control surface/);
+  assert.match(blocks[1].content, /# Shell Commands/);
+  assert.match(blocks[1].content, /# Plugin System/);
+  assert.doesNotMatch(blocks[1].content, /\/tmp\/downcity-project/);
+  assert.doesNotMatch(blocks[1].content, /current year/i);
+  assert.doesNotMatch(blocks[1].content, /# Project Runtime/);
+  assert.doesNotMatch(blocks[1].content, /\.downcity\/agents/);
+  assert.doesNotMatch(blocks[1].content, /\.downcity\/memory/);
+  assert.doesNotMatch(blocks[1].content, /\.downcity\/public/);
+});
+
+test("session system blocks are ordered as instruction, core, plugin, session", async () => {
+  const blocks = await buildSessionSystemBlocks({
+    agentId: "agent-test",
+    projectRoot: "/tmp/downcity-project",
+    sessionId: "session-test",
+    createdAt: Date.UTC(2026, 6, 9, 8, 0, 0),
+    timezone: "Asia/Shanghai",
+    getInstructionSystemBlocks: () =>
+      createInstructionSystemBlocks(
+        ["使用中文回复。"],
+        "/tmp/downcity-project",
+      ),
+    getManagedPluginSystemBlocks: async () => [],
+    getPluginSystemBlocks: async () => [
+      {
+        source: "plugin",
+        name: "task",
+        content: "# Task Plugin\n\n任务插件说明。",
+      },
+    ],
+  });
+
+  assert.deepEqual(
+    blocks.map((block) => `${block.source}:${block.name}`),
+    [
+      "instruction:agent",
+      "core:default",
+      "plugin:task",
+      "session:context",
+    ],
+  );
+  assert.equal(blocks[0].content, "使用中文回复。");
+  assert.match(blocks[1].content, /plugin_call/);
+  assert.match(blocks[3].content, /session-test/);
+});