create-windy 0.8.1 → 0.8.3

package/template/apps/web/src/pages/system/components/agent-workbench/ToolRuleDetail.vue

@@ -0,0 +1,81 @@
+<script setup lang="ts">
+import type { AgentAdminToolCatalogItem } from "@southwind-ai/shared";
+import { availabilityLabel, formatJson } from "./catalog-presenter";
+defineProps<{ tool?: AgentAdminToolCatalogItem }>();
+</script>
+<template>
+  <section
+    class="min-w-0 rounded-lg border bg-card p-5"
+    aria-label="工具规则详情"
+  >
+    <p v-if="!tool" class="text-sm text-muted-foreground">
+      选择工具查看规则与 Schema。
+    </p>
+    <template v-else>
+      <h2 class="text-lg font-semibold">{{ tool.label }}</h2>
+      <p class="mt-1 break-all font-mono text-xs text-muted-foreground">
+        {{ tool.key }}
+      </p>
+      <p class="mt-3 text-sm">{{ tool.description }}</p>
+      <p class="mt-3 rounded-md bg-muted p-3 text-sm">
+        {{ availabilityLabel(tool.availabilityReason) }}
+      </p>
+      <dl class="my-5 grid grid-cols-[7rem_minmax(0,1fr)] gap-2 text-sm">
+        <dt class="text-muted-foreground">所属模块</dt>
+        <dd>{{ tool.module }}</dd>
+        <dt class="text-muted-foreground">Feature / 权限</dt>
+        <dd class="break-all">
+          {{ tool.featureKey }} / {{ tool.permissionKey }}
+        </dd>
+        <dt class="text-muted-foreground">Scope / 执行</dt>
+        <dd>{{ tool.scopeMode }} / {{ tool.executionMode }}</dd>
+        <dt class="text-muted-foreground">动作 / 分类</dt>
+        <dd>{{ tool.operation }} / {{ tool.dataClassification }}</dd>
+        <dt class="text-muted-foreground">审批</dt>
+        <dd>
+          {{ tool.approval === "required" ? "需要审批" : "不需要审批"
+          }}<span v-if="tool.approvalRoles?.length">
+            ·
+            {{
+              tool.approvalRoles
+                .map((role) => role.name ?? role.code)
+                .join("、")
+            }}</span
+          ><span v-if="tool.approvalTimeoutSeconds">
+            · {{ tool.approvalTimeoutSeconds }} 秒</span
+          >
+        </dd>
+        <dt class="text-muted-foreground">幂等策略</dt>
+        <dd>{{ tool.idempotency }}</dd>
+        <dt class="text-muted-foreground">执行限制</dt>
+        <dd>
+          {{ tool.limits.maxDurationSeconds }} 秒；输入
+          {{ tool.limits.maxInputBytes }} 字节；输出
+          {{ tool.limits.maxOutputBytes }} 字节
+        </dd>
+        <dt class="text-muted-foreground">审计动作</dt>
+        <dd class="break-all">{{ tool.auditAction }}</dd>
+        <dt class="text-muted-foreground">允许的 Operations</dt>
+        <dd class="break-all">
+          {{ tool.allowedOperationKeys.join("、") || "没有已注册操作允许调用" }}
+        </dd>
+      </dl>
+      <details open class="mb-3">
+        <summary class="cursor-pointer text-sm font-medium">
+          输入 Schema · {{ tool.inputSchemaKey }}
+        </summary>
+        <pre
+          class="mt-2 max-h-80 overflow-auto rounded-md bg-muted p-3 text-xs"
+          >{{ formatJson(tool.inputSchema) }}</pre>
+      </details>
+      <details open>
+        <summary class="cursor-pointer text-sm font-medium">
+          输出 Schema · {{ tool.outputSchemaKey }}
+        </summary>
+        <pre
+          class="mt-2 max-h-80 overflow-auto rounded-md bg-muted p-3 text-xs"
+          >{{ formatJson(tool.outputSchema) }}</pre>
+      </details>
+    </template>
+  </section>
+</template>

package/template/apps/web/src/pages/system/components/agent-workbench/WorkbenchSessionList.vue

@@ -0,0 +1,57 @@
+<script setup lang="ts">
+import { computed, shallowRef } from "vue";
+import type { AgentWorkbenchRecordingSummaryV1 } from "@southwind-ai/shared";
+import { Input } from "@/components/ui/input";
+const props = defineProps<{
+  sessions: readonly AgentWorkbenchRecordingSummaryV1[];
+  selected?: AgentWorkbenchRecordingSummaryV1;
+}>();
+defineEmits<{ select: [session: AgentWorkbenchRecordingSummaryV1] }>();
+const query = shallowRef("");
+const filtered = computed(() =>
+  props.sessions.filter((session) =>
+    `${session.title} ${session.sessionId} ${session.operationKey ?? ""}`
+      .toLocaleLowerCase()
+      .includes(query.value.toLocaleLowerCase()),
+  ),
+);
+</script>
+<template>
+  <aside
+    class="space-y-3 rounded-lg border bg-card p-4"
+    aria-label="业务与测试会话"
+  >
+    <h2 class="font-medium">会话记录</h2>
+    <Input
+      v-model="query"
+      aria-label="搜索会话"
+      placeholder="名称、Session 或 Operation"
+    />
+    <div class="max-h-[65vh] space-y-2 overflow-y-auto">
+      <button
+        v-for="session in filtered"
+        :key="`${session.source}:${session.sessionId}`"
+        type="button"
+        :aria-pressed="
+          selected?.sessionId === session.sessionId &&
+          selected?.source === session.source
+        "
+        class="w-full rounded-md border p-3 text-left hover:bg-muted aria-pressed:border-primary aria-pressed:bg-primary/5"
+        @click="$emit('select', session)"
+      >
+        <span class="block text-sm font-medium">{{ session.title }}</span
+        ><span class="block break-all text-xs text-muted-foreground"
+          >{{
+            session.source === "business" ? "业务会话" : "Session 事件日志"
+          }}
+          · {{ session.sessionId }}</span
+        ><span class="block text-xs text-muted-foreground">{{
+          session.updatedAt
+        }}</span>
+      </button>
+      <p v-if="!filtered.length" class="py-5 text-sm text-muted-foreground">
+        暂无当前授权可查看的会话。
+      </p>
+    </div>
+  </aside>
+</template>

package/template/apps/web/src/pages/system/components/agent-workbench/catalog-presenter.ts

@@ -0,0 +1,20 @@
+import type { AgentAdminAvailabilityReason } from "@southwind-ai/shared";
+const reasons: Record<AgentAdminAvailabilityReason, string> = {
+  "internal-operation": "仅供服务端内部编排",
+  allowed: "当前具备调用条件（仍需运行时授权与审批）",
+  "permission-denied": "缺少执行权限",
+  "feature-unavailable": "功能未启用",
+  "license-unavailable": "许可不可用",
+  "scope-unavailable": "当前数据范围不满足要求",
+  "runtime-unavailable": "运行服务不可用",
+  "workflow-only": "仅能通过受治理工作流调用",
+  "unsupported-operation": "操作类型不支持直接调试",
+  "handler-unavailable": "工具实现未装配",
+  "governance-unavailable": "治理服务未就绪",
+};
+export function availabilityLabel(reason: AgentAdminAvailabilityReason) {
+  return reasons[reason];
+}
+export function formatJson(value: unknown) {
+  return JSON.stringify(value, null, 2);
+}

package/template/apps/web/src/pages/system/components/agent-workbench/replay-presenter.ts

@@ -0,0 +1,94 @@
+import type {
+  AgentWorkbenchEventV1,
+  AgentWorkbenchRecordingV1,
+} from "@southwind-ai/shared";
+export interface ReplayEntry {
+  readonly event: AgentWorkbenchEventV1;
+  readonly ledger: string;
+  readonly sessionId?: string;
+}
+/** Ledger-local sequence is retained. Expanded children do not imply a global clock. */
+export function replayEntries(
+  recording?: AgentWorkbenchRecordingV1,
+): readonly ReplayEntry[] {
+  if (!recording) return [];
+  const result: ReplayEntry[] = [];
+  const runs = new Set<string>();
+  const workflows = new Set<string>();
+  const segments = recording.segments ?? [
+    {
+      sessionId: recording.sessionId,
+      throughSequence: recording.timeline.at(-1)?.sequence ?? 0,
+      timeline: recording.timeline,
+    },
+  ];
+  for (const segment of segments) {
+    for (const event of segment.timeline) {
+      result.push({
+        event,
+        ledger: `Session ${segment.sessionId}`,
+        sessionId: segment.sessionId,
+      });
+      if (event.runId && !runs.has(event.runId)) {
+        const run = recording.runs.find(
+          (run) =>
+            run.runId === event.runId &&
+            (!run.sessionId || run.sessionId === segment.sessionId),
+        );
+        if (run) {
+          runs.add(run.runId);
+          result.push(
+            ...run.events.map((event) => ({
+              event,
+              ledger: `Run ${run.runId}`,
+              sessionId: run.sessionId ?? segment.sessionId,
+            })),
+          );
+        }
+      }
+      for (const workflow of recording.workflows) {
+        if (
+          workflows.has(workflow.workflowRunId) ||
+          (workflow.sessionId && workflow.sessionId !== segment.sessionId)
+        )
+          continue;
+        if (
+          workflow.workflowRunId !== event.workflowRunId &&
+          (!event.runId || workflow.parentRunId !== event.runId) &&
+          !workflow.nodes.some(
+            (node) => node.agentRunId && node.agentRunId === event.runId,
+          )
+        )
+          continue;
+        workflows.add(workflow.workflowRunId);
+        result.push(
+          ...workflow.events.map((event) => ({
+            event,
+            ledger: `Workflow ${workflow.workflowRunId}`,
+            sessionId: workflow.sessionId ?? segment.sessionId,
+          })),
+        );
+      }
+    }
+  }
+  // Unlinked facts remain explicitly separate; they are never assigned invented Turn IDs.
+  for (const run of recording.runs)
+    if (!runs.has(run.runId))
+      result.push(
+        ...run.events.map((event) => ({
+          event,
+          ledger: `独立 Run ${run.runId}（Session 关联缺失）`,
+          ...(run.sessionId ? { sessionId: run.sessionId } : {}),
+        })),
+      );
+  for (const workflow of recording.workflows)
+    if (!workflows.has(workflow.workflowRunId))
+      result.push(
+        ...workflow.events.map((event) => ({
+          event,
+          ledger: `独立 Workflow ${workflow.workflowRunId}（Session 关联缺失）`,
+          ...(workflow.sessionId ? { sessionId: workflow.sessionId } : {}),
+        })),
+      );
+  return result;
+}

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

@@ -0,0 +1,298 @@
+import { computed, onBeforeUnmount, onMounted, shallowRef, watch } from "vue";
+import type {
+  AgentAdminOperationCatalogItem,
+  AgentWorkbenchEventV1,
+  AgentWorkbenchRecordingSummaryV1,
+  AgentWorkbenchRecordingV1,
+  JsonValue,
+} from "@southwind-ai/shared";
+import { useAuthSession } from "@/composables/useAuthSession";
+import { useAccessSnapshot } from "@/composables/useAccessSnapshot";
+import {
+  cancelTestRun,
+  createTestRun,
+  createTestSession,
+  getTestRunResult,
+  getWorkbenchRecording,
+  listAdminOperations,
+  listWorkbenchRecordings,
+  streamTestRun,
+} from "@/services/agent-admin-api";
+export function useAgentWorkbench() {
+  const access = useAccessSnapshot();
+  const auth = useAuthSession();
+  const sessions = shallowRef<readonly AgentWorkbenchRecordingSummaryV1[]>([]);
+  const operations = shallowRef<readonly AgentAdminOperationCatalogItem[]>([]);
+  const selected = shallowRef<AgentWorkbenchRecordingSummaryV1>();
+  const recording = shallowRef<AgentWorkbenchRecordingV1>();
+  const liveEvents = shallowRef<readonly AgentWorkbenchEventV1[]>([]);
+  const liveRun = shallowRef<{
+    runId: string;
+    operationKey: string;
+    sessionId: string;
+    status: string;
+  }>();
+  const output = shallowRef<JsonValue>();
+  const error = shallowRef("");
+  const loading = shallowRef(false);
+  const starting = shallowRef(false);
+  const cancelling = shallowRef(false);
+  let listController: AbortController | undefined;
+  let detailController: AbortController | undefined;
+  let runController: AbortController | undefined;
+  let cancelController: AbortController | undefined;
+  const testSessions = new Set<string>();
+  const canManage = computed(() =>
+    Boolean(
+      access.snapshot.value?.actor.permissionKeys.includes(
+        "system.agent-debug.manage",
+      ),
+    ),
+  );
+  const running = computed(() =>
+    Boolean(
+      liveRun.value &&
+      !["completed", "failed", "cancelled"].includes(liveRun.value.status),
+    ),
+  );
+  function clear() {
+    listController?.abort();
+    detailController?.abort();
+    runController?.abort();
+    cancelController?.abort();
+    listController = undefined;
+    detailController = undefined;
+    runController = undefined;
+    cancelController = undefined;
+    testSessions.clear();
+    loading.value = false;
+    starting.value = false;
+    cancelling.value = false;
+    sessions.value = [];
+    operations.value = [];
+    selected.value = undefined;
+    recording.value = undefined;
+    liveEvents.value = [];
+    liveRun.value = undefined;
+    output.value = undefined;
+  }
+  watch([access.fingerprint, () => auth.actor.value?.id], () => {
+    clear();
+    error.value = "当前身份或授权发生变化，旧记录已隐藏，请手动刷新。";
+  });
+  onMounted(refresh);
+  onBeforeUnmount(() => {
+    listController?.abort();
+    detailController?.abort();
+    runController?.abort();
+    cancelController?.abort();
+  });
+  async function refresh() {
+    listController?.abort();
+    const controller = new AbortController();
+    listController = controller;
+    error.value = "";
+    loading.value = true;
+    const results = await Promise.allSettled([
+      listWorkbenchRecordings("harness", controller.signal),
+      listWorkbenchRecordings("business", controller.signal),
+      listAdminOperations(controller.signal),
+    ]);
+    if (controller.signal.aborted || listController !== controller) return;
+    const [harness, business, operation] = results;
+    sessions.value = [
+      ...(harness.status === "fulfilled" ? harness.value.items : []),
+      ...(business.status === "fulfilled" ? business.value.items : []),
+    ];
+    operations.value = operation.status === "fulfilled" ? operation.value : [];
+    const failures = results
+      .filter((result) => result.status === "rejected")
+      .map((result) => message(result.reason));
+    if (failures.length) error.value = failures.join("；");
+    loading.value = false;
+    if (selected.value) await select(selected.value);
+  }
+  async function select(session?: AgentWorkbenchRecordingSummaryV1) {
+    detailController?.abort();
+    const preserveLive = Boolean(
+      session &&
+      session.source === "harness" &&
+      liveRun.value?.sessionId === session.sessionId,
+    );
+    if (!preserveLive) {
+      runController?.abort();
+      cancelController?.abort();
+      runController = undefined;
+      cancelController = undefined;
+      starting.value = false;
+      cancelling.value = false;
+      liveEvents.value = [];
+      liveRun.value = undefined;
+      output.value = undefined;
+    }
+    selected.value = session;
+    recording.value = undefined;
+    error.value = "";
+    if (!session) return;
+    const controller = new AbortController();
+    detailController = controller;
+    loading.value = true;
+    try {
+      const result = await getWorkbenchRecording(
+        session.sessionId,
+        session.source,
+        controller.signal,
+      );
+      if (!controller.signal.aborted && detailController === controller)
+        recording.value = result;
+    } catch (failure) {
+      if (!controller.signal.aborted) error.value = message(failure);
+    } finally {
+      if (detailController === controller) loading.value = false;
+    }
+  }
+  async function start(
+    operationKey: string,
+    input: JsonValue,
+  ): Promise<boolean> {
+    if (!canManage.value || starting.value || running.value) return false;
+    starting.value = true;
+    error.value = "";
+    runController?.abort();
+    const controller = new AbortController();
+    runController = controller;
+    try {
+      let session = selected.value;
+      if (
+        !session ||
+        session.source !== "harness" ||
+        !testSessions.has(session.sessionId)
+      ) {
+        const created = await createTestSession(controller.signal);
+        if (controller.signal.aborted || runController !== controller)
+          return false;
+        testSessions.add(created.sessionId);
+        session = {
+          source: "harness",
+          sessionId: created.sessionId,
+          title: "调试测试会话",
+          updatedAt: new Date().toISOString(),
+        };
+        selected.value = session;
+        recording.value = undefined;
+        sessions.value = [session, ...sessions.value];
+      }
+      const created = await createTestRun(
+        operationKey,
+        input,
+        session.sessionId,
+        controller.signal,
+      );
+      if (controller.signal.aborted || runController !== controller)
+        return false;
+      liveEvents.value = [];
+      output.value = undefined;
+      liveRun.value = {
+        ...created,
+        operationKey,
+        sessionId: session.sessionId,
+      };
+      void follow(liveRun.value, controller);
+      return true;
+    } catch (failure) {
+      if (!controller.signal.aborted) error.value = message(failure);
+      return false;
+    } finally {
+      if (runController === controller) starting.value = false;
+    }
+  }
+  async function follow(
+    run: NonNullable<typeof liveRun.value>,
+    controller: AbortController,
+  ) {
+    try {
+      await streamTestRun(
+        run.runId,
+        run.operationKey,
+        run.sessionId,
+        (event) => {
+          if (controller.signal.aborted || runController !== controller) return;
+          if (
+            !liveEvents.value.some(
+              (current) => current.sequence === event.sequence,
+            )
+          )
+            liveEvents.value = [...liveEvents.value, event];
+          const status = event.type.startsWith("run.")
+            ? event.type.slice(4)
+            : undefined;
+          if (status && ["completed", "failed", "cancelled"].includes(status))
+            liveRun.value = { ...run, status };
+        },
+        controller.signal,
+      );
+      if (controller.signal.aborted || runController !== controller) return;
+      const result = await getTestRunResult(
+        run.runId,
+        run.operationKey,
+        run.sessionId,
+        controller.signal,
+      );
+      if (controller.signal.aborted || runController !== controller) return;
+      output.value = result.output;
+      liveRun.value = { ...run, status: result.status };
+      const history = await getWorkbenchRecording(
+        run.sessionId,
+        "harness",
+        controller.signal,
+      );
+      if (!controller.signal.aborted) recording.value = history;
+    } catch (failure) {
+      if (!controller.signal.aborted)
+        error.value = `${message(failure)}。运行未自动重试，请手动刷新会话。`;
+    }
+  }
+  async function cancel() {
+    const run = liveRun.value;
+    if (!run || cancelling.value) return;
+    cancelling.value = true;
+    cancelController?.abort();
+    const controller = new AbortController();
+    cancelController = controller;
+    try {
+      await cancelTestRun(
+        run.runId,
+        run.operationKey,
+        run.sessionId,
+        controller.signal,
+      );
+    } catch (failure) {
+      if (!controller.signal.aborted && cancelController === controller)
+        error.value = message(failure);
+    } finally {
+      if (cancelController === controller) cancelling.value = false;
+    }
+  }
+  return {
+    sessions,
+    operations,
+    selected,
+    recording,
+    liveEvents,
+    liveRun,
+    output,
+    error,
+    loading,
+    starting,
+    cancelling,
+    running,
+    canManage,
+    refresh,
+    select,
+    start,
+    cancel,
+  };
+}
+function message(error: unknown) {
+  return error instanceof Error ? error.message : "会话服务不可用";
+}