@downcity/agent 1.1.408 → 1.1.437

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

@@ -1,282 +0,0 @@
-/**
- * @file 验证 Session 标题会进入 subscribe 事件与 history session 信息。
- *
- * 关键点（中文）
- * - 这里走编译后的公开 SDK，锁住调用方实际可见行为。
- * - title 默认允许为空；没有可用模型时不会再回退成首条 user message。
- * - 当后续补上模型且 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 { City } from "../bin/index.js";
-import { LocalStorageProvider, Workspace } from "@downcity/workspace";
-
-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_mock_title_model(title_text) {
-  return new MockModelClient({
-    modelId: "mock-session-title-model",
-    doStream: async () => create_stream_text_result(title_text),
-  });
-}
-
-function create_failing_title_model() {
-  return new MockModelClient({
-    modelId: "mock-session-title-failing-model",
-    doStream: async () => {
-      throw new Error("mock title generation failed");
-    },
-  });
-}
-
-function create_delayed_title_model(title_text) {
-  let resolve_started;
-  let resolve_release;
-  const started = new Promise((resolve) => {
-    resolve_started = resolve;
-  });
-  const released = new Promise((resolve) => {
-    resolve_release = resolve;
-  });
-  const model = new MockModelClient({
-    modelId: "mock-session-title-delayed-model",
-    doStream: async () => {
-      resolve_started();
-      await released;
-      return create_stream_text_result(title_text);
-    },
-  });
-  return {
-    model,
-    started,
-    release: () => resolve_release(),
-  };
-}
-
-async function read_log_lines(data_path) {
-  const logs_path = path.join(data_path, "logs");
-  const entries = await fs.readdir(logs_path).catch((error) => {
-    if (error?.code === "ENOENT") return [];
-    throw error;
-  });
-  const lines = [];
-  for (const entry of entries) {
-    if (!entry.endsWith(".jsonl")) continue;
-    const content = await fs.readFile(path.join(logs_path, entry), "utf8");
-    lines.push(...content.split("\n").filter(Boolean));
-  }
-  return lines;
-}
-
-async function wait_for_title(session, expected_title) {
-  const deadline = Date.now() + 1000;
-  while (Date.now() < deadline) {
-    if ((await session.get_info()).title === expected_title) return;
-    await new Promise((resolve) => setTimeout(resolve, 10));
-  }
-  assert.equal((await session.get_info()).title, expected_title);
-}
-
-test("Session keeps title empty when no model is available", async () => {
-  const agent_path = await fs.mkdtemp(
-    path.join(os.tmpdir(), "downcity-agent-session-title-"),
-  );
-  const agent = new Agent({ id: "title_agent" });
-  const entry = create_workspace_entry(agent, new Workspace({ id: "test_workspace", path: agent_path, data_root_path: path.join(agent_path, "data") }));
-  const session = await entry.sessions.create();
-  const events = [];
-  const unsubscribe = session.subscribe((event) => {
-    events.push(event);
-  });
-
-  try {
-    await session.append_user_message({
-      text: "Use shell tools to inspect the current workspace",
-    });
-
-    assert.equal(
-      events.some(
-        (event) => event.variant === "message" && event.type === "user",
-      ),
-      true,
-    );
-    assert.equal((await session.get_info()).title, undefined);
-  } finally {
-    unsubscribe();
-    await agent.dispose();
-  }
-});
-
-test("Session title generation does not block user message append", async () => {
-  const agent_path = await fs.mkdtemp(
-    path.join(os.tmpdir(), "downcity-agent-session-title-async-"),
-  );
-  const delayed = create_delayed_title_model("异步标题");
-  const agent = new Agent({
-    id: "title_async_agent",
-    model: delayed.model,
-  });
-  const entry = create_workspace_entry(agent, new Workspace({ id: "test_workspace", path: agent_path, data_root_path: path.join(agent_path, "data") }));
-  const session = await entry.sessions.create();
-
-  try {
-    await session.append_user_message({ text: "标题生成不应阻塞消息写入" });
-    await delayed.started;
-    assert.equal((await session.get_info()).title, undefined);
-    delayed.release();
-    await wait_for_title(session, "异步标题");
-  } finally {
-    await agent.dispose();
-  }
-});
-
-test("Session logs title generation failure without blocking the session", async () => {
-  const agent_path = await fs.mkdtemp(
-    path.join(os.tmpdir(), "downcity-agent-session-title-log-"),
-  );
-  const workspace = new Workspace({
-    id: "test_workspace",
-    path: agent_path,
-  });
-  const city = new City({
-    storage: new LocalStorageProvider(path.join(agent_path, "city-data")),
-    workspaces: [workspace],
-  });
-  const agent = new Agent({
-    id: "title_log_agent",
-    model: create_failing_title_model(),
-  });
-  city.agents.add(agent);
-  const entry = create_workspace_entry(agent, workspace);
-  const session = await entry.sessions.create();
-  await session.set({ model: create_failing_title_model() });
-
-  try {
-    await session.append_user_message({
-      text: "Diagnose why session title generation is flaky",
-    });
-
-    assert.equal((await session.get_info()).title, undefined);
-
-    let log_lines = [];
-    const log_deadline = Date.now() + 1000;
-    while (Date.now() < log_deadline) {
-      await entry.get_logger().save_all_logs();
-      log_lines = await read_log_lines(entry.data_path);
-      if (log_lines.some((line) => line.includes("session_title.generate_failed"))) {
-        break;
-      }
-      await new Promise((resolve) => setTimeout(resolve, 10));
-    }
-    const title_failure_log = log_lines
-      .map((line) => JSON.parse(line))
-      .find((entry) => entry.message.includes("session_title.generate_failed"));
-
-    assert.ok(title_failure_log);
-    assert.equal(title_failure_log.type, "warn");
-    assert.equal(title_failure_log.agent_id, "title_log_agent");
-    assert.equal(title_failure_log.workspace_id, "test_workspace");
-    assert.equal(title_failure_log.details.session_id, session.id);
-    assert.equal(
-      title_failure_log.details.model_label,
-      "mock-session-title-failing-model",
-    );
-    assert.equal(
-      title_failure_log.details.message,
-      "mock title generation failed",
-    );
-    assert.equal(
-      title_failure_log.details.firstUserTextLength,
-      "Diagnose why session title generation is flaky".length,
-    );
-  } finally {
-    await agent.dispose();
-    await city.close();
-  }
-});
-
-test("Session retries title generation after model becomes available", async () => {
-  const agent_path = await fs.mkdtemp(
-    path.join(os.tmpdir(), "downcity-agent-session-title-retry-"),
-  );
-  const agent = new Agent({ id: "title_retry_agent" });
-  const entry = create_workspace_entry(agent, new Workspace({ id: "test_workspace", path: agent_path, data_root_path: path.join(agent_path, "data") }));
-  const session = await entry.sessions.create();
-  const events = [];
-  const unsubscribe = session.subscribe((event) => {
-    events.push(event);
-  });
-
-  try {
-    await session.append_user_message({
-      text: "Investigate flaky session title generation in the SDK",
-    });
-
-    assert.equal((await session.get_info()).title, undefined);
-
-    await session.set({
-      model: create_mock_title_model("排查 session 标题"),
-    });
-    await session.append_user_message({
-      text: "Need another prompt to trigger the retry path",
-    });
-
-    await wait_for_title(session, "排查 session 标题");
-  } finally {
-    unsubscribe();
-    await agent.dispose();
-  }
-});

package/scripts/session-tool-approval.test.mjs

@@ -1,173 +0,0 @@
-/**
- * @file 验证 Downcity RuntimeTool 审批接入 Session Interaction。
- *
- * 关键点（中文）
- * - Tool 自己声明审批意图，Agent 不持有审批配置。
- * - Runtime 展示真实 Tool Call，用户响应后继续原 Turn。
- * - 拒绝时 Tool execute 不能产生副作用。
- */
-
-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 { MockModelClient } from "./ModelClientMock.mjs";
-import { z } from "zod";
-import { Agent } from "@downcity/agent";
-import { Workspace } from "@downcity/workspace";
-import { create_workspace_entry } from "../bin/internal/index.js";
-
-function create_usage() {
-  return {
-    inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
-    outputTokens: { total: 0, text: 0, reasoning: 0 },
-  };
-}
-
-function create_tool_call_stream() {
-  const input = { value: "approval-value" };
-  return {
-    stream: new ReadableStream({
-      start(controller) {
-        controller.enqueue({ type: "stream-start", warnings: [] });
-        controller.enqueue({
-          type: "tool-input-start",
-          id: "call_custom_approval",
-          toolName: "custom_approval",
-        });
-        controller.enqueue({
-          type: "tool-input-delta",
-          id: "call_custom_approval",
-          delta: JSON.stringify(input),
-        });
-        controller.enqueue({ type: "tool-input-end", id: "call_custom_approval" });
-        controller.enqueue({
-          type: "tool-call",
-          toolCallId: "call_custom_approval",
-          toolName: "custom_approval",
-          input: JSON.stringify(input),
-        });
-        controller.enqueue({
-          type: "finish",
-          finishReason: { unified: "tool-calls", raw: "tool-calls" },
-          usage: create_usage(),
-        });
-        controller.close();
-      },
-    }),
-  };
-}
-
-function create_final_text_stream() {
-  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: "finished" });
-        controller.enqueue({ type: "text-end", id: "text_1" });
-        controller.enqueue({
-          type: "finish",
-          finishReason: { unified: "stop", raw: "stop" },
-          usage: create_usage(),
-        });
-        controller.close();
-      },
-    }),
-  };
-}
-
-async function run_approval_case(decision) {
-  const project_root = await fs.mkdtemp(
-    path.join(os.tmpdir(), "downcity-native-tool-approval-"),
-  );
-  let execution_count = 0;
-  let tool_stream_count = 0;
-  const model = new MockModelClient({
-    modelId: "native-tool-approval-model",
-    doStream: async (options) => {
-      if (!Array.isArray(options.tools) || options.tools.length === 0) {
-        return create_final_text_stream();
-      }
-      tool_stream_count += 1;
-      return tool_stream_count === 1
-        ? create_tool_call_stream()
-        : create_final_text_stream();
-    },
-    doGenerate: async () => ({
-      content: [{ type: "text", text: "Approval test" }],
-      finishReason: { unified: "stop", raw: "stop" },
-      usage: create_usage(),
-      warnings: [],
-    }),
-  });
-  const agent = new Agent({
-    id: `native_tool_approval_${decision}`,
-    model,
-    tools: {
-      custom_approval: {
-        description: "Execute a custom operation after approval.",
-        input_schema: z.object({ value: z.string() }),
-        needs_approval: true,
-        execute: async () => {
-          execution_count += 1;
-          return "tool-result";
-        },
-      },
-    },
-  });
-  const entry = create_workspace_entry(agent, new Workspace({ id: "test_workspace", path: project_root, data_root_path: path.join(project_root, "data") }));
-
-  try {
-    const session = await entry.sessions.create({ session_id: "tool_approval" });
-    let pending_request;
-    let response_promise;
-    const unsubscribe = session.subscribe((mutation) => {
-      if (
-        mutation.variant !== "part" ||
-        mutation.type !== "interaction" ||
-        mutation.part.status !== "pending" ||
-        mutation.part.request.type !== "approval" ||
-        mutation.part.request.payload.operation !== "tool"
-      ) return;
-      pending_request = mutation.part.request;
-      response_promise = session.respond({
-        interaction_id: mutation.part.interaction_id,
-        response: { type: "approval", outcome: decision === "approved" ? "resolved" : "denied", payload: { decision } },
-      });
-    });
-
-    const turn = await session.prompt({ query: "run custom approval tool" });
-    const result = await turn.finished;
-    unsubscribe();
-
-    assert.equal(result.success, true, result.error);
-    assert.equal(result.text, "finished");
-    assert.equal(execution_count, decision === "approved" ? 1 : 0);
-    assert.ok(pending_request);
-    assert.equal(pending_request.source.tool_name, "custom_approval");
-    assert.deepEqual(pending_request.payload.validated_input, {
-      value: "approval-value",
-    });
-    assert.equal(
-      pending_request.payload.tool_description,
-      "Execute a custom operation after approval.",
-    );
-    assert.equal("title" in pending_request, false);
-    assert.equal("reason" in pending_request, false);
-    assert.ok(response_promise);
-    await response_promise;
-  } finally {
-    await agent.dispose();
-    await fs.rm(project_root, { recursive: true, force: true });
-  }
-}
-
-test("needs_approval 批准后执行 Tool 并恢复原 Turn", async () => {
-  await run_approval_case("approved");
-});
-
-test("needs_approval 拒绝后不执行 Tool 副作用", async () => {
-  await run_approval_case("denied");
-});