improving the model selection

assets/config/curated_models.yaml

@@ -0,0 +1,25 @@
+# Curated list of models known to work well with #tikslop
+models:
+  - model_id: deepseek-ai/DeepSeek-R1-0528-Qwen3-8B
+    display_name: DeepSeek R1 Qwen3 8B (0528)
+    num_of_parameters: 8B
+  
+  - model_id: mistralai/Mistral-Small-3.2-24B-Instruct-2506
+    display_name: Mistral Small 3.2 24B (Instruct, 2506)
+    num_of_parameters: 24B
+  
+  - model_id: HuggingFaceTB/SmolLM3-3B
+    display_name: SmolLM3 3B
+    num_of_parameters: 3B
+  
+  - model_id: Qwen/Qwen3-0.6B
+    display_name: Qwen3 0.6B
+    num_of_parameters: 0.6B
+  
+  - model_id: google/gemma-3n-E2B-it
+    display_name: Gemma 3n E2B IT (Instruct)
+    num_of_parameters: 2B
+  
+  - model_id: google/gemma-3n-E4B-it
+    display_name: Gemma 3n E4B IT (Instruct)
+    num_of_parameters: 4B

build/web/assets/AssetManifest.bin

@@ -1 +1 @@
-
+

build/web/assets/AssetManifest.bin.json

@@ -1 +1 @@
-"DQgHFGFzc2V0cy9hZHMvUkVBRE1FLm1kDAENAQcFYXNzZXQHFGFzc2V0cy9hZHMvUkVBRE1FLm1kBxZhc3NldHMvYWRzL2xlcm9ib3QuZ2lmDAENAQcFYXNzZXQHFmFzc2V0cy9hZHMvbGVyb2JvdC5naWYHGWFzc2V0cy9hZHMvc21vbGFnZW50cy5naWYMAQ0BBwVhc3NldAcZYXNzZXRzL2Fkcy9zbW9sYWdlbnRzLmdpZgcXYXNzZXRzL2NvbmZpZy9SRUFETUUubWQMAQ0BBwVhc3NldAcXYXNzZXRzL2NvbmZpZy9SRUFETUUubWQHGWFzc2V0cy9jb25maWcvY3VzdG9tLnlhbWwMAQ0BBwVhc3NldAcZYXNzZXRzL2NvbmZpZy9jdXN0b20ueWFtbAcaYXNzZXRzL2NvbmZpZy9kZWZhdWx0LnlhbWwMAQ0BBwVhc3NldAcaYXNzZXRzL2NvbmZpZy9kZWZhdWx0LnlhbWwHGmFzc2V0cy9jb25maWcvdGlrc2xvcC55YW1sDAENAQcFYXNzZXQHGmFzc2V0cy9jb25maWcvdGlrc2xvcC55YW1sBzJwYWNrYWdlcy9jdXBlcnRpbm9faWNvbnMvYXNzZXRzL0N1cGVydGlub0ljb25zLnR0ZgwBDQEHBWFzc2V0BzJwYWNrYWdlcy9jdXBlcnRpbm9faWNvbnMvYXNzZXRzL0N1cGVydGlub0ljb25zLnR0Zg=="
+"DQkHFGFzc2V0cy9hZHMvUkVBRE1FLm1kDAENAQcFYXNzZXQHFGFzc2V0cy9hZHMvUkVBRE1FLm1kBxZhc3NldHMvYWRzL2xlcm9ib3QuZ2lmDAENAQcFYXNzZXQHFmFzc2V0cy9hZHMvbGVyb2JvdC5naWYHGWFzc2V0cy9hZHMvc21vbGFnZW50cy5naWYMAQ0BBwVhc3NldAcZYXNzZXRzL2Fkcy9zbW9sYWdlbnRzLmdpZgcXYXNzZXRzL2NvbmZpZy9SRUFETUUubWQMAQ0BBwVhc3NldAcXYXNzZXRzL2NvbmZpZy9SRUFETUUubWQHIWFzc2V0cy9jb25maWcvY3VyYXRlZF9tb2RlbHMueWFtbAwBDQEHBWFzc2V0ByFhc3NldHMvY29uZmlnL2N1cmF0ZWRfbW9kZWxzLnlhbWwHGWFzc2V0cy9jb25maWcvY3VzdG9tLnlhbWwMAQ0BBwVhc3NldAcZYXNzZXRzL2NvbmZpZy9jdXN0b20ueWFtbAcaYXNzZXRzL2NvbmZpZy9kZWZhdWx0LnlhbWwMAQ0BBwVhc3NldAcaYXNzZXRzL2NvbmZpZy9kZWZhdWx0LnlhbWwHGmFzc2V0cy9jb25maWcvdGlrc2xvcC55YW1sDAENAQcFYXNzZXQHGmFzc2V0cy9jb25maWcvdGlrc2xvcC55YW1sBzJwYWNrYWdlcy9jdXBlcnRpbm9faWNvbnMvYXNzZXRzL0N1cGVydGlub0ljb25zLnR0ZgwBDQEHBWFzc2V0BzJwYWNrYWdlcy9jdXBlcnRpbm9faWNvbnMvYXNzZXRzL0N1cGVydGlub0ljb25zLnR0Zg=="

build/web/assets/AssetManifest.json

@@ -1 +1 @@
-{"assets/ads/README.md":["assets/ads/README.md"],"assets/ads/lerobot.gif":["assets/ads/lerobot.gif"],"assets/ads/smolagents.gif":["assets/ads/smolagents.gif"],"assets/config/README.md":["assets/config/README.md"],"assets/config/custom.yaml":["assets/config/custom.yaml"],"assets/config/default.yaml":["assets/config/default.yaml"],"assets/config/tikslop.yaml":["assets/config/tikslop.yaml"],"packages/cupertino_icons/assets/CupertinoIcons.ttf":["packages/cupertino_icons/assets/CupertinoIcons.ttf"]}
+{"assets/ads/README.md":["assets/ads/README.md"],"assets/ads/lerobot.gif":["assets/ads/lerobot.gif"],"assets/ads/smolagents.gif":["assets/ads/smolagents.gif"],"assets/config/README.md":["assets/config/README.md"],"assets/config/curated_models.yaml":["assets/config/curated_models.yaml"],"assets/config/custom.yaml":["assets/config/custom.yaml"],"assets/config/default.yaml":["assets/config/default.yaml"],"assets/config/tikslop.yaml":["assets/config/tikslop.yaml"],"packages/cupertino_icons/assets/CupertinoIcons.ttf":["packages/cupertino_icons/assets/CupertinoIcons.ttf"]}

build/web/assets/assets/config/curated_models.yaml

@@ -0,0 +1,79 @@
+# Curated list of models known to work well with #tikslop
+models:
+
+  #- model_id: HuggingFaceTB/SmolLM3-3B
+  #  display_name: SmolLM3 3B
+  #  num_of_parameters: 3B
+
+  - model_id: Qwen/Qwen2.5-0.5B-Instruct
+    display_name: Qwen2.5 0.5B
+    num_of_parameters: 0.5B
+  
+  - model_id: Qwen/Qwen3-0.6B
+    display_name: Qwen3 0.6B
+    num_of_parameters: 0.6B
+
+  - model_id: meta-llama/Llama-3.2-1B-Instruct
+    display_name: Llama 3.2 1B
+    num_of_parameters: 1B
+
+  - model_id: Unbabel/Tower-Plus-2B
+    display_name: Tower Plus 2B
+    num_of_parameters: 2B
+  
+  - model_id: microsoft/phi-2
+    display_name: Phi 2
+    num_of_parameters: 2.7B
+
+  - model_id: microsoft/Phi-3-mini-128k-instruct
+    display_name: Phi 3 mini (128k)
+    num_of_parameters: 4B
+
+  - model_id: google/gemma-3-4b-it
+    display_name: Gemma 3 4B
+    num_of_parameters: 4B
+  
+  - model_id: Qwen/Qwen3-4B-Base
+    display_name: Qwen3 4B
+    num_of_parameters: 4B
+  
+  - model_id: Qwen/Qwen3-32B
+    display_name: Qwen3 32B
+    num_of_parameters: 32B
+  
+  - model_id: deepseek-ai/DeepSeek-R1-0528-Qwen3-8B
+    display_name: DeepSeek R1 Qwen3 8B (0528)
+    num_of_parameters: 8B
+  
+  - model_id: meta-llama/Llama-4-Scout-17B-16E-Instruct
+    display_name: Llama 4 Scout 17B
+    num_of_parameters: 17B
+
+  - model_id: mistralai/Mistral-Small-3.2-24B-Instruct-2506
+    display_name: Mistral Small 3.2 24B
+    num_of_parameters: 24B
+
+  - model_id: Qwen/Qwen3-235B-A22B-Instruct-2507
+    display_name: Qwen3 235B A22B
+    num_of_parameters: 235B
+
+  - model_id: deepseek-ai/DeepSeek-V3-0324
+    display_name: DeepSeek V3
+    num_of_parameters: 685B
+  
+
+  # Gemma 3n models are not available on the Inference Providers yet
+  #- model_id: google/gemma-3n-E2B-it
+  #  display_name: Gemma 3n E2B IT (Instruct)
+  #
+  #  # While the raw parameter count of this model is 6B, the architecture design allows the model to be run with a memory footprint comparable to a traditional 2B model by offloading low-utilization matrices from the accelerator.
+  #  #num_of_parameters: 6B
+  #  num_of_parameters: 2B
+  #
+  #- model_id: google/gemma-3n-E4B-it
+  #  display_name: Gemma 3n E4B IT (Instruct)
+  #
+  #  # While the raw parameter count of this model is 8B, the architecture design allows the model to be run with a memory footprint comparable to a traditional 4B model by offloading low-utilization matrices from the accelerator.
+  #  #num_of_parameters: 8B
+  #  num_of_parameters: 4B
+

build/web/flutter_bootstrap.js

@@ -38,6 +38,6 @@ _flutter.buildConfig = {"engineRevision":"1c9c20e7c3dd48c66f400a24d48ea806b4ab31
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "573687876"
+    serviceWorkerVersion: "1152030249"
   }
 });

build/web/flutter_service_worker.js

@@ -3,12 +3,12 @@ const MANIFEST = 'flutter-app-manifest';
 const TEMP = 'flutter-temp-cache';
 const CACHE_NAME = 'flutter-app-cache';
 
-const RESOURCES = {"flutter_bootstrap.js": "581857f4e7740fdd5901e95f9d2a7bc3",
+const RESOURCES = {"flutter_bootstrap.js": "4293255503dbf79f2be0ef00f170c7b9",
 "version.json": "68350cac7987de2728345c72918dd067",
 "tikslop.png": "570e1db759046e2d224fef729983634e",
 "index.html": "3a7029b3672560e7938aab6fa4d30a46",
 "/": "3a7029b3672560e7938aab6fa4d30a46",
-"main.dart.js": "d0545221a5e9d6dd47253d8149064a25",
+"main.dart.js": "c53f6a142be0eaf2a83400fd9070161f",
 "tikslop.svg": "26140ba0d153b213b122bc6ebcc17f6c",
 "flutter.js": "888483df48293866f9f41d3d9274a779",
 "favicon.png": "c8a183c516004e648a7bac7497c89b97",
@@ -17,17 +17,18 @@ const RESOURCES = {"flutter_bootstrap.js": "581857f4e7740fdd5901e95f9d2a7bc3",
 "icons/Icon-maskable-512.png": "8682b581a7dab984ef4f9b7f21976a64",
 "icons/Icon-512.png": "8682b581a7dab984ef4f9b7f21976a64",
 "manifest.json": "c0904388ddaba6a9bd572a80f79a8dcc",
-"assets/AssetManifest.json": "7c3f24a308a466794e1c04bd7b46567e",
+"assets/AssetManifest.json": "42eb9cb8cfb5d55547c6e8e355ddcfac",
 "assets/NOTICES": "90391d860ca53976ec1b643b3e6286b7",
 "assets/FontManifest.json": "dc3d03800ccca4601324923c0b1d6d57",
-"assets/AssetManifest.bin.json": "b4f8d70a60cc7fe6916c636377e8d4bc",
+"assets/AssetManifest.bin.json": "d21861b1d7161e95775d5c89361428d5",
 "assets/packages/cupertino_icons/assets/CupertinoIcons.ttf": "33b7d9392238c04c131b6ce224e13711",
 "assets/shaders/ink_sparkle.frag": "ecc85a2e95f5e9f53123dcaf8cb9b6ce",
-"assets/AssetManifest.bin": "afdc174fb4cb8a6401bd2328a67e184c",
-"assets/fonts/MaterialIcons-Regular.otf": "06b86454c633cc9510ad85ddc0523a91",
+"assets/AssetManifest.bin": "3311f7126492dcfa7fb84733f178441e",
+"assets/fonts/MaterialIcons-Regular.otf": "adb729127dd99d9fd52c132e18ef0b8f",
 "assets/assets/ads/smolagents.gif": "45338af5a4d440b707d02f364be8195c",
 "assets/assets/ads/README.md": "1959fb6b85a966348396f2f0f9c3f32a",
 "assets/assets/ads/lerobot.gif": "0f90b2fc4d15eefb5572363724d6d925",
+"assets/assets/config/curated_models.yaml": "244e9a0acd25da220c9d49cc53c8e358",
 "assets/assets/config/README.md": "07a87720dd00dd1ca98c9d6884440e31",
 "assets/assets/config/custom.yaml": "52bd30aa4d8b980626a5eb02d0871c01",
 "assets/assets/config/default.yaml": "9ca1d05d06721c2b6f6382a1ba40af48",

build/web/index.html

@@ -156,7 +156,7 @@
   </script>
   
   <!-- Add version parameter for cache busting -->
-  <script src="flutter_bootstrap.js?v=1753208400" async></script>
+  <script src="flutter_bootstrap.js?v=1753272934" async></script>
   
   <!-- Add cache busting script -->
   <script>

lib/models/curated_model.dart

@@ -0,0 +1,116 @@
+import 'package:flutter/services.dart';
+import 'package:yaml/yaml.dart';
+
+/// Represents a curated LLM model with metadata
+class CuratedModel {
+  final String modelId;
+  final String displayName;
+  final String numOfParameters;
+
+  const CuratedModel({
+    required this.modelId,
+    required this.displayName,
+    required this.numOfParameters,
+  });
+
+  /// Get speed category based on parameter count
+  String get speedCategory {
+    final paramValue = _parseParameters(numOfParameters);
+    
+    if (paramValue <= 1) return 'Fastest';
+    if (paramValue <= 2) return 'Faster';
+    if (paramValue <= 4) return 'Fast';
+    if (paramValue < 8) return 'Normal';
+    if (paramValue < 17) return 'Slow';
+    if (paramValue < 32) return 'Slower';
+    return 'Slowest';
+  }
+
+  /// Get speed emoji for visual representation
+  String get speedEmoji {
+    switch (speedCategory) {
+      case 'Fastest':
+        return '🚀';
+      case 'Faster':
+        return '⚡';
+      case 'Fast':
+        return '🏃';
+      case 'Normal':
+        return '🚶';
+      case 'Slow':
+        return '🐌';
+      case 'Slower':
+        return '🐢';
+      case 'Slowest':
+        return '🦥';
+      default:
+        return '❓';
+    }
+  }
+
+  /// Parse parameter string to numeric value (in billions)
+  double _parseParameters(String params) {
+    final numStr = params.replaceAll('B', '').trim();
+    return double.tryParse(numStr) ?? 0.0;
+  }
+
+  /// Create from YAML map
+  factory CuratedModel.fromYaml(YamlMap yaml) {
+    return CuratedModel(
+      modelId: yaml['model_id'] as String,
+      displayName: yaml['display_name'] as String,
+      numOfParameters: yaml['num_of_parameters'] as String,
+    );
+  }
+
+  /// Load all curated models from assets
+  static Future<List<CuratedModel>> loadFromAssets() async {
+    try {
+      final yamlString = await rootBundle.loadString('assets/config/curated_models.yaml');
+      final yamlData = loadYaml(yamlString);
+      
+      final models = <CuratedModel>[];
+      if (yamlData['models'] != null) {
+        for (final modelYaml in yamlData['models']) {
+          models.add(CuratedModel.fromYaml(modelYaml));
+        }
+      }
+      
+      // Sort by parameter count (smallest first)
+      models.sort((a, b) => a._parseParameters(a.numOfParameters)
+          .compareTo(b._parseParameters(b.numOfParameters)));
+      
+      return models;
+    } catch (e) {
+      // Return default models if loading fails
+      return _defaultModels;
+    }
+  }
+
+  /// Default models in case asset loading fails
+  static const List<CuratedModel> _defaultModels = [
+    CuratedModel(
+      modelId: 'meta-llama/Llama-3.2-3B-Instruct',
+      displayName: 'Llama 3.2 3B Instruct',
+      numOfParameters: '3B',
+    ),
+    CuratedModel(
+      modelId: 'HuggingFaceTB/SmolLM3-3B',
+      displayName: 'SmolLM3 3B',
+      numOfParameters: '3B',
+    ),
+  ];
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is CuratedModel &&
+          runtimeType == other.runtimeType &&
+          modelId == other.modelId;
+
+  @override
+  int get hashCode => modelId.hashCode;
+
+  @override
+  String toString() => 'CuratedModel(modelId: $modelId, displayName: $displayName, parameters: $numOfParameters)';
+}

lib/models/llm_provider.dart

@@ -0,0 +1,146 @@
+/// LLM Provider configuration for Hugging Face supported providers
+class LLMProvider {
+  final String id;
+  final String name;
+  final String? apiBaseUrl;
+  final String routerBaseUrl;
+  final bool supportsHuggingFaceKey;
+  final bool isAvailable;
+
+  const LLMProvider({
+    required this.id,
+    required this.name,
+    this.apiBaseUrl,
+    required this.routerBaseUrl,
+    this.supportsHuggingFaceKey = true,
+    this.isAvailable = true,
+  });
+
+  /// Create a copy with updated availability
+  LLMProvider copyWith({bool? isAvailable}) {
+    return LLMProvider(
+      id: id,
+      name: name,
+      apiBaseUrl: apiBaseUrl,
+      routerBaseUrl: routerBaseUrl,
+      supportsHuggingFaceKey: supportsHuggingFaceKey,
+      isAvailable: isAvailable ?? this.isAvailable,
+    );
+  }
+
+  /// Get the API key label for this provider
+  String get apiKeyLabel {
+    if (!supportsHuggingFaceKey) {
+      return '$name API Key';
+    }
+    return 'Hugging Face API Key';
+  }
+
+  /// List of all supported providers based on HF documentation
+  static const List<LLMProvider> supportedProviders = [
+    LLMProvider(
+      id: 'built-in',
+      name: 'Built-in (free, slow)',
+      routerBaseUrl: '',
+      supportsHuggingFaceKey: false,
+    ),
+    LLMProvider(
+      id: 'cerebras',
+      name: 'Cerebras',
+      apiBaseUrl: 'https://api.cerebras.ai/v1',
+      routerBaseUrl: 'https://router.huggingface.co/cerebras/v1',
+    ),
+    LLMProvider(
+      id: 'cohere',
+      name: 'Cohere',
+      apiBaseUrl: 'https://api.cohere.com/compatibility/v1',
+      routerBaseUrl: 'https://router.huggingface.co/cohere/v1',
+    ),
+    LLMProvider(
+      id: 'fal-ai',
+      name: 'Fal AI',
+      apiBaseUrl: 'https://api.fal.ai/v1',
+      routerBaseUrl: 'https://router.huggingface.co/fal-ai/v1',
+    ),
+    LLMProvider(
+      id: 'featherless',
+      name: 'Featherless AI',
+      apiBaseUrl: 'https://api.featherless.ai/v1',
+      routerBaseUrl: 'https://router.huggingface.co/featherless/v1',
+    ),
+    LLMProvider(
+      id: 'fireworks',
+      name: 'Fireworks',
+      apiBaseUrl: 'https://api.fireworks.ai/inference/v1',
+      routerBaseUrl: 'https://router.huggingface.co/fireworks/v1',
+    ),
+    LLMProvider(
+      id: 'groq',
+      name: 'Groq',
+      apiBaseUrl: 'https://api.groq.com/openai/v1',
+      routerBaseUrl: 'https://router.huggingface.co/groq/v1',
+    ),
+    LLMProvider(
+      id: 'hf-inference',
+      name: 'HF Inference',
+      apiBaseUrl: 'https://api-inference.huggingface.co/v1',
+      routerBaseUrl: 'https://router.huggingface.co/hf-inference/v1',
+    ),
+    LLMProvider(
+      id: 'hyperbolic',
+      name: 'Hyperbolic',
+      apiBaseUrl: 'https://api.hyperbolic.xyz/v1',
+      routerBaseUrl: 'https://router.huggingface.co/hyperbolic/v1',
+    ),
+    LLMProvider(
+      id: 'nebius',
+      name: 'Nebius',
+      apiBaseUrl: 'https://api.studio.nebius.ai/v1',
+      routerBaseUrl: 'https://router.huggingface.co/nebius/v1',
+    ),
+    LLMProvider(
+      id: 'novita',
+      name: 'Novita',
+      apiBaseUrl: 'https://api.novita.ai/v3/openai',
+      routerBaseUrl: 'https://router.huggingface.co/novita/v1',
+    ),
+    LLMProvider(
+      id: 'nscale',
+      name: 'Nscale',
+      apiBaseUrl: 'https://inference.api.nscale.com/v1',
+      routerBaseUrl: 'https://router.huggingface.co/nscale/v1',
+    ),
+    LLMProvider(
+      id: 'replicate',
+      name: 'Replicate',
+      apiBaseUrl: 'https://api.replicate.com/v1',
+      routerBaseUrl: 'https://router.huggingface.co/replicate/v1',
+    ),
+    LLMProvider(
+      id: 'sambanova',
+      name: 'SambaNova',
+      apiBaseUrl: 'https://api.sambanova.ai/v1',
+      routerBaseUrl: 'https://router.huggingface.co/sambanova/v1',
+    ),
+    LLMProvider(
+      id: 'together',
+      name: 'Together',
+      apiBaseUrl: 'https://api.together.xyz/v1',
+      routerBaseUrl: 'https://router.huggingface.co/together/v1',
+    ),
+  ];
+
+  /// Get provider by ID
+  static LLMProvider? getById(String id) {
+    try {
+      return supportedProviders.firstWhere((provider) => provider.id == id);
+    } catch (e) {
+      return null;
+    }
+  }
+
+  /// Get default provider
+  static LLMProvider get defaultProvider {
+    return supportedProviders.first; // Built-in is first in the list
+  }
+}

lib/screens/settings_screen.dart

@@ -1,6 +1,9 @@
 import 'package:flutter/material.dart';
 import '../services/settings_service.dart';
 import '../services/websocket_api_service.dart';
+import '../services/model_availability_service.dart';
+import '../models/llm_provider.dart';
+import '../models/curated_model.dart';
 import '../theme/colors.dart';
 
 class SettingsScreen extends StatefulWidget {
@@ -15,11 +18,20 @@ class _SettingsScreenState extends State<SettingsScreen> {
   final _negativePromptController = TextEditingController();
   final _hfApiKeyController = TextEditingController();
   final _llmApiKeyController = TextEditingController();
+  final _modelNameController = TextEditingController();
   final _settingsService = SettingsService();
+  final _availabilityService = ModelAvailabilityService();
   bool _showSceneDebugInfo = false;
   bool _enableSimulation = true;
-  String _selectedLlmProvider = 'openai';
-  String _selectedLlmModel = 'gpt-4';
+  String _selectedLlmProvider = 'built-in';
+  String _selectedLlmModel = 'meta-llama/Llama-3.2-3B-Instruct';
+  LLMProvider? _currentProvider;
+  List<LLMProvider> _availableProviders = LLMProvider.supportedProviders.where((p) => p.id != 'built-in').toList();
+  List<CuratedModel> _curatedModels = [];
+  CuratedModel? _selectedCuratedModel;
+  bool _isCheckingAvailability = false;
+  bool _isLoadingModels = true;
+  bool _isBuiltInModelSelected = true;
 
   @override
   void initState() {
@@ -31,16 +43,28 @@ class _SettingsScreenState extends State<SettingsScreen> {
     _showSceneDebugInfo = _settingsService.showSceneDebugInfo;
     _enableSimulation = _settingsService.enableSimulation;
     
-    // Auto-select built-in provider if no HF API key
+    // Auto-select built-in model if no HF API key
     if (_settingsService.huggingfaceApiKey.isEmpty) {
-      _selectedLlmProvider = 'builtin';
-      _selectedLlmModel = 'default';
+      _selectedLlmProvider = 'built-in';
+      _selectedLlmModel = 'built-in';
+      _isBuiltInModelSelected = true;
       // Save the auto-selected values
-      _settingsService.setLlmProvider('builtin');
-      _settingsService.setLlmModel('default');
+      _settingsService.setLlmProvider('built-in');
+      _settingsService.setLlmModel('built-in');
     } else {
       _selectedLlmProvider = _settingsService.llmProvider;
       _selectedLlmModel = _settingsService.llmModel;
+      _isBuiltInModelSelected = _selectedLlmModel == 'built-in';
+    }
+    _currentProvider = _isBuiltInModelSelected ? null : LLMProvider.getById(_selectedLlmProvider);
+    _modelNameController.text = _selectedLlmModel;
+    
+    // Load curated models
+    _loadCuratedModels();
+    
+    // Check model availability on startup
+    if (!_isBuiltInModelSelected) {
+      _checkModelAvailability();
     }
   }
 
@@ -50,8 +74,102 @@ class _SettingsScreenState extends State<SettingsScreen> {
     _negativePromptController.dispose();
     _hfApiKeyController.dispose();
     _llmApiKeyController.dispose();
+    _modelNameController.dispose();
     super.dispose();
   }
+  
+  Future<void> _loadCuratedModels() async {
+    try {
+      final models = await CuratedModel.loadFromAssets();
+      setState(() {
+        _curatedModels = models;
+        _isLoadingModels = false;
+        
+        // Find the currently selected model in the curated list
+        if (!_isBuiltInModelSelected) {
+          try {
+            _selectedCuratedModel = _curatedModels.firstWhere(
+              (model) => model.modelId == _selectedLlmModel,
+            );
+          } catch (e) {
+            // If current model not found in curated list, use first available
+            _selectedCuratedModel = _curatedModels.isNotEmpty ? _curatedModels.first : null;
+          }
+        } else {
+          _selectedCuratedModel = null;
+        }
+      });
+    } catch (e) {
+      setState(() {
+        _isLoadingModels = false;
+      });
+    }
+  }
+  
+  Future<void> _checkModelAvailability() async {
+    if (!mounted || _selectedLlmModel.isEmpty) return;
+
+    setState(() {
+      _isCheckingAvailability = true;
+    });
+
+    try {
+      final availability = await _availabilityService.getModelAvailability(
+        _selectedLlmModel,
+      );
+      if (availability != null && mounted) {
+        final compatibleProviders = _availabilityService.getCompatibleProviders(
+          _selectedLlmModel,
+        );
+
+        // Update provider availability
+        final updatedProviders = LLMProvider.supportedProviders.map((provider) {
+          if (provider.id == 'built-in') {
+            return provider; // Built-in is always available
+          }
+          final isCompatible = compatibleProviders.contains(provider.id);
+          return provider.copyWith(isAvailable: isCompatible);
+        }).toList();
+
+        setState(() {
+          _availableProviders = updatedProviders;
+          _isCheckingAvailability = false;
+        });
+
+        // Auto-switch provider if current one is not compatible
+        if (!compatibleProviders.contains(_selectedLlmProvider) && !_isBuiltInModelSelected) {
+          if (compatibleProviders.isNotEmpty) {
+            // Switch to first compatible provider
+            setState(() {
+              _selectedLlmProvider = compatibleProviders.first;
+              _currentProvider = LLMProvider.getById(_selectedLlmProvider);
+            });
+            await _settingsService.setLlmProvider(_selectedLlmProvider);
+          } else {
+            // No compatible providers, switch to built-in model
+            setState(() {
+              _selectedLlmProvider = 'built-in';
+              _selectedLlmModel = 'built-in';
+              _isBuiltInModelSelected = true;
+              _selectedCuratedModel = null;
+              _currentProvider = null;
+            });
+            await _settingsService.setLlmProvider('built-in');
+            await _settingsService.setLlmModel('built-in');
+          }
+        }
+      }
+    } catch (e) {
+      if (mounted) {
+        setState(() {
+          _isCheckingAvailability = false;
+        });
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(content: Text('Failed to check model availability: $e')),
+        );
+      }
+    }
+  }
 
   @override
   Widget build(BuildContext context) {
@@ -82,7 +200,7 @@ class _SettingsScreenState extends State<SettingsScreen> {
                     controller: _hfApiKeyController,
                     decoration: const InputDecoration(
                       labelText: 'Hugging Face API Key',
-                      helperText: 'Your HF token for API access and higher-resolution rendering',
+                      helperText: 'Providing a HF API key allows you to select faster or better LLMs (billed to your account)',
                       helperMaxLines: 2,
                     ),
                     obscureText: true,
@@ -90,16 +208,24 @@ class _SettingsScreenState extends State<SettingsScreen> {
                       await _settingsService.setHuggingfaceApiKey(value);
                       
                       // Auto-select built-in provider if API key is removed
-                      if (value.isEmpty && _selectedLlmProvider != 'builtin') {
+                      if (value.isEmpty && !_isBuiltInModelSelected) {
                         setState(() {
-                          _selectedLlmProvider = 'builtin';
-                          _selectedLlmModel = 'default';
+                          _selectedLlmProvider = 'built-in';
+                          _selectedLlmModel = 'built-in';
+                          _isBuiltInModelSelected = true;
+                          _currentProvider = null;
+                          _selectedCuratedModel = null;
+                          _modelNameController.text = _selectedLlmModel;
                         });
-                        await _settingsService.setLlmProvider('builtin');
-                        await _settingsService.setLlmModel('default');
+                        await _settingsService.setLlmProvider('built-in');
+                        await _settingsService.setLlmModel('built-in');
                       } else if (value.isNotEmpty) {
                         // Trigger rebuild to enable/disable fields
                         setState(() {});
+                        // Check model availability when HF key is provided
+                        if (!_isBuiltInModelSelected) {
+                          _checkModelAvailability();
+                        }
                       }
                       
                       // Show a snackbar to indicate the API key was saved
@@ -147,105 +273,318 @@ class _SettingsScreenState extends State<SettingsScreen> {
                     },
                   ),
                   const SizedBox(height: 16),
+                  // Model selection dropdown
                   DropdownButtonFormField<String>(
                     decoration: InputDecoration(
-                      labelText: 'LLM Provider',
-                      helperText: _hfApiKeyController.text.isEmpty 
-                          ? 'Enter HF API key to unlock providers' 
-                          : 'Select your preferred LLM provider',
+                      labelText: 'Model',
+                      helperText: _isBuiltInModelSelected
+                          ? 'The built-in model is free, but shared among users and may be out of capacity sometimes'
+                          : _hfApiKeyController.text.isEmpty 
+                              ? 'Enter HF API key to select models' 
+                              : _isCheckingAvailability
+                                  ? 'Checking model availability...'
+                                  : 'Select a curated model optimized for #tikslop',
+                      helperMaxLines: 2,
+                      suffixIcon: _isCheckingAvailability || _isLoadingModels
+                          ? const SizedBox(
+                              width: 16,
+                              height: 16,
+                              child: CircularProgressIndicator(strokeWidth: 2),
+                            )
+                          : null,
                     ),
-                    initialValue: _selectedLlmProvider,
-                    onChanged: _hfApiKeyController.text.isEmpty ? null : (String? newValue) {
-                      if (newValue != null) {
-                        // Prevent selecting non-builtin providers without HF API key
-                        if (_hfApiKeyController.text.isEmpty && newValue != 'builtin') {
-                          ScaffoldMessenger.of(context).showSnackBar(
-                            const SnackBar(
-                              content: Text('Please provide a Hugging Face API key to use external providers'),
-                              backgroundColor: Colors.orange,
-                            ),
-                          );
-                          return;
-                        }
+                    value: _isBuiltInModelSelected ? 'built-in' : _selectedCuratedModel?.modelId,
+                    onChanged: (String? newValue) async {
+                      if (newValue == 'built-in') {
                         setState(() {
-                          _selectedLlmProvider = newValue;
-                          // Reset model when provider changes
-                          if (newValue == 'builtin') {
-                            _selectedLlmModel = 'default';
-                          } else {
-                            _selectedLlmModel = _getModelsForProvider(newValue).first.value!;
-                          }
+                          _isBuiltInModelSelected = true;
+                          _selectedLlmModel = 'built-in';
+                          _selectedLlmProvider = 'built-in';
+                          _selectedCuratedModel = null;
+                          _currentProvider = null;
                         });
-                        _settingsService.setLlmProvider(newValue);
-                        _settingsService.setLlmModel(_selectedLlmModel);
-                      }
-                    },
-                    items: const [
-                      DropdownMenuItem(
-                        value: 'builtin',
-                        child: Text('Built-in (free, slow)'),
-                      ),
-                      DropdownMenuItem(
-                        value: 'openai',
-                        child: Text('OpenAI'),
-                      ),
-                      DropdownMenuItem(
-                        value: 'anthropic',
-                        child: Text('Anthropic'),
-                      ),
-                      DropdownMenuItem(
-                        value: 'google',
-                        child: Text('Google'),
-                      ),
-                      DropdownMenuItem(
-                        value: 'cohere',
-                        child: Text('Cohere'),
-                      ),
-                      DropdownMenuItem(
-                        value: 'together',
-                        child: Text('Together AI'),
-                      ),
-                      DropdownMenuItem(
-                        value: 'huggingface',
-                        child: Text('Hugging Face'),
-                      ),
-                    ],
-                  ),
-                  const SizedBox(height: 16),
-                  DropdownButtonFormField<String>(
-                    decoration: InputDecoration(
-                      labelText: 'LLM Model',
-                      helperText: _hfApiKeyController.text.isEmpty 
-                          ? 'Using default built-in model' 
-                          : 'Select the model to use',
-                    ),
-                    initialValue: _selectedLlmModel,
-                    onChanged: _hfApiKeyController.text.isEmpty ? null : (String? newValue) {
-                      if (newValue != null) {
+                        await _settingsService.setLlmModel('built-in');
+                        await _settingsService.setLlmProvider('built-in');
+                      } else if (newValue != null) {
+                        final newModel = _curatedModels.firstWhere(
+                          (model) => model.modelId == newValue,
+                        );
                         setState(() {
-                          _selectedLlmModel = newValue;
+                          _isBuiltInModelSelected = false;
+                          _selectedCuratedModel = newModel;
+                          _selectedLlmModel = newModel.modelId;
+                          // Reset to first available provider if we had built-in selected
+                          if (_selectedLlmProvider == 'built-in') {
+                            _selectedLlmProvider = _availableProviders.isNotEmpty ? _availableProviders.first.id : 'hf-inference';
+                            _currentProvider = LLMProvider.getById(_selectedLlmProvider);
+                          }
                         });
-                        _settingsService.setLlmModel(newValue);
+                        await _settingsService.setLlmModel(newModel.modelId);
+                        if (_selectedLlmProvider != 'built-in') {
+                          await _settingsService.setLlmProvider(_selectedLlmProvider);
+                        }
+                        // Check availability after model change
+                        _checkModelAvailability();
                       }
                     },
-                    items: _getModelsForProvider(_selectedLlmProvider),
-                  ),
-                  const SizedBox(height: 16),
-                  TextField(
-                    controller: _llmApiKeyController,
-                    decoration: InputDecoration(
-                      labelText: _getLlmApiKeyLabel(),
-                      helperText: _hfApiKeyController.text.isEmpty 
-                          ? 'Enter HF API key above to enable provider options' 
-                          : 'Optional - will use your HF API key if not provided',
-                      helperMaxLines: 2,
-                    ),
-                    obscureText: true,
-                    enabled: _hfApiKeyController.text.isNotEmpty,
-                    onChanged: (value) async {
-                      await _settingsService.setLlmApiKey(value);
+                    selectedItemBuilder: (BuildContext context) {
+                      final allItems = <String>['built-in', ..._curatedModels.map((m) => m.modelId)];
+                      return allItems.map((itemValue) {
+                        if (itemValue == 'built-in') {
+                          return const Row(
+                            children: [
+                              Text('🏠'),
+                              SizedBox(width: 8),
+                              Expanded(
+                                child: Text(
+                                  'Built-in (default, free)',
+                                  style: TextStyle(
+                                    fontWeight: FontWeight.w500,
+                                  ),
+                                  overflow: TextOverflow.ellipsis,
+                                ),
+                              ),
+                            ],
+                          );
+                        } else {
+                          final model = _curatedModels.firstWhere((m) => m.modelId == itemValue);
+                          return Row(
+                            children: [
+                              Text(model.speedEmoji),
+                              const SizedBox(width: 8),
+                              Expanded(
+                                child: Text(
+                                  model.displayName,
+                                  style: const TextStyle(
+                                    fontWeight: FontWeight.w500,
+                                  ),
+                                  overflow: TextOverflow.ellipsis,
+                                ),
+                              ),
+                            ],
+                          );
+                        }
+                      }).toList();
                     },
+                    items: _hfApiKeyController.text.isNotEmpty
+                        ? [
+                            // Scenario 1: HF API key provided - show all models including built-in
+                            const DropdownMenuItem<String>(
+                              value: 'built-in',
+                              child: Column(
+                                crossAxisAlignment: CrossAxisAlignment.start,
+                                mainAxisSize: MainAxisSize.min,
+                                children: [
+                                  Row(
+                                    children: [
+                                      Text('🏠'),
+                                      SizedBox(width: 8),
+                                      Expanded(
+                                        child: Text(
+                                          'Built-in (default, free)',
+                                          style: TextStyle(
+                                            fontWeight: FontWeight.w500,
+                                          ),
+                                        ),
+                                      ),
+                                    ],
+                                  ),
+                                  Padding(
+                                    padding: EdgeInsets.only(left: 24),
+                                    child: Text(
+                                      'Slow and unreliable',
+                                      style: TextStyle(
+                                        fontSize: 12,
+                                        color: Colors.grey,
+                                      ),
+                                    ),
+                                  ),
+                                ],
+                              ),
+                            ),
+                            ..._curatedModels.map((model) {
+                              return DropdownMenuItem<String>(
+                                value: model.modelId,
+                                child: Column(
+                                  crossAxisAlignment: CrossAxisAlignment.start,
+                                  mainAxisSize: MainAxisSize.min,
+                                  children: [
+                                    Row(
+                                      children: [
+                                        Text(model.speedEmoji),
+                                        const SizedBox(width: 8),
+                                        Expanded(
+                                          child: Text(
+                                            model.displayName,
+                                            style: const TextStyle(
+                                              fontWeight: FontWeight.w500,
+                                            ),
+                                          ),
+                                        ),
+                                      ],
+                                    ),
+                                    Padding(
+                                      padding: const EdgeInsets.only(left: 24),
+                                      child: Text(
+                                        '${model.numOfParameters} • ${model.speedCategory}',
+                                        style: TextStyle(
+                                          fontSize: 12,
+                                          color: Colors.grey[600],
+                                        ),
+                                      ),
+                                    ),
+                                  ],
+                                ),
+                              );
+                            }),
+                          ]
+                        : [
+                            // Scenario 2: No HF API key - only show built-in and disabled message
+                            const DropdownMenuItem<String>(
+                              value: 'built-in',
+                              child: Column(
+                                crossAxisAlignment: CrossAxisAlignment.start,
+                                mainAxisSize: MainAxisSize.min,
+                                children: [
+                                  Row(
+                                    children: [
+                                      Text('🏠'),
+                                      SizedBox(width: 8),
+                                      Expanded(
+                                        child: Text(
+                                          'Built-in (default, free)',
+                                          style: TextStyle(
+                                            fontWeight: FontWeight.w500,
+                                          ),
+                                        ),
+                                      ),
+                                    ],
+                                  ),
+                                  Padding(
+                                    padding: EdgeInsets.only(left: 24),
+                                    child: Text(
+                                      'Slow and unreliable',
+                                      style: TextStyle(
+                                        fontSize: 12,
+                                        color: Colors.grey,
+                                      ),
+                                    ),
+                                  ),
+                                ],
+                              ),
+                            ),
+                            const DropdownMenuItem<String>(
+                              value: null,
+                              enabled: false,
+                              child: Padding(
+                                padding: EdgeInsets.symmetric(vertical: 8.0),
+                                child: Text(
+                                  'To use other models you need a HF API key',
+                                  style: TextStyle(
+                                    color: Colors.grey,
+                                    fontStyle: FontStyle.italic,
+                                  ),
+                                ),
+                              ),
+                            ),
+                          ],
                   ),
+                  if (!_isBuiltInModelSelected) ...[                  
+                    const SizedBox(height: 16),
+                    DropdownButtonFormField<String>(
+                      decoration: InputDecoration(
+                        labelText: 'LLM Provider',
+                        helperText: _hfApiKeyController.text.isEmpty 
+                            ? 'Enter HF API key to unlock providers' 
+                            : _isCheckingAvailability
+                                ? 'Checking model availability...'
+                                : 'Select from available providers for this model',
+                        helperMaxLines: 2,
+                      ),
+                      value: _selectedLlmProvider == 'built-in' ? null : _selectedLlmProvider,
+                      onChanged: _hfApiKeyController.text.isEmpty ? null : (String? newValue) {
+                        if (newValue != null) {
+                          // Check if provider is available for this model
+                          final provider = _availableProviders.firstWhere(
+                            (p) => p.id == newValue,
+                            orElse: () => _availableProviders.first,
+                          );
+                          
+                          if (!provider.isAvailable) {
+                            ScaffoldMessenger.of(context).showSnackBar(
+                              SnackBar(
+                                content: Text('${provider.name} does not support this model'),
+                                backgroundColor: Colors.orange,
+                              ),
+                            );
+                            return;
+                          }
+                          
+                          setState(() {
+                            _selectedLlmProvider = newValue;
+                            _currentProvider = provider;
+                          });
+                          _settingsService.setLlmProvider(newValue);
+                        }
+                      },
+                      items: _availableProviders.map((provider) {
+                        final isAvailable = provider.isAvailable;
+                        return DropdownMenuItem(
+                          value: provider.id,
+                          enabled: isAvailable,
+                          child: Row(
+                            children: [
+                              Expanded(
+                                child: Text(
+                                  provider.name,
+                                  style: TextStyle(
+                                    color: isAvailable ? null : Colors.grey,
+                                  ),
+                                ),
+                              ),
+                              if (!isAvailable)
+                                const Icon(
+                                  Icons.lock,
+                                  size: 16,
+                                  color: Colors.grey,
+                                ),
+                            ],
+                          ),
+                        );
+                      }).toList(),
+                    ),
+                  ],
+                  /*
+                  The Hugging Face Inference Providers allow the user to either use their HF API key,
+                  which will bill them automatically on the HF account, or pass a provider-specific
+                  API key, which will bill them on their provider account.
+
+                  This is a nice feature, but for now let's just use the transparent/automatic billing.
+
+                  So I've disabled this whole section:
+                  
+                  if (!_isBuiltInModelSelected) ...[                  
+                    const SizedBox(height: 16),
+                    TextField(
+                      controller: _llmApiKeyController,
+                      decoration: InputDecoration(
+                        labelText: _currentProvider?.apiKeyLabel ?? 'API Key',
+                        helperText: _hfApiKeyController.text.isEmpty 
+                            ? 'Enter HF API key above to enable provider options' 
+                            : _currentProvider?.supportsHuggingFaceKey == true
+                                ? 'Your HF API key will be automatically used for this provider'
+                                : 'Optional - provider-specific API key',
+                        helperMaxLines: 2,
+                      ),
+                      obscureText: true,
+                      enabled: _hfApiKeyController.text.isNotEmpty && 
+                               _currentProvider?.supportsHuggingFaceKey == false,
+                      onChanged: (value) async {
+                        await _settingsService.setLlmApiKey(value);
+                      },
+                    ),
+                  ],
+                  */
                 ],
               ),
             ),
@@ -384,74 +723,5 @@ class _SettingsScreenState extends State<SettingsScreen> {
     );
   }
 
-  List<DropdownMenuItem<String>> _getModelsForProvider(String provider) {
-    switch (provider) {
-      case 'builtin':
-        return const [
-          DropdownMenuItem(value: 'default', child: Text('Default Model')),
-        ];
-      case 'openai':
-        return const [
-          DropdownMenuItem(value: 'gpt-4', child: Text('GPT-4')),
-          DropdownMenuItem(value: 'gpt-4-turbo', child: Text('GPT-4 Turbo')),
-          DropdownMenuItem(value: 'gpt-3.5-turbo', child: Text('GPT-3.5 Turbo')),
-        ];
-      case 'anthropic':
-        return const [
-          DropdownMenuItem(value: 'claude-3-opus', child: Text('Claude 3 Opus')),
-          DropdownMenuItem(value: 'claude-3-sonnet', child: Text('Claude 3 Sonnet')),
-          DropdownMenuItem(value: 'claude-3-haiku', child: Text('Claude 3 Haiku')),
-        ];
-      case 'google':
-        return const [
-          DropdownMenuItem(value: 'gemini-1.5-pro', child: Text('Gemini 1.5 Pro')),
-          DropdownMenuItem(value: 'gemini-1.5-flash', child: Text('Gemini 1.5 Flash')),
-          DropdownMenuItem(value: 'gemini-pro', child: Text('Gemini Pro')),
-        ];
-      case 'cohere':
-        return const [
-          DropdownMenuItem(value: 'command-r-plus', child: Text('Command R Plus')),
-          DropdownMenuItem(value: 'command-r', child: Text('Command R')),
-          DropdownMenuItem(value: 'command', child: Text('Command')),
-        ];
-      case 'together':
-        return const [
-          DropdownMenuItem(value: 'meta-llama/Llama-3.2-3B-Instruct', child: Text('Llama 3.2 3B')),
-          DropdownMenuItem(value: 'mistralai/Mixtral-8x7B-Instruct-v0.1', child: Text('Mixtral 8x7B')),
-          DropdownMenuItem(value: 'deepseek-ai/deepseek-coder', child: Text('DeepSeek Coder')),
-        ];
-      case 'huggingface':
-        return const [
-          DropdownMenuItem(value: 'HuggingFaceTB/SmolLM3-3B', child: Text('SmolLM3 3B')),
-          DropdownMenuItem(value: 'meta-llama/Llama-3.2-3B-Instruct', child: Text('Llama 3.2 3B')),
-          DropdownMenuItem(value: 'microsoft/Phi-3-mini-4k-instruct', child: Text('Phi-3 Mini')),
-        ];
-      default:
-        return const [
-          DropdownMenuItem(value: 'default', child: Text('Default Model')),
-        ];
-    }
-  }
-
-  String _getLlmApiKeyLabel() {
-    switch (_selectedLlmProvider) {
-      case 'builtin':
-        return 'API Key (Not required for built-in)';
-      case 'openai':
-        return 'OpenAI API Key';
-      case 'anthropic':
-        return 'Anthropic API Key';
-      case 'google':
-        return 'Google AI API Key';
-      case 'cohere':
-        return 'Cohere API Key';
-      case 'together':
-        return 'Together AI API Key';
-      case 'huggingface':
-        return 'Hugging Face API Key';
-      default:
-        return 'API Key';
-    }
-  }
 
 }

lib/services/model_availability_service.dart

@@ -0,0 +1,239 @@
+import 'dart:convert';
+import 'package:http/http.dart' as http;
+
+/// Represents the availability status of a model for a specific provider
+class ModelProviderAvailability {
+  final String providerId;
+  final String status; // 'live' or 'staging'
+  final String task; // e.g., 'conversational'
+  final String? mappedLLMProviderId; // Our internal provider ID
+
+  const ModelProviderAvailability({
+    required this.providerId,
+    required this.status,
+    required this.task,
+    this.mappedLLMProviderId,
+  });
+
+  bool get isLive => status == 'live';
+
+  factory ModelProviderAvailability.fromJson(
+    String hfProviderId,
+    Map<String, dynamic> json,
+  ) {
+    return ModelProviderAvailability(
+      providerId: json['providerId'] ?? hfProviderId,
+      status: json['status'] ?? 'unknown',
+      task: json['task'] ?? 'unknown',
+    );
+  }
+}
+
+/// Cached model availability information
+class ModelAvailabilityCache {
+  final String modelId;
+  final List<ModelProviderAvailability> providers;
+  final DateTime lastUpdated;
+
+  const ModelAvailabilityCache({
+    required this.modelId,
+    required this.providers,
+    required this.lastUpdated,
+  });
+
+  bool get isExpired {
+    final now = DateTime.now();
+    final difference = now.difference(lastUpdated);
+    return difference.inSeconds > 30; // 30 seconds cache duration
+  }
+
+  List<ModelProviderAvailability> get liveProviders =>
+      providers.where((p) => p.isLive).toList();
+}
+
+/// Service for querying and caching model availability from Hugging Face API
+class ModelAvailabilityService {
+  static const String _baseUrl = 'https://huggingface.co/api/models';
+
+  // Cache for model availability data
+  final Map<String, ModelAvailabilityCache> _cache = {};
+
+  /// Mapping from HF provider IDs to our internal LLM provider IDs
+  static const Map<String, String> _providerMapping = {
+    'cerebras': 'cerebras',
+    'cohere': 'cohere',
+    'fal-ai': 'fal-ai',
+    'featherless': 'featherless',
+    'fireworks': 'fireworks',
+    'groq': 'groq',
+    'hf-inference': 'hf-inference',
+    'hyperbolic': 'hyperbolic',
+    'nebius': 'nebius',
+    'novita': 'novita',
+    'nscale': 'nscale',
+    'replicate': 'replicate',
+    'sambanova': 'sambanova',
+    'together': 'together',
+  };
+
+  /// Get model availability, using cache if available and not expired
+  Future<ModelAvailabilityCache?> getModelAvailability(String modelId) async {
+    // Check cache first
+    final cached = _cache[modelId];
+    if (cached != null && !cached.isExpired) {
+      return cached;
+    }
+
+    // Fetch fresh data from API
+    try {
+      final availability = await _fetchModelAvailability(modelId);
+      if (availability != null) {
+        _cache[modelId] = availability;
+      }
+      return availability;
+    } catch (e) {
+      // If API call fails and we have cached data, return it even if expired
+      if (cached != null) {
+        return cached;
+      }
+      rethrow;
+    }
+  }
+
+  /// Fetch model availability from Hugging Face API
+  Future<ModelAvailabilityCache?> _fetchModelAvailability(
+    String modelId,
+  ) async {
+    final url = '$_baseUrl/$modelId?expand[]=inferenceProviderMapping';
+
+    try {
+      final response = await http.get(
+        Uri.parse(url),
+        headers: {'Accept': 'application/json', 'User-Agent': '#tikslop-App/1.0'},
+      );
+
+      if (response.statusCode == 200) {
+        final data = json.decode(response.body) as Map<String, dynamic>;
+        return _parseModelAvailability(modelId, data);
+      } else if (response.statusCode == 404) {
+        // Model not found, return empty availability
+        return ModelAvailabilityCache(
+          modelId: modelId,
+          providers: [],
+          lastUpdated: DateTime.now(),
+        );
+      } else {
+        throw ModelAvailabilityException(
+          'Failed to fetch model availability: HTTP ${response.statusCode}',
+        );
+      }
+    } catch (e) {
+      if (e is ModelAvailabilityException) {
+        rethrow;
+      }
+      throw ModelAvailabilityException('Network error: $e');
+    }
+  }
+
+  /// Parse the API response into ModelAvailabilityCache
+  ModelAvailabilityCache _parseModelAvailability(
+    String modelId,
+    Map<String, dynamic> data,
+  ) {
+    final providers = <ModelProviderAvailability>[];
+
+    final inferenceMapping =
+        data['inferenceProviderMapping'] as Map<String, dynamic>?;
+    if (inferenceMapping != null) {
+      for (final entry in inferenceMapping.entries) {
+        final hfProviderId = entry.key;
+        final providerData = entry.value as Map<String, dynamic>;
+
+        final availability = ModelProviderAvailability.fromJson(
+          hfProviderId,
+          providerData,
+        );
+
+        // Map HF provider ID to our internal provider ID
+        final mappedProviderId = _providerMapping[hfProviderId];
+        if (mappedProviderId != null) {
+          providers.add(
+            ModelProviderAvailability(
+              providerId: availability.providerId,
+              status: availability.status,
+              task: availability.task,
+              mappedLLMProviderId: mappedProviderId,
+            ),
+          );
+        } else {
+          // Keep unmapped providers for potential future use
+          providers.add(availability);
+        }
+      }
+    }
+
+    return ModelAvailabilityCache(
+      modelId: modelId,
+      providers: providers,
+      lastUpdated: DateTime.now(),
+    );
+  }
+
+  /// Get list of compatible LLM providers for a model
+  List<String> getCompatibleProviders(String modelId) {
+    final cached = _cache[modelId];
+    if (cached == null) {
+      return [];
+    }
+
+    return cached.liveProviders
+        .where((p) => p.mappedLLMProviderId != null)
+        .map((p) => p.mappedLLMProviderId!)
+        .toList();
+  }
+
+  /// Check if a specific provider supports a model
+  bool isProviderCompatible(String modelId, String llmProviderId) {
+    final compatibleProviders = getCompatibleProviders(modelId);
+    return compatibleProviders.contains(llmProviderId);
+  }
+
+  /// Get the provider-specific model name for a given model and provider
+  String? getProviderSpecificModelName(String modelId, String llmProviderId) {
+    final cached = _cache[modelId];
+    if (cached == null) {
+      return null;
+    }
+
+    final providerAvailability = cached.liveProviders
+        .where((p) => p.mappedLLMProviderId == llmProviderId)
+        .firstOrNull;
+
+    return providerAvailability?.providerId;
+  }
+
+  /// Clear cache for a specific model
+  void clearCache(String modelId) {
+    _cache.remove(modelId);
+  }
+
+  /// Clear all cached data
+  void clearAllCache() {
+    _cache.clear();
+  }
+
+  /// Get cache status for debugging
+  Map<String, bool> getCacheStatus() {
+    return _cache.map((key, value) => MapEntry(key, !value.isExpired));
+  }
+}
+
+/// Exception thrown when model availability operations fail
+class ModelAvailabilityException implements Exception {
+  final String message;
+
+  ModelAvailabilityException(this.message);
+
+  @override
+  String toString() => 'ModelAvailabilityException: $message';
+}

lib/services/settings_service.dart

@@ -61,14 +61,14 @@ class SettingsService {
     _settingsController.add(null);
   }
 
-  String get llmProvider => _prefs.getString(_llmProviderKey) ?? 'openai';
+  String get llmProvider => _prefs.getString(_llmProviderKey) ?? 'built-in';
   
   Future<void> setLlmProvider(String provider) async {
     await _prefs.setString(_llmProviderKey, provider);
     _settingsController.add(null);
   }
 
-  String get llmModel => _prefs.getString(_llmModelKey) ?? 'gpt-4';
+  String get llmModel => _prefs.getString(_llmModelKey) ?? 'meta-llama/Llama-3.2-3B-Instruct';
   
   Future<void> setLlmModel(String model) async {
     await _prefs.setString(_llmModelKey, model);