deepstrike 0.2.72__tar.gz → 0.2.73__tar.gz

{deepstrike-0.2.72 → deepstrike-0.2.73}/Cargo.lock

@@ -254,7 +254,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-core"
-version = "0.2.72"
+version = "0.2.73"
 dependencies = [
  "compact_str",
  "deepstrike-tokenizer",
@@ -268,7 +268,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-node"
-version = "0.2.72"
+version = "0.2.73"
 dependencies = [
  "compact_str",
  "deepstrike-core",
@@ -280,7 +280,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-py"
-version = "0.2.72"
+version = "0.2.73"
 dependencies = [
  "compact_str",
  "deepstrike-core",
@@ -291,7 +291,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-sdk"
-version = "0.2.72"
+version = "0.2.73"
 dependencies = [
  "async-stream",
  "async-trait",
@@ -327,7 +327,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-tokenizer"
-version = "0.2.72"
+version = "0.2.73"
 dependencies = [
  "pretty_assertions",
  "tiktoken-rs",
@@ -335,7 +335,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-wasm"
-version = "0.2.72"
+version = "0.2.73"
 dependencies = [
  "compact_str",
  "deepstrike-core",

{deepstrike-0.2.72 → deepstrike-0.2.73}/Cargo.toml

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

{deepstrike-0.2.72 → deepstrike-0.2.73}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepstrike
-Version: 0.2.72
+Version: 0.2.73
 Requires-Dist: httpx>=0.27
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: anyio>=4.0
@@ -42,40 +42,28 @@ maturin develop --manifest-path crates/deepstrike-py/Cargo.toml
 
 ```python
 import asyncio
-from deepstrike import (
-    FileSessionLog,
-    InMemorySessionLog,
-    LocalExecutionPlane,
-    OpenAIProvider,
-    RuntimeOptions,
-    RuntimeRunner,
-    collect_text,
-    tool,
-)
+from deepstrike import OpenAIProvider, create_agent, tool
 
 @tool
 async def add(x: int, y: int) -> str:
     """Add two numbers."""
     return str(x + y)
 
-plane = LocalExecutionPlane().register(add)
-runner = RuntimeRunner(RuntimeOptions(
-    provider=OpenAIProvider(api_key="sk-...", model="gpt-5-mini"),
-    session_log=FileSessionLog(".deepstrike/sessions"),
-    execution_plane=plane,
-    max_tokens=4096,
-))
+agent = create_agent(
+    "math",
+    model="openai/gpt-5-mini",
+    runtime_binding={"provider": OpenAIProvider(api_key="sk-...", model="gpt-5-mini")},
+    tools=[add],
+)
 
-asyncio.run(collect_text(runner.run(
-    session_id="math-1",
-    goal="What is 17 + 28?",
-)))
+result = asyncio.run(agent.run("What is 17 + 28?", session_id="math-1"))
+print(result["output"])
 # => "45"
 ```
 
 ### Recipes — the canonical entry points
 
-Most apps need one of two shapes. Start with the facades; drop to `RuntimeRunner` for streaming, tools, signals, memory, or governance.
+Most apps start with `Agent`; use `RuntimeRunner` from the runtime submodule only for custom host control.
 
 ```python
 from deepstrike import run_agent, run_fanout

{deepstrike-0.2.72 → deepstrike-0.2.73}/README.md

@@ -28,40 +28,28 @@ maturin develop --manifest-path crates/deepstrike-py/Cargo.toml
 
 ```python
 import asyncio
-from deepstrike import (
-    FileSessionLog,
-    InMemorySessionLog,
-    LocalExecutionPlane,
-    OpenAIProvider,
-    RuntimeOptions,
-    RuntimeRunner,
-    collect_text,
-    tool,
-)
+from deepstrike import OpenAIProvider, create_agent, tool
 
 @tool
 async def add(x: int, y: int) -> str:
     """Add two numbers."""
     return str(x + y)
 
-plane = LocalExecutionPlane().register(add)
-runner = RuntimeRunner(RuntimeOptions(
-    provider=OpenAIProvider(api_key="sk-...", model="gpt-5-mini"),
-    session_log=FileSessionLog(".deepstrike/sessions"),
-    execution_plane=plane,
-    max_tokens=4096,
-))
+agent = create_agent(
+    "math",
+    model="openai/gpt-5-mini",
+    runtime_binding={"provider": OpenAIProvider(api_key="sk-...", model="gpt-5-mini")},
+    tools=[add],
+)
 
-asyncio.run(collect_text(runner.run(
-    session_id="math-1",
-    goal="What is 17 + 28?",
-)))
+result = asyncio.run(agent.run("What is 17 + 28?", session_id="math-1"))
+print(result["output"])
 # => "45"
 ```
 
 ### Recipes — the canonical entry points
 
-Most apps need one of two shapes. Start with the facades; drop to `RuntimeRunner` for streaming, tools, signals, memory, or governance.
+Most apps start with `Agent`; use `RuntimeRunner` from the runtime submodule only for custom host control.
 
 ```python
 from deepstrike import run_agent, run_fanout

{deepstrike-0.2.72 → deepstrike-0.2.73}/crates/deepstrike-core/src/context/measurement.rs

@@ -2,8 +2,7 @@
 //! ("measure provider-visible input, never underestimate") requires between what a request is
 //! *estimated* to cost before it is sent (`PromptMeasurement`, this module), what the provider
 //! actually reports back (`ProviderUsage`, Node/Python Host layer — not this crate). This module
-//! only defines a preflight fact. The `MeasurePrompt` wire tag is reserved, but A-00R removed its
-//! scheduler producer until request fingerprinting and durable replay semantics are defined.
+//! only defines a host-side preflight fact for provider-visible request preparation.
 
 use serde::{Deserialize, Serialize};
 

{deepstrike-0.2.72 → deepstrike-0.2.73}/crates/deepstrike-core/src/runtime/kernel/wire/config.rs

@@ -2557,7 +2557,7 @@ mod tests {
             serde_json::from_value::<HostEffectSupport>(json!({ "supported": ["load_payload"] }))
                 .is_ok()
         );
-        assert_eq!(EffectKindTag::ALL.len(), 11);
+        assert_eq!(EffectKindTag::ALL.len(), 10);
     }
 
     // -----------------------------------------------------------------------------------------
@@ -2926,17 +2926,12 @@ mod tests {
         // required kind from the
         // support declaration must be refused — and the rejection must name the kind, because a
         // host reading it has to know which declaration to fix. Iterating `ALL` also means a new
-        // effect kind cannot be added without deciding what switches it on. `MeasurePrompt` is a
-        // reserved wire shape with no scheduler producer after SPC-013 A-00R, so it deliberately
-        // imposes no host-support requirement.
+        // effect kind cannot be added without deciding what switches it on.
         let full = fully_populated_config();
         full.resolve(&defaults())
             .expect("declaring every kind satisfies every trigger");
 
-        for dropped in EffectKindTag::ALL
-            .into_iter()
-            .filter(|kind| *kind != EffectKindTag::MeasurePrompt)
-        {
+        for dropped in EffectKindTag::ALL {
             let mut config = full.clone();
             config.host_effect_support = HostEffectSupport::new(
                 EffectKindTag::ALL

{deepstrike-0.2.72 → deepstrike-0.2.73}/crates/deepstrike-core/src/runtime/kernel/wire/driver/effects.rs

@@ -220,10 +220,6 @@ impl CanonicalOperationDriver {
             EffectSuccess::PayloadLoaded(loaded) => {
                 self.commit_payload_load(context, effect_id, loaded)
             }
-            EffectSuccess::PromptMeasured(_) => Err(KernelFault::new(
-                KernelFaultCode::UnexpectedEffectOutcome,
-                "prompt measurement outcomes are reserved but adaptive measurement has no scheduler producer",
-            )),
         }
     }
 
@@ -462,10 +458,6 @@ impl CanonicalOperationDriver {
                 step.focus = self.focus.clone();
                 Ok(step)
             }
-            EffectKindTag::MeasurePrompt => Err(KernelFault::new(
-                KernelFaultCode::UnexpectedEffectOutcome,
-                "prompt measurement failures are reserved but adaptive measurement has no scheduler producer",
-            )),
         }
     }
 

{deepstrike-0.2.72 → deepstrike-0.2.73}/crates/deepstrike-core/src/runtime/kernel/wire/effect.rs

@@ -26,7 +26,7 @@ use serde::de::{self, Deserializer, Visitor};
 use serde::{Deserialize, Serialize, Serializer};
 
 use crate::context::execution::ContextCandidate;
-use crate::context::measurement::{PromptMeasurement, ToolMeasurement};
+use crate::context::measurement::ToolMeasurement;
 use crate::types::durable_content::DurableContent;
 
 use super::root::{LogicalAgentSpec, MessageRole};
@@ -260,8 +260,6 @@ pub enum EffectKind {
     /// to it instead of scanning a session log for the original bytes (§7.10 rule 4).
     LoadPayload(LoadPayloadEffect),
     EvaluateMilestone(EvaluateMilestoneEffect),
-    /// spc_011-C-02: preflight prompt-token measurement — see [`MeasurePromptEffect`].
-    MeasurePrompt(MeasurePromptEffect),
 }
 
 impl EffectKind {
@@ -277,7 +275,6 @@ impl EffectKind {
             Self::ArchivePageOut(_) => EffectKindTag::ArchivePageOut,
             Self::LoadPayload(_) => EffectKindTag::LoadPayload,
             Self::EvaluateMilestone(_) => EffectKindTag::EvaluateMilestone,
-            Self::MeasurePrompt(_) => EffectKindTag::MeasurePrompt,
         }
     }
 }
@@ -301,12 +298,10 @@ pub enum EffectKindTag {
     ArchivePageOut,
     LoadPayload,
     EvaluateMilestone,
-    /// spc_011-C-02.
-    MeasurePrompt,
 }
 
 impl EffectKindTag {
-    pub const ALL: [Self; 11] = [
+    pub const ALL: [Self; 10] = [
         Self::CallProvider,
         Self::ExecuteTools,
         Self::RequestApproval,
@@ -317,7 +312,6 @@ impl EffectKindTag {
         Self::ArchivePageOut,
         Self::LoadPayload,
         Self::EvaluateMilestone,
-        Self::MeasurePrompt,
     ];
 
     pub fn as_str(self) -> &'static str {
@@ -332,7 +326,6 @@ impl EffectKindTag {
             Self::ArchivePageOut => "archive_page_out",
             Self::LoadPayload => "load_payload",
             Self::EvaluateMilestone => "evaluate_milestone",
-            Self::MeasurePrompt => "measure_prompt",
         }
     }
 
@@ -349,7 +342,6 @@ impl EffectKindTag {
             Self::ArchivePageOut => EffectSuccessTag::PageOutArchived,
             Self::LoadPayload => EffectSuccessTag::PayloadLoaded,
             Self::EvaluateMilestone => EffectSuccessTag::MilestoneEvaluated,
-            Self::MeasurePrompt => EffectSuccessTag::PromptMeasured,
         }
     }
 }
@@ -375,27 +367,6 @@ pub struct CallProviderEffect {
     pub tools: Vec<ToolSchema>,
 }
 
-/// spc_011-C-02: a preflight token-count request. Reuses the same `RenderedContext`/`ToolSchema`
-/// shape `CallProviderEffect` already carries, rather than inventing a parallel candidate-request
-/// type — the kernel is asking "how many tokens would *this* request cost", the same request it
-/// would otherwise hand to `CallProvider`.
-///
-/// spc_011-C-06: no `provider`/`model` fields, matching `CallProviderEffect` exactly. An earlier
-/// draft of this struct carried both, reasoning that "the answer is meaningless without knowing
-/// which vendor should answer it" — but the kernel has no provider/model identity to put there:
-/// `OperationConfig` carries no such field, vendor selection is entirely a Host-side concern (the
-/// same Host that will execute `CallProvider` for this operation already knows which provider it
-/// dispatches to, the same way it already resolves that for `CallProviderEffect`, which has never
-/// carried these fields). This surfaced only when 011-C-06 tried to actually construct one inside
-/// the kernel and found nothing to put in `provider`/`model`.
-#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct MeasurePromptEffect {
-    pub context: RenderedContext,
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub tools: Vec<ToolSchema>,
-}
-
 #[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct ExecuteToolsEffect {
@@ -777,8 +748,6 @@ pub enum EffectSuccess {
     PageOutArchived(PageOutArchivedSuccess),
     PayloadLoaded(PayloadLoadedSuccess),
     MilestoneEvaluated(MilestoneEvaluatedSuccess),
-    /// spc_011-C-02.
-    PromptMeasured(PromptMeasuredSuccess),
 }
 
 impl EffectSuccess {
@@ -794,7 +763,6 @@ impl EffectSuccess {
             Self::PageOutArchived(_) => EffectSuccessTag::PageOutArchived,
             Self::PayloadLoaded(_) => EffectSuccessTag::PayloadLoaded,
             Self::MilestoneEvaluated(_) => EffectSuccessTag::MilestoneEvaluated,
-            Self::PromptMeasured(_) => EffectSuccessTag::PromptMeasured,
         }
     }
 }
@@ -813,12 +781,10 @@ pub enum EffectSuccessTag {
     PageOutArchived,
     PayloadLoaded,
     MilestoneEvaluated,
-    /// spc_011-C-02.
-    PromptMeasured,
 }
 
 impl EffectSuccessTag {
-    pub const ALL: [Self; 11] = [
+    pub const ALL: [Self; 10] = [
         Self::Provider,
         Self::Tools,
         Self::Approval,
@@ -829,7 +795,6 @@ impl EffectSuccessTag {
         Self::PageOutArchived,
         Self::PayloadLoaded,
         Self::MilestoneEvaluated,
-        Self::PromptMeasured,
     ];
 
     pub fn as_str(self) -> &'static str {
@@ -844,7 +809,6 @@ impl EffectSuccessTag {
             Self::PageOutArchived => "page_out_archived",
             Self::PayloadLoaded => "payload_loaded",
             Self::MilestoneEvaluated => "milestone_evaluated",
-            Self::PromptMeasured => "prompt_measured",
         }
     }
 
@@ -862,7 +826,6 @@ impl EffectSuccessTag {
             Self::PageOutArchived => EffectKindTag::ArchivePageOut,
             Self::PayloadLoaded => EffectKindTag::LoadPayload,
             Self::MilestoneEvaluated => EffectKindTag::EvaluateMilestone,
-            Self::PromptMeasured => EffectKindTag::MeasurePrompt,
         }
     }
 }
@@ -1153,14 +1116,6 @@ pub struct MilestoneCheckResult {
     pub notes: String,
 }
 
-/// spc_011-C-02: the answer to a `MeasurePrompt` effect — one [`PromptMeasurement`] fact, wrapped
-/// the same way every other effect wraps its one matching success payload.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct PromptMeasuredSuccess {
-    pub measurement: PromptMeasurement,
-}
-
 // ---------------------------------------------------------------------------------------------
 // §7.10 · inline / external payload
 // ---------------------------------------------------------------------------------------------
@@ -1354,9 +1309,7 @@ mod tests {
 
     use serde_json::{Value, json};
 
-    use crate::context::measurement::{
-        MeasurementConfidence, MeasurementSource, PromptMeasurement, ToolMeasurement,
-    };
+    use crate::context::measurement::ToolMeasurement;
 
     use super::super::*;
 
@@ -1551,10 +1504,6 @@ mod tests {
                     phase_id: "phase-2".to_string(),
                 },
             }),
-            EffectKind::MeasurePrompt(MeasurePromptEffect {
-                context: RenderedContext::default(),
-                tools: Vec::new(),
-            }),
         ]
     }
 
@@ -1657,15 +1606,6 @@ mod tests {
                     notes: String::new(),
                 },
             }),
-            EffectSuccess::PromptMeasured(PromptMeasuredSuccess {
-                measurement: PromptMeasurement {
-                    input_tokens: 4200,
-                    source: MeasurementSource::Native {
-                        provider: "anthropic".to_string(),
-                    },
-                    confidence: MeasurementConfidence::Exact,
-                },
-            }),
         ]
     }
 
@@ -1682,7 +1622,7 @@ mod tests {
     // -----------------------------------------------------------------------------------------
 
     #[test]
-    fn the_effect_union_is_exactly_the_eleven_host_executable_actions() {
+    fn the_effect_union_is_exactly_the_ten_host_executable_actions() {
         let tags: BTreeSet<&str> = EffectKindTag::ALL.iter().map(|tag| tag.as_str()).collect();
         assert_eq!(
             tags,
@@ -1697,10 +1637,9 @@ mod tests {
                 "archive_page_out",
                 "load_payload",
                 "evaluate_milestone",
-                "measure_prompt",
             ])
         );
-        assert_eq!(EffectKindTag::ALL.len(), 11);
+        assert_eq!(EffectKindTag::ALL.len(), 10);
 
         let sampled: Vec<EffectKindTag> = effect_samples().iter().map(EffectKind::tag).collect();
         assert_eq!(

{deepstrike-0.2.72 → deepstrike-0.2.73}/crates/deepstrike-core/src/runtime/kernel/wire/projection.rs

@@ -9,7 +9,7 @@ use serde::{Deserialize, Serialize};
 use super::driver::PlannedStep;
 use super::effect::{
     ArchivePageOutEffect, CallProviderEffect, EffectKind, EffectKindTag, EvaluateMilestoneEffect,
-    ExecuteToolsEffect, KernelEffect, LoadPayloadEffect, MeasurePromptEffect, PersistMemoryEffect,
+    ExecuteToolsEffect, KernelEffect, LoadPayloadEffect, PersistMemoryEffect,
     PreemptTasksEffect, QueryMemoryEffect, RequestApprovalEffect, SpawnTasksEffect,
 };
 use super::scalar::EffectId;
@@ -77,11 +77,6 @@ pub enum CanonicalHostAction {
         causation_input_id: super::scalar::InputId,
         payload: EvaluateMilestoneEffect,
     },
-    MeasurePrompt {
-        effect_id: EffectId,
-        causation_input_id: super::scalar::InputId,
-        payload: MeasurePromptEffect,
-    },
 }
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -152,11 +147,6 @@ pub fn project_effect(effect: &KernelEffect) -> CanonicalHostAction {
             causation_input_id,
             payload: payload.clone(),
         },
-        EffectKind::MeasurePrompt(payload) => CanonicalHostAction::MeasurePrompt {
-            effect_id,
-            causation_input_id,
-            payload: payload.clone(),
-        },
     }
 }
 

{deepstrike-0.2.72 → deepstrike-0.2.73}/deepstrike/__init__.py

@@ -201,7 +201,7 @@ from deepstrike.types.agent import (
     workflow_budget_note,
     fanout_synthesize, generate_and_filter, verify_rules, gen_eval,
 )
-from deepstrike.agent import Agent, AgentDefinition, AgentMemory, MemoryReference, ModelRef
+from deepstrike.agent import Agent, AgentDefinition, AgentMemory, MemoryReference, ModelRef, create_agent
 from deepstrike.agent_ir import lower_agent, normalize_agent
 from deepstrike.runtime.durable_content import (
     DurableContentError,
@@ -382,7 +382,7 @@ __all__ = [
     "SkillMetadata",
     # Sub-agent isolation
     "AgentIdentity", "AgentCapabilityFilter", "AgentRunSpec",
-    "Agent", "AgentDefinition", "AgentMemory", "MemoryReference", "ModelRef", "lower_agent", "normalize_agent",
+    "Agent", "create_agent", "AgentDefinition", "AgentMemory", "MemoryReference", "ModelRef", "lower_agent", "normalize_agent",
     "AgentProcessChangedObservation", "SubAgentResult", "LoopResult",
     "KernelAgentRole", "AgentIsolation", "ContextInheritance",
     "MilestoneContract", "MilestonePhase", "MilestoneCheckResult", "MilestonePolicy",

deepstrike-0.2.73/deepstrike/agent.py

@@ -0,0 +1,125 @@
+"""Public executable Agent contract.
+
+This surface describes an agent before a host chooses a provider, execution plane, or Kernel run.
+The declaration stays provider-neutral; execution resolves a provider through the explicit
+``runtime_binding`` supplied by the host.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Literal, Mapping, Sequence, TypeAlias
+
+from deepstrike.types.agent import AgentCapabilityFilter
+
+
+ModelRef: TypeAlias = str | dict[str, Any]
+AgentDefinition: TypeAlias = Mapping[str, Any]
+AgentMemory: TypeAlias = Any
+
+
+@dataclass(frozen=True)
+class MemoryReference:
+    """Serializable durable-memory binding for an agent declared before a host store exists."""
+
+    namespace: str | None = None
+    kind: Literal["durable"] = "durable"
+
+
+class Agent:
+    """Provider-neutral declaration and executable public Agent handle.
+
+    ``tools`` may contain executable ``RegisteredTool`` instances or JSON-safe tool descriptors.
+    The latter carry schema only and do not create executable capabilities.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        *,
+        description: str | None = None,
+        instructions: str | None = None,
+        model: ModelRef | None = None,
+        capability_filter: AgentCapabilityFilter | Mapping[str, Any] | None = None,
+        tools: Sequence[Any] | None = None,
+        mcp_servers: Sequence[Mapping[str, Any]] | None = None,
+        skills: Sequence[Mapping[str, Any]] | None = None,
+        memory: AgentMemory | None = None,
+        knowledge: Sequence[Mapping[str, Any]] | None = None,
+        handoffs: Sequence[Mapping[str, Any]] | None = None,
+        provider_options: Mapping[str, Any] | None = None,
+        output_schema: Mapping[str, Any] | None = None,
+        metadata: Mapping[str, Any] | None = None,
+        guardrails: Sequence[Mapping[str, Any]] | None = None,
+        runtime_binding: Mapping[str, Any] | None = None,
+    ) -> None:
+        if not name:
+            raise ValueError("agent name is required")
+        self.name = name
+        self.description = description
+        self.instructions = instructions
+        self.model = model
+        self.capability_filter = capability_filter
+        self.tools = list(tools) if tools is not None else None
+        self.mcp_servers = list(mcp_servers) if mcp_servers is not None else None
+        self.skills = list(skills) if skills is not None else None
+        self.memory = memory
+        self.knowledge = list(knowledge) if knowledge is not None else None
+        self.handoffs = list(handoffs) if handoffs is not None else None
+        self.provider_options = dict(provider_options) if provider_options is not None else None
+        self.output_schema = dict(output_schema) if output_schema is not None else None
+        self.metadata = dict(metadata) if metadata is not None else None
+        self.guardrails = list(guardrails) if guardrails is not None else None
+        self.runtime_binding = dict(runtime_binding) if runtime_binding is not None else None
+
+    async def run(self, goal: str, *, session_id: str | None = None, max_turns: int | None = None) -> dict[str, Any]:
+        """Execute one goal through the host binding and return a structured run result."""
+        if not self.runtime_binding:
+            raise RuntimeError(f'agent "{self.name}" has no runtime binding')
+        provider = self.runtime_binding.get("provider")
+        if provider is None:
+            provider_for = self.runtime_binding.get("provider_for")
+            provider = provider_for(self.model) if callable(provider_for) else None
+        if provider is None:
+            raise RuntimeError(f'agent "{self.name}" has no runtime provider binding')
+        from deepstrike.runtime.facade import run_agent
+        output = await run_agent(
+            provider=provider,
+            goal=goal,
+            system_prompt=self.instructions,
+            tools=list(self.tools or []),
+            session_id=session_id,
+            max_turns=max_turns,
+        )
+        return {"output": output, "status": "completed", "session_id": session_id}
+
+    async def stream(self, goal: str, *, session_id: str | None = None, max_turns: int | None = None):
+        """Stream host events for the same public Agent contract."""
+        if not self.runtime_binding:
+            raise RuntimeError(f'agent "{self.name}" has no runtime binding')
+        provider = self.runtime_binding.get("provider")
+        if provider is None:
+            provider_for = self.runtime_binding.get("provider_for")
+            provider = provider_for(self.model) if callable(provider_for) else None
+        if provider is None:
+            raise RuntimeError(f'agent "{self.name}" has no runtime provider binding')
+        from deepstrike.runtime.execution_plane import LocalExecutionPlane
+        from deepstrike.runtime.runner import RuntimeOptions, RuntimeRunner
+        from deepstrike.runtime.session_log import InMemorySessionLog
+        options = self.runtime_binding.get("runtime_options", {})
+        runner = RuntimeRunner(RuntimeOptions(
+            provider=provider,
+            execution_plane=LocalExecutionPlane(),
+            session_log=InMemorySessionLog(),
+            max_tokens=32_000,
+            agent_id=self.name,
+            **({"system_prompt": self.instructions} if self.instructions else {}),
+            **({"max_turns": max_turns} if max_turns is not None else {}),
+            **options,
+        ))
+        async for event in runner.run(goal=goal, session_id=session_id or f"agent-{uuid.uuid4()}"):
+            yield event
+
+
+def create_agent(name: str, **kwargs: Any) -> Agent:
+    """Create the executable public Agent handle."""
+    return Agent(name, **kwargs)

{deepstrike-0.2.72 → deepstrike-0.2.73}/deepstrike/providers/base.py

@@ -433,8 +433,7 @@ class RuntimePolicy:
         self.timeout_ms = timeout_ms
 
 
-# Wire protocols a provider can speak. Mirrors the Node/WASM ProviderProtocol union.
-ProviderProtocol = str  # "anthropic-messages" | "openai-chat" | "openai-responses" | "gemini"
+from .protocols import GenerationProtocol
 
 
 @dataclass
@@ -442,7 +441,7 @@ class ProviderDescriptor:
     """Stable identity advertised by a provider so the recovery layer can decide
     whether a stored replay envelope may be seeded into it."""
     provider: str
-    protocol: ProviderProtocol
+    protocol: GenerationProtocol
     model: str
     reasoning: dict[str, Any] = field(default_factory=dict)
     tool_calls: dict[str, Any] = field(default_factory=dict)