@downcity/agent 1.1.237 → 1.1.258

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

@@ -1,96 +0,0 @@
-/**
- * @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);
-});

package/scripts/session-history-inflight.test.mjs

@@ -1,146 +0,0 @@
-/**
- * @file 验证 session records 会把运行中的 assistant 收敛到 inflight 快照，并在完成后写回正式历史。
- *
- * 关键点（中文）
- * - 直接覆盖 JSONL history store 的落盘语义，确保运行中不中断丢失过程。
- * - `messages.jsonl` 仍保持一轮一条 assistant 的正式历史语义。
- * - 运行中快照放在 `assistant_message.json`，浏览层读取时也应可见。
- */
-
-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 { JsonlSessionHistoryStore } from "../bin/index.js";
-
-function create_assistant_message(parts) {
-  return {
-    id: "a:test:final",
-    role: "assistant",
-    metadata: {
-      v: 1,
-      ts: Date.now(),
-      sessionId: "session_test",
-      source: "egress",
-      kind: "normal",
-    },
-    parts,
-  };
-}
-
-test("JsonlSessionHistoryStore exposes inflight assistant during execution and finalizes it into history", async () => {
-  const root_path = await fs.mkdtemp(
-    path.join(os.tmpdir(), "downcity-agent-history-inflight-"),
-  );
-
-  const store = new JsonlSessionHistoryStore({
-    rootPath: root_path,
-    agentId: "official",
-    sessionId: "session_test",
-  });
-
-  await store.write_record(
-    store.userText({
-      text: "write to document",
-      metadata: {
-        sessionId: "session_test",
-      },
-    }),
-  );
-
-  await store.write_inflight(
-    create_assistant_message([
-      { type: "step-start" },
-      { type: "text", text: "Let me inspect the document.", state: "done" },
-      {
-        type: "tool-exec_command",
-        toolCallId: "call_1",
-        input: { cmd: "cat demo.mdx" },
-        state: "output-available",
-        output: { success: true, output: "# demo" },
-      },
-    ]),
-  );
-
-  const during_run = await store.list_records();
-  assert.equal(during_run.length, 2);
-  assert.equal(during_run[1]?.role, "assistant");
-  assert.deepEqual(
-    during_run[1]?.parts.map((part) => part.type),
-    ["step-start", "text", "tool-exec_command"],
-  );
-
-  await store.finalize_inflight(
-    create_assistant_message([
-      { type: "text", text: "Done writing.", state: "done" },
-    ]),
-  );
-
-  const after_finish = await store.list_records();
-  assert.equal(after_finish.length, 2);
-  assert.deepEqual(
-    after_finish[1]?.parts.map((part) => part.type),
-    ["step-start", "text", "tool-exec_command", "text"],
-  );
-
-  const inflight_path = path.join(
-    root_path,
-    ".downcity",
-    "agents",
-    "official",
-    "sessions",
-    "session_test",
-    "messages",
-    "assistant_message.json",
-  );
-  const inflight_exists = await fs
-    .access(inflight_path)
-    .then(() => true)
-    .catch(() => false);
-  assert.equal(inflight_exists, false);
-});
-
-test("Appending a new user message flushes stale inflight assistant before the new turn", async () => {
-  const root_path = await fs.mkdtemp(
-    path.join(os.tmpdir(), "downcity-agent-history-flush-"),
-  );
-
-  const store = new JsonlSessionHistoryStore({
-    rootPath: root_path,
-    agentId: "official",
-    sessionId: "session_flush_test",
-  });
-
-  await store.write_record(
-    store.userText({
-      text: "first",
-      metadata: {
-        sessionId: "session_flush_test",
-      },
-    }),
-  );
-
-  await store.write_inflight(
-    create_assistant_message([
-      { type: "step-start" },
-      { type: "text", text: "partial assistant", state: "done" },
-    ]),
-  );
-
-  await store.write_record(
-    store.userText({
-      text: "second",
-      metadata: {
-        sessionId: "session_flush_test",
-      },
-    }),
-  );
-
-  const messages = await store.list_records();
-  assert.equal(messages.length, 3);
-  assert.equal(messages[0]?.role, "user");
-  assert.equal(messages[1]?.role, "assistant");
-  assert.equal(messages[2]?.role, "user");
-});

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

@@ -1,57 +0,0 @@
-/**
- * @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-prompt-runtime.test.mjs

@@ -1,390 +0,0 @@
-/**
- * @file 验证 SessionPromptRuntime 的 actor 队列语义。
- *
- * 关键点（中文）
- * - 测试编译后的 bin 输出，避免把测试文件混入 package 源码导出面。
- * - 重点锁住 prompt merge 与排队到下一 turn 的行为，防止后续重构破坏交互模型。
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import { SessionPromptRuntime } from "../bin/session/runtime/SessionPromptRuntime.js";
-
-function createDeferred() {
-  let resolve;
-  const promise = new Promise((innerResolve) => {
-    resolve = innerResolve;
-  });
-  return {
-    promise,
-    resolve,
-  };
-}
-
-function createUserMessage(query, index) {
-  return {
-    id: `u:test:${String(index)}`,
-    role: "user",
-    metadata: {
-      v: 1,
-      ts: Date.now(),
-      sessionId: "test",
-      source: "sdk",
-      kind: "normal",
-    },
-    parts: [{ type: "text", text: query }],
-  };
-}
-
-function createAssistantMessage(text, index) {
-  return {
-    id: `a:test:${String(index)}`,
-    role: "assistant",
-    metadata: {
-      v: 1,
-      ts: Date.now(),
-      sessionId: "test",
-      source: "sdk",
-      kind: "normal",
-    },
-    parts: [{ type: "text", text }],
-  };
-}
-
-async function waitUntil(readValue) {
-  for (let index = 0; index < 20; index += 1) {
-    const value = readValue();
-    if (value) return value;
-    await new Promise((resolve) => setTimeout(resolve, 0));
-  }
-  throw new Error("Timed out while waiting for test condition");
-}
-
-async function isSettled(promise) {
-  const marker = {};
-  const result = await Promise.race([
-    promise.then(
-      () => true,
-      () => true,
-    ),
-    new Promise((resolve) => setTimeout(() => resolve(marker), 0)),
-  ]);
-  return result !== marker;
-}
-
-test("SessionPromptRuntime merges queued prompts at the next step boundary", async () => {
-  const events = [];
-  const persisted = [];
-  const merge_lifecycle = [];
-  const executionFinished = createDeferred();
-  let stepMerge = null;
-
-  const runtime = new SessionPromptRuntime({
-    sessionId: "test",
-    publish: (event) => {
-      events.push(event);
-    },
-    createAndPersistUserMessage: async (input) => {
-      const message = createUserMessage(input.query, persisted.length + 1);
-      persisted.push(message);
-      merge_lifecycle.push(`message:${input.query}`);
-      return message;
-    },
-    appendErrorMessage: async () => {},
-    executeTurn: async (input) => {
-      stepMerge = input.onStepMerge;
-      await executionFinished.promise;
-      return {
-        text: "done",
-        success: true,
-        assistantMessage: createAssistantMessage("done", 1),
-      };
-    },
-    stopTurn: () => false,
-  });
-
-  const firstTurn = await runtime.prompt({ query: "first" });
-  const secondTurnPromise = runtime.prompt({ query: "second" });
-  const merge = await waitUntil(() => stepMerge);
-
-  assert.equal(await isSettled(secondTurnPromise), false);
-
-  const mergedMessages = await merge();
-  const secondTurn = await secondTurnPromise;
-
-  assert.equal(secondTurn.id, firstTurn.id);
-  assert.deepEqual(
-    mergedMessages.map((message) => message.parts[0]?.text),
-    ["second"],
-  );
-  assert.deepEqual(
-    persisted.map((message) => message.parts[0]?.text),
-    ["first", "second"],
-  );
-  assert.deepEqual(merge_lifecycle, [
-    "message:first",
-    "message:second",
-  ]);
-
-  executionFinished.resolve();
-  const result = await firstTurn.finished;
-
-  assert.equal(result.success, true);
-  assert.equal(result.text, "done");
-  assert.equal(secondTurn.result, result);
-  assert.deepEqual(
-    events.map((event) => event.type),
-    ["start", "finish"],
-  );
-});
-
-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 = [];
-
-  const runtime = new SessionPromptRuntime({
-    sessionId: "test",
-    publish: (event) => {
-      events.push(event);
-    },
-    createAndPersistUserMessage: async (input) => {
-      return createUserMessage(input.query, events.length + 1);
-    },
-    appendErrorMessage: async () => {},
-    executeTurn: async (input) => {
-      const deferred = createDeferred();
-      finishQueue.push({
-        query: input.promptInput.query,
-        deferred,
-      });
-      await deferred.promise;
-      return {
-        text: `done:${input.promptInput.query}`,
-        success: true,
-        assistantMessage: createAssistantMessage(
-          `done:${input.promptInput.query}`,
-          finishQueue.length,
-        ),
-      };
-    },
-    stopTurn: () => false,
-  });
-
-  const firstTurn = await runtime.prompt({ query: "first" });
-  const secondTurnPromise = runtime.prompt({ query: "second" });
-  const firstExecution = await waitUntil(() => finishQueue[0]);
-
-  assert.equal(await isSettled(secondTurnPromise), false);
-
-  firstExecution.deferred.resolve();
-  const firstResult = await firstTurn.finished;
-  const secondTurn = await secondTurnPromise;
-  const secondExecution = await waitUntil(() => finishQueue[1]);
-
-  assert.notEqual(secondTurn.id, firstTurn.id);
-  assert.equal(firstResult.text, "done:first");
-  assert.equal(secondExecution.query, "second");
-
-  secondExecution.deferred.resolve();
-  const secondResult = await secondTurn.finished;
-
-  assert.equal(secondResult.text, "done:second");
-  assert.deepEqual(
-    events.map((event) => event.type),
-    ["start", "finish", "start", "finish"],
-  );
-});
-
-test("SessionPromptRuntime stops current turn and cancels unmerged queued prompts", async () => {
-  const events = [];
-  const executionFinished = createDeferred();
-  let stopRequested = false;
-
-  const runtime = new SessionPromptRuntime({
-    sessionId: "test",
-    publish: (event) => {
-      events.push(event);
-    },
-    createAndPersistUserMessage: async (input) => {
-      return createUserMessage(input.query, events.length + 1);
-    },
-    appendErrorMessage: async () => {},
-    executeTurn: async (input) => {
-      await new Promise((resolve) => {
-        input.abortSignal.addEventListener("abort", resolve, { once: true });
-      });
-      await executionFinished.promise;
-      return {
-        text: "partial answer",
-        success: false,
-        assistantMessage: createAssistantMessage("partial answer", 1),
-        error: "Turn stopped",
-      };
-    },
-    stopTurn: () => {
-      stopRequested = true;
-      executionFinished.resolve();
-      return true;
-    },
-  });
-
-  const firstTurn = await runtime.prompt({ query: "first" });
-  const secondTurnPromise = runtime.prompt({ query: "second" });
-  await waitUntil(() => runtime.isActive());
-
-  const stopResult = runtime.stop();
-  const secondTurn = await secondTurnPromise;
-  const firstResult = await firstTurn.finished;
-  const secondResult = await secondTurn.finished;
-
-  assert.equal(stopRequested, true);
-  assert.equal(stopResult.stopped, true);
-  assert.equal(stopResult.turnId, firstTurn.id);
-  assert.equal(stopResult.cancelledQueuedPrompts, 1);
-  assert.equal(firstResult.success, false);
-  assert.equal(firstResult.error, "Turn stopped");
-  assert.equal(firstResult.text, "partial answer");
-  assert.equal(firstResult.assistantMessage.parts[0]?.text, "partial answer");
-  assert.equal(secondResult.success, false);
-  assert.equal(
-    secondResult.error,
-    "Prompt cancelled because session was stopped",
-  );
-  assert.deepEqual(
-    events.map((event) => event.type),
-    ["start", "start", "finish", "finish"],
-  );
-});
-
-test("SessionPromptRuntime does not synthesize assistant text when stopped before output", async () => {
-  const executionFinished = createDeferred();
-
-  const runtime = new SessionPromptRuntime({
-    sessionId: "test",
-    publish: () => {},
-    createAndPersistUserMessage: async (input) => {
-      return createUserMessage(input.query, 1);
-    },
-    appendErrorMessage: async () => {},
-    executeTurn: async (input) => {
-      await new Promise((resolve) => {
-        input.abortSignal.addEventListener("abort", resolve, { once: true });
-      });
-      await executionFinished.promise;
-      return {
-        text: "",
-        success: false,
-        error: "Turn stopped",
-      };
-    },
-    stopTurn: () => {
-      executionFinished.resolve();
-      return true;
-    },
-  });
-
-  const turn = await runtime.prompt({ query: "first" });
-  await waitUntil(() => runtime.isActive());
-
-  runtime.stop();
-  const result = await turn.finished;
-
-  assert.equal(result.success, false);
-  assert.equal(result.error, "Turn stopped");
-  assert.equal(result.text, "");
-  assert.equal(result.assistantMessage, undefined);
-});