Fix: Improve language context switching by appending explicit instruction to user prompt

README.md

@@ -21,8 +21,7 @@ Planck AI is an advanced agentic search interface that combines the reasoning po
 - **💻 Code Execution**: Writes and runs code in **7+ Languages** (Python, Java, JS/TS, C/C++, Go) to solve logic/math problems.
 - **🌐 Deep Web Search**: Integated with Google & DuckDuckGo to find real-time information.
 - **📄 Document Analysis**: Upload PDFs or paste URLs—Planck reads and analyzes them (up to 10k chars/page).
-- **🗣️ Multi-Language Support**: Fluent in **20+ languages** (English, Nepali, Hindi, Mandarin, etc.) for both interaction and reasoning.
-- **👁️ Vision Capabilities**: Analyze uploaded images using GPT-4o's vision model.
+- **️ Vision Capabilities**: Analyze uploaded images using GPT-4o's vision model.
 - **⚡ Reactive UI**: A beautiful, dark-mode interface built with React & TailwindCSS.
 - **🔒 Privacy First**: All sessions are isolated. No data is stored permanently.
 

backend/agent/graph.py

@@ -201,14 +201,6 @@ class AgentRunner:
         # Append Language Instruction
         if language and language != "English":
             formatted_system_prompt += f"\n\nIMPORTANT: You must respond in {language}. Translate your internal reasoning if necessary, but the final output must be in {language}."
-        
-        # Override History Bias:
-        # If the conversation history has a different language, the model might get confused.
-        # We explicitly append the instruction to the *current* user message to force the switch.
-        current_user_content = user_message
-        if language and language != "English":
-            current_user_content += f"\n\n(Please answer in {language})"
-
         messages = [{"role": "system", "content": formatted_system_prompt}]
         
         # Smart Context Management
@@ -216,36 +208,49 @@ class AgentRunner:
         # Github Models Free Tier has a strict 8k token limit for ALL models
         # 8k tokens ~= 32k chars. We use 30k to be safe.
         MAX_HISTORY_CHARS = 30000
+            
+        current_chars = 0
+        selected_history = []
         
         if conversation_history:
-            # Sort by timestamp just in case
-            sorted_history = sorted(conversation_history, key=lambda x: x.get("timestamp", ""))
-            
-            # Simple truncation strategy
-            truncated_history = []
-            current_chars = 0
-            
-            # Add history from newest to oldest until limit
-            for msg in reversed(sorted_history):
-                content_len = len(msg.get("documents", [""])[0] if isinstance(msg.get("documents"), list) else str(msg.get("content", "")))
-                if current_chars + content_len > MAX_HISTORY_CHARS:
+            # Iterate backwards to keep most recent first
+            for msg in reversed(conversation_history):
+                content = msg.get("content") or ""
+                
+                # Truncate extremely long individual text messages
+                if content and len(content) > 2000:
+                    content = content[:2000] + "... [truncated]"
+                
+                # Estimate size (including tool call overhead)
+                msg_len = len(content) + 200 # Buffer for metadata
+                
+                if current_chars + msg_len > MAX_HISTORY_CHARS:
+                    # Soft limit hit - stop adding history
                     break
-                truncated_history.insert(0, msg)
-                current_chars += content_len
-            
-            # Convert to OpenAI format
-            for msg in truncated_history:
-                # Handle stored document format vs raw content
-                content = msg.get("documents", [""])[0] if isinstance(msg.get("documents"), list) else msg.get("content", "")
                 
-                # Skip system messages in history if any
-                if msg.get("role") == "system":
-                    continue
-                    
-                messages.append({
-                    "role": msg.get("role"),
+                # Reconstruct message preserving CRITICAL fields for API validity
+                clean_msg = {
+                    "role": msg["role"],
                     "content": content
-                })
+                }
+                if "tool_calls" in msg:
+                    clean_msg["tool_calls"] = msg["tool_calls"]
+                if "tool_call_id" in msg:
+                    clean_msg["tool_call_id"] = msg["tool_call_id"]
+                if "name" in msg:
+                    clean_msg["name"] = msg["name"]
+
+                selected_history.insert(0, clean_msg)
+                current_chars += msg_len
+
+        # SAFETY: Ensure history doesn't start with a 'tool' result (orphan)
+        # API requires: User/System -> Assistant -> Tool -> Assistant ...
+        # If we cut in the middle, we might start with 'tool'.
+        while selected_history and selected_history[0].get("role") == "tool":
+            selected_history.pop(0)
+
+        # Add trimmed history to messages
+        messages.extend(selected_history)
                 
         # Add file context if any
         file_context = ""

backend/main.py

@@ -98,41 +98,40 @@ async def chat(request: ChatRequest):
         for msg in history
     ]
     
-    # --- PARSING LOGIC MOVED UP ---
-    mode = "web"
-    clean_message = request.message
-    language = "English"
-
-    # Detect mode
-    if "[Mode: Chat]" in request.message:
-        mode = "chat"
-        clean_message = request.message.replace("[Mode: Chat]", "").strip()
-    elif "[Mode: Web]" in request.message:
-        mode = "web"
-        clean_message = request.message.replace("[Mode: Web]", "").strip()
-
-    # Detect Language
-    import re
-    lang_match = re.search(r'\[Language: (.*?)\]', clean_message)
-    if lang_match:
-        language = lang_match.group(1)
-        clean_message = clean_message.replace(lang_match.group(0), "").strip()
-    
-    # Handle legacy format
-    elif "[Focus Mode: Chat Only]" in request.message:
-        mode = "chat"
-        clean_message = re.sub(r'\[Focus Mode:.*?\]', '', request.message).strip()
-    
-    # --- SAVE CLEAN MESSAGE ---
-    memory.add_message(conversation_id, "user", clean_message)
+    # Add user message to memory
+    memory.add_message(conversation_id, "user", request.message)
     
     async def generate():
         """Generate streaming response."""
         full_response = ""
         tool_calls = []
         
-        # Use captured variables from outer scope: mode, clean_message, language
+        # Detect mode from message content (injected by frontend)
+        mode = "web"
+        clean_message = request.message
+
+        if "[Mode: Chat]" in request.message:
+            mode = "chat"
+            clean_message = request.message.replace("[Mode: Chat]", "").strip()
+        elif "[Mode: Web]" in request.message:
+            mode = "web"
+            clean_message = request.message.replace("[Mode: Web]", "").strip()
         
+        # Detect and extract language preference
+        # Format: [Language: Nepali]
+        language = "English"
+        import re
+        lang_match = re.search(r'\[Language: (.*?)\]', clean_message)
+        if lang_match:
+            language = lang_match.group(1)
+            clean_message = clean_message.replace(lang_match.group(0), "").strip()
+        
+        # Also handle legacy format just in case
+        elif "[Focus Mode: Chat Only]" in request.message:
+            mode = "chat"
+            # Strip the heavy-handed legacy tag
+            clean_message = re.sub(r'\[Focus Mode:.*?\]', '', request.message).strip()
+
         async for chunk in agent_runner.run(
             user_message=clean_message,
             conversation_history=conversation_history,

backend/tools/code_executor.py

@@ -66,7 +66,7 @@ def code_executor_tool(code: str, language: str = "python") -> str:
 
 
 def _execute_python(code: str, result: Dict[str, Any]) -> str:
-    """Executes Python code in-process using AST to capture last expression."""
+    """Executes Python code in-process using exec()."""
     stdout_capture = io.StringIO()
     stderr_capture = io.StringIO()
     
@@ -83,40 +83,14 @@ def _execute_python(code: str, result: Dict[str, Any]) -> str:
     exec_globals = {'__builtins__': safe_builtins}
     exec_locals = {}
     
-    import ast
-
     try:
         with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
-            # Parse the code into an AST
             try:
-                tree = ast.parse(code)
+                exec_result = eval(code, exec_globals, exec_locals)
+                result["result"] = str(exec_result) if exec_result is not None else None
             except SyntaxError:
-                # If parsing fails, fall back to simple exec to let it raise the error naturally
                 exec(code, exec_globals, exec_locals)
                 
-            # Check if likely an expression at the end
-            last_node = None
-            if tree.body and isinstance(tree.body[-1], ast.Expr):
-                last_node = tree.body.pop()
-            
-            # Execute the main block (all statements except the last expression)
-            if tree.body:
-                # Compile as a module
-                module = ast.Module(body=tree.body, type_ignores=[])
-                # We must fix locations for the new AST to be compilable
-                ast.fix_missing_locations(module)
-                compiled_module = compile(module, filename="<string>", mode="exec")
-                exec(compiled_module, exec_globals, exec_locals)
-            
-            # Evaluate the last expression (if any)
-            if last_node:
-                expr = ast.Expression(body=last_node.value)
-                ast.fix_missing_locations(expr)
-                compiled_expr = compile(expr, filename="<string>", mode="eval")
-                exec_result = eval(compiled_expr, exec_globals, exec_locals)
-                # Store the result
-                result["result"] = str(exec_result) if exec_result is not None else None
-                
         result["stdout"] = stdout_capture.getvalue()
         result["stderr"] = stderr_capture.getvalue()
         result["success"] = True

frontend/src/components/Header.jsx

@@ -63,9 +63,6 @@ export default function Header({ onToggleSidebar, onNewChat, currentLanguage = '
                     {/* Dropdown - Using pt-2 instead of mt-2 to maintain hover bridge */}
                     <div className="absolute right-0 top-full pt-2 w-56 hidden group-hover:block transition-all z-50">
                         <div className="bg-pplx-card border border-white/10 rounded-xl shadow-xl overflow-hidden">
-                            <div className="px-4 py-2 text-xs text-pplx-muted font-medium border-b border-white/5 bg-white/5">
-                                Sets language for new messages
-                            </div>
                             <div className="max-h-80 overflow-y-auto py-1 custom-scrollbar">
                                 {LANGUAGES.map((lang) => (
                                     <button