resolve dynamic cache

app.py

@@ -51,31 +51,26 @@ except Exception as e:
 mcp = FastMCP("ZohoCRMAgent")
 
 # ----------------------------
-# Analytics (Kept intact)
+# Analytics
 # ----------------------------
 ANALYTICS_PATH = "mcp_analytics.json"
 def _init_analytics():
     if not os.path.exists(ANALYTICS_PATH):
         with open(ANALYTICS_PATH, "w") as f: json.dump({}, f)
-def _log_tool_call(t, s): pass 
-def _log_llm_call(c): pass      
 _init_analytics()
 
 # ----------------------------
-# FIX: Regex JSON Extractor
+# Regex JSON Extractor
 # ----------------------------
 def extract_json_safely(text: str) -> Optional[Any]:
     """
     Extracts JSON from text even if the model adds conversational filler.
-    Fixes the '(Parse) Model output was not valid JSON' error.
     """
     try:
-        # 1. Try direct parse
         return json.loads(text)
     except:
         pass
     
-    # 2. Regex search for { ... } or [ ... ]
     try:
         match = re.search(r'(\{.*\}|\[.*\])', text, re.DOTALL)
         if match:
@@ -99,10 +94,8 @@ def init_local_model():
     try:
         logger.info(f"Loading model: {LOCAL_MODEL}...")
         TOKENIZER = AutoTokenizer.from_pretrained(LOCAL_MODEL, trust_remote_code=True)
-        # Use CPU if needed, or remove device_map="auto" if causing issues
         model = AutoModelForCausalLM.from_pretrained(LOCAL_MODEL, trust_remote_code=True, device_map="auto")
         
-        # FIX: Lower max_new_tokens to prevent 400s generation loops
         LLM_PIPELINE = pipeline("text-generation", model=model, tokenizer=TOKENIZER)
         LOADED_MODEL_NAME = LOCAL_MODEL
         logger.info("Model loaded.")
@@ -111,19 +104,26 @@ def init_local_model():
 
 init_local_model()
 
+# --- FIX APPLIED HERE ---
 def local_llm_generate(prompt: str, max_tokens: int = 512) -> Dict[str, Any]:
     if LLM_PIPELINE is None:
         return {"text": "LLM not loaded.", "raw": None}
     try:
-        # FIX: return_full_text=False ensures we don't re-parse the prompt
-        out = LLM_PIPELINE(prompt, max_new_tokens=max_tokens, return_full_text=False)
+        # FIX: Added `use_cache=False` to resolve 'DynamicCache' object has no attribute 'seen_tokens'
+        out = LLM_PIPELINE(
+            prompt, 
+            max_new_tokens=max_tokens, 
+            return_full_text=False, 
+            use_cache=False
+        )
         text = out[0]["generated_text"] if out else ""
         return {"text": text, "raw": out}
     except Exception as e:
+        logger.error(f"Generation Error: {e}")
         return {"text": f"Error: {e}", "raw": None}
 
 # ----------------------------
-# Helper: normalize local file_path args (Kept intact)
+# Helper: normalize local file_path args
 # ----------------------------
 def _normalize_local_path_args(args: Any) -> Any:
     if not isinstance(args, dict): return args
@@ -133,7 +133,7 @@ def _normalize_local_path_args(args: Any) -> Any:
     return args
 
 # ----------------------------
-# Zoho Auth & Tools (Kept intact)
+# Zoho Auth & Tools
 # ----------------------------
 def _get_valid_token_headers() -> dict:
     token_url = "https://accounts.zoho.in/oauth/v2/token"
@@ -212,18 +212,17 @@ def process_document(file_path: str, target_module: Optional[str] = "Contacts")
         if not raw_text or len(raw_text) < 5:
             return {"status": "error", "error": "OCR failed to extract text."}
 
-        # 2. Use Prompt Template (Strict Mode)
-        # FIX: Use prompts.py template + reduce max_tokens for speed
+        # 2. Use Prompt Template
         prompt = get_ocr_extraction_prompt(raw_text)
         
-        llm_out = local_llm_generate(prompt, max_tokens=300) # 300 tokens is plenty for JSON
+        # 3. Generate (with cache fix applied in local_llm_generate)
+        llm_out = local_llm_generate(prompt, max_tokens=300)
         extracted_text = llm_out.get("text", "")
         
-        # FIX: Use Regex Safe Extraction
+        # 4. Extract JSON
         extracted_data = extract_json_safely(extracted_text)
         
         if not extracted_data:
-            # Fallback for debugging
             extracted_data = {"raw_llm_text": extracted_text}
 
         return {
@@ -236,10 +235,9 @@ def process_document(file_path: str, target_module: Optional[str] = "Contacts")
         return {"status": "error", "error": str(e)}
 
 # ----------------------------
-# Helpers: map LLM args -> Zoho payloads (Kept intact)
+# Helpers: map LLM args -> Zoho payloads
 # ----------------------------
 def _extract_created_id_from_zoho_response(resp_json) -> Optional[str]:
-    # (Same implementation as before)
     try:
         if isinstance(resp_json, str): resp_json = json.loads(resp_json)
         data = resp_json.get("data") or resp_json.get("result")
@@ -251,17 +249,14 @@ def _extract_created_id_from_zoho_response(resp_json) -> Optional[str]:
     return None
 
 def _map_contact_args_to_zoho_payload(args: dict) -> dict:
-    # (Same implementation as before - abbreviated for strict structure compliance)
     p = {}
     if "contact" in args: p["Last_Name"] = args["contact"]
     if "email" in args: p["Email"] = args["email"]
-    # ... map other fields ...
     for k,v in args.items(): 
         if k not in ["contact", "email", "items"]: p[k] = v
     return p
 
 def _build_invoice_payload_for_zoho(contact_id: str, invoice_items: List[dict], currency: str = None, vat_pct: float = 0.0) -> dict:
-    # (Same implementation as before)
     line_items = []
     for it in invoice_items:
         qty = int(it.get("quantity", 1))
@@ -272,16 +267,14 @@ def _build_invoice_payload_for_zoho(contact_id: str, invoice_items: List[dict],
     return payload
 
 # ----------------------------
-# Parse & Execute (Kept intact)
+# Parse & Execute
 # ----------------------------
 def parse_and_execute_model_tool_output(model_text: str, history: Optional[List] = None) -> str:
-    # FIX: Use Safe Extraction first
     payload = extract_json_safely(model_text)
     
     if not payload:
         return "(Parse) Model output was not valid JSON tool instruction."
 
-    # Normalize to list
     instructions = [payload] if isinstance(payload, dict) else payload
     results = []
     contact_id = None
@@ -293,13 +286,11 @@ def parse_and_execute_model_tool_output(model_text: str, history: Optional[List]
         args = _normalize_local_path_args(args)
 
         if tool == "create_record":
-            # ... (logic same as before)
             res = create_record(args.get("module", "Contacts"), _map_contact_args_to_zoho_payload(args))
             results.append(f"create_record -> {res}")
             contact_id = _extract_created_id_from_zoho_response(res)
 
         elif tool == "create_invoice":
-            # ... (logic same as before)
             if not contact_id: contact_id = args.get("customer_id")
             if contact_id:
                 inv_payload = _build_invoice_payload_for_zoho(contact_id, args.get("line_items", []))
@@ -318,7 +309,6 @@ def parse_and_execute_model_tool_output(model_text: str, history: Optional[List]
 # Command Parser (Debug)
 # ----------------------------
 def try_parse_and_invoke_command(text: str):
-    # (Same implementation)
     if text.startswith("/mnt/data/"): return str(process_document(text))
     return None
 
@@ -340,24 +330,19 @@ def deepseek_response(message: str, file_path: Optional[str] = None, history: li
         else:
             return f"Error processing file: {doc_result.get('error')}"
 
-    # 2. Build Prompt (FIX: Use prompts.py)
-    # Flatten history for the prompt
+    # 2. Build Prompt
     history_text = "\n".join([f"User: {h[0]}\nBot: {h[1]}" for h in history])
     prompt = get_agent_prompt(history_text, ocr_context, message)
     
-    # 3. Generate
+    # 3. Generate (Cache Fix applies here too)
     gen = local_llm_generate(prompt, max_tokens=256)
     response_text = gen["text"]
     
-    # 4. Check for JSON Tool Call (FIX: Use Safe Extraction)
+    # 4. Check for JSON Tool Call
     tool_json = extract_json_safely(response_text)
     
     if tool_json and isinstance(tool_json, (dict, list)):
         try:
-            # We must pass the RAW text or the JSON object? 
-            # Your existing function `parse_and_execute...` expects a string or valid json structure.
-            # Let's pass the JSON stringified to be safe, or modify the caller.
-            # The safest way given your strict structure requirement is:
             return parse_and_execute_model_tool_output(json.dumps(tool_json), history)
         except Exception as e:
             return f"(Execute) Error: {e}"
@@ -378,7 +363,6 @@ def chat_handler(message, history):
     else:
         user_text = str(message)
 
-    # Debug command bypass
     if not uploaded_file_path:
         cmd = try_parse_and_invoke_command(user_text)
         if cmd: return cmd
@@ -386,7 +370,7 @@ def chat_handler(message, history):
     return deepseek_response(user_text, uploaded_file_path, history)
 
 # ----------------------------
-# FIX: Cleanup for fd -1 error
+# Cleanup
 # ----------------------------
 def cleanup_event_loop():
     gc.collect()