Open History to see the last commit
1import * as Context from "effect/Context";
2import * as Effect from "effect/Effect";
3import * as Layer from "effect/Layer";
4import type { ModelSelection, ProjectId, ProviderInstanceId } from "@t3tools/contracts";
5import {
6 isProviderAvailable,
7 isProviderTextGenerationCapable,
8 resolveProjectProviderInstanceEnabled,
9} from "@t3tools/contracts";
10import * as DateTime from "effect/DateTime";
11import { exhaustedUsageWindow } from "@t3tools/shared/usageLimits";
12import { fallbackTextGenerationModelSelection } from "@t3tools/shared/serverSettings";
13import * as ServerSettings from "../serverSettings.ts";
14import type { ProviderTextGeneration } from "@t3tools/provider-core/server/textGeneration";
15import { TextGenerationError } from "@t3tools/contracts";
16
17import * as ProviderInstallationGate from "../provider/ProviderInstallationGate.ts";
18import * as ProviderInstanceRegistry from "../provider/ProviderInstanceRegistry.ts";
19import type { ProviderInstance } from "@t3tools/provider-core/server/driver";
20import * as SourceControlProviderRegistry from "../sourceControl/SourceControlProviderRegistry.ts";
21import * as ThreadTitleLinks from "./ThreadTitleLinks.ts";
22import * as TextGenerators from "./TextGenerators.ts";
23import * as TextGenerationOperations from "@t3tools/provider-core/server/textGenerationOperations";
24
25export type {
26 BranchNameGenerationInput,
27 BranchNameGenerationResult,
28 CommitMessageGenerationInput,
29 CommitMessageGenerationResult,
30 PrContentGenerationInput,
31 PrContentGenerationResult,
32 ReviewGuideGenerationInput,
33 ReviewGuideGenerationResult,
34 ThreadTitleGenerationInput,
35 ThreadTitleGenerationResult,
36 TranscriptionPostProcessingInput,
37 TranscriptionPostProcessingResult,
38} from "@t3tools/provider-core/server/textGeneration";
39
40export class TextGeneration extends Context.Service<TextGeneration, ProviderTextGeneration>()(
41 "t3/textGeneration/TextGeneration",
42) {}
43
44type TextGenerationOp =
45 | "generateCommitMessage"
46 | "generatePrContent"
47 | "generateBranchName"
48 | "generateThreadTitle"
49 | "generateReviewGuide"
50 | "generateTranscriptionPostProcessing";
51
52const resolveInstance = (
53 registry: ProviderInstanceRegistry.ProviderInstanceRegistry["Service"],
54 operation: TextGenerationOp,
55 instanceId: ProviderInstanceId,
56): Effect.Effect<ProviderInstance["textGeneration"], TextGenerationError> =>
57 registry.getInstance(instanceId).pipe(
58 Effect.flatMap((instance) =>
59 instance
60 ? Effect.succeed(instance.textGeneration)
61 : Effect.fail(
62 new TextGenerationError({
63 operation,
64 detail: `No provider instance registered for id '${instanceId}'.`,
65 }),
66 ),
67 ),
68 );
69
70// Review guides investigate the checkout read-only; the other drivers reject that request.
71const INVESTIGATING_DRIVERS = new Set(["codex", "claudeAgent"]);
72
73/** @public */
74export const make = Effect.gen(function* () {
75 const registry = yield* ProviderInstanceRegistry.ProviderInstanceRegistry;
76 const sourceControl = yield* SourceControlProviderRegistry.SourceControlProviderRegistry;
77 const serverSettings = yield* ServerSettings.ServerSettingsService;
78 const installationGate = yield* ProviderInstallationGate.ProviderInstallationGate;
79 const textGenerators = yield* TextGenerators.TextGenerators;
80 const generate = Effect.fn("TextGeneration.generate")(function* <A>(
81 operation: TextGenerationOp,
82 selection: ModelSelection,
83 projectId: ProjectId | null | undefined,
84 invoke: (
85 service: ProviderTextGeneration,
86 modelSelection: ModelSelection,
87 ) => Effect.Effect<A, TextGenerationError>,
88 ) {
89 const textGenerator = yield* textGenerators.runner(selection.instanceId);
90 // A review guide reaches a text generator only through a fallback; it needs an agent instead.
91 const textGeneratorId = selection.instanceId;
92 const textGeneratorCannotRun =
93 textGenerator !== undefined && operation === "generateReviewGuide";
94 if (textGenerator !== undefined && !textGeneratorCannotRun) {
95 return yield* invoke(
96 TextGenerationOperations.fromRunner("TextGenerator", textGenerator),
97 selection,
98 );
99 }
100 const snapshots = yield* registry.listInstances.pipe(
101 Effect.flatMap((instances) =>
102 Effect.forEach(instances, (instance) => instance.snapshot.getSnapshot),
103 ),
104 );
105 const now = DateTime.toEpochMillis(yield* DateTime.now);
106 const selected = snapshots.find((provider) => provider.instanceId === selection.instanceId);
107 // Only a failed probe counts: a pending one is also not installed yet.
108 const unusable =
109 textGeneratorCannotRun ||
110 (selected?.enabled === true &&
111 selected.status === "error" &&
112 (!selected.installed || selected.auth.status === "unauthenticated"));
113 if (unusable || exhaustedUsageWindow(selected, now, selection.model)) {
114 const settings = yield* serverSettings.getSettings.pipe(
115 Effect.mapError(
116 (cause) =>
117 new TextGenerationError({
118 operation,
119 detail: "Could not read fallback model settings.",
120 cause,
121 }),
122 ),
123 );
124 selection =
125 fallbackTextGenerationModelSelection(
126 settings.providerInstances,
127 (instanceId, driver, model) => {
128 const provider = snapshots.find((candidate) => candidate.instanceId === instanceId);
129 return (
130 instanceId !== selection.instanceId &&
131 provider?.enabled === true &&
132 resolveProjectProviderInstanceEnabled(settings, projectId ?? null, instanceId) &&
133 provider.installed &&
134 provider.auth.status !== "unauthenticated" &&
135 provider.status !== "error" &&
136 isProviderAvailable(provider) &&
137 isProviderTextGenerationCapable(provider) &&
138 (operation !== "generateReviewGuide" || INVESTIGATING_DRIVERS.has(driver)) &&
139 !exhaustedUsageWindow(provider, now, model)
140 );
141 },
142 { defaultModelSelection: settings.defaultModelSelection },
143 ) ?? selection;
144 }
145 if (textGeneratorCannotRun && selection.instanceId === textGeneratorId) {
146 return yield* new TextGenerationError({
147 operation,
148 detail:
149 "Review guides need a coding agent that can read the checkout. None is ready. Pick Codex or Claude as the review guide model in Settings → Source control.",
150 });
151 }
152 return yield* installationGate.execute(
153 selection.instanceId,
154 resolveInstance(registry, operation, selection.instanceId).pipe(
155 Effect.flatMap((service) => invoke(service, selection)),
156 ),
157 );
158 });
159 return TextGeneration.of({
160 generateCommitMessage: Effect.fn("TextGeneration.generateCommitMessage")(function (input) {
161 return generate(
162 "generateCommitMessage",
163 input.modelSelection,
164 input.projectId,
165 (service, modelSelection) => service.generateCommitMessage({ ...input, modelSelection }),
166 );
167 }),
168 generatePrContent: Effect.fn("TextGeneration.generatePrContent")(function (input) {
169 return generate(
170 "generatePrContent",
171 input.modelSelection,
172 input.projectId,
173 (service, modelSelection) => service.generatePrContent({ ...input, modelSelection }),
174 );
175 }),
176 generateBranchName: Effect.fn("TextGeneration.generateBranchName")(function (input) {
177 return generate(
178 "generateBranchName",
179 input.modelSelection,
180 input.projectId,
181 (service, modelSelection) => service.generateBranchName({ ...input, modelSelection }),
182 );
183 }),
184 generateReviewGuide: Effect.fn("TextGeneration.generateReviewGuide")(function (input) {
185 return generate(
186 "generateReviewGuide",
187 input.modelSelection,
188 input.projectId,
189 (service, modelSelection) => service.generateReviewGuide({ ...input, modelSelection }),
190 );
191 }),
192 generateTranscriptionPostProcessing: Effect.fn(
193 "TextGeneration.generateTranscriptionPostProcessing",
194 )(function (input) {
195 return generate(
196 "generateTranscriptionPostProcessing",
197 input.modelSelection,
198 null,
199 (service, modelSelection) =>
200 service.generateTranscriptionPostProcessing({ ...input, modelSelection }),
201 );
202 }),
203 generateThreadTitle: Effect.fn("TextGeneration.generateThreadTitle")(function (input) {
204 return generate(
205 "generateThreadTitle",
206 input.modelSelection,
207 input.projectId,
208 (textGeneration, modelSelection) =>
209 Effect.gen(function* () {
210 const linkedContext =
211 input.linkedContext ??
212 (yield* ThreadTitleLinks.resolveThreadTitleLinks(input).pipe(
213 Effect.provideService(
214 SourceControlProviderRegistry.SourceControlProviderRegistry,
215 sourceControl,
216 ),
217 ));
218 return yield* textGeneration.generateThreadTitle({
219 ...input,
220 linkedContext,
221 modelSelection,
222 });
223 }),
224 );
225 }),
226 });
227});
228
229export const layer = Layer.effect(TextGeneration, make).pipe(
230 Layer.provideMerge(TextGenerators.layer),
231);