machinaos 0.0.78 → 0.0.80

package/server/services/handlers/triggers.py

@@ -10,12 +10,7 @@ from services import event_waiter
 logger = get_logger(__name__)
 
 
-async def handle_trigger_node(
-    node_id: str,
-    node_type: str,
-    parameters: Dict[str, Any],
-    context: Dict[str, Any]
-) -> Dict[str, Any]:
+async def handle_trigger_node(node_id: str, node_type: str, parameters: Dict[str, Any], context: Dict[str, Any]) -> Dict[str, Any]:
     """Handle trigger node execution (webhook, whatsapp, etc.).
 
     Uses event_waiter module to register waiter and await matching event.
@@ -31,8 +26,9 @@ async def handle_trigger_node(
         Execution result dict with event data
     """
     from services.status_broadcaster import get_status_broadcaster
+
     start_time = time.time()
-    execution_id = context.get('execution_id', 'unknown')
+    execution_id = context.get("execution_id", "unknown")
 
     # Get trigger configuration
     config = event_waiter.get_trigger_config(node_type)
@@ -44,7 +40,7 @@ async def handle_trigger_node(
             "node_type": node_type,
             "error": f"Unknown trigger type: {node_type}",
             "execution_time": time.time() - start_time,
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         }
 
     try:
@@ -67,20 +63,26 @@ async def handle_trigger_node(
         waiter = await event_waiter.register(node_type, node_id, parameters)
 
         # Get workflow_id from context for per-workflow status scoping (n8n pattern)
-        workflow_id = context.get('workflow_id')
+        workflow_id = context.get("workflow_id")
 
         # Broadcast waiting status to frontend
         broadcaster = get_status_broadcaster()
         logger.info("Broadcasting waiting status", node_id=node_id, execution_id=execution_id)
-        await broadcaster.update_node_status(node_id, "waiting", {
-            "message": f"Waiting for {config.display_name}...",
-            "event_type": config.event_type,
-            "waiter_id": waiter.id
-        }, workflow_id=workflow_id)
-
-        logger.info("Trigger waiting for event", node_id=node_id, node_type=node_type,
-                   event_type=config.event_type, execution_id=execution_id,
-                   backend_mode=event_waiter.get_backend_mode())
+        await broadcaster.update_node_status(
+            node_id,
+            "waiting",
+            {"message": f"Waiting for {config.display_name}...", "event_type": config.event_type, "waiter_id": waiter.id},
+            workflow_id=workflow_id,
+        )
+
+        logger.info(
+            "Trigger waiting for event",
+            node_id=node_id,
+            node_type=node_type,
+            event_type=config.event_type,
+            execution_id=execution_id,
+            backend_mode=event_waiter.get_backend_mode(),
+        )
 
         # Wait for event indefinitely (user cancels via cancel_event_wait)
         # Uses wait_for_event which handles both Redis Streams and asyncio.Future modes
@@ -95,7 +97,7 @@ async def handle_trigger_node(
                 "node_type": node_type,
                 "result": event_data,
                 "execution_time": time.time() - start_time,
-                "timestamp": datetime.now().isoformat()
+                "timestamp": datetime.now().isoformat(),
             }
 
         except asyncio.CancelledError:
@@ -106,17 +108,16 @@ async def handle_trigger_node(
                 "node_type": node_type,
                 "error": "Cancelled by user",
                 "execution_time": time.time() - start_time,
-                "timestamp": datetime.now().isoformat()
+                "timestamp": datetime.now().isoformat(),
             }
 
     except Exception as e:
-        logger.error("Trigger execution failed", node_id=node_id, node_type=node_type,
-                    execution_id=execution_id, error=str(e))
+        logger.error("Trigger execution failed", node_id=node_id, node_type=node_type, execution_id=execution_id, error=str(e))
         return {
             "success": False,
             "node_id": node_id,
             "node_type": node_type,
             "error": str(e),
             "execution_time": time.time() - start_time,
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         }

package/server/services/llm/config.py

@@ -18,9 +18,11 @@ logger = get_logger(__name__)
 # Provider config dataclass
 # ---------------------------------------------------------------------------
 
+
 @dataclass
 class ProviderConfig:
     """Metadata for a single LLM provider."""
+
     name: str
     default_model: str
     detection_patterns: Tuple[str, ...]
@@ -35,6 +37,7 @@ class ProviderConfig:
 # Load config/llm_defaults.json once at import time
 # ---------------------------------------------------------------------------
 
+
 def _load_llm_defaults() -> Dict[str, Any]:
     config_path = Path(__file__).parent.parent.parent / "config" / "llm_defaults.json"
     try:
@@ -68,6 +71,7 @@ _AUTH_OVERRIDES: Dict[str, Dict[str, str]] = {
 # Provider registry -- built dynamically from llm_defaults.json
 # ---------------------------------------------------------------------------
 
+
 def _build_provider_configs() -> Dict[str, ProviderConfig]:
     """Build ProviderConfig entries from llm_defaults.json."""
     providers = LLM_DEFAULTS.get("providers", {})
@@ -100,6 +104,7 @@ def get_provider_config(provider: str) -> Optional[ProviderConfig]:
 # Provider detection from model name
 # ---------------------------------------------------------------------------
 
+
 def detect_provider_from_model(model: str) -> str:
     model_lower = model.lower()
     for name, cfg in PROVIDER_CONFIGS.items():
@@ -114,7 +119,7 @@ def is_model_valid_for_provider(model: str, provider: str) -> bool:
     # match any "lmstudio"/"ollama" substring. Treat as always-valid;
     # the upstream API will 404 a genuinely missing model. See the
     # mirror in services/ai.py for the full rationale.
-    if provider in ('openrouter', 'ollama', 'lmstudio'):
+    if provider in ("openrouter", "ollama", "lmstudio"):
         return True
     cfg = PROVIDER_CONFIGS.get(provider)
     if not cfg:
@@ -127,6 +132,7 @@ def is_model_valid_for_provider(model: str, provider: str) -> bool:
 # Default model helpers
 # ---------------------------------------------------------------------------
 
+
 def get_default_model(provider: str) -> str:
     cfg = PROVIDER_CONFIGS.get(provider)
     return cfg.default_model if cfg else "gpt-5.2"
@@ -148,9 +154,11 @@ async def get_default_model_async(provider: str, database) -> str:
 # Max-tokens / temperature resolution
 # ---------------------------------------------------------------------------
 
+
 def resolve_max_tokens(params: dict, model: str, provider: str) -> int:
     """Resolve max_tokens: user param -> model registry -> llm_defaults -> 4096."""
     from services.model_registry import get_model_registry
+
     registry = get_model_registry()
     model_max = registry.get_max_output_tokens(model, provider)
 
@@ -167,6 +175,7 @@ def resolve_max_tokens(params: dict, model: str, provider: str) -> int:
 def resolve_temperature(params: dict, model: str, provider: str, thinking_enabled: bool) -> float:
     """Resolve temperature with model-specific constraints."""
     from services.model_registry import get_model_registry
+
     registry = get_model_registry()
 
     user_temp = float(params.get("temperature", 0.7))

package/server/services/llm/factory.py

@@ -16,10 +16,16 @@ _DEDICATED_PROVIDERS = frozenset({"anthropic", "openai", "gemini", "openrouter"}
 # Local servers (ollama, lmstudio) expose OpenAI-compatible /v1 endpoints, so they fall
 # through to OpenAIProvider with base_url from llm_defaults.json — same path as deepseek/
 # kimi/mistral. The user's custom URL rides via the existing {provider}_proxy credential.
-NATIVE_PROVIDERS = _DEDICATED_PROVIDERS | frozenset({
-    "xai", "deepseek", "kimi", "mistral",
-    "ollama", "lmstudio",
-})
+NATIVE_PROVIDERS = _DEDICATED_PROVIDERS | frozenset(
+    {
+        "xai",
+        "deepseek",
+        "kimi",
+        "mistral",
+        "ollama",
+        "lmstudio",
+    }
+)
 
 
 def create_provider(
@@ -35,25 +41,31 @@ def create_provider(
     """
     if provider == "anthropic":
         from services.llm.providers.anthropic import AnthropicProvider
+
         return AnthropicProvider(api_key, proxy_url=proxy_url)
 
     if provider == "openai":
         from services.llm.providers.openai import OpenAIProvider
+
         return OpenAIProvider(api_key, proxy_url=proxy_url)
 
     if provider == "gemini":
         from services.llm.providers.gemini import GeminiProvider
+
         return GeminiProvider(api_key, proxy_url=proxy_url)
 
     if provider == "openrouter":
         from services.llm.providers.openrouter import OpenRouterProvider
+
         return OpenRouterProvider(api_key, proxy_url=proxy_url)
 
     # OpenAI-compatible providers: use OpenAIProvider with base_url from config
     from services.llm.config import get_provider_config
+
     config = get_provider_config(provider)
     if config and config.base_url:
         from services.llm.providers.openai import OpenAIProvider
+
         return OpenAIProvider(api_key, base_url=config.base_url, proxy_url=proxy_url)
 
     raise ValueError(f"Unknown provider: {provider}")

package/server/services/llm/messages.py

@@ -11,11 +11,7 @@ def is_valid_message_content(content: Any) -> bool:
     if content is None:
         return False
     if isinstance(content, list):
-        return any(
-            (isinstance(b, dict) and b.get("text", "").strip())
-            or (isinstance(b, str) and b.strip())
-            for b in content
-        )
+        return any((isinstance(b, dict) and b.get("text", "").strip()) or (isinstance(b, str) and b.strip()) for b in content)
     if isinstance(content, str):
         return bool(content.strip())
     return bool(content)

package/server/services/llm/protocol.py

@@ -13,6 +13,7 @@ from typing import Any, Dict, List, Optional, Protocol, runtime_checkable
 # Shared data types
 # ---------------------------------------------------------------------------
 
+
 @dataclass
 class ThinkingConfig:
     """Unified thinking/reasoning configuration.
@@ -23,16 +24,18 @@ class ThinkingConfig:
     - Gemini 3+: thinking_level (low/medium/high)
     - Groq Qwen3: reasoning_format (parsed/hidden)
     """
+
     enabled: bool = False
     budget: int = 2048
     effort: str = "medium"
-    level: str = "medium"   # Gemini 3+ thinking_level
+    level: str = "medium"  # Gemini 3+ thinking_level
     format: str = "parsed"
 
 
 @dataclass
 class ToolDef:
     """Tool definition passed to the LLM."""
+
     name: str
     description: str
     parameters: Dict[str, Any]  # JSON Schema
@@ -41,6 +44,7 @@ class ToolDef:
 @dataclass
 class ToolCall:
     """A tool invocation returned by the LLM."""
+
     id: str
     name: str
     args: Dict[str, Any]
@@ -49,6 +53,7 @@ class ToolCall:
 @dataclass
 class Message:
     """Normalized chat message."""
+
     role: str  # system | user | assistant | tool
     content: str = ""
     tool_calls: List[ToolCall] = field(default_factory=list)
@@ -59,6 +64,7 @@ class Message:
 @dataclass
 class Usage:
     """Token usage metrics."""
+
     input_tokens: int = 0
     output_tokens: int = 0
     total_tokens: int = 0
@@ -70,6 +76,7 @@ class Usage:
 @dataclass
 class LLMResponse:
     """Normalized response from any LLM provider."""
+
     content: str = ""
     thinking: Optional[str] = None
     tool_calls: List[ToolCall] = field(default_factory=list)
@@ -83,6 +90,7 @@ class LLMResponse:
 # Provider protocol (structural typing)
 # ---------------------------------------------------------------------------
 
+
 @runtime_checkable
 class LLMProvider(Protocol):
     provider_name: str

package/server/services/llm/providers/anthropic.py

@@ -7,7 +7,12 @@ from typing import Any, Dict, List, Optional
 
 from core.logging import get_logger
 from services.llm.protocol import (
-    LLMResponse, Message, ThinkingConfig, ToolCall, ToolDef, Usage,
+    LLMResponse,
+    Message,
+    ThinkingConfig,
+    ToolCall,
+    ToolDef,
+    Usage,
 )
 
 logger = get_logger(__name__)
@@ -18,6 +23,7 @@ class AnthropicProvider:
 
     def __init__(self, api_key: str, *, proxy_url: Optional[str] = None):
         import anthropic
+
         kwargs: Dict[str, Any] = {"api_key": api_key}
         if proxy_url:
             kwargs["base_url"] = proxy_url
@@ -71,6 +77,7 @@ class AnthropicProvider:
 
     async def fetch_models(self, api_key: str) -> List[str]:
         import httpx
+
         async with httpx.AsyncClient() as client:
             r = await client.get(
                 "https://api.anthropic.com/v1/models",
@@ -117,12 +124,14 @@ class AnthropicProvider:
             if m.content:
                 content.append({"type": "text", "text": m.content})
             for tc in m.tool_calls:
-                content.append({
-                    "type": "tool_use",
-                    "id": tc.id,
-                    "name": tc.name,
-                    "input": tc.args,
-                })
+                content.append(
+                    {
+                        "type": "tool_use",
+                        "id": tc.id,
+                        "name": tc.name,
+                        "input": tc.args,
+                    }
+                )
             return {"role": "assistant", "content": content}
 
         return {"role": role, "content": m.content}
@@ -146,11 +155,13 @@ class AnthropicProvider:
             elif block.type == "thinking":
                 thinking_parts.append(block.thinking)
             elif block.type == "tool_use":
-                tool_calls.append(ToolCall(
-                    id=block.id,
-                    name=block.name,
-                    args=block.input if isinstance(block.input, dict) else json.loads(block.input),
-                ))
+                tool_calls.append(
+                    ToolCall(
+                        id=block.id,
+                        name=block.name,
+                        args=block.input if isinstance(block.input, dict) else json.loads(block.input),
+                    )
+                )
 
         usage = Usage(
             input_tokens=getattr(resp.usage, "input_tokens", 0),

package/server/services/llm/providers/gemini.py

@@ -6,7 +6,12 @@ from typing import Any, Dict, List, Optional
 
 from core.logging import get_logger
 from services.llm.protocol import (
-    LLMResponse, Message, ThinkingConfig, ToolCall, ToolDef, Usage,
+    LLMResponse,
+    Message,
+    ThinkingConfig,
+    ToolCall,
+    ToolDef,
+    Usage,
 )
 
 logger = get_logger(__name__)
@@ -17,6 +22,7 @@ class GeminiProvider:
 
     def __init__(self, api_key: str, *, proxy_url: Optional[str] = None):
         from google import genai
+
         kwargs: Dict[str, Any] = {"api_key": api_key}
         if proxy_url:
             kwargs["http_options"] = {"base_url": proxy_url}
@@ -74,6 +80,7 @@ class GeminiProvider:
 
     async def fetch_models(self, api_key: str) -> List[str]:
         import httpx
+
         async with httpx.AsyncClient() as client:
             r = await client.get(
                 f"https://generativelanguage.googleapis.com/v1beta/models?key={api_key}",
@@ -103,13 +110,19 @@ class GeminiProvider:
                 continue
 
             if m.role == "tool":
-                contents.append({
-                    "role": "function",
-                    "parts": [{"function_response": {
-                        "name": m.name or "",
-                        "response": {"result": m.content},
-                    }}],
-                })
+                contents.append(
+                    {
+                        "role": "function",
+                        "parts": [
+                            {
+                                "function_response": {
+                                    "name": m.name or "",
+                                    "response": {"result": m.content},
+                                }
+                            }
+                        ],
+                    }
+                )
                 continue
 
             if m.role == "assistant" and m.tool_calls:
@@ -117,10 +130,14 @@ class GeminiProvider:
                 if m.content:
                     parts.append({"text": m.content})
                 for tc in m.tool_calls:
-                    parts.append({"function_call": {
-                        "name": tc.name,
-                        "args": tc.args,
-                    }})
+                    parts.append(
+                        {
+                            "function_call": {
+                                "name": tc.name,
+                                "args": tc.args,
+                            }
+                        }
+                    )
                 contents.append({"role": "model", "parts": parts})
                 continue
 
@@ -133,11 +150,13 @@ class GeminiProvider:
     @staticmethod
     def _to_api_tool(tool: ToolDef) -> Dict[str, Any]:
         return {
-            "function_declarations": [{
-                "name": tool.name,
-                "description": tool.description,
-                "parameters": tool.parameters,
-            }]
+            "function_declarations": [
+                {
+                    "name": tool.name,
+                    "description": tool.description,
+                    "parameters": tool.parameters,
+                }
+            ]
         }
 
     def _normalize(self, resp: Any, model: str) -> LLMResponse:
@@ -152,11 +171,13 @@ class GeminiProvider:
                 elif hasattr(part, "function_call") and part.function_call:
                     fc = part.function_call
                     args = dict(fc.args) if fc.args else {}
-                    tool_calls.append(ToolCall(
-                        id=fc.name,  # Gemini doesn't have separate IDs
-                        name=fc.name,
-                        args=args,
-                    ))
+                    tool_calls.append(
+                        ToolCall(
+                            id=fc.name,  # Gemini doesn't have separate IDs
+                            name=fc.name,
+                            args=args,
+                        )
+                    )
                 elif hasattr(part, "text") and part.text:
                     text_parts.append(part.text)
 

package/server/services/llm/providers/openai.py

@@ -11,7 +11,12 @@ from typing import Any, Dict, List, Optional
 
 from core.logging import get_logger
 from services.llm.protocol import (
-    LLMResponse, Message, ThinkingConfig, ToolCall, ToolDef, Usage,
+    LLMResponse,
+    Message,
+    ThinkingConfig,
+    ToolCall,
+    ToolDef,
+    Usage,
 )
 
 logger = get_logger(__name__)
@@ -22,6 +27,7 @@ class OpenAIProvider:
 
     def __init__(self, api_key: str, *, proxy_url: Optional[str] = None, base_url: Optional[str] = None):
         import openai
+
         kwargs: Dict[str, Any] = {"api_key": api_key}
         url = proxy_url or base_url
         if url:
@@ -143,11 +149,13 @@ class OpenAIProvider:
         if msg.tool_calls:
             for tc in msg.tool_calls:
                 args = tc.function.arguments
-                tool_calls.append(ToolCall(
-                    id=tc.id,
-                    name=tc.function.name,
-                    args=json.loads(args) if isinstance(args, str) else args,
-                ))
+                tool_calls.append(
+                    ToolCall(
+                        id=tc.id,
+                        name=tc.function.name,
+                        args=json.loads(args) if isinstance(args, str) else args,
+                    )
+                )
 
         u = resp.usage
         usage = Usage(

package/server/services/llm/providers/openrouter.py

@@ -6,7 +6,10 @@ from typing import Any, Dict, List, Optional
 
 from core.logging import get_logger
 from services.llm.protocol import (
-    LLMResponse, Message, ThinkingConfig, ToolDef,
+    LLMResponse,
+    Message,
+    ThinkingConfig,
+    ToolDef,
 )
 from services.llm.providers.openai import OpenAIProvider
 
@@ -18,6 +21,7 @@ class OpenRouterProvider(OpenAIProvider):
 
     def __init__(self, api_key: str, *, proxy_url: Optional[str] = None):
         import openai
+
         kwargs: Dict[str, Any] = {
             "api_key": api_key,
             "base_url": proxy_url or "https://openrouter.ai/api/v1",
@@ -51,6 +55,7 @@ class OpenRouterProvider(OpenAIProvider):
 
     async def fetch_models(self, api_key: str) -> List[str]:
         import httpx
+
         async with httpx.AsyncClient() as client:
             r = await client.get(
                 "https://openrouter.ai/api/v1/models",

package/server/services/markdown_formatter.py

@@ -215,8 +215,7 @@ def _walk_tokens(tokens: list, result: list, depth: int = 0) -> None:
             if table_row:
                 table_rows.append(table_row)
             table_row = []
-        elif ttype in ("thead_open", "thead_close", "tbody_open", "tbody_close",
-                        "th_open", "th_close", "td_open", "td_close"):
+        elif ttype in ("thead_open", "thead_close", "tbody_open", "tbody_close", "th_open", "th_close", "td_open", "td_close"):
             pass  # Handled via tr_open/close and inline collection
         elif ttype == "html_block" or ttype == "html_inline":
             result.append(token.content)

package/server/services/memory/__init__.py

@@ -4,7 +4,7 @@ Reorganised from the single-file ``services/memory.py`` so each
 storage format / concern owns its own module:
 
   - :mod:`services.memory.markdown` — markdown parse/append/trim
-    (used by aiAgent / chatAgent / deep_agent / rlm_agent)
+    (used by aiAgent / chatAgent / rlm_agent)
   - :mod:`services.memory.jsonl` — Anthropic Messages JSONL
     parse/append/trim (used by claude_code_agent's session bridge)
   - :mod:`services.memory.vector_store` — per-session
@@ -35,7 +35,7 @@ from services.memory.jsonl import (
 
 __all__ = [
     # Markdown helpers — used by every agent bridge (aiAgent /
-    # chatAgent / deep_agent / rlm_agent / claude_code_agent).
+    # chatAgent / rlm_agent / claude_code_agent).
     "parse_memory_markdown",
     "append_to_memory_markdown",
     "trim_markdown_window",

package/server/services/memory/jsonl.py

@@ -51,7 +51,10 @@ def parse_jsonl(text: str) -> List[BaseMessage]:
 
 
 def append_message(
-    text: str, role: str, content: str, **metadata: Any,
+    text: str,
+    role: str,
+    content: str,
+    **metadata: Any,
 ) -> str:
     """Append one Anthropic Messages-format line to a JSONL string.
 
@@ -59,7 +62,8 @@ def append_message(
     a trailing newline so successive appends concatenate cleanly.
     """
     line = json.dumps(
-        {"role": role, "content": content, **metadata}, ensure_ascii=False,
+        {"role": role, "content": content, **metadata},
+        ensure_ascii=False,
     )
     if text and not text.endswith("\n"):
         text = text + "\n"

package/server/services/memory/markdown.py

@@ -2,8 +2,8 @@
 
 Parse, append, and trim conversation history stored in the bespoke
 ``### **Human/Assistant** (timestamp)`` markdown format. Used by
-aiAgent, chatAgent, deep_agent, and rlm_agent for persistent memory
-across turns. The claude_code_agent bridge uses the JSONL helpers in
+aiAgent, chatAgent, and rlm_agent for persistent memory across turns.
+The claude_code_agent bridge uses the JSONL helpers in
 :mod:`services.memory.jsonl` instead.
 """
 
@@ -25,7 +25,7 @@ def parse_memory_markdown(content: str) -> List[BaseMessage]:
         response content
     """
     messages: List[BaseMessage] = []
-    pattern = r'### \*\*(Human|Assistant)\*\*[^\n]*\n(.*?)(?=\n### \*\*|$)'
+    pattern = r"### \*\*(Human|Assistant)\*\*[^\n]*\n(.*?)(?=\n### \*\*|$)"
     for role, text in re.findall(pattern, content, re.DOTALL):
         text = text.strip()
         if text:
@@ -47,14 +47,14 @@ def trim_markdown_window(content: str, window_size: int) -> tuple:
     """Keep the last ``window_size`` message PAIRS; return
     ``(trimmed_content, removed_texts)``. Removed texts are returned
     so callers can hand them to the long-term vector store."""
-    pattern = r'(### \*\*(Human|Assistant)\*\*[^\n]*\n.*?)(?=\n### \*\*|$)'
+    pattern = r"(### \*\*(Human|Assistant)\*\*[^\n]*\n.*?)(?=\n### \*\*|$)"
     blocks = [m[0] for m in re.findall(pattern, content, re.DOTALL)]
 
     if len(blocks) <= window_size * 2:
         return content, []
 
-    keep = blocks[-(window_size * 2):]
-    removed = blocks[:-(window_size * 2)]
+    keep = blocks[-(window_size * 2) :]
+    removed = blocks[: -(window_size * 2)]
 
     removed_texts: List[str] = []
     for block in removed:

package/server/services/memory/state.py

@@ -93,15 +93,16 @@ async def clear_agent_session_state(
         await db.save_node_parameters(memory_node_id, params)
         cleared_memory_node = True
         logger.info(
-            "[Memory] Cleared simpleMemory node fields memory_node=%s "
-            "(memory_content reset + last_session_id wiped)",
+            "[Memory] Cleared simpleMemory node fields memory_node=%s " "(memory_content reset + last_session_id wiped)",
             memory_node_id,
         )
 
     logger.info(
-        "[Memory] Cleared agent session state session=%s workflow_id=%s "
-        "vector_store=%s todo_keys=%s memory_node=%s",
-        session_id, workflow_id, cleared_vector_store, cleared_todo_keys,
+        "[Memory] Cleared agent session state session=%s workflow_id=%s " "vector_store=%s todo_keys=%s memory_node=%s",
+        session_id,
+        workflow_id,
+        cleared_vector_store,
+        cleared_todo_keys,
         cleared_memory_node,
     )