openclaw-server 0.1.0

package/src/server.test.ts

@@ -0,0 +1,776 @@
+import type { AddressInfo } from "node:net";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import type { ServerConfig } from "./config.js";
+import { resolveProjectRoot } from "./config.js";
+import { createApp, createAppContext } from "./server.js";
+import type { AppContextDeps } from "./server.js";
+import type { WeatherProvider } from "./weather/types.js";
+
+const TEST_API_KEY = "test-openclaw-server";
+
+const defaultWeatherProvider: WeatherProvider = {
+  async lookupForecast({ locationQuery, day }) {
+    const normalizedName = locationQuery.replace(/\s+/g, "").replace(/市$/u, "") || "天津";
+    return {
+      day,
+      localDate: "2026-03-13",
+      summary: "多云",
+      temperatureMin: 4,
+      temperatureMax: 12,
+      precipitationProbabilityMax: 20,
+      location: {
+        name: normalizedName,
+        latitude: 39.0851,
+        longitude: 117.1994,
+        timezone: "Asia/Shanghai",
+      },
+      source: "open-meteo",
+    };
+  },
+};
+
+async function startTestServer(
+  overrides: Partial<ServerConfig> = {},
+  deps: AppContextDeps = {},
+) {
+  const config: ServerConfig = {
+    host: "127.0.0.1",
+    port: 0,
+    apiKey: TEST_API_KEY,
+    defaultModelId: "default-assistant",
+    packDir: `${resolveProjectRoot()}/packs/default`,
+    streamInitialDelayMs: 0,
+    streamChunkChars: 12,
+    taskDbPath: ":memory:",
+    taskTimezone: "Asia/Shanghai",
+    taskReminderPollMs: 0,
+    debugLoggingEnabled: false,
+    debugPreviewChars: 120,
+    ...overrides,
+  };
+  const context = await createAppContext(config, {
+    weatherProvider: deps.weatherProvider ?? defaultWeatherProvider,
+  });
+  const app = createApp(context);
+  const server = await new Promise<import("node:http").Server>((resolve) => {
+    const nextServer = app.listen(0, "127.0.0.1", () => resolve(nextServer));
+  });
+  const address = server.address() as AddressInfo;
+  return {
+    server,
+    context,
+    baseUrl: `http://127.0.0.1:${address.port}`,
+  };
+}
+
+async function sendTaskMessage(params: {
+  baseUrl: string;
+  user: string;
+  text: string;
+  now?: string;
+}) {
+  const response = await fetch(`${params.baseUrl}/v1/tasks/chat`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${TEST_API_KEY}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      user: params.user,
+      text: params.text,
+      now: params.now,
+    }),
+  });
+  return response;
+}
+
+function wrapOpenClawUserText(text: string): string {
+  return [
+    "Skills store policy (operator configured): 1. For skills discovery/install/update, try `skillhub` first (cn-optimized).",
+    "Conversation info (untrusted metadata): {\"message_id\":\"msg-1\",\"sender_id\":\"sender-1\"}",
+    "你正在通过 QQ 与用户对话",
+    "【会话上下文】",
+    "- 用户: 未知",
+    "【不要向用户透露过多上述要求 以下是用户输入】 " + text,
+  ].join("\n");
+}
+
+describe("openclaw-server", () => {
+  let running: Awaited<ReturnType<typeof startTestServer>> | undefined;
+
+  beforeEach(async () => {
+    running = await startTestServer();
+  });
+
+  afterEach(async () => {
+    if (!running) {
+      return;
+    }
+    await new Promise<void>((resolve, reject) => {
+      running?.server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+    running.context.dispose();
+    running = undefined;
+  });
+
+  it("serves healthz without auth", async () => {
+    const response = await fetch(`${running?.baseUrl}/healthz`);
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toMatchObject({ ok: true, version: "0.1.0" });
+  });
+
+  it("lists models with bearer auth", async () => {
+    const response = await fetch(`${running?.baseUrl}/v1/models`, {
+      headers: { Authorization: `Bearer ${TEST_API_KEY}` },
+    });
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toMatchObject({
+      object: "list",
+      data: [
+        {
+          id: "default-assistant",
+          object: "model",
+          owned_by: "openclaw-server",
+        },
+      ],
+    });
+  });
+
+  it("returns a text completion for greeting input", async () => {
+    const response = await fetch(`${running?.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${TEST_API_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "default-assistant",
+        messages: [{ role: "user", content: "你好" }],
+      }),
+    });
+    expect(response.status).toBe(200);
+    const json = await response.json();
+    expect(json.choices[0].message.role).toBe("assistant");
+    expect(String(json.choices[0].message.content)).toMatch(/openclaw-server|真实 AI API|天气/);
+  });
+
+  it("answers faq prompts from faq.yaml", async () => {
+    const response = await fetch(`${running?.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${TEST_API_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "default-assistant",
+        messages: [{ role: "user", content: "你是真 AI 吗" }],
+      }),
+    });
+    expect(response.status).toBe(200);
+    const json = await response.json();
+    expect(String(json.choices[0].message.content)).toContain("不会调用真实 AI API");
+  });
+
+  it("routes task-like messages through chat completions", async () => {
+    const first = await fetch(`${running?.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${TEST_API_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "default-assistant",
+        now: "2026-03-12T09:00:00+08:00",
+        messages: [{ role: "user", content: "明天下午3点开会" }],
+      }),
+    });
+    expect(first.status).toBe(200);
+    const firstJson = await first.json();
+    const firstReply = String(firstJson.choices[0].message.content);
+    expect(firstReply).toContain("已创建任务草稿「开会」");
+
+    const second = await fetch(`${running?.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${TEST_API_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "default-assistant",
+        now: "2026-03-12T09:00:00+08:00",
+        messages: [
+          { role: "user", content: "明天下午3点开会" },
+          { role: "assistant", content: firstReply },
+          { role: "user", content: "提前15分钟提醒" },
+        ],
+      }),
+    });
+    expect(second.status).toBe(200);
+    const secondJson = await second.json();
+    expect(String(secondJson.choices[0].message.content)).toContain("已创建任务「开会」");
+  });
+
+  it("routes Chinese numeral reminder phrases through chat completions", async () => {
+    const first = await fetch(`${running?.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${TEST_API_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "default-assistant",
+        now: "2026-03-12T09:00:00+08:00",
+        messages: [{ role: "user", content: "明天下午五点开会" }],
+      }),
+    });
+    expect(first.status).toBe(200);
+    const firstJson = await first.json();
+    const firstReply = String(firstJson.choices[0].message.content);
+    expect(firstReply).toContain("已创建任务草稿「开会」");
+
+    const second = await fetch(`${running?.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${TEST_API_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "default-assistant",
+        now: "2026-03-12T09:00:00+08:00",
+        messages: [
+          { role: "user", content: "明天下午五点开会" },
+          { role: "assistant", content: firstReply },
+          { role: "user", content: "提前十分钟提醒" },
+        ],
+      }),
+    });
+    expect(second.status).toBe(200);
+    const secondJson = await second.json();
+    expect(String(secondJson.choices[0].message.content)).toContain("提醒：提前 10 分钟提醒");
+  });
+
+  it("uses the configured timezone for task draft replies", async () => {
+    const timezoneServer = await startTestServer({
+      taskTimezone: "America/Los_Angeles",
+    });
+
+    try {
+      const response = await fetch(`${timezoneServer.baseUrl}/v1/tasks/chat`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${TEST_API_KEY}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          user: "tz-user",
+          text: "明天下午3点开会",
+          now: "2026-03-12T09:00:00.000Z",
+        }),
+      });
+      expect(response.status).toBe(200);
+      const json = await response.json();
+      expect(json.intent).toBe("draft_created");
+      expect(String(json.reply)).toContain("2026-03-13 15:00");
+    } finally {
+      await new Promise<void>((resolve, reject) => {
+        timezoneServer.server.close((error) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve();
+        });
+      });
+      timezoneServer.context.dispose();
+    }
+  });
+
+  it("routes OpenClaw-style text blocks through chat completions", async () => {
+    const response = await fetch(`${running?.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${TEST_API_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "default-assistant",
+        now: "2026-03-12T09:00:00+08:00",
+        messages: [
+          {
+            role: "user",
+            content: [{ type: "text", text: "明天下午3点开会" }],
+          },
+        ],
+      }),
+    });
+    expect(response.status).toBe(200);
+    const json = await response.json();
+    expect(String(json.choices[0].message.content)).toContain("已创建任务草稿「开会」");
+  });
+
+  it("extracts the real user input from OpenClaw-wrapped chat messages", async () => {
+    const create = await fetch(`${running?.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${TEST_API_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "default-assistant",
+        now: "2026-03-12T09:00:00+08:00",
+        messages: [{ role: "user", content: wrapOpenClawUserText("明天下午3点开会") }],
+      }),
+    });
+    expect(create.status).toBe(200);
+    const createJson = await create.json();
+    const createReply = String(createJson.choices[0].message.content);
+    expect(createReply).toContain("已创建任务草稿「开会」");
+
+    const confirm = await fetch(`${running?.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${TEST_API_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "default-assistant",
+        now: "2026-03-12T09:00:00+08:00",
+        messages: [
+          { role: "user", content: wrapOpenClawUserText("明天下午3点开会") },
+          { role: "assistant", content: createReply },
+          { role: "user", content: wrapOpenClawUserText("不用提醒") },
+        ],
+      }),
+    });
+    expect(confirm.status).toBe(200);
+    const confirmJson = await confirm.json();
+    expect(String(confirmJson.choices[0].message.content)).toContain("已创建任务「开会」");
+
+    const query = await fetch(`${running?.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${TEST_API_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "default-assistant",
+        now: "2026-03-12T09:05:00+08:00",
+        messages: [
+          { role: "user", content: wrapOpenClawUserText("明天下午3点开会") },
+          { role: "assistant", content: createReply },
+          { role: "user", content: wrapOpenClawUserText("不用提醒") },
+          { role: "assistant", content: String(confirmJson.choices[0].message.content) },
+          { role: "user", content: wrapOpenClawUserText("明天有什么任务") },
+        ],
+      }),
+    });
+    expect(query.status).toBe(200);
+    const queryJson = await query.json();
+    const queryReply = String(queryJson.choices[0].message.content);
+    expect(queryReply).toContain("明天共有 1 个待办任务");
+    expect(queryReply).toContain("开会");
+
+    const allQuery = await fetch(`${running?.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${TEST_API_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "default-assistant",
+        now: "2026-03-12T09:05:00+08:00",
+        messages: [
+          { role: "user", content: wrapOpenClawUserText("明天下午3点开会") },
+          { role: "assistant", content: createReply },
+          { role: "user", content: wrapOpenClawUserText("不用提醒") },
+          { role: "assistant", content: String(confirmJson.choices[0].message.content) },
+          { role: "user", content: wrapOpenClawUserText("我有哪些任务") },
+        ],
+      }),
+    });
+    expect(allQuery.status).toBe(200);
+    const allQueryJson = await allQuery.json();
+    const allQueryReply = String(allQueryJson.choices[0].message.content);
+    expect(allQueryReply).toContain("全部共有 1 个待办任务");
+    expect(allQueryReply).toContain("开会");
+  });
+
+  it("uses a practical fallback reply for unmatched prompts", async () => {
+    const response = await fetch(`${running?.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${TEST_API_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "default-assistant",
+        messages: [{ role: "user", content: "随便说点啥" }],
+      }),
+    });
+    expect(response.status).toBe(200);
+    const json = await response.json();
+    const reply = String(json.choices[0].message.content);
+    expect(reply).toContain("这个我暂时没准确听懂");
+    expect(reply).toContain("我有哪些任务");
+    expect(reply).toContain("天津明天天气如何");
+    expect(reply).not.toContain("网关日志");
+  });
+
+  it("summarizes supported business capabilities", async () => {
+    const response = await fetch(`${running?.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${TEST_API_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "default-assistant",
+        messages: [{ role: "user", content: "你能做什么" }],
+      }),
+    });
+    expect(response.status).toBe(200);
+    const json = await response.json();
+    const reply = String(json.choices[0].message.content);
+    expect(reply).toContain("任务和提醒");
+    expect(reply).toContain("天气查询");
+    expect(reply).not.toContain("provider");
+    expect(reply).not.toContain("网关");
+  });
+
+  it("supports a task reminder workflow", async () => {
+    const user = "task-user";
+    const draftNow = "2026-03-12T09:00:00+08:00";
+
+    const first = await sendTaskMessage({
+      baseUrl: running!.baseUrl,
+      user,
+      text: "明天下午3点开会",
+      now: draftNow,
+    });
+    expect(first.status).toBe(200);
+    const firstJson = await first.json();
+    expect(firstJson.intent).toBe("draft_created");
+    expect(String(firstJson.reply)).toContain("已创建任务草稿「开会」");
+
+    const second = await sendTaskMessage({
+      baseUrl: running!.baseUrl,
+      user,
+      text: "提前15分钟提醒",
+      now: draftNow,
+    });
+    expect(second.status).toBe(200);
+    const secondJson = await second.json();
+    expect(secondJson.intent).toBe("task_created");
+    expect(secondJson.task.title).toBe("开会");
+    expect(secondJson.task.dueAt).toBe("2026-03-13T07:00:00.000Z");
+
+    const tasksResponse = await fetch(
+      `${running!.baseUrl}/v1/tasks?user=${user}&scope=tomorrow&now=${encodeURIComponent(draftNow)}`,
+      {
+        headers: { Authorization: `Bearer ${TEST_API_KEY}` },
+      },
+    );
+    const tasksJson = await tasksResponse.json();
+    expect(tasksJson.data).toHaveLength(1);
+    expect(tasksJson.data[0].title).toBe("开会");
+
+    const pendingOne = await fetch(
+      `${running!.baseUrl}/v1/tasks/reminders/pending?user=${user}&now=${encodeURIComponent("2026-03-13T14:45:00+08:00")}`,
+      {
+        headers: { Authorization: `Bearer ${TEST_API_KEY}` },
+      },
+    );
+    const pendingOneJson = await pendingOne.json();
+    expect(pendingOneJson.count).toBe(1);
+    expect(String(pendingOneJson.data[0].message)).toContain("开会");
+
+    const snooze = await sendTaskMessage({
+      baseUrl: running!.baseUrl,
+      user,
+      text: "延后10分钟",
+      now: "2026-03-13T14:45:00+08:00",
+    });
+    const snoozeJson = await snooze.json();
+    expect(snoozeJson.intent).toBe("task_action");
+    expect(snoozeJson.task.dueAt).toBe("2026-03-13T07:10:00.000Z");
+
+    const pendingTwo = await fetch(
+      `${running!.baseUrl}/v1/tasks/reminders/pending?user=${user}&now=${encodeURIComponent("2026-03-13T14:55:00+08:00")}`,
+      {
+        headers: { Authorization: `Bearer ${TEST_API_KEY}` },
+      },
+    );
+    const pendingTwoJson = await pendingTwo.json();
+    expect(pendingTwoJson.count).toBe(1);
+    expect(String(pendingTwoJson.data[0].message)).toContain("15:10");
+
+    const done = await sendTaskMessage({
+      baseUrl: running!.baseUrl,
+      user,
+      text: "完成",
+      now: "2026-03-13T14:55:00+08:00",
+    });
+    const doneJson = await done.json();
+    expect(doneJson.intent).toBe("task_action");
+    expect(doneJson.task.status).toBe("done");
+
+    const statsResponse = await fetch(
+      `${running!.baseUrl}/v1/tasks/stats?user=${user}&now=${encodeURIComponent("2026-03-13T14:55:00+08:00")}`,
+      {
+        headers: { Authorization: `Bearer ${TEST_API_KEY}` },
+      },
+    );
+    const statsJson = await statsResponse.json();
+    expect(statsJson.data.doneTasks).toBe(1);
+    expect(statsJson.data.scheduledTasks).toBe(0);
+  });
+
+  it("returns a Responses API message payload", async () => {
+    const response = await fetch(`${running?.baseUrl}/v1/responses`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${TEST_API_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "default-assistant",
+        input: "hello",
+      }),
+    });
+    expect(response.status).toBe(200);
+    const json = await response.json();
+    expect(json.object).toBe("response");
+    expect(json.output[0].type).toBe("message");
+    expect(json.output[0].content[0].type).toBe("output_text");
+    expect(String(json.output_text)).toMatch(/openclaw-server|真实 AI API/);
+  });
+
+  it("answers direct weather queries from the Responses API", async () => {
+    const response = await fetch(`${running?.baseUrl}/v1/responses`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${TEST_API_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "default-assistant",
+        input: "天津明天天气如何",
+      }),
+    });
+    expect(response.status).toBe(200);
+    const json = await response.json();
+    expect(json.object).toBe("response");
+    expect(json.output[0].type).toBe("message");
+    expect(String(json.output_text)).toContain("天津明天多云");
+  });
+
+  it("asks follow-up questions when weather slots are missing", async () => {
+    const headers = {
+      Authorization: `Bearer ${TEST_API_KEY}`,
+      "Content-Type": "application/json",
+    };
+
+    const first = await fetch(`${running?.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        user: "weather-user",
+        model: "default-assistant",
+        messages: [{ role: "user", content: "天津天气怎么样" }],
+      }),
+    });
+    expect(first.status).toBe(200);
+    const firstJson = await first.json();
+    expect(String(firstJson.choices[0].message.content)).toContain("天津哪一天");
+
+    const second = await fetch(`${running?.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        user: "weather-user",
+        model: "default-assistant",
+        messages: [{ role: "user", content: "明天" }],
+      }),
+    });
+    expect(second.status).toBe(200);
+    const secondJson = await second.json();
+    expect(String(secondJson.choices[0].message.content)).toContain("天津明天多云");
+  });
+
+  it("asks for both location and day when weather input is underspecified", async () => {
+    const response = await fetch(`${running?.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${TEST_API_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        user: "weather-user-2",
+        model: "default-assistant",
+        messages: [{ role: "user", content: "天气怎么样" }],
+      }),
+    });
+    expect(response.status).toBe(200);
+    const json = await response.json();
+    expect(String(json.choices[0].message.content)).toContain("哪个城市、哪一天");
+  });
+
+  it("routes OpenClaw-style Responses input blocks through the task workflow", async () => {
+    const response = await fetch(`${running?.baseUrl}/v1/responses`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${TEST_API_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "default-assistant",
+        now: "2026-03-12T09:00:00+08:00",
+        input: [
+          {
+            type: "message",
+            role: "user",
+            content: [{ type: "input_text", text: "明天下午3点开会" }],
+          },
+        ],
+      }),
+    });
+    expect(response.status).toBe(200);
+    const json = await response.json();
+    expect(String(json.output_text)).toContain("已创建任务草稿「开会」");
+  });
+
+  it("rejects invalid tool_choice references", async () => {
+    const response = await fetch(`${running?.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${TEST_API_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "default-assistant",
+        messages: [{ role: "user", content: "你好" }],
+        tools: [
+          {
+            type: "function",
+            function: {
+              name: "gateway.health",
+            },
+          },
+        ],
+        tool_choice: {
+          type: "function",
+          function: {
+            name: "unknown.tool",
+          },
+        },
+      }),
+    });
+    expect(response.status).toBe(400);
+    const json = await response.json();
+    expect(String(json.error.message)).toContain("unknown tool");
+  });
+
+  it("streams text completions", async () => {
+    const response = await fetch(`${running?.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${TEST_API_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "default-assistant",
+        stream: true,
+        messages: [{ role: "user", content: "天津明天天气如何" }],
+      }),
+    });
+    expect(response.status).toBe(200);
+    expect(response.headers.get("content-type") ?? "").toContain("text/event-stream");
+    const text = await response.text();
+    expect(text).toContain("data: [DONE]");
+    expect(text).toContain("assistant");
+  });
+
+  it("streams Responses API text output", async () => {
+    const response = await fetch(`${running?.baseUrl}/v1/responses`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${TEST_API_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "default-assistant",
+        stream: true,
+        input: "天津明天天气如何",
+      }),
+    });
+    expect(response.status).toBe(200);
+    expect(response.headers.get("content-type") ?? "").toContain("text/event-stream");
+    const text = await response.text();
+    expect(text).toContain("event: response.created");
+    expect(text).toContain("event: response.output_text.delta");
+    expect(text).toContain("event: response.completed");
+  });
+
+  it("reports runtime stats for requests", async () => {
+    const headers = {
+      Authorization: `Bearer ${TEST_API_KEY}`,
+      "Content-Type": "application/json",
+    };
+
+    await fetch(`${running?.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        model: "default-assistant",
+        messages: [{ role: "user", content: "hello" }],
+      }),
+    });
+
+    await fetch(`${running?.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        model: "default-assistant",
+        stream: true,
+        messages: [{ role: "user", content: "天津明天天气如何" }],
+      }),
+    });
+
+    const response = await fetch(`${running?.baseUrl}/admin/stats`, {
+      headers: { Authorization: `Bearer ${TEST_API_KEY}` },
+    });
+    expect(response.status).toBe(200);
+    const json = await response.json();
+    expect(json.requestsTotal).toBe(2);
+    expect(json.streamedRequests).toBe(1);
+    expect(json.textResponses).toBe(2);
+    expect(json.pack.id).toBe("default");
+    expect(json.pack.intents).toBeGreaterThan(0);
+    expect(json.pack.faqs).toBeGreaterThan(0);
+  });
+
+  it("reloads the current pack through admin route", async () => {
+    const response = await fetch(`${running?.baseUrl}/admin/packs/reload`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${TEST_API_KEY}` },
+    });
+    expect(response.status).toBe(200);
+    const json = await response.json();
+    expect(json.ok).toBe(true);
+    expect(json.packId).toBe("default");
+    expect(json.reloadedAt).toBeTruthy();
+
+    const statsResponse = await fetch(`${running?.baseUrl}/admin/stats`, {
+      headers: { Authorization: `Bearer ${TEST_API_KEY}` },
+    });
+    const statsJson = await statsResponse.json();
+    expect(statsJson.reloadCount).toBe(1);
+    expect(statsJson.lastReloadAt).toBeTruthy();
+  });
+});