The best way to control Claude Code, Codex and more from any computer or phone
fix(pi): async pi-subagents workflow, chain and parallel members show as subagents (#36599)
Julius Marminge committed
Nov 14, 2026 at 01:22 UTC
75c544a9788651e885ff82f5c0c50bf4180b7fdb
2 files changed
+319
-63
packages/provider-pi/src/server/adapter.test.ts
+112
@@ -3232,6 +3232,118 @@ describe("PiAdapterV2", () => {
3232
}).pipe(Effect.scoped, Effect.provide(layerTest)),
3233
);
3234
3235
+ it.effect("shows the members of an async pi-subagents workflow as running subagents", () =>
3236
+ Effect.gen(function* () {
3237
+ const fake = yield* makeFakePi;
3238
+ const { runtime, takeEvent } = yield* openRuntime(fake);
3239
+ const providerThread = yield* runtime.ensureThread({
3240
+ threadId: THREAD_ID,
3241
+ modelSelection: modelSelection("default"),
3242
+ runtimePolicy,
3243
+ });
3244
+ yield* startTurn(runtime, providerThread);
3245
+ yield* fake.takeRequest("prompt");
3246
+ yield* fake.emit({ type: "agent_start" });
3247
+ // Frames as pi-subagents 0.88.1 sends them for an async `runs.all([alpha, beta])` workflow.
3248
+ const step = (key: string, state: string) => ({
3249
+ id: key,
3250
+ kind: "step",
3251
+ label: key,
3252
+ state,
3253
+ startedAt: 1_000,
3254
+ updatedAt: 2_000,
3255
+ activity: { currentTool: "bash", turnCount: 1, toolCount: 1 },
3256
+ agent: "scout",
3257
+ model: "anthropic/claude-haiku-5-5",
3258
+ });
3259
+ const emitSnapshot = (state: string, alpha: string, beta: string) =>
3260
+ fake.emit({
3261
+ type: "extension_ui_request",
3262
+ id: `widget-${state}`,
3263
+ method: "setWidget",
3264
+ widgetKey: "subagent-async",
3265
+ widgetLines: [
3266
+ `PI_SUBAGENT_ASYNC_JSON:${JSON.stringify({
3267
+ kind: "pi-subagents.async-status-snapshot",
3268
+ version: 1,
3269
+ generatedAt: 2_000,
3270
+ runs: [
3271
+ {
3272
+ id: "wf-1",
3273
+ kind: "workflow",
3274
+ label: "scout, scout",
3275
+ state,
3276
+ startedAt: 1_000,
3277
+ updatedAt: 2_000,
3278
+ children: [step("alpha", alpha), step("beta", beta)],
3279
+ },
3280
+ ],
3281
+ })}`,
3282
+ ],
3283
+ });
3284
+ const collect = (marker: string) =>
3285
+ Effect.gen(function* () {
3286
+ yield* fake.emit({
3287
+ type: "tool_execution_end",
3288
+ toolCallId: marker,
3289
+ toolName: marker,
3290
+ result: { content: [{ type: "text", text: "after" }] },
3291
+ });
3292
+ const statuses = new Map<string, string>();
3293
+ const pending: Array<boolean> = [];
3294
+ while (true) {
3295
+ const event = yield* takeEvent(
3296
+ (event) =>
3297
+ event.type === "subagent.updated" ||
3298
+ event.type === "background_work.updated" ||
3299
+ (event.type === "turn_item.updated" &&
3300
+ event.turnItem.type === "dynamic_tool" &&
3301
+ event.turnItem.toolName === marker),
3302
+ );
3303
+ if (event.type === "background_work.updated") pending.push(event.pending);
3304
+ else if (event.type === "subagent.updated")
3305
+ statuses.set(event.subagent.id, event.subagent.status);
3306
+ else break;
3307
+ }
3308
+ return { statuses: [...statuses.values()].toSorted(), pending };
3309
+ });
3310
+ // The launch snapshot precedes the tool result that names the run.
3311
+ yield* emitSnapshot("running", "running", "running");
3312
+ yield* fake.emit({
3313
+ type: "tool_execution_end",
3314
+ toolCallId: "call_wf",
3315
+ toolName: "subagent",
3316
+ isError: false,
3317
+ result: {
3318
+ content: [{ type: "text", text: "Async workflow started: wf-1" }],
3319
+ details: {
3320
+ mode: "workflow",
3321
+ runId: "wf-1",
3322
+ asyncId: "wf-1",
3323
+ results: [],
3324
+ workflowChildren: {
3325
+ version: 1,
3326
+ parentToolCallId: "call_wf",
3327
+ workflowRunId: "wf-1",
3328
+ inventoryComplete: false,
3329
+ workflowState: "running",
3330
+ children: [],
3331
+ },
3332
+ },
3333
+ },
3334
+ });
3335
+ assert.deepEqual(yield* collect("marker-1"), {
3336
+ statuses: ["running", "running"],
3337
+ pending: [true],
3338
+ });
3339
+ yield* emitSnapshot("failed", "complete", "failed");
3340
+ assert.deepEqual(yield* collect("marker-2"), {
3341
+ statuses: ["completed", "failed"],
3342
+ pending: [false],
3343
+ });
3344
+ }).pipe(Effect.scoped, Effect.provide(layerTest)),
3345
+ );
3346
+
3347
it.effect("persists edit patches and write content on file change items", () =>
3348
Effect.gen(function* () {
3349
const fake = yield* makeFakePi;
packages/provider-pi/src/server/adapter.ts
+207
-63
@@ -17,6 +17,7 @@ import {
17
type OrchestrationV2ProviderThread,
18
type OrchestrationV2ProviderTurn,
19
type OrchestrationV2RuntimeRequest,
20
+ type OrchestrationV2Subagent,
21
type OrchestrationV2TurnItem,
22
type OrchestrationV2UserInputQuestion,
23
type ProviderApprovalDecision,
@@ -85,6 +86,8 @@ const PI_INHERIT_MODEL_SLUG = "default";
86
87
const STREAM_FLUSH_MS = 50;
88
const PI_REQUEST_TIMEOUT_MS = 15_000;
89
+const PI_SUBAGENT_ASYNC_PREFIX = "PI_SUBAGENT_ASYNC_JSON:";
90
+const decodePiJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown));
91
const PI_SESSION_TIMEOUT_MS = 60_000;
92
const MAX_EXTENSION_STATUSES = 32;
93
const MAX_EXTENSION_STATUS_KEY_LENGTH = 256;
@@ -545,6 +548,17 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
548
>();
549
const pendingPrompts = new Map<string, PendingPiPrompt>();
550
const sessionApprovals = new Set<string>();
551
+ // Async pi-subagents runs launched in this session, by async id, until they settle.
552
+ const piAsyncRuns = new Map<
553
+ string,
554
+ {
555
+ readonly turn: ActivePiTurn;
556
+ readonly toolCallId: string;
557
+ readonly emitted: Map<string, string>;
558
+ }
559
+ >();
560
+ // The launch snapshot arrives before the tool result that names its run.
561
+ let latestAsyncSnapshotRuns: ReadonlyArray<unknown> = [];
562
// Pi can settle immediately after dialog response; serialize so terminal cannot overtake request resolution.
563
const sessionEventPermit = yield* Semaphore.make(1);
564
let threadState: PiThreadState | null = null;
@@ -1333,24 +1347,15 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
1347
resultRecord: unknown,
1348
completed: boolean,
1349
) {
1336
- const results = recordField(recordField(resultRecord, "details"), "results");
1350
+ const details = recordField(resultRecord, "details");
1351
+ const results = recordField(details, "results");
1352
if (!Array.isArray(results)) return;
1338
- const emittedAt = yield* DateTime.now;
1339
- const parentNodeId = idAllocator.derive.nodeFromProviderItem({
1340
- driver: PI_PROVIDER,
1341
- nativeItemId: toolCallId,
1342
- });
1353
+ let emitted = false;
1354
for (const [index, result] of results.entries()) {
1355
const agent = recordString(result, "agent");
1356
const task = recordString(result, "task");
1357
if (agent === undefined || task === undefined) continue;
1347
- const nativeTaskId = `${toolCallId}:subagent:${recordNumber(result, "step") ?? index}`;
1348
- const subagentId = idAllocator.derive.nodeFromProviderItem({
1349
- driver: PI_PROVIDER,
1350
- nativeItemId: nativeTaskId,
1351
- });
1352
- const startedAt = turn.toolStartedAt.get(nativeTaskId) ?? emittedAt;
1353
- turn.toolStartedAt.set(nativeTaskId, startedAt);
1358
+ emitted = true;
1359
const finished = completed || recordField(result, "finished") === true;
1360
const stopReason = recordString(result, "stopReason");
1361
const interrupted = finished && stopReason === "aborted";
@@ -1358,63 +1363,175 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
1363
finished &&
1364
!interrupted &&
1365
((recordNumber(result, "exitCode") ?? 0) !== 0 || stopReason === "error");
1361
- const status = interrupted
1362
- ? "interrupted"
1363
- : failed
1364
- ? "failed"
1365
- : finished
1366
- ? "completed"
1367
- : "running";
1366
const outputText = piSubagentOutput(result);
1369
- const progress =
1370
- !finished && outputText.length > 0 ? { progress: outputText.slice(0, 200) } : {};
1371
- const resultText = finished && outputText.length > 0 ? outputText.slice(0, 10_000) : null;
1367
+ yield* emitSubagent(turn, toolCallId, `${recordNumber(result, "step") ?? index}`, {
1368
+ agent,
1369
+ task,
1370
+ model: recordString(result, "model") ?? null,
1371
+ status: interrupted
1372
+ ? "interrupted"
1373
+ : failed
1374
+ ? "failed"
1375
+ : finished
1376
+ ? "completed"
1377
+ : "running",
1378
+ progress: !finished && outputText.length > 0 ? outputText.slice(0, 200) : undefined,
1379
+ result: finished && outputText.length > 0 ? outputText.slice(0, 10_000) : null,
1380
+ });
1381
+ }
1382
+ // Async launches return no results; their members arrive in the subagent-async widget.
1383
+ const asyncId = recordString(details, "asyncId");
1384
+ if (!emitted && asyncId !== undefined && !piAsyncRuns.has(asyncId)) {
1385
+ const tracked = { turn, toolCallId, emitted: new Map<string, string>() };
1386
+ piAsyncRuns.set(asyncId, tracked);
1387
+ // Keeps the run ingesting after the coordinator's turn ends, until the run settles.
1388
yield* emit({
1373
- type: "subagent.updated",
1389
+ type: "background_work.updated",
1390
driver: PI_PROVIDER,
1375
- subagent: {
1376
- id: subagentId,
1377
- threadId: turn.turnInput.threadId,
1378
- runId: turn.turnInput.runId,
1379
- parentNodeId,
1380
- origin: "provider_native",
1381
- createdBy: "agent",
1382
- driver: PI_PROVIDER,
1383
- providerInstanceId: options.instanceId,
1384
- providerThreadId: turn.turnInput.providerThread.id,
1385
- childThreadId: null,
1386
- nativeTaskRef: providerRef(nativeTaskId),
1387
- prompt: task,
1388
- title: agent,
1389
- model: recordString(result, "model") ?? null,
1390
- status,
1391
- ...progress,
1392
- result: resultText,
1393
- startedAt,
1394
- completedAt: finished ? emittedAt : null,
1395
- updatedAt: emittedAt,
1396
- },
1391
+ providerTurnId: turn.providerTurn.id,
1392
+ pending: true,
1393
});
1398
- yield* emit({
1399
- type: "turn_item.updated",
1394
+ const run = latestAsyncSnapshotRuns.find((run) => recordString(run, "id") === asyncId);
1395
+ if (run !== undefined) yield* updateAsyncRun(asyncId, tracked, run);
1396
+ }
1397
+ });
1398
+
1399
+ const emitSubagent = Effect.fnUntraced(function* (
1400
+ turn: ActivePiTurn,
1401
+ toolCallId: string,
1402
+ taskKey: string,
1403
+ task: {
1404
+ readonly agent: string;
1405
+ readonly task: string;
1406
+ readonly model: string | null;
1407
+ readonly status: OrchestrationV2Subagent["status"];
1408
+ readonly progress?: string | undefined;
1409
+ readonly result: string | null;
1410
+ },
1411
+ ) {
1412
+ const emittedAt = yield* DateTime.now;
1413
+ const parentNodeId = idAllocator.derive.nodeFromProviderItem({
1414
+ driver: PI_PROVIDER,
1415
+ nativeItemId: toolCallId,
1416
+ });
1417
+ const nativeTaskId = `${toolCallId}:subagent:${taskKey}`;
1418
+ const subagentId = idAllocator.derive.nodeFromProviderItem({
1419
+ driver: PI_PROVIDER,
1420
+ nativeItemId: nativeTaskId,
1421
+ });
1422
+ const startedAt = turn.toolStartedAt.get(nativeTaskId) ?? emittedAt;
1423
+ turn.toolStartedAt.set(nativeTaskId, startedAt);
1424
+ const finished =
1425
+ task.status !== "running" && task.status !== "pending" && task.status !== "waiting";
1426
+ const progress = task.progress === undefined ? {} : { progress: task.progress };
1427
+ yield* emit({
1428
+ type: "subagent.updated",
1429
+ driver: PI_PROVIDER,
1430
+ subagent: {
1431
+ id: subagentId,
1432
+ threadId: turn.turnInput.threadId,
1433
+ runId: turn.turnInput.runId,
1434
+ parentNodeId,
1435
+ origin: "provider_native",
1436
+ createdBy: "agent",
1437
driver: PI_PROVIDER,
1401
- turnItem: {
1402
- ...baseItemFields(turn, nativeTaskId, startedAt, emittedAt),
1403
- status,
1404
- title: agent,
1405
- completedAt: finished ? emittedAt : null,
1406
- type: "subagent",
1407
- subagentId,
1408
- origin: "provider_native",
1409
- driver: PI_PROVIDER,
1410
- providerInstanceId: options.instanceId,
1411
- childThreadId: null,
1412
- prompt: task,
1413
- ...progress,
1414
- result: resultText,
1415
- },
1438
+ providerInstanceId: options.instanceId,
1439
+ providerThreadId: turn.turnInput.providerThread.id,
1440
+ childThreadId: null,
1441
+ nativeTaskRef: providerRef(nativeTaskId),
1442
+ prompt: task.task,
1443
+ title: task.agent,
1444
+ model: task.model,
1445
+ status: task.status,
1446
+ ...progress,
1447
+ result: task.result,
1448
+ startedAt,
1449
+ completedAt: finished ? emittedAt : null,
1450
+ updatedAt: emittedAt,
1451
+ },
1452
+ });
1453
+ yield* emit({
1454
+ type: "turn_item.updated",
1455
+ driver: PI_PROVIDER,
1456
+ turnItem: {
1457
+ ...baseItemFields(turn, nativeTaskId, startedAt, emittedAt),
1458
+ status: task.status,
1459
+ title: task.agent,
1460
+ completedAt: finished ? emittedAt : null,
1461
+ type: "subagent",
1462
+ subagentId,
1463
+ origin: "provider_native",
1464
+ driver: PI_PROVIDER,
1465
+ providerInstanceId: options.instanceId,
1466
+ childThreadId: null,
1467
+ prompt: task.task,
1468
+ ...progress,
1469
+ result: task.result,
1470
+ },
1471
+ });
1472
+ });
1473
+
1474
+ const updateAsyncRun = Effect.fnUntraced(function* (
1475
+ runId: string,
1476
+ tracked: {
1477
+ readonly turn: ActivePiTurn;
1478
+ readonly toolCallId: string;
1479
+ readonly emitted: Map<string, string>;
1480
+ },
1481
+ run: unknown,
1482
+ ) {
1483
+ const children = recordField(run, "children");
1484
+ for (const child of Array.isArray(children) ? children : []) {
1485
+ const id = recordString(child, "id");
1486
+ const agent = recordString(child, "agent");
1487
+ const status = piAsyncSubagentStatus(recordString(child, "state"));
1488
+ if (recordString(child, "kind") !== "step" || id === undefined) continue;
1489
+ if (agent === undefined || status === undefined) continue;
1490
+ const model = recordString(child, "model") ?? null;
1491
+ const key = `${status}:${model}`;
1492
+ if (tracked.emitted.get(id) === key) continue;
1493
+ tracked.emitted.set(id, key);
1494
+ yield* emitSubagent(tracked.turn, tracked.toolCallId, id, {
1495
+ agent,
1496
+ task: "",
1497
+ model,
1498
+ status,
1499
+ result: null,
1500
});
1501
}
1502
+ const runStatus = piAsyncSubagentStatus(recordString(run, "state"));
1503
+ if (runStatus === undefined || runStatus === "running" || runStatus === "pending") return;
1504
+ piAsyncRuns.delete(runId);
1505
+ const providerTurnId = tracked.turn.providerTurn.id;
1506
+ for (const other of piAsyncRuns.values()) {
1507
+ if (other.turn.providerTurn.id === providerTurnId) return;
1508
+ }
1509
+ yield* emit({
1510
+ type: "background_work.updated",
1511
+ driver: PI_PROVIDER,
1512
+ providerTurnId,
1513
+ pending: false,
1514
+ });
1515
+ });
1516
+
1517
+ const updateAsyncSubagents = Effect.fnUntraced(function* (event: PiRpcRecord) {
1518
+ const lines = recordField(event, "widgetLines");
1519
+ if (!Array.isArray(lines)) return;
1520
+ for (const line of lines) {
1521
+ if (typeof line !== "string" || !line.startsWith(PI_SUBAGENT_ASYNC_PREFIX)) continue;
1522
+ const snapshot = Option.getOrUndefined(
1523
+ decodePiJson(line.slice(PI_SUBAGENT_ASYNC_PREFIX.length)),
1524
+ );
1525
+ const runs = recordField(snapshot, "runs");
1526
+ if (!Array.isArray(runs)) continue;
1527
+ latestAsyncSnapshotRuns = runs;
1528
+ for (const run of runs) {
1529
+ const runId = recordString(run, "id");
1530
+ const tracked = runId === undefined ? undefined : piAsyncRuns.get(runId);
1531
+ if (runId === undefined || tracked === undefined) continue;
1532
+ yield* updateAsyncRun(runId, tracked, run);
1533
+ }
1534
+ }
1535
});
1536
1537
const cancelPrompt = Effect.fn("PiAdapter.cancelPrompt")(function* (
@@ -1540,6 +1657,10 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
1657
);
1658
return;
1659
}
1660
+ if (method === "setWidget" && recordString(event, "widgetKey") === "subagent-async") {
1661
+ yield* updateAsyncSubagents(event);
1662
+ return;
1663
+ }
1664
if (
1665
method !== "select" &&
1666
method !== "confirm" &&
@@ -3764,6 +3885,29 @@ function piUncapturedForkEntry(
3885
return earliest;
3886
}
3887
3888
+function piAsyncSubagentStatus(
3889
+ state: string | undefined,
3890
+): OrchestrationV2Subagent["status"] | undefined {
3891
+ switch (state) {
3892
+ case "queued":
3893
+ return "pending";
3894
+ case "running":
3895
+ return "running";
3896
+ case "paused":
3897
+ return "waiting";
3898
+ case "complete":
3899
+ case "partial":
3900
+ return "completed";
3901
+ case "failed":
3902
+ case "rejected":
3903
+ return "failed";
3904
+ case "stopped":
3905
+ return "interrupted";
3906
+ default:
3907
+ return undefined;
3908
+ }
3909
+}
3910
+
3911
function piSubagentOutput(result: unknown): string {
3912
const stopReason = recordString(result, "stopReason");
3913
const failed =