From 771eccfcdf4496e7517ed03d432d40ece56a3cfd Mon Sep 17 00:00:00 2001 From: Greyson LaLonde Date: Wed, 21 Jan 2026 20:05:33 -0500 Subject: [PATCH] feat: add multimodal support to LLM providers - Add format_multimodal_content() to all LLM providers - Support inline base64 and file reference formats - Add FileResolver integration for upload caching - Add module exports for files package --- lib/crewai/src/crewai/llm.py | 124 ++++++- lib/crewai/src/crewai/llms/base_llm.py | 49 +++ .../llms/providers/anthropic/completion.py | 139 ++++++++ .../crewai/llms/providers/azure/completion.py | 84 +++++ .../llms/providers/bedrock/completion.py | 90 +++++ .../llms/providers/gemini/completion.py | 138 +++++++- .../llms/providers/openai/completion.py | 100 ++++++ .../src/crewai/utilities/files/__init__.py | 210 +++++++++++ .../utilities/files/processing/__init__.py | 62 ++++ ...ultimodalIntegration.test_analyze_pdf.yaml | 104 ++++++ ...imodalIntegration.test_describe_image.yaml | 105 ++++++ ...ration.test_generic_file_image_openai.yaml | 114 ++++++ ...gration.test_generic_file_mixed_types.yaml | 106 ++++++ ...ation.test_generic_file_pdf_anthropic.yaml | 104 ++++++ ...ntegration.test_describe_image_claude.yaml | 90 +++++ ...Integration.test_describe_image_gpt4o.yaml | 116 ++++++ ...egration.test_mixed_content_anthropic.yaml | 106 ++++++ ...tegration.test_multiple_images_openai.yaml | 113 ++++++ ...imodalIntegration.test_describe_image.yaml | 114 ++++++ .../tests/llms/test_multimodal_integration.py | 329 ++++++++++++++++++ 20 files changed, 2382 insertions(+), 15 deletions(-) create mode 100644 lib/crewai/src/crewai/utilities/files/__init__.py create mode 100644 lib/crewai/src/crewai/utilities/files/processing/__init__.py create mode 100644 lib/crewai/tests/cassettes/llms/TestAnthropicMultimodalIntegration.test_analyze_pdf.yaml create mode 100644 lib/crewai/tests/cassettes/llms/TestAnthropicMultimodalIntegration.test_describe_image.yaml create mode 100644 lib/crewai/tests/cassettes/llms/TestGenericFileIntegration.test_generic_file_image_openai.yaml create mode 100644 lib/crewai/tests/cassettes/llms/TestGenericFileIntegration.test_generic_file_mixed_types.yaml create mode 100644 lib/crewai/tests/cassettes/llms/TestGenericFileIntegration.test_generic_file_pdf_anthropic.yaml create mode 100644 lib/crewai/tests/cassettes/llms/TestLiteLLMMultimodalIntegration.test_describe_image_claude.yaml create mode 100644 lib/crewai/tests/cassettes/llms/TestLiteLLMMultimodalIntegration.test_describe_image_gpt4o.yaml create mode 100644 lib/crewai/tests/cassettes/llms/TestMultipleFilesIntegration.test_mixed_content_anthropic.yaml create mode 100644 lib/crewai/tests/cassettes/llms/TestMultipleFilesIntegration.test_multiple_images_openai.yaml create mode 100644 lib/crewai/tests/cassettes/llms/TestOpenAIMultimodalIntegration.test_describe_image.yaml create mode 100644 lib/crewai/tests/llms/test_multimodal_integration.py diff --git a/lib/crewai/src/crewai/llm.py b/lib/crewai/src/crewai/llm.py index 8bc1fe648..4a7984b95 100644 --- a/lib/crewai/src/crewai/llm.py +++ b/lib/crewai/src/crewai/llm.py @@ -70,6 +70,7 @@ if TYPE_CHECKING: from crewai.llms.providers.anthropic.completion import AnthropicThinkingConfig from crewai.task import Task from crewai.tools.base_tool import BaseTool + from crewai.utilities.files import FileInput, UploadCache from crewai.utilities.types import LLMMessage try: @@ -683,7 +684,7 @@ class LLM(BaseLLM): "temperature": self.temperature, "top_p": self.top_p, "n": self.n, - "stop": self.stop, + "stop": self.stop or None, "max_tokens": self.max_tokens or self.max_completion_tokens, "presence_penalty": self.presence_penalty, "frequency_penalty": self.frequency_penalty, @@ -931,7 +932,6 @@ class LLM(BaseLLM): self._handle_streaming_callbacks(callbacks, usage_info, last_chunk) if not tool_calls or not available_functions: - if response_model and self.is_litellm: instructor_instance = InternalInstructor( content=full_response, @@ -1144,8 +1144,12 @@ class LLM(BaseLLM): if response_model: params["response_model"] = response_model response = litellm.completion(**params) - - if hasattr(response,"usage") and not isinstance(response.usage, type) and response.usage: + + if ( + hasattr(response, "usage") + and not isinstance(response.usage, type) + and response.usage + ): usage_info = response.usage self._track_token_usage_internal(usage_info) @@ -1273,7 +1277,11 @@ class LLM(BaseLLM): params["response_model"] = response_model response = await litellm.acompletion(**params) - if hasattr(response,"usage") and not isinstance(response.usage, type) and response.usage: + if ( + hasattr(response, "usage") + and not isinstance(response.usage, type) + and response.usage + ): usage_info = response.usage self._track_token_usage_internal(usage_info) @@ -1363,7 +1371,7 @@ class LLM(BaseLLM): """ full_response = "" chunk_count = 0 - + usage_info = None accumulated_tool_args: defaultdict[int, AccumulatedToolArgs] = defaultdict( @@ -2205,3 +2213,107 @@ class LLM(BaseLLM): stop=copy.deepcopy(self.stop, memo) if self.stop else None, **filtered_params, ) + + def supports_multimodal(self) -> bool: + """Check if the model supports multimodal inputs. + + For litellm, check common vision-enabled model prefixes. + + Returns: + True if the model likely supports images. + """ + vision_prefixes = ( + "gpt-4o", + "gpt-4-turbo", + "gpt-4-vision", + "gpt-4.1", + "claude-3", + "claude-4", + "gemini", + ) + model_lower = self.model.lower() + return any( + model_lower.startswith(p) or f"/{p}" in model_lower for p in vision_prefixes + ) + + def supported_multimodal_content_types(self) -> list[str]: + """Get content types supported for multimodal input. + + Determines supported types based on the underlying model. + + Returns: + List of supported MIME type prefixes. + """ + if not self.supports_multimodal(): + return [] + + model_lower = self.model.lower() + + if "gemini" in model_lower: + return ["image/", "audio/", "video/", "application/pdf", "text/"] + if "claude-3" in model_lower or "claude-4" in model_lower: + return ["image/", "application/pdf"] + return ["image/"] + + def format_multimodal_content( + self, + files: dict[str, FileInput], + upload_cache: UploadCache | None = None, + ) -> list[dict[str, Any]]: + """Format files as multimodal content blocks for litellm. + + Uses OpenAI-compatible format which litellm translates to provider format. + Uses FileResolver for consistent base64 encoding. + + Args: + files: Dictionary mapping file names to FileInput objects. + upload_cache: Optional cache (not used by litellm but kept for interface consistency). + + Returns: + List of content blocks in OpenAI's expected format. + """ + import base64 + + from crewai.utilities.files import ( + FileResolver, + FileResolverConfig, + InlineBase64, + ) + + if not self.supports_multimodal(): + return [] + + content_blocks: list[dict[str, Any]] = [] + supported_types = self.supported_multimodal_content_types() + + # LiteLLM uses OpenAI-compatible format + config = FileResolverConfig(prefer_upload=False) + resolver = FileResolver(config=config, upload_cache=upload_cache) + + for file_input in files.values(): + content_type = file_input.content_type + if not any(content_type.startswith(t) for t in supported_types): + continue + + resolved = resolver.resolve(file_input, "openai") + + if isinstance(resolved, InlineBase64): + content_blocks.append( + { + "type": "image_url", + "image_url": { + "url": f"data:{resolved.content_type};base64,{resolved.data}" + }, + } + ) + else: + # Fallback to direct base64 encoding + data = base64.b64encode(file_input.read()).decode("ascii") + content_blocks.append( + { + "type": "image_url", + "image_url": {"url": f"data:{content_type};base64,{data}"}, + } + ) + + return content_blocks diff --git a/lib/crewai/src/crewai/llms/base_llm.py b/lib/crewai/src/crewai/llms/base_llm.py index c09c26453..a3ed8a547 100644 --- a/lib/crewai/src/crewai/llms/base_llm.py +++ b/lib/crewai/src/crewai/llms/base_llm.py @@ -35,6 +35,7 @@ if TYPE_CHECKING: from crewai.agent.core import Agent from crewai.task import Task from crewai.tools.base_tool import BaseTool + from crewai.utilities.files import FileInput, UploadCache from crewai.utilities.types import LLMMessage @@ -280,6 +281,54 @@ class BaseLLM(ABC): # Default implementation - subclasses should override with model-specific values return DEFAULT_CONTEXT_WINDOW_SIZE + def supports_multimodal(self) -> bool: + """Check if the LLM supports multimodal inputs. + + Returns: + True if the LLM supports images, PDFs, audio, or video. + """ + return False + + def supported_multimodal_content_types(self) -> list[str]: + """Get the content types supported by this LLM for multimodal input. + + Returns: + List of supported MIME type prefixes (e.g., ["image/", "application/pdf"]). + """ + return [] + + def format_multimodal_content( + self, + files: dict[str, FileInput], + upload_cache: UploadCache | None = None, + ) -> list[dict[str, Any]]: + """Format files as multimodal content blocks for the LLM. + + Subclasses should override this to provide provider-specific formatting. + + Args: + files: Dictionary mapping file names to FileInput objects. + upload_cache: Optional cache for tracking uploaded files. + + Returns: + List of content blocks in the provider's expected format. + """ + return [] + + def format_text_content(self, text: str) -> dict[str, Any]: + """Format text as a content block for the LLM. + + Default implementation uses OpenAI/Anthropic format. + Subclasses should override for provider-specific formatting. + + Args: + text: The text content to format. + + Returns: + A content block in the provider's expected format. + """ + return {"type": "text", "text": text} + # Common helper methods for native SDK implementations def _emit_call_started_event( diff --git a/lib/crewai/src/crewai/llms/providers/anthropic/completion.py b/lib/crewai/src/crewai/llms/providers/anthropic/completion.py index 5266c9097..658d3fc66 100644 --- a/lib/crewai/src/crewai/llms/providers/anthropic/completion.py +++ b/lib/crewai/src/crewai/llms/providers/anthropic/completion.py @@ -1,5 +1,6 @@ from __future__ import annotations +import base64 import json import logging import os @@ -20,6 +21,9 @@ from crewai.utilities.types import LLMMessage if TYPE_CHECKING: from crewai.llms.hooks.base import BaseInterceptor + from crewai.utilities.files import FileInput, UploadCache + +DEFAULT_CACHE_TTL = "ephemeral" try: from anthropic import Anthropic, AsyncAnthropic @@ -1231,3 +1235,138 @@ class AnthropicCompletion(BaseLLM): "total_tokens": input_tokens + output_tokens, } return {"total_tokens": 0} + + def supports_multimodal(self) -> bool: + """Check if the model supports multimodal inputs. + + All Claude 3+ models support vision and PDFs. + + Returns: + True if the model supports images and PDFs. + """ + return "claude-3" in self.model.lower() or "claude-4" in self.model.lower() + + def supported_multimodal_content_types(self) -> list[str]: + """Get content types supported by Anthropic for multimodal input. + + Returns: + List of supported MIME type prefixes. + """ + if not self.supports_multimodal(): + return [] + return ["image/", "application/pdf"] + + def format_multimodal_content( + self, + files: dict[str, FileInput], + upload_cache: UploadCache | None = None, + enable_caching: bool = True, + cache_ttl: str | None = None, + ) -> list[dict[str, Any]]: + """Format files as Anthropic multimodal content blocks. + + Anthropic supports both base64 inline format and file references via Files API. + Uses FileResolver to determine the best delivery method based on file size. + Supports prompt caching to reduce costs and latency for repeated file usage. + + Args: + files: Dictionary mapping file names to FileInput objects. + upload_cache: Optional cache for tracking uploaded files. + enable_caching: Whether to add cache_control markers (default: True). + cache_ttl: Cache TTL - "ephemeral" (5min) or "1h" (1hr for supported models). + + Returns: + List of content blocks in Anthropic's expected format. + """ + if not self.supports_multimodal(): + return [] + + from crewai.utilities.files import ( + FileReference, + FileResolver, + FileResolverConfig, + InlineBase64, + ) + + content_blocks: list[dict[str, Any]] = [] + supported_types = self.supported_multimodal_content_types() + + config = FileResolverConfig(prefer_upload=False) + resolver = FileResolver(config=config, upload_cache=upload_cache) + + file_list = list(files.values()) + num_files = len(file_list) + + for i, file_input in enumerate(file_list): + content_type = file_input.content_type + if not any(content_type.startswith(t) for t in supported_types): + continue + + resolved = resolver.resolve(file_input, "anthropic") + block: dict[str, Any] = {} + + if isinstance(resolved, FileReference): + if content_type.startswith("image/"): + block = { + "type": "image", + "source": { + "type": "file", + "file_id": resolved.file_id, + }, + } + elif content_type == "application/pdf": + block = { + "type": "document", + "source": { + "type": "file", + "file_id": resolved.file_id, + }, + } + elif isinstance(resolved, InlineBase64): + if content_type.startswith("image/"): + block = { + "type": "image", + "source": { + "type": "base64", + "media_type": resolved.content_type, + "data": resolved.data, + }, + } + elif content_type == "application/pdf": + block = { + "type": "document", + "source": { + "type": "base64", + "media_type": resolved.content_type, + "data": resolved.data, + }, + } + else: + data = base64.b64encode(file_input.read()).decode("ascii") + if content_type.startswith("image/"): + block = { + "type": "image", + "source": { + "type": "base64", + "media_type": content_type, + "data": data, + }, + } + elif content_type == "application/pdf": + block = { + "type": "document", + "source": { + "type": "base64", + "media_type": content_type, + "data": data, + }, + } + + if block and enable_caching and i == num_files - 1: + cache_control: dict[str, str] = {"type": cache_ttl or DEFAULT_CACHE_TTL} + block["cache_control"] = cache_control + + if block: + content_blocks.append(block) + + return content_blocks diff --git a/lib/crewai/src/crewai/llms/providers/azure/completion.py b/lib/crewai/src/crewai/llms/providers/azure/completion.py index 33502bd39..8efd83405 100644 --- a/lib/crewai/src/crewai/llms/providers/azure/completion.py +++ b/lib/crewai/src/crewai/llms/providers/azure/completion.py @@ -1,5 +1,6 @@ from __future__ import annotations +import base64 import json import logging import os @@ -18,6 +19,7 @@ from crewai.utilities.types import LLMMessage if TYPE_CHECKING: from crewai.llms.hooks.base import BaseInterceptor + from crewai.utilities.files import FileInput, UploadCache try: @@ -1016,3 +1018,85 @@ class AzureCompletion(BaseLLM): async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None: """Async context manager exit.""" await self.aclose() + + def supports_multimodal(self) -> bool: + """Check if the model supports multimodal inputs. + + Azure OpenAI vision-enabled models include GPT-4o and GPT-4 Turbo with Vision. + + Returns: + True if the model supports images. + """ + vision_models = ("gpt-4o", "gpt-4-turbo", "gpt-4-vision", "gpt-4v") + return any(self.model.lower().startswith(m) for m in vision_models) + + def supported_multimodal_content_types(self) -> list[str]: + """Get content types supported by Azure for multimodal input. + + Returns: + List of supported MIME type prefixes. + """ + if not self.supports_multimodal(): + return [] + return ["image/"] + + def format_multimodal_content( + self, + files: dict[str, FileInput], + upload_cache: UploadCache | None = None, + ) -> list[dict[str, Any]]: + """Format files as Azure OpenAI multimodal content blocks. + + Azure OpenAI uses the same image_url format as OpenAI. + Uses FileResolver for consistent base64 encoding. + + Args: + files: Dictionary mapping file names to FileInput objects. + upload_cache: Optional cache (not used by Azure but kept for interface consistency). + + Returns: + List of content blocks in Azure OpenAI's expected format. + """ + if not self.supports_multimodal(): + return [] + + from crewai.utilities.files import ( + FileResolver, + FileResolverConfig, + InlineBase64, + ) + + content_blocks: list[dict[str, Any]] = [] + supported_types = self.supported_multimodal_content_types() + + # Azure doesn't support file uploads for images, so just use inline + config = FileResolverConfig(prefer_upload=False) + resolver = FileResolver(config=config, upload_cache=upload_cache) + + for file_input in files.values(): + content_type = file_input.content_type + if not any(content_type.startswith(t) for t in supported_types): + continue + + resolved = resolver.resolve(file_input, "azure") + + if isinstance(resolved, InlineBase64): + content_blocks.append( + { + "type": "image_url", + "image_url": { + "url": f"data:{resolved.content_type};base64,{resolved.data}" + }, + } + ) + else: + # Fallback to direct base64 encoding + data = base64.b64encode(file_input.read()).decode("ascii") + content_blocks.append( + { + "type": "image_url", + "image_url": {"url": f"data:{content_type};base64,{data}"}, + } + ) + + return content_blocks diff --git a/lib/crewai/src/crewai/llms/providers/bedrock/completion.py b/lib/crewai/src/crewai/llms/providers/bedrock/completion.py index f66b1cf31..6ffddb791 100644 --- a/lib/crewai/src/crewai/llms/providers/bedrock/completion.py +++ b/lib/crewai/src/crewai/llms/providers/bedrock/completion.py @@ -33,6 +33,7 @@ if TYPE_CHECKING: ) from crewai.llms.hooks.base import BaseInterceptor + from crewai.utilities.files import FileInput, UploadCache try: @@ -1450,3 +1451,92 @@ class BedrockCompletion(BaseLLM): # Default context window size return int(8192 * CONTEXT_WINDOW_USAGE_RATIO) + + def supports_multimodal(self) -> bool: + """Check if the model supports multimodal inputs. + + Claude models on Bedrock support vision. + + Returns: + True if the model supports images. + """ + vision_models = ("anthropic.claude-3",) + return any(self.model.lower().startswith(m) for m in vision_models) + + def supported_multimodal_content_types(self) -> list[str]: + """Get content types supported by Bedrock for multimodal input. + + Returns: + List of supported MIME type prefixes. + """ + if not self.supports_multimodal(): + return [] + return ["image/", "application/pdf"] + + def format_multimodal_content( + self, + files: dict[str, FileInput], + upload_cache: UploadCache | None = None, + ) -> list[dict[str, Any]]: + """Format files as Bedrock Converse API multimodal content blocks. + + Bedrock Converse API uses specific formats for images and documents with raw bytes. + Uses FileResolver to get InlineBytes format for Bedrock's byte-based API. + + Args: + files: Dictionary mapping file names to FileInput objects. + upload_cache: Optional cache (not used by Bedrock but kept for interface consistency). + + Returns: + List of content blocks in Bedrock's expected format. + """ + if not self.supports_multimodal(): + return [] + + from crewai.utilities.files import ( + FileResolver, + FileResolverConfig, + InlineBytes, + ) + + content_blocks: list[dict[str, Any]] = [] + + # Bedrock uses raw bytes, configure resolver accordingly + config = FileResolverConfig(prefer_upload=False, use_bytes_for_bedrock=True) + resolver = FileResolver(config=config, upload_cache=upload_cache) + + for name, file_input in files.items(): + content_type = file_input.content_type + + resolved = resolver.resolve(file_input, "bedrock") + + if isinstance(resolved, InlineBytes): + file_bytes = resolved.data + else: + # Fallback to reading directly + file_bytes = file_input.read() + + if content_type.startswith("image/"): + media_type = content_type.split("/")[-1] + if media_type == "jpg": + media_type = "jpeg" + content_blocks.append( + { + "image": { + "format": media_type, + "source": {"bytes": file_bytes}, + } + } + ) + elif content_type == "application/pdf": + content_blocks.append( + { + "document": { + "name": name, + "format": "pdf", + "source": {"bytes": file_bytes}, + } + } + ) + + return content_blocks diff --git a/lib/crewai/src/crewai/llms/providers/gemini/completion.py b/lib/crewai/src/crewai/llms/providers/gemini/completion.py index 962082755..d5758248a 100644 --- a/lib/crewai/src/crewai/llms/providers/gemini/completion.py +++ b/lib/crewai/src/crewai/llms/providers/gemini/completion.py @@ -1,5 +1,6 @@ from __future__ import annotations +import base64 import json import logging import os @@ -19,6 +20,10 @@ from crewai.utilities.types import LLMMessage if TYPE_CHECKING: from crewai.llms.hooks.base import BaseInterceptor + from crewai.utilities.files import ( + FileInput, + UploadCache, + ) try: @@ -516,17 +521,31 @@ class GeminiCompletion(BaseLLM): role = message["role"] content = message["content"] - # Convert content to string if it's a list + # Build parts list from content + parts: list[types.Part] = [] if isinstance(content, list): - text_content = " ".join( - str(item.get("text", "")) if isinstance(item, dict) else str(item) - for item in content - ) + for item in content: + if isinstance(item, dict): + if "text" in item: + parts.append(types.Part.from_text(text=str(item["text"]))) + elif "inlineData" in item: + inline = item["inlineData"] + parts.append( + types.Part.from_bytes( + data=base64.b64decode(inline["data"]), + mime_type=inline["mimeType"], + ) + ) + else: + parts.append(types.Part.from_text(text=str(item))) else: - text_content = str(content) if content else "" + parts.append(types.Part.from_text(text=str(content) if content else "")) if role == "system": # Extract system instruction - Gemini handles it separately + text_content = " ".join( + p.text for p in parts if hasattr(p, "text") and p.text + ) if system_instruction: system_instruction += f"\n\n{text_content}" else: @@ -536,9 +555,7 @@ class GeminiCompletion(BaseLLM): gemini_role = "model" if role == "assistant" else "user" # Create Content object - gemini_content = types.Content( - role=gemini_role, parts=[types.Part.from_text(text=text_content)] - ) + gemini_content = types.Content(role=gemini_role, parts=parts) contents.append(gemini_content) return contents, system_instruction @@ -1060,3 +1077,106 @@ class GeminiCompletion(BaseLLM): ) ) return result + + def supports_multimodal(self) -> bool: + """Check if the model supports multimodal inputs. + + Gemini models support images, audio, video, and PDFs. + + Returns: + True if the model supports multimodal inputs. + """ + return True + + def supported_multimodal_content_types(self) -> list[str]: + """Get content types supported by Gemini for multimodal input. + + Returns: + List of supported MIME type prefixes. + """ + return ["image/", "audio/", "video/", "application/pdf", "text/"] + + def format_multimodal_content( + self, + files: dict[str, FileInput], + upload_cache: UploadCache | None = None, + ) -> list[dict[str, Any]]: + """Format files as Gemini multimodal content blocks. + + Gemini supports both inlineData format and file references via File API. + Uses FileResolver to determine the best delivery method based on file size. + + Args: + files: Dictionary mapping file names to FileInput objects. + upload_cache: Optional cache for tracking uploaded files. + + Returns: + List of content blocks in Gemini's expected format. + """ + from crewai.utilities.files import ( + FileReference, + FileResolver, + FileResolverConfig, + InlineBase64, + ) + + content_blocks: list[dict[str, Any]] = [] + supported_types = self.supported_multimodal_content_types() + + # Create resolver with optional cache + config = FileResolverConfig(prefer_upload=False) + resolver = FileResolver(config=config, upload_cache=upload_cache) + + for file_input in files.values(): + content_type = file_input.content_type + if not any(content_type.startswith(t) for t in supported_types): + continue + + resolved = resolver.resolve(file_input, "gemini") + + if isinstance(resolved, FileReference) and resolved.file_uri: + # Use file reference format for uploaded files + content_blocks.append( + { + "fileData": { + "mimeType": resolved.content_type, + "fileUri": resolved.file_uri, + } + } + ) + elif isinstance(resolved, InlineBase64): + # Use inline format for smaller files + content_blocks.append( + { + "inlineData": { + "mimeType": resolved.content_type, + "data": resolved.data, + } + } + ) + else: + # Fallback to base64 encoding + data = base64.b64encode(file_input.read()).decode("ascii") + content_blocks.append( + { + "inlineData": { + "mimeType": content_type, + "data": data, + } + } + ) + + return content_blocks + + def format_text_content(self, text: str) -> dict[str, Any]: + """Format text as a Gemini content block. + + Gemini uses {"text": "..."} format instead of {"type": "text", "text": "..."}. + + Args: + text: The text content to format. + + Returns: + A content block in Gemini's expected format. + """ + return {"text": text} diff --git a/lib/crewai/src/crewai/llms/providers/openai/completion.py b/lib/crewai/src/crewai/llms/providers/openai/completion.py index 35a50ce43..78946a782 100644 --- a/lib/crewai/src/crewai/llms/providers/openai/completion.py +++ b/lib/crewai/src/crewai/llms/providers/openai/completion.py @@ -1,5 +1,6 @@ from __future__ import annotations +import base64 from collections.abc import AsyncIterator import json import logging @@ -30,6 +31,7 @@ if TYPE_CHECKING: from crewai.llms.hooks.base import BaseInterceptor from crewai.task import Task from crewai.tools.base_tool import BaseTool + from crewai.utilities.files import FileInput, UploadCache class OpenAICompletion(BaseLLM): @@ -1048,3 +1050,101 @@ class OpenAICompletion(BaseLLM): formatted_messages.append(message) return formatted_messages + + def supports_multimodal(self) -> bool: + """Check if the model supports multimodal inputs. + + OpenAI vision-enabled models include GPT-4o, GPT-4.1, and o-series. + + Returns: + True if the model supports images. + """ + vision_models = ( + "gpt-4o", + "gpt-4.1", + "gpt-4-turbo", + "gpt-4-vision", + "o1", + "o3", + "o4", + ) + return any(self.model.lower().startswith(m) for m in vision_models) + + def supported_multimodal_content_types(self) -> list[str]: + """Get content types supported by OpenAI for multimodal input. + + Returns: + List of supported MIME type prefixes. + """ + if not self.supports_multimodal(): + return [] + return ["image/"] + + def format_multimodal_content( + self, + files: dict[str, FileInput], + upload_cache: UploadCache | None = None, + ) -> list[dict[str, Any]]: + """Format files as OpenAI multimodal content blocks. + + OpenAI supports both base64 data URLs and file_id references via Files API. + Uses FileResolver to determine the best delivery method based on file size. + + Args: + files: Dictionary mapping file names to FileInput objects. + upload_cache: Optional cache for tracking uploaded files. + + Returns: + List of content blocks in OpenAI's expected format. + """ + if not self.supports_multimodal(): + return [] + + from crewai.utilities.files import ( + FileReference, + FileResolver, + FileResolverConfig, + InlineBase64, + ) + + content_blocks: list[dict[str, Any]] = [] + supported_types = self.supported_multimodal_content_types() + + config = FileResolverConfig(prefer_upload=False) + resolver = FileResolver(config=config, upload_cache=upload_cache) + + for file_input in files.values(): + content_type = file_input.content_type + if not any(content_type.startswith(t) for t in supported_types): + continue + + resolved = resolver.resolve(file_input, "openai") + + if isinstance(resolved, FileReference): + content_blocks.append( + { + "type": "file", + "file": { + "file_id": resolved.file_id, + }, + } + ) + elif isinstance(resolved, InlineBase64): + content_blocks.append( + { + "type": "image_url", + "image_url": { + "url": f"data:{resolved.content_type};base64,{resolved.data}" + }, + } + ) + else: + data = base64.b64encode(file_input.read()).decode("ascii") + content_blocks.append( + { + "type": "image_url", + "image_url": {"url": f"data:{content_type};base64,{data}"}, + } + ) + + return content_blocks diff --git a/lib/crewai/src/crewai/utilities/files/__init__.py b/lib/crewai/src/crewai/utilities/files/__init__.py new file mode 100644 index 000000000..fcd235e15 --- /dev/null +++ b/lib/crewai/src/crewai/utilities/files/__init__.py @@ -0,0 +1,210 @@ +"""File handling utilities for crewAI tasks.""" + +from crewai.utilities.files.cleanup import ( + cleanup_expired_files, + cleanup_provider_files, + cleanup_uploaded_files, +) +from crewai.utilities.files.content_types import ( + AudioContentType, + AudioExtension, + AudioFile, + BaseFile, + File, + FileMode, + ImageContentType, + ImageExtension, + ImageFile, + PDFContentType, + PDFExtension, + PDFFile, + TextContentType, + TextExtension, + TextFile, + VideoContentType, + VideoExtension, + VideoFile, +) +from crewai.utilities.files.file import ( + FileBytes, + FilePath, + FileSource, + FileSourceInput, + FileStream, + RawFileInput, +) +from crewai.utilities.files.processing import ( + ANTHROPIC_CONSTRAINTS, + BEDROCK_CONSTRAINTS, + GEMINI_CONSTRAINTS, + OPENAI_CONSTRAINTS, + AudioConstraints, + FileHandling, + FileProcessingError, + FileProcessor, + FileTooLargeError, + FileValidationError, + ImageConstraints, + PDFConstraints, + ProcessingDependencyError, + ProviderConstraints, + UnsupportedFileTypeError, + VideoConstraints, + get_constraints_for_provider, +) +from crewai.utilities.files.resolved import ( + FileReference, + InlineBase64, + InlineBytes, + ResolvedFile, + ResolvedFileType, + UrlReference, +) +from crewai.utilities.files.resolver import ( + FileResolver, + FileResolverConfig, + create_resolver, +) +from crewai.utilities.files.upload_cache import ( + CachedUpload, + UploadCache, + get_upload_cache, + reset_upload_cache, +) +from crewai.utilities.files.uploaders import FileUploader, UploadResult, get_uploader + + +FileInput = AudioFile | File | ImageFile | PDFFile | TextFile | VideoFile + + +def wrap_file_source(source: FileSource) -> FileInput: + """Wrap a FileSource in the appropriate typed FileInput wrapper. + + Args: + source: The file source to wrap. + + Returns: + Typed FileInput wrapper based on content type. + """ + content_type = source.content_type + + if content_type.startswith("image/"): + return ImageFile(source=source) + if content_type.startswith("audio/"): + return AudioFile(source=source) + if content_type.startswith("video/"): + return VideoFile(source=source) + if content_type == "application/pdf": + return PDFFile(source=source) + # Default to text for anything else + return TextFile(source=source) + + +def normalize_input_files( + input_files: list[FileSourceInput | FileInput], +) -> dict[str, FileInput]: + """Convert a list of file sources to a named dictionary of FileInputs. + + Args: + input_files: List of file source inputs or File objects. + + Returns: + Dictionary mapping names to FileInput wrappers. + """ + from pathlib import Path + + result: dict[str, FileInput] = {} + + for i, item in enumerate(input_files): + # If it's already a typed File wrapper, use it directly + if isinstance(item, BaseFile): + name = item.filename or f"file_{i}" + # Remove extension from name for cleaner keys + if "." in name: + name = name.rsplit(".", 1)[0] + result[name] = item + continue + + file_source: FilePath | FileBytes | FileStream + if isinstance(item, (FilePath, FileBytes, FileStream)): + file_source = item + elif isinstance(item, Path): + file_source = FilePath(path=item) + elif isinstance(item, str): + file_source = FilePath(path=Path(item)) + elif isinstance(item, (bytes, memoryview)): + file_source = FileBytes(data=bytes(item)) + else: + continue + + name = file_source.filename or f"file_{i}" + result[name] = wrap_file_source(file_source) + + return result + + +__all__ = [ + "ANTHROPIC_CONSTRAINTS", + "BEDROCK_CONSTRAINTS", + "GEMINI_CONSTRAINTS", + "OPENAI_CONSTRAINTS", + "AudioConstraints", + "AudioContentType", + "AudioExtension", + "AudioFile", + "BaseFile", + "CachedUpload", + "File", + "FileBytes", + "FileHandling", + "FileInput", + "FileMode", + "FilePath", + "FileProcessingError", + "FileProcessor", + "FileReference", + "FileResolver", + "FileResolverConfig", + "FileSource", + "FileSourceInput", + "FileStream", + "FileTooLargeError", + "FileUploader", + "FileValidationError", + "ImageConstraints", + "ImageContentType", + "ImageExtension", + "ImageFile", + "InlineBase64", + "InlineBytes", + "PDFConstraints", + "PDFContentType", + "PDFExtension", + "PDFFile", + "ProcessingDependencyError", + "ProviderConstraints", + "RawFileInput", + "ResolvedFile", + "ResolvedFileType", + "TextContentType", + "TextExtension", + "TextFile", + "UnsupportedFileTypeError", + "UploadCache", + "UploadResult", + "UrlReference", + "VideoConstraints", + "VideoContentType", + "VideoExtension", + "VideoFile", + "cleanup_expired_files", + "cleanup_provider_files", + "cleanup_uploaded_files", + "create_resolver", + "get_constraints_for_provider", + "get_upload_cache", + "get_uploader", + "normalize_input_files", + "reset_upload_cache", + "wrap_file_source", +] diff --git a/lib/crewai/src/crewai/utilities/files/processing/__init__.py b/lib/crewai/src/crewai/utilities/files/processing/__init__.py new file mode 100644 index 000000000..cfe44a372 --- /dev/null +++ b/lib/crewai/src/crewai/utilities/files/processing/__init__.py @@ -0,0 +1,62 @@ +"""File processing module for multimodal content handling. + +This module provides validation, transformation, and processing utilities +for files used in multimodal LLM interactions. +""" + +from crewai.utilities.files.processing.constraints import ( + ANTHROPIC_CONSTRAINTS, + BEDROCK_CONSTRAINTS, + GEMINI_CONSTRAINTS, + OPENAI_CONSTRAINTS, + AudioConstraints, + ImageConstraints, + PDFConstraints, + ProviderConstraints, + VideoConstraints, + get_constraints_for_provider, +) +from crewai.utilities.files.processing.enums import FileHandling +from crewai.utilities.files.processing.exceptions import ( + FileProcessingError, + FileTooLargeError, + FileValidationError, + ProcessingDependencyError, + UnsupportedFileTypeError, +) +from crewai.utilities.files.processing.processor import FileProcessor +from crewai.utilities.files.processing.validators import ( + validate_audio, + validate_file, + validate_image, + validate_pdf, + validate_text, + validate_video, +) + + +__all__ = [ + "ANTHROPIC_CONSTRAINTS", + "BEDROCK_CONSTRAINTS", + "GEMINI_CONSTRAINTS", + "OPENAI_CONSTRAINTS", + "AudioConstraints", + "FileHandling", + "FileProcessingError", + "FileProcessor", + "FileTooLargeError", + "FileValidationError", + "ImageConstraints", + "PDFConstraints", + "ProcessingDependencyError", + "ProviderConstraints", + "UnsupportedFileTypeError", + "VideoConstraints", + "get_constraints_for_provider", + "validate_audio", + "validate_file", + "validate_image", + "validate_pdf", + "validate_text", + "validate_video", +] diff --git a/lib/crewai/tests/cassettes/llms/TestAnthropicMultimodalIntegration.test_analyze_pdf.yaml b/lib/crewai/tests/cassettes/llms/TestAnthropicMultimodalIntegration.test_analyze_pdf.yaml new file mode 100644 index 000000000..d5fbbd6bd --- /dev/null +++ b/lib/crewai/tests/cassettes/llms/TestAnthropicMultimodalIntegration.test_analyze_pdf.yaml @@ -0,0 +1,104 @@ +interactions: +- request: + body: '{"max_tokens":4096,"messages":[{"role":"user","content":[{"type":"text","text":"What + type of document is this? Answer in one word."},{"type":"document","source":{"type":"base64","media_type":"application/pdf","data":"JVBERi0xLjQKMSAwIG9iaiA8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4gZW5kb2JqCjIgMCBvYmogPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4gZW5kb2JqCjMgMCBvYmogPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSA+PiBlbmRvYmoKeHJlZgowIDQKMDAwMDAwMDAwMCA2NTUzNSBmCjAwMDAwMDAwMDkgMDAwMDAgbgowMDAwMDAwMDU4IDAwMDAwIG4KMDAwMDAwMDExNSAwMDAwMCBuCnRyYWlsZXIgPDwgL1NpemUgNCAvUm9vdCAxIDAgUiA+PgpzdGFydHhyZWYKMTk2CiUlRU9GCg=="},"cache_control":{"type":"ephemeral"}}]}],"model":"claude-3-5-haiku-20241022","stream":false}' + headers: + User-Agent: + - X-USER-AGENT-XXX + accept: + - application/json + accept-encoding: + - ACCEPT-ENCODING-XXX + anthropic-version: + - '2023-06-01' + connection: + - keep-alive + content-length: + - '748' + content-type: + - application/json + host: + - api.anthropic.com + x-api-key: + - X-API-KEY-XXX + x-stainless-arch: + - X-STAINLESS-ARCH-XXX + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - X-STAINLESS-OS-XXX + x-stainless-package-version: + - 0.71.1 + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.10 + x-stainless-timeout: + - NOT_GIVEN + method: POST + uri: https://api.anthropic.com/v1/messages + response: + body: + string: !!binary | + H4sIAAAAAAAA/3WQTUvEMBCG/8ucW2jr7rL25sKCKHrQiyASYjJsw6ZJzUxEKf3vTheLX3hKeJ8n + 8zIZoY8WPbRgvM4Wy7NyXXbaHXPZVM2qrpoGCnBWhJ4Oqqovd/nBnt92tF1dX+z3u6t7ffO8FYff + B5wtJNIHlCBFPweayBHrwBKZGBjl1j6Oi8/4NpPT0cIdUu4RpqcCiOOgEmqKQQAGqzinAJ+A8CVj + MDIhZO8LyKfSdgQXhsyK4xEDQVtvmo3UatOhMjKMXQzqp1ItXLD9jy1v5wYcOuwxaa/W/V//i9bd + bzoVEDN/j1ayDqZXZ1CxwySLzl9ldbIwTR/rySkqnAEAAA== + headers: + CF-RAY: + - CF-RAY-XXX + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Thu, 22 Jan 2026 00:18:50 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Robots-Tag: + - none + anthropic-organization-id: + - ANTHROPIC-ORGANIZATION-ID-XXX + anthropic-ratelimit-input-tokens-limit: + - ANTHROPIC-RATELIMIT-INPUT-TOKENS-LIMIT-XXX + anthropic-ratelimit-input-tokens-remaining: + - ANTHROPIC-RATELIMIT-INPUT-TOKENS-REMAINING-XXX + anthropic-ratelimit-input-tokens-reset: + - ANTHROPIC-RATELIMIT-INPUT-TOKENS-RESET-XXX + anthropic-ratelimit-output-tokens-limit: + - ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-LIMIT-XXX + anthropic-ratelimit-output-tokens-remaining: + - ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-REMAINING-XXX + anthropic-ratelimit-output-tokens-reset: + - ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-RESET-XXX + anthropic-ratelimit-requests-limit: + - '4000' + anthropic-ratelimit-requests-remaining: + - '3999' + anthropic-ratelimit-requests-reset: + - '2026-01-22T00:18:50Z' + anthropic-ratelimit-tokens-limit: + - ANTHROPIC-RATELIMIT-TOKENS-LIMIT-XXX + anthropic-ratelimit-tokens-remaining: + - ANTHROPIC-RATELIMIT-TOKENS-REMAINING-XXX + anthropic-ratelimit-tokens-reset: + - ANTHROPIC-RATELIMIT-TOKENS-RESET-XXX + cf-cache-status: + - DYNAMIC + request-id: + - REQUEST-ID-XXX + strict-transport-security: + - STS-XXX + x-envoy-upstream-service-time: + - '750' + status: + code: 200 + message: OK +version: 1 diff --git a/lib/crewai/tests/cassettes/llms/TestAnthropicMultimodalIntegration.test_describe_image.yaml b/lib/crewai/tests/cassettes/llms/TestAnthropicMultimodalIntegration.test_describe_image.yaml new file mode 100644 index 000000000..92bd43535 --- /dev/null +++ b/lib/crewai/tests/cassettes/llms/TestAnthropicMultimodalIntegration.test_describe_image.yaml @@ -0,0 +1,105 @@ +interactions: +- request: + body: '{"max_tokens":4096,"messages":[{"role":"user","content":[{"type":"text","text":"Describe + this image in one sentence. Be brief."},{"type":"image","source":{"type":"base64","media_type":"image/png","data":"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"},"cache_control":{"type":"ephemeral"}}]}],"model":"claude-3-5-haiku-20241022","stream":false}' + headers: + User-Agent: + - X-USER-AGENT-XXX + accept: + - application/json + accept-encoding: + - ACCEPT-ENCODING-XXX + anthropic-version: + - '2023-06-01' + connection: + - keep-alive + content-length: + - '37299' + content-type: + - application/json + host: + - api.anthropic.com + x-api-key: + - X-API-KEY-XXX + x-stainless-arch: + - X-STAINLESS-ARCH-XXX + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - X-STAINLESS-OS-XXX + x-stainless-package-version: + - 0.71.1 + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.10 + x-stainless-timeout: + - NOT_GIVEN + method: POST + uri: https://api.anthropic.com/v1/messages + response: + body: + string: !!binary | + H4sIAAAAAAAA/3WRzWrDMBCEX0WIHO0i2zEUH9tjry2ElCKEtbFEZMnRSknT4HevlNb0j552mfmk + nWUvdHQSDO1ob0SUUDZlWyqh97GsWb2uWF3TgmqZgBEHzqr24aC2p834trmHXYNPW3UrmrvEhPME + mQJEMUASvDNZEIgag7AhSb2zAVLXPV8WPsBrdq6lo48KyODFpAgqd0IiiNEWhCfa9h4EQmqIhyPY + CGTn3UhSSkaCy3VdEK9R24FgACG1OX8gwrtoJVlV7EquGsZu6PxSUAxu4vlbZ9NssJKH6C39NBAO + EWyfQtpoTEHjda/uQrWdYuDB7cEi7dZtkxYTvQKeIwbtLP9JsMVPtvzPW97mATApGMELw9vxL//l + Vuq3OxfUxfBdalI6BH/UPfCgwadF8zWk8JLO8zs1V9f2/wEAAA== + headers: + CF-RAY: + - CF-RAY-XXX + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Thu, 22 Jan 2026 00:18:52 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Robots-Tag: + - none + anthropic-organization-id: + - ANTHROPIC-ORGANIZATION-ID-XXX + anthropic-ratelimit-input-tokens-limit: + - ANTHROPIC-RATELIMIT-INPUT-TOKENS-LIMIT-XXX + anthropic-ratelimit-input-tokens-remaining: + - ANTHROPIC-RATELIMIT-INPUT-TOKENS-REMAINING-XXX + anthropic-ratelimit-input-tokens-reset: + - ANTHROPIC-RATELIMIT-INPUT-TOKENS-RESET-XXX + anthropic-ratelimit-output-tokens-limit: + - ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-LIMIT-XXX + anthropic-ratelimit-output-tokens-remaining: + - ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-REMAINING-XXX + anthropic-ratelimit-output-tokens-reset: + - ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-RESET-XXX + anthropic-ratelimit-requests-limit: + - '4000' + anthropic-ratelimit-requests-remaining: + - '3999' + anthropic-ratelimit-requests-reset: + - '2026-01-22T00:18:51Z' + anthropic-ratelimit-tokens-limit: + - ANTHROPIC-RATELIMIT-TOKENS-LIMIT-XXX + anthropic-ratelimit-tokens-remaining: + - ANTHROPIC-RATELIMIT-TOKENS-REMAINING-XXX + anthropic-ratelimit-tokens-reset: + - ANTHROPIC-RATELIMIT-TOKENS-RESET-XXX + cf-cache-status: + - DYNAMIC + request-id: + - REQUEST-ID-XXX + strict-transport-security: + - STS-XXX + x-envoy-upstream-service-time: + - '1124' + status: + code: 200 + message: OK +version: 1 diff --git a/lib/crewai/tests/cassettes/llms/TestGenericFileIntegration.test_generic_file_image_openai.yaml b/lib/crewai/tests/cassettes/llms/TestGenericFileIntegration.test_generic_file_image_openai.yaml new file mode 100644 index 000000000..e5bfb4ef9 --- /dev/null +++ b/lib/crewai/tests/cassettes/llms/TestGenericFileIntegration.test_generic_file_image_openai.yaml @@ -0,0 +1,114 @@ +interactions: +- request: + body: '{"messages":[{"role":"user","content":[{"type":"text","text":"Describe + this image in one sentence. Be brief."},{"type":"image_url","image_url":{"url":"data:image/png;base64,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"}}]}],"model":"gpt-4o-mini"}' + headers: + User-Agent: + - X-USER-AGENT-XXX + accept: + - application/json + accept-encoding: + - ACCEPT-ENCODING-XXX + authorization: + - AUTHORIZATION-XXX + connection: + - keep-alive + content-length: + - '37202' + content-type: + - application/json + host: + - api.openai.com + x-stainless-arch: + - X-STAINLESS-ARCH-XXX + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - X-STAINLESS-OS-XXX + x-stainless-package-version: + - 1.83.0 + x-stainless-read-timeout: + - X-STAINLESS-READ-TIMEOUT-XXX + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.10 + method: POST + uri: https://api.openai.com/v1/chat/completions + response: + body: + string: !!binary | + H4sIAAAAAAAAA4ySwW7bMAyG734KQugxLmzHadLcOuyyw9bLig0bCkOWaFurLGkSXSwo8u6D7DR2 + uw7oRQd+/Cn+JJ8SAKYk2wMTHSfRO51+zER3t/3++2Hz4/Mnye+2G3H7JadvH25uuwNbRYWtf6Gg + Z9WlsL3TSMqaCQuPnDBWzbdX11mZ5+urEfRWoo6y1lFa2rRXRqVFVpRptk3z3UndWSUwsD38TAAA + nsY39mkk/mF7yFbPkR5D4C2y/TkJgHmrY4TxEFQgboitZiisITRj6187hNZz14FEpwQF4BAIuTyA + MtFCQFAGPD6iGRAab3u4yLMMeqW1sibCIisyIAsX60W8PsR4ebn812MzBB69m0HrBeDGWOJxdqPj + +xM5nj1q2zpv6/BKyhplVOiq2Kc10U8g69hIjwnA/TjL4cV4mPO2d1SRfcDxu7zMd+VUkc1LnHmx + OUGyxPVSV2TXqzdqVhKJKx0WG2GCiw7lLJ7Xxwep7AIkC+f/9vNW7cm9Mu17ys9ACHSEsnIepRIv + Pc9pHuOV/y/tPOmxYRbQPyqBFSn0cRsSGz7o6fZYOATCvmqUadE7r6YDbFy1q2ux3tWlrFlyTP4C + AAD//wMAFh8A4o4DAAA= + headers: + CF-RAY: + - CF-RAY-XXX + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Thu, 22 Jan 2026 00:18:57 GMT + Server: + - cloudflare + Set-Cookie: + - SET-COOKIE-XXX + Strict-Transport-Security: + - STS-XXX + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - X-CONTENT-TYPE-XXX + access-control-expose-headers: + - ACCESS-CONTROL-XXX + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-organization: + - OPENAI-ORG-XXX + openai-processing-ms: + - '878' + openai-project: + - OPENAI-PROJECT-XXX + openai-version: + - '2020-10-01' + x-envoy-upstream-service-time: + - '1088' + x-openai-proxy-wasm: + - v0.1 + x-ratelimit-limit-input-images: + - '50000' + x-ratelimit-limit-requests: + - X-RATELIMIT-LIMIT-REQUESTS-XXX + x-ratelimit-limit-tokens: + - X-RATELIMIT-LIMIT-TOKENS-XXX + x-ratelimit-remaining-input-images: + - '49999' + x-ratelimit-remaining-requests: + - X-RATELIMIT-REMAINING-REQUESTS-XXX + x-ratelimit-remaining-tokens: + - X-RATELIMIT-REMAINING-TOKENS-XXX + x-ratelimit-reset-input-images: + - 1ms + x-ratelimit-reset-requests: + - X-RATELIMIT-RESET-REQUESTS-XXX + x-ratelimit-reset-tokens: + - X-RATELIMIT-RESET-TOKENS-XXX + x-request-id: + - X-REQUEST-ID-XXX + status: + code: 200 + message: OK +version: 1 diff --git a/lib/crewai/tests/cassettes/llms/TestGenericFileIntegration.test_generic_file_mixed_types.yaml b/lib/crewai/tests/cassettes/llms/TestGenericFileIntegration.test_generic_file_mixed_types.yaml new file mode 100644 index 000000000..470061bc7 --- /dev/null +++ b/lib/crewai/tests/cassettes/llms/TestGenericFileIntegration.test_generic_file_mixed_types.yaml @@ -0,0 +1,106 @@ +interactions: +- request: + body: '{"max_tokens":4096,"messages":[{"role":"user","content":[{"type":"text","text":"What + types of files did I send? List them briefly."},{"type":"image","source":{"type":"base64","media_type":"image/png","data":"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"}},{"type":"document","source":{"type":"base64","media_type":"application/pdf","data":"JVBERi0xLjQKMSAwIG9iaiA8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4gZW5kb2JqCjIgMCBvYmogPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4gZW5kb2JqCjMgMCBvYmogPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSA+PiBlbmRvYmoKeHJlZgowIDQKMDAwMDAwMDAwMCA2NTUzNSBmCjAwMDAwMDAwMDkgMDAwMDAgbgowMDAwMDAwMDU4IDAwMDAwIG4KMDAwMDAwMDExNSAwMDAwMCBuCnRyYWlsZXIgPDwgL1NpemUgNCAvUm9vdCAxIDAgUiA+PgpzdGFydHhyZWYKMTk2CiUlRU9GCg=="},"cache_control":{"type":"ephemeral"}}]}],"model":"claude-3-5-haiku-20241022","stream":false}' + headers: + User-Agent: + - X-USER-AGENT-XXX + accept: + - application/json + accept-encoding: + - ACCEPT-ENCODING-XXX + anthropic-version: + - '2023-06-01' + connection: + - keep-alive + content-length: + - '37827' + content-type: + - application/json + host: + - api.anthropic.com + x-api-key: + - X-API-KEY-XXX + x-stainless-arch: + - X-STAINLESS-ARCH-XXX + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - X-STAINLESS-OS-XXX + x-stainless-package-version: + - 0.71.1 + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.10 + x-stainless-timeout: + - NOT_GIVEN + method: POST + uri: https://api.anthropic.com/v1/messages + response: + body: + string: !!binary | + H4sIAAAAAAAA/22R3UoDMRCFX2XIlcJWtttW6d4pIiiKouKNlSUm0yY0O1nzU39K391ZsajFqwxz + vjnJmaxF6zU6UQvlZNY4GA0mAyPtMg+qshoPy6oShbCagTYumnI4vru4mj98TFK+ndDb4ejocnqH + U2bSe4c9hTHKBXIjeNc3ZIw2JkmJW8pTQq7qx/WWT/jWK19HLU5kRA2eIBmEuXUYIfJAAeegJHGN + 9YyGB3AMzhLCIsjOQDT+1dICZuIWV0gZ4XqFAe5tizMB8+Bb4CwlJN+f4xlVvcHN6Rlor3LL/rD3 + aqwyILsOZYg9+Yzw7CQtwQdgMeG+2DwVIibfNQFl9MTPRdJNyoHEtxDxJSMpzkXZuULkr1XUa2Gp + y6lJfokURT3iTUhlsFHslKyn5q9elYflFmFC78jl7nh/A3YGWwzSNZP2X7sfYGh2DTeF8Dn9bo2n + HAnDyipsksXAYftP1DJosdl8ApF6VLU2AgAA + headers: + CF-RAY: + - CF-RAY-XXX + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Thu, 22 Jan 2026 00:18:59 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Robots-Tag: + - none + anthropic-organization-id: + - ANTHROPIC-ORGANIZATION-ID-XXX + anthropic-ratelimit-input-tokens-limit: + - ANTHROPIC-RATELIMIT-INPUT-TOKENS-LIMIT-XXX + anthropic-ratelimit-input-tokens-remaining: + - ANTHROPIC-RATELIMIT-INPUT-TOKENS-REMAINING-XXX + anthropic-ratelimit-input-tokens-reset: + - ANTHROPIC-RATELIMIT-INPUT-TOKENS-RESET-XXX + anthropic-ratelimit-output-tokens-limit: + - ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-LIMIT-XXX + anthropic-ratelimit-output-tokens-remaining: + - ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-REMAINING-XXX + anthropic-ratelimit-output-tokens-reset: + - ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-RESET-XXX + anthropic-ratelimit-requests-limit: + - '4000' + anthropic-ratelimit-requests-remaining: + - '3999' + anthropic-ratelimit-requests-reset: + - '2026-01-22T00:18:57Z' + anthropic-ratelimit-tokens-limit: + - ANTHROPIC-RATELIMIT-TOKENS-LIMIT-XXX + anthropic-ratelimit-tokens-remaining: + - ANTHROPIC-RATELIMIT-TOKENS-REMAINING-XXX + anthropic-ratelimit-tokens-reset: + - ANTHROPIC-RATELIMIT-TOKENS-RESET-XXX + cf-cache-status: + - DYNAMIC + request-id: + - REQUEST-ID-XXX + strict-transport-security: + - STS-XXX + x-envoy-upstream-service-time: + - '1956' + status: + code: 200 + message: OK +version: 1 diff --git a/lib/crewai/tests/cassettes/llms/TestGenericFileIntegration.test_generic_file_pdf_anthropic.yaml b/lib/crewai/tests/cassettes/llms/TestGenericFileIntegration.test_generic_file_pdf_anthropic.yaml new file mode 100644 index 000000000..6b7bfa7fe --- /dev/null +++ b/lib/crewai/tests/cassettes/llms/TestGenericFileIntegration.test_generic_file_pdf_anthropic.yaml @@ -0,0 +1,104 @@ +interactions: +- request: + body: '{"max_tokens":4096,"messages":[{"role":"user","content":[{"type":"text","text":"What + type of document is this? Answer in one word."},{"type":"document","source":{"type":"base64","media_type":"application/pdf","data":"JVBERi0xLjQKMSAwIG9iaiA8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4gZW5kb2JqCjIgMCBvYmogPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4gZW5kb2JqCjMgMCBvYmogPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSA+PiBlbmRvYmoKeHJlZgowIDQKMDAwMDAwMDAwMCA2NTUzNSBmCjAwMDAwMDAwMDkgMDAwMDAgbgowMDAwMDAwMDU4IDAwMDAwIG4KMDAwMDAwMDExNSAwMDAwMCBuCnRyYWlsZXIgPDwgL1NpemUgNCAvUm9vdCAxIDAgUiA+PgpzdGFydHhyZWYKMTk2CiUlRU9GCg=="},"cache_control":{"type":"ephemeral"}}]}],"model":"claude-3-5-haiku-20241022","stream":false}' + headers: + User-Agent: + - X-USER-AGENT-XXX + accept: + - application/json + accept-encoding: + - ACCEPT-ENCODING-XXX + anthropic-version: + - '2023-06-01' + connection: + - keep-alive + content-length: + - '748' + content-type: + - application/json + host: + - api.anthropic.com + x-api-key: + - X-API-KEY-XXX + x-stainless-arch: + - X-STAINLESS-ARCH-XXX + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - X-STAINLESS-OS-XXX + x-stainless-package-version: + - 0.71.1 + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.10 + x-stainless-timeout: + - NOT_GIVEN + method: POST + uri: https://api.anthropic.com/v1/messages + response: + body: + string: !!binary | + H4sIAAAAAAAA/3WQTUvEMBCG/8ucW2hju4eeRUU97EFRFAkhGbZh06Qmk1Up/e9OF4tf7CnhfZ7J + y2SCIRh00IF2Khssz8q27JXd51JUoqkrIaAAa1gY0k5W9bbptXo7PD60l/V1f/V0J+5vxQ079DHi + YmFKaoccxOCWQKVkEylPHOngCfnWPU+rT/i+kOPRwfb8AuaXAhKFUUZUKXhO0RtJOXr4AglfM3rN + 4z47V0A+NnYTWD9mkhT26BN09UZsuFPpHqXmx8gGL38r1coZm1NsnV0acOxxwKicbIf//jet+790 + LiBk+hk1vA7Gg9UoyWLkRZd/MioamOdP24g1JZkBAAA= + headers: + CF-RAY: + - CF-RAY-XXX + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Thu, 22 Jan 2026 00:18:56 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Robots-Tag: + - none + anthropic-organization-id: + - ANTHROPIC-ORGANIZATION-ID-XXX + anthropic-ratelimit-input-tokens-limit: + - ANTHROPIC-RATELIMIT-INPUT-TOKENS-LIMIT-XXX + anthropic-ratelimit-input-tokens-remaining: + - ANTHROPIC-RATELIMIT-INPUT-TOKENS-REMAINING-XXX + anthropic-ratelimit-input-tokens-reset: + - ANTHROPIC-RATELIMIT-INPUT-TOKENS-RESET-XXX + anthropic-ratelimit-output-tokens-limit: + - ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-LIMIT-XXX + anthropic-ratelimit-output-tokens-remaining: + - ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-REMAINING-XXX + anthropic-ratelimit-output-tokens-reset: + - ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-RESET-XXX + anthropic-ratelimit-requests-limit: + - '4000' + anthropic-ratelimit-requests-remaining: + - '3999' + anthropic-ratelimit-requests-reset: + - '2026-01-22T00:18:55Z' + anthropic-ratelimit-tokens-limit: + - ANTHROPIC-RATELIMIT-TOKENS-LIMIT-XXX + anthropic-ratelimit-tokens-remaining: + - ANTHROPIC-RATELIMIT-TOKENS-REMAINING-XXX + anthropic-ratelimit-tokens-reset: + - ANTHROPIC-RATELIMIT-TOKENS-RESET-XXX + cf-cache-status: + - DYNAMIC + request-id: + - REQUEST-ID-XXX + strict-transport-security: + - STS-XXX + x-envoy-upstream-service-time: + - '648' + status: + code: 200 + message: OK +version: 1 diff --git a/lib/crewai/tests/cassettes/llms/TestLiteLLMMultimodalIntegration.test_describe_image_claude.yaml b/lib/crewai/tests/cassettes/llms/TestLiteLLMMultimodalIntegration.test_describe_image_claude.yaml new file mode 100644 index 000000000..9d4e9b7c9 --- /dev/null +++ b/lib/crewai/tests/cassettes/llms/TestLiteLLMMultimodalIntegration.test_describe_image_claude.yaml @@ -0,0 +1,90 @@ +interactions: +- request: + body: '{"model": "claude-3-5-haiku-20241022", "messages": [{"role": "user", "content": + [{"type": "text", "text": "Describe this image in one sentence. Be brief."}, + {"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": + "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"}}]}], + "max_tokens": 4096}' + headers: + User-Agent: + - X-USER-AGENT-XXX + accept: + - application/json + accept-encoding: + - ACCEPT-ENCODING-XXX + anthropic-version: + - '2023-06-01' + connection: + - keep-alive + content-length: + - '37267' + content-type: + - application/json + host: + - api.anthropic.com + x-api-key: + - X-API-KEY-XXX + method: POST + uri: https://api.anthropic.com/v1/messages + response: + body: + string: !!binary | + H4sIAAAAAAAA/3WRS0sDMRSF/0oIXc5I5lEGZtuNK0ERUURCnFwnoZmbMY/WUua/m1SLL1zlcs6X + m3PIkU5WgqE9HYyIEsqmXJdK6G0sa1a3FatrWlAtEzD5kbPq/vnmrhuvK9ldPQi13W+mbnPZJSYc + ZsgUeC9GSIKzJgvCe+2DwJCkwWKANPWPxzMf4C07p6OntwrI6MSsiFd274kgRiMIRzQODoSHNBAH + O8AI5MXZiaSUjASbz7YgTnuNI/EBhNTm8IEIZyNKsqrYicz7krVqGLugy1NBfbAzz9stpgiAkofo + kH4aHl4j4JCyYjSmoPFUrz9SjXMMPNgtoKd9u25SPzEo4Dlp0Bb5T4Kd/WTL/7zz3fwAzAomcMLw + 9fSX/3Ir9dtdCmpj+C41baoDbqcH4EGDS0Xzp0jhJF2Wd6pUrUsGAgAA + headers: + CF-RAY: + - CF-RAY-XXX + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Thu, 22 Jan 2026 00:18:55 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Robots-Tag: + - none + anthropic-organization-id: + - ANTHROPIC-ORGANIZATION-ID-XXX + anthropic-ratelimit-input-tokens-limit: + - ANTHROPIC-RATELIMIT-INPUT-TOKENS-LIMIT-XXX + anthropic-ratelimit-input-tokens-remaining: + - ANTHROPIC-RATELIMIT-INPUT-TOKENS-REMAINING-XXX + anthropic-ratelimit-input-tokens-reset: + - ANTHROPIC-RATELIMIT-INPUT-TOKENS-RESET-XXX + anthropic-ratelimit-output-tokens-limit: + - ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-LIMIT-XXX + anthropic-ratelimit-output-tokens-remaining: + - ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-REMAINING-XXX + anthropic-ratelimit-output-tokens-reset: + - ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-RESET-XXX + anthropic-ratelimit-requests-limit: + - '4000' + anthropic-ratelimit-requests-remaining: + - '3999' + anthropic-ratelimit-requests-reset: + - '2026-01-22T00:18:54Z' + anthropic-ratelimit-tokens-limit: + - ANTHROPIC-RATELIMIT-TOKENS-LIMIT-XXX + anthropic-ratelimit-tokens-remaining: + - ANTHROPIC-RATELIMIT-TOKENS-REMAINING-XXX + anthropic-ratelimit-tokens-reset: + - ANTHROPIC-RATELIMIT-TOKENS-RESET-XXX + cf-cache-status: + - DYNAMIC + request-id: + - REQUEST-ID-XXX + strict-transport-security: + - STS-XXX + x-envoy-upstream-service-time: + - '1340' + status: + code: 200 + message: OK +version: 1 diff --git a/lib/crewai/tests/cassettes/llms/TestLiteLLMMultimodalIntegration.test_describe_image_gpt4o.yaml b/lib/crewai/tests/cassettes/llms/TestLiteLLMMultimodalIntegration.test_describe_image_gpt4o.yaml new file mode 100644 index 000000000..b8e111ab9 --- /dev/null +++ b/lib/crewai/tests/cassettes/llms/TestLiteLLMMultimodalIntegration.test_describe_image_gpt4o.yaml @@ -0,0 +1,116 @@ +interactions: +- request: + body: '{"messages":[{"role":"user","content":[{"type":"text","text":"Describe + this image in one sentence. Be brief."},{"type":"image_url","image_url":{"url":"data:image/png;base64,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"}}]}],"model":"gpt-4o-mini"}' + headers: + User-Agent: + - X-USER-AGENT-XXX + accept: + - application/json + accept-encoding: + - ACCEPT-ENCODING-XXX + authorization: + - AUTHORIZATION-XXX + connection: + - keep-alive + content-length: + - '37202' + content-type: + - application/json + host: + - api.openai.com + x-stainless-arch: + - X-STAINLESS-ARCH-XXX + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - X-STAINLESS-OS-XXX + x-stainless-package-version: + - 1.83.0 + x-stainless-raw-response: + - 'true' + x-stainless-read-timeout: + - X-STAINLESS-READ-TIMEOUT-XXX + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.10 + method: POST + uri: https://api.openai.com/v1/chat/completions + response: + body: + string: !!binary | + H4sIAAAAAAAAAwAAAP//jFPBjpswEL3zFSNrj2EFhHazOVdqK+2hG23VQ7VCxh5gWmNbtok2XeXf + K0MSyLaVesHCb97zvDf2awLASLItMNHxIHqr0g+Z6B4f7xv1UB7o0+7bry576t7tPn59+Pxlx1aR + YeofKMKZdStMbxUGMnqChUMeMKrmd+/vszLP18UI9EaiirTWhrQ0aU+a0iIryjS7S/PNid0ZEujZ + Fr4nAACv4zf2qSW+sC1kq/NOj97zFtn2UgTAnFFxh3HvyQeuA1vNoDA6oB5bf+oQWsdtBxItieCB + gw/I5QFIRwsegTQ43KMeEMweHQTqERpneiiyIoNg4lquwJEn3U4It9aZF+p5QHWAmzzLoCelyOhY + f7Oe/2+XnTlsBs9jOnpQagFwrU3gMd0xk+cTcrykoExrnan9GyprSJPvqujE6OjYB2PZiB4TgOcx + 7eEqQGad6W2ogvmJ43F5mW/KSZHNY57x9WkYLJjA1ZJX5GfelWYlMXBSfjEzJrjoUM7kecB8kGQW + QLJw/mc/f9Oe3JNu/0d+BoRAG1BW1qEkce15LnMY38G/yi5Jjw0zj25PAqtA6OI0JDZ8UNPtZP7g + A/ZVQ7pFZx1NV7Sx1aauxXpTl7JmyTH5DQAA//8DAHFBod6wAwAA + headers: + CF-RAY: + - CF-RAY-XXX + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Thu, 22 Jan 2026 00:18:53 GMT + Server: + - cloudflare + Set-Cookie: + - SET-COOKIE-XXX + Strict-Transport-Security: + - STS-XXX + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - X-CONTENT-TYPE-XXX + access-control-expose-headers: + - ACCESS-CONTROL-XXX + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-organization: + - OPENAI-ORG-XXX + openai-processing-ms: + - '1587' + openai-project: + - OPENAI-PROJECT-XXX + openai-version: + - '2020-10-01' + x-envoy-upstream-service-time: + - '1608' + x-openai-proxy-wasm: + - v0.1 + x-ratelimit-limit-input-images: + - '50000' + x-ratelimit-limit-requests: + - X-RATELIMIT-LIMIT-REQUESTS-XXX + x-ratelimit-limit-tokens: + - X-RATELIMIT-LIMIT-TOKENS-XXX + x-ratelimit-remaining-input-images: + - '49999' + x-ratelimit-remaining-requests: + - X-RATELIMIT-REMAINING-REQUESTS-XXX + x-ratelimit-remaining-tokens: + - X-RATELIMIT-REMAINING-TOKENS-XXX + x-ratelimit-reset-input-images: + - 1ms + x-ratelimit-reset-requests: + - X-RATELIMIT-RESET-REQUESTS-XXX + x-ratelimit-reset-tokens: + - X-RATELIMIT-RESET-TOKENS-XXX + x-request-id: + - X-REQUEST-ID-XXX + status: + code: 200 + message: OK +version: 1 diff --git a/lib/crewai/tests/cassettes/llms/TestMultipleFilesIntegration.test_mixed_content_anthropic.yaml b/lib/crewai/tests/cassettes/llms/TestMultipleFilesIntegration.test_mixed_content_anthropic.yaml new file mode 100644 index 000000000..b544e7451 --- /dev/null +++ b/lib/crewai/tests/cassettes/llms/TestMultipleFilesIntegration.test_mixed_content_anthropic.yaml @@ -0,0 +1,106 @@ +interactions: +- request: + body: '{"max_tokens":4096,"messages":[{"role":"user","content":[{"type":"text","text":"What + types of files did I send you? List them briefly."},{"type":"image","source":{"type":"base64","media_type":"image/png","data":"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"}},{"type":"document","source":{"type":"base64","media_type":"application/pdf","data":"JVBERi0xLjQKMSAwIG9iaiA8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4gZW5kb2JqCjIgMCBvYmogPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4gZW5kb2JqCjMgMCBvYmogPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSA+PiBlbmRvYmoKeHJlZgowIDQKMDAwMDAwMDAwMCA2NTUzNSBmCjAwMDAwMDAwMDkgMDAwMDAgbgowMDAwMDAwMDU4IDAwMDAwIG4KMDAwMDAwMDExNSAwMDAwMCBuCnRyYWlsZXIgPDwgL1NpemUgNCAvUm9vdCAxIDAgUiA+PgpzdGFydHhyZWYKMTk2CiUlRU9GCg=="},"cache_control":{"type":"ephemeral"}}]}],"model":"claude-3-5-haiku-20241022","stream":false}' + headers: + User-Agent: + - X-USER-AGENT-XXX + accept: + - application/json + accept-encoding: + - ACCEPT-ENCODING-XXX + anthropic-version: + - '2023-06-01' + connection: + - keep-alive + content-length: + - '37831' + content-type: + - application/json + host: + - api.anthropic.com + x-api-key: + - X-API-KEY-XXX + x-stainless-arch: + - X-STAINLESS-ARCH-XXX + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - X-STAINLESS-OS-XXX + x-stainless-package-version: + - 0.71.1 + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.10 + x-stainless-timeout: + - NOT_GIVEN + method: POST + uri: https://api.anthropic.com/v1/messages + response: + body: + string: !!binary | + H4sIAAAAAAAA/22Ry07DMBBFf2XkFUgtSkLLIjsQ0AULHgKJiqDITYbYNB4HP5qiqv/OpKICKla2 + 7j1zxzPeCGNrbEUuqlbGGsen4+lYSb2M4yzJJmmSZWIkdM2A8U2ZpE/2qldm3mCazu79+n32fNNf + WGbCZ4cDhd7LBllwth0E6b32QVJgqbIUkG/5y2bPB1wPzu7IxdxGUHKF4BkDgxB6C2+6RZ8XVFB6 + AucE2nCDnQpHEhonOwVe2V5TA4V4wBVSRLhdoYNHbbAQxwVlXAl3l9dQ2yqaIfyoV7pSILsOpfMQ + LCwQJCxaSUuwDtgOCB23Ohbb15HwwXalQ+kt8UOR6jJER+Lb8PgRkSqeiGLbjkTcLSHfCE1dDGWw + SyQv8lPegawUlhUnBW2p/OtnyVm6R5ioD+zksHzogJ1Cg0625dT8G/cDpOowcDsSNobf0iTjkdCt + dIVl0Oh42OH7aulqsd1+AaB4L9AwAgAA + headers: + CF-RAY: + - CF-RAY-XXX + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Thu, 22 Jan 2026 00:18:48 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Robots-Tag: + - none + anthropic-organization-id: + - ANTHROPIC-ORGANIZATION-ID-XXX + anthropic-ratelimit-input-tokens-limit: + - ANTHROPIC-RATELIMIT-INPUT-TOKENS-LIMIT-XXX + anthropic-ratelimit-input-tokens-remaining: + - ANTHROPIC-RATELIMIT-INPUT-TOKENS-REMAINING-XXX + anthropic-ratelimit-input-tokens-reset: + - ANTHROPIC-RATELIMIT-INPUT-TOKENS-RESET-XXX + anthropic-ratelimit-output-tokens-limit: + - ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-LIMIT-XXX + anthropic-ratelimit-output-tokens-remaining: + - ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-REMAINING-XXX + anthropic-ratelimit-output-tokens-reset: + - ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-RESET-XXX + anthropic-ratelimit-requests-limit: + - '4000' + anthropic-ratelimit-requests-remaining: + - '3999' + anthropic-ratelimit-requests-reset: + - '2026-01-22T00:18:46Z' + anthropic-ratelimit-tokens-limit: + - ANTHROPIC-RATELIMIT-TOKENS-LIMIT-XXX + anthropic-ratelimit-tokens-remaining: + - ANTHROPIC-RATELIMIT-TOKENS-REMAINING-XXX + anthropic-ratelimit-tokens-reset: + - ANTHROPIC-RATELIMIT-TOKENS-RESET-XXX + cf-cache-status: + - DYNAMIC + request-id: + - REQUEST-ID-XXX + strict-transport-security: + - STS-XXX + x-envoy-upstream-service-time: + - '1924' + status: + code: 200 + message: OK +version: 1 diff --git a/lib/crewai/tests/cassettes/llms/TestMultipleFilesIntegration.test_multiple_images_openai.yaml b/lib/crewai/tests/cassettes/llms/TestMultipleFilesIntegration.test_multiple_images_openai.yaml new file mode 100644 index 000000000..26dc0f64d --- /dev/null +++ b/lib/crewai/tests/cassettes/llms/TestMultipleFilesIntegration.test_multiple_images_openai.yaml @@ -0,0 +1,113 @@ +interactions: +- request: + body: '{"messages":[{"role":"user","content":[{"type":"text","text":"How many + images do you see? Answer with just the number."},{"type":"image_url","image_url":{"url":"data:image/png;base64,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"}},{"type":"image_url","image_url":{"url":"data:image/png;base64,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"}}]}],"model":"gpt-4o-mini"}' + headers: + User-Agent: + - X-USER-AGENT-XXX + accept: + - application/json + accept-encoding: + - ACCEPT-ENCODING-XXX + authorization: + - AUTHORIZATION-XXX + connection: + - keep-alive + content-length: + - '74278' + content-type: + - application/json + host: + - api.openai.com + x-stainless-arch: + - X-STAINLESS-ARCH-XXX + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - X-STAINLESS-OS-XXX + x-stainless-package-version: + - 1.83.0 + x-stainless-read-timeout: + - X-STAINLESS-READ-TIMEOUT-XXX + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.10 + method: POST + uri: https://api.openai.com/v1/chat/completions + response: + body: + string: !!binary | + H4sIAAAAAAAAAwAAAP//jJJPT9wwEMXv+RTWnDcoCQGWvYIEAtQLbS8Vihx7khgc27InpS3a7145 + WTZZ/khccpjfvOc3k3lJGAMlYcNAdJxE73R6mYnu2/UNNbffC7q6+HHH3b+fT214HvD+ElZRYetH + FPSqOhK2dxpJWTNh4ZETRtf87PQ8K/O8OB9BbyXqKGsdpaVNe2VUWmRFmWZnab7eqTurBAbYsF8J + Y4y9jN+Y00j8AxuWrV4rPYbAW4TNvokx8FbHCvAQVCBuCFYzFNYQmjF6sax7bIbAYzYzaL0A3BhL + PM42JnrYke0+g7at87YOb6TQKKNCV3nkwZr4XiDrYKTbhLGHcdbhID44b3tHFdknHJ8r1scn5eQI + 85Jnnu8YWeL6UHay+sCykkhc6bBYGAguOpSzeN4uH6SyC5AsBn8f5yPvaXhl2q/Yz0AIdISych6l + Eocjz20e4xF+1rZf9BgYAvrfSmBFCn38GRIbPujpNCD8DYR91SjTondeTffRuGpd1+J4XZeyhmSb + /AcAAP//AwBr4D4MLQMAAA== + headers: + CF-RAY: + - CF-RAY-XXX + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Thu, 22 Jan 2026 00:18:49 GMT + Server: + - cloudflare + Set-Cookie: + - SET-COOKIE-XXX + Strict-Transport-Security: + - STS-XXX + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - X-CONTENT-TYPE-XXX + access-control-expose-headers: + - ACCESS-CONTROL-XXX + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-organization: + - OPENAI-ORG-XXX + openai-processing-ms: + - '869' + openai-project: + - OPENAI-PROJECT-XXX + openai-version: + - '2020-10-01' + x-envoy-upstream-service-time: + - '896' + x-openai-proxy-wasm: + - v0.1 + x-ratelimit-limit-input-images: + - '50000' + x-ratelimit-limit-requests: + - X-RATELIMIT-LIMIT-REQUESTS-XXX + x-ratelimit-limit-tokens: + - X-RATELIMIT-LIMIT-TOKENS-XXX + x-ratelimit-remaining-input-images: + - '49998' + x-ratelimit-remaining-requests: + - X-RATELIMIT-REMAINING-REQUESTS-XXX + x-ratelimit-remaining-tokens: + - X-RATELIMIT-REMAINING-TOKENS-XXX + x-ratelimit-reset-input-images: + - 2ms + x-ratelimit-reset-requests: + - X-RATELIMIT-RESET-REQUESTS-XXX + x-ratelimit-reset-tokens: + - X-RATELIMIT-RESET-TOKENS-XXX + x-request-id: + - X-REQUEST-ID-XXX + status: + code: 200 + message: OK +version: 1 diff --git a/lib/crewai/tests/cassettes/llms/TestOpenAIMultimodalIntegration.test_describe_image.yaml b/lib/crewai/tests/cassettes/llms/TestOpenAIMultimodalIntegration.test_describe_image.yaml new file mode 100644 index 000000000..d71aa7853 --- /dev/null +++ b/lib/crewai/tests/cassettes/llms/TestOpenAIMultimodalIntegration.test_describe_image.yaml @@ -0,0 +1,114 @@ +interactions: +- request: + body: '{"messages":[{"role":"user","content":[{"type":"text","text":"Describe + this image in one sentence. Be brief."},{"type":"image_url","image_url":{"url":"data:image/png;base64,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"}}]}],"model":"gpt-4o-mini"}' + headers: + User-Agent: + - X-USER-AGENT-XXX + accept: + - application/json + accept-encoding: + - ACCEPT-ENCODING-XXX + authorization: + - AUTHORIZATION-XXX + connection: + - keep-alive + content-length: + - '37202' + content-type: + - application/json + host: + - api.openai.com + x-stainless-arch: + - X-STAINLESS-ARCH-XXX + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - X-STAINLESS-OS-XXX + x-stainless-package-version: + - 1.83.0 + x-stainless-read-timeout: + - X-STAINLESS-READ-TIMEOUT-XXX + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.10 + method: POST + uri: https://api.openai.com/v1/chat/completions + response: + body: + string: !!binary | + H4sIAAAAAAAAA4xSwYrbMBC9+ysGnePF9prGybn0uNDSFtqyGFka29OVJSGNQ5cl/17kpLHbbqEX + CfTmPb03My8ZgCAtjiDUKFlN3uRvCzV+kU+9OfCDOvQPPCluPn/6IO2791/FLjFc9x0V/2LdKTd5 + g0zOXmAVUDIm1XL/5lDUZVkXCzA5jSbRBs957fKJLOVVUdV5sc/L5soeHSmM4gjfMgCAl+VMPq3G + H+IIi9byMmGMckBxvBUBiOBMehEyRoosLYvdCipnGe1i/eOIQJMcECiCBEMWYQjSj6DRk2KyA/CI + EBmlfgayKVZEIAsBT2hnBHfCAEwTQh/cBFVRFcAu3fXd9teA/RxlSm5nYzaAtNaxTJ1b8j5ekfMt + oXGDD66Lf1BFT5bi2CZHzqY0kZ0XC3rOAB6XTs6/NUf44CbPLbsnXL4r67KpL4piHeGKV/dXkB1L + s+VVxX73imarkSWZuJmHUFKNqFfyOjw5a3IbINsk/9vPa9qX9GSH/5FfAaXQM+rWB9RpztvMa1nA + tOP/Krt1ejEsIoYTKWyZMKRpaOzlbC6bJ+JzZJzanuyAwQe6rF/v26br1H3T1boT2Tn7CQAA//8D + AE5VXS6MAwAA + headers: + CF-RAY: + - CF-RAY-XXX + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Thu, 22 Jan 2026 00:19:01 GMT + Server: + - cloudflare + Set-Cookie: + - SET-COOKIE-XXX + Strict-Transport-Security: + - STS-XXX + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - X-CONTENT-TYPE-XXX + access-control-expose-headers: + - ACCESS-CONTROL-XXX + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-organization: + - OPENAI-ORG-XXX + openai-processing-ms: + - '1035' + openai-project: + - OPENAI-PROJECT-XXX + openai-version: + - '2020-10-01' + x-envoy-upstream-service-time: + - '1072' + x-openai-proxy-wasm: + - v0.1 + x-ratelimit-limit-input-images: + - '50000' + x-ratelimit-limit-requests: + - X-RATELIMIT-LIMIT-REQUESTS-XXX + x-ratelimit-limit-tokens: + - X-RATELIMIT-LIMIT-TOKENS-XXX + x-ratelimit-remaining-input-images: + - '49999' + x-ratelimit-remaining-requests: + - X-RATELIMIT-REMAINING-REQUESTS-XXX + x-ratelimit-remaining-tokens: + - X-RATELIMIT-REMAINING-TOKENS-XXX + x-ratelimit-reset-input-images: + - 1ms + x-ratelimit-reset-requests: + - X-RATELIMIT-RESET-REQUESTS-XXX + x-ratelimit-reset-tokens: + - X-RATELIMIT-RESET-TOKENS-XXX + x-request-id: + - X-REQUEST-ID-XXX + status: + code: 200 + message: OK +version: 1 diff --git a/lib/crewai/tests/llms/test_multimodal_integration.py b/lib/crewai/tests/llms/test_multimodal_integration.py new file mode 100644 index 000000000..ec66365ac --- /dev/null +++ b/lib/crewai/tests/llms/test_multimodal_integration.py @@ -0,0 +1,329 @@ +"""Integration tests for LLM multimodal functionality with cassettes. + +These tests make actual API calls (recorded via VCR cassettes) to verify +multimodal content is properly sent and processed by each provider. +""" + +from pathlib import Path + +import pytest + +from crewai.llm import LLM +from crewai.utilities.files import File, ImageFile, PDFFile, TextFile + + +# Path to test data files +TEST_DATA_DIR = Path(__file__).parent.parent.parent.parent.parent / "data" +TEST_IMAGE_PATH = TEST_DATA_DIR / "revenue_chart.png" +TEST_TEXT_PATH = TEST_DATA_DIR / "review_guidelines.txt" + + +@pytest.fixture +def test_image_bytes() -> bytes: + """Load test image bytes.""" + return TEST_IMAGE_PATH.read_bytes() + + +@pytest.fixture +def test_text_bytes() -> bytes: + """Load test text bytes.""" + return TEST_TEXT_PATH.read_bytes() + + +# Minimal PDF for testing (real PDF structure) +MINIMAL_PDF = b"""%PDF-1.4 +1 0 obj << /Type /Catalog /Pages 2 0 R >> endobj +2 0 obj << /Type /Pages /Kids [3 0 R] /Count 1 >> endobj +3 0 obj << /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >> endobj +xref +0 4 +0000000000 65535 f +0000000009 00000 n +0000000058 00000 n +0000000115 00000 n +trailer << /Size 4 /Root 1 0 R >> +startxref +196 +%%EOF +""" + + +def _build_multimodal_message(llm: LLM, prompt: str, files: dict) -> list[dict]: + """Build a multimodal message with text and file content.""" + content_blocks = llm.format_multimodal_content(files) + return [ + { + "role": "user", + "content": [ + llm.format_text_content(prompt), + *content_blocks, + ], + } + ] + + +class TestOpenAIMultimodalIntegration: + """Integration tests for OpenAI multimodal with real API calls.""" + + @pytest.mark.vcr() + def test_describe_image(self, test_image_bytes: bytes) -> None: + """Test OpenAI can describe an image.""" + llm = LLM(model="openai/gpt-4o-mini") + files = {"image": ImageFile(source=test_image_bytes)} + + messages = _build_multimodal_message( + llm, + "Describe this image in one sentence. Be brief.", + files, + ) + + response = llm.call(messages) + + assert response + assert isinstance(response, str) + assert len(response) > 0 + + +class TestAnthropicMultimodalIntegration: + """Integration tests for Anthropic multimodal with real API calls.""" + + @pytest.mark.vcr() + def test_describe_image(self, test_image_bytes: bytes) -> None: + """Test Anthropic can describe an image.""" + llm = LLM(model="anthropic/claude-3-5-haiku-20241022") + files = {"image": ImageFile(source=test_image_bytes)} + + messages = _build_multimodal_message( + llm, + "Describe this image in one sentence. Be brief.", + files, + ) + + response = llm.call(messages) + + assert response + assert isinstance(response, str) + assert len(response) > 0 + + @pytest.mark.vcr() + def test_analyze_pdf(self) -> None: + """Test Anthropic can analyze a PDF.""" + llm = LLM(model="anthropic/claude-3-5-haiku-20241022") + files = {"document": PDFFile(source=MINIMAL_PDF)} + + messages = _build_multimodal_message( + llm, + "What type of document is this? Answer in one word.", + files, + ) + + response = llm.call(messages) + + assert response + assert isinstance(response, str) + assert len(response) > 0 + + +class TestGeminiMultimodalIntegration: + """Integration tests for Gemini multimodal with real API calls.""" + + @pytest.mark.vcr() + def test_describe_image(self, test_image_bytes: bytes) -> None: + """Test Gemini can describe an image.""" + llm = LLM(model="gemini/gemini-2.0-flash") + files = {"image": ImageFile(source=test_image_bytes)} + + messages = _build_multimodal_message( + llm, + "Describe this image in one sentence. Be brief.", + files, + ) + + response = llm.call(messages) + + assert response + assert isinstance(response, str) + assert len(response) > 0 + + @pytest.mark.vcr() + def test_analyze_text_file(self, test_text_bytes: bytes) -> None: + """Test Gemini can analyze a text file.""" + llm = LLM(model="gemini/gemini-2.0-flash") + files = {"readme": TextFile(source=test_text_bytes)} + + messages = _build_multimodal_message( + llm, + "Summarize what this text file says in one sentence.", + files, + ) + + response = llm.call(messages) + + assert response + assert isinstance(response, str) + assert len(response) > 0 + + +class TestLiteLLMMultimodalIntegration: + """Integration tests for LiteLLM wrapper multimodal with real API calls.""" + + @pytest.mark.vcr() + def test_describe_image_gpt4o(self, test_image_bytes: bytes) -> None: + """Test LiteLLM with GPT-4o can describe an image.""" + llm = LLM(model="gpt-4o-mini", is_litellm=True) + files = {"image": ImageFile(source=test_image_bytes)} + + messages = _build_multimodal_message( + llm, + "Describe this image in one sentence. Be brief.", + files, + ) + + response = llm.call(messages) + + assert response + assert isinstance(response, str) + assert len(response) > 0 + + @pytest.mark.vcr() + def test_describe_image_claude(self, test_image_bytes: bytes) -> None: + """Test LiteLLM with Claude can describe an image.""" + llm = LLM(model="anthropic/claude-3-5-haiku-20241022", is_litellm=True) + files = {"image": ImageFile(source=test_image_bytes)} + + messages = _build_multimodal_message( + llm, + "Describe this image in one sentence. Be brief.", + files, + ) + + response = llm.call(messages) + + assert response + assert isinstance(response, str) + assert len(response) > 0 + + +class TestMultipleFilesIntegration: + """Integration tests for multiple files in a single request.""" + + @pytest.mark.vcr() + def test_multiple_images_openai(self, test_image_bytes: bytes) -> None: + """Test OpenAI can process multiple images.""" + llm = LLM(model="openai/gpt-4o-mini") + files = { + "image1": ImageFile(source=test_image_bytes), + "image2": ImageFile(source=test_image_bytes), + } + + messages = _build_multimodal_message( + llm, + "How many images do you see? Answer with just the number.", + files, + ) + + response = llm.call(messages) + + assert response + assert isinstance(response, str) + assert "2" in response or "two" in response.lower() + + @pytest.mark.vcr() + def test_mixed_content_anthropic(self, test_image_bytes: bytes) -> None: + """Test Anthropic can process image and PDF together.""" + llm = LLM(model="anthropic/claude-3-5-haiku-20241022") + files = { + "image": ImageFile(source=test_image_bytes), + "document": PDFFile(source=MINIMAL_PDF), + } + + messages = _build_multimodal_message( + llm, + "What types of files did I send you? List them briefly.", + files, + ) + + response = llm.call(messages) + + assert response + assert isinstance(response, str) + assert len(response) > 0 + + +class TestGenericFileIntegration: + """Integration tests for the generic File class with auto-detection.""" + + @pytest.mark.vcr() + def test_generic_file_image_openai(self, test_image_bytes: bytes) -> None: + """Test generic File auto-detects image and sends correct content type.""" + llm = LLM(model="openai/gpt-4o-mini") + files = {"image": File(source=test_image_bytes)} + + messages = _build_multimodal_message( + llm, + "Describe this image in one sentence. Be brief.", + files, + ) + + response = llm.call(messages) + + assert response + assert isinstance(response, str) + assert len(response) > 0 + + @pytest.mark.vcr() + def test_generic_file_pdf_anthropic(self) -> None: + """Test generic File auto-detects PDF and sends correct content type.""" + llm = LLM(model="anthropic/claude-3-5-haiku-20241022") + files = {"document": File(source=MINIMAL_PDF)} + + messages = _build_multimodal_message( + llm, + "What type of document is this? Answer in one word.", + files, + ) + + response = llm.call(messages) + + assert response + assert isinstance(response, str) + assert len(response) > 0 + + @pytest.mark.vcr() + def test_generic_file_text_gemini(self, test_text_bytes: bytes) -> None: + """Test generic File auto-detects text and sends correct content type.""" + llm = LLM(model="gemini/gemini-2.0-flash") + files = {"content": File(source=test_text_bytes)} + + messages = _build_multimodal_message( + llm, + "Summarize what this text says in one sentence.", + files, + ) + + response = llm.call(messages) + + assert response + assert isinstance(response, str) + assert len(response) > 0 + + @pytest.mark.vcr() + def test_generic_file_mixed_types(self, test_image_bytes: bytes) -> None: + """Test generic File works with multiple auto-detected types.""" + llm = LLM(model="anthropic/claude-3-5-haiku-20241022") + files = { + "chart": File(source=test_image_bytes), + "doc": File(source=MINIMAL_PDF), + } + + messages = _build_multimodal_message( + llm, + "What types of files did I send? List them briefly.", + files, + ) + + response = llm.call(messages) + + assert response + assert isinstance(response, str) + assert len(response) > 0 \ No newline at end of file