refactor: model scope for sql query only

.gitignore

@@ -37,6 +37,10 @@ Thumbs.db
 logs/
 *.log
 
+# Graphify local artifacts
+graphify-out/
+.graphifyignore
+
 # Large local model artifacts should stay on the Hub, not in this Space repo
 *.safetensors
 *.bin
@@ -48,7 +52,10 @@ logs/
 # Local agent/workspace notes
 /AGENTS.md
 /CLAUDE.md
-/PROGRESS.md
+/HANDOFF.md
+/FLOWS.md
+/ERRORS.md
+/ROADMAP.md
 .claude
 .gstack/
 docs

README.md

@@ -17,16 +17,16 @@ Generates SQL queries from a table schema and a natural-language question using
 
 ## What the App Does
 
-Transforms simple table descriptions and questions into SQL using the fine-tuned Phi-3 Mini model. The base model is shown as offline evaluation evidence instead of a second live CPU-loaded model.
+Transforms explicit table schemas and schema-edit requests deterministically, then uses the fine-tuned Phi-3 Mini model only for SQL query generation. The base model is shown as offline evaluation evidence instead of a second live CPU-loaded model.
 
 ## How to Use
 
 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. Chat normally or enter/edit the **SQL table schema**.
+2. Select, create, or edit the **SQL table schema**.
    - You can use the presets: `employees`, `orders`, `students`, `products`, `sales`.
-   - You can also write your own schema manually.
+   - You can also ask for explicit schema operations, such as `create table products with id name price` or `add stock`.
 3. Enter the question in the chat input.
 4. Click **Send**.
 5. Review the result in `gr.Code(language="sql")`.
@@ -50,8 +50,9 @@ 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, chat, and inspect SQL artifacts.
-- Intent routing that keeps normal conversation separate from SQL generation.
+- Gradio UI with a step-by-step flow: load the fine-tuned model, define schema context, and inspect SQL artifacts.
+- Intent routing with 5 supported routes: `CREATE_TABLE`, `EDIT_TABLE`, `SQL_QUERY`, `SMALLTALK`, `UNKNOWN`.
+- Model calls only for `SQL_QUERY`; smalltalk and unknown messages use a static fallback.
 - Lazy loading to reduce startup cost.
 - Preserved Phi-3 patches for local/Spaces compatibility.
 - Schema presets without blocking manual input.
@@ -66,7 +67,7 @@ The normal pytest suite does not load the 3.8B model. To manually verify the rea
 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.
+The probe prints JSON with pass/fail checks for static fallback, deterministic CREATE TABLE, deterministic schema edit, SQL query generation, and smalltalk while a schema is active.
 
 ## Run Locally
 

app.py

@@ -18,29 +18,18 @@ 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"
 
-BASE_MODEL_KEY = "base"
 FINE_TUNED_MODEL_KEY = "fine_tuned"
 DEFAULT_MODEL_KEY = FINE_TUNED_MODEL_KEY
+FALLBACK_RESPONSE = (
+    "Select a schema and ask a SQL question, "
+    "or ask to create or edit a table. "
+    "Example: 'what is the most expensive product?' or "
+    "'create table products with id name price'."
+)
 
 MODEL_CATALOG = {
-    BASE_MODEL_KEY: {
-        "label": "Base Phi-3 Mini",
-        "short_label": "Base",
-        "tag": "Base",
-        "title": "Phi-3 Mini base",
-        "model_id": BASE_MODEL_ID,
-        "exact_match": "2.0%",
-        "trust_remote_code": False,
-        "ready_text": "Base model ready",
-        "metadata": (
-            "Model: microsoft/Phi-3-mini-4k-instruct\n"
-            "Role: unfine-tuned baseline\n"
-            "Metric: 2.0% exact match on the comparison setup"
-        ),
-    },
     FINE_TUNED_MODEL_KEY: {
         "label": "Fine-tuned QLoRA model",
         "short_label": "Fine-tuned",
@@ -400,12 +389,7 @@ def normalize_text(value):
 
 
 def safe_chat_fallback(_message=""):
-    return (
-        "Selecione um schema e faça uma pergunta SQL, "
-        "ou peça para criar ou editar uma tabela. "
-        "Exemplo: 'crie tabela produtos com id nome preco' "
-        "ou 'qual o produto mais caro?'."
-    )
+    return FALLBACK_RESPONSE
 
 
 def clean_generation(text):
@@ -459,11 +443,11 @@ def render_header():
     <section class="top-panel">
       <div>
         <h1>Phi-3 Mini SQL Chatbot</h1>
-        <p>Conversational SQL assistant powered by a fine-tuned Phi-3 Mini model</p>
+        <p>SQL generation demo powered by a fine-tuned Phi-3 Mini model</p>
       </div>
       <div class="top-badges">
-        <span class="badge badge-green">Natural chat + SQL</span>
-        <span class="badge badge-cream">Context-aware schema</span>
+        <span class="badge badge-green">SQL_QUERY only</span>
+        <span class="badge badge-cream">Deterministic schema edits</span>
         <span class="badge badge-light">CPU lazy load</span>
       </div>
     </section>
@@ -534,10 +518,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>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>
+      <div class="stat-card"><strong>SQL</strong><span>model-generated SELECT queries</span></div>
+      <div class="stat-card"><strong>Create</strong><span>deterministic CREATE TABLE parser</span></div>
+      <div class="stat-card"><strong>Edit</strong><span>deterministic schema updates</span></div>
+      <div class="stat-card"><strong>Fallback</strong><span>static non-SQL response</span></div>
     </section>
     """
 
@@ -935,21 +919,6 @@ def render_message(message="", kind="error"):
     return f'<div class="message-box {class_name}">{html.escape(str(message))}</div>'
 
 
-def select_model(model_key, loaded_key):
-    selected_key = model_key if model_key in MODEL_CATALOG else DEFAULT_MODEL_KEY
-    query_is_active = loaded_key == selected_key
-    return (
-        selected_key,
-        render_model_card(BASE_MODEL_KEY, selected_key),
-        render_model_card(FINE_TUNED_MODEL_KEY, selected_key),
-        render_status(selected_key, loaded_key),
-        model_metadata(selected_key),
-        *query_control_updates(query_is_active),
-        gr.update(interactive=False),
-        render_message(),
-    )
-
-
 def load_selected_model(selected_key=FINE_TUNED_MODEL_KEY):
     selected_key = FINE_TUNED_MODEL_KEY
     model_def = model_by_key(selected_key)
@@ -966,7 +935,6 @@ def load_selected_model(selected_key=FINE_TUNED_MODEL_KEY):
         *query_control_updates(False),
         "",
         EMPTY_VALIDATOR,
-        gr.update(value=None),
         render_message(),
     )
     started = time.time()
@@ -996,7 +964,6 @@ def load_selected_model(selected_key=FINE_TUNED_MODEL_KEY):
             *query_control_updates(False),
             "",
             EMPTY_VALIDATOR,
-            gr.update(value=None),
             render_message(error),
         )
         return
@@ -1011,7 +978,6 @@ def load_selected_model(selected_key=FINE_TUNED_MODEL_KEY):
         *query_control_updates(True),
         "",
         EMPTY_VALIDATOR,
-        gr.update(value=None),
         render_message(f"Loaded {model_def['model_id']} in {elapsed}s.", kind="ok"),
     )
 
@@ -1030,62 +996,6 @@ def trim_chat_history(chat_history, max_exchanges=10):
     return history[-max_exchanges * 2 :]
 
 
-def comparison_updates(saved_state, current_sql, loaded_key):
-    if not saved_state or not (current_sql or "").strip():
-        return gr.update(visible=False), "", "", "", ""
-
-    loaded_def = model_by_key(loaded_key) if loaded_key else model_by_key(DEFAULT_MODEL_KEY)
-    return (
-        gr.update(visible=True),
-        render_compare_label("Saved", saved_state.get("model_label", "Unknown"), saved_state.get("match", "")),
-        saved_state.get("sql", ""),
-        render_compare_label("Current", loaded_def["short_label"], loaded_def["exact_match"]),
-        current_sql or "",
-    )
-
-
-def render_compare_label(prefix, model_label, metric):
-    metric_html = f"<strong>{html.escape(metric)} match</strong>" if metric else ""
-    return (
-        f'<div class="compare-head"><span>{html.escape(prefix)} - '
-        f"{html.escape(model_label)}</span>{metric_html}</div>"
-    )
-
-
-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(
         [
@@ -1109,7 +1019,7 @@ def _response_tuple(
 ):
     state = chat_core.ConversationState.from_value(state)
     if sql_text and "CREATE TABLE" in sql_text.upper():
-        state = state.with_active_schema(sql_text).clear_pending_schema()
+        state = state.with_active_schema(sql_text)
     new_history = _append_chat_turn(chat_history, message, assistant_content)
     return (
         new_history,
@@ -1118,7 +1028,6 @@ def _response_tuple(
         message,
         sql_text,
         validator,
-        gr.update(value=None),
         render_message(status_message, kind=status_kind),
         state.to_dict(),
     )
@@ -1129,7 +1038,6 @@ def deterministic_response(
     message,
     active_schema,
     loaded_key,
-    saved_state,
     assistant_content,
     status_message,
     *,
@@ -1153,7 +1061,7 @@ def deterministic_response(
 
 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."
+        return False, "Load the fine-tuned model before 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."
@@ -1195,12 +1103,6 @@ def _generate_model_text(prompt, generation_kind=model_core.SQL_GENERATION):
     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,
@@ -1209,13 +1111,12 @@ def _empty_generation_response(chat_history, message, state, status_message, *,
         "",
         "",
         EMPTY_VALIDATOR,
-        gr.update(value=None),
         render_message(status_message, kind=status_kind),
         state.to_dict(),
     )
 
 
-def generate_response(message, chat_history, active_schema, loaded_key, saved_state=None, conversation_state=None):
+def generate_response(message, chat_history, active_schema, loaded_key, conversation_state=None):
     message = (message or "").strip()
     chat_history = list(chat_history or [])
     state = chat_core.ConversationState.from_value(conversation_state, active_schema=(active_schema or ""))
@@ -1227,7 +1128,6 @@ def generate_response(message, chat_history, active_schema, loaded_key, saved_st
             "",
             "",
             EMPTY_VALIDATOR,
-            gr.update(value=None),
             render_message("Type a message before sending."),
             state.to_dict(),
         )
@@ -1241,20 +1141,6 @@ def generate_response(message, chat_history, active_schema, loaded_key, saved_st
     )
 
     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```"
@@ -1274,32 +1160,8 @@ def generate_response(message, chat_history, active_schema, loaded_key, saved_st
             "I need an existing CREATE TABLE in the chat or an active schema before editing columns.",
         )
 
-    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 _response_tuple(
-                chat_history,
-                message,
-                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(
@@ -1315,72 +1177,17 @@ def generate_response(message, chat_history, active_schema, loaded_key, saved_st
             chat_history,
             message,
             state,
-            "CREATE TABLE needs a table name and columns, or a loaded model to propose them.",
+            "CREATE TABLE needs a table name and columns.",
         )
 
-    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 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}",
-            )
+    if intent_result.intent in {intent_core.SMALLTALK, intent_core.UNKNOWN}:
+        return _response_tuple(
+            chat_history,
+            message,
+            state,
+            FALLBACK_RESPONSE,
+            "Static fallback - no model call.",
+        )
 
     ready, error = _model_ready(loaded_key)
     if not ready:
@@ -1458,7 +1265,6 @@ def sync_on_load():
                 *query_control_updates(True),
                 "",
                 EMPTY_VALIDATOR,
-                gr.update(value=None),
                 render_message(f"Model already loaded: {_current_model_id}", kind="ok"),
             )
     return (
@@ -1470,7 +1276,6 @@ def sync_on_load():
         *query_control_updates(False),
         "",
         EMPTY_VALIDATOR,
-        gr.update(value=None),
         render_message(),
     )
 
@@ -1481,7 +1286,6 @@ CSS = """
 /* Prevent Gradio dark theme from overriding text in light-bg components */
 [class*="badge"],
 [class*="validator-"],
-[class*="compare-head"],
 [class*="model-tag"],
 [class*="stat-card"] {
   color: inherit !important;
@@ -1608,7 +1412,6 @@ CSS = """
 }
 
 .model-grid,
-.compare-grid,
 .stats-row {
   display: grid;
   gap: 12px;
@@ -1616,7 +1419,6 @@ CSS = """
 }
 
 .model-grid > div,
-.compare-grid > div,
 .stats-row > div {
   min-width: 0;
 }
@@ -1756,8 +1558,7 @@ CSS = """
 }
 
 #load-button,
-#generate-button,
-#save-button {
+#generate-button {
   width: 100% !important;
 }
 
@@ -1790,19 +1591,6 @@ CSS = """
   color: var(--bg-base) !important;
 }
 
-#save-button button {
-  background: transparent !important;
-  border: 0.5px solid var(--border-hi) !important;
-  color: var(--text-primary) !important;
-  min-height: 38px !important;
-  width: 100% !important;
-}
-
-#save-button button:hover {
-  border-color: var(--text-primary) !important;
-}
-
-#save-button button:disabled,
 #generate-button button:disabled {
   opacity: 0.4 !important;
 }
@@ -2079,10 +1867,7 @@ textarea {
 
 .output-shell .cm-editor,
 .output-shell pre,
-.output-shell code,
-.compare-card .cm-editor,
-.compare-card pre,
-.compare-card code {
+.output-shell code {
   border: 0 !important;
   font-size: 12px !important;
   font-weight: 400 !important;
@@ -2104,45 +1889,6 @@ textarea {
   color: var(--teal);
 }
 
-.comparison-panel {
-  margin-top: 28px;
-}
-
-.compare-card {
-  background: var(--bg-surface);
-  border: 0.5px solid var(--border);
-  border-radius: 6px;
-  overflow: hidden;
-}
-
-.compare-card.current {
-  border-color: rgba(29, 158, 117, 0.45);
-}
-
-.compare-head {
-  align-items: center;
-  background: var(--amber-soft);
-  color: var(--amber-text) !important;
-  display: flex;
-  font-size: 11px;
-  font-weight: 500;
-  gap: 16px;
-  justify-content: space-between;
-  min-height: 34px;
-  padding: 0 12px;
-}
-
-.compare-card.current .compare-head,
-.current-compare-head .compare-head {
-  background: var(--teal-soft);
-  color: var(--teal-text) !important;
-}
-
-.compare-head strong {
-  color: inherit;
-  font-weight: 500;
-}
-
 .loading-overlay {
   align-items: center;
   background: rgba(0, 0, 0, 0.6);
@@ -2210,7 +1956,6 @@ textarea {
 @media (max-width: 860px) {
   .top-panel,
   .model-grid,
-  .compare-grid,
   .evidence-grid {
     grid-template-columns: 1fr;
   }
@@ -2233,7 +1978,6 @@ with gr.Blocks(title="Phi-3 Mini SQL Chatbot") as demo:
     loaded_key_state = 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"]):
@@ -2335,7 +2079,6 @@ with gr.Blocks(title="Phi-3 Mini SQL Chatbot") as demo:
             send_button,
             sql_output,
             validator_output,
-            generation_meta_state,
             error_output,
         ],
         js=LOAD_SCROLL_JS,
@@ -2356,18 +2099,17 @@ with gr.Blocks(title="Phi-3 Mini SQL Chatbot") as demo:
         last_user_message,
         sql_output,
         validator_output,
-        generation_meta_state,
         error_output,
         conversation_state,
     ]
     send_button.click(
         generate_response,
-        inputs=[message_input, chatbot, active_schema, loaded_key_state, generation_meta_state, conversation_state],
+        inputs=[message_input, chatbot, active_schema, loaded_key_state, conversation_state],
         outputs=chat_generation_outputs,
     )
     message_input.submit(
         generate_response,
-        inputs=[message_input, chatbot, active_schema, loaded_key_state, generation_meta_state, conversation_state],
+        inputs=[message_input, chatbot, active_schema, loaded_key_state, conversation_state],
         outputs=chat_generation_outputs,
     )
     demo.load(
@@ -2388,7 +2130,6 @@ with gr.Blocks(title="Phi-3 Mini SQL Chatbot") as demo:
             send_button,
             sql_output,
             validator_output,
-            generation_meta_state,
             error_output,
         ],
     )

chat_state.py

@@ -1,51 +1,10 @@
 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
@@ -56,52 +15,24 @@ class ConversationState:
             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 {}),
         )
 
@@ -112,13 +43,10 @@ class ConversationState:
         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()
-
+    return ConversationState(active_schema=(active_schema or "").strip()).to_dict()

intent.py

@@ -5,12 +5,9 @@ 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"
 
 
@@ -21,29 +18,17 @@ class IntentResult:
     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",
+        "tudo bem", "tudo bom", "tudo", "tchau", "xau", "ate mais", "ate logo",
+        "de nada", "por nada", "imagina",
         "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",
@@ -56,60 +41,33 @@ def _is_smalltalk(message):
         "conte uma piada",
         "vamos conversar",
         "obrigado",
+        "tudo bem",
+        "tudo bom",
     )
     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")
+        return IntentResult(
+            EDIT_TABLE,
+            0.9 if (edited_table or _has_active_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

@@ -1,41 +1,12 @@
-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"
@@ -63,28 +34,6 @@ def _history_context(chat_history, max_exchanges=3):
     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(
@@ -119,14 +68,3 @@ def format_generation_result(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

@@ -20,7 +20,6 @@ def _scenario(name, message, history, active_schema, state):
         history,
         active_schema,
         app.FINE_TUNED_MODEL_KEY,
-        None,
         state,
     )
     return {
@@ -28,9 +27,9 @@ def _scenario(name, message, history, active_schema, state):
         "message": message,
         "assistant": _assistant_text(result),
         "sql": result[4],
-        "status": result[7],
+        "status": result[6],
         "active_schema": result[2],
-        "state": result[8],
+        "state": result[7],
         "history": result[0],
     }
 
@@ -45,19 +44,14 @@ def _grade(records):
     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.",
+        "name": "smalltalk_is_static_fallback",
+        "pass": app.FALLBACK_RESPONSE in by_name["greeting"]["assistant"] and not by_name["greeting"]["sql"],
+        "detail": "Greeting should use the static fallback 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.",
+        "name": "create_table_is_deterministic",
+        "pass": "CREATE TABLE ZOOLOGICO" in (by_name["create_schema"]["sql"] or "").upper(),
+        "detail": "Explicit CREATE TABLE request should not need model generation.",
     })
     checks.append({
         "name": "edit_updates_schema",
@@ -71,8 +65,8 @@ def _grade(records):
     })
     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.",
+        "pass": app.FALLBACK_RESPONSE in by_name["smalltalk_with_schema"]["assistant"] and not by_name["smalltalk_with_schema"]["sql"],
+        "detail": "Smalltalk with active schema should still use static fallback.",
     })
     return checks
 
@@ -87,8 +81,7 @@ def main():
 
     for name, message in [
         ("greeting", "oi"),
-        ("schema_request", "preciso de uma tabela sobre zoologico"),
-        ("confirm_generate", "gera"),
+        ("create_schema", "crie tabela zoologico com id nome cidade capacidade"),
         ("edit_schema", "troca capacidade por numero_animais"),
         ("query_schema", "liste zoologicos de Sao Paulo"),
         ("smalltalk_with_schema", "como voce esta hoje?"),
@@ -112,4 +105,3 @@ def main():
 
 if __name__ == "__main__":
     raise SystemExit(main())
-

sql_tools.py

@@ -118,32 +118,37 @@ def validate_sql(sql_text):
     return '<span class="validator-badge validator-ok">Valid SQL</span>'
 
 
+# Verb stems for create-table intent — keep in sync with create_table_from_message below.
+_CREATE_VERBS = (
+    r"create|make|build|generate"
+    r"|criar|crie|cria|criando"
+    r"|gerar|gere|gera|gerando"
+    r"|faz|faca|fa\u00e7a|fazendo"
+    r"|monta|montar|monte"
+    r"|construa|construir|constroi"
+    r"|elabore|elaborar|elabora"
+)
+
+
 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)
+        re.search(rf"\b({_CREATE_VERBS})\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,
-        )
-    )
+    return bool(extract_renamed_columns(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|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"
+    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|exclui|novo|nova|troca|trocar|coloque|colocar|coloca|insira|insere|bota|tira|retire|retira|apaga|apague)\b"
+    direct_add_terms = r"\b(add|include|adicione|adicionar|adicionando|inclua|incluir|acrescente|coloque|colocar|coloca|acrescenta|insere|inserir|insira|bota|botar|bote)\b"
+    direct_remove_terms = r"\b(remove|delete|drop|remova|remover|deletar|exclua|excluir|exclui|tira|tirar|tire|retira|retirar|retire|apaga|apagar|apague)\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"}
+    sql_aggregation_terms = {"up", "sum", "total", "count", "average", "avg", "max", "min", "by", "soma", "media", "contagem", "maximo", "minimo"}
     add_match = re.search(direct_add_terms, message)
     if add_match:
         after_add = message[add_match.start() + len(add_match.group()) :].strip()
@@ -278,8 +283,8 @@ def format_create_table(table_name, columns):
 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+(.+)$",
+        r"\b(?:table|tabela)\s+(?:called\s+|named\s+|chamada?\s+|nomeada?\s+)?([A-Za-z_][\w]*)\s+(?:with|containing|including|com|tendo|contendo)\s+(.+)$",
+        rf"\b(?:{_CREATE_VERBS})\b.*?\b(?:table|tabela)\b\s+([A-Za-z_][\w]*)\s+(?:with|containing|including|com|tendo|contendo)\s+(.+)$",
     )
     for pattern in patterns:
         match = re.search(pattern, message, flags=re.IGNORECASE)
@@ -361,7 +366,7 @@ def extract_added_columns(message):
 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*(.+)$",
+        r"\b(?:remove|delete|drop|remova|remover|deletar|exclua|excluir|exclui|tira|tirar|tire|retira|retirar|retire|apaga|apagar|apague)\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)
@@ -376,15 +381,20 @@ def extract_removed_columns(message):
 
 def extract_renamed_columns(message):
     pattern = (
-        r"\b(?:rename|edit|change|renomeie|renomear|renomeia|altere|mude)\s+"
+        r"\b(?:rename|edit|change|renomeie|renomear|renomeia|altere|alterar|altera|mude|mudar|muda|edita|editar)\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)
+    invalid_old_names = {"ela", "ele", "isso", "isto", "essa", "esse", "this", "it"}
+    invalid_new_names = {"ter", "have", "having", "tambem", "tambem"}
     return [
         (normalize_identifier(old), normalize_identifier(new))
         for old, new in [*matches, *troca_matches]
-        if normalize_identifier(old) and normalize_identifier(new)
+        if normalize_identifier(old)
+        and normalize_identifier(new)
+        and normalize_identifier(old) not in invalid_old_names
+        and normalize_identifier(new) not in invalid_new_names
     ]
 
 
@@ -392,8 +402,12 @@ 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)"
+        r"adicione|adicionar|adicionando|inclua|incluir|acrescente|"
+        r"coloca|coloque|bota|insira|insere|"
+        r"remova|remover|deletar|exclua|excluir|exclui|"
+        r"tira|tirar|tire|retira|retire|apaga|apague|"
+        r"renomeie|renomear|renomeia|altere|alterar|altera|"
+        r"mude|mudar|muda|edita|editar|troca|trocar)\b)"
     )
     segments = re.split(segment_pattern, message or "", flags=re.IGNORECASE)
     added, removed, renamed = [], [], []
@@ -451,4 +465,3 @@ def create_table_from_suggestion(suggestion):
         if identifier:
             parsed.append((identifier, (column_type or "TEXT").upper()))
     return format_create_table(normalize_identifier(table_name), parsed)
-

tests/e2e_flow_test.py

@@ -17,7 +17,7 @@ def sql_out(result):
     return result[4]
 
 def status(result):
-    return result[7]
+    return result[6]
 
 def reset_model_state():
     app._model = None
@@ -247,4 +247,4 @@ if __name__ == "__main__":
         print("Model not loaded. Call app.load_model(app.FINE_TUNED_MODEL_ID) then re-run.")
         print("From python: python -c \"import app; app.load_model(app.FINE_TUNED_MODEL_ID); exec(open('tests/e2e_flow_test.py').read())\"")
     else:
-        run_all()
+        run_all()

tests/test_chatbot_behavior.py

@@ -24,7 +24,7 @@ def sql_output(result):
 
 
 def status_html(result):
-    return result[7]
+    return result[6]
 
 
 @pytest.fixture(autouse=True)
@@ -436,7 +436,7 @@ def test_model_id_mismatch_returns_inconsistency_error():
         generation_config=types.SimpleNamespace(eos_token_id=0)
     )
     app._tokenizer = object()
-    app._current_model_id = app.BASE_MODEL_ID
+    app._current_model_id = "microsoft/Phi-3-mini-4k-instruct"
 
     try:
         result = app.generate_response(
@@ -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 "load the fine-tuned model" in assistant_text(result).lower()
+    assert app.FALLBACK_RESPONSE in assistant_text(result)
 
 
 def test_greeting_returns_fallback(monkeypatch):
@@ -502,6 +502,7 @@ def test_greeting_returns_fallback(monkeypatch):
     result = app.generate_response("oi", [], "", None, None)
 
     assert sql_output(result) == ""
+    assert app.FALLBACK_RESPONSE in assistant_text(result)
 
 
 # ---------------------------------------------------------------------------

tests/test_chatbot_core.py

@@ -1,32 +1,22 @@
 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,
-)
+from chat_state import ConversationState
+from intent import CREATE_TABLE, EDIT_TABLE, SMALLTALK, SQL_QUERY, UNKNOWN, classify_intent
 
 
 def test_conversation_state_roundtrip_dict():
-    suggestion = SchemaSuggestion(
-        table_name="zoologico",
-        columns=(("id", "INTEGER"), ("nome", "TEXT")),
-        rationale="base",
+    state = ConversationState(
+        active_schema="CREATE TABLE zoologico (id INTEGER)",
+        last_intent=SQL_QUERY,
+        debug={"intent": SQL_QUERY, "confidence": 0.86, "reason": "sql_query_terms"},
     )
-    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
+    assert restored.active_schema == "CREATE TABLE zoologico (id INTEGER)"
+    assert restored.last_intent == SQL_QUERY
+    assert restored.debug["reason"] == "sql_query_terms"
 
 
 def test_intent_smalltalk_with_active_schema_is_not_sql():
@@ -37,69 +27,66 @@ def test_intent_smalltalk_with_active_schema_is_not_sql():
     assert result.intent == SMALLTALK
 
 
-def test_intent_schema_suggestion_and_confirmation():
-    state = ConversationState()
+def test_schema_request_without_columns_is_unknown_not_model_schema_task():
+    result = classify_intent("preciso de uma tabela sobre zoologico", 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
+    assert result.intent == UNKNOWN
 
 
-def test_intent_edit_and_sql_query():
-    state = ConversationState(active_schema="CREATE TABLE zoologico (id INTEGER, cidade TEXT)")
+def test_intent_create_edit_and_sql_query():
+    empty_state = ConversationState()
+    schema_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)
+    create = classify_intent("crie tabela zoologico com id nome cidade", empty_state)
+    edit = classify_intent("troca cidade por municipio", schema_state)
+    query = classify_intent("liste zoologicos por municipio", schema_state)
 
+    assert create.intent == CREATE_TABLE
     assert edit.intent == EDIT_TABLE
     assert query.intent == SQL_QUERY
 
 
-def test_zoologico_transcript_with_mocked_model(monkeypatch):
+def test_zoologico_transcript_with_mocked_sql_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,
-            )
+        assert generation_kind == app.model_core.SQL_GENERATION
+        assert "CREATE TABLE zoologico" in prompt
         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 == ""
+    r1 = app.generate_response("oi", [], "", app.FINE_TUNED_MODEL_KEY)
     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]
+    assert app.FALLBACK_RESPONSE in r1[0][-1]["content"]
+
+    r2 = app.generate_response(
+        "crie tabela zoologico com id nome cidade capacidade",
+        r1[0],
+        r1[2],
+        app.FINE_TUNED_MODEL_KEY,
+        r1[7],
+    )
+    assert "CREATE TABLE zoologico" in r2[4]
+    assert "CREATE TABLE zoologico" in r2[2]
+
+    r3 = app.generate_response(
+        "troca capacidade por numero_animais",
+        r2[0],
+        r2[2],
+        app.FINE_TUNED_MODEL_KEY,
+        r2[7],
+    )
+    assert "numero_animais TEXT" in r3[4]
+    assert "capacidade" not in r3[4]
+
+    r4 = app.generate_response(
+        "liste zoologicos de Sao Paulo",
+        r3[0],
+        r3[2],
+        app.FINE_TUNED_MODEL_KEY,
+        r3[7],
+    )
+    assert "SELECT * FROM zoologico" in r4[4]