mojentic 0.7.2__tar.gz → 0.7.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mojentic
-Version: 0.7.2
+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.2 → mojentic-0.7.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mojentic"
-version = "0.7.2"
+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.2 → mojentic-0.7.4}/src/mojentic/llm/gateways/anthropic.py

@@ -29,7 +29,7 @@ class AnthropicGateway(LLMGateway):
         response = self.client.messages.create(
             **anthropic_args,
             temperature=args.get('temperature', 1.0),
-            max_tokens=args.get('num_predict', 2000),
+            max_tokens=args.get('max_tokens', args.get('num_predict', 2000)),
             # thinking={
             #     "type": "enabled",
             #     "budget_tokens": 32768,

{mojentic-0.7.2 → mojentic-0.7.4}/src/mojentic/llm/gateways/llm_gateway.py

@@ -19,7 +19,7 @@ class LLMGateway:
                  object_model: Optional[Type[BaseModel]] = None,
                  tools: Optional[List[LLMTool]] = None,
                  temperature: float = 1.0,
-                 num_ctx: int = 32768,
+                 num_ctx: int = 32768, max_tokens: int = 16384,
                  num_predict: int = -1) -> LLMGatewayResponse:
         """
         Complete the LLM request.
@@ -39,6 +39,8 @@ class LLMGateway:
             The temperature to use for the response. Defaults to 1.0.
         num_ctx : int
             The number of context tokens to use. Defaults to 32768.
+        max_tokens : int
+            The maximum number of tokens to generate. Defaults to 16384.
         num_predict : int
             The number of tokens to predict. Defaults to no limit.
 

{mojentic-0.7.2 → mojentic-0.7.4}/src/mojentic/llm/gateways/ollama.py

@@ -35,6 +35,8 @@ class OllamaGateway(LLMGateway):
         )
         if args.get('num_predict', 0) > 0:
             options.num_predict = args['num_predict']
+        if 'max_tokens' in args:
+            options.num_predict = args['max_tokens']
         return options
 
     def complete(self, **args) -> LLMGatewayResponse:
@@ -56,6 +58,8 @@ class OllamaGateway(LLMGateway):
             The temperature to use for the response. Defaults to 1.0.
         num_ctx : int, optional
             The number of context tokens to use. Defaults to 32768.
+        max_tokens : int, optional
+            The maximum number of tokens to generate. Defaults to 16384.
         num_predict : int, optional
             The number of tokens to predict. Defaults to no limit.
 
@@ -120,6 +124,8 @@ class OllamaGateway(LLMGateway):
             The temperature to use for the response. Defaults to 1.0.
         num_ctx : int, optional
             The number of context tokens to use. Defaults to 32768.
+        max_tokens : int, optional
+            The maximum number of tokens to generate. Defaults to 16384.
         num_predict : int, optional
             The number of tokens to predict. Defaults to no limit.
 

{mojentic-0.7.2 → 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.
@@ -46,6 +98,8 @@ class OpenAIGateway(LLMGateway):
             The temperature to use for the response. Defaults to 1.0.
         num_ctx : int, optional
             The number of context tokens to use. Defaults to 32768.
+        max_tokens : int, optional
+            The maximum number of tokens to generate. Defaults to 16384.
         num_predict : int, optional
             The number of tokens to predict. Defaults to no limit.
 
@@ -54,19 +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 adapted_args and adapted_args['tools'] is not None:
+            openai_args['tools'] = [t.descriptor for t in adapted_args['tools']]
 
-        if 'tools' in args and args['tools'] is not None:
-            openai_args['tools'] = [t.descriptor for t in args['tools']]
+        # 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.2 → mojentic-0.7.4}/src/mojentic/llm/llm_broker.py

@@ -5,18 +5,19 @@ from typing import List, Optional, Type
 import structlog
 from pydantic import BaseModel
 
-from mojentic.tracer.tracer_system import TracerSystem
 from mojentic.llm.gateways.llm_gateway import LLMGateway
 from mojentic.llm.gateways.models import MessageRole, LLMMessage, LLMGatewayResponse
 from mojentic.llm.gateways.ollama import OllamaGateway
 from mojentic.llm.gateways.tokenizer_gateway import TokenizerGateway
+from mojentic.tracer.tracer_system import TracerSystem
 
 logger = structlog.get_logger()
 
 
 class LLMBroker():
     """
-    This class is responsible for managing interaction with a Large Language Model. It abstracts the user
+    This class is responsible for managing interaction with a Large Language Model. It abstracts
+    the user
     from the specific mechanics of the LLM and provides a common interface for generating responses.
     """
 
@@ -25,7 +26,8 @@ class LLMBroker():
     model: str
     tracer: Optional[TracerSystem]
 
-    def __init__(self, model: str, gateway: Optional[LLMGateway] = None, tokenizer: Optional[TokenizerGateway] = None,
+    def __init__(self, model: str, gateway: Optional[LLMGateway] = None,
+                 tokenizer: Optional[TokenizerGateway] = None,
                  tracer: Optional[TracerSystem] = None):
         """
         Create an instance of the LLMBroker.
@@ -35,10 +37,12 @@ class LLMBroker():
         model
             The name of the model to use.
         gateway
-            The gateway to use for communication with the LLM. If None, a gateway is created that will utilize a local
+            The gateway to use for communication with the LLM. If None, a gateway is created that
+            will utilize a local
             Ollama server.
         tokenizer
-            The gateway to use for tokenization. This is used to log approximate token counts for the LLM calls. If
+            The gateway to use for tokenization. This is used to log approximate token counts for
+            the LLM calls. If
             None, `mxbai-embed-large` is used on a local Ollama server.
         tracer
             Optional tracer system to record LLM calls and responses.
@@ -58,8 +62,9 @@ class LLMBroker():
         else:
             self.adapter = gateway
 
-    def generate(self, messages: List[LLMMessage], tools=None, temperature=1.0, num_ctx=32768, num_predict=-1, 
-              correlation_id: str = None) -> str:
+    def generate(self, messages: List[LLMMessage], tools=None, temperature=1.0, num_ctx=32768,
+                 num_predict=-1, max_tokens=16384,
+                 correlation_id: str = None) -> str:
         """
         Generate a text response from the LLM.
 
@@ -68,7 +73,8 @@ class LLMBroker():
         messages : LLMMessage
             A list of messages to send to the LLM.
         tools : List[Tool]
-            A list of tools to use with the LLM. If a tool call is requested, the tool will be called and the output
+            A list of tools to use with the LLM. If a tool call is requested, the tool will be
+            called and the output
             will be included in the response.
         temperature : float
             The temperature to use for the response. Defaults to 1.0
@@ -91,10 +97,11 @@ class LLMBroker():
         messages_for_tracer = [m.model_dump() for m in messages]
 
         # Record LLM call in tracer
-        tools_for_tracer = [{"name": t.name, "description": t.description} for t in tools] if tools else None
+        tools_for_tracer = [{"name": t.name, "description": t.description} for t in
+                            tools] if tools else None
         self.tracer.record_llm_call(
-            self.model, 
-            messages_for_tracer, 
+            self.model,
+            messages_for_tracer,
             temperature,
             tools=tools_for_tracer,
             source=type(self),
@@ -110,12 +117,14 @@ class LLMBroker():
             tools=tools,
             temperature=temperature,
             num_ctx=num_ctx,
-            num_predict=num_predict)
+            num_predict=num_predict,
+            max_tokens=max_tokens)
 
         call_duration_ms = (time.time() - start_time) * 1000
 
         # Record LLM response in tracer
-        tool_calls_for_tracer = [tc.model_dump() for tc in result.tool_calls] if result.tool_calls else None
+        tool_calls_for_tracer = [tc.model_dump() for tc in
+                                 result.tool_calls] if result.tool_calls else None
         self.tracer.record_llm_response(
             self.model,
             result.content,
@@ -153,13 +162,17 @@ class LLMBroker():
                     logger.info('Function output', output=output)
                     messages.append(LLMMessage(role=MessageRole.Assistant, tool_calls=[tool_call]))
                     messages.append(
-                        LLMMessage(role=MessageRole.Tool, content=json.dumps(output), tool_calls=[tool_call]))
-                    # {'role': 'tool', 'content': str(output), 'name': tool_call.name, 'tool_call_id': tool_call.id})
-                    return self.generate(messages, tools, temperature, num_ctx, num_predict, correlation_id=correlation_id)
+                        LLMMessage(role=MessageRole.Tool, content=json.dumps(output),
+                                   tool_calls=[tool_call]))
+                    # {'role': 'tool', 'content': str(output), 'name': tool_call.name,
+                    # 'tool_call_id': tool_call.id})
+                    return self.generate(messages, tools, temperature, num_ctx, num_predict,
+                                         correlation_id=correlation_id)
                 else:
                     logger.warn('Function not found', function=tool_call.name)
                     logger.info('Expected usage of missing function', expected_usage=tool_call)
-                    # raise Exception('Unknown tool function requested:', requested_tool.function.name)
+                    # raise Exception('Unknown tool function requested:',
+                    # requested_tool.function.name)
 
         return result.content
 
@@ -170,8 +183,9 @@ class LLMBroker():
                 content += message.content
         return content
 
-    def generate_object(self, messages: List[LLMMessage], object_model: Type[BaseModel], temperature=1.0, num_ctx=32768,
-                        num_predict=-1, correlation_id: str = None) -> BaseModel:
+    def generate_object(self, messages: List[LLMMessage], object_model: Type[BaseModel],
+                        temperature=1.0, num_ctx=32768, num_predict=-1, max_tokens=16384,
+                        correlation_id: str = None) -> BaseModel:
         """
         Generate a structured response from the LLM and return it as an object.
 
@@ -203,8 +217,8 @@ class LLMBroker():
 
         # Record LLM call in tracer
         self.tracer.record_llm_call(
-            self.model, 
-            messages_for_tracer, 
+            self.model,
+            messages_for_tracer,
             temperature,
             tools=None,
             source=type(self),
@@ -214,14 +228,18 @@ class LLMBroker():
         # Measure call duration for audit
         start_time = time.time()
 
-        result = self.adapter.complete(model=self.model, messages=messages, object_model=object_model,
-                                       temperature=temperature, num_ctx=num_ctx, num_predict=num_predict)
+        result = self.adapter.complete(model=self.model, messages=messages,
+                                       object_model=object_model,
+                                       temperature=temperature, num_ctx=num_ctx,
+                                       num_predict=num_predict, max_tokens=max_tokens)
 
         call_duration_ms = (time.time() - start_time) * 1000
 
         # Record LLM response in tracer with object representation
         # Convert object to string for tracer
-        object_str = str(result.object.model_dump()) if hasattr(result.object, "model_dump") else str(result.object)
+        object_str = str(result.object.model_dump()) if hasattr(result.object,
+                                                                "model_dump") else str(
+            result.object)
         self.tracer.record_llm_response(
             self.model,
             f"Structured response: {object_str}",

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mojentic
-Version: 0.7.2
+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.2 → 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