sidekick-agent-cli 0.2.1__tar.gz → 0.2.2__tar.gz

{sidekick_agent_cli-0.2.1 → sidekick_agent_cli-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sidekick-agent-cli
-Version: 0.2.1
+Version: 0.2.2
 Summary: CLI for the Sidekick Agent Orchestrator
 Project-URL: Homepage, https://github.com/datex-labs/sidekick
 Project-URL: Repository, https://github.com/datex-labs/sidekick

{sidekick_agent_cli-0.2.1 → sidekick_agent_cli-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sidekick-agent-cli"
-version = "0.2.1"
+version = "0.2.2"
 description = "CLI for the Sidekick Agent Orchestrator"
 requires-python = ">=3.11"
 license = "MIT"

{sidekick_agent_cli-0.2.1 → sidekick_agent_cli-0.2.2}/src/agent_runtime/runtime.py

@@ -13,6 +13,7 @@ It never touches databases, Redis, or LLM providers directly.
 import asyncio
 import json
 import logging
+import os
 from typing import Dict, List, Optional
 
 from .api_client import (
@@ -63,6 +64,12 @@ class AgentRuntime:
         """
         turn = await self.api.start_turn(conversation_id, node_id, ref_name, user_id=user_id)
 
+        # Expose agent/conversation context as env vars so local tools
+        # (RunCommand, etc.) inherit them in their subprocess environment.
+        if turn.agent_id:
+            os.environ["SIDEKICK_AGENT_ID"] = turn.agent_id
+        os.environ["SIDEKICK_CONVERSATION_ID"] = conversation_id
+
         logger.info(
             f"Turn started: {turn.turn_id} | "
             f"conversation={conversation_id} | "
@@ -75,75 +82,80 @@ class AgentRuntime:
         iteration = 0
         max_iterations = 25  # Safety limit
 
-        while iteration < max_iterations:
-            iteration += 1
+        try:
+            while iteration < max_iterations:
+                iteration += 1
+
+                # Check cancellation
+                if await self.api.is_cancelled(turn.turn_id):
+                    logger.info(f"Turn {turn.turn_id} cancelled")
+                    if self._display:
+                        self._display.on_turn_cancelled(turn.turn_id)
+                    break
 
-            # Check cancellation
-            if await self.api.is_cancelled(turn.turn_id):
-                logger.info(f"Turn {turn.turn_id} cancelled")
+                # Call LLM (Sidekick handles frontend streaming as a side effect)
+                logger.info(f"LLM call #{iteration} for turn {turn.turn_id}")
                 if self._display:
-                    self._display.on_turn_cancelled(turn.turn_id)
-                break
-
-            # Call LLM (Sidekick handles frontend streaming as a side effect)
-            logger.info(f"LLM call #{iteration} for turn {turn.turn_id}")
-            if self._display:
-                self._display.on_llm_call(iteration, turn.turn_id)
-            response = await self.api.stream_llm(turn.turn_id, turn, on_delta=on_delta)
-
-            if not response.tool_calls:
-                # No tool calls — finalize the turn
-                await self.api.complete_turn(turn.turn_id, response.parts)
+                    self._display.on_llm_call(iteration, turn.turn_id)
+                response = await self.api.stream_llm(turn.turn_id, turn, on_delta=on_delta)
+
+                if not response.tool_calls:
+                    # No tool calls — finalize the turn
+                    await self.api.complete_turn(turn.turn_id, response.parts)
+                    logger.info(
+                        f"Turn {turn.turn_id} completed (no tools) after {iteration} iteration(s)"
+                    )
+                    if self._display:
+                        self._display.on_turn_completed(turn.turn_id, iteration)
+                    return
+
+                # Register tool calls with Sidekick (creates pending nodes)
+                tool_nodes = await self.api.register_tool_calls(
+                    turn.turn_id,
+                    response.parts,
+                    response.tool_calls,
+                    turn.tool_definitions,
+                )
+
+                tool_names = [tn.tool_name for tn in tool_nodes]
                 logger.info(
-                    f"Turn {turn.turn_id} completed (no tools) after {iteration} iteration(s)"
+                    f"Registered {len(tool_nodes)} tool calls: "
+                    f"{', '.join(tool_names)}"
                 )
                 if self._display:
-                    self._display.on_turn_completed(turn.turn_id, iteration)
-                return
-
-            # Register tool calls with Sidekick (creates pending nodes)
-            tool_nodes = await self.api.register_tool_calls(
-                turn.turn_id,
-                response.parts,
-                response.tool_calls,
-                turn.tool_definitions,
-            )
+                    self._display.on_tools_registered(tool_names)
 
-            tool_names = [tn.tool_name for tn in tool_nodes]
-            logger.info(
-                f"Registered {len(tool_nodes)} tool calls: "
-                f"{', '.join(tool_names)}"
-            )
-            if self._display:
-                self._display.on_tools_registered(tool_names)
-
-            # Execute tools (local or remote)
-            results = await self._execute_tools(
-                tool_nodes, conversation_id, node_id, ref_name,
-                on_tool_start=on_tool_start, on_tool_complete=on_tool_complete,
-            )
+                # Execute tools (local or remote)
+                results = await self._execute_tools(
+                    tool_nodes, conversation_id, node_id, ref_name,
+                    on_tool_start=on_tool_start, on_tool_complete=on_tool_complete,
+                )
 
-            # Submit results to Sidekick
-            await self.api.submit_tool_results(turn.turn_id, results)
+                # Submit results to Sidekick
+                await self.api.submit_tool_results(turn.turn_id, results)
 
-            # Evaluate oversized tool results via ephemeral branches
-            eval_config = (turn.agent_config or {}).get("context_evaluation", {})
-            if eval_config.get("enabled"):
-                await self._evaluate_tool_results(
-                    turn, results, eval_config, tool_nodes
-                )
+                # Evaluate oversized tool results via ephemeral branches
+                eval_config = (turn.agent_config or {}).get("context_evaluation", {})
+                if eval_config.get("enabled"):
+                    await self._evaluate_tool_results(
+                        turn, results, eval_config, tool_nodes
+                    )
 
-            # Get updated context for next LLM call
-            continuation = await self.api.continue_turn(turn.turn_id)
-            turn.messages = continuation.messages
-            turn.tool_definitions = continuation.tool_definitions
+                # Get updated context for next LLM call
+                continuation = await self.api.continue_turn(turn.turn_id)
+                turn.messages = continuation.messages
+                turn.tool_definitions = continuation.tool_definitions
 
-        if iteration >= max_iterations:
-            logger.warning(
-                f"Turn {turn.turn_id} hit max iterations ({max_iterations})"
-            )
-            # Still complete the turn with whatever we have
-            await self.api.complete_turn(turn.turn_id, [])
+            if iteration >= max_iterations:
+                logger.warning(
+                    f"Turn {turn.turn_id} hit max iterations ({max_iterations})"
+                )
+                # Still complete the turn with whatever we have
+                await self.api.complete_turn(turn.turn_id, [])
+        finally:
+            # Clean up turn-scoped env vars
+            os.environ.pop("SIDEKICK_AGENT_ID", None)
+            os.environ.pop("SIDEKICK_CONVERSATION_ID", None)
 
     async def _execute_single_tool(
         self,