autobyteus 1.1.0__py3-none-any.whl → 1.1.2__py3-none-any.whl

autobyteus/llm/api/openai_llm.py

@@ -1,154 +1,26 @@
 import logging
-from typing import Optional, List, AsyncGenerator
-import openai
-from openai.types.completion_usage import CompletionUsage
-from openai.types.chat import ChatCompletionChunk
-import os
+from typing import Optional
 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.image_payload_formatter import process_image
-from autobyteus.llm.utils.token_usage import TokenUsage
-from autobyteus.llm.utils.response_types import CompleteResponse, ChunkResponse
+from autobyteus.llm.api.openai_compatible_llm import OpenAICompatibleLLM
 
 logger = logging.getLogger(__name__)
 
-class OpenAILLM(BaseLLM):
+class OpenAILLM(OpenAICompatibleLLM):
     def __init__(self, model: LLMModel = None, llm_config: LLMConfig = None):
         # Provide defaults if not specified
         if model is None:
-            model = LLMModel.GPT_3_5_TURBO_API
+            model = LLMModel['gpt-4o']  # Use factory access
         if llm_config is None:
             llm_config = LLMConfig()
             
-        super().__init__(model=model, llm_config=llm_config)
-        self.initialize()  # Class method called after super()
-        self.max_tokens = 8000
-        logger.info(f"OpenAILLM initialized with model: {self.model}")
-    
-    @classmethod
-    def initialize(cls):
-        openai_api_key = os.getenv("OPENAI_API_KEY")
-        if not openai_api_key:
-            logger.error("OPENAI_API_KEY environment variable is not set.")
-            raise ValueError("OPENAI_API_KEY environment variable is not set.")
-        openai.api_key = openai_api_key
-        logger.info("OpenAI API key set successfully")
-    
-    def _create_token_usage(self, usage_data: Optional[CompletionUsage]) -> Optional[TokenUsage]:
-        """Convert OpenAI 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,
-            total_tokens=usage_data.total_tokens
+        super().__init__(
+            model=model, 
+            llm_config=llm_config,
+            api_key_env_var="OPENAI_API_KEY",
+            base_url="https://api.openai.com/v1"
         )
-    
-    async def _send_user_message_to_llm(
-        self, user_message: str, image_urls: Optional[List[str]] = None, **kwargs
-    ) -> CompleteResponse:
-        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}")
-
-        try:
-            logger.info("Sending request to OpenAI API")
-            response = openai.chat.completions.create(
-                model=self.model.value,
-                messages=[msg.to_dict() for msg in self.messages],
-                max_tokens=self.max_tokens,
-            )
-            assistant_message = response.choices[0].message.content
-            self.add_assistant_message(assistant_message)
-            
-            token_usage = self._create_token_usage(response.usage)
-            logger.info("Received response from OpenAI API with usage data")
-            
-            return CompleteResponse(
-                content=assistant_message,
-                usage=token_usage
-            )
-        except Exception as e:
-            logger.error(f"Error in OpenAI API request: {str(e)}")
-            raise ValueError(f"Error in OpenAI API request: {str(e)}")
-    
-    async def _stream_user_message_to_llm(
-        self, user_message: str, image_urls: Optional[List[str]] = None, **kwargs
-    ) -> AsyncGenerator[ChunkResponse, None]:
-        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(content)
-        logger.debug(f"Prepared streaming message content: {content}")
-
-        complete_response = ""
-
-        try:
-            logger.info("Starting streaming request to OpenAI API")
-            stream = openai.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}
-            )
-
-            for chunk in stream:
-                chunk: ChatCompletionChunk
-                
-                # Check if this chunk has choices with content
-                if chunk.choices and chunk.choices[0].delta.content is not None:
-                    token = chunk.choices[0].delta.content
-                    complete_response += token
-                    yield ChunkResponse(
-                        content=token,
-                        is_complete=False
-                    )
-                
-                # Handle the final chunk with usage data
-                if hasattr(chunk, 'usage') and chunk.usage is not None:
-                    token_usage = self._create_token_usage(chunk.usage)
-                    # Add the assistant's complete response to the conversation history
-                    self.add_assistant_message(complete_response)
-                    logger.info("Completed streaming response from OpenAI API")
-                    yield ChunkResponse(
-                        content="",
-                        is_complete=True,
-                        usage=token_usage
-                    )
+        logger.info(f"OpenAILLM initialized with model: {self.model}")
 
-        except Exception as e:
-            logger.error(f"Error in OpenAI API streaming: {str(e)}")
-            raise ValueError(f"Error in OpenAI API streaming: {str(e)}")
-    
     async def cleanup(self):
-        super().cleanup()
+        await super().cleanup()

autobyteus/llm/extensions/token_usage_tracking_extension.py

@@ -1,4 +1,5 @@
 from typing import Optional, List, TYPE_CHECKING
+import logging
 from autobyteus.llm.extensions.base_extension import LLMExtension
 from autobyteus.llm.token_counter.token_counter_factory import get_token_counter
 from autobyteus.llm.utils.token_usage import TokenUsage
@@ -9,6 +10,8 @@ from autobyteus.llm.utils.response_types import CompleteResponse
 if TYPE_CHECKING:
     from autobyteus.llm.base_llm import BaseLLM
 
+logger = logging.getLogger(__name__)
+
 class TokenUsageTrackingExtension(LLMExtension):
     """
     Extension that tracks and monitors token usage and associated costs for LLM interactions.
@@ -37,7 +40,14 @@ class TokenUsageTrackingExtension(LLMExtension):
         Get the latest usage from tracker and optionally override token counts with provider's usage if available
         """
         latest_usage = self.usage_tracker.get_latest_usage()
-        
+    
+        if latest_usage is None:
+            logger.warning(
+                "No token usage record found in after_invoke. This may indicate the LLM implementation "
+                "did not call add_user_message. Skipping token usage update for this call."
+            )
+            return
+
         if isinstance(response, CompleteResponse) and response.usage:
             # Override token counts with provider's data if available
             latest_usage.prompt_tokens = response.usage.prompt_tokens

autobyteus/llm/llm_factory.py

@@ -3,7 +3,7 @@ import logging
 import inspect
 
 from autobyteus.llm.autobyteus_provider import AutobyteusModelProvider
-from autobyteus.llm.models import LLMModel
+from autobyteus.llm.models import LLMModel, ModelInfo, ProviderModelGroup
 from autobyteus.llm.providers import LLMProvider
 from autobyteus.llm.utils.llm_config import LLMConfig, TokenPricingConfig
 from autobyteus.llm.base_llm import BaseLLM
@@ -14,6 +14,7 @@ from autobyteus.llm.api.openai_llm import OpenAILLM
 from autobyteus.llm.api.ollama_llm import OllamaLLM
 from autobyteus.llm.api.deepseek_llm import DeepSeekLLM
 from autobyteus.llm.api.grok_llm import GrokLLM
+from autobyteus.llm.api.kimi_llm import KimiLLM
 from autobyteus.llm.ollama_provider import OllamaModelProvider
 from autobyteus.utils.singleton import SingletonMeta
 
@@ -36,21 +37,6 @@ class LLMFactory(metaclass=SingletonMeta):
             LLMFactory._initialize_registry()
             LLMFactory._initialized = True
 
-    @staticmethod
-    def _clear_model_class_attributes():
-        """
-        Clear all LLMModel instances that were set as class attributes on the LLMModel class.
-        This is necessary for reinitialization to avoid 'model already exists' errors.
-        """
-        # Get all attributes of the LLMModel class
-        for attr_name in list(vars(LLMModel).keys()):
-            attr_value = getattr(LLMModel, attr_name)
-            # Check if the attribute is an instance of LLMModel
-            if isinstance(attr_value, LLMModel):
-                logger.debug(f"Removing LLMModel class attribute: {attr_name}")
-                # Delete the attribute to avoid 'model already exists' errors during reinitialization
-                delattr(LLMModel, attr_name)
-
     @staticmethod
     def reinitialize():
         """
@@ -66,9 +52,6 @@ class LLMFactory(metaclass=SingletonMeta):
         try:
             logger.info("Reinitializing LLM model registry...")
             
-            # Clear all LLMModel instances set as class attributes
-            LLMFactory._clear_model_class_attributes()
-            
             # Reset the initialized flag
             LLMFactory._initialized = False
             
@@ -94,7 +77,7 @@ class LLMFactory(metaclass=SingletonMeta):
         supported_models = [
             # OPENAI Provider Models
             LLMModel(
-                name="GPT_4o_API",
+                name="gpt-4o",
                 value="gpt-4o",
                 provider=LLMProvider.OPENAI,
                 llm_class=OpenAILLM,
@@ -106,7 +89,7 @@ class LLMFactory(metaclass=SingletonMeta):
                 )
             ),
             LLMModel(
-                name="o3_API",
+                name="o3",
                 value="o3",
                 provider=LLMProvider.OPENAI,
                 llm_class=OpenAILLM,
@@ -116,7 +99,7 @@ class LLMFactory(metaclass=SingletonMeta):
                 )
             ),
             LLMModel(
-                name="o4_MINI_API",
+                name="o4-mini",
                 value="o4-mini",
                 provider=LLMProvider.OPENAI,
                 llm_class=OpenAILLM,
@@ -127,7 +110,7 @@ class LLMFactory(metaclass=SingletonMeta):
             ),
             # MISTRAL Provider Models
             LLMModel(
-                name="MISTRAL_LARGE_API",
+                name="mistral-large",
                 value="mistral-large-latest",
                 provider=LLMProvider.MISTRAL,
                 llm_class=MistralLLM,
@@ -138,28 +121,48 @@ class LLMFactory(metaclass=SingletonMeta):
             ),
             # ANTHROPIC Provider Models
             LLMModel(
-                name="CLAUDE_3_7_SONNET_API",
-                value="claude-3-7-sonnet-20250219",
+                name="claude-4-opus",
+                value="claude-opus-4-20250514",
+                provider=LLMProvider.ANTHROPIC,
+                llm_class=ClaudeLLM,
+                canonical_name="claude-4-opus",
+                default_config=LLMConfig(
+                    pricing_config=TokenPricingConfig(15.00, 75.00)
+                )
+            ),
+            LLMModel(
+                name="bedrock-claude-4-opus",
+                value="anthropic.claude-opus-4-20250514-v1:0",
+                provider=LLMProvider.ANTHROPIC,
+                llm_class=ClaudeLLM,
+                canonical_name="claude-4-opus",
+                default_config=LLMConfig(
+                    pricing_config=TokenPricingConfig(15.00, 75.00)
+                )
+            ),
+            LLMModel(
+                name="claude-4-sonnet",
+                value="claude-sonnet-4-20250514",
                 provider=LLMProvider.ANTHROPIC,
                 llm_class=ClaudeLLM,
-                canonical_name="claude-3.7",
+                canonical_name="claude-4-sonnet",
                 default_config=LLMConfig(
                     pricing_config=TokenPricingConfig(3.00, 15.00)
                 )
             ),
             LLMModel(
-                name="BEDROCK_CLAUDE_3_7_SONNET_API",
-                value="anthropic.claude-3-7-sonnet-20250219-v1:0",
+                name="bedrock-claude-4-sonnet",
+                value="anthropic.claude-sonnet-4-20250514-v1:0",
                 provider=LLMProvider.ANTHROPIC,
                 llm_class=ClaudeLLM,
-                canonical_name="claude-3.7",
+                canonical_name="claude-4-sonnet",
                 default_config=LLMConfig(
                     pricing_config=TokenPricingConfig(3.00, 15.00)
                 )
             ),
             # DEEPSEEK Provider Models
             LLMModel(
-                name="DEEPSEEK_CHAT_API",
+                name="deepseek-chat",
                 value="deepseek-chat",
                 provider=LLMProvider.DEEPSEEK,
                 llm_class=DeepSeekLLM,
@@ -172,7 +175,7 @@ class LLMFactory(metaclass=SingletonMeta):
             ),
             # Adding deepseek-reasoner support
             LLMModel(
-                name="DEEPSEEK_REASONER_API",
+                name="deepseek-reasoner",
                 value="deepseek-reasoner",
                 provider=LLMProvider.DEEPSEEK,
                 llm_class=DeepSeekLLM,
@@ -185,28 +188,48 @@ class LLMFactory(metaclass=SingletonMeta):
             ),
             # GEMINI Provider Models
             LLMModel(
-                name="GEMINI_1_5_PRO_API",
-                value="gemini-1-5-pro",
+                name="gemini-2.5-pro",
+                value="gemini-2.5-pro",
                 provider=LLMProvider.GEMINI,
                 llm_class=OpenAILLM,
-                canonical_name="gemini-1.5-pro",
+                canonical_name="gemini-2.5-pro",
                 default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(1.25, 5.00)
+                    pricing_config=TokenPricingConfig(2.50, 10.00)
+                )
+            ),
+            LLMModel(
+                name="gemini-2.5-flash",
+                value="gemini-2.5-flash",
+                provider=LLMProvider.GEMINI,
+                llm_class=OpenAILLM,
+                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)
                 )
             ),
             LLMModel(
-                name="GEMINI_1_5_FLASH_API",
-                value="gemini-1-5-flash",
+                name="gemini-2.0-flash-lite",
+                value="gemini-2.0-flash-lite",
                 provider=LLMProvider.GEMINI,
                 llm_class=OpenAILLM,
-                canonical_name="gemini-1.5-flash",
+                canonical_name="gemini-2.0-flash-lite",
                 default_config=LLMConfig(
                     pricing_config=TokenPricingConfig(0.075, 0.30)
                 )
             ),
             # GROK Provider Models
             LLMModel(
-                name="GROK_2_1212_API",
+                name="grok-2-1212",
                 value="grok-2-1212",
                 provider=LLMProvider.GROK,
                 llm_class=GrokLLM,
@@ -217,6 +240,67 @@ class LLMFactory(metaclass=SingletonMeta):
                     pricing_config=TokenPricingConfig(2.0, 6.0)
                 )
             ),
+            # KIMI Provider Models
+            LLMModel(
+                name="kimi-latest",
+                value="kimi-latest",
+                provider=LLMProvider.KIMI,
+                llm_class=KimiLLM,
+                canonical_name="kimi-latest",
+                default_config=LLMConfig(
+                    pricing_config=TokenPricingConfig(1.38, 4.14)
+                )
+            ),
+            LLMModel(
+                name="moonshot-v1-8k",
+                value="moonshot-v1-8k",
+                provider=LLMProvider.KIMI,
+                llm_class=KimiLLM,
+                canonical_name="moonshot-v1-8k",
+                default_config=LLMConfig(
+                    pricing_config=TokenPricingConfig(0.28, 1.38)
+                )
+            ),
+            LLMModel(
+                name="moonshot-v1-32k",
+                value="moonshot-v1-32k",
+                provider=LLMProvider.KIMI,
+                llm_class=KimiLLM,
+                canonical_name="moonshot-v1-32k",
+                default_config=LLMConfig(
+                    pricing_config=TokenPricingConfig(0.69, 2.76)
+                )
+            ),
+            LLMModel(
+                name="moonshot-v1-128k",
+                value="moonshot-v1-128k",
+                provider=LLMProvider.KIMI,
+                llm_class=KimiLLM,
+                canonical_name="moonshot-v1-128k",
+                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",
+                provider=LLMProvider.KIMI,
+                llm_class=KimiLLM,
+                canonical_name="kimi-thinking-preview",
+                default_config=LLMConfig(
+                    pricing_config=TokenPricingConfig(27.59, 27.59)
+                )
+            ),
         ]
         for model in supported_models:
             LLMFactory.register_model(model)
@@ -228,7 +312,18 @@ class LLMFactory(metaclass=SingletonMeta):
     def register_model(model: LLMModel):
         """
         Register a new LLM model, storing it under its provider category.
+        If a model with the same name already exists, it will be replaced.
         """
+        # Using a flat list of all models to check for existing model by name
+        all_models = [m for models in LLMFactory._models_by_provider.values() for m in models]
+        
+        for existing_model in all_models:
+            if existing_model.name == model.name:
+                logger.warning(f"Model with name '{model.name}' is being redefined.")
+                # Remove the old model from its provider list
+                LLMFactory._models_by_provider[existing_model.provider].remove(existing_model)
+                break
+
         models = LLMFactory._models_by_provider.setdefault(model.provider, [])
         models.append(model)
 
@@ -238,7 +333,7 @@ class LLMFactory(metaclass=SingletonMeta):
         Create an LLM instance for the specified model identifier.
         
         Args:
-            model_identifier (str): The model name or value to create an instance for.
+            model_identifier (str): The model name to create an instance for.
             llm_config (Optional[LLMConfig]): Configuration for the LLM. If None,
                                              the model's default configuration is used.
         
@@ -251,7 +346,7 @@ class LLMFactory(metaclass=SingletonMeta):
         LLMFactory.ensure_initialized()
         for models in LLMFactory._models_by_provider.values():
             for model_instance in models:
-                if model_instance.value == model_identifier or model_instance.name == model_identifier:
+                if model_instance.name == model_identifier:
                     return model_instance.create_llm(llm_config)
         raise ValueError(f"Unsupported model: {model_identifier}")
 
@@ -296,7 +391,7 @@ class LLMFactory(metaclass=SingletonMeta):
         Get the canonical name for a model by its name.
         
         Args:
-            model_name (str): The model name (e.g., "GPT_4o_API")
+            model_name (str): The model name (e.g., "gpt_4o")
             
         Returns:
             Optional[str]: The canonical name if found, None otherwise
@@ -308,4 +403,35 @@ class LLMFactory(metaclass=SingletonMeta):
                     return model_instance.canonical_name
         return None
 
+    @staticmethod
+    def get_models_grouped_by_provider() -> List[ProviderModelGroup]:
+        """
+        Returns a list of all providers, each with a list of its available models,
+        sorted by provider name and model name. Providers with no models are included
+        with an empty model list.
+        """
+        LLMFactory.ensure_initialized()
+        result: List[ProviderModelGroup] = []
+        # Sort all providers from the enum by name for consistent order
+        all_providers_sorted = sorted(list(LLMProvider), key=lambda p: p.name)
+        
+        for provider in all_providers_sorted:
+            # Get models for the current provider, defaults to [] if none are registered
+            models = LLMFactory._models_by_provider.get(provider, [])
+            
+            # Sort the models for this provider by name
+            sorted_models = sorted(models, key=lambda model: model.name)
+            
+            model_infos = [
+                ModelInfo(name=model.name, canonical_name=model.canonical_name)
+                for model in sorted_models
+            ]
+            
+            result.append(ProviderModelGroup(
+                provider=provider.name,
+                models=model_infos
+            ))
+            
+        return result
+
 default_llm_factory = LLMFactory()

autobyteus/llm/models.py

@@ -1,5 +1,6 @@
 import logging
 from typing import TYPE_CHECKING, Type, Optional, List, Iterator
+from dataclasses import dataclass
 
 from autobyteus.llm.providers import LLMProvider
 from autobyteus.llm.utils.llm_config import LLMConfig
@@ -10,6 +11,18 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+@dataclass
+class ModelInfo:
+    """A simple data structure for essential model information."""
+    name: str
+    canonical_name: str
+
+@dataclass
+class ProviderModelGroup:
+    """A data structure to group models by their provider."""
+    provider: str
+    models: List[ModelInfo]
+
 class LLMModelMeta(type):
     """
     Metaclass for LLMModel to make it iterable and support item access like Enums.
@@ -24,15 +37,12 @@ class LLMModelMeta(type):
         from autobyteus.llm.llm_factory import LLMFactory
         LLMFactory.ensure_initialized()
 
-        for attr_name in dir(cls):
-            if not attr_name.startswith('_'):  # Skip private/dunder attributes
-                attr_value = getattr(cls, attr_name)
-                if isinstance(attr_value, cls):  # Check if it's an LLMModel instance
-                    yield attr_value
+        for models in LLMFactory._models_by_provider.values():
+            yield from models
 
     def __getitem__(cls, name_or_value: str) -> 'LLMModel':
         """
-        Allows dictionary-like access to LLMModel instances by name (e.g., 'GPT_4o_API')
+        Allows dictionary-like access to LLMModel instances by name (e.g., 'gpt-4o')
         or by value (e.g., 'gpt-4o').
         Search is performed by name first, then by value.
         """
@@ -40,13 +50,12 @@ class LLMModelMeta(type):
         from autobyteus.llm.llm_factory import LLMFactory
         LLMFactory.ensure_initialized()
 
-        # 1. Try to find by name first (e.g., LLMModel['GPT_4o_API'])
-        if hasattr(cls, name_or_value):
-            attribute = getattr(cls, name_or_value)
-            if isinstance(attribute, cls):
-                return attribute
+        # 1. Try to find by name first
+        for model in cls:
+            if model.name == name_or_value:
+                return model
         
-        # 2. If not found by name, iterate and find by value (e.g., LLMModel['gpt-4o'])
+        # 2. If not found by name, iterate and find by value
         for model in cls:
             if model.value == name_or_value:
                 return model
@@ -64,17 +73,14 @@ class LLMModelMeta(type):
         LLMFactory.ensure_initialized()
         
         count = 0
-        for attr_name in dir(cls):
-            if not attr_name.startswith('_'):
-                attr_value = getattr(cls, attr_name)
-                if isinstance(attr_value, cls):
-                    count += 1
+        for models in LLMFactory._models_by_provider.values():
+            count += len(models)
         return count
 
 class LLMModel(metaclass=LLMModelMeta):
     """
     Represents a single model's metadata:
-      - name (str): A human-readable label, e.g. "GPT-4 Official" 
+      - name (str): A human-readable label, e.g. "gpt-4o"
       - value (str): A unique identifier used in code or APIs, e.g. "gpt-4o"
       - canonical_name (str): A shorter, standardized reference name for prompts, e.g. "gpt-4o" or "claude-3.7"
       - provider (LLMProvider): The provider enum 
@@ -94,12 +100,6 @@ class LLMModel(metaclass=LLMModelMeta):
         canonical_name: str,
         default_config: Optional[LLMConfig] = None
     ):
-        # Validate name doesn't already exist as a class attribute
-        if hasattr(LLMModel, name):
-            existing_model = getattr(LLMModel, name)
-            if isinstance(existing_model, LLMModel):
-                logger.warning(f"Model with name '{name}' is being redefined. This is expected during reinitialization.")
-            
         self._name = name
         self._value = value
         self._canonical_name = canonical_name
@@ -107,16 +107,12 @@ class LLMModel(metaclass=LLMModelMeta):
         self.llm_class = llm_class
         self.default_config = default_config if default_config else LLMConfig()
 
-        # Set this instance as a class attribute, making LLMModel.MODEL_NAME available.
-        logger.debug(f"Setting LLMModel class attribute: {name}")
-        setattr(LLMModel, name, self)
-
     @property
     def name(self) -> str:
         """
         A friendly or descriptive name for this model (could appear in UI).
         This is the key used for `LLMModel['MODEL_NAME']` access.
-        Example: "GPT_4o_API"
+        Example: "gpt-4o"
         """
         return self._name