mojentic 0.4.2__py3-none-any.whl → 0.5.1__py3-none-any.whl

_examples/current_datetime_tool_example.py

@@ -0,0 +1,28 @@
+from mojentic.llm.gateways.models import LLMMessage
+from mojentic.llm.llm_broker import LLMBroker
+from mojentic.llm.tools.current_datetime import CurrentDateTimeTool
+
+# Create an LLM broker with a specified model
+# You can change the model to any supported model
+llm = LLMBroker(model="qwen2.5:7b")  # Using the same model as in simple_tool.py
+
+# Create our custom tool
+datetime_tool = CurrentDateTimeTool()
+
+# Generate a response with tool assistance
+result = llm.generate(
+    messages=[LLMMessage(content="What time is it right now? Also, what day of the week is it today?")],
+    tools=[datetime_tool]
+)
+
+print("LLM Response:")
+print(result)
+
+# You can also try with a custom format string
+result = llm.generate(
+    messages=[LLMMessage(content="Tell me the current date in a friendly format, like 'Monday, January 1, 2023'")],
+    tools=[datetime_tool]
+)
+
+print("\nLLM Response with custom format:")
+print(result)

_examples/design_analysis.py

@@ -0,0 +1,42 @@
+from pathlib import Path
+
+from mojentic.llm.gateways import OllamaGateway
+from mojentic.llm.gateways.models import LLMMessage
+
+llmg = OllamaGateway()
+
+
+def complete(prompt: str):
+    response = llmg.complete(
+        model="gemma3:27b",
+        messages=[
+            LLMMessage(
+                content=prompt.strip(),
+                image_paths=[
+                    str(Path.cwd() / "images" / "screen_cap.png")
+                ]
+            )
+        ],
+    )
+    return response.content
+
+
+# It's quite good at extracting text from images
+result = complete("Extract the text from the attached image in markdown format.")
+print(result)
+
+# It's not bad at extracting and structuring the text it finds in images
+result = complete("""
+Extract the title and text boxes from the attached image in the form of a JSON object.
+Use descriptive key names like `title` or `bullet` or `footer`. In the values, use html
+but don't attempt to convert all of the visual formatting, just simple formatting like
+paragraphs, bold, or italic.
+""")
+print(result)
+
+# Gemma3 is not very good at determining hex colours :)
+result = complete("""
+Extract the colours from the attached image in the form of a JSON object, where the key
+is the description of how the colour is used, and the value is the colour in hex format.
+""")
+print(result)

_examples/ensures_files_exist.py

@@ -0,0 +1,58 @@
+from pathlib import Path
+import sys
+import os
+
+from mojentic.llm.message_composers import MessageBuilder
+
+# Get the project root directory (2 levels up from the current script)
+project_root = Path(os.path.dirname(os.path.abspath(__file__))).parent.parent
+
+# Test adding non-existent image
+print("Testing adding non-existent image:")
+non_existent_image = project_root / 'src' / '_examples' / 'images' / 'non_existent_image.jpg'
+
+try:
+    message_builder = MessageBuilder("Testing non-existent image")
+    message_builder.add_image(non_existent_image)
+    print("ERROR: Expected FileNotFoundError was not raised")
+    sys.exit(1)
+except FileNotFoundError as e:
+    print(f"Success: Caught expected exception: {e}")
+
+# Test adding non-existent file
+print("\nTesting adding non-existent file:")
+non_existent_file = project_root / 'src' / '_examples' / 'non_existent_file.py'
+
+try:
+    message_builder = MessageBuilder("Testing non-existent file")
+    message_builder.add_file(non_existent_file)
+    print("ERROR: Expected FileNotFoundError was not raised")
+    sys.exit(1)
+except FileNotFoundError as e:
+    print(f"Success: Caught expected exception: {e}")
+
+# Test adding existing image
+print("\nTesting adding existing image:")
+existing_image = project_root / 'src' / '_examples' / 'images' / 'xbox-one.jpg'
+
+try:
+    message_builder = MessageBuilder("Testing existing image")
+    message_builder.add_image(existing_image)
+    print("Success: Added existing image without exception")
+except FileNotFoundError as e:
+    print(f"ERROR: Unexpected exception: {e}")
+    sys.exit(1)
+
+# Test adding existing file
+print("\nTesting adding existing file:")
+existing_file = Path(__file__)  # This file itself (absolute path)
+
+try:
+    message_builder = MessageBuilder("Testing existing file")
+    message_builder.add_file(existing_file)
+    print("Success: Added existing file without exception")
+except FileNotFoundError as e:
+    print(f"ERROR: Unexpected exception: {e}")
+    sys.exit(1)
+
+print("\nAll tests passed!")

_examples/file_deduplication.py

@@ -0,0 +1,38 @@
+from pathlib import Path
+
+from mojentic.llm.message_composers import MessageBuilder
+
+# Test de-duplication of images
+print("Testing image de-duplication:")
+image_path = Path.cwd() / 'src' / '_examples' / 'images' / 'xbox-one.jpg'
+
+# Create a message builder and add the same image multiple times
+message_builder = MessageBuilder("Testing image de-duplication")
+message_builder.add_image(image_path)
+message_builder.add_image(image_path)  # Adding the same image again
+message_builder.add_images(image_path, image_path)  # Adding the same image twice more
+
+# Build the message and check the number of images
+message = message_builder.build()
+print(f"Number of images in message: {len(message.image_paths)}")
+print(f"Expected number of images: 1")
+print(f"De-duplication working: {len(message.image_paths) == 1}")
+
+# Test de-duplication of files
+print("\nTesting file de-duplication:")
+file_path = Path('file_deduplication.py')  # This file itself
+
+# Create a message builder and add the same file multiple times
+message_builder = MessageBuilder("Testing file de-duplication")
+message_builder.add_file(file_path)
+message_builder.add_file(file_path)  # Adding the same file again
+message_builder.add_files(file_path, file_path)  # Adding the same file twice more
+
+# Build the message and check the number of files
+message = message_builder.build()
+# Since we're using the file content in the message, we need to check file_paths directly
+print(f"Number of files in message_builder.file_paths: {len(message_builder.file_paths)}")
+print(f"Expected number of files: 1")
+print(f"De-duplication working: {len(message_builder.file_paths) == 1}")
+
+print("\nTest completed.")

_examples/image_broker.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+
+from mojentic.llm import LLMBroker
+from mojentic.llm.message_composers import MessagesBuilder, MessageBuilder
+
+llm = LLMBroker(model="gemma3:27b")
+
+message = MessageBuilder("What is in this image?") \
+    .add_image(Path.cwd() / 'images' / 'xbox-one.jpg') \
+    .build()
+
+result = llm.generate(messages=[message])
+
+print(result)

_examples/image_broker_splat.py

@@ -0,0 +1,50 @@
+from pathlib import Path
+
+from mojentic.llm import LLMBroker
+from mojentic.llm.message_composers import MessageBuilder
+
+# Initialize the LLM broker
+llm = LLMBroker(model="gemma3:27b")
+
+# Example 1: Adding multiple specific images using the splat operator
+print("Example 1: Adding multiple specific images")
+message1 = MessageBuilder("What are in these images?") \
+    .add_images(
+        Path.cwd() / 'images' / 'flash_rom.jpg',
+        Path.cwd() / 'images' / 'screen_cap.png'  # Assuming this file exists
+    ) \
+    .build()
+
+# Example 2: Adding all JPG images from a directory
+print("\nExample 2: Adding all JPG images from a directory")
+images_dir = Path.cwd() / 'images'
+message2 = MessageBuilder("Describe all these images:") \
+    .add_images(images_dir) \
+    .build()
+
+# Example 3: Using a glob pattern to add specific types of images
+print("\nExample 3: Using a glob pattern")
+message3 = MessageBuilder("What can you tell me about these images?") \
+    .add_images(Path.cwd() / 'images' / '*.jpg') \
+    .build()
+
+# Example 4: Combining different ways to specify images
+print("\nExample 4: Combining different ways to specify images")
+message4 = MessageBuilder("Analyze these images:") \
+    .add_images(
+        Path.cwd() / 'images' / 'xbox-one.jpg',  # Specific image
+        images_dir,                              # All JPGs in directory
+        Path.cwd() / 'images' / '*.png'          # All PNGs using glob pattern
+    ) \
+    .build()
+
+# Print the number of images added in each example
+print(f"Example 1: Added {len(message1.image_paths)} image(s)")
+print(f"Example 2: Added {len(message2.image_paths)} image(s)")
+print(f"Example 3: Added {len(message3.image_paths)} image(s)")
+print(f"Example 4: Added {len(message4.image_paths)} image(s)")
+
+# Generate a response using one of the messages (e.g., message1)
+print("\nGenerating response for Example 1...")
+result = llm.generate(messages=[message1])
+print(result)

_examples/list_models.py

@@ -1,6 +1,7 @@
 import os
 
 from mojentic.llm.gateways import OllamaGateway, OpenAIGateway
+from mojentic.llm.gateways.anthropic import AnthropicGateway
 
 ollama = OllamaGateway()
 print("Ollama Models:")
@@ -12,4 +13,11 @@ print()
 openai = OpenAIGateway(os.environ["OPENAI_API_KEY"])
 print("OpenAI Models:")
 for model in openai.get_available_models():
-    print(f"- {model}")
+    print(f"- {model}")
+
+print()
+
+anthropic = AnthropicGateway(os.environ["ANTHROPIC_API_KEY"])
+print("Anthropic Models:")
+for model in anthropic.get_available_models():
+    print(f"- {model}")

_examples/raw.py

@@ -0,0 +1,21 @@
+import os
+
+from anthropic import Anthropic
+
+client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
+
+anthropic_args = {
+    'model': "claude-3-5-haiku-20241022",
+    'system': "You are a helpful assistant.",
+    'messages': [
+        {
+            "role": "user",
+            "content": "Say hello world",
+        }
+    ],
+    'max_tokens': 2000,
+}
+
+response = client.messages.create(**anthropic_args)
+
+print(response.content[0].text)

mojentic/llm/__init__.py

@@ -1,3 +1,4 @@
 from .llm_broker import LLMBroker
 from .registry.llm_registry import LLMRegistry
 from .chat_session import ChatSession
+from .message_composers import MessageBuilder, FileTypeSensor

mojentic/llm/gateways/anthropic.py

@@ -0,0 +1,52 @@
+from typing import List
+
+import structlog
+from anthropic import Anthropic
+
+from mojentic.llm.gateways import LLMGateway
+from mojentic.llm.gateways.models import LLMGatewayResponse, LLMToolCall, MessageRole
+from mojentic.llm.gateways.anthropic_messages_adapter import adapt_messages_to_anthropic
+
+logger = structlog.get_logger()
+
+class AnthropicGateway(LLMGateway):
+    def __init__(self, api_key: str):
+        self.client = Anthropic(api_key=api_key)
+
+    def complete(self, **args) -> LLMGatewayResponse:
+
+        messages = args.get('messages')
+
+        system_messages = [m for m in messages if m.role == MessageRole.System]
+        user_messages = [m for m in messages if m.role == MessageRole.User]
+
+        anthropic_args = {
+            'model': args['model'],
+            'system': " " . join([m.content for m in system_messages]) if system_messages else None,
+            'messages': adapt_messages_to_anthropic(user_messages),
+        }
+
+        response = self.client.messages.create(
+            **anthropic_args,
+            temperature=args.get('temperature', 1.0),
+            max_tokens=args.get('num_predict', 2000),
+            # thinking={
+            #     "type": "enabled",
+            #     "budget_tokens": 32768,
+            # }
+        )
+
+        object = None
+        tool_calls: List[LLMToolCall] = []
+
+        return LLMGatewayResponse(
+            content=response.content[0].text,
+            object=object,
+            tool_calls=tool_calls,
+        )
+
+    def get_available_models(self) -> List[str]:
+        return sorted([m.id for m in self.client.models.list()])
+
+    def calculate_embeddings(self, text: str, model: str = "voyage-3-large") -> List[float]:
+        raise NotImplementedError("The Anthropic API does not support embedding generation.")

mojentic/llm/gateways/anthropic_messages_adapter.py

@@ -0,0 +1,72 @@
+import base64
+import json
+import os
+from typing import List, Any
+
+import structlog
+
+from mojentic.llm.gateways.models import LLMMessage, MessageRole
+
+logger = structlog.get_logger()
+
+
+def adapt_messages_to_anthropic(messages: List[LLMMessage]):
+    new_messages: List[dict[str, Any]] = []
+    for m in messages:
+        if m.role == MessageRole.System:
+            # System messages aren't supported by Anthropic
+            pass
+        elif m.role == MessageRole.User:
+            if m.image_paths is not None and len(m.image_paths) > 0:
+                # Create a content structure with text and images
+                content = []
+                if m.content:
+                    content.append({"type": "text", "text": m.content})
+
+                # 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",
+                                "source": {
+                                    "type": "base64",
+                                    "media_type": f"image/{image_type}",
+                                    "data": base64_image
+                                }
+                            })
+                    except Exception as e:
+                        logger.error("Failed to encode image", error=str(e), image_path=image_path)
+
+                new_messages.append({'role': 'user', 'content': content})
+            else:
+                new_messages.append({'role': 'user', 'content': m.content})
+        elif m.role == MessageRole.Assistant:
+            msg = {'role': 'assistant', 'content': m.content or ''}
+            # if m.tool_calls is not None:
+            #     msg['tool_calls'] = [{
+            #         'id': m.tool_calls[0].id,
+            #         'type': 'function',
+            #         'function': {
+            #             'name': m.tool_calls[0].name,
+            #             'arguments': json.dumps({k: v for k, v in m.tool_calls[0].arguments.items()})
+            #         }
+            #     }]
+            new_messages.append(msg)
+        # elif m.role == MessageRole.Tool:
+        #     new_messages.append({
+        #         'role': 'tool',
+        #         'content': m.content,
+        #         'tool_call_id': m.tool_calls[0].id
+        #     })
+        else:
+            logger.error("Unknown message role", role=m.role)
+    return new_messages

mojentic/llm/gateways/file_gateway.py

@@ -0,0 +1,55 @@
+from pathlib import Path
+from typing import Union
+
+
+class FileGateway:
+
+    def read(self, path: Union[Path, str]):
+        if isinstance(path, str):
+            path = Path(path)
+        with open(path, 'r') as file:
+            return file.read()
+
+    def exists(self, path: Union[Path, str]) -> bool:
+        """
+        Check if a file exists.
+
+        Parameters
+        ----------
+        path : Union[Path, str]
+            Path to the file
+
+        Returns
+        -------
+        bool
+            True if the file exists, False otherwise
+        """
+        if isinstance(path, str):
+            path = Path(path)
+        return path.exists()
+
+    def is_binary(self, path: Union[Path, str]) -> bool:
+        """
+        Check if a file is binary.
+
+        Parameters
+        ----------
+        path : Union[Path, str]
+            Path to the file
+
+        Returns
+        -------
+        bool
+            True if the file is binary, False otherwise
+        """
+        if isinstance(path, str):
+            path = Path(path)
+        try:
+            with open(path, 'rb') as file:
+                # Read the first 1024 bytes
+                chunk = file.read(1024)
+                # Check for null bytes, which are typically present in binary files
+                return b'\0' in chunk
+        except Exception:
+            # If there's an error reading the file, assume it's binary
+            return True

mojentic/llm/gateways/openai.py

@@ -21,7 +21,7 @@ class OpenAIGateway(LLMGateway):
         The OpenAI API key to use.
     """
 
-    def __init__(self, api_key):
+    def __init__(self, api_key: str):
         self.client = OpenAI(api_key=api_key)
 
     def complete(self, **args) -> LLMGatewayResponse:

mojentic/llm/message_composers.py

@@ -0,0 +1,317 @@
+from pathlib import Path
+from typing import Union, Dict, List, Optional
+
+from mojentic.llm.gateways.file_gateway import FileGateway
+from mojentic.llm.gateways.models import LLMMessage, MessageRole
+
+
+class FileTypeSensor:
+    """Maps file extensions to language declarations for markdown code-fence."""
+
+    def __init__(self):
+        """
+        Initialize the TypeSensor with a default mapping of file extensions to language declarations.
+
+        The TypeSensor is used to determine the appropriate language syntax highlighting 
+        for code blocks in markdown based on file extensions.
+        """
+        self.extension_map: Dict[str, str] = {
+            'c': 'c',
+            'cpp': 'c++',
+            'c++': 'c++',
+            'cxx': 'c++',
+            'h': 'c',
+            'objc': 'objective-c',
+            'swift': 'swift',
+            'cs': 'csharp',
+            'fs': 'fsharp',
+            'clj': 'clojure',
+            'py': 'python',
+            'java': 'java',
+            'kt': 'kotlin',
+            'rb': 'ruby',
+            'js': 'javascript',
+            'ts': 'typescript',
+            'rs': 'rust',
+            'go': 'go',
+            'cbl': 'cobol',
+            'html': 'html',
+            'css': 'css',
+            'json': 'json',
+            'csv': 'csv',
+            'xml': 'xml',
+            'md': 'markdown',
+        }
+        self.default_language = 'text'
+
+    def add_language(self, extension: str, language: str):
+        """
+        Add or update a mapping from a file extension to a language declaration.
+
+        Parameters
+        ----------
+        extension : str
+            The file extension without the leading dot (e.g., 'py', 'js')
+        language : str
+            The language identifier for markdown code-fence (e.g., 'python', 'javascript')
+        """
+        self.extension_map[extension] = language
+
+    def get_language(self, file_path: Path) -> str:
+        """
+        Determine the language declaration for a file based on its extension.
+
+        Parameters
+        ----------
+        file_path : Path
+            Path to the file
+
+        Returns
+        -------
+        str
+            Language declaration for markdown code-fence
+        """
+        ext = file_path.suffix[1:]  # Remove the leading dot
+        return self.extension_map.get(ext, self.default_language)
+
+
+class MessageBuilder():
+    """
+    A builder class for creating LLM messages with text content, images, and files.
+
+    This class provides a fluent interface for constructing messages to be sent to an LLM,
+    with support for adding text content, images, and file contents. It handles file reading,
+    language detection for syntax highlighting, and proper formatting of the message.
+    """
+    role: MessageRole
+    content: Optional[str]
+    image_paths: List[Path]
+    file_paths: List[Path]
+    type_sensor: FileTypeSensor
+
+    def __init__(self, content: str = None):
+        """
+        Initialize a new MessageBuilder with optional text content.
+
+        Parameters
+        ----------
+        content : str, optional
+            Optional text content for the message. If None, the message will only
+            contain added files and images.
+        """
+        self.role = MessageRole.User
+        self.content = content
+        self.image_paths = []
+        self.file_paths = []
+        self.type_sensor = FileTypeSensor()
+        self.file_gateway = FileGateway()
+
+    def _file_content_partial(self, file_path: Path) -> str:
+        """
+        Format the content of a file for inclusion in the message.
+
+        This method reads the file content and formats it with appropriate markdown code-fence
+        syntax highlighting based on the file extension.
+
+        Parameters
+        ----------
+        file_path : Path
+            Path to the file to be read and formatted
+
+        Returns
+        -------
+        str
+            Formatted string containing the file path and content with markdown code-fence
+        """
+        content = self.file_gateway.read(file_path)
+        return (f"File: {file_path}\n"
+                f"```{self.type_sensor.get_language(file_path)}\n"
+                f"{content.strip()}\n"
+                f"```\n")
+
+
+    def add_image(self, image_path: Union[str, Path]) -> "MessageBuilder":
+        """
+        Add a single image to the message.
+
+        Parameters
+        ----------
+        image_path : Union[str, Path]
+            Path to the image file. Can be a string or Path object.
+
+        Returns
+        -------
+        MessageBuilder
+            The MessageBuilder instance for method chaining.
+
+        Raises
+        ------
+        FileNotFoundError
+            If the specified image file does not exist.
+        """
+        if isinstance(image_path, str):
+            image_path = Path(image_path)
+        if not self.file_gateway.exists(image_path):
+            raise FileNotFoundError(f"Image file not found: {image_path}")
+        if image_path not in self.image_paths:
+            self.image_paths.append(image_path)
+        return self
+
+    def add_file(self, file_path: Union[str, Path]) -> "MessageBuilder":
+        """
+        Add a single file to the message.
+
+        Parameters
+        ----------
+        file_path : Union[str, Path]
+            Path to the file. Can be a string or Path object.
+
+        Returns
+        -------
+        MessageBuilder
+            The MessageBuilder instance for method chaining.
+
+        Raises
+        ------
+        FileNotFoundError
+            If the specified file does not exist.
+        """
+        if isinstance(file_path, str):
+            file_path = Path(file_path)
+        if not self.file_gateway.exists(file_path):
+            raise FileNotFoundError(f"File not found: {file_path}")
+        if file_path not in self.file_paths:
+            self.file_paths.append(file_path)
+        return self
+
+    def add_images(self, *image_paths: Union[str, Path]) -> "MessageBuilder":
+        """
+        Add multiple images to the message.
+
+        Parameters
+        ----------
+        *image_paths : Union[str, Path]
+            Variable number of image paths. Can be strings or Path objects.
+            Can include glob patterns like '*.jpg' to include all JPG and PNG images in a directory.
+
+        Returns
+        -------
+        MessageBuilder
+            The MessageBuilder instance for method chaining.
+        """
+        for path in image_paths:
+            path_obj = Path(path) if isinstance(path, str) else path
+
+            if path_obj.is_dir():
+                for ext in ['*.jpg', '*.png']:
+                    for img_path in path_obj.glob(ext):
+                        self.add_image(img_path)
+            elif '*' in str(path_obj):
+                parent_dir = path_obj.parent if path_obj.parent != Path('.') else Path.cwd()
+                for img_path in parent_dir.glob(path_obj.name):
+                    if img_path.is_file():
+                        self.add_image(img_path)
+            else:
+                self.add_image(path_obj)
+
+        return self
+
+    def add_files(self, *file_paths: Union[str, Path]) -> "MessageBuilder":
+        """
+        Add multiple text files to the message, ignoring binary files.
+
+        Parameters
+        ----------
+        *file_paths : Union[str, Path]
+            Variable number of file paths. Can be strings or Path objects.
+            Can include glob patterns like '*.txt' to include all text files in a directory.
+            If a directory is provided, all text files in the directory will be added.
+
+        Returns
+        -------
+        MessageBuilder
+            The MessageBuilder instance for method chaining.
+        """
+        for path in file_paths:
+            path_obj = Path(path) if isinstance(path, str) else path
+
+            if path_obj.is_dir():
+                # If a directory is provided, add all text files in the directory
+                for file_path in path_obj.glob('*'):
+                    if file_path.is_file() and not self.file_gateway.is_binary(file_path):
+                        self.add_file(file_path)
+            elif '*' in str(path_obj):
+                # If a glob pattern is provided, add all matching text files
+                parent_dir = path_obj.parent if path_obj.parent != Path('.') else Path.cwd()
+                for file_path in parent_dir.glob(path_obj.name):
+                    if file_path.is_file() and not self.file_gateway.is_binary(file_path):
+                        self.add_file(file_path)
+            else:
+                # If a single file is provided, add it if it's a text file
+                if path_obj.is_file() and not self.file_gateway.is_binary(path_obj):
+                    self.add_file(path_obj)
+
+        return self
+
+    def load_content(self, file_path: Union[str, Path], template_values: Optional[Dict[str, str]] = None) -> "MessageBuilder":
+        """
+        Load content from a file into the content field of the MessageBuilder.
+
+        This method reads the content of the specified file and sets it as the content
+        of the MessageBuilder, replacing any existing content. If template_values is provided,
+        placeholders in the content will be replaced with the corresponding values.
+
+        Parameters
+        ----------
+        file_path : Union[str, Path]
+            Path to the file to load content from. Can be a string or Path object.
+        template_values : Optional[Dict[str, str]], optional
+            Dictionary of values used to replace placeholders in the content.
+            For example, if the content contains "{greeting}" and template_values is
+            {"greeting": "Hello, World!"}, then "{greeting}" will be replaced with
+            "Hello, World!". Default is None.
+
+        Returns
+        -------
+        MessageBuilder
+            The MessageBuilder instance for method chaining.
+
+        Raises
+        ------
+        FileNotFoundError
+            If the specified file does not exist.
+        """
+        if isinstance(file_path, str):
+            file_path = Path(file_path)
+        if not self.file_gateway.exists(file_path):
+            raise FileNotFoundError(f"File not found: {file_path}")
+        self.content = self.file_gateway.read(file_path)
+
+        # Replace placeholders with template values if provided
+        if template_values:
+            for key, value in template_values.items():
+                self.content = self.content.replace(f"{{{key}}}", value)
+
+        return self
+
+    def build(self) -> LLMMessage:
+        """
+        Build the final LLMMessage from the accumulated content, images, and files.
+
+        This method combines all the content, file contents, and image paths into a single
+        LLMMessage object that can be sent to an LLM. If files have been added, their contents
+        will be formatted and included in the message content.
+
+        Returns
+        -------
+        LLMMessage
+            An LLMMessage object containing the message content and image paths.
+        """
+        if self.file_paths:
+            file_contents = [self._file_content_partial(p) for p in self.file_paths]
+            self.content = "\n\n".join(file_contents)
+        return LLMMessage(
+            role=self.role,
+            content=self.content,
+            image_paths=[str(p) for p in self.image_paths]
+        )

mojentic/llm/message_composers_spec.py

@@ -0,0 +1,387 @@
+from pathlib import Path
+
+import pytest
+
+from mojentic.llm.gateways.models import LLMMessage, MessageRole
+from mojentic.llm import MessageBuilder, FileTypeSensor
+
+
+@pytest.fixture
+def file_gateway(mocker):
+    file_gateway = mocker.MagicMock()
+    file_gateway.read.return_value = "test file content"
+    file_gateway.exists.return_value = True
+    file_gateway.is_binary.return_value = False
+    return file_gateway
+
+@pytest.fixture
+def file_path():
+    return Path("/path/to/file.txt")
+
+@pytest.fixture
+def whitespace_file_content():
+    return "\n\n  \n  test file content with whitespace  \n\n  \n"
+
+
+@pytest.fixture
+def message_builder(file_gateway):
+    builder = MessageBuilder()
+    builder.file_gateway = file_gateway
+    return builder
+
+
+class DescribeMessageBuilder:
+    """
+    Specification for the MessageBuilder class which helps build LLM messages.
+    """
+
+    class DescribeInitialization:
+        """
+        Specifications for MessageBuilder initialization
+        """
+
+        def should_initialize_with_default_values(self):
+            """
+            Given a new MessageBuilder
+            When it is initialized
+            Then it should have default values set
+            """
+            builder = MessageBuilder()
+
+            assert builder.role == MessageRole.User
+            assert builder.content is None
+            assert builder.image_paths == []
+            assert builder.file_paths == []
+            assert isinstance(builder.type_sensor, FileTypeSensor)
+            assert isinstance(builder.file_gateway, object)
+
+    class DescribeBuildMethod:
+        """
+        Specifications for the build method
+        """
+
+        def should_build_message_with_content(self, message_builder):
+            """
+            Given a MessageBuilder with content
+            When build is called
+            Then it should return a message with that content
+            """
+            message_builder.content = "Test content"
+
+            message = message_builder.build()
+
+            assert isinstance(message, LLMMessage)
+            assert message.content == "Test content"
+            assert message.role == MessageRole.User
+            assert message.image_paths == []
+
+        def should_build_message_with_role(self, message_builder):
+            """
+            Given a MessageBuilder with a specific role
+            When build is called
+            Then it should return a message with that role
+            """
+            message_builder.role = MessageRole.Assistant
+
+            message = message_builder.build()
+
+            assert message.role == MessageRole.Assistant
+
+        def should_build_message_with_image_paths(self, message_builder):
+            """
+            Given a MessageBuilder with image paths
+            When build is called
+            Then it should return a message with those image paths
+            """
+            message_builder.image_paths = [Path("/path/to/image1.jpg"), Path("/path/to/image2.jpg")]
+
+            message = message_builder.build()
+
+            assert message.image_paths == ["/path/to/image1.jpg", "/path/to/image2.jpg"]
+
+        def should_build_message_with_file_content(self, message_builder, file_gateway):
+            """
+            Given a MessageBuilder with file paths
+            When build is called
+            Then it should return a message with the file contents
+            """
+            file_path = Path("/path/to/file.txt")
+            message_builder.file_paths = [file_path]
+
+            message = message_builder.build()
+
+            file_gateway.read.assert_called_once_with(file_path)
+            assert "test file content" in message.content
+            assert "File: /path/to/file.txt" in message.content
+
+        def should_build_message_with_multiple_file_contents(self, message_builder, file_gateway):
+            """
+            Given a MessageBuilder with multiple file paths
+            When build is called
+            Then it should return a message with all file contents
+            """
+            file_path1 = Path("/path/to/file1.txt")
+            file_path2 = Path("/path/to/file2.txt")
+            message_builder.file_paths = [file_path1, file_path2]
+
+            message = message_builder.build()
+
+            assert file_gateway.read.call_count == 2
+            assert "File: /path/to/file1.txt" in message.content
+            assert "File: /path/to/file2.txt" in message.content
+
+    class DescribeFileContentPartial:
+        """
+        Specifications for the _file_content_partial method
+        """
+
+        def should_format_file_content_with_language(self, message_builder, file_gateway, mocker):
+            """
+            Given a MessageBuilder
+            When _file_content_partial is called
+            Then it should format the file content with the correct language
+            """
+            file_path = Path("/path/to/file.py")
+            mocker.patch.object(message_builder.type_sensor, 'get_language', return_value='python')
+
+            result = message_builder._file_content_partial(file_path)
+
+            file_gateway.read.assert_called_once_with(file_path)
+            assert "File: /path/to/file.py" in result
+            assert "```python" in result
+            assert "test file content" in result
+            assert "```" in result
+
+        def should_strip_whitespace_from_file_content(self, message_builder, file_gateway, file_path, whitespace_file_content, mocker):
+            """
+            Given a MessageBuilder
+            When _file_content_partial is called with content that has whitespace above and below
+            Then it should strip the whitespace when putting it in code fences
+            """
+            # Use the fixtures instead of creating file path and content directly
+            file_gateway.read.return_value = whitespace_file_content
+            mocker.patch.object(message_builder.type_sensor, 'get_language', return_value='text')
+
+            result = message_builder._file_content_partial(file_path)
+
+            file_gateway.read.assert_called_with(file_path)
+            assert "File: /path/to/file.txt" in result
+            assert "```text" in result
+            assert "test file content with whitespace" in result
+            assert "```" in result
+            # Verify that the content in the code fence doesn't have leading/trailing whitespace
+            lines = result.split('\n')
+            code_fence_start_index = lines.index("```text")
+            code_fence_end_index = lines.index("```", code_fence_start_index + 1)
+            code_content = lines[code_fence_start_index + 1:code_fence_end_index]
+            assert code_content == ["test file content with whitespace"]
+
+    class DescribeAddImageMethod:
+        """
+        Specifications for the add_image method
+        """
+
+        def should_add_image_path_to_list(self, message_builder):
+            """
+            Given a MessageBuilder
+            When add_image is called with a path
+            Then it should add the path to the image_paths list
+            """
+            image_path = Path("/path/to/image.jpg")
+
+            result = message_builder.add_image(image_path)
+
+            assert image_path in message_builder.image_paths
+            assert result is message_builder  # Returns self for method chaining
+
+        def should_convert_string_path_to_path_object(self, message_builder):
+            """
+            Given a MessageBuilder
+            When add_image is called with a string path
+            Then it should convert the string to a Path object
+            """
+            image_path_str = "/path/to/image.jpg"
+
+            message_builder.add_image(image_path_str)
+
+            assert Path(image_path_str) in message_builder.image_paths
+
+    class DescribeAddImagesMethod:
+        """
+        Specifications for the add_images method
+        """
+
+        def should_add_multiple_specific_images(self, message_builder):
+            """
+            Given a MessageBuilder
+            When add_images is called with multiple specific image paths
+            Then it should add all paths to the image_paths list
+            """
+            image_path1 = Path("/path/to/image1.jpg")
+            image_path2 = Path("/path/to/image2.jpg")
+
+            result = message_builder.add_images(image_path1, image_path2)
+
+            assert image_path1 in message_builder.image_paths
+            assert image_path2 in message_builder.image_paths
+            assert result is message_builder  # Returns self for method chaining
+
+        def should_add_all_jpg_images_from_directory(self, message_builder, mocker):
+            """
+            Given a MessageBuilder
+            When add_images is called with a directory path
+            Then it should add all JPG images in that directory
+            """
+            dir_path = Path("/path/to/images")
+            jpg_files = [Path("/path/to/images/image1.jpg"), Path("/path/to/images/image2.jpg")]
+
+            # Mock is_dir, glob, and exists methods
+            mocker.patch.object(Path, 'is_dir', return_value=True)
+            mocker.patch.object(Path, 'glob', return_value=jpg_files)
+            mocker.patch.object(Path, 'exists', return_value=True)
+
+            message_builder.add_images(dir_path)
+
+            assert jpg_files[0] in message_builder.image_paths
+            assert jpg_files[1] in message_builder.image_paths
+
+        def should_add_images_matching_glob_pattern(self, message_builder, mocker):
+            """
+            Given a MessageBuilder
+            When add_images is called with a path containing a wildcard
+            Then it should add all matching files
+            """
+            pattern_path = Path("/path/to/*.jpg")
+            matching_files = [Path("/path/to/image1.jpg"), Path("/path/to/image2.jpg")]
+
+            # Mock methods
+            mocker.patch.object(Path, 'is_dir', return_value=False)
+            mocker.patch.object(Path, 'glob', return_value=matching_files)
+            mocker.patch.object(Path, 'is_file', return_value=True)
+            mocker.patch.object(Path, 'exists', return_value=True)
+
+            # Mock the parent property and its glob method
+            parent_mock = mocker.MagicMock()
+            parent_mock.glob.return_value = matching_files
+            mocker.patch.object(Path, 'parent', parent_mock)
+
+            message_builder.add_images(pattern_path)
+
+            assert matching_files[0] in message_builder.image_paths
+            assert matching_files[1] in message_builder.image_paths
+
+    class DescribeLoadContentMethod:
+        """
+        Specifications for the load_content method
+        """
+
+        def should_load_content_from_file(self, message_builder, file_gateway, file_path):
+            """
+            Given a MessageBuilder
+            When load_content is called with a file path
+            Then it should load the content from the file and set it as the content
+            """
+            result = message_builder.load_content(file_path)
+
+            file_gateway.read.assert_called_once_with(file_path)
+            assert message_builder.content == "test file content"
+            assert result is message_builder  # Returns self for method chaining
+
+        def should_convert_string_path_to_path_object(self, message_builder, file_gateway):
+            """
+            Given a MessageBuilder
+            When load_content is called with a string path
+            Then it should convert the string to a Path object
+            """
+            file_path_str = "/path/to/file.txt"
+
+            message_builder.load_content(file_path_str)
+
+            file_gateway.read.assert_called_once_with(Path(file_path_str))
+
+        def should_raise_error_if_file_not_found(self, message_builder, file_gateway, file_path):
+            """
+            Given a MessageBuilder
+            When load_content is called with a non-existent file
+            Then it should raise a FileNotFoundError
+            """
+            file_gateway.exists.return_value = False
+
+            with pytest.raises(FileNotFoundError):
+                message_builder.load_content(file_path)
+
+        def should_replace_placeholders_with_template_values(self, message_builder, file_gateway, file_path):
+            """
+            Given a MessageBuilder
+            When load_content is called with a file path and template values
+            Then it should replace placeholders in the content with the corresponding values
+            """
+            # Set up the file content with placeholders
+            file_gateway.read.return_value = "Hello, {name}! Today is {day}."
+
+            # Call load_content with template values
+            template_values = {"name": "World", "day": "Monday"}
+            result = message_builder.load_content(file_path, template_values)
+
+            # Verify that placeholders were replaced
+            assert message_builder.content == "Hello, World! Today is Monday."
+            assert result is message_builder  # Returns self for method chaining
+
+
+class DescribeTypeSensor:
+    """
+    Specification for the TypeSensor class which maps file extensions to language declarations.
+    """
+
+    def should_initialize_with_default_mappings(self):
+        """
+        Given a new TypeSensor
+        When it is initialized
+        Then it should have default mappings
+        """
+        sensor = FileTypeSensor()
+
+        assert sensor.extension_map['py'] == 'python'
+        assert sensor.extension_map['js'] == 'javascript'
+        assert sensor.default_language == 'text'
+
+    def should_get_language_for_known_extension(self):
+        """
+        Given a TypeSensor
+        When get_language is called with a known extension
+        Then it should return the correct language
+        """
+        sensor = FileTypeSensor()
+        file_path = Path("/path/to/file.py")
+
+        language = sensor.get_language(file_path)
+
+        assert language == 'python'
+
+    def should_get_default_language_for_unknown_extension(self):
+        """
+        Given a TypeSensor
+        When get_language is called with an unknown extension
+        Then it should return the default language
+        """
+        sensor = FileTypeSensor()
+        file_path = Path("/path/to/file.unknown")
+
+        language = sensor.get_language(file_path)
+
+        assert language == 'text'
+
+    def should_add_new_language_mapping(self):
+        """
+        Given a TypeSensor
+        When add_language is called
+        Then it should add the new mapping
+        """
+        sensor = FileTypeSensor()
+        sensor.add_language('custom', 'customlang')
+
+        assert sensor.extension_map['custom'] == 'customlang'
+
+        file_path = Path("/path/to/file.custom")
+        language = sensor.get_language(file_path)
+        assert language == 'customlang'

mojentic/llm/tools/current_datetime.py

@@ -0,0 +1,47 @@
+from datetime import datetime
+from mojentic.llm.tools.llm_tool import LLMTool
+
+
+class CurrentDateTimeTool(LLMTool):
+    def run(self, format_string: str = "%Y-%m-%d %H:%M:%S") -> dict:
+        """
+        Returns the current date and time.
+        
+        Parameters
+        ----------
+        format_string : str, optional
+            The format string for the datetime, by default "%Y-%m-%d %H:%M:%S"
+            
+        Returns
+        -------
+        dict
+            A dictionary containing the current date and time
+        """
+        current_time = datetime.now()
+        formatted_time = current_time.strftime(format_string)
+        
+        return {
+            "current_datetime": formatted_time,
+            "timestamp": current_time.timestamp(),
+            "timezone": datetime.now().astimezone().tzname()
+        }
+    
+    @property
+    def descriptor(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": "get_current_datetime",
+                "description": "Get the current date and time. Useful when you need to know the current time or date.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "format_string": {
+                            "type": "string",
+                            "description": "Format string for the datetime (e.g., '%Y-%m-%d %H:%M:%S', '%A, %B %d, %Y'). Default is ISO format."
+                        }
+                    },
+                    "required": []
+                }
+            }
+        }

{mojentic-0.4.2.dist-info → mojentic-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mojentic
-Version: 0.4.2
+Version: 0.5.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
@@ -15,6 +15,7 @@ Requires-Dist: pydantic
 Requires-Dist: structlog
 Requires-Dist: ollama
 Requires-Dist: openai
+Requires-Dist: anthropic
 Requires-Dist: tiktoken
 Requires-Dist: parsedatetime
 Requires-Dist: pytz

{mojentic-0.4.2.dist-info → mojentic-0.5.1.dist-info}/RECORD

@@ -6,11 +6,18 @@ _examples/characterize_openai.py,sha256=JQQNjsHIEegjLAS3uzDmq_Ci_ZqXTqjcoVaC-rS_
 _examples/chat_session.py,sha256=7mLpH4IGQUgyyiY-fYbikDEiR5vEH-V5Z1qtB50d_qg,288
 _examples/chat_session_with_tool.py,sha256=vQfwR24ze5LIhn0MQTQr-JMVGi4Df_SgMXi1npKBt-g,376
 _examples/coding_file_tool.py,sha256=P4nCuFJ2UW0B_S7N03ImBNs-ADzBC7gb3ivCE0IJAqw,2570
+_examples/current_datetime_tool_example.py,sha256=Ihjwp9svf2rf4WUGOzs6L_rEqc5QhPfA6E9J4MGoGCQ,919
+_examples/design_analysis.py,sha256=66JxvnA065QV__WXpxJX_eTBDan34nGcKvao75UPLlw,1321
 _examples/embeddings.py,sha256=94DAMsMB35BU98hOfOeOsbqntcequFSdtaStox2hTvk,267
+_examples/ensures_files_exist.py,sha256=LAwX9YtUZGI6NT254PY7oC5yg6q-b9Q_Dez9gGrabQM,2009
+_examples/file_deduplication.py,sha256=jYayx4BCrk1uJwVBkjIXzguLQOWLREi4PBPzoK9LuOU,1665
 _examples/file_tool.py,sha256=F8xU7JdTScNzEXyGYqK6D_xQ28MbUXXm854WJmJkZo8,2214
 _examples/image_analysis.py,sha256=Kj49vLQD1DIpvv5P7rir4BqzsVCTgq-tfppqXcYVJkA,503
+_examples/image_broker.py,sha256=SoIphNj98zk1i7EQc7M2n2O_9ShDHwErmJ6jf67mzX0,355
+_examples/image_broker_splat.py,sha256=O7rzTFUka32if4G4VuXvhu1O-2lRMWfi0r8gjIE8-0Y,1934
 _examples/iterative_solver.py,sha256=ANGdC74ymHosVt6xUBjplkJl_W3ALTGxOkDpPLEDcm8,1331
-_examples/list_models.py,sha256=-QJzlxsOfwGQCGBDEbSOeUXA9CegA6KWnZu_TYzgstU,346
+_examples/list_models.py,sha256=8noMpGeXOdX5Pf0NXCt_CRurOKEg_5luhWveGntBhe8,578
+_examples/raw.py,sha256=Y2wvgynFuoUs28agE4ijsLYec8VRjiReklqlCH2lERs,442
 _examples/react.py,sha256=VQ-5MmjUXoHzBFPTV_JrocuOkDzZ8oyUUSYLlEToJ_0,939
 _examples/recursive_agent.py,sha256=NHmX8iQc1y43AKh1ZlAdV9OZ18qVaRRmSaKALE_KI6k,2966
 _examples/routed_send_response.py,sha256=FHhTy7y2f7GY_WAWZYqOnFqF1xeJTBuS5EjfJGsJ3S8,4146
@@ -47,19 +54,24 @@ mojentic/audit/event_store.py,sha256=uw5ploNym9CvI-WDeW3Y4qHJupPWBQaGrfrubxOfmpA
 mojentic/audit/event_store_spec.py,sha256=mCryZGWNXP9CmukvD3hUyQGs_7afjwbTK3RdT831Lzc,594
 mojentic/context/__init__.py,sha256=MKMP7ViQg8gMtLFvn9pf47XMc5beA5Wx95K4dEw93z8,55
 mojentic/context/shared_working_memory.py,sha256=Zt9MNGErEkDIUAaHvyhEOiTaEobI9l0MV4Z59lQFBr0,396
-mojentic/llm/__init__.py,sha256=EL2BRdSTAmPnv8MXOY0gQxRjNxs-4MvyJTGxNSd9iek,119
+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=8dEgqU-cPesPk4-jx36oPnvKxB34bLONbpyAW_2L-es,5884
 mojentic/llm/llm_broker_spec.py,sha256=zxOf3n8lXmUsowzlMcC-fRcOj_6wwDf7xIqLIV278nM,6979
+mojentic/llm/message_composers.py,sha256=IrTK6HrwAQtJRMW5spMRZmX4yKHl2SJdOkFYvhVXZYg,11305
+mojentic/llm/message_composers_spec.py,sha256=IXZ-Gl--1MGbmRkFNxucWTE7OZgLQHDDgw1WqMiZnF0,14762
 mojentic/llm/gateways/__init__.py,sha256=u7hXzngoRw_qbsJeiCH2NQ8vC2hF5DnqcXsfLVVPSSw,104
+mojentic/llm/gateways/anthropic.py,sha256=SsyNjq9QaXaqiMM43C9fwLp57hpgFtwNPJUnOAYVrtc,1788
+mojentic/llm/gateways/anthropic_messages_adapter.py,sha256=K6kEZeVt7E1endbGMLsh5l9SxC3Y5dnvbcejVqi_qUs,3003
 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=rHoXkaK5FOgWV5X-nkFhqubwk3sUQceJj3rBnxgqB-E,2335
 mojentic/llm/gateways/ollama.py,sha256=629fpZhC0zVCYqj360-PKTT4mQOLec5nzzvfMtS_mLQ,7581
 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=Jex-11SnzK58E1dHbNV8IVowY3UlhBbfl_YsEOTXSYA,4468
+mojentic/llm/gateways/openai.py,sha256=lYD2-DWt2W3fnmO7k8m29PD-wx4UDvcpPLduanj7tzc,4473
 mojentic/llm/gateways/openai_message_adapter_spec.py,sha256=IgXyio15nXn11MiFpUnAxm5fFpPU9m-c4qerd9gbpBA,6473
 mojentic/llm/gateways/openai_messages_adapter.py,sha256=Qwidv7C-wXDOEV8NYNjgIbHnJSlkcoK10FaeLos5zTc,2882
 mojentic/llm/gateways/tokenizer_gateway.py,sha256=ztuqfunlJ6xmyUPPHcC_69-kegiNJD6jdSEde7hDh2w,485
@@ -69,6 +81,7 @@ mojentic/llm/registry/models.py,sha256=XOZ0ElTL5mEicpcUk9lrVr0GRFgR1uFmDm7GGWm7y
 mojentic/llm/registry/populate_registry_from_ollama.py,sha256=YFlnyXW-Htveu8frPEntV-c_84Xoh_WhHGww5IqtPIg,2539
 mojentic/llm/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mojentic/llm/tools/ask_user_tool.py,sha256=WrI3uTzIEmr_S5Pl-rmvh2f3O2IIFYfnJ5zeel_59ck,972
+mojentic/llm/tools/current_datetime.py,sha256=JkIFlBBnvE4CMcgZizqITVTtNfL7zeeLxD54E7oMeC8,1585
 mojentic/llm/tools/date_resolver.py,sha256=Vs8kmAONKif03YcVMZ3TqkKyOJZiy1yEAOqjTcvJFA8,2048
 mojentic/llm/tools/date_resolver_spec.py,sha256=OaRvJyhSN8sgi75euk4E5ImaqUmvQdgZKY8u_NOiPWE,1185
 mojentic/llm/tools/file_manager.py,sha256=X8Uw4XtdH_Ol2EB3SN11-GYlC1diJ1cAywU9_EuCjCg,3788
@@ -78,8 +91,8 @@ mojentic/llm/tools/tool_wrapper_spec.py,sha256=LGqtre-g8SzOy3xtpbMdgTnw2EdYutmFO
 mojentic/llm/tools/web_search.py,sha256=L1accST2xMhGAkwHCLlIvKihTLiaYxl0NI6IqCJWGCw,1102
 mojentic/utils/__init__.py,sha256=lqECkkoFvHFttDnafRE1vvh0Dmna_lwupMToP5VvX5k,115
 mojentic/utils/formatting.py,sha256=bPrwwdluXdQ8TsFxfWtHNOeMWKNvAfABSoUnnA1g7c8,947
-mojentic-0.4.2.dist-info/licenses/LICENSE.md,sha256=txSgV8n5zY1W3NiF5HHsCwlaW0e8We1cSC6TuJUqxXA,1060
-mojentic-0.4.2.dist-info/METADATA,sha256=ObeHqe_V8iAVsxYDl02IUxluaHTGpGMRAaW3aS6bb5U,4910
-mojentic-0.4.2.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-mojentic-0.4.2.dist-info/top_level.txt,sha256=Q-BvPQ8Eu1jnEqK8Xkr6A9C8Xa1z38oPZRHuA5MCTqg,19
-mojentic-0.4.2.dist-info/RECORD,,
+mojentic-0.5.1.dist-info/licenses/LICENSE.md,sha256=txSgV8n5zY1W3NiF5HHsCwlaW0e8We1cSC6TuJUqxXA,1060
+mojentic-0.5.1.dist-info/METADATA,sha256=YIXg6guNrmTF3fBI225OEvBGuFro2uPOdmnGl5xi1Xc,4935
+mojentic-0.5.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+mojentic-0.5.1.dist-info/top_level.txt,sha256=Q-BvPQ8Eu1jnEqK8Xkr6A9C8Xa1z38oPZRHuA5MCTqg,19
+mojentic-0.5.1.dist-info/RECORD,,

{mojentic-0.4.2.dist-info → mojentic-0.5.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (77.0.3)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any