import type { ModelPreferences } from "@t3tools/contracts/settings"; import { DEFAULT_MODEL_BY_PROVIDER, DEFAULT_TEXT_GENERATION_MODEL, DEFAULT_TEXT_GENERATION_MODEL_BY_PROVIDER, defaultInstanceIdForDriver, globalIdleCompaction, type IdleCompactionMode, isProviderAvailable, isUnconfiguredDefaultInstanceEnabled, resolveProjectProviderInstanceEnabled, resolveProviderInstanceEnabled, resolveTextGenerationSelectionEnabled, textGeneratorForSelection, isProviderTextGenerationCapable, type ModelSelection, type ProjectId, type ProjectScopedServerSettingKey, ProjectSettingsOverrides, ProviderDriverKind, ProviderInstanceId, type ServerProvider, ServerSettings, type ServerSettingsPatch, withIdleCompaction, } from "@t3tools/contracts"; import * as Option from "effect/Option"; import * as Predicate from "effect/Predicate"; import * as Schema from "effect/Schema"; import { deepMerge } from "./Struct.ts"; import { fromLenientJson } from "./schemaJson.ts"; import { createModelSelection, readCustomModelEntries } from "./model.ts"; import { getBackgroundActivityBaseProfile, normalizeBackgroundActivitySettings, normalizeServerBackgroundActivitySettings, resolveBackgroundActivitySettings, } from "./backgroundActivitySettings.ts"; // Only observability: a value the server migrates on load elsewhere in the file must not drop it. const ServerObservabilitySettingsJson = fromLenientJson( Schema.Struct({ observability: ServerSettings.fields.observability }), ); const decodeServerObservabilitySettingsJson = Schema.decodeUnknownOption( ServerObservabilitySettingsJson, ); export function isModelSelectionProviderEnabled( settings: ServerSettings, selection: ModelSelection, ): boolean { const generator = textGeneratorForSelection(settings, selection.instanceId); if (generator !== undefined) return generator.enabled; const instanceConfig = Object.hasOwn(settings.providerInstances, selection.instanceId) ? settings.providerInstances[selection.instanceId] : undefined; if (instanceConfig !== undefined) { return resolveProviderInstanceEnabled(instanceConfig); } return isUnconfiguredDefaultInstanceEnabled(selection.instanceId); } const TEXT_GENERATION_FALLBACK_DRIVERS = [ "codex", "claudeAgent", "cursor", "grok", "muse", "pi", "opencode", "antigravity", ].map((driver) => ProviderDriverKind.make(driver)); /** Configured instances come after every default instance, so they only win when no default qualifies. */ export function fallbackTextGenerationModelSelection( providerInstances: ServerSettings["providerInstances"], isEnabled: (instanceId: ProviderInstanceId, driver: ProviderDriverKind, model: string) => boolean, options?: { readonly defaultModelSelection?: ModelSelection | null }, ): ModelSelection | null { const threadDefault = options?.defaultModelSelection; // The thread default's custom model wins on its instance; the driver default still serves when that model is unusable. const selectionsFor = (instanceId: ProviderInstanceId, driver: ProviderDriverKind) => { const config = providerInstances[instanceId]?.config as { customModels?: unknown } | undefined; const driverDefault = { instanceId, model: defaultTextGenerationModel(driver) }; return threadDefault?.instanceId === instanceId && readCustomModelEntries(config?.customModels).some( (entry) => entry.slug === threadDefault.model, ) ? [threadDefault, driverDefault] : [driverDefault]; }; const candidates = [ ...TEXT_GENERATION_FALLBACK_DRIVERS.map( (driver) => [defaultInstanceIdForDriver(driver), driver] as const, ), ...Object.entries(providerInstances).flatMap(([instanceId, instance]) => TEXT_GENERATION_FALLBACK_DRIVERS.includes(instance.driver) ? [[ProviderInstanceId.make(instanceId), instance.driver] as const] : [], ), ]; for (const [instanceId, driver] of candidates) { for (const selection of selectionsFor(instanceId, driver)) { if (isEnabled(instanceId, driver, selection.model)) return selection; } } return null; } function defaultTextGenerationModel(driver: ProviderDriverKind): string { return ( DEFAULT_TEXT_GENERATION_MODEL_BY_PROVIDER[driver] ?? DEFAULT_MODEL_BY_PROVIDER[driver] ?? DEFAULT_TEXT_GENERATION_MODEL ); } /** A text generator, or a provider whose snapshot can generate text; no snapshots trusts settings. */ function isTextGenerationTargetUsable( settings: ServerSettings, providers: ReadonlyArray | undefined, instanceId: ProviderInstanceId, ): boolean { if (providers === undefined || textGeneratorForSelection(settings, instanceId) !== undefined) { return true; } const provider = providers.find((candidate) => candidate.instanceId === instanceId); return ( provider?.enabled === true && isProviderAvailable(provider) && isProviderTextGenerationCapable(provider) ); } export function resolveSourceControlWriterModelSelection( settings: ServerSettings, providers: ReadonlyArray | undefined, projectId: ProjectId | null, ): ModelSelection { const selection = settings.sourceControlWriterModelSelection; return selection && resolveTextGenerationSelectionEnabled(settings, projectId, selection.instanceId) && isTextGenerationTargetUsable(settings, providers, selection.instanceId) ? selection : settings.textGenerationModelSelection; } export function resolveReviewGuideModelSelection( settings: ServerSettings, providers: ReadonlyArray | undefined, projectId: ProjectId | null, ): ModelSelection { const selection = settings.reviewGuideModelSelection; // Text generators cannot investigate a checkout, so they never write review guides. return selection && textGeneratorForSelection(settings, selection.instanceId) === undefined && resolveProjectProviderInstanceEnabled(settings, projectId, selection.instanceId) && isTextGenerationTargetUsable(settings, providers, selection.instanceId) ? selection : resolveSourceControlWriterModelSelection(settings, providers, projectId); } /** Transcript cleanup follows the text generation model unless its own usable model is set. */ export function resolveSpeechPostProcessingModelSelection( settings: ServerSettings, providers?: ReadonlyArray, ): ModelSelection { const selection = settings.speechPostProcessingModelSelection; return selection && isModelSelectionProviderEnabled(settings, selection) && isTextGenerationTargetUsable(settings, providers, selection.instanceId) ? selection : settings.textGenerationModelSelection; } export interface PersistedServerObservabilitySettings { readonly otlpTracesUrl: string | undefined; readonly otlpMetricsUrl: string | undefined; readonly otlpLogsUrl: string | undefined; } function normalizePersistedServerSettingString( value: string | null | undefined, ): string | undefined { const trimmed = value?.trim(); return trimmed && trimmed.length > 0 ? trimmed : undefined; } function extractPersistedServerObservabilitySettings(input: { readonly observability?: { readonly otlpTracesUrl?: string; readonly otlpMetricsUrl?: string; readonly otlpLogsUrl?: string; }; }): PersistedServerObservabilitySettings { return { otlpTracesUrl: normalizePersistedServerSettingString(input.observability?.otlpTracesUrl), otlpMetricsUrl: normalizePersistedServerSettingString(input.observability?.otlpMetricsUrl), otlpLogsUrl: normalizePersistedServerSettingString(input.observability?.otlpLogsUrl), }; } export function parsePersistedServerObservabilitySettings( raw: string, ): PersistedServerObservabilitySettings { const decoded = decodeServerObservabilitySettingsJson(raw); if (Option.isSome(decoded)) { return extractPersistedServerObservabilitySettings(decoded.value); } return { otlpTracesUrl: undefined, otlpMetricsUrl: undefined, otlpLogsUrl: undefined }; } function shouldReplaceTextGenerationModelSelection( patch: ServerSettingsPatch["textGenerationModelSelection"] | undefined, ): boolean { return Boolean(patch && (patch.instanceId !== undefined || patch.model !== undefined)); } function mergeModelSelectionOptionsById(input: { current: ReadonlyArray<{ readonly id: string; readonly value: string | boolean }> | undefined; patch: ReadonlyArray<{ readonly id: string; readonly value: string | boolean }> | undefined; }): Array<{ id: string; value: string | boolean }> | undefined { if (input.patch === undefined) { return input.current ? [...input.current] : undefined; } if (input.patch.length === 0) { return undefined; } const merged = new Map((input.current ?? []).map((selection) => [selection.id, selection.value])); for (const selection of input.patch) { merged.set(selection.id, selection.value); } return [...merged.entries()].map(([id, value]) => ({ id, value })); } function mergeSettingsEntries( current: Readonly>, patch: Readonly>, ): Record { const next = new Map(Object.entries(current)); for (const [id, config] of Object.entries(patch)) { if (config === null) { next.delete(id); } else { next.set(id, config); } } return Object.fromEntries(next); } // Secret persistence keys tokens by trimmed, lowercased host, so merge on the same key. const byHost = (tokens: unknown) => Object.fromEntries( Object.entries(Predicate.isObject(tokens) ? tokens : {}).map(([host, token]) => [ host.trim().toLowerCase(), token, ]), ); const knownProjectOverrideKeys = new Set(Object.keys(ProjectSettingsOverrides.fields)); function pickOverrideKeys(entry: ProjectSettingsOverrides | undefined, known: boolean) { return Object.fromEntries( Object.entries(entry ?? {}).filter( ([key]) => knownProjectOverrideKeys.has(key) === known, ), ); } // Older clients omit providerInstances during whole-entry replacement; preserve it to avoid wiping overrides. function mergeProjectSettingsOverridesPatch( current: Readonly>, patch: Readonly>, ): Record { const next = new Map(Object.entries(current)); for (const [projectId, entry] of Object.entries(patch)) { if (entry === null) { next.delete(projectId); continue; } const storedProviderInstances = current[projectId]?.providerInstances; next.set(projectId, { // Preserve downgraded storage, but reject new unknown writes so clients can detect unsupported settings. ...pickOverrideKeys(current[projectId], false), ...pickOverrideKeys(entry, true), ...(Object.hasOwn(entry, "providerInstances") || storedProviderInstances === undefined ? {} : { providerInstances: storedProviderInstances }), }); } return Object.fromEntries(next); } export function deriveLegacyProjectOverrides( settings: Pick, ): Pick< ServerSettings, "projectAgentBrowserAccessOverrides" | "projectAutoPullOverrides" | "projectScriptOverrides" > { const projectAgentBrowserAccessOverrides: Record = {}; const projectAutoPullOverrides: Record = {}; const projectScriptOverrides: Record = {}; for (const [projectId, entry] of Object.entries(settings.projectSettingsOverrides)) { if (entry.enableAgentBrowserAccess !== undefined) { projectAgentBrowserAccessOverrides[projectId] = entry.enableAgentBrowserAccess; } if (entry.defaultAutoPull !== undefined) { projectAutoPullOverrides[projectId] = entry.defaultAutoPull; } if (entry.defaultProjectScripts !== undefined) { projectScriptOverrides[projectId] = entry.defaultProjectScripts; } } return { projectAgentBrowserAccessOverrides, projectAutoPullOverrides, projectScriptOverrides }; } function translateLegacyProjectOverridePatch( current: Pick, patch: ServerSettingsPatch, ): ServerSettingsPatch { const { projectAgentBrowserAccessOverrides, projectAutoPullOverrides, projectScriptOverrides, ...rest } = patch; if ( projectAgentBrowserAccessOverrides === undefined && projectAutoPullOverrides === undefined && projectScriptOverrides === undefined ) { return patch; } const currentEntries: Readonly> = current.projectSettingsOverrides; const entries = new Map( Object.entries(rest.projectSettingsOverrides ?? {}), ); // Canonical entries outrank legacy maps, including deliberately omitted keys. const canonicalProjectIds = new Set(Object.keys(rest.projectSettingsOverrides ?? {})); const applyKey = ( map: Readonly> | undefined, key: K, ) => { if (map === undefined) return; for (const [projectId, value] of Object.entries(map)) { if (canonicalProjectIds.has(projectId)) continue; const entry: ProjectSettingsOverrides = { ...(entries.get(projectId) ?? currentEntries[projectId]), }; if (value === null || value === undefined) { delete entry[key]; } else { entry[key] = value; } entries.set(projectId, Object.keys(entry).length === 0 ? null : entry); } }; applyKey(projectAgentBrowserAccessOverrides, "enableAgentBrowserAccess"); applyKey(projectAutoPullOverrides, "defaultAutoPull"); applyKey(projectScriptOverrides, "defaultProjectScripts"); return { ...rest, projectSettingsOverrides: Object.fromEntries(entries), } as ServerSettingsPatch; } /** * A client from before `idleCompaction` patches the old boolean switch. Turning * it off keeps "Never" rather than reverting to the default. */ function patchedIdleCompaction( current: ServerSettings, patch: ServerSettingsPatch, ): IdleCompactionMode { if (patch.idleCompaction !== undefined) return patch.idleCompaction; const legacy = patch.compactIdleThreads; if (legacy === undefined) return globalIdleCompaction(current); if (typeof legacy === "string") return legacy; if (legacy) return "beforeCacheExpires"; return globalIdleCompaction(current) === "off" ? "off" : "onReturn"; } function applyNullableEntries( current: Readonly>, patch: Readonly> | undefined, ): Record { const next = { ...current } as Record; if (patch === undefined) return next; for (const key of Object.keys(patch) as Key[]) { const value = patch[key]; if (value === null) delete next[key]; else if (value !== undefined) next[key] = value; } return next; } export function applyServerSettingsPatch( current: ServerSettings, rawPatch: ServerSettingsPatch, ): ServerSettings { const patch = translateLegacyProjectOverridePatch(current, rawPatch); const selectionPatch = patch.textGenerationModelSelection; const { migrateModelPreferences, setModelFavorites, setModelsHidden, setProviderModelOrder, providerModelPreferences, automaticGitFetchInterval, providerHealthRefreshInterval, backgroundActivityProfile, backgroundActivity, worktreeCleanup: worktreeCleanupPatch, // Merged per entry below; its `null` removals must not reach deepMerge. usageLimitSources: usageLimitSourcesPatch, textGenerators: textGeneratorsPatch, secretProviders: secretProvidersPatch, sourceControlHosts: sourceControlHostsPatch, usagePriceOverrides: usagePriceOverridesPatch, usageModelAliases: usageModelAliasesPatch, // Entry replacement: deepMerge would keep keys the client meant to clear. projectSettingsOverrides: projectSettingsOverridesPatch, trogonStack: trogonStackPatch, projectAgentBrowserAccessOverrides: _legacyBrowserAccess, projectAutoPullOverrides: _legacyAutoPull, projectScriptOverrides: _legacyScripts, ...patchForMerge } = patch; const currentBackgroundActivity = normalizeServerBackgroundActivitySettings(current); const backgroundActivityPatch = backgroundActivityProfile !== undefined ? { schemaVersion: 1 as const, profile: automaticGitFetchInterval !== undefined || providerHealthRefreshInterval !== undefined ? ("custom" as const) : backgroundActivityProfile, ...(automaticGitFetchInterval !== undefined || providerHealthRefreshInterval !== undefined ? { baseProfile: backgroundActivityProfile } : {}), overrides: { ...(automaticGitFetchInterval !== undefined ? { automaticGitFetchInterval } : {}), ...(providerHealthRefreshInterval !== undefined ? { providerHealthRefreshInterval } : {}), }, } : automaticGitFetchInterval !== undefined || providerHealthRefreshInterval !== undefined ? { schemaVersion: 1 as const, profile: "custom" as const, baseProfile: getBackgroundActivityBaseProfile(currentBackgroundActivity), overrides: { ...(currentBackgroundActivity.profile === "custom" ? currentBackgroundActivity.overrides : {}), ...(automaticGitFetchInterval !== undefined ? { automaticGitFetchInterval } : {}), ...(providerHealthRefreshInterval !== undefined ? { providerHealthRefreshInterval } : {}), }, } : undefined; const initialFavorites = patch.favorites ?? current.favorites ?? migrateModelPreferences?.favorites ?? null; const favorites = setModelFavorites?.reduce( (current, change) => { const exists = current.some( (favorite) => favorite.provider === change.provider && favorite.model === change.model, ); if (change.favorite) { if (!exists) current.push({ provider: change.provider, model: change.model }); return current; } return current.filter( (favorite) => favorite.provider !== change.provider || favorite.model !== change.model, ); }, [...(initialFavorites ?? [])], ) ?? initialFavorites; const initialModelPreferences = providerModelPreferences ?? current.providerModelPreferences ?? migrateModelPreferences?.providerModelPreferences ?? null; let nextModelPreferences = initialModelPreferences; if (setModelsHidden?.length) { const updated = { ...initialModelPreferences }; for (const change of setModelsHidden) { const preferences = (Object.hasOwn(updated, change.provider) ? updated[change.provider] : undefined) ?? { hiddenModels: [], modelOrder: [], }; const hiddenModels = preferences.hiddenModels.filter((model) => model !== change.model); if (change.hidden) hiddenModels.push(change.model); updated[change.provider] = { ...preferences, hiddenModels }; } nextModelPreferences = updated; } if (setProviderModelOrder) { const preferences = nextModelPreferences?.[setProviderModelOrder.provider] ?? { hiddenModels: [], modelOrder: [], }; nextModelPreferences = { ...nextModelPreferences, [setProviderModelOrder.provider]: { ...preferences, modelOrder: [...setProviderModelOrder.modelOrder], }, }; } const next = deepMerge(current, patchForMerge); const nextWithReplacementsBase = { ...next, favorites, providerModelPreferences: nextModelPreferences, ...(trogonStackPatch === undefined ? {} : { trogonStack: { providerProfiles: applyNullableEntries( current.trogonStack.providerProfiles, trogonStackPatch.providerProfiles, ), projectProfiles: applyNullableEntries( current.trogonStack.projectProfiles, trogonStackPatch.projectProfiles, ), projectsRequiringProfile: applyNullableEntries( current.trogonStack.projectsRequiringProfile, trogonStackPatch.projectsRequiringProfile, ), }, }), ...(worktreeCleanupPatch === undefined ? {} : { worktreeCleanup: worktreeCleanupPatch?.mode === "custom" ? { mode: "custom" as const, rules: { worktreeKeepWhen: next.storageCleanup.worktreeKeepWhen, worktreeAfterDays: next.storageCleanup.worktreeAfterDays, worktreeSettledAfterDays: next.storageCleanup.worktreeSettledAfterDays, worktreeOnMerge: next.storageCleanup.worktreeOnMerge, worktreeOnDelete: next.storageCleanup.worktreeOnDelete, worktreeUnchanged: next.storageCleanup.worktreeUnchanged, ...(current.worktreeCleanup?.mode === "custom" ? current.worktreeCleanup.rules : {}), ...worktreeCleanupPatch.rules, }, } : worktreeCleanupPatch, }), ...(backgroundActivity !== undefined ? { backgroundActivity: { ...deepMerge(currentBackgroundActivity, backgroundActivity), ...(backgroundActivity.overrides !== undefined ? { overrides: backgroundActivity.overrides } : {}), }, } : { backgroundActivity: currentBackgroundActivity }), ...(backgroundActivity === undefined && backgroundActivityPatch !== undefined ? { backgroundActivity: backgroundActivityPatch } : {}), ...(patch.providerInstances !== undefined ? { providerInstances: patch.providerInstances } : {}), ...(patch.worktreesDirectory !== undefined && patch.worktreesDirectory !== current.worktreesDirectory ? { previousWorktreesDirectories: [ ...current.previousWorktreesDirectories.filter( (directory) => directory !== patch.worktreesDirectory, ), ...(current.worktreesDirectory !== "" && !current.previousWorktreesDirectories.includes(current.worktreesDirectory) ? [current.worktreesDirectory] : []), ], } : {}), // Per host, a patched field replaces the saved one: deepMerge would keep a cleared account pin. ...(sourceControlHostsPatch !== undefined ? { sourceControlHosts: { ...current.sourceControlHosts, ...Object.fromEntries( Object.entries(sourceControlHostsPatch).map(([kind, fields]) => { const saved = current.sourceControlHosts[kind]; return [ kind, { ...saved, ...fields, // Older clients send the whole token map; a host missing from it keeps its saved // token. An empty map still clears them all. ...(Predicate.isObject(fields.tokens) && Object.keys(fields.tokens).length > 0 ? { tokens: { ...byHost(saved?.tokens), ...byHost(fields.tokens), }, } : {}), }, ]; }), ), }, } : {}), ...(projectSettingsOverridesPatch !== undefined ? { projectSettingsOverrides: Object.fromEntries( Object.entries( mergeProjectSettingsOverridesPatch( current.projectSettingsOverrides, projectSettingsOverridesPatch, ), ).filter(([, entry]) => Object.keys(entry).length > 0), ), } : {}), ...(patch.defaultModelSelection !== undefined ? { defaultModelSelection: patch.defaultModelSelection } : {}), ...(patch.fallbackModelSelection !== undefined ? { fallbackModelSelection: patch.fallbackModelSelection } : {}), ...(patch.speechPostProcessingModelSelection !== undefined ? { speechPostProcessingModelSelection: patch.speechPostProcessingModelSelection } : {}), ...(patch.defaultProjectScripts !== undefined ? { defaultProjectScripts: patch.defaultProjectScripts } : {}), ...(usageLimitSourcesPatch !== undefined ? { usageLimitSources: mergeSettingsEntries( current.usageLimitSources, usageLimitSourcesPatch, ), } : {}), ...(textGeneratorsPatch !== undefined ? { textGenerators: mergeSettingsEntries(current.textGenerators, textGeneratorsPatch) } : {}), ...(secretProvidersPatch !== undefined ? { secretProviders: mergeSettingsEntries(current.secretProviders, secretProvidersPatch) } : {}), ...(usagePriceOverridesPatch !== undefined ? { usagePriceOverrides: mergeSettingsEntries( current.usagePriceOverrides, usagePriceOverridesPatch, ), } : {}), ...(usageModelAliasesPatch !== undefined ? { usageModelAliases: mergeSettingsEntries( current.usageModelAliases, usageModelAliasesPatch, ), } : {}), ...(patch.sourceControlWriterModelSelection !== undefined ? { sourceControlWriterModelSelection: patch.sourceControlWriterModelSelection } : {}), ...(patch.reviewGuideModelSelection !== undefined ? { reviewGuideModelSelection: patch.reviewGuideModelSelection } : {}), ...(automaticGitFetchInterval !== undefined ? { automaticGitFetchInterval } : {}), ...(providerHealthRefreshInterval !== undefined ? { providerHealthRefreshInterval } : {}), }; const normalizedBackgroundActivity = normalizeBackgroundActivitySettings( nextWithReplacementsBase.backgroundActivity, ); const resolvedBackgroundActivity = resolveBackgroundActivitySettings( normalizedBackgroundActivity, ); const nextWithReplacements = { ...withIdleCompaction(nextWithReplacementsBase, patchedIdleCompaction(current, patch)), ...deriveLegacyProjectOverrides(nextWithReplacementsBase), backgroundActivity: normalizedBackgroundActivity, automaticGitFetchInterval: resolvedBackgroundActivity.automaticGitFetchInterval, providerHealthRefreshInterval: resolvedBackgroundActivity.providerHealthRefreshInterval, backgroundActivityProfile: resolvedBackgroundActivity.profile, }; if (!selectionPatch) { return nextWithReplacements; } const instanceId = selectionPatch.instanceId ?? current.textGenerationModelSelection.instanceId; const model = selectionPatch.model ?? current.textGenerationModelSelection.model; const options = shouldReplaceTextGenerationModelSelection(selectionPatch) ? selectionPatch.options : mergeModelSelectionOptionsById({ current: current.textGenerationModelSelection.options, patch: selectionPatch.options, }); return { ...nextWithReplacements, textGenerationModelSelection: createModelSelection(instanceId, model, options), }; } export function resolveModelPreferences( settings: Pick, legacy: Partial = {}, ): ModelPreferences { return { favorites: settings.favorites ?? legacy.favorites ?? [], providerModelPreferences: settings.providerModelPreferences ?? legacy.providerModelPreferences ?? {}, }; } /** Empty legacy values do not claim ownership before another client can migrate its saved list. */ export function modelPreferencesMigrationPatch( settings: Pick, legacy: Partial, ): ServerSettingsPatch | null { const favorites = settings.favorites === null && (legacy.favorites?.length ?? 0) > 0 ? legacy.favorites : undefined; const providerModelPreferences = settings.providerModelPreferences === null && Object.keys(legacy.providerModelPreferences ?? {}).length > 0 ? legacy.providerModelPreferences : undefined; return favorites === undefined && providerModelPreferences === undefined ? null : { migrateModelPreferences: { ...(favorites === undefined ? {} : { favorites }), ...(providerModelPreferences === undefined ? {} : { providerModelPreferences }), }, }; }