Open History to see the last commit
1import * as Effect from "effect/Effect";
2import * as Schema from "effect/Schema";
3
4import { NonNegativeInt, settingsSecretLiteral, TextGenerationError } from "@t3tools/contracts";
5import type { OpenCodeSettings } from "../settings.ts";
6import { getModelSelectionStringOptionValue } from "@t3tools/shared/model";
7
8import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost";
9import * as TextGenerationOperations from "@t3tools/provider-core/server/textGenerationOperations";
10import * as OpenCodeRuntime from "./OpenCodeRuntime.ts";
11import * as OpenCodeServerOwner from "./OpenCodeServerOwner.ts";
12
13const GENERATION_TIMEOUT = "3 minutes";
14
15const OpenCodeTextGenerationOperation = Schema.Literals([
16 "generateCommitMessage",
17 "generatePrContent",
18 "generateBranchName",
19 "generateThreadTitle",
20 "generateReviewGuide",
21 "generateTranscriptionPostProcessing",
22]);
23
24const openCodeTextGenerationErrorContext = {
25 operation: OpenCodeTextGenerationOperation,
26 cwd: Schema.String,
27};
28
29export class OpenCodeTextGenerationSessionRequestError extends Schema.TaggedError<OpenCodeTextGenerationSessionRequestError>()(
30 "OpenCodeTextGenerationSessionRequestError",
31 {
32 ...openCodeTextGenerationErrorContext,
33 cause: Schema.Defect(),
34 },
35) {
36 override get message(): string {
37 return `OpenCode session creation request failed for ${this.operation} in ${this.cwd}.`;
38 }
39}
40
41export class OpenCodeTextGenerationSessionPayloadError extends Schema.TaggedError<OpenCodeTextGenerationSessionPayloadError>()(
42 "OpenCodeTextGenerationSessionPayloadError",
43 openCodeTextGenerationErrorContext,
44) {
45 override get message(): string {
46 return `OpenCode session.create returned no session payload for ${this.operation} in ${this.cwd}.`;
47 }
48}
49
50const openCodePromptErrorContext = {
51 ...openCodeTextGenerationErrorContext,
52 sessionId: Schema.String,
53 providerId: Schema.String,
54 modelId: Schema.String,
55};
56
57export class OpenCodeTextGenerationPromptRequestError extends Schema.TaggedError<OpenCodeTextGenerationPromptRequestError>()(
58 "OpenCodeTextGenerationPromptRequestError",
59 {
60 ...openCodePromptErrorContext,
61 cause: Schema.Defect(),
62 },
63) {
64 override get message(): string {
65 return `OpenCode prompt request failed for ${this.operation} in ${this.cwd} using ${this.providerId}/${this.modelId} (session ${this.sessionId}).`;
66 }
67}
68
69export class OpenCodeTextGenerationPromptResponseError extends Schema.TaggedError<OpenCodeTextGenerationPromptResponseError>()(
70 "OpenCodeTextGenerationPromptResponseError",
71 {
72 ...openCodePromptErrorContext,
73 providerErrorName: Schema.optional(Schema.String),
74 statusCode: Schema.optional(Schema.Int),
75 cause: Schema.Defect(),
76 },
77) {
78 override get message(): string {
79 const providerError = this.providerErrorName ? ` ${this.providerErrorName}` : "";
80 const status = this.statusCode === undefined ? "" : `, HTTP ${this.statusCode}`;
81 return `OpenCode prompt${providerError} failed for ${this.operation} in ${this.cwd} using ${this.providerId}/${this.modelId} (session ${this.sessionId}${status}).`;
82 }
83}
84
85function openCodePromptResponseErrorDetail(error: OpenCodeTextGenerationPromptResponseError) {
86 if (
87 error.providerErrorName === "ProviderAuthError" ||
88 error.statusCode === 401 ||
89 error.statusCode === 403
90 ) {
91 return "The model provider rejected the credentials. Check the provider's sign-in or API key in OpenCode.";
92 }
93 if (error.statusCode === 429) {
94 return "The model provider's usage or rate limit was reached. Try again later.";
95 }
96 if (error.providerErrorName === "ContextOverflowError") {
97 return "The prompt is too long for the selected model's context window.";
98 }
99 if (error.providerErrorName === "MessageAbortedError") {
100 return "OpenCode stopped the generation.";
101 }
102 if (error.statusCode !== undefined) {
103 return `The model provider failed the request (HTTP ${error.statusCode}).`;
104 }
105 return "OpenCode could not generate the text.";
106}
107
108export class OpenCodeTextGenerationEmptyOutputError extends Schema.TaggedError<OpenCodeTextGenerationEmptyOutputError>()(
109 "OpenCodeTextGenerationEmptyOutputError",
110 {
111 ...openCodePromptErrorContext,
112 responsePartCount: NonNegativeInt,
113 textPartCount: NonNegativeInt,
114 },
115) {
116 override get message(): string {
117 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).`;
118 }
119}
120
121interface OpenCodePromptFailure {
122 readonly name?: string;
123 readonly statusCode?: number;
124}
125
126interface OpenCodeTextPart {
127 readonly type: "text";
128 readonly text: string;
129}
130
131function getOpenCodePromptFailure(error: unknown): OpenCodePromptFailure | null {
132 if (!error || typeof error !== "object") {
133 return null;
134 }
135
136 const name =
137 "name" in error && typeof error.name === "string" && error.name.trim().length > 0
138 ? error.name.trim()
139 : undefined;
140 const data = "data" in error && error.data && typeof error.data === "object" ? error.data : {};
141 const statusCode =
142 "statusCode" in data && typeof data.statusCode === "number" && Number.isInteger(data.statusCode)
143 ? data.statusCode
144 : undefined;
145 const hasMessage =
146 "message" in data && typeof data.message === "string" && data.message.trim().length > 0;
147 if (!name && statusCode === undefined && !hasMessage) {
148 return null;
149 }
150
151 return {
152 ...(name ? { name } : {}),
153 ...(statusCode !== undefined ? { statusCode } : {}),
154 };
155}
156
157function isOpenCodeTextPart(part: unknown): part is OpenCodeTextPart {
158 return (
159 part !== null &&
160 typeof part === "object" &&
161 "type" in part &&
162 part.type === "text" &&
163 "text" in part &&
164 typeof part.text === "string"
165 );
166}
167
168function getOpenCodeTextResponse(parts: ReadonlyArray<unknown> | undefined): string {
169 return (parts ?? [])
170 .filter(isOpenCodeTextPart)
171 .map((part) => part.text)
172 .join("")
173 .trim();
174}
175
176export const makeOpenCodeTextGeneration = Effect.fn("makeOpenCodeTextGeneration")(function* (
177 openCodeSettings: OpenCodeSettings,
178) {
179 const host = yield* ProviderHost.ProviderHost;
180 const openCodeRuntime = yield* OpenCodeRuntime.OpenCodeRuntime;
181 const serverOwner = yield* OpenCodeServerOwner.OpenCodeServerOwner;
182
183 const runOpenCodeJson = Effect.fn("runOpenCodeJson")(function* <S extends Schema.Top>(
184 input: TextGenerationOperations.Request<S>,
185 ) {
186 const parsedModel = OpenCodeRuntime.parseOpenCodeModelSlug(input.modelSelection.model);
187 if (!parsedModel) {
188 return yield* new TextGenerationError({
189 operation: input.operation,
190 detail: "OpenCode model selection must use the 'provider/model' format.",
191 });
192 }
193
194 const fileParts = OpenCodeRuntime.toOpenCodeFileParts({
195 attachments: input.attachments?.filter((attachment) => attachment.type === "image"),
196 resolveAttachmentPath: host.resolveAttachmentPath,
197 });
198
199 const runAgainstServer = Effect.fn("runOpenCodeJson.runAgainstServer")(
200 function* (
201 server: Pick<
202 OpenCodeRuntime.OpenCodeServerConnection,
203 "url" | "serverPassword" | "version"
204 >,
205 ) {
206 const client = openCodeRuntime.createOpenCodeSdkClient({
207 baseUrl: server.url,
208 directory: input.cwd,
209 ...(server.serverPassword !== undefined ? { serverPassword: server.serverPassword } : {}),
210 });
211 const session = yield* Effect.tryPromise({
212 try: (signal) =>
213 client.session.create(
214 {
215 title: `T3 Code ${input.operation}`,
216 // OpenCode Zen refuses free-model requests that carry no tools, so keep read.
217 permission: [
218 { permission: "*", pattern: "*", action: "deny" },
219 { permission: "read", pattern: "*", action: "allow" },
220 ],
221 },
222 { signal },
223 ),
224 catch: (cause) =>
225 new OpenCodeTextGenerationSessionRequestError({
226 operation: input.operation,
227 cwd: input.cwd,
228 cause,
229 }),
230 });
231 if (!session.data) {
232 return yield* new OpenCodeTextGenerationSessionPayloadError({
233 operation: input.operation,
234 cwd: input.cwd,
235 });
236 }
237 yield* Effect.addFinalizer(() =>
238 OpenCodeRuntime.runOpenCodeSdk("session.delete", (signal) =>
239 client.session.delete({ sessionID: session.data.id }, { signal }),
240 ).pipe(Effect.timeout("5 seconds"), Effect.ignore({ log: "Warn" })),
241 );
242 const selectedAgent = getModelSelectionStringOptionValue(input.modelSelection, "agent");
243 const selectedVariant = yield* OpenCodeRuntime.resolveOpenCodeVariant(
244 client,
245 parsedModel,
246 getModelSelectionStringOptionValue(input.modelSelection, "variant"),
247 );
248 const promptContext = {
249 operation: input.operation,
250 cwd: input.cwd,
251 sessionId: session.data.id,
252 providerId: parsedModel.providerID,
253 modelId: parsedModel.modelID,
254 };
255
256 const result = yield* Effect.tryPromise({
257 try: (signal) =>
258 client.session.prompt(
259 {
260 sessionID: session.data.id,
261 model: parsedModel,
262 ...(selectedAgent ? { agent: selectedAgent } : {}),
263 ...(selectedVariant ? { variant: selectedVariant } : {}),
264 parts: [{ type: "text", text: input.prompt }, ...fileParts],
265 },
266 { signal },
267 ),
268 catch: (cause) =>
269 new OpenCodeTextGenerationPromptRequestError({
270 ...promptContext,
271 cause,
272 }),
273 }).pipe(
274 // Disconnecting the HTTP request does not stop work in a shared or external server.
275 Effect.onInterrupt(() =>
276 OpenCodeRuntime.runOpenCodeSdk("session.abort", (signal) =>
277 client.session.abort({ sessionID: session.data.id }, { signal }),
278 ).pipe(
279 Effect.interruptible,
280 Effect.timeout("10 seconds"),
281 Effect.catch(() =>
282 Effect.logWarning(
283 "Failed to stop cancelled OpenCode text generation.",
284 promptContext,
285 ),
286 ),
287 Effect.asVoid,
288 ),
289 ),
290 );
291 const promptError = result.data?.info?.error;
292 const promptFailure = getOpenCodePromptFailure(promptError);
293 if (promptFailure) {
294 return yield* new OpenCodeTextGenerationPromptResponseError({
295 ...promptContext,
296 ...(promptFailure.name ? { providerErrorName: promptFailure.name } : {}),
297 ...(promptFailure.statusCode !== undefined
298 ? { statusCode: promptFailure.statusCode }
299 : {}),
300 cause: promptError,
301 });
302 }
303 const responseParts = result.data?.parts ?? [];
304 const rawText = getOpenCodeTextResponse(responseParts);
305 if (rawText.length === 0) {
306 return yield* new OpenCodeTextGenerationEmptyOutputError({
307 ...promptContext,
308 responsePartCount: responseParts.length,
309 textPartCount: responseParts.filter(isOpenCodeTextPart).length,
310 });
311 }
312 return rawText;
313 },
314 Effect.scoped,
315 Effect.catchTags({
316 OpenCodeTextGenerationSessionRequestError: (cause) =>
317 Effect.fail(
318 new TextGenerationError({
319 operation: cause.operation,
320 detail: "OpenCode session.create request failed.",
321 cause,
322 }),
323 ),
324 OpenCodeTextGenerationSessionPayloadError: (cause) =>
325 Effect.fail(
326 new TextGenerationError({
327 operation: cause.operation,
328 detail: "OpenCode session.create returned no session payload.",
329 cause,
330 }),
331 ),
332 OpenCodeTextGenerationPromptRequestError: (cause) =>
333 Effect.fail(
334 new TextGenerationError({
335 operation: cause.operation,
336 detail: "OpenCode session.prompt request failed.",
337 cause,
338 }),
339 ),
340 OpenCodeTextGenerationPromptResponseError: (cause) =>
341 Effect.fail(
342 new TextGenerationError({
343 operation: cause.operation,
344 detail: openCodePromptResponseErrorDetail(cause),
345 cause,
346 }),
347 ),
348 OpenCodeTextGenerationEmptyOutputError: (cause) =>
349 Effect.fail(
350 new TextGenerationError({
351 operation: cause.operation,
352 detail: "OpenCode returned empty output.",
353 cause,
354 }),
355 ),
356 }),
357 );
358
359 const serverOutput =
360 openCodeSettings.serverUrl.length > 0
361 ? openCodeRuntime
362 .connectToOpenCodeServer({
363 binaryPath: openCodeSettings.binaryPath,
364 directory: input.cwd,
365 serverUrl: openCodeSettings.serverUrl,
366 ...(settingsSecretLiteral(openCodeSettings.serverPassword)
367 ? { serverPassword: settingsSecretLiteral(openCodeSettings.serverPassword) }
368 : {}),
369 })
370 .pipe(Effect.flatMap(runAgainstServer), Effect.scoped)
371 : serverOwner.withServer(runAgainstServer);
372 const rawOutput = yield* serverOutput.pipe(
373 Effect.timeoutOrElse({
374 duration: GENERATION_TIMEOUT,
375 orElse: () =>
376 Effect.fail(
377 new TextGenerationError({
378 operation: input.operation,
379 detail: "OpenCode did not finish generating in time.",
380 }),
381 ),
382 }),
383 Effect.catchTags({
384 OpenCodeRuntimeError: (cause) =>
385 Effect.fail(
386 new TextGenerationError({
387 operation: input.operation,
388 detail: OpenCodeRuntime.openCodeRuntimeErrorDetail(cause),
389 cause,
390 }),
391 ),
392 }),
393 );
394
395 return yield* TextGenerationOperations.decodeJsonReply(input, "OpenCode", rawOutput);
396 });
397
398 return TextGenerationOperations.fromRunner(
399 "OpenCodeTextGeneration",
400 TextGenerationOperations.withoutInvestigation("OpenCode", runOpenCodeJson),
401 );
402});