@tasksai/install 0.1.29 → 0.1.30

package/README.md

@@ -75,3 +75,15 @@ folder. The save tool supports `.docx` and Markdown output, sanitizes filenames,
 and avoids overwriting existing files unless explicitly told to overwrite.
 Generated document content is handled by the customer's AI framework and local
 MCP runtime; it is not sent to TasksAI websites or APIs.
+
+## Realtor jurisdiction sources
+
+For jurisdiction-sensitive RealtorTasksAI workflows, the local runtime sends
+only the selected skill ID and general state, county, city, public-authority,
+and MLS labels to the TasksAI API. It never sends the user's prompt, property
+address, client facts, uploaded records, or generated document.
+
+The API returns a reviewed source pack when one exists. If it does not, the
+licensed runtime can request a controlled official-web lookup. Live results are
+cached, source-linked, and visibly labeled `provisional`; they never substitute
+for private MLS rules, brokerage policy, approved forms, or professional review.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tasksai/install",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "description": "Shared TasksAI MCP installer CLI",
   "type": "module",
   "bin": {

package/runtime/server.py

@@ -125,7 +125,7 @@ if not LICENSE_KEY:
     print("Find your key in your purchase confirmation email.", file=sys.stderr, flush=True)
     sys.exit(1)
 
-SERVER_VERSION = "2.4.5"
+SERVER_VERSION = "2.5.0"
 
 AUTH_HEADERS = {
     "Authorization":    f"Bearer {LICENSE_KEY}",
@@ -509,8 +509,8 @@ async def api_get(path):
         return resp.json()
 
 
-async def api_post(path, payload):
-    async with httpx.AsyncClient(timeout=10.0) as client:
+async def api_post(path, payload, *, timeout=10.0):
+    async with httpx.AsyncClient(timeout=timeout) as client:
         resp = await client.post(
             f"{API_BASE}{path}",
             json=payload,
@@ -523,20 +523,58 @@ async def api_post(path, payload):
 def jurisdiction_sources_path(arguments):
     """Build a metadata-only source lookup path without customer or property data."""
     skill_id = (arguments.get("skill_id") or "").strip()
-    state = (arguments.get("state") or "").strip()
+    state = general_authority_label(arguments.get("state"), "state")
     if not skill_id:
         raise ValueError("skill_id is required.")
 
     params = {"skill_id": skill_id}
     if state:
         params["state"] = state
-    for field in ("county", "locality", "district"):
-        value = (arguments.get(field) or "").strip()
+    for field in ("county", "locality", "district", "mls"):
+        value = general_authority_label(arguments.get(field), field)
         if value:
             params[field] = value
     return f"/v1/skills/jurisdiction-sources?{urlencode(params)}"
 
 
+_GENERAL_AUTHORITY_LABEL = re.compile(r"^[A-Za-z0-9 .,'&()/-]{1,240}$")
+_LIKELY_STREET_ADDRESS = re.compile(
+    r"^\d+\s+.+\b(?:street|st|avenue|ave|road|rd|drive|dr|lane|ln|boulevard|blvd|court|ct|way)\b",
+    re.IGNORECASE,
+)
+
+
+def general_authority_label(value, field):
+    """Normalize a public authority label and reject likely customer data."""
+    normalized = " ".join(str(value or "").strip().split())
+    if not normalized:
+        return None
+    if (
+        not _GENERAL_AUTHORITY_LABEL.fullmatch(normalized)
+        or _LIKELY_STREET_ADDRESS.search(normalized)
+    ):
+        raise ValueError(
+            f"{field} must be a general authority label, not an address or customer record."
+        )
+    return normalized
+
+
+def jurisdiction_research_payload(arguments):
+    """Build the privacy-safe research request sent only after reviewed lookup misses."""
+    payload = {}
+    for field in ("skill_id", "state", "county", "locality", "district", "mls"):
+        value = (
+            (arguments.get(field) or "").strip()
+            if field == "skill_id"
+            else general_authority_label(arguments.get(field), field)
+        )
+        if value:
+            payload[field] = value
+    if not payload.get("skill_id") or not payload.get("state"):
+        raise ValueError("skill_id and state are required for live jurisdiction research.")
+    return payload
+
+
 def format_jurisdiction_source_pack(pack):
     """Render the public source pack as compact instructions for the local AI."""
     status = pack.get("status", "unsupported")
@@ -548,6 +586,7 @@ def format_jurisdiction_source_pack(pack):
         f"- Skill: `{pack.get('skill_id', '')}`",
         f"- Registry reviewed: {pack.get('registry_reviewed_on', 'not supplied')}",
         f"- Registry refresh due: {pack.get('registry_refresh_due_on', 'not supplied')}",
+        f"- Resolution: **{pack.get('resolution_source', 'packaged')}**",
     ]
     if pack.get("state_name"):
         lines.append(f"- State: {pack['state_name']} ({pack.get('state_code', '')})")
@@ -566,6 +605,8 @@ def format_jurisdiction_source_pack(pack):
         lines.extend(["", "## Sources"])
         for source in sources:
             effective = source.get("effective_date") or "not specified"
+            verification = source.get("verification_status", "reviewed")
+            date_label = "Machine researched" if verification == "machine_researched" else "Reviewed"
             lines.extend(
                 [
                     "",
@@ -573,7 +614,8 @@ def format_jurisdiction_source_pack(pack):
                     f"- Authority: {source.get('authority', '')}",
                     f"- Jurisdiction: {source.get('jurisdiction', '')} ({source.get('scope_type', 'scope not supplied')})",
                     f"- Effective date: {effective}",
-                    f"- Reviewed: {source.get('reviewed_on', '')}",
+                    f"- Verification: {verification}",
+                    f"- {date_label}: {source.get('reviewed_on', '')}",
                     f"- Refresh due: {source.get('refresh_due_on', '')}",
                     f"- URL: {source.get('url', '')}",
                     f"- Use: {source.get('purpose', '')}",
@@ -1672,8 +1714,9 @@ def build_tools(prefix, product_name, occupation):
             Tool(
                 name=f"{prefix}_jurisdiction_sources",
                 description=(
-                    f"Retrieve the curated current jurisdiction-and-authority source pack for a jurisdiction-sensitive {product_name} workflow. "
+                    f"Retrieve the current jurisdiction-and-authority sources for a jurisdiction-sensitive {product_name} workflow. "
                     "Use after the applicable state is known and before applying state, local, district, regulator, form, or policy requirements. "
+                    "For RealtorTasksAI, a missing reviewed pack can trigger a licensed, privacy-safe official-web lookup whose results are explicitly provisional. "
                     "Send only the skill ID and general authority labels; never send an address, person name, student or client facts, documents, or generated content."
                 ),
                 inputSchema={
@@ -1699,6 +1742,10 @@ def build_tools(prefix, product_name, occupation):
                             "type": "string",
                             "description": "Optional public authority or school-district name only; do not include a person, student, or record identifier.",
                         },
+                        "mls": {
+                            "type": "string",
+                            "description": "Optional MLS or Realtor-association name only; never send credentials, listing data, or member-only content.",
+                        },
                     },
                     "required": ["skill_id"],
                 },
@@ -1905,6 +1952,24 @@ async def call_tool(name, arguments):
         }:
             path = jurisdiction_sources_path(arguments or {})
             result = await api_get(path)
+            if (
+                prefix == "realtortasksai"
+                and (arguments or {}).get("state")
+                and result.get("status") not in {"ready", "provisional"}
+            ):
+                try:
+                    result = await api_post(
+                        "/v1/skills/jurisdiction-research",
+                        jurisdiction_research_payload(arguments or {}),
+                        timeout=90.0,
+                    )
+                except Exception:
+                    result = dict(result)
+                    instructions = list(result.get("instructions") or [])
+                    instructions.append(
+                        "Controlled live research was unavailable. Continue only with intake or professional-supplied current official sources; do not substitute another jurisdiction."
+                    )
+                    result["instructions"] = instructions
             return [TextContent(type="text", text=format_jurisdiction_source_pack(result))]
 
         # ── Save Document ───────────────────────────────────────────────────