claude-smart 0.2.44 → 0.2.46

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

@@ -9,7 +9,8 @@ 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 typing import Any
 
 from reflexio.server.llm.rerank import score_pairs
 from reflexio.server.llm.rerank.cross_encoder_reranker import (
@@ -20,6 +21,14 @@ from reflexio.server.tracing import profile_step
 logger = logging.getLogger(__name__)
 
 
+def _floor_and_sort[T](items: list[T], scores: list[float], floor: float) -> list[T]:
+    """Return items scoring >= ``floor``, sorted by score descending."""
+    ranked = sorted(
+        zip(items, scores, strict=True), key=lambda pair: pair[1], reverse=True
+    )
+    return [item for item, score in ranked if score >= floor]
+
+
 def apply_relevance_floor[T](
     query: str,
     items: list[T],
@@ -62,11 +71,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 = _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 +84,74 @@ 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[list[Any]]:
+    """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 survivor list per arm, in input order — each sorted by score
+        descending and capped at ``top_k``. On reranker unavailability,
+        every arm returns ``items[:top_k]`` unchanged (logged).
+    """
+    if not any(items for _, items, _ in arms):
+        return [[] 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),
+    ) 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 top_k)",
+                arm_names,
+                len(contents),
+            )
+            return [items[:top_k] for _, items, _ in arms]
+        span.set_data("available", True)
+
+        results: list[list[Any]] = []
+        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(survivors[:top_k])
+        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,27 @@ class StorageError(Exception):
 
     def __str__(self):
         return f"StorageError: {self.message}"
+
+
+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"
+    )

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

@@ -36,15 +36,6 @@ RETENTION_TARGETS: tuple[RetentionTarget, ...] = (
         "created_at",
         ("result_id",),
     ),
-    RetentionTarget(
-        "profile_change_logs", "profile_change_logs", "created_at", ("id",)
-    ),
-    RetentionTarget(
-        "playbook_aggregation_change_logs",
-        "playbook_aggregation_change_logs",
-        "created_at",
-        ("id",),
-    ),
     RetentionTarget("share_links", "share_links", "created_at", ("id",)),
     RetentionTarget(
         "agent_playbook_source_user_playbooks",
@@ -76,6 +67,12 @@ RETENTION_TARGETS: tuple[RetentionTarget, ...] = (
         "created_at",
         ("event_id",),
     ),
+    RetentionTarget(
+        "playbook_retrieval_logs",
+        "playbook_retrieval_logs",
+        "created_at",
+        ("retrieval_log_id",),
+    ),
     RetentionTarget("skills", "skills", "created_at", ("skill_id",)),
 )
 
@@ -117,6 +114,9 @@ RETENTION_CASCADES: dict[str, tuple[CascadeRef, ...]] = {
     "playbook_optimization_candidates": (
         CascadeRef("playbook_optimization_evaluations", "candidate_id"),
     ),
+    "playbook_retrieval_logs": (
+        CascadeRef("playbook_retrieval_log_items", "retrieval_log_id"),
+    ),
 }
 
 

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/__init__.py

@@ -8,6 +8,7 @@ from ._base import (
     _vector_rank_rows,
 )
 from ._extras import ExtrasMixin
+from ._lineage import SQLiteLineageMixin
 from ._operations import OperationMixin
 from ._playbook import PlaybookMixin
 from ._profiles import ProfileMixin
@@ -31,6 +32,7 @@ class SQLiteStorage(
     ProfileMixin,
     RequestMixin,
     PlaybookMixin,
+    SQLiteLineageMixin,
     OperationMixin,
     ExtrasMixin,
     SQLiteShareLinkMixin,

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/_agent_run.py

@@ -26,7 +26,10 @@ from ._base import SQLiteStorageBase, _json_dumps, _json_loads
 def _dt(value: str | None) -> datetime | None:
     if value is None:
         return None
-    return datetime.fromisoformat(value)
+    parsed = datetime.fromisoformat(value)
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=UTC)
+    return parsed
 
 
 def _dt_str(value: datetime | None) -> str | None: