fix: unsupported data mutation routing

README.md

@@ -51,6 +51,7 @@ Reported gain: **+71.5 percentage points** over the base model.
 Known limits:
 
 - The training data is mostly `SELECT`; `INSERT`, `UPDATE`, and `DELETE` are not a reliable model capability.
+- Unsupported DML requests are not generated by the model and must not be disguised as schema edits. For example, `delete species` can remove a schema column, but `delete all animals` returns a static unsupported-scope fallback.
 - PT-BR input is not trained model capability. The app handles selected PT-BR cases through deterministic normalization/templates.
 - Conversational chat and JSON schema proposal are out of scope and use fallback behavior instead of model prompts.
 - Exact match does not prove semantic perfection. It is useful evidence, not a substitute for qualitative review.
@@ -126,7 +127,7 @@ The probe prints JSON with pass/fail checks for static fallback, deterministic C
 set PYTHONPATH=. && pytest tests/test_chatbot_core.py tests/test_chatbot_behavior.py -q
 ```
 
-Current unit suite: **105 tests**. These tests avoid loading the 3.8B model and focus on routing, deterministic tools, prompt construction, model-output rejection, SQL validation, UI schema-context synchronization, and error handling.
+Current unit suite: **127 tests**. These tests avoid loading the 3.8B model and focus on routing, deterministic tools, prompt construction, model-output rejection, SQL validation, UI schema-context synchronization, and error handling.
 
 ## Run Locally
 

app.py

@@ -28,6 +28,10 @@ FALLBACK_RESPONSE = (
     "Example: 'what is the most expensive product?' or "
     "'create table products with id name price'."
 )
+UNSUPPORTED_MUTATION_RESPONSE = (
+    "This demo does not generate INSERT, UPDATE, DELETE, or DROP statements. "
+    "It only supports SELECT/WITH model SQL plus deterministic CREATE TABLE tools."
+)
 SOURCE_FINE_TUNED_MODEL = "Source: fine-tuned model"
 SOURCE_DETERMINISTIC_SQL_TEMPLATE = "Source: deterministic SQL template"
 SOURCE_DETERMINISTIC_SCHEMA_PARSER = "Source: deterministic schema parser"
@@ -1175,6 +1179,14 @@ def generate_response(message, chat_history, active_schema, loaded_key, conversa
                 sql_text=edited_table,
                 validator=sql_core.validate_sql(edited_table),
             )
+        if sql_core.last_create_table_from_history(chat_history) or sql_core.create_table_from_schema(state.active_schema):
+            return _empty_generation_response(
+                chat_history,
+                message,
+                state,
+                "No matching schema column was changed.",
+                source_label=SOURCE_DETERMINISTIC_SCHEMA_PARSER,
+            )
         return _empty_generation_response(
             chat_history,
             message,
@@ -1204,6 +1216,17 @@ def generate_response(message, chat_history, active_schema, loaded_key, conversa
             source_label=SOURCE_DETERMINISTIC_SCHEMA_PARSER,
         )
 
+    if intent_result.intent == intent_core.UNKNOWN and intent_result.reason == "unsupported_data_mutation":
+        return _response_tuple(
+            chat_history,
+            message,
+            state,
+            UNSUPPORTED_MUTATION_RESPONSE,
+            f"{SOURCE_STATIC_FALLBACK}. Unsupported data mutation - no model call.",
+            sql_text="",
+            validator=EMPTY_VALIDATOR,
+        )
+
     if intent_result.intent in {intent_core.SMALLTALK, intent_core.UNKNOWN}:
         return _response_tuple(
             chat_history,

intent.py

@@ -55,6 +55,10 @@ def classify_intent(message, state=None, chat_history=None):
     if _is_smalltalk(message):
         return IntentResult(SMALLTALK, 0.95, "smalltalk_phrase")
 
+    schema_context = sql_tools.last_create_table_from_history(chat_history) or state.active_schema
+    if sql_tools.is_unsupported_data_mutation_for_schema(message, schema_context):
+        return IntentResult(UNKNOWN, 0.9, "unsupported_data_mutation")
+
     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(

sql_tools.py

@@ -284,6 +284,67 @@ def is_table_edit_intent(message):
     )
 
 
+def is_unsupported_data_mutation_intent(message):
+    message = normalize_text(message)
+    if not message:
+        return False
+    if is_create_table_intent(message):
+        return False
+    explicit_dml = (
+        r"\b(?:insert\s+into|update\b.+\bset\b|delete\s+from|"
+        r"drop\s+table|drop\s+(?:the\s+|a\s+|an\s+)?\w+\s+table|truncate\s+table)\b"
+    )
+    if re.search(explicit_dml, message):
+        return True
+    if re.search(r"\binsert\b", message) and not re.search(r"\b(column|field|coluna|campo)\b", message):
+        return True
+    row_terms = r"(?:row|rows|record|records|linha|linhas|registro|registros)"
+    row_mutation = (
+        rf"\b(?:add|create|insert|include|remove|delete|drop|"
+        rf"adicionar|adicione|criar|crie|incluir|inclua|remover|remova|deletar|excluir|exclua|apagar|apague)\b"
+        rf".*\b{row_terms}\b"
+    )
+    if re.search(row_mutation, message):
+        return True
+    destructive_all = (
+        r"\b(?:delete|drop|remove|deletar|exclua|excluir|apaga|apagar|apague|remova|remover)\b"
+        r"\s+(?:all|every|rows?|records?|table|todos|todas|linhas?|registros?|tabela)\b"
+    )
+    return bool(re.search(destructive_all, message))
+
+
+def _table_name_variants(table_name):
+    base = normalize_text(table_name)
+    if not base:
+        return set()
+    variants = {base}
+    if base.endswith("ies") and len(base) > 3:
+        variants.add(f"{base[:-3]}y")
+    elif base.endswith("s") and len(base) > 1:
+        variants.add(base[:-1])
+    else:
+        variants.add(f"{base}s")
+    return {variant for variant in variants if variant}
+
+
+def is_unsupported_data_mutation_for_schema(message, active_schema=""):
+    if is_unsupported_data_mutation_intent(message):
+        return True
+    table_name, _columns = parse_create_table_schema(create_table_from_schema(active_schema))
+    if not table_name:
+        return False
+    message = normalize_text(message)
+    table_pattern = "|".join(
+        re.escape(variant)
+        for variant in sorted(_table_name_variants(table_name), key=len, reverse=True)
+    )
+    table_mutation = (
+        rf"\b(?:delete|drop|remove|deletar|excluir|exclua|remover|remova)\b"
+        rf"\s+(?:the\s+|a\s+|an\s+)?(?:table\s+)?(?:{table_pattern})\b(?:\s+table)?"
+    )
+    return bool(re.search(table_mutation, 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"}:
@@ -795,7 +856,10 @@ def edit_create_table_from_message(message, chat_history, active_schema):
         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])
+    updated_columns = [*kept_columns, *added_columns]
+    if updated_columns == existing_columns:
+        return ""
+    return format_create_table(table_name, updated_columns)
 
 
 def create_table_from_suggestion(suggestion):

tests/test_chatbot_behavior.py

@@ -148,7 +148,7 @@ def test_add_column_variants(message, expected_col, monkeypatch):
     [
         ("remova salario",  "salario"),
         ("remove nome",     "nome"),
-        ("delete salary",   "salary"),
+        ("delete salario",  "salario"),
         ("drop coluna id",  "id"),
     ],
 )
@@ -674,6 +674,92 @@ def test_edit_without_existing_table_returns_error():
     assert app.SOURCE_DETERMINISTIC_SCHEMA_PARSER in status_html(result)
 
 
+@pytest.mark.parametrize(
+    "message",
+    [
+        "delete all animals",
+        "delete animals",
+        "DELETE FROM animals",
+        "drop table animals",
+        "drop animals table",
+        "drop the animals table",
+        "drop animals",
+        "update animals set weight = 0",
+        "insert into animals values (1)",
+        "insert animal",
+        "insert row into animals",
+        "add row to animals",
+        "add animal record",
+    ],
+)
+def test_unsupported_data_mutation_returns_static_fallback(message, monkeypatch):
+    monkeypatch.setattr(app, "_run_generation", lambda *a, **k: pytest.fail("model should not run"))
+
+    result = app.generate_response(
+        message,
+        [],
+        "CREATE TABLE animals (id INTEGER, name TEXT, weight NUMERIC)",
+        None,
+        None,
+    )
+
+    assert sql_output(result) == ""
+    assert result[5] == app.EMPTY_VALIDATOR
+    assert app.UNSUPPORTED_MUTATION_RESPONSE in assistant_text(result)
+    assert app.SOURCE_STATIC_FALLBACK in status_html(result)
+    assert app.SOURCE_DETERMINISTIC_SCHEMA_PARSER not in status_html(result)
+
+
+def test_remove_nonexistent_columns_does_not_return_unchanged_schema():
+    schema = "CREATE TABLE animals (id INTEGER, name TEXT, species TEXT);"
+
+    assert app.sql_core.edit_create_table_from_message("delete all animals", [], schema) == ""
+
+
+def test_noop_schema_edit_reports_no_matching_column(monkeypatch):
+    monkeypatch.setattr(app, "_run_generation", lambda *a, **k: pytest.fail("model should not run"))
+
+    result = app.generate_response(
+        "delete salary",
+        [],
+        "CREATE TABLE animals (id INTEGER, name TEXT, species TEXT)",
+        None,
+        None,
+    )
+
+    assert sql_output(result) == ""
+    assert "No matching schema column was changed." in status_html(result)
+    assert app.SOURCE_DETERMINISTIC_SCHEMA_PARSER in status_html(result)
+
+
+def test_data_mutation_uses_schema_from_history_when_active_schema_empty(monkeypatch):
+    monkeypatch.setattr(app, "_run_generation", lambda *a, **k: pytest.fail("model should not run"))
+    history = [
+        {
+            "role": "assistant",
+            "content": "```sql\nCREATE TABLE animals (id INTEGER, species TEXT);\n```",
+        }
+    ]
+
+    result = app.generate_response("delete animals", history, "", None, None)
+
+    assert sql_output(result) == ""
+    assert app.UNSUPPORTED_MUTATION_RESPONSE in assistant_text(result)
+    assert app.SOURCE_STATIC_FALLBACK in status_html(result)
+
+
+@pytest.mark.parametrize("message", ["create table rows with id name", "create table records with id name"])
+def test_create_table_names_that_overlap_row_terms_still_create_schema(message, monkeypatch):
+    monkeypatch.setattr(app, "_run_generation", lambda *a, **k: pytest.fail("model should not run"))
+
+    result = app.generate_response(message, [], "", None, None)
+
+    assert "CREATE TABLE" in sql_output(result)
+    assert "id INTEGER" in sql_output(result)
+    assert "name TEXT" in sql_output(result)
+    assert app.SOURCE_DETERMINISTIC_SCHEMA_PARSER in status_html(result)
+
+
 def test_non_template_sql_intent_without_model_returns_load_error():
     result = app.generate_response(
         "find employees named Alice", [], app.PRESETS["employees"], None, None

tests/test_chatbot_core.py

@@ -46,6 +46,52 @@ def test_intent_create_edit_and_sql_query():
     assert query.intent == SQL_QUERY
 
 
+def test_destructive_data_mutation_is_unknown_with_active_schema():
+    state = ConversationState(active_schema="CREATE TABLE animals (id INTEGER, name TEXT, species TEXT)")
+
+    assert classify_intent("delete all animals", state).intent == UNKNOWN
+    assert classify_intent("DELETE FROM animals", state).intent == UNKNOWN
+    assert classify_intent("UPDATE animals SET name = 'x'", state).intent == UNKNOWN
+    assert classify_intent("INSERT INTO animals VALUES (1)", state).intent == UNKNOWN
+    assert classify_intent("insert animal", state).intent == UNKNOWN
+    assert classify_intent("insert row into animals", state).intent == UNKNOWN
+    assert classify_intent("add row to animals", state).intent == UNKNOWN
+    assert classify_intent("add animal record", state).intent == UNKNOWN
+    assert classify_intent("drop animals table", state).intent == UNKNOWN
+    assert classify_intent("drop the animals table", state).intent == UNKNOWN
+    assert classify_intent("delete animals", state).intent == UNKNOWN
+    assert classify_intent("drop animals", state).intent == UNKNOWN
+
+    singular_state = ConversationState(active_schema="CREATE TABLE animal (id INTEGER, species TEXT)")
+    assert classify_intent("delete animals", singular_state).intent == UNKNOWN
+    assert classify_intent("drop animals", singular_state).intent == UNKNOWN
+
+
+def test_data_mutation_uses_schema_from_history_when_active_schema_empty():
+    history = [
+        {
+            "role": "assistant",
+            "content": "```sql\nCREATE TABLE animals (id INTEGER, species TEXT);\n```",
+        }
+    ]
+
+    assert classify_intent("delete animals", ConversationState(), history).intent == UNKNOWN
+    assert classify_intent("drop animals", ConversationState(), history).intent == UNKNOWN
+
+
+def test_delete_existing_column_stays_schema_edit():
+    state = ConversationState(active_schema="CREATE TABLE animals (id INTEGER, species TEXT)")
+
+    assert classify_intent("delete species", state).intent == EDIT_TABLE
+    assert classify_intent("drop coluna id", state).intent == EDIT_TABLE
+    assert classify_intent("add habitat", state).intent == EDIT_TABLE
+
+
+def test_create_tables_named_rows_or_records_are_not_data_mutation():
+    assert classify_intent("create table rows with id name", ConversationState()).intent == CREATE_TABLE
+    assert classify_intent("create table records with id name", ConversationState()).intent == CREATE_TABLE
+
+
 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)