| import gradio as gr |
| import os, re, json, textwrap |
| from typing import Dict, Tuple |
|
|
| SKILLS_ROOT = os.path.join(os.path.dirname(__file__), "skills") |
|
|
| def parse_frontmatter(md_text: str) -> Tuple[dict, str]: |
| if not md_text.startswith("---"): |
| return {}, md_text |
| parts = md_text.split("\n") |
| if parts[0].strip() != "---": |
| return {}, md_text |
| try: |
| end_idx = parts[1:].index("---") + 1 |
| except ValueError: |
| return {}, md_text |
| fm_lines = parts[1:end_idx] |
| body = "\n".join(parts[end_idx+1:]) |
| meta = {} |
| for line in fm_lines: |
| if ":" in line: |
| k, v = line.split(":", 1) |
| meta[k.strip()] = v.strip().strip('"').strip("'") |
| return meta, body |
|
|
| def load_skill(skill_slug: str): |
| path = os.path.join(SKILLS_ROOT, skill_slug, "SKILL.md") |
| if not os.path.exists(path): |
| return {}, f"**SKILL.md not found for skill `{skill_slug}`.**" |
| with open(path, "r", encoding="utf-8") as f: |
| text = f.read() |
| meta, body = parse_frontmatter(text) |
| return meta, body |
|
|
| def list_skills(): |
| out = [] |
| if not os.path.isdir(SKILLS_ROOT): |
| return out |
| for name in sorted(os.listdir(SKILLS_ROOT)): |
| if os.path.isdir(os.path.join(SKILLS_ROOT, name)) and os.path.exists(os.path.join(SKILLS_ROOT, name, "SKILL.md")): |
| meta, _ = load_skill(name) |
| out.append((name, meta.get("name", name), meta.get("description", ""))) |
| return out |
|
|
| def list_linked_files(skill_slug: str): |
| root = os.path.join(SKILLS_ROOT, skill_slug) |
| if not os.path.isdir(root): |
| return [] |
| return [fn for fn in sorted(os.listdir(root)) if fn.lower().endswith(".md") and fn != "SKILL.md"] |
|
|
| def read_linked_file(skill_slug: str, filename: str) -> str: |
| path = os.path.join(SKILLS_ROOT, skill_slug, filename) |
| if not os.path.exists(path): |
| return f"**{filename} not found.**" |
| with open(path, "r", encoding="utf-8") as f: |
| return f.read() |
|
|
| def run_pdf_tool(skill_slug: str, uploaded_pdf) -> str: |
| try: |
| if uploaded_pdf is None: |
| return "Please upload a PDF." |
| import runpy, json as _json, os as _os |
| tool_path = os.path.join(SKILLS_ROOT, skill_slug, "tools", "extract_form_fields.py") |
| if not os.path.exists(tool_path): |
| return "Tool script not found. Expected tools/extract_form_fields.py" |
| ns = runpy.run_path(tool_path) |
| if "extract_fields" not in ns: |
| return "extract_form_fields.py does not define extract_fields(pdf_path)." |
| fn = ns["extract_fields"] |
| result = fn(uploaded_pdf.name if hasattr(uploaded_pdf, "name") else uploaded_pdf) |
| try: |
| return "```json\n" + _json.dumps(result, indent=2) + "\n```" |
| except Exception: |
| return str(result) |
| except Exception as e: |
| return f"Error running tool: {e}" |
|
|
| def explain_progressive_disclosure() -> str: |
| return ( |
| "### Progressive Disclosure\\n\\n" |
| "1. **Startup**: Only skill *metadata* (name, description) is shown.\\n" |
| "2. **Trigger**: Loading a skill reads **SKILL.md** into context.\\n" |
| "3. **Deep Dive**: Linked files (e.g., `reference.md`, `forms.md`) are opened only when needed.\\n" |
| "4. **Tools**: For the PDF skill, run the Python tool to extract form fields without adding the PDF to context." |
| ) |
|
|
| with gr.Blocks(title="Agent Skills — Progressive Disclosure Demo") as demo: |
| gr.Markdown("# Equipping agents for the real world with Agent Skills\\nPublished Oct 16, 2025") |
| gr.Markdown("This Space demonstrates **Agent Skills** as folders containing a `SKILL.md`, optional linked files, and tools.") |
|
|
| with gr.Row(): |
| with gr.Column(scale=1): |
| gr.Markdown("### Installed Skills") |
| skills = list_skills() |
| skill_map = {f"{title} — {desc}": slug for (slug, title, desc) in skills} if skills else {} |
| labels = list(skill_map.keys()) or ["(No skills found)"] |
| skill_dd = gr.Dropdown(choices=labels, value=labels[0], label="Pick a skill") |
| meta_out = gr.JSON(label="Skill metadata") |
|
|
| def on_pick(label): |
| if not skill_map: |
| return {}, "", [], None, None |
| slug = skill_map.get(label, None) |
| if not slug: |
| return {}, "", [], None, None |
| meta, body = load_skill(slug) |
| return meta, body, list_linked_files(slug), slug, None |
|
|
| body_out = gr.Markdown(label="SKILL.md body") |
| linked_files = gr.Dropdown(choices=[], label="Linked files") |
| selected_slug_state = gr.State(value=None) |
| _reset = gr.State(value=None) |
|
|
| skill_dd.change(fn=on_pick, inputs=[skill_dd], outputs=[meta_out, body_out, linked_files, selected_slug_state, _reset]) |
|
|
| with gr.Column(scale=2): |
| gr.Markdown("### Progressive Disclosure") |
| gr.Markdown(explain_progressive_disclosure()) |
|
|
| gr.Markdown("---") |
| gr.Markdown("### Linked File Viewer") |
| linked_view = gr.Markdown() |
|
|
| def on_view_linked(filename, slug): |
| if not slug or not filename: |
| return "Pick a skill and a linked file." |
| return read_linked_file(slug, filename) |
|
|
| view_btn = gr.Button("Open linked file") |
| view_btn.click(fn=on_view_linked, inputs=[linked_files, selected_slug_state], outputs=[linked_view]) |
|
|
| gr.Markdown("---") |
| gr.Markdown("### Run Skill Tool (PDF form field extractor)") |
| pdf_in = gr.File(label="Upload a PDF", file_count="single", type="filepath") |
| tool_out = gr.Markdown() |
|
|
| def run_tool_clicked(slug, pdf): |
| if not slug: |
| return "Pick a skill first." |
| return run_pdf_tool(slug, pdf) |
|
|
| run_tool_btn = gr.Button("Extract form fields") |
| run_tool_btn.click(fn=run_tool_clicked, inputs=[selected_slug_state, pdf_in], outputs=[tool_out]) |
|
|
| if __name__ == "__main__": |
| demo.launch() |
|
|
