mirror of
https://github.com/hanzoai/dev-desktop.git
synced 2026-11-20 01:07:23 +00:00
187 lines
7.1 KiB
TypeScript
187 lines
7.1 KiB
TypeScript
// @effect-diagnostics nodeBuiltinImport:off
|
|
import * as NodeChildProcess from "node:child_process";
|
|
import * as NodeFS from "node:fs";
|
|
import * as NodeReadline from "node:readline";
|
|
import * as NodeURL from "node:url";
|
|
|
|
import { describe, expect, it } from "@effect/vitest";
|
|
|
|
import { parseReplayTurns, SCENARIOS, streamChunks } from "./dev-replay-agent.ts";
|
|
|
|
interface AgentMessage {
|
|
readonly id?: number;
|
|
readonly method?: string;
|
|
readonly params?: {
|
|
readonly update?: {
|
|
readonly sessionUpdate?: string;
|
|
readonly toolCallId?: string;
|
|
readonly status?: string;
|
|
};
|
|
};
|
|
readonly result?: { readonly sessionId?: string; readonly stopReason?: string };
|
|
readonly error?: { readonly code?: number };
|
|
}
|
|
|
|
/**
|
|
* Runs the agent over stdio and returns every message it sent until each request is answered.
|
|
* Permission requests get `permissionResult`.
|
|
*/
|
|
async function talkToAgent(
|
|
requests: ReadonlyArray<(sessionId: string) => object>,
|
|
permissionResult: object = { outcome: { outcome: "selected", optionId: "allow-once" } },
|
|
) {
|
|
const agent = NodeChildProcess.spawn(
|
|
process.execPath,
|
|
[NodeURL.fileURLToPath(new URL("./dev-replay-agent.ts", import.meta.url))],
|
|
{ stdio: ["pipe", "pipe", "inherit"] },
|
|
);
|
|
const lines = NodeReadline.createInterface({ input: agent.stdout })[Symbol.asyncIterator]();
|
|
const received: Array<AgentMessage> = [];
|
|
let sessionId = "";
|
|
try {
|
|
for (const [index, request] of requests.entries()) {
|
|
agent.stdin.write(
|
|
`${JSON.stringify({ jsonrpc: "2.0", id: index + 1, ...request(sessionId) })}\n`,
|
|
);
|
|
for (;;) {
|
|
const message = JSON.parse((await lines.next()).value as string) as AgentMessage;
|
|
received.push(message);
|
|
if (message.method === "session/request_permission") {
|
|
const answer = { jsonrpc: "2.0", id: message.id, result: permissionResult };
|
|
agent.stdin.write(`${JSON.stringify(answer)}\n`);
|
|
}
|
|
if (message.id !== index + 1 || message.method !== undefined) continue;
|
|
sessionId = message.result?.sessionId ?? sessionId;
|
|
break;
|
|
}
|
|
}
|
|
} finally {
|
|
agent.kill();
|
|
}
|
|
return { sessionId, received };
|
|
}
|
|
|
|
describe("dev replay agent", () => {
|
|
it("keeps sessions and tool ids unique across processes and reloads", async () => {
|
|
const prompt = (sessionId: string) => ({ method: "session/prompt", params: { sessionId } });
|
|
const selectTodoList = (sessionId: string) => ({
|
|
method: "session/set_model",
|
|
params: { sessionId, modelId: "todo-list" },
|
|
});
|
|
const run = () =>
|
|
talkToAgent([
|
|
() => ({ method: "session/new", params: { cwd: "/tmp" } }),
|
|
selectTodoList,
|
|
prompt,
|
|
prompt,
|
|
]);
|
|
const [first, second] = await Promise.all([run(), run()]);
|
|
expect(first.sessionId).not.toBe(second.sessionId);
|
|
// A server restart loads the same session in a new agent process.
|
|
const reloaded = await talkToAgent([
|
|
() => ({ method: "session/load", params: { sessionId: first.sessionId, cwd: "/tmp" } }),
|
|
() => selectTodoList(first.sessionId),
|
|
() => prompt(first.sessionId),
|
|
]);
|
|
const toolCallIds = [...first.received, ...reloaded.received].flatMap((message) =>
|
|
message.params?.update?.toolCallId === undefined ? [] : [message.params.update.toolCallId],
|
|
);
|
|
expect(new Set(toolCallIds).size).toBe(6);
|
|
});
|
|
|
|
it.each(SCENARIOS)("$id plays a turn without session setup frames", ({ file }) => {
|
|
const turns = parseReplayTurns(NodeFS.readFileSync(new URL(file, import.meta.url), "utf8"));
|
|
expect(turns.length).toBeGreaterThan(0);
|
|
const updates = turns.flatMap((turn) =>
|
|
turn.frames.flatMap(({ frame }) =>
|
|
frame.method === "session/update"
|
|
? [(frame.params as { update: { sessionUpdate: string } }).update.sessionUpdate]
|
|
: [],
|
|
),
|
|
);
|
|
expect(updates).toContain("agent_message_chunk");
|
|
expect(updates).not.toContain("available_commands_update");
|
|
});
|
|
|
|
it("keeps permission requests and the recorded stop reason in order", () => {
|
|
const turns = parseReplayTurns(
|
|
NodeFS.readFileSync(new URL(SCENARIOS[0].file, import.meta.url), "utf8"),
|
|
);
|
|
const methods = turns[0]!.frames.map(({ frame }) => frame.method);
|
|
expect(methods).toContain("session/request_permission");
|
|
expect(turns[0]!.stopReason).toBe("end_turn");
|
|
});
|
|
|
|
it("rejects an unknown scenario instead of playing another one", async () => {
|
|
const { received } = await talkToAgent([
|
|
() => ({ method: "session/new", params: { cwd: "/tmp" } }),
|
|
(sessionId) => ({ method: "session/set_model", params: { sessionId, modelId: "typo" } }),
|
|
]);
|
|
expect(received.at(-1)?.error?.code).toBe(-32602);
|
|
});
|
|
|
|
it("ends the turn with a failed tool call when the user rejects an approval", async () => {
|
|
const { received } = await talkToAgent(
|
|
[
|
|
() => ({ method: "session/new", params: { cwd: "/tmp" } }),
|
|
(sessionId) => ({ method: "session/prompt", params: { sessionId } }),
|
|
],
|
|
{ outcome: { outcome: "selected", optionId: "reject-once" } },
|
|
);
|
|
const updates = received.flatMap((message) =>
|
|
message.params?.update === undefined ? [] : [message.params.update],
|
|
);
|
|
expect(updates.at(-1)).toMatchObject({ sessionUpdate: "tool_call_update", status: "failed" });
|
|
expect(updates.some((update) => update.toolCallId?.endsWith("showcase-test"))).toBe(false);
|
|
expect(received.at(-1)?.result?.stopReason).toBe("end_turn");
|
|
});
|
|
|
|
it("ends the turn as cancelled when the client cancels an open approval", async () => {
|
|
const { received } = await talkToAgent(
|
|
[
|
|
() => ({ method: "session/new", params: { cwd: "/tmp" } }),
|
|
(sessionId) => ({ method: "session/prompt", params: { sessionId } }),
|
|
],
|
|
{ outcome: { outcome: "cancelled" } },
|
|
);
|
|
const requestIndex = received.findIndex(
|
|
(message) => message.method === "session/request_permission",
|
|
);
|
|
expect(received.slice(requestIndex + 1).some((message) => message.method !== undefined)).toBe(
|
|
false,
|
|
);
|
|
expect(received.at(-1)?.result?.stopReason).toBe("cancelled");
|
|
});
|
|
|
|
it("leaves frames after a prompt's response out of that turn", () => {
|
|
const update = (text: string) => ({
|
|
type: "emit_inbound",
|
|
frame: {
|
|
kind: "notification",
|
|
method: "session/update",
|
|
params: {
|
|
update: { sessionUpdate: "agent_message_chunk", content: { type: "text", text } },
|
|
},
|
|
},
|
|
});
|
|
const transcript = [
|
|
{ type: "expect_outbound", frame: { kind: "request", method: "session/prompt" } },
|
|
update("root"),
|
|
{ type: "emit_inbound", frame: { kind: "response", method: "session/prompt", result: {} } },
|
|
update("background"),
|
|
]
|
|
.map((entry) => JSON.stringify(entry))
|
|
.join("\n");
|
|
const turns = parseReplayTurns(transcript);
|
|
expect(turns).toHaveLength(1);
|
|
expect(turns[0]!.frames).toHaveLength(1);
|
|
});
|
|
|
|
it("streams text in chunks that rebuild the original", () => {
|
|
const text = "One two three four five\n\n```ts\nx\n```";
|
|
const chunks = streamChunks(text);
|
|
expect(chunks.length).toBeGreaterThan(1);
|
|
expect(chunks.join("")).toBe(text);
|
|
});
|
|
});
|