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

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

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

Synced Nov 21, 16:00 UTC

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 =