netra-zen 1.0.11__tar.gz → 1.1.2__tar.gz

{netra_zen-1.0.11/netra_zen.egg-info → netra_zen-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: netra-zen
-Version: 1.0.11
+Version: 1.1.2
 Summary: Multi-instance Claude orchestrator for parallel task execution
 Home-page: https://github.com/netra-systems/zen
 Author:  Systems

{netra_zen-1.0.11 → netra_zen-1.1.2/netra_zen.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: netra-zen
-Version: 1.0.11
+Version: 1.1.2
 Summary: Multi-instance Claude orchestrator for parallel task execution
 Home-page: https://github.com/netra-systems/zen
 Author:  Systems

{netra_zen-1.0.11 → netra_zen-1.1.2}/netra_zen.egg-info/SOURCES.txt

@@ -36,14 +36,23 @@ tests/__init__.py
 tests/test_agent_interface.py
 tests/test_agent_logs.py
 tests/test_apex_integration.py
+tests/test_apex_streaming_fix.py
 tests/test_apex_telemetry.py
+tests/test_apex_telemetry_live.py
+tests/test_apex_telemetry_mock.py
+tests/test_apex_telemetry_regression.py
 tests/test_cli_extensions.py
 tests/test_cli_integration.py
 tests/test_direct_command_execution.py
 tests/test_dollar_budget_enhancement.py
+tests/test_event_batching_issue.py
 tests/test_permission_fix_windows.py
 tests/test_pricing_engine.py
 tests/test_runner.py
+tests/test_thread_handshake.py
+tests/test_thread_id_fix.py
+tests/test_thread_management.py
+tests/test_thread_resolution.py
 tests/test_workspace_detection.py
 tests/test_zen_commands.py
 tests/test_zen_integration.py

{netra_zen-1.0.11 → netra_zen-1.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "netra-zen"
-version = "1.0.11"
+version = "1.1.2"
 description = "Multi-instance Claude orchestrator for parallel task execution"
 readme = "README.md"
 authors = [

{netra_zen-1.0.11 → netra_zen-1.1.2}/scripts/agent_cli.py

@@ -216,7 +216,9 @@ EMOJI_FALLBACKS = {
     '🔥': '[HOT]',
     '💭': '[THOUGHT]',
     '📥': '[INPUT]',
-    '📤': '[OUTPUT]'
+    '📤': '[OUTPUT]',
+    '📍': '[ENV]',
+    '🔗': '[LINK]'
 }
 
 def detect_terminal_capabilities(override_mode: str = None) -> str:
@@ -1592,18 +1594,18 @@ def show_startup_banner(config):
         config: Config object containing environment, backend_url, and auth_url
     """
     print()
-    print("━" * 75)
-    print("🤖 Netra Agent CLI - Interactive Mode")
-    print("━" * 75)
+    print("=" * 75)
+    safe_console_print("🤖 Netra Agent CLI - Interactive Mode", display_mode=detect_terminal_capabilities())
+    print("=" * 75)
     print()
-    print(f"📍 Environment: {config.environment.value.upper()}")
+    safe_console_print(f"📍 Environment: {config.environment.value.upper()}", display_mode=detect_terminal_capabilities())
     print()
 
-    print("🔗 Endpoints: ")
+    safe_console_print("🔗 Endpoints: ", display_mode=detect_terminal_capabilities())
     print(f"Backend: {config.backend_url}")
     print(f"Auth: {config.auth_url}")
     print()
-    print("━" * 75)
+    print("=" * 75)
     print()
 
 
@@ -2881,15 +2883,20 @@ class WebSocketClient:
                         self.connected = True
                         return True
                     else:
-                        # Handshake failed - backend might be old version
+                        # Handshake failed - backend might be using old reactive model
                         self.debug.debug_print(
-                            "WARNING: Handshake failed - backend may not support thread agreement",
+                            "WARNING: No proactive handshake received from server",
                             DebugLevel.BASIC,
                             style="yellow"
                         )
+                        self.debug.debug_print(
+                            "Server may be using pre-2025-10-09 architecture (reactive handshake)",
+                            DebugLevel.VERBOSE,
+                            style="yellow"
+                        )
 
                         # Still mark as connected for backward compatibility
-                        # Old backends might work without the handshake
+                        # Old backends might work without the proactive handshake
                         self.connected = True
                         return True
             except Exception as e:
@@ -2997,77 +3004,149 @@ class WebSocketClient:
 
     async def _perform_handshake(self) -> bool:
         """
-        SSOT: Perform handshake protocol to get backend-provided thread_id.
-        This ensures both CLI and backend agree on the thread_id for proper event routing.
+        Wait for proactive handshake from server (as of 2025-10-09).
 
-        Protocol:
-        1. Client sends handshake_request with client info
-        2. Backend responds with handshake_response containing thread_id and session info
-        3. Client extracts thread_id and sends session_acknowledged
+        Server Phase Alignment:
+        - INITIALIZING: WebSocket connection accepted
+        - AUTHENTICATING: User validation (happens during connect())
+        - HANDSHAKING: Server proactively sends handshake_response (we wait here)
+        - READY: Services initialized
+        - PROCESSING: Message handling begins
 
-        The handshake_response is distinct from connection_established to avoid
-        race conditions and clearly separate WebSocket connection from session handshake.
+        The client waits during server's HANDSHAKING phase to receive the
+        proactive handshake_response without sending any request.
         """
         try:
             import asyncio
 
             self.debug.debug_print(
-                "Starting handshake...",
+                "Waiting for server to enter HANDSHAKING phase and send handshake...",
                 DebugLevel.VERBOSE,
                 style="cyan"
             )
 
-            # Try to receive immediately (backend may send immediately)
+            # Server enters HANDSHAKING phase after authentication
+            # and proactively sends handshake_response
+            handshake_timeout = 10.0  # Wait up to 10 seconds
+            start_time = asyncio.get_event_loop().time()
+
             try:
-                # Non-blocking check if backend sent handshake_response immediately
-                # Use configurable timeout (default 2.0 seconds for initial check)
-                initial_timeout = min(2.0, self.handshake_timeout / 6)
-                response_msg = await asyncio.wait_for(self.ws.recv(), timeout=initial_timeout)
-                response = json.loads(response_msg)
-
-                # SSOT: Process any handshake-related response
-                return await self._process_any_handshake_response(response)
-            except asyncio.TimeoutError:
-                # Backend didn't send immediately, try sending a trigger message
-                pass  # Silent - this is normal for backends that wait for trigger
-
-            # If we didn't get handshake_response immediately, send a trigger
-            # This handles backends that wait for an initial message
-            trigger_message = {
-                "type": "handshake_request",
-                "client_type": "cli",
-                "client_version": "2.0.0",
-                "timestamp": datetime.now(timezone.utc).isoformat()
-            }
+                while (asyncio.get_event_loop().time() - start_time) < handshake_timeout:
+                    remaining_time = handshake_timeout - (asyncio.get_event_loop().time() - start_time)
 
-            self.debug.debug_print(
-                "Sending handshake_request...",
-                DebugLevel.VERBOSE,
-                style="cyan"
-            )
+                    # Be ready to receive messages during server's HANDSHAKING phase
+                    self.debug.debug_print(
+                        f"Listening for handshake (remaining: {remaining_time:.1f}s)...",
+                        DebugLevel.VERBOSE,
+                        style="dim"
+                    )
 
-            await self.ws.send(json.dumps(trigger_message))
+                    try:
+                        # Use the full remaining time for recv to avoid timeout errors
+                        # This prevents premature connection closure during handshake
+                        response_msg = await asyncio.wait_for(
+                            self.ws.recv(),
+                            timeout=remaining_time
+                        )
+                        response = json.loads(response_msg)
+                    except asyncio.TimeoutError:
+                        # Gracefully handle timeout - don't let it propagate and close connection
+                        self.debug.debug_print(
+                            "Handshake wait timed out after 10 seconds",
+                            DebugLevel.VERBOSE,
+                            style="yellow"
+                        )
+                        break  # Exit loop to handle timeout below
+                    except json.JSONDecodeError as e:
+                        # Handle JSON parsing errors gracefully
+                        self.debug.debug_print(
+                            f"Invalid JSON received during handshake: {e}",
+                            DebugLevel.VERBOSE,
+                            style="yellow"
+                        )
+                        continue  # Try to receive next message
+                    except websockets.exceptions.ConnectionClosed as e:
+                        # Connection closed during handshake - this is the issue!
+                        self.debug.debug_print(
+                            f"Connection closed during handshake wait: {e}",
+                            DebugLevel.BASIC,
+                            style="red"
+                        )
+                        return False  # Connection lost, can't continue
 
-            # Now wait for the response
-            try:
-                # Use configurable handshake timeout for main wait
-                response_msg = await asyncio.wait_for(self.ws.recv(), timeout=self.handshake_timeout)
-                response = json.loads(response_msg)
+                    msg_type = response.get('type', 'unknown')
+                    self.debug.debug_print(
+                        f"Received: {msg_type}",
+                        DebugLevel.VERBOSE,
+                        style="cyan"
+                    )
+
+                    # Check for the proactive handshake_response
+                    if msg_type == 'handshake_response':
+                        # Server is in HANDSHAKING phase and sent the handshake
+                        self.debug.debug_print(
+                            "✅ Server sent proactive handshake (HANDSHAKING phase)",
+                            DebugLevel.VERBOSE,
+                            style="green"
+                        )
 
-                # SSOT: Process any handshake-related response
-                return await self._process_any_handshake_response(response)
+                        # Process the handshake
+                        result = await self._process_handshake_response(response)
+
+                        if result:
+                            self.debug.debug_print(
+                                f"Handshake complete - Thread ID: {self.current_thread_id}",
+                                DebugLevel.BASIC,
+                                style="green"
+                            )
+                            self.debug.debug_print(
+                                "Server phases: AUTH ✓ → HANDSHAKING ✓ → READY",
+                                DebugLevel.VERBOSE,
+                                style="green"
+                            )
+
+                        return result
+
+                    # Handle other message types while waiting
+                    elif msg_type == 'connection_established':
+                        # This is from AUTHENTICATING phase completion
+                        self.debug.debug_print(
+                            "Connection established (AUTH phase) - waiting for HANDSHAKING phase",
+                            DebugLevel.VERBOSE,
+                            style="yellow"
+                        )
+                        # Store the event but continue waiting
+                        if hasattr(self, 'events'):
+                            self.events.append(WebSocketEvent.from_dict(response))
+
+                    else:
+                        # Other event types - store but keep waiting for handshake
+                        self.debug.debug_print(
+                            f"Storing {msg_type} event - still waiting for handshake",
+                            DebugLevel.VERBOSE,
+                            style="dim"
+                        )
+                        if hasattr(self, 'events'):
+                            self.events.append(WebSocketEvent.from_dict(response))
 
             except asyncio.TimeoutError:
-                # Timeout - log error concisely
-                self.debug.debug_print(
-                    "ERROR: Handshake timeout - no response from backend",
-                    DebugLevel.BASIC,
-                    style="red"
-                )
-                return False
+                pass  # Fall through to timeout handling below
+
+            # Timeout - server didn't send handshake
+            self.debug.debug_print(
+                "ERROR: Server did not send handshake within 10 seconds",
+                DebugLevel.BASIC,
+                style="red"
+            )
+            self.debug.debug_print(
+                "Server may not have HANDSHAKING phase (pre-2025-10-09 version)",
+                DebugLevel.BASIC,
+                style="yellow"
+            )
+            return False
 
         except Exception as e:
-            # Handshake error - log but don't completely fail
+            # Handshake error
             error_msg = f"WARNING: Handshake error: {e}"
             self.debug.log_error(e, "handshake protocol")
             self.debug.debug_print(error_msg, DebugLevel.BASIC, style="yellow")
@@ -3100,51 +3179,29 @@ class WebSocketClient:
             return await self._process_handshake_response(response)
 
         elif response_type == 'connection_established':
-            # Backend sends connection_established with connection_id as thread identifier
+            # connection_established is NOT a handshake response!
+            # It's just a WebSocket connection event. We should NOT acknowledge it.
+            # We need to wait for the actual handshake_response message.
             self.debug.debug_print(
-                "Processing connection_established as handshake response",
+                "Received connection_established - waiting for handshake_response",
                 DebugLevel.VERBOSE,
-                style="green"
+                style="yellow"
             )
 
-            # Extract connection_id from the data field and use as thread_id
+            # Extract connection_id for logging purposes only
             connection_data = response.get('data', {})
             connection_id = connection_data.get('connection_id')
 
-            if not connection_id:
+            if connection_id:
                 self.debug.debug_print(
-                    "ERROR: connection_established missing connection_id",
-                    DebugLevel.BASIC,
-                    style="red"
+                    f"Connection established with connection_id: {connection_id} (not using as thread_id)",
+                    DebugLevel.VERBOSE,
+                    style="yellow"
                 )
-                return False
-
-            # Use connection_id as thread_id (SSOT for thread identification)
-            self.current_thread_id = connection_id
-            self.run_id = connection_id  # Also use as run_id
-            self._update_thread_cache(connection_id)
-
-            self.debug.debug_print(
-                f"Handshake complete - Using connection_id as thread ID: {connection_id}",
-                DebugLevel.VERBOSE,
-                style="green"
-            )
 
-            # Send acknowledgment with the connection_id
-            ack_message = {
-                "type": "session_acknowledged",
-                "thread_id": connection_id,
-                "timestamp": datetime.now(timezone.utc).isoformat()
-            }
-
-            await self.ws.send(json.dumps(ack_message))
-            self.debug.debug_print(
-                f"Sent session_acknowledged with thread_id: {connection_id}",
-                DebugLevel.VERBOSE,
-                style="cyan"
-            )
-
-            return True
+            # Return False to indicate we're still waiting for handshake_response
+            # DO NOT send session_acknowledged here!
+            return False
 
         else:
             # Unexpected response type
@@ -3810,9 +3867,9 @@ class WebSocketClient:
         # Check if payload exceeds maximum allowed size
         if payload_size_mb > MAX_SIZE_MB:
             error_msg = f"""
-╔══════════════════════════════════════════════════════════════════════════════╗
-║                         ❌ PAYLOAD SIZE EXCEEDED                              ║
-╔══════════════════════════════════════════════════════════════════════════════╗
++==============================================================================+
+|                         ❌ PAYLOAD SIZE EXCEEDED                              |
++==============================================================================+
 
   Payload Size: {payload_size_mb:.2f} MB
   Maximum Allowed: {MAX_SIZE_MB:.1f} MB
@@ -3840,7 +3897,7 @@ class WebSocketClient:
 
 ✨ OPTIMAL PERFORMANCE: Keep payload under {OPTIMAL_SIZE_MB:.1f} MB for best results
 
-╚══════════════════════════════════════════════════════════════════════════════╝
++==============================================================================+
 """
             safe_console_print(error_msg, style="red")
             raise RuntimeError(f"Payload size ({payload_size_mb:.2f} MB) exceeds maximum allowed ({MAX_SIZE_MB:.1f} MB)")
@@ -3848,9 +3905,9 @@ class WebSocketClient:
         # Warn if payload is large but within limits
         if payload_size_mb > WARNING_SIZE_MB:
             warning_msg = f"""
-╔══════════════════════════════════════════════════════════════════════════════╗
-║                      ⚠️  LARGE PAYLOAD WARNING                                ║
-╔══════════════════════════════════════════════════════════════════════════════╗
++==============================================================================+
+|                      ⚠️  LARGE PAYLOAD WARNING                                |
++==============================================================================+
 
   Payload Size: {payload_size_mb:.2f} MB
   Maximum Allowed: {MAX_SIZE_MB:.1f} MB
@@ -3875,7 +3932,7 @@ class WebSocketClient:
   • Keep total payload under {OPTIMAL_SIZE_MB:.1f} MB for best results
   • Larger payloads may take longer to process
 
-╚══════════════════════════════════════════════════════════════════════════════╝
++==============================================================================+
 """
             safe_console_print(warning_msg, style="yellow")
 
@@ -3910,7 +3967,16 @@ class WebSocketClient:
                     type=data.get('type', 'unknown'),
                     data=data
                 )
-                self.events.append(event)
+                # Skip duplicate connection_established events after handshake
+                if event.type == 'connection_established' and self.connected and self.current_thread_id:
+                    self.debug.debug_print(
+                        "Ignoring duplicate connection_established (already connected with thread_id)",
+                        DebugLevel.VERBOSE,
+                        style="yellow"
+                    )
+                    # Don't append duplicate connection events
+                else:
+                    self.events.append(event)
 
                 # Handle connection_established as a basic WebSocket connection event
                 # Note: handshake_response is now used for thread_id exchange, not connection_established
@@ -4781,51 +4847,47 @@ class AgentCLI:
 
     async def _receive_events(self):
         """Background task to receive and display events"""
-        thinking_spinner = None
-        thinking_live = None
+        # Create persistent spinner that stays at bottom
+        thinking_spinner = Progress(
+            SpinnerColumn(spinner_name="dots"),
+            TextColumn("[dim]{task.description}"),
+            console=Console(file=sys.stderr),
+            transient=True
+        )
+        thinking_live = Live(thinking_spinner, console=Console(file=sys.stderr), refresh_per_second=10)
+        thinking_task = None
 
-        async def handle_event(event: WebSocketEvent):
-            nonlocal thinking_spinner, thinking_live
+        # Start the spinner live display
+        thinking_live.start()
 
-            # Stop spinner if it's running and we get any non-thinking/non-executing event
-            if thinking_live and event.type not in ["agent_thinking", "tool_executing"]:
-                thinking_live.stop()
-                thinking_live = None
-                thinking_spinner = None
+        async def handle_event(event: WebSocketEvent):
+            nonlocal thinking_task
 
             # Display event with enhanced formatting
             formatted_event = event.format_for_display(self.debug)
             safe_console_print(f"[{event.timestamp.strftime('%H:%M:%S')}] {formatted_event}")
 
-            # Start spinner for agent_thinking events (20-60 second wait indicator)
-            if event.type == "agent_thinking" and not thinking_live:
-                thought = event.data.get('thought', event.data.get('reasoning', ''))
-                spinner_text = truncate_with_ellipsis(thought, 60) if thought else "Processing..."
+            # Update spinner for thinking and tool_executing events
+            if event.type in ["agent_thinking", "tool_executing"]:
+                # Remove old task if exists
+                if thinking_task is not None:
+                    thinking_spinner.remove_task(thinking_task)
+                    thinking_task = None
 
-                thinking_spinner = Progress(
-                    SpinnerColumn(spinner_name="dots"),
-                    TextColumn("[cyan]{task.description}"),
-                    console=Console(file=sys.stderr),
-                    transient=True
-                )
-                thinking_live = Live(thinking_spinner, console=Console(file=sys.stderr), refresh_per_second=10)
-                thinking_live.start()
-                thinking_spinner.add_task(f"💭 {spinner_text}", total=None)
-
-            # Start spinner for tool_executing events
-            elif event.type == "tool_executing" and not thinking_live:
-                tool_name = event.data.get('tool', event.data.get('tool_name', 'Unknown'))
-                spinner_text = f"Executing {tool_name}..."
-
-                thinking_spinner = Progress(
-                    SpinnerColumn(spinner_name="dots"),
-                    TextColumn("[blue]{task.description}"),
-                    console=Console(file=sys.stderr),
-                    transient=True
-                )
-                thinking_live = Live(thinking_spinner, console=Console(file=sys.stderr), refresh_per_second=10)
-                thinking_live.start()
-                thinking_spinner.add_task(f"🔧 {spinner_text}", total=None)
+                # Add new task with latest event
+                if event.type == "agent_thinking":
+                    thought = event.data.get('thought', event.data.get('reasoning', ''))
+                    spinner_text = truncate_with_ellipsis(thought, 60) if thought else "Processing..."
+                    thinking_task = thinking_spinner.add_task(f"💭 {spinner_text}", total=None)
+                elif event.type == "tool_executing":
+                    tool_name = event.data.get('tool', event.data.get('tool_name', 'Unknown'))
+                    spinner_text = f"Executing {tool_name}..."
+                    thinking_task = thinking_spinner.add_task(f"🔧 {spinner_text}", total=None)
+
+            # Clear spinner for any other event type
+            elif thinking_task is not None:
+                thinking_spinner.remove_task(thinking_task)
+                thinking_task = None
 
             # Display raw data in verbose mode
             if self.debug.debug_level >= DebugLevel.DIAGNOSTIC:
@@ -4838,58 +4900,53 @@ class AgentCLI:
         try:
             await self.ws_client.receive_events(callback=handle_event)
         finally:
-            # Clean up spinner if it's still running
-            if thinking_live:
-                thinking_live.stop()
+            # Clean up spinner
+            thinking_live.stop()
 
     async def _receive_events_with_display(self):
         """ISSUE #1603 FIX: Enhanced event receiver with better display for single message mode"""
-        thinking_spinner = None
-        thinking_live = None
+        # Create persistent spinner that stays at bottom
+        thinking_spinner = Progress(
+            SpinnerColumn(spinner_name="dots"),
+            TextColumn("[dim]{task.description}"),
+            console=Console(file=sys.stderr),
+            transient=True
+        )
+        thinking_live = Live(thinking_spinner, console=Console(file=sys.stderr), refresh_per_second=10)
+        thinking_task = None
 
-        async def handle_event_with_display(event: WebSocketEvent):
-            nonlocal thinking_spinner, thinking_live
+        # Start the spinner live display
+        thinking_live.start()
 
-            # Stop spinner if it's running and we get any non-thinking/non-executing event
-            if thinking_live and event.type not in ["agent_thinking", "tool_executing"]:
-                thinking_live.stop()
-                thinking_live = None
-                thinking_spinner = None
+        async def handle_event_with_display(event: WebSocketEvent):
+            nonlocal thinking_task
 
             # Display event with enhanced formatting and emojis
             formatted_event = event.format_for_display(self.debug)
             timestamp = event.timestamp.strftime('%H:%M:%S')
             safe_console_print(f"[{timestamp}] {formatted_event}")
 
-            # Start spinner for agent_thinking events (20-60 second wait indicator)
-            if event.type == "agent_thinking" and not thinking_live:
-                thought = event.data.get('thought', event.data.get('reasoning', ''))
-                spinner_text = truncate_with_ellipsis(thought, 60) if thought else "Processing..."
+            # Update spinner for thinking and tool_executing events
+            if event.type in ["agent_thinking", "tool_executing"]:
+                # Remove old task if exists
+                if thinking_task is not None:
+                    thinking_spinner.remove_task(thinking_task)
+                    thinking_task = None
 
-                thinking_spinner = Progress(
-                    SpinnerColumn(spinner_name="dots"),
-                    TextColumn("[cyan]{task.description}"),
-                    console=Console(file=sys.stderr),
-                    transient=True
-                )
-                thinking_live = Live(thinking_spinner, console=Console(file=sys.stderr), refresh_per_second=10)
-                thinking_live.start()
-                thinking_spinner.add_task(f"💭 {spinner_text}", total=None)
-
-            # Start spinner for tool_executing events
-            elif event.type == "tool_executing" and not thinking_live:
-                tool_name = event.data.get('tool', event.data.get('tool_name', 'Unknown'))
-                spinner_text = f"Executing {tool_name}..."
-
-                thinking_spinner = Progress(
-                    SpinnerColumn(spinner_name="dots"),
-                    TextColumn("[blue]{task.description}"),
-                    console=Console(file=sys.stderr),
-                    transient=True
-                )
-                thinking_live = Live(thinking_spinner, console=Console(file=sys.stderr), refresh_per_second=10)
-                thinking_live.start()
-                thinking_spinner.add_task(f"🔧 {spinner_text}", total=None)
+                # Add new task with latest event
+                if event.type == "agent_thinking":
+                    thought = event.data.get('thought', event.data.get('reasoning', ''))
+                    spinner_text = truncate_with_ellipsis(thought, 60) if thought else "Processing..."
+                    thinking_task = thinking_spinner.add_task(f"💭 {spinner_text}", total=None)
+                elif event.type == "tool_executing":
+                    tool_name = event.data.get('tool', event.data.get('tool_name', 'Unknown'))
+                    spinner_text = f"Executing {tool_name}..."
+                    thinking_task = thinking_spinner.add_task(f"🔧 {spinner_text}", total=None)
+
+            # Clear spinner for any other event type
+            elif thinking_task is not None:
+                thinking_spinner.remove_task(thinking_task)
+                thinking_task = None
 
             # Issue #2177: WebSocket event validation
             if self.validate_events and self.event_validator:
@@ -4969,9 +5026,8 @@ class AgentCLI:
         try:
             await self.ws_client.receive_events(callback=handle_event_with_display)
         finally:
-            # Clean up spinner if it's still running
-            if thinking_live:
-                thinking_live.stop()
+            # Clean up spinner
+            thinking_live.stop()
 
     def _get_event_summary(self, event: WebSocketEvent) -> str:
         """ISSUE #1603 FIX: Get a concise summary of an event for display"""

{netra_zen-1.0.11 → netra_zen-1.1.2}/setup.py

@@ -8,7 +8,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="netra-zen",
-    version="1.0.11",
+    version="1.1.2",
     author=" Systems",
     author_email="pypi@netrasystems.ai",
     description="Multi-instance Claude orchestrator for parallel task execution",