sovara 0.2.6__tar.gz → 0.2.7__tar.gz

{sovara-0.2.6 → sovara-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sovara
-Version: 0.2.6
+Version: 0.2.7
 Summary: A development tool for LLM call visualization and debugging
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{sovara-0.2.6 → sovara-0.2.7}/pyproject.toml

@@ -26,7 +26,7 @@ line-length = 100
 
 [project]
 name = "sovara"
-version = "0.2.6"
+version = "0.2.7"
 description = "A development tool for LLM call visualization and debugging"
 readme = "docs/release/PYPI_DESC.md"
 requires-python = ">=3.10"

{sovara-0.2.6 → sovara-0.2.7}/src/sovara/runner/agent_runner.py

@@ -245,16 +245,29 @@ def _check_server_health() -> bool:
     """Check if the server is healthy via HTTP."""
     import httpx
 
+    expected_python = os.path.realpath(sys.executable)
     try:
         resp = httpx.get(f"http://{HOST}:{PORT}/health", timeout=SERVER_START_TIMEOUT)
         if resp.status_code != 200:
             return False
         payload = resp.json()
-        return (
+        if not (
             isinstance(payload, dict)
             and payload.get("status") == "ok"
             and payload.get("service") == "sovara"
-        )
+        ):
+            return False
+        server_python = payload.get("python_executable")
+        if not server_python:
+            logger.warning("Sovara server health response is missing python_executable.")
+            return False
+        if os.path.realpath(str(server_python)) != expected_python:
+            logger.warning(
+                "Sovara server is running under a different Python executable "
+                f"({server_python}); expected {sys.executable}."
+            )
+            return False
+        return True
     except Exception:
         return False
 
@@ -265,11 +278,13 @@ def ensure_server_running() -> None:
         logger.debug(f"Server already running on {HOST}:{PORT}")
         return
 
-    # Check for zombie process
-    zombie_pid = _find_process_on_port(PORT)
-    if zombie_pid:
-        logger.warning(f"Found unresponsive server process {zombie_pid}, killing it...")
-        if _kill_zombie_server(zombie_pid):
+    # Check for an unresponsive or incompatible server process.
+    existing_pid = _find_process_on_port(PORT)
+    if existing_pid:
+        logger.warning(
+            f"Found unresponsive or incompatible server process {existing_pid}, killing it..."
+        )
+        if _kill_zombie_server(existing_pid):
             time.sleep(1)
 
     # Launch new daemon
@@ -553,11 +568,7 @@ class AgentRunner:
     def _register_with_server(self) -> None:
         """Register with the server via HTTP POST."""
         logger.info(f"[AgentRunner] Registering with server at {self.server_url}...")
-        prev_run_id = (
-            os.getenv("SOVARA_RUN_ID")
-            if os.getenv(_REUSE_RUN_ID_ENV) == "1"
-            else None
-        )
+        prev_run_id = os.getenv("SOVARA_RUN_ID") if os.getenv(_REUSE_RUN_ID_ENV) == "1" else None
 
         response = http_post(
             "/runner/register",

{sovara-0.2.6 → sovara-0.2.7}/src/sovara/runner/priors.py

@@ -240,7 +240,16 @@ def restore_input_after_call(prior_result: PriorPreparationResult | None) -> Ite
 
 
 def prepare_llm_call_for_priors(
-    input_dict: dict[str, Any], api_type: str
+    input_dict: dict[str, Any],
+    api_type: str,
+    *,
+    lookup_prefix_cache_func: (
+        Callable[[str, list[dict[str, str]]], tuple[dict[str, Any] | None, int]] | None
+    ) = None,
+    store_prefix_cache_func: (
+        Callable[[str | None, list[dict[str, str]], list[dict[str, str]], list[str]], None] | None
+    ) = None,
+    retrieve_priors_func: Callable[[str, str, list[str]], dict[str, Any]] | None = None,
 ) -> PriorPreparationResult:
     run_id = get_run_id()
     complete_json_str = func_kwargs_to_json_str(input_dict, api_type)
@@ -283,9 +292,23 @@ def prepare_llm_call_for_priors(
     matched_prefix_len = 0
     working_flattened = dict(cleaned_flattened)
     if run_id and clean_content_pairs:
-        prefix_entry, matched_prefix_len = _lookup_longest_prefix_cache_hit(
-            run_id, clean_content_pairs
-        )
+        if lookup_prefix_cache_func is not None:
+            try:
+                prefix_entry, matched_prefix_len = lookup_prefix_cache_func(
+                    run_id, clean_content_pairs
+                )
+            except Exception as exc:
+                _log_priors(
+                    "automatic",
+                    "warning",
+                    "[PRIORS RUNTIME] prefix lookup failed",
+                    error=str(exc),
+                )
+                prefix_entry, matched_prefix_len = None, 0
+        else:
+            prefix_entry, matched_prefix_len = _lookup_longest_prefix_cache_hit(
+                run_id, clean_content_pairs
+            )
         if prefix_entry is not None:
             working_flattened = replay_injected_prefix(
                 cleaned_flattened,
@@ -387,14 +410,22 @@ def prepare_llm_call_for_priors(
             run_id=run_id,
             ignore_ids=inherited_prior_ids,
         )
-        response = http_post(
-            "/internal/priors/retrieve",
-            {
-                "run_id": run_id,
-                "raw_context": raw_context,
-                "ignore_prior_ids": inherited_prior_ids,
-            },
-            timeout=_INTERNAL_PRIORS_HTTP_TIMEOUT_S,
+        response = (
+            http_post(
+                "/internal/priors/retrieve",
+                {
+                    "run_id": run_id,
+                    "raw_context": raw_context,
+                    "ignore_prior_ids": inherited_prior_ids,
+                },
+                timeout=_INTERNAL_PRIORS_HTTP_TIMEOUT_S,
+            )
+            if retrieve_priors_func is None
+            else retrieve_priors_func(
+                run_id,
+                raw_context,
+                inherited_prior_ids,
+            )
         )
         metadata.retrieval_latency_ms = int((time.perf_counter() - started_at) * 1000)
         metadata.retrieval_id = response.get("retrieval_id")
@@ -430,12 +461,29 @@ def prepare_llm_call_for_priors(
                 if isinstance(prior.get("id"), str) and prior.get("id")
             ]
         )
-        _store_prefix_cache_entry(
-            run_id,
-            clean_content_pairs,
-            extract_content_bearing_pairs(executed_flattened, api_type),
-            effective_prior_ids,
-        )
+        injected_pairs = extract_content_bearing_pairs(executed_flattened, api_type)
+        if store_prefix_cache_func is not None:
+            try:
+                store_prefix_cache_func(
+                    run_id,
+                    clean_content_pairs,
+                    injected_pairs,
+                    effective_prior_ids,
+                )
+            except Exception as exc:
+                _log_priors(
+                    "automatic",
+                    "warning",
+                    "[PRIORS RUNTIME] prefix store failed",
+                    error=str(exc),
+                )
+        else:
+            _store_prefix_cache_entry(
+                run_id,
+                clean_content_pairs,
+                injected_pairs,
+                effective_prior_ids,
+            )
         return _build_result(executed_flattened)
     except httpx.TimeoutException as exc:
         _mark_retrieval_failure(

{sovara-0.2.6 → sovara-0.2.7}/src/sovara/server/app.py

@@ -5,6 +5,7 @@ FastAPI application factory.
 import asyncio
 import json
 import os
+import sys
 from contextlib import asynccontextmanager
 from pathlib import Path
 
@@ -232,7 +233,11 @@ def create_app() -> FastAPI:
 
     @app.get("/health")
     async def health():
-        return {"status": "ok", "service": "sovara"}
+        return {
+            "status": "ok",
+            "service": "sovara",
+            "python_executable": sys.executable,
+        }
 
     @app.get("/", include_in_schema=False)
     async def web_app_index():

{sovara-0.2.6 → sovara-0.2.7}/src/sovara/server/database/llm_calls.py

@@ -1,3 +1,4 @@
+from collections.abc import Callable
 import json
 import random
 import time
@@ -223,6 +224,7 @@ class LlmCallsMixin:
         api_type: str,
         *,
         prepare_runtime_priors: bool = False,
+        prior_preparer: Callable[[dict, str], Any] | None = None,
     ) -> CacheOutput:
         """Get input/output for an LLM call, handling caching, overwrites, and priors."""
         from sovara.common.utils import hash_input, set_seed
@@ -247,7 +249,8 @@ class LlmCallsMixin:
         if should_prepare_runtime_priors:
             from sovara.runner.priors import prepare_llm_call_for_priors
 
-            prior_result = prepare_llm_call_for_priors(input_dict, api_type)
+            preparer = prior_preparer or prepare_llm_call_for_priors
+            prior_result = preparer(input_dict, api_type)
             working_input_dict = prior_result.executed_input_dict
 
         input_pickle = func_kwargs_to_json_str(working_input_dict, api_type)
@@ -305,7 +308,8 @@ class LlmCallsMixin:
             if should_prepare_runtime_priors:
                 from sovara.runner.priors import prepare_llm_call_for_priors
 
-                prior_result = prepare_llm_call_for_priors(working_input_dict, api_type)
+                preparer = prior_preparer or prepare_llm_call_for_priors
+                prior_result = preparer(working_input_dict, api_type)
                 prior_result.restore_original_input = restore_original_transport_input
                 working_input_dict = prior_result.executed_input_dict
             input_pickle = func_kwargs_to_json_str(working_input_dict, api_type)
@@ -554,6 +558,9 @@ class LlmCallsMixin:
 
     def get_tokens_timeseries(self, project_id, time_from, time_to, bucket_seconds):
         return self.backend.get_tokens_timeseries_query(
-            project_id, time_from, time_to, bucket_seconds,
+            project_id,
+            time_from,
+            time_to,
+            bucket_seconds,
             user_id=self.user_id,
         )

{sovara-0.2.6 → sovara-0.2.7}/src/sovara/server/graph_models.py

@@ -30,7 +30,9 @@ class IncomingNode:
             input=str(data["input"]),
             output=str(data["output"]),
             label=str(data["label"]),
-            latency_seconds=None if data.get("latency_seconds") is None else float(data["latency_seconds"]),
+            latency_seconds=(
+                None if data.get("latency_seconds") is None else float(data["latency_seconds"])
+            ),
             status=None if data.get("status") is None else str(data["status"]),
             error_message=None if data.get("error_message") is None else str(data["error_message"]),
             llm_verdict=None if data.get("llm_verdict") is None else str(data["llm_verdict"]),
@@ -82,7 +84,9 @@ class GraphNode:
             input=str(data["input"]),
             output=str(data["output"]),
             label=str(data["label"]),
-            latency_seconds=None if data.get("latency_seconds") is None else float(data["latency_seconds"]),
+            latency_seconds=(
+                None if data.get("latency_seconds") is None else float(data["latency_seconds"])
+            ),
             status=None if data.get("status") is None else str(data["status"]),
             error_message=None if data.get("error_message") is None else str(data["error_message"]),
             llm_verdict=None if data.get("llm_verdict") is None else str(data["llm_verdict"]),
@@ -112,6 +116,28 @@ class GraphNode:
             payload["llm_verdict"] = self.llm_verdict
         return payload
 
+    def to_metadata_dict(self) -> dict[str, Any]:
+        payload = {
+            "uuid": self.uuid,
+            "step_id": self.step_id,
+            "label": self.label,
+            "node_kind": self.node_kind,
+            "raw_node_name": self.raw_node_name,
+            "has_input": bool(self.input),
+            "has_output": bool(self.output),
+            "input_size": len(self.input or ""),
+            "output_size": len(self.output or ""),
+        }
+        if self.latency_seconds is not None:
+            payload["latency_seconds"] = self.latency_seconds
+        if self.status is not None:
+            payload["status"] = self.status
+        if self.error_message is not None:
+            payload["error_message"] = self.error_message
+        if self.llm_verdict is not None:
+            payload["llm_verdict"] = self.llm_verdict
+        return payload
+
 
 @dataclass(slots=True)
 class GraphEdge:
@@ -163,11 +189,18 @@ class RunGraph:
             "edges": [edge.to_dict() for edge in self.edges],
         }
 
+    def to_metadata_dict(self) -> dict[str, Any]:
+        return {
+            "nodes": [node.to_metadata_dict() for node in self.nodes],
+            "edges": [edge.to_dict() for edge in self.edges],
+        }
+
     @classmethod
     def from_json_string(cls, data: str | None) -> "RunGraph":
         if not data:
             return cls.empty()
         from sovara.server.database.blob_storage import restore  # lazy to avoid circular import
+
         return cls.from_dict(json.loads(restore(data)))
 
     def to_json_string(self) -> str: