Update zoho_client_mcp.py

zoho_client_mcp.py

@@ -1,101 +1,93 @@
 from mcp.server.fastmcp import FastMCP
-from typing import dict, list, Optional
+from typing import Optional
+import requests
 import os
-# Placeholder for configuration constants and dependencies (e.g., Tesseract, pdf2image)
+
 from config import CLIENT_ID, CLIENT_SECRET, REFRESH_TOKEN, API_BASE
 
 # --- Initialize the FastMCP Server ---
-# The server is focused on Zoho CRM actions [12, 13].
 mcp = FastMCP("ZohoCRMAgent")
 
-# --- Conceptual Zoho API Handling Functions (Internal Logic) ---
-# NOTE: These functions simulate the logic that would use the existing CLIENT_ID, 
-# CLIENT_SECRET, and REFRESH_TOKEN to make authenticated API calls to the 
-# new API_BASE (Zoho CRM /crm/v2) [5, 6].
-
+# --- Token Refresh Utility ---
 def _get_valid_token_headers() -> dict:
-    """Internal function to ensure a valid Zoho access token is available."""
-    # This logic reuses the pattern of handling OAuth and token refresh 
-    # from the original zoho_client.py [1, 5, 6].
-    # In a real implementation, it would use the stored REFRESH_TOKEN to get a new Access Token.
-    return {"Authorization": "Zoho-oauthtoken <ACCESS_TOKEN_HERE>"}
+    """Internal function to ensure a valid Zoho access token is available.
+    This uses the refresh token flow to retrieve a fresh access token."""
+    token_url = "https://accounts.zoho.in/oauth/v2/token"
+    params = {
+        "refresh_token": REFRESH_TOKEN,
+        "client_id": CLIENT_ID,
+        "client_secret": CLIENT_SECRET,
+        "grant_type": "refresh_token"
+    }
+    response = requests.post(token_url, params=params)
+    if response.status_code == 200:
+        access_token = response.json().get("access_token")
+        return {"Authorization": f"Zoho-oauthtoken {access_token}"}
+    else:
+        raise Exception(f"Failed to refresh token: {response.text}")
 
-# --- MCP Tools for Zoho CRM CRUD Operations (Required actions) ---
+# --- MCP Tools for Zoho CRM and Zoho Books Operations ---
 
 @mcp.tool()
 def authenticate_zoho() -> str:
-    """
-    Performs the OAuth 2.0 flow to ensure the agent has a valid Zoho CRM 
-    access token for subsequent API calls [7, 14].
-    """
-    # Placeholder for the actual OAuth flow [6].
+    """Refreshes and confirms Zoho CRM access token availability."""
+    _ = _get_valid_token_headers()
     return "Zoho CRM access token successfully refreshed."
 
 @mcp.tool()
 def create_record(module_name: str, record_data: dict) -> str:
-    """
-    Creates a new record (e.g., Contact, Lead, Account, Deal) in the 
-    specified Zoho CRM module [6, 12].
-    Example: create_record("Contacts", {"Last_Name": "Alice", "Email": "[email protected]"})
-    """
-    # This tool fulfills the 'create user/contact' requirement [12, 13].
+    """Creates a new record in the specified Zoho CRM module."""
     headers = _get_valid_token_headers()
-    # Logic: POST to f"{API_BASE}/{module_name}" with record_data
-    if module_name in ["Contacts", "Leads", "Accounts", "Deals"]:
-        return f"Successfully created a new record in {module_name}."
-    else:
-        return f"Error: Module {module_name} is not supported or recognized."
+    response = requests.post(f"{API_BASE}/{module_name}", headers=headers, json={"data": [record_data]})
+    if response.status_code in [200, 201]:
+        return f"Record created successfully in {module_name}."
+    return f"Error creating record: {response.text}"
 
 @mcp.tool()
-def get_records(module_name: str, page: int=1, per_page: int=200) -> list:
-    """
-    Fetches records from a CRM module based on module name, used for searches 
-    or getting lists [6, 15].
-    """
+def get_records(module_name: str, page: int = 1, per_page: int = 200) -> list:
+    """Fetches records from a specified Zoho CRM module."""
     headers = _get_valid_token_headers()
-    # Logic: GET from f"{API_BASE}/{module_name}"
-    return [f"List of records retrieved from {module_name} module on page {page}."]
+    params = {"page": page, "per_page": per_page}
+    response = requests.get(f"{API_BASE}/{module_name}", headers=headers, params=params)
+    if response.status_code == 200:
+        return response.json().get("data", [])
+    return [f"Error retrieving records: {response.text}"]
 
 @mcp.tool()
 def update_record(module_name: str, record_id: str, data: dict) -> str:
-    """
-    Updates fields on an existing record identified by module and ID [6, 10, 15].
-    """
+    """Updates a record in a Zoho CRM module."""
     headers = _get_valid_token_headers()
-    # Logic: PUT to f"{API_BASE}/{module_name}/{record_id}"
-    return f"Record {record_id} in {module_name} updated successfully."
+    response = requests.put(f"{API_BASE}/{module_name}/{record_id}", headers=headers, json={"data": [data]})
+    if response.status_code == 200:
+        return f"Record {record_id} in {module_name} updated successfully."
+    return f"Error updating record: {response.text}"
 
 @mcp.tool()
 def delete_record(module_name: str, record_id: str) -> str:
-    """
-    Deletes a record from the specified CRM module [6, 10, 15].
-    """
+    """Deletes a record from the specified Zoho CRM module."""
     headers = _get_valid_token_headers()
-    # Logic: DELETE to f"{API_BASE}/{module_name}/{record_id}"
-    return f"Record {record_id} in {module_name} deleted."
+    response = requests.delete(f"{API_BASE}/{module_name}/{record_id}", headers=headers)
+    if response.status_code == 200:
+        return f"Record {record_id} in {module_name} deleted."
+    return f"Error deleting record: {response.text}"
 
-# --- MCP Tool for File Processing (Incorporating old ai_engine logic) ---
-# This tool handles the requirement for accepting uploaded images or PDFs [13, 16, 17].
+@mcp.tool()
+def create_invoice(data: dict) -> str:
+    """Creates an invoice in Zoho Books."""
+    headers = _get_valid_token_headers()
+    response = requests.post(f"{API_BASE}/invoices", headers=headers, json={"data": [data]})
+    if response.status_code in [200, 201]:
+        return "Invoice created successfully."
+    return f"Error creating invoice: {response.text}"
 
-# NOTE: The FastMCP framework handles file references automatically, passing 
-# a path or URL to the tool function [10, 18].
 @mcp.tool()
 def process_document(file_path: str, target_module: Optional[str] = "Contacts") -> dict:
-    """
-    Analyzes an attached PDF or image using OCR and AI, extracts structured data,
-    and returns fields ready for Zoho entry [8-10].
-    
-    The internal process reuses perform_ocr and extract_intelligent_json logic [1, 9].
-    """
-    # 1. OCR Step (Uses Tesseract/pdf2image from existing pipeline) [1, 9].
-    # raw_text = perform_ocr(file_path) 
-    
-    # 2. AI Parsing Step (Uses Gemini to parse text into JSON) [1, 11].
-    # extracted_data = gemini_parse_json(raw_text) 
-    
-    # 3. If successful, the LLM will decide whether to call 'create_record' next.
+    """Extracts data from uploaded file (PDF/image) and returns structured info."""
+    # Placeholder for OCR + Gemini parsing logic
+    # raw_text = perform_ocr(file_path)
+    # structured_data = gemini_parse_json(raw_text)
     return {
-        "status": "success", 
+        "status": "success",
         "file": os.path.basename(file_path),
-        "extracted_data": f"Structured data extracted from {target_module} document."
-    }
+        "extracted_data": f"Simulated structured data from {target_module} document."
+    }