@tasksai/install 0.1.28 → 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.28",
+  "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.4"
+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', '')}",
@@ -1436,11 +1478,85 @@ def write_markdown(path, title, content_markdown, product_name):
     path.write_text("\n\n".join(part for part in parts if part), encoding="utf-8")
 
 
+def reconcile_public_copy_counts(content_markdown):
+    """Replace stale public-copy counts with deterministic local counts.
+
+    AI hosts sometimes leave ``NOT VERIFIED`` or an estimated count beside a
+    marked public-copy body. The local runtime can resolve that mechanical
+    value without transmitting the document. It changes only count lines tied
+    to balanced PUBLIC COPY markers and a detectable numeric maximum.
+    """
+    start_marker = "<!-- PUBLIC COPY START -->"
+    end_marker = "<!-- PUBLIC COPY END -->"
+    if content_markdown.count(start_marker) != content_markdown.count(end_marker):
+        return content_markdown
+
+    blocks = list(
+        re.finditer(
+            re.escape(start_marker) + r"\n?(.*?)\n?" + re.escape(end_marker),
+            content_markdown,
+            re.DOTALL,
+        )
+    )
+    if not blocks:
+        return content_markdown
+
+    count_pattern = re.compile(
+        r"(?im)^(?P<prefix>\s*(?:\*\*)?Deterministic count:(?:\*\*)?\s*)"
+        r"(?P<actual>NOT VERIFIED|[\d,]+)"
+        r"(?:\s*/\s*(?P<target>[\d,]+)\s*(?P<unit>words|characters))?\s*$"
+    )
+    limit_patterns = (
+        re.compile(r"(?i)\bmaximum(?:\s+public[- ]copy\s+length)?\s+(?:is\s+)?([\d,]+)\s*(words|characters)\b"),
+        re.compile(r"(?i)\bmax(?:imum)?\s*[:=]?\s*([\d,]+)\s*(words|characters)\b"),
+        re.compile(r"(?i)\b([\d,]+)[ -](word|character)\s+maximum\b"),
+    )
+
+    replacements = []
+    count_matches = list(count_pattern.finditer(content_markdown))
+    for block in blocks:
+        following = [match for match in count_matches if match.start() >= block.end()]
+        if not following:
+            continue
+        count_match = min(following, key=lambda match: match.start() - block.end())
+        if count_match.start() - block.end() > 2000:
+            continue
+
+        target_text = count_match.group("target")
+        unit = (count_match.group("unit") or "").lower()
+        if not target_text or not unit:
+            limit_match = None
+            for pattern in limit_patterns:
+                limit_match = pattern.search(content_markdown)
+                if limit_match:
+                    break
+            if not limit_match:
+                continue
+            target_text = limit_match.group(1)
+            unit = limit_match.group(2).lower()
+            if unit == "word":
+                unit = "words"
+            elif unit == "character":
+                unit = "characters"
+
+        target = int(target_text.replace(",", ""))
+        body = block.group(1)
+        actual = len(body) if unit == "characters" else len(re.findall(r"\S+", body))
+        replacement = f"{count_match.group('prefix')}{actual} / {target} {unit}"
+        replacements.append((count_match.start(), count_match.end(), replacement))
+
+    corrected = content_markdown
+    for start, end, replacement in reversed(replacements):
+        corrected = corrected[:start] + replacement + corrected[end:]
+    return corrected
+
+
 def save_document(arguments, product_name):
     """Save AI-produced final content to a local downloadable file."""
     content_markdown = (arguments.get("content_markdown") or arguments.get("content") or "").strip()
     if not content_markdown:
         raise ValueError("content_markdown is required.")
+    content_markdown = reconcile_public_copy_counts(content_markdown)
 
     title = (arguments.get("title") or "").strip()
     skill_id = (arguments.get("skill_id") or "").strip()
@@ -1598,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={
@@ -1625,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"],
                 },
@@ -1831,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 ───────────────────────────────────────────────────