claude-smart 0.2.43 → 0.2.44

package/plugin/vendor/reflexio/reflexio/server/services/extraction/resumable_agent.py

@@ -43,6 +43,12 @@ logger = logging.getLogger(__name__)
 FINISH_EXTRACTION_TOOL_NAME = "finish_extraction"
 PROFILE_EXTRACTOR_KIND = "profile"
 
+# Max in-process retries when the model returns a plain-text turn with no tool
+# call (finished_reason="no_tool_call"). tool_choice="required" is not always
+# honored by every provider/model, so a single bad turn would otherwise drop the
+# extraction entirely. Retries re-issue the same prompt from scratch.
+_NO_TOOL_CALL_MAX_RETRIES = 2
+
 
 def _record_agent_usage_event(
     *,
@@ -351,18 +357,6 @@ class ResumableExtractionAgent:
         extra_tool_context: Any | None = None,
         log_label: str | None = None,
     ) -> AgentRunResult:
-        finish_ctx = _FinishExtractionContext()
-        ctx: Any = (
-            _ExtractionAgentToolContext(
-                finish_context=finish_ctx,
-                extra_tool_context=extra_tool_context,
-            )
-            if extra_tool_context is not None
-            else finish_ctx
-        )
-        registry = ToolRegistry(
-            [*(extra_tools or []), create_finish_extraction_tool(output_schema)]
-        )
         max_steps = self.max_steps
         if run.max_steps_remaining is not None:
             max_steps = min(max_steps, max(0, run.max_steps_remaining))
@@ -387,29 +381,101 @@ class ResumableExtractionAgent:
             else "required"
         )
 
-        result = run_tool_loop(
-            client=self.client,
-            messages=messages,
-            registry=registry,
-            model_role=self.model_role,
-            max_steps=max_steps,
-            ctx=ctx,
-            finish_tool_name=FINISH_EXTRACTION_TOOL_NAME,
-            tool_choice=tool_choice,
-            log_label=log_label,
-        )
+        # Retry only the no_tool_call termination: the model emitted plain text
+        # with zero tool calls, so nothing was committed and re-issuing the same
+        # prompt is safe. Each attempt uses a fresh finish_ctx/registry so no
+        # partial state leaks across attempts. We do NOT retry once the model has
+        # already registered async tool calls (e.g. attach_pending_info_request)
+        # — restarting from scratch would discard them.
+        for attempt in range(_NO_TOOL_CALL_MAX_RETRIES + 1):
+            finish_ctx = _FinishExtractionContext()
+            ctx: Any = (
+                _ExtractionAgentToolContext(
+                    finish_context=finish_ctx,
+                    extra_tool_context=extra_tool_context,
+                )
+                if extra_tool_context is not None
+                else finish_ctx
+            )
+            registry = ToolRegistry(
+                [*(extra_tools or []), create_finish_extraction_tool(output_schema)]
+            )
+
+            result = run_tool_loop(
+                client=self.client,
+                messages=messages,
+                registry=registry,
+                model_role=self.model_role,
+                max_steps=max_steps,
+                ctx=ctx,
+                finish_tool_name=FINISH_EXTRACTION_TOOL_NAME,
+                tool_choice=tool_choice,
+                log_label=log_label,
+            )
+
+            should_retry = (
+                result.finished_reason == "no_tool_call"
+                and not result.pending_tool_call_ids
+                and attempt < _NO_TOOL_CALL_MAX_RETRIES
+            )
+            if not should_retry:
+                break
+            logger.warning(
+                "event=extraction_agent_retry org_id=%s user_id=%s "
+                "extractor_kind=%s run_id=%s request_id=%s "
+                "finished_reason=%s attempt=%d max_retries=%d",
+                run.binding.org_id,
+                run.binding.user_id,
+                run.binding.extractor_kind,
+                run.id,
+                run.binding.request_id,
+                result.finished_reason,
+                attempt + 1,
+                _NO_TOOL_CALL_MAX_RETRIES,
+            )
+            _record_agent_usage_event(
+                run=run,
+                event_name="extraction_agent_retry",
+                error_kind=result.finished_reason,
+                metadata={"attempt": attempt + 1},
+            )
 
         committed_output = (
             finish_ctx.output.model_dump() if finish_ctx.output is not None else None
         )
+        active_statuses = (AgentRunStatus.RUNNING, AgentRunStatus.RESUMING)
         if result.finished_reason == "finish_tool" and committed_output is not None:
-            self.storage.update_agent_run_status(
+            stored_run = self.storage.update_agent_run_status(
                 run.id,
                 AgentRunStatus.AGENT_COMPLETED,
                 committed_output=committed_output,
                 pending_tool_call_ids=result.pending_tool_call_ids,
                 max_steps_remaining=result.max_steps_remaining,
+                expected_statuses=active_statuses,
             )
+            if (
+                stored_run is None
+                or stored_run.status != AgentRunStatus.AGENT_COMPLETED
+            ):
+                logger.warning(
+                    "event=extraction_agent_late_output_discarded org_id=%s "
+                    "user_id=%s extractor_kind=%s run_id=%s request_id=%s "
+                    "stored_status=%s",
+                    run.binding.org_id,
+                    run.binding.user_id,
+                    run.binding.extractor_kind,
+                    run.id,
+                    run.binding.request_id,
+                    stored_run.status if stored_run is not None else None,
+                )
+                return AgentRunResult(
+                    run_id=run.id,
+                    output=None,
+                    pending_tool_call_ids=[],
+                    messages=result.messages,
+                    trace=result.trace,
+                    finished_reason="late_output_discarded",
+                )
             logger.info(
                 "event=extraction_agent_finished org_id=%s user_id=%s "
                 "extractor_kind=%s run_id=%s request_id=%s "
@@ -437,6 +503,7 @@ class ResumableExtractionAgent:
                 AgentRunStatus.FAILED,
                 max_steps_remaining=result.max_steps_remaining,
                 last_error=last_error,
+                expected_statuses=active_statuses,
             )
             logger.warning(
                 "event=extraction_agent_failed org_id=%s user_id=%s "

package/plugin/vendor/reflexio/reflexio/server/services/extraction/resume_worker.py

@@ -161,7 +161,9 @@ def _select_current_extractor_config(
             f"Unsupported extractor kind {run.binding.extractor_kind!r}"
         )
 
-    if config is not None and isinstance(config, ProfileExtractorConfig | PlaybookConfig):
+    if config is not None and isinstance(
+        config, ProfileExtractorConfig | PlaybookConfig
+    ):
         return config
     raise ResumeWorkerError(
         f"Current extractor config not found for {run.binding.extractor_kind}"

package/plugin/vendor/reflexio/reflexio/server/services/extractor_config_utils.py

@@ -34,9 +34,12 @@ def get_extractor_name(config: object) -> str:
         return SINGLETON_USER_PLAYBOOK_NAME
     if isinstance(config, AgentSuccessConfig):
         return SINGLETON_AGENT_SUCCESS_EVALUATION_NAME
-    return getattr(config, "extractor_name", None) or getattr(
-        config, "playbook_name", None
-    ) or getattr(config, "evaluation_name", "unknown") or "unknown"
+    return (
+        getattr(config, "extractor_name", None)
+        or getattr(config, "playbook_name", None)
+        or getattr(config, "evaluation_name", "unknown")
+        or "unknown"
+    )
 
 
 def filter_extractor_configs[TExtractorConfig](

package/plugin/vendor/reflexio/reflexio/server/services/extractor_interaction_utils.py

@@ -23,7 +23,7 @@ def get_extractor_window_params[TExtractorConfig](
     Get effective window_size and stride_size for a specific extractor.
 
     Uses extractor's override values if set, otherwise falls back to global values,
-    then to defaults (window_size=10, stride_size=5).
+    then to defaults (DEFAULT_WINDOW_SIZE / DEFAULT_STRIDE_SIZE from config_schema).
 
     Args:
         extractor_config: Extractor configuration object

package/plugin/vendor/reflexio/reflexio/server/services/generation_service.py

@@ -172,10 +172,20 @@ class GenerationService:
         )
 
         try:
-            # Always generate a new UUID for request_id
-            request_id = str(uuid.uuid4())
+            caller_request_id = publish_user_interaction_request.request_id
+            request_id = (
+                caller_request_id
+                if caller_request_id is not None
+                else str(uuid.uuid4())
+            )
             result.request_id = request_id
 
+            if (
+                caller_request_id is not None
+                and self.storage.get_request(request_id) is not None  # type: ignore[reportOptionalMemberAccess]
+            ):
+                raise ValueError(f"request_id {request_id!r} already exists")
+
             new_interactions: list[Interaction] = (
                 GenerationService.get_interaction_from_publish_user_interaction_request(
                     publish_user_interaction_request, request_id
@@ -326,7 +336,8 @@ class GenerationService:
                             error_type=type(e).__name__,
                         ):
                             logger.exception(
-                                "Generation service failed for request %s", request_id,
+                                "Generation service failed for request %s",
+                                request_id,
                             )
                         result.warnings.append(msg)
             finally:
@@ -380,7 +391,8 @@ class GenerationService:
                 error_type=type(e).__name__,
             ):
                 logger.exception(
-                    "Failed to refresh user profile for user id: %s", user_id,
+                    "Failed to refresh user profile for user id: %s",
+                    user_id,
                 )
             raise
 
@@ -521,7 +533,8 @@ class GenerationService:
                             error_type=type(e).__name__,
                         ):
                             logger.exception(
-                                "Failed to cleanup retention target %s", target_name,
+                                "Failed to cleanup retention target %s",
+                                target_name,
                             )
             finally:
                 mgr.release_simple_lock()

package/plugin/vendor/reflexio/reflexio/server/services/operation_state_utils.py

@@ -403,7 +403,7 @@ class OperationStateManager:
                 request when the lock is held by someone else. Required for the
                 rerun loop to operate on the SAME interactions the original
                 publish enqueued, not whatever the bookmark currently points at
-                (R2 / reflexio-enterprise#59).
+                (R2).
 
         Returns:
             bool: True if lock acquired (proceed with generation), False if skipped
@@ -545,7 +545,7 @@ class OperationStateManager:
         FIFO drain — preserves order so blocked publishes are processed in the
         order they arrived. Replaces the older single-slot ``pending_request_id``
         last-wins behaviour that silently dropped earlier blocked publishes
-        (R2 / reflexio-enterprise#59).
+        (R2).
 
         On a legacy state row (written by a pre-fix server before redeploy)
         the queue is missing but ``pending_request_id`` may be set; we surface

package/plugin/vendor/reflexio/reflexio/server/services/playbook/playbook_consolidator.py

@@ -33,6 +33,66 @@ logger = logging.getLogger(__name__)
 # ===============================
 
 
+def _coerce_existing_position(value: object) -> int:
+    """Accept either a bare int position or an ``"EXISTING-N"`` label.
+
+    Wired ONLY to ``UnifyDecision.archive_existing_ids`` — the one field whose
+    int contract is genuinely a list **position** (resolved via
+    ``existing_by_position`` as ``f"EXISTING-{idx}"`` in ``_apply_unify``).
+    ``RejectNewDecision.superseded_by_existing_id`` and
+    ``DifferentiateDecision.existing_id`` are DB ``user_playbook_id`` values
+    (resolved via ``existing_by_id`` in ``_apply_reject_new`` /
+    ``_apply_differentiate``) — coercing ``"EXISTING-N"`` to ``N`` on those
+    fields would silently misroute decisions when the position int doesn't
+    map to a real DB id.
+
+    The consolidation prompt labels rows as ``[EXISTING-0]``, ``[EXISTING-1]``
+    etc. (see ``_format_playbooks_with_prefix``) and ``_apply_unify``
+    reconstructs ``f"EXISTING-{position}"`` from the integer the LLM returns.
+    Strong structured-output models (GPT-4o, Claude) honor the ``list[int]``
+    schema and return the bare integer ``0``; weaker models (e.g. MiniMax-M3)
+    ignore the int constraint and return the literal label ``"EXISTING-0"``
+    instead — which then fails pydantic validation and the whole
+    consolidation batch dies.
+
+    Strip the prefix when present so the schema tolerates both shapes
+    without changing the int contract downstream consumers rely on. Plain
+    numeric strings (``"5"``) are also accepted for symmetry with how
+    most JSON-coerced models handle ID-like values. Negative values are
+    rejected — list positions are always ``>= 0``.
+
+    Raises:
+        ValueError: when ``value`` is not a non-negative int or a recognized
+            position-label / numeric string.
+    """
+    if isinstance(value, bool):
+        # ``bool`` is a subclass of ``int`` in Python; reject explicitly so a
+        # stray ``True`` doesn't silently become position 1.
+        raise ValueError(f"existing-position must be int, got bool: {value!r}")
+    if isinstance(value, int):
+        if value < 0:
+            raise ValueError(f"existing-position must be >= 0, got {value!r}")
+        return value
+    if isinstance(value, str):
+        stripped = value.strip()
+        for prefix in ("EXISTING-", "EXISTING_", "existing-", "existing_"):
+            if stripped.startswith(prefix):
+                stripped = stripped[len(prefix) :]
+                break
+        try:
+            parsed = int(stripped)
+        except ValueError as exc:
+            raise ValueError(
+                f"existing-position must be int or 'EXISTING-N' label, got {value!r}"
+            ) from exc
+        if parsed < 0:
+            raise ValueError(f"existing-position must be >= 0, got {value!r}")
+        return parsed
+    raise ValueError(
+        f"existing-position must be int or 'EXISTING-N' label, got {type(value).__name__}: {value!r}"
+    )
+
+
 class UnifyDecision(BaseModel):
     """Collapse NEW (+ 0..N EXISTING) into one row with LLM-supplied content.
 
@@ -57,11 +117,28 @@ class UnifyDecision(BaseModel):
     rationale: str
     reason: str = ""
 
+    @field_validator("archive_existing_ids", mode="before")
+    @classmethod
+    def _coerce_archive_ids(cls, value: object) -> object:
+        if value is None:
+            return []
+        if isinstance(value, list):
+            return [_coerce_existing_position(item) for item in value]
+        return value
+
     model_config = ConfigDict(json_schema_extra={"additionalProperties": False})
 
 
 class RejectNewDecision(BaseModel):
-    """The new candidate is redundant; an existing row supersedes it (storage no-op)."""
+    """The new candidate is redundant; an existing row supersedes it (storage no-op).
+
+    ``superseded_by_existing_id`` is a DB ``user_playbook_id`` (resolved
+    against ``existing_by_id`` in ``_apply_reject_new``), NOT a list
+    position — no ``"EXISTING-N"`` coercion is wired here. If the LLM
+    returns ``"EXISTING-N"`` for this field, pydantic rejects it loudly
+    rather than silently misrouting the decision (see
+    ``_coerce_existing_position`` docstring).
+    """
 
     kind: Literal["reject_new"] = "reject_new"
     new_id: str
@@ -72,7 +149,13 @@ class RejectNewDecision(BaseModel):
 
 
 class DifferentiateDecision(BaseModel):
-    """Both rules valid in distinct contexts: refine both triggers."""
+    """Both rules valid in distinct contexts: refine both triggers.
+
+    ``existing_id`` is a DB ``user_playbook_id`` (resolved against
+    ``existing_by_id`` in ``_apply_differentiate``), NOT a list position —
+    no ``"EXISTING-N"`` coercion is wired here. See
+    ``_coerce_existing_position`` docstring.
+    """
 
     kind: Literal["differentiate"] = "differentiate"
     new_id: str
@@ -571,7 +654,9 @@ class PlaybookConsolidator(BaseDeduplicator):
                 ):
                     logger.exception(
                         "event=consolidation_apply_failed kind=%s new_id=%s existing_id=%s",
-                        decision.kind, new_id_str, existing_id_str,
+                        decision.kind,
+                        new_id_str,
+                        existing_id_str,
                     )
                 continue
             new_rows.extend(rows)

package/plugin/vendor/reflexio/reflexio/server/services/profile/profile_deduplicator.py

@@ -7,12 +7,12 @@ import logging
 import os
 import uuid
 from datetime import UTC, datetime
+from typing import Any, cast
 
 from pydantic import BaseModel, ConfigDict, Field
 
 from reflexio.models.api_schema.retriever_schema import SearchUserProfileRequest
 from reflexio.models.api_schema.service_schemas import Status, UserProfile
-from reflexio.models.config_schema import EMBEDDING_DIMENSIONS
 from reflexio.server.api_endpoints.request_context import RequestContext
 from reflexio.server.llm.litellm_client import LiteLLMClient
 from reflexio.server.services.deduplication_utils import (
@@ -20,6 +20,7 @@ from reflexio.server.services.deduplication_utils import (
     format_dedup_timestamp,
     parse_item_id,
 )
+from reflexio.server.services.embedding_text import embedding_input
 from reflexio.server.services.profile.profile_generation_service_utils import (
     ProfileTimeToLive,
     calculate_expiration_timestamp,
@@ -302,11 +303,41 @@ class ProfileDeduplicator(BaseDeduplicator):
         if not query_texts:
             return []
 
-        # Batch-generate embeddings
+        # Generate embeddings with the request storage backend so dedup search
+        # uses the same model/prefix/routing as normal profile search.
+        embeddings: list[list[float] | None]
         try:
-            embeddings = self.client.get_embeddings(
-                query_texts, dimensions=EMBEDDING_DIMENSIONS
-            )
+            get_storage_embedding = getattr(storage, "_get_embedding", None)
+            if callable(get_storage_embedding):
+                logger.info(
+                    "Profile dedup query embeddings: source=storage model=%s",
+                    getattr(storage, "embedding_model_name", "unknown"),
+                )
+                embeddings = [
+                    cast(
+                        list[float],
+                        get_storage_embedding(query_text, purpose="query"),
+                    )
+                    for query_text in query_texts
+                ]
+            else:
+                storage_with_embeddings = cast(Any, storage)
+                embedding_model_name = storage_with_embeddings.embedding_model_name
+                embedding_dimensions = storage_with_embeddings.embedding_dimensions
+                logger.info(
+                    "Profile dedup query embeddings: source=llm_client model=%s",
+                    embedding_model_name,
+                )
+                embeddings = list(
+                    self.client.get_embeddings(
+                        [
+                            embedding_input(query_text, purpose="query")
+                            for query_text in query_texts
+                        ],
+                        model=embedding_model_name,
+                        dimensions=embedding_dimensions,
+                    )
+                )
         except Exception as e:
             logger.warning("Failed to generate embeddings for dedup search: %s", e)
             embeddings = [None] * len(query_texts)

package/plugin/vendor/reflexio/reflexio/server/services/profile/profile_generation_service.py

@@ -198,7 +198,8 @@ class ProfileGenerationService(
                     error_type=type(e).__name__,
                 ):
                     logger.exception(
-                        "Failed to save profiles for user id: %s", user_id,
+                        "Failed to save profiles for user id: %s",
+                        user_id,
                     )
                 return
 
@@ -224,7 +225,8 @@ class ProfileGenerationService(
                     ):
                         logger.exception(
                             "Failed to delete superseded profile %s for user %s",
-                            profile_id, user_id,
+                            profile_id,
+                            user_id,
                         )
 
         # Create profile changelog post-deduplication
@@ -250,7 +252,8 @@ class ProfileGenerationService(
                     error_type=type(e).__name__,
                 ):
                     logger.exception(
-                        "Failed to add profile change log for user %s", user_id,
+                        "Failed to add profile change log for user %s",
+                        user_id,
                     )
 
     def check_and_update_profiles(self, profiles: list[UserProfile]) -> None:

package/plugin/vendor/reflexio/reflexio/server/services/reflection/reflection_service.py

@@ -253,7 +253,8 @@ class ReflectionService:
                 ):
                     logger.exception(
                         "event=reflection_apply_failed kind=%s target_id=%s",
-                        decision.target_kind, decision.target_id,
+                        decision.target_kind,
+                        decision.target_id,
                     )
                 continue
             if applied:
@@ -498,7 +499,8 @@ class ReflectionService:
                 logger.exception(
                     "event=reflection_archive_after_insert_failed kind=profile "
                     "cited_id=%s new_id=%s",
-                    cited.profile_id, new_profile.profile_id,
+                    cited.profile_id,
+                    new_profile.profile_id,
                 )
             return True
         if not archived:
@@ -597,7 +599,8 @@ class ReflectionService:
                 logger.exception(
                     "event=reflection_archive_after_insert_failed kind=playbook "
                     "cited_id=%s new_id=%s",
-                    cited.user_playbook_id, new_playbook.user_playbook_id,
+                    cited.user_playbook_id,
+                    new_playbook.user_playbook_id,
                 )
             return True
         if not archived:

package/plugin/vendor/reflexio/reflexio/server/services/retrieval/relevance_floor.py

@@ -15,6 +15,7 @@ from reflexio.server.llm.rerank import score_pairs
 from reflexio.server.llm.rerank.cross_encoder_reranker import (
     CrossEncoderUnavailableError,
 )
+from reflexio.server.tracing import profile_step
 
 logger = logging.getLogger(__name__)
 
@@ -44,27 +45,36 @@ def apply_relevance_floor[T](
     """
     if not items:
         return []
-    try:
-        scores = score_pairs(query, [content_of(item) for item in items])
-    except CrossEncoderUnavailableError:
-        logger.warning(
-            "event=relevance_floor_unavailable arm=%s items=%d (returning unfiltered top_k)",
-            arm,
-            len(items),
-        )
-        return items[:top_k]
+    with profile_step(
+        "search.rerank.relevance_floor",
+        arm=arm,
+        items=len(items),
+    ) as span:
+        try:
+            scores = score_pairs(query, [content_of(item) for item in items])
+        except CrossEncoderUnavailableError:
+            span.set_data("available", False)
+            logger.warning(
+                "event=relevance_floor_unavailable arm=%s items=%d (returning unfiltered top_k)",
+                arm,
+                len(items),
+            )
+            return items[:top_k]
+        span.set_data("available", True)
 
-    ranked = sorted(
-        zip(items, scores, strict=True), key=lambda pair: pair[1], reverse=True
-    )
-    survivors = [item for item, score in ranked if score >= floor]
-    dropped = len(ranked) - len(survivors)
-    if dropped:
-        logger.info(
-            "event=relevance_floor arm=%s kept=%d dropped=%d floor=%.2f",
-            arm,
-            len(survivors),
-            dropped,
-            floor,
+        ranked = sorted(
+            zip(items, scores, strict=True), key=lambda pair: pair[1], reverse=True
         )
-    return survivors[:top_k]
+        survivors = [item for item, score in ranked if score >= floor]
+        dropped = len(ranked) - len(survivors)
+        span.set_data("kept", len(survivors))
+        span.set_data("dropped", dropped)
+        if dropped:
+            logger.info(
+                "event=relevance_floor arm=%s kept=%d dropped=%d floor=%.2f",
+                arm,
+                len(survivors),
+                dropped,
+                floor,
+            )
+        return survivors[:top_k]