Merge pull request #22 from redis-applied-ai/fix/query-without-redis-instance

fix: Queries with an instance ID should pass the instance to the triage agent

Author: abrookins

.github/workflows/publish-docker.yml

@@ -56,7 +56,7 @@ jobs:
         id: meta
         uses: docker/metadata-action@v5
         with:
-          images: abrookins/redis-sre-agent
+          images: redislabs/redis-sre-agent
           tags: |
             type=raw,value=${{ github.event.inputs.tag }}
             type=raw,value=latest,enable=${{ github.event.inputs.push_latest }}

redis_sre_agent/agent/knowledge_agent.py

@@ -419,7 +419,7 @@ async def process_query(
             session_id: Session identifier
             user_id: User identifier
             max_iterations: Maximum number of agent iterations
-            context: Additional context (ignored for knowledge-only agent)
+            context: Additional context (currently ignored for knowledge-only agent)
             progress_callback: Optional callback for progress updates
             conversation_history: Optional list of previous messages for context
 
@@ -432,9 +432,9 @@ async def process_query(
         if progress_callback:
             self.progress_callback = progress_callback
 
-        # Create ToolManager with only knowledge tools (no redis_instance)
+        # Create ToolManager with Redis instance-independent tools
         async with ToolManager(redis_instance=None) as tool_mgr:
-            logger.info(f"Loaded {len(tool_mgr.get_tools())} knowledge tools")
+            logger.info(f"Loaded {len(tool_mgr.get_tools())} usable without Redis instance details")
 
             # Build workflow with tools
             workflow = self._build_workflow(tool_mgr)

redis_sre_agent/agent/langgraph_agent.py

@@ -1911,11 +1911,11 @@ async def _retry_with_backoff(
         raise last_exception
 
 
-def get_sre_agent() -> SRELangGraphAgent:
+def get_sre_agent(*args, **kwargs) -> SRELangGraphAgent:
     """Create a new SRE agent instance for each task to prevent cross-contamination.
 
     Previously this was a singleton, but that caused cross-contamination between
     different tasks/threads when multiple tasks ran concurrently. Each task now
     gets its own isolated agent instance.
     """
-    return SRELangGraphAgent()
+    return SRELangGraphAgent(*args, **kwargs)

redis_sre_agent/cli/query.py

@@ -22,6 +22,9 @@ def query(query: str, redis_instance_id: Optional[str]):
     async def _query():
         if redis_instance_id:
             instance = await get_instance_by_id(redis_instance_id)
+            if not instance:
+                click.echo(f"❌ Instance not found: {redis_instance_id}")
+                exit(1)
         else:
             instance = None
 
@@ -34,11 +37,13 @@ async def _query():
             agent = get_knowledge_agent()
 
         try:
+            context = {"instance_id": instance.id} if instance else None
             response = await agent.process_query(
                 query,
                 session_id="cli",
                 user_id="cli_user",
                 max_iterations=settings.max_iterations,
+                context=context,
             )
 
             from rich.console import Console
@@ -49,5 +54,6 @@ async def _query():
             console.print(Markdown(str(response)))
         except Exception as e:
             click.echo(f"❌ Error: {e}")
+            exit(1)
 
     asyncio.run(_query())

tests/unit/cli/test_cli_query.py

@@ -0,0 +1,136 @@
+"""Tests for the `query` CLI command."""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from click.testing import CliRunner
+
+from redis_sre_agent.cli.query import query
+
+
+def test_query_cli_help_shows_instance_option():
+    runner = CliRunner()
+    result = runner.invoke(query, ["--help"])
+
+    assert result.exit_code == 0
+    assert "--redis-instance-id" in result.output
+    assert "-r" in result.output
+
+
+def test_query_without_instance_uses_knowledge_agent():
+    runner = CliRunner()
+
+    mock_agent = MagicMock()
+    mock_agent.process_query = AsyncMock(return_value="ok")
+
+    with (
+        patch(
+            "redis_sre_agent.cli.query.get_knowledge_agent", return_value=mock_agent
+        ) as mock_get_knowledge,
+        patch("redis_sre_agent.cli.query.get_sre_agent") as mock_get_sre,
+        patch(
+            "redis_sre_agent.cli.query.get_instance_by_id",
+            new=AsyncMock(),
+        ) as mock_get_instance,
+    ):
+        result = runner.invoke(query, ["What is Redis SRE?"])
+
+    assert result.exit_code == 0, result.output
+    mock_get_knowledge.assert_called_once()
+    mock_get_sre.assert_not_called()
+    mock_get_instance.assert_not_awaited()
+    mock_agent.process_query.assert_awaited_once()
+
+
+def test_query_with_instance_uses_sre_agent_and_passes_instance_context():
+    runner = CliRunner()
+
+    class DummyInstance:
+        def __init__(self, id: str, name: str):  # noqa: A003 - keep click-style arg name
+            self.id = id
+            self.name = name
+
+    instance = DummyInstance("redis-prod-123", "Haink Production")
+
+    mock_sre_agent = MagicMock()
+    mock_sre_agent.process_query = AsyncMock(return_value="ok")
+
+    with (
+        patch(
+            "redis_sre_agent.cli.query.get_instance_by_id",
+            new=AsyncMock(return_value=instance),
+        ) as mock_get_instance,
+        patch(
+            "redis_sre_agent.cli.query.get_sre_agent", return_value=mock_sre_agent
+        ) as mock_get_sre,
+        patch("redis_sre_agent.cli.query.get_knowledge_agent") as mock_get_knowledge,
+    ):
+        # Use -r / --redis-instance-id option to select instance
+        result = runner.invoke(
+            query,
+            [
+                "Should I scale this instance yet?",
+                "-r",
+                instance.id,
+            ],
+        )
+
+    assert result.exit_code == 0, result.output
+
+    # Instance lookup should happen once with the provided ID
+    mock_get_instance.assert_awaited_once_with(instance.id)
+
+    # SRE agent should be used (not the knowledge agent)
+    mock_get_sre.assert_called_once()
+    mock_get_knowledge.assert_not_called()
+
+    # The agent should be called exactly once
+    mock_sre_agent.process_query.assert_awaited_once()
+    _, kwargs = mock_sre_agent.process_query.call_args
+
+    # Critical behavior: CLI must pass instance context through to the agent
+    assert kwargs.get("context") == {"instance_id": instance.id}
+
+
+def test_query_with_unknown_instance_exits_with_error_and_skips_agents():
+    """If -r is provided but the instance does not exist, CLI should error and exit.
+
+    This directly tests the new existence-check logic in redis_sre_agent.cli.query.
+    """
+
+    runner = CliRunner()
+
+    mock_agent = MagicMock()
+    mock_agent.process_query = AsyncMock(return_value="ok")
+
+    missing_id = "nonexistent-instance-id"
+
+    with (
+        patch(
+            "redis_sre_agent.cli.query.get_instance_by_id",
+            new=AsyncMock(return_value=None),
+        ) as mock_get_instance,
+        patch(
+            "redis_sre_agent.cli.query.get_knowledge_agent", return_value=mock_agent
+        ) as mock_get_knowledge,
+        patch("redis_sre_agent.cli.query.get_sre_agent") as mock_get_sre,
+    ):
+        result = runner.invoke(
+            query,
+            [
+                "-r",
+                missing_id,
+                "Check the health of this instance",
+            ],
+        )
+
+    # CLI should exit with non-zero status (explicitly exit(1) in implementation)
+    assert result.exit_code == 1
+    assert f"Instance not found: {missing_id}" in result.output
+
+    # We attempted to resolve the instance ID once
+    mock_get_instance.assert_awaited_once_with(missing_id)
+
+    # Since the instance doesn't exist, no agent should be initialized or invoked
+    mock_get_knowledge.assert_not_called()
+    mock_get_sre.assert_not_called()
+    mock_agent.process_query.assert_not_awaited()