m8flow 1.1.1 → 1.1.3

package/bundled/backend/api/routes/flows.py

@@ -1,3 +1,4 @@
+import json
 from fastapi import APIRouter, HTTPException, Request
 from pydantic import BaseModel
 from domain.models import FlowSchema
@@ -86,9 +87,20 @@ def _to_canvas_node(node: dict) -> dict:
 
 
 def _inject_api_key(http_request: Request) -> None:
-    """Read X-OpenRouter-Key header and set it as the per-request ContextVar."""
-    key = http_request.headers.get("X-OpenRouter-Key")
-    llm_service._request_api_key.set(key or None)
+    """Read provider key + per-agent model headers and set per-request ContextVars."""
+    llm_service._request_api_key.set(http_request.headers.get("X-OpenRouter-Key") or None)
+    llm_service._request_gemini_key.set(http_request.headers.get("X-Gemini-Key") or None)
+    llm_service._request_mistral_key.set(http_request.headers.get("X-Mistral-Key") or None)
+
+    # Parse per-agent model matrix sent as JSON: {"architect":"gemini-2.5-flash", ...}
+    raw_agents = http_request.headers.get("X-Agent-Models")
+    if raw_agents:
+        try:
+            llm_service._request_agent_models.set(json.loads(raw_agents))
+        except Exception:
+            llm_service._request_agent_models.set(None)
+    else:
+        llm_service._request_agent_models.set(None)
 
 
 @router.post("/generate")
@@ -257,6 +269,34 @@ async def ask_flow(http_request: Request, req: AskRequest):
     }
 
 
+class InterviewRequest(BaseModel):
+    """Trigger Phase 1 analysis when a CSV is first uploaded."""
+    context: str  # dataset summary string from the upload response
+
+
+@router.post("/interview")
+async def interview_flow(http_request: Request, req: InterviewRequest):
+    """
+    Phase 1 — Interactive interview entry point.
+
+    Called immediately after a CSV upload. Returns a conversational
+    analysis text (with [PLANNING], [ANALYSIS], [DEDUCTION],
+    [AWAITING CONFIRMATION] status labels) WITHOUT generating any nodes.
+    The frontend displays this as an assistant message and waits for user
+    confirmation before proceeding to pipeline generation.
+    """
+    _inject_api_key(http_request)
+    if not req.context.strip():
+        raise HTTPException(status_code=422, detail="Context cannot be empty")
+    try:
+        text = await llm_service.interview_dataset(req.context)
+        return {"result_type": "interview", "message": text}
+    except RuntimeError as exc:
+        raise HTTPException(status_code=503, detail=str(exc))
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"{type(exc).__name__}: {exc}")
+
+
 @router.post("/execute")
 def execute_flow(flow: FlowSchema):
     try:

package/bundled/backend/api/routes/nodes.py

@@ -77,9 +77,9 @@ async def generate_node_code_route(http_request: Request, req: GenerateCodeReque
     """Generate M8Flow-compatible Python node code from a plain-English description."""
     from services import llm_service
 
-    # Honour the per-request OpenRouter key set by the frontend
-    key = http_request.headers.get("X-OpenRouter-Key")
-    llm_service._request_api_key.set(key or None)
+    llm_service._request_api_key.set(http_request.headers.get("X-OpenRouter-Key") or None)
+    llm_service._request_gemini_key.set(http_request.headers.get("X-Gemini-Key") or None)
+    llm_service._request_mistral_key.set(http_request.headers.get("X-Mistral-Key") or None)
 
     if not req.description.strip():
         raise HTTPException(status_code=422, detail="Description cannot be empty")

package/bundled/backend/config.py

@@ -10,9 +10,11 @@ if _global_env.exists():
     load_dotenv(_global_env, override=False)   # don't override already-set vars
 
 class Config:
-    MISTRAL_API_KEY    = os.getenv("MISTRAL_API_KEY", "")
-    OPENAI_API_KEY     = os.getenv("OPENAI_API_KEY", "")
+    MISTRAL_API_KEY    = os.getenv("MISTRAL_API_KEY",    "")
+    OPENAI_API_KEY     = os.getenv("OPENAI_API_KEY",     "")
     OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY", "")
+    GEMINI_API_KEY     = os.getenv("GEMINI_API_KEY",     "")  # Google AI Studio key
+    MISTRAL_API_KEY    = os.getenv("MISTRAL_API_KEY",    "")  # Mistral La Plateforme key
     STORAGE_DIR        = os.getenv("M8FLOW_UPLOAD_DIR", os.getenv("STORAGE_DIR", "./storage"))
 
 config = Config()

package/bundled/backend/core/code_validator.py

@@ -41,7 +41,7 @@ ALLOWED_IMPORTS = frozenset({
     "numpy", "pandas", "scipy", "sklearn", "xgboost", "lightgbm",
     "statsmodels", "imblearn",
     # Plotting
-    "matplotlib", "seaborn", "plotly",
+    "matplotlib", "seaborn", "plotly", "mpl_toolkits",
     # Standard safe libs
     "math", "statistics", "itertools", "functools", "collections",
     "json", "re", "datetime", "typing",

package/bundled/backend/core/executor.py

@@ -62,6 +62,49 @@ def _serialize_value(val: Any) -> Any:
             "shape": list(val.shape),
             "dtype": str(val.dtype),
         }
+
+    # ── sklearn displays ─────────────────────────────────────────────────────
+    is_display = hasattr(val, "figure_") and hasattr(val.figure_, "savefig")
+    if is_display:
+        try:
+            import io
+            import base64
+            buf = io.BytesIO()
+            val.figure_.savefig(buf, format="png", bbox_inches="tight")
+            b64 = base64.b64encode(buf.getvalue()).decode("utf-8")
+            return {
+                "image_base64": b64,
+                "title": getattr(val, "estimator_name", type(val).__name__)
+            }
+        except Exception:
+            pass
+
+    # ── matplotlib / seaborn ─────────────────────────────────────────────────
+    is_figure = hasattr(val, "savefig") and type(val).__module__.startswith("matplotlib")
+    if is_figure:
+        try:
+            import io
+            import base64
+            buf = io.BytesIO()
+            val.savefig(buf, format="png", bbox_inches="tight")
+            b64 = base64.b64encode(buf.getvalue()).decode("utf-8")
+            return {
+                "image_base64": b64,
+                "title": "Matplotlib / Seaborn Plot"
+            }
+        except Exception:
+            pass
+
+    # ── plotly ───────────────────────────────────────────────────────────────
+    if hasattr(val, "to_html") and type(val).__module__.startswith("plotly"):
+        try:
+            return {
+                "plotly_html": val.to_html(full_html=False, include_plotlyjs="cdn"),
+                "title": "Plotly Visualization"
+            }
+        except Exception:
+            pass
+
     # sklearn / any estimator
     if hasattr(val, "predict") and hasattr(val, "fit"):
         return {
@@ -75,9 +118,33 @@ def _serialize_value(val: Any) -> Any:
     if isinstance(val, (np.bool_,)):
         return bool(val)
     if isinstance(val, dict):
+        if "data" in val and isinstance(val.get("data"), list) and "layout" in val:
+            try:
+                import json
+                import plotly.io as pio
+                val_json = json.dumps(val)
+                fig = pio.from_json(val_json)
+                return {
+                    "plotly_html": fig.to_html(full_html=False, include_plotlyjs="cdn"),
+                    "title": "Plotly Visualization"
+                }
+            except Exception:
+                pass
         return {k: _serialize_value(v) for k, v in val.items()}
     if isinstance(val, (list, tuple)):
         return [_serialize_value(v) for v in val]
+    if isinstance(val, str):
+        if val.startswith('{') and '"data":' in val and '"layout":' in val:
+            try:
+                import plotly.io as pio
+                fig = pio.from_json(val)
+                return {
+                    "plotly_html": fig.to_html(full_html=False, include_plotlyjs="cdn"),
+                    "title": "Plotly Visualization"
+                }
+            except Exception:
+                pass
+        return val
     return val
 
 

package/bundled/backend/core/runtime.py

@@ -3,6 +3,13 @@ import inspect
 import functools
 from typing import Any
 
+# Ensure matplotlib uses a non-interactive backend
+try:
+    import matplotlib
+    matplotlib.use('Agg')
+except ImportError:
+    pass
+
 
 @functools.lru_cache(maxsize=128)
 def _compile(code: str):
@@ -45,5 +52,33 @@ def execute_node_code(code: str, inputs: dict[str, Any]) -> dict[str, Any]:
 
     result = run_fn(**filtered)
     if not isinstance(result, dict):
-        return {"output": result}
+        result = {"output": result}
+
+    # ── Automatically capture unreturned matplotlib figures ──────────────────
+    import sys
+    if "matplotlib.pyplot" in sys.modules:
+        import matplotlib.pyplot as plt
+        figs = plt.get_fignums()
+        if figs:
+            # Identify figures already returned explicitly to avoid duplicates
+            returned_fig_ids = {id(v) for v in result.values() if hasattr(v, "savefig")}
+            
+            import io, base64
+            for i, num in enumerate(figs):
+                fig = plt.figure(num)
+                if id(fig) in returned_fig_ids:
+                    continue
+
+                buf = io.BytesIO()
+                fig.savefig(buf, format="png", bbox_inches="tight")
+                b64 = base64.b64encode(buf.getvalue()).decode("utf-8")
+                # Avoid overwriting explicit returns
+                key = f"plot_{i}" if i > 0 else "plot"
+                if key not in result:
+                    result[key] = {
+                        "image_base64": b64,
+                        "title": f"Figure {num}"
+                    }
+            plt.close("all")
+
     return result

package/bundled/backend/main.py

@@ -1,6 +1,16 @@
 from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
+
+# Force matplotlib to use a non-interactive backend (Agg)
+# This prevents "main thread is not in main loop" errors when running 
+# inside background threads (like FastAPI/uvicorn).
+try:
+    import matplotlib
+    matplotlib.use('Agg')
+except ImportError:
+    pass
+
 from api.routes import flows, nodes, appstate
 import os
 import time
@@ -60,6 +70,17 @@ app.include_router(nodes.router,    prefix="/api/nodes",    tags=["Nodes"])
 app.include_router(appstate.router, prefix="/api/app/state", tags=["AppState"])
 
 
+@app.get("/v1/models")
+def openai_compat_models():
+    """
+    OpenAI-compatible /v1/models stub.
+    External tools (VS Code extensions, Cursor, Continue.dev …) probe this
+    endpoint to check if the server speaks the OpenAI protocol.
+    Return a minimal valid response so they get a 200 instead of a noisy 404.
+    """
+    return {"object": "list", "data": []}
+
+
 @app.get("/api/health")
 def health_check():
     from config import config