sovara 0.2.4__tar.gz → 0.2.5__tar.gz

{sovara-0.2.4 → sovara-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sovara
-Version: 0.2.4
+Version: 0.2.5
 Summary: A development tool for LLM call visualization and debugging
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -43,6 +43,7 @@ Requires-Dist: openai; extra == "examples"
 Requires-Dist: anthropic; extra == "examples"
 Requires-Dist: openai-agents; extra == "examples"
 Requires-Dist: google-genai; extra == "examples"
+Requires-Dist: claude-agent-sdk; extra == "examples"
 Provides-Extra: docs
 Requires-Dist: mkdocs-material>=9.5; extra == "docs"
 Requires-Dist: mkdocs-minify-plugin; extra == "docs"

{sovara-0.2.4 → sovara-0.2.5}/pyproject.toml

@@ -26,7 +26,7 @@ line-length = 100
 
 [project]
 name = "sovara"
-version = "0.2.4"
+version = "0.2.5"
 description = "A development tool for LLM call visualization and debugging"
 readme = "docs/release/PYPI_DESC.md"
 requires-python = ">=3.10"
@@ -76,7 +76,8 @@ examples = [
     "openai",
     "anthropic",
     "openai-agents",
-    "google-genai"
+    "google-genai",
+    "claude-agent-sdk"
 ]
 
 docs = [

{sovara-0.2.4 → sovara-0.2.5}/src/sovara/runner/context_manager.py

@@ -97,6 +97,16 @@ def sovara_launch(run_name="Workflow run"):
             clear_run_timer(run_id)
 
 
+@contextmanager
+def bind_run_id(run_id: str | None):
+    """Temporarily bind the active run id inside the current context."""
+    token = current_run_id.set(run_id)
+    try:
+        yield
+    finally:
+        current_run_id.reset(token)
+
+
 def log(**metrics):
     run_id = warn_if_inactive_run("log()")
     if run_id is None:

{sovara-0.2.4 → sovara-0.2.5}/src/sovara/runner/monkey_patching/api_parser.py

@@ -27,19 +27,12 @@ from sovara.runner.monkey_patching.api_parsers.requests_api_parser import (
     json_str_to_api_obj_requests,
     json_str_to_original_inp_dict_requests,
 )
-from sovara.runner.monkey_patching.api_parsers.claude_sdk_api_parser import (
-    build_to_show_claude_sdk_input,
-    build_to_show_claude_sdk_output,
-    func_kwargs_to_json_str_claude_sdk,
-    api_obj_to_json_str_claude_sdk,
-    json_str_to_api_obj_claude_sdk,
-    json_str_to_original_inp_dict_claude_sdk,
-)
-from sovara.runner.monkey_patching.api_parsers.langchain_tool_api_parser import (
-    func_kwargs_to_json_str_langchain_tool,
-    api_obj_to_json_str_langchain_tool,
-    json_str_to_api_obj_langchain_tool,
-    json_str_to_original_inp_dict_langchain_tool,
+from sovara.runner.monkey_patching.api_parsers.claude_code_messages_api_parser import (
+    build_to_show_claude_code_messages_output,
+    func_kwargs_to_json_str_claude_code_messages,
+    api_obj_to_json_str_claude_code_messages,
+    json_str_to_api_obj_claude_code_messages,
+    json_str_to_original_inp_dict_claude_code_messages,
 )
 from sovara.runner.monkey_patching.api_parsers.urllib3_api_parser import (
     func_kwargs_to_json_str_urllib3,
@@ -235,9 +228,11 @@ def func_kwargs_to_json_str(input_dict: Dict[str, Any], api_type: str) -> str:
     elif api_type == "MCP.ClientSession.send_request":
         complete_json_str = func_kwargs_to_json_str_mcp(input_dict)
     elif api_type == "claude_agent_sdk.parse_message":
-        complete_json_str = func_kwargs_to_json_str_claude_sdk(input_dict)
+        complete_json_str = json.dumps(input_dict)
+    elif api_type == "claude_code.messages":
+        complete_json_str = func_kwargs_to_json_str_claude_code_messages(input_dict)
     elif api_type == "langchain_core.tools.BaseTool.run":
-        complete_json_str = func_kwargs_to_json_str_langchain_tool(input_dict)
+        complete_json_str = json.dumps(input_dict)
     elif api_type == "urllib3.HTTPConnectionPool.urlopen":
         complete_json_str = func_kwargs_to_json_str_urllib3(input_dict)
     else:
@@ -247,10 +242,7 @@ def func_kwargs_to_json_str(input_dict: Dict[str, Any], api_type: str) -> str:
     raw_dict = json.loads(complete_json_str)
 
     # Filter the dict to create the display version
-    if api_type == "claude_agent_sdk.parse_message":
-        to_show_dict = build_to_show_claude_sdk_input(raw_dict)
-    else:
-        to_show_dict = filter_dict(raw_dict)
+    to_show_dict = filter_dict(raw_dict)
 
     # Construct the wrapped format
     complete_dict = {"raw": raw_dict, "to_show": to_show_dict}
@@ -294,9 +286,11 @@ def json_str_to_original_inp_dict(json_str: str, input_dict: dict, api_type: str
     elif api_type == "MCP.ClientSession.send_request":
         return json_str_to_original_inp_dict_mcp(merged_json_str, input_dict)
     elif api_type == "claude_agent_sdk.parse_message":
-        return json_str_to_original_inp_dict_claude_sdk(merged_json_str, input_dict)
+        return json.loads(merged_json_str)
+    elif api_type == "claude_code.messages":
+        return json_str_to_original_inp_dict_claude_code_messages(merged_json_str, input_dict)
     elif api_type == "langchain_core.tools.BaseTool.run":
-        return json_str_to_original_inp_dict_langchain_tool(merged_json_str, input_dict)
+        return json.loads(merged_json_str)
     elif api_type == "urllib3.HTTPConnectionPool.urlopen":
         return json_str_to_original_inp_dict_urllib3(merged_json_str, input_dict)
     else:
@@ -342,9 +336,11 @@ def api_obj_to_json_str(response_obj: Any, api_type: str) -> str:
     elif api_type == "MCP.ClientSession.send_request":
         complete_json_str = api_obj_to_json_str_mcp(response_obj)
     elif api_type == "claude_agent_sdk.parse_message":
-        complete_json_str = api_obj_to_json_str_claude_sdk(response_obj)
+        complete_json_str = json.dumps(response_obj)
+    elif api_type == "claude_code.messages":
+        complete_json_str = api_obj_to_json_str_claude_code_messages(response_obj)
     elif api_type == "langchain_core.tools.BaseTool.run":
-        complete_json_str = api_obj_to_json_str_langchain_tool(response_obj)
+        complete_json_str = json.dumps(response_obj)
     elif api_type == "urllib3.HTTPConnectionPool.urlopen":
         complete_json_str = api_obj_to_json_str_urllib3(response_obj)
     else:
@@ -353,8 +349,8 @@ def api_obj_to_json_str(response_obj: Any, api_type: str) -> str:
     # Parse the JSON string to get the raw dict
     raw_dict = json.loads(complete_json_str)
     # Filter the content dict
-    if api_type == "claude_agent_sdk.parse_message":
-        to_show_dict = build_to_show_claude_sdk_output(raw_dict)
+    if api_type == "claude_code.messages":
+        to_show_dict = build_to_show_claude_code_messages_output(raw_dict)
     else:
         to_show_dict = filter_dict(raw_dict)
     # Create to_show with filtered content
@@ -394,9 +390,11 @@ def json_str_to_api_obj(new_output_text: str, api_type: str) -> Any:
     elif api_type == "MCP.ClientSession.send_request":
         return json_str_to_api_obj_mcp(merged_json_str)
     elif api_type == "claude_agent_sdk.parse_message":
-        return json_str_to_api_obj_claude_sdk(merged_json_str)
+        return json.loads(merged_json_str)
+    elif api_type == "claude_code.messages":
+        return json_str_to_api_obj_claude_code_messages(merged_json_str)
     elif api_type == "langchain_core.tools.BaseTool.run":
-        return json_str_to_api_obj_langchain_tool(merged_json_str)
+        return json.loads(merged_json_str)
     elif api_type == "urllib3.HTTPConnectionPool.urlopen":
         return json_str_to_api_obj_urllib3(merged_json_str)
     else:

sovara-0.2.5/src/sovara/runner/monkey_patching/api_parsers/claude_code_messages_api_parser.py

@@ -0,0 +1,47 @@
+"""API parser helpers for ``claude_code.messages`` proxy calls."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+def build_to_show_claude_code_messages_input(raw_input: dict[str, Any]) -> dict[str, Any]:
+    body = raw_input.get("body")
+    if body is None:
+        return {}
+    return {"body": body}
+
+
+def build_to_show_claude_code_messages_output(raw_output: dict[str, Any]) -> dict[str, Any]:
+    visible_output = {
+        key: value
+        for key, value in raw_output.items()
+        if not str(key).startswith("_")
+    }
+    from sovara.runner.monkey_patching.api_parser import filter_dict
+
+    return filter_dict(visible_output)
+
+
+def func_kwargs_to_json_str_claude_code_messages(input_dict: dict[str, Any]) -> str:
+    return json.dumps({
+        "url": input_dict.get("url", ""),
+        "body": input_dict.get("body"),
+    })
+
+
+def api_obj_to_json_str_claude_code_messages(obj: Any) -> str:
+    if not isinstance(obj, dict):
+        obj = {"value": obj}
+    return json.dumps(obj)
+
+
+def json_str_to_api_obj_claude_code_messages(json_str: str) -> Any:
+    return json.loads(json_str)
+
+
+def json_str_to_original_inp_dict_claude_code_messages(json_str: str, input_dict: dict) -> dict:
+    payload = json.loads(json_str)
+    input_dict["url"] = payload.get("url", input_dict.get("url", ""))
+    input_dict["body"] = payload.get("body")
+    return input_dict

{sovara-0.2.4 → sovara-0.2.5}/src/sovara/runner/monkey_patching/edit_io_filters.py

@@ -9,6 +9,16 @@ COMPILED_EDIT_IO_EXCLUDE_PATTERNS = [
     re.compile(r"^max_tokens$"),
     re.compile(r"^stream$"),
     re.compile(r"^temperature$"),
+    re.compile(r"^metadata\.user_id$"),
+    re.compile(r"^thinking(\.|$)"),
+    re.compile(r"^context_management(\.|$)"),
+    re.compile(r"^output_config\.(?!effort$).+"),
+    re.compile(r"^body\.metadata\.user_id$"),
+    re.compile(r"^body\.thinking(\.|$)"),
+    re.compile(r"^body\.context_management(\.|$)"),
+    re.compile(r"^body\.output_config\.(?!effort$).+"),
+    re.compile(r"^body\.stream$"),
+    re.compile(r"^body\.messages\.\d+\.content\.\d+\.signature$"),
     # Bedrock request tuning fields
     re.compile(r"^body\.inferenceConfig\.(maxTokens|temperature)$"),
     # content.* fields
@@ -30,7 +40,10 @@ COMPILED_EDIT_IO_EXCLUDE_PATTERNS = [
     re.compile(r"^content\.max_output_tokens$"),
     re.compile(r"^content\.max_tool_calls$"),
     re.compile(r"^content\.createTime$"),
+    re.compile(r"^content\.frequency_penalty$"),
+    re.compile(r"^content\.incomplete_details(\.|$)"),
     re.compile(r"^content\.parallel_tool_calls$"),
+    re.compile(r"^content\.presence_penalty$"),
     re.compile(r"^content\.previous_response_id$"),
     re.compile(r"^content\.prompt_cache"),
     re.compile(r"^content\.reasoning\.(effort|summary)$"),
@@ -46,6 +59,7 @@ COMPILED_EDIT_IO_EXCLUDE_PATTERNS = [
     re.compile(r"^content\.responseId$"),
     re.compile(r"^content\.metrics(\.|$)"),
     re.compile(r"^content\.stopReason$"),
+    re.compile(r"^content\.\d+\.signature$"),
     # content.content.* fields
     re.compile(r"^content\.content\.\d+\.(type|id|signature)$"),
     re.compile(r"^content\.content\.\d+\.content\.\d+\.type$"),

sovara-0.2.5/src/sovara/runner/monkey_patching/patches/claude_sdk_patch.py

@@ -0,0 +1,181 @@
+"""Patch Claude Agent SDK to route model traffic through the Sovara proxy."""
+
+from __future__ import annotations
+
+from dataclasses import replace
+from functools import wraps
+import os
+import uuid
+from typing import Any
+
+from sovara.common.constants import SOVARA_SERVER_URL
+from sovara.common.logger import logger
+from sovara.runner.context_manager import get_run_id
+from sovara.runner.monkey_patching.patching_utils import capture_stack_trace
+from sovara.runner.runtime_client import runtime_client
+
+_DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com"
+_UNSUPPORTED_CUSTOM_TRANSPORT_MESSAGE = (
+    "Custom Claude Agent SDK transports are not supported yet under so-record. "
+    "Please reach out to support@sovara-labs.com."
+)
+_PROXY_LOOP_MESSAGE = (
+    "Claude Agent SDK ANTHROPIC_BASE_URL points at the Sovara Claude proxy itself. "
+    "Nested Claude proxy configuration is not supported under so-record."
+)
+
+
+def _replace_options_env(options: Any, env: dict[str, str]):
+    try:
+        return replace(options, env=env)
+    except Exception:
+        options.env = env
+        return options
+
+
+def _merged_transport_env(options_env: dict[str, str] | None) -> dict[str, str]:
+    inherited_env = {key: value for key, value in os.environ.items() if key != "CLAUDECODE"}
+    return {
+        **inherited_env,
+        "CLAUDE_CODE_ENTRYPOINT": "sdk-py",
+        **(options_env or {}),
+    }
+
+
+def _proxy_base_url(run_id: str, client_id: str) -> str:
+    return f"{SOVARA_SERVER_URL}/claude-proxy/runs/{run_id}/clients/{client_id}"
+
+
+def _is_sovara_proxy_base_url(base_url: str) -> bool:
+    return base_url.rstrip("/").startswith(f"{SOVARA_SERVER_URL.rstrip('/')}/claude-proxy/")
+
+
+def _ensure_supported_transport(transport: Any) -> None:
+    if transport is not None and get_run_id():
+        raise RuntimeError(_UNSUPPORTED_CUSTOM_TRANSPORT_MESSAGE)
+
+
+def _normalize_tool_result_content(content: Any) -> Any:
+    if content is None:
+        return ""
+    return content
+
+
+def claude_sdk_patch():
+    """Apply Claude Agent SDK patches when running under ``so-record``."""
+    try:
+        from claude_agent_sdk._internal import client as internal_client
+        from claude_agent_sdk._internal import message_parser
+        from claude_agent_sdk._internal.transport.subprocess_cli import SubprocessCLITransport
+        from claude_agent_sdk import client as sdk_client
+        from claude_agent_sdk.client import ClaudeSDKClient
+    except ImportError:
+        logger.info("claude_agent_sdk not installed, skipping SDK patches")
+        return
+
+    try:
+        from claude_agent_sdk.types import AssistantMessage, ToolResultBlock, ToolUseBlock, UserMessage
+    except ImportError:
+        logger.info("claude_agent_sdk types unavailable, skipping SDK patches")
+        return
+
+    original_parse = message_parser.parse_message
+    original_process_query = internal_client.InternalClient.process_query
+    original_client_connect = ClaudeSDKClient.connect
+    original_transport_connect = SubprocessCLITransport.connect
+
+    @wraps(original_parse)
+    def patched_parse_message(data: dict) -> Any:
+        message = original_parse(data)
+        run_id = get_run_id()
+        if not run_id:
+            return message
+
+        stack_trace = capture_stack_trace()
+        try:
+            if isinstance(message, AssistantMessage):
+                for block in getattr(message, "content", []) or []:
+                    if isinstance(block, ToolUseBlock):
+                        runtime_client.register_claude_sdk_tool_use(
+                            run_id,
+                            block.id,
+                            block.name,
+                            getattr(block, "input", None),
+                            stack_trace=stack_trace,
+                        )
+            elif isinstance(message, UserMessage):
+                content = getattr(message, "content", None)
+                if isinstance(content, list):
+                    for block in content:
+                        if isinstance(block, ToolResultBlock):
+                            runtime_client.finalize_claude_sdk_tool_result(
+                                run_id,
+                                block.tool_use_id,
+                                _normalize_tool_result_content(getattr(block, "content", None)),
+                                is_error=bool(getattr(block, "is_error", False)),
+                            )
+        except Exception as exc:
+            logger.error("Error in claude_sdk_patch parse hook: %s", exc)
+        return message
+
+    @wraps(original_process_query)
+    async def patched_process_query(self, prompt, options, transport=None):
+        _ensure_supported_transport(transport)
+        async for message in original_process_query(self, prompt, options, transport=transport):
+            yield message
+
+    @wraps(original_client_connect)
+    async def patched_client_connect(self, prompt=None):
+        _ensure_supported_transport(getattr(self, "_custom_transport", None))
+        return await original_client_connect(self, prompt)
+
+    @wraps(original_transport_connect)
+    async def patched_transport_connect(self):
+        run_id = get_run_id()
+        if not run_id:
+            return await original_transport_connect(self)
+
+        original_env = dict(getattr(self._options, "env", {}) or {})
+        merged_env = _merged_transport_env(original_env)
+        if merged_env.get("SOVARA_CLAUDE_PROXY_ACTIVE") == "1":
+            return await original_transport_connect(self)
+
+        upstream_base_url = merged_env.get("ANTHROPIC_BASE_URL") or _DEFAULT_ANTHROPIC_BASE_URL
+        if _is_sovara_proxy_base_url(upstream_base_url):
+            raise RuntimeError(_PROXY_LOOP_MESSAGE)
+        client_id = getattr(self, "_sovara_claude_proxy_client_id", None)
+        if not client_id:
+            client_id = uuid.uuid4().hex
+            self._sovara_claude_proxy_client_id = client_id
+
+        runtime_client.register_claude_proxy_client(
+            run_id,
+            client_id,
+            upstream_base_url,
+            stack_trace=capture_stack_trace(),
+        )
+
+        proxy_env = {
+            **merged_env,
+            "ANTHROPIC_BASE_URL": _proxy_base_url(run_id, client_id),
+            "SOVARA_CLAUDE_PROXY_ACTIVE": "1",
+        }
+        self._options = _replace_options_env(self._options, proxy_env)
+        try:
+            return await original_transport_connect(self)
+        finally:
+            self._options = _replace_options_env(self._options, original_env)
+
+    message_parser.parse_message = patched_parse_message
+    internal_client.parse_message = patched_parse_message
+    sdk_client.parse_message = patched_parse_message
+    internal_client.InternalClient.process_query = patched_process_query
+    ClaudeSDKClient.connect = patched_client_connect
+    SubprocessCLITransport.connect = patched_transport_connect
+
+    logger.info("claude_agent_sdk patch applied")
+
+
+def clear_sdk_run_data(run_id: str):
+    """Retained for compatibility with older cleanup paths."""
+    del run_id

{sovara-0.2.4 → sovara-0.2.5}/src/sovara/runner/monkey_patching/patching_utils.py

@@ -64,6 +64,12 @@ def _extract_model_from_body(input_dict: Dict[str, Any], api_type: str) -> Optio
                 return "Redacted Reasoning"
             return input_dict.get("tool_name") or input_dict.get("model")
 
+        elif api_type == "claude_code.messages":
+            body = input_dict.get("body")
+            if isinstance(body, dict):
+                return body.get("model")
+            return None
+
         elif api_type == "langchain_core.tools.BaseTool.run":
             return input_dict.get("tool_name")
 
@@ -188,6 +194,10 @@ def _extract_request_url_and_path(input_dict: Dict[str, Any], api_type: str) ->
             return url, parsed.path
         if api_type == "urllib3.HTTPConnectionPool.urlopen":
             return input_dict.get("full_url"), input_dict.get("url")
+        if api_type == "claude_code.messages":
+            url = str(input_dict.get("url") or "")
+            parsed = urlparse(url)
+            return url, parsed.path
     except (AttributeError, KeyError, TypeError):
         return None, None
 
@@ -209,6 +219,9 @@ def get_node_kind(input_dict: Dict[str, Any], api_type: str) -> str:
     if api_type == "claude_agent_sdk.parse_message":
         return "tool" if input_dict.get("tool_name") else "llm"
 
+    if api_type == "claude_code.messages":
+        return "llm"
+
     if api_type == "langchain_core.tools.BaseTool.run":
         return "tool"
 
@@ -339,6 +352,36 @@ def send_graph_node_and_edges(
     latency_seconds=None,
 ):
     """Send graph node and edge updates to the server."""
+    run_id = get_run_id()
+    node_msg = build_add_node_message(
+        run_id=run_id,
+        node_id=node_id,
+        input_dict=input_dict,
+        output_obj=output_obj,
+        source_node_ids=source_node_ids,
+        api_type=api_type,
+        stack_trace=stack_trace,
+        latency_seconds=latency_seconds,
+    )
+
+    try:
+        http_post("/runner/add-node", node_msg)
+    except Exception as e:
+        logger.error(f"Failed to send add_node: {e}")
+
+
+def build_add_node_message(
+    *,
+    run_id,
+    node_id,
+    input_dict,
+    output_obj,
+    source_node_ids,
+    api_type,
+    stack_trace,
+    latency_seconds=None,
+):
+    """Build the canonical add-node payload for graph updates."""
     # Import here to avoid circular import
     from sovara.runner.monkey_patching.api_parser import func_kwargs_to_json_str, api_obj_to_json_str
     from sovara.runner.node_execution import extract_node_error
@@ -351,7 +394,6 @@ def send_graph_node_and_edges(
     raw_node_name = get_node_name(input_dict, api_type)
     label = get_node_label(input_dict, api_type)
     node_kind = get_node_kind(input_dict, api_type)
-    run_id = get_run_id()
     error_payload = extract_node_error(output_obj, api_type)
     node_status = "error" if error_payload else "success"
     error_message = error_payload.get("message") if isinstance(error_payload, dict) else None
@@ -378,10 +420,9 @@ def send_graph_node_and_edges(
                 if node_a != node_b and node_b in _graph_reachable_set[run_id][node_a]:
                     if output_contained_in_input(run_id, node_a, node_b):
                         nodes_to_remove.add(node_a)
-        source_node_ids = [n for n in source_node_ids if n not in nodes_to_remove]
+        filtered_source_node_ids = [n for n in source_node_ids if n not in nodes_to_remove]
 
-    # Send node
-    node_msg = {
+    return {
         "type": "add_node",
         "run_id": run_id,
         "node": {
@@ -396,10 +437,5 @@ def send_graph_node_and_edges(
             "node_kind": node_kind,
             "raw_node_name": raw_node_name,
         },
-        "incoming_edges": source_node_ids,
+        "incoming_edges": filtered_source_node_ids,
     }
-
-    try:
-        http_post("/runner/add-node", node_msg)
-    except Exception as e:
-        logger.error(f"Failed to send add_node: {e}")

{sovara-0.2.4 → sovara-0.2.5}/src/sovara/runner/node_execution.py

@@ -68,11 +68,9 @@ def record_prepared_call_exception(
     if build_exception_output_func is None:
         build_exception_output_func = build_exception_output
 
-    record_exception_func(
-        prepared_call=prepared_call,
-        exc=exc,
-        api_type=api_type,
-    )
+    # Support recorders that use either ``prepared_call`` or ``cache_result``
+    # for the first argument name.
+    record_exception_func(prepared_call, exc, api_type)
     prepared_call.output = build_exception_output_func(exc, api_type, prepared_call.input_dict)
     send_graph_node_and_edges_func(
         node_id=prepared_call.node_uuid,
@@ -194,6 +192,23 @@ def extract_node_error(output_obj: Any, api_type: str) -> dict[str, Any] | None:
 
     payload = _jsonable_payload(output_obj)
 
+    if api_type == "claude_code.messages":
+        if isinstance(payload, dict):
+            status = payload.get("_status_code")
+            if isinstance(status, int) and status >= 400:
+                details = {
+                    key: value
+                    for key, value in payload.items()
+                    if not str(key).startswith("_")
+                }
+                return _http_error_payload(
+                    api_type=api_type,
+                    status=status,
+                    reason=None,
+                    details=details,
+                )
+        return None
+
     if api_type == "MCP.ClientSession.send_request":
         if isinstance(payload, dict) and (payload.get("isError") is True or payload.get("is_error") is True):
             return _structured_error_payload(
@@ -288,4 +303,12 @@ def build_exception_output(exc: Exception, api_type: str, input_dict: dict[str,
             request_url=input_dict.get("full_url"),
         )
 
+    if api_type == "claude_code.messages":
+        return {
+            **error_payload,
+            "_stream": bool(input_dict.get("body", {}).get("stream")),
+            "_status_code": 599,
+            "_headers": {"content-type": "application/json"},
+        }
+
     return error_payload

{sovara-0.2.4 → sovara-0.2.5}/src/sovara/runner/runtime_client.py

@@ -63,12 +63,67 @@ class RuntimeClient:
     def get_run_scope(self, run_id: str) -> dict[str, Any] | None:
         return http_post("/internal/runner/run-scope", {"run_id": run_id}).get("run")
 
+    def register_claude_proxy_client(
+        self,
+        run_id: str,
+        client_id: str,
+        upstream_base_url: str,
+        stack_trace: str | None = None,
+    ) -> None:
+        http_post(
+            "/internal/runner/claude-proxy/register-client",
+            {
+                "run_id": run_id,
+                "client_id": client_id,
+                "upstream_base_url": upstream_base_url,
+                "stack_trace": stack_trace,
+            },
+        )
+
     def add_prior_applied(self, prior_id: str, run_id: str, node_uuid: str | None = None) -> None:
         http_post(
             "/internal/runner/priors/track-applied",
             {"prior_id": prior_id, "run_id": run_id, "node_uuid": node_uuid},
         )
 
+    def register_claude_sdk_tool_use(
+        self,
+        run_id: str,
+        tool_use_id: str,
+        tool_name: str,
+        tool_input: Any,
+        *,
+        stack_trace: str | None = None,
+    ) -> None:
+        http_post(
+            "/internal/runner/claude-sdk/tool-use",
+            {
+                "run_id": run_id,
+                "tool_use_id": tool_use_id,
+                "tool_name": tool_name,
+                "tool_input": tool_input,
+                "stack_trace": stack_trace,
+            },
+        )
+
+    def finalize_claude_sdk_tool_result(
+        self,
+        run_id: str,
+        tool_use_id: str,
+        tool_result: Any,
+        *,
+        is_error: bool = False,
+    ) -> None:
+        http_post(
+            "/internal/runner/claude-sdk/tool-result",
+            {
+                "run_id": run_id,
+                "tool_use_id": tool_use_id,
+                "tool_result": tool_result,
+                "is_error": is_error,
+            },
+        )
+
     def upsert_prior_retrieval(
         self,
         run_id: str,
@@ -127,6 +182,7 @@ class RuntimeClient:
                 "aiohttp.ClientSession._request",
                 "requests.Session.send",
                 "urllib3.HTTPConnectionPool.urlopen",
+                "claude_code.messages",
             }
         )
 

{sovara-0.2.4 → sovara-0.2.5}/src/sovara/server/app.py

@@ -212,12 +212,14 @@ def create_app() -> FastAPI:
     from sovara.server.routes.ui import router as ui_router
     from sovara.server.routes.events import router as events_router
     from sovara.server.routes.internal import router as internal_router
+    from sovara.server.routes.claude_proxy import router as claude_proxy_router
     from sovara.server.priors_backend.routes import router as priors_router
 
     app.include_router(runner_router)
     app.include_router(ui_router)
     app.include_router(events_router)
     app.include_router(internal_router)
+    app.include_router(claude_proxy_router)
     app.include_router(priors_router)
 
     @app.get("/health")