root
f416950556
Move fresh and retry runner dispatch into AgentRun command admission, remove process-local job creation and secret persistence, and split oversized modules by responsibility. Co-Authored-By: Codex <noreply@openai.com>
1551 lines
75 KiB
TypeScript
1551 lines
75 KiB
TypeScript
// SPEC: PJ2026-0104010803 Workbench唯一投影 draft-2026-06-20-p2-terminal-outbox-recovery; PJ2026-010403 API契约 draft-2026-06-20-p2-terminal-outbox-recovery.
|
|
// Responsibility: Workbench read model, durable projection diagnostics, and pure-GET regression tests.
|
|
|
|
import assert from "node:assert/strict";
|
|
import { test } from "bun:test";
|
|
|
|
import { createCloudApiServer } from "./server.ts";
|
|
import { createBackendPerformanceStore } from "./backend-performance.ts";
|
|
import { createCodeAgentTraceStore } from "./code-agent-trace-store.ts";
|
|
import { classifyWorkbenchReadModelFailure } from "./server-workbench-http.ts";
|
|
import { codeAgentTurnStatusPayload, createCodeAgentChatResultStore } from "./server-code-agent-http.ts";
|
|
import { createWorkbenchTurnProjection, durableTraceStatus, projectionDiagnostics, traceTerminalEvidence } from "./workbench-turn-projection.ts";
|
|
|
|
import {
|
|
ACTOR,
|
|
getJson,
|
|
waitForCondition,
|
|
createDurableFactsRuntimeStore,
|
|
createRuntimeStoreFromFacts,
|
|
buildDurableFactsForSession,
|
|
normalizeTestMessages,
|
|
testTimingProjection,
|
|
timestampIso,
|
|
elapsedMs,
|
|
normalizeTestEvents,
|
|
filterFacts,
|
|
workbenchTestFactOrder,
|
|
matchesFact,
|
|
matchesTraceFact,
|
|
testFactFamilySet,
|
|
mergeFacts,
|
|
emptyFacts,
|
|
normalizeTestStatus,
|
|
getSseEvents,
|
|
parseSseBlock,
|
|
createFakeKafkaFactory,
|
|
waitFor
|
|
} from "./server-workbench-http-test-helpers.ts";
|
|
|
|
test("workbench projection diagnostics exposes AgentRun refresh errors without terminal inference", () => {
|
|
const traceId = "trc_projection_refresh_degraded";
|
|
const result = {
|
|
traceId,
|
|
status: "running",
|
|
agentRun: { runId: "run_projection_refresh_degraded", commandId: "cmd_projection_refresh_degraded", status: "running" }
|
|
};
|
|
const trace = { traceId, status: "running", events: [], eventCount: 0, updatedAt: "2026-06-18T01:00:00.000Z" };
|
|
const projection = createWorkbenchTurnProjection({ traceId, result, trace });
|
|
const diagnostics = projectionDiagnostics({
|
|
traceId,
|
|
result,
|
|
trace,
|
|
projection,
|
|
refreshError: { code: "agentrun_result_timeout", message: "状态更新超时，AgentRun 结果暂不可见。", retryable: true, timeoutMs: 2500 }
|
|
});
|
|
assert.equal(projection.status, "running");
|
|
assert.equal(diagnostics.projectionStatus, "blocked");
|
|
assert.equal(diagnostics.projectionHealth, "degraded");
|
|
assert.equal(diagnostics.blocker.code, "agentrun_result_timeout");
|
|
assert.equal(diagnostics.blocker.message, "状态更新超时，AgentRun 结果暂不可见。");
|
|
assert.equal(diagnostics.sourceRunId, "run_projection_refresh_degraded");
|
|
assert.equal(diagnostics.sourceCommandId, "cmd_projection_refresh_degraded");
|
|
});
|
|
test("workbench projection diagnostics keeps projecting health distinct from caught-up", () => {
|
|
const traceId = "trc_projection_health_projecting";
|
|
const result = {
|
|
traceId,
|
|
status: "running",
|
|
agentRun: { runId: "run_projection_health_projecting", commandId: "cmd_projection_health_projecting", status: "running" }
|
|
};
|
|
const trace = {
|
|
traceId,
|
|
status: "running",
|
|
events: [{ traceId, seq: 7, sourceSeq: 7, type: "backend_status", status: "running", createdAt: "2026-06-19T04:40:00.000Z" }],
|
|
eventCount: 1,
|
|
updatedAt: "2026-06-19T04:40:00.000Z"
|
|
};
|
|
const projection = createWorkbenchTurnProjection({ traceId, result, trace });
|
|
const diagnostics = projectionDiagnostics({ traceId, result, trace, projection });
|
|
assert.equal(projection.status, "running");
|
|
assert.equal(diagnostics.projectionStatus, "projecting");
|
|
assert.equal(diagnostics.projectionHealth, "projecting");
|
|
});
|
|
test("workbench runtime retryable dependency failures classify as 503 (#2020)", () => {
|
|
const error = new Error("fetch failed");
|
|
error.name = "WorkbenchRuntimeDependencyError";
|
|
error.code = "workbench_runtime_unreachable";
|
|
error.data = {
|
|
serviceId: "hwlab-workbench-runtime",
|
|
retryable: true,
|
|
transient: true,
|
|
valuesRedacted: true
|
|
};
|
|
const classified = classifyWorkbenchReadModelFailure(error);
|
|
assert.equal(classified.statusCode, 503);
|
|
assert.equal(classified.code, "workbench_runtime_unreachable");
|
|
assert.equal(classified.retryable, true);
|
|
assert.equal(classified.transient, true);
|
|
assert.equal(classified.serviceId, "hwlab-workbench-runtime");
|
|
});
|
|
|
|
test("workbench turn projection keeps lastEventAt on the latest event instead of stale admission timing (#1889)", () => {
|
|
const traceId = "trc_turn_timing_latest_event";
|
|
const result = {
|
|
traceId,
|
|
status: "running",
|
|
startedAt: "2026-06-23T21:43:48.740Z",
|
|
lastEventAt: "2026-06-23T21:43:48.740Z",
|
|
timing: {
|
|
startedAt: "2026-06-23T21:43:48.740Z",
|
|
lastEventAt: "2026-06-23T21:43:48.740Z",
|
|
durationMs: null
|
|
}
|
|
};
|
|
const trace = {
|
|
traceId,
|
|
status: "running",
|
|
updatedAt: "2026-06-23T21:44:33.486Z",
|
|
lastEventAt: "2026-06-23T21:44:31.000Z",
|
|
events: [
|
|
{ seq: 1, type: "admitted", createdAt: "2026-06-23T21:43:48.740Z" },
|
|
{ seq: 2, type: "commandExecution", status: "completed", updatedAt: "2026-06-23T21:44:31.000Z" }
|
|
],
|
|
eventCount: 2
|
|
};
|
|
const projection = createWorkbenchTurnProjection({ traceId, result, trace });
|
|
assert.equal(projection.startedAt, "2026-06-23T21:43:48.740Z");
|
|
assert.equal(projection.lastEventAt, "2026-06-23T21:44:33.486Z");
|
|
assert.equal(projection.timing.lastEventAt, "2026-06-23T21:44:33.486Z");
|
|
});
|
|
|
|
test("workbench turn projection treats retryable provider stream disconnect as active", () => {
|
|
const traceId = "trc_retryable_provider_stream_disconnect";
|
|
const result = {
|
|
traceId,
|
|
status: "canceled",
|
|
failureKind: "provider-stream-disconnected",
|
|
willRetry: true,
|
|
agentRun: {
|
|
runId: "run_retryable_provider_stream_disconnect",
|
|
commandId: "cmd_retryable_provider_stream_disconnect",
|
|
terminalStatus: "cancelled",
|
|
failureKind: "provider-stream-disconnected",
|
|
willRetry: true
|
|
},
|
|
providerTrace: { failureKind: "provider-stream-disconnected", willRetry: true }
|
|
};
|
|
const trace = {
|
|
traceId,
|
|
status: "canceled",
|
|
events: [
|
|
{ seq: 1, type: "error", status: "retrying", errorCode: "provider-stream-disconnected", willRetry: true, terminal: false },
|
|
{ seq: 2, type: "result", status: "canceled", errorCode: "provider-stream-disconnected", willRetry: true, terminal: true }
|
|
],
|
|
eventCount: 2
|
|
};
|
|
const projection = createWorkbenchTurnProjection({ traceId, result, trace });
|
|
assert.equal(projection.status, "retrying");
|
|
assert.equal(projection.running, true);
|
|
assert.equal(projection.terminal, false);
|
|
assert.equal(projection.finalResponse, null);
|
|
assert.equal(durableTraceStatus(trace.events), "retrying");
|
|
assert.equal(traceTerminalEvidence(trace), null);
|
|
|
|
const completedProjection = createWorkbenchTurnProjection({
|
|
traceId,
|
|
result: {
|
|
...result,
|
|
status: "completed",
|
|
finalResponse: "retry recovered",
|
|
agentRun: { ...result.agentRun, terminalStatus: "completed" }
|
|
},
|
|
trace: {
|
|
...trace,
|
|
status: "completed",
|
|
events: [
|
|
...trace.events,
|
|
{ seq: 3, type: "assistant", status: "completed", message: "retry recovered", terminal: true, replyAuthority: true }
|
|
],
|
|
eventCount: 3
|
|
}
|
|
});
|
|
assert.equal(completedProjection.status, "completed");
|
|
assert.equal(completedProjection.running, false);
|
|
assert.equal(completedProjection.terminal, true);
|
|
assert.equal(completedProjection.finalResponse?.text, "retry recovered");
|
|
});
|
|
|
|
test("workbench turn projection sanitizes legacy agentrun-unreachable into retryable AgentRun transport interruption (#1853)", () => {
|
|
const traceId = "trc_retryable_legacy_agentrun_unreachable";
|
|
const result = {
|
|
traceId,
|
|
status: "failed",
|
|
failureKind: "agentrun-unreachable",
|
|
willRetry: true,
|
|
agentRun: {
|
|
runId: "run_retryable_legacy_agentrun_unreachable",
|
|
commandId: "cmd_retryable_legacy_agentrun_unreachable",
|
|
terminalStatus: "failed",
|
|
failureKind: "agentrun-unreachable",
|
|
willRetry: true
|
|
},
|
|
providerTrace: { failureKind: "agentrun-unreachable", willRetry: true }
|
|
};
|
|
const trace = {
|
|
traceId,
|
|
status: "failed",
|
|
events: [
|
|
{ seq: 1, type: "error", status: "failed", errorCode: "agentrun-unreachable", failureKind: "agentrun-unreachable", willRetry: true, terminal: true }
|
|
],
|
|
eventCount: 1
|
|
};
|
|
const projection = createWorkbenchTurnProjection({ traceId, result, trace });
|
|
assert.equal(projection.status, "retrying");
|
|
assert.equal(projection.running, true);
|
|
assert.equal(projection.terminal, false);
|
|
assert.equal(projection.finalResponse, null);
|
|
assert.equal(projection.source, "provider-retry");
|
|
assert.equal(projection.terminalEvidence, null);
|
|
assert.equal(durableTraceStatus(trace.events), "retrying");
|
|
assert.equal(traceTerminalEvidence(trace), null);
|
|
});
|
|
|
|
test("workbench turn projection seals final response from authoritative terminal assistant trace event (#1629)", () => {
|
|
const traceId = "trc_workbench_terminal_assistant_final";
|
|
const finalText = [
|
|
"全部六份数据到手！下面是完整的六语言终极性能对比：",
|
|
"",
|
|
"| language | runtime | status |",
|
|
"|---|---|---|",
|
|
"| Lua | LuaJIT | pass |"
|
|
].join("\n");
|
|
const trace = {
|
|
traceId,
|
|
status: "completed",
|
|
events: [
|
|
{ seq: 1, type: "assistant_message", status: "running", message: "正在补 Lua 基准测试。" },
|
|
{ seq: 2, type: "assistant_message", status: "completed", replyAuthority: true, final: true, message: finalText },
|
|
{ seq: 3, type: "result", status: "completed", terminal: true, label: "agentrun:terminal:completed" }
|
|
],
|
|
eventCount: 3
|
|
};
|
|
const projection = createWorkbenchTurnProjection({ traceId, result: { traceId, status: "completed" }, trace });
|
|
assert.equal(projection.status, "completed");
|
|
assert.equal(projection.terminal, true);
|
|
assert.equal(projection.finalResponse.text, finalText);
|
|
assert.equal(projection.assistantText, finalText);
|
|
assert.equal(projection.terminalEvidence.finalResponse.text, finalText);
|
|
});
|
|
|
|
test("workbench turn projection keeps progress-only assistant trace text out of final response (#1629)", () => {
|
|
const traceId = "trc_workbench_terminal_without_authoritative_final";
|
|
const trace = {
|
|
traceId,
|
|
status: "completed",
|
|
events: [
|
|
{ seq: 1, type: "assistant_message", status: "running", message: "这只是运行中的进度。" },
|
|
{ seq: 2, type: "result", status: "completed", terminal: true, label: "agentrun:terminal:completed" }
|
|
],
|
|
eventCount: 2
|
|
};
|
|
const projection = createWorkbenchTurnProjection({ traceId, result: { traceId, status: "completed" }, trace });
|
|
const diagnostics = projectionDiagnostics({ traceId, result: { traceId, status: "completed" }, trace, projection });
|
|
assert.equal(projection.status, "running");
|
|
assert.equal(projection.running, true);
|
|
assert.equal(projection.terminal, false);
|
|
assert.equal(projection.terminalObserved, true);
|
|
assert.equal(projection.terminalObservedStatus, "completed");
|
|
assert.equal(projection.waitingFor, "final_response");
|
|
assert.equal(projection.finalResponse, null);
|
|
assert.equal(projection.assistantText, null);
|
|
assert.equal(diagnostics.projectionStatus, "projecting");
|
|
assert.equal(diagnostics.projectionHealth, "projecting");
|
|
assert.equal(diagnostics.waitingFor, "final_response");
|
|
});
|
|
|
|
test("code agent turn status keeps completed AgentRun without final response unsealed", () => {
|
|
const traceId = "trc_code_agent_terminal_without_final";
|
|
const payload = codeAgentTurnStatusPayload({
|
|
traceId,
|
|
result: {
|
|
traceId,
|
|
status: "completed",
|
|
agentRun: {
|
|
runId: "run_code_agent_terminal_without_final",
|
|
commandId: "cmd_code_agent_terminal_without_final",
|
|
status: "completed",
|
|
terminalStatus: "completed"
|
|
},
|
|
runnerTrace: {
|
|
traceId,
|
|
status: "completed",
|
|
events: [
|
|
{ seq: 1, type: "assistant_message", status: "running", message: "progress only" },
|
|
{ seq: 2, type: "terminal_status", terminal: true, terminalStatus: "completed" }
|
|
]
|
|
}
|
|
},
|
|
snapshot: null,
|
|
resultPollError: null,
|
|
refreshError: null,
|
|
options: { env: {} }
|
|
});
|
|
assert.equal(payload.status, "running");
|
|
assert.equal(payload.running, true);
|
|
assert.equal(payload.terminal, false);
|
|
assert.equal(payload.terminalObserved, true);
|
|
assert.equal(payload.terminalObservedStatus, "completed");
|
|
assert.equal(payload.terminalSealBlocked, true);
|
|
assert.equal(payload.waitingFor, "final_response");
|
|
assert.equal(payload.finalResponse, null);
|
|
});
|
|
|
|
test("code agent turn status keeps failed AgentRun without final response unsealed", () => {
|
|
const traceId = "trc_code_agent_failed_without_final";
|
|
const payload = codeAgentTurnStatusPayload({
|
|
traceId,
|
|
result: {
|
|
traceId,
|
|
status: "failed",
|
|
agentRun: {
|
|
runId: "run_code_agent_failed_without_final",
|
|
commandId: "cmd_code_agent_failed_without_final",
|
|
status: "failed",
|
|
terminalStatus: "failed"
|
|
},
|
|
runnerTrace: {
|
|
traceId,
|
|
status: "failed",
|
|
events: [
|
|
{ seq: 1, type: "assistant_message", status: "running", message: "progress only" },
|
|
{ seq: 2, type: "terminal_status", terminal: true, terminalStatus: "failed" }
|
|
]
|
|
}
|
|
},
|
|
snapshot: null,
|
|
resultPollError: null,
|
|
refreshError: null,
|
|
options: { env: {} }
|
|
});
|
|
assert.equal(payload.status, "running");
|
|
assert.equal(payload.running, true);
|
|
assert.equal(payload.terminal, false);
|
|
assert.equal(payload.terminalObserved, true);
|
|
assert.equal(payload.terminalObservedStatus, "failed");
|
|
assert.equal(payload.terminalSealBlocked, true);
|
|
assert.equal(payload.waitingFor, "final_response");
|
|
assert.equal(payload.finalResponse, null);
|
|
});
|
|
|
|
test("code agent turn status seals failed AgentRun when final response is authoritative", () => {
|
|
const traceId = "trc_code_agent_failed_with_final";
|
|
const payload = codeAgentTurnStatusPayload({
|
|
traceId,
|
|
result: {
|
|
traceId,
|
|
status: "failed",
|
|
finalResponse: { text: "Workbench terminal failed: provider-stream-disconnected", status: "failed" },
|
|
agentRun: {
|
|
runId: "run_code_agent_failed_with_final",
|
|
commandId: "cmd_code_agent_failed_with_final",
|
|
status: "failed",
|
|
terminalStatus: "failed"
|
|
}
|
|
},
|
|
snapshot: null,
|
|
resultPollError: null,
|
|
refreshError: null,
|
|
options: { env: {} }
|
|
});
|
|
assert.equal(payload.status, "failed");
|
|
assert.equal(payload.running, false);
|
|
assert.equal(payload.terminal, true);
|
|
assert.equal(payload.terminalSealBlocked, false);
|
|
assert.equal(payload.finalResponse.text, "Workbench terminal failed: provider-stream-disconnected");
|
|
});
|
|
|
|
test("code agent turn status seals completed AgentRun when finalText is authoritative", () => {
|
|
const traceId = "trc_code_agent_terminal_with_final_text";
|
|
const payload = codeAgentTurnStatusPayload({
|
|
traceId,
|
|
result: {
|
|
traceId,
|
|
status: "completed",
|
|
finalText: "authoritative final",
|
|
agentRun: {
|
|
runId: "run_code_agent_terminal_with_final_text",
|
|
commandId: "cmd_code_agent_terminal_with_final_text",
|
|
status: "completed",
|
|
terminalStatus: "completed"
|
|
}
|
|
},
|
|
snapshot: null,
|
|
resultPollError: null,
|
|
refreshError: null,
|
|
options: { env: {} }
|
|
});
|
|
assert.equal(payload.status, "completed");
|
|
assert.equal(payload.running, false);
|
|
assert.equal(payload.terminal, true);
|
|
assert.equal(payload.terminalSealBlocked, false);
|
|
assert.equal(payload.finalResponse.text, "authoritative final");
|
|
});
|
|
|
|
test("workbench trace event page exposes projectedSeq cursor range from durable facts", async () => {
|
|
const traceId = "trc_workbench_trace_mixed_cursor";
|
|
const session = {
|
|
id: "ses_workbench_trace_mixed_cursor",
|
|
projectId: "prj_workbench_authority_session",
|
|
agentId: "hwlab-code-agent",
|
|
status: "completed",
|
|
ownerUserId: ACTOR.id,
|
|
conversationId: "cnv_workbench_trace_mixed_cursor",
|
|
threadId: "thread-workbench-trace-mixed-cursor",
|
|
lastTraceId: traceId,
|
|
updatedAt: "2026-06-19T04:10:17.060Z",
|
|
session: { sessionStatus: "completed", lastTraceId: traceId, messages: [{ role: "user", text: "trace", traceId }] }
|
|
};
|
|
const mixedEvents = [
|
|
{ projectedSeq: 7, source: "agentrun", sourceSeq: 1, type: "backend", status: "running", label: "projected:7", createdAt: "2026-06-19T01:27:27.092Z" },
|
|
{ projectedSeq: 1, source: "agentrun", sourceSeq: 99, type: "backend", status: "running", label: "projected:1", createdAt: "2026-06-19T04:10:15.362Z" },
|
|
{ projectedSeq: 11, source: "agentrun", sourceSeq: 4, type: "backend", status: "running", label: "projected:11", createdAt: "2026-06-19T01:27:34.128Z" },
|
|
{ projectedSeq: 5, source: "agentrun", sourceSeq: 4, type: "backend", status: "running", label: "projected:5", createdAt: "2026-06-19T04:10:15.664Z" },
|
|
{ projectedSeq: 3, source: "agentrun", sourceSeq: 5, type: "backend", status: "running", label: "projected:3", createdAt: "2026-06-19T01:27:34.324Z" },
|
|
{ projectedSeq: 9, source: "agentrun", sourceSeq: 5, type: "backend", status: "running", label: "projected:9", createdAt: "2026-06-19T04:10:16.013Z" },
|
|
{ projectedSeq: 4, type: "result", status: "completed", label: "projected:4", terminal: true, createdAt: "2026-06-19T01:27:34.324Z" },
|
|
{ projectedSeq: 2, type: "request", status: "accepted", label: "projected:2", createdAt: "2026-06-19T04:10:15.362Z" },
|
|
{ projectedSeq: 6, type: "backend", status: "running", label: "projected:6", createdAt: "2026-06-19T04:10:15.664Z" },
|
|
{ projectedSeq: 8, type: "backend", status: "running", label: "projected:8", createdAt: "2026-06-19T04:10:16.013Z" },
|
|
{ projectedSeq: 10, type: "backend", status: "running", label: "projected:10", createdAt: "2026-06-19T04:10:17.060Z" }
|
|
];
|
|
const accessController = {
|
|
store: {
|
|
async getAgentSession(sessionId) { return sessionId === session.id ? session : null; },
|
|
async getAgentSessionByTraceId(requestTraceId) { return requestTraceId === traceId ? session : null; }
|
|
},
|
|
async ensureBootstrap() {},
|
|
async authenticate() { return { ok: true, actor: ACTOR, session: { id: "uss_workbench_reader" } }; }
|
|
};
|
|
const runtimeStore = createDurableFactsRuntimeStore({ sessions: [{ session, events: mixedEvents, status: "completed" }] });
|
|
const server = createCloudApiServer({ accessController, runtimeStore, codeAgentChatResults: createCodeAgentChatResultStore() });
|
|
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
|
|
|
|
try {
|
|
const { port } = server.address();
|
|
const trace = await getJson(port, `/v1/workbench/traces/${encodeURIComponent(traceId)}/events?limit=25`);
|
|
assert.equal(trace.status, 200);
|
|
assert.equal(trace.body.events.length, mixedEvents.length);
|
|
assert.deepEqual(trace.body.events.map((event) => event.seq), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
|
|
assert.equal(trace.body.events[0].label, "projected:1");
|
|
assert.equal(trace.body.events.at(-1).label, "projected:11");
|
|
assert.deepEqual(trace.body.range, { afterProjectedSeq: 0, fromProjectedSeq: 1, toProjectedSeq: 11, limit: 25, returned: 11, total: 11 });
|
|
assert.equal(trace.body.nextProjectedSeq, 11);
|
|
assert.equal(trace.body.hasMore, false);
|
|
assert.equal(trace.body.nextCursor, null);
|
|
|
|
const middle = await getJson(port, `/v1/workbench/traces/${encodeURIComponent(traceId)}/events?cursor=projected:4&limit=3`);
|
|
assert.equal(middle.status, 200);
|
|
assert.deepEqual(middle.body.events.map((event) => event.seq), [5, 6, 7]);
|
|
assert.deepEqual(middle.body.range, { afterProjectedSeq: 4, fromProjectedSeq: 5, toProjectedSeq: 7, limit: 3, returned: 3, total: 11 });
|
|
assert.equal(middle.body.hasMore, true);
|
|
assert.equal(middle.body.nextProjectedSeq, 7);
|
|
assert.equal(middle.body.nextCursor, "projected:7");
|
|
|
|
const empty = await getJson(port, `/v1/workbench/traces/${encodeURIComponent(traceId)}/events?afterProjectedSeq=999999&limit=5`);
|
|
assert.equal(empty.status, 200);
|
|
assert.deepEqual(empty.body.events, []);
|
|
assert.deepEqual(empty.body.range, { afterProjectedSeq: 999999, fromProjectedSeq: null, toProjectedSeq: null, limit: 5, returned: 0, total: 11 });
|
|
assert.equal(empty.body.nextProjectedSeq, 999999);
|
|
} finally {
|
|
await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
|
|
}
|
|
});
|
|
|
|
test("workbench trace event page pushes projectedSeq cursor into durable trace facts", async () => {
|
|
const traceId = "trc_long_trace_projection_page";
|
|
const session = {
|
|
id: "ses_long_trace_projection_page",
|
|
projectId: "prj_hwpod_workbench",
|
|
agentId: "hwlab-code-agent",
|
|
status: "running",
|
|
ownerUserId: ACTOR.id,
|
|
conversationId: "cnv_long_trace_projection_page",
|
|
threadId: "thread-long-trace-projection-page",
|
|
lastTraceId: traceId,
|
|
updatedAt: "2026-06-20T02:30:00.000Z",
|
|
session: { sessionStatus: "running", lastTraceId: traceId, messages: [{ role: "user", text: "long trace", traceId }] }
|
|
};
|
|
const events = Array.from({ length: 2600 }, (_, index) => ({
|
|
seq: index + 1,
|
|
sourceSeq: index + 1,
|
|
projectedSeq: index + 1,
|
|
type: "backend",
|
|
label: `event:${index + 1}`,
|
|
createdAt: new Date(Date.UTC(2026, 5, 20, 2, 30, index % 60)).toISOString()
|
|
}));
|
|
const queries = [];
|
|
const runtimeStore = createDurableFactsRuntimeStore({ sessions: [{ session, events, status: "running" }], queries });
|
|
const accessController = {
|
|
store: {
|
|
async getAgentSession(sessionId) { return sessionId === session.id ? session : null; },
|
|
async getAgentSessionByTraceId(requestTraceId) { return requestTraceId === traceId ? session : null; }
|
|
},
|
|
async ensureBootstrap() {},
|
|
async authenticate() { return { ok: true, actor: ACTOR, session: { id: "uss_workbench_reader" } }; }
|
|
};
|
|
const server = createCloudApiServer({ accessController, runtimeStore });
|
|
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
|
|
|
|
try {
|
|
const { port } = server.address();
|
|
const trace = await getJson(port, `/v1/workbench/traces/${encodeURIComponent(traceId)}/events?afterProjectedSeq=2500&limit=25`);
|
|
assert.equal(trace.status, 200);
|
|
assert.deepEqual(trace.body.events.map((event) => event.seq), Array.from({ length: 25 }, (_, index) => 2501 + index));
|
|
assert.equal(trace.body.hasMore, true);
|
|
assert.equal(trace.body.nextCursor, "projected:2525");
|
|
|
|
const traceQueries = queries.filter((query) => Array.isArray(query.families) && query.families.includes("traceEvents"));
|
|
assert.equal(traceQueries.length, 1);
|
|
assert.deepEqual(traceQueries[0].families, ["traceEvents"]);
|
|
assert.equal(traceQueries[0].traceId, traceId);
|
|
assert.equal(traceQueries[0].afterProjectedSeq, 2500);
|
|
assert.equal(traceQueries[0].limit, 26);
|
|
} finally {
|
|
await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
|
|
}
|
|
});
|
|
|
|
test("workbench trace events stay visible after session lastTraceId advances", async () => {
|
|
const firstTraceId = "trc_workbench_historical_visible_first";
|
|
const secondTraceId = "trc_workbench_historical_visible_second";
|
|
const session = {
|
|
id: "ses_workbench_historical_visible",
|
|
projectId: "prj_hwpod_workbench",
|
|
agentId: "hwlab-code-agent",
|
|
status: "completed",
|
|
ownerUserId: ACTOR.id,
|
|
conversationId: "cnv_workbench_historical_visible",
|
|
threadId: "thread-workbench-historical-visible",
|
|
lastTraceId: firstTraceId,
|
|
updatedAt: "2026-06-20T10:00:00.000Z",
|
|
session: { sessionStatus: "completed", lastTraceId: firstTraceId, messages: [{ role: "user", text: "first", traceId: firstTraceId, status: "sent" }, { role: "agent", text: "OK", traceId: firstTraceId, status: "completed" }] }
|
|
};
|
|
const facts = buildDurableFactsForSession({
|
|
session,
|
|
status: "completed",
|
|
finalText: "OK",
|
|
events: [
|
|
{ projectedSeq: 1, sourceSeq: 1, type: "request", status: "accepted", label: "first:accepted", createdAt: "2026-06-20T09:59:58.000Z" },
|
|
{ projectedSeq: 2, sourceSeq: 2, type: "result", status: "completed", label: "first:completed", terminal: true, createdAt: "2026-06-20T10:00:00.000Z" }
|
|
]
|
|
});
|
|
facts.sessions[0].lastTraceId = secondTraceId;
|
|
facts.sessions[0].status = "running";
|
|
const queries = [];
|
|
const runtimeStore = {
|
|
async queryWorkbenchFacts(params = {}) {
|
|
queries.push(params);
|
|
const filtered = filterFacts(facts, params);
|
|
return {
|
|
facts: filtered,
|
|
count: Object.values(filtered).reduce((sum, rows) => sum + rows.length, 0),
|
|
persistence: { adapter: "test-durable-workbench-facts", durable: true }
|
|
};
|
|
}
|
|
};
|
|
const accessController = {
|
|
store: {},
|
|
async ensureBootstrap() {},
|
|
async authenticate() { return { ok: true, actor: ACTOR, session: { id: "uss_workbench_reader" } }; }
|
|
};
|
|
const server = createCloudApiServer({ accessController, runtimeStore, codeAgentChatResults: createCodeAgentChatResultStore() });
|
|
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
|
|
|
|
try {
|
|
const { port } = server.address();
|
|
const trace = await getJson(port, `/v1/workbench/traces/${encodeURIComponent(firstTraceId)}/events?limit=10`);
|
|
assert.equal(trace.status, 200);
|
|
assert.equal(trace.body.sessionId, session.id);
|
|
assert.deepEqual(trace.body.events.map((event) => event.label), ["first:accepted", "first:completed"]);
|
|
assert.ok(queries.some((query) => query.traceId === firstTraceId && query.families?.includes("messages") && query.families?.includes("turns")));
|
|
assert.ok(queries.some((query) => query.sessionId === session.id && query.families?.includes("sessions") && !query.traceId));
|
|
} finally {
|
|
await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
|
|
}
|
|
});
|
|
|
|
test("workbench read model exposes session, messages, turn, and trace without write repair", async () => {
|
|
const traceStore = createCodeAgentTraceStore();
|
|
const results = createCodeAgentChatResultStore();
|
|
const writes = { recordAgentSessionOwner: 0, updateWorkspace: 0 };
|
|
const traceId = "trc_workbench_read_model";
|
|
const session = {
|
|
id: "ses_workbench_read_model",
|
|
projectId: "prj_workbench_authority_session",
|
|
agentId: "hwlab-code-agent",
|
|
status: "completed",
|
|
startedAt: "2026-06-17T00:00:00.000Z",
|
|
endedAt: "2026-06-17T00:00:03.000Z",
|
|
ownerUserId: ACTOR.id,
|
|
conversationId: "cnv_workbench_read_model",
|
|
threadId: "thread-workbench-read-model",
|
|
lastTraceId: traceId,
|
|
updatedAt: "2026-06-17T00:00:03.000Z",
|
|
session: {
|
|
sessionStatus: "completed",
|
|
providerProfile: "codex-api",
|
|
lastTraceId: traceId,
|
|
messages: [
|
|
{ role: "user", text: "ping", traceId, createdAt: "2026-06-17T00:00:00.000Z" },
|
|
{ role: "assistant", text: "pong", traceId, createdAt: "2026-06-17T00:00:03.000Z" }
|
|
],
|
|
valuesRedacted: true,
|
|
secretMaterialStored: false
|
|
}
|
|
};
|
|
const factQueries = [];
|
|
traceStore.append(traceId, { type: "request", status: "accepted", label: "request:accepted" });
|
|
traceStore.append(traceId, { type: "result", status: "completed", label: "result:completed", terminal: true });
|
|
results.set(traceId, {
|
|
status: "completed",
|
|
traceId,
|
|
ownerUserId: ACTOR.id,
|
|
conversationId: session.conversationId,
|
|
sessionId: session.id,
|
|
threadId: session.threadId,
|
|
finalResponse: "pong",
|
|
agentRun: { runId: "run_workbench_read_model", commandId: "cmd_workbench_read_model", status: "completed" }
|
|
});
|
|
|
|
const accessController = {
|
|
store: {
|
|
async listAgentSessionsForUser(input = {}) {
|
|
return [session];
|
|
},
|
|
async getAgentSession(sessionId) { return sessionId === session.id ? session : null; },
|
|
async getAgentSessionByTraceId(requestTraceId) { return requestTraceId === traceId ? session : null; },
|
|
async recordAgentSessionOwner() { writes.recordAgentSessionOwner += 1; throw new Error("read model must not write session owner"); },
|
|
async updateWorkspace() { writes.updateWorkspace += 1; throw new Error("read model must not update workspace"); }
|
|
},
|
|
async ensureBootstrap() {},
|
|
async authenticate() { return { ok: true, actor: ACTOR, session: { id: "uss_workbench_reader" } }; }
|
|
};
|
|
const runtimeStore = createDurableFactsRuntimeStore({
|
|
sessions: [{
|
|
session,
|
|
events: [
|
|
{ seq: 1, type: "request", status: "accepted", label: "request:accepted", createdAt: "2026-06-17T00:00:00.000Z" },
|
|
{ seq: 2, type: "result", status: "completed", label: "result:completed", terminal: true, createdAt: "2026-06-17T00:00:03.000Z" }
|
|
],
|
|
status: "completed",
|
|
finalText: "pong",
|
|
runId: "run_workbench_read_model",
|
|
commandId: "cmd_workbench_read_model",
|
|
lastProjectedSeq: 2
|
|
}],
|
|
queries: factQueries
|
|
});
|
|
const server = createCloudApiServer({ accessController, traceStore, runtimeStore, codeAgentChatResults: results });
|
|
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
|
|
|
|
try {
|
|
const { port } = server.address();
|
|
const sessions = await getJson(port, "/v1/workbench/sessions");
|
|
assert.equal(sessions.status, 200);
|
|
assert.equal(sessions.body.contractVersion, "workbench-sessions-v1");
|
|
assert.equal(sessions.body.sessions[0].sessionId, session.id);
|
|
assert.equal(sessions.body.sessions[0].turnSummary.traceId, traceId);
|
|
assert.equal(sessions.body.sessions[0].turnSummary.lastEventAt, "2026-06-17T00:00:03.000Z");
|
|
assert.equal(sessions.body.sessions[0].turnSummary.durationMs, 3000);
|
|
assert.equal(factQueries[0].projectId, undefined);
|
|
assert.equal(factQueries[0].limit, 21);
|
|
assert.equal(factQueries[0].sessionsOrder, "updated_desc");
|
|
assert.deepEqual(factQueries[0].families, ["sessions"]);
|
|
assert.deepEqual(factQueries[1].families, ["messages", "parts", "turns"]);
|
|
assert.deepEqual(factQueries[1].sessionIds, [session.id]);
|
|
assert.deepEqual(factQueries[2].families, ["checkpoints"]);
|
|
assert.deepEqual(factQueries[2].traceIds, [traceId]);
|
|
|
|
const staleProject = await getJson(port, `/v1/workbench/sessions?projectId=prj_stale_filter&includeSessionId=${encodeURIComponent(session.id)}`);
|
|
assert.equal(staleProject.status, 400);
|
|
assert.equal(staleProject.body.error.code, "workbench_authority_removed");
|
|
assert.equal(factQueries.length, 3);
|
|
|
|
const detail = await getJson(port, `/v1/workbench/sessions/${encodeURIComponent(session.id)}?includeMessages=false`);
|
|
assert.equal(detail.status, 200);
|
|
assert.equal(detail.body.detailMode, "metadata-only");
|
|
assert.equal(detail.body.messagesIncluded, false);
|
|
assert.equal(detail.body.session.sessionId, session.id);
|
|
assert.equal(detail.body.session.messagePageUrl, `/v1/workbench/sessions/${encodeURIComponent(session.id)}/messages`);
|
|
assert.equal(detail.body.session.messageCount, 2);
|
|
assert.equal(Object.hasOwn(detail.body.session, "messages"), false);
|
|
|
|
const fullDetail = await getJson(port, `/v1/workbench/sessions/${encodeURIComponent(session.id)}?includeMessages=true`);
|
|
assert.equal(fullDetail.status, 200);
|
|
assert.equal(fullDetail.body.detailMode, "full");
|
|
assert.equal(fullDetail.body.messagesIncluded, true);
|
|
assert.equal(fullDetail.body.session.messages.length, 2);
|
|
|
|
const messages = await getJson(port, `/v1/workbench/sessions/${encodeURIComponent(session.id)}/messages?limit=1`);
|
|
assert.equal(messages.status, 200);
|
|
assert.equal(messages.body.contractVersion, "workbench-message-page-v1");
|
|
assert.equal(messages.body.messages.length, 1);
|
|
assert.equal(messages.body.messages[0].role, "user");
|
|
assert.equal(messages.body.messages[0].text, "ping");
|
|
assert.equal(messages.body.messages[0].parts[0].text, "ping");
|
|
assert.equal(messages.body.hasMore, true);
|
|
|
|
const allMessages = await getJson(port, `/v1/workbench/sessions/${encodeURIComponent(session.id)}/messages?limit=2`);
|
|
const agentMessage = allMessages.body.messages.find((message) => message.role !== "user");
|
|
assert.equal(agentMessage.lastEventAt, "2026-06-17T00:00:03.000Z");
|
|
assert.equal(agentMessage.durationMs, 3000);
|
|
|
|
const turn = await getJson(port, `/v1/workbench/turns/${encodeURIComponent(traceId)}`);
|
|
assert.equal(turn.status, 200);
|
|
assert.equal(turn.body.contractVersion, "workbench-turn-snapshot-v1");
|
|
assert.equal(turn.body.turn.traceId, traceId);
|
|
assert.equal(turn.body.turn.userMessageId, messages.body.messages[0].messageId);
|
|
assert.equal(turn.body.turn.terminal, true);
|
|
assert.equal(turn.body.turn.startedAt, "2026-06-17T00:00:00.000Z");
|
|
assert.equal(turn.body.turn.finishedAt, "2026-06-17T00:00:03.000Z");
|
|
assert.equal(turn.body.turn.durationMs, 3000);
|
|
|
|
const trace = await getJson(port, `/v1/workbench/traces/${encodeURIComponent(traceId)}/events?limit=1`);
|
|
assert.equal(trace.status, 200);
|
|
assert.equal(trace.body.contractVersion, "workbench-trace-events-v1");
|
|
assert.equal(trace.body.events.length, 1);
|
|
assert.equal(trace.body.hasMore, true);
|
|
assert.equal(trace.body.durationMs, 3000);
|
|
|
|
const emptyTracePage = await getJson(port, `/v1/workbench/traces/${encodeURIComponent(traceId)}/events?afterProjectedSeq=99`);
|
|
assert.equal(emptyTracePage.status, 200);
|
|
assert.equal(emptyTracePage.body.events.length, 0);
|
|
assert.equal(emptyTracePage.body.range.fromProjectedSeq, null);
|
|
assert.equal(emptyTracePage.body.range.toProjectedSeq, null);
|
|
assert.equal(emptyTracePage.body.nextProjectedSeq, 99);
|
|
|
|
assert.deepEqual(writes, { recordAgentSessionOwner: 0, updateWorkspace: 0 });
|
|
} finally {
|
|
await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
|
|
}
|
|
});
|
|
|
|
test("workbench session messages use turn timeline instead of clustered projection writes", async () => {
|
|
const traceIds = Array.from({ length: 5 }, (_, index) => `trc_workbench_timeline_cluster_${index + 1}`);
|
|
const session = {
|
|
id: "ses_workbench_timeline_cluster",
|
|
projectId: "prj_hwpod_workbench",
|
|
agentId: "hwlab-code-agent",
|
|
status: "completed",
|
|
startedAt: "2026-06-27T00:00:00.000Z",
|
|
endedAt: "2026-06-27T00:10:00.000Z",
|
|
ownerUserId: ACTOR.id,
|
|
conversationId: "cnv_workbench_timeline_cluster",
|
|
threadId: "thread-workbench-timeline-cluster",
|
|
lastTraceId: traceIds.at(-1),
|
|
updatedAt: "2026-06-27T00:10:00.000Z",
|
|
session: {
|
|
sessionStatus: "completed",
|
|
messages: traceIds.flatMap((traceId, index) => {
|
|
const turn = index + 1;
|
|
return [
|
|
{ role: "user", text: `sentinel-${turn}`, traceId, turnId: traceId, projectedSeq: turn, sourceSeq: turn, status: "sent", createdAt: `2026-06-27T00:0${index}:00.000Z` },
|
|
{ role: "agent", text: `ok-${turn}`, traceId, turnId: traceId, projectedSeq: 100 + turn, sourceSeq: 100 + turn, status: "completed", createdAt: `2026-06-27T00:0${index}:30.000Z` }
|
|
];
|
|
}),
|
|
valuesRedacted: true,
|
|
secretMaterialStored: false
|
|
}
|
|
};
|
|
const runtimeStore = createDurableFactsRuntimeStore({ sessions: [{ session, status: "completed", lastProjectedSeq: 105 }] });
|
|
const accessController = {
|
|
async ensureBootstrap() {},
|
|
async authenticate() { return { ok: true, actor: ACTOR, session: { id: "uss_workbench_reader" } }; }
|
|
};
|
|
const server = createCloudApiServer({ accessController, runtimeStore });
|
|
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
|
|
|
|
try {
|
|
const { port } = server.address();
|
|
const messages = await getJson(port, `/v1/workbench/sessions/${encodeURIComponent(session.id)}/messages?limit=20`);
|
|
assert.equal(messages.status, 200);
|
|
assert.deepEqual(messages.body.messages.map((message) => message.role), ["user", "agent", "user", "agent", "user", "agent", "user", "agent", "user", "agent"]);
|
|
assert.deepEqual(messages.body.messages.map((message) => message.text), ["sentinel-1", "ok-1", "sentinel-2", "ok-2", "sentinel-3", "ok-3", "sentinel-4", "ok-4", "sentinel-5", "ok-5"]);
|
|
|
|
const sessions = await getJson(port, `/v1/workbench/sessions?includeSessionId=${encodeURIComponent(session.id)}`);
|
|
assert.equal(sessions.status, 200);
|
|
assert.equal(sessions.body.sessions[0].title, "sentinel-5");
|
|
assert.equal(sessions.body.sessions[0].preview, "ok-5");
|
|
assert.equal(sessions.body.sessions[0].titleSource, "message-projection");
|
|
assert.equal(sessions.body.sessions[0].previewSource, "message-projection");
|
|
} finally {
|
|
await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
|
|
}
|
|
});
|
|
|
|
test("workbench session messages use prompt admission time when turn seq is stale", async () => {
|
|
const sessionId = "ses_workbench_timeline_stale_turn_seq";
|
|
const turnRows = [
|
|
{ traceId: "trc_stale_turn_01", turnSeq: 1, at: "2026-06-28T08:40:42.000Z", prompt: "sentinel-01", reply: "ok-01" },
|
|
{ traceId: "trc_stale_turn_02", turnSeq: 3, at: "2026-06-28T08:43:51.000Z", prompt: "sentinel-02", reply: "ok-02" },
|
|
{ traceId: "trc_stale_turn_03", turnSeq: 2, at: "2026-06-28T08:44:07.000Z", prompt: "sentinel-03", reply: "ok-03" },
|
|
{ traceId: "trc_stale_turn_04", turnSeq: 5, at: "2026-06-28T08:44:27.000Z", prompt: "sentinel-04", reply: "ok-04" },
|
|
{ traceId: "trc_stale_turn_05", turnSeq: 4, at: "2026-06-28T08:44:44.000Z", prompt: "sentinel-05", reply: "ok-05" }
|
|
];
|
|
const facts = emptyFacts();
|
|
facts.sessions.push({
|
|
sessionId,
|
|
ownerUserId: ACTOR.id,
|
|
ownerRole: ACTOR.role,
|
|
agentId: "hwlab-code-agent",
|
|
status: "completed",
|
|
lastTraceId: turnRows.at(-1).traceId,
|
|
projectedSeq: 99,
|
|
sourceSeq: 99,
|
|
terminal: true,
|
|
sealed: true,
|
|
createdAt: turnRows[0].at,
|
|
updatedAt: "2026-06-28T08:45:00.000Z",
|
|
valuesRedacted: true
|
|
});
|
|
turnRows.forEach((row, index) => {
|
|
const userMessageId = `msg_${row.traceId}_user`;
|
|
const agentMessageId = `msg_${row.traceId}_agent`;
|
|
const finishedAt = new Date(Date.parse(row.at) + 5000).toISOString();
|
|
facts.messages.push(
|
|
{ messageId: userMessageId, sessionId, turnId: row.traceId, traceId: row.traceId, role: "user", status: "sent", text: row.prompt, projectedSeq: 100 + index, sourceSeq: 100 + index, createdAt: row.at, updatedAt: row.at, valuesRedacted: true },
|
|
{ messageId: agentMessageId, sessionId, turnId: row.traceId, traceId: row.traceId, role: "agent", status: "completed", text: row.reply, projectedSeq: 200 + index, sourceSeq: 200 + index, terminal: true, sealed: true, createdAt: finishedAt, updatedAt: finishedAt, timing: { startedAt: row.at, lastEventAt: finishedAt, finishedAt, durationMs: 5000, valuesRedacted: true }, valuesRedacted: true }
|
|
);
|
|
facts.parts.push(
|
|
{ partId: `prt_${row.traceId}_user`, messageId: userMessageId, sessionId, turnId: row.traceId, traceId: row.traceId, partIndex: 0, partType: "text", status: "sent", text: row.prompt, projectedSeq: 100 + index, updatedAt: row.at, valuesRedacted: true },
|
|
{ partId: `prt_${row.traceId}_agent`, messageId: agentMessageId, sessionId, turnId: row.traceId, traceId: row.traceId, partIndex: 0, partType: "final_response", status: "completed", text: row.reply, projectedSeq: 200 + index, terminal: true, sealed: true, updatedAt: finishedAt, valuesRedacted: true }
|
|
);
|
|
facts.turns.push({ turnId: row.traceId, sessionId, traceId: row.traceId, messageId: agentMessageId, status: "completed", projectedSeq: row.turnSeq, sourceSeq: row.turnSeq, terminal: true, sealed: true, startedAt: row.at, lastEventAt: finishedAt, finishedAt, durationMs: 5000, updatedAt: finishedAt, valuesRedacted: true });
|
|
facts.checkpoints.push({ traceId: row.traceId, sessionId, turnId: row.traceId, status: "completed", projectionStatus: "caught_up", projectionHealth: "caught-up", projectedSeq: row.turnSeq, sourceSeq: row.turnSeq, terminal: true, sealed: true, startedAt: row.at, lastEventAt: finishedAt, finishedAt, durationMs: 5000, updatedAt: finishedAt, valuesRedacted: true });
|
|
});
|
|
const runtimeStore = createRuntimeStoreFromFacts(facts);
|
|
const accessController = {
|
|
async ensureBootstrap() {},
|
|
async authenticate() { return { ok: true, actor: ACTOR, session: { id: "uss_workbench_reader" } }; }
|
|
};
|
|
const server = createCloudApiServer({ accessController, runtimeStore });
|
|
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
|
|
|
|
try {
|
|
const { port } = server.address();
|
|
const messages = await getJson(port, `/v1/workbench/sessions/${encodeURIComponent(sessionId)}/messages?limit=20`);
|
|
assert.equal(messages.status, 200);
|
|
assert.deepEqual(messages.body.messages.map((message) => message.text), ["sentinel-01", "ok-01", "sentinel-02", "ok-02", "sentinel-03", "ok-03", "sentinel-04", "ok-04", "sentinel-05", "ok-05"]);
|
|
assert.equal(messages.body.roleSequencePrefix, "UAUAUAUAUA");
|
|
assert.equal(messages.body.adjacentSameRoleCount, 0);
|
|
assert.match(messages.body.timelineDigest, /^sha256:[0-9a-f]{64}$/u);
|
|
|
|
const sessions = await getJson(port, `/v1/workbench/sessions?includeSessionId=${encodeURIComponent(sessionId)}`);
|
|
assert.equal(sessions.status, 200);
|
|
assert.equal(sessions.body.sessions[0].title, "sentinel-05");
|
|
assert.equal(sessions.body.sessions[0].preview, "ok-05");
|
|
assert.equal(sessions.body.sessions[0].firstUserMessagePreview, "sentinel-01");
|
|
} finally {
|
|
await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
|
|
}
|
|
});
|
|
|
|
test("workbench session list hides shadowed AgentRun alias rows", async () => {
|
|
const sessionId = "ses_fake_echo_canonical";
|
|
const aliasSessionId = "ses_agentrun_fake_echo_canonical";
|
|
const traceId = "trc_fake_echo_alias";
|
|
const facts = emptyFacts();
|
|
facts.sessions.push(
|
|
{ sessionId: aliasSessionId, ownerUserId: ACTOR.id, ownerRole: ACTOR.role, status: "failed", lastTraceId: traceId, projectedSeq: 20, sourceSeq: 20, updatedAt: "2026-06-28T08:52:18.000Z", valuesRedacted: true },
|
|
{ sessionId, ownerUserId: ACTOR.id, ownerRole: ACTOR.role, status: "completed", lastTraceId: traceId, projectedSeq: 10, sourceSeq: 10, updatedAt: "2026-06-28T08:52:10.000Z", valuesRedacted: true }
|
|
);
|
|
facts.messages.push(
|
|
{ messageId: "msg_fake_user", sessionId, turnId: traceId, traceId, role: "user", status: "sent", text: "ECHO sentinel-01", projectedSeq: 1, sourceSeq: 1, createdAt: "2026-06-28T08:52:00.000Z", updatedAt: "2026-06-28T08:52:00.000Z", valuesRedacted: true },
|
|
{ messageId: "msg_fake_agent", sessionId, turnId: traceId, traceId, role: "agent", status: "completed", text: "ECHO sentinel-01 ok", projectedSeq: 2, sourceSeq: 2, terminal: true, sealed: true, createdAt: "2026-06-28T08:52:05.000Z", updatedAt: "2026-06-28T08:52:05.000Z", valuesRedacted: true }
|
|
);
|
|
facts.parts.push(
|
|
{ partId: "prt_fake_user", messageId: "msg_fake_user", sessionId, turnId: traceId, traceId, partIndex: 0, partType: "text", status: "sent", text: "ECHO sentinel-01", projectedSeq: 1, valuesRedacted: true },
|
|
{ partId: "prt_fake_agent", messageId: "msg_fake_agent", sessionId, turnId: traceId, traceId, partIndex: 0, partType: "final_response", status: "completed", text: "ECHO sentinel-01 ok", projectedSeq: 2, terminal: true, sealed: true, valuesRedacted: true }
|
|
);
|
|
const runtimeStore = createRuntimeStoreFromFacts(facts);
|
|
const accessController = {
|
|
async ensureBootstrap() {},
|
|
async authenticate() { return { ok: true, actor: ACTOR, session: { id: "uss_workbench_reader" } }; }
|
|
};
|
|
const server = createCloudApiServer({ accessController, runtimeStore });
|
|
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
|
|
|
|
try {
|
|
const { port } = server.address();
|
|
const sessions = await getJson(port, "/v1/workbench/sessions?limit=10");
|
|
assert.equal(sessions.status, 200);
|
|
assert.deepEqual(sessions.body.sessions.map((session) => session.sessionId), [sessionId]);
|
|
assert.equal(sessions.body.sessions[0].title, "ECHO sentinel-01");
|
|
assert.equal(sessions.body.sessions[0].preview, "ECHO sentinel-01 ok");
|
|
} finally {
|
|
await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
|
|
}
|
|
});
|
|
|
|
test("workbench trace event continuation returns empty catch-up page instead of 404", async () => {
|
|
const traceId = "trc_workbench_trace_events_catchup";
|
|
const session = {
|
|
id: "ses_workbench_trace_events_catchup",
|
|
projectId: "prj_hwpod_workbench",
|
|
agentId: "hwlab-code-agent",
|
|
status: "running",
|
|
startedAt: "2026-06-27T01:00:00.000Z",
|
|
ownerUserId: ACTOR.id,
|
|
conversationId: "cnv_workbench_trace_events_catchup",
|
|
threadId: "thread-workbench-trace-events-catchup",
|
|
lastTraceId: traceId,
|
|
updatedAt: "2026-06-27T01:00:05.000Z",
|
|
session: {
|
|
sessionStatus: "running",
|
|
messages: [
|
|
{ role: "user", text: "start", traceId, createdAt: "2026-06-27T01:00:00.000Z" }
|
|
],
|
|
valuesRedacted: true,
|
|
secretMaterialStored: false
|
|
}
|
|
};
|
|
const runtimeStore = createDurableFactsRuntimeStore({
|
|
sessions: [{
|
|
session,
|
|
status: "running",
|
|
projectionStatus: "projecting",
|
|
projectionHealth: "projecting",
|
|
lastProjectedSeq: 5,
|
|
events: [
|
|
{ projectedSeq: 1, sourceSeq: 1, type: "request", status: "accepted", label: "request:accepted", createdAt: "2026-06-27T01:00:00.000Z" },
|
|
{ projectedSeq: 2, sourceSeq: 2, type: "tool", status: "running", label: "tool:running", createdAt: "2026-06-27T01:00:05.000Z" }
|
|
]
|
|
}]
|
|
});
|
|
const accessController = {
|
|
async ensureBootstrap() {},
|
|
async authenticate() { return { ok: true, actor: ACTOR, session: { id: "uss_workbench_reader" } }; }
|
|
};
|
|
const server = createCloudApiServer({ accessController, runtimeStore });
|
|
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
|
|
|
|
try {
|
|
const { port } = server.address();
|
|
const response = await getJson(port, `/v1/workbench/traces/${encodeURIComponent(traceId)}/events?afterProjectedSeq=2&limit=100`);
|
|
assert.equal(response.status, 200);
|
|
assert.equal(response.body.status, "projecting");
|
|
assert.deepEqual(response.body.events, []);
|
|
assert.equal(response.body.range.fromProjectedSeq, null);
|
|
assert.equal(response.body.range.toProjectedSeq, null);
|
|
assert.equal(response.body.range.total, 5);
|
|
assert.equal(response.body.nextProjectedSeq, 2);
|
|
assert.equal(response.body.traceLastSeq, 5);
|
|
assert.equal(response.body.fullTraceLoaded, false);
|
|
assert.equal(response.body.projectionStatus, "projecting");
|
|
assert.equal(response.body.projectionHealth, "projecting");
|
|
assert.equal(response.body.diagnostic.code, "workbench_trace_events_missing");
|
|
assert.equal(response.body.blocker, null);
|
|
} finally {
|
|
await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
|
|
}
|
|
});
|
|
|
|
test("workbench terminal timing ignores late projection updatedAt after sealed result (#2132)", async () => {
|
|
const traceId = "trc_workbench_terminal_late_projection_update";
|
|
const session = {
|
|
id: "ses_workbench_terminal_late_projection_update",
|
|
projectId: "prj_hwpod_workbench",
|
|
agentId: "hwlab-code-agent",
|
|
status: "completed",
|
|
startedAt: "2026-06-25T23:07:10.153Z",
|
|
ownerUserId: ACTOR.id,
|
|
conversationId: "cnv_workbench_terminal_late_projection_update",
|
|
threadId: "thread-workbench-terminal-late-projection-update",
|
|
lastTraceId: traceId,
|
|
updatedAt: "2026-06-25T23:08:27.097Z",
|
|
session: {
|
|
sessionStatus: "completed",
|
|
lastTraceId: traceId,
|
|
finalResponse: "P5 durable facts smoke OK",
|
|
messages: [
|
|
{ role: "user", text: "请直接回答：P5 durable facts smoke OK", traceId, status: "sent", createdAt: "2026-06-25T23:07:10.153Z" },
|
|
{ role: "agent", text: "P5 durable facts smoke OK", traceId, status: "completed", createdAt: "2026-06-25T23:07:10.976Z", updatedAt: "2026-06-25T23:08:27.097Z" }
|
|
],
|
|
valuesRedacted: true,
|
|
secretMaterialStored: false
|
|
}
|
|
};
|
|
const facts = emptyFacts();
|
|
mergeFacts(facts, buildDurableFactsForSession({
|
|
session,
|
|
status: "completed",
|
|
finalText: "P5 durable facts smoke OK",
|
|
events: [
|
|
{ projectedSeq: 1, sourceSeq: 1, type: "backend", status: "running", label: "agentrun:backend:admitted", createdAt: "2026-06-25T23:07:10.153Z", updatedAt: "2026-06-25T23:07:10.153Z" },
|
|
{ projectedSeq: 31, sourceSeq: 31, type: "terminal", eventType: "terminal", status: "completed", label: "agentrun:result:completed", terminal: true, createdAt: "2026-06-25T23:07:32.418Z", occurredAt: "2026-06-25T23:07:32.418Z", updatedAt: "2026-06-25T23:08:27.127Z" }
|
|
],
|
|
lastProjectedSeq: 31
|
|
}));
|
|
const checkpointTiming = {
|
|
startedAt: "2026-06-25T23:07:10.153Z",
|
|
lastEventAt: "2026-06-25T23:07:32.418Z",
|
|
finishedAt: "2026-06-25T23:07:32.418Z",
|
|
durationMs: 22265,
|
|
valuesRedacted: true
|
|
};
|
|
const turnTiming = {
|
|
startedAt: "2026-06-25T23:07:10.976Z",
|
|
lastEventAt: "2026-06-25T23:08:27.097Z",
|
|
finishedAt: "2026-06-25T23:07:32.418Z",
|
|
durationMs: 21442,
|
|
valuesRedacted: true
|
|
};
|
|
for (const record of [...facts.sessions, ...facts.messages.filter((message) => message.role !== "user"), ...facts.turns]) {
|
|
Object.assign(record, turnTiming, { timing: turnTiming, updatedAt: "2026-06-25T23:08:27.097Z" });
|
|
}
|
|
Object.assign(facts.checkpoints[0], checkpointTiming, { timing: checkpointTiming, updatedAt: "2026-06-25T23:08:27.127Z" });
|
|
Object.assign(facts.traceEvents.at(-1), checkpointTiming, { timing: checkpointTiming, updatedAt: "2026-06-25T23:08:27.127Z" });
|
|
const runtimeStore = {
|
|
async queryWorkbenchFacts(params = {}) {
|
|
const filtered = filterFacts(facts, params);
|
|
return {
|
|
facts: filtered,
|
|
count: Object.values(filtered).reduce((sum, rows) => sum + rows.length, 0),
|
|
persistence: { adapter: "test-durable-workbench-facts", durable: true }
|
|
};
|
|
}
|
|
};
|
|
const accessController = {
|
|
async ensureBootstrap() {},
|
|
async authenticate() { return { ok: true, actor: ACTOR, session: { id: "uss_workbench_reader" } }; }
|
|
};
|
|
const server = createCloudApiServer({ accessController, workbenchRuntime: runtimeStore, codeAgentChatResults: createCodeAgentChatResultStore() });
|
|
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
|
|
|
|
try {
|
|
const { port } = server.address();
|
|
const turn = await getJson(port, `/v1/workbench/turns/${encodeURIComponent(traceId)}`);
|
|
assert.equal(turn.status, 200);
|
|
assert.equal(turn.body.turn.startedAt, "2026-06-25T23:07:10.153Z");
|
|
assert.equal(turn.body.turn.lastEventAt, "2026-06-25T23:07:32.418Z");
|
|
assert.equal(turn.body.turn.finishedAt, "2026-06-25T23:07:32.418Z");
|
|
assert.equal(turn.body.turn.durationMs, 22265);
|
|
assert.equal(turn.body.turn.trace.updatedAt, "2026-06-25T23:08:27.127Z");
|
|
|
|
const trace = await getJson(port, `/v1/workbench/traces/${encodeURIComponent(traceId)}/events?limit=80`);
|
|
assert.equal(trace.status, 200);
|
|
assert.equal(trace.body.lastEventAt, "2026-06-25T23:07:32.418Z");
|
|
assert.equal(trace.body.finishedAt, "2026-06-25T23:07:32.418Z");
|
|
assert.equal(trace.body.durationMs, 22265);
|
|
assert.equal(trace.body.events.at(-1).updatedAt, "2026-06-25T23:08:27.127Z");
|
|
} finally {
|
|
await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
|
|
}
|
|
});
|
|
|
|
test("workbench read model recovers trace events from durable projection without duplicating final response", async () => {
|
|
const traceStore = createCodeAgentTraceStore();
|
|
const traceId = "trc_workbench_durable_reload";
|
|
const session = {
|
|
id: "ses_workbench_durable_reload",
|
|
projectId: "prj_hwpod_workbench",
|
|
agentId: "hwlab-code-agent",
|
|
status: "completed",
|
|
startedAt: "2026-06-17T01:00:00.000Z",
|
|
endedAt: "2026-06-17T01:00:04.000Z",
|
|
ownerUserId: ACTOR.id,
|
|
conversationId: "cnv_workbench_durable_reload",
|
|
threadId: "thread-workbench-durable-reload",
|
|
lastTraceId: traceId,
|
|
updatedAt: "2026-06-17T01:00:04.000Z",
|
|
session: {
|
|
sessionStatus: "completed",
|
|
lastTraceId: traceId,
|
|
finalResponse: "durable pong",
|
|
messages: [
|
|
{ role: "user", text: "durable ping", traceId, createdAt: "2026-06-17T01:00:00.000Z" },
|
|
{ role: "agent", text: "durable pong", traceId, createdAt: "2026-06-17T01:00:04.000Z" }
|
|
],
|
|
valuesRedacted: true,
|
|
secretMaterialStored: false
|
|
}
|
|
};
|
|
const durableEvents = [
|
|
{ traceId, seq: 1, type: "request", status: "accepted", label: "request:accepted", createdAt: "2026-06-17T01:00:00.000Z", valuesPrinted: false },
|
|
{ traceId, seq: 2, type: "result", status: "completed", label: "result:completed", terminal: true, createdAt: "2026-06-17T01:00:04.000Z", valuesPrinted: false }
|
|
];
|
|
const accessController = {
|
|
store: {
|
|
async getAgentSession(sessionId) { return sessionId === session.id ? session : null; },
|
|
async getAgentSessionByTraceId(requestTraceId) { return requestTraceId === traceId ? session : null; }
|
|
},
|
|
async ensureBootstrap() {},
|
|
async authenticate() { return { ok: true, actor: ACTOR, session: { id: "uss_workbench_reader" } }; }
|
|
};
|
|
const factQueries = [];
|
|
const runtimeStore = createDurableFactsRuntimeStore({
|
|
sessions: [{ session, events: durableEvents, status: "completed", finalText: "durable pong", lastProjectedSeq: 2 }],
|
|
queries: factQueries
|
|
});
|
|
const server = createCloudApiServer({ accessController, traceStore, runtimeStore, codeAgentChatResults: createCodeAgentChatResultStore() });
|
|
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
|
|
|
|
try {
|
|
const { port } = server.address();
|
|
const messages = await getJson(port, `/v1/workbench/sessions/${encodeURIComponent(session.id)}/messages?limit=10`);
|
|
assert.equal(messages.status, 200);
|
|
assert.equal(messages.body.total, 2);
|
|
assert.deepEqual(messages.body.messages.map((message) => message.role), ["user", "agent"]);
|
|
|
|
const turn = await getJson(port, `/v1/workbench/turns/${encodeURIComponent(traceId)}`);
|
|
assert.equal(turn.status, 200);
|
|
assert.equal(turn.body.turn.assistantMessageId, messages.body.messages[1].messageId);
|
|
assert.equal(turn.body.turn.trace.eventCount, 2);
|
|
assert.equal(turn.body.turn.trace.status, "completed");
|
|
|
|
const trace = await getJson(port, `/v1/workbench/traces/${encodeURIComponent(traceId)}/events?limit=10`);
|
|
assert.equal(trace.status, 200);
|
|
assert.equal(trace.body.events.length, 2);
|
|
assert.equal(trace.body.traceStatus, "completed");
|
|
assert.equal(trace.body.hasMore, false);
|
|
assert.ok(factQueries.length >= 3);
|
|
} finally {
|
|
await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
|
|
}
|
|
});
|
|
|
|
test("workbench read model canonicalizes duplicate assistant facts for the same trace", async () => {
|
|
const traceStore = createCodeAgentTraceStore();
|
|
const traceId = "trc_workbench_duplicate_agent_message";
|
|
const preferredMessageId = "msg_workbench_duplicate_agent_message_agent";
|
|
const duplicateMessageId = "msg_3ae9b11ac11c2dcf816980916f1152b0";
|
|
const finalText = "duplicate history final response";
|
|
const session = {
|
|
id: "ses_workbench_duplicate_agent_message",
|
|
projectId: "prj_hwpod_workbench",
|
|
agentId: "hwlab-code-agent",
|
|
status: "completed",
|
|
startedAt: "2026-06-17T01:20:00.000Z",
|
|
endedAt: "2026-06-17T01:20:16.000Z",
|
|
ownerUserId: ACTOR.id,
|
|
conversationId: "cnv_workbench_duplicate_agent_message",
|
|
threadId: "thread-workbench-duplicate-agent-message",
|
|
lastTraceId: traceId,
|
|
updatedAt: "2026-06-17T01:20:16.000Z",
|
|
session: {
|
|
sessionStatus: "completed",
|
|
lastTraceId: traceId,
|
|
messages: [
|
|
{ messageId: "msg_workbench_duplicate_agent_message_user", role: "user", text: "duplicate ping", traceId, createdAt: "2026-06-17T01:20:00.000Z" },
|
|
{ messageId: preferredMessageId, role: "agent", text: "", traceId, status: "completed", createdAt: "2026-06-17T01:20:16.000Z", updatedAt: "2026-06-17T01:20:16.000Z" }
|
|
],
|
|
valuesRedacted: true,
|
|
secretMaterialStored: false
|
|
}
|
|
};
|
|
const facts = buildDurableFactsForSession({
|
|
session,
|
|
events: [
|
|
{ seq: 1, type: "request", status: "accepted", label: "request:accepted", createdAt: "2026-06-17T01:20:00.000Z" },
|
|
{ seq: 2, type: "result", status: "completed", label: "result:completed", terminal: true, createdAt: "2026-06-17T01:20:16.000Z" }
|
|
],
|
|
status: "completed",
|
|
lastProjectedSeq: 2
|
|
});
|
|
facts.turns[0].messageId = duplicateMessageId;
|
|
facts.messages.push({
|
|
messageId: duplicateMessageId,
|
|
sessionId: session.id,
|
|
turnId: traceId,
|
|
traceId,
|
|
role: "agent",
|
|
status: "completed",
|
|
projectedSeq: 9,
|
|
sourceSeq: 9,
|
|
sourceEventId: `${session.id}:message:duplicate-hash`,
|
|
terminal: true,
|
|
sealed: true,
|
|
text: finalText,
|
|
timing: {
|
|
startedAt: "2026-06-17T01:20:00.000Z",
|
|
lastEventAt: "2026-06-17T01:21:48.722Z",
|
|
finishedAt: "2026-06-17T01:21:48.722Z",
|
|
durationMs: 108722,
|
|
status: "completed",
|
|
valuesRedacted: true
|
|
},
|
|
startedAt: "2026-06-17T01:20:00.000Z",
|
|
lastEventAt: "2026-06-17T01:21:48.722Z",
|
|
finishedAt: "2026-06-17T01:21:48.722Z",
|
|
durationMs: 108722,
|
|
createdAt: "2026-06-17T01:20:16.000Z",
|
|
updatedAt: "2026-06-17T01:21:48.722Z",
|
|
valuesRedacted: true
|
|
});
|
|
facts.parts.push({
|
|
partId: "prt_workbench_duplicate_agent_message_hash_final",
|
|
messageId: duplicateMessageId,
|
|
sessionId: session.id,
|
|
turnId: traceId,
|
|
traceId,
|
|
partIndex: 0,
|
|
partType: "final_response",
|
|
status: "completed",
|
|
text: finalText,
|
|
projectedSeq: 9,
|
|
sourceSeq: 9,
|
|
sourceEventId: `${session.id}:part:duplicate-hash`,
|
|
terminal: true,
|
|
sealed: true,
|
|
updatedAt: "2026-06-17T01:21:48.722Z",
|
|
valuesRedacted: true
|
|
});
|
|
const runtimeStore = {
|
|
async queryWorkbenchFacts(params = {}) {
|
|
const filtered = filterFacts(facts, params);
|
|
return {
|
|
facts: filtered,
|
|
count: Object.values(filtered).reduce((sum, rows) => sum + rows.length, 0),
|
|
persistence: { adapter: "test-durable-workbench-facts", durable: true }
|
|
};
|
|
}
|
|
};
|
|
const accessController = {
|
|
store: {
|
|
async getAgentSession(sessionId) { return sessionId === session.id ? session : null; },
|
|
async getAgentSessionByTraceId(requestTraceId) { return requestTraceId === traceId ? session : null; }
|
|
},
|
|
async ensureBootstrap() {},
|
|
async authenticate() { return { ok: true, actor: ACTOR, session: { id: "uss_workbench_reader" } }; }
|
|
};
|
|
const server = createCloudApiServer({ accessController, traceStore, workbenchRuntime: runtimeStore, codeAgentChatResults: createCodeAgentChatResultStore() });
|
|
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
|
|
|
|
try {
|
|
const { port } = server.address();
|
|
const messages = await getJson(port, `/v1/workbench/sessions/${encodeURIComponent(session.id)}/messages?limit=10`);
|
|
assert.equal(messages.status, 200);
|
|
assert.equal(messages.body.total, 2);
|
|
assert.deepEqual(messages.body.messages.map((message) => message.role), ["user", "agent"]);
|
|
const assistant = messages.body.messages[1];
|
|
assert.equal(assistant.messageId, preferredMessageId);
|
|
assert.equal(assistant.text, finalText);
|
|
assert.equal(assistant.parts.length, 1);
|
|
assert.equal(assistant.parts[0].messageId, preferredMessageId);
|
|
assert.equal(assistant.parts[0].type, "final_response");
|
|
assert.equal(assistant.parts[0].text, finalText);
|
|
} finally {
|
|
await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
|
|
}
|
|
});
|
|
|
|
test("workbench read model projects terminal result atomically across session, messages, and turn", async () => {
|
|
const traceStore = createCodeAgentTraceStore();
|
|
const results = createCodeAgentChatResultStore();
|
|
const traceId = "trc_workbench_terminal_atomic";
|
|
const finalText = "terminal projection final response";
|
|
const session = {
|
|
id: "ses_workbench_terminal_atomic",
|
|
projectId: "prj_hwpod_workbench",
|
|
agentId: "hwlab-code-agent",
|
|
status: "running",
|
|
ownerUserId: ACTOR.id,
|
|
conversationId: "cnv_workbench_terminal_atomic",
|
|
threadId: "thread-workbench-terminal-atomic",
|
|
lastTraceId: traceId,
|
|
updatedAt: "2026-06-17T02:10:00.000Z",
|
|
session: {
|
|
sessionStatus: "running",
|
|
lastTraceId: traceId,
|
|
messages: [
|
|
{ role: "user", text: "terminal atomic ping", traceId, status: "sent", createdAt: "2026-06-17T02:09:58.000Z" },
|
|
{ role: "agent", text: "", traceId, status: "running", createdAt: "2026-06-17T02:09:59.000Z" }
|
|
],
|
|
valuesRedacted: true,
|
|
secretMaterialStored: false
|
|
}
|
|
};
|
|
traceStore.append(traceId, { seq: 1, type: "request", status: "accepted", label: "request:accepted" });
|
|
traceStore.append(traceId, { seq: 2, type: "result", status: "completed", label: "result:completed", terminal: true });
|
|
results.set(traceId, {
|
|
status: "completed",
|
|
traceId,
|
|
ownerUserId: ACTOR.id,
|
|
conversationId: session.conversationId,
|
|
sessionId: session.id,
|
|
threadId: session.threadId,
|
|
finalResponse: { text: finalText, status: "completed", traceId },
|
|
agentRun: { runId: "run_workbench_terminal_atomic", commandId: "cmd_workbench_terminal_atomic", status: "completed", terminalStatus: "completed" }
|
|
});
|
|
const accessController = {
|
|
store: {
|
|
async listAgentSessionsForUser() { return [session]; },
|
|
async getAgentSession(sessionId) { return sessionId === session.id ? session : null; },
|
|
async getAgentSessionByTraceId(requestTraceId) { return requestTraceId === traceId ? session : null; }
|
|
},
|
|
async ensureBootstrap() {},
|
|
async authenticate() { return { ok: true, actor: ACTOR, session: { id: "uss_workbench_reader" } }; }
|
|
};
|
|
const runtimeStore = createDurableFactsRuntimeStore({
|
|
sessions: [{
|
|
session,
|
|
events: [
|
|
{ seq: 1, type: "request", status: "accepted", label: "request:accepted", createdAt: "2026-06-17T02:09:58.000Z" },
|
|
{ seq: 2, type: "result", status: "completed", label: "result:completed", terminal: true, createdAt: "2026-06-17T02:10:00.000Z" }
|
|
],
|
|
status: "completed",
|
|
finalText,
|
|
runId: "run_workbench_terminal_atomic",
|
|
commandId: "cmd_workbench_terminal_atomic",
|
|
lastProjectedSeq: 2
|
|
}]
|
|
});
|
|
const server = createCloudApiServer({ accessController, traceStore, runtimeStore, codeAgentChatResults: results });
|
|
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
|
|
|
|
try {
|
|
const { port } = server.address();
|
|
const sessions = await getJson(port, `/v1/workbench/sessions?includeSessionId=${encodeURIComponent(session.id)}`);
|
|
assert.equal(sessions.status, 200);
|
|
assert.equal(sessions.body.sessions[0].status, "completed");
|
|
assert.equal(sessions.body.sessions[0].running, false);
|
|
assert.equal(sessions.body.sessions[0].terminal, true);
|
|
|
|
const messages = await getJson(port, `/v1/workbench/sessions/${encodeURIComponent(session.id)}/messages?limit=10`);
|
|
assert.equal(messages.status, 200);
|
|
assert.equal(messages.body.total, 2);
|
|
const assistant = messages.body.messages[1];
|
|
assert.equal(assistant.role, "agent");
|
|
assert.equal(assistant.status, "completed");
|
|
assert.equal(assistant.text, finalText);
|
|
assert.equal(assistant.parts[0].status, "completed");
|
|
assert.equal(assistant.parts[0].type, "final_response");
|
|
assert.equal(assistant.parts[0].messageId, assistant.messageId);
|
|
assert.equal(assistant.parts[0].traceId, traceId);
|
|
assert.equal(assistant.parts[0].text, finalText);
|
|
|
|
const turn = await getJson(port, `/v1/workbench/turns/${encodeURIComponent(traceId)}`);
|
|
assert.equal(turn.status, 200);
|
|
assert.equal(turn.body.turn.status, "completed");
|
|
assert.equal(turn.body.turn.terminal, true);
|
|
assert.equal(turn.body.turn.assistantMessageId, assistant.messageId);
|
|
assert.equal(turn.body.turn.assistantText, finalText);
|
|
assert.equal(turn.body.turn.finalResponse.source, "message-part");
|
|
assert.equal(turn.body.turn.finalResponse.sealed, true);
|
|
assert.equal(turn.body.turn.finalResponse.text, finalText);
|
|
} finally {
|
|
await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
|
|
}
|
|
});
|
|
|
|
test("workbench read model seals turn from terminal message projection when checkpoint is stale", async () => {
|
|
const sessionId = "ses_workbench_terminal_message_stale_checkpoint";
|
|
const traceId = "trc_terminal_message_stale_checkpoint";
|
|
const finalText = "terminal message projection must close the visible turn";
|
|
const startedAt = "2026-06-29T22:09:32.000Z";
|
|
const finishedAt = "2026-06-29T22:09:47.000Z";
|
|
const facts = emptyFacts();
|
|
facts.sessions.push({
|
|
sessionId,
|
|
ownerUserId: ACTOR.id,
|
|
ownerRole: ACTOR.role,
|
|
agentId: "hwlab-code-agent",
|
|
status: "running",
|
|
lastTraceId: traceId,
|
|
projectedSeq: 33,
|
|
sourceSeq: 36,
|
|
createdAt: startedAt,
|
|
updatedAt: finishedAt,
|
|
valuesRedacted: true
|
|
});
|
|
facts.messages.push(
|
|
{ messageId: "msg_stale_user", sessionId, turnId: traceId, traceId, role: "user", status: "sent", text: "hi", projectedSeq: 31, sourceSeq: 31, createdAt: startedAt, updatedAt: startedAt, valuesRedacted: true },
|
|
{ messageId: "msg_stale_agent", sessionId, turnId: traceId, traceId, role: "agent", status: "completed", text: finalText, projectedSeq: 36, sourceSeq: 36, terminal: true, sealed: true, timing: { startedAt, lastEventAt: finishedAt, finishedAt, durationMs: 15000, valuesRedacted: true }, startedAt, lastEventAt: finishedAt, finishedAt, durationMs: 15000, createdAt: startedAt, updatedAt: finishedAt, valuesRedacted: true }
|
|
);
|
|
facts.parts.push(
|
|
{ partId: "prt_stale_user", messageId: "msg_stale_user", sessionId, turnId: traceId, traceId, partIndex: 0, partType: "text", status: "sent", text: "hi", projectedSeq: 31, sourceSeq: 31, updatedAt: startedAt, valuesRedacted: true },
|
|
{ partId: "prt_stale_agent", messageId: "msg_stale_agent", sessionId, turnId: traceId, traceId, partIndex: 0, partType: "final_response", status: "completed", text: finalText, projectedSeq: 36, sourceSeq: 36, terminal: true, sealed: true, updatedAt: finishedAt, valuesRedacted: true }
|
|
);
|
|
facts.turns.push({ turnId: traceId, sessionId, traceId, messageId: "msg_stale_agent", status: "running", projectedSeq: 33, sourceSeq: 33, terminal: false, sealed: false, startedAt, lastEventAt: finishedAt, updatedAt: finishedAt, valuesRedacted: true });
|
|
facts.checkpoints.push({ traceId, sessionId, turnId: traceId, runId: "run_stale_checkpoint", commandId: "cmd_stale_checkpoint", status: "running", projectionStatus: "projecting", projectionHealth: "degraded", projectedSeq: 33, sourceSeq: 33, terminal: false, sealed: false, startedAt, lastEventAt: finishedAt, updatedAt: finishedAt, valuesRedacted: true });
|
|
const runtimeStore = createRuntimeStoreFromFacts(facts);
|
|
const accessController = {
|
|
async ensureBootstrap() {},
|
|
async authenticate() { return { ok: true, actor: ACTOR, session: { id: "uss_workbench_reader" } }; }
|
|
};
|
|
const server = createCloudApiServer({ accessController, runtimeStore });
|
|
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
|
|
|
|
try {
|
|
const { port } = server.address();
|
|
const sessions = await getJson(port, `/v1/workbench/sessions?includeSessionId=${encodeURIComponent(sessionId)}`);
|
|
assert.equal(sessions.status, 200);
|
|
assert.equal(sessions.body.sessions[0].status, "completed");
|
|
assert.equal(sessions.body.sessions[0].running, false);
|
|
assert.equal(sessions.body.sessions[0].terminal, true);
|
|
|
|
const messages = await getJson(port, `/v1/workbench/sessions/${encodeURIComponent(sessionId)}/messages?limit=10`);
|
|
assert.equal(messages.status, 200);
|
|
const assistant = messages.body.messages.find((message) => message.role === "agent");
|
|
assert.equal(assistant.status, "completed");
|
|
assert.equal(assistant.text, finalText);
|
|
|
|
const turn = await getJson(port, `/v1/workbench/turns/${encodeURIComponent(traceId)}`);
|
|
assert.equal(turn.status, 200);
|
|
assert.equal(turn.body.turn.status, "completed");
|
|
assert.equal(turn.body.turn.running, false);
|
|
assert.equal(turn.body.turn.terminal, true);
|
|
assert.equal(turn.body.turn.finalResponse.text, finalText);
|
|
} finally {
|
|
await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
|
|
}
|
|
});
|
|
|
|
test("workbench read model exposes failed terminal body when final response part is missing", async () => {
|
|
const sessionId = "ses_workbench_failed_terminal_missing_part";
|
|
const traceId = "trc_failed_terminal_missing_part";
|
|
const startedAt = "2026-06-29T22:19:32.000Z";
|
|
const finishedAt = "2026-06-29T22:19:47.000Z";
|
|
const facts = emptyFacts();
|
|
facts.sessions.push({
|
|
sessionId,
|
|
ownerUserId: ACTOR.id,
|
|
ownerRole: ACTOR.role,
|
|
agentId: "hwlab-code-agent",
|
|
status: "failed",
|
|
lastTraceId: traceId,
|
|
projectedSeq: 40,
|
|
sourceSeq: 40,
|
|
terminal: true,
|
|
sealed: true,
|
|
createdAt: startedAt,
|
|
updatedAt: finishedAt,
|
|
valuesRedacted: true
|
|
});
|
|
facts.messages.push(
|
|
{ messageId: "msg_failed_missing_part_user", sessionId, turnId: traceId, traceId, role: "user", status: "sent", text: "hi", projectedSeq: 39, sourceSeq: 39, createdAt: startedAt, updatedAt: startedAt, valuesRedacted: true },
|
|
{ messageId: "msg_failed_missing_part_agent", sessionId, turnId: traceId, traceId, role: "agent", status: "failed", text: "", projectedSeq: 40, sourceSeq: 40, terminal: true, sealed: true, timing: { startedAt, lastEventAt: finishedAt, finishedAt, durationMs: 15000, valuesRedacted: true }, startedAt, lastEventAt: finishedAt, finishedAt, durationMs: 15000, createdAt: startedAt, updatedAt: finishedAt, valuesRedacted: true }
|
|
);
|
|
facts.turns.push({ turnId: traceId, sessionId, traceId, messageId: "msg_failed_missing_part_agent", status: "failed", projectedSeq: 40, sourceSeq: 40, terminal: true, sealed: true, finalResponse: null, diagnostic: { blocker: { code: "provider-stream-disconnected", message: "provider stream disconnected" }, projectionStatus: "caught_up", projectionHealth: "healthy", valuesRedacted: true }, startedAt, lastEventAt: finishedAt, finishedAt, durationMs: 15000, updatedAt: finishedAt, valuesRedacted: true });
|
|
facts.checkpoints.push({ traceId, sessionId, turnId: traceId, runId: "run_failed_missing_part", commandId: "cmd_failed_missing_part", status: "failed", projectionStatus: "caught_up", projectionHealth: "healthy", projectedSeq: 40, sourceSeq: 40, terminal: true, sealed: true, diagnostic: { blocker: { code: "provider-stream-disconnected", message: "provider stream disconnected" }, valuesRedacted: true }, startedAt, lastEventAt: finishedAt, finishedAt, durationMs: 15000, updatedAt: finishedAt, valuesRedacted: true });
|
|
const runtimeStore = createRuntimeStoreFromFacts(facts);
|
|
const accessController = {
|
|
async ensureBootstrap() {},
|
|
async authenticate() { return { ok: true, actor: ACTOR, session: { id: "uss_workbench_reader" } }; }
|
|
};
|
|
const server = createCloudApiServer({ accessController, runtimeStore });
|
|
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
|
|
|
|
try {
|
|
const { port } = server.address();
|
|
const sessions = await getJson(port, `/v1/workbench/sessions?includeSessionId=${encodeURIComponent(sessionId)}`);
|
|
assert.equal(sessions.status, 200);
|
|
assert.equal(sessions.body.sessions[0].status, "failed");
|
|
assert.equal(sessions.body.sessions[0].terminal, true);
|
|
|
|
const messages = await getJson(port, `/v1/workbench/sessions/${encodeURIComponent(sessionId)}/messages?limit=10`);
|
|
assert.equal(messages.status, 200);
|
|
const assistant = messages.body.messages.find((message) => message.role === "agent");
|
|
assert.equal(assistant.status, "failed");
|
|
assert.match(assistant.text, /provider-stream-disconnected/u);
|
|
assert.equal(assistant.parts[0].type, "final_response");
|
|
assert.match(assistant.parts[0].text, /provider-stream-disconnected/u);
|
|
|
|
const turn = await getJson(port, `/v1/workbench/turns/${encodeURIComponent(traceId)}`);
|
|
assert.equal(turn.status, 200);
|
|
assert.equal(turn.body.turn.status, "failed");
|
|
assert.equal(turn.body.turn.running, false);
|
|
assert.equal(turn.body.turn.terminal, true);
|
|
assert.match(turn.body.turn.finalResponse.text, /provider-stream-disconnected/u);
|
|
} finally {
|
|
await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
|
|
}
|
|
});
|
|
|
|
test("workbench read model does not expose trace-only memory without visible session or result owner", async () => {
|
|
const traceStore = createCodeAgentTraceStore();
|
|
const traceId = "trc_workbench_trace_only";
|
|
traceStore.append(traceId, { type: "request", status: "accepted", label: "request:accepted" });
|
|
const accessController = {
|
|
store: {
|
|
async getAgentSessionByTraceId() { return null; }
|
|
},
|
|
async ensureBootstrap() {},
|
|
async authenticate() { return { ok: true, actor: ACTOR, session: { id: "uss_workbench_reader" } }; }
|
|
};
|
|
const server = createCloudApiServer({ accessController, traceStore, codeAgentChatResults: createCodeAgentChatResultStore() });
|
|
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
|
|
|
|
try {
|
|
const { port } = server.address();
|
|
const turn = await getJson(port, `/v1/workbench/turns/${encodeURIComponent(traceId)}`);
|
|
assert.equal(turn.status, 404);
|
|
assert.equal(turn.body.error.code, "workbench_turn_not_found");
|
|
|
|
const trace = await getJson(port, `/v1/workbench/traces/${encodeURIComponent(traceId)}/events`);
|
|
assert.equal(trace.status, 404);
|
|
assert.equal(trace.body.error.code, "workbench_trace_not_found");
|
|
} finally {
|
|
await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
|
|
}
|
|
});
|
|
|
|
test("workbench trace events reports metadata gap when turn projection is visible", async () => {
|
|
const traceStore = createCodeAgentTraceStore();
|
|
const traceId = "trc_workbench_trace_metadata_gap";
|
|
const session = {
|
|
id: "ses_workbench_trace_metadata_gap",
|
|
projectId: "prj_hwpod_workbench",
|
|
agentId: "hwlab-code-agent",
|
|
status: "completed",
|
|
ownerUserId: ACTOR.id,
|
|
conversationId: "cnv_workbench_trace_metadata_gap",
|
|
threadId: "thread-workbench-trace-metadata-gap",
|
|
lastTraceId: traceId,
|
|
updatedAt: "2026-06-20T13:00:00.000Z",
|
|
session: { sessionStatus: "completed", lastTraceId: traceId, messages: [{ role: "user", text: "metadata gap", traceId }, { role: "agent", text: "OK", traceId }] }
|
|
};
|
|
const accessController = {
|
|
store: {},
|
|
async ensureBootstrap() {},
|
|
async authenticate() { return { ok: true, actor: ACTOR, session: { id: "uss_workbench_reader" } }; }
|
|
};
|
|
const runtimeStore = createDurableFactsRuntimeStore({
|
|
sessions: [{ session, events: [], status: "completed", finalText: "OK", runId: "run_workbench_trace_metadata_gap", commandId: "cmd_workbench_trace_metadata_gap", lastProjectedSeq: 2, omitSessions: true }]
|
|
});
|
|
const server = createCloudApiServer({ accessController, traceStore, runtimeStore, codeAgentChatResults: createCodeAgentChatResultStore() });
|
|
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
|
|
|
|
try {
|
|
const { port } = server.address();
|
|
const turn = await getJson(port, `/v1/workbench/turns/${encodeURIComponent(traceId)}`);
|
|
assert.equal(turn.status, 200);
|
|
assert.equal(turn.body.turn.status, "completed");
|
|
|
|
const trace = await getJson(port, `/v1/workbench/traces/${encodeURIComponent(traceId)}/events?limit=10`);
|
|
assert.equal(trace.status, 404);
|
|
assert.equal(trace.body.error.code, "workbench_trace_metadata_missing");
|
|
assert.equal(trace.body.error.message, "Workbench trace metadata is missing from the trace events read model.");
|
|
assert.equal(trace.body.error.projectionStatus, "blocked");
|
|
assert.equal(trace.body.error.projectionHealth, "degraded");
|
|
assert.equal(trace.body.error.lastProjectedSeq, 2);
|
|
assert.equal(trace.body.error.sourceRunId, "run_workbench_trace_metadata_gap");
|
|
assert.equal(trace.body.error.sourceCommandId, "cmd_workbench_trace_metadata_gap");
|
|
assert.equal(trace.body.error.blocker.code, "workbench_trace_metadata_missing");
|
|
assert.notEqual(trace.body.error.message, "Workbench trace is not visible to the current actor.");
|
|
} finally {
|
|
await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
|
|
}
|
|
});
|