claude-smart 0.2.43 → 0.2.45

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

@@ -5,11 +5,14 @@ Utils for service layer
 import ast
 import json
 import logging
+import os
 import re
 from dataclasses import dataclass
 from datetime import UTC, datetime
 from typing import Any
 
+import tiktoken
+
 from reflexio.cli.log_format import LLM_IO_LOG_FILE, next_llm_entry_id
 from reflexio.models.api_schema.internal_schema import RequestInteractionDataModel
 from reflexio.models.api_schema.service_schemas import (
@@ -25,6 +28,88 @@ logger = logging.getLogger(__name__)
 # Already registered in server/__init__.py; import the numeric constant only.
 MODEL_RESPONSE_LEVEL = 25
 
+# Per-interaction content token budget when formatting interactions into an
+# extraction/evaluation prompt. Read from REFLEXIO_MAX_INTERACTION_CONTENT_TOKENS;
+# a value <= 0 disables slicing. See _resolve_max_interaction_content_tokens.
+DEFAULT_MAX_INTERACTION_CONTENT_TOKENS = 512
+_MAX_INTERACTION_CONTENT_TOKENS_ENV = "REFLEXIO_MAX_INTERACTION_CONTENT_TOKENS"
+# Inserted between the head and tail of a sliced interaction so the LLM can see
+# that the middle of the content was elided.
+_CONTENT_TRUNCATION_MARKER = " …[truncated] "
+# Encoder used purely as a length heuristic for slicing. tiktoken does not know
+# the real tokenizer for non-OpenAI providers, but cl100k_base is a consistent,
+# good-enough proxy for budgeting prompt content (mirrors the embedding path).
+_CONTENT_ENCODING_NAME = "cl100k_base"
+_content_token_encoding: tiktoken.Encoding | None = None
+# Guards against logging the same malformed env value on every call.
+_INVALID_MAX_TOKENS_WARNED = False
+
+
+def _get_content_token_encoding() -> tiktoken.Encoding:
+    """Return a process-cached tiktoken encoder for content slicing."""
+    global _content_token_encoding
+    if _content_token_encoding is None:
+        _content_token_encoding = tiktoken.get_encoding(_CONTENT_ENCODING_NAME)
+    return _content_token_encoding
+
+
+def _resolve_max_interaction_content_tokens() -> int | None:
+    """Resolve the per-interaction content token budget from the environment.
+
+    Returns:
+        int | None: The positive token budget, or None when slicing is
+            disabled (env value <= 0). Unset or malformed values fall back to
+            ``DEFAULT_MAX_INTERACTION_CONTENT_TOKENS``.
+    """
+    global _INVALID_MAX_TOKENS_WARNED
+    raw = os.getenv(_MAX_INTERACTION_CONTENT_TOKENS_ENV, "").strip()
+    if not raw:
+        return DEFAULT_MAX_INTERACTION_CONTENT_TOKENS
+    try:
+        value = int(raw)
+    except ValueError:
+        if not _INVALID_MAX_TOKENS_WARNED:
+            logger.warning(
+                "Invalid %s=%r; falling back to default %d",
+                _MAX_INTERACTION_CONTENT_TOKENS_ENV,
+                raw,
+                DEFAULT_MAX_INTERACTION_CONTENT_TOKENS,
+            )
+            _INVALID_MAX_TOKENS_WARNED = True
+        return DEFAULT_MAX_INTERACTION_CONTENT_TOKENS
+    return value if value > 0 else None
+
+
+def slice_content_by_tokens(content: str, max_tokens: int | None) -> str:
+    """Slice interaction content to a token budget, keeping head and tail.
+
+    When the content exceeds ``max_tokens`` tokens, keep the first ``max_tokens
+    // 2`` tokens and the last ``max_tokens - max_tokens // 2`` tokens, joined by
+    a truncation marker so the elision is visible to the LLM. Content within
+    budget (or when ``max_tokens`` is None / content is empty) is returned
+    unchanged.
+
+    Args:
+        content (str): The interaction content to slice.
+        max_tokens (int | None): Token budget, or None to disable slicing.
+
+    Returns:
+        str: The original or head+marker+tail-sliced content.
+    """
+    if max_tokens is None or not content:
+        return content
+    encoding = _get_content_token_encoding()
+    tokens = encoding.encode(content)
+    if len(tokens) <= max_tokens:
+        return content
+    head = max_tokens // 2
+    tail = max_tokens - head
+    return (
+        f"{encoding.decode(tokens[:head])}"
+        f"{_CONTENT_TRUNCATION_MARKER}"
+        f"{encoding.decode(tokens[-tail:])}"
+    )
+
 
 def _format_response_for_logging(response: Any) -> Any:
     """Render ``ToolCallingChatResponse`` with pretty tool_calls; pass others through.
@@ -188,22 +273,22 @@ def format_interactions_to_history_string(interactions: list[Interaction]) -> st
         user: I love sushi
         user: click menu item
     """
+    max_content_tokens = _resolve_max_interaction_content_tokens()
     formatted_interactions = []
     for interaction in interactions:
         # Add text content with tools_used prefix if present
         if interaction.content:
+            content = slice_content_by_tokens(interaction.content, max_content_tokens)
             if interaction.tools_used:
                 tool_prefix = " ".join(
                     f"[used tool: {t.tool_name}({json.dumps(t.tool_data)})]"
                     for t in interaction.tools_used
                 )
                 formatted_interactions.append(
-                    f"{interaction.role}: ```{tool_prefix} {interaction.content}```"
+                    f"{interaction.role}: ```{tool_prefix} {content}```"
                 )
             else:
-                formatted_interactions.append(
-                    f"{interaction.role}: ```{interaction.content}```"
-                )
+                formatted_interactions.append(f"{interaction.role}: ```{content}```")
 
         # Add user action
         if interaction.user_action != UserActionType.NONE:

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/_agent_run.py

@@ -333,6 +333,7 @@ class SQLiteAgentRunMixin:
         next_resume_at: datetime | None = None,
         last_error: str | None = None,
         increment_finalization_attempts: bool = False,
+        expected_statuses: tuple[AgentRunStatus, ...] | None = None,
     ) -> AgentRunRecord | None:
         current_timestamp = self._current_timestamp()
         assignments = ["status = ?", "updated_at = ?"]
@@ -361,14 +362,58 @@ class SQLiteAgentRunMixin:
             assignments.append("finalized_at = ?")
             params.append(current_timestamp)
         params.append(run_id)
+        status_filter = ""
+        if expected_statuses:
+            placeholders = ",".join("?" for _ in expected_statuses)
+            status_filter = f" AND status IN ({placeholders})"
+            params.extend(expected.value for expected in expected_statuses)
         with self._lock:
             self.conn.execute(
-                f"UPDATE _agent_runs SET {', '.join(assignments)} WHERE id = ?",
+                f"UPDATE _agent_runs SET {', '.join(assignments)} WHERE id = ?{status_filter}",
                 params,
             )
             self.conn.commit()
         return self.get_agent_run(run_id)
 
+    @SQLiteStorageBase.handle_exceptions
+    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:
+        current_timestamp = self._current_timestamp()
+        with self._lock:
+            cursor = self.conn.execute(
+                """
+                UPDATE _agent_runs
+                SET status = ?,
+                    updated_at = ?,
+                    last_error = ?
+                WHERE org_id = ?
+                  AND extractor_kind = ?
+                  AND user_id IS ?
+                  AND request_id = ?
+                  AND status IN (?, ?)
+                """,
+                (
+                    AgentRunStatus.FAILED.value,
+                    current_timestamp,
+                    last_error,
+                    org_id,
+                    extractor_kind,
+                    user_id,
+                    request_id,
+                    AgentRunStatus.RUNNING.value,
+                    AgentRunStatus.RESUMING.value,
+                ),
+            )
+            self.conn.commit()
+            return cursor.rowcount
+
     @SQLiteStorageBase.handle_exceptions
     def create_pending_tool_call(
         self, record: PendingToolCallRecord

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

@@ -220,9 +220,21 @@ class AgentRunMixin:
         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 create_pending_tool_call(
         self, record: PendingToolCallRecord
     ) -> PendingToolCallRecord:

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

@@ -160,7 +160,7 @@ class OperationMixin:
             payload (dict | None): Optional serialized request payload preserved
                 for the rerun loop. Required so the rerun runs against the SAME
                 interactions the blocked publish enqueued, not whatever the
-                bookmark currently points at (R2 / reflexio-enterprise#59).
+                bookmark currently points at (R2).
 
         Returns:
             dict: Result with keys:

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

@@ -357,7 +357,8 @@ def _apply_floors(
 ) -> tuple[list[UserProfile], list[AgentPlaybook], list[UserPlaybook]]:
     """Apply the per-arm relevance floor to each entity arm in parallel."""
     with ThreadPoolExecutor(max_workers=3) as ex:
-        f_profiles = ex.submit(
+        f_profiles = _submit_with_current_context(
+            ex,
             apply_relevance_floor,
             query,
             profiles,
@@ -365,7 +366,8 @@ def _apply_floors(
             top_k,
             arm="profiles",
         )
-        f_agent = ex.submit(
+        f_agent = _submit_with_current_context(
+            ex,
             apply_relevance_floor,
             query,
             agent_playbooks,
@@ -373,7 +375,8 @@ def _apply_floors(
             top_k,
             arm="agent_playbooks",
         )
-        f_user = ex.submit(
+        f_user = _submit_with_current_context(
+            ex,
             apply_relevance_floor,
             query,
             user_playbooks,
@@ -533,9 +536,10 @@ def _submit_with_current_context(
     executor: ThreadPoolExecutor,
     fn: Callable[..., object],
     *args: object,
+    **kwargs: object,
 ) -> Future[Any]:
     context = contextvars.copy_context()
-    return executor.submit(context.run, fn, *args)
+    return executor.submit(context.run, fn, *args, **kwargs)
 
 
 def _storage_backend_name(storage: BaseStorage) -> str: