@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 417 lines 14.7 KB
Raw
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 });