claude-smart 0.2.41 → 0.2.43

package/plugin/vendor/reflexio/reflexio/server/llm/llm_utils.py

@@ -0,0 +1,112 @@
+import inspect
+from copy import deepcopy
+from typing import Any
+
+from pydantic import BaseModel
+
+_STRICT_SCHEMA_UNSUPPORTED_KEYWORDS = frozenset(
+    {
+        "exclusiveMaximum",
+        "exclusiveMinimum",
+        "format",
+        "maxItems",
+        "maxLength",
+        "maxProperties",
+        "maximum",
+        "minItems",
+        "minLength",
+        "minProperties",
+        "minimum",
+        "multipleOf",
+        "pattern",
+        "patternProperties",
+        "propertyNames",
+        "uniqueItems",
+    }
+)
+
+
+def is_pydantic_model(response_format: Any) -> bool:
+    """
+    Check if response_format is a Pydantic BaseModel class.
+
+    Args:
+        response_format: Response format to check.
+
+    Returns:
+        True if response_format is a Pydantic BaseModel class, False otherwise.
+    """
+    return inspect.isclass(response_format) and issubclass(response_format, BaseModel)
+
+
+def make_strict_json_schema(schema: dict[str, Any]) -> dict[str, Any]:
+    """Return a JSON schema shaped for strict structured-output decoding.
+
+    Strict structured-output providers generally require object schemas to
+    forbid extra keys and list all properties as required. Pydantic optional
+    fields are still preserved as nullable via their existing ``anyOf`` /
+    ``type: ["...", "null"]`` schema, so the model can emit ``null`` instead
+    of omitting the field. Provider-unsupported validation keywords are
+    removed from the request schema; Pydantic still enforces them after parse.
+    """
+
+    strict_schema = deepcopy(schema)
+
+    def visit(node: Any) -> None:
+        if not isinstance(node, dict):
+            return
+
+        node.pop("default", None)
+        for keyword in _STRICT_SCHEMA_UNSUPPORTED_KEYWORDS:
+            node.pop(keyword, None)
+
+        # Strict structured output (OpenAI) permits ``anyOf`` but rejects
+        # ``oneOf`` and ``discriminator``. Pydantic emits ``oneOf`` for
+        # discriminated unions; fold it into ``anyOf`` so generation is
+        # constrained to the same variants. Pydantic still enforces the
+        # discriminator after parse, so semantics are preserved.
+        one_of = node.pop("oneOf", None)
+        node.pop("discriminator", None)
+        if isinstance(one_of, list):
+            node["anyOf"] = node.get("anyOf", []) + one_of
+
+        properties = node.get("properties")
+        if isinstance(properties, dict):
+            node["additionalProperties"] = False
+            node["required"] = list(properties.keys())
+            for child in properties.values():
+                visit(child)
+        else:
+            additional = node.get("additionalProperties")
+            if isinstance(additional, dict):
+                visit(additional)
+
+        defs = node.get("$defs")
+        if isinstance(defs, dict):
+            for child in defs.values():
+                visit(child)
+
+        for key in ("items", "contains", "not"):
+            visit(node.get(key))
+
+        for key in ("anyOf", "allOf", "prefixItems"):
+            children = node.get(key)
+            if isinstance(children, list):
+                for child in children:
+                    visit(child)
+
+    visit(strict_schema)
+    return strict_schema
+
+
+def strict_response_format_for_model(model: type[BaseModel]) -> dict[str, Any]:
+    """Build a LiteLLM/OpenAI-compatible strict ``json_schema`` response format."""
+
+    return {
+        "type": "json_schema",
+        "json_schema": {
+            "name": model.__name__,
+            "schema": make_strict_json_schema(model.model_json_schema()),
+            "strict": True,
+        },
+    }

package/plugin/vendor/reflexio/reflexio/server/llm/model_defaults.py

@@ -0,0 +1,469 @@
+"""Auto-detect available LLM providers and resolve default models by API key.
+
+Resolution order (highest priority first):
+    1. LLMConfig override (org-level configuration)
+    2. llm_model_setting.json site var (non-empty string values)
+    3. Auto-detect from available API keys in environment / APIKeyConfig
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from reflexio.models.config_schema import APIKeyConfig
+
+# Env var opting into the Claude Code CLI provider (registered in
+# reflexio.server.llm.providers.claude_code_provider). When set to "1"
+# *and* the active host CLI is available, the provider is auto-detected
+# with highest priority — reflexio will route extraction/evaluation
+# calls through the local CLI instead of requiring an API key.
+_CLAUDE_CODE_ENABLE_ENV = "CLAUDE_SMART_USE_LOCAL_CLI"
+_CLAUDE_CODE_PROVIDER = "claude-code"
+
+# Companion provider key for the local ONNX embedder (registered in
+# reflexio.server.llm.providers.local_embedding_provider). Surfaces in
+# ``providers`` only when ``CLAUDE_SMART_USE_LOCAL_EMBEDDING=1`` is set
+# (claude-smart's explicit opt-in); otherwise the embedding role still
+# silently falls back to "local" when chromadb is importable but no
+# cloud embedder is configured — see Path 3 in ``_auto_detect_model``.
+_LOCAL_EMBEDDING_PROVIDER = "local"
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Provider detection
+# ---------------------------------------------------------------------------
+
+_ENV_TO_PROVIDER: dict[str, str] = {
+    "OPENAI_API_KEY": "openai",
+    "ANTHROPIC_API_KEY": "anthropic",
+    "GEMINI_API_KEY": "gemini",
+    "DEEPSEEK_API_KEY": "deepseek",
+    "OPENROUTER_API_KEY": "openrouter",
+    "MINIMAX_API_KEY": "minimax",
+    "DASHSCOPE_API_KEY": "dashscope",
+    "XAI_API_KEY": "xai",
+    "MOONSHOT_API_KEY": "moonshot",
+    "ZAI_API_KEY": "zai",
+}
+
+# When multiple keys are set, prefer providers in this order. The
+# claude-code CLI provider sits at the top — when it's available, users
+# are explicitly opting into local-auth extraction and should not be
+# surprised by an OpenAI/Anthropic API bill from a leftover env var.
+_PROVIDER_PRIORITY: list[str] = [
+    _CLAUDE_CODE_PROVIDER,
+    _LOCAL_EMBEDDING_PROVIDER,
+    "anthropic",
+    "gemini",
+    "openrouter",
+    "deepseek",
+    "minimax",
+    "dashscope",
+    "xai",
+    "moonshot",
+    "zai",
+    "openai",
+]
+
+# Maps APIKeyConfig field names to provider keys (field name == provider key
+# for all current providers, but kept explicit for clarity).
+_API_KEY_CONFIG_FIELDS: dict[str, str] = {
+    "openai": "openai",
+    "anthropic": "anthropic",
+    "gemini": "gemini",
+    "deepseek": "deepseek",
+    "openrouter": "openrouter",
+    "minimax": "minimax",
+    "dashscope": "dashscope",
+    "xai": "xai",
+    "moonshot": "moonshot",
+    "zai": "zai",
+}
+
+
+def detect_available_providers(
+    api_key_config: APIKeyConfig | None = None,
+) -> list[str]:
+    """Detect available LLM providers from APIKeyConfig and/or environment variables.
+
+    Args:
+        api_key_config: Optional org-level API key configuration. Fields set here
+            take precedence over environment variables.
+
+    Returns:
+        list[str]: Available provider keys in priority order.
+    """
+    available: set[str] = set()
+
+    # Check APIKeyConfig fields
+    if api_key_config:
+        for field, provider in _API_KEY_CONFIG_FIELDS.items():
+            if getattr(api_key_config, field, None) is not None:
+                available.add(provider)
+
+    # Check environment variables
+    for env_var, provider in _ENV_TO_PROVIDER.items():
+        if os.environ.get(env_var):
+            available.add(provider)
+
+    # Claude Code CLI and the local ONNX embedder are opt-in via their
+    # own env vars + runtime requirements (`claude` on PATH for the CLI,
+    # `chromadb` installed for the embedder). Their availability helpers
+    # own the detection logic so there's one source of truth.
+    from reflexio.server.llm.providers.claude_code_provider import (
+        is_claude_code_available,
+    )
+    from reflexio.server.llm.providers.local_embedding_provider import (
+        is_local_embedder_available,
+    )
+
+    if is_claude_code_available():
+        available.add(_CLAUDE_CODE_PROVIDER)
+    if is_local_embedder_available():
+        available.add(_LOCAL_EMBEDDING_PROVIDER)
+
+    return [p for p in _PROVIDER_PRIORITY if p in available]
+
+
+# ---------------------------------------------------------------------------
+# Per-provider default models
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class ProviderDefaults:
+    """Default model names for a given provider.
+
+    Any field may be ``None`` for a role the provider does not support.
+    For example, the ``local`` ONNX embedder has no generation model;
+    the ``claude-code`` CLI has no embedding endpoint. ``_auto_detect_model``
+    falls through to the next provider in priority order when the
+    requested role is missing.
+
+    Args:
+        generation: Model for content generation, or None.
+        evaluation: Model for evaluation/scoring, or None.
+        should_run: Model for lightweight "should run extraction" checks, or None.
+        pre_retrieval: Model for pre-retrieval query reformulation, or None.
+        embedding: Model for embedding generation, or None.
+        extraction_agent: Sonnet-tier model for the resumable extraction loop, or None.
+    """
+
+    generation: str | None
+    evaluation: str | None
+    should_run: str | None
+    pre_retrieval: str | None
+    embedding: str | None
+    extraction_agent: str | None = None
+
+
+_PROVIDER_DEFAULTS: dict[str, ProviderDefaults] = {
+    # claude-code routes through the local Claude Code CLI via LiteLLM's
+    # custom provider mechanism (see providers/claude_code_provider.py).
+    # The model-name suffix after "claude-code/" is opaque — the CLI
+    # picks whichever model the user has auth for.
+    _CLAUDE_CODE_PROVIDER: ProviderDefaults(
+        generation="claude-code/default",
+        evaluation="claude-code/default",
+        should_run="claude-code/default",
+        pre_retrieval="claude-code/default",
+        embedding=None,
+        extraction_agent="claude-code/default",
+    ),
+    # local is an embedding-only provider that routes through an
+    # in-process ONNX model (chromadb's all-MiniLM-L6-v2). Generation
+    # roles stay None — use claude-code for those.
+    _LOCAL_EMBEDDING_PROVIDER: ProviderDefaults(
+        generation=None,
+        evaluation=None,
+        should_run=None,
+        pre_retrieval=None,
+        embedding="local/minilm-l6-v2",
+    ),
+    "openai": ProviderDefaults(
+        generation="gpt-5-mini",
+        evaluation="gpt-5-mini",
+        should_run="gpt-5-nano",
+        pre_retrieval="gpt-5-nano",
+        embedding="text-embedding-3-small",
+        extraction_agent="gpt-5-mini",
+    ),
+    "anthropic": ProviderDefaults(
+        generation="claude-sonnet-4-6",
+        evaluation="claude-sonnet-4-6",
+        should_run="claude-haiku-4-5-20251001",
+        pre_retrieval="claude-haiku-4-5-20251001",
+        embedding=None,
+        extraction_agent="claude-sonnet-4-6",
+    ),
+    "gemini": ProviderDefaults(
+        generation="gemini/gemini-3-flash-preview",
+        evaluation="gemini/gemini-3-flash-preview",
+        should_run="gemini/gemini-3-flash-preview",
+        pre_retrieval="gemini/gemini-3-flash-preview",
+        embedding="gemini/gemini-embedding-001",
+    ),
+    "deepseek": ProviderDefaults(
+        generation="deepseek/deepseek-chat",
+        evaluation="deepseek/deepseek-chat",
+        should_run="deepseek/deepseek-chat",
+        pre_retrieval="deepseek/deepseek-chat",
+        embedding=None,
+    ),
+    "openrouter": ProviderDefaults(
+        generation="openrouter/google/gemini-3-flash-preview",
+        evaluation="openrouter/google/gemini-3-flash-preview",
+        should_run="openrouter/google/gemini-3-flash-preview",
+        pre_retrieval="openrouter/google/gemini-3-flash-preview",
+        embedding=None,
+    ),
+    "minimax": ProviderDefaults(
+        generation="minimax/MiniMax-M3",
+        evaluation="minimax/MiniMax-M3",
+        should_run="minimax/MiniMax-M3",
+        pre_retrieval="minimax/MiniMax-M3",
+        embedding=None,
+        # Same M2.7 model handles resumable extraction. Surfaced by an
+        # e2e run on a MiniMax-only VPS where publish printed
+        # "No provider in ['minimax'] supports role=extraction_agent"
+        # warnings and silently skipped profile creation. Without this,
+        # MiniMax-only users can publish but get zero profiles.
+        extraction_agent="minimax/MiniMax-M3",
+    ),
+    "dashscope": ProviderDefaults(
+        generation="dashscope/qwen-plus",
+        evaluation="dashscope/qwen-plus",
+        should_run="dashscope/qwen-turbo",
+        pre_retrieval="dashscope/qwen-turbo",
+        embedding=None,
+    ),
+    "xai": ProviderDefaults(
+        generation="xai/grok-3-mini",
+        evaluation="xai/grok-3-mini",
+        should_run="xai/grok-3-mini",
+        pre_retrieval="xai/grok-3-mini",
+        embedding=None,
+    ),
+    "moonshot": ProviderDefaults(
+        generation="moonshot/moonshot-v1-8k",
+        evaluation="moonshot/moonshot-v1-8k",
+        should_run="moonshot/moonshot-v1-8k",
+        pre_retrieval="moonshot/moonshot-v1-8k",
+        embedding=None,
+    ),
+    "zai": ProviderDefaults(
+        generation="zai/glm-5.1",
+        evaluation="zai/glm-5.1",
+        should_run="zai/glm-5.1",
+        pre_retrieval="zai/glm-5.1",
+        embedding=None,
+    ),
+}
+
+
+EMBEDDING_CAPABLE_PROVIDERS: frozenset[str] = frozenset(
+    p for p, d in _PROVIDER_DEFAULTS.items() if d.embedding is not None
+)
+
+
+GENERATION_CAPABLE_PROVIDERS: frozenset[str] = frozenset(
+    p for p, d in _PROVIDER_DEFAULTS.items() if d.generation is not None
+)
+
+
+def _local_cli_provider_hint() -> str:
+    return (
+        f"or set {_CLAUDE_CODE_ENABLE_ENV}=1 with the active host CLI "
+        "(claude for Claude Code, codex for Codex) available."
+    )
+
+
+# ---------------------------------------------------------------------------
+# Model role enum and resolution
+# ---------------------------------------------------------------------------
+
+
+class ModelRole(StrEnum):
+    """Roles that require an LLM model name."""
+
+    GENERATION = "generation"
+    EVALUATION = "evaluation"
+    SHOULD_RUN = "should_run"
+    PRE_RETRIEVAL = "pre_retrieval"
+    EMBEDDING = "embedding"
+    # Sonnet-tier agent that drives the resumable extraction tool loop.
+    EXTRACTION_AGENT = "extraction_agent"
+
+
+def _auto_detect_model(
+    role: ModelRole,
+    providers: list[str],
+) -> str:
+    """Pick the default model for *role* from the first available provider.
+
+    For the EMBEDDING role, if the primary provider has no embedding support,
+    search the remaining providers for one that does.
+
+    Args:
+        role: The model role to resolve.
+        providers: Available providers in priority order.
+
+    Returns:
+        str: The resolved model name.
+
+    Raises:
+        RuntimeError: If no suitable provider is found.
+    """
+    if not providers:
+        raise RuntimeError(
+            "No LLM provider available. Set at least one of: "
+            + ", ".join(sorted(_ENV_TO_PROVIDER))
+            + f" in your .env file, {_local_cli_provider_hint()}"
+        )
+
+    if role == ModelRole.EMBEDDING:
+        # Path 1+2: explicit claude-smart opt-in or a cloud embedder. The
+        # priority list places `local` at position 2, so when the env var is
+        # set ``providers`` already contains "local" and this loop returns it
+        # before any cloud provider. When the env var is unset, only cloud
+        # providers can hit here (local is filtered out by
+        # ``is_local_embedder_available``).
+        for provider in providers:
+            defaults = _PROVIDER_DEFAULTS[provider]
+            if defaults.embedding:
+                return defaults.embedding
+        # Path 3: no embedding-capable provider in `providers`, but chromadb
+        # is importable — silently fall back to the local ONNX embedder so
+        # users with only a non-embedding LLM key (Anthropic, MiniMax, etc.)
+        # are not blocked at startup.
+        from reflexio.server.llm.providers.local_embedding_provider import (
+            is_chromadb_importable,
+        )
+
+        if is_chromadb_importable():
+            return _PROVIDER_DEFAULTS[_LOCAL_EMBEDDING_PROVIDER].embedding  # type: ignore[return-value]
+        raise RuntimeError(
+            "No embedding-capable provider configured and chromadb is not "
+            "importable. Set OPENAI_API_KEY or GEMINI_API_KEY, or "
+            "`pip install chromadb`."
+        )
+
+    # Non-embedding roles: fall through to the first provider whose slot
+    # for this role is non-None. Lets embedding-only providers (e.g.
+    # "local") sit in the priority list without breaking generation.
+    for provider in providers:
+        defaults = _PROVIDER_DEFAULTS[provider]
+        model_name = getattr(defaults, role.value)
+        if model_name:
+            return model_name
+    raise RuntimeError(f"No provider in {providers} supports role={role.value}.")
+
+
+def resolve_model_name(
+    role: ModelRole,
+    *,
+    site_var_value: str | None = None,
+    config_override: str | None = None,
+    api_key_config: APIKeyConfig | None = None,
+) -> str:
+    """Resolve a model name using the 3-tier chain.
+
+    Resolution order (highest priority first):
+        1. config_override (from LLMConfig, org-level)
+        2. site_var_value (from llm_model_setting.json, non-empty strings only)
+        3. Auto-detect from available API keys
+
+    Args:
+        role: The model role to resolve.
+        site_var_value: Value from llm_model_setting.json. Empty strings are treated as unset.
+        config_override: Value from org-level LLMConfig.
+        api_key_config: Optional org-level API key configuration for provider detection.
+
+    Returns:
+        str: The resolved model name.
+
+    Raises:
+        RuntimeError: If no API keys are available and no override is set.
+    """
+    if config_override:
+        return config_override
+    if site_var_value:
+        return site_var_value
+    providers = detect_available_providers(api_key_config)
+    return _auto_detect_model(role, providers)
+
+
+def validate_llm_availability(
+    api_key_config: APIKeyConfig | None = None,
+) -> None:
+    """Validate that at least one LLM provider and one embedding provider are available.
+
+    Should be called once during startup. Logs the auto-selected provider at INFO level.
+
+    Args:
+        api_key_config: Optional org-level API key configuration.
+
+    Raises:
+        RuntimeError: If no API keys are found, or if no embedding-capable provider is available.
+    """
+    providers = detect_available_providers(api_key_config)
+    if not providers:
+        raise RuntimeError(
+            "No LLM provider available. Set at least one of: "
+            + ", ".join(sorted(_ENV_TO_PROVIDER))
+            + f" in your .env file, {_local_cli_provider_hint()}"
+        )
+
+    logger.info("Auto-detected LLM providers (priority order): %s", providers)
+    generation_provider = next(
+        (p for p in providers if _PROVIDER_DEFAULTS[p].generation), None
+    )
+    if generation_provider is None:
+        # Configurations that surface only embedding-capable providers
+        # (e.g. ``providers == ["local"]`` from chromadb being importable
+        # but no LLM key set) leave every generation-role lookup
+        # unresolvable. Failing here means the next reflexio call would
+        # raise "No provider supports role=generation" deep inside the
+        # extraction pipeline; we'd rather raise at startup with the
+        # same actionable message users hit when no providers are
+        # detected at all.
+        raise RuntimeError(
+            "No generation-capable LLM provider available. Set at least "
+            "one of: "
+            + ", ".join(sorted(_ENV_TO_PROVIDER))
+            + f" in your .env file, {_local_cli_provider_hint()}"
+        )
+    logger.info("Primary provider for generation: %s", generation_provider)
+
+    # Validate embedding availability. When no embedding-capable provider
+    # is configured, fall back to the in-process local ONNX embedder if
+    # chromadb is importable — this keeps users with only a non-embedding
+    # LLM key (Anthropic, MiniMax, etc.) from being blocked at startup.
+    embedding_provider = next(
+        (p for p in providers if _PROVIDER_DEFAULTS[p].embedding), None
+    )
+    if embedding_provider:
+        logger.info("Embedding provider: %s", embedding_provider)
+        return
+
+    from reflexio.server.llm.providers.local_embedding_provider import (
+        is_chromadb_importable,
+    )
+
+    if is_chromadb_importable():
+        logger.info(
+            "Embedding provider: %s (fallback — no cloud embedder configured)",
+            _LOCAL_EMBEDDING_PROVIDER,
+        )
+        return
+    raise RuntimeError(
+        "No embedding-capable provider configured and chromadb is not "
+        "importable. Set OPENAI_API_KEY or GEMINI_API_KEY, or "
+        "`pip install chromadb`."
+    )

package/plugin/vendor/reflexio/reflexio/server/llm/providers/__init__.py

@@ -0,0 +1 @@
+"""Custom LiteLLM providers registered by reflexio."""