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

autobyteus/llm/api/minimax_llm.py

@@ -0,0 +1,26 @@
+import logging
+from typing import Optional
+from autobyteus.llm.models import LLMModel
+from autobyteus.llm.utils.llm_config import LLMConfig
+from autobyteus.llm.api.openai_compatible_llm import OpenAICompatibleLLM
+
+logger = logging.getLogger(__name__)
+
+class MinimaxLLM(OpenAICompatibleLLM):
+    def __init__(self, model: LLMModel = None, llm_config: LLMConfig = None):
+        # Provide defaults if not specified
+        if model is None:
+            model = LLMModel['minimax-m2.1']
+        if llm_config is None:
+            llm_config = LLMConfig()
+            
+        super().__init__(
+            model=model, 
+            llm_config=llm_config,
+            api_key_env_var="MINIMAX_API_KEY",
+            base_url="https://api.minimax.io/v1"
+        )
+        logger.info(f"MinimaxLLM initialized with model: {self.model}")
+
+    async def cleanup(self):
+        await super().cleanup()

autobyteus/llm/api/mistral_llm.py

@@ -1,67 +1,18 @@
-from typing import Dict, Optional, List, Any, AsyncGenerator, Union
+from typing import List, Any, AsyncGenerator
 import os
 import logging
 import httpx
-import asyncio
 from autobyteus.llm.models import LLMModel
 from autobyteus.llm.base_llm import BaseLLM
 from mistralai import Mistral
-from autobyteus.llm.utils.messages import Message, MessageRole
+from autobyteus.llm.utils.messages import Message
 from autobyteus.llm.utils.llm_config import LLMConfig
 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, get_mime_type, is_valid_image_path
+from autobyteus.llm.prompt_renderers.mistral_prompt_renderer import MistralPromptRenderer
 
 logger = logging.getLogger(__name__)
 
-async def _format_mistral_messages(messages: List[Message]) -> List[Dict[str, Any]]:
-    """Formats a list of internal Message objects into a list of dictionaries for the Mistral API."""
-    mistral_messages = []
-    for msg in messages:
-        # Skip empty messages from non-system roles as Mistral API may reject them
-        if not msg.content and not msg.image_urls and msg.role != MessageRole.SYSTEM:
-            continue
-
-        content: Union[str, List[Dict[str, Any]]]
-
-        if msg.image_urls:
-            content_parts: List[Dict[str, Any]] = []
-            if msg.content:
-                content_parts.append({"type": "text", "text": msg.content})
-
-            image_tasks = [image_source_to_base64(url) for url in msg.image_urls]
-            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_image_path(original_url) else "image/jpeg"
-                    data_uri = f"data:{mime_type};base64,{b64_image}"
-                    
-                    # Mistral's format for image parts
-                    content_parts.append({
-                        "type": "image_url",
-                        "image_url": {
-                            "url": data_uri
-                        }
-                    })
-            except Exception as e:
-                logger.error(f"Error processing images for Mistral: {e}")
-            
-            if msg.audio_urls:
-                logger.warning("MistralLLM does not yet support audio; skipping.")
-            if msg.video_urls:
-                logger.warning("MistralLLM does not yet support video; skipping.")
-            
-            content = content_parts
-        else:
-            content = msg.content or ""
-        
-        mistral_messages.append({"role": msg.role.value, "content": content})
-            
-    return mistral_messages
-
-
 class MistralLLM(BaseLLM):
     def __init__(self, model: LLMModel = None, llm_config: LLMConfig = None):
         if model is None:
@@ -70,8 +21,12 @@ class MistralLLM(BaseLLM):
             llm_config = LLMConfig()
             
         super().__init__(model=model, llm_config=llm_config)
-        self.http_client = httpx.AsyncClient()
+        # Let the SDK manage its own HTTP client. Passing a raw httpx client
+        # does not satisfy the SDK's HttpClient protocol and raises an
+        # AssertionError during construction (observed in tests). Rely on the
+        # internal client instead.
         self.client: Mistral = self._initialize()
+        self._renderer = MistralPromptRenderer()
         logger.info(f"MistralLLM initialized with model: {self.model}")
 
     def _initialize(self) -> Mistral:
@@ -80,7 +35,7 @@ class MistralLLM(BaseLLM):
             logger.error("MISTRAL_API_KEY environment variable is not set")
             raise ValueError("MISTRAL_API_KEY environment variable is not set.")
         try:
-            return Mistral(api_key=mistral_api_key, client=self.http_client)
+            return Mistral(api_key=mistral_api_key)
         except Exception as e:
             logger.error(f"Failed to initialize Mistral client: {str(e)}")
             raise ValueError(f"Failed to initialize Mistral client: {str(e)}")
@@ -93,13 +48,11 @@ class MistralLLM(BaseLLM):
             total_tokens=usage_data.total_tokens
         )
 
-    async def _send_user_message_to_llm(
-        self, user_message: LLMUserMessage, **kwargs
+    async def _send_messages_to_llm(
+        self, messages: List[Message], **kwargs
     ) -> CompleteResponse:
-        self.add_user_message(user_message)
-        
         try:
-            mistral_messages = await _format_mistral_messages(self.messages)
+            mistral_messages = await self._renderer.render(messages)
             
             chat_response = await self.client.chat.complete_async(
                 model=self.model.value,
@@ -110,7 +63,6 @@ class MistralLLM(BaseLLM):
             )
 
             assistant_message = chat_response.choices[0].message.content
-            self.add_assistant_message(assistant_message)
 
             token_usage = self._create_token_usage(chat_response.usage)
             logger.debug(f"Token usage recorded: {token_usage}")
@@ -123,49 +75,123 @@ class MistralLLM(BaseLLM):
             logger.error(f"Error in Mistral API call: {str(e)}")
             raise ValueError(f"Error in Mistral API call: {str(e)}")
     
-    async def _stream_user_message_to_llm(
-        self, user_message: LLMUserMessage, **kwargs
+    async def _stream_messages_to_llm(
+        self, messages: List[Message], **kwargs
     ) -> AsyncGenerator[ChunkResponse, None]:
-        self.add_user_message(user_message)
-        
         accumulated_message = ""
         final_usage = None
         
         try:
-            mistral_messages = await _format_mistral_messages(self.messages)
-
-            stream = self.client.chat.stream_async(
-                model=self.model.value,
-                messages=mistral_messages,
-                temperature=self.config.temperature,
-                max_tokens=self.config.max_tokens,
-                top_p=self.config.top_p,
-            )
-
-            async for chunk in stream:
-                if chunk.choices and chunk.choices[0].delta.content is not None:
-                    token = chunk.choices[0].delta.content
-                    accumulated_message += token
+            mistral_messages = await self._renderer.render(messages)
+            
+            # Raw HTTP streaming to bypass SDK validation issues with tool calls
+            api_key = os.environ.get("MISTRAL_API_KEY")
+            if not api_key:
+                raise ValueError("MISTRAL_API_KEY not set")
+
+            headers = {
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+                "Accept": "text/event-stream"
+            }
+            
+            payload = {
+                "model": self.model.value,
+                "messages": mistral_messages,
+                "temperature": self.config.temperature,
+                "max_tokens": self.config.max_tokens,
+                "top_p": self.config.top_p,
+                "stream": True
+            }
+            # Filter None values
+            payload = {k: v for k, v in payload.items() if v is not None}
+            
+            if kwargs.get("tools"):
+                payload["tools"] = kwargs.get("tools")
+                payload["tool_choice"] = "auto"
+
+            # Use internal httpx client logic or create new one context
+            async with httpx.AsyncClient() as client:
+                req = client.build_request("POST", "https://api.mistral.ai/v1/chat/completions", headers=headers, json=payload, timeout=60.0)
+                # Do not set stream=True for python client, let it buffer content automatically.
+                # The API will still stream SSE but client reads until close.
+                response = await client.send(req)
+                
+                try:
+                    if response.status_code != 200:
+                        # response.read() is not needed if stream=False, it's already read
+                        error_text = response.text
+                        raise ValueError(f"Mistral API error: {response.status_code} - {error_text}")
+
+                    buffer = ""
+                    # Content is already in response.text
+                    buffer = response.text
                     
-                    yield ChunkResponse(content=token, is_complete=False)
-
-                if hasattr(chunk, 'usage') and chunk.usage:
-                    final_usage = self._create_token_usage(chunk.usage)
-
-            # Yield the final chunk with usage data
+                    # Split buffer into lines and process like stream
+                    lines = buffer.split('\n')
+                    for line in lines:
+                        line = line.strip()
+                        if not line or line == "":
+                            continue
+                        
+                        if line.startswith("data: "):
+                            data_str = line[6:]
+                            if data_str.strip() == "[DONE]":
+                                break
+                            
+                            try:
+                                import json
+                                chunk_data = json.loads(data_str)
+                                
+                                if "choices" in chunk_data and chunk_data["choices"]:
+                                    choice = chunk_data["choices"][0]
+                                    delta = choice.get("delta", {})
+                                    
+                                    if "tool_calls" in delta and delta["tool_calls"]:
+                                        from autobyteus.llm.converters.mistral_tool_call_converter import convert_mistral_tool_calls
+                                        tool_calls = convert_mistral_tool_calls(delta["tool_calls"])
+                                        if tool_calls:
+                                            yield ChunkResponse(
+                                                content="",
+                                                tool_calls=tool_calls,
+                                                is_complete=False
+                                            )
+
+                                    content = delta.get("content")
+                                    if content:
+                                         accumulated_message += content
+                                         yield ChunkResponse(content=content, is_complete=False)
+                                
+                                if chunk_data.get("usage"):
+                                     final_usage_data = chunk_data.get("usage")
+                                     from collections import namedtuple
+                                     UsageObj = namedtuple('UsageObj', ['prompt_tokens', 'completion_tokens', 'total_tokens'])
+                                     usage_obj = UsageObj(
+                                        prompt_tokens=final_usage_data.get('prompt_tokens', 0),
+                                        completion_tokens=final_usage_data.get('completion_tokens', 0),
+                                        total_tokens=final_usage_data.get('total_tokens', 0)
+                                     )
+                                     final_usage = self._create_token_usage(usage_obj)
+
+                            except json.JSONDecodeError:
+                                logger.warning(f"Failed to decode Mistral stream line: {line}")
+                                continue
+                finally:
+                    await response.aclose()
+
+            # Yield the final chunk
             yield ChunkResponse(
                 content="",
                 is_complete=True,
                 usage=final_usage
             )
             
-            self.add_assistant_message(accumulated_message)
         except Exception as e:
             logger.error(f"Error in Mistral API streaming call: {str(e)}")
+            import traceback
+            traceback.print_exc()
             raise ValueError(f"Error in Mistral API streaming call: {str(e)}")
     
     async def cleanup(self):
         logger.debug("Cleaning up MistralLLM instance")
-        if self.http_client and not self.http_client.is_closed:
-            await self.http_client.aclose()
         await super().cleanup()

autobyteus/llm/api/ollama_llm.py

@@ -1,16 +1,13 @@
-from typing import Dict, Optional, List, AsyncGenerator, Any
+from typing import List, AsyncGenerator
 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 Message
+from autobyteus.llm.utils.messages import Message, MessageRole
 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
+from autobyteus.llm.prompt_renderers.ollama_prompt_renderer import OllamaPromptRenderer
 import logging
-import asyncio
 import httpx
 
 logger = logging.getLogger(__name__)
@@ -25,37 +22,12 @@ class OllamaLLM(BaseLLM):
         self.client = AsyncClient(host=model.host_url)
         
         super().__init__(model=model, llm_config=llm_config)
+        self._renderer = OllamaPromptRenderer()
         logger.info(f"OllamaLLM initialized with model: {self.model.model_identifier}")
 
-    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)
-
+    async def _send_messages_to_llm(self, messages: List[Message], **kwargs) -> CompleteResponse:
         try:
-            formatted_messages = await self._format_ollama_messages()
+            formatted_messages = await self._renderer.render(messages)
             response: ChatResponse = await self.client.chat(
                 model=self.model.value,
                 messages=formatted_messages
@@ -71,8 +43,6 @@ class OllamaLLM(BaseLLM):
                     reasoning_content = assistant_message[start_index + len("<think>"):end_index].strip()
                     main_content = (assistant_message[:start_index] + assistant_message[end_index + len("</think>"):])
             
-            self.add_assistant_message(main_content, reasoning_content=reasoning_content)
-            
             token_usage = TokenUsage(
                 prompt_tokens=response.get('prompt_eval_count', 0),
                 completion_tokens=response.get('eval_count', 0),
@@ -94,17 +64,16 @@ class OllamaLLM(BaseLLM):
             logging.error(f"Unexpected error in Ollama call: {e}")
             raise
 
-    async def _stream_user_message_to_llm(
-        self, user_message: LLMUserMessage, **kwargs
+    async def _stream_messages_to_llm(
+        self, messages: List[Message], **kwargs
     ) -> AsyncGenerator[ChunkResponse, None]:
-        self.add_user_message(user_message)
         accumulated_main = ""
         accumulated_reasoning = ""
         in_reasoning = False
         final_response = None
         
         try:
-            formatted_messages = await self._format_ollama_messages()
+            formatted_messages = await self._renderer.render(messages)
             async for part in await self.client.chat(
                 model=self.model.value,
                 messages=formatted_messages,
@@ -141,8 +110,6 @@ class OllamaLLM(BaseLLM):
                 )
 
             yield ChunkResponse(content="", reasoning=None, is_complete=True, usage=token_usage)
-            
-            self.add_assistant_message(accumulated_main, reasoning_content=accumulated_reasoning)
 
         except httpx.HTTPError as e:
             logging.error(f"HTTP Error in Ollama streaming: {e.response.status_code} - {e.response.text}")