refactor: split chat flow from SQL routing

.gitignore

@@ -45,11 +45,10 @@ logs/
 *.ckpt
 *.gguf
 
-# AI-generated code artifacts
-*.gen.py
-.claude
-
 # Local agent/workspace notes
 /AGENTS.md
 /CLAUDE.md
 /PROGRESS.md
+.claude
+.gstack/
+docs

README.md

@@ -24,7 +24,7 @@ Transforms simple table descriptions and questions into SQL using the fine-tuned
 1. Click **Load fine-tuned model**.
    - Loading is lazy: the model is only downloaded and loaded when you request it.
    - On CPU, the first load can take a few minutes.
-2. Enter or edit the **SQL table schema**.
+2. Chat normally or enter/edit the **SQL table schema**.
    - You can use the presets: `employees`, `orders`, `students`, `products`, `sales`.
    - You can also write your own schema manually.
 3. Enter the question in the chat input.
@@ -38,6 +38,7 @@ Transforms simple table descriptions and questions into SQL using the fine-tuned
 - Fine-tuned merged model used in the app: [Shizu0n/phi3-mini-sql-generator-merged](https://huggingface.co/Shizu0n/phi3-mini-sql-generator-merged)
 - Offline baseline model used for evaluation: [microsoft/Phi-3-mini-4k-instruct](https://huggingface.co/microsoft/Phi-3-mini-4k-instruct)
 
+
 ## Metrics
 
 | Model | Exact match |
@@ -49,14 +50,24 @@ Reported gain: **+71.5 percentage points** over the base model.
 
 ## Current Features
 
-- Gradio UI with a step-by-step flow: load the fine-tuned model, enter schema/question, and generate SQL.
-- Offline baseline metrics shown in the UI without loading a second 3.8B model on the CPU Space.
+- Gradio UI with a step-by-step flow: load the fine-tuned model, chat, and inspect SQL artifacts.
+- Intent routing that keeps normal conversation separate from SQL generation.
 - Lazy loading to reduce startup cost.
 - Preserved Phi-3 patches for local/Spaces compatibility.
 - Schema presets without blocking manual input.
 - SQL output separated from errors/status so booleans, integers, and error messages do not appear inside the SQL block.
 - Centered loading overlay to make the loading state obvious.
 
+## Model Probe
+
+The normal pytest suite does not load the 3.8B model. To manually verify the real model behavior:
+
+```bash
+python scripts/model_probe.py
+```
+
+The probe prints JSON with pass/fail checks for greeting, schema proposal, CREATE TABLE confirmation, schema edit, SQL query, and smalltalk while a schema is active.
+
 ## Run Locally
 
 ```bash

app.py

@@ -12,6 +12,11 @@ import unicodedata
 import gradio as gr
 import sqlparse
 
+import chat_state as chat_core
+import intent as intent_core
+import model_io as model_core
+import sql_tools as sql_core
+
 
 BASE_MODEL_ID = "microsoft/Phi-3-mini-4k-instruct"
 FINE_TUNED_MODEL_ID = "Shizu0n/phi3-mini-sql-generator-merged"
@@ -447,166 +452,18 @@ def is_sql_like(text):
     }
 
 
-def is_sql_intent(message, schema):
-    message = normalize_text(message)
-    schema = (schema or "").strip()
-    if not message:
-        return False
-    # P1 fix: if schema exists and message has substance, treat as SQL intent
-    # (user is likely asking a question about the known schema)
-    # Exclude short greetings/acknowledgments that could accompany a schema setup
-    short_greetings = {
-        "oi", "olá", "ola", "hi", "hello", "hey", "bom", "boa",
-        "obrigado", "thanks", "ok", "sim", "claro", "de nada",
-    }
-    # Extended exclusions for FAQ/off-topic with schema active
-    off_topic_patterns = {
-        "obrigado", "thanks", "thank you", "muito obrigado", "obrigada",
-        "como você funciona", "como voce funciona", "como funciona",
-        "o que você faz", "o que voce faz", "o que faz",
-        "como foi treinado", "como voce foi treinado", "treinado",
-        "quais habilidades", "o que consegue", "o que pode fazer",
-        "me ajude", "help me", "ajuda", "help",
-        # Edit/table manipulation terms — prevent blanket-catch from routing to model
-        "troca", "trocar", "renomeia", "renomear", "renomeie",
-        "muda", "mudar", "altera", "alterar", "edita", "editar",
-        "adiciona", "adicionar", "adicione", "remove", "remover",
-        "apaga", "apagar", "delete column", "drop column",
-        "coluna nova", "nova coluna", "novo campo", "campo novo",
-        "trocando", "mudando", "alterando", "editando",
-    }
-    words = message.split()
-    # Check if message is off-topic even with 2+ words
-    if schema and len(words) >= 2:
-        # Check exact matches and patterns
-        if message in short_greetings or message in off_topic_patterns:
-            return False
-        # Check partial matches for common off-topic phrases
-        for pattern in off_topic_patterns:
-            if pattern in message:
-                return False
-    if schema and len(words) >= 2 and message not in short_greetings:
-        return True
-    sql_terms = {
-        "all",
-        "average",
-        "count",
-        "columns",
-        "database",
-        "find",
-        "get",
-        "group by",
-        "join",
-        "list",
-        "order by",
-        "query",
-        "rows",
-        "schema",
-        "select",
-        "show",
-        "sql",
-        "sum",
-        "table",
-        "where",
-        "consulta",
-        "consultar",
-        "contar",
-        "colunas",
-        "linhas",
-        "liste",
-        "listar",
-        "maior",
-        "mais caro",
-        "menor",
-        "media",
-        "média",
-        "mostre",
-        "mostrar",
-        "ordene",
-        "por departamento",
-        "selecione",
-        "sql",
-        "some",
-        "soma",
-        "tabela",
-    }
-    return any(
-        re.search(rf"(?<!\w){re.escape(normalize_text(term))}(?!\w)", message)
-        for term in sql_terms
-    )
-
-
-def build_generation_prompt(schema, message, chat_history=None):
-    schema = (schema or "").strip()
-    message = (message or "").strip()
-    if is_sql_intent(message, schema):
-        table_schema = schema or "CREATE TABLE unknown (id INTEGER)"
-        # Inject last 3 conversation exchanges for multi-turn context
-        history_context = ""
-        if chat_history:
-            trimmed = trim_chat_history(chat_history, max_exchanges=3)
-            if trimmed:
-                lines = []
-                for i in range(0, len(trimmed), 2):
-                    entry1 = trimmed[i]
-                    entry2 = trimmed[i + 1] if i + 1 < len(trimmed) else None
-                    user_msg = entry1.get("content", "") if isinstance(entry1, dict) else (entry1[1] if isinstance(entry1, tuple) else str(entry1))
-                    asst_msg = entry2.get("content", "") if isinstance(entry2, dict) else (entry2[1] if isinstance(entry2, tuple) else str(entry2)) if entry2 else ""
-                    lines.append(f"User: {user_msg}")
-                    if asst_msg:
-                        lines.append(f"Assistant: {asst_msg}")
-                if lines:
-                    history_context = "\n\nPrevious conversation:\n" + "\n".join(lines) + "\n"
-        return PROMPT_TEMPLATE.format(schema=table_schema, question=message) + history_context
-    return GENERAL_PROMPT_TEMPLATE.format(message=message)
-
-
-def format_generation_result(text):
-    cleaned = extract_sql_candidate(text)
-    if is_sql_like(cleaned):
-        return str(cleaned), EMPTY_CHAT_OUTPUT, validate_sql(cleaned)
-    return "", str(cleaned), CHAT_VALIDATOR
-
-
-def validate_sql(sql_text):
-    sql_text = (sql_text or "").strip()
-    if not sql_text:
-        return EMPTY_VALIDATOR
-    try:
-        statements = [stmt for stmt in sqlparse.parse(sql_text) if str(stmt).strip()]
-    except Exception as exc:
-        error_type = html.escape(type(exc).__name__)
-        return (
-            '<span class="validator-badge validator-warn">Check syntax</span>'
-            f'<span class="validator-detail">sqlparse error: {error_type}</span>'
-        )
-    if not statements:
-        return (
-            '<span class="validator-badge validator-warn">Check syntax</span>'
-            '<span class="validator-detail">No parsed SQL statement.</span>'
-        )
-    first_token = statements[0].token_first(skip_cm=True)
-    token_value = first_token.value.strip().upper() if first_token is not None else "UNKNOWN"
-    allowed_starters = {"SELECT", "WITH", "INSERT", "UPDATE", "DELETE", "CREATE", "ALTER", "DROP"}
-    if token_value not in allowed_starters:
-        escaped_token = html.escape(token_value)
-        return (
-            '<span class="validator-badge validator-warn">Check syntax</span>'
-            f'<span class="validator-detail">First token: {escaped_token}</span>'
-        )
-    return '<span class="validator-badge validator-ok">Valid SQL</span>'
 
 
 def render_header():
     return """
     <section class="top-panel">
       <div>
-        <h1>Phi-3 Mini SQL Generator</h1>
-        <p>QLoRA fine-tuned - b-mc2/sql-create-context</p>
+        <h1>Phi-3 Mini SQL Chatbot</h1>
+        <p>Conversational SQL assistant powered by a fine-tuned Phi-3 Mini model</p>
       </div>
       <div class="top-badges">
-        <span class="badge badge-green">73.5% exact match</span>
-        <span class="badge badge-cream">+71.5pp vs base</span>
+        <span class="badge badge-green">Natural chat + SQL</span>
+        <span class="badge badge-cream">Context-aware schema</span>
         <span class="badge badge-light">CPU lazy load</span>
       </div>
     </section>
@@ -677,10 +534,10 @@ def render_loading_overlay(model_key=None, visible=False):
 def model_metadata(model_key=None):
     return """
     <section class="stats-row">
-      <div class="stat-card"><strong>73.5%</strong><span>exact match</span></div>
-      <div class="stat-card"><strong>+71.5pp</strong><span>vs base</span></div>
-      <div class="stat-card"><strong>1,000</strong><span>examples</span></div>
-      <div class="stat-card"><strong>21 min</strong><span>T4 training</span></div>
+      <div class="stat-card"><strong>Chat</strong><span>normal conversation</span></div>
+      <div class="stat-card"><strong>Schema</strong><span>table proposals</span></div>
+      <div class="stat-card"><strong>SQL</strong><span>query generation</span></div>
+      <div class="stat-card"><strong>Probe</strong><span>manual model gate</span></div>
     </section>
     """
 
@@ -731,7 +588,7 @@ def is_create_table_intent(message):
 
 def is_table_edit_intent(message):
     message = (message or "").strip().lower()
-    edit_terms = r"\b(edit|update|modify|alter|add|include|remove|delete|drop|edita|editar|altera|altere|alterar|mude|mudar|adicione|adicionar|inclua|incluir|acrescente|remova|remover|delete|deletar|exclua|excluir|novo|nova)\b"
+    edit_terms = r"\b(edit|update|modify|alter|add|include|remove|delete|drop|edita|editar|altera|altere|alterar|mude|mudar|adicione|adicionar|inclua|incluir|acrescente|remova|remover|delete|deletar|exclua|excluir|novo|nova|troca|trocar|troquecoloque|colocar)\b"
     direct_add_terms = r"\b(add|include|adicione|adicionar|adicionando|inclua|incluir|acrescente)\b"
     direct_remove_terms = r"\b(remove|delete|drop|remova|remover|deletar|exclua|excluir)\b"
     target_terms = r"\b(column|field|element|coluna|campo|elemento|item)\b"
@@ -757,7 +614,7 @@ def is_table_edit_intent(message):
         or re.search(direct_remove_terms, message)
         or is_rename_intent(message)
         or re.search(r"\b(?:altere|alterar|mude|mudar)\b.*\bter\b", message)
-        or (re.search(edit_terms, message) and (re.search(target_terms, message) or ":" in message))
+        or (re.search(edit_terms, message) and (re.search(target_terms, message) or ":" in message or re.search(r"\bpor\b", message)))
     )
 
 
@@ -915,26 +772,6 @@ def format_create_table(table_name, columns):
     return f"CREATE TABLE {table_name} (\n" + ",\n".join(column_lines) + "\n);"
 
 
-def create_table_from_message(message):
-    message = (message or "").strip()
-    patterns = (
-        r"\b(?:table|tabela)\s+(?:called\s+|named\s+|chamada?\s+|nomeada?\s+)?([A-Za-z_][\w]*)\s+(?:with|containing|including|com)\s+(.+)$",
-        r"\b(?:create|make|build|generate|criar|crie|gerar|gere)\b.*?\b(?:table|tabela)\b\s+([A-Za-z_][\w]*)\s+(?:with|containing|including|com)\s+(.+)$",
-    )
-    for pattern in patterns:
-        match = re.search(pattern, message, flags=re.IGNORECASE)
-        if not match:
-            continue
-        table_name = normalize_identifier(match.group(1))
-        columns = [
-            parsed
-            for parsed in (parse_column_definition(column) for column in split_column_list(match.group(2)))
-            if parsed
-        ]
-        return format_create_table(table_name, columns)
-    return ""
-
-
 def parse_create_table_schema(schema):
     schema = (schema or "").strip()
     match = re.match(
@@ -953,11 +790,6 @@ def parse_create_table_schema(schema):
     return table_name, columns
 
 
-def create_table_from_schema(schema):
-    table_name, columns = parse_create_table_schema(schema)
-    return format_create_table(table_name, columns)
-
-
 def extract_create_table_statement(text):
     cleaned = extract_sql_candidate(text)
     match = re.search(
@@ -1018,7 +850,7 @@ def is_rename_intent(message):
     message = (message or "").strip().lower()
     return bool(
         re.search(
-            r"\b(rename|edit|change|renomeie|renomear|altere|mude)\s+\w+\s+(to|para|as|como)\s+\w+",
+            r"\b(rename|edit|change|renomeie|renomear|renomeia|renomeia|altere|mude|muda|troca|trocar)\s+\w+\s+(to|para|as|como|por)\s+\w+",
             message,
             flags=re.IGNORECASE,
         )
@@ -1031,9 +863,16 @@ def extract_renamed_columns(message):
         r"(\w+)\s+(?:to|para|as|como)\s+(\w+)"
     )
     matches = re.findall(pattern, message or "", flags=re.IGNORECASE)
+    # Also handle "troca X por Y" pattern
+    troca_matches = re.findall(
+        r"\btroca\b\s+(\w+)\s+\bpor\b\s+(\w+)",
+        message or "",
+        flags=re.IGNORECASE,
+    )
+    all_matches = matches + troca_matches
     return [
         (normalize_identifier(old), normalize_identifier(new))
-        for old, new in matches
+        for old, new in all_matches
         if normalize_identifier(old) and normalize_identifier(new)
     ]
 
@@ -1044,7 +883,7 @@ def parse_compound_edit(message):
         r"\s+(?:and|e)\s+"
         r"(?=\b(?:add|include|remove|delete|drop|rename|edit|change|"
         r"adicione|adicionar|inclua|acrescente|remova|remover|deletar|"
-        r"exclua|renomeie|renomear|altere|mude)\b)"
+        r"exclua|renomeie|renomear|altere|mude|troca|trocar)\b)"
     )
     segments = re.split(segment_pattern, message or "", flags=re.IGNORECASE)
 
@@ -1068,29 +907,6 @@ def parse_compound_edit(message):
     return added, removed, renamed
 
 
-def edit_create_table_from_message(message, chat_history, active_schema):
-    if not is_table_edit_intent(message) and not is_rename_intent(message):
-        return ""
-    base_sql = last_create_table_from_history(chat_history) or create_table_from_schema(active_schema)
-    table_name, existing_columns = parse_create_table_schema(base_sql)
-    if not table_name:
-        return ""
-
-    added_columns, removed_columns_list, renamed_columns = parse_compound_edit(message)
-    removed_set = set(extract_removed_columns(message)) | {r for r in removed_columns_list}
-
-    if not added_columns and not removed_set and not renamed_columns:
-        return ""
-
-    rename_map = dict(renamed_columns)
-    kept_columns = [
-        (rename_map.get(col_name, col_name), col_type)
-        for col_name, col_type in existing_columns
-        if col_name not in removed_set
-    ]
-    return format_create_table(table_name, [*kept_columns, *added_columns])
-
-
 def render_schema_context(schema=""):
     schema = (schema or "").strip()
     if not schema:
@@ -1150,9 +966,8 @@ def load_selected_model(selected_key=FINE_TUNED_MODEL_KEY):
         *query_control_updates(False),
         "",
         EMPTY_VALIDATOR,
-        gr.update(interactive=False, visible=False),
+        gr.update(value=None),
         render_message(),
-        gr.update(visible=False),
     )
     started = time.time()
     try:
@@ -1181,9 +996,8 @@ def load_selected_model(selected_key=FINE_TUNED_MODEL_KEY):
             *query_control_updates(False),
             "",
             EMPTY_VALIDATOR,
-            gr.update(interactive=False, visible=False),
+            gr.update(value=None),
             render_message(error),
-            gr.update(visible=False),
         )
         return
 
@@ -1197,19 +1011,18 @@ def load_selected_model(selected_key=FINE_TUNED_MODEL_KEY):
         *query_control_updates(True),
         "",
         EMPTY_VALIDATOR,
-        gr.update(interactive=False, visible=False),
+        gr.update(value=None),
         render_message(f"Loaded {model_def['model_id']} in {elapsed}s.", kind="ok"),
-        gr.update(visible=False),
     )
 
 
 def set_preset(name):
     schema = PRESETS[name]
-    return schema, render_schema_context(schema), gr.update(visible=True)
+    return schema, render_schema_context(schema), gr.update(visible=True), chat_core.default_state(schema)
 
 
 def clear_schema_context():
-    return "", render_schema_context(""), gr.update(visible=False)
+    return "", render_schema_context(""), gr.update(visible=False), chat_core.default_state("")
 
 
 def trim_chat_history(chat_history, max_exchanges=10):
@@ -1239,12 +1052,54 @@ def render_compare_label(prefix, model_label, metric):
     )
 
 
-def deterministic_response(
+def save_for_comparison(sql_text, loaded_key, active_schema, last_message):
+    sql_text = (sql_text or "").strip()
+    if not sql_text or not loaded_key:
+        return (
+            None,
+            gr.update(visible=False),
+            "",
+            "",
+            "",
+            "",
+            gr.update(interactive=False, visible=False),
+            render_message("Generate SQL before saving a comparison."),
+        )
+
+    model_def = model_by_key(loaded_key)
+    saved = {
+        "sql": sql_text,
+        "model_label": model_def["short_label"],
+        "match": model_def["exact_match"],
+        "schema_context": active_schema or "",
+        "user_message": last_message or "",
+    }
+    return (
+        saved,
+        gr.update(visible=True),
+        render_compare_label("Saved", model_def["short_label"], model_def["exact_match"]),
+        sql_text,
+        render_compare_label("Current", model_def["short_label"], model_def["exact_match"]),
+        sql_text,
+        gr.update(interactive=True),
+        render_message("Saved output for comparison.", kind="ok"),
+    )
+
+
+def _append_chat_turn(chat_history, message, assistant_content):
+    return trim_chat_history(
+        [
+            *list(chat_history or []),
+            {"role": "user", "content": message},
+            {"role": "assistant", "content": assistant_content},
+        ]
+    )
+
+
+def _response_tuple(
     chat_history,
     message,
-    active_schema,
-    loaded_key,
-    saved_state,
+    state,
     assistant_content,
     status_message,
     *,
@@ -1252,262 +1107,342 @@ def deterministic_response(
     validator=CHAT_VALIDATOR,
     status_kind="ok",
 ):
-    new_history = trim_chat_history(
-        [
-            *list(chat_history or []),
-            {"role": "user", "content": message},
-            {"role": "assistant", "content": assistant_content},
-        ]
-    )
-    # If sql_text is a CREATE TABLE, promote it to active_schema for subsequent queries
-    new_schema = active_schema
+    state = chat_core.ConversationState.from_value(state)
     if sql_text and "CREATE TABLE" in sql_text.upper():
-        new_schema = sql_text
-    compare = comparison_updates(saved_state, sql_text, loaded_key)
+        state = state.with_active_schema(sql_text).clear_pending_schema()
+    new_history = _append_chat_turn(chat_history, message, assistant_content)
     return (
         new_history,
         "",
-        new_schema,
+        state.active_schema,
         message,
         sql_text,
         validator,
-        gr.update(interactive=False, visible=False),
+        gr.update(value=None),
+        render_message(status_message, kind=status_kind),
+        state.to_dict(),
+    )
+
+
+def deterministic_response(
+    chat_history,
+    message,
+    active_schema,
+    loaded_key,
+    saved_state,
+    assistant_content,
+    status_message,
+    *,
+    sql_text="",
+    validator=CHAT_VALIDATOR,
+    status_kind="ok",
+    conversation_state=None,
+):
+    state = chat_core.ConversationState.from_value(conversation_state, active_schema=active_schema)
+    return _response_tuple(
+        chat_history,
+        message,
+        state,
+        assistant_content,
+        status_message,
+        sql_text=sql_text,
+        validator=validator,
+        status_kind=status_kind,
+    )
+
+
+def _model_ready(loaded_key):
+    if not loaded_key or _model is None or _tokenizer is None:
+        return False, "Load the fine-tuned model before chatting or generating SQL."
+    model_def = model_by_key(loaded_key)
+    if _current_model_id != model_def["model_id"]:
+        return False, "Loaded model state is inconsistent. Reload the selected model."
+    return True, ""
+
+
+def _generate_model_text(prompt, generation_kind=model_core.SQL_GENERATION):
+    started = time.time()
+    import_model_runtime()
+    with _model_lock:
+        model = _model
+        tokenizer = _tokenizer
+        if model is None or tokenizer is None:
+            raise RuntimeError("Model runtime is not loaded.")
+
+        inputs = tokenizer(prompt, return_tensors="pt")
+        input_length = inputs["input_ids"].shape[-1]
+        generation_config = getattr(model, "generation_config", None)
+        gen_kwargs = {
+            "max_new_tokens": model_core.generation_budget(generation_kind),
+            "max_time": GENERATION_MAX_TIME_SECONDS,
+            "do_sample": False,
+            "use_cache": False,
+            "repetition_penalty": 1.1,
+            "eos_token_id": getattr(generation_config, "eos_token_id", tokenizer.eos_token_id),
+            "pad_token_id": tokenizer.pad_token_id or tokenizer.eos_token_id,
+        }
+        executor = concurrent.futures.ThreadPoolExecutor(max_workers=1)
+        future = executor.submit(_run_generation, model, inputs, gen_kwargs)
+        try:
+            output_ids = future.result(timeout=GENERATION_TIMEOUT_SECONDS)
+        except concurrent.futures.TimeoutError:
+            executor.shutdown(wait=False, cancel_futures=False)
+            raise TimeoutError(f"Generation timed out after {GENERATION_TIMEOUT_SECONDS}s")
+        finally:
+            executor.shutdown(wait=False, cancel_futures=True)
+        generated_ids = output_ids[0][input_length:]
+        generated_text = tokenizer.decode(generated_ids, skip_special_tokens=True)
+    return generated_text, int(time.time() - started)
+
+
+def _schema_suggestion_message(suggestion):
+    columns = ", ".join(f"{name} {column_type}" for name, column_type in suggestion.columns)
+    rationale = f"\n\n{suggestion.rationale}" if suggestion.rationale else ""
+    return f"Posso montar a tabela `{suggestion.table_name}` com: {columns}.{rationale}\n\nSe quiser, diga `gera`."
+
+
+def _empty_generation_response(chat_history, message, state, status_message, *, status_kind="error"):
+    return (
+        chat_history,
+        message,
+        state.active_schema,
+        "",
+        "",
+        EMPTY_VALIDATOR,
+        gr.update(value=None),
         render_message(status_message, kind=status_kind),
-        *compare,
+        state.to_dict(),
     )
 
 
-def generate_response(message, chat_history, active_schema, loaded_key, saved_state):
+def generate_response(message, chat_history, active_schema, loaded_key, saved_state=None, conversation_state=None):
     message = (message or "").strip()
-    active_schema = (active_schema or "").strip()
     chat_history = list(chat_history or [])
+    state = chat_core.ConversationState.from_value(conversation_state, active_schema=(active_schema or ""))
     if not message:
-        compare = comparison_updates(saved_state, "", loaded_key)
         return (
             chat_history,
             "",
-            active_schema,
+            state.active_schema,
             "",
             "",
             EMPTY_VALIDATOR,
-            gr.update(interactive=False, visible=False),
+            gr.update(value=None),
             render_message("Type a message before sending."),
-            *compare,
+            state.to_dict(),
         )
 
-    # Routing debug log — shows which intent matched
-    _routing = []
-    edited_table = edit_create_table_from_message(message, chat_history, active_schema)
-    if edited_table:
-        _routing.append("edit_create_table")
-    elif is_table_edit_intent(message):
-        _routing.append("is_table_edit_intent")
-    elif is_create_table_intent(message):
-        _routing.append("is_create_table_intent")
-    elif is_sql_intent(message, active_schema):
-        _routing.append("is_sql_intent")
-    else:
-        _routing.append("no_match")
-    print(f"[ROUTING] \"{message[:60]}\" → {_routing}")
+    intent_result = intent_core.classify_intent(message, state, chat_history)
+    state = state.with_intent(intent_result)
+    print(
+        f"[ROUTING] \"{message[:60]}\" -> intent={intent_result.intent} "
+        f"confidence={intent_result.confidence} reason={intent_result.reason}",
+        flush=True,
+    )
 
-    if edited_table:
-        display_response = f"```sql\n{edited_table}\n```"
-        return deterministic_response(
-            chat_history,
-            message,
-            active_schema,
-            loaded_key,
-            saved_state,
-            display_response,
-            "Edited CREATE TABLE without calling the model.",
-            sql_text=edited_table,
-            validator=validate_sql(edited_table),
-        )
-    if is_table_edit_intent(message):
-        compare = comparison_updates(saved_state, "", loaded_key)
-        return (
+    if intent_result.intent == intent_core.EDIT_TABLE:
+        if state.pending_schema_suggestion and not state.active_schema:
+            pending_sql = sql_core.create_table_from_suggestion(state.pending_schema_suggestion)
+            edited_table = sql_core.edit_create_table_from_message(message, chat_history, pending_sql)
+            table_name, columns = sql_core.parse_create_table_schema(edited_table)
+            if edited_table and table_name and columns:
+                suggestion = chat_core.SchemaSuggestion(table_name=table_name, columns=tuple(columns))
+                state = state.with_pending_schema(suggestion)
+                return _response_tuple(
+                    chat_history,
+                    message,
+                    state,
+                    _schema_suggestion_message(suggestion),
+                    "Updated pending table proposal without calling the model.",
+                )
+        edited_table = sql_core.edit_create_table_from_message(message, chat_history, state.active_schema)
+        if edited_table:
+            display_response = f"```sql\n{edited_table}\n```"
+            return _response_tuple(
+                chat_history,
+                message,
+                state,
+                display_response,
+                "Edited CREATE TABLE without calling the model.",
+                sql_text=edited_table,
+                validator=sql_core.validate_sql(edited_table),
+            )
+        return _empty_generation_response(
             chat_history,
             message,
-            active_schema,
-            "",
-            "",
-            EMPTY_VALIDATOR,
-            gr.update(interactive=False, visible=False),
-            render_message("I need an existing CREATE TABLE in the chat or an active schema before editing columns."),
-            *compare,
+            state,
+            "I need an existing CREATE TABLE in the chat or an active schema before editing columns.",
         )
 
-    if is_create_table_intent(message):
-        sql_text = create_table_from_message(message) or create_table_from_schema(active_schema)
+    if intent_result.intent == intent_core.CREATE_TABLE_CONFIRM:
+        sql_text = sql_core.create_table_from_suggestion(state.pending_schema_suggestion)
         if sql_text:
             display_response = f"```sql\n{sql_text}\n```"
-            return deterministic_response(
+            return _response_tuple(
                 chat_history,
                 message,
-                active_schema,
-                loaded_key,
-                saved_state,
+                state.clear_pending_schema(),
+                display_response,
+                "Generated CREATE TABLE from the pending proposal.",
+                sql_text=sql_text,
+                validator=sql_core.validate_sql(sql_text),
+            )
+
+    if intent_result.intent == intent_core.CREATE_TABLE:
+        sql_text = sql_core.create_table_from_message(message) or sql_core.create_table_from_schema(state.active_schema)
+        if not sql_text:
+            ready, _error = _model_ready(loaded_key)
+            if ready:
+                try:
+                    prompt = model_core.build_schema_suggestion_prompt(message, state, chat_history)
+                    generated_text, _elapsed = _generate_model_text(prompt, model_core.SCHEMA_GENERATION)
+                    suggestion = model_core.parse_schema_suggestion(generated_text)
+                    sql_text = sql_core.create_table_from_suggestion(suggestion)
+                except Exception:
+                    sql_text = ""
+        if sql_text:
+            display_response = f"```sql\n{sql_text}\n```"
+            return _response_tuple(
+                chat_history,
+                message,
+                state,
                 display_response,
                 "Generated CREATE TABLE without calling the model.",
                 sql_text=sql_text,
-                validator=validate_sql(sql_text),
+                validator=sql_core.validate_sql(sql_text),
             )
-        compare = comparison_updates(saved_state, "", loaded_key)
-        return (
+        return _empty_generation_response(
             chat_history,
             message,
-            active_schema,
-            "",
-            "",
-            EMPTY_VALIDATOR,
-            gr.update(interactive=False, visible=False),
-            render_message("CREATE TABLE needs a table name and columns, or an active schema context."),
-            *compare,
+            state,
+            "CREATE TABLE needs a table name and columns, or a loaded model to propose them.",
         )
 
+    if intent_result.intent == intent_core.SCHEMA_SUGGESTION:
+        ready, error = _model_ready(loaded_key)
+        if not ready:
+            return _response_tuple(chat_history, message, state, error, error, status_kind="error")
+        try:
+            prompt = model_core.build_schema_suggestion_prompt(message, state, chat_history)
+            generated_text, elapsed = _generate_model_text(prompt, model_core.SCHEMA_GENERATION)
+            suggestion = model_core.parse_schema_suggestion(generated_text)
+            if not suggestion:
+                repair_prompt = (
+                    "Return valid JSON only for this SQL table proposal. "
+                    "Use table_name, columns, and rationale.\n\n"
+                    f"Previous output:\n{generated_text}"
+                )
+                repaired_text, elapsed = _generate_model_text(repair_prompt, model_core.SCHEMA_GENERATION)
+                suggestion = model_core.parse_schema_suggestion(repaired_text)
+            if not suggestion:
+                return _response_tuple(
+                    chat_history,
+                    message,
+                    state,
+                    "Nao consegui estruturar essa proposta de tabela. Diga o nome da tabela e algumas colunas.",
+                    "Schema proposal was not valid JSON.",
+                    status_kind="error",
+                )
+            state = state.with_pending_schema(suggestion)
+            return _response_tuple(
+                chat_history,
+                message,
+                state,
+                _schema_suggestion_message(suggestion),
+                f"Generated schema proposal in {elapsed}s.",
+            )
+        except Exception as exc:
+            return _empty_generation_response(
+                chat_history,
+                message,
+                state,
+                f"Generation failed: {type(exc).__name__}: {exc}",
+            )
 
-    if not is_sql_intent(message, active_schema):
-        fallback = safe_chat_fallback()
-        return deterministic_response(
-            chat_history,
-            message,
-            active_schema,
-            loaded_key,
-            saved_state,
-            fallback,
-            "No SQL intent or active schema detected.",
-        )
-
-    if not loaded_key or _model is None or _tokenizer is None:
-        compare = comparison_updates(saved_state, "", loaded_key)
-        return (
-            chat_history,
-            message,
-            active_schema,
-            "",
-            "",
-            EMPTY_VALIDATOR,
-            gr.update(interactive=False, visible=False),
-            render_message("Load a model before generating SQL."),
-            *compare,
-        )
+    if intent_result.intent in {intent_core.SMALLTALK, intent_core.CLARIFICATION, intent_core.UNKNOWN}:
+        ready, error = _model_ready(loaded_key)
+        if not ready:
+            return _response_tuple(chat_history, message, state, error, error, status_kind="error")
+        try:
+            prompt = model_core.build_chat_prompt(message, state, chat_history)
+            generated_text, elapsed = _generate_model_text(prompt, model_core.CHAT_GENERATION)
+            chat_text = model_core.clean_generation(generated_text)
+            return _response_tuple(
+                chat_history,
+                message,
+                state,
+                chat_text,
+                f"Generated chat response in {elapsed}s.",
+            )
+        except Exception as exc:
+            return _empty_generation_response(
+                chat_history,
+                message,
+                state,
+                f"Generation failed: {type(exc).__name__}: {exc}",
+            )
 
-    model_def = model_by_key(loaded_key)
-    if _current_model_id != model_def["model_id"]:
-        compare = comparison_updates(saved_state, "", loaded_key)
-        return (
+    ready, error = _model_ready(loaded_key)
+    if not ready:
+        return _empty_generation_response(
             chat_history,
             message,
-            active_schema,
-            "",
-            "",
-            EMPTY_VALIDATOR,
-            gr.update(interactive=False, visible=False),
-            render_message("Loaded model state is inconsistent. Reload the selected model."),
-            *compare,
+            state,
+            error if "inconsistent" in error else "Load a model before generating SQL.",
         )
 
-    started = time.time()
     try:
-        import_model_runtime()
-        with _model_lock:
-            prompt = build_generation_prompt(active_schema, message, chat_history)
-            inputs = _tokenizer(prompt, return_tensors="pt")
-            input_length = inputs["input_ids"].shape[-1]
-            gen_kwargs = {
-                "max_new_tokens": 80,
-                "max_time": GENERATION_MAX_TIME_SECONDS,
-                "do_sample": False,
-                "use_cache": False,
-                "repetition_penalty": 1.1,
-                "eos_token_id": getattr(_model.generation_config, "eos_token_id", _tokenizer.eos_token_id),
-                "pad_token_id": _tokenizer.pad_token_id or _tokenizer.eos_token_id,
-            }
-            executor = concurrent.futures.ThreadPoolExecutor(max_workers=1)
-            future = executor.submit(_run_generation, _model, inputs, gen_kwargs)
-            try:
-                output_ids = future.result(timeout=GENERATION_TIMEOUT_SECONDS)
-            except concurrent.futures.TimeoutError:
-                # Timeout reached - do NOT call future.result() without timeout as it can block indefinitely.
-                # The thread may continue in background but we won't wait for it.
-                # Return error to user and release the slot.
-                executor.shutdown(wait=False, cancel_futures=False)
-                raise TimeoutError(f"Generation timed out after {GENERATION_TIMEOUT_SECONDS}s")
-            finally:
-                executor.shutdown(wait=False, cancel_futures=True)
-            generated_ids = output_ids[0][input_length:]
-            generated_text = _tokenizer.decode(generated_ids, skip_special_tokens=True)
+        prompt = model_core.build_sql_prompt(state.active_schema, message, chat_history)
+        generated_text, elapsed = _generate_model_text(prompt, model_core.SQL_GENERATION)
     except Exception as exc:
-        compare = comparison_updates(saved_state, "", loaded_key)
-        return (
+        return _empty_generation_response(
             chat_history,
             message,
-            active_schema,
-            "",
-            "",
-            EMPTY_VALIDATOR,
-            gr.update(interactive=False, visible=False),
-            render_message(f"Generation failed: {type(exc).__name__}: {exc}"),
-            *compare,
+            state,
+            f"Generation failed: {type(exc).__name__}: {exc}",
         )
 
-    elapsed = int(time.time() - started)
-    sql_text, chat_text, validator = format_generation_result(generated_text)
+    sql_text, chat_text, validator = model_core.format_generation_result(generated_text)
     display_response = f"```sql\n{sql_text}\n```" if sql_text else chat_text
-    new_history = trim_chat_history(
-        [
-            *chat_history,
-            {"role": "user", "content": message},
-            {"role": "assistant", "content": display_response},
-        ]
-    )
-    compare = comparison_updates(saved_state, sql_text, loaded_key)
     response_kind = "SQL" if sql_text.strip() else "chat response"
-    return (
-        new_history,
-        "",
-        active_schema,
+    model_def = model_by_key(loaded_key)
+    return _response_tuple(
+        chat_history,
         message,
-        str(sql_text),
-        validator,
-        gr.update(interactive=False, visible=False),
-        render_message(f"Generated {response_kind} with {model_def['model_id']} in {elapsed}s.", kind="ok"),
-        *compare,
+        state,
+        display_response,
+        f"Generated {response_kind} with {model_def['model_id']} in {elapsed}s.",
+        sql_text=str(sql_text),
+        validator=validator,
     )
 
 
-def save_for_comparison(sql_text, loaded_key, active_schema, last_message):
-    sql_text = (sql_text or "").strip()
-    if not sql_text or not loaded_key:
-        return (
-            None,
-            gr.update(visible=False),
-            "",
-            "",
-            "",
-            "",
-            gr.update(interactive=False, visible=False),
-            render_message("Generate SQL before saving a comparison."),
-        )
+def is_sql_intent(message, schema):
+    return sql_core.is_sql_intent(message, schema)
 
-    model_def = model_by_key(loaded_key)
-    saved = {
-        "sql": sql_text,
-        "model_label": model_def["short_label"],
-        "match": model_def["exact_match"],
-        "schema_context": active_schema or "",
-        "user_message": last_message or "",
-    }
-    return (
-        saved,
-        gr.update(visible=True),
-        render_compare_label("Saved", model_def["short_label"], model_def["exact_match"]),
-        sql_text,
-        render_compare_label("Current", model_def["short_label"], model_def["exact_match"]),
-        sql_text,
-        gr.update(interactive=True),
-        render_message("Saved output for comparison.", kind="ok"),
-    )
+
+def build_generation_prompt(schema, message, chat_history=None):
+    return model_core.build_sql_prompt(schema, message, chat_history)
+
+
+def format_generation_result(text):
+    return model_core.format_generation_result(text)
+
+
+def validate_sql(sql_text):
+    return sql_core.validate_sql(sql_text)
+
+
+def create_table_from_message(message):
+    return sql_core.create_table_from_message(message)
+
+
+def create_table_from_schema(schema):
+    return sql_core.create_table_from_schema(schema)
+
+
+def edit_create_table_from_message(message, chat_history, active_schema):
+    return sql_core.edit_create_table_from_message(message, chat_history, active_schema)
 
 
 def sync_on_load():
@@ -1523,9 +1458,8 @@ def sync_on_load():
                 *query_control_updates(True),
                 "",
                 EMPTY_VALIDATOR,
-                gr.update(interactive=False, visible=False),
+                gr.update(value=None),
                 render_message(f"Model already loaded: {_current_model_id}", kind="ok"),
-                gr.update(visible=False),
             )
     return (
         None,
@@ -1536,9 +1470,8 @@ def sync_on_load():
         *query_control_updates(False),
         "",
         EMPTY_VALIDATOR,
-        gr.update(interactive=False, visible=False),
+        gr.update(value=None),
         render_message(),
-        gr.update(visible=False),
     )
 
 
@@ -2296,10 +2229,11 @@ textarea {
 }
 """
 
-with gr.Blocks(title="Phi-3 Mini SQL Generator") as demo:
+with gr.Blocks(title="Phi-3 Mini SQL Chatbot") as demo:
     loaded_key_state = gr.State(value=None)
-    saved_output = gr.State(value=None)
     active_schema = gr.State(value="")
+    conversation_state = gr.State(value=chat_core.default_state())
+    generation_meta_state = gr.State(value=None)
     last_user_message = gr.State(value="")
 
     with gr.Column(elem_classes=["app-shell"]):
@@ -2312,7 +2246,6 @@ with gr.Blocks(title="Phi-3 Mini SQL Generator") as demo:
         load_button = gr.Button("Load fine-tuned model", variant="primary", elem_id="load-button")
         model_status = gr.HTML(render_status(DEFAULT_MODEL_KEY, None))
         model_info = gr.HTML(model_metadata(DEFAULT_MODEL_KEY))
-        gr.HTML(render_baseline_evidence())
 
         with gr.Column(elem_id="query-section", elem_classes=["query-section"]):
             gr.HTML(render_step("02", "Chat"))
@@ -2366,23 +2299,8 @@ with gr.Blocks(title="Phi-3 Mini SQL Generator") as demo:
                 interactive=False,
                 show_label=False,
             )
-        save_button = gr.Button(
-            "Save output",
-            interactive=False,
-            visible=False,
-            elem_id="save-button",
-        )
         error_output = gr.HTML(render_message())
 
-        with gr.Column(visible=False, elem_classes=["comparison-panel"]) as comparison_panel:
-            with gr.Row(elem_classes=["compare-grid"]):
-                with gr.Column(elem_classes=["compare-card"]):
-                    saved_model_label = gr.HTML("")
-                    saved_sql = gr.Code(label="", language="sql", lines=6, show_label=False)
-                with gr.Column(elem_classes=["compare-card", "current"]):
-                    current_model_label = gr.HTML("")
-                    current_sql = gr.Code(label="", language="sql", lines=6, show_label=False)
-
     model_state_outputs = [
         fine_tuned_model_card,
         model_status,
@@ -2395,7 +2313,6 @@ with gr.Blocks(title="Phi-3 Mini SQL Generator") as demo:
         clear_schema_button,
         message_input,
         send_button,
-        save_button,
         error_output,
     ]
 
@@ -2418,14 +2335,13 @@ with gr.Blocks(title="Phi-3 Mini SQL Generator") as demo:
             send_button,
             sql_output,
             validator_output,
-            save_button,
+            generation_meta_state,
             error_output,
-            comparison_panel,
         ],
         js=LOAD_SCROLL_JS,
     )
 
-    schema_context_outputs = [active_schema, active_schema_pill, clear_schema_button]
+    schema_context_outputs = [active_schema, active_schema_pill, clear_schema_button, conversation_state]
     employees_preset.click(set_preset, inputs=gr.State("employees"), outputs=schema_context_outputs)
     orders_preset.click(set_preset, inputs=gr.State("orders"), outputs=schema_context_outputs)
     students_preset.click(set_preset, inputs=gr.State("students"), outputs=schema_context_outputs)
@@ -2440,38 +2356,20 @@ with gr.Blocks(title="Phi-3 Mini SQL Generator") as demo:
         last_user_message,
         sql_output,
         validator_output,
-        save_button,
+        generation_meta_state,
         error_output,
-        comparison_panel,
-        saved_model_label,
-        saved_sql,
-        current_model_label,
-        current_sql,
+        conversation_state,
     ]
     send_button.click(
         generate_response,
-        inputs=[message_input, chatbot, active_schema, loaded_key_state, saved_output],
+        inputs=[message_input, chatbot, active_schema, loaded_key_state, generation_meta_state, conversation_state],
         outputs=chat_generation_outputs,
     )
     message_input.submit(
         generate_response,
-        inputs=[message_input, chatbot, active_schema, loaded_key_state, saved_output],
+        inputs=[message_input, chatbot, active_schema, loaded_key_state, generation_meta_state, conversation_state],
         outputs=chat_generation_outputs,
     )
-    save_button.click(
-        save_for_comparison,
-        inputs=[sql_output, loaded_key_state, active_schema, last_user_message],
-        outputs=[
-            saved_output,
-            comparison_panel,
-            saved_model_label,
-            saved_sql,
-            current_model_label,
-            current_sql,
-            save_button,
-            error_output,
-        ],
-    )
     demo.load(
         sync_on_load,
         outputs=[
@@ -2490,9 +2388,8 @@ with gr.Blocks(title="Phi-3 Mini SQL Generator") as demo:
             send_button,
             sql_output,
             validator_output,
-            save_button,
+            generation_meta_state,
             error_output,
-            comparison_panel,
         ],
     )
 

chat_state.py

@@ -0,0 +1,124 @@
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class SchemaSuggestion:
+    table_name: str = ""
+    columns: tuple[tuple[str, str], ...] = ()
+    rationale: str = ""
+
+    @classmethod
+    def from_value(cls, value):
+        if isinstance(value, cls):
+            return value
+        if not isinstance(value, dict):
+            return None
+        raw_columns = value.get("columns") or ()
+        columns = []
+        for column in raw_columns:
+            if isinstance(column, dict):
+                name = str(column.get("name") or "").strip()
+                column_type = str(column.get("type") or "TEXT").strip().upper()
+            elif isinstance(column, (list, tuple)) and len(column) >= 2:
+                name = str(column[0] or "").strip()
+                column_type = str(column[1] or "TEXT").strip().upper()
+            else:
+                continue
+            if name:
+                columns.append((name, column_type or "TEXT"))
+        table_name = str(value.get("table_name") or "").strip()
+        rationale = str(value.get("rationale") or "").strip()
+        if not table_name or not columns:
+            return None
+        return cls(table_name=table_name, columns=tuple(columns), rationale=rationale)
+
+    def to_dict(self):
+        return {
+            "table_name": self.table_name,
+            "columns": [{"name": name, "type": column_type} for name, column_type in self.columns],
+            "rationale": self.rationale,
+        }
+
+
+@dataclass(frozen=True)
+class ConversationState:
+    active_schema: str = ""
+    pending_schema_suggestion: SchemaSuggestion | None = None
+    last_intent: str | None = None
+    last_table_topic: str | None = None
+    debug: dict = field(default_factory=dict)
+
+    @classmethod
+    def from_value(cls, value=None, *, active_schema=""):
+        if isinstance(value, cls):
+            if active_schema and active_schema != value.active_schema:
+                return value.with_active_schema(active_schema)
+            return value
+        if not isinstance(value, dict):
+            return cls(active_schema=(active_schema or "").strip())
+        pending = SchemaSuggestion.from_value(value.get("pending_schema_suggestion"))
+        state_active_schema = (value.get("active_schema") or active_schema or "").strip()
+        return cls(
+            active_schema=state_active_schema,
+            pending_schema_suggestion=pending,
+            last_intent=value.get("last_intent"),
+            last_table_topic=value.get("last_table_topic"),
+            debug=dict(value.get("debug") or {}),
+        )
+
+    def to_dict(self):
+        return {
+            "active_schema": self.active_schema,
+            "pending_schema_suggestion": (
+                self.pending_schema_suggestion.to_dict() if self.pending_schema_suggestion else None
+            ),
+            "last_intent": self.last_intent,
+            "last_table_topic": self.last_table_topic,
+            "debug": dict(self.debug or {}),
+        }
+
+    def with_active_schema(self, schema):
+        return ConversationState(
+            active_schema=(schema or "").strip(),
+            pending_schema_suggestion=self.pending_schema_suggestion,
+            last_intent=self.last_intent,
+            last_table_topic=self.last_table_topic,
+            debug=dict(self.debug or {}),
+        )
+
+    def with_pending_schema(self, suggestion):
+        suggestion = SchemaSuggestion.from_value(suggestion)
+        return ConversationState(
+            active_schema=self.active_schema,
+            pending_schema_suggestion=suggestion,
+            last_intent=self.last_intent,
+            last_table_topic=(suggestion.table_name if suggestion else self.last_table_topic),
+            debug=dict(self.debug or {}),
+        )
+
+    def clear_pending_schema(self):
+        return ConversationState(
+            active_schema=self.active_schema,
+            pending_schema_suggestion=None,
+            last_intent=self.last_intent,
+            last_table_topic=self.last_table_topic,
+            debug=dict(self.debug or {}),
+        )
+
+    def with_intent(self, intent_result):
+        debug = dict(self.debug or {})
+        debug["intent"] = getattr(intent_result, "intent", None)
+        debug["confidence"] = getattr(intent_result, "confidence", None)
+        debug["reason"] = getattr(intent_result, "reason", None)
+        return ConversationState(
+            active_schema=self.active_schema,
+            pending_schema_suggestion=self.pending_schema_suggestion,
+            last_intent=getattr(intent_result, "intent", None),
+            last_table_topic=self.last_table_topic,
+            debug=debug,
+        )
+
+
+def default_state(active_schema=""):
+    return ConversationState(active_schema=(active_schema or "").strip()).to_dict()
+

intent.py

@@ -0,0 +1,115 @@
+from dataclasses import dataclass
+
+from chat_state import ConversationState
+import sql_tools
+
+
+SMALLTALK = "smalltalk"
+SCHEMA_SUGGESTION = "schema_suggestion"
+CREATE_TABLE = "create_table"
+CREATE_TABLE_CONFIRM = "create_table_confirm"
+EDIT_TABLE = "edit_table"
+SQL_QUERY = "sql_query"
+CLARIFICATION = "clarification"
+UNKNOWN = "unknown"
+
+
+@dataclass(frozen=True)
+class IntentResult:
+    intent: str
+    confidence: float
+    reason: str
+
+
+def _has_pending_schema(state):
+    return bool(getattr(state, "pending_schema_suggestion", None))
+
+
+def _has_active_schema(state):
+    return bool((getattr(state, "active_schema", "") or "").strip())
+
+
+def _is_confirmation(message):
+    normalized = sql_tools.normalize_text(message)
+    confirmations = {
+        "sim", "yes", "ok", "claro", "pode", "pode gerar", "gera", "gerar",
+        "gere", "faz", "faca", "cria", "crie", "manda", "confirmo", "isso",
+        "isso mesmo", "perfeito",
+    }
+    return normalized in confirmations or normalized.startswith(("gera ", "pode gerar", "faz "))
+
+
+def _is_smalltalk(message):
+    normalized = sql_tools.normalize_text(message)
+    exact = {
+        "oi", "ola", "hi", "hello", "hey", "bom dia", "boa tarde", "boa noite",
+        "obrigado", "obrigada", "valeu", "thanks", "thank you",
+        "como voce esta", "como voce esta hoje", "qual seu nome",
+        "me conte uma piada", "conte uma piada", "vamos conversar",
+        "o que voce faz", "como voce funciona", "como funciona",
+    }
+    if normalized in exact:
+        return True
+    smalltalk_fragments = (
+        "como voce esta",
+        "qual seu nome",
+        "conte uma piada",
+        "vamos conversar",
+        "obrigado",
+    )
+    return any(fragment in normalized for fragment in smalltalk_fragments)
+
+
+def _is_schema_suggestion(message):
+    normalized = sql_tools.normalize_text(message)
+    patterns = (
+        "preciso de uma tabela",
+        "preciso de um schema",
+        "quero uma tabela",
+        "quero um schema",
+        "sugira uma tabela",
+        "sugerir uma tabela",
+        "tabela sobre",
+        "tabela de",
+        "schema sobre",
+        "schema de",
+        "modelo de tabela",
+        "modelar",
+    )
+    if any(pattern in normalized for pattern in patterns) and not sql_tools.is_create_table_intent(message):
+        return True
+    if "tabela" in normalized and any(term in normalized for term in ("sobre", "para", "de")):
+        return not any(term in normalized for term in ("crie", "criar", "create", "generate", "gerar", "gere"))
+    return False
+
+
+def classify_intent(message, state=None, chat_history=None):
+    state = ConversationState.from_value(state)
+    normalized = sql_tools.normalize_text(message)
+    if not normalized:
+        return IntentResult(UNKNOWN, 0.0, "empty_message")
+
+    if _has_pending_schema(state) and _is_confirmation(message):
+        return IntentResult(CREATE_TABLE_CONFIRM, 0.95, "confirmation_with_pending_schema")
+
+    if _is_smalltalk(message):
+        return IntentResult(SMALLTALK, 0.95, "smalltalk_phrase")
+
+    edited_table = sql_tools.edit_create_table_from_message(message, chat_history, state.active_schema)
+    if edited_table or sql_tools.is_table_edit_intent(message):
+        return IntentResult(EDIT_TABLE, 0.9 if (edited_table or _has_active_schema(state) or _has_pending_schema(state)) else 0.7, "table_edit_terms")
+
+    if sql_tools.is_create_table_intent(message):
+        return IntentResult(CREATE_TABLE, 0.9, "explicit_create_table")
+
+    if _is_schema_suggestion(message):
+        return IntentResult(SCHEMA_SUGGESTION, 0.86, "schema_suggestion_phrase")
+
+    if sql_tools.is_sql_intent(message, state.active_schema):
+        return IntentResult(SQL_QUERY, 0.86, "sql_query_terms")
+
+    if _has_pending_schema(state):
+        return IntentResult(CLARIFICATION, 0.55, "pending_schema_context")
+
+    return IntentResult(UNKNOWN, 0.25, "no_intent_match")
+

model_io.py

@@ -0,0 +1,132 @@
+import json
+import re
+
+from chat_state import ConversationState, SchemaSuggestion
+import sql_tools
+
+
+CHAT_GENERATION = "chat"
+SCHEMA_GENERATION = "schema"
+SQL_GENERATION = "sql"
+
+GENERATION_BUDGETS = {
+    CHAT_GENERATION: 120,
+    SCHEMA_GENERATION: 180,
+    SQL_GENERATION: 96,
+}
+
+CHAT_PROMPT_TEMPLATE = (
+    "<|user|>\n"
+    "You are a conversational SQL assistant. Reply naturally in Brazilian Portuguese unless the user writes in English.\n"
+    "You can chat normally, discuss table ideas, and help generate SQL, but do not generate SQL unless the user asks for it.\n"
+    "Current state:\n{state_summary}\n\n"
+    "{history_context}"
+    "User message: {message}<|end|>\n"
+    "<|assistant|>"
+)
+
+SCHEMA_SUGGESTION_PROMPT_TEMPLATE = (
+    "<|user|>\n"
+    "Create a practical SQL table proposal for the user's domain request.\n"
+    "Return JSON only with this shape: "
+    '{{"table_name":"name","columns":[{{"name":"id","type":"INTEGER"}}],"rationale":"short reason"}}.\n'
+    "Use simple SQL types: INTEGER, TEXT, NUMERIC, DATE, BOOLEAN.\n"
+    "{history_context}"
+    "Request: {message}<|end|>\n"
+    "<|assistant|>"
+)
+
+SQL_PROMPT_TEMPLATE = (
+    "<|user|>\n"
+    "Given the following SQL table, write one SQL query. Output SQL only.\n\n"
+    "Table: {schema}\n\n"
+    "{history_context}"
+    "Question: {question}<|end|>\n"
+    "<|assistant|>"
+)
+
+
+def _history_context(chat_history, max_exchanges=3):
+    history = list(chat_history or [])[-max_exchanges * 2 :]
+    if not history:
+        return ""
+    lines = []
+    for item in history:
+        if not isinstance(item, dict):
+            continue
+        role = item.get("role", "user")
+        content = sql_tools.content_to_text(item.get("content", "")).strip()
+        if content:
+            lines.append(f"{role.title()}: {content}")
+    if not lines:
+        return ""
+    return "Previous conversation:\n" + "\n".join(lines) + "\n\n"
+
+
+def _state_summary(state):
+    state = ConversationState.from_value(state)
+    pending = state.pending_schema_suggestion.table_name if state.pending_schema_suggestion else "none"
+    active = "present" if state.active_schema else "none"
+    return f"- active_schema: {active}\n- pending_schema_suggestion: {pending}"
+
+
+def build_chat_prompt(message, state=None, chat_history=None):
+    return CHAT_PROMPT_TEMPLATE.format(
+        message=(message or "").strip(),
+        state_summary=_state_summary(state),
+        history_context=_history_context(chat_history),
+    )
+
+
+def build_schema_suggestion_prompt(message, state=None, chat_history=None):
+    return SCHEMA_SUGGESTION_PROMPT_TEMPLATE.format(
+        message=(message or "").strip(),
+        history_context=_history_context(chat_history),
+    )
+
+
+def build_sql_prompt(schema, message, chat_history=None):
+    table_schema = (schema or "").strip() or "CREATE TABLE unknown (id INTEGER)"
+    return SQL_PROMPT_TEMPLATE.format(
+        schema=table_schema,
+        question=(message or "").strip(),
+        history_context=_history_context(chat_history),
+    )
+
+
+def build_generation_prompt(schema, message, chat_history=None):
+    return build_sql_prompt(schema, message, chat_history)
+
+
+def generation_budget(kind):
+    return GENERATION_BUDGETS.get(kind, GENERATION_BUDGETS[SQL_GENERATION])
+
+
+def clean_generation(text):
+    return sql_tools.clean_generation(text)
+
+
+def extract_sql_candidate(text):
+    return sql_tools.extract_sql_candidate(text)
+
+
+def is_sql_like(text):
+    return sql_tools.is_sql_like(text)
+
+
+def format_generation_result(text):
+    cleaned = extract_sql_candidate(text)
+    if is_sql_like(cleaned):
+        return str(cleaned), "", sql_tools.validate_sql(cleaned)
+    return "", str(cleaned), '<span class="validator-badge validator-empty">Chat response</span>'
+
+
+def parse_schema_suggestion(text):
+    cleaned = clean_generation(text)
+    match = re.search(r"\{.*\}", cleaned, flags=re.DOTALL)
+    raw_json = match.group(0) if match else cleaned
+    try:
+        payload = json.loads(raw_json)
+    except json.JSONDecodeError:
+        return None
+    return SchemaSuggestion.from_value(payload)

scripts/model_probe.py

@@ -0,0 +1,115 @@
+import json
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+import app  # noqa: E402
+
+
+def _assistant_text(result):
+    history = result[0] or []
+    return history[-1]["content"] if history else ""
+
+
+def _scenario(name, message, history, active_schema, state):
+    result = app.generate_response(
+        message,
+        history,
+        active_schema,
+        app.FINE_TUNED_MODEL_KEY,
+        None,
+        state,
+    )
+    return {
+        "name": name,
+        "message": message,
+        "assistant": _assistant_text(result),
+        "sql": result[4],
+        "status": result[7],
+        "active_schema": result[2],
+        "state": result[8],
+        "history": result[0],
+    }
+
+
+def _contains_any(text, needles):
+    text = (text or "").lower()
+    return any(needle.lower() in text for needle in needles)
+
+
+def _grade(records):
+    checks = []
+    by_name = {record["name"]: record for record in records}
+
+    checks.append({
+        "name": "smalltalk_is_conversational",
+        "pass": bool(by_name["greeting"]["assistant"]) and not by_name["greeting"]["sql"],
+        "detail": "Greeting should produce chat text and no SQL.",
+    })
+    checks.append({
+        "name": "schema_suggestion_sets_pending",
+        "pass": bool((by_name["schema_request"]["state"] or {}).get("pending_schema_suggestion")),
+        "detail": "Domain table request should create a pending schema proposal.",
+    })
+    checks.append({
+        "name": "confirmation_generates_create_table",
+        "pass": "CREATE TABLE" in (by_name["confirm_generate"]["sql"] or "").upper(),
+        "detail": "Confirmation should generate CREATE TABLE SQL.",
+    })
+    checks.append({
+        "name": "edit_updates_schema",
+        "pass": _contains_any(by_name["edit_schema"]["sql"], ["numero_animais", "num_animais"]),
+        "detail": "Edit should replace capacidade with an animal-count column.",
+    })
+    checks.append({
+        "name": "query_generates_select",
+        "pass": "SELECT" in (by_name["query_schema"]["sql"] or "").upper(),
+        "detail": "Natural query should generate SELECT SQL.",
+    })
+    checks.append({
+        "name": "smalltalk_with_schema_stays_chat",
+        "pass": bool(by_name["smalltalk_with_schema"]["assistant"]) and not by_name["smalltalk_with_schema"]["sql"],
+        "detail": "Smalltalk with active schema should not become SQL.",
+    })
+    return checks
+
+
+def main():
+    app.load_model(app.FINE_TUNED_MODEL_ID)
+
+    history = []
+    active_schema = ""
+    state = app.chat_core.default_state()
+    records = []
+
+    for name, message in [
+        ("greeting", "oi"),
+        ("schema_request", "preciso de uma tabela sobre zoologico"),
+        ("confirm_generate", "gera"),
+        ("edit_schema", "troca capacidade por numero_animais"),
+        ("query_schema", "liste zoologicos de Sao Paulo"),
+        ("smalltalk_with_schema", "como voce esta hoje?"),
+    ]:
+        record = _scenario(name, message, history, active_schema, state)
+        records.append({key: value for key, value in record.items() if key != "history"})
+        history = record["history"]
+        active_schema = record["active_schema"]
+        state = record["state"]
+
+    checks = _grade(records)
+    report = {
+        "model": app.FINE_TUNED_MODEL_ID,
+        "passed": all(check["pass"] for check in checks),
+        "checks": checks,
+        "records": records,
+    }
+    print(json.dumps(report, ensure_ascii=False, indent=2))
+    return 0 if report["passed"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

sql_tools.py

@@ -0,0 +1,454 @@
+import html
+import re
+import unicodedata
+
+import sqlparse
+
+
+SQL_STARTERS = {"SELECT", "WITH", "INSERT", "UPDATE", "DELETE", "CREATE", "ALTER", "DROP"}
+
+
+def content_to_text(value):
+    if value is None:
+        return ""
+    if isinstance(value, str):
+        return value
+    if isinstance(value, dict):
+        for key in ("text", "content", "value"):
+            if key in value:
+                return content_to_text(value[key])
+        return " ".join(content_to_text(item) for item in value.values())
+    if isinstance(value, (list, tuple)):
+        return "\n".join(content_to_text(item) for item in value)
+    return str(value)
+
+
+def normalize_text(value):
+    text = content_to_text(value).lower()
+    text = unicodedata.normalize("NFKD", text)
+    text = "".join(char for char in text if not unicodedata.combining(char))
+    return re.sub(r"\s+", " ", text).strip()
+
+
+def clean_generation(text):
+    cleaned = content_to_text(text).strip()
+    if cleaned.startswith("```"):
+        lines = cleaned.splitlines()
+        if lines and lines[0].strip().lower() in {"```", "```sql"}:
+            lines = lines[1:]
+        if lines and lines[-1].strip() == "```":
+            lines = lines[:-1]
+        cleaned = "\n".join(lines).strip()
+    for marker in ("<|end|>", "<|user|>", "<|assistant|>", "</s>"):
+        if marker in cleaned:
+            cleaned = cleaned.split(marker, 1)[0].strip()
+    if cleaned.upper().startswith("SQL:"):
+        cleaned = cleaned[4:].strip()
+    return cleaned
+
+
+def extract_sql_candidate(text):
+    cleaned = clean_generation(text)
+    match = re.search(r"\b(SELECT|WITH|INSERT|UPDATE|DELETE|CREATE|ALTER|DROP)\b", cleaned, flags=re.IGNORECASE)
+    if not match:
+        return cleaned
+    return cleaned[match.start() :].strip()
+
+
+def is_sql_like(text):
+    text = (text or "").strip()
+    if not text:
+        return False
+    first_word = re.match(r"^\s*([A-Za-z]+)", text)
+    if not first_word:
+        return False
+    return first_word.group(1).upper() in SQL_STARTERS
+
+
+def is_sql_intent(message, schema=""):
+    message = normalize_text(message)
+    if not message:
+        return False
+    smalltalk_patterns = {
+        "oi", "ola", "olá", "hi", "hello", "hey", "obrigado", "obrigada", "thanks",
+        "thank you", "como voce esta", "como você esta", "qual seu nome", "me conte uma piada",
+        "vamos conversar", "como voce funciona", "como funciona", "o que voce faz", "o que faz",
+    }
+    if message in {normalize_text(item) for item in smalltalk_patterns}:
+        return False
+    if any(pattern in message for pattern in ("como voce esta", "qual seu nome", "conte uma piada")):
+        return False
+    sql_terms = {
+        "all", "average", "count", "columns", "database", "find", "get", "group by",
+        "join", "list", "order by", "query", "rows", "select", "show", "sum", "where",
+        "consulta", "consultar", "contar", "colunas", "linhas", "liste", "listar",
+        "maior", "mais caro", "menor", "media", "mostre", "mostrar", "ordene",
+        "selecione", "some", "soma", "quantos", "filtre", "filtrar",
+    }
+    if any(re.search(rf"(?<!\w){re.escape(normalize_text(term))}(?!\w)", message) for term in sql_terms):
+        return True
+    return bool(schema and is_sql_like(message))
+
+
+def validate_sql(sql_text):
+    sql_text = (sql_text or "").strip()
+    if not sql_text:
+        return '<span class="validator-badge validator-empty">No SQL yet</span>'
+    try:
+        statements = [stmt for stmt in sqlparse.parse(sql_text) if str(stmt).strip()]
+    except Exception as exc:
+        error_type = html.escape(type(exc).__name__)
+        return (
+            '<span class="validator-badge validator-warn">Check syntax</span>'
+            f'<span class="validator-detail">sqlparse error: {error_type}</span>'
+        )
+    if not statements:
+        return (
+            '<span class="validator-badge validator-warn">Check syntax</span>'
+            '<span class="validator-detail">No parsed SQL statement.</span>'
+        )
+    first_token = statements[0].token_first(skip_cm=True)
+    token_value = first_token.value.strip().upper() if first_token is not None else "UNKNOWN"
+    if token_value not in SQL_STARTERS:
+        escaped_token = html.escape(token_value)
+        return (
+            '<span class="validator-badge validator-warn">Check syntax</span>'
+            f'<span class="validator-detail">First token: {escaped_token}</span>'
+        )
+    return '<span class="validator-badge validator-ok">Valid SQL</span>'
+
+
+def is_create_table_intent(message):
+    message = (message or "").strip().lower()
+    return bool(
+        re.search(r"\b(create|make|build|generate|criar|crie|cria|criando|gerar|gere|gera|gerando|faz|faça|fazendo|monta|montar|monte)\b", message)
+        and re.search(r"\b(table|schema|tabela)\b", message)
+    )
+
+
+def is_rename_intent(message):
+    message = (message or "").strip().lower()
+    return bool(
+        re.search(
+            r"\b(rename|edit|change|renomeie|renomear|renomeia|altere|mude|muda|troca|trocar)\s+\w+\s+(to|para|as|como|por)\s+\w+",
+            message,
+            flags=re.IGNORECASE,
+        )
+    )
+
+
+def is_table_edit_intent(message):
+    message = (message or "").strip().lower()
+    edit_terms = r"\b(edit|update|modify|alter|add|include|remove|delete|drop|edita|editar|altera|altere|alterar|mude|mudar|adicione|adicionar|inclua|incluir|acrescente|remova|remover|deletar|exclua|excluir|novo|nova|troca|trocar|coloque|colocar)\b"
+    direct_add_terms = r"\b(add|include|adicione|adicionar|adicionando|inclua|incluir|acrescente|coloque|colocar)\b"
+    direct_remove_terms = r"\b(remove|delete|drop|remova|remover|deletar|exclua|excluir)\b"
+    target_terms = r"\b(column|field|element|coluna|campo|elemento|item)\b"
+    sql_aggregation_terms = {"up", "sum", "total", "count", "average", "avg", "max", "min", "by"}
+    add_match = re.search(direct_add_terms, message)
+    if add_match:
+        after_add = message[add_match.start() + len(add_match.group()) :].strip()
+        first_word_after = after_add.split()[0] if after_add.split() else ""
+        is_add_intent = first_word_after not in sql_aggregation_terms
+    else:
+        is_add_intent = False
+    return bool(
+        is_add_intent
+        or re.search(direct_remove_terms, message)
+        or is_rename_intent(message)
+        or re.search(r"\b(?:altere|alterar|mude|mudar)\b.*\bter\b", message)
+        or (re.search(edit_terms, message) and (re.search(target_terms, message) or ":" in message or re.search(r"\bpor\b", message)))
+    )
+
+
+def infer_column_type(column_name):
+    name = column_name.strip().lower()
+    if name == "id" or name.endswith("_id") or name in {"quantity", "quantidade", "stock", "estoque", "year"}:
+        return "INTEGER"
+    if name in {
+        "salary", "price", "preco", "amount", "total", "grade", "peso", "weight",
+        "idade", "age", "altura", "height", "largura", "width", "comprimento",
+        "length", "desconto", "discount",
+    }:
+        return "NUMERIC"
+    if name in {"date", "created_at", "updated_at"} or name.endswith("_date"):
+        return "DATE"
+    return "TEXT"
+
+
+def normalize_identifier(value):
+    identifier = re.sub(r"\W+", "_", normalize_text(value)).strip("_")
+    if not identifier:
+        return ""
+    if identifier[0].isdigit():
+        identifier = f"col_{identifier}"
+    return identifier
+
+
+def parse_column_definition(raw_column):
+    raw_column = re.sub(r"\b(for me|please|por favor)\b", "", raw_column or "", flags=re.IGNORECASE)
+    raw_column = raw_column.strip(" .;:")
+    if not raw_column:
+        return None
+    type_matches = list(
+        re.finditer(
+            r"\b(integer|int|numeric|decimal|real|float|double|text|varchar|char|date|datetime|timestamp|boolean|bool)\b",
+            raw_column,
+            flags=re.IGNORECASE,
+        )
+    )
+    explicit_type = type_matches[-1] if type_matches else None
+    if explicit_type:
+        name_part = raw_column[: explicit_type.start()].strip()
+        column_type = explicit_type.group(1).upper()
+        if column_type == "INT":
+            column_type = "INTEGER"
+        elif column_type == "BOOL":
+            column_type = "BOOLEAN"
+        elif column_type == "DECIMAL":
+            column_type = "NUMERIC"
+        elif column_type in {"FLOAT", "DOUBLE"}:
+            column_type = "REAL"
+        if not name_part.strip():
+            column_type = None
+            name_part = raw_column
+    else:
+        name_part = raw_column
+        column_type = None
+    name_part = re.sub(r"\b(column|field|coluna|campo)\b", "", name_part, flags=re.IGNORECASE)
+    column_name = normalize_identifier(name_part)
+    if not column_name:
+        return None
+    return column_name, column_type or infer_column_type(column_name)
+
+
+def split_column_list(columns_text):
+    columns_text = re.sub(r"\s+(and|e)\s+", ",", columns_text or "", flags=re.IGNORECASE)
+    parts = []
+    type_pattern = r"\b(integer|int|numeric|decimal|real|float|double|text|varchar|char|date|datetime|timestamp|boolean|bool)\b"
+    type_tokens = {
+        "integer", "int", "numeric", "decimal", "real", "float", "double",
+        "text", "varchar", "char", "date", "datetime", "timestamp", "boolean", "bool",
+    }
+    stopwords = {"to", "from", "into", "as", "for", "o", "a", "os", "de", "do", "da", "dos", "das"}
+    for part in (item.strip() for item in columns_text.split(",") if item.strip()):
+        tokens = [token.strip() for token in re.split(r"\s+", part) if token.strip()]
+        tokens = [token for token in tokens if token.lower() not in stopwords]
+        if not tokens:
+            continue
+        if re.search(type_pattern, part, flags=re.IGNORECASE) and len(tokens) > 2:
+            index = 0
+            inferrable_names = {"total", "date", "time", "timestamp", "int", "text", "real", "char"}
+            while index < len(tokens):
+                current = tokens[index]
+                next_token = tokens[index + 1].lower() if index + 1 < len(tokens) else ""
+                if next_token in type_tokens and not (
+                    current.lower() in inferrable_names and next_token in {"date", "datetime", "timestamp"}
+                ):
+                    parts.append(f"{current} {tokens[index + 1]}")
+                    index += 2
+                else:
+                    parts.append(current)
+                    index += 1
+            continue
+        if re.search(type_pattern, part, flags=re.IGNORECASE):
+            parts.append(part)
+            continue
+        if len(tokens) > 1 and all(re.match(r"^[A-Za-z_][\wÀ-ÿ]*$", token) for token in tokens):
+            parts.extend(tokens)
+        else:
+            parts.append(part)
+    return parts
+
+
+def format_create_table(table_name, columns):
+    if not table_name or not columns:
+        return ""
+    seen = set()
+    column_lines = []
+    for column_name, column_type in columns:
+        if column_name in seen:
+            continue
+        seen.add(column_name)
+        column_lines.append(f"    {column_name} {column_type}")
+    if not column_lines:
+        return ""
+    return f"CREATE TABLE {table_name} (\n" + ",\n".join(column_lines) + "\n);"
+
+
+def create_table_from_message(message):
+    message = (message or "").strip()
+    patterns = (
+        r"\b(?:table|tabela)\s+(?:called\s+|named\s+|chamada?\s+|nomeada?\s+)?([A-Za-z_][\w]*)\s+(?:with|containing|including|com)\s+(.+)$",
+        r"\b(?:create|make|build|generate|criar|crie|gerar|gere)\b.*?\b(?:table|tabela)\b\s+([A-Za-z_][\w]*)\s+(?:with|containing|including|com)\s+(.+)$",
+    )
+    for pattern in patterns:
+        match = re.search(pattern, message, flags=re.IGNORECASE)
+        if not match:
+            continue
+        table_name = normalize_identifier(match.group(1))
+        columns = [
+            parsed
+            for parsed in (parse_column_definition(column) for column in split_column_list(match.group(2)))
+            if parsed
+        ]
+        return format_create_table(table_name, columns)
+    return ""
+
+
+def parse_create_table_schema(schema):
+    schema = (schema or "").strip()
+    match = re.match(
+        r"^\s*(?:CREATE\s+TABLE\s+)?([A-Za-z_][\w]*)\s*\((.*?)\)\s*;?\s*$",
+        schema,
+        flags=re.IGNORECASE | re.DOTALL,
+    )
+    if not match:
+        return "", []
+    table_name = normalize_identifier(match.group(1))
+    columns = [
+        parsed
+        for parsed in (parse_column_definition(column) for column in split_column_list(match.group(2)))
+        if parsed
+    ]
+    return table_name, columns
+
+
+def create_table_from_schema(schema):
+    table_name, columns = parse_create_table_schema(schema)
+    return format_create_table(table_name, columns)
+
+
+def extract_create_table_statement(text):
+    cleaned = extract_sql_candidate(text)
+    match = re.search(
+        r"\bCREATE\s+TABLE\s+[A-Za-z_][\w]*\s*\(.*?\)\s*;?",
+        cleaned,
+        flags=re.IGNORECASE | re.DOTALL,
+    )
+    return clean_generation(match.group(0)) if match else ""
+
+
+def last_create_table_from_history(chat_history):
+    for item in reversed(list(chat_history or [])):
+        if not isinstance(item, dict) or item.get("role") != "assistant":
+            continue
+        statement = extract_create_table_statement(item.get("content", ""))
+        if statement:
+            return statement
+    return ""
+
+
+def extract_added_columns(message):
+    message = (message or "").strip()
+    patterns = (
+        r":\s*(.+)$",
+        r"\b(?:add|include|with|adicionar|adicione|adicionando|inclua|incluir|acrescente|ter|coloque|colocar)\b\s+(?:um\s+|uma\s+|a\s+|an\s+)?(?:novo\s+|nova\s+|new\s+)?(?:column|field|element|coluna|campo|elemento|item)?\s*(.+)$",
+    )
+    for pattern in patterns:
+        match = re.search(pattern, message, flags=re.IGNORECASE)
+        if not match:
+            continue
+        columns = [
+            parsed
+            for parsed in (parse_column_definition(column) for column in split_column_list(match.group(1)))
+            if parsed
+        ]
+        if columns:
+            return columns
+    return []
+
+
+def extract_removed_columns(message):
+    message = (message or "").strip()
+    patterns = (
+        r"\b(?:remove|delete|drop|remova|remover|deletar|exclua|excluir)\b\s+(?:a\s+|o\s+|the\s+)?(?:column|field|element|coluna|campo|elemento|item)?\s*(.+)$",
+    )
+    for pattern in patterns:
+        match = re.search(pattern, message, flags=re.IGNORECASE)
+        if not match:
+            continue
+        columns = [normalize_identifier(column) for column in split_column_list(match.group(1))]
+        columns = [column for column in columns if column]
+        if columns:
+            return columns
+    return []
+
+
+def extract_renamed_columns(message):
+    pattern = (
+        r"\b(?:rename|edit|change|renomeie|renomear|renomeia|altere|mude)\s+"
+        r"(\w+)\s+(?:to|para|as|como|por)\s+(\w+)"
+    )
+    matches = re.findall(pattern, message or "", flags=re.IGNORECASE)
+    troca_matches = re.findall(r"\btroca\b\s+(\w+)\s+\bpor\b\s+(\w+)", message or "", flags=re.IGNORECASE)
+    return [
+        (normalize_identifier(old), normalize_identifier(new))
+        for old, new in [*matches, *troca_matches]
+        if normalize_identifier(old) and normalize_identifier(new)
+    ]
+
+
+def parse_compound_edit(message):
+    segment_pattern = (
+        r"\s+(?:and|e)\s+"
+        r"(?=\b(?:add|include|remove|delete|drop|rename|edit|change|"
+        r"adicione|adicionar|inclua|acrescente|remova|remover|deletar|"
+        r"exclua|renomeie|renomear|renomeia|altere|mude|troca|trocar)\b)"
+    )
+    segments = re.split(segment_pattern, message or "", flags=re.IGNORECASE)
+    added, removed, renamed = [], [], []
+    for seg in segments:
+        seg = seg.strip()
+        if not seg:
+            continue
+        if is_rename_intent(seg):
+            renamed.extend(extract_renamed_columns(seg))
+        elif re.search(r"\b(remove|delete|drop|remova|remover|deletar|exclua|excluir)\b", seg, flags=re.IGNORECASE):
+            removed.extend(extract_removed_columns(seg))
+        else:
+            cols = extract_added_columns(seg)
+            if cols:
+                added.extend(cols)
+    return added, removed, renamed
+
+
+def edit_create_table_from_message(message, chat_history, active_schema):
+    if not is_table_edit_intent(message) and not is_rename_intent(message):
+        return ""
+    base_sql = last_create_table_from_history(chat_history) or create_table_from_schema(active_schema)
+    table_name, existing_columns = parse_create_table_schema(base_sql)
+    if not table_name:
+        return ""
+    added_columns, removed_columns_list, renamed_columns = parse_compound_edit(message)
+    removed_set = set(extract_removed_columns(message)) | {r for r in removed_columns_list}
+    if not added_columns and not removed_set and not renamed_columns:
+        return ""
+    rename_map = dict(renamed_columns)
+    kept_columns = [
+        (rename_map.get(col_name, col_name), col_type)
+        for col_name, col_type in existing_columns
+        if col_name not in removed_set
+    ]
+    return format_create_table(table_name, [*kept_columns, *added_columns])
+
+
+def create_table_from_suggestion(suggestion):
+    if not suggestion:
+        return ""
+    if isinstance(suggestion, dict):
+        table_name = suggestion.get("table_name")
+        columns = [
+            (column.get("name"), column.get("type", "TEXT"))
+            for column in suggestion.get("columns", [])
+            if isinstance(column, dict)
+        ]
+    else:
+        table_name = getattr(suggestion, "table_name", "")
+        columns = getattr(suggestion, "columns", ())
+    parsed = []
+    for name, column_type in columns:
+        identifier = normalize_identifier(name)
+        if identifier:
+            parsed.append((identifier, (column_type or "TEXT").upper()))
+    return format_create_table(normalize_identifier(table_name), parsed)
+

tests/test_chatbot_behavior.py

@@ -493,7 +493,7 @@ def test_off_topic_message_returns_fallback(monkeypatch):
     result = app.generate_response("me conte uma piada", [], "", None, None)
 
     assert sql_output(result) == ""
-    assert "schema" in assistant_text(result).lower() or "tabela" in assistant_text(result).lower()
+    assert "load the fine-tuned model" in assistant_text(result).lower()
 
 
 def test_greeting_returns_fallback(monkeypatch):
@@ -670,3 +670,23 @@ def test_build_generation_prompt_no_history_no_context():
     assert "comida" in prompt
     assert "liste todos" in prompt or "liste" in prompt
 
+
+# ---------------------------------------------------------------------------
+# Regression: ISSUE-001 — "troca X por Y" rename pattern
+# ---------------------------------------------------------------------------
+
+def test_troca_x_por_y_rename(monkeypatch):
+    monkeypatch.setattr(app, "_run_generation", lambda *a, **k: pytest.fail("model should not run"))
+    base = app.generate_response(
+        "crie tabela comida com id nome sabor peso tipo", [], "", None, None
+    )
+    result = app.generate_response(
+        "troca tipo por medida", base[0], base[2], None, None
+    )
+    schema = sql_output(result)
+    assert "medida TEXT" in schema
+    assert "tipo TEXT" not in schema
+    assert "id INTEGER" in schema
+    assert "nome TEXT" in schema
+    assert "sabor TEXT" in schema
+    assert "peso NUMERIC" in schema

tests/test_chatbot_core.py

@@ -0,0 +1,105 @@
+import types
+
+import app
+from chat_state import ConversationState, SchemaSuggestion
+from intent import (
+    CREATE_TABLE_CONFIRM,
+    EDIT_TABLE,
+    SCHEMA_SUGGESTION,
+    SMALLTALK,
+    SQL_QUERY,
+    classify_intent,
+)
+
+
+def test_conversation_state_roundtrip_dict():
+    suggestion = SchemaSuggestion(
+        table_name="zoologico",
+        columns=(("id", "INTEGER"), ("nome", "TEXT")),
+        rationale="base",
+    )
+    state = ConversationState(active_schema="", pending_schema_suggestion=suggestion, last_intent=SCHEMA_SUGGESTION)
+
+    restored = ConversationState.from_value(state.to_dict())
+
+    pending = restored.pending_schema_suggestion
+    assert pending is not None
+    assert pending.table_name == "zoologico"
+    assert pending.columns == (("id", "INTEGER"), ("nome", "TEXT"))
+    assert restored.last_intent == SCHEMA_SUGGESTION
+
+
+def test_intent_smalltalk_with_active_schema_is_not_sql():
+    state = ConversationState(active_schema="CREATE TABLE employees (id INTEGER)")
+
+    result = classify_intent("como voce esta hoje?", state)
+
+    assert result.intent == SMALLTALK
+
+
+def test_intent_schema_suggestion_and_confirmation():
+    state = ConversationState()
+
+    suggestion = classify_intent("preciso de uma tabela sobre zoologico", state)
+    pending = state.with_pending_schema(
+        SchemaSuggestion(table_name="zoologico", columns=(("id", "INTEGER"), ("nome", "TEXT")))
+    )
+    confirmation = classify_intent("gera", pending)
+
+    assert suggestion.intent == SCHEMA_SUGGESTION
+    assert confirmation.intent == CREATE_TABLE_CONFIRM
+
+
+def test_intent_edit_and_sql_query():
+    state = ConversationState(active_schema="CREATE TABLE zoologico (id INTEGER, cidade TEXT)")
+
+    edit = classify_intent("troca cidade por municipio", state)
+    query = classify_intent("liste zoologicos por municipio", state)
+
+    assert edit.intent == EDIT_TABLE
+    assert query.intent == SQL_QUERY
+
+
+def test_zoologico_transcript_with_mocked_model(monkeypatch):
+    app._model = types.SimpleNamespace(generation_config=types.SimpleNamespace(eos_token_id=0))
+    app._tokenizer = types.SimpleNamespace(eos_token_id=0, pad_token_id=0)
+    app._current_model_id = app.FINE_TUNED_MODEL_ID
+
+    def fake_generate(prompt, generation_kind):
+        if generation_kind == app.model_core.CHAT_GENERATION:
+            return "Oi, posso ajudar com conversa comum ou SQL.", 1
+        if generation_kind == app.model_core.SCHEMA_GENERATION:
+            return (
+                '{"table_name":"zoologico","columns":['
+                '{"name":"id","type":"INTEGER"},'
+                '{"name":"nome","type":"TEXT"},'
+                '{"name":"cidade","type":"TEXT"},'
+                '{"name":"capacidade","type":"INTEGER"}],'
+                '"rationale":"Tabela inicial para zoologicos."}',
+                1,
+            )
+        return "SELECT * FROM zoologico WHERE cidade = 'Sao Paulo';", 1
+
+    monkeypatch.setattr(app, "_generate_model_text", fake_generate)
+
+    r1 = app.generate_response("oi", [], "", app.FINE_TUNED_MODEL_KEY, None)
+    assert app.EMPTY_CHAT_OUTPUT == ""
+    assert r1[4] == ""
+    assert "Oi" in r1[0][-1]["content"]
+
+    r2 = app.generate_response("preciso de uma tabela sobre zoologico", r1[0], r1[2], app.FINE_TUNED_MODEL_KEY, None, r1[8])
+    assert r2[4] == ""
+    assert r2[8]["pending_schema_suggestion"] is not None
+    assert r2[8]["pending_schema_suggestion"]["table_name"] == "zoologico"
+
+    r3 = app.generate_response("gera", r2[0], r2[2], app.FINE_TUNED_MODEL_KEY, None, r2[8])
+    assert "CREATE TABLE zoologico" in r3[4]
+    assert "CREATE TABLE zoologico" in r3[2]
+    assert r3[8]["pending_schema_suggestion"] is None
+
+    r4 = app.generate_response("troca capacidade por numero_animais", r3[0], r3[2], app.FINE_TUNED_MODEL_KEY, None, r3[8])
+    assert "numero_animais INTEGER" in r4[4]
+    assert "capacidade" not in r4[4]
+
+    r5 = app.generate_response("liste zoologicos de Sao Paulo", r4[0], r4[2], app.FINE_TUNED_MODEL_KEY, None, r4[8])
+    assert "SELECT * FROM zoologico" in r5[4]