From a69f547bedfa2e325fa68465c7c9da05c2d5cfd5 Mon Sep 17 00:00:00 2001 From: T3 Code Date: Sat, 21 Nov 2026 00:16:43 +0800 Subject: [PATCH 1/2] fix(antigravity): a message sent while a question waits no longer breaks the turn Since #39165, a message sent during an Antigravity turn is delivered as a new session/prompt. agy rejects that prompt while ask_question or an approval waits for an answer, so the turn failed and every later message failed the same way until the user switched provider. Decline the steer while a question or approval is pending. The orchestrator then queues the message as a follow-up, and the question stays open. Co-Authored-By: Claude Opus 5.5 --- .../Adapters/AntigravityAdapterV2.test.ts | 55 +++++++++++++++++++ packages/provider-acp/src/server/adapter.ts | 12 +++- 2 files changed, 66 insertions(+), 1 deletion(-) diff --git a/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.test.ts index e87b96f990466..99a7d98796c1a 100644 --- a/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.test.ts @@ -1414,6 +1414,61 @@ describe("AntigravityAdapterV2 work after the prompt ends", () => { }).pipe(Effect.provide(layerSession)), ); + // agy 1.5.13 answers a prompt sent while ask_question waits with "Can't add this prompt to + // session ...: the running prompt is waiting for a permission or question answer". + it.effect("declines a steer while the agent waits on a question", () => + Effect.gen(function* () { + const opened = yield* openSessionWithRunningCommand({}, undefined, { + agentVersion: "1.5.13", + holdsFirstPrompt: true, + }); + const { session, providerThread, command, startTurn, until, requestPermission } = opened; + yield* startTurn(1, false); + const started = yield* until( + (event) => + event.type === "turn_item.updated" && + event.turnItem.nativeItemRef?.nativeId === command.toolCallId, + ); + const providerTurnId = started.flatMap((event) => + event.type === "provider_turn.updated" ? [event.providerTurn.id] : [], + )[0]!; + const answer = yield* requestPermission( + { + ...permissionRequest("interaction_1", [ + { optionId: "red", name: "Red", kind: "allow_once" }, + { optionId: "blue", name: "Blue", kind: "allow_once" }, + ]), + sessionId: "mock-session-1", + }, + { requestId: "question-1", method: "session/request_permission" }, + ).pipe(Effect.forkScoped({ startImmediately: true })); + yield* until( + (event) => + event.type === "turn_item.updated" && event.turnItem.type === "user_input_request", + ); + + const steer = yield* session + .steerTurn({ + threadId: ThreadId.make("thread-antigravity-wake"), + runId: RunId.make("run-antigravity-wake-1"), + providerThread, + providerTurnId, + message: { + messageId: MessageId.make("message-antigravity-steer"), + text: "Pick whichever you like", + attachments: [], + createdBy: "user", + creationSource: "web", + }, + }) + .pipe(Effect.flip); + assert.equal(steer._tag, "ProviderAdapterSteerDeclinedError"); + assert.lengthOf(opened.prompts, 1, "the steer must not reach the waiting agent"); + assert.equal(opened.cancels(), 0, "a declined steer must not cancel the question"); + assert.isUndefined(answer.pollUnsafe(), "the question stays open for the user"); + }).pipe(Effect.provide(layerSession)), + ); + // A wake run has no prompt of its own, yet agy can keep working in it for minutes. it.effect("steers a continuation run that keeps working after its wake", () => Effect.gen(function* () { diff --git a/packages/provider-acp/src/server/adapter.ts b/packages/provider-acp/src/server/adapter.ts index d25274bb9a4ce..abc1d32854f37 100644 --- a/packages/provider-acp/src/server/adapter.ts +++ b/packages/provider-acp/src/server/adapter.ts @@ -9553,6 +9553,15 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( detail: `Provider turn ${turnInput.providerTurnId} is not active and cannot be steered.`, }); } + // `agy acp` rejects a prompt while the running one waits on a question or approval, + // so the message waits as a follow-up until the user answers. + if ((yield* Ref.get(pendingRuntimeRequests)).size > 0) { + return yield* new ProviderAdapter.ProviderAdapterSteerDeclinedError({ + driver, + providerThreadId: turnInput.providerThread.id, + providerTurnId: turnInput.providerTurnId, + }); + } const generation = yield* Ref.get(runtimeCallbackGeneration); const checkPromptOutcome = flavor.watchPromptOutcome === undefined @@ -9961,7 +9970,8 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( (effect, turnInput) => effect.pipe( Effect.mapError((cause) => - cause._tag === "ProviderAdapterSteerRunUnsupportedError" + cause._tag === "ProviderAdapterSteerRunUnsupportedError" || + cause._tag === "ProviderAdapterSteerDeclinedError" ? cause : new ProviderAdapter.ProviderAdapterSteerRunError({ driver, From 39515f8b19da243349038afc9c84c165d6fec4a1 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Fri, 20 Nov 2026 16:55:53 +0000 Subject: [PATCH 2/2] fix(antigravity): check pending questions under the callback permit before steering A question or approval registers under the runtime callback permit, so a check made before taking it could miss one and still send the prompt. Co-Authored-By: Claude Opus 5.5 --- packages/provider-acp/src/server/adapter.ts | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/packages/provider-acp/src/server/adapter.ts b/packages/provider-acp/src/server/adapter.ts index abc1d32854f37..b98d6489901e5 100644 --- a/packages/provider-acp/src/server/adapter.ts +++ b/packages/provider-acp/src/server/adapter.ts @@ -9553,15 +9553,6 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( detail: `Provider turn ${turnInput.providerTurnId} is not active and cannot be steered.`, }); } - // `agy acp` rejects a prompt while the running one waits on a question or approval, - // so the message waits as a follow-up until the user answers. - if ((yield* Ref.get(pendingRuntimeRequests)).size > 0) { - return yield* new ProviderAdapter.ProviderAdapterSteerDeclinedError({ - driver, - providerThreadId: turnInput.providerThread.id, - providerTurnId: turnInput.providerTurnId, - }); - } const generation = yield* Ref.get(runtimeCallbackGeneration); const checkPromptOutcome = flavor.watchPromptOutcome === undefined @@ -9572,6 +9563,16 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( generation, Effect.gen(function* () { if (context.finalized || context.interrupted) return false; + // `agy acp` rejects a prompt while the running one waits on a question or + // approval, so the message waits as a follow-up until the user answers. Checked + // under the callback permit, which also guards registering those requests. + if ((yield* Ref.get(pendingRuntimeRequests)).size > 0) { + return yield* new ProviderAdapter.ProviderAdapterSteerDeclinedError({ + driver, + providerThreadId: turnInput.providerThread.id, + providerTurnId: turnInput.providerTurnId, + }); + } // The steer prompt carries the turn on, also past a prompt that already settled. const released = context.foregroundIdle; context.foregroundIdle = yield* Deferred.make();