create-windy 0.8.2 → 0.8.3

package/template/apps/web/src/pages/system/composables/useAgentWorkbench.webtest.ts

@@ -0,0 +1,164 @@
+import { defineComponent, shallowRef } from "vue";
+import { flushPromises, mount } from "@vue/test-utils";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import type { AgentWorkbenchRecordingV1 } from "@southwind-ai/shared";
+const mocks = vi.hoisted(() => ({
+  list: vi.fn(),
+  operations: vi.fn(),
+  detail: vi.fn(),
+  session: vi.fn(),
+  run: vi.fn(),
+  stream: vi.fn(),
+  result: vi.fn(),
+  cancel: vi.fn(),
+}));
+vi.mock("@/services/agent-admin-api", () => ({
+  listWorkbenchRecordings: mocks.list,
+  listAdminOperations: mocks.operations,
+  getWorkbenchRecording: mocks.detail,
+  createTestSession: mocks.session,
+  createTestRun: mocks.run,
+  streamTestRun: mocks.stream,
+  getTestRunResult: mocks.result,
+  cancelTestRun: mocks.cancel,
+}));
+const fingerprint = shallowRef("actor-one");
+vi.mock("@/composables/useAccessSnapshot", () => ({
+  useAccessSnapshot: () => ({
+    fingerprint,
+    snapshot: shallowRef({
+      actor: { permissionKeys: ["system.agent-debug.manage"] },
+    }),
+  }),
+}));
+vi.mock("@/composables/useAuthSession", () => ({
+  useAuthSession: () => ({ actor: shallowRef({ id: "actor-one" }) }),
+}));
+import { useAgentWorkbench } from "./useAgentWorkbench";
+const history: AgentWorkbenchRecordingV1 = {
+  source: "harness",
+  sessionId: "session_test",
+  title: "测试",
+  updatedAt: "today",
+  mode: "read-only",
+  sideEffectPolicy: "no-reexecution",
+  correlationStatus: "complete",
+  timeline: [],
+  messages: [],
+  runs: [],
+  workflows: [],
+  missing: [],
+};
+function setup() {
+  let state!: ReturnType<typeof useAgentWorkbench>;
+  const wrapper = mount(
+    defineComponent({
+      setup() {
+        state = useAgentWorkbench();
+        return () => null;
+      },
+    }),
+  );
+  return { state, wrapper };
+}
+beforeEach(() => {
+  fingerprint.value = "actor-one";
+  vi.clearAllMocks();
+  mocks.list.mockResolvedValue({ items: [] });
+  mocks.operations.mockResolvedValue([]);
+  mocks.detail.mockResolvedValue(history);
+  mocks.session.mockResolvedValue({ sessionId: "session_test" });
+  mocks.run.mockResolvedValue({ runId: "run_test", status: "accepted" });
+  mocks.result.mockResolvedValue({
+    status: "completed",
+    output: { total: 12 },
+  });
+  mocks.cancel.mockResolvedValue({});
+  mocks.stream.mockImplementation(
+    async (_run, _operation, _session, onEvent) => {
+      onEvent({ sequence: 1, type: "run.completed", summary: "已完成" });
+    },
+  );
+});
+describe("真实测试工作台编排", () => {
+  test("选中的历史 canonical Session 只读，另起运行使用新 Session", async () => {
+    const { state, wrapper } = setup();
+    await flushPromises();
+    await state.select({
+      source: "harness",
+      sessionId: "session_historical",
+      title: "历史",
+      updatedAt: "today",
+    });
+    expect(mocks.run).not.toHaveBeenCalled();
+    await state.start("finance.query", {});
+    await flushPromises();
+    expect(mocks.session).toHaveBeenCalledTimes(1);
+    expect(mocks.run.mock.calls[0]?.[2]).toBe("session_test");
+    wrapper.unmount();
+  });
+
+  test("使用常规治理API，成功结果后同一Session可以再运行，不重复建Session", async () => {
+    const { state, wrapper } = setup();
+    await flushPromises();
+    expect(await state.start("finance.query", { request: "sum" })).toBe(true);
+    await flushPromises();
+    expect(state.output.value).toEqual({ total: 12 });
+    expect(await state.start("finance.query", { request: "next" })).toBe(true);
+    await flushPromises();
+    expect(mocks.session).toHaveBeenCalledTimes(1);
+    expect(mocks.run).toHaveBeenCalledTimes(2);
+    expect(mocks.run.mock.calls[1]?.slice(0, 3)).toEqual([
+      "finance.query",
+      { request: "next" },
+      "session_test",
+    ]);
+    wrapper.unmount();
+  });
+  test("只读业务选择不会启动模型；另起测试使用独立Session", async () => {
+    const { state, wrapper } = setup();
+    await flushPromises();
+    await state.select({
+      source: "business",
+      sessionId: "copilot_one",
+      title: "业务",
+      updatedAt: "today",
+    });
+    expect(mocks.run).not.toHaveBeenCalled();
+    expect(mocks.stream).not.toHaveBeenCalled();
+    expect(mocks.result).not.toHaveBeenCalled();
+    await state.start("finance.query", {});
+    await flushPromises();
+    expect(mocks.run.mock.calls[0]?.[2]).toBe("session_test");
+    wrapper.unmount();
+  });
+  test("手动取消运行与离开detach分开，授权变化会隐藏旧记录", async () => {
+    mocks.stream.mockImplementation(() => new Promise(() => {}));
+    const { state, wrapper } = setup();
+    await flushPromises();
+    await state.start("finance.query", {});
+    await state.cancel();
+    expect(mocks.cancel.mock.calls[0]?.slice(0, 3)).toEqual([
+      "run_test",
+      "finance.query",
+      "session_test",
+    ]);
+    fingerprint.value = "actor-two";
+    await flushPromises();
+    expect(state.liveRun.value).toBeUndefined();
+    expect(state.recording.value).toBeUndefined();
+    expect(state.sessions.value).toEqual([]);
+    wrapper.unmount();
+    expect(mocks.cancel).toHaveBeenCalledTimes(1);
+  });
+  test("新建失败保留错误且不自动重试", async () => {
+    mocks.run.mockRejectedValue(new Error("Runtime不可用"));
+    const { state, wrapper } = setup();
+    await flushPromises();
+    expect(await state.start("finance.query", {})).toBe(false);
+    await flushPromises();
+    expect(state.error.value).toContain("Runtime不可用");
+    expect(mocks.run).toHaveBeenCalledTimes(1);
+    wrapper.unmount();
+  });
+});

package/template/apps/web/src/pages/system/composables/useSessionReplay.ts

@@ -0,0 +1,48 @@
+import { computed, onBeforeUnmount, shallowRef, watch, type Ref } from "vue";
+import type { AgentWorkbenchEventV1 } from "@southwind-ai/shared";
+/** Local playback changes only the visible cursor; it never calls a runtime. */
+export function useSessionReplay(
+  events: Readonly<Ref<readonly AgentWorkbenchEventV1[]>>,
+) {
+  const cursor = shallowRef(-1);
+  const playing = shallowRef(false);
+  const speed = shallowRef(1);
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const current = computed(() => events.value[cursor.value]);
+  const visible = computed(() => events.value.slice(0, cursor.value + 1));
+  function pause() {
+    playing.value = false;
+    if (timer) clearTimeout(timer);
+    timer = undefined;
+  }
+  function seek(index: number) {
+    pause();
+    cursor.value = Math.max(-1, Math.min(index, events.value.length - 1));
+  }
+  function advance() {
+    if (!playing.value) return;
+    if (cursor.value >= events.value.length - 1) {
+      pause();
+      return;
+    }
+    cursor.value += 1;
+    timer = setTimeout(advance, 1000 / speed.value);
+  }
+  function play() {
+    if (cursor.value >= events.value.length - 1) cursor.value = -1;
+    playing.value = true;
+    advance();
+  }
+  watch(events, () => {
+    pause();
+    cursor.value = events.value.length ? 0 : -1;
+  });
+  watch(speed, () => {
+    if (playing.value) {
+      pause();
+      play();
+    }
+  });
+  onBeforeUnmount(pause);
+  return { cursor, playing, speed, current, visible, seek, pause, play };
+}

package/template/apps/web/src/router/index.ts

@@ -20,6 +20,8 @@ import SystemOperationsPage from "@/pages/system/SystemOperationsPage.vue";
 // @windy-module system.operations end
 // @windy-module system.agent begin
 import AiRuntimePage from "@/pages/system/AiRuntimePage.vue";
+import AgentToolsPage from "@/pages/system/AgentToolsPage.vue";
+import AgentDebugPage from "@/pages/system/AgentDebugPage.vue";
 import AgentSessionPage from "@/pages/system/AgentSessionPage.vue";
 import AgentWorkflowPage from "@/pages/system/AgentWorkflowPage.vue";
 // @windy-module system.agent end
@@ -101,6 +103,8 @@ const platformAdminPageComponents: Partial<
   operations: SystemOperationsPage,
   // @windy-module system.operations end
   // @windy-module system.agent begin
+  "agent-tools": AgentToolsPage,
+  "agent-debug": AgentDebugPage,
   "agent-session": AgentSessionPage,
   "agent-workflow": AgentWorkflowPage,
   "ai-runtime": AiRuntimePage,

package/template/apps/web/src/router/platform-admin-route-bindings.ts

@@ -8,6 +8,8 @@ export type PlatformAdminPageKey =
   | "notification"
   | "operations"
   // @windy-module system.agent begin
+  | "agent-tools"
+  | "agent-debug"
   | "agent-session"
   | "agent-workflow"
   | "ai-runtime"
@@ -60,6 +62,8 @@ export const platformAdminRouteBindings: readonly PlatformAdminRouteBinding[] =
     { routeKey: "system.ops", page: "operations" },
     // @windy-module system.operations end
     // @windy-module system.agent begin
+    { routeKey: "system.agent-tools", page: "agent-tools" },
+    { routeKey: "system.agent-debug", page: "agent-debug" },
     { routeKey: "system.agent-session", page: "agent-session" },
     { routeKey: "system.agent-workflow", page: "agent-workflow" },
     { routeKey: "system.ai-runtime", page: "ai-runtime" },

package/template/apps/web/src/services/agent-admin-api.ts

@@ -0,0 +1,155 @@
+import type {
+  AgentAdminOperationCatalogItem,
+  AgentAdminToolCatalogItem,
+  AgentWorkbenchRecordingSummaryV1,
+  AgentWorkbenchRecordingV1,
+  AgentWorkbenchEventV1,
+  JsonValue,
+} from "@southwind-ai/shared";
+import { apiRequest, apiResponse } from "./http";
+import { publicWorkbenchEvent } from "./agent-workbench-event";
+
+const policy = { suppressFailureHandler: true };
+export function listAdminTools(signal?: AbortSignal) {
+  return apiRequest<readonly AgentAdminToolCatalogItem[]>(
+    "/agent/admin/tools",
+    { signal },
+    policy,
+  );
+}
+export function listAdminOperations(signal?: AbortSignal) {
+  return apiRequest<readonly AgentAdminOperationCatalogItem[]>(
+    "/agent/admin/operations",
+    { signal },
+    policy,
+  );
+}
+export function listWorkbenchRecordings(
+  source: "harness" | "business",
+  signal?: AbortSignal,
+) {
+  return apiRequest<{ items: readonly AgentWorkbenchRecordingSummaryV1[] }>(
+    `/agent/admin/session-recordings?source=${source}`,
+    { signal },
+    policy,
+  );
+}
+export function getWorkbenchRecording(
+  sessionId: string,
+  source: "harness" | "business",
+  signal?: AbortSignal,
+) {
+  return apiRequest<AgentWorkbenchRecordingV1>(
+    `/agent/admin/session-recordings/${encodeURIComponent(sessionId)}?source=${source}`,
+    { signal },
+    policy,
+  );
+}
+export function createTestSession(signal?: AbortSignal) {
+  return apiRequest<{ sessionId: string }>(
+    "/agent/admin/test-sessions",
+    { method: "POST", body: "{}", signal },
+    policy,
+  );
+}
+export function createTestRun(
+  operationKey: string,
+  input: JsonValue,
+  sessionId: string,
+  signal?: AbortSignal,
+) {
+  return apiRequest<{ runId: string; status: string }>(
+    "/agent/runs",
+    {
+      method: "POST",
+      body: JSON.stringify({ operationKey, input, sessionId }),
+      headers: { "idempotency-key": crypto.randomUUID() },
+      signal,
+    },
+    policy,
+  );
+}
+function runPath(
+  runId: string,
+  operationKey: string,
+  action: string,
+  sessionId: string,
+) {
+  return `/agent/runs/${encodeURIComponent(runId)}/${action}?${new URLSearchParams({ operationKey, sessionId })}`;
+}
+export function getTestRunResult(
+  runId: string,
+  operationKey: string,
+  sessionId: string,
+  signal?: AbortSignal,
+) {
+  return apiRequest<{ status: string; output?: JsonValue }>(
+    runPath(runId, operationKey, "result", sessionId),
+    { signal },
+    policy,
+  );
+}
+export function cancelTestRun(
+  runId: string,
+  operationKey: string,
+  sessionId: string,
+  signal?: AbortSignal,
+) {
+  return apiRequest<unknown>(
+    runPath(runId, operationKey, "cancel", sessionId),
+    {
+      method: "POST",
+      body: JSON.stringify({ operationKey, sessionId }),
+      signal,
+    },
+    policy,
+  );
+}
+/** The server publishes a controlled summary; never retain arbitrary provider payloads. */
+export async function streamTestRun(
+  runId: string,
+  operationKey: string,
+  sessionId: string,
+  onEvent: (event: AgentWorkbenchEventV1) => void,
+  signal: AbortSignal,
+) {
+  const response = await apiResponse(
+    runPath(runId, operationKey, "events", sessionId),
+    { signal, headers: { accept: "text/event-stream" } },
+    policy,
+  );
+  if (!response.body) throw new Error("运行事件流不可用，请手动刷新会话");
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (!signal.aborted) {
+      const chunk = await reader.read();
+      if (chunk.done) break;
+      buffer += decoder.decode(chunk.value, { stream: true });
+      buffer = buffer.replace(/\r\n/g, "\n");
+      let boundary = buffer.indexOf("\n\n");
+      while (boundary !== -1) {
+        if (boundary > 1_048_576)
+          throw new Error("事件流超出安全大小，请手动刷新");
+        const frame = buffer.slice(0, boundary);
+        buffer = buffer.slice(boundary + 2);
+        const data = frame
+          .split("\n")
+          .filter((line) => line.startsWith("data:"))
+          .map((line) => line.slice(5).trimStart())
+          .join("\n");
+        if (data) {
+          const event = publicWorkbenchEvent(JSON.parse(data));
+          if (event) onEvent(event);
+        }
+        boundary = buffer.indexOf("\n\n");
+      }
+      if (buffer.length > 1_048_576)
+        throw new Error("事件流超出安全大小，请手动刷新");
+    }
+  } finally {
+    await reader.cancel().catch(() => undefined);
+    reader.releaseLock();
+  }
+}

package/template/apps/web/src/services/agent-admin-api.webtest.ts

@@ -0,0 +1,120 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+const mocks = vi.hoisted(() => ({ request: vi.fn(), response: vi.fn() }));
+vi.mock("./http", () => ({
+  apiRequest: mocks.request,
+  apiResponse: mocks.response,
+}));
+import {
+  cancelTestRun,
+  createTestRun,
+  createTestSession,
+  getTestRunResult,
+  getWorkbenchRecording,
+  streamTestRun,
+} from "./agent-admin-api";
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.request.mockResolvedValue({});
+});
+describe("工作台正常治理 API 契约", () => {
+  test("创建真实Session/run并绑定幂等键，result/cancel带同一Session与Operation", async () => {
+    const controller = new AbortController();
+    await createTestSession(controller.signal);
+    await createTestRun(
+      "finance.query",
+      { question: "sum" },
+      "session_one",
+      controller.signal,
+    );
+    expect(mocks.request.mock.calls[0]?.[0]).toBe("/agent/admin/test-sessions");
+    const request = mocks.request.mock.calls[1]!;
+    expect(request[0]).toBe("/agent/runs");
+    expect(JSON.parse(request[1].body)).toEqual({
+      operationKey: "finance.query",
+      input: { question: "sum" },
+      sessionId: "session_one",
+    });
+    expect(request[1].headers["idempotency-key"]).toMatch(/^[0-9a-f-]{36}$/);
+    expect(request[1].signal).toBe(controller.signal);
+    await getTestRunResult(
+      "run_one",
+      "finance.query",
+      "session_one",
+      controller.signal,
+    );
+    await cancelTestRun(
+      "run_one",
+      "finance.query",
+      "session_one",
+      controller.signal,
+    );
+    expect(mocks.request.mock.calls[2]?.[0]).toBe(
+      "/agent/runs/run_one/result?operationKey=finance.query&sessionId=session_one",
+    );
+    expect(mocks.request.mock.calls[3]?.[0]).toContain(
+      "/cancel?operationKey=finance.query&sessionId=session_one",
+    );
+    expect(mocks.request.mock.calls[3]?.[1].signal).toBe(controller.signal);
+  });
+  test("历史读取只请求受控recording，不触发result或启动接口", async () => {
+    await getWorkbenchRecording("business/session", "business");
+    expect(mocks.request).toHaveBeenCalledTimes(1);
+    expect(mocks.request.mock.calls[0]?.[0]).toBe(
+      "/agent/admin/session-recordings/business%2Fsession?source=business",
+    );
+  });
+  test("SSE跨chunk CRLF与UTF8、同chunk多frame不会漏事件或保留私有参数", async () => {
+    const encoder = new TextEncoder();
+    const frames = [
+      'data: {"sequence":1,"type":"tool.requested","summary":"位置工具","arguments":{"token":"hidden"}}\r\n\r\n',
+      'data: {"sequence":2,"type":"run.completed","summary":"已完成"}\r\n\r\n',
+    ].join("");
+    const bytes = encoder.encode(frames);
+    const split =
+      frames.indexOf("\r\n") +
+      encoder.encode("位置工具").length -
+      "位置工具".length +
+      1;
+    mocks.response.mockResolvedValue(
+      new Response(
+        new ReadableStream({
+          start(controller) {
+            controller.enqueue(bytes.slice(0, split));
+            controller.enqueue(bytes.slice(split));
+            controller.close();
+          },
+        }),
+      ),
+    );
+    const events: unknown[] = [];
+    await streamTestRun(
+      "run_1",
+      "query",
+      "session_1",
+      (event) => events.push(event),
+      new AbortController().signal,
+    );
+    expect(events).toHaveLength(2);
+    expect(JSON.stringify(events)).toContain("位置工具");
+    expect(JSON.stringify(events)).not.toContain("hidden");
+  });
+  test("单chunk的多个合法frame总大小超过1MB仍逐条处理", async () => {
+    const data = Array.from(
+      { length: 100 },
+      (_, index) =>
+        `data: ${JSON.stringify({ sequence: index + 1, type: "output.delta", summary: "a".repeat(11000) })}\n\n`,
+    ).join("");
+    mocks.response.mockResolvedValue(new Response(data));
+    let count = 0;
+    await streamTestRun(
+      "run_1",
+      "query",
+      "session_1",
+      () => {
+        count += 1;
+      },
+      new AbortController().signal,
+    );
+    expect(count).toBe(100);
+  });
+});

package/template/apps/web/src/services/agent-workbench-event.ts

@@ -0,0 +1,60 @@
+import type { AgentWorkbenchEventV1 } from "@southwind-ai/shared";
+/** Defense in depth: discard fields outside the server's public event contract. */
+export function publicWorkbenchEvent(
+  value: unknown,
+): AgentWorkbenchEventV1 | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return;
+  const raw = value as Record<string, unknown>;
+  if (
+    !Number.isSafeInteger(raw.sequence) ||
+    Number(raw.sequence) < 0 ||
+    typeof raw.type !== "string"
+  )
+    return;
+  const summary = typeof raw.summary === "string" ? raw.summary : raw.type;
+  const strings = [
+    "occurredAt",
+    "runId",
+    "turnId",
+    "stepId",
+    "modelAttemptId",
+    "toolCallId",
+    "toolKey",
+    "workItemId",
+    "artifactId",
+    "workflowRunId",
+    "nodeRunId",
+    "outcome",
+  ] as const;
+  const refs = Object.fromEntries(
+    strings.flatMap((key) =>
+      typeof raw[key] === "string" ? [[key, raw[key]]] : [],
+    ),
+  );
+  const usage =
+    raw.usage && typeof raw.usage === "object" && !Array.isArray(raw.usage)
+      ? (raw.usage as Record<string, unknown>)
+      : undefined;
+  const measured = usage
+    ? Object.fromEntries(
+        ["inputTokens", "outputTokens", "totalTokens", "costMicros"].flatMap(
+          (key) =>
+            typeof usage[key] === "number" &&
+            Number.isFinite(usage[key]) &&
+            Number(usage[key]) >= 0
+              ? [[key, usage[key]]]
+              : [],
+        ),
+      )
+    : undefined;
+  return {
+    sequence: Number(raw.sequence),
+    type: raw.type,
+    summary,
+    ...refs,
+    ...(Number.isSafeInteger(raw.attemptSequence)
+      ? { attemptSequence: Number(raw.attemptSequence) }
+      : {}),
+    ...(measured ? { usage: measured } : {}),
+  };
+}

package/template/docs/architecture/agent-harness.md

@@ -462,3 +462,7 @@ Compose、`service_adk_debug` 或活跃 `ADK_DEBUG_*` 配置。
 - [DeepSeek Harness Architecture](https://github.com/deepseek-ai/deepseek-harness/blob/master/docs/architecture.md)
 - [Vue Flow](https://vueflow.dev/)：Vue 3 Workflow 画布候选；采用前仍需完成依赖评估与固定版本。
 - [PageAgent](https://github.com/alibaba/page-agent)：页面理解与浏览器动作复用边界。
+
+## 管理端调试与业务回放（2026-10-07）
+
+动态工具目录与统一调试工作台沿用本 Harness 治理边界；业务会话可提供真实 Run/Workflow 引用，父子 Session 回放沿用 AH-1 checkpoint/lineage。历史只读取已有记录，缺少引用或超出有界窗口时显示 partial/missing。测试运行新建独立 Session，不在历史回放中启动模型或工具。实现与发布边界见[工作台技术实现](./agent-admin-workbench-implementation.md)，本节不将尚未发布的隔离执行与 Trace 扩展视为已交付。

package/template/packages/modules/src/ai-operation-composition.ts

@@ -57,6 +57,15 @@ function validateOperation(
   operation: ModuleAiOperationDefinition,
   catalogs: AiOperationCatalogs,
 ): void {
+  if (
+    operation.visibility !== undefined &&
+    operation.visibility !== "public" &&
+    operation.visibility !== "internal"
+  ) {
+    throw new Error(
+      `AI Operation ${operation.key} visibility 必须为 public 或 internal`,
+    );
+  }
   const strings = [
     operation.key,
     operation.featureKey,

package/template/packages/modules/src/ai-operation-visibility.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "bun:test";
+import type { ModuleAiOperationDefinition } from "./manifest.js";
+import { validateModuleComposition } from "./composition.js";
+import { fixture, operation } from "./ai-operation-composition.test-support.js";
+
+describe("AI Operation browser visibility", () => {
+  test.each([undefined, "public", "internal"] as const)(
+    "Explicit %s keeps canonical registration compatible",
+    (visibility) => {
+      const module = fixture("business");
+      module.aiOperations = [
+        {
+          ...operation("business.generate"),
+          ...(visibility ? { visibility } : {}),
+        },
+      ];
+      expect(() => validateModuleComposition([module])).not.toThrow();
+    },
+  );
+
+  test("Unknown visibility fails closed instead of becoming public", () => {
+    const module = fixture("business");
+    module.aiOperations = [
+      {
+        ...operation("business.generate"),
+        visibility: "private",
+      } as unknown as ModuleAiOperationDefinition,
+    ];
+    expect(() => validateModuleComposition([module])).toThrow(
+      "visibility 必须为 public 或 internal",
+    );
+  });
+});

package/template/packages/modules/src/manifest.ts

@@ -234,6 +234,8 @@ export interface AiScreenshotContextBindingV1 {
 export interface ModuleAiOperationDefinition {
   key: string;
   kind: AiOperationKind;
+  /** internal Operation 仅供可信服务端编排，不暴露普通 Agent Run API。 */
+  visibility?: "public" | "internal";
   featureKey: string;
   permissionKey: string;
   auditAction: AuditActionType;

package/template/packages/modules/src/system-admin-routes.ts

@@ -122,6 +122,22 @@ export const systemAdminRoutes: ModuleManifest["adminRoutes"] = [
   ),
   // @windy-module system.audit end
   // @windy-module system.agent begin
+  route(
+    "system.agent-tools",
+    "/admin/system/agent-tools",
+    "Agent 工具目录",
+    "sidebar",
+    "system.agent-tools.read",
+    "system.agent-tools",
+  ),
+  route(
+    "system.agent-debug",
+    "/admin/system/agent-debug",
+    "Agent 调试工作台",
+    "sidebar",
+    "system.agent-debug.read",
+    "system.agent-debug",
+  ),
   route(
     "system.agent-session",
     "/admin/system/agent-sessions",