fast-agent-mcp 0.2.57__py3-none-any.whl → 0.3.0__py3-none-any.whl

{mcp_agent/llm/providers → fast_agent/llm/provider/anthropic}/multipart_converter_anthropic.py

@@ -10,6 +10,7 @@ from anthropic.types import (
     PlainTextSourceParam,
     TextBlockParam,
     ToolResultBlockParam,
+    ToolUseBlockParam,
     URLImageSourceParam,
     URLPDFSourceParam,
 )
@@ -24,8 +25,8 @@ from mcp.types import (
     TextResourceContents,
 )
 
-from mcp_agent.logging.logger import get_logger
-from mcp_agent.mcp.helpers.content_helpers import (
+from fast_agent.core.logging.logger import get_logger
+from fast_agent.mcp.helpers.content_helpers import (
     get_image_data,
     get_resource_uri,
     get_text,
@@ -33,13 +34,12 @@ from mcp_agent.mcp.helpers.content_helpers import (
     is_resource_content,
     is_text_content,
 )
-from mcp_agent.mcp.mime_utils import (
+from fast_agent.mcp.mime_utils import (
     guess_mime_type,
     is_image_mime_type,
     is_text_mime_type,
 )
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
-from mcp_agent.mcp.resource_utils import extract_title_from_uri
+from fast_agent.types import PromptMessageExtended
 
 _logger = get_logger("multipart_converter_anthropic")
 
@@ -63,41 +63,81 @@ class AnthropicConverter:
         return mime_type in SUPPORTED_IMAGE_MIME_TYPES
 
     @staticmethod
-    def convert_to_anthropic(multipart_msg: PromptMessageMultipart) -> MessageParam:
+    def convert_to_anthropic(multipart_msg: PromptMessageExtended) -> MessageParam:
         """
-        Convert a PromptMessageMultipart message to Anthropic API format.
+        Convert a PromptMessageExtended message to Anthropic API format.
 
         Args:
-            multipart_msg: The PromptMessageMultipart message to convert
+            multipart_msg: The PromptMessageExtended message to convert
 
         Returns:
             An Anthropic API MessageParam object
         """
         role = multipart_msg.role
+        all_content_blocks = []
+
+        # If this is an assistant message that contains tool_calls, convert
+        # those into Anthropic tool_use blocks so the next user message can
+        # legally include corresponding tool_result blocks.
+        if role == "assistant" and multipart_msg.tool_calls:
+            for tool_use_id, req in multipart_msg.tool_calls.items():
+                name = None
+                args = None
+                try:
+                    params = getattr(req, "params", None)
+                    if params is not None:
+                        name = getattr(params, "name", None)
+                        args = getattr(params, "arguments", None)
+                except Exception:
+                    pass
+
+                all_content_blocks.append(
+                    ToolUseBlockParam(
+                        type="tool_use",
+                        id=tool_use_id,
+                        name=name or "unknown_tool",
+                        input=args or {},
+                    )
+                )
 
-        # Handle empty content case - create an empty list instead of a text block
-        if not multipart_msg.content:
-            return MessageParam(role=role, content=[])
+            return MessageParam(role=role, content=all_content_blocks)
+
+        # Handle tool_results if present (for user messages with tool results)
+        # Tool results must come FIRST in the content array per Anthropic API requirements
+        if multipart_msg.tool_results:
+            # Convert dict to list of tuples for create_tool_results_message
+            tool_results_list = list(multipart_msg.tool_results.items())
+            tool_msg = AnthropicConverter.create_tool_results_message(tool_results_list)
+            # Extract the content blocks from the tool results message
+            all_content_blocks.extend(tool_msg["content"])
+
+        # Then handle regular content blocks if present
+        if multipart_msg.content:
+            # Convert content blocks
+            anthropic_blocks = AnthropicConverter._convert_content_items(
+                multipart_msg.content, document_mode=True
+            )
 
-        # Convert content blocks
-        anthropic_blocks = AnthropicConverter._convert_content_items(
-            multipart_msg.content, document_mode=True
-        )
+            # Filter blocks based on role (assistant can only have text blocks)
+            if role == "assistant":
+                text_blocks = []
+                for block in anthropic_blocks:
+                    if block.get("type") == "text":
+                        text_blocks.append(block)
+                    else:
+                        _logger.warning(
+                            f"Removing non-text block from assistant message: {block.get('type')}"
+                        )
+                anthropic_blocks = text_blocks
 
-        # Filter blocks based on role (assistant can only have text blocks)
-        if role == "assistant":
-            text_blocks = []
-            for block in anthropic_blocks:
-                if block.get("type") == "text":
-                    text_blocks.append(block)
-                else:
-                    _logger.warning(
-                        f"Removing non-text block from assistant message: {block.get('type')}"
-                    )
-            anthropic_blocks = text_blocks
+            all_content_blocks.extend(anthropic_blocks)
+
+        # Handle empty content case
+        if not all_content_blocks:
+            return MessageParam(role=role, content=[])
 
         # Create the Anthropic message
-        return MessageParam(role=role, content=anthropic_blocks)
+        return MessageParam(role=role, content=all_content_blocks)
 
     @staticmethod
     def convert_prompt_message_to_anthropic(message: PromptMessage) -> MessageParam:
@@ -110,8 +150,8 @@ class AnthropicConverter:
         Returns:
             An Anthropic API MessageParam object
         """
-        # Convert the PromptMessage to a PromptMessageMultipart containing a single content item
-        multipart = PromptMessageMultipart(role=message.role, content=[message.content])
+        # Convert the PromptMessage to a PromptMessageExtended containing a single content item
+        multipart = PromptMessageExtended(role=message.role, content=[message.content])
 
         # Use the existing conversion method
         return AnthropicConverter.convert_to_anthropic(multipart)
@@ -195,6 +235,8 @@ class AnthropicConverter:
         mime_type = AnthropicConverter._determine_mime_type(resource_content)
 
         # Extract title from URI
+        from fast_agent.mcp.resource_utils import extract_title_from_uri
+
         title = extract_title_from_uri(uri) if uri else "resource"
 
         # Convert based on MIME type
@@ -345,47 +387,6 @@ class AnthropicConverter:
 
         return TextBlockParam(type="text", text=f"[{message}]")
 
-    @staticmethod
-    def convert_tool_result_to_anthropic(
-        tool_result: CallToolResult, tool_use_id: str
-    ) -> ToolResultBlockParam:
-        """
-        Convert an MCP CallToolResult to an Anthropic ToolResultBlockParam.
-
-        Args:
-            tool_result: The tool result from a tool call
-            tool_use_id: The ID of the associated tool use
-
-        Returns:
-            An Anthropic ToolResultBlockParam ready to be included in a user message
-        """
-        # For tool results, always use document_mode=False to get text blocks instead of document blocks
-        anthropic_content = []
-
-        for item in tool_result.content:
-            if isinstance(item, EmbeddedResource):
-                # For embedded resources, always use text mode in tool results
-                resource_block = AnthropicConverter._convert_embedded_resource(
-                    item, document_mode=False
-                )
-                anthropic_content.append(resource_block)
-            elif isinstance(item, (TextContent, ImageContent)):
-                # For text and image, use standard conversion
-                blocks = AnthropicConverter._convert_content_items([item], document_mode=False)
-                anthropic_content.extend(blocks)
-
-        # If we ended up with no valid content blocks, create a placeholder
-        if not anthropic_content:
-            anthropic_content = [TextBlockParam(type="text", text="[No content in tool result]")]
-
-        # Create the tool result block
-        return ToolResultBlockParam(
-            type="tool_result",
-            tool_use_id=tool_use_id,
-            content=anthropic_content,
-            is_error=tool_result.isError,
-        )
-
     @staticmethod
     def create_tool_results_message(
         tool_results: List[tuple[str, CallToolResult]],
@@ -404,7 +405,6 @@ class AnthropicConverter:
         for tool_use_id, result in tool_results:
             # Process each tool result
             tool_result_blocks = []
-            separate_blocks = []
 
             # Process each content item in the result
             for item in result.content:
@@ -413,19 +413,13 @@ class AnthropicConverter:
                     tool_result_blocks.extend(blocks)
                 elif isinstance(item, EmbeddedResource):
                     resource_content = item.resource
-
-                    # Text resources go in tool results, others go as separate blocks
-                    if isinstance(resource_content, TextResourceContents):
-                        block = AnthropicConverter._convert_embedded_resource(
-                            item, document_mode=False
-                        )
-                        tool_result_blocks.append(block)
-                    else:
-                        # For binary resources like PDFs, add as separate block
-                        block = AnthropicConverter._convert_embedded_resource(
-                            item, document_mode=True
-                        )
-                        separate_blocks.append(block)
+                    document_mode: bool = not isinstance(resource_content, TextResourceContents)
+                    # With  Anthropic SDK 0.66, documents can be inside tool results
+                    # Text resources remain inline within the tool_result
+                    block = AnthropicConverter._convert_embedded_resource(
+                        item, document_mode=document_mode
+                    )
+                    tool_result_blocks.append(block)
 
             # Create the tool result block if we have content
             if tool_result_blocks:
@@ -448,7 +442,6 @@ class AnthropicConverter:
                     )
                 )
 
-            # Add separate blocks directly to the message
-            content_blocks.extend(separate_blocks)
+            # All content is now included within the tool_result block.
 
         return MessageParam(role="user", content=content_blocks)

fast_agent/llm/provider/bedrock/bedrock_utils.py

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+from typing import Collection, Dict, List, Literal, Optional, Set, TypedDict, cast
+
+# Lightweight, runtime-only loader for AWS Bedrock models.
+# - Fetches once per process via boto3 (region from session; env override supported)
+# - Memory cache only; no disk persistence
+# - Provides filtering and optional prefixing (default 'bedrock.') for model IDs
+
+try:
+    import boto3
+except Exception:  # pragma: no cover - import error path
+    boto3 = None  # type: ignore[assignment]
+
+
+Modality = Literal["TEXT", "IMAGE", "VIDEO", "SPEECH", "EMBEDDING"]
+Lifecycle = Literal["ACTIVE", "LEGACY"]
+InferenceType = Literal["ON_DEMAND", "PROVISIONED", "INFERENCE_PROFILE"]
+
+
+class ModelSummary(TypedDict, total=False):
+    modelId: str
+    modelName: str
+    providerName: str
+    inputModalities: List[Modality]
+    outputModalities: List[Modality]
+    responseStreamingSupported: bool
+    customizationsSupported: List[str]
+    inferenceTypesSupported: List[InferenceType]
+    modelLifecycle: Dict[str, Lifecycle]
+
+
+_MODELS_CACHE_BY_REGION: Dict[str, Dict[str, ModelSummary]] = {}
+
+
+def _resolve_region(region: Optional[str]) -> str:
+    if region:
+        return region
+    import os
+
+    env_region = os.getenv("BEDROCK_REGION")
+    if env_region:
+        return env_region
+    if boto3 is None:
+        raise RuntimeError(
+            "boto3 is required to load Bedrock models. Install boto3 or provide a static list."
+        )
+    session = boto3.Session()
+    if not session.region_name:
+        raise RuntimeError(
+            "AWS region could not be resolved. Configure your AWS SSO/profile or set BEDROCK_REGION."
+        )
+    return session.region_name
+
+
+def _strip_prefix(model_id: str, prefix: str) -> str:
+    return model_id[len(prefix) :] if prefix and model_id.startswith(prefix) else model_id
+
+
+def _ensure_loaded(region: Optional[str] = None) -> Dict[str, ModelSummary]:
+    resolved_region = _resolve_region(region)
+    cache = _MODELS_CACHE_BY_REGION.get(resolved_region)
+    if cache is not None:
+        return cache
+
+    if boto3 is None:
+        raise RuntimeError("boto3 is required to load Bedrock models. Install boto3.")
+
+    try:
+        client = boto3.client("bedrock", region_name=resolved_region)
+        resp = client.list_foundation_models()
+        summaries: List[ModelSummary] = resp.get("modelSummaries", [])  # type: ignore[assignment]
+    except Exception as exc:  # keep error simple and actionable
+        raise RuntimeError(
+            f"Failed to list Bedrock foundation models in region '{resolved_region}'. "
+            f"Ensure AWS credentials (SSO) and permissions (bedrock:ListFoundationModels) are configured. "
+            f"Original error: {exc}"
+        )
+
+    cache = {s.get("modelId", ""): s for s in summaries if s.get("modelId")}
+    _MODELS_CACHE_BY_REGION[resolved_region] = cache
+    return cache
+
+
+def refresh_bedrock_models(region: Optional[str] = None) -> None:
+    resolved_region = _resolve_region(region)
+    # drop and reload on next access
+    _MODELS_CACHE_BY_REGION.pop(resolved_region, None)
+    _ensure_loaded(resolved_region)
+
+
+def _matches_modalities(model_modalities: List[Modality], requested: Collection[Modality]) -> bool:
+    # include if all requested are present in the model's modalities
+    return set(requested).issubset(set(model_modalities))
+
+
+def all_model_summaries(
+    input_modalities: Optional[Collection[Modality]] = None,
+    output_modalities: Optional[Collection[Modality]] = None,
+    include_legacy: bool = False,
+    providers: Optional[Collection[str]] = None,
+    inference_types: Optional[Collection[InferenceType]] = None,
+    direct_invocation_only: bool = True,
+    region: Optional[str] = None,
+) -> List[ModelSummary]:
+    """Return filtered Bedrock model summaries.
+
+    Defaults: input_modalities={"TEXT"}, output_modalities={"TEXT"}, include_legacy=False,
+    inference_types={"ON_DEMAND"}, direct_invocation_only=True.
+    """
+
+    cache = _ensure_loaded(region)
+    results: List[ModelSummary] = []
+
+    effective_output: Set[Modality] = (
+        set(output_modalities) if output_modalities is not None else {cast("Modality", "TEXT")}
+    )
+    effective_input: Optional[Set[Modality]] = (
+        set(input_modalities) if input_modalities is not None else {cast("Modality", "TEXT")}
+    )
+    provider_filter: Optional[Set[str]] = set(providers) if providers is not None else None
+    effective_inference: Set[InferenceType] = (
+        set(inference_types)
+        if inference_types is not None
+        else {cast("InferenceType", "ON_DEMAND")}
+    )
+
+    for summary in cache.values():
+        lifecycle = (summary.get("modelLifecycle") or {}).get("status")
+        if not include_legacy and lifecycle == "LEGACY":
+            continue
+
+        if provider_filter is not None and summary.get("providerName") not in provider_filter:
+            continue
+
+        # direct invocation only: exclude profile variants like :0:24k or :mm
+        if direct_invocation_only:
+            mid = summary.get("modelId") or ""
+            if mid.count(":") > 1:
+                continue
+
+        # modalities
+        model_inputs: List[Modality] = summary.get("inputModalities", [])  # type: ignore[assignment]
+        model_outputs: List[Modality] = summary.get("outputModalities", [])  # type: ignore[assignment]
+
+        if effective_input is not None and not _matches_modalities(model_inputs, effective_input):
+            continue
+        if effective_output and not _matches_modalities(model_outputs, effective_output):
+            continue
+
+        # inference types
+        model_inference: List[InferenceType] = summary.get("inferenceTypesSupported", [])  # type: ignore[assignment]
+        if effective_inference and not set(effective_inference).issubset(set(model_inference)):
+            continue
+
+        results.append(summary)
+
+    return results
+
+
+def all_bedrock_models(
+    input_modalities: Optional[Collection[Modality]] = None,
+    output_modalities: Optional[Collection[Modality]] = None,
+    include_legacy: bool = False,
+    providers: Optional[Collection[str]] = None,
+    prefix: str = "bedrock.",
+    inference_types: Optional[Collection[InferenceType]] = None,
+    direct_invocation_only: bool = True,
+    region: Optional[str] = None,
+) -> List[str]:
+    """Return model IDs (optionally prefixed) filtered by the given criteria.
+
+    Defaults: output_modalities={"TEXT"}, exclude LEGACY,
+    inference_types={"ON_DEMAND"}, direct_invocation_only=True.
+    """
+
+    summaries = all_model_summaries(
+        input_modalities=input_modalities,
+        output_modalities=output_modalities,
+        include_legacy=include_legacy,
+        providers=providers,
+        inference_types=inference_types,
+        direct_invocation_only=direct_invocation_only,
+        region=region,
+    )
+    ids: List[str] = []
+    for s in summaries:
+        mid = s.get("modelId")
+        if mid:
+            ids.append(mid)
+    if prefix:
+        return [f"{prefix}{mid}" for mid in ids]
+    return ids
+
+
+def get_model_metadata(model_id: str, region: Optional[str] = None) -> Optional[ModelSummary]:
+    cache = _ensure_loaded(region)
+    # Accept either prefixed or plain model IDs
+    plain_id = _strip_prefix(model_id, "bedrock.")
+    return cache.get(plain_id)
+
+
+def list_providers(region: Optional[str] = None) -> List[str]:
+    cache = _ensure_loaded(region)
+    providers = {s.get("providerName") for s in cache.values() if s.get("providerName")}
+    return sorted(providers)  # type: ignore[arg-type]
+
+
+__all__ = [
+    "Modality",
+    "Lifecycle",
+    "ModelSummary",
+    "all_bedrock_models",
+    "all_model_summaries",
+    "get_model_metadata",
+    "list_providers",
+    "refresh_bedrock_models",
+]