fast-agent-mcp 0.4.7__py3-none-any.whl

fast_agent/llm/provider/anthropic/multipart_converter_anthropic.py

@@ -0,0 +1,462 @@
+import re
+from typing import Sequence, Union
+
+from anthropic.types import (
+    Base64ImageSourceParam,
+    Base64PDFSourceParam,
+    ContentBlockParam,
+    DocumentBlockParam,
+    ImageBlockParam,
+    MessageParam,
+    PlainTextSourceParam,
+    TextBlockParam,
+    ToolResultBlockParam,
+    ToolUseBlockParam,
+    URLImageSourceParam,
+    URLPDFSourceParam,
+)
+from mcp.types import (
+    BlobResourceContents,
+    CallToolResult,
+    ContentBlock,
+    EmbeddedResource,
+    ImageContent,
+    PromptMessage,
+    TextContent,
+    TextResourceContents,
+)
+
+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,
+    is_image_content,
+    is_resource_content,
+    is_text_content,
+)
+from fast_agent.mcp.mime_utils import (
+    guess_mime_type,
+    is_image_mime_type,
+    is_text_mime_type,
+)
+from fast_agent.types import PromptMessageExtended
+
+_logger = get_logger("multipart_converter_anthropic")
+
+# List of image MIME types supported by Anthropic API
+SUPPORTED_IMAGE_MIME_TYPES = {"image/jpeg", "image/png", "image/gif", "image/webp"}
+
+
+class AnthropicConverter:
+    """Converts MCP message types to Anthropic API format."""
+
+    @staticmethod
+    def _is_supported_image_type(mime_type: str) -> bool:
+        """Check if the given MIME type is supported by Anthropic's image API.
+
+        Args:
+            mime_type: The MIME type to check
+
+        Returns:
+            True if the MIME type is supported, False otherwise
+        """
+        return mime_type in SUPPORTED_IMAGE_MIME_TYPES
+
+    @staticmethod
+    def convert_to_anthropic(multipart_msg: PromptMessageExtended) -> MessageParam:
+        """
+        Convert a PromptMessageExtended message to Anthropic API format.
+
+        Args:
+            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():
+                sanitized_id = AnthropicConverter._sanitize_tool_id(tool_use_id)
+                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=sanitized_id,
+                        name=name or "unknown_tool",
+                        input=args or {},
+                    )
+                )
+
+            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
+            )
+
+            # 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=all_content_blocks)
+
+    @staticmethod
+    def convert_prompt_message_to_anthropic(message: PromptMessage) -> MessageParam:
+        """
+        Convert a standard PromptMessage to Anthropic API format.
+
+        Args:
+            message: The PromptMessage to convert
+
+        Returns:
+            An Anthropic API MessageParam object
+        """
+        # 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)
+
+    @staticmethod
+    def _convert_content_items(
+        content_items: Sequence[ContentBlock],
+        document_mode: bool = True,
+    ) -> list[ContentBlockParam]:
+        """
+        Convert a list of content items to Anthropic content blocks.
+
+        Args:
+            content_items: Sequence of MCP content items
+            document_mode: Whether to convert text resources to document blocks (True) or text blocks (False)
+
+        Returns:
+            List of Anthropic content blocks
+        """
+        anthropic_blocks: list[ContentBlockParam] = []
+
+        for content_item in content_items:
+            if is_text_content(content_item):
+                # Handle text content
+                text = get_text(content_item)
+                anthropic_blocks.append(TextBlockParam(type="text", text=text))
+
+            elif is_image_content(content_item):
+                # Handle image content
+                image_content = content_item  # type: ImageContent
+                # Check if image MIME type is supported
+                if not AnthropicConverter._is_supported_image_type(image_content.mimeType):
+                    data_size = len(image_content.data) if image_content.data else 0
+                    anthropic_blocks.append(
+                        TextBlockParam(
+                            type="text",
+                            text=f"Image with unsupported format '{image_content.mimeType}' ({data_size} bytes)",
+                        )
+                    )
+                else:
+                    image_data = get_image_data(image_content)
+                    anthropic_blocks.append(
+                        ImageBlockParam(
+                            type="image",
+                            source=Base64ImageSourceParam(
+                                type="base64",
+                                media_type=image_content.mimeType,
+                                data=image_data,
+                            ),
+                        )
+                    )
+
+            elif is_resource_content(content_item):
+                # Handle embedded resource
+                block = AnthropicConverter._convert_embedded_resource(content_item, document_mode)
+                anthropic_blocks.append(block)
+
+        return anthropic_blocks
+
+    @staticmethod
+    def _convert_embedded_resource(
+        resource: EmbeddedResource,
+        document_mode: bool = True,
+    ) -> ContentBlockParam:
+        """
+        Convert EmbeddedResource to appropriate Anthropic block type.
+
+        Args:
+            resource: The embedded resource to convert
+            document_mode: Whether to convert text resources to Document blocks (True) or Text blocks (False)
+
+        Returns:
+            An appropriate ContentBlockParam for the resource
+        """
+        resource_content = resource.resource
+        uri_str = get_resource_uri(resource)
+        uri = getattr(resource_content, "uri", None)
+        is_url: bool = uri and uri.scheme in ("http", "https")
+
+        # Determine MIME type
+        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
+        if mime_type == "image/svg+xml":
+            return AnthropicConverter._convert_svg_resource(resource_content)
+
+        elif is_image_mime_type(mime_type):
+            if not AnthropicConverter._is_supported_image_type(mime_type):
+                return AnthropicConverter._create_fallback_text(
+                    f"Image with unsupported format '{mime_type}'", resource
+                )
+
+            if is_url and uri_str:
+                return ImageBlockParam(
+                    type="image", source=URLImageSourceParam(type="url", url=uri_str)
+                )
+
+            # Try to get image data
+            image_data = get_image_data(resource)
+            if image_data:
+                return ImageBlockParam(
+                    type="image",
+                    source=Base64ImageSourceParam(
+                        type="base64", media_type=mime_type, data=image_data
+                    ),
+                )
+
+            return AnthropicConverter._create_fallback_text("Image missing data", resource)
+
+        elif mime_type == "application/pdf":
+            if is_url and uri_str:
+                return DocumentBlockParam(
+                    type="document",
+                    title=title,
+                    source=URLPDFSourceParam(type="url", url=uri_str),
+                )
+            elif isinstance(resource_content, BlobResourceContents):
+                return DocumentBlockParam(
+                    type="document",
+                    title=title,
+                    source=Base64PDFSourceParam(
+                        type="base64",
+                        media_type="application/pdf",
+                        data=resource_content.blob,
+                    ),
+                )
+            return TextBlockParam(type="text", text=f"[PDF resource missing data: {title}]")
+
+        elif is_text_mime_type(mime_type):
+            text = get_text(resource)
+            if not text:
+                return TextBlockParam(
+                    type="text",
+                    text=f"[Text content could not be extracted from {title}]",
+                )
+
+            # Create document block when in document mode
+            if document_mode:
+                return DocumentBlockParam(
+                    type="document",
+                    title=title,
+                    source=PlainTextSourceParam(
+                        type="text",
+                        media_type="text/plain",
+                        data=text,
+                    ),
+                )
+
+            # Return as simple text block when not in document mode
+            return TextBlockParam(type="text", text=text)
+
+        # Default fallback - convert to text if possible
+        text = get_text(resource)
+        if text:
+            return TextBlockParam(type="text", text=text)
+
+        # This is for binary resources - match the format expected by the test
+        if isinstance(resource.resource, BlobResourceContents) and hasattr(
+            resource.resource, "blob"
+        ):
+            blob_length = len(resource.resource.blob)
+            return TextBlockParam(
+                type="text",
+                text=f"Embedded Resource {uri._url} with unsupported format {mime_type} ({blob_length} characters)",
+            )
+
+        return AnthropicConverter._create_fallback_text(
+            f"Unsupported resource ({mime_type})", resource
+        )
+
+    @staticmethod
+    def _determine_mime_type(
+        resource: Union[TextResourceContents, BlobResourceContents],
+    ) -> str:
+        """
+        Determine the MIME type of a resource.
+
+        Args:
+            resource: The resource to check
+
+        Returns:
+            The MIME type as a string
+        """
+        if getattr(resource, "mimeType", None):
+            return resource.mimeType
+
+        if getattr(resource, "uri", None):
+            return guess_mime_type(resource.uri.serialize_url)
+
+        if hasattr(resource, "blob"):
+            return "application/octet-stream"
+
+        return "text/plain"
+
+    @staticmethod
+    def _convert_svg_resource(resource_content) -> TextBlockParam:
+        """
+        Convert SVG resource to text block with XML code formatting.
+
+        Args:
+            resource_content: The resource content containing SVG data
+
+        Returns:
+            A TextBlockParam with formatted SVG content
+        """
+        # Use get_text helper to extract text from various content types
+        svg_content = get_text(resource_content)
+        if svg_content:
+            return TextBlockParam(type="text", text=f"```xml\n{svg_content}\n```")
+        return TextBlockParam(type="text", text="[SVG content could not be extracted]")
+
+    @staticmethod
+    def _create_fallback_text(
+        message: str, resource: Union[TextContent, ImageContent, EmbeddedResource]
+    ) -> TextBlockParam:
+        """
+        Create a fallback text block for unsupported resource types.
+
+        Args:
+            message: The fallback message
+            resource: The resource that couldn't be converted
+
+        Returns:
+            A TextBlockParam with the fallback message
+        """
+        if isinstance(resource, EmbeddedResource) and hasattr(resource.resource, "uri"):
+            uri = resource.resource.uri
+            return TextBlockParam(type="text", text=f"[{message}: {uri._url}]")
+
+        return TextBlockParam(type="text", text=f"[{message}]")
+
+    @staticmethod
+    def create_tool_results_message(
+        tool_results: list[tuple[str, CallToolResult]],
+    ) -> MessageParam:
+        """
+        Create a user message containing tool results.
+
+        Args:
+            tool_results: List of (tool_use_id, tool_result) tuples
+
+        Returns:
+            A MessageParam with role='user' containing all tool results
+        """
+        content_blocks = []
+
+        for tool_use_id, result in tool_results:
+            sanitized_id = AnthropicConverter._sanitize_tool_id(tool_use_id)
+            # Process each tool result
+            tool_result_blocks = []
+
+            # Process each content item in the result
+            for item in result.content:
+                if isinstance(item, (TextContent, ImageContent)):
+                    blocks = AnthropicConverter._convert_content_items([item], document_mode=False)
+                    tool_result_blocks.extend(blocks)
+                elif isinstance(item, EmbeddedResource):
+                    resource_content = item.resource
+                    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:
+                content_blocks.append(
+                    ToolResultBlockParam(
+                        type="tool_result",
+                        tool_use_id=sanitized_id,
+                        content=tool_result_blocks,
+                        is_error=result.isError,
+                    )
+                )
+            else:
+                # If there's no content, still create a placeholder
+                content_blocks.append(
+                    ToolResultBlockParam(
+                        type="tool_result",
+                        tool_use_id=sanitized_id,
+                        content=[TextBlockParam(type="text", text="[No content in tool result]")],
+                        is_error=result.isError,
+                    )
+                )
+
+            # All content is now included within the tool_result block.
+
+        return MessageParam(role="user", content=content_blocks)
+
+    @staticmethod
+    def _sanitize_tool_id(tool_id: str | None) -> str:
+        """
+        Anthropic tool_use ids must match ^[a-zA-Z0-9_-]+$.
+        Clean any other characters to underscores and provide a stable fallback.
+        """
+        if not tool_id:
+            return "tool"
+        cleaned = re.sub(r"[^a-zA-Z0-9_-]", "_", tool_id)
+        return cleaned or "tool"

fast_agent/llm/provider/bedrock/bedrock_utils.py

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+from typing import Collection, Literal, 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: str | None) -> 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: str | None = 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: str | None = 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: Collection[Modality] | None = None,
+    output_modalities: Collection[Modality] | None = None,
+    include_legacy: bool = False,
+    providers: Collection[str] | None = None,
+    inference_types: Collection[InferenceType] | None = None,
+    direct_invocation_only: bool = True,
+    region: str | None = 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: set[Modality] | None = (
+        set(input_modalities) if input_modalities is not None else {cast("Modality", "TEXT")}
+    )
+    provider_filter: set[str] | None = 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: Collection[Modality] | None = None,
+    output_modalities: Collection[Modality] | None = None,
+    include_legacy: bool = False,
+    providers: Collection[str] | None = None,
+    prefix: str = "bedrock.",
+    inference_types: Collection[InferenceType] | None = None,
+    direct_invocation_only: bool = True,
+    region: str | None = 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: str | None = None) -> ModelSummary | None:
+    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: str | None = 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",
+]