autobyteus 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

autobyteus/llm/prompt_renderers/ollama_prompt_renderer.py

@@ -0,0 +1,51 @@
+import asyncio
+import logging
+from typing import Dict, List, Any, Optional
+
+from ollama import Image
+
+from autobyteus.llm.prompt_renderers.base_prompt_renderer import BasePromptRenderer
+from autobyteus.llm.utils.messages import Message, MessageRole, ToolCallPayload, ToolResultPayload
+from autobyteus.llm.utils.media_payload_formatter import media_source_to_base64
+
+logger = logging.getLogger(__name__)
+
+
+class OllamaPromptRenderer(BasePromptRenderer):
+    async def render(self, messages: List[Message]) -> List[Dict[str, Any]]:
+        formatted_messages: List[Dict[str, Any]] = []
+        for msg in messages:
+            role = msg.role.value
+            content = msg.content or ""
+            if msg.tool_payload or msg.role == MessageRole.TOOL:
+                content = _format_tool_payload(msg) or ""
+                role = (
+                    MessageRole.USER.value
+                    if msg.role == MessageRole.TOOL
+                    else MessageRole.ASSISTANT.value
+                )
+            msg_dict: Dict[str, Any] = {"role": role, "content": content}
+
+            if msg.image_urls:
+                try:
+                    image_tasks = [media_source_to_base64(url) for url in msg.image_urls]
+                    prepared_base64_images = await asyncio.gather(*image_tasks)
+                    if prepared_base64_images:
+                        msg_dict["images"] = [Image(value=b64_string) for b64_string in prepared_base64_images]
+                except Exception as exc:
+                    logger.error("Error processing images for Ollama, skipping them. Error: %s", exc)
+
+            formatted_messages.append(msg_dict)
+        return formatted_messages
+
+
+def _format_tool_payload(message: Message) -> Optional[str]:
+    payload = message.tool_payload
+    if isinstance(payload, ToolCallPayload):
+        lines = [f"[TOOL_CALL] {call.name} {call.arguments}" for call in payload.tool_calls]
+        return "\n".join(lines)
+    if isinstance(payload, ToolResultPayload):
+        if payload.tool_error:
+            return f"[TOOL_ERROR] {payload.tool_name} {payload.tool_error}"
+        return f"[TOOL_RESULT] {payload.tool_name} {payload.tool_result}"
+    return None

autobyteus/llm/prompt_renderers/openai_chat_renderer.py

@@ -0,0 +1,97 @@
+import asyncio
+import json
+import logging
+from typing import List, Dict, Any
+
+from autobyteus.llm.prompt_renderers.base_prompt_renderer import BasePromptRenderer
+from autobyteus.llm.utils.media_payload_formatter import (
+    media_source_to_base64,
+    create_data_uri,
+    get_mime_type,
+    is_valid_media_path,
+)
+from autobyteus.llm.utils.messages import Message, ToolCallPayload, ToolResultPayload
+
+logger = logging.getLogger(__name__)
+
+
+class OpenAIChatRenderer(BasePromptRenderer):
+    async def render(self, messages: List[Message]) -> List[Dict[str, Any]]:
+        rendered: List[Dict[str, Any]] = []
+
+        for msg in messages:
+            content: Any = msg.content
+            if msg.image_urls or msg.audio_urls or msg.video_urls:
+                content_parts: List[Dict[str, Any]] = []
+                if msg.content:
+                    content_parts.append({"type": "text", "text": msg.content})
+
+                image_tasks = []
+                for url in msg.image_urls:
+                    image_tasks.append(media_source_to_base64(url))
+
+                try:
+                    base64_images = await asyncio.gather(*image_tasks)
+                    for i, b64_image in enumerate(base64_images):
+                        original_url = msg.image_urls[i]
+                        mime_type = (
+                            get_mime_type(original_url)
+                            if is_valid_media_path(original_url)
+                            else "image/jpeg"
+                        )
+                        content_parts.append(create_data_uri(mime_type, b64_image))
+                except Exception as e:
+                    logger.error("Error processing one or more images: %s", e)
+
+                if msg.audio_urls:
+                    logger.warning("OpenAI compatible layer does not yet support audio; skipping.")
+                if msg.video_urls:
+                    logger.warning("OpenAI compatible layer does not yet support video; skipping.")
+
+                content = content_parts
+
+            if isinstance(msg.tool_payload, ToolCallPayload):
+                tool_calls = [
+                    {
+                        "id": call.id,
+                        "type": "function",
+                        "function": {
+                            "name": call.name,
+                            "arguments": json.dumps(call.arguments, ensure_ascii=True),
+                        },
+                    }
+                    for call in msg.tool_payload.tool_calls
+                ]
+                rendered.append(
+                    {
+                        "role": "assistant",
+                        "content": content,
+                        "tool_calls": tool_calls,
+                    }
+                )
+                continue
+
+            if isinstance(msg.tool_payload, ToolResultPayload):
+                result_text = _format_tool_result(msg.tool_payload)
+                rendered.append(
+                    {
+                        "role": "tool",
+                        "tool_call_id": msg.tool_payload.tool_call_id,
+                        "content": result_text,
+                    }
+                )
+                continue
+
+            rendered.append({"role": msg.role.value, "content": content})
+
+        return rendered
+
+
+def _format_tool_result(payload: ToolResultPayload) -> str:
+    if payload.tool_error:
+        return f"Error: {payload.tool_error}"
+    if payload.tool_result is None:
+        return ""
+    if isinstance(payload.tool_result, (dict, list)):
+        return json.dumps(payload.tool_result, ensure_ascii=True)
+    return str(payload.tool_result)

autobyteus/llm/prompt_renderers/openai_responses_renderer.py

@@ -0,0 +1,101 @@
+import asyncio
+import json
+import logging
+from typing import List, Dict, Any
+
+from autobyteus.llm.prompt_renderers.base_prompt_renderer import BasePromptRenderer
+from autobyteus.llm.utils.media_payload_formatter import (
+    media_source_to_base64,
+    create_data_uri,
+    get_mime_type,
+    is_valid_media_path,
+)
+from autobyteus.llm.utils.messages import Message, ToolCallPayload, ToolResultPayload
+
+logger = logging.getLogger(__name__)
+
+
+class OpenAIResponsesRenderer(BasePromptRenderer):
+    async def render(self, messages: List[Message]) -> List[Dict[str, Any]]:
+        rendered: List[Dict[str, Any]] = []
+
+        for msg in messages:
+            if isinstance(msg.tool_payload, ToolCallPayload):
+                rendered.append(
+                    {
+                        "type": "message",
+                        "role": "assistant",
+                        "content": _format_tool_calls(msg.tool_payload),
+                    }
+                )
+                continue
+
+            if isinstance(msg.tool_payload, ToolResultPayload):
+                rendered.append(
+                    {
+                        "type": "message",
+                        "role": "user",
+                        "content": _format_tool_result(msg.tool_payload),
+                    }
+                )
+                continue
+
+            if msg.image_urls or msg.audio_urls or msg.video_urls:
+                content_parts: List[Dict[str, Any]] = []
+                if msg.content:
+                    content_parts.append({"type": "input_text", "text": msg.content})
+
+                image_tasks = []
+                for url in msg.image_urls:
+                    image_tasks.append(media_source_to_base64(url))
+
+                try:
+                    base64_images = await asyncio.gather(*image_tasks)
+                    for i, b64_image in enumerate(base64_images):
+                        original_url = msg.image_urls[i]
+                        mime_type = (
+                            get_mime_type(original_url)
+                            if is_valid_media_path(original_url)
+                            else "image/jpeg"
+                        )
+                        data_uri = create_data_uri(mime_type, b64_image)["image_url"]["url"]
+                        content_parts.append(
+                            {"type": "input_image", "image_url": data_uri, "detail": "auto"}
+                        )
+                except Exception as e:
+                    logger.error("Error processing one or more images: %s", e)
+
+                if msg.audio_urls:
+                    logger.warning("OpenAI Responses input does not yet support audio; skipping.")
+                if msg.video_urls:
+                    logger.warning("OpenAI Responses input does not yet support video; skipping.")
+
+                rendered.append(
+                    {"type": "message", "role": msg.role.value, "content": content_parts}
+                )
+            else:
+                rendered.append(
+                    {"type": "message", "role": msg.role.value, "content": msg.content or ""}
+                )
+
+        return rendered
+
+
+def _format_tool_calls(payload: ToolCallPayload) -> str:
+    lines = []
+    for call in payload.tool_calls:
+        args = json.dumps(call.arguments, ensure_ascii=True)
+        lines.append(f"[TOOL_CALL] {call.name} {args}")
+    return "\n".join(lines)
+
+
+def _format_tool_result(payload: ToolResultPayload) -> str:
+    if payload.tool_error:
+        return f"[TOOL_ERROR] {payload.tool_name} {payload.tool_error}"
+    if payload.tool_result is None:
+        return f"[TOOL_RESULT] {payload.tool_name}"
+    if isinstance(payload.tool_result, (dict, list)):
+        result_text = json.dumps(payload.tool_result, ensure_ascii=True)
+    else:
+        result_text = str(payload.tool_result)
+    return f"[TOOL_RESULT] {payload.tool_name} {result_text}"

autobyteus/llm/providers.py

@@ -4,10 +4,7 @@ class LLMProvider(Enum):
     OPENAI = "OPENAI"
     ANTHROPIC = "ANTHROPIC"
     MISTRAL = "MISTRAL"
-    GROQ = "GROQ"
     GEMINI = "GEMINI"
-    NVIDIA = "NVIDIA"
-    PERPLEXITY = "PERPLEXITY"
     OLLAMA = "OLLAMA"
     DEEPSEEK = "DEEPSEEK"
     GROK = "GROK"
@@ -16,3 +13,4 @@ class LLMProvider(Enum):
     QWEN = "QWEN"
     LMSTUDIO = "LMSTUDIO"
     ZHIPU = "ZHIPU"
+    MINIMAX = "MINIMAX"

autobyteus/llm/token_counter/claude_token_counter.py

@@ -1,8 +1,9 @@
 import anthropic
-from typing import List, TYPE_CHECKING
+import json
+from typing import List, TYPE_CHECKING, Dict, Any, Optional, Tuple
 from autobyteus.llm.token_counter.base_token_counter import BaseTokenCounter
 from autobyteus.llm.models import LLMModel
-from autobyteus.llm.utils.messages import Message
+from autobyteus.llm.utils.messages import Message, MessageRole
 
 if TYPE_CHECKING:
     from autobyteus.llm.base_llm import BaseLLM
@@ -14,23 +15,47 @@ class ClaudeTokenCounter(BaseTokenCounter):
 
     def __init__(self, model: LLMModel, llm: 'BaseLLM' = None):
         super().__init__(model, llm)
-        self.client = anthropic.Client()
+        self.client = anthropic.Anthropic()
 
-    def convert_to_internal_format(self, messages: List[Message]) -> List[str]:
+    def convert_to_anthropic_messages(self, messages: List[Message]) -> Tuple[Optional[str], List[Dict[str, Any]]]:
         """
-        Convert messages to the internal format required for Claude token counting.
+        Convert messages to the format required for Claude token counting.
 
         Args:
             messages (List[Message]): The list of input messages.
 
         Returns:
-            List[str]: The list of processed message strings.
+            Tuple[Optional[str], List[Dict[str, Any]]]: System prompt (if any) and message payloads.
         """
-        processed_messages = []
+        system_parts: List[str] = []
+        processed_messages: List[Dict[str, Any]] = []
         for message in messages:
-            processed_message = f"{message.role.value}: {message.content}"
-            processed_messages.append(processed_message)
-        return processed_messages
+            content = self._extract_message_text(message)
+            if message.role == MessageRole.SYSTEM:
+                system_parts.append(content)
+                continue
+            role = "assistant" if message.role == MessageRole.ASSISTANT else "user"
+            processed_messages.append({"role": role, "content": content})
+        system = "\n".join(system_parts) if system_parts else None
+        return system, processed_messages
+
+    def _extract_message_text(self, message: Message) -> str:
+        if message.content is not None:
+            return message.content
+        if message.tool_payload is None:
+            raise ValueError("Message content is None and no tool payload is available.")
+        payload = message.to_dict().get("tool_payload")
+        return json.dumps(payload, sort_keys=True)
+
+    def _count_tokens(self, messages: List[Dict[str, Any]], system: Optional[str] = None) -> int:
+        kwargs: Dict[str, Any] = {
+            "model": self.model.value,
+            "messages": messages,
+        }
+        if system:
+            kwargs["system"] = system
+        response = self.client.messages.count_tokens(**kwargs)
+        return response.input_tokens
 
     def count_input_tokens(self, messages: List[Message]) -> int:
         """
@@ -45,17 +70,16 @@ class ClaudeTokenCounter(BaseTokenCounter):
         if not messages:
             return 0
 
-        total_tokens = 0
-        processed_messages = self.convert_to_internal_format(messages)
-        
-        for message in processed_messages:
-            try:
-                tokens = self.client.count_tokens(message)
-                total_tokens += tokens
-            except Exception as e:
-                raise ValueError(f"Failed to count tokens for message: {str(e)}")
-                
-        return total_tokens
+        try:
+            system, processed_messages = self.convert_to_anthropic_messages(messages)
+            if not processed_messages:
+                dummy = [{"role": "user", "content": " "}]
+                total_tokens = self._count_tokens(dummy, system=system)
+                prompt_tokens = self._count_tokens(dummy)
+                return max(0, total_tokens - prompt_tokens)
+            return self._count_tokens(processed_messages, system=system)
+        except Exception as e:
+            raise ValueError(f"Failed to count tokens for messages: {str(e)}")
 
     def count_output_tokens(self, message: Message) -> int:
         """
@@ -67,11 +91,18 @@ class ClaudeTokenCounter(BaseTokenCounter):
         Returns:
             int: The number of output tokens.
         """
-        if not message.content:
+        if not message:
             return 0
-            
+
         try:
-            processed_message = f"{message.role.value}: {message.content}"
-            return self.client.count_tokens(processed_message)
+            content = self._extract_message_text(message)
+            if content == "":
+                return 0
+            if message.role == MessageRole.ASSISTANT:
+                dummy_user = Message(role=MessageRole.USER, content=" ")
+                total_tokens = self.count_input_tokens([dummy_user, message])
+                prompt_tokens = self.count_input_tokens([dummy_user])
+                return max(0, total_tokens - prompt_tokens)
+            return self.count_input_tokens([message])
         except Exception as e:
             raise ValueError(f"Failed to count output tokens: {str(e)}")

autobyteus/llm/token_counter/mistral_token_counter.py

@@ -95,7 +95,6 @@ class MistralTokenCounter(BaseTokenCounter):
     def count_output_tokens(self, message: Message) -> int:
         """
         Count the number of tokens in the output message using Mistral's tokenizer.
-        This implementation subtracts the token count of previous messages from the total tokens to isolate the output tokens.
 
         Args:
             message (Message): The output message.
@@ -106,10 +105,15 @@ class MistralTokenCounter(BaseTokenCounter):
         Raises:
             Exception: If token counting fails for any reason.
         """
-        # Calculate total tokens for all messages including the assistant message
-        all_tokens = self.count_input_tokens(self.llm.messages)
-        # Exclude the last message (assistant message) to get previous messages
-        prev_messages = self.llm.messages[:-1] if len(self.llm.messages) > 1 else []
-        prev_tokens = self.count_input_tokens(prev_messages) if prev_messages else 0
-        # The difference should correspond to the tokens for the assistant's last message
-        return all_tokens - prev_tokens
+        if not message:
+            return 0
+        if message.role == MessageRole.ASSISTANT:
+            if not message.content:
+                return 0
+            # Mistral requires conversations to start with user/system.
+            # Estimate output tokens by subtracting a dummy prompt prefix.
+            dummy_user = Message(role=MessageRole.USER, content=" ")
+            total_tokens = self.count_input_tokens([dummy_user, message])
+            prompt_tokens = self.count_input_tokens([dummy_user])
+            return max(0, total_tokens - prompt_tokens)
+        return self.count_input_tokens([message])

autobyteus/llm/token_counter/openai_token_counter.py

@@ -1,3 +1,4 @@
+import logging
 import tiktoken
 from typing import List, TYPE_CHECKING
 from autobyteus.llm.token_counter.base_token_counter import BaseTokenCounter
@@ -7,6 +8,8 @@ from autobyteus.llm.utils.messages import Message
 if TYPE_CHECKING:
     from autobyteus.llm.base_llm import BaseLLM
 
+logger = logging.getLogger(__name__)
+
 class OpenAITokenCounter(BaseTokenCounter):
     """
     A token counter implementation for OpenAI models using tiktoken.
@@ -17,8 +20,24 @@ class OpenAITokenCounter(BaseTokenCounter):
         try:
             self.encoding = tiktoken.encoding_for_model(model.value)
         except Exception:
-            # fallback if model_name is not recognized
-            self.encoding = tiktoken.get_encoding("cl100k_base")
+            # If the specific model is unknown, fall back to the widely available
+            # cl100k_base encoding. tiktoken bundles this file; it loads locally
+            # without needing network access.
+            try:
+                logger.warning(
+                    "tiktoken encoding_for_model failed for '%s'; falling back to cl100k_base (approximate token counts).",
+                    model.value,
+                )
+                self.encoding = tiktoken.get_encoding("cl100k_base")
+            except Exception:
+                # As a last resort (e.g., stripped-down wheels), degrade gracefully
+                # with a naive whitespace encoder so tests can still execute offline.
+                logger.warning(
+                    "tiktoken cl100k_base unavailable; using whitespace token counting for model '%s' (very approximate).",
+                    model.value,
+                )
+                self.encoding = None
+        self._encode = self.encoding.encode if self.encoding else (lambda text: text.split() if text else [])
 
     def convert_to_internal_format(self, messages: List[Message]) -> List[str]:
         """
@@ -51,7 +70,7 @@ class OpenAITokenCounter(BaseTokenCounter):
         processed_messages = self.convert_to_internal_format(messages)
         total_tokens = 0
         for processed_message in processed_messages:
-            total_tokens += len(self.encoding.encode(processed_message))
+            total_tokens += len(self._encode(processed_message))
         return total_tokens
 
     def count_output_tokens(self, message: Message) -> int:
@@ -67,7 +86,7 @@ class OpenAITokenCounter(BaseTokenCounter):
         if not message.content:
             return 0
         processed_message = f"<im_start>{message.role.value}\n{message.content}\n<im_end>"
-        return len(self.encoding.encode(processed_message))
+        return len(self._encode(processed_message))
 
     def count_tokens(self, text: str) -> int:
         """
@@ -81,4 +100,4 @@ class OpenAITokenCounter(BaseTokenCounter):
         """
         if not text:
             return 0
-        return len(self.encoding.encode(text))
+        return len(self._encode(text))

autobyteus/llm/token_counter/token_counter_factory.py

@@ -1,4 +1,6 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
+import logging
+
 from autobyteus.llm.token_counter.openai_token_counter import OpenAITokenCounter
 from autobyteus.llm.token_counter.claude_token_counter import ClaudeTokenCounter
 from autobyteus.llm.token_counter.mistral_token_counter import MistralTokenCounter
@@ -12,7 +14,9 @@ from autobyteus.llm.providers import LLMProvider
 if TYPE_CHECKING:
     from autobyteus.llm.base_llm import BaseLLM
 
-def get_token_counter(model: LLMModel, llm: 'BaseLLM') -> BaseTokenCounter:
+logger = logging.getLogger(__name__)
+
+def get_token_counter(model: LLMModel, llm: 'BaseLLM') -> Optional[BaseTokenCounter]:
     """
     Return the appropriate token counter implementation based on the model.
     
@@ -21,7 +25,8 @@ def get_token_counter(model: LLMModel, llm: 'BaseLLM') -> BaseTokenCounter:
         llm (BaseLLM): The LLM instance.
 
     Returns:
-        BaseTokenCounter: An instance of a token counter specific to the model.
+        Optional[BaseTokenCounter]: An instance of a token counter specific to the model,
+            or None if no token counter is available for the provider.
     """
     if model.provider == LLMProvider.OPENAI:
         return OpenAITokenCounter(model, llm)
@@ -46,5 +51,7 @@ def get_token_counter(model: LLMModel, llm: 'BaseLLM') -> BaseTokenCounter:
     elif model.provider == LLMProvider.ZHIPU:
         return ZhipuTokenCounter(model, llm)
     else:
-        # For models that do not have a specialized counter, raise a NotImplementedError
-        raise NotImplementedError(f"No token counter available for model {model.value}")
+        # For providers without a specialized counter, return None and log a warning
+        logger.info(f"No token counter available for provider {model.provider.value}. Token usage tracking will be disabled.")
+        return None
+

autobyteus/llm/utils/llm_config.py

@@ -54,8 +54,9 @@ class LLMConfig:
     top_p: Optional[float] = None
     frequency_penalty: Optional[float] = None
     presence_penalty: Optional[float] = None
+    compaction_ratio: Optional[float] = None
+    safety_margin_tokens: Optional[int] = None
     stop_sequences: Optional[List] = None
-    uses_max_completion_tokens: bool = False
     extra_params: Dict[str, Any] = field(default_factory=dict)
     pricing_config: TokenPricingConfig = field(default_factory=TokenPricingConfig)
 
@@ -107,7 +108,7 @@ class LLMConfig:
         known_fields = {
             'rate_limit', 'token_limit', 'system_message', 'temperature', 
             'max_tokens', 'top_p', 'frequency_penalty', 'presence_penalty', 
-            'stop_sequences', 'uses_max_completion_tokens', 'extra_params', 
+            'compaction_ratio', 'safety_margin_tokens', 'stop_sequences', 'extra_params',
             'pricing_config'
         }
         
@@ -122,8 +123,9 @@ class LLMConfig:
             top_p=init_kwargs.get('top_p'),
             frequency_penalty=init_kwargs.get('frequency_penalty'),
             presence_penalty=init_kwargs.get('presence_penalty'),
+            compaction_ratio=init_kwargs.get('compaction_ratio'),
+            safety_margin_tokens=init_kwargs.get('safety_margin_tokens'),
             stop_sequences=init_kwargs.get('stop_sequences'),
-            uses_max_completion_tokens=init_kwargs.get('uses_max_completion_tokens', False),
             extra_params=init_kwargs.get('extra_params', {}),
             pricing_config=pricing_config_data 
         )
@@ -174,16 +176,8 @@ class LLMConfig:
         for f_info in fields(override_config):
             override_value = getattr(override_config, f_info.name)
             
-            # Special handling for booleans where we want to merge if it's not the default
-            # For `uses_max_completion_tokens`, the default is False, so `if override_value:` is fine
-            is_boolean_field = f_info.type == bool
-            
-            # Standard check for None, but also merge if it's a non-default boolean
             if override_value is not None:
-                # For uses_max_completion_tokens, `False` is a valid override value, but `None` is not
-                if is_boolean_field and override_value is False and getattr(self, f_info.name) is True:
-                     setattr(self, f_info.name, override_value)
-                elif f_info.name == 'pricing_config':
+                if f_info.name == 'pricing_config':
                     if not isinstance(self.pricing_config, TokenPricingConfig):
                         self.pricing_config = TokenPricingConfig()
                     

autobyteus/llm/utils/media_payload_formatter.py

@@ -27,8 +27,8 @@ logger.warning(
 def get_mime_type(file_path: str) -> str:
     """Determine MIME type of file."""
     mime_type, _ = mimetypes.guess_type(file_path)
-    if not mime_type or not mime_type.startswith('image/'):
-        return 'image/jpeg'  # default fallback
+    if not mime_type:
+        return 'application/octet-stream'  # generic fallback
     return mime_type
 
 
@@ -44,9 +44,16 @@ def is_base64(s: str) -> bool:
         return False
 
 
-def is_valid_image_path(path: str) -> bool:
-    """Check if path exists and has a valid image extension."""
-    valid_extensions = {".jpg", ".jpeg", ".png", ".gif", ".webp"}
+def is_valid_media_path(path: str) -> bool:
+    """Check if path exists and has a valid media extension."""
+    valid_extensions = {
+        # Images
+        ".jpg", ".jpeg", ".png", ".gif", ".webp",
+        # Audio
+        ".mp3", ".wav", ".ogg", ".aac", ".flac",
+        # Video
+        ".mp4", ".mpeg", ".mov", ".avi", ".webm", ".mkv"
+    }
     try:
         file_path = Path(path)
         return file_path.is_file() and file_path.suffix.lower() in valid_extensions
@@ -64,36 +71,36 @@ def create_data_uri(mime_type: str, base64_data: str) -> Dict:
     }
 
 def file_to_base64(path: str) -> str:
-    """Reads an image file from a local path and returns it as a base64 encoded string."""
+    """Reads a file from a local path and returns it as a base64 encoded string."""
     try:
-        with open(path, "rb") as img_file:
-            return base64.b64encode(img_file.read()).decode("utf-8")
+        with open(path, "rb") as f:
+            return base64.b64encode(f.read()).decode("utf-8")
     except Exception as e:
-        logger.error(f"Failed to read and encode image file at {path}: {e}")
+        logger.error(f"Failed to read and encode file at {path}: {e}")
         raise
 
 async def url_to_base64(url: str) -> str:
-    """Downloads an image from a URL and returns it as a base64 encoded string."""
+    """Downloads content from a URL and returns it as a base64 encoded string."""
     try:
         response = await _http_client.get(url)
         response.raise_for_status()
         return base64.b64encode(response.content).decode("utf-8")
     except httpx.HTTPError as e:
-        logger.error(f"Failed to download image from URL {url}: {e}")
+        logger.error(f"Failed to download from URL {url}: {e}")
         raise
 
-async def image_source_to_base64(image_source: str) -> str:
+async def media_source_to_base64(media_source: str) -> str:
     """
-    Orchestrator function that converts an image source (file path, URL, or existing base64)
+    Orchestrator function that converts a media source (file path, URL, or existing base64)
     into a base64 encoded string by delegating to specialized functions.
     """
-    if is_valid_image_path(image_source):
-        return file_to_base64(image_source)
+    if is_valid_media_path(media_source):
+        return file_to_base64(media_source)
     
-    if image_source.startswith(("http://", "https://")):
-        return await url_to_base64(image_source)
+    if media_source.startswith(("http://", "https://")):
+        return await url_to_base64(media_source)
 
-    if is_base64(image_source):
-        return image_source
+    if is_base64(media_source):
+        return media_source
 
-    raise ValueError(f"Invalid image source: not a valid file path, URL, or base64 string.")
+    raise ValueError(f"Invalid media source: not a valid file path, URL, or base64 string.")