feat(console): add optional Agent workflow demo

apps/console/src/api/__tests__/agent.spec.ts

@@ -0,0 +1,64 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { apiGet, apiPost, apiPut } from "@/utils/request";
+import { agentApi } from "@/api/agent";
+
+vi.mock("@/utils/request", () => ({
+  apiGet: vi.fn(),
+  apiPost: vi.fn(),
+  apiPut: vi.fn(),
+}));
+
+describe("agentApi", () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it("uses the authenticated Agent workflow endpoints and explicit confirmation payload", async () => {
+    const thread = { threadId: "thread-1" };
+    vi.mocked(apiPost).mockResolvedValue(thread);
+    vi.mocked(apiPut).mockResolvedValue(thread);
+    vi.mocked(apiGet).mockResolvedValue(thread);
+
+    await agentApi.createThread("submission-1", "review this");
+    expect(apiPost).toHaveBeenCalledWith("/agent/threads", {
+      sourceSubmissionId: "submission-1",
+      question: "review this",
+    });
+    await agentApi.confirm("thread-1", {
+      draftVersion: 2,
+      title: "Title",
+      content: "Content",
+      facts: [],
+      hypotheses: [],
+      citations: [],
+      citationChecks: [],
+      sampleScope: null,
+    }, "digest");
+    expect(apiPost).toHaveBeenLastCalledWith("/agent/threads/thread-1/confirm", {
+      draftVersion: 2,
+      paramsDigest: "digest",
+      confirm: true,
+    });
+    await agentApi.save("thread-1", "confirmation-1");
+    expect(apiPost).toHaveBeenLastCalledWith("/agent/threads/thread-1/save", {
+      confirmationId: "confirmation-1",
+    });
+    await agentApi.recover("thread-1");
+    expect(apiPost).toHaveBeenLastCalledWith("/agent/threads/thread-1/recover", { retry: false });
+    await agentApi.cancel("thread-1");
+    expect(apiPost).toHaveBeenLastCalledWith("/agent/threads/thread-1/cancel", {});
+    await agentApi.updateDraft("thread-1", { draftVersion: 2, title: "Title", content: "Content" });
+    expect(apiPut).toHaveBeenCalledWith("/agent/threads/thread-1/draft", {
+      draftVersion: 2,
+      title: "Title",
+      content: "Content",
+    });
+  });
+
+  it("encodes thread IDs for reads and event streams", async () => {
+    vi.mocked(apiGet).mockResolvedValue({});
+    await agentApi.getThread("thread/with space");
+    expect(apiGet).toHaveBeenCalledWith("/agent/threads/thread%2Fwith%20space");
+    expect(agentApi.eventStreamUrl("thread/with space")).toBe(
+      "/api/agent/threads/thread%2Fwith%20space/events/stream?after=0",
+    );
+  });
+});

apps/console/src/api/agent.ts

@@ -0,0 +1,109 @@
+import { apiGet, apiPost, apiPut } from "@/utils/request";
+
+export type AgentThreadStatus =
+  | "awaiting_confirmation"
+  | "analyzing"
+  | "confirmed"
+  | "saving"
+  | "saved"
+  | "unknown"
+  | "failed"
+  | "cancelled";
+
+export interface AgentCitation {
+  claim: string;
+  chunk_id: string;
+  doc_id: string;
+  version: string;
+  source_path: string;
+  source_position: string;
+  access_scope: string;
+  sample_kind: string;
+  source_trust: string;
+  text: string;
+}
+
+export interface AgentWorkflowEvent {
+  seq: number;
+  kind: string;
+  detail: Record<string, unknown>;
+  createdAt: number;
+}
+
+export interface AgentThread {
+  threadId: string;
+  runId: string;
+  status: AgentThreadStatus;
+  sourceSubmissionId: string;
+  question: string;
+  draft: {
+    draftVersion: number;
+    title: string;
+    content: string;
+    facts: unknown[];
+    hypotheses: unknown[];
+    citations: AgentCitation[];
+    citationChecks: Array<Record<string, unknown>>;
+    sampleScope: string | null;
+    model_answer?: string;
+  };
+  paramsDigest: string;
+  analysis: {
+    answer?: string;
+    trace?: Array<{ tool_name?: string; failed?: boolean }>;
+    citation_checks?: Array<Record<string, unknown>>;
+  } | null;
+  confirmation: {
+    id?: string;
+    action?: string;
+    draftVersion?: number;
+    paramsDigest?: string;
+    expiresAt?: number;
+  } | null;
+  receipt: {
+    planId: string | null;
+    cancelRequested: boolean;
+    failureReason: string | null;
+  };
+}
+
+const threadPath = (threadId: string) =>
+  `/agent/threads/${encodeURIComponent(threadId)}`;
+
+export const agentApi = {
+  createThread(sourceSubmissionId: string, question: string) {
+    return apiPost<AgentThread>("/agent/threads", { sourceSubmissionId, question });
+  },
+  getThread(threadId: string) {
+    return apiGet<AgentThread>(threadPath(threadId));
+  },
+  analyze(threadId: string) {
+    return apiPost<AgentThread>(`${threadPath(threadId)}/analyze`, {});
+  },
+  updateDraft(
+    threadId: string,
+    draft: { draftVersion: number; title: string; content: string },
+  ) {
+    return apiPut<AgentThread>(`${threadPath(threadId)}/draft`, draft);
+  },
+  confirm(threadId: string, draft: AgentThread["draft"], paramsDigest: string) {
+    return apiPost<AgentThread>(`${threadPath(threadId)}/confirm`, {
+      draftVersion: draft.draftVersion,
+      paramsDigest,
+      confirm: true,
+    });
+  },
+  save(threadId: string, confirmationId: string) {
+    return apiPost<AgentThread>(`${threadPath(threadId)}/save`, { confirmationId });
+  },
+  recover(threadId: string) {
+    return apiPost<AgentThread>(`${threadPath(threadId)}/recover`, { retry: false });
+  },
+  cancel(threadId: string) {
+    return apiPost<AgentThread>(`${threadPath(threadId)}/cancel`, {});
+  },
+  eventStreamUrl(threadId: string) {
+    const base = (import.meta.env.VITE_API_BASE_URL || "/api").replace(/\/$/, "");
+    return `${base}${threadPath(threadId)}/events/stream?after=0`;
+  },
+};