@ashx-j/lunr-ai 0.2.23 → 0.2.25

package/vendor/hermes-claude-subscription-directsdk/directsdk_setup.py

@@ -0,0 +1,116 @@
+"""Setup-time probes of the user's Claude CLI: login state and its own model picker.
+
+Both are offline with respect to Anthropic: ``auth status`` reads the local credential store, and
+the ``initialize`` handshake enumerates the picker without a Messages request (the admission relay
+proves it by counting upstream calls). Anything unexpected returns ``None``/``False`` so callers
+fall back to the pinned catalog rather than failing setup.
+"""
+import json
+import os
+import shutil
+import subprocess
+import tempfile
+
+try:
+    from .admission import Admission
+    from .model_catalog import CONTEXT_WINDOWS, native_model
+except ImportError:
+    from admission import Admission
+    from model_catalog import CONTEXT_WINDOWS, native_model
+
+INSTALL_HINT = ("Claude Code is not installed (no `claude` on PATH). Install it with "
+                "`npm install -g @anthropic-ai/claude-code` or set CLAUDE_SUBSCRIPTION_DIRECTSDK_COMMAND to the binary.")
+LOGIN_HINT = "Claude Code is installed but not logged in. Run `claude auth login`, then select this provider again."
+
+
+def _resolve(command, env):
+    command = list(command) if command else [env.get("CLAUDE_SUBSCRIPTION_DIRECTSDK_COMMAND") or "claude"]
+    head = command[0]
+    exe = head if os.path.isabs(head) and os.access(head, os.X_OK) else shutil.which(head, path=env.get("PATH") or os.defpath)
+    return ([exe] + command[1:]) if exe else None
+
+
+def _child_env(env):
+    child = dict(env)
+    config = child.pop("CLAUDE_SUBSCRIPTION_DIRECTSDK_CONFIG_DIR", None)
+    if config:
+        child["CLAUDE_CONFIG_DIR"] = config
+    child.update(CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC="1", DISABLE_TELEMETRY="1", DISABLE_ERROR_REPORTING="1")
+    return child
+
+
+def _plan_label(raw):
+    """``"pro"`` (auth status) and ``"Claude Pro"`` (handshake) name the same plan."""
+    raw = str(raw or "").strip()
+    if not raw:
+        return ""
+    return raw if raw.lower().startswith("claude") else "Claude " + raw.replace("_", " ").title()
+
+
+def setup_status(command=None, env=None, timeout=20):
+    """``{available, logged_in, plan, detail, login_command}`` from the CLI's own ``auth status``."""
+    env = dict(env if env is not None else os.environ)
+    resolved = _resolve(command, env)
+    if resolved is None:
+        return {"available": False, "logged_in": False, "plan": "", "detail": INSTALL_HINT, "login_command": None}
+    login_command = resolved + ["auth", "login"]
+    try:
+        run = subprocess.run(resolved + ["auth", "status"], env=_child_env(env), stdin=subprocess.DEVNULL,
+                             capture_output=True, text=True, encoding="utf-8", errors="replace", timeout=timeout)
+        auth = json.loads(run.stdout) if run.stdout.strip().startswith("{") else {}
+    except (OSError, ValueError, subprocess.SubprocessError):
+        auth = {}
+    logged_in = auth.get("loggedIn") is True
+    plan = str(auth.get("subscriptionType") or "")
+    detail = "" if logged_in else LOGIN_HINT
+    return {"available": True, "logged_in": logged_in, "plan": _plan_label(plan), "detail": detail,
+            "login_command": login_command}
+
+
+def discover_models(command=None, env=None, timeout=40):
+    """The account's live picker as ``[{id, label, note, upstream_requests}]`` in Hermes route ids,
+    or ``None`` when the CLI is missing, logged out, or the handshake fails."""
+    env = dict(env if env is not None else os.environ)
+    resolved = _resolve(command, env)
+    # Logged out, the handshake still answers with a generic default list; only a signed-in
+    # account's picker reflects its entitlements.
+    if resolved is None or not setup_status(command=resolved, env=env, timeout=timeout)["logged_in"]:
+        return None
+    child = _child_env(env)
+    gate = Admission("https://api.anthropic.com", timeout)
+    try:
+        child["ANTHROPIC_BASE_URL"] = gate.url
+        argv = resolved + ["-p", "--model", "sonnet", "--input-format", "stream-json", "--output-format", "stream-json",
+                           "--verbose", "--tools", "", "--setting-sources", "", "--strict-mcp-config",
+                           "--mcp-config", '{"mcpServers":{}}', "--disable-slash-commands", "--no-session-persistence"]
+        handshake = json.dumps({"type": "control_request", "request_id": "hermes-picker",
+                                "request": {"subtype": "initialize"}}) + "\n"
+        with tempfile.TemporaryDirectory(prefix="claude-directsdk-picker-") as cwd:
+            run = subprocess.run(argv, input=handshake, env=child, cwd=cwd, capture_output=True,
+                                 text=True, encoding="utf-8", errors="replace", timeout=timeout)
+        rows = [json.loads(line) for line in run.stdout.splitlines() if line.startswith("{")]
+        response = next(r["response"] for r in rows if r.get("type") == "control_response")
+        native = response.get("response", {}).get("models") or []
+        upstream = int(bool(gate.used))
+    except (OSError, ValueError, StopIteration, KeyError, subprocess.SubprocessError):
+        return None
+    finally:
+        gate.close()
+    if upstream or not native:
+        return None
+    # Pro / Team-standard seats bill Fable to usage credits from the first request; the CLI only
+    # says so at request time, so apply the documented plan rule here.
+    plan = str((response.get("response", {}).get("account") or {}).get("subscriptionType") or "").lower()
+    credit_billed_on_plan = {"claude-fable-5-1"} if plan and "max" not in plan else set()
+    routes = {}
+    for row in native:
+        base = str(row.get("resolvedModel") or row.get("value") or "").removesuffix("[1m]")
+        if base not in CONTEXT_WINDOWS:
+            continue
+        route = native_model(base)
+        # Model names, not the native "Default (recommended)" alias row.
+        label = str(row.get("description") or "").split("·")[0].strip() or route
+        entry = routes.setdefault(route, {"id": route, "label": label, "note": "", "upstream_requests": upstream})
+        if "usage credit" in str(row.get("description") or "").lower() or base in credit_billed_on_plan:
+            entry["note"] = "usage credits"
+    return list(routes.values()) or None

package/vendor/hermes-claude-subscription-directsdk/inert_mcp.py

@@ -0,0 +1,24 @@
+"""Inventory only. No host imports, effects or executable tool implementations."""
+import json
+from pathlib import Path
+import sys
+
+
+def main():
+    manifest = json.loads(Path(sys.argv[1]).read_text(encoding='utf-8'))
+    for line in sys.stdin:
+        row = json.loads(line)
+        method = row.get('method')
+        result = {}
+        if method == 'initialize':
+            result = {'protocolVersion': '2024-11-05', 'capabilities': {'tools': {}}, 'serverInfo': {'name': 'hermes-inert-inventory', 'version': '1'}}
+        elif method == 'tools/list':
+            result = {'tools': manifest}
+        elif method == 'tools/call':
+            result = {'isError': True, 'content': [{'type': 'text', 'text': 'Denied: native tools are inert; only Hermes executes tools.'}]}
+        if 'id' in row:
+            print(json.dumps({'jsonrpc': '2.0', 'id': row['id'], 'result': result}), flush=True)
+
+
+if __name__ == '__main__':
+    main()

package/vendor/hermes-claude-subscription-directsdk/lunr_bridge.py

@@ -0,0 +1,89 @@
+"""Per-request JSON-lines bridge to the pinned, request-scoped native transport."""
+import json
+import sys
+import threading
+import subprocess
+import re
+
+from directsdk import Client
+from directsdk_setup import _resolve, _child_env
+
+MAX_RECORD = 64 * 1024 * 1024
+_write_lock = threading.Lock()
+
+
+def emit(request_id, kind, **fields):
+    with _write_lock:
+        sys.stdout.write(json.dumps({'v': 1, 'requestId': request_id, 'type': kind, **fields}, separators=(',', ':')) + '\n')
+        sys.stdout.flush()
+
+
+def main():
+    line = sys.stdin.buffer.readline(MAX_RECORD + 1)
+    if not line or len(line) > MAX_RECORD:
+        return 2
+    try:
+        start = json.loads(line)
+        if start.get('v') != 1 or start.get('type') != 'start' or not isinstance(start.get('requestId'), str):
+            return 2
+        request_id = start['requestId']
+        command = start['command']
+        if not isinstance(command, str) or not command or not isinstance(start.get('messages'), list):
+            raise ValueError('Invalid bridge request')
+        resolved = _resolve([command], start['env'])
+        if resolved is None:
+            raise ValueError('Missing Claude Code CLI')
+        version = subprocess.run(resolved + ['--version'], env=_child_env(start['env']), stdin=subprocess.DEVNULL,
+                                 capture_output=True, text=True, timeout=20, check=True).stdout.strip()
+        if not re.match(r'^2\.1\.263(?:\s|$)', version):
+            raise ValueError('Unqualified Claude Code version')
+        client = Client(command=command, env=start['env'], timeout=start.get('timeout', 180),
+                        on_spawn=lambda pid: emit(request_id, 'native_started', pid=pid),
+                        on_replay=lambda: emit(request_id, 'replay_progress'))
+    except Exception:
+        return 2
+
+    cancelled = threading.Event()
+
+    def read_control():
+        while True:
+            control = sys.stdin.buffer.readline(MAX_RECORD + 1)
+            if not control:
+                return
+            try:
+                record = json.loads(control)
+                if record == {'v': 1, 'requestId': request_id, 'type': 'cancel'}:
+                    cancelled.set()
+                    client.close()
+                    return
+            except (ValueError, UnicodeError):
+                cancelled.set()
+                client.close()
+                return
+
+    threading.Thread(target=read_control, daemon=True).start()
+    emit(request_id, 'ready')
+    try:
+        with client.create(model=start['model'], messages=start['messages'], tools=start['tools'],
+                           extra_body=start.get('extraBody', {}), stream=True) as stream:
+            emit(request_id, 'start')
+            for chunk in stream:
+                delta = chunk.choices[0].delta
+                if delta.content:
+                    emit(request_id, 'text_delta', text=delta.content)
+                if getattr(delta, 'reasoning_content', None):
+                    emit(request_id, 'thinking_delta', text=delta.reasoning_content)
+                if hasattr(chunk, '_response'):
+                    response = chunk._response.model_dump()
+                    emit(request_id, 'complete', response=response)
+        return 0
+    except Exception:
+        emit(request_id, 'cancelled' if cancelled.is_set() else 'error',
+             message='Claude Code request failed. Check subscription setup and native CLI compatibility.')
+        return 1
+    finally:
+        client.close()
+
+
+if __name__ == '__main__':
+    sys.exit(main())

package/vendor/hermes-claude-subscription-directsdk/lunr_setup_bridge.py

@@ -0,0 +1,49 @@
+"""Explicit setup probes. Never imported during normal model requests."""
+import json
+import sys
+import subprocess
+import hashlib
+import os
+from directsdk_setup import setup_status, discover_models, _resolve, _child_env
+
+
+def main():
+    if len(sys.argv) == 3 and sys.argv[1] == 'auth-login':
+        try:
+            resolved = _resolve([sys.argv[2]], dict(os.environ))
+            if resolved is None:
+                return 1
+            return subprocess.run(resolved + ['auth', 'login'], timeout=300, check=False).returncode
+        except (OSError, subprocess.SubprocessError):
+            return 1
+    try:
+        request = json.loads(sys.stdin.readline(65537))
+        if request.get('v') != 1 or request.get('type') not in ('status', 'discover', 'version') or not isinstance(request.get('command'), str):
+            return 2
+        command = [request['command']]
+        env = request['env']
+        if request['type'] == 'version':
+            resolved = _resolve(command, env)
+            if resolved is None:
+                return 1
+            result = subprocess.run(resolved + ['--version'], env=_child_env(env), stdin=subprocess.DEVNULL,
+                                    capture_output=True, text=True, timeout=20, check=True).stdout.strip()
+        elif request['type'] == 'status':
+            result = setup_status(command=command, env=env)
+            if result['logged_in']:
+                auth = subprocess.run(_resolve(command, env) + ['auth', 'status'], env=_child_env(env),
+                                      stdin=subprocess.DEVNULL, capture_output=True, text=True, timeout=20, check=True)
+                account = json.loads(auth.stdout)
+                email = account.get('email', '')
+                if isinstance(email, str) and email:
+                    result['accountFingerprint'] = hashlib.sha256(email.strip().lower().encode()).hexdigest()
+        else:
+            result = discover_models(command=command, env=env)
+        sys.stdout.write(json.dumps({'v': 1, 'requestId': request['requestId'], 'type': 'result', 'result': result}) + '\n')
+        return 0
+    except Exception:
+        return 1
+
+
+if __name__ == '__main__':
+    sys.exit(main())

package/vendor/hermes-claude-subscription-directsdk/manifest.json

@@ -0,0 +1,32 @@
+{
+  "upstream": "https://github.com/NousResearch/hermes-plugin-claude-subscription-directsdk",
+  "commit": "f1c1220778c7864fe4c1494baf9b1566e7c95bd2",
+  "license": "MIT",
+  "upstreamFiles": {
+    "LICENSE": "d1410a18033e51061f8a81279632cfe5d7e8041af30be9810a750f96edf1e0d5",
+    "README.md": "4c2057d1e6cb19fa078f439933b8f73d85a0f183c6651f66440e4e9d4d58e511",
+    "__init__.py": "01654271c9d9802122c7577ec3933c64330148e91aadd12fd711eff34cd9f7a4",
+    "admission.py": "a6841b870887eecc84501ab358891356ee2bb39431de68291ffd890028d82ac3",
+    "conftest.py": "64515322aea459826b85d0255c85779a2b11ef31a42a213b4602469d386627d4",
+    "directsdk.py": "d5d3d60ca59418697eaf08640eb445c25dc41ac64ee827b79008e06e8da2df54",
+    "directsdk_setup.py": "7b3499aea9405ff3f98a7fa25aad22053b1a89ce286d4e0e2841a880fc0dbe8c",
+    "evals/directsdk_admission.py": "58a7bde324a41c26889c910170f8766479b6c98e1a2c4b088b8bb69bd9cddb9a",
+    "evals/directsdk_cache_wire.py": "089cb380386cfe28fadd7c720e7ba609a6cb1ad2cf5a320a617b61a6ad7cfc94",
+    "inert_mcp.py": "6c5a0f64e4470ae90c6171bd83e2b537f641ff6d06cd76b3d49edba227274cb6",
+    "model_catalog.py": "5e4fa7ed95eedf243b46524abbd9771f8c4ba756cc0208f1fa9a5768a1281077",
+    "plugin.yaml": "6e2edc160c8a928e3393bc4e479589dfddee5291814ae930317086f2b0275067",
+    "pyproject.toml": "e041f415bf92d7a3ed71c40f5a1732be9e629000c6b46479f9036ebde3071453",
+    "tests/test_directsdk.py": "884c960c1b88c8727bbd1cc70598d509dd435ba02296bad2a805b23f717bdc91",
+    "tests/test_directsdk_admission.py": "a52d64907973d32e91dbc890f42e67d191a7b7d283b042f4d278968130385251",
+    "tests/test_directsdk_discovery.py": "279a5a0723f3327439238d7a682602627d1aceccc2e45ee9122159cfeb292f16",
+    "tests/test_directsdk_models.py": "b13ccf8b53d9748e41490940ce9fd092a8bf5069f2fa2e44f09cbf0ad49af044",
+    "tests/test_directsdk_replay.py": "9894ab096289142f84785533d728dcac0b721720fc03b1c5f4c5e509533adee3",
+    "tests/test_directsdk_setup.py": "82552e84aa4a0cf0a16c3a70e4418c9edfa85a27a89821b79cf8fb957e8f91f3"
+  },
+  "patchedFiles": {
+    "directsdk.py": "42b8eef95cc313ad0314083a25fd534603adb56cb86c57987ed5e67d31141e73"
+  },
+  "patches": {
+    "patches/0001-lunr-lifecycle-hooks.patch": "0c19a60c69f15745e7076a1791988408feb32611ae29156ab28a2670a50fedb5"
+  }
+}

package/vendor/hermes-claude-subscription-directsdk/model_catalog.py

@@ -0,0 +1,44 @@
+"""Pinned native routes; a loopback gateway needs explicit long-context selection."""
+CONTEXT_WINDOWS = {
+    'claude-sonnet-5': 1_000_000,
+    'claude-haiku-4-5-20251001': 200_000,
+    'claude-opus-5': 1_000_000,
+    'claude-opus-4-8': 1_000_000,
+    'claude-fable-5-1': 1_000_000,
+}
+ALIASES = {
+    'sonnet': 'claude-sonnet-5',
+    'haiku': 'claude-haiku-4-5-20251001',
+    'claude-haiku-4-5': 'claude-haiku-4-5-20251001',
+    'opus': 'claude-opus-5',
+    'fable': 'claude-fable-5-1',
+}
+# Haiku 4.5 rejects `thinking: {'type': 'adaptive'}` with a 400 upstream; its effort signal
+# still applies. Unknown routes keep adaptive so future models are not silently downgraded.
+NO_ADAPTIVE_THINKING = frozenset({'claude-haiku-4-5-20251001'})
+
+
+def native_model(model):
+    base = model.removesuffix('[1m]')
+    canonical = ALIASES.get(base, base)
+    window = CONTEXT_WINDOWS.get(canonical)
+    if window == 1_000_000:
+        return canonical + '[1m]'
+    if window == 200_000:
+        if model.endswith('[1m]'):
+            raise ValueError('Haiku 4.5 does not support a 1M context window')
+        return canonical
+    return model
+
+
+def supports_adaptive_thinking(model):
+    # Body assembly precedes model validation, so an absent or invalid route answers True
+    # and still reaches the existing `model is required` error.
+    base = model.removesuffix('[1m]') if isinstance(model, str) else ''
+    return ALIASES.get(base, base) not in NO_ADAPTIVE_THINKING
+
+
+MODEL_METADATA = {
+    native_model(model): {'canonical_model': model, 'context_window': window}
+    for model, window in CONTEXT_WINDOWS.items()
+}

package/vendor/hermes-claude-subscription-directsdk/patches/0001-lunr-lifecycle-hooks.patch

@@ -0,0 +1,14 @@
+--- a/directsdk.py
++++ b/directsdk.py
+@@ -269,0 +270,2 @@
++            if self.client.on_spawn is not None:
++                self.client.on_spawn(self.process.pid)
+@@ -368 +370 @@
+-    def __init__(self, command=None, args=None, env=None, timeout=180, **_):
++    def __init__(self, command=None, args=None, env=None, timeout=180, on_spawn=None, on_replay=None, **_):
+@@ -376,0 +379,2 @@
++        self.on_spawn = on_spawn
++        self.on_replay = on_replay
+@@ -525,0 +530,2 @@
++                                if self.on_replay is not None:
++                                    self.on_replay()

package/vendor/hermes-claude-subscription-directsdk/tools/schema_sanitizer.py

@@ -0,0 +1,23 @@
+def strip_nullable_unions(schema, *, keep_nullable_hint=True):
+    def rewrite(value):
+        if isinstance(value, list):
+            return [rewrite(item) for item in value]
+        if not isinstance(value, dict):
+            return value
+        out = {key: rewrite(item) for key, item in value.items()}
+        for key in ('anyOf', 'oneOf'):
+            variants = out.get(key)
+            if not isinstance(variants, list):
+                continue
+            non_null = [item for item in variants if not isinstance(item, dict) or item.get('type') != 'null']
+            if len(non_null) != 1 or len(non_null) == len(variants):
+                continue
+            replacement = dict(non_null[0]) if isinstance(non_null[0], dict) else {}
+            if keep_nullable_hint:
+                replacement.setdefault('nullable', True)
+            for meta in ('title', 'description', 'default', 'examples'):
+                if meta in out and meta not in replacement and not (meta == 'default' and '$ref' in replacement):
+                    replacement[meta] = out[meta]
+            return rewrite(replacement)
+        return out
+    return rewrite(schema)