Update app.py

app.py

@@ -36,19 +36,18 @@ if not GROQ_API_KEY:
     # raise ValueError("GROQ_API_KEY not set in environment") 
     exit(1)
 
-# --- Flask app setup (MOVED HERE) ---
+# --- Flask app setup ---
 BASE_DIR = Path(__file__).resolve().parent
 static_folder = BASE_DIR / "static"
 
-# The 'app' object MUST be defined before its first use, e.g., in @app.route
 app = Flask(__name__, static_folder=str(static_folder), static_url_path="/static")
 CORS(app)
+
 # --- LLM setup ---
-# Using a model that's good for coding tasks
 llm = ChatGroq(
-    model=os.getenv("LLM_MODEL", "meta-llama/llama-4-scout-17b-16e-instruct"), # Use the supported model
-    temperature=0, 
-    # max_tokens=2048,
+    model=os.getenv("LLM_MODEL", "meta-llama/llama-4-scout-17b-16e-instruct"),
+    temperature=0.1, # Set a lower, deterministic temperature
+    max_tokens=2048, # Ensure max_tokens is set to avoid truncation
     api_key=GROQ_API_KEY,
 )
 
@@ -60,35 +59,39 @@ You are an expert programming assistant. Your role is to provide code suggestion
 - **Language Adaptation:** Adjust your suggestions, code, and explanations to the programming language specified in the 'language' field of the 'AssistantState'.
 
 STRICT OUTPUT FORMAT (JSON ONLY):
-Return a single JSON object with the following keys:
-- assistant_reply: string  // a natural language reply TO THE USER, INCLUDING ANY REQUESTED CODE BLOCK(S).
+Return a single JSON object with the following keys. **The JSON object MUST be enclosed in a single ```json block.**
+- assistant_reply: string  // A natural language reply to the user (short and helpful). Do NOT include code blocks here.
+- code_snippet: string  // If suggesting code, provide it here in a markdown code block (e.g., ```python\\nprint('Hello')\\n```). If no code is required, use an empty string: "".
 - state_updates: object  // updates to the internal state, must include: language, conversationSummary
 - suggested_tags: array of strings // a list of 1-3 relevant tags for the assistant_reply
 
 Rules:
+- ALWAYS include all four top-level keys: `assistant_reply`, `code_snippet`, `state_updates`, and `suggested_tags`.
 - ALWAYS include `assistant_reply` as a non-empty string.
-- If the user is asking for code, the code MUST be enclosed in appropriate markdown code blocks (e.g., ```python\n...\n```) and placed within the `assistant_reply` string.
-- Do NOT produce any text outside the JSON object.
-- Be concise in the non-code parts of `assistant_reply`.
+- Do NOT produce any text outside the JSON block.
 """
 
-
 def extract_json_from_llm_response(raw_response: str) -> dict:
     default = {
-        "assistant_reply": "I'm sorry — I couldn't understand that. Could you please rephrase?",
+        "assistant_reply": "I'm sorry, I couldn't process the response correctly. Could you please rephrase?",
+        "code_snippet": "",
         "state_updates": {"conversationSummary": "", "language": "Python"},
         "suggested_tags": [],
     }
-    # Simplified JSON extraction logic
+    
     if not raw_response or not isinstance(raw_response, str):
         return default
     
-    m = re.search(r"```(?:json)?\s*([\s\S]*?)\s*```", raw_response)
+    # Use a non-greedy regex to find the JSON content inside the first code block
+    m = re.search(r"```json\s*([\s\S]*?)\s*```", raw_response)
     json_string = m.group(1).strip() if m else raw_response
     
+    # Further refine candidate to just the JSON object content
     first = json_string.find('{')
     last = json_string.rfind('}')
     candidate = json_string[first:last+1] if first != -1 and last != -1 and first < last else json_string
+    
+    # Remove trailing commas which can break JSON parsing
     candidate = re.sub(r',\s*(?=[}\]])', '', candidate)
     
     try:
@@ -97,11 +100,18 @@ def extract_json_from_llm_response(raw_response: str) -> dict:
         logger.warning("Failed to parse JSON from LLM output: %s. Candidate: %s", e, candidate)
         return default
     
-    if isinstance(parsed, dict) and "assistant_reply" in parsed and parsed["assistant_reply"].strip():
+    # Validate and clean up the parsed dictionary
+    if isinstance(parsed, dict) and "assistant_reply" in parsed:
+        parsed.setdefault("code_snippet", "")
         parsed.setdefault("state_updates", {})
         parsed["state_updates"].setdefault("conversationSummary", "")
         parsed["state_updates"].setdefault("language", "Python")
         parsed.setdefault("suggested_tags", [])
+        
+        # Ensure reply is not empty
+        if not parsed["assistant_reply"].strip():
+             parsed["assistant_reply"] = "I need a clearer instruction to provide a reply."
+        
         return parsed
     else:
         logger.warning("Parsed JSON missing 'assistant_reply' or invalid format. Returning default.")
@@ -120,7 +130,7 @@ def detect_language_from_text(text: str) -> Optional[str]:
     return None
 
 # --- Flask routes ---
-@app.route("/", methods=["GET"]) # <-- 'app' is now defined!
+@app.route("/", methods=["GET"])
 def serve_frontend():
     try:
         return app.send_static_file("frontend.html") 
@@ -133,7 +143,6 @@ def chat():
     if not isinstance(data, dict):
         return jsonify({"error": "invalid request body"}), 400
 
-    # chat_history now receives the full conversation history from the corrected frontend
     chat_history: List[Dict[str, str]] = data.get("chat_history") or []
     assistant_state: AssistantState = data.get("assistant_state") or {}
 
@@ -164,15 +173,11 @@ def chat():
         state["language"] = detected_lang
         
     # 3. Inject Contextual Hint and State into the LAST user message
-    # This ensures the LLM has immediate access to the *summarized* history and current language.
     context_hint = f"Current Language: {state['language']}. Conversation Summary so far: {state['conversationSummary']}"
     
-    # Update the content of the last message in llm_messages
     if llm_messages and llm_messages[-1]["role"] == "user":
-        # Overwrite the last user message to include the context hint
         llm_messages[-1]["content"] = f"USER MESSAGE: {last_user_message}\n\n[CONTEXT HINT: {context_hint}]"
     elif last_user_message:
-        # Should not happen with the corrected frontend, but handles fresh start gracefully
         llm_messages.append({"role": "user", "content": f"USER MESSAGE: {last_user_message}\n\n[CONTEXT HINT: {context_hint}]"})
     
     
@@ -180,13 +185,12 @@ def chat():
         logger.info("Invoking LLM with full history and prepared prompt...")
         llm_response = llm.invoke(llm_messages)
         raw_response = llm_response.content if hasattr(llm_response, "content") else str(llm_response)
-        print("llm_response",llm_response)
+        
         logger.info(f"Raw LLM response: {raw_response}")
         parsed_result = extract_json_from_llm_response(raw_response)
 
     except Exception as e:
         logger.exception("LLM invocation failed")
-        # CRITICAL FIX: The Groq model might still be the problem if environment is inconsistent.
         error_detail = str(e)
         if 'decommissioned' in error_detail:
              error_detail = "LLM Model Error: The model is likely decommissioned. Please check the 'LLM_MODEL' environment variable or the default model in app.py."
@@ -195,19 +199,28 @@ def chat():
     # 4. State Update from LLM
     updated_state_from_llm = parsed_result.get("state_updates", {})
     
-    # CRUCIAL: Update state with the NEW summary generated by the LLM
     if 'conversationSummary' in updated_state_from_llm:
         state["conversationSummary"] = updated_state_from_llm["conversationSummary"]
     if 'language' in updated_state_from_llm:
         state["language"] = updated_state_from_llm["language"]
 
     assistant_reply = parsed_result.get("assistant_reply")
-    if not assistant_reply or not isinstance(assistant_reply, str) or not assistant_reply.strip():
-        assistant_reply = "I'm here to help with your code! What programming language are you using?"
+    code_snippet = parsed_result.get("code_snippet")
+    
+    # 5. Final Response Payload: Combine the reply and the code snippet
+    # The frontend is expecting the code to be *in* the assistant_reply, so we stitch it back together.
+    final_reply_content = assistant_reply
+    if code_snippet and code_snippet.strip():
+        # Add a newline for clean separation if the reply isn't just whitespace
+        if final_reply_content.strip():
+            final_reply_content += "\n\n"
+        final_reply_content += code_snippet
+        
+    if not final_reply_content.strip():
+        final_reply_content = "I'm here to help with your code! What programming language are you using?"
 
-    # 5. Final Response Payload
     response_payload = {
-        "assistant_reply": assistant_reply,
+        "assistant_reply": final_reply_content, # Send combined reply + code
         "updated_state": state,
         "suggested_tags": parsed_result.get("suggested_tags", []),
     }