From aa0ce0bf367b7f490179217a57fbdecbfb2d7a73 Mon Sep 17 00:00:00 2001 From: kyle Date: Sat, 21 Nov 2026 01:43:42 +0100 Subject: [PATCH 1/3] fix(provider-acp): re-check prompt outcome before deferred background finalize --- .../Adapters/AcpAdapterV2.test.ts | 237 ++++++++++++++++++ packages/provider-acp/src/server/adapter.ts | 53 +++- 2 files changed, 288 insertions(+), 2 deletions(-) diff --git a/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts index ec56c0c389a6..e72ca5fcc318 100644 --- a/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts @@ -1638,6 +1638,243 @@ describe("AcpAdapterV2", () => { assert.deepEqual(promptTexts.slice(3), ["continue"], "a turn resumes only once"); }).pipe(Effect.provide(layerTest)), ); + it.effect( + "re-checks prompt outcome before deferred finalize and discards stale in-flight checks", + () => + Effect.gen(function* () { + const childProcessSpawner = yield* ChildProcessSpawner.ChildProcessSpawner; + const idAllocator = yield* IdAllocator.IdAllocatorV2; + const selfInvocation = yield* resolveSelfInvocation(); + const mockAgentPath = yield* bundledMockAgentPath; + const instanceId = ProviderInstanceId.make("acp-test-deferred-outcome"); + const threadId = ThreadId.make("thread-acp-deferred-outcome"); + const quota = { + class: "usage_limit", + message: "Quota reached after background work.", + code: "QUOTA_EXHAUSTED", + retryable: true, + resetAt: "2030-01-01T00:00:00.000Z", + } as const; + type RuntimeService = AcpSessionRuntime.AcpSessionRuntime["Service"]; + type PromptOutcome = { + readonly failure: typeof quota; + readonly threadDisposition: "reusable" | "broken"; + }; + let sessionUpdateHandler: Parameters[0] | undefined; + const subagentStatuses = new Map([ + ["tool-call-generic-1", "running"], + ]); + const promptRuntimes: Array = []; + const checkStopReasons: Array = []; + let nextOutcome: () => Effect.Effect = () => Effect.undefined; + const promptSettled = yield* Queue.unbounded(); + const deferredScheduled = yield* Queue.unbounded(); + const deferredFinalized = yield* Queue.unbounded(); + const adapter = yield* makeAcpAdapterV2({ + instanceId, + selfInvocation, + testHooks: { + afterPromptSettledWithBackgroundWork: () => + Queue.offer(promptSettled, undefined).pipe(Effect.asVoid), + onDeferredFinalizeScheduled: () => + Queue.offer(deferredScheduled, undefined).pipe(Effect.asVoid), + afterDeferredFinalize: () => + Queue.offer(deferredFinalized, undefined).pipe(Effect.asVoid), + }, + flavor: { + driver: ACP_TEST_DRIVER, + capabilities: AcpProviderCapabilitiesV2, + deferFinalizeForBackgroundWork: true, + extractSubagentUpdate: (toolCall) => { + const status = subagentStatuses.get(toolCall.toolCallId); + if (status === undefined) return undefined; + return { + nativeTaskId: `task-${toolCall.toolCallId}`, + prompt: toolCall.toolCallId, + title: toolCall.toolCallId, + model: null, + status, + childSessionId: null, + result: status === "completed" ? "DONE" : null, + }; + }, + watchPromptOutcome: () => + Effect.succeed((result: EffectAcpSchema.PromptResponse) => + Effect.sync(() => { + checkStopReasons.push(result.stopReason); + }).pipe(Effect.andThen(Effect.suspend(() => nextOutcome()))), + ), + makeRuntime: makeMockRuntime({ + childProcessSpawner, + mockAgentPath, + environment: { T3_ACP_EMIT_GENERIC_TOOL_PLACEHOLDERS: "1" }, + wrapRuntime: (runtime, runtimeOrdinal) => ({ + ...runtime, + handleSessionUpdate: (handler) => + Effect.sync(() => { + sessionUpdateHandler = handler; + }).pipe(Effect.andThen(runtime.handleSessionUpdate(handler))), + prompt: (payload, promptOptions) => + Effect.sync(() => { + promptRuntimes.push(runtimeOrdinal); + }).pipe(Effect.andThen(runtime.prompt(payload, promptOptions))), + }), + }), + }, + }); + const runtimePolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({ + runtimeMode: "full-access", + interactionMode: "default", + cwd: process.cwd(), + }); + const modelSelection = { instanceId, model: "default" } as const; + const runtime = yield* adapter.openSession({ + threadId, + providerSessionId: ProviderSessionId.make("provider-session-acp-deferred-outcome"), + modelSelection, + runtimePolicy, + }); + const terminals = + yield* Queue.unbounded< + Extract + >(); + yield* runtime.events.pipe( + Stream.filter((event) => event.type === "turn.terminal"), + Stream.runForEach((event) => Queue.offer(terminals, event)), + Effect.forkScoped, + ); + const providerThread = yield* runtime.ensureThread({ + threadId, + modelSelection, + runtimePolicy, + }); + const startTurn = Effect.fnUntraced(function* (ordinal: number) { + yield* runtime.startTurn( + makeTurnInput({ + threadId, + providerThread, + instanceId, + runtimePolicy, + now: yield* DateTime.now, + ordinal, + }), + ); + }); + const emitSubagent = ( + toolCallId: string, + status: "running" | "completed", + sessionUpdate: "tool_call" | "tool_call_update" = "tool_call_update", + ) => { + subagentStatuses.set(toolCallId, status); + return sessionUpdateHandler!({ + sessionId: "mock-session-1", + update: { + sessionUpdate, + toolCallId, + title: toolCallId, + kind: "other", + status: status === "running" ? "in_progress" : "completed", + ...(status === "completed" ? { rawOutput: { content: "DONE" } } : {}), + }, + }); + }; + + yield* startTurn(1); + yield* Queue.take(promptSettled); + assert.deepEqual(checkStopReasons, ["end_turn"]); + assert.isDefined(sessionUpdateHandler); + + nextOutcome = () => Effect.succeed({ failure: quota, threadDisposition: "broken" }); + yield* emitSubagent("tool-call-generic-1", "completed"); + yield* Queue.take(deferredScheduled); + yield* TestClock.adjust("3000 millis"); + + const firstTerminal = yield* Queue.take(terminals); + yield* Queue.take(deferredFinalized); + assert.equal(firstTerminal.status, "failed"); + assert.deepEqual(firstTerminal.failure, quota); + assert.equal(firstTerminal.threadDisposition, "broken"); + assert.deepEqual(checkStopReasons, ["end_turn", "end_turn"]); + + nextOutcome = () => Effect.undefined; + subagentStatuses.set("tool-call-generic-1", "running"); + yield* startTurn(2); + yield* Queue.take(promptSettled); + assert.deepEqual(promptRuntimes, [1, 2], "hidden deferred failure must restart runtime"); + + const workRaceStarted = yield* Deferred.make(); + const releaseWorkRace = yield* Deferred.make(); + nextOutcome = () => + Deferred.succeed(workRaceStarted, undefined).pipe( + Effect.andThen(Deferred.await(releaseWorkRace)), + Effect.as({ failure: quota, threadDisposition: "reusable" }), + ); + yield* emitSubagent("tool-call-generic-1", "completed"); + yield* Queue.take(deferredScheduled); + yield* TestClock.adjust("3000 millis"); + yield* Deferred.await(workRaceStarted); + + yield* emitSubagent("tool-call-generic-2", "running", "tool_call"); + nextOutcome = () => Effect.undefined; + yield* Deferred.succeed(releaseWorkRace, undefined); + // Settle the stale callback while the second subagent still holds the turn open. + yield* Queue.take(deferredFinalized); + assert.deepEqual(yield* Queue.clear(terminals), []); + + yield* emitSubagent("tool-call-generic-2", "completed"); + yield* Queue.take(deferredScheduled); + yield* TestClock.adjust("3000 millis"); + const secondTerminal = yield* Queue.take(terminals); + yield* Queue.take(deferredFinalized); + assert.equal(secondTerminal.status, "completed"); + + subagentStatuses.set("tool-call-generic-1", "running"); + yield* startTurn(3); + yield* Queue.take(promptSettled); + assert.deepEqual( + promptRuntimes, + [1, 2, 2], + "discarded deferred failure must not restart runtime", + ); + + const interruptRaceStarted = yield* Deferred.make(); + const releaseInterruptRace = yield* Deferred.make(); + nextOutcome = () => + Deferred.succeed(interruptRaceStarted, undefined).pipe( + Effect.andThen(Deferred.await(releaseInterruptRace)), + Effect.as({ failure: quota, threadDisposition: "reusable" }), + ); + yield* emitSubagent("tool-call-generic-1", "completed"); + yield* Queue.take(deferredScheduled); + yield* TestClock.adjust("3000 millis"); + yield* Deferred.await(interruptRaceStarted); + + yield* runtime.interruptTurn({ + providerThread, + providerTurnId: idAllocator.derive.providerTurn({ + driver: ACP_TEST_DRIVER, + nativeTurnId: acpScopedNativeId(instanceId, "mock-session-1:turn:3"), + }), + }); + const thirdTerminal = yield* Queue.take(terminals); + assert.equal(thirdTerminal.status, "interrupted"); + + nextOutcome = () => Effect.undefined; + yield* Deferred.succeed(releaseInterruptRace, undefined); + yield* Queue.take(deferredFinalized); + assert.deepEqual(yield* Queue.clear(terminals), []); + + subagentStatuses.set("tool-call-generic-1", "completed"); + yield* startTurn(4); + const fourthTerminal = yield* Queue.take(terminals); + assert.equal(fourthTerminal.status, "completed"); + assert.deepEqual( + promptRuntimes, + [1, 2, 2, 2], + "interrupted deferred check must not restart runtime", + ); + }).pipe(Effect.provide(layerTest)), + ); it.live("retains returned usage when Stop finalizes before the prompt callback", () => Effect.gen(function* () { const instanceId = ProviderInstanceId.make("acp-test-prompt-usage-stop"); diff --git a/packages/provider-acp/src/server/adapter.ts b/packages/provider-acp/src/server/adapter.ts index 144943368c1d..9b10eeb431dd 100644 --- a/packages/provider-acp/src/server/adapter.ts +++ b/packages/provider-acp/src/server/adapter.ts @@ -787,6 +787,7 @@ export interface AcpAdapterV2Options { }; readonly testHooks?: { readonly onDeferredFinalizeScheduled?: (debounce: Duration.Input) => Effect.Effect; + readonly afterDeferredFinalize?: () => Effect.Effect; /** `cancelAfterPromptStarts`: Stop is holding `session/cancel` until the prompt starts. */ readonly onCancelHeld?: () => Effect.Effect; readonly afterPromptWireSettled?: () => Effect.Effect; @@ -1726,6 +1727,9 @@ interface ActiveAcpTurn { /** Completed when an update after dispatch matches `cancelAfterPromptStarts.isStart`. */ readonly promptStarted: Deferred.Deferred; promptUsage: EffectAcpSchema.Usage | undefined; + checkPromptOutcome: + | Effect.Success>> + | undefined; backgroundFinalizeGeneration: number; /** `replyEndsWithUsageUpdate`: output arrived and its closing `usage_update` has not. */ replyOpen: boolean; @@ -8731,6 +8735,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( if (hasDeferredBackgroundWork(context)) return; context.backgroundFinalizeGeneration += 1; const generation = context.backgroundFinalizeGeneration; + const runtimeGeneration = yield* Ref.get(runtimeCallbackGeneration); const replyOpen = context.replyOpen; const debounce = replyOpen ? ACP_OPEN_REPLY_QUIET_LIMIT : ACP_DEFERRED_FINALIZE_DEBOUNCE; yield* Effect.gen(function* () { @@ -8752,8 +8757,49 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( return; } const status = context.promptSettledStatus ?? "completed"; - yield* finalizeTurn(context, status); - }).pipe(Effect.forkIn(sessionScope), Effect.asVoid); + const checkPromptOutcome = + status === "completed" ? context.checkPromptOutcome : undefined; + if (checkPromptOutcome === undefined) { + yield* finalizeTurn(context, status); + return; + } + if ( + (yield* Ref.get(runtimeTeardownState))._tag !== "Idle" || + (yield* Ref.get(runtimeCallbackGeneration)) !== runtimeGeneration + ) { + return; + } + // A completed status implies the prompt ended with end_turn. + const hiddenFailure = yield* Effect.suspend(() => + checkPromptOutcome({ stopReason: "end_turn" }), + ).pipe( + Effect.catchDefect((defect) => + Effect.logWarning("Could not check deferred ACP prompt outcome.", defect).pipe( + Effect.as(undefined), + ), + ), + ); + yield* runRuntimeCallbackAtGeneration( + runtimeGeneration, + Effect.gen(function* () { + if (!stillCurrent()) return; + if (hiddenFailure !== undefined) { + yield* Ref.set(runtimeRestartRequired, true); + yield* terminalizeOpenForegroundTools(context, "failed"); + yield* finalizeTurn(context, "failed", hiddenFailure.failure, { + childTurnsContinue: hasSurvivingBackgroundWork(context), + threadDisposition: hiddenFailure.threadDisposition, + }); + return; + } + yield* finalizeTurn(context, status); + }), + ); + }).pipe( + Effect.andThen(() => options.testHooks?.afterDeferredFinalize?.() ?? Effect.void), + Effect.forkIn(sessionScope), + Effect.asVoid, + ); yield* options.testHooks?.onDeferredFinalizeScheduled?.(debounce) ?? Effect.void; }); @@ -9443,6 +9489,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( promptSentAt: null, promptStarted, promptUsage: undefined, + checkPromptOutcome: undefined, backgroundFinalizeGeneration: 0, replyOpen: false, nativePromptId: undefined, @@ -9599,6 +9646,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( flavor.watchPromptOutcome === undefined ? undefined : yield* flavor.watchPromptOutcome(requestedSessionId); + context.checkPromptOutcome = checkPromptOutcome; const promptGeneration = yield* Ref.get(runtimeCallbackGeneration); const promptOptions = { dispatched: context.promptDispatched, @@ -9700,6 +9748,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( context.promptSettled = false; context.promptSettledStatus = null; context.backgroundFinalizeGeneration += 1; + context.checkPromptOutcome = checkPromptOutcome; context.promptSentAt = yield* Clock.currentTimeMillis; context.lastProgressAt = context.promptSentAt; const watchdog = context.inactivityWatchdog; From 318d7f3c93088dab523737f129b595f98818efd6 Mon Sep 17 00:00:00 2001 From: kyle Date: Sat, 21 Nov 2026 10:20:48 +0100 Subject: [PATCH 2/3] test(provider-acp): tighten deferred finalize race wait, bound warning log, and add Antigravity E2E test --- .../Adapters/AcpAdapterV2.test.ts | 23 +++--- .../Adapters/AntigravityAdapterV2.test.ts | 70 +++++++++++++++++++ packages/provider-acp/src/server/adapter.ts | 15 ++-- 3 files changed, 92 insertions(+), 16 deletions(-) diff --git a/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts index 9b32899cb0bc..d9f9c4352fe0 100644 --- a/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts @@ -1669,7 +1669,7 @@ describe("AcpAdapterV2", () => { let nextOutcome: () => Effect.Effect = () => Effect.undefined; const promptSettled = yield* Queue.unbounded(); const deferredScheduled = yield* Queue.unbounded(); - const deferredFinalized = yield* Queue.unbounded(); + let nextDeferredFinalized: Deferred.Deferred | undefined; const adapter = yield* makeAcpAdapterV2({ instanceId, selfInvocation, @@ -1678,8 +1678,13 @@ describe("AcpAdapterV2", () => { Queue.offer(promptSettled, undefined).pipe(Effect.asVoid), onDeferredFinalizeScheduled: () => Queue.offer(deferredScheduled, undefined).pipe(Effect.asVoid), - afterDeferredFinalize: () => - Queue.offer(deferredFinalized, undefined).pipe(Effect.asVoid), + afterDeferredFinalize: () => { + const milestone = nextDeferredFinalized; + nextDeferredFinalized = undefined; + return milestone === undefined + ? Effect.void + : Deferred.succeed(milestone, undefined).pipe(Effect.asVoid); + }, }, flavor: { driver: ACP_TEST_DRIVER, @@ -1790,7 +1795,6 @@ describe("AcpAdapterV2", () => { yield* TestClock.adjust("3000 millis"); const firstTerminal = yield* Queue.take(terminals); - yield* Queue.take(deferredFinalized); assert.equal(firstTerminal.status, "failed"); assert.deepEqual(firstTerminal.failure, quota); assert.equal(firstTerminal.threadDisposition, "broken"); @@ -1815,17 +1819,18 @@ describe("AcpAdapterV2", () => { yield* Deferred.await(workRaceStarted); yield* emitSubagent("tool-call-generic-2", "running", "tool_call"); + const workRaceSettled = yield* Deferred.make(); + nextDeferredFinalized = workRaceSettled; nextOutcome = () => Effect.undefined; yield* Deferred.succeed(releaseWorkRace, undefined); - // Settle the stale callback while the second subagent still holds the turn open. - yield* Queue.take(deferredFinalized); + // Settle the exact blocked attempt while the second subagent still holds the turn open. + yield* Deferred.await(workRaceSettled); assert.deepEqual(yield* Queue.clear(terminals), []); yield* emitSubagent("tool-call-generic-2", "completed"); yield* Queue.take(deferredScheduled); yield* TestClock.adjust("3000 millis"); const secondTerminal = yield* Queue.take(terminals); - yield* Queue.take(deferredFinalized); assert.equal(secondTerminal.status, "completed"); subagentStatuses.set("tool-call-generic-1", "running"); @@ -1859,9 +1864,11 @@ describe("AcpAdapterV2", () => { const thirdTerminal = yield* Queue.take(terminals); assert.equal(thirdTerminal.status, "interrupted"); + const interruptRaceSettled = yield* Deferred.make(); + nextDeferredFinalized = interruptRaceSettled; nextOutcome = () => Effect.undefined; yield* Deferred.succeed(releaseInterruptRace, undefined); - yield* Queue.take(deferredFinalized); + yield* Deferred.await(interruptRaceSettled); assert.deepEqual(yield* Queue.clear(terminals), []); subagentStatuses.set("tool-call-generic-1", "completed"); diff --git a/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.test.ts index fca472c6c433..b5c50f66ee05 100644 --- a/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.test.ts @@ -1,3 +1,6 @@ +// @effect-diagnostics nodeBuiltinImport:off -- node:sqlite writes the native Antigravity session log fixture. +import * as NodeSqlite from "node:sqlite"; + import * as NodeCrypto from "@effect/platform-node/NodeCrypto"; import * as NodeServices from "@effect/platform-node/NodeServices"; import { assert, describe, it } from "@effect/vitest"; @@ -1349,6 +1352,73 @@ describe("AntigravityAdapterV2 work after the prompt ends", () => { }).pipe(Effect.provide(layerSession)), ); + it.effect("fails deferred finalize when Antigravity logs a post-background quota error", () => + Effect.gen(function* () { + const fileSystem = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const profile = yield* fileSystem.makeTempDirectoryScoped({ + prefix: "t3-agy-deferred-quota-", + }); + const conversations = path.join(profile, "antigravity-acp", "conversations"); + yield* fileSystem.makeDirectory(conversations, { recursive: true }); + const appendStep = (stepIndex: number, stepType: number, payload: Uint8Array) => { + const database = new NodeSqlite.DatabaseSync(path.join(conversations, "mock-session-1.db")); + try { + database.exec( + "CREATE TABLE IF NOT EXISTS steps (idx INTEGER PRIMARY KEY, step_type INTEGER, step_payload BLOB)", + ); + database.prepare("INSERT INTO steps VALUES (?, ?, ?)").run(stepIndex, stepType, payload); + } finally { + database.close(); + } + }; + + const { command, usage, offers, send, startTurn, until, throughPromptSettled } = + yield* openSessionWithRunningCommand({ WaitMsBeforeAsync: 10000 }, undefined, undefined, { + profileDirectory: profile, + }); + yield* startTurn(1, false); + yield* throughPromptSettled; + + // Command finishes and wakes the model; during the wake Antigravity hits a 429 quota error + // and writes CORTEX_STEP_TYPE_ERROR_MESSAGE (17) into its native conversation log. + yield* send({ + sessionUpdate: "tool_call_update", + ...command, + status: "completed", + rawOutput: { output: "Command exited with code 0.", exit_code: 0 }, + }); + appendStep( + 1, + 17, + Buffer.concat([ + Buffer.from([0x0a, 0x24]), + Buffer.from( + "Agent execution terminated due to error.\u0012agent executor error: Error 429, Message: Quota exhausted for test model., Status: RESOURCE_EXHAUSTED, Details: [map[@type:type.googleapis.com/google.rpc.ErrorInfo domain:googleapis.com metadata:map[quotaResetTimeStamp:2030-01-01T00:00:00Z] reason:QUOTA_EXHAUSTED]]", + ), + ]), + ); + yield* send(usage); + yield* TestClock.adjust("3 seconds"); + + const run = yield* until((event) => event.type === "turn.terminal"); + const terminal = run.at(-1); + assert.equal(terminal?.type, "turn.terminal"); + if (terminal?.type === "turn.terminal") { + assert.equal(terminal.status, "failed"); + assert.deepEqual(terminal.failure, { + class: "usage_limit", + message: "You have reached your Antigravity quota for this period.", + code: "RESOURCE_EXHAUSTED", + retryable: true, + resetAt: "2030-01-01T00:00:00.000Z", + }); + assert.equal(terminal.threadDisposition, "reusable"); + } + assert.lengthOf(offers, 0, "the open run needs no continuation"); + }).pipe(Effect.provide(layerSession)), + ); + // Command 2 finishes during reply 1; agy dequeues command 2 after reply 1's usage_update and // needs >3 s before streaming reply 2. Wait for reply 2 (bounded by the 2-minute quiet limit), // but still finalize at 3 s when both commands were batched into reply 1. diff --git a/packages/provider-acp/src/server/adapter.ts b/packages/provider-acp/src/server/adapter.ts index 61e55ed5c7bf..29a4b563619d 100644 --- a/packages/provider-acp/src/server/adapter.ts +++ b/packages/provider-acp/src/server/adapter.ts @@ -8763,6 +8763,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( status === "completed" ? context.checkPromptOutcome : undefined; if (checkPromptOutcome === undefined) { yield* finalizeTurn(context, status); + yield* options.testHooks?.afterDeferredFinalize?.() ?? Effect.void; return; } if ( @@ -8771,12 +8772,13 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( ) { return; } - // A completed status implies the prompt ended with end_turn. + // A completed status implies end_turn. Deferred finalization reports hidden failures + // directly rather than re-running followPrompt's resumeWith retry loop. const hiddenFailure = yield* Effect.suspend(() => checkPromptOutcome({ stopReason: "end_turn" }), ).pipe( - Effect.catchDefect((defect) => - Effect.logWarning("Could not check deferred ACP prompt outcome.", defect).pipe( + Effect.catchDefect(() => + Effect.logWarning("Could not check deferred ACP prompt outcome.").pipe( Effect.as(undefined), ), ), @@ -8797,11 +8799,8 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( yield* finalizeTurn(context, status); }), ); - }).pipe( - Effect.andThen(() => options.testHooks?.afterDeferredFinalize?.() ?? Effect.void), - Effect.forkIn(sessionScope), - Effect.asVoid, - ); + yield* options.testHooks?.afterDeferredFinalize?.() ?? Effect.void; + }).pipe(Effect.forkIn(sessionScope), Effect.asVoid); yield* options.testHooks?.onDeferredFinalizeScheduled?.(debounce) ?? Effect.void; }); From 86cef125e686f2216c2c14ab5d6e23db9caa18f2 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Sat, 21 Nov 2026 09:28:18 +0000 Subject: [PATCH 3/3] test(server): drop the Antigravity copy of the deferred finalize failure case AcpAdapterV2.test.ts already covers re-checking the prompt outcome before deferred finalize; test it at one layer. Co-Authored-By: Claude Opus 5.5 --- .../Adapters/AntigravityAdapterV2.test.ts | 70 ------------------- 1 file changed, 70 deletions(-) diff --git a/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.test.ts index b5c50f66ee05..fca472c6c433 100644 --- a/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.test.ts @@ -1,6 +1,3 @@ -// @effect-diagnostics nodeBuiltinImport:off -- node:sqlite writes the native Antigravity session log fixture. -import * as NodeSqlite from "node:sqlite"; - import * as NodeCrypto from "@effect/platform-node/NodeCrypto"; import * as NodeServices from "@effect/platform-node/NodeServices"; import { assert, describe, it } from "@effect/vitest"; @@ -1352,73 +1349,6 @@ describe("AntigravityAdapterV2 work after the prompt ends", () => { }).pipe(Effect.provide(layerSession)), ); - it.effect("fails deferred finalize when Antigravity logs a post-background quota error", () => - Effect.gen(function* () { - const fileSystem = yield* FileSystem.FileSystem; - const path = yield* Path.Path; - const profile = yield* fileSystem.makeTempDirectoryScoped({ - prefix: "t3-agy-deferred-quota-", - }); - const conversations = path.join(profile, "antigravity-acp", "conversations"); - yield* fileSystem.makeDirectory(conversations, { recursive: true }); - const appendStep = (stepIndex: number, stepType: number, payload: Uint8Array) => { - const database = new NodeSqlite.DatabaseSync(path.join(conversations, "mock-session-1.db")); - try { - database.exec( - "CREATE TABLE IF NOT EXISTS steps (idx INTEGER PRIMARY KEY, step_type INTEGER, step_payload BLOB)", - ); - database.prepare("INSERT INTO steps VALUES (?, ?, ?)").run(stepIndex, stepType, payload); - } finally { - database.close(); - } - }; - - const { command, usage, offers, send, startTurn, until, throughPromptSettled } = - yield* openSessionWithRunningCommand({ WaitMsBeforeAsync: 10000 }, undefined, undefined, { - profileDirectory: profile, - }); - yield* startTurn(1, false); - yield* throughPromptSettled; - - // Command finishes and wakes the model; during the wake Antigravity hits a 429 quota error - // and writes CORTEX_STEP_TYPE_ERROR_MESSAGE (17) into its native conversation log. - yield* send({ - sessionUpdate: "tool_call_update", - ...command, - status: "completed", - rawOutput: { output: "Command exited with code 0.", exit_code: 0 }, - }); - appendStep( - 1, - 17, - Buffer.concat([ - Buffer.from([0x0a, 0x24]), - Buffer.from( - "Agent execution terminated due to error.\u0012agent executor error: Error 429, Message: Quota exhausted for test model., Status: RESOURCE_EXHAUSTED, Details: [map[@type:type.googleapis.com/google.rpc.ErrorInfo domain:googleapis.com metadata:map[quotaResetTimeStamp:2030-01-01T00:00:00Z] reason:QUOTA_EXHAUSTED]]", - ), - ]), - ); - yield* send(usage); - yield* TestClock.adjust("3 seconds"); - - const run = yield* until((event) => event.type === "turn.terminal"); - const terminal = run.at(-1); - assert.equal(terminal?.type, "turn.terminal"); - if (terminal?.type === "turn.terminal") { - assert.equal(terminal.status, "failed"); - assert.deepEqual(terminal.failure, { - class: "usage_limit", - message: "You have reached your Antigravity quota for this period.", - code: "RESOURCE_EXHAUSTED", - retryable: true, - resetAt: "2030-01-01T00:00:00.000Z", - }); - assert.equal(terminal.threadDisposition, "reusable"); - } - assert.lengthOf(offers, 0, "the open run needs no continuation"); - }).pipe(Effect.provide(layerSession)), - ); - // Command 2 finishes during reply 1; agy dequeues command 2 after reply 1's usage_update and // needs >3 s before streaming reply 2. Wait for reply 2 (bounded by the 2-minute quiet limit), // but still finalize at 3 s when both commands were batched into reply 1.