ars/iiEsaywebUIapp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #313 from cogwheel0/refactor-model-selection-restore-logic

Browse Source 
feat(chat): Refactor model selection to use shared restore logic
This commit is contained in:
cogwheel
2025-12-22 11:00:52 +05:30
committed by GitHub
parent 0f8003e210 9e73fc93c6
commit 83f890d6e4
5 changed files with 56 additions and 194 deletions
Download Patch File Download Diff File Expand all files Collapse all files

126
lib/core/providers/app_providers.dart
View File

@@ -1561,7 +1561,34 @@ Future<Model?> defaultModel(Ref ref) async {
DebugLogger.log('api-available', scope: 'models/default');
try {
// Warm restore from cached resolved default model
// Respect manual selection if present
if (ref.read(isManualModelSelectionProvider)) {
final current = ref.read(selectedModelProvider);
if (current != null) return current;
}
// 1) Priority: user's configured default from app settings
// This ensures new chats use the user's preference (fixes #296)
final settingsDefaultId = ref.read(appSettingsProvider).defaultModel;
final storedDefaultId = settingsDefaultId ??
await SettingsService.getDefaultModel().catchError((_) => null);
if (storedDefaultId != null && storedDefaultId.isNotEmpty) {
// Try cached models first for speed
final cachedMatch = await selectCachedModel(storage, storedDefaultId);
if (cachedMatch != null && !ref.read(isManualModelSelectionProvider)) {
ref.read(selectedModelProvider.notifier).set(cachedMatch);
unawaited(storage.saveLocalDefaultModel(cachedMatch).catchError((_) {}));
DebugLogger.log(
'settings-default',
scope: 'models/default',
data: {'name': cachedMatch.name, 'source': 'settings'},
);
return cachedMatch;
}
}
// 2) Fallback: cached resolved default model (for offline/fast startup)
try {
final cached = await storage.getLocalDefaultModel();
if (cached != null && !ref.read(isManualModelSelectionProvider)) {
@@ -1575,102 +1602,7 @@ Future<Model?> defaultModel(Ref ref) async {
}
} catch (_) {}
// Respect manual selection if present
if (ref.read(isManualModelSelectionProvider)) {
final current = ref.read(selectedModelProvider);
if (current != null) return current;
}
// 1) Fast path: read stored default model ID directly and select optimistically
try {
final storedDefaultId = await SettingsService.getDefaultModel();
if (storedDefaultId != null && storedDefaultId.isNotEmpty) {
if (!ref.read(isManualModelSelectionProvider)) {
final cachedMatch = await selectCachedModel(storage, storedDefaultId);
if (cachedMatch != null) {
ref.read(selectedModelProvider.notifier).set(cachedMatch);
unawaited(
storage.saveLocalDefaultModel(cachedMatch).onError((
error,
stack,
) {
DebugLogger.error(
'Failed to save default model to cache',
scope: 'models/default',
error: error,
stackTrace: stack,
);
}),
);
DebugLogger.log(
'cache-select',
scope: 'models/default',
data: {'name': cachedMatch.name, 'source': 'cache'},
);
} else {
DebugLogger.log(
'cache-skip-missing',
scope: 'models/default',
data: {'id': storedDefaultId},
);
}
}
// Reconcile against real models in background
Future.microtask(() async {
try {
if (!ref.mounted) return;
List<Model> models;
final modelsAsync = ref.read(modelsProvider);
if (modelsAsync.hasValue) {
models = modelsAsync.value ?? const <Model>[];
} else {
models = await ref.read(modelsProvider.future);
}
if (!ref.mounted) return;
Model? resolved;
try {
resolved = models.firstWhere((m) => m.id == storedDefaultId);
} catch (_) {
final byName = models
.where((m) => m.name == storedDefaultId)
.toList();
if (byName.length == 1) resolved = byName.first;
}
resolved ??= models.isNotEmpty ? models.first : null;
if (!ref.mounted) return;
if (resolved != null && !ref.read(isManualModelSelectionProvider)) {
ref.read(selectedModelProvider.notifier).set(resolved);
unawaited(
storage.saveLocalDefaultModel(resolved).onError((error, stack) {
DebugLogger.error(
'Failed to save default model to cache',
scope: 'models/default',
error: error,
stackTrace: stack,
);
}),
);
DebugLogger.log(
'reconcile',
scope: 'models/default',
data: {'name': resolved.name, 'source': 'stored'},
);
}
} catch (e) {
DebugLogger.error(
'reconcile-failed',
scope: 'models/default',
error: e,
);
}
});
return ref.read(selectedModelProvider);
}
} catch (_) {}
// 2) Fast server path: query server default ID without listing all models
// 3) Fast server path: query server default ID without listing all models
try {
final serverDefault = await api.getDefaultModel();
if (serverDefault != null && serverDefault.isNotEmpty) {

19
lib/features/chat/providers/chat_providers.dart
View File

@@ -990,8 +990,27 @@ void startNewChat(dynamic ref) {
ref.read(pendingFolderIdProvider.notifier).clear();
// Reset to default model for new conversations (fixes #296)
restoreDefaultModel(ref);
}
/// Restores the selected model to the user's configured default model.
/// Call this when starting a new conversation.
Future<void> restoreDefaultModel(dynamic ref) async {
// Mark that this is not a manual selection
ref.read(isManualModelSelectionProvider.notifier).set(false);
// Invalidate and re-read to force defaultModelProvider to use settings priority
ref.invalidate(defaultModelProvider);
try {
await ref.read(defaultModelProvider.future);
} catch (e) {
DebugLogger.error(
'restore-default-failed',
scope: 'chat/model',
error: e,
);
}
}
// Available tools provider

100
lib/features/chat/views/chat_page.dart
View File

@@ -83,42 +83,6 @@ class _ChatPageState extends ConsumerState<ChatPage> {
return fileSize <= (maxSizeMB * 1024 * 1024);
}
Future<Model?> _trySelectCachedModel() async {
final existing = ref.read(selectedModelProvider);
if (existing != null) {
return existing;
}
try {
final storage = ref.read(optimizedStorageServiceProvider);
// Prefer the stored default model ID/name if available
final settingsDesired = ref.read(appSettingsProvider).defaultModel;
final storedDesired = await SettingsService.getDefaultModel().catchError(
(_) => null,
);
final desiredId = settingsDesired ?? storedDesired;
final match = await selectCachedModel(storage, desiredId);
if (match != null) {
ref.read(selectedModelProvider.notifier).set(match);
DebugLogger.log(
'cache-select',
scope: 'chat/model',
data: {'name': match.name, 'source': 'cache'},
);
}
return match;
} catch (error, stackTrace) {
DebugLogger.error(
'cache-select-failed',
scope: 'chat/model',
error: error,
stackTrace: stackTrace,
);
return null;
}
}
void startNewChat() {
// Clear current conversation
ref.read(chatMessagesProvider.notifier).clearMessages();
@@ -131,8 +95,7 @@ class _ChatPageState extends ConsumerState<ChatPage> {
ref.read(pendingFolderIdProvider.notifier).clear();
// Reset to default model for new conversations (fixes #296)
ref.read(isManualModelSelectionProvider.notifier).set(false);
ref.invalidate(defaultModelProvider);
restoreDefaultModel(ref);
// Scroll to top
if (_scrollController.hasClients) {
@@ -157,65 +120,8 @@ class _ChatPageState extends ConsumerState<ChatPage> {
return;
}
// Fast path: try cached models + stored default before waiting on providers
final cached = await _trySelectCachedModel();
if (cached != null) {
// Still continue to reconcile against remote models below
DebugLogger.log(
'cache-hit',
scope: 'chat/model',
data: {'name': cached.name},
);
}
DebugLogger.log('auto-select-start', scope: 'chat/model');
try {
// First ensure models are loaded
final modelsAsync = ref.read(modelsProvider);
List<Model> models;
if (modelsAsync.hasValue) {
models = modelsAsync.value!;
} else {
DebugLogger.log('models-fetch', scope: 'chat/model');
models = await ref.read(modelsProvider.future);
}
DebugLogger.log(
'models-count',
scope: 'chat/model',
data: {'count': models.length},
);
if (models.isEmpty) {
DebugLogger.warning('models-empty', scope: 'chat/model');
return;
}
// Try to use the default model provider
try {
final Model? model = await ref.read(defaultModelProvider.future);
if (model != null) {
DebugLogger.log(
'auto-select',
scope: 'chat/model',
data: {'name': model.name},
);
}
} catch (e) {
DebugLogger.warning('provider-fallback', scope: 'chat/model');
// Fallback: select the first available model
ref.read(selectedModelProvider.notifier).set(models.first);
DebugLogger.log(
'fallback',
scope: 'chat/model',
data: {'name': models.first.name},
);
}
} catch (e) {
DebugLogger.error('auto-select-failed', scope: 'chat/model', error: e);
}
// Use shared restore logic which handles settings priority and fallbacks
await restoreDefaultModel(ref);
}
Future<void> _checkAndShowOnboarding() async {

3
lib/features/navigation/widgets/chats_drawer.dart
View File

@@ -1342,6 +1342,9 @@ class _ChatsDrawerState extends ConsumerState<ChatsDrawer> {
// Clear context attachments (web pages, YouTube, knowledge base docs)
ref.read(contextAttachmentsProvider.notifier).clear();
// Reset to default model for new conversations (fixes #296)
chat.restoreDefaultModel(ref);
// Close drawer using the responsive layout (same pattern as _selectConversation)
if (mounted) {
final mediaQuery = MediaQuery.maybeOf(context);

2
lib/shared/utils/conversation_context_menu.dart
View File

@@ -523,6 +523,8 @@ Future<void> _confirmAndDeleteConversation(
if (active?.id == conversationId) {
ref.read(activeConversationProvider.notifier).clear();
ref.read(chat.chatMessagesProvider.notifier).clearMessages();
// Reset to default model for new conversations (fixes #296)
chat.restoreDefaultModel(ref);
}
refreshConversationsCache(ref);
} catch (_) {