Skip to content
TypeScript

fix(pi): hold messages until compaction ends (#24388)

Julius Marminge18ac394ee4a9
diff --git a/packages/provider-pi/src/server/adapter.test.ts b/packages/provider-pi/src/server/adapter.test.ts
index 0fb1768b245..0afd6960485 100644
--- a/packages/provider-pi/src/server/adapter.test.ts
+++ b/packages/provider-pi/src/server/adapter.test.ts
@@ -161,10 +161,11 @@ interface FakePi {
readonly vetoNextSwitch: () => void;
readonly queueState: (data: Record<string, unknown>) => void;
readonly setStreaming: (streaming: boolean) => void;
+ readonly setCompacting: (compacting: boolean) => void;
readonly deferNextState: () => void;
readonly resolveDeferredState: (data: unknown) => Effect.Effect<void>;
readonly failNextState: () => void;
- readonly deferNextLifecycle: (type: "switch_session" | "new_session" | "fork") => void;
+ readonly deferNextLifecycle: (type: "switch_session" | "new_session" | "fork" | "abort") => void;
readonly deferNextModelSelection: () => void;
readonly queueModels: (models: ReadonlyArray<unknown>) => void;
readonly vetoNextNewSession: () => void;
@@ -197,6 +198,10 @@ const recordedIdleState = (sessionFile: string) => ({
pendingMessageCount: 0,
});
+/** Pi 1.4.0 rejects every prompt while compaction runs, including steers. */
+const PI_COMPACTING_PROMPT_ERROR =
+ "Cannot submit a prompt while compaction is in progress. Wait for compaction to finish and retry.";
+
const makeFakePi: Effect.Effect<FakePi> = Effect.gen(function* () {
const stdout = yield* Queue.unbounded<Uint8Array, Cause.Done>();
const requests = yield* Queue.unbounded<PiRpcRecord>();
@@ -215,6 +220,7 @@ const makeFakePi: Effect.Effect<FakePi> = Effect.gen(function* () {
let sessionGeneration = 0;
let models: ReadonlyArray<unknown> = [];
let isStreaming: boolean | null = null;
+ let isCompacting = false;
let clearQueue: Parameters<FakePi["setClearQueue"]>[0] = { steering: [], followUp: [] };
let stdinBuffer = "";
@@ -228,7 +234,10 @@ const makeFakePi: Effect.Effect<FakePi> = Effect.gen(function* () {
});
const respondTo = (record: PiRpcRecord): PiRpcRecord | null => {
- if (typeof record["id"] !== "string" && !(record["type"] === "prompt" && isStreaming !== null))
+ if (
+ typeof record["id"] !== "string" &&
+ !(record["type"] === "prompt" && (isStreaming !== null || isCompacting))
+ )
return null;
const base = {
type: "response",
@@ -251,6 +260,9 @@ const makeFakePi: Effect.Effect<FakePi> = Effect.gen(function* () {
},
};
case "prompt":
+ if (isCompacting) {
+ return { ...base, success: false, error: PI_COMPACTING_PROMPT_ERROR };
+ }
if (isStreaming && record["streamingBehavior"] === undefined) {
return {
...base,
@@ -397,6 +409,9 @@ const makeFakePi: Effect.Effect<FakePi> = Effect.gen(function* () {
setStreaming: (streaming) => {
isStreaming = streaming;
},
+ setCompacting: (compacting) => {
+ isCompacting = compacting;
+ },
queueStats: (data) => statsQueue.push(data),
setClearQueue: (result) => {
clearQueue = result;
@@ -791,7 +806,7 @@ describe("PiAdapterV2", () => {
);
it.effect.each([false, true])(
- "retains native wake ownership after a rejected joining prompt, compaction aborted=%s",
+ "retains native wake ownership and delivers a joining prompt held through compaction, aborted=%s",
(aborted) =>
Effect.gen(function* () {
const fake = yield* makeFakePi;
@@ -818,9 +833,6 @@ describe("PiAdapterV2", () => {
yield* fake.emit({ type: "agent_settled" });
yield* fake.emit({ type: "compaction_start", reason: "manual" });
yield* startTurn(runtime, providerThread);
- yield* fake.takeRequest("prompt");
- const rejection = "Cannot submit a prompt while compaction is in progress.";
- yield* fake.emit({ type: "response", command: "prompt", success: false, error: rejection });
yield* fake.emit({
type: "extension_ui_request",
id: "native-compaction-dialog",
@@ -836,22 +848,21 @@ describe("PiAdapterV2", () => {
decision: "accept",
});
yield* fake.takeRequest("extension_ui_response");
- if (aborted) {
- yield* fake.emit({ type: "compaction_end", result: null, aborted: true });
- const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
- assert.isTrue(
- terminal.type === "turn.terminal" &&
- terminal.status === "failed" &&
- terminal.failure.message === rejection,
- );
- return;
- }
+ assert.isFalse(fake.allRequests().some((request) => request["type"] === "prompt"));
+ yield* fake.emit(
+ aborted
+ ? { type: "compaction_end", result: null, aborted: true }
+ : {
+ type: "compaction_end",
+ result: { summary: "Native compaction finished" },
+ willRetry: true,
+ },
+ );
+ const prompt = yield* fake.takeRequest("prompt");
+ assert.equal(prompt["message"], "Hello pi");
fake.queueState({ isStreaming: true });
- yield* fake.emit({
- type: "compaction_end",
- result: { summary: "Native compaction finished" },
- willRetry: true,
- });
+ yield* fake.emit({ type: "response", command: "prompt", success: true });
+ yield* fake.takeRequest("get_state");
yield* fake.emit({ type: "agent_start" });
yield* fake.emit({ type: "message_start", message: { role: "assistant" } });
yield* fake.emit({
@@ -864,13 +875,12 @@ describe("PiAdapterV2", () => {
});
const message = yield* takeEvent((event) => event.type === "message.updated");
assert.isTrue(message.type === "message.updated" && message.message.runId !== null);
- yield* fake.takeRequest("get_state");
yield* fake.emit({ type: "agent_settled" });
const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
- assert.isTrue(
- terminal.type === "turn.terminal" &&
- terminal.status === "failed" &&
- terminal.failure.message === rejection,
+ assert.isTrue(terminal.type === "turn.terminal" && terminal.status === "completed");
+ assert.equal(
+ fake.allRequests().filter((request) => request["type"] === "prompt").length,
+ 1,
);
}).pipe(Effect.scoped, Effect.provide(layerTest)),
);
@@ -4138,6 +4148,310 @@ describe("PiAdapterV2", () => {
}).pipe(Effect.scoped, Effect.provide(layerTest)),
);
+ it.effect("delivers a turn-start prompt sent during detached compaction once it ends", () =>
+ Effect.gen(function* () {
+ const fake = yield* makeFakePi;
+ const { runtime, takeEvent } = yield* openRuntime(fake);
+ const providerThread = yield* runtime.ensureThread({
+ threadId: THREAD_ID,
+ modelSelection: modelSelection("default"),
+ runtimePolicy,
+ });
+ yield* startTurn(runtime, providerThread);
+ yield* fake.takeRequest("prompt");
+ yield* fake.emit({ type: "agent_start" });
+ yield* fake.emit({ type: "agent_settled" });
+ yield* fake.takeRequest("get_state");
+ const first = yield* takeEvent((event) => event.type === "turn.terminal");
+ assert.isTrue(first.type === "turn.terminal" && first.status === "completed");
+
+ fake.setCompacting(true);
+ yield* fake.emit({ type: "compaction_start", reason: "manual" });
+ // The dialog proves the pump observed compaction_start before the prompt.
+ yield* fake.emit({
+ type: "extension_ui_request",
+ id: "detached-compaction-dialog",
+ method: "confirm",
+ title: "Continue?",
+ });
+ yield* takeEvent((event) => event.type === "runtime_request.updated");
+ yield* startTurn(
+ runtime,
+ providerThread,
+ "default",
+ [],
+ "Sent during compaction",
+ undefined,
+ 2,
+ );
+ // Writes go out in order, so this round trip flushes any prompt sent before it.
+ yield* runtime.readThreadSnapshot({ providerThread });
+ fake.setCompacting(false);
+ const compactionEnded = fake.allRequests().length;
+ assert.isFalse(
+ fake
+ .allRequests()
+ .some(
+ (request) =>
+ request["type"] === "prompt" && request["message"] === "Sent during compaction",
+ ),
+ );
+ yield* fake.emit({
+ type: "compaction_end",
+ reason: "manual",
+ result: { summary: "smaller", tokensBefore: 10_000, estimatedTokensAfter: 2_000 },
+ aborted: false,
+ willRetry: false,
+ });
+ const delivered = yield* fake.takeRequest("prompt");
+ assert.equal(delivered["message"], "Sent during compaction");
+ yield* fake.emit({ type: "agent_start" });
+ fake.queueState({ isStreaming: false, isCompacting: false, pendingMessageCount: 0 });
+ yield* fake.emit({ type: "agent_settled" });
+ const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
+ assert.equal(
+ fake
+ .allRequests()
+ .slice(compactionEnded)
+ .filter(
+ (request) =>
+ request["type"] === "prompt" && request["message"] === "Sent during compaction",
+ ).length,
+ 1,
+ );
+ assert.isTrue(
+ terminal.type === "turn.terminal" && terminal.status === "completed",
+ `turn ended ${terminal.type === "turn.terminal" ? terminal.status : terminal.type}`,
+ );
+ }).pipe(Effect.scoped, Effect.provide(layerTest)),
+ );
+
+ it.effect.each([
+ { error: PI_COMPACTING_PROMPT_ERROR, retried: true },
+ { error: "Model unavailable", retried: false },
+ ])(
+ "retries a prompt Pi rejected because compaction started first, retried=$retried",
+ ({ error, retried }) =>
+ Effect.gen(function* () {
+ const fake = yield* makeFakePi;
+ const { runtime, takeEvent } = yield* openRuntime(fake);
+ const providerThread = yield* runtime.ensureThread({
+ threadId: THREAD_ID,
+ modelSelection: modelSelection("default"),
+ runtimePolicy,
+ });
+ yield* startTurn(runtime, providerThread);
+ yield* fake.takeRequest("prompt");
+ yield* fake.emit({ type: "response", command: "prompt", success: true });
+ yield* fake.emit({ type: "agent_start" });
+ yield* fake.emit({ type: "agent_settled" });
+ yield* fake.takeRequest("get_state");
+ yield* takeEvent((event) => event.type === "turn.terminal");
+
+ yield* startTurn(runtime, providerThread, "default", [], "Raced compaction", undefined, 2);
+ yield* fake.takeRequest("prompt");
+ yield* fake.emit({ type: "compaction_start", reason: "manual" });
+ yield* fake.emit({
+ type: "response",
+ command: "prompt",
+ success: false,
+ error,
+ });
+ if (!retried) {
+ const failed = yield* takeEvent((event) => event.type === "turn.terminal");
+ assert.isTrue(
+ failed.type === "turn.terminal" &&
+ failed.status === "failed" &&
+ failed.failure.message === error,
+ );
+ return;
+ }
+ const compactionEnded = fake.allRequests().length;
+ yield* fake.emit({ type: "compaction_end", result: null, aborted: true });
+ const retriedPrompt = yield* fake.takeRequest("prompt");
+ assert.equal(retriedPrompt["message"], "Raced compaction");
+ yield* fake.emit({ type: "agent_start" });
+ yield* fake.emit({ type: "agent_settled" });
+ const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
+ assert.isTrue(
+ terminal.type === "turn.terminal" && terminal.status === "completed",
+ `turn ended ${terminal.type === "turn.terminal" ? terminal.status : terminal.type}`,
+ );
+ assert.equal(
+ fake
+ .allRequests()
+ .slice(compactionEnded)
+ .filter((request) => request["type"] === "prompt").length,
+ 1,
+ );
+ }).pipe(Effect.scoped, Effect.provide(layerTest)),
+ );
+
+ it.effect.each([{ restart: false }, { restart: true }])(
+ "restarts Pi when Stop interrupts a prompt held for detached compaction, restart=$restart",
+ ({ restart }) =>
+ Effect.gen(function* () {
+ const fake = yield* makeFakePi;
+ const { runtime, takeEvent } = yield* openRuntime(fake);
+ const providerThread = yield* runtime.ensureThread({
+ threadId: THREAD_ID,
+ modelSelection: modelSelection("default"),
+ runtimePolicy,
+ });
+ yield* startTurn(runtime, providerThread);
+ yield* fake.takeRequest("prompt");
+ yield* fake.emit({ type: "agent_start" });
+ yield* fake.emit({ type: "agent_settled" });
+ yield* fake.takeRequest("get_state");
+ yield* takeEvent((event) => event.type === "turn.terminal");
+
+ fake.setCompacting(true);
+ yield* fake.emit({ type: "compaction_start", reason: "manual" });
+ // The dialog proves the pump observed compaction_start before the prompt.
+ yield* fake.emit({
+ type: "extension_ui_request",
+ id: "held-prompt-dialog",
+ method: "confirm",
+ title: "Continue?",
+ });
+ yield* takeEvent((event) => event.type === "runtime_request.updated");
+ yield* startTurn(runtime, providerThread, "default", [], "Held prompt", undefined, 2);
+ // Writes go out in order, so this round trip flushes any prompt sent before it.
+ yield* runtime.readThreadSnapshot({ providerThread });
+ assert.isFalse(
+ fake
+ .allRequests()
+ .some(
+ (request) => request["type"] === "prompt" && request["message"] === "Held prompt",
+ ),
+ );
+ const running = yield* takeEvent(
+ (event) =>
+ event.type === "provider_turn.updated" &&
+ event.providerTurn.status === "running" &&
+ event.providerTurn.ordinal === 2,
+ );
+ const providerTurnId =
+ running.type === "provider_turn.updated" ? running.providerTurn.id : undefined;
+ assert.isDefined(providerTurnId);
+
+ const interruptedAt = fake.allRequests().length;
+ if (restart) {
+ fake.deferNextLifecycle("abort");
+ const stop = yield* Effect.forkChild(
+ runtime.interruptTurn({
+ providerThread,
+ providerTurnId: providerTurnId!,
+ requestRuntimeRestart: true,
+ }),
+ );
+ const abort = yield* fake.takeRequest("abort");
+ // The abort ends compaction before Pi exits; the stopped turn's prompt stays held.
+ fake.setCompacting(false);
+ yield* fake.emit({
+ type: "compaction_end",
+ reason: "manual",
+ result: null,
+ aborted: true,
+ });
+ yield* fake.emit({
+ type: "extension_ui_request",
+ id: "after-compaction-dialog",
+ method: "confirm",
+ title: "Continue?",
+ });
+ yield* takeEvent((event) => event.type === "runtime_request.updated");
+ yield* fake.emit({ type: "response", id: abort["id"], command: "abort", success: true });
+ yield* Fiber.join(stop);
+ } else {
+ yield* runtime.interruptTurn({ providerThread, providerTurnId: providerTurnId! });
+ assert.isFalse(fake.allRequests().some((request) => request["type"] === "abort"));
+ }
+ yield* fake.closeStdout;
+ const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
+ assert.isTrue(terminal.type === "turn.terminal" && terminal.status === "interrupted");
+ assert.isFalse(
+ fake
+ .allRequests()
+ .slice(interruptedAt)
+ .some((request) => request["type"] === "prompt"),
+ );
+ }).pipe(Effect.scoped, Effect.provide(layerTest)),
+ );
+
+ it.effect("delivers a steer sent during in-turn compaction once it ends", () =>
+ Effect.gen(function* () {
+ const fake = yield* makeFakePi;
+ const { runtime, takeEvent } = yield* openRuntime(fake);
+ const providerThread = yield* runtime.ensureThread({
+ threadId: THREAD_ID,
+ modelSelection: modelSelection("default"),
+ runtimePolicy,
+ });
+ yield* startTurn(runtime, providerThread);
+ yield* fake.takeRequest("prompt");
+ const running = yield* takeEvent(
+ (event) =>
+ event.type === "provider_turn.updated" && event.providerTurn.status === "running",
+ );
+ const providerTurnId =
+ running.type === "provider_turn.updated" ? running.providerTurn.id : undefined;
+ assert.isDefined(providerTurnId);
+ yield* fake.emit({ type: "agent_start" });
+ fake.queueState({ isStreaming: false, isCompacting: true, pendingMessageCount: 0 });
+ yield* fake.emit({ type: "agent_settled" });
+ yield* fake.takeRequest("get_state");
+ fake.setCompacting(true);
+ yield* fake.emit({ type: "compaction_start", reason: "manual" });
+ yield* takeEvent(
+ (event) => event.type === "turn_item.updated" && event.turnItem.type === "compaction",
+ );
+
+ yield* runtime.steerTurn({
+ threadId: THREAD_ID,
+ runId: RunId.make("run:thread-pi-test:1"),
+ providerThread,
+ providerTurnId: providerTurnId!,
+ message: {
+ messageId: "message:thread-pi-test:steer-during-compaction" as never,
+ text: "Steer during compaction",
+ attachments: [],
+ createdBy: "user",
+ creationSource: "web",
+ },
+ });
+ fake.setCompacting(false);
+ const compactionEnded = fake.allRequests().length;
+ yield* fake.emit({
+ type: "compaction_end",
+ reason: "manual",
+ result: { summary: "smaller", tokensBefore: 10_000, estimatedTokensAfter: 2_000 },
+ aborted: false,
+ willRetry: false,
+ });
+ const delivered = yield* fake.takeRequest("prompt");
+ assert.equal(delivered["message"], "Steer during compaction");
+ yield* fake.emit({ type: "agent_start" });
+ fake.queueState({ isStreaming: false, isCompacting: false, pendingMessageCount: 0 });
+ yield* fake.emit({ type: "agent_settled" });
+ const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
+ assert.equal(
+ fake
+ .allRequests()
+ .slice(compactionEnded)
+ .filter(
+ (request) =>
+ request["type"] === "prompt" && request["message"] === "Steer during compaction",
+ ).length,
+ 1,
+ );
+ assert.isTrue(
+ terminal.type === "turn.terminal" && terminal.status === "completed",
+ `turn ended ${terminal.type === "turn.terminal" ? terminal.status : terminal.type}`,
+ );
+ }).pipe(Effect.scoped, Effect.provide(layerTest)),
+ );
+
it.effect("keeps working after a settle probe fails before detached compaction", () =>
Effect.gen(function* () {
const fake = yield* makeFakePi;
diff --git a/packages/provider-pi/src/server/adapter.ts b/packages/provider-pi/src/server/adapter.ts
index a32a5759ba7..b7045bcd643 100644
--- a/packages/provider-pi/src/server/adapter.ts
+++ b/packages/provider-pi/src/server/adapter.ts
@@ -398,6 +398,15 @@ function piApprovalRequestKind(title: string): "command" | "file-change" {
: "command";
}
+/** Pi 1.4.0 rejects prompts with this when they race a compaction it already started. */
+const PI_COMPACTING_PROMPT_REJECTION = "Cannot submit a prompt while compaction is in progress";
+
+interface PiPromptSend {
+ readonly providerTurnId: OrchestrationV2ProviderTurn["id"];
+ readonly kind: "turn_start" | "steer";
+ readonly record: PiRpcRecord;
+}
+
interface PiThreadState {
providerThread: OrchestrationV2ProviderThread;
activeTurn: ActivePiTurn | null;
@@ -560,14 +569,30 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
const modelContextWindows = new Map<string, number>();
let modelsDiscovered = false;
// Prompt ACKs lack IDs; retain session send order and ownership so late ACKs cannot affect new turns.
- const pendingPromptResponses: Array<{
- readonly providerTurnId: OrchestrationV2ProviderTurn["id"];
- readonly kind: "turn_start" | "steer";
- }> = [];
+ const pendingPromptResponses: Array<PiPromptSend> = [];
const pendingCompactResponses: Array<{
readonly providerTurnId: OrchestrationV2ProviderTurn["id"];
readonly kind: "turn_start" | "steer";
}> = [];
+ // Pi rejects every prompt while it compacts, including compaction an
+ // extension starts after the turn settled. Hold prompts until it ends.
+ let nativeCompacting = false;
+ const heldPrompts: Array<PiPromptSend> = [];
+ // Prompts sent before the pump observed compaction_start are rejected
+ // after it; they precede every prompt held since.
+ let rejectedHeldCount = 0;
+
+ const sendPrompt = Effect.fnUntraced(function* (prompt: PiPromptSend) {
+ if (nativeCompacting) {
+ heldPrompts.push(prompt);
+ return;
+ }
+ yield* connection.send(prompt.record);
+ pendingPromptResponses.push(prompt);
+ });
+ // A just-released prompt has not started its run yet, so a settle probe
+ // racing it would see Pi idle. Its ack re-arms the probe instead.
+ let releasedPromptTurnId: OrchestrationV2ProviderTurn["id"] | null = null;
const compactRpcRecord = (command: PiCompactCommand): PiRpcRecord =>
command.customInstructions === undefined
@@ -1835,7 +1860,10 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
if (result === null || result === undefined) {
if (event["aborted"] === true) {
yield* emitCompaction(turn, compaction, "cancelled");
- if (turn.settleWhenIdle || !turn.sawAgentActivity) {
+ if (
+ (turn.settleWhenIdle || !turn.sawAgentActivity) &&
+ releasedPromptTurnId !== turn.providerTurn.id
+ ) {
yield* scheduleSettleProbe(turn, turn.settleWhenIdle);
}
return;
@@ -1845,7 +1873,10 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
yield* emitCompaction(turn, compaction, "failed", {
summary: errorMessage.slice(0, 1_000),
});
- if (turn.settleWhenIdle || !turn.sawAgentActivity) {
+ if (
+ (turn.settleWhenIdle || !turn.sawAgentActivity) &&
+ releasedPromptTurnId !== turn.providerTurn.id
+ ) {
yield* scheduleSettleProbe(turn, turn.settleWhenIdle);
}
return;
@@ -1862,7 +1893,10 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
...(beforeTokenCount === undefined ? {} : { beforeTokenCount }),
...(afterTokenCount === undefined ? {} : { afterTokenCount }),
});
- if (turn.settleWhenIdle || !turn.sawAgentActivity) {
+ if (
+ (turn.settleWhenIdle || !turn.sawAgentActivity) &&
+ releasedPromptTurnId !== turn.providerTurn.id
+ ) {
yield* scheduleSettleProbe(turn, turn.settleWhenIdle);
}
return;
@@ -2012,6 +2046,22 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
const pendingPrompt = command === "prompt" ? pendingPromptResponses.shift() : undefined;
const responseTurn =
pendingPrompt?.providerTurnId === turn?.providerTurn.id ? turn : null;
+ if (
+ event["success"] === false &&
+ nativeCompacting &&
+ recordString(event, "error")?.startsWith(PI_COMPACTING_PROMPT_REJECTION) === true &&
+ pendingPrompt !== undefined &&
+ responseTurn !== null
+ ) {
+ heldPrompts.splice(rejectedHeldCount++, 0, pendingPrompt);
+ return;
+ }
+ // Settlement is not probed while a steer awaits its ack (see
+ // compaction_end); once Pi answers, the run it may have started is
+ // visible to get_state.
+ if (pendingPrompt?.kind === "steer" && responseTurn?.settleWhenIdle === true) {
+ yield* scheduleSettleProbe(responseTurn, true);
+ }
if (event["success"] === true) {
// Command-only prompts emit no agent_settled; probe idle and re-queue behind preceding native events.
if (
@@ -2123,7 +2173,33 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
yield* Effect.gen(function* () {
while (true) {
const event = yield* Queue.take(connection.events);
- yield* sessionEventPermit.withPermits(1)(handleSessionEvent(event));
+ yield* sessionEventPermit.withPermits(1)(
+ Effect.gen(function* () {
+ // Tracked here rather than in handleSessionEvent, which also
+ // replays buffered wake events after they were observed.
+ if (event["type"] === "compaction_start") nativeCompacting = true;
+ if (event["type"] === "compaction_end") {
+ nativeCompacting = false;
+ // Send before the handler can probe settlement, so Pi sees the
+ // prompt first. Prompts whose turn ended or is stopping are dropped.
+ rejectedHeldCount = 0;
+ for (const held of heldPrompts.splice(0)) {
+ const turn = threadState?.activeTurn;
+ if (
+ turn?.providerTurn.id !== held.providerTurnId ||
+ turn.interrupted ||
+ stopRequested
+ )
+ continue;
+ yield* sendPrompt(held);
+ releasedPromptTurnId = held.providerTurnId;
+ }
+ }
+ yield* handleSessionEvent(event).pipe(
+ Effect.ensuring(Effect.sync(() => (releasedPromptTurnId = null))),
+ );
+ }),
+ );
}
}).pipe(
Effect.catchCause((cause) =>
@@ -2558,15 +2634,15 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
kind: "turn_start",
});
} else if (payload !== null) {
- yield* connection.send({
- type: "prompt",
- message: payload.message,
- streamingBehavior: "steer",
- ...(payload.images.length === 0 ? {} : { images: payload.images }),
- });
- pendingPromptResponses.push({
+ yield* sendPrompt({
providerTurnId: providerTurn.id,
kind: "turn_start",
+ record: {
+ type: "prompt",
+ message: payload.message,
+ streamingBehavior: "steer",
+ ...(payload.images.length === 0 ? {} : { images: payload.images }),
+ },
});
}
yield* emit({
@@ -2652,15 +2728,15 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
kind: "steer",
});
} else if (payload !== null) {
- yield* connection.send({
- type: "prompt",
- message: payload.message,
- streamingBehavior: "steer",
- ...(payload.images.length === 0 ? {} : { images: payload.images }),
- });
- pendingPromptResponses.push({
+ yield* sendPrompt({
providerTurnId: turn.providerTurn.id,
kind: "steer",
+ record: {
+ type: "prompt",
+ message: payload.message,
+ streamingBehavior: "steer",
+ ...(payload.images.length === 0 ? {} : { images: payload.images }),
+ },
});
}
turn.settleProbeGeneration += 1;
@@ -2696,7 +2772,8 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
interruptInput.requestRuntimeRestart === true ||
turn.settleWhenIdle ||
turn.activeCompaction !== null ||
- turn.manualCompactInFlight
+ turn.manualCompactInFlight ||
+ nativeCompacting
) {
// Generic abort misses manual compaction; terminate so Stop covers /compact and recovery.
stopRequested = true;