claude-smart 0.2.45 → 0.2.46

package/plugin/vendor/reflexio/reflexio/server/api_endpoints/precondition_checks.py

@@ -20,6 +20,13 @@ def validate_publish_user_interaction_request(
     if not request.interaction_data_list:
         return False, "No interaction data provided"
 
+    # Defense-in-depth: session_id is a required NonEmptyStr on
+    # PublishUserInteractionRequest, so the normal validated API path already
+    # rejects empty/missing values with a 422. This guard additionally covers
+    # paths that bypass Pydantic validation (e.g. ``model_construct``).
+    if not request.session_id or not request.session_id.strip():
+        return False, "session_id is required and cannot be empty"
+
     for interaction_data in request.interaction_data_list:
         if (
             interaction_data.user_action != UserActionType.NONE

package/plugin/vendor/reflexio/reflexio/server/api_endpoints/request_context.py

@@ -17,7 +17,9 @@ class RequestContext:
         self.storage_base_dir = storage_base_dir
         cls = get_configurator_class()
         self.configurator = configurator or cls(org_id, base_dir=storage_base_dir)
-        self.prompt_manager = PromptManager()
+        self.prompt_manager = PromptManager(
+            extra_prompt_bank_paths=self.configurator.get_prompt_bank_paths()
+        )
         self.storage = self.configurator.create_storage(
             storage_config=self.configurator.get_current_storage_configuration(),
         )

package/plugin/vendor/reflexio/reflexio/server/billing_meter.py

@@ -0,0 +1,173 @@
+"""OSS emission helpers: translate billing signals into usage_events.
+
+The single source of truth for each billing event's name/category/fields. Plain
+primitive signatures (no reflexio_ext types) so OSS call sites — the generation
+service and search endpoints — can use them directly. Each is a thin, non-blocking
+wrapper over the ``record_usage_event`` hook (which only enqueues). No DB I/O.
+"""
+
+from __future__ import annotations
+
+from reflexio.server.usage_metrics import record_usage_event
+
+_INTERNAL = (
+    "internal"  # == BillingCallerType.INTERNAL.value (kept literal; OSS stays clean)
+)
+
+
+def record_extraction_tokens(
+    *,
+    org_id: str,
+    billing_input_tokens: int,
+    prompt_tokens: int,
+    completion_tokens: int,
+    platform_llm: bool | None,
+    platform_storage: bool | None,
+    pipeline: str | None = None,
+    request_id: str | None = None,
+    session_id: str | None = None,
+) -> None:
+    """Emit the Learning cost facet — call only when extraction fired.
+
+    No-op when ``billing_input_tokens <= 0``.
+
+    Args:
+        org_id: Organisation identifier.
+        billing_input_tokens: Input-anchored token count (the metered basis).
+        prompt_tokens: Real provider prompt tokens (COGS; not billed to customer).
+        completion_tokens: Real provider completion tokens (COGS; not billed).
+        platform_llm: True iff the platform supplies the LLM for this org.
+        platform_storage: True iff the platform supplies storage; None defers to rollup.
+        pipeline: Optional pipeline tag (e.g. ``"profile"``).
+        request_id: Optional request correlation ID.
+        session_id: Optional session ID.
+    """
+    if billing_input_tokens <= 0:
+        return
+    record_usage_event(
+        org_id=org_id,
+        event_name="extraction_tokens",
+        event_category="learning",
+        pipeline=pipeline,
+        request_id=request_id,
+        session_id=session_id,
+        count_value=billing_input_tokens,
+        prompt_tokens=prompt_tokens,
+        completion_tokens=completion_tokens,
+        billing_input_tokens=billing_input_tokens,
+        platform_llm=platform_llm,
+        platform_storage=platform_storage,
+        caller_type=_INTERNAL,
+    )
+
+
+def record_learnings_generated(
+    *,
+    org_id: str,
+    count: int,
+    platform_llm: bool | None,
+    platform_storage: bool | None,
+    pipeline: str | None = None,
+    request_id: str | None = None,
+    session_id: str | None = None,
+) -> None:
+    """Emit the Learning value facet — number of profiles/playbooks generated.
+
+    No-op when ``count <= 0``.
+
+    Args:
+        org_id: Organisation identifier.
+        count: Number of learnings generated in this run.
+        platform_llm: True iff the platform supplies the LLM for this org.
+        platform_storage: True iff the platform supplies storage; None defers to rollup.
+        pipeline: Optional pipeline tag (e.g. ``"playbook"``).
+        request_id: Optional request correlation ID.
+        session_id: Optional session ID.
+    """
+    if count <= 0:
+        return
+    record_usage_event(
+        org_id=org_id,
+        event_name="learnings_generated",
+        event_category="learning",
+        pipeline=pipeline,
+        request_id=request_id,
+        session_id=session_id,
+        count_value=count,
+        platform_llm=platform_llm,
+        platform_storage=platform_storage,
+        caller_type=_INTERNAL,
+    )
+
+
+def record_applied_learnings(
+    *,
+    org_id: str,
+    surfaced_count: int,
+    caller_type: str,
+    platform_llm: bool | None,
+    platform_storage: bool | None,
+    pipeline: str | None = None,
+    request_id: str | None = None,
+    session_id: str | None = None,
+) -> None:
+    """Emit the Application line — surfaced top-K learnings.
+
+    No-op unless ``caller_type == "production_agent"`` AND ``surfaced_count > 0``.
+
+    Args:
+        org_id: Organisation identifier.
+        surfaced_count: Number of learnings surfaced in the search response.
+        caller_type: Caller classification string (e.g. ``"production_agent"``).
+        platform_llm: True iff the platform supplies the LLM for this org.
+        platform_storage: True iff the platform supplies storage; None defers to rollup.
+        pipeline: Optional pipeline tag.
+        request_id: Optional request correlation ID.
+        session_id: Optional session ID.
+    """
+    if caller_type != "production_agent" or surfaced_count <= 0:
+        return
+    record_usage_event(
+        org_id=org_id,
+        event_name="learning_applied",
+        event_category="application",
+        pipeline=pipeline,
+        request_id=request_id,
+        session_id=session_id,
+        count_value=surfaced_count,
+        platform_llm=platform_llm,
+        platform_storage=platform_storage,
+        caller_type=caller_type,
+    )
+
+
+def record_search_request(
+    *,
+    org_id: str,
+    caller_type: str,
+    request_id: str | None = None,
+    session_id: str | None = None,
+) -> None:
+    """Emit one analytics-only search request count for production agents.
+
+    No-op unless ``caller_type == "production_agent"``. Unlike
+    :func:`record_applied_learnings`, empty search responses still count because
+    this measures requests made, not learnings surfaced.
+
+    Args:
+        org_id: Organisation identifier.
+        caller_type: Caller classification string.
+        request_id: Optional request correlation ID.
+        session_id: Optional session ID.
+    """
+    if caller_type != "production_agent":
+        return
+    record_usage_event(
+        org_id=org_id,
+        event_name="search_request",
+        event_category="application",
+        request_id=request_id,
+        session_id=session_id,
+        count_value=1,
+        caller_type=caller_type,
+    )

package/plugin/vendor/reflexio/reflexio/server/billing_signals.py

@@ -0,0 +1,64 @@
+"""OSS-pure billing signal helpers (no reflexio_ext imports).
+
+Single source of truth for whether the platform supplies the LLM, so the OSS
+generation service and the enterprise attribution resolver never diverge.
+Also provides the one canonical input-anchored tokenizer for the whole platform.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+import tiktoken
+
+# One fixed canonical encoding for the whole platform. Changing this is a
+# price-book-affecting decision; do not make it model-dependent.
+_CANONICAL_ENCODING_NAME = "cl100k_base"
+_encoding = tiktoken.get_encoding(_CANONICAL_ENCODING_NAME)
+
+
+def count_input_tokens(text: str) -> int:
+    """Count billable input tokens for ``text`` under the canonical cl100k_base encoding.
+
+    This is the single canonical tokenizer for the whole platform. Enterprise
+    code delegates here so OSS and enterprise always use the same encoding.
+
+    Args:
+        text (str): The input text to tokenize.
+
+    Returns:
+        int: Number of tokens under cl100k_base, or 0 for empty input.
+    """
+    if not text:
+        return 0
+    return len(_encoding.encode(text, disallowed_special=()))
+
+
+def platform_llm_from_config(config: Any) -> bool:
+    """Return True iff Reflexio (not the customer) supplies the LLM for ``config``.
+
+    A populated ``api_key_config`` provider sub-config means BYO-LLM → False.
+    A missing/empty ``api_key_config`` means platform-supplied → True.
+
+    Args:
+        config: The org's resolved ``Config`` object, or None.
+
+    Returns:
+        bool: True when the platform supplies the LLM; False when the customer
+            has configured a BYO provider key.
+    """
+    api_key_config = getattr(config, "api_key_config", None)
+    if api_key_config is None:
+        return True
+    data = (
+        api_key_config.model_dump(exclude_none=True)
+        if hasattr(api_key_config, "model_dump")
+        else {}
+    )
+    # Guard against a model_dump that returns a non-mapping: without this,
+    # `.values()` would raise. Default to platform-supplied (True) on a shape
+    # we don't understand rather than misclassifying the org as BYO-LLM.
+    if not isinstance(data, Mapping):
+        return True
+    return not any(bool(v) for v in data.values())

package/plugin/vendor/reflexio/reflexio/server/cache/reflexio_cache.py

@@ -8,6 +8,7 @@ from typing import Any, Final
 from cachetools import TTLCache
 
 from reflexio.lib.reflexio_lib import Reflexio
+from reflexio.server.tracing import profile_step
 
 logger = logging.getLogger(__name__)
 
@@ -112,8 +113,14 @@ def get_reflexio(org_id: str, storage_base_dir: str | None = None) -> Reflexio:
 
     # Cache lookup — held briefly to extract the entry, then released
     # before doing any I/O (file stat, DB query) for the version probe.
-    with _reflexio_cache_lock:
-        entry: _CacheEntry | None = _reflexio_cache.get(cache_key)
+    with profile_step("reflexio.cache.lookup") as span:
+        with _reflexio_cache_lock:
+            entry: _CacheEntry | None = _reflexio_cache.get(cache_key)
+        span.set_data("cache_hit", entry is not None)
+        span.set_data(
+            "has_cached_version",
+            entry is not None and entry.cached_version is not None,
+        )
 
     if entry is not None:
         cached_version = entry.cached_version
@@ -122,7 +129,13 @@ def get_reflexio(org_id: str, storage_base_dir: str | None = None) -> Reflexio:
         # rely on TTL + explicit invalidation instead.
         if cached_version is None:
             return entry.reflexio
-        current_version = _probe_version_safe(entry.reflexio)
+        with profile_step("reflexio.cache.version_probe", cache_state="hit") as span:
+            current_version = _probe_version_safe(entry.reflexio)
+            span.set_data("probe_failed", current_version is _PROBE_FAILED)
+            span.set_data(
+                "probe_supported",
+                current_version is not None and current_version is not _PROBE_FAILED,
+            )
         # Transient probe failure: keep the cached instance for this
         # request but DON'T mutate the stamp — the next request will
         # try again, so a brief outage doesn't permanently disable
@@ -134,15 +147,27 @@ def get_reflexio(org_id: str, storage_base_dir: str | None = None) -> Reflexio:
         # Stale entry. Evict only if the cached version still matches
         # the one we just compared against — another thread may have
         # already replaced the entry while we were probing.
-        with _reflexio_cache_lock:
-            existing = _reflexio_cache.get(cache_key)
-            if existing is not None and existing.cached_version == cached_version:
-                del _reflexio_cache[cache_key]
+        with profile_step("reflexio.cache.evict_stale") as span:
+            with _reflexio_cache_lock:
+                existing = _reflexio_cache.get(cache_key)
+                evicted = (
+                    existing is not None and existing.cached_version == cached_version
+                )
+                if evicted:
+                    del _reflexio_cache[cache_key]
+            span.set_data("evicted", evicted)
 
     # Cache miss (or just-evicted stale entry) - create a new instance
     # outside the lock to avoid blocking concurrent requests for other orgs.
-    reflexio = Reflexio(org_id=org_id, storage_base_dir=storage_base_dir)
-    new_version = _probe_version_safe(reflexio)
+    with profile_step("reflexio.cache.construct"):
+        reflexio = Reflexio(org_id=org_id, storage_base_dir=storage_base_dir)
+    with profile_step("reflexio.cache.version_probe", cache_state="miss") as span:
+        new_version = _probe_version_safe(reflexio)
+        span.set_data("probe_failed", new_version is _PROBE_FAILED)
+        span.set_data(
+            "probe_supported",
+            new_version is not None and new_version is not _PROBE_FAILED,
+        )
 
     # Construction-time probe failure: serve this request from the
     # newly-built instance but DON'T cache it. Caching with
@@ -159,13 +184,18 @@ def get_reflexio(org_id: str, storage_base_dir: str | None = None) -> Reflexio:
         cached_version=new_version,  # type: ignore[arg-type]
     )
 
-    with _reflexio_cache_lock:
-        # Double-check in case another thread populated while we were constructing.
-        existing = _reflexio_cache.get(cache_key)
-        if existing is None:
-            _reflexio_cache[cache_key] = new_entry
-            return reflexio
-        return existing.reflexio
+    with profile_step("reflexio.cache.store") as span:
+        with _reflexio_cache_lock:
+            # Double-check in case another thread populated while we were constructing.
+            existing = _reflexio_cache.get(cache_key)
+            stored = existing is None
+            if stored:
+                _reflexio_cache[cache_key] = new_entry
+                result = reflexio
+            else:
+                result = existing.reflexio
+        span.set_data("stored", stored)
+        return result
 
 
 def invalidate_reflexio_cache(org_id: str, storage_base_dir: str | None = None) -> bool:

package/plugin/vendor/reflexio/reflexio/server/env_utils.py

@@ -0,0 +1,65 @@
+"""Small helpers for parsing environment-backed settings."""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Mapping
+
+
+def env_get(env: Mapping[str, str], name: str) -> str:
+    """Return a stripped environment value or an empty string."""
+    return str(env.get(name, "")).strip()
+
+
+def env_str(
+    name: str,
+    default: str = "",
+    *,
+    env: Mapping[str, str] | None = None,
+) -> str:
+    """Return an environment value, treating unset OR blank as the default.
+
+    Unlike ``os.getenv(name, default)``, an empty / whitespace-only value
+    resolves to ``default`` rather than passing the empty string through. This
+    closes the "set to blank behaves differently from unset" gap: a ``KEY=``
+    line (which python-dotenv exports as ``""``) and an absent key both yield
+    the default, so callers never silently receive ``""`` where they expected a
+    real fallback (e.g. an ``int()``/``float()`` parse that would crash on ``""``).
+
+    Args:
+        name: Environment variable name.
+        default: Value returned when the variable is unset or blank.
+        env: Mapping to read from; defaults to ``os.environ``.
+
+    Returns:
+        The stripped environment value, or ``default`` when unset/blank.
+    """
+    raw = (env if env is not None else os.environ).get(name)
+    return raw.strip() if raw and raw.strip() else default
+
+
+def env_required(env: Mapping[str, str], name: str) -> str:
+    """Return a required environment value or raise a startup error."""
+    value = env_get(env, name)
+    if not value:
+        raise RuntimeError(f"{name} is required for enterprise startup")
+    return value
+
+
+def env_required_literal(
+    env: Mapping[str, str],
+    name: str,
+    *,
+    allowed: tuple[str, ...],
+) -> str:
+    """Return a required lowercased value constrained to allowed literals."""
+    value = env_required(env, name).lower()
+    if value not in allowed:
+        allowed_text = " or ".join(repr(item) for item in allowed)
+        raise RuntimeError(f"{name} must be {allowed_text} (got {value!r})")
+    return value
+
+
+def env_truthy(value: str) -> bool:
+    """Return whether a string environment value is truthy."""
+    return value.strip().lower() in {"1", "true", "yes", "on"}

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

@@ -34,6 +34,16 @@ _SUPPORTED_MODELS = {
 _ACTIVE_MODEL: str | None = None
 _ACTIVE_MODEL_LOCK = threading.Lock()
 
+# The underlying sentence-transformers / ONNX embedders share internal buffers
+# and are NOT thread-safe: concurrent ``.embed()`` calls interleave and corrupt
+# each other's padding/attention tensors (observed under concurrent publishes as
+# ``RuntimeError: The size of tensor a (62) must match the size of tensor b (61)
+# at non-singleton dimension 1``). The ``_ENCODE_SEMAPHORE`` below only caps how
+# many requests run at once (for memory), it does NOT serialize them, so this
+# lock guards the actual model inference. Throughput comes from micro-batch
+# coalescing (many texts per encode), not from parallel encodes on one model.
+_MODEL_ENCODE_LOCK = threading.Lock()
+
 DEFAULT_OSS_EMBEDDING_MODEL = MINILM_MODEL
 
 # Bound how many embed/encode calls run at once. The endpoint is a sync ``def``
@@ -314,10 +324,15 @@ def _encode_texts_now(model: str, texts: list[str]) -> list[list[float]]:
         )
         semaphore.acquire()
     try:
-        if is_nomic_model(model):
-            return NomicEmbedder.get().embed(texts)
-        if model == MINILM_MODEL:
-            return LocalEmbedder.get().embed(texts)
+        # Serialize the actual inference: the shared embedder models are not
+        # thread-safe, so concurrent encodes race and produce tensor-shape
+        # errors. The semaphore (above) bounds memory; this lock bounds the
+        # model to one in-flight encode at a time.
+        with _MODEL_ENCODE_LOCK:
+            if is_nomic_model(model):
+                return NomicEmbedder.get().embed(texts)
+            if model == MINILM_MODEL:
+                return LocalEmbedder.get().embed(texts)
         raise HTTPException(status_code=400, detail=f"Unsupported model: {model}")
     finally:
         semaphore.release()