* feat(audio): let resolveAgentVoice honor per-agent voice overrides * feat(settings): persist per-agent voice overrides * fix(agents): persist AgentBar voice picks via settings overrides * fix(classroom): keep user's agent mode and selection across loads * fix(agents): only carry user-set agent selection across classrooms Review follow-ups: stage-derived defaults written by a classroom load were re-read as a user choice on the next load, so visiting a preset classroom permanently downgraded auto classrooms to preset agents. Track the origin with a persisted agentSelectionIsUserSet flag (set by AgentBar interactions, cleared by fallback writes). Also: voice overrides are now clearable (undefined deletes), the override type is single-sourced in voice-resolver, and persist rehydration of the new fields is pinned by tests. * fix(agents): don't mark stage-derived selections as user choices Round-2 review: clicking the already-active mode tab no longer flags the selection as user-set (a visual no-op must not promote stage defaults to a choice), generation-preview clears the flag when it writes the generated roster, and tests now pin that setter writes actually reach storage. * fix(agents): restore generated agent selection when switching back to Auto Review follow-up (#723): handleModeChange('auto') left the preset ids selected, so the UI said Auto while discussion playback kept using preset agents, and the persisted user-set auto pair could never validate on restore. Switching to Auto now selects the loaded classroom's generated agents (empty when none are loaded, falling back to stage defaults on the next classroom load).
1916 lines
73 KiB
TypeScript
1916 lines
73 KiB
TypeScript
/**
|
|
* Settings Store
|
|
* Global settings state synchronized with localStorage
|
|
*/
|
|
|
|
import { create } from 'zustand';
|
|
import { persist } from 'zustand/middleware';
|
|
import type { ProviderId } from '@/lib/ai/providers';
|
|
import type { ProvidersConfig } from '@/lib/types/settings';
|
|
import { PROVIDERS } from '@/lib/ai/providers';
|
|
import type { ThinkingConfig } from '@/lib/types/provider';
|
|
import { getThinkingConfigKey, supportsConfigurableThinking } from '@/lib/ai/thinking-config';
|
|
import type { TTSProviderId, ASRProviderId, BuiltInTTSProviderId } from '@/lib/audio/types';
|
|
import type { AgentVoiceOverride } from '@/lib/audio/voice-resolver';
|
|
import { isCustomTTSProvider, isCustomASRProvider } from '@/lib/audio/types';
|
|
import { ASR_PROVIDERS, DEFAULT_TTS_VOICES, TTS_PROVIDERS } from '@/lib/audio/constants';
|
|
import { DEFAULT_VOXCPM_BACKEND, VOXCPM_MODEL_ID, VOXCPM_VLLM_MODEL_ID } from '@/lib/audio/voxcpm';
|
|
import { PDF_PROVIDERS } from '@/lib/pdf/constants';
|
|
import type { PDFProviderId } from '@/lib/pdf/types';
|
|
import type { ImageProviderId, VideoProviderId } from '@/lib/media/types';
|
|
import { IMAGE_PROVIDERS } from '@/lib/media/image-providers';
|
|
import { VIDEO_PROVIDERS } from '@/lib/media/video-providers';
|
|
import { WEB_SEARCH_PROVIDERS } from '@/lib/web-search/constants';
|
|
import type { BaiduSubSources, WebSearchProviderId } from '@/lib/web-search/types';
|
|
import { createLogger } from '@/lib/logger';
|
|
import {
|
|
validateProvider,
|
|
resolveSelectedModel,
|
|
isLLMProviderConfigured,
|
|
} from '@/lib/store/settings-validation';
|
|
|
|
const log = createLogger('Settings');
|
|
|
|
function pruneThinkingConfigs(
|
|
thinkingConfigs: Record<string, ThinkingConfig> | undefined,
|
|
providersConfig: ProvidersConfig | undefined,
|
|
): Record<string, ThinkingConfig> {
|
|
if (!thinkingConfigs || !providersConfig) return {};
|
|
|
|
const validKeys = new Set<string>();
|
|
for (const [providerId, providerConfig] of Object.entries(providersConfig)) {
|
|
for (const model of providerConfig.models) {
|
|
if (supportsConfigurableThinking(model.capabilities?.thinking)) {
|
|
validKeys.add(getThinkingConfigKey(providerId, model.id));
|
|
}
|
|
}
|
|
}
|
|
|
|
return Object.fromEntries(
|
|
Object.entries(thinkingConfigs).filter(([key]) => validKeys.has(key)),
|
|
) as Record<string, ThinkingConfig>;
|
|
}
|
|
|
|
/** Available playback speed tiers */
|
|
export const PLAYBACK_SPEEDS = [1, 1.25, 1.5, 2] as const;
|
|
export type PlaybackSpeed = (typeof PLAYBACK_SPEEDS)[number];
|
|
|
|
export interface SettingsState {
|
|
// Model selection
|
|
providerId: ProviderId;
|
|
modelId: string;
|
|
thinkingConfigs: Record<string, ThinkingConfig>;
|
|
|
|
// Provider configurations (unified JSON storage)
|
|
providersConfig: ProvidersConfig;
|
|
|
|
// TTS settings (legacy, kept for backward compatibility)
|
|
ttsModel: string;
|
|
|
|
// Audio settings (new unified audio configuration)
|
|
ttsProviderId: TTSProviderId;
|
|
ttsVoice: string;
|
|
ttsSpeed: number;
|
|
asrProviderId: ASRProviderId;
|
|
asrLanguage: string;
|
|
|
|
// Audio provider configurations
|
|
ttsProvidersConfig: Record<
|
|
TTSProviderId,
|
|
{
|
|
apiKey: string;
|
|
baseUrl: string;
|
|
enabled: boolean;
|
|
modelId?: string;
|
|
customModels?: Array<{ id: string; name: string }>;
|
|
providerOptions?: Record<string, unknown>;
|
|
isServerConfigured?: boolean;
|
|
/** Admin/server-level force-off (server-providers.yml / env). Overrides `enabled`. */
|
|
serverDisabled?: boolean;
|
|
// Custom provider fields
|
|
customName?: string;
|
|
customDefaultBaseUrl?: string;
|
|
customVoices?: Array<{ id: string; name: string }>;
|
|
isBuiltIn?: boolean;
|
|
requiresApiKey?: boolean;
|
|
}
|
|
>;
|
|
|
|
asrProvidersConfig: Record<
|
|
ASRProviderId,
|
|
{
|
|
apiKey: string;
|
|
baseUrl: string;
|
|
enabled: boolean;
|
|
modelId?: string;
|
|
customModels?: Array<{ id: string; name: string }>;
|
|
providerOptions?: Record<string, unknown>;
|
|
isServerConfigured?: boolean;
|
|
// Custom provider fields
|
|
customName?: string;
|
|
customDefaultBaseUrl?: string;
|
|
isBuiltIn?: boolean;
|
|
requiresApiKey?: boolean;
|
|
}
|
|
>;
|
|
|
|
// PDF settings
|
|
pdfProviderId: PDFProviderId;
|
|
pdfProvidersConfig: Record<
|
|
PDFProviderId,
|
|
{
|
|
apiKey: string;
|
|
baseUrl: string;
|
|
enabled: boolean;
|
|
requiresApiKey?: boolean;
|
|
isServerConfigured?: boolean;
|
|
}
|
|
>;
|
|
baiduSubSources: BaiduSubSources;
|
|
|
|
// Image Generation settings
|
|
imageProviderId: ImageProviderId;
|
|
imageModelId: string;
|
|
imageProvidersConfig: Record<
|
|
ImageProviderId,
|
|
{
|
|
apiKey: string;
|
|
baseUrl: string;
|
|
enabled: boolean;
|
|
isServerConfigured?: boolean;
|
|
customModels?: Array<{ id: string; name: string }>;
|
|
}
|
|
>;
|
|
|
|
// Video Generation settings
|
|
videoProviderId: VideoProviderId;
|
|
videoModelId: string;
|
|
videoProvidersConfig: Record<
|
|
VideoProviderId,
|
|
{
|
|
apiKey: string;
|
|
baseUrl: string;
|
|
enabled: boolean;
|
|
isServerConfigured?: boolean;
|
|
customModels?: Array<{ id: string; name: string }>;
|
|
}
|
|
>;
|
|
|
|
// Media generation toggles
|
|
imageGenerationEnabled: boolean;
|
|
videoGenerationEnabled: boolean;
|
|
reviewOutlineEnabled: boolean;
|
|
|
|
// Web Search settings
|
|
webSearchProviderId: WebSearchProviderId;
|
|
webSearchProvidersConfig: Record<
|
|
WebSearchProviderId,
|
|
{
|
|
apiKey: string;
|
|
baseUrl: string;
|
|
enabled: boolean;
|
|
requiresApiKey?: boolean;
|
|
isServerConfigured?: boolean;
|
|
}
|
|
>;
|
|
|
|
// Global TTS/ASR toggles
|
|
ttsEnabled: boolean;
|
|
asrEnabled: boolean;
|
|
|
|
// Server-configured opt-in parallel scene-content concurrency (#572).
|
|
// 0 = off (serial generation); populated by fetchServerProviders.
|
|
parallelSceneConcurrency: number;
|
|
|
|
// Auto-config lifecycle flag (persisted)
|
|
autoConfigApplied: boolean;
|
|
|
|
// Playback controls
|
|
ttsMuted: boolean;
|
|
ttsVolume: number; // 0-1, actual volume level
|
|
autoPlayLecture: boolean;
|
|
playbackSpeed: PlaybackSpeed;
|
|
|
|
// Agent settings
|
|
selectedAgentIds: string[];
|
|
agentMode: 'preset' | 'auto';
|
|
autoAgentCount: number;
|
|
/**
|
|
* Per-agent voice picks made in the AgentBar, keyed by agent id. Lives here
|
|
* (persisted) rather than on registry AgentConfig records because default
|
|
* agents are reset from code and generated agents are rebuilt from IndexedDB
|
|
* on every load. Highest-priority input to resolveAgentVoice.
|
|
*/
|
|
agentVoiceOverrides: Record<string, AgentVoiceOverride>;
|
|
/**
|
|
* Whether agentMode/selectedAgentIds were explicitly set by the user (in the
|
|
* AgentBar), as opposed to stage-derived defaults written by a classroom
|
|
* load. Only a user-set selection carries across classrooms on restore.
|
|
*/
|
|
agentSelectionIsUserSet: boolean;
|
|
|
|
// Layout preferences (persisted via localStorage)
|
|
sidebarCollapsed: boolean;
|
|
chatAreaCollapsed: boolean;
|
|
chatAreaWidth: number;
|
|
editRailCollapsed: boolean;
|
|
editRailWidth: number;
|
|
editInsertToolbarCollapsed: boolean;
|
|
|
|
// Actions
|
|
setModel: (providerId: ProviderId, modelId: string) => void;
|
|
setThinkingConfig: (
|
|
providerId: ProviderId,
|
|
modelId: string,
|
|
config: ThinkingConfig | undefined,
|
|
) => void;
|
|
setProviderConfig: (providerId: ProviderId, config: Partial<ProvidersConfig[ProviderId]>) => void;
|
|
setProvidersConfig: (config: ProvidersConfig) => void;
|
|
setTtsModel: (model: string) => void;
|
|
setTTSMuted: (muted: boolean) => void;
|
|
setTTSVolume: (volume: number) => void;
|
|
setAutoPlayLecture: (autoPlay: boolean) => void;
|
|
setPlaybackSpeed: (speed: PlaybackSpeed) => void;
|
|
setSelectedAgentIds: (ids: string[]) => void;
|
|
setAgentMode: (mode: 'preset' | 'auto') => void;
|
|
setAutoAgentCount: (count: number) => void;
|
|
/** Set (or clear, with `undefined`) the persisted voice pick for one agent. */
|
|
setAgentVoiceOverride: (agentId: string, voice: AgentVoiceOverride | undefined) => void;
|
|
setAgentSelectionIsUserSet: (isUserSet: boolean) => void;
|
|
|
|
// Layout actions
|
|
setSidebarCollapsed: (collapsed: boolean) => void;
|
|
setChatAreaCollapsed: (collapsed: boolean) => void;
|
|
setChatAreaWidth: (width: number) => void;
|
|
setEditRailCollapsed: (collapsed: boolean) => void;
|
|
setEditInsertToolbarCollapsed: (collapsed: boolean) => void;
|
|
setEditRailWidth: (width: number) => void;
|
|
|
|
// Audio actions
|
|
setTTSProvider: (providerId: TTSProviderId) => void;
|
|
setTTSVoice: (voice: string) => void;
|
|
setTTSSpeed: (speed: number) => void;
|
|
setASRProvider: (providerId: ASRProviderId) => void;
|
|
setASRLanguage: (language: string) => void;
|
|
setTTSProviderConfig: (
|
|
providerId: TTSProviderId,
|
|
config: Partial<{
|
|
apiKey: string;
|
|
baseUrl: string;
|
|
enabled: boolean;
|
|
modelId: string;
|
|
customModels: Array<{ id: string; name: string }>;
|
|
customVoices: Array<{ id: string; name: string }>;
|
|
providerOptions: Record<string, unknown>;
|
|
}>,
|
|
) => void;
|
|
setASRProviderConfig: (
|
|
providerId: ASRProviderId,
|
|
config: Partial<{
|
|
apiKey: string;
|
|
baseUrl: string;
|
|
enabled: boolean;
|
|
modelId: string;
|
|
customModels: Array<{ id: string; name: string }>;
|
|
providerOptions: Record<string, unknown>;
|
|
}>,
|
|
) => void;
|
|
setTTSEnabled: (enabled: boolean) => void;
|
|
setASREnabled: (enabled: boolean) => void;
|
|
|
|
// Custom audio provider actions
|
|
addCustomTTSProvider: (
|
|
id: TTSProviderId,
|
|
name: string,
|
|
baseUrl: string,
|
|
requiresApiKey: boolean,
|
|
defaultModel?: string,
|
|
) => void;
|
|
removeCustomTTSProvider: (id: TTSProviderId) => void;
|
|
addCustomASRProvider: (
|
|
id: ASRProviderId,
|
|
name: string,
|
|
baseUrl: string,
|
|
requiresApiKey: boolean,
|
|
) => void;
|
|
removeCustomASRProvider: (id: ASRProviderId) => void;
|
|
|
|
// PDF actions
|
|
setPDFProvider: (providerId: PDFProviderId) => void;
|
|
setPDFProviderConfig: (
|
|
providerId: PDFProviderId,
|
|
config: Partial<{ apiKey: string; baseUrl: string; enabled: boolean }>,
|
|
) => void;
|
|
|
|
// Image Generation actions
|
|
setImageProvider: (providerId: ImageProviderId) => void;
|
|
setImageModelId: (modelId: string) => void;
|
|
setImageProviderConfig: (
|
|
providerId: ImageProviderId,
|
|
config: Partial<{
|
|
apiKey: string;
|
|
baseUrl: string;
|
|
enabled: boolean;
|
|
customModels: Array<{ id: string; name: string }>;
|
|
}>,
|
|
) => void;
|
|
|
|
// Video Generation actions
|
|
setVideoProvider: (providerId: VideoProviderId) => void;
|
|
setVideoModelId: (modelId: string) => void;
|
|
setVideoProviderConfig: (
|
|
providerId: VideoProviderId,
|
|
config: Partial<{
|
|
apiKey: string;
|
|
baseUrl: string;
|
|
enabled: boolean;
|
|
customModels: Array<{ id: string; name: string }>;
|
|
}>,
|
|
) => void;
|
|
|
|
// Media generation toggle actions
|
|
setImageGenerationEnabled: (enabled: boolean) => void;
|
|
setVideoGenerationEnabled: (enabled: boolean) => void;
|
|
setReviewOutlineEnabled: (enabled: boolean) => void;
|
|
|
|
// Web Search actions
|
|
setWebSearchProvider: (providerId: WebSearchProviderId) => void;
|
|
setWebSearchProviderConfig: (
|
|
providerId: WebSearchProviderId,
|
|
config: Partial<{ apiKey: string; baseUrl: string; enabled: boolean }>,
|
|
) => void;
|
|
setBaiduSubSources: (sources: Partial<BaiduSubSources>) => void;
|
|
|
|
// Server provider actions
|
|
fetchServerProviders: () => Promise<void>;
|
|
}
|
|
|
|
// Initialize default providers config
|
|
const getDefaultProvidersConfig = (): ProvidersConfig => {
|
|
const config: ProvidersConfig = {} as ProvidersConfig;
|
|
Object.keys(PROVIDERS).forEach((pid) => {
|
|
const provider = PROVIDERS[pid as ProviderId];
|
|
config[pid as ProviderId] = {
|
|
apiKey: '',
|
|
baseUrl: '',
|
|
models: provider.models,
|
|
name: provider.name,
|
|
type: provider.type,
|
|
defaultBaseUrl: provider.defaultBaseUrl,
|
|
icon: provider.icon,
|
|
requiresApiKey: provider.requiresApiKey,
|
|
isBuiltIn: true,
|
|
};
|
|
});
|
|
return config;
|
|
};
|
|
|
|
/**
|
|
* Single shared LLM selection resolver (#580). Given a providers config and
|
|
* the current (providerId, modelId), return the resolved selection that
|
|
* upholds the invariant for ANY config mutation — clearing/adding a key,
|
|
* editing models, deleting a provider, import, reset:
|
|
*
|
|
* - keep the current provider if it is still usable;
|
|
* - else fall back to the first usable provider;
|
|
* - else State A (empty selection).
|
|
*
|
|
* Then resolve a concrete model for the chosen provider. Used by both
|
|
* setProviderConfig (single edit) and setProvidersConfig (bulk) so the two
|
|
* paths can never diverge — the per-call-site asymmetry #580 set out to kill.
|
|
*/
|
|
function resolveLLMSelection(
|
|
config: ProvidersConfig,
|
|
currentProviderId: ProviderId,
|
|
currentModelId: string,
|
|
): { providerId: ProviderId; modelId: string } {
|
|
const isUsable = (id: ProviderId) => !!config[id] && isLLMProviderConfigured(config[id]);
|
|
const providerId = isUsable(currentProviderId)
|
|
? currentProviderId
|
|
: ((Object.keys(config) as ProviderId[]).find(isUsable) ?? ('' as ProviderId));
|
|
const modelId = providerId
|
|
? resolveSelectedModel(currentModelId, config[providerId]?.models ?? [])
|
|
: '';
|
|
return { providerId, modelId };
|
|
}
|
|
|
|
// Initialize default audio config
|
|
const getDefaultAudioConfig = () => ({
|
|
ttsProviderId: 'browser-native-tts' as TTSProviderId,
|
|
ttsVoice: 'default',
|
|
ttsSpeed: 1.0,
|
|
asrProviderId: 'browser-native' as ASRProviderId,
|
|
asrLanguage: 'zh',
|
|
ttsProvidersConfig: {
|
|
// Built-in providers default enabled:true — they only ever surface once
|
|
// configured (API key or server-managed), so "enabled" is a user opt-OUT,
|
|
// not the visibility gate. A server-configured provider must not be hidden
|
|
// by a stale default (#665).
|
|
'openai-tts': { apiKey: '', baseUrl: '', enabled: true },
|
|
'azure-tts': { apiKey: '', baseUrl: '', enabled: true },
|
|
'glm-tts': { apiKey: '', baseUrl: '', enabled: true },
|
|
'qwen-tts': { apiKey: '', baseUrl: '', enabled: true },
|
|
'voxcpm-tts': {
|
|
apiKey: '',
|
|
baseUrl: '',
|
|
modelId: VOXCPM_VLLM_MODEL_ID,
|
|
enabled: true,
|
|
providerOptions: { backend: DEFAULT_VOXCPM_BACKEND },
|
|
},
|
|
'doubao-tts': { apiKey: '', baseUrl: '', enabled: true },
|
|
'elevenlabs-tts': { apiKey: '', baseUrl: '', enabled: true },
|
|
'minimax-tts': { apiKey: '', baseUrl: '', modelId: 'speech-2.8-hd', enabled: true },
|
|
'lemonade-tts': {
|
|
apiKey: '',
|
|
baseUrl: '',
|
|
modelId: 'kokoro-v1',
|
|
enabled: true,
|
|
},
|
|
// Browser-native is OFF by default — fully opt-in. Native voice quality is
|
|
// poor; it must never be a silent default (#665).
|
|
'browser-native-tts': { apiKey: '', baseUrl: '', enabled: false },
|
|
} as Record<
|
|
TTSProviderId,
|
|
{ apiKey: string; baseUrl: string; modelId?: string; enabled: boolean }
|
|
>,
|
|
asrProvidersConfig: {
|
|
'openai-whisper': { apiKey: '', baseUrl: '', enabled: true },
|
|
'browser-native': { apiKey: '', baseUrl: '', enabled: true },
|
|
'qwen-asr': { apiKey: '', baseUrl: '', enabled: false },
|
|
'azure-asr': { apiKey: '', baseUrl: '', enabled: false },
|
|
'lemonade-asr': { apiKey: '', baseUrl: '', enabled: false },
|
|
} as Record<ASRProviderId, { apiKey: string; baseUrl: string; enabled: boolean }>,
|
|
});
|
|
|
|
// Initialize default PDF config
|
|
const getDefaultPDFConfig = () => ({
|
|
pdfProviderId: 'unpdf' as PDFProviderId,
|
|
pdfProvidersConfig: {
|
|
unpdf: { apiKey: '', baseUrl: '', enabled: true },
|
|
mineru: { apiKey: '', baseUrl: '', enabled: false },
|
|
'mineru-cloud': { apiKey: '', baseUrl: '', enabled: false },
|
|
} as Record<PDFProviderId, { apiKey: string; baseUrl: string; enabled: boolean }>,
|
|
});
|
|
|
|
// Initialize default Image config
|
|
const getDefaultImageConfig = () => ({
|
|
imageProviderId: 'seedream' as ImageProviderId,
|
|
imageModelId: 'doubao-seedream-5-0-260128',
|
|
imageProvidersConfig: {
|
|
seedream: { apiKey: '', baseUrl: '', enabled: false },
|
|
'openai-image': { apiKey: '', baseUrl: '', enabled: false },
|
|
'qwen-image': { apiKey: '', baseUrl: '', enabled: false },
|
|
'nano-banana': { apiKey: '', baseUrl: '', enabled: false },
|
|
'minimax-image': { apiKey: '', baseUrl: '', enabled: false },
|
|
'grok-image': { apiKey: '', baseUrl: '', enabled: false },
|
|
lemonade: { apiKey: '', baseUrl: '', enabled: false },
|
|
} as Record<ImageProviderId, { apiKey: string; baseUrl: string; enabled: boolean }>,
|
|
});
|
|
|
|
// Initialize default Video config
|
|
const getDefaultVideoConfig = () => ({
|
|
videoProviderId: 'seedance' as VideoProviderId,
|
|
videoModelId: 'doubao-seedance-1-5-pro-251215',
|
|
videoProvidersConfig: {
|
|
seedance: { apiKey: '', baseUrl: '', enabled: false },
|
|
kling: { apiKey: '', baseUrl: '', enabled: false },
|
|
veo: { apiKey: '', baseUrl: '', enabled: false },
|
|
sora: { apiKey: '', baseUrl: '', enabled: false },
|
|
'minimax-video': { apiKey: '', baseUrl: '', enabled: false },
|
|
'grok-video': { apiKey: '', baseUrl: '', enabled: false },
|
|
happyhorse: { apiKey: '', baseUrl: '', enabled: false },
|
|
} as Record<VideoProviderId, { apiKey: string; baseUrl: string; enabled: boolean }>,
|
|
});
|
|
|
|
// Initialize default Web Search config
|
|
const getDefaultWebSearchConfig = () => ({
|
|
webSearchProviderId: 'tavily' as WebSearchProviderId,
|
|
webSearchProvidersConfig: {
|
|
tavily: { apiKey: '', baseUrl: '', enabled: true, requiresApiKey: true },
|
|
bocha: { apiKey: '', baseUrl: '', enabled: true, requiresApiKey: true },
|
|
brave: {
|
|
apiKey: '',
|
|
baseUrl: WEB_SEARCH_PROVIDERS.brave.defaultBaseUrl || '',
|
|
enabled: true,
|
|
requiresApiKey: false,
|
|
},
|
|
baidu: { apiKey: '', baseUrl: '', enabled: true, requiresApiKey: true },
|
|
minimax: {
|
|
apiKey: '',
|
|
baseUrl: WEB_SEARCH_PROVIDERS.minimax.defaultBaseUrl || '',
|
|
enabled: true,
|
|
requiresApiKey: true,
|
|
},
|
|
} as Record<
|
|
WebSearchProviderId,
|
|
{ apiKey: string; baseUrl: string; enabled: boolean; requiresApiKey?: boolean }
|
|
>,
|
|
baiduSubSources: {
|
|
webSearch: true,
|
|
baike: true,
|
|
scholar: true,
|
|
} as BaiduSubSources,
|
|
});
|
|
|
|
/**
|
|
* Check whether a provider ID exists in the given provider registry.
|
|
*/
|
|
function hasProviderId(providerMap: Record<string, unknown>, providerId?: string): boolean {
|
|
return typeof providerId === 'string' && providerId in providerMap;
|
|
}
|
|
|
|
/**
|
|
* Validate all persisted provider IDs against their registries.
|
|
* Reset any stale / removed ID back to its default value.
|
|
* Called during both migrate and merge to cover all rehydration paths.
|
|
*/
|
|
function ensureValidProviderSelections(state: Partial<SettingsState>): void {
|
|
const defaultAudioConfig = getDefaultAudioConfig();
|
|
const defaultPdfConfig = getDefaultPDFConfig();
|
|
const defaultImageConfig = getDefaultImageConfig();
|
|
const defaultVideoConfig = getDefaultVideoConfig();
|
|
const defaultWebSearchConfig = getDefaultWebSearchConfig();
|
|
|
|
if (!hasProviderId(PDF_PROVIDERS, state.pdfProviderId)) {
|
|
state.pdfProviderId = defaultPdfConfig.pdfProviderId;
|
|
}
|
|
|
|
if (!hasProviderId(WEB_SEARCH_PROVIDERS, state.webSearchProviderId)) {
|
|
state.webSearchProviderId = defaultWebSearchConfig.webSearchProviderId;
|
|
}
|
|
ensureBaiduSubSources(state);
|
|
|
|
if (!hasProviderId(IMAGE_PROVIDERS, state.imageProviderId)) {
|
|
state.imageProviderId = defaultImageConfig.imageProviderId;
|
|
}
|
|
|
|
if (!hasProviderId(VIDEO_PROVIDERS, state.videoProviderId)) {
|
|
state.videoProviderId = defaultVideoConfig.videoProviderId;
|
|
}
|
|
|
|
if (
|
|
!hasProviderId(TTS_PROVIDERS, state.ttsProviderId) &&
|
|
!(
|
|
state.ttsProviderId &&
|
|
isCustomTTSProvider(state.ttsProviderId) &&
|
|
state.ttsProvidersConfig &&
|
|
state.ttsProviderId in state.ttsProvidersConfig
|
|
)
|
|
) {
|
|
state.ttsProviderId = defaultAudioConfig.ttsProviderId;
|
|
}
|
|
|
|
if (
|
|
!hasProviderId(ASR_PROVIDERS, state.asrProviderId) &&
|
|
!(
|
|
state.asrProviderId &&
|
|
isCustomASRProvider(state.asrProviderId) &&
|
|
state.asrProvidersConfig &&
|
|
state.asrProviderId in state.asrProvidersConfig
|
|
)
|
|
) {
|
|
state.asrProviderId = defaultAudioConfig.asrProviderId;
|
|
}
|
|
}
|
|
|
|
function ensureBuiltInAudioProviders(state: Partial<SettingsState>): void {
|
|
const defaultAudioConfig = getDefaultAudioConfig();
|
|
|
|
if (state.ttsProvidersConfig) {
|
|
for (const providerId of Object.keys(TTS_PROVIDERS) as BuiltInTTSProviderId[]) {
|
|
if (!state.ttsProvidersConfig[providerId]) {
|
|
state.ttsProvidersConfig[providerId] = defaultAudioConfig.ttsProvidersConfig[providerId];
|
|
}
|
|
}
|
|
const voxcpmConfig = state.ttsProvidersConfig['voxcpm-tts'];
|
|
if (voxcpmConfig) {
|
|
if (!voxcpmConfig.modelId || voxcpmConfig.modelId === VOXCPM_MODEL_ID) {
|
|
voxcpmConfig.modelId = VOXCPM_VLLM_MODEL_ID;
|
|
}
|
|
voxcpmConfig.providerOptions = {
|
|
backend: DEFAULT_VOXCPM_BACKEND,
|
|
...(voxcpmConfig.providerOptions || {}),
|
|
};
|
|
}
|
|
}
|
|
|
|
if (state.asrProvidersConfig) {
|
|
for (const providerId of Object.keys(ASR_PROVIDERS) as ASRProviderId[]) {
|
|
if (!state.asrProvidersConfig[providerId]) {
|
|
state.asrProvidersConfig[providerId] = defaultAudioConfig.asrProvidersConfig[providerId];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Ensure providersConfig includes all built-in providers and their latest models.
|
|
* Called on every rehydrate (not just version migrations) so new providers
|
|
* added in code are always picked up without clearing cache.
|
|
*/
|
|
function ensureBuiltInProviders(state: Partial<SettingsState>): void {
|
|
if (!state.providersConfig) return;
|
|
const defaultConfig = getDefaultProvidersConfig();
|
|
Object.keys(PROVIDERS).forEach((pid) => {
|
|
const providerId = pid as ProviderId;
|
|
if (!state.providersConfig![providerId]) {
|
|
// New provider: add with defaults
|
|
state.providersConfig![providerId] = defaultConfig[providerId];
|
|
} else {
|
|
// Existing provider: refresh built-in models from the registry and
|
|
// keep user-added models after the built-in list.
|
|
const provider = PROVIDERS[providerId];
|
|
const existing = state.providersConfig![providerId];
|
|
|
|
const builtInModelIds = new Set(provider.models.map((m) => m.id));
|
|
const customModels = (existing.models || []).filter((m) => !builtInModelIds.has(m.id));
|
|
const mergedModels = [...provider.models, ...customModels];
|
|
|
|
state.providersConfig![providerId] = {
|
|
...existing,
|
|
models: mergedModels,
|
|
name: existing.name || provider.name,
|
|
type: existing.type || provider.type,
|
|
defaultBaseUrl: existing.defaultBaseUrl || provider.defaultBaseUrl,
|
|
icon: provider.icon || existing.icon,
|
|
requiresApiKey: existing.requiresApiKey ?? provider.requiresApiKey,
|
|
isBuiltIn: existing.isBuiltIn ?? true,
|
|
};
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Custom providers created before #414 stored their actual endpoint in
|
|
* defaultBaseUrl while leaving baseUrl empty. Promote that persisted value
|
|
* during rehydrate so downstream request builders keep using baseUrl only.
|
|
*/
|
|
export function promoteLegacyCustomProviderBaseUrls(state: Partial<SettingsState>): void {
|
|
if (!state.providersConfig) return;
|
|
|
|
Object.values(state.providersConfig).forEach((config) => {
|
|
if (!config.isBuiltIn && !config.baseUrl && config.defaultBaseUrl) {
|
|
config.baseUrl = config.defaultBaseUrl;
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Ensure imageProvidersConfig includes all built-in image providers.
|
|
* Called on every rehydrate so newly added image providers appear automatically.
|
|
*/
|
|
function ensureBuiltInImageProviders(state: Partial<SettingsState>): void {
|
|
if (!state.imageProvidersConfig) return;
|
|
const defaultConfig = getDefaultImageConfig().imageProvidersConfig;
|
|
Object.keys(IMAGE_PROVIDERS).forEach((pid) => {
|
|
const providerId = pid as ImageProviderId;
|
|
if (!state.imageProvidersConfig![providerId]) {
|
|
state.imageProvidersConfig![providerId] = defaultConfig[providerId];
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Ensure videoProvidersConfig includes all built-in video providers.
|
|
* Called on every rehydrate so newly added video providers appear automatically.
|
|
*/
|
|
function ensureBuiltInVideoProviders(state: Partial<SettingsState>): void {
|
|
if (!state.videoProvidersConfig) return;
|
|
const defaultConfig = getDefaultVideoConfig().videoProvidersConfig;
|
|
Object.keys(VIDEO_PROVIDERS).forEach((pid) => {
|
|
const providerId = pid as VideoProviderId;
|
|
if (!state.videoProvidersConfig![providerId]) {
|
|
state.videoProvidersConfig![providerId] = defaultConfig[providerId];
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Ensure webSearchProvidersConfig includes all built-in web search providers.
|
|
* Called on every rehydrate so newly added providers appear automatically.
|
|
*/
|
|
function ensureBuiltInWebSearchProviders(state: Partial<SettingsState>): void {
|
|
if (!state.webSearchProvidersConfig) return;
|
|
const defaultConfig = getDefaultWebSearchConfig().webSearchProvidersConfig;
|
|
Object.keys(WEB_SEARCH_PROVIDERS).forEach((pid) => {
|
|
const providerId = pid as WebSearchProviderId;
|
|
if (!state.webSearchProvidersConfig![providerId]) {
|
|
state.webSearchProvidersConfig![providerId] = defaultConfig[providerId];
|
|
} else {
|
|
state.webSearchProvidersConfig![providerId] = {
|
|
...state.webSearchProvidersConfig![providerId],
|
|
requiresApiKey: WEB_SEARCH_PROVIDERS[providerId].requiresApiKey,
|
|
};
|
|
}
|
|
});
|
|
}
|
|
|
|
function ensureBaiduSubSources(state: Partial<SettingsState>): void {
|
|
const defaults = getDefaultWebSearchConfig().baiduSubSources;
|
|
const current = state.baiduSubSources;
|
|
state.baiduSubSources = {
|
|
webSearch: current?.webSearch ?? defaults.webSearch,
|
|
baike: current?.baike ?? defaults.baike,
|
|
scholar: current?.scholar ?? defaults.scholar,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Strip the removed `serverBaseUrl` field from any persisted provider config.
|
|
*
|
|
* Managed providers no longer expose their base URL to the client (#620). Old
|
|
* localStorage may still carry a `serverBaseUrl` on provider entries; this
|
|
* clears it on every rehydrate so a stale server URL can't linger in client
|
|
* state. Called from both migrate and merge to cover all rehydration paths.
|
|
*/
|
|
function stripLegacyServerBaseUrl(state: Partial<SettingsState>): void {
|
|
const maps = [
|
|
state.providersConfig,
|
|
state.ttsProvidersConfig,
|
|
state.asrProvidersConfig,
|
|
state.pdfProvidersConfig,
|
|
state.imageProvidersConfig,
|
|
state.videoProvidersConfig,
|
|
state.webSearchProvidersConfig,
|
|
];
|
|
for (const map of maps) {
|
|
if (!map) continue;
|
|
for (const cfg of Object.values(map as Record<string, Record<string, unknown>>)) {
|
|
if (cfg && 'serverBaseUrl' in cfg) delete cfg.serverBaseUrl;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Migrate from old localStorage format
|
|
const migrateFromOldStorage = () => {
|
|
if (typeof window === 'undefined') return null;
|
|
|
|
// Check if new storage already exists
|
|
const newStorage = localStorage.getItem('settings-storage');
|
|
if (newStorage) return null; // Already migrated or new install
|
|
|
|
// Read old localStorage keys
|
|
const oldLlmModel = localStorage.getItem('llmModel');
|
|
const oldProvidersConfig = localStorage.getItem('providersConfig');
|
|
const oldTtsModel = localStorage.getItem('ttsModel');
|
|
const oldSelectedAgents = localStorage.getItem('selectedAgentIds');
|
|
|
|
if (!oldLlmModel && !oldProvidersConfig) return null; // No old data
|
|
|
|
// Parse model selection
|
|
let providerId: ProviderId = 'openai';
|
|
let modelId = 'gpt-5.4-mini';
|
|
if (oldLlmModel) {
|
|
const [pid, mid] = oldLlmModel.split(':');
|
|
if (pid && mid) {
|
|
providerId = pid as ProviderId;
|
|
modelId = mid;
|
|
}
|
|
}
|
|
|
|
// Parse providers config
|
|
let providersConfig = getDefaultProvidersConfig();
|
|
if (oldProvidersConfig) {
|
|
try {
|
|
const parsed = JSON.parse(oldProvidersConfig);
|
|
providersConfig = { ...providersConfig, ...parsed };
|
|
} catch (e) {
|
|
log.error('Failed to parse old providersConfig:', e);
|
|
}
|
|
}
|
|
|
|
// Parse other settings
|
|
let ttsModel = 'openai-tts';
|
|
if (oldTtsModel) ttsModel = oldTtsModel;
|
|
|
|
let selectedAgentIds = ['default-1', 'default-2', 'default-3'];
|
|
if (oldSelectedAgents) {
|
|
try {
|
|
const parsed = JSON.parse(oldSelectedAgents);
|
|
if (Array.isArray(parsed) && parsed.length > 0) {
|
|
selectedAgentIds = parsed;
|
|
}
|
|
} catch (e) {
|
|
log.error('Failed to parse old selectedAgentIds:', e);
|
|
}
|
|
}
|
|
|
|
return {
|
|
providerId,
|
|
modelId,
|
|
thinkingConfigs: {},
|
|
providersConfig,
|
|
ttsModel,
|
|
selectedAgentIds,
|
|
};
|
|
};
|
|
|
|
export const useSettingsStore = create<SettingsState>()(
|
|
persist(
|
|
(set, get) => {
|
|
// Try to migrate from old storage
|
|
const migratedData = migrateFromOldStorage();
|
|
const defaultAudioConfig = getDefaultAudioConfig();
|
|
const defaultPDFConfig = getDefaultPDFConfig();
|
|
const defaultImageConfig = getDefaultImageConfig();
|
|
const defaultVideoConfig = getDefaultVideoConfig();
|
|
const defaultWebSearchConfig = getDefaultWebSearchConfig();
|
|
|
|
const initialProvidersConfig = migratedData?.providersConfig || getDefaultProvidersConfig();
|
|
|
|
return {
|
|
// Initial state (use migrated data if available)
|
|
providerId: migratedData?.providerId || 'openai',
|
|
modelId: migratedData?.modelId || '',
|
|
thinkingConfigs: pruneThinkingConfigs(
|
|
migratedData?.thinkingConfigs || {},
|
|
initialProvidersConfig,
|
|
),
|
|
providersConfig: initialProvidersConfig,
|
|
ttsModel: migratedData?.ttsModel || 'openai-tts',
|
|
selectedAgentIds: migratedData?.selectedAgentIds || ['default-1', 'default-2', 'default-3'],
|
|
agentMode: 'auto' as const,
|
|
autoAgentCount: 3,
|
|
agentVoiceOverrides: {},
|
|
agentSelectionIsUserSet: false,
|
|
|
|
// Playback controls
|
|
ttsMuted: false,
|
|
ttsVolume: 1,
|
|
autoPlayLecture: false,
|
|
playbackSpeed: 1,
|
|
|
|
// Layout preferences
|
|
sidebarCollapsed: true,
|
|
chatAreaCollapsed: true,
|
|
chatAreaWidth: 320,
|
|
editRailCollapsed: false,
|
|
editRailWidth: 220,
|
|
editInsertToolbarCollapsed: false,
|
|
|
|
// Audio settings (use defaults)
|
|
...defaultAudioConfig,
|
|
|
|
// PDF settings (use defaults)
|
|
...defaultPDFConfig,
|
|
|
|
// Image settings (use defaults)
|
|
...defaultImageConfig,
|
|
|
|
// Video settings (use defaults)
|
|
...defaultVideoConfig,
|
|
|
|
// Media generation toggles (off by default)
|
|
imageGenerationEnabled: false,
|
|
videoGenerationEnabled: false,
|
|
reviewOutlineEnabled: false,
|
|
|
|
// TTS is OFF by default; auto-enabled on first server-sync when a TTS
|
|
// provider is configured (mirrors image/video). Fresh installs with no
|
|
// provider stay off and show an "enable browser-native" CTA (#665).
|
|
ttsEnabled: false,
|
|
asrEnabled: true,
|
|
|
|
// Off until the server reports a concurrency via fetchServerProviders.
|
|
parallelSceneConcurrency: 0,
|
|
|
|
autoConfigApplied: false,
|
|
|
|
// Web Search settings (use defaults)
|
|
...defaultWebSearchConfig,
|
|
|
|
// Actions
|
|
setModel: (providerId, modelId) => set({ providerId, modelId }),
|
|
|
|
setThinkingConfig: (providerId, modelId, config) =>
|
|
set((state) => {
|
|
const key = getThinkingConfigKey(providerId, modelId);
|
|
const next = { ...state.thinkingConfigs };
|
|
if (config) {
|
|
next[key] = config;
|
|
} else {
|
|
delete next[key];
|
|
}
|
|
return { thinkingConfigs: next };
|
|
}),
|
|
|
|
setProviderConfig: (providerId, config) =>
|
|
set((state) => {
|
|
const providersConfig = {
|
|
...state.providersConfig,
|
|
[providerId]: {
|
|
...state.providersConfig[providerId],
|
|
...config,
|
|
},
|
|
};
|
|
// Re-resolve through the shared resolver (#580): a single config
|
|
// edit can make the active provider usable (adopt + pick a model),
|
|
// make it INVALID — e.g. the user clears its API key — (fall back
|
|
// to another usable provider or State A), or change its model list
|
|
// (re-pick the model). All handled atomically here, never leaving
|
|
// an invalid/stale (provider, model) selected.
|
|
const { providerId: nextProvider, modelId: nextModel } = resolveLLMSelection(
|
|
providersConfig,
|
|
state.providerId,
|
|
state.modelId,
|
|
);
|
|
return {
|
|
providersConfig,
|
|
thinkingConfigs: pruneThinkingConfigs(state.thinkingConfigs, providersConfig),
|
|
...(nextProvider !== state.providerId && { providerId: nextProvider }),
|
|
...(nextModel !== state.modelId && { modelId: nextModel }),
|
|
};
|
|
}),
|
|
|
|
setProvidersConfig: (config) =>
|
|
set((state) => {
|
|
// Bulk config replace (delete provider/model, import, reset): same
|
|
// shared resolver as setProviderConfig so the two paths can never
|
|
// diverge — never leave the deleted/invalid provider selected.
|
|
const { providerId: nextProvider, modelId: nextModel } = resolveLLMSelection(
|
|
config,
|
|
state.providerId,
|
|
state.modelId,
|
|
);
|
|
return {
|
|
providersConfig: config,
|
|
thinkingConfigs: pruneThinkingConfigs(state.thinkingConfigs, config),
|
|
...(nextProvider !== state.providerId && { providerId: nextProvider }),
|
|
...(nextModel !== state.modelId && { modelId: nextModel }),
|
|
};
|
|
}),
|
|
|
|
setTtsModel: (model) => set({ ttsModel: model }),
|
|
|
|
setTTSMuted: (muted) => set({ ttsMuted: muted }),
|
|
|
|
setTTSVolume: (volume) => set({ ttsVolume: Math.max(0, Math.min(1, volume)) }),
|
|
|
|
setAutoPlayLecture: (autoPlay) => set({ autoPlayLecture: autoPlay }),
|
|
|
|
setPlaybackSpeed: (speed) => set({ playbackSpeed: speed }),
|
|
|
|
setSelectedAgentIds: (ids) => set({ selectedAgentIds: ids }),
|
|
|
|
setAgentMode: (mode) => set({ agentMode: mode }),
|
|
setAutoAgentCount: (count) => set({ autoAgentCount: count }),
|
|
setAgentVoiceOverride: (agentId, voice) =>
|
|
set((state) => {
|
|
const next = { ...state.agentVoiceOverrides };
|
|
if (voice) {
|
|
next[agentId] = voice;
|
|
} else {
|
|
delete next[agentId];
|
|
}
|
|
return { agentVoiceOverrides: next };
|
|
}),
|
|
setAgentSelectionIsUserSet: (isUserSet) => set({ agentSelectionIsUserSet: isUserSet }),
|
|
|
|
// Layout actions
|
|
setSidebarCollapsed: (collapsed) => set({ sidebarCollapsed: collapsed }),
|
|
setChatAreaCollapsed: (collapsed) => set({ chatAreaCollapsed: collapsed }),
|
|
setEditRailCollapsed: (collapsed) => set({ editRailCollapsed: collapsed }),
|
|
setEditRailWidth: (width) => set({ editRailWidth: width }),
|
|
setEditInsertToolbarCollapsed: (collapsed) =>
|
|
set({ editInsertToolbarCollapsed: collapsed }),
|
|
setChatAreaWidth: (width) => set({ chatAreaWidth: width }),
|
|
|
|
// Audio actions
|
|
setTTSProvider: (providerId) =>
|
|
set((state) => {
|
|
// If switching provider, set default voice for that provider
|
|
const shouldUpdateVoice = state.ttsProviderId !== providerId;
|
|
const defaultVoice = isCustomTTSProvider(providerId)
|
|
? state.ttsProvidersConfig[providerId]?.customVoices?.[0]?.id || 'default'
|
|
: DEFAULT_TTS_VOICES[providerId as BuiltInTTSProviderId] || 'default';
|
|
return {
|
|
ttsProviderId: providerId,
|
|
...(shouldUpdateVoice && { ttsVoice: defaultVoice }),
|
|
};
|
|
}),
|
|
|
|
setTTSVoice: (voice) => set({ ttsVoice: voice }),
|
|
|
|
setTTSSpeed: (speed) => set({ ttsSpeed: speed }),
|
|
|
|
// Reset language when switching providers, since language code formats differ
|
|
// (e.g. browser-native uses BCP-47 "en-US", OpenAI Whisper uses ISO 639-1 "en")
|
|
setASRProvider: (providerId) =>
|
|
set((state) => {
|
|
let supportedLanguages: string[];
|
|
if (isCustomASRProvider(providerId)) {
|
|
supportedLanguages = ['auto'];
|
|
} else {
|
|
supportedLanguages =
|
|
ASR_PROVIDERS[providerId as keyof typeof ASR_PROVIDERS]?.supportedLanguages || [];
|
|
}
|
|
const isLanguageValid = supportedLanguages.includes(state.asrLanguage);
|
|
return {
|
|
asrProviderId: providerId,
|
|
...(isLanguageValid ? {} : { asrLanguage: supportedLanguages[0] || 'auto' }),
|
|
};
|
|
}),
|
|
|
|
setASRLanguage: (language) => set({ asrLanguage: language }),
|
|
|
|
setTTSProviderConfig: (providerId, config) =>
|
|
set((state) => ({
|
|
ttsProvidersConfig: {
|
|
...state.ttsProvidersConfig,
|
|
[providerId]: {
|
|
...state.ttsProvidersConfig[providerId],
|
|
...config,
|
|
},
|
|
},
|
|
})),
|
|
|
|
setASRProviderConfig: (providerId, config) =>
|
|
set((state) => ({
|
|
asrProvidersConfig: {
|
|
...state.asrProvidersConfig,
|
|
[providerId]: {
|
|
...state.asrProvidersConfig[providerId],
|
|
...config,
|
|
},
|
|
},
|
|
})),
|
|
|
|
// PDF actions
|
|
setPDFProvider: (providerId) => set({ pdfProviderId: providerId }),
|
|
|
|
setPDFProviderConfig: (providerId, config) =>
|
|
set((state) => ({
|
|
pdfProvidersConfig: {
|
|
...state.pdfProvidersConfig,
|
|
[providerId]: {
|
|
...state.pdfProvidersConfig[providerId],
|
|
...config,
|
|
},
|
|
},
|
|
})),
|
|
|
|
// Image Generation actions
|
|
setImageProvider: (providerId) =>
|
|
set((state) => ({
|
|
imageProviderId: providerId,
|
|
imageModelId: resolveSelectedModel(
|
|
state.imageModelId,
|
|
IMAGE_PROVIDERS[providerId]?.models ?? [],
|
|
),
|
|
})),
|
|
setImageModelId: (modelId) => set({ imageModelId: modelId }),
|
|
|
|
setImageProviderConfig: (providerId, config) =>
|
|
set((state) => {
|
|
const mergedProvider = {
|
|
...state.imageProvidersConfig[providerId],
|
|
...config,
|
|
};
|
|
const imageProvidersConfig = {
|
|
...state.imageProvidersConfig,
|
|
[providerId]: mergedProvider,
|
|
};
|
|
const base = { imageProvidersConfig };
|
|
// Atomic invariant (#580): a config edit on the active image
|
|
// provider (e.g. deleting the selected custom model) must not
|
|
// leave imageModelId pointing at a model that no longer exists.
|
|
if (state.imageProviderId === providerId) {
|
|
const models = [
|
|
...(IMAGE_PROVIDERS[providerId]?.models ?? []),
|
|
...(mergedProvider.customModels ?? []),
|
|
];
|
|
const imageModelId = resolveSelectedModel(state.imageModelId, models);
|
|
if (imageModelId) {
|
|
return { ...base, imageModelId };
|
|
}
|
|
}
|
|
return base;
|
|
}),
|
|
|
|
// Video Generation actions
|
|
setVideoProvider: (providerId) =>
|
|
set((state) => ({
|
|
videoProviderId: providerId,
|
|
videoModelId: resolveSelectedModel(
|
|
state.videoModelId,
|
|
VIDEO_PROVIDERS[providerId]?.models ?? [],
|
|
),
|
|
})),
|
|
setVideoModelId: (modelId) => set({ videoModelId: modelId }),
|
|
|
|
setVideoProviderConfig: (providerId, config) =>
|
|
set((state) => {
|
|
const mergedProvider = {
|
|
...state.videoProvidersConfig[providerId],
|
|
...config,
|
|
};
|
|
const videoProvidersConfig = {
|
|
...state.videoProvidersConfig,
|
|
[providerId]: mergedProvider,
|
|
};
|
|
const base = { videoProvidersConfig };
|
|
// Atomic invariant (#580): symmetric with image — a config edit on
|
|
// the active video provider must not leave videoModelId stale.
|
|
if (state.videoProviderId === providerId) {
|
|
const models = [
|
|
...(VIDEO_PROVIDERS[providerId]?.models ?? []),
|
|
...(mergedProvider.customModels ?? []),
|
|
];
|
|
const videoModelId = resolveSelectedModel(state.videoModelId, models);
|
|
if (videoModelId) {
|
|
return { ...base, videoModelId };
|
|
}
|
|
}
|
|
return base;
|
|
}),
|
|
|
|
// Media generation toggle actions
|
|
setImageGenerationEnabled: (enabled) => {
|
|
if (enabled) {
|
|
const cfg = get().imageProvidersConfig;
|
|
const hasUsable = Object.values(cfg).some((c) => c.isServerConfigured || c.apiKey);
|
|
if (!hasUsable) return;
|
|
}
|
|
set({ imageGenerationEnabled: enabled });
|
|
},
|
|
setVideoGenerationEnabled: (enabled) => {
|
|
if (enabled) {
|
|
const cfg = get().videoProvidersConfig;
|
|
const hasUsable = Object.values(cfg).some((c) => c.isServerConfigured || c.apiKey);
|
|
if (!hasUsable) return;
|
|
}
|
|
set({ videoGenerationEnabled: enabled });
|
|
},
|
|
setReviewOutlineEnabled: (enabled) => set({ reviewOutlineEnabled: enabled }),
|
|
setTTSEnabled: (enabled) => set({ ttsEnabled: enabled }),
|
|
setASREnabled: (enabled) => set({ asrEnabled: enabled }),
|
|
|
|
// Custom audio provider actions
|
|
addCustomTTSProvider: (id, name, baseUrl, requiresApiKey, defaultModel) =>
|
|
set((state) => ({
|
|
ttsProvidersConfig: {
|
|
...state.ttsProvidersConfig,
|
|
[id]: {
|
|
apiKey: '',
|
|
baseUrl: '',
|
|
enabled: true,
|
|
modelId: defaultModel || '',
|
|
customName: name,
|
|
customDefaultBaseUrl: baseUrl,
|
|
customVoices: [],
|
|
isBuiltIn: false,
|
|
requiresApiKey,
|
|
},
|
|
},
|
|
ttsProviderId: id,
|
|
})),
|
|
|
|
removeCustomTTSProvider: (id) =>
|
|
set((state) => {
|
|
if (!isCustomTTSProvider(id)) return state;
|
|
const { [id]: _, ...rest } = state.ttsProvidersConfig;
|
|
return {
|
|
ttsProvidersConfig: rest as typeof state.ttsProvidersConfig,
|
|
...(state.ttsProviderId === id && {
|
|
ttsProviderId: 'browser-native-tts' as TTSProviderId,
|
|
ttsVoice: 'default',
|
|
}),
|
|
};
|
|
}),
|
|
|
|
addCustomASRProvider: (id, name, baseUrl, requiresApiKey) =>
|
|
set((state) => ({
|
|
asrProvidersConfig: {
|
|
...state.asrProvidersConfig,
|
|
[id]: {
|
|
apiKey: '',
|
|
baseUrl: '',
|
|
enabled: true,
|
|
modelId: '',
|
|
customModels: [],
|
|
customName: name,
|
|
customDefaultBaseUrl: baseUrl,
|
|
isBuiltIn: false,
|
|
requiresApiKey,
|
|
},
|
|
},
|
|
asrProviderId: id,
|
|
})),
|
|
|
|
removeCustomASRProvider: (id) =>
|
|
set((state) => {
|
|
if (!isCustomASRProvider(id)) return state;
|
|
const { [id]: _, ...rest } = state.asrProvidersConfig;
|
|
return {
|
|
asrProvidersConfig: rest as typeof state.asrProvidersConfig,
|
|
...(state.asrProviderId === id && {
|
|
asrProviderId: 'browser-native' as ASRProviderId,
|
|
asrLanguage: 'zh',
|
|
}),
|
|
};
|
|
}),
|
|
|
|
// Web Search actions
|
|
setWebSearchProvider: (providerId) => set({ webSearchProviderId: providerId }),
|
|
setWebSearchProviderConfig: (providerId, config) =>
|
|
set((state) => ({
|
|
webSearchProvidersConfig: {
|
|
...state.webSearchProvidersConfig,
|
|
[providerId]: {
|
|
...state.webSearchProvidersConfig[providerId],
|
|
...config,
|
|
},
|
|
},
|
|
})),
|
|
setBaiduSubSources: (sources) =>
|
|
set((state) => {
|
|
const next = {
|
|
...state.baiduSubSources,
|
|
...sources,
|
|
};
|
|
if (!next.webSearch && !next.baike && !next.scholar) {
|
|
return state;
|
|
}
|
|
return { baiduSubSources: next };
|
|
}),
|
|
|
|
// Fetch server-configured providers and merge into local state
|
|
fetchServerProviders: async () => {
|
|
try {
|
|
const res = await fetch('/api/server-providers');
|
|
if (!res.ok) return;
|
|
// Managed providers expose only their allowed model list (LLM/image)
|
|
// and presence (the "managed" flag) — never a base URL.
|
|
const data = (await res.json()) as {
|
|
providers: Record<string, { models?: string[] }>;
|
|
// TTS additionally carries an optional `disabled` flag for
|
|
// admin/server-level force-off (#665).
|
|
tts: Record<string, { disabled?: boolean }>;
|
|
asr: Record<string, Record<string, never>>;
|
|
pdf: Record<string, Record<string, never>>;
|
|
image: Record<string, { models?: string[] }>;
|
|
video: Record<string, Record<string, never>>;
|
|
webSearch: Record<string, Record<string, never>>;
|
|
generation?: { parallelSceneConcurrency?: number };
|
|
};
|
|
|
|
set((state) => {
|
|
// Merge LLM providers
|
|
const newProvidersConfig = { ...state.providersConfig };
|
|
// First reset all server flags
|
|
for (const pid of Object.keys(newProvidersConfig)) {
|
|
const key = pid as ProviderId;
|
|
if (newProvidersConfig[key]) {
|
|
newProvidersConfig[key] = {
|
|
...newProvidersConfig[key],
|
|
isServerConfigured: false,
|
|
serverModels: undefined,
|
|
};
|
|
}
|
|
}
|
|
// Set flags for server-configured providers
|
|
for (const [pid, info] of Object.entries(data.providers)) {
|
|
const key = pid as ProviderId;
|
|
if (newProvidersConfig[key]) {
|
|
const currentModels = newProvidersConfig[key].models;
|
|
// When server specifies allowed models, filter the models list
|
|
// while preserving custom IDs from env/YAML in server order.
|
|
const currentModelMap = new Map(currentModels.map((m) => [m.id, m]));
|
|
const filteredModels = info.models?.length
|
|
? info.models.map((id) => currentModelMap.get(id) ?? { id, name: id })
|
|
: currentModels;
|
|
newProvidersConfig[key] = {
|
|
...newProvidersConfig[key],
|
|
isServerConfigured: true,
|
|
serverModels: info.models,
|
|
models: filteredModels,
|
|
};
|
|
}
|
|
}
|
|
|
|
// Merge TTS providers. Reset both server flags first, then apply:
|
|
// an entry with `disabled` is force-off (server precedence) and is
|
|
// NOT treated as managed/configured; any other entry is managed.
|
|
const newTTSConfig = { ...state.ttsProvidersConfig };
|
|
for (const pid of Object.keys(newTTSConfig)) {
|
|
const key = pid as TTSProviderId;
|
|
if (newTTSConfig[key]) {
|
|
newTTSConfig[key] = {
|
|
...newTTSConfig[key],
|
|
isServerConfigured: false,
|
|
serverDisabled: false,
|
|
};
|
|
}
|
|
}
|
|
for (const [pid, info] of Object.entries(data.tts)) {
|
|
const key = pid as TTSProviderId;
|
|
if (newTTSConfig[key]) {
|
|
newTTSConfig[key] = {
|
|
...newTTSConfig[key],
|
|
isServerConfigured: !info.disabled,
|
|
serverDisabled: info.disabled === true,
|
|
};
|
|
}
|
|
}
|
|
|
|
// Merge ASR providers
|
|
const newASRConfig = { ...state.asrProvidersConfig };
|
|
for (const pid of Object.keys(newASRConfig)) {
|
|
const key = pid as ASRProviderId;
|
|
if (newASRConfig[key]) {
|
|
newASRConfig[key] = {
|
|
...newASRConfig[key],
|
|
isServerConfigured: false,
|
|
};
|
|
}
|
|
}
|
|
for (const pid of Object.keys(data.asr)) {
|
|
const key = pid as ASRProviderId;
|
|
if (newASRConfig[key]) {
|
|
newASRConfig[key] = {
|
|
...newASRConfig[key],
|
|
isServerConfigured: true,
|
|
};
|
|
}
|
|
}
|
|
|
|
// Merge PDF providers
|
|
const newPDFConfig = { ...state.pdfProvidersConfig };
|
|
for (const pid of Object.keys(newPDFConfig)) {
|
|
const key = pid as PDFProviderId;
|
|
if (newPDFConfig[key]) {
|
|
newPDFConfig[key] = {
|
|
...newPDFConfig[key],
|
|
isServerConfigured: false,
|
|
};
|
|
}
|
|
}
|
|
for (const pid of Object.keys(data.pdf)) {
|
|
const key = pid as PDFProviderId;
|
|
if (newPDFConfig[key]) {
|
|
newPDFConfig[key] = {
|
|
...newPDFConfig[key],
|
|
isServerConfigured: true,
|
|
};
|
|
}
|
|
}
|
|
|
|
// Merge Image providers
|
|
const newImageConfig = { ...state.imageProvidersConfig };
|
|
for (const pid of Object.keys(newImageConfig)) {
|
|
const key = pid as ImageProviderId;
|
|
if (newImageConfig[key]) {
|
|
newImageConfig[key] = {
|
|
...newImageConfig[key],
|
|
isServerConfigured: false,
|
|
};
|
|
}
|
|
}
|
|
for (const pid of Object.keys(data.image)) {
|
|
const key = pid as ImageProviderId;
|
|
if (newImageConfig[key]) {
|
|
newImageConfig[key] = {
|
|
...newImageConfig[key],
|
|
isServerConfigured: true,
|
|
};
|
|
}
|
|
}
|
|
|
|
// Merge Video providers
|
|
const newVideoConfig = { ...state.videoProvidersConfig };
|
|
for (const pid of Object.keys(newVideoConfig)) {
|
|
const key = pid as VideoProviderId;
|
|
if (newVideoConfig[key]) {
|
|
newVideoConfig[key] = {
|
|
...newVideoConfig[key],
|
|
isServerConfigured: false,
|
|
};
|
|
}
|
|
}
|
|
if (data.video) {
|
|
for (const pid of Object.keys(data.video)) {
|
|
const key = pid as VideoProviderId;
|
|
if (newVideoConfig[key]) {
|
|
newVideoConfig[key] = {
|
|
...newVideoConfig[key],
|
|
isServerConfigured: true,
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
// Merge Web Search config — reset all first, then mark server-configured
|
|
const newWebSearchConfig = { ...state.webSearchProvidersConfig };
|
|
for (const key of Object.keys(newWebSearchConfig) as WebSearchProviderId[]) {
|
|
newWebSearchConfig[key] = {
|
|
...newWebSearchConfig[key],
|
|
isServerConfigured: false,
|
|
};
|
|
}
|
|
if (data.webSearch) {
|
|
for (const pid of Object.keys(data.webSearch)) {
|
|
const key = pid as WebSearchProviderId;
|
|
if (newWebSearchConfig[key]) {
|
|
newWebSearchConfig[key] = {
|
|
...newWebSearchConfig[key],
|
|
isServerConfigured: true,
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
// === Validate current selections against updated configs ===
|
|
// Build fallback: server-configured first, then client-key-only
|
|
const buildFallback = <T extends string>(
|
|
config: Record<
|
|
string,
|
|
{ isServerConfigured?: boolean; apiKey?: string; serverDisabled?: boolean }
|
|
>,
|
|
): T[] => [
|
|
// Server-disabled providers (TTS only) are never fallback targets.
|
|
...Object.entries(config)
|
|
.filter(([, c]) => c.isServerConfigured && !c.serverDisabled)
|
|
.map(([id]) => id as T),
|
|
...Object.entries(config)
|
|
.filter(([, c]) => !c.isServerConfigured && !c.serverDisabled && !!c.apiKey)
|
|
.map(([id]) => id as T),
|
|
];
|
|
|
|
const llmFallback = buildFallback<ProviderId>(newProvidersConfig);
|
|
const ttsFallback = buildFallback<TTSProviderId>(newTTSConfig);
|
|
const asrFallback = buildFallback<ASRProviderId>(newASRConfig);
|
|
const pdfFallback = buildFallback<PDFProviderId>(newPDFConfig);
|
|
const imageFallback = buildFallback<ImageProviderId>(newImageConfig);
|
|
const videoFallback = buildFallback<VideoProviderId>(newVideoConfig);
|
|
const webSearchFallback = buildFallback<WebSearchProviderId>(newWebSearchConfig);
|
|
|
|
let validLLMProvider = validateProvider(
|
|
state.providerId,
|
|
newProvidersConfig,
|
|
llmFallback,
|
|
);
|
|
const validTTSProvider = validateProvider(
|
|
state.ttsProviderId,
|
|
newTTSConfig,
|
|
ttsFallback,
|
|
'browser-native-tts' as TTSProviderId,
|
|
);
|
|
const validASRProvider = validateProvider(
|
|
state.asrProviderId,
|
|
newASRConfig,
|
|
asrFallback,
|
|
'browser-native' as ASRProviderId,
|
|
);
|
|
const validPDFProvider = validateProvider(
|
|
state.pdfProviderId,
|
|
newPDFConfig,
|
|
pdfFallback,
|
|
'unpdf' as PDFProviderId,
|
|
);
|
|
let validImageProvider = validateProvider(
|
|
state.imageProviderId,
|
|
newImageConfig,
|
|
imageFallback,
|
|
);
|
|
let validVideoProvider = validateProvider(
|
|
state.videoProviderId,
|
|
newVideoConfig,
|
|
videoFallback,
|
|
);
|
|
const validWebSearchProvider = validateProvider(
|
|
state.webSearchProviderId,
|
|
newWebSearchConfig,
|
|
webSearchFallback,
|
|
'tavily' as WebSearchProviderId,
|
|
);
|
|
|
|
// Auto-recover: when the selected provider is empty/unusable but
|
|
// a usable one exists, adopt the first usable fallback. Applied
|
|
// symmetrically to LLM/image/video so that "usable provider ⇒ a
|
|
// concrete model is selected" holds for every modality (#580).
|
|
if (!validLLMProvider && llmFallback.length > 0) {
|
|
validLLMProvider = llmFallback[0];
|
|
}
|
|
if (!validImageProvider && imageFallback.length > 0) {
|
|
validImageProvider = imageFallback[0];
|
|
}
|
|
if (!validVideoProvider && videoFallback.length > 0) {
|
|
validVideoProvider = videoFallback[0];
|
|
}
|
|
|
|
// Resolve the model in the same place the provider is resolved.
|
|
// resolveSelectedModel never yields '' when the provider has ≥1
|
|
// model, so a usable provider can never settle with an empty model.
|
|
const llmModels = validLLMProvider
|
|
? (newProvidersConfig[validLLMProvider as ProviderId]?.models ?? [])
|
|
: [];
|
|
const validLLMModel = validLLMProvider
|
|
? resolveSelectedModel(state.modelId, llmModels)
|
|
: '';
|
|
const imageModels =
|
|
IMAGE_PROVIDERS[validImageProvider as ImageProviderId]?.models ?? [];
|
|
const validImageModel = validImageProvider
|
|
? resolveSelectedModel(state.imageModelId, imageModels)
|
|
: '';
|
|
const videoModels =
|
|
VIDEO_PROVIDERS[validVideoProvider as VideoProviderId]?.models ?? [];
|
|
const validVideoModel = validVideoProvider
|
|
? resolveSelectedModel(state.videoModelId, videoModels)
|
|
: '';
|
|
|
|
const validTTSVoice =
|
|
validTTSProvider !== state.ttsProviderId
|
|
? DEFAULT_TTS_VOICES[validTTSProvider as BuiltInTTSProviderId] || 'default'
|
|
: state.ttsVoice;
|
|
|
|
// Auto-disable image/video generation when no provider is usable
|
|
const shouldDisableImage = !validImageProvider && state.imageGenerationEnabled;
|
|
const shouldDisableVideo = !validVideoProvider && state.videoGenerationEnabled;
|
|
|
|
// === Auto-select / auto-enable (only on first run) ===
|
|
let autoTtsProvider: TTSProviderId | undefined;
|
|
let autoTtsVoice: string | undefined;
|
|
let autoAsrProvider: ASRProviderId | undefined;
|
|
let autoPdfProvider: PDFProviderId | undefined;
|
|
let autoImageProvider: ImageProviderId | undefined;
|
|
let autoImageModel: string | undefined;
|
|
let autoVideoProvider: VideoProviderId | undefined;
|
|
let autoVideoModel: string | undefined;
|
|
let autoImageEnabled: boolean | undefined;
|
|
let autoVideoEnabled: boolean | undefined;
|
|
let autoTtsEnabled: boolean | undefined;
|
|
|
|
if (!state.autoConfigApplied) {
|
|
// PDF: unpdf → mineru-cloud or mineru if server has it
|
|
if (state.pdfProviderId === 'unpdf') {
|
|
if (newPDFConfig['mineru-cloud']?.isServerConfigured) {
|
|
autoPdfProvider = 'mineru-cloud' as PDFProviderId;
|
|
} else if (newPDFConfig.mineru?.isServerConfigured) {
|
|
autoPdfProvider = 'mineru' as PDFProviderId;
|
|
}
|
|
}
|
|
|
|
// TTS: select first server provider if current is not server-configured.
|
|
// Skip server-disabled entries — they are force-off, not selectable.
|
|
const serverTtsIds = Object.entries(data.tts)
|
|
.filter(([, info]) => !info.disabled)
|
|
.map(([id]) => id) as TTSProviderId[];
|
|
if (
|
|
serverTtsIds.length > 0 &&
|
|
!newTTSConfig[state.ttsProviderId]?.isServerConfigured
|
|
) {
|
|
autoTtsProvider = serverTtsIds[0];
|
|
autoTtsVoice =
|
|
DEFAULT_TTS_VOICES[autoTtsProvider as BuiltInTTSProviderId] || 'default';
|
|
}
|
|
// Auto-enable TTS on first run when a server provider exists
|
|
// (mirrors image/video). No provider ⇒ stays off + CTA.
|
|
if (serverTtsIds.length > 0 && !state.ttsEnabled) {
|
|
autoTtsEnabled = true;
|
|
}
|
|
|
|
// ASR: select first server provider if current is not server-configured
|
|
const serverAsrIds = Object.keys(data.asr) as ASRProviderId[];
|
|
if (
|
|
serverAsrIds.length > 0 &&
|
|
!newASRConfig[state.asrProviderId]?.isServerConfigured
|
|
) {
|
|
autoAsrProvider = serverAsrIds[0];
|
|
}
|
|
|
|
// Image: first server provider
|
|
const serverImageIds = Object.keys(data.image) as ImageProviderId[];
|
|
if (
|
|
serverImageIds.length > 0 &&
|
|
!newImageConfig[state.imageProviderId]?.isServerConfigured
|
|
) {
|
|
autoImageProvider = serverImageIds[0];
|
|
const models = IMAGE_PROVIDERS[autoImageProvider]?.models;
|
|
if (models?.length) autoImageModel = models[0].id;
|
|
}
|
|
if (serverImageIds.length > 0 && !state.imageGenerationEnabled) {
|
|
autoImageEnabled = true;
|
|
}
|
|
|
|
// Video: first server provider
|
|
const serverVideoIds = Object.keys(data.video || {}) as VideoProviderId[];
|
|
if (
|
|
serverVideoIds.length > 0 &&
|
|
!newVideoConfig[state.videoProviderId]?.isServerConfigured
|
|
) {
|
|
autoVideoProvider = serverVideoIds[0];
|
|
const models = VIDEO_PROVIDERS[autoVideoProvider]?.models;
|
|
if (models?.length) autoVideoModel = models[0].id;
|
|
}
|
|
if (serverVideoIds.length > 0 && !state.videoGenerationEnabled) {
|
|
autoVideoEnabled = true;
|
|
}
|
|
}
|
|
|
|
// (LLM first-load auto-select removed: the symmetric provider
|
|
// recovery + resolveSelectedModel above now resolve LLM provider
|
|
// and model atomically at the source, covering server-configured
|
|
// AND client-API-key providers — see #580.)
|
|
|
|
return {
|
|
providersConfig: newProvidersConfig,
|
|
ttsProvidersConfig: newTTSConfig,
|
|
asrProvidersConfig: newASRConfig,
|
|
pdfProvidersConfig: newPDFConfig,
|
|
imageProvidersConfig: newImageConfig,
|
|
videoProvidersConfig: newVideoConfig,
|
|
webSearchProvidersConfig: newWebSearchConfig,
|
|
// Already clamped server-side (getParallelSceneConcurrency); this
|
|
// re-clamp is intentional belt-and-suspenders against a malformed
|
|
// response. The consumer (use-scene-generator) clamps once more.
|
|
parallelSceneConcurrency: Math.max(
|
|
0,
|
|
Math.floor(data.generation?.parallelSceneConcurrency ?? 0),
|
|
),
|
|
autoConfigApplied: true,
|
|
// Validated selections
|
|
...(validLLMProvider !== state.providerId && {
|
|
providerId: validLLMProvider as ProviderId,
|
|
}),
|
|
...(validLLMModel !== state.modelId && { modelId: validLLMModel }),
|
|
...(validTTSProvider !== state.ttsProviderId && {
|
|
ttsProviderId: validTTSProvider as TTSProviderId,
|
|
ttsVoice: validTTSVoice,
|
|
}),
|
|
...(validASRProvider !== state.asrProviderId && {
|
|
asrProviderId: validASRProvider as ASRProviderId,
|
|
}),
|
|
...(validPDFProvider !== state.pdfProviderId && {
|
|
pdfProviderId: validPDFProvider as PDFProviderId,
|
|
}),
|
|
...(validWebSearchProvider !== state.webSearchProviderId && {
|
|
webSearchProviderId: validWebSearchProvider as WebSearchProviderId,
|
|
}),
|
|
...(validImageProvider !== state.imageProviderId && {
|
|
imageProviderId: validImageProvider as ImageProviderId,
|
|
}),
|
|
...(validImageModel !== state.imageModelId && {
|
|
imageModelId: validImageModel,
|
|
}),
|
|
...(validVideoProvider !== state.videoProviderId && {
|
|
videoProviderId: validVideoProvider as VideoProviderId,
|
|
}),
|
|
...(validVideoModel !== state.videoModelId && {
|
|
videoModelId: validVideoModel,
|
|
}),
|
|
...(shouldDisableImage && { imageGenerationEnabled: false }),
|
|
...(shouldDisableVideo && { videoGenerationEnabled: false }),
|
|
// First-run auto-select overrides validation (autoConfigApplied guard).
|
|
// On first sync, auto-select picks the best provider. On subsequent syncs,
|
|
// auto* variables stay undefined so only validation spreads take effect.
|
|
...(autoPdfProvider && { pdfProviderId: autoPdfProvider }),
|
|
...(autoTtsProvider && {
|
|
ttsProviderId: autoTtsProvider,
|
|
ttsVoice: autoTtsVoice,
|
|
}),
|
|
...(autoAsrProvider && { asrProviderId: autoAsrProvider }),
|
|
...(autoImageProvider && {
|
|
imageProviderId: autoImageProvider,
|
|
}),
|
|
...(autoImageModel && { imageModelId: autoImageModel }),
|
|
...(autoVideoProvider && {
|
|
videoProviderId: autoVideoProvider,
|
|
}),
|
|
...(autoVideoModel && { videoModelId: autoVideoModel }),
|
|
...(autoImageEnabled !== undefined && {
|
|
imageGenerationEnabled: autoImageEnabled,
|
|
}),
|
|
...(autoVideoEnabled !== undefined && {
|
|
videoGenerationEnabled: autoVideoEnabled,
|
|
}),
|
|
...(autoTtsEnabled !== undefined && { ttsEnabled: autoTtsEnabled }),
|
|
};
|
|
});
|
|
} catch (e) {
|
|
// Silently fail — server providers are optional
|
|
log.warn('Failed to fetch server providers:', e);
|
|
}
|
|
},
|
|
};
|
|
},
|
|
{
|
|
name: 'settings-storage',
|
|
version: 4,
|
|
// Migrate persisted state
|
|
migrate: (persistedState: unknown, version: number) => {
|
|
const state = persistedState as Partial<SettingsState>;
|
|
|
|
// v0 → v1: clear hardcoded default model so user must actively select
|
|
if (version === 0) {
|
|
if (state.providerId === 'openai' && state.modelId === 'gpt-4o-mini') {
|
|
state.modelId = '';
|
|
}
|
|
}
|
|
|
|
// Ensure providersConfig has all built-in providers (also in merge below)
|
|
ensureBuiltInProviders(state);
|
|
promoteLegacyCustomProviderBaseUrls(state);
|
|
|
|
// Ensure image/video configs have all built-in providers
|
|
ensureBuiltInImageProviders(state);
|
|
ensureBuiltInVideoProviders(state);
|
|
|
|
// Migrate from old ttsModel to new ttsProviderId
|
|
if (state.ttsModel && !state.ttsProviderId) {
|
|
// Map old ttsModel values to new ttsProviderId
|
|
if (state.ttsModel === 'openai-tts') {
|
|
state.ttsProviderId = 'openai-tts';
|
|
} else if (state.ttsModel === 'azure-tts') {
|
|
state.ttsProviderId = 'azure-tts';
|
|
} else {
|
|
// Default to OpenAI
|
|
state.ttsProviderId = 'openai-tts';
|
|
}
|
|
}
|
|
|
|
// Add default audio config if missing
|
|
if (!state.ttsProvidersConfig || !state.asrProvidersConfig) {
|
|
const defaultAudioConfig = getDefaultAudioConfig();
|
|
Object.assign(state, defaultAudioConfig);
|
|
}
|
|
ensureBuiltInAudioProviders(state);
|
|
ensureBuiltInWebSearchProviders(state);
|
|
|
|
// Migrate global ttsModelId to per-provider
|
|
if ((state as Record<string, unknown>).ttsModelId) {
|
|
const pid = state.ttsProviderId;
|
|
if (pid && state.ttsProvidersConfig?.[pid]) {
|
|
state.ttsProvidersConfig[pid].modelId = (state as Record<string, unknown>)
|
|
.ttsModelId as string;
|
|
}
|
|
delete (state as Record<string, unknown>).ttsModelId;
|
|
}
|
|
// Same for asrModelId
|
|
if ((state as Record<string, unknown>).asrModelId) {
|
|
const pid = state.asrProviderId;
|
|
if (pid && state.asrProvidersConfig?.[pid]) {
|
|
state.asrProvidersConfig[pid].modelId = (state as Record<string, unknown>)
|
|
.asrModelId as string;
|
|
}
|
|
delete (state as Record<string, unknown>).asrModelId;
|
|
}
|
|
// Migrate MiniMax's model field to modelId
|
|
for (const [, cfg] of Object.entries(
|
|
(state.ttsProvidersConfig as Record<string, Record<string, unknown>>) || {},
|
|
)) {
|
|
if (cfg.model && !cfg.modelId) {
|
|
cfg.modelId = cfg.model;
|
|
delete cfg.model;
|
|
}
|
|
}
|
|
|
|
// Add default PDF config if missing
|
|
if (!state.pdfProvidersConfig) {
|
|
const defaultPDFConfig = getDefaultPDFConfig();
|
|
Object.assign(state, defaultPDFConfig);
|
|
}
|
|
|
|
// Add default Image config if missing
|
|
if (!state.imageProvidersConfig) {
|
|
const defaultImageConfig = getDefaultImageConfig();
|
|
Object.assign(state, defaultImageConfig);
|
|
}
|
|
|
|
// Add default Video config if missing
|
|
if (!state.videoProvidersConfig) {
|
|
const defaultVideoConfig = getDefaultVideoConfig();
|
|
Object.assign(state, defaultVideoConfig);
|
|
}
|
|
|
|
// v1 → v2: Replace deep research with web search
|
|
if (version < 2) {
|
|
delete (state as Record<string, unknown>).deepResearchProviderId;
|
|
delete (state as Record<string, unknown>).deepResearchProvidersConfig;
|
|
}
|
|
|
|
// Add default media generation toggles if missing
|
|
if (state.imageGenerationEnabled === undefined) {
|
|
state.imageGenerationEnabled = false;
|
|
}
|
|
if (state.videoGenerationEnabled === undefined) {
|
|
state.videoGenerationEnabled = false;
|
|
}
|
|
if (state.reviewOutlineEnabled === undefined) {
|
|
state.reviewOutlineEnabled = false;
|
|
}
|
|
|
|
// Add default audio toggles if missing. TTS defaults OFF (opt-in / CTA);
|
|
// first server-sync auto-enables it when a provider is configured (#665).
|
|
if ((state as Record<string, unknown>).ttsEnabled === undefined) {
|
|
(state as Record<string, unknown>).ttsEnabled = false;
|
|
}
|
|
if ((state as Record<string, unknown>).asrEnabled === undefined) {
|
|
(state as Record<string, unknown>).asrEnabled = true;
|
|
}
|
|
|
|
// Existing users already have their config set up — mark auto-config as done
|
|
if ((state as Record<string, unknown>).autoConfigApplied === undefined) {
|
|
(state as Record<string, unknown>).autoConfigApplied = true;
|
|
}
|
|
|
|
if ((state as Record<string, unknown>).agentMode === undefined) {
|
|
(state as Record<string, unknown>).agentMode = 'preset';
|
|
}
|
|
if ((state as Record<string, unknown>).autoAgentCount === undefined) {
|
|
(state as Record<string, unknown>).autoAgentCount = 3;
|
|
}
|
|
|
|
if ((state as Record<string, unknown>).thinkingConfigs === undefined) {
|
|
(state as Record<string, unknown>).thinkingConfigs = {};
|
|
}
|
|
|
|
// Migrate Web Search: old flat fields → new provider-based config
|
|
if (!state.webSearchProvidersConfig) {
|
|
const stateRecord = state as Record<string, unknown>;
|
|
const oldApiKey = (stateRecord.webSearchApiKey as string) || '';
|
|
const oldIsServerConfigured =
|
|
(stateRecord.webSearchIsServerConfigured as boolean) || false;
|
|
state.webSearchProviderId = 'tavily' as WebSearchProviderId;
|
|
state.webSearchProvidersConfig = {
|
|
tavily: {
|
|
apiKey: oldApiKey,
|
|
baseUrl: '',
|
|
enabled: true,
|
|
requiresApiKey: true,
|
|
isServerConfigured: oldIsServerConfigured,
|
|
},
|
|
bocha: {
|
|
apiKey: '',
|
|
baseUrl: '',
|
|
enabled: true,
|
|
requiresApiKey: true,
|
|
},
|
|
brave: {
|
|
apiKey: '',
|
|
baseUrl: WEB_SEARCH_PROVIDERS.brave.defaultBaseUrl || '',
|
|
enabled: true,
|
|
requiresApiKey: false,
|
|
},
|
|
baidu: {
|
|
apiKey: '',
|
|
baseUrl: '',
|
|
enabled: true,
|
|
requiresApiKey: true,
|
|
},
|
|
minimax: {
|
|
apiKey: '',
|
|
baseUrl: WEB_SEARCH_PROVIDERS.minimax.defaultBaseUrl || '',
|
|
enabled: true,
|
|
requiresApiKey: true,
|
|
},
|
|
} as SettingsState['webSearchProvidersConfig'];
|
|
delete stateRecord.webSearchApiKey;
|
|
delete stateRecord.webSearchIsServerConfigured;
|
|
}
|
|
|
|
// v2 → v3: managed providers no longer expose a base URL to the client;
|
|
// drop any persisted serverBaseUrl left over from older versions (#620).
|
|
stripLegacyServerBaseUrl(state);
|
|
|
|
// v3 → v4: the per-provider `enabled` flag becomes live under the
|
|
// unified enablement model (#665). Before v4 it was never user-editable,
|
|
// so any persisted value is just a stale default — normalize it:
|
|
// browser-native OFF (opt-in), every other built-in ON (it only surfaces
|
|
// once configured, so a server-managed provider must not stay hidden).
|
|
if (version < 4 && state.ttsProvidersConfig) {
|
|
for (const pid of Object.keys(TTS_PROVIDERS) as BuiltInTTSProviderId[]) {
|
|
const cfg = state.ttsProvidersConfig[pid];
|
|
if (cfg) cfg.enabled = pid !== 'browser-native-tts';
|
|
}
|
|
}
|
|
|
|
ensureValidProviderSelections(state);
|
|
ensureBuiltInAudioProviders(state);
|
|
ensureBuiltInWebSearchProviders(state);
|
|
state.thinkingConfigs = pruneThinkingConfigs(state.thinkingConfigs, state.providersConfig);
|
|
|
|
return state;
|
|
},
|
|
// Custom merge: always sync built-in providers on every rehydrate,
|
|
// so newly added providers/models appear without clearing cache.
|
|
merge: (persistedState, currentState) => {
|
|
const merged = { ...currentState, ...(persistedState as object) };
|
|
ensureBuiltInProviders(merged as Partial<SettingsState>);
|
|
promoteLegacyCustomProviderBaseUrls(merged as Partial<SettingsState>);
|
|
ensureBuiltInAudioProviders(merged as Partial<SettingsState>);
|
|
ensureBuiltInImageProviders(merged as Partial<SettingsState>);
|
|
ensureBuiltInVideoProviders(merged as Partial<SettingsState>);
|
|
ensureBuiltInWebSearchProviders(merged as Partial<SettingsState>);
|
|
ensureValidProviderSelections(merged as Partial<SettingsState>);
|
|
stripLegacyServerBaseUrl(merged as Partial<SettingsState>);
|
|
const typedMerged = merged as Partial<SettingsState>;
|
|
typedMerged.thinkingConfigs = pruneThinkingConfigs(
|
|
typedMerged.thinkingConfigs,
|
|
typedMerged.providersConfig,
|
|
);
|
|
return merged as SettingsState;
|
|
},
|
|
},
|
|
),
|
|
);
|