claude-smart 0.2.45 → 0.2.47

package/plugin/vendor/reflexio/reflexio/server/llm/providers/embedding_service_provider.py

@@ -11,11 +11,14 @@ from __future__ import annotations
 import json
 import logging
 import os
+import threading
 import time
 from typing import Any, Literal
 
 import httpx
 
+from reflexio.server.tracing import profile_step
+
 _LOGGER = logging.getLogger(__name__)
 
 EmbeddingProviderMode = Literal[
@@ -41,10 +44,22 @@ _DEFAULT_LOCAL_SERVICE_PROBE_TIMEOUT_MS = 200
 # daemon. Cap texts per request and concatenate; encode batching is a separate
 # server-side knob (REFLEXIO_EMBED_BATCH_SIZE).
 _DEFAULT_MAX_TEXTS_PER_REQUEST = 32
-_LOCAL_SERVICE_PROBE_CACHE_SECONDS = 5.0
+# A reachable daemon is stable, so positive probe results are cached long
+# enough that steady-state requests skip the sequential /health round trip.
+# Failures stay short-lived so a restarted daemon is re-adopted quickly and
+# the inprocess-fallback window stays small.
+_LOCAL_SERVICE_PROBE_CACHE_SECONDS = 60.0
+_LOCAL_SERVICE_PROBE_FAILURE_CACHE_SECONDS = 5.0
+# Keep-alive must expire below the ALB's default 60s idle timeout so the pool
+# never hands out a connection the load balancer already closed.
+_HTTP_KEEPALIVE_EXPIRY_SECONDS = 50.0
+_EMBEDDING_RETRY_BACKOFF_SECONDS = 0.1
 _SERVICE_MODES = {"local_service", "internal_service"}
 _VALID_MODES = {"cloud", *_SERVICE_MODES, "inprocess", "off"}
 _local_service_probe_cache: tuple[float, bool, str | None] | None = None
+_http_client_lock = threading.Lock()
+_http_client_instance: httpx.Client | None = None
+_http_client_pid: int | None = None
 
 
 class EmbeddingUnavailableError(RuntimeError):
@@ -113,17 +128,46 @@ def _is_local_model(model: str | None) -> bool:
     return bool(model and model.startswith("local/"))
 
 
+def _http_client() -> httpx.Client:
+    """Shared keep-alive client for health probes and embedding POSTs.
+
+    A per-request client pays DNS resolution plus a TCP handshake on every
+    embedding call. The client is recreated after fork (PID check) so worker
+    children never reuse sockets inherited from the parent process.
+    """
+    global _http_client_instance, _http_client_pid
+    pid = os.getpid()
+    with _http_client_lock:
+        if _http_client_instance is None or _http_client_pid != pid:
+            if _http_client_instance is not None and _http_client_pid != pid:
+                try:
+                    _http_client_instance.close()
+                except Exception:
+                    _LOGGER.debug(
+                        "Failed to close stale embedding HTTP client", exc_info=True
+                    )
+            _http_client_instance = httpx.Client(
+                limits=httpx.Limits(keepalive_expiry=_HTTP_KEEPALIVE_EXPIRY_SECONDS)
+            )
+            _http_client_pid = pid
+        return _http_client_instance
+
+
 def _local_service_status() -> tuple[bool, str | None]:
     global _local_service_probe_cache
     now = time.monotonic()
-    if (
-        _local_service_probe_cache is not None
-        and now - _local_service_probe_cache[0] < _LOCAL_SERVICE_PROBE_CACHE_SECONDS
-    ):
-        return _local_service_probe_cache[1], _local_service_probe_cache[2]
+    if _local_service_probe_cache is not None:
+        cached_at, cached_reachable, cached_model = _local_service_probe_cache
+        ttl = (
+            _LOCAL_SERVICE_PROBE_CACHE_SECONDS
+            if cached_reachable
+            else _LOCAL_SERVICE_PROBE_FAILURE_CACHE_SECONDS
+        )
+        if now - cached_at < ttl:
+            return cached_reachable, cached_model
 
     try:
-        response = httpx.get(
+        response = _http_client().get(
             f"{_local_service_url()}/health",
             timeout=_local_service_probe_timeout_seconds(),
         )
@@ -192,9 +236,9 @@ def embedding_provider_mode(model: str | None = None) -> EmbeddingProviderMode:
     """Resolve the embedding provider mode for a model.
 
     Explicit legacy env modes keep their historical behavior. With no explicit
-    env mode, routing is model-driven: ``local/*`` uses the local daemon when it
-    is reachable and otherwise falls back to the in-process embedder; cloud
-    models use their provider directly.
+    env mode, routing is model-driven: ``local/*`` uses a configured daemon host
+    authoritatively, otherwise it uses the local daemon when reachable and falls
+    back to the in-process embedder. Cloud models use their provider directly.
     """
     configured = os.environ.get(_ENV_PROVIDER)
     if configured:
@@ -212,6 +256,9 @@ def embedding_provider_mode(model: str | None = None) -> EmbeddingProviderMode:
     if os.environ.get(_ENV_SERVICE_URL):
         return "internal_service"
 
+    if _is_local_model(model) and os.environ.get(_ENV_DAEMON_HOST, "").strip():
+        return "local_service"
+
     if _is_local_model(model):
         return "local_service" if _local_service_supports_model(model) else "inprocess"
     return "cloud"
@@ -286,17 +333,29 @@ def _post_embedding_batch(
     last_error: Exception | None = None
     for attempt in range(2):
         try:
-            with httpx.Client(timeout=timeout) as client:
-                response = client.post(url, json=payload)
+            response = _http_client().post(url, json=payload, timeout=timeout)
             response.raise_for_status()
             body = response.json()
             return _ordered_embeddings_from_response(body.get("data"), len(texts))
-        except (httpx.ConnectError, httpx.ConnectTimeout) as exc:
-            # Connection never established — the request never reached the
-            # server, so a single retry is safe and cannot duplicate work.
+        except (
+            httpx.ConnectError,
+            httpx.ConnectTimeout,
+            httpx.RemoteProtocolError,
+        ) as exc:
+            # Connection never established, or the server closed a pooled
+            # keep-alive connection before sending a response (stale-reuse
+            # race) — the request was not processed, so a single retry is
+            # safe and cannot duplicate work.
             last_error = exc
             if attempt == 0:
-                time.sleep(0.1)
+                with profile_step(
+                    "search.embedding.api.retry_backoff",
+                    retry_reason=type(exc).__name__,
+                    retry_backoff_ms=int(_EMBEDDING_RETRY_BACKOFF_SECONDS * 1000),
+                    attempt=attempt + 1,
+                    max_attempts=2,
+                ):
+                    time.sleep(_EMBEDDING_RETRY_BACKOFF_SECONDS)
         except (httpx.HTTPError, json.JSONDecodeError, ValueError) as exc:
             # The server already received the request: a read timeout means it
             # is still encoding, and retrying would queue a second identical

package/plugin/vendor/reflexio/reflexio/server/llm/providers/openclaw_provider.py

@@ -0,0 +1,280 @@
+"""openClaw CLI as a LiteLLM custom provider.
+
+Routes ``litellm.completion(model="openclaw/...", ...)`` through the
+user's locally-installed ``openclaw`` CLI by spawning
+``openclaw infer model run --prompt <p> --json [--model <m>]``.
+
+Activation is opt-in via ``OPENCLAW_SMART_USE_LOCAL_CLI=1``. Without it,
+the provider does not register and reflexio falls back to its normal
+provider priority. Every spawn sets ``OPENCLAW_SMART_INTERNAL=1`` so the
+openclaw-smart plugin's hooks short-circuit when this provider invokes
+the CLI (recursion guard).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import shutil
+import subprocess  # noqa: S404 — subprocess is the integration point.
+from pathlib import Path
+from typing import Any
+
+import litellm
+from litellm.llms.custom_llm import CustomLLM
+from litellm.types.utils import Choices, Message, ModelResponse, Usage
+
+_LOGGER = logging.getLogger(__name__)
+
+PROVIDER_KEY = "openclaw"
+ENV_ENABLE = "OPENCLAW_SMART_USE_LOCAL_CLI"
+ENV_CLI_PATH = "OPENCLAW_BIN"
+ENV_DEFAULT_MODEL = "OPENCLAW_DEFAULT_MODEL"
+ENV_TIMEOUT = "OPENCLAW_CLI_TIMEOUT"
+_DEFAULT_TIMEOUT_SECONDS = 180
+
+_TRUTHY = {"1", "true", "yes"}
+
+# Module-level state reset by tests via the _reset_module_state fixture.
+_REGISTERED: bool = False
+_HANDLER: OpenClawLLM | None = None
+
+
+class OpenClawCLIError(RuntimeError):
+    """Raised when the openclaw CLI subprocess fails."""
+
+
+def _env_enabled() -> bool:
+    """Return True when OPENCLAW_SMART_USE_LOCAL_CLI is truthy.
+
+    Returns:
+        bool: True if the opt-in env var is set to a truthy value, else False.
+    """
+    return os.environ.get(ENV_ENABLE, "").lower() in _TRUTHY
+
+
+def _resolve_cli_path() -> str | None:
+    """Resolve the openclaw CLI absolute path.
+
+    Honors ``OPENCLAW_BIN`` env override, otherwise falls back to
+    ``shutil.which("openclaw")``.
+
+    Returns:
+        str | None: Absolute path to the openclaw binary, or None if not found.
+    """
+    override = os.environ.get(ENV_CLI_PATH)
+    if override:
+        path = Path(override)
+        if path.is_file() and os.access(override, os.X_OK):
+            return override
+    return shutil.which("openclaw")
+
+
+def is_openclaw_available() -> bool:
+    """Return True when the openclaw provider is usable right now.
+
+    Both the opt-in env var *and* a resolvable CLI path are required.
+
+    Returns:
+        bool: True iff ``OPENCLAW_SMART_USE_LOCAL_CLI`` is truthy AND a
+            CLI binary is resolvable.
+    """
+    return _env_enabled() and _resolve_cli_path() is not None
+
+
+def _extract_text(payload: Any) -> str:
+    """Extract the model's text reply from openclaw's JSON output.
+
+    The exact field name in ``openclaw infer model run --json`` output
+    couldn't be probed at design time (no model providers were
+    auth-configured). Scan common keys in priority order: ``text`` →
+    ``content`` → ``output`` → ``message.content``. The first end-to-end
+    test will surface the real key; we can pin it then if needed.
+
+    Args:
+        payload (Any): Parsed JSON response from openclaw.
+
+    Returns:
+        str: Completion text, or empty string if no known key matches.
+    """
+    if not isinstance(payload, dict):
+        return ""
+    for key in ("text", "content", "output"):
+        value = payload.get(key)
+        if isinstance(value, str):
+            return value
+    msg = payload.get("message")
+    if isinstance(msg, dict) and isinstance(msg.get("content"), str):
+        return msg["content"]
+    return ""
+
+
+def _call_cli(*, prompt: str, model: str | None, timeout_s: int) -> str:
+    """Invoke openclaw CLI for a one-shot completion.
+
+    Args:
+        prompt (str): User prompt text passed via ``--prompt``.
+        model (str | None): Optional model id passed via ``--model``.
+        timeout_s (int): Subprocess timeout in seconds.
+
+    Returns:
+        str: Completion text extracted from the CLI's JSON stdout.
+
+    Raises:
+        OpenClawCLIError: If the CLI is not found, exits non-zero, returns
+            non-JSON stdout, or returns JSON with no recognized text field.
+    """
+    cli = _resolve_cli_path()
+    if not cli:
+        raise OpenClawCLIError("openclaw CLI not found; set OPENCLAW_BIN")
+
+    argv = [cli, "infer", "model", "run", "--prompt", prompt, "--json"]
+    if model:
+        argv += ["--model", model]
+
+    env = os.environ.copy()
+    env["OPENCLAW_SMART_INTERNAL"] = "1"
+
+    try:
+        proc = subprocess.run(  # noqa: S603 — argv is fully constructed.
+            argv,
+            env=env,
+            capture_output=True,
+            text=True,
+            timeout=timeout_s,
+            check=False,
+        )
+    except subprocess.TimeoutExpired as exc:
+        raise OpenClawCLIError(f"openclaw timed out after {timeout_s}s") from exc
+
+    if proc.returncode != 0:
+        raise OpenClawCLIError(
+            proc.stderr.strip() or f"openclaw exit {proc.returncode}"
+        )
+
+    try:
+        payload = json.loads(proc.stdout)
+    except json.JSONDecodeError as exc:
+        raise OpenClawCLIError(
+            f"openclaw returned non-JSON: {proc.stdout[:200]}"
+        ) from exc
+
+    text = _extract_text(payload)
+    if not text:
+        raise OpenClawCLIError(
+            f"openclaw JSON had no completion text: {list(payload)[:5]}"
+        )
+    return text
+
+
+class OpenClawLLM(CustomLLM):
+    """LiteLLM CustomLLM that routes completions through the openclaw CLI."""
+
+    def completion(self, *args: Any, **kwargs: Any) -> ModelResponse:  # noqa: ARG002 — LiteLLM CustomLLM signature
+        """Synchronous completion via ``openclaw infer model run``.
+
+        The ``openclaw/`` prefix is stripped from the requested model id.
+        If no model is provided, ``OPENCLAW_DEFAULT_MODEL`` is used; if
+        that's also unset, the CLI's own default is used.
+
+        Args:
+            *args: Unused (LiteLLM signature).
+            **kwargs: LiteLLM completion kwargs (``messages``, ``model``).
+
+        Returns:
+            ModelResponse: Reply text in ``choices[0].message.content``.
+        """
+        # ``kwargs.get("model")`` can be ``None`` — coercing via ``str(...)``
+        # would yield the literal "None" and skip the default-model fallback.
+        raw_model = kwargs.get("model")
+        model_kwarg = "" if raw_model is None else str(raw_model)
+        if "/" in model_kwarg:
+            model = model_kwarg.split("/", 1)[1] or None
+        else:
+            model = model_kwarg or None
+        if not model:
+            model = os.environ.get(ENV_DEFAULT_MODEL) or None
+
+        messages = kwargs.get("messages", [])
+        prompt = _messages_to_prompt(messages)
+        # An invalid OPENCLAW_CLI_TIMEOUT must not crash the completion path —
+        # fall back to the default with a warning so misconfiguration degrades
+        # to working-but-slow rather than working-then-erroring.
+        raw_timeout = os.environ.get(ENV_TIMEOUT)
+        try:
+            timeout_s = (
+                int(raw_timeout)
+                if raw_timeout is not None
+                else _DEFAULT_TIMEOUT_SECONDS
+            )
+        except ValueError:
+            _LOGGER.warning(
+                "Invalid %s=%r; using default %d",
+                ENV_TIMEOUT,
+                raw_timeout,
+                _DEFAULT_TIMEOUT_SECONDS,
+            )
+            timeout_s = _DEFAULT_TIMEOUT_SECONDS
+
+        text = _call_cli(prompt=prompt, model=model, timeout_s=timeout_s)
+
+        return ModelResponse(
+            choices=[Choices(message=Message(content=text, role="assistant"))],
+            usage=Usage(prompt_tokens=0, completion_tokens=0, total_tokens=0),
+            model=model_kwarg or "openclaw",
+        )
+
+
+def _messages_to_prompt(messages: list[dict[str, Any]]) -> str:
+    """Flatten chat messages into a single prompt string.
+
+    ``openclaw infer model run`` takes a single ``--prompt``; we serialize
+    the chat as ``role: content`` lines separated by blank lines. Content
+    blocks (lists) are flattened to text.
+
+    Args:
+        messages (list[dict[str, Any]]): LiteLLM-style chat messages.
+
+    Returns:
+        str: Newline-joined role:content lines.
+    """
+    parts: list[str] = []
+    for m in messages:
+        role = m.get("role", "user")
+        content = m.get("content", "")
+        if isinstance(content, list):
+            content = "".join(c.get("text", "") for c in content if isinstance(c, dict))
+        parts.append(f"{role}: {content}")
+    return "\n\n".join(parts)
+
+
+def register_if_enabled() -> bool:
+    """Register the openclaw provider with LiteLLM if the opt-in env is set.
+
+    Idempotent: safe to call multiple times.
+
+    Returns:
+        bool: True if the provider is now registered, False if env is off or
+            the CLI is missing.
+    """
+    global _REGISTERED, _HANDLER
+    if _REGISTERED:
+        return True
+    if not _env_enabled():
+        return False
+    if not _resolve_cli_path():
+        _LOGGER.warning(
+            "%s=1 but openclaw CLI not found; set %s",
+            ENV_ENABLE,
+            ENV_CLI_PATH,
+        )
+        return False
+    _HANDLER = OpenClawLLM()
+    litellm.custom_provider_map = [
+        *getattr(litellm, "custom_provider_map", []),
+        {"provider": PROVIDER_KEY, "custom_handler": _HANDLER},
+    ]
+    _REGISTERED = True
+    _LOGGER.info("Registered openclaw LiteLLM provider")
+    return True

package/plugin/vendor/reflexio/reflexio/server/llm/rerank/cross_encoder_reranker.py

@@ -150,7 +150,18 @@ def score_pairs(query: str, docs: list[str]) -> list[float]:
         return []
     model = _get_model()
     pairs = [(query, doc) for doc in docs]
-    raw_scores = model.predict(pairs, show_progress_bar=False)
+    try:
+        from torch import nn
+    except ImportError as e:
+        raise CrossEncoderUnavailableError(
+            "torch is not installed; cannot use the cross-encoder reranker"
+        ) from e
+
+    raw_scores = model.predict(
+        pairs,
+        show_progress_bar=False,
+        activation_fn=nn.Identity(),
+    )
     # ``predict`` returns a numpy array; convert to plain Python floats so
     # the caller can serialise the result without numpy as a dependency.
     return [float(s) for s in raw_scores]

package/plugin/vendor/reflexio/reflexio/server/llm/token_accounting.py

@@ -0,0 +1,48 @@
+"""Plain, dependency-free per-run token accounting (OSS-safe).
+
+Folds the per-turn token counts already present on a ToolLoopTrace into a single
+run total. The enterprise billing layer converts this into a TokenUsage; OSS never
+imports reflexio_ext.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(slots=True)
+class RunTokenTotals:
+    """Accumulated token counts for a single extraction agent run."""
+
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+
+    def add(self, *, prompt_tokens: int | None, completion_tokens: int | None) -> None:
+        """Accumulate token counts, treating None as 0.
+
+        Args:
+            prompt_tokens: Prompt token count for one turn, or None if unavailable.
+            completion_tokens: Completion token count for one turn, or None if unavailable.
+        """
+        self.prompt_tokens += int(prompt_tokens or 0)
+        self.completion_tokens += int(completion_tokens or 0)
+
+
+def sum_trace_tokens(trace: Any) -> RunTokenTotals:
+    """Fold a ToolLoopTrace's per-turn token counts into one RunTokenTotals.
+
+    Args:
+        trace: A ToolLoopTrace (or duck-typed equivalent) with a ``turns`` attribute.
+            Each turn may have ``prompt_tokens`` and ``completion_tokens`` attributes.
+
+    Returns:
+        RunTokenTotals with the summed prompt and completion tokens across all turns.
+    """
+    totals = RunTokenTotals()
+    for turn in getattr(trace, "turns", []) or []:
+        totals.add(
+            prompt_tokens=getattr(turn, "prompt_tokens", None),
+            completion_tokens=getattr(turn, "completion_tokens", None),
+        )
+    return totals