import * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import type { ModelSelection, ProviderInstanceId } from "@t3tools/contracts";
import {
isProviderAvailable,
isProviderTextGenerationCapable,
resolveProjectProviderInstanceEnabled,
} from "@t3tools/contracts";
import * as DateTime from "effect/DateTime";
import { exhaustedUsageWindow } from "@t3tools/shared/usageLimits";
import {
defaultTextGenerationModel,
fallbackTextGenerationModelSelection,
} from "@t3tools/shared/serverSettings";
import * as ServerSettings from "../serverSettings.ts";
import type { ProviderTextGeneration } from "@t3tools/provider-core/server/textGeneration";
import { TextGenerationError } from "@t3tools/contracts";
import * as ProviderInstanceRegistry from "../provider/ProviderInstanceRegistry.ts";
import type { ProviderInstance } from "@t3tools/provider-core/server/driver";
import * as SourceControlProviderRegistry from "../sourceControl/SourceControlProviderRegistry.ts";
import * as ThreadTitleLinks from "./ThreadTitleLinks.ts";
export type {
BranchNameGenerationInput,
BranchNameGenerationResult,
CommitMessageGenerationInput,
CommitMessageGenerationResult,
PrContentGenerationInput,
PrContentGenerationResult,
ReviewGuideGenerationInput,
ReviewGuideGenerationResult,
ThreadTitleGenerationInput,
ThreadTitleGenerationResult,
TranscriptionPostProcessingInput,
TranscriptionPostProcessingResult,
} from "@t3tools/provider-core/server/textGeneration";
export class TextGeneration extends Context.Service<TextGeneration, ProviderTextGeneration>()(
"t3/textGeneration/TextGeneration",
) {}
type TextGenerationOp =
| "generateCommitMessage"
| "generatePrContent"
| "generateBranchName"
| "generateThreadTitle"
| "generateReviewGuide"
| "generateTranscriptionPostProcessing";
const resolveInstance = (
registry: ProviderInstanceRegistry.ProviderInstanceRegistry["Service"],
operation: TextGenerationOp,
instanceId: ProviderInstanceId,
): Effect.Effect<ProviderInstance["textGeneration"], TextGenerationError> =>
registry.getInstance(instanceId).pipe(
Effect.flatMap((instance) =>
instance
? Effect.succeed(instance.textGeneration)
: Effect.fail(
new TextGenerationError({
operation,
detail: `No provider instance registered for id '${instanceId}'.`,
}),
),
),
);
// Review guides investigate the checkout read-only; the other drivers reject that request.
const INVESTIGATING_DRIVERS = new Set(["codex", "claudeAgent"]);
/** @public */
export const make = Effect.gen(function* () {
const registry = yield* ProviderInstanceRegistry.ProviderInstanceRegistry;
const sourceControl = yield* SourceControlProviderRegistry.SourceControlProviderRegistry;
const serverSettings = yield* ServerSettings.ServerSettingsService;
const generate = Effect.fn("TextGeneration.generate")(function* <A>(
operation: TextGenerationOp,
selection: ModelSelection,
invoke: (
service: ProviderTextGeneration,
modelSelection: ModelSelection,
) => Effect.Effect<A, TextGenerationError>,
) {
const snapshots = yield* registry.listInstances.pipe(
Effect.flatMap((instances) =>
Effect.forEach(instances, (instance) => instance.snapshot.getSnapshot),
),
);
const now = DateTime.toEpochMillis(yield* DateTime.now);
const selected = snapshots.find((provider) => provider.instanceId === selection.instanceId);
// Only a failed probe counts: a pending one is also not installed yet.
const unusable =
selected?.enabled === true &&
selected.status === "error" &&
(!selected.installed || selected.auth.status === "unauthenticated");
if (unusable || exhaustedUsageWindow(selected, now, selection.model)) {
const settings = yield* serverSettings.getSettings.pipe(
Effect.mapError(
(cause) =>
new TextGenerationError({
operation,
detail: "Could not read fallback model settings.",
cause,
}),
),
);
selection =
fallbackTextGenerationModelSelection(
settings.providerInstances,
(instanceId, driver) => {
const provider = snapshots.find((candidate) => candidate.instanceId === instanceId);
return (
instanceId !== selection.instanceId &&
provider?.enabled === true &&
resolveProjectProviderInstanceEnabled(settings, null, instanceId) &&
provider.installed &&
provider.auth.status !== "unauthenticated" &&
provider.status !== "error" &&
isProviderAvailable(provider) &&
isProviderTextGenerationCapable(provider) &&
(operation !== "generateReviewGuide" || INVESTIGATING_DRIVERS.has(driver)) &&
!exhaustedUsageWindow(provider, now, defaultTextGenerationModel(driver))
);
},
{ includeConfiguredInstances: true },
) ?? selection;
}
return yield* resolveInstance(registry, operation, selection.instanceId).pipe(
Effect.flatMap((service) => invoke(service, selection)),
);
});
return TextGeneration.of({
generateCommitMessage: Effect.fn("TextGeneration.generateCommitMessage")(function (input) {
return generate("generateCommitMessage", input.modelSelection, (service, modelSelection) =>
service.generateCommitMessage({ ...input, modelSelection }),
);
}),
generatePrContent: Effect.fn("TextGeneration.generatePrContent")(function (input) {
return generate("generatePrContent", input.modelSelection, (service, modelSelection) =>
service.generatePrContent({ ...input, modelSelection }),
);
}),
generateBranchName: Effect.fn("TextGeneration.generateBranchName")(function (input) {
return generate("generateBranchName", input.modelSelection, (service, modelSelection) =>
service.generateBranchName({ ...input, modelSelection }),
);
}),
generateReviewGuide: Effect.fn("TextGeneration.generateReviewGuide")(function (input) {
return generate("generateReviewGuide", input.modelSelection, (service, modelSelection) =>
service.generateReviewGuide({ ...input, modelSelection }),
);
}),
generateTranscriptionPostProcessing: Effect.fn(
"TextGeneration.generateTranscriptionPostProcessing",
)(function (input) {
return generate(
"generateTranscriptionPostProcessing",
input.modelSelection,
(service, modelSelection) =>
service.generateTranscriptionPostProcessing({ ...input, modelSelection }),
);
}),
generateThreadTitle: Effect.fn("TextGeneration.generateThreadTitle")(function (input) {
return generate(
"generateThreadTitle",
input.modelSelection,
(textGeneration, modelSelection) =>
Effect.gen(function* () {
const linkedContext =
input.linkedContext ??
(yield* ThreadTitleLinks.resolveThreadTitleLinks(input).pipe(
Effect.provideService(
SourceControlProviderRegistry.SourceControlProviderRegistry,
sourceControl,
),
));
return yield* textGeneration.generateThreadTitle({
...input,
linkedContext,
modelSelection,
});
}),
);
}),
});
});
export const layer = Layer.effect(TextGeneration, make);