Revert "v5"

This reverts commit 82420e4218944073bcc0dbdfeac91741fb39d2f1.

app.py

@@ -572,6 +572,7 @@ async def stream_agent_response(question: str, chat_history: List[List[str]]) ->
         response_text = str(response)
     
     logger.info(f"Extracted response text: {response_text[:200]}...")
+    
     # Check if the response contains an SQL query and it truly looks like SQL
     sql_query = extract_sql_query(response_text)
     if sql_query and looks_like_sql(sql_query):
@@ -579,173 +580,167 @@ async def stream_agent_response(question: str, chat_history: List[List[str]]) ->
         # Execute the query and update the response
         db_connection, _ = setup_database_connection()
         if db_connection:
+            query_result = execute_sql_query(sql_query, db_connection)
+            
+            # Add the query and its result to the response
+            response_text += f"\n\n### 🔍 Resultado de la consulta:\n```sql\n{sql_query}\n```\n\n{query_result}"
+            
+            # Try to generate an interactive chart if the result is tabular
             try:
-                query_result = execute_sql_query(sql_query, db_connection)
+                if isinstance(query_result, str) and '|' in query_result and '---' in query_result:
+                    # Clean up the markdown table
+                    lines = [line.strip() for line in query_result.split('\n') 
+                            if line.strip() and '---' not in line and '|' in line]
+                    if len(lines) > 1:  # At least header + 1 data row
+                        # Get column names from the first line
+                        columns = [col.strip() for col in lines[0].split('|')[1:-1]]
+                        # Get data rows
+                        data = []
+                        for line in lines[1:]:
+                            values = [val.strip() for val in line.split('|')[1:-1]]
+                            if len(values) == len(columns):
+                                data.append(dict(zip(columns, values)))
+                        
+                        if data and len(columns) >= 2:
+                            # Determine chart type from user's question
+                            _, desired_type = detect_chart_preferences(question)
 
-                # Add the query and its result to the response
-                response_text += f"\n\n### 🔍 Resultado de la consulta:\n```sql\n{sql_query}\n```\n\n{query_result}"
+                            # Choose x/y columns (assume first is category, second numeric)
+                            x_col = columns[0]
+                            y_col = columns[1]
 
-                # Try to generate an interactive chart if the result is tabular
-                if isinstance(query_result, str) and '|' in query_result and '---' in query_result:
+                            # Coerce numeric values for y
+                            for row in data:
+                                try:
+                                    row[y_col] = float(re.sub(r"[^0-9.\-]", "", str(row[y_col])))
+                                except Exception:
+                                    pass
+
+                            chart_fig = generate_chart(
+                                data=data,
+                                chart_type=desired_type,
+                                x=x_col,
+                                y=y_col,
+                                title=f"{y_col} por {x_col}"
+                            )
+                            if chart_fig is not None:
+                                logger.info(f"Chart generated from SQL table: type={desired_type}, x={x_col}, y={y_col}, rows={len(data)}")
+                    except Exception as e:
+                        logger.error(f"Error generating chart: {str(e)}", exc_info=True)
+                        # Don't fail the whole request if chart generation fails
+                        response_text += "\n\n⚠️ No se pudo generar la visualización de los datos."
+                else:
+                    response_text += "\n\n⚠️ No se pudo conectar a la base de datos para ejecutar la consulta."
+            elif sql_query and not looks_like_sql(sql_query):
+                logger.info("Detected code block but it does not look like SQL; skipping execution.")
+
+            # If we still have no chart but the user clearly wants one,
+            # try a second pass to get ONLY a SQL query from the agent and execute it.
+            if chart_fig is None:
+                wants_chart, default_type = detect_chart_preferences(question)
+                if wants_chart:
                     try:
-                        # Clean up the markdown table
-                        lines = [line.strip() for line in query_result.split('\n')
-                                if line.strip() and '---' not in line and '|' in line]
-                        if len(lines) > 1:  # At least header + 1 data row
-                            # Get column names from the first line
-                            columns = [col.strip() for col in lines[0].split('|')[1:-1]]
-                            # Get data rows
-                            data = []
-                            for line in lines[1:]:
-                                values = [val.strip() for val in line.split('|')[1:-1]]
-                                if len(values) == len(columns):
-                                    data.append(dict(zip(columns, values)))
-
-                            if data and len(columns) >= 2:
-                                # Determine chart type from user's question
-                                _, desired_type = detect_chart_preferences(question)
-
-                                # Choose x/y columns (assume first is category, second numeric)
-                                x_col = columns[0]
-                                y_col = columns[1]
-
-                                # Coerce numeric values for y
-                                for row in data:
+                        logger.info("Second pass: asking agent for ONLY SQL query in fenced block.")
+                        sql_only_prompt = (
+                            "Devuelve SOLO la consulta SQL en un bloque ```sql``` para responder a: "
+                            f"{question}. No incluyas explicación ni texto adicional."
+                        )
+                        sql_only_resp = await agent.ainvoke({"input": sql_only_prompt})
+                        sql_only_text = str(sql_only_resp)
+                        sql_query2 = extract_sql_query(sql_only_text)
+                        if sql_query2 and looks_like_sql(sql_query2):
+                            logger.info(f"Second pass SQL detected: {sql_query2}")
+                            db_connection, _ = setup_database_connection()
+                            if db_connection:
+                                query_result = execute_sql_query(sql_query2, db_connection)
+                                # Try to parse table-like text into DataFrame if possible
+                                data = None
+                                if isinstance(query_result, str):
                                     try:
-                                        row[y_col] = float(re.sub(r"[^0-9.\-]", "", str(row[y_col])))
+                                        import pandas as pd
+                                        df = pd.read_csv(io.StringIO(query_result), sep="|")
+                                        data = df
                                     except Exception:
                                         pass
-
-                                chart_fig = generate_chart(
-                                    data=data,
-                                    chart_type=desired_type,
-                                    x=x_col,
-                                    y=y_col,
-                                    title=f"{y_col} por {x_col}"
-                                )
-                                if chart_fig is not None:
-                                    logger.info(
-                                        f"Chart generated from SQL table: type={desired_type}, x={x_col}, y={y_col}, rows={len(data)}"
-                                    )
+                                # As a fallback, don't rely on text table; just skip charting here
+                                if data is not None and hasattr(data, "empty") and not data.empty:
+                                    # Heuristics: choose first column as x and second as y if numeric
+                                    x_col = data.columns[0]
+                                    # pick first numeric column different to x
+                                    y_col = None
+                                    for col in data.columns[1:]:
+                                        try:
+                                            pd.to_numeric(data[col])
+                                            y_col = col
+                                            break
+                                        except Exception:
+                                            continue
+                                    if y_col:
+                                        desired_type = default_type
+                                        chart_fig = generate_chart(
+                                            data=data,
+                                            chart_type=desired_type,
+                                            x=x_col,
+                                            y=y_col,
+                                            title=f"{y_col} por {x_col}"
+                                        )
+                                        if chart_fig is not None:
+                                            logger.info("Chart generated from second-pass SQL execution.")
+                            else:
+                                logger.info("No DB connection on second pass; skipping.")
                     except Exception as e:
-                        logger.error(f"Error generating chart: {str(e)}", exc_info=True)
-                        # Don't fail the whole request if chart generation fails
-                        response_text += "\n\n⚠️ No se pudo generar la visualización de los datos."
-            except Exception as e:
-                logger.error(f"Error handling SQL result: {e}", exc_info=True)
-                response_text += "\n\n⚠️ Ocurrió un error al procesar la consulta."
-        else:
-            response_text += "\n\n⚠️ No se pudo conectar a la base de datos para ejecutar la consulta."
-    elif sql_query and not looks_like_sql(sql_query):
-        logger.info("Detected code block but it does not look like SQL; skipping execution.")
-
-    # If we still have no chart but the user clearly wants one,
-    # try a second pass to get ONLY a SQL query from the agent and execute it.
-    if chart_fig is None:
-        wants_chart, default_type = detect_chart_preferences(question)
-        if wants_chart:
-            try:
-                logger.info("Second pass: asking agent for ONLY SQL query in fenced block.")
-                sql_only_prompt = (
-                    "Devuelve SOLO la consulta SQL en un bloque ```sql``` para responder a: "
-                    f"{question}. No incluyas explicación ni texto adicional."
-                )
-                sql_only_resp = await agent.ainvoke({"input": sql_only_prompt})
-                sql_only_text = str(sql_only_resp)
-                sql_query2 = extract_sql_query(sql_only_text)
-                if sql_query2 and looks_like_sql(sql_query2):
-                    logger.info(f"Second pass SQL detected: {sql_query2}")
-                    db_connection, _ = setup_database_connection()
-                    if db_connection:
-                        query_result = execute_sql_query(sql_query2, db_connection)
-                        # Try to parse table-like text into DataFrame if possible
-                        data = None
-                        if isinstance(query_result, str):
-                            try:
-                                import pandas as pd
-                                df = pd.read_csv(io.StringIO(query_result), sep="|")
-                                data = df
-                            except Exception:
-                                pass
-                        # As a fallback, don't rely on text table; just skip charting here
-                        if data is not None and hasattr(data, "empty") and not data.empty:
-                            # Heuristics: choose first column as x and second as y if numeric
-                            x_col = data.columns[0]
-                            # pick first numeric column different to x
-                            y_col = None
-                            for col in data.columns[1:]:
+                        logger.error(f"Second-pass SQL synthesis failed: {e}")
+            
+            # Fallback: if user asked for a chart and we didn't get SQL or chart yet,
+            # parse the most recent assistant text for lines like "LABEL: NUMBER" (bulleted or plain).
+            if chart_fig is None:
+                wants_chart, desired_type = detect_chart_preferences(question)
+                if wants_chart:
+                    # Find the most recent assistant message with usable numeric pairs
+                    candidate_text = ""
+                    if chat_history:
+                        for pair in reversed(chat_history):
+                            if len(pair) >= 2 and isinstance(pair[1], str) and pair[1].strip():
+                                candidate_text = pair[1]
+                                break
+                    # Also consider current response_text as a data source
+                    if not candidate_text and isinstance(response_text, str) and response_text.strip():
+                        candidate_text = response_text
+                    if candidate_text:
+                        raw_lines = candidate_text.split('\n')
+                        # Normalize lines: strip bullets and markdown symbols
+                        norm_lines = []
+                        for l in raw_lines:
+                            s = l.strip()
+                            if not s:
+                                continue
+                            s = s.lstrip("•*-\t ")
+                            # Remove surrounding markdown emphasis from labels later
+                            norm_lines.append(s)
+                        data = []
+                        for l in norm_lines:
+                            # Accept patterns like "**LABEL**: 123" or "LABEL: 1,234"
+                            m = re.match(r"^(.+?):\s*([0-9][0-9.,]*)$", l)
+                            if m:
+                                label = m.group(1).strip()
+                                # Strip common markdown emphasis
+                                label = re.sub(r"[*_`]+", "", label).strip()
                                 try:
-                                    pd.to_numeric(data[col])
-                                    y_col = col
-                                    break
+                                    val = float(m.group(2).replace(',', ''))
                                 except Exception:
                                     continue
-                            if y_col:
-                                desired_type = default_type
-                                chart_fig = generate_chart(
-                                    data=data,
-                                    chart_type=desired_type,
-                                    x=x_col,
-                                    y=y_col,
-                                    title=f"{y_col} por {x_col}"
-                                )
-                                if chart_fig is not None:
-                                    logger.info("Chart generated from second-pass SQL execution.")
-                    else:
-                        logger.info("No DB connection on second pass; skipping.")
-            except Exception as e:
-                logger.error(f"Second-pass SQL synthesis failed: {e}")
-
-    # Fallback: if user asked for a chart and we didn't get SQL or chart yet,
-    # parse the most recent assistant text for lines like "LABEL: NUMBER" (bulleted or plain).
-    if chart_fig is None:
-        wants_chart, desired_type = detect_chart_preferences(question)
-        if wants_chart:
-            # Find the most recent assistant message with usable numeric pairs
-            candidate_text = ""
-            if chat_history:
-                for pair in reversed(chat_history):
-                    if len(pair) >= 2 and isinstance(pair[1], str) and pair[1].strip():
-                        candidate_text = pair[1]
-                        break
-            # Also consider current response_text as a data source
-            if not candidate_text and isinstance(response_text, str) and response_text.strip():
-                candidate_text = response_text
-            if candidate_text:
-                raw_lines = candidate_text.split('\n')
-                # Normalize lines: strip bullets and markdown symbols
-                norm_lines = []
-                for l in raw_lines:
-                    s = l.strip()
-                    if not s:
-                        continue
-                    s = s.lstrip("•*-\t ")
-                    # Remove surrounding markdown emphasis from labels later
-                    norm_lines.append(s)
-                data = []
-                for l in norm_lines:
-                    # Accept patterns like "**LABEL**: 123" or "LABEL: 1,234"
-                    m = re.match(r"^(.+?):\s*([0-9][0-9.,]*)$", l)
-                    if m:
-                        label = m.group(1).strip()
-                        # Strip common markdown emphasis
-                        label = re.sub(r"[*_`]+", "", label).strip()
-                        try:
-                            val = float(m.group(2).replace(',', ''))
-                        except Exception:
-                            continue
-                        data.append({"label": label, "value": val})
-                logger.info(f"Fallback parse from text: extracted {len(data)} items for potential chart")
-                if len(data) >= 2:
-                    chart_fig = generate_chart(
-                        data=data,
-                        chart_type=desired_type,
-                        x="label",
-                        y="value",
-                        title="Distribución"
-                    )
-                    if chart_fig is not None:
-                        logger.info(f"Chart generated from text fallback: type={desired_type}, items={len(data)}")
+                                data.append({"label": label, "value": val})
+                        logger.info(f"Fallback parse from text: extracted {len(data)} items for potential chart")
+                        if len(data) >= 2:
+                            chart_fig = generate_chart(
+                                data=data,
+                                chart_type=desired_type,
+                                x="label",
+                                y="value",
+                                title="Distribución"
+                            )
+                            if chart_fig is not None:
+                                logger.info(f"Chart generated from text fallback: type={desired_type}, items={len(data)}")
             
             # Update the assistant's message with the response
             assistant_message["content"] = response_text