mojentic 0.7.3__tar.gz → 0.7.4__tar.gz

{mojentic-0.7.3/src/mojentic.egg-info → mojentic-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mojentic
-Version: 0.7.3
+Version: 0.7.4
 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

{mojentic-0.7.3 → mojentic-0.7.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mojentic"
-version = "0.7.3"
+version = "0.7.4"
 authors = [
     { name = "Stacey Vetzal", email = "stacey@vetzal.com" },
 ]

mojentic-0.7.4/src/_examples/model_characterization.py

@@ -0,0 +1,73 @@
+import os
+from mojentic.llm.gateways.openai import OpenAIGateway
+from mojentic.llm.gateways.models import LLMMessage, MessageRole
+
+def check_model_characterization():
+    """
+    Test the model characterization functionality with different OpenAI models.
+    This demonstrates how the gateway adapts parameters based on model type.
+    """
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        print("OPENAI_API_KEY environment variable not set. Skipping actual API calls.")
+        return
+
+    gateway = OpenAIGateway(api_key)
+
+    # Test messages for chat models
+    chat_messages = [
+        LLMMessage(role=MessageRole.System, content="You are a helpful assistant."),
+        LLMMessage(role=MessageRole.User, content="What is 2 + 2? Give a brief answer.")
+    ]
+
+    # Test messages for reasoning models (no system message supported)
+    reasoning_messages = [
+        LLMMessage(role=MessageRole.User, content="What is 2 + 2? Give a brief answer.")
+    ]
+
+    # Test with different model types
+    test_models = [
+        ("gpt-4o", "chat model"),
+        ("gpt-4o-mini", "chat model"),
+        ("o1-mini", "reasoning model"),
+        ("o1-preview", "reasoning model")
+    ]
+
+    print("Testing model characterization and parameter adaptation:")
+    print("=" * 60)
+
+    for model, model_type in test_models:
+        print(f"\nTesting {model} ({model_type}):")
+
+        # Test model classification
+        is_reasoning = gateway._is_reasoning_model(model)
+        print(f"  Classified as reasoning model: {is_reasoning}")
+
+        # Use appropriate messages based on model type
+        messages = reasoning_messages if gateway._is_reasoning_model(model) else chat_messages
+
+        # Test parameter adaptation
+        original_args = {
+            'model': model,
+            'messages': messages,
+            'max_tokens': 100
+        }
+
+        adapted_args = gateway._adapt_parameters_for_model(model, original_args)
+
+        if 'max_tokens' in adapted_args:
+            print(f"  Using parameter: max_tokens = {adapted_args['max_tokens']}")
+        elif 'max_completion_tokens' in adapted_args:
+            print(f"  Using parameter: max_completion_tokens = {adapted_args['max_completion_tokens']}")
+
+        try:
+            response = gateway.complete(**adapted_args)
+            print(f"  Response: {response.content[:50]}...")
+        except Exception as e:
+            print(f"  Error: {str(e)}")
+
+    print("\n" + "=" * 60)
+    print("Model characterization test completed!")
+
+if __name__ == "__main__":
+    check_model_characterization()

{mojentic-0.7.3 → mojentic-0.7.4}/src/mojentic/llm/gateways/openai.py

@@ -27,6 +27,58 @@ class OpenAIGateway(LLMGateway):
     def __init__(self, api_key: str, base_url: str = None):
         self.client = OpenAI(api_key=api_key, base_url=base_url)
 
+    def _is_reasoning_model(self, model: str) -> bool:
+        """
+        Determine if a model is a reasoning model that requires max_completion_tokens.
+
+        Parameters
+        ----------
+        model : str
+            The model name to classify.
+
+        Returns
+        -------
+        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)
+
+    def _adapt_parameters_for_model(self, model: str, args: dict) -> dict:
+        """
+        Adapt parameters based on the model type.
+
+        Parameters
+        ----------
+        model : str
+            The model name.
+        args : dict
+            The original arguments.
+
+        Returns
+        -------
+        dict
+            The adapted arguments with correct parameter names for the model type.
+        """
+        adapted_args = args.copy()
+
+        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'])
+
+        return adapted_args
+
     def complete(self, **args) -> LLMGatewayResponse:
         """
         Complete the LLM request by delegating to the OpenAI service.
@@ -56,22 +108,28 @@ class OpenAIGateway(LLMGateway):
         LLMGatewayResponse
             The response from the OpenAI service.
         """
+        # Adapt parameters based on model type
+        adapted_args = self._adapt_parameters_for_model(args['model'], args)
+
         openai_args = {
-            'model': args['model'],
-            'messages': adapt_messages_to_openai(args['messages']),
+            'model': adapted_args['model'],
+            'messages': adapt_messages_to_openai(adapted_args['messages']),
         }
 
         completion = self.client.chat.completions.create
 
-        if 'object_model' in args and args['object_model'] is not None:
+        if 'object_model' in adapted_args and adapted_args['object_model'] is not None:
             completion = self.client.beta.chat.completions.parse
-            openai_args['response_format'] = args['object_model']
+            openai_args['response_format'] = adapted_args['object_model']
 
-        if 'tools' in args and args['tools'] is not None:
-            openai_args['tools'] = [t.descriptor for t in args['tools']]
+        if 'tools' in adapted_args and adapted_args['tools'] is not None:
+            openai_args['tools'] = [t.descriptor for t in adapted_args['tools']]
 
-        if 'max_tokens' in args:
-            openai_args['max_tokens'] = args['max_tokens']
+        # Handle both max_tokens (for chat models) and max_completion_tokens (for reasoning models)
+        if 'max_tokens' in adapted_args:
+            openai_args['max_tokens'] = adapted_args['max_tokens']
+        elif 'max_completion_tokens' in adapted_args:
+            openai_args['max_completion_tokens'] = adapted_args['max_completion_tokens']
 
         response = completion(**openai_args)
 

{mojentic-0.7.3 → mojentic-0.7.4/src/mojentic.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mojentic
-Version: 0.7.3
+Version: 0.7.4
 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

{mojentic-0.7.3 → mojentic-0.7.4}/src/mojentic.egg-info/SOURCES.txt

@@ -25,6 +25,7 @@ src/_examples/image_broker.py
 src/_examples/image_broker_splat.py
 src/_examples/iterative_solver.py
 src/_examples/list_models.py
+src/_examples/model_characterization.py
 src/_examples/oversized_embeddings.py
 src/_examples/raw.py
 src/_examples/react.py