claude-smart 0.2.41 → 0.2.43

package/plugin/vendor/reflexio/reflexio/models/api_schema/service_schemas.py

@@ -0,0 +1,9 @@
+# Backward compatibility — all models are now organized in domain/ and ui/ subpackages.
+# Import from those packages directly for new code:
+#   from reflexio.models.api_schema.domain import Interaction, UserProfile, ...
+#   from reflexio.models.api_schema.ui import InteractionView, ProfileView, ...
+
+# ruff: noqa: I001 — import order is deliberate: domain enums must shadow ui enums
+from .common import *  # noqa: F401, F403
+from .ui import *  # noqa: F401, F403
+from .domain import *  # noqa: F401, F403

package/plugin/vendor/reflexio/reflexio/models/api_schema/stall_state_schema.py

@@ -0,0 +1,32 @@
+"""Pydantic models for the stall_state HTTP endpoint."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+StallReason = Literal["billing_error", "auth_error"]
+"""Canonical stall-reason discriminator.
+
+Imported by the storage layer (``sqlite_storage._stall_state``) and the
+LiteLLM provider's stream parser so all three layers share one source of
+truth for the allowed values."""
+
+
+class StallStateResponse(BaseModel):
+    """Returned by GET /stall_state."""
+
+    stalled: bool = Field(..., description="True when learning is currently paused.")
+    reason: StallReason | None = None
+    stalled_at: datetime | None = None
+    reset_estimate: datetime | None = None
+    notified_in_cc: bool = False
+    error_message: str | None = None
+
+
+class MarkNotifiedResponse(BaseModel):
+    """Returned by POST /stall_state/notified."""
+
+    notified_in_cc: bool

package/plugin/vendor/reflexio/reflexio/models/api_schema/ui/__init__.py

@@ -0,0 +1,3 @@
+from .converters import *  # noqa: F401, F403
+from .entities import *  # noqa: F401, F403
+from .enums import *  # noqa: F401, F403

package/plugin/vendor/reflexio/reflexio/models/api_schema/ui/converters.py

@@ -0,0 +1,177 @@
+"""Converters from domain models to UI View models.
+
+This module bridges the domain layer and UI layer. It imports from both
+domain/entities (input types) and ui/entities (output types).
+"""
+
+from ..domain.entities import (
+    AgentPlaybook,
+    AgentSuccessEvaluationResult,
+    Interaction,
+    ProfileChangeLog,
+    UserPlaybook,
+    UserProfile,
+)
+from .entities import (
+    AgentPlaybookView,
+    EvaluationResultView,
+    InteractionView,
+    ProfileChangeLogView,
+    ProfileView,
+    UserPlaybookView,
+)
+
+__all__ = [
+    "to_interaction_view",
+    "to_profile_view",
+    "to_user_playbook_view",
+    "to_agent_playbook_view",
+    "to_evaluation_result_view",
+    "to_profile_change_log_view",
+]
+
+
+def to_interaction_view(interaction: Interaction) -> InteractionView:
+    """Convert internal Interaction to user-facing InteractionView.
+
+    Args:
+        interaction (Interaction): Full internal interaction
+
+    Returns:
+        InteractionView: View without embedding and image_encoding
+    """
+    return InteractionView(
+        interaction_id=interaction.interaction_id,
+        user_id=interaction.user_id,
+        request_id=interaction.request_id,
+        created_at=interaction.created_at,
+        role=interaction.role,
+        content=interaction.content,
+        user_action=interaction.user_action,
+        user_action_description=interaction.user_action_description,
+        interacted_image_url=interaction.interacted_image_url,
+        shadow_content=interaction.shadow_content,
+        expert_content=interaction.expert_content,
+        tools_used=interaction.tools_used,
+    )
+
+
+def to_profile_view(profile: UserProfile) -> ProfileView:
+    """Convert internal UserProfile to user-facing ProfileView.
+
+    Args:
+        profile (UserProfile): Full internal user profile
+
+    Returns:
+        ProfileView: View without embedding
+    """
+    return ProfileView(
+        profile_id=profile.profile_id,
+        user_id=profile.user_id,
+        content=profile.content,
+        last_modified_timestamp=profile.last_modified_timestamp,
+        generated_from_request_id=profile.generated_from_request_id,
+        profile_time_to_live=profile.profile_time_to_live,
+        expiration_timestamp=profile.expiration_timestamp,
+        custom_features=profile.custom_features,
+        source=profile.source,
+        status=profile.status,
+        extractor_names=profile.extractor_names,
+        source_span=profile.source_span,
+    )
+
+
+def to_user_playbook_view(rf: UserPlaybook) -> UserPlaybookView:
+    """Convert internal UserPlaybook to user-facing UserPlaybookView.
+
+    Args:
+        rf (UserPlaybook): Full internal user playbook
+
+    Returns:
+        UserPlaybookView: View without embedding
+    """
+    return UserPlaybookView(
+        user_playbook_id=rf.user_playbook_id,
+        user_id=rf.user_id,
+        agent_version=rf.agent_version,
+        request_id=rf.request_id,
+        playbook_name=rf.playbook_name,
+        created_at=rf.created_at,
+        content=rf.content,
+        trigger=rf.trigger,
+        rationale=rf.rationale,
+        status=rf.status,
+        source=rf.source,
+        source_interaction_ids=rf.source_interaction_ids,
+        source_span=rf.source_span,
+    )
+
+
+def to_agent_playbook_view(fb: AgentPlaybook) -> AgentPlaybookView:
+    """Convert internal AgentPlaybook to user-facing AgentPlaybookView.
+
+    Args:
+        fb (AgentPlaybook): Full internal agent playbook
+
+    Returns:
+        AgentPlaybookView: View without embedding
+    """
+    return AgentPlaybookView(
+        agent_playbook_id=fb.agent_playbook_id,
+        playbook_name=fb.playbook_name,
+        agent_version=fb.agent_version,
+        created_at=fb.created_at,
+        content=fb.content,
+        trigger=fb.trigger,
+        rationale=fb.rationale,
+        playbook_status=fb.playbook_status,
+        playbook_metadata=fb.playbook_metadata,
+        status=fb.status,
+    )
+
+
+def to_evaluation_result_view(
+    result: AgentSuccessEvaluationResult,
+) -> EvaluationResultView:
+    """Convert internal AgentSuccessEvaluationResult to user-facing EvaluationResultView.
+
+    Args:
+        result (AgentSuccessEvaluationResult): Full internal evaluation result
+
+    Returns:
+        EvaluationResultView: View without embedding
+    """
+    return EvaluationResultView(
+        result_id=result.result_id,
+        agent_version=result.agent_version,
+        session_id=result.session_id,
+        is_success=result.is_success,
+        failure_type=result.failure_type,
+        failure_reason=result.failure_reason,
+        evaluation_name=result.evaluation_name,
+        created_at=result.created_at,
+        regular_vs_shadow=result.regular_vs_shadow,
+        number_of_correction_per_session=result.number_of_correction_per_session,
+        user_turns_to_resolution=result.user_turns_to_resolution,
+        is_escalated=result.is_escalated,
+    )
+
+
+def to_profile_change_log_view(log: ProfileChangeLog) -> ProfileChangeLogView:
+    """Convert internal ProfileChangeLog to user-facing ProfileChangeLogView.
+
+    Args:
+        log (ProfileChangeLog): Full internal profile change log
+
+    Returns:
+        ProfileChangeLogView: View with ProfileView lists instead of UserProfile lists
+    """
+    return ProfileChangeLogView(
+        id=log.id,
+        user_id=log.user_id,
+        request_id=log.request_id,
+        created_at=log.created_at,
+        added_profiles=[to_profile_view(p) for p in log.added_profiles],
+        removed_profiles=[to_profile_view(p) for p in log.removed_profiles],
+        mentioned_profiles=[to_profile_view(p) for p in log.mentioned_profiles],
+    )

package/plugin/vendor/reflexio/reflexio/models/api_schema/ui/entities.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime
+
+from pydantic import BaseModel, Field, field_validator
+
+from ..common import NEVER_EXPIRES_TIMESTAMP, ToolUsed
+from ..validators import _validate_image_url
+from .enums import (
+    PlaybookStatus,
+    ProfileTimeToLive,
+    RegularVsShadow,
+    Status,
+    UserActionType,
+)
+
+__all__ = [
+    "InteractionView",
+    "ProfileView",
+    "UserPlaybookView",
+    "AgentPlaybookView",
+    "EvaluationResultView",
+    "ProfileChangeLogView",
+]
+
+# ===============================
+# View Models (user-facing, without embeddings)
+# ===============================
+
+
+class InteractionView(BaseModel):
+    """User-facing Interaction — excludes embedding and image_encoding."""
+
+    interaction_id: int = 0
+    user_id: str
+    request_id: str
+    created_at: int = Field(default_factory=lambda: int(datetime.now(UTC).timestamp()))
+    role: str = "User"
+    content: str = ""
+    user_action: UserActionType = UserActionType.NONE
+    user_action_description: str = ""
+    interacted_image_url: str = ""
+    shadow_content: str = ""
+    expert_content: str = ""
+    tools_used: list[ToolUsed] = Field(default_factory=list)
+
+    @field_validator("interacted_image_url", mode="after")
+    @classmethod
+    def validate_image_url(cls, v: str) -> str:
+        return _validate_image_url(v)
+
+
+class ProfileView(BaseModel):
+    """User-facing UserProfile — excludes embedding."""
+
+    profile_id: str
+    user_id: str
+    content: str
+    last_modified_timestamp: int
+    generated_from_request_id: str
+    profile_time_to_live: ProfileTimeToLive = ProfileTimeToLive.INFINITY
+    expiration_timestamp: int = NEVER_EXPIRES_TIMESTAMP
+    custom_features: dict | None = None
+    source: str | None = None
+    status: Status | None = None
+    extractor_names: list[str] | None = None
+    source_span: str | None = None
+
+
+class UserPlaybookView(BaseModel):
+    """User-facing UserPlaybook — excludes embedding."""
+
+    user_playbook_id: int = 0
+    user_id: str | None = None
+    agent_version: str
+    request_id: str
+    playbook_name: str = ""
+    created_at: int = Field(default_factory=lambda: int(datetime.now(UTC).timestamp()))
+    content: str = ""
+    trigger: str | None = None
+    rationale: str | None = None
+    status: Status | None = None
+    source: str | None = None
+    source_interaction_ids: list[int] = Field(default_factory=list)
+    source_span: str | None = None
+
+
+class AgentPlaybookView(BaseModel):
+    """User-facing AgentPlaybook — excludes embedding."""
+
+    agent_playbook_id: int = 0
+    playbook_name: str = ""
+    agent_version: str
+    created_at: int = Field(default_factory=lambda: int(datetime.now(UTC).timestamp()))
+    content: str
+    trigger: str | None = None
+    rationale: str | None = None
+    playbook_status: PlaybookStatus = PlaybookStatus.PENDING
+    playbook_metadata: str = ""
+    status: Status | None = None
+
+
+class EvaluationResultView(BaseModel):
+    """User-facing AgentSuccessEvaluationResult — excludes embedding."""
+
+    result_id: int = 0
+    agent_version: str
+    session_id: str
+    is_success: bool
+    failure_type: str | None = None
+    failure_reason: str | None = None
+    evaluation_name: str | None = None
+    created_at: int = Field(default_factory=lambda: int(datetime.now(UTC).timestamp()))
+    regular_vs_shadow: RegularVsShadow | None = None
+    number_of_correction_per_session: int = 0
+    user_turns_to_resolution: int | None = None
+    is_escalated: bool = False
+
+
+class ProfileChangeLogView(BaseModel):
+    """User-facing ProfileChangeLog — uses ProfileView lists."""
+
+    id: int
+    user_id: str
+    request_id: str
+    created_at: int = Field(default_factory=lambda: int(datetime.now(UTC).timestamp()))
+    added_profiles: list[ProfileView]
+    removed_profiles: list[ProfileView]
+    mentioned_profiles: list[ProfileView]

package/plugin/vendor/reflexio/reflexio/models/api_schema/ui/enums.py

@@ -0,0 +1,25 @@
+"""UI-layer enums — re-export domain enums to keep type identity shared.
+
+Previously this module declared duplicate StrEnum classes with the same
+variants as the domain enums. That broke type identity for pyright — the
+UI enum and the domain enum were seen as distinct types even though their
+values matched. Re-exporting means ``reflexio.models.api_schema.ui.enums.UserActionType``
+and ``reflexio.models.api_schema.domain.enums.UserActionType`` are the same
+class, and converter functions don't need casts.
+"""
+
+from reflexio.models.api_schema.domain.enums import (
+    PlaybookStatus,
+    ProfileTimeToLive,
+    RegularVsShadow,
+    Status,
+    UserActionType,
+)
+
+__all__ = [
+    "PlaybookStatus",
+    "ProfileTimeToLive",
+    "RegularVsShadow",
+    "Status",
+    "UserActionType",
+]

package/plugin/vendor/reflexio/reflexio/models/api_schema/validators.py

@@ -0,0 +1,280 @@
+"""
+Reusable Pydantic v2 validator types for reflexio.models.
+
+This module provides:
+1. **Data Integrity Validators** - NonEmptyStr, EmbeddingVector, numeric constraints
+2. **Security Validators** - SafeHttpUrl (SSRF prevention), SanitizedStr (prompt injection mitigation)
+3. **Mixins** - TimeRangeValidatorMixin for models with start_time/end_time
+
+Usage:
+    from reflexio.models.api_schema.validators import (
+        NonEmptyStr, SafeHttpUrl, SanitizedNonEmptyStr, EmbeddingVector, ...
+    )
+"""
+
+from __future__ import annotations
+
+import ipaddress
+import os
+import re
+from typing import Annotated, Any
+from urllib.parse import urlparse
+
+from pydantic import AfterValidator, HttpUrl
+
+# Embedding vector dimensions — must match config_schema.EMBEDDING_DIMENSIONS.
+# Duplicated here to avoid circular imports (config_schema imports from this module).
+EMBEDDING_DIMENSIONS = 512
+
+
+# =============================================================================
+# Data Integrity Validators
+# =============================================================================
+
+
+def _check_non_empty_str(v: str) -> str:
+    """Validate that a string is not empty or whitespace-only after stripping.
+
+    Args:
+        v (str): The string to validate
+
+    Returns:
+        str: The stripped string
+
+    Raises:
+        ValueError: If the string is empty or whitespace-only
+    """
+    stripped = v.strip()
+    if not stripped:
+        raise ValueError("String must not be empty or whitespace-only")
+    return stripped
+
+
+def _check_optional_non_empty_str(v: str | None) -> str | None:
+    """Validate that an optional string, if provided, is not empty or whitespace-only.
+
+    Args:
+        v (Optional[str]): The string to validate, or None
+
+    Returns:
+        Optional[str]: The stripped string, or None
+
+    Raises:
+        ValueError: If the string is provided but empty or whitespace-only
+    """
+    if v is None:
+        return v
+    stripped = v.strip()
+    if not stripped:
+        raise ValueError("String must not be empty or whitespace-only")
+    return stripped
+
+
+def _check_embedding_dimensions(v: list[float]) -> list[float]:
+    """Validate that an embedding vector is either empty or has the correct dimensions.
+
+    Args:
+        v (list[float]): The embedding vector
+
+    Returns:
+        list[float]: The validated embedding vector
+
+    Raises:
+        ValueError: If the embedding has wrong dimensions (not empty and not EMBEDDING_DIMENSIONS)
+    """
+    if len(v) > 0 and len(v) != EMBEDDING_DIMENSIONS:
+        raise ValueError(
+            f"Embedding must be empty or have exactly {EMBEDDING_DIMENSIONS} dimensions, "
+            f"got {len(v)}"
+        )
+    return v
+
+
+# Reusable Annotated types for data integrity
+NonEmptyStr = Annotated[str, AfterValidator(_check_non_empty_str)]
+"""String that rejects empty/whitespace-only values. Strips leading/trailing whitespace."""
+
+OptionalNonEmptyStr = Annotated[
+    str | None, AfterValidator(_check_optional_non_empty_str)
+]
+"""Optional string that, if provided, rejects empty/whitespace-only values."""
+
+EmbeddingVector = Annotated[list[float], AfterValidator(_check_embedding_dimensions)]
+"""Embedding vector that must be either empty or exactly EMBEDDING_DIMENSIONS (512) floats."""
+
+
+# =============================================================================
+# Security Validators — SSRF Prevention
+# =============================================================================
+
+# Cloud metadata endpoints — ALWAYS blocked (no legitimate use case)
+METADATA_HOSTS = {"metadata.google.internal"}
+METADATA_IPS = {"169.254.169.254", "fd00:ec2::254"}  # AWS/GCP/Azure
+
+
+def _is_strict_mode() -> bool:
+    """Check if strict URL validation is enabled (for production).
+
+    Returns:
+        bool: True if REFLEXIO_BLOCK_PRIVATE_URLS env var is set to true/1/yes
+    """
+    return os.environ.get("REFLEXIO_BLOCK_PRIVATE_URLS", "").lower() in (
+        "true",
+        "1",
+        "yes",
+    )
+
+
+def _check_safe_url(v: Any) -> Any:
+    """Validate URL is not targeting dangerous resources.
+
+    Always blocks: cloud metadata endpoints, non-http schemes.
+    In strict mode (REFLEXIO_BLOCK_PRIVATE_URLS=true): also blocks private IPs and localhost.
+
+    Args:
+        v: The URL value (HttpUrl or string)
+
+    Returns:
+        The validated URL value
+
+    Raises:
+        ValueError: If the URL targets a dangerous resource
+    """
+    url_str = str(v)
+    parsed = urlparse(url_str)
+    host = (parsed.hostname or "").lower()
+
+    # ALWAYS block cloud metadata (never legitimate)
+    if host in METADATA_HOSTS:
+        raise ValueError(f"URL must not target cloud metadata: {host}")
+
+    try:
+        ip = ipaddress.ip_address(host)
+        if str(ip) in METADATA_IPS:
+            raise ValueError(f"URL must not target cloud metadata endpoint: {host}")
+
+        # In strict mode, also block private/localhost
+        if _is_strict_mode() and (
+            ip.is_private or ip.is_reserved or ip.is_loopback or ip.is_link_local
+        ):
+            raise ValueError(
+                f"URL targets private/reserved IP '{host}'. "
+                f"If running locally, unset REFLEXIO_BLOCK_PRIVATE_URLS."
+            )
+    except ValueError as e:
+        if "must not target" in str(e) or "targets private" in str(e):
+            raise
+        # Not an IP (hostname) — check localhost in strict mode
+        if _is_strict_mode() and host in ("localhost", "0.0.0.0"):  # noqa: S104
+            raise ValueError(
+                f"URL targets '{host}'. "
+                f"If running locally, unset REFLEXIO_BLOCK_PRIVATE_URLS."
+            ) from None
+
+    return v
+
+
+SafeHttpUrl = Annotated[HttpUrl, AfterValidator(_check_safe_url)]
+"""HTTP URL that blocks cloud metadata endpoints (always) and private IPs (in strict mode).
+
+Use for: api_base, endpoint — anywhere the server fetches a user-provided URL.
+
+Local dev:  works out of the box (localhost allowed)
+Production: set REFLEXIO_BLOCK_PRIVATE_URLS=true in env/Dockerfile for full protection
+"""
+
+
+# =============================================================================
+# Security Validators — Prompt Injection Mitigation
+# =============================================================================
+
+# Control characters that can manipulate prompt rendering or terminal output.
+# Excludes tab (\x09), newline (\x0a), carriage return (\x0d) which are legitimate.
+_CONTROL_CHAR_PATTERN = re.compile(
+    r"[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]"  # C0 control chars except \t \n \r
+)
+
+
+def _strip_control_chars(v: str) -> str:
+    """Remove invisible control characters that could manipulate prompt rendering.
+
+    Strips C0 control characters (NULL, bell, backspace, escape sequences, etc.)
+    while preserving tabs, newlines, and carriage returns.
+
+    Args:
+        v (str): The string to sanitize
+
+    Returns:
+        str: The sanitized string with control characters removed
+    """
+    return _CONTROL_CHAR_PATTERN.sub("", v)
+
+
+SanitizedStr = Annotated[str, AfterValidator(_strip_control_chars)]
+"""String with control characters stripped. Use for user content flowing into LLM prompts."""
+
+SanitizedNonEmptyStr = Annotated[
+    str,
+    AfterValidator(_strip_control_chars),
+    AfterValidator(_check_non_empty_str),
+]
+"""String that is sanitized (control chars stripped) AND non-empty. Use for config prompts."""
+
+
+# =============================================================================
+# Time Range Validator Mixin
+# =============================================================================
+
+
+def _validate_image_url(v: str) -> str:
+    """SSRF prevention: if URL is provided, must be safe http(s) or data URI.
+
+    Args:
+        v (str): The image URL to validate
+
+    Returns:
+        str: The validated URL
+
+    Raises:
+        ValueError: If the URL scheme is not http, https, or data, or if it targets unsafe resources
+    """
+    if not v:
+        return v
+    parsed = urlparse(v)
+    if parsed.scheme not in ("http", "https", "data"):
+        raise ValueError(
+            f"Image URL scheme must be http, https, or data — got '{parsed.scheme}'"
+        )
+    if parsed.scheme in ("http", "https"):
+        _check_safe_url(v)
+    return v
+
+
+class TimeRangeValidatorMixin:
+    """Mixin for models with optional start_time/end_time fields.
+
+    Validates that end_time is after start_time when both are provided.
+    Add to models by including in the class bases alongside BaseModel.
+
+    Usage:
+        class MyRequest(TimeRangeValidatorMixin, BaseModel):
+            start_time: Optional[datetime] = None
+            end_time: Optional[datetime] = None
+    """
+
+    # Note: This is implemented as a classmethod to be called from
+    # @model_validator(mode='after') in each model, rather than using
+    # __init_subclass__ magic that could conflict with Pydantic's metaclass.
+    @staticmethod
+    def validate_time_range(start_time: Any, end_time: Any) -> None:
+        """Validate that end_time is after start_time.
+
+        Args:
+            start_time: The start time value
+            end_time: The end time value
+
+        Raises:
+            ValueError: If end_time is not after start_time
+        """
+        if start_time is not None and end_time is not None and end_time <= start_time:
+            raise ValueError("end_time must be after start_time")