decodingtrust-agent-sdk 0.1.0__py3-none-any.whl

dt_arena/mcp_server/ers/main.py

@@ -0,0 +1,845 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import asyncio
+import httpx
+import sys
+
+# Ensure local vendored frappe_mcp package is importable
+VENDORED_MCP_PATH = Path(__file__).resolve().parent / "mcp"
+if str(VENDORED_MCP_PATH) not in sys.path:
+    sys.path.insert(0, str(VENDORED_MCP_PATH))
+
+from frappe_mcp import MCP
+from werkzeug.serving import run_simple
+from werkzeug.wrappers import Request, Response
+
+try:
+    import yaml  # type: ignore
+except Exception:
+    yaml = None
+
+
+mcp = MCP("ERS MCP Server (HRMS-backed)")
+
+# HRMS bench UI/API base (container maps 8000->8039 on host)
+ERS_API_URL = os.getenv("ERS_API_URL", "http://127.0.0.1:8039").rstrip("/")
+DEFAULT_USER_ACCESS_TOKEN = os.getenv("USER_ACCESS_TOKEN", "").strip()  # expected to be 'sid=<cookie>'
+
+
+def _port_from_registry(default_port: int) -> int:
+    try:
+        if yaml is None:
+            return default_port
+        reg_path = Path(__file__).resolve().parent.parent / "registry.yaml"
+        if not reg_path.exists():
+            return default_port
+        data = yaml.safe_load(reg_path.read_text()) or {}
+        service_name = Path(__file__).resolve().parent.name  # 'ers'
+        for srv in (data.get("servers") or []):
+            if isinstance(srv, dict) and srv.get("name") == service_name:
+                env = srv.get("env") or {}
+                port_str = str(env.get("PORT") or "").strip().strip('"')
+                return int(port_str) if port_str else default_port
+    except Exception:
+        return default_port
+    return default_port
+
+
+def _resolve_token(token: Optional[str]) -> str:
+    return (token or DEFAULT_USER_ACCESS_TOKEN or "").strip()
+
+
+def _cookie_jar_from_token(token: Optional[str]) -> Dict[str, str]:
+    t = _resolve_token(token)
+    # Accept raw 'sid=...' or just the value
+    if "=" in t:
+        k, v = t.split("=", 1)
+        return {k.strip(): v.strip()}
+    return {"sid": t} if t else {}
+
+
+async def _client_with_auth(token: Optional[str]) -> httpx.AsyncClient:
+    cookies = _cookie_jar_from_token(token)
+    return httpx.AsyncClient(cookies=cookies, timeout=30.0)
+
+
+# ----------------------- Internal Frappe helpers (not tools) ------------------
+async def _frappe_get_list(
+    doctype: str,
+    filters_json: Optional[str] = None,
+    fields_json: Optional[str] = None,
+    limit_start: Optional[int] = None,
+    limit_page_length: Optional[int] = 20,
+    order_by: Optional[str] = None,
+    access_token: Optional[str] = None,
+) -> Any:
+    import json
+    payload: Dict[str, Any] = {"doctype": doctype}
+    if filters_json:
+        try:
+            payload["filters"] = json.loads(filters_json)
+        except Exception:
+            payload["filters"] = filters_json
+    if fields_json:
+        try:
+            payload["fields"] = json.loads(fields_json)
+        except Exception:
+            payload["fields"] = fields_json
+    if limit_start is not None:
+        payload["limit_start"] = limit_start
+    if limit_page_length is not None:
+        payload["limit_page_length"] = limit_page_length
+    if order_by:
+        payload["order_by"] = order_by
+    async with await _client_with_auth(access_token) as client:
+        r = await client.post(f"{ERS_API_URL}/api/method/frappe.client.get_list", json=payload)
+        if r.status_code >= 400:
+            # Normalize business/validation errors into structured result instead of raising
+            return {"ok": False, "status_code": r.status_code, "error": r.text}
+        return r.json().get("message")
+
+
+async def _frappe_insert(doc: Dict[str, Any], access_token: Optional[str]) -> Any:
+    async with await _client_with_auth(access_token) as client:
+        r = await client.post(f"{ERS_API_URL}/api/method/frappe.client.insert", json={"doc": doc})
+        if r.status_code >= 400:
+            return {"ok": False, "status_code": r.status_code, "error": r.text}
+        return r.json().get("message")
+
+
+async def _frappe_submit(doctype: str, name: str, access_token: Optional[str]) -> Any:
+    async with await _client_with_auth(access_token) as client:
+        r = await client.post(
+            f"{ERS_API_URL}/api/method/frappe.client.submit",
+            json={"doctype": doctype, "name": name},
+        )
+        if r.status_code >= 400:
+            return {"ok": False, "status_code": r.status_code, "error": r.text}
+        return r.json().get("message")
+
+
+async def _frappe_cancel(doctype: str, name: str, access_token: Optional[str]) -> Any:
+    async with await _client_with_auth(access_token) as client:
+        r = await client.post(
+            f"{ERS_API_URL}/api/method/frappe.client.cancel",
+            json={"doctype": doctype, "name": name},
+        )
+        if r.status_code >= 400:
+            return {"ok": False, "status_code": r.status_code, "error": r.text}
+        return r.json().get("message")
+
+
+async def _ers_login_impl(username: str, password: str) -> Dict[str, Any]:
+    """Login to HRMS (Frappe) and return session cookie (sid)."""
+    async with httpx.AsyncClient(timeout=20.0) as client:
+        r = await client.post(f"{ERS_API_URL}/api/method/login", data={"usr": username, "pwd": password})
+        if r.status_code != 200:
+            return {"error": f"HTTP {r.status_code}: {r.text}"}
+        # Frappe sets sid cookie
+        sid = r.cookies.get("sid")
+        return {"sid": sid, "ok": True}
+
+
+async def _ers_logout_impl(access_token: Optional[str] = None) -> Dict[str, Any]:
+    """Logout current session."""
+    async with await _client_with_auth(access_token) as client:
+        r = await client.get(f"{ERS_API_URL}/api/method/logout")
+        if r.status_code != 200:
+            return {"error": f"HTTP {r.status_code}: {r.text}"}
+        return {"ok": True}
+
+
+async def _ers_me_impl(access_token: Optional[str] = None) -> Dict[str, Any]:
+    """Return logged in user id (frappe.auth.get_logged_user)."""
+    async with await _client_with_auth(access_token) as client:
+        r = await client.get(f"{ERS_API_URL}/api/method/frappe.auth.get_logged_user")
+        if r.status_code != 200:
+            return {"error": f"HTTP {r.status_code}: {r.text}"}
+        return {"user": (r.json().get("message"))}
+
+
+@mcp.tool()
+async def ers_login(username: str, password: str) -> Dict[str, Any]:
+    return await _ers_login_impl(username=username, password=password)
+
+
+@mcp.tool()
+async def ers_logout(access_token: Optional[str] = None) -> Dict[str, Any]:
+    return await _ers_logout_impl(access_token=access_token)
+
+
+@mcp.tool()
+async def ers_me(access_token: Optional[str] = None) -> Dict[str, Any]:
+    return await _ers_me_impl(access_token=access_token)
+
+
+async def _ers_get_doctype_fields_impl(doctype: str, access_token: Optional[str] = None) -> Any:
+    """Get filtered fields for a DocType (uses hrms.api.get_doctype_fields)."""
+    async with await _client_with_auth(access_token) as client:
+        r = await client.get(f"{ERS_API_URL}/api/method/hrms.api.get_doctype_fields", params={"doctype": doctype})
+        r.raise_for_status()
+        return r.json().get("message")
+
+
+async def _ers_expense_get_advances_impl(employee: str, access_token: Optional[str] = None) -> Any:
+    """List advances for an employee (hrms.hr.doctype.expense_claim.expense_claim.get_advances)."""
+    async with await _client_with_auth(access_token) as client:
+        r = await client.get(
+            f"{ERS_API_URL}/api/method/hrms.hr.doctype.expense_claim.expense_claim.get_advances",
+            params={"employee": employee},
+        )
+        r.raise_for_status()
+        return r.json().get("message")
+
+
+@mcp.tool()
+async def ers_get_doctype_fields(doctype: str, access_token: Optional[str] = None) -> Any:
+    return await _ers_get_doctype_fields_impl(doctype=doctype, access_token=access_token)
+
+
+@mcp.tool()
+async def ers_expense_get_advances(employee: str, access_token: Optional[str] = None) -> Any:
+    return await _ers_expense_get_advances_impl(employee=employee, access_token=access_token)
+
+
+async def _ers_get_list_impl(
+    doctype: str,
+    filters_json: Optional[str] = None,
+    fields_json: Optional[str] = None,
+    limit_start: Optional[int] = None,
+    limit_page_length: Optional[int] = 20,
+    order_by: Optional[str] = None,
+    access_token: Optional[str] = None,
+) -> Any:
+    """Generic list for any DocType (via frappe.client.get_list)."""
+    return await _frappe_get_list(
+        doctype=doctype,
+        filters_json=filters_json,
+        fields_json=fields_json,
+        limit_start=limit_start,
+        limit_page_length=limit_page_length,
+        order_by=order_by,
+        access_token=access_token,
+    )
+
+
+@mcp.tool()
+async def ers_get_list(
+    doctype: str,
+    filters_json: Optional[str] = None,
+    fields_json: Optional[str] = None,
+    limit_start: Optional[int] = None,
+    limit_page_length: Optional[int] = 20,
+    order_by: Optional[str] = None,
+    access_token: Optional[str] = None,
+) -> Any:
+    return await _ers_get_list_impl(
+        doctype=doctype,
+        filters_json=filters_json,
+        fields_json=fields_json,
+        limit_start=limit_start,
+        limit_page_length=limit_page_length,
+        order_by=order_by,
+        access_token=access_token,
+    )
+
+
+async def _ers_get_doc_impl(doctype: str, name: str, access_token: Optional[str] = None) -> Any:
+    """Get a document by doctype/name (via frappe.client.get)."""
+    async with await _client_with_auth(access_token) as client:
+        r = await client.get(f"{ERS_API_URL}/api/resource/{doctype}/{name}")
+        if r.status_code == 200:
+            return r.json().get("data")
+        # fallback to method
+        r = await client.post(f"{ERS_API_URL}/api/method/frappe.client.get", json={"doctype": doctype, "name": name})
+        r.raise_for_status()
+        return r.json().get("message")
+
+
+@mcp.tool()
+async def ers_get_doc(doctype: str, name: str, access_token: Optional[str] = None) -> Any:
+    return await _ers_get_doc_impl(doctype=doctype, name=name, access_token=access_token)
+
+
+@mcp.tool()
+async def ers_insert(doc_json: str, access_token: Optional[str] = None) -> Any:
+    """Insert a document (doc_json must include 'doctype'). Uses frappe.client.insert."""
+    import json
+    try:
+        doc = json.loads(doc_json)
+    except Exception as e:
+        return {"error": f"invalid json: {e}"}
+    return await _frappe_insert(doc, access_token)
+
+
+@mcp.tool()
+async def ers_submit(doctype: str, name: str, access_token: Optional[str] = None) -> Any:
+    """Submit a document (docstatus -> 1) via frappe.client.submit."""
+    return await _frappe_submit(doctype, name, access_token)
+
+
+@mcp.tool()
+async def ers_cancel(doctype: str, name: str, access_token: Optional[str] = None) -> Any:
+    """Cancel a submitted document via frappe.client.cancel."""
+    return await _frappe_cancel(doctype, name, access_token)
+
+
+@mcp.tool()
+async def ers_set_value(doctype: str, name: str, fieldname: str, value: Any, access_token: Optional[str] = None) -> Any:
+    """Set a single value on a document."""
+    async with await _client_with_auth(access_token) as client:
+        r = await client.post(
+            f"{ERS_API_URL}/api/method/frappe.client.set_value",
+            json={"doctype": doctype, "name": name, "fieldname": fieldname, "value": value},
+        )
+        r.raise_for_status()
+        return r.json().get("message")
+
+
+async def _ers_run_method_impl(method: str, args_json: Optional[str] = None, access_token: Optional[str] = None) -> Any:
+    """Call an arbitrary whitelisted method, e.g., hrms.api.get_expense_approval_details."""
+    import json
+    payload: Dict[str, Any] = {}
+    if args_json:
+        try:
+            payload = json.loads(args_json)
+        except Exception:
+            payload = {"args": args_json}
+    async with await _client_with_auth(access_token) as client:
+        r = await client.post(f"{ERS_API_URL}/api/method/{method}", json=payload)
+        r.raise_for_status()
+        # Some methods return message; others return data
+        data = r.json()
+        return data.get("message", data.get("data", data))
+
+
+@mcp.tool()
+async def ers_run_method(method: str, args_json: Optional[str] = None, access_token: Optional[str] = None) -> Any:
+    return await _ers_run_method_impl(method=method, args_json=args_json, access_token=access_token)
+
+
+# ---- HRMS specific convenience wrappers -------------------------------------
+
+async def _ers_get_expense_approval_details_impl(employee: str, access_token: Optional[str] = None) -> Any:
+    """Wrapper for hrms.api.get_expense_approval_details."""
+    async with await _client_with_auth(access_token) as client:
+        r = await client.get(
+            f"{ERS_API_URL}/api/method/hrms.api.get_expense_approval_details",
+            params={"employee": employee},
+        )
+        r.raise_for_status()
+        return r.json().get("message")
+
+
+async def _ers_get_company_cost_center_and_expense_account_impl(company: str, access_token: Optional[str] = None) -> Any:
+    """Wrapper for hrms.api.get_company_cost_center_and_expense_account."""
+    async with await _client_with_auth(access_token) as client:
+        r = await client.get(
+            f"{ERS_API_URL}/api/method/hrms.api.get_company_cost_center_and_expense_account",
+            params={"company": company},
+        )
+        r.raise_for_status()
+        return r.json().get("message")
+
+
+@mcp.tool()
+async def ers_get_expense_approval_details(employee: str, access_token: Optional[str] = None) -> Any:
+    return await _ers_get_expense_approval_details_impl(employee=employee, access_token=access_token)
+
+
+@mcp.tool()
+async def ers_get_company_cost_center_and_expense_account(company: str, access_token: Optional[str] = None) -> Any:
+    return await _ers_get_company_cost_center_and_expense_account_impl(company=company, access_token=access_token)
+
+
+# ---- Leaves ------------------------------------------------------------------
+
+@mcp.tool()
+async def ers_leave_create(doc_json: str, access_token: Optional[str] = None) -> Any:
+    """Create a Leave Application document (doctype must be 'Leave Application')."""
+    import json
+    try:
+        doc = json.loads(doc_json)
+    except Exception as e:
+        return {"error": f"invalid json: {e}"}
+    return await _frappe_insert(doc, access_token)
+
+
+@mcp.tool()
+async def ers_leave_submit(name: str, access_token: Optional[str] = None) -> Any:
+    """Submit a Leave Application."""
+    return await _frappe_submit("Leave Application", name, access_token)
+
+
+@mcp.tool()
+async def ers_leave_cancel(name: str, access_token: Optional[str] = None) -> Any:
+    """Cancel a Leave Application."""
+    return await _frappe_cancel("Leave Application", name, access_token)
+
+
+@mcp.tool()
+async def ers_leave_list(filters_json: Optional[str] = None, limit_page_length: Optional[int] = 20, access_token: Optional[str] = None) -> Any:
+    """List Leave Application documents."""
+    return await _frappe_get_list(
+        "Leave Application",
+        filters_json=filters_json,
+        fields_json='["name","employee","from_date","to_date","status","leave_type"]',
+        limit_page_length=limit_page_length,
+        access_token=access_token,
+    )
+
+
+@mcp.tool()
+async def ers_leave_balance_on(employee: str, date: str, leave_type: str, access_token: Optional[str] = None) -> Any:
+    """Get leave balance on date (calls hrms.hr.doctype.leave_application.leave_application.get_leave_balance_on)."""
+    async with await _client_with_auth(access_token) as client:
+        r = await client.get(
+            f"{ERS_API_URL}/api/method/hrms.hr.doctype.leave_application.leave_application.get_leave_balance_on",
+            params={"employee": employee, "date": date, "leave_type": leave_type},
+        )
+        r.raise_for_status()
+        return r.json().get("message")
+
+
+# ---- Attendance & Shift ------------------------------------------------------
+
+@mcp.tool()
+async def ers_checkin(employee: str, log_type: str = "IN", time: Optional[str] = None, access_token: Optional[str] = None) -> Any:
+    """Create Employee Checkin (log_type IN/OUT). If time omitted, server time is used."""
+    doc: Dict[str, Any] = {"doctype": "Employee Checkin", "employee": employee, "log_type": log_type}
+    if time:
+        doc["time"] = time
+    return await _frappe_insert(doc, access_token)
+
+
+@mcp.tool()
+async def ers_attendance_list(filters_json: Optional[str] = None, limit_page_length: Optional[int] = 50, access_token: Optional[str] = None) -> Any:
+    """List Attendance docs (status: Present/Absent/Half Day)."""
+    return await ers_get_list("Attendance", filters_json=filters_json, fields_json='["name","employee","attendance_date","status"]', limit_page_length=limit_page_length, access_token=access_token)
+
+
+@mcp.tool()
+async def ers_shift_assignment_create(doc_json: str, access_token: Optional[str] = None) -> Any:
+    """Create a Shift Assignment document."""
+    import json
+    try:
+        doc = json.loads(doc_json)
+    except Exception as e:
+        return {"error": f"invalid json: {e}"}
+    return await _frappe_insert(doc, access_token)
+
+
+# ---- Expenses (additional helpers) ------------------------------------------
+
+@mcp.tool()
+async def ers_expense_create(doc_json: str, access_token: Optional[str] = None) -> Any:
+    """Create an Expense Claim document."""
+    import json
+    try:
+        doc = json.loads(doc_json)
+    except Exception as e:
+        return {"error": f"invalid json: {e}"}
+    return await _frappe_insert(doc, access_token)
+
+
+@mcp.tool()
+async def ers_expense_submit(name: str, access_token: Optional[str] = None) -> Any:
+    """Submit an Expense Claim."""
+    return await _frappe_submit("Expense Claim", name, access_token)
+
+
+@mcp.tool()
+async def ers_expense_cancel(name: str, access_token: Optional[str] = None) -> Any:
+    """Cancel an Expense Claim."""
+    return await _frappe_cancel("Expense Claim", name, access_token)
+
+
+# ---- Payroll (Salary Slip) ---------------------------------------------------
+
+@mcp.tool()
+async def ers_salary_slip_create(employee: str, start_date: str, end_date: str, company: Optional[str] = None, access_token: Optional[str] = None) -> Any:
+    """Create a Salary Slip document for an employee and period."""
+    import json
+    doc = {
+        "doctype": "Salary Slip",
+        "employee": employee,
+        "start_date": start_date,
+        "end_date": end_date,
+    }
+    if company:
+        doc["company"] = company
+    return await _frappe_insert(doc, access_token)
+
+
+@mcp.tool()
+async def ers_salary_slip_submit(name: str, access_token: Optional[str] = None) -> Any:
+    """Submit a Salary Slip."""
+    return await _frappe_submit("Salary Slip", name, access_token)
+
+
+@mcp.tool()
+async def ers_salary_slip_list(filters_json: Optional[str] = None, limit_page_length: Optional[int] = 20, access_token: Optional[str] = None) -> Any:
+    """List Salary Slips."""
+    return await _frappe_get_list(
+        "Salary Slip",
+        filters_json=filters_json,
+        fields_json='["name","employee","start_date","end_date","status","company"]',
+        limit_page_length=limit_page_length,
+        access_token=access_token,
+    )
+
+
+# ---- File Upload (attach to a DocType) --------------------------------------
+
+@mcp.tool()
+async def ers_upload_file(doctype: str, name: str, filename: str, content_b64: str, is_private: bool = True, access_token: Optional[str] = None) -> Any:
+    """Upload a file and attach to document (uses /api/method/upload_file)."""
+    import base64
+    token = _resolve_token(access_token)
+    files = {
+        "file": (filename, base64.b64decode(content_b64)),
+    }
+    data = {
+        "doctype": doctype,
+        "docname": name,
+        "is_private": 1 if is_private else 0,
+        "filename": filename,
+    }
+    async with await _client_with_auth(token) as client:
+        r = await client.post(f"{ERS_API_URL}/api/method/upload_file", data=data, files=files)
+        r.raise_for_status()
+        return r.json().get("message") or r.json()
+
+
+# ---- Payroll & Tax/Benefits --------------------------------------------------
+
+@mcp.tool()
+async def ers_salary_structure_list(filters_json: Optional[str] = None, limit_page_length: Optional[int] = 20, access_token: Optional[str] = None) -> Any:
+    """List Salary Structure."""
+    return await _frappe_get_list(
+        "Salary Structure",
+        filters_json=filters_json,
+        fields_json='["name","company","is_active"]',
+        limit_page_length=limit_page_length,
+        access_token=access_token,
+    )
+
+
+@mcp.tool()
+async def ers_salary_component_list(filters_json: Optional[str] = None, limit_page_length: Optional[int] = 50, access_token: Optional[str] = None) -> Any:
+    """List Salary Component."""
+    return await _frappe_get_list(
+        "Salary Component",
+        filters_json=filters_json,
+        fields_json='["name","type","company","disabled"]',
+        limit_page_length=limit_page_length,
+        access_token=access_token,
+    )
+
+
+@mcp.tool()
+async def ers_payroll_entry_create(doc_json: str, access_token: Optional[str] = None) -> Any:
+    """Create Payroll Entry."""
+    import json
+    try:
+        doc = json.loads(doc_json)
+    except Exception as e:
+        return {"error": f"invalid json: {e}"}
+    return await _frappe_insert(doc, access_token)
+
+
+@mcp.tool()
+async def ers_payroll_entry_submit(name: str, access_token: Optional[str] = None) -> Any:
+    """Submit Payroll Entry."""
+    return await _frappe_submit("Payroll Entry", name, access_token)
+
+
+@mcp.tool()
+async def ers_payroll_entry_list(filters_json: Optional[str] = None, limit_page_length: Optional[int] = 20, access_token: Optional[str] = None) -> Any:
+    """List Payroll Entry."""
+    return await _frappe_get_list(
+        "Payroll Entry",
+        filters_json=filters_json,
+        fields_json='["name","company","posting_date","status"]',
+        limit_page_length=limit_page_length,
+        access_token=access_token,
+    )
+
+
+@mcp.tool()
+async def ers_employee_benefit_application_create(doc_json: str, access_token: Optional[str] = None) -> Any:
+    """Create Employee Benefit Application."""
+    import json
+    try:
+        doc = json.loads(doc_json)
+    except Exception as e:
+        return {"error": f"invalid json: {e}"}
+    return await _frappe_insert(doc, access_token)
+
+
+@mcp.tool()
+async def ers_employee_benefit_application_submit(name: str, access_token: Optional[str] = None) -> Any:
+    """Submit Employee Benefit Application."""
+    return await _frappe_submit("Employee Benefit Application", name, access_token)
+
+
+@mcp.tool()
+async def ers_employee_benefit_application_list(filters_json: Optional[str] = None, limit_page_length: Optional[int] = 20, access_token: Optional[str] = None) -> Any:
+    """List Employee Benefit Applications."""
+    return await _frappe_get_list(
+        "Employee Benefit Application",
+        filters_json=filters_json,
+        fields_json='["name","employee","benefit_type","status","company"]',
+        limit_page_length=limit_page_length,
+        access_token=access_token,
+    )
+
+
+@mcp.tool()
+async def ers_employee_tax_exemption_declaration_create(doc_json: str, access_token: Optional[str] = None) -> Any:
+    """Create Employee Tax Exemption Declaration."""
+    import json
+    try:
+        doc = json.loads(doc_json)
+    except Exception as e:
+        return {"error": f"invalid json: {e}"}
+    return await _frappe_insert(doc, access_token)
+
+
+@mcp.tool()
+async def ers_employee_tax_exemption_declaration_list(filters_json: Optional[str] = None, limit_page_length: Optional[int] = 20, access_token: Optional[str] = None) -> Any:
+    """List Employee Tax Exemption Declarations."""
+    return await _frappe_get_list(
+        "Employee Tax Exemption Declaration",
+        filters_json=filters_json,
+        fields_json='["name","employee","company","fiscal_year","status"]',
+        limit_page_length=limit_page_length,
+        access_token=access_token,
+    )
+
+
+# ---- Performance -------------------------------------------------------------
+
+@mcp.tool()
+async def ers_goal_create(doc_json: str, access_token: Optional[str] = None) -> Any:
+    """Create Goal."""
+    import json
+    try:
+        doc = json.loads(doc_json)
+    except Exception as e:
+        return {"error": f"invalid json: {e}"}
+    return await _frappe_insert(doc, access_token)
+
+
+@mcp.tool()
+async def ers_goal_list(filters_json: Optional[str] = None, limit_page_length: Optional[int] = 50, access_token: Optional[str] = None) -> Any:
+    """List Goals."""
+    return await _frappe_get_list(
+        "Goal",
+        filters_json=filters_json,
+        fields_json='["name","employee","goal_name","status","from_date","to_date"]',
+        limit_page_length=limit_page_length,
+        access_token=access_token,
+    )
+
+
+@mcp.tool()
+async def ers_performance_feedback_create(doc_json: str, access_token: Optional[str] = None) -> Any:
+    """Create Performance Feedback."""
+    import json
+    try:
+        doc = json.loads(doc_json)
+    except Exception as e:
+        return {"error": f"invalid json: {e}"}
+    return await _frappe_insert(doc, access_token)
+
+
+@mcp.tool()
+async def ers_performance_feedback_list(filters_json: Optional[str] = None, limit_page_length: Optional[int] = 50, access_token: Optional[str] = None) -> Any:
+    """List Performance Feedback."""
+    return await _frappe_get_list(
+        "Performance Feedback",
+        filters_json=filters_json,
+        fields_json='["name","employee","feedback_by","status","date"]',
+        limit_page_length=limit_page_length,
+        access_token=access_token,
+    )
+
+
+# ---- Recruitment -------------------------------------------------------------
+
+@mcp.tool()
+async def ers_job_applicant_create(doc_json: str, access_token: Optional[str] = None) -> Any:
+    """Create Job Applicant."""
+    import json
+    try:
+        doc = json.loads(doc_json)
+    except Exception as e:
+        return {"error": f"invalid json: {e}"}
+    return await _frappe_insert(doc, access_token)
+
+
+@mcp.tool()
+async def ers_job_applicant_list(filters_json: Optional[str] = None, limit_page_length: Optional[int] = 50, access_token: Optional[str] = None) -> Any:
+    """List Job Applicants."""
+    return await _frappe_get_list(
+        "Job Applicant",
+        filters_json=filters_json,
+        fields_json='["name","applicant_name","email_id","status","job_title"]',
+        limit_page_length=limit_page_length,
+        access_token=access_token,
+    )
+
+
+@mcp.tool()
+async def ers_interview_create(doc_json: str, access_token: Optional[str] = None) -> Any:
+    """Create Interview."""
+    import json
+    try:
+        doc = json.loads(doc_json)
+    except Exception as e:
+        return {"error": f"invalid json: {e}"}
+    return await _frappe_insert(doc, access_token)
+
+
+@mcp.tool()
+async def ers_interview_list(filters_json: Optional[str] = None, limit_page_length: Optional[int] = 50, access_token: Optional[str] = None) -> Any:
+    """List Interviews."""
+    return await _frappe_get_list(
+        "Interview",
+        filters_json=filters_json,
+        fields_json='["name","job_applicant","interview_round","status","start_time"]',
+        limit_page_length=limit_page_length,
+        access_token=access_token,
+    )
+
+
+@mcp.tool()
+async def ers_interview_feedback_create(doc_json: str, access_token: Optional[str] = None) -> Any:
+    """Create Interview Feedback."""
+    import json
+    try:
+        doc = json.loads(doc_json)
+    except Exception as e:
+        return {"error": f"invalid json: {e}"}
+    return await _frappe_insert(doc, access_token)
+
+
+@mcp.tool()
+async def ers_interview_feedback_list(filters_json: Optional[str] = None, limit_page_length: Optional[int] = 50, access_token: Optional[str] = None) -> Any:
+    """List Interview Feedback."""
+    return await _frappe_get_list(
+        "Interview Feedback",
+        filters_json=filters_json,
+        fields_json='["name","job_applicant","interviewer","interview_round","status","date"]',
+        limit_page_length=limit_page_length,
+        access_token=access_token,
+    )
+
+
+@mcp.tool()
+async def ers_job_offer_create(doc_json: str, access_token: Optional[str] = None) -> Any:
+    """Create Job Offer."""
+    import json
+    try:
+        doc = json.loads(doc_json)
+    except Exception as e:
+        return {"error": f"invalid json: {e}"}
+    return await _frappe_insert(doc, access_token)
+
+
+@mcp.tool()
+async def ers_job_offer_submit(name: str, access_token: Optional[str] = None) -> Any:
+    """Submit Job Offer."""
+    return await _frappe_submit("Job Offer", name, access_token)
+
+
+@mcp.tool()
+async def ers_job_offer_list(filters_json: Optional[str] = None, limit_page_length: Optional[int] = 50, access_token: Optional[str] = None) -> Any:
+    """List Job Offers."""
+    return await _frappe_get_list(
+        "Job Offer",
+        filters_json=filters_json,
+        fields_json='["name","job_applicant","offer_date","status","designation"]',
+        limit_page_length=limit_page_length,
+        access_token=access_token,
+    )
+
+
+# ---- Tenure / Lifecycle ------------------------------------------------------
+
+@mcp.tool()
+async def ers_exit_interview_create(doc_json: str, access_token: Optional[str] = None) -> Any:
+    """Create Exit Interview."""
+    import json
+    try:
+        doc = json.loads(doc_json)
+    except Exception as e:
+        return {"error": f"invalid json: {e}"}
+    return await _frappe_insert(doc, access_token)
+
+
+@mcp.tool()
+async def ers_exit_interview_list(filters_json: Optional[str] = None, limit_page_length: Optional[int] = 20, access_token: Optional[str] = None) -> Any:
+    """List Exit Interviews."""
+    return await _frappe_get_list(
+        "Exit Interview",
+        filters_json=filters_json,
+        fields_json='["name","employee","exit_interview_date","status"]',
+        limit_page_length=limit_page_length,
+        access_token=access_token,
+    )
+
+
+@mcp.tool()
+async def ers_full_and_final_statement_create(doc_json: str, access_token: Optional[str] = None) -> Any:
+    """Create Full and Final Statement."""
+    import json
+    try:
+        doc = json.loads(doc_json)
+    except Exception as e:
+        return {"error": f"invalid json: {e}"}
+    return await _frappe_insert(doc, access_token)
+
+
+@mcp.tool()
+async def ers_full_and_final_statement_submit(name: str, access_token: Optional[str] = None) -> Any:
+    """Submit Full and Final Statement."""
+    return await _frappe_submit("Full and Final Statement", name, access_token)
+
+
+@mcp.tool()
+async def ers_full_and_final_statement_list(filters_json: Optional[str] = None, limit_page_length: Optional[int] = 20, access_token: Optional[str] = None) -> Any:
+    """List Full and Final Statements."""
+    return await _frappe_get_list(
+        "Full and Final Statement",
+        filters_json=filters_json,
+        fields_json='["name","employee","status","company"]',
+        limit_page_length=limit_page_length,
+        access_token=access_token,
+    )
+
+@Request.application
+def application(request: Request) -> Response:
+    """Werkzeug WSGI entrypoint that delegates to frappe_mcp.MCP."""
+    response = Response()
+    return mcp.handle(request, response)
+
+
+def main() -> None:
+    env_port = os.getenv("PORT", "").strip()
+    if env_port.isdigit():
+        port = int(env_port)
+    else:
+        port = _port_from_registry(8859)
+    # Bind on all interfaces similar to other MCP servers; path is '/' for MCP.
+    run_simple("0.0.0.0", port, application)
+
+
+if __name__ == "__main__":
+    main()
+