cua-agent 0.1.1__tar.gz → 0.1.2__tar.gz

{cua_agent-0.1.1 → cua_agent-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cua-agent
-Version: 0.1.1
+Version: 0.1.2
 Summary: CUA (Computer Use) Agent for AI-driven computer interaction
 Author-Email: TryCua <gh@trycua.com>
 Requires-Python: <3.13,>=3.10

{cua_agent-0.1.1 → cua_agent-0.1.2}/README.md

@@ -20,19 +20,19 @@
 ### Get started with Agent
 
 ```python
-from agent import ComputerAgent, AgenticLoop, APIProvider
+from agent import ComputerAgent, AgentLoop, LLMProvider
 from computer import Computer
 
 computer = Computer(verbosity=logging.INFO)
 
 agent = ComputerAgent(
     computer=computer,
-    api_key="<your-anthropic-api-key>",
-    loop_type=AgenticLoop.ANTHROPIC, # or AgenticLoop.OMNI
-    ai_provider=APIProvider.ANTHROPIC,
-    model='claude-3-7-sonnet-20250219',
+    loop=AgentLoop.ANTHROPIC,
+    # loop=AgentLoop.OMNI,
+    model=LLM(provider=LLMProvider.ANTHROPIC, name="claude-3-7-sonnet-20250219"),
+    # model=LLM(provider=LLMProvider.OPENAI, name="gpt-4.5-preview"),
     save_trajectory=True,
-    trajectory_dir=str(Path("trajectories") / datetime.now().strftime("%Y%m%d_%H%M%S")),
+    trajectory_dir=str(Path("trajectories")),
     only_n_most_recent_images=3,
     verbosity=logging.INFO,
 )

cua_agent-0.1.2/agent/__init__.py

@@ -0,0 +1,10 @@
+"""CUA (Computer Use) Agent for AI-driven computer interaction."""
+
+__version__ = "0.1.0"
+
+from .core.factory import AgentFactory
+from .core.agent import ComputerAgent
+from .providers.omni.types import LLMProvider, LLM
+from .types.base import Provider, AgentLoop
+
+__all__ = ["AgentFactory", "Provider", "ComputerAgent", "AgentLoop", "LLMProvider", "LLM"]

{cua_agent-0.1.1 → cua_agent-0.1.2}/agent/core/README.md

@@ -34,7 +34,7 @@ Here's how to use the unified ComputerAgent:
 ```python
 from agent.core.agent import ComputerAgent
 from agent.types.base import AgenticLoop
-from agent.providers.omni.types import APIProvider
+from agent.providers.omni.types import LLMProvider
 from computer import Computer
 
 # Create a Computer instance
@@ -44,7 +44,7 @@ computer = Computer()
 agent = ComputerAgent(
     computer=computer,
     loop_type=AgenticLoop.OMNI,
-    provider=APIProvider.OPENAI,
+    provider=LLMProvider.OPENAI,
     model="gpt-4o",
     api_key="your_api_key_here",  # Can also use OPENAI_API_KEY environment variable
     save_trajectory=True,

{cua_agent-0.1.1 → cua_agent-0.1.2}/agent/core/agent.py

@@ -8,7 +8,7 @@ from datetime import datetime
 
 from computer import Computer
 
-from ..types.base import Provider, AgenticLoop
+from ..types.base import Provider, AgentLoop
 from .base_agent import BaseComputerAgent
 
 # Only import types for type checking to avoid circular imports
@@ -18,7 +18,7 @@ if TYPE_CHECKING:
     from ..providers.omni.parser import OmniParser
 
 # Import the provider types
-from ..providers.omni.types import LLMProvider, LLM, Model, LLMModel, APIProvider
+from ..providers.omni.types import LLMProvider, LLM, Model, LLMModel
 
 logger = logging.getLogger(__name__)
 
@@ -47,7 +47,7 @@ class ComputerAgent(BaseComputerAgent):
     def __init__(
         self,
         computer: Computer,
-        loop_type: AgenticLoop = AgenticLoop.OMNI,
+        loop: AgentLoop = AgentLoop.OMNI,
         model: Optional[Union[LLM, Dict[str, str], str]] = None,
         api_key: Optional[str] = None,
         save_trajectory: bool = True,
@@ -61,12 +61,12 @@ class ComputerAgent(BaseComputerAgent):
 
         Args:
             computer: Computer instance to control
-            loop_type: The type of loop to use (Anthropic or Omni)
+            loop: The type of loop to use (Anthropic or Omni)
             model: LLM configuration. Can be:
                   - LLM object with provider and name
                   - Dict with 'provider' and 'name' keys
                   - String with model name (defaults to OpenAI provider)
-                  - None (defaults based on loop_type)
+                  - None (defaults based on loop)
             api_key: Optional API key (will use environment variable if not provided)
             save_trajectory: Whether to save screenshots and logs
             trajectory_dir: Directory to save trajectories (defaults to "trajectories")
@@ -89,7 +89,7 @@ class ComputerAgent(BaseComputerAgent):
             **kwargs,
         )
 
-        self.loop_type = loop_type
+        self.loop_type = loop
         self.save_trajectory = save_trajectory
         self.trajectory_dir = trajectory_dir
         self.only_n_most_recent_images = only_n_most_recent_images
@@ -100,13 +100,13 @@ class ComputerAgent(BaseComputerAgent):
         self._configure_logging(verbosity)
 
         # Process model configuration
-        self.model_config = self._process_model_config(model, loop_type)
-        
+        self.model_config = self._process_model_config(model, loop)
+
         # Get API key from environment if not provided
         if api_key is None:
             env_var = (
-                ENV_VARS.get(self.model_config.provider) 
-                if loop_type == AgenticLoop.OMNI 
+                ENV_VARS.get(self.model_config.provider)
+                if loop == AgentLoop.OMNI
                 else "ANTHROPIC_API_KEY"
             )
             if not env_var:
@@ -127,16 +127,16 @@ class ComputerAgent(BaseComputerAgent):
 
         # Initialize the appropriate loop based on loop_type
         self.loop = self._init_loop()
-        
+
     def _process_model_config(
-        self, model_input: Optional[Union[LLM, Dict[str, str], str]], loop_type: AgenticLoop
+        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_type: The loop type being used
-            
+            loop: The loop type being used
+
         Returns:
             Normalized LLM instance
         """
@@ -144,31 +144,28 @@ class ComputerAgent(BaseComputerAgent):
         if model_input is None:
             # Use Anthropic for Anthropic loop, OpenAI for Omni loop
             default_provider = (
-                LLMProvider.ANTHROPIC if loop_type == AgenticLoop.ANTHROPIC else LLMProvider.OPENAI
+                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")
-            )
-            
+            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_type == AgenticLoop.ANTHROPIC else LLMProvider.OPENAI
+                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):
@@ -199,12 +196,12 @@ class ComputerAgent(BaseComputerAgent):
         from ..providers.omni.loop import OmniLoop
         from ..providers.omni.parser import OmniParser
 
-        if self.loop_type == AgenticLoop.ANTHROPIC:
+        if self.loop_type == AgentLoop.ANTHROPIC:
             from ..providers.anthropic.loop import AnthropicLoop
 
             # Ensure we always have a valid model name
             model_name = self.model_config.name or DEFAULT_MODELS[LLMProvider.ANTHROPIC]
-            
+
             return AnthropicLoop(
                 api_key=self.api_key,
                 model=model_name,
@@ -221,7 +218,7 @@ class ComputerAgent(BaseComputerAgent):
 
         # Ensure we always have a valid model name
         model_name = self.model_config.name or DEFAULT_MODELS[self.model_config.provider]
-        
+
         return OmniLoop(
             provider=self.model_config.provider,
             api_key=self.api_key,
@@ -244,7 +241,7 @@ class ComputerAgent(BaseComputerAgent):
         """
         try:
             # Format the messages based on loop type
-            if self.loop_type == AgenticLoop.ANTHROPIC:
+            if self.loop_type == AgentLoop.ANTHROPIC:
                 # Anthropic format
                 messages = [{"role": "user", "content": [{"type": "text", "text": task}]}]
             else:
@@ -267,7 +264,7 @@ class ComputerAgent(BaseComputerAgent):
                         continue
 
                     # Extract content and metadata based on loop type
-                    if self.loop_type == AgenticLoop.ANTHROPIC:
+                    if self.loop_type == AgentLoop.ANTHROPIC:
                         # Handle Anthropic format
                         if "content" in result:
                             content_text = ""

{cua_agent-0.1.1 → cua_agent-0.1.2}/agent/providers/anthropic/__init__.py

@@ -1,6 +1,6 @@
 """Anthropic provider implementation."""
 
 from .loop import AnthropicLoop
-from .types import APIProvider
+from .types import LLMProvider
 
-__all__ = ["AnthropicLoop", "APIProvider"]
+__all__ = ["AnthropicLoop", "LLMProvider"]

{cua_agent-0.1.1 → cua_agent-0.1.2}/agent/providers/anthropic/api/client.py

@@ -3,25 +3,28 @@ import httpx
 import asyncio
 from anthropic import Anthropic, AnthropicBedrock, AnthropicVertex
 from anthropic.types.beta import BetaMessage, BetaMessageParam, BetaToolUnionParam
-from ..types import APIProvider
+from ..types import LLMProvider
 from .logging import log_api_interaction
 import random
 import logging
 
 logger = logging.getLogger(__name__)
 
+
 class APIConnectionError(Exception):
     """Error raised when there are connection issues with the API."""
+
     pass
 
+
 class BaseAnthropicClient:
     """Base class for Anthropic API clients."""
-    
+
     MAX_RETRIES = 10
     INITIAL_RETRY_DELAY = 1.0
     MAX_RETRY_DELAY = 60.0
     JITTER_FACTOR = 0.1
-    
+
     async def create_message(
         self,
         *,
@@ -36,79 +39,67 @@ class BaseAnthropicClient:
 
     async def _make_api_call_with_retries(self, api_call):
         """Make an API call with exponential backoff retry logic.
-        
+
         Args:
             api_call: Async function that makes the actual API call
-            
+
         Returns:
             API response
-            
+
         Raises:
             APIConnectionError: If all retries fail
         """
         retry_count = 0
         last_error = None
-        
+
         while retry_count < self.MAX_RETRIES:
             try:
                 return await api_call()
             except Exception as e:
                 last_error = e
                 retry_count += 1
-                
+
                 if retry_count == self.MAX_RETRIES:
                     break
-                    
+
                 # Calculate delay with exponential backoff and jitter
                 delay = min(
-                    self.INITIAL_RETRY_DELAY * (2 ** (retry_count - 1)),
-                    self.MAX_RETRY_DELAY
+                    self.INITIAL_RETRY_DELAY * (2 ** (retry_count - 1)), self.MAX_RETRY_DELAY
                 )
                 # Add jitter to avoid thundering herd
                 jitter = delay * self.JITTER_FACTOR * (2 * random.random() - 1)
                 final_delay = delay + jitter
-                
+
                 logger.info(
                     f"Retrying request (attempt {retry_count}/{self.MAX_RETRIES}) "
                     f"in {final_delay:.2f} seconds after error: {str(e)}"
                 )
                 await asyncio.sleep(final_delay)
-        
+
         raise APIConnectionError(
-            f"Failed after {self.MAX_RETRIES} retries. "
-            f"Last error: {str(last_error)}"
+            f"Failed after {self.MAX_RETRIES} retries. " f"Last error: {str(last_error)}"
         )
 
+
 class AnthropicDirectClient(BaseAnthropicClient):
     """Direct Anthropic API client implementation."""
-    
+
     def __init__(self, api_key: str, model: str):
         self.model = model
-        self.client = Anthropic(
-            api_key=api_key,
-            http_client=self._create_http_client()
-        )
-    
+        self.client = Anthropic(api_key=api_key, http_client=self._create_http_client())
+
     def _create_http_client(self) -> httpx.Client:
         """Create an HTTP client with appropriate settings."""
         return httpx.Client(
             verify=True,
-            timeout=httpx.Timeout(
-                connect=30.0,
-                read=300.0,
-                write=30.0,
-                pool=30.0
-            ),
+            timeout=httpx.Timeout(connect=30.0, read=300.0, write=30.0, pool=30.0),
             transport=httpx.HTTPTransport(
                 retries=3,
                 verify=True,
-                limits=httpx.Limits(
-                    max_keepalive_connections=5,
-                    max_connections=10
-                )
-            )
+                limits=httpx.Limits(max_keepalive_connections=5, max_connections=10),
+            ),
         )
-    
+
     async def create_message(
         self,
         *,
@@ -119,6 +110,7 @@ class AnthropicDirectClient(BaseAnthropicClient):
         betas: list[str],
     ) -> BetaMessage:
         """Create a message using the direct Anthropic API with retry logic."""
+
         async def api_call():
             response = self.client.beta.messages.with_raw_response.create(
                 max_tokens=max_tokens,
@@ -130,20 +122,21 @@ class AnthropicDirectClient(BaseAnthropicClient):
             )
             log_api_interaction(response.http_response.request, response.http_response, None)
             return response.parse()
-            
+
         try:
             return await self._make_api_call_with_retries(api_call)
         except Exception as e:
             log_api_interaction(None, None, e)
             raise
 
+
 class AnthropicVertexClient(BaseAnthropicClient):
     """Google Cloud Vertex AI implementation of Anthropic client."""
-    
+
     def __init__(self, model: str):
         self.model = model
         self.client = AnthropicVertex()
-    
+
     async def create_message(
         self,
         *,
@@ -154,6 +147,7 @@ class AnthropicVertexClient(BaseAnthropicClient):
         betas: list[str],
     ) -> BetaMessage:
         """Create a message using Vertex AI with retry logic."""
+
         async def api_call():
             response = self.client.beta.messages.with_raw_response.create(
                 max_tokens=max_tokens,
@@ -165,20 +159,21 @@ class AnthropicVertexClient(BaseAnthropicClient):
             )
             log_api_interaction(response.http_response.request, response.http_response, None)
             return response.parse()
-            
+
         try:
             return await self._make_api_call_with_retries(api_call)
         except Exception as e:
             log_api_interaction(None, None, e)
             raise
 
+
 class AnthropicBedrockClient(BaseAnthropicClient):
     """AWS Bedrock implementation of Anthropic client."""
-    
+
     def __init__(self, model: str):
         self.model = model
         self.client = AnthropicBedrock()
-    
+
     async def create_message(
         self,
         *,
@@ -189,6 +184,7 @@ class AnthropicBedrockClient(BaseAnthropicClient):
         betas: list[str],
     ) -> BetaMessage:
         """Create a message using AWS Bedrock with retry logic."""
+
         async def api_call():
             response = self.client.beta.messages.with_raw_response.create(
                 max_tokens=max_tokens,
@@ -200,23 +196,24 @@ class AnthropicBedrockClient(BaseAnthropicClient):
             )
             log_api_interaction(response.http_response.request, response.http_response, None)
             return response.parse()
-            
+
         try:
             return await self._make_api_call_with_retries(api_call)
         except Exception as e:
             log_api_interaction(None, None, e)
             raise
 
+
 class AnthropicClientFactory:
     """Factory for creating appropriate Anthropic client implementations."""
-    
+
     @staticmethod
-    def create_client(provider: APIProvider, api_key: str, model: str) -> BaseAnthropicClient:
+    def create_client(provider: LLMProvider, api_key: str, model: str) -> BaseAnthropicClient:
         """Create an appropriate client based on the provider."""
-        if provider == APIProvider.ANTHROPIC:
+        if provider == LLMProvider.ANTHROPIC:
             return AnthropicDirectClient(api_key, model)
-        elif provider == APIProvider.VERTEX:
+        elif provider == LLMProvider.VERTEX:
             return AnthropicVertexClient(model)
-        elif provider == APIProvider.BEDROCK:
+        elif provider == LLMProvider.BEDROCK:
             return AnthropicBedrockClient(model)
-        raise ValueError(f"Unsupported provider: {provider}") 
+        raise ValueError(f"Unsupported provider: {provider}")

{cua_agent-0.1.1 → cua_agent-0.1.2}/agent/providers/anthropic/loop.py

@@ -32,7 +32,7 @@ from .tools.manager import ToolManager
 from .messages.manager import MessageManager
 from .callbacks.manager import CallbackManager
 from .prompts import SYSTEM_PROMPT
-from .types import APIProvider
+from .types import LLMProvider
 from .tools import ToolResult
 
 # Constants
@@ -86,7 +86,7 @@ class AnthropicLoop(BaseLoop):
         self.model = "claude-3-7-sonnet-20250219"
 
         # Anthropic-specific attributes
-        self.provider = APIProvider.ANTHROPIC
+        self.provider = LLMProvider.ANTHROPIC
         self.client = None
         self.retry_count = 0
         self.tool_manager = None

cua_agent-0.1.2/agent/providers/anthropic/types.py

@@ -0,0 +1,16 @@
+from enum import StrEnum
+
+
+class LLMProvider(StrEnum):
+    """Enum for supported API providers."""
+
+    ANTHROPIC = "anthropic"
+    BEDROCK = "bedrock"
+    VERTEX = "vertex"
+
+
+PROVIDER_TO_DEFAULT_MODEL_NAME: dict[LLMProvider, str] = {
+    LLMProvider.ANTHROPIC: "claude-3-7-sonnet-20250219",
+    LLMProvider.BEDROCK: "anthropic.claude-3-7-sonnet-20250219-v2:0",
+    LLMProvider.VERTEX: "claude-3-5-sonnet-v2@20241022",
+}

{cua_agent-0.1.1 → cua_agent-0.1.2}/agent/providers/omni/__init__.py

@@ -2,7 +2,7 @@
 
 # The OmniComputerAgent has been replaced by the unified ComputerAgent
 # which can be found in agent.core.agent
-from .types import APIProvider
+from .types import LLMProvider
 from .experiment import ExperimentManager
 from .visualization import visualize_click, visualize_scroll, calculate_element_center
 from .image_utils import (
@@ -14,7 +14,7 @@ from .image_utils import (
 )
 
 __all__ = [
-    "APIProvider",
+    "LLMProvider",
     "ExperimentManager",
     "visualize_click",
     "visualize_scroll",

{cua_agent-0.1.1 → cua_agent-0.1.2}/agent/providers/omni/loop.py

@@ -17,7 +17,7 @@ import copy
 from .parser import OmniParser, ParseResult, ParserMetadata, UIElement
 from ...core.loop import BaseLoop
 from computer import Computer
-from .types import APIProvider
+from .types import LLMProvider
 from .clients.base import BaseOmniClient
 from .clients.openai import OpenAIClient
 from .clients.groq import GroqClient
@@ -46,7 +46,7 @@ class OmniLoop(BaseLoop):
     def __init__(
         self,
         parser: OmniParser,
-        provider: APIProvider,
+        provider: LLMProvider,
         api_key: str,
         model: str,
         computer: Computer,
@@ -180,11 +180,11 @@ class OmniLoop(BaseLoop):
         try:
             logger.info(f"Initializing {self.provider} client with model {self.model}...")
 
-            if self.provider == APIProvider.OPENAI:
+            if self.provider == LLMProvider.OPENAI:
                 self.client = OpenAIClient(api_key=self.api_key, model=self.model)
-            elif self.provider == APIProvider.GROQ:
+            elif self.provider == LLMProvider.GROQ:
                 self.client = GroqClient(api_key=self.api_key, model=self.model)
-            elif self.provider == APIProvider.ANTHROPIC:
+            elif self.provider == LLMProvider.ANTHROPIC:
                 self.client = AnthropicClient(
                     api_key=self.api_key,
                     model=self.model,
@@ -228,7 +228,7 @@ class OmniLoop(BaseLoop):
                 prepared_messages = self.message_manager.get_formatted_messages(provider_name)
 
                 # Filter out system messages for Anthropic
-                if self.provider == APIProvider.ANTHROPIC:
+                if self.provider == LLMProvider.ANTHROPIC:
                     filtered_messages = [
                         msg for msg in prepared_messages if msg["role"] != "system"
                     ]
@@ -238,7 +238,7 @@ class OmniLoop(BaseLoop):
                 # Log request
                 request_data = {"messages": filtered_messages, "max_tokens": self.max_tokens}
 
-                if self.provider == APIProvider.ANTHROPIC:
+                if self.provider == LLMProvider.ANTHROPIC:
                     request_data["system"] = self._get_system_prompt()
                 else:
                     request_data["system"] = system_prompt
@@ -255,7 +255,7 @@ class OmniLoop(BaseLoop):
 
                 if is_async:
                     # For async implementations (AnthropicClient)
-                    if self.provider == APIProvider.ANTHROPIC:
+                    if self.provider == LLMProvider.ANTHROPIC:
                         response = await run_method(
                             messages=filtered_messages,
                             system=self._get_system_prompt(),
@@ -269,7 +269,7 @@ class OmniLoop(BaseLoop):
                         )
                 else:
                     # For non-async implementations (GroqClient, etc.)
-                    if self.provider == APIProvider.ANTHROPIC:
+                    if self.provider == LLMProvider.ANTHROPIC:
                         response = run_method(
                             messages=filtered_messages,
                             system=self._get_system_prompt(),
@@ -339,7 +339,7 @@ class OmniLoop(BaseLoop):
         action_screenshot_saved = False
         try:
             # Handle Anthropic response format
-            if self.provider == APIProvider.ANTHROPIC:
+            if self.provider == LLMProvider.ANTHROPIC:
                 if hasattr(response, "content") and isinstance(response.content, list):
                     # Extract text from content blocks
                     for block in response.content:
@@ -563,7 +563,7 @@ class OmniLoop(BaseLoop):
         """Process and add screen info to messages."""
         try:
             # Only add message if we have an image and provider supports it
-            if self.provider in [APIProvider.OPENAI, APIProvider.ANTHROPIC]:
+            if self.provider in [LLMProvider.OPENAI, LLMProvider.ANTHROPIC]:
                 image = parsed_screen.annotated_image_base64 or None
                 if image:
                     # Save screen info to current turn directory
@@ -577,7 +577,7 @@ class OmniLoop(BaseLoop):
                             logger.info(f"Saved elements to {elements_path}")
 
                     # Format the image content based on the provider
-                    if self.provider == APIProvider.ANTHROPIC:
+                    if self.provider == LLMProvider.ANTHROPIC:
                         # Compress the image before sending to Anthropic (5MB limit)
                         image_size = len(image)
                         logger.info(f"Image base64 is present, length: {image_size}")

{cua_agent-0.1.1 → cua_agent-0.1.2}/agent/providers/omni/prompts.py

@@ -62,17 +62,3 @@ IMPORTANT NOTES:
 9. Reflect whether the element is clickable or not, for example reflect if it is an hyperlink or a button or a normal text.
 10. If you are prompted with login information page or captcha page, or you think it need user's permission to do the next action, you should say "Action": "None" in the json field.
 """
-
-# SYSTEM_PROMPT1 = """You are an AI assistant helping users interact with their computer.
-# Analyze the screen information and respond with JSON containing:
-# {
-#     "Box ID": "Numeric ID of the relevant UI element",
-#     "Action": "One of: left_click, right_click, double_click, move_cursor, drag_to, type_text, press_key, hotkey, scroll_down, scroll_up, wait",
-#     "Value": "Text to type, key to press",
-#     "Explanation": "Why this action was chosen"
-# }
-
-# Notes:
-# - For starting applications, use the "hotkey" action with command+space for starting a Spotlight search.
-# - Each UI element is highlighted with a colored bounding box, and its Box ID appears nearby in the same color for easy identification.
-# """

{cua_agent-0.1.1 → cua_agent-0.1.2}/agent/providers/omni/types.py

@@ -14,17 +14,16 @@ class LLMProvider(StrEnum):
     QWEN = "qwen"
 
 
-# For backward compatibility
-APIProvider = LLMProvider
+LLMProvider
 
 
 @dataclass
 class LLM:
     """Configuration for LLM model and provider."""
-    
+
     provider: LLMProvider
     name: Optional[str] = None
-    
+
     def __post_init__(self):
         """Set default model name if not provided."""
         if self.name is None:

{cua_agent-0.1.1 → cua_agent-0.1.2}/agent/types/base.py

@@ -44,9 +44,10 @@ class Annotation(BaseModel):
     vm_url: str
 
 
-class AgenticLoop(Enum):
+class AgentLoop(Enum):
     """Enumeration of available loop types."""
 
     ANTHROPIC = auto()  # Anthropic implementation
+    OPENAI = auto()  # OpenAI implementation
     OMNI = auto()  # OmniLoop implementation
     # Add more loop types as needed

{cua_agent-0.1.1 → cua_agent-0.1.2}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "pdm.backend"
 
 [project]
 name = "cua-agent"
-version = "0.1.1"
+version = "0.1.2"
 description = "CUA (Computer Use) Agent for AI-driven computer interaction"
 authors = [
     { name = "TryCua", email = "gh@trycua.com" },
@@ -78,7 +78,7 @@ target-version = [
 
 [tool.ruff]
 line-length = 100
-target-version = "0.1.1"
+target-version = "0.1.2"
 select = [
     "E",
     "F",
@@ -92,7 +92,7 @@ docstring-code-format = true
 
 [tool.mypy]
 strict = true
-python_version = "0.1.1"
+python_version = "0.1.2"
 ignore_missing_imports = true
 disallow_untyped_defs = true
 check_untyped_defs = true

{cua_agent-0.1.1 → cua_agent-0.1.2}/tests/test_agent.py

@@ -1,19 +1,19 @@
 # """Basic tests for the agent package."""
 
 # import pytest
-# from agent import OmniComputerAgent, APIProvider
+# from agent import OmniComputerAgent, LLMProvider
 # from agent.base.agent import BaseComputerAgent
 # from computer import Computer
 
 # def test_agent_import():
 #     """Test that we can import the OmniComputerAgent class."""
 #     assert OmniComputerAgent is not None
-#     assert APIProvider is not None
+#     assert LLMProvider is not None
 
 # def test_agent_init():
 #     """Test that we can create an OmniComputerAgent instance."""
 #     agent = OmniComputerAgent(
-#         provider=APIProvider.OPENAI,
+#         provider=LLMProvider.OPENAI,
 #         use_host_computer_server=True
 #     )
 #     assert agent is not None

cua_agent-0.1.1/agent/__init__.py

@@ -1,10 +0,0 @@
-"""CUA (Computer Use) Agent for AI-driven computer interaction."""
-
-__version__ = "0.1.0"
-
-from .core.factory import AgentFactory
-from .core.agent import ComputerAgent
-from .types.base import Provider, AgenticLoop
-from .providers.omni.types import LLMProvider, LLM, Model, LLMModel, APIProvider
-
-__all__ = ["AgentFactory", "Provider", "ComputerAgent", "AgenticLoop", "LLMProvider", "LLM", "Model", "LLMModel", "APIProvider"]

cua_agent-0.1.1/agent/providers/anthropic/types.py

@@ -1,16 +0,0 @@
-from enum import StrEnum
-
-
-class APIProvider(StrEnum):
-    """Enum for supported API providers."""
-
-    ANTHROPIC = "anthropic"
-    BEDROCK = "bedrock"
-    VERTEX = "vertex"
-
-
-PROVIDER_TO_DEFAULT_MODEL_NAME: dict[APIProvider, str] = {
-    APIProvider.ANTHROPIC: "claude-3-7-sonnet-20250219",
-    APIProvider.BEDROCK: "anthropic.claude-3-7-sonnet-20250219-v2:0",
-    APIProvider.VERTEX: "claude-3-5-sonnet-v2@20241022",
-}