claude-smart 0.2.46 → 0.2.48

package/plugin/vendor/reflexio/reflexio/server/routes/_metering.py

@@ -0,0 +1,98 @@
+"""Billing money-path metering helpers shared by search + playbook routes (Tier3 A2).
+
+These emit the ③ Application / search-request billing signals. They resolve
+``get_reflexio`` through the ``reflexio_cache`` module (not a bound import) so a
+single ``patch("reflexio.server.cache.reflexio_cache.get_reflexio")`` at the
+source intercepts the lookup regardless of which route module calls them.
+"""
+
+import logging
+import time
+
+from fastapi import Request
+
+from reflexio.server.cache import reflexio_cache
+
+logger = logging.getLogger(__name__)
+
+
+def _stamp_search_dependencies_done(request: Request) -> None:
+    """Stamp when dependency resolution reaches its final search dependency."""
+    request.state.search_deps_done_monotonic = time.monotonic()
+
+
+def _meter_applied_learnings(
+    *,
+    org_id: str,
+    caller_type: str,
+    surfaced_count: int,
+    request_id: str | None = None,
+    session_id: str | None = None,
+) -> None:
+    """Emit the ③ Application event via the OSS emission helper.
+
+    No-op unless a production-agent caller surfaced >= 1 result.  The cheap
+    caller-type and count guard runs first so the get_reflexio / config lookup
+    is skipped on the free paths (dashboard / empty result).
+
+    Args:
+        org_id: Organization ID for the requesting caller.
+        caller_type: Resolved caller classification (e.g. ``"production_agent"``).
+        surfaced_count: Total number of learnings returned to the caller.
+        request_id: Optional request correlation ID from the payload.
+        session_id: Optional session ID from the payload.
+    """
+    if caller_type != "production_agent" or surfaced_count <= 0:
+        return
+    try:
+        from reflexio.server.billing_meter import record_applied_learnings
+        from reflexio.server.billing_signals import platform_llm_from_config
+
+        config = reflexio_cache.get_reflexio(
+            org_id=org_id
+        ).request_context.configurator.get_config()
+        record_applied_learnings(
+            org_id=org_id,
+            surfaced_count=surfaced_count,
+            caller_type=caller_type,
+            platform_llm=platform_llm_from_config(config),
+            platform_storage=None,  # resolved enterprise-side at rollup (Phase 1)
+            request_id=request_id,
+            session_id=session_id,
+        )
+    except Exception:
+        logger.warning(
+            "applied-learnings metering failed for org %s", org_id, exc_info=True
+        )
+
+
+def _meter_search_request(
+    *,
+    org_id: str,
+    caller_type: str,
+    request_id: str | None = None,
+    session_id: str | None = None,
+) -> None:
+    """Emit one production-agent search request metric.
+
+    Args:
+        org_id: Organization ID for the requesting caller.
+        caller_type: Resolved caller classification.
+        request_id: Optional request correlation ID from the payload.
+        session_id: Optional session ID from the payload.
+    """
+    if caller_type != "production_agent":
+        return
+    try:
+        from reflexio.server.billing_meter import record_search_request
+
+        record_search_request(
+            org_id=org_id,
+            caller_type=caller_type,
+            request_id=request_id,
+            session_id=session_id,
+        )
+    except Exception:
+        logger.warning(
+            "search-request metering failed for org %s", org_id, exc_info=True
+        )

package/plugin/vendor/reflexio/reflexio/server/routes/braintrust.py

@@ -0,0 +1,129 @@
+"""Braintrust connector route handlers (extracted from api.py, Tier3 A2)."""
+
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    pass
+
+from fastapi import (
+    APIRouter,
+    Depends,
+    Request,
+)
+
+from reflexio.models.api_schema.braintrust_schema import (
+    BraintrustStatusResponse,
+    ConnectBraintrustRequest,
+    ConnectBraintrustResponse,
+    SelectProjectsRequest,
+    SelectProjectsResponse,
+    SyncBraintrustResponse,
+)
+from reflexio.server.auth import (
+    default_get_org_id,
+)
+from reflexio.server.cache import reflexio_cache
+from reflexio.server.rate_limit import limiter
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+
+@router.post(
+    "/api/braintrust/connect",
+    response_model=ConnectBraintrustResponse,
+    response_model_exclude_none=True,
+)
+@limiter.limit("10/minute")
+def braintrust_connect(
+    request: Request,
+    payload: ConnectBraintrustRequest,
+    org_id: str = Depends(default_get_org_id),
+) -> ConnectBraintrustResponse:
+    """Step 1: validate the Braintrust API key and list workspaces/projects.
+
+    Persists nothing — call `/api/braintrust/select_projects` to commit.
+
+    Args:
+        request (Request): The HTTP request object for rate limiting.
+        payload (ConnectBraintrustRequest): Customer's Braintrust API key.
+        org_id (str): Resolved by auth dependency.
+
+    Returns:
+        ConnectBraintrustResponse: Workspaces tree on success; `success=False`
+            with a message when the key is rejected.
+    """
+    reflexio = reflexio_cache.get_reflexio(org_id=org_id)
+    return reflexio.braintrust_connect(payload)
+
+
+@router.post(
+    "/api/braintrust/select_projects",
+    response_model=SelectProjectsResponse,
+    response_model_exclude_none=True,
+)
+@limiter.limit("10/minute")
+def braintrust_select_projects(
+    request: Request,
+    payload: SelectProjectsRequest,
+    org_id: str = Depends(default_get_org_id),
+) -> SelectProjectsResponse:
+    """Step 2: commit the Braintrust connection with selected projects.
+
+    The API key is encrypted at rest. Subsequent syncs use the persisted
+    connection until the customer calls DELETE /api/braintrust/connection.
+    """
+    reflexio = reflexio_cache.get_reflexio(org_id=org_id)
+    return reflexio.braintrust_select_projects(payload)
+
+
+@router.get(
+    "/api/braintrust/status",
+    response_model=BraintrustStatusResponse,
+    response_model_exclude_none=True,
+)
+def braintrust_status(
+    org_id: str = Depends(default_get_org_id),
+) -> BraintrustStatusResponse:
+    """Return Braintrust connection state. Never echoes the API key."""
+    reflexio = reflexio_cache.get_reflexio(org_id=org_id)
+    return reflexio.braintrust_status()
+
+
+@router.delete("/api/braintrust/connection")
+@limiter.limit("10/minute")
+def braintrust_disconnect(
+    request: Request,
+    org_id: str = Depends(default_get_org_id),
+) -> dict:
+    """Delete the persisted Braintrust connection for the org.
+
+    Args:
+        org_id (str): Resolved by auth dependency.
+
+    Returns:
+        dict: ``{"success": True}`` on completion.
+    """
+    reflexio = reflexio_cache.get_reflexio(org_id=org_id)
+    reflexio.braintrust_disconnect()
+    return {"success": True}
+
+
+@router.post(
+    "/api/braintrust/sync",
+    response_model=SyncBraintrustResponse,
+    response_model_exclude_none=True,
+)
+@limiter.limit("10/minute")
+def braintrust_sync(
+    request: Request,
+    org_id: str = Depends(default_get_org_id),
+) -> SyncBraintrustResponse:
+    """Trigger a one-shot sync of Braintrust scorer outputs.
+
+    Scheduled (cron) sync is a follow-up; for now the endpoint exists so
+    operators can drive a manual import.
+    """
+    reflexio = reflexio_cache.get_reflexio(org_id=org_id)
+    return reflexio.braintrust_sync()

package/plugin/vendor/reflexio/reflexio/server/routes/config.py

@@ -0,0 +1,210 @@
+"""Config route handlers (extracted from api.py, Tier3 A2)."""
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    pass
+
+from fastapi import (
+    APIRouter,
+    Depends,
+    HTTPException,
+    Request,
+    status,
+)
+
+from reflexio.models.api_schema.retriever_schema import (
+    SetConfigResponse,
+)
+from reflexio.models.api_schema.service_schemas import (
+    MyConfigResponse,
+)
+from reflexio.models.config_schema import (
+    Config,
+)
+from reflexio.server.api_endpoints import (
+    account_api,
+)
+from reflexio.server.auth import (
+    default_get_org_id,
+)
+from reflexio.server.cache import reflexio_cache
+from reflexio.server.rate_limit import limiter
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+
+@router.get(
+    "/api/my_config",
+    response_model=MyConfigResponse,
+    response_model_exclude_none=True,
+)
+def my_config_endpoint(
+    request: Request,
+    org_id: str = Depends(default_get_org_id),
+) -> MyConfigResponse:
+    """Return raw storage credentials for the caller's org.
+
+    Enablement is controlled by two independent opt-ins so the endpoint
+    is closed by default on unauthenticated self-host deployments:
+
+    - ``request.app.state.my_config_enabled`` — set to True by
+      :func:`create_app` when the host wires in a Bearer-auth
+      ``get_org_id`` dependency, so enterprise callers are always
+      authenticated before they reach this route.
+    - ``REFLEXIO_ALLOW_MY_CONFIG=true`` — OS self-host escape hatch.
+
+    If neither is set we return a closed response instead of a 404 so
+    the CLI can display an actionable hint.
+    """
+    app_state_enabled = bool(getattr(request.app.state, "my_config_enabled", False))
+    if not (app_state_enabled or account_api.my_config_allowed()):
+        return MyConfigResponse(
+            success=False,
+            message=(
+                "GET /api/my_config is disabled. Set "
+                "REFLEXIO_ALLOW_MY_CONFIG=true to enable."
+            ),
+        )
+    return account_api.my_config(org_id=org_id)
+
+
+@router.post("/api/set_config")
+@limiter.limit("10/minute")
+def set_config(
+    request: Request,
+    config: dict[str, Any],
+    org_id: str = Depends(default_get_org_id),
+) -> SetConfigResponse:
+    """Set configuration for the organization.
+
+    Args:
+        config (dict[str, Any]): The configuration payload to set
+        org_id (str): Organization ID
+
+    Returns:
+        dict: Response containing success status and message
+    """
+    from pydantic import ValidationError
+
+    # Create Reflexio instance to access the configurator through request_context
+    reflexio = reflexio_cache.get_reflexio(org_id=org_id)
+    configurator = reflexio.request_context.configurator
+    normalized_config = configurator.normalize_config_payload(config)
+    if not isinstance(normalized_config, dict):
+        normalized_config = config
+    try:
+        Config.model_validate(normalized_config)
+    except ValidationError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail=exc.errors(),
+        ) from exc
+
+    # Set the config using Reflexio's set_config method
+    response = reflexio.set_config(normalized_config)
+
+    # Invalidate cache on successful config change to ensure fresh instance next request
+    if response.success:
+        reflexio_cache.invalidate_reflexio_cache(org_id=org_id)
+
+    return response
+
+
+@router.post("/api/update_config")
+@limiter.limit("10/minute")
+def update_config(
+    request: Request,
+    partial: dict[str, Any],
+    org_id: str = Depends(default_get_org_id),
+) -> SetConfigResponse:
+    """Apply a partial update to the org's config (PATCH semantics).
+
+    Performs a **top-level shallow merge** of *partial* over the existing
+    config and round-trips through ``Config(**merged)`` so Pydantic
+    validates the result and rejects bogus top-level fields.
+
+    .. warning::
+       Nested objects (e.g. ``storage_config``, ``profile_extractor_config``,
+       ``user_playbook_extractor_config``) are **replaced wholesale**.
+       Deep merging is intentionally not supported -- the discriminator on
+       ``storage_config`` would be lost on partial updates, and merging nested
+       dicts has ambiguous semantics.
+
+       To update a field inside an extractor config you must resend that
+       extractor object fully populated (including ``extractor_name``,
+       ``extraction_definition_prompt``, etc.). For one-off mutations prefer
+       ``GET /api/get_config`` followed by ``POST /api/set_config`` with the
+       modified full config.
+
+    Unlike :func:`set_config`, callers do not need to re-send the full
+    config (including required fields like ``storage_config``) just to
+    flip a single top-level boolean. The merge happens server-side
+    atomically within the request, eliminating the read-modify-write
+    race a client would otherwise hit.
+
+    Args:
+        partial: Top-level fields to overlay on the existing config.
+        org_id: Organization ID resolved by the auth layer.
+
+    Returns:
+        SetConfigResponse: Success status and message from
+        :meth:`Reflexio.set_config`.
+    """
+    from pydantic import ValidationError
+
+    reflexio = reflexio_cache.get_reflexio(org_id=org_id)
+    existing_config = reflexio.request_context.configurator.get_config()
+    existing = existing_config.model_dump(mode="python")
+    merged = {**existing, **partial}
+    # Pydantic validates the merged shape and rejects unknown / malformed
+    # fields here, before storage validation in reflexio.set_config.
+    # Convert ValidationError into 422 so callers passing a partial that
+    # would replace a nested extractor object with an incomplete dict (e.g.
+    # {"user_playbook_extractor_config": {"aggregation_config": {...}}})
+    # get a clean client-error response instead of a 500.
+    try:
+        merged_config = Config(**merged)
+    except ValidationError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail={
+                "error": "Invalid partial config (top-level shallow merge)",
+                "hint": (
+                    "Nested objects (e.g. user_playbook_extractor_config) "
+                    "are replaced wholesale, not deep-merged. To mutate a "
+                    "single nested field, fetch the full config via "
+                    "/api/get_config, edit, and POST it back via "
+                    "/api/set_config."
+                ),
+                "validation_errors": exc.errors(),
+            },
+        ) from exc
+    if merged_config.model_dump(mode="python") == existing:
+        logger.info("Skipping no-op config update for org %s", org_id)
+        return SetConfigResponse(success=True, msg="Configuration unchanged")
+
+    response = reflexio.set_config(merged_config)
+    if response.success:
+        reflexio_cache.invalidate_reflexio_cache(org_id=org_id)
+    return response
+
+
+@router.get("/api/get_config")
+def get_config(
+    org_id: str = Depends(default_get_org_id),
+) -> dict[str, Any]:
+    """Get configuration for the organization.
+
+    Args:
+        org_id (str): Organization ID
+
+    Returns:
+        Config: The current configuration
+    """
+    # Create Reflexio instance to access the configurator through request_context
+    reflexio = reflexio_cache.get_reflexio(org_id=org_id)
+
+    return reflexio.request_context.configurator.get_config_for_response()