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.tsindex 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.tsindex 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;