deepstrike 0.2.44__tar.gz → 0.2.46__tar.gz

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

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

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

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

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

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

{deepstrike-0.2.44 → deepstrike-0.2.46}/crates/deepstrike-core/src/runtime/kernel/runtime.rs

@@ -2352,6 +2352,19 @@ fn validate_run_config(config: &RunConfig, max_tokens: u32) -> Result<(), String
     {
         return Err("budget_grant reservation_id must be non-empty".to_string());
     }
+    // A zero-token grant admits no runnable work: the run would silently degrade to a
+    // tool-less final round. Reject it at admission so the host surfaces the exhausted
+    // reservation instead of a phantom completion.
+    if let Some(grant) = config
+        .budget_grant
+        .as_ref()
+        .filter(|grant| grant.tokens == Some(0))
+    {
+        return Err(format!(
+            "budget_grant tokens must be positive (zero-token grant admits no runnable work), reservation_id={}",
+            grant.reservation_id
+        ));
+    }
     if let Some(reliability) = &config.reliability {
         for (name, capacity) in [
             ("event_replay_capacity", reliability.event_replay_capacity),

{deepstrike-0.2.44 → deepstrike-0.2.46}/crates/deepstrike-core/src/runtime/kernel/tests.rs

@@ -167,6 +167,35 @@ fn prompt_reservations_cannot_consume_the_entire_context_window() {
     ));
 }
 
+#[test]
+fn zero_token_budget_grant_is_rejected_at_configure() {
+    let mut runtime = KernelRuntime::new(SchedulerBudget::default());
+    let rejected = runtime.step(KernelInput::new(KernelInputEvent::ConfigureRun {
+        config: RunConfig {
+            budget_grant: Some(BudgetGrant {
+                reservation_id: "r0".into(),
+                tokens: Some(0),
+                subagents: None,
+                rounds: None,
+            }),
+            ..RunConfig::default()
+        },
+    }));
+
+    assert!(matches!(
+        rejected.faults.as_slice(),
+        [KernelFault {
+            code: KernelFaultCode::InvalidConfig,
+            ..
+        }]
+    ));
+    assert!(
+        rejected.faults[0].message.contains("r0"),
+        "fault message must name the rejected reservation: {}",
+        rejected.faults[0].message
+    );
+}
+
 #[test]
 fn aborting_prepared_step_restores_the_exact_committed_runtime() {
     let mut runtime = KernelRuntime::new(SchedulerBudget::default());

{deepstrike-0.2.44 → deepstrike-0.2.46}/crates/deepstrike-core/src/scheduler/state_machine/mod.rs

@@ -829,29 +829,54 @@ impl LoopStateMachine {
         // A loop vehicle with no admitted round capacity must not make even one provider call.
         // The host may have raced another member between reading its durable loop log and reserve;
         // the reservation is the authoritative admission decision.
-        if self
+        let zero_round_grant = self
             .run_spec
             .as_ref()
             .and_then(|spec| spec.loop_round.as_ref())
             .is_some()
-            && self.budget_grant.as_ref().and_then(|grant| grant.rounds) == Some(0)
-        {
-            self.observations.push(KernelObservation::BudgetExceeded {
-                turn: self.turn,
-                budget: "rounds".into(),
-                operation_id: String::new(),
-                reservation_id: self
-                    .budget_grant
-                    .as_ref()
-                    .map(|grant| grant.reservation_id.clone()),
-            });
-            self.pending_pace = Some(crate::types::result::PaceDecision {
-                action: crate::types::result::PaceAction::Stop,
-                delay_ms: None,
-                reason: "round budget grant exhausted before start".into(),
-                coerced_from: None,
-            });
-            return self.terminate(TerminationReason::Completed, None);
+            && self.budget_grant.as_ref().and_then(|grant| grant.rounds) == Some(0);
+        // A zero-token grant is the same exhausted admission on the token axis, but it binds
+        // every vehicle, loop or not. Both axes can race to zero on one reservation; report
+        // each before terminating so no provider call is ever dispatched.
+        let zero_token_grant = self.budget_grant.as_ref().and_then(|grant| grant.tokens) == Some(0);
+        if zero_round_grant || zero_token_grant {
+            if zero_round_grant {
+                self.observations.push(KernelObservation::BudgetExceeded {
+                    turn: self.turn,
+                    budget: "rounds".into(),
+                    operation_id: String::new(),
+                    reservation_id: self
+                        .budget_grant
+                        .as_ref()
+                        .map(|grant| grant.reservation_id.clone()),
+                });
+                self.pending_pace = Some(crate::types::result::PaceDecision {
+                    action: crate::types::result::PaceAction::Stop,
+                    delay_ms: None,
+                    reason: "round budget grant exhausted before start".into(),
+                    coerced_from: None,
+                });
+            }
+            if zero_token_grant {
+                self.observations.push(KernelObservation::BudgetExceeded {
+                    turn: self.turn,
+                    budget: "tokens".into(),
+                    operation_id: String::new(),
+                    reservation_id: self
+                        .budget_grant
+                        .as_ref()
+                        .map(|grant| grant.reservation_id.clone()),
+                });
+            }
+            // Token exhaustion is the harder stop: prefer it when both axes are zero.
+            return self.terminate(
+                if zero_token_grant {
+                    TerminationReason::TokenBudget
+                } else {
+                    TerminationReason::Completed
+                },
+                None,
+            );
         }
 
         let user_msg = "Proceed with the task described in [TASK STATE].".to_string();

{deepstrike-0.2.44 → deepstrike-0.2.46}/crates/deepstrike-core/src/scheduler/state_machine/tests.rs

@@ -4340,6 +4340,34 @@ fn zero_round_grant_stops_before_provider_dispatch() {
     )));
 }
 
+#[test]
+fn zero_token_grant_stops_before_provider_dispatch() {
+    let mut sm = sm();
+    sm.set_budget_grant(crate::runtime::kernel::BudgetGrant {
+        reservation_id: "no-tokens".into(),
+        tokens: Some(0),
+        subagents: None,
+        rounds: None,
+    });
+
+    let action = sm.start(RuntimeTask::new("write"));
+
+    match action {
+        LoopAction::Done { result } => {
+            assert_eq!(result.termination, TerminationReason::TokenBudget);
+        }
+        other => panic!("expected Done, got {other:?}"),
+    }
+    assert_eq!(
+        sm.turn, 0,
+        "no provider turn may start without token capacity"
+    );
+    assert!(sm.take_observations().iter().any(|observation| matches!(
+        observation,
+        KernelObservation::BudgetExceeded { budget, .. } if budget == "tokens"
+    )));
+}
+
 #[test]
 fn pace_stop_routes_through_criteria_gate_then_honors_the_redecision() {
     let mut sm = loop_sm(crate::types::agent::LoopRoundSpec::default());

{deepstrike-0.2.44 → deepstrike-0.2.46}/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.46}/deepstrike/runtime/runner.py

@@ -278,6 +278,11 @@ class RuntimeOptions:
   # L1 (RunGroup): bind this runner to a governance domain shared by N peer sessions of one logical
   # run. The store must atomically reserve, settle, and release capacity. None ⇒ N=1.
   run_group: "RunGroup | None" = None
+  # Set by the SubAgentOrchestrator for host-derived child runs: the child still joins the
+  # `run_group` (lineage) and settles its actual terminal usage into the group ledger, but reserves
+  # no budget axes — group admission governs peer vehicles only. The child's caps stay local
+  # (kernel `max_total_tokens` policy + `resource_quota`). Never set this for a top-level run.
+  nested_group_vehicle: bool = False
   memory_policy: MemoryPolicy | dict[str, Any] | None = None
   os_profile: "OsProfile | None" = None
   tokenizer: str | None = None
@@ -747,6 +752,7 @@ class RuntimeRunner:
       spec=spec,
       manifest=manifest,
       session_log=self._opts.session_log,
+      tool_access=spec.tool_access or "filtered",
       harness=self._opts.sub_agent_harness,
     ))
 
@@ -2180,7 +2186,10 @@ class RuntimeRunner:
     # only local granted capacity and reports exact terminal usage against the same reservation id.
     group_budget_scope: GroupBudgetScope | None = None
     if self._opts.run_group is not None:
-      request = self._group_budget_request()
+      # A nested vehicle (derived by the SubAgentOrchestrator) joins for lineage and settles actual
+      # usage, but reserves no budget axes — group admission governs peer vehicles only; the
+      # child's caps stay local (kernel policy + resource quota).
+      request = ({}, {}) if self._opts.nested_group_vehicle else self._group_budget_request()
       group_budget_scope = await GroupBudgetScope.open(
         self._opts.run_group,
         GroupMember(session_id, self._opts.agent_id, kind="vehicle"),
@@ -2189,15 +2198,22 @@ class RuntimeRunner:
       )
       self._active_group_budget_scope = group_budget_scope
       granted = group_budget_scope.granted
-      kernel_apply(runtime, self._pending_observations, {
-        "kind": "configure_run",
-        "config": {"budget_grant": {
-          "reservation_id": group_budget_scope.reservation_id,
-          **({"tokens": granted.tokens} if granted.tokens is not None else {}),
-          **({"subagents": granted.subagents} if granted.subagents is not None else {}),
-          **({"rounds": granted.rounds} if granted.rounds is not None else {}),
-        }},
-      })
+      try:
+        kernel_apply(runtime, self._pending_observations, {
+          "kind": "configure_run",
+          "config": {"budget_grant": {
+            "reservation_id": group_budget_scope.reservation_id,
+            **({"tokens": granted.tokens} if granted.tokens is not None else {}),
+            **({"subagents": granted.subagents} if granted.subagents is not None else {}),
+            **({"rounds": granted.rounds} if granted.rounds is not None else {}),
+          }},
+        })
+      except Exception:
+        # Admission failure (e.g. the kernel rejecting a zero-capacity grant): release the
+        # reservation so it cannot linger in the group ledger, then surface the error.
+        await group_budget_scope.release()
+        self._active_group_budget_scope = None
+        raise
 
     if self._opts.memory_policy is not None:
       kernel_apply(runtime, self._pending_observations, {

{deepstrike-0.2.44 → deepstrike-0.2.46}/deepstrike/runtime/sub_agent_orchestrator.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import warnings
 from dataclasses import dataclass, replace
 from typing import TYPE_CHECKING, Any
 
@@ -141,6 +142,19 @@ def _resolve_tool_grants(ctx: SubAgentRunContext) -> tuple[Any, frozenset[str]]:
     return plane, _available_meta_tools(ctx.parent_opts)
   permitted = set(ctx.manifest.permitted_capability_ids)
   meta_tools = _derive_meta_tools(permitted, ctx.parent_opts)
+  # A "filtered" spawn with no capability grants and no meta-tools resolves to a deny-all plane —
+  # the child model sees zero tools and reports "no tools available". Warn the host (visible, not
+  # fatal) with the fix, mirroring execution_plane's failure-shaped-chunk warning. Exempt workflow
+  # nodes: not-inherit + workflow-node ⇒ quarantined ⇒ intentional deny-all, not a misconfiguration.
+  if not ctx.is_workflow_node and not permitted and not meta_tools:
+    warnings.warn(
+      f'spawned sub-agent "{ctx.spec.identity.agent_id}" resolved to zero tools (deny-all filter). '
+      "Mount tools as capabilities and grant via spec.capability_filter, or pass "
+      "spec.tool_access='inherit' to run on the parent's plane. If a tool-less child is intentional, "
+      "ignore this.",
+      RuntimeWarning,
+      stacklevel=2,
+    )
   return FilteredExecutionPlane(plane, permitted, meta_tools), meta_tools
 
 
@@ -200,6 +214,10 @@ def _build_child_opts(
     enable_plan_tool=ctx.parent_opts.enable_plan_tool if "update_plan" in meta_tools else None,
     # M5 v2.1: a workflow node's `start_workflow` flattens to the parent kernel (no nested pivot).
     is_workflow_node=ctx.is_workflow_node,
+    # Nested vehicle: the child joins the inherited run_group for lineage/settlement only — it
+    # must NOT re-reserve budget axes the parent already holds (that double-reserve squeezed the
+    # child's grant to 0 and the kernel stripped its first-turn tools).
+    nested_group_vehicle=True,
     # The child runs under ITS OWN spec, never the parent's: the replace() above would otherwise
     # leak the parent's ``run_spec`` (identity, capability filter — and a LoopDriver's armed
     # ``loop_round``, giving every child a phantom pace tool). A loop-node iteration carries its

{deepstrike-0.2.44 → deepstrike-0.2.46}/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.46}/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.46}/deepstrike/types/agent.py

@@ -81,6 +81,13 @@ class AgentRunSpec:
   # dict: {"max_rounds"?, "min_sleep_ms"?, "max_sleep_ms"?, "default_action"?}. Only set keys are
   # lowered to the kernel; None ⇒ no trap (a plain run).
   loop_round: dict[str, Any] | None = None
+  # Tool surface for a spawned sub-agent. Host-side only (like ``model_hint``) — NOT sent to the
+  # kernel (``agent_run_spec_to_kernel`` maps fields explicitly and omits it). Default "filtered"
+  # keeps the spawn path's deny-all-safe default: the child is filtered to its manifest grants, and a
+  # grant-less spawn resolves to zero tools. "inherit" runs the child on the parent's execution plane
+  # with the parent's meta-tool availability (same mechanism trusted workflow nodes use) — the child's
+  # surface is a subset of the parent's, never a privilege escalation.
+  tool_access: str = "filtered"  # "inherit" | "filtered"
 
 
 @dataclass

{deepstrike-0.2.44 → deepstrike-0.2.46}/pyproject.toml

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