Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

[codex] Structure OpenCode text generation failures (#3472)

Julius Marminge8c1605b38327
diff --git a/apps/server/src/textGeneration/OpenCodeTextGeneration.test.ts b/apps/server/src/textGeneration/OpenCodeTextGeneration.test.ts
index f6d9c133f..558a8663b 100644
--- a/apps/server/src/textGeneration/OpenCodeTextGeneration.test.ts
+++ b/apps/server/src/textGeneration/OpenCodeTextGeneration.test.ts
@@ -1,4 +1,4 @@
-import { OpenCodeSettings, ProviderInstanceId } from "@t3tools/contracts";
+import { OpenCodeSettings, ProviderInstanceId, TextGenerationError } from "@t3tools/contracts";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { it } from "@effect/vitest";
import * as Duration from "effect/Duration";
@@ -11,8 +11,8 @@ import { beforeEach, expect } from "vite-plus/test";
import * as ServerConfig from "../config.ts";
import * as OpenCodeRuntime from "../provider/opencodeRuntime.ts";
+import * as OpenCodeTextGeneration from "./OpenCodeTextGeneration.ts";
import * as TextGeneration from "./TextGeneration.ts";
-import { makeOpenCodeTextGeneration } from "./OpenCodeTextGeneration.ts";
const runtimeMock = {
state: {
@@ -20,8 +20,11 @@ const runtimeMock = {
promptUrls: [] as string[],
authHeaders: [] as Array<string | null>,
closeCalls: [] as string[],
+ sessionCreateError: undefined as unknown,
+ sessionResult: undefined as { data?: { id: string } } | undefined,
+ promptRequestError: undefined as unknown,
promptResult: undefined as
- | { data?: { info?: { error?: unknown }; parts?: Array<{ type: string; text?: string }> } }
+ | { data?: { info?: { error?: unknown }; parts?: Array<unknown> } }
| undefined,
},
reset() {
@@ -29,6 +32,9 @@ const runtimeMock = {
this.state.promptUrls.length = 0;
this.state.authHeaders.length = 0;
this.state.closeCalls.length = 0;
+ this.state.sessionCreateError = undefined;
+ this.state.sessionResult = undefined;
+ this.state.promptRequestError = undefined;
this.state.promptResult = undefined;
},
};
@@ -61,12 +67,20 @@ const OpenCodeRuntimeTestDouble: OpenCodeRuntime.OpenCodeRuntimeShape = {
createOpenCodeSdkClient: ({ baseUrl, serverPassword }) =>
({
session: {
- create: async () => ({ data: { id: `${baseUrl}/session` } }),
+ create: async () => {
+ if (runtimeMock.state.sessionCreateError !== undefined) {
+ throw runtimeMock.state.sessionCreateError;
+ }
+ return runtimeMock.state.sessionResult ?? { data: { id: `${baseUrl}/session` } };
+ },
prompt: async () => {
runtimeMock.state.promptUrls.push(baseUrl);
runtimeMock.state.authHeaders.push(
serverPassword ? `Basic ${btoa(`opencode:${serverPassword}`)}` : null,
);
+ if (runtimeMock.state.promptRequestError !== undefined) {
+ throw runtimeMock.state.promptRequestError;
+ }
return (
runtimeMock.state.promptResult ?? {
data: {
@@ -99,6 +113,13 @@ const DEFAULT_TEST_MODEL_SELECTION = {
instanceId: ProviderInstanceId.make("opencode"),
model: "openai/gpt-5",
};
+const DEFAULT_COMMIT_MESSAGE_INPUT = {
+ cwd: process.cwd(),
+ branch: "feature/opencode-reuse",
+ stagedSummary: "M README.md",
+ stagedPatch: "diff --git a/README.md b/README.md",
+ modelSelection: DEFAULT_TEST_MODEL_SELECTION,
+};
const OPENCODE_TEXT_GENERATION_IDLE_TTL_MS = 30_000;
@@ -142,7 +163,7 @@ function withOpenCodeTextGeneration<A, E, R>(
effectFn: (textGeneration: TextGeneration.TextGeneration["Service"]) => Effect.Effect<A, E, R>,
) {
return Effect.gen(function* () {
- const textGeneration = yield* makeOpenCodeTextGeneration(settings);
+ const textGeneration = yield* OpenCodeTextGeneration.makeOpenCodeTextGeneration(settings);
return yield* effectFn(textGeneration);
}).pipe(Effect.scoped);
}
@@ -221,22 +242,99 @@ it.layer(OpenCodeTextGenerationTestLayer)("OpenCodeTextGeneration", (it) => {
).pipe(Effect.provide(TestClock.layer())),
);
- it.effect("returns a typed empty-output error when OpenCode returns no text parts", () =>
+ it.effect("preserves the SDK cause when session creation fails", () =>
withOpenCodeTextGeneration(DEFAULT_OPENCODE_SETTINGS, (textGeneration) =>
Effect.gen(function* () {
- runtimeMock.state.promptResult = { data: {} };
+ const sdkCause = new Error("session endpoint unavailable");
+ runtimeMock.state.sessionCreateError = sdkCause;
const error = yield* textGeneration
- .generateCommitMessage({
- cwd: process.cwd(),
- branch: "feature/opencode-reuse",
- stagedSummary: "M README.md",
- stagedPatch: "diff --git a/README.md b/README.md",
- modelSelection: DEFAULT_TEST_MODEL_SELECTION,
- })
+ .generateCommitMessage(DEFAULT_COMMIT_MESSAGE_INPUT)
+ .pipe(Effect.flip);
+
+ expect(error).toBeInstanceOf(TextGenerationError);
+ expect(error.message).toContain("OpenCode session.create request failed.");
+ expect(error.cause).toMatchObject({
+ _tag: "OpenCodeTextGenerationSessionRequestError",
+ operation: "generateCommitMessage",
+ cwd: process.cwd(),
+ cause: sdkCause,
+ });
+ expect((error.cause as { cause: unknown }).cause).toBe(sdkCause);
+ }),
+ ),
+ );
+
+ it.effect("reports a missing session payload without manufacturing a cause", () =>
+ withOpenCodeTextGeneration(DEFAULT_OPENCODE_SETTINGS, (textGeneration) =>
+ Effect.gen(function* () {
+ runtimeMock.state.sessionResult = {};
+
+ const error = yield* textGeneration
+ .generateCommitMessage(DEFAULT_COMMIT_MESSAGE_INPUT)
+ .pipe(Effect.flip);
+
+ expect(error.message).toContain("OpenCode session.create returned no session payload.");
+ expect(error.cause).toMatchObject({
+ _tag: "OpenCodeTextGenerationSessionPayloadError",
+ operation: "generateCommitMessage",
+ cwd: process.cwd(),
+ });
+ expect(error.cause).not.toHaveProperty("cause");
+ }),
+ ),
+ );
+
+ it.effect("preserves the SDK cause and request context when prompting fails", () =>
+ withOpenCodeTextGeneration(DEFAULT_OPENCODE_SETTINGS, (textGeneration) =>
+ Effect.gen(function* () {
+ const sdkCause = new Error("prompt endpoint unavailable");
+ runtimeMock.state.promptRequestError = sdkCause;
+
+ const error = yield* textGeneration
+ .generateCommitMessage(DEFAULT_COMMIT_MESSAGE_INPUT)
+ .pipe(Effect.flip);
+
+ expect(error.message).toContain("OpenCode session.prompt request failed.");
+ expect(error.cause).toMatchObject({
+ _tag: "OpenCodeTextGenerationPromptRequestError",
+ operation: "generateCommitMessage",
+ cwd: process.cwd(),
+ sessionId: "http://127.0.0.1:4301/session",
+ providerId: "openai",
+ modelId: "gpt-5",
+ cause: sdkCause,
+ });
+ expect((error.cause as { cause: unknown }).cause).toBe(sdkCause);
+ }),
+ ),
+ );
+
+ it.effect("returns a typed empty-output error for malformed and blank response parts", () =>
+ withOpenCodeTextGeneration(DEFAULT_OPENCODE_SETTINGS, (textGeneration) =>
+ Effect.gen(function* () {
+ runtimeMock.state.promptResult = {
+ data: {
+ parts: [null, { type: "tool" }, { type: "text", text: " " }],
+ },
+ };
+
+ const error = yield* textGeneration
+ .generateCommitMessage(DEFAULT_COMMIT_MESSAGE_INPUT)
.pipe(Effect.flip);
expect(error.message).toContain("OpenCode returned empty output.");
+ expect(error.cause).toMatchObject({
+ _tag: "OpenCodeTextGenerationEmptyOutputError",
+ operation: "generateCommitMessage",
+ cwd: process.cwd(),
+ sessionId: "http://127.0.0.1:4301/session",
+ providerId: "openai",
+ modelId: "gpt-5",
+ responsePartCount: 3,
+ textPartCount: 1,
+ });
+ expect(error.cause).not.toHaveProperty("cause");
}),
),
);
@@ -289,16 +387,21 @@ it.layer(OpenCodeTextGenerationTestLayer)("OpenCodeTextGeneration", (it) => {
};
const error = yield* textGeneration
- .generateCommitMessage({
- cwd: process.cwd(),
- branch: "feature/opencode-reuse",
- stagedSummary: "M README.md",
- stagedPatch: "diff --git a/README.md b/README.md",
- modelSelection: DEFAULT_TEST_MODEL_SELECTION,
- })
+ .generateCommitMessage(DEFAULT_COMMIT_MESSAGE_INPUT)
.pipe(Effect.flip);
expect(error.message).toContain("Model did not produce structured output");
+ expect(error.cause).toMatchObject({
+ _tag: "OpenCodeTextGenerationPromptResponseError",
+ operation: "generateCommitMessage",
+ cwd: process.cwd(),
+ sessionId: "http://127.0.0.1:4301/session",
+ providerId: "openai",
+ modelId: "gpt-5",
+ providerErrorName: "StructuredOutputError",
+ providerMessage: "Model did not produce structured output",
+ });
+ expect(error.cause).not.toHaveProperty("cause");
}),
),
);
diff --git a/apps/server/src/textGeneration/OpenCodeTextGeneration.ts b/apps/server/src/textGeneration/OpenCodeTextGeneration.ts
index f59e76942..1f94f9706 100644
--- a/apps/server/src/textGeneration/OpenCodeTextGeneration.ts
+++ b/apps/server/src/textGeneration/OpenCodeTextGeneration.ts
@@ -6,6 +6,7 @@ import * as Scope from "effect/Scope";
import * as Semaphore from "effect/Semaphore";
import {
+ NonNegativeInt,
TextGenerationError,
type ChatAttachment,
type ModelSelection,
@@ -33,11 +34,106 @@ import * as OpenCodeRuntime from "../provider/opencodeRuntime.ts";
const OPENCODE_TEXT_GENERATION_IDLE_TTL = "30 seconds";
-function getOpenCodePromptErrorMessage(error: unknown): string | null {
+const OpenCodeTextGenerationOperation = Schema.Literals([
+ "generateCommitMessage",
+ "generatePrContent",
+ "generateBranchName",
+ "generateThreadTitle",
+]);
+
+type OpenCodeTextGenerationOperation = typeof OpenCodeTextGenerationOperation.Type;
+
+const openCodeTextGenerationErrorContext = {
+ operation: OpenCodeTextGenerationOperation,
+ cwd: Schema.String,
+};
+
+export class OpenCodeTextGenerationSessionRequestError extends Schema.TaggedErrorClass<OpenCodeTextGenerationSessionRequestError>()(
+ "OpenCodeTextGenerationSessionRequestError",
+ {
+ ...openCodeTextGenerationErrorContext,
+ cause: Schema.Defect(),
+ },
+) {
+ override get message(): string {
+ return `OpenCode session creation request failed for ${this.operation} in ${this.cwd}.`;
+ }
+}
+
+export class OpenCodeTextGenerationSessionPayloadError extends Schema.TaggedErrorClass<OpenCodeTextGenerationSessionPayloadError>()(
+ "OpenCodeTextGenerationSessionPayloadError",
+ openCodeTextGenerationErrorContext,
+) {
+ override get message(): string {
+ return `OpenCode session.create returned no session payload for ${this.operation} in ${this.cwd}.`;
+ }
+}
+
+const openCodePromptErrorContext = {
+ ...openCodeTextGenerationErrorContext,
+ sessionId: Schema.String,
+ providerId: Schema.String,
+ modelId: Schema.String,
+};
+
+export class OpenCodeTextGenerationPromptRequestError extends Schema.TaggedErrorClass<OpenCodeTextGenerationPromptRequestError>()(
+ "OpenCodeTextGenerationPromptRequestError",
+ {
+ ...openCodePromptErrorContext,
+ cause: Schema.Defect(),
+ },
+) {
+ override get message(): string {
+ return `OpenCode prompt request failed for ${this.operation} in ${this.cwd} using ${this.providerId}/${this.modelId} (session ${this.sessionId}).`;
+ }
+}
+
+export class OpenCodeTextGenerationPromptResponseError extends Schema.TaggedErrorClass<OpenCodeTextGenerationPromptResponseError>()(
+ "OpenCodeTextGenerationPromptResponseError",
+ {
+ ...openCodePromptErrorContext,
+ providerErrorName: Schema.optional(Schema.String),
+ providerMessage: Schema.String,
+ },
+) {
+ override get message(): string {
+ const providerError = this.providerErrorName ? ` ${this.providerErrorName}` : "";
+ return `OpenCode prompt${providerError} failed for ${this.operation} in ${this.cwd} using ${this.providerId}/${this.modelId} (session ${this.sessionId}): ${this.providerMessage}`;
+ }
+}
+
+export class OpenCodeTextGenerationEmptyOutputError extends Schema.TaggedErrorClass<OpenCodeTextGenerationEmptyOutputError>()(
+ "OpenCodeTextGenerationEmptyOutputError",
+ {
+ ...openCodePromptErrorContext,
+ responsePartCount: NonNegativeInt,
+ textPartCount: NonNegativeInt,
+ },
+) {
+ override get message(): string {
+ return `OpenCode returned empty output for ${this.operation} in ${this.cwd} using ${this.providerId}/${this.modelId} (session ${this.sessionId}, ${this.responsePartCount} response parts, ${this.textPartCount} text parts).`;
+ }
+}
+
+interface OpenCodePromptFailure {
+ readonly name?: string;
+ readonly message: string;
+}
+
+interface OpenCodeTextPart {
+ readonly type: "text";
+ readonly text: string;
+}
+
+function getOpenCodePromptFailure(error: unknown): OpenCodePromptFailure | null {
if (!error || typeof error !== "object") {
return null;
}
+ const name =
+ "name" in error && typeof error.name === "string" && error.name.trim().length > 0
+ ? error.name.trim()
+ : undefined;
const message =
"data" in error &&
error.data &&
@@ -47,31 +143,34 @@ function getOpenCodePromptErrorMessage(error: unknown): string | null {
? error.data.message.trim()
: "";
if (message.length > 0) {
- return message;
+ return {
+ ...(name ? { name } : {}),
+ message,
+ };
}
- if ("name" in error && typeof error.name === "string") {
- const name = error.name.trim();
- return name.length > 0 ? name : null;
+ if (name) {
+ return { name, message: name };
}
return null;
}
+function isOpenCodeTextPart(part: unknown): part is OpenCodeTextPart {
+ return (
+ part !== null &&
+ typeof part === "object" &&
+ "type" in part &&
+ part.type === "text" &&
+ "text" in part &&
+ typeof part.text === "string"
+ );
+}
+
function getOpenCodeTextResponse(parts: ReadonlyArray<unknown> | undefined): string {
return (parts ?? [])
- .flatMap((part) => {
- if (!part || typeof part !== "object") {
- return [];
- }
- if (!("type" in part) || part.type !== "text") {
- return [];
- }
- if (!("text" in part) || typeof part.text !== "string") {
- return [];
- }
- return [part.text];
- })
+ .filter(isOpenCodeTextPart)
+ .map((part) => part.text)
.join("")
.trim();
}
@@ -260,11 +359,7 @@ export const makeOpenCodeTextGeneration = Effect.fn("makeOpenCodeTextGeneration"
);
const runOpenCodeJson = Effect.fn("runOpenCodeJson")(function* <S extends Schema.Top>(input: {
- readonly operation:
- | "generateCommitMessage"
- | "generatePrContent"
- | "generateBranchName"
- | "generateThreadTitle";
+ readonly operation: OpenCodeTextGenerationOperation;
readonly cwd: string;
readonly prompt: string;
readonly outputSchemaJson: S;
@@ -285,54 +380,121 @@ export const makeOpenCodeTextGeneration = Effect.fn("makeOpenCodeTextGeneration"
resolveAttachmentPath({ attachmentsDir: serverConfig.attachmentsDir, attachment }),
});
- const runAgainstServer = (server: Pick<OpenCodeRuntime.OpenCodeServerConnection, "url">) =>
- Effect.tryPromise({
- try: async () => {
- const client = openCodeRuntime.createOpenCodeSdkClient({
- baseUrl: server.url,
- directory: input.cwd,
- ...(openCodeSettings.serverUrl.length > 0 && openCodeSettings.serverPassword
- ? { serverPassword: openCodeSettings.serverPassword }
- : {}),
+ const runAgainstServer = Effect.fn("runOpenCodeJson.runAgainstServer")(
+ function* (server: Pick<OpenCodeRuntime.OpenCodeServerConnection, "url">) {
+ const client = openCodeRuntime.createOpenCodeSdkClient({
+ baseUrl: server.url,
+ directory: input.cwd,
+ ...(openCodeSettings.serverUrl.length > 0 && openCodeSettings.serverPassword
+ ? { serverPassword: openCodeSettings.serverPassword }
+ : {}),
+ });
+ const session = yield* Effect.tryPromise({
+ try: () =>
+ client.session.create({
+ title: `T3 Code ${input.operation}`,
+ permission: [{ permission: "*", pattern: "*", action: "deny" }],
+ }),
+ catch: (cause) =>
+ new OpenCodeTextGenerationSessionRequestError({
+ operation: input.operation,
+ cwd: input.cwd,
+ cause,
+ }),
+ });
+ if (!session.data) {
+ return yield* new OpenCodeTextGenerationSessionPayloadError({
+ operation: input.operation,
+ cwd: input.cwd,
});
- const session = await client.session.create({
- title: `T3 Code ${input.operation}`,
- permission: [{ permission: "*", pattern: "*", action: "deny" }],
+ }
+ const selectedAgent = getModelSelectionStringOptionValue(input.modelSelection, "agent");
+ const selectedVariant = getModelSelectionStringOptionValue(input.modelSelection, "variant");
+ const promptContext = {
+ operation: input.operation,
+ cwd: input.cwd,
+ sessionId: session.data.id,
+ providerId: parsedModel.providerID,
+ modelId: parsedModel.modelID,
+ };
+
+ const result = yield* Effect.tryPromise({
+ try: () =>
+ client.session.prompt({
+ sessionID: session.data.id,
+ model: parsedModel,
+ ...(selectedAgent ? { agent: selectedAgent } : {}),
+ ...(selectedVariant ? { variant: selectedVariant } : {}),
+ parts: [{ type: "text", text: input.prompt }, ...fileParts],
+ }),
+ catch: (cause) =>
+ new OpenCodeTextGenerationPromptRequestError({
+ ...promptContext,
+ cause,
+ }),
+ });
+ const promptFailure = getOpenCodePromptFailure(result.data?.info?.error);
+ if (promptFailure) {
+ return yield* new OpenCodeTextGenerationPromptResponseError({
+ ...promptContext,
+ ...(promptFailure.name ? { providerErrorName: promptFailure.name } : {}),
+ providerMessage: promptFailure.message,
});
- if (!session.data) {
- throw new Error("OpenCode session.create returned no session payload.");
- }
- const selectedAgent = getModelSelectionStringOptionValue(input.modelSelection, "agent");
- const selectedVariant = getModelSelectionStringOptionValue(
- input.modelSelection,
- "variant",
- );
-
- const result = await client.session.prompt({
- sessionID: session.data.id,
- model: parsedModel,
- ...(selectedAgent ? { agent: selectedAgent } : {}),
- ...(selectedVariant ? { variant: selectedVariant } : {}),
- parts: [{ type: "text", text: input.prompt }, ...fileParts],
+ }
+ const responseParts = result.data?.parts ?? [];
+ const rawText = getOpenCodeTextResponse(responseParts);
+ if (rawText.length === 0) {
+ return yield* new OpenCodeTextGenerationEmptyOutputError({
+ ...promptContext,
+ responsePartCount: responseParts.length,
+ textPartCount: responseParts.filter(isOpenCodeTextPart).length,
});
- const info = result.data?.info;
- const errorMessage = getOpenCodePromptErrorMessage(info?.error);
- if (errorMessage) {
- throw new Error(errorMessage);
- }
- const rawText = getOpenCodeTextResponse(result.data?.parts);
- if (rawText.length === 0) {
- throw new Error("OpenCode returned empty output.");
- }
- return rawText;
- },
- catch: (cause) =>
- new TextGenerationError({
- operation: input.operation,
- detail: OpenCodeRuntime.openCodeRuntimeErrorDetail(cause),
- cause,
- }),
- });
+ }
+ return rawText;
+ },
+ Effect.catchTags({
+ OpenCodeTextGenerationSessionRequestError: (cause) =>
+ Effect.fail(
+ new TextGenerationError({
+ operation: cause.operation,
+ detail: "OpenCode session.create request failed.",
+ cause,
+ }),
+ ),
+ OpenCodeTextGenerationSessionPayloadError: (cause) =>
+ Effect.fail(
+ new TextGenerationError({
+ operation: cause.operation,
+ detail: "OpenCode session.create returned no session payload.",
+ cause,
+ }),
+ ),
+ OpenCodeTextGenerationPromptRequestError: (cause) =>
+ Effect.fail(
+ new TextGenerationError({
+ operation: cause.operation,
+ detail: "OpenCode session.prompt request failed.",
+ cause,
+ }),
+ ),
+ OpenCodeTextGenerationPromptResponseError: (cause) =>
+ Effect.fail(
+ new TextGenerationError({
+ operation: cause.operation,
+ detail: cause.providerMessage,
+ cause,
+ }),
+ ),
+ OpenCodeTextGenerationEmptyOutputError: (cause) =>
+ Effect.fail(
+ new TextGenerationError({
+ operation: cause.operation,
+ detail: "OpenCode returned empty output.",
+ cause,
+ }),
+ ),
+ }),
+ );
const rawOutput =
openCodeSettings.serverUrl.length > 0