create-windy 0.6.12 → 0.6.14

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

@@ -0,0 +1,74 @@
+import type {
+  AgentWorkflowNodeRunStatus,
+  AgentWorkflowNodeType,
+  AgentWorkflowRunStatus,
+} from "@/services/agent-workflow-api";
+
+type Status = AgentWorkflowRunStatus | AgentWorkflowNodeRunStatus;
+type BadgeVariant = "default" | "secondary" | "destructive" | "outline";
+
+const STATUS_LABELS: Record<Status, string> = {
+  accepted: "已接受",
+  pending: "待调度",
+  ready: "就绪",
+  running: "运行中",
+  waiting: "等待中",
+  "retry-scheduled": "等待重试",
+  completed: "已完成",
+  failed: "失败",
+  cancelled: "已取消",
+  skipped: "已跳过",
+  "timed-out": "已超时",
+};
+
+const NODE_TYPE_LABELS: Record<AgentWorkflowNodeType, string> = {
+  model: "模型",
+  tool: "工具",
+  subagent: "子 Agent",
+  condition: "条件",
+  parallel: "并行",
+  join: "汇合",
+  approval: "审批",
+  job: "后台作业",
+  wait: "等待",
+  artifact: "Artifact",
+  final: "最终输出",
+};
+
+export function workflowStatusLabel(status: Status) {
+  return STATUS_LABELS[status];
+}
+
+export function workflowStatusVariant(status: Status): BadgeVariant {
+  if (status === "failed" || status === "timed-out") return "destructive";
+  if (status === "completed") return "default";
+  if (status === "running" || status === "ready") return "secondary";
+  return "outline";
+}
+
+export function workflowNodeTypeLabel(type: AgentWorkflowNodeType) {
+  return NODE_TYPE_LABELS[type];
+}
+
+export function formatDuration(durationMs: number) {
+  if (durationMs < 1_000) return `${durationMs} ms`;
+  const seconds = durationMs / 1_000;
+  if (seconds < 60) return `${seconds.toFixed(seconds < 10 ? 1 : 0)} 秒`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = Math.floor(seconds % 60);
+  return `${minutes} 分 ${remainingSeconds} 秒`;
+}
+
+export function formatInteger(value: number) {
+  return new Intl.NumberFormat("zh-CN").format(value);
+}
+
+export function formatByteSize(value: number) {
+  if (value < 1_024) return `${value} B`;
+  if (value < 1_048_576) return `${(value / 1_024).toFixed(1)} KiB`;
+  return `${(value / 1_048_576).toFixed(1)} MiB`;
+}
+
+export function formatCostMicros(value: number, currency: string) {
+  return `${currency} ${(value / 1_000_000).toFixed(6)}`;
+}

package/template/apps/web/src/pages/system/components/agent-workflow/workflow-graph-layout.ts

@@ -0,0 +1,108 @@
+import { MarkerType, Position } from "@vue-flow/core";
+import type { Edge, Node } from "@vue-flow/core";
+import type {
+  AgentWorkflowEdgeProjection,
+  AgentWorkflowNodeProjection,
+} from "@/services/agent-workflow-api";
+
+export interface WorkflowGraphNodeData {
+  readonly projection: AgentWorkflowNodeProjection;
+  readonly selected: boolean;
+}
+
+export function latestWorkflowNodes(
+  nodes: readonly AgentWorkflowNodeProjection[],
+) {
+  const latest = new Map<string, AgentWorkflowNodeProjection>();
+  for (const node of nodes) {
+    const current = latest.get(node.nodeId);
+    if (!current || node.attempt > current.attempt)
+      latest.set(node.nodeId, node);
+  }
+  return [...latest.values()];
+}
+
+export function layoutWorkflowGraph(
+  nodes: readonly AgentWorkflowNodeProjection[],
+  edges: readonly AgentWorkflowEdgeProjection[],
+  selectedNodeRunId: string,
+): { nodes: Node<WorkflowGraphNodeData>[]; edges: Edge[] } {
+  const latestNodes = latestWorkflowNodes(nodes);
+  const nodeIds = new Set(latestNodes.map(({ nodeId }) => nodeId));
+  const knownEdges = edges.filter(
+    ({ from, to }) => nodeIds.has(from) && nodeIds.has(to),
+  );
+  const depths = calculateDepths(latestNodes, knownEdges);
+  const rowByDepth = new Map<number, number>();
+
+  return {
+    nodes: latestNodes.map((node) => {
+      const depth = depths.get(node.nodeId) ?? 0;
+      const row = rowByDepth.get(depth) ?? 0;
+      rowByDepth.set(depth, row + 1);
+      return {
+        id: node.nodeId,
+        type: "workflow",
+        position: { x: depth * 300, y: row * 150 },
+        sourcePosition: Position.Right,
+        targetPosition: Position.Left,
+        data: {
+          projection: node,
+          selected: node.nodeRunId === selectedNodeRunId,
+        },
+        draggable: false,
+        connectable: false,
+        deletable: false,
+        selectable: true,
+        focusable: true,
+        ariaLabel: `${node.label}，${node.type}，${node.status}`,
+      };
+    }),
+    edges: knownEdges.map((edge, index) => ({
+      id: `${edge.from}-${edge.to}-${edge.branch ?? index}`,
+      source: edge.from,
+      target: edge.to,
+      label: edge.branch,
+      selectable: false,
+      focusable: false,
+      animated: false,
+      markerEnd: MarkerType.ArrowClosed,
+    })),
+  };
+}
+
+function calculateDepths(
+  nodes: readonly AgentWorkflowNodeProjection[],
+  edges: readonly AgentWorkflowEdgeProjection[],
+) {
+  const order = new Map(nodes.map((node, index) => [node.nodeId, index]));
+  const indegree = new Map(nodes.map((node) => [node.nodeId, 0]));
+  const outgoing = new Map<string, string[]>();
+  const depths = new Map(nodes.map((node) => [node.nodeId, 0]));
+
+  for (const edge of edges) {
+    indegree.set(edge.to, (indegree.get(edge.to) ?? 0) + 1);
+    outgoing.set(edge.from, [...(outgoing.get(edge.from) ?? []), edge.to]);
+  }
+
+  const queue = nodes
+    .filter(({ nodeId }) => indegree.get(nodeId) === 0)
+    .map(({ nodeId }) => nodeId);
+  while (queue.length) {
+    const nodeId = queue.shift();
+    if (!nodeId) continue;
+    const nextNodeIds = [...(outgoing.get(nodeId) ?? [])].sort(
+      (left, right) => (order.get(left) ?? 0) - (order.get(right) ?? 0),
+    );
+    for (const nextNodeId of nextNodeIds) {
+      depths.set(
+        nextNodeId,
+        Math.max(depths.get(nextNodeId) ?? 0, (depths.get(nodeId) ?? 0) + 1),
+      );
+      const remaining = (indegree.get(nextNodeId) ?? 1) - 1;
+      indegree.set(nextNodeId, remaining);
+      if (remaining === 0) queue.push(nextNodeId);
+    }
+  }
+  return depths;
+}

package/template/apps/web/src/pages/system/components/ai-runtime/AiRuntimeRunDetailDialog.vue

@@ -26,6 +26,7 @@ import {
   formatTokenCount,
   runStatusLabel,
 } from "../../ai-runtime-presenter";
+import AiRuntimeTrajectory from "./AiRuntimeTrajectory.vue";
 
 defineProps<{
   detail?: AiRuntimeRunDetail;
@@ -81,6 +82,12 @@ const open = defineModel<boolean>("open", { required: true });
               {{ detail.operationKey }}
             </dd>
           </div>
+          <div class="sm:col-span-2">
+            <dt class="text-muted-foreground">Engine</dt>
+            <dd class="mt-1 break-all font-mono text-xs">
+              {{ detail.engineId }}
+            </dd>
+          </div>
           <div>
             <dt class="text-muted-foreground">开始时间</dt>
             <dd class="mt-1">{{ formatDateTime(detail.startedAt) }}</dd>
@@ -101,6 +108,8 @@ const open = defineModel<boolean>("open", { required: true });
           </div>
         </dl>
 
+        <AiRuntimeTrajectory :trajectory="detail.trajectory" />
+
         <section class="space-y-3">
           <h3 class="text-sm font-medium">Provider Attempts</h3>
           <div class="overflow-hidden rounded-md border">

package/template/apps/web/src/pages/system/components/ai-runtime/AiRuntimeRunDetailDialog.webtest.ts

@@ -12,6 +12,7 @@ describe("AI Runtime Run 详情", () => {
         open: true,
         detail: {
           runId: "run_1",
+          engineId: "windy.direct.openai-compatible.v1",
           operationKey: "business.answer",
           actor: null,
           status: "completed",
@@ -21,6 +22,25 @@ describe("AI Runtime Run 详情", () => {
           cacheStatus: "unknown",
           releaseId: "release_1",
           traceId: "trace_1",
+          trajectory: {
+            available: true,
+            events: [
+              {
+                sequence: 1,
+                sequenceEnd: 1,
+                type: "run.started",
+                title: "开始执行",
+              },
+              {
+                sequence: 2,
+                sequenceEnd: 3,
+                type: "output.delta",
+                title: "模型生成输出",
+                deltaCount: 2,
+                outputCharacters: 8,
+              },
+            ],
+          },
           attemptItems: [
             {
               sequence: 1,
@@ -65,6 +85,8 @@ describe("AI Runtime Run 详情", () => {
     );
     expect(rows[0]?.textContent).toContain("ai.primary · Provider 回报");
     expect(rows[1]?.textContent).toContain("ai.fallback · 请求模型");
+    expect(document.body.textContent).toContain("执行轨迹");
+    expect(document.body.textContent).toContain("2 个输出片段 · 8 字符");
     wrapper.unmount();
   });
 });

package/template/apps/web/src/pages/system/components/ai-runtime/AiRuntimeRunTable.webtest.ts

@@ -10,6 +10,7 @@ describe("AI Runtime Run 列表", () => {
           items: [
             {
               runId: "run_1",
+              engineId: "windy.direct.openai-compatible.v1",
               operationKey: "business.answer",
               actor: null,
               status: "completed",
@@ -31,6 +32,7 @@ describe("AI Runtime Run 列表", () => {
             },
             {
               runId: "run_2",
+              engineId: "google.adk.v2",
               operationKey: "business.answer",
               actor: null,
               status: "failed",

package/template/apps/web/src/pages/system/components/ai-runtime/AiRuntimeTrajectory.vue

@@ -0,0 +1,118 @@
+<script setup lang="ts">
+import { computed } from "vue";
+import type { AiRuntimeTrajectory } from "@southwind-ai/shared";
+
+interface DisplayEvent {
+  key: string;
+  sequence: string;
+  title: string;
+  detail?: string;
+}
+
+const props = defineProps<{
+  trajectory: AiRuntimeTrajectory;
+}>();
+
+const displayEvents = computed<DisplayEvent[]>(() =>
+  props.trajectory.events.map((event) => ({
+    key: `${event.sequence}-${event.sequenceEnd}-${event.type}`,
+    sequence:
+      event.sequence === event.sequenceEnd
+        ? `#${event.sequence}`
+        : `#${event.sequence}–${event.sequenceEnd}`,
+    title: event.title,
+    detail: eventDetail(event),
+  })),
+);
+
+function eventDetail(event: AiRuntimeTrajectory["events"][number]) {
+  const details: string[] = [];
+  if (event.inputModalities?.length) {
+    details.push(
+      `输入模态：${event.inputModalities.map(modalityLabel).join("、")}`,
+    );
+  }
+  if (event.artifactCount) details.push(`${event.artifactCount} 个受控附件`);
+  if (event.toolKey) details.push(event.toolKey);
+  if (event.approvalOutcome) {
+    details.push(`审批结果：${approvalLabel(event.approvalOutcome)}`);
+  }
+  if (event.attemptSequence) details.push(`Attempt #${event.attemptSequence}`);
+  if (event.totalTokens !== undefined)
+    details.push(`${event.totalTokens} Token`);
+  if (event.deltaCount !== undefined) {
+    details.push(
+      `${event.deltaCount} 个输出片段 · ${event.outputCharacters ?? 0} 字符`,
+    );
+  }
+  if (event.errorCode) details.push(`错误码：${event.errorCode}`);
+  return details.length ? details.join(" · ") : undefined;
+}
+
+function modalityLabel(value: string) {
+  if (value === "text") return "文本";
+  if (value === "image") return "图像";
+  return value;
+}
+
+function approvalLabel(value: string) {
+  if (value === "approved") return "已批准";
+  if (value === "rejected") return "已拒绝";
+  if (value === "cancelled") return "已取消";
+  if (value === "timed-out") return "已超时";
+  return value;
+}
+</script>
+
+<template>
+  <section class="space-y-3" aria-labelledby="ai-runtime-trajectory-title">
+    <div>
+      <h3 id="ai-runtime-trajectory-title" class="text-sm font-medium">
+        执行轨迹
+      </h3>
+      <p class="mt-1 text-xs text-muted-foreground">
+        仅展示受治理事件；输入输出正文、Tool 参数和 Provider
+        原始响应不会出现在这里。
+      </p>
+    </div>
+
+    <p
+      v-if="!trajectory.available"
+      class="rounded-md border border-dashed px-4 py-6 text-center text-sm text-muted-foreground"
+    >
+      该 Run 的报表仍可读取，但 canonical 事件已超过留存期。
+    </p>
+    <p
+      v-else-if="!displayEvents.length"
+      class="rounded-md border border-dashed px-4 py-6 text-center text-sm text-muted-foreground"
+    >
+      暂无可展示的受治理事件。
+    </p>
+    <ol v-else class="rounded-md border px-4 py-1">
+      <li
+        v-for="event in displayEvents"
+        :key="event.key"
+        class="grid grid-cols-[auto_1fr] gap-3 border-b py-3 last:border-b-0"
+      >
+        <span
+          class="mt-1.5 size-2 rounded-full bg-primary"
+          aria-hidden="true"
+        />
+        <div class="min-w-0">
+          <div class="flex flex-wrap items-baseline gap-x-2 gap-y-1">
+            <span class="text-sm font-medium">{{ event.title }}</span>
+            <span class="font-mono text-xs text-muted-foreground">
+              {{ event.sequence }}
+            </span>
+          </div>
+          <p
+            v-if="event.detail"
+            class="mt-1 break-all text-xs text-muted-foreground"
+          >
+            {{ event.detail }}
+          </p>
+        </div>
+      </li>
+    </ol>
+  </section>
+</template>

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

@@ -0,0 +1,209 @@
+import { onBeforeUnmount, onMounted, readonly, shallowRef } from "vue";
+import {
+  deleteAgentSessionMemory,
+  getAgentSession,
+  listAgentSessionContextVersions,
+  listAgentSessionMemories,
+  listAgentSessions,
+  type AgentContextVersion,
+  type AgentMemoryProjection,
+  type AgentSessionDetailResponse,
+  type AgentSessionSummary,
+} from "@/services/agent-session-api";
+
+export function useAgentSessions() {
+  const sessions = shallowRef<readonly AgentSessionSummary[]>([]);
+  const selectedSessionId = shallowRef("");
+  const detail = shallowRef<AgentSessionDetailResponse>();
+  const contextVersions = shallowRef<readonly AgentContextVersion[]>([]);
+  const memories = shallowRef<readonly AgentMemoryProjection[]>([]);
+  const listLoading = shallowRef(false);
+  const detailLoading = shallowRef(false);
+  const contextLoading = shallowRef(false);
+  const memoryLoading = shallowRef(false);
+  const deletingMemoryId = shallowRef("");
+  const listError = shallowRef("");
+  const detailError = shallowRef("");
+  const contextError = shallowRef("");
+  const memoryError = shallowRef("");
+  let listController: AbortController | undefined;
+  let projectionController: AbortController | undefined;
+  let listRevision = 0;
+  let projectionRevision = 0;
+
+  onMounted(() => void refresh());
+  onBeforeUnmount(cancelRequests);
+
+  async function refresh() {
+    const revision = ++listRevision;
+    listController?.abort();
+    const controller = new AbortController();
+    listController = controller;
+    listLoading.value = true;
+    listError.value = "";
+    try {
+      const result = await listAgentSessions(controller.signal);
+      if (!isCurrentList(revision, controller)) return;
+      sessions.value = result.items;
+      const nextSessionId = result.items.some(
+        ({ sessionId }) => sessionId === selectedSessionId.value,
+      )
+        ? selectedSessionId.value
+        : (result.items[0]?.sessionId ?? "");
+      if (!nextSessionId) {
+        clearSelection();
+        return;
+      }
+      selectedSessionId.value = nextSessionId;
+      await loadProjection(nextSessionId);
+    } catch (error) {
+      if (isCurrentList(revision, controller) && !isAbortError(error)) {
+        listError.value = errorMessage(error);
+      }
+    } finally {
+      if (revision === listRevision) {
+        listLoading.value = false;
+        listController = undefined;
+      }
+    }
+  }
+
+  async function selectSession(sessionId: string) {
+    if (!sessionId.trim()) return;
+    selectedSessionId.value = sessionId;
+    await loadProjection(sessionId);
+  }
+
+  async function deleteMemory(memoryId: string) {
+    const sessionId = selectedSessionId.value;
+    if (!sessionId || !memoryId.trim() || deletingMemoryId.value) return;
+    deletingMemoryId.value = memoryId;
+    memoryError.value = "";
+    try {
+      await deleteAgentSessionMemory(sessionId, memoryId);
+      if (selectedSessionId.value === sessionId) {
+        memories.value = memories.value.filter(
+          (memory) => memory.memoryId !== memoryId,
+        );
+      }
+    } catch (error) {
+      if (selectedSessionId.value === sessionId) {
+        memoryError.value = errorMessage(error);
+      }
+    } finally {
+      if (deletingMemoryId.value === memoryId) {
+        deletingMemoryId.value = "";
+      }
+    }
+  }
+
+  async function loadProjection(sessionId: string) {
+    const revision = ++projectionRevision;
+    projectionController?.abort();
+    const controller = new AbortController();
+    projectionController = controller;
+    resetProjection();
+    setProjectionLoading(true);
+
+    const [detailResult, contextResult, memoryResult] =
+      await Promise.allSettled([
+        getAgentSession(sessionId, controller.signal),
+        listAgentSessionContextVersions(sessionId, controller.signal),
+        listAgentSessionMemories(sessionId, controller.signal),
+      ]);
+    if (!isCurrentProjection(revision, sessionId, controller)) return;
+
+    if (detailResult.status === "fulfilled") {
+      detail.value = detailResult.value;
+    } else if (!isAbortError(detailResult.reason)) {
+      detailError.value = errorMessage(detailResult.reason);
+    }
+    if (contextResult.status === "fulfilled") {
+      contextVersions.value = contextResult.value.items;
+    } else if (!isAbortError(contextResult.reason)) {
+      contextError.value = errorMessage(contextResult.reason);
+    }
+    if (memoryResult.status === "fulfilled") {
+      memories.value = memoryResult.value.items;
+    } else if (!isAbortError(memoryResult.reason)) {
+      memoryError.value = errorMessage(memoryResult.reason);
+    }
+    setProjectionLoading(false);
+    projectionController = undefined;
+  }
+
+  function resetProjection() {
+    detail.value = undefined;
+    contextVersions.value = [];
+    memories.value = [];
+    detailError.value = "";
+    contextError.value = "";
+    memoryError.value = "";
+  }
+
+  function clearSelection() {
+    projectionRevision += 1;
+    projectionController?.abort();
+    projectionController = undefined;
+    selectedSessionId.value = "";
+    resetProjection();
+    setProjectionLoading(false);
+  }
+
+  function setProjectionLoading(value: boolean) {
+    detailLoading.value = value;
+    contextLoading.value = value;
+    memoryLoading.value = value;
+  }
+
+  function cancelRequests() {
+    listRevision += 1;
+    projectionRevision += 1;
+    listController?.abort();
+    projectionController?.abort();
+  }
+
+  function isCurrentList(revision: number, controller: AbortController) {
+    return revision === listRevision && !controller.signal.aborted;
+  }
+
+  function isCurrentProjection(
+    revision: number,
+    sessionId: string,
+    controller: AbortController,
+  ) {
+    return (
+      revision === projectionRevision &&
+      selectedSessionId.value === sessionId &&
+      !controller.signal.aborted
+    );
+  }
+
+  return {
+    sessions: readonly(sessions),
+    selectedSessionId: readonly(selectedSessionId),
+    detail: readonly(detail),
+    contextVersions: readonly(contextVersions),
+    memories: readonly(memories),
+    listLoading: readonly(listLoading),
+    detailLoading: readonly(detailLoading),
+    contextLoading: readonly(contextLoading),
+    memoryLoading: readonly(memoryLoading),
+    deletingMemoryId: readonly(deletingMemoryId),
+    listError: readonly(listError),
+    detailError: readonly(detailError),
+    contextError: readonly(contextError),
+    memoryError: readonly(memoryError),
+    refresh,
+    selectSession,
+    deleteMemory,
+  };
+}
+
+function errorMessage(error: unknown) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function isAbortError(error: unknown) {
+  return error instanceof Error && error.name === "AbortError";
+}