deepstrike 0.2.22__tar.gz → 0.2.24__tar.gz

{deepstrike-0.2.22 → deepstrike-0.2.24}/Cargo.lock

@@ -194,7 +194,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-core"
-version = "0.2.22"
+version = "0.2.24"
 dependencies = [
  "compact_str",
  "pretty_assertions",
@@ -206,7 +206,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-node"
-version = "0.2.22"
+version = "0.2.24"
 dependencies = [
  "compact_str",
  "deepstrike-core",
@@ -218,7 +218,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-py"
-version = "0.2.22"
+version = "0.2.24"
 dependencies = [
  "compact_str",
  "deepstrike-core",
@@ -229,7 +229,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-sdk"
-version = "0.2.22"
+version = "0.2.24"
 dependencies = [
  "async-stream",
  "async-trait",
@@ -263,7 +263,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-wasm"
-version = "0.2.22"
+version = "0.2.24"
 dependencies = [
  "compact_str",
  "deepstrike-core",

{deepstrike-0.2.22 → deepstrike-0.2.24}/Cargo.toml

@@ -3,13 +3,13 @@ resolver = "2"
 members = ["crates/deepstrike-core", "crates/deepstrike-py"]
 
 [workspace.package]
-version = "0.2.22"
+version = "0.2.24"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/kongusen/deepstrike"
 
 [workspace.dependencies]
-deepstrike-core = { path = "crates/deepstrike-core", version = "0.2.22" }
+deepstrike-core = { path = "crates/deepstrike-core", version = "0.2.24" }
 notify = "6"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

{deepstrike-0.2.22 → deepstrike-0.2.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepstrike
-Version: 0.2.22
+Version: 0.2.24
 Requires-Dist: httpx>=0.27
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: anyio>=4.0

{deepstrike-0.2.22 → deepstrike-0.2.24}/deepstrike/__init__.py

@@ -64,7 +64,11 @@ from deepstrike.providers import (
     PermissionRequestEvent, PermissionResolvedEvent, PermissionResponse, ToolArgumentRepairedEvent,
     RetryConfig, CircuitBreaker, TokenUsage, ProviderToolSpec,
 )
-from deepstrike.tools import RegisteredTool, tool, streaming_tool, validate_tool_arguments, execute_tools, read_file
+from deepstrike.tools import (
+    RegisteredTool, tool, streaming_tool, validate_tool_arguments, execute_tools, read_file,
+    ToolError, safe_tool, ok, fail, format_tool_error,
+)
+from deepstrike.providers.stream import ToolAuditFailedEvent
 from deepstrike.memory import (
     WorkingMemory,
     DreamStore, DreamResult, SessionData, MemoryEntry, CurationResult, CurationStats,
@@ -75,6 +79,9 @@ from deepstrike.harness import (
     QualityGate,
     SinglePassHarness, HarnessLoop, EvalLoopHarness,
     HarnessRequest, HarnessOutcome,
+    # I3.1: surface harness types so hosts can construct verdicts and stream-event handlers
+    # without importing from deepstrike.harness.harness directly.
+    HarnessEvent, CriterionResult,
 )
 from deepstrike.skills import SkillRegistry
 from deepstrike.knowledge import KnowledgeSource
@@ -136,11 +143,13 @@ __all__ = [
     "PermissionRequestEvent", "PermissionResolvedEvent", "PermissionResponse", "ToolArgumentRepairedEvent",
     "RetryConfig", "CircuitBreaker", "TokenUsage", "ProviderToolSpec",
     "RegisteredTool", "tool", "streaming_tool", "validate_tool_arguments", "execute_tools", "read_file",
+    "ToolError", "safe_tool", "ok", "fail", "format_tool_error", "ToolAuditFailedEvent",
     "WorkingMemory",
     "DreamStore", "DreamResult", "SessionData", "MemoryEntry", "CurationResult", "CurationStats",
     "PermissionManager", "PermissionMode", "Permission", "PermissionDecision",
     "QualityGate",
     "SinglePassHarness", "HarnessLoop", "EvalLoopHarness", "HarnessRequest", "HarnessOutcome",
+    "HarnessEvent", "CriterionResult",
     "SkillRegistry",
     "KnowledgeSource",
     "RuntimeSignal", "SignalSource", "ScheduledPrompt", "SignalGateway",

{deepstrike-0.2.22 → deepstrike-0.2.24}/deepstrike/governance.py

@@ -28,6 +28,38 @@ class GovernancePolicy:
     vetoes: list[str] = field(default_factory=list)
     rate_limits: list[GovernanceRateLimit] = field(default_factory=list)
     constraints: list[dict[str, Any]] = field(default_factory=list)
+    # I5: when True (default), the runner pre-filters denied tools out of the schema. Mirrors Node.
+    surface_denied_in_system: bool = True
+
+
+def governance_filter_schema(tools: list, policy: "GovernancePolicy | None") -> tuple[list, list[str]]:
+    """I5: bucket tools into (allowed, denied) per the policy. Pure. Mirrors Node ``governanceFilterSchema``."""
+    if policy is None:
+        return tools, []
+    vetoes = set(policy.vetoes or [])
+    allowed: list = []
+    denied: list[str] = []
+    def matches(pat: str, name: str) -> bool:
+        return pat == name or (pat.endswith("*") and name.startswith(pat[:-1]))
+    for t in tools:
+        name = t.name if hasattr(t, "name") else (t.get("name") if isinstance(t, dict) else None)
+        if name is None:
+            allowed.append(t)
+            continue
+        if name in vetoes:
+            denied.append(name)
+            continue
+        action = policy.default_action or "allow"
+        for r in (policy.rules or []):
+            pat = r.pattern if hasattr(r, "pattern") else r.get("pattern")
+            act = r.action if hasattr(r, "action") else r.get("action")
+            if pat is not None and matches(pat, name):
+                action = act
+        if action == "deny":
+            denied.append(name)
+        else:
+            allowed.append(t)
+    return allowed, denied
 
 
 def governance_policy_to_kernel_event(policy: GovernancePolicy) -> dict[str, Any]:

{deepstrike-0.2.22 → deepstrike-0.2.24}/deepstrike/harness/harness.py

@@ -16,6 +16,10 @@ class Criterion:
     text: str
     required: bool = True
     weight: float = 1.0
+    # I3.3 (A4): optional stable id from the host's contract layer (threaded to verdict_fn).
+    id: "str | None" = None
+    # I3.3 (A4): host hint — host has a deterministic check for this criterion.
+    machine_checkable: "bool | None" = None
 
 
 @dataclass
@@ -160,6 +164,9 @@ class SinglePassHarness:
 
 
 class EvalLoopHarness:
+    """I3.4 (A1): deprecated — prefer ``HarnessLoop`` with ``verdict_fn`` for host-defined
+    judgment. ``EvalLoopHarness.stream()`` does NOT honor ``gate`` (only ``.run()`` does);
+    ``HarnessLoop`` runs the eval loop uniformly across stream and run."""
     def __init__(self, runner: "RuntimeRunner", gate: "QualityGate", max_attempts: int = 3):
         self._runner = runner
         self._gate = gate
@@ -186,11 +193,16 @@ class HarnessLoop:
         *,
         max_attempts: int = 3,
         skill_dir: str | None = None,
+        # I3.2 (A2/A3): host-supplied judgment. Receives kwargs (goal, criteria, attempt, result);
+        # returns Verdict to short-circuit the LLM eval, or None/Awaitable[None] to defer. Mirrors
+        # the Node SDK ``verdictFn``.
+        verdict_fn=None,
     ):
         self._runner = runner
         self._eval_provider = eval_provider
         self._max_attempts = max_attempts
         self._skill_dir = pathlib.Path(skill_dir) if skill_dir else None
+        self._verdict_fn = verdict_fn
 
     async def run(self, request: HarnessRequest) -> HarnessOutcome:
         # R3-1: collect nodes the agent submits while running under the harness (dynamic fan-out in
@@ -251,30 +263,41 @@ class HarnessLoop:
 
             yield SupervisingEvent()
 
-            # #6 (0.5.0): the eval/verdict compute is the kernel's stateless free functions (was the
-            # EvalPipeline state machine). Build the eval prompt, call the eval LLM, parse the verdict.
-            eval_msgs = build_eval_messages(request.goal, criteria, last_result, attempt, True)
-            eval_text = ""
-            eval_system = "\n\n".join(m.content for m in eval_msgs if m.role == "system")
-            eval_turns = [m for m in eval_msgs if m.role != "system"]
-            eval_context = RenderedContext(system_text=eval_system, turns=eval_turns)
-            async for evt in self._eval_provider.stream(eval_context, [], extensions=None):
-                if isinstance(evt, TextDelta):
-                    eval_text += evt.delta
-
-            parsed = parse_verdict(eval_text)
-            verdict = Verdict(
-                passed=parsed.passed,
-                overall_score=parsed.overall_score,
-                feedback=parsed.feedback,
-                details=[
-                    CriterionResult(criterion=d.criterion, passed=d.passed, score=d.score, feedback=d.feedback)
-                    for d in (parsed.details or [])
-                ],
-            )
+            # I3.2 (A2/A3): host-supplied verdict_fn short-circuits the LLM eval. Returning None
+            # (or awaitable None) defers to the built-in eval below — enables hybrid judgment.
+            verdict = None
+            skill_candidate = None
+            if self._verdict_fn is not None:
+                result = self._verdict_fn(goal=request.goal, criteria=criteria, attempt=attempt, result=last_result)
+                if hasattr(result, "__await__"):
+                    result = await result
+                verdict = result
+            if verdict is None:
+                # #6 (0.5.0): the eval/verdict compute is the kernel's stateless free functions (was the
+                # EvalPipeline state machine). Build the eval prompt, call the eval LLM, parse the verdict.
+                eval_msgs = build_eval_messages(request.goal, criteria, last_result, attempt, True)
+                eval_text = ""
+                eval_system = "\n\n".join(m.content for m in eval_msgs if m.role == "system")
+                eval_turns = [m for m in eval_msgs if m.role != "system"]
+                eval_context = RenderedContext(system_text=eval_system, turns=eval_turns)
+                async for evt in self._eval_provider.stream(eval_context, [], extensions=None):
+                    if isinstance(evt, TextDelta):
+                        eval_text += evt.delta
+
+                parsed = parse_verdict(eval_text)
+                verdict = Verdict(
+                    passed=parsed.passed,
+                    overall_score=parsed.overall_score,
+                    feedback=parsed.feedback,
+                    details=[
+                        CriterionResult(criterion=d.criterion, passed=d.passed, score=d.score, feedback=d.feedback)
+                        for d in (parsed.details or [])
+                    ],
+                )
+                skill_candidate = parsed.skill_candidate
 
             if verdict.passed:
-                sc = parsed.skill_candidate
+                sc = skill_candidate
                 if sc and self._skill_dir:
                     lines = ["---", f"name: {sc.name}", f"description: {sc.description}"]
                     if sc.when_to_use:

{deepstrike-0.2.22 → deepstrike-0.2.24}/deepstrike/providers/anthropic.py

@@ -222,6 +222,8 @@ class AnthropicProvider:
         system = self._build_system(context, strategy)
         tool_defs = self._build_tools(tools, anchor_cache=not isinstance(system, list), strategy=strategy)
         _assert_cache_budget(system, len(tools))
+        # I1: capture which slots will carry cache_control for pro-rata attribution at usage time.
+        slot_bp = _count_cache_control_slots(system, tool_defs, msgs)
 
         native_blocks: dict[int, dict] = {}
         tool_blocks: dict[int, dict] = {}
@@ -254,12 +256,14 @@ class AnthropicProvider:
                         # input_tokens is the FULL prompt size (uncached + cache
                         # read + cache write) for accurate context accounting.
                         full_input = uncached_input + cache_read + cache_creation
+                        by_slot = _estimate_cache_read_by_slot(cache_read, slot_bp)
                         yield UsageEvent(
                             total_tokens=full_input + output_tokens,
                             input_tokens=full_input,
                             output_tokens=output_tokens,
                             cache_read_input_tokens=cache_read,
                             cache_creation_input_tokens=cache_creation,
+                            cache_read_input_tokens_by_slot=by_slot,
                         )
                 elif event.type == "content_block_start":
                     idx = event.index
@@ -341,6 +345,37 @@ def _resolve_cache_breakpoint_strategy(extensions: "dict | None") -> str:
     return "default"
 
 
+def _count_cache_control_slots(system, tool_defs, msgs) -> dict:
+    """I1: which slots of the outgoing request carry a ``cache_control`` breakpoint. Mirrors Node."""
+    sys_bp = isinstance(system, list) and any((isinstance(b, dict) and b.get("cache_control") is not None) for b in system)
+    tool_bp = bool(tool_defs) and any((isinstance(t, dict) and t.get("cache_control") is not None) for t in tool_defs)
+    msg_bp = False
+    for m in msgs or []:
+        content = m.get("content") if isinstance(m, dict) else None
+        if isinstance(content, list):
+            if any((isinstance(b, dict) and b.get("cache_control") is not None) for b in content):
+                msg_bp = True
+                break
+    return {"system": sys_bp, "tools": tool_bp, "messages": msg_bp}
+
+
+def _estimate_cache_read_by_slot(cache_read: int, slot_bp: dict) -> "dict | None":
+    """I1: split ``cache_read_input_tokens`` evenly across contributing slots. Remainder lands on the
+    first contributing slot to keep the sum exact. Returns None when no cache read or no slot
+    contributed — consumers see the field absent rather than all zeros. Mirrors Node."""
+    if cache_read <= 0:
+        return None
+    contributors = [s for s in ("system", "tools", "messages") if slot_bp.get(s)]
+    if not contributors:
+        return None
+    share = cache_read // len(contributors)
+    remainder = cache_read - share * len(contributors)
+    out: dict = {}
+    for i, slot in enumerate(contributors):
+        out[slot] = share + (remainder if i == 0 else 0)
+    return out
+
+
 def _apply_message_cache_control(msgs: list[dict], frozen_prefix_len: "int | None" = None, strategy: str = "default") -> None:
     """Place the (<=2) message-history cache breakpoints. The final message always
     gets one (writes the current full prefix). The second is placed by one of two

{deepstrike-0.2.22 → deepstrike-0.2.24}/deepstrike/providers/stream.py

@@ -63,6 +63,9 @@ class UsageEvent:
     # Cost breakdown (subset of input_tokens): reads bill ~0.1x, writes ~1.25x.
     cache_read_input_tokens: int = 0
     cache_creation_input_tokens: int = 0
+    # I1: pro-rata per-slot attribution of cache_read_input_tokens (Anthropic only). None when the
+    # provider doesn't honor cache_control. Shape: {"system": int?, "tools": int?, "messages": int?}.
+    cache_read_input_tokens_by_slot: "dict | None" = None
 
 
 @dataclass
@@ -123,6 +126,18 @@ class ToolDeniedEvent:
     reason: str = ""
 
 
+@dataclass
+class ToolAuditFailedEvent:
+    """A tool's ``ctx.audit(label, fn)`` best-effort side-effect threw. The tool itself completed
+    successfully (no ``is_error`` flip, no retry); this event lets the host log / monitor that an
+    audit-store / metrics-emit / non-essential persistence step failed."""
+    type: str = "tool_audit_failed"
+    call_id: str = ""
+    name: str = ""
+    label: str = ""
+    error: str = ""
+
+
 @dataclass
 class WorkflowNodesSubmittedEvent:
     """R3-1: a workflow node's agent called the ``submit_workflow_nodes`` tool. The runner surfaces
@@ -146,5 +161,6 @@ StreamEvent = Union[
     PermissionResolvedEvent,
     ToolArgumentRepairedEvent,
     ToolDeniedEvent,
+    ToolAuditFailedEvent,
     WorkflowNodesSubmittedEvent,
 ]

{deepstrike-0.2.22 → deepstrike-0.2.24}/deepstrike/runtime/execution_plane.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
 import asyncio
+import inspect
 import json
+import warnings
 from collections.abc import AsyncIterable, AsyncIterator
 from dataclasses import dataclass
 from pathlib import Path
@@ -13,12 +15,14 @@ from deepstrike.providers.stream import (
   PermissionResolvedEvent,
   PermissionResponse,
   StreamEvent,
+  ToolAuditFailedEvent,
   ToolDeltaEvent,
   ToolDeniedEvent,
   ToolResultEvent,
   ToolSuspendEvent,
   ToolArgumentRepairedEvent,
 )
+from deepstrike.tools.errors import format_tool_error
 from deepstrike.tools.registry import RegisteredTool, normalize_tool_chunk, tool_chunk_text, validate_tool_arguments
 
 if TYPE_CHECKING:
@@ -33,6 +37,39 @@ def _strip_frontmatter(content: str) -> str:
   return re.sub(r"^---\n.*?\n---\n?", "", content, count=1, flags=re.DOTALL)
 
 
+_WARNED_FAILURE_SHAPES: set[str] = set()
+
+
+def _maybe_warn_failure_shaped_chunk(tool_name: str, delta_text: str) -> None:
+  """One-shot heuristic: detect when a streaming tool yielded text that *looks* like a failure
+  envelope. The runtime cannot block the tool from doing it, but we warn (once per tool) so
+  the author migrates to raising — the canonical "streaming tool fails" path. Aligns with the
+  non-streaming ``tool()`` / ``safe_tool`` contract: failures raise, successes return data."""
+  if not delta_text or tool_name in _WARNED_FAILURE_SHAPES:
+    return
+  trimmed = delta_text.strip()
+  if len(trimmed) < 2 or trimmed[0] != "{":
+    return
+  try:
+    parsed = json.loads(trimmed)
+  except Exception:
+    return
+  if not isinstance(parsed, dict):
+    return
+  looks_like_failure = parsed.get("success") is False or parsed.get("isError") is True or parsed.get("is_error") is True
+  if not looks_like_failure:
+    return
+  _WARNED_FAILURE_SHAPES.add(tool_name)
+  warnings.warn(
+    f'streaming tool "{tool_name}" yielded a failure-shaped chunk '
+    "(success:false / isError:true). Streaming tools should fail by raising; the runtime will "
+    "catch and surface the error consistently. Returning a failure-shaped chunk is a foot-gun: "
+    "the kernel still sees is_error=False.",
+    RuntimeWarning,
+    stacklevel=2,
+  )
+
+
 @dataclass
 class RunContext:
   agent_id: str | None = None
@@ -45,6 +82,12 @@ class RunContext:
   # M3/G4: the working directory a sub-agent's tools should run in (the git worktree created for an
   # ``isolation: "worktree"`` node). Injected by ``WorktreeExecutionPlane``; a cwd-aware tool reads it.
   cwd: str | None = None
+  # Per-call best-effort side-effect helper (injected by the execution plane). Wrap audit-log
+  # writes, metrics emits, or any non-essential persistence in ``await ctx.audit(label, fn)``;
+  # if ``fn`` raises, the failure is surfaced as a ``ToolAuditFailedEvent`` and the tool still
+  # completes successfully — avoiding the foot-gun where a transient audit-store outage flips
+  # an already-committed write into ``is_error=True`` and triggers a duplicate retry.
+  audit: Callable[[str, Callable[[], Awaitable[None] | None]], Awaitable[None]] | None = None
 
 
 class ExecutionPlane:
@@ -174,6 +217,29 @@ class LocalExecutionPlane:
         error_kind="recoverable",
       )
       return
+    # Per-call ``audit`` helper: failures collected here are surfaced as
+    # ``ToolAuditFailedEvent`` rather than flipping the main tool result to ``is_error=True``.
+    audit_failures: list[tuple[str, str]] = []
+
+    async def _audit(label: str, fn: Callable[[], Awaitable[None] | None]) -> None:
+      try:
+        result = fn()
+        if inspect.isawaitable(result):
+          await result
+      except Exception as ae:
+        audit_failures.append((label, format_tool_error(ae)))
+
+    call_ctx = RunContext(
+      agent_id=ctx.agent_id,
+      skill_dir=ctx.skill_dir,
+      dream_store=ctx.dream_store,
+      knowledge_source=ctx.knowledge_source,
+      on_tool_suspend=ctx.on_tool_suspend,
+      on_permission_request=ctx.on_permission_request,
+      result_spool=ctx.result_spool,
+      cwd=ctx.cwd,
+      audit=_audit,
+    )
     try:
       kwargs = json.loads(call.arguments or "{}")
       original_args_str = json.dumps(kwargs)
@@ -195,8 +261,9 @@ class LocalExecutionPlane:
           original_arguments=original_args_str,
           repaired_arguments=json.dumps(kwargs),
         )
-      # M3/G4: pass the run context (incl. ``cwd``) so cwd-aware tools scope work to the worktree.
-      output = await registered(_ctx=ctx, **kwargs)
+      # M3/G4: pass the run context (incl. ``cwd``, ``audit``) so cwd-aware / audit-aware tools
+      # scope work to the worktree and route best-effort side-effects through the plane.
+      output = await registered(_ctx=call_ctx, **kwargs)
       if isinstance(output, AsyncIterable):
         combined = ""
         iterator = output.__aiter__()
@@ -234,22 +301,30 @@ class LocalExecutionPlane:
             continue
           delta = tool_chunk_text(raw)
           combined += delta
+          if delta:
+            _maybe_warn_failure_shaped_chunk(call.name, delta)
           yield ToolDeltaEvent(
             call_id=call.id, name=call.name, delta=delta,
             chunk=None if isinstance(raw, str) else chunk,
           )
+        for label, error in audit_failures:
+          yield ToolAuditFailedEvent(call_id=call.id, name=call.name, label=label, error=error)
         yield ToolResultEvent(call_id=call.id, name=call.name, content=combined, is_error=False)
         return
+      for label, error in audit_failures:
+        yield ToolAuditFailedEvent(call_id=call.id, name=call.name, label=label, error=error)
       yield ToolResultEvent(call_id=call.id, name=call.name, content=str(output), is_error=False)
     except Exception as exc:
       is_fatal = getattr(exc, "is_fatal", False)
       error_kind = getattr(exc, "error_kind", None)
       if error_kind is None:
         error_kind = "fatal" if is_fatal else "recoverable"
+      for label, error in audit_failures:
+        yield ToolAuditFailedEvent(call_id=call.id, name=call.name, label=label, error=error)
       yield ToolResultEvent(
         call_id=call.id,
         name=call.name,
-        content=str(exc),
+        content=format_tool_error(exc),
         is_error=True,
         is_fatal=is_fatal,
         error_kind=error_kind,

{deepstrike-0.2.22 → deepstrike-0.2.24}/deepstrike/runtime/mcp_proxy_plane.py

@@ -10,6 +10,7 @@ from typing import TYPE_CHECKING, Any
 
 from deepstrike._kernel import ToolCall, ToolSchema
 from deepstrike.providers.stream import StreamEvent, ToolResultEvent
+from deepstrike.tools.errors import format_tool_error
 from deepstrike.tools.registry import RegisteredTool
 from deepstrike.runtime.execution_plane import ExecutionPlane, LocalExecutionPlane, RunContext
 from deepstrike.runtime.credential_vault import CredentialVault
@@ -126,7 +127,7 @@ class _McpConnection:
       )
       return (text or json.dumps(result)), result.get("isError", False)
     except Exception as exc:
-      return str(exc), True
+      return format_tool_error(exc), True
 
   async def stop(self) -> None:
     if self._reader_task:

{deepstrike-0.2.22 → deepstrike-0.2.24}/deepstrike/runtime/process_sandbox_plane.py

@@ -6,6 +6,7 @@ import os
 from pathlib import Path
 
 from deepstrike._kernel import ToolSchema
+from deepstrike.tools.errors import format_tool_error
 from deepstrike.tools.registry import RegisteredTool
 from deepstrike.runtime.execution_plane import LocalExecutionPlane
 
@@ -72,7 +73,7 @@ class ProcessSandboxPlane(LocalExecutionPlane):
         combined = combined[: self._max_output_bytes] + b"\n[output truncated]"
       return combined.decode("utf-8", errors="replace"), proc.returncode != 0
     except Exception as exc:
-      return str(exc), True
+      return format_tool_error(exc), True
 
   def _make_bash_tool(self) -> RegisteredTool:
     sandbox = self

{deepstrike-0.2.22 → deepstrike-0.2.24}/deepstrike/runtime/remote_vpc_plane.py

@@ -9,6 +9,7 @@ import aiohttp
 
 from deepstrike._kernel import ToolCall, ToolSchema
 from deepstrike.providers.stream import StreamEvent, ToolResultEvent
+from deepstrike.tools.errors import format_tool_error
 from deepstrike.tools.registry import RegisteredTool
 from deepstrike.runtime.execution_plane import LocalExecutionPlane, RunContext
 from deepstrike.runtime.credential_vault import CredentialVault
@@ -97,4 +98,4 @@ class RemoteVpcPlane:
           result: dict = await resp.json()
           return result.get("output", ""), bool(result.get("isError", False))
     except Exception as exc:
-      return str(exc), True
+      return format_tool_error(exc), True