Populate artifact for subagent failures (#116)

mateusz834 · web-flow · commit eb05701b109e · 2026-04-02T07:49:50.000Z
diff --git a/splunklib/ai/engines/langchain.py b/splunklib/ai/engines/langchain.py
@@ -203,15 +203,12 @@ async def awrap_tool_call(
                 assert resp.name, "missing tool name"
 
                 if resp.status == "error":
-                    # This assertion asserts the current behaviour, but can be removed safely,
-                    # if we at some point decide to raise a LC_ToolException in a subagent invocation.
-                    # Also in such case we would need to populate artifact with SubagentFailureResult.
-                    assert not resp.name.startswith(AGENT_PREFIX), (
-                        "subagent produced a non-fatal error"
-                    )
-
                     assert resp.artifact is None, "artifact is already populated"
-                    resp.artifact = ToolFailureResult(str(resp.content))  # pyright: ignore[reportUnknownArgumentType]
+
+                    if resp.name.startswith(AGENT_PREFIX):
+                        resp.artifact = SubagentFailureResult(str(resp.content))  # pyright: ignore[reportUnknownArgumentType]
+                    else:
+                        resp.artifact = ToolFailureResult(str(resp.content))  # pyright: ignore[reportUnknownArgumentType]
 
                 return resp
 
diff --git a/splunklib/ai/messages.py b/splunklib/ai/messages.py
@@ -126,9 +126,6 @@ class SubagentFailureResult:
 
     This type of failure is non-fatal, i.e. it does not stop the agent loop.
     Instead, the error information is returned to the LLM.
-
-    Currently this result is not produced by the subagent call, but can be leveraged
-    in middlewares e.g. to reject subagent calls in a non-fatal way.
     """
 
     error_message: str
diff --git a/tests/integration/ai/test_agent.py b/tests/integration/ai/test_agent.py
@@ -12,11 +12,28 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
+from dataclasses import replace
 import pytest
 from pydantic import BaseModel, Field
 
 from splunklib.ai import Agent
-from splunklib.ai.messages import AIMessage, HumanMessage, SubagentCall, SubagentMessage
+from splunklib.ai.messages import (
+    AIMessage,
+    HumanMessage,
+    SubagentCall,
+    SubagentFailureResult,
+    SubagentMessage,
+)
+from splunklib.ai.middleware import (
+    ModelMiddlewareHandler,
+    ModelRequest,
+    ModelResponse,
+    SubagentMiddlewareHandler,
+    SubagentRequest,
+    SubagentResponse,
+    model_middleware,
+    subagent_middleware,
+)
 from tests.ai_testlib import AITestCase
 
 OPENAI_BASE_URL = "http://localhost:11434/v1"
@@ -411,3 +428,92 @@ async def test_duplicated_subagent_name(self) -> None:
                     agents=[subagent1_empty_name, subagent2_empty_name],
                 ):
                     pass
+
+    @pytest.mark.asyncio
+    async def test_subagent_soft_failure_with_invalid_args(self) -> None:
+        pytest.importorskip("langchain_openai")
+
+        # Regression test - In case invalid schema is provided to the
+        # subagent during execution, we should not fail the entire agent.
+
+        class SubagentInput(BaseModel):
+            name: str = Field(description="person name", min_length=1)
+
+        after_subagent_call = False
+
+        @subagent_middleware
+        async def _subagent_call_middleware(
+            request: SubagentRequest, handler: SubagentMiddlewareHandler
+        ) -> SubagentResponse:
+            nonlocal after_subagent_call
+
+            # Override the arguments, such that are invalid.
+            resp = await handler(replace(request, call=replace(request.call, args={})))
+            assert isinstance(resp.result, SubagentFailureResult), (
+                "subagent call did not fail"
+            )
+
+            after_subagent_call = True
+            return resp
+
+        @model_middleware
+        async def _model_call_middleware(
+            req: ModelRequest, _handler: ModelMiddlewareHandler
+        ) -> ModelResponse:
+            if after_subagent_call:
+                msgs = req.state.response.messages
+                assert isinstance(msgs[-1], SubagentMessage)
+                assert isinstance(msgs[-1].result, SubagentFailureResult)
+
+                return ModelResponse(
+                    message=AIMessage(
+                        content="End of the agent loop",
+                        calls=[],
+                    ),
+                    structured_output=None,
+                )
+            else:
+                return ModelResponse(
+                    message=AIMessage(
+                        content="I need to call tools",
+                        calls=[
+                            SubagentCall(
+                                id="call-1",
+                                name="NicknameGeneratorAgent",
+                                args=SubagentInput(name="Chris").model_dump(),
+                            )
+                        ],
+                    ),
+                    structured_output=None,
+                )
+
+        async with (
+            Agent(
+                model=(await self.model()),
+                system_prompt=(
+                    "You are a helpful assistant that generates nicknames"
+                    "If prompted for nickname you MUST append '-zilla' to provided name to create nickname."
+                    "Remember the dash and lowercase zilla. Example: Stefan -> Stefan-zilla"
+                ),
+                service=self.service,
+                input_schema=SubagentInput,
+                name="NicknameGeneratorAgent",
+                description="Generates nicknames for people. Pass a name and get a nickname",
+            ) as subagent,
+            Agent(
+                model=(await self.model()),
+                system_prompt="You are a supervisor agent that MUST use other agents",
+                agents=[subagent],
+                service=self.service,
+                middleware=[_subagent_call_middleware, _model_call_middleware],
+            ) as supervisor,
+        ):
+            await supervisor.invoke(
+                [
+                    HumanMessage(
+                        content="Hi, my name is Chris. Generate a nickname for me",
+                    )
+                ]
+            )
+
+        assert after_subagent_call, "subagent was not called"
