import { ProviderInstanceId, settingsSecretLiteral, TextGenerationError } from "@t3tools/contracts";
import { OpenCodeSettings } from "../settings.ts";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { it } from "@effect/vitest";
import * as Cause from "effect/Cause";
import * as Deferred from "effect/Deferred";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as Schema from "effect/Schema";
import * as TestClock from "effect/testing/TestClock";
import * as NetService from "@t3tools/shared/Net";
import { beforeEach, expect } from "vite-plus/test";
import * as TestProviderHost from "@t3tools/provider-testing/TestProviderHost";
import * as OpenCodeRuntime from "./OpenCodeRuntime.ts";
import * as OpenCodeServerOwner from "./OpenCodeServerOwner.ts";
import * as OpenCodeTextGeneration from "./textGeneration.ts";
import type { ProviderTextGeneration } from "@t3tools/provider-core/server/textGeneration";
const runtimeMock = {
state: {
startCalls: [] as string[],
promptUrls: [] as string[],
promptParts: [] as ReadonlyArray<unknown>[],
authHeaders: [] as Array<string | null>,
closeCalls: [] as string[],
sessionCreateCalls: 0,
sessionCalls: [] as string[],
onSessionCreate: undefined as ((signal?: AbortSignal) => Promise<never>) | undefined,
onPrompt: undefined as
| ((signal?: AbortSignal) => Promise<{ data: { parts: ReadonlyArray<unknown> } }>)
| undefined,
onAbort: undefined as ((signal?: AbortSignal) => Promise<never>) | undefined,
connectionError: undefined as Error | undefined,
sessionCreateError: undefined as unknown,
sessionResult: undefined as { data?: { id: string } } | undefined,
promptRequestError: undefined as unknown,
promptResult: undefined as
| { data?: { info?: { error?: unknown }; parts?: Array<unknown> } }
| undefined,
},
reset() {
this.state.startCalls.length = 0;
this.state.promptUrls.length = 0;
this.state.promptParts.length = 0;
this.state.authHeaders.length = 0;
this.state.closeCalls.length = 0;
this.state.sessionCreateCalls = 0;
this.state.sessionCalls.length = 0;
this.state.onSessionCreate = undefined;
this.state.onPrompt = undefined;
this.state.onAbort = undefined;
this.state.connectionError = undefined;
this.state.sessionCreateError = undefined;
this.state.sessionResult = undefined;
this.state.promptRequestError = undefined;
this.state.promptResult = undefined;
},
};
const OpenCodeRuntimeTestDouble: OpenCodeRuntime.OpenCodeRuntime["Service"] = {
startOpenCodeServerProcess: ({ binaryPath, serverPassword, environment }) =>
Effect.gen(function* () {
const index = runtimeMock.state.startCalls.length + 1;
const url = `http://127.0.0.1:${4_300 + index}`;
runtimeMock.state.startCalls.push(binaryPath);
yield* Effect.addFinalizer(() =>
Effect.sync(() => {
runtimeMock.state.closeCalls.push(url);
}),
);
const effectiveServerPassword = OpenCodeRuntime.resolveOpenCodeServerPassword({
external: false,
...(serverPassword !== undefined ? { serverPassword } : {}),
...(environment !== undefined ? { environment } : {}),
});
return {
url,
...(effectiveServerPassword !== undefined
? { serverPassword: effectiveServerPassword }
: {}),
version: "1.14.19",
isRunning: Effect.succeed(true),
exitCode: Effect.never,
};
}),
connectToOpenCodeServer: ({ serverUrl, serverPassword }) =>
runtimeMock.state.connectionError
? Effect.fail(
new OpenCodeRuntime.OpenCodeRuntimeError({
operation: "global.health",
detail: runtimeMock.state.connectionError.message,
cause: runtimeMock.state.connectionError,
}),
)
: Effect.succeed({
url: serverUrl ?? "http://127.0.0.1:4301",
...(serverPassword ? { serverPassword } : {}),
version: "1.14.19",
exitCode: null,
external: Boolean(serverUrl),
}),
runOpenCodeCommand: () => Effect.succeed({ stdout: "", stderr: "", code: 0 }),
createOpenCodeSdkClient: ({ baseUrl, serverPassword }) =>
({
session: {
create: async (_input: unknown, options?: { readonly signal?: AbortSignal }) => {
runtimeMock.state.sessionCreateCalls += 1;
if (runtimeMock.state.onSessionCreate) {
return runtimeMock.state.onSessionCreate(options?.signal);
}
if (runtimeMock.state.sessionCreateError !== undefined) {
throw runtimeMock.state.sessionCreateError;
}
return runtimeMock.state.sessionResult ?? { data: { id: `${baseUrl}/session` } };
},
abort: async (
input: { readonly sessionID: string },
options?: { readonly signal?: AbortSignal },
) => {
runtimeMock.state.sessionCalls.push(`abort ${input.sessionID}`);
if (runtimeMock.state.onAbort) return runtimeMock.state.onAbort(options?.signal);
return { data: true };
},
delete: async (input: { readonly sessionID: string }) => {
runtimeMock.state.sessionCalls.push(`delete ${input.sessionID}`);
return { data: true };
},
prompt: async (
input: { readonly parts: ReadonlyArray<unknown> },
options?: { readonly signal?: AbortSignal },
) => {
runtimeMock.state.promptUrls.push(baseUrl);
runtimeMock.state.promptParts.push(input.parts);
runtimeMock.state.authHeaders.push(
serverPassword ? `Basic ${btoa(`opencode:${serverPassword}`)}` : null,
);
if (runtimeMock.state.onPrompt) return runtimeMock.state.onPrompt(options?.signal);
if (runtimeMock.state.promptRequestError !== undefined) {
throw runtimeMock.state.promptRequestError;
}
return (
runtimeMock.state.promptResult ?? {
data: {
parts: [
{
type: "text",
text: JSON.stringify({
subject: "Improve OpenCode reuse",
body: "Reuse one server for the full action.",
}),
},
],
},
}
);
},
},
}) as unknown as ReturnType<
OpenCodeRuntime.OpenCodeRuntime["Service"]["createOpenCodeSdkClient"]
>,
loadOpenCodeInventory: () =>
Effect.fail(
new OpenCodeRuntime.OpenCodeRuntimeError({
operation: "loadOpenCodeInventory",
detail: "OpenCodeRuntimeTestDouble.loadOpenCodeInventory not used in this test",
cause: null,
}),
),
loadOpenCodeSkills: () => Effect.succeed([]),
};
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;
const layerOpenCodeTextGenerationTest = Layer.succeed(
OpenCodeRuntime.OpenCodeRuntime,
OpenCodeRuntimeTestDouble,
).pipe(
Layer.provideMerge(TestProviderHost.layer()),
Layer.provideMerge(NetService.layer),
Layer.provideMerge(NodeServices.layer),
);
const layerOpenCodeTextGenerationExistingServerTest = Layer.succeed(
OpenCodeRuntime.OpenCodeRuntime,
OpenCodeRuntimeTestDouble,
).pipe(
Layer.provideMerge(TestProviderHost.layer()),
Layer.provideMerge(NetService.layer),
Layer.provideMerge(NodeServices.layer),
);
const DEFAULT_OPENCODE_SETTINGS = Schema.decodeSync(OpenCodeSettings)({
binaryPath: "fake-opencode",
});
const EXISTING_SERVER_OPENCODE_SETTINGS = Schema.decodeSync(OpenCodeSettings)({
binaryPath: "fake-opencode",
serverUrl: "http://127.0.0.1:9999",
serverPassword: "secret-password",
});
const EXTERNAL_SERVER_WITHOUT_AUTH_OPENCODE_SETTINGS = Schema.decodeSync(OpenCodeSettings)({
binaryPath: "fake-opencode",
serverUrl: "http://127.0.0.1:9999",
});
function withOpenCodeTextGeneration<A, E, R>(
settings: OpenCodeSettings,
effectFn: (textGeneration: ProviderTextGeneration) => Effect.Effect<A, E, R>,
environment?: NodeJS.ProcessEnv,
) {
return Effect.gen(function* () {
const serverOwner = yield* OpenCodeServerOwner.make({
binaryPath: settings.binaryPath,
directory: process.cwd(),
...(settingsSecretLiteral(settings.serverPassword)
? { serverPassword: settingsSecretLiteral(settings.serverPassword) }
: {}),
...(environment ? { environment } : {}),
});
const textGeneration = yield* OpenCodeTextGeneration.makeOpenCodeTextGeneration(settings).pipe(
Effect.provideService(OpenCodeServerOwner.OpenCodeServerOwner, serverOwner),
);
return yield* effectFn(textGeneration);
}).pipe(Effect.scoped);
}
beforeEach(() => {
runtimeMock.reset();
});
const advanceIdleClock = Effect.gen(function* () {
yield* Effect.yieldNow;
yield* TestClock.adjust(Duration.millis(OPENCODE_TEXT_GENERATION_IDLE_TTL_MS + 1));
yield* Effect.yieldNow;
});
it.layer(layerOpenCodeTextGenerationTest)("OpenCodeTextGeneration", (it) => {
it.effect("cancels or times out an in-flight session creation before prompting", () =>
withOpenCodeTextGeneration(EXISTING_SERVER_OPENCODE_SETTINGS, (textGeneration) =>
Effect.gen(function* () {
const timedOut = yield* Deferred.make<AbortSignal | undefined>();
runtimeMock.state.onSessionCreate = (signal) => {
Deferred.doneUnsafe(timedOut, Effect.succeed(signal));
return new Promise<never>(() => {});
};
const timedOutFiber = yield* textGeneration
.generateCommitMessage(DEFAULT_COMMIT_MESSAGE_INPUT)
.pipe(Effect.forkChild);
const timedOutSignal = yield* Deferred.await(timedOut);
yield* TestClock.adjust(Duration.minutes(3));
const timeoutError = yield* Fiber.join(timedOutFiber).pipe(Effect.flip);
expect(timeoutError).toBeInstanceOf(TextGenerationError);
expect(timeoutError.detail).toBe("OpenCode did not finish generating in time.");
expect(timedOutSignal?.aborted).toBe(true);
const started = yield* Deferred.make<AbortSignal | undefined>();
runtimeMock.state.onSessionCreate = (signal) => {
Deferred.doneUnsafe(started, Effect.succeed(signal));
return new Promise<never>(() => {});
};
const fiber = yield* textGeneration
.generateCommitMessage(DEFAULT_COMMIT_MESSAGE_INPUT)
.pipe(Effect.forkChild);
const signal = yield* Deferred.await(started);
yield* Fiber.interrupt(fiber);
const exit = yield* Fiber.await(fiber);
expect(Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)).toBe(true);
expect(signal?.aborted).toBe(true);
expect(runtimeMock.state.promptUrls).toEqual([]);
expect(runtimeMock.state.sessionCalls).toEqual([]);
}),
),
);
it.effect("cancels only its prompt session while another generation uses the shared server", () =>
withOpenCodeTextGeneration(DEFAULT_OPENCODE_SETTINGS, (textGeneration) =>
Effect.gen(function* () {
const started = yield* Deferred.make<AbortSignal | undefined>();
runtimeMock.state.sessionResult = { data: { id: "cancelled-session" } };
runtimeMock.state.onPrompt = (signal) => {
Deferred.doneUnsafe(started, Effect.succeed(signal));
return new Promise<never>(() => {});
};
const fiber = yield* textGeneration
.generateCommitMessage(DEFAULT_COMMIT_MESSAGE_INPUT)
.pipe(Effect.forkChild);
const signal = yield* Deferred.await(started);
const otherStarted = yield* Deferred.make<AbortSignal | undefined>();
const otherReply = Promise.withResolvers<{ data: { parts: ReadonlyArray<unknown> } }>();
runtimeMock.state.sessionResult = { data: { id: "other-session" } };
runtimeMock.state.onPrompt = (otherSignal) => {
Deferred.doneUnsafe(otherStarted, Effect.succeed(otherSignal));
return otherReply.promise;
};
const otherFiber = yield* textGeneration
.generateCommitMessage(DEFAULT_COMMIT_MESSAGE_INPUT)
.pipe(Effect.forkChild);
const otherSignal = yield* Deferred.await(otherStarted);
yield* Fiber.interrupt(fiber);
const exit = yield* Fiber.await(fiber);
expect(Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)).toBe(true);
expect(signal?.aborted).toBe(true);
expect(otherSignal?.aborted).toBe(false);
expect(runtimeMock.state.sessionCalls).toEqual([
"abort cancelled-session",
"delete cancelled-session",
]);
expect(runtimeMock.state.closeCalls).toEqual([]);
otherReply.resolve({
data: {
parts: [{ type: "text", text: '{"subject":"Other generation completed","body":""}' }],
},
});
expect((yield* Fiber.join(otherFiber)).subject).toBe("Other generation completed");
expect(runtimeMock.state.startCalls).toEqual(["fake-opencode"]);
expect(runtimeMock.state.promptUrls).toEqual([
"http://127.0.0.1:4301",
"http://127.0.0.1:4301",
]);
expect(runtimeMock.state.sessionCalls).toEqual([
"abort cancelled-session",
"delete cancelled-session",
"delete other-session",
]);
expect(runtimeMock.state.closeCalls).toEqual([]);
}),
),
);
it.effect("excludes generic files from thread title generation", () =>
withOpenCodeTextGeneration(DEFAULT_OPENCODE_SETTINGS, (textGeneration) =>
Effect.gen(function* () {
runtimeMock.state.promptResult = {
data: {
parts: [{ type: "text", text: '{"title":"Review uploaded report"}' }],
},
};
yield* textGeneration.generateThreadTitle({
cwd: process.cwd(),
message: "Review these attachments.",
modelSelection: DEFAULT_TEST_MODEL_SELECTION,
attachments: [
{
type: "image",
id: "thread-image-attachment",
name: "screenshot.png",
mimeType: "image/png",
sizeBytes: 3,
},
{
type: "file",
id: "thread-report-attachment-pdf",
name: "report.pdf",
mimeType: "application/pdf",
sizeBytes: 42,
},
],
});
expect(runtimeMock.state.promptParts[0]).toEqual([
expect.objectContaining({ type: "text" }),
expect.objectContaining({ type: "file", filename: "screenshot.png" }),
]);
}),
),
);
it.effect("gives up and aborts the session when a prompt never settles", () =>
withOpenCodeTextGeneration(DEFAULT_OPENCODE_SETTINGS, (textGeneration) =>
Effect.gen(function* () {
const started = yield* Deferred.make<AbortSignal | undefined>();
let sessionAborts = 0;
runtimeMock.state.onPrompt = (signal) => {
Deferred.doneUnsafe(started, Effect.succeed(signal));
return new Promise<never>(() => {});
};
runtimeMock.state.onAbort = () => {
sessionAborts += 1;
return Promise.reject(new Error("abort observed"));
};
const fiber = yield* textGeneration
.generateCommitMessage(DEFAULT_COMMIT_MESSAGE_INPUT)
.pipe(Effect.forkChild);
const signal = yield* Deferred.await(started);
yield* TestClock.adjust(Duration.minutes(3));
const error = yield* Fiber.join(fiber).pipe(Effect.flip);
expect(error).toBeInstanceOf(TextGenerationError);
expect(error.detail).toBe("OpenCode did not finish generating in time.");
expect(signal?.aborted).toBe(true);
expect(sessionAborts).toBe(1);
}),
),
);
it.effect("uses an environment-only password for a locally spawned server", () =>
withOpenCodeTextGeneration(
DEFAULT_OPENCODE_SETTINGS,
(textGeneration) =>
Effect.gen(function* () {
yield* textGeneration.generateCommitMessage(DEFAULT_COMMIT_MESSAGE_INPUT);
expect(runtimeMock.state.authHeaders).toEqual([
`Basic ${btoa("opencode:environment-password")}`,
]);
}),
{ OPENCODE_SERVER_PASSWORD: "environment-password" },
),
);
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");
expect(runtimeMock.state.sessionCalls).toEqual(["delete http://127.0.0.1:4301/session"]);
}),
),
);
it.effect(
"maps OpenCode prompt errors to fixed details and keeps provider text in the cause",
() =>
Effect.forEach(
[
{
error: {
name: "APIError",
data: {
message: "Org quota secret-org exceeded",
statusCode: 429,
isRetryable: true,
},
},
rawText: "secret-org",
detail: "The model provider's usage or rate limit was reached. Try again later.",
},
{
error: {
name: "APIError",
data: {
message: "<none>",
statusCode: 503,
isRetryable: true,
responseBody: "<title>Upstream gateway secret-host</title>",
},
},
rawText: "secret-host",
detail: "The model provider failed the request (HTTP 503).",
},
{
error: { name: "UnknownError", data: { message: "Provider stack trace secret-token" } },
rawText: "secret-token",
detail: "OpenCode could not generate the text.",
},
],
(testCase) =>
withOpenCodeTextGeneration(DEFAULT_OPENCODE_SETTINGS, (textGeneration) =>
Effect.gen(function* () {
runtimeMock.state.promptResult = {
data: { info: { error: testCase.error }, parts: [] },
};
const error = yield* textGeneration
.generateCommitMessage(DEFAULT_COMMIT_MESSAGE_INPUT)
.pipe(Effect.flip);
expect(error.detail).toBe(testCase.detail);
expect(error.message).not.toContain(testCase.rawText);
expect(error.cause).toMatchObject({
_tag: "OpenCodeTextGenerationPromptResponseError",
providerErrorName: testCase.error.name,
cause: testCase.error,
});
expect((error.cause as Error).message).not.toContain(testCase.rawText);
}),
),
{ discard: true },
),
);
it.effect("deletes the session when the prompt request rejects", () =>
withOpenCodeTextGeneration(DEFAULT_OPENCODE_SETTINGS, (textGeneration) =>
Effect.gen(function* () {
runtimeMock.state.promptRequestError = new Error("prompt transport failed");
const error = yield* textGeneration
.generateCommitMessage(DEFAULT_COMMIT_MESSAGE_INPUT)
.pipe(Effect.flip);
expect(error.detail).toBe("OpenCode session.prompt request failed.");
expect(runtimeMock.state.sessionCalls).toEqual(["delete http://127.0.0.1:4301/session"]);
}),
),
);
it.effect("parses JSON returned as plain text output", () =>
withOpenCodeTextGeneration(DEFAULT_OPENCODE_SETTINGS, (textGeneration) =>
Effect.gen(function* () {
runtimeMock.state.promptResult = {
data: {
parts: [
{
type: "text",
text: 'Here is the result:\n{"subject":"Tighten OpenCode parsing","body":"Handle JSON text output locally."}',
},
],
},
};
const result = 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,
});
expect(result).toEqual({
subject: "Tighten OpenCode parsing",
body: "Handle JSON text output locally.",
});
}),
),
);
});
it.layer(layerOpenCodeTextGenerationExistingServerTest)(
"OpenCodeTextGeneration with configured server URL",
(it) => {
it.effect("does not send a local environment password to a configured server", () =>
withOpenCodeTextGeneration(
EXTERNAL_SERVER_WITHOUT_AUTH_OPENCODE_SETTINGS,
(textGeneration) =>
Effect.gen(function* () {
yield* textGeneration.generateCommitMessage(DEFAULT_COMMIT_MESSAGE_INPUT);
expect(runtimeMock.state.authHeaders).toEqual([null]);
}),
{ OPENCODE_SERVER_PASSWORD: "local-secret" },
),
);
it.effect("does not create a session when the server version is unsupported", () =>
withOpenCodeTextGeneration(EXISTING_SERVER_OPENCODE_SETTINGS, (textGeneration) =>
Effect.gen(function* () {
runtimeMock.state.connectionError = new Error(
"OpenCode v1.14.18 is too old. Upgrade to v1.14.19 or newer.",
);
const error = yield* textGeneration
.generateCommitMessage(DEFAULT_COMMIT_MESSAGE_INPUT)
.pipe(Effect.flip);
expect(error).toBeInstanceOf(TextGenerationError);
expect(error.message).toContain("v1.14.18 is too old");
expect(runtimeMock.state.sessionCreateCalls).toBe(0);
}),
),
);
it.effect("reuses a configured OpenCode server URL without spawning or applying idle TTL", () =>
withOpenCodeTextGeneration(EXISTING_SERVER_OPENCODE_SETTINGS, (textGeneration) =>
Effect.gen(function* () {
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,
});
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,
});
expect(runtimeMock.state.startCalls).toEqual([]);
expect(runtimeMock.state.sessionCalls).toEqual([
"delete http://127.0.0.1:9999/session",
"delete http://127.0.0.1:9999/session",
]);
expect(runtimeMock.state.promptUrls).toEqual([
"http://127.0.0.1:9999",
"http://127.0.0.1:9999",
]);
expect(runtimeMock.state.authHeaders).toEqual([
`Basic ${btoa("opencode:secret-password")}`,
`Basic ${btoa("opencode:secret-password")}`,
]);
yield* advanceIdleClock;
expect(runtimeMock.state.closeCalls).toEqual([]);
}),
).pipe(Effect.provide(TestClock.layer())),
);
},
);