Create app.py

app.py

@@ -0,0 +1,813 @@
+# app.py — Structured Output Extractor | Function Calling + Pydantic
+import streamlit as st
+import json
+import os
+
+st.set_page_config(
+    page_title="Structured Extractor · Daniel Fonseca",
+    page_icon="⬡",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+# ── CSS: TERMINAL HACKER ──────────────────────────────────────
+st.markdown("""
+<style>
+@import url('https://fonts.googleapis.com/css2?family=Share+Tech+Mono&family=Orbitron:wght@400;700;900&family=VT323&display=swap');
+
+:root {
+    --bg:       #060810;
+    --bg2:      #0a0d18;
+    --bg3:      #0e1220;
+    --green:    #00ff88;
+    --green2:   #00cc66;
+    --green3:   #009944;
+    --amber:    #ffb700;
+    --cyan:     #00d4ff;
+    --red:      #ff3355;
+    --dim:      #1a2a1a;
+    --grid:     #0d1a0d;
+    --border:   #0a3a0a;
+    --border2:  #1a4a1a;
+    --text:     #c8ffc8;
+    --text2:    #88cc88;
+    --text3:    #446644;
+}
+
+html, body, [class*="css"] {
+    background: var(--bg) !important;
+    color: var(--text) !important;
+    font-family: 'Share Tech Mono', monospace !important;
+}
+
+/* CRT scanlines overlay */
+body::before {
+    content: '';
+    position: fixed;
+    top: 0; left: 0; right: 0; bottom: 0;
+    background: repeating-linear-gradient(
+        0deg,
+        transparent,
+        transparent 2px,
+        rgba(0,255,136,0.015) 2px,
+        rgba(0,255,136,0.015) 4px
+    );
+    pointer-events: none;
+    z-index: 9999;
+}
+
+#MainMenu, footer, header { visibility: hidden; }
+.block-container { padding-top: 1rem; max-width: 1300px; }
+
+/* ── HEADER ── */
+.term-header {
+    border-bottom: 1px solid var(--green3);
+    padding-bottom: 0.8rem;
+    margin-bottom: 1.2rem;
+}
+.term-title {
+    font-family: 'Orbitron', monospace;
+    font-weight: 900;
+    font-size: 1.8rem;
+    color: var(--green);
+    letter-spacing: 0.08em;
+    text-shadow: 0 0 20px rgba(0,255,136,0.5);
+    line-height: 1;
+}
+.term-sub {
+    font-family: 'Share Tech Mono', monospace;
+    font-size: 0.7rem;
+    color: var(--green3);
+    letter-spacing: 0.2em;
+    margin-top: 0.3rem;
+}
+.blink {
+    animation: blink 1s step-end infinite;
+    color: var(--green);
+}
+@keyframes blink { 50% { opacity: 0; } }
+
+/* ── TERMINAL WINDOW ── */
+.term-window {
+    background: var(--bg2);
+    border: 1px solid var(--border2);
+    border-radius: 4px;
+    overflow: hidden;
+    margin-bottom: 1rem;
+}
+.term-titlebar {
+    background: var(--bg3);
+    border-bottom: 1px solid var(--border);
+    padding: 0.4rem 0.8rem;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+.term-dot {
+    width: 8px; height: 8px;
+    border-radius: 50%;
+    display: inline-block;
+}
+.dot-r { background: #ff3355; }
+.dot-y { background: #ffb700; }
+.dot-g { background: #00ff88; }
+.term-wintitle {
+    font-size: 0.65rem;
+    color: var(--text3);
+    letter-spacing: 0.15em;
+    text-transform: uppercase;
+    margin-left: 0.5rem;
+}
+.term-body { padding: 1rem 1.2rem; }
+
+/* ── PROMPT LINE ── */
+.prompt-line {
+    font-size: 0.8rem;
+    color: var(--green3);
+    margin-bottom: 0.4rem;
+}
+.prompt-line span { color: var(--green); }
+
+/* ── JSON RENDERER ── */
+.json-output {
+    background: #040608;
+    border: 1px solid var(--border);
+    border-radius: 3px;
+    padding: 1.2rem;
+    font-family: 'Share Tech Mono', monospace;
+    font-size: 0.8rem;
+    line-height: 1.7;
+    overflow-x: auto;
+    position: relative;
+}
+.json-key     { color: var(--cyan); }
+.json-str     { color: var(--amber); }
+.json-num     { color: #ff88aa; }
+.json-bool    { color: var(--green); font-weight: bold; }
+.json-null    { color: var(--text3); font-style: italic; }
+.json-bracket { color: var(--text2); }
+
+/* ── FIELD CARDS ── */
+.field-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(220px, 1fr));
+    gap: 0.6rem;
+    margin-top: 0.8rem;
+}
+.field-card {
+    background: #040a08;
+    border: 1px solid var(--border);
+    border-left: 2px solid var(--green3);
+    border-radius: 3px;
+    padding: 0.6rem 0.8rem;
+    transition: border-color 0.2s;
+}
+.field-card:hover { border-left-color: var(--green); }
+.field-key {
+    font-size: 0.65rem;
+    color: var(--cyan);
+    text-transform: uppercase;
+    letter-spacing: 0.12em;
+    margin-bottom: 0.2rem;
+}
+.field-val {
+    font-size: 0.82rem;
+    color: var(--amber);
+    word-break: break-word;
+}
+.field-val-null { color: var(--text3); font-style: italic; }
+.field-val-bool-true  { color: var(--green); }
+.field-val-bool-false { color: var(--red); }
+
+/* ── STATS BAR ── */
+.stats-bar {
+    display: flex;
+    gap: 1.5rem;
+    padding: 0.5rem 0;
+    border-top: 1px solid var(--border);
+    margin-top: 0.8rem;
+    flex-wrap: wrap;
+}
+.stat-item {
+    font-size: 0.68rem;
+    color: var(--text3);
+}
+.stat-item span { color: var(--green2); }
+
+/* ── SCHEMA SELECTOR ── */
+.schema-btn-active {
+    background: var(--dim) !important;
+    border: 1px solid var(--green) !important;
+    color: var(--green) !important;
+}
+
+/* ── SIDEBAR ── */
+section[data-testid="stSidebar"] {
+    background: var(--bg2) !important;
+    border-right: 1px solid var(--border) !important;
+}
+section[data-testid="stSidebar"] * { color: var(--text2) !important; }
+
+/* ── STREAMLIT OVERRIDES ── */
+.stTextArea textarea {
+    background: #040608 !important;
+    border: 1px solid var(--border2) !important;
+    border-radius: 3px !important;
+    color: var(--text) !important;
+    font-family: 'Share Tech Mono', monospace !important;
+    font-size: 0.8rem !important;
+    line-height: 1.6 !important;
+}
+.stTextArea textarea:focus {
+    border-color: var(--green) !important;
+    box-shadow: 0 0 8px rgba(0,255,136,0.2) !important;
+}
+.stSelectbox select, .stSelectbox > div {
+    background: var(--bg2) !important;
+    border-color: var(--border2) !important;
+    color: var(--text) !important;
+    font-family: 'Share Tech Mono', monospace !important;
+}
+.stButton button {
+    background: transparent !important;
+    border: 1px solid var(--green3) !important;
+    color: var(--green) !important;
+    border-radius: 3px !important;
+    font-family: 'Orbitron', monospace !important;
+    font-size: 0.68rem !important;
+    letter-spacing: 0.1em !important;
+    text-transform: uppercase !important;
+    transition: all 0.2s !important;
+}
+.stButton button:hover {
+    background: var(--dim) !important;
+    border-color: var(--green) !important;
+    box-shadow: 0 0 12px rgba(0,255,136,0.3) !important;
+}
+.stTextInput input {
+    background: #040608 !important;
+    border: 1px solid var(--border2) !important;
+    color: var(--text) !important;
+    font-family: 'Share Tech Mono', monospace !important;
+    font-size: 0.8rem !important;
+}
+div[data-testid="stTabs"] button {
+    font-family: 'Orbitron', monospace !important;
+    font-size: 0.62rem !important;
+    letter-spacing: 0.08em !important;
+    color: var(--text3) !important;
+}
+div[data-testid="stTabs"] button[aria-selected="true"] {
+    color: var(--green) !important;
+    border-bottom-color: var(--green) !important;
+}
+hr { border-color: var(--border) !important; }
+</style>
+""", unsafe_allow_html=True)
+
+# ── SESSION STATE ──────────────────────────────────────────────
+for k, v in {
+    'openai_key':   '',
+    'history':      [],
+    'active_schema': 'Contrato Legal',
+    'custom_schema': '',
+}.items():
+    if k not in st.session_state:
+        st.session_state[k] = v
+
+# ── HELPERS ───────────────────────────────────────────────────
+def get_key():
+    try:
+        if 'OPENAI_API_KEY' in st.secrets:
+            return st.secrets['OPENAI_API_KEY']
+    except Exception:
+        pass
+    return os.getenv('OPENAI_API_KEY', st.session_state.openai_key)
+
+
+def syntax_highlight_json(obj, indent=0) -> str:
+    """Renderiza JSON com syntax highlighting HTML."""
+    pad = "&nbsp;" * (indent * 3)
+    pad2 = "&nbsp;" * ((indent + 1) * 3)
+
+    if isinstance(obj, dict):
+        if not obj:
+            return '<span class="json-bracket">{}</span>'
+        lines = ['<span class="json-bracket">{</span>']
+        items = list(obj.items())
+        for i, (k, v) in enumerate(items):
+            comma = "," if i < len(items) - 1 else ""
+            val_html = syntax_highlight_json(v, indent + 1)
+            lines.append(f'{pad2}<span class="json-key">"{k}"</span>: {val_html}{comma}')
+        lines.append(f'{pad}<span class="json-bracket">}}</span>')
+        return "\n".join(lines)
+
+    elif isinstance(obj, list):
+        if not obj:
+            return '<span class="json-bracket">[]</span>'
+        lines = ['<span class="json-bracket">[</span>']
+        for i, item in enumerate(obj):
+            comma = "," if i < len(obj) - 1 else ""
+            val_html = syntax_highlight_json(item, indent + 1)
+            lines.append(f'{pad2}{val_html}{comma}')
+        lines.append(f'{pad}<span class="json-bracket">]</span>')
+        return "\n".join(lines)
+
+    elif isinstance(obj, str):
+        escaped = obj.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+        return f'<span class="json-str">"{escaped}"</span>'
+
+    elif isinstance(obj, bool):
+        cls = "json-bool"
+        return f'<span class="{cls}">{"true" if obj else "false"}</span>'
+
+    elif obj is None:
+        return '<span class="json-null">null</span>'
+
+    elif isinstance(obj, (int, float)):
+        return f'<span class="json-num">{obj}</span>'
+
+    else:
+        return f'<span class="json-str">"{obj}"</span>'
+
+
+def render_flat_fields(data: dict) -> str:
+    """Renderiza campos flat (não-aninhados) como cards."""
+    cards = []
+    for k, v in data.items():
+        if isinstance(v, (dict, list)):
+            continue
+        key_html = f'<div class="field-key">{k}</div>'
+        if v is None:
+            val_html = '<div class="field-val field-val-null">null</div>'
+        elif isinstance(v, bool):
+            cls = "field-val-bool-true" if v else "field-val-bool-false"
+            val_html = f'<div class="field-val {cls}">{"true" if v else "false"}</div>'
+        else:
+            escaped = str(v).replace("<", "&lt;").replace(">", "&gt;")
+            val_html = f'<div class="field-val">{escaped}</div>'
+        cards.append(f'<div class="field-card">{key_html}{val_html}</div>')
+    if not cards:
+        return ""
+    return f'<div class="field-grid">{"".join(cards)}</div>'
+
+
+# ── SIDEBAR ───────────────────────────────────────────────────
+with st.sidebar:
+    st.markdown("""
+    <div style='font-family:Orbitron,monospace;font-weight:900;
+    font-size:1rem;color:#00ff88;text-shadow:0 0 10px rgba(0,255,136,0.4);
+    letter-spacing:0.1em'>STRUCT//EXTRACT</div>
+    <div style='font-family:Share Tech Mono,monospace;font-size:0.6rem;
+    color:#446644;letter-spacing:0.2em;text-transform:uppercase;margin-top:0.2rem'>
+    v1.0 · Function Calling Engine
+    </div>
+    """, unsafe_allow_html=True)
+    st.divider()
+
+    st.markdown("**🔑 OpenAI API Key**")
+    k_in = st.text_input("", type="password", value=st.session_state.openai_key,
+                          placeholder="sk-...", label_visibility="collapsed")
+    if k_in:
+        st.session_state.openai_key = k_in
+    if get_key():
+        st.markdown('<div style="color:#00ff88;font-size:0.75rem">✓ KEY LOADED</div>',
+                    unsafe_allow_html=True)
+    else:
+        st.markdown('<div style="color:#ff3355;font-size:0.75rem">✗ KEY MISSING</div>',
+                    unsafe_allow_html=True)
+
+    st.divider()
+    st.markdown("""
+    <div style='font-family:Share Tech Mono,monospace;font-size:0.72rem;
+    color:#446644;line-height:1.8'>
+    <div style='color:#00cc66;margin-bottom:0.4rem'>// PIPELINE</div>
+    01. Text input<br>
+    02. Schema selection<br>
+    03. Tool definition (OpenAI)<br>
+    04. Function calling<br>
+    05. JSON parse + validate<br>
+    06. Retry on error<br>
+    07. Render + export
+    </div>
+    """, unsafe_allow_html=True)
+    st.divider()
+    st.markdown("""
+    <div style='font-family:Share Tech Mono,monospace;font-size:0.65rem;color:#2a4a2a'>
+    model: gpt-4o-mini<br>
+    tool_choice: required<br>
+    temperature: 0.0<br>
+    max_retries: 2<br>
+    validation: pydantic v2
+    </div>
+    """, unsafe_allow_html=True)
+    st.divider()
+    if st.button("⬡ Limpar histórico", use_container_width=True):
+        st.session_state.history = []
+        st.rerun()
+
+# ── HEADER ────────────────────────────────────────────────────
+st.markdown("""
+<div class="term-header">
+  <div class="term-title">⬡ STRUCTURED OUTPUT EXTRACTOR <span class="blink">_</span></div>
+  <div class="term-sub">OpenAI Function Calling · Pydantic v2 · Dynamic JSON Schema · Auto-Retry</div>
+</div>
+""", unsafe_allow_html=True)
+
+# ── TABS ──────────────────────────────────────────────────────
+tab_extract, tab_custom, tab_history = st.tabs([
+    "⬡ Extrair",
+    "⬢ Schema Customizado",
+    "⬣ Histórico",
+])
+
+# ════════════════════════════════════════════════════════════════
+# EXEMPLOS
+# ════════════════════════════════════════════════════════════════
+EXAMPLES = {
+    "Contrato Legal": """CONTRATO DE PRESTAÇÃO DE SERVIÇOS DE CONSULTORIA EM INTELIGÊNCIA ARTIFICIAL
+
+Entre as partes:
+CONTRATANTE: TechCorp Brasil Ltda., CNPJ 12.345.678/0001-99, com sede em São Paulo/SP.
+CONTRATADO: Daniel Fonseca - ML Engineer, CPF 123.456.789-00, residente no Rio de Janeiro/RJ.
+
+CLÁUSULA 1 - OBJETO
+O CONTRATADO prestará serviços de consultoria em Graph Neural Networks e sistemas de detecção de fraude com IA Generativa, incluindo desenvolvimento de modelos, treinamento de equipes e documentação técnica.
+
+CLÁUSULA 2 - VALOR
+O valor total dos serviços é de R$ 48.000,00 (quarenta e oito mil reais), pagos em 4 parcelas mensais de R$ 12.000,00.
+
+CLÁUSULA 3 - PRAZO
+Vigência de 4 (quatro) meses, iniciando em 01/04/2025 e encerrando em 31/07/2025.
+
+CLÁUSULA 4 - OBRIGAÇÕES DO CONTRATADO
+- Entregar relatórios mensais de progresso
+- Participar de reuniões semanais remotas
+- Manter confidencialidade sobre os dados da empresa
+
+CLÁUSULA 5 - FORO
+Fica eleito o foro da Comarca de São Paulo/SP para dirimir quaisquer controvérsias.
+
+Assinado digitalmente em 28/03/2025.""",
+
+    "Notícia / Artigo": """Meta anuncia novo modelo de linguagem open-source com 405 bilhões de parâmetros
+
+SAN FRANCISCO, 15 de março de 2025 — A Meta Platforms anunciou nesta quinta-feira o lançamento do Llama 4, seu mais novo modelo de linguagem de grande escala com 405 bilhões de parâmetros, disponível gratuitamente para pesquisadores e empresas sob licença open-source.
+
+O CEO Mark Zuckerberg afirmou que o modelo supera o GPT-4o em 73% dos benchmarks testados internamente, incluindo MMLU, HumanEval e MT-Bench. A vice-presidente de IA da empresa, Yann LeCun, destacou que o modelo foi treinado em 30 trilhões de tokens de dados multimodais.
+
+O lançamento acontece em meio à crescente disputa entre Meta, OpenAI, Google e Anthropic pelo mercado de IA generativa, avaliado em US$ 2,4 trilhões até 2030 segundo a consultoria Goldman Sachs.
+
+Especialistas do MIT e Stanford avaliam que a decisão de tornar o modelo open-source pode democratizar o acesso à IA avançada, embora levante preocupações sobre uso malicioso. O governo americano já sinalizou que pode regulamentar o setor ainda em 2025.""",
+
+    "Artigo Científico": """GraphSAGE: Inductive Representation Learning on Large Graphs
+
+Autores: William L. Hamilton, Rex Ying, Jure Leskovec
+Venue: NeurIPS 2017, Long Beach, CA
+
+Abstract:
+Low-dimensional embeddings of nodes in large graphs have proved extremely useful in a variety of prediction tasks. However, most existing approaches require that all nodes in the graph are present during training of the embeddings; these previous approaches are inherently transductive and do not naturally generalize to unseen nodes.
+
+Problema resolvido:
+A maioria dos métodos de embedding para grafos é transductive — só funciona para nós vistos durante o treino. Em aplicações reais como redes sociais e sistemas de recomendação, novos nós aparecem constantemente.
+
+Metodologia:
+O GraphSAGE aprende funções de agregação (mean, LSTM, pooling) que generalizam para nós não vistos, combinando features do nó com as de sua vizinhança amostrada.
+
+Resultados:
+- Dataset Citation (Cora): F1 = 0.935
+- Dataset Reddit: F1 = 0.950  
+- Dataset PPI (Protein-Protein Interaction): F1 = 0.612 (vs 0.421 baseline)
+
+Contribuições principais:
+1. Framework inductive para grafos de larga escala
+2. Três agregadores comparados: mean, LSTM, max-pooling
+3. Mini-batch training para escalabilidade
+4. Open-source no repositório snap-stanford/GraphSAGE""",
+}
+
+# ════════════════════════════════════════════════════════════════
+# TAB 1 — EXTRAIR
+# ════════════════════════════════════════════════════════════════
+with tab_extract:
+    from extractor import PRESET_SCHEMAS
+
+    # Schema selector
+    st.markdown("""
+    <div class="prompt-line">user@extractor:~$ <span>select --schema</span></div>
+    """, unsafe_allow_html=True)
+
+    schema_cols = st.columns(len(PRESET_SCHEMAS))
+    for i, (name, _) in enumerate(PRESET_SCHEMAS.items()):
+        with schema_cols[i]:
+            active = st.session_state.active_schema == name
+            if st.button(name, key=f"sc_{i}", use_container_width=True):
+                st.session_state.active_schema = name
+                st.rerun()
+
+    active_schema = PRESET_SCHEMAS[st.session_state.active_schema]
+    st.markdown(f"""
+    <div style='font-family:Share Tech Mono,monospace;font-size:0.68rem;
+    color:#446644;margin:0.4rem 0 0.8rem;padding:0.4rem 0.8rem;
+    border-left:2px solid #0a3a0a;background:#040a04'>
+    // {st.session_state.active_schema} — {active_schema['description']}
+    </div>
+    """, unsafe_allow_html=True)
+
+    # Exemplo rápido
+    col_ex, _ = st.columns([2, 3])
+    with col_ex:
+        if st.button(f"⬡ Carregar exemplo: {st.session_state.active_schema}",
+                     use_container_width=True):
+            ex_text = EXAMPLES.get(st.session_state.active_schema, "")
+            if ex_text:
+                st.session_state["load_example"] = ex_text
+
+    default_text = st.session_state.pop("load_example", "")
+
+    st.markdown("""
+    <div class="prompt-line" style="margin-top:0.8rem">
+    user@extractor:~$ <span>paste --input</span></div>
+    """, unsafe_allow_html=True)
+
+    text_input = st.text_area(
+        "", value=default_text, height=220,
+        placeholder="Cole qualquer texto aqui: contrato, notícia, currículo, invoice, artigo...",
+        label_visibility="collapsed", key="main_text"
+    )
+
+    run_col, _ = st.columns([1, 3])
+    with run_col:
+        run_btn = st.button("⬡ EXTRAIR DADOS", use_container_width=True, type="primary")
+
+    if run_btn:
+        if not get_key():
+            st.markdown('<div style="color:#ff3355;font-size:0.8rem">✗ API Key não configurada</div>',
+                        unsafe_allow_html=True)
+            st.stop()
+        if not text_input.strip():
+            st.markdown('<div style="color:#ffb700;font-size:0.8rem">⚠ Cole um texto para extrair</div>',
+                        unsafe_allow_html=True)
+            st.stop()
+
+        from extractor import StructuredExtractor
+
+        # Terminal de progresso
+        prog_ph = st.empty()
+        prog_ph.markdown("""
+        <div class="term-window">
+          <div class="term-titlebar">
+            <span class="term-dot dot-r"></span>
+            <span class="term-dot dot-y"></span>
+            <span class="term-dot dot-g"></span>
+            <span class="term-wintitle">extraction.log</span>
+          </div>
+          <div class="term-body" style="font-size:0.75rem;color:#446644;line-height:2">
+            <div>→ Inicializando engine...</div>
+            <div>→ Tool definition criada</div>
+            <div>→ Chamando gpt-4o-mini com tool_choice=required...</div>
+            <div style="color:#ffb700">⟳ Aguardando resposta<span class="blink">_</span></div>
+          </div>
+        </div>
+        """, unsafe_allow_html=True)
+
+        try:
+            engine = StructuredExtractor(get_key())
+            result = engine.extract(
+                text=text_input,
+                schema=active_schema["schema"],
+                schema_name=st.session_state.active_schema,
+            )
+
+            prog_ph.markdown(f"""
+            <div class="term-window">
+              <div class="term-titlebar">
+                <span class="term-dot dot-r"></span>
+                <span class="term-dot dot-y"></span>
+                <span class="term-dot dot-g"></span>
+                <span class="term-wintitle">extraction.log</span>
+              </div>
+              <div class="term-body" style="font-size:0.75rem;color:#446644;line-height:2">
+                <div>✓ Engine inicializado</div>
+                <div>✓ Tool definition: <span style="color:#00d4ff">{st.session_state.active_schema}</span></div>
+                <div>✓ Function call executado com sucesso</div>
+                <div>✓ JSON parseado e validado</div>
+                <div style="color:#00ff88">✓ EXTRAÇÃO COMPLETA em {result['attempts']} tentativa(s) · {result['tokens']} tokens</div>
+              </div>
+            </div>
+            """, unsafe_allow_html=True)
+
+            # Salva no histórico
+            st.session_state.history.append({
+                "schema": st.session_state.active_schema,
+                "text_preview": text_input[:120] + "...",
+                "result": result,
+            })
+
+            # ── OUTPUT ──────────────────────────────────────────
+            out_col, raw_col = st.columns([3, 2], gap="large")
+
+            with out_col:
+                st.markdown("""
+                <div class="prompt-line">user@extractor:~$ <span>render --view=structured</span></div>
+                """, unsafe_allow_html=True)
+
+                # Cards de campos flat
+                flat_html = render_flat_fields(result["data"])
+                if flat_html:
+                    st.markdown(flat_html, unsafe_allow_html=True)
+
+                # Campos complexos (listas/objetos)
+                for k, v in result["data"].items():
+                    if not isinstance(v, (dict, list)):
+                        continue
+                    st.markdown(f"""
+                    <div style='font-family:Share Tech Mono,monospace;font-size:0.65rem;
+                    color:#00d4ff;text-transform:uppercase;letter-spacing:0.1em;
+                    margin:0.8rem 0 0.3rem'>// {k}</div>
+                    """, unsafe_allow_html=True)
+
+                    if isinstance(v, list):
+                        for item in v:
+                            if isinstance(item, dict):
+                                st.markdown(f"""
+                                <div class="json-output" style="font-size:0.75rem;margin-bottom:0.4rem">
+                                {syntax_highlight_json(item, 0)}
+                                </div>
+                                """, unsafe_allow_html=True)
+                            else:
+                                esc = str(item).replace("<","&lt;")
+                                st.markdown(f'<div class="field-card"><div class="field-val">{esc}</div></div>',
+                                            unsafe_allow_html=True)
+                    elif isinstance(v, dict):
+                        st.markdown(f"""
+                        <div class="json-output" style="font-size:0.75rem">
+                        {syntax_highlight_json(v, 0)}
+                        </div>
+                        """, unsafe_allow_html=True)
+
+                # Stats
+                st.markdown(f"""
+                <div class="stats-bar">
+                  <div class="stat-item">schema: <span>{st.session_state.active_schema}</span></div>
+                  <div class="stat-item">fields: <span>{len(result['data'])}</span></div>
+                  <div class="stat-item">tokens: <span>{result['tokens']}</span></div>
+                  <div class="stat-item">attempts: <span>{result['attempts']}</span></div>
+                  <div class="stat-item">method: <span>{result['method']}</span></div>
+                </div>
+                """, unsafe_allow_html=True)
+
+            with raw_col:
+                st.markdown("""
+                <div class="prompt-line">user@extractor:~$ <span>cat output.json</span></div>
+                """, unsafe_allow_html=True)
+                json_html = syntax_highlight_json(result["data"])
+                st.markdown(f'<div class="json-output">{json_html}</div>',
+                             unsafe_allow_html=True)
+
+                # Download
+                st.download_button(
+                    "⬡ Download JSON",
+                    data=json.dumps(result["data"], ensure_ascii=False, indent=2),
+                    file_name=f"extracted_{st.session_state.active_schema.lower().replace(' ','_')}.json",
+                    mime="application/json",
+                    use_container_width=True,
+                )
+
+        except Exception as e:
+            prog_ph.markdown(f"""
+            <div class="term-window">
+              <div class="term-titlebar">
+                <span class="term-dot dot-r"></span><span class="term-wintitle">error.log</span>
+              </div>
+              <div class="term-body" style="color:#ff3355;font-size:0.8rem">
+                ✗ ERRO: {e}
+              </div>
+            </div>
+            """, unsafe_allow_html=True)
+
+# ════════════════════════════════════════════════════════════════
+# TAB 2 — SCHEMA CUSTOMIZADO
+# ════════════════════════════════════════════════════════════════
+with tab_custom:
+    st.markdown("""
+    <div class="prompt-line">user@extractor:~$ <span>define --schema=custom</span></div>
+    <div style='font-family:Share Tech Mono,monospace;font-size:0.7rem;
+    color:#446644;margin:0.3rem 0 0.8rem'>
+    // Defina seu próprio JSON Schema e extraia qualquer estrutura de qualquer texto
+    </div>
+    """, unsafe_allow_html=True)
+
+    DEFAULT_CUSTOM = '''{
+  "type": "object",
+  "properties": {
+    "nome_produto":   {"type": "string"},
+    "preco":          {"type": "number"},
+    "categorias":     {"type": "array", "items": {"type": "string"}},
+    "disponivel":     {"type": "boolean"},
+    "especificacoes": {
+      "type": "object",
+      "properties": {
+        "peso":  {"type": "string"},
+        "cor":   {"type": "string"}
+      }
+    }
+  },
+  "required": ["nome_produto"]
+}'''
+
+    c_left, c_right = st.columns(2, gap="large")
+
+    with c_left:
+        st.markdown('<div class="prompt-line">$ <span>vim schema.json</span></div>',
+                    unsafe_allow_html=True)
+        custom_schema = st.text_area(
+            "", value=st.session_state.custom_schema or DEFAULT_CUSTOM,
+            height=280, label_visibility="collapsed", key="custom_schema_input"
+        )
+
+    with c_right:
+        st.markdown('<div class="prompt-line">$ <span>cat input.txt</span></div>',
+                    unsafe_allow_html=True)
+        custom_text = st.text_area(
+            "", height=280, label_visibility="collapsed", key="custom_text",
+            placeholder="Cole o texto para extrair..."
+        )
+
+    run_custom = st.button("⬡ EXTRAIR COM SCHEMA CUSTOMIZADO", use_container_width=True)
+
+    if run_custom:
+        if not get_key():
+            st.error("Configure a API Key na sidebar.")
+            st.stop()
+        if not custom_text.strip() or not custom_schema.strip():
+            st.warning("Preencha o schema e o texto.")
+            st.stop()
+
+        from extractor import StructuredExtractor
+        with st.spinner("Extraindo..."):
+            try:
+                engine = StructuredExtractor(get_key())
+                result = engine.extract_with_custom_schema(custom_text, custom_schema)
+
+                st.markdown('<div class="prompt-line">$ <span>cat output.json</span></div>',
+                            unsafe_allow_html=True)
+                json_html = syntax_highlight_json(result["data"])
+                st.markdown(f'<div class="json-output">{json_html}</div>',
+                             unsafe_allow_html=True)
+
+                st.markdown(f"""
+                <div class="stats-bar">
+                  <div class="stat-item">tokens: <span>{result['tokens']}</span></div>
+                  <div class="stat-item">attempts: <span>{result['attempts']}</span></div>
+                </div>
+                """, unsafe_allow_html=True)
+
+                st.download_button(
+                    "⬡ Download JSON",
+                    data=json.dumps(result["data"], ensure_ascii=False, indent=2),
+                    file_name="custom_extraction.json",
+                    mime="application/json",
+                )
+                st.session_state.history.append({
+                    "schema": "Custom",
+                    "text_preview": custom_text[:120] + "...",
+                    "result": result,
+                })
+            except ValueError as e:
+                st.error(f"Schema inválido: {e}")
+            except Exception as e:
+                st.error(f"Erro: {e}")
+
+# ════════════════════════════════════════════════════════════════
+# TAB 3 — HISTÓRICO
+# ════════════════════════════════════════════════════════════════
+with tab_history:
+    if not st.session_state.history:
+        st.markdown("""
+        <div style='font-family:Share Tech Mono,monospace;font-size:0.8rem;
+        color:#2a4a2a;text-align:center;padding:3rem'>
+        // nenhuma extração executada ainda
+        </div>
+        """, unsafe_allow_html=True)
+    else:
+        for i, h in enumerate(reversed(st.session_state.history)):
+            r = h["result"]
+            with st.expander(
+                f"#{len(st.session_state.history)-i} · {h['schema']} · {r['tokens']} tokens",
+                expanded=(i == 0)
+            ):
+                st.markdown(f"""
+                <div style='font-family:Share Tech Mono,monospace;font-size:0.7rem;
+                color:#446644;margin-bottom:0.5rem'>// {h['text_preview']}</div>
+                """, unsafe_allow_html=True)
+                json_html = syntax_highlight_json(r["data"])
+                st.markdown(f'<div class="json-output" style="font-size:0.75rem">{json_html}</div>',
+                             unsafe_allow_html=True)
+                st.download_button(
+                    "⬡ Download",
+                    data=json.dumps(r["data"], ensure_ascii=False, indent=2),
+                    file_name=f"extract_{i}.json",
+                    mime="application/json",
+                    key=f"dl_{i}",
+                )