create-windy 0.6.12 → 0.6.15

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";
+}

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

@@ -0,0 +1,138 @@
+import { flushPromises, mount } from "@vue/test-utils";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { defineComponent } from "vue";
+
+const mocks = vi.hoisted(() => ({
+  list: vi.fn(),
+  detail: vi.fn(),
+  contexts: vi.fn(),
+  memories: vi.fn(),
+  deleteMemory: vi.fn(),
+}));
+
+vi.mock("@/services/agent-session-api", () => ({
+  listAgentSessions: mocks.list,
+  getAgentSession: mocks.detail,
+  listAgentSessionContextVersions: mocks.contexts,
+  listAgentSessionMemories: mocks.memories,
+  deleteAgentSessionMemory: mocks.deleteMemory,
+}));
+
+import { useAgentSessions } from "./useAgentSessions";
+
+const Harness = defineComponent({
+  setup() {
+    return useAgentSessions();
+  },
+  template: "<div />",
+});
+
+describe("长期 Agent Session 只读状态", () => {
+  beforeEach(() => {
+    mocks.list.mockReset().mockResolvedValue({
+      items: [session("session_1"), session("session_2")],
+    });
+    mocks.detail.mockReset().mockImplementation(async (sessionId: string) => ({
+      session: session(sessionId),
+      timeline: [],
+    }));
+    mocks.contexts.mockReset().mockResolvedValue({ items: [] });
+    mocks.memories.mockReset().mockResolvedValue({ items: [] });
+    mocks.deleteMemory.mockReset().mockResolvedValue({ deleted: true });
+  });
+
+  test("加载列表后选择首项并并行读取三个投影", async () => {
+    const wrapper = mount(Harness);
+    await flushPromises();
+
+    expect(wrapper.vm.selectedSessionId).toBe("session_1");
+    expect(mocks.detail).toHaveBeenCalledWith(
+      "session_1",
+      expect.any(AbortSignal),
+    );
+    expect(mocks.contexts).toHaveBeenCalledWith(
+      "session_1",
+      expect.any(AbortSignal),
+    );
+    expect(mocks.memories).toHaveBeenCalledWith(
+      "session_1",
+      expect.any(AbortSignal),
+    );
+    wrapper.unmount();
+  });
+
+  test("单个投影失败不抹除其余已授权投影", async () => {
+    mocks.contexts.mockRejectedValue(new Error("Context 暂不可用"));
+    mocks.memories.mockResolvedValue({
+      items: [
+        {
+          memoryId: "memory_1",
+          kind: "session-summary",
+          scope: { kind: "session", id: "session_1" },
+          derivation: { sessionId: "session_1", throughSequence: 3 },
+          source: {
+            moduleKey: "system.agent",
+            kind: "recent-event",
+            id: "event_1",
+            version: "1",
+            sequence: 1,
+            digest: "sha256:source",
+          },
+          status: "active",
+          summary: "受控摘要",
+        },
+      ],
+    });
+    const wrapper = mount(Harness);
+    await flushPromises();
+
+    expect(wrapper.vm.detail?.session.sessionId).toBe("session_1");
+    expect(wrapper.vm.contextError).toBe("Context 暂不可用");
+    expect(wrapper.vm.memories).toHaveLength(1);
+    wrapper.unmount();
+  });
+
+  test("删除成功后只移除当前 Session 的单项投影", async () => {
+    mocks.memories.mockResolvedValue({
+      items: [memory("memory_1"), memory("memory_2")],
+    });
+    const wrapper = mount(Harness);
+    await flushPromises();
+
+    await wrapper.vm.deleteMemory("memory_1");
+
+    expect(mocks.deleteMemory).toHaveBeenCalledWith("session_1", "memory_1");
+    expect(wrapper.vm.memories.map(({ memoryId }) => memoryId)).toEqual([
+      "memory_2",
+    ]);
+    wrapper.unmount();
+  });
+});
+
+function memory(memoryId: string) {
+  return {
+    memoryId,
+    kind: "session-summary" as const,
+    scope: { kind: "session" as const, id: "session_1" },
+    derivation: { sessionId: "session_1", throughSequence: 3 },
+    source: {
+      moduleKey: "system.agent",
+      kind: "recent-event",
+      id: "event_1",
+      version: "1",
+      sequence: 1,
+      digest: "sha256:source",
+    },
+    status: "active" as const,
+    summary: "受控摘要",
+  };
+}
+
+function session(sessionId: string) {
+  return {
+    sessionId,
+    status: "active" as const,
+    headSequence: 3,
+    updatedAt: "2026-08-27T10:00:00.000Z",
+  };
+}