diff --git a/apps/server/src/git/GitManager.test.ts b/apps/server/src/git/GitManager.test.ts index 634898612b077..90ed65bac560e 100644 --- a/apps/server/src/git/GitManager.test.ts +++ b/apps/server/src/git/GitManager.test.ts @@ -28,6 +28,7 @@ import type { GitActionProgressEvent, GitPreparePullRequestThreadInput, ModelSelection, + ServerProvider, } from "@t3tools/contracts"; import { @@ -601,6 +602,7 @@ function makeManager(input?: { sourceControlProvider?: SourceControlProvider["Service"]; textGeneration?: Partial; serverSettings?: Parameters[0]; + providers?: ReadonlyArray; setupScriptRunner?: ProjectSetupScriptRunner.ProjectSetupScriptRunner["Service"]; gitConfigReads?: string[]; gitCommands?: string[]; @@ -707,7 +709,7 @@ function makeManager(input?: { const layerManager = Layer.mergeAll( Layer.succeed(TextGeneration.TextGeneration, textGeneration), Layer.mock(ProviderRegistry.ProviderRegistry)({ - getProviders: Effect.succeed([]), + getProviders: Effect.succeed(input?.providers ?? []), }), Layer.succeed( ProjectSetupScriptRunner.ProjectSetupScriptRunner, @@ -746,6 +748,22 @@ const layerGitManagerTest = GitVcsDriver.layer.pipe( Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)), ); +const WRITER_INSTANCE_ID = ProviderInstanceId.make("claudeAgent"); +const WRITER = { instanceId: WRITER_INSTANCE_ID, model: "claude-sonnet-4-5" }; +const WRITER_SNAPSHOT: ServerProvider = { + instanceId: WRITER_INSTANCE_ID, + driver: ProviderDriverKind.make("claudeAgent"), + enabled: true, + installed: true, + status: "ready", + auth: { status: "authenticated" }, + version: null, + checkedAt: "1970-01-01T00:00:00Z", + models: [], + slashCommands: [], + skills: [], +}; + it.layer(layerGitManagerTest)("GitManager", (it) => { it.effect( "publishes local Git changes during a held PR lookup without caching its old branch", @@ -3016,6 +3034,85 @@ it.layer(layerGitManagerTest)("GitManager", (it) => { }), ); + it.effect.each([ + { name: "no writer", writer: null, providers: [], expected: "textGeneration" }, + { + name: "an available writer", + writer: WRITER, + providers: [WRITER_SNAPSHOT], + expected: "sourceControlWriter", + }, + { + name: "an unavailable writer", + writer: WRITER, + providers: [{ ...WRITER_SNAPSHOT, availability: "unavailable" }], + expected: "textGeneration", + }, + ] as const)( + "a failed commit message names the setting that picked its model with $name", + ({ writer, providers, expected }) => + Effect.gen(function* () { + const repoDir = yield* makeTempDir("t3code-git-manager-"); + yield* initRepo(repoDir); + NodeFS.writeFileSync(NodePath.join(repoDir, "README.md"), "hello\nwriter\n"); + const { manager } = yield* makeManager({ + serverSettings: { sourceControlWriterModelSelection: writer }, + providers, + textGeneration: { + generateCommitMessage: () => + Effect.fail( + new TextGenerationError({ + operation: "generateCommitMessage", + detail: "model rejected", + }), + ), + }, + }); + + const error = yield* runStackedAction(manager, { cwd: repoDir, action: "commit" }).pipe( + Effect.flip, + ); + + expect(error).toBeInstanceOf(TextGenerationError); + expect(error).toMatchObject({ modelSetting: expected }); + }), + ); + + it.effect("failed pull request content names the writer setting that picked its model", () => + Effect.gen(function* () { + const repoDir = yield* makeTempDir("t3code-git-manager-"); + yield* initRepo(repoDir); + yield* runGit(repoDir, ["checkout", "-b", "feature/writer-failure"]); + const remoteDir = yield* createBareRemote(); + yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]); + NodeFS.writeFileSync(NodePath.join(repoDir, "writer.txt"), "writer\n"); + yield* runGit(repoDir, ["add", "writer.txt"]); + yield* runGit(repoDir, ["commit", "-m", "Writer failure"]); + yield* runGit(repoDir, ["push", "-u", "origin", "feature/writer-failure"]); + const { manager, providerCalls } = yield* makeManager({ + serverSettings: { sourceControlWriterModelSelection: WRITER }, + providers: [WRITER_SNAPSHOT], + textGeneration: { + generatePrContent: () => + Effect.fail( + new TextGenerationError({ + operation: "generatePrContent", + detail: "model rejected", + }), + ), + }, + }); + + const error = yield* runStackedAction(manager, { cwd: repoDir, action: "create_pr" }).pipe( + Effect.flip, + ); + + expect(error).toBeInstanceOf(TextGenerationError); + expect(error).toMatchObject({ modelSetting: "sourceControlWriter" }); + expect(created(providerCalls)).toHaveLength(0); + }), + ); + it.effect("uses an explicit project's provider settings for generated commit text", () => Effect.gen(function* () { const repoDir = yield* makeTempDir("t3code-git-manager-"); diff --git a/apps/server/src/git/GitManager.ts b/apps/server/src/git/GitManager.ts index a944922d530b5..b50ae851eea80 100644 --- a/apps/server/src/git/GitManager.ts +++ b/apps/server/src/git/GitManager.ts @@ -39,6 +39,7 @@ import { type ProjectId, SourceControlProviderError, type SourceControlWritingStyleSettings, + type TextGenerationModelSetting, type ThreadId, type ThreadPullRequestKey, type VcsCreateWorktreeInput, @@ -65,7 +66,11 @@ import { } from "../sourceControl/threadPullRequests.ts"; import { sourceControlDefinitions } from "../sourceControl/sourceControlDefinitions.ts"; -import { GitManagerError, GitPullRequestMaterializationError } from "@t3tools/contracts"; +import { + GitManagerError, + GitPullRequestMaterializationError, + TextGenerationError, +} from "@t3tools/contracts"; import { historicalMessage, renderHistory, @@ -114,9 +119,20 @@ export type GitBranchPullRequest = NonNullable & { interface SourceControlTextGenerationSettings { readonly modelSelection: ModelSelection; + readonly modelSetting: TextGenerationModelSetting; readonly style: SourceControlWritingStyleSettings; } +const withModelSetting = (error: TextGenerationError, modelSetting: TextGenerationModelSetting) => + new TextGenerationError({ + operation: error.operation, + detail: error.detail, + ...(error.instanceId === undefined ? {} : { instanceId: error.instanceId }), + ...(error.model === undefined ? {} : { model: error.model }), + modelSetting, + ...(error.cause === undefined ? {} : { cause: error.cause }), + }); + export class GitManager extends Context.Service< GitManager, { @@ -2147,7 +2163,10 @@ export const make = Effect.gen(function* () { ...(policy ? { policy } : {}), modelSelection: input.settings.modelSelection, }) - .pipe(Effect.map((result) => sanitizeCommitMessage(result))); + .pipe( + Effect.map((result) => sanitizeCommitMessage(result)), + Effect.mapError((error) => withModelSetting(error, input.settings.modelSetting)), + ); return { subject: generated.subject, @@ -2337,18 +2356,20 @@ export const make = Effect.gen(function* () { : undefined; const threadContext = yield* readThreadContext(threadId); - const generated = yield* textGeneration.generatePrContent({ - cwd, - baseBranch, - headBranch: headContext.headBranch, - commitSummary: limitContext(rangeContext.commitSummary, 20_000), - diffSummary: limitContext(rangeContext.diffSummary, 20_000), - diffPatch: limitContext(rangeContext.diffPatch, 60_000), - ...(changeRequestTemplate ? { changeRequestTemplate } : {}), - ...(threadContext ? { threadContext } : {}), - ...(policy ? { policy } : {}), - modelSelection: settings.modelSelection, - }); + const generated = yield* textGeneration + .generatePrContent({ + cwd, + baseBranch, + headBranch: headContext.headBranch, + commitSummary: limitContext(rangeContext.commitSummary, 20_000), + diffSummary: limitContext(rangeContext.diffSummary, 20_000), + diffPatch: limitContext(rangeContext.diffPatch, 60_000), + ...(changeRequestTemplate ? { changeRequestTemplate } : {}), + ...(threadContext ? { threadContext } : {}), + ...(policy ? { policy } : {}), + modelSelection: settings.modelSelection, + }) + .pipe(Effect.mapError((error) => withModelSetting(error, settings.modelSetting))); const bodyFile = path.join( tempDir, @@ -3191,19 +3212,29 @@ export const make = Effect.gen(function* () { const textGenerationSettings = yield* projectSettingsFor(input).pipe( Effect.flatMap(({ settings, projectId }) => settings.sourceControlWriterModelSelection === null - ? Effect.succeed({ + ? Effect.succeed({ modelSelection: settings.textGenerationModelSelection, + modelSetting: "textGeneration", style: settings.sourceControlWritingStyle, }) : providerRegistry.getProviders.pipe( - Effect.map((providers) => ({ - modelSelection: ServerSettings.resolveSourceControlWriterModelSelection( + Effect.map((providers): SourceControlTextGenerationSettings => { + const modelSelection = ServerSettings.resolveSourceControlWriterModelSelection( settings, providers, projectId, - ), - style: settings.sourceControlWritingStyle, - })), + ); + return { + modelSelection, + // The resolver returns the writer's own selection or falls back to the + // general one; a fallback is fixed in the general setting. + modelSetting: + modelSelection === settings.sourceControlWriterModelSelection + ? "sourceControlWriter" + : "textGeneration", + style: settings.sourceControlWritingStyle, + }; + }), ), ), Effect.mapError( diff --git a/apps/server/src/textGeneration/CodexTextGeneration.test.ts b/apps/server/src/textGeneration/CodexTextGeneration.test.ts index 34cc76c95912b..a5a371b6a60f8 100644 --- a/apps/server/src/textGeneration/CodexTextGeneration.test.ts +++ b/apps/server/src/textGeneration/CodexTextGeneration.test.ts @@ -22,7 +22,7 @@ import * as Scope from "effect/Scope"; import { createModelSelection } from "@t3tools/shared/model"; import { expect } from "vite-plus/test"; -import { CodexSettings, ProviderInstanceId } from "@t3tools/contracts"; +import { CodexSettings, ProviderInstanceId, TextGenerationError } from "@t3tools/contracts"; import * as ServerConfig from "../config.ts"; import { makeProcessProbe, processProbeSource } from "../testUtils/processProbe.ts"; @@ -545,16 +545,13 @@ const PREFLIGHT_PRIMARY_STATES = [ "signed out, fallback failed", ] as const; -it.effect.each(PREFLIGHT_PRIMARY_STATES)("text generation preflight: %s", (primaryState) => +const makePreflightTextGeneration = ( + primaryState: (typeof PREFLIGHT_PRIMARY_STATES)[number], + generateThreadTitle: TextGeneration.TextGeneration["Service"]["generateThreadTitle"], +) => Effect.gen(function* () { const primary = ProviderInstanceId.make("codex"); const fallback = ProviderInstanceId.make("claude_work"); - const selection = { - instanceId: primary, - model: "chat-model", - options: [{ id: "effort", value: "high" }], - }; - const calls: ModelSelection[] = []; const instances: ProviderInstance[] = [primary, fallback].map((instanceId) => { const driver = ProviderDriverKind.make(instanceId === primary ? "codex" : "claudeAgent"); const snapshot: ServerProvider = { @@ -604,11 +601,7 @@ it.effect.each(PREFLIGHT_PRIMARY_STATES)("text generation preflight: %s", (prima generateBranchName: () => Effect.die("unused"), generateReviewGuide: () => Effect.die("unused"), generateTranscriptionPostProcessing: () => Effect.die("unused"), - generateThreadTitle: (input) => - Effect.sync(() => { - calls.push(input.modelSelection); - return { title: "Generated title" }; - }), + generateThreadTitle, }), }; }); @@ -631,6 +624,23 @@ it.effect.each(PREFLIGHT_PRIMARY_STATES)("text generation preflight: %s", (prima ), ), ); + return { service, primary, fallback }; + }); + +it.effect.each(PREFLIGHT_PRIMARY_STATES)("text generation preflight: %s", (primaryState) => + Effect.gen(function* () { + const selection = { + instanceId: ProviderInstanceId.make("codex"), + model: "chat-model", + options: [{ id: "effort", value: "high" }], + }; + const calls: ModelSelection[] = []; + const { service, fallback } = yield* makePreflightTextGeneration(primaryState, (input) => + Effect.sync(() => { + calls.push(input.modelSelection); + return { title: "Generated title" }; + }), + ); expect( yield* service.generateThreadTitle({ cwd: "/tmp", @@ -652,3 +662,33 @@ it.effect.each(PREFLIGHT_PRIMARY_STATES)("text generation preflight: %s", (prima ]); }), ); + +it.effect.each([false, true])( + "a text generation failure names the model that ran: exhausted=%s", + (exhausted) => + Effect.gen(function* () { + const { service, primary, fallback } = yield* makePreflightTextGeneration( + exhausted ? "exhausted" : "ready", + () => + Effect.fail( + new TextGenerationError({ operation: "generateThreadTitle", detail: "model rejected" }), + ), + ); + const error = yield* service + .generateThreadTitle({ + cwd: "/tmp", + message: "hello", + linkedContext: "", + modelSelection: { instanceId: primary, model: "chat-model" }, + }) + .pipe(Effect.flip); + const fallbackModel = + DEFAULT_TEXT_GENERATION_MODEL_BY_PROVIDER[ProviderDriverKind.make("claudeAgent")]; + + expect(error.message).toBe( + exhausted + ? `Text generation failed in generateThreadTitle using ${fallbackModel} (${fallback}): model rejected` + : `Text generation failed in generateThreadTitle using chat-model (${primary}): model rejected`, + ); + }), +); diff --git a/apps/server/src/textGeneration/TextGeneration.ts b/apps/server/src/textGeneration/TextGeneration.ts index ac1aa545250d4..ef939cd743c28 100644 --- a/apps/server/src/textGeneration/TextGeneration.ts +++ b/apps/server/src/textGeneration/TextGeneration.ts @@ -129,6 +129,19 @@ export const make = Effect.gen(function* () { } return yield* resolveInstance(registry, operation, selection.instanceId).pipe( Effect.flatMap((service) => invoke(service, selection)), + // Drivers report what went wrong, not which model ran; after a usage-limit fallback only + // this layer knows. + Effect.mapError( + (error) => + new TextGenerationError({ + operation: error.operation, + detail: error.detail, + instanceId: selection.instanceId, + model: selection.model, + ...(error.modelSetting === undefined ? {} : { modelSetting: error.modelSetting }), + ...(error.cause === undefined ? {} : { cause: error.cause }), + }), + ), ); }); return TextGeneration.of({ diff --git a/apps/web/src/components/GitActionsControl.logic.test.ts b/apps/web/src/components/GitActionsControl.logic.test.ts index 43e10293741b0..3706b3ee36dc3 100644 --- a/apps/web/src/components/GitActionsControl.logic.test.ts +++ b/apps/web/src/components/GitActionsControl.logic.test.ts @@ -1,4 +1,10 @@ -import { SourceControlProviderKind, type VcsStatusResult } from "@t3tools/contracts"; +import { + EnvironmentId, + GitManagerError, + SourceControlProviderKind, + TextGenerationError, + type VcsStatusResult, +} from "@t3tools/contracts"; import { sourceControlClients } from "@t3tools/client-runtime/source-control-clients"; import { resolveAutoFeatureBranchName } from "@t3tools/shared/git"; import { assert, describe, it } from "vite-plus/test"; @@ -9,6 +15,7 @@ import { resolveDefaultBranchActionDialogCopy, resolveLiveThreadBranchUpdate, resolveQuickAction, + resolveTextGenerationSettingsLink, } from "./GitActionsControl.logic"; function status(overrides: Partial = {}): VcsStatusResult { @@ -298,3 +305,42 @@ describe("resolveChangesTotals", () => { ); }); }); + +describe("resolveTextGenerationSettingsLink", () => { + const scope = { environmentId: EnvironmentId.make("env-1"), projectKey: "project-1" }; + const failure = (modelSetting?: "textGeneration" | "sourceControlWriter") => + new TextGenerationError({ + operation: "generateCommitMessage", + detail: "model rejected", + ...(modelSetting ? { modelSetting } : {}), + }); + + it("opens the setting that picked the model, scoped to the acting project", () => { + assert.deepEqual(resolveTextGenerationSettingsLink(failure("textGeneration"), scope), { + to: "/settings/threads", + hash: "text-generation-model", + search: { machine: scope.environmentId, project: "project-1", checkout: undefined }, + }); + assert.deepEqual( + resolveTextGenerationSettingsLink(failure("sourceControlWriter"), { + ...scope, + projectKey: null, + }), + { + to: "/settings/source-control", + hash: "source-control-writer-model", + search: { machine: scope.environmentId, project: undefined, checkout: undefined }, + }, + ); + }); + + it("offers nothing when the server did not say which setting ran", () => { + assert.isNull(resolveTextGenerationSettingsLink(failure(), scope)); + assert.isNull( + resolveTextGenerationSettingsLink( + new GitManagerError({ operation: "runStackedAction", cwd: "/repo", detail: "failed" }), + scope, + ), + ); + }); +}); diff --git a/apps/web/src/components/GitActionsControl.logic.ts b/apps/web/src/components/GitActionsControl.logic.ts index 5effb44c79a87..7f58c5472d273 100644 --- a/apps/web/src/components/GitActionsControl.logic.ts +++ b/apps/web/src/components/GitActionsControl.logic.ts @@ -1,10 +1,15 @@ -import type { - GitRunStackedActionResult, - GitStackedAction, - VcsStatusResult, +import { + TextGenerationError, + type EnvironmentId, + type GitRunStackedActionResult, + type GitStackedAction, + type TextGenerationModelSetting, + type VcsStatusResult, } from "@t3tools/contracts"; +import * as Schema from "effect/Schema"; import { isTemporaryWorktreeBranch } from "@t3tools/shared/git"; import type { ChangeRequestTerminology } from "@t3tools/client-runtime/source-control-clients"; +import type { SettingsSearchItemId } from "./settings/settingsSearch"; import { changeRequestTerminologyFor, type DefaultBranchActionDialogCopy, @@ -453,3 +458,28 @@ export function resolveChangesTotals( baseRef: selected.baseRef, }; } + +const isTextGenerationError = Schema.is(TextGenerationError); + +const TEXT_GENERATION_SETTINGS = { + textGeneration: { to: "/settings/threads", id: "text-generation-model" }, + sourceControlWriter: { to: "/settings/source-control", id: "source-control-writer-model" }, +} as const satisfies Record; + +/** The setting that picked the model of a failed generation, opened where the action ran. */ +export function resolveTextGenerationSettingsLink( + error: unknown, + scope: { readonly environmentId: EnvironmentId; readonly projectKey: string | null }, +) { + if (!isTextGenerationError(error) || error.modelSetting === undefined) return null; + const setting = TEXT_GENERATION_SETTINGS[error.modelSetting]; + return { + to: setting.to, + hash: setting.id, + search: { + machine: scope.environmentId, + project: scope.projectKey ?? undefined, + checkout: undefined, + }, + }; +} diff --git a/apps/web/src/components/GitActionsControl.tsx b/apps/web/src/components/GitActionsControl.tsx index c927aa302c6e1..35818440ae998 100644 --- a/apps/web/src/components/GitActionsControl.tsx +++ b/apps/web/src/components/GitActionsControl.tsx @@ -11,8 +11,10 @@ import { squashAtomCommandFailure, } from "@t3tools/client-runtime/state/runtime"; import type { + EnvironmentId, GitRunStackedActionResult, GitStackedAction, + ProjectId, SourceControlCloneProtocol, SourceControlProviderDiscoveryItem, SourceControlPublishRepositoryResult, @@ -60,6 +62,7 @@ import { resolveLiveThreadBranchUpdate, resolveThreadBranchMetadataPatch, resolveQuickAction, + resolveTextGenerationSettingsLink, resolveThreadBranchUpdate, } from "./GitActionsControl.logic"; import { WizardPopup, WizardHeader, WizardSteps, WizardPanel, WizardFooter } from "./ui/wizard"; @@ -90,7 +93,14 @@ import { useVcsInitAction, useVcsPullAction, } from "../state/sourceControlActions"; -import { useQuietThreadProjection, useQuietThreadShell } from "~/state/entities"; +import { readProjects, useQuietThreadProjection, useQuietThreadShell } from "~/state/entities"; +import { getClientSettings } from "~/hooks/useSettings"; +import { + deriveLogicalProjectKeyFromSettings, + derivePhysicalProjectKey, + selectProjectGroupingSettings, +} from "@t3tools/client-runtime/state/project-grouping"; +import { buildPhysicalToLogicalProjectKeyMap } from "~/sidebarProjectGrouping"; import { readEnvironmentScope, useEnvironmentScope } from "~/state/session"; import { useEnvironmentQuery } from "~/state/query"; import { serverEnvironment } from "~/state/server"; @@ -151,6 +161,24 @@ interface InlineGitActionSuccess { const inlineSuccessExpiresAt = () => Date.now() + GIT_ACTION_SUCCESS_VISIBLE_MS; +/** The project key Settings scopes to, read when needed so the control does not track projects. */ +function projectSettingsKey(environmentId: EnvironmentId, projectId: ProjectId | null) { + const projects = readProjects(); + const project = projects.find( + (candidate) => candidate.environmentId === environmentId && candidate.id === projectId, + ); + if (!project) return null; + const grouping = selectProjectGroupingSettings(getClientSettings()); + return ( + buildPhysicalToLogicalProjectKeyMap({ + projects, + settings: grouping, + primaryEnvironmentId: null, + }).get(derivePhysicalProjectKey(project)) ?? + deriveLogicalProjectKeyFromSettings(project, grouping) + ); +} + type RefreshVcsStatus = (target: { readonly environmentId: ScopedThreadRef["environmentId"]; readonly input: { readonly cwd: string }; @@ -934,6 +962,7 @@ export default function GitActionsControl({ onOpenChanges, }: GitActionsControlProps) { const panelAnchorRef = useRef(null); + const navigate = useNavigate(); const updateThreadMetadata = useAtomCommand( threadEnvironment.updateMetadata, "thread branch metadata update", @@ -1222,12 +1251,30 @@ export default function GitActionsControl({ const error = squashAtomCommandFailure(result); const errorToastTiming = resolveGitActionResultToastTiming("error"); - toastManager.add( + const settingsLink = resolveTextGenerationSettingsLink(error, { + environmentId: activeEnvironmentId, + projectKey: projectSettingsKey( + activeEnvironmentId, + activeServerThread?.projectId ?? activeDraftThread?.projectId ?? null, + ), + }); + const toastId = toastManager.add( stackedThreadToast({ type: "error", title: "Action failed", description: error instanceof Error ? error.message : "An error occurred.", timeout: errorToastTiming.timeout, + ...(settingsLink + ? { + actionProps: { + children: "Settings", + onClick: () => { + toastManager.close(toastId); + void navigate(settingsLink); + }, + }, + } + : {}), ...(scopedToastData !== undefined ? { data: scopedToastData } : {}), }), ); diff --git a/packages/contracts/src/git.test.ts b/packages/contracts/src/git.test.ts index 60d99defe6e2f..c0ece04add866 100644 --- a/packages/contracts/src/git.test.ts +++ b/packages/contracts/src/git.test.ts @@ -5,9 +5,11 @@ import { GitCommandError, GitPreparePullRequestThreadResult, GitRunStackedActionInput, + TextGenerationError, } from "./git.ts"; const decodeGitCommandError = Schema.decodeUnknownSync(Schema.toCodecJson(GitCommandError)); +const decodeTextGenerationError = Schema.decodeUnknownSync(Schema.toCodecJson(TextGenerationError)); const decodePreparePullRequestThreadResult = Schema.decodeUnknownSync( GitPreparePullRequestThreadResult, ); @@ -31,6 +33,34 @@ describe("GitCommandError", () => { }); }); +describe("TextGenerationError", () => { + it("names the model that ran and keeps an unknown setting out", () => { + const error = decodeTextGenerationError({ + _tag: "TextGenerationError", + operation: "generateCommitMessage", + detail: "model not found", + instanceId: "codex_work", + model: "gpt-6-luna", + modelSetting: "added_by_a_newer_server", + }); + + expect(error.modelSetting).toBeUndefined(); + expect(error.message).toBe( + "Text generation failed in generateCommitMessage using gpt-6-luna (codex_work): model not found", + ); + }); + + it("reads an older server's error without a model", () => { + const error = decodeTextGenerationError({ + _tag: "TextGenerationError", + operation: "generatePrContent", + detail: "model not found", + }); + + expect(error.message).toBe("Text generation failed in generatePrContent: model not found"); + }); +}); + describe("GitPreparePullRequestThreadResult", () => { it("defaults legacy responses to the pull request head", () => { const parsed = decodePreparePullRequestThreadResult({ diff --git a/packages/contracts/src/git.ts b/packages/contracts/src/git.ts index 0dc958f59c490..b66153fd5ccd5 100644 --- a/packages/contracts/src/git.ts +++ b/packages/contracts/src/git.ts @@ -8,6 +8,7 @@ import { ThreadId, TrimmedNonEmptyString, } from "./baseSchemas.ts"; +import { ProviderInstanceId } from "./providerInstance.ts"; import { SourceControlProviderError, SourceControlProviderInfo } from "./sourceControl.ts"; import { VcsDriverKind } from "./vcs.ts"; @@ -385,16 +386,30 @@ export class GitCommandError extends Schema.TaggedError()("GitC } } +/** The setting that picked the model, so a failure can point at where to change it. */ +export const TextGenerationModelSetting = Schema.Literals([ + "textGeneration", + "sourceControlWriter", +]); +export type TextGenerationModelSetting = typeof TextGenerationModelSetting.Type; + export class TextGenerationError extends Schema.TaggedError()( "TextGenerationError", { operation: Schema.String, detail: Schema.String, + instanceId: Schema.optional(ProviderInstanceId), + model: Schema.optional(Schema.String), + modelSetting: ForwardCompatibleOptional(TextGenerationModelSetting), cause: Schema.optional(Schema.Defect()), }, ) { override get message(): string { - return `Text generation failed in ${this.operation}: ${this.detail}`; + const attempted = + this.model === undefined + ? "" + : ` using ${this.model}${this.instanceId === undefined ? "" : ` (${this.instanceId})`}`; + return `Text generation failed in ${this.operation}${attempted}: ${this.detail}`; } }