The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 21, 04:45 UTC
| 1 | import { |
| 2 | EnvironmentId, |
| 3 | MessageId, |
| 4 | NodeId, |
| 5 | ProviderDriverKind, |
| 6 | ProviderSessionId, |
| 7 | ProviderThreadId, |
| 8 | RunId, |
| 9 | RuntimeRequestId, |
| 10 | TurnItemId, |
| 11 | } from "@t3tools/contracts"; |
| 12 | import * as DateTime from "effect/DateTime"; |
| 13 | import { describe, expect, it } from "vite-plus/test"; |
| 14 | |
| 15 | import { presentThreadShell, resolveThreadWorkingStartedAt } from "./models.ts"; |
| 16 | import { v2Projection, v2ThreadShell } from "./orchestrationV2TestFixtures.ts"; |
| 17 | import { deriveLatestThreadRun, deriveThreadRuntime } from "./threadExecution.ts"; |
| 18 | import { isThreadWorking } from "./threadInbox.ts"; |
| 19 | import { derivePendingThreadRequests } from "./threadRequests.ts"; |
| 20 | import { canSnooze, effectiveSnoozed } from "./threadSettled.ts"; |
| 21 | |
| 22 | const environmentId = EnvironmentId.make("environment-v2"); |
| 23 | |
| 24 | describe("V2 client presentation", () => { |
| 25 | it("an async question allows snooze and wakes an older snooze", () => { |
| 26 | const runId = RunId.make("run-async-question"); |
| 27 | const running = { |
| 28 | ...v2ThreadShell, |
| 29 | snoozedAt: DateTime.makeUnsafe("2026-06-19T23:59:00.000Z"), |
| 30 | snoozedUntil: DateTime.makeUnsafe("2026-06-20T01:00:00.000Z"), |
| 31 | latestRunId: runId, |
| 32 | activeRunId: runId, |
| 33 | status: "running" as const, |
| 34 | pendingRuntimeRequest: { |
| 35 | id: RuntimeRequestId.make("request-async-question"), |
| 36 | kind: "user_input" as const, |
| 37 | createdAt: v2ThreadShell.updatedAt, |
| 38 | blocking: false, |
| 39 | }, |
| 40 | }; |
| 41 | const active = presentThreadShell(environmentId, running); |
| 42 | expect(active.hasPendingUserInput).toBe(true); |
| 43 | expect(isThreadWorking(active)).toBe(false); |
| 44 | expect(canSnooze(active, { now: "2026-06-20T00:05:00.000Z" })).toBe(true); |
| 45 | |
| 46 | const completed = presentThreadShell(environmentId, { |
| 47 | ...running, |
| 48 | activeRunId: null, |
| 49 | status: "completed", |
| 50 | }); |
| 51 | expect(completed.hasPendingUserInput).toBe(true); |
| 52 | expect(isThreadWorking(completed)).toBe(false); |
| 53 | expect(effectiveSnoozed(active, { now: "2026-06-20T00:05:00.000Z" })).toBe(false); |
| 54 | }); |
| 55 | |
| 56 | it("moves a running thread with any question out of Working", () => { |
| 57 | for (const capability of [{ blocking: false }, { blocking: true }, {}]) { |
| 58 | const shell = presentThreadShell(environmentId, { |
| 59 | ...v2ThreadShell, |
| 60 | latestRunId: RunId.make("run-blocking-question"), |
| 61 | activeRunId: RunId.make("run-blocking-question"), |
| 62 | status: "running", |
| 63 | pendingRuntimeRequest: { |
| 64 | id: RuntimeRequestId.make("request-blocking-question"), |
| 65 | kind: "user_input", |
| 66 | createdAt: v2ThreadShell.updatedAt, |
| 67 | ...capability, |
| 68 | }, |
| 69 | }); |
| 70 | expect(shell.hasPendingUserInput).toBe(true); |
| 71 | expect(isThreadWorking(shell)).toBe(false); |
| 72 | } |
| 73 | }); |
| 74 | |
| 75 | it("parks a thread that never ran at idle while a pull request watch holds it", () => { |
| 76 | const watch = { |
| 77 | taskId: "pull-request-watch:github.com/acme/app#1", |
| 78 | kind: "monitor" as const, |
| 79 | awaited: true as const, |
| 80 | }; |
| 81 | const watched = presentThreadShell(environmentId, { |
| 82 | ...v2ThreadShell, |
| 83 | latestRunId: null, |
| 84 | activeProviderThreadId: null, |
| 85 | activeRunId: null, |
| 86 | status: "idle", |
| 87 | pendingBackgroundTasks: [watch], |
| 88 | }); |
| 89 | expect(watched.runtime).toMatchObject({ status: "idle", activeRunId: null }); |
| 90 | expect( |
| 91 | presentThreadShell(environmentId, { |
| 92 | ...v2ThreadShell, |
| 93 | latestRunId: null, |
| 94 | activeProviderThreadId: null, |
| 95 | status: "idle", |
| 96 | pendingBackgroundTasks: [], |
| 97 | }).runtime, |
| 98 | ).toBeNull(); |
| 99 | }); |
| 100 | |
| 101 | it("keeps an imported thread that never ran out of Working", () => { |
| 102 | const imported = presentThreadShell(environmentId, { |
| 103 | ...v2ThreadShell, |
| 104 | historyOrigin: "v1_import", |
| 105 | activeProviderThreadId: ProviderThreadId.make("provider-thread-imported"), |
| 106 | latestRunId: null, |
| 107 | activeRunId: null, |
| 108 | status: "idle", |
| 109 | pendingBackgroundTasks: [], |
| 110 | }); |
| 111 | expect(isThreadWorking(imported)).toBe(false); |
| 112 | }); |
| 113 | |
| 114 | it.each([ |
| 115 | { kinds: ["command"], expected: "completed" }, |
| 116 | { kinds: ["command", "subagent"], expected: "idle" }, |
| 117 | { kinds: ["background_task"], expected: "idle" }, |
| 118 | ] as const)("presents a completed shell with $kinds as $expected", ({ kinds, expected }) => { |
| 119 | const pendingBackgroundTasks = kinds.map((kind, index) => ({ |
| 120 | taskId: `bg-${index}`, |
| 121 | kind, |
| 122 | })); |
| 123 | const shell = presentThreadShell(environmentId, { |
| 124 | ...v2ThreadShell, |
| 125 | latestRunId: RunId.make("run-completed"), |
| 126 | activeRunId: null, |
| 127 | status: "completed", |
| 128 | pendingBackgroundTasks, |
| 129 | }); |
| 130 | |
| 131 | expect(shell.latestRun?.status).toBe("completed"); |
| 132 | expect(shell.runtime).toMatchObject({ status: expected, activeRunId: null }); |
| 133 | expect(shell.pendingBackgroundTasks).toEqual(pendingBackgroundTasks); |
| 134 | }); |
| 135 | |
| 136 | it.each(["running", "waiting"] as const)( |
| 137 | "preserves shell %s while only commands remain in the roster", |
| 138 | (status) => { |
| 139 | const runId = RunId.make("run-command"); |
| 140 | const shell = presentThreadShell(environmentId, { |
| 141 | ...v2ThreadShell, |
| 142 | latestRunId: runId, |
| 143 | activeRunId: runId, |
| 144 | status, |
| 145 | pendingBackgroundTasks: [{ taskId: "dev-server", kind: "command" }], |
| 146 | }); |
| 147 | |
| 148 | expect(shell.latestRun?.status).toBe(status); |
| 149 | expect(shell.runtime).toMatchObject({ status, activeRunId: runId }); |
| 150 | expect(shell.pendingBackgroundTasks).toEqual([{ taskId: "dev-server", kind: "command" }]); |
| 151 | }, |
| 152 | ); |
| 153 | |
| 154 | it("keeps a failed latest run failed while background tasks are still pending", () => { |
| 155 | const shell = presentThreadShell(environmentId, { |
| 156 | ...v2ThreadShell, |
| 157 | latestRunId: RunId.make("run-failed"), |
| 158 | activeRunId: null, |
| 159 | status: "failed", |
| 160 | lastError: "Provider turn failed", |
| 161 | pendingBackgroundTasks: [ |
| 162 | { taskId: "bg-1", description: "Watch build", kind: "monitor", awaited: true }, |
| 163 | ], |
| 164 | }); |
| 165 | |
| 166 | expect(shell.runtime).toMatchObject({ status: "failed", lastError: "Provider turn failed" }); |
| 167 | expect(shell.pendingBackgroundTasks).toHaveLength(1); |
| 168 | }); |
| 169 | |
| 170 | it("keeps an older active run visible over a newer cancelled run", () => { |
| 171 | const activeRunId = RunId.make("run-active"); |
| 172 | const cancelledRunId = RunId.make("run-cancelled"); |
| 173 | const shell = presentThreadShell(environmentId, { |
| 174 | ...v2ThreadShell, |
| 175 | latestRunId: cancelledRunId, |
| 176 | latestRunStartedAt: null, |
| 177 | latestRunCompletedAt: DateTime.makeUnsafe("2026-06-20T01:05:00.000Z"), |
| 178 | activeRunId, |
| 179 | activityRunStatus: "running", |
| 180 | status: "cancelled", |
| 181 | pendingBackgroundTasks: [], |
| 182 | }); |
| 183 | |
| 184 | expect(shell.latestRun).toMatchObject({ runId: cancelledRunId, status: "cancelled" }); |
| 185 | expect(shell.runtime).toMatchObject({ |
| 186 | status: "running", |
| 187 | activeRunId, |
| 188 | }); |
| 189 | }); |
| 190 | |
| 191 | it("keeps a post-settlement background roster ahead of activity status", () => { |
| 192 | const activeRunId = RunId.make("run-active"); |
| 193 | const shell = presentThreadShell(environmentId, { |
| 194 | ...v2ThreadShell, |
| 195 | latestRunId: RunId.make("run-cancelled"), |
| 196 | activeRunId, |
| 197 | activityRunStatus: "running", |
| 198 | status: "cancelled", |
| 199 | pendingBackgroundTasks: [ |
| 200 | { taskId: "bg-activity", description: "background work", kind: "background_task" }, |
| 201 | ], |
| 202 | }); |
| 203 | |
| 204 | expect(shell.runtime).toMatchObject({ status: "idle", activeRunId }); |
| 205 | }); |
| 206 | |
| 207 | it("parks runtime idle over stale shell running when the roster is nonempty", () => { |
| 208 | const runId = RunId.make("run-stale-running"); |
| 209 | const shell = presentThreadShell(environmentId, { |
| 210 | ...v2ThreadShell, |
| 211 | latestRunId: runId, |
| 212 | activeRunId: runId, |
| 213 | status: "running", |
| 214 | pendingBackgroundTasks: [ |
| 215 | { taskId: "bg-1", description: "Watch build", kind: "monitor", awaited: true }, |
| 216 | ], |
| 217 | }); |
| 218 | |
| 219 | expect(shell.latestRun).toMatchObject({ runId, status: "running" }); |
| 220 | expect(shell.runtime).toMatchObject({ |
| 221 | status: "idle", |
| 222 | activeRunId: runId, |
| 223 | }); |
| 224 | expect(shell.pendingBackgroundTasks).toEqual([ |
| 225 | { taskId: "bg-1", description: "Watch build", kind: "monitor", awaited: true }, |
| 226 | ]); |
| 227 | }); |
| 228 | |
| 229 | it("derives execution summaries without wrapping or copying the projection", () => { |
| 230 | const runId = RunId.make("run-1"); |
| 231 | const now = DateTime.makeUnsafe("2026-06-20T01:00:00.000Z"); |
| 232 | const projection = { |
| 233 | ...v2Projection, |
| 234 | runs: [ |
| 235 | { |
| 236 | id: runId, |
| 237 | threadId: v2Projection.thread.id, |
| 238 | ordinal: 1, |
| 239 | providerInstanceId: v2Projection.thread.providerInstanceId, |
| 240 | modelSelection: v2Projection.thread.modelSelection, |
| 241 | providerThreadId: null, |
| 242 | userMessageId: MessageId.make("message-user"), |
| 243 | rootNodeId: null, |
| 244 | activeAttemptId: null, |
| 245 | status: "running" as const, |
| 246 | requestedAt: now, |
| 247 | startedAt: now, |
| 248 | completedAt: null, |
| 249 | checkpointId: null, |
| 250 | contextHandoffId: null, |
| 251 | }, |
| 252 | ], |
| 253 | messages: [ |
| 254 | { |
| 255 | id: MessageId.make("message-user"), |
| 256 | threadId: v2Projection.thread.id, |
| 257 | runId, |
| 258 | nodeId: null, |
| 259 | role: "user" as const, |
| 260 | text: "Hello", |
| 261 | attachments: [], |
| 262 | streaming: false, |
| 263 | createdBy: "user" as const, |
| 264 | creationSource: "web" as const, |
| 265 | createdAt: now, |
| 266 | updatedAt: now, |
| 267 | }, |
| 268 | ], |
| 269 | updatedAt: now, |
| 270 | }; |
| 271 | |
| 272 | expect(deriveLatestThreadRun(projection)).toMatchObject({ |
| 273 | runId, |
| 274 | status: "running", |
| 275 | requestedAt: "2026-06-20T01:00:00.000Z", |
| 276 | assistantMessageId: null, |
| 277 | }); |
| 278 | expect(deriveThreadRuntime(projection)).toMatchObject({ |
| 279 | status: "running", |
| 280 | activeRunId: runId, |
| 281 | providerInstanceId: projection.thread.providerInstanceId, |
| 282 | }); |
| 283 | for (const status of ["queued", "cancelled"] as const) { |
| 284 | const later = DateTime.add(now, { hours: 1 }); |
| 285 | const latest = { |
| 286 | ...projection.runs[0]!, |
| 287 | id: RunId.make("newer-run"), |
| 288 | ordinal: 2, |
| 289 | status, |
| 290 | requestedAt: later, |
| 291 | startedAt: null, |
| 292 | completedAt: status === "cancelled" ? later : null, |
| 293 | }; |
| 294 | const detail = { ...projection, runs: [...projection.runs, latest], updatedAt: later }; |
| 295 | const shell = presentThreadShell(environmentId, { |
| 296 | ...v2ThreadShell, |
| 297 | latestRunId: latest.id, |
| 298 | latestRunStartedAt: null, |
| 299 | latestRunRequestedAt: later, |
| 300 | latestRunCompletedAt: latest.completedAt, |
| 301 | status, |
| 302 | activeRunId: runId, |
| 303 | activityRunStatus: "running", |
| 304 | activityRunStartedAt: now, |
| 305 | updatedAt: later, |
| 306 | }); |
| 307 | expect(resolveThreadWorkingStartedAt(shell)).toBe(DateTime.formatIso(now)); |
| 308 | expect( |
| 309 | resolveThreadWorkingStartedAt({ |
| 310 | latestRun: deriveLatestThreadRun(detail), |
| 311 | runtime: deriveThreadRuntime(detail), |
| 312 | }), |
| 313 | ).toBe(resolveThreadWorkingStartedAt(shell)); |
| 314 | const stopped = { |
| 315 | ...detail, |
| 316 | runs: detail.runs.map((run) => ({ |
| 317 | ...run, |
| 318 | status: "completed" as const, |
| 319 | completedAt: later, |
| 320 | })), |
| 321 | }; |
| 322 | expect( |
| 323 | resolveThreadWorkingStartedAt({ |
| 324 | latestRun: deriveLatestThreadRun(stopped), |
| 325 | runtime: deriveThreadRuntime(stopped), |
| 326 | }), |
| 327 | ).toBeNull(); |
| 328 | } |
| 329 | }); |
| 330 | |
| 331 | it("parks waiting runtime for a post-settlement roster without hiding active running work", () => { |
| 332 | const runId = RunId.make("run-background-presentation"); |
| 333 | const now = DateTime.makeUnsafe("2026-06-20T01:00:00.000Z"); |
| 334 | const run = { |
| 335 | id: runId, |
| 336 | threadId: v2Projection.thread.id, |
| 337 | ordinal: 1, |
| 338 | providerInstanceId: v2Projection.thread.providerInstanceId, |
| 339 | modelSelection: v2Projection.thread.modelSelection, |
| 340 | providerThreadId: null, |
| 341 | userMessageId: MessageId.make("message-background-presentation"), |
| 342 | rootNodeId: null, |
| 343 | activeAttemptId: null, |
| 344 | status: "waiting" as const, |
| 345 | requestedAt: now, |
| 346 | startedAt: now, |
| 347 | completedAt: null, |
| 348 | checkpointId: null, |
| 349 | contextHandoffId: null, |
| 350 | }; |
| 351 | const backgroundItem = { |
| 352 | id: TurnItemId.make("item-background-subagent"), |
| 353 | threadId: v2Projection.thread.id, |
| 354 | runId, |
| 355 | nodeId: null, |
| 356 | providerThreadId: null, |
| 357 | providerTurnId: null, |
| 358 | nativeItemRef: null, |
| 359 | parentItemId: null, |
| 360 | ordinal: 0, |
| 361 | status: "running" as const, |
| 362 | title: "Background review", |
| 363 | startedAt: now, |
| 364 | completedAt: null, |
| 365 | updatedAt: now, |
| 366 | type: "subagent" as const, |
| 367 | subagentId: NodeId.make("subagent-review"), |
| 368 | origin: "provider_native" as const, |
| 369 | driver: ProviderDriverKind.make("codex"), |
| 370 | providerInstanceId: v2Projection.thread.providerInstanceId, |
| 371 | childThreadId: null, |
| 372 | prompt: "Review the changes", |
| 373 | result: null, |
| 374 | }; |
| 375 | |
| 376 | expect( |
| 377 | deriveThreadRuntime({ |
| 378 | ...v2Projection, |
| 379 | runs: [run], |
| 380 | turnItems: [backgroundItem], |
| 381 | }), |
| 382 | ).toMatchObject({ |
| 383 | status: "idle", |
| 384 | activeRunId: null, |
| 385 | }); |
| 386 | expect( |
| 387 | deriveThreadRuntime({ |
| 388 | ...v2Projection, |
| 389 | runs: [{ ...run, status: "running" as const }], |
| 390 | turnItems: [backgroundItem], |
| 391 | }), |
| 392 | ).toMatchObject({ |
| 393 | status: "running", |
| 394 | activeRunId: runId, |
| 395 | }); |
| 396 | expect( |
| 397 | deriveThreadRuntime({ |
| 398 | ...v2Projection, |
| 399 | runs: [{ ...run, status: "failed" as const, completedAt: now }], |
| 400 | turnItems: [backgroundItem], |
| 401 | }), |
| 402 | ).toMatchObject({ status: "failed", activeRunId: null }); |
| 403 | const commandItem = { |
| 404 | ...backgroundItem, |
| 405 | id: TurnItemId.make("item-background-command"), |
| 406 | type: "command_execution" as const, |
| 407 | input: "npm run dev", |
| 408 | }; |
| 409 | expect( |
| 410 | deriveThreadRuntime({ ...v2Projection, runs: [run], turnItems: [commandItem] }), |
| 411 | ).toMatchObject({ status: "waiting", activeRunId: null }); |
| 412 | |
| 413 | for (const [turnItems, status] of [ |
| 414 | [[commandItem], "completed"], |
| 415 | [[backgroundItem], "idle"], |
| 416 | [[commandItem, backgroundItem], "idle"], |
| 417 | ] as const) { |
| 418 | expect( |
| 419 | deriveThreadRuntime({ |
| 420 | ...v2Projection, |
| 421 | runs: [{ ...run, status: "completed", completedAt: now }], |
| 422 | turnItems, |
| 423 | }), |
| 424 | ).toMatchObject({ status, activeRunId: null }); |
| 425 | } |
| 426 | |
| 427 | for (const held of [{ kind: "monitor", awaited: true }, { kind: "background_task" }] as const) { |
| 428 | const providerThread = { |
| 429 | id: ProviderThreadId.make("provider-thread-background"), |
| 430 | driver: ProviderDriverKind.make("claudeCode"), |
| 431 | providerInstanceId: v2Projection.thread.providerInstanceId, |
| 432 | providerSessionId: null, |
| 433 | appThreadId: v2Projection.thread.id, |
| 434 | ownerNodeId: null, |
| 435 | nativeThreadRef: null, |
| 436 | nativeConversationHeadRef: null, |
| 437 | status: "idle" as const, |
| 438 | firstRunOrdinal: 1, |
| 439 | lastRunOrdinal: 1, |
| 440 | handoffIds: [], |
| 441 | forkedFrom: null, |
| 442 | pendingBackgroundTasks: [{ taskId: "background-task", ...held }], |
| 443 | createdAt: now, |
| 444 | updatedAt: now, |
| 445 | }; |
| 446 | for (const status of ["completed", "failed"] as const) { |
| 447 | expect( |
| 448 | deriveThreadRuntime({ |
| 449 | ...v2Projection, |
| 450 | runs: [{ ...run, status, completedAt: now }], |
| 451 | providerThreads: [providerThread], |
| 452 | }), |
| 453 | ).toMatchObject({ status: status === "failed" ? "failed" : "idle", activeRunId: null }); |
| 454 | } |
| 455 | } |
| 456 | }); |
| 457 | |
| 458 | it("joins pending request entities to their native turn-item display data", () => { |
| 459 | const now = DateTime.makeUnsafe("2026-06-20T01:00:00.000Z"); |
| 460 | const requestId = RuntimeRequestId.make("request-approval"); |
| 461 | const item = { |
| 462 | id: TurnItemId.make("item-approval"), |
| 463 | threadId: v2Projection.thread.id, |
| 464 | runId: null, |
| 465 | nodeId: NodeId.make("node-root"), |
| 466 | providerThreadId: null, |
| 467 | providerTurnId: null, |
| 468 | nativeItemRef: null, |
| 469 | parentItemId: null, |
| 470 | ordinal: 0, |
| 471 | status: "completed" as const, |
| 472 | title: null, |
| 473 | startedAt: now, |
| 474 | completedAt: now, |
| 475 | updatedAt: now, |
| 476 | type: "approval_request" as const, |
| 477 | requestId, |
| 478 | requestKind: "command" as const, |
| 479 | prompt: "Allow command?", |
| 480 | }; |
| 481 | const projection = { |
| 482 | ...v2Projection, |
| 483 | runtimeRequests: [ |
| 484 | { |
| 485 | id: requestId, |
| 486 | nodeId: NodeId.make("node-root"), |
| 487 | providerTurnId: null, |
| 488 | nativeRequestRef: null, |
| 489 | kind: "command" as const, |
| 490 | status: "pending" as const, |
| 491 | responseCapability: { |
| 492 | type: "not_resumable" as const, |
| 493 | reason: "provider disconnected", |
| 494 | }, |
| 495 | createdAt: now, |
| 496 | resolvedAt: null, |
| 497 | }, |
| 498 | ], |
| 499 | turnItems: [item], |
| 500 | updatedAt: now, |
| 501 | }; |
| 502 | |
| 503 | expect(derivePendingThreadRequests(projection).approvals).toEqual([ |
| 504 | { |
| 505 | requestId, |
| 506 | requestKind: "command", |
| 507 | createdAt: "2026-06-20T01:00:00.000Z", |
| 508 | detail: "Allow command?", |
| 509 | responseCapability: "not_resumable", |
| 510 | }, |
| 511 | ]); |
| 512 | expect(derivePendingThreadRequests(projection).userInputs).toEqual([]); |
| 513 | }); |
| 514 | |
| 515 | it("preserves structured-question selection mode and defaults legacy payloads", () => { |
| 516 | const now = DateTime.makeUnsafe("2026-06-20T01:00:00.000Z"); |
| 517 | const multiRequestId = RuntimeRequestId.make("request-multi-select"); |
| 518 | const legacyRequestId = RuntimeRequestId.make("request-legacy-single-select"); |
| 519 | const runtimeRequests = [multiRequestId, legacyRequestId].map((id) => ({ |
| 520 | id, |
| 521 | nodeId: NodeId.make(`node-${id}`), |
| 522 | providerTurnId: null, |
| 523 | nativeRequestRef: null, |
| 524 | kind: "user_input" as const, |
| 525 | status: "pending" as const, |
| 526 | responseCapability: { |
| 527 | type: "live" as const, |
| 528 | providerSessionId: ProviderSessionId.make("provider-session-questions"), |
| 529 | }, |
| 530 | createdAt: now, |
| 531 | resolvedAt: null, |
| 532 | })); |
| 533 | const common = { |
| 534 | threadId: v2Projection.thread.id, |
| 535 | runId: null, |
| 536 | providerThreadId: null, |
| 537 | providerTurnId: null, |
| 538 | nativeItemRef: null, |
| 539 | parentItemId: null, |
| 540 | ordinal: 0, |
| 541 | status: "completed" as const, |
| 542 | title: null, |
| 543 | startedAt: now, |
| 544 | completedAt: now, |
| 545 | updatedAt: now, |
| 546 | type: "user_input_request" as const, |
| 547 | }; |
| 548 | const projection = { |
| 549 | ...v2Projection, |
| 550 | runtimeRequests, |
| 551 | turnItems: [ |
| 552 | { |
| 553 | ...common, |
| 554 | id: TurnItemId.make("item-multi-select"), |
| 555 | nodeId: NodeId.make("node-request-multi-select"), |
| 556 | requestId: multiRequestId, |
| 557 | questions: [ |
| 558 | { |
| 559 | id: "regions", |
| 560 | header: "Regions", |
| 561 | question: "Which regions?", |
| 562 | options: [ |
| 563 | { label: "US", description: "United States" }, |
| 564 | { label: "EU", description: "European Union" }, |
| 565 | ], |
| 566 | multiSelect: true, |
| 567 | }, |
| 568 | ], |
| 569 | }, |
| 570 | { |
| 571 | ...common, |
| 572 | id: TurnItemId.make("item-legacy-single-select"), |
| 573 | nodeId: NodeId.make("node-request-legacy-single-select"), |
| 574 | requestId: legacyRequestId, |
| 575 | questions: [ |
| 576 | { |
| 577 | id: "target", |
| 578 | header: "Target", |
| 579 | question: "Which target?", |
| 580 | options: [{ label: "Staging", description: "Staging environment" }], |
| 581 | }, |
| 582 | ], |
| 583 | }, |
| 584 | ], |
| 585 | updatedAt: now, |
| 586 | }; |
| 587 | |
| 588 | expect( |
| 589 | derivePendingThreadRequests(projection).userInputs.map((input) => ({ |
| 590 | requestId: input.requestId, |
| 591 | multiSelect: input.questions[0]?.multiSelect, |
| 592 | })), |
| 593 | ).toEqual([ |
| 594 | { requestId: multiRequestId, multiSelect: true }, |
| 595 | { requestId: legacyRequestId, multiSelect: false }, |
| 596 | ]); |
| 597 | }); |
| 598 | }); |