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

abstractcore/media/vision_fallback.py

@@ -6,7 +6,9 @@ Uses unified AbstractCore configuration system.
 """
 
 from pathlib import Path
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, Tuple
+
+from ..utils.jsonish import loads_dict_like
 from ..utils.structured_logging import get_logger
 
 logger = get_logger(__name__)
@@ -69,6 +71,16 @@ class VisionFallbackHandler:
         Raises:
             VisionNotConfiguredError: When vision fallback is not configured
         """
+        description, _trace = self.create_description_with_trace(image_path, user_prompt=user_prompt)
+        return description
+
+    def create_description_with_trace(self, image_path: str, user_prompt: str = None) -> Tuple[str, Dict[str, Any]]:
+        """
+        Generate a description along with a small transparency trace.
+
+        The trace is intentionally bounded and JSON-serializable so it can be
+        surfaced in response metadata without relying on logs.
+        """
         if self.vision_config.strategy == "disabled":
             raise VisionNotConfiguredError("Vision fallback is disabled")
 
@@ -76,7 +88,14 @@ class VisionFallbackHandler:
             raise VisionNotConfiguredError("No vision capability configured")
 
         try:
-            return self._generate_with_fallback(image_path)
+            description, trace = self._generate_with_fallback_with_trace(image_path, user_prompt=user_prompt)
+            # Always include strategy in trace for host UX.
+            if isinstance(trace, dict):
+                trace = dict(trace)
+            else:
+                trace = {}
+            trace.setdefault("strategy", getattr(self.vision_config, "strategy", None))
+            return description, trace
         except Exception as e:
             logger.debug(f"Vision fallback failed: {e}")
             raise VisionNotConfiguredError(f"Vision fallback generation failed: {e}")
@@ -92,32 +111,61 @@ class VisionFallbackHandler:
 
     def _has_local_models(self) -> bool:
         """Check if any local vision models are available."""
-        models_dir = Path(self.vision_config.local_models_path).expanduser()
+        local_models_path = getattr(self.vision_config, "local_models_path", None)
+        if not isinstance(local_models_path, str) or not local_models_path.strip():
+            return False
+
+        models_dir = Path(local_models_path).expanduser()
         return models_dir.exists() and any(models_dir.iterdir())
 
-    def _generate_with_fallback(self, image_path: str) -> str:
-        """Try vision models in fallback chain order."""
+    def _generate_with_fallback(self, image_path: str, user_prompt: Optional[str] = None) -> str:
+        """Backward-compatible: return only the description."""
+        description, _trace = self._generate_with_fallback_with_trace(image_path, user_prompt=user_prompt)
+        return description
+
+    def _generate_with_fallback_with_trace(
+        self, image_path: str, user_prompt: Optional[str] = None
+    ) -> Tuple[str, Dict[str, Any]]:
+        """Try vision models in fallback chain order and return a small trace."""
         # Try primary provider first
         if self.vision_config.caption_provider and self.vision_config.caption_model:
             try:
                 description = self._generate_description(
                     self.vision_config.caption_provider,
                     self.vision_config.caption_model,
-                    image_path
+                    image_path,
+                    user_prompt=user_prompt,
                 )
-                return description
+                return description, {
+                    "backend": {
+                        "kind": "llm",
+                        "provider": str(self.vision_config.caption_provider),
+                        "model": str(self.vision_config.caption_model),
+                        "source": "primary",
+                    }
+                }
             except Exception as e:
                 logger.debug(f"Primary vision provider failed: {e}")
 
         # Try fallback chain
-        for provider_config in self.vision_config.fallback_chain:
+        for idx, provider_config in enumerate(self.vision_config.fallback_chain):
             try:
+                provider = provider_config.get("provider")
+                model = provider_config.get("model")
                 description = self._generate_description(
-                    provider_config["provider"],
-                    provider_config["model"],
-                    image_path
+                    provider,
+                    model,
+                    image_path,
+                    user_prompt=user_prompt,
                 )
-                return description
+                return description, {
+                    "backend": {
+                        "kind": "llm",
+                        "provider": str(provider),
+                        "model": str(model),
+                        "source": f"fallback_chain[{idx}]",
+                    }
+                }
             except Exception as e:
                 logger.debug(f"Vision provider {provider_config} failed: {e}")
                 continue
@@ -125,37 +173,97 @@ class VisionFallbackHandler:
         # Try local models
         if self._has_local_models():
             try:
-                description = self._generate_local_description(image_path)
-                return description
+                description, local_trace = self._generate_local_description_with_trace(image_path)
+                return description, local_trace
             except Exception as e:
                 logger.debug(f"Local vision model failed: {e}")
 
         raise Exception("All vision fallback providers failed")
 
-    def _generate_description(self, provider: str, model: str, image_path: str) -> str:
+    def _generate_description(self, provider: str, model: str, image_path: str, user_prompt: Optional[str] = None) -> str:
         """Generate description using specified provider and model."""
         try:
             # Import here to avoid circular imports
             from abstractcore import create_llm
 
             vision_llm = create_llm(provider, model=model)
+            prompt = self._build_caption_prompt(user_prompt=user_prompt)
             response = vision_llm.generate(
-                "Provide a detailed description of this image in 3-4 sentences. Be precise about specific landmarks, buildings, objects, and details. If you recognize specific places or things, name them accurately. Describe naturally without phrases like 'this image shows'.",
+                prompt,
                 media=[image_path]
             )
-            return response.content.strip()
+            return self._extract_caption_text(response.content)
         except Exception as e:
             logger.debug(f"Failed to generate description with {provider}/{model}: {e}")
             raise
 
+    def _build_caption_prompt(self, user_prompt: Optional[str] = None) -> str:
+        """
+        Build the prompt sent to the vision model.
+
+        Design goals:
+        - "Perception only": provide grounded visual observations, not a full answer.
+        - Context-aware: bias observations toward what's useful for the user's request.
+        - Seamless: avoid meta phrases that make the parent model "comment on a caption".
+        """
+        cleaned_user_prompt = (user_prompt or "").strip()
+
+        base = (
+            "Provide grounded visual observations that will help answer the user's request.\n"
+            "- Write 3–4 natural sentences.\n"
+            "- Be precise about objects, people, settings, and notable details.\n"
+            "- If there is readable text, include it verbatim in quotes.\n"
+            "- If you recognize specific places/people/brands with high confidence, name them; otherwise say \"unclear\".\n"
+            "- Avoid meta phrasing like \"this image shows\", \"the image depicts\", \"image analysis\", or apologies.\n"
+            "- Return only the description text.\n"
+        )
+
+        if not cleaned_user_prompt:
+            return base
+
+        return f"{base}\nUser request (for context): {cleaned_user_prompt}"
+
+    def _extract_caption_text(self, raw: Any) -> str:
+        """
+        Extract a plain caption string from the vision model output.
+
+        Some vision models (or wrappers) may return JSON-ish objects; accept both.
+        """
+        text = str(raw or "").strip()
+        if not text:
+            return ""
+
+        parsed = loads_dict_like(text)
+        if isinstance(parsed, dict):
+            for key in ("description", "caption", "text", "content"):
+                val = parsed.get(key)
+                if isinstance(val, str) and val.strip():
+                    return val.strip()
+
+        return text
+
     def _generate_local_description(self, image_path: str) -> str:
-        """Generate description using local vision model."""
+        """Backward-compatible: return only the local model description."""
+        description, _trace = self._generate_local_description_with_trace(image_path)
+        return description
+
+    def _generate_local_description_with_trace(self, image_path: str) -> Tuple[str, Dict[str, Any]]:
+        """Generate description using a local vision model and return trace."""
         try:
-            models_dir = Path(self.vision_config.local_models_path).expanduser()
+            local_models_path = getattr(self.vision_config, "local_models_path", None)
+            if not isinstance(local_models_path, str) or not local_models_path.strip():
+                raise Exception("No local_models_path configured")
+
+            models_dir = Path(local_models_path).expanduser()
 
             # Look for downloaded vision models
             for model_dir in models_dir.iterdir():
-                if model_dir.is_dir() and ("caption" in model_dir.name.lower() or "blip" in model_dir.name.lower() or "vit" in model_dir.name.lower() or "git" in model_dir.name.lower()):
+                if model_dir.is_dir() and (
+                    "caption" in model_dir.name.lower()
+                    or "blip" in model_dir.name.lower()
+                    or "vit" in model_dir.name.lower()
+                    or "git" in model_dir.name.lower()
+                ):
                     try:
                         # Check if download is complete
                         if not (model_dir / "download_complete.txt").exists():
@@ -164,7 +272,13 @@ class VisionFallbackHandler:
 
                         description = self._use_local_model(model_dir, image_path)
                         if description:
-                            return description
+                            return description, {
+                                "backend": {
+                                    "kind": "local_model",
+                                    "model": str(model_dir.name),
+                                    "source": "local_models",
+                                }
+                            }
 
                     except Exception as e:
                         logger.debug(f"Local model {model_dir} failed: {e}")
@@ -271,4 +385,4 @@ def has_vision_capability() -> bool:
 def create_image_description(image_path: str, user_prompt: str = None) -> str:
     """Create image description for text-only models."""
     handler = VisionFallbackHandler()
-    return handler.create_description(image_path, user_prompt)
+    return handler.create_description(image_path, user_prompt)

abstractcore/processing/__init__.py

@@ -5,11 +5,40 @@ Basic text processing capabilities built on top of AbstractCore,
 demonstrating how to leverage the core infrastructure for real-world tasks.
 """
 
+from __future__ import annotations
+
+# Keep this package import-safe for minimal installs.
+# Some processing apps pull optional deps (e.g. DeepSearch uses built-in web tools).
+from importlib import import_module
+from typing import Any
+
 from .basic_summarizer import BasicSummarizer, SummaryStyle, SummaryLength, CompressionMode
 from .basic_extractor import BasicExtractor
 from .basic_judge import BasicJudge, JudgmentCriteria, Assessment, create_judge
-from .basic_deepsearch import BasicDeepSearch, ResearchReport, ResearchFinding, ResearchPlan, ResearchSubTask
-from .basic_intent import BasicIntentAnalyzer, IntentType, IntentDepth, IntentContext, IdentifiedIntent, IntentAnalysisOutput
+from .basic_intent import (
+    BasicIntentAnalyzer,
+    IntentType,
+    IntentDepth,
+    IntentContext,
+    IdentifiedIntent,
+    IntentAnalysisOutput,
+)
+
+
+def __getattr__(name: str) -> Any:
+    lazy = {
+        "BasicDeepSearch",
+        "ResearchReport",
+        "ResearchFinding",
+        "ResearchPlan",
+        "ResearchSubTask",
+    }
+    if name in lazy:
+        mod = import_module("abstractcore.processing.basic_deepsearch")
+        value = getattr(mod, name)
+        globals()[name] = value
+        return value
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
 __all__ = [
     'BasicSummarizer', 'SummaryStyle', 'SummaryLength', 'CompressionMode',
@@ -17,4 +46,4 @@ __all__ = [
     'BasicJudge', 'JudgmentCriteria', 'Assessment', 'create_judge',
     'BasicDeepSearch', 'ResearchReport', 'ResearchFinding', 'ResearchPlan', 'ResearchSubTask',
     'BasicIntentAnalyzer', 'IntentType', 'IntentDepth', 'IntentContext', 'IdentifiedIntent', 'IntentAnalysisOutput'
-]
+]

abstractcore/processing/basic_deepsearch.py

@@ -24,6 +24,7 @@ from ..core.interface import AbstractCoreInterface
 from ..core.factory import create_llm
 from ..structured.retry import FeedbackRetry
 from ..utils.structured_logging import get_logger
+from ..utils.truncation import preview_text
 from ..tools.common_tools import web_search, fetch_url
 
 logger = get_logger(__name__)
@@ -172,7 +173,7 @@ class ResearchSubTaskModel(BaseModel):
 class ResearchThemeModel(BaseModel):
     """Pydantic model for research theme (for structured output)"""
     name: str = Field(description="Theme name")
-    questions: List[str] = Field(description="3 specific research questions for this theme", min_items=3, max_items=3)
+    questions: List[str] = Field(description="3 specific research questions for this theme", min_length=3, max_length=3)
     priority: int = Field(description="Theme priority (1=essential, 2=important, 3=supplementary)", ge=1, le=3)
 
 class ResearchPlanModel(BaseModel):
@@ -185,7 +186,7 @@ class ResearchPlanModel(BaseModel):
 
 class SearchQueriesModel(BaseModel):
     """Pydantic model for search queries (for structured output)"""
-    queries: List[str] = Field(description="List of specific search queries", min_items=1, max_items=5)
+    queries: List[str] = Field(description="List of specific search queries", min_length=1, max_length=5)
 
 
 @dataclass
@@ -697,7 +698,7 @@ Avoid generic terms like "qubit" alone (which returns lab instruments) - be spec
             logger.info(f"🔍 Executing search for: {query}")
             search_results = web_search(query, num_results=5)
             logger.debug(f"📄 Search results length: {len(search_results)}")
-            logger.debug(f"📄 Search results preview: {search_results[:500]}")
+            logger.debug(f"📄 Search results preview: {preview_text(search_results, max_chars=500)}")
             
             # Parse search results to extract URLs and content
             urls = self._extract_urls_from_search(search_results)
@@ -739,7 +740,7 @@ Avoid generic terms like "qubit" alone (which returns lab instruments) - be spec
                     synthetic_finding = ResearchFinding(
                         source_url="https://duckduckgo.com/?q=" + query.replace(" ", "+"),
                         title=f"Search results for: {query}",
-                        content=search_results[:500] + "...",
+                        content=preview_text(search_results, max_chars=500),
                         relevance_score=0.3,
                         timestamp=timestamp,
                         sub_task_id=sub_task_id
@@ -940,7 +941,7 @@ Avoid generic terms like "qubit" alone (which returns lab instruments) - be spec
             }
         
         # Limit content for efficient assessment
-        assessment_content = content[:1500] + "..." if len(content) > 1500 else content
+        assessment_content = preview_text(content, max_chars=1500)
         
         assessment_prompt = f"""
 Assess if this content contains meaningful information related to the research query.
@@ -1386,7 +1387,7 @@ BE GENEROUS with relevance assessment - when in doubt, mark as relevant.
                     content_parts.append(f"**Content:** {text_preview}")
             else:
                 # Standard mode: use longer preview (up to 1000 chars)
-                preview = text_preview[:1000] + "..." if len(text_preview) > 1000 else text_preview
+                preview = preview_text(text_preview, max_chars=1000)
                 content_parts.append(f"**Content:** {preview}")
         
         if not content_parts:
@@ -1536,8 +1537,7 @@ If the content is not relevant to the query, respond with "NOT_RELEVANT".
         """Fallback LLM-based extraction for unstructured content"""
         
         # Limit content length for processing
-        if len(content) > 8000:
-            content = content[:8000] + "..."
+        content = preview_text(content, max_chars=8000)
         
         extraction_prompt = f"""
 Extract the most relevant information from this content for the research query.
@@ -1944,7 +1944,7 @@ Guidelines:
         sources = []
         
         for finding in findings[:10]:  # Limit to top 10 findings
-            key_findings.append(finding.content[:200] + "..." if len(finding.content) > 200 else finding.content)
+            key_findings.append(preview_text(finding.content, max_chars=200))
             sources.append({
                 "title": finding.title,
                 "url": finding.source_url,
@@ -1964,6 +1964,11 @@ Guidelines:
 
     def _verify_report(self, report: ResearchReport, findings: List[ResearchFinding]) -> ResearchReport:
         """Stage 5: Verify report accuracy and add fact-checking"""
+
+        sources_preview = "\n".join(
+            f"- {preview_text(f.content, max_chars=200)}"
+            for f in findings[:10]
+        )
         
         verification_prompt = f"""
 Review this research report for accuracy and consistency with the source findings.
@@ -1973,7 +1978,7 @@ EXECUTIVE SUMMARY: {report.executive_summary}
 KEY FINDINGS: {report.key_findings}
 
 SOURCE FINDINGS:
-{[f"- {f.content[:200]}..." for f in findings[:10]]}
+{sources_preview}
 
 Identify any potential issues:
 1. Claims not supported by the source findings

abstractcore/processing/basic_intent.py

@@ -13,6 +13,7 @@ from ..core.interface import AbstractCoreInterface
 from ..core.factory import create_llm
 from ..structured.retry import FeedbackRetry
 from ..utils.structured_logging import get_logger
+from ..utils.truncation import preview_text
 
 logger = get_logger(__name__)
 
@@ -275,7 +276,7 @@ class BasicIntentAnalyzer:
             # Debug information for troubleshooting
             error_msg = f"Failed to generate structured intent analysis output. Response type: {type(response)}"
             if hasattr(response, 'content'):
-                error_msg += f", Content: {response.content[:200]}..."
+                error_msg += f", Content: {preview_text(response.content, max_chars=200)}"
             if hasattr(response, 'structured_output'):
                 error_msg += f", Structured output: {response.structured_output}"
             raise ValueError(error_msg)
@@ -375,7 +376,7 @@ class BasicIntentAnalyzer:
             # Debug information for troubleshooting
             error_msg = f"Failed to generate final structured intent analysis output. Response type: {type(response)}"
             if hasattr(response, 'content'):
-                error_msg += f", Content: {response.content[:200]}..."
+                error_msg += f", Content: {preview_text(response.content, max_chars=200)}"
             if hasattr(response, 'structured_output'):
                 error_msg += f", Structured output: {response.structured_output}"
             raise ValueError(error_msg)

abstractcore/processing/basic_judge.py

@@ -19,6 +19,7 @@ from ..core.interface import AbstractCoreInterface
 from ..core.factory import create_llm
 from ..structured.retry import FeedbackRetry
 from ..utils.structured_logging import get_logger
+from ..utils.truncation import preview_text
 
 logger = get_logger(__name__)
 
@@ -657,7 +658,7 @@ These criteria form the foundation of this assessment. Each criterion is evaluat
         # Determine source reference
         source_ref = f"Content evaluation in context: {context}"
         if len(content) > 50:
-            content_preview = content[:50] + "..."
+            content_preview = preview_text(content, max_chars=50)
             source_ref = f"Content: '{content_preview}' (context: {context})"
         else:
             source_ref = f"Content: '{content}' (context: {context})"
@@ -774,4 +775,4 @@ def create_judge(
         llm = create_llm(provider, model=model, temperature=temperature, max_tokens=max_tokens, max_output_tokens=max_output_tokens, timeout=timeout, **kwargs)
         return BasicJudge(llm=llm, temperature=temperature, max_tokens=max_tokens, max_output_tokens=max_output_tokens, debug=debug, timeout=timeout)
     else:
-        return BasicJudge(temperature=temperature, max_tokens=max_tokens, max_output_tokens=max_output_tokens, debug=debug, timeout=timeout)
+        return BasicJudge(temperature=temperature, max_tokens=max_tokens, max_output_tokens=max_output_tokens, debug=debug, timeout=timeout)

abstractcore/processing/basic_summarizer.py

@@ -166,7 +166,7 @@ class BasicSummarizer:
                     "   summarizer = BasicSummarizer(llm)\n"
                     "   \n"
                     "   # Using Anthropic\n"
-                    "   llm = create_llm('anthropic', model='claude-3-5-haiku-latest')\n"
+                    "   llm = create_llm('anthropic', model='claude-haiku-4-5')\n"
                     "   summarizer = BasicSummarizer(llm)\n"
                     "   \n"
                     "   # Using different Ollama model\n"

abstractcore/providers/__init__.py

@@ -9,6 +9,7 @@ from .huggingface_provider import HuggingFaceProvider
 from .mlx_provider import MLXProvider
 from .vllm_provider import VLLMProvider
 from .openai_compatible_provider import OpenAICompatibleProvider
+from .openrouter_provider import OpenRouterProvider
 
 # Provider registry for centralized provider discovery and management
 from .registry import (
@@ -45,6 +46,7 @@ __all__ = [
     'MLXProvider',
     'VLLMProvider',
     'OpenAICompatibleProvider',
+    'OpenRouterProvider',
 
     # Provider registry
     'ProviderRegistry',
@@ -65,4 +67,4 @@ __all__ = [
     'get_model_output_capabilities',
     'filter_models_by_capabilities',
     'get_capability_summary',
-]
+]

abstractcore/providers/anthropic_provider.py

@@ -15,7 +15,6 @@ except ImportError:
     BaseModel = None
 from .base import BaseProvider
 from ..core.types import GenerateResponse
-from ..media import MediaHandler
 from ..exceptions import AuthenticationError, ProviderAPIError, ModelNotFoundError, format_model_error, format_auth_error
 from ..tools import UniversalToolHandler, execute_tools
 from ..events import EventType
@@ -142,7 +141,7 @@ class AnthropicProvider(BaseProvider):
                     multimodal_message = media_handler.create_multimodal_message(prompt, media)
                     api_messages.append(multimodal_message)
                 except ImportError:
-                    self.logger.warning("Media processing not available. Install with: pip install abstractcore[media]")
+                    self.logger.warning("Media processing not available. Install with: pip install \"abstractcore[media]\"")
                     api_messages.append({"role": "user", "content": prompt})
                 except Exception as e:
                     self.logger.warning(f"Failed to process media content: {e}")
@@ -150,6 +149,50 @@ class AnthropicProvider(BaseProvider):
             else:
                 api_messages.append({"role": "user", "content": prompt})
 
+        # If media is present but no multimodal message was created (common when prompt="" and the
+        # caller provided the request in `messages`), attach media to the last plain user message.
+        if media:
+            try:
+                has_image = False
+                for m in api_messages:
+                    if not isinstance(m, dict):
+                        continue
+                    if m.get("role") != "user":
+                        continue
+                    c = m.get("content")
+                    if not isinstance(c, list):
+                        continue
+                    for b in c:
+                        if isinstance(b, dict) and b.get("type") == "image":
+                            has_image = True
+                            break
+                    if has_image:
+                        break
+
+                if not has_image:
+                    from ..media.handlers import AnthropicMediaHandler
+
+                    media_handler = AnthropicMediaHandler(self.model_capabilities)
+                    idx: Optional[int] = None
+                    for i in range(len(api_messages) - 1, -1, -1):
+                        m = api_messages[i]
+                        if not isinstance(m, dict):
+                            continue
+                        if m.get("role") != "user":
+                            continue
+                        if isinstance(m.get("content"), str):
+                            idx = i
+                            break
+                    if idx is None:
+                        api_messages.append(media_handler.create_multimodal_message("", media))
+                    else:
+                        text0 = str(api_messages[idx].get("content") or "")
+                        api_messages[idx] = media_handler.create_multimodal_message(text0, media)
+            except ImportError:
+                self.logger.warning("Media processing not available. Install with: pip install \"abstractcore[media]\"")
+            except Exception as e:
+                self.logger.warning(f"Failed to process media content: {e}")
+
         # Prepare API call parameters using unified system
         generation_kwargs = self._prepare_generation_kwargs(**kwargs)
         max_output_tokens = self._get_provider_max_tokens_param(generation_kwargs)
@@ -158,7 +201,7 @@ class AnthropicProvider(BaseProvider):
             "model": self.model,
             "messages": api_messages,
             "max_tokens": max_output_tokens,  # This is max_output_tokens for Anthropic
-            "temperature": kwargs.get("temperature", self.temperature),
+            "temperature": generation_kwargs.get("temperature", self.temperature),
             "stream": stream
         }
 
@@ -175,7 +218,7 @@ class AnthropicProvider(BaseProvider):
             call_params["top_k"] = kwargs.get("top_k", self.top_k)
 
         # Handle seed parameter (Anthropic doesn't support seed natively)
-        seed_value = kwargs.get("seed", self.seed)
+        seed_value = generation_kwargs.get("seed")
         if seed_value is not None:
             import warnings
             warnings.warn(
@@ -330,7 +373,7 @@ class AnthropicProvider(BaseProvider):
                     multimodal_message = media_handler.create_multimodal_message(prompt, media)
                     api_messages.append(multimodal_message)
                 except ImportError:
-                    self.logger.warning("Media processing not available. Install with: pip install abstractcore[media]")
+                    self.logger.warning("Media processing not available. Install with: pip install \"abstractcore[media]\"")
                     api_messages.append({"role": "user", "content": prompt})
                 except Exception as e:
                     self.logger.warning(f"Failed to process media content: {e}")
@@ -338,6 +381,50 @@ class AnthropicProvider(BaseProvider):
             else:
                 api_messages.append({"role": "user", "content": prompt})
 
+        # If media is present but no multimodal message was created (common when prompt="" and the
+        # caller provided the request in `messages`), attach media to the last plain user message.
+        if media:
+            try:
+                has_image = False
+                for m in api_messages:
+                    if not isinstance(m, dict):
+                        continue
+                    if m.get("role") != "user":
+                        continue
+                    c = m.get("content")
+                    if not isinstance(c, list):
+                        continue
+                    for b in c:
+                        if isinstance(b, dict) and b.get("type") == "image":
+                            has_image = True
+                            break
+                    if has_image:
+                        break
+
+                if not has_image:
+                    from ..media.handlers import AnthropicMediaHandler
+
+                    media_handler = AnthropicMediaHandler(self.model_capabilities)
+                    idx: Optional[int] = None
+                    for i in range(len(api_messages) - 1, -1, -1):
+                        m = api_messages[i]
+                        if not isinstance(m, dict):
+                            continue
+                        if m.get("role") != "user":
+                            continue
+                        if isinstance(m.get("content"), str):
+                            idx = i
+                            break
+                    if idx is None:
+                        api_messages.append(media_handler.create_multimodal_message("", media))
+                    else:
+                        text0 = str(api_messages[idx].get("content") or "")
+                        api_messages[idx] = media_handler.create_multimodal_message(text0, media)
+            except ImportError:
+                self.logger.warning("Media processing not available. Install with: pip install \"abstractcore[media]\"")
+            except Exception as e:
+                self.logger.warning(f"Failed to process media content: {e}")
+
         # Prepare API call parameters (same logic as sync)
         generation_kwargs = self._prepare_generation_kwargs(**kwargs)
         max_output_tokens = self._get_provider_max_tokens_param(generation_kwargs)
@@ -346,7 +433,7 @@ class AnthropicProvider(BaseProvider):
             "model": self.model,
             "messages": api_messages,
             "max_tokens": max_output_tokens,
-            "temperature": kwargs.get("temperature", self.temperature),
+            "temperature": generation_kwargs.get("temperature", self.temperature),
             "stream": stream
         }
 
@@ -363,7 +450,7 @@ class AnthropicProvider(BaseProvider):
             call_params["top_k"] = kwargs.get("top_k", self.top_k)
 
         # Handle seed parameter (Anthropic doesn't support seed natively)
-        seed_value = kwargs.get("seed", self.seed)
+        seed_value = generation_kwargs.get("seed")
         if seed_value is not None:
             import warnings
             warnings.warn(
@@ -455,7 +542,7 @@ class AnthropicProvider(BaseProvider):
         except Exception as e:
             raise
 
-    def unload(self) -> None:
+    def unload_model(self, model_name: str) -> None:
         """Close async client if it was created."""
         if self._async_client is not None:
             import asyncio