agy-connect 0.1.0__tar.gz

agy_connect-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Antigravity Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agy_connect-0.1.0/PKG-INFO

@@ -0,0 +1,188 @@
+Metadata-Version: 2.4
+Name: agy-connect
+Version: 0.1.0
+Summary: A production-grade Python runtime for Antigravity CLI
+Author-email: Antigravity Team <team@example.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Dynamic: license-file
+
+# agy-connect
+
+![Python Version](https://img.shields.io/badge/python-3.9+-blue.svg)
+![License](https://img.shields.io/badge/license-MIT-green.svg)
+
+**agy-connect** is a production-grade Python runtime and SDK that bridges your Python applications seamlessly with the Antigravity CLI (`agy`).
+
+It completely abstracts away all subprocess management, inter-process communication, and session state tracking, providing a clean, robust, and strongly-typed API for interacting with the `agy` AI coding assistant natively in Python.
+
+---
+
+## Key Features
+
+* **Zero API Key Requirement:** `agy-connect` securely piggybacks off your local Antigravity CLI's existing credentials and setup.
+* **Native Context Memory:** Takes full advantage of `agy`'s native memory management by isolating chats into physical directory structures. Conversations maintain perfect memory across multiple requests!
+* **Real-time Streaming:** Fetch tokens as they arrive instantly using the async generators (`chat.stream()`).
+* **Session Management:** Built-in `SessionManager` utilizes LRU (Least Recently Used) caching with configurable auto-expiration to manage hundreds of simultaneous chats efficiently.
+* **Robust Process Management:** Handles batch processing intelligently. If `agy` hangs or crashes, the SDK detects it and optionally performs auto-recovery.
+* **Dual API Support:** Complete support for both highly scalable `asyncio` applications (via `SessionManager`) and simple synchronous scripts (via `Chat`).
+* **Health Metrics:** Check CPU/process uptime and state machine transitions in real time (`chat.health()`).
+
+---
+
+## Installation
+
+To install `agy-connect`, use `pip`:
+
+```bash
+pip install agy-connect
+```
+
+**Prerequisites:** You must have the [Antigravity CLI](https://antigravity.google/product/antigravity-cli) installed on your system.
+*If `agy` is missing from your system PATH, the library will gracefully raise an `AgyNotInstalled` exception guiding the user on how to install it.*
+
+---
+
+## Usage & Quick Start
+
+### 1. Synchronous Chatbot (Simple Scripts)
+The `Chat` class provides an easy-to-use, blocking interface perfect for automation scripts.
+
+```python
+from agy_connect import Chat
+
+def main():
+    chat = Chat()
+    print("User: Hello!")
+    
+    # Send a prompt and wait for the complete response
+    response = chat.send("Hello!")
+    print(f"Agy: {response}")
+    
+    # Context memory is naturally maintained!
+    response2 = chat.send("What did I just say?")
+    print(f"Agy: {response2}")
+    
+if __name__ == "__main__":
+    main()
+```
+
+### 2. Streaming Responses
+If you want to render text back to a user in real-time (like ChatGPT):
+
+```python
+import sys
+from agy_connect import Chat
+
+chat = Chat()
+
+print("Agy: ", end="")
+for chunk in chat.stream("Write a short poem about code."):
+    sys.stdout.write(chunk)
+    sys.stdout.flush()
+print()
+```
+
+### 3. Asynchronous APIs (FastAPI / Web Servers)
+For high-performance non-blocking code, use the `SessionManager`.
+
+```python
+import asyncio
+from agy_connect import SessionManager, Config
+
+async def run_server():
+    # Configure session limits and timeouts
+    config = Config(max_sessions=10, idle_timeout=300)
+    manager = SessionManager(config)
+    
+    # Request a specific session (Memory is tied to "user_123")
+    session = await manager.get("user_123")
+    
+    # Stream asynchronously
+    async for chunk in session.stream("Explain asyncio."):
+        print(chunk, end="", flush=True)
+        
+    # Cleanup memory
+    await manager.shutdown()
+
+asyncio.run(run_server())
+```
+
+---
+
+## API Reference
+
+The `Chat` and `Session` objects expose the following methods:
+
+| Method | Description |
+|--------|-------------|
+| `send(prompt: str)` | Sends a prompt synchronously and returns the complete string response. |
+| `stream(prompt: str)` | Generator that yields response tokens in real-time as they arrive. |
+| `save(filename: str)` | Saves the entire conversation history to a JSON file on disk. |
+| `load(filename: str)` | Reloads a previous conversation history from a JSON file. |
+| `reset()` | Wipes the current session's memory/history completely. |
+| `history()` | Returns the raw list of messages (dictionaries) in the current session. |
+| `health()` | Returns real-time health metrics (PID, uptime, state, last errors). |
+| `status()` | Returns the current string state of the adapter (e.g. `READY`, `BUSY`). |
+| `restart()` | Forces a reboot of the underlying state machine and adapter. |
+| `close()` / `shutdown()` | Gracefully cleans up all resources and background tasks. |
+
+---
+
+## Architecture & Design
+
+`agy-connect` uses an event-driven, state-machine architecture under the hood to ensure predictable process execution.
+
+### The Problem it Solves
+The Antigravity CLI intentionally disables its interactive REPL mode when standard streams are piped (waiting for an `EOF` before processing anything). This makes a long-running persistent subprocess impossible.
+
+### The Solution (Batch-Mode Strategy)
+`agy-connect` embraces batch-mode processing using isolated workspaces.
+1. When a new session is requested, a unique session folder is dynamically created (`/sessions/<session_id>`).
+2. When a prompt is sent, `agy-connect` explicitly prepends the entire Python-side tracked history to ensure context isn't lost.
+3. It spawns a fresh, ephemeral `agy` process in that directory, immediately flushes `stdin`, and sends an `EOF`.
+4. It attaches an async reader to `stdout` to yield the tokens back to your application as `agy` generates them, then terminates the ephemeral process cleanly.
+
+### State Machine
+Every adapter tracks its state strictly using `agy_connect.constants`:
+`STOPPED -> STARTING -> READY -> STREAMING -> READY`
+
+---
+
+## Configuration
+
+You can customize the library's behavior entirely by injecting a `Config` object:
+
+```python
+from agy_connect import Chat, Config
+
+config = Config(
+    executable_path="/custom/path/to/agy", # Override auto-discovery
+    idle_timeout=60,                       # Clean up session memory after 60s
+    stream_chunk_size=512,                 # Byte sizes yielded during streams
+    debug_mode=True                        # Enable verbose logger traces
+)
+
+chat = Chat(config)
+```
+
+---
+
+## Contributing
+
+Contributions, issues, and feature requests are welcome!
+Feel free to check the [issues page](https://github.com/Prince-1652/agy-connect/issues).
+
+## License
+
+This project is [MIT](https://github.com/Prince-1652/agy-connect/blob/main/LICENSE) licensed.

agy_connect-0.1.0/README.md

@@ -0,0 +1,169 @@
+# agy-connect
+
+![Python Version](https://img.shields.io/badge/python-3.9+-blue.svg)
+![License](https://img.shields.io/badge/license-MIT-green.svg)
+
+**agy-connect** is a production-grade Python runtime and SDK that bridges your Python applications seamlessly with the Antigravity CLI (`agy`).
+
+It completely abstracts away all subprocess management, inter-process communication, and session state tracking, providing a clean, robust, and strongly-typed API for interacting with the `agy` AI coding assistant natively in Python.
+
+---
+
+## Key Features
+
+* **Zero API Key Requirement:** `agy-connect` securely piggybacks off your local Antigravity CLI's existing credentials and setup.
+* **Native Context Memory:** Takes full advantage of `agy`'s native memory management by isolating chats into physical directory structures. Conversations maintain perfect memory across multiple requests!
+* **Real-time Streaming:** Fetch tokens as they arrive instantly using the async generators (`chat.stream()`).
+* **Session Management:** Built-in `SessionManager` utilizes LRU (Least Recently Used) caching with configurable auto-expiration to manage hundreds of simultaneous chats efficiently.
+* **Robust Process Management:** Handles batch processing intelligently. If `agy` hangs or crashes, the SDK detects it and optionally performs auto-recovery.
+* **Dual API Support:** Complete support for both highly scalable `asyncio` applications (via `SessionManager`) and simple synchronous scripts (via `Chat`).
+* **Health Metrics:** Check CPU/process uptime and state machine transitions in real time (`chat.health()`).
+
+---
+
+## Installation
+
+To install `agy-connect`, use `pip`:
+
+```bash
+pip install agy-connect
+```
+
+**Prerequisites:** You must have the [Antigravity CLI](https://antigravity.google/product/antigravity-cli) installed on your system.
+*If `agy` is missing from your system PATH, the library will gracefully raise an `AgyNotInstalled` exception guiding the user on how to install it.*
+
+---
+
+## Usage & Quick Start
+
+### 1. Synchronous Chatbot (Simple Scripts)
+The `Chat` class provides an easy-to-use, blocking interface perfect for automation scripts.
+
+```python
+from agy_connect import Chat
+
+def main():
+    chat = Chat()
+    print("User: Hello!")
+    
+    # Send a prompt and wait for the complete response
+    response = chat.send("Hello!")
+    print(f"Agy: {response}")
+    
+    # Context memory is naturally maintained!
+    response2 = chat.send("What did I just say?")
+    print(f"Agy: {response2}")
+    
+if __name__ == "__main__":
+    main()
+```
+
+### 2. Streaming Responses
+If you want to render text back to a user in real-time (like ChatGPT):
+
+```python
+import sys
+from agy_connect import Chat
+
+chat = Chat()
+
+print("Agy: ", end="")
+for chunk in chat.stream("Write a short poem about code."):
+    sys.stdout.write(chunk)
+    sys.stdout.flush()
+print()
+```
+
+### 3. Asynchronous APIs (FastAPI / Web Servers)
+For high-performance non-blocking code, use the `SessionManager`.
+
+```python
+import asyncio
+from agy_connect import SessionManager, Config
+
+async def run_server():
+    # Configure session limits and timeouts
+    config = Config(max_sessions=10, idle_timeout=300)
+    manager = SessionManager(config)
+    
+    # Request a specific session (Memory is tied to "user_123")
+    session = await manager.get("user_123")
+    
+    # Stream asynchronously
+    async for chunk in session.stream("Explain asyncio."):
+        print(chunk, end="", flush=True)
+        
+    # Cleanup memory
+    await manager.shutdown()
+
+asyncio.run(run_server())
+```
+
+---
+
+## API Reference
+
+The `Chat` and `Session` objects expose the following methods:
+
+| Method | Description |
+|--------|-------------|
+| `send(prompt: str)` | Sends a prompt synchronously and returns the complete string response. |
+| `stream(prompt: str)` | Generator that yields response tokens in real-time as they arrive. |
+| `save(filename: str)` | Saves the entire conversation history to a JSON file on disk. |
+| `load(filename: str)` | Reloads a previous conversation history from a JSON file. |
+| `reset()` | Wipes the current session's memory/history completely. |
+| `history()` | Returns the raw list of messages (dictionaries) in the current session. |
+| `health()` | Returns real-time health metrics (PID, uptime, state, last errors). |
+| `status()` | Returns the current string state of the adapter (e.g. `READY`, `BUSY`). |
+| `restart()` | Forces a reboot of the underlying state machine and adapter. |
+| `close()` / `shutdown()` | Gracefully cleans up all resources and background tasks. |
+
+---
+
+## Architecture & Design
+
+`agy-connect` uses an event-driven, state-machine architecture under the hood to ensure predictable process execution.
+
+### The Problem it Solves
+The Antigravity CLI intentionally disables its interactive REPL mode when standard streams are piped (waiting for an `EOF` before processing anything). This makes a long-running persistent subprocess impossible.
+
+### The Solution (Batch-Mode Strategy)
+`agy-connect` embraces batch-mode processing using isolated workspaces.
+1. When a new session is requested, a unique session folder is dynamically created (`/sessions/<session_id>`).
+2. When a prompt is sent, `agy-connect` explicitly prepends the entire Python-side tracked history to ensure context isn't lost.
+3. It spawns a fresh, ephemeral `agy` process in that directory, immediately flushes `stdin`, and sends an `EOF`.
+4. It attaches an async reader to `stdout` to yield the tokens back to your application as `agy` generates them, then terminates the ephemeral process cleanly.
+
+### State Machine
+Every adapter tracks its state strictly using `agy_connect.constants`:
+`STOPPED -> STARTING -> READY -> STREAMING -> READY`
+
+---
+
+## Configuration
+
+You can customize the library's behavior entirely by injecting a `Config` object:
+
+```python
+from agy_connect import Chat, Config
+
+config = Config(
+    executable_path="/custom/path/to/agy", # Override auto-discovery
+    idle_timeout=60,                       # Clean up session memory after 60s
+    stream_chunk_size=512,                 # Byte sizes yielded during streams
+    debug_mode=True                        # Enable verbose logger traces
+)
+
+chat = Chat(config)
+```
+
+---
+
+## Contributing
+
+Contributions, issues, and feature requests are welcome!
+Feel free to check the [issues page](https://github.com/Prince-1652/agy-connect/issues).
+
+## License
+
+This project is [MIT](https://github.com/Prince-1652/agy-connect/blob/main/LICENSE) licensed.

agy_connect-0.1.0/agy_connect/__init__.py

@@ -0,0 +1,17 @@
+"""
+agy-connect
+
+A production-grade Python runtime for Antigravity CLI.
+"""
+
+from .client import Chat
+from .manager import SessionManager
+from .config import Config
+from . import exceptions
+
+__all__ = [
+    "Chat",
+    "SessionManager",
+    "Config",
+    "exceptions"
+]

agy_connect-0.1.0/agy_connect/adapter.py

@@ -0,0 +1,106 @@
+"""AntigravityAdapter orchestrating process and communication."""
+
+import asyncio
+from typing import AsyncGenerator, Optional, Callable, Coroutine, Any, List
+from .config import Config
+from .process import ProcessManager
+from .state import StateMachine
+from .events import EventDispatcher, EVENT_PROCESS_CRASHED, EVENT_PROMPT_COMPLETED
+from .stream import SafeStreamer
+from .completion import CompletionDetector
+from .constants import (
+    STATE_STOPPED, STATE_STARTING, STATE_READY, STATE_BUSY,
+    STATE_STREAMING, STATE_ERROR, STATE_RESTARTING, DEFAULT_PROMPT_MARKER
+)
+from .exceptions import ProcessCrash, StreamError, InvalidState
+from .logger import get_logger
+
+logger = get_logger()
+
+class AntigravityAdapter:
+    """
+    The heart of the runtime. Manages state, process, and streaming.
+    Hides all subprocess implementation details from the rest of the library.
+    """
+    
+    def __init__(self, session_id: str, config: Config) -> None:
+        self.session_id = session_id
+        self.config = config
+        self.state = StateMachine()
+        self.events = EventDispatcher()
+        self.process = ProcessManager(session_id, config)
+        self.detector = CompletionDetector(marker=DEFAULT_PROMPT_MARKER)
+        self._background_tasks: List[asyncio.Task[Any]] = []
+        
+    async def start(self) -> None:
+        """Initialize the adapter."""
+        await self.state.transition(STATE_STARTING)
+        await self.state.transition(STATE_READY)
+            
+    async def stop(self) -> None:
+        """Stop the adapter."""
+        for task in self._background_tasks:
+            if not task.done():
+                task.cancel()
+        await self.process.terminate()
+        await self.state.transition(STATE_STOPPED)
+        
+    async def restart(self) -> None:
+        """Restart the adapter."""
+        await self.state.transition(STATE_RESTARTING)
+        await self.stop()
+        await self.start()
+        
+    async def _ensure_ready(self) -> None:
+        """Ensures the adapter is ready to process a prompt."""
+        if self.state.current != STATE_READY:
+            if self.state.current in (STATE_BUSY, STATE_STREAMING):
+                raise InvalidState("Adapter is currently busy with another prompt.")
+            if self.state.current == STATE_ERROR and self.config.auto_recover:
+                await self.restart()
+            else:
+                raise InvalidState(f"Adapter is in state: {self.state.current}")
+                
+    async def stream(self, prompt: str) -> AsyncGenerator[str, None]:
+        """
+        Sends a prompt and yields the response tokens.
+        """
+        await self._ensure_ready()
+        
+        await self.state.transition(STATE_BUSY)
+        
+        try:
+            # Spawn a new batch process
+            process = await self.process.spawn()
+            await self.state.transition(STATE_STREAMING)
+            
+            # Write prompt and close stdin so agy executes
+            await self.process.write_stdin_and_close(process, prompt)
+            
+            if not process.stdout:
+                raise ProcessCrash("No stdout available.")
+                
+            streamer = SafeStreamer(marker="", chunk_size=self.config.stream_chunk_size)
+            
+            async for chunk in streamer.stream(process.stdout):
+                yield chunk
+                
+            await process.wait()
+            
+            await self.events.emit(EVENT_PROMPT_COMPLETED)
+            await self.state.transition(STATE_READY)
+            
+        except Exception as e:
+            logger.error(f"Error during stream: {e}")
+            await self.state.transition(STATE_ERROR)
+            await self.events.emit(EVENT_PROCESS_CRASHED, error=str(e))
+            raise
+            
+    async def send(self, prompt: str) -> str:
+        """
+        Sends a prompt and returns the full response string.
+        """
+        response_parts = []
+        async for chunk in self.stream(prompt):
+            response_parts.append(chunk)
+        return "".join(response_parts)

agy_connect-0.1.0/agy_connect/checks.py

@@ -0,0 +1,52 @@
+"""Authentication checks for agy-connect."""
+
+import asyncio
+from typing import Optional
+from .exceptions import AuthenticationRequired, AgyNotInstalled
+from .utils import find_executable
+from .logger import get_logger
+
+logger = get_logger()
+
+async def check_authentication(executable_path: Optional[str] = None) -> bool:
+    """
+    Checks if the agy CLI is authenticated.
+    Runs an arbitrary command (e.g., `agy auth status`) to verify.
+    Returns True if authenticated, otherwise raises AuthenticationRequired.
+    """
+    try:
+        exe = find_executable(executable_path)
+    except AgyNotInstalled as e:
+        raise e
+        
+    logger.debug(f"Checking authentication using executable: {exe}")
+    
+    # Note: In a real integration, the exact command `agy auth status` or similar would be used.
+    # For this robust SDK, we will attempt to run it and parse stderr/stdout.
+    # If the tool just exits with a known auth error code, we catch it.
+    
+    try:
+        # Mocking the command structure since agy internal details are abstracted.
+        # This will need to be adapted based on real agy behavior.
+        process = await asyncio.create_subprocess_exec(
+            exe, "--help", # Using help as a safe fallback command to see if it even runs
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        stdout, stderr = await process.communicate()
+        
+        output = stdout.decode() + stderr.decode()
+        
+        # If output explicitly mentions "login" or "authentication required"
+        if "authenticate" in output.lower() or "login" in output.lower():
+             raise AuthenticationRequired("Antigravity CLI is not authenticated. Please login first.")
+             
+        return True
+    except FileNotFoundError:
+        raise AgyNotInstalled("Executable not found during auth check.")
+    except Exception as e:
+        if isinstance(e, AuthenticationRequired):
+            raise
+        logger.warning(f"Could not verify authentication status: {e}")
+        # Proceed cautiously
+        return True

agy_connect-0.1.0/agy_connect/client.py

@@ -0,0 +1,122 @@
+"""Synchronous client interface for agy-connect."""
+
+import asyncio
+import threading
+import uuid
+from typing import Iterator, Optional, Dict, Any, List
+from .config import Config
+from .session import Session
+from .manager import SessionManager
+
+# A global thread to run the asyncio loop for synchronous API
+_loop_thread: Optional[threading.Thread] = None
+_loop: Optional[asyncio.AbstractEventLoop] = None
+_loop_lock = threading.Lock()
+
+def _start_background_loop(loop: asyncio.AbstractEventLoop) -> None:
+    asyncio.set_event_loop(loop)
+    loop.run_forever()
+
+def _get_loop() -> asyncio.AbstractEventLoop:
+    global _loop, _loop_thread
+    with _loop_lock:
+        if _loop is None:
+            _loop = asyncio.new_event_loop()
+            _loop_thread = threading.Thread(target=_start_background_loop, args=(_loop,), daemon=True)
+            _loop_thread.start()
+        return _loop
+        
+def _run_coroutine(coro: Any) -> Any:
+    """Run a coroutine thread-safely in the background loop."""
+    loop = _get_loop()
+    future = asyncio.run_coroutine_threadsafe(coro, loop)
+    return future.result()
+
+class Chat:
+    """
+    Synchronous Chat interface representing one independent conversation.
+    """
+    
+    def __init__(self, config: Optional[Config] = None) -> None:
+        self.config = config or Config()
+        self.session_id = str(uuid.uuid4())
+        self._session = Session(self.session_id, self.config)
+        _run_coroutine(self._session.initialize())
+        
+    def send(self, prompt: str) -> str:
+        """Send a prompt and wait for the full response."""
+        return _run_coroutine(self._session.send(prompt))
+        
+    def stream(self, prompt: str) -> Iterator[str]:
+        """Stream the response chunks synchronously."""
+        loop = _get_loop()
+        
+        # We use a thread-safe queue to pass chunks from async generator to sync iterator
+        q: "asyncio.Queue[Optional[str]]" = asyncio.Queue()
+        
+        async def _consume_stream() -> None:
+            try:
+                async for chunk in self._session.stream(prompt):
+                    await q.put(chunk)
+                await q.put(None) # EOF
+            except Exception as e:
+                # We could put the exception in the queue, but for simplicity
+                await q.put(None)
+                
+        asyncio.run_coroutine_threadsafe(_consume_stream(), loop)
+        
+        while True:
+            # We must wait for items in the queue thread-safely
+            future = asyncio.run_coroutine_threadsafe(q.get(), loop)
+            chunk = future.result()
+            if chunk is None:
+                break
+            yield chunk
+            
+    def history(self) -> List[Dict[str, str]]:
+        """Retrieve the conversation history."""
+        return self._session.history.get_all()
+        
+    def save(self, filepath: str) -> None:
+        """Save history to a file."""
+        self._session.history.save(filepath)
+        
+    def load(self, filepath: str) -> None:
+        """Load history from a file."""
+        self._session.history.load(filepath)
+        
+    def reset(self) -> None:
+        """Reset the conversation history."""
+        self._session.history.clear()
+        
+    def restart(self) -> None:
+        """Restart the underlying process."""
+        _run_coroutine(self._session.adapter.restart())
+        
+    def interrupt(self) -> None:
+        """Interrupt the current generation (restarts the process)."""
+        self.restart()
+        
+    def status(self) -> str:
+        """Get the current state of the adapter."""
+        return self._session.adapter.state.current
+        
+    def health(self) -> Dict[str, Any]:
+        """Get health metrics."""
+        h = self._session.health.get_status(
+            process_alive=self._session.adapter.process.is_running,
+            pid=self._session.adapter.process.pid,
+            queue_length=self._session.queue.qsize() if hasattr(self._session, 'queue') else 0, # Since we removed RequestQueue for Lock, queue length is N/A
+            current_state=self._session.adapter.state.current
+        )
+        return {
+            "process_alive": h.process_alive,
+            "pid": h.pid,
+            "uptime": h.uptime,
+            "current_state": h.current_state,
+            "last_error": h.last_error
+        }
+        
+    def close(self) -> None:
+        """Close the session and terminate the process."""
+        _run_coroutine(self._session.cleanup())