deepstrike 0.2.12__tar.gz → 0.2.14__tar.gz

{deepstrike-0.2.12 → deepstrike-0.2.14}/Cargo.lock

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

{deepstrike-0.2.12 → deepstrike-0.2.14}/Cargo.toml

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

{deepstrike-0.2.12 → deepstrike-0.2.14}/PKG-INFO

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

{deepstrike-0.2.12 → deepstrike-0.2.14}/crates/deepstrike-core/src/orchestration/workflow/mod.rs

@@ -307,11 +307,11 @@ impl WorkflowSpec {
 pub fn fanout_synthesize(workers: Vec<RuntimeTask>, synthesize: RuntimeTask) -> WorkflowSpec {
     let mut nodes: Vec<WorkflowNode> = workers
         .into_iter()
-        .map(|t| WorkflowNode::new(t.with_lane(TaskLane::Retrieve), AgentRole::Explore))
+        .map(|t| WorkflowNode::new(t.with_lane(TaskLane::new(TaskLane::RETRIEVE)), AgentRole::Explore))
         .collect();
     let worker_ids: Vec<usize> = (0..nodes.len()).collect();
     nodes.push(
-        WorkflowNode::new(synthesize.with_lane(TaskLane::Orchestrate), AgentRole::Plan)
+        WorkflowNode::new(synthesize.with_lane(TaskLane::new(TaskLane::ORCHESTRATE)), AgentRole::Plan)
             .with_depends_on(worker_ids),
     );
     WorkflowSpec::new(nodes)
@@ -329,11 +329,11 @@ pub fn fanout_synthesize(workers: Vec<RuntimeTask>, synthesize: RuntimeTask) ->
 pub fn generate_and_filter(generators: Vec<RuntimeTask>, filter: RuntimeTask) -> WorkflowSpec {
     let mut nodes: Vec<WorkflowNode> = generators
         .into_iter()
-        .map(|t| WorkflowNode::new(t.with_lane(TaskLane::Retrieve), AgentRole::Implement))
+        .map(|t| WorkflowNode::new(t.with_lane(TaskLane::new(TaskLane::RETRIEVE)), AgentRole::Implement))
         .collect();
     let gen_ids: Vec<usize> = (0..nodes.len()).collect();
     nodes.push(
-        WorkflowNode::new(filter.with_lane(TaskLane::Verify), AgentRole::Verify)
+        WorkflowNode::new(filter.with_lane(TaskLane::new(TaskLane::VERIFY)), AgentRole::Verify)
             .with_depends_on(gen_ids),
     );
     WorkflowSpec::new(nodes)
@@ -358,12 +358,12 @@ pub fn generate_and_filter(generators: Vec<RuntimeTask>, filter: RuntimeTask) ->
 pub fn verify_rules(rules: Vec<RuntimeTask>, skeptic: Option<RuntimeTask>) -> WorkflowSpec {
     let mut nodes: Vec<WorkflowNode> = rules
         .into_iter()
-        .map(|t| WorkflowNode::new(t.with_lane(TaskLane::Verify), AgentRole::Verify))
+        .map(|t| WorkflowNode::new(t.with_lane(TaskLane::new(TaskLane::VERIFY)), AgentRole::Verify))
         .collect();
     if let Some(skeptic) = skeptic {
         let verifier_ids: Vec<usize> = (0..nodes.len()).collect();
         nodes.push(
-            WorkflowNode::new(skeptic.with_lane(TaskLane::Verify), AgentRole::Verify)
+            WorkflowNode::new(skeptic.with_lane(TaskLane::new(TaskLane::VERIFY)), AgentRole::Verify)
                 .with_depends_on(verifier_ids),
         );
     }

deepstrike-0.2.14/crates/deepstrike-core/src/types/task.rs

@@ -0,0 +1,65 @@
+use serde::{Deserialize, Serialize};
+
+/// Freeform parallelism / classification hint for task scheduling.
+///
+/// The kernel transparently round-trips any string the caller sets.  Well-known
+/// constants are provided for the built-in workflow templates:
+///
+/// - `"orchestrate"` — serial, produces contracts; runs one at a time
+/// - `"implement"`   — serial, DAG chain; `TaskGraph::ready_tasks` enforces max 1
+/// - `"retrieve"`    — parallelisable; no mutual exclusion
+/// - `"verify"`      — parallelisable, isolated agent context
+///
+/// Callers may use any other value (e.g. `"prd-fill"`, `"eval"`) without kernel
+/// changes — the field is a transparent label, not a scheduling gate.
+#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq)]
+#[serde(transparent)]
+pub struct TaskLane(pub String);
+
+impl TaskLane {
+    pub const ORCHESTRATE: &'static str = "orchestrate";
+    pub const IMPLEMENT: &'static str = "implement";
+    pub const RETRIEVE: &'static str = "retrieve";
+    pub const VERIFY: &'static str = "verify";
+
+    pub fn new(s: impl Into<String>) -> Self {
+        Self(s.into())
+    }
+}
+
+impl std::fmt::Display for TaskLane {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&self.0)
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct RuntimeTask {
+    pub goal: String,
+    pub criteria: Vec<String>,
+    #[serde(default)]
+    pub metadata: serde_json::Value,
+    #[serde(default)]
+    pub lane: TaskLane,
+}
+
+impl RuntimeTask {
+    pub fn new(goal: impl Into<String>) -> Self {
+        Self {
+            goal: goal.into(),
+            criteria: Vec::new(),
+            metadata: serde_json::Value::Null,
+            lane: TaskLane::default(),
+        }
+    }
+
+    pub fn with_criteria(mut self, criteria: Vec<String>) -> Self {
+        self.criteria = criteria;
+        self
+    }
+
+    pub fn with_lane(mut self, lane: TaskLane) -> Self {
+        self.lane = lane;
+        self
+    }
+}

{deepstrike-0.2.12 → deepstrike-0.2.14}/deepstrike/providers/anthropic.py

@@ -99,8 +99,17 @@ class AnthropicProvider:
         # boundary; None ⇒ rolling-pair fallback.
         _apply_message_cache_control(msgs, frozen_prefix_len)
         if state_turn is not None:
-            role = "assistant" if state_turn.role == "assistant" else "user"
-            msgs.append({"role": role, "content": to_anthropic_content(state_turn)})
+            # Render through to_anthropic_messages so assistant tool_use blocks
+            # and tool-role tool_result parts are serialized correctly —
+            # to_anthropic_content only handles contentParts/content and would
+            # silently drop tool_calls.
+            state_msgs = to_anthropic_messages(
+                [state_turn],
+                native_replay=lambda message: self._native_assistant_blocks.get(
+                    self._assistant_replay_key(message)
+                ),
+            )
+            msgs.extend(state_msgs)
         return msgs
 
     def _build_tools(self, tools: list[ToolSchema], anchor_cache: bool) -> list[dict] | None:

{deepstrike-0.2.12 → deepstrike-0.2.14}/pyproject.toml

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

deepstrike-0.2.12/crates/deepstrike-core/src/types/task.rs

@@ -1,48 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-/// Parallelism hint for task scheduling and executor enforcement.
-///
-/// - `Orchestrate`: serial, produces contracts; runs one at a time
-/// - `Implement`: serial, DAG chain; `TaskGraph::ready_tasks` enforces max 1 running
-/// - `Retrieve`: parallelisable; no mutual exclusion between retrieve tasks
-/// - `Verify`: parallelisable, but each task must run in an isolated agent context
-#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq)]
-#[serde(rename_all = "snake_case")]
-pub enum TaskLane {
-    Orchestrate,
-    #[default]
-    Implement,
-    Retrieve,
-    Verify,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct RuntimeTask {
-    pub goal: String,
-    pub criteria: Vec<String>,
-    #[serde(default)]
-    pub metadata: serde_json::Value,
-    #[serde(default)]
-    pub lane: TaskLane,
-}
-
-impl RuntimeTask {
-    pub fn new(goal: impl Into<String>) -> Self {
-        Self {
-            goal: goal.into(),
-            criteria: Vec::new(),
-            metadata: serde_json::Value::Null,
-            lane: TaskLane::default(),
-        }
-    }
-
-    pub fn with_criteria(mut self, criteria: Vec<String>) -> Self {
-        self.criteria = criteria;
-        self
-    }
-
-    pub fn with_lane(mut self, lane: TaskLane) -> Self {
-        self.lane = lane;
-        self
-    }
-}