claude-smart 0.2.45 → 0.2.46

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/_profiles.py

@@ -34,6 +34,7 @@ class ProfileMixin:
         self,
         user_id: str,
         status_filter: list[Status | None] | None = None,
+        tags: list[str] | None = None,
     ) -> list[UserProfile]:
         raise NotImplementedError
 
@@ -78,6 +79,13 @@ class ProfileMixin:
     ) -> None:
         raise NotImplementedError
 
+    @abstractmethod
+    def update_user_profile_tags(
+        self, user_id: str, profile_id: str, tags: list[str]
+    ) -> None:
+        """Replace only the tags of a profile, leaving content and embedding untouched."""
+        raise NotImplementedError
+
     @abstractmethod
     def delete_all_interactions_for_user(self, user_id: str) -> None:
         raise NotImplementedError
@@ -178,6 +186,22 @@ class ProfileMixin:
         """
         raise NotImplementedError
 
+    @abstractmethod
+    def get_profile_by_id(
+        self, profile_id: str, *, include_tombstones: bool = False
+    ) -> UserProfile | None:
+        """Fetch a single profile by primary key.
+
+        Args:
+            profile_id: The profile's primary key.
+            include_tombstones: When False (default), MERGED/SUPERSEDED profiles
+                return None. Set to True for lineage resolution (resolve_current).
+
+        Returns:
+            The UserProfile if found and not filtered, otherwise None.
+        """
+        raise NotImplementedError
+
     @abstractmethod
     def archive_profile_by_id(self, user_id: str, profile_id: str) -> bool:
         """Atomically archive a single profile by id, only if currently CURRENT.
@@ -220,17 +244,113 @@ class ProfileMixin:
         raise NotImplementedError
 
     @abstractmethod
-    def delete_profiles_by_ids(self, profile_ids: list[str]) -> int:
+    def delete_profiles_by_ids(
+        self, profile_ids: list[str], *, emit_hard_delete: bool = True
+    ) -> int:
         """Delete profiles by their IDs.
 
         Args:
             profile_ids (list[str]): List of profile IDs to delete
+            emit_hard_delete (bool): When True (default), emit a ``hard_delete``
+                lineage event for each id before removing the row.  Pass ``False``
+                from rollback callers that cleaned up a never-CURRENT successor to
+                avoid poisoning the audit log with phantom erasures.
 
         Returns:
             int: Number of profiles deleted
         """
         raise NotImplementedError
 
+    @abstractmethod
+    def get_distinct_generated_from_request_ids(self) -> list[str]:
+        """Return the DISTINCT non-empty generated_from_request_id values present on profiles.
+
+        Scoped to the org. Includes profiles of any status (tombstones included) so
+        that an add-only run whose profiles were later tombstoned is still discoverable.
+        Empty-string values are excluded by the query (they must never form a group).
+
+        Used by ``reconstruct_profile_change_log`` to discover add-only dedup runs
+        (runs that added new profiles but superseded nothing, which emit no lineage
+        event and would otherwise be invisible).
+
+        Returns:
+            list[str]: Distinct non-empty ``generated_from_request_id`` values.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_profiles_by_generated_from_request_id(
+        self,
+        request_id: str,
+    ) -> list[UserProfile]:
+        """Return all profiles (any status, including tombstones) for a given generated_from_request_id.
+
+        Scoped to the org. Used by reconstruct_profile_change_log to find the
+        "added" side of a dedup run without depending on mutable status columns.
+        The column is set at profile creation and never changes — it is the
+        time-travel-stable signal for "added in run R".
+
+        Args:
+            request_id (str): The generated_from_request_id value to filter on.
+
+        Returns:
+            list[UserProfile]: All profiles (live or tombstone) whose
+                ``generated_from_request_id`` matches, scoped by org.
+        """
+        raise NotImplementedError
+
+    def get_all_generated_profiles(self) -> list[UserProfile]:
+        """Return every profile (any status, incl. tombstones) with a non-empty
+        ``generated_from_request_id``, scoped to the org.
+
+        Bulk equivalent of :meth:`get_profiles_by_generated_from_request_id` — it
+        lets ``reconstruct_profile_change_log`` resolve the "added" side of every
+        run in a single query instead of one read per candidate request_id (an
+        org-history-sized fan-out on network-backed storage).
+
+        The default implementation loops the per-id reads, so every backend is
+        correct without an override; backends SHOULD override it with a single
+        ``WHERE generated_from_request_id <> ''`` query for the performance win.
+
+        Returns:
+            list[UserProfile]: All profiles with a non-empty
+                ``generated_from_request_id``.
+        """
+        out: list[UserProfile] = []
+        for request_id in self.get_distinct_generated_from_request_ids():
+            out.extend(self.get_profiles_by_generated_from_request_id(request_id))
+        return out
+
+    @abstractmethod
+    def supersede_profiles_by_ids(
+        self,
+        user_id: str,
+        profile_ids: list[str],
+        request_id: str,
+    ) -> list[str]:
+        """Soft-delete profiles by setting status to SUPERSEDED, emitting set-based lineage.
+
+        For each profile id that matches (user_id, current status in {NULL/CURRENT,
+        PENDING}), updates status to SUPERSEDED and emits one ``status_change``
+        lineage event under the shared ``request_id``.  Rows are NOT physically
+        deleted — reads that exclude tombstones will simply filter them out by status.
+
+        Args:
+            user_id (str): Owning user id. Predicate scoped to this user.
+            profile_ids (list[str]): Profile ids to supersede. Already-superseded or
+                non-existent ids are silently skipped.
+            request_id (str): Shared request id to stamp on all emitted events so the
+                entire dedup run is reconstructible from a single id.
+
+        Returns:
+            list[str]: The profile ids that were actually superseded by this call, in
+                input order. Already-superseded or non-existent ids are omitted (so an
+                empty list means nothing committed). Callers needing a count use
+                ``len(...)``. This is the commit-accurate set used to build a
+                commit-atomic legacy change-log "removed" entry.
+        """
+        raise NotImplementedError
+
     # Search methods
     @abstractmethod
     def search_interaction(

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/_requests.py

@@ -4,6 +4,7 @@ from reflexio.models.api_schema.domain import Request
 from reflexio.models.api_schema.internal_schema import (
     RequestInteractionDataModel,
     SessionDescriptor,
+    SessionFirstRequest,
 )
 
 
@@ -152,3 +153,62 @@ class RequestMixin:
             list[SessionDescriptor]: Deduped descriptors ordered by session_id.
         """
         raise NotImplementedError
+
+    def get_first_requests_by_session_ids(
+        self, session_ids: list[str]
+    ) -> dict[str, SessionFirstRequest]:
+        """Return earliest-request metadata for each requested session.
+
+        Default implementation preserves the historical storage contract by
+        calling ``get_sessions`` per session. SQL backends should override with
+        a set-based query.
+        """
+        out: dict[str, SessionFirstRequest] = {}
+        for session_id in set(session_ids):
+            requests = []
+            page_size = 1000
+            offset = 0
+            while True:
+                grouped = self.get_sessions(
+                    session_id=session_id,
+                    top_k=page_size,
+                    offset=offset,
+                )
+                rows = grouped.get(session_id) or []
+                requests.extend(r.request for r in rows if r.request is not None)
+                if len(rows) < page_size:
+                    break
+                offset += page_size
+            if not requests:
+                continue
+            first = min(requests, key=lambda r: r.created_at)
+            out[session_id] = SessionFirstRequest(
+                session_id=session_id,
+                user_id=first.user_id,
+                source=first.source or "",
+                created_at=first.created_at,
+            )
+        return out
+
+    def get_first_requests_by_user_session_pairs(
+        self, pairs: list[tuple[str, str]]
+    ) -> dict[tuple[str, str], SessionFirstRequest]:
+        """Return earliest-request metadata for each requested (user_id, session_id).
+
+        Default implementation preserves backend compatibility by calling the
+        existing user-scoped request lookup per distinct pair. SQL backends
+        override with set-based queries.
+        """
+        out: dict[tuple[str, str], SessionFirstRequest] = {}
+        for user_id, session_id in set(pairs):
+            requests = self.get_requests_by_session(user_id, session_id)
+            if not requests:
+                continue
+            first = min(requests, key=lambda r: r.created_at)
+            out[(user_id, session_id)] = SessionFirstRequest(
+                session_id=session_id,
+                user_id=user_id,
+                source=first.source or "",
+                created_at=first.created_at,
+            )
+        return out

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/_retrieval_log.py

@@ -0,0 +1,51 @@
+from reflexio.models.api_schema.domain.entities import PlaybookRetrievalLog
+
+
+class RetrievalLogMixin:
+    """Mixin for playbook retrieval log storage methods.
+
+    These methods are optional retrieval-capture storage hooks. They are
+    intentionally concrete (not ``@abstractmethod``) so concrete storage classes
+    remain instantiable; each raises ``NotImplementedError`` until a backend
+    provides a real implementation.
+    """
+
+    def save_playbook_retrieval_log(self, log: PlaybookRetrievalLog) -> int:
+        """Persist a retrieval log entry and return its assigned id.
+
+        Args:
+            log (PlaybookRetrievalLog): The log entry to save. ``retrieval_log_id``
+                may be 0; the storage layer assigns a real id on insert.
+
+        Returns:
+            int: The assigned ``retrieval_log_id``.
+        """
+        raise NotImplementedError
+
+    def get_playbook_retrieval_logs(
+        self,
+        *,
+        session_id: str | None = None,
+        request_id: str | None = None,
+        interaction_id: int | None = None,
+        user_id: str | None = None,
+        start_time: int | None = None,
+        end_time: int | None = None,
+    ) -> list[PlaybookRetrievalLog]:
+        """Retrieve playbook retrieval log entries, optionally filtered.
+
+        Args:
+            session_id (str | None): Filter to logs for this session. If None,
+                no session filter is applied.
+            request_id (str | None): Filter to logs for this request. If None,
+                no request filter is applied.
+            interaction_id (int | None): Filter to logs for this interaction.
+            user_id (str | None): Filter to logs for this user.
+            start_time (int | None): Inclusive lower bound on ``created_at``.
+            end_time (int | None): Inclusive upper bound on ``created_at``.
+
+        Returns:
+            list[PlaybookRetrievalLog]: Matching log entries, ordered by
+                ``created_at`` ascending.
+        """
+        raise NotImplementedError

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/_shadow_verdicts.py

@@ -108,6 +108,23 @@ class ShadowVerdictsMixin:
             f"{type(self).__name__} does not support shadow_comparison_verdicts"
         )
 
+    def get_recent_shadow_comparison_verdicts(
+        self,
+        from_ts: int,
+        to_ts: int,
+        judge_prompt_version: str,
+        limit: int,
+    ) -> list[ShadowComparisonVerdict]:
+        """Fetch newest verdicts in descending ``created_at`` order."""
+        if limit <= 0:
+            return []
+        verdicts = self.get_shadow_comparison_verdicts(
+            from_ts=from_ts,
+            to_ts=to_ts,
+            judge_prompt_version=judge_prompt_version,
+        )
+        return list(reversed(verdicts))[:limit]
+
     def delete_shadow_comparison_verdicts_by_session(self, session_id: str) -> int:
         """Remove all verdicts for one session.
 

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

@@ -0,0 +1,8 @@
+# tagging
+
+Compact post-generation entity tagging capability.
+
+- `service.py` tags profiles and playbooks with the configured tagging prompts.
+- `tagging_scheduler.py` debounces post-publish tagging and rebuilds request context for background execution.
+
+This package intentionally does not use `components/`: the service and scheduler are the only module responsibilities.

package/plugin/vendor/reflexio/reflexio/server/services/tagging/__init__.py

@@ -0,0 +1 @@
+"""Post-generation entity tagging services."""

package/plugin/vendor/reflexio/reflexio/server/services/tagging/service.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+import logging
+import os
+
+from pydantic import ConfigDict, Field
+
+from reflexio.models.api_schema.service_schemas import (
+    AgentPlaybook,
+    UserPlaybook,
+    UserProfile,
+)
+from reflexio.models.structured_output import StrictStructuredOutput
+from reflexio.server.api_endpoints.request_context import RequestContext
+from reflexio.server.llm.litellm_client import LiteLLMClient
+from reflexio.server.llm.model_defaults import ModelRole, resolve_model_name
+from reflexio.server.services.service_utils import log_llm_messages, log_model_response
+from reflexio.server.site_var.site_var_manager import SiteVarManager
+
+logger = logging.getLogger(__name__)
+
+TAGGING_PROMPT_ID = "tagging"
+
+# Upper bound on how many current playbooks a single tagging pass will scan for
+# untagged entries. Tagging is idempotent (already-tagged entities are skipped),
+# so steady-state passes only tag newly generated entities; this bound just keeps
+# a one-time backfill from being silently truncated at the storage default of 100.
+_TAGGING_FETCH_LIMIT = 1000
+
+
+class TagsOutput(StrictStructuredOutput):
+    tags: list[str] = Field(default_factory=list)
+
+    model_config = ConfigDict(
+        extra="allow",
+        json_schema_extra={"additionalProperties": False},
+    )
+
+
+class TaggingService:
+    def __init__(
+        self,
+        llm_client: LiteLLMClient,
+        request_context: RequestContext,
+    ) -> None:
+        self.client = llm_client
+        self.request_context = request_context
+        self.configurator = request_context.configurator
+        self.storage = request_context.storage
+
+        model_setting = SiteVarManager().get_site_var("llm_model_setting")
+        site_var = model_setting if isinstance(model_setting, dict) else {}
+        config = self.configurator.get_config()
+        llm_config = config.llm_config if config else None
+        api_key_config = config.api_key_config if config else None
+        self.model_name = resolve_model_name(
+            ModelRole.GENERATION,
+            site_var_value=site_var.get("default_generation_model_name"),
+            config_override=llm_config.generation_model_name if llm_config else None,
+            api_key_config=api_key_config,
+        )
+
+    def run(
+        self,
+        *,
+        user_id: str,
+        agent_version: str,
+        tag_profiles: bool = True,
+        tag_playbooks: bool = True,
+    ) -> None:
+        if self.storage is None:
+            return
+
+        config = self.configurator.get_config()
+        if config is None:
+            return
+
+        profile_prompt = getattr(
+            config.profile_extractor_config, "tagging_definition_prompt", None
+        )
+        user_playbook_prompt = getattr(
+            config.user_playbook_extractor_config, "tagging_definition_prompt", None
+        )
+
+        if tag_profiles and profile_prompt:
+            self._tag_profiles(
+                user_id=user_id, tagging_definition_prompt=profile_prompt
+            )
+        if tag_playbooks and user_playbook_prompt:
+            self._tag_user_playbooks(
+                user_id=user_id,
+                agent_version=agent_version,
+                tagging_definition_prompt=user_playbook_prompt,
+            )
+            self._tag_agent_playbooks(
+                agent_version=agent_version,
+                tagging_definition_prompt=user_playbook_prompt,
+            )
+
+    def _tag_profiles(self, *, user_id: str, tagging_definition_prompt: str) -> None:
+        profiles = self.storage.get_user_profile(user_id)  # type: ignore[union-attr]
+        for profile in profiles:
+            if profile.tags is not None:
+                continue  # already tagged (incl. empty result) — tag each entity once
+            tags = self._generate_tags(
+                tagging_definition_prompt=tagging_definition_prompt,
+                content=self._profile_content(profile),
+            )
+            self.storage.update_user_profile_tags(  # type: ignore[union-attr]
+                user_id, profile.profile_id, tags
+            )
+
+    def _tag_user_playbooks(
+        self,
+        *,
+        user_id: str,
+        agent_version: str,
+        tagging_definition_prompt: str,
+    ) -> None:
+        playbooks = self.storage.get_user_playbooks(  # type: ignore[union-attr]
+            limit=_TAGGING_FETCH_LIMIT,
+            user_id=user_id,
+            agent_version=agent_version,
+            status_filter=[None],
+        )
+        for playbook in playbooks:
+            if playbook.tags is not None:
+                continue  # already tagged (incl. empty result) — tag each entity once
+            tags = self._generate_tags(
+                tagging_definition_prompt=tagging_definition_prompt,
+                content=self._playbook_content(playbook),
+            )
+            self.storage.update_user_playbook(  # type: ignore[union-attr]
+                playbook.user_playbook_id,
+                tags=tags,
+            )
+
+    def _tag_agent_playbooks(
+        self,
+        *,
+        agent_version: str,
+        tagging_definition_prompt: str,
+    ) -> None:
+        playbooks = self.storage.get_agent_playbooks(  # type: ignore[union-attr]
+            limit=_TAGGING_FETCH_LIMIT,
+            agent_version=agent_version,
+            status_filter=[None],
+        )
+        for playbook in playbooks:
+            if playbook.tags is not None:
+                continue  # already tagged (incl. empty result) — tag each entity once
+            tags = self._generate_tags(
+                tagging_definition_prompt=tagging_definition_prompt,
+                content=self._playbook_content(playbook),
+            )
+            self.storage.update_agent_playbook(  # type: ignore[union-attr]
+                playbook.agent_playbook_id,
+                tags=tags,
+            )
+
+    def _generate_tags(
+        self, *, tagging_definition_prompt: str, content: str
+    ) -> list[str]:
+        if os.getenv("MOCK_LLM_RESPONSE", "").lower() == "true":
+            return ["example_tag"]
+
+        prompt = self.request_context.prompt_manager.render_prompt(
+            TAGGING_PROMPT_ID,
+            {
+                "tagging_definition_prompt": tagging_definition_prompt.strip(),
+                "content": content,
+            },
+        )
+        messages = [{"role": "user", "content": prompt}]
+        log_llm_messages(logger, "Tagging", messages)
+        response = self.client.generate_chat_response(
+            messages=messages,
+            model=self.model_name,
+            response_format=TagsOutput,
+        )
+        log_model_response(logger, "Tagging response", response)
+        if not isinstance(response, TagsOutput):
+            logger.warning(
+                "Unexpected response type from tagging LLM: %s", type(response)
+            )
+            return []
+        return [tag.strip() for tag in response.tags if tag.strip()]
+
+    @staticmethod
+    def _profile_content(profile: UserProfile) -> str:
+        return profile.content
+
+    @staticmethod
+    def _playbook_content(playbook: UserPlaybook | AgentPlaybook) -> str:
+        parts = [playbook.content]
+        if playbook.trigger:
+            parts.append(f"Trigger: {playbook.trigger}")
+        if playbook.rationale:
+            parts.append(f"Rationale: {playbook.rationale}")
+        return "\n".join(part for part in parts if part)

package/plugin/vendor/reflexio/reflexio/server/services/tagging/tagging_scheduler.py

@@ -0,0 +1,149 @@
+"""Singleton scheduler for deferred, off-publish-path entity tagging.
+
+Tagging runs an LLM call per newly generated profile/playbook, so it must not
+block the publish request. This scheduler mirrors
+:class:`GroupEvaluationScheduler`: a single daemon thread with a min-heap, where
+each publish upserts the fire time for its ``(org_id, user_id, agent_version)``
+key. Rapid successive publishes for the same key debounce into a single tagging
+pass; when the timer fires, the tagging callback runs on its own daemon thread.
+
+Tagging is idempotent (already-tagged entities are skipped), so a deferred pass
+naturally handles both newly generated entities and the one-time backfill that
+happens when a tagging definition is first configured.
+"""
+
+from __future__ import annotations
+
+import heapq
+import logging
+import os
+import threading
+import time
+from collections.abc import Callable
+
+from reflexio.server.api_endpoints.request_context import RequestContext
+from reflexio.server.llm.litellm_client import LiteLLMClient
+from reflexio.server.services.tagging.service import TaggingService
+
+logger = logging.getLogger(__name__)
+
+# Delay before a tagging pass fires after the last publish for a key. Long enough
+# to debounce a burst of publishes into one pass, short enough that tags appear
+# promptly. Kept as a patch point for tests.
+TAGGING_DELAY_SECONDS = 15
+IS_TEST_ENV = os.environ.get("IS_TEST_ENV", "false").strip().lower() == "true"
+_EFFECTIVE_DELAY_SECONDS = 1 if IS_TEST_ENV else TAGGING_DELAY_SECONDS
+
+# (org_id, user_id, agent_version)
+TaggingKey = tuple[str, str, str]
+
+
+class TaggingScheduler:
+    """Singleton scheduler that fires entity tagging after a short debounce."""
+
+    _instance = None
+    _lock = threading.Lock()
+
+    @classmethod
+    def get_instance(cls) -> TaggingScheduler:
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = cls()
+        return cls._instance
+
+    def __init__(self) -> None:
+        self._scheduled: dict[TaggingKey, tuple[float, Callable]] = {}
+        self._heap: list[tuple[float, TaggingKey]] = []
+        self._mutex = threading.Lock()
+        self._wake_event = threading.Event()
+        self._thread = threading.Thread(
+            target=self._scheduler_loop, daemon=True, name="tagging-scheduler"
+        )
+        self._thread.start()
+        logger.info("TaggingScheduler started")
+
+    def schedule(self, key: TaggingKey, callback: Callable) -> None:
+        """Schedule or reschedule a tagging pass for ``key`` (slides the fire time forward)."""
+        fire_time = time.monotonic() + _EFFECTIVE_DELAY_SECONDS
+        with self._mutex:
+            self._scheduled[key] = (fire_time, callback)
+            heapq.heappush(self._heap, (fire_time, key))
+        self._wake_event.set()
+
+    def _scheduler_loop(self) -> None:
+        while True:
+            try:
+                with self._mutex:
+                    next_fire_time = self._heap[0][0] if self._heap else None
+
+                if next_fire_time is None:
+                    self._wake_event.wait()
+                    self._wake_event.clear()
+                    continue
+
+                wait_seconds = next_fire_time - time.monotonic()
+                if wait_seconds > 0:
+                    self._wake_event.wait(timeout=wait_seconds)
+                    self._wake_event.clear()
+                    continue
+
+                with self._mutex:
+                    while self._heap and self._heap[0][0] <= time.monotonic():
+                        fire_time, key = heapq.heappop(self._heap)
+
+                        current = self._scheduled.get(key)
+                        if current is None:
+                            continue
+                        current_fire_time, callback = current
+                        if abs(current_fire_time - fire_time) > 0.001:
+                            # Superseded by a newer schedule for the same key.
+                            continue
+
+                        del self._scheduled[key]
+                        t = threading.Thread(
+                            target=self._run_callback,
+                            args=(key, callback),
+                            daemon=True,
+                            name=f"tagging-{key[1][:20]}",
+                        )
+                        t.start()
+            except Exception:
+                logger.exception("Error in tagging scheduler loop")
+                time.sleep(1)
+
+    @staticmethod
+    def _run_callback(key: TaggingKey, callback: Callable) -> None:
+        try:
+            logger.info("Firing tagging for key=%s", key)
+            callback()
+            logger.info("Completed tagging for key=%s", key)
+        except Exception:
+            logger.exception("Tagging callback failed for key=%s", key)
+
+
+def schedule_tagging(
+    *,
+    org_id: str,
+    user_id: str,
+    agent_version: str,
+    request_context: RequestContext,
+    llm_client: LiteLLMClient,
+) -> None:
+    """Enqueue a deferred tagging pass for the given user/agent off the publish path."""
+    if not user_id:
+        return
+
+    key: TaggingKey = (org_id, user_id, agent_version)
+    storage_base_dir = getattr(request_context, "storage_base_dir", None)
+
+    def callback() -> None:
+        fresh_context = RequestContext(
+            org_id=org_id,
+            storage_base_dir=storage_base_dir,
+        )
+        TaggingService(llm_client=llm_client, request_context=fresh_context).run(
+            user_id=user_id, agent_version=agent_version
+        )
+
+    TaggingScheduler.get_instance().schedule(key, callback)