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

autobyteus/llm/lmstudio_provider.py

@@ -39,6 +39,57 @@ class LMStudioModelProvider:
         except Exception:
             return False
 
+    @staticmethod
+    def get_models() -> List[LLMModel]:
+        """
+        Fetches models from all configured LM Studio instances and returns them as LLMModel objects.
+        """
+        hosts = LMStudioModelProvider._get_hosts()
+        all_models = []
+
+        for host_url in hosts:
+            if not LMStudioModelProvider.is_valid_url(host_url):
+                logger.error(f"Invalid LM Studio host URL: {host_url}, skipping.")
+                continue
+
+            logger.info(f"Discovering LM Studio models from host: {host_url}")
+            base_url = f"{host_url}/v1"
+            client = OpenAI(base_url=base_url, api_key="lm-studio") # Dummy key
+
+            try:
+                response = client.models.list()
+                models = response.data
+            except APIConnectionError:
+                logger.warning(f"Could not connect to LM Studio at {host_url}. Please ensure the server is running.")
+                continue
+            except OpenAIError as e:
+                logger.error(f"An error occurred fetching models from LM Studio at {host_url}: {e}")
+                continue
+
+            for model_info in models:
+                model_id = model_info.id
+                if not model_id:
+                    continue
+                
+                try:
+                    llm_model = LLMModel(
+                        name=model_id,
+                        value=model_id,
+                        provider=LLMProvider.LMSTUDIO, # LMStudio is both provider and runtime
+                        llm_class=LMStudioLLM,
+                        canonical_name=model_id,
+                        runtime=LLMRuntime.LMSTUDIO,
+                        host_url=host_url,
+                        default_config=LLMConfig(
+                            pricing_config=TokenPricingConfig(0.0, 0.0) # Local models are free
+                        )
+                    )
+                    all_models.append(llm_model)
+                except Exception as e:
+                    logger.warning(f"Failed to create LLMModel for '{model_id}' from {host_url}: {e}")
+
+        return all_models
+
     @staticmethod
     def discover_and_register():
         """
@@ -47,58 +98,18 @@ class LMStudioModelProvider:
         try:
             from autobyteus.llm.llm_factory import LLMFactory
             
-            hosts = LMStudioModelProvider._get_hosts()
-            total_registered_count = 0
-
-            for host_url in hosts:
-                if not LMStudioModelProvider.is_valid_url(host_url):
-                    logger.error(f"Invalid LM Studio host URL: {host_url}, skipping.")
-                    continue
-
-                logger.info(f"Discovering LM Studio models from host: {host_url}")
-                base_url = f"{host_url}/v1"
-                client = OpenAI(base_url=base_url, api_key="lm-studio") # Dummy key
+            discovered_models = LMStudioModelProvider.get_models()
+            registered_count = 0
 
+            for model in discovered_models:
                 try:
-                    response = client.models.list()
-                    models = response.data
-                except APIConnectionError:
-                    logger.warning(f"Could not connect to LM Studio at {host_url}. Please ensure the server is running.")
-                    continue
-                except OpenAIError as e:
-                    logger.error(f"An error occurred fetching models from LM Studio at {host_url}: {e}")
-                    continue
-
-                host_registered_count = 0
-                for model_info in models:
-                    model_id = model_info.id
-                    if not model_id:
-                        continue
-                    
-                    try:
-                        llm_model = LLMModel(
-                            name=model_id,
-                            value=model_id,
-                            provider=LLMProvider.LMSTUDIO, # LMStudio is both provider and runtime
-                            llm_class=LMStudioLLM,
-                            canonical_name=model_id,
-                            runtime=LLMRuntime.LMSTUDIO,
-                            host_url=host_url,
-                            default_config=LLMConfig(
-                                pricing_config=TokenPricingConfig(0.0, 0.0) # Local models are free
-                            )
-                        )
-                        LLMFactory.register_model(llm_model)
-                        host_registered_count += 1
-                    except Exception as e:
-                        logger.warning(f"Failed to register LM Studio model '{model_id}' from {host_url}: {e}")
-
-                if host_registered_count > 0:
-                    logger.info(f"Registered {host_registered_count} models from LM Studio host {host_url}")
-                total_registered_count += host_registered_count
+                    LLMFactory.register_model(model)
+                    registered_count += 1
+                except Exception as e:
+                    logger.warning(f"Failed to register LM Studio model '{model.name}': {e}")
 
-            if total_registered_count > 0:
-                logger.info(f"Finished LM Studio discovery. Total models registered: {total_registered_count}")
+            if registered_count > 0:
+                logger.info(f"Finished LM Studio discovery. Total models registered: {registered_count}")
 
         except Exception as e:
             logger.error(f"An unexpected error occurred during LM Studio model discovery: {e}")

autobyteus/llm/models.py

@@ -1,17 +1,19 @@
 import logging
-from typing import TYPE_CHECKING, Type, Optional, List, Iterator
+from typing import TYPE_CHECKING, Type, Optional, List, Iterator, Dict, Any
 from dataclasses import dataclass
 from urllib.parse import urlparse
 
 from autobyteus.llm.providers import LLMProvider
 from autobyteus.llm.runtimes import LLMRuntime
 from autobyteus.llm.utils.llm_config import LLMConfig
+from autobyteus.utils.parameter_schema import ParameterSchema
 
 if TYPE_CHECKING:
     from autobyteus.llm.base_llm import BaseLLM
     from autobyteus.llm.llm_factory import LLMFactory
 
 logger = logging.getLogger(__name__)
+DEFAULT_MAX_CONTEXT_TOKENS = 200000
 
 @dataclass
 class ModelInfo:
@@ -23,6 +25,7 @@ class ModelInfo:
     provider: str
     runtime: str
     host_url: Optional[str] = None
+    config_schema: Optional[Dict[str, Any]] = None  # Serialized ParameterSchema
 
 @dataclass
 class ProviderModelGroup:
@@ -101,7 +104,11 @@ class LLMModel(metaclass=LLMModelMeta):
         canonical_name: str,
         default_config: Optional[LLMConfig] = None,
         runtime: LLMRuntime = LLMRuntime.API,
-        host_url: Optional[str] = None
+        host_url: Optional[str] = None,
+        config_schema: Optional[ParameterSchema] = None,
+        max_context_tokens: Optional[int] = None,
+        default_compaction_ratio: float = 0.8,
+        default_safety_margin_tokens: int = 256,
     ):
         self._name = name
         self._value = value
@@ -109,8 +116,18 @@ class LLMModel(metaclass=LLMModelMeta):
         self.provider = provider
         self.llm_class = llm_class
         self.default_config = default_config if default_config else LLMConfig()
+        if max_context_tokens is None:
+            max_context_tokens = (
+                self.default_config.token_limit
+                if self.default_config.token_limit is not None
+                else DEFAULT_MAX_CONTEXT_TOKENS
+            )
+        self.max_context_tokens = max_context_tokens
+        self.default_compaction_ratio = default_compaction_ratio
+        self.default_safety_margin_tokens = default_safety_margin_tokens
         self.runtime = runtime
         self.host_url = host_url
+        self.config_schema = config_schema
         self._model_identifier = self._generate_identifier()
 
     def _generate_identifier(self) -> str:
@@ -183,6 +200,22 @@ class LLMModel(metaclass=LLMModelMeta):
             
         return self.llm_class(model=self, llm_config=config_to_use)
 
+    def to_model_info(self) -> ModelInfo:
+        """
+        Converts this LLMModel to a ModelInfo data structure for API responses.
+        Serializes the config_schema if present.
+        """
+        return ModelInfo(
+            model_identifier=self.model_identifier,
+            display_name=self.name,
+            value=self.value,
+            canonical_name=self.canonical_name,
+            provider=self.provider.value,
+            runtime=self.runtime.value,
+            host_url=self.host_url,
+            config_schema=self.config_schema.to_dict() if self.config_schema else None
+        )
+
     def __repr__(self):
         return (
             f"LLMModel(identifier='{self.model_identifier}', name='{self.name}', "

autobyteus/llm/ollama_provider.py

@@ -44,6 +44,58 @@ class OllamaModelProvider:
         except Exception:
             return False
 
+    @staticmethod
+    def get_models() -> List[LLMModel]:
+        """
+        Fetches models from all configured Ollama hosts and returns them as LLMModel objects.
+        """
+        hosts = OllamaModelProvider._get_hosts()
+        all_models = []
+
+        for host_url in hosts:
+            if not OllamaModelProvider.is_valid_url(host_url):
+                logger.error(f"Invalid Ollama host URL provided: '{host_url}', skipping.")
+                continue
+            
+            logger.info(f"Discovering Ollama models from host: {host_url}")
+            client = Client(host=host_url)
+            
+            try:
+                response = client.list()
+                models = response.get('models', [])
+            except httpx.ConnectError:
+                logger.warning(f"Could not connect to Ollama server at {host_url}. Please ensure it's running.")
+                continue
+            except Exception as e:
+                logger.error(f"Failed to fetch models from {host_url}: {e}")
+                continue
+
+            for model_info in models:
+                model_name = model_info.get('model')
+                if not model_name:
+                    continue
+
+                try:
+                    provider = OllamaProviderResolver.resolve(model_name)
+                    
+                    llm_model = LLMModel(
+                        name=model_name,
+                        value=model_name,
+                        provider=provider,
+                        llm_class=OllamaLLM,
+                        canonical_name=model_name,
+                        runtime=LLMRuntime.OLLAMA,
+                        host_url=host_url,
+                        default_config=LLMConfig(
+                            pricing_config=TokenPricingConfig(0.0, 0.0) # Local models are free
+                        )
+                    )
+                    all_models.append(llm_model)
+                except Exception as e:
+                    logger.warning(f"Failed to create LLMModel for '{model_name}' from host {host_url}: {e}")
+        
+        return all_models
+
     @staticmethod
     def discover_and_register():
         """
@@ -52,59 +104,18 @@ class OllamaModelProvider:
         try:
             from autobyteus.llm.llm_factory import LLMFactory
 
-            hosts = OllamaModelProvider._get_hosts()
-            total_registered_count = 0
+            discovered_models = OllamaModelProvider.get_models()
+            registered_count = 0
 
-            for host_url in hosts:
-                if not OllamaModelProvider.is_valid_url(host_url):
-                    logger.error(f"Invalid Ollama host URL provided: '{host_url}', skipping.")
-                    continue
-                
-                logger.info(f"Discovering Ollama models from host: {host_url}")
-                client = Client(host=host_url)
-                
+            for model in discovered_models:
                 try:
-                    response = client.list()
-                    models = response.get('models', [])
-                except httpx.ConnectError:
-                    logger.warning(f"Could not connect to Ollama server at {host_url}. Please ensure it's running.")
-                    continue
+                    LLMFactory.register_model(model)
+                    registered_count += 1
                 except Exception as e:
-                    logger.error(f"Failed to fetch models from {host_url}: {e}")
-                    continue
-
-                host_registered_count = 0
-                for model_info in models:
-                    model_name = model_info.get('model')
-                    if not model_name:
-                        continue
-
-                    try:
-                        provider = OllamaProviderResolver.resolve(model_name)
-                        
-                        llm_model = LLMModel(
-                            name=model_name,
-                            value=model_name,
-                            provider=provider,
-                            llm_class=OllamaLLM,
-                            canonical_name=model_name,
-                            runtime=LLMRuntime.OLLAMA,
-                            host_url=host_url,
-                            default_config=LLMConfig(
-                                pricing_config=TokenPricingConfig(0.0, 0.0) # Local models are free
-                            )
-                        )
-                        LLMFactory.register_model(llm_model)
-                        host_registered_count += 1
-                    except Exception as e:
-                        logger.warning(f"Failed to register model '{model_name}' from host {host_url}: {e}")
-                
-                if host_registered_count > 0:
-                    logger.info(f"Registered {host_registered_count} models from Ollama host {host_url}")
-                total_registered_count += host_registered_count
+                    logger.warning(f"Failed to register Ollama model '{model.name}': {e}")
             
-            if total_registered_count > 0:
-                logger.info(f"Finished Ollama discovery. Total models registered: {total_registered_count}")
+            if registered_count > 0:
+                logger.info(f"Finished Ollama discovery. Total models registered: {registered_count}")
 
         except Exception as e:
             logger.error(f"An unexpected error occurred during Ollama model discovery: {e}")

autobyteus/llm/ollama_provider_resolver.py

@@ -15,7 +15,6 @@ class OllamaProviderResolver:
     KEYWORD_PROVIDER_MAP = [
         (['gpt'], LLMProvider.OPENAI),
         (['gemma', 'gemini'], LLMProvider.GEMINI),
-        (['llama'], LLMProvider.GROQ),
         (['mistral'], LLMProvider.MISTRAL),
         (['deepseek'], LLMProvider.DEEPSEEK),
         (['qwen'], LLMProvider.QWEN),

autobyteus/llm/prompt_renderers/__init__.py

@@ -0,0 +1,19 @@
+from autobyteus.llm.prompt_renderers.base_prompt_renderer import BasePromptRenderer
+from autobyteus.llm.prompt_renderers.openai_responses_renderer import OpenAIResponsesRenderer
+from autobyteus.llm.prompt_renderers.openai_chat_renderer import OpenAIChatRenderer
+from autobyteus.llm.prompt_renderers.anthropic_prompt_renderer import AnthropicPromptRenderer
+from autobyteus.llm.prompt_renderers.gemini_prompt_renderer import GeminiPromptRenderer
+from autobyteus.llm.prompt_renderers.mistral_prompt_renderer import MistralPromptRenderer
+from autobyteus.llm.prompt_renderers.ollama_prompt_renderer import OllamaPromptRenderer
+from autobyteus.llm.prompt_renderers.autobyteus_prompt_renderer import AutobyteusPromptRenderer
+
+__all__ = [
+    "BasePromptRenderer",
+    "OpenAIResponsesRenderer",
+    "OpenAIChatRenderer",
+    "AnthropicPromptRenderer",
+    "GeminiPromptRenderer",
+    "MistralPromptRenderer",
+    "OllamaPromptRenderer",
+    "AutobyteusPromptRenderer",
+]

autobyteus/llm/prompt_renderers/anthropic_prompt_renderer.py

@@ -0,0 +1,104 @@
+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,
+    get_mime_type,
+    is_valid_media_path,
+)
+from autobyteus.llm.utils.messages import Message, MessageRole, ToolCallPayload, ToolResultPayload
+
+logger = logging.getLogger(__name__)
+
+
+class AnthropicPromptRenderer(BasePromptRenderer):
+    async def render(self, messages: List[Message]) -> List[Dict[str, Any]]:
+        formatted_messages: List[Dict[str, Any]] = []
+        valid_image_mimes = {"image/jpeg", "image/png", "image/gif", "image/webp"}
+
+        for msg in messages:
+            role = msg.role.value
+            if msg.tool_payload or msg.role == MessageRole.TOOL:
+                payload_text = _format_tool_payload(msg)
+                role = (
+                    MessageRole.USER.value
+                    if msg.role == MessageRole.TOOL
+                    else MessageRole.ASSISTANT.value
+                )
+                msg = Message(
+                    role=MessageRole.USER
+                    if role == MessageRole.USER.value
+                    else MessageRole.ASSISTANT,
+                    content=payload_text or "",
+                )
+
+            if msg.image_urls:
+                content_blocks: List[Dict[str, Any]] = []
+
+                image_tasks = [media_source_to_base64(url) for url in msg.image_urls]
+                try:
+                    base64_images = await asyncio.gather(*image_tasks)
+
+                    for i, b64_data in enumerate(base64_images):
+                        original_url = msg.image_urls[i]
+                        mime_type = get_mime_type(original_url)
+
+                        if mime_type not in valid_image_mimes:
+                            logger.warning(
+                                "Unsupported image MIME type '%s' for %s. "
+                                "Anthropic supports: %s. Defaulting to image/jpeg.",
+                                mime_type,
+                                original_url,
+                                valid_image_mimes,
+                            )
+                            mime_type = "image/jpeg"
+
+                        content_blocks.append(
+                            {
+                                "type": "image",
+                                "source": {
+                                    "type": "base64",
+                                    "media_type": mime_type,
+                                    "data": b64_data,
+                                },
+                            }
+                        )
+                except Exception as e:
+                    logger.error("Error processing images for Claude: %s", e)
+
+                if msg.content:
+                    content_blocks.append({"type": "text", "text": msg.content})
+
+                formatted_messages.append({"role": role, "content": content_blocks})
+            else:
+                formatted_messages.append(
+                    {
+                        "role": role,
+                        "content": msg.content or "",
+                    }
+                )
+
+        return formatted_messages
+
+
+def _format_tool_payload(message: Message) -> str:
+    payload = message.tool_payload
+    if isinstance(payload, ToolCallPayload):
+        lines = []
+        for call in payload.tool_calls:
+            args = call.arguments
+            if isinstance(args, (dict, list)):
+                args = json.dumps(args, ensure_ascii=True)
+            lines.append(f"[TOOL_CALL] {call.name} {args}")
+        return "\n".join(lines)
+    if isinstance(payload, ToolResultPayload):
+        if payload.tool_error:
+            return f"[TOOL_ERROR] {payload.tool_name} {payload.tool_error}"
+        result = payload.tool_result
+        if isinstance(result, (dict, list)):
+            result = json.dumps(result, ensure_ascii=True)
+        return f"[TOOL_RESULT] {payload.tool_name} {result}"
+    return message.content or ""

autobyteus/llm/prompt_renderers/autobyteus_prompt_renderer.py

@@ -0,0 +1,19 @@
+from typing import List, Dict, Any
+
+from autobyteus.llm.prompt_renderers.base_prompt_renderer import BasePromptRenderer
+from autobyteus.llm.utils.messages import Message, MessageRole
+
+
+class AutobyteusPromptRenderer(BasePromptRenderer):
+    async def render(self, messages: List[Message]) -> List[Dict[str, Any]]:
+        for msg in reversed(messages):
+            if msg.role == MessageRole.USER:
+                return [
+                    {
+                        "content": msg.content or "",
+                        "image_urls": list(msg.image_urls),
+                        "audio_urls": list(msg.audio_urls),
+                        "video_urls": list(msg.video_urls),
+                    }
+                ]
+        raise ValueError("AutobyteusPromptRenderer requires at least one user message.")

autobyteus/llm/prompt_renderers/base_prompt_renderer.py

@@ -0,0 +1,10 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any
+
+from autobyteus.llm.utils.messages import Message
+
+
+class BasePromptRenderer(ABC):
+    @abstractmethod
+    async def render(self, messages: List[Message]) -> List[Dict[str, Any]]:
+        raise NotImplementedError

autobyteus/llm/prompt_renderers/gemini_prompt_renderer.py

@@ -0,0 +1,63 @@
+import base64
+import mimetypes
+import logging
+from typing import Dict, List, Any, Optional
+
+from google.genai import types as genai_types
+
+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, get_mime_type
+
+logger = logging.getLogger(__name__)
+
+
+class GeminiPromptRenderer(BasePromptRenderer):
+    async def render(self, messages: List[Message]) -> List[Dict[str, Any]]:
+        history: List[Dict[str, Any]] = []
+        for msg in messages:
+            role = None
+            content_text = msg.content
+            if msg.tool_payload or msg.role == MessageRole.TOOL:
+                content_text = _format_tool_payload(msg)
+                role = "model" if msg.role == MessageRole.ASSISTANT else "user"
+            elif msg.role in (MessageRole.USER, MessageRole.ASSISTANT):
+                role = "model" if msg.role == MessageRole.ASSISTANT else "user"
+            else:
+                continue
+
+            if role is None:
+                continue
+
+            parts: List[Any] = []
+            if content_text:
+                parts.append({"text": content_text})
+
+            media_urls = msg.image_urls + msg.audio_urls + msg.video_urls
+            for url in media_urls:
+                try:
+                    b64_data = await media_source_to_base64(url)
+                    data_bytes = base64.b64decode(b64_data)
+                    mime_type, _ = mimetypes.guess_type(url)
+                    if not mime_type:
+                        mime_type = get_mime_type(url)
+                    parts.append(genai_types.Part.from_bytes(data=data_bytes, mime_type=mime_type))
+                except Exception as exc:
+                    logger.error("Failed to process media content %s: %s", url, exc)
+
+            if parts:
+                history.append({"role": role, "parts": parts})
+
+        return history
+
+
+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/mistral_prompt_renderer.py

@@ -0,0 +1,87 @@
+import asyncio
+import logging
+from typing import Dict, List, Any, Optional, Union
+
+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,
+    get_mime_type,
+    is_valid_media_path,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class MistralPromptRenderer(BasePromptRenderer):
+    async def render(self, messages: List[Message]) -> List[Dict[str, Any]]:
+        mistral_messages: List[Dict[str, Any]] = []
+        for msg in messages:
+            role = msg.role.value
+            if msg.tool_payload or msg.role == MessageRole.TOOL:
+                content_text = _format_tool_payload(msg) or ""
+                role = (
+                    MessageRole.USER.value
+                    if msg.role == MessageRole.TOOL
+                    else MessageRole.ASSISTANT.value
+                )
+                msg = Message(
+                    role=MessageRole.USER
+                    if role == MessageRole.USER.value
+                    else MessageRole.ASSISTANT,
+                    content=content_text,
+                )
+
+            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 = [media_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_media_path(original_url)
+                            else "image/jpeg"
+                        )
+                        data_uri = f"data:{mime_type};base64,{b64_image}"
+                        content_parts.append(
+                            {
+                                "type": "image_url",
+                                "image_url": {"url": data_uri},
+                            }
+                        )
+                except Exception as exc:
+                    logger.error("Error processing images for Mistral: %s", exc)
+
+                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": role, "content": content})
+
+        return mistral_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