Deploy Space

README.md

@@ -2,12 +2,12 @@
 title: AI-Agentic-Coder
 app_file: src/ai_agentic_coder/main.py
 sdk: gradio
-sdk_version: 5.44.1
+sdk_version: 6.14.0
 ---
 
 # AI Agentic Coder
 
-[![Live Demo – Hugging Face Space](https://img.shields.io/badge/Live%20Demo-Hugging%20Face%20Space-yellow?logo=huggingface&logoColor=white)](https://huggingface.co/spaces/kaushikpaul/AI-Agentic-Coder)
+[![Live Website](https://img.shields.io/badge/Live_Website-6c63ff?logo=rocket&logoColor=white&labelColor=5a52d3)](https://projects.kaushikpaul.co.in/ai-agentic-coder)
 
 An AI-powered agentic coding assistant that:
 - Turns your natural language requirements into a working Python module
@@ -17,7 +17,7 @@ An AI-powered agentic coding assistant that:
 Backed by a multi-agent CrewAI pipeline, the app coordinates “engineering lead”, “backend”, “frontend”, “QA”, and a “runner” agent to deliver end-to-end results.
 
 ## Live Demo
-- Visit the hosted Space: https://huggingface.co/spaces/kaushikpaul/AI-Agentic-Coder
+- Visit the hosted Space: https://projects.kaushikpaul.co.in/ai-agentic-coder
 
 ## Features
 - **Idea → Running App in Minutes**
@@ -27,7 +27,7 @@ Backed by a multi-agent CrewAI pipeline, the app coordinates “engineering lead
 - **Production‑Friendly Reliability**
   - Built‑in retry limits and execution timeouts for coding/testing agents, plus automatic cleanup of previous app processes to avoid port conflicts.
 - **Model‑Flexible by Design**
-  - Swap LLMs per‑agent via `config/agents.yaml` using OpenRouter model IDs. Compatible with OpenAI‑style endpoints and easy to tune per role.
+  - Switch between OpenRouter and OpenCode Go from `.env`. Models are configured with environment variables instead of hardcoded YAML values.
 - **Modern Developer UX**
   - Polished Gradio UI with non‑blocking background execution, streaming progress, one‑click example loader, and strict URL extraction/validation on completion.
 - **Secure Artifact Delivery**
@@ -103,11 +103,22 @@ pip install -r requirements.txt
 Create a `.env` file in the project root with the following variables (adjust as needed):
 
 ```ini
-# ——— LLM provider (using OpenRouter-hosted models in agents.yaml) ———
-OPENROUTER_API_KEY=your_openrouter_key
-# Optional but commonly needed when using OpenRouter via OpenAI-compatible clients:
-# OPENAI_API_BASE=https://openrouter.ai/api/v1
-# OPENAI_API_KEY=${OPENROUTER_API_KEY}
+# ——— LLM provider ———
+# Defaults to OpenCode Go when USE_OPENROUTER is false or omitted.
+USE_OPENROUTER=false
+OPENCODE_GO_API_KEY=your_opencode_go_key
+OPENCODE_GO_MODEL=minimax-m2.7
+# Optional: auto, openai, or anthropic. auto reads OpenCode Go model metadata and falls back safely.
+OPENCODE_GO_API_STYLE=auto
+
+# To use OpenRouter instead:
+# USE_OPENROUTER=true
+# OPENROUTER_API_KEY=your_openrouter_key
+# OPENROUTER_MODEL=moonshotai/kimi-k2:free
+
+# Optional shared tuning:
+LLM_TEMPERATURE=0.2
+LLM_TIMEOUT=300
 
 # ——— Google Cloud Storage (used by PythonCodeRunTool) ———
 GCP_PROJECT_ID=your_gcp_project_id
@@ -140,9 +151,9 @@ Key features used in this project:
 ## Configuration
 
 ### LLMs and Agents
-- File: `src/ai_agentic_coder/config/agents.yaml`
-- Default agents use OpenRouter-hosted models (e.g., `openrouter/meta-llama/llama-3.1-405b-instruct:free`, `openrouter/moonshotai/kimi-k2:free`).
-- To change models or providers, update the `llm` field for each agent. Ensure appropriate API keys and base configuration are set for your provider.
+- File: `src/ai_agentic_coder/model_client.py`
+- Provider selection is driven by `.env`: `USE_OPENROUTER=true` uses `OPENROUTER_MODEL`; otherwise the app uses OpenCode Go with `OPENCODE_GO_MODEL`.
+- OpenCode Go defaults to `minimax-m2.7`. The app checks OpenCode Go model metadata to choose the correct API style, so Anthropic-style models use `/messages` and OpenAI-compatible models use `/chat/completions`. You can override detection with `OPENCODE_GO_API_STYLE=openai` or `OPENCODE_GO_API_STYLE=anthropic`.
 
 ### Tasks & Outputs
 - File: `src/ai_agentic_coder/config/tasks.yaml`
@@ -152,6 +163,7 @@ Key features used in this project:
 - File: `src/ai_agentic_coder/gradio_ui.py`
 - You provide: `Requirements`, `Module Name` (without .py), `Class Name`.
 - The app displays a progress bar during execution and, on success, two URLs: a signed download URL and a live app URL.
+- Generated demos are served through the main Gradio app at `/generated-app/`, which works on Hugging Face Spaces without relying on Gradio tunnel/share URLs.
 
 ### Execution Mode (Docker vs non‑Docker)
 - Files: `src/ai_agentic_coder/crew.py`
@@ -176,8 +188,8 @@ This removes the need to have Docker running locally.
 3. Enter a module name (e.g., `accounts`) and class name (e.g., `Account`).
 4. Click “Run AI Coder”.
 5. Wait a few minutes while the pipeline runs. When done, you’ll see:
-   - A signed Google Cloud Storage URL to download the generated artifacts as a zip
-   - A public/live URL of the generated Gradio demo app
+   - A 30-minute signed Google Cloud Storage URL to download the generated artifacts as a zip
+   - A live URL of the generated Gradio demo app, proxied through the main app
 
 ## Outputs
 Generated files are saved under `src/ai_agentic_coder/output/`:
@@ -185,30 +197,37 @@ Generated files are saved under `src/ai_agentic_coder/output/`:
 - `{module_name}.py` — The generated backend module
 - `app.py` — A minimal Gradio UI demonstrating the backend (launched with share=True)
 - `test_{module_name}` — Unit test module for the backend
-- `gradio_public_url.txt` — A convenience file containing the live URL output
+- `gradio_public_url.txt` — CrewAI task output containing the returned URLs
+- `latest_run_result.json` — Exact tool result used by the UI, so signed URL query parameters are preserved
 
 ## Deployment
-- The project is already hosted on Hugging Face Spaces: https://huggingface.co/spaces/kaushikpaul/AI-Agentic-Coder
-- To deploy your own Space:
+- The project is already hosted on Hugging Face Spaces: https://projects.kaushikpaul.co.in/ai-agentic-coder
+- To deploy with the helper script:
+  - Set `HF_TOKEN` with write access to the Space.
+  - Optionally set `HF_SPACE_ID`; it defaults to `kaushikpaul/AI-Agentic-Coder`.
+  - Run `uv run python scripts/deploy_space.py`.
+- To deploy your own Space manually:
   - Set Space SDK to “Gradio” and point to `src/ai_agentic_coder/main.py` as the entry file.
   - Add required secrets in the Space settings:
-    - `OPENROUTER_API_KEY`
+    - `USE_OPENROUTER`
+    - `OPENCODE_GO_API_KEY`, `OPENCODE_GO_MODEL` or `OPENROUTER_API_KEY`, `OPENROUTER_MODEL`
     - `GCP_PROJECT_ID`, `GCP_BUCKET_NAME`, `GCP_SERVICE_KEY` (base64-encoded service account JSON)
   - Ensure the Python version matches (3.10–3.12) and install via `requirements.txt` or `pyproject.toml`.
 
 ## Troubleshooting
 - **Missing or invalid API keys/credentials**
-  - Verify `.env` values. Ensure OpenRouter key and GCP service key are valid; confirm bucket exists and is accessible.
+  - Verify `.env` values. Ensure the selected LLM provider key and GCP service key are valid; confirm bucket exists and is accessible.
 - **GCS upload errors**
-  - Confirm `GCP_SERVICE_KEY` contains a valid base64-encoded service account JSON with `storage.objects.create` permission.
+  - Confirm `GCP_SERVICE_KEY` contains a valid base64-encoded service account JSON with `storage.objects.create` and signing capability. The service account should also be able to access the target bucket.
 - **Live URL not detected**
-  - The runner waits up to 60 seconds to capture a public URL. If the generated UI didn’t enable `share=True` or the network blocks tunnels, you may see: “Gradio started but no accessible URL was detected within 60 seconds.” Re-run or check network settings.
+  - The generated preview is available at `/generated-app/` for `AI_AGENTIC_CODER_PREVIEW_TTL_MINUTES` minutes, defaulting to 30. A new run stops the previous preview and reuses the same route.
+  - If your app is behind a custom domain or proxy, set `AI_AGENTIC_CODER_BASE_URL` so returned preview links use the exact public origin.
 - **Virtualenv issues on Windows**
   - Use `.venv\Scripts\activate` and ensure `python` points to the venv interpreter.
 
 ## Tech Stack
 - **Python**: 3.10–3.12
-- **Frameworks/Libraries**: CrewAI, Gradio 5, google-cloud-storage, python-dotenv, requests, httpx
+- **Frameworks/Libraries**: CrewAI, Gradio 6, google-cloud-storage, python-dotenv, requests, httpx
 - **Orchestration**: YAML-configured agents and tasks via CrewAI
 - **UI**: Gradio Blocks with live progress and URL surfacing
 

pyproject.toml

@@ -5,15 +5,16 @@ description = "ai_agentic_coder using crewAI"
 authors = [{ name = "Kaushik Paul", email = "kaushik.paul755@gmail.com" }]
 requires-python = ">=3.10,<3.13"
 dependencies = [
-    "crewai[tools]>=0.108.0,<1.0.0",
+    "crewai[tools]>=1.14.4",
     "mailjet-rest>=1.5.1",
     "autogen-agentchat>=0.4.9.2",
     "autogen-ext[grpc,mcp,ollama,openai]>=0.4.9.2",
     "bs4>=0.0.2",
-    "gradio>=5.22.0",
+    "gradio>=6.14.0",
     "httpx>=0.28.1",
     "ipywidgets>=8.1.5",
     "langsmith>=0.3.18",
+    "litellm>=1.74.9",
     "lxml>=5.3.1",
     "mcp-server-fetch>=2025.1.17",
     "mcp[cli]>=1.5.0",
@@ -30,6 +31,7 @@ dependencies = [
     "setuptools>=78.1.0",
     "smithery>=0.1.0",
     "google-cloud-storage>=3.3.1",
+    "huggingface-hub>=1.15.0",
 ]
 
 [project.scripts]

requirements.txt

@@ -1,12 +1,13 @@
-crewai[tools]>=0.108.0,<1.0.0
+crewai[tools]>=1.14.4
 mailjet-rest>=1.5.1
 autogen-agentchat>=0.4.9.2
 autogen-ext[grpc,mcp,ollama,openai]>=0.4.9.2
 bs4>=0.0.2
-gradio>=5.22.0
+gradio>=6.14.0
 httpx>=0.28.1
 ipywidgets>=8.1.5
 langsmith>=0.3.18
+litellm>=1.74.9
 lxml>=5.3.1
 mcp-server-fetch>=2025.1.17
 mcp[cli]>=1.5.0
@@ -22,4 +23,5 @@ semantic-kernel>=1.25.0
 sendgrid>=6.11.0
 setuptools>=78.1.0
 smithery>=0.1.0
-google-cloud-storage>=3.3.1
+google-cloud-storage>=3.3.1
+huggingface-hub>=1.15.0

src/ai_agentic_coder/.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

src/ai_agentic_coder/config/agents.yaml

@@ -9,7 +9,6 @@ engineering_lead:
     The module should be named {module_name} and the class should be named {class_name}
   backstory: >
     You're a seasoned engineering lead with a knack for writing clear and concise designs.
-  llm: openrouter/openai/gpt-4.1-mini
 
 
 backend_engineer:
@@ -24,7 +23,6 @@ backend_engineer:
     You're a seasoned python engineer with a knack for writing clean, efficient code.
     You follow the design instructions carefully.
     You produce 1 python module named {module_name} that implements the design and achieves the requirements.
-  llm: openrouter/openai/gpt-4.1-mini
 
 frontend_engineer:
   role: >
@@ -35,7 +33,6 @@ frontend_engineer:
   backstory: >
     You're a seasoned python engineer highly skilled at writing simple Gradio UIs for a backend class.
     You produce a simple gradio UI that demonstrates the given backend class; you write the gradio UI in a module app.py that is in the same directory as the backend module {module_name}.
-  llm: openrouter/openai/gpt-4.1-mini
 
 test_engineer:
   role: >
@@ -44,7 +41,6 @@ test_engineer:
     Write unit tests for the given backend module {module_name} and create a test_{module_name} in the same directory as the backend module.
   backstory: >
     You're a seasoned QA engineer and software developer who writes great unit tests for python code.
-  llm: openrouter/openai/gpt-4.1-mini
 
 python_code_runner:
   role: >
@@ -53,4 +49,3 @@ python_code_runner:
     Upload the zip to google cloud storage and run the given python code and return the output
   backstory: >
     You're a seasoned python engineer with a knack for uploading zip to google cloud storage and running python code.
-  llm: openrouter/openai/gpt-4.1-mini

src/ai_agentic_coder/config/tasks.yaml

@@ -51,12 +51,11 @@ test_task:
 
 python_code_run_task:
   description: >  
-    Upload the zip to google cloud storage and run the python code that was generated
+    Upload the zip to Google Cloud Storage and run the Python code that was generated.
   expected_output: >
-    Signed public url of the zip that is uploaded in google cloud storage and the public url of gradle url 
-    that is started returned after running the tool.
-    IMPORTANT: tool returns both the url, so just return the output returned by the tool, without any additional text or formatting.
+    Signed URL of the zip uploaded to Google Cloud Storage and the live URL of the generated Gradio app.
+    IMPORTANT: The tool returns both URLs, so return the exact output returned by the tool without any additional text or formatting.
   agent: python_code_runner
   context:
     - code_task
-  output_file: src/ai_agentic_coder/output/gradio_public_url.txt
+  output_file: src/ai_agentic_coder/output/gradio_public_url.txt

src/ai_agentic_coder/crew.py

@@ -3,6 +3,7 @@ import os
 from crewai import Agent, Crew, Process, Task
 from crewai.project import CrewBase, agent, crew, task
 
+from .model_client import create_llm
 from .tools.python_code_run_tool import PythonCodeRunTool
 
 def is_running_in_hf_space() -> bool:
@@ -20,17 +21,24 @@ class EngineeringTeam():
     agents_config = 'config/agents.yaml'
     tasks_config = 'config/tasks.yaml'
 
+    def _agent_config(self, name: str) -> dict:
+        config = dict(self.agents_config[name])
+        config.pop("llm", None)
+        return config
+
     @agent
     def engineering_lead(self) -> Agent:
         return Agent(
-            config=self.agents_config['engineering_lead'],
+            config=self._agent_config('engineering_lead'),
+            llm=create_llm(),
             verbose=True,
         )
 
     @agent
     def backend_engineer(self) -> Agent:
         return Agent(
-            config=self.agents_config['backend_engineer'],
+            config=self._agent_config('backend_engineer'),
+            llm=create_llm(),
             verbose=True,
             allow_code_execution=True,
             code_execution_mode=run_in_docker,
@@ -41,14 +49,16 @@ class EngineeringTeam():
     @agent
     def frontend_engineer(self) -> Agent:
         return Agent(
-            config=self.agents_config['frontend_engineer'],
+            config=self._agent_config('frontend_engineer'),
+            llm=create_llm(),
             verbose=True,
         )
     
     @agent
     def test_engineer(self) -> Agent:
         return Agent(
-            config=self.agents_config['test_engineer'],
+            config=self._agent_config('test_engineer'),
+            llm=create_llm(),
             verbose=True,
             allow_code_execution=True,
             code_execution_mode=run_in_docker,
@@ -59,7 +69,8 @@ class EngineeringTeam():
     @agent
     def python_code_runner(self) -> Agent:
         return Agent(
-            config=self.agents_config['python_code_runner'],
+            config=self._agent_config('python_code_runner'),
+            llm=create_llm(),
             verbose=True,
             tools=[PythonCodeRunTool()],
         )
@@ -102,4 +113,4 @@ class EngineeringTeam():
             tasks=self.tasks,
             process=Process.sequential,
             verbose=True,
-        )
+        )

src/ai_agentic_coder/crewai_wrapper.py

@@ -4,19 +4,65 @@ import subprocess
 import time
 import threading
 import re
+import json
+import os
+from pathlib import Path
 import gradio as gr
 
 from src.ai_agentic_coder.crew import EngineeringTeam
+from src.ai_agentic_coder.tools.python_code_run_tool import RUN_RESULT_FILE
+
+
+OUTPUT_DIR = Path(__file__).resolve().parent / "output"
+
+
+def _run_result_path() -> Path:
+    return OUTPUT_DIR / RUN_RESULT_FILE
+
+
+def _clear_run_result() -> None:
+    try:
+        _run_result_path().unlink()
+    except FileNotFoundError:
+        pass
+
+
+def _load_run_result() -> dict[str, str]:
+    try:
+        data = json.loads(_run_result_path().read_text(encoding="utf-8"))
+    except (FileNotFoundError, json.JSONDecodeError):
+        return {}
+
+    return {
+        "download_url": str(data.get("download_url", "")),
+        "live_url": str(data.get("live_url", "")),
+    }
+
+
+def _set_base_url_from_request(request: gr.Request | None) -> None:
+    if request is None:
+        return
+
+    host = request.headers.get("x-forwarded-host") or request.headers.get("host")
+    if not host:
+        return
+
+    proto = request.headers.get("x-forwarded-proto") or request.url.scheme or "http"
+    os.environ["AI_AGENTIC_CODER_BASE_URL"] = f"{proto}://{host}"
 
 def run_crew(requirements, module_name, class_name, progress=gr.Progress()):
     """Run the crew with the given inputs and return ONLY the raw result text."""
     try:
         # Kill any running processes from previous runs
-        subprocess.run(
-            ["pkill", "-f", "python.*src.ai_agentic_coder.output.app"],
-            stderr=subprocess.DEVNULL,
-            stdout=subprocess.DEVNULL
-        )
+        for pattern in (
+            "python.*src.ai_agentic_coder.output.app",
+            "python.*ai_agentic_coder.generated_app_runner",
+        ):
+            subprocess.run(
+                ["pkill", "-f", pattern],
+                stderr=subprocess.DEVNULL,
+                stdout=subprocess.DEVNULL
+            )
 
         inputs = {
             'requirements': requirements,
@@ -39,7 +85,10 @@ def run_crew(requirements, module_name, class_name, progress=gr.Progress()):
         return f"❌ Error: {str(e)}"
 
 # Generator function to manage state, progress, and output
-def run_crew_wrapper(requirements, module_name, class_name):
+def run_crew_wrapper(requirements, module_name, class_name, request: gr.Request | None = None):
+    _clear_run_result()
+    _set_base_url_from_request(request)
+
     progress = gr.Progress()
     # Immediately disable the button, show Output as progress area, and hide URL boxes
     yield (
@@ -102,6 +151,16 @@ def run_crew_wrapper(requirements, module_name, class_name):
         return
 
     raw_output = result_holder["output"] or ""
+    run_result = _load_run_result()
+
+    if run_result.get("download_url") and run_result.get("live_url"):
+        yield (
+            gr.update(value="", visible=False, label="Output"),
+            gr.update(value=run_result["download_url"], visible=True),
+            gr.update(value=run_result["live_url"], visible=True),
+            gr.update(interactive=True, value="Run AI Coder")
+        )
+        return
 
     # If the output looks like a failure (but no exception was thrown), treat it as an error
     failure_like = bool(re.search(r"\b(failed|failure|error|exception|traceback)\b", raw_output, re.IGNORECASE))

src/ai_agentic_coder/generated_app_runner.py

@@ -0,0 +1,77 @@
+"""Run generated Gradio apps with controlled launch settings."""
+
+from __future__ import annotations
+
+import os
+import runpy
+import sys
+from pathlib import Path
+from typing import Any
+
+import gradio as gr
+
+
+_LAUNCH_CALLED = False
+
+
+def _preview_port() -> int:
+    return int(os.getenv("GENERATED_GRADIO_PORT", "7861"))
+
+
+def _root_path() -> str:
+    root_path = os.getenv("GENERATED_GRADIO_ROOT_PATH", "/generated-app").strip()
+    if not root_path.startswith("/"):
+        root_path = f"/{root_path}"
+    return root_path.rstrip("/") or "/generated-app"
+
+
+def _patch_launch(cls: type[Any]) -> None:
+    original_launch = cls.launch
+    if getattr(original_launch, "_ai_agentic_coder_controlled", False):
+        return
+
+    def controlled_launch(self: Any, *args: Any, **kwargs: Any) -> Any:
+        global _LAUNCH_CALLED
+        _LAUNCH_CALLED = True
+        kwargs["server_name"] = "127.0.0.1"
+        kwargs["server_port"] = _preview_port()
+        kwargs["share"] = False
+        kwargs["root_path"] = _root_path()
+        kwargs["prevent_thread_lock"] = False
+        return original_launch(self, *args, **kwargs)
+
+    controlled_launch._ai_agentic_coder_controlled = True  # type: ignore[attr-defined]
+    cls.launch = controlled_launch  # type: ignore[method-assign]
+
+
+def main() -> None:
+    app_path = Path(os.environ["GENERATED_GRADIO_APP_PATH"]).resolve()
+    output_dir = app_path.parent
+
+    sys.path.insert(0, str(output_dir))
+    os.chdir(output_dir)
+
+    _patch_launch(gr.Blocks)
+    _patch_launch(gr.Interface)
+
+    globals_after_run = runpy.run_path(str(app_path), run_name="__main__")
+
+    if _LAUNCH_CALLED:
+        return
+
+    for value in globals_after_run.values():
+        if isinstance(value, gr.Blocks):
+            value.launch(
+                server_name="127.0.0.1",
+                server_port=_preview_port(),
+                share=False,
+                root_path=_root_path(),
+                prevent_thread_lock=False,
+            )
+            return
+
+    raise RuntimeError("Generated app did not define or launch a Gradio Blocks/Interface app.")
+
+
+if __name__ == "__main__":
+    main()

src/ai_agentic_coder/gradio_ui.py

@@ -2,6 +2,7 @@
 import gradio as gr
 
 from src.ai_agentic_coder.crewai_wrapper import run_crew_wrapper
+from src.ai_agentic_coder.preview_proxy import register_preview_proxy
 
 # Example configuration
 EXAMPLE_CONFIG = {
@@ -24,7 +25,7 @@ EXAMPLE_CONFIG = {
 
 def create_interface():
     """Create and return the Gradio interface."""
-    with gr.Blocks(title="AI Agentic Coder", theme=gr.themes.Soft()) as demo:
+    with gr.Blocks(title="AI Agentic Coder") as demo:
         gr.HTML("""
         <div class="header">
             <div class="brand">AI Agentic Coder</div>
@@ -90,7 +91,7 @@ def create_interface():
                 label="Output",
                 interactive=False,
                 lines=20,
-                show_copy_button=True,
+                buttons=["copy"],
                 elem_classes=["card"],
                 visible=False,
                 elem_id="output-box"
@@ -102,14 +103,15 @@ def create_interface():
                 label="Download URL",
                 interactive=False,
                 visible=False,
-                show_copy_button=True,
+                buttons=["copy"],
                 elem_classes=["card"]
             )
+        with gr.Row():
             live_url_box = gr.Textbox(
                 label="Live App URL",
                 interactive=False,
                 visible=False,
-                show_copy_button=True,
+                buttons=["copy"],
                 elem_classes=["card"]
             )
 
@@ -174,4 +176,6 @@ def create_interface():
         # Ensure progress overlay renders reliably
         demo.queue()
 
+    register_preview_proxy(demo.app)
+
     return demo

src/ai_agentic_coder/main.py

@@ -2,12 +2,13 @@
 import warnings
 import os
 from dotenv import load_dotenv
+import gradio as gr
 
 from crewai.agent import Agent as _CrewaiAgent
 from src.ai_agentic_coder.gradio_ui import create_interface
 
 # Load environment variables
-load_dotenv(override=True)
+load_dotenv()
 warnings.filterwarnings("ignore", category=SyntaxWarning, module="pysbd")
 
 try:
@@ -24,4 +25,4 @@ except ImportError:
 
 if __name__ == "__main__":
     ai_agentic_coder = create_interface()
-    ai_agentic_coder.launch()
+    ai_agentic_coder.launch(theme=gr.themes.Soft())

src/ai_agentic_coder/model_client.py

@@ -0,0 +1,141 @@
+import os
+from functools import lru_cache
+from typing import Any
+
+import requests
+from crewai import LLM
+from dotenv import load_dotenv
+
+load_dotenv()
+
+OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1"
+OPENCODE_GO_OPENAI_BASE_URL = "https://opencode.ai/zen/go/v1"
+OPENCODE_GO_ANTHROPIC_BASE_URL = "https://opencode.ai/zen/go"
+OPENCODE_GO_MODELS_URL = "https://opencode.ai/zen/go/v1/models"
+
+DEFAULT_OPENROUTER_MODEL = "moonshotai/kimi-k2:free"
+DEFAULT_OPENCODE_GO_MODEL = "deepseek-v4-flash"
+
+
+def _env_bool(name: str, default: bool = False) -> bool:
+    value = os.getenv(name)
+    if value is None:
+        return default
+    return value.strip().lower() in {"1", "true", "yes", "y", "on"}
+
+
+def _env_required(name: str) -> str:
+    value = os.getenv(name)
+    if not value:
+        raise RuntimeError(f"Missing required environment variable: {name}")
+    return value
+
+
+def _opencode_model_id(model: str) -> str:
+    return model.removeprefix("opencode-go/").strip()
+
+
+def _openrouter_model_id(model: str) -> str:
+    model = model.strip()
+    if model.startswith("openrouter/"):
+        return model
+    return f"openrouter/{model}"
+
+
+def _strings_from(value: Any) -> list[str]:
+    if isinstance(value, str):
+        return [value.lower()]
+    if isinstance(value, dict):
+        strings: list[str] = []
+        for item in value.values():
+            strings.extend(_strings_from(item))
+        return strings
+    if isinstance(value, list):
+        strings = []
+        for item in value:
+            strings.extend(_strings_from(item))
+        return strings
+    return []
+
+
+@lru_cache(maxsize=32)
+def _opencode_go_api_style(model: str, api_key: str) -> str:
+    configured = os.getenv("OPENCODE_GO_API_STYLE", "auto").strip().lower()
+    if configured in {"openai", "anthropic"}:
+        return configured
+    if configured != "auto":
+        raise RuntimeError("OPENCODE_GO_API_STYLE must be auto, openai, or anthropic")
+
+    model_id = _opencode_model_id(model)
+    try:
+        response = requests.get(
+            OPENCODE_GO_MODELS_URL,
+            headers={"Authorization": f"Bearer {api_key}"},
+            timeout=5,
+        )
+        response.raise_for_status()
+        payload = response.json()
+        models = payload.get("data", payload) if isinstance(payload, dict) else payload
+        if isinstance(models, list):
+            for item in models:
+                if not isinstance(item, dict):
+                    continue
+                ids = {
+                    str(item.get("id", "")),
+                    str(item.get("model", "")),
+                    str(item.get("name", "")),
+                }
+                if model_id not in ids and f"opencode-go/{model_id}" not in ids:
+                    continue
+                details = " ".join(_strings_from(item))
+                if "messages" in details or "anthropic" in details:
+                    return "anthropic"
+                if (
+                    "chat/completions" in details
+                    or "openai" in details
+                    or "alibaba" in details
+                ):
+                    return "openai"
+    except requests.RequestException:
+        pass
+
+    if model_id.startswith("minimax-"):
+        return "anthropic"
+    return "openai"
+
+
+def create_llm() -> LLM:
+    temperature = float(os.getenv("LLM_TEMPERATURE", "0.2"))
+    timeout = int(os.getenv("LLM_TIMEOUT", "300"))
+
+    if _env_bool("USE_OPENROUTER", default=False):
+        return LLM(
+            model=_openrouter_model_id(
+                os.getenv("OPENROUTER_MODEL", DEFAULT_OPENROUTER_MODEL)
+            ),
+            api_base=OPENROUTER_BASE_URL,
+            api_key=_env_required("OPENROUTER_API_KEY"),
+            temperature=temperature,
+            timeout=timeout,
+        )
+
+    api_key = _env_required("OPENCODE_GO_API_KEY")
+    model = _opencode_model_id(os.getenv("OPENCODE_GO_MODEL", DEFAULT_OPENCODE_GO_MODEL))
+    api_style = _opencode_go_api_style(model, api_key)
+
+    if api_style == "anthropic":
+        return LLM(
+            model=f"anthropic/{model}",
+            api_base=OPENCODE_GO_ANTHROPIC_BASE_URL,
+            api_key=api_key,
+            temperature=temperature,
+            timeout=timeout,
+        )
+
+    return LLM(
+        model=f"openai/{model}",
+        api_base=OPENCODE_GO_OPENAI_BASE_URL,
+        api_key=api_key,
+        temperature=temperature,
+        timeout=timeout,
+    )

src/ai_agentic_coder/preview_proxy.py

@@ -0,0 +1,107 @@
+"""Proxy the generated demo app through the main Gradio Space."""
+
+from __future__ import annotations
+
+import os
+
+import httpx
+from fastapi import Request, Response
+from starlette.responses import RedirectResponse
+
+
+PREVIEW_PATH = os.getenv("AI_AGENTIC_CODER_PREVIEW_PATH", "/generated-app").rstrip("/") or "/generated-app"
+PREVIEW_PORT = int(os.getenv("AI_AGENTIC_CODER_PREVIEW_PORT", "7861"))
+PREVIEW_API_PREFIXES = (
+    "/gradio_api",
+    "/queue",
+    "/call",
+    "/reset",
+    "/heartbeat",
+    "/component_server",
+)
+
+
+def _is_generated_app_request(request: Request) -> bool:
+    referrer = request.headers.get("referer", "")
+    return f"{PREVIEW_PATH}/" in referrer or referrer.rstrip("/").endswith(PREVIEW_PATH)
+
+
+def _is_generated_app_api_request(request: Request) -> bool:
+    return request.url.path.startswith(PREVIEW_API_PREFIXES) and _is_generated_app_request(request)
+
+
+async def _proxy_to_preview(request: Request, target_path: str) -> Response:
+    target_path = target_path.lstrip("/")
+    target = f"http://127.0.0.1:{PREVIEW_PORT}/{target_path}"
+    if request.url.query:
+        target = f"{target}?{request.url.query}"
+
+    headers = {
+        key: value
+        for key, value in request.headers.items()
+        if key.lower() not in {"host", "content-length"}
+    }
+
+    try:
+        async with httpx.AsyncClient(follow_redirects=False, timeout=300.0) as client:
+            upstream = await client.request(
+                request.method,
+                target,
+                headers=headers,
+                content=await request.body(),
+            )
+    except httpx.RequestError:
+        return Response(
+            "The generated preview app is not running yet, or it has expired.",
+            status_code=503,
+            media_type="text/plain",
+        )
+
+    excluded_headers = {
+        "connection",
+        "content-encoding",
+        "content-length",
+        "transfer-encoding",
+    }
+    response_headers = {
+        key: value
+        for key, value in upstream.headers.items()
+        if key.lower() not in excluded_headers
+    }
+
+    location = response_headers.get("location")
+    if location and location.startswith(f"http://127.0.0.1:{PREVIEW_PORT}/"):
+        response_headers["location"] = location.replace(
+            f"http://127.0.0.1:{PREVIEW_PORT}",
+            PREVIEW_PATH,
+            1,
+        )
+
+    return Response(
+        upstream.content,
+        status_code=upstream.status_code,
+        headers=response_headers,
+        media_type=upstream.headers.get("content-type"),
+    )
+
+
+def register_preview_proxy(app) -> None:
+    if getattr(app.state, "ai_agentic_coder_preview_proxy_registered", False):
+        return
+    app.state.ai_agentic_coder_preview_proxy_registered = True
+
+    @app.middleware("http")
+    async def generated_app_api_proxy(request: Request, call_next):
+        if _is_generated_app_api_request(request):
+            return await _proxy_to_preview(request, request.url.path)
+        return await call_next(request)
+
+    async def preview_root() -> RedirectResponse:
+        return RedirectResponse(f"{PREVIEW_PATH}/")
+
+    async def proxy(request: Request, path: str = "") -> Response:
+        return await _proxy_to_preview(request, path)
+
+    methods = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"]
+    app.add_api_route(PREVIEW_PATH, preview_root, methods=["GET"], include_in_schema=False)
+    app.add_api_route(f"{PREVIEW_PATH}/{{path:path}}", proxy, methods=methods, include_in_schema=False)

src/ai_agentic_coder/tools/python_code_run_tool.py

@@ -7,6 +7,11 @@ import select
 import json
 import base64
 import shutil
+import signal
+import tempfile
+import threading
+import urllib.error
+import urllib.request
 from datetime import datetime, timezone, timedelta
 from pathlib import Path
 
@@ -15,6 +20,75 @@ from pydantic import BaseModel, Field
 from google.cloud import storage
 from google.oauth2 import service_account
 
+
+PREVIEW_PATH = os.getenv("AI_AGENTIC_CODER_PREVIEW_PATH", "/generated-app").rstrip("/") or "/generated-app"
+PREVIEW_PORT = int(os.getenv("AI_AGENTIC_CODER_PREVIEW_PORT", "7861"))
+RUN_RESULT_FILE = "latest_run_result.json"
+
+
+def _output_dir() -> Path:
+    return Path(__file__).resolve().parents[1] / "output"
+
+
+def _expiry_minutes() -> int:
+    return int(os.getenv("AI_AGENTIC_CODER_PREVIEW_TTL_MINUTES", "30"))
+
+
+def _base_url() -> str:
+    explicit_base_url = os.getenv("AI_AGENTIC_CODER_BASE_URL")
+    if explicit_base_url:
+        return explicit_base_url.rstrip("/")
+
+    space_host = os.getenv("SPACE_HOST")
+    if space_host:
+        if space_host.startswith(("http://", "https://")):
+            return space_host.rstrip("/")
+        return f"https://{space_host.rstrip('/')}"
+
+    space_author = os.getenv("SPACE_AUTHOR_NAME")
+    space_repo = os.getenv("SPACE_REPO_NAME")
+    if space_author and space_repo:
+        return f"https://{space_author}-{space_repo}.hf.space".lower()
+
+    main_port = os.getenv("AI_AGENTIC_CODER_PORT") or os.getenv("GRADIO_SERVER_PORT") or "7860"
+    return f"http://127.0.0.1:{main_port}"
+
+
+def _preview_url() -> str:
+    return f"{_base_url()}{PREVIEW_PATH}/"
+
+
+def _terminate_later(process: subprocess.Popen, ttl_seconds: int) -> None:
+    def terminate() -> None:
+        if process.poll() is not None:
+            return
+        try:
+            os.killpg(process.pid, signal.SIGTERM)
+            process.wait(timeout=10)
+        except Exception:
+            try:
+                os.killpg(process.pid, signal.SIGKILL)
+            except Exception:
+                pass
+
+    timer = threading.Timer(ttl_seconds, terminate)
+    timer.daemon = True
+    timer.start()
+
+
+def _wait_for_preview_server(process: subprocess.Popen, timeout_seconds: int = 60) -> bool:
+    deadline = time.time() + timeout_seconds
+    url = f"http://127.0.0.1:{PREVIEW_PORT}/"
+    while time.time() < deadline:
+        if process.poll() is not None:
+            return False
+        try:
+            with urllib.request.urlopen(url, timeout=1):
+                return True
+        except (urllib.error.URLError, TimeoutError):
+            time.sleep(0.5)
+    return process.poll() is None
+
 class PythonCodeRunToolInput(BaseModel):
     """Input schema for PythonCodeRunTool."""
     argument: str = Field(..., description="Description of the argument.")
@@ -25,17 +99,21 @@ class PythonCodeRunTool(BaseTool):
         "This tool runs the python code"
     )
 
-    def upload_to_gcp(self):
+    def upload_to_gcp(self) -> str:
         project_id = os.getenv("GCP_PROJECT_ID")
         bucket_name = os.getenv("GCP_BUCKET_NAME")
+        if not project_id or not bucket_name:
+            raise RuntimeError("GCP_PROJECT_ID and GCP_BUCKET_NAME are required.")
+
         timestamp = datetime.now(timezone.utc).strftime("%Y%m%d%H%M%S")
-        bucket_file_name = f"ai-agentic-coder-{timestamp}"
+        bucket_file_name = f"ai-agentic-coder-{timestamp}.zip"
         gcp_service_key = os.getenv("GCP_SERVICE_KEY")
-        local_file_name = bucket_file_name + ".zip"
-        output_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "../output"))
+        if not gcp_service_key:
+            raise RuntimeError("GCP_SERVICE_KEY is required.")
 
-        # Create a zip file of the output directory
-        shutil.make_archive(bucket_file_name, format="zip", root_dir=output_dir)
+        output_dir = _output_dir()
+        archive_base = Path(tempfile.gettempdir()) / f"ai-agentic-coder-{timestamp}"
+        archive_path = shutil.make_archive(str(archive_base), format="zip", root_dir=output_dir)
 
         service_key = json.loads(base64.b64decode(gcp_service_key).decode('utf-8'))
         creds = service_account.Credentials.from_service_account_info(service_key)
@@ -44,28 +122,41 @@ class PythonCodeRunTool(BaseTool):
         client = storage.Client(project=project_id, credentials=creds)
         bucket = client.get_bucket(bucket_name)
         blob = bucket.blob(bucket_file_name)
-        blob.upload_from_filename(local_file_name)
+        blob.upload_from_filename(archive_path, content_type="application/zip")
 
         # Delete the temporary zip file after uploading
-        os.remove(local_file_name)
+        os.remove(archive_path)
 
         # Get the signed URL for the uploaded file
         signed_url = blob.generate_signed_url(
             version="v4",
             method="GET",
-            expiration=timedelta(minutes=10)
+            expiration=timedelta(minutes=_expiry_minutes()),
+            response_disposition=f'attachment; filename="{bucket_file_name}"',
         )
 
         return signed_url
 
+    def write_run_result(self, download_url: str, live_url: str) -> None:
+        result_path = _output_dir() / RUN_RESULT_FILE
+        result_path.write_text(
+            json.dumps(
+                {
+                    "download_url": download_url,
+                    "live_url": live_url,
+                    "expires_in_minutes": _expiry_minutes(),
+                },
+                indent=2,
+            ),
+            encoding="utf-8",
+        )
+
     def _run(self, argument: str) -> str:
         # First upload the code to GCP
         signed_url = self.upload_to_gcp()
 
-        # Get the project root directory (src/ai_agentic_coder)
-        # Resolve project root and module path
-        project_root = Path(__file__).resolve().parents[2]  # /.../AI-Agentic-Coder
-        module_path = "src.ai_agentic_coder.output.app"
+        project_src = Path(__file__).resolve().parents[2]
+        module_path = "ai_agentic_coder.generated_app_runner"
 
         # Build the environment so the subprocess can find our package.
         # We need both the project root (src/) **and** the output directory
@@ -73,13 +164,18 @@ class PythonCodeRunTool(BaseTool):
         env = os.environ.copy()
 
         # Path to /src/ai_agentic_coder/output so `accounts.py` is importable
-        output_dir = project_root / "ai_agentic_coder" / "output"
+        output_dir = _output_dir()
 
-        # Compose PYTHONPATH: [output_dir]:[project_root]:<existing>
-        pythonpath_parts = [str(output_dir), str(project_root)]
+        # Compose PYTHONPATH: [output_dir]:[project_src]:<existing>
+        pythonpath_parts = [str(output_dir), str(project_src)]
         if env.get("PYTHONPATH"):
             pythonpath_parts.append(env["PYTHONPATH"])
         env["PYTHONPATH"] = os.pathsep.join(pythonpath_parts)
+        env["GENERATED_GRADIO_APP_PATH"] = str(output_dir / "app.py")
+        env["GENERATED_GRADIO_PORT"] = str(PREVIEW_PORT)
+        env["GENERATED_GRADIO_ROOT_PATH"] = PREVIEW_PATH
+        env["GRADIO_ROOT_PATH"] = PREVIEW_PATH
+        env["GRADIO_SHARE"] = "False"
 
         # Construct the command to run the app as a module in unbuffered mode
         cmd = [sys.executable, "-u", "-m", module_path]
@@ -102,7 +198,7 @@ class PythonCodeRunTool(BaseTool):
             start_new_session=True,
         )
 
-        public_url = None
+        public_url = _preview_url()
         local_url = None
 
         start_time = time.time()
@@ -122,22 +218,14 @@ class PythonCodeRunTool(BaseTool):
             if line:
                 print(line)
 
-            # Prefer public URL
-            m = re.search(r"Running on public URL:\s*(https?://\S+)", line)
-            if m:
-                public_url = m.group(1)
-                break
-
             # Fallback: capture local URL
             m_local = re.search(r"http://127\.0\.0\.1:\d+", line)
             if m_local and not local_url:
                 local_url = m_local.group(0)
+                break
 
-        if not public_url and local_url:
-            public_url = local_url
-
-        if not public_url:
-            public_url = "http://127.0.0.1:7860/"
+        if not local_url and not _wait_for_preview_server(process):
+            raise RuntimeError("Generated Gradio app exited before it became available.")
 
         # Close our copy of stdout; the app keeps running detached.
         try:
@@ -145,6 +233,8 @@ class PythonCodeRunTool(BaseTool):
         except Exception:
             pass
 
+        _terminate_later(process, _expiry_minutes() * 60)
+        self.write_run_result(signed_url, public_url)
         return_urls = f"{signed_url}, {public_url}"
 
-        return return_urls
+        return return_urls