@devries-cameron20 / t3code Mirror · read-only
Fork 0

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

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 7,257 lines 281 KB
Raw
1 import { assert, describe, it } from "@effect/vitest";
2 import * as NodeServices from "@effect/platform-node/NodeServices";
3 import {
4 CheckpointId,
5 ChatAttachmentId,
6 EnvironmentId,
7 NodeId,
8 ProviderInstanceId,
9 ProviderSessionId,
10 ProviderThreadId,
11 ProviderTurnId,
12 RunAttemptId,
13 RunId,
14 ThreadId,
15 type ChatAttachment,
16 type ModelSelection,
17 type OrchestrationV2AppThread,
18 type OrchestrationV2ProviderThread,
19 OrchestrationV2UserInputQuestion,
20 type OrchestrationV2ProviderTurn,
21 } from "@t3tools/contracts";
22 import * as Cause from "effect/Cause";
23 import * as PlatformError from "effect/PlatformError";
24 import * as DateTime from "effect/DateTime";
25 import * as Deferred from "effect/Deferred";
26 import * as Duration from "effect/Duration";
27 import * as Effect from "effect/Effect";
28 import * as Exit from "effect/Exit";
29 import * as Fiber from "effect/Fiber";
30 import * as FileSystem from "effect/FileSystem";
31 import * as Layer from "effect/Layer";
32 import * as Logger from "effect/Logger";
33 import * as Queue from "effect/Queue";
34 import * as Schema from "effect/Schema";
35 import * as Scope from "effect/Scope";
36 import * as Sink from "effect/Sink";
37 import * as Stream from "effect/Stream";
38 import * as TestClock from "effect/testing/TestClock";
39 import * as ChildProcess from "effect/process/ChildProcess";
40 import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
41
42 import * as TestProviderHost from "@t3tools/provider-testing/TestProviderHost";
43 import * as ProviderContinuationRequests from "@t3tools/provider-core/server/ProviderContinuationRequests";
44 import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
45 import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
46 import * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter";
47 import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost";
48 import { handoffBudget } from "@t3tools/provider-core/server/handoffBudget";
49 import * as HostProcess from "@t3tools/shared/HostProcess";
50 import { AgentScope } from "@t3tools/shared/AgentScope";
51 import { toolOutputImages, compactDynamicToolOutput } from "@t3tools/shared/toolOutput";
52 import {
53 makePiAdapterV2,
54 PiAdapterV2Driver,
55 PI_PROVIDER,
56 type PiAdapterV2Options,
57 } from "./adapter.ts";
58 import { makePiRpcConnection, type PiRpcRecord } from "./rpc.ts";
59 import { loadMcpBridge } from "./mcpBridge.testkit.ts";
60 import { PI_T3_SERVICE_TIER_COMMAND } from "./mcpExtensionSource.ts";
61 import { turnItemOutputText } from "../../../client-runtime/src/work-log/itemDetail.ts";
62
63 const layerTest = Layer.mergeAll(
64 NodeServices.layer,
65 IdAllocator.layer,
66 McpProviderSessions.layer,
67 TestProviderHost.layer().pipe(Layer.provide(NodeServices.layer)),
68 );
69
70 const decodeUserInputQuestions = Schema.decodeUnknownSync(
71 Schema.Array(OrchestrationV2UserInputQuestion),
72 );
73
74 const isProviderProtocolError = Schema.is(ProviderAdapter.ProviderAdapterProtocolError);
75 const decodeJsonLine = Schema.decodeSync(Schema.fromJsonString(Schema.Unknown));
76 const encodeJsonLine = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
77
78 const PI_INSTANCE_ID = ProviderInstanceId.make("pi");
79 const THREAD_ID = ThreadId.make("thread-pi-test");
80 const SESSION_ID = ProviderSessionId.make("provider-session-pi-test");
81 const FAKE_SESSION_FILE = "/fake/.pi/agent/sessions/--workspace--/0001_abc.jsonl";
82 /** Deliberately outside the valid pid range so a group-kill can never land. */
83 const FAKE_PID = 999_999_999;
84
85 const at = (seconds: number) => DateTime.makeUnsafe(seconds * 1000);
86
87 const sessionMessage = (
88 id: string,
89 parentId: string | null,
90 role: "user" | "assistant",
91 seconds: number,
92 ) => ({
93 type: "message",
94 id,
95 parentId,
96 timestamp: DateTime.formatIso(at(seconds)),
97 message: { role, content: [] },
98 });
99
100 const TURN_ONE_ENTRIES = [
101 sessionMessage("u1", null, "user", 10),
102 sessionMessage("a1", "u1", "assistant", 20),
103 sessionMessage("steer1", "a1", "user", 30),
104 sessionMessage("a1b", "steer1", "assistant", 40),
105 ];
106 const UNCAPTURED_TURN_TREE = {
107 entries: [
108 ...TURN_ONE_ENTRIES,
109 sessionMessage("u2", "a1b", "user", 110),
110 sessionMessage("a2", "u2", "assistant", 120),
111 sessionMessage("steer2", "a2", "user", 130),
112 sessionMessage("a2b", "steer2", "assistant", 140),
113 ],
114 leafId: "a2b",
115 };
116
117 function uncapturedTurns(
118 providerThreadId: ProviderThreadId,
119 window = { startedAt: 150, completedAt: 200 },
120 ): ReadonlyArray<OrchestrationV2ProviderTurn> {
121 const turn = (
122 ordinal: number,
123 nativeTurnRef: OrchestrationV2ProviderTurn["nativeTurnRef"],
124 status: OrchestrationV2ProviderTurn["status"],
125 startedAt: number,
126 completedAt: number,
127 ): OrchestrationV2ProviderTurn => ({
128 id: ProviderTurnId.make(`turn-${ordinal}`),
129 providerThreadId,
130 nodeId: NodeId.make(`node-${ordinal}`),
131 runAttemptId: null,
132 nativeTurnRef,
133 ordinal,
134 status,
135 startedAt: at(startedAt),
136 completedAt: at(completedAt),
137 });
138 return [
139 turn(1, { driver: PI_PROVIDER, nativeId: "u1", strength: "strong" }, "completed", 0, 50),
140 turn(
141 2,
142 { driver: PI_PROVIDER, nativeId: "synthetic-2", strength: "weak" },
143 "cancelled",
144 window.startedAt,
145 window.completedAt,
146 ),
147 ];
148 }
149
150 const runtimePolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
151 runtimeMode: "full-access",
152 interactionMode: "default",
153 cwd: null,
154 });
155
156 const modelSelection = (model: string): ModelSelection => ({
157 instanceId: PI_INSTANCE_ID,
158 model,
159 });
160
161 interface FakePi {
162 readonly spawner: ChildProcessSpawner.ChildProcessSpawner["Service"];
163 readonly emit: (record: PiRpcRecord, chunkBytes?: number) => Effect.Effect<void>;
164 readonly takeRequest: (type: string) => Effect.Effect<PiRpcRecord>;
165 readonly queueEntries: (data: unknown) => void;
166 readonly queueMessages: (data: unknown) => void;
167 readonly vetoNextSwitch: () => void;
168 readonly failNextFork: () => void;
169 readonly queueState: (data: Record<string, unknown>) => void;
170 readonly setStreaming: (streaming: boolean) => void;
171 readonly setCompacting: (compacting: boolean) => void;
172 readonly deferNextState: (started?: Deferred.Deferred<void>) => void;
173 readonly resolveDeferredState: (data: unknown) => Effect.Effect<void>;
174 readonly failNextState: (skip?: number) => void;
175 readonly failNextThinking: () => void;
176 readonly deferNextLifecycle: (
177 type: "switch_session" | "new_session" | "fork" | "prompt" | "abort",
178 ) => void;
179 readonly deferNextModelSelection: () => void;
180 readonly queueModels: (models: ReadonlyArray<unknown>) => void;
181 readonly vetoNextNewSession: () => void;
182 readonly allRequests: () => ReadonlyArray<PiRpcRecord>;
183 readonly promptThinkingLevels: ReadonlyArray<string>;
184 readonly promptModels: ReadonlyArray<string>;
185 /** Simulates a native extension changing Pi's active selection. */
186 readonly changeNatively: (change: {
187 readonly model?: string;
188 readonly thinking?: string;
189 }) => void;
190 /** T3 extension's service tier as each prompt was sent; Pi resets it with each session. */
191 readonly promptServiceTiers: ReadonlyArray<string | null>;
192 /** Pi reloads extensions without the adapter seeing it, e.g. a user extension's ctx.newSession(). */
193 readonly reloadExtensions: (newSessionFile?: string) => void;
194 /** Pi before 0.99 acknowledges prompts without a disposition. */
195 readonly omitPromptDisposition: () => void;
196 readonly queueStats: (data: unknown) => void;
197 /** Pi before 0.84.4 answers clear_queue as an unknown command. */
198 readonly setClearQueue: (
199 result:
200 | { readonly steering: ReadonlyArray<string>; readonly followUp: ReadonlyArray<string> }
201 | "unknown_command",
202 ) => void;
203 readonly closeStdout: Effect.Effect<void>;
204 readonly lastSpawn: () => {
205 readonly args: ReadonlyArray<string>;
206 readonly env: NonNullable<ChildProcess.CommandOptions["env"]>;
207 };
208 }
209
210 /** Pi omits `model` when none is selected and `sessionName` until one is set. */
211 const recordedIdleState = (sessionFile: string) => ({
212 thinkingLevel: "high",
213 isStreaming: false,
214 isCompacting: false,
215 steeringMode: "one-at-a-time",
216 followUpMode: "one-at-a-time",
217 sessionFile,
218 sessionId: "00000000-0000-4000-8000-000000000002",
219 autoCompactionEnabled: true,
220 messageCount: 0,
221 pendingMessageCount: 0,
222 });
223
224 /** Pi 1.4.0 rejects every prompt while compaction runs, including steers. */
225 const PI_COMPACTING_PROMPT_ERROR =
226 "Cannot submit a prompt while compaction is in progress. Wait for compaction to finish and retry.";
227
228 const makeFakePi: Effect.Effect<FakePi> = Effect.gen(function* () {
229 const stdout = yield* Queue.unbounded<Uint8Array, Cause.Done>();
230 const requests = yield* Queue.unbounded<PiRpcRecord>();
231 const entriesQueue: Array<unknown> = [];
232 const messagesQueue: Array<unknown> = [];
233 const stateQueue: Array<Record<string, unknown>> = [];
234 const statsQueue: Array<unknown> = [];
235 const allRequests: Array<PiRpcRecord> = [];
236 let deferState = false;
237 let deferredStateStarted: Deferred.Deferred<void> | undefined;
238 let deferredStateRequest: PiRpcRecord | undefined;
239 let failStateAfter: number | null = null;
240 let failThinking = false;
241 let vetoSwitch = false;
242 let failFork = false;
243 let vetoNewSession = false;
244 let deferredLifecycle: string | undefined;
245 let sessionFile = FAKE_SESSION_FILE;
246 let sessionGeneration = 0;
247 let models: ReadonlyArray<unknown> = [];
248 let isStreaming: boolean | null = null;
249 let isCompacting = false;
250 let clearQueue: Parameters<FakePi["setClearQueue"]>[0] = { steering: [], followUp: [] };
251 let stdinBuffer = "";
252 let thinkingLevel = "high";
253 const promptThinkingLevels: Array<string> = [];
254 const promptModels: Array<string> = [];
255 const promptServiceTiers: Array<string | null> = [];
256 let serviceTier: string | null = null;
257 let promptDisposition = true;
258 let currentModel = "default";
259 const serviceTierCommand = `/${PI_T3_SERVICE_TIER_COMMAND}`;
260
261 const emit = (record: PiRpcRecord, chunkBytes?: number) =>
262 Effect.gen(function* () {
263 const bytes = new TextEncoder().encode(`${encodeJsonLine(record)}\n`);
264 const size = chunkBytes ?? bytes.byteLength;
265 for (let offset = 0; offset < bytes.byteLength; offset += size) {
266 yield* Queue.offer(stdout, bytes.subarray(offset, offset + size));
267 }
268 });
269
270 const respondTo = (record: PiRpcRecord): PiRpcRecord | null => {
271 if (
272 typeof record["id"] !== "string" &&
273 !(record["type"] === "prompt" && (isStreaming !== null || isCompacting))
274 )
275 return null;
276 const base = {
277 type: "response",
278 id: record["id"],
279 command: String(record["type"]),
280 success: true,
281 };
282 switch (record["type"]) {
283 case "get_state":
284 if (failStateAfter !== null && failStateAfter-- === 0) {
285 failStateAfter = null;
286 return { ...base, success: false, error: "state unavailable" };
287 }
288 return {
289 ...base,
290 data: {
291 ...recordedIdleState(sessionFile),
292 thinkingLevel,
293 ...(currentModel === "default"
294 ? {}
295 : {
296 model: {
297 provider: currentModel.slice(0, currentModel.indexOf("/")),
298 id: currentModel.slice(currentModel.indexOf("/") + 1),
299 },
300 }),
301 isStreaming: isStreaming ?? false,
302 ...stateQueue.shift(),
303 },
304 };
305 case "set_model":
306 // Pi reapplies the target model's configured thinking default.
307 thinkingLevel = "low";
308 currentModel = `${String(record["provider"])}/${String(record["modelId"])}`;
309 return base;
310 case "set_thinking_level":
311 if (failThinking) {
312 failThinking = false;
313 return { ...base, success: false, error: "thinking unavailable" };
314 }
315 thinkingLevel = String(record["level"]);
316 return base;
317 case "prompt":
318 if (String(record["message"]).startsWith(serviceTierCommand)) {
319 serviceTier = String(record["message"]).slice(serviceTierCommand.length).trim() || null;
320 return promptDisposition ? { ...base, data: { disposition: "handled" } } : base;
321 }
322 if (isCompacting) {
323 return { ...base, success: false, error: PI_COMPACTING_PROMPT_ERROR };
324 }
325 if (isStreaming && record["streamingBehavior"] === undefined) {
326 return {
327 ...base,
328 success: false,
329 error:
330 "Agent is already processing. Specify streamingBehavior ('steer' or 'followUp') to queue the message.",
331 };
332 }
333 return promptDisposition && isStreaming
334 ? { ...base, data: { disposition: "queued" } }
335 : base;
336 case "get_available_models":
337 return { ...base, data: { models } };
338 case "new_session": {
339 const cancelled = vetoNewSession;
340 vetoNewSession = false;
341 if (!cancelled) {
342 sessionFile = `/fake/new-${++sessionGeneration}.jsonl`;
343 serviceTier = null;
344 }
345 return { ...base, data: { cancelled } };
346 }
347 case "switch_session": {
348 const cancelled = vetoSwitch;
349 vetoSwitch = false;
350 if (!cancelled) serviceTier = null;
351 return { ...base, data: { cancelled } };
352 }
353 case "get_entries":
354 return { ...base, data: entriesQueue.shift() ?? { entries: [], leafId: null } };
355 case "get_messages":
356 return { ...base, data: messagesQueue.shift() ?? { messages: [] } };
357 case "get_session_stats":
358 return { ...base, data: statsQueue.shift() ?? {} };
359 case "fork":
360 if (failFork) {
361 failFork = false;
362 return { ...base, success: false, error: "Invalid entry ID for forking" };
363 }
364 serviceTier = null;
365 return { ...base, data: { text: "Hello pi", cancelled: false } };
366 case "clear_queue":
367 return clearQueue === "unknown_command"
368 ? { ...base, success: false, error: "Unknown command: clear_queue" }
369 : { ...base, data: clearQueue };
370 default:
371 return base;
372 }
373 };
374
375 const handleStdinChunk = (chunk: Uint8Array) =>
376 Effect.gen(function* () {
377 stdinBuffer += new TextDecoder().decode(chunk);
378 while (true) {
379 const newline = stdinBuffer.indexOf("\n");
380 if (newline === -1) return;
381 const line = stdinBuffer.slice(0, newline);
382 stdinBuffer = stdinBuffer.slice(newline + 1);
383 if (line.length === 0) continue;
384 const record = decodeJsonLine(line) as PiRpcRecord;
385 if (
386 record["type"] === "prompt" &&
387 !String(record["message"]).startsWith(serviceTierCommand)
388 ) {
389 promptThinkingLevels.push(thinkingLevel);
390 promptModels.push(currentModel);
391 promptServiceTiers.push(serviceTier);
392 }
393 allRequests.push(record);
394 yield* Queue.offer(requests, record);
395 if (record["type"] === "get_state" && deferState) {
396 deferState = false;
397 deferredStateRequest = record;
398 if (deferredStateStarted !== undefined) {
399 yield* Deferred.succeed(deferredStateStarted, undefined);
400 deferredStateStarted = undefined;
401 }
402 continue;
403 }
404 if (record["type"] === deferredLifecycle) {
405 deferredLifecycle = undefined;
406 continue;
407 }
408 const response = respondTo(record);
409 if (response !== null) yield* emit(response);
410 }
411 });
412
413 let lastSpawn: ReturnType<FakePi["lastSpawn"]> = {
414 args: [],
415 env: {},
416 };
417 const spawner = ChildProcessSpawner.make((command) =>
418 Effect.sync(() => {
419 if (ChildProcess.isStandardCommand(command)) {
420 lastSpawn = {
421 args: command.args.map(String),
422 env: command.options.env ?? {},
423 };
424 }
425 return ChildProcessSpawner.makeHandle({
426 pid: ChildProcessSpawner.ProcessId(FAKE_PID),
427 exitCode: Effect.never,
428 isRunning: Effect.succeed(true),
429 kill: () => Effect.void,
430 unref: Effect.succeed(Effect.void),
431 stdin: Sink.forEach(handleStdinChunk),
432 stdout: Stream.fromQueue(stdout),
433 stderr: Stream.empty,
434 all: Stream.empty,
435 getInputFd: () => Sink.drain,
436 getOutputFd: () => Stream.empty,
437 });
438 }),
439 );
440
441 const takeRequest = (type: string): Effect.Effect<PiRpcRecord> =>
442 Effect.gen(function* () {
443 while (true) {
444 const record = yield* Queue.take(requests);
445 if (record["type"] === type) return record;
446 }
447 });
448
449 return {
450 spawner,
451 failNextThinking: () => {
452 failThinking = true;
453 },
454 promptThinkingLevels,
455 promptModels,
456 changeNatively: (change) => {
457 currentModel = change.model ?? currentModel;
458 thinkingLevel = change.thinking ?? thinkingLevel;
459 },
460 promptServiceTiers,
461 reloadExtensions: (newSessionFile) => {
462 serviceTier = null;
463 if (newSessionFile !== undefined) sessionFile = newSessionFile;
464 },
465 omitPromptDisposition: () => {
466 promptDisposition = false;
467 },
468 emit,
469 takeRequest,
470 queueEntries: (data) => entriesQueue.push(data),
471 queueMessages: (data) => messagesQueue.push(data),
472 deferNextState: (started) => {
473 deferState = true;
474 deferredStateStarted = started;
475 },
476 resolveDeferredState: (data) =>
477 Effect.gen(function* () {
478 const record = deferredStateRequest;
479 assert.isDefined(record);
480 deferredStateRequest = undefined;
481 yield* emit({
482 type: "response",
483 id: record!["id"],
484 command: "get_state",
485 success: true,
486 data,
487 });
488 }),
489 failNextState: (skip = 0) => {
490 failStateAfter = skip;
491 },
492 deferNextLifecycle: (type) => {
493 deferredLifecycle = type;
494 },
495 deferNextModelSelection: () => {
496 deferredLifecycle = "set_model";
497 },
498 queueModels: (value) => {
499 models = value;
500 },
501 vetoNextNewSession: () => {
502 vetoNewSession = true;
503 },
504 allRequests: () => allRequests,
505 vetoNextSwitch: () => {
506 vetoSwitch = true;
507 },
508 failNextFork: () => {
509 failFork = true;
510 },
511 queueState: (data) => stateQueue.push(data),
512 setStreaming: (streaming) => {
513 isStreaming = streaming;
514 },
515 setCompacting: (compacting) => {
516 isCompacting = compacting;
517 },
518 queueStats: (data) => statsQueue.push(data),
519 setClearQueue: (result) => {
520 clearQueue = result;
521 },
522 closeStdout: Queue.end(stdout),
523 lastSpawn: () => lastSpawn,
524 } satisfies FakePi;
525 });
526
527 const makeAdapter = Effect.fnUntraced(function* (
528 fake: FakePi,
529 launchArgs = "",
530 forkFake?: FakePi,
531 continuationRequests?: PiAdapterV2Options["continuationRequests"],
532 ) {
533 const spawner =
534 forkFake === undefined
535 ? fake.spawner
536 : ChildProcessSpawner.make((command) =>
537 ChildProcess.isStandardCommand(command) && command.args.includes("--fork")
538 ? forkFake.spawner.spawn(command)
539 : fake.spawner.spawn(command),
540 );
541 if (continuationRequests !== undefined) {
542 return yield* PiAdapterV2Driver.create({
543 instanceId: PI_INSTANCE_ID,
544 displayName: undefined,
545 enabled: true,
546 environment: [],
547 config: { enabled: true, binaryPath: "pi", launchArgs, customModels: [] },
548 }).pipe(
549 Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
550 Effect.provideService(HostProcess.Environment, {}),
551 Effect.provideService(ProviderContinuationRequests.ProviderContinuationRequests, {
552 ...continuationRequests,
553 take: Effect.never,
554 }),
555 );
556 }
557 return yield* makePiAdapterV2({
558 instanceId: PI_INSTANCE_ID,
559 settings: { enabled: true, binaryPath: "pi", launchArgs, customModels: [] },
560 environment: {},
561 }).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner));
562 });
563
564 const openRuntime = Effect.fnUntraced(function* (
565 fake: FakePi,
566 model = "default",
567 threadId = THREAD_ID,
568 providerSessionId = SESSION_ID,
569 forkFake?: FakePi,
570 continuationRequests?: PiAdapterV2Options["continuationRequests"],
571 initialNativeThreadId?: string,
572 ) {
573 const adapter = yield* makeAdapter(fake, "", forkFake, continuationRequests);
574 const runtime = yield* adapter.openSession({
575 threadId,
576 providerSessionId,
577 modelSelection: modelSelection(model),
578 runtimePolicy,
579 ...(initialNativeThreadId === undefined ? {} : { initialNativeThreadId }),
580 });
581 const emitted = yield* Queue.unbounded<ProviderAdapter.ProviderAdapterV2Event>();
582 yield* runtime.events.pipe(
583 Stream.runForEach((event) => Queue.offer(emitted, event)),
584 Effect.forkScoped,
585 );
586 const takeEvent = (predicate: (event: ProviderAdapter.ProviderAdapterV2Event) => boolean) =>
587 Effect.gen(function* () {
588 while (true) {
589 const event = yield* Queue.take(emitted);
590 if (predicate(event)) return event;
591 }
592 });
593 return { runtime, takeEvent };
594 });
595
596 const makeAppThread = Effect.fnUntraced(function* (model: string, threadId = THREAD_ID) {
597 const now = yield* DateTime.now;
598 return {
599 createdBy: "user",
600 creationSource: "web",
601 id: threadId,
602 projectId: "project:fixture:pi" as OrchestrationV2AppThread["projectId"],
603 title: "Pi test thread",
604 providerInstanceId: PI_INSTANCE_ID,
605 modelSelection: modelSelection(model),
606 runtimeMode: "full-access",
607 interactionMode: "default",
608 branch: null,
609 worktreePath: null,
610 activeProviderThreadId: null,
611 lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: threadId },
612 forkedFrom: null,
613 createdAt: now,
614 updatedAt: now,
615 archivedAt: null,
616 settledOverride: null,
617 settledAt: null,
618 lastVisitedAt: null,
619 deletedAt: null,
620 } satisfies OrchestrationV2AppThread;
621 });
622
623 const startTurn = Effect.fnUntraced(function* (
624 runtime: ProviderAdapter.ProviderAdapterV2SessionRuntime,
625 providerThread: OrchestrationV2ProviderThread,
626 model = "default",
627 attachments: ReadonlyArray<ChatAttachment> = [],
628 text = "Hello pi",
629 selection?: ModelSelection,
630 runOrdinal = 1,
631 threadId = THREAD_ID,
632 continuation = false,
633 ) {
634 const appThread = yield* makeAppThread(model, threadId);
635 const runId = RunId.make(`run:${threadId}:${runOrdinal}`);
636 yield* runtime.startTurn({
637 appThread,
638 threadId,
639 runId,
640 runOrdinal,
641 providerTurnOrdinal: runOrdinal,
642 attemptId: RunAttemptId.make(`run-attempt:${runId}:1`),
643 rootNodeId: NodeId.make(`node:${runId}:root`),
644 providerThread,
645 message: {
646 messageId: `message:${threadId}:${runOrdinal}` as never,
647 text,
648 attachments,
649 createdBy: continuation ? "agent" : "user",
650 creationSource: continuation ? "provider" : "web",
651 },
652 modelSelection: selection ?? modelSelection(model),
653 runtimePolicy,
654 });
655 });
656
657 describe("PiAdapterV2", () => {
658 it.effect(
659 "replaces keyed extension statuses while idle without producing conversation items",
660 () =>
661 Effect.gen(function* () {
662 const fake = yield* makeFakePi;
663 const { runtime, takeEvent } = yield* openRuntime(fake);
664 const updates = [
665 { statusKey: "watch", statusText: "\u001b[32mWatching 3 files\u001b[0m\u0007" },
666 { statusKey: "lint", statusText: "Lint clean" },
667 { statusKey: "watch", statusText: "Watching 4 files" },
668 { statusKey: "watch", statusText: "Watching 4 files" },
669 { statusKey: "watch", statusText: "\u001b[32mWatching 4 files\u001b[0m" },
670 { statusKey: "lint", statusText: "" },
671 { statusKey: "missing" },
672 { statusKey: "watch" },
673 { statusKey: "watch", statusText: "Watching 4 files" },
674 ];
675 for (const update of updates) {
676 yield* fake.emit({ type: "extension_ui_request", method: "setStatus", ...update });
677 }
678 // The following dialog is an observable milestone after the preceding native notifications.
679 yield* fake.emit({
680 type: "extension_ui_request",
681 id: "status-barrier",
682 method: "input",
683 title: "Continue?",
684 });
685 const observed: ProviderAdapter.ProviderAdapterV2Event[] = [];
686 yield* takeEvent((event) => {
687 observed.push(event);
688 return event.type === "runtime_request.updated";
689 });
690 assert.deepInclude(runtime.providerSession, {
691 extensionStatuses: [{ key: "watch", text: "Watching 4 files" }],
692 });
693 const snapshots = observed.filter((event) => event.type === "provider_session.updated");
694 assert.lengthOf(snapshots, 6);
695 assert.deepInclude(snapshots[0]?.providerSession, {
696 extensionStatuses: [{ key: "watch", text: "Watching 3 files" }],
697 });
698 assert.deepInclude(snapshots[2]?.providerSession, {
699 extensionStatuses: [
700 { key: "watch", text: "Watching 4 files" },
701 { key: "lint", text: "Lint clean" },
702 ],
703 });
704 assert.isFalse(observed.some((event) => event.type === "message.updated"));
705 assert.isFalse(
706 observed.some(
707 (event) =>
708 event.type === "turn_item.updated" && event.turnItem.type !== "user_input_request",
709 ),
710 );
711 assert.isFalse(
712 fake.allRequests().some((request) => request["type"] === "extension_ui_response"),
713 );
714 }).pipe(Effect.scoped, Effect.provide(layerTest)),
715 );
716
717 it.effect("bounds native extension statuses and lets cleared keys free capacity", () =>
718 Effect.gen(function* () {
719 const fake = yield* makeFakePi;
720 const { runtime, takeEvent } = yield* openRuntime(fake);
721 for (let index = 0; index < 35; index++) {
722 yield* fake.emit({
723 type: "extension_ui_request",
724 method: "setStatus",
725 statusKey: `key-${index}`,
726 statusText: index === 1 ? "w".repeat(20000) : "Watching",
727 });
728 }
729 for (const update of [
730 { statusKey: "" },
731 { statusKey: "x".repeat(257) },
732 { statusKey: "malformed", statusText: null },
733 ]) {
734 yield* fake.emit({
735 type: "extension_ui_request",
736 method: "setStatus",
737 statusText: "Invalid",
738 ...update,
739 });
740 }
741 yield* fake.emit({ type: "extension_ui_request", method: "setStatus", statusKey: "key-0" });
742 yield* fake.emit({
743 type: "extension_ui_request",
744 method: "setStatus",
745 statusKey: "replacement",
746 statusText: "New status",
747 });
748 yield* fake.emit({
749 type: "extension_ui_request",
750 id: "status-barrier",
751 method: "input",
752 title: "Continue?",
753 });
754 yield* takeEvent((event) => event.type === "runtime_request.updated");
755 const statuses = runtime.providerSession.extensionStatuses ?? [];
756 assert.lengthOf(statuses, 32);
757 assert.equal(statuses[0]?.key, "key-1");
758 assert.equal(statuses[0]?.text.length, 4096);
759 assert.deepEqual(statuses.at(-1), { key: "replacement", text: "New status" });
760 }).pipe(Effect.scoped, Effect.provide(layerTest)),
761 );
762
763 it.effect("publishes extension status while native work awaits adoption", () =>
764 Effect.gen(function* () {
765 const fake = yield* makeFakePi;
766 const offers =
767 yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
768 const { runtime, takeEvent } = yield* openRuntime(
769 fake,
770 "default",
771 THREAD_ID,
772 SESSION_ID,
773 undefined,
774 { offer: (offer) => Queue.offer(offers, offer).pipe(Effect.asVoid) },
775 );
776 yield* runtime.ensureThread({
777 threadId: THREAD_ID,
778 modelSelection: modelSelection("default"),
779 runtimePolicy,
780 });
781 yield* fake.emit({ type: "agent_start" });
782 yield* Queue.take(offers);
783 yield* fake.emit({
784 type: "extension_ui_request",
785 method: "setStatus",
786 statusKey: "watch",
787 statusText: "Native wake",
788 });
789 yield* fake.emit({
790 type: "extension_ui_request",
791 id: "status-barrier",
792 method: "input",
793 title: "Continue?",
794 });
795 yield* takeEvent((event) => event.type === "runtime_request.updated");
796 assert.deepEqual(runtime.providerSession.extensionStatuses, [
797 { key: "watch", text: "Native wake" },
798 ]);
799 assert.isTrue(yield* runtime.hasPendingBackgroundWork!);
800 }).pipe(Effect.scoped, Effect.provide(layerTest)),
801 );
802
803 it.effect(
804 "keeps extension status through turn settlement and clears it on native session replacement",
805 () =>
806 Effect.gen(function* () {
807 const fake = yield* makeFakePi;
808 const { runtime, takeEvent } = yield* openRuntime(fake);
809 const providerThread = yield* runtime.ensureThread({
810 threadId: THREAD_ID,
811 modelSelection: modelSelection("default"),
812 runtimePolicy,
813 });
814 yield* startTurn(runtime, providerThread);
815 yield* fake.takeRequest("prompt");
816 yield* fake.emit({
817 type: "extension_ui_request",
818 method: "setStatus",
819 statusKey: "watch",
820 statusText: "Watching",
821 });
822 yield* fake.emit({ type: "agent_settled" });
823 yield* takeEvent((event) => event.type === "turn.terminal");
824 assert.deepInclude(runtime.providerSession, {
825 status: "ready",
826 extensionStatuses: [{ key: "watch", text: "Watching" }],
827 });
828 yield* startTurn(
829 runtime,
830 providerThread,
831 "anthropic/other-model",
832 [],
833 "Hello again",
834 undefined,
835 2,
836 );
837 assert.deepEqual(runtime.providerSession.extensionStatuses, [
838 { key: "watch", text: "Watching" },
839 ]);
840 yield* fake.emit({ type: "agent_settled" });
841 yield* takeEvent((event) => event.type === "turn.terminal");
842 yield* runtime.ensureThread({
843 threadId: THREAD_ID,
844 modelSelection: modelSelection("default"),
845 runtimePolicy,
846 });
847 assert.deepInclude(runtime.providerSession, { extensionStatuses: [] });
848 }).pipe(Effect.scoped, Effect.provide(layerTest)),
849 );
850
851 it.effect.each(["model error", "rejected prompt", "failed compact"] as const)(
852 "keeps extension status through a reusable %s and the next turn",
853 (failure) =>
854 Effect.gen(function* () {
855 const fake = yield* makeFakePi;
856 const { runtime, takeEvent } = yield* openRuntime(fake);
857 const providerThread = yield* runtime.ensureThread({
858 threadId: THREAD_ID,
859 modelSelection: modelSelection("default"),
860 runtimePolicy,
861 });
862 yield* fake.emit({
863 type: "extension_ui_request",
864 method: "setStatus",
865 statusKey: "watch",
866 statusText: "Watching 3 files",
867 });
868 const command = failure === "failed compact" ? "compact" : "prompt";
869 if (failure === "rejected prompt") fake.deferNextLifecycle("prompt");
870 yield* startTurn(
871 runtime,
872 providerThread,
873 "default",
874 [],
875 command === "compact" ? "/compact" : "Hello pi",
876 );
877 yield* fake.takeRequest(command);
878 if (failure === "model error") {
879 yield* fake.emit({
880 type: "message_end",
881 message: { role: "assistant", stopReason: "error", errorMessage: "Rate limited" },
882 });
883 yield* fake.emit({ type: "agent_settled" });
884 } else {
885 yield* fake.emit({
886 type: "response",
887 command,
888 success: false,
889 error: "Request rejected",
890 });
891 }
892 const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
893 assert.isTrue(terminal.type === "turn.terminal" && terminal.status === "failed");
894 assert.deepInclude(runtime.providerSession, {
895 status: "error",
896 extensionStatuses: [{ key: "watch", text: "Watching 3 files" }],
897 });
898
899 yield* fake.emit({
900 type: "extension_ui_request",
901 method: "setStatus",
902 statusKey: "watch",
903 statusText: "Watching 4 files",
904 });
905 yield* fake.emit({
906 type: "extension_ui_request",
907 id: "failed-turn-status-barrier",
908 method: "input",
909 title: "Continue?",
910 });
911 yield* takeEvent((event) => event.type === "runtime_request.updated");
912 assert.deepInclude(runtime.providerSession, {
913 status: "error",
914 extensionStatuses: [{ key: "watch", text: "Watching 4 files" }],
915 });
916
917 yield* startTurn(runtime, providerThread, "default", [], "Hello again", undefined, 2);
918 yield* fake.takeRequest("prompt");
919 yield* fake.emit({ type: "agent_settled" });
920 const nextTerminal = yield* takeEvent((event) => event.type === "turn.terminal");
921 assert.isTrue(nextTerminal.type === "turn.terminal" && nextTerminal.status === "completed");
922 assert.deepInclude(runtime.providerSession, {
923 id: SESSION_ID,
924 status: "ready",
925 extensionStatuses: [{ key: "watch", text: "Watching 4 files" }],
926 });
927 }).pipe(Effect.scoped, Effect.provide(layerTest)),
928 );
929
930 it.effect("preserves extension statuses when a native session switch is vetoed", () =>
931 Effect.gen(function* () {
932 const fake = yield* makeFakePi;
933 const { runtime, takeEvent } = yield* openRuntime(fake);
934 const providerThread = yield* runtime.ensureThread({
935 threadId: THREAD_ID,
936 modelSelection: modelSelection("default"),
937 runtimePolicy,
938 });
939 yield* fake.emit({
940 type: "extension_ui_request",
941 method: "setStatus",
942 statusKey: "watch",
943 statusText: "Watching",
944 });
945 yield* fake.emit({
946 type: "extension_ui_request",
947 id: "status-barrier",
948 method: "input",
949 title: "Continue?",
950 });
951 yield* takeEvent((event) => event.type === "runtime_request.updated");
952 fake.queueState({ sessionFile: "/fake/other-session.jsonl" });
953 fake.vetoNextSwitch();
954 const exit = yield* runtime.resumeThread({ providerThread }).pipe(Effect.exit);
955 assert.isTrue(Exit.isFailure(exit));
956 assert.deepEqual(runtime.providerSession.extensionStatuses, [
957 { key: "watch", text: "Watching" },
958 ]);
959 }).pipe(Effect.scoped, Effect.provide(layerTest)),
960 );
961
962 it.effect.each(["success", "cancelled", "error"] as const)(
963 "handles native status publications during session switch hooks, outcome=%s",
964 (outcome) =>
965 Effect.gen(function* () {
966 const fake = yield* makeFakePi;
967 const { runtime, takeEvent } = yield* openRuntime(fake);
968 const providerThread = yield* runtime.ensureThread({
969 threadId: THREAD_ID,
970 modelSelection: modelSelection("default"),
971 runtimePolicy,
972 });
973 for (const key of ["watch", "lint"])
974 yield* fake.emit({
975 type: "extension_ui_request",
976 method: "setStatus",
977 statusKey: key,
978 statusText: key === "lint" ? "Lint clean" : "Watching",
979 });
980 fake.queueState({ sessionFile: "/fake/other-session.jsonl" });
981 fake.deferNextLifecycle("switch_session");
982 const switching = yield* runtime
983 .resumeThread({ providerThread })
984 .pipe(Effect.exit, Effect.forkScoped);
985 const request = yield* fake.takeRequest("switch_session");
986 yield* fake.emit({ type: "extension_ui_request", method: "setStatus", statusKey: "watch" });
987 yield* fake.emit({
988 type: "extension_ui_request",
989 method: "setStatus",
990 statusKey: "startup",
991 statusText: "Fresh status",
992 });
993 yield* fake.emit({
994 type: "extension_ui_request",
995 id: "switch-hook",
996 method: "input",
997 title: "Continue?",
998 });
999 yield* takeEvent((event) => event.type === "runtime_request.updated");
1000 yield* fake.emit({
1001 type: "response",
1002 id: request["id"],
1003 command: "switch_session",
1004 success: outcome !== "error",
1005 data: { cancelled: outcome === "cancelled" },
1006 ...(outcome === "error" ? { error: "Session replacement failed" } : {}),
1007 });
1008 const exit = yield* Fiber.join(switching);
1009 assert.equal(Exit.isFailure(exit), outcome !== "success");
1010 if (outcome === "error") {
1011 const reuse = yield* runtime.resumeThread({ providerThread }).pipe(Effect.exit);
1012 assert.isTrue(Exit.isFailure(reuse));
1013 yield* takeEvent(
1014 (event) =>
1015 event.type === "provider_session.updated" && event.providerSession.status === "error",
1016 );
1017 assert.deepEqual(runtime.providerSession.extensionStatuses, []);
1018 return;
1019 }
1020 assert.deepEqual(runtime.providerSession.extensionStatuses, [
1021 ...(outcome === "cancelled" ? [{ key: "lint", text: "Lint clean" }] : []),
1022 { key: "startup", text: "Fresh status" },
1023 ]);
1024 }).pipe(Effect.scoped, Effect.provide(layerTest)),
1025 );
1026
1027 it.effect.each(["stop", "transport death"] as const)(
1028 "clears extension statuses on %s",
1029 (retirement) =>
1030 Effect.gen(function* () {
1031 const fake = yield* makeFakePi;
1032 const { runtime, takeEvent } = yield* openRuntime(fake);
1033 const providerThread = yield* runtime.ensureThread({
1034 threadId: THREAD_ID,
1035 modelSelection: modelSelection("default"),
1036 runtimePolicy,
1037 });
1038 yield* startTurn(runtime, providerThread);
1039 const turnStarted = yield* takeEvent((event) => event.type === "provider_turn.updated");
1040 assert.equal(turnStarted.type, "provider_turn.updated");
1041 if (turnStarted.type !== "provider_turn.updated") return;
1042 yield* fake.emit({
1043 type: "extension_ui_request",
1044 method: "setStatus",
1045 statusKey: "watch",
1046 statusText: "Watching",
1047 });
1048 yield* fake.emit({
1049 type: "extension_ui_request",
1050 id: "status-barrier",
1051 method: "input",
1052 title: "Continue?",
1053 });
1054 yield* takeEvent((event) => event.type === "runtime_request.updated");
1055 assert.deepInclude(runtime.providerSession, {
1056 extensionStatuses: [{ key: "watch", text: "Watching" }],
1057 });
1058 if (retirement === "stop") {
1059 yield* runtime.interruptTurn({
1060 providerThread,
1061 providerTurnId: turnStarted.providerTurn.id,
1062 requestRuntimeRestart: true,
1063 });
1064 } else yield* fake.closeStdout;
1065 yield* takeEvent(
1066 (event) =>
1067 event.type === "provider_session.updated" &&
1068 event.providerSession.status === (retirement === "stop" ? "stopped" : "error"),
1069 );
1070 assert.deepInclude(runtime.providerSession, { extensionStatuses: [] });
1071 }).pipe(Effect.scoped, Effect.provide(layerTest)),
1072 );
1073
1074 // Session release interrupts open tool calls, such as a worktree handoff's, only with this flag.
1075 it.effect("declares that its tool calls end with its process", () =>
1076 Effect.gen(function* () {
1077 const { runtime } = yield* openRuntime(yield* makeFakePi);
1078 assert.isTrue(runtime.backgroundTasksEndWithProcess);
1079 }).pipe(Effect.scoped, Effect.provide(layerTest)),
1080 );
1081
1082 it.effect("keeps native image bytes and the saved path in the prompt", () =>
1083 Effect.gen(function* () {
1084 const host = yield* ProviderHost.ProviderHost;
1085 const fileSystem = yield* FileSystem.FileSystem;
1086 const attachment: ChatAttachment = {
1087 id: ChatAttachmentId.make("image"),
1088 type: "image",
1089 name: "image.png",
1090 mimeType: "image/png",
1091 sizeBytes: 3,
1092 };
1093 const path = host.resolveAttachmentPath(attachment)!;
1094 yield* fileSystem.writeFile(path, new Uint8Array([1, 2, 3]));
1095 const fake = yield* makeFakePi;
1096 const { runtime } = yield* openRuntime(fake);
1097 const providerThread = yield* runtime.ensureThread({
1098 threadId: THREAD_ID,
1099 modelSelection: modelSelection("default"),
1100 runtimePolicy,
1101 });
1102 yield* startTurn(runtime, providerThread, "default", [attachment]);
1103 const prompt = yield* fake.takeRequest("prompt");
1104 assert.include(String(prompt["message"]), path);
1105 assert.deepEqual(prompt["images"], [{ type: "image", data: "AQID", mimeType: "image/png" }]);
1106 }).pipe(Effect.scoped, Effect.provide(layerTest)),
1107 );
1108
1109 it.effect("lists unavailable attachments alongside resolvable files in the native prompt", () =>
1110 Effect.gen(function* () {
1111 const host = yield* ProviderHost.ProviderHost;
1112 const fake = yield* makeFakePi;
1113 const { runtime } = yield* openRuntime(fake).pipe(
1114 Effect.provideService(ProviderHost.ProviderHost, {
1115 ...host,
1116 resolveAttachmentPath: (attachment) =>
1117 attachment.id === "available" ? host.resolveAttachmentPath(attachment) : null,
1118 }),
1119 );
1120 const providerThread = yield* runtime.ensureThread({
1121 threadId: THREAD_ID,
1122 modelSelection: modelSelection("default"),
1123 runtimePolicy,
1124 });
1125 const attachments: ReadonlyArray<ChatAttachment> = [
1126 {
1127 id: ChatAttachmentId.make("available"),
1128 type: "file",
1129 name: "notes.txt",
1130 mimeType: "text/plain",
1131 sizeBytes: 1,
1132 },
1133 {
1134 id: ChatAttachmentId.make("missing-file"),
1135 type: "file",
1136 name: "missing.txt",
1137 mimeType: "text/plain",
1138 sizeBytes: 1,
1139 },
1140 {
1141 id: ChatAttachmentId.make("missing-image"),
1142 type: "image",
1143 name: "missing.png",
1144 mimeType: "image/png",
1145 sizeBytes: 1,
1146 },
1147 {
1148 id: ChatAttachmentId.make("missing-future"),
1149 type: "future",
1150 name: "future.bin",
1151 mimeType: "application/octet-stream",
1152 sizeBytes: 1,
1153 },
1154 ];
1155 yield* startTurn(runtime, providerThread, "default", attachments);
1156 const prompt = yield* fake.takeRequest("prompt");
1157 assert.isString(prompt["message"]);
1158 const message = String(prompt["message"]);
1159 assert.include(message, host.resolveAttachmentPath(attachments[0]!)!);
1160 for (const attachment of attachments.slice(1)) {
1161 assert.include(message, attachment.name);
1162 assert.include(message, attachment.id);
1163 }
1164 assert.equal((message.match(/unavailable/g) ?? []).length, 3);
1165 }).pipe(Effect.scoped, Effect.provide(layerTest)),
1166 );
1167
1168 it.effect.each([false, true])(
1169 "completes a resumed user turn before native wake events arrive, Pi streaming=%s",
1170 (streaming) =>
1171 Effect.gen(function* () {
1172 const fake = yield* makeFakePi;
1173 const { runtime, takeEvent } = yield* openRuntime(fake);
1174 const providerThread = yield* runtime.ensureThread({
1175 threadId: THREAD_ID,
1176 modelSelection: modelSelection("default"),
1177 runtimePolicy,
1178 });
1179 fake.setStreaming(streaming);
1180 yield* runtime.resumeThread({ providerThread });
1181 yield* startTurn(runtime, providerThread);
1182 yield* fake.takeRequest("prompt");
1183 yield* fake.emit({ type: "agent_start" });
1184 yield* fake.emit({
1185 type: "message_end",
1186 message: {
1187 role: "assistant",
1188 content: [{ type: "text", text: "Resumed prompt completed" }],
1189 stopReason: "stop",
1190 },
1191 });
1192 fake.queueState({ isStreaming: false });
1193 yield* fake.emit({ type: "agent_settled" });
1194 const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
1195 assert.isTrue(terminal.type === "turn.terminal" && terminal.status === "completed");
1196 }).pipe(Effect.scoped, Effect.provide(layerTest)),
1197 );
1198
1199 it.effect.each([false, true])(
1200 "serializes rollback fork hooks with native wake ownership, wake=%s",
1201 (nativeWake) =>
1202 Effect.gen(function* () {
1203 const fake = yield* makeFakePi;
1204 const offers =
1205 yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
1206 const { runtime, takeEvent } = yield* openRuntime(
1207 fake,
1208 "default",
1209 THREAD_ID,
1210 SESSION_ID,
1211 undefined,
1212 {
1213 offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
1214 },
1215 );
1216 const providerThread = yield* runtime.ensureThread({
1217 threadId: THREAD_ID,
1218 modelSelection: modelSelection("default"),
1219 runtimePolicy,
1220 });
1221 fake.deferNextLifecycle("fork");
1222 const rollingBack = yield* runtime
1223 .rollbackThread({
1224 providerThread,
1225 target: {
1226 type: "thread_start",
1227 checkpointId: CheckpointId.make("checkpoint-start"),
1228 appRunOrdinal: 0,
1229 },
1230 providerThreadTurns: [
1231 {
1232 id: ProviderTurnId.make("previous-turn"),
1233 providerThreadId: providerThread.id,
1234 nodeId: NodeId.make("previous-node"),
1235 runAttemptId: null,
1236 nativeTurnRef: {
1237 driver: PI_PROVIDER,
1238 nativeId: "user-before-wake",
1239 strength: "strong",
1240 },
1241 ordinal: 1,
1242 status: "completed",
1243 startedAt: providerThread.createdAt,
1244 completedAt: providerThread.createdAt,
1245 },
1246 ],
1247 })
1248 .pipe(Effect.result, Effect.forkScoped);
1249 const fork = yield* fake.takeRequest("fork");
1250 const overlappingTurn = yield* startTurn(runtime, providerThread).pipe(Effect.result);
1251 assert.equal(overlappingTurn._tag, "Failure");
1252 const overlappingRegistration = yield* runtime
1253 .ensureThread({
1254 threadId: THREAD_ID,
1255 modelSelection: modelSelection("default"),
1256 runtimePolicy,
1257 })
1258 .pipe(Effect.result);
1259 assert.equal(overlappingRegistration._tag, "Failure");
1260 yield* fake.emit({
1261 type: "extension_ui_request",
1262 id: "fork-hook-dialog",
1263 method: "confirm",
1264 title: "Restore this branch?",
1265 });
1266 const forkDialog = yield* takeEvent((event) => event.type === "runtime_request.updated");
1267 assert.isTrue(forkDialog.type === "runtime_request.updated");
1268 if (forkDialog.type !== "runtime_request.updated") return;
1269 assert.isNull(forkDialog.runtimeRequest.providerTurnId);
1270 yield* runtime.respondToRuntimeRequest({
1271 requestId: forkDialog.runtimeRequest.id,
1272 decision: "accept",
1273 });
1274 yield* fake.takeRequest("extension_ui_response");
1275 if (nativeWake) {
1276 yield* fake.emit({ type: "agent_start" });
1277 yield* fake.emit({ type: "message_start", message: { role: "assistant" } });
1278 yield* fake.emit({
1279 type: "message_update",
1280 assistantMessageEvent: {
1281 type: "text_end",
1282 contentIndex: 0,
1283 content: "Discarded branch wake output",
1284 },
1285 });
1286 yield* fake.emit({ type: "agent_settled" });
1287 const retired = yield* takeEvent(
1288 (event) =>
1289 event.type === "provider_session.updated" &&
1290 event.providerSession.status === "stopped",
1291 ).pipe(Effect.as(true), Effect.raceFirst(Queue.take(offers).pipe(Effect.as(false))));
1292 assert.isTrue(retired, "Pi offered native work while rollback was changing its binding");
1293 const result = yield* Fiber.join(rollingBack);
1294 assert.equal(result._tag, "Failure");
1295 assert.isFalse(yield* runtime.hasPendingBackgroundWork!);
1296 const staleTurn = yield* startTurn(
1297 runtime,
1298 providerThread,
1299 "default",
1300 [],
1301 "Synthetic wake",
1302 undefined,
1303 1,
1304 THREAD_ID,
1305 true,
1306 ).pipe(Effect.result);
1307 assert.equal(staleTurn._tag, "Failure");
1308 assert.isFalse(fake.allRequests().some((request) => request["type"] === "prompt"));
1309 return;
1310 }
1311 fake.queueState({ sessionFile: "/fake/rolled-back-session.jsonl" });
1312 yield* fake.emit({
1313 type: "response",
1314 id: fork["id"],
1315 command: "fork",
1316 success: true,
1317 data: { cancelled: false },
1318 });
1319 const result = yield* Fiber.join(rollingBack);
1320 assert.equal(result._tag, "Success");
1321 if (result._tag !== "Success") return;
1322 assert.equal(
1323 result.success.providerThread.nativeThreadRef?.nativeId,
1324 "/fake/rolled-back-session.jsonl",
1325 );
1326 yield* startTurn(runtime, result.success.providerThread);
1327 const prompt = yield* fake.takeRequest("prompt");
1328 assert.equal(prompt["message"], "Hello pi");
1329 yield* fake.emit({ type: "response", command: "prompt", success: true });
1330 yield* fake.emit({ type: "agent_start" });
1331 yield* fake.emit({ type: "agent_settled" });
1332 const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
1333 assert.isTrue(terminal.type === "turn.terminal" && terminal.status === "completed");
1334 }).pipe(Effect.scoped, Effect.provide(layerTest)),
1335 );
1336
1337 it.effect.each([false, true])(
1338 "retains native wake ownership and delivers a joining prompt held through compaction, aborted=%s",
1339 (aborted) =>
1340 Effect.gen(function* () {
1341 const fake = yield* makeFakePi;
1342 const offers =
1343 yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
1344 const { runtime, takeEvent } = yield* openRuntime(
1345 fake,
1346 "default",
1347 THREAD_ID,
1348 SESSION_ID,
1349 undefined,
1350 {
1351 offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
1352 },
1353 );
1354 const providerThread = yield* runtime.ensureThread({
1355 threadId: THREAD_ID,
1356 modelSelection: modelSelection("default"),
1357 runtimePolicy,
1358 });
1359 yield* fake.takeRequest("get_state");
1360 yield* fake.emit({ type: "agent_start" });
1361 yield* Queue.take(offers);
1362 yield* fake.emit({ type: "agent_settled" });
1363 yield* fake.emit({ type: "compaction_start", reason: "manual" });
1364 fake.deferNextLifecycle("prompt");
1365 yield* startTurn(runtime, providerThread);
1366 yield* fake.emit({
1367 type: "extension_ui_request",
1368 id: "native-compaction-dialog",
1369 method: "confirm",
1370 title: "Continue native work?",
1371 });
1372 const dialog = yield* takeEvent((event) => event.type === "runtime_request.updated");
1373 assert.isTrue(dialog.type === "runtime_request.updated");
1374 if (dialog.type !== "runtime_request.updated") return;
1375 assert.isNotNull(dialog.runtimeRequest.providerTurnId);
1376 yield* runtime.respondToRuntimeRequest({
1377 requestId: dialog.runtimeRequest.id,
1378 decision: "accept",
1379 });
1380 yield* fake.takeRequest("extension_ui_response");
1381 assert.isFalse(fake.allRequests().some((request) => request["type"] === "prompt"));
1382 yield* fake.emit(
1383 aborted
1384 ? { type: "compaction_end", result: null, aborted: true }
1385 : {
1386 type: "compaction_end",
1387 result: { summary: "Native compaction finished" },
1388 willRetry: true,
1389 },
1390 );
1391 const prompt = yield* fake.takeRequest("prompt");
1392 assert.equal(prompt["message"], "Hello pi");
1393 fake.queueState({ isStreaming: true });
1394 yield* fake.emit({ type: "response", command: "prompt", success: true });
1395 yield* fake.takeRequest("get_state");
1396 yield* fake.emit({ type: "agent_start" });
1397 yield* fake.emit({ type: "message_start", message: { role: "assistant" } });
1398 yield* fake.emit({
1399 type: "message_update",
1400 assistantMessageEvent: {
1401 type: "text_end",
1402 contentIndex: 0,
1403 content: "Native work completed",
1404 },
1405 });
1406 const message = yield* takeEvent((event) => event.type === "message.updated");
1407 assert.isTrue(message.type === "message.updated" && message.message.runId !== null);
1408 yield* fake.emit({ type: "agent_settled" });
1409 const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
1410 assert.isTrue(terminal.type === "turn.terminal" && terminal.status === "completed");
1411 assert.equal(
1412 fake.allRequests().filter((request) => request["type"] === "prompt").length,
1413 1,
1414 );
1415 }).pipe(Effect.scoped, Effect.provide(layerTest)),
1416 );
1417
1418 it.effect("rejects rollback while native wake output is awaiting ownership", () =>
1419 Effect.gen(function* () {
1420 const fake = yield* makeFakePi;
1421 const offers =
1422 yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
1423 const { runtime, takeEvent } = yield* openRuntime(
1424 fake,
1425 "default",
1426 THREAD_ID,
1427 SESSION_ID,
1428 undefined,
1429 {
1430 offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
1431 },
1432 );
1433 const providerThread = yield* runtime.ensureThread({
1434 threadId: THREAD_ID,
1435 modelSelection: modelSelection("default"),
1436 runtimePolicy,
1437 });
1438 yield* fake.emit({ type: "agent_start" });
1439 yield* Queue.take(offers);
1440 yield* fake.emit({ type: "message_start", message: { role: "assistant" } });
1441 yield* fake.emit({
1442 type: "message_update",
1443 assistantMessageEvent: {
1444 type: "text_end",
1445 contentIndex: 0,
1446 content: "Current branch wake output",
1447 },
1448 });
1449 yield* fake.emit({ type: "agent_settled" });
1450 yield* takeEvent(
1451 (event) =>
1452 event.type === "provider_session.updated" && event.providerSession.status === "ready",
1453 );
1454 const rolledBack = yield* runtime
1455 .rollbackThread({
1456 providerThread,
1457 target: {
1458 type: "thread_start",
1459 checkpointId: CheckpointId.make("checkpoint-start"),
1460 appRunOrdinal: 0,
1461 },
1462 providerThreadTurns: [
1463 {
1464 id: ProviderTurnId.make("previous-turn"),
1465 providerThreadId: providerThread.id,
1466 nodeId: NodeId.make("previous-node"),
1467 runAttemptId: null,
1468 nativeTurnRef: {
1469 driver: PI_PROVIDER,
1470 nativeId: "user-before-wake",
1471 strength: "strong",
1472 },
1473 ordinal: 1,
1474 status: "completed",
1475 startedAt: providerThread.createdAt,
1476 completedAt: providerThread.createdAt,
1477 },
1478 ],
1479 })
1480 .pipe(Effect.result);
1481 assert.equal(
1482 rolledBack._tag,
1483 "Failure",
1484 "Rollback changed the native session while its wake was still buffered",
1485 );
1486 assert.isFalse(fake.allRequests().some((request) => request["type"] === "fork"));
1487 assert.isTrue(yield* runtime.hasPendingBackgroundWork!);
1488 yield* startTurn(
1489 runtime,
1490 providerThread,
1491 "default",
1492 [],
1493 "Synthetic wake",
1494 undefined,
1495 1,
1496 THREAD_ID,
1497 true,
1498 );
1499 const message = yield* takeEvent((event) => event.type === "message.updated");
1500 assert.equal(
1501 message.type === "message.updated" && message.message.text,
1502 "Current branch wake output",
1503 );
1504 yield* takeEvent((event) => event.type === "turn.terminal");
1505 }).pipe(Effect.scoped, Effect.provide(layerTest)),
1506 );
1507
1508 it.effect("answers model-selection dialogs before a user turn claims a native wake", () =>
1509 Effect.gen(function* () {
1510 const fake = yield* makeFakePi;
1511 const offers =
1512 yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
1513 const { runtime, takeEvent } = yield* openRuntime(
1514 fake,
1515 "default",
1516 THREAD_ID,
1517 SESSION_ID,
1518 undefined,
1519 { offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid) },
1520 );
1521 const providerThread = yield* runtime.ensureThread({
1522 threadId: THREAD_ID,
1523 modelSelection: modelSelection("default"),
1524 runtimePolicy,
1525 });
1526 yield* fake.emit({ type: "agent_start" });
1527 yield* Queue.take(offers);
1528 const requests: Array<
1529 Extract<ProviderAdapter.ProviderAdapterV2Event, { type: "runtime_request.updated" }>
1530 > = [];
1531 fake.deferNextModelSelection();
1532 const starting = yield* startTurn(
1533 runtime,
1534 providerThread,
1535 "default",
1536 [],
1537 "Continue the review",
1538 modelSelection("xai/grok-4.6"),
1539 ).pipe(Effect.forkScoped);
1540 const modelRequest = yield* fake.takeRequest("set_model");
1541 yield* fake.emit({
1542 type: "extension_ui_request",
1543 id: "model-selection-dialog",
1544 method: "confirm",
1545 title: "Use this model?",
1546 });
1547 yield* fake.emit({ type: "agent_settled" });
1548 yield* takeEvent((event) => {
1549 if (event.type === "runtime_request.updated") requests.push(event);
1550 return (
1551 event.type === "provider_session.updated" && event.providerSession.status === "ready"
1552 );
1553 });
1554 const dialog = requests[0]?.runtimeRequest;
1555 assert.isDefined(dialog, "Pi buffered the dialog needed to finish model selection");
1556 assert.equal(requests[0]?.threadId, THREAD_ID);
1557 assert.isNull(dialog!.providerTurnId);
1558 yield* runtime.respondToRuntimeRequest({ requestId: dialog!.id, decision: "accept" });
1559 const response = yield* fake.takeRequest("extension_ui_response");
1560 assert.equal(response["id"], "model-selection-dialog");
1561 assert.isTrue(response["confirmed"]);
1562 yield* fake.emit({
1563 type: "response",
1564 id: modelRequest["id"],
1565 command: "set_model",
1566 success: true,
1567 data: { provider: "xai", id: "grok-4.6" },
1568 });
1569 yield* Fiber.join(starting);
1570 const prompt = yield* fake.takeRequest("prompt");
1571 assert.equal(prompt["message"], "Continue the review");
1572 assert.equal(prompt["streamingBehavior"], "steer");
1573 const resolved = yield* takeEvent(
1574 (event) =>
1575 event.type === "runtime_request.updated" && event.runtimeRequest.id === dialog!.id,
1576 );
1577 assert.isTrue(
1578 resolved.type === "runtime_request.updated" &&
1579 resolved.runtimeRequest.status === "resolved",
1580 );
1581 }).pipe(Effect.scoped, Effect.provide(layerTest)),
1582 );
1583
1584 it.effect("adopts a wake during same-file registration without a prompt", () =>
1585 Effect.gen(function* () {
1586 const fake = yield* makeFakePi;
1587 const offers =
1588 yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
1589 const { runtime, takeEvent } = yield* openRuntime(
1590 fake,
1591 "default",
1592 THREAD_ID,
1593 SESSION_ID,
1594 undefined,
1595 {
1596 offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
1597 },
1598 );
1599 const providerThread = yield* runtime.ensureThread({
1600 threadId: THREAD_ID,
1601 modelSelection: modelSelection("default"),
1602 runtimePolicy,
1603 });
1604 const reading = yield* Deferred.make<void>();
1605 fake.deferNextState(reading);
1606 const registering = yield* runtime.resumeThread({ providerThread }).pipe(Effect.forkChild);
1607 yield* Deferred.await(reading);
1608 yield* fake.emit({ type: "agent_start" });
1609 const offer = yield* Queue.take(offers).pipe(
1610 Effect.raceFirst(
1611 takeEvent(
1612 (event) =>
1613 event.type === "provider_session.updated" && event.providerSession.status === "error",
1614 ).pipe(
1615 Effect.andThen(Effect.sync(() => assert.fail("Pi killed a routable native wake"))),
1616 ),
1617 ),
1618 );
1619 assert.equal(offer.threadId, THREAD_ID);
1620 assert.equal(offer.providerThreadId, providerThread.id);
1621 assert.equal(offer.delivery, "adapter_buffered");
1622 assert.isTrue(yield* runtime.hasPendingBackgroundWork!);
1623 yield* fake.resolveDeferredState(recordedIdleState(FAKE_SESSION_FILE));
1624 yield* Fiber.join(registering);
1625 let dispatchCommitted = false;
1626 yield* offer.dispatchIfCurrent!(
1627 Effect.sync(() => {
1628 dispatchCommitted = true;
1629 }),
1630 );
1631 assert.isTrue(dispatchCommitted);
1632 assert.isTrue(yield* runtime.hasPendingBackgroundWork!);
1633 yield* fake.emit({ type: "message_start", message: { role: "assistant" } });
1634 yield* fake.emit({
1635 type: "message_update",
1636 assistantMessageEvent: {
1637 type: "text_delta",
1638 contentIndex: 0,
1639 delta: "Background review finished",
1640 },
1641 });
1642 yield* fake.emit({ type: "message_end", message: { role: "assistant" } });
1643 yield* fake.emit({ type: "agent_settled" });
1644 yield* takeEvent(
1645 (event) =>
1646 event.type === "provider_session.updated" && event.providerSession.status === "ready",
1647 );
1648 assert.isTrue(yield* runtime.hasPendingBackgroundWork!);
1649 yield* startTurn(
1650 runtime,
1651 providerThread,
1652 "default",
1653 [],
1654 "Synthetic wake",
1655 undefined,
1656 1,
1657 THREAD_ID,
1658 true,
1659 );
1660 const message = yield* takeEvent((event) => event.type === "message.updated");
1661 assert.equal(
1662 message.type === "message.updated" && message.message.text,
1663 "Background review finished",
1664 );
1665 yield* takeEvent((event) => event.type === "turn.terminal");
1666 assert.equal(fake.allRequests().filter((request) => request["type"] === "prompt").length, 0);
1667 assert.isFalse(yield* runtime.hasPendingBackgroundWork!);
1668 let dispatched = false;
1669 yield* offer.dispatchIfCurrent!(
1670 Effect.sync(() => {
1671 dispatched = true;
1672 }),
1673 );
1674 assert.isFalse(dispatched);
1675 }).pipe(Effect.scoped, Effect.provide(layerTest)),
1676 );
1677
1678 it.effect.each([false, true])(
1679 "a user prompt takes the wake without premature settlement, native wake settled=%s",
1680 (settled) =>
1681 Effect.gen(function* () {
1682 const fake = yield* makeFakePi;
1683 const offers =
1684 yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
1685 const { runtime, takeEvent } = yield* openRuntime(
1686 fake,
1687 "default",
1688 THREAD_ID,
1689 SESSION_ID,
1690 undefined,
1691 {
1692 offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
1693 },
1694 );
1695 const providerThread = yield* runtime.ensureThread({
1696 threadId: THREAD_ID,
1697 modelSelection: modelSelection("default"),
1698 runtimePolicy,
1699 });
1700 yield* fake.emit({ type: "agent_start" });
1701 const offer = yield* Queue.take(offers);
1702 if (settled) {
1703 yield* fake.emit({ type: "agent_settled" });
1704 yield* takeEvent(
1705 (event) =>
1706 event.type === "provider_session.updated" && event.providerSession.status === "ready",
1707 );
1708 }
1709 fake.deferNextLifecycle("prompt");
1710 yield* startTurn(runtime, providerThread);
1711 const prompt = yield* fake.takeRequest("prompt");
1712 assert.equal(prompt["message"], "Hello pi");
1713 assert.equal(prompt["streamingBehavior"], "steer");
1714 yield* fake.emit({ type: "response", command: "prompt", success: true });
1715 yield* fake.emit({ type: "agent_start" });
1716 yield* fake.emit({
1717 type: "extension_ui_request",
1718 id: "owned-dialog",
1719 method: "confirm",
1720 title: "Continue?",
1721 });
1722 const dialog = yield* takeEvent((event) => event.type === "runtime_request.updated");
1723 assert.isTrue(dialog.type === "runtime_request.updated");
1724 if (dialog.type !== "runtime_request.updated") return;
1725 assert.isNotNull(dialog.runtimeRequest.providerTurnId);
1726 yield* offer.clearIfCurrent!();
1727 yield* runtime.respondToRuntimeRequest({
1728 requestId: dialog.runtimeRequest.id,
1729 decision: "accept",
1730 });
1731 const response = yield* fake.takeRequest("extension_ui_response");
1732 assert.isTrue(response["confirmed"]);
1733 yield* fake.emit({ type: "message_start", message: { role: "assistant" } });
1734 yield* fake.emit({
1735 type: "message_update",
1736 assistantMessageEvent: {
1737 type: "text_end",
1738 contentIndex: 0,
1739 content: "User prompt completed",
1740 },
1741 });
1742 yield* fake.emit({ type: "agent_settled" });
1743 const message = yield* takeEvent(
1744 (event) =>
1745 event.type === "message.updated" && event.message.text === "User prompt completed",
1746 );
1747 assert.isTrue(message.type === "message.updated" && message.message.runId !== null);
1748 yield* takeEvent((event) => event.type === "turn.terminal");
1749 let dispatched = false;
1750 yield* offer.dispatchIfCurrent!(
1751 Effect.sync(() => {
1752 dispatched = true;
1753 }),
1754 );
1755 assert.isFalse(dispatched);
1756 }).pipe(Effect.scoped, Effect.provide(layerTest)),
1757 );
1758
1759 it.effect.each([false, true])(
1760 "defers a wake's late settlement until the joined user prompt is acknowledged, aborted=%s",
1761 (aborted) =>
1762 Effect.gen(function* () {
1763 const fake = yield* makeFakePi;
1764 const offers =
1765 yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
1766 const { runtime, takeEvent } = yield* openRuntime(
1767 fake,
1768 "default",
1769 THREAD_ID,
1770 SESSION_ID,
1771 undefined,
1772 {
1773 offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
1774 },
1775 );
1776 const providerThread = yield* runtime.ensureThread({
1777 threadId: THREAD_ID,
1778 modelSelection: modelSelection("default"),
1779 runtimePolicy,
1780 });
1781 yield* fake.emit({ type: "agent_start" });
1782 yield* Queue.take(offers);
1783 fake.deferNextLifecycle("prompt");
1784 yield* startTurn(runtime, providerThread);
1785 yield* fake.takeRequest("prompt");
1786 yield* fake.emit({ type: "agent_settled", aborted });
1787 yield* fake.emit({
1788 type: "extension_ui_request",
1789 method: "notify",
1790 message: "Ordering barrier",
1791 });
1792 yield* takeEvent(
1793 (event) => event.type === "turn_item.updated" && event.turnItem.type === "system_notice",
1794 );
1795 assert.equal(runtime.providerSession.status, "running");
1796 fake.queueState({ isStreaming: true });
1797 yield* fake.emit({ type: "response", command: "prompt", success: true });
1798 yield* fake.takeRequest("get_state");
1799 yield* fake.emit({ type: "agent_start" });
1800 yield* fake.emit({ type: "agent_settled" });
1801 const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
1802 assert.isTrue(terminal.type === "turn.terminal" && terminal.status === "completed");
1803 }).pipe(Effect.scoped, Effect.provide(layerTest)),
1804 );
1805
1806 it.effect.each([
1807 { aborted: false, resumes: false, expected: "completed" },
1808 { aborted: true, resumes: false, expected: "interrupted" },
1809 { aborted: true, resumes: true, expected: "completed" },
1810 ])(
1811 "settles a completed wake, aborted=$aborted, resumes=$resumes",
1812 ({ aborted, resumes, expected }) =>
1813 Effect.gen(function* () {
1814 const fake = yield* makeFakePi;
1815 const offers =
1816 yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
1817 const { runtime, takeEvent } = yield* openRuntime(
1818 fake,
1819 "default",
1820 THREAD_ID,
1821 SESSION_ID,
1822 undefined,
1823 {
1824 offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
1825 },
1826 );
1827 const providerThread = yield* runtime.ensureThread({
1828 threadId: THREAD_ID,
1829 modelSelection: modelSelection("default"),
1830 runtimePolicy,
1831 });
1832 yield* fake.emit({ type: "agent_start" });
1833 yield* Queue.take(offers);
1834 yield* fake.emit({ type: "agent_settled", aborted });
1835 yield* takeEvent(
1836 (event) =>
1837 event.type === "provider_session.updated" && event.providerSession.status === "ready",
1838 );
1839 fake.deferNextLifecycle("prompt");
1840 yield* startTurn(runtime, providerThread, "default", [], "/hello");
1841 yield* fake.takeRequest("prompt");
1842 if (resumes) yield* fake.emit({ type: "agent_start" });
1843 yield* fake.emit({ type: "response", command: "prompt", success: true });
1844 if (resumes) yield* fake.emit({ type: "agent_settled", aborted: false });
1845 const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
1846 assert.isTrue(terminal.type === "turn.terminal" && terminal.status === expected);
1847 yield* startTurn(
1848 runtime,
1849 providerThread,
1850 "default",
1851 [],
1852 "Stale continuation",
1853 undefined,
1854 2,
1855 THREAD_ID,
1856 true,
1857 );
1858 yield* takeEvent((event) => event.type === "turn.terminal");
1859 assert.equal(
1860 fake.allRequests().filter((request) => request["type"] === "prompt").length,
1861 1,
1862 );
1863 }).pipe(Effect.scoped, Effect.provide(layerTest)),
1864 );
1865
1866 it.effect("keeps a pending wake on its thread and lets Stop retire its process", () =>
1867 Effect.gen(function* () {
1868 const fake = yield* makeFakePi;
1869 const offers =
1870 yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
1871 const { runtime, takeEvent } = yield* openRuntime(
1872 fake,
1873 "default",
1874 THREAD_ID,
1875 SESSION_ID,
1876 undefined,
1877 {
1878 offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
1879 },
1880 );
1881 const providerThread = yield* runtime.ensureThread({
1882 threadId: THREAD_ID,
1883 modelSelection: modelSelection("default"),
1884 runtimePolicy,
1885 });
1886 const otherThread = {
1887 ...providerThread,
1888 appThreadId: ThreadId.make("other-thread"),
1889 id: ProviderThreadId.make("other-provider-thread"),
1890 };
1891 const reading = yield* Deferred.make<void>();
1892 fake.deferNextState(reading);
1893 const registering = yield* runtime
1894 .resumeThread({ providerThread: otherThread })
1895 .pipe(Effect.result, Effect.forkChild);
1896 yield* Deferred.await(reading);
1897 yield* fake.emit({ type: "agent_start" });
1898 const offer = yield* Queue.take(offers);
1899 yield* fake.resolveDeferredState(recordedIdleState("/fake/other-session.jsonl"));
1900 assert.equal((yield* Fiber.join(registering))._tag, "Failure");
1901 assert.isFalse(fake.allRequests().some((request) => request.type === "switch_session"));
1902 assert.isTrue(yield* runtime.hasPendingBackgroundWorkForThread!(providerThread));
1903 assert.isFalse(yield* runtime.hasPendingBackgroundWorkForThread!(otherThread));
1904 const failure = yield* runtime
1905 .resumeThread({ providerThread: otherThread })
1906 .pipe(Effect.flip);
1907 assert.equal(failure._tag, "ProviderAdapterResumeThreadError");
1908 yield* runtime.interruptTurn({
1909 providerThread,
1910 providerTurnId: ProviderTurnId.make("settled-turn"),
1911 requestRuntimeRestart: true,
1912 });
1913 yield* takeEvent(
1914 (event) =>
1915 event.type === "provider_session.updated" && event.providerSession.status === "stopped",
1916 );
1917 assert.isFalse(yield* runtime.hasPendingBackgroundWork!);
1918 let dispatched = false;
1919 yield* offer.dispatchIfCurrent!(
1920 Effect.sync(() => {
1921 dispatched = true;
1922 }),
1923 );
1924 assert.isFalse(dispatched);
1925 }).pipe(Effect.scoped, Effect.provide(layerTest)),
1926 );
1927
1928 it.effect.each(["archive", "stop", "transport death"] as const)(
1929 "retiring a wake by %s cancels visible dialogs and invalidates its offer",
1930 (retirement) =>
1931 Effect.gen(function* () {
1932 const fake = yield* makeFakePi;
1933 const offers =
1934 yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
1935 const { runtime, takeEvent } = yield* openRuntime(
1936 fake,
1937 "default",
1938 THREAD_ID,
1939 SESSION_ID,
1940 undefined,
1941 {
1942 offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
1943 },
1944 );
1945 const providerThread = yield* runtime.ensureThread({
1946 threadId: THREAD_ID,
1947 modelSelection: modelSelection("default"),
1948 runtimePolicy,
1949 });
1950 yield* fake.emit({ type: "agent_start" });
1951 const offer = yield* Queue.take(offers);
1952 yield* fake.emit({
1953 type: "extension_ui_request",
1954 id: "wake-dialog",
1955 method: "confirm",
1956 title: "Continue background work?",
1957 });
1958 const dialog = yield* takeEvent((event) => event.type === "runtime_request.updated");
1959 assert.isTrue(dialog.type === "runtime_request.updated");
1960 if (dialog.type !== "runtime_request.updated") return;
1961 assert.isNull(dialog.runtimeRequest.providerTurnId);
1962 if (retirement === "archive") yield* offer.clearIfCurrent!();
1963 else if (retirement === "stop") {
1964 yield* runtime.interruptTurn({
1965 providerThread,
1966 providerTurnId: ProviderTurnId.make("settled-turn"),
1967 requestRuntimeRestart: true,
1968 });
1969 } else yield* fake.closeStdout;
1970 let requestCancelled = false;
1971 let nodeCancelled = false;
1972 let itemCancelled = false;
1973 yield* takeEvent((event) => {
1974 if (
1975 event.type === "runtime_request.updated" &&
1976 event.runtimeRequest.id === dialog.runtimeRequest.id
1977 )
1978 requestCancelled = event.runtimeRequest.status === "cancelled";
1979 if (event.type === "node.updated" && event.node.id === dialog.runtimeRequest.nodeId)
1980 nodeCancelled = event.node.status === "cancelled";
1981 if (
1982 event.type === "turn_item.updated" &&
1983 event.turnItem.nodeId === dialog.runtimeRequest.nodeId
1984 )
1985 itemCancelled = event.turnItem.status === "cancelled";
1986 return (
1987 event.type === "provider_session.updated" &&
1988 event.providerSession.status ===
1989 (retirement === "transport death" ? "error" : "stopped")
1990 );
1991 });
1992 assert.isTrue(requestCancelled, "Retired wake left a pending runtime request");
1993 assert.isTrue(nodeCancelled);
1994 assert.isTrue(itemCancelled);
1995 assert.isFalse(yield* runtime.hasPendingBackgroundWork!);
1996 let dispatched = false;
1997 yield* offer.dispatchIfCurrent!(
1998 Effect.sync(() => {
1999 dispatched = true;
2000 }),
2001 );
2002 assert.isFalse(dispatched);
2003 }).pipe(Effect.scoped, Effect.provide(layerTest)),
2004 );
2005
2006 it.effect("stops provider-initiated work that has no T3 turn owner", () =>
2007 Effect.gen(function* () {
2008 const fake = yield* makeFakePi;
2009 const { runtime, takeEvent } = yield* openRuntime(fake);
2010 yield* runtime.ensureThread({
2011 threadId: THREAD_ID,
2012 modelSelection: modelSelection("default"),
2013 runtimePolicy,
2014 });
2015
2016 yield* fake.emit({ type: "agent_start" });
2017
2018 const sessionError = yield* takeEvent(
2019 (event) =>
2020 event.type === "provider_session.updated" && event.providerSession.status === "error",
2021 );
2022 assert.isTrue(
2023 sessionError.type === "provider_session.updated" &&
2024 sessionError.providerSession.lastError?.includes("invisible tool execution") === true,
2025 );
2026 }).pipe(Effect.scoped, Effect.provide(layerTest)),
2027 );
2028
2029 it.effect.each(["session", "process"] as const)("cleans up detached work on Pi %s exit", (exit) =>
2030 Effect.gen(function* () {
2031 const fake = yield* makeFakePi;
2032 const exited = yield* Deferred.make<ChildProcessSpawner.ExitCode>();
2033 const scopeStopped = yield* Deferred.make<void>();
2034 let processReleased = false;
2035 const stopped: Array<{ unit: string; processReleased: boolean }> = [];
2036 yield* Effect.gen(function* () {
2037 yield* openRuntime({
2038 ...fake,
2039 spawner: ChildProcessSpawner.make((command) =>
2040 Effect.acquireRelease(
2041 fake.spawner
2042 .spawn(command)
2043 .pipe(
2044 Effect.map((child) =>
2045 ChildProcessSpawner.makeHandle({ ...child, exitCode: Deferred.await(exited) }),
2046 ),
2047 ),
2048 () =>
2049 Effect.sync(() => {
2050 processReleased = true;
2051 }),
2052 ),
2053 ),
2054 });
2055 assert.deepStrictEqual(stopped, []);
2056 if (exit === "process") {
2057 // Stdout stays open as it would for a child holding the inherited pipe.
2058 yield* Deferred.succeed(exited, ChildProcessSpawner.ExitCode(19));
2059 yield* Deferred.await(scopeStopped);
2060 assert.isFalse(processReleased);
2061 }
2062 }).pipe(
2063 Effect.scoped,
2064 Effect.provideService(AgentScope, {
2065 ...AgentScope.defaultValue(),
2066 wrap: ({ command, args }) =>
2067 Effect.succeed({ command, args, unit: "t3code-pi-test.scope" }),
2068 stop: (unit) =>
2069 Effect.sync(() => void stopped.push({ unit, processReleased })).pipe(
2070 Effect.andThen(Deferred.succeed(scopeStopped, undefined)),
2071 Effect.asVoid,
2072 ),
2073 }),
2074 );
2075 assert.deepStrictEqual(stopped, [
2076 { unit: "t3code-pi-test.scope", processReleased: exit === "session" },
2077 ]);
2078 }).pipe(Effect.provide(layerTest)),
2079 );
2080
2081 it.effect("counts a running Pi for port discovery until its session closes", () =>
2082 Effect.gen(function* () {
2083 const host = yield* ProviderHost.ProviderHost;
2084 let running = 0;
2085 yield* Effect.gen(function* () {
2086 const fake = yield* makeFakePi;
2087 yield* openRuntime(fake);
2088 assert.equal(running, 1);
2089 }).pipe(
2090 Effect.scoped,
2091 Effect.provideService(ProviderHost.ProviderHost, {
2092 ...host,
2093 trackAgent: () => {
2094 running += 1;
2095 return () => {
2096 running -= 1;
2097 };
2098 },
2099 }),
2100 );
2101 assert.equal(running, 0);
2102 }).pipe(Effect.provide(layerTest)),
2103 );
2104
2105 it.effect("gives notify and extension-error items distinct ids in each thread", () =>
2106 Effect.gen(function* () {
2107 const itemIds = new Set<string>();
2108 for (const [threadId, extensionPath] of [
2109 [THREAD_ID, "/ext/a.ts"],
2110 [ThreadId.make("thread-pi-test-2"), "/ext/a/index.ts"],
2111 ] as const) {
2112 const fake = yield* makeFakePi;
2113 const { runtime, takeEvent } = yield* openRuntime(fake, "default", threadId);
2114 const providerThread = yield* runtime.ensureThread({
2115 threadId,
2116 modelSelection: modelSelection("default"),
2117 runtimePolicy,
2118 });
2119 yield* startTurn(
2120 runtime,
2121 providerThread,
2122 "default",
2123 [],
2124 "Hello pi",
2125 undefined,
2126 1,
2127 threadId,
2128 );
2129 yield* fake.takeRequest("prompt");
2130 yield* fake.emit({
2131 type: "extension_ui_request",
2132 id: "ui-notify",
2133 method: "notify",
2134 message: "note",
2135 });
2136 yield* fake.emit({ type: "extension_error", extensionPath, error: "boom" });
2137 for (const prefix of ["notify:", "extension-error:"]) {
2138 const item = yield* takeEvent(
2139 (event) =>
2140 event.type === "turn_item.updated" &&
2141 event.turnItem.nativeItemRef?.nativeId?.startsWith(prefix) === true,
2142 );
2143 if (item.type === "turn_item.updated") itemIds.add(item.turnItem.id);
2144 if (item.type === "turn_item.updated" && prefix === "extension-error:") {
2145 assert.equal(item.turnItem.title, "a");
2146 }
2147 }
2148 }
2149 assert.equal(itemIds.size, 4);
2150 }).pipe(Effect.scoped, Effect.provide(layerTest)),
2151 );
2152
2153 it.effect("injects the T3 MCP extension and bearer when a session exists", () =>
2154 Effect.gen(function* () {
2155 yield* (yield* McpProviderSessions.McpProviderSessions).set({
2156 environmentId: EnvironmentId.make("environment-pi-mcp"),
2157 threadId: THREAD_ID,
2158 providerSessionId: "mcp-session-pi",
2159 providerInstanceId: PI_INSTANCE_ID,
2160 endpoint: "http://127.0.0.1:43123/mcp",
2161 authorizationHeader: "Bearer secret-pi-token",
2162 browserToolsAvailable: true,
2163 });
2164 const fake = yield* makeFakePi;
2165 yield* openRuntime(fake);
2166 const spawn = fake.lastSpawn();
2167 assert.isTrue(spawn.args.includes("--extension"));
2168 const extensions = spawn.args.flatMap((arg, index) =>
2169 arg === "--extension" ? [spawn.args[index + 1]] : [],
2170 );
2171 assert.isFalse(spawn.args.includes("--no-extensions"));
2172 // A thread's long-lived process keeps Pi's startup model refresh unless the user opts out.
2173 assert.notInclude(spawn.args, "--offline");
2174 assert.isUndefined(spawn.env.PI_OFFLINE);
2175 assert.isTrue(extensions.some((path) => path?.endsWith("pi-t3-mcp-extension.ts")));
2176 assert.equal(spawn.env.T3_MCP_URL, "http://127.0.0.1:43123/mcp");
2177 assert.equal(spawn.env.T3_MCP_BEARER_TOKEN, "secret-pi-token");
2178 assert.equal(spawn.env.T3_PI_RUNTIME_MODE, "full-access");
2179 assert.equal(spawn.env.T3CODE_THREAD_ID, THREAD_ID);
2180 }).pipe(Effect.scoped, Effect.provide(layerTest)),
2181 );
2182
2183 it.effect(
2184 "resumes a persisted session at spawn without replacing it or clearing model selection",
2185 () =>
2186 Effect.gen(function* () {
2187 const original = yield* openRuntime(yield* makeFakePi);
2188 const persisted = yield* original.runtime.ensureThread({
2189 threadId: THREAD_ID,
2190 modelSelection: modelSelection("default"),
2191 runtimePolicy,
2192 });
2193 const fake = yield* makeFakePi;
2194 const { runtime, takeEvent } = yield* openRuntime(
2195 fake,
2196 "default",
2197 THREAD_ID,
2198 SESSION_ID,
2199 undefined,
2200 undefined,
2201 FAKE_SESSION_FILE,
2202 );
2203 const args = fake.lastSpawn().args;
2204 assert.include(args, "--session");
2205 assert.equal(args[args.indexOf("--session") + 1], FAKE_SESSION_FILE);
2206 assert.notInclude(args, "--no-session");
2207 assert.notInclude(args, "--no-extensions");
2208 assert.include(args, "--extension");
2209
2210 // Startup extensions can hold Pi's first reply past the ordinary request deadline.
2211 const reading = yield* Deferred.make<void>();
2212 fake.deferNextState(reading);
2213 const registering = yield* runtime
2214 .ensureThread({
2215 threadId: THREAD_ID,
2216 modelSelection: modelSelection("default"),
2217 runtimePolicy,
2218 existingProviderThread: persisted,
2219 })
2220 .pipe(Effect.forkChild);
2221 yield* Deferred.await(reading);
2222 yield* TestClock.adjust(Duration.millis(16_820));
2223 yield* fake.resolveDeferredState({
2224 ...recordedIdleState(FAKE_SESSION_FILE.replace("/--workspace--/", "/--workspace--/./")),
2225 });
2226 const providerThread = yield* Fiber.join(registering);
2227 assert.equal(providerThread.id, persisted.id);
2228 assert.isFalse(fake.allRequests().some((request) => request.type === "switch_session"));
2229 yield* startTurn(runtime, providerThread, "anthropic/claude-sonnet");
2230 assert.equal((yield* fake.takeRequest("prompt"))["message"], "Hello pi");
2231 yield* fake.emit({ type: "agent_start" });
2232 yield* fake.emit({ type: "agent_settled" });
2233 yield* takeEvent((event) => event.type === "turn.terminal");
2234
2235 const resumed = yield* runtime.resumeThread({ providerThread });
2236 yield* startTurn(runtime, resumed, "anthropic/claude-sonnet", [], "Continue", undefined, 2);
2237 assert.equal((yield* fake.takeRequest("prompt"))["message"], "Continue");
2238 assert.isFalse(fake.allRequests().some((request) => request.type === "switch_session"));
2239 assert.equal(
2240 fake.allRequests().filter((request) => request.type === "set_model").length,
2241 1,
2242 );
2243 }).pipe(Effect.scoped, Effect.provide(layerTest)),
2244 );
2245
2246 it.effect("creates a fresh session when cold resume is bypassed before registration", () =>
2247 Effect.gen(function* () {
2248 const original = yield* openRuntime(yield* makeFakePi);
2249 const persisted = yield* original.runtime.ensureThread({
2250 threadId: THREAD_ID,
2251 modelSelection: modelSelection("default"),
2252 runtimePolicy,
2253 });
2254 const fake = yield* makeFakePi;
2255 const { runtime } = yield* openRuntime(
2256 fake,
2257 "default",
2258 THREAD_ID,
2259 SESSION_ID,
2260 undefined,
2261 undefined,
2262 FAKE_SESSION_FILE,
2263 );
2264 const fresh = yield* runtime.ensureThread({
2265 threadId: THREAD_ID,
2266 modelSelection: modelSelection("default"),
2267 runtimePolicy,
2268 existingProviderThread: { ...persisted, nativeThreadRef: null },
2269 });
2270 assert.equal(fresh.id, persisted.id);
2271 assert.notEqual(fresh.nativeThreadRef?.nativeId, persisted.nativeThreadRef?.nativeId);
2272 assert.equal(
2273 fake.allRequests().filter((request) => request.type === "new_session").length,
2274 1,
2275 );
2276 assert.isFalse(fake.allRequests().some((request) => request.type === "switch_session"));
2277 }).pipe(Effect.scoped, Effect.provide(layerTest)),
2278 );
2279
2280 it.effect("reserves registration during its state read and releases it on interruption", () =>
2281 Effect.gen(function* () {
2282 const fake = yield* makeFakePi;
2283 const { runtime, takeEvent } = yield* openRuntime(fake);
2284 const providerThread = yield* runtime.ensureThread({
2285 threadId: THREAD_ID,
2286 modelSelection: modelSelection("default"),
2287 runtimePolicy,
2288 });
2289 yield* startTurn(runtime, providerThread, "anthropic/claude-sonnet");
2290 yield* fake.takeRequest("prompt");
2291 yield* fake.emit({ type: "agent_start" });
2292 yield* fake.emit({ type: "agent_settled" });
2293 yield* takeEvent((event) => event.type === "turn.terminal");
2294
2295 const reading = yield* Deferred.make<void>();
2296 fake.deferNextState(reading);
2297 const registering = yield* runtime.resumeThread({ providerThread }).pipe(Effect.forkChild);
2298 yield* Deferred.await(reading);
2299 const overlappingTurn = yield* startTurn(runtime, providerThread).pipe(Effect.result);
2300 assert.equal(overlappingTurn._tag, "Failure", "A turn was accepted during registration");
2301 const overlappingResume = yield* runtime.resumeThread({ providerThread }).pipe(Effect.result);
2302 assert.equal(overlappingResume._tag, "Failure");
2303 yield* fake.resolveDeferredState(recordedIdleState(FAKE_SESSION_FILE));
2304 const resumed = yield* Fiber.join(registering);
2305
2306 const interruptedRead = yield* Deferred.make<void>();
2307 fake.deferNextState(interruptedRead);
2308 const interrupted = yield* runtime
2309 .resumeThread({ providerThread: resumed })
2310 .pipe(Effect.forkChild);
2311 yield* Deferred.await(interruptedRead);
2312 yield* Fiber.interrupt(interrupted);
2313 yield* fake.resolveDeferredState(recordedIdleState(FAKE_SESSION_FILE));
2314 fake.failNextState();
2315 const failedRead = yield* runtime
2316 .resumeThread({ providerThread: resumed })
2317 .pipe(Effect.result);
2318 assert.equal(failedRead._tag, "Failure");
2319
2320 yield* startTurn(runtime, resumed, "anthropic/claude-sonnet", [], "Continue", undefined, 2);
2321 assert.equal((yield* fake.takeRequest("prompt"))["message"], "Continue");
2322 yield* fake.emit({ type: "agent_start" });
2323 yield* fake.emit({ type: "agent_settled" });
2324 const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
2325 assert.isTrue(terminal.type === "turn.terminal" && terminal.status === "completed");
2326 assert.isFalse(fake.allRequests().some((request) => request.type === "switch_session"));
2327 assert.equal(fake.allRequests().filter((request) => request.type === "set_model").length, 1);
2328 }).pipe(Effect.scoped, Effect.provide(layerTest)),
2329 );
2330
2331 it.effect("respawns without the session when Pi exits on an unusable spawn session", () =>
2332 Effect.gen(function* () {
2333 const original = yield* openRuntime(yield* makeFakePi);
2334 const persisted = yield* original.runtime.ensureThread({
2335 threadId: THREAD_ID,
2336 modelSelection: modelSelection("default"),
2337 runtimePolicy,
2338 });
2339 // A cleared ref takes the new_session path, which must also run the recovery.
2340 for (const providerThread of [persisted, { ...persisted, nativeThreadRef: null }]) {
2341 const failed = yield* makeFakePi;
2342 const replacement = yield* makeFakePi;
2343 // The transport fails stdin and events together; awaiting this orders registration after both.
2344 const transportDown = yield* Deferred.make<void>();
2345 let spawnCount = 0;
2346 const fake = {
2347 ...replacement,
2348 spawner: ChildProcessSpawner.make((command) => {
2349 spawnCount++;
2350 if (spawnCount > 1) return replacement.spawner.spawn(command);
2351 // Exits at once so the transport is already down before registration runs.
2352 return failed.spawner.spawn(command).pipe(
2353 Effect.map((child) =>
2354 ChildProcessSpawner.makeHandle({
2355 ...child,
2356 exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(1)),
2357 stdin: child.stdin.pipe(
2358 Sink.ensuring(Deferred.succeed(transportDown, undefined)),
2359 ),
2360 }),
2361 ),
2362 );
2363 }),
2364 };
2365 yield* failed.closeStdout;
2366 const { runtime, takeEvent } = yield* openRuntime(
2367 fake,
2368 "default",
2369 THREAD_ID,
2370 SESSION_ID,
2371 undefined,
2372 undefined,
2373 FAKE_SESSION_FILE,
2374 );
2375 assert.include(failed.lastSpawn().args, "--session");
2376 yield* Deferred.await(transportDown);
2377 replacement.queueState({ sessionFile: "/fake/default-session.jsonl" });
2378 const resumed = yield* runtime.resumeThread({ providerThread });
2379 assert.equal(spawnCount, 2);
2380 assert.notInclude(replacement.lastSpawn().args, "--session");
2381 assert.include(replacement.lastSpawn().args, "--extension");
2382 const switched = replacement.allRequests().find((r) => r.type === "switch_session");
2383 if (providerThread.nativeThreadRef === null) {
2384 assert.isUndefined(switched);
2385 assert.notEqual(resumed.nativeThreadRef?.nativeId, FAKE_SESSION_FILE);
2386 } else {
2387 assert.equal(switched?.sessionPath, FAKE_SESSION_FILE);
2388 assert.equal(resumed.nativeThreadRef?.nativeId, FAKE_SESSION_FILE);
2389 }
2390 yield* startTurn(runtime, resumed);
2391 yield* replacement.takeRequest("prompt");
2392 yield* replacement.emit({ type: "agent_start" });
2393 yield* replacement.emit({ type: "agent_settled" });
2394 const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
2395 assert.isTrue(terminal.type === "turn.terminal" && terminal.status === "completed");
2396 }
2397 }).pipe(Effect.scoped, Effect.provide(layerTest)),
2398 );
2399
2400 it.effect("rejects a resume while a turn is active", () =>
2401 Effect.gen(function* () {
2402 const fake = yield* makeFakePi;
2403 const { runtime } = yield* openRuntime(fake);
2404 const providerThread = yield* runtime.ensureThread({
2405 threadId: THREAD_ID,
2406 modelSelection: modelSelection("default"),
2407 runtimePolicy,
2408 });
2409 yield* startTurn(runtime, providerThread);
2410 yield* fake.takeRequest("prompt");
2411 const error = yield* runtime.resumeThread({ providerThread }).pipe(Effect.flip);
2412 assert.equal(error._tag, "ProviderAdapterResumeThreadError");
2413 assert.match(String(error.cause), /while a turn is active/);
2414 }).pipe(Effect.scoped, Effect.provide(layerTest)),
2415 );
2416
2417 it.effect("forks a resumed session recorded in another cwd into the runtime cwd", () =>
2418 Effect.gen(function* () {
2419 const host = yield* ProviderHost.ProviderHost;
2420 const fileSystem = yield* FileSystem.FileSystem;
2421 const fake = yield* makeFakePi;
2422 const forkFake = yield* makeFakePi;
2423 const forkFile = "/fake/forked-into-worktree.jsonl";
2424 const { runtime } = yield* openRuntime(fake, "default", THREAD_ID, SESSION_ID, forkFake);
2425 const providerThread = yield* runtime.ensureThread({
2426 threadId: THREAD_ID,
2427 modelSelection: modelSelection("default"),
2428 runtimePolicy,
2429 });
2430 const dir = yield* fileSystem.makeTempDirectoryScoped();
2431 const sessionAt = (sessionCwd: string) =>
2432 Effect.gen(function* () {
2433 const file = `${dir}/${sessionCwd.length}.jsonl`;
2434 yield* fileSystem.writeFileString(
2435 file,
2436 `${JSON.stringify({ type: "session", version: 3, id: "s", cwd: sessionCwd })}\n{}\n`,
2437 );
2438 return {
2439 ...providerThread,
2440 nativeThreadRef: { driver: PI_PROVIDER, nativeId: file, strength: "strong" as const },
2441 };
2442 });
2443 const lastSwitch = () =>
2444 fake.allRequests().findLast((request) => request.type === "switch_session")?.sessionPath;
2445
2446 const sameCwd = yield* sessionAt(host.paths.cwd);
2447 yield* runtime.resumeThread({ providerThread: sameCwd });
2448 assert.equal(lastSwitch(), sameCwd.nativeThreadRef?.nativeId);
2449 assert.isFalse(forkFake.allRequests().some((request) => request.type === "get_state"));
2450
2451 const otherCwd = yield* sessionAt(`${host.paths.cwd}-original-checkout`);
2452 forkFake.queueState({ sessionFile: forkFile });
2453 fake.queueState({ sessionFile: FAKE_SESSION_FILE });
2454 fake.queueState({ sessionFile: forkFile });
2455 const resumed = yield* runtime.resumeThread({ providerThread: otherCwd });
2456 const args = forkFake.lastSpawn().args;
2457 assert.equal(args[args.indexOf("--fork") + 1], otherCwd.nativeThreadRef?.nativeId);
2458 assert.equal(lastSwitch(), forkFile);
2459 assert.equal(resumed.nativeThreadRef?.nativeId, forkFile);
2460
2461 // A cold start may attach only a session recorded in this cwd; others take the fork above.
2462 for (const thread of [sameCwd, otherCwd]) {
2463 const coldFake = yield* makeFakePi;
2464 yield* openRuntime(
2465 coldFake,
2466 "default",
2467 THREAD_ID,
2468 SESSION_ID,
2469 undefined,
2470 undefined,
2471 thread.nativeThreadRef?.nativeId,
2472 );
2473 const coldArgs = coldFake.lastSpawn().args;
2474 assert.equal(
2475 coldArgs.includes("--session") ? coldArgs[coldArgs.indexOf("--session") + 1] : undefined,
2476 thread === sameCwd ? sameCwd.nativeThreadRef?.nativeId : undefined,
2477 );
2478 }
2479 }).pipe(Effect.scoped, Effect.provide(layerTest)),
2480 );
2481
2482 it.effect("creates a distinct native session after a failed resume", () =>
2483 Effect.gen(function* () {
2484 const fake = yield* makeFakePi;
2485 const { runtime } = yield* openRuntime(fake);
2486 const providerThread = yield* runtime.ensureThread({
2487 threadId: THREAD_ID,
2488 modelSelection: modelSelection("default"),
2489 runtimePolicy,
2490 });
2491 fake.queueState({ sessionFile: "/fake/other-session.jsonl" });
2492 fake.vetoNextSwitch();
2493 const error = yield* runtime.resumeThread({ providerThread }).pipe(Effect.flip);
2494 assert.match(String(error.cause), /cancelled the session switch/);
2495 const replacement = yield* runtime.ensureThread({
2496 threadId: THREAD_ID,
2497 modelSelection: modelSelection("default"),
2498 runtimePolicy,
2499 existingProviderThread: { ...providerThread, nativeThreadRef: null },
2500 });
2501 assert.equal(replacement.id, providerThread.id);
2502 assert.notEqual(
2503 replacement.nativeThreadRef?.nativeId,
2504 providerThread.nativeThreadRef?.nativeId,
2505 );
2506 assert.equal(
2507 fake.allRequests().filter((request) => request.type === "new_session").length,
2508 1,
2509 );
2510 yield* startTurn(runtime, replacement, "default");
2511 yield* fake.takeRequest("prompt");
2512 }).pipe(Effect.scoped, Effect.provide(layerTest)),
2513 );
2514
2515 it.effect.each(["veto", "same identity"] as const)(
2516 "rejects a replacement with %s",
2517 (invalidReplacement) =>
2518 Effect.gen(function* () {
2519 const fake = yield* makeFakePi;
2520 const { runtime } = yield* openRuntime(fake);
2521 const providerThread = yield* runtime.ensureThread({
2522 threadId: THREAD_ID,
2523 modelSelection: modelSelection("default"),
2524 runtimePolicy,
2525 });
2526 if (invalidReplacement === "veto") fake.vetoNextNewSession();
2527 else fake.queueState({ sessionFile: FAKE_SESSION_FILE });
2528 const error = yield* runtime
2529 .ensureThread({
2530 threadId: THREAD_ID,
2531 modelSelection: modelSelection("default"),
2532 runtimePolicy,
2533 existingProviderThread: { ...providerThread, nativeThreadRef: null },
2534 })
2535 .pipe(Effect.flip);
2536 assert.equal(error._tag, "ProviderAdapterEnsureThreadError");
2537 assert.match(
2538 String(error.cause),
2539 invalidReplacement === "veto" ? /cancelled/ : /distinct session/,
2540 );
2541 yield* startTurn(runtime, providerThread, "default").pipe(Effect.flip);
2542 assert.isFalse(fake.allRequests().some((request) => request.type === "prompt"));
2543 }).pipe(Effect.scoped, Effect.provide(layerTest)),
2544 );
2545
2546 it.effect("retires an interrupted switch before accepting further requests", () =>
2547 Effect.gen(function* () {
2548 const fake = yield* makeFakePi;
2549 const { runtime, takeEvent } = yield* openRuntime(fake);
2550 const providerThread = yield* runtime.ensureThread({
2551 threadId: THREAD_ID,
2552 modelSelection: modelSelection("default"),
2553 runtimePolicy,
2554 });
2555 fake.queueState({ sessionFile: "/fake/other-session.jsonl" });
2556 fake.deferNextLifecycle("switch_session");
2557 const resumed = yield* runtime.resumeThread({ providerThread }).pipe(Effect.forkChild);
2558 yield* fake.takeRequest("switch_session");
2559 yield* Fiber.interrupt(resumed);
2560 yield* takeEvent(
2561 (event) =>
2562 event.type === "provider_session.updated" && event.providerSession.status === "error",
2563 );
2564 yield* runtime
2565 .ensureThread({
2566 threadId: THREAD_ID,
2567 modelSelection: modelSelection("default"),
2568 runtimePolicy,
2569 existingProviderThread: { ...providerThread, nativeThreadRef: null },
2570 })
2571 .pipe(Effect.flip);
2572 assert.isFalse(fake.allRequests().some((request) => request.type === "new_session"));
2573 }).pipe(Effect.scoped, Effect.provide(layerTest)),
2574 );
2575
2576 it.effect("budgets legacy native history with Pi's selected model capacity", () =>
2577 Effect.gen(function* () {
2578 const fake = yield* makeFakePi;
2579 fake.queueState({
2580 sessionFile: FAKE_SESSION_FILE,
2581 model: { provider: "anthropic", id: "large", contextWindow: 1_000_000 },
2582 });
2583 fake.queueModels([{ provider: "anthropic", id: "small", contextWindow: 32_000 }]);
2584 const { runtime } = yield* openRuntime(fake);
2585 const providerThread = yield* runtime.ensureThread({
2586 threadId: THREAD_ID,
2587 modelSelection: modelSelection("default"),
2588 runtimePolicy,
2589 });
2590 const budget = (model: string) =>
2591 handoffBudget({
2592 tokenCap: 16_000,
2593 userText: "$handoff",
2594 attachments: [],
2595 providerThread,
2596 nativeContextEstimate: 307_543,
2597 modelContextWindow: runtime.getModelContextWindow?.(modelSelection(model)),
2598 });
2599 assert.equal(budget("default"), 16_000);
2600 assert.equal(budget("anthropic/large"), 16_000);
2601 assert.equal(runtime.getModelContextWindow?.(modelSelection("anthropic/small")), 32_000);
2602 assert.equal(budget("anthropic/small"), 0);
2603 assert.isUndefined(runtime.getModelContextWindow?.(modelSelection("anthropic/unknown")));
2604 assert.isUndefined(
2605 runtime.getModelContextWindow?.({
2606 instanceId: ProviderInstanceId.make("other-pi"),
2607 model: "anthropic/large",
2608 }),
2609 );
2610 fake.queueState({
2611 sessionFile: "/fake/replacement.jsonl",
2612 model: { provider: "anthropic", id: "small", contextWindow: 32_000 },
2613 });
2614 yield* runtime.ensureThread({
2615 threadId: THREAD_ID,
2616 modelSelection: modelSelection("default"),
2617 runtimePolicy,
2618 existingProviderThread: { ...providerThread, nativeThreadRef: null },
2619 });
2620 assert.equal(runtime.getModelContextWindow?.(modelSelection("default")), 32_000);
2621 }).pipe(Effect.scoped, Effect.provide(layerTest)),
2622 );
2623
2624 it.effect("adopts the run's provider thread identity instead of minting a second row", () =>
2625 Effect.gen(function* () {
2626 const fake = yield* makeFakePi;
2627 const { runtime, takeEvent } = yield* openRuntime(fake);
2628 const now = yield* DateTime.now;
2629 const placeholder: OrchestrationV2ProviderThread = {
2630 id: ProviderThreadId.make("thread:provider:pi:native-thread:pending:run:thread-pi-test:1"),
2631 driver: PI_PROVIDER,
2632 providerInstanceId: PI_INSTANCE_ID,
2633 providerSessionId: SESSION_ID,
2634 appThreadId: THREAD_ID,
2635 ownerNodeId: null,
2636 nativeThreadRef: null,
2637 nativeConversationHeadRef: null,
2638 status: "not_loaded",
2639 firstRunOrdinal: 1,
2640 lastRunOrdinal: 1,
2641 handoffIds: [],
2642 forkedFrom: null,
2643 createdAt: now,
2644 updatedAt: now,
2645 };
2646 const providerThread = yield* runtime.ensureThread({
2647 threadId: THREAD_ID,
2648 modelSelection: modelSelection("default"),
2649 runtimePolicy,
2650 existingProviderThread: placeholder,
2651 });
2652 assert.equal(providerThread.id, placeholder.id);
2653 assert.equal(providerThread.nativeThreadRef?.nativeId, FAKE_SESSION_FILE);
2654 assert.isFalse(fake.allRequests().some((request) => request.type === "new_session"));
2655 const updated = yield* takeEvent((event) => event.type === "provider_thread.updated");
2656 assert.isTrue(
2657 updated.type === "provider_thread.updated" && updated.providerThread.id === placeholder.id,
2658 );
2659 }).pipe(Effect.scoped, Effect.provide(layerTest)),
2660 );
2661
2662 it.effect("selects the provider and id Pi reported when either contains a slash", () =>
2663 Effect.gen(function* () {
2664 const fake = yield* makeFakePi;
2665 const hub = "hub=https://hub.example:8318/v1";
2666 fake.queueModels([{ provider: "openrouter", id: "openrouter/auto" }]);
2667 const { runtime, takeEvent } = yield* openRuntime(fake);
2668 const providerThread = yield* runtime.ensureThread({
2669 threadId: THREAD_ID,
2670 modelSelection: modelSelection("default"),
2671 runtimePolicy,
2672 });
2673
2674 yield* startTurn(
2675 runtime,
2676 providerThread,
2677 "default",
2678 [],
2679 "First",
2680 modelSelection("openrouter/openrouter/auto"),
2681 );
2682 const openRouterRequest = yield* fake.takeRequest("set_model");
2683 assert.deepEqual(
2684 { provider: openRouterRequest["provider"], modelId: openRouterRequest["modelId"] },
2685 { provider: "openrouter", modelId: "openrouter/auto" },
2686 );
2687 yield* fake.takeRequest("prompt");
2688 yield* fake.emit({ type: "agent_start" });
2689 yield* fake.emit({ type: "agent_end", messages: [], willRetry: false });
2690 yield* fake.emit({ type: "agent_settled" });
2691 yield* takeEvent((event) => event.type === "turn.terminal");
2692
2693 // A provider registered after the session started, e.g. by an extension reload.
2694 fake.queueModels([
2695 { provider: "openrouter", id: "openrouter/auto" },
2696 { provider: hub, id: "claude-haiku-4-5" },
2697 ]);
2698 yield* startTurn(
2699 runtime,
2700 providerThread,
2701 "default",
2702 [],
2703 "Second",
2704 modelSelection(`${hub}/claude-haiku-4-5`),
2705 2,
2706 );
2707 const hubRequest = yield* fake.takeRequest("set_model");
2708 assert.deepEqual(
2709 { provider: hubRequest["provider"], modelId: hubRequest["modelId"] },
2710 { provider: hub, modelId: "claude-haiku-4-5" },
2711 );
2712 }).pipe(Effect.scoped, Effect.provide(layerTest)),
2713 );
2714
2715 it.effect.each(["anthropic/model-b", "default"])(
2716 "preserves explicit thinking when switching models to %s in the same runtime",
2717 (targetModel) =>
2718 Effect.gen(function* () {
2719 const fake = yield* makeFakePi;
2720 fake.queueState({
2721 model: { provider: "anthropic", id: "model-b" },
2722 thinkingLevel: "high",
2723 sessionFile: FAKE_SESSION_FILE,
2724 });
2725 const { runtime, takeEvent } = yield* openRuntime(fake);
2726 const providerThread = yield* runtime.ensureThread({
2727 threadId: THREAD_ID,
2728 modelSelection: modelSelection("default"),
2729 runtimePolicy,
2730 });
2731 const selection = (model: string): ModelSelection => ({
2732 instanceId: PI_INSTANCE_ID,
2733 model,
2734 options: [{ id: "thinking", value: "high" }],
2735 });
2736
2737 yield* startTurn(
2738 runtime,
2739 providerThread,
2740 "default",
2741 [],
2742 "First",
2743 selection("anthropic/model-a"),
2744 );
2745 yield* fake.takeRequest("prompt");
2746 yield* fake.emit({ type: "agent_start" });
2747 yield* fake.emit({ type: "agent_end", messages: [], willRetry: false });
2748 yield* fake.emit({ type: "agent_settled" });
2749 yield* takeEvent((event) => event.type === "turn.terminal");
2750
2751 yield* startTurn(
2752 runtime,
2753 providerThread,
2754 "default",
2755 [],
2756 "Second",
2757 selection(targetModel),
2758 2,
2759 );
2760 yield* fake.takeRequest("prompt");
2761 assert.deepEqual(fake.promptThinkingLevels, ["high", "high"]);
2762 }).pipe(Effect.scoped, Effect.provide(layerTest)),
2763 );
2764
2765 it.effect("applies the selected service tier without changing thinking", () =>
2766 Effect.gen(function* () {
2767 const fake = yield* makeFakePi;
2768 const { runtime, takeEvent } = yield* openRuntime(fake);
2769 const providerThread = yield* runtime.ensureThread({
2770 threadId: THREAD_ID,
2771 modelSelection: modelSelection("default"),
2772 runtimePolicy,
2773 });
2774 const turn = (text: string, serviceTier: string | undefined, ordinal: number) =>
2775 Effect.gen(function* () {
2776 yield* startTurn(
2777 runtime,
2778 providerThread,
2779 "default",
2780 [],
2781 text,
2782 {
2783 instanceId: PI_INSTANCE_ID,
2784 model: "columbia-codex/gpt-6.1-sol",
2785 options: [
2786 { id: "thinking", value: "high" },
2787 ...(serviceTier === undefined ? [] : [{ id: "serviceTier", value: serviceTier }]),
2788 ],
2789 },
2790 ordinal,
2791 );
2792 while (String((yield* fake.takeRequest("prompt"))["message"]).startsWith("/")) {}
2793 yield* fake.emit({ type: "agent_start" });
2794 yield* fake.emit({ type: "agent_end", messages: [], willRetry: false });
2795 yield* fake.emit({ type: "agent_settled" });
2796 yield* takeEvent((event) => event.type === "turn.terminal");
2797 });
2798
2799 yield* turn("Fast", "priority", 1);
2800 fake.reloadExtensions();
2801 yield* turn("Still fast", "priority", 2);
2802 yield* turn("Ultrafast", "ultrafast", 3);
2803 fake.omitPromptDisposition();
2804 yield* turn("Standard", "default", 4);
2805 yield* turn("Unset", undefined, 5);
2806
2807 assert.deepEqual(fake.promptServiceTiers, ["priority", "priority", "ultrafast", null, null]);
2808 assert.deepEqual(fake.promptThinkingLevels, ["high", "high", "high", "high", "high"]);
2809 assert.deepEqual(
2810 fake
2811 .allRequests()
2812 .flatMap((request) =>
2813 String(request["message"]).startsWith(`/${PI_T3_SERVICE_TIER_COMMAND}`)
2814 ? [request["message"]]
2815 : [],
2816 ),
2817 [
2818 `/${PI_T3_SERVICE_TIER_COMMAND} priority`,
2819 `/${PI_T3_SERVICE_TIER_COMMAND} priority`,
2820 `/${PI_T3_SERVICE_TIER_COMMAND} ultrafast`,
2821 `/${PI_T3_SERVICE_TIER_COMMAND}`,
2822 ],
2823 );
2824 }).pipe(Effect.scoped, Effect.provide(layerTest)),
2825 );
2826
2827 it.effect("tracks the session file a user extension switches to during a turn", () =>
2828 Effect.gen(function* () {
2829 const fake = yield* makeFakePi;
2830 const { runtime, takeEvent } = yield* openRuntime(fake);
2831 const providerThread = yield* runtime.ensureThread({
2832 threadId: THREAD_ID,
2833 modelSelection: modelSelection("default"),
2834 runtimePolicy,
2835 });
2836 assert.equal(providerThread.nativeThreadRef?.nativeId, FAKE_SESSION_FILE);
2837 const childFile = "/fake/extension-child.jsonl";
2838
2839 // An extension command such as /handoff calls ctx.newSession(); later prompts go to its file.
2840 yield* startTurn(runtime, providerThread, "default", [], "/handoff", undefined, 1);
2841 yield* fake.takeRequest("prompt");
2842 fake.reloadExtensions(childFile);
2843 yield* fake.emit({ type: "response", command: "prompt", success: true });
2844 yield* takeEvent((event) => event.type === "turn.terminal");
2845
2846 yield* startTurn(runtime, providerThread, "default", [], "prompt B", undefined, 2);
2847 yield* fake.takeRequest("prompt");
2848 yield* fake.emit({ type: "agent_start" });
2849 yield* fake.emit({ type: "agent_end", messages: [], willRetry: false });
2850 yield* fake.emit({ type: "agent_settled" });
2851 const completed = yield* takeEvent(
2852 (event) =>
2853 event.type === "provider_turn.updated" && event.providerTurn.status === "completed",
2854 );
2855 assert.equal(
2856 completed.type === "provider_turn.updated"
2857 ? completed.providerTurn.nativeThreadRef?.nativeId
2858 : undefined,
2859 childFile,
2860 );
2861 const idle = yield* takeEvent(
2862 (event) =>
2863 event.type === "provider_thread.updated" && event.providerThread.status === "idle",
2864 );
2865 yield* takeEvent((event) => event.type === "turn.terminal");
2866
2867 // The persisted ref is what a later resume passes to switch_session.
2868 assert.equal(
2869 idle.type === "provider_thread.updated"
2870 ? idle.providerThread.nativeThreadRef?.nativeId
2871 : undefined,
2872 childFile,
2873 );
2874 }).pipe(Effect.scoped, Effect.provide(layerTest)),
2875 );
2876
2877 it.effect.each(["abort", "runtime restart"] as const)(
2878 "keeps the extension's session file when its handoff turn is stopped (%s)",
2879 (stop) =>
2880 Effect.gen(function* () {
2881 const fake = yield* makeFakePi;
2882 const { runtime, takeEvent } = yield* openRuntime(fake);
2883 const providerThread = yield* runtime.ensureThread({
2884 threadId: THREAD_ID,
2885 modelSelection: modelSelection("default"),
2886 runtimePolicy,
2887 });
2888 yield* startTurn(runtime, providerThread, "default", [], "/handoff");
2889 yield* fake.takeRequest("prompt");
2890 const running = yield* takeEvent((event) => event.type === "provider_turn.updated");
2891 if (running.type !== "provider_turn.updated") return yield* Effect.die("Missing turn");
2892 const childFile = "/fake/extension-child.jsonl";
2893 fake.reloadExtensions(childFile);
2894 fake.setStreaming(true);
2895 yield* fake.emit({ type: "response", command: "prompt", success: true });
2896 yield* fake.emit({ type: "agent_start" });
2897 yield* runtime.interruptTurn({
2898 providerThread,
2899 providerTurnId: running.providerTurn.id,
2900 requestRuntimeRestart: stop === "runtime restart",
2901 });
2902 if (stop === "abort") {
2903 fake.setStreaming(false);
2904 yield* fake.emit({ type: "agent_settled", aborted: true });
2905 }
2906 const idle = yield* takeEvent(
2907 (event) =>
2908 event.type === "provider_thread.updated" && event.providerThread.status === "idle",
2909 );
2910 const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
2911 assert.equal(
2912 terminal.type === "turn.terminal" ? terminal.status : undefined,
2913 "interrupted",
2914 );
2915 assert.equal(
2916 idle.type === "provider_thread.updated"
2917 ? idle.providerThread.nativeThreadRef?.nativeId
2918 : undefined,
2919 childFile,
2920 );
2921 }).pipe(Effect.scoped, Effect.provide(layerTest)),
2922 );
2923
2924 it.effect.each([false, true, "previous"] as const)(
2925 "resets applied thinking when returning to Pi default (failed first restore: %s)",
2926 (failFirstRestore) =>
2927 Effect.gen(function* () {
2928 const fake = yield* makeFakePi;
2929 fake.queueState({
2930 model: { provider: "xai", id: "grok-4.6" },
2931 thinkingLevel: "medium",
2932 sessionFile: FAKE_SESSION_FILE,
2933 sessionId: "abc",
2934 });
2935 const { runtime, takeEvent } = yield* openRuntime(fake);
2936 const providerThread = yield* runtime.ensureThread({
2937 threadId: THREAD_ID,
2938 modelSelection: modelSelection("default"),
2939 runtimePolicy,
2940 });
2941
2942 yield* startTurn(runtime, providerThread, "default", [], "Hello pi", {
2943 instanceId: PI_INSTANCE_ID,
2944 model: "anthropic/model-a",
2945 options: [{ id: "thinking", value: "high" }],
2946 });
2947 const modelRequest = yield* fake.takeRequest("set_model");
2948 assert.equal(modelRequest["provider"], "anthropic");
2949 assert.equal(modelRequest["modelId"], "model-a");
2950 const levelRequest = yield* fake.takeRequest("set_thinking_level");
2951 assert.equal(levelRequest["level"], "high");
2952 yield* fake.takeRequest("prompt");
2953 yield* fake.emit({ type: "agent_start" });
2954 yield* fake.emit({ type: "agent_end", messages: [], willRetry: false });
2955 yield* fake.emit({ type: "agent_settled" });
2956 yield* takeEvent((event) => event.type === "turn.terminal");
2957
2958 if (failFirstRestore) {
2959 fake.failNextThinking();
2960 const result = yield* startTurn(
2961 runtime,
2962 providerThread,
2963 "default",
2964 [],
2965 "Hello pi",
2966 {
2967 instanceId: PI_INSTANCE_ID,
2968 model: "default",
2969 },
2970 2,
2971 ).pipe(Effect.exit);
2972 assert.equal(result._tag, "Failure");
2973 yield* fake.takeRequest("set_model");
2974 yield* fake.takeRequest("set_thinking_level");
2975 }
2976
2977 yield* startTurn(
2978 runtime,
2979 providerThread,
2980 "default",
2981 [],
2982 "Hello pi",
2983 {
2984 instanceId: PI_INSTANCE_ID,
2985 model: failFirstRestore === "previous" ? "anthropic/model-a" : "default",
2986 ...(failFirstRestore === "previous"
2987 ? { options: [{ id: "thinking", value: "high" }] }
2988 : {}),
2989 },
2990 2,
2991 );
2992 yield* fake.takeRequest("prompt");
2993 assert.deepEqual(fake.promptThinkingLevels, [
2994 "high",
2995 failFirstRestore === "previous" ? "high" : "medium",
2996 ]);
2997 assert.deepEqual(fake.promptModels, [
2998 "anthropic/model-a",
2999 failFirstRestore === "previous" ? "anthropic/model-a" : "xai/grok-4.6",
3000 ]);
3001 const replayModel = fake
3002 .allRequests()
3003 .findLast((request) => request["type"] === "set_model")!;
3004 assert.equal(
3005 replayModel["provider"],
3006 failFirstRestore === "previous" ? "anthropic" : "xai",
3007 );
3008 assert.equal(
3009 replayModel["modelId"],
3010 failFirstRestore === "previous" ? "model-a" : "grok-4.6",
3011 );
3012 const resetLevel = fake
3013 .allRequests()
3014 .findLast((request) => request["type"] === "set_thinking_level")!;
3015 assert.equal(resetLevel["level"], failFirstRestore === "previous" ? "high" : "medium");
3016 }).pipe(Effect.scoped, Effect.provide(layerTest)),
3017 );
3018
3019 it.effect.each([
3020 { historical: false, moved: false, split: false, label: "the latest turn" },
3021 { historical: true, moved: false, split: false, label: "a historical turn" },
3022 {
3023 historical: true,
3024 moved: true,
3025 split: false,
3026 label: "a historical turn after a session switch",
3027 },
3028 {
3029 historical: true,
3030 moved: true,
3031 split: true,
3032 label: "the last turn before a switch to a fresh session",
3033 },
3034 ])("natively forks $label into an independent session", ({ historical, moved, split }) =>
3035 Effect.gen(function* () {
3036 const fake = yield* makeFakePi;
3037 const forkFake = yield* makeFakePi;
3038 const forkFile = "/fake/forked.jsonl";
3039 const { runtime, takeEvent } = yield* openRuntime(
3040 fake,
3041 "default",
3042 THREAD_ID,
3043 SESSION_ID,
3044 forkFake,
3045 );
3046 const source = yield* runtime.ensureThread({
3047 threadId: THREAD_ID,
3048 modelSelection: modelSelection("default"),
3049 runtimePolicy,
3050 });
3051 const freshSession = {
3052 driver: PI_PROVIDER,
3053 nativeId: "/fake/new-session.jsonl",
3054 strength: "strong",
3055 } as const;
3056 const turn = (ordinal: number): OrchestrationV2ProviderTurn => ({
3057 id: ProviderTurnId.make(`turn-${ordinal}`),
3058 providerThreadId: source.id,
3059 nodeId: NodeId.make(`node-${ordinal}`),
3060 runAttemptId: null,
3061 nativeTurnRef: { driver: PI_PROVIDER, nativeId: `u${ordinal}`, strength: "strong" },
3062 ...(split && ordinal === 2
3063 ? { nativeThreadRef: freshSession }
3064 : moved && source.nativeThreadRef !== null
3065 ? { nativeThreadRef: source.nativeThreadRef }
3066 : {}),
3067 ordinal,
3068 status: "completed",
3069 startedAt: null,
3070 completedAt: null,
3071 });
3072 yield* startTurn(runtime, source, "anthropic/claude-sonnet");
3073 yield* fake.takeRequest("prompt");
3074 yield* fake.emit({ type: "agent_start" });
3075 yield* fake.emit({ type: "agent_settled" });
3076 yield* takeEvent((event) => event.type === "turn.terminal");
3077 forkFake.queueState({ sessionFile: forkFile });
3078 fake.queueState({ sessionFile: FAKE_SESSION_FILE });
3079 fake.queueState({ sessionFile: forkFile });
3080 const target = ThreadId.make("fork-target");
3081 const forked = yield* runtime.forkThread({
3082 sourceProviderThread: moved ? { ...source, nativeThreadRef: freshSession } : source,
3083 sourceProviderTurns: historical ? [turn(1), turn(2)] : [turn(1)],
3084 providerTurnId: turn(1).id,
3085 targetThreadId: target,
3086 });
3087 assert.equal(forked.appThreadId, target);
3088 assert.equal(forked.nativeThreadRef?.nativeId, forkFile);
3089 assert.notEqual(forked.id, source.id);
3090 assert.equal(source.nativeThreadRef?.nativeId, FAKE_SESSION_FILE);
3091 const args = forkFake.lastSpawn().args;
3092 assert.equal(args[args.indexOf("--fork") + 1], FAKE_SESSION_FILE);
3093 assert.include(args, "--no-extensions");
3094 assert.include(args, "--no-tools");
3095 assert.include(args, "--offline");
3096 assert.notInclude(args, "--no-session");
3097 assert.deepEqual(
3098 forkFake
3099 .allRequests()
3100 .filter((request) => request.type === "fork")
3101 .map((request) => request.entryId),
3102 historical && !split ? ["u2"] : [],
3103 );
3104 assert.isFalse(
3105 fake.allRequests().some((request) => request.type === "fork" || request.type === "clone"),
3106 );
3107 const adopted = { ...forked, id: ProviderThreadId.make("pending-fork-row") };
3108 yield* startTurn(
3109 runtime,
3110 adopted,
3111 "anthropic/claude-sonnet",
3112 [],
3113 "Continue",
3114 undefined,
3115 1,
3116 target,
3117 );
3118 yield* fake.takeRequest("prompt");
3119 assert.equal(fake.allRequests().filter((request) => request.type === "set_model").length, 2);
3120 yield* fake.emit({ type: "agent_start" });
3121 yield* fake.emit({ type: "agent_settled" });
3122 const updated = yield* takeEvent(
3123 (event) =>
3124 event.type === "provider_thread.updated" && event.providerThread.appThreadId === target,
3125 );
3126 assert.isTrue(
3127 updated.type === "provider_thread.updated" && updated.providerThread.id === adopted.id,
3128 );
3129 yield* takeEvent((event) => event.type === "turn.terminal");
3130 yield* runtime.resumeThread({ providerThread: adopted });
3131 assert.equal(
3132 fake.allRequests().findLast((request) => request.type === "switch_session")?.sessionPath,
3133 forkFile,
3134 );
3135 }).pipe(Effect.scoped, Effect.provide(layerTest)),
3136 );
3137
3138 it.effect("recovers a historical Pi fork recorded before turns stored the session file", () =>
3139 Effect.gen(function* () {
3140 const fs = yield* FileSystem.FileSystem;
3141 const dir = yield* fs.makeTempDirectoryScoped();
3142 const oldFile = `${dir}/original.jsonl`;
3143 const unrelatedFile = `${dir}/unrelated.jsonl`;
3144 const currentFile = `${dir}/current.jsonl`;
3145 const header = { type: "session", version: 3 };
3146 const writeSession = (file: string, entries: ReadonlyArray<unknown>) =>
3147 fs.writeFileString(
3148 file,
3149 [header, ...entries].map((entry) => encodeJsonLine(entry)).join("\n") + "\n",
3150 );
3151 yield* writeSession(oldFile, UNCAPTURED_TURN_TREE.entries);
3152 yield* writeSession(unrelatedFile, [
3153 sessionMessage("u1", null, "user", 10),
3154 sessionMessage("u2", null, "user", 110),
3155 ]);
3156 yield* writeSession(currentFile, [sessionMessage("new", null, "user", 120)]);
3157
3158 const fake = yield* makeFakePi;
3159 const forkFake = yield* makeFakePi;
3160 const { runtime } = yield* openRuntime(fake, "default", THREAD_ID, SESSION_ID, forkFake);
3161 const source = yield* runtime.ensureThread({
3162 threadId: THREAD_ID,
3163 modelSelection: modelSelection("default"),
3164 runtimePolicy,
3165 });
3166 const forkFile = `${dir}/forked.jsonl`;
3167 forkFake.failNextFork();
3168 forkFake.queueState({ sessionFile: forkFile });
3169 fake.queueState({ sessionFile: forkFile });
3170 const [target, boundary] = uncapturedTurns(source.id, {
3171 startedAt: 100,
3172 completedAt: 145,
3173 });
3174 if (target === undefined || boundary === undefined) throw new Error("missing fork turns");
3175 const forked = yield* runtime.forkThread({
3176 sourceProviderThread: {
3177 ...source,
3178 nativeThreadRef: { driver: PI_PROVIDER, nativeId: currentFile, strength: "strong" },
3179 },
3180 sourceProviderTurns: [
3181 target,
3182 {
3183 ...boundary,
3184 nativeTurnRef: { driver: PI_PROVIDER, nativeId: "u2", strength: "strong" },
3185 },
3186 ],
3187 providerTurnId: target.id,
3188 targetThreadId: ThreadId.make("fork-target"),
3189 });
3190 const args = forkFake.lastSpawn().args;
3191 assert.equal(args[args.indexOf("--fork") + 1], oldFile);
3192 assert.equal(forked.nativeThreadRef?.nativeId, forkFile);
3193 }).pipe(Effect.scoped, Effect.provide(layerTest)),
3194 );
3195
3196 it.effect("natively forks before a turn whose start entry was never captured", () =>
3197 Effect.gen(function* () {
3198 const fake = yield* makeFakePi;
3199 const forkFake = yield* makeFakePi;
3200 const forkFile = "/fake/forked.jsonl";
3201 const { runtime } = yield* openRuntime(fake, "default", THREAD_ID, SESSION_ID, forkFake);
3202 const source = yield* runtime.ensureThread({
3203 threadId: THREAD_ID,
3204 modelSelection: modelSelection("default"),
3205 runtimePolicy,
3206 });
3207 const forkAtFirst = (turns: ReadonlyArray<OrchestrationV2ProviderTurn>) =>
3208 runtime.forkThread({
3209 sourceProviderThread: source,
3210 sourceProviderTurns: turns,
3211 providerTurnId: turns[0]!.id,
3212 targetThreadId: ThreadId.make("fork-target"),
3213 });
3214 const forkedEntries = () =>
3215 forkFake
3216 .allRequests()
3217 .filter((request) => request.type === "fork")
3218 .map((request) => request.entryId);
3219
3220 // A later prompt cannot stand in for a cancelled turn that ended before it landed.
3221 forkFake.queueEntries(UNCAPTURED_TURN_TREE);
3222 const unresolved = yield* forkAtFirst(
3223 uncapturedTurns(source.id, { startedAt: 60, completedAt: 100 }),
3224 ).pipe(Effect.result);
3225 assert.deepEqual(forkedEntries(), []);
3226 assert.equal(unresolved._tag, "Failure");
3227
3228 forkFake.queueEntries(UNCAPTURED_TURN_TREE);
3229 forkFake.queueState({ sessionFile: forkFile });
3230 fake.queueState({ sessionFile: forkFile });
3231 const forked = yield* forkAtFirst(
3232 uncapturedTurns(source.id, { startedAt: 100, completedAt: 200 }),
3233 );
3234 assert.equal(forked.nativeThreadRef?.nativeId, forkFile);
3235 assert.deepEqual(forkedEntries(), ["u2"]);
3236 assert.isFalse(fake.allRequests().some((request) => request.type === "fork"));
3237 }).pipe(Effect.scoped, Effect.provide(layerTest)),
3238 );
3239
3240 it.effect("natively forks before a running turn whose start entry was not captured yet", () =>
3241 Effect.gen(function* () {
3242 const fake = yield* makeFakePi;
3243 const forkFake = yield* makeFakePi;
3244 const forkFile = "/fake/forked.jsonl";
3245 const { runtime } = yield* openRuntime(fake, "default", THREAD_ID, SESSION_ID, forkFake);
3246 const source = yield* runtime.ensureThread({
3247 threadId: THREAD_ID,
3248 modelSelection: modelSelection("default"),
3249 runtimePolicy,
3250 });
3251 // Turn 2 is still in flight, so it has no end to bound the session-tree search.
3252 const turns = uncapturedTurns(source.id, { startedAt: 100, completedAt: 200 }).map((turn) =>
3253 turn.ordinal === 2 ? { ...turn, status: "running" as const, completedAt: null } : turn,
3254 );
3255 forkFake.queueEntries(UNCAPTURED_TURN_TREE);
3256 forkFake.queueState({ sessionFile: forkFile });
3257 fake.queueState({ sessionFile: forkFile });
3258
3259 const result = yield* runtime
3260 .forkThread({
3261 sourceProviderThread: source,
3262 sourceProviderTurns: turns,
3263 providerTurnId: turns[0]!.id,
3264 targetThreadId: ThreadId.make("fork-target"),
3265 })
3266 .pipe(Effect.exit);
3267 assert.isTrue(
3268 Exit.isSuccess(result),
3269 `forking turn 1 while turn 2 runs must locate turn 2's prompt in the session tree, got: ${
3270 Exit.isFailure(result) ? Cause.pretty(result.cause) : ""
3271 }`,
3272 );
3273 if (!Exit.isSuccess(result)) return;
3274 assert.equal(result.value.nativeThreadRef?.nativeId, forkFile);
3275
3276 const forkedEntries = forkFake
3277 .allRequests()
3278 .filter((request) => request.type === "fork")
3279 .map((request) => request.entryId);
3280 // Pi keeps only the fork entry's ancestors, so u2 (not steer2) drops all of turn 2.
3281 assert.deepEqual(forkedEntries, ["u2"]);
3282 }).pipe(Effect.scoped, Effect.provide(layerTest)),
3283 );
3284
3285 it.effect("presents explicitly namespaced MCP extension tools", () =>
3286 Effect.gen(function* () {
3287 const fake = yield* makeFakePi;
3288 const { runtime, takeEvent } = yield* openRuntime(fake);
3289 const providerThread = yield* runtime.ensureThread({
3290 threadId: THREAD_ID,
3291 modelSelection: modelSelection("default"),
3292 runtimePolicy,
3293 });
3294 yield* startTurn(runtime, providerThread);
3295 yield* fake.takeRequest("prompt");
3296 yield* fake.emit({ type: "agent_start" });
3297 for (const type of ["tool_execution_start", "tool_execution_end"]) {
3298 yield* fake.emit({
3299 type,
3300 toolCallId: "weather-call",
3301 toolName: "mcp__weather__get_weather",
3302 args: { city: "Berlin" },
3303 result: { content: [{ type: "text", text: "Sunny" }] },
3304 isError: false,
3305 });
3306 const event = yield* takeEvent(
3307 (event) => event.type === "turn_item.updated" && event.turnItem.type === "dynamic_tool",
3308 );
3309 if (event.type !== "turn_item.updated" || event.turnItem.type !== "dynamic_tool")
3310 return yield* Effect.die("Expected an MCP tool item");
3311 assert.equal(event.turnItem.title, "get weather");
3312 assert.equal(
3313 event.turnItem.status,
3314 type === "tool_execution_start" ? "running" : "completed",
3315 );
3316 assert.deepEqual(event.turnItem.toolSource, {
3317 key: "mcp:weather",
3318 name: "weather",
3319 kind: "integration",
3320 });
3321 assert.deepEqual(event.turnItem.input, { city: "Berlin" });
3322 }
3323 }).pipe(Effect.scoped, Effect.provide(layerTest)),
3324 );
3325
3326 it.effect("nests tools called through another tool under their caller", () =>
3327 Effect.gen(function* () {
3328 const fake = yield* makeFakePi;
3329 const { runtime, takeEvent } = yield* openRuntime(fake);
3330 const providerThread = yield* runtime.ensureThread({
3331 threadId: THREAD_ID,
3332 modelSelection: modelSelection("default"),
3333 runtimePolicy,
3334 });
3335 yield* startTurn(runtime, providerThread);
3336 yield* fake.takeRequest("prompt");
3337 yield* fake.emit({ type: "agent_start" });
3338 const takeToolEvents = Effect.fnUntraced(function* (toolCallId: string) {
3339 const node = yield* takeEvent(
3340 (event) =>
3341 event.type === "node.updated" && event.node.nativeItemRef?.nativeId === toolCallId,
3342 );
3343 const item = yield* takeEvent(
3344 (event) =>
3345 event.type === "turn_item.updated" &&
3346 event.turnItem.nativeItemRef?.nativeId === toolCallId,
3347 );
3348 if (node.type !== "node.updated" || item.type !== "turn_item.updated")
3349 return yield* Effect.die("Expected tool node and item events");
3350 return { node: node.node, item: item.turnItem };
3351 });
3352
3353 yield* fake.emit({
3354 type: "tool_execution_start",
3355 toolCallId: "call_code",
3356 toolName: "codemode",
3357 args: { code: "await read({ path: 'a.ts' })" },
3358 });
3359 const caller = yield* takeToolEvents("call_code");
3360 assert.equal(caller.node.parentNodeId, caller.node.rootNodeId);
3361 assert.isNull(caller.item.parentItemId);
3362
3363 // Pi tags every phase, so an update that arrives before its start still nests.
3364 const phases = [
3365 { type: "tool_execution_update", partialResult: { content: [] }, status: "running" },
3366 { type: "tool_execution_start", args: { path: "a.ts" }, status: "running" },
3367 {
3368 type: "tool_execution_end",
3369 isError: true,
3370 result: { content: [{ type: "text", text: "ENOENT" }] },
3371 status: "failed",
3372 },
3373 ] as const;
3374 for (const { status, ...phase } of phases) {
3375 yield* fake.emit({
3376 ...phase,
3377 toolCallId: "call_code/1",
3378 toolName: "read",
3379 parentToolCallId: "call_code",
3380 });
3381 const nested = yield* takeToolEvents("call_code/1");
3382 assert.equal(nested.node.status, status);
3383 assert.equal(nested.node.parentNodeId, caller.node.id);
3384 assert.equal(nested.item.parentItemId, caller.item.id);
3385 }
3386 }).pipe(Effect.scoped, Effect.provide(layerTest)),
3387 );
3388
3389 it.effect(
3390 "keeps native and MCP images available to the shared asset reader with typed results",
3391 () =>
3392 Effect.gen(function* () {
3393 const fake = yield* makeFakePi;
3394 const { runtime, takeEvent } = yield* openRuntime(fake);
3395 const providerThread = yield* runtime.ensureThread({
3396 threadId: THREAD_ID,
3397 modelSelection: modelSelection("default"),
3398 runtimePolicy,
3399 });
3400 yield* startTurn(runtime, providerThread);
3401 yield* fake.takeRequest("prompt");
3402 yield* fake.emit({ type: "agent_start" });
3403 const image = {
3404 type: "image",
3405 mimeType: "image/png",
3406 data: Buffer.alloc(64 * 1024, 0x61).toString("base64"),
3407 };
3408 const note = "Read image file [image/png]";
3409 const content = [{ type: "text", text: note }, image];
3410 const structured = { count: 2, ready: true, paths: ["one.png", "two.png"] };
3411 const scriptResult = { content, structuredContent: { threadId: "child-thread" } };
3412 const cases = [
3413 {
3414 toolName: "read",
3415 args: { path: "/workspace/screens/shot.png" },
3416 result: { content, structuredContent: { ...image, note } },
3417 expected: { content },
3418 },
3419 {
3420 toolName: "image_generate",
3421 result: { content, structuredContent: structured },
3422 expected: { content, structuredContent: structured },
3423 },
3424 {
3425 toolName: "mcp__t3-code__preview_snapshot",
3426 result: {
3427 content,
3428 structuredContent: scriptResult,
3429 details: { server: "t3-code", tool: "preview_snapshot" },
3430 },
3431 expected: { content, structuredContent: { threadId: "child-thread" } },
3432 },
3433 {
3434 toolName: "structured_tool",
3435 result: { content: [], structuredContent: [false, 2, null, { ready: true }] },
3436 expected: { content: [], structuredContent: [false, 2, null, { ready: true }] },
3437 },
3438 {
3439 toolName: "mcp__custom__extension",
3440 result: { content, structuredContent: { content: ["domain content"], ready: true } },
3441 expected: { content, structuredContent: { content: ["domain content"], ready: true } },
3442 },
3443 {
3444 toolName: "mcp__t3-code__preview_snapshot",
3445 result: {
3446 content: [
3447 { type: "text", text: "first" },
3448 { type: "text", text: "second" },
3449 ],
3450 structuredContent: {
3451 content: [
3452 { type: "text", text: "first" },
3453 { type: "text", text: "second" },
3454 ],
3455 },
3456 details: { server: "t3-code", tool: "preview_snapshot" },
3457 },
3458 expected: {
3459 content: [
3460 { type: "text", text: "first" },
3461 { type: "text", text: "second" },
3462 ],
3463 },
3464 },
3465 ];
3466 for (const [index, test] of cases.entries()) {
3467 for (const phase of ["update", "end"] as const) {
3468 yield* fake.emit({
3469 type: `tool_execution_${phase}`,
3470 toolCallId: `image-${index}`,
3471 toolName: test.toolName,
3472 ...("args" in test ? { args: test.args } : {}),
3473 ...(phase === "end" ? { result: test.result } : { partialResult: test.result }),
3474 isError: false,
3475 });
3476 const event = yield* takeEvent(
3477 (event) =>
3478 event.type === "turn_item.updated" && event.turnItem.type === "dynamic_tool",
3479 );
3480 if (event.type !== "turn_item.updated" || event.turnItem.type !== "dynamic_tool")
3481 return yield* Effect.die("Expected an image tool item");
3482 assert.equal(event.turnItem.status, phase === "end" ? "completed" : "running");
3483 assert.deepEqual(event.turnItem.output, test.expected);
3484 assert.deepEqual(
3485 toolOutputImages(event.turnItem.output),
3486 test.expected.content.some((block) => block.type === "image")
3487 ? [{ mimeType: "image/png", data: image.data }]
3488 : [],
3489 );
3490 if (index === 0) {
3491 assert.equal(turnItemOutputText(event.turnItem), note);
3492 assert.equal(event.turnItem.viewedImagePath, "/workspace/screens/shot.png");
3493 }
3494 if (index === 5) assert.equal(turnItemOutputText(event.turnItem), "first\nsecond");
3495 if (index === 2) {
3496 assert.deepEqual(compactDynamicToolOutput(event.turnItem.output), {
3497 threadId: "child-thread",
3498 });
3499 assert.equal(JSON.stringify(event.turnItem.output).split(image.data).length - 1, 1);
3500 }
3501 }
3502 }
3503 }).pipe(Effect.scoped, Effect.provide(layerTest)),
3504 );
3505
3506 it.effect(
3507 "keeps large tool text readable, drops identical read mirrors, and bounds structured values",
3508 () =>
3509 Effect.gen(function* () {
3510 const fake = yield* makeFakePi;
3511 const { runtime, takeEvent } = yield* openRuntime(fake);
3512 const providerThread = yield* runtime.ensureThread({
3513 threadId: THREAD_ID,
3514 modelSelection: modelSelection("default"),
3515 runtimePolicy,
3516 });
3517 yield* startTurn(runtime, providerThread);
3518 yield* fake.takeRequest("prompt");
3519 yield* fake.emit({ type: "agent_start" });
3520 const text = "hello\nworld\n" + "🙂".repeat(40_000);
3521 const content = [{ type: "text", text }];
3522 const cases = [
3523 { content, structuredContent: text },
3524 { content, structuredContent: { oversized: "x".repeat(128 * 1024) } },
3525 { content, structuredContent: Array.from({ length: 10_000 }, () => 1) },
3526 {
3527 content,
3528 structuredContent: Array.from({ length: 40 }).reduce<unknown>(
3529 (nested) => ({ nested }),
3530 null,
3531 ),
3532 },
3533 ];
3534 for (const [index, result] of cases.entries()) {
3535 yield* fake.emit({
3536 type: "tool_execution_end",
3537 toolCallId: `structured-${index}`,
3538 toolName: "read",
3539 result,
3540 isError: true,
3541 });
3542 const event = yield* takeEvent(
3543 (event) => event.type === "turn_item.updated" && event.turnItem.type === "dynamic_tool",
3544 );
3545 if (event.type !== "turn_item.updated" || event.turnItem.type !== "dynamic_tool")
3546 return yield* Effect.die("Expected a tool item");
3547 assert.equal(event.turnItem.status, "failed");
3548 assert.notProperty(event.turnItem.output, "structuredContent");
3549 const displayed = turnItemOutputText(event.turnItem);
3550 if (index === 0) {
3551 assert.equal(event.turnItem.output, text);
3552 assert.equal(displayed, text);
3553 } else {
3554 assert.equal(
3555 displayed,
3556 text + "\nStructured output omitted because it exceeds the stored result limit.",
3557 );
3558 assert.deepEqual(Object.keys(event.turnItem.output as object), ["content"]);
3559 }
3560 }
3561 yield* fake.emit({
3562 type: "tool_execution_end",
3563 toolCallId: "distinct-metadata",
3564 toolName: "read",
3565 result: { content, structuredContent: { path: "read.ts", ready: true } },
3566 });
3567 const event = yield* takeEvent(
3568 (event) => event.type === "turn_item.updated" && event.turnItem.type === "dynamic_tool",
3569 );
3570 if (event.type !== "turn_item.updated" || event.turnItem.type !== "dynamic_tool")
3571 return yield* Effect.die("Expected a tool item");
3572 assert.deepEqual(event.turnItem.output, {
3573 content,
3574 structuredContent: { path: "read.ts", ready: true },
3575 });
3576 assert.equal(turnItemOutputText(event.turnItem), text);
3577 const note = "Read image file [image/png]";
3578 const image = { type: "image", data: "AAAA", mimeType: "image/png" };
3579 const imageContent = [{ type: "text", text: note }, image];
3580 for (const structuredContent of [
3581 { ...image, note, width: 1200 },
3582 { ...image, note: "A distinct note" },
3583 { ...image, note, data: "AQID" },
3584 ]) {
3585 yield* fake.emit({
3586 type: "tool_execution_end",
3587 toolCallId: "distinct-image-metadata",
3588 toolName: "read",
3589 result: { content: imageContent, structuredContent },
3590 });
3591 const event = yield* takeEvent(
3592 (event) => event.type === "turn_item.updated" && event.turnItem.type === "dynamic_tool",
3593 );
3594 if (event.type !== "turn_item.updated" || event.turnItem.type !== "dynamic_tool")
3595 return yield* Effect.die("Expected a read image tool item");
3596 assert.deepEqual(event.turnItem.output, { content: imageContent, structuredContent });
3597 assert.equal(
3598 turnItemOutputText(event.turnItem),
3599 JSON.stringify(structuredContent, null, 2),
3600 );
3601 }
3602 }).pipe(Effect.scoped, Effect.provide(layerTest)),
3603 );
3604
3605 it.effect(
3606 "delivers realistic MCP screenshots through the bridge, JSONL transport, and adapter",
3607 () =>
3608 Effect.gen(function* () {
3609 const fake = yield* makeFakePi;
3610 const { runtime, takeEvent } = yield* openRuntime(fake);
3611 const providerThread = yield* runtime.ensureThread({
3612 threadId: THREAD_ID,
3613 modelSelection: modelSelection("default"),
3614 runtimePolicy,
3615 });
3616 yield* startTurn(runtime, providerThread);
3617 yield* fake.takeRequest("prompt");
3618 yield* fake.emit({ type: "agent_start" });
3619 for (const size of [3.25 * 1024 * 1024, 10 * 1024 * 1024]) {
3620 const pixels = Buffer.alloc(size, 0x61);
3621 const data = pixels.toString("base64");
3622 const content = [
3623 { type: "text", text: "Screenshot captured" },
3624 { type: "image", data, mimeType: "image/png" },
3625 ];
3626 const metadata = { screenshot: { width: 1200, height: 800 }, ready: true };
3627 const bridge = yield* Effect.promise(() =>
3628 loadMcpBridge({ modern: true, result: { content, structuredContent: metadata } }),
3629 );
3630 const tool = bridge.tools.find((tool) => tool.name === "mcp__t3-code__preview_snapshot")!;
3631 const result = yield* Effect.promise(() => tool.execute("screenshot", {}));
3632 assert.deepEqual(result.structuredContent, { content, structuredContent: metadata });
3633 yield* fake.emit(
3634 {
3635 type: "tool_execution_end",
3636 toolCallId: "screenshot",
3637 toolName: tool.name,
3638 result,
3639 isError: false,
3640 },
3641 64 * 1024,
3642 );
3643 yield* fake.emit({
3644 type: "tool_execution_end",
3645 toolCallId: "after-screenshot",
3646 toolName: "marker",
3647 result: { content: [{ type: "text", text: "after" }] },
3648 });
3649 const event = yield* takeEvent(
3650 (event) => event.type === "turn_item.updated" && event.turnItem.type === "dynamic_tool",
3651 );
3652 if (event.type !== "turn_item.updated" || event.turnItem.type !== "dynamic_tool")
3653 return yield* Effect.die("Expected a screenshot tool item");
3654 assert.equal(event.turnItem.toolName, tool.name);
3655 assert.equal(event.turnItem.status, "completed");
3656 assert.deepEqual(event.turnItem.output, { content, structuredContent: metadata });
3657 assert.equal(turnItemOutputText(event.turnItem), JSON.stringify(metadata, null, 2));
3658 const image = toolOutputImages(event.turnItem.output)[0];
3659 assert.equal(image?.mimeType, "image/png");
3660 assert.deepEqual(Buffer.from(image!.data!, "base64"), pixels);
3661 yield* takeEvent(
3662 (event) =>
3663 event.type === "turn_item.updated" &&
3664 event.turnItem.type === "dynamic_tool" &&
3665 event.turnItem.toolName === "marker",
3666 );
3667 }
3668 }).pipe(Effect.scoped, Effect.provide(layerTest)),
3669 );
3670
3671 it.effect("observes official subagent results without inventing child threads", () =>
3672 Effect.gen(function* () {
3673 const fake = yield* makeFakePi;
3674 const { runtime, takeEvent } = yield* openRuntime(fake);
3675 const providerThread = yield* runtime.ensureThread({
3676 threadId: THREAD_ID,
3677 modelSelection: modelSelection("default"),
3678 runtimePolicy,
3679 });
3680 yield* startTurn(runtime, providerThread);
3681 yield* fake.takeRequest("prompt");
3682 yield* fake.emit({ type: "agent_start" });
3683 yield* fake.emit({
3684 type: "tool_execution_update",
3685 toolCallId: "call_sub",
3686 toolName: "subagent",
3687 partialResult: {
3688 content: [{ type: "text", text: "(running...)" }],
3689 details: {
3690 mode: "single",
3691 results: [
3692 {
3693 agent: "scout",
3694 task: "map the repo",
3695 exitCode: 0,
3696 stderr: "",
3697 sessionFile: "/ignored/custom-extension-session.jsonl",
3698 messages: [
3699 { role: "assistant", content: [{ type: "text", text: "scanning files" }] },
3700 ],
3701 },
3702 ],
3703 },
3704 },
3705 });
3706 const running = yield* takeEvent(
3707 (event) => event.type === "subagent.updated" && event.subagent.status === "running",
3708 );
3709 assert.isTrue(
3710 running.type === "subagent.updated" &&
3711 running.subagent.title === "scout" &&
3712 running.subagent.prompt === "map the repo" &&
3713 running.subagent.progress === "scanning files" &&
3714 running.subagent.childThreadId === null,
3715 );
3716
3717 yield* fake.emit({
3718 type: "tool_execution_end",
3719 toolCallId: "call_sub",
3720 toolName: "subagent",
3721 isError: false,
3722 result: {
3723 content: [{ type: "text", text: "done" }],
3724 details: {
3725 mode: "single",
3726 results: [
3727 {
3728 agent: "scout",
3729 task: "map the repo",
3730 exitCode: 0,
3731 stopReason: "stop",
3732 stderr: "",
3733 messages: [
3734 { role: "assistant", content: [{ type: "text", text: "repo has one file" }] },
3735 ],
3736 },
3737 ],
3738 },
3739 },
3740 });
3741 const doneCard = yield* takeEvent(
3742 (event) => event.type === "subagent.updated" && event.subagent.status === "completed",
3743 );
3744 assert.isTrue(
3745 doneCard.type === "subagent.updated" &&
3746 doneCard.subagent.result === "repo has one file" &&
3747 doneCard.subagent.childThreadId === null,
3748 );
3749 const subagentItem = yield* takeEvent(
3750 (event) =>
3751 event.type === "turn_item.updated" &&
3752 event.turnItem.type === "subagent" &&
3753 event.turnItem.status === "completed",
3754 );
3755 assert.isTrue(
3756 subagentItem.type === "turn_item.updated" &&
3757 subagentItem.turnItem.type === "subagent" &&
3758 subagentItem.turnItem.childThreadId === null,
3759 );
3760 }).pipe(Effect.scoped, Effect.provide(layerTest)),
3761 );
3762
3763 it.effect("shows the members of an async pi-subagents workflow as running subagents", () =>
3764 Effect.gen(function* () {
3765 const fake = yield* makeFakePi;
3766 const { runtime, takeEvent } = yield* openRuntime(fake);
3767 const providerThread = yield* runtime.ensureThread({
3768 threadId: THREAD_ID,
3769 modelSelection: modelSelection("default"),
3770 runtimePolicy,
3771 });
3772 yield* startTurn(runtime, providerThread);
3773 yield* fake.takeRequest("prompt");
3774 yield* fake.emit({ type: "agent_start" });
3775 // Frames as pi-subagents 0.88.1 sends them for an async `runs.all([alpha, beta])` workflow.
3776 const step = (key: string, state: string) => ({
3777 id: key,
3778 kind: "step",
3779 label: key,
3780 state,
3781 startedAt: 1_000,
3782 updatedAt: 2_000,
3783 activity: { currentTool: "bash", turnCount: 1, toolCount: 1 },
3784 agent: "scout",
3785 model: "anthropic/claude-haiku-5-5",
3786 });
3787 const emitSnapshot = (state: string, alpha: string, beta: string) =>
3788 fake.emit({
3789 type: "extension_ui_request",
3790 id: `widget-${state}`,
3791 method: "setWidget",
3792 widgetKey: "subagent-async",
3793 widgetLines: [
3794 `PI_SUBAGENT_ASYNC_JSON:${JSON.stringify({
3795 kind: "pi-subagents.async-status-snapshot",
3796 version: 1,
3797 generatedAt: 2_000,
3798 runs: [
3799 {
3800 id: "wf-1",
3801 kind: "workflow",
3802 label: "scout, scout",
3803 state,
3804 startedAt: 1_000,
3805 updatedAt: 2_000,
3806 children: [step("alpha", alpha), step("beta", beta)],
3807 },
3808 ],
3809 })}`,
3810 ],
3811 });
3812 const collect = (marker: string) =>
3813 Effect.gen(function* () {
3814 yield* fake.emit({
3815 type: "tool_execution_end",
3816 toolCallId: marker,
3817 toolName: marker,
3818 result: { content: [{ type: "text", text: "after" }] },
3819 });
3820 const statuses = new Map<string, string>();
3821 const pending: Array<boolean> = [];
3822 while (true) {
3823 const event = yield* takeEvent(
3824 (event) =>
3825 event.type === "subagent.updated" ||
3826 event.type === "background_work.updated" ||
3827 (event.type === "turn_item.updated" &&
3828 event.turnItem.type === "dynamic_tool" &&
3829 event.turnItem.toolName === marker),
3830 );
3831 if (event.type === "background_work.updated") pending.push(event.pending);
3832 else if (event.type === "subagent.updated")
3833 statuses.set(event.subagent.id, event.subagent.status);
3834 else break;
3835 }
3836 return { statuses: [...statuses.values()].toSorted(), pending };
3837 });
3838 // The launch snapshot precedes the tool result that names the run.
3839 yield* emitSnapshot("running", "running", "running");
3840 yield* fake.emit({
3841 type: "tool_execution_end",
3842 toolCallId: "call_wf",
3843 toolName: "subagent",
3844 isError: false,
3845 result: {
3846 content: [{ type: "text", text: "Async workflow started: wf-1" }],
3847 details: {
3848 mode: "workflow",
3849 runId: "wf-1",
3850 asyncId: "wf-1",
3851 results: [],
3852 workflowChildren: {
3853 version: 1,
3854 parentToolCallId: "call_wf",
3855 workflowRunId: "wf-1",
3856 inventoryComplete: false,
3857 workflowState: "running",
3858 children: [],
3859 },
3860 },
3861 },
3862 });
3863 assert.deepEqual(yield* collect("marker-1"), {
3864 statuses: ["running", "running"],
3865 pending: [true],
3866 });
3867 // pi-subagents can mark the run settled one snapshot before the member that ran last.
3868 yield* emitSnapshot("failed", "running", "failed");
3869 yield* emitSnapshot("failed", "complete", "failed");
3870 assert.deepEqual(yield* collect("marker-2"), {
3871 statuses: ["completed", "failed"],
3872 pending: [false],
3873 });
3874 }).pipe(Effect.scoped, Effect.provide(layerTest)),
3875 );
3876
3877 it.effect("persists edit patches and write content on file change items", () =>
3878 Effect.gen(function* () {
3879 const fake = yield* makeFakePi;
3880 const { runtime, takeEvent } = yield* openRuntime(fake);
3881 const providerThread = yield* runtime.ensureThread({
3882 threadId: THREAD_ID,
3883 modelSelection: modelSelection("default"),
3884 runtimePolicy,
3885 });
3886 yield* startTurn(runtime, providerThread);
3887 yield* fake.takeRequest("prompt");
3888 yield* fake.emit({ type: "agent_start" });
3889 const patch = "--- a.ts\n+++ a.ts\n@@ -1 +1 @@\n-old\n+new\n";
3890 yield* fake.emit({
3891 type: "tool_execution_start",
3892 toolCallId: "call_edit",
3893 toolName: "edit",
3894 args: { path: "a.ts", edits: [{ oldText: "old", newText: "new" }] },
3895 });
3896 yield* fake.emit({
3897 type: "tool_execution_end",
3898 toolCallId: "call_edit",
3899 toolName: "edit",
3900 isError: false,
3901 result: {
3902 content: [{ type: "text", text: "Successfully replaced 1 block(s) in a.ts." }],
3903 details: { diff: "-1 old\n+1 new", patch, firstChangedLine: 1 },
3904 },
3905 });
3906 const edit = yield* takeEvent(
3907 (event) =>
3908 event.type === "turn_item.updated" &&
3909 event.turnItem.type === "file_change" &&
3910 event.turnItem.status === "completed",
3911 );
3912 assert.isTrue(
3913 edit.type === "turn_item.updated" &&
3914 edit.turnItem.type === "file_change" &&
3915 edit.turnItem.fileName === "a.ts" &&
3916 edit.turnItem.diffStr === patch,
3917 );
3918
3919 yield* fake.emit({
3920 type: "tool_execution_start",
3921 toolCallId: "call_write",
3922 toolName: "write",
3923 args: { path: "b.ts", content: "export {};\n" },
3924 });
3925 yield* fake.emit({
3926 type: "tool_execution_end",
3927 toolCallId: "call_write",
3928 toolName: "write",
3929 isError: false,
3930 result: { content: [{ type: "text", text: "Successfully wrote to b.ts" }] },
3931 });
3932 const write = yield* takeEvent(
3933 (event) =>
3934 event.type === "turn_item.updated" &&
3935 event.turnItem.type === "file_change" &&
3936 event.turnItem.status === "completed",
3937 );
3938 assert.isTrue(
3939 write.type === "turn_item.updated" &&
3940 write.turnItem.type === "file_change" &&
3941 write.turnItem.fileName === "b.ts" &&
3942 write.turnItem.newStr === "export {};\n",
3943 );
3944
3945 yield* fake.emit({
3946 type: "tool_execution_start",
3947 toolCallId: "call_edit_failed",
3948 toolName: "edit",
3949 args: { path: "c.ts", edits: [{ oldText: "missing", newText: "new" }] },
3950 });
3951 yield* fake.emit({
3952 type: "tool_execution_end",
3953 toolCallId: "call_edit_failed",
3954 toolName: "edit",
3955 isError: true,
3956 result: { content: [{ type: "text", text: "Could not find the text in c.ts." }] },
3957 });
3958 const failedEdit = yield* takeEvent(
3959 (event) =>
3960 event.type === "turn_item.updated" &&
3961 event.turnItem.type === "file_change" &&
3962 event.turnItem.status === "failed",
3963 );
3964 assert.isTrue(
3965 failedEdit.type === "turn_item.updated" &&
3966 failedEdit.turnItem.type === "file_change" &&
3967 failedEdit.turnItem.diffStr === "Could not find the text in c.ts.",
3968 );
3969 }).pipe(Effect.scoped, Effect.provide(layerTest)),
3970 );
3971
3972 it.effect.each([false, true])("follows an extension rewind with summarize=%s", (summarize) =>
3973 Effect.gen(function* () {
3974 const fake = yield* makeFakePi;
3975 const { runtime, takeEvent } = yield* openRuntime(fake);
3976 const root = { type: "model_change", id: "root", parentId: null };
3977 const user = (id: string, parentId: string) => ({
3978 type: "message",
3979 id,
3980 parentId,
3981 message: { role: "user", content: [{ type: "text", text: id }] },
3982 });
3983 const reply = (id: string, parentId: string) => ({
3984 type: "message",
3985 id,
3986 parentId,
3987 message: { role: "assistant", content: [] },
3988 });
3989 fake.queueEntries({ entries: [root], leafId: "root" });
3990 const providerThread = yield* runtime.ensureThread({
3991 threadId: THREAD_ID,
3992 modelSelection: modelSelection("default"),
3993 runtimePolicy,
3994 });
3995 const settle = Effect.fnUntraced(function* (
3996 text: string,
3997 runOrdinal: number,
3998 ...listings: ReadonlyArray<unknown>
3999 ) {
4000 yield* startTurn(runtime, providerThread, "default", [], text, undefined, runOrdinal);
4001 yield* fake.takeRequest("prompt");
4002 for (const listing of listings) fake.queueEntries(listing);
4003 yield* fake.emit({ type: "response", command: "prompt", success: true });
4004 if (!text.startsWith("/")) {
4005 yield* fake.emit({ type: "agent_start" });
4006 yield* fake.emit({ type: "agent_settled" });
4007 }
4008 const turn = yield* takeEvent(
4009 (event) =>
4010 event.type === "provider_turn.updated" && event.providerTurn.status === "completed",
4011 );
4012 const thread = yield* takeEvent(
4013 (event) =>
4014 event.type === "provider_thread.updated" && event.providerThread.status === "idle",
4015 );
4016 yield* takeEvent((event) => event.type === "turn.terminal");
4017 return {
4018 turnRef:
4019 turn.type === "provider_turn.updated" ? turn.providerTurn.nativeTurnRef : undefined,
4020 head:
4021 thread.type === "provider_thread.updated"
4022 ? thread.providerThread.nativeConversationHeadRef?.nativeId
4023 : undefined,
4024 retained:
4025 thread.type === "provider_thread.updated" ? thread.retainedNativeTurnIds : undefined,
4026 };
4027 });
4028
4029 yield* settle("prompt A", 1, {
4030 entries: [user("uA", "root"), reply("aA", "uA")],
4031 leafId: "aA",
4032 });
4033 const promptB = yield* settle("prompt B", 2, {
4034 entries: [user("uB", "aA"), reply("aB", "uB")],
4035 leafId: "aB",
4036 });
4037 assert.equal(promptB.turnRef?.nativeId, "uB");
4038 assert.isUndefined(promptB.retained);
4039
4040 const rewoundLeaf = summarize ? "summary" : "aA";
4041 const summary = summarize ? [{ type: "branch_summary", id: "summary", parentId: "aA" }] : [];
4042 const rewind = yield* settle(
4043 "/rewind",
4044 3,
4045 { entries: summary, leafId: rewoundLeaf },
4046 {
4047 entries: [
4048 root,
4049 user("uA", "root"),
4050 reply("aA", "uA"),
4051 user("uB", "aA"),
4052 reply("aB", "uB"),
4053 ...summary,
4054 ],
4055 leafId: rewoundLeaf,
4056 },
4057 );
4058 assert.deepEqual(rewind.retained, ["uA"]);
4059 assert.equal(rewind.head, rewoundLeaf);
4060 if (summarize) {
4061 assert.equal(rewind.turnRef?.strength, "weak");
4062 } else {
4063 assert.isNull(rewind.turnRef);
4064 }
4065
4066 const promptC = yield* settle("prompt C", 4, {
4067 entries: [
4068 ...(summarize ? [] : [user("uB", "aA"), reply("aB", "uB")]),
4069 user("uC", rewoundLeaf),
4070 reply("aC", "uC"),
4071 ],
4072 leafId: "aC",
4073 });
4074 assert.deepEqual(promptC.turnRef, {
4075 driver: PI_PROVIDER,
4076 nativeId: "uC",
4077 strength: "strong",
4078 });
4079 assert.isUndefined(promptC.retained);
4080 }).pipe(Effect.scoped, Effect.provide(layerTest)),
4081 );
4082
4083 it.effect.each([
4084 { change: { model: "openai/model-b", thinking: "minimal" }, setModels: 2 },
4085 { change: { thinking: "minimal" }, setModels: 1 },
4086 ])(
4087 "reapplies the selection after an extension changes it natively (%o)",
4088 ({ change, setModels }) =>
4089 Effect.gen(function* () {
4090 const fake = yield* makeFakePi;
4091 const { runtime, takeEvent } = yield* openRuntime(fake);
4092 const selection: ModelSelection = {
4093 instanceId: PI_INSTANCE_ID,
4094 model: "anthropic/model-a",
4095 options: [{ id: "thinking", value: "high" }],
4096 };
4097 const providerThread = yield* runtime.ensureThread({
4098 threadId: THREAD_ID,
4099 modelSelection: selection,
4100 runtimePolicy,
4101 });
4102 yield* startTurn(
4103 runtime,
4104 providerThread,
4105 "anthropic/model-a",
4106 [],
4107 "/preset fast",
4108 selection,
4109 );
4110 yield* fake.takeRequest("prompt");
4111 yield* fake.emit({ type: "agent_start" });
4112 fake.changeNatively(change);
4113 yield* fake.emit({ type: "agent_settled" });
4114 yield* takeEvent((event) => event.type === "turn.terminal");
4115
4116 yield* startTurn(runtime, providerThread, "anthropic/model-a", [], "Next", selection, 2);
4117 yield* fake.takeRequest("prompt");
4118 assert.deepEqual(fake.promptModels, ["anthropic/model-a", "anthropic/model-a"]);
4119 assert.deepEqual(fake.promptThinkingLevels, ["high", "high"]);
4120 assert.equal(
4121 fake.allRequests().filter((request) => request["type"] === "set_model").length,
4122 setModels,
4123 );
4124 }).pipe(Effect.scoped, Effect.provide(layerTest)),
4125 );
4126
4127 it.effect("records the model Pi reports on the completed provider turn", () =>
4128 Effect.gen(function* () {
4129 const fake = yield* makeFakePi;
4130 const { runtime, takeEvent } = yield* openRuntime(fake);
4131 const providerThread = yield* runtime.ensureThread({
4132 threadId: THREAD_ID,
4133 modelSelection: modelSelection("default"),
4134 runtimePolicy,
4135 });
4136 yield* startTurn(runtime, providerThread);
4137 yield* fake.takeRequest("prompt");
4138 yield* fake.emit({ type: "response", command: "prompt", success: true });
4139 yield* fake.emit({ type: "agent_start" });
4140 yield* fake.emit({
4141 type: "message_end",
4142 message: {
4143 role: "assistant",
4144 provider: "anthropic",
4145 model: "model-b",
4146 content: [{ type: "text", text: "done" }],
4147 stopReason: "stop",
4148 },
4149 });
4150 yield* fake.emit({ type: "agent_settled" });
4151 const turn = yield* takeEvent(
4152 (event) =>
4153 event.type === "provider_turn.updated" && event.providerTurn.status === "completed",
4154 );
4155 assert.equal(
4156 turn.type === "provider_turn.updated" ? turn.providerTurn.model : null,
4157 "anthropic/model-b",
4158 );
4159 }).pipe(Effect.scoped, Effect.provide(layerTest)),
4160 );
4161
4162 it.effect.each(["turn window", "full tree"] as const)(
4163 "finishes a turn whose %s has a parentId cycle",
4164 (cycleIn) =>
4165 Effect.gen(function* () {
4166 const fake = yield* makeFakePi;
4167 const { runtime, takeEvent } = yield* openRuntime(fake);
4168 const root = { type: "model_change", id: "root", parentId: null };
4169 const cycle = [
4170 { type: "message", id: "x", parentId: "y", message: { role: "user", content: [] } },
4171 { type: "message", id: "y", parentId: "x", message: { role: "assistant", content: [] } },
4172 ];
4173 fake.queueEntries({ entries: [root], leafId: "root" });
4174 const providerThread = yield* runtime.ensureThread({
4175 threadId: THREAD_ID,
4176 modelSelection: modelSelection("default"),
4177 runtimePolicy,
4178 });
4179 yield* startTurn(runtime, providerThread, "default", [], "prompt", undefined, 1);
4180 yield* fake.takeRequest("prompt");
4181 if (cycleIn === "turn window") {
4182 fake.queueEntries({ entries: cycle, leafId: "x" });
4183 } else {
4184 fake.queueEntries({ entries: [], leafId: "x" });
4185 fake.queueEntries({ entries: [root, ...cycle], leafId: "x" });
4186 }
4187 yield* fake.emit({ type: "response", command: "prompt", success: true });
4188 yield* fake.emit({ type: "agent_start" });
4189 yield* fake.emit({ type: "agent_settled" });
4190 yield* takeEvent(
4191 (event) =>
4192 event.type === "provider_turn.updated" && event.providerTurn.status === "completed",
4193 );
4194 const thread = yield* takeEvent(
4195 (event) =>
4196 event.type === "provider_thread.updated" && event.providerThread.status === "idle",
4197 );
4198 assert.isUndefined(
4199 thread.type === "provider_thread.updated" ? thread.retainedNativeTurnIds : null,
4200 );
4201 }).pipe(Effect.scoped, Effect.provide(layerTest)),
4202 );
4203
4204 it.effect.each(["missing parent", "invalid parent", "duplicate id"] as const)(
4205 "does not reconcile malformed session entries: %s",
4206 (malformed) =>
4207 Effect.gen(function* () {
4208 const fake = yield* makeFakePi;
4209 const { runtime, takeEvent } = yield* openRuntime(fake);
4210 const root = { type: "model_change", id: "root", parentId: null };
4211 fake.queueEntries({ entries: [root], leafId: "root" });
4212 const providerThread = yield* runtime.ensureThread({
4213 threadId: THREAD_ID,
4214 modelSelection: modelSelection("default"),
4215 runtimePolicy,
4216 });
4217 yield* startTurn(runtime, providerThread);
4218 yield* fake.takeRequest("prompt");
4219 const entry = {
4220 type: "message",
4221 id: "x",
4222 message: { role: "user", content: [] },
4223 ...(malformed === "missing parent"
4224 ? {}
4225 : { parentId: malformed === "invalid parent" ? 42 : null }),
4226 };
4227 fake.queueEntries({ entries: [], leafId: "x" });
4228 fake.queueEntries({
4229 entries: [
4230 root,
4231 entry,
4232 ...(malformed === "duplicate id" ? [{ ...entry, parentId: "root" }] : []),
4233 ],
4234 leafId: "x",
4235 });
4236 yield* fake.emit({ type: "response", command: "prompt", success: true });
4237 yield* fake.emit({ type: "agent_start" });
4238 yield* fake.emit({ type: "agent_settled" });
4239 yield* takeEvent(
4240 (event) =>
4241 event.type === "provider_turn.updated" && event.providerTurn.status === "completed",
4242 );
4243 const thread = yield* takeEvent(
4244 (event) =>
4245 event.type === "provider_thread.updated" && event.providerThread.status === "idle",
4246 );
4247 assert.isUndefined(
4248 thread.type === "provider_thread.updated" ? thread.retainedNativeTurnIds : null,
4249 );
4250 yield* takeEvent((event) => event.type === "turn.terminal");
4251 }).pipe(Effect.scoped, Effect.provide(layerTest)),
4252 );
4253
4254 it.effect("does not reconcile a replacement session tree as a native rewind", () =>
4255 Effect.gen(function* () {
4256 const fake = yield* makeFakePi;
4257 fake.queueEntries({
4258 entries: [{ type: "model_change", id: "old-leaf", parentId: null }],
4259 leafId: "old-leaf",
4260 });
4261 const { runtime, takeEvent } = yield* openRuntime(fake);
4262 const providerThread = yield* runtime.ensureThread({
4263 threadId: THREAD_ID,
4264 modelSelection: modelSelection("default"),
4265 runtimePolicy,
4266 });
4267 const finish = Effect.fnUntraced(function* () {
4268 yield* startTurn(runtime, providerThread);
4269 yield* fake.takeRequest("prompt");
4270 yield* fake.emit({ type: "response", command: "prompt", success: true });
4271 yield* fake.emit({ type: "agent_start" });
4272 yield* fake.emit({ type: "agent_settled" });
4273 const update = yield* takeEvent(
4274 (event) =>
4275 event.type === "provider_thread.updated" && event.providerThread.status === "idle",
4276 );
4277 yield* takeEvent((event) => event.type === "turn.terminal");
4278 assert.isUndefined(
4279 update.type === "provider_thread.updated" ? update.retainedNativeTurnIds : null,
4280 );
4281 });
4282 fake.queueEntries({ entries: [] });
4283 yield* finish();
4284 fake.queueEntries({
4285 entries: [
4286 {
4287 type: "message",
4288 id: "new-user",
4289 parentId: null,
4290 message: { role: "user", content: [] },
4291 },
4292 ],
4293 leafId: "new-user",
4294 });
4295 yield* finish();
4296 }).pipe(Effect.scoped, Effect.provide(layerTest)),
4297 );
4298
4299 it.effect("rolls back past turns that left nothing in the session tree", () =>
4300 Effect.gen(function* () {
4301 const fake = yield* makeFakePi;
4302 const { runtime } = yield* openRuntime(fake);
4303 const providerThread = yield* runtime.ensureThread({
4304 threadId: THREAD_ID,
4305 modelSelection: modelSelection("default"),
4306 runtimePolicy,
4307 });
4308 const turn = (ordinal: number, entryId: string | null): OrchestrationV2ProviderTurn => ({
4309 id: ProviderTurnId.make(`turn-${ordinal}`),
4310 providerThreadId: providerThread.id,
4311 nodeId: NodeId.make(`node-${ordinal}`),
4312 runAttemptId: null,
4313 nativeTurnRef:
4314 entryId === null ? null : { driver: PI_PROVIDER, nativeId: entryId, strength: "strong" },
4315 ordinal,
4316 status: "completed",
4317 startedAt: null,
4318 completedAt: null,
4319 });
4320 const rollBackToFirst = (turns: ReadonlyArray<OrchestrationV2ProviderTurn>) =>
4321 runtime.rollbackThread({
4322 providerThread,
4323 target: {
4324 type: "provider_turn",
4325 checkpointId: CheckpointId.make("checkpoint-1"),
4326 appRunOrdinal: 1,
4327 providerTurn: turns[0]!,
4328 },
4329 providerThreadTurns: turns,
4330 });
4331 const forkedEntries = () =>
4332 fake
4333 .allRequests()
4334 .filter((request) => request.type === "fork")
4335 .map((request) => request.entryId);
4336
4337 yield* rollBackToFirst([turn(1, "u1"), turn(2, null)]);
4338 assert.deepEqual(forkedEntries(), []);
4339 yield* rollBackToFirst([turn(1, "u1"), turn(2, null), turn(3, "u3")]);
4340 assert.deepEqual(forkedEntries(), ["u3"]);
4341 }).pipe(Effect.scoped, Effect.provide(layerTest)),
4342 );
4343
4344 it.effect("rolls back past a turn whose start entry was never captured", () =>
4345 Effect.gen(function* () {
4346 const fake = yield* makeFakePi;
4347 const { runtime } = yield* openRuntime(fake);
4348 const providerThread = yield* runtime.ensureThread({
4349 threadId: THREAD_ID,
4350 modelSelection: modelSelection("default"),
4351 runtimePolicy,
4352 });
4353 const rollBackToFirst = (turns: ReadonlyArray<OrchestrationV2ProviderTurn>) =>
4354 runtime.rollbackThread({
4355 providerThread,
4356 target: {
4357 type: "provider_turn",
4358 checkpointId: CheckpointId.make("checkpoint-1"),
4359 appRunOrdinal: 1,
4360 providerTurn: turns[0]!,
4361 },
4362 providerThreadTurns: turns,
4363 });
4364 const forkedEntries = () =>
4365 fake
4366 .allRequests()
4367 .filter((request) => request.type === "fork")
4368 .map((request) => request.entryId);
4369
4370 fake.queueEntries(UNCAPTURED_TURN_TREE);
4371 const unresolved = yield* rollBackToFirst(
4372 uncapturedTurns(providerThread.id, { startedAt: 60, completedAt: 100 }),
4373 ).pipe(Effect.result);
4374 assert.deepEqual(forkedEntries(), []);
4375 assert.equal(unresolved._tag, "Failure");
4376
4377 fake.queueEntries({ entries: TURN_ONE_ENTRIES, leafId: "a1b" });
4378 const missing = yield* rollBackToFirst(uncapturedTurns(providerThread.id)).pipe(
4379 Effect.result,
4380 );
4381 assert.deepEqual(forkedEntries(), []);
4382 assert.equal(missing._tag, "Failure");
4383
4384 // An adopted wake precedes its T3 turn, but follows turn 1 and its steer.
4385 fake.queueEntries(UNCAPTURED_TURN_TREE);
4386 yield* rollBackToFirst(uncapturedTurns(providerThread.id));
4387 assert.deepEqual(forkedEntries(), ["u2"]);
4388 }).pipe(Effect.scoped, Effect.provide(layerTest)),
4389 );
4390
4391 it.effect("preserves inherited history when rolling back an uncaptured first turn", () =>
4392 Effect.gen(function* () {
4393 const fake = yield* makeFakePi;
4394 const { runtime } = yield* openRuntime(fake);
4395 const providerThread = yield* runtime.ensureThread({
4396 threadId: THREAD_ID,
4397 modelSelection: modelSelection("default"),
4398 runtimePolicy,
4399 });
4400 const rollBackToStart = (startedAt: number) =>
4401 runtime.rollbackThread({
4402 providerThread: { ...providerThread, createdAt: at(50) },
4403 target: {
4404 type: "thread_start",
4405 checkpointId: CheckpointId.make("checkpoint-start"),
4406 appRunOrdinal: 0,
4407 },
4408 providerThreadTurns: [
4409 {
4410 ...uncapturedTurns(providerThread.id)[1]!,
4411 ordinal: 1,
4412 startedAt: at(startedAt),
4413 },
4414 ],
4415 });
4416 const forkedEntries = () =>
4417 fake
4418 .allRequests()
4419 .filter((request) => request.type === "fork")
4420 .map((request) => request.entryId);
4421
4422 const entries = {
4423 entries: [
4424 ...TURN_ONE_ENTRIES,
4425 sessionMessage("u2", "a1b", "user", 100),
4426 sessionMessage("a2", "u2", "assistant", 120),
4427 sessionMessage("u3", "a2", "user", 160),
4428 sessionMessage("a3", "u3", "assistant", 180),
4429 ],
4430 leafId: "a3",
4431 };
4432
4433 // The adopted wake precedes T3's first turn; its steer must be discarded with it.
4434 fake.queueEntries(entries);
4435 yield* rollBackToStart(150);
4436 assert.deepEqual(forkedEntries(), ["u2"]);
4437
4438 fake.queueEntries(entries);
4439 yield* rollBackToStart(100);
4440 assert.deepEqual(forkedEntries(), ["u2", "u2"]);
4441 }).pipe(Effect.scoped, Effect.provide(layerTest)),
4442 );
4443
4444 it.effect("rolls back a persisted thread on a fresh runtime after its session was released", () =>
4445 Effect.gen(function* () {
4446 const previousFake = yield* makeFakePi;
4447 const { runtime: previousRuntime } = yield* openRuntime(previousFake);
4448 const providerThread = yield* previousRuntime.ensureThread({
4449 threadId: THREAD_ID,
4450 modelSelection: modelSelection("default"),
4451 runtimePolicy,
4452 });
4453 const sessionFile = providerThread.nativeThreadRef?.nativeId;
4454 assert.isDefined(sessionFile);
4455 const turn = (ordinal: number, entryId: string): OrchestrationV2ProviderTurn => ({
4456 id: ProviderTurnId.make(`turn-${ordinal}`),
4457 providerThreadId: providerThread.id,
4458 nodeId: NodeId.make(`node-${ordinal}`),
4459 runAttemptId: null,
4460 nativeTurnRef: { driver: PI_PROVIDER, nativeId: entryId, strength: "strong" },
4461 ordinal,
4462 status: "completed",
4463 startedAt: null,
4464 completedAt: null,
4465 });
4466 const turns = [turn(1, "u1"), turn(2, "u2")];
4467
4468 // Rollback opens the session the way CheckpointRollbackService does, without resumeThread.
4469 const fake = yield* makeFakePi;
4470 const adapter = yield* makeAdapter(fake);
4471 const runtime = yield* adapter.openSession({
4472 threadId: THREAD_ID,
4473 providerSessionId: SESSION_ID,
4474 modelSelection: modelSelection("default"),
4475 runtimePolicy,
4476 initialNativeThreadId: sessionFile!,
4477 });
4478 yield* runtime.events.pipe(Stream.runDrain, Effect.forkScoped);
4479 fake.queueState({ sessionFile: sessionFile! });
4480 fake.queueState({ sessionFile: "/fake/rolled-back-session.jsonl" });
4481 const result = yield* runtime
4482 .rollbackThread({
4483 providerThread,
4484 target: {
4485 type: "provider_turn",
4486 checkpointId: CheckpointId.make("checkpoint-1"),
4487 appRunOrdinal: 1,
4488 providerTurn: turns[0]!,
4489 },
4490 providerThreadTurns: turns,
4491 })
4492 .pipe(Effect.result);
4493
4494 assert.equal(
4495 result._tag,
4496 "Success",
4497 `rollback on a fresh Pi runtime failed: ${result._tag === "Failure" ? String(result.failure.cause) : ""}`,
4498 );
4499 const args = fake.lastSpawn().args;
4500 assert.equal(args[args.indexOf("--session") + 1], sessionFile);
4501 const requests = fake.allRequests();
4502 assert.isFalse(requests.some((request) => request.type === "switch_session"));
4503 assert.equal(requests.find((request) => request.type === "fork")?.entryId, "u2");
4504 if (result._tag !== "Success") return;
4505 assert.equal(
4506 result.success.providerThread.nativeThreadRef?.nativeId,
4507 "/fake/rolled-back-session.jsonl",
4508 );
4509 }).pipe(Effect.scoped, Effect.provide(layerTest)),
4510 );
4511
4512 it.effect.each([
4513 { first: "initial", accepted: true },
4514 { first: "steer", accepted: true },
4515 { first: "steer", accepted: false },
4516 ])(
4517 "waits for consumed input acknowledgments, first=$first accepted=$accepted",
4518 ({ first, accepted }) =>
4519 Effect.gen(function* () {
4520 const fake = yield* makeFakePi;
4521 const { runtime, takeEvent } = yield* openRuntime(fake);
4522 const providerThread = yield* runtime.ensureThread({
4523 threadId: THREAD_ID,
4524 modelSelection: modelSelection("default"),
4525 runtimePolicy,
4526 });
4527 fake.deferNextLifecycle("prompt");
4528 yield* startTurn(runtime, providerThread);
4529 const initial = yield* fake.takeRequest("prompt");
4530 fake.deferNextLifecycle("prompt");
4531 const running = yield* takeEvent((event) => event.type === "provider_turn.updated");
4532 assert.isTrue(running.type === "provider_turn.updated");
4533 if (running.type !== "provider_turn.updated") return;
4534 yield* runtime.steerTurn({
4535 threadId: THREAD_ID,
4536 runId: RunId.make("run:thread-pi-test:1"),
4537 providerThread,
4538 providerTurnId: running.providerTurn.id,
4539 message: {
4540 messageId: "message:handled-steer-first" as never,
4541 text: "Consumed steer",
4542 attachments: [],
4543 createdBy: "user",
4544 creationSource: "web",
4545 },
4546 });
4547 const steer = yield* fake.takeRequest("prompt");
4548 const stateRequests = fake
4549 .allRequests()
4550 .filter((request) => request["type"] === "get_state").length;
4551 yield* fake.emit({
4552 type: "response",
4553 id: (first === "steer" ? steer : initial)["id"],
4554 command: "prompt",
4555 success: accepted,
4556 data: { disposition: "handled" },
4557 error: accepted ? undefined : "Input refused",
4558 });
4559 yield* fake.emit({
4560 type: "extension_ui_request",
4561 method: "notify",
4562 message: "Steer acknowledged",
4563 });
4564 yield* takeEvent(
4565 (event) => event.type === "turn_item.updated" && event.turnItem.type === "system_notice",
4566 );
4567 assert.equal(runtime.providerSession.status, "running");
4568 assert.equal(
4569 fake.allRequests().filter((request) => request["type"] === "get_state").length,
4570 stateRequests,
4571 );
4572 yield* fake.emit({
4573 type: "response",
4574 id: (first === "steer" ? initial : steer)["id"],
4575 command: "prompt",
4576 success: true,
4577 data: { disposition: "handled" },
4578 });
4579 const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
4580 assert.isTrue(terminal.type === "turn.terminal" && terminal.status === "completed");
4581 }).pipe(Effect.scoped, Effect.provide(layerTest)),
4582 );
4583
4584 it.effect.each([
4585 { text: "/command-only", data: undefined, compacts: false },
4586 { text: "Plain handled input", data: { disposition: "handled" }, compacts: false },
4587 { text: "Handled input after compaction", data: { disposition: "handled" }, compacts: true },
4588 ])("settles consumed input after its ack: $text", ({ text, data, compacts }) =>
4589 Effect.gen(function* () {
4590 const fake = yield* makeFakePi;
4591 const { runtime, takeEvent } = yield* openRuntime(fake);
4592 const providerThread = yield* runtime.ensureThread({
4593 threadId: THREAD_ID,
4594 modelSelection: modelSelection("default"),
4595 runtimePolicy,
4596 });
4597 if (compacts) yield* fake.takeRequest("get_state");
4598 fake.deferNextLifecycle("prompt");
4599 yield* startTurn(runtime, providerThread, "default", [], text);
4600 yield* fake.takeRequest("prompt");
4601 if (compacts) {
4602 yield* fake.emit({ type: "compaction_start", reason: "manual" });
4603 yield* fake.emit({
4604 type: "compaction_end",
4605 reason: "manual",
4606 result: { summary: "Smaller context", tokensBefore: 1000, estimatedTokensAfter: 100 },
4607 aborted: false,
4608 willRetry: false,
4609 });
4610 yield* takeEvent(
4611 (event) =>
4612 event.type === "turn_item.updated" &&
4613 event.turnItem.type === "compaction" &&
4614 event.turnItem.status === "completed",
4615 );
4616 yield* fake.takeRequest("get_state");
4617 }
4618 for (const notifyType of ["info", "warning", "error", undefined, "unknown"] as const) {
4619 yield* fake.emit({
4620 type: "extension_ui_request",
4621 id: "ui-cmd",
4622 method: "notify",
4623 message: "Command finished\nwith details",
4624 ...(notifyType === undefined ? {} : { notifyType }),
4625 });
4626 const notice = yield* takeEvent(
4627 (event) =>
4628 (event.type === "turn_item.updated" && event.turnItem.type === "system_notice") ||
4629 event.type === "turn.terminal",
4630 );
4631 assert.isTrue(
4632 notice.type === "turn_item.updated" &&
4633 notice.turnItem.type === "system_notice" &&
4634 notice.turnItem.status === "completed" &&
4635 notice.turnItem.level ===
4636 (notifyType === "warning" || notifyType === "error" ? notifyType : "info") &&
4637 notice.turnItem.message === "Command finished\nwith details",
4638 );
4639 }
4640 assert.equal(runtime.providerSession.status, "running");
4641 yield* fake.emit({ type: "response", command: "prompt", success: true, data });
4642 const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
4643 assert.isTrue(terminal.type === "turn.terminal" && terminal.status === "completed");
4644 }).pipe(Effect.scoped, Effect.provide(layerTest)),
4645 );
4646
4647 it.effect("leaves /compacted as an ordinary prompt", () =>
4648 Effect.gen(function* () {
4649 const fake = yield* makeFakePi;
4650 const { runtime } = yield* openRuntime(fake);
4651 const providerThread = yield* runtime.ensureThread({
4652 threadId: THREAD_ID,
4653 modelSelection: modelSelection("default"),
4654 runtimePolicy,
4655 });
4656 yield* startTurn(runtime, providerThread, "default", [], "/compacted please");
4657 const prompt = yield* fake.takeRequest("prompt");
4658 assert.equal(prompt["message"], "/compacted please");
4659 assert.isFalse(fake.allRequests().some((request) => request["type"] === "compact"));
4660 }).pipe(Effect.scoped, Effect.provide(layerTest)),
4661 );
4662
4663 // A failed compact can respond before starting or after compaction_start/end.
4664 it.effect.each([
4665 {
4666 name: "fails a compact Pi rejects before starting",
4667 compactionEnd: null,
4668 error: "Nothing to compact (session too small)",
4669 status: "failed",
4670 },
4671 {
4672 name: "fails a compact after compaction starts",
4673 compactionEnd: { aborted: false, errorMessage: "Compaction failed: model request failed" },
4674 error: "model request failed",
4675 status: "failed",
4676 },
4677 {
4678 name: "completes a compact an extension cancelled",
4679 compactionEnd: { aborted: true },
4680 error: "Compaction cancelled",
4681 status: "completed",
4682 },
4683 ])("$name", ({ compactionEnd, error, status }) =>
4684 Effect.gen(function* () {
4685 const fake = yield* makeFakePi;
4686 const { runtime, takeEvent } = yield* openRuntime(fake);
4687 const providerThread = yield* runtime.ensureThread({
4688 threadId: THREAD_ID,
4689 modelSelection: modelSelection("default"),
4690 runtimePolicy,
4691 });
4692 yield* startTurn(runtime, providerThread, "default", [], "/compact");
4693 yield* fake.takeRequest("compact");
4694 if (compactionEnd !== null) {
4695 yield* fake.emit({ type: "compaction_start", reason: "manual" });
4696 yield* fake.emit({
4697 type: "compaction_end",
4698 reason: "manual",
4699 result: null,
4700 ...compactionEnd,
4701 });
4702 }
4703 yield* fake.emit({ type: "response", command: "compact", success: false, error });
4704 const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
4705 assert.deepEqual(
4706 terminal.type === "turn.terminal"
4707 ? { status: terminal.status, failure: terminal.failure?.message }
4708 : null,
4709 { status, failure: status === "failed" ? error : undefined },
4710 );
4711 }).pipe(Effect.scoped, Effect.provide(layerTest)),
4712 );
4713
4714 it.effect("restarts Pi when Stop interrupts a user compact", () =>
4715 Effect.gen(function* () {
4716 const fake = yield* makeFakePi;
4717 const { runtime, takeEvent } = yield* openRuntime(fake);
4718 const providerThread = yield* runtime.ensureThread({
4719 threadId: THREAD_ID,
4720 modelSelection: modelSelection("default"),
4721 runtimePolicy,
4722 });
4723 yield* startTurn(runtime, providerThread, "default", [], "/compact");
4724 yield* fake.takeRequest("compact");
4725 const running = yield* takeEvent(
4726 (event) =>
4727 event.type === "provider_turn.updated" && event.providerTurn.status === "running",
4728 );
4729 const providerTurnId =
4730 running.type === "provider_turn.updated" ? running.providerTurn.id : undefined;
4731 assert.isDefined(providerTurnId);
4732 yield* fake.emit({ type: "compaction_start", reason: "manual" });
4733 yield* takeEvent(
4734 (event) => event.type === "turn_item.updated" && event.turnItem.type === "compaction",
4735 );
4736 yield* runtime.interruptTurn({ providerThread, providerTurnId: providerTurnId! });
4737 assert.isFalse(fake.allRequests().some((request) => request["type"] === "abort"));
4738 yield* fake.closeStdout;
4739 const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
4740 assert.isTrue(terminal.type === "turn.terminal" && terminal.status === "interrupted");
4741 }).pipe(Effect.scoped, Effect.provide(layerTest)),
4742 );
4743
4744 it.effect("steers /compact as RPC compact instead of a prompt", () =>
4745 Effect.gen(function* () {
4746 const fake = yield* makeFakePi;
4747 const { runtime, takeEvent } = yield* openRuntime(fake);
4748 const providerThread = yield* runtime.ensureThread({
4749 threadId: THREAD_ID,
4750 modelSelection: modelSelection("default"),
4751 runtimePolicy,
4752 });
4753 yield* startTurn(runtime, providerThread);
4754 yield* fake.takeRequest("prompt");
4755 const running = yield* takeEvent(
4756 (event) =>
4757 event.type === "provider_turn.updated" && event.providerTurn.status === "running",
4758 );
4759 const providerTurnId =
4760 running.type === "provider_turn.updated" ? running.providerTurn.id : undefined;
4761 yield* fake.emit({ type: "agent_start" });
4762 yield* runtime.steerTurn({
4763 threadId: THREAD_ID,
4764 runId: RunId.make("run:thread-pi-test:1"),
4765 providerThread,
4766 providerTurnId: providerTurnId!,
4767 message: {
4768 messageId: "message:thread-pi-test:steer-compact" as never,
4769 text: "/compact keep the tests",
4770 attachments: [],
4771 createdBy: "user",
4772 creationSource: "web",
4773 },
4774 });
4775 const compact = yield* fake.takeRequest("compact");
4776 assert.equal(compact["customInstructions"], "keep the tests");
4777 assert.isUndefined(compact["streamingBehavior"]);
4778 yield* fake.emit({ type: "compaction_start", reason: "manual" });
4779 yield* takeEvent(
4780 (event) => event.type === "turn_item.updated" && event.turnItem.type === "compaction",
4781 );
4782 fake.queueState({ isStreaming: false, isCompacting: false, pendingMessageCount: 0 });
4783 yield* fake.emit({
4784 type: "compaction_end",
4785 reason: "manual",
4786 result: { summary: "smaller", tokensBefore: 10_000, estimatedTokensAfter: 2_000 },
4787 aborted: false,
4788 willRetry: false,
4789 });
4790 yield* takeEvent(
4791 (event) =>
4792 event.type === "turn_item.updated" &&
4793 event.turnItem.type === "compaction" &&
4794 event.turnItem.status === "completed",
4795 );
4796 yield* fake.emit({ type: "response", command: "compact", success: true });
4797 yield* fake.emit({ type: "agent_settled" });
4798 yield* fake.takeRequest("get_state");
4799 const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
4800 assert.isTrue(terminal.type === "turn.terminal" && terminal.status === "completed");
4801 }).pipe(Effect.scoped, Effect.provide(layerTest)),
4802 );
4803
4804 it.effect.each([
4805 { toolName: "bash", exitCode: 0, legacy: false },
4806 { toolName: "powershell", exitCode: 2, legacy: false },
4807 { toolName: "bash", exitCode: 1, legacy: true },
4808 { toolName: "powershell", exitCode: 0, legacy: true },
4809 ])(
4810 "normalizes $toolName command results, exit=$exitCode legacy=$legacy",
4811 ({ toolName, exitCode, legacy }) =>
4812 Effect.gen(function* () {
4813 const fake = yield* makeFakePi;
4814 const { runtime, takeEvent } = yield* openRuntime(fake);
4815 const providerThread = yield* runtime.ensureThread({
4816 threadId: THREAD_ID,
4817 modelSelection: modelSelection("default"),
4818 runtimePolicy,
4819 });
4820 yield* startTurn(runtime, providerThread);
4821 yield* fake.takeRequest("prompt");
4822 yield* fake.emit({
4823 type: "tool_execution_start",
4824 toolCallId: "shell-call",
4825 toolName,
4826 args: { command: "echo hello" },
4827 });
4828 const running = yield* takeEvent(
4829 (event) =>
4830 event.type === "turn_item.updated" && event.turnItem.type === "command_execution",
4831 );
4832 assert.isTrue(
4833 running.type === "turn_item.updated" &&
4834 running.turnItem.type === "command_execution" &&
4835 running.turnItem.status === "running" &&
4836 running.turnItem.input === "echo hello",
4837 );
4838 // Pi resends the whole output so far every 100 ms; each snapshot item is a stored row.
4839 // Past its limit Pi sends only the tail, with the running total in details.truncation.
4840 for (const [text, totalBytes] of [
4841 ["hel", undefined],
4842 ["hello", undefined],
4843 ["lo\n\u00e9!", 9],
4844 ] as const) {
4845 yield* fake.emit({
4846 type: "tool_execution_update",
4847 toolCallId: "shell-call",
4848 toolName,
4849 partialResult: {
4850 content: [{ type: "text", text }],
4851 ...(totalBytes === undefined ? {} : { details: { truncation: { totalBytes } } }),
4852 },
4853 });
4854 }
4855 yield* fake.emit({
4856 type: "tool_execution_end",
4857 toolCallId: "shell-call",
4858 toolName,
4859 isError: exitCode !== 0,
4860 result: {
4861 content: [{ type: "text", text: "hello" }],
4862 details: { exitCode: legacy ? exitCode : 99 },
4863 ...(legacy ? {} : { structuredContent: { exit_code: exitCode } }),
4864 },
4865 });
4866 const chunks: Array<string> = [];
4867 let completed: ProviderAdapter.ProviderAdapterV2Event;
4868 while (true) {
4869 completed = yield* takeEvent(
4870 (event) =>
4871 event.type === "command_output.delta" ||
4872 (event.type === "turn_item.updated" && event.turnItem.type === "command_execution"),
4873 );
4874 if (completed.type !== "command_output.delta") break;
4875 chunks.push(completed.chunk);
4876 }
4877 assert.deepStrictEqual(chunks, ["hel", "lo", "\n\u00e9!"]);
4878 assert.isTrue(
4879 completed.type === "turn_item.updated" &&
4880 completed.turnItem.type === "command_execution" &&
4881 completed.turnItem.title === toolName &&
4882 completed.turnItem.input === "echo hello" &&
4883 completed.turnItem.output === "hello" &&
4884 completed.turnItem.exitCode === exitCode &&
4885 completed.turnItem.status === (exitCode === 0 ? "completed" : "failed"),
4886 );
4887 }).pipe(Effect.scoped, Effect.provide(layerTest)),
4888 );
4889
4890 it.effect("emits session-start dialogs before a turn exists", () =>
4891 Effect.gen(function* () {
4892 const fake = yield* makeFakePi;
4893 const { runtime, takeEvent } = yield* openRuntime(fake);
4894 yield* runtime.ensureThread({
4895 threadId: THREAD_ID,
4896 modelSelection: modelSelection("default"),
4897 runtimePolicy,
4898 });
4899 yield* fake.emit({
4900 type: "extension_ui_request",
4901 id: "ui-trust",
4902 method: "confirm",
4903 title: "Run project extensions?",
4904 message: "This project has .pi/extensions.",
4905 });
4906 const pending = yield* takeEvent(
4907 (event) =>
4908 event.type === "runtime_request.updated" && event.runtimeRequest.status === "pending",
4909 );
4910 const requestId =
4911 pending.type === "runtime_request.updated" ? pending.runtimeRequest.id : undefined;
4912 yield* runtime.respondToRuntimeRequest({ requestId: requestId!, decision: "accept" });
4913 const uiResponse = yield* fake.takeRequest("extension_ui_response");
4914 assert.equal(uiResponse["id"], "ui-trust");
4915 assert.equal(uiResponse["confirmed"], true);
4916 }).pipe(Effect.scoped, Effect.provide(layerTest)),
4917 );
4918
4919 it.effect("cancels startup dialogs when Pi exits before a turn exists", () =>
4920 Effect.gen(function* () {
4921 const fake = yield* makeFakePi;
4922 const { runtime, takeEvent } = yield* openRuntime(fake);
4923 yield* runtime.ensureThread({
4924 threadId: THREAD_ID,
4925 modelSelection: modelSelection("default"),
4926 runtimePolicy,
4927 });
4928 yield* fake.emit({
4929 type: "extension_ui_request",
4930 id: "startup",
4931 method: "confirm",
4932 title: "Trust project?",
4933 });
4934 const pending = yield* takeEvent(
4935 (event) =>
4936 event.type === "runtime_request.updated" && event.runtimeRequest.status === "pending",
4937 );
4938 if (pending.type !== "runtime_request.updated") return;
4939 yield* fake.closeStdout;
4940 const cancelled = yield* takeEvent(
4941 (event) =>
4942 event.type === "runtime_request.updated" &&
4943 event.runtimeRequest.id === pending.runtimeRequest.id &&
4944 event.runtimeRequest.status === "cancelled",
4945 );
4946 assert.isTrue(cancelled.type === "runtime_request.updated");
4947 }).pipe(Effect.scoped, Effect.provide(layerTest)),
4948 );
4949
4950 it.effect("remembers session approvals only for identical confirmation content", () =>
4951 Effect.gen(function* () {
4952 const fake = yield* makeFakePi;
4953 const { runtime, takeEvent } = yield* openRuntime(fake);
4954 yield* runtime.ensureThread({
4955 threadId: THREAD_ID,
4956 modelSelection: modelSelection("default"),
4957 runtimePolicy,
4958 });
4959 yield* fake.emit({
4960 type: "extension_ui_request",
4961 id: "ui-trust",
4962 method: "confirm",
4963 title: "Run project extensions?",
4964 message: "This project has .pi/extensions.",
4965 });
4966 const pending = yield* takeEvent(
4967 (event) =>
4968 event.type === "runtime_request.updated" && event.runtimeRequest.status === "pending",
4969 );
4970 const requestId =
4971 pending.type === "runtime_request.updated" ? pending.runtimeRequest.id : undefined;
4972 yield* runtime.respondToRuntimeRequest({
4973 requestId: requestId!,
4974 decision: "acceptForSession",
4975 });
4976 const uiResponse = yield* fake.takeRequest("extension_ui_response");
4977 assert.equal(uiResponse["id"], "ui-trust");
4978 assert.equal(uiResponse["confirmed"], true);
4979 yield* fake.emit({
4980 type: "extension_ui_request",
4981 id: "ui-trust-again",
4982 method: "confirm",
4983 title: "Run project extensions?",
4984 message: "This project has .pi/extensions.",
4985 });
4986 assert.equal((yield* fake.takeRequest("extension_ui_response"))["id"], "ui-trust-again");
4987 yield* fake.emit({
4988 type: "extension_ui_request",
4989 id: "ui-other",
4990 method: "confirm",
4991 title: "Run project extensions?",
4992 message: "A different project.",
4993 });
4994 const other = yield* takeEvent(
4995 (event) =>
4996 event.type === "runtime_request.updated" && event.runtimeRequest.status === "pending",
4997 );
4998 assert.isTrue(
4999 other.type === "runtime_request.updated" &&
5000 other.runtimeRequest.nativeRequestRef?.nativeId === "ui-other",
Showing first 5,000 of 7,257 lines. View raw