@downcity/agent 1.1.408 → 1.1.437

package/scripts/session-dynamic-interaction.test.mjs

@@ -1,75 +0,0 @@
-/**
- * @file 验证 Plugin 动态 Interaction 不依赖核心固定业务联合体。
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { JsonlSessionMessageStore } from "../bin/workspace/store/JsonlSessionMessageStore.js";
-import { LocalFileSystem } from "@downcity/workspace";
-import { SessionMessages } from "../bin/session/SessionMessages.js";
-import { SessionInteractions } from "../bin/session/control/SessionInteractions.js";
-
-test("动态 Plugin Interaction 使用通用 type/payload 完成恢复", async () => {
-  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-dynamic-interaction-"));
-  const recorder = new SessionMessages({
-    session_id: "dynamic-interaction-test",
-    store: new JsonlSessionMessageStore({
-      files: new LocalFileSystem(root_path),
-      session_id: "dynamic-interaction-test",
-      file_path: path.join(root_path, "active.jsonl"),
-    }),
-    publish: () => {},
-  });
-  await recorder.initialize();
-  const interactions = new SessionInteractions({
-    session_id: "dynamic-interaction-test",
-    messages: recorder,
-  });
-  const writer = await recorder.open_assistant_message({ turn_id: "turn-1" });
-
-  try {
-    const handle = await interactions.request({
-      interaction_id: "interaction:deploy-confirm",
-      turn_id: "turn-1",
-      type: "plugin:deployment/confirm",
-      source: {
-        type: "plugin",
-        plugin_name: "deployment",
-      },
-      title: "确认发布",
-      payload: {
-        environment: "production",
-        version: "2026.08.24",
-      },
-      response_schema: {
-        type: "object",
-        required: ["decision"],
-      },
-      created_at: Date.now(),
-    });
-
-    assert.deepEqual((await interactions.list())[0].request.payload, {
-      environment: "production",
-      version: "2026.08.24",
-    });
-
-    const result = await interactions.respond({
-      interaction_id: handle.interaction_id,
-      response: {
-        type: "plugin:deployment/confirm",
-        outcome: "resolved",
-        payload: { decision: "confirmed" },
-      },
-    });
-
-    assert.deepEqual(await handle.result, result);
-    assert.equal(result.status, "resolved");
-    assert.deepEqual(result.response.payload, { decision: "confirmed" });
-    assert.equal(recorder.get_message(writer.message_id).parts[0].status, "resolved");
-  } finally {
-    await fs.rm(root_path, { recursive: true, force: true });
-  }
-});

package/scripts/session-fork.test.mjs

@@ -1,35 +0,0 @@
-/** @file 验证 Session Fork 锚点包含语义。 */
-
-import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import test from "node:test";
-import { Agent } from "../bin/index.js";
-import { create_workspace_entry } from "../bin/internal/index.js";
-import { Workspace } from "@downcity/workspace";
-
-async function create_session(t) {
-  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-session-fork-"));
-  t.after(async () => await fs.rm(root_path, { recursive: true, force: true }));
-  const agent = new Agent({ id: "fork_test_agent" });
-  t.after(async () => await agent.dispose());
-  const workspace = new Workspace({ id: "fork_workspace", path: root_path, data_root_path: path.join(root_path, "data") });
-  return await create_workspace_entry(agent, workspace).sessions.create({ session_id: "source" });
-}
-
-test("Fork 默认包含锚点消息，显式排除时只复制锚点之前的历史", async (t) => {
-  const session = await create_session(t);
-  await session.append_user_message({ text: "第一条" });
-  await session.append_assistant_message({ text: "第一次回答" });
-  await session.append_user_message({ text: "需要编辑" });
-  const source_messages = (await session.messages()).items;
-  const target = source_messages.find((message) => message.type === "user" && message.parts.some((part) => part.type === "text" && part.text === "需要编辑"));
-  assert.ok(target);
-
-  const included = await session.fork({ message_id: target.message_id });
-  const excluded = await session.fork({ message_id: target.message_id, include_message: false });
-  assert.equal((await included.messages()).items.length, 3);
-  assert.equal((await excluded.messages()).items.length, 2);
-  assert.deepEqual((await excluded.messages()).items.map((message) => message.type), ["user", "assistant"]);
-});

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

@@ -1,202 +0,0 @@
-/**
- * @file 验证 session 列表从正确目录读取持久化 title。
- *
- * 关键点（中文）
- * - 普通列表只读取 Workspace `sessions` 下当前 Agent 的 meta。
- * - 归档列表只读取 Workspace `archived-sessions` 下当前 Agent 的 meta。
- * - title 允许为空；这里仅验证已由模型生成并落盘的 title 能被列表返回。
- */
-
-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 { MockModelClient } from "./ModelClientMock.mjs";
-import { Agent } from "../bin/index.js";
-import { create_workspace_entry } from "../bin/internal/index.js";
-import { Workspace } from "@downcity/workspace";
-
-function create_mock_title_model(title_text) {
-  return new MockModelClient({
-    modelId: "mock-session-list-title-model",
-    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();
-        },
-      }),
-    }),
-  });
-}
-
-async function create_agent_with_titled_session(input) {
-  const agent_path = await fs.mkdtemp(
-    path.join(os.tmpdir(), input.tmp_prefix),
-  );
-  const agent = new Agent({
-    id: input.agent_id,
-    model: create_mock_title_model(input.title),
-  });
-  const entry = create_workspace_entry(agent, new Workspace({ id: "test_workspace", path: agent_path, data_root_path: path.join(agent_path, "data") }));
-  const collection = entry.sessions;
-  const session = await collection.create({
-    session_id: input.session_id,
-  });
-  await session.set({ model: create_mock_title_model(input.title) });
-
-  await session.append_user_message({
-    text: input.first_user_text,
-  });
-  const title_deadline = Date.now() + 1000;
-  while (Date.now() < title_deadline) {
-    if ((await session.get_info()).title === input.title) break;
-    await new Promise((resolve) => setTimeout(resolve, 10));
-  }
-  assert.equal((await session.get_info()).title, input.title);
-
-  return {
-    agent,
-    entry,
-    collection,
-    session,
-  };
-}
-
-test("list_sessions returns persisted title from active session metadata", async () => {
-  const { agent, entry, collection, session } = await create_agent_with_titled_session({
-    tmp_prefix: "downcity-agent-session-list-title-",
-    agent_id: "list_title_agent",
-    session_id: "active_session",
-    title: "列表标题",
-    first_user_text: "Need the session list to show the generated title",
-  });
-
-  try {
-    const page = await collection.list();
-    assert.equal(page.total, 1);
-    assert.deepEqual(
-      page.items.map((item) => ({
-        session_id: item.session_id,
-        title: item.title,
-        message_count: item.message_count,
-      })),
-      [
-        {
-          session_id: session.id,
-          title: "列表标题",
-          message_count: 1,
-        },
-      ],
-    );
-  } finally {
-    await agent.dispose();
-  }
-});
-
-test("list_sessions reflects canonical SessionMessages changes", async () => {
-  const { agent, entry, 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(
-    entry.data_path,
-    "sessions",
-    encodeURIComponent(session.id),
-    "messages",
-  );
-  const messages_path = path.join(messages_dir, "active.jsonl");
-  const meta_path = path.join(path.dirname(messages_dir), "meta.json");
-
-  try {
-    await session.append_assistant_message({
-      text: "Recorder appended history",
-    });
-    await session.session_messages.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();
-    assert.equal(page.items[0].message_count, 2);
-    assert.equal(info.message_count, 2);
-    assert.equal(page.items[0].preview_text, "Recorder appended history");
-  } 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-",
-    agent_id: "archive_list_title_agent",
-    session_id: "archived_session",
-    title: "归档标题",
-    first_user_text: "Archive this titled session",
-  });
-
-  try {
-    await collection.archive({
-      id: session.id,
-    });
-
-    const active_page = await collection.list();
-    const archived_page = await collection.archived();
-
-    assert.equal(active_page.total, 0);
-    assert.equal(archived_page.total, 1);
-    assert.deepEqual(
-      archived_page.items.map((item) => ({
-        session_id: item.session_id,
-        title: item.title,
-        message_count: item.message_count,
-      })),
-      [
-        {
-          session_id: session.id,
-          title: "归档标题",
-          message_count: 1,
-        },
-      ],
-    );
-  } finally {
-    await agent.dispose();
-  }
-});