mojentic 0.5.7__py3-none-any.whl → 0.6.1__py3-none-any.whl

_examples/recursive_agent.py

@@ -21,7 +21,8 @@ async def demonstrate_async():
     3. Running multiple problem-solving tasks concurrently
     """
     # Initialize the LLM broker with your preferred model
-    llm = LLMBroker(model="llama3.3-70b-32k")
+    # llm = LLMBroker(model="llama3.3-70b-32k")
+    llm = LLMBroker(model="qwen3:30b-a3b-q4_K_M")
 
     # Create the agent with a maximum of 3 iterations
     agent = SimpleRecursiveAgent(llm=llm, max_iterations=3)
@@ -41,7 +42,7 @@ async def demonstrate_async():
     print(f"\nProblem (With Event Handling): {problem2}")
 
     # Set up event handlers for monitoring the solution process
-    from mojentic.agents.simple_recursive_agent import ProblemSolvedEvent, IterationCompletedEvent
+    from mojentic.agents.simple_recursive_agent import GoalAchievedEvent, IterationCompletedEvent
 
     # Define event handlers
     def on_iteration_completed(event):
@@ -52,7 +53,7 @@ async def demonstrate_async():
 
     # Subscribe to events
     unsubscribe_iteration = agent.emitter.subscribe(IterationCompletedEvent, on_iteration_completed)
-    unsubscribe_solved = agent.emitter.subscribe(ProblemSolvedEvent, on_problem_solved)
+    unsubscribe_solved = agent.emitter.subscribe(GoalAchievedEvent, on_problem_solved)
 
     # Solve the problem
     solution2 = await agent.solve(problem2)

_examples/tracer_demo.py

@@ -0,0 +1,170 @@
+"""
+Example script demonstrating the tracer system with ChatSession and tools.
+
+This example shows how to use the tracer system to monitor an interactive 
+chat session with LLMBroker and tools. When the user exits the session, 
+the script displays a summary of all traced events.
+
+It also demonstrates how correlation_id is used to trace related events
+across the system, allowing you to track the flow of a request from start to finish.
+"""
+import uuid
+from datetime import datetime
+
+from mojentic.tracer import TracerSystem
+from mojentic.tracer.tracer_events import LLMCallTracerEvent, LLMResponseTracerEvent, ToolCallTracerEvent
+from mojentic.llm import ChatSession, LLMBroker
+from mojentic.llm.gateways.models import LLMMessage, MessageRole
+from mojentic.llm.tools.date_resolver import ResolveDateTool
+
+
+def print_tracer_events(events):
+    """Print tracer events using their printable_summary method."""
+    print(f"\n{'-'*80}")
+    print("Tracer Events:")
+    print(f"{'-'*80}")
+
+    for i, event in enumerate(events, 1):
+        print(f"{i}. {event.printable_summary()}")
+        print()
+
+
+def main():
+    """Run a chat session with tracer system to monitor interactions."""
+    # Create a tracer system to monitor all interactions
+    tracer = TracerSystem()
+
+    # Create an LLM broker with the tracer
+    llm_broker = LLMBroker(model="llama3.3-70b-32k", tracer=tracer)
+
+    # Create a date resolver tool that will also use the tracer
+    date_tool = ResolveDateTool(llm_broker=llm_broker, tracer=tracer)
+
+    # Create a chat session with the broker and tool
+    chat_session = ChatSession(llm_broker, tools=[date_tool])
+
+    # Dictionary to store correlation_ids for each conversation turn
+    # This allows us to track related events across the system
+    conversation_correlation_ids = {}
+
+    print("Welcome to the chat session with tracer demonstration!")
+    print("Ask questions about dates (e.g., 'What day is next Friday?') or anything else.")
+    print("Behind the scenes, the tracer system is recording all interactions.")
+    print("Each interaction is assigned a unique correlation_id to trace related events.")
+    print("Press Enter with no input to exit and see the trace summary.")
+    print("-" * 80)
+
+    # Interactive chat session
+    turn_counter = 0
+    while True:
+        query = input("You: ")
+        if not query:
+            print("Exiting chat session...")
+            break
+        else:
+            # Generate a unique correlation_id for this conversation turn
+            # In a real system, this would be passed from the initiating event
+            # to all downstream events to maintain the causal chain
+            correlation_id = str(uuid.uuid4())
+            turn_counter += 1
+            conversation_correlation_ids[turn_counter] = correlation_id
+
+            print(f"[Turn {turn_counter}, correlation_id: {correlation_id[:8]}...]")
+            print("Assistant: ", end="")
+
+            # For demonstration purposes, we'll use the chat_session normally
+            # In a production system, you would modify ChatSession to accept and use correlation_id
+            response = chat_session.send(query)
+
+            # Alternatively, you could use the LLMBroker directly with correlation_id:
+            # messages = [LLMMessage(role=MessageRole.User, content=query)]
+            # response = llm_broker.generate(messages, tools=[date_tool], correlation_id=correlation_id)
+
+            print(response)
+
+    # After the user exits, display tracer event summary
+    print("\nTracer System Summary")
+    print("=" * 80)
+    print(f"You just had a conversation with an LLM, and the tracer recorded everything!")
+
+    # Get all events
+    all_events = tracer.get_events()
+    print(f"Total events recorded: {len(all_events)}")
+    print_tracer_events(all_events)
+
+    # Show how to filter events by type
+    print("\nYou can filter events by type:")
+
+    llm_calls = tracer.get_events(event_type=LLMCallTracerEvent)
+    print(f"LLM Call Events: {len(llm_calls)}")
+    if llm_calls:
+        print(f"Example: {llm_calls[0].printable_summary()}")
+
+    llm_responses = tracer.get_events(event_type=LLMResponseTracerEvent)
+    print(f"LLM Response Events: {len(llm_responses)}")
+    if llm_responses:
+        print(f"Example: {llm_responses[0].printable_summary()}")
+
+    tool_calls = tracer.get_events(event_type=ToolCallTracerEvent)
+    print(f"Tool Call Events: {len(tool_calls)}")
+    if tool_calls:
+        print(f"Example: {tool_calls[0].printable_summary()}")
+
+    # Show the last few events
+    print("\nThe last few events:")
+    last_events = tracer.get_last_n_tracer_events(3)
+    print_tracer_events(last_events)
+
+    # Show how to use time-based filtering
+    print("\nYou can also filter events by time range:")
+    print("Example: tracer.get_events(start_time=start_timestamp, end_time=end_timestamp)")
+
+    # Demonstrate filtering events by correlation_id
+    print("\nFiltering events by correlation_id:")
+    print("This is a powerful feature that allows you to trace all events related to a specific request")
+
+    # If we have any conversation turns, show events for the first turn
+    if conversation_correlation_ids:
+        # Get the correlation_id for the first turn
+        first_turn_id = 1
+        first_correlation_id = conversation_correlation_ids.get(first_turn_id)
+
+        if first_correlation_id:
+            print(f"\nEvents for conversation turn {first_turn_id} (correlation_id: {first_correlation_id[:8]}...):")
+
+            # Define a filter function that checks the correlation_id
+            def filter_by_correlation_id(event):
+                return event.correlation_id == first_correlation_id
+
+            # Get all events with this correlation_id
+            related_events = tracer.get_events(filter_func=filter_by_correlation_id)
+
+            if related_events:
+                print(f"Found {len(related_events)} related events")
+                print_tracer_events(related_events)
+
+                # Show how this helps trace the flow of a request
+                print("\nThe correlation_id allows you to trace the complete flow of a request:")
+                print("1. From the initial LLM call")
+                print("2. To the LLM response")
+                print("3. To any tool calls triggered by the LLM")
+                print("4. And any subsequent LLM calls with the tool results")
+                print("\nThis creates a complete audit trail for debugging and observability.")
+            else:
+                print("No events found with this correlation_id. This is unexpected and may indicate an issue.")
+
+    # Show how to extract specific information from events
+    if tool_calls:
+        print("\nDetailed analysis example - Tool usage stats:")
+        tool_names = {}
+        for event in tool_calls:
+            tool_name = event.tool_name
+            tool_names[tool_name] = tool_names.get(tool_name, 0) + 1
+
+        print("Tool usage frequency:")
+        for tool_name, count in tool_names.items():
+            print(f"  - {tool_name}: {count} calls")
+
+
+if __name__ == "__main__":
+    main()

mojentic/agents/simple_recursive_agent.py

@@ -8,17 +8,16 @@ from typing import List, Optional
 
 from pydantic import BaseModel
 
-from mojentic.llm.gateways.models import LLMMessage
+from mojentic.llm.chat_session import ChatSession
 from mojentic.llm.llm_broker import LLMBroker
 from mojentic.llm.tools.llm_tool import LLMTool
-from mojentic.llm.chat_session import ChatSession
 
 
-class ProblemState(BaseModel):
+class GoalState(BaseModel):
     """
     Represents the state of a problem-solving process.
     """
-    problem: str
+    goal: str
     iteration: int = 0
     max_iterations: int = 5
     solution: Optional[str] = None
@@ -29,10 +28,10 @@ class SolverEvent(BaseModel):
     """
     Base class for solver events.
     """
-    state: ProblemState
+    state: GoalState
 
 
-class ProblemSubmittedEvent(SolverEvent):
+class GoalSubmittedEvent(SolverEvent):
     """
     Event triggered when a problem is submitted for solving.
     """
@@ -46,14 +45,14 @@ class IterationCompletedEvent(SolverEvent):
     response: str
 
 
-class ProblemSolvedEvent(SolverEvent):
+class GoalAchievedEvent(SolverEvent):
     """
     Event triggered when a problem is solved.
     """
     pass
 
 
-class ProblemFailedEvent(SolverEvent):
+class GoalFailedEvent(SolverEvent):
     """
     Event triggered when a problem cannot be solved.
     """
@@ -168,7 +167,7 @@ class SimpleRecursiveAgent:
         )
 
         # Set up event handlers
-        self.emitter.subscribe(ProblemSubmittedEvent, self._handle_problem_submitted)
+        self.emitter.subscribe(GoalSubmittedEvent, self._handle_problem_submitted)
         self.emitter.subscribe(IterationCompletedEvent, self._handle_iteration_completed)
 
     async def solve(self, problem: str) -> str:
@@ -189,7 +188,7 @@ class SimpleRecursiveAgent:
         solution_future = asyncio.Future()
 
         # Create the initial problem state
-        state = ProblemState(problem=problem, max_iterations=self.max_iterations)
+        state = GoalState(goal=problem, max_iterations=self.max_iterations)
 
         # Define handlers for completion events
         async def handle_solution_event(event):
@@ -197,12 +196,12 @@ class SimpleRecursiveAgent:
                 solution_future.set_result(event.state.solution)
 
         # Subscribe to completion events
-        self.emitter.subscribe(ProblemSolvedEvent, handle_solution_event)
-        self.emitter.subscribe(ProblemFailedEvent, handle_solution_event)
+        self.emitter.subscribe(GoalAchievedEvent, handle_solution_event)
+        self.emitter.subscribe(GoalFailedEvent, handle_solution_event)
         self.emitter.subscribe(TimeoutEvent, handle_solution_event)
 
         # Start the solving process
-        self.emitter.emit(ProblemSubmittedEvent(state=state))
+        self.emitter.emit(GoalSubmittedEvent(state=state))
 
         # Wait for the solution or timeout
         try:
@@ -215,13 +214,13 @@ class SimpleRecursiveAgent:
                 self.emitter.emit(TimeoutEvent(state=state))
             return timeout_message
 
-    async def _handle_problem_submitted(self, event: ProblemSubmittedEvent):
+    async def _handle_problem_submitted(self, event: GoalSubmittedEvent):
         """
         Handle a problem submitted event.
 
         Parameters
         ----------
-        event : ProblemSubmittedEvent
+        event : GoalSubmittedEvent
             The problem submitted event to handle
         """
         # Start the first iteration
@@ -243,31 +242,31 @@ class SimpleRecursiveAgent:
         if "FAIL".lower() in response.lower():
             state.solution = f"Failed to solve after {state.iteration} iterations:\n{response}"
             state.is_complete = True
-            self.emitter.emit(ProblemFailedEvent(state=state))
+            self.emitter.emit(GoalFailedEvent(state=state))
             return
         elif "DONE".lower() in response.lower():
             state.solution = response
             state.is_complete = True
-            self.emitter.emit(ProblemSolvedEvent(state=state))
+            self.emitter.emit(GoalAchievedEvent(state=state))
             return
 
         # Check if we've reached the maximum number of iterations
         if state.iteration >= state.max_iterations:
             state.solution = f"Best solution after {state.max_iterations} iterations:\n{response}"
             state.is_complete = True
-            self.emitter.emit(ProblemSolvedEvent(state=state))
+            self.emitter.emit(GoalAchievedEvent(state=state))
             return
 
         # If the problem is not solved and we haven't reached max_iterations, continue with next iteration
         await self._process_iteration(state)
 
-    async def _process_iteration(self, state: ProblemState):
+    async def _process_iteration(self, state: GoalState):
         """
         Process a single iteration of the problem-solving process.
 
         Parameters
         ----------
-        state : ProblemState
+        state : GoalState
             The current state of the problem-solving process
         """
         # Increment the iteration counter
@@ -276,7 +275,7 @@ class SimpleRecursiveAgent:
         # Create a prompt for the LLM
         prompt = f"""
 Given the user request:
-{state.problem}
+{state.goal}
 
 Use the tools at your disposal to act on their request. You may wish to create a step-by-step plan for more complicated requests.
 

mojentic/dispatcher.py

@@ -1,6 +1,7 @@
 import logging
 import threading
 from time import sleep
+from typing import Optional, Type
 from uuid import uuid4
 
 import structlog
@@ -11,12 +12,16 @@ logger = structlog.get_logger()
 
 
 class Dispatcher:
-    def __init__(self, router, shared_working_memory=None, batch_size=5):
+    def __init__(self, router, shared_working_memory=None, batch_size=5, tracer=None):
         self.router = router
         self.batch_size = batch_size
         self.event_queue = []
         self._stop_event = threading.Event()
         self._thread = threading.Thread(target=self._dispatch_events)
+        
+        # Use null_tracer if no tracer is provided
+        from mojentic.tracer import null_tracer
+        self.tracer = tracer or null_tracer
 
         logger.debug("Starting event dispatch thread")
         self._thread.start()
@@ -44,6 +49,17 @@ class Dispatcher:
                     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
                         received_events = agent.receive_event(event)
                         logger.debug(f"Agent {agent} returned {len(events)} events")
                         events.extend(received_events)

mojentic/llm/gateways/openai_message_adapter_spec.py

@@ -92,13 +92,13 @@ class DescribeOpenAIMessagesAdapter:
             When adapting to OpenAI format
             Then it should convert to the correct format with structured content array
             """
-            # Mock the open function to avoid reading actual files
-            mock_file = mocker.mock_open(read_data=b'fake_image_data')
-            mocker.patch('builtins.open', mock_file)
-
-            # Mock base64 encoding to return a predictable value
-            mock_b64encode = mocker.patch('base64.b64encode')
-            mock_b64encode.return_value = b'ZmFrZV9pbWFnZV9kYXRhX2VuY29kZWQ='  # 'fake_image_data_encoded' in base64
+            # Patch our own methods that encapsulate external library calls
+            mocker.patch('mojentic.llm.gateways.openai_messages_adapter.read_file_as_binary', 
+                         return_value=b'fake_image_data')
+            mocker.patch('mojentic.llm.gateways.openai_messages_adapter.encode_base64', 
+                         return_value='ZmFrZV9pbWFnZV9kYXRhX2VuY29kZWQ=')
+            mocker.patch('mojentic.llm.gateways.openai_messages_adapter.get_image_type', 
+                         side_effect=lambda path: 'jpg' if path.endswith('.jpg') else 'png')
 
             image_paths = ["/path/to/image1.jpg", "/path/to/image2.png"]
             messages = [LLMMessage(role=MessageRole.User, content="What's in these images?", image_paths=image_paths)]

mojentic/llm/gateways/openai_messages_adapter.py

@@ -10,6 +10,53 @@ from mojentic.llm.gateways.models import LLMMessage, MessageRole
 logger = structlog.get_logger()
 
 
+def read_file_as_binary(file_path: str) -> bytes:
+    """Read a file as binary data.
+
+    This function encapsulates the external library call to open() so it can be mocked in tests.
+
+    Args:
+        file_path: Path to the file to read
+
+    Returns:
+        Binary content of the file
+    """
+    with open(file_path, "rb") as file:
+        return file.read()
+
+
+def encode_base64(data: bytes) -> str:
+    """Encode binary data as base64 string.
+
+    This function encapsulates the external library call to base64.b64encode() so it can be mocked in tests.
+
+    Args:
+        data: Binary data to encode
+
+    Returns:
+        Base64-encoded string
+    """
+    return base64.b64encode(data).decode('utf-8')
+
+
+def get_image_type(file_path: str) -> str:
+    """Determine image type from file extension.
+
+    This function encapsulates the external library call to os.path.splitext() so it can be mocked in tests.
+
+    Args:
+        file_path: Path to the image file
+
+    Returns:
+        Image type (e.g., 'jpg', '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
+
+
 def adapt_messages_to_openai(messages: List[LLMMessage]):
     new_messages: List[dict[str, Any]] = []
     for m in messages:
@@ -25,21 +72,17 @@ def adapt_messages_to_openai(messages: List[LLMMessage]):
                 # Add each image as a base64-encoded URL
                 for image_path in m.image_paths:
                     try:
-                        with open(image_path, "rb") as image_file:
-                            base64_image = base64.b64encode(image_file.read()).decode('utf-8')
-
-                            # Determine image type from file extension
-                            _, ext = os.path.splitext(image_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
-
-                            content.append({
-                                "type": "image_url",
-                                "image_url": {
-                                    "url": f"data:image/{image_type};base64,{base64_image}"
-                                }
-                            })
+                        # Use our encapsulated methods instead of direct library calls
+                        binary_data = read_file_as_binary(image_path)
+                        base64_image = encode_base64(binary_data)
+                        image_type = get_image_type(image_path)
+
+                        content.append({
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/{image_type};base64,{base64_image}"
+                            }
+                        })
                     except Exception as e:
                         logger.error("Failed to encode image", error=str(e), image_path=image_path)
 

mojentic/llm/llm_broker.py

@@ -1,9 +1,11 @@
 import json
+import time
 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
@@ -21,8 +23,10 @@ class LLMBroker():
     adapter: LLMGateway
     tokenizer: TokenizerGateway
     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.
 
@@ -36,8 +40,15 @@ class LLMBroker():
         tokenizer
             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.
         """
         self.model = model
+
+        # Use null_tracer if no tracer is provided
+        from mojentic.tracer import null_tracer
+        self.tracer = tracer or null_tracer
+
         if tokenizer is None:
             self.tokenizer = TokenizerGateway()
         else:
@@ -47,7 +58,8 @@ class LLMBroker():
         else:
             self.adapter = gateway
 
-    def generate(self, messages: List[LLMMessage], tools=None, temperature=1.0, num_ctx=32768, num_predict=-1) -> str:
+    def generate(self, messages: List[LLMMessage], tools=None, temperature=1.0, num_ctx=32768, num_predict=-1, 
+              correlation_id: str = None) -> str:
         """
         Generate a text response from the LLM.
 
@@ -64,6 +76,8 @@ class LLMBroker():
             The number of context tokens to use. Defaults to 32768.
         num_predict : int
             The number of tokens to predict. Defaults to no limit.
+        correlation_id : str
+            UUID string that is copied from cause-to-affect for tracing events.
 
         Returns
         -------
@@ -73,6 +87,23 @@ class LLMBroker():
         approximate_tokens = len(self.tokenizer.encode(self._content_to_count(messages)))
         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]
+
+        # Record LLM call in tracer
+        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, 
+            temperature,
+            tools=tools_for_tracer,
+            source=type(self),
+            correlation_id=correlation_id
+        )
+
+        # Measure call duration for audit
+        start_time = time.time()
+
         result: LLMGatewayResponse = self.adapter.complete(
             model=self.model,
             messages=messages,
@@ -81,6 +112,19 @@ class LLMBroker():
             num_ctx=num_ctx,
             num_predict=num_predict)
 
+        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
+        self.tracer.record_llm_response(
+            self.model,
+            result.content,
+            tool_calls=tool_calls_for_tracer,
+            call_duration_ms=call_duration_ms,
+            source=type(self),
+            correlation_id=correlation_id
+        )
+
         if result.tool_calls and tools is not None:
             logger.info("Tool call requested")
             for tool_call in result.tool_calls:
@@ -89,13 +133,29 @@ class LLMBroker():
                                 None):
                     logger.info('Calling function', function=tool_call.name)
                     logger.info('Arguments:', arguments=tool_call.arguments)
+
+                    # Get the arguments before calling the tool
+                    tool_arguments = tool_call.arguments
+
+                    # Call the tool
                     output = tool.run(**tool_call.arguments)
+
+                    # Record tool call in tracer
+                    self.tracer.record_tool_call(
+                        tool_call.name,
+                        tool_arguments,
+                        output,
+                        caller="LLMBroker",
+                        source=type(self),
+                        correlation_id=correlation_id
+                    )
+
                     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)
+                    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)
@@ -111,7 +171,7 @@ class LLMBroker():
         return content
 
     def generate_object(self, messages: List[LLMMessage], object_model: Type[BaseModel], temperature=1.0, num_ctx=32768,
-                        num_predict=-1) -> BaseModel:
+                        num_predict=-1, correlation_id: str = None) -> BaseModel:
         """
         Generate a structured response from the LLM and return it as an object.
 
@@ -127,6 +187,8 @@ class LLMBroker():
             The number of context tokens to use. Defaults to 32768.
         num_predict : int
             The number of tokens to predict. Defaults to no limit.
+        correlation_id : str
+            UUID string that is copied from cause-to-affect for tracing events.
 
         Returns
         -------
@@ -135,6 +197,37 @@ class LLMBroker():
         """
         approximate_tokens = len(self.tokenizer.encode(self._content_to_count(messages)))
         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]
+
+        # Record LLM call in tracer
+        self.tracer.record_llm_call(
+            self.model, 
+            messages_for_tracer, 
+            temperature,
+            tools=None,
+            source=type(self),
+            correlation_id=correlation_id
+        )
+
+        # 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)
+
+        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.dict()) if hasattr(result.object, "dict") else str(result.object)
+        self.tracer.record_llm_response(
+            self.model,
+            f"Structured response: {object_str}",
+            call_duration_ms=call_duration_ms,
+            source=type(self),
+            correlation_id=correlation_id
+        )
+
         return result.object