create-windy 0.6.12 → 0.6.14

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

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

@@ -0,0 +1,173 @@
+import {
+  onBeforeUnmount,
+  onMounted,
+  readonly,
+  shallowRef,
+  toValue,
+  watch,
+  type MaybeRefOrGetter,
+} from "vue";
+import {
+  getAgentWorkflowRun,
+  listAgentWorkflowRuns,
+  type AgentWorkflowRunDetailResponse,
+  type AgentWorkflowRunSummary,
+} from "@/services/agent-workflow-api";
+
+interface UseAgentWorkflowRunsOptions {
+  readonly preferredRunId?: MaybeRefOrGetter<string>;
+}
+
+export function useAgentWorkflowRuns(
+  options: UseAgentWorkflowRunsOptions = {},
+) {
+  const runs = shallowRef<readonly AgentWorkflowRunSummary[]>([]);
+  const selectedRunId = shallowRef("");
+  const detail = shallowRef<AgentWorkflowRunDetailResponse>();
+  const listLoading = shallowRef(false);
+  const detailLoading = shallowRef(false);
+  const listError = shallowRef("");
+  const detailError = shallowRef("");
+  let listController: AbortController | undefined;
+  let detailController: AbortController | undefined;
+  let listRevision = 0;
+  let detailRevision = 0;
+
+  onMounted(() => void refresh());
+  onBeforeUnmount(cancelRequests);
+  watch(
+    () => preferredRunId(options.preferredRunId),
+    (runId) => {
+      if (runId && runId !== selectedRunId.value) void selectRun(runId);
+    },
+  );
+
+  async function refresh() {
+    const revision = ++listRevision;
+    listController?.abort();
+    const controller = new AbortController();
+    listController = controller;
+    listLoading.value = true;
+    listError.value = "";
+
+    try {
+      const response = await listAgentWorkflowRuns(controller.signal);
+      if (!isCurrentList(revision, controller)) return;
+      runs.value = response.items;
+      const requestedRunId = preferredRunId(options.preferredRunId);
+      const nextRunId =
+        requestedRunId ||
+        (response.items.some(({ runId }) => runId === selectedRunId.value)
+          ? selectedRunId.value
+          : (response.items[0]?.runId ?? ""));
+      if (!nextRunId) {
+        clearSelection();
+        return;
+      }
+      selectedRunId.value = nextRunId;
+      await loadDetail(nextRunId);
+    } catch (error) {
+      if (isCurrentList(revision, controller) && !isAbortError(error)) {
+        listError.value = errorMessage(error);
+      }
+    } finally {
+      if (revision === listRevision) {
+        listLoading.value = false;
+        listController = undefined;
+      }
+    }
+  }
+
+  async function selectRun(runId: string) {
+    if (!runId.trim() || runId === selectedRunId.value) return;
+    selectedRunId.value = runId;
+    await loadDetail(runId);
+  }
+
+  async function loadDetail(runId: string) {
+    const revision = ++detailRevision;
+    detailController?.abort();
+    const controller = new AbortController();
+    detailController = controller;
+    detailLoading.value = true;
+    detailError.value = "";
+    detail.value = undefined;
+
+    try {
+      const response = await getAgentWorkflowRun(runId, controller.signal);
+      if (isCurrentDetail(revision, runId, controller)) {
+        detail.value = response;
+      }
+    } catch (error) {
+      if (
+        isCurrentDetail(revision, runId, controller) &&
+        !isAbortError(error)
+      ) {
+        detailError.value = errorMessage(error);
+      }
+    } finally {
+      if (revision === detailRevision) {
+        detailLoading.value = false;
+        detailController = undefined;
+      }
+    }
+  }
+
+  function clearSelection() {
+    detailRevision += 1;
+    detailController?.abort();
+    detailController = undefined;
+    selectedRunId.value = "";
+    detail.value = undefined;
+    detailError.value = "";
+    detailLoading.value = false;
+  }
+
+  function cancelRequests() {
+    listRevision += 1;
+    detailRevision += 1;
+    listController?.abort();
+    detailController?.abort();
+  }
+
+  function isCurrentList(revision: number, controller: AbortController) {
+    return revision === listRevision && !controller.signal.aborted;
+  }
+
+  function isCurrentDetail(
+    revision: number,
+    runId: string,
+    controller: AbortController,
+  ) {
+    return (
+      revision === detailRevision &&
+      selectedRunId.value === runId &&
+      !controller.signal.aborted
+    );
+  }
+
+  return {
+    runs: readonly(runs),
+    selectedRunId: readonly(selectedRunId),
+    detail: readonly(detail),
+    listLoading: readonly(listLoading),
+    detailLoading: readonly(detailLoading),
+    listError: readonly(listError),
+    detailError: readonly(detailError),
+    refresh,
+    selectRun,
+  };
+}
+
+function preferredRunId(value: MaybeRefOrGetter<string> | undefined) {
+  const runId = value ? toValue(value).trim() : "";
+  return runId.length <= 256 ? runId : "";
+}
+
+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/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 AgentSessionPage from "@/pages/system/AgentSessionPage.vue";
+import AgentWorkflowPage from "@/pages/system/AgentWorkflowPage.vue";
 // @windy-module system.agent end
 // @windy-module system.notification begin
 import SystemNotificationsPage from "@/pages/system/SystemNotificationsPage.vue";
@@ -99,6 +101,8 @@ const platformAdminPageComponents: Partial<
   operations: SystemOperationsPage,
   // @windy-module system.operations end
   // @windy-module system.agent begin
+  "agent-session": AgentSessionPage,
+  "agent-workflow": AgentWorkflowPage,
   "ai-runtime": AiRuntimePage,
   // @windy-module system.agent end
   // @windy-module system.configuration begin

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

@@ -7,7 +7,11 @@ export type PlatformAdminPageKey =
   | "license"
   | "notification"
   | "operations"
+  // @windy-module system.agent begin
+  | "agent-session"
+  | "agent-workflow"
   | "ai-runtime"
+  // @windy-module system.agent end
   | "configuration"
   | "ui-components";
 
@@ -56,6 +60,8 @@ export const platformAdminRouteBindings: readonly PlatformAdminRouteBinding[] =
     { routeKey: "system.ops", page: "operations" },
     // @windy-module system.operations end
     // @windy-module system.agent begin
+    { routeKey: "system.agent-session", page: "agent-session" },
+    { routeKey: "system.agent-workflow", page: "agent-workflow" },
     { routeKey: "system.ai-runtime", page: "ai-runtime" },
     // @windy-module system.agent end
     // @windy-module system.configuration begin

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

@@ -0,0 +1,159 @@
+import { apiRequest } from "./http";
+
+export type AgentSessionStatus = "active" | "archived";
+
+export interface AgentSessionLineage {
+  readonly parentSessionId: string;
+  readonly parentCheckpointId: string;
+  readonly parentSequence: number;
+}
+
+export interface AgentSessionSummary {
+  readonly sessionId: string;
+  readonly status: AgentSessionStatus;
+  readonly headSequence: number;
+  readonly updatedAt: string;
+  readonly lineage?: AgentSessionLineage;
+}
+
+export interface AgentSessionTimelineEvent {
+  readonly sequence: number;
+  readonly type: string;
+  readonly occurredAt: string;
+  readonly summary: string;
+  readonly runId?: string;
+  readonly turnId?: string;
+  readonly stepId?: string;
+}
+
+export interface AgentSessionDetailResponse {
+  readonly session: AgentSessionSummary;
+  readonly timeline: readonly AgentSessionTimelineEvent[];
+}
+
+export interface AgentSessionListResponse {
+  readonly items: readonly AgentSessionSummary[];
+}
+
+export type ContextSourceValidityStatus = "valid" | "invalid";
+
+export interface ContextSourceValidity {
+  readonly status: ContextSourceValidityStatus;
+  readonly checkedAt: string;
+  readonly expiresAt?: string;
+  readonly reason?: string;
+}
+
+export interface AgentContextSource {
+  readonly moduleKey: string;
+  readonly kind: string;
+  readonly id: string;
+  readonly version: string;
+  readonly sequence: number;
+  readonly digest: string;
+  readonly validity: ContextSourceValidity;
+}
+
+export interface AgentContextVersion {
+  readonly contextVersionId: string;
+  readonly sessionId: string;
+  readonly turnId: string;
+  readonly runId: string;
+  readonly modelAttemptId: string;
+  readonly sources: readonly AgentContextSource[];
+  readonly digest: string;
+  readonly createdAt: string;
+}
+
+export interface AgentContextVersionListResponse {
+  readonly items: readonly AgentContextVersion[];
+}
+
+export type AgentMemoryKind =
+  | "working-context"
+  | "session-summary"
+  | "user-preference"
+  | "case-memory-candidate"
+  | "verified-fact-reference";
+
+export type AgentMemoryStatus = "active" | "invalidated" | "deleted";
+export type AgentMemoryScopeKind = "session" | "user" | "case";
+
+export interface AgentMemoryScope {
+  readonly kind: AgentMemoryScopeKind;
+  readonly id: string;
+}
+
+export interface AgentMemorySource {
+  readonly moduleKey: string;
+  readonly kind: string;
+  readonly id: string;
+  readonly version: string;
+  readonly sequence: number;
+  readonly digest: string;
+}
+
+export interface AgentMemoryProjection {
+  readonly memoryId: string;
+  readonly kind: AgentMemoryKind;
+  readonly scope: AgentMemoryScope;
+  readonly derivation: {
+    readonly sessionId: string;
+    readonly throughSequence: number;
+  };
+  readonly currentCaseId?: string;
+  readonly source: AgentMemorySource;
+  readonly status: AgentMemoryStatus;
+  readonly expiresAt?: string;
+  /** Server-controlled projection. Raw content, value and claim are never read. */
+  readonly summary: string;
+}
+
+export interface AgentMemoryListResponse {
+  readonly items: readonly AgentMemoryProjection[];
+}
+
+export function listAgentSessions(signal?: AbortSignal) {
+  return apiRequest<AgentSessionListResponse>(
+    "/agent/harness/sessions",
+    requestOptions(signal),
+  );
+}
+
+export function getAgentSession(sessionId: string, signal?: AbortSignal) {
+  return apiRequest<AgentSessionDetailResponse>(
+    `/agent/harness/sessions/${encodeURIComponent(sessionId)}`,
+    requestOptions(signal),
+  );
+}
+
+export function listAgentSessionContextVersions(
+  sessionId: string,
+  signal?: AbortSignal,
+) {
+  return apiRequest<AgentContextVersionListResponse>(
+    `/agent/harness/sessions/${encodeURIComponent(sessionId)}/context-versions`,
+    requestOptions(signal),
+  );
+}
+
+export function listAgentSessionMemories(
+  sessionId: string,
+  signal?: AbortSignal,
+) {
+  return apiRequest<AgentMemoryListResponse>(
+    `/agent/harness/sessions/${encodeURIComponent(sessionId)}/memories`,
+    requestOptions(signal),
+  );
+}
+
+export function deleteAgentSessionMemory(sessionId: string, memoryId: string) {
+  return apiRequest<{ readonly deleted: true }>(
+    `/agent/harness/sessions/${encodeURIComponent(sessionId)}/memories/${encodeURIComponent(memoryId)}`,
+    { method: "DELETE" },
+  );
+}
+
+function requestOptions(signal?: AbortSignal): { signal?: AbortSignal } {
+  return signal ? { signal } : {};
+}

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

@@ -0,0 +1,65 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({ apiRequest: vi.fn() }));
+vi.mock("./http", () => mocks);
+
+import {
+  deleteAgentSessionMemory,
+  getAgentSession,
+  listAgentSessionContextVersions,
+  listAgentSessionMemories,
+  listAgentSessions,
+} from "./agent-session-api";
+
+describe("长期 Agent Session API", () => {
+  beforeEach(() =>
+    mocks.apiRequest.mockReset().mockResolvedValue({ items: [] }),
+  );
+
+  test("调用只读 Session、Context 与 Memory 投影接口", async () => {
+    await listAgentSessions();
+    await getAgentSession("session/含空格");
+    await listAgentSessionContextVersions("session/含空格");
+    await listAgentSessionMemories("session/含空格");
+
+    expect(mocks.apiRequest).toHaveBeenNthCalledWith(
+      1,
+      "/agent/harness/sessions",
+      {},
+    );
+    expect(mocks.apiRequest).toHaveBeenNthCalledWith(
+      2,
+      "/agent/harness/sessions/session%2F%E5%90%AB%E7%A9%BA%E6%A0%BC",
+      {},
+    );
+    expect(mocks.apiRequest).toHaveBeenNthCalledWith(
+      3,
+      "/agent/harness/sessions/session%2F%E5%90%AB%E7%A9%BA%E6%A0%BC/context-versions",
+      {},
+    );
+    expect(mocks.apiRequest).toHaveBeenNthCalledWith(
+      4,
+      "/agent/harness/sessions/session%2F%E5%90%AB%E7%A9%BA%E6%A0%BC/memories",
+      {},
+    );
+  });
+
+  test("详情请求传递取消信号", async () => {
+    const controller = new AbortController();
+    await getAgentSession("session_1", controller.signal);
+
+    expect(mocks.apiRequest).toHaveBeenCalledWith(
+      "/agent/harness/sessions/session_1",
+      { signal: controller.signal },
+    );
+  });
+
+  test("删除单项 Memory 投影使用编码后的派生坐标", async () => {
+    await deleteAgentSessionMemory("session/含空格", "memory/1");
+
+    expect(mocks.apiRequest).toHaveBeenCalledWith(
+      "/agent/harness/sessions/session%2F%E5%90%AB%E7%A9%BA%E6%A0%BC/memories/memory%2F1",
+      { method: "DELETE" },
+    );
+  });
+});