Rewrite explorer with Docker SDK, streaming, citations, custom UI

Switch from Gradio SDK to Docker SDK with custom HTML frontend.
Add streaming answers, citation processing (from harness), source
list, trace toggle, file upload with drag-and-drop, session cost
tracking. Shared chat-ui.js/css fetched at build time from
harness-apps-shared repo. Pin harness to acfd4f2.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Dockerfile

@@ -0,0 +1,20 @@
+FROM python:3.12-slim
+
+RUN apt-get update && apt-get install -y git curl && rm -rf /var/lib/apt/lists/*
+
+RUN useradd -m -u 1000 user
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt "gradio>=5.12,<6"
+
+RUN mkdir -p /app/static && \
+    curl -sL https://raw.githubusercontent.com/chuckfinca/harness-apps-shared/main/chat-ui.js -o /app/static/chat-ui.js && \
+    curl -sL https://raw.githubusercontent.com/chuckfinca/harness-apps-shared/main/chat-ui.css -o /app/static/chat-ui.css
+
+COPY . .
+
+USER user
+EXPOSE 7860
+
+CMD ["python", "app.py"]

README.md

@@ -3,11 +3,8 @@ title: Document Explorer
 emoji: 📄
 colorFrom: blue
 colorTo: green
-sdk: gradio
-sdk_version: "6.9.0"
-app_file: app.py
+sdk: docker
 pinned: false
-python_version: "3.12"
 license: mit
 ---
 

app.py

@@ -1,10 +1,7 @@
-"""Web interface for exploring document workspaces with an LLM agent.
+"""Document Explorer — upload documents, ask questions with cited answers.
 
-Usage:
-    python app.py
-
-Requires LH_MODEL and LH_ACCESS_TOKEN in .env or environment.
-Uses E2B sandboxes for code execution (no Docker required).
+The LLM explores documents by writing Python code. No training, no vector DB.
+Built on a-simple-llm-harness.
 """
 
 from __future__ import annotations
@@ -13,6 +10,7 @@ import json
 import os
 import tempfile
 import time
+from collections.abc import Generator
 from dataclasses import asdict
 from datetime import datetime, timezone
 from pathlib import Path
@@ -23,10 +21,11 @@ from dotenv import load_dotenv
 from huggingface_hub import HfApi
 
 from llm_harness.agent import run_agent_loop
+from llm_harness.citations import process_citations, superscript
 from llm_harness.prompt import build_system_prompt
 from llm_harness.tools import TOOL_DEFINITIONS
 from llm_harness.trace_viewer import render_trace
-from llm_harness.types import Message, ToolCallEvent, ToolResultEvent
+from llm_harness.types import Message, TextDeltaEvent, ToolCallEvent, ToolResultEvent
 
 from sandbox_e2b import run_python as e2b_run_python
 
@@ -40,18 +39,25 @@ MAX_SESSION_COST = float(os.environ.get("LH_MAX_SESSION_COST", "0.50"))
 HF_TRACES_REPO = os.environ.get("HF_TRACES_REPO", "")
 HF_TOKEN = os.environ.get("HF_TOKEN", "")
 
+SOURCE = "prod" if os.environ.get("SPACE_ID") else "dev"
+
 hf_api = HfApi(token=HF_TOKEN) if HF_TOKEN else None
 
 
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
 def _slugify(text: str, max_len: int = 50) -> str:
     slug = text.lower().replace(" ", "-")
     slug = "".join(c for c in slug if c.isalnum() or c == "-")
     return slug[:max_len].rstrip("-")
 
 
-def upload_trace(result: dict) -> str | None:
+def upload_trace(result: dict) -> None:
     if not hf_api or not HF_TRACES_REPO:
-        return None
+        return
     timestamp = datetime.now(timezone.utc).strftime("%Y%m%d-%H%M%S-%f")
     question_slug = _slugify(result.get("question", ""))
     filename = f"{timestamp}_{question_slug}.json" if question_slug else f"{timestamp}.json"
@@ -63,36 +69,8 @@ def upload_trace(result: dict) -> str | None:
             repo_id=HF_TRACES_REPO,
             repo_type="dataset",
         )
-        return filename
     except Exception as exc:
         print(f"WARNING: trace upload failed: {exc}")
-        return None
-
-
-def list_traces() -> list[str]:
-    if not hf_api or not HF_TRACES_REPO:
-        return []
-    try:
-        files = hf_api.list_repo_files(HF_TRACES_REPO, repo_type="dataset")
-        traces = sorted(
-            [f for f in files if f.endswith(".json")],
-            reverse=True,
-        )
-        return traces
-    except Exception:
-        return []
-
-
-def fetch_trace(filename: str) -> dict | None:
-    if not hf_api or not HF_TRACES_REPO or not filename:
-        return None
-    try:
-        path = hf_api.hf_hub_download(
-            HF_TRACES_REPO, filename, repo_type="dataset"
-        )
-        return json.loads(Path(path).read_text())
-    except Exception:
-        return None
 
 
 def save_uploaded_files(files: list[str]) -> Path:
@@ -104,56 +82,78 @@ def save_uploaded_files(files: list[str]) -> Path:
 
 
 def format_stats(trace: object) -> str:
-    cost_str = f"${trace.cost:.4f}" if trace.cost else "n/a"
     cached = trace.cached_tokens
     cache_str = f" ({cached} cached)" if cached else ""
-    scratchpad = len(trace.scratch_files)
     model_name = trace.model.split("/")[-1] if trace.model else ""
-    stats = (
-        f"*{model_name}"
-        f" · {trace.prompt_tokens + trace.completion_tokens:,} tokens{cache_str}"
-        f" · {len(trace.tool_calls)} tool calls"
-        f" · {trace.wall_time_s:.1f}s"
-        f" · {cost_str}"
-    )
-    if scratchpad:
-        stats += f" · {scratchpad} scratchpad files"
-    return stats + "*"
+    parts = [
+        model_name,
+        f"{trace.prompt_tokens + trace.completion_tokens:,} tokens{cache_str}",
+        f"{len(trace.tool_calls)} tool calls",
+        f"{trace.wall_time_s:.1f}s",
+    ]
+    if trace.cost:
+        parts.append(f"${trace.cost:.4f}")
+    return " · ".join(parts)
+
+
+def format_stats_from_trace(trace: dict) -> str:
+    cached = trace.get("cached_tokens", 0)
+    cache_str = f" ({cached} cached)" if cached else ""
+    model = trace.get("model", "")
+    model_name = model.split("/")[-1] if model else ""
+    prompt = trace.get("prompt_tokens", 0)
+    completion = trace.get("completion_tokens", 0)
+    tool_calls = trace.get("tool_calls", [])
+    wall = trace.get("wall_time_s", 0)
+    cost = trace.get("cost")
+    parts = [
+        model_name,
+        f"{prompt + completion:,} tokens{cache_str}",
+        f"{len(tool_calls)} tool calls",
+        f"{wall:.1f}s",
+    ]
+    if cost:
+        parts.append(f"${cost:.4f}")
+    return " · ".join(parts)
 
 
-def chat(
-    message: str,
-    files: list[str] | None,
+# ---------------------------------------------------------------------------
+# Streaming question handler
+# ---------------------------------------------------------------------------
+
+
+def stream_question(
+    question: str,
     workspace_path: str,
     scratch_path: str,
     session_cost: float,
-    token: str = "",
-):
-    empty = ("", "", workspace_path, scratch_path, session_cost, None)
-
+    token: str,
+    files: list[str] | None = None,
+) -> Generator[str, None, None]:
+    """Streaming API — yields JSON event strings."""
     if ACCESS_TOKEN and token != ACCESS_TOKEN:
-        yield ("Invalid access token.", *empty[1:])
+        yield json.dumps({"type": "error", "error": "Invalid access token."})
         return
 
     if not MODEL:
-        yield ("Error: LH_MODEL not set.", *empty[1:])
+        yield json.dumps({"type": "error", "error": "LH_MODEL not set."})
         return
 
     if session_cost >= MAX_SESSION_COST:
-        yield (
-            f"Session cost limit reached (${session_cost:.2f} / "
-            f"${MAX_SESSION_COST:.2f}). Start a new session.",
-            *empty[1:],
-        )
+        yield json.dumps({
+            "type": "error",
+            "error": f"Session cost limit reached (${session_cost:.2f} / ${MAX_SESSION_COST:.2f}).",
+        })
         return
 
-    # Set up workspace from uploaded files (first message only)
     workspace = Path(workspace_path) if workspace_path else None
     if files and not workspace:
         workspace = save_uploaded_files(files)
-        workspace_path = str(workspace)
 
-    # Set up scratchpad (once per session)
+    if not workspace:
+        yield json.dumps({"type": "error", "error": "No documents uploaded."})
+        return
+
     if not scratch_path:
         scratch_path = tempfile.mkdtemp(prefix="lh-scratch-")
     scratch_dir = Path(scratch_path)
@@ -161,10 +161,9 @@ def chat(
     system_prompt = build_system_prompt(base_prompt="", workspace=workspace)
     messages: list[Message] = [
         {"role": "system", "content": system_prompt},
-        {"role": "user", "content": message},
+        {"role": "user", "content": question},
     ]
 
-    # Run agent loop with E2B sandbox
     start = time.monotonic()
     agent_run = run_agent_loop(
         model=MODEL,
@@ -174,185 +173,374 @@ def chat(
         workspace=workspace,
         scratch_dir=scratch_dir,
         sandbox_fn=e2b_run_python,
+        stream=True,
     )
 
     tool_call_count = 0
     try:
         for event in agent_run:
-            if isinstance(event, ToolCallEvent):
+            if isinstance(event, TextDeltaEvent):
+                yield json.dumps({"type": "delta", "content": event.content})
+            elif isinstance(event, ToolCallEvent):
                 tool_call_count += 1
-                status = f"*Exploring documents ({tool_call_count} tool calls)...*"
-                yield status, "", workspace_path, scratch_path, session_cost, None
-            elif isinstance(event, ToolResultEvent):
-                continue
-            else:
-                cost = agent_run.trace.cost or 0
-                session_cost += cost
+                yield json.dumps({"type": "tool_call", "count": tool_call_count, "name": event.name})
     except Exception as exc:
-        yield (
-            f"Error: {exc}",
-            "",
-            workspace_path,
-            scratch_path,
-            session_cost,
-            None,
-        )
+        yield json.dumps({"type": "error", "error": str(exc)})
         return
 
     trace = agent_run.trace
     trace.wall_time_s = round(time.monotonic() - start, 2)
-    answer = trace.answer or "(no answer)"
-    stats = format_stats(trace)
-    result = {"question": message, "passed": True, "assertions": {}, "trace": asdict(trace)}
-    trace_filename = upload_trace(result)
+
+    clean_answer, sources = process_citations(trace.answer or "", workspace)
+
+    result = {
+        "question": question,
+        "source": SOURCE,
+        "passed": True,
+        "assertions": {},
+        "trace": asdict(trace),
+        "citations": sources,
+    }
+    upload_trace(result)
     trace_html = render_trace(result, max_chars=2000)
 
-    yield (
-        f"{answer}\n\n---\n{stats}",
-        trace_html,
-        workspace_path,
-        scratch_path,
-        session_cost,
-        trace_filename,
-    )
+    yield json.dumps({
+        "type": "done",
+        "answer": clean_answer,
+        "sources": sources,
+        "stats": format_stats(trace),
+        "trace_html": trace_html,
+        "workspace_path": str(workspace),
+        "scratch_path": str(scratch_dir),
+        "session_cost": session_cost + (trace.cost or 0),
+    })
+
+
+# ---------------------------------------------------------------------------
+# Gradio app
+# ---------------------------------------------------------------------------
+
+CUSTOM_HTML = """
+<div id="explorer-app">
+    <div id="setup-panel">
+        <div class="setup-field">
+            <label for="token-input">Access Token</label>
+            <input type="password" id="token-input" placeholder="Enter your access token" />
+        </div>
+        <div class="setup-field">
+            <label>Upload Documents</label>
+            <div id="drop-zone" class="drop-zone">
+                <p>Drag and drop files here, or <label for="file-input" class="file-label">browse</label></p>
+                <input type="file" id="file-input" multiple accept=".txt,.csv,.md,.json,.pdf" style="display:none" />
+                <div id="file-list"></div>
+            </div>
+        </div>
+        <button id="start-btn" disabled>Start exploring</button>
+    </div>
+
+    <div id="chat-panel" style="display:none">
+        <div class="chat-container">
+            <div class="chat-history" id="chat-history"></div>
+            <div class="chat-input-wrapper">
+                <input type="text" id="chat-input" class="chat-input" placeholder="Ask a question about your documents..." autocomplete="off" />
+            </div>
+            <div class="chat-stats" id="session-cost"></div>
+        </div>
+    </div>
+</div>
+
+<link rel="stylesheet" href="/file=static/chat-ui.css" />
+<script src="/file=static/chat-ui.js"></script>
+<style>
+    #explorer-app { font-family: var(--font-family, 'Inter', system-ui, sans-serif); max-width: 800px; margin: 0 auto; }
+    #setup-panel { padding: 24px 0; }
+    .setup-field { margin-bottom: 16px; }
+    .setup-field label { display: block; font-size: 13px; color: #6B7280; margin-bottom: 4px; }
+    #token-input { width: 100%; padding: 8px 12px; border: 1px solid #E5E7EB; border-radius: 4px; font-family: inherit; font-size: 14px; }
+    #token-input:focus { outline: none; border-color: #4682B4; }
+    .drop-zone { border: 2px dashed #E5E7EB; border-radius: 8px; padding: 32px; text-align: center; color: #9CA3AF; cursor: pointer; transition: border-color 0.2s; }
+    .drop-zone.drag-over { border-color: #4682B4; background: #f0f7ff; }
+    .drop-zone p { margin: 0; }
+    .file-label { color: #4682B4; cursor: pointer; text-decoration: underline; }
+    #file-list { margin-top: 8px; font-size: 13px; color: #374151; text-align: left; }
+    #file-list div { padding: 2px 0; }
+    #start-btn { width: 100%; padding: 10px; background: #4682B4; color: white; border: none; border-radius: 4px; font-family: inherit; font-size: 14px; cursor: pointer; margin-top: 8px; }
+    #start-btn:disabled { background: #D1D5DB; cursor: default; }
+    #start-btn:not(:disabled):hover { background: #3a6f9a; }
+    #chat-panel { padding-top: 8px; }
+</style>
+<script>
+(function() {
+    var API_BASE = window.location.origin;
+    var tokenInput = document.getElementById('token-input');
+    var fileInput = document.getElementById('file-input');
+    var dropZone = document.getElementById('drop-zone');
+    var fileList = document.getElementById('file-list');
+    var startBtn = document.getElementById('start-btn');
+    var setupPanel = document.getElementById('setup-panel');
+    var chatPanel = document.getElementById('chat-panel');
+    var chatInput = document.getElementById('chat-input');
+    var chatHistory = document.getElementById('chat-history');
+    var sessionCostEl = document.getElementById('session-cost');
+
+    var selectedFiles = [];
+    var workspacePath = '';
+    var scratchPath = '';
+    var sessionCost = 0;
+
+    function updateStartBtn() {
+        startBtn.disabled = !(selectedFiles.length > 0);
+    }
+
+    function showFiles() {
+        fileList.innerHTML = selectedFiles.map(function(f) { return '<div>' + escapeHtml(f.name) + '</div>'; }).join('');
+        updateStartBtn();
+    }
+
+    fileInput.addEventListener('change', function() {
+        selectedFiles = Array.from(fileInput.files);
+        showFiles();
+    });
+
+    dropZone.addEventListener('click', function() { fileInput.click(); });
+    dropZone.addEventListener('dragover', function(e) { e.preventDefault(); dropZone.classList.add('drag-over'); });
+    dropZone.addEventListener('dragleave', function() { dropZone.classList.remove('drag-over'); });
+    dropZone.addEventListener('drop', function(e) {
+        e.preventDefault();
+        dropZone.classList.remove('drag-over');
+        selectedFiles = Array.from(e.dataTransfer.files);
+        showFiles();
+    });
+
+    startBtn.addEventListener('click', function() {
+        startBtn.disabled = true;
+        startBtn.textContent = 'Uploading...';
+
+        var formData = new FormData();
+        selectedFiles.forEach(function(f) { formData.append('files', f); });
+
+        fetch(API_BASE + '/gradio_api/call/upload', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ data: [tokenInput.value] })
+        })
+        .then(function(r) { return r.json(); })
+        .then(function(result) {
+            return fetch(API_BASE + '/gradio_api/call/upload/' + result.event_id);
+        })
+        .then(function(r) { return r.text(); })
+        .then(function() {
+            setupPanel.style.display = 'none';
+            chatPanel.style.display = 'block';
+            chatInput.focus();
+        })
+        .catch(function() {
+            startBtn.disabled = false;
+            startBtn.textContent = 'Start exploring';
+        });
+    });
+
+    chatInput.addEventListener('keydown', function(e) {
+        if (e.key !== 'Enter' || !chatInput.value.trim() || chatInput.disabled) return;
+        e.preventDefault();
+        var question = chatInput.value.trim();
+        chatInput.value = '';
+        chatInput.disabled = true;
+        chatInput.placeholder = '';
+
+        var turn = document.createElement('div');
+        turn.className = 'chat-turn';
+        turn.innerHTML = '<div class="chat-question">' + escapeHtml(question) + '</div>';
+        chatHistory.appendChild(turn);
+
+        var answerEl = document.createElement('div');
+        answerEl.className = 'chat-answer';
+        turn.appendChild(answerEl);
+        var accumulated = '';
+        var toolCount = 0;
+
+        fetch(API_BASE + '/gradio_api/call/ask', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ data: [question, workspacePath, scratchPath, sessionCost, tokenInput.value] })
+        })
+        .then(function(r) { return r.json(); })
+        .then(function(result) {
+            var eventSource = new EventSource(API_BASE + '/gradio_api/call/ask/' + result.event_id);
+
+            function handleEvent(e) {
+                var raw = JSON.parse(e.data);
+                var eventData = JSON.parse(Array.isArray(raw) ? raw[0] : raw);
+
+                if (eventData.type === 'delta') {
+                    accumulated += eventData.content;
+                    answerEl.innerHTML = markdownToHtml(accumulated);
+                    answerEl.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
+                } else if (eventData.type === 'tool_call') {
+                    toolCount = eventData.count;
+                    answerEl.innerHTML = '<em class="chat-tool-status">Exploring documents (' + toolCount + ' tool calls)...</em>';
+                    accumulated = '';
+                } else if (eventData.type === 'error') {
+                    eventSource.close();
+                    answerEl.innerHTML = '<span class="chat-error">' + escapeHtml(eventData.error) + '</span>';
+                    chatInput.disabled = false;
+                    chatInput.placeholder = 'Ask a question about your documents...';
+                } else if (eventData.type === 'done') {
+                    eventSource.close();
+                    var finalHtml = '<div class="chat-answer">' + markdownToHtml(eventData.answer || accumulated) + '</div>';
+                    finalHtml += renderSources(eventData.sources);
+                    if (eventData.stats) {
+                        finalHtml += '<div class="chat-stats">' + eventData.stats + '</div>';
+                    }
+                    if (eventData.trace_html) {
+                        finalHtml += '<button class="chat-trace-toggle" onclick="this.nextElementSibling.classList.toggle(\'open\')">trace</button>';
+                        finalHtml += '<div class="chat-trace">' + eventData.trace_html + '</div>';
+                    }
+                    turn.innerHTML = '<div class="chat-question">' + escapeHtml(question) + '</div>' + finalHtml;
+
+                    if (eventData.workspace_path) workspacePath = eventData.workspace_path;
+                    if (eventData.scratch_path) scratchPath = eventData.scratch_path;
+                    if (eventData.session_cost != null) {
+                        sessionCost = eventData.session_cost;
+                        sessionCostEl.textContent = 'Session cost: $' + sessionCost.toFixed(4);
+                    }
+
+                    chatInput.disabled = false;
+                    chatInput.placeholder = 'Ask a question about your documents...';
+                    chatInput.focus({ preventScroll: true });
+                }
+            }
+
+            eventSource.addEventListener('generating', handleEvent);
+            eventSource.addEventListener('complete', handleEvent);
+
+            eventSource.onerror = function() {
+                eventSource.close();
+                if (!accumulated) {
+                    answerEl.innerHTML = '<span class="chat-error">Connection error.</span>';
+                }
+                chatInput.disabled = false;
+                chatInput.placeholder = 'Ask a question about your documents...';
+            };
+        })
+        .catch(function() {
+            turn.innerHTML += '<div class="chat-error">Connection error.</div>';
+            chatInput.disabled = false;
+            chatInput.placeholder = 'Ask a question about your documents...';
+        });
+    });
+})();
+</script>
+"""
 
 
 def build_app() -> gr.Blocks:
-    with gr.Blocks(title="Document Explorer", theme=gr.themes.Soft()) as demo:
-        gr.Markdown("# Document Explorer")
-
-        with gr.Tabs():
-            with gr.Tab("Chat"):
-                gr.Markdown(
-                    "Upload text or CSV files, then ask questions. "
-                    "The model explores your documents by writing and running Python code."
-                )
+    with gr.Blocks(title="Document Explorer") as demo:
+        gr.HTML(CUSTOM_HTML)
+
+        # Hidden state for file upload workspace
+        upload_workspace = gr.State("")
+
+        # Streaming ask endpoint
+        api_ask_input = [
+            gr.Textbox(visible=False),  # question
+            gr.Textbox(visible=False),  # workspace_path
+            gr.Textbox(visible=False),  # scratch_path
+            gr.Number(visible=False),   # session_cost
+            gr.Textbox(visible=False),  # token
+        ]
+        api_ask_output = gr.Textbox(visible=False)
+
+        def api_ask_stream(question, workspace_path, scratch_path, session_cost, token):
+            for event_json in stream_question(
+                question, workspace_path, scratch_path, session_cost, token
+            ):
+                yield event_json
+
+        api_ask_btn = gr.Button(visible=False)
+        api_ask_btn.click(
+            api_ask_stream,
+            inputs=api_ask_input,
+            outputs=api_ask_output,
+            api_name="ask",
+        )
 
-                workspace_state = gr.State("")
-                scratch_state = gr.State("")
-                cost_state = gr.State(0.0)
-                session_traces_state = gr.State([])  # filenames uploaded this session
-
-                with gr.Row():
-                    token_input = gr.Textbox(
-                        placeholder="Access token",
-                        label="Access Token",
-                        type="password",
-                        scale=1,
-                    )
-
-                with gr.Accordion("Upload documents", open=True):
-                    file_upload = gr.File(
-                        label="Text, CSV, Markdown, or JSON files",
-                        file_count="multiple",
-                        file_types=[".txt", ".csv", ".md", ".json"],
-                    )
-
-                chatbot = gr.Chatbot(height=500)
-                msg = gr.Textbox(
-                    placeholder="Ask a question about your documents...",
-                    label="",
-                    show_label=False,
-                )
+        # Upload endpoint (validates token, returns confirmation)
+        upload_input = gr.Textbox(visible=False)
+        upload_output = gr.Textbox(visible=False)
 
-                with gr.Accordion("Trace", open=False, visible=False) as trace_accordion:
-                    trace_display = gr.HTML("")
-
-                def respond(
-                    message, history, files, workspace_path, scratch_path,
-                    session_cost, session_traces, token,
-                ):
-                    history = history or []
-                    history.append({"role": "user", "content": message})
-
-                    for response, trace_html, wp, sp, sc, trace_file in chat(
-                        message, files, workspace_path, scratch_path, session_cost, token
-                    ):
-                        if trace_file:
-                            session_traces = [*session_traces, trace_file]
-                        history_with_response = [
-                            *history,
-                            {"role": "assistant", "content": response},
-                        ]
-                        accordion = gr.Accordion(visible=bool(trace_html))
-                        yield (
-                            history_with_response, "", trace_html, accordion,
-                            wp, sp, sc, session_traces,
-                        )
-
-                msg.submit(
-                    respond,
-                    inputs=[
-                        msg,
-                        chatbot,
-                        file_upload,
-                        workspace_state,
-                        scratch_state,
-                        cost_state,
-                        session_traces_state,
-                        token_input,
-                    ],
-                    outputs=[
-                        chatbot,
-                        msg,
-                        trace_display,
-                        trace_accordion,
-                        workspace_state,
-                        scratch_state,
-                        cost_state,
-                        session_traces_state,
-                    ],
-                )
+        def api_upload(token):
+            if ACCESS_TOKEN and token != ACCESS_TOKEN:
+                return json.dumps({"error": "Invalid access token."})
+            return json.dumps({"ok": True})
 
-            with gr.Tab("Traces") as traces_tab:
-                admin_state = gr.State(False)
-                trace_dropdown = gr.Dropdown(
-                    choices=[],
-                    label="Select trace",
-                )
-                refresh_btn = gr.Button("Refresh")
-                trace_viewer = gr.HTML("")
-
-                def check_admin(request: gr.Request):
-                    token = request.query_params.get("admin", "")
-                    return ADMIN_TOKEN and token == ADMIN_TOKEN
-
-                def show_trace(filename):
-                    result = fetch_trace(filename)
-                    if not result:
-                        return ""
-                    return render_trace(result, max_chars=5000)
-
-                def refresh_traces(session_traces, is_admin):
-                    if is_admin:
-                        filenames = list_traces()
-                    else:
-                        filenames = sorted(session_traces, reverse=True)
-                    return gr.Dropdown(
-                        choices=filenames,
-                        value=filenames[0] if filenames else None,
-                    )
-
-                demo.load(
-                    check_admin,
-                    outputs=[admin_state],
-                )
+        upload_btn = gr.Button(visible=False)
+        upload_btn.click(api_upload, inputs=upload_input, outputs=upload_output, api_name="upload")
+
+        # Document viewer endpoint
+        doc_input = gr.Textbox(visible=False)
+        doc_output = gr.Textbox(visible=False)
+
+        def api_get_doc(filename):
+            return json.dumps({"error": "not available"})
+
+        doc_btn = gr.Button(visible=False)
+        doc_btn.click(api_get_doc, inputs=doc_input, outputs=doc_output, api_name="doc")
+
+        # Trace list endpoint
+        traces_input = gr.Textbox(visible=False)
+        traces_output = gr.Textbox(visible=False)
 
-                trace_dropdown.change(
-                    show_trace,
-                    inputs=[trace_dropdown],
-                    outputs=[trace_viewer],
+        def api_list_traces(query):
+            if not hf_api or not HF_TRACES_REPO:
+                return json.dumps({"error": "traces not configured"})
+            try:
+                files = hf_api.list_repo_files(
+                    repo_id=HF_TRACES_REPO, repo_type="dataset"
                 )
-                refresh_btn.click(
-                    refresh_traces,
-                    inputs=[session_traces_state, admin_state],
-                    outputs=[trace_dropdown],
+                traces = sorted(
+                    [f for f in files if f.endswith(".json")], reverse=True
                 )
-                traces_tab.select(
-                    refresh_traces,
-                    inputs=[session_traces_state, admin_state],
-                    outputs=[trace_dropdown],
+                if query:
+                    traces = [f for f in traces if query.lower() in f.lower()]
+                return json.dumps({"traces": traces[:100]})
+            except Exception as exc:
+                return json.dumps({"error": str(exc)})
+
+        traces_btn = gr.Button(visible=False)
+        traces_btn.click(api_list_traces, inputs=traces_input, outputs=traces_output, api_name="traces")
+
+        # Trace replay endpoint
+        replay_input = gr.Textbox(visible=False)
+        replay_output = gr.Textbox(visible=False)
+
+        def api_get_trace(filename):
+            if not hf_api or not HF_TRACES_REPO or not filename:
+                return json.dumps({"error": "not found"})
+            safe_name = Path(filename).name
+            try:
+                path = hf_api.hf_hub_download(
+                    HF_TRACES_REPO, safe_name, repo_type="dataset"
                 )
+                data = json.loads(Path(path).read_text())
+                trace = data.get("trace", {})
+                raw_answer = trace.get("answer", "")
+                clean_answer, sources = process_citations(raw_answer, None)
+                trace_html = render_trace(data, max_chars=2000)
+                return json.dumps({
+                    "question": data.get("question", ""),
+                    "answer": clean_answer,
+                    "sources": sources,
+                    "stats": format_stats_from_trace(trace),
+                    "source_tag": data.get("source", ""),
+                    "trace_html": trace_html,
+                    "filename": safe_name,
+                })
+            except Exception as exc:
+                return json.dumps({"error": str(exc)})
+
+        replay_btn = gr.Button(visible=False)
+        replay_btn.click(api_get_trace, inputs=replay_input, outputs=replay_output, api_name="replay")
 
     return demo
 
@@ -362,4 +550,4 @@ if __name__ == "__main__":
         print("WARNING: LH_ACCESS_TOKEN not set — app is unprotected")
 
     app = build_app()
-    app.launch()
+    app.launch(server_name="0.0.0.0", server_port=7860)

requirements.txt

@@ -1,6 +1,6 @@
 click>=8.1
 litellm @ git+https://github.com/BerriAI/litellm.git
-a-simple-llm-harness @ git+https://github.com/chuckfinca/a-simple-llm-harness.git
+a-simple-llm-harness @ git+https://github.com/chuckfinca/a-simple-llm-harness.git@acfd4f2
 e2b-code-interpreter>=2.5
 huggingface-hub
 python-dotenv

static/.gitkeep

@@ -0,0 +1 @@
+.gitkeep