diff --git a/packages/provider-opencode/src/server/adapter.test.ts b/packages/provider-opencode/src/server/adapter.test.ts index 2eb62547185e6..c46b34e0a51c6 100644 --- a/packages/provider-opencode/src/server/adapter.test.ts +++ b/packages/provider-opencode/src/server/adapter.test.ts @@ -635,6 +635,324 @@ describe("OpenCodeAdapterV2", () => { }).pipe(Effect.provide(Layer.merge(IdAllocator.layer, McpProviderSessions.layer))), ); + for (const message of [ + "GoUsageLimitError: weekly usage limit reached", + "FreeUsageLimitError", + "account_rate_limit", + "free_tier_limit", + "Rate limit exceeded", + "structured quota", + ]) { + it.effect(`stops quota retry: ${message}; ignores late events and isolates replacement`, () => + Effect.gen(function* () { + const nativeEvents = asyncEventStream(); + const aborts: string[] = []; + let creates = 0; + let promptId = ""; + const harness = yield* makeOpenCodeRuntimeHarness("quota-retry", "root", { + event: { subscribe: async () => ({ stream: nativeEvents.stream }) }, + session: { + create: async () => ({ + data: { + id: ++creates === 1 ? "root" : "replacement", + time: { created: 1, updated: 1 }, + }, + }), + promptAsync: async (input: { messageID: string }) => { + promptId = input.messageID; + return { data: true }; + }, + abort: async (input: { sessionID: string }) => { + aborts.push(input.sessionID); + return { data: true }; + }, + children: async () => ({ data: [] }), + }, + }); + yield* harness.startTurn(); + const firstTerminal = yield* Deferred.make(); + let terminalCount = 0; + const received = yield* harness.runtime.events.pipe( + Stream.filter((e) => e.type === "turn.terminal"), + Stream.tap(() => + Effect.sync(() => { + terminalCount++; + }).pipe(Effect.andThen(Deferred.succeed(firstTerminal, undefined))), + ), + Stream.take(2), + Stream.runCollect, + Effect.forkScoped, + ); + const now = yield* DateTime.now; + yield* Effect.promise(() => + nativeEvents.push({ + type: "session.status", + properties: { + sessionID: "root", + status: { + type: "retry", + message, + ...(["structured quota", "account_rate_limit", "free_tier_limit"].includes(message) + ? { + action: { + reason: + message === "free_tier_limit" ? "free_tier_limit" : "account_rate_limit", + message: "wait", + provider: "go", + title: "Limit", + label: "Upgrade", + }, + } + : {}), + attempt: 1, + next: DateTime.toEpochMillis(now) + 7 * 86_400_000, + }, + }, + }), + ); + yield* Deferred.await(firstTerminal); + assert.deepEqual(aborts, ["root"]); + assert.equal((yield* Effect.exit(harness.startTurn()))._tag, "Failure"); + const replacement = yield* harness.runtime.ensureThread({ + threadId: ThreadId.make("thread-opencode-replacement"), + modelSelection: { + instanceId: ProviderInstanceId.make("opencode-quota-retry"), + model: "anthropic/claude-sonnet", + options: [], + }, + runtimePolicy: harness.policy, + }); + yield* harness.startTurn("replacement", replacement, harness.policy, false, "replacement"); + yield* Effect.promise(() => + nativeEvents.push({ + type: "message.updated", + properties: { + sessionID: "replacement", + info: { id: promptId, role: "user", time: { created: 1 } }, + }, + }), + ); + for (const event of [ + { type: "session.idle", properties: { sessionID: "root" } }, + { type: "session.status", properties: { sessionID: "root", status: { type: "idle" } } }, + { + type: "session.error", + properties: { + sessionID: "root", + error: { name: "MessageAbortedError", data: { message: "aborted" } }, + }, + }, + { + type: "session.error", + properties: { + sessionID: "root", + error: { + name: "APIError", + data: { message: "quota", statusCode: 429, isRetryable: true }, + }, + }, + }, + ]) + yield* Effect.promise(() => nativeEvents.push(event)); + assert.equal(terminalCount, 1); + yield* Effect.promise(() => + nativeEvents.push({ type: "session.idle", properties: { sessionID: "replacement" } }), + ); + nativeEvents.close(); + const events = yield* Fiber.join(received); + const terminals = events.filter((e) => e.type === "turn.terminal"); + assert.equal(terminals.length, 2); + assert.equal(terminals[0]?.status, "failed"); + assert.equal(terminals[0]?.failure?.class, "usage_limit"); + assert.include(terminals[0]?.failure?.message ?? "", message); + assert.equal(terminals[0]?.threadDisposition, "broken"); + assert.equal(terminals[1]?.status, "completed"); + }).pipe(Effect.provide(Layer.merge(IdAllocator.layer, McpProviderSessions.layer))), + ); + } + + for (const message of [ + "429: Rate limit exceeded", + "503: service unavailable", + "429: per-minute token usage limit exceeded; retry in 1 second", + "503: upstream overload; account_rate_limit=false", + '503: upstream overload; "free_tier_limit":false', + ]) { + it.effect(`surfaces a short retry and completes normally: ${message}`, () => + Effect.gen(function* () { + const nativeEvents = asyncEventStream(); + let aborts = 0; + let promptId = ""; + const harness = yield* makeOpenCodeRuntimeHarness("transient-retry", "root", { + event: { subscribe: async () => ({ stream: nativeEvents.stream }) }, + session: { + create: async () => ({ data: { id: "root", time: { created: 1, updated: 1 } } }), + promptAsync: async (input: { messageID: string }) => { + promptId = input.messageID; + return { data: true }; + }, + abort: async () => { + aborts++; + return { data: true }; + }, + children: async () => ({ data: [] }), + }, + }); + yield* harness.startTurn(); + const received = yield* harness.runtime.events.pipe( + Stream.takeUntil((e) => e.type === "turn.terminal"), + Stream.runCollect, + Effect.forkScoped, + ); + const now = yield* DateTime.now; + const next = DateTime.toEpochMillis(now) + (message.includes("false") ? 300_000 : 1_000); + yield* Effect.promise(() => + nativeEvents.push({ + type: "message.updated", + properties: { + sessionID: "root", + info: { id: promptId, role: "user", time: { created: 1 } }, + }, + }), + ); + yield* Effect.promise(() => + nativeEvents.push({ + type: "session.status", + properties: { sessionID: "root", status: { type: "retry", message, attempt: 1, next } }, + }), + ); + yield* Effect.promise(() => + nativeEvents.push({ type: "session.idle", properties: { sessionID: "root" } }), + ); + const events = yield* Fiber.join(received); + assert.equal(aborts, 0); + const notice = events.find( + (e) => e.type === "turn_item.updated" && e.turnItem.type === "system_notice", + ); + assert.isDefined(notice); + if (notice?.type === "turn_item.updated" && notice.turnItem.type === "system_notice") { + assert.include(notice.turnItem.message, message); + assert.include(notice.turnItem.message, DateTime.formatIso(DateTime.makeUnsafe(next))); + } + assert.equal(events.find((e) => e.type === "turn.terminal")?.status, "completed"); + }).pipe(Effect.provide(Layer.merge(IdAllocator.layer, McpProviderSessions.layer))), + ); + } + + it.effect("quota owns terminal when abort rejects a pending prompt submission", () => + Effect.gen(function* () { + const nativeEvents = asyncEventStream(); + const submitted = promiseGate(); + let rejectPrompt!: (reason: Error) => void; + const prompt = new Promise<{ data: boolean }>((_resolve, reject) => { + rejectPrompt = reject; + }); + const harness = yield* makeOpenCodeRuntimeHarness("quota-prompt-race", "root", { + event: { subscribe: async () => ({ stream: nativeEvents.stream }) }, + session: { + create: async () => ({ data: { id: "root", time: { created: 1, updated: 1 } } }), + promptAsync: async () => { + submitted.resolve(); + return prompt; + }, + abort: async () => { + rejectPrompt(new Error("submission aborted")); + await Promise.resolve(); + return { data: true }; + }, + children: async () => ({ data: [] }), + }, + }); + const starting = yield* harness.startTurn().pipe(Effect.exit, Effect.forkScoped); + yield* Effect.promise(() => submitted.promise); + yield* Effect.promise(() => + nativeEvents.push({ + type: "session.status", + properties: { + sessionID: "root", + status: { + type: "retry", + message: "GoUsageLimitError", + attempt: 1, + next: 2_000_000_000_000, + }, + }, + }), + ); + // The orchestration caller cancels ingestion on a failed start. Keep the + // terminal queued until startup returns, so consumption cannot hide the race. + assert.equal((yield* Fiber.join(starting))._tag, "Success"); + const terminal = yield* harness.runtime.events.pipe( + Stream.filter((e) => e.type === "turn.terminal"), + Stream.runHead, + ); + assert(Option.isSome(terminal)); + assert.equal(terminal.value.status, "failed"); + assert.equal(terminal.value.failure?.class, "usage_limit"); + assert.equal(terminal.value.failure?.code, "usage_limit"); + assert.equal(terminal.value.threadDisposition, "broken"); + }).pipe(Effect.provide(Layer.merge(IdAllocator.layer, McpProviderSessions.layer))), + ); + + it.effect("finalizes quota failure even when native abort never answers", () => + Effect.gen(function* () { + const nativeEvents = asyncEventStream(); + const submitted = promiseGate(); + const abortCalled = promiseGate(); + let aborts = 0; + const harness = yield* makeOpenCodeRuntimeHarness("quota-abort-timeout", "root", { + event: { subscribe: async () => ({ stream: nativeEvents.stream }) }, + session: { + create: async () => ({ data: { id: "root", time: { created: 1, updated: 1 } } }), + promptAsync: async () => { + submitted.resolve(); + return new Promise(() => {}); + }, + abort: async () => { + if (++aborts > 1) return { data: true }; + abortCalled.resolve(); + return new Promise(() => {}); + }, + children: async () => ({ data: [] }), + }, + }); + const starting = yield* harness + .startTurn() + .pipe(Effect.timeout("1 second"), Effect.forkScoped); + yield* Effect.promise(() => submitted.promise); + const received = yield* harness.runtime.events.pipe( + Stream.takeUntil((e) => e.type === "turn.terminal"), + Stream.runCollect, + Effect.forkScoped, + ); + const pushed = yield* Effect.promise(() => + nativeEvents.push({ + type: "session.status", + properties: { + sessionID: "root", + status: { + type: "retry", + message: "GoUsageLimitError", + attempt: 1, + next: 2_000_000_000_000, + }, + }, + }), + ).pipe(Effect.forkScoped); + yield* Effect.promise(() => abortCalled.promise); + yield* TestClock.adjust("1 second"); + yield* Fiber.join(starting); + yield* TestClock.adjust("4 seconds"); + yield* Fiber.join(pushed); + const events = yield* Fiber.join(received); + assert.equal(events.filter((e) => e.type === "turn.terminal").length, 1); + const terminal = events.find((e) => e.type === "turn.terminal"); + assert.equal(terminal?.status, "failed"); + assert.equal(terminal?.failure?.class, "usage_limit"); + assert.equal(terminal?.threadDisposition, "broken"); + }).pipe(Effect.provide(Layer.merge(IdAllocator.layer, McpProviderSessions.layer))), + ); + it.effect("classifies APIError 429 as a usage limit", () => Effect.gen(function* () { const nativeEvents = asyncEventStream(); @@ -1570,6 +1888,7 @@ describe("OpenCodeAdapterV2", () => { { state: "settled", end: "foreground" }, { state: "settled", end: "foreground-buffered" }, { state: "settled", end: "foreground-buffered-error" }, + { state: "settled", end: "foreground-buffered-quota" }, { state: "settled", end: "foreground-stop" }, { state: "settled", end: "foreground-eof" }, { state: "settled", end: "invalid-continuation" }, @@ -1595,6 +1914,7 @@ describe("OpenCodeAdapterV2", () => { const push = (event: unknown) => Effect.promise(() => nativeEvents.push(event)); const root = "ses_root"; const promptIds: Array = []; + let creates = 0; const aborted: Array = []; const nativeExit = yield* Deferred.make(); const routeStarted = promiseGate(); @@ -1633,7 +1953,12 @@ describe("OpenCodeAdapterV2", () => { }, }, session: { - create: async () => ({ data: { id: root, time: { created: 1, updated: 1 } } }), + create: async () => ({ + data: { + id: ++creates > 1 && end === "foreground-buffered-quota" ? "fresh" : root, + time: { created: 1, updated: 1 }, + }, + }), get: async (input: { sessionID: string }) => { if (input.sessionID === "ses_unrelated" || input.sessionID === "ses_replay_child") { routeStarted.resolve(); @@ -2457,6 +2782,52 @@ describe("OpenCodeAdapterV2", () => { assert.equal(replacementSnapshot.providerTurns.at(-1)?.status, "running"); return; } + if (end === "foreground-buffered-quota") { + const receivedAt = DateTime.toEpochMillis(yield* DateTime.now); + yield* push({ + type: "session.status", + properties: { + sessionID: root, + status: { + type: "retry", + message: "429: rate limit exceeded", + attempt: 1, + next: receivedAt + 5 * 60_000, + }, + }, + }); + yield* TestClock.adjust("2 seconds"); + // No more native events: replay alone must settle admission and retire root. + const foreground = yield* harness + .startTurn("follow up", undefined, undefined, false, "next") + .pipe(Effect.timeout("1 second"), Effect.forkScoped); + yield* TestClock.adjust("1 second"); + yield* Fiber.join(foreground); + const events = yield* harness.runtime.events.pipe( + Stream.takeUntil((e) => e.type === "turn.terminal"), + Stream.runCollect, + ); + const terminal = events.find((e) => e.type === "turn.terminal"); + assert.equal(terminal?.status, "failed"); + assert.equal(terminal?.failure?.class, "usage_limit"); + assert.equal(terminal?.failure?.code, "usage_limit"); + assert.equal(terminal?.threadDisposition, "broken"); + assert.equal(promptIds.length, 1, "foreground never submits on retired native root"); + assert.equal((yield* Effect.exit(harness.startTurn()))._tag, "Failure"); + assert.include(aborted, root); + const fresh = yield* harness.runtime.ensureThread({ + threadId: ThreadId.make("thread-quota-fresh"), + modelSelection: { + instanceId: ProviderInstanceId.make("opencode-root-background-wake"), + model: "anthropic/claude-sonnet", + options: [], + }, + runtimePolicy: harness.policy, + }); + yield* harness.startTurn("retry", fresh, harness.policy, false, "fresh"); + assert.equal(promptIds.length, 2, "foreground recovery submits on fresh native session"); + return; + } const foreground = end === "foreground" || end === "foreground-stop" || end === "foreground-eof" ? yield* harness diff --git a/packages/provider-opencode/src/server/adapter.ts b/packages/provider-opencode/src/server/adapter.ts index e41dc10ec9038..3fbbb4627acb9 100644 --- a/packages/provider-opencode/src/server/adapter.ts +++ b/packages/provider-opencode/src/server/adapter.ts @@ -407,9 +407,14 @@ interface OpenCodeSubagentContext { launch: ToolPart | null; } +interface ReceivedOpenCodeEvent { + readonly event: OpenCodeEvent; + readonly quotaRetry: boolean; +} + /** Root work OpenCode began with no T3 turn, such as a background task's result; held until a run admits it. */ interface OpenCodeWake { - readonly events: Array; + readonly events: Array; // A user message alone can be a late update; only a busy root is work worth a run. offered: boolean; cancelling: boolean; @@ -910,6 +915,46 @@ function providerRef(nativeId: string, strength: "strong" | "weak" = "strong") { } satisfies OrchestrationV2ProviderRef; } +const OPENCODE_INTERACTIVE_RETRY_CEILING_MS = 5 * 60 * 1_000; + +function isOpenCodeQuotaRetry( + status: { + readonly message: string; + readonly next: number; + readonly action?: { readonly reason: string; readonly message: string }; + }, + now: number, +): boolean { + const identifiers = new Set([ + "account_rate_limit", + "free_tier_limit", + "GoUsageLimitError", + "FreeUsageLimitError", + ]); + const structuredQuota = (value: unknown): boolean => { + if (typeof value !== "object" || value === null) return false; + return ["reason", "code", "type"].some((key) => + identifiers.has(String(Reflect.get(value, key))), + ); + }; + if (structuredQuota(status) || structuredQuota(status.action)) return true; + // Text is evidence only of an explicit quota identifier/window, never a + // structured reason embedded in diagnostics (e.g. account_rate_limit=false). + return [status.message, status.action?.message ?? ""].some((message) => { + // Negative diagnostic fields do not become quota evidence merely because + // their identifier contains "rate_limit" or "tier_limit". + const diagnosticText = message.replace( + /["']?\b(?:account_rate_limit|free_tier_limit)\b["']?\s*[:=]\s*(?:false|null|0)\b/gi, + "", + ); + return ( + /\b(?:GoUsageLimitError|FreeUsageLimitError)\b|OpenCode Go usage limit reached|weekly.*resets in|5[ -]hour.*limit/i.test(message) || + (status.next - now >= OPENCODE_INTERACTIVE_RETRY_CEILING_MS && + /(?:rate|usage|quota)[ _-]?limit|quota.{0,20}(?:exhausted|exceeded)/i.test(diagnosticText)) + ); + }); +} + function openCodeErrorMessage(event: Extract): string { const error = event.properties.error; if (error === undefined) return "OpenCode session failed without an error payload."; @@ -1125,6 +1170,9 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function const relatedSessionOwners = new Map(); // Busy children outlive parent settlement; keep their server open. const busySessionIds = new Set(); + // v1 status/error events have no turn identity. Retire quota-stopped sessions so + // late abort events (or an abort that outlives its timeout) cannot hit a new turn. + const quotaStoppedSessionIds = new Set(); // A background task returns before its new child session reports busy. const unstartedSessionIds = new Set(); // A child can error before any turn of it is projected; its next idle settles the launch. @@ -2890,13 +2938,15 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function // Callers hold eventPermit. A root user message with no T3 turn starts a wake; its work stays // held, with that of children no turn has claimed yet, until startTurn takes it. - const acceptEvent = Effect.fnUntraced(function* (event: OpenCodeEvent) { + const acceptEvent = Effect.fnUntraced(function* (received: ReceivedOpenCodeEvent) { + const { event } = received; const sessionId = sessionWorkEventSessionId(event); + if (sessionId !== undefined && quotaStoppedSessionIds.has(sessionId)) return; const owner = sessionId === undefined ? undefined : (threads.get(sessionId) ?? relatedSessionOwners.get(sessionId)); - if (owner === undefined || sessionId === undefined) return yield* routeEvent(event); + if (owner === undefined || sessionId === undefined) return yield* routeEvent(received); const wake = owner.wake; const isRoot = sessionId === owner.nativeSessionId; const rootStatus = @@ -2909,7 +2959,7 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function event.type === "message.updated" && event.properties.info.role === "user" && !wake.events.some( - (held) => + ({ event: held }) => held.type === "message.updated" && held.properties.info.id === event.properties.info.id, ); @@ -2921,8 +2971,8 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function wake.settled = Deferred.makeUnsafe(); } if (wake?.cancelling) { - if (!isRoot) return yield* routeEvent(event); - wake.events.push(event); + if (!isRoot) return yield* routeEvent(received); + wake.events.push(received); if (isRoot && (rootStatus === "busy" || rootStatus === "retry")) { wake.offered = true; yield* Deferred.succeed(wake.admission, true); @@ -2954,7 +3004,7 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function yield* Deferred.succeed(wake.admission, false); owner.wake = null; } else if (wake !== null && (wake.offered || isRoot)) { - wake.events.push(event); + wake.events.push(received); if (!wake.offered && (rootStatus === "busy" || rootStatus === "retry")) { wake.offered = true; yield* Deferred.succeed(wake.admission, true); @@ -2976,7 +3026,7 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function ) { owner.userMessageIds.push(event.properties.info.id); owner.wake = { - events: [event], + events: [received], offered: false, cancelling: false, admission: Deferred.makeUnsafe(), @@ -2984,10 +3034,18 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function }; return; } - yield* routeEvent(event); + yield* routeEvent(received); }); const handleEvent = Effect.fnUntraced(function* (event: OpenCodeEvent) { + // A retry deadline is relative to receipt, even when routing or wake takeover waits. + const quotaRetry = + event.type === "session.status" && + event.properties.status.type === "retry" && + isOpenCodeQuotaRetry( + event.properties.status, + DateTime.toEpochMillis(yield* DateTime.now), + ); yield* logProtocolEvent({ direction: "incoming", messageKind: "notification", @@ -2995,11 +3053,11 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function payload: event, }); // A slow native call only delays events, as on main; Stop goes through lifecyclePermit. - yield* eventPermit.withPermit(acceptEvent(event)); + yield* eventPermit.withPermit(acceptEvent({ event, quotaRetry })); }); const routeEvent = Effect.fnUntraced(function* ( - event: OpenCodeEvent, + { event, quotaRetry }: ReceivedOpenCodeEvent, historicalRootSessionId?: string, ) { const historicalRoot = @@ -3008,11 +3066,14 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function // A foreground prompt inherits held output, but has not submitted its own native work yet. if ( historicalRoot && + !quotaRetry && (event.type === "session.status" || event.type === "session.idle" || event.type === "session.error") ) return; + const eventSessionId = sessionWorkEventSessionId(event); + if (eventSessionId !== undefined && quotaStoppedSessionIds.has(eventSessionId)) return; switch (event.type) { case "server.connected": if (hasConnected) { @@ -3107,6 +3168,60 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function if (state.activeTurn?.admissionPending) { state.activeTurn.admissionStatusSequence++; } + const retry = event.properties.status; + const turn = state.activeTurn; + if (retry.type === "retry" && turn !== null && !turn.finalized) { + if (quotaRetry) { + quotaStoppedSessionIds.add(sessionId); + busySessionIds.delete(sessionId); + const failure = makeProviderFailure({ + message: `OpenCode quota limit: ${retry.message} (retry at ${DateTime.formatIso(DateTime.makeUnsafe(retry.next))}). Start a new provider thread after quota resets or select another provider.`, + code: "usage_limit", + class: "usage_limit", + }); + // Claim terminal ownership before abort can reject a pending prompt. + // Historical wake transfer also settles priorWakeSettled here; the + // foreground must recover on a fresh session, never wait for quota reset. + yield* finalizeTurn(state, turn, turn.interrupted ? "interrupted" : "failed", { + failure, + threadDisposition: "broken", + }); + // Startup must succeed so orchestration keeps ingesting the queued terminal. + yield* Deferred.succeed(turn.admissionSettled, undefined); + yield* updateProviderSession("error", failure.message); + yield* abortRootSession(state).pipe(Effect.timeout("5 seconds"), Effect.ignore); + return; + } + const now = yield* DateTime.now; + const nativeItemId = `${turn.providerTurnId}:retry:${retry.attempt}`; + yield* emitProviderEvent({ + type: "turn_item.updated", + driver: OPENCODE_PROVIDER, + turnItem: { + id: idAllocator.derive.turnItemFromProviderItem({ + driver: OPENCODE_PROVIDER, + nativeItemId, + }), + threadId: turn.threadId, + runId: turn.runId, + nodeId: turn.rootNodeId, + providerThreadId: state.providerThread.id, + providerTurnId: turn.providerTurnId, + nativeItemRef: providerRef(nativeItemId, "weak"), + parentItemId: null, + ordinal: itemOrdinal(turn, nativeItemId), + type: "system_notice", + title: "OpenCode retry", + level: "warning", + status: "completed", + message: `OpenCode retry ${retry.attempt}: ${retry.message} (retry at ${DateTime.formatIso(DateTime.makeUnsafe(retry.next))}).`, + startedAt: now, + completedAt: now, + updatedAt: now, + }, + }); + return; + } if (event.properties.status.type === "busy") { yield* updateProviderThread(state, { status: "active" }); return; @@ -3829,6 +3944,11 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function "OpenCode event stream has ended; reconnect the provider session before starting another turn.", ); } + if (quotaStoppedSessionIds.has(sessionId)) { + return yield* protocolError( + "OpenCode session stopped at a quota limit; start a new provider thread.", + ); + } if (state.activeTurn !== null) { return yield* new ProviderAdapter.ProviderAdapterProtocolError({ driver: OPENCODE_PROVIDER, @@ -3851,7 +3971,7 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function }); yield* updateProviderSession("running", null); if (!continuation) { - for (const event of wake?.events ?? []) { + for (const { event } of wake?.events ?? []) { if ( event.type === "message.updated" && event.properties.sessionID === sessionId && @@ -3949,15 +4069,20 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function turnInput.message.text, ).pipe( Effect.tapError((cause) => - admissionAbortController!.signal.aborted + quotaStoppedSessionIds.has(sessionId) || admissionAbortController!.signal.aborted ? Effect.void : finalizeTurn(state, turn, "failed", { failure: makeProviderFailure({ cause, class: "provider_error" }), }), ), - Effect.catch((cause) => - admissionAbortController!.signal.aborted ? Effect.void : Effect.fail(cause), - ), + Effect.catch((cause) => { + if (quotaStoppedSessionIds.has(sessionId)) + return Deferred.await(admissionSettled); + return admissionAbortController!.signal.aborted + ? Effect.void + : Effect.fail(cause); + }), + Effect.raceFirst(Deferred.await(admissionSettled)), Effect.ensuring( Effect.all([ Deferred.succeed(admissionSettled, undefined).pipe(Effect.ignore),