code-analysis-client 1.6.189__tar.gz → 1.6.191__tar.gz

{code_analysis_client-1.6.189 → code_analysis_client-1.6.191}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-analysis-client
-Version: 1.6.189
+Version: 1.6.191
 Summary: Async JSON-RPC client for the code-analysis MCP server (mcp-proxy-adapter JsonRpcClient)
 Author-email: Vasiliy Zdanovskiy <vasilyvz@gmail.com>
 Requires-Python: >=3.10

{code_analysis_client-1.6.189 → code_analysis_client-1.6.191}/code_analysis_client/__init__.py

@@ -22,6 +22,7 @@ from code_analysis_client.exceptions import (
     JobFailedError,
     JobTimeoutError,
     QueueJobError,
+    VectorizerUnavailableError,
 )
 from code_analysis_client.file_session import FileSessionClient, SessionNotFoundError
 from code_analysis_client.check_chain import (
@@ -63,6 +64,16 @@ from code_analysis_client.validation import (
     prepare_params_for_schema,
     validate_params_against_schema,
 )
+from code_analysis_client.vectorizer_state import (
+    ServiceState,
+    VectorizerState,
+    VectorizerWarning,
+    VectorizationWorkerBlock,
+    extract_vectorizer_state_from_response,
+    safe_get_vectorizer_state,
+    safe_get_warnings,
+    safe_get_vectorization_worker,
+)
 
 __all__ = [
     "CLIENT_FACADE_COMMANDS",
@@ -84,6 +95,11 @@ __all__ = [
     "UNIVERSAL_FILE_COMMANDS",
     "UniversalFileClient",
     "ValidatedCommandsProxy",
+    "VectorizerUnavailableError",
+    "ServiceState",
+    "VectorizerState",
+    "VectorizerWarning",
+    "VectorizationWorkerBlock",
     "CheckChainClient",
     "CheckChainConfigInvalidError",
     "CheckChainError",
@@ -99,11 +115,15 @@ __all__ = [
     "adapter_settings_from_server_config",
     "adapter_settings_to_jsonrpc_kwargs",
     "extract_job_id",
+    "extract_vectorizer_state_from_response",
     "fetch_command_schema_from_server",
     "is_queued_envelope",
     "load_server_config",
     "parse_schema_from_help_payload",
     "prepare_params_for_schema",
+    "safe_get_vectorizer_state",
+    "safe_get_warnings",
+    "safe_get_vectorization_worker",
     "unwrap_job_result",
     "validate_params_against_schema",
     "wait_for_job",

{code_analysis_client-1.6.189 → code_analysis_client-1.6.191}/code_analysis_client/exceptions.py

@@ -108,3 +108,59 @@ class CommandFailedError(QueueJobError):
         )
         self.command = command
         self.error = error
+
+
+class VectorizerUnavailableError(RuntimeError):
+    """The vectorizer (embedding or chunker service) is not available.
+
+    Raised by vectorizer-dependent commands (semantic_search, revectorize,
+    rebuild_faiss) when the embedding or chunker service is known unavailable.
+    The pre-V1 contract EMBEDDING_SERVICE_ERROR is reserved for a failure of
+    the call itself, not for unavailability of a known-down service.
+    """
+
+    code = "VECTORIZER_UNAVAILABLE"
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        service: Optional[str] = None,
+        services: Optional[list[str]] = None,
+        reason: Optional[str] = None,
+        since: Optional[str] = None,
+        last_probe_at: Optional[str] = None,
+        retry_after_seconds: Optional[int] = None,
+        details: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Initialize with message and vectorizer availability details.
+
+        Args:
+            message: Human-readable error message
+            service: The first unavailable required service (embedding or chunker)
+            services: List of all unavailable required services
+            reason: Reason for unavailability (e.g., timeout, connection_refused)
+            since: ISO-8601 UTC timestamp of when the service became unavailable
+            last_probe_at: ISO-8601 UTC timestamp of the last probe attempt
+            retry_after_seconds: Suggested wait time before retrying
+            details: Additional details dict (overrides individual fields if provided)
+        """
+        super().__init__(message)
+        if details is None:
+            details = {}
+        self.service = service or details.get("service")
+        self.services = services or details.get("services", [])
+        self.reason = reason or details.get("reason")
+        self.since = since or details.get("since")
+        self.last_probe_at = last_probe_at or details.get("last_probe_at")
+        self.retry_after_seconds = retry_after_seconds or details.get(
+            "retry_after_seconds"
+        )
+        self.details = {
+            "service": self.service,
+            "services": self.services,
+            "reason": self.reason,
+            "since": self.since,
+            "last_probe_at": self.last_probe_at,
+            "retry_after_seconds": self.retry_after_seconds,
+        }

{code_analysis_client-1.6.189 → code_analysis_client-1.6.191}/code_analysis_client/responses.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import Any, Dict
 
-from code_analysis_client.exceptions import ClientValidationError
+from code_analysis_client.exceptions import ClientValidationError, VectorizerUnavailableError
 
 
 def command_error_code(data: Dict[str, Any]) -> str:
@@ -24,6 +24,23 @@ def command_error_code(data: Dict[str, Any]) -> str:
     return ""
 
 
+def vectorizer_error_details(data: Dict[str, Any]) -> Dict[str, Any]:
+    """Return the ``details`` object of a failed command response.
+
+    The server (mcp-proxy-adapter ``ErrorResult``) puts the details at ``error.data``; a flat
+    envelope may carry ``details`` at the top level or ``error.details``. All three are read, in
+    the order ``error.data``, ``error.details``, top-level ``details``.
+    """
+    err = data.get("error")
+    if isinstance(err, dict):
+        for key in ("data", "details"):
+            nested = err.get(key)
+            if isinstance(nested, dict):
+                return nested
+    top = data.get("details")
+    return top if isinstance(top, dict) else {}
+
+
 def unwrap_command_result(
     data: Dict[str, Any],
     *,
@@ -42,4 +59,16 @@ def unwrap_command_result(
         message = str(data)
     if code == "SESSION_NOT_FOUND" and session_not_found_type is not None:
         raise session_not_found_type(message, field="session_id", details=data)
+    if code == "VECTORIZER_UNAVAILABLE":
+        details = vectorizer_error_details(data)
+        raise VectorizerUnavailableError(
+            message,
+            service=details.get("service"),
+            services=details.get("services", []),
+            reason=details.get("reason"),
+            since=details.get("since"),
+            last_probe_at=details.get("last_probe_at"),
+            retry_after_seconds=details.get("retry_after_seconds"),
+            details=details,
+        )
     raise ClientValidationError(message, field="command", details=data)

code_analysis_client-1.6.191/code_analysis_client/vectorizer_state.py

@@ -0,0 +1,159 @@
+"""Typed models for vectorizer availability state from health and get_worker_status.
+
+The vectorizer_availability section of pipeline/matrix.yaml defines the contract.
+Clients must tolerate absence of these fields (deployed 1.6.190 server does not emit
+them yet) without raising.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, TypedDict
+
+
+class ServiceState(TypedDict, total=False):
+    """State of one vectorizer service (embedding or chunker).
+
+    All fields are optional to tolerate absence in pre-V1 deployments.
+    """
+
+    state: str  # "available", "unavailable", or "unknown"
+    since: str  # ISO-8601 UTC timestamp
+    last_probe_at: Optional[str]  # ISO-8601 UTC timestamp or null
+    last_ok_at: Optional[str]  # ISO-8601 UTC timestamp or null
+    reason: Optional[str]  # One of reason_enum or null
+    consecutive_failures: int
+
+
+class VectorizerState(TypedDict, total=False):
+    """Shared vectorizer availability state read by health and get_worker_status.
+
+    All fields are optional to tolerate absence in pre-V1 deployments.
+    Fields are presented as TypedDict with total=False; callers use .get()
+    to safely access optional fields.
+    """
+
+    state: str  # "available", "unavailable", or "unknown"
+    paused: bool  # True when state == unavailable
+    paused_reason: Optional[str]  # Reason from the earliest-failing unavailable service
+    paused_since: Optional[str]  # ISO-8601 UTC, from the earliest-failing service
+    services: Dict[str, ServiceState]  # {embedding: ..., chunker: ...}
+    probe_interval_seconds: int
+    probe_timeout_seconds: int
+    staleness_bound_seconds: int
+
+
+class VectorizerWarning(TypedDict, total=False):
+    """A warning from health.data.warnings or get_worker_status.data.warnings.
+
+    Only populated for VECTORIZER_UNAVAILABLE warnings.
+    All fields are optional to tolerate absence.
+    """
+
+    code: str  # "VECTORIZER_UNAVAILABLE"
+    service: str  # "embedding" or "chunker"
+    since: str  # ISO-8601 UTC timestamp
+    reason: Optional[str]  # Reason enum value
+    message: str  # Human-readable text
+
+
+class VectorizationWorkerBlock(TypedDict, total=False):
+    """The vectorization worker block from get_worker_status.
+
+    Present when worker_type in {vectorization, all} or omitted (defaults to all).
+    All fields are optional to tolerate absence in pre-V1 deployments.
+    """
+
+    paused: bool  # True when vectorizer state == unavailable
+    paused_reason: Optional[str]  # Reason from the unavailable service
+    paused_since: Optional[str]  # ISO-8601 UTC
+    last_heartbeat_at: str  # ISO-8601 UTC
+    heartbeat_age_seconds: float  # Age of the last heartbeat
+    rpc_in_flight: Optional[Dict[str, Any]]  # {service, started_at, elapsed_seconds}
+    dead_letter: Dict[str, Any]  # {total, by_reason}
+
+
+def safe_get_vectorizer_state(data: Any) -> Optional[VectorizerState]:
+    """Extract vectorizer state from a response dict, tolerating absence.
+
+    Supports both response formats:
+    - health: data.components.vectorizer
+    - get_worker_status: data.vectorizer
+
+    Args:
+        data: Response dict (e.g., from health or get_worker_status)
+
+    Returns:
+        VectorizerState dict if present, None if absent
+    """
+    if not isinstance(data, dict):
+        return None
+
+    # Try direct path first (get_worker_status)
+    vectorizer = data.get("vectorizer")
+    if isinstance(vectorizer, dict):
+        return vectorizer  # type: ignore
+
+    # Try components path (health)
+    components = data.get("components")
+    if isinstance(components, dict):
+        vectorizer = components.get("vectorizer")
+        if isinstance(vectorizer, dict):
+            return vectorizer  # type: ignore
+
+    return None
+
+
+def safe_get_warnings(data: Any) -> List[VectorizerWarning]:
+    """Extract warnings list from a response dict, tolerating absence.
+
+    Args:
+        data: Response dict (e.g., from health or get_worker_status)
+
+    Returns:
+        List of VectorizerWarning dicts, empty list if absent
+    """
+    if not isinstance(data, dict):
+        return []
+    warnings = data.get("warnings")
+    if not isinstance(warnings, list):
+        return []
+    return warnings  # type: ignore
+
+
+def safe_get_vectorization_worker(data: Any) -> Optional[VectorizationWorkerBlock]:
+    """Extract vectorization worker block from response data, tolerating absence.
+
+    Args:
+        data: Worker status data dict (e.g., from get_worker_status)
+
+    Returns:
+        VectorizationWorkerBlock dict if present, None if absent
+    """
+    if not isinstance(data, dict):
+        return None
+    # The worker block is in the response at the same level as other worker types
+    # when worker_type is vectorization or all (or omitted which defaults to all)
+    worker = data.get("vectorization")
+    if not isinstance(worker, dict):
+        return None
+    return worker  # type: ignore
+
+
+def extract_vectorizer_state_from_response(response: Dict[str, Any]) -> Optional[VectorizerState]:
+    """Extract vectorizer state from any response that may contain it.
+
+    Checks both data.components.vectorizer (health/get_worker_status) paths.
+
+    Args:
+        response: Response dict from a command
+
+    Returns:
+        VectorizerState dict if found, None otherwise
+    """
+    if not isinstance(response, dict):
+        return None
+    data = response.get("data")
+    return safe_get_vectorizer_state(data)

code_analysis_client-1.6.191/code_analysis_client/version.txt

@@ -0,0 +1 @@
+1.6.191

{code_analysis_client-1.6.189 → code_analysis_client-1.6.191}/code_analysis_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-analysis-client
-Version: 1.6.189
+Version: 1.6.191
 Summary: Async JSON-RPC client for the code-analysis MCP server (mcp-proxy-adapter JsonRpcClient)
 Author-email: Vasiliy Zdanovskiy <vasilyvz@gmail.com>
 Requires-Python: >=3.10

{code_analysis_client-1.6.189 → code_analysis_client-1.6.191}/code_analysis_client.egg-info/SOURCES.txt

@@ -15,6 +15,7 @@ code_analysis_client/server_api.py
 code_analysis_client/server_schema.py
 code_analysis_client/universal_file.py
 code_analysis_client/validation.py
+code_analysis_client/vectorizer_state.py
 code_analysis_client/version.txt
 code_analysis_client/worktree.py
 code_analysis_client.egg-info/PKG-INFO

code_analysis_client-1.6.189/code_analysis_client/version.txt

@@ -1 +0,0 @@
-1.6.189