pari-cli 0.1.3__tar.gz → 0.1.6__tar.gz

pari_cli-0.1.6/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: pari-cli
+Version: 0.1.6
+Summary: A resilient, sandbox-first terminal coding agent engineered for high pass rates and low token burn.
+Author: PARI Contributors
+License: MIT
+Project-URL: Homepage, https://pari-cli.in
+Project-URL: Documentation, https://pari-cli.in/docs
+Project-URL: Repository, https://github.com/MdTanwer/pari
+Keywords: ai,coding-agent,terminal,llm,developer-tools
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.0.0
+Requires-Dist: prompt_toolkit>=3.0.36
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: httpx>=0.24.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: ruff>=0.12.10; extra == "dev"
+Requires-Dist: pre-commit>=4.3.0; extra == "dev"
+Requires-Dist: pycodestyle>=2.12.0; extra == "dev"
+Provides-Extra: ast
+Requires-Dist: tree-sitter>=0.21.0; extra == "ast"
+Requires-Dist: tree-sitter-languages>=1.10.0; extra == "ast"
+Requires-Dist: networkx>=3.0; extra == "ast"
+Requires-Dist: grep-ast>=0.3.0; extra == "ast"
+Provides-Extra: cloud
+Requires-Dist: e2b>=0.14.0; extra == "cloud"
+Provides-Extra: all
+Requires-Dist: pari-cli[ast,cloud,dev]; extra == "all"
+Dynamic: license-file
+
+# PARI — Next-Generation Terminal Coding Agent
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
+[![Architecture: 11-Layer Stack](https://img.shields.io/badge/architecture-11--layer-green.svg)](docs/architecture/overview.md)
+[![Security: Kernel Sandboxed](https://img.shields.io/badge/sandbox-bwrap%20%7C%20Seatbelt%20%7C%20E2B-orange.svg)](docs/layers/layer-0-sandboxing.md)
+
+---
+
+## ⚡ The Core Thesis
+
+$$\text{\bf Agent failure is a systems engineering failure, not a reasoning failure.}$$
+
+The exact same frontier reasoning model (Claude 3.7 Sonnet, GPT-4o) demonstrates a **15% pass rate** in a naive loop, but achieves a **50–55% pass rate** inside an engineered harness. The 35% delta is not model intelligence; it is accounted for by **six fatal systems failure modes**:
+
+1. **Unbounded stdout poisoning** $\rightarrow$ Solved by Layer 7 (50KB/2k-line disk spooler + balanced head/tail extraction).
+2. **Mid-stream token truncation** $\rightarrow$ Solved by Layer 4 (Strict `stop_reason == "length"` rejection guard).
+3. **File write race conditions** $\rightarrow$ Solved by Layer 6 (`FileMutationQueue` canonical realpath serialization).
+4. **KV cache invalidation cascades** $\rightarrow$ Solved by Layer 2 (Immutable Baseline Epochs freezing Tiers 1–4).
+5. **Blind file traversal loops** $\rightarrow$ Solved by Layer 3 (v1: Fast substring ripgrep & globbing / v2: Tree-sitter AST fallback).
+6. **Unsandboxed host execution** $\rightarrow$ Solved by Layer 0 (Multi-platform kernel isolation: `bwrap`, `Seatbelt`, E2B MicroVMs).
+
+---
+
+## 🚀 Installation & Quick Start
+
+Official Website & Documentation: **[https://pari-cli.in/docs](https://pari-cli.in/docs)**
+
+Choose your platform's installation command:
+
+### 1. macOS & Linux (`curl`)
+```bash
+curl -fsSL https://pari-cli.in/install.sh | bash
+```
+
+### 2. Windows (`irm` in PowerShell)
+```powershell
+irm https://www.pari-cli.in/install.ps1 | iex
+```
+
+### 3. Via `pip` / `pipx` / `uv`
+```bash
+# Recommended (isolated CLI)
+pipx install pari-cli
+
+# Fast via uv
+uv tool install pari-cli
+
+# Standard pip
+pip install pari-cli
+```
+
+---
+
+### 💻 Launch Interactive Session
+```bash
+# Export your API key
+export ANTHROPIC_API_KEY="sk-ant-..."
+
+# Launch PARI anywhere in your project workspace
+pari-cli
+```
+
+---
+
+## ⚖️ License
+
+MIT License. See [LICENSE](LICENSE) for details.

pari_cli-0.1.6/README.md

@@ -0,0 +1,68 @@
+# PARI — Next-Generation Terminal Coding Agent
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
+[![Architecture: 11-Layer Stack](https://img.shields.io/badge/architecture-11--layer-green.svg)](docs/architecture/overview.md)
+[![Security: Kernel Sandboxed](https://img.shields.io/badge/sandbox-bwrap%20%7C%20Seatbelt%20%7C%20E2B-orange.svg)](docs/layers/layer-0-sandboxing.md)
+
+---
+
+## ⚡ The Core Thesis
+
+$$\text{\bf Agent failure is a systems engineering failure, not a reasoning failure.}$$
+
+The exact same frontier reasoning model (Claude 3.7 Sonnet, GPT-4o) demonstrates a **15% pass rate** in a naive loop, but achieves a **50–55% pass rate** inside an engineered harness. The 35% delta is not model intelligence; it is accounted for by **six fatal systems failure modes**:
+
+1. **Unbounded stdout poisoning** $\rightarrow$ Solved by Layer 7 (50KB/2k-line disk spooler + balanced head/tail extraction).
+2. **Mid-stream token truncation** $\rightarrow$ Solved by Layer 4 (Strict `stop_reason == "length"` rejection guard).
+3. **File write race conditions** $\rightarrow$ Solved by Layer 6 (`FileMutationQueue` canonical realpath serialization).
+4. **KV cache invalidation cascades** $\rightarrow$ Solved by Layer 2 (Immutable Baseline Epochs freezing Tiers 1–4).
+5. **Blind file traversal loops** $\rightarrow$ Solved by Layer 3 (v1: Fast substring ripgrep & globbing / v2: Tree-sitter AST fallback).
+6. **Unsandboxed host execution** $\rightarrow$ Solved by Layer 0 (Multi-platform kernel isolation: `bwrap`, `Seatbelt`, E2B MicroVMs).
+
+---
+
+## 🚀 Installation & Quick Start
+
+Official Website & Documentation: **[https://pari-cli.in/docs](https://pari-cli.in/docs)**
+
+Choose your platform's installation command:
+
+### 1. macOS & Linux (`curl`)
+```bash
+curl -fsSL https://pari-cli.in/install.sh | bash
+```
+
+### 2. Windows (`irm` in PowerShell)
+```powershell
+irm https://www.pari-cli.in/install.ps1 | iex
+```
+
+### 3. Via `pip` / `pipx` / `uv`
+```bash
+# Recommended (isolated CLI)
+pipx install pari-cli
+
+# Fast via uv
+uv tool install pari-cli
+
+# Standard pip
+pip install pari-cli
+```
+
+---
+
+### 💻 Launch Interactive Session
+```bash
+# Export your API key
+export ANTHROPIC_API_KEY="sk-ant-..."
+
+# Launch PARI anywhere in your project workspace
+pari-cli
+```
+
+---
+
+## ⚖️ License
+
+MIT License. See [LICENSE](LICENSE) for details.

{pari_cli-0.1.3 → pari_cli-0.1.6}/pari/__init__.py

@@ -1,3 +1,3 @@
 """PARI — High-performance terminal coding agent."""
 
-__version__ = "0.1.3"
+__version__ = "0.1.6"

{pari_cli-0.1.3 → pari_cli-0.1.6}/pari/agent/guards.py

@@ -5,7 +5,9 @@ The loop itself decides when to stop. These values are the limits it checks.
 
 MAX_TURNS = 40
 TURN_WARNING = 30
+TURN_EXTENSION = 10
 DAEMON_IDLE_SECONDS = 10
+TURN_LIMIT_PROMPT = "[Turn limit reached. Continue (+10 turns) | Revert | Stop]?"
 
 # Shown when stop_reason is "length". The loop must drop the pending tool
 # calls before it appends this notice. A truncated edit must not touch disk.

{pari_cli-0.1.3 → pari_cli-0.1.6}/pari/agent/loop.py

@@ -17,6 +17,7 @@ from pari.agent.guards import (
     DAEMON_IDLE_SECONDS,
     LENGTH_TRUNCATION_NOTICE,
     MAX_TURNS,
+    TURN_LIMIT_PROMPT,
     TURN_WARNING,
     format_daemon_notice,
     is_length_stop,
@@ -27,7 +28,8 @@ from pari.context.chunks import ContextChunk, ContextTier, assemble_context
 from pari.context.compaction import compact_context
 from pari.edit.diff import generate_unified_diff
 from pari.fs.path import resolve_safe_path
-from pari.providers.base import ModelResponse, ToolCall
+from pari.providers.message import ToolCall
+from pari.providers.response import ModelResponse
 from pari.session.logger import SessionLogger
 from pari.session.undo import GuardedUndoManager
 
@@ -49,7 +51,6 @@ class TurnResult:
     cached_tokens: int = 0
 
 
-_TURN_LIMIT = "[Turn limit reached. Continue (+10 turns) | Revert | Stop]?"
 _FILE_TOOLS = frozenset({"write_file", "edit_file"})
 
 
@@ -66,6 +67,7 @@ class AgentExecutionLoop:
         undo: GuardedUndoManager | None = None,
         workspace: Path | None = None,
         on_tool_call: Callable[[str, dict[str, Any]], None] | None = None,
+        on_tool_result: Callable[[ToolCall, str], None] | None = None,
         on_diff: Callable[[str, str], None] | None = None,
         on_warning: Callable[[str], None] | None = None,
     ):
@@ -76,6 +78,7 @@ class AgentExecutionLoop:
         self.undo = undo
         self.workspace = workspace
         self.on_tool_call = on_tool_call
+        self.on_tool_result = on_tool_result
         self.on_diff = on_diff
         self.on_warning = on_warning
         self._warning = ""
@@ -140,19 +143,21 @@ class AgentExecutionLoop:
                 return finish(halt, executed, True)
             history = _append(history, response_text)
             pending = feedback
-        return finish(_TURN_LIMIT, executed, True, capture_diff=True)
+        return finish(TURN_LIMIT_PROMPT, executed, True, capture_diff=True)
 
     async def _run_calls(
         self, calls: list[ToolCall], executed: int
     ) -> tuple[str, int, str | None]:
         """Run the calls in order. A failure stops the rest of this batch."""
         notes: list[str] = []
-        for call in calls:
+        for index, call in enumerate(calls):
             path = _file_path(call)
             before = self._read_rel(path) if path is not None else ""
             try:
                 text = await self._execute_call(call)
             except Exception as exc:
+                self._report_result(call, f"{type(exc).__name__}: {exc}")
+                self._skip_rest(calls[index + 1 :])
                 return self._fail(type(exc).__name__, str(exc), executed)
             executed += 1
             if path is not None:
@@ -160,7 +165,10 @@ class AgentExecutionLoop:
                 self._snapshot(path, before, after)
                 lint = lint_python(path, after)
                 if lint is not None:
+                    self._report_result(call, lint)
+                    self._skip_rest(calls[index + 1 :])
                     return self._fail("LINT ERROR", lint, executed)
+            self._report_result(call, text)
             notes.append(text)
         return "\n".join(notes), executed, None
 
@@ -179,6 +187,14 @@ class AgentExecutionLoop:
             self.logger.append_event("TOOL_RESULT", {"tool": call.name, "output": text})
         return text
 
+    def _report_result(self, call: ToolCall, text: str) -> None:
+        if self.on_tool_result is not None:
+            self.on_tool_result(call, text)
+
+    def _skip_rest(self, calls: list[ToolCall]) -> None:
+        for call in calls:
+            self._report_result(call, "Skipped because an earlier call failed.")
+
     def _log_assistant(self, text: str) -> None:
         if self.logger is None:
             return

{pari_cli-0.1.3 → pari_cli-0.1.6}/pari/agent/runtime.py

@@ -14,12 +14,20 @@ from collections.abc import Callable
 from pathlib import Path
 from typing import Any
 
-from pari.agent.guards import is_length_stop
-from pari.agent.loop import AgentExecutionLoop
+from pari.agent.guards import (
+    MAX_TURNS,
+    TURN_EXTENSION,
+    TURN_LIMIT_PROMPT,
+    is_length_stop,
+)
+from pari.agent.loop import AgentExecutionLoop, TurnResult
 from pari.agent.reflection import ReflectionManager
 from pari.intelligence.repomap import RepoMapGenerator
 from pari.providers import get_provider
-from pari.providers.base import LLMProvider, ModelResponse, ProviderMessage
+from pari.providers.base import LLMProvider
+from pari.providers.exceptions import ProviderError
+from pari.providers.message import ProviderMessage, ToolCall
+from pari.providers.response import ModelResponse
 from pari.routing.router import DualModelRouter, router_for
 from pari.session.events import SessionEventType
 from pari.session.logger import SessionLogger
@@ -39,6 +47,7 @@ class AgentRuntime:
         edit_fallback: str = "none",
         repomap: str = "off",
         router: DualModelRouter | None = None,
+        sandbox_mode: str | None = None,
     ):
         self.workspace = workspace.resolve()
         self.session_file = session_file or (self.workspace / ".pari" / "session.jsonl")
@@ -51,7 +60,14 @@ class AgentRuntime:
         self._owns_router = router is None
         self.router = router if router is not None else router_for(self.provider)
         self.undo_manager = GuardedUndoManager(self.workspace)
-        self.tools = get_default_registry(self.workspace, edit_fallback=edit_fallback)
+        self.tools = get_default_registry(
+            self.workspace,
+            edit_fallback=edit_fallback,
+            sandbox_mode=sandbox_mode,
+        )
+        self.awaiting_limit = False
+        self.last_result: TurnResult | None = None
+        self._tool_followup = False
         self.pinned_files: list[str] = []
         self.session_id: str | None = None
         self.messages: list[ProviderMessage] = []
@@ -110,23 +126,51 @@ class AgentRuntime:
     def add_pinned_file(self, rel_path: str) -> bool:
         """Pin reference file into active context."""
         file_path = (self.workspace / rel_path).resolve()
-        if not file_path.exists():
+        if not file_path.is_file():
+            return False
+        try:
+            clean_rel = str(file_path.relative_to(self.workspace))
+        except ValueError:
             return False
-        clean_rel = str(file_path.relative_to(self.workspace))
         if clean_rel not in self.pinned_files:
             self.pinned_files.append(clean_rel)
         return True
 
+    async def continue_turn(
+        self,
+        on_tool_call: Callable[[str, dict[str, Any]], None] | None = None,
+        on_diff: Callable[[str, str], None] | None = None,
+        on_tool_result: Callable[[ToolCall, str], None] | None = None,
+        on_step_text: Callable[[str], None] | None = None,
+        on_delta: Callable[[str], None] | None = None,
+    ) -> str:
+        """Run another block of turns after the user chooses Continue."""
+        return await self.execute_turn(
+            "Continue.",
+            on_tool_call=on_tool_call,
+            on_diff=on_diff,
+            on_tool_result=on_tool_result,
+            on_step_text=on_step_text,
+            on_delta=on_delta,
+            max_turns=TURN_EXTENSION,
+        )
+
     async def execute_turn(
         self,
         prompt: str,
         on_tool_call: Callable[[str, dict[str, Any]], None] | None = None,
         on_diff: Callable[[str, str], None] | None = None,
+        on_tool_result: Callable[[ToolCall, str], None] | None = None,
+        on_step_text: Callable[[str], None] | None = None,
+        on_delta: Callable[[str], None] | None = None,
+        *,
+        max_turns: int | None = None,
     ) -> str:
         """Execute conversational turn with autonomous tool execution."""
         self.on_tool_call = on_tool_call
         self.on_diff = on_diff
         self.turn_warning = ""
+        self._tool_followup = False
         if not self.session_id:
             self.start_session()
         self.router.begin_turn()
@@ -134,16 +178,35 @@ class AgentRuntime:
         schemas = self.tools.get_schemas()
 
         async def step(context: str, _turn: int) -> ModelResponse:
-            self.messages.append(ProviderMessage(role="user", content=context))
+            # After a tool call, the results are already on the transcript.
+            # A new user message here would hide them from the model.
+            if not self._tool_followup:
+                self.messages.append(ProviderMessage(role="user", content=context))
+            self._tool_followup = False
             # Wide prompts plan once, with no tools. The editor runs the calls.
             resp = await self.router.complete(
                 self.messages,
                 schemas,
                 prompt=prompt,
                 active_files=self.pinned_files,
+                on_delta=on_delta,
             )
             # Drop tool calls that were cut off so the next step cannot rerun them.
-            calls = [] if is_length_stop(resp.stop_reason) else resp.tool_calls
+            calls = [] if is_length_stop(resp.stop_reason) else list(resp.tool_calls)
+            for index, call in enumerate(calls):
+                if not call.id:
+                    call.id = f"call_{index}"
+            self._tool_followup = bool(calls)
+            # Show the note that introduces this tool batch. The final answer
+            # has no tool calls and is printed once, after the turn returns.
+            # Deltas already painted this text. Printing it again would repeat it.
+            if (
+                calls
+                and resp.text.strip()
+                and on_step_text is not None
+                and on_delta is None
+            ):
+                on_step_text(resp.text)
             self.messages.append(
                 ProviderMessage(
                     role="assistant",
@@ -153,28 +216,46 @@ class AgentRuntime:
             )
             return resp
 
+        def remember_result(call: ToolCall, text: str) -> None:
+            self.messages.append(
+                ProviderMessage(role="tool", content=text, tool_call_id=call.id)
+            )
+            if on_tool_result is not None:
+                on_tool_result(call, text)
+
         dag = self.workspace / ".pari" / "sessions" / f"{self.session_id}.jsonl"
 
         def remember_warning(text: str) -> None:
             self.turn_warning = text
 
         loop = AgentExecutionLoop(
+            max_turns if max_turns is not None else MAX_TURNS,
             registry=self.tools,
             reflection=ReflectionManager(),
             logger=SessionLogger(dag),
             undo=self.undo_manager,
             workspace=self.workspace,
             on_tool_call=on_tool_call,
+            on_tool_result=remember_result,
             on_diff=on_diff,
             on_warning=remember_warning,
         )
-        result = await loop.run_turn(
-            prompt,
-            step,
-            lambda response: is_length_stop(response.stop_reason),
-            active_files=self._pinned_contents(),
-            repo_map=self._repo_map(),
-        )
+        # A failed model call must not leave the prompt sitting on the transcript.
+        # The next message would otherwise resend a turn the provider never answered.
+        sent = len(self.messages)
+        try:
+            result = await loop.run_turn(
+                prompt,
+                step,
+                lambda response: is_length_stop(response.stop_reason),
+                active_files=self._pinned_contents(),
+                repo_map=self._repo_map(),
+            )
+        except ProviderError:
+            self._tool_followup = False
+            if len(self.messages) == sent + 1 and self.messages[-1].role == "user":
+                self.messages.pop()
+            raise
         turn_record = {
             "event": "turn_complete",
             "session_id": self.session_id,
@@ -189,6 +270,8 @@ class AgentRuntime:
         self.tokens_in = result.tokens_in
         self.tokens_out = result.tokens_out
         self.cached_tokens = result.cached_tokens
+        self.last_result = result
+        self.awaiting_limit = result.response_text == TURN_LIMIT_PROMPT
         return result.response_text
 
     def _repo_map(self) -> str:

{pari_cli-0.1.3 → pari_cli-0.1.6}/pari/agent/subagent.py

@@ -35,9 +35,8 @@ class FiberSubagentPool:
         self.max_concurrency = max_concurrency
         self._slots = asyncio.Semaphore(max_concurrency)
 
-    async def run_task(self, task_id: str, coro: Coroutine) -> Any:
+    async def run_task(self, _task_id: str, coro: Coroutine) -> Any:
         """Run one research task, waiting if the pool is already full."""
-        _ = task_id
         async with self._slots:
             return await coro
 

{pari_cli-0.1.3 → pari_cli-0.1.6}/pari/auth/account.py

@@ -1,13 +1,14 @@
-"""Account sign-in for the five providers.
+"""Account sign-in for providers that have a browser or device login.
 
 OpenAI, Anthropic, and OpenRouter open a browser and accept the redirect URL
-if the local callback does not finish. Grok uses a device code. DeepSeek has
-no browser login, so the account token is pasted. Radius is not a provider.
+if the local callback does not finish. Grok uses a device code. A provider
+with ``account=False`` has no account login. Radius is not a provider.
 """
 
 import base64
 import errno
 import hashlib
+import html
 import json
 import re
 import secrets
@@ -21,7 +22,7 @@ from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from typing import Protocol
 
 from pari.auth.login import sign_in
-from pari.auth.providers import ProviderInfo, get_info
+from pari.auth.providers import ProviderInfo, get_info, no_account_message
 from pari.auth.store import AuthStore
 
 
@@ -34,6 +35,8 @@ class AccountUI(Protocol):
 
     def read_line(self, prompt: str) -> str | None: ...
 
+    def read_secret(self, prompt: str) -> str | None: ...
+
     def show_auth_url(
         self,
         url: str,
@@ -46,6 +49,8 @@ class AccountUI(Protocol):
 
     def sleep(self, seconds: float) -> bool: ...
 
+    def progress(self, message: str) -> None: ...
+
     def show_error(self, message: str) -> None: ...
 
 
@@ -67,6 +72,7 @@ _ANTHROPIC_SCOPES = (
     "org:create_api_key user:profile user:inference "
     "user:sessions:claude_code user:mcp_servers user:file_upload"
 )
+_CALLBACK_PATH = "/callback"
 _ANTHROPIC_COPY_REDIRECT = "https://platform.claude.com/oauth/code/callback"
 
 _OPENROUTER_AUTHORIZE = "https://openrouter.ai/auth"
@@ -88,11 +94,8 @@ _BROWSER = (
 def sign_in_account(provider_id: str, ui: AccountUI, store: AuthStore) -> str:
     """Run that provider's account login and store the credential."""
     info = get_info(provider_id)
-    if info.id == "deepseek":
-        token = ui.read_line("Paste your DeepSeek account token:")
-        if not token or not token.strip():
-            raise LoginCancelled()
-        return sign_in(info.id, token, "account", store)
+    if not info.account:
+        raise ValueError(no_account_message(info))
     if info.id == "openai":
         cred = _login_openai(ui, store)
     elif info.id == "anthropic":
@@ -175,9 +178,7 @@ def _login_openai(ui: AccountUI, store: AuthStore) -> dict:
         code, client_id = _code_from(server, pasted, _OPENAI_REDIRECT, state)
         if not client_id:
             raise ValueError("Paste the full callback URL from the browser.")
-        ui_progress = getattr(ui, "progress", None)
-        if ui_progress:
-            ui_progress("Exchanging authorization code for tokens...")
+        ui.progress("Exchanging authorization code for tokens...")
         return _exchange_openai(code, verifier, client_id)
     finally:
         server.close()
@@ -195,7 +196,7 @@ def _login_anthropic(ui: AccountUI) -> dict:
         return _anthropic_copy_code(ui, verifier, challenge)
     server = _anthropic_server(verifier)
     redirect = (
-        server.redirect_uri if server else (f"http://localhost:53692{_callback_path()}")
+        server.redirect_uri if server else f"http://localhost:53692{_CALLBACK_PATH}"
     )
     try:
         url = _anthropic_url(challenge, verifier, redirect)
@@ -511,20 +512,18 @@ def _anthropic_url(challenge: str, state: str, redirect: str) -> str:
 
 def _anthropic_server(state: str) -> "CallbackServer | None":
     try:
-        return _listen("127.0.0.1", 53692, "/callback", "localhost", state, "Anthropic")
+        return _listen(
+            "127.0.0.1", 53692, _CALLBACK_PATH, "localhost", state, "Anthropic"
+        )
     except OSError as exc:
         if exc.errno != errno.EADDRINUSE:
             return None
     try:
-        return _listen("127.0.0.1", 0, "/callback", "localhost", state, "Anthropic")
+        return _listen("127.0.0.1", 0, _CALLBACK_PATH, "localhost", state, "Anthropic")
     except OSError:
         return None
 
 
-def _callback_path() -> str:
-    return "/callback"
-
-
 class CallbackServer:
     """Loopback redirect. OpenAI's port stays 1455 because the redirect is fixed."""
 
@@ -619,7 +618,8 @@ def _listen(
 
 def _send(request: BaseHTTPRequestHandler, status: int, message: str) -> None:
     body = (
-        f"<!doctype html><meta charset=utf-8><title>PARI</title><p>{_html(message)}</p>"
+        "<!doctype html><meta charset=utf-8><title>PARI</title>"
+        f"<p>{html.escape(message)}</p>"
     ).encode()
     request.send_response(status)
     request.send_header("Content-Type", "text/html; charset=utf-8")
@@ -653,6 +653,9 @@ def _request(url: str, data: bytes, content_type: str) -> tuple[int, dict]:
             return response.status, _json_body(response.read())
     except urllib.error.HTTPError as exc:
         return exc.code, _json_body(exc.read())
+    except (urllib.error.URLError, TimeoutError):
+        host = urllib.parse.urlparse(url).netloc
+        raise RuntimeError(f"Could not reach {host}. Check your connection.") from None
 
 
 def _json_body(raw: bytes) -> dict:
@@ -724,7 +727,3 @@ def _http_error(action: str, status: int, body: dict) -> str:
         detail = detail.get("message")
     suffix = f": {detail}" if isinstance(detail, str) and detail else ""
     return f"{action} failed (HTTP {status}){suffix}."
-
-
-def _html(text: str) -> str:
-    return text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")