tactus 0.34.0__py3-none-any.whl → 0.35.0__py3-none-any.whl

tactus/adapters/file_storage.py

@@ -6,7 +6,7 @@ Stores procedure metadata and execution log as JSON files on disk.
 
 import json
 from pathlib import Path
-from typing import Any, Optional, Dict, List
+from typing import Any, Optional
 from datetime import datetime
 
 from tactus.protocols.models import (
@@ -67,20 +67,20 @@ class FileStorage:
             return {}
 
         try:
-            with open(file_path, "r") as f:
-                return json.load(f)
-        except (json.JSONDecodeError, IOError) as e:
-            raise RuntimeError(f"Failed to read procedure file {file_path}: {e}")
+            with open(file_path, "r") as file_handle:
+                return json.load(file_handle)
+        except (json.JSONDecodeError, IOError) as error:
+            raise RuntimeError(f"Failed to read procedure file {file_path}: {error}")
 
     def _write_file(self, procedure_id: str, data: dict) -> None:
         """Write procedure data to file."""
         file_path = self._get_file_path(procedure_id)
 
         try:
-            with open(file_path, "w") as f:
-                json.dump(data, f, indent=2, default=str)
-        except (IOError, OSError) as e:
-            raise RuntimeError(f"Failed to write procedure file {file_path}: {e}")
+            with open(file_path, "w") as file_handle:
+                json.dump(data, file_handle, indent=2, default=str)
+        except (IOError, OSError) as error:
+            raise RuntimeError(f"Failed to write procedure file {file_path}: {error}")
 
     def _deserialize_result(self, result: Any) -> Any:
         """Deserialize checkpoint result, reconstructing Pydantic models."""
@@ -189,25 +189,25 @@ class FileStorage:
         self, procedure_id: str, status: str, waiting_on_message_id: Optional[str] = None
     ) -> None:
         """Update procedure status."""
-        metadata = self.load_procedure_metadata(procedure_id)
-        metadata.status = status
-        metadata.waiting_on_message_id = waiting_on_message_id
-        self.save_procedure_metadata(procedure_id, metadata)
+        procedure_metadata = self.load_procedure_metadata(procedure_id)
+        procedure_metadata.status = status
+        procedure_metadata.waiting_on_message_id = waiting_on_message_id
+        self.save_procedure_metadata(procedure_id, procedure_metadata)
 
-    def get_state(self, procedure_id: str) -> Dict[str, Any]:
+    def get_state(self, procedure_id: str) -> dict[str, Any]:
         """Get mutable state dictionary."""
-        metadata = self.load_procedure_metadata(procedure_id)
-        return metadata.state
+        procedure_metadata = self.load_procedure_metadata(procedure_id)
+        return procedure_metadata.state
 
-    def set_state(self, procedure_id: str, state: Dict[str, Any]) -> None:
+    def set_state(self, procedure_id: str, state: dict[str, Any]) -> None:
         """Set mutable state dictionary."""
-        metadata = self.load_procedure_metadata(procedure_id)
-        metadata.state = state
-        self.save_procedure_metadata(procedure_id, metadata)
+        procedure_metadata = self.load_procedure_metadata(procedure_id)
+        procedure_metadata.state = state
+        self.save_procedure_metadata(procedure_id, procedure_metadata)
 
     # Tracing & Debugging Methods
 
-    def _load_index(self) -> Dict[str, Any]:
+    def _load_index(self) -> dict[str, Any]:
         """Load the run index."""
         if not self.index_file.exists():
             return {}
@@ -218,13 +218,13 @@ class FileStorage:
         except (json.JSONDecodeError, IOError):
             return {}
 
-    def _save_index(self, index: Dict[str, Any]) -> None:
+    def _save_index(self, index: dict[str, Any]) -> None:
         """Save the run index."""
         try:
-            with open(self.index_file, "w") as f:
-                json.dump(index, f, indent=2, default=str)
-        except (IOError, OSError) as e:
-            raise RuntimeError(f"Failed to write index file: {e}")
+            with open(self.index_file, "w") as file_handle:
+                json.dump(index, file_handle, indent=2, default=str)
+        except (IOError, OSError) as error:
+            raise RuntimeError(f"Failed to write index file: {error}")
 
     def _update_index(self, run: ExecutionRun) -> None:
         """Update index with run metadata."""
@@ -263,10 +263,10 @@ class FileStorage:
                 checkpoint["timestamp"] = checkpoint["timestamp"].isoformat()
 
         try:
-            with open(run_path, "w") as f:
-                json.dump(data, f, indent=2, default=str)
-        except (IOError, OSError) as e:
-            raise RuntimeError(f"Failed to save run {run.run_id}: {e}")
+            with open(run_path, "w") as file_handle:
+                json.dump(data, file_handle, indent=2, default=str)
+        except (IOError, OSError) as error:
+            raise RuntimeError(f"Failed to save run {run.run_id}: {error}")
 
         # Update index
         self._update_index(run)
@@ -290,10 +290,10 @@ class FileStorage:
             raise FileNotFoundError(f"Run {run_id} not found")
 
         try:
-            with open(run_path, "r") as f:
-                data = json.load(f)
-        except (json.JSONDecodeError, IOError) as e:
-            raise RuntimeError(f"Failed to load run {run_id}: {e}")
+            with open(run_path, "r") as file_handle:
+                data = json.load(file_handle)
+        except (json.JSONDecodeError, IOError) as error:
+            raise RuntimeError(f"Failed to load run {run_id}: {error}")
 
         # Convert timestamps back to datetime objects
         if data.get("start_time"):
@@ -303,28 +303,30 @@ class FileStorage:
 
         # Convert checkpoint timestamps and rebuild CheckpointEntry objects
         execution_log = []
-        for cp_data in data.get("execution_log", []):
-            if cp_data.get("timestamp"):
-                cp_data["timestamp"] = datetime.fromisoformat(cp_data["timestamp"])
+        for checkpoint_data in data.get("execution_log", []):
+            if checkpoint_data.get("timestamp"):
+                checkpoint_data["timestamp"] = datetime.fromisoformat(checkpoint_data["timestamp"])
 
             # Rebuild SourceLocation if present
-            if cp_data.get("source_location"):
-                cp_data["source_location"] = SourceLocation(**cp_data["source_location"])
+            if checkpoint_data.get("source_location"):
+                checkpoint_data["source_location"] = SourceLocation(
+                    **checkpoint_data["source_location"]
+                )
 
-            execution_log.append(CheckpointEntry(**cp_data))
+            execution_log.append(CheckpointEntry(**checkpoint_data))
 
         data["execution_log"] = execution_log
 
         # Rebuild Breakpoint objects
         breakpoints = []
-        for bp_data in data.get("breakpoints", []):
-            breakpoints.append(Breakpoint(**bp_data))
+        for breakpoint_data in data.get("breakpoints", []):
+            breakpoints.append(Breakpoint(**breakpoint_data))
 
         data["breakpoints"] = breakpoints
 
         return ExecutionRun(**data)
 
-    def list_runs(self, procedure_name: Optional[str] = None) -> List[ExecutionRun]:
+    def list_runs(self, procedure_name: Optional[str] = None) -> list[ExecutionRun]:
         """
         List all runs, optionally filtered by procedure name.
 
@@ -339,7 +341,9 @@ class FileStorage:
         # Filter by procedure name if specified
         if procedure_name:
             run_ids = [
-                rid for rid, info in index.items() if info.get("procedure_name") == procedure_name
+                run_id
+                for run_id, info in index.items()
+                if info.get("procedure_name") == procedure_name
             ]
         else:
             run_ids = list(index.keys())
@@ -358,7 +362,7 @@ class FileStorage:
 
         return runs
 
-    def save_breakpoints(self, procedure_name: str, breakpoints: List[Breakpoint]) -> None:
+    def save_breakpoints(self, procedure_name: str, breakpoints: list[Breakpoint]) -> None:
         """
         Save breakpoints for a procedure.
 
@@ -371,12 +375,12 @@ class FileStorage:
         data = [bp.model_dump() for bp in breakpoints]
 
         try:
-            with open(bp_path, "w") as f:
-                json.dump(data, f, indent=2)
-        except (IOError, OSError) as e:
-            raise RuntimeError(f"Failed to save breakpoints for {procedure_name}: {e}")
+            with open(bp_path, "w") as file_handle:
+                json.dump(data, file_handle, indent=2)
+        except (IOError, OSError) as error:
+            raise RuntimeError(f"Failed to save breakpoints for {procedure_name}: {error}")
 
-    def load_breakpoints(self, procedure_name: str) -> List[Breakpoint]:
+    def load_breakpoints(self, procedure_name: str) -> list[Breakpoint]:
         """
         Load breakpoints for a procedure.
 
@@ -392,8 +396,8 @@ class FileStorage:
             return []
 
         try:
-            with open(bp_path, "r") as f:
-                data = json.load(f)
+            with open(bp_path, "r") as file_handle:
+                data = json.load(file_handle)
         except (json.JSONDecodeError, IOError):
             return []
 

tactus/adapters/http_callback_log.py

@@ -7,7 +7,7 @@ Used when TACTUS_CALLBACK_URL environment variable is set.
 
 import logging
 import os
-from typing import Optional, List
+from typing import Optional
 
 import requests
 from requests.adapters import HTTPAdapter
@@ -42,7 +42,7 @@ class HTTPCallbackLogHandler:
         """
         self.callback_url = callback_url
         self.timeout = timeout
-        self.cost_events: List[CostEvent] = []  # Track cost events for aggregation
+        self.cost_events: list[CostEvent] = []  # Track cost events for aggregation
 
         # Setup session with retry logic
         self.session = requests.Session()
@@ -55,7 +55,7 @@ class HTTPCallbackLogHandler:
         self.session.mount("http://", adapter)
         self.session.mount("https://", adapter)
 
-        logger.info(f"[HTTP_CALLBACK] Initialized with URL: {callback_url}")
+        logger.info("[HTTP_CALLBACK] Initialized with URL: %s", callback_url)
 
     def log(self, event: LogEvent) -> None:
         """
@@ -70,29 +70,36 @@ class HTTPCallbackLogHandler:
 
         try:
             # Serialize event to JSON
-            event_dict = event.model_dump(mode="json")
+            event_payload = event.model_dump(mode="json")
 
             # Format timestamp to ensure ISO format with Z suffix
             iso_string = event.timestamp.isoformat()
-            if not (iso_string.endswith("Z") or "+" in iso_string or iso_string.count("-") > 2):
+            has_timezone_marker = (
+                iso_string.endswith("Z") or "+" in iso_string or iso_string.count("-") > 2
+            )
+            if not has_timezone_marker:
                 iso_string += "Z"
-            event_dict["timestamp"] = iso_string
+            event_payload["timestamp"] = iso_string
 
             # POST to callback URL
             response = self.session.post(
                 self.callback_url,
-                json=event_dict,
+                json=event_payload,
                 timeout=self.timeout,
             )
             response.raise_for_status()
-            logger.debug(f"[HTTP_CALLBACK] Event posted: type={event.event_type}")
+            logger.debug("[HTTP_CALLBACK] Event posted: type=%s", event.event_type)
 
-        except requests.exceptions.RequestException as e:
+        except requests.exceptions.RequestException as error:
             # Log but don't fail - event streaming is best-effort
-            logger.warning(f"[HTTP_CALLBACK] Failed to POST event to {self.callback_url}: {e}")
-        except Exception as e:
+            logger.warning(
+                "[HTTP_CALLBACK] Failed to POST event to %s: %s",
+                self.callback_url,
+                error,
+            )
+        except Exception as error:
             # Catch any other errors to prevent crashing the procedure
-            logger.warning(f"[HTTP_CALLBACK] Unexpected error posting event: {e}")
+            logger.warning("[HTTP_CALLBACK] Unexpected error posting event: %s", error)
 
     @classmethod
     def from_environment(cls) -> Optional["HTTPCallbackLogHandler"]:
@@ -104,6 +111,9 @@ class HTTPCallbackLogHandler:
         """
         callback_url = os.environ.get("TACTUS_CALLBACK_URL")
         if callback_url:
-            logger.info(f"[HTTP_CALLBACK] Creating handler from environment: {callback_url}")
+            logger.info(
+                "[HTTP_CALLBACK] Creating handler from environment: %s",
+                callback_url,
+            )
             return cls(callback_url=callback_url)
         return None

tactus/adapters/ide_log.py

@@ -6,9 +6,8 @@ Collects log events in a queue for streaming to IDE frontend.
 
 import logging
 import queue
-from typing import List
 
-from tactus.protocols.models import LogEvent
+from tactus.protocols.models import CostEvent, LogEvent
 
 logger = logging.getLogger(__name__)
 
@@ -25,8 +24,8 @@ class IDELogHandler:
 
     def __init__(self):
         """Initialize IDE log handler."""
-        self.events = queue.Queue()
-        self.cost_events = []  # Track cost events for aggregation
+        self.events: queue.Queue[LogEvent] = queue.Queue()
+        self.cost_events: list[CostEvent] = []  # Track cost events for aggregation
         logger.debug("IDELogHandler initialized")
 
     def log(self, event: LogEvent) -> None:
@@ -37,7 +36,10 @@ class IDELogHandler:
             event: Structured log event
         """
         # CRITICAL DEBUG: Log every call to this method
-        logger.info(f"[IDE_LOG] log() called with event type: {type(event).__name__}")
+        logger.info(
+            "[IDE_LOG] log() called with event type: %s",
+            type(event).__name__,
+        )
 
         # Track cost events for aggregation
         from tactus.protocols.models import CostEvent, AgentStreamChunkEvent
@@ -48,16 +50,22 @@ class IDELogHandler:
         # Debug logging for streaming events
         if isinstance(event, AgentStreamChunkEvent):
             logger.info(
-                f"[IDE_LOG] Received AgentStreamChunkEvent: agent={event.agent_name}, chunk_len={len(event.chunk_text)}, accumulated_len={len(event.accumulated_text)}"
+                "[IDE_LOG] Received AgentStreamChunkEvent: agent=%s, "
+                "chunk_len=%s, accumulated_len=%s",
+                event.agent_name,
+                len(event.chunk_text),
+                len(event.accumulated_text),
             )
 
         self.events.put(event)
         # Use INFO level to ensure we see this in logs
         logger.info(
-            f"[IDE_LOG] Event queued: type={type(event).__name__}, queue_size={self.events.qsize()}"
+            "[IDE_LOG] Event queued: type=%s, queue_size=%s",
+            type(event).__name__,
+            self.events.qsize(),
         )
 
-    def get_events(self, timeout: float = 0.1) -> List[LogEvent]:
+    def get_events(self, timeout: float = 0.1) -> list[LogEvent]:
         """
         Get all available events from the queue.
 
@@ -67,7 +75,7 @@ class IDELogHandler:
         Returns:
             List of LogEvent objects
         """
-        events = []
+        events: list[LogEvent] = []
         while True:
             try:
                 event = self.events.get(timeout=timeout)

tactus/adapters/lua_tools.py

@@ -193,8 +193,7 @@ class LuaToolsAdapter:
                         # Track the mock call
                         if self.tool_primitive:
                             self.tool_primitive.record_call(tool_name, kwargs, result_str)
-                        if self.mock_manager:
-                            self.mock_manager.record_call(tool_name, kwargs, result_str)
+                        self.mock_manager.record_call(tool_name, kwargs, result_str)
                         return result_str
 
                 # Call Lua function directly (Lupa is NOT thread-safe, so we can't use executor)
@@ -221,8 +220,8 @@ class LuaToolsAdapter:
                 logger.debug(f"Lua tool '{tool_name}' executed successfully")
                 return result_str
 
-            except Exception as e:
-                error_msg = f"Error executing Lua tool '{tool_name}': {str(e)}"
+            except Exception as error:
+                error_msg = f"Error executing Lua tool '{tool_name}': {str(error)}"
                 logger.error(error_msg, exc_info=True)
 
                 # Record failed call
@@ -230,7 +229,7 @@ class LuaToolsAdapter:
                     self.tool_primitive.record_call(tool_name, kwargs, error_msg)
 
                 # Re-raise to let agent handle it
-                raise RuntimeError(error_msg) from e
+                raise RuntimeError(error_msg) from error
 
         # Build proper signature for Pydantic AI tool discovery
         sig_params = []

tactus/adapters/mcp.py

@@ -54,8 +54,8 @@ class PydanticAIMCPAdapter:
                     "MCP client doesn't have list_tools() or get_tools(), trying direct call"
                 )
                 mcp_tools = await self.mcp_client() if callable(self.mcp_client) else []
-        except Exception as e:
-            logger.error(f"Failed to load tools from MCP server: {e}", exc_info=True)
+        except Exception as error:
+            logger.error(f"Failed to load tools from MCP server: {error}", exc_info=True)
             return []
 
         if not mcp_tools:
@@ -71,9 +71,9 @@ class PydanticAIMCPAdapter:
                 tool = self._convert_mcp_tool_to_pydantic_ai(mcp_tool)
                 if tool:
                     pydantic_tools.append(tool)
-            except Exception as e:
+            except Exception as error:
                 logger.error(
-                    f"Failed to convert MCP tool {getattr(mcp_tool, 'name', 'unknown')}: {e}",
+                    f"Failed to convert MCP tool {getattr(mcp_tool, 'name', 'unknown')}: {error}",
                     exc_info=True,
                 )
 
@@ -91,16 +91,12 @@ class PydanticAIMCPAdapter:
             pydantic_ai.Tool instance or None if conversion fails
         """
         # Extract tool metadata
-        tool_name = (
-            getattr(mcp_tool, "name", None) or mcp_tool.get("name")
-            if isinstance(mcp_tool, dict)
-            else None
-        )
-        tool_description = (
-            getattr(mcp_tool, "description", None) or mcp_tool.get("description", "")
-            if isinstance(mcp_tool, dict)
-            else ""
-        )
+        if isinstance(mcp_tool, dict):
+            tool_name = mcp_tool.get("name")
+            tool_description = mcp_tool.get("description", "")
+        else:
+            tool_name = getattr(mcp_tool, "name", None)
+            tool_description = getattr(mcp_tool, "description", None) or ""
 
         if not tool_name:
             logger.warning(f"MCP tool missing name: {mcp_tool}")
@@ -120,9 +116,10 @@ class PydanticAIMCPAdapter:
         if input_schema:
             try:
                 args_model = self._json_schema_to_pydantic_model(input_schema, tool_name)
-            except Exception as e:
+            except Exception as error:
                 logger.error(
-                    f"Failed to create Pydantic model for tool '{tool_name}': {e}", exc_info=True
+                    f"Failed to create Pydantic model for tool '{tool_name}': {error}",
+                    exc_info=True,
                 )
                 # Fallback: create a simple model that accepts any dict
                 args_model = create_model(
@@ -186,9 +183,9 @@ class PydanticAIMCPAdapter:
                 logger.debug(f"Tool '{tool_name}' returned: {result_str[:100]}...")
                 return result_str
 
-            except Exception as e:
-                logger.error(f"MCP tool '{tool_name}' execution failed: {e}", exc_info=True)
-                error_msg = f"Error executing tool '{tool_name}': {str(e)}"
+            except Exception as error:
+                logger.error(f"MCP tool '{tool_name}' execution failed: {error}", exc_info=True)
+                error_msg = f"Error executing tool '{tool_name}': {str(error)}"
                 # Still record the failed call
                 if self.tool_primitive:
                     self.tool_primitive.record_call(tool_name, args_dict, error_msg)

tactus/adapters/mcp_manager.py

@@ -10,7 +10,7 @@ import os
 import re
 import asyncio
 from contextlib import AsyncExitStack
-from typing import Dict, Any, List
+from typing import Any
 
 from pydantic_ai.mcp import MCPServerStdio
 
@@ -29,10 +29,10 @@ def substitute_env_vars(value: Any) -> Any:
     """
     if isinstance(value, str):
         # Replace ${VAR} or $VAR with environment variable value
-        return re.sub(r"\$\{(\w+)\}", lambda m: os.getenv(m.group(1), ""), value)
-    elif isinstance(value, dict):
+        return re.sub(r"\$\{(\w+)\}", lambda match: os.getenv(match.group(1), ""), value)
+    if isinstance(value, dict):
         return {k: substitute_env_vars(v) for k, v in value.items()}
-    elif isinstance(value, list):
+    if isinstance(value, list):
         return [substitute_env_vars(v) for v in value]
     return value
 
@@ -45,7 +45,7 @@ class MCPServerManager:
     tool prefixing. Handles connection lifecycle and tool call tracking.
     """
 
-    def __init__(self, server_configs: Dict[str, Dict[str, Any]], tool_primitive=None):
+    def __init__(self, server_configs: dict[str, dict[str, Any]], tool_primitive=None):
         """
         Initialize MCP server manager.
 
@@ -55,10 +55,10 @@ class MCPServerManager:
         """
         self.configs = server_configs
         self.tool_primitive = tool_primitive
-        self.servers: List[MCPServerStdio] = []
-        self.server_toolsets: Dict[str, MCPServerStdio] = {}  # Map server names to toolsets
+        self.servers: list[MCPServerStdio] = []
+        self.server_toolsets: dict[str, MCPServerStdio] = {}  # Map server names to toolsets
         self._exit_stack = AsyncExitStack()
-        logger.info(f"MCPServerManager initialized with {len(server_configs)} server(s)")
+        logger.info("MCPServerManager initialized with %s server(s)", len(server_configs))
 
     async def __aenter__(self):
         """Connect to all configured MCP servers."""
@@ -67,17 +67,21 @@ class MCPServerManager:
             last_error: Exception | None = None
             for attempt in range(1, 4):
                 try:
-                    logger.info(f"Connecting to MCP server '{name}' (attempt {attempt}/3)...")
+                    logger.info(
+                        "Connecting to MCP server '%s' (attempt %s/3)...",
+                        name,
+                        attempt,
+                    )
 
                     # Substitute environment variables in config
-                    config = substitute_env_vars(config)
+                    resolved_config = substitute_env_vars(config)
 
                     # Create base server
                     server = MCPServerStdio(
-                        command=config["command"],
-                        args=config.get("args", []),
-                        env=config.get("env"),
-                        cwd=config.get("cwd"),
+                        command=resolved_config["command"],
+                        args=resolved_config.get("args", []),
+                        env=resolved_config.get("env"),
+                        cwd=resolved_config.get("cwd"),
                         process_tool_call=self._create_trace_callback(name),  # Tracking hook
                     )
 
@@ -93,17 +97,19 @@ class MCPServerManager:
                     )
                     last_error = None
                     break
-                except Exception as e:
-                    last_error = e
+                except Exception as error:
+                    last_error = error
 
                     # Check if this is a fileno error (common in test environments)
                     import io
 
-                    error_str = str(e)
-                    if "fileno" in error_str or isinstance(e, io.UnsupportedOperation):
+                    error_str = str(error)
+                    if "fileno" in error_str or isinstance(error, io.UnsupportedOperation):
                         logger.warning(
-                            f"Failed to connect to MCP server '{name}': {e} "
-                            f"(test environment with redirected streams)"
+                            "Failed to connect to MCP server '%s': %s "
+                            "(test environment with redirected streams)",
+                            name,
+                            error,
                         )
                         # Allow procedures to continue without MCP in this environment.
                         last_error = None
@@ -115,12 +121,19 @@ class MCPServerManager:
                         or "unhandled errors in a TaskGroup" in error_str
                     ):
                         logger.warning(
-                            f"Transient MCP connection failure for '{name}': {e} (retrying)"
+                            "Transient MCP connection failure for '%s': %s (retrying)",
+                            name,
+                            error,
                         )
                         await asyncio.sleep(0.05 * attempt)
                         continue
 
-                    logger.error(f"Failed to connect to MCP server '{name}': {e}", exc_info=True)
+                    logger.error(
+                        "Failed to connect to MCP server '%s': %s",
+                        name,
+                        error,
+                        exc_info=True,
+                    )
                     break
 
             if last_error is not None:
@@ -146,14 +159,17 @@ class MCPServerManager:
             Async callback function for process_tool_call
         """
 
-        async def trace_tool_call(ctx, next_call, tool_name, tool_args):
+        async def trace_tool_call(execution_context, invoke_next, tool_name, tool_args):
             """Middleware to record tool calls in Tactus ToolPrimitive."""
             logger.debug(
-                f"MCP server '{server_name}' calling tool '{tool_name}' with args: {tool_args}"
+                "MCP server '%s' calling tool '%s' with args: %s",
+                server_name,
+                tool_name,
+                tool_args,
             )
 
             try:
-                result = await next_call(tool_name, tool_args)
+                result = await invoke_next(tool_name, tool_args)
 
                 # Record in ToolPrimitive if available
                 if self.tool_primitive:
@@ -162,19 +178,19 @@ class MCPServerManager:
                     result_str = str(result) if not isinstance(result, str) else result
                     self.tool_primitive.record_call(tool_name, tool_args, result_str)
 
-                logger.debug(f"Tool '{tool_name}' completed successfully")
+                logger.debug("Tool '%s' completed successfully", tool_name)
                 return result
-            except Exception as e:
-                logger.error(f"Tool '{tool_name}' failed: {e}", exc_info=True)
+            except Exception as error:
+                logger.error("Tool '%s' failed: %s", tool_name, error, exc_info=True)
                 # Still record the failed call
                 if self.tool_primitive:
-                    error_msg = f"Error: {str(e)}"
+                    error_msg = f"Error: {str(error)}"
                     self.tool_primitive.record_call(tool_name, tool_args, error_msg)
                 raise
 
         return trace_tool_call
 
-    def get_toolsets(self) -> List[MCPServerStdio]:
+    def get_toolsets(self) -> list[MCPServerStdio]:
         """
         Return list of connected servers as toolsets.
 

tactus/adapters/memory.py

@@ -36,18 +36,18 @@ class MemoryStorage:
         self, procedure_id: str, status: str, waiting_on_message_id: Optional[str] = None
     ) -> None:
         """Update procedure status."""
-        metadata = self.load_procedure_metadata(procedure_id)
-        metadata.status = status
-        metadata.waiting_on_message_id = waiting_on_message_id
-        self.save_procedure_metadata(procedure_id, metadata)
+        procedure_metadata = self.load_procedure_metadata(procedure_id)
+        procedure_metadata.status = status
+        procedure_metadata.waiting_on_message_id = waiting_on_message_id
+        self.save_procedure_metadata(procedure_id, procedure_metadata)
 
     def get_state(self, procedure_id: str) -> Dict[str, Any]:
         """Get mutable state dictionary."""
-        metadata = self.load_procedure_metadata(procedure_id)
-        return metadata.state
+        procedure_metadata = self.load_procedure_metadata(procedure_id)
+        return procedure_metadata.state
 
     def set_state(self, procedure_id: str, state: Dict[str, Any]) -> None:
         """Set mutable state dictionary."""
-        metadata = self.load_procedure_metadata(procedure_id)
-        metadata.state = state
-        self.save_procedure_metadata(procedure_id, metadata)
+        procedure_metadata = self.load_procedure_metadata(procedure_id)
+        procedure_metadata.state = state
+        self.save_procedure_metadata(procedure_id, procedure_metadata)