The best way to control Claude Code, Codex and more from any computer or phone

main
ts 1,697 lines 64.5 KB
Raw
1 // @effect-diagnostics nodeBuiltinImport:off
2 import * as NodePath from "node:path";
3 import * as NodeOS from "node:os";
4 import * as NodeURL from "node:url";
5 import * as NodeFS from "node:fs";
6
7 import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
8 import * as NodeServices from "@effect/platform-node/NodeServices";
9 import * as Layer from "effect/Layer";
10 import { assert, it } from "@effect/vitest";
11 import * as HostProcess from "@t3tools/shared/HostProcess";
12 import * as Deferred from "effect/Deferred";
13 import * as Effect from "effect/Effect";
14 import * as Exit from "effect/Exit";
15 import * as Fiber from "effect/Fiber";
16 import * as Scope from "effect/Scope";
17 import * as Result from "effect/Result";
18 import * as Scheduler from "effect/Scheduler";
19 import * as Stream from "effect/Stream";
20 import * as TestClock from "effect/testing/TestClock";
21 import { ChildProcessSpawner } from "effect/process";
22 import { describe, expect } from "vite-plus/test";
23
24 import * as AcpSessionRuntime from "@t3tools/provider-acp/server/AcpSessionRuntime";
25 import { AgentScope } from "@t3tools/shared/AgentScope";
26 import * as EffectAcpErrors from "effect-acp/errors";
27 import type * as EffectAcpSchema from "effect-acp/compat";
28 import type * as EffectAcpProtocol from "effect-acp/protocol";
29
30 const __dirname = NodePath.dirname(NodeURL.fileURLToPath(import.meta.url));
31 const mockAgentPath = NodePath.join(__dirname, "../../../scripts/acp-mock-agent.ts");
32 const mockAgentCommand = "node";
33 const mockAgentArgs = [mockAgentPath];
34 const mockRuntimeOptions = {
35 spawn: { command: mockAgentCommand, args: mockAgentArgs },
36 cwd: process.cwd(),
37 clientInfo: { name: "t3-test", version: "0.0.0" },
38 authMethodId: "test",
39 } satisfies AcpSessionRuntime.AcpSessionRuntimeOptions;
40
41 // The spawner extends the real process environment, so the test must set it there.
42 const setProcessEnv = (name: string, value: string) => {
43 const previous = process.env[name];
44 process.env[name] = value;
45 return () => {
46 if (previous === undefined) delete process.env[name];
47 else process.env[name] = previous;
48 };
49 };
50
51 const isPromptStarted = (event: AcpSessionRuntime.AcpSessionRequestLogEvent) =>
52 event.method === "session/prompt" && event.status === "started";
53
54 const isOutgoing = (tag: string) => (event: EffectAcpProtocol.AcpProtocolLogEvent) =>
55 event.direction === "outgoing" &&
56 event.stage === "decoded" &&
57 typeof event.payload === "object" &&
58 event.payload !== null &&
59 Reflect.get(event.payload, "tag") === tag;
60
61 // The methods the mock agent read, in order, keeping only the given ones.
62 const readReceived = (requestLogPath: string, methods: ReadonlyArray<string>) =>
63 NodeFS.readFileSync(requestLogPath, "utf8")
64 .split("\n")
65 .filter((line) => line.length > 0)
66 .map((line) => (JSON.parse(line) as { readonly method?: string }).method)
67 .filter((method) => method !== undefined && methods.includes(method));
68
69 // Prompts, then cancels while the prompt is held on its way out: in its started request record,
70 // in its outgoing protocol log record, or by its fiber yielding every few operations. The cancel
71 // comes on dispatch or from inside the held record. Returns the prompt's exit
72 // and the order in which the agent read the prompt, the cancel and the request that ends it.
73 const promptThenCancel = (input: {
74 readonly cancelBehavior: "interrupt" | "wait-for-prompt";
75 readonly holdPrompt: {
76 readonly in: "request-log" | "protocol-log" | "scheduler";
77 readonly cancelOn: "dispatch" | "log";
78 };
79 }) =>
80 Effect.gen(function* () {
81 const tempDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "acp-runtime-"));
82 yield* Effect.addFinalizer(() =>
83 Effect.sync(() => NodeFS.rmSync(tempDir, { recursive: true, force: true })),
84 );
85 const requestLogPath = NodePath.join(tempDir, "requests.ndjson");
86 const { holdPrompt } = input;
87 const promptHeld = yield* Deferred.make<void>();
88 const promptReleased = yield* Deferred.make<void>();
89 yield* Effect.addFinalizer(() => Deferred.succeed(promptReleased, undefined));
90 const testScope = yield* Scope.Scope;
91 const runtimeMade = yield* Deferred.make<AcpSessionRuntime.AcpSessionRuntime["Service"]>();
92 const cancelledFromLog = yield* Deferred.make<Fiber.Fiber<void, EffectAcpErrors.AcpError>>();
93 const hold = (
94 holdPrompt.cancelOn === "log"
95 ? Deferred.await(runtimeMade).pipe(
96 Effect.flatMap((made) =>
97 made.cancel.pipe(Effect.forkIn(testScope, { startImmediately: true })),
98 ),
99 Effect.flatMap((fiber) => Deferred.succeed(cancelledFromLog, fiber)),
100 )
101 : Effect.void
102 ).pipe(
103 Effect.andThen(Deferred.succeed(promptHeld, undefined)),
104 Effect.andThen(Deferred.await(promptReleased)),
105 );
106 const runtime = yield* AcpSessionRuntime.make({
107 ...mockRuntimeOptions,
108 spawn: {
109 ...mockRuntimeOptions.spawn,
110 env: {
111 T3_ACP_COMPLETE_FIRST_PROMPT_ON_CANCEL: "1",
112 T3_ACP_REQUEST_LOG_PATH: requestLogPath,
113 },
114 },
115 cancelBehavior: input.cancelBehavior,
116 interruptPromptOnCancel: false,
117 protocolLogging: {
118 logOutgoing: holdPrompt.in === "protocol-log",
119 logger: (event) => (isOutgoing("session/prompt")(event) ? hold : Effect.void),
120 },
121 requestLogger: (event) =>
122 holdPrompt.in === "request-log" && isPromptStarted(event) ? hold : Effect.void,
123 });
124 yield* Deferred.succeed(runtimeMade, runtime);
125 const cancelReceived = yield* Deferred.make<void>();
126 yield* runtime.getEvents().pipe(
127 Stream.runForEach((event) => {
128 if (event._tag === "EventStreamBarrier") {
129 return Deferred.succeed(event.acknowledge, undefined);
130 }
131 if (event._tag === "ThoughtDelta" && event.text === "native-cancel-received") {
132 return Deferred.succeed(cancelReceived, undefined);
133 }
134 return Effect.void;
135 }),
136 Effect.forkChild,
137 );
138 yield* runtime.start();
139 const dispatched = yield* Deferred.make<void>();
140 const prompt = yield* runtime
141 .prompt({ prompt: [{ type: "text", text: "first" }] }, { dispatched })
142 .pipe(
143 holdPrompt.in === "scheduler"
144 ? Effect.provideService(Scheduler.MaxOpsBeforeYield, 3)
145 : (effect) => effect,
146 Effect.forkChild,
147 );
148 // A round trip: whatever was queued before it reaches the agent first.
149 const roundTrip = runtime.request("_test/environment", {});
150 let cancel: Fiber.Fiber<void, EffectAcpErrors.AcpError>;
151 if (holdPrompt.in === "scheduler") {
152 yield* Deferred.await(dispatched);
153 cancel = yield* runtime.cancel.pipe(Effect.forkChild({ startImmediately: true }));
154 } else {
155 yield* Deferred.await(promptHeld);
156 if (holdPrompt.cancelOn === "dispatch") {
157 cancel = yield* Deferred.await(dispatched).pipe(
158 Effect.andThen(runtime.cancel),
159 Effect.forkChild({ startImmediately: true }),
160 );
161 } else {
162 cancel = yield* Deferred.await(cancelledFromLog);
163 }
164 yield* roundTrip;
165 yield* Deferred.succeed(promptReleased, undefined);
166 }
167 yield* Deferred.await(cancelReceived);
168 yield* runtime.request("_test/finish-cancel", {});
169 // The agent answers it only after reading every earlier line.
170 yield* roundTrip;
171 const received = readReceived(requestLogPath, [
172 "session/prompt",
173 "session/cancel",
174 "_test/finish-cancel",
175 ]);
176 const promptExit = yield* Fiber.await(prompt);
177 yield* Fiber.join(cancel);
178 return { received, promptExit };
179 }).pipe(Effect.scoped);
180
181 describe("AcpSessionRuntime", () => {
182 it.effect.each(["session/new", "session/resume"] as const)(
183 "buffers root metadata while %s startup is still pending",
184 (setupMethod) =>
185 Effect.gen(function* () {
186 const setupReplied = yield* Deferred.make<void>();
187 const allowStartup = yield* Deferred.make<void>();
188 const events: Array<AcpSessionRuntime.AcpSessionRuntimeEvent> = [];
189 const runtime = yield* AcpSessionRuntime.make({
190 ...mockRuntimeOptions,
191 ...(setupMethod === "session/resume"
192 ? {
193 spawn: {
194 ...mockRuntimeOptions.spawn,
195 env: { T3_ACP_SESSION_LIFECYCLE: "1" },
196 },
197 resumeSessionId: "mock-session-1",
198 resumeMethod: "resume" as const,
199 }
200 : {}),
201 requestLogger: (event) =>
202 event.method === setupMethod && event.status === "succeeded"
203 ? Deferred.succeed(setupReplied, undefined).pipe(
204 Effect.andThen(Deferred.await(allowStartup)),
205 )
206 : Effect.void,
207 });
208 yield* runtime.getEvents().pipe(
209 Stream.runForEach((event) => {
210 if (event._tag === "EventStreamBarrier") {
211 return Deferred.succeed(event.acknowledge, undefined);
212 }
213 events.push(event);
214 return Effect.void;
215 }),
216 Effect.forkChild,
217 );
218 const startup = yield* runtime.start().pipe(Effect.forkChild);
219 yield* Deferred.await(setupReplied);
220 yield* runtime.request("_test/startup-metadata", {});
221 yield* Deferred.succeed(allowStartup, undefined);
222 yield* Fiber.join(startup);
223 yield* runtime.drainEvents;
224
225 expect(events.map((event) => event._tag)).toEqual([
226 "AvailableCommandsUpdated",
227 "ModeChanged",
228 "ConfigOptionsUpdated",
229 ]);
230 expect(events[0]).toMatchObject({
231 availableCommands: [{ name: "plan", description: "Native command" }],
232 });
233 expect(yield* runtime.getModeState).toMatchObject({ currentModeId: "code" });
234 expect(events[2]).toMatchObject({
235 configOptions: yield* runtime.getConfigOptions,
236 });
237 expect(
238 (yield* runtime.getConfigOptions).find((option) => option.category === "model"),
239 ).toMatchObject({ currentValue: "gpt-5.4" });
240 }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
241 );
242
243 it.effect("publishes model changes returned by a config request and live notifications", () =>
244 Effect.gen(function* () {
245 const runtime = yield* AcpSessionRuntime.make(mockRuntimeOptions);
246 yield* runtime.start();
247 const updates = yield* Stream.toPull(
248 runtime.getEvents().pipe(Stream.filter((event) => event._tag === "ConfigOptionsUpdated")),
249 );
250 const selected = yield* runtime.setConfigOption("model", "composer-2");
251 expect((yield* updates)[0]?.configOptions).toEqual(selected.configOptions);
252 yield* runtime.request("_test/startup-metadata", {});
253 expect((yield* updates)[0]?.configOptions).toEqual(yield* runtime.getConfigOptions);
254 }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
255 );
256
257 it.effect("waits for native cancellation and drains final updates before another prompt", () =>
258 Effect.gen(function* () {
259 const toolStarted = yield* Deferred.make<void>();
260 const cancelReceived = yield* Deferred.make<void>();
261 const events: Array<AcpSessionRuntime.AcpSessionRuntimeEvent> = [];
262 let promptRequests = 0;
263 const runtime = yield* AcpSessionRuntime.make({
264 ...mockRuntimeOptions,
265 spawn: {
266 ...mockRuntimeOptions.spawn,
267 env: { T3_ACP_COMPLETE_FIRST_PROMPT_ON_CANCEL: "1" },
268 },
269 cancelBehavior: "wait-for-prompt",
270 requestLogger: (event) =>
271 Effect.sync(() => {
272 if (event.method === "session/prompt" && event.status === "started")
273 promptRequests += 1;
274 }),
275 });
276 yield* runtime.getEvents().pipe(
277 Stream.runForEach((event) => {
278 if (event._tag === "EventStreamBarrier") {
279 return Deferred.succeed(event.acknowledge, undefined);
280 }
281 events.push(event);
282 if (event._tag === "ToolCallUpdated" && event.toolCall.status === "inProgress") {
283 return Deferred.succeed(toolStarted, undefined);
284 }
285 if (event._tag === "ThoughtDelta" && event.text === "native-cancel-received") {
286 return Deferred.succeed(cancelReceived, undefined);
287 }
288 return Effect.void;
289 }),
290 Effect.forkChild,
291 );
292 yield* runtime.start();
293 const prompt = yield* runtime
294 .prompt({
295 prompt: [{ type: "text", text: "first" }],
296 })
297 .pipe(Effect.forkChild);
298 yield* Deferred.await(toolStarted);
299 const cancellation = yield* runtime.cancel.pipe(Effect.forkChild);
300 yield* Deferred.await(cancelReceived);
301 const replacement = yield* runtime
302 .prompt({
303 prompt: [{ type: "text", text: "second" }],
304 })
305 .pipe(Effect.forkChild({ startImmediately: true }));
306
307 expect(prompt.pollUnsafe()).toBeUndefined();
308 expect(cancellation.pollUnsafe()).toBeUndefined();
309 expect(promptRequests).toBe(1);
310 yield* runtime.request("_test/finish-cancel", {});
311 yield* Fiber.join(cancellation);
312
313 expect(yield* Fiber.join(prompt)).toEqual({
314 stopReason: "cancelled",
315 _meta: { nativeCancel: true },
316 });
317 expect(
318 events.some(
319 (event) =>
320 event._tag === "ToolCallUpdated" &&
321 event.toolCall.status === "failed" &&
322 event.toolCall.detail === "Cancelled.",
323 ),
324 ).toBe(true);
325 const cancelledDelta = events.find(
326 (event) => event._tag === "ContentDelta" && event.text === "Request cancelled.",
327 );
328 expect(cancelledDelta?._tag).toBe("ContentDelta");
329 if (cancelledDelta?._tag === "ContentDelta") {
330 expect(
331 events.filter(
332 (event) =>
333 event._tag === "AssistantItemCompleted" && event.itemId === cancelledDelta.itemId,
334 ),
335 ).toHaveLength(1);
336 }
337 expect(yield* Fiber.join(replacement)).toMatchObject({ stopReason: "end_turn" });
338 expect(promptRequests).toBe(2);
339 }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
340 );
341
342 it.effect("reports an idle child exit and rejects later prompts", () =>
343 Effect.gen(function* () {
344 const stopped = yield* Deferred.make<string>();
345 const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
346 const runtime = yield* AcpSessionRuntime.make(mockRuntimeOptions).pipe(
347 Effect.provideService(
348 ChildProcessSpawner.ChildProcessSpawner,
349 ChildProcessSpawner.make((command) =>
350 spawner.spawn(command).pipe(
351 Effect.map((child) =>
352 ChildProcessSpawner.makeHandle({
353 ...child,
354 // Model an inherited pipe held open until detached work is stopped.
355 stdout: Stream.concat(
356 child.stdout,
357 Stream.fromEffect(Deferred.await(stopped)).pipe(Stream.drain),
358 ),
359 }),
360 ),
361 ),
362 ),
363 ),
364 Effect.provideService(AgentScope, {
365 ...AgentScope.defaultValue(),
366 wrap: ({ command, args }) =>
367 Effect.succeed({ command, args, unit: "t3code-acp-test.scope" }),
368 stop: (unit) => Deferred.succeed(stopped, unit).pipe(Effect.asVoid),
369 }),
370 );
371 yield* runtime.start();
372 expect(yield* Deferred.isDone(stopped)).toBe(false);
373 yield* runtime.notify("_test/exit", {});
374 const events = yield* runtime.getEvents().pipe(Stream.take(1), Stream.runCollect);
375 expect(yield* Deferred.await(stopped)).toBe("t3code-acp-test.scope");
376 const event = events[0];
377 expect(event).toMatchObject({ _tag: "ConnectionTerminated", error: { code: 19 } });
378 if (event?._tag !== "ConnectionTerminated") return;
379 expect(
380 yield* runtime
381 .prompt({
382 prompt: [{ type: "text", text: "must not run" }],
383 })
384 .pipe(Effect.flip),
385 ).toBe(event.error);
386 expect(yield* runtime.start().pipe(Effect.flip)).toBe(event.error);
387 expect(yield* runtime.initialize().pipe(Effect.flip)).toBe(event.error);
388 expect(
389 yield* runtime.request("_test/environment", {}).pipe(
390 Effect.match({
391 onFailure: (error) => error,
392 onSuccess: () => undefined,
393 }),
394 ),
395 ).toBe(event.error);
396 expect(yield* runtime.notify("_test/exit", {}).pipe(Effect.flip)).toBe(event.error);
397 }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
398 );
399
400 it.effect("retires a native runtime when its prompt caller is interrupted", () =>
401 Effect.gen(function* () {
402 const dispatched = yield* Deferred.make<void>();
403 const runtime = yield* AcpSessionRuntime.make({
404 ...mockRuntimeOptions,
405 spawn: {
406 ...mockRuntimeOptions.spawn,
407 env: { T3_ACP_COMPLETE_FIRST_PROMPT_ON_CANCEL: "1" },
408 },
409 cancelBehavior: "wait-for-prompt",
410 });
411 yield* runtime.start();
412 const prompt = yield* runtime
413 .prompt(
414 {
415 prompt: [{ type: "text", text: "first" }],
416 },
417 { dispatched },
418 )
419 .pipe(Effect.forkChild);
420 yield* Deferred.await(dispatched);
421 yield* Fiber.interrupt(prompt);
422 const events = yield* runtime.getEvents().pipe(
423 Stream.filter((event) => event._tag === "ConnectionTerminated"),
424 Stream.take(1),
425 Stream.runCollect,
426 );
427 expect(events[0]).toMatchObject({
428 error: { _tag: "AcpTransportError", method: "session/prompt" },
429 });
430 expect(
431 yield* runtime
432 .prompt({
433 prompt: [{ type: "text", text: "must not run" }],
434 })
435 .pipe(Effect.flip),
436 ).toBe(events[0]?.error);
437 }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
438 );
439
440 it.effect("fails a pending request when the stderr handler rejects the runtime", () =>
441 Effect.gen(function* () {
442 const failure = new EffectAcpErrors.AcpTransportError({
443 detail: "Sign in before continuing.",
444 cause: undefined,
445 });
446 const runtime = yield* AcpSessionRuntime.make({
447 ...mockRuntimeOptions,
448 spawn: { ...mockRuntimeOptions.spawn, env: { T3_ACP_FLOOD_STDERR: "1" } },
449 onStderr: () => Effect.fail(failure),
450 });
451 expect(yield* runtime.start().pipe(Effect.flip)).toBe(failure);
452 const events = yield* runtime.getEvents().pipe(
453 Stream.filter((event) => event._tag === "ConnectionTerminated"),
454 Stream.take(1),
455 Stream.runCollect,
456 );
457 expect(events[0]?.error).toBe(failure);
458 expect(yield* runtime.initialize().pipe(Effect.flip)).toBe(failure);
459 }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
460 );
461
462 it.effect.each([
463 { name: "exit code", terminate: "process.exit(1)", code: 1, signal: undefined },
464 ...(HostProcess.Platform.defaultValue() === "win32"
465 ? []
466 : [
467 {
468 name: "signal",
469 terminate: "process.kill(process.pid, 'SIGTERM')",
470 code: undefined,
471 signal: "SIGTERM",
472 },
473 ]),
474 ])("retains the $name and sanitized stderr when ACP exits before initialize", (testCase) =>
475 Effect.gen(function* () {
476 const runtime = yield* AcpSessionRuntime.make({
477 ...mockRuntimeOptions,
478 spawn: {
479 command: process.execPath,
480 args: [
481 "-e",
482 `process.stderr.write("Invalid project config: Unrecognized key in cli.json\\nAuthorization: Bearer secret-token-value\\n", () => { ${testCase.terminate}; });`,
483 ],
484 },
485 });
486 const error = yield* runtime.start().pipe(Effect.flip);
487 assert.instanceOf(error, EffectAcpErrors.AcpProcessExitedError);
488 expect(error.code).toBe(testCase.code);
489 expect(error.signal).toBe(testCase.signal);
490 expect(error).toMatchObject({
491 pid: expect.any(Number),
492 stderr:
493 "Invalid project config: Unrecognized key in cli.json\nAuthorization: Bearer [redacted]",
494 });
495 expect(error.message).toBe(
496 `${testCase.signal ? "ACP process exited after signal SIGTERM" : "ACP process exited with code 1"}\nInvalid project config: Unrecognized key in cli.json\nAuthorization: Bearer [redacted]`,
497 );
498 if (testCase.signal) {
499 expect(error.cause).toMatchObject({
500 reason: {
501 module: "ChildProcess",
502 method: "exitCode",
503 cause: new Error("Process interrupted due to receipt of signal: 'SIGTERM'"),
504 },
505 });
506 }
507 }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
508 );
509
510 it.effect("drains large stderr output and keeps auth-sized logging chunks", () =>
511 Effect.gen(function* () {
512 const lengths: Array<number> = [];
513 for (const logStderr of [false, true]) {
514 yield* Effect.gen(function* () {
515 const runtime = yield* AcpSessionRuntime.make({
516 ...mockRuntimeOptions,
517 spawn: { ...mockRuntimeOptions.spawn, env: { T3_ACP_FLOOD_STDERR: "1" } },
518 ...(logStderr
519 ? {
520 onStderr: (text: string) =>
521 Effect.sync(() => {
522 lengths.push(text.length);
523 }),
524 }
525 : {}),
526 });
527 expect(yield* runtime.initialize()).toMatchObject({ protocolVersion: 2 });
528 }).pipe(Effect.scoped);
529 }
530 expect(lengths.length).toBeGreaterThan(0);
531 expect(Math.max(...lengths)).toBeGreaterThanOrEqual(16_384);
532 expect(Math.max(...lengths)).toBeLessThanOrEqual(32_768);
533 }).pipe(Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
534 );
535
536 it.effect("releases a queued event drain when its runtime scope closes", () =>
537 Effect.gen(function* () {
538 const scope = yield* Effect.acquireRelease(Scope.make(), (scope) =>
539 Scope.close(scope, Exit.void),
540 );
541 const barrierReceived = yield* Deferred.make<void>();
542 const runtime = yield* AcpSessionRuntime.make(mockRuntimeOptions).pipe(
543 Effect.provideService(Scope.Scope, scope),
544 );
545 yield* runtime.start();
546 yield* runtime.getEvents().pipe(
547 Stream.runForEach((event) =>
548 event._tag === "EventStreamBarrier"
549 ? Deferred.succeed(barrierReceived, undefined).pipe(Effect.andThen(Effect.never))
550 : Effect.void,
551 ),
552 Effect.forkIn(scope),
553 );
554 const drain = yield* runtime.drainEvents.pipe(Effect.forkChild);
555 yield* Deferred.await(barrierReceived);
556 yield* Scope.close(scope, Exit.void);
557 yield* Fiber.join(drain);
558 yield* runtime.drainEvents;
559 expect(yield* runtime.initialize().pipe(Effect.flip)).toMatchObject({
560 _tag: "AcpTransportError",
561 detail: "The ACP session runtime is closed.",
562 });
563 }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
564 );
565
566 it.effect("does not restore ambient variables to a sanitized child environment", () =>
567 Effect.gen(function* () {
568 yield* Effect.acquireRelease(
569 Effect.sync(() => setProcessEnv("T3_ACP_RUNTIME_AMBIENT", "sentinel")),
570 (restore) => Effect.sync(restore),
571 );
572 const runtime = yield* AcpSessionRuntime.make({
573 ...mockRuntimeOptions,
574 spawn: {
575 command: process.execPath,
576 args: mockAgentArgs,
577 extendEnv: false,
578 env: { T3_ACP_RUNTIME_EXPLICIT: "kept" },
579 },
580 });
581 yield* runtime.initialize();
582 expect(yield* runtime.request("_test/environment", {})).toEqual({
583 inherited: false,
584 explicit: true,
585 });
586 }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
587 );
588
589 it("selects explicit or agent-managed authentication without choosing terminal auth", () => {
590 const methods = [
591 { id: "browser", name: "Browser", type: "terminal" as const },
592 { id: "api-key", name: "API key", type: "agent" as const },
593 ];
594
595 expect(AcpSessionRuntime.selectAcpAgentAuthMethod(methods)?.id).toBe("api-key");
596 expect(AcpSessionRuntime.selectAcpAgentAuthMethod(methods, "browser")?.id).toBe("browser");
597 expect(AcpSessionRuntime.selectAcpAgentAuthMethod(methods, "missing")).toBeUndefined();
598 });
599
600 it.effect("prefers MCP-over-ACP only when the agent advertises that transport", () => {
601 const requestEvents: Array<AcpSessionRuntime.AcpSessionRequestLogEvent> = [];
602 return Effect.gen(function* () {
603 const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;
604 yield* runtime.start();
605
606 const created = requestEvents.find(
607 (event) => event.method === "session/new" && event.status === "started",
608 );
609 expect(created?.payload).toMatchObject({
610 mcpServers: [{ type: "acp", name: "t3-code", serverId: "t3-code" }],
611 });
612 }).pipe(
613 Effect.provide(
614 AcpSessionRuntime.layer({
615 spawn: {
616 command: mockAgentCommand,
617 args: mockAgentArgs,
618 env: { T3_ACP_MCP_ACP: "1" },
619 },
620 cwd: process.cwd(),
621 clientInfo: { name: "t3-test", version: "0.0.0" },
622 authMethodId: "test",
623 mcpServers: [{ type: "stdio", name: "t3-code", command: "/usr/bin/node", args: [] }],
624 acpMcpServers: [{ type: "acp", name: "t3-code", serverId: "t3-code" }],
625 requestLogger: (event) =>
626 Effect.sync(() => {
627 requestEvents.push(event);
628 }),
629 }),
630 ),
631 Effect.scoped,
632 Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
633 );
634 });
635
636 it.effect("supports v2 session deletion and secret-safe provider management", () => {
637 const requestEvents: Array<AcpSessionRuntime.AcpSessionRequestLogEvent> = [];
638 return Effect.gen(function* () {
639 const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;
640 yield* runtime.start();
641
642 yield* runtime.deleteSession("native-session-1");
643 expect((yield* runtime.listProviders).providers[0]).toMatchObject({
644 providerId: "mock-provider",
645 current: null,
646 });
647 yield* runtime.setProvider({
648 providerId: "mock-provider",
649 apiType: "openai",
650 baseUrl: "https://api.example.test/v1",
651 headers: { Authorization: "Bearer top-secret" },
652 });
653 expect((yield* runtime.listProviders).providers[0]?.current).toEqual({
654 apiType: "openai",
655 baseUrl: "https://api.example.test/v1",
656 });
657 yield* runtime.disableProvider("mock-provider");
658 expect((yield* runtime.listProviders).providers[0]?.current).toBeNull();
659
660 const setRequest = requestEvents.find(
661 (event) => event.method === "providers/set" && event.status === "started",
662 );
663 expect(setRequest?.payload).toMatchObject({
664 headers: { Authorization: "[redacted]" },
665 });
666 }).pipe(
667 Effect.provide(
668 AcpSessionRuntime.layer({
669 spawn: {
670 command: mockAgentCommand,
671 args: mockAgentArgs,
672 env: { T3_ACP_V2_MANAGEMENT: "1" },
673 },
674 cwd: process.cwd(),
675 clientInfo: { name: "t3-test", version: "0.0.0" },
676 authMethodId: "test",
677 requestLogger: (event) =>
678 Effect.sync(() => {
679 requestEvents.push(event);
680 }),
681 }),
682 ),
683 Effect.scoped,
684 Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
685 );
686 });
687
688 it.effect("authenticates explicitly typed v2 agent methods and retries session creation", () => {
689 const requestEvents: Array<AcpSessionRuntime.AcpSessionRequestLogEvent> = [];
690 return Effect.gen(function* () {
691 const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;
692 const started = yield* runtime.start();
693 expect(started.sessionId).toBe("mock-session-1");
694 expect(
695 requestEvents.filter((event) => event.status === "started").map((event) => event.method),
696 ).toEqual(["initialize", "session/new", "authenticate", "session/new"]);
697 expect(
698 requestEvents.filter(
699 (event) => event.method === "session/new" && event.status === "failed",
700 ),
701 ).toHaveLength(1);
702 expect(
703 requestEvents.filter(
704 (event) => event.method === "session/new" && event.status === "succeeded",
705 ),
706 ).toHaveLength(1);
707 }).pipe(
708 Effect.provide(
709 AcpSessionRuntime.layer({
710 authMethodId: "test",
711 spawn: {
712 command: mockAgentCommand,
713 args: mockAgentArgs,
714 env: {
715 T3_ACP_AUTH_METHOD_ID: "test",
716 T3_ACP_REQUIRE_AUTH: "1",
717 },
718 },
719 cwd: process.cwd(),
720 clientInfo: { name: "t3-test", version: "0.0.0" },
721 requestLogger: (event) =>
722 Effect.sync(() => {
723 requestEvents.push(event);
724 }),
725 }),
726 ),
727 Effect.scoped,
728 Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
729 );
730 });
731
732 it.effect("can surface auth-required without authenticating during discovery", () => {
733 const requestEvents: Array<AcpSessionRuntime.AcpSessionRequestLogEvent> = [];
734 let advertisedAuthMethodName: string | undefined;
735 return Effect.gen(function* () {
736 const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;
737 const result = yield* Effect.result(runtime.start());
738
739 expect(Result.isFailure(result)).toBe(true);
740 expect(advertisedAuthMethodName).toBe("Mock agent authentication");
741 expect(
742 requestEvents.filter((event) => event.status === "started").map((event) => event.method),
743 ).toEqual(["initialize", "session/new"]);
744 }).pipe(
745 Effect.provide(
746 AcpSessionRuntime.layer({
747 authenticateOnAuthRequired: false,
748 authMethodId: "test",
749 spawn: {
750 command: mockAgentCommand,
751 args: mockAgentArgs,
752 env: {
753 T3_ACP_AUTH_METHOD_ID: "test",
754 T3_ACP_REQUIRE_AUTH: "1",
755 },
756 },
757 cwd: process.cwd(),
758 clientInfo: { name: "t3-test", version: "0.0.0" },
759 onInitialized: (initializeResult) =>
760 Effect.sync(() => {
761 advertisedAuthMethodName = initializeResult.authMethods?.[0]?.name;
762 }),
763 requestLogger: (event) =>
764 Effect.sync(() => {
765 requestEvents.push(event);
766 }),
767 }),
768 ),
769 Effect.scoped,
770 Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
771 );
772 });
773
774 it.effect("starts a session, prompts, and emits normalized events against the mock agent", () =>
775 Effect.gen(function* () {
776 const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;
777 const started = yield* runtime.start();
778
779 expect(started.initializeResult).toMatchObject({ protocolVersion: 2 });
780 expect(started.sessionId).toBe("mock-session-1");
781
782 const promptResult = yield* runtime.prompt({
783 prompt: [{ type: "text", text: "hi" }],
784 });
785 expect(promptResult).toMatchObject({ stopReason: "end_turn" });
786
787 const notes = Array.from(yield* Stream.runCollect(Stream.take(runtime.getEvents(), 4)));
788 expect(notes).toHaveLength(4);
789 expect(notes.map((note) => note._tag)).toEqual([
790 "PlanUpdated",
791 "AssistantItemStarted",
792 "ContentDelta",
793 "AssistantItemCompleted",
794 ]);
795 const planUpdate = notes.find((note) => note._tag === "PlanUpdated");
796 expect(planUpdate?._tag).toBe("PlanUpdated");
797 if (planUpdate?._tag === "PlanUpdated") {
798 expect(planUpdate.payload).toMatchObject({
799 nativePlanId: "mock-plan",
800 kind: "items",
801 });
802 if (planUpdate.payload.kind === "items") {
803 expect(planUpdate.payload.plan).toHaveLength(2);
804 }
805 }
806 const assistantStart = notes[1];
807 const assistantDelta = notes[2];
808 if (
809 assistantStart?._tag === "AssistantItemStarted" &&
810 assistantDelta?._tag === "ContentDelta"
811 ) {
812 expect(assistantDelta.itemId).toBe(assistantStart.itemId);
813 }
814 }).pipe(
815 Effect.provide(
816 AcpSessionRuntime.layer({
817 spawn: {
818 command: mockAgentCommand,
819 args: mockAgentArgs,
820 },
821 cwd: process.cwd(),
822 clientInfo: { name: "t3-test", version: "0.0.0" },
823 authMethodId: "test",
824 }),
825 ),
826 Effect.scoped,
827 Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
828 ),
829 );
830
831 it.effect("keeps assistant item IDs unique when a provider session restarts", () => {
832 const collectFirstAssistantItemId = Effect.gen(function* () {
833 const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;
834 const started = yield* runtime.start();
835 expect(started.sessionId).toBe("mock-session-1");
836
837 yield* runtime.prompt({
838 prompt: [{ type: "text", text: "hi" }],
839 });
840
841 const events = Array.from(yield* Stream.runCollect(Stream.take(runtime.getEvents(), 4)));
842 const assistantStart = events.find((event) => event._tag === "AssistantItemStarted");
843 expect(assistantStart?._tag).toBe("AssistantItemStarted");
844 return assistantStart?._tag === "AssistantItemStarted" ? assistantStart.itemId : "";
845 }).pipe(
846 Effect.provide(
847 AcpSessionRuntime.layer({
848 spawn: {
849 command: mockAgentCommand,
850 args: mockAgentArgs,
851 },
852 cwd: process.cwd(),
853 clientInfo: { name: "t3-test", version: "0.0.0" },
854 authMethodId: "test",
855 }),
856 ),
857 Effect.scoped,
858 );
859
860 return Effect.gen(function* () {
861 const beforeRestart = yield* collectFirstAssistantItemId;
862 const afterRestart = yield* collectFirstAssistantItemId;
863
864 expect(afterRestart).not.toBe(beforeRestart);
865 }).pipe(Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)));
866 });
867
868 it.effect("drops session updates emitted for a child ACP session", () =>
869 Effect.gen(function* () {
870 const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;
871 yield* runtime.start();
872
873 const promptResult = yield* runtime.prompt({
874 prompt: [{ type: "text", text: "hi" }],
875 });
876 expect(promptResult).toMatchObject({ stopReason: "end_turn" });
877
878 const notes = Array.from(yield* Stream.runCollect(Stream.take(runtime.getEvents(), 4)));
879 expect(notes.map((note) => note._tag)).toEqual([
880 "AssistantItemStarted",
881 "ContentDelta",
882 "ContentDelta",
883 "AssistantItemCompleted",
884 ]);
885 expect(
886 notes
887 .filter((note) => note._tag === "ContentDelta")
888 .map((note) => note.text)
889 .join(""),
890 ).toBe("root before child root after child");
891 expect(notes.some((note) => note._tag === "ToolCallUpdated")).toBe(false);
892 }).pipe(
893 Effect.provide(
894 AcpSessionRuntime.layer({
895 spawn: {
896 command: mockAgentCommand,
897 args: mockAgentArgs,
898 env: {
899 T3_ACP_EMIT_FOREIGN_SESSION_UPDATES: "1",
900 },
901 },
902 cwd: process.cwd(),
903 clientInfo: { name: "t3-test", version: "0.0.0" },
904 authMethodId: "test",
905 }),
906 ),
907 Effect.scoped,
908 Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
909 ),
910 );
911
912 it.effect("segments assistant text around ACP tool calls", () =>
913 Effect.gen(function* () {
914 const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;
915 yield* runtime.start();
916
917 const promptResult = yield* runtime.prompt({
918 prompt: [{ type: "text", text: "hi" }],
919 });
920 expect(promptResult).toMatchObject({ stopReason: "end_turn" });
921
922 const notes = Array.from(yield* Stream.runCollect(Stream.take(runtime.getEvents(), 7)));
923 expect(notes.map((note) => note._tag)).toEqual([
924 "AssistantItemStarted",
925 "ContentDelta",
926 "AssistantItemCompleted",
927 "ToolCallUpdated",
928 "ToolCallUpdated",
929 "AssistantItemStarted",
930 "ContentDelta",
931 ]);
932
933 const firstStarted = notes[0];
934 const firstDelta = notes[1];
935 const firstCompleted = notes[2];
936 const secondStarted = notes[5];
937 const secondDelta = notes[6];
938 expect(firstStarted?._tag).toBe("AssistantItemStarted");
939 expect(firstCompleted?._tag).toBe("AssistantItemCompleted");
940 expect(secondStarted?._tag).toBe("AssistantItemStarted");
941 if (
942 firstStarted?._tag === "AssistantItemStarted" &&
943 firstDelta?._tag === "ContentDelta" &&
944 firstCompleted?._tag === "AssistantItemCompleted" &&
945 secondStarted?._tag === "AssistantItemStarted" &&
946 secondDelta?._tag === "ContentDelta"
947 ) {
948 expect(firstDelta.itemId).toBe(firstStarted.itemId);
949 expect(firstCompleted.itemId).toBe(firstStarted.itemId);
950 expect(secondStarted.itemId).not.toBe(firstStarted.itemId);
951 expect(secondDelta.itemId).toBe(secondStarted.itemId);
952 }
953 }).pipe(
954 Effect.provide(
955 AcpSessionRuntime.layer({
956 spawn: {
957 command: mockAgentCommand,
958 args: mockAgentArgs,
959 env: {
960 T3_ACP_EMIT_INTERLEAVED_ASSISTANT_TOOL_CALLS: "1",
961 },
962 },
963 cwd: process.cwd(),
964 clientInfo: { name: "t3-test", version: "0.0.0" },
965 authMethodId: "test",
966 }),
967 ),
968 Effect.scoped,
969 Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
970 ),
971 );
972
973 it.effect("keeps one answer when an earlier tool reports progress mid-stream", () =>
974 Effect.gen(function* () {
975 const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;
976 yield* runtime.start();
977 yield* runtime.prompt({ prompt: [{ type: "text", text: "hi" }] });
978
979 const notes = Array.from(yield* Stream.runCollect(Stream.take(runtime.getEvents(), 9)));
980 expect(notes.map((note) => note._tag)).toEqual([
981 "ToolCallUpdated",
982 "AssistantItemStarted",
983 "ContentDelta",
984 "ContentDelta",
985 "ToolCallUpdated",
986 "ContentDelta",
987 "ToolCallUpdated",
988 "ContentDelta",
989 "AssistantItemCompleted",
990 ]);
991 const itemIds = new Set(
992 notes.flatMap((note) =>
993 note._tag === "ContentDelta" ||
994 note._tag === "AssistantItemStarted" ||
995 note._tag === "AssistantItemCompleted"
996 ? [note.itemId]
997 : [],
998 ),
999 );
1000 expect(itemIds.size).toBe(1);
1001 }).pipe(
1002 Effect.provide(
1003 AcpSessionRuntime.layer({
1004 spawn: {
1005 command: mockAgentCommand,
1006 args: mockAgentArgs,
1007 env: { T3_ACP_EMIT_BACKGROUND_TOOL_DURING_ANSWER: "1" },
1008 },
1009 cwd: process.cwd(),
1010 clientInfo: { name: "t3-test", version: "0.0.0" },
1011 authMethodId: "test",
1012 }),
1013 ),
1014 Effect.scoped,
1015 Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
1016 ),
1017 );
1018
1019 it.effect("emits status-only tool updates through completion", () =>
1020 Effect.gen(function* () {
1021 const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;
1022 yield* runtime.start();
1023
1024 const promptResult = yield* runtime.prompt({
1025 prompt: [{ type: "text", text: "hi" }],
1026 });
1027 expect(promptResult).toMatchObject({ stopReason: "end_turn" });
1028
1029 const notes = Array.from(yield* Stream.runCollect(Stream.take(runtime.getEvents(), 3)));
1030 expect(notes.map((note) => note._tag)).toEqual([
1031 "ToolCallUpdated",
1032 "ToolCallUpdated",
1033 "ToolCallUpdated",
1034 ]);
1035 const toolCalls = notes.flatMap((note) =>
1036 note._tag === "ToolCallUpdated" ? [note.toolCall] : [],
1037 );
1038 expect(toolCalls.map((toolCall) => toolCall.status)).toEqual([
1039 "pending",
1040 "inProgress",
1041 "completed",
1042 ]);
1043 for (const toolCall of toolCalls) {
1044 expect(toolCall.title).toBe("Read file");
1045 }
1046 }).pipe(
1047 Effect.provide(
1048 AcpSessionRuntime.layer({
1049 spawn: {
1050 command: mockAgentCommand,
1051 args: mockAgentArgs,
1052 env: {
1053 T3_ACP_EMIT_GENERIC_TOOL_PLACEHOLDERS: "1",
1054 },
1055 },
1056 cwd: process.cwd(),
1057 clientInfo: { name: "t3-test", version: "0.0.0" },
1058 authMethodId: "test",
1059 }),
1060 ),
1061 Effect.scoped,
1062 Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
1063 ),
1064 );
1065
1066 it.effect("supports negotiated ACP session list, fork, resume, and close methods", () => {
1067 const requestEvents: Array<AcpSessionRuntime.AcpSessionRequestLogEvent> = [];
1068 return Effect.gen(function* () {
1069 const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;
1070 const started = yield* runtime.start();
1071 expect(started.initializeResult.agentCapabilities?.sessionCapabilities).toMatchObject({
1072 list: {},
1073 fork: {},
1074 resume: {},
1075 close: {},
1076 });
1077 expect(started.initializeResult.agentCapabilities?.auth).toMatchObject({ logout: {} });
1078
1079 const listed = yield* runtime.listSessions();
1080 expect(listed.sessions.map((session) => session.sessionId)).toEqual(["mock-session-1"]);
1081
1082 const forked = yield* runtime.forkSession(started.sessionId);
1083 expect(forked.sessionId).toBe("mock-session-1-fork");
1084 yield* runtime.prompt({ prompt: [{ type: "text", text: "on fork" }] });
1085
1086 const resumed = yield* runtime.resumeSession(started.sessionId);
1087 expect(resumed.sessionId).toBe("mock-session-1");
1088 yield* runtime.closeSession();
1089 yield* runtime.logout;
1090
1091 expect(
1092 requestEvents.find(
1093 (event) => event.method === "session/prompt" && event.status === "started",
1094 )?.payload,
1095 ).toMatchObject({ sessionId: "mock-session-1-fork" });
1096 expect(
1097 requestEvents.filter((event) => event.status === "started").map((event) => event.method),
1098 ).toEqual(
1099 expect.arrayContaining([
1100 "session/list",
1101 "session/fork",
1102 "session/resume",
1103 "session/close",
1104 "logout",
1105 ]),
1106 );
1107 // Omitted roots clear an agent's stored ones, so every activation resends them.
1108 for (const method of ["session/new", "session/fork", "session/resume"]) {
1109 expect(
1110 requestEvents.find((event) => event.method === method && event.status === "started")
1111 ?.payload,
1112 ).toMatchObject({
1113 additionalDirectories: ["/tmp/t3-attachments"],
1114 _meta: { negotiated: "0.0.0" },
1115 });
1116 }
1117 }).pipe(
1118 Effect.provide(
1119 AcpSessionRuntime.layer({
1120 authMethodId: "test",
1121 spawn: {
1122 command: mockAgentCommand,
1123 args: mockAgentArgs,
1124 env: {
1125 T3_ACP_SESSION_LIFECYCLE: "1",
1126 },
1127 },
1128 additionalDirectories: ["/tmp/t3-attachments"],
1129 sessionMeta: (initializeResult) => ({
1130 negotiated: initializeResult.agentInfo?.version ?? "none",
1131 }),
1132 cwd: process.cwd(),
1133 clientInfo: { name: "t3-test", version: "0.0.0" },
1134 requestLogger: (event) =>
1135 Effect.sync(() => {
1136 requestEvents.push(event);
1137 }),
1138 }),
1139 ),
1140 Effect.scoped,
1141 Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
1142 );
1143 });
1144
1145 it.effect("rejects unauthenticated ACP session lifecycle requests", () =>
1146 Effect.gen(function* () {
1147 const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;
1148 yield* runtime.start();
1149
1150 const listError = yield* runtime.listSessions().pipe(Effect.flip);
1151 expect(listError._tag).toBe("AcpRequestError");
1152 if (listError._tag === "AcpRequestError") {
1153 expect(listError.code).toBe(-32000);
1154 }
1155
1156 const forkError = yield* runtime.forkSession("mock-session-1").pipe(Effect.flip);
1157 expect(forkError._tag).toBe("AcpRequestError");
1158 if (forkError._tag === "AcpRequestError") {
1159 expect(forkError.code).toBe(-32000);
1160 }
1161
1162 const resumeError = yield* runtime.resumeSession("mock-session-1").pipe(Effect.flip);
1163 expect(resumeError._tag).toBe("AcpRequestError");
1164 if (resumeError._tag === "AcpRequestError") {
1165 expect(resumeError.code).toBe(-32000);
1166 }
1167
1168 const closeError = yield* runtime.closeSession().pipe(Effect.flip);
1169 expect(closeError._tag).toBe("AcpRequestError");
1170 if (closeError._tag === "AcpRequestError") {
1171 expect(closeError.code).toBe(-32000);
1172 }
1173 }).pipe(
1174 Effect.provide(
1175 AcpSessionRuntime.layer({
1176 spawn: {
1177 command: mockAgentCommand,
1178 args: mockAgentArgs,
1179 env: {
1180 T3_ACP_REQUIRE_AUTH: "1",
1181 T3_ACP_SESSION_LIFECYCLE: "1",
1182 },
1183 },
1184 cwd: process.cwd(),
1185 resumeSessionId: "mock-session-1",
1186 clientInfo: { name: "t3-test", version: "0.0.0" },
1187 }),
1188 ),
1189 Effect.scoped,
1190 Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
1191 ),
1192 );
1193
1194 // regression: #3156 harden ACP resume with replay-idle load readiness
1195 it.effect("fails session startup when session/load returns an error", () =>
1196 Effect.gen(function* () {
1197 const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;
1198 const error = yield* runtime.start().pipe(Effect.flip);
1199
1200 expect(error._tag).toBe("AcpRequestError");
1201 }).pipe(
1202 Effect.provide(
1203 AcpSessionRuntime.layer({
1204 authMethodId: "test",
1205 spawn: {
1206 command: mockAgentCommand,
1207 args: mockAgentArgs,
1208 env: {
1209 T3_ACP_FAIL_LOAD_SESSION: "1",
1210 },
1211 },
1212 cwd: process.cwd(),
1213 resumeSessionId: "stale-session-id",
1214 clientInfo: { name: "t3-test", version: "0.0.0" },
1215 }),
1216 ),
1217 Effect.scoped,
1218 Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
1219 ),
1220 );
1221
1222 // Live clock: the replay-idle gap must elapse in real time against the mock agent process.
1223 it.live("adopts config options from a session/load response that arrives after replay idle", () =>
1224 Effect.gen(function* () {
1225 const runtime = yield* AcpSessionRuntime.make({
1226 ...mockRuntimeOptions,
1227 spawn: {
1228 ...mockRuntimeOptions.spawn,
1229 env: {
1230 T3_ACP_DELAY_LOAD_SESSION_AFTER_REPLAY: "1",
1231 T3_ACP_LOAD_SESSION_DELAY_MS: "500",
1232 },
1233 },
1234 resumeSessionId: "mock-session-1",
1235 sessionLoadReplayIdleGap: "100 millis",
1236 sessionLoadReplayIdleReadiness: true,
1237 });
1238 const started = yield* runtime.start();
1239 expect(started.sessionSetupResult._meta).toMatchObject({ t3SessionLoadReady: "replay_idle" });
1240
1241 yield* runtime.getEvents().pipe(
1242 Stream.filter((event) => event._tag === "ConfigOptionsUpdated"),
1243 Stream.take(1),
1244 Stream.runDrain,
1245 Effect.timeoutOption("5 seconds"),
1246 );
1247
1248 expect((yield* runtime.getConfigOptions).map((option) => option.id)).toEqual([
1249 "mode",
1250 "model",
1251 ]);
1252 }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
1253 );
1254
1255 it.live("drops a late session/load response when a selection was sent before it", () =>
1256 Effect.gen(function* () {
1257 const lateLoadLogged = yield* Deferred.make<void>();
1258 const runtime = yield* AcpSessionRuntime.make({
1259 ...mockRuntimeOptions,
1260 spawn: {
1261 ...mockRuntimeOptions.spawn,
1262 env: {
1263 T3_ACP_DELAY_LOAD_SESSION_AFTER_REPLAY: "1",
1264 T3_ACP_LOAD_SESSION_DELAY_MS: "500",
1265 T3_ACP_HOLD_SET_CONFIG_OPTION_UNTIL_LOAD_REPLY: "1",
1266 },
1267 },
1268 resumeSessionId: "mock-session-1",
1269 sessionLoadReplayIdleGap: "100 millis",
1270 sessionLoadReplayIdleReadiness: true,
1271 requestLogger: (event) =>
1272 event.method === "session/load" &&
1273 event.status === "succeeded" &&
1274 (event.result as { readonly configOptions?: unknown } | undefined)?.configOptions !==
1275 undefined
1276 ? Deferred.succeed(lateLoadLogged, undefined).pipe(Effect.asVoid)
1277 : Effect.void,
1278 });
1279 const started = yield* runtime.start();
1280 // The agent answers the load before this request, so no config change
1281 // is visible when the late response arrives.
1282 yield* runtime.setConfigOption("model", "gpt-5.4");
1283 yield* Deferred.await(lateLoadLogged).pipe(Effect.timeout("5 seconds"));
1284
1285 expect((yield* runtime.start()).sessionSetupResult).toBe(started.sessionSetupResult);
1286 const model = (yield* runtime.getConfigOptions).find((option) => option.id === "model");
1287 expect(model?.currentValue).toBe("gpt-5.4");
1288 }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
1289 );
1290
1291 it.live("drops a late session/load response when the agent changed mode before it", () =>
1292 Effect.gen(function* () {
1293 const lateLoadLogged = yield* Deferred.make<void>();
1294 const runtime = yield* AcpSessionRuntime.make({
1295 ...mockRuntimeOptions,
1296 spawn: {
1297 ...mockRuntimeOptions.spawn,
1298 env: {
1299 T3_ACP_DELAY_LOAD_SESSION_AFTER_REPLAY: "1",
1300 T3_ACP_LOAD_SESSION_DELAY_MS: "500",
1301 T3_ACP_NOTIFY_MODE_BEFORE_LOAD_REPLY: "code",
1302 },
1303 },
1304 resumeSessionId: "mock-session-1",
1305 sessionLoadReplayIdleGap: "100 millis",
1306 sessionLoadReplayIdleReadiness: true,
1307 // The mock speaks ACP v2, which has no current_mode_update; decode it as a v1 agent's.
1308 transformSessionUpdate: (notification) =>
1309 notification.update.sessionUpdate === "_t3_unknown" &&
1310 notification.update.originalSessionUpdate === "current_mode_update"
1311 ? {
1312 ...notification,
1313 update: notification.update.raw as EffectAcpSchema.SessionNotification["update"],
1314 }
1315 : notification,
1316 requestLogger: (event) =>
1317 event.method === "session/load" &&
1318 event.status === "succeeded" &&
1319 (event.result as { readonly configOptions?: unknown } | undefined)?.configOptions !==
1320 undefined
1321 ? Deferred.succeed(lateLoadLogged, undefined).pipe(Effect.asVoid)
1322 : Effect.void,
1323 });
1324 const started = yield* runtime.start();
1325 // No mode metadata yet, so the notification leaves the mode state as is.
1326 expect(yield* runtime.getModeState).toBeUndefined();
1327 yield* Deferred.await(lateLoadLogged).pipe(Effect.timeout("5 seconds"));
1328
1329 expect((yield* runtime.start()).sessionSetupResult).toBe(started.sessionSetupResult);
1330 expect(yield* runtime.getModeState).toBeUndefined();
1331 }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
1332 );
1333
1334 it.live("drops a late session/load response that startup metadata superseded", () =>
1335 Effect.gen(function* () {
1336 const provisionalLogged = yield* Deferred.make<void>();
1337 const allowStartup = yield* Deferred.make<void>();
1338 const lateLoadLogged = yield* Deferred.make<void>();
1339 const runtime = yield* AcpSessionRuntime.make({
1340 ...mockRuntimeOptions,
1341 spawn: {
1342 ...mockRuntimeOptions.spawn,
1343 env: {
1344 T3_ACP_DELAY_LOAD_SESSION_AFTER_REPLAY: "1",
1345 T3_ACP_LOAD_SESSION_DELAY_MS: "500",
1346 },
1347 },
1348 resumeSessionId: "mock-session-1",
1349 sessionLoadReplayIdleGap: "100 millis",
1350 sessionLoadReplayIdleReadiness: true,
1351 requestLogger: (event) => {
1352 if (event.method !== "session/load" || event.status !== "succeeded") {
1353 return Effect.void;
1354 }
1355 return (event.result as { readonly configOptions?: unknown } | undefined)
1356 ?.configOptions === undefined
1357 ? Deferred.succeed(provisionalLogged, undefined).pipe(
1358 Effect.andThen(Deferred.await(allowStartup)),
1359 )
1360 : Deferred.succeed(lateLoadLogged, undefined).pipe(Effect.asVoid);
1361 },
1362 });
1363 const startup = yield* runtime.start().pipe(Effect.forkChild);
1364 yield* Deferred.await(provisionalLogged);
1365 yield* runtime.request("_test/startup-metadata", {});
1366 yield* Deferred.succeed(allowStartup, undefined);
1367 yield* Fiber.join(startup);
1368 yield* Deferred.await(lateLoadLogged).pipe(Effect.timeout("5 seconds"));
1369
1370 expect(yield* runtime.getModeState).toMatchObject({ currentModeId: "code" });
1371 expect(
1372 (yield* runtime.getConfigOptions).find((option) => option.category === "model"),
1373 ).toMatchObject({ currentValue: "gpt-5.4" });
1374 }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
1375 );
1376
1377 it.effect("keeps active configuration after a candidate session load fails", () =>
1378 Effect.gen(function* () {
1379 const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;
1380 yield* runtime.start();
1381 const before = yield* runtime.getConfigOptions;
1382
1383 const error = yield* runtime.loadSession("candidate-session").pipe(Effect.flip);
1384
1385 expect(error._tag).toBe("AcpRequestError");
1386 expect(yield* runtime.getConfigOptions).toEqual(before);
1387 expect(before.some((option) => option.id === "candidate-only")).toBe(false);
1388 }).pipe(
1389 Effect.provide(
1390 AcpSessionRuntime.layer({
1391 authMethodId: "test",
1392 spawn: {
1393 command: mockAgentCommand,
1394 args: mockAgentArgs,
1395 env: {
1396 T3_ACP_FAIL_LOAD_SESSION_AFTER_CONFIG_REPLAY: "1",
1397 },
1398 },
1399 cwd: process.cwd(),
1400 clientInfo: { name: "t3-test", version: "0.0.0" },
1401 }),
1402 ),
1403 Effect.scoped,
1404 Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
1405 ),
1406 );
1407
1408 it.effect("ignores session/update replay notifications during session/load", () =>
1409 Effect.gen(function* () {
1410 const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;
1411 yield* runtime.start();
1412
1413 yield* runtime.prompt({
1414 prompt: [{ type: "text", text: "hi" }],
1415 });
1416 const notes = Array.from(yield* Stream.runCollect(Stream.take(runtime.getEvents(), 4)));
1417 expect(notes.map((note) => note._tag)).toEqual([
1418 "PlanUpdated",
1419 "AssistantItemStarted",
1420 "ContentDelta",
1421 "AssistantItemCompleted",
1422 ]);
1423 expect(notes.some((note) => note._tag === "ToolCallUpdated")).toBe(false);
1424 }).pipe(
1425 Effect.provide(
1426 AcpSessionRuntime.layer({
1427 authMethodId: "test",
1428 spawn: {
1429 command: mockAgentCommand,
1430 args: mockAgentArgs,
1431 env: {
1432 T3_ACP_EMIT_LOAD_REPLAY: "1",
1433 },
1434 },
1435 cwd: process.cwd(),
1436 resumeSessionId: "mock-session-1",
1437 clientInfo: { name: "t3-test", version: "0.0.0" },
1438 }),
1439 ),
1440 Effect.scoped,
1441 Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
1442 ),
1443 );
1444
1445 // regression: #37106 prompt sent before session/load replied
1446 it.live("does not prompt before session/load replies after replay goes idle", () =>
1447 Effect.gen(function* () {
1448 const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;
1449 yield* runtime.start();
1450
1451 const result = yield* runtime.prompt({
1452 prompt: [{ type: "text", text: "hi" }],
1453 });
1454 expect(result.stopReason).toBe("end_turn");
1455 }).pipe(
1456 Effect.provide(
1457 AcpSessionRuntime.layer({
1458 authMethodId: "test",
1459 spawn: {
1460 command: mockAgentCommand,
1461 args: mockAgentArgs,
1462 env: {
1463 T3_ACP_EMIT_LOAD_REPLAY: "1",
1464 T3_ACP_LOAD_REPLY_DELAY_MS: "500",
1465 T3_ACP_REJECT_PROMPT_UNTIL_LOADED: "1",
1466 },
1467 },
1468 cwd: process.cwd(),
1469 resumeSessionId: "mock-session-1",
1470 sessionLoadReplayIdleGap: "50 millis",
1471 clientInfo: { name: "t3-test", version: "0.0.0" },
1472 }),
1473 ),
1474 Effect.scoped,
1475 Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
1476 ),
1477 );
1478
1479 it.live("treats replay idle as loaded when the agent opts in", () =>
1480 Effect.gen(function* () {
1481 const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;
1482 const started = yield* runtime.start();
1483
1484 expect(started.sessionSetupResult._meta).toMatchObject({
1485 t3SessionLoadReady: "replay_idle",
1486 });
1487 }).pipe(
1488 Effect.provide(
1489 AcpSessionRuntime.layer({
1490 authMethodId: "test",
1491 spawn: {
1492 command: mockAgentCommand,
1493 args: mockAgentArgs,
1494 env: {
1495 T3_ACP_EMIT_LOAD_REPLAY: "1",
1496 T3_ACP_LOAD_NEVER_REPLIES: "1",
1497 },
1498 },
1499 cwd: process.cwd(),
1500 resumeSessionId: "mock-session-1",
1501 sessionLoadReplayIdleGap: "50 millis",
1502 sessionLoadReplayIdleReadiness: true,
1503 clientInfo: { name: "t3-test", version: "0.0.0" },
1504 }),
1505 ),
1506 Effect.scoped,
1507 Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
1508 ),
1509 );
1510
1511 it.effect("rejects invalid config option values before sending session/set_config_option", () => {
1512 const tempDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "acp-runtime-"));
1513 const requestLogPath = NodePath.join(tempDir, "requests.ndjson");
1514 return Effect.gen(function* () {
1515 const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;
1516 yield* runtime.start();
1517
1518 const error = yield* runtime.setModel("composer-2[fast=false]").pipe(Effect.flip);
1519 expect(error._tag).toBe("AcpRequestError");
1520 if (error._tag === "AcpRequestError") {
1521 expect(error.code).toBe(-32602);
1522 expect(error.message).toContain(
1523 'Invalid value "composer-2[fast=false]" for session config option "model"',
1524 );
1525 expect(error.message).toContain("composer-2[fast=true]");
1526 }
1527
1528 const recordedRequests = NodeFS.readFileSync(requestLogPath, "utf8")
1529 .trim()
1530 .split("\n")
1531 .filter((line) => line.length > 0)
1532 .map((line) => JSON.parse(line) as { method?: string; params?: { value?: unknown } });
1533 expect(
1534 recordedRequests.some(
1535 (message) =>
1536 message.method === "session/set_config_option" &&
1537 message.params?.value === "composer-2[fast=false]",
1538 ),
1539 ).toBe(false);
1540 }).pipe(
1541 Effect.provide(
1542 AcpSessionRuntime.layer({
1543 authMethodId: "test",
1544 spawn: {
1545 command: mockAgentCommand,
1546 args: mockAgentArgs,
1547 env: {
1548 T3_ACP_REQUEST_LOG_PATH: requestLogPath,
1549 },
1550 },
1551 cwd: process.cwd(),
1552 clientInfo: { name: "t3-test", version: "0.0.0" },
1553 }),
1554 ),
1555 Effect.scoped,
1556 Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
1557 Effect.ensuring(Effect.sync(() => NodeFS.rmSync(tempDir, { recursive: true, force: true }))),
1558 );
1559 });
1560
1561 it.effect("sends configured custom models the agent does not advertise", () => {
1562 const tempDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "acp-runtime-"));
1563 const requestLogPath = NodePath.join(tempDir, "requests.ndjson");
1564 return Effect.gen(function* () {
1565 const runtime = yield* AcpSessionRuntime.AcpSessionRuntime;
1566 yield* runtime.start();
1567
1568 yield* runtime.setModel("cline-free/custom-model");
1569 const error = yield* runtime.setModel("unconfigured/model").pipe(Effect.flip);
1570 expect(error._tag).toBe("AcpRequestError");
1571
1572 const sentModels = NodeFS.readFileSync(requestLogPath, "utf8")
1573 .trim()
1574 .split("\n")
1575 .filter((line) => line.length > 0)
1576 .map((line) => JSON.parse(line) as { method?: string; params?: { value?: unknown } })
1577 .filter((message) => message.method === "session/set_config_option")
1578 .map((message) => message.params?.value);
1579 expect(sentModels).toEqual(["cline-free/custom-model"]);
1580 }).pipe(
1581 Effect.provide(
1582 AcpSessionRuntime.layer({
1583 ...mockRuntimeOptions,
1584 spawn: {
1585 command: mockAgentCommand,
1586 args: mockAgentArgs,
1587 env: { T3_ACP_REQUEST_LOG_PATH: requestLogPath },
1588 },
1589 customModels: ["cline-free/custom-model"],
1590 }),
1591 ),
1592 Effect.scoped,
1593 Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
1594 Effect.ensuring(Effect.sync(() => NodeFS.rmSync(tempDir, { recursive: true, force: true }))),
1595 );
1596 });
1597
1598 it.effect.each(
1599 (["interrupt", "wait-for-prompt"] as const).flatMap((cancelBehavior) =>
1600 (
1601 [
1602 { in: "request-log", cancelOn: "dispatch" },
1603 { in: "protocol-log", cancelOn: "log" },
1604 { in: "scheduler", cancelOn: "dispatch" },
1605 ] as const
1606 ).map((holdPrompt) => ({ cancelBehavior, holdPrompt })),
1607 ),
1608 )(
1609 "sends session/prompt before a cancel issued while the prompt is held in the $holdPrompt.in ($cancelBehavior, cancel on $holdPrompt.cancelOn)",
1610 ({ cancelBehavior, holdPrompt }) =>
1611 Effect.gen(function* () {
1612 const run = yield* promptThenCancel({ cancelBehavior, holdPrompt });
1613 expect(run.received).toEqual(["session/prompt", "session/cancel", "_test/finish-cancel"]);
1614 expect(run.promptExit).toEqual(
1615 Exit.succeed({ stopReason: "cancelled", _meta: { nativeCancel: true } }),
1616 );
1617 }).pipe(Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
1618 );
1619
1620 it.effect("sends a cancel after the cancel timeout when its prompt never goes out", () =>
1621 Effect.gen(function* () {
1622 const runtime = yield* AcpSessionRuntime.make({
1623 ...mockRuntimeOptions,
1624 interruptPromptOnCancel: false,
1625 cancelTimeout: "5 seconds",
1626 requestLogger: (event) => (isPromptStarted(event) ? Effect.never : Effect.void),
1627 });
1628 yield* runtime.start();
1629 const dispatched = yield* Deferred.make<void>();
1630 yield* runtime
1631 .prompt({ prompt: [{ type: "text", text: "first" }] }, { dispatched })
1632 .pipe(Effect.forkChild);
1633 yield* Deferred.await(dispatched);
1634 const cancel = yield* runtime.cancel.pipe(Effect.forkChild({ startImmediately: true }));
1635 yield* TestClock.adjust("5 seconds");
1636 yield* Fiber.join(cancel);
1637 }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
1638 );
1639
1640 it.effect(
1641 "sends a cancel before the next prompt when the prompt it waited for never went out",
1642 () =>
1643 Effect.gen(function* () {
1644 const tempDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "acp-runtime-"));
1645 yield* Effect.addFinalizer(() =>
1646 Effect.sync(() => NodeFS.rmSync(tempDir, { recursive: true, force: true })),
1647 );
1648 const requestLogPath = NodePath.join(tempDir, "requests.ndjson");
1649 let promptsStarted = 0;
1650 const runtime = yield* AcpSessionRuntime.make({
1651 ...mockRuntimeOptions,
1652 spawn: { ...mockRuntimeOptions.spawn, env: { T3_ACP_REQUEST_LOG_PATH: requestLogPath } },
1653 interruptPromptOnCancel: false,
1654 // The cancel spends a test-clock second in its outgoing record, the window in which the
1655 // next prompt could overtake it.
1656 protocolLogging: {
1657 logOutgoing: true,
1658 logger: (event) =>
1659 isOutgoing("session/cancel")(event) ? Effect.sleep("1 second") : Effect.void,
1660 },
1661 requestLogger: (event) =>
1662 isPromptStarted(event) && promptsStarted++ === 0 ? Effect.never : Effect.void,
1663 });
1664 yield* runtime.getEvents().pipe(
1665 Stream.runForEach((event) =>
1666 event._tag === "EventStreamBarrier"
1667 ? Deferred.succeed(event.acknowledge, undefined)
1668 : Effect.void,
1669 ),
1670 Effect.forkChild,
1671 );
1672 yield* runtime.start();
1673 const dispatched = yield* Deferred.make<void>();
1674 const first = yield* runtime
1675 .prompt({ prompt: [{ type: "text", text: "first" }] }, { dispatched })
1676 .pipe(Effect.forkChild);
1677 yield* Deferred.await(dispatched);
1678 const cancel = yield* runtime.cancel.pipe(Effect.forkChild({ startImmediately: true }));
1679 const next = yield* runtime
1680 .prompt({ prompt: [{ type: "text", text: "next" }] })
1681 .pipe(Effect.forkChild);
1682 // The first prompt ends before it is queued, which releases the cancel's wait.
1683 yield* Effect.sleep("1 second").pipe(
1684 Effect.andThen(Fiber.interrupt(first)),
1685 Effect.forkChild,
1686 );
1687 yield* TestClock.adjust("1 second");
1688 yield* TestClock.adjust("1 second");
1689 yield* Fiber.join(cancel);
1690 yield* Fiber.join(next);
1691 expect(readReceived(requestLogPath, ["session/prompt", "session/cancel"])).toEqual([
1692 "session/cancel",
1693 "session/prompt",
1694 ]);
1695 }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
1696 );
1697 });