adding one shot agent

README.md

@@ -0,0 +1,46 @@
+---
+title: One-Shot Deploy
+emoji: 🚀
+colorFrom: indigo
+colorTo: purple
+sdk: streamlit
+sdk_version: "1.40.0"
+app_file: app.py
+pinned: true
+---
+
+# One-Shot Deploy
+
+Describe a demo in plain English → Crusoe's multi-model agent writes the code and ships it to Hugging Face Spaces in minutes.
+
+## How it works
+
+| Stage | Model | What happens |
+|-------|-------|-------------|
+| 1 · Intent | **DeepSeek R1** | Reasons about your prompt, selects a template, writes the AI system prompt |
+| 2 · Codegen | **Kimi-K2** | Writes a complete single-file Streamlit app wired to Crusoe inference |
+| 3 · Validate | *(ast parser)* | Checks syntax and structural patterns |
+| 4 · Deploy | **Qwen3** (healer) | Pushes to HF Spaces, injects secrets, auto-fixes on build failure (up to 3×) |
+
+## Required secrets
+
+Set these in **Settings → Variables and secrets** in your Space:
+
+| Name | Description |
+|------|-------------|
+| `CRUSOE_API_KEY` | Crusoe Managed Inference API key |
+| `HF_TOKEN` | Hugging Face token with write scope |
+| `HF_USERNAME` | Your Hugging Face username |
+
+Optionally override the default models:
+
+| Name | Default |
+|------|---------|
+| `CRUSOE_BASE_URL` | `https://api.inference.crusoe.ai/v1` |
+| `INTENT_MODEL` | `deepseek-ai/DeepSeek-R1` |
+| `CODEGEN_MODEL` | `moonshotai/Kimi-K2-Instruct` |
+| `HEALER_MODEL` | `Qwen/Qwen3-235B-A22B` |
+
+## Built by
+
+Crusoe DevRel · Powered by [Crusoe Managed Inference](https://crusoe.ai)

agent/code_generator.py

@@ -0,0 +1,102 @@
+"""
+Stage 2 — Code Generator
+Model: Kimi-K2 (long-context, excels at code generation)
+Input:  structured intent dict
+Output: complete single-file Streamlit app as a string
+"""
+
+import re
+from openai import OpenAI
+from config import CRUSOE_API_KEY, CRUSOE_BASE_URL, CODEGEN_MODEL
+from templates import get_template
+
+client = OpenAI(api_key=CRUSOE_API_KEY, base_url=CRUSOE_BASE_URL)
+
+SYSTEM_PROMPT = """You are an expert Streamlit developer creating polished AI demos.
+
+You will be given a base template and a structured intent. Your job is to:
+1. Fill in the template placeholders accurately
+2. Add any extra UI polish or features mentioned in the intent
+3. Keep the code as a single self-contained Python file
+4. Ensure the openai client uses env vars for CRUSOE_API_KEY and CRUSOE_BASE_URL
+
+Rules:
+- Output ONLY valid Python code
+- No markdown fences, no explanations
+- All string placeholders ({title}, {description}, etc.) must be replaced
+- Do not change the streaming pattern or client setup
+- Available Crusoe models: deepseek-ai/DeepSeek-R1, moonshotai/Kimi-K2-Instruct, Qwen/Qwen3-235B-A22B"""
+
+
+def generate_code(intent: dict) -> str:
+    template = get_template(intent.get("template_type", "chatbot"))
+
+    # Build the pre-filled template by substituting known values
+    try:
+        prefilled = _fill_template(template, intent)
+    except KeyError:
+        prefilled = template  # fall back to raw template
+
+    user_message = f"""Fill in this Streamlit app template using the intent below.
+
+INTENT:
+- Title: {intent.get('title')}
+- Description: {intent.get('description')}
+- Template type: {intent.get('template_type')}
+- Model: {intent.get('model')}
+- System prompt: {intent.get('system_prompt')}
+- Features: {', '.join(intent.get('features', []))}
+- Chat placeholder: {intent.get('chat_placeholder', '')}
+- Input label: {intent.get('input_label', '')}
+- Input placeholder: {intent.get('input_placeholder', '')}
+- Model A: {intent.get('model_a', '')} ({intent.get('model_a_label', '')})
+- Model B: {intent.get('model_b', '')} ({intent.get('model_b_label', '')})
+- Steps: {intent.get('steps', [])}
+
+TEMPLATE (replace all {{placeholders}} and improve where noted):
+{prefilled}"""
+
+    response = client.chat.completions.create(
+        model=CODEGEN_MODEL,
+        messages=[
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": user_message},
+        ],
+        temperature=0.2,
+        max_tokens=4096,
+    )
+
+    raw = response.choices[0].message.content or ""
+    return _extract_code(raw)
+
+
+def _fill_template(template: str, intent: dict) -> str:
+    """Best-effort template fill — remaining {placeholders} are sent to the LLM."""
+    steps_repr = repr(intent.get("steps", []))
+    return template.format(
+        title=_esc(intent.get("title", "AI Demo")),
+        description=_esc(intent.get("description", "Powered by Crusoe")),
+        system_prompt=_esc(intent.get("system_prompt", "You are a helpful assistant.")),
+        model=intent.get("model", "Qwen/Qwen3-235B-A22B"),
+        chat_placeholder=_esc(intent.get("chat_placeholder", "Ask me anything...")),
+        input_label=_esc(intent.get("input_label", "Enter input:")),
+        input_placeholder=_esc(intent.get("input_placeholder", "Type here...")),
+        model_a=intent.get("model_a", "deepseek-ai/DeepSeek-R1"),
+        model_a_label=_esc(intent.get("model_a_label", "Model A")),
+        model_b=intent.get("model_b", "moonshotai/Kimi-K2-Instruct"),
+        model_b_label=_esc(intent.get("model_b_label", "Model B")),
+        steps=steps_repr,
+    )
+
+
+def _esc(s: str) -> str:
+    """Escape triple-quotes inside template string values."""
+    return str(s).replace('"""', "'''")
+
+
+def _extract_code(raw: str) -> str:
+    """Strip markdown fences if the model wrapped the output."""
+    fenced = re.search(r"```(?:python)?\n(.*?)```", raw, re.DOTALL)
+    if fenced:
+        return fenced.group(1).strip()
+    return raw.strip()

agent/deployer.py

@@ -0,0 +1,222 @@
+"""
+Stage 4 — Deployer + Self-Healer
+Deploys generated code to Hugging Face Spaces.
+If the build fails, Qwen3 reads the error logs and patches the code.
+Up to MAX_RETRIES self-heal cycles before giving up.
+"""
+
+import re
+import time
+import requests
+from openai import OpenAI
+from huggingface_hub import HfApi
+from huggingface_hub.utils import HfHubHTTPError
+from config import (
+    CRUSOE_API_KEY,
+    CRUSOE_BASE_URL,
+    HEALER_MODEL,
+    HF_TOKEN,
+    HF_USERNAME,
+)
+
+MAX_RETRIES = 3
+POLL_INTERVAL = 15  # seconds between status checks
+BUILD_TIMEOUT = 300  # seconds before we give up waiting
+
+healer_client = OpenAI(api_key=CRUSOE_API_KEY, base_url=CRUSOE_BASE_URL)
+
+HEALER_SYSTEM_PROMPT = """You are an expert Python/Streamlit debugging assistant.
+You will receive broken Streamlit app code and a build/runtime error message.
+Fix the code so it runs cleanly on Hugging Face Spaces with:
+  - Python 3.11
+  - streamlit and openai installed
+  - CRUSOE_API_KEY and CRUSOE_BASE_URL set as environment secrets
+
+Output ONLY the corrected Python code. No markdown fences, no explanations."""
+
+APP_REQUIREMENTS = "streamlit\nopenai\n"
+
+README_TEMPLATE = """---
+title: {title}
+emoji: 🚀
+colorFrom: blue
+colorTo: purple
+sdk: streamlit
+sdk_version: "1.40.0"
+app_file: app.py
+pinned: false
+---
+
+{description}
+
+*Powered by [Crusoe Managed Inference](https://crusoe.ai)*
+"""
+
+
+def deploy(code: str, intent: dict, on_progress=None) -> str:
+    """
+    Deploy code to HF Spaces and return the live URL.
+    Calls on_progress(message) at each significant step.
+    """
+    api = HfApi(token=HF_TOKEN)
+    space_name = _slugify(intent.get("title", "crusoe-demo"))
+    repo_id = f"{HF_USERNAME}/{space_name}"
+
+    _log(on_progress, f"Creating Space `{repo_id}`...")
+    _create_space(api, repo_id)
+
+    readme = README_TEMPLATE.format(
+        title=intent.get("title", "AI Demo"),
+        description=intent.get("description", ""),
+    )
+
+    for attempt in range(1, MAX_RETRIES + 1):
+        _log(on_progress, f"Uploading files (attempt {attempt}/{MAX_RETRIES})...")
+        _upload_files(api, repo_id, code, readme)
+
+        _log(on_progress, "Waiting for Hugging Face build...")
+        status, error_log = _wait_for_build(api, repo_id, on_progress)
+
+        if status == "RUNNING":
+            app_url = _space_url(repo_id)
+            _log(on_progress, f"Space is live at {app_url}")
+            return app_url
+
+        if attempt < MAX_RETRIES:
+            _log(on_progress, f"Build failed. Asking {HEALER_MODEL} to fix the code...")
+            code = _heal(code, error_log)
+        else:
+            raise RuntimeError(
+                f"Deployment failed after {MAX_RETRIES} attempts.\nLast error:\n{error_log}"
+            )
+
+    raise RuntimeError("Unexpected exit from deploy loop")
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+def _create_space(api: HfApi, repo_id: str) -> None:
+    try:
+        api.create_repo(
+            repo_id=repo_id,
+            repo_type="space",
+            space_sdk="streamlit",
+            exist_ok=True,
+            private=False,
+        )
+        # Inject Crusoe credentials as Space secrets
+        from config import CRUSOE_API_KEY as KEY, CRUSOE_BASE_URL as BASE_URL
+        api.add_space_secret(repo_id=repo_id, key="CRUSOE_API_KEY", value=KEY)
+        api.add_space_secret(repo_id=repo_id, key="CRUSOE_BASE_URL", value=BASE_URL)
+    except HfHubHTTPError as exc:
+        raise RuntimeError(f"Failed to create HF Space: {exc}") from exc
+
+
+def _upload_files(api: HfApi, repo_id: str, code: str, readme: str) -> None:
+    api.upload_file(
+        path_or_fileobj=code.encode(),
+        path_in_repo="app.py",
+        repo_id=repo_id,
+        repo_type="space",
+    )
+    api.upload_file(
+        path_or_fileobj=APP_REQUIREMENTS.encode(),
+        path_in_repo="requirements.txt",
+        repo_id=repo_id,
+        repo_type="space",
+    )
+    api.upload_file(
+        path_or_fileobj=readme.encode(),
+        path_in_repo="README.md",
+        repo_id=repo_id,
+        repo_type="space",
+    )
+
+
+def _wait_for_build(
+    api: HfApi, repo_id: str, on_progress=None
+) -> tuple[str, str]:
+    """
+    Poll the Space runtime until it reaches a terminal state.
+    Returns (stage_string, error_log).
+    """
+    deadline = time.time() + BUILD_TIMEOUT
+    terminal_stages = {"RUNNING", "RUNTIME_ERROR", "BUILD_ERROR", "APP_CRASHED"}
+
+    while time.time() < deadline:
+        try:
+            runtime = api.get_space_runtime(repo_id=repo_id)
+            stage = str(runtime.stage)
+            _log(on_progress, f"Build status: {stage}")
+
+            if stage in terminal_stages:
+                if stage == "RUNNING":
+                    return "RUNNING", ""
+                error_log = _fetch_build_logs(repo_id)
+                return stage, error_log
+
+        except Exception:
+            pass  # transient API error — keep polling
+
+        time.sleep(POLL_INTERVAL)
+
+    return "TIMEOUT", "Build timed out after 5 minutes."
+
+
+def _fetch_build_logs(repo_id: str) -> str:
+    """Fetch build logs from the HF REST API."""
+    try:
+        owner, name = repo_id.split("/", 1)
+        url = f"https://huggingface.co/api/spaces/{owner}/{name}/logs"
+        headers = {"Authorization": f"Bearer {HF_TOKEN}"}
+        resp = requests.get(url, headers=headers, timeout=15)
+        if resp.ok:
+            logs = resp.json()
+            # logs is a list of {"type": "...", "data": "..."}
+            lines = [entry.get("data", "") for entry in logs if entry.get("data")]
+            return "\n".join(lines[-100:])  # last 100 lines
+    except Exception:
+        pass
+    return "Unable to retrieve build logs."
+
+
+def _heal(code: str, error_log: str) -> str:
+    """Ask HEALER_MODEL to fix the code given the error log."""
+    response = healer_client.chat.completions.create(
+        model=HEALER_MODEL,
+        messages=[
+            {"role": "system", "content": HEALER_SYSTEM_PROMPT},
+            {
+                "role": "user",
+                "content": (
+                    f"Error log:\n```\n{error_log}\n```\n\n"
+                    f"Code to fix:\n```python\n{code}\n```"
+                ),
+            },
+        ],
+        temperature=0.1,
+        max_tokens=4096,
+    )
+    raw = response.choices[0].message.content or ""
+    fenced = re.search(r"```(?:python)?\n(.*?)```", raw, re.DOTALL)
+    return fenced.group(1).strip() if fenced else raw.strip()
+
+
+def _space_url(repo_id: str) -> str:
+    owner, name = repo_id.split("/", 1)
+    slug = f"{owner}-{name}".replace(".", "-")
+    return f"https://{slug}.hf.space"
+
+
+def _slugify(text: str) -> str:
+    text = text.lower().strip()
+    text = re.sub(r"[^a-z0-9]+", "-", text)
+    text = text.strip("-")[:40]
+    return f"crusoe-{text}" if text else "crusoe-demo"
+
+
+def _log(callback, message: str) -> None:
+    if callback:
+        callback(message)

agent/intent_parser.py

@@ -0,0 +1,108 @@
+"""
+Stage 1 — Intent Parser
+Model: DeepSeek R1 (reasoning model, ideal for structured analysis)
+Input:  raw user prompt
+Output: structured intent dict used by the code generator
+"""
+
+import json
+import re
+from openai import OpenAI
+from config import CRUSOE_API_KEY, CRUSOE_BASE_URL, INTENT_MODEL
+
+client = OpenAI(api_key=CRUSOE_API_KEY, base_url=CRUSOE_BASE_URL)
+
+SYSTEM_PROMPT = """You are an expert at analysing AI demo requests and mapping them to the right app template.
+
+Given a user's demo idea, output a single JSON object with these fields:
+
+REQUIRED (all templates):
+- template_type: one of "chatbot" | "comparison" | "dashboard" | "form_wizard"
+- title: short, catchy demo title (max 8 words)
+- description: one-line description shown below the title
+- system_prompt: detailed system prompt for the AI assistant inside the demo
+- model: best Crusoe model for this demo:
+    • "deepseek-ai/DeepSeek-R1"        — reasoning, analysis, step-by-step thinking
+    • "moonshotai/Kimi-K2-Instruct"   — coding, long documents, structured output
+    • "Qwen/Qwen3-235B-A22B"           — general purpose, fast responses, multilingual
+- features: list of 2-4 key features to highlight
+
+CONDITIONAL (chatbot only):
+- chat_placeholder: placeholder text shown in the chat input box
+
+CONDITIONAL (comparison only):
+- model_a: first model ID (from the list above)
+- model_a_label: friendly display name for model A
+- model_b: second model ID
+- model_b_label: friendly display name for model B
+
+CONDITIONAL (dashboard only):
+- input_label: label for the main input text area
+- input_placeholder: placeholder text for that input
+
+CONDITIONAL (form_wizard only):
+- steps: list of 3-5 objects, each {"key": "snake_case_name", "question": "Question text?"}
+
+Template selection guide:
+- chatbot:     conversational Q&A, support bots, advisors
+- comparison:  show two models side-by-side on the same prompt
+- dashboard:   analyze / summarize pasted text, data, or documents
+- form_wizard: multi-step intake flows that end with AI recommendations
+
+Output ONLY the JSON object. No markdown, no explanations."""
+
+
+def parse_intent(prompt: str) -> dict:
+    response = client.chat.completions.create(
+        model=INTENT_MODEL,
+        messages=[
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": f"Create a demo for: {prompt}"},
+        ],
+        temperature=0.3,
+        max_tokens=2000,
+    )
+
+    content = response.choices[0].message.content or ""
+
+    # Strip DeepSeek R1 chain-of-thought tags
+    content = re.sub(r"<think>.*?</think>", "", content, flags=re.DOTALL).strip()
+
+    # Extract the JSON block if surrounded by markdown fences
+    fenced = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", content, re.DOTALL)
+    if fenced:
+        content = fenced.group(1)
+    else:
+        # Grab the outermost { ... }
+        brace = re.search(r"\{.*\}", content, re.DOTALL)
+        if brace:
+            content = brace.group()
+
+    intent = json.loads(content)
+    return _apply_defaults(intent)
+
+
+def _apply_defaults(intent: dict) -> dict:
+    intent.setdefault("template_type", "chatbot")
+    intent.setdefault("title", "AI Demo")
+    intent.setdefault("description", "Powered by Crusoe Managed Inference")
+    intent.setdefault("system_prompt", "You are a helpful AI assistant.")
+    intent.setdefault("model", "Qwen/Qwen3-235B-A22B")
+    intent.setdefault("features", [])
+    # Chatbot defaults
+    intent.setdefault("chat_placeholder", "Ask me anything...")
+    # Comparison defaults
+    intent.setdefault("model_a", "deepseek-ai/DeepSeek-R1")
+    intent.setdefault("model_a_label", "DeepSeek R1")
+    intent.setdefault("model_b", "moonshotai/Kimi-K2-Instruct")
+    intent.setdefault("model_b_label", "Kimi K2")
+    # Dashboard defaults
+    intent.setdefault("input_label", "Paste your content here:")
+    intent.setdefault("input_placeholder", "Enter text to analyze...")
+    # Form wizard defaults
+    intent.setdefault("steps", [
+        {"key": "requirement", "question": "What is your main requirement?"},
+        {"key": "context", "question": "Can you describe your use case in more detail?"},
+        {"key": "constraints", "question": "Are there any constraints or preferences to keep in mind?"},
+    ])
+    return intent

agent/pipeline.py

@@ -0,0 +1,90 @@
+"""
+Main orchestration pipeline.
+Runs the four stages sequentially and surfaces progress via callbacks.
+"""
+
+from dataclasses import dataclass, field
+from typing import Callable
+
+from agent.intent_parser import parse_intent
+from agent.code_generator import generate_code
+from agent.validator import validate_code
+from agent.deployer import deploy
+
+
+@dataclass
+class PipelineResult:
+    intent: dict = field(default_factory=dict)
+    code: str = ""
+    url: str = ""
+    error: str = ""
+    success: bool = False
+
+
+def run(
+    prompt: str,
+    on_stage: Callable[[str, str], None] | None = None,
+) -> PipelineResult:
+    """
+    Execute the full pipeline.
+
+    on_stage(stage_key, message) is called at each significant step:
+      stage_key in {"parsing", "parsed", "generating", "generated",
+                    "validating", "validated", "deploying", "deploy_progress",
+                    "done", "error"}
+    """
+    result = PipelineResult()
+
+    def _notify(stage: str, msg: str = "") -> None:
+        if on_stage:
+            on_stage(stage, msg)
+
+    # ── Stage 1: Intent Parsing ──────────────────────────────────────────────
+    _notify("parsing", f"DeepSeek R1 is analysing your prompt...")
+    try:
+        result.intent = parse_intent(prompt)
+        _notify(
+            "parsed",
+            f"Template: **{result.intent['template_type']}** · "
+            f"Title: **{result.intent['title']}** · "
+            f"Model: `{result.intent['model']}`",
+        )
+    except Exception as exc:
+        result.error = f"Intent parsing failed: {exc}"
+        _notify("error", result.error)
+        return result
+
+    # ── Stage 2: Code Generation ─────────────────────────────────────────────
+    _notify("generating", "Kimi-K2 is writing your Streamlit app...")
+    try:
+        result.code = generate_code(result.intent)
+        _notify("generated", f"Generated {len(result.code.splitlines())} lines of code.")
+    except Exception as exc:
+        result.error = f"Code generation failed: {exc}"
+        _notify("error", result.error)
+        return result
+
+    # ── Stage 3: Validation ──────────────────────────────────────────────────
+    _notify("validating", "Validating generated code...")
+    valid, validation_error = validate_code(result.code)
+    if not valid:
+        # Non-fatal: log the issue and continue — the healer may fix it on deploy
+        _notify("validated", f"Validation warning: {validation_error}. Proceeding anyway.")
+    else:
+        _notify("validated", "Code looks good.")
+
+    # ── Stage 4: Deploy + Self-Heal ──────────────────────────────────────────
+    _notify("deploying", "Deploying to Hugging Face Spaces...")
+    try:
+        result.url = deploy(
+            result.code,
+            result.intent,
+            on_progress=lambda msg: _notify("deploy_progress", msg),
+        )
+        result.success = True
+        _notify("done", result.url)
+    except Exception as exc:
+        result.error = f"Deployment failed: {exc}"
+        _notify("error", result.error)
+
+    return result

agent/validator.py

@@ -0,0 +1,36 @@
+"""
+Stage 3 — Validator
+No LLM needed — uses Python's ast module for a fast syntax check.
+Returns (is_valid: bool, error_message: str).
+"""
+
+import ast
+
+
+def validate_code(code: str) -> tuple[bool, str]:
+    try:
+        ast.parse(code)
+    except SyntaxError as exc:
+        return False, f"SyntaxError at line {exc.lineno}: {exc.msg}"
+
+    issues = _lint(code)
+    if issues:
+        return False, "; ".join(issues)
+
+    return True, ""
+
+
+def _lint(code: str) -> list[str]:
+    """Lightweight structural checks."""
+    issues = []
+
+    if "import streamlit" not in code:
+        issues.append("missing 'import streamlit'")
+    if "OpenAI(" not in code:
+        issues.append("missing OpenAI client instantiation")
+    if "CRUSOE_API_KEY" not in code:
+        issues.append("missing CRUSOE_API_KEY env var reference")
+    if "stream=True" not in code:
+        issues.append("missing streaming (stream=True)")
+
+    return issues

app.py

@@ -0,0 +1,378 @@
+"""
+One-Shot Deploy — Main Streamlit UI
+Describe a demo → watch the agent build and deploy it live.
+Every request calls Crusoe Managed Inference in real time.
+"""
+
+import re
+import streamlit as st
+from config import CRUSOE_API_KEY, CRUSOE_BASE_URL, HF_TOKEN, HF_USERNAME
+
+# ── Page config ───────────────────────────────────────────────────────────────
+st.set_page_config(
+    page_title="One-Shot Deploy | Crusoe",
+    page_icon="🚀",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+# ── CSS ───────────────────────────────────────────────────────────────────────
+st.markdown(
+    """
+    <style>
+    /* Pipeline log rows */
+    .stage-row  { padding: 5px 0 5px 4px; font-size: 0.92rem; border-left: 3px solid transparent; margin-bottom: 2px; }
+    .stage-done { color: #22c55e; border-left-color: #22c55e; }
+    .stage-run  { color: #f59e0b; border-left-color: #f59e0b; }
+    .stage-err  { color: #ef4444; border-left-color: #ef4444; }
+    .stage-info { color: #94a3b8; border-left-color: #475569; }
+
+    /* Integration badge */
+    .int-badge {
+        display: flex; align-items: center; gap: 10px;
+        background: #1e293b; border: 1px solid #334155;
+        border-radius: 10px; padding: 10px 14px; margin-bottom: 10px;
+    }
+    .int-dot-green { width:10px; height:10px; border-radius:50%; background:#22c55e; flex-shrink:0; }
+    .int-dot-grey  { width:10px; height:10px; border-radius:50%; background:#64748b; flex-shrink:0; }
+    .int-label     { font-weight: 600; font-size: 0.88rem; }
+    .int-sub       { font-size: 0.78rem; color: #94a3b8; }
+
+    /* Pipeline flow diagram */
+    .flow-wrap {
+        display: flex; align-items: center; gap: 0;
+        background: #0f172a; border: 1px solid #1e293b;
+        border-radius: 12px; padding: 16px 20px;
+        margin-bottom: 4px; overflow-x: auto;
+    }
+    .flow-node {
+        background: #1e293b; border: 1px solid #334155;
+        border-radius: 8px; padding: 8px 14px;
+        text-align: center; min-width: 110px; flex-shrink: 0;
+    }
+    .flow-node .fn-label { font-size: 0.72rem; color: #94a3b8; margin-bottom: 2px; }
+    .flow-node .fn-value { font-size: 0.85rem; font-weight: 600; }
+    .flow-arrow { color: #475569; font-size: 1.3rem; padding: 0 10px; flex-shrink: 0; }
+    .flow-node-hf { border-color: #FFD21E44; background: #1a1800; }
+    .flow-node-hf .fn-value { color: #FFD21E; }
+    .flow-node-crusoe { border-color: #6366f144; background: #0f0f1a; }
+    .flow-node-crusoe .fn-value { color: #818cf8; }
+
+    /* HF Space result card */
+    .hf-card {
+        background: #1a1800; border: 1px solid #FFD21E55;
+        border-radius: 12px; padding: 20px 24px;
+    }
+    .hf-card-header { display: flex; align-items: center; gap: 10px; margin-bottom: 16px; }
+    .hf-title { font-size: 1.1rem; font-weight: 700; }
+    .hf-row   { display: flex; align-items: center; gap: 8px; margin-bottom: 8px; font-size: 0.88rem; color: #cbd5e1; }
+    .hf-pill  {
+        display: inline-block; background: #FFD21E22; color: #FFD21E;
+        border: 1px solid #FFD21E44; border-radius: 999px;
+        padding: 1px 10px; font-size: 0.75rem; font-weight: 600;
+    }
+    </style>
+    """,
+    unsafe_allow_html=True,
+)
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+def _slugify(text: str) -> str:
+    text = text.lower().strip()
+    text = re.sub(r"[^a-z0-9]+", "-", text)
+    return text.strip("-")[:40] or "demo"
+
+
+def _space_page_url(space_name: str) -> str:
+    return f"https://huggingface.co/spaces/{HF_USERNAME}/{space_name}"
+
+
+def _config_ok() -> bool:
+    missing = []
+    if not CRUSOE_API_KEY:
+        missing.append("`CRUSOE_API_KEY`")
+    if not HF_TOKEN:
+        missing.append("`HF_TOKEN`")
+    if not HF_USERNAME:
+        missing.append("`HF_USERNAME`")
+    if missing:
+        st.error(
+            f"Missing required environment variables: {', '.join(missing)}. "
+            "Copy `env.example` to `.env` and fill in your credentials."
+        )
+        return False
+    return True
+
+
+# ── Sidebar — Integrations ────────────────────────────────────────────────────
+with st.sidebar:
+    st.markdown("### Connected integrations")
+
+    crusoe_dot = "int-dot-green" if CRUSOE_API_KEY else "int-dot-grey"
+    crusoe_status = "Connected" if CRUSOE_API_KEY else "Missing API key"
+    st.markdown(
+        f"""
+        <div class="int-badge">
+            <div class="{crusoe_dot}"></div>
+            <div>
+                <div class="int-label">Crusoe Managed Inference</div>
+                <div class="int-sub">{crusoe_status} · {CRUSOE_BASE_URL.replace("https://","")}</div>
+            </div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    hf_dot = "int-dot-green" if (HF_TOKEN and HF_USERNAME) else "int-dot-grey"
+    hf_status = f"@{HF_USERNAME}" if HF_USERNAME else "Missing token / username"
+    st.markdown(
+        f"""
+        <div class="int-badge">
+            <div class="{hf_dot}"></div>
+            <div>
+                <div class="int-label">🤗 Hugging Face Spaces</div>
+                <div class="int-sub">{hf_status} · streamlit · public</div>
+            </div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    st.divider()
+    st.markdown("**Models in this pipeline**")
+    st.markdown(
+        """
+| Stage | Model |
+|-------|-------|
+| Intent | DeepSeek R1 |
+| Codegen | Kimi-K2 |
+| Healer | Qwen3 |
+        """
+    )
+
+    st.divider()
+    st.caption("Built by Crusoe DevRel")
+
+
+# ── Header ────────────────────────────────────────────────────────────────────
+st.markdown("# 🚀 One-Shot Deploy")
+st.caption(
+    "Describe a demo in plain English. "
+    "Crusoe's multi-model agent writes the code and ships it to **Hugging Face Spaces** — live in minutes."
+)
+
+# Pipeline flow diagram
+st.markdown(
+    """
+    <div class="flow-wrap">
+        <div class="flow-node">
+            <div class="fn-label">You provide</div>
+            <div class="fn-value">💬 Prompt</div>
+        </div>
+        <div class="flow-arrow">→</div>
+        <div class="flow-node flow-node-crusoe">
+            <div class="fn-label">DeepSeek R1</div>
+            <div class="fn-value">Intent</div>
+        </div>
+        <div class="flow-arrow">→</div>
+        <div class="flow-node flow-node-crusoe">
+            <div class="fn-label">Kimi-K2</div>
+            <div class="fn-value">Codegen</div>
+        </div>
+        <div class="flow-arrow">→</div>
+        <div class="flow-node flow-node-crusoe">
+            <div class="fn-label">Qwen3</div>
+            <div class="fn-value">Self-heal</div>
+        </div>
+        <div class="flow-arrow">→</div>
+        <div class="flow-node flow-node-hf">
+            <div class="fn-label">🤗 HF Spaces</div>
+            <div class="fn-value">Live URL</div>
+        </div>
+    </div>
+    """,
+    unsafe_allow_html=True,
+)
+
+st.divider()
+
+# ── Prompt input ──────────────────────────────────────────────────────────────
+examples = [
+    "A chatbot that helps users pick the right GPU for their ML workload",
+    "Side-by-side comparison of DeepSeek R1 vs Kimi K2 on coding problems",
+    "A dashboard that analyses a job description and surfaces key requirements",
+    "A wizard that collects ML requirements and recommends the optimal Crusoe instance type",
+]
+
+col_input, col_examples = st.columns([3, 2])
+
+with col_input:
+    prompt = st.text_area(
+        "What demo do you want to build?",
+        height=120,
+        placeholder="e.g. A chatbot that helps startups write investor updates...",
+    )
+    deploy_btn = st.button(
+        "🚀 Deploy to Hugging Face Spaces",
+        type="primary",
+        disabled=not prompt,
+        use_container_width=True,
+    )
+
+with col_examples:
+    st.markdown("**Try an example**")
+    for ex in examples:
+        if st.button(ex, use_container_width=True, key=f"ex_{ex[:20]}"):
+            st.session_state["example_tip"] = ex
+
+if "example_tip" in st.session_state:
+    st.info(f"Paste into the prompt box: *{st.session_state['example_tip']}*")
+
+st.divider()
+
+# ── Pipeline runner ────────────────────────────────────────────────────────────
+if deploy_btn and prompt and _config_ok():
+    from agent.pipeline import run as run_pipeline
+
+    stage_log_el = st.empty()
+    code_expander = st.expander("Generated code", expanded=False)
+    result_el = st.empty()
+
+    log_lines: list[str] = []
+
+    ICONS = {
+        "parsing":         "⏳",
+        "parsed":          "✅",
+        "generating":      "⏳",
+        "generated":       "✅",
+        "validating":      "⏳",
+        "validated":       "✅",
+        "deploying":       "⏳",
+        "deploy_progress": "   ",
+        "done":            "🎉",
+        "error":           "❌",
+    }
+    LABELS = {
+        "parsing":         "Stage 1 · DeepSeek R1 — Parsing intent",
+        "parsed":          "Stage 1 · Intent parsed",
+        "generating":      "Stage 2 · Kimi-K2 — Generating code",
+        "generated":       "Stage 2 · Code generated",
+        "validating":      "Stage 3 · Validating code",
+        "validated":       "Stage 3 · Validation complete",
+        "deploying":       "Stage 4 · Pushing to 🤗 Hugging Face Spaces",
+        "deploy_progress": "Stage 4 ·",
+        "done":            "Done",
+        "error":           "Error",
+    }
+    CSS = {
+        "parsed": "stage-done", "generated": "stage-done",
+        "validated": "stage-done", "done": "stage-done",
+        "error": "stage-err",
+        "deploy_progress": "stage-info",
+    }
+
+    def on_stage(stage: str, msg: str) -> None:
+        icon = ICONS.get(stage, "  ")
+        label = LABELS.get(stage, stage)
+        css = CSS.get(stage, "stage-run")
+        line = (
+            f'<div class="stage-row {css}">'
+            f'{icon}&nbsp; <b>{label}</b>'
+            f'{"&nbsp;&nbsp;" + msg if msg else ""}'
+            f'</div>'
+        )
+        log_lines.append(line)
+        stage_log_el.markdown("\n".join(log_lines), unsafe_allow_html=True)
+
+    result = run_pipeline(prompt, on_stage=on_stage)
+
+    # Generated code preview
+    if result.code:
+        with code_expander:
+            st.code(result.code, language="python")
+
+    # Outcome
+    if result.success:
+        title = result.intent.get("title", "demo")
+        space_name = f"crusoe-{_slugify(title)}"
+        page_url = _space_page_url(space_name)
+        app_url = result.url
+
+        # HF Space result card
+        result_el.markdown(
+            f"""
+            <div class="hf-card">
+                <div class="hf-card-header">
+                    <span style="font-size:1.6rem">🤗</span>
+                    <div>
+                        <div class="hf-title">Your Space is live on Hugging Face</div>
+                        <div style="font-size:0.82rem;color:#94a3b8;">
+                            Deployed to <b>huggingface.co/spaces/{HF_USERNAME}/{space_name}</b>
+                        </div>
+                    </div>
+                </div>
+                <div class="hf-row">
+                    <span>👤</span>
+                    <span><b>{HF_USERNAME}</b> / <b>{space_name}</b></span>
+                    <span class="hf-pill">streamlit</span>
+                    <span class="hf-pill">public</span>
+                </div>
+                <div class="hf-row">
+                    <span>🌐</span>
+                    <a href="{app_url}" target="_blank" style="color:#FFD21E;">{app_url}</a>
+                </div>
+                <div class="hf-row">
+                    <span>📄</span>
+                    <a href="{page_url}" target="_blank" style="color:#94a3b8;">{page_url}</a>
+                </div>
+                <div class="hf-row" style="margin-top:6px;">
+                    <span>⚡</span>
+                    <span style="color:#94a3b8;">Calls <b>Crusoe Managed Inference</b> on every request</span>
+                </div>
+            </div>
+            """,
+            unsafe_allow_html=True,
+        )
+
+        col_a, col_b = st.columns(2)
+        with col_a:
+            st.link_button(
+                "🚀 Open live demo",
+                app_url,
+                use_container_width=True,
+                type="primary",
+            )
+        with col_b:
+            st.link_button(
+                "🤗 View Space on Hugging Face",
+                page_url,
+                use_container_width=True,
+            )
+
+        st.subheader("Live preview")
+        st.caption(f"Embedded from `{app_url}`")
+        st.components.v1.iframe(app_url, height=600, scrolling=True)
+
+    else:
+        result_el.error(f"**Deployment failed.** {result.error}")
+
+
+# ── How it works ──────────────────────────────────────────────────────────────
+with st.expander("How it works", expanded=False):
+    st.markdown(
+        """
+| Stage | Model | What happens |
+|-------|-------|-------------|
+| 1 · Intent | **DeepSeek R1** | Reasons about your prompt, selects a template (chatbot / comparison / dashboard / wizard), writes the AI system prompt |
+| 2 · Codegen | **Kimi-K2** | Writes a complete single-file Streamlit app wired to Crusoe inference |
+| 3 · Validate | *(ast parser)* | Checks syntax and structural patterns — no LLM cost |
+| 4 · Deploy | **Qwen3** (healer) | Pushes `app.py` + `requirements.txt` to HF Spaces; injects `CRUSOE_API_KEY` as a Space secret; reads build logs and auto-fixes on failure (up to 3×) |
+
+Every deployed app calls **Crusoe Managed Inference** live, so every visitor experiences Crusoe's speed firsthand.
+        """
+    )
+
+# ── Footer ────────────────────────────────────────────────────────────────────
+st.divider()
+st.caption("Built with ❤️ by Crusoe DevRel · Powered by Crusoe Managed Inference · Deployed via 🤗 Hugging Face Spaces")

config.py

@@ -0,0 +1,15 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+CRUSOE_API_KEY = os.environ.get("CRUSOE_API_KEY", "")
+CRUSOE_BASE_URL = os.environ.get("CRUSOE_BASE_URL", "https://api.inference.crusoe.ai/v1")
+
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
+HF_USERNAME = os.environ.get("HF_USERNAME", "")
+
+# Model assignments per pipeline stage
+INTENT_MODEL = os.environ.get("INTENT_MODEL", "deepseek-ai/DeepSeek-R1")
+CODEGEN_MODEL = os.environ.get("CODEGEN_MODEL", "moonshotai/Kimi-K2-Instruct")
+HEALER_MODEL = os.environ.get("HEALER_MODEL", "Qwen/Qwen3-235B-A22B")

env.example

@@ -0,0 +1,12 @@
+# Crusoe Managed Inference
+CRUSOE_API_KEY=your_crusoe_api_key_here
+CRUSOE_BASE_URL=https://api.inference.crusoe.ai/v1
+
+# Hugging Face (for deployment)
+HF_TOKEN=your_hf_token_here
+HF_USERNAME=your_hf_username_here
+
+# Model overrides (optional — defaults shown)
+INTENT_MODEL=deepseek-ai/DeepSeek-R1
+CODEGEN_MODEL=moonshotai/Kimi-K2-Instruct
+HEALER_MODEL=Qwen/Qwen3-235B-A22B

requirements.txt

@@ -0,0 +1,5 @@
+streamlit>=1.40.0
+openai>=1.50.0
+huggingface_hub>=0.25.0
+python-dotenv>=1.0.0
+requests>=2.31.0

templates/__init__.py

@@ -0,0 +1,15 @@
+from .chatbot import CHATBOT_TEMPLATE
+from .comparison import COMPARISON_TEMPLATE
+from .dashboard import DASHBOARD_TEMPLATE
+from .form_wizard import FORM_WIZARD_TEMPLATE
+
+TEMPLATES = {
+    "chatbot": CHATBOT_TEMPLATE,
+    "comparison": COMPARISON_TEMPLATE,
+    "dashboard": DASHBOARD_TEMPLATE,
+    "form_wizard": FORM_WIZARD_TEMPLATE,
+}
+
+
+def get_template(template_type: str) -> str:
+    return TEMPLATES.get(template_type, CHATBOT_TEMPLATE)

templates/chatbot.py

@@ -0,0 +1,57 @@
+CHATBOT_TEMPLATE = '''import streamlit as st
+from openai import OpenAI
+import os
+
+TITLE = "{title}"
+DESCRIPTION = "{description}"
+SYSTEM_PROMPT = """{system_prompt}"""
+MODEL = "{model}"
+CHAT_PLACEHOLDER = "{chat_placeholder}"
+
+client = OpenAI(
+    api_key=os.environ.get("CRUSOE_API_KEY"),
+    base_url=os.environ.get("CRUSOE_BASE_URL", "https://api.inference.crusoe.ai/v1"),
+)
+
+st.set_page_config(page_title=TITLE, page_icon="💬", layout="centered")
+st.title(TITLE)
+st.caption(DESCRIPTION)
+st.divider()
+
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+for message in st.session_state.messages:
+    with st.chat_message(message["role"]):
+        st.markdown(message["content"])
+
+if prompt := st.chat_input(CHAT_PLACEHOLDER):
+    st.session_state.messages.append({{"role": "user", "content": prompt}})
+    with st.chat_message("user"):
+        st.markdown(prompt)
+
+    with st.chat_message("assistant"):
+        stream = client.chat.completions.create(
+            model=MODEL,
+            messages=[
+                {{"role": "system", "content": SYSTEM_PROMPT}},
+                *st.session_state.messages,
+            ],
+            stream=True,
+        )
+
+        def get_stream():
+            for chunk in stream:
+                content = chunk.choices[0].delta.content
+                if content:
+                    yield content
+
+        response = st.write_stream(get_stream())
+        st.session_state.messages.append({{"role": "assistant", "content": response}})
+
+with st.sidebar:
+    st.caption("Powered by [Crusoe](https://crusoe.ai)")
+    if st.button("Clear chat"):
+        st.session_state.messages = []
+        st.rerun()
+'''

templates/comparison.py

@@ -0,0 +1,71 @@
+COMPARISON_TEMPLATE = '''import streamlit as st
+from openai import OpenAI
+import os
+import threading
+
+TITLE = "{title}"
+DESCRIPTION = "{description}"
+SYSTEM_PROMPT = """{system_prompt}"""
+MODEL_A = "{model_a}"
+MODEL_A_LABEL = "{model_a_label}"
+MODEL_B = "{model_b}"
+MODEL_B_LABEL = "{model_b_label}"
+
+client = OpenAI(
+    api_key=os.environ.get("CRUSOE_API_KEY"),
+    base_url=os.environ.get("CRUSOE_BASE_URL", "https://api.inference.crusoe.ai/v1"),
+)
+
+st.set_page_config(page_title=TITLE, page_icon="⚖️", layout="wide")
+st.title(TITLE)
+st.caption(DESCRIPTION)
+st.divider()
+
+prompt = st.text_area("Enter your prompt:", height=120, placeholder="Ask anything to compare both models...")
+
+if st.button("⚡ Compare Models", type="primary", disabled=not prompt):
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.subheader(f"🤖 {MODEL_A_LABEL}")
+        stream_a = client.chat.completions.create(
+            model=MODEL_A,
+            messages=[
+                {{"role": "system", "content": SYSTEM_PROMPT}},
+                {{"role": "user", "content": prompt}},
+            ],
+            stream=True,
+        )
+
+        def stream_a_content():
+            for chunk in stream_a:
+                content = chunk.choices[0].delta.content
+                if content:
+                    yield content
+
+        st.write_stream(stream_a_content())
+
+    with col2:
+        st.subheader(f"🤖 {MODEL_B_LABEL}")
+        stream_b = client.chat.completions.create(
+            model=MODEL_B,
+            messages=[
+                {{"role": "system", "content": SYSTEM_PROMPT}},
+                {{"role": "user", "content": prompt}},
+            ],
+            stream=True,
+        )
+
+        def stream_b_content():
+            for chunk in stream_b:
+                content = chunk.choices[0].delta.content
+                if content:
+                    yield content
+
+        st.write_stream(stream_b_content())
+
+with st.sidebar:
+    st.caption("Powered by [Crusoe](https://crusoe.ai)")
+    st.markdown(f"**Model A:** `{MODEL_A}`")
+    st.markdown(f"**Model B:** `{MODEL_B}`")
+'''

templates/dashboard.py

@@ -0,0 +1,54 @@
+DASHBOARD_TEMPLATE = '''import streamlit as st
+from openai import OpenAI
+import os
+
+TITLE = "{title}"
+DESCRIPTION = "{description}"
+SYSTEM_PROMPT = """{system_prompt}"""
+MODEL = "{model}"
+INPUT_LABEL = "{input_label}"
+INPUT_PLACEHOLDER = "{input_placeholder}"
+
+client = OpenAI(
+    api_key=os.environ.get("CRUSOE_API_KEY"),
+    base_url=os.environ.get("CRUSOE_BASE_URL", "https://api.inference.crusoe.ai/v1"),
+)
+
+st.set_page_config(page_title=TITLE, page_icon="📊", layout="wide")
+st.title(TITLE)
+st.caption(DESCRIPTION)
+st.divider()
+
+col_input, col_output = st.columns([1, 2])
+
+with col_input:
+    st.subheader("Input")
+    user_input = st.text_area(INPUT_LABEL, placeholder=INPUT_PLACEHOLDER, height=200)
+    analyze = st.button("🔍 Analyze", type="primary", disabled=not user_input)
+
+with col_output:
+    st.subheader("Analysis")
+    if analyze and user_input:
+        stream = client.chat.completions.create(
+            model=MODEL,
+            messages=[
+                {{"role": "system", "content": SYSTEM_PROMPT}},
+                {{"role": "user", "content": user_input}},
+            ],
+            stream=True,
+        )
+
+        def get_stream():
+            for chunk in stream:
+                content = chunk.choices[0].delta.content
+                if content:
+                    yield content
+
+        st.write_stream(get_stream())
+    else:
+        st.info("Enter your input and click Analyze to get started.")
+
+with st.sidebar:
+    st.caption("Powered by [Crusoe](https://crusoe.ai)")
+    st.markdown(f"**Model:** `{MODEL}`")
+'''

templates/form_wizard.py

@@ -0,0 +1,87 @@
+FORM_WIZARD_TEMPLATE = '''import streamlit as st
+from openai import OpenAI
+import os
+
+TITLE = "{title}"
+DESCRIPTION = "{description}"
+SYSTEM_PROMPT = """{system_prompt}"""
+MODEL = "{model}"
+STEPS = {steps}
+
+client = OpenAI(
+    api_key=os.environ.get("CRUSOE_API_KEY"),
+    base_url=os.environ.get("CRUSOE_BASE_URL", "https://api.inference.crusoe.ai/v1"),
+)
+
+st.set_page_config(page_title=TITLE, page_icon="🧙", layout="centered")
+st.title(TITLE)
+st.caption(DESCRIPTION)
+st.divider()
+
+if "step" not in st.session_state:
+    st.session_state.step = 0
+if "answers" not in st.session_state:
+    st.session_state.answers = {{}}
+if "result" not in st.session_state:
+    st.session_state.result = None
+
+if st.session_state.step < len(STEPS):
+    current_step = STEPS[st.session_state.step]
+    progress = st.session_state.step / len(STEPS)
+    st.progress(progress, text=f"Step {{st.session_state.step + 1}} of {{len(STEPS)}}")
+    st.subheader(current_step["question"])
+
+    answer = st.text_input(
+        "Your answer:",
+        key=f"answer_{{st.session_state.step}}",
+        placeholder="Type your answer here...",
+    )
+
+    col1, col2 = st.columns([3, 1])
+    with col2:
+        if st.button("Next →", type="primary", disabled=not answer):
+            st.session_state.answers[current_step["key"]] = answer
+            st.session_state.step += 1
+            st.rerun()
+
+else:
+    st.success("Great! Generating your personalized recommendations...")
+    summary = "\\n".join([f"- {{k.replace('_', ' ').title()}}: {{v}}" for k, v in st.session_state.answers.items()])
+
+    if st.session_state.result is None:
+        stream = client.chat.completions.create(
+            model=MODEL,
+            messages=[
+                {{"role": "system", "content": SYSTEM_PROMPT}},
+                {{"role": "user", "content": f"Based on the following information, provide detailed recommendations:\\n{{summary}}"}},
+            ],
+            stream=True,
+        )
+
+        def get_stream():
+            for chunk in stream:
+                content = chunk.choices[0].delta.content
+                if content:
+                    yield content
+
+        st.subheader("Your Recommendations")
+        result = st.write_stream(get_stream())
+        st.session_state.result = result
+    else:
+        st.subheader("Your Recommendations")
+        st.markdown(st.session_state.result)
+
+    st.divider()
+    if st.button("Start Over"):
+        st.session_state.step = 0
+        st.session_state.answers = {{}}
+        st.session_state.result = None
+        st.rerun()
+
+with st.sidebar:
+    st.caption("Powered by [Crusoe](https://crusoe.ai)")
+    if st.session_state.answers:
+        st.subheader("Your answers so far")
+        for k, v in st.session_state.answers.items():
+            st.markdown(f"**{{k.replace('_', ' ').title()}}:** {{v}}")
+'''