@downcity/agent 1.1.228 → 1.1.232

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,95 @@
+/**
+ * @file 验证 CityModel 上下文窗口会驱动默认 session compact 预算。
+ *
+ * 关键点（中文）
+ * - CityModel 目录元数据需要在归一化前读取。
+ * - 默认 compact 使用模型总窗口的 80%，并随重试次数收紧。
+ * - 显式 maxInputTokensApprox 始终优先于模型目录配置。
+ */
+
+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,
+    ...(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("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("explicit compact budget overrides the model context window", async () => {
+  const compact_input = await capture_compact_input({
+    context_window: 256000,
+    composer_options: { maxInputTokensApprox: 64000 },
+  });
+  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);
+})

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

@@ -0,0 +1,224 @@
+/**
+ * @file 验证 Agent 配置在运行中修改后统一于下一模型 turn 生效。
+ *
+ * 关键点（中文）
+ * - 第一轮 provider 请求保持阻塞，用来制造真实的运行中配置修改窗口。
+ * - instruction、env 与 plugin registry 修改不能改变已经开始的请求。
+ * - 下一模型 turn 统一提交配置，并通过 Session action message 表达生效。
+ */
+
+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 { MockLanguageModelV3 } from "ai/test";
+import { Agent } from "../bin/index.js";
+import {
+  createAction,
+  createPlugin,
+} from "../bin/plugin/core/PluginActionFactory.js";
+
+function create_deferred() {
+  let resolve;
+  const promise = new Promise((inner_resolve) => {
+    resolve = inner_resolve;
+  });
+  return { promise, resolve };
+}
+
+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();
+      },
+    }),
+  };
+}
+
+test("running Agent config changes become effective together at the next model turn", 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 provider_prompts = [];
+  let provider_turn_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_prompts.push(JSON.stringify(options.prompt));
+      if (provider_turn_count === 1) {
+        first_model_turn_started.resolve();
+        await release_first_model_turn.promise;
+      }
+      return create_stream_text_result(`done:${String(provider_turn_count)}`);
+    },
+  });
+  const runtime_plugin = createPlugin({
+    name: "runtime-config",
+    title: "Runtime Config",
+    description: "Provides a system block for turn-boundary tests",
+    system: (context) => `plugin-env:${context.env.TURN_ENV || "missing"}`,
+    actions: {
+      ping: createAction({
+        description: "Ping",
+        execute: async () => ({ success: true, data: { ok: true } }),
+      }),
+    },
+  });
+  const agent = new Agent({
+    id: "config_turn_boundary_agent",
+    path: agent_path,
+    model,
+    instruction: ["instruction:old"],
+    env: { TURN_ENV: "old" },
+    plugins: [runtime_plugin],
+  });
+
+  try {
+    const session = await agent.sessions.create({
+      sessionId: "config_turn_boundary_session",
+    });
+    const first_turn = await session.prompt({ query: "first" });
+    await first_model_turn_started.promise;
+
+    agent.setInstruction(["instruction:new"]);
+    agent.patchEnv({ TURN_ENV: "new" });
+    await agent.plugins.unregister("runtime-config");
+
+    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();
+    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(provider_prompts.length, 2);
+    assert.match(provider_prompts[1], /instruction:new/);
+    assert.doesNotMatch(provider_prompts[1], /instruction:old/);
+    assert.doesNotMatch(provider_prompts[1], /plugin-env:old/);
+
+    const messages = await session.messages();
+    const completed_actions = messages.items
+      .filter((message) => message.type === "action" && message.status === "completed")
+      .map((message) => message.title);
+    assert.deepEqual(completed_actions, [
+      "Agent instruction updated",
+      "Agent environment updated",
+      "Agent plugin runtime-config unregistered",
+    ]);
+  } finally {
+    release_first_model_turn.resolve();
+    await agent.dispose();
+  }
+});
+
+test("running session model changes keep the current provider and switch the next model turn", async () => {
+  const agent_path = await fs.mkdtemp(
+    path.join(os.tmpdir(), "downcity-session-model-turn-boundary-"),
+  );
+  const old_model_started = create_deferred();
+  const release_old_model = create_deferred();
+  const model_calls = [];
+
+  const old_model = new MockLanguageModelV3({
+    modelId: "old-model",
+    doStream: async (options) => {
+      const has_tools = Array.isArray(options.tools) && options.tools.length > 0;
+      if (!has_tools) return create_stream_text_result("Old title");
+      model_calls.push("old-model");
+      old_model_started.resolve();
+      await release_old_model.promise;
+      return create_stream_text_result("old response");
+    },
+  });
+  const new_model = new MockLanguageModelV3({
+    modelId: "new-model",
+    doStream: async (options) => {
+      const has_tools = Array.isArray(options.tools) && options.tools.length > 0;
+      if (!has_tools) return create_stream_text_result("New title");
+      model_calls.push("new-model");
+      return create_stream_text_result("new response");
+    },
+  });
+  const runtime_plugin = createPlugin({
+    name: "model-boundary",
+    title: "Model Boundary",
+    description: "Ensures the main provider request has tools",
+    actions: {
+      ping: createAction({
+        description: "Ping",
+        execute: async () => ({ success: true, data: { ok: true } }),
+      }),
+    },
+  });
+  const agent = new Agent({
+    id: "session_model_turn_boundary_agent",
+    path: agent_path,
+    model: old_model,
+    plugins: [runtime_plugin],
+  });
+
+  try {
+    const session = await agent.sessions.create({
+      sessionId: "session_model_turn_boundary_session",
+    });
+    const first_turn = await session.prompt({ query: "first" });
+    await old_model_started.promise;
+
+    await session.set({ model: new_model });
+    assert.deepEqual(model_calls, ["old-model"]);
+
+    release_old_model.resolve();
+    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.deepEqual(model_calls, ["old-model", "new-model"]);
+
+    const messages = await session.messages();
+    const model_actions = messages.items.filter(
+      (message) =>
+        message.type === "action" &&
+        message.title === "Session model switched from old-model to new-model",
+    );
+    assert.deepEqual(
+      model_actions.map((message) => message.status),
+      ["completed"],
+    );
+  } finally {
+    release_old_model.resolve();
+    await agent.dispose();
+  }
+});

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

@@ -118,7 +118,7 @@ test("list_sessions returns persisted title from active session metadata", async
         "sessions",
         encodeURIComponent(session.id),
         "messages",
-        "messages.jsonl",
+        "active.jsonl",
       ),
     );
     assert.equal(meta.historyBytes, history_stat.size);
@@ -158,23 +158,41 @@ test("list_sessions reflects canonical Recorder history changes", async () => {
     encodeURIComponent(session.id),
     "messages",
   );
-  const messages_path = path.join(messages_dir, "messages.jsonl");
+  const messages_path = path.join(messages_dir, "active.jsonl");
   const meta_path = path.join(messages_dir, "meta.json");
 
   try {
     await session.append_assistant_message({
       text: "Recorder appended history",
     });
+    await session.recorder.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();
     const repaired_meta = JSON.parse(await fs.readFile(meta_path, "utf8"));
     const history_stat = await fs.stat(messages_path);
+    const segment_stat = await fs.stat(path.join(
+      messages_dir,
+      "segments",
+      "000000000001-000000000001.jsonl",
+    ));
 
     assert.equal(page.items[0].messageCount, 2);
+    assert.equal(info.messageCount, 2);
     assert.equal(page.items[0].previewText, "Recorder appended history");
     assert.equal(repaired_meta.messageCount, 2);
     assert.equal(repaired_meta.previewText, "Recorder appended history");
-    assert.equal(repaired_meta.historyBytes, history_stat.size);
+    assert.equal(repaired_meta.historyBytes, history_stat.size + segment_stat.size);
   } finally {
     await agent.dispose();
   }

package/scripts/session-prompt-runtime.test.mjs

@@ -139,6 +139,91 @@ test("SessionPromptRuntime merges queued prompts at the next step boundary", asy
   );
 });
 
+test("SessionPromptRuntime applies config and steer in queue order before the next model turn", async () => {
+  const lifecycle = [];
+  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_config({
+    mutation_id: "config-1",
+    scope: "agent",
+    apply: async ({ model_turn_index }) => {
+      lifecycle.push(`config:1:${String(model_turn_index)}`);
+    },
+  });
+  const first_turn = await runtime.prompt({ query: "first" });
+  const merge = await waitUntil(() => step_merge);
+  runtime.enqueue_config({
+    mutation_id: "config-2",
+    scope: "session",
+    apply: async ({ model_turn_index }) => {
+      lifecycle.push(`config:2:${String(model_turn_index)}`);
+    },
+  });
+  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:1",
+    "prompt:first",
+    "config:2:2",
+    "steer:second",
+  ]);
+
+  execution_finished.resolve();
+  await first_turn.finished;
+});
+
+test("SessionPromptRuntime keeps config 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_config({
+    mutation_id: "config-only",
+    scope: "agent",
+    apply: async () => {
+      apply_count += 1;
+    },
+  });
+
+  assert.equal(runtime.isActive(), false);
+  assert.equal(apply_count, 0);
+});
+
 test("SessionPromptRuntime moves unmerged prompts into the next turn", async () => {
   const events = [];
   const finishQueue = [];