Merge pull request #3 from MSghais/feat/next_step_basics

.cursor/plans/skill_agent_pptx_5413e3c2.plan.md

@@ -0,0 +1,230 @@
+---
+name: Skill Agent PPTX
+overview: Add a Hermes-style skill agent library on top of your existing TransformersBackend, with one education PowerPoint task as the first tab in a multi-tab Gradio Space — structured so more task tabs can be added later.
+todos:
+  - id: agent-lib
+    content: "Create libs/agent: SkillRegistry, ToolRegistry, AgentRunner, TraceRecorder, pydantic outline models"
+    status: completed
+  - id: pptx-skill
+    content: Add skills/education-pptx/SKILL.md and create_pptx tool (python-pptx)
+    status: completed
+  - id: gradio-tabs
+    content: "Refactor Gradio app into Tabs: Education PPTX (primary) + Chat (debug)"
+    status: completed
+  - id: docker-workspace
+    content: Wire agent package into uv workspace, Dockerfile, models.yaml active_model
+    status: completed
+  - id: trace-demo
+    content: Add trace JSON export + README demo script for hackathon submission
+    status: completed
+isProject: false
+---
+
+# Skill Agent + Education PowerPoint (Phase 1)
+
+## Goal
+
+Replace the generic chat demo with a **local skill-based agent** that uses your **transformers** presets (default: `minicpm5-1b` or `openbmb/MiniCPM5-1B` from [`models.yaml`](models.yaml)) to run a real workflow: **topic in → slide outline → downloadable `.pptx` out**.
+
+This follows the **agentskills.io / Hermes SKILL.md pattern** without embedding the full Hermes runtime (too heavy for HF Space Docker).
+
+**Hackathon alignment:** Backyard AI (teacher/tutor you know), **Best Agent**, **Tiny Titan** (≤4B), **OpenBMB** (MiniCPM), **Sharing is Caring** (publish trace JSON to Hub), optional **Well-Tuned** if you ship a fine-tuned preset later.
+
+---
+
+## Architecture
+
+```mermaid
+flowchart TB
+  subgraph ui [apps/gradio-space]
+    Tabs[gr.Tabs]
+    EduTab[EducationPptxTab]
+    ChatTab[ChatTab optional later]
+    Tabs --> EduTab
+  end
+
+  subgraph agent [libs/agent]
+    Runner[AgentRunner]
+    Skills[SkillRegistry]
+    Tools[ToolRegistry]
+    Trace[TraceRecorder]
+    Runner --> Skills
+    Runner --> Tools
+    Runner --> Trace
+  end
+
+  subgraph inference [libs/inference]
+    Factory[factory.get_backend]
+    TF[TransformersBackend]
+    Factory --> TF
+  end
+
+  EduTab --> Runner
+  Runner --> Factory
+  Tools --> PptxTool[python-pptx]
+```
+
+**Agent loop (simple, reliable for small models):**
+
+1. Load skill `education-pptx` from `skills/education-pptx/SKILL.md`
+2. User provides: topic, grade level, number of slides (3–8)
+3. **Step A — LLM:** generate structured slide outline (JSON schema in prompt; parse with fallback regex)
+4. **Step B — Tool:** `create_pptx(outline)` writes file via `python-pptx` (deterministic; no LLM needed for file bytes)
+5. **Step C — LLM (optional):** one-sentence “teacher notes” per slide
+6. Return: trace steps + `gr.File` download + markdown preview
+
+Small models are weak at multi-hop tool JSON — keep the loop **fixed 2-step** (outline → tool) rather than open-ended ReAct for v1.
+
+---
+
+## New package: `libs/agent`
+
+Add workspace member `libs/agent` with:
+
+| Module | Responsibility |
+|--------|----------------|
+| `skills.py` | Load `SKILL.md` (YAML frontmatter + body), list skills by `task` tag |
+| `tools.py` | Register callable tools with name, description, JSON schema |
+| `runner.py` | `AgentRunner.run(skill_id, user_input, backend)` — orchestrates LLM + tools |
+| `trace.py` | Append-only step log (`thought`, `tool_call`, `tool_result`, `artifact`) |
+| `prompts.py` | Skill-specific system prompts and JSON outline template |
+
+**Dependencies:** `inference` (workspace), `python-pptx`, `pydantic` (outline validation)
+
+**Extend [`libs/inference/src/inference/base.py`](libs/inference/src/inference/base.py) usage only** — no changes required to `TransformersBackend` beyond optionally bumping `max_tokens` for outline generation via env or per-call kwargs (already supported in [`transformers.py`](libs/inference/src/inference/transformers.py)).
+
+---
+
+## First skill: `skills/education-pptx/SKILL.md`
+
+```markdown
+---
+name: education-pptx
+description: Create a short lesson PowerPoint from a topic and grade level
+task: education
+tools:
+  - create_pptx
+model_hints:
+  - minicpm5-1b
+  - qwen3b-gguf
+---
+
+## Workflow
+1. Ask for topic, audience grade, slide count.
+2. Produce JSON outline: title, slides[{title, bullets[], speaker_note}].
+3. Call create_pptx with validated outline.
+4. Return download link and preview.
+```
+
+---
+
+## First tool: `create_pptx`
+
+Implement in `libs/agent/src/agent/tools/pptx.py`:
+
+- Input: Pydantic model `SlideOutline` (title, slides list)
+- Output: path under `/tmp/agent_outputs/{run_id}.pptx` (HF Space writable temp)
+- Simple template: title slide + bullet slides + optional speaker notes in notes field
+- No images in v1 (keeps scope shippable by June 15)
+
+---
+
+## Gradio UI changes: [`apps/gradio-space/src/gradio_space/app.py`](apps/gradio-space/src/gradio_space/app.py)
+
+Refactor into:
+
+```
+gradio_space/
+  app.py              # build_demo(), launch
+  tabs/
+    __init__.py
+    education_pptx.py # first task tab
+    chat.py           # move existing ChatInterface here (secondary tab)
+```
+
+**Tab 1 — Lesson Slides (primary submission UI):**
+
+- Inputs: Topic, Grade (dropdown), Slides (slider 3–8)
+- Button: Generate
+- Outputs: Markdown outline preview, File download, Agent trace (accordion)
+- Status line: model name + device from existing `warmup()` / `model_status()`
+
+**Tab 2 — Chat (keep for debugging):** existing chat wired to same `ACTIVE_MODEL`
+
+Use `gr.Tabs()` at top level; only Tab 1 needs polish for demo video.
+
+**Model default for Space:** set `active_model: minicpm5-1b` in [`models.yaml`](models.yaml) (OpenBMB + Tiny Titan). Space hardware: GPU basic if transformers on CPU is too slow.
+
+---
+
+## Trace export (Sharing is Caring badge)
+
+After each run, write trace JSON to `outputs/traces/{run_id}.json` and expose a “Copy trace” / optional Hub dataset upload script:
+
+- `scripts/upload_trace.py` — pushes latest trace to a HF dataset repo (manual one-time setup; not required for v1 demo)
+
+Trace schema (minimal):
+
+```json
+{
+  "skill": "education-pptx",
+  "model": "minicpm5-1b",
+  "input": {"topic": "...", "grade": "6", "slides": 5},
+  "steps": [{"type": "llm", "prompt_hash": "...", "output": "..."}, {"type": "tool", "name": "create_pptx", "result": "..."}],
+  "artifact": "lesson_photosynthesis.pptx"
+}
+```
+
+---
+
+## Docker / workspace updates
+
+- [`pyproject.toml`](pyproject.toml): add `agent` workspace member + root dep
+- [`Dockerfile`](Dockerfile): COPY `libs/agent`, `skills/`, update `uv sync`
+- [`apps/gradio-space/pyproject.toml`](apps/gradio-space/pyproject.toml): depend on `agent`
+- Update root [`README.md`](README.md) hackathon story: “Lesson slide builder for a teacher you know”
+
+---
+
+## Phase 2 (after v1 ships — not in first PR)
+
+- New tabs: `tabs/quiz_maker.py`, `tabs/worksheet.py` — each maps to a new `skills/*/SKILL.md`
+- `SkillRegistry` already supports multiple skills; tabs just call `AgentRunner.run(skill_id=...)`
+- **Off-Brand:** custom layout via `gr.Blocks` theming or `gr.Server` if time allows
+- Fine-tuned Gemma preset from [`notebook/gemma-finetune.ipynb`](notebook/gemma-finetune.ipynb) for **Well-Tuned** badge
+
+---
+
+## Demo video script (for submission)
+
+1. Introduce real user (teacher/tutor) and problem: “building a 5-slide lesson takes 30+ minutes”
+2. Enter topic + grade in Tab 1, click Generate (~30–90s on GPU)
+3. Show outline preview + download `.pptx`, open in LibreOffice/Google Slides
+4. Show agent trace proving local model + tool pipeline (no cloud LLM API)
+
+---
+
+## Risks and mitigations
+
+| Risk | Mitigation |
+|------|------------|
+| Small model outputs invalid JSON | Pydantic validate + one repair retry with “fix JSON only” prompt |
+| CPU Space too slow | Pin `minicpm5-1b`, use GPU basic, or fallback `qwen3b-gguf` + llama.cpp for outline-only step |
+| pptx dependency size | `python-pptx` is lightweight (~few MB) |
+| Scope creep (many tabs) | Ship Tab 1 only; stub Tab 2 chat for dev |
+
+---
+
+## Files to create / modify (summary)
+
+**Create:**
+- `libs/agent/` (package + runner, tools, skills loader, trace)
+- `skills/education-pptx/SKILL.md`
+- `apps/gradio-space/src/gradio_space/tabs/education_pptx.py`
+- `apps/gradio-space/src/gradio_space/tabs/chat.py`
+
+**Modify:**
+- [`apps/gradio-space/src/gradio_space/app.py`](apps/gradio-space/src/gradio_space/app.py) — Tabs shell
+- [`models.yaml`](models.yaml) — `active_model: minicpm5-1b` for Space
+- [`Dockerfile`](Dockerfile), [`pyproject.toml`](pyproject.toml), workspace lockfile
+- [`README.md`](README.md) — product story + agent docs

.env.example

@@ -1,25 +1,30 @@
 # --- Preset selection (models.yaml is the source of truth) ---
-ACTIVE_MODEL=qwen3b-gguf
+ACTIVE_MODEL=minicpm5-1b
 # Dev: enable dropdown in Gradio. Space: leave false to pin one model for visitors.
-ALLOW_MODEL_SWITCH=true
+ALLOW_MODEL_SWITCH=false
 # MODEL_PRESETS_PATH=./models.yaml
 
-# --- Legacy single-model overrides (optional; applied to ACTIVE_MODEL only) ---
-INFERENCE_BACKEND=llama_cpp
-MODEL_REPO=Qwen/Qwen2.5-3B-Instruct-GGUF
-MODEL_FILE=qwen2.5-3b-instruct-q4_k_m.gguf
-N_CTX=4096
-N_GPU_LAYERS=0
-
-# Optional: local GGUF path instead of Hub download (set in models.yaml model_path too)
-# MODEL_PATH=./models/qwen2.5-3b-instruct-q4_k_m.gguf
+# --- Agent outputs ---
+# AGENT_OUTPUTS_DIR=/tmp/agent_outputs
+# AGENT_TRACES_DIR=outputs/traces
+# SKILLS_DIR=./skills
 
-# Optional: transformers presets (requires inference[transformers] extra)
-# ACTIVE_MODEL=minicpm5-1b
+# --- Legacy single-model overrides (optional; applied to ACTIVE_MODEL only) ---
 # INFERENCE_BACKEND=transformers
 # MODEL_ID=openbmb/MiniCPM5-1B
 # TRUST_REMOTE_CODE=true
 
+# --- llama.cpp presets (optional) ---
+# ACTIVE_MODEL=qwen3b-gguf
+# INFERENCE_BACKEND=llama_cpp
+# MODEL_REPO=Qwen/Qwen2.5-3B-Instruct-GGUF
+# MODEL_FILE=qwen2.5-3b-instruct-q4_k_m.gguf
+# N_CTX=4096
+# N_GPU_LAYERS=0
+
+# Optional: local GGUF path instead of Hub download
+# MODEL_PATH=./models/qwen2.5-3b-instruct-q4_k_m.gguf
+
 # Optional: local fine-tuned merged weights
 # ACTIVE_MODEL=gemma-merged-local
 # MODEL_ID=./gemma_merged_model

.gitignore

@@ -9,3 +9,5 @@ models/
 *.egg-info/
 dist/
 build/
+
+outputs/traces

Dockerfile

@@ -16,8 +16,11 @@ WORKDIR /app
 COPY pyproject.toml uv.lock .python-version README.md models.yaml ./
 COPY apps/gradio-space/pyproject.toml apps/gradio-space/README.md apps/gradio-space/
 COPY libs/inference/pyproject.toml libs/inference/README.md libs/inference/
+COPY libs/agent/pyproject.toml libs/agent/README.md libs/agent/
 COPY apps/gradio-space/src apps/gradio-space/src
 COPY libs/inference/src libs/inference/src
+COPY libs/agent/src libs/agent/src
+COPY skills skills
 
 RUN useradd -m -u 1000 user && \
     uv sync --frozen --no-dev --package gradio-space && \
@@ -25,7 +28,11 @@ RUN useradd -m -u 1000 user && \
 
 USER user
 ENV HOME=/home/user \
-    PATH="/app/.venv/bin:$PATH"
+    PATH="/app/.venv/bin:$PATH" \
+    AGENT_OUTPUTS_DIR=/tmp/agent_outputs \
+    AGENT_TRACES_DIR=/tmp/agent_traces
+
+RUN mkdir -p /tmp/agent_outputs /tmp/agent_traces
 
 EXPOSE 7860
 

README.md

@@ -1,7 +1,7 @@
 ---
 
-## title: Small Model Hackathon
-emoji: 🦙
+## title: Lesson Agent
+emoji: 📚
 colorFrom: blue
 colorTo: green
 sdk: docker
@@ -9,11 +9,13 @@ app_port: 7860
 pinned: false
 license: apache-2.0
 
-# Small Model Hackathon
+# Lesson Agent
 
-Gradio chat Space for the [Build Small Hackathon](https://huggingface.co/build-small-hackathon). Runs local inference with **llama.cpp** (GGUF) by default; optional **transformers** backend via env.
+**Backyard AI** Gradio Space for the [Build Small Hackathon](https://huggingface.co/build-small-hackathon).
 
-See **[USAGE.md](USAGE.md)** for local run, Docker smoke test, and HF Space deployment steps.
+A local skill-based agent helps a teacher you know turn a **topic + grade level** into a downloadable **PowerPoint** — powered by a small transformers model (`MiniCPM5-1B` by default), no cloud LLM API.
+
+See **[USAGE.md](USAGE.md)** for local run, Docker smoke test, and HF Space deployment.
 
 ## Prerequisites
 
@@ -26,81 +28,75 @@ See **[USAGE.md](USAGE.md)** for local run, Docker smoke test, and HF Space depl
 uv sync --all-packages
 cp .env.example .env   # optional: edit model settings
 
-# Download GGUF for offline dev (optional)
-uv run python scripts/download_model.py
-
 # Run Gradio locally
 uv run --package gradio-space python -m gradio_space.app
 ```
 
-Open [http://localhost:7860](http://localhost:7860). The model downloads from Hugging Face Hub on the first chat message (or set `MODEL_PATH` to a local GGUF).
-
-## Environment variables
-
-
-| Variable            | Default                           | Description                                |
-| ------------------- | --------------------------------- | ------------------------------------------ |
-| `INFERENCE_BACKEND` | `llama_cpp`                       | `llama_cpp` or `transformers`              |
-| `MODEL_REPO`        | `Qwen/Qwen2.5-3B-Instruct-GGUF`   | Hub repo for GGUF                          |
-| `MODEL_FILE`        | `qwen2.5-3b-instruct-q4_k_m.gguf` | GGUF filename                              |
-| `MODEL_PATH`        | —                                 | Local GGUF path (skips Hub download)       |
-| `N_CTX`             | `4096`                            | Context window                             |
-| `N_GPU_LAYERS`      | `0`                               | GPU layers for llama.cpp (0 = CPU)         |
-| `MODEL_ID`          | `Qwen/Qwen2.5-3B-Instruct`        | Used when `INFERENCE_BACKEND=transformers` |
-
+Open [http://localhost:7860](http://localhost:7860). Use the **Lesson slides** tab: enter a topic, grade, and slide count. The model loads on first generate.
 
-See `[.env.example](.env.example)` for a full template.
+## How it works
 
-## Monorepo layout
+1. **Skill** — `skills/education-pptx/SKILL.md` (Hermes / agentskills.io format)
+2. **LLM** — local model drafts a JSON slide outline
+3. **Tool** — `create_pptx` builds the file with `python-pptx`
+4. **Trace** — JSON log saved under `outputs/traces/` for the Sharing is Caring badge
 
 ```text
-apps/gradio-space/   # Gradio UI (HF Space entrypoint)
-libs/inference/      # Swappable inference backends
-scripts/             # Dev utilities
+apps/gradio-space/   # Gradio tabs (Lesson slides + Chat debug)
+libs/agent/          # Skill agent runner, tools, trace recorder
+libs/inference/      # Transformers + llama.cpp backends
+skills/              # SKILL.md task definitions
 ```
 
-### Common commands
+## Environment variables
 
-```bash
-uv add --package gradio-space <package>
-uv add --package inference <package>
-uv run --package gradio-space python -m gradio_space.app
-uv run python -c "from inference.factory import get_backend"
-```
+| Variable | Default | Description |
+| -------- | ------- | ----------- |
+| `ACTIVE_MODEL` | `minicpm5-1b` | Preset key from `models.yaml` |
+| `AGENT_OUTPUTS_DIR` | `/tmp/agent_outputs` | Generated `.pptx` files |
+| `AGENT_TRACES_DIR` | `outputs/traces` | Agent trace JSON |
+| `SKILLS_DIR` | `./skills` | Skill definitions root |
+
+See [`.env.example`](.env.example) and [`models.yaml`](models.yaml) for model presets.
 
 ## Hugging Face Space deployment
 
 1. Create a Space under [build-small-hackathon](https://huggingface.co/build-small-hackathon) with **Docker** SDK.
 2. Link this repository (root `Dockerfile` + root `README.md` YAML above).
-3. Hardware: start with **CPU basic**; upgrade to GPU if you set `N_GPU_LAYERS > 0`.
-4. Add Space secrets: `MODEL_REPO`, `MODEL_FILE`, `N_CTX`, `N_GPU_LAYERS`.
+3. Hardware: **GPU basic** recommended for transformers (`minicpm5-1b`).
+4. Optional secrets: `ACTIVE_MODEL`, `N_GPU_LAYERS` (if using GGUF preset).
 
 ```bash
-# Optional local Docker smoke test
 docker build -t hackathon-space .
-docker run --rm -p 7860:7860 -e MODEL_REPO=Qwen/Qwen2.5-3B-Instruct-GGUF hackathon-space
+docker run --rm -p 7860:7860 -e ACTIVE_MODEL=minicpm5-1b hackathon-space
 ```
 
 ## Hackathon checklist
 
-- Choose a track (Backyard AI or Thousand Token Wood)
+- **Track:** Backyard AI — lesson slide builder for a teacher you know
 - Space live under build-small-hackathon
-- Demo video recorded
+- Demo video: real user enters topic → download `.pptx` → show agent trace
 - Social post published
-- Submission locked in by **June 15, 2026**
+- Submission by **June 15, 2026**
 
 ### Badge targets
 
-- **Off-the-Grid** — local llama.cpp inference (default setup)
-- **Llama Champion** — llama.cpp + GGUF model
-- **Off-Brand** — custom UI via `gr.Server` (Phase 2)
-- **Sharing is Caring** — agent traces dataset (Phase 2)
+- **Best Agent** — skill loop + `create_pptx` tool
+- **Tiny Titan** — MiniCPM5 1B (≤4B)
+- **OpenBMB** — `openbmb/MiniCPM5-1B`
+- **Sharing is Caring** — upload traces with `scripts/upload_trace.py`
+- **Off-the-Grid** — local inference only (no cloud LLM API)
+- **Well-Tuned** — optional fine-tuned preset in `models.yaml` (Phase 2)
 
-## Transformers backend (optional)
+## Agent trace upload
 
 ```bash
-uv sync --package inference --extra transformers
-INFERENCE_BACKEND=transformers MODEL_ID=Qwen/Qwen2.5-3B-Instruct \
-  uv run --package gradio-space python -m gradio_space.app
+uv run python scripts/upload_trace.py --repo-id YOUR_USER/build-small-agent-traces
 ```
 
+## Demo video script
+
+1. Introduce the teacher and the problem (building a 5-slide lesson takes 30+ minutes).
+2. Open **Lesson slides**, enter topic + grade, click **Generate**.
+3. Show outline preview and download the `.pptx`.
+4. Expand the agent trace JSON — local model, no cloud API.

USAGE.md

@@ -1,6 +1,8 @@
 # Usage
 
-How to run the Gradio chat app locally, test it in Docker, and deploy to a Hugging Face Space for the [Build Small Hackathon](https://huggingface.co/build-small-hackathon).
+How to run the **Lesson Agent** Gradio app locally, test it in Docker, and deploy to a Hugging Face Space for the [Build Small Hackathon](https://huggingface.co/build-small-hackathon).
+
+The primary UI is the **Lesson slides** tab (topic → local model outline → downloadable `.pptx`). The **Chat (debug)** tab tests the underlying model.
 
 ## Prerequisites
 
@@ -23,11 +25,11 @@ uv sync --all-packages
 cp .env.example .env
 ```
 
-Edit `.env` if you want a different model or local GGUF path. Defaults work out of the box.
+Edit `.env` if you want a different model preset. Default is `minicpm5-1b` (transformers).
 
-### 3. Pre-download the model (recommended)
+### 3. Pre-download the model (optional for GGUF presets)
 
-The app can download the GGUF on first chat, but pre-downloading avoids a long wait during your first message:
+If using a GGUF preset (`qwen3b-gguf`), pre-download avoids a long wait on first use:
 
 ```bash
 uv run python scripts/download_model.py
@@ -47,7 +49,13 @@ uv run --package gradio-space python -m gradio_space.app
 
 Open [http://localhost:7860](http://localhost:7860).
 
-The model loads on the **first chat message** unless you set `MODEL_PATH`. After code changes, restart the process to pick up updates.
+The model loads on the **first Generate** (Lesson slides) or chat message. Agent traces are written to `outputs/traces/`. After code changes, restart the process to pick up updates.
+
+### 5. Upload agent trace (Sharing is Caring badge)
+
+```bash
+uv run python scripts/upload_trace.py --repo-id YOUR_USER/build-small-agent-traces
+```
 
 ### 5. Quick sanity checks
 

apps/gradio-space/pyproject.toml

@@ -8,11 +8,13 @@ authors = [
 ]
 requires-python = ">=3.12"
 dependencies = [
+    "agent",
     "gradio>=5.0.0",
     "inference",
 ]
 
 [tool.uv.sources]
+agent = { workspace = true }
 inference = { workspace = true }
 
 [build-system]

apps/gradio-space/src/gradio_space/app.py

@@ -2,103 +2,12 @@ import os
 
 import gradio as gr
 
-from inference.config import get_app_config, get_model_config
-from inference.factory import get_backend, reset_backend
+from gradio_space.model_loading import preload_active_model
+from gradio_space.tabs import build_chat_tab, build_education_pptx_tab
+from gradio_space.tabs.education_pptx import gradio_allowed_paths
+from inference.config import get_app_config
 
 _app_config = get_app_config()
-_current_model_key: str | None = None
-_load_state: dict[str, bool] = {}
-_load_errors: dict[str, str] = {}
-
-
-def _ensure_model_loaded(model_key: str) -> str | None:
-    global _current_model_key
-
-    if model_key != _current_model_key:
-        reset_backend()
-        _current_model_key = model_key
-
-    if _load_state.get(model_key):
-        return None
-
-    if model_key in _load_errors:
-        return _load_errors[model_key]
-
-    try:
-        get_backend(model_key).load()
-        _load_state[model_key] = True
-        return None
-    except Exception as exc:  # noqa: BLE001 — surface model load failures in the UI
-        message = f"Failed to load model: {exc}"
-        _load_errors[model_key] = message
-        return message
-
-
-def _history_to_messages(history: list) -> list[dict[str, str]]:
-    messages: list[dict[str, str]] = []
-    for item in history:
-        if isinstance(item, dict):
-            messages.append({"role": item["role"], "content": item["content"]})
-        else:
-            user_msg, assistant_msg = item
-            messages.append({"role": "user", "content": user_msg})
-            if assistant_msg:
-                messages.append({"role": "assistant", "content": assistant_msg})
-    return messages
-
-
-def chat(message: str, history: list, model_key: str) -> str:
-    load_error = _ensure_model_loaded(model_key)
-    if load_error:
-        return load_error
-
-    messages = _history_to_messages(history)
-    messages.append({"role": "user", "content": message})
-    return get_backend(model_key).chat(messages)
-
-
-def _runtime_device_hint(model_key: str) -> str:
-    model = get_model_config(model_key)
-    if model.backend == "transformers":
-        try:
-            import torch
-
-            if torch.cuda.is_available():
-                return f"GPU ({torch.cuda.get_device_name(0)})"
-        except ImportError:
-            pass
-        return "CPU"
-    if model.n_gpu_layers > 0:
-        return f"llama.cpp GPU offload ({model.n_gpu_layers} layers)"
-    return "CPU"
-
-
-def warmup(model_key: str | None = None) -> str:
-    key = model_key or _app_config.active_model
-    model = get_model_config(key)
-
-    if _load_state.get(key):
-        backend = get_backend(key)
-        device = (
-            backend.device_label
-            if hasattr(backend, "device_label")
-            else _runtime_device_hint(key)
-        )
-        return f"Model ready: {model.label} on {device}"
-
-    if key in _load_errors:
-        return _load_errors[key]
-
-    device_hint = _runtime_device_hint(key)
-    return (
-        f"Preset `{key}` selected ({model.backend}, {device_hint}). "
-        "Weights load on the first chat message."
-    )
-
-
-def model_status(model_key: str) -> str:
-    model = get_model_config(model_key)
-    return f"**{model.label}**\n\n- Backend: `{model.backend}`\n- {warmup(model_key)}"
 
 
 def build_demo() -> gr.Blocks:
@@ -109,14 +18,14 @@ def build_demo() -> gr.Blocks:
         else "Using built-in presets (models.yaml not found)."
     )
 
-    with gr.Blocks(title="Small Model Hackathon") as demo:
+    with gr.Blocks(title="Lesson Agent — Build Small Hackathon") as demo:
         gr.Markdown(
             f"""
-# Small Model Chat
+# Lesson Agent
 
-Local inference with preset-based configuration.
+Local skill-based agent for teachers — **topic in, PowerPoint out**.
 
-- **Default preset:** `{active.key}` — {active.label}
+- **Model:** `{active.key}` — {active.label}
 - **Backend:** `{active.backend}`
 - {presets_note}
 
@@ -124,47 +33,22 @@ Part of the [Build Small Hackathon](https://huggingface.co/build-small-hackathon
 """
         )
 
-        if _app_config.allow_model_switch and len(_app_config.models) > 1:
-            model_dropdown = gr.Dropdown(
-                choices=_app_config.model_choices(),
-                value=_app_config.active_model,
-                label="Model preset",
-                info="Switch presets for local testing. Each preset loads on first use.",
-            )
-            status = gr.Markdown(model_status(_app_config.active_model))
-
-            model_dropdown.change(
-                fn=model_status,
-                inputs=model_dropdown,
-                outputs=status,
-            )
-
-            gr.ChatInterface(
-                fn=chat,
-                additional_inputs=[model_dropdown],
-                examples=[
-                    ["Hello! What can you help me with?", _app_config.active_model],
-                    ["Explain llama.cpp in one sentence.", _app_config.active_model],
-                ],
-            )
-        else:
-            status = gr.Markdown(model_status(_app_config.active_model))
-            gr.ChatInterface(
-                fn=lambda message, history: chat(message, history, _app_config.active_model),
-                examples=["Hello! What can you help me with?", "Explain llama.cpp in one sentence."],
-            )
-            demo.load(lambda: warmup(_app_config.active_model), outputs=status)
+        with gr.Tabs():
+            with gr.Tab("Lesson slides"):
+                build_education_pptx_tab()
+            with gr.Tab("Chat (debug)"):
+                build_chat_tab()
 
     return demo
 
 
-demo = build_demo()
-
-
 def main() -> None:
+    preload_active_model()
+    demo = build_demo()
     demo.launch(
         server_name="0.0.0.0",
         server_port=int(os.environ.get("PORT", "7860")),
+        allowed_paths=gradio_allowed_paths(),
     )
 
 

apps/gradio-space/src/gradio_space/model_loading.py

@@ -0,0 +1,114 @@
+from inference.config import get_app_config, get_model_config
+from inference.factory import get_backend, reset_backend
+
+_app_config = get_app_config()
+_current_model_key: str | None = None
+_load_state: dict[str, bool] = {}
+_load_errors: dict[str, str] = {}
+
+
+def get_active_model_key() -> str:
+    return _app_config.active_model
+
+
+def ensure_model_loaded(model_key: str) -> str | None:
+    global _current_model_key
+
+    if model_key != _current_model_key:
+        reset_backend()
+        _current_model_key = model_key
+
+    if _load_state.get(model_key):
+        return None
+
+    if model_key in _load_errors:
+        return _load_errors[model_key]
+
+    try:
+        get_backend(model_key).load()
+        _load_state[model_key] = True
+        return None
+    except Exception as exc:  # noqa: BLE001 — surface model load failures in the UI
+        message = f"Failed to load model: {exc}"
+        _load_errors[model_key] = message
+        return message
+
+
+def runtime_device_hint(model_key: str) -> str:
+    model = get_model_config(model_key)
+    if model.backend == "transformers":
+        try:
+            import torch
+
+            if torch.cuda.is_available():
+                return f"GPU ({torch.cuda.get_device_name(0)})"
+        except ImportError:
+            pass
+        return "CPU"
+    if model.n_gpu_layers > 0:
+        return f"llama.cpp GPU offload ({model.n_gpu_layers} layers)"
+    return "CPU"
+
+
+def warmup(model_key: str | None = None) -> str:
+    key = model_key or _app_config.active_model
+    model = get_model_config(key)
+
+    if _load_state.get(key):
+        backend = get_backend(key)
+        device = (
+            backend.device_label
+            if hasattr(backend, "device_label")
+            else runtime_device_hint(key)
+        )
+        return f"Model ready: {model.label} on {device}"
+
+    if key in _load_errors:
+        return _load_errors[key]
+
+    device_hint = runtime_device_hint(key)
+    return (
+        f"Preset `{key}` selected ({model.backend}, {device_hint}). "
+        "Loading weights…"
+    )
+
+
+def preload_active_model() -> str:
+    """Load the active preset at startup so the first request is fast."""
+    key = get_active_model_key()
+    print(f"[startup] Loading model preset `{key}`…", flush=True)
+    error = ensure_model_loaded(key)
+    if error:
+        print(f"[startup] {error}", flush=True)
+        return error
+    status = warmup(key)
+    print(f"[startup] {status}", flush=True)
+    return status
+
+
+def model_status(model_key: str) -> str:
+    model = get_model_config(model_key)
+    return f"**{model.label}**\n\n- Backend: `{model.backend}`\n- {warmup(model_key)}"
+
+
+def _history_to_messages(history: list) -> list[dict[str, str]]:
+    messages: list[dict[str, str]] = []
+    for item in history:
+        if isinstance(item, dict):
+            messages.append({"role": item["role"], "content": item["content"]})
+        else:
+            user_msg, assistant_msg = item
+            messages.append({"role": "user", "content": user_msg})
+            if assistant_msg:
+                messages.append({"role": "assistant", "content": assistant_msg})
+    return messages
+
+
+def chat(message: str, history: list, model_key: str) -> str:
+    load_error = ensure_model_loaded(model_key)
+    if load_error:
+        return load_error
+
+    messages = _history_to_messages(history)
+    messages.append({"role": "user", "content": message})
+    return get_backend(model_key).chat(messages)

apps/gradio-space/src/gradio_space/tabs/__init__.py

@@ -0,0 +1,4 @@
+from gradio_space.tabs.chat import build_chat_tab
+from gradio_space.tabs.education_pptx import build_education_pptx_tab
+
+__all__ = ["build_chat_tab", "build_education_pptx_tab"]

apps/gradio-space/src/gradio_space/tabs/chat.py

@@ -0,0 +1,44 @@
+import gradio as gr
+
+from gradio_space.model_loading import chat, model_status
+from inference.config import get_app_config
+
+_app_config = get_app_config()
+
+
+def build_chat_tab() -> None:
+    gr.Markdown(
+        """
+### Model chat (debug)
+
+Test the active local model with a simple chat interface.
+"""
+    )
+
+    model_key = _app_config.active_model
+
+    if _app_config.allow_model_switch and len(_app_config.models) > 1:
+        model_dropdown = gr.Dropdown(
+            choices=_app_config.model_choices(),
+            value=_app_config.active_model,
+            label="Model preset",
+        )
+        status = gr.Markdown(model_status(model_key))
+        model_dropdown.change(fn=model_status, inputs=model_dropdown, outputs=status)
+        gr.ChatInterface(
+            fn=chat,
+            additional_inputs=[model_dropdown],
+            examples=[
+                ["Hello! What can you help me with?", _app_config.active_model],
+                ["Explain photosynthesis in one sentence.", _app_config.active_model],
+            ],
+        )
+    else:
+        status = gr.Markdown(model_status(model_key))
+        gr.ChatInterface(
+            fn=lambda message, history: chat(message, history, model_key),
+            examples=[
+                "Hello! What can you help me with?",
+                "Explain photosynthesis in one sentence.",
+            ],
+        )

apps/gradio-space/src/gradio_space/tabs/education_pptx.py

@@ -0,0 +1,161 @@
+from pathlib import Path
+
+import gradio as gr
+
+from agent.runner import AgentRunner
+from agent.tools.pptx import get_outputs_dir
+from gradio_space.model_loading import ensure_model_loaded, get_active_model_key, model_status
+from inference.factory import get_backend
+
+def _error_html(message: str) -> str:
+    safe = (
+        message.replace("&", "&")
+        .replace("<", "&lt;")
+        .replace(">", "&gt;")
+    )
+    return (
+        f'<div style="padding:12px;border:1px solid #c44;border-radius:8px;'
+        f'background:#fff5f5;color:#8a1f1f;">{safe}</div>'
+    )
+
+
+def generate_lesson_slides(
+    topic: str,
+    grade: str,
+    slide_count: int,
+) -> tuple[str, str, list[str], str | None, str | None, str | None, str, str]:
+    model_key = get_active_model_key()
+    load_error = ensure_model_loaded(model_key)
+    if load_error:
+        return load_error, _error_html(load_error), [], None, None, None, load_error, load_error
+
+    if not topic.strip():
+        message = "Please enter a lesson topic."
+        return message, _error_html(message), [], None, None, None, message, message
+
+    try:
+        runner = AgentRunner()
+        result = runner.run_education_pptx(
+            topic=topic,
+            grade=grade,
+            slide_count=int(slide_count),
+            model_key=model_key,
+            backend=get_backend(model_key),
+        )
+    except Exception as exc:  # noqa: BLE001 — show agent errors in UI
+        message = f"Agent error: {exc}"
+        return message, _error_html(message), [], None, None, None, message, message
+
+    gallery = [str(Path(p).resolve()) for p in result.preview_images]
+    trace_summary = (
+        f"Run `{result.trace.run_id}` · skill `{result.trace.skill}` · "
+        f"model `{result.trace.model}`\n\n"
+        f"Trace saved: `{result.trace_path}`"
+    )
+    return (
+        result.markdown_preview,
+        result.html_preview,
+        gallery,
+        str(Path(result.pptx_path).resolve()),
+        str(Path(result.docx_path).resolve()),
+        str(Path(result.html_export_path).resolve()),
+        trace_summary,
+        result.trace.to_json(),
+    )
+
+
+def build_education_pptx_tab() -> None:
+    model_key = get_active_model_key()
+
+    gr.Markdown(
+        """
+### Lesson slide builder
+
+Enter a topic and grade level. A **local small model** drafts the outline;
+the agent then builds a downloadable PowerPoint — no cloud LLM API.
+"""
+    )
+    gr.Markdown(model_status(model_key))
+
+    with gr.Row():
+        topic = gr.Textbox(
+            label="Lesson topic",
+            placeholder="e.g. Photosynthesis, Fractions, The water cycle",
+        )
+        grade = gr.Dropdown(
+            label="Grade level",
+            choices=["K", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "Adult"],
+            value="6",
+        )
+        slide_count = gr.Slider(
+            minimum=3,
+            maximum=8,
+            step=1,
+            value=5,
+            label="Content slides",
+        )
+
+    generate_btn = gr.Button("Generate lesson slides", variant="primary")
+
+    with gr.Tabs():
+        with gr.Tab("Slide preview"):
+            slide_preview = gr.HTML(label="Slides")
+            slide_gallery = gr.Gallery(
+                label="Slide thumbnails",
+                columns=2,
+                height=420,
+                object_fit="contain",
+                preview=True,
+            )
+        with gr.Tab("Outline"):
+            outline_preview = gr.Markdown(label="Outline (markdown)")
+
+    with gr.Row():
+        pptx_file = gr.File(label="Download PowerPoint (.pptx)", interactive=False)
+        docx_file = gr.File(
+            label="Download Word / Google Docs (.docx)",
+            interactive=False,
+        )
+        html_file = gr.File(
+            label="Download HTML (import to Google Docs)",
+            interactive=False,
+        )
+
+    gr.Markdown(
+        """
+**Open in Google Docs:** download the `.docx` file, upload it to [Google Drive](https://drive.google.com),
+then choose **Open with → Google Docs**. You can also upload the `.html` file via
+**Google Docs → File → Open → Upload**.
+"""
+    )
+
+    trace_box = gr.Textbox(
+        label="Agent trace (JSON)",
+        lines=12,
+        max_lines=20,
+        interactive=False,
+    )
+
+    with gr.Accordion("Trace summary", open=False):
+        trace_summary = gr.Markdown()
+
+    generate_btn.click(
+        fn=generate_lesson_slides,
+        inputs=[topic, grade, slide_count],
+        outputs=[
+            outline_preview,
+            slide_preview,
+            slide_gallery,
+            pptx_file,
+            docx_file,
+            html_file,
+            trace_summary,
+            trace_box,
+        ],
+    )
+
+
+def gradio_allowed_paths() -> list[str]:
+    """Paths Gradio must be allowed to read for previews and downloads."""
+    root = get_outputs_dir().resolve()
+    return [str(root)]

libs/agent/README.md

@@ -0,0 +1,17 @@
+# agent
+
+Hermes-style skill agent on top of the local `inference` backends.
+
+```python
+from agent.runner import AgentRunner
+from inference.factory import get_backend
+
+runner = AgentRunner()
+result = runner.run_education_pptx(
+    topic="Photosynthesis",
+    grade="6",
+    slide_count=5,
+    model_key="minicpm5-1b",
+    backend=get_backend("minicpm5-1b"),
+)
+```

libs/agent/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "agent"
+version = "0.1.0"
+description = "Skill-based local agent loop for hackathon tasks"
+readme = "README.md"
+authors = [
+    { name = "MSGhais", email = "msghais135@gmail.com" }
+]
+requires-python = ">=3.12"
+dependencies = [
+    "inference",
+    "pillow>=10.0.0",
+    "pydantic>=2.0.0",
+    "python-docx>=1.1.0",
+    "python-pptx>=1.0.0",
+    "pyyaml>=6.0.2",
+]
+
+[tool.uv.sources]
+inference = { workspace = true }
+
+[build-system]
+requires = ["uv_build>=0.8.13,<0.9.0"]
+build-backend = "uv_build"

libs/agent/src/agent/__init__.py

@@ -0,0 +1,11 @@
+from agent.runner import AgentResult, AgentRunner
+from agent.skills import Skill, SkillRegistry
+from agent.trace import TraceRecorder
+
+__all__ = [
+    "AgentResult",
+    "AgentRunner",
+    "Skill",
+    "SkillRegistry",
+    "TraceRecorder",
+]

libs/agent/src/agent/models.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+
+class SlideSpec(BaseModel):
+    title: str
+    bullets: list[str] = Field(default_factory=list, min_length=1)
+    speaker_note: str = ""
+
+
+class SlideOutline(BaseModel):
+    title: str
+    slides: list[SlideSpec] = Field(min_length=1)
+
+
+class EducationPptxInput(BaseModel):
+    topic: str
+    grade: str
+    slide_count: int = Field(ge=3, le=8)

libs/agent/src/agent/preview.py

@@ -0,0 +1,254 @@
+from __future__ import annotations
+
+import html
+from pathlib import Path
+
+from PIL import Image, ImageDraw, ImageFont
+
+from agent.models import SlideOutline
+from agent.tools.pptx import _outputs_dir, _safe_filename
+
+
+def outline_to_html(outline: SlideOutline) -> str:
+    """Render slide-like cards for in-browser preview."""
+    slides_html: list[str] = []
+    slides_html.append(
+        _slide_card_html(
+            title=outline.title,
+            subtitle="Lesson slides",
+            bullets=[],
+            speaker_note="",
+            index=0,
+            is_title=True,
+        )
+    )
+    for index, slide in enumerate(outline.slides, start=1):
+        slides_html.append(
+            _slide_card_html(
+                title=slide.title,
+                subtitle="",
+                bullets=slide.bullets,
+                speaker_note=slide.speaker_note,
+                index=index,
+                is_title=False,
+            )
+        )
+
+    return f"""
+<div class="lesson-deck">
+  <style>
+    .lesson-deck {{
+      font-family: Georgia, "Iowan Old Style", serif;
+      display: flex;
+      flex-direction: column;
+      gap: 16px;
+      max-width: 960px;
+    }}
+    .lesson-slide {{
+      border: 2px solid #5a3a22;
+      border-radius: 12px;
+      background: linear-gradient(180deg, #fbf6e8 0%, #f6efe1 100%);
+      box-shadow: 0 4px 0 rgba(58,37,22,0.12);
+      padding: 24px 28px;
+      min-height: 180px;
+    }}
+    .lesson-slide.title-slide {{
+      background: linear-gradient(135deg, #3a2516 0%, #5a3a22 100%);
+      color: #f6efe1;
+      min-height: 220px;
+      display: flex;
+      flex-direction: column;
+      justify-content: center;
+    }}
+    .lesson-slide .slide-index {{
+      font-size: 11px;
+      letter-spacing: 0.18em;
+      text-transform: uppercase;
+      color: #8a4a2b;
+      margin-bottom: 8px;
+      font-weight: 700;
+    }}
+    .lesson-slide.title-slide .slide-index {{
+      color: #e6a85c;
+    }}
+    .lesson-slide h3 {{
+      margin: 0 0 12px 0;
+      font-size: 1.5rem;
+      line-height: 1.2;
+    }}
+    .lesson-slide .subtitle {{
+      margin: 0;
+      opacity: 0.85;
+      font-style: italic;
+    }}
+    .lesson-slide ul {{
+      margin: 0;
+      padding-left: 1.25rem;
+    }}
+    .lesson-slide li {{
+      margin-bottom: 6px;
+      line-height: 1.45;
+    }}
+    .lesson-slide .speaker-note {{
+      margin-top: 14px;
+      padding-top: 10px;
+      border-top: 1px dashed #8a6a48;
+      font-size: 0.9rem;
+      color: #5a3a22;
+      font-style: italic;
+    }}
+  </style>
+  {''.join(slides_html)}
+</div>
+"""
+
+
+def _slide_card_html(
+    *,
+    title: str,
+    subtitle: str,
+    bullets: list[str],
+    speaker_note: str,
+    index: int,
+    is_title: bool,
+) -> str:
+    safe_title = html.escape(title)
+    safe_subtitle = html.escape(subtitle)
+    klass = "lesson-slide title-slide" if is_title else "lesson-slide"
+    label = "Title" if is_title else f"Slide {index}"
+
+    bullets_html = ""
+    if bullets:
+        items = "".join(f"<li>{html.escape(b)}</li>" for b in bullets)
+        bullets_html = f"<ul>{items}</ul>"
+
+    note_html = ""
+    if speaker_note:
+        note_html = f'<div class="speaker-note">Teacher note: {html.escape(speaker_note)}</div>'
+
+    subtitle_html = f'<p class="subtitle">{safe_subtitle}</p>' if subtitle else ""
+
+    return f"""
+<article class="{klass}">
+  <div class="slide-index">{label}</div>
+  <h3>{safe_title}</h3>
+  {subtitle_html}
+  {bullets_html}
+  {note_html}
+</article>
+"""
+
+
+def render_slide_images(outline: SlideOutline, run_id: str) -> list[Path]:
+    """Render PNG thumbnails for gr.Gallery preview."""
+    out_dir = _outputs_dir() / f"preview_{run_id}"
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    width, height = 1280, 720
+    paths: list[Path] = []
+
+    title_path = out_dir / "00_title.png"
+    _draw_slide_image(
+        title_path,
+        width,
+        height,
+        title=outline.title,
+        subtitle="Generated lesson slides",
+        bullets=[],
+        is_title=True,
+    )
+    paths.append(title_path)
+
+    for index, slide in enumerate(outline.slides, start=1):
+        path = out_dir / f"{index:02d}_{_safe_filename(slide.title)}.png"
+        _draw_slide_image(
+            path,
+            width,
+            height,
+            title=slide.title,
+            subtitle="",
+            bullets=slide.bullets,
+            is_title=False,
+        )
+        paths.append(path)
+
+    return paths
+
+
+def _load_font(size: int, bold: bool = False) -> ImageFont.FreeTypeFont | ImageFont.ImageFont:
+    candidates = [
+        "/usr/share/fonts/truetype/dejavu/DejaVuSerif-Bold.ttf" if bold else "/usr/share/fonts/truetype/dejavu/DejaVuSerif.ttf",
+        "/usr/share/fonts/truetype/liberation/LiberationSerif-Bold.ttf" if bold else "/usr/share/fonts/truetype/liberation/LiberationSerif-Regular.ttf",
+    ]
+    for path in candidates:
+        if Path(path).exists():
+            return ImageFont.truetype(path, size)
+    return ImageFont.load_default()
+
+
+def _draw_slide_image(
+    path: Path,
+    width: int,
+    height: int,
+    *,
+    title: str,
+    subtitle: str,
+    bullets: list[str],
+    is_title: bool,
+) -> None:
+    if is_title:
+        bg = (58, 37, 22)
+        fg = (246, 239, 225)
+        accent = (230, 168, 92)
+    else:
+        bg = (251, 246, 232)
+        fg = (42, 33, 24)
+        accent = (138, 106, 72)
+
+    image = Image.new("RGB", (width, height), bg)
+    draw = ImageDraw.Draw(image)
+
+    margin = 80
+    title_font = _load_font(56 if is_title else 44, bold=True)
+    body_font = _load_font(30)
+    small_font = _load_font(24)
+
+    y = margin
+    if is_title:
+        y_title = height // 2 - 80
+        for part in _wrap_text(title, 28).split("\n"):
+            draw.text((margin, y_title), part, fill=fg, font=title_font)
+            y_title += 64
+        if subtitle:
+            draw.text((margin, height // 2 + 40), subtitle, fill=accent, font=small_font)
+    else:
+        for part in _wrap_text(title, 32).split("\n"):
+            draw.text((margin, y), part, fill=fg, font=title_font)
+            y += 52
+        y += 20
+        for bullet in bullets:
+            line = _wrap_text(f"• {bullet}", 48)
+            for part in line.split("\n"):
+                draw.text((margin + 10, y), part, fill=fg, font=body_font)
+                y += 42
+            y += 8
+
+    draw.rectangle([(0, 0), (width, 8)], fill=accent)
+    image.save(path)
+
+
+def _wrap_text(text: str, max_chars: int) -> str:
+    words = text.split()
+    lines: list[str] = []
+    current: list[str] = []
+    for word in words:
+        candidate = " ".join(current + [word])
+        if len(candidate) <= max_chars:
+            current.append(word)
+        else:
+            if current:
+                lines.append(" ".join(current))
+            current = [word]
+    if current:
+        lines.append(" ".join(current))
+    return "\n".join(lines) if lines else text

libs/agent/src/agent/prompts.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import json
+
+from agent.models import EducationPptxInput
+
+
+def education_outline_system(skill_body: str) -> str:
+    return f"""You are a lesson-planning assistant for teachers.
+Follow the skill workflow below and output ONLY valid JSON (no markdown fences).
+
+Skill workflow:
+{skill_body}
+
+JSON schema:
+{{
+  "title": "string — presentation title",
+  "slides": [
+    {{
+      "title": "string — slide heading",
+      "bullets": ["string", "..."],
+      "speaker_note": "string — one sentence for the teacher"
+    }}
+  ]
+}}
+
+Rules:
+- Use exactly the requested number of content slides (title slide is added separately by the tool).
+- Bullets should be short, age-appropriate, and factual.
+- speaker_note is optional but helpful for each slide.
+"""
+
+
+def education_outline_user(req: EducationPptxInput) -> str:
+    return (
+        f"Topic: {req.topic}\n"
+        f"Grade level: {req.grade}\n"
+        f"Number of content slides: {req.slide_count}\n"
+        "Return JSON only."
+    )
+
+
+def education_outline_repair(
+    invalid_output: str,
+    error: str,
+    *,
+    expected_slides: int | None = None,
+) -> str:
+    count_line = ""
+    if expected_slides is not None:
+        count_line = f"\nYou must include exactly {expected_slides} items in the slides array.\n"
+    return (
+        "The previous response was invalid JSON or did not match the schema.\n"
+        f"Validation error: {error}\n"
+        f"{count_line}"
+        f"Previous output:\n{invalid_output}\n\n"
+        "Return corrected JSON only, no explanation."
+    )
+
+
+def outline_to_markdown(title: str, slides: list[dict]) -> str:
+    lines = [f"# {title}", ""]
+    for index, slide in enumerate(slides, start=1):
+        lines.append(f"## Slide {index}: {slide.get('title', 'Untitled')}")
+        for bullet in slide.get("bullets", []):
+            lines.append(f"- {bullet}")
+        note = slide.get("speaker_note", "")
+        if note:
+            lines.append(f"\n*Teacher note:* {note}")
+        lines.append("")
+    return "\n".join(lines).strip()
+
+
+def outline_json_example(slide_count: int) -> str:
+    example = {
+        "title": "Example Lesson",
+        "slides": [
+            {
+                "title": f"Slide {i}",
+                "bullets": ["Key point A", "Key point B"],
+                "speaker_note": "Brief teaching tip.",
+            }
+            for i in range(1, slide_count + 1)
+        ],
+    }
+    return json.dumps(example, indent=2)

libs/agent/src/agent/runner.py

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from typing import Any
+
+from inference.base import InferenceBackend
+
+from agent.models import EducationPptxInput, SlideOutline, SlideSpec
+from agent.preview import outline_to_html, render_slide_images
+from agent.prompts import (
+    education_outline_repair,
+    education_outline_system,
+    education_outline_user,
+    outline_to_markdown,
+)
+from agent.skills import SkillRegistry
+from agent.tools.docx import create_docx, create_html_export
+from agent.tools_registry import ToolRegistry
+from agent.trace import TraceRecorder
+
+EDUCATION_PPTX_SKILL = "education-pptx"
+
+
+@dataclass
+class AgentResult:
+    markdown_preview: str
+    html_preview: str
+    preview_images: list[str]
+    pptx_path: str
+    docx_path: str
+    html_export_path: str
+    trace: TraceRecorder
+    trace_path: str
+    outline: SlideOutline
+
+
+class AgentRunner:
+    def __init__(
+        self,
+        skills: SkillRegistry | None = None,
+        tools: ToolRegistry | None = None,
+    ) -> None:
+        self._skills = skills or SkillRegistry()
+        self._tools = tools or ToolRegistry()
+
+    def run_education_pptx(
+        self,
+        *,
+        topic: str,
+        grade: str,
+        slide_count: int,
+        model_key: str,
+        backend: InferenceBackend,
+    ) -> AgentResult:
+        skill = self._skills.get(EDUCATION_PPTX_SKILL)
+        req = EducationPptxInput(topic=topic.strip(), grade=grade, slide_count=slide_count)
+
+        trace = TraceRecorder(
+            skill=skill.name,
+            model=model_key,
+            user_input=req.model_dump(),
+        )
+
+        backend.load()
+        outline = self._generate_outline(skill, req, backend, trace)
+        tool = self._tools.get("create_pptx")
+        pptx_path = tool.handler(outline, run_id=trace.run_id)
+        trace.log_tool(
+            "create_pptx",
+            {"title": outline.title, "slide_count": len(outline.slides)},
+            pptx_path,
+        )
+
+        docx_path = create_docx(outline, run_id=trace.run_id)
+        trace.log_tool(
+            "create_docx",
+            {"title": outline.title, "slide_count": len(outline.slides)},
+            str(docx_path),
+        )
+
+        html_export_path = create_html_export(outline, run_id=trace.run_id)
+        trace.log_tool(
+            "create_html_export",
+            {"title": outline.title},
+            str(html_export_path),
+        )
+
+        trace.set_artifact(pptx_path)
+
+        slides_dicts = [s.model_dump() for s in outline.slides]
+        markdown = outline_to_markdown(outline.title, slides_dicts)
+        html_preview = outline_to_html(outline)
+        preview_images = [str(p) for p in render_slide_images(outline, trace.run_id)]
+        trace_path = trace.save()
+
+        return AgentResult(
+            markdown_preview=markdown,
+            html_preview=html_preview,
+            preview_images=preview_images,
+            pptx_path=pptx_path,
+            docx_path=str(docx_path),
+            html_export_path=str(html_export_path),
+            trace=trace,
+            trace_path=str(trace_path),
+            outline=outline,
+        )
+
+    def _generate_outline(
+        self,
+        skill: Any,
+        req: EducationPptxInput,
+        backend: InferenceBackend,
+        trace: TraceRecorder,
+    ) -> SlideOutline:
+        system = education_outline_system(skill.body)
+        user = education_outline_user(req)
+        messages = [
+            {"role": "system", "content": system},
+            {"role": "user", "content": user},
+        ]
+        prompt_text = system + "\n\n" + user
+        raw = backend.chat(messages, max_tokens=2048, temperature=0.3)
+        trace.log_llm(prompt_text, raw)
+
+        try:
+            return self._parse_outline(raw, req.slide_count, trace)
+        except (json.JSONDecodeError, ValueError) as first_error:
+            repair_messages = messages + [
+                {"role": "assistant", "content": raw},
+                {
+                    "role": "user",
+                    "content": education_outline_repair(
+                        raw, str(first_error), expected_slides=req.slide_count
+                    ),
+                },
+            ]
+            repair_prompt = education_outline_repair(
+                raw, str(first_error), expected_slides=req.slide_count
+            )
+            repaired = backend.chat(repair_messages, max_tokens=2048, temperature=0.1)
+            trace.log_llm(repair_prompt, repaired)
+            return self._parse_outline(repaired, req.slide_count, trace)
+
+    def _parse_outline(
+        self,
+        raw: str,
+        expected_slides: int,
+        trace: TraceRecorder | None = None,
+    ) -> SlideOutline:
+        data = self._sanitize_outline_data(self._extract_json(raw))
+        outline = SlideOutline.model_validate(data)
+        original_count = len(outline.slides)
+        outline = self._normalize_slide_count(outline, expected_slides)
+        if trace and original_count != expected_slides:
+            trace.log_note(
+                "Adjusted slide count to match request",
+                requested=expected_slides,
+                model_returned=original_count,
+                final=len(outline.slides),
+            )
+        return outline
+
+    @staticmethod
+    def _sanitize_outline_data(data: dict[str, Any]) -> dict[str, Any]:
+        title = str(data.get("title") or "Lesson").strip() or "Lesson"
+        slides_in = data.get("slides") or []
+        slides_out: list[dict[str, Any]] = []
+        for index, slide in enumerate(slides_in):
+            if not isinstance(slide, dict):
+                continue
+            slide_title = str(slide.get("title") or f"Slide {index + 1}").strip()
+            bullets_raw = slide.get("bullets") or []
+            if isinstance(bullets_raw, str):
+                bullets_raw = [bullets_raw]
+            bullets = [str(b).strip() for b in bullets_raw if str(b).strip()]
+            if not bullets:
+                bullets = ["Discuss this topic with the class"]
+            slides_out.append(
+                {
+                    "title": slide_title or f"Slide {index + 1}",
+                    "bullets": bullets,
+                    "speaker_note": str(slide.get("speaker_note") or ""),
+                }
+            )
+        if not slides_out:
+            slides_out.append(
+                {
+                    "title": "Introduction",
+                    "bullets": ["Overview of the topic", "Why it matters"],
+                    "speaker_note": "",
+                }
+            )
+        return {"title": title, "slides": slides_out}
+
+    @staticmethod
+    def _normalize_slide_count(outline: SlideOutline, expected: int) -> SlideOutline:
+        slides = list(outline.slides)
+        if len(slides) > expected:
+            slides = slides[:expected]
+        while len(slides) < expected:
+            number = len(slides) + 1
+            slides.append(
+                SlideSpec(
+                    title=f"More about {outline.title}",
+                    bullets=[
+                        "Key idea to expand in class",
+                        "Question for students",
+                    ],
+                    speaker_note="Add details for this slide during the lesson.",
+                )
+            )
+        return SlideOutline(title=outline.title, slides=slides)
+
+    @staticmethod
+    def _extract_json(text: str) -> dict[str, Any]:
+        cleaned = text.strip()
+        fence = re.search(r"```(?:json)?\s*(\{.*\})\s*```", cleaned, re.DOTALL)
+        if fence:
+            cleaned = fence.group(1)
+        else:
+            start = cleaned.find("{")
+            end = cleaned.rfind("}")
+            if start >= 0 and end > start:
+                cleaned = cleaned[start : end + 1]
+        return json.loads(cleaned)

libs/agent/src/agent/skills.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+@dataclass(frozen=True)
+class Skill:
+    name: str
+    description: str
+    task: str
+    tools: list[str]
+    model_hints: list[str]
+    body: str
+    path: Path
+
+
+def _find_skills_root() -> Path | None:
+    import os
+
+    env_path = os.environ.get("SKILLS_DIR")
+    if env_path:
+        root = Path(env_path)
+        if root.is_dir():
+            return root.resolve()
+
+    for base in (Path.cwd(), *Path.cwd().parents):
+        candidate = base / "skills"
+        if candidate.is_dir():
+            return candidate.resolve()
+    return None
+
+
+def _parse_skill_md(path: Path) -> Skill:
+    text = path.read_text()
+    match = re.match(r"^---\s*\n(.*?)\n---\s*\n(.*)$", text, re.DOTALL)
+    if not match:
+        raise ValueError(f"{path}: expected YAML frontmatter delimited by ---")
+
+    meta: dict[str, Any] = yaml.safe_load(match.group(1)) or {}
+    body = match.group(2).strip()
+
+    return Skill(
+        name=str(meta.get("name", path.parent.name)),
+        description=str(meta.get("description", "")),
+        task=str(meta.get("task", "")),
+        tools=[str(t) for t in meta.get("tools", [])],
+        model_hints=[str(m) for m in meta.get("model_hints", [])],
+        body=body,
+        path=path,
+    )
+
+
+class SkillRegistry:
+    def __init__(self, skills_root: Path | None = None) -> None:
+        self._root = skills_root or _find_skills_root()
+        self._skills: dict[str, Skill] = {}
+        if self._root is not None:
+            self._load_all()
+
+    @property
+    def root(self) -> Path | None:
+        return self._root
+
+    def _load_all(self) -> None:
+        assert self._root is not None
+        for skill_md in sorted(self._root.glob("*/SKILL.md")):
+            skill = _parse_skill_md(skill_md)
+            self._skills[skill.name] = skill
+
+    def get(self, name: str) -> Skill:
+        if name not in self._skills:
+            known = ", ".join(sorted(self._skills)) or "(none found)"
+            raise KeyError(f"Unknown skill {name!r}. Known: {known}")
+        return self._skills[name]
+
+    def list_by_task(self, task: str) -> list[Skill]:
+        return [s for s in self._skills.values() if s.task == task]
+
+    def all(self) -> list[Skill]:
+        return list(self._skills.values())

libs/agent/src/agent/tools/__init__.py

@@ -0,0 +1,4 @@
+from agent.tools.docx import create_docx, create_html_export
+from agent.tools.pptx import create_pptx
+
+__all__ = ["create_docx", "create_html_export", "create_pptx"]

libs/agent/src/agent/tools/docx.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import re
+import uuid
+from pathlib import Path
+
+from docx import Document
+from docx.shared import Pt
+
+from agent.models import SlideOutline
+from agent.tools.pptx import _outputs_dir, _safe_filename
+
+
+def create_docx(outline: SlideOutline, run_id: str | None = None) -> Path:
+    """Build a Word document from a slide outline (opens in Google Docs when uploaded)."""
+    rid = run_id or uuid.uuid4().hex[:12]
+    out_dir = _outputs_dir()
+    filename = f"{_safe_filename(outline.title)}_{rid}.docx"
+    path = out_dir / filename
+
+    doc = Document()
+    title = doc.add_heading(outline.title, level=0)
+    title.runs[0].font.size = Pt(28)
+    doc.add_paragraph("Generated lesson slides").italic = True
+    doc.add_page_break()
+
+    for index, slide in enumerate(outline.slides, start=1):
+        heading = doc.add_heading(f"Slide {index}: {slide.title}", level=1)
+        heading.runs[0].font.size = Pt(22)
+        for bullet in slide.bullets:
+            para = doc.add_paragraph(bullet, style="List Bullet")
+            para.runs[0].font.size = Pt(14)
+        if slide.speaker_note:
+            note = doc.add_paragraph(f"Teacher note: {slide.speaker_note}")
+            note.runs[0].italic = True
+            note.runs[0].font.size = Pt(11)
+        if index < len(outline.slides):
+            doc.add_page_break()
+
+    doc.save(str(path))
+    return path
+
+
+def create_html_export(outline: SlideOutline, run_id: str | None = None) -> Path:
+    """Standalone HTML file — import into Google Docs via File → Open → Upload."""
+    from agent.preview import outline_to_html
+
+    rid = run_id or uuid.uuid4().hex[:12]
+    out_dir = _outputs_dir()
+    filename = f"{_safe_filename(outline.title)}_{rid}.html"
+    path = out_dir / filename
+
+    body = outline_to_html(outline)
+    full = f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <title>{_escape_html(outline.title)}</title>
+</head>
+<body>
+{body}
+</body>
+</html>
+"""
+    path.write_text(full)
+    return path
+
+
+def _escape_html(text: str) -> str:
+    return (
+        text.replace("&", "&amp;")
+        .replace("<", "&lt;")
+        .replace(">", "&gt;")
+        .replace('"', "&quot;")
+    )

libs/agent/src/agent/tools/pptx.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import re
+import uuid
+from pathlib import Path
+
+from pptx import Presentation
+from pptx.util import Inches, Pt
+
+from agent.models import SlideOutline
+
+
+def get_outputs_dir() -> Path:
+    """Directory for generated artifacts (pptx, docx, preview images)."""
+    return _outputs_dir()
+
+
+def _outputs_dir() -> Path:
+    import os
+    import tempfile
+
+    env = os.environ.get("AGENT_OUTPUTS_DIR")
+    if env:
+        path = Path(env)
+    else:
+        path = Path(tempfile.gettempdir()) / "agent_outputs"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def _safe_filename(title: str) -> str:
+    slug = re.sub(r"[^a-zA-Z0-9]+", "_", title.strip().lower()).strip("_")
+    return slug[:60] or "lesson"
+
+
+def create_pptx(outline: SlideOutline, run_id: str | None = None) -> Path:
+    """Build a .pptx from a validated slide outline."""
+    rid = run_id or uuid.uuid4().hex[:12]
+    out_dir = _outputs_dir()
+    filename = f"{_safe_filename(outline.title)}_{rid}.pptx"
+    path = out_dir / filename
+
+    prs = Presentation()
+    prs.slide_width = Inches(10)
+    prs.slide_height = Inches(7.5)
+
+    title_layout = prs.slide_layouts[0]
+    title_slide = prs.slides.add_slide(title_layout)
+    title_slide.shapes.title.text = outline.title
+    if title_slide.placeholders[1].text_frame:
+        title_slide.placeholders[1].text = "Generated lesson slides"
+
+    bullet_layout = prs.slide_layouts[1]
+    for slide_spec in outline.slides:
+        slide = prs.slides.add_slide(bullet_layout)
+        slide.shapes.title.text = slide_spec.title
+        body = slide.placeholders[1].text_frame
+        body.clear()
+        for index, bullet in enumerate(slide_spec.bullets):
+            if index == 0:
+                p = body.paragraphs[0]
+            else:
+                p = body.add_paragraph()
+            p.text = bullet
+            p.level = 0
+            p.font.size = Pt(20)
+        if slide_spec.speaker_note:
+            notes = slide.notes_slide.notes_text_frame
+            notes.text = slide_spec.speaker_note
+
+    prs.save(str(path))
+    return path

libs/agent/src/agent/tools_registry.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+from agent.models import SlideOutline
+from agent.tools.pptx import create_pptx
+
+
+@dataclass(frozen=True)
+class ToolSpec:
+    name: str
+    description: str
+    handler: Callable[..., Any]
+
+
+class ToolRegistry:
+    def __init__(self) -> None:
+        self._tools: dict[str, ToolSpec] = {}
+        self.register(
+            "create_pptx",
+            "Create a PowerPoint file from a validated SlideOutline",
+            self._handle_create_pptx,
+        )
+
+    def register(self, name: str, description: str, handler: Callable[..., Any]) -> None:
+        self._tools[name] = ToolSpec(name=name, description=description, handler=handler)
+
+    def get(self, name: str) -> ToolSpec:
+        if name not in self._tools:
+            raise KeyError(f"Unknown tool {name!r}")
+        return self._tools[name]
+
+    def _handle_create_pptx(self, outline: SlideOutline, run_id: str | None = None) -> str:
+        path = create_pptx(outline, run_id=run_id)
+        return str(path)

libs/agent/src/agent/trace.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import uuid
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+
+def _prompt_hash(text: str) -> str:
+    return hashlib.sha256(text.encode()).hexdigest()[:16]
+
+
+@dataclass
+class TraceRecorder:
+    skill: str
+    model: str
+    user_input: dict[str, Any]
+    run_id: str = field(default_factory=lambda: uuid.uuid4().hex[:12])
+    steps: list[dict[str, Any]] = field(default_factory=list)
+    artifact: str | None = None
+    created_at: str = field(default_factory=lambda: datetime.now(UTC).isoformat())
+
+    def log_llm(self, prompt: str, output: str) -> None:
+        self.steps.append(
+            {
+                "type": "llm",
+                "prompt_hash": _prompt_hash(prompt),
+                "output": output,
+            }
+        )
+
+    def log_note(self, message: str, **details: Any) -> None:
+        self.steps.append({"type": "note", "message": message, **details})
+
+    def log_tool(self, name: str, arguments: dict[str, Any], result: str) -> None:
+        self.steps.append(
+            {
+                "type": "tool",
+                "name": name,
+                "arguments": arguments,
+                "result": result,
+            }
+        )
+
+    def set_artifact(self, path: str) -> None:
+        self.artifact = path
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "run_id": self.run_id,
+            "skill": self.skill,
+            "model": self.model,
+            "input": self.user_input,
+            "steps": self.steps,
+            "artifact": self.artifact,
+            "created_at": self.created_at,
+        }
+
+    def to_json(self, *, indent: int = 2) -> str:
+        return json.dumps(self.to_dict(), indent=indent)
+
+    def save(self, traces_dir: Path | None = None) -> Path:
+        base = traces_dir or _default_traces_dir()
+        base.mkdir(parents=True, exist_ok=True)
+        path = base / f"{self.run_id}.json"
+        path.write_text(self.to_json())
+        return path
+
+
+def _default_traces_dir() -> Path:
+    env = __import__("os").environ.get("AGENT_TRACES_DIR")
+    if env:
+        return Path(env)
+    for base in (Path.cwd(), *Path.cwd().parents):
+        candidate = base / "outputs" / "traces"
+        if (base / "models.yaml").is_file() or (base / "pyproject.toml").is_file():
+            return candidate
+    return Path.cwd() / "outputs" / "traces"

libs/agent/tests/test_runner.py

@@ -0,0 +1,88 @@
+from agent.models import SlideOutline, SlideSpec
+from agent.preview import outline_to_html, render_slide_images
+from agent.runner import AgentRunner
+from agent.tools.docx import create_docx, create_html_export
+from agent.tools.pptx import create_pptx
+
+
+def test_parse_outline_pads_when_model_returns_too_few():
+    runner = AgentRunner()
+    raw = (
+        '{"title": "AI Agents", "slides": ['
+        '{"title": "Intro", "bullets": ["What is an agent?"]},'
+        '{"title": "Uses", "bullets": ["Automation"]}'
+        "]}"
+    )
+    outline = runner._parse_outline(raw, expected_slides=5)
+    assert len(outline.slides) == 5
+    assert outline.title == "AI Agents"
+
+
+def test_parse_outline_trims_when_model_returns_too_many():
+    runner = AgentRunner()
+    raw = (
+        '{"title": "Topic", "slides": ['
+        '{"title": "A", "bullets": ["a"]},'
+        '{"title": "B", "bullets": ["b"]},'
+        '{"title": "C", "bullets": ["c"]},'
+        '{"title": "D", "bullets": ["d"]}'
+        "]}"
+    )
+    outline = runner._parse_outline(raw, expected_slides=3)
+    assert len(outline.slides) == 3
+
+
+def test_extract_json_from_fenced_block():
+    raw = '```json\n{"title": "T", "slides": [{"title": "S", "bullets": ["a"]}]}\n```'
+    data = AgentRunner._extract_json(raw)
+    assert data["title"] == "T"
+
+
+def test_create_pptx_writes_file(tmp_path, monkeypatch):
+    monkeypatch.setenv("AGENT_OUTPUTS_DIR", str(tmp_path))
+    outline = SlideOutline(
+        title="Photosynthesis",
+        slides=[
+            SlideSpec(title="What is it?", bullets=["Plants make food", "Uses sunlight"]),
+            SlideSpec(title="Why it matters", bullets=["Oxygen", "Food chain"]),
+        ],
+    )
+    path = create_pptx(outline, run_id="test")
+    assert path.exists()
+    assert path.suffix == ".pptx"
+
+
+def test_create_docx_writes_file(tmp_path, monkeypatch):
+    monkeypatch.setenv("AGENT_OUTPUTS_DIR", str(tmp_path))
+    outline = SlideOutline(
+        title="Photosynthesis",
+        slides=[SlideSpec(title="Intro", bullets=["Sunlight", "Chlorophyll"])],
+    )
+    path = create_docx(outline, run_id="test")
+    assert path.exists()
+    assert path.suffix == ".docx"
+
+
+def test_outline_preview_and_images(tmp_path, monkeypatch):
+    monkeypatch.setenv("AGENT_OUTPUTS_DIR", str(tmp_path))
+    outline = SlideOutline(
+        title="Water Cycle",
+        slides=[SlideSpec(title="Evaporation", bullets=["Heat", "Vapor"])],
+    )
+    html = outline_to_html(outline)
+    assert "Water Cycle" in html
+    assert "Evaporation" in html
+    images = render_slide_images(outline, run_id="prev")
+    assert len(images) == 2
+    assert all(p.exists() for p in images)
+
+
+def test_create_html_export(tmp_path, monkeypatch):
+    monkeypatch.setenv("AGENT_OUTPUTS_DIR", str(tmp_path))
+    outline = SlideOutline(
+        title="Fractions",
+        slides=[SlideSpec(title="Parts", bullets=["Half", "Quarter"])],
+    )
+    path = create_html_export(outline, run_id="html")
+    assert path.exists()
+    assert "Fractions" in path.read_text()

models.yaml

@@ -3,6 +3,9 @@
 
 defaults:
   active_model: minicpm-v-4.6
+
+  # active_model: minicpm5-1b
+
   # Dev: set ALLOW_MODEL_SWITCH=true in .env to expose a dropdown in Gradio.
   # Space: keep false so visitors use one pinned model.
   allow_model_switch: false

outputs/traces/5ffe463cd9ff.json

@@ -0,0 +1,28 @@
+{
+  "run_id": "5ffe463cd9ff",
+  "skill": "education-pptx",
+  "model": "minicpm5-1b",
+  "input": {
+    "topic": "ai agent",
+    "grade": "6",
+    "slide_count": 5
+  },
+  "steps": [
+    {
+      "type": "llm",
+      "prompt_hash": "92e1b034dc5f5dca",
+      "output": "<think>\nThe user wants a lesson plan for teaching AI agent to grade level 6 students. I need to create a JSON outline with 5 slides. The topic is \"AI Agent\", grade level is 6, and content slides are 5.\n\nI'll structure the JSON with a title and then 5 slides. Each slide should have a title, bullets (short factual statements), and optionally a speaker_note. I'll make sure to keep it simple and age-appropriate for 6th graders.\n\nLet me outline the content:\n\n1. Introduction to AI Agent\n2. What is an AI Agent?\n3. Key features of an AI Agent\n4. How AI Agents work\n5. Real-world applications\n\nI'll make sure each slide has 2-3 bullets for brevity. The speaker_note can be brief if helpful.\n\nNow, I'll generate the JSON accordingly.\n</think>\n\n{\n  \"title\": \"AI Agent: Teaching a 6th Grade\",\n  \"slides\": [\n    {\n      \"title\": \"Introduction to AI Agent\",\n      \"bullets\": [\n        \"An AI Agent is a computer program that can perform tasks for you.\",\n        \"It can learn from experience and improve over time.\",\n        \"It can be used for many different tasks.\"\n      ],\n      \"speaker_note\": \"AI agents are like helpful digital assistants that can help with homework, answering questions, and more.\"\n    },\n    {\n      \"title\": \"What is an AI Agent?\",\n      \"bullets\": [\n        \"An AI Agent is a program that can learn from experience and improve over time.\",\n        \"It can be used for many different tasks, such as answering questions, helping with homework, and more.\"\n      ],\n      \"speaker_note\": \"Think of it as a smart program that can learn from your interactions and become better over time.\"\n    },\n    {\n      \"title\": \"Key Features of an AI Agent\",\n      \"bullets\": [\n        \"It can learn from experience and improve over time.\",\n        \"It can be used for many different tasks, such as answering questions, helping with homework, and more.\"\n      ],\n      \"speaker_note\": \"AI agents are designed to be helpful and efficient in their tasks.\"\n    },\n    {\n      \"title\": \"How AI Agents Work\",\n      \"bullets\": [\n        \"An AI Agent uses algorithms and data to make decisions.\",\n        \"It learns from user interactions to become more accurate over time.\",\n        \"It can be programmed to perform specific tasks.\"\n      ],\n      \"speaker_note\": \"AI agents use algorithms to make decisions based on data.\"\n    },\n    {\n      \"title\": \"Real-World Applications\",\n      \"bullets\": [\n        \"AI agents can help with homework, answering questions, and more.\",\n        \"They can be used in many different fields, like education, customer service, and more.\"\n      ],\n      \"speaker_note\": \"AI agents are used in many different fields, including education and customer service.\"\n    }\n  ]\n}"
+    },
+    {
+      "type": "tool",
+      "name": "create_pptx",
+      "arguments": {
+        "title": "AI Agent: Teaching a 6th Grade",
+        "slide_count": 5
+      },
+      "result": "/tmp/agent_outputs/ai_agent_teaching_a_6th_grade_5ffe463cd9ff.pptx"
+    }
+  ],
+  "artifact": "/tmp/agent_outputs/ai_agent_teaching_a_6th_grade_5ffe463cd9ff.pptx",
+  "created_at": "2026-06-11T12:15:49.294920+00:00"
+}

pyproject.toml

@@ -5,6 +5,7 @@ description = "Build Small Hackathon — Gradio Space with local llama.cpp infer
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
+    "agent",
     "gradio-space",
     "inference",
 ]
@@ -22,5 +23,6 @@ members = [
 ]
 
 [tool.uv.sources]
+agent = { workspace = true }
 gradio-space = { workspace = true }
 inference = { workspace = true }

scripts/upload_trace.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""Upload the latest agent trace JSON to a Hugging Face dataset repo."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+
+from huggingface_hub import HfApi
+
+
+def _latest_trace(traces_dir: Path) -> Path:
+    files = sorted(traces_dir.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True)
+    if not files:
+        raise FileNotFoundError(f"No trace files in {traces_dir}")
+    return files[0]
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Upload agent trace to HF dataset")
+    parser.add_argument(
+        "--traces-dir",
+        type=Path,
+        default=Path(os.environ.get("AGENT_TRACES_DIR", "outputs/traces")),
+    )
+    parser.add_argument(
+        "--repo-id",
+        required=True,
+        help="HF dataset repo, e.g. username/build-small-agent-traces",
+    )
+    parser.add_argument("--trace", type=Path, default=None, help="Specific trace file")
+    args = parser.parse_args()
+
+    trace_path = args.trace or _latest_trace(args.traces_dir)
+    data = json.loads(trace_path.read_text())
+
+    api = HfApi()
+    api.create_repo(args.repo_id, repo_type="dataset", exist_ok=True)
+    api.upload_file(
+        path_or_fileobj=trace_path.read_bytes(),
+        path_in_repo=f"traces/{trace_path.name}",
+        repo_id=args.repo_id,
+        repo_type="dataset",
+        commit_message=f"Add agent trace {trace_path.stem}",
+    )
+
+    print(f"Uploaded {trace_path} -> {args.repo_id}/traces/{trace_path.name}")
+    print(f"Skill: {data.get('skill')} | Model: {data.get('model')} | Run: {data.get('run_id')}")
+
+
+if __name__ == "__main__":
+    main()

skills/education-pptx/SKILL.md

@@ -0,0 +1,17 @@
+---
+name: education-pptx
+description: Create a short lesson PowerPoint from a topic and grade level
+task: education
+tools:
+  - create_pptx
+model_hints:
+  - minicpm5-1b
+  - qwen3b-gguf
+---
+
+## Workflow
+
+1. Ask for topic, audience grade, and slide count (3–8 content slides).
+2. Produce a JSON outline with `title` and `slides` (each slide has `title`, `bullets`, `speaker_note`).
+3. Call `create_pptx` with the validated outline.
+4. Return a download link and markdown preview for the teacher.

uv.lock

@@ -15,6 +15,7 @@ resolution-markers = [
 
 [manifest]
 members = [
+    "agent",
     "gradio-space",
     "inference",
     "small-model-hackathon",
@@ -38,6 +39,29 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/7e/46/02ac5e262d4af18054b3e922b2baedbb2a03289ee792162de60a865defc5/accelerate-1.13.0-py3-none-any.whl", hash = "sha256:cf1a3efb96c18f7b152eb0fa7490f3710b19c3f395699358f08decca2b8b62e0", size = 383744, upload-time = "2026-03-04T19:34:10.313Z" },
 ]
 
+[[package]]
+name = "agent"
+version = "0.1.0"
+source = { editable = "libs/agent" }
+dependencies = [
+    { name = "inference" },
+    { name = "pillow" },
+    { name = "pydantic" },
+    { name = "python-docx" },
+    { name = "python-pptx" },
+    { name = "pyyaml" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "inference", editable = "libs/inference" },
+    { name = "pillow", specifier = ">=10.0.0" },
+    { name = "pydantic", specifier = ">=2.0.0" },
+    { name = "python-docx", specifier = ">=1.1.0" },
+    { name = "python-pptx", specifier = ">=1.0.0" },
+    { name = "pyyaml", specifier = ">=6.0.2" },
+]
+
 [[package]]
 name = "annotated-doc"
 version = "0.0.4"
@@ -362,12 +386,14 @@ name = "gradio-space"
 version = "0.1.0"
 source = { editable = "apps/gradio-space" }
 dependencies = [
+    { name = "agent" },
     { name = "gradio" },
     { name = "inference" },
 ]
 
 [package.metadata]
 requires-dist = [
+    { name = "agent", editable = "libs/agent" },
     { name = "gradio", specifier = ">=5.0.0" },
     { name = "inference", editable = "libs/inference" },
 ]
@@ -551,6 +577,86 @@ dependencies = [
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/6e/1a/4cf485fccebb768cb07b54a497335127235852e2d9a50b219e754c7a4c8d/llama_cpp_python-0.3.26.tar.gz", hash = "sha256:71b004d52a274273ae03ec954d62771d26c86f32193fd30be57601508bec0064", size = 68011908, upload-time = "2026-06-05T02:14:43.27Z" }
 
+[[package]]
+name = "lxml"
+version = "6.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/3b/aab6728cae887456f409b4d75e8a01856e4f04bd510de38052a47768b680/lxml-6.1.1.tar.gz", hash = "sha256:ba96ae44888e0185281e937633a743ea90d5a196c6000f82565ebb0580012d40", size = 4197430, upload-time = "2026-05-18T19:19:06.424Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6a/6e/c4add832b6fc1e887125b96f880d7b9b70aae5248718e046b1704bcac4b9/lxml-6.1.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:104c09bda8d2a562824c0e319d0768ce26a779b7601e0931d33b09b53c392ef7", size = 8570821, upload-time = "2026-05-18T19:17:42.068Z" },
+    { url = "https://files.pythonhosted.org/packages/22/00/ff3009c88e65de8011630acf8ab5a09cb2becd2aaf47fba2f3449f6224e9/lxml-6.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:25c6997a9a534e016695a0ba06b2f07945de682731ff01065b6d5a4474179da1", size = 4624252, upload-time = "2026-05-18T19:17:47.897Z" },
+    { url = "https://files.pythonhosted.org/packages/42/95/bb63f0fd62e554fe078e1fb3c8fe9083c14ddc7ad7fa178d10e57e071ac7/lxml-6.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c921ba5c51e4e9f63b8b00267d06566e1f63407408a0496da2d1d0bfc819c7fc", size = 4930746, upload-time = "2026-05-18T19:18:29.637Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/99/0013e8d9b5960f4f041cf0b73e2f80c23eb5205b1f7bfb20203243651359/lxml-6.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:54a7f95e4de5fb94e2f9f4b9055c6ba33bf3d628fd77a1d647c5923caa2cdcdc", size = 5093723, upload-time = "2026-05-18T19:18:34.168Z" },
+    { url = "https://files.pythonhosted.org/packages/29/91/317b332636bfc7bddcff828d41b3307f50043f4b237e40849c333d80fa1a/lxml-6.1.1-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f2ec43df44b1f76249ee0a615334f9b5b060e1c8bd90e706dad2d14d02f383", size = 5005557, upload-time = "2026-05-18T19:18:39.798Z" },
+    { url = "https://files.pythonhosted.org/packages/42/2f/cc9bf06afe70f9c9093ae60855d9759da9db601ec4080f7473319666ffd7/lxml-6.1.1-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:70ef8a7e102a1508f8121aae5b0867abd663f72c14f0a9c937e6554cb4587b7b", size = 5631036, upload-time = "2026-05-18T19:18:44.858Z" },
+    { url = "https://files.pythonhosted.org/packages/08/f6/af32e23e563971ffb0fb86be52bc5be5c2c118858ffc119bf6a9039b173d/lxml-6.1.1-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ebe6af670449830d6d9b752c256a983291c766a1365ba5d5460048f9e33a7818", size = 5240367, upload-time = "2026-05-18T19:18:49.217Z" },
+    { url = "https://files.pythonhosted.org/packages/78/83/8555d40948b09ce86f1bd0c68a7ac31d07b1929f92cc1b074006c97ef2d2/lxml-6.1.1-cp312-cp312-manylinux_2_28_i686.whl", hash = "sha256:27acc820660aaffa4f7c087f29120e12980f7779d56d8492d263170111284740", size = 5350171, upload-time = "2026-05-18T19:18:52.779Z" },
+    { url = "https://files.pythonhosted.org/packages/63/75/5d92da93729b7bad783689e6496049fa40927b45bec7bf183c981de3ca70/lxml-6.1.1-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:1db753c9115ec7100d073b744d17e25e88a8f90f5c39b2f5dd878149af59671f", size = 4694874, upload-time = "2026-05-18T19:18:55.139Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/b5/3aad415a9a25b822e783f15deeb4dffccf5113030f1afa2222dd929313d9/lxml-6.1.1-cp312-cp312-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c4f469aebd783bb741c2ecb2a681008fd26bfe5c16a9a72ed5467f834e810df2", size = 5244492, upload-time = "2026-05-18T19:19:01.28Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/a1/5fcf7eb9904b80086aa47dcf0027de07b1bb990afad2e6823144c368ae04/lxml-6.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:766b010012d59470072c1816b5b6c69f1d243e5db36ea5968e94accf430a4635", size = 5048232, upload-time = "2026-05-18T19:18:12.67Z" },
+    { url = "https://files.pythonhosted.org/packages/77/74/1f601b63c7a69fcdf10fa9b148c81da8442204194f6c55509cc485c786b9/lxml-6.1.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b8d812c6011c08b8111a15e54dd990b8923692d80adf35488bee34026c35accf", size = 4777023, upload-time = "2026-05-18T19:18:15.928Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/b9/7a78f51aec95b1bf780d78e12705a9f6533284f8693dc5c0e6724fa53d3f/lxml-6.1.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:fe0306bd29505a9177aac19f1877174b0e7422c222a59f70b2cd41633448c3dc", size = 5645773, upload-time = "2026-05-18T19:18:23.223Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/6e/98a7b7ad54e4e74fa1f20fff776913980619d0ebe5558232d7da6580bdd8/lxml-6.1.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:5ba186ad207446c65d3bb3d3e0412b032b1d9f595e59861e2354798c5703d955", size = 5233088, upload-time = "2026-05-18T19:18:31.433Z" },
+    { url = "https://files.pythonhosted.org/packages/65/d1/bc0ed2427bf609f2ee10da303a6a226f9c8bce94f945dc29a32ce55de6e4/lxml-6.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:aa366a1e55b8ebfe8ca8ddc3cfe75c8ebade181aeb0f661d0cb05986b647f72a", size = 5260995, upload-time = "2026-05-18T19:18:37.091Z" },
+    { url = "https://files.pythonhosted.org/packages/69/8b/6772e1a4b513fc50a8d931f19edde0e13ae6918510a1e13ff67864f3e5ed/lxml-6.1.1-cp312-cp312-win32.whl", hash = "sha256:126c93f7f56f0eda92f6d8c619edc463a4f23d9252f1c9d0405a76f25fa9f11a", size = 3596382, upload-time = "2026-05-18T19:17:18.37Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/89/45198e9624762af2dfd2cb8782598477ceb29f6e59caab560388ae1f4ec1/lxml-6.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:26e6eda8d38c1fcab1090dd196ee87cbd13788e531937610e2589085de074e77", size = 3997255, upload-time = "2026-05-18T19:17:56.781Z" },
+    { url = "https://files.pythonhosted.org/packages/90/a9/7a54b6834088d9ae528a7b780584ba6a39a9457b0ac330479f20ffbc9449/lxml-6.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:6540377fbd53fe1b629172288c464fb18db11ce1fa7dc15891da10aa9dcc3e7f", size = 3659610, upload-time = "2026-05-19T19:22:50.843Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/eb/7e6f37c5584ccbb2ff267f56fd0339016938c1c8684cfefab9b33ffc2f36/lxml-6.1.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:68a9198d0fc122d14bb76837de9aa80cf84caed990b5b237f532ed87d3706736", size = 8559780, upload-time = "2026-05-18T19:17:57.661Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/36/587c2521cf23a2cd6c9c22108aa7528f683a1f195ed7ccd23a4b1786ad36/lxml-6.1.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7d47866cb32fb503450b6edc9df355d10dc49836af2e89901bd6ac6b0896d9d9", size = 4618006, upload-time = "2026-05-18T19:18:04.452Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/ca/ab7bfe2bf4c972af5e7878262845ead3a24a929a9b04bc11c7c1ece6c82a/lxml-6.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:eb7c9811bfaa8b1ed5ed319f5d370dfbcaa59d52ea64be2a5a85e18195930354", size = 4924139, upload-time = "2026-05-18T19:19:04.873Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/55/a0c72851dfee5ecc689f949723a73dea457758912542cb955b108eaf0d8f/lxml-6.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:762ff394d5bd56da0cf034a23dcce4e13923f15321a2adfa2ac00201dc6d3fca", size = 5082329, upload-time = "2026-05-18T19:19:09.728Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/b6/0608f7d61a3b96cc67e5648a3d906e31a5082093e10e7be65b3886289938/lxml-6.1.1-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a088f287f7d8275a33c07f2cac6c50b9319309a0200a39e7e75d80c707723099", size = 4993564, upload-time = "2026-05-18T19:19:13.608Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/66/ae227524b066d29d55bf0b453d93d2d793c40218657d643dcbbca13b8faf/lxml-6.1.1-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e902da4b04e6b52e5893900d4b8ab46068f75f3561f01bf1080957f9fd932ed6", size = 5613467, upload-time = "2026-05-18T19:19:16.228Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/76/dbe4a00b50385e40194231dcfe5a12c059de7cf90e89c83407d2b085b719/lxml-6.1.1-cp313-cp313-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1d4962d4c66bf830a7e59ed6cfc17d148149898a3aefa8ec6e59763e6e3ed085", size = 5228304, upload-time = "2026-05-18T19:19:19.354Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/01/00b1b8442ed2041793336868ba0b9ea4b13d7da7c085c6404c207a63bf79/lxml-6.1.1-cp313-cp313-manylinux_2_28_i686.whl", hash = "sha256:581d4c8ae690a6609e64862dd6b7c2489635c2d13907fc2b20f2bc200ff1d21e", size = 5341607, upload-time = "2026-05-18T19:19:22.297Z" },
+    { url = "https://files.pythonhosted.org/packages/63/36/1ad29931e9a4638bb707869f01d423a6c815f82152138d1a40dfcfde2b95/lxml-6.1.1-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:876e1ff5930ed8bf295ec5ef9a8155e9b6b1876bbf1deed8b3a8069311875a8f", size = 4700168, upload-time = "2026-05-18T19:19:25.133Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/d1/a9536cecf9be18a0dc72d32bead283a2332d1ffebd2dd3ac70ce444686e5/lxml-6.1.1-cp313-cp313-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9eb9b5a968f6e0f6d640092a567e14529ff8cea2e29d00da6f78a79fa49f013c", size = 5232487, upload-time = "2026-05-18T19:19:28.603Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/77/b4fb1e03bf5d130e879214d3100092e386418807fb74dd0adc4b0a48f351/lxml-6.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:aa49e06d94aba782c6a02eecb7e507969e7e7a41b267f1b359bb35585f295d5b", size = 5044231, upload-time = "2026-05-18T19:18:42.246Z" },
+    { url = "https://files.pythonhosted.org/packages/26/4c/d00daeeb0a5530c4028a9232aa1b93db3ef4ed2158c116ea73c79a9765b3/lxml-6.1.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:70cdfd80589d59e43e18005dd7244e8895e93db8ab6a620b7e23df5445a4e3d2", size = 4769450, upload-time = "2026-05-18T19:18:48.013Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/6a/715a3a8d156ce42f29cf014706f5410c2ff3b02267774110fc23266409fe/lxml-6.1.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:aad9aa39483ed8ec44d6d2e59e5b98a0d80676ef0d92f44bfc374836111f62f5", size = 5635874, upload-time = "2026-05-18T19:18:51.914Z" },
+    { url = "https://files.pythonhosted.org/packages/45/37/0544bc21dde2a88f3a17b504e6fc79c0e01d25a33c2f6079724e9e72b9c7/lxml-6.1.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:d49514be2f28d895c38cf9d2b72d7b9a07d00314519f456c0b50b53cfcf4c785", size = 5223987, upload-time = "2026-05-18T19:18:59.715Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/f8/f6a5e8185bcb28c2befae3d31f8e3df3b811cb0f47746517a81279fcafe1/lxml-6.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:47402e62c52ff5988c1e8c6c63177f5708bccf48e366dea4e3dcf1e645e04947", size = 5250276, upload-time = "2026-05-18T19:19:03.834Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/f2/1a2b9f1b7a49d45495369be7ef9ad05b262930f2eab3e3145706fca8083f/lxml-6.1.1-cp313-cp313-win32.whl", hash = "sha256:3483644525531e1d5762b0c44a8e18b6efba321b6dcf8a8952de10b037618bca", size = 3596903, upload-time = "2026-05-18T19:17:29.863Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/99/f4ffb024f238eec2131aaa09f3278fb6129cf892741bf68e1fc1afb8c100/lxml-6.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:a10bd2fd62e8ce916ececb342f348f190724a098c1faa056fdfb2a22ad5e8660", size = 3995869, upload-time = "2026-05-18T19:18:02.596Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/53/70eb8c5c6037f27448f1e3c54ebede9545a801ae63f0a7254afca4fe8e45/lxml-6.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:424aa57aca0897eb922aef34395bd1289b3b6f04e6bae20ea123c0c7e333cffc", size = 3658490, upload-time = "2026-05-19T19:22:53.846Z" },
+    { url = "https://files.pythonhosted.org/packages/13/e2/2e325795566de01d0d7c3bb57d3c370616b2d07b01214e84eec5d3b10963/lxml-6.1.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:19b7ab10b210b0b3ad7985d9ac4eb66ab09a90b20fe6e2f7ba55d01a234345d0", size = 8577146, upload-time = "2026-05-18T19:18:17.765Z" },
+    { url = "https://files.pythonhosted.org/packages/93/cf/5630b5e4be7d2e6bee8efe83865c925221103cf0221303b104ce134b01e2/lxml-6.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:c08e5c694306507275f2290073350c4f32e383db15213b2c69e7ff39c1193840", size = 4623866, upload-time = "2026-05-18T19:18:30.669Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/51/3904907c063451cf8d4a5c9fe0cad95fa1f4ec57f4e3884fa0731bd7a305/lxml-6.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:74a9717fd0d82effef5c2854f0d917231d5324b5a3eb7275c43ac9fa32f97a14", size = 4950022, upload-time = "2026-05-18T19:19:31.958Z" },
+    { url = "https://files.pythonhosted.org/packages/94/cd/9c7611a51c37a2830928405817cc5d56a97f64fab83cc3f628748b135749/lxml-6.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:efe0374196335f93b53269acd811b944f2e6bdc88e8894f214bd636455484909", size = 5086695, upload-time = "2026-05-18T19:19:34.764Z" },
+    { url = "https://files.pythonhosted.org/packages/da/d6/24e3b5906abb0b674ff2ae195bc3ce59708df2bcd17cf17703b2d7dd643a/lxml-6.1.1-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ac931cdc9442c1763b8a8f6cd62c0c938737eafc5be75eff88df55fc73bc0d00", size = 5031642, upload-time = "2026-05-18T19:19:37.771Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/db/6ec54f99019838bff54785c51da07f189eb4676861c5f2730962b0d8d665/lxml-6.1.1-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:aee395f5d0927f947758b4ec119fd5fc8ec71f07a1c5c52077b30b04c0fa6955", size = 5647338, upload-time = "2026-05-18T19:19:40.553Z" },
+    { url = "https://files.pythonhosted.org/packages/42/3d/ef4dcfffd22d27a61805d8ed9f7fb888495bc6aa88648fa07c1eaa5586b6/lxml-6.1.1-cp314-cp314-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9395002973c827b3ed67db77e6ec09f092919a587022174554096a269378fb13", size = 5239528, upload-time = "2026-05-18T19:19:43.657Z" },
+    { url = "https://files.pythonhosted.org/packages/62/bb/37fb3f0dff146bdcfa78eec47879273820b2a0bf350ec236ce14bd0b1c26/lxml-6.1.1-cp314-cp314-manylinux_2_28_i686.whl", hash = "sha256:73bc2086f141224ebddb7fc5c6a36ca58b31b94b561e1dfe8e073e3270fad1e7", size = 5350730, upload-time = "2026-05-18T19:19:46.307Z" },
+    { url = "https://files.pythonhosted.org/packages/90/42/43253f168388df4fae1f38c01df36ddb9bee39e2048167b54cdcbae85ea3/lxml-6.1.1-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:3779def59032b81e44a5f70096ef6bf2082f8d901937dca354474ba09782e245", size = 4697530, upload-time = "2026-05-18T19:19:49.889Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/a8/c5a8504f81bbdfc8e7094c2c850cdb4ed6777fc4d5ddd9e5ab819f3b0d54/lxml-6.1.1-cp314-cp314-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:86c89b9d55ebf820ad7c90bc533410f0d098054f293351f10603c0c46ff598f5", size = 5250670, upload-time = "2026-05-18T19:19:53.199Z" },
+    { url = "https://files.pythonhosted.org/packages/77/b7/c7e76ab18744d75e21f320ebf9ff9d1ceae2b54dd431ea5a64caf26c9672/lxml-6.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:19607c6bbff2a44cf3fe8250abccd20942d3462473e0a721d01d379ed017e462", size = 5084485, upload-time = "2026-05-18T19:19:08.422Z" },
+    { url = "https://files.pythonhosted.org/packages/31/31/b35c53f8ef7b7c31cacd23d3638652fff7bcd1deb6eedb709ab43b685908/lxml-6.1.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:c6ed5141a5c7507cf3ee76bd363b0d6f801e3321adc35b5d825a23115faa5465", size = 4737635, upload-time = "2026-05-18T19:19:12.321Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/06/31f23c813a7fe8e0cb1b175e915b08c9bf4e86d225b210feadbdbe519667/lxml-6.1.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:62aeb7e85b5d60320b9d77eef2e773994e2c0ce10121b277e0a19804e1654a5a", size = 5670681, upload-time = "2026-05-18T19:19:15.001Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/bc/ce619bccc89b1fd9ad8a8e1330ee3f3beff9f2ff95b712d7bbcdd6e22fc3/lxml-6.1.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:b1b963fd8f5caa68e99dfae060d54de1fe9cba899b8718b44a00cdca53c3e590", size = 5238229, upload-time = "2026-05-18T19:19:18.131Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/5d/b329acbbedc0b619ebc2be6cf7ee9ed07e80892c88d4dfd612c33805789a/lxml-6.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:63876be28efefa04a1df615b46770e82042cce445cfdce55160522f57b231ccb", size = 5264191, upload-time = "2026-05-18T19:19:21.118Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/85/be36fb1425b30db3c3f9df75fe86343ebffb79e6320bd7f588e25bfeac39/lxml-6.1.1-cp314-cp314-win32.whl", hash = "sha256:7f7a92e8583f06b1fd49d01158143b8461cfcd135dcb10ec807270a3051bd603", size = 3657202, upload-time = "2026-05-18T19:17:39.509Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/ce/3cf9a827342269f54d405a6202397de63f07c69cbd6ce7d183a3f0cba1e9/lxml-6.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:b2d444f2e66624d68e9c6b211e28a76e22fff5fcabcfff4deac18b529b7d4137", size = 4064497, upload-time = "2026-05-18T19:18:14.662Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/3e/1a957bde8f0760039e627f94699f82caa782c9d838d86c3d28245ee67212/lxml-6.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:3fd9728a2735fda14f4e8235830c86b539e9661e849665bf926d3f867943b4bf", size = 3741991, upload-time = "2026-05-19T19:22:59.111Z" },
+    { url = "https://files.pythonhosted.org/packages/78/b2/00ed55b3a2efa4658fb795c38d1090ec9b3e8a6c3683d4441fa517f09c3b/lxml-6.1.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:787b2496d0dbe8cd180984e8d29e3a6f76e7ea34db781cb3bd55e4ba1ef8b4ee", size = 8827545, upload-time = "2026-05-18T19:18:41.193Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/73/74573db19baa618d5f266f2407898b087ff6927115b00b71e5fc1b700847/lxml-6.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2c8daa471358dc2d6fcf02165e80ec68f77871a286df95bc5cc3816153b0fd2c", size = 4735736, upload-time = "2026-05-18T19:18:46.761Z" },
+    { url = "https://files.pythonhosted.org/packages/16/02/6f7061f4f95f51e545d48e87647c54791d204a4e881be4156e7a26ba5338/lxml-6.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:acd7d70b64c0aae0c7922cca83d288a16f5f6da523637697872253415269baef", size = 4970291, upload-time = "2026-05-18T19:19:56.215Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/02/55fc057d8283427dea7d6edb102e7a840239c77a64a983d92f62a304c0e9/lxml-6.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4f0dd2f01f9f8a89f565d000e03abcf0a13d692a346c8d22f628d49af098777a", size = 5102822, upload-time = "2026-05-18T19:19:59.223Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/48/8e1cf78d89d66850121d9255a2a24414c98f775da93b90cf976956c24b14/lxml-6.1.1-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0b7e8a14c8634bf6f7a568634cb395305a6d964aeb5b7ee32248094bed3a7e2c", size = 5027923, upload-time = "2026-05-18T19:20:01.549Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/00/0632a0647612c8af24d26997b3b961397daa9d5b2581444805933629a4cb/lxml-6.1.1-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:86281fbdd6a8162756f8d603f37e3435bfa38043adb79c6dc6a2dfee065e7525", size = 5595843, upload-time = "2026-05-18T19:20:03.93Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/86/ab008a7dc360711b66858d61c80a5979a70a09f2aa2b05d9698df80b803d/lxml-6.1.1-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c5d7152ec39ca7c402d8fb9bad86140a15b9503bd0c54484e3f1bbe3dd37ceca", size = 5224515, upload-time = "2026-05-18T19:20:06.381Z" },
+    { url = "https://files.pythonhosted.org/packages/75/c6/2702ff375e728e34f56d9a45339a9cf7e4427e917f542225242d63a05afa/lxml-6.1.1-cp314-cp314t-manylinux_2_28_i686.whl", hash = "sha256:88d8cb75b9d82858497a5393e3c63cfbf03035225e4b35a49ed7ccb151e4dc0e", size = 5312511, upload-time = "2026-05-18T19:20:09.308Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/57/a5807c98f87a86f10ef9ffab35516df7c0f0c4b6d5d33e9f608ab9c04a31/lxml-6.1.1-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:f64ec5397ea6a41fc1b4af0380d79b44a755b5531dcaccd9940fb260dca93038", size = 4639206, upload-time = "2026-05-18T19:20:11.704Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/e1/8a0a2c35734812395f4da4eaf33748a7e5705bfb2a58b128da764339d5ec/lxml-6.1.1-cp314-cp314t-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d34bbf07dbc7ca5970671b1512e928991fb5e9d95365636c9b2d8b4f53af405e", size = 5232404, upload-time = "2026-05-18T19:20:14.064Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/e2/0e6a4dd5ad84d01d99aa7bae7cfefd4a760a0e0f8176818241de17d9b6c0/lxml-6.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:17e0e18d4ad8adbd0399291bc44845b69d9dd68439a3cdebdf35ff902ec05072", size = 5083769, upload-time = "2026-05-18T19:19:23.758Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/7e/161f33d463f6ffc1c7679104b65086dea120080d49dde4d238f015aaee2f/lxml-6.1.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:3ab541146f1f6968c462d6c2ac495148e8cdba2f8347700b2141b6ec5a75bf52", size = 4758936, upload-time = "2026-05-18T19:19:27.256Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/fb/2369825e3f6ca99305bf9f7b7085fda91c8b0922a89e54d900974aa3ef85/lxml-6.1.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:2a0217714657e023ef4293500f65aa20fce6164c8fd6b08fa5bd4a859fb14b9b", size = 5620296, upload-time = "2026-05-18T19:19:29.993Z" },
+    { url = "https://files.pythonhosted.org/packages/30/90/d61e383146f74c5ab683947ea14dc7b82778838ab9b95ea73a23b60d0191/lxml-6.1.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:05a82eb6e1530a64f26225b55cbd178113bd0b5af1c2b625f25e5296742c26d2", size = 5228598, upload-time = "2026-05-18T19:19:33.523Z" },
+    { url = "https://files.pythonhosted.org/packages/76/2d/2dafd8149e94b05bb070690efd5bb2680720681e03ff03fc57d2b70a1105/lxml-6.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:9e36f163528fc50cbef305f02a5fd66d404edf7049cdaff211dbc2cba5a7013e", size = 5247845, upload-time = "2026-05-18T19:19:36.649Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/68/b30e913340c380ddac9580c6e6230991fc37240ec4f64704833e4f3e2769/lxml-6.1.1-cp314-cp314t-win32.whl", hash = "sha256:649dda677cf3bd6ac9ae14007ba0c824ded8ce5808b53fc7431d9140399118c1", size = 3897345, upload-time = "2026-05-18T19:17:33.562Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/4e/9eb2af5335545f9fbcd7af57bcf87c6025d31eaa31b14ec184a6c8675328/lxml-6.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:793033d6c5cdf33a573f910d9bea14ef8f5771820411d118da8e1182edb53d5e", size = 4393350, upload-time = "2026-05-18T19:18:10.076Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/2c/0f1e93c636720e8a3eb59af2bfda99d98b55891e1c53bc30c2e0e865f01b/lxml-6.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:58bb955caba94e467d2a96da17660d2d704e0675894cba21ab8a775b8621fd1c", size = 3817223, upload-time = "2026-05-19T19:22:56.823Z" },
+]
+
 [[package]]
 name = "markdown-it-py"
 version = "4.2.0"
@@ -1222,6 +1328,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
 ]
 
+[[package]]
+name = "python-docx"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "lxml" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a9/f7/eddfe33871520adab45aaa1a71f0402a2252050c14c7e3009446c8f4701c/python_docx-1.2.0.tar.gz", hash = "sha256:7bc9d7b7d8a69c9c02ca09216118c86552704edc23bac179283f2e38f86220ce", size = 5723256, upload-time = "2025-06-16T20:46:27.921Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d0/00/1e03a4989fa5795da308cd774f05b704ace555a70f9bf9d3be057b680bcf/python_docx-1.2.0-py3-none-any.whl", hash = "sha256:3fd478f3250fbbbfd3b94fe1e985955737c145627498896a8a6bf81f4baf66c7", size = 252987, upload-time = "2025-06-16T20:46:22.506Z" },
+]
+
 [[package]]
 name = "python-multipart"
 version = "0.0.32"
@@ -1231,6 +1350,21 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e1/04/e8135ebd1ad02c56ec633277529b2602ff99ff634be76cdba5744cf554fd/python_multipart-0.0.32-py3-none-any.whl", hash = "sha256:ff6d3f776f16878c894e52e107296ffc890e913c611b1a4ec6c44e2821fe2e23", size = 30042, upload-time = "2026-06-04T16:18:57.319Z" },
 ]
 
+[[package]]
+name = "python-pptx"
+version = "1.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "lxml" },
+    { name = "pillow" },
+    { name = "typing-extensions" },
+    { name = "xlsxwriter" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/52/a9/0c0db8d37b2b8a645666f7fd8accea4c6224e013c42b1d5c17c93590cd06/python_pptx-1.0.2.tar.gz", hash = "sha256:479a8af0eaf0f0d76b6f00b0887732874ad2e3188230315290cd1f9dd9cc7095", size = 10109297, upload-time = "2024-08-07T17:33:37.772Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d9/4f/00be2196329ebbff56ce564aa94efb0fbc828d00de250b1980de1a34ab49/python_pptx-1.0.2-py3-none-any.whl", hash = "sha256:160838e0b8565a8b1f67947675886e9fea18aa5e795db7ae531606d68e785cba", size = 472788, upload-time = "2024-08-07T17:33:28.192Z" },
+]
+
 [[package]]
 name = "pytz"
 version = "2026.2"
@@ -1487,6 +1621,7 @@ name = "small-model-hackathon"
 version = "0.1.0"
 source = { virtual = "." }
 dependencies = [
+    { name = "agent" },
     { name = "gradio-space" },
     { name = "inference" },
 ]
@@ -1499,6 +1634,7 @@ dev = [
 
 [package.metadata]
 requires-dist = [
+    { name = "agent", editable = "libs/agent" },
     { name = "gradio-space", editable = "apps/gradio-space" },
     { name = "inference", editable = "libs/inference" },
 ]
@@ -1751,3 +1887,12 @@ sdist = { url = "https://files.pythonhosted.org/packages/c4/1f/fa18009dea8469069
 wheels = [
     { url = "https://files.pythonhosted.org/packages/88/fa/e1388bbcf24ef3274f45c0c1c7b501fd14971037c1b6ee23610553307497/uvicorn-0.49.0-py3-none-any.whl", hash = "sha256:ba3d14c3ee7e41c6c654c46c9eb489d33213cdd30aa1696eab1374337c13f68f", size = 71376, upload-time = "2026-06-03T22:01:29.037Z" },
 ]
+
+[[package]]
+name = "xlsxwriter"
+version = "3.2.9"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/2c/c06ef49dc36e7954e55b802a8b231770d286a9758b3d936bd1e04ce5ba88/xlsxwriter-3.2.9.tar.gz", hash = "sha256:254b1c37a368c444eac6e2f867405cc9e461b0ed97a3233b2ac1e574efb4140c", size = 215940, upload-time = "2025-09-16T00:16:21.63Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3a/0c/3662f4a66880196a590b202f0db82d919dd2f89e99a27fadef91c4a33d41/xlsxwriter-3.2.9-py3-none-any.whl", hash = "sha256:9a5db42bc5dff014806c58a20b9eae7322a134abb6fce3c92c181bfb275ec5b3", size = 175315, upload-time = "2025-09-16T00:16:20.108Z" },
+]