mojentic 0.6.2__py3-none-any.whl → 0.7.1__py3-none-any.whl

mojentic/async_dispatcher.py

@@ -0,0 +1,134 @@
+import asyncio
+import logging
+from collections import deque
+from typing import Optional, Type
+from uuid import uuid4
+
+import structlog
+
+from mojentic.event import TerminateEvent
+
+logger = structlog.get_logger()
+
+
+class AsyncDispatcher:
+    """
+    AsyncDispatcher class is an asynchronous version of the Dispatcher class.
+    It uses asyncio and deque for event processing.
+    """
+    def __init__(self, router, shared_working_memory=None, batch_size=5, tracer=None):
+        """
+        Initialize the AsyncDispatcher.
+
+        Parameters
+        ----------
+        router : Router
+            The router to use for routing events to agents
+        shared_working_memory : SharedWorkingMemory, optional
+            The shared working memory to use
+        batch_size : int, optional
+            The number of events to process in each batch
+        tracer : Tracer, optional
+            The tracer to use for tracing events
+        """
+        self.router = router
+        self.batch_size = batch_size
+        self.event_queue = deque()
+        self._stop_event = asyncio.Event()
+        self._task = None
+
+        # Use null_tracer if no tracer is provided
+        from mojentic.tracer import null_tracer
+        self.tracer = tracer or null_tracer
+
+    async def start(self):
+        """
+        Start the event dispatch task.
+        """
+        logger.debug("Starting event dispatch task")
+        self._task = asyncio.create_task(self._dispatch_events())
+        return self
+
+    async def stop(self):
+        """
+        Stop the event dispatch task.
+        """
+        self._stop_event.set()
+        if self._task:
+            await self._task
+
+    async def wait_for_empty_queue(self, timeout=None):
+        """
+        Wait for the event queue to be empty.
+
+        Parameters
+        ----------
+        timeout : float, optional
+            The timeout in seconds
+
+        Returns
+        -------
+        bool
+            True if the queue is empty, False if the timeout was reached
+        """
+        start_time = asyncio.get_event_loop().time()
+        while len(self.event_queue) > 0:
+            if timeout is not None and asyncio.get_event_loop().time() - start_time > timeout:
+                return False
+            await asyncio.sleep(0.1)
+        return True
+
+    def dispatch(self, event):
+        """
+        Dispatch an event to the event queue.
+
+        Parameters
+        ----------
+        event : Event
+            The event to dispatch
+        """
+        logger.log(logging.DEBUG, f"Dispatching event: {event}")
+        if event.correlation_id is None:
+            event.correlation_id = str(uuid4())
+        self.event_queue.append(event)
+
+    async def _dispatch_events(self):
+        """
+        Dispatch events from the event queue to agents.
+        """
+        while not self._stop_event.is_set():
+            for _ in range(self.batch_size):
+                logger.debug("Checking for events")
+                if len(self.event_queue) > 0:
+                    logger.debug(f"{len(self.event_queue)} events in queue")
+                    event = self.event_queue.popleft()
+                    logger.debug(f"Processing event: {event}")
+                    agents = self.router.get_agents(event)
+                    logger.debug(f"Found {len(agents)} agents for event type {type(event)}")
+                    events = []
+                    for agent in agents:
+                        logger.debug(f"Sending event to agent {agent}")
+
+                        # Record agent interaction in tracer system
+                        self.tracer.record_agent_interaction(
+                            from_agent=str(event.source),
+                            to_agent=str(type(agent)),
+                            event_type=str(type(event).__name__),
+                            event_id=event.correlation_id,
+                            source=type(self)
+                        )
+
+                        # Process the event through the agent
+                        # If the agent is an async agent, await its receive_event method
+                        if hasattr(agent, 'receive_event_async'):
+                            received_events = await agent.receive_event_async(event)
+                        else:
+                            received_events = agent.receive_event(event)
+
+                        logger.debug(f"Agent {agent} returned {len(received_events)} events")
+                        events.extend(received_events)
+                    for fe in events:
+                        if type(fe) is TerminateEvent:
+                            self._stop_event.set()
+                        self.dispatch(fe)
+            await asyncio.sleep(0.1)  # Use asyncio.sleep instead of time.sleep

mojentic/async_dispatcher_spec.py

@@ -0,0 +1,244 @@
+import asyncio
+import pytest
+import pytest_asyncio
+from unittest.mock import AsyncMock, MagicMock
+
+from mojentic.async_dispatcher import AsyncDispatcher
+from mojentic.event import Event, TerminateEvent
+from mojentic.agents.base_async_agent import BaseAsyncAgent
+from mojentic.router import Router
+
+
+class SampleEvent(Event):
+    """A simple event for testing."""
+    message: str
+
+
+class SampleResponseEvent(Event):
+    """A response event for testing."""
+    response: str
+
+
+class AsyncTestAgent(BaseAsyncAgent):
+    """A test async agent that returns a SampleResponseEvent."""
+
+    async def receive_event_async(self, event):
+        if isinstance(event, SampleEvent):
+            return [SampleResponseEvent(
+                source=type(self),
+                correlation_id=event.correlation_id,
+                response=f"Processed: {event.message}"
+            )]
+        return []
+
+
+class SyncTestAgent:
+    """A test sync agent that returns a SampleResponseEvent."""
+
+    def __init__(self):
+        # Create a mock for tracking calls
+        self._mock = MagicMock()
+
+    def receive_event(self, event):
+        # Track the call
+        self._mock(event)
+
+        if isinstance(event, SampleEvent):
+            return [SampleResponseEvent(
+                source=type(self),
+                correlation_id=event.correlation_id,
+                response=f"Processed sync: {event.message}"
+            )]
+        return []
+
+    def assert_called_once(self):
+        # Delegate to the mock
+        self._mock.assert_called_once()
+
+
+@pytest.fixture
+def router():
+    """Create a router for testing."""
+    return Router()
+
+
+@pytest.fixture
+def async_agent():
+    """Create an async agent for testing."""
+    return AsyncTestAgent()
+
+
+@pytest.fixture
+def sync_agent():
+    """Create a sync agent for testing."""
+    return SyncTestAgent()
+
+
+@pytest_asyncio.fixture
+async def dispatcher(router):
+    """Create and start an AsyncDispatcher for testing."""
+    dispatcher = AsyncDispatcher(router)
+    await dispatcher.start()
+    yield dispatcher
+    await dispatcher.stop()
+
+
+@pytest.mark.asyncio
+async def test_async_dispatcher_init(router):
+    """Test that the AsyncDispatcher initializes correctly."""
+    dispatcher = AsyncDispatcher(router)
+
+    assert dispatcher.router == router
+    assert dispatcher.batch_size == 5
+    assert len(dispatcher.event_queue) == 0
+    assert dispatcher._task is None
+
+
+@pytest.mark.asyncio
+async def test_async_dispatcher_start_stop(router):
+    """Test that the AsyncDispatcher starts and stops correctly."""
+    dispatcher = AsyncDispatcher(router)
+
+    # Start the dispatcher
+    await dispatcher.start()
+    assert dispatcher._task is not None
+    assert not dispatcher._stop_event.is_set()
+
+    # Stop the dispatcher
+    await dispatcher.stop()
+    assert dispatcher._stop_event.is_set()
+
+
+@pytest.mark.asyncio
+async def test_async_dispatcher_dispatch(dispatcher, router, async_agent):
+    """Test that the AsyncDispatcher dispatches events correctly."""
+    # Register the agent
+    router.add_route(SampleEvent, async_agent)
+
+    # Create and dispatch an event
+    event = SampleEvent(source=str, message="Hello")
+    dispatcher.dispatch(event)
+
+    # Wait for the event to be processed
+    await dispatcher.wait_for_empty_queue(timeout=1)
+
+    # The event should have been processed and removed from the queue
+    assert len(dispatcher.event_queue) == 0
+
+
+@pytest.mark.asyncio
+async def test_async_dispatcher_with_async_agent(dispatcher, router, async_agent):
+    """Test that the AsyncDispatcher works with async agents."""
+    # Register the agent
+    router.add_route(SampleEvent, async_agent)
+
+    # Create and dispatch an event
+    event = SampleEvent(source=str, message="Hello")
+    dispatcher.dispatch(event)
+
+    # Wait for the event to be processed
+    await dispatcher.wait_for_empty_queue(timeout=1)
+
+    # The event should have been processed and removed from the queue
+    assert len(dispatcher.event_queue) == 0
+
+
+@pytest.mark.asyncio
+async def test_async_dispatcher_with_sync_agent(dispatcher, router, sync_agent):
+    """Test that the AsyncDispatcher works with sync agents."""
+    # Register the agent
+    router.add_route(SampleEvent, sync_agent)
+
+    # Create and dispatch an event
+    event = SampleEvent(source=str, message="Hello")
+    dispatcher.dispatch(event)
+
+    # Wait for the event to be processed
+    await dispatcher.wait_for_empty_queue(timeout=1)
+
+    # The event should have been processed and removed from the queue
+    assert len(dispatcher.event_queue) == 0
+
+    # Verify that the sync agent's receive_event method was called
+    sync_agent.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_async_dispatcher_terminate_event(dispatcher, router):
+    """Test that the AsyncDispatcher handles TerminateEvent correctly."""
+    # Create a mock agent that returns a TerminateEvent
+    class TerminateAgent(BaseAsyncAgent):
+        async def receive_event_async(self, event):
+            return [TerminateEvent(source=type(self))]
+
+    terminate_agent = TerminateAgent()
+
+    # Register the agent
+    router.add_route(SampleEvent, terminate_agent)
+
+    # Create and dispatch an event
+    event = SampleEvent(source=str, message="Hello")
+    dispatcher.dispatch(event)
+
+    # Wait a moment for the event to be processed
+    await asyncio.sleep(0.5)
+
+    # The dispatcher should have stopped
+    assert dispatcher._stop_event.is_set()
+
+
+@pytest.mark.asyncio
+async def test_async_dispatcher_wait_for_empty_queue(dispatcher):
+    """Test that wait_for_empty_queue works correctly."""
+    # Queue is initially empty
+    assert await dispatcher.wait_for_empty_queue() is True
+
+    # Add multiple events to the queue to test batch processing
+    for i in range(10):
+        event = SampleEvent(source=str, message=f"Event {i}")
+        dispatcher.dispatch(event)
+
+    # Queue is not empty
+    assert len(dispatcher.event_queue) > 0
+
+    # Wait for the queue to be empty with a sufficient timeout
+    # The dispatcher should process all events
+    assert await dispatcher.wait_for_empty_queue(timeout=1) is True
+
+    # Verify the queue is empty
+    assert len(dispatcher.event_queue) == 0
+
+
+@pytest.mark.asyncio
+async def test_async_dispatcher_batch_processing(dispatcher, router, async_agent):
+    """Test that the AsyncDispatcher processes events in batches."""
+    # Register the agent
+    router.add_route(SampleEvent, async_agent)
+
+    # Set a small batch size
+    dispatcher.batch_size = 2
+
+    # Create and dispatch multiple events
+    for i in range(5):
+        event = SampleEvent(source=str, message=f"Event {i}")
+        dispatcher.dispatch(event)
+
+    # Wait for all events to be processed
+    await dispatcher.wait_for_empty_queue(timeout=2)
+
+    # All events should have been processed
+    assert len(dispatcher.event_queue) == 0
+
+
+@pytest.mark.asyncio
+async def test_async_dispatcher_correlation_id(dispatcher):
+    """Test that the AsyncDispatcher assigns correlation_id if not provided."""
+    # Create an event without a correlation_id
+    event = SampleEvent(source=str, message="Hello")
+    assert event.correlation_id is None
+
+    # Dispatch the event
+    dispatcher.dispatch(event)
+
+    # The event should now have a correlation_id
+    assert event.correlation_id is not None

mojentic/llm/gateways/models.py

@@ -46,7 +46,7 @@ class LLMToolCall(BaseModel):
     """
     A tool call to be made available to the LLM.
 
-    Parameters
+    Attributes
     ----------
     id : Optional[str]
         The identifier of the tool call.
@@ -64,7 +64,7 @@ class LLMMessage(BaseModel):
     """
     A message to be sent to the LLM. These would accumulate during a chat session with an LLM.
 
-    Parameters
+    Attributes
     ----------
     role : MessageRole
         The role of the message in the conversation.
@@ -89,7 +89,7 @@ class LLMGatewayResponse(BaseModel):
     """
     The response from the LLM gateway, abstracting you from the quirks of a specific LLM.
 
-    Parameters
+    Attributes
     ----------
     content : Optional[Union[str, dict[str, str]]]
         The content of the response.

mojentic/llm/gateways/ollama.py

@@ -41,8 +41,8 @@ class OllamaGateway(LLMGateway):
         """
         Complete the LLM request by delegating to the Ollama service.
 
-        Parameters
-        ----------
+        Keyword Arguments
+        ----------------
         model : str
             The name of the model to use, as appears in `ollama list`.
         messages : List[LLMMessage]
@@ -107,8 +107,8 @@ class OllamaGateway(LLMGateway):
         """
         Stream the LLM response from Ollama service.
 
-        Parameters
-        ----------
+        Keyword Arguments
+        ----------------
         model : str
             The name of the model to use, as appears in `ollama list`.
         messages : List[LLMMessage]

mojentic/llm/gateways/openai.py

@@ -31,8 +31,8 @@ class OpenAIGateway(LLMGateway):
         """
         Complete the LLM request by delegating to the OpenAI service.
 
-        Parameters
-        ----------
+        Keyword Arguments
+        ----------------
         model : str
             The name of the model to use, as appears in `ollama list`.
         messages : List[LLMMessage]
@@ -148,4 +148,4 @@ class OpenAIGateway(LLMGateway):
         tokenizer = TokenizerGateway()
         tokens = tokenizer.encode(text)
         chunks_iterator = self._batched(tokens, chunk_length)
-        yield from chunks_iterator
+        yield from chunks_iterator

mojentic/llm/gateways/openai_messages_adapter.py

@@ -48,13 +48,17 @@ def get_image_type(file_path: str) -> str:
         file_path: Path to the image file
 
     Returns:
-        Image type (e.g., 'jpg', 'png')
+        Image type (e.g., 'jpeg', 'png')
     """
     _, ext = os.path.splitext(file_path)
     image_type = ext.lstrip('.').lower()
-    if image_type not in ['jpeg', 'jpg', 'png', 'gif', 'webp']:
-        image_type = 'jpeg'  # Default to jpeg if unknown extension
-    return image_type
+
+    # Convert 'jpg' to 'jpeg'
+    if image_type == 'jpg':
+        return 'jpeg'
+
+    # Use 'jpeg' for unknown extensions, otherwise use the detected type
+    return image_type if image_type in ['jpeg', 'png', 'gif', 'webp'] else 'jpeg'
 
 
 def adapt_messages_to_openai(messages: List[LLMMessage]):

mojentic/llm/llm_broker.py

@@ -88,7 +88,7 @@ class LLMBroker():
         logger.info(f"Requesting llm response with approx {approximate_tokens} tokens")
 
         # Convert messages to serializable dict for audit
-        messages_for_tracer = [m.dict() for m in messages]
+        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
@@ -115,7 +115,7 @@ class LLMBroker():
         call_duration_ms = (time.time() - start_time) * 1000
 
         # Record LLM response in tracer
-        tool_calls_for_tracer = [tc.dict() 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,
@@ -199,7 +199,7 @@ class LLMBroker():
         logger.info(f"Requesting llm response with approx {approximate_tokens} tokens")
 
         # Convert messages to serializable dict for audit
-        messages_for_tracer = [m.dict() for m in messages]
+        messages_for_tracer = [m.model_dump() for m in messages]
 
         # Record LLM call in tracer
         self.tracer.record_llm_call(
@@ -221,7 +221,7 @@ class LLMBroker():
 
         # Record LLM response in tracer with object representation
         # Convert object to string for tracer
-        object_str = str(result.object.dict()) if hasattr(result.object, "dict") 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.6.2.dist-info → mojentic-0.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mojentic
-Version: 0.6.2
+Version: 0.7.1
 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
@@ -24,6 +24,7 @@ Requires-Dist: serpapi
 Requires-Dist: colorama
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
 Requires-Dist: pytest-spec; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: pytest-mock>=3.10.0; extra == "dev"

{mojentic-0.6.2.dist-info → mojentic-0.7.1.dist-info}/RECORD

@@ -1,4 +1,6 @@
 _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=axLrX9lzQAAxSTCmm1njvOk63EWfVRG3NU6pLiMyYH8,2962
 _examples/broker_examples.py,sha256=7tES2KyKc3uigBuxkwOTf5UGhp7nVeVqLhd8fEHSWEc,1901
 _examples/broker_image_examples.py,sha256=8dpZ2RFmRYhJqoeWklzlPxmvj9m4M393452SO_D2bJY,1133
@@ -42,13 +44,20 @@ _examples/react/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 _examples/react/models/base.py,sha256=F3hR023XQofs3Op37sruuONxAU7eRjGnLnf4515BeYU,1239
 _examples/react/models/events.py,sha256=0lRY0D5VrSkIGEKnSEQQBRyxxMQl71yxPkdMBuVBKHw,1062
 mojentic/__init__.py,sha256=Jrllv5OKZKjkfVNLRJV6yT3NZA8ZELSrqj3798H4cDs,1172
+mojentic/async_dispatcher.py,sha256=uDw4thjK0O7OAuV-v35s6k7ZIm6BLcZ8qhRZU_UKdn0,4735
+mojentic/async_dispatcher_spec.py,sha256=wBlEzdw6wvMf5g982824nFxzP6EGtMM5yO-sd-fYx2w,7279
 mojentic/dispatcher.py,sha256=Jx73v1799pYqzdLBDnq1tbPzXVEs3xArwtMhZvByyH8,2760
 mojentic/event.py,sha256=P0kgI0Si41ifCTLNtpfkks0OktlK4wuAj3oMCDtdUyo,330
 mojentic/router.py,sha256=7z2xqgpsuHmA32HfH3rAgDk3zLhUBxz8DHPt2vDlVOU,377
 mojentic/router_spec.py,sha256=CRYeKEa7dz_yN8ABAi5DgY5C0mJW7she3Kw0NzxoHx4,876
 mojentic/agents/__init__.py,sha256=HQe0ygpRMamz9x7dCcri_aAMwr8XDTCMls2g2g0LBL0,345
 mojentic/agents/agent_broker.py,sha256=ulLuCzqDtPPxLSB8dre8Js1fwR3Uls7gGtJrmhcelwo,927
+mojentic/agents/async_aggregator_agent.py,sha256=mv4iFND6krvZQjnBmR9Z9Quu6a_b1zl_opSquKIjqFk,5355
+mojentic/agents/async_aggregator_agent_spec.py,sha256=TsetYelNy2biD_mYN3qqKbF7Zg6-9Xi_5pYXGAM4WAU,8340
+mojentic/agents/async_llm_agent.py,sha256=KSTpQ40zVpbPYwwg73la3WY1LKBeBL2HsfJoUCp_rTI,6464
+mojentic/agents/async_llm_agent_spec.py,sha256=myNKJlgK0mqHzBWQfeB_TpcT0Mwv9CvyqNcqurvVGIc,5371
 mojentic/agents/base_agent.py,sha256=m1SRyzY9ou4tesFDszonC4Y8moQMg9eofvJeuhoXmM0,722
+mojentic/agents/base_async_agent.py,sha256=oUYDhMOqTyDmlmCt1q3S0gLrTK-w-FnlCfTOpYZ7ln8,888
 mojentic/agents/base_llm_agent.py,sha256=26pe0nS7UD1x1-NZjGMQMguxxQBjcRDyXMzcSmJOd2c,3094
 mojentic/agents/base_llm_agent_spec.py,sha256=1kzayCtAZY7oWloaFMh7-NkTtiKihDCLD3i9HwH3_Uc,2571
 mojentic/agents/correlation_aggregator_agent.py,sha256=okdq92rMNwIXTgnuwwn3zp4JzSxTh05vGWzTGocOgbU,1134
@@ -60,7 +69,7 @@ mojentic/context/shared_working_memory.py,sha256=Zt9MNGErEkDIUAaHvyhEOiTaEobI9l0
 mojentic/llm/__init__.py,sha256=mwdPpTRofw7_KSlW6ZQmcM-GSpyISWyI2bxphKpV7A0,180
 mojentic/llm/chat_session.py,sha256=H2gY0mZYVym8jC69VHsmKaRZ9T87Suyw0-TW5r850nA,3992
 mojentic/llm/chat_session_spec.py,sha256=8-jj-EHV2WwWuvo3t8I75kSEAYiG1nR-OEwkkLTi_z0,3872
-mojentic/llm/llm_broker.py,sha256=DFi0zgFYgdOKrJx7DomktnbBQKppi4mB_RcDvXTf9-4,9170
+mojentic/llm/llm_broker.py,sha256=i9jhSulXV4lQX9G6YOQTiMZt4UMipqUfvl-P-gmXQXo,9200
 mojentic/llm/llm_broker_spec.py,sha256=40lzmYm_6Zje6z5MQ7_o3gSBThLsNW_l_1mZTUVll6A,5342
 mojentic/llm/message_composers.py,sha256=Fo9o7UGZOOIYoGI_DyOfP_oMiEiCMQz-zdWdTKtozVk,12108
 mojentic/llm/message_composers_spec.py,sha256=RNW14Zb-kIBWT5Wy9cZQyxHPrcRIaBFjBYCR9N-m0kE,12109
@@ -70,13 +79,13 @@ mojentic/llm/gateways/anthropic_messages_adapter.py,sha256=K6kEZeVt7E1endbGMLsh5
 mojentic/llm/gateways/embeddings_gateway.py,sha256=kcOhiyHzOyQgKgwPDQJD5oVvfwk71GsBgMYJOIDv5NU,1347
 mojentic/llm/gateways/file_gateway.py,sha256=3bZpalSyl_R4016WzCmmjUBDtAgPsmx19eVGv6p1Ufk,1418
 mojentic/llm/gateways/llm_gateway.py,sha256=5BayP6VuMgMHdAzCFaXLRjRCWh-IOYnaq_s4LZ0_3x4,2559
-mojentic/llm/gateways/models.py,sha256=lnGvr3E4C5n15v0aI8Cc0FMOH6GBCrk5_XaEEe3vKkM,3015
-mojentic/llm/gateways/ollama.py,sha256=629fpZhC0zVCYqj360-PKTT4mQOLec5nzzvfMtS_mLQ,7581
+mojentic/llm/gateways/models.py,sha256=OyIaMHKrrx6dHo5FbC8qOFct7PRql9wqbe_BJlgDSDE,3015
+mojentic/llm/gateways/ollama.py,sha256=fBnmG4B0Trq8BJa8eZgrYUEVgb3kiTPytW1e6aTIjj8,7607
 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=G5bdQ0AkMlG-nOCvsw1gziyIerCiA1__RPfFK4M6fXI,5475
+mojentic/llm/gateways/openai.py,sha256=P40KKfNCmY_EKDP6VUKu7sM2GaqX_iUPx6_2_BYb80Q,5489
 mojentic/llm/gateways/openai_message_adapter_spec.py,sha256=ITBSV5njldV_x0NPgjmg8Okf9KzevQJ8dTXM-t6ubcg,6612
-mojentic/llm/gateways/openai_messages_adapter.py,sha256=9Btcr77RzlqZIdkNuGDGitk9D7SQTv4GsdKXaN2Fuv4,3863
+mojentic/llm/gateways/openai_messages_adapter.py,sha256=Scal68JKKdBHB35ok1c5DeWYdD6Wra5oXSsPxJyyXSQ,3947
 mojentic/llm/gateways/tokenizer_gateway.py,sha256=ztuqfunlJ6xmyUPPHcC_69-kegiNJD6jdSEde7hDh2w,485
 mojentic/llm/registry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mojentic/llm/registry/llm_registry.py,sha256=beyrgGrkXx5ZckUJzC1nQ461vra0fF6s_qRaEdi5bsg,2508
@@ -121,8 +130,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.6.2.dist-info/licenses/LICENSE.md,sha256=txSgV8n5zY1W3NiF5HHsCwlaW0e8We1cSC6TuJUqxXA,1060
-mojentic-0.6.2.dist-info/METADATA,sha256=VEeadz_96qq1APeO0zg-Nc2U5nBErrr2q6R1WfmEUlQ,5383
-mojentic-0.6.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mojentic-0.6.2.dist-info/top_level.txt,sha256=Q-BvPQ8Eu1jnEqK8Xkr6A9C8Xa1z38oPZRHuA5MCTqg,19
-mojentic-0.6.2.dist-info/RECORD,,
+mojentic-0.7.1.dist-info/licenses/LICENSE.md,sha256=txSgV8n5zY1W3NiF5HHsCwlaW0e8We1cSC6TuJUqxXA,1060
+mojentic-0.7.1.dist-info/METADATA,sha256=tH9I2vnk7ypAmVkNzkZhdn3i_KuWQWQkEIKhtJZdQkM,5429
+mojentic-0.7.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mojentic-0.7.1.dist-info/top_level.txt,sha256=Q-BvPQ8Eu1jnEqK8Xkr6A9C8Xa1z38oPZRHuA5MCTqg,19
+mojentic-0.7.1.dist-info/RECORD,,