Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.
Rust agentai-agentapplecomputer-usecomputer-use-agentcontainerizationcuadesktop-automationhacktoberfestlumemacosmanusoperatorswiftvirtualizationvirtualization-frameworkwindowswindows-sandbox
Add dev container, fix lints
f-trycuaafce3b9e66b7
diff --git a/.dockerignore b/.dockerignorenew file mode 100644index 0000000000..8546ffff3e--- /dev/null+++ b/.dockerignore@@ -0,0 +1,37 @@+# Version control+.git+.github+.gitignore++# Environment and cache+.venv+.env+.env.local+__pycache__+*.pyc+*.pyo+*.pyd+.Python+.pytest_cache+.pdm-build++# Distribution / packaging+dist+build+*.egg-info++# Development+.vscode+.idea+*.swp+*.swo++# Docs+docs/site++# Notebooks+notebooks/.ipynb_checkpoints++# Docker+Dockerfile+.dockerignore\ No newline at end of filediff --git a/Dockerfile b/Dockerfilenew file mode 100644index 0000000000..c1e8bbf887--- /dev/null+++ b/Dockerfile@@ -0,0 +1,55 @@+FROM python:3.11-slim++# Set environment variables+ENV PYTHONUNBUFFERED=1 \+ PYTHONDONTWRITEBYTECODE=1 \+ PIP_NO_CACHE_DIR=1 \+ PIP_DISABLE_PIP_VERSION_CHECK=1 \+ PYTHONPATH="/app/libs/core:/app/libs/computer:/app/libs/agent:/app/libs/som:/app/libs/pylume:/app/libs/computer-server"++# Install system dependencies for ARM architecture+RUN apt-get update && apt-get install -y --no-install-recommends \+ git \+ build-essential \+ libgl1-mesa-glx \+ libglib2.0-0 \+ libxcb-xinerama0 \+ libxkbcommon-x11-0 \+ cmake \+ pkg-config \+ curl \+ iputils-ping \+ net-tools \+ sed \+ && apt-get clean \+ && rm -rf /var/lib/apt/lists/*++# Set working directory+WORKDIR /app++# Copy the entire project temporarily+# We'll mount the real source code over this at runtime+COPY . /app/++# Create a simple .env.local file for build.sh+RUN echo "PYTHON_BIN=python" > /app/.env.local++# Modify build.sh to skip virtual environment creation+RUN sed -i 's/python -m venv .venv/echo "Skipping venv creation in Docker"/' /app/scripts/build.sh && \+ sed -i 's/source .venv\/bin\/activate/echo "Skipping venv activation in Docker"/' /app/scripts/build.sh && \+ sed -i 's/find . -type d -name ".venv" -exec rm -rf {} +/echo "Skipping .venv removal in Docker"/' /app/scripts/build.sh && \+ chmod +x /app/scripts/build.sh++# Run the build script to install dependencies+RUN cd /app && ./scripts/build.sh++# Clean up the source files now that dependencies are installed+# When we run the container, we'll mount the actual source code+RUN rm -rf /app/* /app/.??*++# Note: This Docker image doesn't contain the lume executable (macOS-specific)+# Instead, it relies on connecting to a lume server running on the host machine+# via host.docker.internal:3000++# Default command+CMD ["bash"]\ No newline at end of filediff --git a/docs/Developer-Guide.md b/docs/Developer-Guide.mdindex 6fd95fce38..96c19a98a4 100644--- a/docs/Developer-Guide.md+++ b/docs/Developer-Guide.md@@ -4,24 +4,29 @@The project is organized as a monorepo with these main packages:- `libs/core/` - Base package with telemetry support-- `libs/pylume/` - Python bindings for Lume-- `libs/computer/` - Core computer interaction library+- `libs/computer/` - Computer-use interface (CUI) library- `libs/agent/` - AI agent library with multi-provider support-- `libs/som/` - Computer vision and NLP processing library (formerly omniparser)-- `libs/computer-server/` - Server implementation for computer control-- `libs/lume/` - Swift implementation for enhanced macOS integration+- `libs/som/` - Set-of-Mark parser+- `libs/computer-server/` - Server component for VM+- `libs/lume/` - Lume CLI+- `libs/pylume/` - Python bindings for LumeEach package has its own virtual environment and dependencies, managed through PDM.### Local Development Setup-1. Clone the repository:+1. Install Lume CLI:+```bash+/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/trycua/cua/main/libs/lume/scripts/install.sh)"+```++2. Clone the repository:```bashgit clone https://github.com/trycua/cua.gitcd cua```-2. Create a `.env.local` file in the root directory with your API keys:+3. Create a `.env.local` file in the root directory with your API keys:```bash# Required for Anthropic providerANTHROPIC_API_KEY=your_anthropic_key_here@@ -30,7 +35,7 @@ ANTHROPIC_API_KEY=your_anthropic_key_hereOPENAI_API_KEY=your_openai_key_here```-3. Run the build script to set up all packages:+4. Run the build script to set up all packages:```bash./scripts/build.sh```@@ -41,9 +46,9 @@ This will:- Set up the correct Python path- Install development tools-4. Open the workspace in VSCode or Cursor:+5. Open the workspace in VSCode or Cursor:```bash-# Using VSCode or Cursor+# For Cua Python developmentcode .vscode/py.code-workspace# For Lume (Swift) development@@ -56,9 +61,55 @@ Using the workspace file is strongly recommended as it:- Enables debugging configurations- Maintains consistent settings across packages+### Docker Development Environment++As an alternative to running directly on your host machine, you can use Docker for development. This approach has several advantages:++- Ensures consistent development environment across different machines+- Isolates dependencies from your host system+- Works well for cross-platform development+- Avoids conflicts with existing Python installations++#### Prerequisites++- Docker installed on your machine+- Lume server running on your host (port 3000): `lume serve`++#### Setup and Usage++1. Build the development Docker image:+```bash+./scripts/run-docker-dev.sh build+```++2. Run an example in the container:+```bash+./scripts/run-docker-dev.sh run computer_examples.py+```++3. Get an interactive shell in the container:+```bash+./scripts/run-docker-dev.sh run --interactive+```++4. Stop any running containers:+```bash+./scripts/run-docker-dev.sh stop+```++#### How it Works++The Docker development environment:+- Installs all required Python dependencies in the container+- Mounts your source code from the host at runtime+- Automatically configures the connection to use host.docker.internal:3000 for accessing the Lume server on your host machine+- Preserves your code changes without requiring rebuilds (source code is mounted as a volume)++> **Note**: The Docker container doesn't include the macOS-specific Lume executable. Instead, it connects to the Lume server running on your host machine via host.docker.internal:3000. Make sure to start the Lume server on your host before running examples in the container.+### Cleanup and Reset-If you need to clean up the environment and start fresh:+If you need to clean up the environment (non-docker) and start fresh:```bash./scripts/cleanup.shdiff --git a/examples/agent_examples.py b/examples/agent_examples.pyindex ebcb1070ea..d17045b734 100644--- a/examples/agent_examples.py+++ b/examples/agent_examples.py@@ -5,13 +5,13 @@ import asyncioimport loggingimport tracebackfrom pathlib import Path-from datetime import datetimeimport signalfrom computer import Computer# Import the unified agent class and types-from agent import ComputerAgent, AgentLoop, LLMProvider, LLM+from agent import AgentLoop, LLMProvider, LLM+from agent.core.computer_agent import ComputerAgent# Import utility functionsfrom utils import load_dotenv_files, handle_sigint@@ -23,7 +23,8 @@ logger = logging.getLogger(__name__)async def run_omni_agent_example():"""Run example of using the ComputerAgent with OpenAI and Omni provider."""- print(f"\n=== Example: ComputerAgent with OpenAI and Omni provider ===")+ print("\n=== Example: ComputerAgent with OpenAI and Omni provider ===")+try:# Create Computer instance with default parameterscomputer = Computer(verbosity=logging.DEBUG)@@ -31,10 +32,10 @@ async def run_omni_agent_example():# Create agent with loop and provideragent = ComputerAgent(computer=computer,- # loop=AgentLoop.OMNI,- loop=AgentLoop.ANTHROPIC,- # model=LLM(provider=LLMProvider.OPENAI, name="gpt-4.5-preview"),- model=LLM(provider=LLMProvider.ANTHROPIC, name="claude-3-7-sonnet-20250219"),+ # loop=AgentLoop.ANTHROPIC,+ loop=AgentLoop.OMNI,+ model=LLM(provider=LLMProvider.OPENAI, name="gpt-4.5-preview"),+ # model=LLM(provider=LLMProvider.ANTHROPIC, name="claude-3-7-sonnet-20250219"),save_trajectory=True,trajectory_dir=str(Path("trajectories")),only_n_most_recent_images=3,@@ -69,14 +70,15 @@ async def run_omni_agent_example():print(f"Task {i} completed")except Exception as e:- logger.error(f"Error in run_anthropic_agent_example: {e}")+ logger.error(f"Error in run_omni_agent_example: {e}")traceback.print_exc()raisefinally:# Clean up resourcesif computer and computer._initialized:try:- await computer.stop()+ # await computer.stop()+ passexcept Exception as e:logger.warning(f"Error stopping computer: {e}")diff --git a/examples/computer_examples.py b/examples/computer_examples.pyindex b5e9fc84e3..697ff83e59 100644--- a/examples/computer_examples.py+++ b/examples/computer_examples.py@@ -28,6 +28,8 @@ from computer.utils import get_image_sizeasync def main():try:print("\n=== Using direct initialization ===")++ # Create computer with configured hostcomputer = Computer(display="1024x768", # Higher resolutionmemory="8GB", # More memory@@ -48,10 +50,10 @@ async def main():print(f"Accessibility tree: {accessibility_tree}")# Screen Actions Examples- print("\n=== Screen Actions ===")- screenshot = await computer.interface.screenshot()- with open("screenshot_direct.png", "wb") as f:- f.write(screenshot)+ # print("\n=== Screen Actions ===")+ # screenshot = await computer.interface.screenshot()+ # with open("screenshot_direct.png", "wb") as f:+ # f.write(screenshot)screen_size = await computer.interface.get_screen_size()print(f"Screen size: {screen_size}")diff --git a/libs/agent/agent/__init__.py b/libs/agent/agent/__init__.pyindex cbc46bf62c..c521f345a5 100644--- a/libs/agent/agent/__init__.py+++ b/libs/agent/agent/__init__.py@@ -48,9 +48,7 @@ except Exception as e:# Other issues with telemetrylogger.warning(f"Error initializing telemetry: {e}")-from .core.factory import AgentFactory-from .core.agent import ComputerAgentfrom .providers.omni.types import LLMProvider, LLM-from .types.base import Provider, AgentLoop+from .types.base import AgentLoop-__all__ = ["AgentFactory", "Provider", "ComputerAgent", "AgentLoop", "LLMProvider", "LLM"]+__all__ = ["AgentLoop", "LLMProvider", "LLM"]diff --git a/libs/agent/agent/core/__init__.py b/libs/agent/agent/core/__init__.pyindex 68deb67e8e..19a57b5fca 100644--- a/libs/agent/agent/core/__init__.py+++ b/libs/agent/agent/core/__init__.py@@ -1,6 +1,5 @@"""Core agent components."""-from .base_agent import BaseComputerAgentfrom .loop import BaseLoopfrom .messages import (create_user_message,@@ -12,7 +11,7 @@ from .messages import (ImageRetentionConfig,)from .callbacks import (- CallbackManager,+ CallbackManager,CallbackHandler,BaseCallbackManager,ContentCallback,@@ -21,9 +20,8 @@ from .callbacks import ()__all__ = [- "BaseComputerAgent",- "BaseLoop",- "CallbackManager",+ "BaseLoop",+ "CallbackManager","CallbackHandler","BaseMessageManager","ImageRetentionConfig",diff --git a/libs/agent/agent/core/agent.py b/libs/agent/agent/core/agent.pydeleted file mode 100644index f737f8ce31..0000000000--- a/libs/agent/agent/core/agent.py+++ /dev/null@@ -1,252 +0,0 @@-"""Unified computer agent implementation that supports multiple loops."""--import os-import logging-import asyncio-import time-import uuid-from typing import Any, AsyncGenerator, Dict, List, Optional, TYPE_CHECKING, Union, cast-from datetime import datetime-from enum import Enum--from computer import Computer--from ..types.base import Provider, AgentLoop-from .base_agent import BaseComputerAgent-from ..core.telemetry import record_agent_initialization--# Only import types for type checking to avoid circular imports-if TYPE_CHECKING:- from ..providers.anthropic.loop import AnthropicLoop- from ..providers.omni.loop import OmniLoop- from ..providers.omni.parser import OmniParser--# Import the provider types-from ..providers.omni.types import LLMProvider, LLM, Model, LLMModel--logger = logging.getLogger(__name__)--# Default models for different providers-DEFAULT_MODELS = {- LLMProvider.OPENAI: "gpt-4o",- LLMProvider.ANTHROPIC: "claude-3-7-sonnet-20250219",-}--# Map providers to their environment variable names-ENV_VARS = {- LLMProvider.OPENAI: "OPENAI_API_KEY",- LLMProvider.ANTHROPIC: "ANTHROPIC_API_KEY",-}---class ComputerAgent(BaseComputerAgent):- """Unified implementation of the computer agent supporting multiple loop types.-- This class consolidates the previous AnthropicComputerAgent and OmniComputerAgent- into a single implementation with configurable loop type.- """-- def __init__(- self,- computer: Computer,- loop: AgentLoop = AgentLoop.OMNI,- model: Optional[Union[LLM, Dict[str, str], str]] = None,- api_key: Optional[str] = None,- save_trajectory: bool = True,- trajectory_dir: Optional[str] = "trajectories",- only_n_most_recent_images: Optional[int] = None,- max_retries: int = 3,- verbosity: int = logging.INFO,- telemetry_enabled: bool = True,- **kwargs,- ):- """Initialize a ComputerAgent instance.-- Args:- computer: The Computer instance to control- loop: The agent loop to use: ANTHROPIC or OMNI- model: The model to use. Can be a string, dict or LLM object.- Defaults to LLM for the loop type.- api_key: The API key to use. If None, will use environment variables.- save_trajectory: Whether to save the trajectory.- trajectory_dir: The directory to save trajectories to.- only_n_most_recent_images: Only keep this many most recent images.- max_retries: Maximum number of retries for failed requests.- verbosity: Logging level (standard Python logging levels).- telemetry_enabled: Whether to enable telemetry tracking. Defaults to True.- **kwargs: Additional keyword arguments to pass to the loop.- """- super().__init__(computer)- self._configure_logging(verbosity)- logger.info(f"Initializing ComputerAgent with {loop} loop")-- # Store telemetry preference- self.telemetry_enabled = telemetry_enabled-- # Process the model configuration- self.model = self._process_model_config(model, loop)- self.loop_type = loop- self.api_key = api_key-- # Store computer- self.computer = computer-- # Save trajectory settings- self.save_trajectory = save_trajectory- self.trajectory_dir = trajectory_dir- self.only_n_most_recent_images = only_n_most_recent_images-- # Store the max retries setting- self.max_retries = max_retries-- # Initialize message history- self.messages = []-- # Extra kwargs for the loop- self.loop_kwargs = kwargs-- # Initialize the actual loop implementation- self.loop = self._init_loop()-- # Record initialization in telemetry if enabled- if telemetry_enabled:- record_agent_initialization()-- def _process_model_config(- self, model_input: Optional[Union[LLM, Dict[str, str], str]], loop: AgentLoop- ) -> LLM:- """Process and normalize model configuration.-- Args:- model_input: Input model configuration (LLM, dict, string, or None)- loop: The loop type being used-- Returns:- Normalized LLM instance- """- # Handle case where model_input is None- if model_input is None:- # Use Anthropic for Anthropic loop, OpenAI for Omni loop- default_provider = (- LLMProvider.ANTHROPIC if loop == AgentLoop.ANTHROPIC else LLMProvider.OPENAI- )- return LLM(provider=default_provider)-- # Handle case where model_input is already a LLM or one of its aliases- if isinstance(model_input, (LLM, Model, LLMModel)):- return model_input-- # Handle case where model_input is a dict- if isinstance(model_input, dict):- provider = model_input.get("provider", LLMProvider.OPENAI)- if isinstance(provider, str):- provider = LLMProvider(provider)- return LLM(provider=provider, name=model_input.get("name"))-- # Handle case where model_input is a string (model name)- if isinstance(model_input, str):- default_provider = (- LLMProvider.ANTHROPIC if loop == AgentLoop.ANTHROPIC else LLMProvider.OPENAI- )- return LLM(provider=default_provider, name=model_input)-- raise ValueError(f"Unsupported model configuration: {model_input}")-- def _configure_logging(self, verbosity: int):- """Configure logging based on verbosity level."""- # Use the logging level directly without mapping- logger.setLevel(verbosity)- logging.getLogger("agent").setLevel(verbosity)-- # Log the verbosity level that was set- if verbosity <= logging.DEBUG:- logger.info("Agent logging set to DEBUG level (full debug information)")- elif verbosity <= logging.INFO:- logger.info("Agent logging set to INFO level (standard output)")- elif verbosity <= logging.WARNING:- logger.warning("Agent logging set to WARNING level (warnings and errors only)")- elif verbosity <= logging.ERROR:- logger.warning("Agent logging set to ERROR level (errors only)")- elif verbosity <= logging.CRITICAL:- logger.warning("Agent logging set to CRITICAL level (critical errors only)")-- def _init_loop(self) -> Any:- """Initialize the loop based on the loop_type.-- Returns:- Initialized loop instance- """- # Lazy import OmniLoop and OmniParser to avoid circular imports- from ..providers.omni.loop import OmniLoop- from ..providers.omni.parser import OmniParser-- if self.loop_type == AgentLoop.ANTHROPIC:- from ..providers.anthropic.loop import AnthropicLoop-- # Ensure we always have a valid model name- model_name = self.model.name or DEFAULT_MODELS[LLMProvider.ANTHROPIC]-- return AnthropicLoop(- api_key=self.api_key,- model=model_name,- computer=self.computer,- save_trajectory=self.save_trajectory,- base_dir=self.trajectory_dir,- only_n_most_recent_images=self.only_n_most_recent_images,- **self.loop_kwargs,- )-- # Initialize parser for OmniLoop with appropriate device- if "parser" not in self.loop_kwargs:- self.loop_kwargs["parser"] = OmniParser()-- # Ensure we always have a valid model name- model_name = self.model.name or DEFAULT_MODELS[self.model.provider]-- return OmniLoop(- provider=self.model.provider,- api_key=self.api_key,- model=model_name,- computer=self.computer,- save_trajectory=self.save_trajectory,- base_dir=self.trajectory_dir,- only_n_most_recent_images=self.only_n_most_recent_images,- **self.loop_kwargs,- )-- async def _execute_task(self, task: str) -> AsyncGenerator[Dict[str, Any], None]:- """Execute a task using the appropriate agent loop.-- Args:- task: The task to execute-- Returns:- AsyncGenerator yielding task outputs- """- logger.info(f"Executing task: {task}")-- try:- # Create a message from the task- task_message = {"role": "user", "content": task}- messages_with_task = self.messages + [task_message]-- # Use the run method of the loop- async for output in self.loop.run(messages_with_task):- yield output- except Exception as e:- logger.error(f"Error executing task: {e}")- raise- finally:- pass-- async def _execute_action(self, action_type: str, **action_params) -> Any:- """Execute an action with telemetry tracking."""- try:- # Execute the action- result = await super()._execute_action(action_type, **action_params)- return result- except Exception as e:- logger.exception(f"Error executing action {action_type}: {e}")- raise- finally:- passdiff --git a/libs/agent/agent/core/base_agent.py b/libs/agent/agent/core/base_agent.pydeleted file mode 100644index 7227bd5a41..0000000000--- a/libs/agent/agent/core/base_agent.py+++ /dev/null@@ -1,164 +0,0 @@-"""Base computer agent implementation."""--import asyncio-import logging-import os-from abc import ABC, abstractmethod-from typing import Any, AsyncGenerator, Dict, Optional--from computer import Computer--from ..types.base import Provider--logger = logging.getLogger(__name__)---class BaseComputerAgent(ABC):- """Base class for computer agents."""-- def __init__(- self,- max_retries: int = 3,- computer: Optional[Computer] = None,- screenshot_dir: Optional[str] = None,- log_dir: Optional[str] = None,- **kwargs,- ):- """Initialize the base computer agent.-- Args:- max_retries: Maximum number of retry attempts- computer: Optional Computer instance- screenshot_dir: Directory to save screenshots- log_dir: Directory to save logs (set to None to disable logging to files)- **kwargs: Additional provider-specific arguments- """- self.max_retries = max_retries- self.computer = computer or Computer()- self.queue = asyncio.Queue()- self.screenshot_dir = screenshot_dir- self.log_dir = log_dir- self._retry_count = 0- self.provider = Provider.UNKNOWN-- # Setup logging- if self.log_dir:- os.makedirs(self.log_dir, exist_ok=True)- logger.info(f"Created logs directory: {self.log_dir}")-- # Setup screenshots directory- if self.screenshot_dir:- os.makedirs(self.screenshot_dir, exist_ok=True)- logger.info(f"Created screenshots directory: {self.screenshot_dir}")-- logger.info("BaseComputerAgent initialized")-- async def run(self, task: str) -> AsyncGenerator[Dict[str, Any], None]:- """Run a task using the computer agent.-- Args:- task: Task description-- Yields:- Task execution updates- """- try:- logger.info(f"Running task: {task}")-- # Initialize the computer if needed- await self._init_if_needed()-- # Execute the task and yield results- # The _execute_task method should be implemented to yield results- async for result in self._execute_task(task):- yield result-- except Exception as e:- logger.error(f"Error in agent run method: {str(e)}")- yield {- "role": "assistant",- "content": f"Error: {str(e)}",- "metadata": {"title": "❌ Error"},- }-- async def _init_if_needed(self):- """Initialize the computer interface if it hasn't been initialized yet."""- if not self.computer._initialized:- logger.info("Computer not initialized, initializing now...")- try:- # Call run directly without setting the flag first- await self.computer.run()- logger.info("Computer interface initialized successfully")- except Exception as e:- logger.error(f"Error initializing computer interface: {str(e)}")- raise-- async def __aenter__(self):- """Initialize the agent when used as a context manager."""- logger.info("Entering BaseComputerAgent context")-- # In case the computer wasn't initialized- try:- # Initialize the computer only if not already initialized- logger.info("Checking if computer is already initialized...")- if not self.computer._initialized:- logger.info("Initializing computer in __aenter__...")- # Use the computer's __aenter__ directly instead of calling run()- # This avoids the circular dependency- await self.computer.__aenter__()- logger.info("Computer initialized in __aenter__")- else:- logger.info("Computer already initialized, skipping initialization")-- # Take a test screenshot to verify the computer is working- logger.info("Testing computer with a screenshot...")- try:- test_screenshot = await self.computer.interface.screenshot()- # Determine the screenshot size based on its type- if isinstance(test_screenshot, bytes):- size = len(test_screenshot)- else:- # Assume it's an object with base64_image attribute- try:- size = len(test_screenshot.base64_image)- except AttributeError:- size = "unknown"- logger.info(f"Screenshot test successful, size: {size}")- except Exception as e:- logger.error(f"Screenshot test failed: {str(e)}")- # Even though screenshot failed, we continue since some tests might not need it- except Exception as e:- logger.error(f"Error initializing computer in __aenter__: {str(e)}")- raise-- return self-- async def __aexit__(self, exc_type, exc_val, exc_tb):- """Cleanup computer resources if needed."""- logger.info("Cleaning up agent resources")-- # Do any necessary cleanup- # We're not shutting down the computer here as it might be shared- # Just log that we're exiting- if exc_type:- logger.error(f"Exiting agent context with error: {exc_type.__name__}: {exc_val}")- else:- logger.info("Exiting agent context normally")-- # If we have a queue, make sure to signal it's done- if hasattr(self, "queue") and self.queue:- await self.queue.put(None) # Signal that we're done-- @abstractmethod- async def _execute_task(self, task: str) -> AsyncGenerator[Dict[str, Any], None]:- """Execute a task. Must be implemented by subclasses.-- This is an async method that returns an AsyncGenerator. Implementations- should use 'yield' statements to produce results asynchronously.- """- yield {- "role": "assistant",- "content": "Base class method called",- "metadata": {"title": "Error"},- }- raise NotImplementedError("Subclasses must implement _execute_task")diff --git a/libs/agent/agent/core/computer_agent.py b/libs/agent/agent/core/computer_agent.pyindex 875f7049d5..0702ef1171 100644--- a/libs/agent/agent/core/computer_agent.py+++ b/libs/agent/agent/core/computer_agent.py@@ -1,69 +1,251 @@"""Main entry point for computer agents."""+import asyncioimport logging-from typing import Any, AsyncGenerator, Dict, Optional+import os+from typing import Any, AsyncGenerator, Dict, Optional, cast+from dataclasses import dataclassfrom computer import Computer-from ..types.base import Provider-from .factory import AgentFactory+from ..providers.anthropic.loop import AnthropicLoop+from ..providers.omni.loop import OmniLoop+from ..providers.omni.parser import OmniParser+from ..providers.omni.types import LLMProvider, LLM+from .. import AgentLooplogging.basicConfig(level=logging.INFO)logger = logging.getLogger(__name__)+# Default models for different providers+DEFAULT_MODELS = {+ LLMProvider.OPENAI: "gpt-4o",+ LLMProvider.ANTHROPIC: "claude-3-7-sonnet-20250219",+}++# Map providers to their environment variable names+ENV_VARS = {+ LLMProvider.OPENAI: "OPENAI_API_KEY",+ LLMProvider.ANTHROPIC: "ANTHROPIC_API_KEY",+}+class ComputerAgent:"""A computer agent that can perform automated tasks using natural language instructions."""- def __init__(self, provider: Provider, computer: Optional[Computer] = None, **kwargs):+ def __init__(+ self,+ computer: Computer,+ model: LLM,+ loop: AgentLoop,+ max_retries: int = 3,+ screenshot_dir: Optional[str] = None,+ log_dir: Optional[str] = None,+ api_key: Optional[str] = None,+ save_trajectory: bool = True,+ trajectory_dir: str = "trajectories",+ only_n_most_recent_images: Optional[int] = None,+ parser: Optional[OmniParser] = None,+ verbosity: int = logging.INFO,+ ):"""Initialize the ComputerAgent.Args:- provider: The AI provider to use (e.g., Provider.ANTHROPIC)- computer: Optional Computer instance. If not provided, one will be created with default settings.- **kwargs: Additional provider-specific arguments+ computer: Computer instance. If not provided, one will be created with default settings.+ max_retries: Maximum number of retry attempts.+ screenshot_dir: Directory to save screenshots.+ log_dir: Directory to save logs (set to None to disable logging to files).+ model: LLM object containing provider and model name. Takes precedence over provider/model_name.+ provider: The AI provider to use (e.g., LLMProvider.ANTHROPIC). Only used if model is None.+ api_key: The API key for the provider. If not provided, will look for environment variable.+ model_name: The model name to use. Only used if model is None.+ save_trajectory: Whether to save the trajectory.+ trajectory_dir: Directory to save the trajectory.+ only_n_most_recent_images: Maximum number of recent screenshots to include in API requests.+ parser: Parser instance for the OmniLoop. Only used if provider is not ANTHROPIC.+ verbosity: Logging level."""- self.provider = provider- self._computer = computer- self._kwargs = kwargs- self._agent = None+ # Basic agent configuration+ self.max_retries = max_retries+ self.computer = computer or Computer()+ self.queue = asyncio.Queue()+ self.screenshot_dir = screenshot_dir+ self.log_dir = log_dir+ self._retry_count = 0self._initialized = Falseself._in_context = False- # Create provider-specific agent using factory- self._agent = AgentFactory.create(provider=provider, computer=computer, **kwargs)+ # Set logging level+ logger.setLevel(verbosity)++ # Setup logging+ if self.log_dir:+ os.makedirs(self.log_dir, exist_ok=True)+ logger.info(f"Created logs directory: {self.log_dir}")++ # Setup screenshots directory+ if self.screenshot_dir:+ os.makedirs(self.screenshot_dir, exist_ok=True)+ logger.info(f"Created screenshots directory: {self.screenshot_dir}")++ # Use the provided LLM object+ self.provider = model.provider+ actual_model_name = model.name or DEFAULT_MODELS.get(self.provider, "")++ # Ensure we have a valid model name+ if not actual_model_name:+ actual_model_name = DEFAULT_MODELS.get(self.provider, "")+ if not actual_model_name:+ raise ValueError(+ f"No model specified for provider {self.provider} and no default found"+ )++ # Ensure computer is properly cast for typing purposes+ computer_instance = cast(Computer, self.computer)++ # Get API key from environment if not provided+ actual_api_key = api_key or os.environ.get(ENV_VARS[self.provider], "")+ if not actual_api_key:+ raise ValueError(f"No API key provided for {self.provider}")++ # Initialize the appropriate loop based on the loop parameter+ if loop == AgentLoop.ANTHROPIC:+ self._loop = AnthropicLoop(+ api_key=actual_api_key,+ model=actual_model_name,+ computer=computer_instance,+ save_trajectory=save_trajectory,+ base_dir=trajectory_dir,+ only_n_most_recent_images=only_n_most_recent_images,+ )+ else:+ # Default to OmniLoop for other loop types+ # Initialize parser if not provided+ actual_parser = parser or OmniParser()++ self._loop = OmniLoop(+ provider=self.provider,+ api_key=actual_api_key,+ model=actual_model_name,+ computer=computer_instance,+ save_trajectory=save_trajectory,+ base_dir=trajectory_dir,+ only_n_most_recent_images=only_n_most_recent_images,+ parser=actual_parser,+ )++ logger.info(+ f"ComputerAgent initialized with provider: {self.provider}, model: {actual_model_name}"+ )async def __aenter__(self):- """Enter the async context manager."""+ """Initialize the agent when used as a context manager."""+ logger.info("Entering ComputerAgent context")self._in_context = True++ # In case the computer wasn't initialized+ try:+ # Initialize the computer only if not already initialized+ logger.info("Checking if computer is already initialized...")+ if not self.computer._initialized:+ logger.info("Initializing computer in __aenter__...")+ # Use the computer's __aenter__ directly instead of calling run()+ await self.computer.__aenter__()+ logger.info("Computer initialized in __aenter__")+ else:+ logger.info("Computer already initialized, skipping initialization")++ # Take a test screenshot to verify the computer is working+ logger.info("Testing computer with a screenshot...")+ try:+ test_screenshot = await self.computer.interface.screenshot()+ # Determine the screenshot size based on its type+ if isinstance(test_screenshot, (bytes, bytearray, memoryview)):+ size = len(test_screenshot)+ elif hasattr(test_screenshot, "base64_image"):+ size = len(test_screenshot.base64_image)+ else:+ size = "unknown"+ logger.info(f"Screenshot test successful, size: {size}")+ except Exception as e:+ logger.error(f"Screenshot test failed: {str(e)}")+ # Even though screenshot failed, we continue since some tests might not need it+ except Exception as e:+ logger.error(f"Error initializing computer in __aenter__: {str(e)}")+ raise+await self.initialize()return selfasync def __aexit__(self, exc_type, exc_val, exc_tb):- """Exit the async context manager."""+ """Cleanup agent resources if needed."""+ logger.info("Cleaning up agent resources")self._in_context = False+ # Do any necessary cleanup+ # We're not shutting down the computer here as it might be shared+ # Just log that we're exiting+ if exc_type:+ logger.error(f"Exiting agent context with error: {exc_type.__name__}: {exc_val}")+ else:+ logger.info("Exiting agent context normally")++ # If we have a queue, make sure to signal it's done+ if hasattr(self, "queue") and self.queue:+ await self.queue.put(None) # Signal that we're done+async def initialize(self) -> None:"""Initialize the agent and its components."""if not self._initialized:- if not self._in_context and self._computer:- # If not in context manager but have a computer, initialize it- await self._computer.run()+ # Always initialize the computer if available+ if self.computer and not self.computer._initialized:+ await self.computer.run()self._initialized = True+ async def _init_if_needed(self):+ """Initialize the computer interface if it hasn't been initialized yet."""+ if not self.computer._initialized:+ logger.info("Computer not initialized, initializing now...")+ try:+ # Call run directly+ await self.computer.run()+ logger.info("Computer interface initialized successfully")+ except Exception as e:+ logger.error(f"Error initializing computer interface: {str(e)}")+ raise+async def run(self, task: str) -> AsyncGenerator[Dict[str, Any], None]:- """Run the agent with a given task."""- if not self._initialized:- await self.initialize()+ """Run a task using the computer agent.++ Args:+ task: Task description++ Yields:+ Task execution updates+ """+ try:+ logger.info(f"Running task: {task}")++ # Initialize the computer if needed+ if not self._initialized:+ await self.initialize()++ # Format task as a message+ messages = [{"role": "user", "content": task}]- if self._agent is None:- logger.error("Agent not initialized properly")- yield {"error": "Agent not initialized properly"}- return+ # Pass properly formatted messages to the loop+ if self._loop is None:+ logger.error("Loop not initialized properly")+ yield {"error": "Loop not initialized properly"}+ return- async for result in self._agent.run(task):- yield result+ # Execute the task and yield results+ async for result in self._loop.run(messages):+ yield result- @property- def computer(self) -> Optional[Computer]:- """Get the underlying computer instance."""- return self._agent.computer if self._agent else None+ except Exception as e:+ logger.error(f"Error in agent run method: {str(e)}")+ yield {+ "role": "assistant",+ "content": f"Error: {str(e)}",+ "metadata": {"title": "❌ Error"},+ }diff --git a/libs/agent/agent/core/experiment.py b/libs/agent/agent/core/experiment.pyindex c5162e785c..1dae8c3efd 100644--- a/libs/agent/agent/core/experiment.py+++ b/libs/agent/agent/core/experiment.py@@ -84,7 +84,21 @@ class ExperimentManager:if isinstance(data, dict):result = {}for k, v in data.items():- result[k] = self.sanitize_log_data(v)+ # Special handling for 'data' field in Anthropic message source+ if k == "data" and isinstance(v, str) and len(v) > 1000:+ result[k] = f"[BASE64_DATA_LENGTH_{len(v)}]"+ # Special handling for the 'media_type' key which indicates we're in an image block+ elif k == "media_type" and "image" in str(v):+ result[k] = v+ # If we're in an image block, look for a sibling 'data' field with base64 content+ if (+ "data" in result+ and isinstance(result["data"], str)+ and len(result["data"]) > 1000+ ):+ result["data"] = f"[BASE64_DATA_LENGTH_{len(result['data'])}]"+ else:+ result[k] = self.sanitize_log_data(v)return resultelif isinstance(data, list):return [self.sanitize_log_data(item) for item in data]@@ -93,15 +107,18 @@ class ExperimentManager:else:return data- def save_screenshot(self, img_base64: str, action_type: str = "") -> None:+ def save_screenshot(self, img_base64: str, action_type: str = "") -> Optional[str]:"""Save a screenshot to the experiment directory.Args:img_base64: Base64 encoded screenshotaction_type: Type of action that triggered the screenshot++ Returns:+ Path to the saved screenshot or None if there was an error"""if not self.current_turn_dir:- return+ return Nonetry:# Increment screenshot counterdiff --git a/libs/agent/agent/core/factory.py b/libs/agent/agent/core/factory.pydeleted file mode 100644index e2454134d1..0000000000--- a/libs/agent/agent/core/factory.py+++ /dev/null@@ -1,102 +0,0 @@-"""Factory for creating provider-specific agents."""--from typing import Optional, Dict, Any, List--from computer import Computer-from ..types.base import Provider-from .base_agent import BaseComputerAgent--# Import provider-specific implementations-_ANTHROPIC_AVAILABLE = False-_OPENAI_AVAILABLE = False-_OLLAMA_AVAILABLE = False-_OMNI_AVAILABLE = False--# Try importing providers-try:- import anthropic- from ..providers.anthropic.agent import AnthropicComputerAgent-- _ANTHROPIC_AVAILABLE = True-except ImportError:- pass--try:- import openai-- _OPENAI_AVAILABLE = True-except ImportError:- pass--try:- from ..providers.omni.agent import OmniComputerAgent-- _OMNI_AVAILABLE = True-except ImportError:- pass---class AgentFactory:- """Factory for creating provider-specific agent implementations."""-- @staticmethod- def create(- provider: Provider, computer: Optional[Computer] = None, **kwargs: Any- ) -> BaseComputerAgent:- """Create an agent based on the specified provider.-- Args:- provider: The AI provider to use- computer: Optional Computer instance- **kwargs: Additional provider-specific arguments-- Returns:- A provider-specific agent implementation-- Raises:- ImportError: If provider dependencies are not installed- ValueError: If provider is not supported- """- # Create a Computer instance if none is provided- if computer is None:- computer = Computer()-- if provider == Provider.ANTHROPIC:- if not _ANTHROPIC_AVAILABLE:- raise ImportError(- "Anthropic provider requires additional dependencies. "- "Install them with: pip install cua-agent[anthropic]"- )- return AnthropicComputerAgent(max_retries=3, computer=computer, **kwargs)- elif provider == Provider.OPENAI:- if not _OPENAI_AVAILABLE:- raise ImportError(- "OpenAI provider requires additional dependencies. "- "Install them with: pip install cua-agent[openai]"- )- raise NotImplementedError("OpenAI provider not yet implemented")- elif provider == Provider.OLLAMA:- if not _OLLAMA_AVAILABLE:- raise ImportError(- "Ollama provider requires additional dependencies. "- "Install them with: pip install cua-agent[ollama]"- )- # Only import ollama when actually creating an Ollama agent- try:- import ollama- from ..providers.ollama.agent import OllamaComputerAgent-- return OllamaComputerAgent(max_retries=3, computer=computer, **kwargs)- except ImportError:- raise ImportError(- "Failed to import ollama package. " "Install it with: pip install ollama"- )- elif provider == Provider.OMNI:- if not _OMNI_AVAILABLE:- raise ImportError(- "Omni provider requires additional dependencies. "- "Install them with: pip install cua-agent[omni]"- )- return OmniComputerAgent(max_retries=3, computer=computer, **kwargs)- else:- raise ValueError(f"Unsupported provider: {provider}")diff --git a/libs/agent/agent/core/loop.py b/libs/agent/agent/core/loop.pyindex 81b41f6e75..ad6c3ccad2 100644--- a/libs/agent/agent/core/loop.py+++ b/libs/agent/agent/core/loop.py@@ -141,9 +141,6 @@ class BaseLoop(ABC):# Initialize API clientawait self.initialize_client()- # Initialize computer- await self.computer.initialize()-logger.info("Initialization complete.")returnexcept Exception as e:@@ -173,15 +170,22 @@ class BaseLoop(ABC):base64_image = ""# Handle different types of screenshot returns- if isinstance(screenshot, bytes):+ if isinstance(screenshot, (bytes, bytearray, memoryview)):# Raw bytes screenshotbase64_image = base64.b64encode(screenshot).decode("utf-8")elif hasattr(screenshot, "base64_image"):# Object-style screenshot with attributes- base64_image = screenshot.base64_image- if hasattr(screenshot, "width") and hasattr(screenshot, "height"):- width = screenshot.width- height = screenshot.height+ # Type checking can't infer these attributes, but they exist at runtime+ # on certain screenshot return types+ base64_image = getattr(screenshot, "base64_image")+ width = (+ getattr(screenshot, "width", width) if hasattr(screenshot, "width") else width+ )+ height = (+ getattr(screenshot, "height", height)+ if hasattr(screenshot, "height")+ else height+ )# Create parsed screen dataparsed_screen = {diff --git a/libs/agent/agent/core/telemetry.py b/libs/agent/agent/core/telemetry.pyindex 39865f55b5..3c708b174a 100644--- a/libs/agent/agent/core/telemetry.py+++ b/libs/agent/agent/core/telemetry.py@@ -4,58 +4,70 @@ import loggingimport osimport platformimport sys-from typing import Dict, Any+from typing import Dict, Any, Callable# Import the core telemetry moduleTELEMETRY_AVAILABLE = False++# Local fallbacks in case core telemetry isn't available+def _noop(*args: Any, **kwargs: Any) -> None:+ """No-op function for when telemetry is not available."""+ pass+++# Define default functions with unique names to avoid shadowing+_default_record_event = _noop+_default_increment_counter = _noop+_default_set_dimension = _noop+_default_get_telemetry_client = lambda: None+_default_flush = _noop+_default_is_telemetry_enabled = lambda: False+_default_is_telemetry_globally_disabled = lambda: True++# Set the actual functions to the defaults initially+record_event = _default_record_event+increment_counter = _default_increment_counter+set_dimension = _default_set_dimension+get_telemetry_client = _default_get_telemetry_client+flush = _default_flush+is_telemetry_enabled = _default_is_telemetry_enabled+is_telemetry_globally_disabled = _default_is_telemetry_globally_disabled++logger = logging.getLogger("cua.agent.telemetry")+try:+ # Import from core telemetryfrom core.telemetry import (- record_event,- increment,- get_telemetry_client,- flush,- is_telemetry_enabled,- is_telemetry_globally_disabled,+ record_event as core_record_event,+ increment as core_increment,+ get_telemetry_client as core_get_telemetry_client,+ flush as core_flush,+ is_telemetry_enabled as core_is_telemetry_enabled,+ is_telemetry_globally_disabled as core_is_telemetry_globally_disabled,)+ # Override the default functions with actual implementations+ record_event = core_record_event+ get_telemetry_client = core_get_telemetry_client+ flush = core_flush+ is_telemetry_enabled = core_is_telemetry_enabled+ is_telemetry_globally_disabled = core_is_telemetry_globally_disabled+def increment_counter(counter_name: str, value: int = 1) -> None:"""Wrapper for increment to maintain backward compatibility."""if is_telemetry_enabled():- increment(counter_name, value)+ core_increment(counter_name, value)def set_dimension(name: str, value: Any) -> None:"""Set a dimension that will be attached to all events."""- logger = logging.getLogger("cua.agent.telemetry")logger.debug(f"Setting dimension {name}={value}")TELEMETRY_AVAILABLE = True- logger = logging.getLogger("cua.agent.telemetry")logger.info("Successfully imported telemetry")except ImportError as e:- logger = logging.getLogger("cua.agent.telemetry")logger.warning(f"Could not import telemetry: {e}")- TELEMETRY_AVAILABLE = False---# Local fallbacks in case core telemetry isn't available-def _noop(*args: Any, **kwargs: Any) -> None:- """No-op function for when telemetry is not available."""- pass---logger = logging.getLogger("cua.agent.telemetry")--# If telemetry isn't available, use no-op functions-if not TELEMETRY_AVAILABLE:logger.debug("Telemetry not available, using no-op functions")- record_event = _noop # type: ignore- increment_counter = _noop # type: ignore- set_dimension = _noop # type: ignore- get_telemetry_client = lambda: None # type: ignore- flush = _noop # type: ignore- is_telemetry_enabled = lambda: False # type: ignore- is_telemetry_globally_disabled = lambda: True # type: ignore# Get system info once to use in telemetrySYSTEM_INFO = {@@ -71,7 +83,7 @@ def enable_telemetry() -> bool:Returns:bool: True if telemetry was successfully enabled, False otherwise"""- global TELEMETRY_AVAILABLE+ global TELEMETRY_AVAILABLE, record_event, increment_counter, get_telemetry_client, flush, is_telemetry_enabled, is_telemetry_globally_disabled# Check if globally disabled using core functionif TELEMETRY_AVAILABLE and is_telemetry_globally_disabled():diff --git a/libs/agent/agent/providers/anthropic/loop.py b/libs/agent/agent/providers/anthropic/loop.pyindex de6d513378..af60138ae8 100644--- a/libs/agent/agent/providers/anthropic/loop.py+++ b/libs/agent/agent/providers/anthropic/loop.py@@ -17,6 +17,7 @@ from anthropic.types.beta import (BetaTextBlock,BetaTextBlockParam,BetaToolUseBlockParam,+ BetaContentBlockParam,)# Computer@@ -24,12 +25,12 @@ from computer import Computer# Base importsfrom ...core.loop import BaseLoop-from ...core.messages import ImageRetentionConfig+from ...core.messages import ImageRetentionConfig as CoreImageRetentionConfig# Anthropic provider-specific importsfrom .api.client import AnthropicClientFactory, BaseAnthropicClientfrom .tools.manager import ToolManager-from .messages.manager import MessageManager+from .messages.manager import MessageManager, ImageRetentionConfigfrom .callbacks.manager import CallbackManagerfrom .prompts import SYSTEM_PROMPTfrom .types import LLMProvider@@ -48,8 +49,8 @@ class AnthropicLoop(BaseLoop):def __init__(self,api_key: str,+ computer: Computer,model: str = "claude-3-7-sonnet-20250219", # Fixed model- computer: Optional[Computer] = None,only_n_most_recent_images: Optional[int] = 2,base_dir: Optional[str] = "trajectories",max_retries: int = 3,@@ -69,7 +70,7 @@ class AnthropicLoop(BaseLoop):retry_delay: Delay between retries in secondssave_trajectory: Whether to save trajectory data"""- # Initialize base class+ # Initialize base class with core configsuper().__init__(computer=computer,model=model,@@ -93,8 +94,8 @@ class AnthropicLoop(BaseLoop):self.message_manager = Noneself.callback_manager = None- # Configure image retention- self.image_retention_config = ImageRetentionConfig(+ # Configure image retention with core config+ self.image_retention_config = CoreImageRetentionConfig(num_images_to_keep=only_n_most_recent_images)@@ -113,7 +114,7 @@ class AnthropicLoop(BaseLoop):# Initialize message managerself.message_manager = MessageManager(- ImageRetentionConfig(+ image_retention_config=ImageRetentionConfig(num_images_to_keep=self.only_n_most_recent_images, enable_caching=True))@@ -250,6 +251,10 @@ class AnthropicLoop(BaseLoop):await self._process_screen(parsed_screen, self.message_history)# Prepare messages and make API call+ if self.message_manager is None:+ raise RuntimeError(+ "Message manager not initialized. Call initialize_client() first."+ )prepared_messages = self.message_manager.prepare_messages(cast(List[BetaMessageParam], self.message_history.copy()))@@ -257,7 +262,7 @@ class AnthropicLoop(BaseLoop):# Create new turn directory for this API callself._create_turn_dir()- # Make API call+ # Use _make_api_call instead of direct client call to ensure loggingresponse = await self._make_api_call(prepared_messages)# Handle the response@@ -287,6 +292,11 @@ class AnthropicLoop(BaseLoop):Returns:API response"""+ if self.client is None:+ raise RuntimeError("Client not initialized. Call initialize_client() first.")+ if self.tool_manager is None:+ raise RuntimeError("Tool manager not initialized. Call initialize_client() first.")+last_error = Nonefor attempt in range(self.max_retries):@@ -297,6 +307,7 @@ class AnthropicLoop(BaseLoop):"max_tokens": self.max_tokens,"system": SYSTEM_PROMPT,}+ # Let ExperimentManager handle sanitizationself._log_api_call("request", request_data)# Setup betas and system@@ -320,7 +331,7 @@ class AnthropicLoop(BaseLoop):betas=betas,)- # Log success response+ # Let ExperimentManager handle sanitizationself._log_api_call("response", request_data, response)return response@@ -365,25 +376,38 @@ class AnthropicLoop(BaseLoop):})+ if self.callback_manager is None:+ raise RuntimeError(+ "Callback manager not initialized. Call initialize_client() first."+ )+# Handle tool use blocks and collect resultstool_result_content = []for content_block in response_params:# Notify callback of content- self.callback_manager.on_content(content_block)+ self.callback_manager.on_content(cast(BetaContentBlockParam, content_block))# Handle tool useif content_block.get("type") == "tool_use":+ if self.tool_manager is None:+ raise RuntimeError(+ "Tool manager not initialized. Call initialize_client() first."+ )result = await self.tool_manager.execute_tool(name=content_block["name"],tool_input=cast(Dict[str, Any], content_block["input"]),)# Create tool result and add to content- tool_result = self._make_tool_result(result, content_block["id"])+ tool_result = self._make_tool_result(+ cast(ToolResult, result), content_block["id"]+ )tool_result_content.append(tool_result)# Notify callback of tool result- self.callback_manager.on_tool_result(result, content_block["id"])+ self.callback_manager.on_tool_result(+ cast(ToolResult, result), content_block["id"]+ )# If no tool results, we're doneif not tool_result_content:@@ -495,13 +519,13 @@ class AnthropicLoop(BaseLoop):result_text = f"<s>{result.system}</s>\n{result_text}"return result_text- def _handle_content(self, content: Dict[str, Any]) -> None:+ def _handle_content(self, content: BetaContentBlockParam) -> None:"""Handle content updates from the assistant."""if content.get("type") == "text":- text = content.get("text", "")+ text_content = cast(BetaTextBlockParam, content)+ text = text_content["text"]if text == "<DONE>":return-logger.info(f"Assistant: {text}")def _handle_tool_result(self, result: ToolResult, tool_id: str) -> None:@@ -517,5 +541,10 @@ class AnthropicLoop(BaseLoop):"""Handle API interactions."""if error:logger.error(f"API error: {error}")+ self._log_api_call("error", request, error=error)else:logger.debug(f"API request: {request}")+ if response:+ self._log_api_call("response", request, response)+ else:+ self._log_api_call("request", request)diff --git a/libs/agent/agent/providers/anthropic/messages/manager.py b/libs/agent/agent/providers/anthropic/messages/manager.pyindex c513613566..f29af1b7e5 100644--- a/libs/agent/agent/providers/anthropic/messages/manager.py+++ b/libs/agent/agent/providers/anthropic/messages/manager.py@@ -90,7 +90,9 @@ class MessageManager:blocks_with_cache_control += 1# Add cache control to the last content block onlyif content and len(content) > 0:- content[-1]["cache_control"] = {"type": "ephemeral"}+ content[-1]["cache_control"] = BetaCacheControlEphemeralParam(+ type="ephemeral"+ )else:# Remove any existing cache controlif content and len(content) > 0:diff --git a/libs/agent/agent/providers/anthropic/tools/base.py b/libs/agent/agent/providers/anthropic/tools/base.pyindex 2edbfeff5d..447d58ac70 100644--- a/libs/agent/agent/providers/anthropic/tools/base.py+++ b/libs/agent/agent/providers/anthropic/tools/base.py@@ -6,7 +6,7 @@ from typing import Any, Dictfrom anthropic.types.beta import BetaToolUnionParam-from ....core.tools.base import BaseTool, ToolError, ToolResult, ToolFailure, CLIResult+from ....core.tools.base import BaseToolclass BaseAnthropicTool(BaseTool, metaclass=ABCMeta):diff --git a/libs/agent/agent/providers/anthropic/tools/collection.py b/libs/agent/agent/providers/anthropic/tools/collection.pyindex c4e8c95c0b..2ed5aa1f43 100644--- a/libs/agent/agent/providers/anthropic/tools/collection.py+++ b/libs/agent/agent/providers/anthropic/tools/collection.py@@ -1,6 +1,6 @@"""Collection classes for managing multiple tools."""-from typing import Any+from typing import Any, castfrom anthropic.types.beta import BetaToolUnionParam@@ -22,7 +22,7 @@ class ToolCollection:def to_params(self,) -> list[BetaToolUnionParam]:- return [tool.to_params() for tool in self.tools]+ return cast(list[BetaToolUnionParam], [tool.to_params() for tool in self.tools])async def run(self, *, name: str, tool_input: dict[str, Any]) -> ToolResult:tool = self.tool_map.get(name)diff --git a/libs/agent/agent/providers/anthropic/tools/computer.py b/libs/agent/agent/providers/anthropic/tools/computer.pyindex 2d00b3c682..8425f35f70 100644--- a/libs/agent/agent/providers/anthropic/tools/computer.py+++ b/libs/agent/agent/providers/anthropic/tools/computer.py@@ -61,9 +61,9 @@ class ComputerTool(BaseComputerTool, BaseAnthropicTool):name: Literal["computer"] = "computer"api_type: Literal["computer_20250124"] = "computer_20250124"- width: int | None- height: int | None- display_num: int | None+ width: int | None = None+ height: int | None = None+ display_num: int | None = Nonecomputer: Computer # The CUA Computer instancelogger = logging.getLogger(__name__)@@ -106,6 +106,7 @@ class ComputerTool(BaseComputerTool, BaseAnthropicTool):display_size = await self.computer.interface.get_screen_size()self.width = display_size["width"]self.height = display_size["height"]+ assert isinstance(self.width, int) and isinstance(self.height, int)self.logger.info(f"Initialized screen dimensions to {self.width}x{self.height}")async def __call__(@@ -120,6 +121,8 @@ class ComputerTool(BaseComputerTool, BaseAnthropicTool):# Ensure dimensions are initializedif self.width is None or self.height is None:await self.initialize_dimensions()+ if self.width is None or self.height is None:+ raise ToolError("Failed to initialize screen dimensions")except Exception as e:raise ToolError(f"Failed to initialize dimensions: {e}")@@ -147,7 +150,10 @@ class ComputerTool(BaseComputerTool, BaseAnthropicTool):self.logger.info(f"Scaling image from {pre_img.size} to {self.width}x{self.height} to match screen dimensions")- pre_img = pre_img.resize((self.width, self.height), Image.Resampling.LANCZOS)+ if not isinstance(self.width, int) or not isinstance(self.height, int):+ raise ToolError("Screen dimensions must be integers")+ size = (int(self.width), int(self.height))+ pre_img = pre_img.resize(size, Image.Resampling.LANCZOS)self.logger.info(f" Current dimensions: {pre_img.width}x{pre_img.height}")@@ -160,15 +166,7 @@ class ComputerTool(BaseComputerTool, BaseAnthropicTool):await self.computer.interface.move_cursor(x, y)# Then perform drag operation - check if drag_to exists or we need to use other methodstry:- if hasattr(self.computer.interface, "drag_to"):- await self.computer.interface.drag_to(x, y)- else:- # Alternative approach: press mouse down, move, release- await self.computer.interface.mouse_down()- await asyncio.sleep(0.2)- await self.computer.interface.move_cursor(x, y)- await asyncio.sleep(0.2)- await self.computer.interface.mouse_up()+ await self.computer.interface.drag_to(x, y)except Exception as e:self.logger.error(f"Error during drag operation: {str(e)}")raise ToolError(f"Failed to perform drag: {str(e)}")@@ -214,9 +212,10 @@ class ComputerTool(BaseComputerTool, BaseAnthropicTool):self.logger.info(f"Scaling image from {pre_img.size} to {self.width}x{self.height} to match screen dimensions")- pre_img = pre_img.resize(- (self.width, self.height), Image.Resampling.LANCZOS- )+ if not isinstance(self.width, int) or not isinstance(self.height, int):+ raise ToolError("Screen dimensions must be integers")+ size = (int(self.width), int(self.height))+ pre_img = pre_img.resize(size, Image.Resampling.LANCZOS)# Save the scaled image back to bytesbuffer = io.BytesIO()pre_img.save(buffer, format="PNG")@@ -275,9 +274,10 @@ class ComputerTool(BaseComputerTool, BaseAnthropicTool):self.logger.info(f"Scaling image from {pre_img.size} to {self.width}x{self.height}")- pre_img = pre_img.resize(- (self.width, self.height), Image.Resampling.LANCZOS- )+ if not isinstance(self.width, int) or not isinstance(self.height, int):+ raise ToolError("Screen dimensions must be integers")+ size = (int(self.width), int(self.height))+ pre_img = pre_img.resize(size, Image.Resampling.LANCZOS)# Perform the click actionif action == "left_click":@@ -335,7 +335,10 @@ class ComputerTool(BaseComputerTool, BaseAnthropicTool):self.logger.info(f"Scaling image from {pre_img.size} to {self.width}x{self.height}")- pre_img = pre_img.resize((self.width, self.height), Image.Resampling.LANCZOS)+ if not isinstance(self.width, int) or not isinstance(self.height, int):+ raise ToolError("Screen dimensions must be integers")+ size = (int(self.width), int(self.height))+ pre_img = pre_img.resize(size, Image.Resampling.LANCZOS)if action == "key":# Special handling for page up/down on macOS@@ -365,7 +368,7 @@ class ComputerTool(BaseComputerTool, BaseAnthropicTool):# Handle single key pressself.logger.info(f"Pressing key: {text}")try:- await self.computer.interface.press(text)+ await self.computer.interface.press_key(text)output_text = textexcept ValueError as e:raise ToolError(f"Invalid key: {text}. {str(e)}")@@ -442,7 +445,10 @@ class ComputerTool(BaseComputerTool, BaseAnthropicTool):self.logger.info(f"Scaling image from {img.size} to {self.width}x{self.height}")- img = img.resize((self.width, self.height), Image.Resampling.LANCZOS)+ if not isinstance(self.width, int) or not isinstance(self.height, int):+ raise ToolError("Screen dimensions must be integers")+ size = (int(self.width), int(self.height))+ img = img.resize(size, Image.Resampling.LANCZOS)buffer = io.BytesIO()img.save(buffer, format="PNG")screenshot = buffer.getvalue()@@ -451,7 +457,8 @@ class ComputerTool(BaseComputerTool, BaseAnthropicTool):elif action == "cursor_position":pos = await self.computer.interface.get_cursor_position()- return ToolResult(output=f"X={int(pos[0])},Y={int(pos[1])}")+ x, y = pos # Unpack the tuple+ return ToolResult(output=f"X={int(x)},Y={int(y)}")except Exception as e:self.logger.error(f"Error during {action} action: {str(e)}")@@ -517,7 +524,10 @@ class ComputerTool(BaseComputerTool, BaseAnthropicTool):# Scale image if neededif img.size != (self.width, self.height):self.logger.info(f"Scaling image from {img.size} to {self.width}x{self.height}")- img = img.resize((self.width, self.height), Image.Resampling.LANCZOS)+ if not isinstance(self.width, int) or not isinstance(self.height, int):+ raise ToolError("Screen dimensions must be integers")+ size = (int(self.width), int(self.height))+ img = img.resize(size, Image.Resampling.LANCZOS)buffer = io.BytesIO()img.save(buffer, format="PNG")screenshot = buffer.getvalue()diff --git a/libs/agent/agent/providers/anthropic/tools/manager.py b/libs/agent/agent/providers/anthropic/tools/manager.pyindex 6e8857d12c..94444b9453 100644--- a/libs/agent/agent/providers/anthropic/tools/manager.py+++ b/libs/agent/agent/providers/anthropic/tools/manager.py@@ -1,4 +1,4 @@-from typing import Any, Dict, List+from typing import Any, Dict, List, castfrom anthropic.types.beta import BetaToolUnionParamfrom computer.computer import Computer@@ -37,7 +37,7 @@ class ToolManager(BaseToolManager):"""Get tool parameters for Anthropic API calls."""if self.tools is None:raise RuntimeError("Tools not initialized. Call initialize() first.")- return self.tools.to_params()+ return cast(List[BetaToolUnionParam], self.tools.to_params())async def execute_tool(self, name: str, tool_input: dict[str, Any]) -> ToolResult:"""Execute a tool with the given input.diff --git a/libs/agent/agent/providers/omni/experiment.py b/libs/agent/agent/providers/omni/experiment.pyindex 347eb74a5f..7e5c3a1d6d 100644--- a/libs/agent/agent/providers/omni/experiment.py+++ b/libs/agent/agent/providers/omni/experiment.py@@ -126,15 +126,18 @@ class ExperimentManager:# Since we no longer want to use the images/ folder, we'll skip this functionalityreturn- def save_screenshot(self, img_base64: str, action_type: str = "") -> None:+ def save_screenshot(self, img_base64: str, action_type: str = "") -> Optional[str]:"""Save a screenshot to the experiment directory.Args:img_base64: Base64 encoded screenshotaction_type: Type of action that triggered the screenshot++ Returns:+ Optional[str]: Path to the saved screenshot, or None if saving failed"""if not self.current_turn_dir:- return+ return Nonetry:# Increment screenshot counterdiff --git a/libs/agent/agent/providers/omni/loop.py b/libs/agent/agent/providers/omni/loop.pyindex 3901b5306a..cb54714849 100644--- a/libs/agent/agent/providers/omni/loop.py+++ b/libs/agent/agent/providers/omni/loop.py@@ -13,6 +13,7 @@ import asynciofrom httpx import ConnectError, ReadTimeoutimport shutilimport copy+from typing import castfrom .parser import OmniParser, ParseResult, ParserMetadata, UIElementfrom ...core.loop import BaseLoop@@ -182,8 +183,6 @@ class OmniLoop(BaseLoop):if self.provider == LLMProvider.OPENAI:self.client = OpenAIClient(api_key=self.api_key, model=self.model)- elif self.provider == LLMProvider.GROQ:- self.client = GroqClient(api_key=self.api_key, model=self.model)elif self.provider == LLMProvider.ANTHROPIC:self.client = AnthropicClient(api_key=self.api_key,@@ -329,10 +328,15 @@ class OmniLoop(BaseLoop):raise RuntimeError(error_message)async def _handle_response(- self, response: Any, messages: List[Dict[str, Any]], parsed_screen: Dict[str, Any]+ self, response: Any, messages: List[Dict[str, Any]], parsed_screen: ParseResult) -> Tuple[bool, bool]:"""Handle API response.+ Args:+ response: API response+ messages: List of messages to update+ parsed_screen: Current parsed screen information+Returns:Tuple of (should_continue, action_screenshot_saved)"""@@ -394,7 +398,9 @@ class OmniLoop(BaseLoop):try:# Execute action with current parsed screen info- await self._execute_action(parsed_content, parsed_screen)+ await self._execute_action(+ parsed_content, cast(ParseResult, parsed_screen)+ )action_screenshot_saved = Trueexcept Exception as e:logger.error(f"Error executing action: {str(e)}")@@ -463,7 +469,7 @@ class OmniLoop(BaseLoop):try:# Execute action with current parsed screen info- await self._execute_action(parsed_content, parsed_screen)+ await self._execute_action(parsed_content, cast(ParseResult, parsed_screen))action_screenshot_saved = Trueexcept Exception as e:logger.error(f"Error executing action: {str(e)}")@@ -488,7 +494,7 @@ class OmniLoop(BaseLoop):try:# Execute action with current parsed screen info- await self._execute_action(content, parsed_screen)+ await self._execute_action(content, cast(ParseResult, parsed_screen))action_screenshot_saved = Trueexcept Exception as e:logger.error(f"Error executing action: {str(e)}")diff --git a/libs/agent/agent/providers/omni/parser.py b/libs/agent/agent/providers/omni/parser.pyindex 1ecc381b0c..0206a7a4e9 100644--- a/libs/agent/agent/providers/omni/parser.py+++ b/libs/agent/agent/providers/omni/parser.py@@ -122,8 +122,9 @@ class OmniParser:# Create a minimal valid result for error casesreturn ParseResult(elements=[],+ screen_info=None,annotated_image_base64="",- parsed_content_list=[f"Error: {str(e)}"],+ parsed_content_list=[{"error": str(e)}],metadata=ParserMetadata(image_size=(0, 0),num_icons=0,diff --git a/libs/agent/agent/providers/omni/tools/__init__.py b/libs/agent/agent/providers/omni/tools/__init__.pyindex 31b65f8dcc..7091d1503d 100644--- a/libs/agent/agent/providers/omni/tools/__init__.py+++ b/libs/agent/agent/providers/omni/tools/__init__.py@@ -2,7 +2,6 @@from .bash import OmniBashToolfrom .computer import OmniComputerTool-from .edit import OmniEditToolfrom .manager import OmniToolManager__all__ = [diff --git a/libs/agent/agent/providers/omni/tools/computer.py b/libs/agent/agent/providers/omni/tools/computer.pyindex ccd933bab4..40c7593376 100644--- a/libs/agent/agent/providers/omni/tools/computer.py+++ b/libs/agent/agent/providers/omni/tools/computer.py@@ -177,7 +177,7 @@ class OmniComputerTool(BaseComputerTool):keys = text.split("+")await self.computer.interface.hotkey(*keys)else:- await self.computer.interface.press(text)+ await self.computer.interface.press_key(text)# Take screenshot after actionscreenshot = await self.computer.interface.screenshot()@@ -188,7 +188,8 @@ class OmniComputerTool(BaseComputerTool):)elif action == "cursor_position":pos = await self.computer.interface.get_cursor_position()- return ToolResult(output=f"X={int(pos[0])},Y={int(pos[1])}")+ x, y = pos+ return ToolResult(output=f"X={int(x)},Y={int(y)}")elif action == "scroll":if direction == "down":self.logger.info(f"Scrolling down, amount: {amount}")diff --git a/libs/agent/agent/providers/omni/tools/manager.py b/libs/agent/agent/providers/omni/tools/manager.pyindex 2e1152fb9d..2449f6650b 100644--- a/libs/agent/agent/providers/omni/tools/manager.py+++ b/libs/agent/agent/providers/omni/tools/manager.py@@ -10,7 +10,6 @@ from ....core.tools.collection import ToolCollectionfrom .bash import OmniBashToolfrom .computer import OmniComputerTool-from .edit import OmniEditToolclass ProviderType(Enum):@@ -35,11 +34,10 @@ class OmniToolManager(BaseToolManager):# Initialize toolsself.computer_tool = OmniComputerTool(self.computer)self.bash_tool = OmniBashTool(self.computer)- self.edit_tool = OmniEditTool(self.computer)def _initialize_tools(self) -> ToolCollection:"""Initialize all available tools."""- return ToolCollection(self.computer_tool, self.bash_tool, self.edit_tool)+ return ToolCollection(self.computer_tool, self.bash_tool)async def _initialize_tools_specific(self) -> None:"""Initialize provider-specific tool requirements."""diff --git a/libs/agent/agent/providers/omni/utils.py b/libs/agent/agent/providers/omni/utils.pyindex 7513caf6bc..d3da4f6c04 100644--- a/libs/agent/agent/providers/omni/utils.py+++ b/libs/agent/agent/providers/omni/utils.py@@ -96,7 +96,7 @@ def compress_image_base64(# Resize imagenew_width = int(img.width * scale_factor)new_height = int(img.height * scale_factor)- current_img = img.resize((new_width, new_height), Image.LANCZOS)+ current_img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)# Try with reduced size and qualitybuffer = io.BytesIO()@@ -130,7 +130,9 @@ def compress_image_base64(# Last resort: Use minimum quality and sizebuffer = io.BytesIO()- smallest_img = img.resize((int(img.width * 0.5), int(img.height * 0.5)), Image.LANCZOS)+ smallest_img = img.resize(+ (int(img.width * 0.5), int(img.height * 0.5)), Image.Resampling.LANCZOS+ )# Convert to RGB if necessaryif smallest_img.mode in ("RGBA", "LA") or (smallest_img.mode == "P" and "transparency" in smallest_img.infodiff --git a/libs/agent/agent/types/__init__.py b/libs/agent/agent/types/__init__.pyindex f42a6efc72..aac3f334d2 100644--- a/libs/agent/agent/types/__init__.py+++ b/libs/agent/agent/types/__init__.py@@ -1,23 +1,20 @@"""Type definitions for the agent package."""-from .base import Provider, HostConfig, TaskResult, Annotation+from .base import HostConfig, TaskResult, Annotationfrom .messages import Message, Request, Response, StepMessage, DisengageMessagefrom .tools import ToolInvocation, ToolInvocationState, ClientAttachment, ToolResult__all__ = [# Base types- "Provider","HostConfig","TaskResult","Annotation",-# Message types"Message","Request","Response","StepMessage","DisengageMessage",-# Tool types"ToolInvocation","ToolInvocationState",diff --git a/libs/agent/agent/types/base.py b/libs/agent/agent/types/base.pyindex 23cc9a7bcd..dc01800a5f 100644--- a/libs/agent/agent/types/base.py+++ b/libs/agent/agent/types/base.py@@ -5,17 +5,6 @@ from typing import Dict, Anyfrom pydantic import BaseModel, ConfigDict-class Provider(str, Enum):- """Available AI providers."""-- UNKNOWN = "unknown" # Default provider for base class- ANTHROPIC = "anthropic"- OPENAI = "openai"- OLLAMA = "ollama"- OMNI = "omni"- GROQ = "groq"--class HostConfig(BaseModel):"""Host configuration."""@@ -48,6 +37,5 @@ class AgentLoop(Enum):"""Enumeration of available loop types."""ANTHROPIC = auto() # Anthropic implementation- OPENAI = auto() # OpenAI implementationOMNI = auto() # OmniLoop implementation# Add more loop types as neededdiff --git a/libs/computer/computer/computer.py b/libs/computer/computer/computer.pyindex 8d86b67290..5aa851e6f1 100644--- a/libs/computer/computer/computer.py+++ b/libs/computer/computer/computer.py@@ -1,6 +1,14 @@from typing import Optional, List, Literal, Dict, Any, Union, TYPE_CHECKING, castfrom pylume import PyLume-from pylume.models import VMRunOpts, VMUpdateOpts, ImageRef, SharedDirectory+from pylume.models import (+ VMRunOpts,+ VMUpdateOpts,+ ImageRef,+ SharedDirectory,+ VMStatus,+ VMConfig,+ CloneSpec,+)import asynciofrom .models import Computer as ComputerConfig, Displayfrom .interface.factory import InterfaceFactory@@ -13,6 +21,7 @@ from .logger import Logger, LogLevelimport jsonimport loggingfrom .telemetry import record_computer_initialization+import osOSType = Literal["macos", "linux"]@@ -36,6 +45,8 @@ class Computer:use_host_computer_server: bool = False,verbosity: Union[int, LogLevel] = logging.INFO,telemetry_enabled: bool = True,+ port: Optional[int] = 3000,+ host: str = os.environ.get("PYLUME_HOST", "localhost"),):"""Initialize a new Computer instance.@@ -55,6 +66,8 @@ class Computer:verbosity: Logging level (standard Python logging levels: logging.DEBUG, logging.INFO, etc.)LogLevel enum values are still accepted for backward compatibilitytelemetry_enabled: Whether to enable telemetry tracking. Defaults to True.+ port: Optional port to use for the PyLume server+ host: Host to use for PyLume connections (e.g. "localhost", "host.docker.internal")"""if TYPE_CHECKING:from .interface.base import BaseComputerInterface@@ -64,6 +77,8 @@ class Computer:# Store original parametersself.image = image+ self.port = port+ self.host = host# Store telemetry preferenceself._telemetry_enabled = telemetry_enabled@@ -185,6 +200,26 @@ class Computer:if not self._pylume_context:try:self.logger.verbose("Initializing PyLume context...")++ # Configure PyLume based on initialization parameters+ pylume_kwargs = {+ "debug": self.verbosity <= LogLevel.DEBUG,+ "server_start_timeout": 120, # Increase timeout to 2 minutes+ }++ # Add port if specified+ if hasattr(self, "port") and self.port is not None:+ pylume_kwargs["port"] = self.port+ self.logger.verbose(f"Using specified port for PyLume: {self.port}")++ # Add host if specified+ if hasattr(self, "host") and self.host != "localhost":+ pylume_kwargs["host"] = self.host+ self.logger.verbose(f"Using specified host for PyLume: {self.host}")++ # Create PyLume instance with configured parameters+ self.config.pylume = PyLume(**pylume_kwargs)+self._pylume_context = await self.config.pylume.__aenter__() # type: ignore[attr-defined]self.logger.verbose("PyLume context initialized successfully")except Exception as e:diff --git a/libs/computer/computer/telemetry.py b/libs/computer/computer/telemetry.pyindex e5996c0c3c..38be92a9c1 100644--- a/libs/computer/computer/telemetry.py+++ b/libs/computer/computer/telemetry.py@@ -8,7 +8,12 @@ from typing import AnyTELEMETRY_AVAILABLE = Falsetry:- from core.telemetry import record_event, increment, is_telemetry_enabled+ from core.telemetry import (+ record_event,+ increment,+ is_telemetry_enabled,+ is_telemetry_globally_disabled,+ )def increment_counter(counter_name: str, value: int = 1) -> None:"""Wrapper for increment to maintain backward compatibility."""@@ -75,14 +80,8 @@ def enable_telemetry() -> bool:# Try to import and enabletry:- from core.telemetry import (- is_telemetry_globally_disabled,- )-- # Check again after import- if is_telemetry_globally_disabled():- logger.info("Telemetry is globally disabled via environment variable - cannot enable")- return False+ # Verify we can import core telemetry+ from core.telemetry import record_event # type: ignoreTELEMETRY_AVAILABLE = Truelogger.info("Telemetry successfully enabled")diff --git a/libs/computer/tests/test_computer.py b/libs/computer/tests/test_computer.pydeleted file mode 100644index 642ccb4ed3..0000000000--- a/libs/computer/tests/test_computer.py+++ /dev/null@@ -1,18 +0,0 @@-"""Basic tests for the computer package."""--import pytest-from computer import Computer--def test_computer_import():- """Test that we can import the Computer class."""- assert Computer is not None--def test_computer_init():- """Test that we can create a Computer instance."""- computer = Computer(- display={"width": 1920, "height": 1080},- memory="16GB",- cpu="4",- use_host_computer_server=True- )- assert computer is not None\ No newline at end of filediff --git a/libs/core/core/telemetry/sender.py b/libs/core/core/telemetry/sender.pynew file mode 100644index 0000000000..db96b1ac4e--- /dev/null+++ b/libs/core/core/telemetry/sender.py@@ -0,0 +1,24 @@+"""Telemetry sender module for sending anonymous usage data."""++import logging+from typing import Any, Dict++logger = logging.getLogger("cua.telemetry")+++def send_telemetry(payload: Dict[str, Any]) -> bool:+ """Send telemetry data to collection endpoint.++ Args:+ payload: Telemetry data to send++ Returns:+ bool: True if sending was successful, False otherwise+ """+ try:+ # For now, just log the payload and return success+ logger.debug(f"Would send telemetry: {payload}")+ return True+ except Exception as e:+ logger.debug(f"Error sending telemetry: {e}")+ return Falsediff --git a/libs/core/pdm.lock b/libs/core/pdm.lockdeleted file mode 100644index 619351458b..0000000000--- a/libs/core/pdm.lock+++ /dev/null@@ -1,411 +0,0 @@-# This file is @generated by PDM.-# It is not intended for manual editing.--[metadata]-groups = ["default", "dev"]-strategy = []-lock_version = "4.5.0"-content_hash = "sha256:012f523673653e261a7b65007c36c67b540b2477da9bf3a71a849ae36aeeb7b1"--[[metadata.targets]]-requires_python = ">=3.10,<3.13"--[[package]]-name = "annotated-types"-version = "0.7.0"-summary = ""-files = [- {file = "annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53"},- {file = "annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89"},-]--[[package]]-name = "anyio"-version = "4.8.0"-summary = ""-dependencies = [- "exceptiongroup; python_full_version < \"3.11\"",- "idna",- "sniffio",- "typing-extensions",-]-files = [- {file = "anyio-4.8.0-py3-none-any.whl", hash = "sha256:b5011f270ab5eb0abf13385f851315585cc37ef330dd88e27ec3d34d651fd47a"},- {file = "anyio-4.8.0.tar.gz", hash = "sha256:1d9fe889df5212298c0c0723fa20479d1b94883a2df44bd3897aa91083316f7a"},-]--[[package]]-name = "backoff"-version = "2.2.1"-summary = ""-files = [- {file = "backoff-2.2.1-py3-none-any.whl", hash = "sha256:63579f9a0628e06278f7e47b7d7d5b6ce20dc65c5e96a6f3ca99a6adca0396e8"},- {file = "backoff-2.2.1.tar.gz", hash = "sha256:03f829f5bb1923180821643f8753b0502c3b682293992485b0eef2807afa5cba"},-]--[[package]]-name = "certifi"-version = "2025.1.31"-summary = ""-files = [- {file = "certifi-2025.1.31-py3-none-any.whl", hash = "sha256:ca78db4565a652026a4db2bcdf68f2fb589ea80d0be70e03929ed730746b84fe"},- {file = "certifi-2025.1.31.tar.gz", hash = "sha256:3d5da6925056f6f18f119200434a4780a94263f10d1c21d032a6f6b2baa20651"},-]--[[package]]-name = "charset-normalizer"-version = "3.4.1"-summary = ""-files = [- {file = "charset_normalizer-3.4.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:91b36a978b5ae0ee86c394f5a54d6ef44db1de0815eb43de826d41d21e4af3de"},- {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7461baadb4dc00fd9e0acbe254e3d7d2112e7f92ced2adc96e54ef6501c5f176"},- {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e218488cd232553829be0664c2292d3af2eeeb94b32bea483cf79ac6a694e037"},- {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:80ed5e856eb7f30115aaf94e4a08114ccc8813e6ed1b5efa74f9f82e8509858f"},- {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b010a7a4fd316c3c484d482922d13044979e78d1861f0e0650423144c616a46a"},- {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4532bff1b8421fd0a320463030c7520f56a79c9024a4e88f01c537316019005a"},- {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d973f03c0cb71c5ed99037b870f2be986c3c05e63622c017ea9816881d2dd247"},- {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3a3bd0dcd373514dcec91c411ddb9632c0d7d92aed7093b8c3bbb6d69ca74408"},- {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:d9c3cdf5390dcd29aa8056d13e8e99526cda0305acc038b96b30352aff5ff2bb"},- {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:2bdfe3ac2e1bbe5b59a1a63721eb3b95fc9b6817ae4a46debbb4e11f6232428d"},- {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:eab677309cdb30d047996b36d34caeda1dc91149e4fdca0b1a039b3f79d9a807"},- {file = "charset_normalizer-3.4.1-cp310-cp310-win32.whl", hash = "sha256:c0429126cf75e16c4f0ad00ee0eae4242dc652290f940152ca8c75c3a4b6ee8f"},- {file = "charset_normalizer-3.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:9f0b8b1c6d84c8034a44893aba5e767bf9c7a211e313a9605d9c617d7083829f"},- {file = "charset_normalizer-3.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8bfa33f4f2672964266e940dd22a195989ba31669bd84629f05fab3ef4e2d125"},- {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:28bf57629c75e810b6ae989f03c0828d64d6b26a5e205535585f96093e405ed1"},- {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f08ff5e948271dc7e18a35641d2f11a4cd8dfd5634f55228b691e62b37125eb3"},- {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:234ac59ea147c59ee4da87a0c0f098e9c8d169f4dc2a159ef720f1a61bbe27cd"},- {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd4ec41f914fa74ad1b8304bbc634b3de73d2a0889bd32076342a573e0779e00"},- {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eea6ee1db730b3483adf394ea72f808b6e18cf3cb6454b4d86e04fa8c4327a12"},- {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c96836c97b1238e9c9e3fe90844c947d5afbf4f4c92762679acfe19927d81d77"},- {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4d86f7aff21ee58f26dcf5ae81a9addbd914115cdebcbb2217e4f0ed8982e146"},- {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:09b5e6733cbd160dcc09589227187e242a30a49ca5cefa5a7edd3f9d19ed53fd"},- {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:5777ee0881f9499ed0f71cc82cf873d9a0ca8af166dfa0af8ec4e675b7df48e6"},- {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:237bdbe6159cff53b4f24f397d43c6336c6b0b42affbe857970cefbb620911c8"},- {file = "charset_normalizer-3.4.1-cp311-cp311-win32.whl", hash = "sha256:8417cb1f36cc0bc7eaba8ccb0e04d55f0ee52df06df3ad55259b9a323555fc8b"},- {file = "charset_normalizer-3.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7f50a1f8c450f3925cb367d011448c39239bb3eb4117c36a6d354794de4ce76"},- {file = "charset_normalizer-3.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:73d94b58ec7fecbc7366247d3b0b10a21681004153238750bb67bd9012414545"},- {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dad3e487649f498dd991eeb901125411559b22e8d7ab25d3aeb1af367df5efd7"},- {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c30197aa96e8eed02200a83fba2657b4c3acd0f0aa4bdc9f6c1af8e8962e0757"},- {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2369eea1ee4a7610a860d88f268eb39b95cb588acd7235e02fd5a5601773d4fa"},- {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc2722592d8998c870fa4e290c2eec2c1569b87fe58618e67d38b4665dfa680d"},- {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffc9202a29ab3920fa812879e95a9e78b2465fd10be7fcbd042899695d75e616"},- {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:804a4d582ba6e5b747c625bf1255e6b1507465494a40a2130978bda7b932c90b"},- {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0f55e69f030f7163dffe9fd0752b32f070566451afe180f99dbeeb81f511ad8d"},- {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c4c3e6da02df6fa1410a7680bd3f63d4f710232d3139089536310d027950696a"},- {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:5df196eb874dae23dcfb968c83d4f8fdccb333330fe1fc278ac5ceeb101003a9"},- {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e358e64305fe12299a08e08978f51fc21fac060dcfcddd95453eabe5b93ed0e1"},- {file = "charset_normalizer-3.4.1-cp312-cp312-win32.whl", hash = "sha256:9b23ca7ef998bc739bf6ffc077c2116917eabcc901f88da1b9856b210ef63f35"},- {file = "charset_normalizer-3.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:6ff8a4a60c227ad87030d76e99cd1698345d4491638dfa6673027c48b3cd395f"},- {file = "charset_normalizer-3.4.1-py3-none-any.whl", hash = "sha256:d98b1668f06378c6dbefec3b92299716b931cd4e6061f3c875a71ced1780ab85"},- {file = "charset_normalizer-3.4.1.tar.gz", hash = "sha256:44251f18cd68a75b56585dd00dae26183e102cd5e0f9f1466e6df5da2ed64ea3"},-]--[[package]]-name = "colorama"-version = "0.4.6"-summary = ""-files = [- {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"},- {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"},-]--[[package]]-name = "distro"-version = "1.9.0"-summary = ""-files = [- {file = "distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2"},- {file = "distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed"},-]--[[package]]-name = "exceptiongroup"-version = "1.2.2"-summary = ""-files = [- {file = "exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b"},- {file = "exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc"},-]--[[package]]-name = "h11"-version = "0.14.0"-summary = ""-files = [- {file = "h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761"},- {file = "h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d"},-]--[[package]]-name = "httpcore"-version = "1.0.7"-summary = ""-dependencies = [- "certifi",- "h11",-]-files = [- {file = "httpcore-1.0.7-py3-none-any.whl", hash = "sha256:a3fff8f43dc260d5bd363d9f9cf1830fa3a458b332856f34282de498ed420edd"},- {file = "httpcore-1.0.7.tar.gz", hash = "sha256:8551cb62a169ec7162ac7be8d4817d561f60e08eaa485234898414bb5a8a0b4c"},-]--[[package]]-name = "httpx"-version = "0.28.1"-summary = ""-dependencies = [- "anyio",- "certifi",- "httpcore",- "idna",-]-files = [- {file = "httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad"},- {file = "httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc"},-]--[[package]]-name = "idna"-version = "3.10"-summary = ""-files = [- {file = "idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3"},- {file = "idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9"},-]--[[package]]-name = "iniconfig"-version = "2.0.0"-summary = ""-files = [- {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"},- {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"},-]--[[package]]-name = "monotonic"-version = "1.6"-summary = ""-files = [- {file = "monotonic-1.6-py2.py3-none-any.whl", hash = "sha256:68687e19a14f11f26d140dd5c86f3dba4bf5df58003000ed467e0e2a69bca96c"},- {file = "monotonic-1.6.tar.gz", hash = "sha256:3a55207bcfed53ddd5c5bae174524062935efed17792e9de2ad0205ce9ad63f7"},-]--[[package]]-name = "packaging"-version = "24.2"-summary = ""-files = [- {file = "packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759"},- {file = "packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f"},-]--[[package]]-name = "pluggy"-version = "1.5.0"-summary = ""-files = [- {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"},- {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"},-]--[[package]]-name = "posthog"-version = "3.20.0"-summary = ""-dependencies = [- "backoff",- "distro",- "monotonic",- "python-dateutil",- "requests",- "six",-]-files = [- {file = "posthog-3.20.0-py2.py3-none-any.whl", hash = "sha256:ce3aa75a39c36bc3af2b6947757493e6c7d021fe5088b185d3277157770d4ef4"},- {file = "posthog-3.20.0.tar.gz", hash = "sha256:7933f7c98c0152a34e387e441fefdc62e2b86aade5dea94dc6ecbe7358138828"},-]--[[package]]-name = "pydantic"-version = "2.10.6"-summary = ""-dependencies = [- "annotated-types",- "pydantic-core",- "typing-extensions",-]-files = [- {file = "pydantic-2.10.6-py3-none-any.whl", hash = "sha256:427d664bf0b8a2b34ff5dd0f5a18df00591adcee7198fbd71981054cef37b584"},- {file = "pydantic-2.10.6.tar.gz", hash = "sha256:ca5daa827cce33de7a42be142548b0096bf05a7e7b365aebfa5f8eeec7128236"},-]--[[package]]-name = "pydantic-core"-version = "2.27.2"-summary = ""-dependencies = [- "typing-extensions",-]-files = [- {file = "pydantic_core-2.27.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2d367ca20b2f14095a8f4fa1210f5a7b78b8a20009ecced6b12818f455b1e9fa"},- {file = "pydantic_core-2.27.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:491a2b73db93fab69731eaee494f320faa4e093dbed776be1a829c2eb222c34c"},- {file = "pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7969e133a6f183be60e9f6f56bfae753585680f3b7307a8e555a948d443cc05a"},- {file = "pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3de9961f2a346257caf0aa508a4da705467f53778e9ef6fe744c038119737ef5"},- {file = "pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e2bb4d3e5873c37bb3dd58714d4cd0b0e6238cebc4177ac8fe878f8b3aa8e74c"},- {file = "pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:280d219beebb0752699480fe8f1dc61ab6615c2046d76b7ab7ee38858de0a4e7"},- {file = "pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47956ae78b6422cbd46f772f1746799cbb862de838fd8d1fbd34a82e05b0983a"},- {file = "pydantic_core-2.27.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:14d4a5c49d2f009d62a2a7140d3064f686d17a5d1a268bc641954ba181880236"},- {file = "pydantic_core-2.27.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:337b443af21d488716f8d0b6164de833e788aa6bd7e3a39c005febc1284f4962"},- {file = "pydantic_core-2.27.2-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:03d0f86ea3184a12f41a2d23f7ccb79cdb5a18e06993f8a45baa8dfec746f0e9"},- {file = "pydantic_core-2.27.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:7041c36f5680c6e0f08d922aed302e98b3745d97fe1589db0a3eebf6624523af"},- {file = "pydantic_core-2.27.2-cp310-cp310-win32.whl", hash = "sha256:50a68f3e3819077be2c98110c1f9dcb3817e93f267ba80a2c05bb4f8799e2ff4"},- {file = "pydantic_core-2.27.2-cp310-cp310-win_amd64.whl", hash = "sha256:e0fd26b16394ead34a424eecf8a31a1f5137094cabe84a1bcb10fa6ba39d3d31"},- {file = "pydantic_core-2.27.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:8e10c99ef58cfdf2a66fc15d66b16c4a04f62bca39db589ae8cba08bc55331bc"},- {file = "pydantic_core-2.27.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:26f32e0adf166a84d0cb63be85c562ca8a6fa8de28e5f0d92250c6b7e9e2aff7"},- {file = "pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c19d1ea0673cd13cc2f872f6c9ab42acc4e4f492a7ca9d3795ce2b112dd7e15"},- {file = "pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5e68c4446fe0810e959cdff46ab0a41ce2f2c86d227d96dc3847af0ba7def306"},- {file = "pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d9640b0059ff4f14d1f37321b94061c6db164fbe49b334b31643e0528d100d99"},- {file = "pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:40d02e7d45c9f8af700f3452f329ead92da4c5f4317ca9b896de7ce7199ea459"},- {file = "pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1c1fd185014191700554795c99b347d64f2bb637966c4cfc16998a0ca700d048"},- {file = "pydantic_core-2.27.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d81d2068e1c1228a565af076598f9e7451712700b673de8f502f0334f281387d"},- {file = "pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:1a4207639fb02ec2dbb76227d7c751a20b1a6b4bc52850568e52260cae64ca3b"},- {file = "pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:3de3ce3c9ddc8bbd88f6e0e304dea0e66d843ec9de1b0042b0911c1663ffd474"},- {file = "pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:30c5f68ded0c36466acede341551106821043e9afaad516adfb6e8fa80a4e6a6"},- {file = "pydantic_core-2.27.2-cp311-cp311-win32.whl", hash = "sha256:c70c26d2c99f78b125a3459f8afe1aed4d9687c24fd677c6a4436bc042e50d6c"},- {file = "pydantic_core-2.27.2-cp311-cp311-win_amd64.whl", hash = "sha256:08e125dbdc505fa69ca7d9c499639ab6407cfa909214d500897d02afb816e7cc"},- {file = "pydantic_core-2.27.2-cp311-cp311-win_arm64.whl", hash = "sha256:26f0d68d4b235a2bae0c3fc585c585b4ecc51382db0e3ba402a22cbc440915e4"},- {file = "pydantic_core-2.27.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:9e0c8cfefa0ef83b4da9588448b6d8d2a2bf1a53c3f1ae5fca39eb3061e2f0b0"},- {file = "pydantic_core-2.27.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:83097677b8e3bd7eaa6775720ec8e0405f1575015a463285a92bfdfe254529ef"},- {file = "pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:172fce187655fece0c90d90a678424b013f8fbb0ca8b036ac266749c09438cb7"},- {file = "pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:519f29f5213271eeeeb3093f662ba2fd512b91c5f188f3bb7b27bc5973816934"},- {file = "pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:05e3a55d124407fffba0dd6b0c0cd056d10e983ceb4e5dbd10dda135c31071d6"},- {file = "pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9c3ed807c7b91de05e63930188f19e921d1fe90de6b4f5cd43ee7fcc3525cb8c"},- {file = "pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6fb4aadc0b9a0c063206846d603b92030eb6f03069151a625667f982887153e2"},- {file = "pydantic_core-2.27.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:28ccb213807e037460326424ceb8b5245acb88f32f3d2777427476e1b32c48c4"},- {file = "pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:de3cd1899e2c279b140adde9357c4495ed9d47131b4a4eaff9052f23398076b3"},- {file = "pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:220f892729375e2d736b97d0e51466252ad84c51857d4d15f5e9692f9ef12be4"},- {file = "pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a0fcd29cd6b4e74fe8ddd2c90330fd8edf2e30cb52acda47f06dd615ae72da57"},- {file = "pydantic_core-2.27.2-cp312-cp312-win32.whl", hash = "sha256:1e2cb691ed9834cd6a8be61228471d0a503731abfb42f82458ff27be7b2186fc"},- {file = "pydantic_core-2.27.2-cp312-cp312-win_amd64.whl", hash = "sha256:cc3f1a99a4f4f9dd1de4fe0312c114e740b5ddead65bb4102884b384c15d8bc9"},- {file = "pydantic_core-2.27.2-cp312-cp312-win_arm64.whl", hash = "sha256:3911ac9284cd8a1792d3cb26a2da18f3ca26c6908cc434a18f730dc0db7bfa3b"},- {file = "pydantic_core-2.27.2-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:2bf14caea37e91198329b828eae1618c068dfb8ef17bb33287a7ad4b61ac314e"},- {file = "pydantic_core-2.27.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:b0cb791f5b45307caae8810c2023a184c74605ec3bcbb67d13846c28ff731ff8"},- {file = "pydantic_core-2.27.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:688d3fd9fcb71f41c4c015c023d12a79d1c4c0732ec9eb35d96e3388a120dcf3"},- {file = "pydantic_core-2.27.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d591580c34f4d731592f0e9fe40f9cc1b430d297eecc70b962e93c5c668f15f"},- {file = "pydantic_core-2.27.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:82f986faf4e644ffc189a7f1aafc86e46ef70372bb153e7001e8afccc6e54133"},- {file = "pydantic_core-2.27.2-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:bec317a27290e2537f922639cafd54990551725fc844249e64c523301d0822fc"},- {file = "pydantic_core-2.27.2-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:0296abcb83a797db256b773f45773da397da75a08f5fcaef41f2044adec05f50"},- {file = "pydantic_core-2.27.2-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:0d75070718e369e452075a6017fbf187f788e17ed67a3abd47fa934d001863d9"},- {file = "pydantic_core-2.27.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:7e17b560be3c98a8e3aa66ce828bdebb9e9ac6ad5466fba92eb74c4c95cb1151"},- {file = "pydantic_core-2.27.2.tar.gz", hash = "sha256:eb026e5a4c1fee05726072337ff51d1efb6f59090b7da90d30ea58625b1ffb39"},-]--[[package]]-name = "pytest"-version = "8.3.5"-summary = ""-dependencies = [- "colorama; sys_platform == \"win32\"",- "exceptiongroup; python_full_version < \"3.11\"",- "iniconfig",- "packaging",- "pluggy",- "tomli; python_full_version < \"3.11\"",-]-files = [- {file = "pytest-8.3.5-py3-none-any.whl", hash = "sha256:c69214aa47deac29fad6c2a4f590b9c4a9fdb16a403176fe154b79c0b4d4d820"},- {file = "pytest-8.3.5.tar.gz", hash = "sha256:f4efe70cc14e511565ac476b57c279e12a855b11f48f212af1080ef2263d3845"},-]--[[package]]-name = "python-dateutil"-version = "2.9.0.post0"-summary = ""-dependencies = [- "six",-]-files = [- {file = "python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3"},- {file = "python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427"},-]--[[package]]-name = "requests"-version = "2.32.3"-summary = ""-dependencies = [- "certifi",- "charset-normalizer",- "idna",- "urllib3",-]-files = [- {file = "requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6"},- {file = "requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760"},-]--[[package]]-name = "six"-version = "1.17.0"-summary = ""-files = [- {file = "six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274"},- {file = "six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81"},-]--[[package]]-name = "sniffio"-version = "1.3.1"-summary = ""-files = [- {file = "sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2"},- {file = "sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc"},-]--[[package]]-name = "tomli"-version = "2.2.1"-summary = ""-files = [- {file = "tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249"},- {file = "tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6"},- {file = "tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a"},- {file = "tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee"},- {file = "tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e"},- {file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4"},- {file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106"},- {file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8"},- {file = "tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff"},- {file = "tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b"},- {file = "tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea"},- {file = "tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8"},- {file = "tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192"},- {file = "tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222"},- {file = "tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77"},- {file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6"},- {file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd"},- {file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e"},- {file = "tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98"},- {file = "tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4"},- {file = "tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc"},- {file = "tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff"},-]--[[package]]-name = "typing-extensions"-version = "4.12.2"-summary = ""-files = [- {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"},- {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"},-]--[[package]]-name = "urllib3"-version = "2.3.0"-summary = ""-files = [- {file = "urllib3-2.3.0-py3-none-any.whl", hash = "sha256:1cee9ad369867bfdbbb48b7dd50374c0967a0bb7710050facf0dd6911440e3df"},- {file = "urllib3-2.3.0.tar.gz", hash = "sha256:f8c5449b3cf0861679ce7e0503c7b44b5ec981bec0d1d3795a07f1ba96f0204d"},-]diff --git a/libs/core/tests/test_posthog_telemetry.py b/libs/core/tests/test_posthog_telemetry.pydeleted file mode 100644index d3d0f2eff4..0000000000--- a/libs/core/tests/test_posthog_telemetry.py+++ /dev/null@@ -1,154 +0,0 @@-"""Tests for the PostHog telemetry client."""--import os-from unittest.mock import MagicMock, patch--import pytest--from core.telemetry.posthog_client import (- PostHogTelemetryClient,- TelemetryConfig,- get_posthog_config,- get_posthog_telemetry_client,-)---def mock_environment():- """Set up and tear down environment variables for testing."""- original_env = os.environ.copy()- os.environ["CUA_TELEMETRY_SAMPLE_RATE"] = "100"- # Remove PostHog env vars as they're hardcoded now- # os.environ["CUA_POSTHOG_API_KEY"] = "test-api-key"- # os.environ["CUA_POSTHOG_HOST"] = "https://test.posthog.com"-- yield-- # Restore original environment- os.environ.clear()- os.environ.update(original_env)---def mock_disabled_environment():- """Set up and tear down environment variables with telemetry disabled."""- original_env = os.environ.copy()- os.environ["CUA_TELEMETRY"] = "off"- os.environ["CUA_TELEMETRY_SAMPLE_RATE"] = "100"- # Remove PostHog env vars as they're hardcoded now- # os.environ["CUA_POSTHOG_API_KEY"] = "test-api-key"- # os.environ["CUA_POSTHOG_HOST"] = "https://test.posthog.com"-- yield-- # Restore original environment- os.environ.clear()- os.environ.update(original_env)---class TestTelemetryConfig:- """Tests for telemetry configuration."""-- def test_from_env_defaults(self):- """Test loading config from environment with defaults."""- # Clear relevant environment variables- with patch.dict(- os.environ,- {- k: v- for k, v in os.environ.items()- if k not in ["CUA_TELEMETRY", "CUA_TELEMETRY_SAMPLE_RATE"]- },- ):- config = TelemetryConfig.from_env()- assert config.enabled is True # Default is now enabled- assert config.sample_rate == 5- assert config.project_root is None-- def test_from_env_with_vars(self, mock_environment):- """Test loading config from environment variables."""- config = TelemetryConfig.from_env()- assert config.enabled is True- assert config.sample_rate == 100- assert config.project_root is None-- def test_from_env_disabled(self, mock_disabled_environment):- """Test disabling telemetry via environment variable."""- config = TelemetryConfig.from_env()- assert config.enabled is False- assert config.sample_rate == 100- assert config.project_root is None-- def test_to_dict(self):- """Test converting config to dictionary."""- config = TelemetryConfig(enabled=True, sample_rate=50)- config_dict = config.to_dict()- assert config_dict == {"enabled": True, "sample_rate": 50}---class TestPostHogConfig:- """Tests for PostHog configuration."""-- def test_get_posthog_config(self):- """Test getting PostHog config."""- config = get_posthog_config()- assert config is not None- assert config["api_key"] == "phc_eSkLnbLxsnYFaXksif1ksbrNzYlJShr35miFLDppF14"- assert config["host"] == "https://eu.i.posthog.com"---class TestPostHogTelemetryClient:- """Tests for PostHog telemetry client."""-- @patch("posthog.capture")- @patch("posthog.identify")- def test_initialization(self, mock_identify, mock_capture, mock_environment):- """Test client initialization."""- client = PostHogTelemetryClient()- assert client.config.enabled is True- assert client.initialized is True- mock_identify.assert_called_once()-- @patch("posthog.capture")- def test_increment_counter(self, mock_capture, mock_environment):- """Test incrementing a counter."""- client = PostHogTelemetryClient()- client.increment("test_counter", 5)- mock_capture.assert_called_once()- args, kwargs = mock_capture.call_args- assert kwargs["event"] == "counter_increment"- assert kwargs["properties"]["counter_name"] == "test_counter"- assert kwargs["properties"]["value"] == 5-- @patch("posthog.capture")- def test_record_event(self, mock_capture, mock_environment):- """Test recording an event."""- client = PostHogTelemetryClient()- client.record_event("test_event", {"param": "value"})- mock_capture.assert_called_once()- args, kwargs = mock_capture.call_args- assert kwargs["event"] == "test_event"- assert kwargs["properties"]["param"] == "value"-- @patch("posthog.capture")- def test_disabled_client(self, mock_capture, mock_environment):- """Test that disabled client doesn't send events."""- client = PostHogTelemetryClient()- client.disable()- client.increment("test_counter")- client.record_event("test_event")- mock_capture.assert_not_called()-- @patch("posthog.flush")- def test_flush(self, mock_flush, mock_environment):- """Test flushing events."""- client = PostHogTelemetryClient()- result = client.flush()- assert result is True- mock_flush.assert_called_once()-- def test_global_client(self, mock_environment):- """Test global client initialization."""- client1 = get_posthog_telemetry_client()- client2 = get_posthog_telemetry_client()- assert client1 is client2 # Same instancediff --git a/libs/core/tests/test_telemetry.py b/libs/core/tests/test_telemetry.pydeleted file mode 100644index 5b9c256d48..0000000000--- a/libs/core/tests/test_telemetry.py+++ /dev/null@@ -1,169 +0,0 @@-"""Tests for the telemetry module."""--import os-from pathlib import Path-from unittest.mock import MagicMock, patch--import pytest--from core.telemetry import (- UniversalTelemetryClient,- disable_telemetry,- enable_telemetry,- get_telemetry_client,-)---def mock_project_root(tmp_path):- """Create a temporary directory for testing."""- return tmp_path---def mock_environment():- """Set up and tear down environment variables for testing."""- original_env = os.environ.copy()- os.environ["CUA_TELEMETRY_SAMPLE_RATE"] = "100"-- yield-- # Restore original environment- os.environ.clear()- os.environ.update(original_env)---def mock_disabled_environment():- """Set up environment variables with telemetry disabled."""- original_env = os.environ.copy()- os.environ["CUA_TELEMETRY"] = "off"- os.environ["CUA_TELEMETRY_SAMPLE_RATE"] = "100"-- yield-- # Restore original environment- os.environ.clear()- os.environ.update(original_env)---class TestTelemetryClient:- """Tests for the universal telemetry client."""-- @patch("core.telemetry.telemetry.POSTHOG_AVAILABLE", True)- @patch("core.telemetry.telemetry.get_posthog_telemetry_client")- def test_initialization(self, mock_get_posthog, mock_project_root, mock_environment):- """Test client initialization."""- mock_client = MagicMock()- mock_get_posthog.return_value = mock_client-- client = UniversalTelemetryClient(mock_project_root)- assert client._client is not None- mock_get_posthog.assert_called_once_with(mock_project_root)-- @patch("core.telemetry.telemetry.POSTHOG_AVAILABLE", True)- @patch("core.telemetry.telemetry.get_posthog_telemetry_client")- def test_increment(self, mock_get_posthog, mock_project_root, mock_environment):- """Test incrementing counters."""- mock_client = MagicMock()- mock_get_posthog.return_value = mock_client-- client = UniversalTelemetryClient(mock_project_root)- client.increment("test_counter", 5)-- mock_client.increment.assert_called_once_with("test_counter", 5)-- @patch("core.telemetry.telemetry.POSTHOG_AVAILABLE", True)- @patch("core.telemetry.telemetry.get_posthog_telemetry_client")- def test_record_event(self, mock_get_posthog, mock_project_root, mock_environment):- """Test recording events."""- mock_client = MagicMock()- mock_get_posthog.return_value = mock_client-- client = UniversalTelemetryClient(mock_project_root)- client.record_event("test_event", {"prop1": "value1"})-- mock_client.record_event.assert_called_once_with("test_event", {"prop1": "value1"})-- @patch("core.telemetry.telemetry.POSTHOG_AVAILABLE", True)- @patch("core.telemetry.telemetry.get_posthog_telemetry_client")- def test_flush(self, mock_get_posthog, mock_project_root, mock_environment):- """Test flushing telemetry data."""- mock_client = MagicMock()- mock_client.flush.return_value = True- mock_get_posthog.return_value = mock_client-- client = UniversalTelemetryClient(mock_project_root)- result = client.flush()-- assert result is True- mock_client.flush.assert_called_once()-- @patch("core.telemetry.telemetry.POSTHOG_AVAILABLE", True)- @patch("core.telemetry.telemetry.get_posthog_telemetry_client")- def test_enable_disable(self, mock_get_posthog, mock_project_root):- """Test enabling and disabling telemetry."""- mock_client = MagicMock()- mock_get_posthog.return_value = mock_client-- client = UniversalTelemetryClient(mock_project_root)-- client.enable()- mock_client.enable.assert_called_once()-- client.disable()- mock_client.disable.assert_called_once()---def test_get_telemetry_client():- """Test the global client getter."""- # Reset global state- from core.telemetry.telemetry import _universal_client-- _universal_client = None-- with patch("core.telemetry.telemetry.UniversalTelemetryClient") as mock_client_class:- mock_client = MagicMock()- mock_client_class.return_value = mock_client-- # First call should create a new client- client1 = get_telemetry_client()- assert client1 is mock_client- mock_client_class.assert_called_once()-- # Second call should return the same client- client2 = get_telemetry_client()- assert client2 is client1- assert mock_client_class.call_count == 1---def test_disable_telemetry():- """Test the global disable function."""- # Reset global state- from core.telemetry.telemetry import _universal_client-- _universal_client = None-- with patch("core.telemetry.telemetry.get_telemetry_client") as mock_get_client:- mock_client = MagicMock()- mock_get_client.return_value = mock_client-- # Disable globally- disable_telemetry()- mock_client.disable.assert_called_once()---def test_enable_telemetry():- """Test the global enable function."""- # Reset global state- from core.telemetry.telemetry import _universal_client-- _universal_client = None-- with patch("core.telemetry.telemetry.get_telemetry_client") as mock_get_client:- mock_client = MagicMock()- mock_get_client.return_value = mock_client-- # Enable globally- enable_telemetry()- mock_client.enable.assert_called_once()diff --git a/libs/lume/scripts/build/build-debug.sh b/libs/lume/scripts/build/build-debug.shdeleted file mode 100755index 452e20c326..0000000000--- a/libs/lume/scripts/build/build-debug.sh+++ /dev/null@@ -1,4 +0,0 @@-#!/bin/sh--swift build --product lume-codesign --force --entitlement resources/lume.entitlements --sign - .build/debug/lumediff --git a/libs/lume/scripts/build/build-release-notarized.sh b/libs/lume/scripts/build/build-release-notarized.shdeleted file mode 100755index df2b82c21b..0000000000--- a/libs/lume/scripts/build/build-release-notarized.sh+++ /dev/null@@ -1,187 +0,0 @@-#!/bin/bash--# Set default log level if not provided-LOG_LEVEL=${LOG_LEVEL:-"normal"}--# Function to log based on level-log() {- local level=$1- local message=$2-- case "$LOG_LEVEL" in- "minimal")- # Only show essential or error messages- if [ "$level" = "essential" ] || [ "$level" = "error" ]; then- echo "$message"- fi- ;;- "none")- # Show nothing except errors- if [ "$level" = "error" ]; then- echo "$message" >&2- fi- ;;- *)- # Normal logging - show everything- echo "$message"- ;;- esac-}--# Check required environment variables-required_vars=(- "CERT_APPLICATION_NAME"- "CERT_INSTALLER_NAME"- "APPLE_ID"- "TEAM_ID"- "APP_SPECIFIC_PASSWORD"-)--for var in "${required_vars[@]}"; do- if [ -z "${!var}" ]; then- log "error" "Error: $var is not set"- exit 1- fi-done--# Get VERSION from environment or use default-VERSION=${VERSION:-"0.1.0"}--# Move to the project root directory-pushd ../../ > /dev/null--# Ensure .release directory exists and is clean-mkdir -p .release-log "normal" "Ensuring .release directory exists and is accessible"--# Build the release version-log "essential" "Building release version..."-swift build -c release --product lume > /dev/null--# Sign the binary with hardened runtime entitlements-log "essential" "Signing binary with entitlements..."-codesign --force --options runtime \- --entitlement ./resources/lume.entitlements \- --sign "$CERT_APPLICATION_NAME" \- .build/release/lume 2> /dev/null--# Create a temporary directory for packaging-TEMP_ROOT=$(mktemp -d)-mkdir -p "$TEMP_ROOT/usr/local/bin"-cp -f .build/release/lume "$TEMP_ROOT/usr/local/bin/"--# Build the installer package-log "essential" "Building installer package..."-pkgbuild --root "$TEMP_ROOT" \- --identifier "com.trycua.lume" \- --version "1.0" \- --install-location "/" \- --sign "$CERT_INSTALLER_NAME" \- ./.release/lume.pkg 2> /dev/null--# Submit for notarization using stored credentials-log "essential" "Submitting for notarization..."-if [ "$LOG_LEVEL" = "minimal" ] || [ "$LOG_LEVEL" = "none" ]; then- # Minimal output - capture ID but hide details- NOTARY_OUTPUT=$(xcrun notarytool submit ./.release/lume.pkg \- --apple-id "${APPLE_ID}" \- --team-id "${TEAM_ID}" \- --password "${APP_SPECIFIC_PASSWORD}" \- --wait 2>&1)-- # Just show success or failure- if echo "$NOTARY_OUTPUT" | grep -q "status: Accepted"; then- log "essential" "Notarization successful!"- else- log "error" "Notarization failed. Please check logs."- fi-else- # Normal verbose output- xcrun notarytool submit ./.release/lume.pkg \- --apple-id "${APPLE_ID}" \- --team-id "${TEAM_ID}" \- --password "${APP_SPECIFIC_PASSWORD}" \- --wait-fi--# Staple the notarization ticket-log "essential" "Stapling notarization ticket..."-xcrun stapler staple ./.release/lume.pkg > /dev/null 2>&1--# Create temporary directory for package extraction-EXTRACT_ROOT=$(mktemp -d)-PKG_PATH="$(pwd)/.release/lume.pkg"--# Extract the pkg using xar-cd "$EXTRACT_ROOT"-xar -xf "$PKG_PATH" > /dev/null 2>&1--# Verify Payload exists before proceeding-if [ ! -f "Payload" ]; then- log "error" "Error: Payload file not found after xar extraction"- exit 1-fi--# Create a directory for the extracted contents-mkdir -p extracted-cd extracted--# Extract the Payload-cat ../Payload | gunzip -dc | cpio -i > /dev/null 2>&1--# Verify the binary exists-if [ ! -f "usr/local/bin/lume" ]; then- log "error" "Error: lume binary not found in expected location"- exit 1-fi--# Get the release directory absolute path-RELEASE_DIR="$(realpath "$(dirname "$PKG_PATH")")"-log "normal" "Using release directory: $RELEASE_DIR"--# Copy extracted lume to the release directory-cp -f usr/local/bin/lume "$RELEASE_DIR/lume"--# Create symbolic link in /usr/local/bin if not in minimal mode-if [ "$LOG_LEVEL" != "minimal" ] && [ "$LOG_LEVEL" != "none" ]; then- log "normal" "Creating symbolic link..."- sudo ln -sf "$RELEASE_DIR/lume" /usr/local/bin/lume-fi--# Get architecture and create OS identifier-ARCH=$(uname -m)-OS_IDENTIFIER="darwin-${ARCH}"--# Create versioned archives of the package with OS identifier in the name-log "essential" "Creating archives in $RELEASE_DIR..."-cd "$RELEASE_DIR"--# Clean up any existing artifacts first to avoid conflicts-rm -f lume-*.tar.gz lume-*.pkg.tar.gz--# Create version-specific archives-log "essential" "Creating version-specific archives (${VERSION})..."-# Package the binary-tar -czf "lume-${VERSION}-${OS_IDENTIFIER}.tar.gz" lume > /dev/null 2>&1-# Package the installer-tar -czf "lume-${VERSION}-${OS_IDENTIFIER}.pkg.tar.gz" lume.pkg > /dev/null 2>&1--# Create sha256 checksum file-log "essential" "Generating checksums..."-shasum -a 256 lume-*.tar.gz > checksums.txt-log "essential" "Package created successfully with checksums generated."--# Show what's in the release directory-log "essential" "Files in release directory:"-ls -la "$RELEASE_DIR"--# Ensure correct permissions-chmod 644 "$RELEASE_DIR"/*.tar.gz "$RELEASE_DIR"/*.pkg.tar.gz "$RELEASE_DIR"/checksums.txt--popd > /dev/null--# Clean up-rm -rf "$TEMP_ROOT"-rm -rf "$EXTRACT_ROOT"--log "essential" "Build and packaging completed successfully."\ No newline at end of filediff --git a/libs/lume/scripts/build/build-release.sh b/libs/lume/scripts/build/build-release.shdeleted file mode 100755index 9861ca5639..0000000000--- a/libs/lume/scripts/build/build-release.sh+++ /dev/null@@ -1,15 +0,0 @@-#!/bin/sh--pushd ../../--swift build -c release --product lume-codesign --force --entitlement ./resources/lume.entitlements --sign - .build/release/lume--mkdir -p ./.release-cp -f .build/release/lume ./.release/lume--# Create symbolic link in /usr/local/bin-sudo mkdir -p /usr/local/bin-sudo ln -sf "$(pwd)/.release/lume" /usr/local/bin/lume--popd\ No newline at end of filediff --git a/libs/pylume/pylume/pylume.py b/libs/pylume/pylume/pylume.pyindex 66fb6bc414..2073b8834f 100644--- a/libs/pylume/pylume/pylume.py+++ b/libs/pylume/pylume/pylume.py@@ -33,18 +33,22 @@ from .exceptions import ()# Type variable for the decorator-T = TypeVar('T')+T = TypeVar("T")+def ensure_server(func: Callable[..., T]) -> Callable[..., T]:"""Decorator to ensure server is running before executing the method."""+@wraps(func)- async def wrapper(self: 'PyLume', *args: Any, **kwargs: Any) -> T:+ async def wrapper(self: "PyLume", *args: Any, **kwargs: Any) -> T:# ensure_running is an async method, so we need to await itawait self.server.ensure_running()# Initialize client if neededawait self._init_client()- return await func(self, *args, **kwargs) # type: ignore- return wrapper # type: ignore+ return await func(self, *args, **kwargs) # type: ignore++ return wrapper # type: ignore+class PyLume:def __init__(@@ -52,10 +56,11 @@ class PyLume:debug: bool = False,server_start_timeout: int = 60,port: Optional[int] = None,- use_existing_server: bool = False+ use_existing_server: bool = False,+ host: str = "localhost",):"""Initialize the async PyLume client.-+Args:debug: Enable debug loggingauto_start_server: Whether to automatically start the lume server if not running@@ -63,27 +68,35 @@ class PyLume:port: Port number for the lume server. Required when use_existing_server is True.use_existing_server: If True, will try to connect to an existing server on the specified portinstead of starting a new one.+ host: Host to use for connections (e.g., "localhost", "127.0.0.1", "host.docker.internal")"""if use_existing_server and port is None:raise LumeConfigError("Port must be specified when using an existing server")-+self.server = LumeServer(- debug=debug,+ debug=debug,server_start_timeout=server_start_timeout,port=port,- use_existing_server=use_existing_server+ use_existing_server=use_existing_server,+ host=host,)self.client = None- async def __aenter__(self) -> 'PyLume':+ async def __aenter__(self) -> "PyLume":"""Async context manager entry."""if self.server.use_existing_server:- # Just set up the base URL and initialize client for existing server- self.server.port = self.server.requested_port- self.server.base_url = f"http://localhost:{self.server.port}/lume"- else:- await self.server.ensure_running()-+ # Just ensure base_url is set for existing server+ if self.server.requested_port is None:+ raise LumeConfigError("Port must be specified when using an existing server")++ if not self.server.base_url:+ self.server.port = self.server.requested_port+ self.server.base_url = f"http://{self.server.host}:{self.server.port}/lume"++ # Ensure the server is running (will connect to existing or start new as needed)+ await self.server.ensure_running()++ # Initialize the clientawait self._init_client()return self@@ -98,11 +111,7 @@ class PyLume:if self.client is None:if self.server.base_url is None:raise RuntimeError("Server base URL not set")- self.client = LumeClient(- base_url=self.server.base_url,- timeout=300.0,- debug=self.server.debug- )+ self.client = LumeClient(self.server.base_url, debug=self.server.debug)def _log_debug(self, message: str, **kwargs) -> None:"""Log debug information if debug mode is enabled."""@@ -117,19 +126,17 @@ class PyLume:raise LumeConnectionError(f"Failed to connect to PyLume server: {str(e)}")elif isinstance(e, asyncio.TimeoutError):raise LumeTimeoutError(f"Request timed out: {str(e)}")-- if not hasattr(e, 'status') and not isinstance(e, subprocess.CalledProcessError):++ if not hasattr(e, "status") and not isinstance(e, subprocess.CalledProcessError):raise LumeServerError(f"Unknown error during {operation}: {str(e)}")-- status_code = getattr(e, 'status', 500)++ status_code = getattr(e, "status", 500)response_text = str(e)-+self._log_debug(- f"{operation} request failed",- status_code=status_code,- response_text=response_text+ f"{operation} request failed", status_code=status_code, response_text=response_text)-+if status_code == 404:raise LumeNotFoundError(f"Resource not found during {operation}")elif status_code == 400:@@ -138,13 +145,11 @@ class PyLume:raise LumeServerError(f"Server error during {operation}",status_code=status_code,- response_text=response_text+ response_text=response_text,)else:raise LumeServerError(- f"Error during {operation}",- status_code=status_code,- response_text=response_text+ f"Error during {operation}", status_code=status_code, response_text=response_text)async def _read_output(self) -> None:@@ -163,7 +168,7 @@ class PyLume:breakline = line.strip()self._log_debug(f"Server stdout: {line}")- if "Server started" in line.decode('utf-8'):+ if "Server started" in line.decode("utf-8"):self._log_debug("Detected server started message")return@@ -175,7 +180,7 @@ class PyLume:breakline = line.strip()self._log_debug(f"Server stderr: {line}")- if "error" in line.decode('utf-8').lower():+ if "error" in line.decode("utf-8").lower():raise RuntimeError(f"Server error: {line}")await asyncio.sleep(0.1) # Small delay to prevent CPU spinning@@ -188,10 +193,10 @@ class PyLume:"""Create a VM with the given configuration."""# Ensure client is initializedawait self._init_client()-+if isinstance(spec, VMConfig):spec = spec.model_dump(by_alias=True, exclude_none=True)-+# Suppress optional attribute access errorsself.client.print_curl("POST", "/vms", spec) # type: ignore[attr-defined]await self.client.post("/vms", spec) # type: ignore[attr-defined]@@ -200,10 +205,10 @@ class PyLume:async def run_vm(self, name: str, opts: Optional[Union[VMRunOpts, dict]] = None) -> None:"""Run a VM."""if opts is None:- opts = VMRunOpts(no_display=False) # type: ignore[attr-defined]+ opts = VMRunOpts(no_display=False) # type: ignore[attr-defined]elif isinstance(opts, dict):opts = VMRunOpts(**opts)-+payload = opts.model_dump(by_alias=True, exclude_none=True)self.client.print_curl("POST", f"/vms/{name}/run", payload) # type: ignore[attr-defined]await self.client.post(f"/vms/{name}/run", payload) # type: ignore[attr-defined]@@ -225,7 +230,7 @@ class PyLume:"""Update VM settings."""if isinstance(params, dict):params = VMUpdateOpts(**params)-+payload = params.model_dump(by_alias=True, exclude_none=True)self.client.print_curl("PATCH", f"/vms/{name}", payload) # type: ignore[attr-defined]await self.client.patch(f"/vms/{name}", payload) # type: ignore[attr-defined]@@ -241,7 +246,9 @@ class PyLume:await self.client.delete(f"/vms/{name}") # type: ignore[attr-defined]@ensure_server- async def pull_image(self, spec: Union[ImageRef, dict, str], name: Optional[str] = None) -> None:+ async def pull_image(+ self, spec: Union[ImageRef, dict, str], name: Optional[str] = None+ ) -> None:"""Pull a VM image."""await self._init_client()if isinstance(spec, str):@@ -261,14 +268,14 @@ class PyLume:image_str = f"{spec.image}:{spec.tag}"registry = spec.registryorganization = spec.organization-+payload = {"image": image_str,"name": name,"registry": registry,- "organization": organization+ "organization": organization,}-+self.client.print_curl("POST", "/pull", payload) # type: ignore[attr-defined]await self.client.post("/pull", payload, timeout=300.0) # type: ignore[attr-defined]@@ -305,4 +312,4 @@ class PyLume:async def _ensure_client(self) -> None:"""Ensure client is initialized."""if self.client is None:- await self._init_client()\ No newline at end of file+ await self._init_client()diff --git a/libs/pylume/pylume/server.py b/libs/pylume/pylume/server.pyindex ab0b9a7114..01c480849a 100644--- a/libs/pylume/pylume/server.py+++ b/libs/pylume/pylume/server.py@@ -9,16 +9,31 @@ from typing import Optionalimport sysfrom .exceptions import LumeConnectionErrorimport signal+import json+import shlex+import random+from logging import getLogger+class LumeServer:def __init__(- self,- debug: bool = False,+ self,+ debug: bool = False,server_start_timeout: int = 60,port: Optional[int] = None,- use_existing_server: bool = False+ use_existing_server: bool = False,+ host: str = "localhost",):- """Initialize the LumeServer."""+ """Initialize the LumeServer.++ Args:+ debug: Enable debug logging+ server_start_timeout: Timeout in seconds to wait for server to start+ port: Specific port to use for the server+ use_existing_server: If True, will try to connect to an existing server+ instead of starting a new one+ host: Host to use for connections (e.g., "localhost", "127.0.0.1", "host.docker.internal")+ """self.debug = debugself.server_start_timeout = server_start_timeoutself.server_process = None@@ -27,72 +42,58 @@ class LumeServer:self.port = Noneself.base_url = Noneself.use_existing_server = use_existing_server-+ self.host = host+# Configure logging- self.logger = logging.getLogger('lume_server')+ self.logger = getLogger("pylume.server")if not self.logger.handlers:handler = logging.StreamHandler()- formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')+ formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")handler.setFormatter(formatter)self.logger.addHandler(handler)self.logger.setLevel(logging.DEBUG if debug else logging.INFO)+ self.logger.debug(f"Server initialized with host: {self.host}")+def _check_port_available(self, port: int) -> bool:- """Check if a specific port is available."""+ """Check if a port is available."""try:- # Create a socket- s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)- self.logger.debug(f"Created socket for port {port} check")-- # Set socket options- s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)- self.logger.debug("Set SO_REUSEADDR")-- # Bind to the port+ with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:+ s.settimeout(0.5)+ result = s.connect_ex(("127.0.0.1", port))+ if result == 0: # Port is in use on localhost+ return False+ except:+ pass++ # Check the specified host (e.g., "host.docker.internal") if it's not a localhost alias+ if self.host not in ["localhost", "127.0.0.1"]:try:- s.bind(('127.0.0.1', port))- self.logger.debug(f"Successfully bound to port {port}")- s.listen(1)- self.logger.debug(f"Successfully listening on port {port}")- s.close()- self.logger.debug(f"Port {port} is available")- return True- except OSError as e:- self.logger.debug(f"Failed to bind to port {port}: {str(e)}")- return False- finally:- try:- s.close()- self.logger.debug("Socket closed")- except:- pass-- except Exception as e:- self.logger.debug(f"Unexpected error checking port {port}: {str(e)}")- return False+ with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:+ s.settimeout(0.5)+ result = s.connect_ex((self.host, port))+ if result == 0: # Port is in use on host+ return False+ except:+ pass++ return Truedef _get_server_port(self) -> int:- """Get and validate the server port."""- from .exceptions import LumeConfigError-- if self.requested_port is None:- raise LumeConfigError("Port must be specified when starting a new server")-- self.logger.debug(f"Checking availability of port {self.requested_port}")-- # Try multiple times with a small delay- for attempt in range(3):- if attempt > 0:- self.logger.debug(f"Retrying port check (attempt {attempt + 1})")- time.sleep(1)-- if self._check_port_available(self.requested_port):- self.logger.debug(f"Port {self.requested_port} is available")- return self.requested_port- else:- self.logger.debug(f"Port {self.requested_port} check failed on attempt {attempt + 1}")-- raise LumeConfigError(f"Requested port {self.requested_port} is not available after 3 attempts")+ """Get an available port for the server."""+ # Use requested port if specified+ if self.requested_port is not None:+ if not self._check_port_available(self.requested_port):+ raise RuntimeError(f"Requested port {self.requested_port} is not available")+ return self.requested_port++ # Find a free port+ for _ in range(10): # Try up to 10 times+ port = random.randint(49152, 65535)+ if self._check_port_available(port):+ return port++ raise RuntimeError("Could not find an available port")async def _ensure_server_running(self) -> None:"""Ensure the lume server is running, start it if it's not."""@@ -101,35 +102,33 @@ class LumeServer:# Try to connect to the server with a short timeoutcmd = ["curl", "-s", "-w", "%{http_code}", "-m", "5", f"{self.base_url}/vms"]process = await asyncio.create_subprocess_exec(- *cmd,- stdout=subprocess.PIPE,- stderr=subprocess.PIPE+ *cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)stdout, stderr = await process.communicate()-+if process.returncode == 0:response = stdout.decode()status_code = int(response[-3:])if status_code == 200:self.logger.debug("PyLume server is running")return-+self.logger.debug("PyLume server not running, attempting to start it")# Server not running, try to start itlume_path = os.path.join(os.path.dirname(__file__), "lume")if not os.path.exists(lume_path):raise RuntimeError(f"Could not find lume binary at {lume_path}")-+# Make sure the file is executableos.chmod(lume_path, 0o755)-+# Create a temporary file for server output- self.output_file = tempfile.NamedTemporaryFile(mode='w+', delete=False)+ self.output_file = tempfile.NamedTemporaryFile(mode="w+", delete=False)self.logger.debug(f"Using temporary file for server output: {self.output_file.name}")-+# Start the serverself.logger.debug(f"Starting lume server with: {lume_path} serve --port {self.port}")-+# Start server in background using subprocess.Popentry:self.server_process = subprocess.Popen(@@ -137,19 +136,21 @@ class LumeServer:stdout=self.output_file,stderr=self.output_file,cwd=os.path.dirname(lume_path),- start_new_session=True # Run in new session to avoid blocking+ start_new_session=True, # Run in new session to avoid blocking)except Exception as e:self.output_file.close()os.unlink(self.output_file.name)raise RuntimeError(f"Failed to start lume server process: {str(e)}")-+# Wait for server to start- self.logger.debug(f"Waiting up to {self.server_start_timeout} seconds for server to start...")+ self.logger.debug(+ f"Waiting up to {self.server_start_timeout} seconds for server to start..."+ )start_time = time.time()server_ready = Falselast_size = 0-+while time.time() - start_time < self.server_start_timeout:if self.server_process.poll() is not None:# Process has terminated@@ -163,7 +164,7 @@ class LumeServer:f"Output: {output}")raise RuntimeError(error_msg)-+# Check output file for server ready messageself.output_file.seek(0, os.SEEK_END)size = self.output_file.tell()@@ -173,22 +174,20 @@ class LumeServer:if new_output.strip(): # Only log non-empty outputself.logger.debug(f"Server output: {new_output.strip()}")last_size = size-+if "Server started" in new_output:server_ready = Trueself.logger.debug("Server startup detected")break-+# Try to connect to the server periodicallytry:cmd = ["curl", "-s", "-w", "%{http_code}", "-m", "5", f"{self.base_url}/vms"]process = await asyncio.create_subprocess_exec(- *cmd,- stdout=subprocess.PIPE,- stderr=subprocess.PIPE+ *cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)stdout, stderr = await process.communicate()-+if process.returncode == 0:response = stdout.decode()status_code = int(response[-3:])@@ -198,9 +197,9 @@ class LumeServer:breakexcept:pass # Server not ready yet-+await asyncio.sleep(1.0)-+if not server_ready:# Cleanup if server didn't startif self.server_process:@@ -215,29 +214,27 @@ class LumeServer:f"Failed to start lume server after {self.server_start_timeout} seconds. ""Check the debug output for more details.")-+# Give the server a moment to fully initializeawait asyncio.sleep(2.0)-+# Verify server is respondingtry:cmd = ["curl", "-s", "-w", "%{http_code}", "-m", "10", f"{self.base_url}/vms"]process = await asyncio.create_subprocess_exec(- *cmd,- stdout=subprocess.PIPE,- stderr=subprocess.PIPE+ *cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)stdout, stderr = await process.communicate()-+if process.returncode != 0:raise RuntimeError(f"Curl command failed: {stderr.decode()}")-+response = stdout.decode()status_code = int(response[-3:])-+if status_code != 200:raise RuntimeError(f"Server returned status code {status_code}")-+self.logger.debug("PyLume server started successfully")except Exception as e:self.logger.debug(f"Server verification failed: {str(e)}")@@ -250,16 +247,16 @@ class LumeServer:self.output_file.close()os.unlink(self.output_file.name)raise RuntimeError(f"Server started but is not responding: {str(e)}")-+self.logger.debug("Server startup completed successfully")-+except Exception as e:raise RuntimeError(f"Failed to start lume server: {str(e)}")async def _start_server(self) -> None:"""Start the lume server using the lume executable."""self.logger.debug("Starting PyLume server")-+# Get absolute path to lume executable in the same directory as this filelume_path = os.path.join(os.path.dirname(__file__), "lume")if not os.path.exists(lume_path):@@ -268,24 +265,25 @@ class LumeServer:try:# Make executableos.chmod(lume_path, 0o755)-+# Get and validate portself.port = self._get_server_port()- self.base_url = f"http://localhost:{self.port}/lume"+ self.base_url = f"http://{self.host}:{self.port}/lume"# Set up output handling- self.output_file = tempfile.NamedTemporaryFile(mode='w+', delete=False)-+ self.output_file = tempfile.NamedTemporaryFile(mode="w+", delete=False)+# Start the server process with the lume executableenv = os.environ.copy()env["RUST_BACKTRACE"] = "1" # Enable backtrace for better error reporting-++ # Specify the host to bind to (0.0.0.0 to allow external connections)self.server_process = subprocess.Popen([lume_path, "serve", "--port", str(self.port)],stdout=self.output_file,stderr=subprocess.STDOUT,cwd=os.path.dirname(lume_path), # Run from same directory as executable- env=env+ env=env,)# Wait for server to initialize@@ -300,13 +298,13 @@ class LumeServer:"""Read and display server log output in debug mode."""while True:try:- self.output_file.seek(0, os.SEEK_END) # type: ignore[attr-defined]- line = self.output_file.readline() # type: ignore[attr-defined]+ self.output_file.seek(0, os.SEEK_END) # type: ignore[attr-defined]+ line = self.output_file.readline() # type: ignore[attr-defined]if line:line = line.strip()if line:print(f"SERVER: {line}")- if self.server_process.poll() is not None: # type: ignore[attr-defined]+ if self.server_process.poll() is not None: # type: ignore[attr-defined]print("Server process ended")breakawait asyncio.sleep(0.1)@@ -318,11 +316,11 @@ class LumeServer:"""Wait for server to start and become responsive with increased timeout."""start_time = time.time()while time.time() - start_time < self.server_start_timeout:- if self.server_process.poll() is not None: # type: ignore[attr-defined]+ if self.server_process.poll() is not None: # type: ignore[attr-defined]error_msg = await self._get_error_output()await self._cleanup()raise RuntimeError(error_msg)-+try:await self._verify_server()self.logger.debug("Server is now responsive")@@ -330,30 +328,36 @@ class LumeServer:except Exception as e:self.logger.debug(f"Server not ready yet: {str(e)}")await asyncio.sleep(1.0)-+await self._cleanup()raise RuntimeError(f"Server failed to start after {self.server_start_timeout} seconds")async def _verify_server(self) -> None:"""Verify server is responding to requests."""try:- cmd = ["curl", "-s", "-w", "%{http_code}", "-m", "10", f"{self.base_url}/vms"]+ cmd = [+ "curl",+ "-s",+ "-w",+ "%{http_code}",+ "-m",+ "10",+ f"http://{self.host}:{self.port}/lume/vms",+ ]process = await asyncio.create_subprocess_exec(- *cmd,- stdout=subprocess.PIPE,- stderr=subprocess.PIPE+ *cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)stdout, stderr = await process.communicate()-+if process.returncode != 0:raise RuntimeError(f"Curl command failed: {stderr.decode()}")-+response = stdout.decode()status_code = int(response[-3:])-+if status_code != 200:raise RuntimeError(f"Server returned status code {status_code}")-+self.logger.debug("PyLume server started successfully")except Exception as e:raise RuntimeError(f"Server not responding: {str(e)}")@@ -366,7 +370,7 @@ class LumeServer:output = self.output_file.read()return (f"Server process terminated unexpectedly.\n"- f"Exit code: {self.server_process.returncode}\n" # type: ignore[attr-defined]+ f"Exit code: {self.server_process.returncode}\n" # type: ignore[attr-defined]f"Output: {output}")@@ -393,12 +397,84 @@ class LumeServer:self.output_file = Noneasync def ensure_running(self) -> None:- """Start the server if we're managing it."""- if not self.use_existing_server:+ """Ensure the server is running.++ If use_existing_server is True, will only try to connect to an existing server.+ Otherwise will:+ 1. Try to connect to an existing server on the specified port+ 2. If that fails and not in Docker, start a new server+ 3. If in Docker and no existing server is found, raise an error+ """+ # First check if we're in Docker+ in_docker = os.path.exists("/.dockerenv") or (+ os.path.exists("/proc/1/cgroup") and "docker" in open("/proc/1/cgroup", "r").read()+ )++ # If using a non-localhost host like host.docker.internal, set up the connection details+ if self.host not in ["localhost", "127.0.0.1"]:+ if self.requested_port is None:+ raise RuntimeError("Port must be specified when using a remote host")++ self.port = self.requested_port+ self.base_url = f"http://{self.host}:{self.port}/lume"+ self.logger.debug(f"Using remote host server at {self.base_url}")++ # Try to verify the server is accessible+ try:+ await self._verify_server()+ self.logger.debug("Successfully connected to remote server")+ return+ except Exception as e:+ if self.use_existing_server or in_docker:+ # If explicitly requesting an existing server or in Docker, we can't start a new one+ raise RuntimeError(+ f"Failed to connect to remote server at {self.base_url}: {str(e)}"+ )+ else:+ self.logger.debug(f"Remote server not available at {self.base_url}: {str(e)}")+ # Fall back to localhost for starting a new server+ self.host = "localhost"++ # If explicitly using an existing server, verify it's running+ if self.use_existing_server:+ if self.requested_port is None:+ raise RuntimeError("Port must be specified when using an existing server")++ self.port = self.requested_port+ self.base_url = f"http://{self.host}:{self.port}/lume"++ try:+ await self._verify_server()+ self.logger.debug("Successfully connected to existing server")+ except Exception as e:+ raise RuntimeError(+ f"Failed to connect to existing server at {self.base_url}: {str(e)}"+ )+ else:+ # Try to connect to an existing server first+ if self.requested_port is not None:+ self.port = self.requested_port+ self.base_url = f"http://{self.host}:{self.port}/lume"++ try:+ await self._verify_server()+ self.logger.debug("Successfully connected to existing server")+ return+ except Exception:+ self.logger.debug(f"No existing server found at {self.base_url}")++ # If in Docker and can't connect to existing server, raise an error+ if in_docker:+ raise RuntimeError(+ f"Failed to connect to server at {self.base_url} and cannot start a new server in Docker"+ )++ # Start a new server+ self.logger.debug("Starting a new server instance")await self._start_server()async def stop(self) -> None:"""Stop the server if we're managing it."""if not self.use_existing_server:self.logger.debug("Stopping lume server...")- await self._cleanup()\ No newline at end of file+ await self._cleanup()diff --git a/libs/pylume/tests/__init__.py b/libs/pylume/tests/__init__.pydeleted file mode 100644index e1b66e8e20..0000000000--- a/libs/pylume/tests/__init__.py+++ /dev/null@@ -1,3 +0,0 @@-"""-PyLume tests package-"""\ No newline at end of filediff --git a/libs/pylume/tests/test_basic.py b/libs/pylume/tests/test_basic.pydeleted file mode 100644index 18c2f30e6c..0000000000--- a/libs/pylume/tests/test_basic.py+++ /dev/null@@ -1,20 +0,0 @@-"""-Basic tests for the pylume package-"""-import pytest---def test_import():- """Test that the package can be imported"""- import pylume- try:- assert pylume.__version__ == "0.1.0"- except AttributeError:- # If __version__ is not defined, that's okay for this test- pass---def test_pylume_import():- """Test that the PyLume class can be imported"""- from pylume import PyLume- assert PyLume is not None\ No newline at end of filediff --git a/libs/som/som/detect.py b/libs/som/som/detect.pyindex 25b95c8d88..e845740e7f 100644--- a/libs/som/som/detect.py+++ b/libs/som/som/detect.py@@ -1,5 +1,5 @@from pathlib import Path-from typing import Union, List, Dict, Any, Tuple, Optional+from typing import Union, List, Dict, Any, Tuple, Optional, castimport loggingimport torchimport torchvision.ops@@ -179,16 +179,23 @@ class OmniParser:logger.info(f"Found {len(icon_detections)} interactive elements")# Convert icon detections to typed objects- elements: List[UIElement] = [- IconElement(- bbox=BoundingBox(- x1=det["bbox"][0], y1=det["bbox"][1], x2=det["bbox"][2], y2=det["bbox"][3]- ),- confidence=det["confidence"],- scale=det.get("scale"),- )- for det in icon_detections- ]+ elements: List[UIElement] = cast(+ List[UIElement],+ [+ IconElement(+ id=i + 1,+ bbox=BoundingBox(+ x1=det["bbox"][0],+ y1=det["bbox"][1],+ x2=det["bbox"][2],+ y2=det["bbox"][3],+ ),+ confidence=det["confidence"],+ scale=det.get("scale"),+ )+ for i, det in enumerate(icon_detections)+ ],+ )# Run OCR if enabledif use_ocr:@@ -198,21 +205,25 @@ class OmniParser:text_detections = []logger.info(f"Found {len(text_detections)} text regions")- # Convert text detections to typed objects+ # Convert text detections to typed objects and extend the listelements.extend(- [- TextElement(- bbox=BoundingBox(- x1=det["bbox"][0],- y1=det["bbox"][1],- x2=det["bbox"][2],- y2=det["bbox"][3],- ),- content=det["content"],- confidence=det["confidence"],- )- for det in text_detections- ]+ cast(+ List[UIElement],+ [+ TextElement(+ id=len(elements) + i + 1,+ bbox=BoundingBox(+ x1=det["bbox"][0],+ y1=det["bbox"][1],+ x2=det["bbox"][2],+ y2=det["bbox"][3],+ ),+ content=det["content"],+ confidence=det["confidence"],+ )+ for i, det in enumerate(text_detections)+ ],+ ))# Calculate drawing parameters based on image sizediff --git a/scripts/run-docker-dev.sh b/scripts/run-docker-dev.shnew file mode 100755index 0000000000..bb6ef18865--- /dev/null+++ b/scripts/run-docker-dev.sh@@ -0,0 +1,97 @@+#!/bin/bash++# Colors for output+GREEN='\033[0;32m'+BLUE='\033[0;34m'+RED='\033[0;31m'+NC='\033[0m' # No Color++# Print with color+print_info() {+ echo -e "${BLUE}==> $1${NC}"+}++print_success() {+ echo -e "${GREEN}==> $1${NC}"+}++print_error() {+ echo -e "${RED}==> $1${NC}"+}++# Docker image name+IMAGE_NAME="cua-dev-image"+CONTAINER_NAME="cua-dev-container"+PLATFORM="linux/arm64"++# Environment variables+PYTHONPATH="/app/libs/core:/app/libs/computer:/app/libs/agent:/app/libs/som:/app/libs/pylume:/app/libs/computer-server"++# Check if Docker is installed+if ! command -v docker &> /dev/null; then+ print_error "Docker is not installed. Please install Docker first."+ exit 1+fi++# Command options+case "$1" in+ build)+ print_info "Building the development Docker image..."+ print_info "This will install all dependencies but won't include source code"+ docker build -f Dockerfile --platform=${PLATFORM} -t ${IMAGE_NAME} .+ print_success "Development Docker image built successfully!"+ ;;++ run)+ # Check for interactive flag+ if [ "$2" == "--interactive" ]; then+ print_info "Running the development Docker container with interactive shell..."+ print_info "Mounting source code from host"+ print_info "Connecting to host.docker.internal:3000"++ docker run -it --rm \+ --platform=${PLATFORM} \+ --name ${CONTAINER_NAME} \+ -v "$(pwd):/app" \+ -e PYTHONPATH=${PYTHONPATH} \+ -e DISPLAY=${DISPLAY:-:0} \+ -e PYLUME_HOST="host.docker.internal" \+ ${IMAGE_NAME} bash+ else+ # Run the specified example+ if [ -z "$2" ]; then+ print_error "Please specify an example file, e.g., ./run-docker-dev.sh run computer_examples.py"+ exit 1+ fi+ print_info "Running example: $2"+ print_info "Connecting to host.docker.internal:3000"++ docker run -it --rm \+ --platform=${PLATFORM} \+ --name ${CONTAINER_NAME} \+ -v "$(pwd):/app" \+ -e PYTHONPATH=${PYTHONPATH} \+ -e DISPLAY=${DISPLAY:-:0} \+ -e PYLUME_HOST="host.docker.internal" \+ ${IMAGE_NAME} python "/app/examples/$2"+ fi+ ;;++ stop)+ print_info "Stopping any running containers..."+ docker stop ${CONTAINER_NAME} 2>/dev/null || true+ print_success "Done!"+ ;;++ *)+ echo "Usage: $0 {build|run [--interactive] [filename]|stop}"+ echo ""+ echo "Commands:"+ echo " build Build the development Docker image with dependencies"+ echo " run [example_filename] Run the specified example file in the container"+ echo " run --interactive Run the container with mounted code and get an interactive shell"+ echo " stop Stop the container"+ exit 1+esac++exit 0\ No newline at end of file