refactor: consolidate chat state and task bridges
Centralize session scope, chat projections and typed task bridges. Keep historical interaction replies authoritative and publish terminal state to subscribers. Validate Server contracts before replacing generated artifacts.
This commit is contained in:
@@ -0,0 +1,47 @@
|
||||
import { expect, it } from "bun:test";
|
||||
import type { UIMessageChunk } from "ai";
|
||||
import { createChatRunAccumulator, publishRunEvent } from "../../src/routes/chat-run-accumulator.js";
|
||||
import { createInitialStreamingMessages, type ActiveRun } from "../../src/routes/chatUiState.js";
|
||||
|
||||
it.each([false, true])("projects one event stream into reconnect and persisted messages (collaboration=%s)", (collaboration) => {
|
||||
const run: ActiveRun = {
|
||||
clientSessionId: "s", controller: new AbortController(), status: "running",
|
||||
messages: createInitialStreamingMessages([], "查询"), pendingPermissions: new Map(), pendingQuestions: new Map(), subscribers: new Set(),
|
||||
};
|
||||
const chunks: UIMessageChunk[] = [];
|
||||
const stream = createChatRunAccumulator({ run, messages: [{ id: "user", role: "user", parts: [{ type: "text", text: "查询" }] }],
|
||||
messageId: "answer", sessionId: "s", collaboration, write: (chunk) => chunks.push(chunk), onStatus() {} });
|
||||
stream.apply("progress", { id: "query", status: "running", title: "查询资料" });
|
||||
stream.apply("token", { content: "已有数据" });
|
||||
stream.apply("permission_request", { request_id: "permission", session_id: "s", permission: "shell", patterns: [], always: [], created_at: 1 });
|
||||
stream.apply("permission_response", { request_id: "permission", reply: "once" });
|
||||
stream.appendInput({ id: "extra", role: "user", parts: [{ type: "text", text: "补充" }] }, "补充");
|
||||
stream.appendInput({ id: "extra", role: "user", parts: [] }, "重复");
|
||||
stream.apply("final_answer", { content: "结论" });
|
||||
stream.apply("done", {});
|
||||
expect(run.status).toBe("completed");
|
||||
expect(run.pendingPermissions.size).toBe(0);
|
||||
expect(run.messages.at(-1)).toMatchObject({ id: "answer", content: "结论", permissions: [{ status: "approved_once" }], progress: [{ status: "completed" }, { status: "completed" }] });
|
||||
const saved = stream.uiMessages();
|
||||
expect(saved.map((message) => message.id)).toEqual(["user", "extra", "answer"]);
|
||||
expect(saved.at(-1)?.parts).toEqual((run.messages.at(-1) as { parts: typeof saved[number]["parts"] }).parts);
|
||||
expect(saved.at(-1)?.parts.some((part) => part.type === "data-progress")).toBe(!collaboration);
|
||||
expect(chunks.filter((chunk) => chunk.type === "finish")).toHaveLength(1);
|
||||
});
|
||||
|
||||
it.each(["done", "error", "aborted"])("publishes the same %s terminal state to reconnect subscribers and storage", (event) => {
|
||||
const run: ActiveRun = {
|
||||
clientSessionId: "s", controller: new AbortController(), status: "running",
|
||||
messages: createInitialStreamingMessages([], "查询"), pendingPermissions: new Map(), pendingQuestions: new Map(), subscribers: new Set(),
|
||||
};
|
||||
const received: Array<{ event: string; data: Record<string, unknown> }> = [];
|
||||
run.subscribers.add({ write: (event, data) => received.push({ event, data }), close() {} });
|
||||
const stream = createChatRunAccumulator({ run, messages: [], messageId: "answer", sessionId: "s",
|
||||
collaboration: false, write() {}, onStatus() {} });
|
||||
publishRunEvent(run, "progress", { id: "tool", title: "正在处理", status: "running", phase: "tool" });
|
||||
publishRunEvent(run, "token", { content: "部分结果" });
|
||||
publishRunEvent(run, event, { session_id: "s", message: "执行已停止" });
|
||||
const canonical = stream.uiMessages().at(-1)?.parts.find((part) => part.type === "data-run_status");
|
||||
expect(received.at(-2)).toMatchObject({ event: "run_status", data: { status: event === "done" ? "completed" : event } });
|
||||
expect(canonical).toMatchObject({ data: { status: received.at(-2)?.data.status } });
|
||||
});
|
||||
@@ -0,0 +1,58 @@
|
||||
import { createChatRunAccumulator } from "../../src/routes/chat-run-accumulator.js";
|
||||
import { expect, it } from "bun:test";
|
||||
import express from "express";
|
||||
import { mkdtemp, rm } from "node:fs/promises";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
import { getLocalAgentContext } from "../../src/context/localContext.js";
|
||||
import { registerChatInteractionRoutes } from "../../src/routes/chatInteractionRoutes.js";
|
||||
import type { ActiveRun } from "../../src/routes/chatUiState.js";
|
||||
import type { OpencodeRuntimeAdapter } from "../../src/runtime/opencode.js";
|
||||
import { SessionMetadataStore } from "../../src/sessions/metadataStore.js";
|
||||
import { SessionUiStateStore } from "../../src/sessions/uiStateStore.js";
|
||||
import { SessionWorkspaceStore } from "../../src/sessions/workspace-store.js";
|
||||
|
||||
it.each([false, true])("persists permission replies in the owner's workspace (native failure=%s)", async (nativeFailure) => {
|
||||
const root = await mkdtemp(join(tmpdir(), "permission-persistence-"));
|
||||
const workspaces = new SessionWorkspaceStore(join(root, "workspaces"));
|
||||
const sessions = new SessionMetadataStore(join(root, "metadata"), workspaces);
|
||||
const states = new SessionUiStateStore(join(root, "unused"), workspaces);
|
||||
const context = { ...getLocalAgentContext(), sessionId: "permission-session" };
|
||||
await sessions.ensure(context);
|
||||
const messages = [{ id: "answer", role: "assistant", permissions: [] }];
|
||||
await states.write(context, { sessionId: context.sessionId, isTitleManuallyEdited: true, messages });
|
||||
let calls = 0;
|
||||
const runtime = { replyPermission: async () => { calls++; if (nativeFailure) throw new Error("native unavailable"); } } as unknown as OpencodeRuntimeAdapter;
|
||||
const run: ActiveRun = {
|
||||
clientSessionId: context.sessionId, controller: new AbortController(), messages,
|
||||
pendingPermissions: new Map([["permission", { request_id: "permission", session_id: context.sessionId, permission: "shell", patterns: [], always: [], created_at: Date.now() }]]),
|
||||
pendingQuestions: new Map(), subscribers: new Set(), status: "running",
|
||||
};
|
||||
const accumulator = createChatRunAccumulator({ run, messages: [], messageId: "answer", sessionId: context.sessionId,
|
||||
collaboration: false, write() {}, onStatus() {} });
|
||||
accumulator.apply("permission_request", run.pendingPermissions.get("permission")! as unknown as Record<string, unknown>);
|
||||
await states.write(context, { sessionId: context.sessionId, isTitleManuallyEdited: true, messages: run.messages });
|
||||
const app = express(); app.use(express.json());
|
||||
registerChatInteractionRoutes(app, { activeRuns: new Map([[context.sessionId, run]]), runtime, sessionMetadataStore: sessions, sessionUiStateStore: states });
|
||||
const server = app.listen(0, "127.0.0.1");
|
||||
await new Promise<void>((resolve) => server.once("listening", resolve));
|
||||
const url = `http://127.0.0.1:${(server.address() as { port: number }).port}/permission/permission/reply`;
|
||||
const reply = (headers = {}) => fetch(url, { method: "POST", headers: { "Content-Type": "application/json", ...headers }, body: JSON.stringify({ session_id: context.sessionId, reply: "once" }) });
|
||||
try {
|
||||
expect((await reply({ "X-Agent-Local-User": "other" })).status).toBe(404);
|
||||
expect(calls).toBe(0);
|
||||
expect((await reply()).status).toBe(nativeFailure ? 502 : 202);
|
||||
expect(calls).toBe(1);
|
||||
expect(run.pendingPermissions.has("permission")).toBe(nativeFailure);
|
||||
const saved = await states.read(context);
|
||||
expect(saved?.isTitleManuallyEdited).toBe(true);
|
||||
const parts = (saved?.messages[0] as { parts: Array<{ type: string; data: Record<string, unknown> }> }).parts;
|
||||
expect(parts.find((part) => part.type === "data-permission_response")?.data).toMatchObject(nativeFailure
|
||||
? { request_id: "permission", status: "error", error: "native unavailable" }
|
||||
: { request_id: "permission", reply: "once" });
|
||||
expect(run.messages[0]).toMatchObject({ permissions: [{ requestId: "permission", status: nativeFailure ? "error" : "approved_once" }] });
|
||||
} finally {
|
||||
await new Promise<void>((resolve) => server.close(() => resolve()));
|
||||
await rm(root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,71 @@
|
||||
import { expect, it } from "bun:test";
|
||||
import express from "express";
|
||||
import { mkdtemp, rm } from "node:fs/promises";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
import type { UIMessage } from "ai";
|
||||
import { getLocalAgentContext } from "../../src/context/localContext.js";
|
||||
import { createChatRunAccumulator } from "../../src/routes/chat-run-accumulator.js";
|
||||
import { registerChatInteractionRoutes } from "../../src/routes/chatInteractionRoutes.js";
|
||||
import { createInitialStreamingMessages, type ActiveRun } from "../../src/routes/chatUiState.js";
|
||||
import type { OpencodeRuntimeAdapter } from "../../src/runtime/opencode.js";
|
||||
import { SessionMetadataStore } from "../../src/sessions/metadataStore.js";
|
||||
import { SessionUiStateStore } from "../../src/sessions/uiStateStore.js";
|
||||
import { SessionWorkspaceStore } from "../../src/sessions/workspace-store.js";
|
||||
|
||||
it("keeps historical question invalidation across the next live snapshot", async () => {
|
||||
const root = await mkdtemp(join(tmpdir(), "question-persistence-"));
|
||||
const workspaces = new SessionWorkspaceStore(join(root, "workspaces"));
|
||||
const sessions = new SessionMetadataStore(join(root, "metadata"), workspaces);
|
||||
const states = new SessionUiStateStore(join(root, "unused"), workspaces);
|
||||
const context = { ...getLocalAgentContext(), sessionId: "history-session" };
|
||||
await sessions.ensure(context);
|
||||
const history: UIMessage[] = [{ id: "old-answer", role: "assistant", parts: [
|
||||
{ type: "data-question_request", data: { request_id: "old-question", session_id: context.sessionId,
|
||||
questions: [{ question: "继续吗？", options: [] }] } },
|
||||
{ type: "data-final_answer", data: { content: "此前的结果" } },
|
||||
] }, { id: "user", role: "user", parts: [{ type: "text", text: "新一轮" }] }];
|
||||
const run: ActiveRun = {
|
||||
clientSessionId: context.sessionId, controller: new AbortController(), status: "running",
|
||||
messages: createInitialStreamingMessages(history, "新一轮"),
|
||||
pendingPermissions: new Map(), pendingQuestions: new Map(), subscribers: new Set(),
|
||||
};
|
||||
const stream = createChatRunAccumulator({ run, messages: history, messageId: "current-answer",
|
||||
sessionId: context.sessionId, collaboration: false, write() {}, onStatus() {} });
|
||||
stream.apply("token", { content: "正在核查" });
|
||||
await states.write(context, { sessionId: context.sessionId, isTitleManuallyEdited: true, messages: stream.uiMessages() });
|
||||
let nativeReads = 0;
|
||||
const runtime = { getQuestionStatus: async () => { nativeReads++; return "missing"; } } as unknown as OpencodeRuntimeAdapter;
|
||||
const app = express();
|
||||
registerChatInteractionRoutes(app, { activeRuns: new Map([[context.sessionId, run]]), runtime,
|
||||
sessionMetadataStore: sessions, sessionUiStateStore: states });
|
||||
const server = app.listen(0, "127.0.0.1");
|
||||
await new Promise<void>((resolve) => server.once("listening", resolve));
|
||||
const url = `http://127.0.0.1:${(server.address() as { port: number }).port}/session/${context.sessionId}/questions/old-question`;
|
||||
const resolved = (messages: unknown[]) => {
|
||||
const message = messages[0] as UIMessage;
|
||||
expect(message.id).toBe("old-answer");
|
||||
const part = message.parts.find((part) => part.type === "data-question_response");
|
||||
expect(part).toMatchObject({ type: "data-question_response", data: { request_id: "old-question", status: "invalidated" } });
|
||||
};
|
||||
try {
|
||||
expect((await fetch(url, { headers: { "X-Agent-Local-User": "other" } })).status).toBe(404);
|
||||
expect(nativeReads).toBe(0);
|
||||
const response = await fetch(url);
|
||||
expect(response.status).toBe(200);
|
||||
expect(await response.json()).toMatchObject({ status: "invalidated" });
|
||||
resolved((await states.read(context))!.messages);
|
||||
resolved(run.messages);
|
||||
resolved(stream.uiMessages());
|
||||
expect(stream.uiMessages().at(-1)?.parts.some((part) => part.type === "data-question_response")).toBe(false);
|
||||
stream.apply("token", { content: "，继续查询" });
|
||||
await states.write(context, { ...(await states.read(context))!, messages: stream.uiMessages() });
|
||||
resolved((await states.read(context))!.messages);
|
||||
expect((await states.read(context))?.isTitleManuallyEdited).toBe(true);
|
||||
await fetch(url);
|
||||
expect(nativeReads).toBe(1);
|
||||
} finally {
|
||||
await new Promise<void>((resolve) => server.close(() => resolve()));
|
||||
await rm(root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
@@ -296,6 +296,11 @@ it("marks an explicitly aborted response incomplete and preserves scoped history
|
||||
const text = await response.text();
|
||||
expect(text).toContain("event: response.incomplete");
|
||||
expect(text).not.toContain("event: response.completed");
|
||||
const context = { actorKey: toActorKey("product:owner"), projectKey: toProjectKey(`product:${project}`), sessionId: "owned" };
|
||||
const saved = (await states.read(context))!.messages as Array<{ parts: Array<{ type: string; data?: { status?: string } }> }>;
|
||||
expect(saved.at(-1)?.parts.find((part) => part.type === "data-run_status")?.data?.status).toBe("aborted");
|
||||
const loaded = await http(`${base}/api/v1/session/owned`, { headers: { Authorization: "Bearer owner", "X-Project-Id": project } });
|
||||
expect((await loaded.json()).messages).toEqual(saved);
|
||||
});
|
||||
|
||||
it("continues a paged conversation from the complete saved history and preserves client message IDs", async () => {
|
||||
@@ -316,3 +321,28 @@ it("continues a paged conversation from the complete saved history and preserves
|
||||
expect((await call({ input: "重复提交", conversation: "owned", tjwater: { client_message_id: "client-turn-a" } })).status).toBe(409);
|
||||
expect(prompted).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("uses the same canonical live messages for session reads and older pages", async () => {
|
||||
gate = new Promise<void>((resolve) => { release = resolve; });
|
||||
const context = { actorKey: toActorKey("product:owner"), projectKey: toProjectKey(`product:${project}`), sessionId: "owned" };
|
||||
const history = Array.from({ length: 5 }, (_, index) => ({ id: `old-${index}`, role: index % 2 ? "assistant" : "user",
|
||||
parts: [{ type: "text", text: `历史 ${index}` }] as unknown[] }));
|
||||
history[1].parts.push({ type: "data-question_request", data: { request_id: "old-question", session_id: "owned", questions: [] } });
|
||||
await states.write(context, { sessionId: "owned", messages: history });
|
||||
const response = await call({ input: "新一轮", conversation: "owned", stream: true, tjwater: { client_message_id: "live-user" } });
|
||||
const headers = { Authorization: "Bearer owner", "X-Project-Id": project };
|
||||
const live = await http(`${base}/api/v1/session/owned`, { headers });
|
||||
const snapshot = await live.json();
|
||||
expect(snapshot.is_streaming).toBe(true);
|
||||
expect(snapshot.messages).toHaveLength(7);
|
||||
expect(snapshot.messages.slice(0, 5)).toEqual(history);
|
||||
expect(snapshot.messages[5].id).toBe("live-user");
|
||||
const recent = await http(`${base}/api/v1/session/owned?message_limit=2`, { headers });
|
||||
const page = await recent.json();
|
||||
expect(page.messages).toEqual(snapshot.messages.slice(-2));
|
||||
const older = await http(`${base}/api/v1/session/owned/messages?limit=40&before=${encodeURIComponent(page.message_page.before_cursor)}`, { headers });
|
||||
expect(older.status).toBe(200);
|
||||
expect((await older.json()).messages).toEqual(history);
|
||||
release();
|
||||
await response.text();
|
||||
});
|
||||
|
||||
@@ -0,0 +1,39 @@
|
||||
import { expect, it } from "bun:test";
|
||||
import { createHash } from "node:crypto";
|
||||
import { copyFile, mkdir, mkdtemp, readFile, readdir, rm, symlink, writeFile } from "node:fs/promises";
|
||||
import { join } from "node:path";
|
||||
import { tmpdir } from "node:os";
|
||||
import { astToString, COMMENT_HEADER, default as openapiTS } from "openapi-typescript";
|
||||
|
||||
it.each(["valid", "invalid-schema", "invalid-digest"])("synchronizes the complete artifact group or preserves it (%s)", async (scenario) => {
|
||||
const root = await mkdtemp(join(tmpdir(), "server-contract-sync-"));
|
||||
try {
|
||||
for (const directory of ["scripts", "openapi", "src/generated", "upstream"]) await mkdir(join(root, directory), { recursive: true });
|
||||
await copyFile(new URL("../../scripts/server-contract.ts", import.meta.url), join(root, "scripts/server-contract.ts"));
|
||||
await symlink(new URL("../../node_modules", import.meta.url).pathname, join(root, "node_modules"), "dir");
|
||||
const targets = ["openapi/openapi.json", "openapi/server-manifest.json", "src/generated/server-api.d.ts"];
|
||||
for (const target of targets) await writeFile(join(root, target), `original:${target}`);
|
||||
const schema = { openapi: scenario === "invalid-schema" ? "9.9.9" : "3.1.0", info: { title: "Fixture", version: "1" }, paths: {} };
|
||||
const raw = JSON.stringify(schema);
|
||||
const manifest = { contracts: { server: { sha256: scenario === "invalid-digest" ? "incorrect" : createHash("sha256").update(raw).digest("hex") } } };
|
||||
await writeFile(join(root, "upstream/schema.json"), raw);
|
||||
await writeFile(join(root, "upstream/manifest.json"), JSON.stringify(manifest));
|
||||
const child = Bun.spawn([process.execPath, "scripts/server-contract.ts", "--sync", "--upstream", "upstream/schema.json"], {
|
||||
cwd: root, stdout: "pipe", stderr: "pipe",
|
||||
});
|
||||
const [code, stderr] = await Promise.all([child.exited, new Response(child.stderr).text()]);
|
||||
if (scenario === "valid") {
|
||||
expect(code).toBe(0);
|
||||
expect(await readFile(join(root, targets[0]), "utf8")).toBe(raw);
|
||||
expect(JSON.parse(await readFile(join(root, targets[1]), "utf8"))).toEqual(manifest);
|
||||
expect(await readFile(join(root, targets[2]), "utf8")).toBe(COMMENT_HEADER + astToString(await openapiTS(schema)));
|
||||
} else {
|
||||
expect(code).not.toBe(0);
|
||||
expect(stderr).toContain(scenario === "invalid-schema" ? "Unsupported OpenAPI version" : "contract digest differs");
|
||||
for (const target of targets) expect(await readFile(join(root, target), "utf8")).toBe(`original:${target}`);
|
||||
}
|
||||
expect((await readdir(join(root, "openapi"))).sort()).toEqual(["openapi.json", "server-manifest.json"]);
|
||||
} finally {
|
||||
await rm(root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,45 @@
|
||||
import { expect, it } from "bun:test";
|
||||
import express from "express";
|
||||
import type { OperationalTaskClient } from "../../src/product/operational-task-client.js";
|
||||
import { registerTaskCommandBridge } from "../../src/routes/task-command-bridge.js";
|
||||
import { removeRuntimeSessionContext, setRuntimeSessionContext } from "../../src/runtime/sessionContext.js";
|
||||
|
||||
it("preserves command-specific session purposes and trusted bridge authentication", async () => {
|
||||
const calls: unknown[][] = [];
|
||||
const client = {
|
||||
requestDataAccess: async (...args: unknown[]) => { calls.push(args); return {}; },
|
||||
proposeAction: async (...args: unknown[]) => { calls.push(args); throw Object.assign(new Error("conflict"), { status: 409 }); },
|
||||
addHumanEvidence: async (...args: unknown[]) => { calls.push(args); return {}; },
|
||||
} as unknown as Pick<OperationalTaskClient, "requestDataAccess" | "proposeAction" | "addHumanEvidence">;
|
||||
for (const purpose of ["task_execution", "task_collaboration"] as const) setRuntimeSessionContext({
|
||||
sessionId: purpose, clientSessionId: `client-${purpose}`, taskId: "task", purpose,
|
||||
actorKey: "actor", projectKey: "project", traceId: "test",
|
||||
});
|
||||
const app = express(); app.use(express.json());
|
||||
registerTaskCommandBridge(app, { internalToken: "test-token", client });
|
||||
const server = app.listen(0, "127.0.0.1");
|
||||
await new Promise<void>((resolve) => server.once("listening", resolve));
|
||||
const post = (kind: string, session: string, data: object, headers = {}) => fetch(`http://127.0.0.1:${(server.address() as { port: number }).port}/internal/operational-task/${kind}`, {
|
||||
method: "POST", headers: { "Content-Type": "application/json", "x-agent-internal-token": "test-token", ...headers }, body: JSON.stringify({ session_id: session, ...data }),
|
||||
});
|
||||
const requestId = "60000000-0000-4000-8000-000000000001";
|
||||
const access = { request: { requestId, nodeId: "read", scopes: ["scada_devices"], reason: "查询" } };
|
||||
const evidence = { command: { request_id: requestId, evidence: { evidence_id: "e1", kind: "human_input", summary: "已复核", source_label: "用户", observed_at: "2026-11-09T00:00:00Z" } } };
|
||||
try {
|
||||
expect((await post("access-requests", "task_execution", access, { Origin: "http://browser.test" })).status).toBe(403);
|
||||
expect((await post("access-requests", "task_execution", access, { "x-agent-internal-token": "wrong" })).status).toBe(403);
|
||||
expect((await post("access-requests", "task_collaboration", access)).status).toBe(403);
|
||||
expect((await post("human-evidence", "task_execution", evidence)).status).toBe(403);
|
||||
expect(calls).toHaveLength(0);
|
||||
expect((await post("access-requests", "task_execution", access)).status).toBe(200);
|
||||
expect(calls[0]).toEqual(["task_execution", "task", { ...access.request, sourceSessionId: "client-task_execution" }]);
|
||||
expect((await post("human-evidence", "task_collaboration", evidence)).status).toBe(200);
|
||||
const action = { action: { request_id: requestId, reason: "核验", kind: "create_work_order", payload: { title: "采样", description: "核验", work_order_type: "general" } } };
|
||||
expect((await post("actions", "task_execution", action)).status).toBe(409);
|
||||
expect((await post("actions", "task_collaboration", action)).status).toBe(409);
|
||||
expect((await post("actions", "unknown", action)).status).toBe(403);
|
||||
} finally {
|
||||
removeRuntimeSessionContext("task_execution"); removeRuntimeSessionContext("task_collaboration");
|
||||
await new Promise<void>((resolve) => server.close(() => resolve()));
|
||||
}
|
||||
});
|
||||
Reference in New Issue
Block a user