deepstrike 0.2.44__tar.gz → 0.2.45__tar.gz

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

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

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

@@ -3,13 +3,13 @@ resolver = "2"
 members = ["crates/deepstrike-core", "crates/deepstrike-py"]
 
 [workspace.package]
-version = "0.2.44"
+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.44" }
+deepstrike-core = { path = "crates/deepstrike-core", version = "0.2.45" }
 notify = "6"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

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

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

{deepstrike-0.2.44 → 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.44 → 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.44 → 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.44 → deepstrike-0.2.45}/pyproject.toml

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