The best way to control Claude Code, Codex and more from any computer or phone
| 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