diff --git a/Cargo.lock b/Cargo.lock index 863ecddc..f14171b0 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -402,7 +402,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" dependencies = [ "libc", - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] @@ -1380,7 +1380,7 @@ dependencies = [ "once_cell", "socket2", "tracing", - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] @@ -1596,14 +1596,14 @@ dependencies = [ "errno", "libc", "linux-raw-sys", - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] name = "rustls" -version = "0.23.45" +version = "0.23.46" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0d41d731c7d2f962d1ccc364cec258de3c0e93b38c2fb3ba97ac74513048d634" +checksum = "48e13bd8c0e9365c43cfa5c9e8f9ad49d3c8444926c9aac819e0e4dc503c8fdf" dependencies = [ "aws-lc-rs", "log", @@ -1655,7 +1655,7 @@ dependencies = [ "security-framework", "security-framework-sys", "webpki-root-certs", - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] @@ -1977,10 +1977,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd" dependencies = [ "fastrand", - "getrandom 0.3.4", + "getrandom 0.4.3", "once_cell", "rustix", - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] @@ -2007,6 +2007,27 @@ dependencies = [ name = "tinybus" version = "0.1.6" source = "git+https://github.com/tinyhumansai/tinybus?rev=0de2d283f35cbbff08efad6fbe05537ffb74611b#0de2d283f35cbbff08efad6fbe05537ffb74611b" +dependencies = [ + "async-trait", + "flate2", + "libc", + "serde", + "serde_json", + "sha2 0.10.9", + "tar", + "tempfile", + "thiserror", + "tokio", + "toml", + "tracing", + "ureq", + "zip", +] + +[[package]] +name = "tinybus" +version = "0.3.6" +source = "git+https://github.com/tinyhumansai/tinybus?rev=6ce06bc674e4f4d718aa51e643ef62c1f372e270#6ce06bc674e4f4d718aa51e643ef62c1f372e270" dependencies = [ "async-trait", "flate2", @@ -2027,8 +2048,8 @@ dependencies = [ [[package]] name = "tinybus-macros" -version = "0.1.6" -source = "git+https://github.com/tinyhumansai/tinybus?rev=0de2d283f35cbbff08efad6fbe05537ffb74611b#0de2d283f35cbbff08efad6fbe05537ffb74611b" +version = "0.3.6" +source = "git+https://github.com/tinyhumansai/tinybus?rev=6ce06bc674e4f4d718aa51e643ef62c1f372e270#6ce06bc674e4f4d718aa51e643ef62c1f372e270" dependencies = [ "proc-macro2", "quote", @@ -2037,13 +2058,13 @@ dependencies = [ [[package]] name = "tinybus-module" -version = "0.1.6" -source = "git+https://github.com/tinyhumansai/tinybus?rev=0de2d283f35cbbff08efad6fbe05537ffb74611b#0de2d283f35cbbff08efad6fbe05537ffb74611b" +version = "0.3.6" +source = "git+https://github.com/tinyhumansai/tinybus?rev=6ce06bc674e4f4d718aa51e643ef62c1f372e270#6ce06bc674e4f4d718aa51e643ef62c1f372e270" dependencies = [ "async-trait", "serde", "serde_json", - "tinybus", + "tinybus 0.3.6", "tokio", "tracing", ] @@ -2165,7 +2186,7 @@ dependencies = [ "serde", "serde_json", "tempfile", - "tinybus", + "tinybus 0.3.6", "tinybus-module", "tinyflows", "tinyflows-bus", @@ -2209,7 +2230,7 @@ dependencies = [ "serde", "serde_json", "sha2 0.11.0", - "tinybus", + "tinybus 0.1.6", "tinystoragedrivers-api", "tinystoragedrivers-busproxy", "tinystoragedrivers-testkit", @@ -2220,8 +2241,8 @@ dependencies = [ [[package]] name = "tinystoragedrivers-api" -version = "2.1.0" -source = "git+https://github.com/tinyhumansai/tinystoragedrivers?rev=05eaada962decbab33bafa4763d2bd1a67f6b456#05eaada962decbab33bafa4763d2bd1a67f6b456" +version = "2.1.1" +source = "git+https://github.com/tinyhumansai/tinystoragedrivers?rev=bf1f0a97fbe6165a6edd9521659c7f6859700761#bf1f0a97fbe6165a6edd9521659c7f6859700761" dependencies = [ "async-trait", "bytes", @@ -2234,8 +2255,8 @@ dependencies = [ [[package]] name = "tinystoragedrivers-blob" -version = "2.1.0" -source = "git+https://github.com/tinyhumansai/tinystoragedrivers?rev=05eaada962decbab33bafa4763d2bd1a67f6b456#05eaada962decbab33bafa4763d2bd1a67f6b456" +version = "2.1.1" +source = "git+https://github.com/tinyhumansai/tinystoragedrivers?rev=bf1f0a97fbe6165a6edd9521659c7f6859700761#bf1f0a97fbe6165a6edd9521659c7f6859700761" dependencies = [ "async-trait", "bytes", @@ -2248,26 +2269,26 @@ dependencies = [ [[package]] name = "tinystoragedrivers-bus" -version = "2.1.0" -source = "git+https://github.com/tinyhumansai/tinystoragedrivers?rev=05eaada962decbab33bafa4763d2bd1a67f6b456#05eaada962decbab33bafa4763d2bd1a67f6b456" +version = "2.1.1" +source = "git+https://github.com/tinyhumansai/tinystoragedrivers?rev=bf1f0a97fbe6165a6edd9521659c7f6859700761#bf1f0a97fbe6165a6edd9521659c7f6859700761" dependencies = [ "serde", "serde_json", - "tinybus", + "tinybus 0.1.6", "tinystoragedrivers-types", ] [[package]] name = "tinystoragedrivers-busproxy" -version = "2.1.0" -source = "git+https://github.com/tinyhumansai/tinystoragedrivers?rev=05eaada962decbab33bafa4763d2bd1a67f6b456#05eaada962decbab33bafa4763d2bd1a67f6b456" +version = "2.1.1" +source = "git+https://github.com/tinyhumansai/tinystoragedrivers?rev=bf1f0a97fbe6165a6edd9521659c7f6859700761#bf1f0a97fbe6165a6edd9521659c7f6859700761" dependencies = [ "async-trait", "bytes", "futures-core", "serde", "serde_json", - "tinybus", + "tinybus 0.1.6", "tinystoragedrivers-api", "tinystoragedrivers-bus", "tinystoragedrivers-types", @@ -2277,8 +2298,8 @@ dependencies = [ [[package]] name = "tinystoragedrivers-connect" -version = "2.1.0" -source = "git+https://github.com/tinyhumansai/tinystoragedrivers?rev=05eaada962decbab33bafa4763d2bd1a67f6b456#05eaada962decbab33bafa4763d2bd1a67f6b456" +version = "2.1.1" +source = "git+https://github.com/tinyhumansai/tinystoragedrivers?rev=bf1f0a97fbe6165a6edd9521659c7f6859700761#bf1f0a97fbe6165a6edd9521659c7f6859700761" dependencies = [ "rusqlite", "serde_json", @@ -2289,8 +2310,8 @@ dependencies = [ [[package]] name = "tinystoragedrivers-document" -version = "2.1.0" -source = "git+https://github.com/tinyhumansai/tinystoragedrivers?rev=05eaada962decbab33bafa4763d2bd1a67f6b456#05eaada962decbab33bafa4763d2bd1a67f6b456" +version = "2.1.1" +source = "git+https://github.com/tinyhumansai/tinystoragedrivers?rev=bf1f0a97fbe6165a6edd9521659c7f6859700761#bf1f0a97fbe6165a6edd9521659c7f6859700761" dependencies = [ "async-trait", "data-encoding", @@ -2307,8 +2328,8 @@ dependencies = [ [[package]] name = "tinystoragedrivers-kv" -version = "2.1.0" -source = "git+https://github.com/tinyhumansai/tinystoragedrivers?rev=05eaada962decbab33bafa4763d2bd1a67f6b456#05eaada962decbab33bafa4763d2bd1a67f6b456" +version = "2.1.1" +source = "git+https://github.com/tinyhumansai/tinystoragedrivers?rev=bf1f0a97fbe6165a6edd9521659c7f6859700761#bf1f0a97fbe6165a6edd9521659c7f6859700761" dependencies = [ "async-trait", "serde", @@ -2319,8 +2340,8 @@ dependencies = [ [[package]] name = "tinystoragedrivers-queue" -version = "2.1.0" -source = "git+https://github.com/tinyhumansai/tinystoragedrivers?rev=05eaada962decbab33bafa4763d2bd1a67f6b456#05eaada962decbab33bafa4763d2bd1a67f6b456" +version = "2.1.1" +source = "git+https://github.com/tinyhumansai/tinystoragedrivers?rev=bf1f0a97fbe6165a6edd9521659c7f6859700761#bf1f0a97fbe6165a6edd9521659c7f6859700761" dependencies = [ "async-trait", "data-encoding", @@ -2335,8 +2356,8 @@ dependencies = [ [[package]] name = "tinystoragedrivers-secrets" -version = "2.1.0" -source = "git+https://github.com/tinyhumansai/tinystoragedrivers?rev=05eaada962decbab33bafa4763d2bd1a67f6b456#05eaada962decbab33bafa4763d2bd1a67f6b456" +version = "2.1.1" +source = "git+https://github.com/tinyhumansai/tinystoragedrivers?rev=bf1f0a97fbe6165a6edd9521659c7f6859700761#bf1f0a97fbe6165a6edd9521659c7f6859700761" dependencies = [ "async-trait", "tinystoragedrivers-api", @@ -2346,8 +2367,8 @@ dependencies = [ [[package]] name = "tinystoragedrivers-testkit" -version = "2.1.0" -source = "git+https://github.com/tinyhumansai/tinystoragedrivers?rev=05eaada962decbab33bafa4763d2bd1a67f6b456#05eaada962decbab33bafa4763d2bd1a67f6b456" +version = "2.1.1" +source = "git+https://github.com/tinyhumansai/tinystoragedrivers?rev=bf1f0a97fbe6165a6edd9521659c7f6859700761#bf1f0a97fbe6165a6edd9521659c7f6859700761" dependencies = [ "async-trait", "bytes", @@ -2367,8 +2388,8 @@ dependencies = [ [[package]] name = "tinystoragedrivers-types" -version = "2.1.0" -source = "git+https://github.com/tinyhumansai/tinystoragedrivers?rev=05eaada962decbab33bafa4763d2bd1a67f6b456#05eaada962decbab33bafa4763d2bd1a67f6b456" +version = "2.1.1" +source = "git+https://github.com/tinyhumansai/tinystoragedrivers?rev=bf1f0a97fbe6165a6edd9521659c7f6859700761#bf1f0a97fbe6165a6edd9521659c7f6859700761" dependencies = [ "serde", "serde_json", @@ -2387,8 +2408,8 @@ dependencies = [ [[package]] name = "tinytools" -version = "0.5.0" -source = "git+https://github.com/tinyhumansai/tinytools?rev=643df90ba25f93187249fa99f6789f9aa7f8bbc8#643df90ba25f93187249fa99f6789f9aa7f8bbc8" +version = "0.6.0" +source = "git+https://github.com/tinyhumansai/tinytools?rev=41cc80ac9acf37a14f20be94f60ee552749f1540#41cc80ac9acf37a14f20be94f60ee552749f1540" dependencies = [ "anyhow", "async-trait", @@ -2633,9 +2654,9 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" [[package]] name = "ureq" -version = "3.4.2" +version = "3.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9a7ac20be9b7726e0bbdbf974c059676d9acb1cd414961f570a4e8231cacd7fc" +checksum = "cde93ff05758a36a851a398a772b0b79a82fbe3c186a46f2696baaeaf84c966b" dependencies = [ "base64", "flate2", @@ -2650,9 +2671,9 @@ dependencies = [ [[package]] name = "ureq-proto" -version = "0.6.4" +version = "0.6.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f86fd172ccca569e458f61b6bdd6220965a9ef36e672a6852953b51a0e1583be" +checksum = "841583fc36089d7d59419568ae157f43a5a03a2e5a81ba87c77d1596ef46e922" dependencies = [ "base64", "http", @@ -2838,9 +2859,9 @@ dependencies = [ [[package]] name = "webpki-roots" -version = "1.0.9" +version = "1.0.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7dcd9d09a39985f5344844e66b0c530a33843579125f23e21e9f0f220850f22a" +checksum = "f5f280bbb2b287bc8e7de7e3852945a0ff50d1bbcb5ed42b6c7a568c546df171" dependencies = [ "rustls-pki-types", ] @@ -2851,7 +2872,7 @@ version = "0.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" dependencies = [ - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index 3104c655..97399424 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -19,8 +19,8 @@ exclude = ["worktrees", "vendor/tinybus"] # Pin unpublished module APIs to a source available in non-recursive clones and archives. [patch.crates-io] -tinybus = { git = "https://github.com/tinyhumansai/tinybus", rev = "0de2d283f35cbbff08efad6fbe05537ffb74611b" } -tinybus-module = { git = "https://github.com/tinyhumansai/tinybus", rev = "0de2d283f35cbbff08efad6fbe05537ffb74611b" } +tinybus = { git = "https://github.com/tinyhumansai/tinybus", rev = "6ce06bc674e4f4d718aa51e643ef62c1f372e270" } +tinybus-module = { git = "https://github.com/tinyhumansai/tinybus", rev = "6ce06bc674e4f4d718aa51e643ef62c1f372e270" } [workspace.package] edition = "2024" diff --git a/crates/tinyflows-adaptive/Cargo.toml b/crates/tinyflows-adaptive/Cargo.toml index 32ed755d..6c86a95f 100644 --- a/crates/tinyflows-adaptive/Cargo.toml +++ b/crates/tinyflows-adaptive/Cargo.toml @@ -19,8 +19,8 @@ thiserror = "2" # revision so a host that vendors tinystoragedrivers once can `[patch]` it; chrono # turns the RFC 3339 instants of the records into the stored `*_ms`; tokio's # `OnceCell` for one-time collection setup. -tinystoragedrivers-api = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.0", rev = "05eaada962decbab33bafa4763d2bd1a67f6b456", optional = true } -tinystoragedrivers-types = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.0", rev = "05eaada962decbab33bafa4763d2bd1a67f6b456", optional = true } +tinystoragedrivers-api = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.1", rev = "bf1f0a97fbe6165a6edd9521659c7f6859700761", optional = true } +tinystoragedrivers-types = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.1", rev = "bf1f0a97fbe6165a6edd9521659c7f6859700761", optional = true } tinyflows-storage = { path = "../tinyflows-storage", optional = true } chrono = { version = "0.4", default-features = false, features = ["std"], optional = true } tracing = { version = "0.1", default-features = false, features = ["std"], optional = true } @@ -41,9 +41,9 @@ tinyflows = { path = "../tinyflows", features = ["store", "mock"] } # The engine's `WorkflowStore` on an in-memory storage backend, for tests and # the eval example. tinyflows-drivers = { path = "../tinyflows-drivers", default-features = false, features = ["store"] } -tinystoragedrivers-api = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.0", rev = "05eaada962decbab33bafa4763d2bd1a67f6b456" } -tinystoragedrivers-types = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.0", rev = "05eaada962decbab33bafa4763d2bd1a67f6b456" } -tinystoragedrivers-testkit = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.0", rev = "05eaada962decbab33bafa4763d2bd1a67f6b456" } +tinystoragedrivers-api = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.1", rev = "bf1f0a97fbe6165a6edd9521659c7f6859700761" } +tinystoragedrivers-types = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.1", rev = "bf1f0a97fbe6165a6edd9521659c7f6859700761" } +tinystoragedrivers-testkit = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.1", rev = "bf1f0a97fbe6165a6edd9521659c7f6859700761" } tokio = { version = "1", features = ["macros", "rt", "rt-multi-thread", "sync", "time"] } [lints.rust] diff --git a/crates/tinyflows-adaptive/src/evals/mod.rs b/crates/tinyflows-adaptive/src/evals/mod.rs index d9fefc59..782b56af 100644 --- a/crates/tinyflows-adaptive/src/evals/mod.rs +++ b/crates/tinyflows-adaptive/src/evals/mod.rs @@ -12,16 +12,16 @@ //! six" is compatible with the ledger being decorative. What answers it is a //! **family** of related tasks, run twice in the same order, where the only //! difference between the runs is whether anything survives between episodes — -//! and the number to read is the [`Series::slope`]: attempts-to-success +//! and the number to read is the `Series::slope`: attempts-to-success //! falling as the family progresses. //! //! Two pieces, because that experiment needs two things this crate did not //! have: //! -//! * [`slope`] — the measurement. `Episode`, two arms, the slope, and a +//! * `slope` — the measurement. `Episode`, two arms, the slope, and a //! comparison that refuses to call a bend a win unless the arm also //! converges. -//! * [`arms`] — the control. A loop with learning off is not a loop with its +//! * `arms` — the control. A loop with learning off is not a loop with its //! ledger removed; [`Forgetful`] blanks the cross-episode reads and leaves //! the within-episode ones, which is the difference under test. //! diff --git a/crates/tinyflows-bus/src/node_kinds.rs b/crates/tinyflows-bus/src/node_kinds.rs index 07d6504e..9e4bd712 100644 --- a/crates/tinyflows-bus/src/node_kinds.rs +++ b/crates/tinyflows-bus/src/node_kinds.rs @@ -2,10 +2,10 @@ //! schema. //! //! A node's `config` is free-form -//! [`serde_json::Value`](serde_json::Value): each executor reads the keys it +//! [`serde_json::Value`]: each executor reads the keys it //! needs at run time, so the per-kind config *shape* was, until now, documented //! only in prose in downstream hosts. This module makes that shape a typed, -//! host-agnostic **source of truth** — one [`NodeKindContract`] per node kind — so a host (or an agent authoring a +//! host-agnostic **source of truth** — one `NodeKindContract` per node kind — so a host (or an agent authoring a //! graph) can enumerate the kinds and fetch one kind's config fields, ports, an //! example node, and the authoring gotchas without reading a prompt. //! @@ -107,7 +107,7 @@ impl ConfigField { } /// The input/output ports a node exposes. Routing is keyed exclusively on the -/// source node's `from_port` (see [`crate::validate`]'s condition-routing +/// source node's `from_port` (see `crate::validate`'s condition-routing /// check), so the output-port list is what an author wires branch edges onto. #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] pub struct PortSpec { diff --git a/crates/tinyflows-bus/src/schedule/types.rs b/crates/tinyflows-bus/src/schedule/types.rs index 47619424..98bf0352 100644 --- a/crates/tinyflows-bus/src/schedule/types.rs +++ b/crates/tinyflows-bus/src/schedule/types.rs @@ -246,7 +246,7 @@ impl<'de> Deserialize<'de> for Schedule { pub mod delivery_mode { /// Keep the result in the run history only. pub const NONE: &str = "none"; - /// Announce the result on [`DeliveryConfig::channel`] / [`DeliveryConfig::to`]. + /// Announce the result on `DeliveryConfig::channel` / `DeliveryConfig::to`. pub const ANNOUNCE: &str = "announce"; /// Surface the result as a proactive message. pub const PROACTIVE: &str = "proactive"; @@ -454,7 +454,7 @@ pub struct CronJobPatch { pub delete_after_run: Option, /// `Option>` distinguishes "no change" (`None`) from /// "clear the agent definition" (`Some(None)`). See - /// [`deserialize_double_option`] for why the custom deserializer is required + /// `deserialize_double_option` for why the custom deserializer is required /// to honor a wire `null` as a clear rather than a silent no-op. /// /// Omitted when serialized for `None`: the custom deserializer reads a diff --git a/crates/tinyflows-copilot/Cargo.toml b/crates/tinyflows-copilot/Cargo.toml index e541cadb..716e0954 100644 --- a/crates/tinyflows-copilot/Cargo.toml +++ b/crates/tinyflows-copilot/Cargo.toml @@ -42,7 +42,7 @@ tracing = { workspace = true } # through tinyagents) patches this exact URL to its own copy, so the two unify # into one package and `tinytools::Tool` stays one type. Keep the rev equal to the # tinytools gitlink tinyagents pins. -tinytools = { git = "https://github.com/tinyhumansai/tinytools", rev = "643df90ba25f93187249fa99f6789f9aa7f8bbc8" } +tinytools = { git = "https://github.com/tinyhumansai/tinytools", rev = "41cc80ac9acf37a14f20be94f60ee552749f1540" } [dev-dependencies] tokio = { workspace = true } diff --git a/crates/tinyflows-copilot/src/tools.rs b/crates/tinyflows-copilot/src/tools.rs index 68c3bba2..3f518111 100644 --- a/crates/tinyflows-copilot/src/tools.rs +++ b/crates/tinyflows-copilot/src/tools.rs @@ -1,7 +1,7 @@ //! The authoring tool belt for a `workflow-builder` agent. //! //! These tools give the `workflow-builder` agent its full authoring surface for -//! tinyflows [`WorkflowGraph`]s in chat — tools spanning propose-only +//! tinyflows `WorkflowGraph`s in chat — tools spanning propose-only //! validation, in-place draft mutation, reads, run control, and persistence: //! //! | Tool | Permission | Effect | diff --git a/crates/tinyflows-copilot/src/tools/dry_run.rs b/crates/tinyflows-copilot/src/tools/dry_run.rs index c582426d..a55994bb 100644 --- a/crates/tinyflows-copilot/src/tools/dry_run.rs +++ b/crates/tinyflows-copilot/src/tools/dry_run.rs @@ -39,7 +39,7 @@ use tinytools::{PermissionLevel, Tool, ToolResult}; /// `=`-expression that silently resolves to `null` — the preflight above only /// catches a *missing/null Composio-required* arg, so a graph like that used to /// dry-run green and then do nothing at runtime. The run is driven through -/// [`tinyflows::engine::run_with_observer`] with a [`CapturingObserver`] that +/// [`tinyflows::engine::run_with_observer`] with a `CapturingObserver` that /// records every node's [`ExecutionStep::diagnostics`](tinyflows::observability::ExecutionStep) /// — the `=`-expressions the vendored engine itself traced as null-resolved /// (see `tinyflows::expr::resolve_traced`). After the run settles, every @@ -88,8 +88,8 @@ use tinytools::{PermissionLevel, Tool, ToolResult}; /// default), so the condition takes a different branch under mock data than /// it would at runtime — a graph can dry-run `ok: true` while its most /// data-dependent node was never actually checked. After the run settles, -/// every `agent`/`tool_call` node with no [`ExecutionStep`] in the -/// [`CapturingObserver`] is collected into `routing_divergence_warnings` +/// every `agent`/`tool_call` node with no `ExecutionStep` in the +/// `CapturingObserver` is collected into `routing_divergence_warnings` /// (`{ node_id, condition_node_id, message }`, `condition_node_id` naming the /// nearest upstream `condition` node found by walking predecessors — see /// `tinyflows::diagnostics::nearest_upstream_condition` — or `null` if none is found). This is a diff --git a/crates/tinyflows-copilot/src/tools/flow_reads.rs b/crates/tinyflows-copilot/src/tools/flow_reads.rs index 5140cce4..b113c575 100644 --- a/crates/tinyflows-copilot/src/tools/flow_reads.rs +++ b/crates/tinyflows-copilot/src/tools/flow_reads.rs @@ -220,7 +220,7 @@ impl Tool for ListFlowsTool { // get_flow — read-only: a saved flow's graph // ───────────────────────────────────────────────────────────────────────────── -/// `get_flow`: read-only fetch of a saved flow's full [`WorkflowGraph`] by id, +/// `get_flow`: read-only fetch of a saved flow's full `WorkflowGraph` by id, /// so the builder can clone or extend an existing automation. pub struct GetFlowTool { flows: Arc, diff --git a/crates/tinyflows-copilot/src/trail_off.rs b/crates/tinyflows-copilot/src/trail_off.rs index a84d9551..1c9d081a 100644 --- a/crates/tinyflows-copilot/src/trail_off.rs +++ b/crates/tinyflows-copilot/src/trail_off.rs @@ -113,13 +113,13 @@ fn last_paragraph(text: &str) -> Option { /// of the same rule. /// /// Codex review follow-up: a bare `?` outside code isn't necessarily a real -/// question — a status line like "Checked https://api.example/search?q=foo +/// question — a status line like "Checked /// and got 403." has one mid-token, in a URL query string. Counting that /// would flip `text_looks_like_question` to `true` and skip /// the host's fallback entirely, leaving the user with an /// unanswerable status note — exactly the failure mode this backstop exists /// to prevent. So each candidate `?` is additionally required to be -/// sentence-terminal via [`is_sentence_terminal_question_mark`]. +/// sentence-terminal via `is_sentence_terminal_question_mark`. #[must_use] pub fn question_mark_outside_code(text: &str) -> bool { let chars: Vec = text.chars().collect(); diff --git a/crates/tinyflows-drivers/Cargo.toml b/crates/tinyflows-drivers/Cargo.toml index 527ef9f4..75a630c3 100644 --- a/crates/tinyflows-drivers/Cargo.toml +++ b/crates/tinyflows-drivers/Cargo.toml @@ -51,8 +51,8 @@ store = [ test-fixtures = ["catalog"] [dependencies] -tinystoragedrivers-api = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.0", rev = "05eaada962decbab33bafa4763d2bd1a67f6b456" } -tinystoragedrivers-types = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.0", rev = "05eaada962decbab33bafa4763d2bd1a67f6b456" } +tinystoragedrivers-api = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.1", rev = "bf1f0a97fbe6165a6edd9521659c7f6859700761" } +tinystoragedrivers-types = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.1", rev = "bf1f0a97fbe6165a6edd9521659c7f6859700761" } tinyflows-storage = { path = "../tinyflows-storage" } serde = { workspace = true } serde_json = { workspace = true } @@ -72,4 +72,4 @@ uuid = { workspace = true, optional = true } [dev-dependencies] async-trait = { workspace = true } tokio = { workspace = true } -tinystoragedrivers-testkit = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.0", rev = "05eaada962decbab33bafa4763d2bd1a67f6b456" } +tinystoragedrivers-testkit = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.1", rev = "bf1f0a97fbe6165a6edd9521659c7f6859700761" } diff --git a/crates/tinyflows-drivers/src/store/mod.rs b/crates/tinyflows-drivers/src/store/mod.rs index 47b54993..c790cafc 100644 --- a/crates/tinyflows-drivers/src/store/mod.rs +++ b/crates/tinyflows-drivers/src/store/mod.rs @@ -1,4 +1,4 @@ -//! [`WorkflowStore`] on a `tinystoragedrivers` document handle. +//! `WorkflowStore` on a `tinystoragedrivers` document handle. //! //! [`DriverWorkflowStore`] is the storage behind the engine's authoring layer //! (`tinyflows::store`): saved workflow definitions, their superseded @@ -11,15 +11,15 @@ //! //! | Collection | Document id | Holds | //! | --- | --- | --- | -//! | `flows.workflows` | `Key::of([workflow id])` | one [`WorkflowRecord`] | +//! | `flows.workflows` | `Key::of([workflow id])` | one `WorkflowRecord` | //! | `flows.workflow_revisions` | revision id | one superseded copy of a workflow | -//! | `flows.workflow_runs` | `Key::of([run id])` | one [`RunRecord`] | +//! | `flows.workflow_runs` | `Key::of([run id])` | one `RunRecord` | //! | `flows.workflow_notes` | `Key::of([workflow id])` | the workflow's whole journal (at most [`MAX_NOTES`]) | -//! | `flows.workflow_proposals` | `Key::of([proposal id])` | one [`WorkflowProposal`] | +//! | `flows.workflow_proposals` | `Key::of([proposal id])` | one `WorkflowProposal` | //! | `flows.workflow_quarantine` | ULID | a journal that could not be parsed, set aside | //! //! The names carry `workflow_` because the records are not the catalog's: a -//! [`WorkflowRecord`] is not a `Flow` (`flows.definitions`), nor a [`RunRecord`] +//! `WorkflowRecord` is not a `Flow` (`flows.definitions`), nor a `RunRecord` //! a catalog run (`flows.runs`). The decision lock is not a collection of this //! owner: it is a `tsd.leases` lease (owner `flows`, key //! `workflow_decision/`). @@ -46,12 +46,12 @@ //! then swaps the definition, and takes the revision back when the swap loses //! (then retries). A crash between the two leaves one extra revision, never //! a lost one; -//! - [`WorkflowStore::save_if_fingerprint`] and -//! [`WorkflowStore::save_if_record_fingerprint`] compare the fingerprint on +//! - `WorkflowStore::save_if_fingerprint` and +//! `WorkflowStore::save_if_record_fingerprint` compare the fingerprint on //! the document they swap, so two processes (or store instances) racing the //! same edit cannot both win; //! - the journal is one document per workflow, updated by compare-and-swap; -//! - [`WorkflowStore::lock_proposal_decision`] is a `tsd.leases` lease, so it +//! - `WorkflowStore::lock_proposal_decision` is a `tsd.leases` lease, so it //! holds across processes sharing one database. The lease lasts //! [`LOCK_LEASE`]; a decision that takes longer than that loses its //! exclusion. @@ -162,7 +162,7 @@ impl DriverWorkflowStore { } /// The same store, naming itself `label` in - /// [`WorkflowStore::proposal_decision_scope`]. Instances over the same + /// `WorkflowStore::proposal_decision_scope`. Instances over the same /// storage should share a label; unrelated catalogs in one process should /// not. #[must_use] diff --git a/crates/tinyflows-module/Cargo.toml b/crates/tinyflows-module/Cargo.toml index 2e131e17..1b5fa983 100644 --- a/crates/tinyflows-module/Cargo.toml +++ b/crates/tinyflows-module/Cargo.toml @@ -14,8 +14,8 @@ crate-type = ["rlib", "cdylib"] [dependencies] tinyflows-drivers = { path = "../tinyflows-drivers", default-features = false, features = ["catalog", "engine", "schedule"] } tinyflows-catalog = { path = "../tinyflows-catalog" } -tinystoragedrivers-api = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.0", rev = "05eaada962decbab33bafa4763d2bd1a67f6b456" } -tinystoragedrivers-types = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.0", rev = "05eaada962decbab33bafa4763d2bd1a67f6b456" } +tinystoragedrivers-api = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.1", rev = "bf1f0a97fbe6165a6edd9521659c7f6859700761" } +tinystoragedrivers-types = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.1", rev = "bf1f0a97fbe6165a6edd9521659c7f6859700761" } tinyflows-storage = { path = "../tinyflows-storage" } tinyflows-schedule = { path = "../tinyflows-schedule" } anyhow = "1" @@ -28,9 +28,9 @@ tracing.workspace = true tinyflows = { workspace = true, features = ["mock"] } tinyflows-bus = { path = "../tinyflows-bus" } tinyflows-copilot = { path = "../tinyflows-copilot" } -tinytools = { git = "https://github.com/tinyhumansai/tinytools", rev = "643df90ba25f93187249fa99f6789f9aa7f8bbc8" } -tinybus = { version = ">=0.1.3, <0.2", default-features = false, features = ["macros", "modules"] } -tinybus-module = ">=0.1.3, <0.2" +tinytools = { git = "https://github.com/tinyhumansai/tinytools", rev = "41cc80ac9acf37a14f20be94f60ee552749f1540" } +tinybus = { version = ">=0.3.6, <0.4", default-features = false, features = ["macros", "modules"] } +tinybus-module = ">=0.3.6, <0.4" serde_json.workspace = true [features] @@ -42,4 +42,4 @@ static-link = [] [dev-dependencies] tempfile = "3" tokio = { workspace = true, features = ["test-util"] } -tinystoragedrivers-testkit = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.0", rev = "05eaada962decbab33bafa4763d2bd1a67f6b456" } +tinystoragedrivers-testkit = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.1", rev = "bf1f0a97fbe6165a6edd9521659c7f6859700761" } diff --git a/crates/tinyflows-schedule/src/schedule.rs b/crates/tinyflows-schedule/src/schedule.rs index b6e9b999..124ea951 100644 --- a/crates/tinyflows-schedule/src/schedule.rs +++ b/crates/tinyflows-schedule/src/schedule.rs @@ -103,8 +103,8 @@ pub fn validate_agent_schedule(schedule: &Schedule, now: DateTime) -> Resul /// `*/7 * * * *` fires at :56 and then at :00, four minutes apart, and is /// reported as such. Ties keep the earliest pair. /// -/// The walk is bounded ([`RUN_GAP_SCAN_OCCURRENCES`] runs, one shared -/// [`ACTIVE_WINDOW_CANDIDATE_LIMIT`] budget), so a sparse or window-restricted +/// The walk is bounded (`RUN_GAP_SCAN_OCCURRENCES` runs, one shared +/// `ACTIVE_WINDOW_CANDIDATE_LIMIT` budget), so a sparse or window-restricted /// expression stays cheap; if the budget runs out mid-walk, the closest pair /// seen so far is still reported. An expression that cannot be parsed, or that /// has no second occurrence, is not evidence of anything and yields `None`; diff --git a/crates/tinyflows-storage/Cargo.toml b/crates/tinyflows-storage/Cargo.toml index acfe5b31..a07fd448 100644 --- a/crates/tinyflows-storage/Cargo.toml +++ b/crates/tinyflows-storage/Cargo.toml @@ -9,8 +9,8 @@ publish = false description = "TinyFlows-owned generic document persistence helpers" [dependencies] -tinystoragedrivers-api = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.0", rev = "05eaada962decbab33bafa4763d2bd1a67f6b456" } -tinystoragedrivers-types = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.0", rev = "05eaada962decbab33bafa4763d2bd1a67f6b456" } +tinystoragedrivers-api = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.1", rev = "bf1f0a97fbe6165a6edd9521659c7f6859700761" } +tinystoragedrivers-types = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.1", rev = "bf1f0a97fbe6165a6edd9521659c7f6859700761" } serde = { workspace = true } serde_json = { workspace = true } async-trait = { workspace = true } @@ -20,6 +20,7 @@ ulid = "1" data-encoding = "2" [dev-dependencies] -tinystoragedrivers-testkit = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.0", rev = "05eaada962decbab33bafa4763d2bd1a67f6b456" } -tinystoragedrivers-busproxy = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.0", rev = "05eaada962decbab33bafa4763d2bd1a67f6b456" } +tinystoragedrivers-testkit = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.1", rev = "bf1f0a97fbe6165a6edd9521659c7f6859700761" } +tinystoragedrivers-busproxy = { git = "https://github.com/tinyhumansai/tinystoragedrivers", version = "2.1.1", rev = "bf1f0a97fbe6165a6edd9521659c7f6859700761" } +# Keep this on the rev tinystoragedrivers pins so `tinybus::Connection` is one type with its busproxy. tinybus-sdk = { package = "tinybus", git = "https://github.com/tinyhumansai/tinybus", rev = "0de2d283f35cbbff08efad6fbe05537ffb74611b", default-features = false } diff --git a/crates/tinyflows-storage/src/primitives/leases.rs b/crates/tinyflows-storage/src/primitives/leases.rs index 25e7ed6f..fb9c7fb9 100644 --- a/crates/tinyflows-storage/src/primitives/leases.rs +++ b/crates/tinyflows-storage/src/primitives/leases.rs @@ -145,7 +145,7 @@ impl Lease { /// Leases over [`LEASES`], one record per `(owner, key)`. /// -/// Time comes from an injectable [`Clock`] (Unix epoch milliseconds), so +/// Time comes from an injectable `Clock` (Unix epoch milliseconds), so /// tests drive expiry without sleeping. A lease is live while /// `now < expires_ms`. #[derive(Clone)] diff --git a/crates/tinyflows/src/authoring_report.rs b/crates/tinyflows/src/authoring_report.rs index 83d6c233..a3c4597f 100644 --- a/crates/tinyflows/src/authoring_report.rs +++ b/crates/tinyflows/src/authoring_report.rs @@ -1,6 +1,6 @@ //! The authoring-time dry-run report a builder host shows an agent. //! -//! [`diagnostics::diagnose`](crate::diagnostics::diagnose) reads a simulation +//! [`diagnostics::diagnose`] reads a simulation //! generically. A *builder* surface wants the same evidence bucketed by what the //! author should do about it, with advice worded for the kinds a host actually //! ships: null `tool_call` args (with the honest "unverifiable" variant when the diff --git a/crates/tinyflows/src/caps/agent.rs b/crates/tinyflows/src/caps/agent.rs index d5f5d46a..f8d3ea31 100644 --- a/crates/tinyflows/src/caps/agent.rs +++ b/crates/tinyflows/src/caps/agent.rs @@ -139,7 +139,7 @@ impl ContextBlock { /// The discovery half [`ToolInvoker`](crate::caps::ToolInvoker) never had: a /// slug plus enough metadata for a model to choose it. Produced from an /// author's [`ToolGrant`]s by -/// [`AgentRunner::resolve_tools`](AgentRunner::resolve_tools). +/// [`AgentRunner::resolve_tools`]. #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)] pub struct ToolDescriptor { /// The slug the harness would pass to diff --git a/crates/tinyflows/src/catalog.rs b/crates/tinyflows/src/catalog.rs index 8689a572..8102646d 100644 --- a/crates/tinyflows/src/catalog.rs +++ b/crates/tinyflows/src/catalog.rs @@ -8,7 +8,7 @@ //! renderers aligned. //! //! A [`Node`](crate::model::Node)'s `config` is free-form -//! [`serde_json::Value`](serde_json::Value): each executor reads the keys it +//! [`serde_json::Value`]: each executor reads the keys it //! needs at run time, so the per-kind config *shape* was, until now, documented //! only in prose in downstream hosts. This module makes that shape a typed, //! host-agnostic **source of truth** — one [`NodeKindContract`] per diff --git a/crates/tinyflows/src/compat.rs b/crates/tinyflows/src/compat.rs index 2b1dd2c2..c3174d7a 100644 --- a/crates/tinyflows/src/compat.rs +++ b/crates/tinyflows/src/compat.rs @@ -1,7 +1,7 @@ //! Topologies this engine's fan-in lowering cannot execute safely. //! -//! [`validate`](crate::validate) answers "is this a well-formed graph" and -//! [`gates`](crate::gates) answers "are its bindings resolvable". Neither +//! [`validate`] answers "is this a well-formed graph" and +//! [`gates`] answers "are its bindings resolvable". Neither //! answers the third question, which is about the engine rather than the graph: //! *can this implementation actually run it?* //! @@ -26,7 +26,7 @@ //! //! An inline `sub_workflow` is part of the graph and is descended into, to the //! same depth the run will use — one budget shared across the whole call chain, -//! which is why [`errors_with_max_depth`] exists at all. A `sub_workflow` that +//! which is why `errors_with_max_depth` exists at all. A `sub_workflow` that //! names a *saved* workflow cannot be resolved here, because this crate has no //! catalog; a host that has one walks those itself and passes the remaining //! depth in. diff --git a/crates/tinyflows/src/gates/mod.rs b/crates/tinyflows/src/gates/mod.rs index 672c2372..83728004 100644 --- a/crates/tinyflows/src/gates/mod.rs +++ b/crates/tinyflows/src/gates/mod.rs @@ -1,6 +1,6 @@ //! Checks that run before an authoring write lands. //! -//! [`validate`](crate::validate) answers "would this compile" — no trigger, an +//! [`validate`] answers "would this compile" — no trigger, an //! edge to a node that is not there. That is a real bar and it is not the one //! authors keep failing. The graphs that cost people an afternoon *do* compile: //! they have a binding that resolves to null at run time, so a step executes @@ -27,7 +27,7 @@ //! of those would have to hard-code a host, which this crate does not do. A host //! adds its own by implementing //! [`HostPolicy::check_graph`](crate::store::HostPolicy::check_graph), whose -//! default is exactly [`failures`] below. +//! default is exactly `failures` below. use crate::bindings::{self, collect_expressions, parse_node_binding, reads_as_prose}; use crate::model::{NodeKind, WorkflowGraph}; diff --git a/crates/tinyflows/src/graph/builder/implementation.rs b/crates/tinyflows/src/graph/builder/implementation.rs index 20a77149..421ee219 100644 --- a/crates/tinyflows/src/graph/builder/implementation.rs +++ b/crates/tinyflows/src/graph/builder/implementation.rs @@ -78,7 +78,7 @@ where /// Sets a default wall-clock timeout applied to every node handler. A node /// whose future does not resolve within `timeout` fails the run with - /// [`crate::GraphError::Timeout`]. + /// `crate::GraphError::Timeout`. pub fn with_node_timeout(mut self, timeout: std::time::Duration) -> Self { self.node_timeout = Some(timeout); self @@ -271,7 +271,7 @@ where /// /// These are advisory only — the runtime always resolves the real successor /// from the [`crate::graph::Command`] a node emits — but they let the - /// [topology export](crate::graph::export) draw and validate the set of + /// topology export draw and validate the set of /// nodes a command node may jump to. Implies [`Self::mark_command_routing`]. pub fn with_command_destinations( mut self, @@ -317,14 +317,14 @@ where } /// Sets a human-readable kind for `node` (e.g. `model`, `tool`, `subgraph`) - /// surfaced as [`crate::graph::NodeInfo::kind`] in the export. + /// surfaced as `crate::graph::NodeInfo::kind` in the export. pub fn with_node_kind(mut self, node: impl Into, kind: impl Into) -> Self { self.node_meta.entry(node.into()).or_default().kind = Some(kind.into()); self } /// Records a sorted, free-form `key=value` annotation on `node`, carried - /// verbatim into [`crate::graph::NodeInfo::metadata`]. + /// verbatim into `crate::graph::NodeInfo::metadata`. pub fn with_node_metadata( mut self, node: impl Into, diff --git a/crates/tinyflows/src/graph/builder/mod.rs b/crates/tinyflows/src/graph/builder/mod.rs index 1705363a..e627a3c0 100644 --- a/crates/tinyflows/src/graph/builder/mod.rs +++ b/crates/tinyflows/src/graph/builder/mod.rs @@ -8,7 +8,7 @@ //! both hand-written Rust and model-authored `.rag`/`.ragsh` programs lower into //! when they assemble a workflow that may recurse into sub-workflows. //! -//! See [`types`] for the builder data types. `compile` validates the topology +//! See `types` for the builder data types. `compile` validates the topology //! and freezes it into an immutable [`crate::graph::CompiledGraph`]. mod types; diff --git a/crates/tinyflows/src/graph/builder/types.rs b/crates/tinyflows/src/graph/builder/types.rs index 1fae1ccb..3462483c 100644 --- a/crates/tinyflows/src/graph/builder/types.rs +++ b/crates/tinyflows/src/graph/builder/types.rs @@ -189,7 +189,7 @@ impl std::fmt::Display for Route { /// [`GraphDefaults`] (the [`Default`]) changes nothing. #[derive(Clone, Debug, Default)] pub struct GraphDefaults { - /// Maximum number of supersteps before [`crate::GraphError::RecursionLimit`]. + /// Maximum number of supersteps before `crate::GraphError::RecursionLimit`. pub recursion_limit: Option, /// Whether the active node set of a superstep runs concurrently. pub parallel: Option, @@ -197,7 +197,7 @@ pub struct GraphDefaults { /// (only meaningful when `parallel` is enabled). `None` means unbounded. pub max_concurrency: Option, /// Default wall-clock timeout applied to every node handler; on elapse the - /// run fails with [`crate::GraphError::Timeout`]. `None` means no + /// run fails with `crate::GraphError::Timeout`. `None` means no /// per-node timeout. pub node_timeout: Option, } diff --git a/crates/tinyflows/src/graph/channel/mod.rs b/crates/tinyflows/src/graph/channel/mod.rs index b4c38083..04c5396c 100644 --- a/crates/tinyflows/src/graph/channel/mod.rs +++ b/crates/tinyflows/src/graph/channel/mod.rs @@ -1,6 +1,6 @@ //! Channel-per-field state model (additive). //! -//! See [`types`] for the type definitions and the high-level model. This file +//! See `types` for the type definitions and the high-level model. This file //! supplies the concrete [`Channel`] merge rules, the [`ChannelSet`] map //! operations, and the [`ChannelState`] ⇒ [`StateReducer`] bridge that lets a //! channel graph run on the existing executor. diff --git a/crates/tinyflows/src/graph/channel/types.rs b/crates/tinyflows/src/graph/channel/types.rs index 2a09c640..c1748026 100644 --- a/crates/tinyflows/src/graph/channel/types.rs +++ b/crates/tinyflows/src/graph/channel/types.rs @@ -36,7 +36,7 @@ use crate::graph::error::Result; /// - [`Channel::merge`] — how an incoming write combines with the current value. /// - [`Channel::allows_concurrent`] — whether two branches in the *same* step may /// both write this channel (aggregates: yes; last-value: no, see -/// [`crate::GraphError::InvalidConcurrentUpdate`]). +/// `crate::GraphError::InvalidConcurrentUpdate`). /// - [`Channel::is_ephemeral`] — whether the value is cleared at the start of the /// next step (one-shot channels). /// - [`Channel::is_tracked`] — whether the value appears in [`ChannelSet::snapshot`] @@ -58,7 +58,7 @@ pub trait Channel: Send + Sync { /// Whether more than one concurrent branch may write this channel within a /// single superstep. Aggregates (append/fold/accumulate/barrier) return /// `true`; overwrite-style channels return `false` and trigger - /// [`crate::GraphError::InvalidConcurrentUpdate`] on a same-step clash. + /// `crate::GraphError::InvalidConcurrentUpdate` on a same-step clash. fn allows_concurrent(&self) -> bool { false } @@ -101,7 +101,7 @@ impl std::fmt::Debug for Box { /// Overwrite channel: each write replaces the value (last-value semantics). /// /// Rejects concurrent same-step writes from multiple branches with -/// [`crate::GraphError::InvalidConcurrentUpdate`]. +/// `crate::GraphError::InvalidConcurrentUpdate`. #[derive(Clone, Copy, Debug, Default)] pub struct LastValue; diff --git a/crates/tinyflows/src/graph/checkpoint/mod.rs b/crates/tinyflows/src/graph/checkpoint/mod.rs index 1d91592a..1c7721e6 100644 --- a/crates/tinyflows/src/graph/checkpoint/mod.rs +++ b/crates/tinyflows/src/graph/checkpoint/mod.rs @@ -5,11 +5,11 @@ //! another compiled graph, which can run another, each producing its own state. //! Checkpointing snapshots every level of that tree at superstep boundaries and //! keys them by `thread_id`/`namespace` so a parent and its embedded subgraphs -//! never collide (see [`crate::graph::subgraph`]). Persisting committed state at +//! never collide (see `crate::graph::subgraph`). Persisting committed state at //! each boundary is what lets a run be paused on an interrupt, resumed later, //! forked, or replayed for time-travel debugging. //! -//! See [`types`] for the checkpoint record definitions. Checkpoints are written +//! See `types` for the checkpoint record definitions. Checkpoints are written //! at superstep boundaries only — never mid-node — so resuming always reruns a //! node from its start. diff --git a/crates/tinyflows/src/graph/command/mod.rs b/crates/tinyflows/src/graph/command/mod.rs index bace91a1..5240b62e 100644 --- a/crates/tinyflows/src/graph/command/mod.rs +++ b/crates/tinyflows/src/graph/command/mod.rs @@ -8,7 +8,7 @@ //! run for human-in-the-loop input, which the durable executor checkpoints and //! later resumes. //! -//! See [`types`] for the definitions. +//! See `types` for the definitions. mod types; diff --git a/crates/tinyflows/src/graph/compiled/executor/api.rs b/crates/tinyflows/src/graph/compiled/executor/api.rs index 9bcc5b6c..5af0cab3 100644 --- a/crates/tinyflows/src/graph/compiled/executor/api.rs +++ b/crates/tinyflows/src/graph/compiled/executor/api.rs @@ -100,7 +100,7 @@ where /// human interrupt): after a node handler aborts a checkpointed run — a /// transient outage that outlived the node-retry policy, or a hard crash — /// the run leaves a resumable checkpoint (see - /// [`CompiledGraph::with_node_retry`]). Calling `retry` re-runs exactly what + /// `CompiledGraph::with_node_retry`). Calling `retry` re-runs exactly what /// did not complete, carrying no resume value. It is shorthand for /// [`CompiledGraph::resume`] with an empty [`Command`]. /// diff --git a/crates/tinyflows/src/graph/compiled/mod.rs b/crates/tinyflows/src/graph/compiled/mod.rs index 7aba62f4..23a1b315 100644 --- a/crates/tinyflows/src/graph/compiled/mod.rs +++ b/crates/tinyflows/src/graph/compiled/mod.rs @@ -18,7 +18,7 @@ //! By default execution is sequential within a step. When the graph is compiled //! with [`crate::graph::GraphBuilder::with_parallel`], a step with more than one //! active node runs every branch concurrently via -//! [`futures::future::join_all`], yet the data flow — snapshot reads, boundary +//! `futures::future::join_all`, yet the data flow — snapshot reads, boundary //! reducer application, boundary checkpointing — is identical: each branch reads //! the same committed snapshot (its own clone), and results are folded into the //! reducer in deterministic active-set order at the step boundary, so the merged @@ -45,11 +45,11 @@ //! restartable after a hard one: //! //! - **Node retry.** With -//! [`CompiledGraph::with_node_retry`], a node whose handler fails with a -//! [retryable][crate::harness::retry::is_retryable] error (a model or tool +//! `CompiledGraph::with_node_retry`, a node whose handler fails with a +//! retryablecrate::harness::retry::is_retryable error (a model or tool //! error — the transient class) is re-run from its start up to the policy's //! attempt cap, emitting -//! [`GraphEvent::NodeRetryScheduled`](crate::graph::stream::GraphEvent::NodeRetryScheduled) +//! [`GraphEvent::NodeRetryScheduled`] //! and sleeping the opt-in backoff between attempts. A single network blip is //! absorbed without touching the run. //! - **Resumable failure.** When a handler fails beyond the retry budget (or the diff --git a/crates/tinyflows/src/graph/compiled/types.rs b/crates/tinyflows/src/graph/compiled/types.rs index 1640c14e..3a6ea9f5 100644 --- a/crates/tinyflows/src/graph/compiled/types.rs +++ b/crates/tinyflows/src/graph/compiled/types.rs @@ -285,7 +285,7 @@ pub struct GraphInput { /// Target node for this input. `__start__` is accepted as the virtual entry /// target and is resolved to the graph's compiled entry node at run time. pub node: NodeId, - /// Optional per-input payload delivered as [`NodeContext::send_arg`]. + /// Optional per-input payload delivered as `NodeContext::send_arg`. pub payload: Option, } diff --git a/crates/tinyflows/src/graph/ids/mod.rs b/crates/tinyflows/src/graph/ids/mod.rs index c8ad111c..5533afe9 100644 --- a/crates/tinyflows/src/graph/ids/mod.rs +++ b/crates/tinyflows/src/graph/ids/mod.rs @@ -2,13 +2,13 @@ //! //! These ids are the keys that make recursion observable and correlatable: a //! [`RunId`] names one run, and pairing it with the `root_run_id` / -//! `parent_run_id` recorded in [`crate::harness::events::HarnessRunStatus`] lets +//! `parent_run_id` recorded in `crate::harness::events::HarnessRunStatus` lets //! a child run (a sub-agent or sub-graph invocation) be traced back up to the //! top-level run that spawned it. A `From`/`Display`/`as_str` surface is //! generated for each newtype by a single macro so the ids stay cheap to clone, //! log, and serialize. //! -//! See [`types`] for the type definitions. This module provides the shared +//! See `types` for the type definitions. This module provides the shared //! constructors, accessors, and conversions for every id newtype. mod types; diff --git a/crates/tinyflows/src/graph/ids/types.rs b/crates/tinyflows/src/graph/ids/types.rs index f0b82500..08a720db 100644 --- a/crates/tinyflows/src/graph/ids/types.rs +++ b/crates/tinyflows/src/graph/ids/types.rs @@ -12,7 +12,7 @@ use serde::{Deserialize, Serialize}; /// /// A `RunId` is the unit of recursion in the graph runtime: when a run spawns a /// sub-agent or sub-graph, the child gets its own `RunId` while -/// [`crate::harness::events::HarnessRunStatus`] records that child's +/// `crate::harness::events::HarnessRunStatus` records that child's /// `parent_run_id` (the spawning run) and `root_run_id` (the top-level /// ancestor), so the full recursion tree is reconstructable from these ids. #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)] @@ -54,7 +54,7 @@ pub struct TaskId(pub(crate) String); /// Identifies a single interactive `.ragsh` REPL session. /// -/// A `SessionId` names one [`crate::repl`] session: a persistent namespace and +/// A `SessionId` names one `crate::repl` session: a persistent namespace and /// capability boundary that a (possibly model-driven) orchestrator drives one /// cell at a time. Pairing it with a [`RunId`] lets REPL events and the child /// model/tool/graph runs a session spawns be correlated back to the session diff --git a/crates/tinyflows/src/graph/observability/mod.rs b/crates/tinyflows/src/graph/observability/mod.rs index b8b2332a..7336f71f 100644 --- a/crates/tinyflows/src/graph/observability/mod.rs +++ b/crates/tinyflows/src/graph/observability/mod.rs @@ -11,7 +11,7 @@ //! `checkpoint_id`, subgraph `namespace`, `step`, `offset`, and timestamp. //! - [`GraphEventJournal`] — an append-only, offset-addressable journal of //! observations, with an [`InMemoryGraphEventJournal`] and a store-backed -//! [`StoreGraphEventJournal`] (stream key = run id). +//! `StoreGraphEventJournal` (stream key = run id). //! - [`GraphStatusStore`] — a compact "what is running now?" surface over //! [`crate::graph::GraphRunStatus`], with an [`InMemoryGraphStatusStore`]. //! - [`JournalGraphSink`] — a [`GraphEventSink`] that wraps each emitted event @@ -32,7 +32,7 @@ //! //! The journaling sink bridges the synchronous [`GraphEventSink::emit`] hook to //! the async journal API through a background drain (an -//! [`AppendWorker`](crate::harness::observability)): `emit` never blocks the +//! `AppendWorker`): `emit` never blocks the //! executor on I/O and persistence is best-effort (a full bounded queue drops //! rather than stalls; backend errors are reported, not propagated). The //! executor calls [`GraphEventSink::flush`] after the terminal run event so a diff --git a/crates/tinyflows/src/graph/observability/types.rs b/crates/tinyflows/src/graph/observability/types.rs index ab78507f..6336772c 100644 --- a/crates/tinyflows/src/graph/observability/types.rs +++ b/crates/tinyflows/src/graph/observability/types.rs @@ -155,7 +155,7 @@ pub struct GraphLatencyMetrics { /// Health rollup for a single graph node across one run. /// /// A graph node is the graph's unit of work — frequently a delegated agent or -/// tool call (see [`crate::graph::SubAgentNode`]) — so per-node success/failure +/// tool call (see `crate::graph::SubAgentNode`) — so per-node success/failure /// counts double as **tool health** telemetry for the graph. Counts are derived /// from durable [`GraphObservation`]s by correlating `node.started` with /// `node.completed` / `node.failed`. @@ -350,7 +350,7 @@ pub(crate) struct StatusStoreState { /// The sink is configured with the emitting run's lineage and checkpoint /// coordinates; each received event is stamped with a monotonically increasing /// `offset`, the latest observed `step`, and the configured `namespace`. The -/// observation is then handed to a background [`AppendWorker`] that persists it +/// observation is then handed to a background `AppendWorker` that persists it /// off the executor thread (best-effort — a full bounded queue drops rather /// than stalling the run, and append errors are reported, not propagated). /// [`crate::graph::stream::GraphEventSink::flush`] blocks until the durable log diff --git a/crates/tinyflows/src/graph/recursion/mod.rs b/crates/tinyflows/src/graph/recursion/mod.rs index 17831b4a..c23ed6fe 100644 --- a/crates/tinyflows/src/graph/recursion/mod.rs +++ b/crates/tinyflows/src/graph/recursion/mod.rs @@ -18,11 +18,11 @@ //! the stack stays symmetric and always describes the path from the root run //! to the current one. //! -//! The executor ([`crate::graph::CompiledGraph::execute`]) builds one stack per +//! The executor (`crate::graph::CompiledGraph::execute`) builds one stack per //! run, tracks graph-call depth separately from node-loop visits, enforces the -//! caps with clear recursion errors ([`crate::GraphError::SubAgentDepth`], -//! [`crate::GraphError::NodeVisitLimit`], -//! [`crate::GraphError::RecursionLimit`]), records the current stack into +//! caps with clear recursion errors (`crate::GraphError::SubAgentDepth`, +//! `crate::GraphError::NodeVisitLimit`, +//! `crate::GraphError::RecursionLimit`), records the current stack into //! checkpoint metadata under a `recursion` array, and emits the live depth on //! [`crate::graph::GraphEvent::RecursionDepthChanged`]. diff --git a/crates/tinyflows/src/graph/reducer/mod.rs b/crates/tinyflows/src/graph/reducer/mod.rs index d5285931..167d9898 100644 --- a/crates/tinyflows/src/graph/reducer/mod.rs +++ b/crates/tinyflows/src/graph/reducer/mod.rs @@ -6,7 +6,7 @@ //! updates back into one committed state through a reducer, in deterministic //! active-set order, so merged state is reproducible regardless of completion //! order. This module supplies the built-in channel/state reducers and the -//! closure-backed escape hatches; see [`types`] for the trait and marker +//! closure-backed escape hatches; see `types` for the trait and marker //! definitions. mod types; diff --git a/crates/tinyflows/src/graph/status/mod.rs b/crates/tinyflows/src/graph/status/mod.rs index 609dfb55..4a617fdc 100644 --- a/crates/tinyflows/src/graph/status/mod.rs +++ b/crates/tinyflows/src/graph/status/mod.rs @@ -8,7 +8,7 @@ //! tree that links a parent graph to the subgraphs and sub-agents it recurses //! into, so progress, interrupts, and errors can be rolled up across levels. //! -//! See [`types`] for the [`GraphRunStatus`] definition. +//! See `types` for the [`GraphRunStatus`] definition. mod types; diff --git a/crates/tinyflows/src/graph/stream/mod.rs b/crates/tinyflows/src/graph/stream/mod.rs index c3fa4055..7b00e73a 100644 --- a/crates/tinyflows/src/graph/stream/mod.rs +++ b/crates/tinyflows/src/graph/stream/mod.rs @@ -9,7 +9,7 @@ //! real time; because every event is tagged with its node and step, the streams //! of nested runs can be merged and attributed back up the run tree. //! -//! See [`types`] for the event and stream-mode definitions. The executor emits +//! See `types` for the event and stream-mode definitions. The executor emits //! [`GraphEvent`]s into an optional [`GraphEventSink`]; callers can plug in a //! [`NoopSink`], a test-friendly [`CollectingSink`], or any custom transport. diff --git a/crates/tinyflows/src/interception.rs b/crates/tinyflows/src/interception.rs index fd10f63b..58328093 100644 --- a/crates/tinyflows/src/interception.rs +++ b/crates/tinyflows/src/interception.rs @@ -6,8 +6,8 @@ //! and the wrong one for a debugger, which has to be able to say "stop here", //! "use this value instead", and "pretend that failed". //! -//! So this is the other half: a [`StepInterceptor`] is consulted before and -//! after every non-trigger node activation, and the [`StepAction`] it returns is +//! So this is the other half: a `StepInterceptor` is consulted before and +//! after every non-trigger node activation, and the `StepAction` it returns is //! obeyed. It is what [`crate::testkit`] is built on, and a host may implement //! it directly for a fault-injection harness of its own. //! @@ -29,7 +29,7 @@ //! detach, and drop for exactly this reason. //! //! **Nothing here costs anything when unused.** The engine holds an -//! `Option>` and builds a [`StepFrame`] only when it is +//! `Option>` and builds a `StepFrame` only when it is //! `Some`, so a run with no interceptor pays two `Option` checks per activation //! and constructs nothing. //! @@ -130,7 +130,7 @@ pub enum StepAction { /// genuine failure instead. Fail { /// The failure message, reported as an - /// [`EngineError::Capability`](crate::error::EngineError::Capability). + /// [`EngineError::Capability`]. message: String, }, /// Raise a real graph interrupt here, checkpointing the run. diff --git a/crates/tinyflows/src/lib.rs b/crates/tinyflows/src/lib.rs index 2326c6e7..2ff2be53 100644 --- a/crates/tinyflows/src/lib.rs +++ b/crates/tinyflows/src/lib.rs @@ -4,7 +4,7 @@ //! tinyflows models an automation as a [`model::WorkflowGraph`]: a directed graph //! of typed [`model::Node`]s connected by [`model::Edge`]s. A [`compiler::compile`] //! step validates the graph and (from stage A1) lowers it onto the -//! in-crate [`graph`](crate::graph) state-graph runtime, which +//! in-crate [`graph`] state-graph runtime, which //! the [`engine::run`] entry point drives. //! //! The crate is deliberately **host-agnostic**: anything that touches the outside diff --git a/crates/tinyflows/src/model/node_kind.rs b/crates/tinyflows/src/model/node_kind.rs index 59199ab9..19a3f6ad 100644 --- a/crates/tinyflows/src/model/node_kind.rs +++ b/crates/tinyflows/src/model/node_kind.rs @@ -111,7 +111,7 @@ pub enum NodeKind { /// The policy (`all` / `any` / `first_n` / `quorum` / `timeout_partial`) /// is what makes this more than a barrier: a gate can proceed on a quorum /// and leave the stragglers, or settle for whatever arrived before its - /// deadline. See [`crate::nodes::release`]. + /// deadline. See `crate::nodes::release`. Gate, /// Terminal sink: accepts items on `main`, discards them, and activates no /// successors. The branch ends here, on purpose. diff --git a/crates/tinyflows/src/nodes/control_flow/dedup.rs b/crates/tinyflows/src/nodes/control_flow/dedup.rs index 6bbd2dbf..6a78b3de 100644 --- a/crates/tinyflows/src/nodes/control_flow/dedup.rs +++ b/crates/tinyflows/src/nodes/control_flow/dedup.rs @@ -71,11 +71,11 @@ //! # Runtime behavior (per item) //! //! 1. Resolve `config.key` against the item (same `"=expr"` resolver as -//! `condition`/`memory`, via [`crate::nodes::resolve_config_traced_for_item`]). +//! `condition`/`memory`, via `crate::nodes::resolve_config_traced_for_item`). //! 2. A key that resolves to `null`, is absent, or is an empty string //! **fails open**: the item passes through and is NOT recorded anywhere. //! An item is never silently dropped just because its key could not be -//! computed — see [`resolve_key`]. +//! computed — see `resolve_key`. //! 3. Otherwise, if the key is already in `committed` **or** was already seen //! earlier in this same batch, the item is dropped. //! 4. Otherwise, the item passes through and the key is added to this run's diff --git a/crates/tinyflows/src/nodes/control_flow/loop_node.rs b/crates/tinyflows/src/nodes/control_flow/loop_node.rs index e4fa3329..e259946b 100644 --- a/crates/tinyflows/src/nodes/control_flow/loop_node.rs +++ b/crates/tinyflows/src/nodes/control_flow/loop_node.rs @@ -32,7 +32,7 @@ //! Because the reducer merges objects key-by-key, an accumulator written //! plainly could only ever *gain* keys — an error recorded on pass 1 would //! haunt every later pass. The accumulator is therefore written through -//! [`crate::engine::replace`], which assigns the slot wholesale. +//! `crate::engine::replace`, which assigns the slot wholesale. //! //! **The fold is at-least-once.** If an activation is replayed after a resume, //! the update applies twice. This is not new — `iteration + 1` has always had diff --git a/crates/tinyflows/src/nodes/integration/agent.rs b/crates/tinyflows/src/nodes/integration/agent.rs index 0443c7ce..843c33d6 100644 --- a/crates/tinyflows/src/nodes/integration/agent.rs +++ b/crates/tinyflows/src/nodes/integration/agent.rs @@ -77,7 +77,7 @@ fn drain(sink: &TranscriptSink) -> Vec { /// multi-turn tool-use loop is a documented follow-up. /// - **output-parser sub-port** (`config.output_parser`): after the completion /// (and any tool hop), the resulting value is validated/repaired against -/// `config.output_parser.schema` using the shared [`schema`] routine +/// `config.output_parser.schema` using the shared `schema` routine /// (validate → one LLM auto-fix → re-validate), honoring /// `config.output_parser.auto_fix` (default `true`). /// @@ -92,7 +92,7 @@ fn drain(sink: &TranscriptSink) -> Vec { /// [`AgentRunRequest`](crate::caps::AgentRunRequest) carrying the resolved /// instructions, model, provider, working directory, context blocks, tool /// descriptors, limits, and metadata. See -/// [`agent_request`](super::agent_request) for the merge rules. +/// `agent_request` for the merge rules. /// /// The inline tool sub-port is skipped on that path (the agent owns its own tool /// loop, and re-invoking a tool it already called would duplicate the side diff --git a/crates/tinyflows/src/nodes/integration/agent_prompt.rs b/crates/tinyflows/src/nodes/integration/agent_prompt.rs index 1d513297..bc8fc25d 100644 --- a/crates/tinyflows/src/nodes/integration/agent_prompt.rs +++ b/crates/tinyflows/src/nodes/integration/agent_prompt.rs @@ -1,7 +1,7 @@ //! The pure half of turning an `agent` node's request into a model call and the //! reply back into a node result. //! -//! Sits beside [`agent_request`](super::agent_request): that module assembles the +//! Sits beside `agent_request`: that module assembles the //! declarative [`AgentRunRequest`](crate::caps::AgentRunRequest); this one //! handles the looser JSON *completion request* a host adapter receives //! (`prompt`, `messages`, `input_context`, `output_parser`, `model`, diff --git a/crates/tinyflows/src/nodes/integration/approval.rs b/crates/tinyflows/src/nodes/integration/approval.rs index 12a40647..2ba2180a 100644 --- a/crates/tinyflows/src/nodes/integration/approval.rs +++ b/crates/tinyflows/src/nodes/integration/approval.rs @@ -40,7 +40,7 @@ //! 2. **The run's approvals list** (`run.trigger.approvals`) — the //! re-execute resume path, and how `engine::resume` has always delivered an //! approval. Listing this node's id there approves it. -//! 3. **The host's [`ApprovalProvider`]** — asked once per activation, under +//! 3. **The host's `ApprovalProvider`** — asked once per activation, under //! the create-or-fetch contract documented on the trait. //! 4. **Nobody**, on a host that wired no provider: the node simply waits, so //! it reduces to a pause the host settles through `engine::resume`. diff --git a/crates/tinyflows/src/nodes/integration/gate.rs b/crates/tinyflows/src/nodes/integration/gate.rs index c9dbce80..c14a7bb0 100644 --- a/crates/tinyflows/src/nodes/integration/gate.rs +++ b/crates/tinyflows/src/nodes/integration/gate.rs @@ -3,13 +3,13 @@ //! A gate collects the tickets a [`spawn`](super::spawn) node produced and emits //! their results. What makes it more than a barrier is the release policy: it //! can proceed on the first result, on a quorum, or on whatever arrived before -//! its deadline, rather than only on all of them (see [`crate::nodes::release`]). +//! its deadline, rather than only on all of them (see `crate::nodes::release`). //! //! # How waiting works in a super-step engine //! //! There is no "block here until the callback comes". A gate is activated, //! looks at the world, and either proceeds or asks to be run again — via -//! [`NodeControl::Reenter`], which commits its notes and re-activates it in the +//! `NodeControl::Reenter`, which commits its notes and re-activates it in the //! next super-step. Waiting is therefore counted in **polls**, and every poll //! costs a super-step and a node visit against the run's budgets. That is why //! the poll count is bounded here rather than left to the run-level backstop: diff --git a/crates/tinyflows/src/nodes/integration/http_request.rs b/crates/tinyflows/src/nodes/integration/http_request.rs index e5c0d9a3..b71c9a70 100644 --- a/crates/tinyflows/src/nodes/integration/http_request.rs +++ b/crates/tinyflows/src/nodes/integration/http_request.rs @@ -14,7 +14,7 @@ use crate::nodes::{ExecutionMode, NodeContext, NodeExecutor, NodeOutput, executi /// the input, issuing one request per item with the descriptor re-resolved /// against that item; `once` issues a single request against the first item. /// Output is wrapped in the stable `{ json, text, raw }` -/// [envelope](crate::nodes::integration::envelope), matching the other +/// envelope, matching the other /// capability nodes. #[derive(Debug, Default, Clone)] pub struct HttpRequestNode; diff --git a/crates/tinyflows/src/nodes/integration/memory.rs b/crates/tinyflows/src/nodes/integration/memory.rs index 9e70ebcd..2ccf9b50 100644 --- a/crates/tinyflows/src/nodes/integration/memory.rs +++ b/crates/tinyflows/src/nodes/integration/memory.rs @@ -49,7 +49,7 @@ const LOG_PREFIX: &str = "[memory-node]"; /// invokes once. /// /// Output is wrapped in the stable `{ json, text, raw }` -/// [envelope](crate::nodes::integration::envelope), matching every other +/// envelope, matching every other /// capability node. #[derive(Debug, Default, Clone)] pub struct MemoryNode; diff --git a/crates/tinyflows/src/nodes/integration/output_parser.rs b/crates/tinyflows/src/nodes/integration/output_parser.rs index 2c69025b..2d83de79 100644 --- a/crates/tinyflows/src/nodes/integration/output_parser.rs +++ b/crates/tinyflows/src/nodes/integration/output_parser.rs @@ -16,7 +16,7 @@ use crate::nodes::{NodeContext, NodeExecutor, NodeOutput}; /// re-validates, emitting the repaired value. A value that still fails — or fails /// with `config.auto_fix == false` — surfaces a capability error, which the /// engine routes per the node's `on_error` policy (`stop` / `continue` / -/// `route`). See [`schema`] for the supported schema subset. +/// `route`). See `schema` for the supported schema subset. /// /// Config: /// - `schema` — the JSON Schema to validate against. Omitted / null ⇒ the node is diff --git a/crates/tinyflows/src/nodes/integration/sub_workflow.rs b/crates/tinyflows/src/nodes/integration/sub_workflow.rs index 3908a901..b81cc898 100644 --- a/crates/tinyflows/src/nodes/integration/sub_workflow.rs +++ b/crates/tinyflows/src/nodes/integration/sub_workflow.rs @@ -10,7 +10,7 @@ use crate::nodes::{NodeContext, NodeExecutor, NodeOutput}; /// Runs another workflow as a nested sub-graph. /// -/// The child [`WorkflowGraph`](crate::model::WorkflowGraph) is supplied one of +/// The child [`WorkflowGraph`] is supplied one of /// two ways — **exactly one** of these config keys must be present: /// /// - `workflow` — the child graph embedded **inline** as JSON (back-compat; @@ -20,7 +20,7 @@ use crate::nodes::{NodeContext, NodeExecutor, NodeOutput}; /// host-injected [`WorkflowResolver`](crate::caps::WorkflowResolver) /// (`ctx.caps.resolver`). /// -/// The resolved child is compiled and run via [`crate::engine::run_sub_workflow`], +/// The resolved child is compiled and run via `crate::engine::run_sub_workflow`, /// sharing the host [`Capabilities`](crate::caps::Capabilities) with the parent /// run, and its final run state is emitted as an output item. /// @@ -34,7 +34,7 @@ use crate::nodes::{NodeContext, NodeExecutor, NodeOutput}; /// that item and resolving `workflow_id` against it (so `=item.x` addresses /// the element that run is for). `config.concurrency` bounds how many run at /// a time and `config.on_item_error` what a failing child does to the batch -/// (see [`crate::nodes::map`]). This is how an array of work becomes N +/// (see `crate::nodes::map`). This is how an array of work becomes N /// parallel multi-step workflows. /// /// Only the fields *this* node reads are `=`-resolved; an inline `workflow` diff --git a/crates/tinyflows/src/nodes/integration/tool_call.rs b/crates/tinyflows/src/nodes/integration/tool_call.rs index 35f1e893..b8ad69ff 100644 --- a/crates/tinyflows/src/nodes/integration/tool_call.rs +++ b/crates/tinyflows/src/nodes/integration/tool_call.rs @@ -17,7 +17,7 @@ use crate::nodes::{ExecutionMode, NodeContext, NodeExecutor, NodeOutput, executi /// single time against the first item. With no input, either mode invokes once. /// /// Output is wrapped in the stable `{ json, text, raw }` -/// [envelope](crate::nodes::integration::envelope), matching the `agent` node so +/// envelope, matching the `agent` node so /// a downstream `=item.json.` binding is consistent across capabilities. #[derive(Debug, Default, Clone)] pub struct ToolCallNode; diff --git a/crates/tinyflows/src/observe.rs b/crates/tinyflows/src/observe.rs index e5370f79..2fe03f27 100644 --- a/crates/tinyflows/src/observe.rs +++ b/crates/tinyflows/src/observe.rs @@ -3,9 +3,9 @@ //! The host owns the event bus and the exporter transport; the two mappings //! here are generic over engine types and carry no I/O: //! -//! - [`step_status_str`]: a [`StepStatus`] as the stable string persisted on a +//! - `step_status_str`: a `StepStatus` as the stable string persisted on a //! run step and published in progress events. -//! - [`to_exporter_observations`]: the engine's durable [`GraphObservation`]s +//! - `to_exporter_observations`: the engine's durable `GraphObservation`s //! re-typed for a trace exporter that names its own, structurally identical //! observation type. diff --git a/crates/tinyflows/src/preflight.rs b/crates/tinyflows/src/preflight.rs index 67cfe327..72302633 100644 --- a/crates/tinyflows/src/preflight.rs +++ b/crates/tinyflows/src/preflight.rs @@ -1,7 +1,7 @@ //! Running a graph against schema-aware mocks to find bindings that can never //! resolve, before an author is allowed to save it. //! -//! [`gates`](crate::gates) refuses what is *statically* guaranteed wrong. This +//! [`gates`] refuses what is *statically* guaranteed wrong. This //! module catches the rest of the same failure by actually running the graph: //! the engine records, per step, which `=`-expressions resolved to null while it //! was assembling a node's config, and an outbound argument that resolved to @@ -370,7 +370,7 @@ fn is_trigger_scoped_expression( /// /// Handles both addressing forms the engine can trace: /// - explicit `=nodes....` / `=.nodes[""]...` (parsed via -/// [`explicit_nodes_ref`]), and +/// `explicit_nodes_ref`), and /// - implicit `=item...` / `=items...`, resolved against `node_id`'s direct /// predecessor — but only when there is exactly ONE incoming edge, so an /// ambiguous fan-in is never mis-attributed to a single upstream node. diff --git a/crates/tinyflows/src/store/mod.rs b/crates/tinyflows/src/store/mod.rs index 9e7893a1..370a1a90 100644 --- a/crates/tinyflows/src/store/mod.rs +++ b/crates/tinyflows/src/store/mod.rs @@ -4,11 +4,11 @@ //! [`crate::caps::WorkflowResolver`] — and it only covers resolving a //! `sub_workflow` node's id. Everything else a host needs (listing, saving, //! deleting, recording runs) has no contract upstream, so this module defines -//! one: [`WorkflowStore`]. +//! one: `WorkflowStore`. //! //! The trait exists so the backing store is a decision, not a fact of the //! codebase. This crate ships no implementation: it carries the contract, the -//! record types, the rules a store judges documents by ([`HostPolicy`]), the +//! record types, the rules a store judges documents by (`HostPolicy`), the //! patch-based [`authoring`] on top, and the pieces every implementation //! shares (ids, the revision cap, note pruning). Storage belongs to the //! `tinystoragedrivers` ports, and `tinyflows-drivers`' `DriverWorkflowStore` diff --git a/crates/tinyflows/src/store/types/mod.rs b/crates/tinyflows/src/store/types/mod.rs index 2b5378a1..f7e0537a 100644 --- a/crates/tinyflows/src/store/types/mod.rs +++ b/crates/tinyflows/src/store/types/mod.rs @@ -14,11 +14,11 @@ //! The submodules split the model by lifetime rather than by shape, because //! that is what decides where each type is stored: //! -//! - [`workflow`] — the versioned document an operator edits. -//! - [`run`] — one execution's durable record, written once and never revised. -//! - [`note`] — what the host has learned about a workflow across runs. -//! - [`proposal`] — a graph change suggested but not yet made. -//! - [`error`] — the failure vocabulary every surface reports through. +//! - `workflow` — the versioned document an operator edits. +//! - `run` — one execution's durable record, written once and never revised. +//! - `note` — what the host has learned about a workflow across runs. +//! - `proposal` — a graph change suggested but not yet made. +//! - `error` — the failure vocabulary every surface reports through. //! - [`TranscriptEntry`] — one line of what an agent did inside a step, //! re-exported from [`crate::transcript`] because the engine carries it too. //! diff --git a/crates/tinyflows/src/store/types/run.rs b/crates/tinyflows/src/store/types/run.rs index f12a31b4..151cc5ca 100644 --- a/crates/tinyflows/src/store/types/run.rs +++ b/crates/tinyflows/src/store/types/run.rs @@ -231,7 +231,7 @@ pub struct RunRecord { /// The single most useful thing about a run that the graph cannot supply: /// two runs of one workflow differ only in what was passed to them, so a /// history that omitted this listed the same sentence over and over. Bounded - /// per value ([`MAX_INPUT_BYTES`]) rather than whole, because every surface + /// per value (`MAX_INPUT_BYTES`) rather than whole, because every surface /// that lists runs shows all of a run's inputs at once. /// /// Empty on a workflow that declares no inputs, and on records written diff --git a/crates/tinyflows/src/store/types/workflow.rs b/crates/tinyflows/src/store/types/workflow.rs index 009f2301..97537bfb 100644 --- a/crates/tinyflows/src/store/types/workflow.rs +++ b/crates/tinyflows/src/store/types/workflow.rs @@ -54,7 +54,7 @@ fn default_enabled() -> bool { /// Stored as free-form strings rather than parsed types because a workflow may /// legitimately name a custom harness preset only some hosts expose. The /// meaning of these strings — and the refusal of one that cannot be a harness — -/// lives in [`crate::flow_engine::harness_choice`]. +/// lives in `crate::flow_engine::harness_choice`. #[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] pub struct WorkflowDefaults { diff --git a/crates/tinyflows/src/testkit/mocks.rs b/crates/tinyflows/src/testkit/mocks.rs index 30ffada4..b2fc1547 100644 --- a/crates/tinyflows/src/testkit/mocks.rs +++ b/crates/tinyflows/src/testkit/mocks.rs @@ -91,7 +91,7 @@ pub enum Respond { /// Return this value. Value(Value), /// Fail with this message, as an - /// [`EngineError::Capability`](crate::error::EngineError::Capability). + /// [`EngineError::Capability`]. Error(String), /// Answer the nth matching call with the nth entry. /// diff --git a/crates/tinyflows/src/testkit/mod.rs b/crates/tinyflows/src/testkit/mod.rs index c24814b6..9bdfb2c0 100644 --- a/crates/tinyflows/src/testkit/mod.rs +++ b/crates/tinyflows/src/testkit/mod.rs @@ -9,15 +9,15 @@ //! //! This module is that, in four layers, each usable on its own: //! -//! - [`mocks`] — programmable capability doubles with a call log. Say what a +//! - `mocks` — programmable capability doubles with a call log. Say what a //! tool returns, make the third call fail, and ask afterwards exactly what was //! sent where. -//! - [`trace`] — a structured record of a run: every node's input and output, +//! - `trace` — a structured record of a run: every node's input and output, //! every `=`-binding with the value it resolved to, every capability call, and //! the diagnosis of what a green run is hiding. -//! - [`harness`] — the ergonomic front door for a test: build, mock, run, +//! - `harness` — the ergonomic front door for a test: build, mock, run, //! assert. -//! - [`debug`] — breakpoints. Pause a run before or after a node, inspect what +//! - `debug` — breakpoints. Pause a run before or after a node, inspect what //! it was about to receive, override it, and step on. //! //! Everything is built on [`crate::interception`], the engine's one @@ -27,7 +27,7 @@ //! # For agents, not only for tests //! //! Workflows here are written by agents as often as by people, and an agent -//! that cannot debug what it wrote can only guess at why it failed. [`tools`] +//! that cannot debug what it wrote can only guess at why it failed. `tools` //! exposes every capability above as a named tool with a JSON Schema and a //! JSON-in/JSON-out handler, so a host can hand the whole of this module to an //! agent without writing an adapter. tinyflows still talks to no model itself: diff --git a/crates/tinyflows/src/testkit/trace.rs b/crates/tinyflows/src/testkit/trace.rs index e51f5feb..5ce22c5b 100644 --- a/crates/tinyflows/src/testkit/trace.rs +++ b/crates/tinyflows/src/testkit/trace.rs @@ -1,6 +1,6 @@ //! A structured record of what a run actually did. //! -//! [`RunObserver`](crate::observability::RunObserver) reports a node's *output* +//! [`RunObserver`] reports a node's *output* //! after the fact. That is the wrong half of the question. When a workflow runs //! green and does nothing, the output is exactly what a correct run's output //! looks like — an object, no errors — and the thing that went wrong is @@ -15,7 +15,7 @@ //! produced it. //! //! Assembled from the [`StepInterceptor`] (which sees a node before it runs) -//! and a [`RunObserver`](crate::observability::RunObserver) (which sees how long +//! and a [`RunObserver`] (which sees how long //! it took), because neither can supply the whole picture alone. use std::sync::Mutex; @@ -238,7 +238,7 @@ struct TraceState { /// /// Implements both [`StepInterceptor`] — which is how it sees a node's input and /// bindings *before* the node runs — and -/// [`RunObserver`](crate::observability::RunObserver), which is how it learns +/// [`RunObserver`], which is how it learns /// how long each activation took. Pass the same instance as both. /// /// Attach a [`MockCaps`] to have the run's capability calls folded into the diff --git a/crates/tinyflows/src/triggers.rs b/crates/tinyflows/src/triggers.rs index 2420ebdb..2d9639d3 100644 --- a/crates/tinyflows/src/triggers.rs +++ b/crates/tinyflows/src/triggers.rs @@ -3,9 +3,9 @@ //! //! A flow whose trigger is `webhook`, `form`, `chat_message`, ... is accepted //! and saved, but a host that has not wired that dispatch path never runs it. -//! [`graph_trigger_warnings`] turns that silence into a non-fatal warning. -//! The set of kinds that fire is [`trigger_kind_fires`]; a host that wires more -//! kinds filters the warning itself with [`graph_trigger_warnings_for`]. +//! `graph_trigger_warnings` turns that silence into a non-fatal warning. +//! The set of kinds that fire is `trigger_kind_fires`; a host that wires more +//! kinds filters the warning itself with `graph_trigger_warnings_for`. use crate::model::{TriggerKind, WorkflowGraph}; diff --git a/crates/tinyflows/src/validate.rs b/crates/tinyflows/src/validate.rs index d7b311c4..904de958 100644 --- a/crates/tinyflows/src/validate.rs +++ b/crates/tinyflows/src/validate.rs @@ -24,7 +24,7 @@ fn kind_name(kind: &NodeKind) -> String { /// sanity (a known value, and an `error` edge when the policy is `route`), /// `void` topology (a terminal sink may have no outgoing edge, and must have an /// incoming one), declared-input sanity (addressable, unique names; defaults -/// that match their declared type), and loop legality (see [`validate_loops`] — cycles are +/// that match their declared type), and loop legality (see `validate_loops` — cycles are /// permitted; only the ones that cannot iterate are refused). /// /// # Errors diff --git a/vendor/tinybus b/vendor/tinybus index 2b2ac165..6ce06bc6 160000 --- a/vendor/tinybus +++ b/vendor/tinybus @@ -1 +1 @@ -Subproject commit 2b2ac165505bdf3dc19c26e0b93c54fb4257bd3c +Subproject commit 6ce06bc674e4f4d718aa51e643ef62c1f372e270