mojentic 0.7.4__py3-none-any.whl → 0.8.1__py3-none-any.whl

_examples/broker_examples.py

@@ -14,7 +14,7 @@ from mojentic.llm.gateways.models import LLMMessage
 from mojentic.llm.tools.date_resolver import ResolveDateTool
 
 
-def openai_llm(model="gpt-4o"):
+def openai_llm(model="gpt-5"):
     api_key = os.getenv("OPENAI_API_KEY")
     gateway = OpenAIGateway(api_key)
     llm = LLMBroker(model=model, gateway=gateway)
@@ -60,7 +60,26 @@ check_structured_output(openai_llm(model="o4-mini"))
 check_tool_use(openai_llm(model="o4-mini"))
 check_image_analysis(openai_llm(model="gpt-4o"))
 
-check_simple_textgen(ollama_llm())
-check_structured_output(ollama_llm())
+# check_simple_textgen(ollama_llm())
+# check_structured_output(ollama_llm())
 check_tool_use(ollama_llm(model="qwen3:32b"))
 check_image_analysis(ollama_llm(model="gemma3:27b"))
+
+# Test all GPT-5 model variants to confirm they're all reasoning models
+print("\n=== Testing GPT-5 Model Variants ===")
+gpt5_models = [
+    "gpt-5",
+    "gpt-5-2025-08-07",
+    "gpt-5-chat-latest",
+    "gpt-5-mini",
+    "gpt-5-mini-2025-08-07",
+    "gpt-5-nano",
+    "gpt-5-nano-2025-08-07"
+]
+
+for model in gpt5_models:
+    print(f"\n--- Testing {model} ---")
+    try:
+        check_simple_textgen(openai_llm(model=model))
+    except Exception as e:
+        print(f"Error with {model}: {e}")

_examples/fetch_openai_models.py

@@ -0,0 +1,104 @@
+"""
+Script to fetch current OpenAI models and update the registry with up-to-date model lists.
+"""
+
+import os
+from mojentic.llm.gateways.openai import OpenAIGateway
+
+def fetch_current_openai_models():
+    """Fetch the current list of OpenAI models."""
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        print("ERROR: OPENAI_API_KEY environment variable not set")
+        return None
+
+    try:
+        gateway = OpenAIGateway(api_key)
+        models = gateway.get_available_models()
+        return models
+    except Exception as e:
+        print(f"ERROR: Failed to fetch models from OpenAI API: {e}")
+        return None
+
+def categorize_models(models):
+    """Categorize models by type based on naming patterns."""
+    reasoning_models = []
+    chat_models = []
+    embedding_models = []
+    other_models = []
+
+    for model in models:
+        model_lower = model.lower()
+
+        # Reasoning models: o1, o3, o4, and gpt-5 series
+        if (any(pattern in model_lower for pattern in ['o1-', 'o3-', 'o4-', 'gpt-5']) or
+            model_lower in ['o1', 'o3', 'o4', 'gpt-5']):
+            reasoning_models.append(model)
+        elif 'embedding' in model_lower:
+            embedding_models.append(model)
+        elif any(pattern in model_lower for pattern in ['gpt-4', 'gpt-3.5']):
+            chat_models.append(model)
+        else:
+            other_models.append(model)
+
+    return {
+        'reasoning': sorted(reasoning_models),
+        'chat': sorted(chat_models),
+        'embedding': sorted(embedding_models),
+        'other': sorted(other_models)
+    }
+
+def print_model_lists(categorized_models):
+    """Print the categorized models in a format ready for the registry."""
+    print("=== Current OpenAI Models ===\n")
+
+    print("# Reasoning Models (o1, o3, o4, gpt-5 series)")
+    print("reasoning_models = [")
+    for model in categorized_models['reasoning']:
+        print(f'    "{model}",')
+    print("]\n")
+
+    print("# Chat Models (GPT-4 and GPT-4.1 series)")
+    print("gpt4_and_newer_models = [")
+    gpt4_and_newer = [m for m in categorized_models['chat'] if 'gpt-4' in m.lower()]
+    for model in gpt4_and_newer:
+        print(f'    "{model}",')
+    print("]\n")
+
+    print("# Chat Models (GPT-3.5 series)")
+    print("gpt35_models = [")
+    gpt35 = [m for m in categorized_models['chat'] if 'gpt-3.5' in m.lower()]
+    for model in gpt35:
+        print(f'    "{model}",')
+    print("]\n")
+
+    print("# Embedding Models")
+    print("embedding_models = [")
+    for model in categorized_models['embedding']:
+        print(f'    "{model}",')
+    print("]\n")
+
+    print("# Other Models (for reference)")
+    print("# other_models = [")
+    for model in categorized_models['other']:
+        print(f'#     "{model}",')
+    print("# ]\n")
+
+if __name__ == "__main__":
+    print("Fetching current OpenAI models...")
+    models = fetch_current_openai_models()
+
+    if models:
+        print(f"Found {len(models)} models\n")
+        categorized = categorize_models(models)
+        print_model_lists(categorized)
+
+        print("\n=== Summary ===")
+        print(f"Reasoning models: {len(categorized['reasoning'])}")
+        print(f"Chat models: {len(categorized['chat'])}")
+        print(f"Embedding models: {len(categorized['embedding'])}")
+        print(f"Other models: {len(categorized['other'])}")
+
+        print("\nCopy the model lists above and update the _initialize_default_models() method in openai_model_registry.py")
+    else:
+        print("Failed to fetch models. Please check your API key and try again.")

_examples/openai_gateway_enhanced_demo.py

@@ -0,0 +1,140 @@
+"""
+Demonstration of the enhanced OpenAI gateway with model registry system.
+
+This script shows how the new infrastructure automatically handles parameter adaptation
+for reasoning models vs chat models, provides detailed logging, and offers better
+error handling.
+"""
+
+import os
+from mojentic.llm.gateways.openai import OpenAIGateway
+from mojentic.llm.gateways.openai_model_registry import get_model_registry
+from mojentic.llm.gateways.models import LLMMessage, MessageRole
+
+def demonstrate_model_registry():
+    """Demonstrate the model registry capabilities."""
+    print("=== Model Registry Demonstration ===")
+
+    registry = get_model_registry()
+
+    print("\n1. Registry contains default models:")
+    registered_models = registry.get_registered_models()
+    reasoning_models = [m for m in registered_models if registry.is_reasoning_model(m)]
+    chat_models = [m for m in registered_models if not registry.is_reasoning_model(m) and not m.startswith('text-')]
+
+    print(f"   Reasoning models: {reasoning_models[:3]}...")  # Show first 3
+    print(f"   Chat models: {chat_models[:3]}...")  # Show first 3
+
+    print("\n2. Model capability detection:")
+    for model in ["o1-mini", "gpt-4o"]:
+        capabilities = registry.get_model_capabilities(model)
+        token_param = capabilities.get_token_limit_param()
+        print(f"   {model}: type={capabilities.model_type.value}, token_param={token_param}")
+
+    # Handle unknown model separately to show the warning works
+    print("\n3. Unknown model handling:")
+    print("   unknown-future-model: (will default to chat model with warning)")
+    capabilities = registry.get_model_capabilities("unknown-future-model")
+    token_param = capabilities.get_token_limit_param()
+    print(f"   → Defaulted to: type={capabilities.model_type.value}, token_param={token_param}")
+
+def demonstrate_parameter_adaptation():
+    """Demonstrate parameter adaptation for different model types."""
+    print("\n=== Parameter Adaptation Demonstration ===")
+
+    # This would normally require an API key, but we're just showing the adaptation logic
+    gateway = OpenAIGateway("fake-key-for-demo")
+
+    print("\n1. Reasoning model parameter adaptation (o1-mini):")
+    original_args = {
+        'model': 'o1-mini',
+        'messages': [LLMMessage(role=MessageRole.User, content="Hello")],
+        'max_tokens': 1000,
+        'tools': []  # Tools will be removed for reasoning models
+    }
+
+    adapted_args = gateway._adapt_parameters_for_model('o1-mini', original_args)
+    print(f"   Original: max_tokens={original_args.get('max_tokens')}, has_tools={'tools' in original_args}")
+    print(f"   Adapted: max_completion_tokens={adapted_args.get('max_completion_tokens')}, has_tools={'tools' in adapted_args}")
+
+    print("\n2. Chat model parameter adaptation (gpt-4o):")
+    original_args = {
+        'model': 'gpt-4o',
+        'messages': [LLMMessage(role=MessageRole.User, content="Hello")],
+        'max_tokens': 1000,
+        'tools': []
+    }
+
+    adapted_args = gateway._adapt_parameters_for_model('gpt-4o', original_args)
+    print(f"   Original: max_tokens={original_args.get('max_tokens')}, has_tools={'tools' in original_args}")
+    print(f"   Adapted: max_tokens={adapted_args.get('max_tokens')}, has_tools={'tools' in adapted_args}")
+
+def demonstrate_model_validation():
+    """Demonstrate model parameter validation."""
+    print("\n=== Model Validation Demonstration ===")
+
+    gateway = OpenAIGateway("fake-key-for-demo")
+
+    print("\n1. Validating parameters for reasoning model:")
+    args = {
+        'model': 'o1-mini',
+        'messages': [LLMMessage(role=MessageRole.User, content="Hello")],
+        'max_tokens': 50000,  # High token count - will show warning
+        'tools': []  # Tools for reasoning model - will show warning
+    }
+
+    try:
+        gateway._validate_model_parameters('o1-mini', args)
+        print("   Validation completed (check logs above for warnings)")
+    except Exception as e:
+        print(f"   Validation error: {e}")
+
+def demonstrate_registry_extensibility():
+    """Demonstrate how to extend the registry with new models."""
+    print("\n=== Registry Extensibility Demonstration ===")
+
+    registry = get_model_registry()
+
+    print("\n1. Adding a new model to the registry:")
+    from mojentic.llm.gateways.openai_model_registry import ModelCapabilities, ModelType
+
+    new_capabilities = ModelCapabilities(
+        model_type=ModelType.REASONING,
+        supports_tools=True,  # Hypothetical future reasoning model with tools
+        supports_streaming=True,
+        max_output_tokens=100000
+    )
+
+    registry.register_model("o5-preview", new_capabilities)
+    print(f"   Registered o5-preview as reasoning model")
+
+    # Test the new model
+    capabilities = registry.get_model_capabilities("o5-preview")
+    print(f"   o5-preview: type={capabilities.model_type.value}, supports_tools={capabilities.supports_tools}")
+
+    print("\n2. Adding a new pattern for model detection:")
+    registry.register_pattern("claude", ModelType.CHAT)
+    print("   Registered 'claude' pattern for chat models")
+
+    # Test pattern matching
+    capabilities = registry.get_model_capabilities("claude-3-opus")
+    print(f"   claude-3-opus (inferred): type={capabilities.model_type.value}")
+
+if __name__ == "__main__":
+    print("OpenAI Gateway Enhanced Infrastructure Demo")
+    print("=" * 50)
+
+    demonstrate_model_registry()
+    demonstrate_parameter_adaptation()
+    demonstrate_model_validation()
+    demonstrate_registry_extensibility()
+
+    print("\n" + "=" * 50)
+    print("Demo completed!")
+    print("\nKey Benefits of the New Infrastructure:")
+    print("✓ Registry-based model management (easy to extend)")
+    print("✓ Automatic parameter adaptation (max_tokens ↔ max_completion_tokens)")
+    print("✓ Enhanced logging for debugging")
+    print("✓ Parameter validation with helpful warnings")
+    print("✓ Pattern matching for unknown models")
+    print("✓ Comprehensive test coverage")

mojentic/llm/gateways/openai.py

@@ -1,15 +1,18 @@
 import json
 from itertools import islice
-from typing import Type, List, Iterable
+from typing import Type, List, Iterable, Optional
 
 import numpy as np
 import structlog
-from openai import OpenAI
+from openai import OpenAI, BadRequestError
+from pydantic import BaseModel
 
 from mojentic.llm.gateways.llm_gateway import LLMGateway
-from mojentic.llm.gateways.models import LLMToolCall, LLMGatewayResponse
+from mojentic.llm.gateways.models import LLMToolCall, LLMGatewayResponse, LLMMessage
 from mojentic.llm.gateways.openai_messages_adapter import adapt_messages_to_openai
+from mojentic.llm.gateways.openai_model_registry import get_model_registry, ModelType
 from mojentic.llm.gateways.tokenizer_gateway import TokenizerGateway
+from mojentic.llm.tools.llm_tool import LLMTool
 
 logger = structlog.get_logger()
 
@@ -24,8 +27,9 @@ class OpenAIGateway(LLMGateway):
         The OpenAI API key to use.
     """
 
-    def __init__(self, api_key: str, base_url: str = None):
+    def __init__(self, api_key: str, base_url: Optional[str] = None):
         self.client = OpenAI(api_key=api_key, base_url=base_url)
+        self.model_registry = get_model_registry()
 
     def _is_reasoning_model(self, model: str) -> bool:
         """
@@ -41,21 +45,11 @@ class OpenAIGateway(LLMGateway):
         bool
             True if the model is a reasoning model, False if it's a chat model.
         """
-        # OpenAI reasoning models typically start with "o1" or contain "o4"
-        reasoning_model_patterns = [
-            "o1-",
-            "o3-",
-            "o4-",
-            "o1",
-            "o3"
-        ]
-
-        model_lower = model.lower()
-        return any(pattern in model_lower for pattern in reasoning_model_patterns)
+        return self.model_registry.is_reasoning_model(model)
 
     def _adapt_parameters_for_model(self, model: str, args: dict) -> dict:
         """
-        Adapt parameters based on the model type.
+        Adapt parameters based on the model type and capabilities.
 
         Parameters
         ----------
@@ -70,26 +64,101 @@ class OpenAIGateway(LLMGateway):
             The adapted arguments with correct parameter names for the model type.
         """
         adapted_args = args.copy()
+        capabilities = self.model_registry.get_model_capabilities(model)
 
-        if self._is_reasoning_model(model) and 'max_tokens' in adapted_args:
-            # For reasoning models, use max_completion_tokens instead of max_tokens
-            adapted_args['max_completion_tokens'] = adapted_args.pop('max_tokens')
-            logger.debug("Adapted max_tokens to max_completion_tokens for reasoning model", 
-                        model=model, max_completion_tokens=adapted_args['max_completion_tokens'])
+        logger.debug("Adapting parameters for model",
+                    model=model,
+                    model_type=capabilities.model_type.value,
+                    supports_tools=capabilities.supports_tools,
+                    supports_streaming=capabilities.supports_streaming)
+
+        # Handle token limit parameter conversion
+        if 'max_tokens' in adapted_args:
+            token_param = capabilities.get_token_limit_param()
+            if token_param != 'max_tokens':
+                # Convert max_tokens to max_completion_tokens for reasoning models
+                adapted_args[token_param] = adapted_args.pop('max_tokens')
+                logger.info("Converted token limit parameter for model",
+                           model=model,
+                           from_param='max_tokens',
+                           to_param=token_param,
+                           value=adapted_args[token_param])
+
+        # Validate tool usage for models that don't support tools
+        if 'tools' in adapted_args and adapted_args['tools'] and not capabilities.supports_tools:
+            logger.warning("Model does not support tools, removing tool configuration",
+                          model=model,
+                          num_tools=len(adapted_args['tools']))
+            adapted_args['tools'] = None  # Set to None instead of removing the key
+
+        # Handle temperature restrictions for specific models
+        if 'temperature' in adapted_args:
+            temperature = adapted_args['temperature']
+
+            # Check if model supports temperature parameter at all
+            if capabilities.supported_temperatures == []:
+                # Model doesn't support temperature parameter at all - remove it
+                logger.warning("Model does not support temperature parameter, removing it",
+                              model=model,
+                              requested_temperature=temperature)
+                adapted_args.pop('temperature', None)
+            elif not capabilities.supports_temperature(temperature):
+                # Model supports temperature but not this specific value - use default
+                default_temp = 1.0
+                logger.warning("Model does not support requested temperature, using default",
+                              model=model,
+                              requested_temperature=temperature,
+                              default_temperature=default_temp,
+                              supported_temperatures=capabilities.supported_temperatures)
+                adapted_args['temperature'] = default_temp
 
         return adapted_args
 
-    def complete(self, **args) -> LLMGatewayResponse:
+    def _validate_model_parameters(self, model: str, args: dict) -> None:
+        """
+        Validate that the parameters are compatible with the model.
+
+        Parameters
+        ----------
+        model : str
+            The model name.
+        args : dict
+            The arguments to validate.
+        """
+        capabilities = self.model_registry.get_model_capabilities(model)
+
+        # Warning for tools on reasoning models that don't support them
+        if (capabilities.model_type == ModelType.REASONING and
+            not capabilities.supports_tools and
+            'tools' in args and args['tools']):
+            logger.warning(
+                "Reasoning model may not support tools",
+                model=model,
+                num_tools=len(args['tools'])
+            )
+
+        # Validate token limits (check both possible parameter names)
+        token_value = args.get('max_tokens') or args.get('max_completion_tokens')
+        if token_value and capabilities.max_output_tokens:
+            if token_value > capabilities.max_output_tokens:
+                logger.warning(
+                    "Requested token limit exceeds model maximum",
+                    model=model,
+                    requested=token_value,
+                    max_allowed=capabilities.max_output_tokens
+                )
+
+    def complete(self, **kwargs) -> LLMGatewayResponse:
         """
         Complete the LLM request by delegating to the OpenAI service.
 
         Keyword Arguments
         ----------------
         model : str
-            The name of the model to use, as appears in `ollama list`.
+            The name of the model to use.
         messages : List[LLMMessage]
             A list of messages to send to the LLM.
-        object_model : Optional[BaseModel]
+        object_model : Optional[Type[BaseModel]]
             The model to use for validating the response.
         tools : Optional[List[LLMTool]]
             A list of tools to use with the LLM. If a tool call is requested, the tool will be called and the output
@@ -108,21 +177,61 @@ class OpenAIGateway(LLMGateway):
         LLMGatewayResponse
             The response from the OpenAI service.
         """
+        # Extract parameters from kwargs with defaults
+        model = kwargs.get('model')
+        messages = kwargs.get('messages')
+        object_model = kwargs.get('object_model', None)
+        tools = kwargs.get('tools', None)
+        temperature = kwargs.get('temperature', 1.0)
+        num_ctx = kwargs.get('num_ctx', 32768)
+        max_tokens = kwargs.get('max_tokens', 16384)
+        num_predict = kwargs.get('num_predict', -1)
+
+        if not model:
+            raise ValueError("'model' parameter is required")
+        if not messages:
+            raise ValueError("'messages' parameter is required")
+
+        # Convert parameters to dict for processing
+        args = {
+            'model': model,
+            'messages': messages,
+            'object_model': object_model,
+            'tools': tools,
+            'temperature': temperature,
+            'num_ctx': num_ctx,
+            'max_tokens': max_tokens,
+            'num_predict': num_predict
+        }
+
         # Adapt parameters based on model type
-        adapted_args = self._adapt_parameters_for_model(args['model'], args)
+        try:
+            adapted_args = self._adapt_parameters_for_model(model, args)
+        except Exception as e:
+            logger.error("Failed to adapt parameters for model",
+                        model=model,
+                        error=str(e))
+            raise
+
+        # Validate parameters after adaptation
+        self._validate_model_parameters(model, adapted_args)
 
         openai_args = {
             'model': adapted_args['model'],
             'messages': adapt_messages_to_openai(adapted_args['messages']),
         }
 
+        # Add temperature if specified
+        if 'temperature' in adapted_args:
+            openai_args['temperature'] = adapted_args['temperature']
+
         completion = self.client.chat.completions.create
 
-        if 'object_model' in adapted_args and adapted_args['object_model'] is not None:
+        if adapted_args['object_model'] is not None:
             completion = self.client.beta.chat.completions.parse
             openai_args['response_format'] = adapted_args['object_model']
 
-        if 'tools' in adapted_args and adapted_args['tools'] is not None:
+        if adapted_args.get('tools') is not None:
             openai_args['tools'] = [t.descriptor for t in adapted_args['tools']]
 
         # Handle both max_tokens (for chat models) and max_completion_tokens (for reasoning models)
@@ -131,18 +240,42 @@ class OpenAIGateway(LLMGateway):
         elif 'max_completion_tokens' in adapted_args:
             openai_args['max_completion_tokens'] = adapted_args['max_completion_tokens']
 
-        response = completion(**openai_args)
+        logger.debug("Making OpenAI API call",
+                    model=openai_args['model'],
+                    has_tools='tools' in openai_args,
+                    has_object_model='response_format' in openai_args,
+                    token_param='max_completion_tokens' if 'max_completion_tokens' in openai_args else 'max_tokens')
+
+        try:
+            response = completion(**openai_args)
+        except BadRequestError as e:
+            # Enhanced error handling for parameter issues
+            if "max_tokens" in str(e) and "max_completion_tokens" in str(e):
+                logger.error("Parameter error detected - model may require different token parameter",
+                            model=model,
+                            error=str(e),
+                            suggestion="This model may be a reasoning model requiring max_completion_tokens")
+            raise e
+        except Exception as e:
+            logger.error("OpenAI API call failed",
+                        model=model,
+                        error=str(e))
+            raise e
 
         object = None
         tool_calls: List[LLMToolCall] = []
 
-        if 'object_model' in args and args['object_model'] is not None:
+        if adapted_args.get('object_model') is not None:
             try:
                 response_content = response.choices[0].message.content
-                object = args['object_model'].model_validate_json(response_content)
+                if response_content is not None:
+                    object = adapted_args['object_model'].model_validate_json(response_content)
+                else:
+                    logger.error("No response content available for object validation", object_model=adapted_args['object_model'])
             except Exception as e:
+                response_content = response.choices[0].message.content if response.choices else "No response content"
                 logger.error("Failed to validate model", error=str(e), response=response_content,
-                           object_model=args['object_model'])
+                           object_model=adapted_args['object_model'])
 
         if response.choices[0].message.tool_calls is not None:
             for t in response.choices[0].message.tool_calls: