@devries-cameron20 / t3code-1 / commits / aac28657cf
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

fix(server): OpenCode 2 turns show provider retries instead of silently running (#15672)

Co-authored-by: Julius Marminge <julius0216@outlook.com>

Shoubhit Dash committed Oct 20, 2026 at 11:35 UTC aac28657cf6a5fb03dc40e4b46b9c85490dac75b
2 files changed +369 -2
apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts
+264 -1
@@ -19,6 +19,7 @@ import {
19 ThreadId,
20 type ModelSelection,
21 type OrchestrationV2AppThread,
22 + type OrchestrationV2ProviderFailure,
23 type OrchestrationV2ProviderThread,
24 type OrchestrationV2ProviderTurn,
25 type ProviderReplayEntry,
@@ -2965,7 +2966,11 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => {
2966 );
2967 }).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
2968 );
2968 - const reconnected = (active: Record<string, unknown>, ended?: "succeeded") => [
2969 + const reconnected = (
2970 + active: Record<string, unknown>,
2971 + ended?: "succeeded",
2972 + assistant: Record<string, unknown> = {},
2973 + ) => [
2974 { type: "runtime_exit", status: "success" } as const,
2975 out("event.subscribe"),
2976 out("session.active"),
@@ -3000,6 +3005,7 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => {
3005 },
3006 ],
3007 finish: "stop",
3008 + ...assistant,
3009 },
3010 {
3011 id: "msg_0eb735d41001NJee1EvVePJAK5",
@@ -3890,6 +3896,263 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => {
3896 }).pipe(Effect.scoped),
3897 );
3898
3899 + const ASSISTANT = "msg_0eb735d5b001oAFVeY5jz3WD4Z";
3900 + const rateLimited = {
3901 + type: "provider.rate-limit",
3902 + message: "Rate limit exceeded: free-models-per-min.",
3903 + status: 429,
3904 + };
3905 + /**
3906 + * OpenCode numbers the request it retries with, so its first retry is
3907 + * attempt 2, and stamps `at` from the clock behind the event's `created` (1 here).
3908 + */
3909 + const retryScheduled = (attempt: number, delayMs: number) =>
3910 + event("session.retry.scheduled", {
3911 + sessionID: SESSION,
3912 + assistantMessageID: ASSISTANT,
3913 + attempt,
3914 + at: 1 + delayMs,
3915 + error: rateLimited,
3916 + });
3917 + const retrying = {
3918 + class: "provider_error",
3919 + message: rateLimited.message,
3920 + code: rateLimited.type,
3921 + retryable: true,
3922 + } satisfies OrchestrationV2ProviderFailure;
3923 + const firstRetry = { attempt: 1, maxAttempts: null, retryDelayMs: 2_000 };
3924 + const errorRows = (collected: ReadonlyArray<ProviderAdapter.ProviderAdapterV2Event>) =>
3925 + collected.flatMap((event) =>
3926 + event.type === "turn_item.updated" && event.turnItem.type === "error" ? [event.turnItem] : [],
3927 + );
3928 + const runRetryTurn = (entries: ReadonlyArray<ProviderReplayEntry>, gate?: ProviderReplayGate) =>
3929 + Effect.gen(function* () {
3930 + const { runtime, thread } = yield* resumed(
3931 + [
3932 + out("session.prompt", { sessionID: SESSION, text: "<any>" }),
3933 + promptAccepted,
3934 + event("session.execution.started", { sessionID: SESSION }),
3935 + ...entries,
3936 + ],
3937 + gate === undefined ? undefined : { replayGate: gate },
3938 + );
3939 + const retryShown = yield* Deferred.make<void>();
3940 + const collected = yield* runtime.events.pipe(
3941 + Stream.tap((event) =>
3942 + event.type === "turn_item.updated" && event.turnItem.type === "error"
3943 + ? Deferred.succeed(retryShown, undefined)
3944 + : Effect.void,
3945 + ),
3946 + Stream.takeUntil((event) => event.type === "turn.terminal"),
3947 + Stream.runCollect,
3948 + Effect.forkScoped,
3949 + );
3950 + yield* runtime.startTurn(turnInput(thread));
3951 + if (gate !== undefined) {
3952 + yield* Deferred.await(retryShown);
3953 + yield* TestClock.adjust("5 seconds");
3954 + gate.releaseAll();
3955 + }
3956 + return yield* Fiber.join(collected);
3957 + });
3958 +
3959 + it.effect.each([
3960 + {
3961 + name: "recovers a provider retry at the provider's first output",
3962 + after: [
3963 + event("session.text.started", {
3964 + sessionID: SESSION,
3965 + assistantMessageID: ASSISTANT,
3966 + ordinal: 0,
3967 + }),
3968 + event("session.text.ended", {
3969 + sessionID: SESSION,
3970 + assistantMessageID: ASSISTANT,
3971 + ordinal: 0,
3972 + text: "DONE",
3973 + }),
3974 + event("session.execution.succeeded", { sessionID: SESSION }),
3975 + ],
3976 + items: ["error:running", "error:completed", "assistant_message:completed"],
3977 + ended: "completed" as const,
3978 + title: "Provider recovered",
3979 + },
3980 + {
3981 + name: "stops a provider retry when the user stops the turn",
3982 + after: [event("session.execution.interrupted", { sessionID: SESSION, reason: "user" })],
3983 + items: ["error:running", "error:interrupted"],
3984 + ended: "interrupted" as const,
3985 + title: "Provider retry stopped",
3986 + },
3987 + ])("$name", ({ after, items, ended, title }) =>
3988 + Effect.gen(function* () {
3989 + const seen = yield* runRetryTurn([retryScheduled(2, 2_000), ...after]);
3990 + assert.deepEqual(turnItems(seen), items);
3991 + const rows = errorRows(seen);
3992 + assert.deepEqual(
3993 + rows.map(({ id, title, failure, retry }) => ({ id, title, failure, retry })),
3994 + [
3995 + { id: rows[0]!.id, title: "Provider retry", failure: retrying, retry: firstRetry },
3996 + { id: rows[0]!.id, title, failure: retrying, retry: firstRetry },
3997 + ],
3998 + );
3999 + assert.deepInclude(seen.at(-1), { type: "turn.terminal", status: ended, failure: null });
4000 + }).pipe(Effect.scoped),
4001 + );
4002 +
4003 + it.effect.each([
4004 + { name: "restores retry pending at reconnect", pending: true, streamed: false },
4005 + { name: "settles retry recovered during drop", pending: false, streamed: false },
4006 + { name: "keeps retry pending when only streamed at reconnect", pending: true, streamed: true },
4007 + ])("$name", ({ pending, streamed }) =>
4008 + Effect.gen(function* () {
4009 + const gate = makeProviderReplayGate(["finish"]);
4010 + const { runtime, thread } = yield* resumed(
4011 + [
4012 + out("session.prompt", { sessionID: SESSION, id: PROMPT_ID, text: "<any>" }),
4013 + promptAccepted,
4014 + event("session.execution.started", { sessionID: SESSION }),
4015 + ...(pending && !streamed ? [] : [retryScheduled(2, 2_000)]),
4016 + ...reconnected({ [SESSION]: { type: "running" } }, undefined, {
4017 + id: ASSISTANT,
4018 + finish: undefined,
4019 + content: pending ? [] : [{ type: "text", text: "Recovered during the drop." }],
4020 + ...(pending && !streamed
4021 + ? { retry: { attempt: 2, at: 2_001, error: rateLimited } }
4022 + : {}),
4023 + ...(streamed ? { time: { created: 2, streamed: 3 } } : {}),
4024 + }),
4025 + ...openRequests([shellAsk.data]),
4026 + event("session.execution.succeeded", { sessionID: SESSION }, "finish"),
4027 + ],
4028 + { supervised: true, replayGate: gate },
4029 + );
4030 + const events = yield* runtime.events.pipe(
4031 + Stream.takeUntil((event) => event.type === "turn.terminal"),
4032 + Stream.runCollect,
4033 + Effect.forkScoped,
4034 + );
4035 + yield* runtime.startTurn(turnInput(thread, bigPickle, "approval-required"));
4036 + yield* Effect.promise(() => gate.waitForReached("finish"));
4037 + gate.release("finish");
4038 + const collected = yield* Fiber.join(events);
4039 + // Reconciled requests follow backfill, before the terminal can settle the retry row.
4040 + const reconciled = collected.findIndex((event) => event.type === "runtime_request.updated");
4041 + assert.isAtLeast(reconciled, 0);
4042 + const seen = collected.slice(0, reconciled);
4043 + const rows = errorRows(seen);
4044 + assert.deepEqual(
4045 + rows.map(({ status, title }) => ({ status, title })),
4046 + pending
4047 + ? [{ status: "running", title: "Provider retry" }]
4048 + : [
4049 + { status: "running", title: "Provider retry" },
4050 + { status: "completed", title: "Provider recovered" },
4051 + ],
4052 + );
4053 + for (const row of rows) {
4054 + assert.deepEqual(row.failure, retrying);
4055 + assert.deepInclude(row.retry, { attempt: 1, maxAttempts: null });
4056 + assert.equal(row.id, rows[0]!.id);
4057 + assert.equal(row.ordinal, rows[0]!.ordinal);
4058 + assert.deepEqual(row.startedAt, rows[0]!.startedAt);
4059 + }
4060 + if (!pending) {
4061 + assert.isTrue(
4062 + seen.some(
4063 + (event) =>
4064 + event.type === "turn_item.updated" &&
4065 + event.turnItem.type === "assistant_message" &&
4066 + event.turnItem.text === "Recovered during the drop.",
4067 + ),
4068 + );
4069 + }
4070 + }).pipe(Effect.scoped),
4071 + );
4072 +
4073 + it.effect("replaces a provider retry with the error that failed the turn", () =>
4074 + Effect.gen(function* () {
4075 + const step = {
4076 + sessionID: SESSION,
4077 + assistantMessageID: ASSISTANT,
4078 + agent: "build",
4079 + model: { providerID: "opencode", id: "big-pickle", variant: "default" },
4080 + started: 1,
4081 + };
4082 + const gate = makeProviderReplayGate(["second retry"]);
4083 + // OpenCode starts the step of each attempt that fails, so a step start is no recovery.
4084 + const seen = yield* runRetryTurn(
4085 + [
4086 + event("session.step.started", step),
4087 + retryScheduled(2, 2_000),
4088 + event("session.step.started", step, "second retry"),
4089 + retryScheduled(3, 4_000),
4090 + event("session.step.started", step),
4091 + event("session.step.failed", {
4092 + sessionID: SESSION,
4093 + assistantMessageID: ASSISTANT,
4094 + error: rateLimited,
4095 + }),
4096 + event("session.execution.failed", { sessionID: SESSION, error: rateLimited }),
4097 + ],
4098 + gate,
4099 + );
4100 + const failed = { ...retrying, class: "usage_limit" as const, retryable: null };
4101 + const lastRetry = { attempt: 2, maxAttempts: null, retryDelayMs: 4_000 };
4102 + const rows = errorRows(seen);
4103 + assert.deepEqual(
4104 + rows.map(({ id, status, title, failure, retry }) => ({
4105 + id,
4106 + status,
4107 + title,
4108 + failure,
4109 + retry,
4110 + })),
4111 + [
4112 + {
4113 + id: rows[0]!.id,
4114 + status: "running",
4115 + title: "Provider retry",
4116 + failure: retrying,
4117 + retry: firstRetry,
4118 + },
4119 + {
4120 + id: rows[0]!.id,
4121 + status: "running",
4122 + title: "Provider retry",
4123 + failure: retrying,
4124 + retry: lastRetry,
4125 + },
4126 + {
4127 + id: rows[0]!.id,
4128 + status: "failed",
4129 + title: "Usage limit reached",
4130 + failure: failed,
4131 + retry: lastRetry,
4132 + },
4133 + ],
4134 + );
4135 + const { startedAt, ordinal } = rows[0]!;
4136 + assert.ok(startedAt);
4137 + assert.deepEqual(
4138 + rows.map((row) => ({ startedAt: row.startedAt, ordinal: row.ordinal })),
4139 + rows.map(() => ({ startedAt, ordinal })),
4140 + );
4141 + assert.isAtLeast(
4142 + DateTime.toEpochMillis(rows[2]!.updatedAt) - DateTime.toEpochMillis(startedAt),
4143 + 5_000,
4144 + );
4145 + assert.deepInclude(seen.at(-1), {
4146 + type: "turn.terminal",
4147 + status: "failed",
4148 + failure: failed,
4149 + failureItemOrdinal: ordinal,
4150 + retry: lastRetry,
4151 + retryStartedAt: startedAt,
4152 + });
4153 + }).pipe(Effect.scoped),
4154 + );
4155 +
4156 it.effect("reports a model's input limit as its context window", () =>
4157 Effect.gen(function* () {
4158 const runtime = yield* openCode2ReplayRuntime([...opening]);
packages/provider-opencode/src/server/v2/adapter.ts
+105 -1
@@ -21,6 +21,8 @@ import {
21 type OrchestrationV2ConversationMessage,
22 type OrchestrationV2ExecutionNode,
23 type OrchestrationV2ProviderCapabilities,
24 + type OrchestrationV2ProviderFailure,
25 + type OrchestrationV2ProviderRetry,
26 type OrchestrationV2ProviderSession,
27 type OrchestrationV2ProviderThread,
28 type OrchestrationV2ProviderTurn,
@@ -73,7 +75,10 @@ import {
75 type BackgroundWorkReport,
76 } from "@t3tools/provider-core/server/notification";
77 import * as ProviderContinuationRequests from "@t3tools/provider-core/server/ProviderContinuationRequests";
76 -import { makeProviderFailure } from "@t3tools/provider-core/server/failure";
78 +import {
79 + makeProviderFailure,
80 + makeProviderRetryTurnItem,
81 +} from "@t3tools/provider-core/server/failure";
82 import {
83 makeSubagentChildThread,
84 makeSubagentConversationArtifacts,
@@ -209,6 +214,13 @@ interface ActiveTurn {
214 before: string | null | undefined;
215 compaction: { readonly nativeId: string; readonly startedAt: DateTime.Utc } | undefined;
216 compactions: number;
217 + retry:
218 + | {
219 + readonly retry: OrchestrationV2ProviderRetry;
220 + readonly failure: OrchestrationV2ProviderFailure;
221 + readonly startedAt: DateTime.Utc;
222 + }
223 + | undefined;
224 interrupted: boolean;
225 unsent: boolean;
226 readonly steers: Set<string>;
@@ -1054,6 +1066,58 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
1066 if (status !== "running") turn.compaction = undefined;
1067 });
1068
1069 + const emitRetry = Effect.fnUntraced(function* (
1070 + state: ThreadState,
1071 + turn: ActiveTurn,
1072 + status: "running" | TurnTerminal["status"],
1073 + failure?: OrchestrationV2ProviderFailure,
1074 + ) {
1075 + const retry = turn.retry;
1076 + if (retry === undefined) return;
1077 + yield* emit({
1078 + type: "turn_item.updated",
1079 + driver,
1080 + turnItem: makeProviderRetryTurnItem({
1081 + driver,
1082 + threadId: turn.input.threadId,
1083 + runId: turn.input.runId,
1084 + nodeId: turn.input.rootNodeId,
1085 + providerThreadId: state.providerThread.id,
1086 + providerTurnId: turn.providerTurn.id,
1087 + itemOrdinal: ordinalOf(turn, `terminal-failure:${turn.providerTurn.id}`),
1088 + failure: failure ?? retry.failure,
1089 + retry: retry.retry,
1090 + status,
1091 + startedAt: retry.startedAt,
1092 + updatedAt: yield* DateTime.now,
1093 + }),
1094 + });
1095 + });
1096 +
1097 + const updateRetry = Effect.fnUntraced(function* (
1098 + state: ThreadState,
1099 + turn: ActiveTurn,
1100 + { attempt, error }: Pick<EventOf<"session.retry.scheduled">["data"], "attempt" | "error">,
1101 + delayMs: number,
1102 + ) {
1103 + turn.retry = {
1104 + retry: {
1105 + // OpenCode counts the first request as attempt 1, so its first retry is attempt 2.
1106 + attempt: Math.max(1, attempt - 1),
1107 + maxAttempts: null,
1108 + retryDelayMs: Math.max(0, Math.trunc(delayMs)),
1109 + },
1110 + failure: makeProviderFailure({
1111 + message: error.message,
1112 + code: error.type,
1113 + class: "provider_error",
1114 + retryable: true,
1115 + }),
1116 + startedAt: turn.retry?.startedAt ?? (yield* DateTime.now),
1117 + };
1118 + yield* emitRetry(state, turn, "running");
1119 + });
1120 +
1121 const emitProviderTurn = (
1122 state: ThreadState,
1123 turn: ActiveTurn,
@@ -1086,6 +1150,7 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
1150 before: undefined,
1151 compaction: undefined,
1152 compactions: 0,
1153 + retry: undefined,
1154 interrupted: false,
1155 unsent: false,
1156 steers: new Set(),
@@ -1539,6 +1604,12 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
1604 });
1605 }
1606 yield* emitCompaction(state, turn, terminal.status === "failed" ? "failed" : "interrupted");
1607 + yield* emitRetry(
1608 + state,
1609 + turn,
1610 + terminal.status,
1611 + terminal.status === "failed" ? terminal.failure : undefined,
1612 + );
1613 const window = windowOf(turn.input.runtimePolicy.cwd, turn.input.modelSelection.model);
1614 const lastStep = turn.lastStep;
1615 yield* emitProviderTurn(state, turn, {
@@ -1612,6 +1683,9 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
1683 status: "failed",
1684 failure: terminal.failure,
1685 failureItemOrdinal: ordinalOf(turn, `terminal-failure:${turn.providerTurn.id}`),
1686 + ...(turn.retry === undefined
1687 + ? {}
1688 + : { retry: turn.retry.retry, retryStartedAt: turn.retry.startedAt }),
1689 }
1690 : { ...base, status: terminal.status, failure: null },
1691 );
@@ -1985,6 +2059,16 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
2059 turn: ActiveTurn,
2060 event: OpenCode2Client.OpenCode2StreamEvent,
2061 ) {
2062 + // OpenCode sends nothing when a retry goes through; the provider's first output marks it.
2063 + if (
2064 + turn.retry !== undefined &&
2065 + (event.type === "session.text.started" ||
2066 + event.type === "session.reasoning.started" ||
2067 + event.type === "session.tool.input.started")
2068 + ) {
2069 + yield* emitRetry(state, turn, "completed");
2070 + turn.retry = undefined;
2071 + }
2072 switch (event.type) {
2073 case "session.text.started":
2074 case "session.reasoning.started":
@@ -2087,6 +2171,8 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
2171 turn.usage.reasoning += tokens.reasoning;
2172 return;
2173 }
2174 + case "session.retry.scheduled":
2175 + return yield* updateRetry(state, turn, event.data, event.data.at - event.created);
2176 case "session.execution.started":
2177 turn.heldEnd = undefined;
2178 return;
@@ -2453,6 +2539,24 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
2539 if (!found) return undefined;
2540 const recent = before !== undefined && before !== null ? read.slice(0, -1) : read;
2541 const idle = recent.find((message) => message.type === "idle");
2542 + const assistant = recent.find((message) => message.type === "assistant");
2543 + if (assistant?.retry !== undefined) {
2544 + // Snapshots omit when the retry was scheduled, so only its remaining delay is known.
2545 + yield* updateRetry(
2546 + state,
2547 + turn,
2548 + assistant.retry,
2549 + DateTime.toEpochMillis(assistant.retry.at) - DateTime.toEpochMillis(yield* DateTime.now),
2550 + );
2551 + } else if (
2552 + turn.retry !== undefined &&
2553 + assistant !== undefined &&
2554 + assistant.error === undefined &&
2555 + assistant.content.length > 0
2556 + ) {
2557 + yield* emitRetry(state, turn, "completed");
2558 + turn.retry = undefined;
2559 + }
2560 for (const message of recent.toReversed()) {
2561 if (message.type !== "assistant" || state.active !== turn) continue;
2562 const ordinals = { text: 0, reasoning: 0 };