atomic-agents 2.7.4__tar.gz → 2.7.5__tar.gz

{atomic_agents-2.7.4 → atomic_agents-2.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomic-agents
-Version: 2.7.4
+Version: 2.7.5
 Summary: A versatile framework for creating and managing intelligent agents.
 Project-URL: Homepage, https://github.com/BrainBlend-AI/atomic-agents
 Project-URL: Repository, https://github.com/BrainBlend-AI/atomic-agents
@@ -18,7 +18,7 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.12
 Requires-Dist: gitpython<4.0.0,>=3.1.43
-Requires-Dist: instructor==1.13.0
+Requires-Dist: instructor==1.14.5
 Requires-Dist: litellm<2.0.0,>=1.50.0
 Requires-Dist: mcp[cli]>=1.6.0
 Requires-Dist: pydantic<3.0.0,>=2.11.0
@@ -96,12 +96,16 @@ To install Atomic Agents, you can use pip:
 pip install atomic-agents
 ```
 
-Make sure you also install the provider you want to use. For example, to use OpenAI and Groq, you can install the `openai` and `groq` packages:
+Make sure you also install the provider you want to use. Provider SDKs are available as instructor extras:
 
 ```bash
-pip install openai groq
+pip install instructor[groq]        # for Groq
+pip install instructor[anthropic]   # for Anthropic
+pip install instructor[google-genai] # for Gemini
 ```
 
+OpenAI is included by default. For a full list of supported providers, see the [Instructor docs](https://python.useinstructor.com/integrations/).
+
 This also installs the CLI *Atomic Assembler*, which can be used to download Tools (and soon also Agents and Pipelines).
 
 ### Quick Example
@@ -404,7 +408,7 @@ uv sync --all-packages
 
 ## Provider & Model Compatibility
 
-Atomic Agents depends on the [Instructor](https://github.com/jxnl/instructor) package. This means that in all examples where OpenAI is used, any other API supported by Instructor can also be used—such as Ollama, Groq, Mistral, Cohere, Anthropic, Gemini, and more. For a complete list, please refer to the Instructor documentation on its [GitHub page](https://github.com/jxnl/instructor).
+Atomic Agents depends on the [Instructor](https://github.com/jxnl/instructor) package. This means that in all examples where OpenAI is used, any other API supported by Instructor can also be used—such as Ollama, Groq, Mistral, Cohere, Anthropic, Gemini, [MiniMax](https://www.minimax.io/), and more. For a complete list, please refer to the Instructor documentation on its [GitHub page](https://github.com/jxnl/instructor).
 
 ## Contributing
 

{atomic_agents-2.7.4 → atomic_agents-2.7.5}/README.md

@@ -65,12 +65,16 @@ To install Atomic Agents, you can use pip:
 pip install atomic-agents
 ```
 
-Make sure you also install the provider you want to use. For example, to use OpenAI and Groq, you can install the `openai` and `groq` packages:
+Make sure you also install the provider you want to use. Provider SDKs are available as instructor extras:
 
 ```bash
-pip install openai groq
+pip install instructor[groq]        # for Groq
+pip install instructor[anthropic]   # for Anthropic
+pip install instructor[google-genai] # for Gemini
 ```
 
+OpenAI is included by default. For a full list of supported providers, see the [Instructor docs](https://python.useinstructor.com/integrations/).
+
 This also installs the CLI *Atomic Assembler*, which can be used to download Tools (and soon also Agents and Pipelines).
 
 ### Quick Example
@@ -373,7 +377,7 @@ uv sync --all-packages
 
 ## Provider & Model Compatibility
 
-Atomic Agents depends on the [Instructor](https://github.com/jxnl/instructor) package. This means that in all examples where OpenAI is used, any other API supported by Instructor can also be used—such as Ollama, Groq, Mistral, Cohere, Anthropic, Gemini, and more. For a complete list, please refer to the Instructor documentation on its [GitHub page](https://github.com/jxnl/instructor).
+Atomic Agents depends on the [Instructor](https://github.com/jxnl/instructor) package. This means that in all examples where OpenAI is used, any other API supported by Instructor can also be used—such as Ollama, Groq, Mistral, Cohere, Anthropic, Gemini, [MiniMax](https://www.minimax.io/), and more. For a complete list, please refer to the Instructor documentation on its [GitHub page](https://github.com/jxnl/instructor).
 
 ## Contributing
 

{atomic_agents-2.7.4 → atomic_agents-2.7.5}/atomic-agents/atomic_agents/agents/atomic_agent.py

@@ -63,7 +63,7 @@ class BasicChatOutputSchema(BaseIOSchema):
 
 
 class AgentConfig(BaseModel):
-    client: instructor.client.Instructor = Field(..., description="Client for interacting with the language model.")
+    client: instructor.core.client.Instructor = Field(..., description="Client for interacting with the language model.")
     model: str = Field(default="gpt-5-mini", description="The model to use for generating responses.")
     history: Optional[ChatHistory] = Field(default=None, description="History component for storing chat history.")
     system_prompt_generator: Optional[SystemPromptGenerator] = Field(
@@ -76,6 +76,14 @@ class AgentConfig(BaseModel):
         default="assistant",
         description="The role of the assistant in the conversation. Use 'model' for Gemini, 'assistant' for OpenAI/Anthropic.",
     )
+    tool_result_role: Optional[str] = Field(
+        default=None,
+        description=(
+            "The role to use for mid-conversation tool results and context injections. "
+            "Defaults to 'user' when assistant_role is 'model' (Gemini), otherwise 'system'. "
+            "Set explicitly to override auto-detection."
+        ),
+    )
     model_config = {"arbitrary_types_allowed": True}
     mode: Mode = Field(default=Mode.TOOLS, description="The Instructor mode used for structured outputs (TOOLS, JSON, etc.).")
     model_api_parameters: Optional[dict] = Field(None, description="Additional parameters passed to the API provider.")
@@ -170,6 +178,12 @@ class AtomicAgent[InputSchema: BaseIOSchema, OutputSchema: BaseIOSchema]:
         self.system_prompt_generator = config.system_prompt_generator or SystemPromptGenerator()
         self.system_role = config.system_role
         self.assistant_role = config.assistant_role
+        if config.tool_result_role is not None:
+            self.tool_result_role = config.tool_result_role
+        else:
+            # Auto-detect: Gemini drops mid-conversation "system" messages,
+            # so default to "user" for Gemini backends (identified by assistant_role="model")
+            self.tool_result_role = "user" if config.assistant_role == "model" else "system"
         self.initial_history = self.history.copy()
         self.current_user_input = None
         self.mode = config.mode
@@ -185,6 +199,21 @@ class AtomicAgent[InputSchema: BaseIOSchema, OutputSchema: BaseIOSchema]:
         """
         self.history = self.initial_history.copy()
 
+    def add_tool_result(self, content: BaseIOSchema) -> None:
+        """
+        Adds a tool result or context injection to the chat history using the
+        backend-appropriate role.
+
+        This method should be used instead of ``history.add_message("system", ...)``
+        when injecting tool execution results, resource contents, or other mid-conversation
+        context into the agent's history. It automatically uses the correct role for the
+        configured backend (e.g. ``"user"`` for Gemini, ``"system"`` for OpenAI/Anthropic).
+
+        Args:
+            content (BaseIOSchema): The tool result or context to inject.
+        """
+        self.history.add_message(self.tool_result_role, content)
+
     @property
     def input_schema(self) -> Type[BaseIOSchema]:
         """
@@ -247,7 +276,21 @@ class AtomicAgent[InputSchema: BaseIOSchema, OutputSchema: BaseIOSchema]:
 
     def _prepare_messages(self):
         self.messages = self._build_system_messages()
-        self.messages += self.history.get_history()
+        history = self.history.get_history()
+        # Remap "system" role messages in history when the backend doesn't support
+        # mid-conversation system messages (e.g. Gemini). The initial system prompt
+        # is built separately via _build_system_messages() and is unaffected.
+        if self.tool_result_role != "system":
+            logger = logging.getLogger(__name__)
+            for msg in history:
+                if msg["role"] == "system":
+                    logger.debug(
+                        "Remapping mid-conversation 'system' message to '%s' "
+                        "(backend does not support mid-conversation system messages).",
+                        self.tool_result_role,
+                    )
+                    msg["role"] = self.tool_result_role
+        self.messages += history
 
     def _get_completion_kwargs(self) -> Dict[str, Any]:
         """
@@ -444,7 +487,7 @@ class AtomicAgent[InputSchema: BaseIOSchema, OutputSchema: BaseIOSchema]:
             OutputSchema: The response from the chat agent.
         """
         assert not isinstance(
-            self.client, instructor.client.AsyncInstructor
+            self.client, instructor.core.client.AsyncInstructor
         ), "The run method is not supported for async clients. Use run_async instead."
         if user_input:
             self.history.initialize_turn()
@@ -477,7 +520,7 @@ class AtomicAgent[InputSchema: BaseIOSchema, OutputSchema: BaseIOSchema]:
             OutputSchema: The final response from the chat agent.
         """
         assert not isinstance(
-            self.client, instructor.client.AsyncInstructor
+            self.client, instructor.core.client.AsyncInstructor
         ), "The run_stream method is not supported for async clients. Use run_async instead."
         if user_input:
             self.history.initialize_turn()
@@ -519,7 +562,7 @@ class AtomicAgent[InputSchema: BaseIOSchema, OutputSchema: BaseIOSchema]:
             NotAsyncIterableError: If used as an async generator (in an async for loop).
                                    Use run_async_stream() method instead for streaming responses.
         """
-        assert isinstance(self.client, instructor.client.AsyncInstructor), "The run_async method is for async clients."
+        assert isinstance(self.client, instructor.core.client.AsyncInstructor), "The run_async method is for async clients."
         if user_input:
             self.history.initialize_turn()
             self.current_user_input = user_input
@@ -545,7 +588,7 @@ class AtomicAgent[InputSchema: BaseIOSchema, OutputSchema: BaseIOSchema]:
         Yields:
             OutputSchema: Partial responses from the chat agent.
         """
-        assert isinstance(self.client, instructor.client.AsyncInstructor), "The run_async method is for async clients."
+        assert isinstance(self.client, instructor.core.client.AsyncInstructor), "The run_async method is for async clients."
         if user_input:
             self.history.initialize_turn()
             self.current_user_input = user_input

{atomic_agents-2.7.4 → atomic_agents-2.7.5}/atomic-agents/atomic_agents/context/chat_history.py

@@ -4,7 +4,7 @@ from enum import Enum
 from pathlib import Path
 from typing import Dict, List, Optional, Type
 
-from instructor.multimodal import PDF, Image, Audio
+from instructor.processing.multimodal import PDF, Image, Audio
 from pydantic import BaseModel, Field
 
 from atomic_agents.base.base_io_schema import BaseIOSchema

{atomic_agents-2.7.4 → atomic_agents-2.7.5}/atomic-agents/tests/agents/test_atomic_agent.py

@@ -35,8 +35,8 @@ def mock_instructor():
 
 @pytest.fixture
 def mock_instructor_async():
-    # Changed spec from instructor.Instructor to instructor.client.AsyncInstructor
-    mock = Mock(spec=instructor.client.AsyncInstructor)
+    # Changed spec from instructor.Instructor to instructor.core.client.AsyncInstructor
+    mock = Mock(spec=instructor.core.client.AsyncInstructor)
 
     # Configure chat.completions structure
     mock.chat = Mock()
@@ -1087,3 +1087,115 @@ def test_get_context_token_count_multimodal_content(mock_get_token_counter, mock
     image_entry = next(item for item in content if item.get("type") == "image_url")
     assert "image_url" in image_entry
     assert image_entry["image_url"]["url"] == "https://example.com/test.png"
+
+
+# --- Tests for tool_result_role and Gemini system message remapping (issue #221) ---
+
+
+def test_tool_result_role_defaults_to_system_for_openai(mock_instructor, mock_system_prompt_generator):
+    config = AgentConfig(
+        client=mock_instructor,
+        model="gpt-5-mini",
+        system_prompt_generator=mock_system_prompt_generator,
+        assistant_role="assistant",
+    )
+    agent = AtomicAgent[BasicChatInputSchema, BasicChatOutputSchema](config)
+    assert agent.tool_result_role == "system"
+
+
+def test_tool_result_role_defaults_to_user_for_gemini(mock_instructor, mock_system_prompt_generator):
+    config = AgentConfig(
+        client=mock_instructor,
+        model="gemini-2.0-flash",
+        system_prompt_generator=mock_system_prompt_generator,
+        assistant_role="model",
+    )
+    agent = AtomicAgent[BasicChatInputSchema, BasicChatOutputSchema](config)
+    assert agent.tool_result_role == "user"
+
+
+def test_tool_result_role_explicit_override(mock_instructor, mock_system_prompt_generator):
+    config = AgentConfig(
+        client=mock_instructor,
+        model="gemini-2.0-flash",
+        system_prompt_generator=mock_system_prompt_generator,
+        assistant_role="model",
+        tool_result_role="system",
+    )
+    agent = AtomicAgent[BasicChatInputSchema, BasicChatOutputSchema](config)
+    assert agent.tool_result_role == "system"
+
+
+def test_add_tool_result_uses_correct_role(mock_instructor, mock_system_prompt_generator):
+    history = ChatHistory()
+    config = AgentConfig(
+        client=mock_instructor,
+        model="gemini-2.0-flash",
+        system_prompt_generator=mock_system_prompt_generator,
+        assistant_role="model",
+        history=history,
+    )
+    agent = AtomicAgent[BasicChatInputSchema, BasicChatOutputSchema](config)
+    content = BasicChatInputSchema(chat_message="Tool result data")
+    agent.add_tool_result(content)
+
+    messages = history.get_history()
+    assert len(messages) == 1
+    assert messages[0]["role"] == "user"
+
+
+def test_add_tool_result_uses_system_for_openai(mock_instructor, mock_system_prompt_generator):
+    history = ChatHistory()
+    config = AgentConfig(
+        client=mock_instructor,
+        model="gpt-5-mini",
+        system_prompt_generator=mock_system_prompt_generator,
+        history=history,
+    )
+    agent = AtomicAgent[BasicChatInputSchema, BasicChatOutputSchema](config)
+    content = BasicChatInputSchema(chat_message="Tool result data")
+    agent.add_tool_result(content)
+
+    messages = history.get_history()
+    assert len(messages) == 1
+    assert messages[0]["role"] == "system"
+
+
+def test_prepare_messages_remaps_system_to_user_for_gemini(mock_instructor, mock_system_prompt_generator):
+    history = ChatHistory()
+    config = AgentConfig(
+        client=mock_instructor,
+        model="gemini-2.0-flash",
+        system_prompt_generator=mock_system_prompt_generator,
+        assistant_role="model",
+        history=history,
+    )
+    agent = AtomicAgent[BasicChatInputSchema, BasicChatOutputSchema](config)
+
+    # Simulate legacy pattern: add_message("system", ...) directly on history
+    history.add_message("system", BasicChatInputSchema(chat_message="Tool output"))
+    agent._prepare_messages()
+
+    # The system prompt message (first) should keep its role,
+    # but mid-conversation "system" messages in history should be remapped to "user"
+    history_messages = [m for m in agent.messages if m.get("content") != mock_system_prompt_generator.generate_prompt()]
+    assert len(history_messages) == 1
+    assert history_messages[0]["role"] == "user"
+
+
+def test_prepare_messages_keeps_system_for_openai(mock_instructor, mock_system_prompt_generator):
+    history = ChatHistory()
+    config = AgentConfig(
+        client=mock_instructor,
+        model="gpt-5-mini",
+        system_prompt_generator=mock_system_prompt_generator,
+        history=history,
+    )
+    agent = AtomicAgent[BasicChatInputSchema, BasicChatOutputSchema](config)
+
+    history.add_message("system", BasicChatInputSchema(chat_message="Tool output"))
+    agent._prepare_messages()
+
+    history_messages = [m for m in agent.messages if m.get("content") != mock_system_prompt_generator.generate_prompt()]
+    assert len(history_messages) == 1
+    assert history_messages[0]["role"] == "system"

atomic_agents-2.7.5/atomic-agents/tests/agents/test_minimax_integration.py

@@ -0,0 +1,79 @@
+"""Integration tests for MiniMax provider with Atomic Agents.
+
+These tests require a valid MINIMAX_API_KEY environment variable.
+Run with: pytest -m integration tests/agents/test_minimax_integration.py
+"""
+
+import os
+import pytest
+import instructor
+from pydantic import Field
+from atomic_agents import (
+    AtomicAgent,
+    AgentConfig,
+    BasicChatInputSchema,
+    BasicChatOutputSchema,
+    BaseIOSchema,
+)
+
+pytestmark = pytest.mark.skipif(
+    not os.getenv("MINIMAX_API_KEY"),
+    reason="MINIMAX_API_KEY not set",
+)
+
+
+def _make_minimax_agent(model="MiniMax-M2.7", **agent_kwargs):
+    """Helper to create a MiniMax-backed agent."""
+    from openai import OpenAI
+
+    raw = OpenAI(
+        base_url="https://api.minimax.io/v1",
+        api_key=os.environ["MINIMAX_API_KEY"],
+    )
+    client = instructor.from_openai(raw, mode=instructor.Mode.JSON)
+    config = AgentConfig(client=client, model=model, mode=instructor.Mode.JSON, **agent_kwargs)
+    return AtomicAgent[BasicChatInputSchema, BasicChatOutputSchema](config)
+
+
+@pytest.mark.integration
+class TestMiniMaxLiveChat:
+    """Live integration tests against MiniMax API."""
+
+    def test_basic_chat(self):
+        """Test a basic chat completion with MiniMax."""
+        agent = _make_minimax_agent()
+        response = agent.run(BasicChatInputSchema(chat_message="Say hello in one word."))
+        assert response.chat_message
+        assert len(response.chat_message) > 0
+
+    def test_multi_turn_conversation(self):
+        """Test multi-turn conversation with MiniMax."""
+        agent = _make_minimax_agent()
+        r1 = agent.run(BasicChatInputSchema(chat_message="Remember the number 42."))
+        assert r1.chat_message  # first response should be non-empty
+        r2 = agent.run(BasicChatInputSchema(chat_message="What number did I ask you to remember?"))
+        assert r2.chat_message
+        # The model should recall "42" from the conversation history
+        assert "42" in r2.chat_message
+
+    def test_custom_output_schema(self):
+        """Test structured output with a custom schema via MiniMax."""
+        from openai import OpenAI
+
+        class AnalysisOutput(BaseIOSchema):
+            """Analysis output schema."""
+
+            sentiment: str = Field(..., description="One of: positive, negative, neutral")
+            confidence: float = Field(..., description="Confidence score between 0 and 1")
+
+        raw = OpenAI(
+            base_url="https://api.minimax.io/v1",
+            api_key=os.environ["MINIMAX_API_KEY"],
+        )
+        client = instructor.from_openai(raw, mode=instructor.Mode.JSON)
+        config = AgentConfig(client=client, model="MiniMax-M2.7", mode=instructor.Mode.JSON)
+        agent = AtomicAgent[BasicChatInputSchema, AnalysisOutput](config)
+
+        response = agent.run(BasicChatInputSchema(chat_message="I love this product, it's amazing!"))
+        assert response.sentiment in ("positive", "negative", "neutral")
+        assert 0 <= response.confidence <= 1

atomic_agents-2.7.5/atomic-agents/tests/agents/test_minimax_provider.py

@@ -0,0 +1,197 @@
+"""Unit tests for MiniMax provider integration with Atomic Agents."""
+
+import os
+import pytest
+from unittest.mock import Mock, patch
+import instructor
+from atomic_agents import (
+    AtomicAgent,
+    AgentConfig,
+    BasicChatInputSchema,
+    BasicChatOutputSchema,
+)
+from atomic_agents.context import SystemPromptGenerator
+
+
+def _create_minimax_client(api_key="test-key"):
+    """Create a MiniMax client via OpenAI-compatible interface."""
+    from openai import OpenAI
+
+    return instructor.from_openai(OpenAI(base_url="https://api.minimax.io/v1", api_key=api_key))
+
+
+class TestMiniMaxClientSetup:
+    """Tests for MiniMax client initialization."""
+
+    def test_minimax_client_creation(self):
+        """Test that MiniMax client can be created with correct base_url."""
+        from openai import OpenAI
+
+        raw_client = OpenAI(base_url="https://api.minimax.io/v1", api_key="test-key")
+        assert raw_client.base_url == "https://api.minimax.io/v1/"
+
+    def test_minimax_instructor_wrapping(self):
+        """Test that MiniMax client can be wrapped with instructor."""
+        client = _create_minimax_client()
+        assert isinstance(client, instructor.Instructor)
+
+    def test_minimax_agent_config(self):
+        """Test that AgentConfig accepts MiniMax client and model."""
+        client = _create_minimax_client()
+        config = AgentConfig(
+            client=client,
+            model="MiniMax-M2.7",
+        )
+        assert config.model == "MiniMax-M2.7"
+        assert config.assistant_role == "assistant"
+
+    def test_minimax_agent_initialization(self):
+        """Test that AtomicAgent can be initialized with MiniMax config."""
+        client = _create_minimax_client()
+        config = AgentConfig(
+            client=client,
+            model="MiniMax-M2.7",
+        )
+        agent = AtomicAgent[BasicChatInputSchema, BasicChatOutputSchema](config)
+        assert agent.model == "MiniMax-M2.7"
+        assert agent.assistant_role == "assistant"
+
+    def test_minimax_m25_model(self):
+        """Test that M2.5 model variant works."""
+        client = _create_minimax_client()
+        config = AgentConfig(
+            client=client,
+            model="MiniMax-M2.5",
+        )
+        agent = AtomicAgent[BasicChatInputSchema, BasicChatOutputSchema](config)
+        assert agent.model == "MiniMax-M2.5"
+
+    def test_minimax_m25_highspeed_model(self):
+        """Test that M2.5-highspeed model variant works."""
+        client = _create_minimax_client()
+        config = AgentConfig(
+            client=client,
+            model="MiniMax-M2.5-highspeed",
+        )
+        agent = AtomicAgent[BasicChatInputSchema, BasicChatOutputSchema](config)
+        assert agent.model == "MiniMax-M2.5-highspeed"
+
+
+class TestMiniMaxAgentBehavior:
+    """Tests for agent behavior with MiniMax provider."""
+
+    @pytest.fixture
+    def mock_minimax_instructor(self):
+        mock = Mock(spec=instructor.Instructor)
+        mock.chat = Mock()
+        mock.chat.completions = Mock()
+        mock.chat.completions.create = Mock(return_value=BasicChatOutputSchema(chat_message="MiniMax response"))
+        mock_response = BasicChatOutputSchema(chat_message="MiniMax response")
+        mock_iter = Mock()
+        mock_iter.__iter__ = Mock(return_value=iter([mock_response]))
+        mock.chat.completions.create_partial.return_value = mock_iter
+        return mock
+
+    @pytest.fixture
+    def minimax_agent(self, mock_minimax_instructor):
+        config = AgentConfig(
+            client=mock_minimax_instructor,
+            model="MiniMax-M2.7",
+        )
+        return AtomicAgent[BasicChatInputSchema, BasicChatOutputSchema](config)
+
+    def test_run_with_minimax(self, minimax_agent, mock_minimax_instructor):
+        """Test that agent.run works with MiniMax mock client."""
+        user_input = BasicChatInputSchema(chat_message="Hello from MiniMax test")
+        response = minimax_agent.run(user_input)
+        assert response.chat_message == "MiniMax response"
+        mock_minimax_instructor.chat.completions.create.assert_called_once()
+
+    def test_run_passes_correct_model(self, minimax_agent, mock_minimax_instructor):
+        """Test that the correct model name is passed to the API."""
+        user_input = BasicChatInputSchema(chat_message="Test")
+        minimax_agent.run(user_input)
+        call_kwargs = mock_minimax_instructor.chat.completions.create.call_args
+        assert call_kwargs.kwargs["model"] == "MiniMax-M2.7"
+
+    def test_run_stream_with_minimax(self, minimax_agent):
+        """Test that streaming works with MiniMax mock client."""
+        user_input = BasicChatInputSchema(chat_message="Stream test")
+        responses = list(minimax_agent.run_stream(user_input))
+        assert len(responses) == 1
+        assert responses[0].chat_message == "MiniMax response"
+
+    def test_history_tracking_with_minimax(self, minimax_agent):
+        """Test that chat history is properly tracked."""
+        user_input = BasicChatInputSchema(chat_message="First message")
+        minimax_agent.run(user_input)
+        history = minimax_agent.history.get_history()
+        assert len(history) == 2  # user + assistant
+
+    def test_system_prompt_with_minimax(self, mock_minimax_instructor):
+        """Test that system prompt works correctly with MiniMax."""
+        spg = SystemPromptGenerator(
+            background=["You are a helpful MiniMax-powered assistant."],
+        )
+        config = AgentConfig(
+            client=mock_minimax_instructor,
+            model="MiniMax-M2.7",
+            system_prompt_generator=spg,
+        )
+        agent = AtomicAgent[BasicChatInputSchema, BasicChatOutputSchema](config)
+        prompt = agent.system_prompt_generator.generate_prompt()
+        assert "MiniMax" in prompt
+
+    def test_model_api_parameters_with_minimax(self, mock_minimax_instructor):
+        """Test that custom API parameters are passed through."""
+        config = AgentConfig(
+            client=mock_minimax_instructor,
+            model="MiniMax-M2.7",
+            model_api_parameters={"temperature": 0.7, "max_tokens": 1024},
+        )
+        agent = AtomicAgent[BasicChatInputSchema, BasicChatOutputSchema](config)
+        assert agent.model_api_parameters["temperature"] == 0.7
+        assert agent.model_api_parameters["max_tokens"] == 1024
+
+    def test_minimax_reset_history(self, minimax_agent):
+        """Test that history reset works with MiniMax agent."""
+        user_input = BasicChatInputSchema(chat_message="Test")
+        minimax_agent.run(user_input)
+        minimax_agent.reset_history()
+        history = minimax_agent.history.get_history()
+        assert len(history) == 0
+
+
+class TestMiniMaxProviderSetup:
+    """Tests for the provider setup function from the quickstart example."""
+
+    def test_setup_client_minimax_by_number(self):
+        """Test setup_client with provider number '7'."""
+        import sys
+
+        sys.path.insert(
+            0,
+            os.path.join(
+                os.path.dirname(__file__),
+                "..",
+                "..",
+                "..",
+                "atomic-examples",
+                "quickstart",
+                "quickstart",
+            ),
+        )
+        # We can't import the example directly (it has top-level console input),
+        # but we can verify the pattern works
+        from openai import OpenAI
+
+        api_key = "test-minimax-key"
+        raw_client = OpenAI(base_url="https://api.minimax.io/v1", api_key=api_key)
+        client = instructor.from_openai(raw_client)
+        assert isinstance(client, instructor.Instructor)
+
+    def test_minimax_env_var_detection(self):
+        """Test that MINIMAX_API_KEY env var can be used."""
+        with patch.dict(os.environ, {"MINIMAX_API_KEY": "test-env-key"}):
+            api_key = os.getenv("MINIMAX_API_KEY")
+            assert api_key == "test-env-key"