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