deepanalysts 0.2.4__tar.gz → 0.2.5__tar.gz

{deepanalysts-0.2.4 → deepanalysts-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepanalysts
-Version: 0.2.4
+Version: 0.2.5
 Summary: LangChain/LangGraph middleware for building AI agents with memory, skills, and filesystem support
 Author-email: Ganchuluun Narantsatsralt <tsatsralt@swifttech.cloud>
 License: MIT

{deepanalysts-0.2.4 → deepanalysts-0.2.5}/deepanalysts/middleware/tool_errors.py

@@ -57,7 +57,13 @@ class ToolErrorHandlingMiddleware(AgentMiddleware):
             self._failure_counts.clear()
 
     def _on_failure(self, tool_name: str, error: str, tool_call_id: str) -> ToolMessage:
-        """Track failure and return an appropriate (possibly escalated) error message."""
+        """Track failure and return an appropriate (possibly escalated) error message.
+
+        The returned ToolMessage carries `status="error"` and `name=tool_name`
+        so downstream middleware (and any caller scanning history) can
+        distinguish failed invocations from successful ones without parsing
+        content prefixes.
+        """
         count = self._failure_counts.get(tool_name, 0) + 1
         self._failure_counts[tool_name] = count
 
@@ -70,7 +76,12 @@ class ToolErrorHandlingMiddleware(AgentMiddleware):
         else:
             content = f"Tool error: {error}"
 
-        return ToolMessage(content=content, tool_call_id=tool_call_id)
+        return ToolMessage(
+            content=content,
+            tool_call_id=tool_call_id,
+            name=tool_name,
+            status="error",
+        )
 
     def _blocked_message(self, tool_name: str, tool_call_id: str) -> ToolMessage:
         """Return a message for tools that have already been blocked."""
@@ -83,6 +94,8 @@ class ToolErrorHandlingMiddleware(AgentMiddleware):
                 f"again. Inform the user and proceed with available information."
             ),
             tool_call_id=tool_call_id,
+            name=tool_name,
+            status="error",
         )
 
     def wrap_tool_call(

{deepanalysts-0.2.4 → deepanalysts-0.2.5}/deepanalysts.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepanalysts
-Version: 0.2.4
+Version: 0.2.5
 Summary: LangChain/LangGraph middleware for building AI agents with memory, skills, and filesystem support
 Author-email: Ganchuluun Narantsatsralt <tsatsralt@swifttech.cloud>
 License: MIT

{deepanalysts-0.2.4 → deepanalysts-0.2.5}/deepanalysts.egg-info/SOURCES.txt

@@ -38,4 +38,5 @@ tests/test_skills_middleware.py
 tests/test_store_backend.py
 tests/test_summarization_middleware.py
 tests/test_supabase_storage_backend.py
+tests/test_tool_errors.py
 tests/test_utils.py

{deepanalysts-0.2.4 → deepanalysts-0.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deepanalysts"
-version = "0.2.4"
+version = "0.2.5"
 description = "LangChain/LangGraph middleware for building AI agents with memory, skills, and filesystem support"
 readme = "README.md"
 license = { text = "MIT" }
@@ -52,3 +52,10 @@ include = ["deepanalysts*"]
 
 [tool.setuptools.package-data]
 deepanalysts = ["py.typed"]
+
+[dependency-groups]
+dev = [
+    "anyio>=4.12.1",
+    "pytest>=9.0.2",
+    "pytest-anyio>=0.0.0",
+]

deepanalysts-0.2.5/tests/test_tool_errors.py

@@ -0,0 +1,106 @@
+"""Tests for ToolErrorHandlingMiddleware error-message contract.
+
+The middleware must mark failure ToolMessages with `status="error"` and
+`name=tool_name` so downstream middleware can distinguish failed tool
+invocations from successful ones without parsing content prefixes.
+"""
+
+from __future__ import annotations
+
+import pytest
+from langchain.agents.middleware.types import ToolCallRequest
+from langchain_core.messages import ToolMessage
+from langchain_core.tools import ToolException
+
+from deepanalysts.middleware import ToolErrorHandlingMiddleware
+
+pytest_plugins = ("anyio",)
+
+
+def _request(tool_name: str, call_id: str = "c1") -> ToolCallRequest:
+    return ToolCallRequest(
+        tool_call={"name": tool_name, "args": {}, "id": call_id},
+        tool=None,
+        state={"messages": []},
+        runtime=None,
+    )
+
+
+async def _raise_tool_exc(req: ToolCallRequest) -> ToolMessage:
+    raise ToolException("boom")
+
+
+async def _raise_unexpected(req: ToolCallRequest) -> ToolMessage:
+    raise RuntimeError("unexpected")
+
+
+async def _success(req: ToolCallRequest) -> ToolMessage:
+    return ToolMessage(
+        content="ok",
+        name=req.tool_call["name"],
+        tool_call_id=req.tool_call["id"],
+    )
+
+
+class TestErrorMessageStatus:
+    @pytest.mark.anyio
+    async def test_tool_exception_marks_status_error(self):
+        mw = ToolErrorHandlingMiddleware()
+        result = await mw.awrap_tool_call(_request("my_tool"), _raise_tool_exc)
+        assert isinstance(result, ToolMessage)
+        assert result.status == "error"
+        assert result.name == "my_tool"
+        assert result.content.startswith("Tool error:")
+
+    @pytest.mark.anyio
+    async def test_unexpected_exception_marks_status_error(self):
+        mw = ToolErrorHandlingMiddleware()
+        result = await mw.awrap_tool_call(_request("my_tool"), _raise_unexpected)
+        assert result.status == "error"
+        assert result.name == "my_tool"
+
+    @pytest.mark.anyio
+    async def test_circuit_breaker_stop_marks_status_error(self):
+        """After max_retries failures, the next failure escalates to STOP:
+        — that message must also be tagged status=error."""
+        mw = ToolErrorHandlingMiddleware(max_retries=2)
+        # Two failures to trip the breaker on the next failure-handling path.
+        await mw.awrap_tool_call(_request("my_tool", "c1"), _raise_tool_exc)
+        result = await mw.awrap_tool_call(_request("my_tool", "c2"), _raise_tool_exc)
+        assert result.content.startswith("STOP:")
+        assert result.status == "error"
+        assert result.name == "my_tool"
+
+    @pytest.mark.anyio
+    async def test_blocked_message_marks_status_error(self):
+        """Once the circuit is open, subsequent calls short-circuit to a
+        BLOCKED message — that message must also be status=error."""
+        mw = ToolErrorHandlingMiddleware(max_retries=1)
+        # Trip the breaker.
+        await mw.awrap_tool_call(_request("my_tool", "c1"), _raise_tool_exc)
+        # This call is short-circuited via _blocked_message.
+        result = await mw.awrap_tool_call(_request("my_tool", "c2"), _success)
+        assert result.content.startswith("BLOCKED:")
+        assert result.status == "error"
+        assert result.name == "my_tool"
+
+    @pytest.mark.anyio
+    async def test_success_passes_through_unchanged(self):
+        mw = ToolErrorHandlingMiddleware()
+        result = await mw.awrap_tool_call(_request("my_tool"), _success)
+        # Successful results are returned as-is — status defaults to success.
+        assert result.status == "success"
+        assert result.content == "ok"
+
+
+class TestSyncPath:
+    def test_sync_tool_exception_marks_status_error(self):
+        mw = ToolErrorHandlingMiddleware()
+
+        def raise_exc(req: ToolCallRequest) -> ToolMessage:
+            raise ToolException("boom")
+
+        result = mw.wrap_tool_call(_request("my_tool"), raise_exc)
+        assert result.status == "error"
+        assert result.name == "my_tool"
+        assert result.content.startswith("Tool error:")