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

autobyteus/llm/base_llm.py

@@ -15,15 +15,6 @@ class BaseLLM(ABC):
     DEFAULT_SYSTEM_MESSAGE = "You are a helpful assistant"
 
     def __init__(self, model: LLMModel, llm_config: LLMConfig):
-        """
-        Base class for all LLMs. Provides core messaging functionality
-        and extension support.
-
-        Args:
-            model (LLMModel): An LLMModel enum value.
-            llm_config (LLMConfig): Configuration for the LLM including system message, 
-                                   rate limits, token limits, etc.
-        """
         if not isinstance(model, LLMModel):
             raise TypeError(f"Expected LLMModel, got {type(model)}")
         if not isinstance(llm_config, LLMConfig):
@@ -33,100 +24,65 @@ class BaseLLM(ABC):
         self.config = llm_config
         self._extension_registry = ExtensionRegistry()
 
-        # Register TokenUsageTrackingExtension by default
         self._token_usage_extension: TokenUsageTrackingExtension = self.register_extension(TokenUsageTrackingExtension)
 
         self.messages: List[Message] = []
-        # Use system_message from config, with fallback to default if not provided
         self.system_message = self.config.system_message or self.DEFAULT_SYSTEM_MESSAGE
         self.add_system_message(self.system_message)
 
     @property
     def latest_token_usage(self):
-        """
-        Get the token usage from the last interaction with the LLM.
-        
-        Returns:
-            The token usage information from the last interaction
-        """
         return self._token_usage_extension.latest_token_usage
 
     def register_extension(self, extension_class: Type[LLMExtension]) -> LLMExtension:
-        """
-        Register a new extension.
-        
-        Args:
-            extension_class: The extension class to instantiate and register
-        
-        Returns:
-            LLMExtension: The instantiated extension
-        """
         extension = extension_class(self)
         self._extension_registry.register(extension)
         return extension
 
     def unregister_extension(self, extension: LLMExtension) -> None:
-        """
-        Unregister an existing extension.
-        
-        Args:
-            extension (LLMExtension): The extension to unregister
-        """
         self._extension_registry.unregister(extension)
 
     def get_extension(self, extension_class: Type[LLMExtension]) -> Optional[LLMExtension]:
-        """
-        Get a registered extension by its class.
-        
-        Args:
-            extension_class: The class of the extension to retrieve
-            
-        Returns:
-            Optional[LLMExtension]: The extension instance if found, None otherwise
-        """
         return self._extension_registry.get(extension_class)
 
     def add_system_message(self, message: str):
-        """
-        Add a system message to the conversation history.
+        self.messages.append(Message(MessageRole.SYSTEM, content=message))
 
-        Args:
-            message (str): The system message content.
+    def add_user_message(self, user_message: LLMUserMessage):
         """
-        self.messages.append(Message(MessageRole.SYSTEM, message))
-
-    def add_user_message(self, user_message: Union[str, List[Dict]]):
+        Adds a user message to history, converting from LLMUserMessage to Message.
         """
-        Add a user message to the conversation history.
-
-        Args:
-            user_message (Union[str, List[Dict]]): The user message content. Can be a simple string
-                                                   or a list of dictionaries for multimodal content.
-        """
-        msg = Message(MessageRole.USER, user_message) 
+        msg = Message(
+            role=MessageRole.USER,
+            content=user_message.content,
+            image_urls=user_message.image_urls,
+            audio_urls=user_message.audio_urls,
+            video_urls=user_message.video_urls
+        )
         self.messages.append(msg)
         self._trigger_on_user_message_added(msg)
 
-    def add_assistant_message(self, message: str, reasoning_content: Optional[str] = None):
-        """
-        Add an assistant message to the conversation history.
-
-        Args:
-            message (str): The assistant message content.
-            reasoning_content (Optional[str]): Optional reasoning content to attach.
-        """
-        msg = Message(MessageRole.ASSISTANT, message, reasoning_content=reasoning_content)
+    def add_assistant_message(self,
+                              content: Optional[str],
+                              reasoning_content: Optional[str] = None,
+                              image_urls: Optional[List[str]] = None,
+                              audio_urls: Optional[List[str]] = None,
+                              video_urls: Optional[List[str]] = None):
+        """
+        Adds a multimodal assistant message to the conversation history.
+        """
+        msg = Message(
+            role=MessageRole.ASSISTANT,
+            content=content,
+            reasoning_content=reasoning_content,
+            image_urls=image_urls,
+            audio_urls=audio_urls,
+            video_urls=video_urls
+        )
         self.messages.append(msg)
         self._trigger_on_assistant_message_added(msg)
 
     def configure_system_prompt(self, new_system_prompt: str):
-        """
-        Updates the system prompt for the LLM instance after initialization.
-        This will replace the existing system message in the conversation history.
-
-        Args:
-            new_system_prompt (str): The new system prompt content.
-        """
         if not new_system_prompt or not isinstance(new_system_prompt, str):
             logging.warning("Attempted to configure an empty or invalid system prompt. No changes made.")
             return
@@ -134,7 +90,6 @@ class BaseLLM(ABC):
         self.system_message = new_system_prompt
         self.config.system_message = new_system_prompt
 
-        # Find and update the existing system message, or add a new one if not found.
         system_message_found = False
         for i, msg in enumerate(self.messages):
             if msg.role == MessageRole.SYSTEM:
@@ -144,113 +99,65 @@ class BaseLLM(ABC):
                 break
         
         if not system_message_found:
-            # If for some reason no system message was there, insert it at the beginning.
             self.messages.insert(0, Message(MessageRole.SYSTEM, new_system_prompt))
             logging.debug("No existing system message found, inserted new one at the beginning.")
         
         logging.info(f"LLM instance system prompt updated. New prompt length: {len(new_system_prompt)}")
 
     def _trigger_on_user_message_added(self, message: Message):
-        """
-        Internal helper to invoke the on_user_message_added hook on every extension.
-
-        Args:
-            message (Message): The user message that was added
-        """
         for extension in self._extension_registry.get_all():
             extension.on_user_message_added(message)
 
     def _trigger_on_assistant_message_added(self, message: Message):
-        """
-        Internal helper to invoke the on_assistant_message_added hook on every extension.
-
-        Args:
-            message (Message): The assistant message that was added
-        """
         for extension in self._extension_registry.get_all():
             extension.on_assistant_message_added(message)
 
     async def _execute_before_hooks(self, user_message: LLMUserMessage, **kwargs) -> None:
-        """
-        Execute all registered before_invoke hooks.
-        """
         for extension in self._extension_registry.get_all():
-            await extension.before_invoke(user_message.content, user_message.image_urls, **kwargs)
+            await extension.before_invoke(user_message, **kwargs)
 
     async def _execute_after_hooks(self, user_message: LLMUserMessage, response: CompleteResponse = None, **kwargs) -> None:
-        """
-        Execute all registered after_invoke hooks.
-        
-        Args:
-            user_message (LLMUserMessage): The user message object
-            response (CompleteResponse): The complete response from the LLM
-            **kwargs: Additional arguments for LLM-specific usage
-        """
         for extension in self._extension_registry.get_all():
-            await extension.after_invoke(user_message.content, user_message.image_urls, response, **kwargs)
+            await extension.after_invoke(user_message, response, **kwargs)
 
     async def send_user_message(self, user_message: LLMUserMessage, **kwargs) -> CompleteResponse:
-        """
-        Sends a user message to the LLM and returns the complete LLM response.
-
-        Args:
-            user_message (LLMUserMessage): The user message object.
-            **kwargs: Additional arguments for LLM-specific usage.
-
-        Returns:
-            CompleteResponse: The complete response from the LLM including content and usage.
-        """
         await self._execute_before_hooks(user_message, **kwargs)
-        response = await self._send_user_message_to_llm(
-            user_message.content, 
-            user_message.image_urls if user_message.image_urls else None, 
-            **kwargs
-        )
+        response = await self._send_user_message_to_llm(user_message, **kwargs)
         await self._execute_after_hooks(user_message, response, **kwargs)
         return response
 
     async def stream_user_message(self, user_message: LLMUserMessage, **kwargs) -> AsyncGenerator[ChunkResponse, None]:
-        """
-        Streams the LLM response as ChunkResponse objects.
-
-        Args:
-            user_message (LLMUserMessage): The user message object.
-            **kwargs: Additional arguments for LLM-specific usage.
-
-        Yields:
-            AsyncGenerator[ChunkResponse, None]: ChunkResponse objects from the LLM.
-        """
         await self._execute_before_hooks(user_message, **kwargs)
 
         accumulated_content = ""
+        accumulated_reasoning = ""
         final_chunk = None
         
-        async for chunk in self._stream_user_message_to_llm(
-            user_message.content, 
-            user_message.image_urls if user_message.image_urls else None, 
-            **kwargs
-        ):
-            accumulated_content += chunk.content
+        async for chunk in self._stream_user_message_to_llm(user_message, **kwargs):
+            if chunk.content:
+                accumulated_content += chunk.content
+            if chunk.reasoning:
+                accumulated_reasoning += chunk.reasoning
+
             if chunk.is_complete:
                 final_chunk = chunk
             yield chunk
 
-        # Create a CompleteResponse from the accumulated content and final chunk's usage
         complete_response = CompleteResponse(
             content=accumulated_content,
+            reasoning=accumulated_reasoning if accumulated_reasoning else None,
             usage=final_chunk.usage if final_chunk else None
         )
         
         await self._execute_after_hooks(user_message, complete_response, **kwargs)
 
     @abstractmethod
-    async def _send_user_message_to_llm(self, user_message: str, image_urls: Optional[List[str]] = None, **kwargs) -> CompleteResponse:
+    async def _send_user_message_to_llm(self, user_message: LLMUserMessage, **kwargs) -> CompleteResponse:
         """
         Abstract method for sending a user message to an LLM. Must be implemented by subclasses.
         
         Args:
-            user_message (str): The user message content.
-            image_urls (Optional[List[str]]): Optional list of image URLs or file paths.
+            user_message (LLMUserMessage): The user message object.
             **kwargs: Additional arguments for LLM-specific usage.
             
         Returns:
@@ -259,13 +166,12 @@ class BaseLLM(ABC):
         pass
 
     @abstractmethod
-    async def _stream_user_message_to_llm(self, user_message: str, image_urls: Optional[List[str]] = None, **kwargs) -> AsyncGenerator[ChunkResponse, None]:
+    async def _stream_user_message_to_llm(self, user_message: LLMUserMessage, **kwargs) -> AsyncGenerator[ChunkResponse, None]:
         """
         Abstract method for streaming a user message response from the LLM. Must be implemented by subclasses.
         
         Args:
-            user_message (str): The user message content.
-            image_urls (Optional[List[str]]): Optional list of image URLs or file paths.
+            user_message (LLMUserMessage): The user message object.
             **kwargs: Additional arguments for LLM-specific usage.
             
         Yields:
@@ -274,9 +180,6 @@ class BaseLLM(ABC):
         pass
 
     async def cleanup(self):
-        """
-        Perform cleanup operations for the LLM and all extensions.
-        """
         for extension in self._extension_registry.get_all():
             await extension.cleanup()
         self._extension_registry.clear()

autobyteus/llm/extensions/base_extension.py

@@ -2,6 +2,7 @@ from abc import ABC, abstractmethod
 from typing import List, Optional, TYPE_CHECKING
 from autobyteus.llm.utils.messages import Message
 from autobyteus.llm.utils.response_types import CompleteResponse
+from autobyteus.llm.user_message import LLMUserMessage
 
 if TYPE_CHECKING:
     from autobyteus.llm.base_llm import BaseLLM
@@ -12,7 +13,7 @@ class LLMExtension(ABC):
 
     @abstractmethod
     async def before_invoke(
-        self, user_message: str, image_urls: Optional[List[str]] = None, **kwargs
+        self, user_message: LLMUserMessage, **kwargs
     ) -> None:
         """
         Called before invoking the LLM with a user message.
@@ -21,16 +22,15 @@ class LLMExtension(ABC):
 
     @abstractmethod
     async def after_invoke(
-        self, user_message: str, image_urls: Optional[List[str]] = None, response: CompleteResponse = None, **kwargs
+        self, user_message: LLMUserMessage, response: CompleteResponse = None, **kwargs
     ) -> None:
         """
         Called after receiving the response from the LLM.
         
         Args:
-            user_message: Original user message
-            image_urls: Optional image URLs used in request
-            response: Complete response including content and usage information
-            kwargs: Additional arguments
+            user_message: The original user message object.
+            response: Complete response including content and usage information.
+            kwargs: Additional arguments.
         """
         pass
 

autobyteus/llm/extensions/token_usage_tracking_extension.py

@@ -6,6 +6,7 @@ from autobyteus.llm.utils.token_usage import TokenUsage
 from autobyteus.llm.utils.token_usage_tracker import TokenUsageTracker
 from autobyteus.llm.utils.messages import Message, MessageRole
 from autobyteus.llm.utils.response_types import CompleteResponse
+from autobyteus.llm.user_message import LLMUserMessage
 
 if TYPE_CHECKING:
     from autobyteus.llm.base_llm import BaseLLM
@@ -29,12 +30,12 @@ class TokenUsageTrackingExtension(LLMExtension):
         return self._latest_usage
 
     async def before_invoke(
-        self, user_message: str, image_urls: Optional[List[str]] = None, **kwargs
+        self, user_message: LLMUserMessage, **kwargs
     ) -> None:
         pass
 
     async def after_invoke(
-        self, user_message: str, image_urls: Optional[List[str]] = None, response: CompleteResponse = None, **kwargs
+        self, user_message: LLMUserMessage, response: CompleteResponse = None, **kwargs
     ) -> None:
         """
         Get the latest usage from tracker and optionally override token counts with provider's usage if available

autobyteus/llm/llm_factory.py

@@ -10,9 +10,11 @@ from autobyteus.llm.utils.llm_config import LLMConfig, TokenPricingConfig
 from autobyteus.llm.base_llm import BaseLLM
 
 from autobyteus.llm.api.claude_llm import ClaudeLLM
+from autobyteus.llm.api.bedrock_llm import BedrockLLM
 from autobyteus.llm.api.mistral_llm import MistralLLM
 from autobyteus.llm.api.openai_llm import OpenAILLM
 from autobyteus.llm.api.deepseek_llm import DeepSeekLLM
+from autobyteus.llm.api.gemini_llm import GeminiLLM
 from autobyteus.llm.api.grok_llm import GrokLLM
 from autobyteus.llm.api.kimi_llm import KimiLLM
 from autobyteus.llm.ollama_provider import OllamaModelProvider
@@ -61,6 +63,83 @@ class LLMFactory(metaclass=SingletonMeta):
                     pricing_config=TokenPricingConfig(2.50, 10.00)
                 )
             ),
+            LLMModel(
+                name="gpt-5",
+                value="gpt-5",
+                provider=LLMProvider.OPENAI,
+                llm_class=OpenAILLM,
+                canonical_name="gpt-5",
+                default_config=LLMConfig(
+                    uses_max_completion_tokens=True,
+                    pricing_config=TokenPricingConfig(1.25, 10.00)
+                )
+            ),
+            LLMModel(
+                name="gpt-5-mini",
+                value="gpt-5-mini",
+                provider=LLMProvider.OPENAI,
+                llm_class=OpenAILLM,
+                canonical_name="gpt-5-mini",
+                default_config=LLMConfig(
+                    uses_max_completion_tokens=True,
+                    pricing_config=TokenPricingConfig(0.25, 2.00)
+                )
+            ),
+            LLMModel(
+                name="gpt-5-nano",
+                value="gpt-5-nano",
+                provider=LLMProvider.OPENAI,
+                llm_class=OpenAILLM,
+                canonical_name="gpt-5-nano",
+                default_config=LLMConfig(
+                    uses_max_completion_tokens=True,
+                    pricing_config=TokenPricingConfig(0.05, 0.40)
+                )
+            ),
+            LLMModel(
+                name="gpt-5-chat-latest",
+                value="gpt-5-chat-latest",
+                provider=LLMProvider.OPENAI,
+                llm_class=OpenAILLM,
+                canonical_name="gpt-5-chat-latest",
+                default_config=LLMConfig(
+                    uses_max_completion_tokens=True,
+                    pricing_config=TokenPricingConfig(1.25, 10.00)
+                )
+            ),
+            LLMModel(
+                name="gpt-4.1",
+                value="gpt-4.1",
+                provider=LLMProvider.OPENAI,
+                llm_class=OpenAILLM,
+                canonical_name="gpt-4.1",
+                default_config=LLMConfig(
+                    uses_max_completion_tokens=True,
+                    pricing_config=TokenPricingConfig(2.00, 8.00)
+                )
+            ),
+            LLMModel(
+                name="gpt-4.1-mini",
+                value="gpt-4.1-mini",
+                provider=LLMProvider.OPENAI,
+                llm_class=OpenAILLM,
+                canonical_name="gpt-4.1-mini",
+                default_config=LLMConfig(
+                    uses_max_completion_tokens=True,
+                    pricing_config=TokenPricingConfig(0.40, 1.60)
+                )
+            ),
+            LLMModel(
+                name="gpt-4.1-nano",
+                value="gpt-4.1-nano",
+                provider=LLMProvider.OPENAI,
+                llm_class=OpenAILLM,
+                canonical_name="gpt-4.1-nano",
+                default_config=LLMConfig(
+                    uses_max_completion_tokens=True,
+                    pricing_config=TokenPricingConfig(0.10, 0.40)
+                )
+            ),
             LLMModel(
                 name="o3",
                 value="o3",
@@ -68,6 +147,7 @@ class LLMFactory(metaclass=SingletonMeta):
                 llm_class=OpenAILLM,
                 canonical_name="o3",
                 default_config=LLMConfig(
+                    uses_max_completion_tokens=True,
                     pricing_config=TokenPricingConfig(15.00, 60.00)
                 )
             ),
@@ -78,6 +158,7 @@ class LLMFactory(metaclass=SingletonMeta):
                 llm_class=OpenAILLM,
                 canonical_name="o4-mini",
                 default_config=LLMConfig(
+                    uses_max_completion_tokens=True,
                     pricing_config=TokenPricingConfig(1.0, 4.00)
                 )
             ),
@@ -104,12 +185,13 @@ class LLMFactory(metaclass=SingletonMeta):
                 )
             ),
             LLMModel(
-                name="bedrock-claude-4-opus",
-                value="anthropic.claude-opus-4-20250514-v1:0",
+                name="claude-4.1-opus",
+                value="claude-opus-4-1-20250805",
                 provider=LLMProvider.ANTHROPIC,
                 llm_class=ClaudeLLM,
-                canonical_name="claude-4-opus",
+                canonical_name="claude-4.1-opus",
                 default_config=LLMConfig(
+                    # NOTE: Pricing is assumed to be the same as claude-4-opus
                     pricing_config=TokenPricingConfig(15.00, 75.00)
                 )
             ),
@@ -123,11 +205,32 @@ class LLMFactory(metaclass=SingletonMeta):
                     pricing_config=TokenPricingConfig(3.00, 15.00)
                 )
             ),
+            LLMModel(
+                name="bedrock-claude-4-opus",
+                value="anthropic.claude-opus-4-20250514-v1:0",
+                provider=LLMProvider.ANTHROPIC,
+                llm_class=BedrockLLM,
+                canonical_name="claude-4-opus",
+                default_config=LLMConfig(
+                    pricing_config=TokenPricingConfig(15.00, 75.00)
+                )
+            ),
+            LLMModel(
+                name="bedrock-claude-4.1-opus",
+                value="anthropic.claude-opus-4-1-20250805-v1:0",
+                provider=LLMProvider.ANTHROPIC,
+                llm_class=BedrockLLM,
+                canonical_name="claude-4.1-opus",
+                default_config=LLMConfig(
+                    # NOTE: Pricing is assumed to be the same as claude-4-opus
+                    pricing_config=TokenPricingConfig(15.00, 75.00)
+                )
+            ),
             LLMModel(
                 name="bedrock-claude-4-sonnet",
                 value="anthropic.claude-sonnet-4-20250514-v1:0",
                 provider=LLMProvider.ANTHROPIC,
-                llm_class=ClaudeLLM,
+                llm_class=BedrockLLM,
                 canonical_name="claude-4-sonnet",
                 default_config=LLMConfig(
                     pricing_config=TokenPricingConfig(3.00, 15.00)
@@ -164,106 +267,73 @@ class LLMFactory(metaclass=SingletonMeta):
                 name="gemini-2.5-pro",
                 value="gemini-2.5-pro",
                 provider=LLMProvider.GEMINI,
-                llm_class=OpenAILLM,
+                llm_class=GeminiLLM,
                 canonical_name="gemini-2.5-pro",
                 default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(2.50, 10.00)
+                    pricing_config=TokenPricingConfig(2.50, 15.00)
                 )
             ),
             LLMModel(
                 name="gemini-2.5-flash",
                 value="gemini-2.5-flash",
                 provider=LLMProvider.GEMINI,
-                llm_class=OpenAILLM,
+                llm_class=GeminiLLM,
                 canonical_name="gemini-2.5-flash",
                 default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(0.15, 0.60)
-                )
-            ),
-            LLMModel(
-                name="gemini-2.0-flash",
-                value="gemini-2.0-flash",
-                provider=LLMProvider.GEMINI,
-                llm_class=OpenAILLM,
-                canonical_name="gemini-2.0-flash",
-                default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(0.1, 0.40)
+                    pricing_config=TokenPricingConfig(0.30, 2.50)
                 )
             ),
             LLMModel(
-                name="gemini-2.0-flash-lite",
-                value="gemini-2.0-flash-lite",
+                name="gemini-2.5-flash-lite",
+                value="gemini-2.5-flash-lite",
                 provider=LLMProvider.GEMINI,
-                llm_class=OpenAILLM,
-                canonical_name="gemini-2.0-flash-lite",
+                llm_class=GeminiLLM,
+                canonical_name="gemini-2.5-flash-lite",
                 default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(0.075, 0.30)
-                )
-            ),
-            # GROK Provider Models
-            LLMModel(
-                name="grok-2-1212",
-                value="grok-2-1212",
-                provider=LLMProvider.GROK,
-                llm_class=GrokLLM,
-                canonical_name="grok-2",
-                default_config=LLMConfig(
-                    rate_limit=60,
-                    token_limit=8000,
-                    pricing_config=TokenPricingConfig(2.0, 6.0)
+                    pricing_config=TokenPricingConfig(0.10, 0.40)
                 )
             ),
             # KIMI Provider Models
             LLMModel(
-                name="kimi-latest",
-                value="kimi-latest",
+                name="kimi-k2-0711-preview",
+                value="kimi-k2-0711-preview",
                 provider=LLMProvider.KIMI,
                 llm_class=KimiLLM,
-                canonical_name="kimi-latest",
+                canonical_name="kimi-k2-0711-preview",
                 default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(1.38, 4.14)
+                    pricing_config=TokenPricingConfig(0.55, 2.21)
                 )
             ),
             LLMModel(
-                name="moonshot-v1-8k",
-                value="moonshot-v1-8k",
+                name="kimi-k2-0905-preview",
+                value="kimi-k2-0905-preview",
                 provider=LLMProvider.KIMI,
                 llm_class=KimiLLM,
-                canonical_name="moonshot-v1-8k",
+                canonical_name="kimi-k2-0905-preview",
                 default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(0.28, 1.38)
+                    pricing_config=TokenPricingConfig(0.55, 2.21)
                 )
             ),
             LLMModel(
-                name="moonshot-v1-32k",
-                value="moonshot-v1-32k",
+                name="kimi-k2-turbo-preview",
+                value="kimi-k2-turbo-preview",
                 provider=LLMProvider.KIMI,
                 llm_class=KimiLLM,
-                canonical_name="moonshot-v1-32k",
+                canonical_name="kimi-k2-turbo-preview",
                 default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(0.69, 2.76)
+                    pricing_config=TokenPricingConfig(2.76, 2.76)
                 )
             ),
             LLMModel(
-                name="moonshot-v1-128k",
-                value="moonshot-v1-128k",
+                name="kimi-latest",
+                value="kimi-latest",
                 provider=LLMProvider.KIMI,
                 llm_class=KimiLLM,
-                canonical_name="moonshot-v1-128k",
+                canonical_name="kimi-latest",
                 default_config=LLMConfig(
                     pricing_config=TokenPricingConfig(1.38, 4.14)
                 )
             ),
-            LLMModel(
-                name="kimi-k2-0711-preview",
-                value="kimi-k2-0711-preview",
-                provider=LLMProvider.KIMI,
-                llm_class=KimiLLM,
-                canonical_name="kimi-k2-0711-preview",
-                default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(0.55, 2.21)
-                )
-            ),
             LLMModel(
                 name="kimi-thinking-preview",
                 value="kimi-thinking-preview",

autobyteus/llm/ollama_provider_resolver.py

@@ -18,6 +18,7 @@ class OllamaProviderResolver:
         (['llama'], LLMProvider.GROQ),
         (['mistral'], LLMProvider.MISTRAL),
         (['deepseek'], LLMProvider.DEEPSEEK),
+        (['qwen'], LLMProvider.QWEN),
     ]
 
     @staticmethod

autobyteus/llm/providers.py

@@ -13,4 +13,5 @@ class LLMProvider(Enum):
     GROK = "GROK"
     AUTOBYTEUS = "AUTOBYTEUS"
     KIMI = "KIMI"
+    QWEN = "QWEN"
     LMSTUDIO = "LMSTUDIO"