create-windy 0.6.12 → 0.6.15

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

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

@@ -0,0 +1,181 @@
+import { apiRequest } from "./http";
+
+export type AgentWorkflowRunStatus =
+  | "accepted"
+  | "running"
+  | "waiting"
+  | "completed"
+  | "failed"
+  | "cancelled"
+  | "timed-out";
+
+export type AgentWorkflowNodeRunStatus =
+  | "pending"
+  | "ready"
+  | "running"
+  | "waiting"
+  | "retry-scheduled"
+  | "completed"
+  | "failed"
+  | "cancelled"
+  | "skipped"
+  | "timed-out";
+
+export type AgentWorkflowNodeType =
+  | "model"
+  | "tool"
+  | "subagent"
+  | "condition"
+  | "parallel"
+  | "join"
+  | "approval"
+  | "job"
+  | "wait"
+  | "artifact"
+  | "final";
+
+export interface AgentWorkflowRunSummary {
+  readonly runId: string;
+  readonly workflowKey: string;
+  readonly workflowLabel: string;
+  readonly workflowVersion: string;
+  readonly releaseId: string;
+  readonly releaseDigest: string;
+  readonly status: AgentWorkflowRunStatus;
+  readonly currentNodeCount: number;
+  readonly totalNodeCount: number;
+  readonly createdAt: string;
+  readonly updatedAt: string;
+  readonly finishedAt?: string;
+  readonly safeErrorCode?: string;
+}
+
+export interface AgentWorkflowBudgetProjection {
+  readonly maxDurationSeconds: number;
+  readonly maxModelAttempts: number;
+  readonly maxToolCalls: number;
+  readonly maxSubagents: number;
+  readonly maxParallelism: number;
+  readonly maxInputTokens: number;
+  readonly maxOutputTokens: number;
+  readonly maxCostMicros: number;
+}
+
+export type AgentWorkflowMeasuredCount =
+  | {
+      readonly status: "measured";
+      readonly value: number;
+      readonly source: "provider-reported" | "host-measured";
+    }
+  | { readonly status: "unknown"; readonly reasonCode: string };
+
+export type AgentWorkflowMeasuredCost =
+  | {
+      readonly status: "measured";
+      readonly amountMicros: number;
+      readonly currency: string;
+      readonly source: "provider-reported" | "catalog-estimated";
+    }
+  | { readonly status: "unknown"; readonly reasonCode: string };
+
+export interface AgentWorkflowUsageProjection {
+  readonly durationMs: number;
+  readonly modelAttempts: number;
+  readonly toolCalls: number;
+  readonly subagents: number;
+  readonly inputTokens: AgentWorkflowMeasuredCount;
+  readonly outputTokens: AgentWorkflowMeasuredCount;
+  readonly cost: AgentWorkflowMeasuredCost;
+}
+
+export interface AgentWorkflowArtifactProjection {
+  readonly artifactId: string;
+  readonly kind: string;
+  readonly mediaType: string;
+  readonly byteSize: number;
+  readonly sha256: string;
+  readonly retentionPolicyKey: string;
+  readonly source: {
+    readonly moduleKey: string;
+    readonly kind: string;
+    readonly id: string;
+    readonly version: string;
+    readonly sequence: number;
+    readonly digest?: string;
+  };
+}
+
+export interface AgentWorkflowNodeProjection {
+  readonly nodeRunId: string;
+  readonly nodeId: string;
+  readonly label: string;
+  readonly type: AgentWorkflowNodeType;
+  readonly status: AgentWorkflowNodeRunStatus;
+  readonly attempt: number;
+  readonly maxAttempts: number;
+  readonly startedAt?: string;
+  readonly finishedAt?: string;
+  readonly safeErrorCode?: string;
+  readonly resultReceipt?: {
+    readonly receiptId: string;
+    readonly resultDigest: string;
+    readonly selectedBranch?: string;
+    readonly artifactIds: readonly string[];
+    readonly recordedAt: string;
+  };
+  readonly inputArtifacts: readonly AgentWorkflowArtifactProjection[];
+  readonly outputArtifacts: readonly AgentWorkflowArtifactProjection[];
+}
+
+export interface AgentWorkflowEdgeProjection {
+  readonly from: string;
+  readonly to: string;
+  readonly branch?: string;
+}
+
+export interface AgentWorkflowRunDetailResponse {
+  readonly run: AgentWorkflowRunSummary & {
+    readonly actorId: string;
+    readonly scopeDigest: string;
+    readonly authorizationSnapshotDigest: string;
+    readonly toolPolicyDigest: string;
+    readonly workspacePolicyDigest: string;
+    readonly executionPolicyDigest: string;
+    readonly budget: AgentWorkflowBudgetProjection;
+    readonly usage: AgentWorkflowUsageProjection;
+    readonly deadlineAt: string;
+  };
+  readonly release: {
+    readonly releaseId: string;
+    readonly releaseDigest: string;
+    readonly runtimeVersion: string;
+    readonly routeVersion: string;
+    readonly promptVersion: string;
+    readonly toolSchemaVersion: string;
+    readonly manifestDigest: string;
+  };
+  readonly nodes: readonly AgentWorkflowNodeProjection[];
+  readonly edges: readonly AgentWorkflowEdgeProjection[];
+}
+
+export interface AgentWorkflowRunListResponse {
+  readonly items: readonly AgentWorkflowRunSummary[];
+}
+
+export function listAgentWorkflowRuns(signal?: AbortSignal) {
+  return apiRequest<AgentWorkflowRunListResponse>(
+    "/agent/workflows/runs",
+    requestOptions(signal),
+  );
+}
+
+export function getAgentWorkflowRun(runId: string, signal?: AbortSignal) {
+  return apiRequest<AgentWorkflowRunDetailResponse>(
+    `/agent/workflows/runs/${encodeURIComponent(runId)}`,
+    requestOptions(signal),
+  );
+}
+
+function requestOptions(signal?: AbortSignal): { signal?: AbortSignal } {
+  return signal ? { signal } : {};
+}

package/template/apps/web/src/services/ai-runtime-api.ts

@@ -23,6 +23,7 @@ export type AiRuntimeModelDeployment = AiRuntimeRunModelDeployment;
 
 export interface AiRuntimeRunItem {
   readonly runId: string;
+  readonly engineId: string;
   readonly operationKey: string;
   readonly actor: AiRuntimeActor | null;
   readonly status: string;
@@ -59,6 +60,7 @@ export interface AiRuntimeAttempt {
 export interface AiRuntimeRunDetail extends AiRuntimeRunItem {
   readonly releaseId?: string;
   readonly attemptItems: readonly AiRuntimeAttempt[];
+  readonly trajectory: RuntimeRunDetail["trajectory"];
 }
 
 export type AiRuntimeActor = AiRuntimeActorSummary;
@@ -114,6 +116,7 @@ function reportParams(query: AiRuntimeReportQuery) {
 function runItem(value: AiRuntimeRunListItem): AiRuntimeRunItem {
   return {
     runId: value.runId,
+    engineId: value.engineId,
     operationKey: value.operationKey,
     actor: value.actor,
     status: value.status,
@@ -134,6 +137,7 @@ function runDetail(value: RuntimeRunDetail): AiRuntimeRunDetail {
     traceId: value.traceId,
     ...(value.safeErrorCode ? { safeErrorCode: value.safeErrorCode } : {}),
     attemptItems: value.attempts.map(attemptItem),
+    trajectory: value.trajectory,
   };
 }