mojentic 0.8.4__py3-none-any.whl → 1.0.0__py3-none-any.whl

_examples/tracer_qt_viewer.py

@@ -14,7 +14,6 @@ Usage:
 import sys
 import uuid
 from datetime import datetime
-from typing import Optional
 
 try:
     from PyQt6.QtWidgets import (
@@ -22,7 +21,7 @@ try:
         QTableWidget, QTableWidgetItem, QTextEdit, QPushButton, QLabel,
         QHeaderView, QSplitter
     )
-    from PyQt6.QtCore import Qt, QTimer, pyqtSignal, QObject, QThread
+    from PyQt6.QtCore import Qt, pyqtSignal, QObject, QThread
     from PyQt6.QtGui import QColor, QFont
 except ImportError:
     print("Error: PyQt6 is required for this example.")
@@ -86,7 +85,7 @@ class LLMWorker(QThread):
 
 class TracerViewer(QMainWindow):
     """Qt window that displays tracer events in real-time."""
-    
+
     def __init__(self):
         super().__init__()
         self.events = []
@@ -99,13 +98,13 @@ class TracerViewer(QMainWindow):
 
         self._setup_ui()
         self._setup_tracer()
-        
+
     def _setup_ui(self):
         """Setup the user interface."""
         central_widget = QWidget()
         self.setCentralWidget(central_widget)
         main_layout = QVBoxLayout(central_widget)
-        
+
         # Title and controls
         header_layout = QHBoxLayout()
         title_label = QLabel("Real-time Tracer Events")
@@ -114,26 +113,26 @@ class TracerViewer(QMainWindow):
         title_font.setBold(True)
         title_label.setFont(title_font)
         header_layout.addWidget(title_label)
-        
+
         header_layout.addStretch()
-        
+
         self.clear_button = QPushButton("Clear Events")
         self.clear_button.clicked.connect(self.clear_events)
         header_layout.addWidget(self.clear_button)
-        
+
         self.test_button = QPushButton("Run Test Query")
         self.test_button.clicked.connect(self.run_test_query)
         header_layout.addWidget(self.test_button)
-        
+
         main_layout.addLayout(header_layout)
-        
+
         # Event counter
         self.event_count_label = QLabel("Events: 0")
         main_layout.addWidget(self.event_count_label)
-        
+
         # Splitter for table and details
         splitter = QSplitter(Qt.Orientation.Vertical)
-        
+
         # Events table
         self.events_table = QTableWidget()
         self.events_table.setColumnCount(5)
@@ -151,53 +150,53 @@ class TracerViewer(QMainWindow):
         )
         self.events_table.itemSelectionChanged.connect(self.show_event_details)
         splitter.addWidget(self.events_table)
-        
+
         # Event details panel
         details_widget = QWidget()
         details_layout = QVBoxLayout(details_widget)
         details_label = QLabel("Event Details (click an event to see details)")
         details_label.setFont(QFont("", 10, QFont.Weight.Bold))
         details_layout.addWidget(details_label)
-        
+
         self.details_text = QTextEdit()
         self.details_text.setReadOnly(True)
         self.details_text.setFont(QFont("Courier", 9))
         details_layout.addWidget(self.details_text)
-        
+
         splitter.addWidget(details_widget)
         splitter.setSizes([400, 300])
-        
+
         main_layout.addWidget(splitter)
-        
+
         # Status bar
         self.statusBar().showMessage("Ready. Waiting for tracer events...")
-        
+
     def _setup_tracer(self):
         """Setup the tracer system with callback."""
         def on_event_stored(event):
             """Callback when an event is stored."""
             if isinstance(event, TracerEvent):
                 self.event_signaler.event_occurred.emit(event)
-        
+
         event_store = EventStore(on_store_callback=on_event_stored)
         self.tracer = TracerSystem(event_store=event_store)
-        
+
     def add_event_to_table(self, event: TracerEvent):
         """Add a new event to the table."""
         self.events.append(event)
-        
+
         row = self.events_table.rowCount()
         self.events_table.insertRow(row)
-        
+
         # Time
         time_str = datetime.fromtimestamp(event.timestamp).strftime("%H:%M:%S.%f")[:-3]
         time_item = QTableWidgetItem(time_str)
         self.events_table.setItem(row, 0, time_item)
-        
+
         # Type
         event_type = type(event).__name__.replace("TracerEvent", "")
         type_item = QTableWidgetItem(event_type)
-        
+
         # Color code by type
         if isinstance(event, LLMCallTracerEvent):
             type_item.setBackground(QColor(107, 182, 96, 50))  # Mojility green
@@ -207,32 +206,32 @@ class TracerViewer(QMainWindow):
             type_item.setBackground(QColor(102, 103, 103, 50))  # Mojility grey
         elif isinstance(event, AgentInteractionTracerEvent):
             type_item.setBackground(QColor(100, 149, 237, 50))  # Blue
-        
+
         self.events_table.setItem(row, 1, type_item)
-        
+
         # Correlation ID (shortened)
         corr_id_short = event.correlation_id[:8] if event.correlation_id else "N/A"
         corr_item = QTableWidgetItem(corr_id_short)
         corr_item.setToolTip(event.correlation_id)
         self.events_table.setItem(row, 2, corr_item)
-        
+
         # Summary
         summary = self._get_event_summary(event)
         summary_item = QTableWidgetItem(summary)
         self.events_table.setItem(row, 3, summary_item)
-        
+
         # Duration
         duration = ""
         if isinstance(event, (LLMResponseTracerEvent, ToolCallTracerEvent)) and event.call_duration_ms:
             duration = f"{event.call_duration_ms:.0f}"
         duration_item = QTableWidgetItem(duration)
         self.events_table.setItem(row, 4, duration_item)
-        
+
         # Scroll to bottom and update counter
         self.events_table.scrollToBottom()
         self.event_count_label.setText(f"Events: {len(self.events)}")
         self.statusBar().showMessage(f"New event: {event_type}")
-        
+
     def _get_event_summary(self, event: TracerEvent) -> str:
         """Get a brief summary of the event."""
         if isinstance(event, LLMCallTracerEvent):
@@ -245,21 +244,21 @@ class TracerViewer(QMainWindow):
         elif isinstance(event, AgentInteractionTracerEvent):
             return f"From: {event.from_agent} → To: {event.to_agent}"
         return "Unknown event type"
-    
+
     def show_event_details(self):
         """Show detailed information about the selected event."""
         selected_rows = self.events_table.selectedIndexes()
         if not selected_rows:
             return
-        
+
         row = selected_rows[0].row()
         if row >= len(self.events):
             return
-        
+
         event = self.events[row]
         details = self._format_event_details(event)
         self.details_text.setPlainText(details)
-        
+
     def _format_event_details(self, event: TracerEvent) -> str:
         """Format detailed event information."""
         details = []
@@ -268,7 +267,7 @@ class TracerViewer(QMainWindow):
         details.append(f"Correlation ID: {event.correlation_id}")
         details.append(f"Source: {event.source}")
         details.append("")
-        
+
         if isinstance(event, LLMCallTracerEvent):
             details.append("=== LLM Call Details ===")
             details.append(f"Model: {event.model}")
@@ -285,7 +284,7 @@ class TracerViewer(QMainWindow):
             if event.tools:
                 details.append("")
                 details.append(f"Available Tools: {[t.get('name') for t in event.tools]}")
-        
+
         elif isinstance(event, LLMResponseTracerEvent):
             details.append("=== LLM Response Details ===")
             details.append(f"Model: {event.model}")
@@ -298,19 +297,23 @@ class TracerViewer(QMainWindow):
                 details.append(f"Tool Calls Made: {len(event.tool_calls)}")
                 for i, tc in enumerate(event.tool_calls, 1):
                     details.append(f"  {i}. {tc}")
-        
+
         elif isinstance(event, ToolCallTracerEvent):
             details.append("=== Tool Call Details ===")
             details.append(f"Tool Name: {event.tool_name}")
             details.append(f"Caller: {event.caller or 'N/A'}")
-            details.append(f"Call Duration: {event.call_duration_ms:.2f} ms" if event.call_duration_ms else "Duration: N/A")
+            duration_text = (
+                f"{event.call_duration_ms:.2f} ms"
+                if event.call_duration_ms else "N/A"
+            )
+            details.append(f"Call Duration: {duration_text}")
             details.append("")
             details.append("Arguments:")
             details.append(f"  {event.arguments}")
             details.append("")
             details.append("Result:")
             details.append(f"  {event.result}")
-        
+
         elif isinstance(event, AgentInteractionTracerEvent):
             details.append("=== Agent Interaction Details ===")
             details.append(f"From Agent: {event.from_agent}")
@@ -318,9 +321,9 @@ class TracerViewer(QMainWindow):
             details.append(f"Event Type: {event.event_type}")
             if event.event_id:
                 details.append(f"Event ID: {event.event_id}")
-        
+
         return "\n".join(details)
-    
+
     def clear_events(self):
         """Clear all events from the display."""
         self.events.clear()
@@ -329,7 +332,7 @@ class TracerViewer(QMainWindow):
         self.event_count_label.setText("Events: 0")
         self.tracer.clear()
         self.statusBar().showMessage("Events cleared")
-    
+
     def run_test_query(self):
         """Run a test query to demonstrate the tracer."""
         # Don't start a new query if one is already running
@@ -369,13 +372,13 @@ class TracerViewer(QMainWindow):
 def main():
     """Main entry point for the tracer viewer application."""
     app = QApplication(sys.argv)
-    
+
     # Set application style
     app.setStyle('Fusion')
-    
+
     window = TracerViewer()
     window.show()
-    
+
     print("\n" + "="*80)
     print("Mojentic Tracer - Real-time Event Viewer")
     print("="*80)
@@ -386,7 +389,7 @@ def main():
     print("\nThe viewer will show events in real-time as they occur.")
     print("Close the window to exit.")
     print("="*80 + "\n")
-    
+
     sys.exit(app.exec())
 
 

_examples/working_memory.py

@@ -51,7 +51,7 @@ memory = SharedWorkingMemory({
 })
 
 llm = LLMBroker("deepseek-r1:70b")
-# llm = LLMBroker("llama3.3-instruct-70b-32k")
+# llm = LLMBroker("qwen3:32b-instruct-70b-32k")
 request_agent = RequestAgent(llm, memory)
 output_agent = OutputAgent()
 

mojentic/__init__.py

@@ -8,9 +8,9 @@ import logging
 import structlog
 
 # Core components
-from .dispatcher import Dispatcher
-from .event import Event
-from .router import Router
+from .dispatcher import Dispatcher  # noqa: F401
+from .event import Event  # noqa: F401
+from .router import Router  # noqa: F401
 
 # Initialize logging
 logging.basicConfig(level=logging.INFO)

mojentic/agents/__init__.py

@@ -3,14 +3,32 @@ Mojentic agents module for creating and working with various agent types.
 """
 
 # Base agent types
-from .base_agent import BaseAgent
-from .base_llm_agent import BaseLLMAgent, BaseLLMAgentWithMemory
+from mojentic.agents.base_agent import BaseAgent
+from mojentic.agents.base_llm_agent import BaseLLMAgent
+from mojentic.agents.base_async_agent import BaseAsyncAgent
+from mojentic.agents.async_llm_agent import BaseAsyncLLMAgent, BaseAsyncLLMAgentWithMemory
+from mojentic.agents.async_aggregator_agent import AsyncAggregatorAgent
 
 # Special purpose agents
-from .correlation_aggregator_agent import BaseAggregatingAgent
-from .output_agent import OutputAgent
-from .iterative_problem_solver import IterativeProblemSolver
-from .simple_recursive_agent import SimpleRecursiveAgent
+from mojentic.agents.iterative_problem_solver import IterativeProblemSolver
+from mojentic.agents.simple_recursive_agent import SimpleRecursiveAgent
+from mojentic.agents.output_agent import OutputAgent
 
-# Agent brokering
-from .agent_broker import AgentBroker
+# Event adapters
+from mojentic.agents.agent_event_adapter import AgentEventAdapter
+
+__all__ = [
+    # Base types
+    "BaseAgent",
+    "BaseLLMAgent",
+    "BaseAsyncAgent",
+    "BaseAsyncLLMAgent",
+    "BaseAsyncLLMAgentWithMemory",
+    "AsyncAggregatorAgent",
+    # Special purpose
+    "IterativeProblemSolver",
+    "SimpleRecursiveAgent",
+    "OutputAgent",
+    # Event adapters
+    "AgentEventAdapter",
+]

mojentic/agents/{agent_broker.py → agent_event_adapter.py}

@@ -4,7 +4,7 @@ from mojentic import Event
 from mojentic.agents import BaseLLMAgent
 
 
-class AgentBroker:
+class AgentEventAdapter:
     """
     Wraps an agent to allow participation in an asynchronous event-driven system.
     """
@@ -14,8 +14,8 @@ class AgentBroker:
 
     def receive_event(self, event: Event) -> List[Event]:
         """
-        receive_event is called by the event broker when an event is to be received by an agent. The broker will return
-        a list of events determined from the agent's output in response to the received event.
+        receive_event is called by the event broker when an event is to be received by an agent. The adapter will
+        return a list of events determined from the agent's output in response to the received event.
 
         In this way, you can perform work based on the event, and generate whatever subsequent events may need to be
         processed next.

mojentic/agents/async_aggregator_agent_spec.py

@@ -1,6 +1,5 @@
 import asyncio
 import pytest
-from unittest.mock import AsyncMock, MagicMock
 
 from mojentic.agents.async_aggregator_agent import AsyncAggregatorAgent
 from mojentic.event import Event
@@ -28,13 +27,13 @@ class TestResultEvent(Event):
 
 class TestAsyncAggregator(AsyncAggregatorAgent):
     """A test implementation of AsyncAggregatorAgent."""
-    
+
     async def process_events(self, events):
         """Process the events and return a result event."""
         # Extract events by type
         event1 = next((e for e in events if isinstance(e, TestEvent1)), None)
         event2 = next((e for e in events if isinstance(e, TestEvent2)), None)
-        
+
         if event1 and event2:
             # Create a result combining the events
             return [TestResultEvent(
@@ -61,7 +60,7 @@ def test_async_aggregator():
 async def test_async_aggregator_init():
     """Test that the AsyncAggregatorAgent initializes correctly."""
     agent = AsyncAggregatorAgent(event_types_needed=[TestEvent1, TestEvent2])
-    
+
     assert agent.event_types_needed == [TestEvent1, TestEvent2]
     assert agent.results == {}
     assert agent.futures == {}
@@ -71,9 +70,9 @@ async def test_async_aggregator_init():
 async def test_async_aggregator_capture_results(async_aggregator):
     """Test that the AsyncAggregatorAgent captures results correctly."""
     event = TestEvent1(source=str, correlation_id="test-id", message="Hello")
-    
+
     await async_aggregator._capture_results_if_needed(event)
-    
+
     assert "test-id" in async_aggregator.results
     assert len(async_aggregator.results["test-id"]) == 1
     assert async_aggregator.results["test-id"][0] == event
@@ -84,14 +83,14 @@ async def test_async_aggregator_has_all_needed(async_aggregator):
     """Test that the AsyncAggregatorAgent checks if all needed events are captured."""
     event1 = TestEvent1(source=str, correlation_id="test-id", message="Hello")
     event2 = TestEvent2(source=str, correlation_id="test-id", data="World")
-    
+
     # Initially, we don't have all needed events
     assert not await async_aggregator._has_all_needed(event1)
-    
+
     # Capture the first event
     await async_aggregator._capture_results_if_needed(event1)
     assert not await async_aggregator._has_all_needed(event1)
-    
+
     # Capture the second event
     await async_aggregator._capture_results_if_needed(event2)
     assert await async_aggregator._has_all_needed(event2)
@@ -102,14 +101,14 @@ async def test_async_aggregator_get_and_reset_results(async_aggregator):
     """Test that the AsyncAggregatorAgent gets and resets results correctly."""
     event1 = TestEvent1(source=str, correlation_id="test-id", message="Hello")
     event2 = TestEvent2(source=str, correlation_id="test-id", data="World")
-    
+
     # Capture the events
     await async_aggregator._capture_results_if_needed(event1)
     await async_aggregator._capture_results_if_needed(event2)
-    
+
     # Get and reset the results
     results = await async_aggregator._get_and_reset_results(event1)
-    
+
     assert len(results) == 2
     assert results[0] == event1
     assert results[1] == event2
@@ -121,17 +120,17 @@ async def test_async_aggregator_wait_for_events(async_aggregator):
     """Test that the AsyncAggregatorAgent waits for events correctly."""
     event1 = TestEvent1(source=str, correlation_id="test-id", message="Hello")
     event2 = TestEvent2(source=str, correlation_id="test-id", data="World")
-    
+
     # Start waiting for events in a separate task
     wait_task = asyncio.create_task(async_aggregator.wait_for_events("test-id", timeout=1))
-    
+
     # Capture the events
     await async_aggregator._capture_results_if_needed(event1)
     await async_aggregator._capture_results_if_needed(event2)
-    
+
     # Wait for the task to complete
     results = await wait_task
-    
+
     assert len(results) == 2
     assert results[0] == event1
     assert results[1] == event2
@@ -141,13 +140,13 @@ async def test_async_aggregator_wait_for_events(async_aggregator):
 async def test_async_aggregator_wait_for_events_timeout(async_aggregator):
     """Test that the AsyncAggregatorAgent handles timeouts correctly."""
     event1 = TestEvent1(source=str, correlation_id="test-id", message="Hello")
-    
+
     # Capture only one event
     await async_aggregator._capture_results_if_needed(event1)
-    
+
     # Wait for events with a short timeout
     results = await async_aggregator.wait_for_events("test-id", timeout=0.1)
-    
+
     # We should get the partial results
     assert len(results) == 1
     assert results[0] == event1
@@ -158,14 +157,14 @@ async def test_async_aggregator_receive_event_async(test_async_aggregator):
     """Test that the AsyncAggregatorAgent processes events correctly."""
     event1 = TestEvent1(source=str, correlation_id="test-id", message="Hello")
     event2 = TestEvent2(source=str, correlation_id="test-id", data="World")
-    
+
     # Receive the first event - should not process yet
     result1 = await test_async_aggregator.receive_event_async(event1)
     assert result1 == []
-    
+
     # Receive the second event - should process both events
     result2 = await test_async_aggregator.receive_event_async(event2)
-    
+
     assert len(result2) == 1
     assert isinstance(result2[0], TestResultEvent)
     assert result2[0].result == "Hello - World"
@@ -176,14 +175,14 @@ async def test_async_aggregator_receive_event_async_wrong_order(test_async_aggre
     """Test that the AsyncAggregatorAgent processes events correctly regardless of order."""
     event1 = TestEvent1(source=str, correlation_id="test-id", message="Hello")
     event2 = TestEvent2(source=str, correlation_id="test-id", data="World")
-    
+
     # Receive the second event first - should not process yet
     result1 = await test_async_aggregator.receive_event_async(event2)
     assert result1 == []
-    
+
     # Receive the first event - should process both events
     result2 = await test_async_aggregator.receive_event_async(event1)
-    
+
     assert len(result2) == 1
     assert isinstance(result2[0], TestResultEvent)
     assert result2[0].result == "Hello - World"
@@ -194,22 +193,22 @@ async def test_async_aggregator_receive_event_async_different_correlation_ids(te
     """Test that the AsyncAggregatorAgent handles different correlation_ids correctly."""
     event1_id1 = TestEvent1(source=str, correlation_id="id1", message="Hello")
     event2_id1 = TestEvent2(source=str, correlation_id="id1", data="World")
-    
+
     event1_id2 = TestEvent1(source=str, correlation_id="id2", message="Goodbye")
     event2_id2 = TestEvent2(source=str, correlation_id="id2", data="Universe")
-    
+
     # Receive events for id1
     await test_async_aggregator.receive_event_async(event1_id1)
     result1 = await test_async_aggregator.receive_event_async(event2_id1)
-    
+
     # Receive events for id2
     await test_async_aggregator.receive_event_async(event1_id2)
     result2 = await test_async_aggregator.receive_event_async(event2_id2)
-    
+
     # Check results for id1
     assert len(result1) == 1
     assert result1[0].result == "Hello - World"
-    
+
     # Check results for id2
     assert len(result2) == 1
     assert result2[0].result == "Goodbye - Universe"
@@ -220,8 +219,8 @@ async def test_async_aggregator_process_events_base_implementation(async_aggrega
     """Test that the base process_events implementation returns an empty list."""
     event1 = TestEvent1(source=str, correlation_id="test-id", message="Hello")
     event2 = TestEvent2(source=str, correlation_id="test-id", data="World")
-    
+
     events = [event1, event2]
     result = await async_aggregator.process_events(events)
-    
-    assert result == []
+
+    assert result == []

mojentic/agents/async_llm_agent.py

@@ -152,8 +152,12 @@ class BaseAsyncLLMAgentWithMemory(BaseAsyncLLMAgent):
         """
         messages = super()._create_initial_messages()
         messages.extend([
-            LLMMessage(content=f"This is what you remember:\n{json.dumps(self.memory.get_working_memory(), indent=2)}"
-                               f"\n\nRemember anything new you learn by storing it to your working memory in your response."),
+            LLMMessage(
+                content=(f"This is what you remember:\n"
+                         f"{json.dumps(self.memory.get_working_memory(), indent=2)}"
+                         f"\n\nRemember anything new you learn by storing it "
+                         f"to your working memory in your response.")
+            ),
             LLMMessage(role=MessageRole.User, content=self.instructions),
         ])
         return messages
@@ -180,7 +184,7 @@ class BaseAsyncLLMAgentWithMemory(BaseAsyncLLMAgent):
         messages.extend([
             LLMMessage(content=content),
         ])
-        
+
         # Use asyncio.to_thread to run the synchronous generate_object method in a separate thread
         import asyncio
         response = await asyncio.to_thread(
@@ -188,10 +192,10 @@ class BaseAsyncLLMAgentWithMemory(BaseAsyncLLMAgent):
             messages=messages,
             object_model=ResponseWithMemory
         )
-        
+
         self.memory.merge_to_working_memory(response.memory)
 
         d = response.model_dump()
         del d["memory"]
 
-        return self.response_model.model_validate(d)
+        return self.response_model.model_validate(d)