Update tools/orchestrator.py

tools/orchestrator.py

@@ -7,7 +7,7 @@ import time
 from model_logic import call_model_stream, MODELS_BY_PROVIDER, get_default_model_display_name_for_provider
 from memory_logic import retrieve_memories_semantic, retrieve_rules_semantic
 from tools.websearch import search_and_scrape_duckduckgo, scrape_url
-from tools.space_builder import build_huggingface_space
+from tools.space_builder import create_huggingface_space, update_huggingface_space_file
 import prompts
 from utils import format_insights_for_prompt
 
@@ -23,28 +23,27 @@ def decide_on_tool(user_input: str, chat_history_for_prompt: list, initial_insig
 
     if "http://" in user_input or "https://" in user_input:
         url_match = re.search(r'(https?://[^\s]+)', user_input)
-        if url_match: return "scrape_url_and_report", {"url": url_match.group(1)}
+        if url_match:
+            return "scrape_url_and_report", {"url": url_match.group(1)}
 
-    if len(user_input.split()) <= 3 and any(kw in user_input_lower for kw in ["hello", "hi", "thanks", "ok", "bye"]) and not "?" in user_input:
-        return "quick_respond", {}
-    
-    if len(user_input.split()) > 3 or "?" in user_input or any(w in user_input_lower for w in ["what is", "how to", "explain", "search for", "build", "create", "make"]):
+    tool_trigger_keywords = ["what is", "how to", "explain", "search for", "build", "create", "make", "update", "modify", "change", "fix"]
+    if len(user_input.split()) > 3 or "?" in user_input or any(w in user_input_lower for w in tool_trigger_keywords):
         history_snippet = "\n".join([f"{msg['role']}: {msg['content'][:100]}" for msg in chat_history_for_prompt[-2:]])
         guideline_snippet = initial_insights_ctx_str[:200].replace('\n', ' ')
         tool_user_prompt = prompts.get_tool_user_prompt(user_input, history_snippet, guideline_snippet)
-        tool_decision_messages = [{"role":"system", "content": prompts.TOOL_SYSTEM_PROMPT}, {"role":"user", "content": tool_user_prompt}]
-        tool_model_display = next((dn for dn, mid in MODELS_BY_PROVIDER.get(TOOL_DECISION_PROVIDER.lower(), {}).get("models", {}).items() if mid == TOOL_DECISION_MODEL_ID), None)
-        if not tool_model_display: tool_model_display = get_default_model_display_name_for_provider(TOOL_DECISION_PROVIDER)
+        tool_decision_messages = [{"role": "system", "content": prompts.TOOL_SYSTEM_PROMPT}, {"role": "user", "content": tool_user_prompt}]
+        tool_model_display = next((dn for dn, mid in MODELS_BY_PROVIDER.get(TOOL_DECISION_PROVIDER.lower(), {}).get("models", {}).items() if mid == TOOL_DECISION_MODEL_ID), None) or get_default_model_display_name_for_provider(TOOL_DECISION_PROVIDER)
         
         if tool_model_display:
             try:
-                tool_resp_raw = "".join(list(call_model_stream(provider=TOOL_DECISION_PROVIDER, model_display_name=tool_model_display, messages=tool_decision_messages, temperature=0.0, max_tokens=200)))
+                tool_resp_raw = "".join(list(call_model_stream(provider=TOOL_DECISION_PROVIDER, model_display_name=tool_model_display, messages=tool_decision_messages, temperature=0.0, max_tokens=2048)))
                 json_match_tool = re.search(r"\{.*\}", tool_resp_raw, re.DOTALL)
                 if json_match_tool:
                     action_data = json.loads(json_match_tool.group(0))
                     action_type = action_data.get("action", "quick_respond")
                     action_input = action_data.get("action_input", {})
-                    if not isinstance(action_input, dict): action_input = {}
+                    if not isinstance(action_input, dict):
+                        action_input = {}
                     return action_type, action_input
             except Exception as e:
                 logger.error(f"Tool decision LLM error: {e}")
@@ -52,72 +51,72 @@ def decide_on_tool(user_input: str, chat_history_for_prompt: list, initial_insig
     return "quick_respond", {}
 
 def orchestrate_and_respond(user_input: str, provider_name: str, model_display_name: str, chat_history_for_prompt: list[dict], custom_system_prompt: str = None, ui_api_key_override: str = None):
-    process_start_time = time.time()
     request_id = os.urandom(4).hex()
     logger.info(f"ORCHESTRATOR [{request_id}] Start. User: '{user_input[:50]}...'")
-
-    history_str_for_prompt = "\n".join([f"{('User' if t['role'] == 'user' else 'AI')}: {t['content']}" for t in chat_history_for_prompt[-(MAX_HISTORY_TURNS * 2):]])
+    history_str_for_prompt = "\n".join([f"{t['role']}: {t['content']}" for t in chat_history_for_prompt])
     
     yield "status", "[Checking guidelines...]"
     initial_insights = retrieve_rules_semantic(f"{user_input}\n{history_str_for_prompt}", k=5)
     initial_insights_ctx_str, parsed_initial_insights_list = format_insights_for_prompt(initial_insights)
     
     yield "status", "[Choosing best approach...]"
-    action_type, action_input_dict = decide_on_tool(user_input, chat_history_for_prompt, initial_insights_ctx_str)
-    logger.info(f"ORCHESTRATOR [{request_id}]: Tool Decision: Action='{action_type}', Input='{action_input_dict}'")
+    action_type, action_input = decide_on_tool(user_input, chat_history_for_prompt, initial_insights_ctx_str)
+    logger.info(f"ORCHESTRATOR [{request_id}]: Tool Decision: Action='{action_type}', Input='{action_input}'")
     
     yield "status", f"[Path: {action_type}]"
-    final_system_prompt_str = custom_system_prompt or prompts.DEFAULT_SYSTEM_PROMPT
-    context_str, final_user_prompt_str = None, ""
+    final_system_prompt = custom_system_prompt or prompts.DEFAULT_SYSTEM_PROMPT
+    context_str = None
 
-    if action_type == "answer_using_conversation_memory":
+    if action_type == "create_huggingface_space":
+        yield "status", "[Tool: Creating Space...]"
+        params = ["owner", "space_name", "sdk", "markdown_content"]
+        if all(p in action_input for p in params):
+            result = create_huggingface_space(**action_input)
+            context_str = f"Tool Result (Create Space): {result.get('result') or result.get('error', 'Unknown outcome from tool.')}"
+        else:
+            context_str = "Tool Failed: Missing required parameters for create_huggingface_space. Required: " + ", ".join(params)
+    elif action_type == "update_huggingface_space_file":
+        yield "status", "[Tool: Updating file...]"
+        params = ["owner", "space_name", "file_path", "new_content", "commit_message"]
+        if all(p in action_input for p in params):
+            result = update_huggingface_space_file(**action_input)
+            context_str = f"Tool Result (Update File): {result.get('result') or result.get('error', 'Unknown outcome from tool.')}"
+        else:
+            context_str = "Tool Failed: Missing required parameters for update_huggingface_space_file. Required: " + ", ".join(params)
+    elif action_type == "search_duckduckgo_and_report" and WEB_SEARCH_ENABLED:
+        query = action_input.get("search_engine_query")
+        if query:
+            yield "status", f"[Web: '{query[:60]}'...]"
+            results = search_and_scrape_duckduckgo(query, num_results=2)
+            context_str = "Web Content:\n" + "\n".join([f"Source {i+1} ({r.get('url','N/A')}):\n{r.get('content', r.get('error', 'N/A'))[:3000]}\n---" for i, r in enumerate(results)])
+        else:
+            context_str = "Tool Failed: Missing 'search_engine_query' for web search."
+    elif action_type == "scrape_url_and_report" and WEB_SEARCH_ENABLED:
+        url = action_input.get("url")
+        if url:
+            yield "status", f"[Web: '{url[:60]}'...]"
+            result = scrape_url(url)
+            context_str = f"Web Content for {url}:\n{result.get('content', result.get('error', 'No content scraped.'))}"
+        else:
+            context_str = "Tool Failed: Missing 'url' for scraping."
+    elif action_type == "answer_using_conversation_memory":
         yield "status", "[Searching conversation memory...]"
         mems = retrieve_memories_semantic(f"User query: {user_input}\nContext:\n{history_str_for_prompt[-1000:]}", k=2)
         context_str = "Relevant Past Interactions:\n" + "\n".join([f"- User:{m.get('user_input','')}->AI:{m.get('bot_response','')} (Takeaway:{m.get('metrics',{}).get('takeaway','N/A')})" for m in mems]) if mems else "No relevant past interactions found."
-        final_system_prompt_str += " Respond using Memory Context, guidelines, & history."
-    elif WEB_SEARCH_ENABLED and action_type in ["search_duckduckgo_and_report", "scrape_url_and_report"]:
-        query_or_url = action_input_dict.get("search_engine_query") or action_input_dict.get("url")
-        if query_or_url:
-            yield "status", f"[Web: '{query_or_url[:60]}'...]"
-            web_results = []
-            try:
-                if action_type == "search_duckduckgo_and_report": web_results = search_and_scrape_duckduckgo(query_or_url, num_results=2)
-                elif action_type == "scrape_url_and_report": web_results = [scrape_url(query_or_url)]
-            except Exception as e: web_results = [{"url": query_or_url, "error": str(e)}]
-            context_str = "Web Content:\n" + "\n".join([f"Source {i+1}:\nURL:{r.get('url','N/A')}\nTitle:{r.get('title','N/A')}\nContent:\n{(r.get('content') or r.get('error') or 'N/A')[:3500]}\n---" for i,r in enumerate(web_results)]) if web_results else f"No results from {action_type} for '{query_or_url}'."
-            yield "status", "[Synthesizing web report...]"
-            final_system_prompt_str += " Generate report/answer from web content, history, & guidelines. Cite URLs as [Source X]."
-    elif action_type == "build_huggingface_space":
-        build_prompt = action_input_dict.get("build_prompt")
-        if not build_prompt:
-             context_str = "Tool Action Failed: The model decided to build a space but did not provide the necessary instructions (build_prompt)."
-             final_system_prompt_str += " Report the tool failure to the user."
-        else:
-            yield "status", f"[Tool: Building Space '{build_prompt[:50]}'...]"
-            build_result = build_huggingface_space(build_prompt)
-            if "error" in build_result:
-                context_str = f"Hugging Face Space Builder Tool Result:\n- Status: FAILED\n- Error: {build_result['error']}"
-                final_system_prompt_str += " The space building tool failed. Report the error to the user and ask if they want to try again."
-                yield "status", "[Tool: Space building failed.]"
-            else:
-                context_str = f"Hugging Face Space Builder Tool Result:\n- Status: SUCCESS\n- Details: {build_result['result']}"
-                final_system_prompt_str += " The space building tool has completed. Inform the user about the result, providing any links or key information from the tool's output."
-                yield "status", "[Tool: Space building complete.]"
-    else: # quick_respond or fallback
-        final_system_prompt_str += " Respond directly using guidelines & history."
-
-    final_user_prompt_str = prompts.get_final_response_prompt(history_str_for_prompt, initial_insights_ctx_str, user_input, context_str)
-    final_llm_messages = [{"role": "system", "content": final_system_prompt_str}, {"role": "user", "content": final_user_prompt_str}]
+    
+    final_user_prompt = prompts.get_final_response_prompt(history_str_for_prompt, initial_insights_ctx_str, user_input, context_str)
+    final_llm_messages = [{"role": "system", "content": final_system_prompt}, {"role": "user", "content": final_user_prompt}]
     
     streamed_response = ""
     try:
-        for chunk in call_model_stream(provider=provider_name, model_display_name=model_display_name, messages=final_llm_messages, api_key_override=ui_api_key_override, temperature=0.6, max_tokens=2500):
+        for chunk in call_model_stream(provider_name, model_display_name, final_llm_messages, ui_api_key_override, max_tokens=4096):
             if isinstance(chunk, str) and chunk.startswith("Error:"):
                 streamed_response += f"\n{chunk}\n"; yield "response_chunk", f"\n{chunk}\n"; break
-            streamed_response += chunk; yield "response_chunk", chunk
+            streamed_response += chunk
+            yield "response_chunk", chunk
     except Exception as e:
         streamed_response += f"\n\n(Error: {e})"; yield "response_chunk", f"\n\n(Error: {e})"
     
-    final_bot_text = streamed_response.strip() or "(No response or error.)"
-    logger.info(f"ORCHESTRATOR [{request_id}]: Finished. Total: {time.time() - process_start_time:.2f}s. Resp len: {len(final_bot_text)}")
+    final_bot_text = streamed_response.strip() or "(No response)"
+    logger.info(f"ORCHESTRATOR [{request_id}]: Finished. Response length: {len(final_bot_text)}")
     yield "final_response_and_insights", {"response": final_bot_text, "insights_used": parsed_initial_insights_list}