Self-improving AI Employees for everyone
Python ai-agentsai-employeeai-employeesassistantautonomous-agentsco-employeescompanygrok-botinstinctloop-agentsmuseown-your-datapersonalself-hosted
Add session persistence and standardize AI model outputs
trohitg85f9a95b1790
diff --git a/client/src/components/parameterPanel/InputSection.tsx b/client/src/components/parameterPanel/InputSection.tsxindex fe8f84cc..b50a5485 100644--- a/client/src/components/parameterPanel/InputSection.tsx+++ b/client/src/components/parameterPanel/InputSection.tsx@@ -152,7 +152,7 @@ const InputSection: React.FC<InputSectionProps> = ({ nodeId, visible = true }) =} else {const sampleSchemas: Record<string, Record<string, any>> = {location: { latitude: 'number', longitude: 'number', accuracy: 'number', provider: 'string', altitude: 'number' },- ai: { response: 'string', model: 'string', usage: { tokens: 'number' } },+ ai: { response: 'string', model: 'string', provider: 'string', finish_reason: 'string', timestamp: 'string' },file: { fileName: 'string', fileSize: 'number' },whatsapp: {message_id: 'string',@@ -309,7 +309,8 @@ const InputSection: React.FC<InputSectionProps> = ({ nodeId, visible = true }) =// Node type detectionconst isMemory = nodeType === 'simpleMemory';- const isAI = !isMemory && (nodeType.includes('ai') || nodeType.includes('chat'));+ const nodeTypeLower = nodeType.toLowerCase();+ const isAI = !isMemory && (nodeTypeLower.includes('chatmodel') || nodeTypeLower.includes('aiagent'));const isFile = nodeType.includes('file');const isWhatsApp = nodeType.includes('whatsapp') || nodeType.includes('Whatsapp');const isWebhook = nodeType === 'webhookTrigger';diff --git a/client/src/nodeDefinitions/whatsappNodes.ts b/client/src/nodeDefinitions/whatsappNodes.tsindex 5c7d3053..111c1157 100644--- a/client/src/nodeDefinitions/whatsappNodes.ts+++ b/client/src/nodeDefinitions/whatsappNodes.ts@@ -719,6 +719,29 @@ export const whatsappNodes: Record<string, INodeTypeDescription> = {description: 'Filter by message type'},+ // ===== RESULT MODE =====+ {+ displayName: 'Result Mode',+ name: 'resultMode',+ type: 'options',+ options: [+ { name: 'Multiple Messages', value: 'multiple' },+ { name: 'Single Message by Position', value: 'single' }+ ],+ default: 'multiple',+ description: 'Return multiple messages or a single message at specific position'+ },+ {+ displayName: 'Message Position',+ name: 'position',+ type: 'number',+ default: 1,+ description: 'Position: positive from newest (1=most recent), negative from oldest (-1=oldest)',+ displayOptions: {+ show: { resultMode: ['single'] }+ }+ },+// ===== PAGINATION ====={displayName: 'Limit',@@ -726,7 +749,10 @@ export const whatsappNodes: Record<string, INodeTypeDescription> = {type: 'number',default: 50,typeOptions: { minValue: 1, maxValue: 500 },- description: 'Maximum number of messages to retrieve (1-500)'+ description: 'Maximum number of messages to retrieve (1-500)',+ displayOptions: {+ show: { resultMode: ['multiple'] }+ }},{displayName: 'Offset',@@ -734,7 +760,10 @@ export const whatsappNodes: Record<string, INodeTypeDescription> = {type: 'number',default: 0,typeOptions: { minValue: 0 },- description: 'Number of messages to skip (for pagination)'+ description: 'Number of messages to skip (for pagination)',+ displayOptions: {+ show: { resultMode: ['multiple'] }+ }}],methods: {diff --git a/deploy.sh b/deploy.shindex ba8c9169..1c878c4a 100644--- a/deploy.sh+++ b/deploy.sh@@ -55,11 +55,19 @@ tar --exclude='node_modules' \scp /tmp/machinaos-src.tar.gz "${GCP_HOST}:/tmp/${SERVICE_NAME}/"-# Upload production .env (prefer .env.production, fallback to .env)+# Upload production .env (prefer .env.production, fallback to .env, then create from template)if [ -f "${LOCAL_DIR}/server/.env.production" ]; thenscp "${LOCAL_DIR}/server/.env.production" "${GCP_HOST}:/tmp/${SERVICE_NAME}/.env"elif [ -f "${LOCAL_DIR}/server/.env" ]; thenscp "${LOCAL_DIR}/server/.env" "${GCP_HOST}:/tmp/${SERVICE_NAME}/.env"+elif [ -f "${LOCAL_DIR}/.env.template" ]; then+ echo "No .env found, creating from .env.template..."+ scp "${LOCAL_DIR}/.env.template" "${GCP_HOST}:/tmp/${SERVICE_NAME}/.env"+elif [ -f "${LOCAL_DIR}/server/.env.template" ]; then+ echo "No .env found, creating from server/.env.template..."+ scp "${LOCAL_DIR}/server/.env.template" "${GCP_HOST}:/tmp/${SERVICE_NAME}/.env"+else+ echo "Warning: No .env or .env.template found. Using docker-compose environment variables only."fi# Step 2: Build and deploy on remotediff --git a/scripts/docker.js b/scripts/docker.jsindex 2f1b07dd..c2ed8ed5 100644--- a/scripts/docker.js+++ b/scripts/docker.js@@ -6,13 +6,36 @@*/import { spawn } from 'child_process';-import { readFileSync, existsSync } from 'fs';+import { readFileSync, existsSync, copyFileSync } from 'fs';import { fileURLToPath } from 'url';import { dirname, resolve } from 'path';const __dirname = dirname(fileURLToPath(import.meta.url));const ROOT = resolve(__dirname, '..');+// Create .env from template if it doesn't exist+function ensureEnvFile() {+ const envPath = resolve(ROOT, '.env');+ if (existsSync(envPath)) return true;++ // Try root .env.template first, then server/.env.template+ const templates = [+ resolve(ROOT, '.env.template'),+ resolve(ROOT, 'server', '.env.template')+ ];++ for (const templatePath of templates) {+ if (existsSync(templatePath)) {+ console.log(`[Docker] Creating .env from ${templatePath.replace(ROOT, '.')}`);+ copyFileSync(templatePath, envPath);+ return true;+ }+ }++ console.warn('[Docker] Warning: No .env or .env.template found');+ return false;+}+// Read .env file and check REDIS_ENABLEDfunction isRedisEnabled() {const envPath = resolve(ROOT, '.env');@@ -35,6 +58,9 @@ if (!command) {process.exit(1);}+// Ensure .env exists (create from template if needed)+ensureEnvFile();+// Build docker-compose commandconst composeArgs = [];diff --git a/server/core/database.py b/server/core/database.pyindex a9e72d00..20a28a7d 100644--- a/server/core/database.py+++ b/server/core/database.py@@ -864,4 +864,64 @@ class Database:except Exception as e:logger.error("Failed to get all tool schemas", error=str(e))- return []\ No newline at end of file+ return []++ # ============================================================================+ # Android Relay Session Persistence+ # ============================================================================++ async def save_android_relay_session(+ self,+ relay_url: str,+ api_key: str,+ device_id: str,+ device_name: Optional[str] = None,+ session_token: Optional[str] = None+ ) -> bool:+ """Save Android relay pairing session for auto-reconnect on server restart.++ Args:+ relay_url: WebSocket relay URL+ api_key: API key for relay authentication+ device_id: Paired Android device ID+ device_name: Paired device name+ session_token: Relay session token+ """+ import json+ try:+ session_data = json.dumps({+ "relay_url": relay_url,+ "api_key": api_key,+ "device_id": device_id,+ "device_name": device_name,+ "session_token": session_token+ })+ # No TTL - session persists until explicitly cleared+ return await self.set_cache_entry("android_relay_session", session_data)+ except Exception as e:+ logger.error("Failed to save Android relay session", error=str(e))+ return False++ async def get_android_relay_session(self) -> Optional[Dict[str, Any]]:+ """Get stored Android relay session for auto-reconnect.++ Returns:+ Session data dict or None if not found+ """+ import json+ try:+ value = await self.get_cache_entry("android_relay_session")+ if value:+ return json.loads(value)+ return None+ except Exception as e:+ logger.error("Failed to get Android relay session", error=str(e))+ return None++ async def clear_android_relay_session(self) -> bool:+ """Clear stored Android relay session (on explicit disconnect)."""+ try:+ return await self.delete_cache_entry("android_relay_session")+ except Exception as e:+ logger.error("Failed to clear Android relay session", error=str(e))+ return False\ No newline at end of filediff --git a/server/services/android/client.py b/server/services/android/client.pyindex 4068ef70..dd7b2908 100644--- a/server/services/android/client.py+++ b/server/services/android/client.py@@ -159,9 +159,15 @@ class RelayWebSocketClient:logger.error("[Relay] Connection error", error=str(e), exc_info=True)return False, f"Connection error: {str(e)}"- async def disconnect(self):- """Close connection and cleanup."""- logger.info("[Relay] Disconnecting...")+ async def disconnect(self, clear_stored_session: bool = True):+ """Close connection and cleanup.++ Args:+ clear_stored_session: If True, clear stored pairing session from database.+ Set to False when disconnecting due to connection drop+ (will try to auto-reconnect later).+ """+ logger.info("[Relay] Disconnecting...", clear_stored_session=clear_stored_session)self._running = False# Cancel background tasks@@ -191,11 +197,26 @@ class RelayWebSocketClient:# Cancel pending RPC requestsself._rpc_tracker.cancel_all()+ # Clear stored session if explicitly disconnecting+ if clear_stored_session:+ await self._clear_stored_session()+# Broadcast relay disconnection (fully disconnected from relay server)await broadcast_relay_disconnected()logger.info("[Relay] Disconnected")+ async def _clear_stored_session(self):+ """Clear stored pairing session from database."""+ try:+ from core.container import container+ database = container.database()++ await database.clear_android_relay_session()+ logger.info("[Relay] Cleared stored pairing session")+ except Exception as e:+ logger.warning("[Relay] Failed to clear stored session", error=str(e))+def is_connected(self) -> bool:"""Check if connected to relay server."""return self.connected and self._running and self.ws is not None and not self.ws.closed@@ -318,9 +339,29 @@ class RelayWebSocketClient:await broadcast_connected(self.paired_device_id, self.paired_device_name)+ # Persist pairing data for auto-reconnect on server restart+ 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:+ from core.container import container+ database = container.database()++ await database.save_android_relay_session(+ relay_url=self.base_url,+ api_key=self.api_key,+ device_id=self.paired_device_id,+ device_name=self.paired_device_name,+ session_token=self.session_token+ )+ logger.info("[Relay] Pairing session saved for auto-reconnect")+ except Exception as e:+ logger.warning("[Relay] Failed to save pairing session", error=str(e))+async def _handle_pairing_disconnected(self, params: dict):"""Handle pairing.disconnected event.diff --git a/server/services/android/manager.py b/server/services/android/manager.pyindex 5d1b585e..6dbd197d 100644--- a/server/services/android/manager.py+++ b/server/services/android/manager.py@@ -51,12 +51,17 @@ async def get_relay_client(base_url: str, api_key: str) -> tuple[Optional[RelayWreturn None, error-async def close_relay_client():- """Close global relay client."""+async def close_relay_client(clear_stored_session: bool = True):+ """Close global relay client.++ Args:+ clear_stored_session: If True, clear stored pairing session from database.+ This prevents auto-reconnect on next client connect.+ """global _relay_clientif _relay_client:- logger.info("[Manager] Closing connection")- await _relay_client.disconnect()+ logger.info("[Manager] Closing connection", clear_stored_session=clear_stored_session)+ await _relay_client.disconnect(clear_stored_session=clear_stored_session)_relay_client = Nonediff --git a/server/services/handlers/whatsapp.py b/server/services/handlers/whatsapp.pyindex 9d802f60..012551f1 100644--- a/server/services/handlers/whatsapp.py+++ b/server/services/handlers/whatsapp.py@@ -226,9 +226,51 @@ async def handle_whatsapp_chat_history(message_filter = parameters.get('messageFilter', 'all')rpc_params['text_only'] = message_filter == 'text_only'- # Pagination- rpc_params['limit'] = parameters.get('limit', 50)- rpc_params['offset'] = parameters.get('offset', 0)+ # Result mode and pagination+ result_mode = parameters.get('resultMode', 'multiple')+ position = parameters.get('position', 1)++ if result_mode == 'single':+ # Single message by position mode+ if position > 0:+ # Positive: from newest (1=most recent)+ rpc_params['limit'] = 1+ rpc_params['offset'] = position - 1+ else:+ # Negative: from oldest (-1=oldest)+ # First, get total count with limit=1 to minimize data transfer+ rpc_params['limit'] = 1+ rpc_params['offset'] = 0+ count_data = await whatsapp_chat_history_handler(rpc_params)+ total = count_data.get('total', 0)++ if total == 0:+ return {+ "success": True,+ "node_id": node_id,+ "node_type": "whatsappChatHistory",+ "result": {+ "messages": [],+ "total": 0,+ "has_more": False,+ "count": 0,+ "chat_type": chat_type,+ "timestamp": datetime.now().isoformat()+ },+ "execution_time": time.time() - start_time,+ "timestamp": datetime.now().isoformat()+ }++ # Calculate offset from the end: -1 = last (oldest in desc order = total-1)+ # Since messages are ordered DESC (newest first), -1 means oldest = offset total-1+ offset = total + position # e.g., total=100, pos=-1 -> offset=99+ if offset < 0:+ offset = 0+ rpc_params['offset'] = offset+ else:+ # Multiple messages mode - use standard pagination+ rpc_params['limit'] = parameters.get('limit', 50)+ rpc_params['offset'] = parameters.get('offset', 0)# Call WhatsApp Go RPC servicedata = await whatsapp_chat_history_handler(rpc_params)@@ -241,6 +283,11 @@ async def handle_whatsapp_chat_history(total = data.get('total', 0)has_more = data.get('has_more', False)+ # Add index to each message (1-based, from offset)+ base_offset = rpc_params.get('offset', 0)+ for i, msg in enumerate(messages):+ msg['index'] = base_offset + i + 1+return {"success": True,"node_id": node_id,diff --git a/server/services/status_broadcaster.py b/server/services/status_broadcaster.pyindex 04d5a571..d916f202 100644--- a/server/services/status_broadcaster.py+++ b/server/services/status_broadcaster.py@@ -69,6 +69,13 @@ class StatusBroadcaster:self._connections.add(websocket)logger.info(f"[StatusBroadcaster] Client connected. Total: {len(self._connections)}")+ # Fetch fresh WhatsApp status before sending initial_status+ # This ensures client sees actual connection state (especially after auto-connect)+ await self._refresh_whatsapp_status()++ # Auto-reconnect Android relay if there's a stored session+ await self._auto_reconnect_android_relay()+# Send current full status immediatelytry:await websocket.send_json({@@ -194,6 +201,106 @@ class StatusBroadcaster:# WhatsApp Status Updates# =========================================================================+ async def _refresh_whatsapp_status(self):+ """Fetch fresh WhatsApp status from Go service and update cache.++ Called on client connect to ensure initial_status has accurate data.+ Silently fails if WhatsApp service is unavailable.+ """+ try:+ from routers.whatsapp import get_client+ import time++ client = await get_client()+ status_data = await client.call("status")++ self._status["whatsapp"] = {+ "connected": status_data.get("connected", False),+ "has_session": status_data.get("has_session", False),+ "running": status_data.get("running", False),+ "pairing": status_data.get("pairing", False),+ "device_id": status_data.get("device_id"),+ "qr": None,+ "timestamp": time.time()+ }+ logger.debug(f"[StatusBroadcaster] Refreshed WhatsApp status: connected={status_data.get('connected')}")+ except Exception as e:+ # Don't fail client connection if WhatsApp service is down+ logger.debug(f"[StatusBroadcaster] Could not refresh WhatsApp status: {e}")++ async def _auto_reconnect_android_relay(self):+ """Auto-reconnect to Android relay if there's a stored pairing session.++ Called on client connect to re-establish relay connection after server restart.+ The stored session contains relay URL, API key, and paired device info.+ """+ try:+ # Check if already connected+ from services.android.manager import get_current_relay_client+ existing = get_current_relay_client()+ if existing and existing.is_connected():+ # Already connected, just refresh status+ self._status["android"] = {+ "connected": True,+ "paired": existing.is_paired(),+ "device_id": existing.paired_device_id,+ "device_name": existing.paired_device_name,+ "connected_devices": list(existing.get_connected_devices()),+ "connection_type": "relay",+ "qr_data": existing.qr_data,+ "session_token": existing.session_token+ }+ logger.debug("[StatusBroadcaster] Android relay already connected")+ return++ # Check for stored session+ from core.container import container+ database = container.database()++ session = await database.get_android_relay_session()+ if not session:+ logger.debug("[StatusBroadcaster] No stored Android relay session")+ return++ relay_url = session.get("relay_url")+ api_key = session.get("api_key")+ device_id = session.get("device_id")+ device_name = session.get("device_name")++ if not relay_url or not api_key:+ logger.debug("[StatusBroadcaster] Stored session missing relay URL or API key")+ return++ logger.info(f"[StatusBroadcaster] Auto-reconnecting to Android relay...",+ relay_url=relay_url, device_id=device_id)++ # Attempt to reconnect+ from services.android.manager import get_relay_client+ client, error = await get_relay_client(relay_url, api_key)++ if client and client.is_connected():+ logger.info("[StatusBroadcaster] Android relay reconnected successfully")+ # Update status - connected to relay but need to check if still paired+ # The relay server creates a new session on each connect, so pairing is lost+ # Update the cached status to reflect the current state+ self._status["android"] = {+ "connected": True,+ "paired": client.is_paired(),+ "device_id": client.paired_device_id,+ "device_name": client.paired_device_name,+ "connected_devices": list(client.get_connected_devices()),+ "connection_type": "relay",+ "qr_data": client.qr_data,+ "session_token": client.session_token+ }+ else:+ logger.warning(f"[StatusBroadcaster] Failed to reconnect Android relay: {error}")+ # Clear the stored session since reconnect failed+ await database.clear_android_relay_session()++ except Exception as e:+ logger.debug(f"[StatusBroadcaster] Could not auto-reconnect Android relay: {e}")+async def update_whatsapp_status(self,connected: bool,diff --git a/server/whatsapp-rpc/src/go/cmd/server/main.go b/server/whatsapp-rpc/src/go/cmd/server/main.goindex c90247d0..87176ea0 100644--- a/server/whatsapp-rpc/src/go/cmd/server/main.go+++ b/server/whatsapp-rpc/src/go/cmd/server/main.go@@ -42,6 +42,16 @@ func main() {logger.Fatalf("Failed to initialize WhatsApp service: %v", err)}+ // Auto-start if there's an existing session (no need to press Start button)+ if whatsappService.HasExistingSession() {+ logger.Info("Existing session found, auto-connecting...")+ if err := whatsappService.Start(); err != nil {+ logger.Warnf("Auto-start failed: %v (user can manually start)", err)+ }+ } else {+ logger.Info("No existing session, waiting for user to start pairing")+ }+// Create and start server (WebSocket RPC only)srv := server.New(whatsappService, logger)router := srv.SetupRoutes()diff --git a/server/whatsapp-rpc/src/go/whatsapp/history.go b/server/whatsapp-rpc/src/go/whatsapp/history.goindex 19eae8db..52ce648c 100644--- a/server/whatsapp-rpc/src/go/whatsapp/history.go+++ b/server/whatsapp-rpc/src/go/whatsapp/history.go@@ -152,6 +152,12 @@ func (h *HistoryStore) Close() error {return nil}+// ClearHistory deletes all messages from the history store+func (h *HistoryStore) ClearHistory() error {+ _, err := h.db.Exec("DELETE FROM message_history")+ return err+}+func boolToInt(b bool) int {if b {return 1diff --git a/server/whatsapp-rpc/src/go/whatsapp/service.go b/server/whatsapp-rpc/src/go/whatsapp/service.goindex 37c09982..401dda7c 100644--- a/server/whatsapp-rpc/src/go/whatsapp/service.go+++ b/server/whatsapp-rpc/src/go/whatsapp/service.go@@ -123,6 +123,17 @@ func NewService(dbConfig config.DatabaseConfig, logger *logrus.Logger) (*Servicereturn service, nil}+// HasExistingSession returns true if there's a stored session that can be used to auto-connect+func (s *Service) HasExistingSession() bool {+ hasClient := s.client != nil+ hasStore := hasClient && s.client.Store != nil+ hasID := hasStore && s.client.Store.ID != nil++ s.logger.Infof("HasExistingSession check: client=%v, store=%v, id=%v", hasClient, hasStore, hasID)++ return hasID+}+func (s *Service) safeEventSend(event Event) {if s.shutdown {return@@ -1916,23 +1927,20 @@ func (s *Service) Reset() error {}}+ // Clear message history (belongs to old instance)+ if s.historyStore != nil {+ s.logger.Info("Clearing message history...")+ if err := s.historyStore.ClearHistory(); err != nil {+ s.logger.Warnf("Failed to clear history: %v", err)+ }+ }+// Clear client reference to allow GC and release DB lockss.client = nils.container = nil// Give time for database to release locks- time.Sleep(2 * time.Second)-- // Delete database files- dbFiles := []string{s.dbPath, s.dbPath + "-wal", s.dbPath + "-shm"}- for _, file := range dbFiles {- if _, err := os.Stat(file); err == nil {- s.logger.Infof("Deleting: %s", file)- if err := os.Remove(file); err != nil {- s.logger.Warnf("Failed to delete %s: %v", file, err)- }- }- }+ time.Sleep(500 * time.Millisecond)// Reinitialize client with fresh databaseif err := s.reinitClient(); err != nil {