Security migration roll-up

crates/tinyagents-harness-tools/Cargo.toml

@@ -24,6 +24,7 @@ reqwest = { workspace = true, features = ["stream", "multipart"], optional = tru
 sha2 = { version = "0.11", optional = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
+schemars = "1.2.3"
 tinyagents-harness = { path = "../tinyagents-harness", version = "3.0.0", default-features = false }
 tinyagents-tasks = { path = "../tinyagents-tasks", version = "3.0.0", default-features = false, optional = true }
 tinyinference-llm = { path = "../../vendor/tinyinference/crates/tinyinference-llm", version = "0.5.0", optional = true }

crates/tinyagents-harness-tools/src/goals/types.rs

@@ -19,7 +19,7 @@ use serde::{Deserialize, Serialize};
 /// [`BudgetLimited`](ThreadGoalStatus::BudgetLimited) are entered only by the
 /// system (host control and accounting respectively), and clearing deletes the
 /// row entirely rather than being a status.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum ThreadGoalStatus {
     /// The graph may make progress and (when driven) auto-continue.
@@ -60,7 +60,7 @@ impl ThreadGoalStatus {
 }
 
 /// A single thread-scoped goal.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct ThreadGoal {
     /// The thread this goal belongs to (one goal per thread).

crates/tinyagents-harness-tools/src/todos/types.rs

@@ -9,7 +9,7 @@
 use serde::{Deserialize, Serialize};
 
 /// Lifecycle state of a todo item.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum TodoStatus {
     /// Not started.
@@ -40,7 +40,7 @@ impl TodoStatus {
 }
 
 /// One item on a thread's todo list.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct TodoItem {
     /// The step, as the model wrote it.
@@ -74,7 +74,7 @@ impl TodoItem {
 }
 
 /// A per-thread list: the items in order plus a last-mutation stamp.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct TodoList {
     /// The thread this list belongs to.
@@ -97,7 +97,7 @@ impl TodoList {
 }
 
 /// A single store outcome: the post-mutation items plus a markdown rendering.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct TodosSnapshot {
     /// The thread the list belongs to.

crates/tinyagents-harness/Cargo.toml

@@ -26,6 +26,7 @@ regex = "1"
 reqwest = { workspace = true, features = ["stream", "http2"], optional = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
+schemars = "1.2.3"
 sha2 = "0.11"
 thiserror = "2"
 tracing = { workspace = true }

crates/tinyagents-harness/src/host/model_factory/README.md

@@ -10,14 +10,18 @@ stable description of each requested route.
 `types.rs` defines the serde-compatible `BuildOpts`, `ModelPurpose`, and
 `ModelBuildRequest` values, plus the `ModelBuildGate` and `ModelFactory`
 contracts. Hosts implement the gate to authorize each construction request and
-the factory to return a model with its resolved provider/model route.
+the async factory to return a model with its resolved provider/model route.
+Both adapters are `Sync`, and factory futures are `Send`, so turn assembly can
+run inside the host's sendable task boundaries.
 
 `assembly.rs` owns `TurnModelSetBuilder` and `TurnModelSet`. It builds the
 primary route, independently builds workload tiers (omitting unavailable or
 gated tiers), builds the summarizer, and records the concrete routes and error
-slots for later resolution. A primary pin does not implicitly pin workload
-routes. An explicit summarization role with no summary pin uses that role's
-configured default.
+slots for later resolution. Await `TurnModelSetBuilder::build` or
+`TurnModelSet::build`; each primary, workload, and summary factory request is
+awaited before assembly continues. A primary pin does not implicitly pin
+workload routes. An explicit summarization role with no summary pin uses that
+role's configured default.
 
 `subprocess.rs` adapts Claude Code and Claude Agent SDK route values to the
 existing provider implementations. Hosts must run `ModelBuildGate` before

crates/tinyagents-harness/src/host/model_factory/assembly.rs

@@ -150,9 +150,9 @@ impl<'a, State: Send + Sync + 'static, F: ModelFactory<State> + ?Sized, G: Model
 
     /// Builds all requested models. Primary and summarization failures are
     /// fatal; failed workload routes are logged and omitted.
-    pub fn build(self) -> Result<TurnModelSet<State>> {
+    pub async fn build(self) -> Result<TurnModelSet<State>> {
         self.gate.check(&self.primary)?;
-        let (primary_model, primary_route) = self.factory.build(&self.primary)?;
+        let (primary_model, primary_route) = self.factory.build(&self.primary).await?;
         let primary = Arc::new(RouteRecordingModel::new(
             primary_model,
             primary_route.clone(),
@@ -182,7 +182,7 @@ impl<'a, State: Send + Sync + 'static, F: ModelFactory<State> + ?Sized, G: Model
                 tracing::debug!(route = ?request.route, %error, "skipping gated workload model");
                 continue;
             }
-            match self.factory.build(&request) {
+            match self.factory.build(&request).await {
                 Ok((model, route)) => {
                     let slot = Arc::new(Mutex::new(None));
                     let recorded = Arc::new(RouteRecordingModel::new(model, route))
@@ -215,7 +215,7 @@ impl<'a, State: Send + Sync + 'static, F: ModelFactory<State> + ?Sized, G: Model
             opts: self.summarization_opts.unwrap_or(self.primary.opts),
         };
         self.gate.check(&summary_request)?;
-        let (summary_model, summary_route) = self.factory.build(&summary_request)?;
+        let (summary_model, summary_route) = self.factory.build(&summary_request).await?;
         let summary_error_slot = Arc::new(Mutex::new(None));
         let summarizer = Arc::new(RouteRecordingModel::new(
             summary_model,
@@ -251,12 +251,12 @@ pub struct TurnModelSet<State: Send + Sync> {
 
 impl<State: Send + Sync + 'static> TurnModelSet<State> {
     /// Builds a turn's primary, canonical workload routes, and summarizer.
-    pub fn build<F, G>(factory: &F, gate: &G, primary_role: impl Into<String>) -> Result<Self>
+    pub async fn build<F, G>(factory: &F, gate: &G, primary_role: impl Into<String>) -> Result<Self>
     where
         F: ModelFactory<State> + ?Sized,
         G: ModelBuildGate + ?Sized,
     {
-        Self::builder(factory, gate, primary_role).build()
+        Self::builder(factory, gate, primary_role).build().await
     }
 
     /// Starts building a model set using the standard workload aliases.

crates/tinyagents-harness/src/host/model_factory/types.rs

@@ -1,5 +1,6 @@
 use std::sync::Arc;
 
+use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
 use tinyinference_llm::model::{ChatModel, ResolvedModelRoute};
 
@@ -58,15 +59,22 @@ impl ModelBuildRequest {
 }
 
 /// Host policy hook called before every model construction.
-pub trait ModelBuildGate {
+///
+/// Implementations are `Sync` so a turn-model assembly future may cross a
+/// host task boundary while retaining the gate between model builds.
+pub trait ModelBuildGate: Sync {
     /// Authorize constructing the model described by `request`.
     fn check(&self, request: &ModelBuildRequest) -> Result<()>;
 }
 
 /// Host implementation that selects and constructs a provider model.
-pub trait ModelFactory<State: Send + Sync> {
+///
+/// Implementations are `Sync`, and [`build`](Self::build) returns a `Send`
+/// future so the harness can assemble turn models inside sendable host tasks.
+#[async_trait]
+pub trait ModelFactory<State: Send + Sync>: Sync {
     /// Construct a model and report the concrete route selected by the host.
-    fn build(
+    async fn build(
         &self,
         request: &ModelBuildRequest,
     ) -> Result<(Arc<dyn ChatModel<State>>, ResolvedModelRoute)>;