Initial upload: Vision Base MiniCPM-V 4.6 demo suite

Four apps (Allergen Lens, Fridge Dinner, Object Oracle, What's That Error)
switchable via APP_ID env var, running on ZeroGPU.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.pyc
+*.pyo
+.venv/
+.env

app.py

@@ -0,0 +1,223 @@
+# ─────────────────────────────────────────────────────────────────────────────
+# Deploy each app by setting APP_ID before launching:
+#
+#   APP_ID=allergen_lens   python app.py   # food label scanner
+#   APP_ID=fridge_dinner   python app.py   # fridge-to-dinner planner
+#   APP_ID=object_oracle   python app.py   # tarot-style reading
+#   APP_ID=whats_that_error python app.py  # error code fixer
+#
+# On Hugging Face Spaces: set APP_ID in Space → Settings → Variables & Secrets.
+# ─────────────────────────────────────────────────────────────────────────────
+
+import spaces  # MUST be the first import for ZeroGPU
+
+import os
+from pathlib import Path
+
+import gradio as gr
+from PIL import Image
+
+from core.apps import APP_REGISTRY, _error_html, _error_updates
+from core.model import vision_infer
+from core.parse import parse_json
+
+# ── Config ────────────────────────────────────────────────────────────────────
+
+APP_ID = os.environ.get("APP_ID", "allergen_lens")
+if APP_ID not in APP_REGISTRY:
+    raise ValueError(f"Unknown APP_ID '{APP_ID}'. Choose from: {list(APP_REGISTRY)}")
+
+spec = APP_REGISTRY[APP_ID]
+
+# ── Image helpers ─────────────────────────────────────────────────────────────
+
+def _pil(item) -> "Image.Image | None":
+    if item is None:
+        return None
+    if isinstance(item, Image.Image):
+        return item.convert("RGB")
+    if isinstance(item, str) and Path(item).exists():
+        return Image.open(item).convert("RGB")
+    if isinstance(item, (list, tuple)) and len(item) >= 1:
+        return _pil(item[0])
+    if hasattr(item, "__array__"):
+        import numpy as np
+        arr = item if isinstance(item, np.ndarray) else item.__array__()
+        return Image.fromarray(arr).convert("RGB")
+    return None
+
+
+def _collect_images(raw) -> list:
+    if raw is None:
+        return []
+    if not isinstance(raw, (list, tuple)):
+        img = _pil(raw)
+        return [img] if img else []
+    imgs = [_pil(item) for item in raw]
+    return [i for i in imgs if i is not None]
+
+
+# ── Status constants ──────────────────────────────────────────────────────────
+
+_STATUS_WARM = "⏳ Warming up the model — first run takes a few seconds…"
+_STATUS_CLEAR = ""
+
+# ── Inference handler (generator — enables warm-up status) ────────────────────
+
+def _run(image_input, *extra_inputs):
+    """
+    Generator so we can yield the warm-up message before the GPU call blocks,
+    then yield the result (+ cleared status) when done.
+    Outputs: [status_md] + one gr.update per spec.output_components entry.
+    """
+    n_out = len(spec.output_components)
+
+    # Phase 1: show warm-up status immediately; leave result components unchanged
+    yield [gr.update(value=_STATUS_WARM)] + [gr.update()] * n_out
+
+    images = _collect_images(image_input)
+    if not images:
+        yield [gr.update(value=_STATUS_CLEAR)] + _error_updates(
+            n_out, "Please upload at least one image."
+        )
+        return
+
+    instruction = spec.instruction_fn(*extra_inputs)
+
+    try:
+        raw = vision_infer(
+            images=images,
+            instruction=instruction,
+            json_mode=(spec.output_mode == "json"),
+            max_tokens=spec.max_tokens,
+        )
+    except Exception as exc:
+        yield [gr.update(value=_STATUS_CLEAR)] + _error_updates(n_out, f"Inference error: {exc}")
+        return
+
+    data = parse_json(raw) if spec.output_mode == "json" else raw
+    updates = spec.render_fn(data)
+
+    # Phase 2: clear status, deliver result
+    yield [gr.update(value=_STATUS_CLEAR)] + updates
+
+
+# ── UI builder (generic — driven entirely by AppSpec) ─────────────────────────
+
+def _build_output_components(component_types: list[str]) -> list:
+    """Create one Gradio component per declared output slot."""
+    comps = []
+    for kind in component_types:
+        if kind == "html":
+            comps.append(
+                gr.HTML(
+                    value=(
+                        '<div style="min-height:180px;display:flex;align-items:center;'
+                        'justify-content:center;color:#aaa;font-family:system-ui;font-size:15px">'
+                        'Upload an image and click Analyze ✦'
+                        '</div>'
+                    )
+                )
+            )
+        elif kind == "markdown":
+            comps.append(gr.Markdown(""))
+        else:
+            comps.append(gr.HTML(""))
+    return comps
+
+
+def build_demo(spec) -> gr.Blocks:
+    css = """
+    .submit-btn { font-size: 16px !important; padding: 12px 0 !important; }
+    footer { display: none !important; }
+    """
+
+    with gr.Blocks(title=spec.title, css=css, theme=gr.themes.Soft()) as demo:
+        gr.HTML(
+            f'<div style="padding:16px 0 8px">'
+            f'<h1 style="margin:0;font-size:26px">{spec.title}</h1>'
+            f'<p style="margin:4px 0 0;color:#555;font-size:15px">{spec.tagline}</p>'
+            f'</div>'
+        )
+
+        # Shared status indicator — one per page, always present
+        status_md = gr.Markdown(_STATUS_CLEAR, visible=True)
+
+        with gr.Row(equal_height=False):
+            # ── Left column: inputs ───────────────────────────────────────────
+            with gr.Column(scale=1):
+                image_comp = gr.Image(
+                    label="Upload image",
+                    type="pil",
+                    sources=["upload", "webcam", "clipboard"],
+                    height=300,
+                )
+
+                extra_comps = []
+
+                if spec.input_spec.text_label:
+                    text_comp = gr.Textbox(
+                        label=spec.input_spec.text_label,
+                        placeholder=spec.input_spec.text_placeholder,
+                        lines=2,
+                    )
+                    extra_comps.append(text_comp)
+
+                if spec.input_spec.dropdown_choices:
+                    drop_comp = gr.Dropdown(
+                        choices=spec.input_spec.dropdown_choices,
+                        value=spec.input_spec.dropdown_default,
+                        label=spec.input_spec.dropdown_label,
+                    )
+                    extra_comps.append(drop_comp)
+
+                submit = gr.Button("Analyze ✦", variant="primary", elem_classes=["submit-btn"])
+
+            # ── Right column: outputs (built from spec) ───────────────────────
+            with gr.Column(scale=1):
+                output_comps = _build_output_components(spec.output_components)
+
+        all_inputs = [image_comp] + extra_comps
+        all_outputs = [status_md] + output_comps
+
+        submit.click(fn=_run, inputs=all_inputs, outputs=all_outputs)
+
+        # Reset outputs when a new image is uploaded
+        def _on_image_change(*_):
+            placeholder = (
+                '<div style="min-height:180px;display:flex;align-items:center;'
+                'justify-content:center;color:#aaa;font-family:system-ui">'
+                'Click Analyze ✦ to process</div>'
+            )
+            return [gr.update(value=_STATUS_CLEAR)] + [
+                gr.update(value=placeholder) for _ in spec.output_components
+            ]
+
+        image_comp.change(fn=_on_image_change, inputs=[image_comp], outputs=all_outputs)
+
+        # Examples (only when local files exist)
+        valid_examples = [
+            row for row in spec.examples
+            if row and Path(str(row[0])).exists()
+        ]
+        if valid_examples:
+            gr.Examples(
+                examples=valid_examples,
+                inputs=all_inputs,
+                label="Try an example",
+                cache_examples=False,
+            )
+
+        gr.HTML(
+            '<div style="text-align:center;color:#aaa;font-size:12px;margin-top:16px">'
+            f'Powered by <b>MiniCPM-V 4.6 (1.3B)</b> · ZeroGPU · App: <code>{APP_ID}</code>'
+            '</div>'
+        )
+
+    return demo
+
+
+demo = build_demo(spec)
+
+if __name__ == "__main__":
+    demo.launch(show_error=True)

core/apps.py

@@ -0,0 +1,439 @@
+import gradio as gr
+from dataclasses import dataclass, field
+from typing import Callable, List, Optional
+
+
+@dataclass
+class InputSpec:
+    multi_image: bool = False
+    text_label: Optional[str] = None
+    text_placeholder: str = ""
+    dropdown_choices: Optional[List[str]] = None
+    dropdown_label: str = ""
+    dropdown_default: str = ""
+
+
+@dataclass
+class AppSpec:
+    app_id: str
+    title: str
+    tagline: str
+    # instruction_fn(*extra_inputs) -> str   (extra_inputs = text + dropdown, if present)
+    instruction_fn: Callable
+    output_mode: str                 # "text" | "json"
+    input_spec: InputSpec
+    max_tokens: int                  # floor 512 (oracle) or 1024 (JSON apps)
+    examples: List[List]             # Gradio examples rows; each row matches inputs order
+    # render_fn(result: str|dict|list) -> list[gr.update], one per output_components entry
+    render_fn: Callable
+    output_components: List[str] = field(default_factory=lambda: ["html"])
+    theme_color: str = "#5c6bc0"
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Shared render helpers
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _card(body: str, border_color: str = "#5c6bc0", bg: str = "#fafafa") -> str:
+    return (
+        f'<div style="border-left:5px solid {border_color};padding:20px 24px;'
+        f'background:{bg};border-radius:8px;font-family:system-ui,sans-serif">'
+        f"{body}</div>"
+    )
+
+
+def _error_html(msg: str) -> str:
+    return _card(
+        f"<p style='color:#c62828;margin:0'><b>Error:</b> {msg}</p>",
+        "#c62828",
+        "#fff8f8",
+    )
+
+
+def _error_updates(n_components: int, msg: str) -> list:
+    """n_components gr.update objects; error goes in slot 0 (always an html component)."""
+    updates = [gr.update(value=_error_html(msg))]
+    updates += [gr.update()] * (n_components - 1)
+    return updates
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 1. allergen_lens
+# ─────────────────────────────────────────────────────────────────────────────
+
+_ALLERGEN_SCHEMA = (
+    '{"allergens": ["peanuts", "..."], '
+    '"dietary": {"vegetarian": true, "vegan": false, "gluten_free": false}, '
+    '"prep_instructions": "...", '
+    '"verdict": "Safe to eat" | "Contains allergens" | "Check carefully"}'
+)
+
+_ALLERGEN_LANGUAGES = [
+    "English", "Spanish", "French", "German", "Portuguese",
+    "Italian", "Japanese", "Korean", "Chinese (Simplified)", "Arabic",
+]
+
+
+def _allergen_instruction(allergies: str = "", language: str = "English") -> str:
+    prompt = (
+        "You are a food-safety assistant. Analyze this food product label image.\n"
+        "Extract ALL allergen information (common allergens: peanuts, tree nuts, milk, eggs, "
+        "wheat/gluten, soy, fish, shellfish, sesame).\n"
+        "Determine vegetarian / vegan / gluten-free status.\n"
+        "Extract preparation instructions if visible.\n"
+    )
+    if allergies.strip():
+        prompt += (
+            f"\nThe user has these dietary restrictions / allergies: {allergies.strip()}\n"
+            "Set 'verdict' to 'Contains allergens' if any of the user's allergens are present, "
+            "'Safe to eat' if none are present, or 'Check carefully' if unsure.\n"
+        )
+    else:
+        prompt += "\nSet 'verdict' to a general safety summary.\n"
+    prompt += f"\nRespond in {language}.\n"
+    prompt += f"\nOutput schema: {_ALLERGEN_SCHEMA}"
+    return prompt
+
+
+def _allergen_render(data) -> list:
+    if isinstance(data, dict) and "error" in data:
+        return [gr.update(value=_error_html(data.get("raw", data["error"])))]
+
+    verdict = data.get("verdict", "Unknown")
+    allergens = data.get("allergens", [])
+    dietary = data.get("dietary", {})
+    prep = data.get("prep_instructions", "")
+
+    has_allergens = bool(allergens)
+    border = "#c62828" if has_allergens else "#2e7d32"
+    verdict_bg = "#ffebee" if has_allergens else "#e8f5e9"
+    verdict_color = "#c62828" if has_allergens else "#2e7d32"
+
+    chips = "".join(
+        f'<span style="display:inline-block;background:#ef5350;color:white;'
+        f'padding:3px 10px;border-radius:12px;margin:3px 3px 3px 0;font-size:13px">{a}</span>'
+        for a in allergens
+    )
+    if not chips:
+        chips = '<span style="color:#757575;font-style:italic">None detected</span>'
+
+    dietary_icons = []
+    if dietary.get("vegetarian"):
+        dietary_icons.append("🥬 Vegetarian")
+    if dietary.get("vegan"):
+        dietary_icons.append("🌱 Vegan")
+    if dietary.get("gluten_free"):
+        dietary_icons.append("✓ Gluten-Free")
+    dietary_text = " &nbsp;·&nbsp; ".join(dietary_icons) if dietary_icons else "No special designations"
+
+    prep_section = (
+        f'<div style="margin-top:14px">'
+        f'<b style="color:#555">Preparation:</b> '
+        f'<span style="color:#333">{prep}</span></div>'
+        if prep else ""
+    )
+
+    body = (
+        f'<div style="background:{verdict_bg};border-radius:6px;padding:12px 16px;margin-bottom:16px">'
+        f'<span style="font-size:22px;font-weight:700;color:{verdict_color}">{verdict}</span>'
+        f'</div>'
+        f'<div style="margin-bottom:12px"><b style="color:#555">Allergens found:</b><br/>{chips}</div>'
+        f'<div><b style="color:#555">Dietary:</b> {dietary_text}</div>'
+        f'{prep_section}'
+    )
+    return [gr.update(value=_card(body, border))]
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 2. fridge_dinner
+# ─────────────────────────────────────────────────────────────────────────────
+
+_FRIDGE_SCHEMA = (
+    '{"available": ["eggs", "spinach", "cheddar", "..."], '
+    '"dinners": ['
+    '  {"name": "Spinach Omelette", "uses": ["eggs", "spinach", "cheddar"]}, '
+    '  {"name": "...", "uses": [...]}, '
+    '  {"name": "...", "uses": [...]}'
+    '], '
+    '"use_soon": ["open yogurt", "wilted lettuce", "..."]}'
+)
+
+_DINNER_PALETTE = [
+    ("#1565c0", "#e3f2fd", "🍳"),
+    ("#2e7d32", "#e8f5e9", "🥘"),
+    ("#6a1b9a", "#f3e5f5", "🍲"),
+]
+
+
+def _fridge_instruction() -> str:
+    return (
+        "You are a creative home chef. Carefully look at this photo of an open fridge or pantry.\n"
+        "1. List ALL visible ingredients and food items you can identify "
+        "(be specific: 'Greek yogurt' not 'dairy', '2% milk' not 'milk').\n"
+        "2. Suggest EXACTLY THREE dinner ideas using ONLY what is visible — "
+        "no grocery run required. For each dinner, list which visible ingredients it uses.\n"
+        "3. Flag any items that look like they should be used soon: "
+        "opened packages, produce past peak freshness, leftovers, etc.\n"
+        f"Output schema (JSON only): {_FRIDGE_SCHEMA}"
+    )
+
+
+def _fridge_render(data) -> list:
+    if isinstance(data, dict) and "error" in data:
+        return [gr.update(value=_error_html(data.get("raw", data["error"])))]
+
+    available = data.get("available", [])
+    dinners = data.get("dinners", [])
+    use_soon = data.get("use_soon", [])
+
+    # Three dinner cards
+    cards_html = ""
+    for i, dinner in enumerate(dinners[:3]):
+        name = dinner.get("name", f"Dinner {i + 1}") if isinstance(dinner, dict) else str(dinner)
+        uses = dinner.get("uses", []) if isinstance(dinner, dict) else []
+        color, bg, emoji = _DINNER_PALETTE[i % len(_DINNER_PALETTE)]
+
+        uses_chips = "".join(
+            f'<span style="background:{color}18;color:{color};border:1px solid {color}44;'
+            f'padding:2px 8px;border-radius:10px;font-size:12px;'
+            f'margin:2px 2px 2px 0;display:inline-block">{ing}</span>'
+            for ing in uses
+        )
+
+        cards_html += (
+            f'<div style="flex:1;min-width:160px;background:{bg};'
+            f'border:2px solid {color}44;border-radius:10px;padding:16px">'
+            f'<div style="font-size:24px;margin-bottom:6px">{emoji}</div>'
+            f'<div style="font-weight:700;font-size:15px;color:{color};margin-bottom:10px">{name}</div>'
+            f'<div style="font-size:11px;color:#757575;margin-bottom:5px;text-transform:uppercase;'
+            f'letter-spacing:.5px">Uses</div>'
+            f'<div>{uses_chips or "<span style=\'color:#aaa;font-size:12px\'>—</span>"}</div>'
+            f'</div>'
+        )
+
+    available_text = ", ".join(available) if available else "Nothing detected"
+
+    use_soon_chips = "".join(
+        f'<span style="background:#fff3e0;color:#e65100;border:1px solid #ff980044;'
+        f'padding:3px 10px;border-radius:10px;font-size:13px;'
+        f'margin:3px 3px 3px 0;display:inline-block">⚠ {item}</span>'
+        for item in use_soon
+    )
+    use_soon_section = (
+        f'<div style="margin-top:20px;padding:14px 16px;background:#fff8e1;'
+        f'border-radius:8px;border-left:4px solid #ffa000">'
+        f'<div style="font-weight:600;color:#e65100;margin-bottom:8px">⏰ Use these soon</div>'
+        f'<div>{use_soon_chips}</div>'
+        f'</div>'
+        if use_soon else ""
+    )
+
+    html = (
+        f'<div style="font-family:system-ui,sans-serif">'
+        f'<div style="font-size:12px;color:#757575;margin-bottom:14px">'
+        f'Spotted: {available_text}</div>'
+        f'<div style="display:flex;gap:12px;flex-wrap:wrap">{cards_html}</div>'
+        f'{use_soon_section}'
+        f'</div>'
+    )
+    return [gr.update(value=html)]
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 3. object_oracle
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _oracle_instruction() -> str:
+    return (
+        "You are the Object Oracle — a mystical seer who reveals the hidden essence of things.\n"
+        "Look at this image and deliver a tarot-style poetic reading.\n"
+        "Rules:\n"
+        "- Clearly reference what is VISIBLY in the photo (name the object, scene, or subject).\n"
+        "- Speak in vivid, poetic language with a mystical/spiritual tone.\n"
+        "- Give the reading a title (e.g. 'The Wandering Teapot', 'Spirit of the Forgotten Key').\n"
+        "- 3-5 sentences maximum. Lead with the title on its own line.\n"
+        "- End with a one-line fortune or warning (prefix with 'Fortune:').\n"
+        "Do NOT mention that you are an AI or a language model."
+    )
+
+
+def _oracle_render(text: str) -> list:
+    lines = text.strip().split("\n", 1)
+    title = lines[0].strip().strip("*#_") if lines else "The Oracle Speaks"
+    body = lines[1].strip() if len(lines) > 1 else text.strip()
+
+    fortune = ""
+    if "Fortune:" in body:
+        parts = body.rsplit("Fortune:", 1)
+        body = parts[0].strip()
+        fortune = parts[1].strip()
+
+    fortune_html = (
+        f'<div style="margin-top:20px;padding:12px 16px;background:rgba(255,255,255,0.1);'
+        f'border-radius:6px;font-style:italic;font-size:14px;color:#f0d080">'
+        f'✦ {fortune} ✦</div>'
+        if fortune else ""
+    )
+
+    html = (
+        '<div style="background:linear-gradient(135deg,#1a1a2e 0%,#16213e 50%,#0f3460 100%);'
+        'color:#e8d5a3;border-radius:14px;padding:32px 36px;font-family:Georgia,serif;'
+        'border:1px solid #e0c97f44;min-height:180px">'
+        f'<div style="text-align:center;font-size:13px;letter-spacing:3px;color:#c9a84c;'
+        f'margin-bottom:16px;text-transform:uppercase">✦ The Oracle Speaks ✦</div>'
+        f'<div style="font-size:20px;font-weight:bold;color:#f0d080;'
+        f'text-align:center;margin-bottom:16px">{title}</div>'
+        f'<div style="font-size:16px;line-height:1.9;color:#e0cfa0;white-space:pre-line">{body}</div>'
+        f'{fortune_html}'
+        f'<div style="text-align:center;margin-top:20px;font-size:22px;color:#c9a84c">⟡</div>'
+        '</div>'
+    )
+    return [gr.update(value=html)]
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 4. whats_that_error
+# ─────────────────────────────────────────────────────────────────────────────
+
+_ERROR_SCHEMA = (
+    '{"detected_code": "E01", "likely_cause": "...", '
+    '"fix_steps": ["Step 1: ...", "Step 2: ..."], "severity": "low|medium|high|critical"}'
+)
+
+_SEVERITY_STYLE = {
+    "low":      ("#2e7d32", "#e8f5e9"),
+    "medium":   ("#e65100", "#fff3e0"),
+    "high":     ("#c62828", "#ffebee"),
+    "critical": ("#6a1b9a", "#f3e5f5"),
+}
+
+
+def _error_instruction(appliance: str = "") -> str:
+    device_hint = f" on a '{appliance.strip()}'" if appliance.strip() else ""
+    return (
+        f"You are an appliance and electronics repair expert.\n"
+        f"Analyze this photo of an error screen, display panel, or error code{device_hint}.\n"
+        f"Identify the error code or fault indicator shown.\n"
+        f"Provide: the exact detected code/indicator, the most likely root cause, "
+        f"clear numbered fix steps a non-expert can follow, and severity level.\n"
+        f"If no code is visible, describe what you see and give general troubleshooting steps.\n"
+        f"Output schema: {_ERROR_SCHEMA}"
+    )
+
+
+def _error_render(data) -> list:
+    if isinstance(data, dict) and "error" in data:
+        return [gr.update(value=_error_html(data.get("raw", data["error"])))]
+
+    code = data.get("detected_code", "Unknown")
+    cause = data.get("likely_cause", "")
+    steps = data.get("fix_steps", [])
+    severity = str(data.get("severity", "medium")).lower()
+
+    color, bg = _SEVERITY_STYLE.get(severity, ("#555", "#f5f5f5"))
+
+    steps_html = "".join(
+        f'<li style="margin:8px 0;color:#333;font-size:14px">{step}</li>'
+        for step in (steps if isinstance(steps, list) else [steps])
+    )
+
+    html = (
+        f'<div style="font-family:system-ui,sans-serif;max-width:620px">'
+        f'<div style="background:{color};color:white;padding:14px 20px;'
+        f'border-radius:8px 8px 0 0;display:flex;align-items:center;gap:12px">'
+        f'<span style="font-size:22px">⚠️</span>'
+        f'<div><div style="font-size:18px;font-weight:700">{code}</div>'
+        f'<div style="font-size:12px;opacity:.85;text-transform:uppercase;letter-spacing:1px">'
+        f'Severity: {severity}</div></div>'
+        f'</div>'
+        f'<div style="border:2px solid {color};border-top:none;border-radius:0 0 8px 8px;'
+        f'padding:18px 20px;background:{bg}">'
+        f'<div style="font-size:13px;font-weight:600;color:#555;margin-bottom:4px">LIKELY CAUSE</div>'
+        f'<p style="margin:0 0 16px;font-size:15px;color:#222">{cause}</p>'
+        f'<div style="font-size:13px;font-weight:600;color:#555;margin-bottom:6px">FIX STEPS</div>'
+        f'<ol style="margin:0;padding-left:22px">{steps_html or "<li>No steps available.</li>"}</ol>'
+        f'</div></div>'
+    )
+    return [gr.update(value=html)]
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# APP_REGISTRY
+# ─────────────────────────────────────────────────────────────────────────────
+
+APP_REGISTRY: dict[str, AppSpec] = {
+    "allergen_lens": AppSpec(
+        app_id="allergen_lens",
+        title="🔍 Allergen Lens",
+        tagline="Snap a food label — get instant allergen & dietary analysis.",
+        instruction_fn=_allergen_instruction,
+        output_mode="json",
+        input_spec=InputSpec(
+            text_label="My allergies / dietary restrictions (optional)",
+            text_placeholder="e.g. peanuts, dairy, gluten",
+            dropdown_choices=_ALLERGEN_LANGUAGES,
+            dropdown_label="Response language",
+            dropdown_default="English",
+        ),
+        max_tokens=1024,
+        examples=[
+            ["examples/allergen_label.jpg", "peanuts, dairy", "English"],
+            ["examples/allergen_label2.jpg", "", "Spanish"],
+        ],
+        render_fn=_allergen_render,
+        output_components=["html"],
+        theme_color="#2e7d32",
+    ),
+
+    "fridge_dinner": AppSpec(
+        app_id="fridge_dinner",
+        title="🍽️ Fridge Dinner",
+        tagline="Photo your fridge — get three dinners you can make right now.",
+        instruction_fn=_fridge_instruction,
+        output_mode="json",
+        input_spec=InputSpec(),
+        max_tokens=1024,
+        examples=[
+            ["examples/fridge_dinner.jpg"],
+        ],
+        render_fn=_fridge_render,
+        output_components=["html"],
+        theme_color="#2e7d32",
+    ),
+
+    "object_oracle": AppSpec(
+        app_id="object_oracle",
+        title="🔮 Object Oracle",
+        tagline="Hold up any object — receive its mystical reading.",
+        instruction_fn=_oracle_instruction,
+        output_mode="text",
+        input_spec=InputSpec(),
+        max_tokens=512,
+        examples=[
+            ["examples/oracle_object.jpg"],
+        ],
+        render_fn=_oracle_render,
+        output_components=["html"],
+        theme_color="#4a148c",
+    ),
+
+    "whats_that_error": AppSpec(
+        app_id="whats_that_error",
+        title="🛠️ What's That Error?",
+        tagline="Photo your error screen — get a plain-English fix.",
+        instruction_fn=_error_instruction,
+        output_mode="json",
+        input_spec=InputSpec(
+            text_label="Appliance or device name (optional)",
+            text_placeholder="e.g. Samsung washing machine, iPhone, HP printer",
+        ),
+        max_tokens=1024,
+        examples=[
+            ["examples/error_screen.jpg", ""],
+            ["examples/error_screen2.jpg", "LG dishwasher"],
+        ],
+        render_fn=_error_render,
+        output_components=["html"],
+        theme_color="#c62828",
+    ),
+}

core/model.py

@@ -0,0 +1,80 @@
+import spaces  # ZeroGPU: must precede torch/transformers imports
+
+import torch
+from PIL import Image
+from transformers import AutoModelForImageTextToText, AutoProcessor
+
+MODEL_ID = "openbmb/MiniCPM-V-4.6"
+
+processor = AutoProcessor.from_pretrained(MODEL_ID)
+model = AutoModelForImageTextToText.from_pretrained(
+    MODEL_ID,
+    torch_dtype=torch.bfloat16,
+)
+model = model.to("cuda")
+model.eval()
+
+
+def _to_pil(img) -> Image.Image:
+    if isinstance(img, Image.Image):
+        return img.convert("RGB")
+    if hasattr(img, "__array__"):
+        import numpy as np
+        arr = img if isinstance(img, np.ndarray) else img.__array__()
+        return Image.fromarray(arr).convert("RGB")
+    if isinstance(img, str):
+        return Image.open(img).convert("RGB")
+    raise TypeError(f"Cannot convert {type(img)} to PIL Image")
+
+
+@spaces.GPU(duration=120)
+def vision_infer(
+    images,
+    instruction: str,
+    json_mode: bool = False,
+    max_tokens: int = 768,
+) -> str:
+    """Single GPU entrypoint. images: PIL Image or list of PIL Images."""
+    if not isinstance(images, list):
+        images = [images]
+
+    pil_images = [_to_pil(img) for img in images]
+
+    if json_mode:
+        instruction = (
+            instruction
+            + "\n\nRespond with ONLY valid JSON. No markdown fences, no prose, no explanation."
+        )
+
+    content = [{"type": "image", "image": img} for img in pil_images]
+    content.append({"type": "text", "text": instruction})
+
+    messages = [{"role": "user", "content": content}]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt",
+        downsample_mode="16x",
+        max_slice_nums=36,
+    ).to(model.device)
+
+    with torch.no_grad():
+        generated_ids = model.generate(
+            **inputs,
+            downsample_mode="16x",
+            max_new_tokens=max_tokens,
+            do_sample=False,
+        )
+
+    trimmed = [
+        out_ids[len(in_ids):]
+        for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+    ]
+    return processor.batch_decode(
+        trimmed,
+        skip_special_tokens=True,
+        clean_up_tokenization_spaces=False,
+    )[0]

core/parse.py

@@ -0,0 +1,41 @@
+import json
+import re
+
+
+def _strip_fences(text: str) -> str:
+    text = text.strip()
+    text = re.sub(r"^```(?:json)?\s*\n?", "", text, flags=re.MULTILINE)
+    text = re.sub(r"\n?```\s*$", "", text, flags=re.MULTILINE)
+    return text.strip()
+
+
+def _extract_first_json(text: str):
+    """Try to pull the first {...} or [...] block from noisy text."""
+    for pattern in (r"\{[\s\S]*\}", r"\[[\s\S]*\]"):
+        match = re.search(pattern, text)
+        if match:
+            try:
+                return json.loads(match.group())
+            except json.JSONDecodeError:
+                pass
+    return None
+
+
+def parse_json(text: str):
+    """
+    Defensively parse model JSON output.
+    Returns parsed dict/list, or {"error": "...", "raw": "..."} on failure.
+    Never raises.
+    """
+    cleaned = _strip_fences(text)
+
+    try:
+        return json.loads(cleaned)
+    except json.JSONDecodeError:
+        pass
+
+    recovered = _extract_first_json(cleaned)
+    if recovered is not None:
+        return recovered
+
+    return {"error": "Could not parse model output as JSON.", "raw": text[:600]}

requirements.txt

@@ -0,0 +1,8 @@
+gradio>=4.40.0
+spaces>=0.30.0
+transformers>=4.51.0
+torch>=2.1.0
+Pillow>=10.0.0
+accelerate>=0.26.0
+sentencepiece
+torchvision

scripts/fetch_examples.py

@@ -0,0 +1,73 @@
+"""
+Download public-domain example images for all four demo apps.
+Run once before first launch:  python scripts/fetch_examples.py
+"""
+
+import urllib.request
+from pathlib import Path
+
+EXAMPLES_DIR = Path(__file__).parent.parent / "examples"
+EXAMPLES_DIR.mkdir(exist_ok=True)
+
+# Each entry: (local_filename, url, description)
+IMAGES = [
+    # allergen_lens — food labels
+    (
+        "allergen_label.jpg",
+        "https://upload.wikimedia.org/wikipedia/commons/thumb/3/33/Nutrition_facts_label_example.jpg/640px-Nutrition_facts_label_example.jpg",
+        "Nutrition facts label (allergen_lens example 1)",
+    ),
+    (
+        "allergen_label2.jpg",
+        "https://upload.wikimedia.org/wikipedia/commons/thumb/a/a3/Nutritional_labels.jpg/640px-Nutritional_labels.jpg",
+        "Ingredient list label (allergen_lens example 2)",
+    ),
+    # camera_roll_concierge — varied everyday photos
+    (
+        "concierge_receipt.jpg",
+        "https://upload.wikimedia.org/wikipedia/commons/thumb/1/18/Store_receipt.jpg/640px-Store_receipt.jpg",
+        "Receipt photo (camera_roll example)",
+    ),
+    (
+        "concierge_recipe.jpg",
+        "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat_03.jpg/640px-Cat_03.jpg",
+        "Placeholder photo (camera_roll example)",
+    ),
+    # object_oracle — interesting objects
+    (
+        "oracle_object.jpg",
+        "https://upload.wikimedia.org/wikipedia/commons/thumb/4/47/PNG_transparency_demonstration_1.png/280px-PNG_transparency_demonstration_1.png",
+        "Interesting object (oracle example)",
+    ),
+    # whats_that_error — error screens
+    (
+        "error_screen.jpg",
+        "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3b/Windows_9X_BSOD.png/640px-Windows_9X_BSOD.png",
+        "BSOD error screen (whats_that_error example 1)",
+    ),
+    (
+        "error_screen2.jpg",
+        "https://upload.wikimedia.org/wikipedia/commons/thumb/e/e5/Windows_XP_BSOD.png/640px-Windows_XP_BSOD.png",
+        "XP BSOD error screen (whats_that_error example 2)",
+    ),
+]
+
+
+def fetch_all():
+    for filename, url, desc in IMAGES:
+        dest = EXAMPLES_DIR / filename
+        if dest.exists():
+            print(f"  skip  {filename}")
+            continue
+        print(f"  get   {filename} — {desc}")
+        try:
+            urllib.request.urlretrieve(url, dest)
+            print(f"  ok    {filename}")
+        except Exception as exc:
+            print(f"  FAIL  {filename}: {exc}")
+
+
+if __name__ == "__main__":
+    print(f"Downloading examples to {EXAMPLES_DIR} ...")
+    fetch_all()
+    print("Done.")

scripts/generate_examples.py

@@ -0,0 +1,387 @@
+"""
+Generate demo example images using PIL only (no network required).
+Run: python scripts/generate_examples.py
+"""
+
+from pathlib import Path
+from PIL import Image, ImageDraw, ImageFont
+
+EXAMPLES = Path(__file__).parent.parent / "examples"
+EXAMPLES.mkdir(exist_ok=True)
+
+
+def _font(size=16):
+    try:
+        return ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", size)
+    except Exception:
+        try:
+            return ImageFont.truetype("/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf", size)
+        except Exception:
+            return ImageFont.load_default()
+
+
+def _font_bold(size=16):
+    try:
+        return ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", size)
+    except Exception:
+        try:
+            return ImageFont.truetype("/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf", size)
+        except Exception:
+            return ImageFont.load_default()
+
+
+# ── allergen_label.jpg ────────────────────────────────────────────────────────
+
+def make_allergen_label(path: Path):
+    img = Image.new("RGB", (480, 640), "#ffffff")
+    d = ImageDraw.Draw(img)
+
+    # outer border
+    d.rectangle([10, 10, 469, 629], outline="#000000", width=3)
+
+    fb = _font_bold(28)
+    fm = _font(14)
+    fs = _font(11)
+
+    y = 24
+    d.text((240, y), "Nutrition Facts", font=fb, fill="#000", anchor="mt")
+    y += 36
+    d.line([14, y, 466, y], fill="#000", width=2)
+    y += 8
+    d.text((20, y), "Serving Size 1 cup (240ml)", font=fm, fill="#000")
+    y += 22
+    d.text((20, y), "Servings Per Container: 2", font=fm, fill="#000")
+    y += 18
+    d.line([14, y, 466, y], fill="#000", width=6)
+    y += 8
+    d.text((20, y), "Amount Per Serving", font=fs, fill="#000")
+    y += 16
+    d.text((20, y), "Calories", font=_font_bold(20), fill="#000")
+    d.text((300, y), "250", font=_font_bold(30), fill="#000")
+    y += 34
+    d.line([14, y, 466, y], fill="#000", width=3)
+
+    nutrients = [
+        ("Total Fat", "8g", "10%"),
+        ("  Saturated Fat", "3g", "15%"),
+        ("  Trans Fat", "0g", ""),
+        ("Cholesterol", "25mg", "8%"),
+        ("Sodium", "580mg", "25%"),
+        ("Total Carbohydrate", "37g", "13%"),
+        ("  Dietary Fiber", "4g", "14%"),
+        ("  Total Sugars", "12g", ""),
+        ("Protein", "5g", ""),
+    ]
+    for name, amt, pct in nutrients:
+        y += 4
+        d.text((20, y), name, font=fm, fill="#000")
+        d.text((340, y), amt, font=fm, fill="#000")
+        if pct:
+            d.text((420, y), pct, font=fm, fill="#000")
+        y += 18
+        d.line([14, y, 466, y], fill="#cccccc", width=1)
+
+    y += 12
+    d.line([14, y, 466, y], fill="#000", width=6)
+    y += 10
+    d.text((20, y), "INGREDIENTS:", font=_font_bold(13), fill="#000")
+    y += 18
+    ingredients = (
+        "Whole milk, enriched flour (wheat flour, niacin, reduced iron,\n"
+        "thiamine mononitrate, riboflavin, folic acid), sugar, palm oil,\n"
+        "cocoa butter, SOY lecithin, PEANUT oil, modified starch,\n"
+        "salt, vanilla extract, MILK protein concentrate."
+    )
+    for line in ingredients.split("\n"):
+        d.text((20, y), line, font=fs, fill="#000")
+        y += 15
+
+    y += 10
+    d.line([14, y, 466, y], fill="#000", width=2)
+    y += 8
+    allergen_text = "CONTAINS: WHEAT, MILK, SOY, PEANUTS"
+    d.text((240, y), allergen_text, font=_font_bold(13), fill="#cc0000", anchor="mt")
+
+    img.save(path, "JPEG", quality=90)
+    print(f"  created {path.name}")
+
+
+def make_allergen_label2(path: Path):
+    img = Image.new("RGB", (480, 360), "#f9f9f0")
+    d = ImageDraw.Draw(img)
+    d.rectangle([8, 8, 471, 351], outline="#888", width=2)
+    fb = _font_bold(18)
+    fm = _font(13)
+
+    d.text((240, 20), "Ingredients List", font=fb, fill="#222", anchor="mt")
+    d.line([10, 44, 470, 44], fill="#888", width=1)
+
+    lines = [
+        "Water, sugar, modified corn starch, citric acid,",
+        "natural flavors, sodium benzoate, MILK powder,",
+        "caramel color, TREE NUTS (almonds, cashews),",
+        "ascorbic acid (Vitamin C), beta-carotene.",
+        "",
+        "ALLERGEN INFORMATION:",
+        "Contains: MILK, TREE NUTS",
+        "Manufactured in a facility that also processes EGGS.",
+        "",
+        "Vegetarian ✓   Gluten-Free ✓   NOT Vegan (contains milk)",
+    ]
+    y = 56
+    for line in lines:
+        color = "#cc0000" if line.startswith("ALLERGEN") or "Contains:" in line else "#333"
+        bold = line.startswith("ALLERGEN") or line.startswith("Vegetarian")
+        d.text((20, y), line, font=_font_bold(13) if bold else fm, fill=color)
+        y += 20
+
+    img.save(path, "JPEG", quality=90)
+    print(f"  created {path.name}")
+
+
+# ── camera_roll examples ────────────────────────────────────────���─────────────
+
+def make_receipt(path: Path):
+    img = Image.new("RGB", (380, 520), "#fffef8")
+    d = ImageDraw.Draw(img)
+    fb = _font_bold(16)
+    fm = _font(13)
+    fs = _font(11)
+
+    y = 20
+    d.text((190, y), "WHOLE FOODS MARKET", font=fb, fill="#000", anchor="mt")
+    y += 22
+    d.text((190, y), "Store #0472 · San Francisco, CA", font=fs, fill="#555", anchor="mt")
+    y += 18
+    d.text((190, y), "Tel: (415) 555-0192", font=fs, fill="#555", anchor="mt")
+    y += 24
+    d.line([10, y, 370, y], fill="#000", width=1)
+    y += 10
+    d.text((20, y), "Date: 06/13/2026 10:42 AM", font=fs, fill="#333")
+    d.text((370, y), "REG #3", font=fs, fill="#333", anchor="rt")
+    y += 20
+    d.line([10, y, 370, y], fill="#999", width=1)
+    y += 8
+
+    items = [
+        ("Organic Whole Milk 1gal", "5.99"),
+        ("Sourdough Bread", "4.49"),
+        ("Free Range Eggs 12ct", "6.29"),
+        ("Mixed Salad Greens 5oz", "3.99"),
+        ("Sparkling Water 12pk", "11.99"),
+        ("Dark Chocolate 70%", "3.49"),
+        ("Almond Butter 16oz", "8.99"),
+    ]
+    for name, price in items:
+        d.text((20, y), name, font=fm, fill="#222")
+        d.text((360, y), f"${price}", font=fm, fill="#222", anchor="rt")
+        y += 20
+
+    y += 6
+    d.line([10, y, 370, y], fill="#000", width=1)
+    y += 8
+    subtotal = "45.23"
+    tax = "3.62"
+    total = "48.85"
+    for label, val in [("Subtotal", subtotal), ("Tax (8%)", tax)]:
+        d.text((20, y), label, font=fm, fill="#444")
+        d.text((360, y), f"${val}", font=fm, fill="#444", anchor="rt")
+        y += 20
+    d.text((20, y), "TOTAL", font=fb, fill="#000")
+    d.text((360, y), f"${total}", font=fb, fill="#000", anchor="rt")
+    y += 24
+    d.line([10, y, 370, y], fill="#000", width=2)
+    y += 10
+    d.text((190, y), "VISA **** 4821", font=fm, fill="#555", anchor="mt")
+    y += 18
+    d.text((190, y), "Thank you for shopping!", font=fs, fill="#888", anchor="mt")
+
+    img.save(path, "JPEG", quality=90)
+    print(f"  created {path.name}")
+
+
+def make_event_flyer(path: Path):
+    img = Image.new("RGB", (480, 360), "#1a237e")
+    d = ImageDraw.Draw(img)
+
+    d.rectangle([16, 16, 463, 343], outline="#ffffff", width=2)
+    y = 40
+    d.text((240, y), "TECH MEETUP", font=_font_bold(32), fill="#ffeb3b", anchor="mt")
+    y += 50
+    d.text((240, y), "Building Small, Shipping Big", font=_font(18), fill="#e8eaf6", anchor="mt")
+    y += 40
+    d.line([40, y, 440, y], fill="#3949ab", width=1)
+    y += 20
+    details = [
+        ("📅 Date:", "Thursday, June 18, 2026"),
+        ("🕖 Time:", "6:30 PM – 9:00 PM"),
+        ("📍 Venue:", "Hugging Face HQ, NYC"),
+        ("🎟️ RSVP:", "events.hf.co/buildsmall"),
+    ]
+    for label, val in details:
+        d.text((60, y), label, font=_font_bold(14), fill="#90caf9")
+        d.text((175, y), val, font=_font(14), fill="#ffffff")
+        y += 26
+    y += 12
+    d.text((240, y), "Free admission · Light refreshments provided", font=_font(11), fill="#9fa8da", anchor="mt")
+
+    img.save(path, "JPEG", quality=90)
+    print(f"  created {path.name}")
+
+
+def make_screenshot(path: Path):
+    img = Image.new("RGB", (640, 400), "#ffffff")
+    d = ImageDraw.Draw(img)
+
+    # Fake browser chrome
+    d.rectangle([0, 0, 640, 40], fill="#dee1e6")
+    d.ellipse([10, 12, 26, 28], fill="#ff5f57")
+    d.ellipse([34, 12, 50, 28], fill="#febc2e")
+    d.ellipse([58, 12, 74, 28], fill="#28c840")
+    d.rectangle([90, 8, 540, 32], fill="#ffffff", outline="#b8b8b8")
+    d.text((315, 20), "https://news.ycombinator.com", font=_font(12), fill="#555", anchor="mm")
+
+    # Page content
+    y = 60
+    d.text((20, y), "Hacker News", font=_font_bold(22), fill="#ff6600")
+    y += 36
+    stories = [
+        "Show HN: I built a 1.3B VLM that fits in a ZeroGPU Space (748 pts)",
+        "Ask HN: What makes a great hackathon demo? (312 pts)",
+        "MiniCPM-V achieves SOTA on OCRBench at 1.3B params (521 pts)",
+        "The unreasonable effectiveness of small vision models (189 pts)",
+        "From zero to ZeroGPU in 24 hours (245 pts)",
+    ]
+    for i, story in enumerate(stories):
+        d.text((20, y), f"{i+1}.", font=_font(13), fill="#828282")
+        d.text((44, y), story, font=_font(13), fill="#000000")
+        y += 22
+        d.text((44, y), f"{(i+1)*47} points by user{i+1} | {i+2} hours ago | {(i+1)*3} comments", font=_font(11), fill="#828282")
+        y += 24
+
+    img.save(path, "JPEG", quality=90)
+    print(f"  created {path.name}")
+
+
+# ── oracle_object.jpg ─────────────────────────────────────────────────────────
+
+def make_oracle_object(path: Path):
+    img = Image.new("RGB", (480, 480), "#1c1c2e")
+    d = ImageDraw.Draw(img)
+
+    # Draw a stylized antique key
+    cx, cy = 240, 240
+
+    # Key handle — circle
+    d.ellipse([cx-90, cy-180, cx+90, cy-0], outline="#c9a84c", width=8)
+    d.ellipse([cx-55, cy-145, cx+55, cy-35], outline="#c9a84c", width=4)
+    # Key shaft
+    d.rectangle([cx-10, cy-10, cx+10, cy+160], fill="#c9a84c")
+    # Key teeth
+    for offset in [100, 130, 155]:
+        d.rectangle([cx+10, cy+offset, cx+35, cy+offset+14], fill="#c9a84c")
+
+    # Mystical glow effect (concentric ellipses)
+    for r in range(5, 0, -1):
+        alpha = 60 - r * 10
+        color = (201, 168, 76, alpha)
+        size = r * 18
+        d.ellipse([cx-size, cy-size, cx+size, cy+size], outline="#c9a84c33")
+
+    # Stars
+    import random
+    rng = random.Random(42)
+    for _ in range(30):
+        x, y_ = rng.randint(10, 470), rng.randint(10, 60)
+        d.ellipse([x, y_, x+2, y_+2], fill="#ffffff")
+    for _ in range(20):
+        x, y_ = rng.randint(10, 470), rng.randint(390, 470)
+        d.ellipse([x, y_, x+2, y_+2], fill="#ffffff")
+
+    d.text((240, 440), "What does this object reveal?", font=_font(13), fill="#9e8fcc", anchor="mt")
+
+    img.save(path, "JPEG", quality=90)
+    print(f"  created {path.name}")
+
+
+# ── error screens ─────────────────────────────────────────────────────────────
+
+def make_error_screen(path: Path):
+    img = Image.new("RGB", (640, 400), "#0a0aff")
+    d = ImageDraw.Draw(img)
+
+    y = 30
+    d.text((40, y), ":(", font=_font_bold(80), fill="#ffffff")
+    y += 110
+    d.text((40, y), "Your PC ran into a problem and needs to restart.", font=_font_bold(20), fill="#ffffff")
+    y += 36
+    d.text((40, y), "We're just collecting some error info, and then", font=_font(16), fill="#ffffff")
+    y += 24
+    d.text((40, y), "we'll restart for you.", font=_font(16), fill="#ffffff")
+    y += 50
+    d.text((40, y), "100% complete", font=_font(16), fill="#ffffff")
+    y += 40
+    d.text((40, y), "For more information about this issue and possible fixes,", font=_font(13), fill="#ccccff")
+    y += 20
+    d.text((40, y), "visit https://www.windows.com/stopcode", font=_font(13), fill="#ccccff")
+    y += 30
+    d.text((40, y), "Stop code: CRITICAL_PROCESS_DIED", font=_font_bold(14), fill="#ffffff")
+    y += 24
+    d.text((40, y), "What failed: ntoskrnl.exe", font=_font(13), fill="#ccccff")
+
+    img.save(path, "JPEG", quality=90)
+    print(f"  created {path.name}")
+
+
+def make_error_screen2(path: Path):
+    img = Image.new("RGB", (560, 420), "#1a1a1a")
+    d = ImageDraw.Draw(img)
+
+    # Fake washing machine display
+    d.rectangle([20, 20, 540, 400], fill="#222222", outline="#444444", width=3)
+    d.rectangle([40, 40, 520, 200], fill="#001a33", outline="#0066cc", width=2)
+
+    # Display panel
+    d.text((280, 80), "ERROR", font=_font_bold(40), fill="#ff3300", anchor="mt")
+    d.text((280, 130), "E4", font=_font_bold(60), fill="#ff6600", anchor="mt")
+    d.text((280, 195), "DOOR OPEN", font=_font_bold(16), fill="#ffaa00", anchor="mt")
+
+    # Status lights
+    for x, col in [(100, "#ff0000"), (200, "#ff0000"), (300, "#888888"), (400, "#888888")]:
+        d.ellipse([x-8, 220, x+8, 236], fill=col)
+
+    y = 260
+    d.text((280, y), "Samsung WF45T6000AW", font=_font(13), fill="#888888", anchor="mt")
+    y += 22
+    d.text((280, y), "Washing Machine", font=_font(12), fill="#666666", anchor="mt")
+    y += 30
+    d.text((280, y), "Press POWER to reset after fixing", font=_font(11), fill="#555555", anchor="mt")
+
+    # Physical buttons
+    for x, label in [(120, "POWER"), (200, "START"), (290, "PAUSE"), (380, "MODE"), (460, "TEMP")]:
+        d.ellipse([x-20, 330, x+20, 370], fill="#333333", outline="#555555")
+        d.text((x, 395), label, font=_font(9), fill="#666666", anchor="mt")
+
+    img.save(path, "JPEG", quality=90)
+    print(f"  created {path.name}")
+
+
+# ── Main ──────────────────────────────────────────────────────────────────────
+
+TASKS = [
+    ("allergen_label.jpg",  make_allergen_label),
+    ("allergen_label2.jpg", make_allergen_label2),
+    ("concierge_receipt.jpg", make_receipt),
+    ("concierge_event.jpg",   make_event_flyer),
+    ("concierge_screenshot.jpg", make_screenshot),
+    ("oracle_object.jpg",   make_oracle_object),
+    ("error_screen.jpg",    make_error_screen),
+    ("error_screen2.jpg",   make_error_screen2),
+]
+
+if __name__ == "__main__":
+    print(f"Generating examples in {EXAMPLES} ...")
+    for filename, fn in TASKS:
+        p = EXAMPLES / filename
+        fn(p)
+    print("Done.")