feat: expand intelligent investigation workspace

src/features/agent/api/answer-view-state.test.ts

@@ -0,0 +1,51 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createAgentApiClient } from "./client";
+import type { AnswerViewStateWrite } from "./answer-view-state";
+
+const remote = { version: "answer-view-state@1", message_id: "message", block_id: "block", revision: 2,
+  schema_digest: "digest", nodes: {}, block: { evidenceFilter: "all" }, updated_at: null };
+const write: AnswerViewStateWrite = { message_id: "message", block_id: "block", expected_revision: 2, schema_digest: "digest", request_id: "intent", nodes: {}, block: { evidenceFilter: "all" } };
+const token = (subject: string) => `header.${btoa(JSON.stringify({ iss: "https://identity.local", sub: subject }))}.signature`;
+afterEach(() => vi.unstubAllGlobals());
+describe("authorized answer view state API", () => {
+  it("keeps the message and block identity and uses the configured auth/project context", async () => {
+    const fetcher = vi.fn().mockImplementation(async () => Response.json(remote)); vi.stubGlobal("fetch", fetcher);
+    const api = createAgentApiClient("https://agent.local", { getAccessToken: async () => token("alice"), getProjectId: async () => "project" });
+    await expect(api.getAnswerViewState("session/one", "message", "block")).resolves.toEqual(remote);
+    await api.putAnswerViewState("session/one", write);
+    expect(fetcher.mock.calls[0][0]).toBe("https://agent.local/api/v1/session/session%2Fone/ui-state?message_id=message&block_id=block");
+    expect(fetcher.mock.calls[1][0]).toBe("https://agent.local/api/v1/session/session%2Fone/ui-state");
+    expect(fetcher.mock.calls[1][1].body).toBe(JSON.stringify(write));
+    for (const [, init] of fetcher.mock.calls) {
+      expect(new Headers(init.headers).get("Authorization")).toBe(`Bearer ${token("alice")}`);
+      expect(new Headers(init.headers).get("X-Project-Id")).toBe("project");
+    }
+  });
+  it("retains structured conflict details for the explicit user choices", async () => {
+    vi.stubGlobal("fetch", vi.fn(async () => Response.json({ code: "ANSWER_VIEW_STATE_CONFLICT", detail: "new revision", current: remote }, { status: 409 })));
+    await expect(createAgentApiClient("https://agent.local").putAnswerViewState("session", write)).rejects.toMatchObject({
+      status: 409, code: "ANSWER_VIEW_STATE_CONFLICT", current: remote,
+    });
+  });
+  it("rejects writes if a mutable token provider changes subject in the same project", async () => {
+    const fetcher = vi.fn(async () => Response.json(remote)); vi.stubGlobal("fetch", fetcher);
+    let subject = "alice";
+    const api = createAgentApiClient("https://agent.local", { getAccessToken: async () => token(subject), getProjectId: async () => "same-project" });
+    await api.getAnswerViewState("session", "message", "block"); subject = "bob";
+    await expect(api.putAnswerViewState("session", write)).rejects.toMatchObject({ code: "ANSWER_VIEW_IDENTITY_CHANGED" });
+    expect(fetcher).toHaveBeenCalledTimes(1);
+  });
+  it("rejects a late read if identity changes while the request is in flight", async () => {
+    let finish!: (response: Response) => void;
+    const fetcher = vi.fn(() => new Promise<Response>((resolve) => { finish = resolve; })); vi.stubGlobal("fetch", fetcher);
+    let subject = "alice";
+    const api = createAgentApiClient("https://agent.local", { getAccessToken: async () => token(subject) });
+    const read = api.getAnswerViewState("session", "message", "block");
+    await vi.waitFor(() => expect(fetcher).toHaveBeenCalledTimes(1)); subject = "bob"; finish(Response.json(remote));
+    await expect(read).rejects.toMatchObject({ code: "ANSWER_VIEW_IDENTITY_CHANGED" });
+  });
+  it("rejects remote state containing unknown executable fields", async () => {
+    vi.stubGlobal("fetch", vi.fn(async () => Response.json({ ...remote, nodes: { x: { type: "Evidence", open: true, script: "bad" } } })));
+    await expect(createAgentApiClient("https://agent.local").getAnswerViewState("session", "message", "block")).rejects.toThrow();
+  });
+});

src/features/agent/api/answer-view-state.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import type { AnswerViewState } from "../answer-ui/answer-view-state";
+
+const index = z.number().int().nonnegative();
+const chartTable = z.object({ query: z.string(), sort: z.object({ column: index, descending: z.boolean() }).strict().nullable(), selection: z.array(index) }).strict();
+const node = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("Chart"), view: z.enum(["line", "bar", "table"]), hidden: z.array(index), range: z.tuple([index, index]), point: index, inspecting: z.boolean(), table: chartTable.optional() }).strict(),
+  z.object({ type: z.literal("Table"), query: z.string(), sort: z.object({ column: index, descending: z.boolean() }).strict().nullable(), selection: z.array(index) }).strict(),
+  z.object({ type: z.literal("FollowUpForm"), values: z.record(z.string()) }).strict(),
+  z.object({ type: z.literal("Evidence"), open: z.boolean() }).strict(),
+]);
+const record = z.object({
+  version: z.literal("answer-view-state@1"), message_id: z.string(), block_id: z.string(),
+  revision: index, schema_digest: z.string().min(1), nodes: z.record(node),
+  block: z.object({ evidenceFilter: z.string() }).strict(), updated_at: z.string().nullable(),
+}).strict();
+
+export type AnswerViewStateRecord = AnswerViewState & {
+  version: "answer-view-state@1"; message_id: string; block_id: string;
+  revision: number; schema_digest: string; updated_at: string | null;
+};
+export type AnswerViewStateWrite = AnswerViewState & {
+  message_id: string; block_id: string; schema_digest: string;
+  expected_revision: number; request_id: string;
+};
+export class AnswerViewStateApiError extends Error {
+  constructor(message: string, readonly status: number, readonly code?: string, readonly current?: AnswerViewStateRecord) {
+    super(message);
+    this.name = "AnswerViewStateApiError";
+  }
+}
+export function parseAnswerViewStateRecord(value: unknown): AnswerViewStateRecord {
+  return record.parse(value) as AnswerViewStateRecord;
+}
+export async function readAnswerViewStateResponse(response: Response): Promise<AnswerViewStateRecord> {
+  const data: unknown = await response.json();
+  if (!response.ok) {
+    const error = z.object({ code: z.string().optional(), detail: z.string().optional(), current: z.unknown().optional() }).passthrough().safeParse(data);
+    const current = error.success && error.data.current ? record.safeParse(error.data.current) : null;
+    throw new AnswerViewStateApiError(error.success ? error.data.detail ?? "交互状态未保存，请重试" : "交互状态暂不可用，请重试", response.status,
+      error.success ? error.data.code : undefined, current?.success ? current.data as AnswerViewStateRecord : undefined);
+  }
+  return parseAnswerViewStateRecord(data);
+}

src/features/agent/api/client.test.ts

@@ -1,7 +1,32 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { createAgentApiClient } from "./client";
+import { AgentResponseFinishedError, createAgentApiClient } from "./client";
 
 describe("Agent prompt suggestions", () => {
+  it("probes public readiness without loading identity or project credentials", async () => {
+    const getAccessToken = vi.fn(async () => "private-token");
+    const getProjectId = vi.fn(async () => "project");
+    const fetcher = vi.fn().mockResolvedValueOnce(Response.json({ ok: true, ready: true }))
+      .mockResolvedValueOnce(Response.json({ ok: true, ready: false }));
+    vi.stubGlobal("fetch", fetcher);
+    const client = createAgentApiClient("https://agent.local/prefix", { getAccessToken, getProjectId });
+    const signal = new AbortController().signal;
+    await expect(client.getHealth(signal)).resolves.toBeUndefined();
+    expect(fetcher).toHaveBeenCalledWith("https://agent.local/prefix/health", { signal, cache: "no-store" });
+    expect(getAccessToken).not.toHaveBeenCalled();
+    expect(getProjectId).not.toHaveBeenCalled();
+    await expect(client.getHealth(signal)).rejects.toThrow("尚未就绪");
+  });
+  it("distinguishes a proven pre-admission idle response from ambiguous input conflicts", async () => {
+    const fetchMock = vi.fn()
+      .mockResolvedValueOnce(Response.json({ code: "RESPONSE_FINISHED", message: "finished" }, { status: 409 }))
+      .mockResolvedValueOnce(Response.json({ message: "unknown conflict" }, { status: 409 }));
+    vi.stubGlobal("fetch", fetchMock);
+    const client = createAgentApiClient("http://agent.local");
+    await expect(client.submitResponseInput("s", "next", "queue", `msg_${"1".repeat(32)}`)).rejects.toBeInstanceOf(AgentResponseFinishedError);
+    const uncertain = client.submitResponseInput("s", "next", "queue", `msg_${"2".repeat(32)}`);
+    await expect(uncertain).rejects.not.toBeInstanceOf(AgentResponseFinishedError);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
   it("uses owned topic endpoints and retains full-text hits from another topic", async () => {
     const topic = { id: "topic-a", name: "城南压力问题", createdAt: "2026-10-22T01:00:00Z", updatedAt: "2026-10-22T01:00:00Z" };
     const fetchMock = vi.fn()

src/features/agent/api/client.ts

@@ -2,6 +2,7 @@ import { createInteractionRequestApi, type InteractionRequestApi } from "./inter
 import { env } from "@/shared/config/env";
 import type { AccessTokenProvider } from "@/shared/auth/keycloak-auth";
 import { agentMessagePageSchema, type AgentMessagePage } from "./agent-messages";
+import { AnswerViewStateApiError, readAnswerViewStateResponse, type AnswerViewStateRecord, type AnswerViewStateWrite } from "./answer-view-state";
 
 export type AgentRunStatus = "running" | "completed" | "error" | "aborted" | "waiting_input";
 export type AgentSessionPurpose = "ordinary_chat" | "task_execution" | "task_collaboration";
@@ -20,8 +21,8 @@ export type AgentEventTriggerContext = {
     summary: string;
     location?: string | null;
     priority: "low" | "normal" | "high" | "urgent";
-    scenario_code: "WQ-SECONDARY-SUPPLY-001";
-    origin: "synthetic";
+    scenario_code?: string | null;
+    origin: "system_data";
   };
 };
 
@@ -156,6 +157,8 @@ export type AgentSessionStreamEvent =
 
 export type AgentApiClient = InteractionRequestApi & {
   getHealth: (signal: AbortSignal) => Promise<void>;
+  getAnswerViewState: (sessionId: string, messageId: string, blockId: string) => Promise<AnswerViewStateRecord>;
+  putAnswerViewState: (sessionId: string, state: AnswerViewStateWrite) => Promise<AnswerViewStateRecord>;
   downloadFile: (path: string) => Promise<void>;
   submitResponseInput: (sessionId: string, text: string, delivery: AgentInputDelivery, id: string) => Promise<AgentResponseInput>;
   listResponseInputs: (sessionId: string) => Promise<AgentResponseInput[]>;
@@ -249,14 +252,41 @@ export function createAgentApiClient(
 
     return data as T;
   };
+  let answerStateActor: string | undefined;
+  const checkedAnswerStateToken = options.getAccessToken ? async () => {
+    const token = await options.getAccessToken!();
+    const actor = answerStateTokenActor(token);
+    if (answerStateActor !== undefined && actor !== answerStateActor) {
+      throw new AnswerViewStateApiError("登录身份已变化，请刷新后继续。", 403, "ANSWER_VIEW_IDENTITY_CHANGED");
+    }
+    answerStateActor = actor;
+    return token;
+  } : undefined;
+  const answerStateRequest = async (path: string, init?: RequestInit) => {
+    const response = await fetchWithFallback(candidates, activeBaseUrl, setActiveBaseUrl, path, init,
+      checkedAnswerStateToken, options.getProjectId);
+    // An identity change while awaiting the network also invalidates the result.
+    await checkedAnswerStateToken?.();
+    return response;
+  };
+
   return {
-    ...createInteractionRequestApi(request),
+    ...createInteractionRequestApi(answerStateRequest),
     async getHealth(signal) {
       const response = await fetchWithFallback(candidates, activeBaseUrl, setActiveBaseUrl, "/health", { signal, cache: "no-store" }, undefined, undefined, "");
       if (!response.ok) throw new Error("Agent 服务暂不可用");
       const data: unknown = await response.json();
       if (!isRecord(data) || data.ok !== true || data.ready !== true) throw new Error("Agent 服务尚未就绪");
     },
+    async getAnswerViewState(sessionId, messageId, blockId) {
+      const query = new URLSearchParams({ message_id: messageId, block_id: blockId });
+      return readAnswerViewStateResponse(await answerStateRequest(`/session/${encodeURIComponent(sessionId)}/ui-state?${query}`));
+    },
+    async putAnswerViewState(sessionId, state) {
+      return readAnswerViewStateResponse(await answerStateRequest(`/session/${encodeURIComponent(sessionId)}/ui-state`, {
+        method: "PUT", headers: { "Content-Type": "application/json" }, body: JSON.stringify(state)
+      }));
+    },
     async downloadFile(path) {
       const match = /^\/api\/v1(\/session\/[^/?#]+\/files\/mcp-[a-f0-9-]{36}\.(?:zip|xlsx))$/.exec(path);
       if (!match) throw new Error("无效的会话文件地址");
@@ -845,3 +875,12 @@ function readMessagePagination(value: unknown): AgentMessagePagination | undefin
   if (!isRecord(value)) return undefined;
   return { hasMore: value.has_more === true, beforeCursor: typeof value.before_cursor === "string" ? value.before_cursor : null };
 }
+
+function answerStateTokenActor(token: string | null): string {
+  if (!token) return "development-context";
+  try {
+    const payload: unknown = JSON.parse(atob(token.split(".")[1].replaceAll("-", "+").replaceAll("_", "/")));
+    if (isRecord(payload) && typeof payload.sub === "string") return JSON.stringify([payload.iss, payload.sub]);
+  } catch { /* Non-JWT development credentials use the enclosing workbench owner. */ }
+  return "development-context";
+}

src/features/agent/api/responses-transport.test.ts

@@ -55,3 +55,11 @@ describe("Responses transport", () => {
     expect((await collect(responsesToUiStream(bytes(failed)))).at(-2)).toEqual({ type: "error", errorText: "数据源不可用" });
   });
 });
+
+it("binds a saved interaction continuation to the owning conversation", () => {
+  const request = createResponseRequest([{ id: "continuation", role: "user", parts: [{ type: "text", text: "继续处理已保存回答" }] }], {
+    conversation: "original-session", interactionId: "saved-interaction", capabilities: ["host-question@1"],
+  });
+  expect(request.conversation).toBe("original-session");
+  expect(request.tjwater).toMatchObject({ interaction_id: "saved-interaction", capabilities: ["host-question@1"] });
+});