autobyteus 1.1.5__py3-none-any.whl → 1.1.7__py3-none-any.whl

autobyteus/llm/api/ollama_llm.py

@@ -1,21 +1,22 @@
-from typing import Dict, Optional, List, AsyncGenerator
+from typing import Dict, Optional, List, AsyncGenerator, Any
 from ollama import AsyncClient, ChatResponse, ResponseError
+from ollama import Image  # FIX: Import the Image type from the ollama library
 from autobyteus.llm.models import LLMModel
 from autobyteus.llm.base_llm import BaseLLM
 from autobyteus.llm.utils.llm_config import LLMConfig
-from autobyteus.llm.utils.messages import MessageRole, Message
+from autobyteus.llm.utils.messages import Message
 from autobyteus.llm.utils.token_usage import TokenUsage
 from autobyteus.llm.utils.response_types import CompleteResponse, ChunkResponse
+from autobyteus.llm.user_message import LLMUserMessage
+from autobyteus.llm.utils.media_payload_formatter import image_source_to_base64
 import logging
 import asyncio
 import httpx
-import os
 
 logger = logging.getLogger(__name__)
 
 class OllamaLLM(BaseLLM):
     def __init__(self, model: LLMModel, llm_config: LLMConfig):
-        # The host URL is now passed via the model object, decoupling from environment variables here.
         if not model.host_url:
             raise ValueError("OllamaLLM requires a host_url to be set in its LLMModel object.")
             
@@ -26,16 +27,41 @@ class OllamaLLM(BaseLLM):
         super().__init__(model=model, llm_config=llm_config)
         logger.info(f"OllamaLLM initialized with model: {self.model.model_identifier}")
 
-    async def _send_user_message_to_llm(self, user_message: str, image_urls: Optional[List[str]] = None, **kwargs) -> CompleteResponse:
+    async def _format_ollama_messages(self) -> List[Dict[str, Any]]:
+        """
+        Formats the conversation history for the Ollama API, including multimodal content.
+        """
+        formatted_messages = []
+        for msg in self.messages:
+            msg_dict = {
+                "role": msg.role.value,
+                "content": msg.content or ""
+            }
+            if msg.image_urls:
+                try:
+                    # Concurrently process all images using the centralized utility
+                    image_tasks = [image_source_to_base64(url) for url in msg.image_urls]
+                    prepared_base64_images = await asyncio.gather(*image_tasks)
+                    if prepared_base64_images:
+                        # FIX: Wrap each base64 string in the official ollama.Image object
+                        msg_dict["images"] = [Image(value=b64_string) for b64_string in prepared_base64_images]
+                except Exception as e:
+                    logger.error(f"Error processing images for Ollama, skipping them. Error: {e}")
+
+            formatted_messages.append(msg_dict)
+        return formatted_messages
+
+    async def _send_user_message_to_llm(self, user_message: LLMUserMessage, **kwargs) -> CompleteResponse:
         self.add_user_message(user_message)
+
         try:
+            formatted_messages = await self._format_ollama_messages()
             response: ChatResponse = await self.client.chat(
                 model=self.model.value,
-                messages=[msg.to_dict() for msg in self.messages]
+                messages=formatted_messages
             )
             assistant_message = response['message']['content']
             
-            # Detect and process reasoning content using <think> markers
             reasoning_content = None
             main_content = assistant_message
             if "<think>" in assistant_message and "</think>" in assistant_message:
@@ -69,7 +95,7 @@ class OllamaLLM(BaseLLM):
             raise
 
     async def _stream_user_message_to_llm(
-        self, user_message: str, image_urls: Optional[List[str]] = None, **kwargs
+        self, user_message: LLMUserMessage, **kwargs
     ) -> AsyncGenerator[ChunkResponse, None]:
         self.add_user_message(user_message)
         accumulated_main = ""
@@ -78,17 +104,16 @@ class OllamaLLM(BaseLLM):
         final_response = None
         
         try:
+            formatted_messages = await self._format_ollama_messages()
             async for part in await self.client.chat(
                 model=self.model.value,
-                messages=[msg.to_dict() for msg in self.messages],
+                messages=formatted_messages,
                 stream=True
             ):
                 token = part['message']['content']
                 
-                # Simple state machine for <think> tags
                 if "<think>" in token:
                     in_reasoning = True
-                    # In case token is like "...</think><think>...", handle it
                     parts = token.split("<think>")
                     token = parts[-1]
 
@@ -130,4 +155,4 @@ class OllamaLLM(BaseLLM):
             raise
 
     async def cleanup(self):
-        await super().cleanup()
+        await super().cleanup()

autobyteus/llm/api/openai_compatible_llm.py

@@ -1,20 +1,62 @@
 import logging
 import os
 from abc import ABC
-from typing import Optional, List, AsyncGenerator
+from typing import Optional, List, AsyncGenerator, Dict, Any
 from openai import OpenAI
 from openai.types.completion_usage import CompletionUsage
 from openai.types.chat import ChatCompletionChunk
+import asyncio
 
 from autobyteus.llm.base_llm import BaseLLM
 from autobyteus.llm.models import LLMModel
 from autobyteus.llm.utils.llm_config import LLMConfig
-from autobyteus.llm.utils.image_payload_formatter import process_image
+from autobyteus.llm.utils.media_payload_formatter import image_source_to_base64, create_data_uri, get_mime_type, is_valid_image_path
 from autobyteus.llm.utils.token_usage import TokenUsage
 from autobyteus.llm.utils.response_types import CompleteResponse, ChunkResponse
+from autobyteus.llm.user_message import LLMUserMessage
+from autobyteus.llm.utils.messages import Message
 
 logger = logging.getLogger(__name__)
 
+async def _format_openai_history(messages: List[Message]) -> List[Dict[str, Any]]:
+    """A local async function to format history for the OpenAI SDK, handling image processing."""
+    formatted_messages = []
+    for msg in messages:
+        # For multimodal messages, build the content list of parts
+        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 = []
+            if msg.image_urls:
+                for url in msg.image_urls:
+                    # Create an async task for each image to process them concurrently
+                    image_tasks.append(image_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]
+                    # Determine mime type from original path if possible, otherwise default
+                    mime_type = get_mime_type(original_url) if is_valid_image_path(original_url) else "image/jpeg"
+                    content_parts.append(create_data_uri(mime_type, b64_image))
+            except Exception as e:
+                logger.error(f"Error processing one or more images: {e}")
+
+            # Placeholder for future audio/video processing
+            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.")
+
+            formatted_messages.append({"role": msg.role.value, "content": content_parts})
+        else:
+            # For text-only messages, use the simple string format
+            formatted_messages.append({"role": msg.role.value, "content": msg.content})
+    return formatted_messages
+
+
 class OpenAICompatibleLLM(BaseLLM, ABC):
     def __init__(
         self,
@@ -24,18 +66,6 @@ class OpenAICompatibleLLM(BaseLLM, ABC):
         base_url: str,
         api_key_default: Optional[str] = None
     ):
-        """
-        Initializes an OpenAI-compatible LLM.
-
-        Args:
-            model (LLMModel): The model to use.
-            llm_config (LLMConfig): Configuration for the LLM.
-            api_key_env_var (str): The name of the environment variable for the API key.
-            base_url (str): The base URL for the API.
-            api_key_default (Optional[str], optional): A default API key to use if the
-                                                       environment variable is not set.
-                                                       Defaults to None.
-        """
         api_key = os.getenv(api_key_env_var)
         if not api_key:
             if api_key_default:
@@ -49,13 +79,11 @@ class OpenAICompatibleLLM(BaseLLM, ABC):
         logger.info(f"Initialized OpenAI compatible client with base_url: {base_url}")
         
         super().__init__(model=model, llm_config=llm_config)
-        self.max_tokens = 8000 # A default, can be overridden by subclass or config
+        self.max_tokens = 8000
 
     def _create_token_usage(self, usage_data: Optional[CompletionUsage]) -> Optional[TokenUsage]:
-        """Convert usage data to TokenUsage format."""
         if not usage_data:
             return None
-        
         return TokenUsage(
             prompt_tokens=usage_data.prompt_tokens,
             completion_tokens=usage_data.completion_tokens,
@@ -63,53 +91,41 @@ class OpenAICompatibleLLM(BaseLLM, ABC):
         )
 
     async def _send_user_message_to_llm(
-        self, user_message: str, image_urls: Optional[List[str]] = None, **kwargs
+        self, user_message: LLMUserMessage, **kwargs
     ) -> CompleteResponse:
-        """
-        Sends a non-streaming request to an OpenAI-compatible API.
-        Supports optional reasoning content if provided in the response.
-        """
-        content = []
-
-        if user_message:
-            content.append({"type": "text", "text": user_message})
-
-        if image_urls:
-            for image_url in image_urls:
-                try:
-                    image_content = process_image(image_url)
-                    content.append(image_content)
-                    logger.info(f"Processed image: {image_url}")
-                except ValueError as e:
-                    logger.error(f"Error processing image {image_url}: {str(e)}")
-                    continue
-
-        self.add_user_message(content)
-        logger.debug(f"Prepared message content: {content}")
-
+        self.add_user_message(user_message)
+        
         try:
+            formatted_messages = await _format_openai_history(self.messages)
             logger.info(f"Sending request to {self.model.provider.value} API")
-            response = self.client.chat.completions.create(
-                model=self.model.value,
-                messages=[msg.to_dict() for msg in self.messages],
-                max_tokens=self.max_tokens,
-            )
+            
+            params: Dict[str, Any] = {
+                "model": self.model.value,
+                "messages": formatted_messages,
+            }
+
+            if self.config.uses_max_completion_tokens:
+                params["max_completion_tokens"] = self.max_tokens
+            else:
+                params["max_tokens"] = self.max_tokens
+
+            response = self.client.chat.completions.create(**params)
             full_message = response.choices[0].message
 
-            # Extract reasoning_content if present
+            # --- PRESERVED ORIGINAL LOGIC ---
             reasoning = None
             if hasattr(full_message, "reasoning_content") and full_message.reasoning_content:
                 reasoning = full_message.reasoning_content
             elif "reasoning_content" in full_message and full_message["reasoning_content"]:
                 reasoning = full_message["reasoning_content"]
 
-            # Extract main content
             main_content = ""
             if hasattr(full_message, "content") and full_message.content:
                 main_content = full_message.content
             elif "content" in full_message and full_message["content"]:
                 main_content = full_message["content"]
-            
+            # --- END PRESERVED LOGIC ---
+
             self.add_assistant_message(main_content, reasoning_content=reasoning)
 
             token_usage = self._create_token_usage(response.usage)
@@ -125,43 +141,30 @@ class OpenAICompatibleLLM(BaseLLM, ABC):
             raise ValueError(f"Error in {self.model.provider.value} API request: {str(e)}")
 
     async def _stream_user_message_to_llm(
-        self, user_message: str, image_urls: Optional[List[str]] = None, **kwargs
+        self, user_message: LLMUserMessage, **kwargs
     ) -> AsyncGenerator[ChunkResponse, None]:
-        """
-        Streams the response from an OpenAI-compatible API.
-        Yields reasoning and content in separate chunks.
-        """
-        content = []
-
-        if user_message:
-            content.append({"type": "text", "text": user_message})
-
-        if image_urls:
-            for image_url in image_urls:
-                try:
-                    image_content = process_image(image_url)
-                    content.append(image_content)
-                    logger.info(f"Processed image for streaming: {image_url}")
-                except ValueError as e:
-                    logger.error(f"Error processing image for streaming {image_url}: {str(e)}")
-                    continue
+        self.add_user_message(user_message)
 
-        self.add_user_message(content)
-        logger.debug(f"Prepared streaming message content: {content}")
-
-        # Initialize variables to track reasoning and main content
         accumulated_reasoning = ""
         accumulated_content = ""
 
         try:
+            formatted_messages = await _format_openai_history(self.messages)
             logger.info(f"Starting streaming request to {self.model.provider.value} API")
-            stream = self.client.chat.completions.create(
-                model=self.model.value,
-                messages=[msg.to_dict() for msg in self.messages],
-                max_tokens=self.max_tokens,
-                stream=True,
-                stream_options={"include_usage": True}
-            )
+            
+            params: Dict[str, Any] = {
+                "model": self.model.value,
+                "messages": formatted_messages,
+                "stream": True,
+                "stream_options": {"include_usage": True},
+            }
+
+            if self.config.uses_max_completion_tokens:
+                params["max_completion_tokens"] = self.max_tokens
+            else:
+                params["max_tokens"] = self.max_tokens
+
+            stream = self.client.chat.completions.create(**params)
 
             for chunk in stream:
                 chunk: ChatCompletionChunk
@@ -170,25 +173,23 @@ class OpenAICompatibleLLM(BaseLLM, ABC):
                 
                 delta = chunk.choices[0].delta
 
-                # Process reasoning tokens (if supported by model)
-                reasoning_chunk = getattr(delta, "reasoning_content", None)
+                # --- PRESERVED ORIGINAL LOGIC (adapted for streaming) ---
+                reasoning_chunk = None
+                if hasattr(delta, "reasoning_content") and delta.reasoning_content:
+                    reasoning_chunk = delta.reasoning_content
+                elif isinstance(delta, dict) and "reasoning_content" in delta and delta["reasoning_content"]:
+                    reasoning_chunk = delta["reasoning_content"]
+                
                 if reasoning_chunk:
                     accumulated_reasoning += reasoning_chunk
-                    yield ChunkResponse(
-                        content="",
-                        reasoning=reasoning_chunk
-                    )
+                    yield ChunkResponse(content="", reasoning=reasoning_chunk)
+                # --- END PRESERVED LOGIC ---
 
-                # Process main content tokens
                 main_token = delta.content
                 if main_token:
                     accumulated_content += main_token
-                    yield ChunkResponse(
-                        content=main_token,
-                        reasoning=None
-                    )
+                    yield ChunkResponse(content=main_token, reasoning=None)
 
-                # Yield token usage if available in the final chunk
                 if hasattr(chunk, "usage") and chunk.usage is not None:
                     token_usage = self._create_token_usage(chunk.usage)
                     yield ChunkResponse(
@@ -198,7 +199,6 @@ class OpenAICompatibleLLM(BaseLLM, ABC):
                         usage=token_usage
                     )
             
-            # After streaming, add the fully accumulated assistant message to history
             self.add_assistant_message(accumulated_content, reasoning_content=accumulated_reasoning)
             logger.info(f"Completed streaming response from {self.model.provider.value} API")
 

autobyteus/llm/autobyteus_provider.py

@@ -49,7 +49,7 @@ class AutobyteusModelProvider:
                 try:
                     # Instantiate client for this specific host
                     client = AutobyteusClient(server_url=host_url)
-                    response = client.get_available_models_sync()
+                    response = client.get_available_llm_models_sync()
                 except Exception as e:
                     logger.warning(f"Could not connect or fetch models from Autobyteus server at {host_url}: {e}")
                     continue