mojentic 0.9.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

mojentic/async_dispatcher.py

@@ -1,7 +1,6 @@
 import asyncio
 import logging
 from collections import deque
-from typing import Optional, Type
 from uuid import uuid4
 
 import structlog

mojentic/async_dispatcher_spec.py

@@ -1,7 +1,7 @@
 import asyncio
 import pytest
 import pytest_asyncio
-from unittest.mock import AsyncMock, MagicMock
+from unittest.mock import MagicMock
 
 from mojentic.async_dispatcher import AsyncDispatcher
 from mojentic.event import Event, TerminateEvent

mojentic/context/__init__.py

@@ -1,5 +1,3 @@
 """
 Mojentic context module for managing shared working memory and context.
 """
-
-from .shared_working_memory import SharedWorkingMemory

mojentic/dispatcher.py

@@ -1,7 +1,6 @@
 import logging
 import threading
 from time import sleep
-from typing import Optional, Type
 from uuid import uuid4
 
 import structlog
@@ -18,7 +17,7 @@ class Dispatcher:
         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
@@ -49,16 +48,16 @@ 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)
-                            )
-                        
+                            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")

mojentic/llm/__init__.py

@@ -3,13 +3,13 @@ Mojentic LLM module for interacting with Large Language Models.
 """
 
 # Main LLM components
-from .llm_broker import LLMBroker
-from .chat_session import ChatSession
-from .message_composers import MessageBuilder, FileTypeSensor
-from .registry.llm_registry import LLMRegistry
+from .llm_broker import LLMBroker  # noqa: F401
+from .chat_session import ChatSession  # noqa: F401
+from .message_composers import MessageBuilder, FileTypeSensor  # noqa: F401
+from .registry.llm_registry import LLMRegistry  # noqa: F401
 
 # Re-export gateway components at the LLM level
-from .gateways.models import (
+from .gateways.models import (  # noqa: F401
     LLMMessage,
     LLMGatewayResponse,
     MessageRole

mojentic/llm/chat_session.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import Iterator, List, Optional
 
 from mojentic.llm import LLMBroker
 from mojentic.llm.gateways.models import LLMMessage, MessageRole
@@ -78,6 +78,29 @@ class ChatSession:
         self.insert_message(LLMMessage(role=MessageRole.Assistant, content=response))
         return response
 
+    def send_stream(self, query) -> Iterator[str]:
+        """
+        Send a query to the LLM and yield response chunks as they arrive. Records the query and
+        the full assembled response in the ongoing chat session after the stream is consumed.
+
+        Parameters
+        ----------
+        query : str
+            The query to send to the LLM.
+
+        Yields
+        ------
+        str
+            Content chunks from the LLM response as they arrive.
+        """
+        self.insert_message(LLMMessage(role=MessageRole.User, content=query))
+        accumulated = []
+        for chunk in self.llm.generate_stream(self.messages, tools=self.tools, temperature=self.temperature):
+            accumulated.append(chunk)
+            yield chunk
+        self._ensure_all_messages_are_sized()
+        self.insert_message(LLMMessage(role=MessageRole.Assistant, content="".join(accumulated)))
+
     def insert_message(self, message: LLMMessage):
         """
         Add a message onto the end of the chat session. If the total token count exceeds the max context, the oldest

mojentic/llm/chat_session_spec.py

@@ -94,6 +94,46 @@ class DescribeChatSession:
             assert chat_session.messages[1].content == "Query message 2"
             assert chat_session.messages[2].content == INTENDED_RESPONSE_MESSAGE
 
+    class DescribeStreamingSend:
+
+        def should_yield_content_chunks(self, chat_session):
+            chat_session.llm.generate_stream.return_value = iter(["Hello", " world"])
+
+            chunks = list(chat_session.send_stream("Query message"))
+
+            assert chunks == ["Hello", " world"]
+
+        def should_grow_message_history_after_stream_consumed(self, chat_session):
+            chat_session.llm.generate_stream.return_value = iter(["Response"])
+
+            list(chat_session.send_stream("Query message"))
+
+            assert len(chat_session.messages) == 3
+
+        def should_record_full_assembled_response_in_history(self, chat_session):
+            chat_session.llm.generate_stream.return_value = iter(["Hello", " world"])
+
+            list(chat_session.send_stream("Query message"))
+
+            assert chat_session.messages[2].content == "Hello world"
+
+        def should_record_user_message_in_history(self, chat_session):
+            chat_session.llm.generate_stream.return_value = iter(["Response"])
+
+            list(chat_session.send_stream("Query message"))
+
+            assert chat_session.messages[1].role == MessageRole.User
+            assert chat_session.messages[1].content == "Query message"
+
+        def should_respect_context_capacity(self, chat_session):
+            chat_session.llm.generate_stream.return_value = iter(["Response 1"])
+            list(chat_session.send_stream("Query 1"))
+
+            chat_session.llm.generate_stream.return_value = iter(["Response 2"])
+            list(chat_session.send_stream("Query 2"))
+
+            assert len(chat_session.messages) == 3
+
     class DescribeMessageRoles:
         """
         Specifications for message role handling

mojentic/llm/gateways/__init__.py

@@ -3,23 +3,24 @@ Mojentic LLM gateways module for connecting to various LLM providers.
 """
 
 # Gateway implementations
-from .llm_gateway import LLMGateway
-from .ollama import OllamaGateway
-from .openai import OpenAIGateway
-from .anthropic import AnthropicGateway
-from .file_gateway import FileGateway
-from .embeddings_gateway import EmbeddingsGateway
-from .tokenizer_gateway import TokenizerGateway
-
-# Message adapters
-from .anthropic_messages_adapter import adapt_messages_to_anthropic
-from .ollama_messages_adapter import adapt_messages_to_ollama
-from .openai_messages_adapter import adapt_messages_to_openai
+from mojentic.llm.gateways.llm_gateway import LLMGateway
+from mojentic.llm.gateways.ollama import OllamaGateway
+from mojentic.llm.gateways.openai import OpenAIGateway
+from mojentic.llm.gateways.anthropic import AnthropicGateway
+from mojentic.llm.gateways.tokenizer_gateway import TokenizerGateway
+from mojentic.llm.gateways.embeddings_gateway import EmbeddingsGateway
 
 # Common models
-from .models import (
-    LLMMessage,
-    MessageRole,
-    LLMGatewayResponse,
-    LLMToolCall
-)
+from mojentic.llm.gateways.models import LLMMessage, LLMToolCall, LLMGatewayResponse
+
+__all__ = [
+    "LLMGateway",
+    "OllamaGateway",
+    "OpenAIGateway",
+    "AnthropicGateway",
+    "TokenizerGateway",
+    "EmbeddingsGateway",
+    "LLMMessage",
+    "LLMToolCall",
+    "LLMGatewayResponse",
+]

mojentic/llm/gateways/anthropic.py

@@ -9,6 +9,7 @@ from mojentic.llm.gateways.anthropic_messages_adapter import adapt_messages_to_a
 
 logger = structlog.get_logger()
 
+
 class AnthropicGateway(LLMGateway):
     def __init__(self, api_key: str):
         self.client = Anthropic(api_key=api_key)

mojentic/llm/gateways/anthropic_messages_adapter.py

@@ -1,5 +1,4 @@
 import base64
-import json
 import os
 from typing import List, Any
 

mojentic/llm/gateways/llm_gateway.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, Type, Any
+from typing import List, Optional, Type
 
 from pydantic import BaseModel
 

mojentic/llm/gateways/ollama.py

@@ -9,6 +9,7 @@ from mojentic.llm.gateways.ollama_messages_adapter import adapt_messages_to_olla
 
 logger = structlog.get_logger()
 
+
 class StreamingResponse(BaseModel):
     """
     Wrapper for streaming response chunks.
@@ -23,6 +24,7 @@ class StreamingResponse(BaseModel):
     content: Optional[str] = None
     tool_calls: Optional[List] = None
 
+
 class OllamaGateway(LLMGateway):
     """
     This class is a gateway to the Ollama LLM service.

mojentic/llm/gateways/openai.py

@@ -1,19 +1,17 @@
 import json
 import os
 from itertools import islice
-from typing import Type, List, Iterable, Optional, Iterator, Dict
+from typing import List, Iterable, Optional, Iterator, Dict
 
 import numpy as np
 import structlog
 from openai import OpenAI, BadRequestError
-from pydantic import BaseModel
 
 from mojentic.llm.gateways.llm_gateway import LLMGateway
-from mojentic.llm.gateways.models import LLMToolCall, LLMGatewayResponse, LLMMessage
+from mojentic.llm.gateways.models import LLMToolCall, LLMGatewayResponse
 from mojentic.llm.gateways.openai_messages_adapter import adapt_messages_to_openai
 from mojentic.llm.gateways.openai_model_registry import get_model_registry, ModelType
 from mojentic.llm.gateways.tokenizer_gateway import TokenizerGateway
-from mojentic.llm.tools.llm_tool import LLMTool
 from mojentic.llm.gateways.ollama import StreamingResponse
 
 logger = structlog.get_logger()
@@ -77,10 +75,10 @@ class OpenAIGateway(LLMGateway):
         capabilities = self.model_registry.get_model_capabilities(model)
 
         logger.debug("Adapting parameters for model",
-                    model=model,
-                    model_type=capabilities.model_type.value,
-                    supports_tools=capabilities.supports_tools,
-                    supports_streaming=capabilities.supports_streaming)
+                     model=model,
+                     model_type=capabilities.model_type.value,
+                     supports_tools=capabilities.supports_tools,
+                     supports_streaming=capabilities.supports_streaming)
 
         # Handle token limit parameter conversion
         if 'max_tokens' in adapted_args:
@@ -89,16 +87,16 @@ class OpenAIGateway(LLMGateway):
                 # Convert max_tokens to max_completion_tokens for reasoning models
                 adapted_args[token_param] = adapted_args.pop('max_tokens')
                 logger.info("Converted token limit parameter for model",
-                           model=model,
-                           from_param='max_tokens',
-                           to_param=token_param,
-                           value=adapted_args[token_param])
+                            model=model,
+                            from_param='max_tokens',
+                            to_param=token_param,
+                            value=adapted_args[token_param])
 
         # Validate tool usage for models that don't support tools
         if 'tools' in adapted_args and adapted_args['tools'] and not capabilities.supports_tools:
             logger.warning("Model does not support tools, removing tool configuration",
-                          model=model,
-                          num_tools=len(adapted_args['tools']))
+                           model=model,
+                           num_tools=len(adapted_args['tools']))
             adapted_args['tools'] = None  # Set to None instead of removing the key
 
         # Handle temperature restrictions for specific models
@@ -108,18 +106,19 @@ class OpenAIGateway(LLMGateway):
             # Check if model supports temperature parameter at all
             if capabilities.supported_temperatures == []:
                 # Model doesn't support temperature parameter at all - remove it
-                logger.warning("Model does not support temperature parameter, removing it",
-                              model=model,
-                              requested_temperature=temperature)
+                logger.warning("Model does not support temperature parameter at all",
+                               model=model,
+                               requested_temperature=temperature)
                 adapted_args.pop('temperature', None)
             elif not capabilities.supports_temperature(temperature):
                 # Model supports temperature but not this specific value - use default
                 default_temp = 1.0
-                logger.warning("Model does not support requested temperature, using default",
-                              model=model,
-                              requested_temperature=temperature,
-                              default_temperature=default_temp,
-                              supported_temperatures=capabilities.supported_temperatures)
+                logger.warning(
+                    "Model does not support requested temperature, using default",
+                    model=model,
+                    requested_temperature=temperature,
+                    default_temperature=default_temp,
+                    supported_temperatures=capabilities.supported_temperatures)
                 adapted_args['temperature'] = default_temp
 
         return adapted_args
@@ -139,13 +138,12 @@ class OpenAIGateway(LLMGateway):
 
         # Warning for tools on reasoning models that don't support them
         if (capabilities.model_type == ModelType.REASONING and
-            not capabilities.supports_tools and
-            'tools' in args and args['tools']):
+                not capabilities.supports_tools and
+                'tools' in args and args['tools']):
             logger.warning(
                 "Reasoning model may not support tools",
                 model=model,
-                num_tools=len(args['tools'])
-            )
+                num_tools=len(args['tools']))
 
         # Validate token limits (check both possible parameter names)
         token_value = args.get('max_tokens') or args.get('max_completion_tokens')
@@ -155,8 +153,7 @@ class OpenAIGateway(LLMGateway):
                     "Requested token limit exceeds model maximum",
                     model=model,
                     requested=token_value,
-                    max_allowed=capabilities.max_output_tokens
-                )
+                    max_allowed=capabilities.max_output_tokens)
 
     def complete(self, **kwargs) -> LLMGatewayResponse:
         """
@@ -219,8 +216,8 @@ class OpenAIGateway(LLMGateway):
             adapted_args = self._adapt_parameters_for_model(model, args)
         except Exception as e:
             logger.error("Failed to adapt parameters for model",
-                        model=model,
-                        error=str(e))
+                         model=model,
+                         error=str(e))
             raise
 
         # Validate parameters after adaptation
@@ -251,25 +248,26 @@ class OpenAIGateway(LLMGateway):
             openai_args['max_completion_tokens'] = adapted_args['max_completion_tokens']
 
         logger.debug("Making OpenAI API call",
-                    model=openai_args['model'],
-                    has_tools='tools' in openai_args,
-                    has_object_model='response_format' in openai_args,
-                    token_param='max_completion_tokens' if 'max_completion_tokens' in openai_args else 'max_tokens')
+                     model=openai_args['model'],
+                     has_tools='tools' in openai_args,
+                     has_object_model='response_format' in openai_args,
+                     token_param='max_completion_tokens' if 'max_completion_tokens' in openai_args else 'max_tokens')
 
         try:
             response = completion(**openai_args)
         except BadRequestError as e:
             # Enhanced error handling for parameter issues
             if "max_tokens" in str(e) and "max_completion_tokens" in str(e):
-                logger.error("Parameter error detected - model may require different token parameter",
-                            model=model,
-                            error=str(e),
-                            suggestion="This model may be a reasoning model requiring max_completion_tokens")
+                logger.error(
+                    "Parameter error detected - model may require different token parameter",
+                    model=model,
+                    error=str(e),
+                    suggestion="This model may be a reasoning model requiring max_completion_tokens")
             raise e
         except Exception as e:
             logger.error("OpenAI API call failed",
-                        model=model,
-                        error=str(e))
+                         model=model,
+                         error=str(e))
             raise e
 
         object = None
@@ -281,11 +279,16 @@ class OpenAIGateway(LLMGateway):
                 if response_content is not None:
                     object = adapted_args['object_model'].model_validate_json(response_content)
                 else:
-                    logger.error("No response content available for object validation", object_model=adapted_args['object_model'])
+                    logger.error(
+                        "No response content available for object validation",
+                        object_model=adapted_args['object_model'])
             except Exception as e:
-                response_content = response.choices[0].message.content if response.choices else "No response content"
-                logger.error("Failed to validate model", error=str(e), response=response_content,
-                           object_model=adapted_args['object_model'])
+                response_content = (response.choices[0].message.content
+                                    if response.choices else "No response content")
+                logger.error("Failed to validate model",
+                             error=str(e),
+                             response=response_content,
+                             object_model=adapted_args['object_model'])
 
         if response.choices[0].message.tool_calls is not None:
             for t in response.choices[0].message.tool_calls:
@@ -363,8 +366,8 @@ class OpenAIGateway(LLMGateway):
             adapted_args = self._adapt_parameters_for_model(model, args)
         except Exception as e:
             logger.error("Failed to adapt parameters for model",
-                        model=model,
-                        error=str(e))
+                         model=model,
+                         error=str(e))
             raise
 
         # Validate parameters after adaptation
@@ -399,23 +402,24 @@ class OpenAIGateway(LLMGateway):
             openai_args['max_completion_tokens'] = adapted_args['max_completion_tokens']
 
         logger.debug("Making OpenAI streaming API call",
-                    model=openai_args['model'],
-                    has_tools='tools' in openai_args,
-                    token_param='max_completion_tokens' if 'max_completion_tokens' in openai_args else 'max_tokens')
+                     model=openai_args['model'],
+                     has_tools='tools' in openai_args,
+                     token_param='max_completion_tokens' if 'max_completion_tokens' in openai_args else 'max_tokens')
 
         try:
             stream = self.client.chat.completions.create(**openai_args)
         except BadRequestError as e:
             if "max_tokens" in str(e) and "max_completion_tokens" in str(e):
-                logger.error("Parameter error detected - model may require different token parameter",
-                            model=model,
-                            error=str(e),
-                            suggestion="This model may be a reasoning model requiring max_completion_tokens")
+                logger.error(
+                    "Parameter error detected - model may require different token parameter",
+                    model=model,
+                    error=str(e),
+                    suggestion="This model may be a reasoning model requiring max_completion_tokens")
             raise e
         except Exception as e:
             logger.error("OpenAI streaming API call failed",
-                        model=model,
-                        error=str(e))
+                         model=model,
+                         error=str(e))
             raise e
 
         # Accumulate tool calls as they stream in
@@ -477,9 +481,9 @@ class OpenAIGateway(LLMGateway):
                         complete_tool_calls.append(tool_call)
                     except json.JSONDecodeError as e:
                         logger.error("Failed to parse tool call arguments",
-                                   tool_name=tc['name'],
-                                   arguments=tc['arguments'],
-                                   error=str(e))
+                                     tool_name=tc['name'],
+                                     arguments=tc['arguments'],
+                                     error=str(e))
 
                 if complete_tool_calls:
                     # Convert to the format expected by ollama's tool calls for compatibility

mojentic/llm/gateways/openai_message_adapter_spec.py

@@ -93,11 +93,11 @@ class DescribeOpenAIMessagesAdapter:
             Then it should convert to the correct format with structured content array
             """
             # Patch our own methods that encapsulate external library calls
-            mocker.patch('mojentic.llm.gateways.openai_messages_adapter.read_file_as_binary', 
+            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', 
+            mocker.patch('mojentic.llm.gateways.openai_messages_adapter.encode_base64',
                          return_value='ZmFrZV9pbWFnZV9kYXRhX2VuY29kZWQ=')
-            mocker.patch('mojentic.llm.gateways.openai_messages_adapter.get_image_type', 
+            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"]

mojentic/llm/gateways/openai_model_registry.py

@@ -6,13 +6,13 @@ their specific parameter requirements and capabilities.
 """
 
 from enum import Enum
-from typing import Dict, Set, Optional, List, TYPE_CHECKING
+from typing import Dict, Optional, List, TYPE_CHECKING
 from dataclasses import dataclass
 
 import structlog
 
 if TYPE_CHECKING:
-    from mojentic.llm.gateways.openai import OpenAIGateway
+    pass
 
 logger = structlog.get_logger()
 
@@ -20,9 +20,9 @@ logger = structlog.get_logger()
 class ModelType(Enum):
     """Classification of OpenAI model types based on their capabilities and parameters."""
     REASONING = "reasoning"  # Models like o1, o3 that use max_completion_tokens
-    CHAT = "chat"           # Standard chat models that use max_tokens
-    EMBEDDING = "embedding" # Text embedding models
-    MODERATION = "moderation" # Content moderation models
+    CHAT = "chat"  # Standard chat models that use max_tokens
+    EMBEDDING = "embedding"  # Text embedding models
+    MODERATION = "moderation"  # Content moderation models
 
 
 @dataclass
@@ -346,6 +346,7 @@ class OpenAIModelRegistry:
 # Global registry instance
 _registry = OpenAIModelRegistry()
 
+
 def get_model_registry() -> OpenAIModelRegistry:
     """Get the global OpenAI model registry instance."""
-    return _registry
+    return _registry

mojentic/llm/gateways/openai_model_registry_spec.py

@@ -2,7 +2,6 @@
 Tests for the OpenAI Model Registry system.
 """
 
-import pytest
 from mojentic.llm.gateways.openai_model_registry import (
     OpenAIModelRegistry,
     ModelType,
@@ -178,4 +177,4 @@ class DescribeOpenAIModelRegistry:
         assert ModelType.REASONING.value == "reasoning"
         assert ModelType.CHAT.value == "chat"
         assert ModelType.EMBEDDING.value == "embedding"
-        assert ModelType.MODERATION.value == "moderation"
+        assert ModelType.MODERATION.value == "moderation"

mojentic/llm/gateways/openai_temperature_handling_spec.py

@@ -3,7 +3,7 @@ from unittest.mock import MagicMock
 
 from mojentic.llm.gateways.openai import OpenAIGateway
 from mojentic.llm.gateways.openai_model_registry import get_model_registry
-from mojentic.llm.gateways.models import LLMMessage, MessageRole, LLMGatewayResponse
+from mojentic.llm.gateways.models import LLMMessage, MessageRole
 
 
 @pytest.fixture
@@ -242,4 +242,4 @@ class DescribeModelCapabilitiesTemperatureRestrictions:
             capabilities = registry.get_model_capabilities(model)
             assert capabilities.supports_temperature(1.0) is True
             assert capabilities.supports_temperature(0.1) is False
-            assert capabilities.supported_temperatures == [1.0]
+            assert capabilities.supported_temperatures == [1.0]

mojentic/llm/llm_broker.py

@@ -7,7 +7,7 @@ from pydantic import BaseModel
 
 from mojentic.llm.gateways.llm_gateway import LLMGateway
 from mojentic.llm.gateways.models import MessageRole, LLMMessage, LLMGatewayResponse, LLMToolCall
-from mojentic.llm.gateways.ollama import OllamaGateway, StreamingResponse
+from mojentic.llm.gateways.ollama import OllamaGateway
 from mojentic.llm.gateways.tokenizer_gateway import TokenizerGateway
 from mojentic.tracer.tracer_system import TracerSystem
 
@@ -183,8 +183,8 @@ class LLMBroker():
         return result.content
 
     def generate_stream(self, messages: List[LLMMessage], tools=None, temperature=1.0, num_ctx=32768,
-                       num_predict=-1, max_tokens=16384,
-                       correlation_id: str = None) -> Iterator[str]:
+                        num_predict=-1, max_tokens=16384,
+                        correlation_id: str = None) -> Iterator[str]:
         """
         Generate a streaming text response from the LLM.
 
@@ -334,8 +334,10 @@ class LLMBroker():
                                    tool_calls=[tool_call]))
 
                     # Recursively stream the response after tool execution
-                    yield from self.generate_stream(messages, tools, temperature, num_ctx, num_predict,
-                                                   max_tokens, correlation_id=correlation_id)
+                    yield from self.generate_stream(
+                        messages, tools, temperature, num_ctx, num_predict,
+                        max_tokens, correlation_id=correlation_id
+                    )
                     return  # Exit after recursive call
                 else:
                     logger.warn('Function not found', function=tool_name)

mojentic/llm/llm_broker_spec.py

@@ -1,4 +1,3 @@
-from unittest.mock import MagicMock
 
 import pytest
 from pydantic import BaseModel
@@ -11,10 +10,12 @@ class SimpleModel(BaseModel):
     text: str
     number: int
 
+
 class NestedModel(BaseModel):
     title: str
     details: SimpleModel
 
+
 class ComplexModel(BaseModel):
     name: str
     items: list[SimpleModel]
@@ -120,7 +121,11 @@ class DescribeLLMBroker:
                 metadata={"key1": "value1", "key2": "value2"}
             )
             mock_gateway.complete.return_value = LLMGatewayResponse(
-                content='{"name": "test", "items": [{"text": "item1", "number": 1}, {"text": "item2", "number": 2}], "metadata": {"key1": "value1", "key2": "value2"}}',
+                content=(
+                    '{"name": "test", "items": [{"text": "item1", "number": 1}, '
+                    '{"text": "item2", "number": 2}], '
+                    '"metadata": {"key1": "value1", "key2": "value2"}}'
+                ),
                 object=mock_object,
                 tool_calls=[]
             )