mojentic 0.7.4__py3-none-any.whl → 0.8.0__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,80 @@ 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
 
         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 +156,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 +219,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:

mojentic/llm/gateways/openai_model_registry.py

@@ -0,0 +1,327 @@
+"""
+OpenAI Model Registry for managing model-specific configurations and capabilities.
+
+This module provides infrastructure for categorizing OpenAI models and managing
+their specific parameter requirements and capabilities.
+"""
+
+from enum import Enum
+from typing import Dict, Set, Optional, List, TYPE_CHECKING
+from dataclasses import dataclass
+
+import structlog
+
+if TYPE_CHECKING:
+    from mojentic.llm.gateways.openai import OpenAIGateway
+
+logger = structlog.get_logger()
+
+
+class ModelType(Enum):
+    """Classification of OpenAI model types based on their capabilities and parameters."""
+    REASONING = "reasoning"  # Models like o1, o3 that use max_completion_tokens
+    CHAT = "chat"           # Standard chat models that use max_tokens
+    EMBEDDING = "embedding" # Text embedding models
+    MODERATION = "moderation" # Content moderation models
+
+
+@dataclass
+class ModelCapabilities:
+    """Defines the capabilities and parameter requirements for a model."""
+    model_type: ModelType
+    supports_tools: bool = True
+    supports_streaming: bool = True
+    supports_vision: bool = False
+    max_context_tokens: Optional[int] = None
+    max_output_tokens: Optional[int] = None
+
+    def get_token_limit_param(self) -> str:
+        """Get the correct parameter name for token limits based on model type."""
+        if self.model_type == ModelType.REASONING:
+            return "max_completion_tokens"
+        return "max_tokens"
+
+
+class OpenAIModelRegistry:
+    """
+    Registry for managing OpenAI model configurations and capabilities.
+
+    This class provides a centralized way to manage model-specific configurations,
+    parameter mappings, and capabilities for OpenAI models.
+    """
+
+    def __init__(self):
+        self._models: Dict[str, ModelCapabilities] = {}
+        self._pattern_mappings: Dict[str, ModelType] = {}
+        self._initialize_default_models()
+
+    def _initialize_default_models(self):
+        """Initialize the registry with known OpenAI models and their capabilities."""
+
+        # Reasoning Models (o1, o3, o4, gpt-5 series) - Updated 2025-09-28
+        reasoning_models = [
+            "o1", "o1-2024-12-17", "o1-mini", "o1-mini-2024-09-12",
+            "o1-pro", "o1-pro-2025-03-19",
+            "o3", "o3-2025-04-16", "o3-deep-research", "o3-deep-research-2025-06-26",
+            "o3-mini", "o3-mini-2025-01-31", "o3-pro", "o3-pro-2025-06-10",
+            "o4-mini", "o4-mini-2025-04-16", "o4-mini-deep-research",
+            "o4-mini-deep-research-2025-06-26",
+            "gpt-5", "gpt-5-2025-08-07", "gpt-5-chat-latest", "gpt-5-codex",
+            "gpt-5-mini", "gpt-5-mini-2025-08-07", "gpt-5-nano", "gpt-5-nano-2025-08-07"
+        ]
+
+        for model in reasoning_models:
+            # Deep research models and GPT-5 might have different capabilities
+            is_deep_research = "deep-research" in model
+            is_gpt5 = "gpt-5" in model
+            is_mini_or_nano = ("mini" in model or "nano" in model)
+
+            # GPT-5 models may support more features than o1/o3/o4
+            supports_tools = is_gpt5  # GPT-5 might support tools
+            supports_streaming = is_gpt5  # GPT-5 might support streaming
+
+            # Set context and output tokens based on model tier
+            if is_gpt5:
+                context_tokens = 300000 if not is_mini_or_nano else 200000
+                output_tokens = 50000 if not is_mini_or_nano else 32768
+            elif is_deep_research:
+                context_tokens = 200000
+                output_tokens = 100000
+            else:
+                context_tokens = 128000
+                output_tokens = 32768
+
+            self._models[model] = ModelCapabilities(
+                model_type=ModelType.REASONING,
+                supports_tools=supports_tools,
+                supports_streaming=supports_streaming,
+                supports_vision=False,  # Vision support would need to be confirmed for GPT-5
+                max_context_tokens=context_tokens,
+                max_output_tokens=output_tokens
+            )
+
+        # Chat Models (GPT-4 and GPT-4.1 series) - Updated 2025-09-28
+        # Note: GPT-5 series moved to reasoning models
+        gpt4_and_newer_models = [
+            "chatgpt-4o-latest",
+            "gpt-4", "gpt-4-0125-preview", "gpt-4-0613", "gpt-4-1106-preview",
+            "gpt-4-turbo", "gpt-4-turbo-2024-04-09", "gpt-4-turbo-preview",
+            "gpt-4.1", "gpt-4.1-2025-04-14", "gpt-4.1-mini", "gpt-4.1-mini-2025-04-14",
+            "gpt-4.1-nano", "gpt-4.1-nano-2025-04-14",
+            "gpt-4o", "gpt-4o-2024-05-13", "gpt-4o-2024-08-06", "gpt-4o-2024-11-20",
+            "gpt-4o-audio-preview", "gpt-4o-audio-preview-2024-10-01",
+            "gpt-4o-audio-preview-2024-12-17", "gpt-4o-audio-preview-2025-06-03",
+            "gpt-4o-mini", "gpt-4o-mini-2024-07-18",
+            "gpt-4o-mini-audio-preview", "gpt-4o-mini-audio-preview-2024-12-17",
+            "gpt-4o-mini-realtime-preview", "gpt-4o-mini-realtime-preview-2024-12-17",
+            "gpt-4o-mini-search-preview", "gpt-4o-mini-search-preview-2025-03-11",
+            "gpt-4o-mini-transcribe", "gpt-4o-mini-tts",
+            "gpt-4o-realtime-preview", "gpt-4o-realtime-preview-2024-10-01",
+            "gpt-4o-realtime-preview-2024-12-17", "gpt-4o-realtime-preview-2025-06-03",
+            "gpt-4o-search-preview", "gpt-4o-search-preview-2025-03-11",
+            "gpt-4o-transcribe"
+        ]
+
+        for model in gpt4_and_newer_models:
+            # Determine capabilities based on model features
+            vision_support = ("gpt-4o" in model or "audio-preview" in model or "realtime" in model)
+            is_mini_or_nano = ("mini" in model or "nano" in model)
+            is_audio = "audio" in model or "realtime" in model or "transcribe" in model
+            is_gpt41 = "gpt-4.1" in model
+
+            # Set context and output tokens based on model tier
+            if is_gpt41:
+                context_tokens = 200000 if not is_mini_or_nano else 128000
+                output_tokens = 32768 if not is_mini_or_nano else 16384
+            elif "gpt-4o" in model:
+                context_tokens = 128000
+                output_tokens = 16384
+            else:  # GPT-4 series
+                context_tokens = 32000
+                output_tokens = 8192
+
+            self._models[model] = ModelCapabilities(
+                model_type=ModelType.CHAT,
+                supports_tools=True,
+                supports_streaming=not is_audio,  # Audio models may not support streaming
+                supports_vision=vision_support,
+                max_context_tokens=context_tokens,
+                max_output_tokens=output_tokens
+            )
+
+        # Chat Models (GPT-3.5 series) - Updated 2025-09-28
+        gpt35_models = [
+            "gpt-3.5-turbo", "gpt-3.5-turbo-0125", "gpt-3.5-turbo-1106",
+            "gpt-3.5-turbo-16k", "gpt-3.5-turbo-instruct", "gpt-3.5-turbo-instruct-0914"
+        ]
+
+        for model in gpt35_models:
+            context_tokens = 16385 if "16k" not in model else 16385
+            self._models[model] = ModelCapabilities(
+                model_type=ModelType.CHAT,
+                supports_tools="instruct" not in model,  # Instruct models don't support tools
+                supports_streaming="instruct" not in model,  # Instruct models don't support streaming
+                supports_vision=False,
+                max_context_tokens=context_tokens,
+                max_output_tokens=4096
+            )
+
+        # Embedding Models - Updated 2025-09-28
+        embedding_models = [
+            "text-embedding-3-large", "text-embedding-3-small", "text-embedding-ada-002"
+        ]
+
+        for model in embedding_models:
+            self._models[model] = ModelCapabilities(
+                model_type=ModelType.EMBEDDING,
+                supports_tools=False,
+                supports_streaming=False,
+                supports_vision=False
+            )
+
+        # Pattern mappings for unknown models - Updated 2025-09-28
+        self._pattern_mappings = {
+            "o1": ModelType.REASONING,
+            "o3": ModelType.REASONING,
+            "o4": ModelType.REASONING,
+            "gpt-5": ModelType.REASONING,  # GPT-5 is a reasoning model
+            "gpt-4": ModelType.CHAT,
+            "gpt-4.1": ModelType.CHAT,
+            "gpt-3.5": ModelType.CHAT,
+            "chatgpt": ModelType.CHAT,
+            "text-embedding": ModelType.EMBEDDING,
+            "text-moderation": ModelType.MODERATION
+        }
+
+    def get_model_capabilities(self, model_name: str) -> ModelCapabilities:
+        """
+        Get the capabilities for a specific model.
+
+        Parameters
+        ----------
+        model_name : str
+            The name of the model to look up.
+
+        Returns
+        -------
+        ModelCapabilities
+            The capabilities for the model.
+        """
+        # Direct lookup first
+        if model_name in self._models:
+            return self._models[model_name]
+
+        # Pattern matching for unknown models
+        model_lower = model_name.lower()
+        for pattern, model_type in self._pattern_mappings.items():
+            if pattern in model_lower:
+                logger.warning(
+                    "Using pattern matching for unknown model",
+                    model=model_name,
+                    pattern=pattern,
+                    inferred_type=model_type.value
+                )
+                # Return default capabilities for the inferred type
+                return self._get_default_capabilities_for_type(model_type)
+
+        # Default to chat model if no pattern matches
+        logger.warning(
+            "Unknown model, defaulting to chat model capabilities",
+            model=model_name
+        )
+        return self._get_default_capabilities_for_type(ModelType.CHAT)
+
+    def _get_default_capabilities_for_type(self, model_type: ModelType) -> ModelCapabilities:
+        """Get default capabilities for a model type."""
+        if model_type == ModelType.REASONING:
+            return ModelCapabilities(
+                model_type=ModelType.REASONING,
+                supports_tools=False,
+                supports_streaming=False,
+                supports_vision=False
+            )
+        elif model_type == ModelType.CHAT:
+            return ModelCapabilities(
+                model_type=ModelType.CHAT,
+                supports_tools=True,
+                supports_streaming=True,
+                supports_vision=False
+            )
+        elif model_type == ModelType.EMBEDDING:
+            return ModelCapabilities(
+                model_type=ModelType.EMBEDDING,
+                supports_tools=False,
+                supports_streaming=False,
+                supports_vision=False
+            )
+        else:  # MODERATION
+            return ModelCapabilities(
+                model_type=ModelType.MODERATION,
+                supports_tools=False,
+                supports_streaming=False,
+                supports_vision=False
+            )
+
+    def is_reasoning_model(self, model_name: str) -> bool:
+        """
+        Check if a model is a reasoning model.
+
+        Parameters
+        ----------
+        model_name : str
+            The name of the model to check.
+
+        Returns
+        -------
+        bool
+            True if the model is a reasoning model, False otherwise.
+        """
+        capabilities = self.get_model_capabilities(model_name)
+        return capabilities.model_type == ModelType.REASONING
+
+    def get_registered_models(self) -> List[str]:
+        """
+        Get a list of all explicitly registered models.
+
+        Returns
+        -------
+        List[str]
+            List of registered model names.
+        """
+        return list(self._models.keys())
+
+    def register_model(self, model_name: str, capabilities: ModelCapabilities):
+        """
+        Register a new model with its capabilities.
+
+        Parameters
+        ----------
+        model_name : str
+            The name of the model to register.
+        capabilities : ModelCapabilities
+            The capabilities of the model.
+        """
+        self._models[model_name] = capabilities
+        logger.info("Registered new model", model=model_name, type=capabilities.model_type.value)
+
+    def register_pattern(self, pattern: str, model_type: ModelType):
+        """
+        Register a pattern for inferring model types.
+
+        Parameters
+        ----------
+        pattern : str
+            The pattern to match in model names.
+        model_type : ModelType
+            The type to infer for matching models.
+        """
+        self._pattern_mappings[pattern] = model_type
+        logger.info("Registered new pattern", pattern=pattern, type=model_type.value)
+
+
+# Global registry instance
+_registry = OpenAIModelRegistry()
+
+def get_model_registry() -> OpenAIModelRegistry:
+    """Get the global OpenAI model registry instance."""
+    return _registry

mojentic/llm/gateways/openai_model_registry_spec.py

@@ -0,0 +1,181 @@
+"""
+Tests for the OpenAI Model Registry system.
+"""
+
+import pytest
+from mojentic.llm.gateways.openai_model_registry import (
+    OpenAIModelRegistry,
+    ModelType,
+    ModelCapabilities,
+    get_model_registry
+)
+
+
+class DescribeOpenAIModelRegistry:
+    """Specification for the OpenAI Model Registry."""
+
+    def should_initialize_with_default_models(self):
+        """
+        Given a new model registry
+        When initialized
+        Then it should contain default models for all major OpenAI model families
+        """
+        registry = OpenAIModelRegistry()
+        registered_models = registry.get_registered_models()
+
+        # Check that we have reasoning models
+        assert "o1" in registered_models
+        assert "o1-mini" in registered_models
+
+        # Check that we have chat models
+        assert "gpt-4o" in registered_models
+        assert "gpt-4o-mini" in registered_models
+        assert "gpt-3.5-turbo" in registered_models
+
+        # Check that we have embedding models
+        assert "text-embedding-3-large" in registered_models
+        assert "text-embedding-3-small" in registered_models
+
+    def should_identify_reasoning_models_correctly(self):
+        """
+        Given various model names
+        When checking if they are reasoning models
+        Then it should correctly classify known reasoning models
+        """
+        registry = OpenAIModelRegistry()
+
+        # Test known reasoning models
+        assert registry.is_reasoning_model("o1-preview") is True
+        assert registry.is_reasoning_model("o1-mini") is True
+        assert registry.is_reasoning_model("o3-mini") is True
+
+        # Test chat models
+        assert registry.is_reasoning_model("gpt-4o") is False
+        assert registry.is_reasoning_model("gpt-4o-mini") is False
+        assert registry.is_reasoning_model("gpt-3.5-turbo") is False
+
+    def should_use_pattern_matching_for_unknown_models(self):
+        """
+        Given an unknown model name that matches a pattern
+        When getting model capabilities
+        Then it should infer the correct model type
+        """
+        registry = OpenAIModelRegistry()
+
+        # Test unknown reasoning model
+        capabilities = registry.get_model_capabilities("o1-super-new")
+        assert capabilities.model_type == ModelType.REASONING
+        assert capabilities.get_token_limit_param() == "max_completion_tokens"
+
+        # Test unknown chat model
+        capabilities = registry.get_model_capabilities("gpt-4-future")
+        assert capabilities.model_type == ModelType.CHAT
+        assert capabilities.get_token_limit_param() == "max_tokens"
+
+    def should_return_correct_token_limit_parameters(self):
+        """
+        Given models of different types
+        When getting their token limit parameters
+        Then it should return the correct parameter name
+        """
+        registry = OpenAIModelRegistry()
+
+        # Reasoning models should use max_completion_tokens
+        o1_capabilities = registry.get_model_capabilities("o1-mini")
+        assert o1_capabilities.get_token_limit_param() == "max_completion_tokens"
+
+        # Chat models should use max_tokens
+        gpt4_capabilities = registry.get_model_capabilities("gpt-4o")
+        assert gpt4_capabilities.get_token_limit_param() == "max_tokens"
+
+    def should_allow_registering_new_models(self):
+        """
+        Given a new model with specific capabilities
+        When registering it in the registry
+        Then it should be available for lookup
+        """
+        registry = OpenAIModelRegistry()
+
+        new_capabilities = ModelCapabilities(
+            model_type=ModelType.REASONING,
+            supports_tools=True,
+            supports_streaming=True,
+            max_output_tokens=50000
+        )
+
+        registry.register_model("o5-preview", new_capabilities)
+
+        retrieved_capabilities = registry.get_model_capabilities("o5-preview")
+        assert retrieved_capabilities.model_type == ModelType.REASONING
+        assert retrieved_capabilities.supports_tools is True
+        assert retrieved_capabilities.max_output_tokens == 50000
+
+    def should_allow_registering_new_patterns(self):
+        """
+        Given a new pattern for model type inference
+        When registering it in the registry
+        Then it should be used for unknown models matching the pattern
+        """
+        registry = OpenAIModelRegistry()
+
+        registry.register_pattern("claude", ModelType.CHAT)
+
+        capabilities = registry.get_model_capabilities("claude-3-opus")
+        assert capabilities.model_type == ModelType.CHAT
+
+    def should_handle_completely_unknown_models(self):
+        """
+        Given a completely unknown model name with no matching patterns
+        When getting model capabilities
+        Then it should default to chat model capabilities
+        """
+        registry = OpenAIModelRegistry()
+
+        capabilities = registry.get_model_capabilities("completely-unknown-model-xyz")
+        assert capabilities.model_type == ModelType.CHAT
+        assert capabilities.get_token_limit_param() == "max_tokens"
+
+    def should_provide_global_registry_instance(self):
+        """
+        Given the global registry function
+        When called multiple times
+        Then it should return the same instance
+        """
+        registry1 = get_model_registry()
+        registry2 = get_model_registry()
+
+        assert registry1 is registry2
+
+    def should_handle_model_capabilities_dataclass_correctly(self):
+        """
+        Given model capabilities
+        When created with different parameters
+        Then it should handle defaults and customizations correctly
+        """
+        # Test with defaults
+        default_caps = ModelCapabilities(model_type=ModelType.CHAT)
+        assert default_caps.supports_tools is True
+        assert default_caps.supports_streaming is True
+        assert default_caps.supports_vision is False
+
+        # Test with custom values
+        custom_caps = ModelCapabilities(
+            model_type=ModelType.REASONING,
+            supports_tools=False,
+            supports_vision=True,
+            max_context_tokens=100000
+        )
+        assert custom_caps.supports_tools is False
+        assert custom_caps.supports_vision is True
+        assert custom_caps.max_context_tokens == 100000
+
+    def should_have_correct_model_type_enum_values(self):
+        """
+        Given the ModelType enum
+        When accessing its values
+        Then it should have all expected model types
+        """
+        assert ModelType.REASONING.value == "reasoning"
+        assert ModelType.CHAT.value == "chat"
+        assert ModelType.EMBEDDING.value == "embedding"
+        assert ModelType.MODERATION.value == "moderation"

{mojentic-0.7.4.dist-info → mojentic-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mojentic
-Version: 0.7.4
+Version: 0.8.0
 Summary: Mojentic is an agentic framework that aims to provide a simple and flexible way to assemble teams of agents to solve complex problems.
 Author-email: Stacey Vetzal <stacey@vetzal.com>
 Project-URL: Homepage, https://github.com/svetzal/mojentic
@@ -39,7 +39,7 @@ Dynamic: license-file
 
 # Mojentic
 
-Mojentic is a framework that provides a simple and flexible way to interact with Large Language Models (LLMs). It offers integration with various LLM providers and includes tools for structured output generation, task automation, and more. The future direction is to facilitate a team of agents, but the current focus is on robust LLM interaction capabilities.
+Mojentic is a framework that provides a simple and flexible way to interact with Large Language Models (LLMs). It offers integration with various LLM providers and includes tools for structured output generation, task automation, and more. With comprehensive support for all OpenAI models including GPT-5 and automatic parameter adaptation, Mojentic handles the complexities of different model types seamlessly. The future direction is to facilitate a team of agents, but the current focus is on robust LLM interaction capabilities.
 
 [![GitHub](https://img.shields.io/github/license/svetzal/mojentic)](LICENSE.md)
 [![Python Version](https://img.shields.io/badge/python-3.11%2B-blue)](https://www.python.org/downloads/)
@@ -48,6 +48,8 @@ Mojentic is a framework that provides a simple and flexible way to interact with
 ## 🚀 Features
 
 - **LLM Integration**: Support for multiple LLM providers (OpenAI, Ollama)
+- **Latest OpenAI Models**: Full support for GPT-5, GPT-4.1, and all reasoning models (o1, o3, o4 series)
+- **Automatic Model Adaptation**: Seamless parameter handling across different OpenAI model types
 - **Structured Output**: Generate structured data from LLM responses using Pydantic models
 - **Tools Integration**: Utilities for date resolution, image analysis, and more
 - **Multi-modal Capabilities**: Process and analyze images alongside text
@@ -84,8 +86,9 @@ from mojentic.llm.gateways.models import LLMMessage
 from mojentic.llm.tools.date_resolver import ResolveDateTool
 from pydantic import BaseModel, Field
 
-# Initialize with OpenAI
-openai_llm = LLMBroker(model="gpt-4o", gateway=OpenAIGateway(api_key="your_api_key"))
+# Initialize with OpenAI (supports all models including GPT-5, GPT-4.1, reasoning models)
+openai_llm = LLMBroker(model="gpt-5", gateway=OpenAIGateway(api_key="your_api_key"))
+# Or use other models: "gpt-4o", "gpt-4.1", "o1-mini", "o3-mini", etc.
 
 # Or use Ollama for local LLMs
 ollama_llm = LLMBroker(model="llama3")
@@ -99,7 +102,7 @@ class Sentiment(BaseModel):
     label: str = Field(..., description="Label for the sentiment")
 
 sentiment = openai_llm.generate_object(
-    messages=[LLMMessage(content="Hello, how are you?")], 
+    messages=[LLMMessage(content="Hello, how are you?")],
     object_model=Sentiment
 )
 print(sentiment.label)
@@ -118,6 +121,10 @@ result = openai_llm.generate(messages=[
 print(result)
 ```
 
+## 🤖 OpenAI Model Support
+
+The framework automatically handles parameter differences between model types, so you can switch between any models without code changes.
+
 ## 🏗️ Project Structure
 
 ```

{mojentic-0.7.4.dist-info → mojentic-0.8.0.dist-info}/RECORD

@@ -2,7 +2,7 @@ _examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 _examples/async_dispatcher_example.py,sha256=rlaShGpXUsTN7RwVxOo8sbxQjYYJ13gKRB9PWQ3sVTE,8454
 _examples/async_llm_example.py,sha256=IgYBMawHhaKWbA6zkurH-raqBez9nODfjHEAHI7PRek,8708
 _examples/broker_as_tool.py,sha256=QJHryYqIXSUYkK62LhMspbNdK3yL0DoenWHxUK5c_fk,2971
-_examples/broker_examples.py,sha256=7tES2KyKc3uigBuxkwOTf5UGhp7nVeVqLhd8fEHSWEc,1901
+_examples/broker_examples.py,sha256=-fNqOLl4lwja3_sQwVJyT-2Qwy-B0ol9UWs6zSP2QKk,2397
 _examples/broker_image_examples.py,sha256=8dpZ2RFmRYhJqoeWklzlPxmvj9m4M393452SO_D2bJY,1133
 _examples/characterize_ollama.py,sha256=_TzPEAoTuB-saTiaypEQAsUpiBeM37l9I5wCMU3GM4E,2521
 _examples/characterize_openai.py,sha256=JQQNjsHIEegjLAS3uzDmq_Ci_ZqXTqjcoVaC-rS_R_8,564
@@ -14,6 +14,7 @@ _examples/design_analysis.py,sha256=66JxvnA065QV__WXpxJX_eTBDan34nGcKvao75UPLlw,
 _examples/embeddings.py,sha256=94DAMsMB35BU98hOfOeOsbqntcequFSdtaStox2hTvk,267
 _examples/ensures_files_exist.py,sha256=LAwX9YtUZGI6NT254PY7oC5yg6q-b9Q_Dez9gGrabQM,2009
 _examples/ephemeral_task_manager_example.py,sha256=Q1YpLPwDkB-ytIGgCh2eWOr5EJ0FE-osxJ0B0wDlQkY,1491
+_examples/fetch_openai_models.py,sha256=06FrBZfV4FJ7MM9MczbrzFD8wUmXKZOjzPFFxwSVlj4,3545
 _examples/file_deduplication.py,sha256=jYayx4BCrk1uJwVBkjIXzguLQOWLREi4PBPzoK9LuOU,1665
 _examples/file_tool.py,sha256=fUzaIF8qqIy3-E6TJ89jOSD2dwjuO_gBi_1vfCzjuC4,2335
 _examples/image_analysis.py,sha256=Kj49vLQD1DIpvv5P7rir4BqzsVCTgq-tfppqXcYVJkA,503
@@ -22,6 +23,7 @@ _examples/image_broker_splat.py,sha256=O7rzTFUka32if4G4VuXvhu1O-2lRMWfi0r8gjIE8-
 _examples/iterative_solver.py,sha256=ANGdC74ymHosVt6xUBjplkJl_W3ALTGxOkDpPLEDcm8,1331
 _examples/list_models.py,sha256=8noMpGeXOdX5Pf0NXCt_CRurOKEg_5luhWveGntBhe8,578
 _examples/model_characterization.py,sha256=XwLiUP1ZIrNs4ZLmjLDW-nJQsB66H-BV0bWgBgT3N7k,2571
+_examples/openai_gateway_enhanced_demo.py,sha256=vNgJSeQS78PSUibFR9I3WSrBEoSW5qr0dkf2UNlZRdI,5995
 _examples/oversized_embeddings.py,sha256=_z2JoqZn0g7VtRsFVWIkngVqzjhQQvCEUYWVxs1I7MM,284
 _examples/raw.py,sha256=Y2wvgynFuoUs28agE4ijsLYec8VRjiReklqlCH2lERs,442
 _examples/react.py,sha256=VQ-5MmjUXoHzBFPTV_JrocuOkDzZ8oyUUSYLlEToJ_0,939
@@ -84,9 +86,11 @@ mojentic/llm/gateways/models.py,sha256=OyIaMHKrrx6dHo5FbC8qOFct7PRql9wqbe_BJlgDS
 mojentic/llm/gateways/ollama.py,sha256=OUUImBNzPte52Gsf-e7TBjDHRvYW5flU9ddxwG2zlzk,7909
 mojentic/llm/gateways/ollama_messages_adapter.py,sha256=kUN_p2FyN88_trXMcL-Xsn9xPBU7pGKlJwTUEUCf6G4,1404
 mojentic/llm/gateways/ollama_messages_adapter_spec.py,sha256=gVRbWDrHOa1EiZ0CkEWe0pGn-GKRqdGb-x56HBQeYSE,4981
-mojentic/llm/gateways/openai.py,sha256=Wxx_WfG2czOv9Ng8q4JCLFIHGqNs3vaMtE5ggSLBjHk,7787
+mojentic/llm/gateways/openai.py,sha256=42A-8etuDRBSy18q5Qp6S1yndyOJpu3p8Pu0Dd1orFU,12806
 mojentic/llm/gateways/openai_message_adapter_spec.py,sha256=ITBSV5njldV_x0NPgjmg8Okf9KzevQJ8dTXM-t6ubcg,6612
 mojentic/llm/gateways/openai_messages_adapter.py,sha256=Scal68JKKdBHB35ok1c5DeWYdD6Wra5oXSsPxJyyXSQ,3947
+mojentic/llm/gateways/openai_model_registry.py,sha256=4BIWQOl-5yAbug3UHUtpbj3kpkadNoy4sMgThyPi-i8,12858
+mojentic/llm/gateways/openai_model_registry_spec.py,sha256=rCyXhiCOKMewkZjdZoawALoEk62yjENeYTpjYuMuXDM,6711
 mojentic/llm/gateways/tokenizer_gateway.py,sha256=ztuqfunlJ6xmyUPPHcC_69-kegiNJD6jdSEde7hDh2w,485
 mojentic/llm/registry/__init__.py,sha256=P2MHlptrtRPMSWbWl9ojXPmjMwkW0rIn6jwzCkSgnhE,164
 mojentic/llm/registry/llm_registry.py,sha256=beyrgGrkXx5ZckUJzC1nQ461vra0fF6s_qRaEdi5bsg,2508
@@ -132,8 +136,8 @@ mojentic/tracer/tracer_system.py,sha256=7CPy_2tlsHtXQ4DcO5oo52N9a9WS0GH-mjeINzu6
 mojentic/tracer/tracer_system_spec.py,sha256=TNm0f9LV__coBx0JGEKyzzNN9mFjCSG_SSrRISO8Xeg,8632
 mojentic/utils/__init__.py,sha256=lqECkkoFvHFttDnafRE1vvh0Dmna_lwupMToP5VvX5k,115
 mojentic/utils/formatting.py,sha256=bPrwwdluXdQ8TsFxfWtHNOeMWKNvAfABSoUnnA1g7c8,947
-mojentic-0.7.4.dist-info/licenses/LICENSE.md,sha256=txSgV8n5zY1W3NiF5HHsCwlaW0e8We1cSC6TuJUqxXA,1060
-mojentic-0.7.4.dist-info/METADATA,sha256=shFHb00Ezpkzo6QJOp1vAIhXGONL2jFH7pzIJimPBao,5475
-mojentic-0.7.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mojentic-0.7.4.dist-info/top_level.txt,sha256=Q-BvPQ8Eu1jnEqK8Xkr6A9C8Xa1z38oPZRHuA5MCTqg,19
-mojentic-0.7.4.dist-info/RECORD,,
+mojentic-0.8.0.dist-info/licenses/LICENSE.md,sha256=txSgV8n5zY1W3NiF5HHsCwlaW0e8We1cSC6TuJUqxXA,1060
+mojentic-0.8.0.dist-info/METADATA,sha256=EpjGKSzORxFrSG94rw5rUvm4vztoEMfGCTkXON-W49k,6154
+mojentic-0.8.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mojentic-0.8.0.dist-info/top_level.txt,sha256=Q-BvPQ8Eu1jnEqK8Xkr6A9C8Xa1z38oPZRHuA5MCTqg,19
+mojentic-0.8.0.dist-info/RECORD,,