Skip to content

Commit 541f3e8

Browse files
committed
fix(pi): retain pending acknowledgment turn boundaries
Block new starts behind old prompt replies at both ownership checks. Defer idle settlement until manual compact replies arrive and resume probes after accepted or refused compacts. Extend existing race tables with interrupted input, suspended starts and queued compacts. Regressions fail before the fix; 110 scoped tests and eight replay cases pass, with independent review accepted.
1 parent 42bf3ff commit 541f3e8

2 files changed

Lines changed: 180 additions & 40 deletions

File tree

‎packages/provider-pi/src/server/adapter.test.ts‎

Lines changed: 165 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -66,6 +66,7 @@ const decodeUserInputQuestions = Schema.decodeUnknownSync(
6666
Schema.Array(OrchestrationV2UserInputQuestion),
6767
);
6868

69+
const isProviderProtocolError = Schema.is(ProviderAdapter.ProviderAdapterProtocolError);
6970
const decodeJsonLine = Schema.decodeSync(Schema.fromJsonString(Schema.Unknown));
7071
const encodeJsonLine = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
7172

@@ -3682,38 +3683,119 @@ describe("PiAdapterV2", () => {
36823683
}).pipe(Effect.scoped, Effect.provide(layerTest)),
36833684
);
36843685

3685-
it.effect("keeps a settled turn's late prompt rejection off the next turn", () =>
3686-
Effect.gen(function* () {
3687-
const fake = yield* makeFakePi;
3688-
const { runtime, takeEvent } = yield* openRuntime(fake);
3689-
const providerThread = yield* runtime.ensureThread({
3690-
threadId: THREAD_ID,
3691-
modelSelection: modelSelection("default"),
3692-
runtimePolicy,
3693-
});
3694-
yield* startTurn(runtime, providerThread, "default", [], "/my-command");
3695-
const firstPrompt = yield* fake.takeRequest("prompt");
3696-
yield* fake.emit({ type: "agent_start" });
3697-
yield* fake.emit({ type: "agent_settled" });
3698-
const firstTerminal = yield* takeEvent((event) => event.type === "turn.terminal");
3699-
assert.isTrue(firstTerminal.type === "turn.terminal" && firstTerminal.status === "completed");
3686+
it.effect.each(["settled", "interrupted-id", "interrupted-idless"])(
3687+
"keeps a settled turn's late prompt rejection off the next turn: %s",
3688+
(boundary) =>
3689+
Effect.gen(function* () {
3690+
const fake = yield* makeFakePi;
3691+
const { runtime, takeEvent } = yield* openRuntime(fake);
3692+
const providerThread = yield* runtime.ensureThread({
3693+
threadId: THREAD_ID,
3694+
modelSelection: modelSelection("default"),
3695+
runtimePolicy,
3696+
});
3697+
const interrupted = boundary !== "settled";
3698+
// Hold a competing start past the outer guard, before the first turn owns the session.
3699+
if (interrupted) fake.deferNextModelSelection();
3700+
const competing = interrupted
3701+
? yield* startTurn(
3702+
runtime,
3703+
providerThread,
3704+
"default",
3705+
[],
3706+
"Competing turn",
3707+
modelSelection("xai/grok-4.6"),
3708+
2,
3709+
).pipe(Effect.result, Effect.forkScoped)
3710+
: null;
3711+
const modelRequest = interrupted ? yield* fake.takeRequest("set_model") : null;
3712+
if (interrupted) fake.deferNextLifecycle("prompt");
3713+
yield* startTurn(runtime, providerThread, "default", [], "/my-command");
3714+
const firstPrompt = yield* fake.takeRequest("prompt");
3715+
const running = yield* takeEvent((event) => event.type === "provider_turn.updated");
3716+
assert.isTrue(running.type === "provider_turn.updated");
3717+
if (running.type !== "provider_turn.updated") return;
3718+
if (interrupted) {
3719+
yield* runtime.interruptTurn({ providerThread, providerTurnId: running.providerTurn.id });
3720+
} else {
3721+
yield* fake.emit({ type: "agent_start" });
3722+
}
3723+
yield* fake.emit({ type: "agent_settled" });
3724+
const firstTerminal = yield* takeEvent((event) => event.type === "turn.terminal");
3725+
assert.isTrue(
3726+
firstTerminal.type === "turn.terminal" &&
3727+
firstTerminal.status === (interrupted ? "interrupted" : "completed"),
3728+
);
37003729

3701-
yield* startTurn(runtime, providerThread, "default", [], "Second turn", undefined, 2);
3702-
yield* fake.takeRequest("prompt");
3703-
yield* fake.emit({
3704-
type: "response",
3705-
id: firstPrompt["id"],
3706-
command: "prompt",
3707-
success: false,
3708-
error: "late command rejection",
3709-
});
3710-
yield* fake.emit({ type: "agent_start" });
3711-
yield* fake.emit({ type: "agent_settled" });
3712-
const secondTerminal = yield* takeEvent((event) => event.type === "turn.terminal");
3713-
assert.isTrue(
3714-
secondTerminal.type === "turn.terminal" && secondTerminal.status === "completed",
3715-
);
3716-
}).pipe(Effect.scoped, Effect.provide(layerTest)),
3730+
if (competing !== null && modelRequest !== null) {
3731+
const blocked = yield* startTurn(
3732+
runtime,
3733+
providerThread,
3734+
"default",
3735+
[],
3736+
"Blocked turn",
3737+
undefined,
3738+
2,
3739+
).pipe(Effect.result);
3740+
assert.equal(blocked._tag, "Failure");
3741+
assert.isTrue(
3742+
blocked._tag === "Failure" &&
3743+
isProviderProtocolError(blocked.failure.cause) &&
3744+
blocked.failure.cause.reason === "previous_turn_active",
3745+
);
3746+
yield* fake.emit({
3747+
type: "response",
3748+
id: modelRequest["id"],
3749+
command: "set_model",
3750+
success: true,
3751+
data: { provider: "xai", id: "grok-4.6" },
3752+
});
3753+
assert.equal((yield* Fiber.join(competing))._tag, "Failure");
3754+
assert.lengthOf(
3755+
fake.allRequests().filter((request) => request["type"] === "prompt"),
3756+
1,
3757+
);
3758+
yield* fake.emit({
3759+
type: "response",
3760+
command: "prompt",
3761+
success: false,
3762+
...(boundary === "interrupted-idless" ? {} : { id: firstPrompt["id"] }),
3763+
error: "late command rejection",
3764+
});
3765+
yield* fake.emit({
3766+
type: "extension_ui_request",
3767+
id: "old-ack-barrier",
3768+
method: "confirm",
3769+
title: "Old input acknowledged",
3770+
});
3771+
const barrier = yield* takeEvent((event) => event.type === "runtime_request.updated");
3772+
assert.isTrue(barrier.type === "runtime_request.updated");
3773+
if (barrier.type !== "runtime_request.updated") return;
3774+
yield* runtime.respondToRuntimeRequest({
3775+
requestId: barrier.runtimeRequest.id,
3776+
decision: "decline",
3777+
});
3778+
yield* fake.takeRequest("extension_ui_response");
3779+
}
3780+
3781+
fake.deferNextLifecycle("prompt");
3782+
yield* startTurn(runtime, providerThread, "default", [], "Second turn", undefined, 2);
3783+
yield* fake.takeRequest("prompt");
3784+
yield* fake.emit({
3785+
type: "response",
3786+
id: firstPrompt["id"],
3787+
command: "prompt",
3788+
success: false,
3789+
error: "late command rejection",
3790+
});
3791+
yield* fake.emit({ type: "response", command: "prompt", success: true });
3792+
yield* fake.emit({ type: "agent_start" });
3793+
yield* fake.emit({ type: "agent_settled" });
3794+
const secondTerminal = yield* takeEvent((event) => event.type === "turn.terminal");
3795+
assert.isTrue(
3796+
secondTerminal.type === "turn.terminal" && secondTerminal.status === "completed",
3797+
);
3798+
}).pipe(Effect.scoped, Effect.provide(layerTest)),
37173799
);
37183800

37193801
it.effect("shows compaction progress and completes the same activity row", () =>
@@ -4322,6 +4404,12 @@ describe("PiAdapterV2", () => {
43224404
{ handled: true, steer: "starts" },
43234405
{ handled: true, steer: "handled" },
43244406
{ handled: true, steer: "rejected" },
4407+
{ handled: true, steer: "compact-accepted" },
4408+
{ handled: true, steer: "compact-rejected" },
4409+
{ handled: false, steer: "compact-accepted" },
4410+
{ handled: false, steer: "compact-rejected" },
4411+
{ handled: true, steer: "compact-queued-accepted" },
4412+
{ handled: true, steer: "compact-queued-rejected" },
43254413
])("ignores stale idle probes, handled=$handled steer=$steer", ({ handled, steer }) =>
43264414
Effect.gen(function* () {
43274415
const fake = yield* makeFakePi;
@@ -4356,26 +4444,68 @@ describe("PiAdapterV2", () => {
43564444
: { type: "agent_settled" },
43574445
);
43584446
yield* fake.takeRequest("get_state");
4447+
const compact = steer.startsWith("compact-");
43594448
fake.deferNextLifecycle("prompt");
4360-
yield* runtime.steerTurn({
4449+
const steerInput = {
43614450
threadId: THREAD_ID,
43624451
runId: RunId.make("run:thread-pi-test:1"),
43634452
providerThread,
43644453
providerTurnId: providerTurnId!,
43654454
message: {
43664455
messageId: "message:thread-pi-test:late-steer" as never,
4367-
text: "Continue after settlement",
4456+
text: compact ? "/compact" : "Continue after settlement",
43684457
attachments: [],
43694458
createdBy: "user",
43704459
creationSource: "web",
43714460
},
4372-
});
4373-
const steeredPrompt = yield* fake.takeRequest("prompt");
4461+
} satisfies ProviderAdapter.ProviderAdapterV2SteerInput;
4462+
yield* runtime.steerTurn(steerInput);
4463+
const steeredPrompt = yield* fake.takeRequest(compact ? "compact" : "prompt");
43744464
yield* fake.resolveDeferredState({
43754465
isStreaming: false,
43764466
isCompacting: false,
43774467
pendingMessageCount: 0,
43784468
});
4469+
if (compact) {
4470+
if (steer.startsWith("compact-queued-")) {
4471+
yield* runtime.steerTurn(steerInput);
4472+
yield* fake.takeRequest("compact");
4473+
// Put a current probe before a notice in the pump, independent of fork scheduling.
4474+
for (const acknowledged of [false, true]) {
4475+
if (acknowledged) {
4476+
yield* fake.emit({ type: "response", command: "compact", success: true });
4477+
yield* fake.takeRequest("get_state");
4478+
}
4479+
yield* fake.emit({
4480+
type: "t3.settle_probe",
4481+
providerTurnId,
4482+
settleProbeGeneration: 2,
4483+
data: { isStreaming: false, isCompacting: false, pendingMessageCount: 0 },
4484+
});
4485+
yield* fake.emit({
4486+
type: "extension_ui_request",
4487+
method: "notify",
4488+
message: "Compact acknowledgment still pending",
4489+
});
4490+
const barrier = yield* takeEvent(
4491+
(event) =>
4492+
event.type === "turn.terminal" ||
4493+
(event.type === "turn_item.updated" && event.turnItem.type === "system_notice"),
4494+
);
4495+
assert.equal(barrier.type, "turn_item.updated");
4496+
assert.equal(runtime.providerSession.status, "running");
4497+
}
4498+
}
4499+
yield* fake.emit({
4500+
type: "response",
4501+
command: "compact",
4502+
success: !steer.endsWith("rejected"),
4503+
error: "Compact refused",
4504+
});
4505+
const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
4506+
assert.isTrue(terminal.type === "turn.terminal" && terminal.status === "completed");
4507+
return;
4508+
}
43794509
if (steer !== "starts") {
43804510
yield* fake.emit({
43814511
type: "response",

‎packages/provider-pi/src/server/adapter.ts‎

Lines changed: 15 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1979,12 +1979,11 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
19791979
if (compactTurn !== null) compactTurn.manualCompactInFlight = false;
19801980
if (event["success"] === true) {
19811981
if (
1982-
pendingCompact?.kind === "turn_start" &&
19831982
compactTurn !== null &&
1984-
compactTurn.promptMayBeCommandOnly &&
1985-
!compactTurn.sawAgentActivity
1983+
(compactTurn.settleWhenIdle ||
1984+
(compactTurn.promptMayBeCommandOnly && !compactTurn.sawAgentActivity))
19861985
) {
1987-
yield* scheduleSettleProbe(compactTurn);
1986+
yield* scheduleSettleProbe(compactTurn, compactTurn.settleWhenIdle);
19881987
}
19891988
return;
19901989
}
@@ -1995,6 +1994,12 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
19951994
yield* Effect.logWarning("Pi rejected a compact steer.", {
19961995
errorLength: recordString(event, "error")?.length,
19971996
});
1997+
if (
1998+
compactTurn.settleWhenIdle ||
1999+
(compactTurn.promptMayBeCommandOnly && !compactTurn.sawAgentActivity)
2000+
) {
2001+
yield* scheduleSettleProbe(compactTurn, compactTurn.settleWhenIdle);
2002+
}
19982003
return;
19992004
}
20002005
if (!compactTurn.sawCompaction) {
@@ -2119,6 +2124,10 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
21192124
return;
21202125
}
21212126
if (
2127+
turn.manualCompactInFlight ||
2128+
pendingCompactResponses.some(
2129+
(pending) => pending.providerTurnId === turn.providerTurn.id,
2130+
) ||
21222131
pendingPromptResponses.some(
21232132
(pending) => pending.providerTurnId === turn.providerTurn.id,
21242133
)
@@ -2486,7 +2495,7 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
24862495
if (state === null) {
24872496
return yield* protocolError("Pi session has no registered thread");
24882497
}
2489-
if (state.activeTurn !== null) {
2498+
if (state.activeTurn !== null || pendingPromptResponses.length > 0) {
24902499
return yield* new ProviderAdapter.ProviderAdapterProtocolError({
24912500
driver: PI_PROVIDER,
24922501
detail: `Pi provider thread ${turnInput.providerThread.id} already has an active turn`,
@@ -2572,6 +2581,7 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
25722581
if (
25732582
threadState !== state ||
25742583
state.activeTurn !== null ||
2584+
pendingPromptResponses.length > 0 ||
25752585
closed ||
25762586
stopRequested ||
25772587
rollbackBarrier !== null ||

0 commit comments

Comments
 (0)