booking-agent-cli 0.8.0__tar.gz → 0.9.0__tar.gz

{booking_agent_cli-0.8.0 → booking_agent_cli-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: booking-agent-cli
-Version: 0.8.0
+Version: 0.9.0
 Summary: The Booking Agent CLI: a stateful USP booking flow with hard gates, plus its USP protocol library.
 Project-URL: Homepage, https://github.com/wix/booking-agent
 Project-URL: Documentation, https://github.com/wix/booking-agent/blob/master/booking-agent/README.md
@@ -78,7 +78,7 @@ Each release also publishes that skill at an immutable `skill-v<version>` tag an
 the release workflow, so a harness can pin and verify the exact text it follows:
 
 ```bash
-curl -fsSLO https://raw.githubusercontent.com/wix/booking-agent/skill-v0.56.0/booking-agent/skills/booking-agent/SKILL.md
+curl -fsSLO https://raw.githubusercontent.com/wix/booking-agent/skill-v0.57.0/booking-agent/skills/booking-agent/SKILL.md
 gh attestation verify SKILL.md --repo wix/booking-agent \
   --signer-workflow wix/booking-agent/.github/workflows/release.yml
 ```

{booking_agent_cli-0.8.0 → booking_agent_cli-0.9.0}/README.md

@@ -36,7 +36,7 @@ Each release also publishes that skill at an immutable `skill-v<version>` tag an
 the release workflow, so a harness can pin and verify the exact text it follows:
 
 ```bash
-curl -fsSLO https://raw.githubusercontent.com/wix/booking-agent/skill-v0.56.0/booking-agent/skills/booking-agent/SKILL.md
+curl -fsSLO https://raw.githubusercontent.com/wix/booking-agent/skill-v0.57.0/booking-agent/skills/booking-agent/SKILL.md
 gh attestation verify SKILL.md --repo wix/booking-agent \
   --signer-workflow wix/booking-agent/.github/workflows/release.yml
 ```

{booking_agent_cli-0.8.0 → booking_agent_cli-0.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "booking-agent-cli"
-version = "0.8.0"
+version = "0.9.0"
 description = "The Booking Agent CLI: a stateful USP booking flow with hard gates, plus its USP protocol library."
 readme = "README.md"
 license = "Apache-2.0"

{booking_agent_cli-0.8.0 → booking_agent_cli-0.9.0}/src/booking_agent/__init__.py

@@ -3,4 +3,4 @@
 Ships in the booking-agent-cli wheel and never imports ``booking_agent_cli``.
 """
 
-__version__ = "0.8.0"
+__version__ = "0.9.0"

{booking_agent_cli-0.8.0 → booking_agent_cli-0.9.0}/src/booking_agent/backend/live.py

@@ -33,6 +33,7 @@ from ..rest_client import (
     USPTokenStore,
 )
 from ..headless import attach_registry_hit, mark_live_catalog_service, service_from_registry_hit
+from ..faults import record_silent_fault
 from ..authorization import BookingScopedCredential, evaluate, resolve_posture
 from ..pop import PopKey, PopKeyStore
 from ..ucp_profile import UcpNativeContext, fetch_and_resolve_business_profile
@@ -115,39 +116,41 @@ class LiveUSPBackend(USPBackend):
             decision=decision,
         )
 
+    # Discovery absorbs these failures, so they stay at debug level: a warning reaches
+    # stderr, which agent hosts merge into the stdout JSON they parse.
     @staticmethod
     def _log_profile_failure(profile_url: str, exc: BaseException) -> None:
         if is_rate_limited(exc):
-            logger.warning(
+            logger.debug(
                 "Profile resolution rate limited (HTTP 429) for %s",
                 profile_url,
             )
             return
         if isinstance(exc, httpx.HTTPStatusError):
-            logger.warning(
+            logger.debug(
                 "Profile resolution HTTP %s for %s",
                 exc.response.status_code,
                 profile_url,
             )
             return
-        logger.warning("Profile resolution failed for %s", profile_url)
+        logger.debug("Profile resolution failed for %s: %s: %s", profile_url, type(exc).__name__, exc)
 
     @staticmethod
     def _log_service_failure(service_id: str, exc: BaseException) -> None:
         if is_rate_limited(exc):
-            logger.warning(
+            logger.debug(
                 "Service catalog fetch rate limited (HTTP 429) for %s",
                 service_id,
             )
             return
         if isinstance(exc, httpx.HTTPStatusError):
-            logger.warning(
+            logger.debug(
                 "Service catalog fetch HTTP %s for %s",
                 exc.response.status_code,
                 service_id,
             )
             return
-        logger.warning("Service fetch failed: %s", service_id)
+        logger.debug("Service fetch failed: %s: %s", service_id, type(exc).__name__)
 
     # -- Registry-level ------------------------------------------------------
 
@@ -184,6 +187,9 @@ class LiveUSPBackend(USPBackend):
             self._log_profile_failure(profile_url, exc)
             if is_rate_limited(exc):
                 raise
+            record_silent_fault(
+                "profile_resolve", exc, profile_url=profile_url, business_id=biz_id,
+            )
 
     async def search_registry(self, intent: ServiceSearchIntent) -> List[USPService]:
         if not self._cfg.usp_registry_url:
@@ -289,6 +295,10 @@ class LiveUSPBackend(USPBackend):
                     if is_rate_limited(exc):
                         rate_limited_exc = exc
                         raise
+                    record_silent_fault(
+                        "catalog_enrich", exc, profile_url=profile_url,
+                        business_id=biz_id, service_id=r.service_id,
+                    )
                     return attach_registry_hit(
                         service_from_registry_hit(r), r, rank=rank,
                     )

{booking_agent_cli-0.8.0 → booking_agent_cli-0.9.0}/src/booking_agent/defaults.env

@@ -43,6 +43,12 @@ BOOKING_AGENT_DISCOVERY_CONCURRENCY=8
 BOOKING_AGENT_PROFILE_CACHE_TTL_SECONDS=900
 # 1 writes a redacted request log to <session dir>/http_trace.log.
 BOOKING_AGENT_HTTP_TRACE=0
+# 1 writes money-path JSON event lines to stderr. Off by default because many
+# agent hosts merge stderr into the stdout JSON they parse.
+BOOKING_AGENT_STDERR_EVENTS=0
+# 0 stops automatic fault reports: faults the user never saw, about a business's
+# profile or catalog or the assistant's own code, sent with no user data.
+BOOKING_AGENT_FAULT_REPORTS=1
 
 # --- Address -------------------------------------------------------------------
 BOOKING_AGENT_GEOCODER_URL=https://nominatim.openstreetmap.org/search

booking_agent_cli-0.9.0/src/booking_agent/faults.py

@@ -0,0 +1,154 @@
+"""Faults the client absorbed, so the user never saw them.
+
+Code that catches an exception and carries on (a business profile that cannot be
+read during discovery, a catalog entry that cannot be fetched) calls
+``record_silent_fault``. Warnings logged by the allowed modules during a command are
+collected the same way. The CLI decides at the end of the command whether these
+become automatic fault reports; nothing here does I/O.
+
+Only structural facts are kept: the step, the exception type, a code-authored log
+format string, and public identifiers of the business involved. Exception messages
+and log arguments are never kept, because they can carry anything.
+"""
+from __future__ import annotations
+
+import logging
+import re
+from typing import Any, Dict, List, Optional
+from urllib.parse import urlsplit
+
+#: Steps whose outcome never depends on the user's own accounts or data.
+STEPS = frozenset({
+    "registry_search",
+    "profile_resolve",
+    "catalog_enrich",
+    "availability_prefetch",
+    "platform_profile",
+    "cli",
+})
+#: Loggers whose warnings count as degraded results. Link, payment, identity, buyer
+#: details, and Google Calendar code is not here: their faults stay on the consented path.
+WARNING_LOGGERS = (
+    "booking_agent.backend.live",
+    "booking_agent.discovery",
+    "booking_agent.headless",
+    "booking_agent.ucp_profile",
+    "booking_agent.profile_cache",
+)
+_MAX_RECORDED = 50
+_SLUG_RE = re.compile(r"[^a-z0-9]+")
+
+_recorded: List[Dict[str, Any]] = []
+
+
+def _reason(exc: Optional[BaseException]) -> Optional[str]:
+    if exc is None:
+        return None
+    response = getattr(exc, "response", None)
+    status = getattr(response, "status_code", None)
+    if isinstance(status, int):
+        return f"http_{status}"
+    from booking_agent.ucp_profile import UcpProfileValidationError
+
+    if isinstance(exc, UcpProfileValidationError) and exc.args and isinstance(exc.args[0], str):
+        # Validation messages are written in this package and name only profile fields.
+        slug = _SLUG_RE.sub("_", exc.args[0].lower()).strip("_")
+        return slug[:64] or None
+    return None
+
+
+def _subject(profile_url: Optional[str], **ids: Any) -> Dict[str, Any]:
+    subject: Dict[str, Any] = {}
+    if profile_url:
+        try:
+            parts = urlsplit(profile_url)
+        except ValueError:
+            parts = None
+        if parts is not None and parts.scheme in ("http", "https") and parts.hostname:
+            subject["host"] = parts.hostname
+            subject["path"] = parts.path or "/"
+    for key, value in ids.items():
+        if value is not None:
+            subject[key] = value
+    return subject
+
+
+def record_silent_fault(
+    step: str,
+    exc: Optional[BaseException] = None,
+    *,
+    profile_url: Optional[str] = None,
+    business_id: Optional[str] = None,
+    service_id: Optional[str] = None,
+) -> None:
+    """Note a fault this code absorbed. Never raises."""
+    try:
+        if len(_recorded) >= _MAX_RECORDED:
+            return
+        response = getattr(exc, "response", None)
+        status = getattr(response, "status_code", None)
+        _recorded.append({
+            "fault_class": "absorbed_exception",
+            "step": step if step in STEPS else "cli",
+            "exception_type": _qualname(exc),
+            "message_template": None,
+            "reason_code": _reason(exc),
+            "subject": _subject(
+                profile_url,
+                business_id=business_id,
+                service_ids=[service_id] if service_id else None,
+                http_status=status if isinstance(status, int) else None,
+            ),
+        })
+    except Exception:
+        pass
+
+
+def _qualname(exc: Optional[BaseException]) -> Optional[str]:
+    if exc is None:
+        return None
+    cls = type(exc)
+    return f"{cls.__module__}.{cls.__qualname__}"
+
+
+class _WarningCollector(logging.Handler):
+    """Keeps the format string of each warning; the formatted text is never stored."""
+
+    def __init__(self) -> None:
+        super().__init__(level=logging.WARNING)
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            if not record.name.startswith(WARNING_LOGGERS) or len(_recorded) >= _MAX_RECORDED:
+                return
+            exc = record.exc_info[1] if record.exc_info else None
+            _recorded.append({
+                "fault_class": "degraded_result",
+                "step": "cli",
+                "exception_type": _qualname(exc),
+                "message_template": record.msg if isinstance(record.msg, str) else None,
+                "reason_code": None,
+                "subject": {"logger": record.name},
+            })
+        except Exception:
+            pass
+
+
+_collector: Optional[_WarningCollector] = None
+
+
+def install_warning_collector() -> None:
+    """Collect allowed warnings instead of printing them to stderr (idempotent)."""
+    global _collector
+    if _collector is not None:
+        return
+    _collector = _WarningCollector()
+    for name in ("booking_agent", "booking_agent_cli"):
+        logging.getLogger(name).addHandler(_collector)
+
+
+def drain() -> List[Dict[str, Any]]:
+    """Every fault recorded so far, cleared."""
+    out = list(_recorded)
+    _recorded.clear()
+    return out

{booking_agent_cli-0.8.0 → booking_agent_cli-0.9.0}/src/booking_agent/observability.py

@@ -9,6 +9,8 @@ from typing import Any, Callable, Dict, Optional
 
 import httpx
 
+from booking_agent import settings
+
 # Wire name for the flow join key. Optional on the USP HTTP binding (Track S of
 # spec issue #160): send when bound, never require it on responses, never fail a
 # call because a peer omitted or ignored it.
@@ -35,9 +37,14 @@ _FORBIDDEN_FIELD_KEYS = frozenset({
 })
 
 _correlation_id: ContextVar[Optional[str]] = ContextVar("booking_agent_correlation_id", default=None)
-_event_sink: Callable[[Dict[str, Any]], None] = lambda record: sys.stderr.write(
-    json.dumps(record, default=str) + "\n"
-)
+
+
+def _default_sink(record: Dict[str, Any]) -> None:
+    if settings.get_bool("BOOKING_AGENT_STDERR_EVENTS"):
+        sys.stderr.write(json.dumps(record, default=str) + "\n")
+
+
+_event_sink: Callable[[Dict[str, Any]], None] = _default_sink
 
 
 def set_event_sink(sink: Callable[[Dict[str, Any]], None]) -> None:
@@ -49,7 +56,7 @@ def set_event_sink(sink: Callable[[Dict[str, Any]], None]) -> None:
 def reset_event_sink() -> None:
     """Restore the default stderr event sink."""
     global _event_sink
-    _event_sink = lambda record: sys.stderr.write(json.dumps(record, default=str) + "\n")
+    _event_sink = _default_sink
 
 
 def new_correlation_id() -> str:

{booking_agent_cli-0.8.0 → booking_agent_cli-0.9.0}/src/booking_agent/ucp_profile.py

@@ -169,10 +169,11 @@ class UcpNativeContext(BaseModel):
                 continue
             if "authorization" in binding:
                 logger.warning(
-                    f"{SVC_SERVICES} binding declares a sibling 'authorization' member, "
+                    "%s binding declares a sibling 'authorization' member, "
                     "which USP prohibits; the policy MUST be published as "
                     "config.authorization. Treating this business as publishing no "
-                    "policy."
+                    "policy.",
+                    SVC_SERVICES,
                 )
                 misplaced = True
                 continue

{booking_agent_cli-0.8.0 → booking_agent_cli-0.9.0}/src/booking_agent_cli/__init__.py

@@ -1,3 +1,3 @@
 """booking_agent_cli: typer-based stateful CLI for USP booking flows."""
 
-__version__ = "0.8.0"
+__version__ = "0.9.0"

{booking_agent_cli-0.8.0 → booking_agent_cli-0.9.0}/src/booking_agent_cli/booking_summary.py

@@ -6,6 +6,7 @@ address, and price.
 """
 from __future__ import annotations
 
+import re
 from typing import Any, Dict, List, Optional
 
 from . import timezone_context as tz_context
@@ -114,6 +115,174 @@ def price_text(session: Any, price_info: Dict[str, Any]) -> Optional[str]:
     return f"{price}, charged now to your Link wallet"
 
 
+_ISO_DURATION_RE = re.compile(
+    r"^P(?:(?P<days>\d+)D)?(?:T(?:(?P<hours>\d+)H)?(?:(?P<minutes>\d+)M)?)?$"
+)
+# Links a checkout returns that are actions, not terms the business publishes.
+_ACTION_LINK_TYPES = frozenset({"continue"})
+
+
+def _duration_text(value: Any) -> Optional[str]:
+    """``PT24H`` -> ``24 hours``; anything else is returned as the business wrote it."""
+    if not isinstance(value, str) or not value.strip():
+        return None
+    match = _ISO_DURATION_RE.match(value.strip().upper())
+    if not match or not any(match.groupdict().values()):
+        return value.strip()
+    parts = []
+    for unit in ("days", "hours", "minutes"):
+        amount = match.group(unit)
+        if amount and int(amount):
+            word = unit if int(amount) != 1 else unit[:-1]
+            parts.append(f"{int(amount)} {word}")
+    return " ".join(parts) or "0 minutes"
+
+
+def _fee_text(amount: Any, live: Dict[str, Any]) -> Optional[str]:
+    if not isinstance(amount, int) or amount <= 0:
+        return None
+    from .catalog import _format_price_display
+
+    pricing = live.get("pricing") if isinstance(live.get("pricing"), dict) else {}
+    return _format_price_display(amount, pricing.get("currency")) or str(amount)
+
+
+def service_policy_lines(live_service: Any) -> List[str]:
+    """The cancellation and rescheduling policies the business published for the service.
+
+    ``allowed`` is required, and a business with no policy configured still sends
+    ``allowed: true``, so a policy that is only ``allowed: true`` with no window, fee, or
+    limit says nothing the business chose and yields no line.
+    """
+    live = live_service if isinstance(live_service, dict) else {}
+    policies = live.get("policies") if isinstance(live.get("policies"), dict) else {}
+    lines: List[str] = []
+    cancel = policies.get("cancellation")
+    if isinstance(cancel, dict) and cancel.get("allowed") is not None:
+        if cancel.get("allowed") is False:
+            text = "Cancellation is not allowed"
+        else:
+            parts = []
+            free = _duration_text(cancel.get("free_cancellation_until"))
+            if free:
+                parts.append(f"free up to {free} before the appointment")
+            fee = _fee_text(cancel.get("late_cancellation_fee"), live)
+            if fee:
+                parts.append(f"a {fee} fee after that")
+            closed = _duration_text(cancel.get("no_cancellation_after"))
+            if closed:
+                parts.append(f"no cancellation within {closed} of the appointment")
+            text = f"Cancellation allowed, {', '.join(parts)}" if parts else None
+        if text:
+            lines.append(f"Cancellation policy: {text}.")
+    resched = policies.get("rescheduling")
+    if isinstance(resched, dict) and resched.get("allowed") is not None:
+        if resched.get("allowed") is False:
+            text = "Rescheduling is not allowed"
+        else:
+            parts = []
+            free = _duration_text(resched.get("free_reschedule_until"))
+            if free:
+                parts.append(f"free up to {free} before the appointment")
+            limit = resched.get("max_reschedules")
+            if isinstance(limit, int) and limit >= 0:
+                parts.append(f"at most {limit} time{'s' if limit != 1 else ''}")
+            fee = _fee_text(resched.get("fee"), live)
+            if fee:
+                parts.append(f"a {fee} fee")
+            text = f"Rescheduling allowed, {', '.join(parts)}" if parts else None
+        if text:
+            lines.append(f"Rescheduling policy: {text}.")
+    return lines
+
+
+def _http_url(value: Any) -> Optional[str]:
+    if not isinstance(value, str):
+        return None
+    url = value.strip()
+    return url if url.startswith(("https://", "http://")) else None
+
+
+def _link_label(kind: str, title: Any) -> str:
+    if isinstance(title, str) and title.strip():
+        return title.strip()
+    words = kind.replace("_", " ").replace("-", " ").strip()
+    return (words[:1].upper() + words[1:]) if words else "Link"
+
+
+def extract_policy_links(links: Any) -> List[Dict[str, str]]:
+    """Terms and policy links from a checkout: no ``rel=continue`` actions, no duplicates."""
+    out: List[Dict[str, str]] = []
+    seen: set = set()
+    for link in links or []:
+        if not isinstance(link, dict):
+            continue
+        kind = str(link.get("type") or link.get("rel") or "").strip().lower()
+        if kind in _ACTION_LINK_TYPES:
+            continue
+        url = _http_url(link.get("url") or link.get("href"))
+        if url is None or url in seen:
+            continue
+        seen.add(url)
+        out.append({"type": kind or "link", "label": _link_label(kind, link.get("title")), "url": url})
+    return out
+
+
+def _message_text(message: Dict[str, Any], zone: Optional[str]) -> Optional[str]:
+    description = message.get("description")
+    text = description.get("plain") if isinstance(description, dict) else None
+    for key in ("content", "text", "message", "title", "name"):
+        if isinstance(text, str) and text.strip():
+            break
+        text = message.get(key)
+    if not isinstance(text, str) or not text.strip():
+        return None
+    return tz_context.localize_instants_in_text(text.strip(), zone)
+
+
+def collect_provider_policies(session: Any) -> Dict[str, Any]:
+    """Everything the business published for the user to see before the booking is final.
+
+    ``lines`` are the service's cancellation and rescheduling policies, the checkout's policy
+    texts, payment terms, and disclosures; ``links`` are the checkout's policy links (never
+    ``rel=continue``). ``digest`` covers ``lines`` only: the user accepts the lines with the
+    booking summary, and links a checkout adds later are shown without a new question, so a
+    checkout re-asks only when it adds lines. The business website the CLI derives from the
+    profile and any text the CLI writes are not included; with no lines ``digest`` is None.
+    """
+    zone = session.business.timezone if getattr(session, "business", None) else None
+    lines = service_policy_lines(getattr(session, "live_service", None))
+    links = extract_policy_links(getattr(session, "ucp_checkout_links", None))
+    seen_urls = {link["url"] for link in links}
+    for policy in getattr(session, "ucp_checkout_policies", None) or []:
+        if not isinstance(policy, dict):
+            continue
+        url = _http_url(policy.get("url") or policy.get("href"))
+        if url and url not in seen_urls:
+            seen_urls.add(url)
+            kind = str(policy.get("type") or "policy").strip().lower()
+            links.append({"type": kind, "label": _link_label(kind, policy.get("title")), "url": url})
+        text = _message_text(policy, zone)
+        if text and not url:
+            lines.append(f"Policy: {text}")
+    for schedule in getattr(session, "payment_schedules", None) or []:
+        if isinstance(schedule, dict):
+            text = _message_text({"description": schedule.get("description")}, zone)
+            if text:
+                lines.append(f"Payment terms: {text}")
+    for disclosure in getattr(session, "payment_disclosures", None) or []:
+        if isinstance(disclosure, dict):
+            text = _message_text(disclosure, zone)
+            if text:
+                lines.append(text)
+    digest = None
+    if lines:
+        from .gates import digest as _digest
+
+        digest = _digest({"lines": lines})
+    return {"lines": lines, "links": links, "digest": digest}
+
+
 def booking_recap_lines(
     session: Any, price_info: Dict[str, Any], *, dual: bool,
 ) -> List[str]:
@@ -131,6 +300,10 @@ def booking_recap_lines(
     ):
         if value:
             lines.append(f"{label}: {value}")
+    mismatch = getattr(session, "selection_mismatch", None)
+    if mismatch:
+        lines.append(f"Differs from your request: {mismatch}")
+    lines.extend(service_policy_lines(session.live_service))
     return lines