Skip to content

Self-improving AI Employees for everyone

Fix pairing.restored event and reduce verbose logging

trohitgaafe9fc9f6a1
diff --git a/server/routers/whatsapp.py b/server/routers/whatsapp.py
index d4b771ed..7ca2fdee 100644
--- a/server/routers/whatsapp.py
+++ b/server/routers/whatsapp.py
@@ -107,7 +107,7 @@ class RPCClient:
"""
method = data.get("method", "")
params = data.get("params", {})
- logger.info(f"[WhatsApp RPC] Event: {method} params={params}")
+ logger.debug(f"[WhatsApp RPC] Event: {method}")
try:
from services.status_broadcaster import get_status_broadcaster
@@ -200,8 +200,7 @@ class RPCClient:
await broadcaster.send_custom_event("whatsapp_message_sent", params)
elif method == "event.message_received":
- # Message received - broadcast as custom event
- logger.info(f"[WhatsApp RPC] Broadcasting message_received event to trigger nodes")
+ # Message received - broadcast as custom event for trigger nodes
await broadcaster.send_custom_event("whatsapp_message_received", params)
# Forward to custom handler if set
diff --git a/server/services/ai.py b/server/services/ai.py
index b62bf647..0f4e74a0 100644
--- a/server/services/ai.py
+++ b/server/services/ai.py
@@ -255,41 +255,28 @@ def create_agent_node(chat_model):
iteration = state.get("iteration", 0)
max_iterations = state.get("max_iterations", 10)
- logger.info(f"[LangGraph] Agent node invoked, iteration={iteration}, messages={len(messages)}")
+ logger.debug(f"[LangGraph] Agent node invoked, iteration={iteration}, messages={len(messages)}")
# Filter out messages with empty content using standardized utility
# Prevents API errors/warnings from Gemini, Claude, and other providers
filtered_messages = filter_empty_messages(messages)
if len(filtered_messages) != len(messages):
- logger.info(f"[LangGraph] Filtered out {len(messages) - len(filtered_messages)} empty messages before LLM invoke")
+ logger.debug(f"[LangGraph] Filtered out {len(messages) - len(filtered_messages)} empty messages")
# Invoke the model
response = chat_model.invoke(filtered_messages)
- logger.info(f"[LangGraph] LLM response type: {type(response)}, has tool_calls attr: {hasattr(response, 'tool_calls')}")
-
- # Debug log full response for troubleshooting empty responses (especially Gemini)
- if hasattr(response, 'content'):
- logger.info(f"[LangGraph] response.content type: {type(response.content)}, length: {len(str(response.content)) if response.content else 0}")
+ logger.debug(f"[LangGraph] LLM response type: {type(response).__name__}")
# Check for Gemini-specific response attributes (safety ratings, block reason)
if hasattr(response, 'response_metadata'):
meta = response.response_metadata
- logger.info(f"[LangGraph] response_metadata: {meta}")
- # Check for Gemini finish reason (could indicate blocked content)
if meta.get('finish_reason') == 'SAFETY':
logger.warning("[LangGraph] Gemini response blocked by safety filters")
if meta.get('block_reason'):
logger.warning(f"[LangGraph] Gemini block reason: {meta.get('block_reason')}")
- # Log additional_kwargs which may contain Gemini-specific info
- if hasattr(response, 'additional_kwargs') and response.additional_kwargs:
- logger.info(f"[LangGraph] additional_kwargs: {response.additional_kwargs}")
-
- if hasattr(response, 'tool_calls'):
- logger.info(f"[LangGraph] tool_calls value: {response.tool_calls}")
-
# Check for tool calls in the response
pending_tool_calls = []
should_continue = False
@@ -298,9 +285,7 @@ def create_agent_node(chat_model):
# Model wants to use tools
pending_tool_calls = response.tool_calls
should_continue = True
- logger.info(f"[LangGraph] Agent requesting {len(pending_tool_calls)} tool call(s): {[tc.get('name', tc) for tc in pending_tool_calls]}")
- else:
- logger.info(f"[LangGraph] No tool calls in response, content preview: {str(response.content)[:100]}")
+ logger.debug(f"[LangGraph] Agent requesting {len(pending_tool_calls)} tool call(s)")
return {
"messages": [response], # Will be appended via operator.add
@@ -334,7 +319,7 @@ def create_tool_node(tool_executor: Callable):
tool_args = tool_call.get("args", {})
tool_id = tool_call.get("id", "")
- logger.info(f"[LangGraph] Executing tool: {tool_name} with args: {tool_args}")
+ logger.debug(f"[LangGraph] Executing tool: {tool_name}")
try:
# Directly await the async tool executor (proper async pattern)
@@ -350,7 +335,7 @@ def create_tool_node(tool_executor: Callable):
name=tool_name
))
- logger.info(f"[LangGraph] Tool {tool_name} completed with result: {result}")
+ logger.debug(f"[LangGraph] Tool {tool_name} completed")
return {
"messages": tool_messages,
@@ -395,7 +380,7 @@ def build_agent_graph(chat_model, tools: List = None, tool_executor: Callable =
model_with_tools = chat_model
if tools:
model_with_tools = chat_model.bind_tools(tools)
- logger.info(f"[LangGraph] Bound {len(tools)} tools to model")
+ logger.debug(f"[LangGraph] Bound {len(tools)} tools to model")
# Add the agent node
agent_fn = create_agent_node(model_with_tools)
@@ -422,7 +407,7 @@ def build_agent_graph(chat_model, tools: List = None, tool_executor: Callable =
# Tools always route back to agent
graph.add_edge("tools", "agent")
- logger.info("[LangGraph] Built graph with tool execution loop")
+ logger.debug("[LangGraph] Built graph with tool execution loop")
else:
# Simple graph without tools
graph.add_conditional_edges(
@@ -735,7 +720,7 @@ class AIService:
temperature = float(flattened.get('temperature', 0.7))
max_tokens = int(flattened.get('max_tokens') or flattened.get('maxTokens') or 1000)
- logger.info(f"[LangGraph] AI Agent execution - Provider: {provider}, Model: {model}, Memory: {bool(memory_data)}, Tools: {len(tool_data) if tool_data else 0}")
+ logger.info(f"[LangGraph] Agent: {provider}/{model}, tools={len(tool_data) if tool_data else 0}")
# If no model specified or model doesn't match provider, use default from registry
if not model or not is_model_valid_for_provider(model, provider):
@@ -757,7 +742,7 @@ class AIService:
})
# Create LLM using the provider from node configuration
- logger.info(f"[LangGraph] Creating {provider} model: {model}")
+ logger.debug(f"[LangGraph] Creating {provider} model: {model}")
chat_model = self.create_model(provider, api_key, model, temperature, max_tokens)
# Build initial messages for state
@@ -822,7 +807,7 @@ class AIService:
tools.append(tool)
tool_configs[tool.name] = config
- logger.info(f"[LangGraph] Built {len(tools)} tools: {[t.name for t in tools]}")
+ logger.debug(f"[LangGraph] Built {len(tools)} tools")
# Create tool executor callback
async def tool_executor(tool_name: str, tool_args: Dict) -> Any:
@@ -832,7 +817,7 @@ class AIService:
config = tool_configs.get(tool_name, {})
tool_node_id = config.get('node_id')
- logger.info(f"[LangGraph] tool_executor called for: {tool_name} (node_id: {tool_node_id})")
+ logger.debug(f"[LangGraph] tool_executor: {tool_name}")
# Broadcast executing status to the AI Agent node
await broadcast_status("executing_tool", {
@@ -882,7 +867,7 @@ class AIService:
})
# Build and execute LangGraph agent
- logger.info(f"[LangGraph] Building agent graph with {len(initial_messages)} initial messages and {len(tools)} tools")
+ logger.debug(f"[LangGraph] Building agent graph with {len(initial_messages)} messages")
agent_graph = build_agent_graph(
chat_model,
tools=tools if tools else None,
@@ -925,7 +910,7 @@ class AIService:
response_content = self._extract_text_content(raw_content, ai_response)
iterations = final_state.get("iteration", 1)
- logger.info(f"[LangGraph] Agent completed in {iterations} iteration(s), response length: {len(response_content)}")
+ logger.info(f"[LangGraph] Agent completed in {iterations} iteration(s)")
# Save to memory if connected (persist to database)
# Only save non-empty messages using standardized validation
@@ -1025,7 +1010,7 @@ class AIService:
if db_schema:
# Use database schema as source of truth
- logger.info(f"[LangGraph] Using DB schema for tool node {node_id}")
+ logger.debug(f"[LangGraph] Using DB schema for tool node {node_id}")
tool_name = db_schema.get('tool_name', DEFAULT_TOOL_NAMES.get(node_type, f"tool_{node_label}"))
tool_description = db_schema.get('tool_description', DEFAULT_TOOL_DESCRIPTIONS.get(node_type, f"Execute {node_label}"))
# Use stored connected_services if available (for toolkit nodes)
@@ -1082,7 +1067,7 @@ class AIService:
'connected_services': connected_services # Pass through for execution
}
- logger.info(f"[LangGraph] Built tool '{tool_name}' from node type '{node_type}'")
+ logger.debug(f"[LangGraph] Built tool '{tool_name}'")
return tool, config
except Exception as e:
diff --git a/server/services/android/client.py b/server/services/android/client.py
index dd7b2908..c4c2efd9 100644
--- a/server/services/android/client.py
+++ b/server/services/android/client.py
@@ -314,6 +314,10 @@ class RelayWebSocketClient:
if method == "pairing.connected":
await self._handle_pairing_connected(params)
+ elif method == "pairing.restored":
+ # Handle auto-reconnect of previously paired device
+ await self._handle_pairing_restored(params)
+
elif method == "pairing.disconnected":
await self._handle_pairing_disconnected(params)
@@ -345,6 +349,24 @@ class RelayWebSocketClient:
if self.on_pairing_connected:
await self.on_pairing_connected(params)
+ async def _handle_pairing_restored(self, params: dict):
+ """Handle pairing.restored event - auto-reconnect of previously paired device."""
+ self.paired = True
+ self.paired_device_id = params.get("device_id")
+ self.paired_device_name = params.get("device_name")
+
+ logger.info("[Relay] Android pairing restored (auto-reconnect)",
+ device_id=self.paired_device_id,
+ device_name=self.paired_device_name)
+
+ await broadcast_connected(self.paired_device_id, self.paired_device_name)
+
+ # Update saved session with latest info
+ await self._save_pairing_session()
+
+ if self.on_pairing_connected:
+ await self.on_pairing_connected(params)
+
async def _save_pairing_session(self):
"""Save pairing session to database for auto-reconnect."""
try:
diff --git a/server/services/deployment/manager.py b/server/services/deployment/manager.py
index 4928f6c1..88a895d9 100644
--- a/server/services/deployment/manager.py
+++ b/server/services/deployment/manager.py
@@ -495,7 +495,7 @@ class DeploymentManager:
# Build filtered graph
run_filter = {trigger_node_id} | {n['id'] for n in downstream}
- logger.info(f"[Run] run_filter has {len(run_filter)} nodes: {[n.get('type') for n in state.nodes if n['id'] in run_filter]}")
+ logger.debug(f"[Run] run_filter has {len(run_filter)} nodes")
filtered_nodes = []
for node in state.nodes:
@@ -511,7 +511,7 @@ class DeploymentManager:
e for e in state.edges
if e.get('source') in run_filter and e.get('target') in run_filter
]
- logger.info(f"[Run] filtered_edges: {len(filtered_edges)} edges (from {len(state.edges)} total)")
+ logger.debug(f"[Run] filtered_edges: {len(filtered_edges)} edges")
# Execute filtered graph with deployment's workflow_id for scoped status
status_callback = self._status_callbacks.get(workflow_id)
diff --git a/server/services/handlers/ai.py b/server/services/handlers/ai.py
index d6f582b6..812293b7 100644
--- a/server/services/handlers/ai.py
+++ b/server/services/handlers/ai.py
@@ -39,11 +39,7 @@ async def handle_ai_agent(
memory_data = None
tool_data: List[Dict[str, Any]] = [] # Collect connected tool nodes
- # DEBUG: Log what we're working with
- logger.info(f"[AI Agent] Processing node {node_id}, context has {len(edges) if edges else 0} edges, {len(nodes) if nodes else 0} nodes")
- if edges:
- toolkit_edges = [e for e in edges if 'androidTool' in str(e)]
- logger.info(f"[AI Agent] Toolkit-related edges: {toolkit_edges}")
+ logger.debug(f"[AI Agent] Processing node {node_id}, edges={len(edges) if edges else 0}, nodes={len(nodes) if nodes else 0}")
if edges and nodes:
for edge in edges:
@@ -69,8 +65,7 @@ async def handle_ai_agent(
'memory_type': memory_type,
'window_size': window_size
}
- logger.info("AI Agent connected memory node", node_id=node_id, execution_id=execution_id,
- memory_session=memory_session_id, memory_type=memory_type)
+ logger.debug("AI Agent connected memory node", memory_session=memory_session_id)
# Tool detection (new) - any node connected to input-tools becomes a tool
elif target_handle == 'input-tools':
@@ -90,15 +85,6 @@ async def handle_ai_agent(
if tool_type == 'androidTool':
connected_services = []
- # Debug: log all edges to understand the structure
- logger.info(f"[Android Toolkit] Looking for edges targeting toolkit node: {source_node_id}")
- logger.info(f"[Android Toolkit] Total edges in context: {len(edges)}")
- for i, e in enumerate(edges):
- logger.info(f"[Android Toolkit] Edge {i}: source={e.get('source')}, target={e.get('target')}, sourceHandle={e.get('sourceHandle')}, targetHandle={e.get('targetHandle')}")
-
- toolkit_edges = [e for e in edges if e.get('target') == source_node_id]
- logger.info(f"[Android Toolkit] Edges targeting toolkit {source_node_id}: {toolkit_edges}")
-
# Scan edges for Android nodes connected to this toolkit
for service_edge in edges:
# Skip if not targeting this androidTool node
@@ -127,12 +113,10 @@ async def handle_ai_agent(
logger.debug(f"Android toolkit connected service: {android_params.get('service_id')}")
tool_entry['connected_services'] = connected_services
- logger.info(f"Android toolkit has {len(connected_services)} connected services",
- node_id=source_node_id, services=[s.get('service_id') for s in connected_services])
+ logger.debug(f"Android toolkit has {len(connected_services)} connected services")
tool_data.append(tool_entry)
- logger.info("AI Agent connected tool node", node_id=node_id, execution_id=execution_id,
- tool_type=tool_type, tool_node_id=source_node_id)
+ logger.debug(f"AI Agent connected tool: {tool_type}")
# Get broadcaster for real-time status updates
from services.status_broadcaster import get_status_broadcaster
diff --git a/server/services/parameter_resolver.py b/server/services/parameter_resolver.py
index 6758a15c..2b3abd2a 100644
--- a/server/services/parameter_resolver.py
+++ b/server/services/parameter_resolver.py
@@ -131,10 +131,11 @@ class ParameterResolver:
# Case-insensitive lookup
data_lower = {k.lower(): v for k, v in connected_data.items()}
- # Log template resolution context
- template_params = {k: v for k, v in parameters.items() if isinstance(v, str) and '{{' in v}
- if template_params:
- logger.info(f"[ParameterResolver] Resolving templates: params_with_templates={list(template_params.keys())}, available_nodes={list(data_lower.keys())}")
+ # Log template resolution context at debug level
+ if logger.isEnabledFor(10): # DEBUG level
+ template_params = {k: v for k, v in parameters.items() if isinstance(v, str) and '{{' in v}
+ if template_params:
+ logger.debug(f"[ParameterResolver] Resolving templates: {list(template_params.keys())}")
def resolve(value: Any) -> Any:
if isinstance(value, str) and '{{' in value: