- New --flash flag enables Flash Attention 2 installation
- Works with nvidia and all backends (when CUDA available)
- Installs with --no-build-isolation flag
- Graceful error handling if installation fails
- Updated usage instructions to show --flash-attn flag
- Requirements: CUDA 11.6+, Linux, Ampere/Ada/Hopper GPU

- Complete overview of refactoring work
- Architecture before/after comparison
- List of all commits and changes
- Installation and usage instructions
- Configuration examples
- Testing checklist and known limitations
- Next steps for future work

- Added PIP_NO_INPUT and PIP_REQUIRE_VIRTUALENV environment variables
- Better error handling for problematic packages (procname, stable-diffusion-cpp-python)
- Install core dependencies first, then optional packages individually
- Graceful fallback when optional packages fail to build
- Updated PyTorch installation to handle version compatibility
- Clear warnings for optional packages that fail (not critical errors)

- Removed version pins from stable-diffusion-cpp-python and procname
- Both packages have build issues with strict version requirements on Python 3.13
- Allowing pip to find compatible versions automatically

- Changed whispercpp from >=1.0.0 to >=0.0.6
- Package only has versions 0.0.x available, no 1.0.0 exists yet

- Updated torch requirement from ==2.0.0 to >=2.5.0
- Python 3.13 requires torch 2.5.0 or newer
- Added torchvision and torchaudio without version pins

- Updated main.py to use ConfigManager for loading settings
- Models now loaded from config instead of CLI arguments
- Admin dashboard routes integrated into FastAPI app
- Added admin API endpoints for tokens management
- Added admin models management endpoints
- System config reload endpoint
- Static files mounted at /static/admin
- Admin UI available at /admin

- Implement SessionManager with cookie-based authentication
- Create admin routes with login, logout, password change
- Add dashboard, models, tokens, users, and chat pages
- Implement dark theme CSS with modern design
- Add user management (create, delete users)
- Add API token management placeholders
- Session-based auth with CSRF protection
- Password hashing with argon2 fallback
- Jinja2 templates for all admin pages

- Refactor cli.py to only support --debug and --config options
- Create ConfigManager class for loading/saving JSON configs
- Implement per-model configuration approach in models.json
- Create comprehensive design document for admin dashboard
- Set up admin package structure
- All model-specific settings now stored per-model instead of global defaults

- Add offload_strategy to kwargs in _load_default_model and _load_model_by_name
- Fix parameter name: ram -> manual_ram_gb to match backend expectation
- Also pass load_in_4bit, load_in_8bit, and max_gpu_percent

- Add 'none' to --offload-strategy choices in cli.py
- In cuda.py backend:
  - _get_vram_percentages_for_strategy() returns None for 'none' strategy
  - _get_vram_percentages_for_gpu() skips VRAM detection for 'none'
  - load_model() loads directly on GPU without max_memory constraints
- Add startup status message in main.py for --offload-strategy none

- Add --no-ram CLI option to force model loading without CPU RAM spilling
- Implement --no-ram behavior for:
  - llama-cpp-python: n_gpu_layers=-1, use_mmap=False, ignore --n-ctx
  - HuggingFace transformers: device_map='cuda:0', low_cpu_mem_usage=True
  - Diffusers: force full GPU loading
  - sd.cpp: maximize GPU usage
- Propagate flag through model manager
- Add startup banner message

- Add get_all_allowed_identifiers() to MultiModelManager returning all valid
  model identifiers (default model + short name + aliases, audio, tts, image,
  vision models, and custom aliases)
- Rewrite is_allowed_model() to check against the full allowed set with
  support for prefixed forms and short-name matching
- Add validation in request_model() that rejects unknown models with an error
  message listing all available models
- Fix get_model_for_request() to reject loading arbitrary models not in the
  allowed set
- Update all API endpoints (text, images, tts, transcriptions) to check for
  the error key and return HTTP 404 when a disallowed model is requested

- Try GGUF pattern first for HuggingFace model IDs
- Fall back to snapshot_download for entire repo (transformers/diffusers models)
- Works for both GGUF models and full HuggingFace repos

- Remove auto-detection logic, just use download_model from cache
- User can specify --download-file-pattern for non-GGUF models

- Scan HuggingFace repo to detect available file patterns
- Try multiple patterns (.gguf, .safetensors, .bin, .pt, .pth)
- Default to .gguf if nothing found

- Add --download-model argument to download a model (URL or HuggingFace ID) to cache
- Add --download-file-pattern argument to specify file pattern for HF downloads
- Use download_model from codai.models.cache module
- Model downloads to appropriate cache and exits without starting server

text.py's set_global_args() was only setting its local global_args but
not calling state.set_global_args(). This meant _load_default_model()
and _load_model_by_name() got None from get_global_args(), so CLI flags
like --flash-attn, --n-gpu-layers, --ram were not passed to backends.

- Add flash_attn extraction from global_args in _load_default_model()
- Add flash_attn extraction from global_args in _load_model_by_name()
- Now --flash-attn flag will properly enable Flash Attention 2 when loading models

- ModelParserDispatcher: Only log parser selection when actually used for parsing
- ModelParserAdapter: Defer dispatcher creation until first use
- Fixes noisy 'model_name=None, selected parser: ApexBig50Parser' during initialization

- loadall: pre-load image models into VRAM at startup (with OOM fallback)
- loadswap: pre-load image models into CPU RAM at startup (first model stays in VRAM)
- Audio and TTS models are cached at startup, loaded into memory on first request
  (they use specialized loading mechanisms via faster-whisper and kokoro)

- Default mode changed to ondemand (pre-load first model, unload/load on switch)
- loadswap: load first model in VRAM, others in CPU RAM, swap on switch
- loadall: try to load all models in VRAM, offload to CPU RAM if OOM
- --nopreload: skip pre-loading in any mode, load on first request
- request_model() now properly handles all three modes
- Added _move_model_to_cpu() and _move_model_to_vram() for loadswap
- Fixed NameError: model_manager reference in request_model() (was using global singleton instead of self)
- Updated CLI help text for --loadall, --loadswap, --nopreload

- Added request_model() method to MultiModelManager that handles:
  1. Alias resolution (image, audio, tts, vision, default, custom aliases)
  2. VRAM management (unloading previous models in ondemand mode)
  3. Checking if model is already loaded

- Simplified codai/api/images.py:
  - Uses request_model() for model resolution and VRAM management
  - Extracted helper functions: _is_gguf_model(), _load_diffusers_pipeline(),
    _generate_with_diffusers(), _generate_with_sdcpp(), _load_sdcpp_model()
  - Removed duplicated sd.cpp generation code
  - Fixed semaphore scope (all generation now inside semaphore block)

- Simplified codai/api/tts.py:
  - Uses request_model() instead of duplicated VRAM management code
  - Removed duplicate get_cached_model_path() and get_model_cache_dir() wrappers

- Simplified codai/api/transcriptions.py:
  - Uses request_model() instead of duplicated VRAM management code

- Simplified codai/api/text.py:
  - Both /v1/chat/completions and /v1/completions use request_model()
  - Removed duplicated VRAM management blocks

- **Model Manager**: Central coordinator for model lifecycle, alias resolution, loading/unloading
- **Cache Module**: Handles downloading, caching, and storage of models
- **API Modules**: Request models from Model Manager (not directly from cache)

Key changes:
- Removed resolve_and_load_model() from cache - moved logic to Model Manager
- Model Manager now downloads/caches models at startup when registered
- API modules use multi_model_manager.load_model() instead of cache functions
- Proper separation: Cache=storage, Manager=lifecycle coordination, APIs=requests

This fixes the incorrect direct API-to-cache coupling and establishes proper architectural boundaries.

- Added resolve_and_load_model() function to codai.models.cache
- Simplified codai/api/images.py by removing 100+ lines of complex model resolution logic
- API modules now use single centralized function for all model loading
- Eliminates code duplication across API endpoints
- All model resolution logic now managed in one place

- Added check in sd.cpp fallback to skip HF model IDs that are likely diffusers models
- Prevents sd.cpp from trying to download non-GGUF files like .gitattributes for diffusers models
- Tongyi-MAI/Z-Image-Turbo and similar diffusers models now handled correctly by diffusers library
- GGUF models still work with sd.cpp as before

- Updated codai/api/images.py to use cache module functions directly
- Updated codai/api/tts.py to use centralized load_model() function
- Removed proxy method calls that were causing AttributeError
- All model loading/downloading now goes through codai.models.cache

- Updated load_model() to handle three input types:
  1. Local files: Use directly without caching
  2. URLs: Download to cache if not cached, then use
  3. HF model IDs: Download via HF API if not cached, then use
- Updated get_cached_model_path() to validate local files
- Enhanced module documentation to reflect new capabilities
- All model types (text, image, audio, etc.) can now use any input type

- Updated remove_cached_model() to remove entire repo directories when matching by repo_id
- Previously only removed individual files, now removes complete repository cache
- Handles both files and directories in removal process
- More thorough cleanup of HuggingFace cached models

- Added unified load_model() function as main entry point for model loading
- Updated WhisperServerManager to use centralized load_model() instead of inline logic
- Removed proxy methods from MultiModelManager - use cache module directly
- All cache functions now work seamlessly with both GGUF and HF model caches
- Improved separation of concerns: cache module handles all caching/downloading

- Updated get_cached_model_path() to check both coderai and HF caches
- Updated download_model() to handle both URLs and HF model IDs automatically
- Made download_huggingface_model() consistent with unified API
- Updated module docstring to reflect unified cache functionality
- All cache functions now work seamlessly with both cache types

- Updated remove_cached_model() to search by repo_id for HuggingFace models
- Moved cache management options (--list-cached-models, --remove-model, --remove-all-models) to run before heavy imports
- Improved cache operations to use centralized functions in codai.models.cache module
- Fixed model removal to work with full repo IDs like 'TheBloke/Llama-2-7B-GGUF'

- Add list_cached_models_info() function to codai.models.cache module
- Move cache listing logic from main.py to the cache module
- Update main.py to use the centralized function early (before heavy imports)
- Improves code organization and avoids unnecessary imports for --list-cached-models

- CoderAI cache: Shows individual GGUF files with sizes
- HuggingFace cache: Uses HF API (scan_cache_dir) to show model-level info, not individual files
- Shows model names, sizes, revision counts - not thousands of individual files
- Much more useful and readable output

- Added code to print individual cached model files with sizes
- Previously only showed cache directory headers and summary
- Now shows each file with format: [cache_name] filename (size MB)
- Matches the format used by --remove-model command

- Updated get_all_cache_dirs() to properly find HuggingFace hub directory
- Now checks for ~/.cache/huggingface/hub/ instead of just ~/.cache/huggingface/
- This fixes --list-cached-models not showing HuggingFace cached models

- Removed the GGUF-only restriction on sd.cpp fallback
- Some HF models may be GGUF even without 'gguf' in the name
- Let sd.cpp attempt loading and fail gracefully if incompatible
- This allows sd.cpp to work as a proper fallback for any model type

- Added check to only attempt sd.cpp fallback for GGUF models
- Tongyi-MAI/Z-Image-Turbo is a diffusers model, not GGUF, so sd.cpp should be skipped
- sd.cpp only supports GGUF models, diffusers models use the diffusers pipeline
- This prevents unnecessary sd.cpp resolution attempts for incompatible model types