mojentic 0.5.7__tar.gz → 0.6.1__tar.gz

{mojentic-0.5.7 → mojentic-0.6.1}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: mojentic
-Version: 0.5.7
+Version: 0.6.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/mojility/mojentic
-Project-URL: Issues, https://github.com/mojility/mojentic/issues
+Project-URL: Homepage, https://github.com/svetzal/mojentic
+Project-URL: Issues, https://github.com/svetzal/mojentic/issues
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
@@ -22,15 +22,26 @@ Requires-Dist: parsedatetime
 Requires-Dist: pytz
 Requires-Dist: serpapi
 Requires-Dist: colorama
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-spec; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-mock>=3.10.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: mkdocs; extra == "dev"
+Requires-Dist: mkdocstrings[python]; extra == "dev"
+Requires-Dist: griffe-fieldz; extra == "dev"
+Requires-Dist: mkdocs-material; extra == "dev"
+Requires-Dist: pymdown-extensions; extra == "dev"
 Dynamic: license-file
 
 # Mojentic
 
 Mojentic is a framework that provides a simple and flexible way to interact with Large Language Models (LLMs). It offers integration with various LLM providers and includes tools for structured output generation, task automation, and more. The future direction is to facilitate a team of agents, but the current focus is on robust LLM interaction capabilities.
 
-[![GitHub](https://img.shields.io/github/license/mojility/mojentic)](LICENSE.md)
+[![GitHub](https://img.shields.io/github/license/svetzal/mojentic)](LICENSE.md)
 [![Python Version](https://img.shields.io/badge/python-3.11%2B-blue)](https://www.python.org/downloads/)
-[![Documentation](https://img.shields.io/badge/docs-latest-brightgreen)](https://mojility.github.io/mojentic/)
+[![Documentation](https://img.shields.io/badge/docs-latest-brightgreen)](https://svetzal.github.io/mojentic/)
 
 ## 🚀 Features
 
@@ -57,7 +68,7 @@ pip install mojentic
 Or install from source
 
 ```bash
-git clone https://github.com/mojility/mojentic.git
+git clone https://github.com/svetzal/mojentic.git
 cd mojentic
 pip install -e .
 ```
@@ -123,18 +134,17 @@ The primary focus is currently on the `llm` module, which provides robust capabi
 
 ## 📚 Documentation
 
-Visit [the documentation](https://mojility.github.io/mojentic/) for comprehensive guides, API reference, and examples.
+Visit [the documentation](https://svetzal.github.io/mojentic/) for comprehensive guides, API reference, and examples.
 
 ## 🧪 Development
 
 ```bash
 # Clone the repository
-git clone https://github.com/mojility/mojentic.git
+git clone https://github.com/svetzal/mojentic.git
 cd mojentic
 
 # Install dependencies
-pip install -r requirements.txt
-pip install -r dev-requirements.txt
+pip install -e ".[dev]"
 
 # Run tests
 pytest

{mojentic-0.5.7 → mojentic-0.6.1}/README.md

@@ -2,9 +2,9 @@
 
 Mojentic is a framework that provides a simple and flexible way to interact with Large Language Models (LLMs). It offers integration with various LLM providers and includes tools for structured output generation, task automation, and more. The future direction is to facilitate a team of agents, but the current focus is on robust LLM interaction capabilities.
 
-[![GitHub](https://img.shields.io/github/license/mojility/mojentic)](LICENSE.md)
+[![GitHub](https://img.shields.io/github/license/svetzal/mojentic)](LICENSE.md)
 [![Python Version](https://img.shields.io/badge/python-3.11%2B-blue)](https://www.python.org/downloads/)
-[![Documentation](https://img.shields.io/badge/docs-latest-brightgreen)](https://mojility.github.io/mojentic/)
+[![Documentation](https://img.shields.io/badge/docs-latest-brightgreen)](https://svetzal.github.io/mojentic/)
 
 ## 🚀 Features
 
@@ -31,7 +31,7 @@ pip install mojentic
 Or install from source
 
 ```bash
-git clone https://github.com/mojility/mojentic.git
+git clone https://github.com/svetzal/mojentic.git
 cd mojentic
 pip install -e .
 ```
@@ -97,18 +97,17 @@ The primary focus is currently on the `llm` module, which provides robust capabi
 
 ## 📚 Documentation
 
-Visit [the documentation](https://mojility.github.io/mojentic/) for comprehensive guides, API reference, and examples.
+Visit [the documentation](https://svetzal.github.io/mojentic/) for comprehensive guides, API reference, and examples.
 
 ## 🧪 Development
 
 ```bash
 # Clone the repository
-git clone https://github.com/mojility/mojentic.git
+git clone https://github.com/svetzal/mojentic.git
 cd mojentic
 
 # Install dependencies
-pip install -r requirements.txt
-pip install -r dev-requirements.txt
+pip install -e ".[dev]"
 
 # Run tests
 pytest

{mojentic-0.5.7 → mojentic-0.6.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mojentic"
-version = "0.5.7"
+version = "0.6.1"
 authors = [
     { name = "Stacey Vetzal", email = "stacey@vetzal.com" },
 ]
@@ -27,6 +27,20 @@ dependencies = [
     "colorama",
 ]
 
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-spec",
+    "pytest-cov",
+    "pytest-mock>=3.10.0",
+    "flake8>=6.0.0",
+    "mkdocs",
+    "mkdocstrings[python]",
+    "griffe-fieldz",
+    "mkdocs-material",
+    "pymdown-extensions",
+]
+
 [build-system]
 requires = ["setuptools", "wheel"]
 build-backend = "setuptools.build_meta"
@@ -35,5 +49,5 @@ build-backend = "setuptools.build_meta"
 where = ["src"]
 
 [project.urls]
-Homepage = "https://github.com/mojility/mojentic"
-Issues = "https://github.com/mojility/mojentic/issues"
+Homepage = "https://github.com/svetzal/mojentic"
+Issues = "https://github.com/svetzal/mojentic/issues"

{mojentic-0.5.7 → mojentic-0.6.1}/src/_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)

mojentic-0.6.1/src/_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-0.5.7 → mojentic-0.6.1}/src/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-0.5.7 → mojentic-0.6.1}/src/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-0.5.7 → mojentic-0.6.1}/src/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-0.5.7 → mojentic-0.6.1}/src/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)