Open History to see the last commit
1import type { ModelPreferences } from "@t3tools/contracts/settings";
2import {
3 DEFAULT_MODEL_BY_PROVIDER,
4 DEFAULT_TEXT_GENERATION_MODEL,
5 DEFAULT_TEXT_GENERATION_MODEL_BY_PROVIDER,
6 defaultInstanceIdForDriver,
7 globalIdleCompaction,
8 type IdleCompactionMode,
9 isProviderAvailable,
10 isUnconfiguredDefaultInstanceEnabled,
11 resolveProjectProviderInstanceEnabled,
12 resolveProviderInstanceEnabled,
13 resolveTextGenerationSelectionEnabled,
14 textGeneratorForSelection,
15 isProviderTextGenerationCapable,
16 type ModelSelection,
17 type ProjectId,
18 type ProjectScopedServerSettingKey,
19 ProjectSettingsOverrides,
20 ProviderDriverKind,
21 ProviderInstanceId,
22 type ServerProvider,
23 ServerSettings,
24 type ServerSettingsPatch,
25 withIdleCompaction,
26} from "@t3tools/contracts";
27import * as Option from "effect/Option";
28import * as Predicate from "effect/Predicate";
29import * as Schema from "effect/Schema";
30import { deepMerge } from "./Struct.ts";
31import { fromLenientJson } from "./schemaJson.ts";
32import { createModelSelection, readCustomModelEntries } from "./model.ts";
33import {
34 getBackgroundActivityBaseProfile,
35 normalizeBackgroundActivitySettings,
36 normalizeServerBackgroundActivitySettings,
37 resolveBackgroundActivitySettings,
38} from "./backgroundActivitySettings.ts";
39
40// Only observability: a value the server migrates on load elsewhere in the file must not drop it.
41const ServerObservabilitySettingsJson = fromLenientJson(
42 Schema.Struct({ observability: ServerSettings.fields.observability }),
43);
44const decodeServerObservabilitySettingsJson = Schema.decodeUnknownOption(
45 ServerObservabilitySettingsJson,
46);
47
48export function isModelSelectionProviderEnabled(
49 settings: ServerSettings,
50 selection: ModelSelection,
51): boolean {
52 const generator = textGeneratorForSelection(settings, selection.instanceId);
53 if (generator !== undefined) return generator.enabled;
54 const instanceConfig = settings.providerInstances[selection.instanceId];
55 if (instanceConfig !== undefined) {
56 return resolveProviderInstanceEnabled(instanceConfig);
57 }
58
59 return isUnconfiguredDefaultInstanceEnabled(selection.instanceId);
60}
61
62const TEXT_GENERATION_FALLBACK_DRIVERS = [
63 "codex",
64 "claudeAgent",
65 "cursor",
66 "grok",
67 "muse",
68 "pi",
69 "opencode",
70 "antigravity",
71].map((driver) => ProviderDriverKind.make(driver));
72
73/** Configured instances come after every default instance, so they only win when no default qualifies. */
74export function fallbackTextGenerationModelSelection(
75 providerInstances: ServerSettings["providerInstances"],
76 isEnabled: (instanceId: ProviderInstanceId, driver: ProviderDriverKind) => boolean,
77 options?: { readonly defaultModelSelection?: ModelSelection | null },
78): ModelSelection | null {
79 const candidates = [
80 ...TEXT_GENERATION_FALLBACK_DRIVERS.map(
81 (driver) => [defaultInstanceIdForDriver(driver), driver] as const,
82 ),
83 ...Object.entries(providerInstances).flatMap(([instanceId, instance]) =>
84 TEXT_GENERATION_FALLBACK_DRIVERS.includes(instance.driver)
85 ? [[ProviderInstanceId.make(instanceId), instance.driver] as const]
86 : [],
87 ),
88 ];
89 const match = candidates.find(([instanceId, driver]) => isEnabled(instanceId, driver));
90 if (match === undefined) return null;
91 const [instanceId, driver] = match;
92 const threadDefault = options?.defaultModelSelection;
93 const config = providerInstances[instanceId]?.config as { customModels?: unknown } | undefined;
94 if (
95 threadDefault?.instanceId === instanceId &&
96 readCustomModelEntries(config?.customModels).some((entry) => entry.slug === threadDefault.model)
97 ) {
98 return threadDefault;
99 }
100 return { instanceId, model: defaultTextGenerationModel(driver) };
101}
102
103export function defaultTextGenerationModel(driver: ProviderDriverKind): string {
104 return (
105 DEFAULT_TEXT_GENERATION_MODEL_BY_PROVIDER[driver] ??
106 DEFAULT_MODEL_BY_PROVIDER[driver] ??
107 DEFAULT_TEXT_GENERATION_MODEL
108 );
109}
110
111/** A text generator, or a provider whose snapshot can generate text; no snapshots trusts settings. */
112function isTextGenerationTargetUsable(
113 settings: ServerSettings,
114 providers: ReadonlyArray<ServerProvider> | undefined,
115 instanceId: ProviderInstanceId,
116): boolean {
117 if (providers === undefined || textGeneratorForSelection(settings, instanceId) !== undefined) {
118 return true;
119 }
120 const provider = providers.find((candidate) => candidate.instanceId === instanceId);
121 return (
122 provider?.enabled === true &&
123 isProviderAvailable(provider) &&
124 isProviderTextGenerationCapable(provider)
125 );
126}
127
128export function resolveSourceControlWriterModelSelection(
129 settings: ServerSettings,
130 providers: ReadonlyArray<ServerProvider> | undefined,
131 projectId: ProjectId | null,
132): ModelSelection {
133 const selection = settings.sourceControlWriterModelSelection;
134 return selection &&
135 resolveTextGenerationSelectionEnabled(settings, projectId, selection.instanceId) &&
136 isTextGenerationTargetUsable(settings, providers, selection.instanceId)
137 ? selection
138 : settings.textGenerationModelSelection;
139}
140
141export function resolveReviewGuideModelSelection(
142 settings: ServerSettings,
143 providers: ReadonlyArray<ServerProvider> | undefined,
144 projectId: ProjectId | null,
145): ModelSelection {
146 const selection = settings.reviewGuideModelSelection;
147 // Text generators cannot investigate a checkout, so they never write review guides.
148 return selection &&
149 textGeneratorForSelection(settings, selection.instanceId) === undefined &&
150 resolveProjectProviderInstanceEnabled(settings, projectId, selection.instanceId) &&
151 isTextGenerationTargetUsable(settings, providers, selection.instanceId)
152 ? selection
153 : resolveSourceControlWriterModelSelection(settings, providers, projectId);
154}
155
156/** Transcript cleanup follows the text generation model unless its own usable model is set. */
157export function resolveSpeechPostProcessingModelSelection(
158 settings: ServerSettings,
159 providers?: ReadonlyArray<ServerProvider>,
160): ModelSelection {
161 const selection = settings.speechPostProcessingModelSelection;
162 return selection &&
163 isModelSelectionProviderEnabled(settings, selection) &&
164 isTextGenerationTargetUsable(settings, providers, selection.instanceId)
165 ? selection
166 : settings.textGenerationModelSelection;
167}
168
169export interface PersistedServerObservabilitySettings {
170 readonly otlpTracesUrl: string | undefined;
171 readonly otlpMetricsUrl: string | undefined;
172 readonly otlpLogsUrl: string | undefined;
173}
174
175function normalizePersistedServerSettingString(
176 value: string | null | undefined,
177): string | undefined {
178 const trimmed = value?.trim();
179 return trimmed && trimmed.length > 0 ? trimmed : undefined;
180}
181
182function extractPersistedServerObservabilitySettings(input: {
183 readonly observability?: {
184 readonly otlpTracesUrl?: string;
185 readonly otlpMetricsUrl?: string;
186 readonly otlpLogsUrl?: string;
187 };
188}): PersistedServerObservabilitySettings {
189 return {
190 otlpTracesUrl: normalizePersistedServerSettingString(input.observability?.otlpTracesUrl),
191 otlpMetricsUrl: normalizePersistedServerSettingString(input.observability?.otlpMetricsUrl),
192 otlpLogsUrl: normalizePersistedServerSettingString(input.observability?.otlpLogsUrl),
193 };
194}
195
196export function parsePersistedServerObservabilitySettings(
197 raw: string,
198): PersistedServerObservabilitySettings {
199 const decoded = decodeServerObservabilitySettingsJson(raw);
200 if (Option.isSome(decoded)) {
201 return extractPersistedServerObservabilitySettings(decoded.value);
202 }
203 return { otlpTracesUrl: undefined, otlpMetricsUrl: undefined, otlpLogsUrl: undefined };
204}
205
206function shouldReplaceTextGenerationModelSelection(
207 patch: ServerSettingsPatch["textGenerationModelSelection"] | undefined,
208): boolean {
209 return Boolean(patch && (patch.instanceId !== undefined || patch.model !== undefined));
210}
211
212function mergeModelSelectionOptionsById(input: {
213 current: ReadonlyArray<{ readonly id: string; readonly value: string | boolean }> | undefined;
214 patch: ReadonlyArray<{ readonly id: string; readonly value: string | boolean }> | undefined;
215}): Array<{ id: string; value: string | boolean }> | undefined {
216 if (input.patch === undefined) {
217 return input.current ? [...input.current] : undefined;
218 }
219 if (input.patch.length === 0) {
220 return undefined;
221 }
222
223 const merged = new Map((input.current ?? []).map((selection) => [selection.id, selection.value]));
224 for (const selection of input.patch) {
225 merged.set(selection.id, selection.value);
226 }
227 return [...merged.entries()].map(([id, value]) => ({ id, value }));
228}
229
230function mergeSettingsEntries<Value>(
231 current: Readonly<Record<string, Value>>,
232 patch: Readonly<Record<string, Value | null>>,
233): Record<string, Value> {
234 const next = new Map(Object.entries(current));
235 for (const [id, config] of Object.entries(patch)) {
236 if (config === null) {
237 next.delete(id);
238 } else {
239 next.set(id, config);
240 }
241 }
242 return Object.fromEntries(next);
243}
244
245// Secret persistence keys tokens by trimmed, lowercased host, so merge on the same key.
246const byHost = (tokens: unknown) =>
247 Object.fromEntries(
248 Object.entries(Predicate.isObject(tokens) ? tokens : {}).map(([host, token]) => [
249 host.trim().toLowerCase(),
250 token,
251 ]),
252 );
253
254const knownProjectOverrideKeys = new Set(Object.keys(ProjectSettingsOverrides.fields));
255
256function pickOverrideKeys(entry: ProjectSettingsOverrides | undefined, known: boolean) {
257 return Object.fromEntries(
258 Object.entries<unknown>(entry ?? {}).filter(
259 ([key]) => knownProjectOverrideKeys.has(key) === known,
260 ),
261 );
262}
263
264// Older clients omit providerInstances during whole-entry replacement; preserve it to avoid wiping overrides.
265function mergeProjectSettingsOverridesPatch(
266 current: Readonly<Record<string, ProjectSettingsOverrides>>,
267 patch: Readonly<Record<string, ProjectSettingsOverrides | null>>,
268): Record<string, ProjectSettingsOverrides> {
269 const next = new Map(Object.entries(current));
270 for (const [projectId, entry] of Object.entries(patch)) {
271 if (entry === null) {
272 next.delete(projectId);
273 continue;
274 }
275 const storedProviderInstances = current[projectId]?.providerInstances;
276 next.set(projectId, {
277 // Preserve downgraded storage, but reject new unknown writes so clients can detect unsupported settings.
278 ...pickOverrideKeys(current[projectId], false),
279 ...pickOverrideKeys(entry, true),
280 ...(Object.hasOwn(entry, "providerInstances") || storedProviderInstances === undefined
281 ? {}
282 : { providerInstances: storedProviderInstances }),
283 });
284 }
285 return Object.fromEntries(next);
286}
287
288export function deriveLegacyProjectOverrides(
289 settings: Pick<ServerSettings, "projectSettingsOverrides">,
290): Pick<
291 ServerSettings,
292 "projectAgentBrowserAccessOverrides" | "projectAutoPullOverrides" | "projectScriptOverrides"
293> {
294 const projectAgentBrowserAccessOverrides: Record<string, boolean> = {};
295 const projectAutoPullOverrides: Record<string, boolean> = {};
296 const projectScriptOverrides: Record<string, ServerSettings["defaultProjectScripts"] | null> = {};
297 for (const [projectId, entry] of Object.entries(settings.projectSettingsOverrides)) {
298 if (entry.enableAgentBrowserAccess !== undefined) {
299 projectAgentBrowserAccessOverrides[projectId] = entry.enableAgentBrowserAccess;
300 }
301 if (entry.defaultAutoPull !== undefined) {
302 projectAutoPullOverrides[projectId] = entry.defaultAutoPull;
303 }
304 if (entry.defaultProjectScripts !== undefined) {
305 projectScriptOverrides[projectId] = entry.defaultProjectScripts;
306 }
307 }
308 return { projectAgentBrowserAccessOverrides, projectAutoPullOverrides, projectScriptOverrides };
309}
310
311function translateLegacyProjectOverridePatch(
312 current: Pick<ServerSettings, "projectSettingsOverrides">,
313 patch: ServerSettingsPatch,
314): ServerSettingsPatch {
315 const {
316 projectAgentBrowserAccessOverrides,
317 projectAutoPullOverrides,
318 projectScriptOverrides,
319 ...rest
320 } = patch;
321 if (
322 projectAgentBrowserAccessOverrides === undefined &&
323 projectAutoPullOverrides === undefined &&
324 projectScriptOverrides === undefined
325 ) {
326 return patch;
327 }
328 const currentEntries: Readonly<Record<string, ProjectSettingsOverrides>> =
329 current.projectSettingsOverrides;
330 const entries = new Map<string, ProjectSettingsOverrides | null>(
331 Object.entries(rest.projectSettingsOverrides ?? {}),
332 );
333 // Canonical entries outrank legacy maps, including deliberately omitted keys.
334 const canonicalProjectIds = new Set(Object.keys(rest.projectSettingsOverrides ?? {}));
335 const applyKey = <K extends ProjectScopedServerSettingKey>(
336 map: Readonly<Record<string, ProjectSettingsOverrides[K] | null>> | undefined,
337 key: K,
338 ) => {
339 if (map === undefined) return;
340 for (const [projectId, value] of Object.entries(map)) {
341 if (canonicalProjectIds.has(projectId)) continue;
342 const entry: ProjectSettingsOverrides = {
343 ...(entries.get(projectId) ?? currentEntries[projectId]),
344 };
345 if (value === null || value === undefined) {
346 delete entry[key];
347 } else {
348 entry[key] = value;
349 }
350 entries.set(projectId, Object.keys(entry).length === 0 ? null : entry);
351 }
352 };
353 applyKey(projectAgentBrowserAccessOverrides, "enableAgentBrowserAccess");
354 applyKey(projectAutoPullOverrides, "defaultAutoPull");
355 applyKey(projectScriptOverrides, "defaultProjectScripts");
356 return {
357 ...rest,
358 projectSettingsOverrides: Object.fromEntries(entries),
359 } as ServerSettingsPatch;
360}
361
362/**
363 * A client from before `idleCompaction` patches the old boolean switch. Turning
364 * it off keeps "Never" rather than reverting to the default.
365 */
366function patchedIdleCompaction(
367 current: ServerSettings,
368 patch: ServerSettingsPatch,
369): IdleCompactionMode {
370 if (patch.idleCompaction !== undefined) return patch.idleCompaction;
371 const legacy = patch.compactIdleThreads;
372 if (legacy === undefined) return globalIdleCompaction(current);
373 if (typeof legacy === "string") return legacy;
374 if (legacy) return "beforeCacheExpires";
375 return globalIdleCompaction(current) === "off" ? "off" : "onReturn";
376}
377
378export function applyServerSettingsPatch(
379 current: ServerSettings,
380 rawPatch: ServerSettingsPatch,
381): ServerSettings {
382 const patch = translateLegacyProjectOverridePatch(current, rawPatch);
383 const selectionPatch = patch.textGenerationModelSelection;
384 const {
385 migrateModelPreferences,
386 setModelFavorites,
387 setModelsHidden,
388 setProviderModelOrder,
389 providerModelPreferences,
390 automaticGitFetchInterval,
391 providerHealthRefreshInterval,
392 backgroundActivityProfile,
393 backgroundActivity,
394 worktreeCleanup: worktreeCleanupPatch,
395 // Merged per entry below; its `null` removals must not reach deepMerge.
396 usageLimitSources: usageLimitSourcesPatch,
397 textGenerators: textGeneratorsPatch,
398 secretProviders: secretProvidersPatch,
399 sourceControlHosts: sourceControlHostsPatch,
400 usagePriceOverrides: usagePriceOverridesPatch,
401 usageModelAliases: usageModelAliasesPatch,
402 // Entry replacement: deepMerge would keep keys the client meant to clear.
403 projectSettingsOverrides: projectSettingsOverridesPatch,
404 projectAgentBrowserAccessOverrides: _legacyBrowserAccess,
405 projectAutoPullOverrides: _legacyAutoPull,
406 projectScriptOverrides: _legacyScripts,
407 ...patchForMerge
408 } = patch;
409 const currentBackgroundActivity = normalizeServerBackgroundActivitySettings(current);
410 const backgroundActivityPatch =
411 backgroundActivityProfile !== undefined
412 ? {
413 schemaVersion: 1 as const,
414 profile:
415 automaticGitFetchInterval !== undefined || providerHealthRefreshInterval !== undefined
416 ? ("custom" as const)
417 : backgroundActivityProfile,
418 ...(automaticGitFetchInterval !== undefined || providerHealthRefreshInterval !== undefined
419 ? { baseProfile: backgroundActivityProfile }
420 : {}),
421 overrides: {
422 ...(automaticGitFetchInterval !== undefined ? { automaticGitFetchInterval } : {}),
423 ...(providerHealthRefreshInterval !== undefined
424 ? { providerHealthRefreshInterval }
425 : {}),
426 },
427 }
428 : automaticGitFetchInterval !== undefined || providerHealthRefreshInterval !== undefined
429 ? {
430 schemaVersion: 1 as const,
431 profile: "custom" as const,
432 baseProfile: getBackgroundActivityBaseProfile(currentBackgroundActivity),
433 overrides: {
434 ...(currentBackgroundActivity.profile === "custom"
435 ? currentBackgroundActivity.overrides
436 : {}),
437 ...(automaticGitFetchInterval !== undefined ? { automaticGitFetchInterval } : {}),
438 ...(providerHealthRefreshInterval !== undefined
439 ? { providerHealthRefreshInterval }
440 : {}),
441 },
442 }
443 : undefined;
444 const initialFavorites =
445 patch.favorites ?? current.favorites ?? migrateModelPreferences?.favorites ?? null;
446 const favorites =
447 setModelFavorites?.reduce(
448 (current, change) => {
449 const exists = current.some(
450 (favorite) => favorite.provider === change.provider && favorite.model === change.model,
451 );
452 if (change.favorite) {
453 if (!exists) current.push({ provider: change.provider, model: change.model });
454 return current;
455 }
456 return current.filter(
457 (favorite) => favorite.provider !== change.provider || favorite.model !== change.model,
458 );
459 },
460 [...(initialFavorites ?? [])],
461 ) ?? initialFavorites;
462 const initialModelPreferences =
463 providerModelPreferences ??
464 current.providerModelPreferences ??
465 migrateModelPreferences?.providerModelPreferences ??
466 null;
467 let nextModelPreferences = initialModelPreferences;
468 if (setModelsHidden?.length) {
469 const updated = { ...initialModelPreferences };
470 for (const change of setModelsHidden) {
471 const preferences = (Object.hasOwn(updated, change.provider)
472 ? updated[change.provider]
473 : undefined) ?? {
474 hiddenModels: [],
475 modelOrder: [],
476 };
477 const hiddenModels = preferences.hiddenModels.filter((model) => model !== change.model);
478 if (change.hidden) hiddenModels.push(change.model);
479 updated[change.provider] = { ...preferences, hiddenModels };
480 }
481 nextModelPreferences = updated;
482 }
483 if (setProviderModelOrder) {
484 const preferences = nextModelPreferences?.[setProviderModelOrder.provider] ?? {
485 hiddenModels: [],
486 modelOrder: [],
487 };
488 nextModelPreferences = {
489 ...nextModelPreferences,
490 [setProviderModelOrder.provider]: {
491 ...preferences,
492 modelOrder: [...setProviderModelOrder.modelOrder],
493 },
494 };
495 }
496 const next = deepMerge(current, patchForMerge);
497 const nextWithReplacementsBase = {
498 ...next,
499 favorites,
500 providerModelPreferences: nextModelPreferences,
501 ...(worktreeCleanupPatch === undefined
502 ? {}
503 : {
504 worktreeCleanup:
505 worktreeCleanupPatch?.mode === "custom"
506 ? {
507 mode: "custom" as const,
508 rules: {
509 worktreeKeepWhen: next.storageCleanup.worktreeKeepWhen,
510 worktreeAfterDays: next.storageCleanup.worktreeAfterDays,
511 worktreeSettledAfterDays: next.storageCleanup.worktreeSettledAfterDays,
512 worktreeOnMerge: next.storageCleanup.worktreeOnMerge,
513 worktreeOnDelete: next.storageCleanup.worktreeOnDelete,
514 worktreeUnchanged: next.storageCleanup.worktreeUnchanged,
515 ...(current.worktreeCleanup?.mode === "custom"
516 ? current.worktreeCleanup.rules
517 : {}),
518 ...worktreeCleanupPatch.rules,
519 },
520 }
521 : worktreeCleanupPatch,
522 }),
523 ...(backgroundActivity !== undefined
524 ? {
525 backgroundActivity: {
526 ...deepMerge(currentBackgroundActivity, backgroundActivity),
527 ...(backgroundActivity.overrides !== undefined
528 ? { overrides: backgroundActivity.overrides }
529 : {}),
530 },
531 }
532 : { backgroundActivity: currentBackgroundActivity }),
533 ...(backgroundActivity === undefined && backgroundActivityPatch !== undefined
534 ? { backgroundActivity: backgroundActivityPatch }
535 : {}),
536 ...(patch.providerInstances !== undefined
537 ? { providerInstances: patch.providerInstances }
538 : {}),
539 ...(patch.worktreesDirectory !== undefined &&
540 patch.worktreesDirectory !== current.worktreesDirectory
541 ? {
542 previousWorktreesDirectories: [
543 ...current.previousWorktreesDirectories.filter(
544 (directory) => directory !== patch.worktreesDirectory,
545 ),
546 ...(current.worktreesDirectory !== "" &&
547 !current.previousWorktreesDirectories.includes(current.worktreesDirectory)
548 ? [current.worktreesDirectory]
549 : []),
550 ],
551 }
552 : {}),
553 // Per host, a patched field replaces the saved one: deepMerge would keep a cleared account pin.
554 ...(sourceControlHostsPatch !== undefined
555 ? {
556 sourceControlHosts: {
557 ...current.sourceControlHosts,
558 ...Object.fromEntries(
559 Object.entries(sourceControlHostsPatch).map(([kind, fields]) => {
560 const saved = current.sourceControlHosts[kind];
561 return [
562 kind,
563 {
564 ...saved,
565 ...fields,
566 // Older clients send the whole token map; a host missing from it keeps its saved
567 // token. An empty map still clears them all.
568 ...(Predicate.isObject(fields.tokens) && Object.keys(fields.tokens).length > 0
569 ? {
570 tokens: {
571 ...byHost(saved?.tokens),
572 ...byHost(fields.tokens),
573 },
574 }
575 : {}),
576 },
577 ];
578 }),
579 ),
580 },
581 }
582 : {}),
583 ...(projectSettingsOverridesPatch !== undefined
584 ? {
585 projectSettingsOverrides: Object.fromEntries(
586 Object.entries(
587 mergeProjectSettingsOverridesPatch(
588 current.projectSettingsOverrides,
589 projectSettingsOverridesPatch,
590 ),
591 ).filter(([, entry]) => Object.keys(entry).length > 0),
592 ),
593 }
594 : {}),
595 ...(patch.defaultModelSelection !== undefined
596 ? { defaultModelSelection: patch.defaultModelSelection }
597 : {}),
598 ...(patch.fallbackModelSelection !== undefined
599 ? { fallbackModelSelection: patch.fallbackModelSelection }
600 : {}),
601 ...(patch.speechPostProcessingModelSelection !== undefined
602 ? { speechPostProcessingModelSelection: patch.speechPostProcessingModelSelection }
603 : {}),
604 ...(patch.defaultProjectScripts !== undefined
605 ? { defaultProjectScripts: patch.defaultProjectScripts }
606 : {}),
607 ...(usageLimitSourcesPatch !== undefined
608 ? {
609 usageLimitSources: mergeSettingsEntries(
610 current.usageLimitSources,
611 usageLimitSourcesPatch,
612 ),
613 }
614 : {}),
615 ...(textGeneratorsPatch !== undefined
616 ? { textGenerators: mergeSettingsEntries(current.textGenerators, textGeneratorsPatch) }
617 : {}),
618 ...(secretProvidersPatch !== undefined
619 ? { secretProviders: mergeSettingsEntries(current.secretProviders, secretProvidersPatch) }
620 : {}),
621 ...(usagePriceOverridesPatch !== undefined
622 ? {
623 usagePriceOverrides: mergeSettingsEntries(
624 current.usagePriceOverrides,
625 usagePriceOverridesPatch,
626 ),
627 }
628 : {}),
629 ...(usageModelAliasesPatch !== undefined
630 ? {
631 usageModelAliases: mergeSettingsEntries(
632 current.usageModelAliases,
633 usageModelAliasesPatch,
634 ),
635 }
636 : {}),
637 ...(patch.sourceControlWriterModelSelection !== undefined
638 ? { sourceControlWriterModelSelection: patch.sourceControlWriterModelSelection }
639 : {}),
640 ...(patch.reviewGuideModelSelection !== undefined
641 ? { reviewGuideModelSelection: patch.reviewGuideModelSelection }
642 : {}),
643 ...(automaticGitFetchInterval !== undefined ? { automaticGitFetchInterval } : {}),
644 ...(providerHealthRefreshInterval !== undefined ? { providerHealthRefreshInterval } : {}),
645 };
646 const normalizedBackgroundActivity = normalizeBackgroundActivitySettings(
647 nextWithReplacementsBase.backgroundActivity,
648 );
649 const resolvedBackgroundActivity = resolveBackgroundActivitySettings(
650 normalizedBackgroundActivity,
651 );
652 const nextWithReplacements = {
653 ...withIdleCompaction(nextWithReplacementsBase, patchedIdleCompaction(current, patch)),
654 ...deriveLegacyProjectOverrides(nextWithReplacementsBase),
655 backgroundActivity: normalizedBackgroundActivity,
656 automaticGitFetchInterval: resolvedBackgroundActivity.automaticGitFetchInterval,
657 providerHealthRefreshInterval: resolvedBackgroundActivity.providerHealthRefreshInterval,
658 backgroundActivityProfile: resolvedBackgroundActivity.profile,
659 };
660 if (!selectionPatch) {
661 return nextWithReplacements;
662 }
663
664 const instanceId = selectionPatch.instanceId ?? current.textGenerationModelSelection.instanceId;
665 const model = selectionPatch.model ?? current.textGenerationModelSelection.model;
666 const options = shouldReplaceTextGenerationModelSelection(selectionPatch)
667 ? selectionPatch.options
668 : mergeModelSelectionOptionsById({
669 current: current.textGenerationModelSelection.options,
670 patch: selectionPatch.options,
671 });
672
673 return {
674 ...nextWithReplacements,
675 textGenerationModelSelection: createModelSelection(instanceId, model, options),
676 };
677}
678
679export function resolveModelPreferences(
680 settings: Pick<ServerSettings, "favorites" | "providerModelPreferences">,
681 legacy: Partial<ModelPreferences> = {},
682): ModelPreferences {
683 return {
684 favorites: settings.favorites ?? legacy.favorites ?? [],
685 providerModelPreferences:
686 settings.providerModelPreferences ?? legacy.providerModelPreferences ?? {},
687 };
688}
689
690/** Empty legacy values do not claim ownership before another client can migrate its saved list. */
691export function modelPreferencesMigrationPatch(
692 settings: Pick<ServerSettings, "favorites" | "providerModelPreferences">,
693 legacy: Partial<ModelPreferences>,
694): ServerSettingsPatch | null {
695 const favorites =
696 settings.favorites === null && (legacy.favorites?.length ?? 0) > 0
697 ? legacy.favorites
698 : undefined;
699 const providerModelPreferences =
700 settings.providerModelPreferences === null &&
701 Object.keys(legacy.providerModelPreferences ?? {}).length > 0
702 ? legacy.providerModelPreferences
703 : undefined;
704 return favorites === undefined && providerModelPreferences === undefined
705 ? null
706 : {
707 migrateModelPreferences: {
708 ...(favorites === undefined ? {} : { favorites }),
709 ...(providerModelPreferences === undefined ? {} : { providerModelPreferences }),
710 },
711 };
712}