claude-smart 0.2.45 → 0.2.47

package/plugin/vendor/reflexio/reflexio/server/tracing.py

@@ -156,3 +156,33 @@ def sentry_tags(**tags: Any) -> Iterator[None]:
             scope_cm.__exit__(None, None, None)
         except Exception as exc:  # noqa: BLE001
             logger.warning("Failed to close Sentry scope: %s", exc)
+
+
+def capture_anomaly(message: str, *, level: str = "warning", **tags: Any) -> None:
+    """Report a non-fatal anomaly to Sentry, if the SDK is installed.
+
+    For silent-but-noteworthy conditions that return rather than raise — e.g.
+    lineage resolution hitting a cycle or the hop cap, or a best-effort
+    provenance append failing. No-op when ``sentry-sdk`` is absent (the OS
+    package does not depend on it; enterprise deployments pull it in). Never
+    raises — instrumentation must not turn a degraded-but-working path into a
+    failure.
+
+    Args:
+        message: short, low-cardinality description of the anomaly (the Sentry
+            issue title), e.g. ``"lineage.resolve_current.cycle"``.
+        level: Sentry severity ("warning", "error", ...). Defaults to "warning".
+        **tags: contextual tag name → value pairs (None values are skipped).
+    """
+    try:
+        import sentry_sdk  # type: ignore[import-not-found]
+    except ImportError:
+        return
+    try:
+        with sentry_sdk.new_scope() as scope:
+            for key, value in tags.items():
+                if value is not None:
+                    scope.set_tag(key, str(value))
+            sentry_sdk.capture_message(message, level=level)
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("Failed to capture Sentry anomaly %r: %s", message, exc)

package/plugin/vendor/reflexio/reflexio/server/usage_metrics.py

@@ -34,6 +34,12 @@ class UsageEvent:
     backend: str | None = None
     outcome: str | None = None
     count_value: int = 1
+    prompt_tokens: int | None = None
+    completion_tokens: int | None = None
+    billing_input_tokens: int | None = None
+    platform_llm: bool | None = None
+    platform_storage: bool | None = None
+    caller_type: str | None = None
     duration_ms: int | None = None
     error_kind: str | None = None
     metadata: Mapping[str, Any] = field(default_factory=dict)
@@ -73,6 +79,12 @@ def record_usage_event(
     backend: str | None = None,
     outcome: str | None = None,
     count_value: int = 1,
+    prompt_tokens: int | None = None,
+    completion_tokens: int | None = None,
+    billing_input_tokens: int | None = None,
+    platform_llm: bool | None = None,
+    platform_storage: bool | None = None,
+    caller_type: str | None = None,
     duration_ms: int | None = None,
     error_kind: str | None = None,
     metadata: Mapping[str, Any] | None = None,
@@ -104,6 +116,12 @@ def record_usage_event(
                 backend=backend,
                 outcome=outcome,
                 count_value=count_value,
+                prompt_tokens=prompt_tokens,
+                completion_tokens=completion_tokens,
+                billing_input_tokens=billing_input_tokens,
+                platform_llm=platform_llm,
+                platform_storage=platform_storage,
+                caller_type=caller_type,
                 duration_ms=duration_ms,
                 error_kind=error_kind,
                 metadata=metadata or {},

package/plugin/vendor/reflexio/reflexio/test_support/llm_mock.py

@@ -39,6 +39,7 @@ from contextlib import contextmanager
 from typing import Any
 from unittest.mock import MagicMock, patch
 
+from reflexio.models.structured_output import find_schema_keyword as _find_schema_key
 from reflexio.test_support.llm_model_registry import get_model_registry
 
 
@@ -69,6 +70,8 @@ def _create_mock_completion(
         # intrinsic to the schema, not stylistic, so it survives prompt
         # rewrites better than matching on a tagline like "policy mining".
         content = json.dumps(registry["playbook_extraction"].minimal_valid)
+    elif '"tags"' in prompt_content:
+        content = json.dumps(registry["tagging"].minimal_valid)
     elif parse_structured_output:
         content = json.dumps(registry["profile_extraction"].minimal_valid)
     else:
@@ -78,47 +81,58 @@ def _create_mock_completion(
     mock_response = MagicMock()
     mock_response.choices = [MagicMock()]
     mock_response.choices[0].message.content = content
+    # Explicitly clear tool_calls: structured-output extraction now passes
+    # ``tools=`` (ask_human) alongside ``response_format``, so the client's
+    # tool-calling branch inspects ``message.tool_calls``. Without this, a bare
+    # MagicMock attribute would read as truthy and be misparsed as a tool call.
+    mock_response.choices[0].message.tool_calls = None
     mock_response.choices[0].finish_reason = "stop"
     return mock_response
 
 
-def _extraction_finish_args(prompt_content: str) -> dict[str, Any]:
-    """Pick the ``finish_extraction`` payload for an extraction tool-loop turn.
-
-    Profile and playbook extraction both run the always-on ``finish_extraction``
-    tool loop, so the mock must return the structured output as the *arguments*
-    of a ``finish_extraction`` tool call (not as message content). Routes on the
-    same schema marker the content-mode path uses.
+def _assert_response_format_strict_compatible(kwargs: dict[str, Any]) -> None:
+    """Guard every structured-output call: a ``json_schema`` response_format sent
+    to the provider must be OpenAI strict-mode compatible (no ``oneOf`` /
+    ``discriminator``). Pydantic discriminated unions emit ``oneOf``, which strict
+    structured-output endpoints reject with a 400 (Sentry PYTHON-FASTAPI-9J) — a
+    failure the canned mock would otherwise hide. Raw Pydantic-class
+    response_format (the unsupported-provider passthrough) is skipped: that path
+    is handled by LiteLLM/the provider, not by an explicit strict schema.
     """
-    registry = get_model_registry()
-    if '"playbooks"' in prompt_content:
-        return registry["playbook_extraction"].minimal_valid
-    return registry["profile_extraction"].minimal_valid
+    response_format = kwargs.get("response_format")
+    if not isinstance(response_format, dict):
+        return
+    if response_format.get("type") != "json_schema":
+        return
+    schema = response_format.get("json_schema", {}).get("schema")
+    if not isinstance(schema, dict):
+        return
+    for banned in ("oneOf", "discriminator"):
+        if _find_schema_key(schema, banned):
+            raise AssertionError(
+                f"response_format json_schema contains '{banned}' — OpenAI strict "
+                "structured outputs reject it. Normalize via make_strict_json_schema "
+                "before sending (Sentry PYTHON-FASTAPI-9J)."
+            )
 
 
 def _mock_completion(*args: Any, **kwargs: Any) -> MagicMock:
     """Mock implementation for litellm.completion."""
+    _assert_response_format_strict_compatible(kwargs)
     messages = kwargs.get("messages", args[0] if args else [])
     prompt_content = ""
     for message in messages:
         if isinstance(message, dict) and "content" in message:
             prompt_content += str(message["content"])
 
-    # Extraction now runs through the ``finish_extraction`` tool loop, which
-    # invokes ``litellm.completion`` with ``tools=``. In that mode the loop
-    # reads ``resp.tool_calls`` (not message content), so emit a single
-    # ``finish_extraction`` tool call carrying the structured output as args.
-    if kwargs.get("tools"):
-        # Imported lazily to avoid importing the extraction service stack at
-        # module load time (this module is imported by the root conftest).
-        from reflexio.server.services.extraction.resumable_agent import (
-            FINISH_EXTRACTION_TOOL_NAME,
-        )
-
-        return make_tool_call_response(
-            FINISH_EXTRACTION_TOOL_NAME, _extraction_finish_args(prompt_content)
-        )
-
+    # Extraction now delivers its result as a native structured response
+    # (response_format=output_schema): the tool loop reads the final answer from
+    # message CONTENT (parsed into the schema), with ask_human /
+    # attach_pending_info_request available only as optional intermediate tools.
+    # So whenever a response_format is requested, emit structured content with no
+    # tool call — the common "finish" path. Tests that exercise an intermediate
+    # tool call (ask_human) install explicit responses via ``side_effect`` using
+    # ``make_tool_call_response``; they don't rely on this default router.
     parse_structured = kwargs.get("response_format") is not None
     return _create_mock_completion(prompt_content, parse_structured)
 
@@ -221,6 +235,27 @@ def make_tool_call_response(tool_name: str, args: dict[str, Any]) -> MagicMock:
     return resp
 
 
+def make_structured_finish(payload: dict[str, Any] | str) -> MagicMock:
+    """Build a structured-response finish for the extraction agent.
+
+    The resumable extraction agent now delivers its result as a native
+    structured response — the schema-conformant JSON arrives as the assistant
+    message content (no tool call), and the tool loop parses it into the output
+    schema. Use this in place of the old ``make_tool_call_response(
+    FINISH_EXTRACTION_TOOL_NAME, payload)`` pattern.
+
+    Args:
+        payload: The extraction result as a dict (serialized to JSON) or an
+            already-serialized JSON string (e.g. ``model.model_dump_json()``).
+
+    Returns:
+        MagicMock: A response object whose message content is the JSON payload
+            and whose ``tool_calls`` is None.
+    """
+    content = payload if isinstance(payload, str) else json.dumps(payload)
+    return make_finish_response(content)
+
+
 def make_finish_response(text: str = "done") -> MagicMock:
     """Build a normal (non-tool-call) assistant message.
 

package/plugin/vendor/reflexio/reflexio/test_support/llm_model_registry.py

@@ -29,23 +29,29 @@ class ModelRegistryEntry:
 
 def _build_registry() -> dict[str, ModelRegistryEntry]:
     """Build the model registry with lazy imports to avoid circular dependencies."""
+    from reflexio.models.api_schema.eval_overview_schema import ShadowComparisonOutput
     from reflexio.server.services.agent_success_evaluation.agent_success_evaluation_constants import (
         AgentSuccessEvaluationOutput,
     )
-    from reflexio.server.services.playbook.playbook_consolidator import (
+    from reflexio.server.services.playbook.components.consolidator import (
         PlaybookConsolidationOutput,
     )
     from reflexio.server.services.playbook.playbook_service_utils import (
         PlaybookAggregationOutput,
         StructuredPlaybookList,
     )
-    from reflexio.server.services.profile.profile_deduplicator import (
+    from reflexio.server.services.playbook_optimizer.models import JudgeOutput
+    from reflexio.server.services.profile.components.consolidator import (
         ProfileDeduplicationOutput,
     )
     from reflexio.server.services.profile.profile_generation_service_utils import (
         ProfileUpdateOutput,
         StructuredProfilesOutput,
     )
+    from reflexio.server.services.reflection.reflection_service_utils import (
+        ReflectionOutput,
+    )
+    from reflexio.server.services.tagging.service import TagsOutput
 
     return {
         "playbook_extraction": ModelRegistryEntry(
@@ -108,9 +114,40 @@ def _build_registry() -> dict[str, ModelRegistryEntry]:
                 "is_escalated": False,
             },
         ),
+        "tagging": ModelRegistryEntry(
+            model_class=TagsOutput,
+            minimal_valid={"tags": ["example_tag"]},
+        ),
+        "reflection": ModelRegistryEntry(
+            model_class=ReflectionOutput,
+            minimal_valid={
+                "decisions": [
+                    {
+                        "target_kind": "profile",
+                        "target_id": "PROFILE-0",
+                        "reason": "no change",
+                    },
+                ],
+            },
+        ),
+        "playbook_optimizer_judge": ModelRegistryEntry(
+            model_class=JudgeOutput,
+            minimal_valid={
+                "verdict": "candidate",
+                "score": 0.5,
+                "likert": 3,
+            },
+        ),
+        "shadow_comparison": ModelRegistryEntry(
+            model_class=ShadowComparisonOutput,
+            minimal_valid={
+                "better_request": "1",
+                "is_significantly_better": True,
+            },
+        ),
         # F1 cleanup: ``agent_success_evaluation_comparison`` was removed along
-        # with the session-level shadow comparison branch. Per-turn shadow
-        # comparison registers its own registry entry alongside its prompt.
+        # with the session-level shadow comparison branch. The per-turn shadow
+        # comparison entry is registered above (``shadow_comparison``).
         "boolean_evaluation": ModelRegistryEntry(
             model_class=None,
             minimal_valid="true",

package/scripts/setup-claude-smart.sh

@@ -202,7 +202,8 @@ normalize_host() {
   case "$1" in
     1|claude|claude-code|Claude*) printf 'claude-code\n' ;;
     2|codex|Codex*) printf 'codex\n' ;;
-    3|both|Both*) printf 'both\n' ;;
+    3|all|both|Both*) printf 'all\n' ;;
+    4|opencode|OpenCode*) printf 'opencode\n' ;;
     *) return 1 ;;
   esac
 }
@@ -276,9 +277,13 @@ install_for_host() {
     codex)
       "$node_bin" "$INSTALLER" install --host codex
       ;;
-    both)
+    opencode)
+      "$node_bin" "$INSTALLER" install --host opencode
+      ;;
+    all)
       "$node_bin" "$INSTALLER" install
       "$node_bin" "$INSTALLER" install --host codex
+      "$node_bin" "$INSTALLER" install --host opencode
       ;;
   esac
 }
@@ -306,7 +311,7 @@ main() {
     default_scope="global"
   fi
 
-  host="$(prompt_normalized "Host (1=Claude Code, 2=Codex, 3=both)" "claude-code" normalize_host)"
+  host="$(prompt_normalized "Host (1=Claude Code, 2=Codex, 3=all, 4=OpenCode)" "claude-code" normalize_host)"
   mode="$(prompt_normalized "Setup mode (1=local, 2=managed Reflexio)" "$default_mode" normalize_mode)"
 
   if [ "$mode" = "local" ]; then