v5

app.py

@@ -572,7 +572,6 @@ 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):
@@ -580,167 +579,173 @@ 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:
-                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)
-
-                            # Choose x/y columns (assume first is category, second numeric)
-                            x_col = columns[0]
-                            y_col = columns[1]
+                query_result = execute_sql_query(sql_query, db_connection)
 
-                            # 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.")
+                # 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}"
 
-            # 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 to generate an interactive chart if the result is tabular
+                if isinstance(query_result, str) and '|' in query_result and '---' in query_result:
                     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):
+                        # 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:
                                     try:
-                                        import pandas as pd
-                                        df = pd.read_csv(io.StringIO(query_result), sep="|")
-                                        data = df
+                                        row[y_col] = float(re.sub(r"[^0-9.\-]", "", str(row[y_col])))
                                     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:]:
-                                        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.")
+
+                                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"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()
+                        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:]:
                                 try:
-                                    val = float(m.group(2).replace(',', ''))
+                                    pd.to_numeric(data[col])
+                                    y_col = col
+                                    break
                                 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)}")
+                            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)}")
             
             # Update the assistant's message with the response
             assistant_message["content"] = response_text