cua-agent 0.1.33__py3-none-any.whl → 0.1.35__py3-none-any.whl

agent/ui/gradio/app.py

@@ -412,25 +412,23 @@ def create_gradio_ui(
     openai_api_key = os.environ.get("OPENAI_API_KEY", "")
     anthropic_api_key = os.environ.get("ANTHROPIC_API_KEY", "")
 
-    # Prepare model choices based on available API keys
-    openai_models = []
-    anthropic_models = []
-    omni_models = []
-
-    if openai_api_key:
-        openai_models = ["OpenAI: Computer-Use Preview"]
-        omni_models += [
-            "OMNI: OpenAI GPT-4o",
-            "OMNI: OpenAI GPT-4o mini",
-            "OMNI: OpenAI GPT-4.5-preview",
-        ]
-
-    if anthropic_api_key:
-        anthropic_models = [
-            "Anthropic: Claude 3.7 Sonnet (20250219)",
-            "Anthropic: Claude 3.5 Sonnet (20240620)",
-        ]
-        omni_models += ["OMNI: Claude 3.7 Sonnet (20250219)", "OMNI: Claude 3.5 Sonnet (20240620)"]
+    # Always show models regardless of API key availability
+    openai_models = ["OpenAI: Computer-Use Preview"]
+    anthropic_models = [
+        "Anthropic: Claude 3.7 Sonnet (20250219)",
+        "Anthropic: Claude 3.5 Sonnet (20240620)",
+    ]
+    omni_models = [
+        "OMNI: OpenAI GPT-4o",
+        "OMNI: OpenAI GPT-4o mini",
+        "OMNI: OpenAI GPT-4.5-preview",
+        "OMNI: Claude 3.7 Sonnet (20250219)", 
+        "OMNI: Claude 3.5 Sonnet (20240620)"
+    ]
+    
+    # Check if API keys are available
+    has_openai_key = bool(openai_api_key)
+    has_anthropic_key = bool(anthropic_api_key)
 
     # Get Ollama models for OMNI
     ollama_models = get_ollama_models()
@@ -480,6 +478,83 @@ def create_gradio_ui(
         "Open Safari, search for 'macOS automation tools', and save the first three results as bookmarks",
         "Configure SSH keys and set up a connection to a remote server",
     ]
+    
+    # Function to generate Python code based on configuration and tasks
+    def generate_python_code(agent_loop_choice, provider, model_name, tasks, provider_url, recent_images=3, save_trajectory=True):
+        """Generate Python code for the current configuration and tasks.
+        
+        Args:
+            agent_loop_choice: The agent loop type (e.g., UITARS, OPENAI, ANTHROPIC, OMNI)
+            provider: The provider type (e.g., OPENAI, ANTHROPIC, OLLAMA, OAICOMPAT)
+            model_name: The model name
+            tasks: List of tasks to execute
+            provider_url: The provider base URL for OAICOMPAT providers
+            recent_images: Number of recent images to keep in context
+            save_trajectory: Whether to save the agent trajectory
+            
+        Returns:
+            Formatted Python code as a string
+        """
+        # Format the tasks as a Python list
+        tasks_str = ""
+        for task in tasks:
+            if task and task.strip():
+                tasks_str += f'            "{task}",\n'
+        
+        # Create the Python code template
+        code = f'''import asyncio
+from computer import Computer
+from agent import ComputerAgent, LLM, AgentLoop, LLMProvider
+
+async def main():
+    async with Computer() as macos_computer:
+        agent = ComputerAgent(
+            computer=macos_computer,
+            loop=AgentLoop.{agent_loop_choice},
+            only_n_most_recent_images={recent_images},
+            save_trajectory={save_trajectory},'''
+        
+        # Add the model configuration based on provider
+        if provider == LLMProvider.OAICOMPAT:
+            code += f'''
+            model=LLM(
+                provider=LLMProvider.OAICOMPAT, 
+                name="{model_name}",
+                provider_base_url="{provider_url}"
+            )'''
+            
+        code += """
+        )
+        """
+        
+        # Add tasks section if there are tasks
+        if tasks_str:
+            code += f'''
+        # Prompts for the computer-use agent
+        tasks = [
+{tasks_str.rstrip()}
+        ]
+
+        for task in tasks:
+            print(f"Executing task: {{task}}")
+            async for result in agent.run(task):
+                print(result)'''
+        else:
+            # If no tasks, just add a placeholder for a single task
+            code += f'''
+        # Execute a single task
+        task = "Search for information about CUA on GitHub"
+        print(f"Executing task: {{task}}")
+        async for result in agent.run(task):
+            print(result)'''
+        
+        # Add the main block
+        code += '''
+
+if __name__ == "__main__":
+    asyncio.run(main())'''
+        
+        return code
 
     # Function to update model choices based on agent loop selection
     def update_model_choices(loop):
@@ -491,16 +566,51 @@ def create_gradio_ui(
             elif "Custom model..." not in models:
                 models.append("Custom model...")
 
-            return gr.update(
-                choices=models, value=models[0] if models else "Custom model...", interactive=True
-            )
+            # Show both OpenAI and Anthropic key inputs for OMNI if keys aren't set
+            return [
+                gr.update(choices=models, value=models[0] if models else "Custom model...", interactive=True),
+                gr.update(visible=not has_openai_key),
+                gr.update(visible=not has_anthropic_key)
+            ]
+        elif loop == "OPENAI":
+            # Show only OpenAI key input for OPENAI loop if key isn't set
+            if not models:
+                return [
+                    gr.update(choices=["No models available"], value="No models available", interactive=True),
+                    gr.update(visible=not has_openai_key),
+                    gr.update(visible=False)
+                ]
+            return [
+                gr.update(choices=models, value=models[0] if models else None, interactive=True),
+                gr.update(visible=not has_openai_key),
+                gr.update(visible=False)
+            ]
+        elif loop == "ANTHROPIC":
+            # Show only Anthropic key input for ANTHROPIC loop if key isn't set
+            if not models:
+                return [
+                    gr.update(choices=["No models available"], value="No models available", interactive=True),
+                    gr.update(visible=False),
+                    gr.update(visible=not has_anthropic_key)
+                ]
+            return [
+                gr.update(choices=models, value=models[0] if models else None, interactive=True),
+                gr.update(visible=False),
+                gr.update(visible=not has_anthropic_key)
+            ]
         else:
-            # For other providers, use standard dropdown without custom option
+            # For other providers (like UITARS), don't show API key inputs
             if not models:
-                return gr.update(
-                    choices=["No models available"], value="No models available", interactive=True
-                )
-            return gr.update(choices=models, value=models[0] if models else None, interactive=True)
+                return [
+                    gr.update(choices=["No models available"], value="No models available", interactive=True),
+                    gr.update(visible=False),
+                    gr.update(visible=False)
+                ]
+            return [
+                gr.update(choices=models, value=models[0] if models else None, interactive=True),
+                gr.update(visible=False),
+                gr.update(visible=False)
+            ]
 
     # Create the Gradio interface with advanced UI
     with gr.Blocks(title="Computer-Use Agent") as demo:
@@ -537,50 +647,20 @@ def create_gradio_ui(
                     """
                 )
 
-                # Add installation prerequisites as a collapsible section
-                with gr.Accordion("Prerequisites & Installation", open=False):
-                    gr.Markdown(
-                        """
-                    ## Prerequisites
-                    
-                    Before using the Computer-Use Agent, you need to set up the Lume daemon and pull the macOS VM image.
-                    
-                    ### 1. Install Lume daemon
-                    
-                    While a lume binary is included with Computer, we recommend installing the standalone version with brew, and starting the lume daemon service:
-                    
-                    ```bash
-                    sudo /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/trycua/cua/main/libs/lume/scripts/install.sh)"
-                    ```
-                    
-                    ### 2. Start the Lume daemon service
-                    
-                    In a separate terminal:
-                    
-                    ```bash
-                    lume serve
-                    ```
-                    
-                    ### 3. Pull the pre-built macOS image
-                    
-                    ```bash
-                    lume pull macos-sequoia-cua:latest
-                    ```
-                    
-                    Initial download requires 80GB storage, but reduces to ~30GB after first run due to macOS's sparse file system.
-                    
-                    VMs are stored in `~/.lume`, and locally cached images are stored in `~/.lume/cache`.
-                    
-                    ### 4. Test the sandbox
-                    
-                    ```bash
-                    lume run macos-sequoia-cua:latest
-                    ```
-                    
-                    For more detailed instructions, visit the [CUA GitHub repository](https://github.com/trycua/cua).
-                    """
+                # Add accordion for Python code
+                with gr.Accordion("Python Code", open=False):
+                    code_display = gr.Code(
+                        language="python",
+                        value=generate_python_code(
+                            initial_loop, 
+                            LLMProvider.OPENAI, 
+                            "gpt-4o", 
+                            [],
+                            "https://openrouter.ai/api/v1"
+                        ),
+                        interactive=False,
                     )
-
+                    
                 with gr.Accordion("Configuration", open=True):
                     # Configuration options
                     agent_loop = gr.Dropdown(
@@ -599,6 +679,27 @@ def create_gradio_ui(
                         interactive=True,
                     )
 
+                    # Add API key inputs for OpenAI and Anthropic
+                    with gr.Group(visible=not has_openai_key and (initial_loop == "OPENAI" or initial_loop == "OMNI")) as openai_key_group:
+                        openai_api_key_input = gr.Textbox(
+                            label="OpenAI API Key",
+                            placeholder="Enter your OpenAI API key",
+                            value="",
+                            interactive=True,
+                            type="password",
+                            info="Required for OpenAI models"
+                        )
+                    
+                    with gr.Group(visible=not has_anthropic_key and (initial_loop == "ANTHROPIC" or initial_loop == "OMNI")) as anthropic_key_group:
+                        anthropic_api_key_input = gr.Textbox(
+                            label="Anthropic API Key",
+                            placeholder="Enter your Anthropic API key",
+                            value="",
+                            interactive=True,
+                            type="password",
+                            info="Required for Anthropic models"
+                        )
+
                     # Add custom model textbox (only visible when "Custom model..." is selected)
                     custom_model = gr.Textbox(
                         label="Custom Model Name",
@@ -643,6 +744,7 @@ def create_gradio_ui(
                         info="Number of recent images to keep in context",
                         interactive=True,
                     )
+                    
 
             # Right column for chat interface
             with gr.Column(scale=2):
@@ -676,6 +778,8 @@ def create_gradio_ui(
                     recent_imgs,
                     custom_url_value=None,
                     custom_api_key=None,
+                    openai_key_input=None,
+                    anthropic_key_input=None,
                 ):
                     if not history:
                         yield history
@@ -721,9 +825,15 @@ def create_gradio_ui(
                                 f"DEBUG - Using custom API key for model: {final_model_name_to_send}"
                             )
                         elif provider == LLMProvider.OPENAI:
-                            api_key = openai_api_key or os.environ.get("OPENAI_API_KEY", "")
+                            # Use OpenAI key from input if provided, otherwise use environment variable
+                            api_key = openai_key_input if openai_key_input else (openai_api_key or os.environ.get("OPENAI_API_KEY", ""))
+                            if openai_key_input:
+                                print(f"DEBUG - Using provided OpenAI API key from UI")
                         elif provider == LLMProvider.ANTHROPIC:
-                            api_key = anthropic_api_key or os.environ.get("ANTHROPIC_API_KEY", "")
+                            # Use Anthropic key from input if provided, otherwise use environment variable
+                            api_key = anthropic_key_input if anthropic_key_input else (anthropic_api_key or os.environ.get("ANTHROPIC_API_KEY", ""))
+                            if anthropic_key_input:
+                                print(f"DEBUG - Using provided Anthropic API key from UI")
                         else:
                             # For Ollama or default OAICOMPAT (without custom key), no key needed/expected
                             api_key = ""
@@ -869,6 +979,8 @@ def create_gradio_ui(
                         recent_images,
                         provider_base_url,
                         provider_api_key,
+                        openai_api_key_input,
+                        anthropic_api_key_input,
                     ],
                     [chatbot_history],
                 )
@@ -899,6 +1011,70 @@ def create_gradio_ui(
                     outputs=[custom_model, provider_base_url, provider_api_key],
                     queue=False,  # Process immediately without queueing
                 )
+                
+                # Connect agent_loop changes to model selection and API key visibility
+                agent_loop.change(
+                    fn=update_model_choices,
+                    inputs=[agent_loop],
+                    outputs=[model_choice, openai_key_group, anthropic_key_group],
+                    queue=False,  # Process immediately without queueing
+                )
+
+                # Function to update the code display based on configuration and chat history
+                def update_code_display(agent_loop, model_choice_val, custom_model_val, chat_history, provider_base_url, recent_images_val, save_trajectory_val):
+                    # Extract messages from chat history
+                    messages = []
+                    if chat_history:
+                        for msg in chat_history:
+                            if msg.get("role") == "user":
+                                messages.append(msg.get("content", ""))
+                    
+                    # Determine provider and model name based on selection
+                    model_string = custom_model_val if model_choice_val == "Custom model..." else model_choice_val
+                    provider, model_name, _ = get_provider_and_model(model_string, agent_loop)
+                    
+                    # Generate and return the code
+                    return generate_python_code(
+                        agent_loop, 
+                        provider, 
+                        model_name, 
+                        messages, 
+                        provider_base_url,
+                        recent_images_val,
+                        save_trajectory_val
+                    )
+                
+                # Update code display when configuration changes
+                agent_loop.change(
+                    update_code_display,
+                    inputs=[agent_loop, model_choice, custom_model, chatbot_history, provider_base_url, recent_images, save_trajectory],
+                    outputs=[code_display]
+                )
+                model_choice.change(
+                    update_code_display,
+                    inputs=[agent_loop, model_choice, custom_model, chatbot_history, provider_base_url, recent_images, save_trajectory],
+                    outputs=[code_display]
+                )
+                custom_model.change(
+                    update_code_display,
+                    inputs=[agent_loop, model_choice, custom_model, chatbot_history, provider_base_url, recent_images, save_trajectory],
+                    outputs=[code_display]
+                )
+                chatbot_history.change(
+                    update_code_display,
+                    inputs=[agent_loop, model_choice, custom_model, chatbot_history, provider_base_url, recent_images, save_trajectory],
+                    outputs=[code_display]
+                )
+                recent_images.change(
+                    update_code_display,
+                    inputs=[agent_loop, model_choice, custom_model, chatbot_history, provider_base_url, recent_images, save_trajectory],
+                    outputs=[code_display]
+                )
+                save_trajectory.change(
+                    update_code_display,
+                    inputs=[agent_loop, model_choice, custom_model, chatbot_history, provider_base_url, recent_images, save_trajectory],
+                    outputs=[code_display]
+                )
 
     return demo
 

{cua_agent-0.1.33.dist-info → cua_agent-0.1.35.dist-info}/METADATA

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

{cua_agent-0.1.33.dist-info → cua_agent-0.1.35.dist-info}/RECORD

@@ -78,8 +78,8 @@ agent/providers/uitars/utils.py,sha256=S6FiZ3P-O4B15P1Gdup2o7SyuIu4nSQbspxcektpw
 agent/telemetry.py,sha256=pVGxbj0ewnvq4EGj28CydN4a1iOfvZR_XKL3vIOqhOM,390
 agent/ui/__init__.py,sha256=ohhxJLBin6k1hl5sKcmBST8mgh23WXgAXz3pN4f470E,45
 agent/ui/gradio/__init__.py,sha256=ANKZhv1HqsLheWbLVBlyRQ7Q5qGeXuPi5jDs8vu-ZMo,579
-agent/ui/gradio/app.py,sha256=C38XbAAqBIsIfSh-3eF_IqHBEguRSfaMycNX8jRXTjE,41060
-cua_agent-0.1.33.dist-info/METADATA,sha256=qJJM-IExLcghj3mc18IX_zaMI7aAI9L4hWO0wHGPtQU,11335
-cua_agent-0.1.33.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
-cua_agent-0.1.33.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-cua_agent-0.1.33.dist-info/RECORD,,
+agent/ui/gradio/app.py,sha256=q_nS6JJLlu1Y9xu56YHR26l_ypgaK3zR3v6BfpZT4qc,49396
+cua_agent-0.1.35.dist-info/METADATA,sha256=C7b0g8sHR6-3eWEJFQwuelXf6MKPeD8_Z8Z5aPwoikQ,11335
+cua_agent-0.1.35.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
+cua_agent-0.1.35.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+cua_agent-0.1.35.dist-info/RECORD,,