deepstrike 0.2.43__tar.gz → 0.2.45__tar.gz

{deepstrike-0.2.43 → deepstrike-0.2.45}/Cargo.lock

@@ -194,7 +194,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-core"
-version = "0.2.43"
+version = "0.2.45"
 dependencies = [
  "compact_str",
  "pretty_assertions",
@@ -206,7 +206,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-lab"
-version = "0.2.43"
+version = "0.2.45"
 dependencies = [
  "deepstrike-core",
  "serde",
@@ -216,7 +216,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-node"
-version = "0.2.43"
+version = "0.2.45"
 dependencies = [
  "compact_str",
  "deepstrike-core",
@@ -228,7 +228,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-py"
-version = "0.2.43"
+version = "0.2.45"
 dependencies = [
  "compact_str",
  "deepstrike-core",
@@ -239,7 +239,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-sdk"
-version = "0.2.43"
+version = "0.2.45"
 dependencies = [
  "async-stream",
  "async-trait",
@@ -273,7 +273,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-wasm"
-version = "0.2.43"
+version = "0.2.45"
 dependencies = [
  "compact_str",
  "deepstrike-core",

{deepstrike-0.2.43 → deepstrike-0.2.45}/Cargo.toml

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

{deepstrike-0.2.43 → deepstrike-0.2.45}/PKG-INFO

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

{deepstrike-0.2.43 → deepstrike-0.2.45}/crates/deepstrike-core/src/runtime/kernel/protocol.rs

@@ -92,6 +92,13 @@ pub struct KernelInput {
 }
 
 impl KernelInput {
+    /// Operation identity used by [`Self::new`] for in-process callers. Hosts that correlate
+    /// against it (e.g. a `cancel_operation` for an operation started via `new`) must use this
+    /// constant, never a re-typed literal. NOT for durable wire hosts: anything keyed by
+    /// `(session, operation)` in storage that outlives the process needs a unique identity via
+    /// [`Self::correlated`].
+    pub const LOCAL_OPERATION_ID: &'static str = "local-operation";
+
     /// Build an in-process input for callers that do not cross a durable wire boundary.
     /// Wire hosts should use [`Self::correlated`] with their durable identities.
     pub fn new(event: KernelInputEvent) -> Self {
@@ -99,7 +106,7 @@ impl KernelInput {
         static LOCAL_EVENT_SEQUENCE: AtomicU64 = AtomicU64::new(1);
         let event_seq = LOCAL_EVENT_SEQUENCE.fetch_add(1, Ordering::Relaxed);
         Self::correlated(
-            "local-operation",
+            Self::LOCAL_OPERATION_ID,
             format!("local-event-{event_seq}"),
             0,
             event,

{deepstrike-0.2.43 → deepstrike-0.2.45}/crates/deepstrike-py/src/lib.rs

@@ -860,7 +860,10 @@ impl RenderedContext {
 
 // ──────────────────────────────────────── KernelRuntime ────────────────────────────────────
 
-#[pyclass]
+// `weakref` so the SDK can key per-runtime wire state in a WeakKeyDictionary — a module dict
+// keyed by id() aliases recycled addresses (a new runtime inherits a dead one's operation
+// identity) and leaks an entry per runtime.
+#[pyclass(weakref)]
 struct KernelRuntime {
     inner: RustKernelRuntime,
 }

{deepstrike-0.2.43 → deepstrike-0.2.45}/deepstrike/runtime/execution_plane.py

@@ -248,9 +248,11 @@ class LocalExecutionPlane:
       audit=_audit,
     )
     try:
-      kwargs = json.loads(call.arguments or "{}")
-      original_args_str = json.dumps(kwargs)
-      validation = validate_tool_arguments(registered.schema.parameters, kwargs)
+      raw_kwargs = json.loads(call.arguments or "{}")
+      original_args_str = json.dumps(raw_kwargs)
+      # validation["args"], not raw_kwargs, from here on: a oneOf/anyOf ROOT accepts a repaired
+      # probe deep-copy — the original dict never sees those repairs (auto-casts, strips, defaults).
+      validation = validate_tool_arguments(registered.schema.parameters, raw_kwargs)
       if validation.get("error"):
         yield ToolResultEvent(
           call_id=call.id,
@@ -261,6 +263,7 @@ class LocalExecutionPlane:
           error_kind="recoverable",
         )
         return
+      kwargs = validation["args"]
       if validation.get("repaired"):
         yield ToolArgumentRepairedEvent(
           call_id=call.id,

{deepstrike-0.2.43 → deepstrike-0.2.45}/deepstrike/runtime/kernel_step.py

@@ -4,6 +4,7 @@ import json
 import re
 import time
 import uuid
+import weakref
 from dataclasses import dataclass
 from types import SimpleNamespace
 from typing import Any
@@ -13,7 +14,11 @@ from deepstrike.providers.base import ContextBudgetOverflow, RenderedContext
 
 
 KERNEL_ABI_VERSION = 2
-_wire_states: dict[int, tuple[str, int]] = {}
+# Keyed by the runtime OBJECT, not id(runtime): a plain dict keyed by id() aliases recycled
+# addresses (a new runtime inherits a dead one's operation identity — fatal once a durable log
+# keys chains by that identity) and leaks an entry per runtime. WeakKeyDictionary mirrors the
+# Node/WASM WeakMap; the pyo3 KernelRuntime declares `weakref` support for exactly this.
+_wire_states: "weakref.WeakKeyDictionary[Any, tuple[str, int]]" = weakref.WeakKeyDictionary()
 
 
 def snapshot_kernel_runtime(runtime: Any) -> dict[str, Any]:
@@ -24,14 +29,14 @@ def restore_kernel_runtime(runtime: Any, snapshot: dict[str, Any]) -> None:
   runtime.restore(json.dumps(snapshot))
   operation_id = snapshot.get("operation_id")
   if not operation_id:
-    _wire_states.pop(id(runtime), None)
+    _wire_states.pop(runtime, None)
     return
   next_sequence = 1
   for accepted in snapshot.get("accepted_inputs") or []:
     match = re.search(r"-event-(\d+)$", str(accepted.get("event_id") or ""))
     if match:
       next_sequence = max(next_sequence, int(match.group(1)) + 1)
-  _wire_states[id(runtime)] = (str(operation_id), next_sequence)
+  _wire_states[runtime] = (str(operation_id), next_sequence)
 
 
 @dataclass
@@ -373,12 +378,11 @@ def _action_from_kernel(raw: dict[str, Any]) -> KernelRunnerAction:
 
 
 def _step_input(runtime: Any, event: dict[str, Any]) -> str:
-  key = id(runtime)
-  state = _wire_states.get(key)
+  state = _wire_states.get(runtime)
   if state is None:
     state = (f"python-operation-{uuid.uuid4()}", 1)
   operation_id, sequence = state
-  _wire_states[key] = (operation_id, sequence + 1)
+  _wire_states[runtime] = (operation_id, sequence + 1)
   correlated_event = (
     {**event, "operation_id": operation_id}
     if event.get("kind") == "cancel_operation"

{deepstrike-0.2.43 → deepstrike-0.2.45}/deepstrike/runtime/large_result_spool.py

@@ -16,9 +16,16 @@ class LargeResultSpool:
     self._max_age_seconds = max_age_seconds
     self._active_writes: dict[str, asyncio.Lock] = {}
 
-  async def persist_output(self, call_id: str, content: str) -> str:
+  @staticmethod
+  def _call_key(session_id: str, call_id: str) -> str:
+    # Session-scoped: the spool dir is shared across sessions and outlives runs, while vendor
+    # call ids can be index-style ("call_0") and repeat — an unscoped key lets read_result in
+    # one session fetch another session's spooled output.
+    return hashlib.sha256(f"{session_id}\x00{call_id}".encode("utf-8")).hexdigest()[:32]
+
+  async def persist_output(self, session_id: str, call_id: str, content: str) -> str:
     digest = hashlib.sha256(content.encode("utf-8")).hexdigest()[:16]
-    call_key = hashlib.sha256(call_id.encode("utf-8")).hexdigest()[:32]
+    call_key = self._call_key(session_id, call_id)
     self._spool_dir.mkdir(parents=True, exist_ok=True)
     path = self._spool_dir / f"{call_key}-{digest}.txt"
     path_str = str(path)
@@ -50,16 +57,16 @@ class LargeResultSpool:
       return path.read_text(encoding="utf-8")
     return await asyncio.get_running_loop().run_in_executor(None, _read)
 
-  async def find_by_call_id(self, call_id: str) -> str | None:
+  async def find_by_call_id(self, session_id: str, call_id: str) -> str | None:
     """O7: locate a spooled output by the tool call's id (the ``read_result`` meta-tool only
     knows ``call_id``, not the content-hashed file name ``persist_output`` chose). Scans the
-    spool directory for the hashed call-key prefix; returns ``None`` if nothing
+    spool directory for the hashed session-scoped call-key prefix; returns ``None`` if nothing
     was ever spooled for that call."""
     if not self._spool_dir.is_dir():
       return None
 
     def _find() -> Path | None:
-      call_key = hashlib.sha256(call_id.encode("utf-8")).hexdigest()[:32]
+      call_key = self._call_key(session_id, call_id)
       matches = sorted(self._spool_dir.glob(f"{call_key}-*.txt"))
       return matches[0] if matches else None
 

{deepstrike-0.2.43 → deepstrike-0.2.45}/deepstrike/runtime/runner.py

@@ -1864,7 +1864,7 @@ class RuntimeRunner:
     from deepstrike.runtime.large_result_spool import LargeResultSpool
     spool = self._opts.result_spool or LargeResultSpool()
     try:
-      full = await spool.find_by_call_id(call_id)
+      full = await spool.find_by_call_id(session_id, call_id)
     except Exception:
       full = None
 
@@ -2440,7 +2440,7 @@ class RuntimeRunner:
         spool_ref = None
         error = None
         try:
-          spool_ref = await spool.persist_output(action.call_id or "", action.output or "")
+          spool_ref = await spool.persist_output(session_id, action.call_id or "", action.output or "")
         except Exception as exc:
           error = format_tool_error(exc)
         action = kernel_action(runtime, self._pending_observations, {

{deepstrike-0.2.43 → deepstrike-0.2.45}/deepstrike/tools/execution.py

@@ -22,7 +22,9 @@ async def execute_tools(
             if validation.get("error"):
                 results.append(ToolResult(call_id=call.id, output=f"invalid arguments: {validation['error']}", is_error=True))
                 continue
-            output = await tool(**kwargs)
+            # validation["args"], not kwargs: a oneOf/anyOf ROOT accepts a repaired probe
+            # deep-copy — the original dict never sees those repairs (auto-casts, strips, defaults).
+            output = await tool(**validation["args"])
             if isinstance(output, AsyncIterable):
                 chunks = []
                 async for chunk in output:

{deepstrike-0.2.43 → deepstrike-0.2.45}/deepstrike/tools/registry.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 import copy
 import inspect
 import json
+import re
 from collections.abc import AsyncIterable
 from typing import Any, Callable
 from deepstrike._kernel import ToolSchema
@@ -73,11 +74,13 @@ def validate_tool_arguments(schema_json: str, args: dict[str, Any]) -> dict[str,
     try:
         schema = json.loads(schema_json)
     except Exception:
-        return {"error": "invalid tool schema", "repaired": False}
+        return {"error": "invalid tool schema", "repaired": False, "args": args}
     state = {"repaired": False}
     wrapper = {"root": args}
     error = _validate_value(schema, wrapper, "root", "$", state)
-    return {"error": error, "repaired": state["repaired"]}
+    # A oneOf/anyOf ROOT replaces the value with its accepted probe deep-copy — in-place mutation
+    # of the caller's dict only covers non-union roots. Callers must use the returned "args".
+    return {"error": error, "repaired": state["repaired"], "args": wrapper["root"]}
 
 
 def _validate_value(schema: dict[str, Any], parent: Any, key: Any, path: str, state: dict[str, bool]) -> str | None:
@@ -200,10 +203,65 @@ def _validate_value(schema: dict[str, Any], parent: Any, key: Any, path: str, st
             return f"{path} must be integer"
         elif expected == "boolean" and not isinstance(value, bool):
             return f"{path} must be boolean"
+        elif expected == "null" and value is not None:
+            return f"{path} must be null"
     elif path == "$" and not isinstance(value, dict):
         return f"{path} must be object"
 
     enum_values = schema.get("enum")
     if enum_values is not None and value not in enum_values:
         return f"{path} must be one of enum values"
+    # `const` is THE discriminator convention for oneOf variants (kind: {const: "edit"}). Without
+    # it, union branches match on required+type alone and the WRONG branch can win — then its
+    # allow-list strips keys the right branch declared.
+    if "const" in schema:
+        want = schema["const"]
+        if isinstance(want, bool) or isinstance(value, bool):
+            matches = value is want
+        else:
+            matches = value == want
+        if not matches:
+            return f"{path} must equal the const value {json.dumps(want)}"
+    # Constraint keywords, checked per the value's actual type (JSON Schema semantics: string
+    # constraints ignore non-strings, etc.). Keywords outside this set (allOf, multipleOf,
+    # uniqueItems, format, if/then/else, …) are ignored, not rejected.
+    if isinstance(value, str):
+        min_length = schema.get("minLength")
+        if isinstance(min_length, int) and len(value) < min_length:
+            return f"{path} must be at least {min_length} characters"
+        max_length = schema.get("maxLength")
+        if isinstance(max_length, int) and len(value) > max_length:
+            return f"{path} must be at most {max_length} characters"
+        pattern = schema.get("pattern")
+        if isinstance(pattern, str):
+            try:
+                compiled = re.compile(pattern)
+            except re.error:
+                compiled = None  # author-side bad regex: skip, never fail the call
+            if compiled is not None and compiled.search(value) is None:
+                return f"{path} must match pattern {pattern}"
+    elif isinstance(value, (int, float)) and not isinstance(value, bool):
+        for keyword, ok in (
+            ("minimum", lambda bound: value >= bound),
+            ("maximum", lambda bound: value <= bound),
+            ("exclusiveMinimum", lambda bound: value > bound),
+            ("exclusiveMaximum", lambda bound: value < bound),
+        ):
+            bound = schema.get(keyword)
+            if isinstance(bound, (int, float)) and not isinstance(bound, bool) and not ok(bound):
+                op = {"minimum": ">=", "maximum": "<=", "exclusiveMinimum": ">", "exclusiveMaximum": "<"}[keyword]
+                return f"{path} must be {op} {bound}"
+    elif isinstance(value, list):
+        min_items = schema.get("minItems")
+        if isinstance(min_items, int) and len(value) < min_items:
+            return f"{path} must have at least {min_items} items"
+        max_items = schema.get("maxItems")
+        if isinstance(max_items, int) and len(value) > max_items:
+            return f"{path} must have at most {max_items} items"
+    # `not`: probe on a deep copy so a matching (= rejected) subschema's repairs never leak out.
+    not_schema = schema.get("not")
+    if isinstance(not_schema, dict):
+        probe = {"v": copy.deepcopy(value)}
+        if _validate_value(not_schema, probe, "v", path, {"repaired": False}) is None:
+            return f"{path} must not match the disallowed shape"
     return None

{deepstrike-0.2.43 → deepstrike-0.2.45}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "deepstrike"
-version = "0.2.43"
+version = "0.2.45"
 requires-python = ">=3.10"
 readme = "README.md"
 dependencies = [