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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomic-agents
-Version: 2.7.1
+Version: 2.7.4
 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
@@ -321,6 +321,10 @@ For a complete list of examples, see the [examples directory](/atomic-examples/)
 
 ## 🚀 Version 2.0 Released!
 
+[![What's New in V2.0](./.assets/whats-new-v2-thumbnail.png)](https://www.youtube.com/watch?v=ro-pM2bPmr0)
+
+[**Watch: What's New in Atomic Agents V2.0**](https://www.youtube.com/watch?v=ro-pM2bPmr0)
+
 **Atomic Agents v2.0 is here with major improvements!** This release includes breaking changes that significantly improve the developer experience:
 
 ### Key Changes in v2.0:

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

@@ -290,6 +290,10 @@ For a complete list of examples, see the [examples directory](/atomic-examples/)
 
 ## 🚀 Version 2.0 Released!
 
+[![What's New in V2.0](./.assets/whats-new-v2-thumbnail.png)](https://www.youtube.com/watch?v=ro-pM2bPmr0)
+
+[**Watch: What's New in Atomic Agents V2.0**](https://www.youtube.com/watch?v=ro-pM2bPmr0)
+
 **Atomic Agents v2.0 is here with major improvements!** This release includes breaking changes that significantly improve the developer experience:
 
 ### Key Changes in v2.0:

{atomic_agents-2.7.1 → atomic_agents-2.7.4}/atomic-agents/atomic_agents/__init__.py

@@ -6,8 +6,10 @@ Atomic Agents - A modular framework for building AI agents.
 from .agents.atomic_agent import AtomicAgent, AgentConfig, BasicChatInputSchema, BasicChatOutputSchema
 from .base import BaseIOSchema, BaseTool, BaseToolConfig
 
-# Version info
-__version__ = "2.0.0"
+# Version info - read from pyproject.toml via package metadata
+from importlib.metadata import version as _version
+
+__version__ = _version("atomic-agents")
 
 __all__ = [
     "AtomicAgent",

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

@@ -249,6 +249,19 @@ class AtomicAgent[InputSchema: BaseIOSchema, OutputSchema: BaseIOSchema]:
         self.messages = self._build_system_messages()
         self.messages += self.history.get_history()
 
+    def _get_completion_kwargs(self) -> Dict[str, Any]:
+        """
+        Build kwargs for Instructor completion calls.
+
+        Instructor defaults `strict=True`, which forces enum fields to receive enum
+        instances instead of allowing Pydantic's normal coercion from strings. We
+        default to `strict=None` here so the output schema's own Pydantic behavior
+        applies unless callers explicitly override it via `model_api_parameters`.
+        """
+        completion_kwargs = dict(self.model_api_parameters)
+        completion_kwargs.setdefault("strict", None)
+        return completion_kwargs
+
     def _build_tools_definition(self) -> Optional[List[Dict[str, Any]]]:
         """
         Build the tools definition that Instructor sends for TOOLS mode.
@@ -443,7 +456,7 @@ class AtomicAgent[InputSchema: BaseIOSchema, OutputSchema: BaseIOSchema]:
             messages=self.messages,
             model=self.model,
             response_model=self.output_schema,
-            **self.model_api_parameters,
+            **self._get_completion_kwargs(),
         )
         self.history.add_message(self.assistant_role, response)
         self._prepare_messages()
@@ -477,18 +490,20 @@ class AtomicAgent[InputSchema: BaseIOSchema, OutputSchema: BaseIOSchema]:
             model=self.model,
             messages=self.messages,
             response_model=self.output_schema,
-            **self.model_api_parameters,
+            **self._get_completion_kwargs(),
             stream=True,
         )
 
+        last_response = None
         for partial_response in response_stream:
+            last_response = partial_response
             yield partial_response
 
-        full_response_content = self.output_schema(**partial_response.model_dump())
-        self.history.add_message(self.assistant_role, full_response_content)
-        self._prepare_messages()
-
-        return full_response_content
+        if last_response:
+            full_response_content = self.output_schema(**last_response.model_dump())
+            self.history.add_message(self.assistant_role, full_response_content)
+            self._prepare_messages()
+            return full_response_content
 
     async def run_async(self, user_input: Optional[InputSchema] = None) -> OutputSchema:
         """
@@ -513,7 +528,7 @@ class AtomicAgent[InputSchema: BaseIOSchema, OutputSchema: BaseIOSchema]:
         self._prepare_messages()
 
         response = await self.client.chat.completions.create(
-            model=self.model, messages=self.messages, response_model=self.output_schema, **self.model_api_parameters
+            model=self.model, messages=self.messages, response_model=self.output_schema, **self._get_completion_kwargs()
         )
 
         self.history.add_message(self.assistant_role, response)
@@ -542,7 +557,7 @@ class AtomicAgent[InputSchema: BaseIOSchema, OutputSchema: BaseIOSchema]:
             model=self.model,
             messages=self.messages,
             response_model=self.output_schema,
-            **self.model_api_parameters,
+            **self._get_completion_kwargs(),
             stream=True,
         )
 

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

@@ -204,12 +204,12 @@ class ChatHistory:
         """
         return self.current_turn_id
 
-    def delete_turn_id(self, turn_id: int):
+    def delete_turn_id(self, turn_id: str):
         """
         Delete messages from the history by its turn ID.
 
         Args:
-            turn_id (int): The turn ID of the message to delete.
+            turn_id (str): The turn ID of the message to delete.
 
         Returns:
             str: A success message with the deleted turn ID.

{atomic_agents-2.7.1 → atomic_agents-2.7.4}/atomic-agents/atomic_agents/utils/token_counter.py

@@ -147,12 +147,15 @@ class TokenCounter:
             raise TypeError(f"model must be a string, got {type(model).__name__}")
 
         try:
-            from litellm import get_max_tokens
+            from litellm import get_model_info
         except ImportError as e:
             raise ImportError("litellm is required for token counting. " "Install it with: pip install litellm") from e
 
         try:
-            return get_max_tokens(model)
+            info = get_model_info(model)
+            # Use max_input_tokens (context window) not max_tokens (output limit)
+            max_input = info.get("max_input_tokens")
+            return max_input if max_input is not None else info.get("max_tokens")
         except Exception as e:
             logger.warning(f"Could not determine max tokens for model '{model}': {e}")
             return None

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

@@ -1,6 +1,8 @@
 import pytest
 from unittest.mock import Mock, call, patch
+from enum import Enum
 from pydantic import BaseModel, Field
+from pydantic import ValidationError
 import instructor
 from atomic_agents import (
     BaseIOSchema,
@@ -148,6 +150,73 @@ def test_initialization_without_max_tokens(mock_instructor, mock_history, mock_s
     assert agent.model_api_parameters["max_tokens"] == 1024
 
 
+def test_run_uses_pydantic_default_strictness_for_enum_output(mock_history, mock_system_prompt_generator):
+    class Topic(Enum):
+        FOOD = "food"
+        OTHER = "other"
+
+    class EnumOutputSchema(BaseIOSchema):
+        """Output schema with an enum field for validation tests."""
+
+        topic: Topic = Field(...)
+
+    enum_instructor = Mock(spec=instructor.Instructor)
+    enum_instructor.chat = Mock()
+    enum_instructor.chat.completions = Mock()
+
+    def mock_create(*args, **kwargs):
+        return kwargs["response_model"].model_validate({"topic": "food"}, strict=kwargs["strict"])
+
+    enum_instructor.chat.completions.create.side_effect = mock_create
+
+    config = AgentConfig(
+        client=enum_instructor,
+        model="gpt-5-mini",
+        history=mock_history,
+        system_prompt_generator=mock_system_prompt_generator,
+    )
+    agent = AtomicAgent[BasicChatInputSchema, EnumOutputSchema](config)
+
+    result = agent.run()
+
+    assert result.topic is Topic.FOOD
+    assert enum_instructor.chat.completions.create.call_args.kwargs["strict"] is None
+
+
+def test_run_respects_explicit_strict_override_for_enum_output(mock_history, mock_system_prompt_generator):
+    class Topic(Enum):
+        FOOD = "food"
+        OTHER = "other"
+
+    class EnumOutputSchema(BaseIOSchema):
+        """Output schema with an enum field for validation tests."""
+
+        topic: Topic = Field(...)
+
+    enum_instructor = Mock(spec=instructor.Instructor)
+    enum_instructor.chat = Mock()
+    enum_instructor.chat.completions = Mock()
+
+    def mock_create(*args, **kwargs):
+        return kwargs["response_model"].model_validate({"topic": "food"}, strict=kwargs["strict"])
+
+    enum_instructor.chat.completions.create.side_effect = mock_create
+
+    config = AgentConfig(
+        client=enum_instructor,
+        model="gpt-5-mini",
+        history=mock_history,
+        system_prompt_generator=mock_system_prompt_generator,
+        model_api_parameters={"strict": True},
+    )
+    agent = AtomicAgent[BasicChatInputSchema, EnumOutputSchema](config)
+
+    with pytest.raises(ValidationError):
+        agent.run()
+
+    assert enum_instructor.chat.completions.create.call_args.kwargs["strict"] is True
+
+
 def test_initialization_system_role_equals_developer(mock_instructor, mock_history, mock_system_prompt_generator):
     config = AgentConfig(
         client=mock_instructor,

{atomic_agents-2.7.1 → atomic_agents-2.7.4}/atomic-agents/tests/utils/test_token_counter.py

@@ -114,19 +114,57 @@ class TestTokenCounter:
         # Should wrap text in a message
         mock_token_counter.assert_called_once_with(model="gpt-4", messages=[{"role": "user", "content": "Hello world"}])
 
-    @patch("litellm.get_max_tokens")
-    def test_get_max_tokens(self, mock_get_max_tokens):
-        mock_get_max_tokens.return_value = 8192
+    @patch("litellm.get_model_info")
+    def test_get_max_tokens(self, mock_get_model_info):
+        mock_get_model_info.return_value = {"max_input_tokens": 128000, "max_tokens": 16384}
+
+        counter = TokenCounter()
+        result = counter.get_max_tokens("gpt-4")
+
+        assert result == 128000
+        mock_get_model_info.assert_called_once_with("gpt-4")
+
+    @patch("litellm.get_model_info")
+    def test_get_max_tokens_falls_back_to_max_tokens(self, mock_get_model_info):
+        mock_get_model_info.return_value = {"max_tokens": 8192}
+
+        counter = TokenCounter()
+        result = counter.get_max_tokens("gpt-4")
+
+        assert result == 8192
+        mock_get_model_info.assert_called_once_with("gpt-4")
+
+    @patch("litellm.get_model_info")
+    def test_get_max_tokens_falls_back_when_max_input_tokens_is_none(self, mock_get_model_info):
+        mock_get_model_info.return_value = {"max_input_tokens": None, "max_tokens": 8192}
 
         counter = TokenCounter()
         result = counter.get_max_tokens("gpt-4")
 
         assert result == 8192
-        mock_get_max_tokens.assert_called_once_with("gpt-4")
 
-    @patch("litellm.get_max_tokens")
-    def test_get_max_tokens_unknown_model(self, mock_get_max_tokens):
-        mock_get_max_tokens.side_effect = Exception("Unknown model")
+    @patch("litellm.get_model_info")
+    def test_get_max_tokens_zero_input_tokens_returns_zero(self, mock_get_model_info):
+        """Ensure max_input_tokens=0 is not confused with 'missing'."""
+        mock_get_model_info.return_value = {"max_input_tokens": 0, "max_tokens": 4096}
+
+        counter = TokenCounter()
+        result = counter.get_max_tokens("custom-model")
+
+        assert result == 0
+
+    @patch("litellm.get_model_info")
+    def test_get_max_tokens_both_keys_missing(self, mock_get_model_info):
+        mock_get_model_info.return_value = {"model_name": "some-model"}
+
+        counter = TokenCounter()
+        result = counter.get_max_tokens("some-model")
+
+        assert result is None
+
+    @patch("litellm.get_model_info")
+    def test_get_max_tokens_unknown_model(self, mock_get_model_info):
+        mock_get_model_info.side_effect = Exception("Unknown model")
 
         counter = TokenCounter()
         result = counter.get_max_tokens("unknown-model")
@@ -162,11 +200,11 @@ class TestTokenCounter:
 
         assert "model is required" in str(exc_info.value)
 
-    @patch("litellm.get_max_tokens")
+    @patch("litellm.get_model_info")
     @patch("litellm.token_counter")
-    def test_count_context(self, mock_token_counter, mock_get_max_tokens):
+    def test_count_context(self, mock_token_counter, mock_get_model_info):
         mock_token_counter.side_effect = [30, 70]  # system, then history
-        mock_get_max_tokens.return_value = 8192
+        mock_get_model_info.return_value = {"max_input_tokens": 8192, "max_tokens": 4096}
 
         counter = TokenCounter()
         result = counter.count_context(
@@ -183,12 +221,12 @@ class TestTokenCounter:
         assert result.max_tokens == 8192
         assert result.utilization == pytest.approx(100 / 8192)
 
-    @patch("litellm.get_max_tokens")
+    @patch("litellm.get_model_info")
     @patch("litellm.token_counter")
-    def test_count_context_with_tools(self, mock_token_counter, mock_get_max_tokens):
+    def test_count_context_with_tools(self, mock_token_counter, mock_get_model_info):
         # system=30, history=70, empty_with_tools=60, empty_without_tools=10 -> tools=50
         mock_token_counter.side_effect = [30, 70, 60, 10]
-        mock_get_max_tokens.return_value = 8192
+        mock_get_model_info.return_value = {"max_input_tokens": 8192, "max_tokens": 4096}
 
         counter = TokenCounter()
         tools = [{"type": "function", "function": {"name": "test_fn"}}]
@@ -205,11 +243,11 @@ class TestTokenCounter:
         assert result.total == 150  # 30 + 70 + 50
         assert result.model == "gpt-4"
 
-    @patch("litellm.get_max_tokens")
+    @patch("litellm.get_model_info")
     @patch("litellm.token_counter")
-    def test_count_context_empty_system(self, mock_token_counter, mock_get_max_tokens):
+    def test_count_context_empty_system(self, mock_token_counter, mock_get_model_info):
         mock_token_counter.return_value = 50
-        mock_get_max_tokens.return_value = 4096
+        mock_get_model_info.return_value = {"max_input_tokens": 4096, "max_tokens": 2048}
 
         counter = TokenCounter()
         result = counter.count_context(
@@ -224,11 +262,11 @@ class TestTokenCounter:
         assert result.model == "gpt-3.5-turbo"
         assert result.max_tokens == 4096
 
-    @patch("litellm.get_max_tokens")
+    @patch("litellm.get_model_info")
     @patch("litellm.token_counter")
-    def test_count_context_no_max_tokens(self, mock_token_counter, mock_get_max_tokens):
+    def test_count_context_no_max_tokens(self, mock_token_counter, mock_get_model_info):
         mock_token_counter.side_effect = [20, 30]
-        mock_get_max_tokens.return_value = None  # Unknown model
+        mock_get_model_info.side_effect = Exception("Unknown model")
 
         counter = TokenCounter()
         result = counter.count_context(
@@ -263,12 +301,12 @@ class TestTokenCounter:
         # Verify all models were called
         assert mock_token_counter.call_count == len(models)
 
-    @patch("litellm.get_max_tokens")
+    @patch("litellm.get_model_info")
     @patch("litellm.token_counter")
-    def test_count_context_division_by_zero_prevention(self, mock_token_counter, mock_get_max_tokens):
+    def test_count_context_division_by_zero_prevention(self, mock_token_counter, mock_get_model_info):
         """Test that division by zero is prevented when max_tokens is 0."""
         mock_token_counter.side_effect = [20, 30]
-        mock_get_max_tokens.return_value = 0  # Edge case: max_tokens = 0
+        mock_get_model_info.return_value = {"max_input_tokens": 0, "max_tokens": 0}  # Edge case
 
         counter = TokenCounter()
         result = counter.count_context(
@@ -281,12 +319,12 @@ class TestTokenCounter:
         assert result.max_tokens == 0
         assert result.utilization is None  # Should be None, not raise ZeroDivisionError
 
-    @patch("litellm.get_max_tokens")
+    @patch("litellm.get_model_info")
     @patch("litellm.token_counter")
-    def test_count_context_empty_history(self, mock_token_counter, mock_get_max_tokens):
+    def test_count_context_empty_history(self, mock_token_counter, mock_get_model_info):
         """Test counting context with empty history messages."""
         mock_token_counter.return_value = 30  # Only system
-        mock_get_max_tokens.return_value = 4096
+        mock_get_model_info.return_value = {"max_input_tokens": 4096, "max_tokens": 2048}
 
         counter = TokenCounter()
         result = counter.count_context(

{atomic_agents-2.7.1 → atomic_agents-2.7.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "atomic-agents"
-version = "2.7.1"
+version = "2.7.4"
 description = "A versatile framework for creating and managing intelligent agents."
 readme = "README.md"
 license = "MIT"

{atomic_agents-2.7.1 → atomic_agents-2.7.4}/uv.lock

@@ -194,7 +194,7 @@ wheels = [
 
 [[package]]
 name = "atomic-agents"
-version = "2.7.1"
+version = "2.7.4"
 source = { editable = "." }
 dependencies = [
     { name = "gitpython" },