claude-smart 0.2.45 → 0.2.47

package/plugin/vendor/reflexio/reflexio/server/services/retrieval/recency.py

@@ -0,0 +1,211 @@
+"""Recency adjustment helpers for unified search ranking."""
+
+from __future__ import annotations
+
+import logging
+import math
+from collections.abc import Mapping
+from dataclasses import dataclass, replace
+from datetime import UTC, datetime
+
+from reflexio.server.env_utils import env_str, env_truthy
+
+logger = logging.getLogger(__name__)
+
+SECONDS_PER_DAY = 24 * 60 * 60
+PLAYBOOK_HALF_LIFE_SECONDS = 90 * SECONDS_PER_DAY
+_PROFILE_TTL_HALF_LIFE_FRACTION = 0.5
+
+
+@dataclass(frozen=True)
+class ScoredItem[T]:
+    item: T
+    score: float | None
+
+
+@dataclass(frozen=True)
+class RecencyConfig:
+    enabled: bool = True
+    max_penalty_frac: float = 0.15
+    max_penalty_logit: float = 0.2
+    pool_size: int = 20
+
+    @classmethod
+    def from_env(cls, *, env: Mapping[str, str] | None = None) -> RecencyConfig:
+        return cls(
+            enabled=env_truthy(
+                env_str("REFLEXIO_SEARCH_RECENCY_ENABLED", "true", env=env)
+            ),
+            max_penalty_frac=_float_env(
+                "REFLEXIO_SEARCH_RECENCY_MAX_PENALTY_FRAC",
+                cls.max_penalty_frac,
+                env=env,
+                minimum=0.0,
+                maximum=1.0,
+            ),
+            max_penalty_logit=_float_env(
+                "REFLEXIO_SEARCH_RECENCY_MAX_PENALTY_LOGIT",
+                cls.max_penalty_logit,
+                env=env,
+                minimum=0.0,
+            ),
+            pool_size=_int_env(
+                "REFLEXIO_SEARCH_RECENCY_POOL_SIZE",
+                cls.pool_size,
+                env=env,
+                minimum=1,
+            ),
+        )
+
+    def with_overrides(self, values: Mapping[str, object] | None) -> RecencyConfig:
+        if not values:
+            return self
+        updates: dict[str, object] = {}
+        if "recency_enabled" in values:
+            updates["enabled"] = _bool_value(values["recency_enabled"], self.enabled)
+        if "recency_max_penalty_frac" in values:
+            updates["max_penalty_frac"] = _float_value(
+                values["recency_max_penalty_frac"],
+                self.max_penalty_frac,
+                minimum=0.0,
+                maximum=1.0,
+            )
+        if "recency_max_penalty_logit" in values:
+            updates["max_penalty_logit"] = _float_value(
+                values["recency_max_penalty_logit"],
+                self.max_penalty_logit,
+                minimum=0.0,
+            )
+        if "recency_pool_size" in values:
+            updates["pool_size"] = _int_value(
+                values["recency_pool_size"], self.pool_size, minimum=1
+            )
+        return replace(self, **updates)
+
+
+def decay_for_item(
+    item: object,
+    *,
+    entity_type: str,
+    now: int | None = None,
+) -> float:
+    """Return a freshness decay in [0, 1], where 1 means no penalty."""
+    now = now if now is not None else int(datetime.now(UTC).timestamp())
+    if entity_type == "profiles":
+        return _profile_decay(item, now=now)
+    return _timestamp_decay(
+        getattr(item, "created_at", None),
+        half_life_seconds=PLAYBOOK_HALF_LIFE_SECONDS,
+        now=now,
+    )
+
+
+def decay(age_seconds: float, half_life_seconds: float) -> float:
+    if half_life_seconds <= 0:
+        return 1.0
+    age_seconds = max(0.0, age_seconds)
+    return math.exp(-age_seconds / (half_life_seconds / math.log(2)))
+
+
+def multiplicative_factor(decay_value: float, max_penalty_frac: float) -> float:
+    return 1.0 - _clamp(max_penalty_frac, 0.0, 1.0) * (1.0 - _decay(decay_value))
+
+
+def additive_penalty(decay_value: float, max_penalty_logit: float) -> float:
+    return max(0.0, max_penalty_logit) * (1.0 - _decay(decay_value))
+
+
+def _profile_decay(item: object, *, now: int) -> float:
+    modified_at = _int_or_none(getattr(item, "last_modified_timestamp", None))
+    expires_at = _int_or_none(getattr(item, "expiration_timestamp", None))
+    if modified_at is None or expires_at is None or expires_at <= modified_at:
+        return 1.0
+    half_life = (expires_at - modified_at) * _PROFILE_TTL_HALF_LIFE_FRACTION
+    return decay(now - modified_at, half_life)
+
+
+def _timestamp_decay(value: object, *, half_life_seconds: int, now: int) -> float:
+    timestamp = _int_or_none(value)
+    if timestamp is None or timestamp <= 0:
+        return 1.0
+    return decay(now - timestamp, half_life_seconds)
+
+
+def _float_env(
+    name: str,
+    default: float,
+    *,
+    env: Mapping[str, str] | None,
+    minimum: float,
+    maximum: float | None = None,
+) -> float:
+    return _float_value(
+        env_str(name, str(default), env=env),
+        default,
+        minimum=minimum,
+        maximum=maximum,
+    )
+
+
+def _int_env(
+    name: str,
+    default: int,
+    *,
+    env: Mapping[str, str] | None,
+    minimum: int,
+) -> int:
+    return _int_value(env_str(name, str(default), env=env), default, minimum=minimum)
+
+
+def _bool_value(value: object, default: bool) -> bool:
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str) and value.strip():
+        return env_truthy(value)
+    return default
+
+
+def _float_value(
+    value: object,
+    default: float,
+    *,
+    minimum: float,
+    maximum: float | None = None,
+) -> float:
+    try:
+        if not isinstance(value, str | int | float):
+            raise TypeError
+        parsed = float(value)
+    except (TypeError, ValueError):
+        logger.warning("Invalid recency float override %r; using %.3f", value, default)
+        return default
+    parsed = max(minimum, parsed)
+    if maximum is not None:
+        parsed = min(maximum, parsed)
+    return parsed
+
+
+def _int_value(value: object, default: int, *, minimum: int) -> int:
+    try:
+        if not isinstance(value, str | int):
+            raise TypeError
+        parsed = int(value)
+    except (TypeError, ValueError):
+        logger.warning("Invalid recency integer override %r; using %d", value, default)
+        return default
+    return max(minimum, parsed)
+
+
+def _int_or_none(value: object) -> int | None:
+    try:
+        return int(value)  # type: ignore[arg-type]
+    except (TypeError, ValueError):
+        return None
+
+
+def _decay(value: float) -> float:
+    return _clamp(value, 0.0, 1.0)
+
+
+def _clamp(value: float, low: float, high: float) -> float:
+    return min(high, max(low, value))

package/plugin/vendor/reflexio/reflexio/server/services/retrieval/relevance_floor.py

@@ -9,7 +9,9 @@ never crashes, never silently returns the full unfiltered list.
 from __future__ import annotations
 
 import logging
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+from typing import Any
 
 from reflexio.server.llm.rerank import score_pairs
 from reflexio.server.llm.rerank.cross_encoder_reranker import (
@@ -20,6 +22,22 @@ from reflexio.server.tracing import profile_step
 logger = logging.getLogger(__name__)
 
 
+@dataclass(frozen=True)
+class RelevanceFloorResult:
+    items: list[Any]
+    scores: list[float] | None
+
+
+def _floor_and_sort[T](
+    items: list[T], scores: list[float], floor: float
+) -> list[tuple[T, float]]:
+    """Return ``(item, score)`` pairs scoring >= ``floor``, sorted descending."""
+    ranked = sorted(
+        zip(items, scores, strict=True), key=lambda pair: pair[1], reverse=True
+    )
+    return [(item, score) for item, score in ranked if score >= floor]
+
+
 def apply_relevance_floor[T](
     query: str,
     items: list[T],
@@ -62,11 +80,8 @@ def apply_relevance_floor[T](
             return items[:top_k]
         span.set_data("available", True)
 
-        ranked = sorted(
-            zip(items, scores, strict=True), key=lambda pair: pair[1], reverse=True
-        )
-        survivors = [item for item, score in ranked if score >= floor]
-        dropped = len(ranked) - len(survivors)
+        survivors = [item for item, _score in _floor_and_sort(items, scores, floor)]
+        dropped = len(items) - len(survivors)
         span.set_data("kept", len(survivors))
         span.set_data("dropped", dropped)
         if dropped:
@@ -78,3 +93,81 @@ def apply_relevance_floor[T](
                 floor,
             )
         return survivors[:top_k]
+
+
+def apply_relevance_floors(
+    query: str,
+    arms: Sequence[tuple[str, list[Any], float]],
+    top_k: int,
+    *,
+    content_of: Callable[[Any], str] = lambda item: item.content,
+) -> list[RelevanceFloorResult]:
+    """Floor every arm with a single cross-encoder batch.
+
+    CPU cross-encoder inference does not parallelize across threads, so
+    scoring all arms in one ``score_pairs`` call beats one call per arm:
+    the model runs one batched forward pass and per-call overhead is paid
+    once.
+
+    Args:
+        query: The search query.
+        arms: ``(arm_name, items, floor)`` per arm; items must expose
+            ``.content`` or supply ``content_of``.
+        top_k: Max items to return per arm after flooring.
+        content_of: Extracts the text to score for an item.
+
+    Returns:
+        One result per arm, in input order. Available reranker results are
+        sorted by score descending and left uncapped with the paired raw logits.
+        On reranker unavailability, every arm returns the original full item
+        pool with a ``None`` score sentinel (logged).
+    """
+    if not any(items for _, items, _ in arms):
+        return [RelevanceFloorResult([], []) for _ in arms]
+    arm_names = [name for name, _, _ in arms]
+    contents: list[str] = []
+    for _, items, _ in arms:
+        contents.extend(content_of(item) for item in items)
+    with profile_step(
+        "search.rerank.relevance_floor",
+        arm="all",
+        arms=arm_names,
+        items=len(contents),
+        top_k=top_k,
+    ) as span:
+        try:
+            scores = score_pairs(query, contents)
+        except CrossEncoderUnavailableError:
+            span.set_data("available", False)
+            logger.warning(
+                "event=relevance_floor_unavailable arms=%s items=%d (returning unfiltered pool)",
+                arm_names,
+                len(contents),
+            )
+            return [RelevanceFloorResult(list(items), None) for _, items, _ in arms]
+        span.set_data("available", True)
+
+        results: list[RelevanceFloorResult] = []
+        offset = 0
+        for name, items, floor in arms:
+            arm_scores = scores[offset : offset + len(items)]
+            offset += len(items)
+            survivors = _floor_and_sort(items, arm_scores, floor)
+            dropped = len(items) - len(survivors)
+            span.set_data(f"kept_{name}", len(survivors))
+            span.set_data(f"dropped_{name}", dropped)
+            if dropped:
+                logger.info(
+                    "event=relevance_floor arm=%s kept=%d dropped=%d floor=%.2f",
+                    name,
+                    len(survivors),
+                    dropped,
+                    floor,
+                )
+            results.append(
+                RelevanceFloorResult(
+                    [item for item, _score in survivors],
+                    [score for _item, score in survivors],
+                )
+            )
+        return results

package/plugin/vendor/reflexio/reflexio/server/services/service_utils.py

@@ -3,6 +3,8 @@ Utils for service layer
 """
 
 import ast
+import base64
+import binascii
 import json
 import logging
 import os
@@ -45,6 +47,37 @@ _content_token_encoding: tiktoken.Encoding | None = None
 _INVALID_MAX_TOKENS_WARNED = False
 
 
+def _image_mime_type_from_bytes(image_bytes: bytes) -> str | None:
+    if image_bytes.startswith(b"\xff\xd8\xff"):
+        return "image/jpeg"
+    if image_bytes.startswith(b"\x89PNG\r\n\x1a\n"):
+        return "image/png"
+    if image_bytes.startswith((b"GIF87a", b"GIF89a")):
+        return "image/gif"
+    if image_bytes.startswith(b"RIFF") and image_bytes[8:12] == b"WEBP":
+        return "image/webp"
+    return None
+
+
+def _image_data_url_from_encoding(image_encoding: str) -> str:
+    image_encoding = image_encoding.strip()
+    if image_encoding.startswith("data:image/"):
+        return image_encoding
+
+    compact_encoding = "".join(image_encoding.split())
+    prefix = compact_encoding[:64]
+    prefix += "=" * (-len(prefix) % 4)
+    try:
+        image_header = base64.b64decode(prefix, validate=True)
+    except (binascii.Error, ValueError):
+        raise ValueError("image_encoding must be valid base64 image data") from None
+
+    mime_type = _image_mime_type_from_bytes(image_header)
+    if mime_type is None:
+        raise ValueError("Unsupported image signature in image_encoding")
+    return f"data:{mime_type};base64,{compact_encoding}"
+
+
 def _get_content_token_encoding() -> tiktoken.Encoding:
     """Return a process-cached tiktoken encoder for content slicing."""
     global _content_token_encoding
@@ -500,7 +533,9 @@ def construct_messages_from_interactions(
                 {
                     "type": "image_url",
                     "image_url": {
-                        "url": f"data:image/jpeg;base64,{last_interaction.image_encoding}"
+                        "url": _image_data_url_from_encoding(
+                            last_interaction.image_encoding
+                        )
                     },
                 }
             )

package/plugin/vendor/reflexio/reflexio/server/services/shadow_comparison/README.md

@@ -0,0 +1,8 @@
+# shadow_comparison
+
+Compact LLM-as-judge capability for Reflexio-vs-shadow response comparison.
+
+- `judge.py` owns prompt rendering and the LLM call for one interaction.
+- `outcome.py` owns pure position randomization and Reflexio-relative win/loss/tie derivation.
+
+This package intentionally does not use `components/`: the current two-file split already separates LLM orchestration from pure outcome logic.

package/plugin/vendor/reflexio/reflexio/server/services/shadow_comparison/outcome.py

@@ -15,8 +15,7 @@ from reflexio.models.api_schema.eval_overview_schema import ShadowComparisonVerd
 class Outcome(StrEnum):
     """Reflexio-relative outcome derived from a judge's position-randomized verdict.
 
-    Mirrors the GroupAssignment pattern from F2's group_aggregation module —
-    StrEnum so values serialize transparently to JSON / SQL.
+    Uses StrEnum so values serialize transparently to JSON / SQL.
     """
 
     WIN = "win"

package/plugin/vendor/reflexio/reflexio/server/services/storage/error.py

@@ -1,3 +1,6 @@
+from typing import Any
+
+
 class StorageError(Exception):
     """
     Exception raised for storage errors
@@ -9,3 +12,31 @@ class StorageError(Exception):
 
     def __str__(self):
         return f"StorageError: {self.message}"
+
+
+class SubjectWriteBarrierError(StorageError):
+    """Raised when a write targets a subject with an active erasure barrier."""
+
+
+def require_non_empty_session_id(value: Any) -> str:
+    """Return a stripped, non-empty request ``session_id`` or raise ``StorageError``.
+
+    ``Request.session_id`` is a required non-empty field. Rows persisted before
+    the session-id migration may still carry NULL/blank values; surfacing a
+    typed storage error (rather than a raw Pydantic ``ValidationError`` deep in
+    a read path) tells the operator to run the latest data migrations.
+
+    Args:
+        value (Any): The raw ``session_id`` value read from storage.
+
+    Returns:
+        str: The stripped, non-empty session id.
+
+    Raises:
+        StorageError: If ``value`` is missing or blank.
+    """
+    if isinstance(value, str) and value.strip():
+        return value.strip()
+    raise StorageError(
+        "requests.session_id is missing or empty; run the latest data migrations"
+    )