code-analysis-client 1.6.148__tar.gz → 1.6.150__tar.gz

{code_analysis_client-1.6.148 → code_analysis_client-1.6.150}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-analysis-client
-Version: 1.6.148
+Version: 1.6.150
 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.148 → code_analysis_client-1.6.150}/code_analysis_client/queue_wait.py

@@ -156,7 +156,7 @@ async def wait_for_job(
         await asyncio.sleep(poll_interval)
 
 
-_JOB_FAILED_REFETCH_ATTEMPTS = 4
+_JOB_FAILED_REFETCH_ATTEMPTS = 8
 _JOB_FAILED_REFETCH_SLEEP_SECONDS = 0.5
 
 
@@ -179,7 +179,83 @@ def _extract_inner_command_error(status_data: Dict[str, Any]) -> Any:
     return None
 
 
-async def _refetch_inner_command_error(rpc: Any, job_id: str) -> Any:
+async def _refetch_job_status_with_payload(
+    rpc: Any, job_id: str, original_data: Optional[Dict[str, Any]] = None
+) -> Optional[Dict[str, Any]]:
+    """Re-poll ``queue_get_job_status`` hunting for changes in status or result payload.
+
+    Write-order gotcha: the queue store writes the job's terminal ``status``
+    slightly BEFORE it writes the ``result`` payload (or in some cases, the
+    status may transition from one state to another). A caller that reads the
+    status at the instant it turns terminal can therefore observe one of:
+      * A status change that hasn't been re-read yet (e.g. completed->failed)
+      * A terminal status with no ``result`` payload yet, even though the
+        command DID record a structured error - it just hasn't landed.
+
+    This helper re-fetches the job status multiple times, returning the FIRST
+    snapshot where EITHER:
+      * The status has CHANGED relative to the original snapshot
+      * A ``result`` payload has APPEARED or CHANGED (was missing/empty, now populated)
+      * An inner structured error has APPEARED or CHANGED (nested error found)
+      * A top-level error field has APPEARED or CHANGED (not in original or different value)
+
+    If ``original_data`` is provided, each new snapshot is compared against it.
+    Snapshots that are identical to the original (same status, same error, same result)
+    do NOT trigger early exit — the loop continues through all refetch attempts to
+    hunt for the structured error that may be delayed by the write-order race.
+
+    Returns ``None`` when all attempts are exhausted without detecting any change.
+    """
+    original_status = None
+    original_error = None
+    original_result = None
+    if original_data is not None:
+        original_status = str(original_data.get("status", "")).strip().lower()
+        original_error = original_data.get("error")
+        original_result = original_data.get("result")
+
+    for _ in range(_JOB_FAILED_REFETCH_ATTEMPTS):
+        await asyncio.sleep(_JOB_FAILED_REFETCH_SLEEP_SECONDS)
+        resp = await rpc.execute_command("queue_get_job_status", {"job_id": job_id})
+        data = resp.get("data") if isinstance(resp, dict) else None
+        if not isinstance(data, dict):
+            data = resp if isinstance(resp, dict) else {}
+
+        # Detect any of the state changes we were hunting for:
+        # Compare against original snapshot if provided.
+
+        # - Status changed
+        status = str(data.get("status", "")).strip().lower()
+        if original_status is not None and status != original_status:
+            if status in _FAILED_JOB_STATUSES:
+                return data
+        # When no original is provided, accept any failed status change
+        elif original_status is None and status in _FAILED_JOB_STATUSES:
+            return data
+
+        # - Result payload appeared or changed
+        current_result = data.get("result")
+        if original_result != current_result:
+            if isinstance(current_result, dict) and current_result:
+                return data
+
+        # - Inner error appeared or changed (nested structured error)
+        current_inner_error = _extract_inner_command_error(data)
+        original_inner_error = (
+            _extract_inner_command_error(original_data) if original_data else None
+        )
+        if current_inner_error != original_inner_error and current_inner_error is not None:
+            return data
+
+        # - Top-level error appeared or changed
+        current_error = data.get("error")
+        if current_error != original_error and current_error is not None:
+            return data
+
+    return None
+
+
+async def _refetch_inner_command_error(rpc: Any, job_id: str, original_data: Optional[Dict[str, Any]] = None) -> Any:
     """Re-poll ``queue_get_job_status`` hunting for the inner structured error.
 
     Write-order gotcha: the queue store writes the job's terminal ``status``
@@ -190,15 +266,9 @@ async def _refetch_inner_command_error(rpc: Any, job_id: str) -> Any:
     the store. Re-fetching a few times with a short sleep gives that second
     write time to land instead of silently downgrading to ``None``.
     """
-    for _ in range(_JOB_FAILED_REFETCH_ATTEMPTS):
-        await asyncio.sleep(_JOB_FAILED_REFETCH_SLEEP_SECONDS)
-        resp = await rpc.execute_command("queue_get_job_status", {"job_id": job_id})
-        data = resp.get("data") if isinstance(resp, dict) else None
-        if not isinstance(data, dict):
-            data = resp if isinstance(resp, dict) else {}
-        inner_error = _extract_inner_command_error(data)
-        if inner_error is not None:
-            return inner_error
+    data = await _refetch_job_status_with_payload(rpc, job_id, original_data=original_data)
+    if data is not None:
+        return _extract_inner_command_error(data)
     return None
 
 
@@ -219,8 +289,8 @@ async def unwrap_job_result(
     bare queue-level ``error`` field. When that nested error is not yet
     present in ``status_data`` and ``rpc`` was supplied, it re-fetches the job
     status up to :data:`_JOB_FAILED_REFETCH_ATTEMPTS` times (see
-    :func:`_refetch_inner_command_error` for the write-order race this rides
-    out). The queue-level ``error`` field is used as a fallback when no
+    :func:`_refetch_job_status_with_payload` for the write-order race this
+    rides out). The queue-level ``error`` field is used as a fallback when no
     structured inner error is ever found; ``JobFailedError.error`` is ``None``
     only when genuinely nothing was found either way.
     """
@@ -231,7 +301,7 @@ async def unwrap_job_result(
     if status in _FAILED_JOB_STATUSES or error:
         inner_error = _extract_inner_command_error(status_data)
         if inner_error is None and rpc is not None and job_id:
-            inner_error = await _refetch_inner_command_error(rpc, str(job_id))
+            inner_error = await _refetch_inner_command_error(rpc, str(job_id), original_data=status_data)
         raise JobFailedError(
             job_id, inner_error if inner_error is not None else error, status=status
         )
@@ -242,6 +312,24 @@ async def unwrap_job_result(
     else:
         inner = result_field
 
+    # Handle the write-order race on the completed-status path: when
+    # status="completed" is observed but result is missing or empty {},
+    # the status might later transition to "failed" with the structured error.
+    # Refetch up to the configured attempt limit, checking for either:
+    # - Status transitioned to failed/stopped/cancelled
+    # - Result payload appeared or became populated
+    # If we detect any state change, process accordingly (raise if failed,
+    # return if populated). If stable empty result after all attempts, continue.
+    if status == "completed":
+        result_looks_empty = not result_field or (
+            isinstance(result_field, dict) and not result_field
+        )
+        if result_looks_empty and rpc is not None and job_id:
+            refetch_data = await _refetch_job_status_with_payload(rpc, str(job_id), original_data=status_data)
+            if refetch_data is not None:
+                # Status or payload changed; re-process this new snapshot recursively.
+                return await unwrap_job_result(refetch_data, rpc=rpc)
+
     inner_looks_failed = isinstance(inner, dict) and inner.get("success") is False
     command_success_false = status_data.get("command_success") is False
     completed_with_error = bool(status_data.get("completed_with_error")) or bool(

code_analysis_client-1.6.150/code_analysis_client/version.txt

@@ -0,0 +1 @@
+1.6.150

{code_analysis_client-1.6.148 → code_analysis_client-1.6.150}/code_analysis_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-analysis-client
-Version: 1.6.148
+Version: 1.6.150
 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.148/code_analysis_client/version.txt

@@ -1 +0,0 @@
-1.6.148