@devries-cameron20 / t3code-1 / commits / 9f018954d0
Fork 0

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

fix(opencode): show a readable message when a provider error is <none> (#24734)

Co-authored-by: maria-rcks <maria@kuuro.net>

Ricardo Romero committed Oct 31, 2026 at 05:45 UTC 9f018954d0474d9dbfaa53636294459496ed08ba
4 files changed +102 -11
packages/provider-opencode/src/server/adapter.test.ts
+64
@@ -246,6 +246,70 @@ const makeOpenCodeRuntimeHarness = Effect.fn("makeOpenCodeRuntimeHarness")(funct
246 });
247
248 describe("OpenCodeAdapterV2", () => {
249 + it.effect.each([
250 + {
251 + message: "<none>",
252 + statusCode: 503,
253 + responseBody: "<title> Service\n unavailable </title>",
254 + expected: "Service unavailable (HTTP 503).",
255 + },
256 + {
257 + message: " <NoNe> ",
258 + statusCode: 502,
259 + responseBody: "bad gateway",
260 + expected: "The model provider failed the request (HTTP 502).",
261 + },
262 + {
263 + message: "<none>",
264 + expected: "The model provider failed the request and did not include an error message.",
265 + },
266 + {
267 + message: "provider says no",
268 + statusCode: 503,
269 + responseBody: "<title>Unavailable</title>",
270 + expected: "provider says no",
271 + },
272 + {
273 + message: "<none>",
274 + statusCode: 503,
275 + responseBody: "<title>https://user:secret@example.com/error?token=secret</title>",
276 + expected: "https://example.com/error (HTTP 503).",
277 + },
278 + ])("reports readable and sanitized session and turn failures: $expected", (sample) =>
279 + Effect.gen(function* () {
280 + const nativeEvents = asyncEventStream();
281 + const harness = yield* makeOpenCodeRuntimeHarness("provider-error", "root", {
282 + event: { subscribe: async () => ({ stream: nativeEvents.stream }) },
283 + session: {
284 + create: async () => ({ data: { id: "root", time: { created: 1, updated: 1 } } }),
285 + promptAsync: async () => ({ data: true }),
286 + abort: async () => ({ data: true }),
287 + children: async () => ({ data: [] }),
288 + },
289 + });
290 + yield* harness.startTurn();
291 + const received = yield* harness.runtime.events.pipe(
292 + Stream.takeUntil((event) => event.type === "turn.terminal"),
293 + Stream.runCollect,
294 + Effect.forkScoped,
295 + );
296 + yield* Effect.promise(() =>
297 + nativeEvents.push({
298 + type: "session.error",
299 + properties: { sessionID: "root", error: { name: "APIError", data: sample } },
300 + }),
301 + );
302 + const events = yield* Fiber.join(received);
303 + const session = events.findLast((event) => event.type === "provider_session.updated");
304 + const terminal = events.findLast((event) => event.type === "turn.terminal");
305 + assert.strictEqual(session?.providerSession.lastError, sample.expected);
306 + assert.strictEqual(terminal?.failure?.message, sample.expected);
307 + }).pipe(
308 + Effect.provide(Layer.merge(IdAllocator.layer, McpProviderSessions.layer)),
309 + Effect.scoped,
310 + ),
311 + );
312 +
313 it.effect("classifies APIError 429 as a usage limit", () =>
314 Effect.gen(function* () {
315 const nativeEvents = asyncEventStream();
packages/provider-opencode/src/server/adapter.ts
+16 -8
@@ -65,6 +65,7 @@ import { mergeProviderInstanceEnvironment } from "@t3tools/provider-core/server/
65 import { t3OrchestrationSystemPrompt } from "@t3tools/provider-core/server/orchestrationInstructions";
66 import { buildRuntimeInstructions } from "@t3tools/provider-core/server/runtimeInstructions";
67 import * as OpenCodeRuntime from "./OpenCodeRuntime.ts";
68 +import { readableProviderErrorMessage } from "./providerErrorMessage.ts";
69 import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
70 import { makeProviderFailure } from "@t3tools/provider-core/server/failure";
71 import { turnScopedSelectionTransition } from "@t3tools/provider-core/server/selectionTransition";
@@ -846,7 +847,14 @@ function providerRef(nativeId: string, strength: "strong" | "weak" = "strong") {
847 function openCodeErrorMessage(event: Extract<OpenCodeEvent, { type: "session.error" }>): string {
848 const error = event.properties.error;
849 if (error === undefined) return "OpenCode session failed without an error payload.";
849 - return recordString(error.data, "message") ?? error.name;
850 + const statusCode = recordValue(error.data, "statusCode");
851 + return (
852 + readableProviderErrorMessage(
853 + recordString(error.data, "message"),
854 + typeof statusCode === "number" ? statusCode : undefined,
855 + recordString(error.data, "responseBody"),
856 + ) ?? error.name
857 + );
858 }
859
860 function terminalStatusForError(
@@ -2645,15 +2653,19 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function
2653 : [threads.get(event.properties.sessionID)].filter(
2654 (state): state is OpenCodeThreadState => state !== undefined,
2655 );
2648 - const message = openCodeErrorMessage(event);
2656 const error = event.properties.error;
2657 const usageLimit = error?.name === "APIError" && error.data.statusCode === 429;
2658 + const failure = makeProviderFailure({
2659 + message: openCodeErrorMessage(event),
2660 + code: error?.name ?? null,
2661 + class: usageLimit ? "usage_limit" : "provider_error",
2662 + });
2663 if (
2664 !isMessageAbortedError(event) &&
2665 (event.properties.sessionID === undefined ||
2666 states.some((state) => state.parentSubagent === null))
2667 ) {
2656 - yield* updateProviderSession("error", message);
2668 + yield* updateProviderSession("error", failure.message);
2669 }
2670 for (const state of states) {
2671 if (state.activeTurn !== null) {
@@ -2662,11 +2674,7 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function
2674 state.activeTurn,
2675 terminalStatusForError(event, state.activeTurn),
2676 {
2665 - failure: makeProviderFailure({
2666 - message,
2667 - code: error?.name ?? null,
2668 - class: usageLimit ? "usage_limit" : "provider_error",
2669 - }),
2677 + failure,
2678 threadDisposition:
2679 event.properties.sessionID === undefined ? "broken" : "reusable",
2680 },
packages/provider-opencode/src/server/providerErrorMessage.ts new
+18
@@ -0,0 +1,18 @@
1 +/** OpenCode stores `<none>` when it cannot read the provider body. */
2 +export function readableProviderErrorMessage(
3 + message?: string,
4 + status?: number,
5 + body?: string,
6 +): string | undefined {
7 + const text = message?.trim() ?? "";
8 + if (text && text.toLowerCase() !== "<none>") return text;
9 + const title = body
10 + ?.match(/<title[^>]*>([^<]*)<\/title>/i)?.[1]
11 + ?.replace(/\s+/g, " ")
12 + .trim();
13 + if (title) return typeof status === "number" ? `${title} (HTTP ${status}).` : title;
14 + if (typeof status === "number") return `The model provider failed the request (HTTP ${status}).`;
15 + return text
16 + ? "The model provider failed the request and did not include an error message."
17 + : undefined;
18 +}
packages/provider-opencode/src/server/v2/adapter.ts
+4 -3
@@ -56,6 +56,7 @@ import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost";
56 import * as OpenCode2Client from "./OpenCode2Client.ts";
57 import * as OpenCode2Server from "./OpenCode2Server.ts";
58 import * as OpenCodeRuntime from "../OpenCodeRuntime.ts";
59 +import { readableProviderErrorMessage } from "../providerErrorMessage.ts";
60 import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
61 import { buildRuntimeInstructions } from "@t3tools/provider-core/server/runtimeInstructions";
62 import { t3OrchestrationSystemPrompt } from "@t3tools/provider-core/server/orchestrationInstructions";
@@ -1073,7 +1074,7 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
1074 retryDelayMs: Math.max(0, Math.trunc(delayMs)),
1075 },
1076 failure: makeProviderFailure({
1076 - message: error.message,
1077 + message: readableProviderErrorMessage(error.message, error.status, error.response?.body),
1078 code: error.type,
1079 class: "provider_error",
1080 retryable: true,
@@ -2125,7 +2126,7 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
2126 case "session.execution.interrupted":
2127 return yield* endExecution(state, turn, { status: "interrupted" });
2128 case "session.execution.failed": {
2128 - const { type, message, status } = event.data.error;
2129 + const { type, message, status, response } = event.data.error;
2130 // OpenCode types an empty balance as provider.quota too, but it answers
2131 // that with HTTP 402 and it never resets. Usage windows and budgets are 429.
2132 const usageLimit =
@@ -2133,7 +2134,7 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
2134 return yield* endExecution(state, turn, {
2135 status: "failed",
2136 failure: makeProviderFailure({
2136 - message,
2137 + message: readableProviderErrorMessage(message, status, response?.body),
2138 code: type,
2139 class: usageLimit ? "usage_limit" : "provider_error",
2140 }),