claude-smart 0.2.47 → 0.2.49

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/agent_run/__init__.py

@@ -0,0 +1,9 @@
+from ._agent_run_store import AgentRunStoreABC
+from ._pending_tool_call_store import PendingToolCallStoreABC
+from ._run_tool_dependency_store import RunToolDependencyStoreABC
+
+__all__ = [
+    "AgentRunStoreABC",
+    "PendingToolCallStoreABC",
+    "RunToolDependencyStoreABC",
+]

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/agent_run/_agent_run_store.py

@@ -0,0 +1,86 @@
+"""Backend-neutral AgentRunStore contract (the AgentRunStore bucket).
+
+Extracted verbatim from ``_agent_run.py`` (the AgentRunStore bucket): the seven
+agent-run lifecycle methods. The residual ``AgentRunMixin`` composite stays
+composed alongside this class and holds the remaining pending-tool-call /
+run-tool-dependency stubs plus the shared ``build_scope_hash`` /
+``human_feedback_scope`` / ``build_pending_tool_call_dedup_key`` staticmethods.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from ._models import AgentRunRecord, AgentRunStatus
+
+
+class AgentRunStoreABC:
+    """Backend-neutral agent-run lifecycle store contract."""
+
+    def create_agent_run(self, record: AgentRunRecord) -> AgentRunRecord:
+        raise NotImplementedError(f"{type(self).__name__} does not support agent runs")
+
+    def get_agent_run(self, run_id: str) -> AgentRunRecord | None:
+        raise NotImplementedError(f"{type(self).__name__} does not support agent runs")
+
+    def update_agent_run_status(
+        self,
+        run_id: str,
+        status: AgentRunStatus,
+        *,
+        committed_output: dict[str, Any] | None = None,
+        pending_tool_call_ids: list[str] | None = None,
+        max_steps_remaining: int | None = None,
+        next_resume_at: datetime | None = None,
+        last_error: str | None = None,
+        increment_finalization_attempts: bool = False,
+        expected_statuses: tuple[AgentRunStatus, ...] | None = None,
+    ) -> AgentRunRecord | None:
+        raise NotImplementedError(f"{type(self).__name__} does not support agent runs")
+
+    def fail_running_agent_runs_for_request(
+        self,
+        *,
+        org_id: str,
+        extractor_kind: str,
+        user_id: str | None,
+        request_id: str,
+        last_error: str,
+    ) -> int:
+        raise NotImplementedError(f"{type(self).__name__} does not support agent runs")
+
+    def claim_ready_agent_run(
+        self,
+        *,
+        org_id: str,
+        worker_id: str,
+        now: datetime | None = None,
+        claim_ttl_seconds: int = 600,
+    ) -> AgentRunRecord | None:
+        raise NotImplementedError(f"{type(self).__name__} does not support agent runs")
+
+    def claim_finalization_failed_agent_run(
+        self,
+        *,
+        org_id: str,
+        worker_id: str,
+        now: datetime | None = None,
+        claim_ttl_seconds: int = 600,
+    ) -> AgentRunRecord | None:
+        raise NotImplementedError(f"{type(self).__name__} does not support agent runs")
+
+    def list_resumable_work_org_ids(
+        self,
+        *,
+        now: datetime | None = None,
+        limit: int = 1000,
+    ) -> list[str]:
+        """Return distinct org_ids that have actionable resumable-extraction work.
+
+        Cross-org maintenance query (intentionally NOT scoped to ``self.org_id``):
+        the resume scheduler uses it to discover every org that has a run ready
+        to resume, a run awaiting finalization retry, or a pending tool call that
+        can be expired, so per-org workers can be driven for all of them.
+        """
+        raise NotImplementedError(f"{type(self).__name__} does not support agent runs")

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/agent_run/_models.py

@@ -0,0 +1,195 @@
+"""Shared storage types and helpers for resumable extraction agent runs.
+
+Leaf module (imports NO mixin, so it never participates in an import cycle).
+The three ``agent_run`` ABC sub-mixins and the residual ``AgentRunMixin``
+composite import their records/enums/helpers from here.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import unicodedata
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import StrEnum
+from typing import Any
+
+from reflexio.models.api_schema.pending_tool_call_schema import PendingToolCallStatus
+
+_WHITESPACE_RE = re.compile(r"\s+")
+
+
+class AgentRunStatus(StrEnum):
+    RUNNING = "running"
+    AGENT_COMPLETED = "agent_completed"
+    FINALIZING = "finalizing"
+    FINALIZED = "finalized"
+    FINALIZED_PENDING_TOOL = "finalized_pending_tool"
+    RESUME_READY = "resume_ready"
+    RESUMING = "resuming"
+    FINALIZATION_FAILED = "finalization_failed"
+    FAILED = "failed"
+    EXPIRED = "expired"
+    CANCELLED = "cancelled"
+
+
+NOT_APPLICABLE_ANSWER = "User does not have information about this question."
+
+
+class RunToolDependencyKind(StrEnum):
+    FOLLOWUP = "followup"
+
+
+@dataclass(frozen=True)
+class AgentBinding:
+    """Logical run binding flattened into `_agent_runs` storage columns."""
+
+    org_id: str
+    extractor_kind: str
+    user_id: str | None
+    request_id: str
+    agent_version: str | None
+    source: str | None
+    source_interaction_ids: list[int] = field(default_factory=list)
+    window_start_interaction_id: int | None = None
+    window_end_interaction_id: int | None = None
+    extractor_config_hash: str | None = None
+
+
+@dataclass(frozen=True)
+class AgentRunRecord:
+    id: str
+    binding: AgentBinding
+    status: AgentRunStatus
+    generation_request_snapshot: dict[str, Any]
+    service_config_snapshot: dict[str, Any] | None = None
+    agent_context_snapshot: str | None = None
+    committed_output: dict[str, Any] | None = None
+    pending_tool_call_ids: list[str] = field(default_factory=list)
+    max_steps_remaining: int | None = None
+    resume_attempts: int = 0
+    finalization_attempts: int = 0
+    next_resume_at: datetime | None = None
+    claimed_by: str | None = None
+    claimed_at: datetime | None = None
+    agent_completed_at: datetime | None = None
+    finalized_at: datetime | None = None
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+    expires_at: datetime | None = None
+    last_error: str | None = None
+
+
+@dataclass(frozen=True)
+class PendingToolCallRecord:
+    id: str
+    org_id: str
+    scope: dict[str, Any]
+    scope_hash: str
+    tool_name: str
+    dedup_key: str
+    status: PendingToolCallStatus
+    question_text: str
+    args: dict[str, Any] = field(default_factory=dict)
+    tags: list[str] = field(default_factory=list)
+    user_id: str | None = None
+    answer_format: str | None = None
+    result: dict[str, Any] | None = None
+    embedding: list[float] | None = None
+    superseded_by: str | None = None
+    created_at: datetime | None = None
+    resolved_at: datetime | None = None
+    expires_at: datetime | None = None
+    cache_until: datetime | None = None
+    valid_until: datetime | None = None
+
+
+@dataclass(frozen=True)
+class RunToolDependencyRecord:
+    run_id: str
+    pending_tool_call_id: str
+    dependency_kind: RunToolDependencyKind = RunToolDependencyKind.FOLLOWUP
+    resolved_at: datetime | None = None
+    consumed_at: datetime | None = None
+    created_at: datetime | None = None
+
+
+@dataclass(frozen=True)
+class PendingToolCallUpsertResult:
+    pending_tool_call: PendingToolCallRecord
+    created: bool
+
+
+@dataclass(frozen=True)
+class PriorAnswerMatch:
+    pending_tool_call_id: str
+    status: PendingToolCallStatus
+    question_text: str
+    result: dict[str, Any] | None
+    valid_until: datetime | None
+    answer_format: str | None = None
+    created_at: datetime | None = None
+    resolved_at: datetime | None = None
+    expires_at: datetime | None = None
+    similarity: float | None = None
+
+
+def canonical_json(value: Any) -> str:
+    """Return deterministic compact JSON for storage hashes."""
+    return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
+
+
+def build_scope_hash(scope: dict[str, Any]) -> str:
+    """Stable hash for a tool scope dictionary."""
+    return hashlib.sha256(canonical_json(scope).encode("utf-8")).hexdigest()
+
+
+def human_feedback_scope(org_id: str) -> dict[str, str]:
+    """Human feedback is always org-scoped, never user-scoped."""
+    return {"org_id": org_id, "scope_kind": "org"}
+
+
+def normalize_dedup_text(value: str | None) -> str:
+    """Normalize text before pending-tool-call dedup hashing."""
+    if value is None:
+        return ""
+    normalized = unicodedata.normalize("NFKC", value)
+    normalized = _WHITESPACE_RE.sub(" ", normalized.strip())
+    return normalized.casefold()
+
+
+def build_pending_tool_call_dedup_key(
+    *,
+    tool_name: str,
+    question_text: str,
+    answer_format: str | None = None,
+) -> str:
+    """Stable dedup hash for a normalized tool question."""
+    parts = (
+        normalize_dedup_text(tool_name),
+        normalize_dedup_text(question_text),
+        normalize_dedup_text(answer_format),
+    )
+    return hashlib.sha256("\n".join(parts).encode("utf-8")).hexdigest()
+
+
+def not_applicable_tool_result() -> dict[str, Any]:
+    return {"answer": NOT_APPLICABLE_ANSWER, "not_applicable": True}
+
+
+def is_not_applicable_tool_result(result: dict[str, Any] | None) -> bool:
+    return isinstance(result, dict) and result.get("not_applicable") is True
+
+
+def embedding_similarity(a: list[float] | None, b: list[float] | None) -> float | None:
+    """Cosine similarity for optional embedding vectors."""
+    if not a or not b or len(a) != len(b):
+        return None
+    dot = sum(x * y for x, y in zip(a, b, strict=True))
+    mag_a_sq = sum(x * x for x in a)
+    mag_b_sq = sum(y * y for y in b)
+    if mag_a_sq == 0.0 or mag_b_sq == 0.0:
+        return None
+    return dot / ((mag_a_sq**0.5) * (mag_b_sq**0.5))

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/agent_run/_pending_tool_call_store.py

@@ -0,0 +1,148 @@
+"""Backend-neutral PendingToolCallStore contract (the PendingToolCallStore bucket).
+
+Extracted verbatim from ``_agent_run.py`` (the PendingToolCallStore bucket): the
+twelve pending-tool-call methods. The residual ``AgentRunMixin`` composite stays
+composed alongside this class and holds the remaining run-tool-dependency stubs
+plus the shared ``build_scope_hash`` / ``human_feedback_scope`` /
+``build_pending_tool_call_dedup_key`` staticmethods.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from ._models import (
+    PendingToolCallRecord,
+    PendingToolCallStatus,
+    PendingToolCallUpsertResult,
+    PriorAnswerMatch,
+    RunToolDependencyRecord,
+)
+
+
+class PendingToolCallStoreABC:
+    """Backend-neutral pending-tool-call store contract."""
+
+    def create_pending_tool_call(
+        self, record: PendingToolCallRecord
+    ) -> PendingToolCallRecord:
+        raise NotImplementedError(f"{type(self).__name__} does not support agent runs")
+
+    def create_or_attach_pending_tool_call(
+        self,
+        *,
+        record: PendingToolCallRecord,
+        dependency: RunToolDependencyRecord,
+        now: datetime | None = None,
+    ) -> PendingToolCallUpsertResult:
+        raise NotImplementedError(f"{type(self).__name__} does not support agent runs")
+
+    def get_pending_tool_call(self, call_id: str) -> PendingToolCallRecord | None:
+        raise NotImplementedError(f"{type(self).__name__} does not support agent runs")
+
+    def list_pending_tool_calls(
+        self,
+        *,
+        status: PendingToolCallStatus | None = None,
+        limit: int = 100,
+    ) -> list[PendingToolCallRecord]:
+        raise NotImplementedError(f"{type(self).__name__} does not support agent runs")
+
+    def cancel_pending_tool_call(
+        self,
+        call_id: str,
+        *,
+        cancelled_at: datetime | None = None,
+    ) -> PendingToolCallRecord | None:
+        raise NotImplementedError(f"{type(self).__name__} does not support agent runs")
+
+    def expire_pending_tool_calls(
+        self,
+        *,
+        now: datetime | None = None,
+        limit: int = 100,
+    ) -> int:
+        raise NotImplementedError(f"{type(self).__name__} does not support agent runs")
+
+    def delete_expired_pending_tool_calls(
+        self,
+        *,
+        now: int,
+        grace_seconds: int,
+        limit: int = 1000,
+    ) -> int:
+        """Physically delete terminal 'expired'-status rows past the grace window.
+
+        Only rows with ``status = 'expired'`` (the terminal marker set by
+        ``expire_pending_tool_calls``) are candidates. RESOLVED rows are never
+        deleted — even if their ``expires_at`` is in the past — because their
+        ``valid_until`` may still be live and their cached result is needed by
+        resumable extraction resume paths.
+
+        The deletion cutoff is ``now - grace_seconds`` expressed as an ISO-8601
+        string (``expires_at`` is stored as TEXT/ISO in SQLite and as
+        ``timestamp with time zone`` in Postgres).
+
+        Args:
+            now: Current Unix epoch seconds.
+            grace_seconds: Extra TTL buffer; a row is only deleted if its
+                ``expires_at < datetime(now - grace_seconds)``.
+            limit: Maximum rows to delete in one call (default 1000).
+
+        Returns:
+            Number of rows actually deleted.
+        """
+        raise NotImplementedError(f"{type(self).__name__} does not support agent runs")
+
+    def find_active_pending_tool_call(
+        self,
+        *,
+        org_id: str,
+        scope_hash: str,
+        tool_name: str,
+        dedup_key: str,
+        now: datetime | None = None,
+    ) -> PendingToolCallRecord | None:
+        raise NotImplementedError(f"{type(self).__name__} does not support agent runs")
+
+    def search_prior_tool_calls(
+        self,
+        *,
+        org_id: str,
+        scope_hash: str,
+        tool_name: str,
+        query_embedding: list[float] | None = None,
+        now: datetime | None = None,
+        limit: int = 8,
+    ) -> list[PriorAnswerMatch]:
+        raise NotImplementedError(f"{type(self).__name__} does not support agent runs")
+
+    def resolve_pending_tool_call(
+        self,
+        call_id: str,
+        *,
+        result: dict[str, Any],
+        resolved_at: datetime | None = None,
+        valid_for_seconds: int,
+    ) -> PendingToolCallRecord | None:
+        raise NotImplementedError(f"{type(self).__name__} does not support agent runs")
+
+    def update_resolved_pending_tool_call_result(
+        self,
+        call_id: str,
+        *,
+        result: dict[str, Any],
+        resolved_at: datetime | None = None,
+        valid_for_seconds: int,
+    ) -> PendingToolCallRecord | None:
+        raise NotImplementedError(f"{type(self).__name__} does not support agent runs")
+
+    def mark_pending_tool_call_not_applicable(
+        self,
+        call_id: str,
+        *,
+        resolved_at: datetime | None = None,
+        valid_for_seconds: int,
+    ) -> PendingToolCallRecord | None:
+        raise NotImplementedError(f"{type(self).__name__} does not support agent runs")

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/agent_run/_run_tool_dependency_store.py

@@ -0,0 +1,38 @@
+"""Backend-neutral RunToolDependencyStore contract (the RunToolDependencyStore bucket).
+
+Extracted verbatim from ``_agent_run.py`` (the RunToolDependencyStore bucket):
+the four run-tool-dependency methods. This is the LAST bucket — after this
+extraction all twenty-three agent-run methods live in the three ``agent_run``
+sub-mixins and the residual ``_agent_run.py`` module is helpers-only. The
+composite ``AgentRunMixin`` now inherits all three ABCs and retains only the
+shared ``build_scope_hash`` / ``human_feedback_scope`` /
+``build_pending_tool_call_dedup_key`` staticmethods.
+"""
+
+from __future__ import annotations
+
+from ._models import RunToolDependencyRecord
+
+
+class RunToolDependencyStoreABC:
+    """Backend-neutral run-tool-dependency store contract."""
+
+    def attach_run_tool_dependency(
+        self, record: RunToolDependencyRecord
+    ) -> RunToolDependencyRecord:
+        raise NotImplementedError(f"{type(self).__name__} does not support agent runs")
+
+    def count_unresolved_followup_dependencies(
+        self,
+        *,
+        org_id: str,
+        extractor_kind: str,
+        tool_name: str,
+    ) -> int:
+        raise NotImplementedError(f"{type(self).__name__} does not support agent runs")
+
+    def list_run_tool_dependencies(self, run_id: str) -> list[RunToolDependencyRecord]:
+        raise NotImplementedError(f"{type(self).__name__} does not support agent runs")
+
+    def consume_run_tool_dependencies(self, run_id: str) -> int:
+        raise NotImplementedError(f"{type(self).__name__} does not support agent runs")

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/governance/__init__.py

@@ -0,0 +1,13 @@
+from ._audit import AuditEventStoreMixin
+from ._erase_execution import GovernanceEraseExecutionMixin
+from ._purge import PurgeOperationStoreMixin
+from ._rebuild_hide import RebuildHideMixin
+from ._subject_barrier import SubjectBarrierMixin
+
+__all__ = [
+    "AuditEventStoreMixin",
+    "GovernanceEraseExecutionMixin",
+    "PurgeOperationStoreMixin",
+    "RebuildHideMixin",
+    "SubjectBarrierMixin",
+]

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/governance/_audit.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from reflexio.models.api_schema.domain.governance import AuditEvent
+from reflexio.models.config_schema import GovernanceRetentionConfig
+
+
+class AuditEventStoreMixin(ABC):
+    """Backend-neutral audit-event store contract.
+
+    Extracted verbatim from ``_governance.py`` (the AuditEventStore bucket). The
+    residual ``GovernanceMixin`` ABC stays composed alongside this mixin and
+    holds the remaining purge / barrier abstract methods.
+    """
+
+    @abstractmethod
+    def append_audit_event(self, event: AuditEvent) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    def list_audit_events(
+        self, subject_ref: str | None = None, *, org_id: str | None = None
+    ) -> list[AuditEvent]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def gc_governance_retention(self, *, config: GovernanceRetentionConfig) -> int:
+        raise NotImplementedError

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/governance/_erase_execution.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from reflexio.models.api_schema.domain.governance import (
+    AuditEvent,
+    PurgeOperation,
+)
+
+
+class GovernanceEraseExecutionMixin(ABC):
+    """Backend-neutral governance-erase-execution store contract.
+
+    Extracted verbatim from ``_governance.py`` (the GovernanceEraseExecution
+    bucket). The residual ``GovernanceMixin`` ABC stays composed alongside this
+    mixin and holds the remaining rebuild-hide / agent-playbook-rebuild abstract
+    methods.
+    """
+
+    @abstractmethod
+    def apply_governance_user_data_delete(
+        self, purge_id: str, user_id: str
+    ) -> dict[str, int]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def complete_purge_operation_with_audit(
+        self, purge_id: str, audit_event: AuditEvent
+    ) -> PurgeOperation:
+        raise NotImplementedError

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/governance/_purge.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Literal
+
+from reflexio.models.api_schema.domain.governance import (
+    PurgeOperation,
+    PurgeOperationTarget,
+)
+
+
+class PurgeOperationStoreMixin(ABC):
+    """Backend-neutral purge-operation store contract.
+
+    Extracted verbatim from ``_governance.py`` (the PurgeOperationStore bucket).
+    The residual ``GovernanceMixin`` ABC stays composed alongside this mixin and
+    holds the remaining rebuild-hide / governance-erase-execution / barrier
+    abstract methods.
+    """
+
+    @abstractmethod
+    def begin_purge_operation(
+        self,
+        purge_id: str,
+        idempotency_key: str,
+        operation_type: Literal["user_erasure", "org_purge"],
+        scope_type: Literal["user", "org"],
+        subject_ref: str | None,
+        request_ref: str,
+    ) -> PurgeOperation:
+        raise NotImplementedError
+
+    @abstractmethod
+    def record_purge_target(
+        self,
+        purge_id: str,
+        target_name: str,
+        phase: str,
+        status: Literal["pending", "running", "failed", "complete"],
+        target_ref: str = "",
+        detail: dict[str, object] | None = None,
+        deleted_count: int = 0,
+        error_detail: str | None = None,
+    ) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def list_purge_targets(
+        self, purge_id: str, phase: str | None = None
+    ) -> list[PurgeOperationTarget]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def purge_targets_prepared(self, purge_id: str) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    def prepare_governance_erase_targets(
+        self,
+        purge_id: str,
+        user_id: str,
+        owned_user_playbook_ids: set[int] | None = None,
+    ) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def fail_purge_operation(
+        self, purge_id: str, error_code: str, error_detail: str
+    ) -> PurgeOperation:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_purge_operation(self, purge_id: str) -> PurgeOperation:
+        raise NotImplementedError

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/governance/_rebuild_hide.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+
+class RebuildHideMixin(ABC):
+    """Backend-neutral governance rebuild-hide store contract.
+
+    Extracted verbatim from ``_governance.py`` (the RebuildHide bucket): the two
+    public methods (``hide_governance_agent_playbooks_for_rebuild``,
+    ``apply_governance_agent_playbook_rebuild``). The residual ``GovernanceMixin``
+    ABC stays composed alongside this mixin.
+    """
+
+    @abstractmethod
+    def hide_governance_agent_playbooks_for_rebuild(self, purge_id: str) -> list[int]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def apply_governance_agent_playbook_rebuild(
+        self,
+        purge_id: str,
+        agent_playbook_id: int,
+        remaining_source_windows: list[dict[str, object]],
+        content: str | None,
+        trigger: str | None,
+        rationale: str | None,
+        blocking_issue: dict[str, object] | None,
+        expanded_terms: str | None,
+        tags: list[str] | None,
+    ) -> None:
+        raise NotImplementedError