abstractcore 2.9.1__py3-none-any.whl → 2.11.4__py3-none-any.whl

abstractcore/config/manager.py

@@ -25,6 +25,48 @@ class VisionConfig:
             self.fallback_chain = []
 
 
+@dataclass
+class AudioConfig:
+    """Audio configuration settings (input policy + optional fallback)."""
+    # Default: do not silently change semantics. Allow native audio when supported,
+    # otherwise error unless the caller explicitly requests STT/caption.
+    strategy: str = "native_only"  # native_only|speech_to_text|caption|auto
+    # Optional preferred STT backend (capabilities plugin backend_id).
+    stt_backend_id: Optional[str] = None
+    stt_language: Optional[str] = None
+    # Reserved for future "audio caption" backends.
+    caption_provider: Optional[str] = None
+    caption_model: Optional[str] = None
+    fallback_chain: list = None
+
+    def __post_init__(self):
+        if self.fallback_chain is None:
+            self.fallback_chain = []
+
+
+@dataclass
+class VideoConfig:
+    """Video configuration settings (input policy + optional fallback)."""
+    # Default: best-effort usability. Prefer native video when supported; otherwise fall back
+    # to sampled frames routed through existing image/vision handling.
+    strategy: str = "auto"  # native_only|frames_caption|auto
+
+    # Frame sampling controls for frames-based fallback.
+    max_frames: int = 3
+    # Native video models typically require more temporal coverage than the fallback path.
+    # This default is used when the selected model supports native video input (v0: HF only).
+    max_frames_native: int = 8
+    frame_format: str = "jpg"  # jpg|png
+    sampling_strategy: str = "uniform"  # uniform|keyframes
+
+    # Downscale extracted frames (preserve aspect ratio; never upscale). Helps memory + token pressure.
+    # Applies to both frames_caption fallback and HF native video ingestion (which uses ffmpeg frames).
+    max_frame_side: int = 1024
+
+    # Maximum video size allowed for processing (bytes). None => use media handler defaults.
+    max_video_size_bytes: Optional[int] = None
+
+
 @dataclass
 class EmbeddingsConfig:
     """Embeddings configuration settings."""
@@ -47,6 +89,44 @@ class AppDefaults:
     intent_model: Optional[str] = "unsloth/Qwen3-4B-Instruct-2507-GGUF"
 
 
+@dataclass
+class MaintenanceConfig:
+    """Maintenance agent configuration (triage, stewardship)."""
+
+    # LLM assist (optional, local-first).
+    triage_llm_enabled: bool = False
+    triage_llm_base_url: str = "http://localhost:1234"
+    triage_llm_model: str = "qwen/qwen3-next-80b"
+    triage_llm_temperature: float = 0.2
+    triage_llm_max_tokens: int = 800
+    triage_llm_timeout_s: float = 30.0
+
+
+@dataclass
+class EmailConfig:
+    """Email defaults (SMTP outbound + IMAP inbound).
+
+    These defaults are used by framework-native comms tools and gateway bridges when
+    explicit parameters are omitted (env vars still take precedence).
+    """
+
+    # SMTP (outbound)
+    smtp_host: str = ""
+    smtp_port: int = 587
+    smtp_username: str = ""
+    smtp_password_env_var: str = "EMAIL_PASSWORD"
+    smtp_use_starttls: bool = True
+    from_email: Optional[str] = None
+    reply_to: Optional[str] = None
+
+    # IMAP (inbound)
+    imap_host: str = ""
+    imap_port: int = 993
+    imap_username: str = ""
+    imap_password_env_var: str = "EMAIL_PASSWORD"
+    imap_folder: str = "INBOX"
+
+
 @dataclass
 class DefaultModels:
     """Global default model configurations."""
@@ -61,6 +141,7 @@ class ApiKeysConfig:
     """API keys configuration."""
     openai: Optional[str] = None
     anthropic: Optional[str] = None
+    openrouter: Optional[str] = None
     google: Optional[str] = None
 
 
@@ -76,7 +157,7 @@ class CacheConfig:
 @dataclass
 class LoggingConfig:
     """Logging configuration settings."""
-    console_level: str = "WARNING"
+    console_level: str = "ERROR"
     file_level: str = "DEBUG"
     file_logging_enabled: bool = False
     log_base_dir: Optional[str] = None
@@ -85,6 +166,12 @@ class LoggingConfig:
     file_json: bool = True
 
 
+@dataclass
+class StreamingConfig:
+    """Streaming configuration settings."""
+    cli_stream_default: bool = False
+
+
 @dataclass
 class TimeoutConfig:
     """Timeout configuration settings."""
@@ -106,28 +193,38 @@ class OfflineConfig:
 class AbstractCoreConfig:
     """Main configuration class."""
     vision: VisionConfig
+    audio: AudioConfig
+    video: VideoConfig
     embeddings: EmbeddingsConfig
     app_defaults: AppDefaults
     default_models: DefaultModels
     api_keys: ApiKeysConfig
     cache: CacheConfig
     logging: LoggingConfig
+    streaming: StreamingConfig
     timeouts: TimeoutConfig
     offline: OfflineConfig
+    maintenance: MaintenanceConfig
+    email: EmailConfig
 
     @classmethod
     def default(cls):
         """Create default configuration."""
         return cls(
             vision=VisionConfig(),
+            audio=AudioConfig(),
+            video=VideoConfig(),
             embeddings=EmbeddingsConfig(),
             app_defaults=AppDefaults(),
             default_models=DefaultModels(),
             api_keys=ApiKeysConfig(),
             cache=CacheConfig(),
             logging=LoggingConfig(),
+            streaming=StreamingConfig(),
             timeouts=TimeoutConfig(),
-            offline=OfflineConfig()
+            offline=OfflineConfig(),
+            maintenance=MaintenanceConfig(),
+            email=EmailConfig(),
         )
 
 
@@ -157,25 +254,35 @@ class ConfigurationManager:
         """Convert dictionary to config object."""
         # Create config objects from dictionary data
         vision = VisionConfig(**data.get('vision', {}))
+        audio = AudioConfig(**data.get('audio', {}))
+        video = VideoConfig(**data.get('video', {}))
         embeddings = EmbeddingsConfig(**data.get('embeddings', {}))
         app_defaults = AppDefaults(**data.get('app_defaults', {}))
         default_models = DefaultModels(**data.get('default_models', {}))
         api_keys = ApiKeysConfig(**data.get('api_keys', {}))
         cache = CacheConfig(**data.get('cache', {}))
         logging = LoggingConfig(**data.get('logging', {}))
+        streaming = StreamingConfig(**data.get('streaming', {}))
         timeouts = TimeoutConfig(**data.get('timeouts', {}))
         offline = OfflineConfig(**data.get('offline', {}))
+        maintenance = MaintenanceConfig(**data.get('maintenance', {}))
+        email_cfg = EmailConfig(**data.get('email', {}))
 
         return AbstractCoreConfig(
             vision=vision,
+            audio=audio,
+            video=video,
             embeddings=embeddings,
             app_defaults=app_defaults,
             default_models=default_models,
             api_keys=api_keys,
             cache=cache,
             logging=logging,
+            streaming=streaming,
             timeouts=timeouts,
-            offline=offline
+            offline=offline,
+            maintenance=maintenance,
+            email=email_cfg,
         )
 
     def _save_config(self):
@@ -185,14 +292,18 @@ class ConfigurationManager:
         # Convert config to dictionary
         config_dict = {
             'vision': asdict(self.config.vision),
+            'audio': asdict(self.config.audio),
+            'video': asdict(self.config.video),
             'embeddings': asdict(self.config.embeddings),
             'app_defaults': asdict(self.config.app_defaults),
             'default_models': asdict(self.config.default_models),
             'api_keys': asdict(self.config.api_keys),
             'cache': asdict(self.config.cache),
             'logging': asdict(self.config.logging),
+            'streaming': asdict(self.config.streaming),
             'timeouts': asdict(self.config.timeouts),
-            'offline': asdict(self.config.offline)
+            'offline': asdict(self.config.offline),
+            'maintenance': asdict(self.config.maintenance),
         }
 
         with open(self.config_file, 'w') as f:
@@ -242,6 +353,14 @@ class ConfigurationManager:
                 "caption_provider": self.config.vision.caption_provider,
                 "caption_model": self.config.vision.caption_model
             },
+            "video": {
+                "strategy": self.config.video.strategy,
+                "max_frames": self.config.video.max_frames,
+                "max_frames_native": getattr(self.config.video, "max_frames_native", None),
+                "frame_format": self.config.video.frame_format,
+                "sampling_strategy": getattr(self.config.video, "sampling_strategy", None),
+                "max_frame_side": getattr(self.config.video, "max_frame_side", None),
+            },
             "app_defaults": {
                 "cli": {
                     "provider": self.config.app_defaults.cli_provider,
@@ -276,7 +395,7 @@ class ConfigurationManager:
                 "model": self.config.embeddings.model
             },
             "streaming": {
-                "cli_stream_default": False  # Default value
+                "cli_stream_default": self.config.streaming.cli_stream_default
             },
             "logging": {
                 "console_level": self.config.logging.console_level,
@@ -288,11 +407,15 @@ class ConfigurationManager:
                 "tool_timeout": self.config.timeouts.tool_timeout
             },
             "cache": {
-                "default_cache_dir": self.config.cache.default_cache_dir
+                "default_cache_dir": self.config.cache.default_cache_dir,
+                "huggingface_cache_dir": self.config.cache.huggingface_cache_dir,
+                "local_models_cache_dir": self.config.cache.local_models_cache_dir,
+                "glyph_cache_dir": self.config.cache.glyph_cache_dir,
             },
             "api_keys": {
                 "openai": "✅ Set" if self.config.api_keys.openai else "❌ Not set",
                 "anthropic": "✅ Set" if self.config.api_keys.anthropic else "❌ Not set",
+                "openrouter": "✅ Set" if self.config.api_keys.openrouter else "❌ Not set",
                 "google": "✅ Set" if self.config.api_keys.google else "❌ Not set"
             },
             "offline": {
@@ -302,6 +425,16 @@ class ConfigurationManager:
             }
         }
 
+    def reset_configuration(self) -> bool:
+        """Reset all configuration to built-in defaults."""
+        try:
+            self.config = AbstractCoreConfig.default()
+            self._provider_config.clear()
+            self._save_config()
+            return True
+        except Exception:
+            return False
+
     def set_global_default_model(self, provider_model: str) -> bool:
         """Set global default model in provider/model format."""
         try:
@@ -319,6 +452,243 @@ class ConfigurationManager:
         except Exception:
             return False
 
+    def set_default_model(self, provider_model: str) -> bool:
+        """Legacy alias for setting the global default model."""
+        return self.set_global_default_model(provider_model)
+
+    def set_global_default_provider(self, provider: str) -> bool:
+        """Set global default provider (legacy)."""
+        try:
+            provider = str(provider or "").strip()
+            if not provider:
+                raise ValueError("Provider cannot be empty")
+            self.config.default_models.global_provider = provider
+            self._save_config()
+            return True
+        except Exception:
+            return False
+
+    def set_chat_model(self, provider_model: str) -> bool:
+        """Set specialized chat model (provider/model string)."""
+        try:
+            model = str(provider_model or "").strip()
+            if not model:
+                raise ValueError("Model cannot be empty")
+            self.config.default_models.chat_model = model
+            self._save_config()
+            return True
+        except Exception:
+            return False
+
+    def set_code_model(self, provider_model: str) -> bool:
+        """Set specialized code model (provider/model string)."""
+        try:
+            model = str(provider_model or "").strip()
+            if not model:
+                raise ValueError("Model cannot be empty")
+            self.config.default_models.code_model = model
+            self._save_config()
+            return True
+        except Exception:
+            return False
+
+    def set_embeddings_model(self, provider_model: str) -> bool:
+        """Set embeddings provider/model from a provider/model string (preferred)."""
+        try:
+            value = str(provider_model or "").strip()
+            if not value:
+                raise ValueError("Embeddings model cannot be empty")
+
+            if "/" in value:
+                provider, model = value.split("/", 1)
+                self.config.embeddings.provider = provider.strip() or self.config.embeddings.provider
+                self.config.embeddings.model = model.strip()
+            else:
+                self.config.embeddings.model = value
+
+            self._save_config()
+            return True
+        except Exception:
+            return False
+
+    def set_embeddings_provider(self, provider: str) -> bool:
+        """Set embeddings provider."""
+        try:
+            value = str(provider or "").strip()
+            if not value:
+                raise ValueError("Embeddings provider cannot be empty")
+            self.config.embeddings.provider = value
+            self._save_config()
+            return True
+        except Exception:
+            return False
+
+    def set_default_cache_dir(self, path: str) -> bool:
+        """Set default cache directory for AbstractCore."""
+        try:
+            value = str(path or "").strip()
+            if not value:
+                raise ValueError("Cache directory cannot be empty")
+            self.config.cache.default_cache_dir = value
+            self._save_config()
+            return True
+        except Exception:
+            return False
+
+    def set_huggingface_cache_dir(self, path: str) -> bool:
+        """Set HuggingFace cache directory."""
+        try:
+            value = str(path or "").strip()
+            if not value:
+                raise ValueError("HuggingFace cache directory cannot be empty")
+            self.config.cache.huggingface_cache_dir = value
+            self._save_config()
+            return True
+        except Exception:
+            return False
+
+    def set_local_models_cache_dir(self, path: str) -> bool:
+        """Set local models cache directory."""
+        try:
+            value = str(path or "").strip()
+            if not value:
+                raise ValueError("Local models cache directory cannot be empty")
+            self.config.cache.local_models_cache_dir = value
+            self._save_config()
+            return True
+        except Exception:
+            return False
+
+    def set_log_base_dir(self, path: str) -> bool:
+        """Set log base directory."""
+        try:
+            value = str(path or "").strip()
+            if not value:
+                raise ValueError("Log base directory cannot be empty")
+            self.config.logging.log_base_dir = value
+            self._save_config()
+            return True
+        except Exception:
+            return False
+
+    def set_console_log_level(self, level: str) -> bool:
+        """Set console logging level."""
+        try:
+            value = str(level or "").strip().upper()
+            if not value:
+                raise ValueError("Console log level cannot be empty")
+            self.config.logging.console_level = value
+            self._save_config()
+            return True
+        except Exception:
+            return False
+
+    def set_file_log_level(self, level: str) -> bool:
+        """Set file logging level."""
+        try:
+            value = str(level or "").strip().upper()
+            if not value:
+                raise ValueError("File log level cannot be empty")
+            self.config.logging.file_level = value
+            self._save_config()
+            return True
+        except Exception:
+            return False
+
+    def enable_debug_logging(self) -> bool:
+        """Enable debug logging for both console and file."""
+        try:
+            self.config.logging.console_level = "DEBUG"
+            self.config.logging.file_level = "DEBUG"
+            self._save_config()
+            return True
+        except Exception:
+            return False
+
+    def disable_console_logging(self) -> bool:
+        """Disable console logging output."""
+        try:
+            self.config.logging.console_level = "NONE"
+            self._save_config()
+            return True
+        except Exception:
+            return False
+
+    def enable_file_logging(self) -> bool:
+        """Enable file logging."""
+        try:
+            self.config.logging.file_logging_enabled = True
+            self._save_config()
+            return True
+        except Exception:
+            return False
+
+    def disable_file_logging(self) -> bool:
+        """Disable file logging."""
+        try:
+            self.config.logging.file_logging_enabled = False
+            self._save_config()
+            return True
+        except Exception:
+            return False
+
+    def set_streaming_default(self, app_name: str, enabled: bool) -> bool:
+        """Set default streaming behavior for a given app (currently: cli)."""
+        try:
+            app = str(app_name or "").strip().lower()
+            if app != "cli":
+                return False
+            self.config.streaming.cli_stream_default = bool(enabled)
+            self._save_config()
+            return True
+        except Exception:
+            return False
+
+    def get_streaming_default(self, app_name: str) -> bool:
+        """Get default streaming behavior for a given app (currently: cli)."""
+        app = str(app_name or "").strip().lower()
+        if app == "cli":
+            return bool(self.config.streaming.cli_stream_default)
+        return False
+
+    def enable_cli_streaming(self) -> bool:
+        """Enable streaming by default for the CLI."""
+        return self.set_streaming_default("cli", True)
+
+    def disable_cli_streaming(self) -> bool:
+        """Disable streaming by default for the CLI."""
+        return self.set_streaming_default("cli", False)
+
+    def add_vision_fallback(self, provider: str, model: str) -> bool:
+        """Add a vision fallback provider/model to the chain."""
+        try:
+            provider_val = str(provider or "").strip()
+            model_val = str(model or "").strip()
+            if not provider_val or not model_val:
+                raise ValueError("Provider and model are required")
+
+            self.config.vision.fallback_chain.append({"provider": provider_val, "model": model_val})
+            # If vision is configured at all, assume two_stage (caption -> text model).
+            if not self.config.vision.strategy or self.config.vision.strategy == "disabled":
+                self.config.vision.strategy = "two_stage"
+            self._save_config()
+            return True
+        except Exception:
+            return False
+
+    def disable_vision(self) -> bool:
+        """Disable vision fallback for text-only models."""
+        try:
+            self.config.vision.strategy = "disabled"
+            self.config.vision.caption_provider = None
+            self.config.vision.caption_model = None
+            self.config.vision.fallback_chain = []
+            self._save_config()
+            return True
+        except Exception:
+            return False
+
+
     def set_app_default(self, app_name: str, provider: str, model: str) -> bool:
         """Set app-specific default provider and model."""
         try:
@@ -352,6 +722,8 @@ class ConfigurationManager:
                 self.config.api_keys.openai = key
             elif provider == "anthropic":
                 self.config.api_keys.anthropic = key
+            elif provider == "openrouter":
+                self.config.api_keys.openrouter = key
             elif provider == "google":
                 self.config.api_keys.google = key
             else:
@@ -383,9 +755,12 @@ class ConfigurationManager:
     def set_default_timeout(self, timeout: float) -> bool:
         """Set default HTTP request timeout in seconds."""
         try:
-            if timeout <= 0:
-                raise ValueError("Timeout must be positive")
-            self.config.timeouts.default_timeout = timeout
+            # #[WARNING:TIMEOUT]
+            # Contract: allow `0` to mean "unlimited" (the provider layer normalizes <=0 to None).
+            timeout_f = float(timeout)
+            if timeout_f < 0:
+                raise ValueError("Timeout must be >= 0 (0 = unlimited)")
+            self.config.timeouts.default_timeout = timeout_f
             self._save_config()
             return True
         except Exception:
@@ -394,9 +769,12 @@ class ConfigurationManager:
     def set_tool_timeout(self, timeout: float) -> bool:
         """Set tool execution timeout in seconds."""
         try:
-            if timeout <= 0:
-                raise ValueError("Timeout must be positive")
-            self.config.timeouts.tool_timeout = timeout
+            # #[WARNING:TIMEOUT]
+            # Contract: allow `0` to mean "unlimited".
+            timeout_f = float(timeout)
+            if timeout_f < 0:
+                raise ValueError("Timeout must be >= 0 (0 = unlimited)")
+            self.config.timeouts.tool_timeout = timeout_f
             self._save_config()
             return True
         except Exception:

abstractcore/config/vision_config.py

@@ -155,9 +155,9 @@ def handle_list_vision(handler: 'VisionFallbackHandler') -> bool:
             "gpt-4-turbo-with-vision - GPT-4 Turbo Vision"
         ],
         "anthropic": [
-            "claude-3.5-sonnet - Claude 3.5 Sonnet",
-            "claude-3.5-haiku - Claude 3.5 Haiku",
-            "claude-3-opus - Claude 3 Opus"
+            "claude-haiku-4-5 - Claude Haiku 4.5 (vision, cost-effective)",
+            "claude-sonnet-4-5 - Claude Sonnet 4.5 (vision)",
+            "claude-opus-4-5 - Claude Opus 4.5 (vision)"
         ],
         "huggingface": [
             "unsloth/Qwen2.5-VL-7B-Instruct-GGUF - GGUF format",
@@ -400,7 +400,7 @@ def configure_cloud_provider(handler: 'VisionFallbackHandler') -> bool:
         # Suggest models based on provider
         model_suggestions = {
             "openai": ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo-with-vision"],
-            "anthropic": ["claude-3.5-sonnet", "claude-3.5-haiku", "claude-3-opus"]
+            "anthropic": ["claude-haiku-4-5", "claude-sonnet-4-5", "claude-opus-4-5"]
         }
 
         print(f"\nSuggested models for {provider}:")
@@ -488,4 +488,4 @@ def add_vision_arguments(parser: argparse.ArgumentParser):
     vision_group.add_argument('--download-vision-model', nargs='?', const=True, metavar='MODEL',
                              help='Download vision model for offline use (default: blip-base-caption)')
     vision_group.add_argument('--configure', choices=['vision'],
-                             help='Interactive configuration mode')
+                             help='Interactive configuration mode')