import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";
import { NonNegativeInt, settingsSecretLiteral, TextGenerationError } from "@t3tools/contracts";
import type { OpenCodeSettings } from "../settings.ts";
import { getModelSelectionStringOptionValue } from "@t3tools/shared/model";
import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost";
import * as TextGenerationOperations from "@t3tools/provider-core/server/textGenerationOperations";
import * as OpenCodeRuntime from "./OpenCodeRuntime.ts";
import * as OpenCodeServerOwner from "./OpenCodeServerOwner.ts";
const GENERATION_TIMEOUT = "3 minutes";
const OpenCodeTextGenerationOperation = Schema.Literals([
"generateCommitMessage",
"generatePrContent",
"generateBranchName",
"generateThreadTitle",
"generateReviewGuide",
"generateTranscriptionPostProcessing",
]);
const openCodeTextGenerationErrorContext = {
operation: OpenCodeTextGenerationOperation,
cwd: Schema.String,
};
export class OpenCodeTextGenerationSessionRequestError extends Schema.TaggedError<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.TaggedError<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.TaggedError<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.TaggedError<OpenCodeTextGenerationPromptResponseError>()(
"OpenCodeTextGenerationPromptResponseError",
{
...openCodePromptErrorContext,
providerErrorName: Schema.optional(Schema.String),
statusCode: Schema.optional(Schema.Int),
cause: Schema.Defect(),
},
) {
override get message(): string {
const providerError = this.providerErrorName ? ` ${this.providerErrorName}` : "";
const status = this.statusCode === undefined ? "" : `, HTTP ${this.statusCode}`;
return `OpenCode prompt${providerError} failed for ${this.operation} in ${this.cwd} using ${this.providerId}/${this.modelId} (session ${this.sessionId}${status}).`;
}
}
function openCodePromptResponseErrorDetail(error: OpenCodeTextGenerationPromptResponseError) {
if (
error.providerErrorName === "ProviderAuthError" ||
error.statusCode === 401 ||
error.statusCode === 403
) {
return "The model provider rejected the credentials. Check the provider's sign-in or API key in OpenCode.";
}
if (error.statusCode === 429) {
return "The model provider's usage or rate limit was reached. Try again later.";
}
if (error.providerErrorName === "ContextOverflowError") {
return "The prompt is too long for the selected model's context window.";
}
if (error.providerErrorName === "MessageAbortedError") {
return "OpenCode stopped the generation.";
}
if (error.statusCode !== undefined) {
return `The model provider failed the request (HTTP ${error.statusCode}).`;
}
return "OpenCode could not generate the text.";
}
export class OpenCodeTextGenerationEmptyOutputError extends Schema.TaggedError<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 statusCode?: number;
}
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 data = "data" in error && error.data && typeof error.data === "object" ? error.data : {};
const statusCode =
"statusCode" in data && typeof data.statusCode === "number" && Number.isInteger(data.statusCode)
? data.statusCode
: undefined;
const hasMessage =
"message" in data && typeof data.message === "string" && data.message.trim().length > 0;
if (!name && statusCode === undefined && !hasMessage) {
return null;
}
return {
...(name ? { name } : {}),
...(statusCode !== undefined ? { statusCode } : {}),
};
}
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 ?? [])
.filter(isOpenCodeTextPart)
.map((part) => part.text)
.join("")
.trim();
}
export const makeOpenCodeTextGeneration = Effect.fn("makeOpenCodeTextGeneration")(function* (
openCodeSettings: OpenCodeSettings,
) {
const host = yield* ProviderHost.ProviderHost;
const openCodeRuntime = yield* OpenCodeRuntime.OpenCodeRuntime;
const serverOwner = yield* OpenCodeServerOwner.OpenCodeServerOwner;
const runOpenCodeJson = Effect.fn("runOpenCodeJson")(function* <S extends Schema.Top>(
input: TextGenerationOperations.Request<S>,
) {
const parsedModel = OpenCodeRuntime.parseOpenCodeModelSlug(input.modelSelection.model);
if (!parsedModel) {
return yield* new TextGenerationError({
operation: input.operation,
detail: "OpenCode model selection must use the 'provider/model' format.",
});
}
const fileParts = OpenCodeRuntime.toOpenCodeFileParts({
attachments: input.attachments?.filter((attachment) => attachment.type === "image"),
resolveAttachmentPath: host.resolveAttachmentPath,
});
const runAgainstServer = Effect.fn("runOpenCodeJson.runAgainstServer")(
function* (
server: Pick<
OpenCodeRuntime.OpenCodeServerConnection,
"url" | "serverPassword" | "version"
>,
) {
const client = openCodeRuntime.createOpenCodeSdkClient({
baseUrl: server.url,
directory: input.cwd,
...(server.serverPassword !== undefined ? { serverPassword: server.serverPassword } : {}),
});
const session = yield* Effect.tryPromise({
try: (signal) =>
client.session.create(
{
title: `T3 Code ${input.operation}`,
// OpenCode Zen refuses free-model requests that carry no tools, so keep read.
permission: [
{ permission: "*", pattern: "*", action: "deny" },
{ permission: "read", pattern: "*", action: "allow" },
],
},
{ signal },
),
catch: (cause) =>
new OpenCodeTextGenerationSessionRequestError({
operation: input.operation,
cwd: input.cwd,
cause,
}),
});
if (!session.data) {
return yield* new OpenCodeTextGenerationSessionPayloadError({
operation: input.operation,
cwd: input.cwd,
});
}
yield* Effect.addFinalizer(() =>
OpenCodeRuntime.runOpenCodeSdk("session.delete", (signal) =>
client.session.delete({ sessionID: session.data.id }, { signal }),
).pipe(Effect.timeout("5 seconds"), Effect.ignore({ log: "Warn" })),
);
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: (signal) =>
client.session.prompt(
{
sessionID: session.data.id,
model: parsedModel,
...(selectedAgent ? { agent: selectedAgent } : {}),
...(selectedVariant ? { variant: selectedVariant } : {}),
parts: [{ type: "text", text: input.prompt }, ...fileParts],
},
{ signal },
),
catch: (cause) =>
new OpenCodeTextGenerationPromptRequestError({
...promptContext,
cause,
}),
}).pipe(
// Disconnecting the HTTP request does not stop work in a shared or external server.
Effect.onInterrupt(() =>
OpenCodeRuntime.runOpenCodeSdk("session.abort", (signal) =>
client.session.abort({ sessionID: session.data.id }, { signal }),
).pipe(
Effect.interruptible,
Effect.timeout("10 seconds"),
Effect.catch(() =>
Effect.logWarning(
"Failed to stop cancelled OpenCode text generation.",
promptContext,
),
),
Effect.asVoid,
),
),
);
const promptError = result.data?.info?.error;
const promptFailure = getOpenCodePromptFailure(promptError);
if (promptFailure) {
return yield* new OpenCodeTextGenerationPromptResponseError({
...promptContext,
...(promptFailure.name ? { providerErrorName: promptFailure.name } : {}),
...(promptFailure.statusCode !== undefined
? { statusCode: promptFailure.statusCode }
: {}),
cause: promptError,
});
}
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,
});
}
return rawText;
},
Effect.scoped,
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: openCodePromptResponseErrorDetail(cause),
cause,
}),
),
OpenCodeTextGenerationEmptyOutputError: (cause) =>
Effect.fail(
new TextGenerationError({
operation: cause.operation,
detail: "OpenCode returned empty output.",
cause,
}),
),
}),
);
const serverOutput =
openCodeSettings.serverUrl.length > 0
? openCodeRuntime
.connectToOpenCodeServer({
binaryPath: openCodeSettings.binaryPath,
directory: input.cwd,
serverUrl: openCodeSettings.serverUrl,
...(settingsSecretLiteral(openCodeSettings.serverPassword)
? { serverPassword: settingsSecretLiteral(openCodeSettings.serverPassword) }
: {}),
})
.pipe(Effect.flatMap(runAgainstServer), Effect.scoped)
: serverOwner.withServer(runAgainstServer);
const rawOutput = yield* serverOutput.pipe(
Effect.timeoutOrElse({
duration: GENERATION_TIMEOUT,
orElse: () =>
Effect.fail(
new TextGenerationError({
operation: input.operation,
detail: "OpenCode did not finish generating in time.",
}),
),
}),
Effect.catchTags({
OpenCodeRuntimeError: (cause) =>
Effect.fail(
new TextGenerationError({
operation: input.operation,
detail: OpenCodeRuntime.openCodeRuntimeErrorDetail(cause),
cause,
}),
),
}),
);
return yield* TextGenerationOperations.decodeJsonReply(input, "OpenCode", rawOutput);
});
return TextGenerationOperations.fromRunner(
"OpenCodeTextGeneration",
TextGenerationOperations.withoutInvestigation("OpenCode", runOpenCodeJson),
);
});