From eca9970994adc8fdd0a8c7b9f92effa23b0fedc2 Mon Sep 17 00:00:00 2001 From: Helge Sverre Date: Fri, 31 Jul 2026 07:55:09 +0200 Subject: [PATCH 01/11] add compiled workflow policy core --- .github/workflows/publish-npm.yml | 1 + Cargo.lock | 37 + Cargo.toml | 4 + crates/sema-policy/Cargo.toml | 16 + crates/sema-policy/src/lib.rs | 1352 +++++++++++++++++++++++++++++ 5 files changed, 1410 insertions(+) create mode 100644 crates/sema-policy/Cargo.toml create mode 100644 crates/sema-policy/src/lib.rs diff --git a/.github/workflows/publish-npm.yml b/.github/workflows/publish-npm.yml index 329e0818..08063cb4 100644 --- a/.github/workflows/publish-npm.yml +++ b/.github/workflows/publish-npm.yml @@ -81,6 +81,7 @@ jobs: publish sema-fmt publish sema-vm publish sema-otel + publish sema-policy publish sema-workflow publish sema-llm publish sema-stdlib diff --git a/Cargo.lock b/Cargo.lock index e968cf08..54649d4d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -307,6 +307,16 @@ dependencies = [ "objc2", ] +[[package]] +name = "bstr" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1f7dc094d718f2e1c1559ad110e27eeaae14a5465d3d56dd6dbd793079fbd530" +dependencies = [ + "memchr", + "serde_core", +] + [[package]] name = "bumpalo" version = "3.20.2" @@ -1305,6 +1315,19 @@ version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280" +[[package]] +name = "globset" +version = "0.4.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e47d37d2ae4464254884b60ab7071be2b876a9c35b696bd018ddcc76847309cd" +dependencies = [ + "aho-corasick", + "bstr", + "log", + "regex-automata", + "regex-syntax", +] + [[package]] name = "h2" version = "0.4.13" @@ -3571,6 +3594,7 @@ dependencies = [ "sema-core", "sema-io", "sema-otel", + "sema-policy", "serde", "serde_json", "sha2 0.10.9", @@ -3655,6 +3679,18 @@ dependencies = [ "tokio", ] +[[package]] +name = "sema-policy" +version = "1.33.0" +dependencies = [ + "globset", + "sema-core", + "serde_json", + "sha2 0.10.9", + "thiserror 2.0.18", + "url", +] + [[package]] name = "sema-reader" version = "1.33.0" @@ -3702,6 +3738,7 @@ dependencies = [ "sema-io", "sema-llm", "sema-otel", + "sema-policy", "sema-reader", "sema-vm", "sema-workflow", diff --git a/Cargo.toml b/Cargo.toml index fc323dfd..29bc6490 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -16,6 +16,7 @@ members = [ "crates/sema-docs", "crates/sema-mcp", "crates/sema-otel", + "crates/sema-policy", "crates/sema-workflow", ] resolver = "2" @@ -43,6 +44,7 @@ default-members = [ "crates/sema-docs", "crates/sema-mcp", "crates/sema-otel", + "crates/sema-policy", "crates/sema-workflow", ] @@ -68,6 +70,7 @@ sema-notebook = { version = "=1.33.0", path = "crates/sema-notebook" } sema-docs = { version = "=1.33.0", path = "crates/sema-docs" } sema-mcp = { version = "=1.33.0", path = "crates/sema-mcp" } sema-otel = { version = "=1.33.0", path = "crates/sema-otel" } +sema-policy = { version = "=1.33.0", path = "crates/sema-policy" } sema-workflow = { version = "=1.33.0", path = "crates/sema-workflow" } tower-lsp = "0.20" @@ -109,6 +112,7 @@ unicode-width = "0.1" unicode-segmentation = "1" caseless = "0.2" glob = "0.3" +globset = "0.4" hostname = "0.4" libc = "0.2" pdf-extract = "0.12" diff --git a/crates/sema-policy/Cargo.toml b/crates/sema-policy/Cargo.toml new file mode 100644 index 00000000..7803b4ac --- /dev/null +++ b/crates/sema-policy/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "sema-policy" +version.workspace = true +edition.workspace = true +license.workspace = true +repository.workspace = true +homepage.workspace = true +description = "Deterministic policy compiler and matcher for Sema workflows" + +[dependencies] +sema-core.workspace = true +globset.workspace = true +serde_json.workspace = true +sha2.workspace = true +thiserror.workspace = true +url.workspace = true diff --git a/crates/sema-policy/src/lib.rs b/crates/sema-policy/src/lib.rs new file mode 100644 index 00000000..fdab675c --- /dev/null +++ b/crates/sema-policy/src/lib.rs @@ -0,0 +1,1352 @@ +//! Deterministic workflow policy compilation and boundary matching. +//! +//! This crate is deliberately runtime-agnostic. It compiles immutable Sema maps +//! into Rust-only policy data, evaluates resolved model identities and +//! model-supplied tool arguments, and returns decisions for the workflow/LLM +//! integration layers to enforce and journal. + +use globset::{GlobBuilder, GlobMatcher}; +use sema_core::Value; +use sha2::{Digest, Sha256}; +use std::collections::{BTreeMap, BTreeSet}; +use std::path::{Component, Path, PathBuf}; +use thiserror::Error; +use url::{Host, Url}; + +const POLICY_VERSION: i64 = 1; + +/// A policy definition or matcher compilation error. +#[derive(Debug, Error, Clone, PartialEq, Eq)] +pub enum PolicyError { + #[error("{0}")] + Invalid(String), +} + +/// The default effect when no explicit rule matches. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum DefaultEffect { + Allow, + Deny, +} + +/// What a model gate does with a denied fallback target. +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] +pub enum ModelDenyAction { + Skip, + Fail, +} + +/// What an agent loop does with a denied tool call. +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] +pub enum ToolDenyAction { + ToolError, + Fail, +} + +/// The result of checking one policy layer. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct PolicyCheck { + pub allowed: bool, + pub rule: String, + pub reason: Option, +} + +impl PolicyCheck { + fn allow(rule: impl Into) -> Self { + Self { + allowed: true, + rule: rule.into(), + reason: None, + } + } + + fn deny(rule: impl Into, reason: impl Into) -> Self { + Self { + allowed: false, + rule: rule.into(), + reason: Some(reason.into()), + } + } +} + +/// One compiled, named policy layer. +#[derive(Debug)] +pub struct CompiledPolicy { + name: String, + fingerprint: String, + models: Option, + tools: Option, +} + +impl CompiledPolicy { + /// Compile a `defpolicy` map or an inline policy map. + pub fn compile(value: &Value) -> Result { + let map = require_map(value, "policy")?; + reject_unknown_keys( + map, + &["__policy-name", "__policy-version", "models", "tools"], + "policy", + )?; + + let name = get(map, "__policy-name") + .and_then(value_name) + .unwrap_or_else(|| "inline-policy".to_string()); + if name.trim().is_empty() { + return Err(invalid("policy name must not be empty")); + } + + if let Some(version) = get(map, "__policy-version") { + let version = version + .as_int() + .ok_or_else(|| invalid(":__policy-version must be an integer"))?; + if version != POLICY_VERSION { + return Err(invalid(format!( + "unsupported policy version {version}; expected {POLICY_VERSION}" + ))); + } + } + + let models = get(map, "models").map(ModelPolicy::compile).transpose()?; + let tools = get(map, "tools").map(ToolPolicy::compile).transpose()?; + let fingerprint = fingerprint(value, &name); + + Ok(Self { + name, + fingerprint, + models, + tools, + }) + } + + pub fn name(&self) -> &str { + &self.name + } + + /// Stable SHA-256 digest over the policy name, version, and canonical map. + pub fn fingerprint(&self) -> &str { + &self.fingerprint + } + + pub fn model_action(&self) -> ModelDenyAction { + self.models + .as_ref() + .map_or(ModelDenyAction::Fail, |policy| policy.on_deny) + } + + pub fn tool_action(&self) -> ToolDenyAction { + self.tools + .as_ref() + .map_or(ToolDenyAction::Fail, |policy| policy.on_deny) + } + + /// Check a fully resolved provider/model pair. + pub fn check_model(&self, provider: &str, model: &str) -> PolicyCheck { + self.models.as_ref().map_or_else( + || PolicyCheck::allow("models.unrestricted"), + |policy| policy.check(provider, model), + ) + } + + /// Check a named tool and its model-supplied JSON arguments. + pub fn check_tool( + &self, + tool: &str, + arguments: &serde_json::Value, + workspace_root: &Path, + ) -> PolicyCheck { + self.tools.as_ref().map_or_else( + || PolicyCheck::allow("tools.unrestricted"), + |policy| policy.check(tool, arguments, workspace_root), + ) + } +} + +#[derive(Debug)] +struct ModelPolicy { + default: DefaultEffect, + allow: Vec, + deny: Vec, + on_deny: ModelDenyAction, +} + +impl ModelPolicy { + fn compile(value: &Value) -> Result { + let map = require_map(value, ":models")?; + reject_unknown_keys(map, &["default", "allow", "deny", "on-deny"], ":models")?; + Ok(Self { + default: parse_default(get(map, "default"), ":models")?, + allow: parse_model_patterns(get(map, "allow"), ":models :allow")?, + deny: parse_model_patterns(get(map, "deny"), ":models :deny")?, + on_deny: match get(map, "on-deny").and_then(value_name).as_deref() { + None | Some("fail") => ModelDenyAction::Fail, + Some("skip") => ModelDenyAction::Skip, + Some(other) => { + return Err(invalid(format!( + ":models :on-deny must be :fail or :skip, got {other:?}" + ))) + } + }, + }) + } + + fn check(&self, provider: &str, model: &str) -> PolicyCheck { + if self + .deny + .iter() + .any(|pattern| pattern.matches(provider, model)) + { + return PolicyCheck::deny( + "models.deny", + format!("model {provider}/{model} matches a deny rule"), + ); + } + if self + .allow + .iter() + .any(|pattern| pattern.matches(provider, model)) + { + return PolicyCheck::allow("models.allow"); + } + match self.default { + DefaultEffect::Allow => PolicyCheck::allow("models.default-allow"), + DefaultEffect::Deny => PolicyCheck::deny( + "models.default-deny", + format!("model {provider}/{model} is not allowlisted"), + ), + } + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +struct ModelPattern { + provider: String, + model: Option, +} + +impl ModelPattern { + fn parse(value: &str) -> Result { + let (provider, model) = value.split_once('/').ok_or_else(|| { + invalid(format!( + "model rule {value:?} must use provider/model syntax" + )) + })?; + if provider.is_empty() || model.is_empty() { + return Err(invalid(format!( + "model rule {value:?} must have a nonempty provider and model" + ))); + } + if provider.contains('*') { + return Err(invalid(format!( + "model rule {value:?} cannot wildcard the provider" + ))); + } + if model.contains('*') && model != "*" { + return Err(invalid(format!( + "model rule {value:?} only supports the provider/* wildcard" + ))); + } + Ok(Self { + provider: provider.to_string(), + model: (model != "*").then(|| model.to_string()), + }) + } + + fn matches(&self, provider: &str, model: &str) -> bool { + self.provider == provider && self.model.as_deref().is_none_or(|rule| rule == model) + } +} + +#[derive(Debug)] +struct ToolPolicy { + default: DefaultEffect, + allow: BTreeMap, + deny: BTreeSet, + on_deny: ToolDenyAction, +} + +impl ToolPolicy { + fn compile(value: &Value) -> Result { + let map = require_map(value, ":tools")?; + reject_unknown_keys(map, &["default", "allow", "deny", "on-deny"], ":tools")?; + let allow = match get(map, "allow") { + None => BTreeMap::new(), + Some(value) => { + let rules = require_map(value, ":tools :allow")?; + let mut compiled = BTreeMap::new(); + for (name, rule) in rules { + let name = value_name(name) + .ok_or_else(|| invalid(":tools :allow keys must be tool names"))?; + if compiled.contains_key(&name) { + return Err(invalid(format!( + ":tools :allow has duplicate tool name {name:?}" + ))); + } + compiled.insert(name.clone(), ToolRule::compile(&name, rule)?); + } + compiled + } + }; + let deny = parse_string_set(get(map, "deny"), ":tools :deny")?; + let on_deny = match get(map, "on-deny").and_then(value_name).as_deref() { + None | Some("fail") => ToolDenyAction::Fail, + Some("tool-error") => ToolDenyAction::ToolError, + Some(other) => { + return Err(invalid(format!( + ":tools :on-deny must be :fail or :tool-error, got {other:?}" + ))) + } + }; + Ok(Self { + default: parse_default(get(map, "default"), ":tools")?, + allow, + deny, + on_deny, + }) + } + + fn check( + &self, + tool: &str, + arguments: &serde_json::Value, + workspace_root: &Path, + ) -> PolicyCheck { + if self.deny.contains(tool) { + return PolicyCheck::deny( + format!("tools.{tool}.deny"), + format!("tool {tool} matches an explicit deny rule"), + ); + } + if let Some(rule) = self.allow.get(tool) { + return rule.check(tool, arguments, workspace_root); + } + match self.default { + DefaultEffect::Allow => PolicyCheck::allow("tools.default-allow"), + DefaultEffect::Deny => PolicyCheck::deny( + "tools.default-deny", + format!("tool {tool} is not allowlisted"), + ), + } + } +} + +#[derive(Debug, Default)] +struct ToolRule { + constraints: Vec, +} + +impl ToolRule { + fn compile(tool: &str, value: &Value) -> Result { + let map = require_map(value, &format!("tool rule {tool:?}"))?; + reject_unknown_keys( + map, + &["paths", "domains", "commands"], + &format!("tool rule {tool:?}"), + )?; + let mut constraints = Vec::new(); + if let Some(value) = get(map, "paths") { + constraints.extend(compile_constraints( + value, + "path", + ConstraintKind::Path, + tool, + )?); + } + if let Some(value) = get(map, "domains") { + constraints.extend(compile_constraints( + value, + "url", + ConstraintKind::Domain, + tool, + )?); + } + if let Some(value) = get(map, "commands") { + constraints.extend(compile_constraints( + value, + "command", + ConstraintKind::Command, + tool, + )?); + } + Ok(Self { constraints }) + } + + fn check( + &self, + tool: &str, + arguments: &serde_json::Value, + workspace_root: &Path, + ) -> PolicyCheck { + let Some(arguments) = arguments.as_object() else { + return PolicyCheck::deny( + format!("tools.{tool}.arguments"), + "tool arguments must be a JSON object", + ); + }; + for constraint in &self.constraints { + if let Err(reason) = constraint.check(arguments, workspace_root) { + return PolicyCheck::deny( + format!( + "tools.{tool}.{}.{}", + constraint.kind.label(), + constraint.argument + ), + reason, + ); + } + } + PolicyCheck::allow(format!("tools.{tool}.allow")) + } +} + +#[derive(Debug, Clone, Copy)] +enum ConstraintKind { + Path, + Domain, + Command, +} + +impl ConstraintKind { + fn label(self) -> &'static str { + match self { + Self::Path => "paths", + Self::Domain => "domains", + Self::Command => "commands", + } + } +} + +#[derive(Debug)] +struct ArgumentConstraint { + argument: String, + kind: CompiledConstraint, +} + +impl ArgumentConstraint { + fn check( + &self, + arguments: &serde_json::Map, + workspace_root: &Path, + ) -> Result<(), String> { + let value = arguments + .get(&self.argument) + .ok_or_else(|| format!("required argument {:?} is missing", self.argument))?; + self.kind.check(value, workspace_root) + } +} + +#[derive(Debug)] +enum CompiledConstraint { + Path(PathConstraint), + Domain(DomainConstraint), + Command(CommandConstraint), +} + +impl CompiledConstraint { + fn label(&self) -> &'static str { + match self { + Self::Path(_) => "paths", + Self::Domain(_) => "domains", + Self::Command(_) => "commands", + } + } + + fn check(&self, value: &serde_json::Value, workspace_root: &Path) -> Result<(), String> { + match self { + Self::Path(rule) => rule.check(value, workspace_root), + Self::Domain(rule) => rule.check(value), + Self::Command(rule) => rule.check(value), + } + } +} + +#[derive(Debug)] +struct PathConstraint { + allow: Vec, + deny: Vec, +} + +impl PathConstraint { + fn compile(selector: &BTreeMap) -> Result { + let allow = parse_string_list(get(selector, "allow"), "path :allow")?; + let deny = parse_string_list(get(selector, "deny"), "path :deny")?; + if allow.is_empty() { + return Err(invalid("path constraint requires a nonempty :allow list")); + } + Ok(Self { + allow: compile_path_globs(&allow)?, + deny: compile_path_globs(&deny)?, + }) + } + + fn check(&self, value: &serde_json::Value, workspace_root: &Path) -> Result<(), String> { + let path = value + .as_str() + .ok_or_else(|| "path argument must be a string".to_string())?; + let relative = normalize_policy_path(workspace_root, path)?; + if self.deny.iter().any(|pattern| pattern.is_match(&relative)) { + return Err("path matches a deny pattern".to_string()); + } + self.allow + .iter() + .any(|pattern| pattern.is_match(&relative)) + .then_some(()) + .ok_or_else(|| "path is not allowlisted".to_string()) + } +} + +#[derive(Debug)] +struct DomainConstraint { + allow: Vec, + deny: Vec, + schemes: BTreeSet, + ports: Option>, +} + +impl DomainConstraint { + fn compile(selector: &BTreeMap) -> Result { + let allow = parse_string_list(get(selector, "allow"), "domain :allow")? + .into_iter() + .map(|host| HostPattern::parse(&host)) + .collect::, _>>()?; + if allow.is_empty() { + return Err(invalid("domain constraint requires a nonempty :allow list")); + } + let deny = parse_string_list(get(selector, "deny"), "domain :deny")? + .into_iter() + .map(|host| HostPattern::parse(&host)) + .collect::, _>>()?; + let schemes = match get(selector, "schemes") { + Some(value) => parse_string_list(Some(value), "domain :schemes")? + .into_iter() + .map(|scheme| scheme.to_ascii_lowercase()) + .collect(), + None => BTreeSet::from(["https".to_string()]), + }; + if schemes.is_empty() { + return Err(invalid("domain :schemes must not be empty")); + } + if schemes + .iter() + .any(|scheme| scheme != "http" && scheme != "https") + { + return Err(invalid( + "domain :schemes supports only \"http\" and \"https\"", + )); + } + let ports = get(selector, "ports") + .map(|value| { + let values = require_seq(value, "domain :ports")?; + values + .iter() + .map(|value| { + value + .as_int() + .and_then(|port| u16::try_from(port).ok()) + .ok_or_else(|| { + invalid("domain :ports entries must be integers 0-65535") + }) + }) + .collect::, _>>() + }) + .transpose()?; + Ok(Self { + allow, + deny, + schemes, + ports, + }) + } + + fn check(&self, value: &serde_json::Value) -> Result<(), String> { + let raw = value + .as_str() + .ok_or_else(|| "URL argument must be a string".to_string())?; + let url = Url::parse(raw).map_err(|_| "URL argument is invalid".to_string())?; + if !self.schemes.contains(url.scheme()) { + return Err("URL scheme is not allowlisted".to_string()); + } + if !url.username().is_empty() || url.password().is_some() { + return Err("URL credentials are not allowed".to_string()); + } + let host = match url.host() { + Some(Host::Domain(domain)) => domain.to_ascii_lowercase(), + Some(Host::Ipv4(ip)) => ip.to_string(), + Some(Host::Ipv6(ip)) => ip.to_string(), + None => return Err("URL must have a host".to_string()), + }; + if let Some(ports) = &self.ports { + let port = url + .port_or_known_default() + .ok_or_else(|| "URL port cannot be resolved".to_string())?; + if !ports.contains(&port) { + return Err("URL port is not allowlisted".to_string()); + } + } + if self.deny.iter().any(|pattern| pattern.matches(&host)) { + return Err("URL host matches a deny rule".to_string()); + } + self.allow + .iter() + .any(|pattern| pattern.matches(&host)) + .then_some(()) + .ok_or_else(|| "URL host is not allowlisted".to_string()) + } +} + +#[derive(Debug)] +struct HostPattern { + host: String, + include_subdomains: bool, +} + +impl HostPattern { + fn parse(value: &str) -> Result { + if value.contains("://") || value.contains('/') || value.contains('@') { + return Err(invalid(format!( + "domain rule {value:?} must be a hostname, not a URL" + ))); + } + let (host, include_subdomains) = match value.strip_prefix("*.") { + Some(host) => (host, true), + None => (value, false), + }; + if host.is_empty() || host.contains('*') { + return Err(invalid(format!( + "domain rule {value:?} only supports a leading *. wildcard" + ))); + } + let host = match Host::parse(host) { + Ok(Host::Domain(domain)) => domain.to_ascii_lowercase(), + Ok(Host::Ipv4(ip)) => ip.to_string(), + Ok(Host::Ipv6(ip)) => ip.to_string(), + Err(_) => { + return Err(invalid(format!( + "domain rule {value:?} must contain only a valid hostname" + ))) + } + }; + Ok(Self { + host, + include_subdomains, + }) + } + + fn matches(&self, candidate: &str) -> bool { + if !self.include_subdomains { + return candidate == self.host; + } + candidate + .strip_suffix(&self.host) + .is_some_and(|prefix| prefix.ends_with('.') && prefix.len() > 1) + } +} + +#[derive(Debug)] +struct CommandConstraint { + allow: BTreeSet, + deny: BTreeSet, +} + +impl CommandConstraint { + fn compile(selector: &BTreeMap) -> Result { + let allow = parse_string_set(get(selector, "allow"), "command :allow")?; + let deny = parse_string_set(get(selector, "deny"), "command :deny")?; + if allow.is_empty() { + return Err(invalid( + "command constraint requires a nonempty :allow list", + )); + } + if allow + .iter() + .chain(deny.iter()) + .any(|command| command.contains('*') || command.contains('?') || command.contains('[')) + { + return Err(invalid( + "command rules are exact strings; wildcard syntax is not supported", + )); + } + Ok(Self { allow, deny }) + } + + fn check(&self, value: &serde_json::Value) -> Result<(), String> { + let command = value + .as_str() + .ok_or_else(|| "command argument must be a string".to_string())?; + if self.deny.contains(command) { + return Err("command matches an explicit deny rule".to_string()); + } + self.allow + .contains(command) + .then_some(()) + .ok_or_else(|| "command is not allowlisted".to_string()) + } +} + +fn compile_constraints( + value: &Value, + default_argument: &str, + kind: ConstraintKind, + tool: &str, +) -> Result, PolicyError> { + if let Some(map) = value.as_map_ref() { + return compile_selector(map, default_argument, kind, tool).map(|rule| vec![rule]); + } + let values = require_seq(value, &format!("tool {tool:?} {}", kind.label()))?; + if values.iter().all(|value| value.as_str().is_some()) { + let selector = shorthand_selector(&values); + return compile_selector(&selector, default_argument, kind, tool).map(|rule| vec![rule]); + } + values + .iter() + .map(|value| { + let map = require_map(value, &format!("tool {tool:?} {} selector", kind.label()))?; + compile_selector(map, default_argument, kind, tool) + }) + .collect() +} + +fn compile_selector( + selector: &BTreeMap, + default_argument: &str, + kind: ConstraintKind, + tool: &str, +) -> Result { + let allowed_keys: &[&str] = match kind { + ConstraintKind::Path | ConstraintKind::Command => &["arg", "allow", "deny"], + ConstraintKind::Domain => &["arg", "allow", "deny", "schemes", "ports"], + }; + reject_unknown_keys( + selector, + allowed_keys, + &format!("tool {tool:?} {} selector", kind.label()), + )?; + let argument = get(selector, "arg") + .map(|value| { + value_name(value).ok_or_else(|| { + invalid(format!( + "tool {tool:?} {} :arg must be a keyword or string", + kind.label() + )) + }) + }) + .transpose()? + .unwrap_or_else(|| default_argument.to_string()); + if argument.is_empty() { + return Err(invalid(format!( + "tool {tool:?} {} :arg must not be empty", + kind.label() + ))); + } + let kind = match kind { + ConstraintKind::Path => CompiledConstraint::Path(PathConstraint::compile(selector)?), + ConstraintKind::Domain => CompiledConstraint::Domain(DomainConstraint::compile(selector)?), + ConstraintKind::Command => { + CompiledConstraint::Command(CommandConstraint::compile(selector)?) + } + }; + Ok(ArgumentConstraint { argument, kind }) +} + +fn shorthand_selector(values: &[Value]) -> BTreeMap { + BTreeMap::from([(Value::keyword("allow"), Value::vector(values.to_vec()))]) +} + +fn compile_path_globs(patterns: &[String]) -> Result, PolicyError> { + patterns + .iter() + .map(|pattern| { + validate_path_pattern(pattern)?; + GlobBuilder::new(pattern) + .literal_separator(true) + .backslash_escape(false) + .build() + .map(|glob| glob.compile_matcher()) + .map_err(|error| invalid(format!("invalid path pattern {pattern:?}: {error}"))) + }) + .collect() +} + +fn validate_path_pattern(pattern: &str) -> Result<(), PolicyError> { + if pattern.is_empty() + || pattern.starts_with('/') + || pattern.contains('\\') + || pattern.contains(['[', ']', '{', '}', '?']) + { + return Err(invalid(format!( + "path pattern {pattern:?} must be a relative literal/*/** pattern" + ))); + } + for component in pattern.split('/') { + if component == ".." || (component.contains("**") && component != "**") { + return Err(invalid(format!( + "path pattern {pattern:?} has an invalid component {component:?}" + ))); + } + } + Ok(()) +} + +fn normalize_policy_path(workspace_root: &Path, input: &str) -> Result { + if input.is_empty() || input.contains('\0') { + return Err("path must be a nonempty string without NUL bytes".to_string()); + } + let input_path = Path::new(input); + if input_path.is_absolute() { + return Err("absolute paths are not allowed".to_string()); + } + + let root = absolute_lexical(workspace_root)?; + let joined = normalize_lexical(&root.join(input_path)); + if !joined.starts_with(&root) { + return Err("path escapes the workflow root".to_string()); + } + let canonical_root = canonical_or_lexical(&root); + let resolved = canonicalize_existing_prefix(&joined); + if !resolved.starts_with(&canonical_root) { + return Err("path resolves outside the workflow root".to_string()); + } + let relative = resolved + .strip_prefix(&canonical_root) + .map_err(|_| "path cannot be made root-relative".to_string())?; + Ok(relative + .components() + .filter_map(|component| match component { + Component::Normal(part) => Some(part.to_string_lossy().into_owned()), + _ => None, + }) + .collect::>() + .join("/")) +} + +fn absolute_lexical(path: &Path) -> Result { + if path.is_absolute() { + return Ok(normalize_lexical(path)); + } + std::env::current_dir() + .map(|cwd| normalize_lexical(&cwd.join(path))) + .map_err(|error| format!("cannot resolve workflow root: {error}")) +} + +fn canonical_or_lexical(path: &Path) -> PathBuf { + std::fs::canonicalize(path).unwrap_or_else(|_| normalize_lexical(path)) +} + +fn canonicalize_existing_prefix(path: &Path) -> PathBuf { + let mut existing = path.to_path_buf(); + let mut suffix = Vec::new(); + while !existing.exists() { + let Some(name) = existing.file_name().map(|name| name.to_os_string()) else { + break; + }; + suffix.push(name); + if !existing.pop() { + break; + } + } + let mut resolved = canonical_or_lexical(&existing); + for component in suffix.into_iter().rev() { + resolved.push(component); + } + normalize_lexical(&resolved) +} + +fn normalize_lexical(path: &Path) -> PathBuf { + let mut result = PathBuf::new(); + for component in path.components() { + match component { + Component::ParentDir => { + result.pop(); + } + Component::CurDir => {} + other => result.push(other.as_os_str()), + } + } + result +} + +fn fingerprint(value: &Value, name: &str) -> String { + let json = sema_core::value_to_json_lossy(value); + let encoded = serde_json::to_vec(&json).unwrap_or_default(); + let mut hasher = Sha256::new(); + hasher.update(b"sema-policy-v1\0"); + hasher.update(name.as_bytes()); + hasher.update(b"\0"); + hasher.update(encoded); + format!("sha256:{:x}", hasher.finalize()) +} + +fn parse_default(value: Option<&Value>, context: &str) -> Result { + match value.and_then(value_name).as_deref() { + None | Some("deny") => Ok(DefaultEffect::Deny), + Some("allow") => Ok(DefaultEffect::Allow), + Some(other) => Err(invalid(format!( + "{context} :default must be :allow or :deny, got {other:?}" + ))), + } +} + +fn parse_model_patterns( + value: Option<&Value>, + context: &str, +) -> Result, PolicyError> { + parse_string_list(value, context)? + .into_iter() + .map(|value| ModelPattern::parse(&value)) + .collect() +} + +fn parse_string_set(value: Option<&Value>, context: &str) -> Result, PolicyError> { + parse_string_list(value, context).map(|values| values.into_iter().collect()) +} + +fn parse_string_list(value: Option<&Value>, context: &str) -> Result, PolicyError> { + let Some(value) = value else { + return Ok(Vec::new()); + }; + require_seq(value, context)? + .iter() + .map(|value| { + value + .as_str() + .map(str::to_string) + .ok_or_else(|| invalid(format!("{context} entries must be strings"))) + }) + .collect() +} + +fn require_seq(value: &Value, context: &str) -> Result, PolicyError> { + value + .as_seq() + .map(|values| values.to_vec()) + .ok_or_else(|| invalid(format!("{context} must be a list or vector"))) +} + +fn require_map<'a>( + value: &'a Value, + context: &str, +) -> Result<&'a BTreeMap, PolicyError> { + value + .as_map_ref() + .ok_or_else(|| invalid(format!("{context} must be a map"))) +} + +fn get<'a>(map: &'a BTreeMap, key: &str) -> Option<&'a Value> { + map.iter().find_map(|(candidate, value)| { + (value_name(candidate).as_deref() == Some(key)).then_some(value) + }) +} + +fn value_name(value: &Value) -> Option { + value + .as_str() + .map(str::to_string) + .or_else(|| value.as_keyword()) + .or_else(|| value.as_symbol()) +} + +fn reject_unknown_keys( + map: &BTreeMap, + allowed: &[&str], + context: &str, +) -> Result<(), PolicyError> { + let mut seen = BTreeSet::new(); + for key in map.keys() { + let key = value_name(key).ok_or_else(|| { + invalid(format!( + "{context} keys must be keywords, strings, or symbols" + )) + })?; + if !allowed.contains(&key.as_str()) { + return Err(invalid(format!("{context} has unknown key :{key}"))); + } + if !seen.insert(key.clone()) { + return Err(invalid(format!("{context} has duplicate key {key:?}"))); + } + } + Ok(()) +} + +fn invalid(message: impl Into) -> PolicyError { + PolicyError::Invalid(message.into()) +} + +#[cfg(test)] +mod tests { + use super::*; + use std::fs; + + fn map(entries: impl IntoIterator) -> Value { + Value::map( + entries + .into_iter() + .map(|(key, value)| (Value::keyword(key), value)) + .collect(), + ) + } + + fn strings(values: &[&str]) -> Value { + Value::vector(values.iter().map(|value| Value::string(value)).collect()) + } + + fn named_policy(entries: impl IntoIterator) -> Value { + let mut values: BTreeMap = entries + .into_iter() + .map(|(key, value)| (Value::keyword(key), value)) + .collect(); + values.insert(Value::keyword("__policy-name"), Value::symbol("safe")); + values.insert( + Value::keyword("__policy-version"), + Value::int(POLICY_VERSION), + ); + Value::map(values) + } + + #[test] + fn model_rules_match_resolved_pairs_and_provider_wildcard() { + let policy = CompiledPolicy::compile(&named_policy([( + "models", + map([ + ("allow", strings(&["openai/gpt-5", "ollama/*"])), + ("deny", strings(&["ollama/unsafe"])), + ("on-deny", Value::keyword("skip")), + ]), + )])) + .unwrap(); + + assert!(policy.check_model("openai", "gpt-5").allowed); + assert!(policy.check_model("ollama", "qwen").allowed); + assert!(!policy.check_model("ollama", "unsafe").allowed); + assert!(!policy.check_model("openai", "gpt-4").allowed); + assert_eq!(policy.model_action(), ModelDenyAction::Skip); + } + + #[test] + fn invalid_model_globs_are_rejected() { + let error = CompiledPolicy::compile(&named_policy([( + "models", + map([("allow", strings(&["*/gpt-5"]))]), + )])) + .unwrap_err(); + assert!(error.to_string().contains("cannot wildcard the provider")); + } + + #[test] + fn present_sections_default_to_deny_and_hard_fail() { + let policy = + CompiledPolicy::compile(&named_policy([("models", map([])), ("tools", map([]))])) + .unwrap(); + assert!(!policy.check_model("fake", "model").allowed); + assert_eq!(policy.model_action(), ModelDenyAction::Fail); + assert!( + !policy + .check_tool("read-file", &serde_json::json!({}), Path::new(".")) + .allowed + ); + assert_eq!(policy.tool_action(), ToolDenyAction::Fail); + } + + #[test] + fn unknown_keys_are_rejected_instead_of_being_ignored() { + let error = CompiledPolicy::compile(&named_policy([( + "models", + map([("alow", strings(&["fake/*"]))]), + )])) + .unwrap_err(); + assert!(error.to_string().contains("unknown key :alow")); + } + + #[test] + fn structural_string_and_symbol_keys_are_enforced() { + let models = Value::map(BTreeMap::from([ + (Value::string("default"), Value::keyword("deny")), + (Value::symbol("allow"), strings(&["openai/allowed-model"])), + ])); + let policy = Value::map(BTreeMap::from([(Value::string("models"), models)])); + let policy = CompiledPolicy::compile(&policy).unwrap(); + + assert!(policy.check_model("openai", "allowed-model").allowed); + assert!(!policy.check_model("openai", "blocked-model").allowed); + } + + #[test] + fn string_constraint_keys_do_not_create_unconstrained_tool_rules() { + let tool_rule = Value::map(BTreeMap::from([( + Value::string("paths"), + strings(&["safe/**"]), + )])); + let allow = Value::map(BTreeMap::from([(Value::string("read-file"), tool_rule)])); + let tools = Value::map(BTreeMap::from([ + (Value::string("default"), Value::keyword("deny")), + (Value::string("allow"), allow), + ])); + let policy = Value::map(BTreeMap::from([(Value::string("tools"), tools)])); + let policy = CompiledPolicy::compile(&policy).unwrap(); + + assert!( + !policy + .check_tool( + "read-file", + &serde_json::json!({"path":"../outside"}), + Path::new(".") + ) + .allowed + ); + } + + #[test] + fn duplicate_normalized_keys_and_tool_names_are_rejected() { + let duplicate_sections = Value::map(BTreeMap::from([ + (Value::keyword("models"), map([])), + (Value::string("models"), map([])), + ])); + assert!(CompiledPolicy::compile(&duplicate_sections) + .unwrap_err() + .to_string() + .contains("duplicate key")); + + let duplicate_tools = map([( + "tools", + map([( + "allow", + Value::map(BTreeMap::from([ + (Value::keyword("read-file"), map([])), + (Value::string("read-file"), map([])), + ])), + )]), + )]); + assert!(CompiledPolicy::compile(&duplicate_tools) + .unwrap_err() + .to_string() + .contains("duplicate tool name")); + } + + #[test] + fn tool_default_deny_and_explicit_deny_win() { + let policy = CompiledPolicy::compile(&named_policy([( + "tools", + map([ + ( + "allow", + Value::map(BTreeMap::from([(Value::string("read-file"), map([]))])), + ), + ("deny", strings(&["read-file"])), + ]), + )])) + .unwrap(); + assert!( + !policy + .check_tool("read-file", &serde_json::json!({}), Path::new(".")) + .allowed + ); + assert!( + !policy + .check_tool("write-file", &serde_json::json!({}), Path::new(".")) + .allowed + ); + } + + #[test] + fn shorthand_and_explicit_path_arguments_match() { + let root = std::env::temp_dir().join(format!("sema-policy-path-{}", std::process::id())); + fs::create_dir_all(root.join("src")).unwrap(); + let policy = CompiledPolicy::compile(&named_policy([( + "tools", + map([( + "allow", + Value::map(BTreeMap::from([ + ( + Value::string("read-file"), + map([("paths", strings(&["src/**"]))]), + ), + ( + Value::string("copy-file"), + map([( + "paths", + Value::vector(vec![ + map([ + ("arg", Value::keyword("source")), + ("allow", strings(&["src/**"])), + ]), + map([ + ("arg", Value::keyword("destination")), + ("allow", strings(&["tmp/**"])), + ]), + ]), + )]), + ), + ])), + )]), + )])) + .unwrap(); + + assert!( + policy + .check_tool( + "read-file", + &serde_json::json!({"path":"src/lib.rs"}), + &root + ) + .allowed + ); + assert!( + !policy + .check_tool( + "read-file", + &serde_json::json!({"path":"Cargo.toml"}), + &root + ) + .allowed + ); + assert!( + policy + .check_tool( + "copy-file", + &serde_json::json!({"source":"src/lib.rs","destination":"tmp/lib.rs"}), + &root + ) + .allowed + ); + assert!( + !policy + .check_tool( + "copy-file", + &serde_json::json!({"source":"src/lib.rs"}), + &root + ) + .allowed + ); + let _ = fs::remove_dir_all(root); + } + + #[test] + fn path_traversal_and_absolute_paths_are_denied() { + let root = + std::env::temp_dir().join(format!("sema-policy-traversal-{}", std::process::id())); + fs::create_dir_all(root.join("src")).unwrap(); + let rule = PathConstraint { + allow: compile_path_globs(&["**".to_string()]).unwrap(), + deny: Vec::new(), + }; + assert!(rule.check(&serde_json::json!("../outside"), &root).is_err()); + assert!(rule + .check(&serde_json::json!("/tmp/outside"), &root) + .is_err()); + let _ = fs::remove_dir_all(root); + } + + #[cfg(unix)] + #[test] + fn unix_backslash_is_not_treated_as_a_path_separator() { + let root = + std::env::temp_dir().join(format!("sema-policy-backslash-{}", std::process::id())); + fs::create_dir_all(&root).unwrap(); + fs::write(root.join(r"safe\secret"), "not in the safe directory").unwrap(); + let rule = PathConstraint { + allow: compile_path_globs(&["safe/**".to_string()]).unwrap(), + deny: Vec::new(), + }; + + assert!(rule + .check(&serde_json::json!(r"safe\secret"), &root) + .is_err()); + let _ = fs::remove_dir_all(root); + } + + #[cfg(unix)] + #[test] + fn symlink_escape_is_denied() { + use std::os::unix::fs::symlink; + + let root = std::env::temp_dir().join(format!("sema-policy-symlink-{}", std::process::id())); + let outside = + std::env::temp_dir().join(format!("sema-policy-outside-{}", std::process::id())); + fs::create_dir_all(&root).unwrap(); + fs::create_dir_all(&outside).unwrap(); + symlink(&outside, root.join("escape")).unwrap(); + let rule = PathConstraint { + allow: compile_path_globs(&["**".to_string()]).unwrap(), + deny: Vec::new(), + }; + assert!(rule + .check(&serde_json::json!("escape/new.txt"), &root) + .is_err()); + let _ = fs::remove_dir_all(root); + let _ = fs::remove_dir_all(outside); + } + + #[test] + fn domains_normalize_idna_and_reject_credentials() { + let selector = BTreeMap::from([( + Value::keyword("allow"), + strings(&["münchen.de", "*.example.com"]), + )]); + let rule = DomainConstraint::compile(&selector).unwrap(); + assert!(rule + .check(&serde_json::json!("https://münchen.de/a/../b")) + .is_ok()); + assert!(rule + .check(&serde_json::json!("https://api.example.com/v1")) + .is_ok()); + assert!(rule + .check(&serde_json::json!("https://example.com/v1")) + .is_err()); + assert!(rule + .check(&serde_json::json!("http://api.example.com/v1")) + .is_err()); + assert!(rule + .check(&serde_json::json!("https://u:p@api.example.com/v1")) + .is_err()); + } + + #[test] + fn domain_rules_reject_url_components_that_would_be_discarded() { + for host in [ + "example.com:443", + "example.com?tenant=other", + "example.com#fragment", + ] { + let selector = BTreeMap::from([(Value::keyword("allow"), strings(&[host]))]); + let error = DomainConstraint::compile(&selector).unwrap_err(); + assert!( + error.to_string().contains("only a valid hostname"), + "unexpected error for {host:?}: {error}" + ); + } + } + + #[test] + fn commands_are_exact_and_wildcards_are_rejected() { + let selector = BTreeMap::from([( + Value::keyword("allow"), + strings(&["cargo test", "git diff"]), + )]); + let rule = CommandConstraint::compile(&selector).unwrap(); + assert!(rule.check(&serde_json::json!("cargo test")).is_ok()); + assert!(rule.check(&serde_json::json!("cargo test -p x")).is_err()); + + let wildcard = BTreeMap::from([(Value::keyword("allow"), strings(&["cargo test *"]))]); + assert!(CommandConstraint::compile(&wildcard).is_err()); + } + + #[test] + fn fingerprint_is_stable_and_includes_name() { + let first = CompiledPolicy::compile(&named_policy([( + "tools", + map([("default", Value::keyword("allow"))]), + )])) + .unwrap(); + let second = CompiledPolicy::compile(&named_policy([( + "tools", + map([("default", Value::keyword("allow"))]), + )])) + .unwrap(); + assert_eq!(first.fingerprint(), second.fingerprint()); + + let other = CompiledPolicy::compile(&map([( + "tools", + map([("default", Value::keyword("allow"))]), + )])) + .unwrap(); + assert_ne!(first.fingerprint(), other.fingerprint()); + } +} From 1fef5548e890882ed505b9f05b86c6a4d22df726 Mon Sep 17 00:00:00 2001 From: Helge Sverre Date: Fri, 31 Jul 2026 07:55:31 +0200 Subject: [PATCH 02/11] enforce policies at workflow boundaries --- crates/sema-core/src/error.rs | 20 + crates/sema-eval/src/prelude.rs | 22 +- crates/sema-llm/Cargo.toml | 1 + crates/sema-llm/src/builtins.rs | 760 +++++++++++++++++++---- crates/sema-llm/src/cassette.rs | 38 +- crates/sema-llm/src/fake.rs | 28 +- crates/sema-stdlib/Cargo.toml | 1 + crates/sema-stdlib/src/workflow.rs | 258 +++++++- crates/sema-stdlib/src/workflow_check.rs | 155 ++++- crates/sema-vm/src/vm.rs | 14 + crates/sema-workflow/src/context.rs | 18 +- crates/sema-workflow/src/event.rs | 111 +++- crates/sema/src/workflow_view/index.html | 12 +- crates/sema/src/workflow_view/ingest.rs | 80 +++ 14 files changed, 1333 insertions(+), 185 deletions(-) diff --git a/crates/sema-core/src/error.rs b/crates/sema-core/src/error.rs index 51276fac..b9bce6cc 100644 --- a/crates/sema-core/src/error.rs +++ b/crates/sema-core/src/error.rs @@ -187,6 +187,13 @@ pub enum SemaError { #[error("Permission denied: {function} — path '{path}' is outside allowed directories")] PathDenied { function: String, path: String }, + #[error("Policy denied {boundary} '{subject}' ({rule})")] + PolicyDenied { + boundary: String, + subject: String, + rule: String, + }, + #[error("User exception: {0}")] UserException(Value), @@ -330,6 +337,7 @@ const CONDITION_TYPES: &[&str] = &[ "llm", "reader", "permission-denied", + "policy-denied", "cancelled", "timeout", ]; @@ -389,6 +397,18 @@ impl SemaError { SemaError::Eval(msg.into()) } + pub fn policy_denied( + boundary: impl Into, + subject: impl Into, + rule: impl Into, + ) -> Self { + SemaError::PolicyDenied { + boundary: boundary.into(), + subject: subject.into(), + rule: rule.into(), + } + } + #[allow(clippy::too_many_arguments)] pub fn cancelled_condition( message: &str, diff --git a/crates/sema-eval/src/prelude.rs b/crates/sema-eval/src/prelude.rs index f2f0d5d8..2fb9bc9d 100644 --- a/crates/sema-eval/src/prelude.rs +++ b/crates/sema-eval/src/prelude.rs @@ -284,10 +284,27 @@ pub const PRELUDE: &str = r#" (defmacro with-session (id config . body) `(otel/with-session ,id ,config (lambda () ,@body))) +;; defpolicy: name a reusable workflow policy. The runtime compiles the resulting +;; immutable map before entering a protected workflow/step body. +(defmacro defpolicy (name rules) + `(define ,name + (assoc (assoc ,rules + :__policy-name (symbol->string (quote ,name))) + :__policy-version 1))) + +;; policy/without: trusted, lexical, audited policy bypass. It never changes the +;; workflow's outer :permissions sandbox ceiling. +(defmacro policy/without (reason . body) + (if (or (not (string? reason)) (null? body)) + (error "policy/without requires a literal reason string and at least one body form") + `(workflow/policy-without ,reason (fn () ,@body)))) + ;; defworkflow: define + run a sequential, journaled workflow. ;; (defworkflow audit-auth "doc" {:phases [...] :budget {:tokens N :usd N}} (phase ...) ...) ;; The meta map's `:budget` submap caps spend: `:tokens` (deterministic) and/or `:usd` -;; (best-effort, pricing-table dependent). Exceeding a cap latches the run and refuses +;; (best-effort, pricing-table dependent). `:policy` installs a model/tool policy for +;; the full workflow body; a step's own `:policy` can only tighten it. Exceeding a cap +;; latches the run and refuses ;; to launch further `step` leaves; the run ends {:status :failed :reason "budget ;; exceeded"}. Concurrent fan-out shares the aggregate budget while each task keeps ;; its own last-usage snapshot and leaf accumulator. @@ -357,7 +374,8 @@ pub const PRELUDE: &str = r#" ;; named/reusable actor). Runs the prompt through the configured provider and returns ;; TYPED DATA when `:schema` is supplied (validated via `llm/extract`), or the ;; completion text otherwise. The optional opts map carries `:name` (the role label -;; shown in the dashboard, default "step"), `:schema`, `:tools`, and `:agent`. The +;; shown in the dashboard, default "step"), `:schema`, `:tools`, `:agent`, and +;; tightening `:policy`. The ;; call is wrapped by `workflow/step`, which emits agent.started/agent.result + a ;; per-step budget event. (The `agent.*` event names are the FROZEN internal journal ;; contract — they predate the step rename and stay; `agent_name` carries the step's diff --git a/crates/sema-llm/Cargo.toml b/crates/sema-llm/Cargo.toml index 537f0dec..3a8e7b33 100644 --- a/crates/sema-llm/Cargo.toml +++ b/crates/sema-llm/Cargo.toml @@ -12,6 +12,7 @@ readme = "README.md" sema-core.workspace = true sema-io.workspace = true sema-otel.workspace = true +sema-policy.workspace = true thiserror.workspace = true serde.workspace = true serde_json.workspace = true diff --git a/crates/sema-llm/src/builtins.rs b/crates/sema-llm/src/builtins.rs index 2b0fe942..5edea9ea 100644 --- a/crates/sema-llm/src/builtins.rs +++ b/crates/sema-llm/src/builtins.rs @@ -1,6 +1,7 @@ use std::cell::Cell; use std::cell::RefCell; use std::collections::{BTreeMap, VecDeque}; +use std::path::PathBuf; use std::rc::Rc; use sema_core::runtime::RuntimeTaskId; @@ -61,6 +62,16 @@ thread_local! { /// module. Allows `agent/run` to seed from and append to a memory handle without /// depending on `sema-stdlib` (which would be circular). static MEMORY_CALLBACKS: RefCell> = const { RefCell::new(None) }; + /// Ordered policy layers active for the current task. The LLM + /// dynamic-scope mechanism captures and swaps these with cache/budget/cassette + /// state, so workflow and step policies remain isolated across sibling tasks. + static ACTIVE_POLICIES: RefCell> = const { RefCell::new(Vec::new()) }; + /// Trusted lexical policy bypass reasons. A nonempty stack suppresses policy + /// enforcement but still emits a `policy.bypassed` observation per boundary. + static POLICY_BYPASS: RefCell> = const { RefCell::new(Vec::new()) }; + /// Workflow step attribution carried with the policy scope, independent of + /// the workflow crate's task-local state. + static POLICY_AGENT_ID: RefCell> = const { RefCell::new(None) }; } /// Function-pointer table injected by `sema-stdlib/memory.rs` via @@ -98,6 +109,403 @@ pub struct LastUsage { pub cost_usd: Option, } +/// Policy boundary recorded by the workflow journal sink. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum PolicyBoundary { + Model, + Tool, +} + +impl PolicyBoundary { + pub fn as_str(self) -> &'static str { + match self { + Self::Model => "model", + Self::Tool => "tool", + } + } +} + +/// Where a policy-checked model result is about to come from. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum PolicySource { + Request, + Cache, + Cassette, +} + +impl PolicySource { + pub fn as_str(self) -> &'static str { + match self { + Self::Request => "request", + Self::Cache => "cache", + Self::Cassette => "cassette", + } + } +} + +/// The journal-facing result of checking or bypassing one policy layer. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct PolicyObservation { + pub kind: PolicyObservationKind, + pub policy: String, + pub policy_digest: String, + pub boundary: PolicyBoundary, + pub subject: String, + pub subject_digest: Option, + pub rule: String, + pub action: Option, + pub reason: Option, + pub source: PolicySource, + pub agent_id: Option, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum PolicyObservationKind { + Checked, + Violation, + Bypassed, +} + +/// Sink installed by `workflow/run`; it captures only a weak workflow context. +pub type PolicyDecisionSink = Rc; + +#[derive(Clone)] +struct ActivePolicy { + policy: Rc, + workspace_root: PathBuf, + sink: PolicyDecisionSink, +} + +/// Effective result of checking all active policy layers. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum PolicyGate { + Allow, + Deny(T), +} + +/// RAII guard for one workflow or step policy layer. +pub struct PolicyScope { + previous: Option>, +} + +impl Drop for PolicyScope { + fn drop(&mut self) { + if let Some(previous) = self.previous.take() { + ACTIVE_POLICIES.with(|policies| *policies.borrow_mut() = previous); + } + } +} + +/// RAII guard for a trusted lexical policy bypass. +pub struct PolicyBypassScope { + previous: Option>, +} + +impl Drop for PolicyBypassScope { + fn drop(&mut self) { + if let Some(previous) = self.previous.take() { + POLICY_BYPASS.with(|bypass| *bypass.borrow_mut() = previous); + } + } +} + +/// RAII guard for step-level journal attribution. +pub struct PolicyAttributionScope { + previous: Option, +} + +impl Drop for PolicyAttributionScope { + fn drop(&mut self) { + POLICY_AGENT_ID.with(|agent| *agent.borrow_mut() = self.previous.take()); + } +} + +/// Install a compiled policy for the dynamic extent of a workflow or step. +pub fn open_policy_scope( + policy: Rc, + workspace_root: PathBuf, + sink: PolicyDecisionSink, +) -> PolicyScope { + let previous = ACTIVE_POLICIES.with(|policies| { + let previous = policies.borrow().clone(); + policies.borrow_mut().push(ActivePolicy { + policy, + workspace_root, + sink, + }); + previous + }); + PolicyScope { + previous: Some(previous), + } +} + +/// Disable active policies for a trusted lexical extent while retaining audit +/// observations and all sandbox capability checks. +pub fn open_policy_bypass(reason: String) -> PolicyBypassScope { + let previous = POLICY_BYPASS.with(|bypass| { + let previous = bypass.borrow().clone(); + bypass.borrow_mut().push(reason); + previous + }); + PolicyBypassScope { + previous: Some(previous), + } +} + +/// Attribute policy observations to one workflow step. +pub fn open_policy_attribution(agent_id: String) -> PolicyAttributionScope { + let previous = POLICY_AGENT_ID.with(|agent| agent.borrow_mut().replace(agent_id)); + PolicyAttributionScope { previous } +} + +/// Whether at least one policy layer is currently active. +pub fn policy_active() -> bool { + ACTIVE_POLICIES.with(|policies| !policies.borrow().is_empty()) +} + +/// Stable digest of the ordered effective policy stack and bypass state. +pub fn effective_policy_fingerprint() -> String { + let policies = ACTIVE_POLICIES.with(|policies| policies.borrow().clone()); + if policies.is_empty() { + return String::new(); + } + let bypass = POLICY_BYPASS.with(|bypass| bypass.borrow().last().cloned()); + let mut hasher = Sha256::new(); + hasher.update(b"sema-effective-policy-v1\0"); + for layer in policies { + hasher.update(layer.policy.fingerprint().as_bytes()); + hasher.update(b"\0"); + } + if let Some(reason) = bypass { + hasher.update(b"bypass\0"); + hasher.update(reason.as_bytes()); + } + format!("sha256:{:x}", hasher.finalize()) +} + +/// Check all active model policy layers. `minimum_action` upgrades `:skip` +/// outside a real fallback selection so the journal records the action that +/// enforcement will actually take. +fn check_model_policy( + provider: &str, + model: &str, + source: PolicySource, + minimum_action: sema_policy::ModelDenyAction, +) -> PolicyGate { + let subject = format!("{provider}/{model}"); + check_active_policies( + PolicyBoundary::Model, + &subject, + None, + source, + |layer| layer.policy.check_model(provider, model), + |layer| layer.policy.model_action().max(minimum_action), + ) +} + +fn policy_denied(boundary: PolicyBoundary, subject: &str, rule: &str) -> SemaError { + SemaError::policy_denied(boundary.as_str(), subject, rule) +} + +/// Check a resolved model target. `Ok(false)` means a fallback-only `:skip` +/// denial; every other denial is a hard error. +fn model_target_allowed( + provider: &str, + model: &str, + source: PolicySource, + fallback_target: bool, +) -> Result { + let minimum_action = if fallback_target { + sema_policy::ModelDenyAction::Skip + } else { + sema_policy::ModelDenyAction::Fail + }; + match check_model_policy(provider, model, source, minimum_action) { + PolicyGate::Allow => Ok(true), + PolicyGate::Deny(sema_policy::ModelDenyAction::Skip) if fallback_target => Ok(false), + PolicyGate::Deny(_) => { + let subject = format!("{provider}/{model}"); + Err(policy_denied( + PolicyBoundary::Model, + &subject, + "models.denied", + )) + } + } +} + +fn enforce_stored_model_policy( + provider: &str, + model: &str, + source: PolicySource, +) -> Result<(), SemaError> { + if !policy_active() { + return Ok(()); + } + if provider.is_empty() { + return Err(policy_denied( + PolicyBoundary::Model, + model, + &format!("{}.missing-provider", source.as_str()), + )); + } + model_target_allowed(provider, model, source, false).map(|_| ()) +} + +fn preflight_tool_calls(calls: &[ToolCall]) -> Result, SemaError> { + let mut denied = BTreeMap::new(); + let mut hard_denial = None; + for call in calls { + match check_tool_policy( + &call.name, + &call.arguments, + sema_policy::ToolDenyAction::ToolError, + ) { + PolicyGate::Allow => {} + PolicyGate::Deny(sema_policy::ToolDenyAction::ToolError) => { + denied.insert( + call.id.clone(), + format!("Error: policy denied tool '{}'", call.name), + ); + } + PolicyGate::Deny(sema_policy::ToolDenyAction::Fail) => { + hard_denial.get_or_insert_with(|| call.name.clone()); + } + } + } + if let Some(tool) = hard_denial { + return Err(policy_denied(PolicyBoundary::Tool, &tool, "tools.denied")); + } + Ok(denied) +} + +fn enforce_direct_tool_policy(tool: &str, arguments: &serde_json::Value) -> Result<(), SemaError> { + match check_tool_policy(tool, arguments, sema_policy::ToolDenyAction::Fail) { + PolicyGate::Allow => Ok(()), + PolicyGate::Deny(_) => Err(policy_denied(PolicyBoundary::Tool, tool, "tools.denied")), + } +} + +/// Check all active tool policy layers. +fn check_tool_policy( + tool: &str, + arguments: &serde_json::Value, + minimum_action: sema_policy::ToolDenyAction, +) -> PolicyGate { + let subject_digest = policy_value_digest(arguments); + check_active_policies( + PolicyBoundary::Tool, + tool, + Some(subject_digest), + PolicySource::Request, + |layer| { + layer + .policy + .check_tool(tool, arguments, &layer.workspace_root) + }, + |layer| layer.policy.tool_action().max(minimum_action), + ) +} + +trait PolicyAction: Copy + Ord { + fn name(self) -> &'static str; +} + +impl PolicyAction for sema_policy::ModelDenyAction { + fn name(self) -> &'static str { + match self { + Self::Skip => "skip", + Self::Fail => "fail", + } + } +} + +impl PolicyAction for sema_policy::ToolDenyAction { + fn name(self) -> &'static str { + match self { + Self::ToolError => "tool-error", + Self::Fail => "fail", + } + } +} + +fn check_active_policies( + boundary: PolicyBoundary, + subject: &str, + subject_digest: Option, + source: PolicySource, + check: impl Fn(&ActivePolicy) -> sema_policy::PolicyCheck, + action: impl Fn(&ActivePolicy) -> T, +) -> PolicyGate { + let policies = ACTIVE_POLICIES.with(|policies| policies.borrow().clone()); + if policies.is_empty() { + return PolicyGate::Allow; + } + let agent_id = POLICY_AGENT_ID.with(|agent| agent.borrow().clone()); + if let Some(reason) = POLICY_BYPASS.with(|bypass| bypass.borrow().last().cloned()) { + let fingerprint = effective_policy_fingerprint(); + let observation = PolicyObservation { + kind: PolicyObservationKind::Bypassed, + policy: "effective-policy".to_string(), + policy_digest: fingerprint, + boundary, + subject: subject.to_string(), + subject_digest, + rule: "policy.without".to_string(), + action: Some("bypass".to_string()), + reason: Some(reason), + source, + agent_id, + }; + (policies.last().expect("nonempty policy stack").sink)(observation); + return PolicyGate::Allow; + } + + let decisions: Vec<_> = policies + .iter() + .map(|layer| { + let result = check(layer); + let configured_action = (!result.allowed).then(|| action(layer)); + (result, configured_action) + }) + .collect(); + let denied_action = decisions.iter().filter_map(|(_, action)| *action).max(); + + for (layer, (result, configured_action)) in policies.iter().zip(decisions) { + let observation = PolicyObservation { + kind: if result.allowed { + PolicyObservationKind::Checked + } else { + PolicyObservationKind::Violation + }, + policy: layer.policy.name().to_string(), + policy_digest: layer.policy.fingerprint().to_string(), + boundary, + subject: subject.to_string(), + subject_digest: subject_digest.clone(), + rule: result.rule, + // Journal what the boundary will actually do. A stricter denial in + // any active layer upgrades every violation observation to that + // effective action. + action: configured_action + .and(denied_action) + .map(|action| action.name().to_string()), + reason: result.reason, + source, + agent_id: agent_id.clone(), + }; + (layer.sink)(observation); + } + denied_action.map_or(PolicyGate::Allow, PolicyGate::Deny) +} + +fn policy_value_digest(value: &serde_json::Value) -> String { + let mut hasher = Sha256::new(); + hasher.update(serde_json::to_vec(value).unwrap_or_default()); + format!("sha256:{:x}", hasher.finalize()) +} + /// Clear the per-thread last-usage slot. The workflow runtime calls this at the START /// of each agent leaf so that [`last_usage_snapshot`] read afterwards reflects ONLY a /// completion this leaf made — a leaf whose call fails (or makes none) reports `None` @@ -141,16 +549,8 @@ pub struct LeafUsage { fn accumulate_into(slot: &Rc>, usage: &Usage, cost: Option) { let input = usage.prompt_tokens as u64; let output = usage.completion_tokens as u64; - // Cache-hit-zero-usage invariant: an all-zero completion is a cache hit; - // don't count it as a call (no phantom zero Budget event for a cached leaf). - // - // Cost is deliberately NOT part of this test. The only caller prices the - // usage first, and pricing a zero-token usage against a model that IS in the - // snapshot yields `Some(0.0)`, not `None` — so requiring `cost.is_none()` - // let every cache hit on a priced model (gpt-5.5, claude-*, …) fall through - // and book a call at $0.00, flipping a purely-cached leaf's cost from - // "unknown" to "free". Only fakes and unpriced models took the intended - // path, which is why nothing caught it. + // A cache hit reports no tokens and no cost. Priced models can report the + // cost as `Some(0.0)`, so `cost.is_none()` cannot identify cache hits. if input == 0 && output == 0 && cost.unwrap_or(0.0) == 0.0 { return; } @@ -344,6 +744,9 @@ struct LlmDynScope { /// The cassette selected by this scope. Spawned siblings share one tape so /// replay and recording remain coherent across quantum boundaries. cassette: Option, + policies: Vec, + policy_bypass: Vec, + policy_agent_id: Option, } impl Default for LlmDynScope { @@ -364,6 +767,9 @@ impl Default for LlmDynScope { budget_stack: Vec::new(), custom_pricing: std::collections::HashMap::new(), cassette: None, + policies: Vec::new(), + policy_bypass: Vec::new(), + policy_agent_id: None, } } } @@ -386,6 +792,9 @@ fn read_llm_scope() -> LlmDynScope { budget_stack: BUDGET_STACK.with(|s| s.borrow().clone()), custom_pricing: pricing::snapshot_custom_pricing(), cassette: CASSETTE.with(|c| c.borrow().clone()), + policies: ACTIVE_POLICIES.with(|policies| policies.borrow().clone()), + policy_bypass: POLICY_BYPASS.with(|bypass| bypass.borrow().clone()), + policy_agent_id: POLICY_AGENT_ID.with(|agent| agent.borrow().clone()), } } @@ -407,6 +816,9 @@ fn write_llm_scope(s: LlmDynScope) -> LlmDynScope { BUDGET_STACK.with(|stack| *stack.borrow_mut() = s.budget_stack); pricing::restore_custom_pricing(s.custom_pricing); CASSETTE.with(|c| *c.borrow_mut() = s.cassette); + ACTIVE_POLICIES.with(|policies| *policies.borrow_mut() = s.policies); + POLICY_BYPASS.with(|bypass| *bypass.borrow_mut() = s.policy_bypass); + POLICY_AGENT_ID.with(|agent| *agent.borrow_mut() = s.policy_agent_id); prev } @@ -464,6 +876,9 @@ fn llm_scope_ambient_is_empty() -> bool { && RETRY_BASE_MS.with(|base| base.get() == 500) && NETWORK_MAX_RETRIES.with(|retries| retries.get() == 3) && CASSETTE.with(|c| c.borrow().is_none()) + && ACTIVE_POLICIES.with(|policies| policies.borrow().is_empty()) + && POLICY_BYPASS.with(|bypass| bypass.borrow().is_empty()) + && POLICY_AGENT_ID.with(|agent| agent.borrow().is_none()) } /// Shared field-by-field default check for [`LlmDynScope`] (avoids requiring @@ -485,6 +900,9 @@ fn llm_dyn_scope_is_default(s: &LlmDynScope) -> bool { && s.rate_limit_rps.is_none() && s.retry_base_ms == 500 && s.network_max_retries == 3 + && s.policies.is_empty() + && s.policy_bypass.is_empty() + && s.policy_agent_id.is_none() } /// Register the per-task LLM dynamic-scope callbacks with sema-core. Called once at startup. @@ -507,19 +925,15 @@ struct BudgetFrame { #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] struct CachedResponse { content: String, + /// Provider that served this response. An empty value marks a legacy cache + /// entry, which an active policy rejects. + #[serde(default)] + provider: String, model: String, prompt_tokens: u32, completion_tokens: u32, cached_at: i64, - /// The assistant turn's tool calls, if any. - /// - /// Omitting these made caching silently break agents: a tool-call turn has - /// empty `content` and N tool calls, so it was stored as an empty string - /// and replayed as a *final* answer. `run_tool_loop` sees no tool calls, - /// stops, and returns "" — no tool ever runs, no error is raised. Since - /// entries persist to disk, that poisoned every later run within the TTL, - /// which is exactly the "re-run the script cheaply" workflow `with-cache` - /// exists for. Defaulted so entries written before this field still load. + /// Assistant tool calls retained for agent-loop cache replay. #[serde(default)] tool_calls: Vec, } @@ -875,6 +1289,9 @@ pub fn reset_runtime_state() { RATE_LIMIT_RPS.with(|r| r.set(None)); RATE_LIMIT_LAST.with(|r| *r.borrow_mut() = None); install_cassette_scope(None); + ACTIVE_POLICIES.with(|policies| policies.borrow_mut().clear()); + POLICY_BYPASS.with(|bypass| bypass.borrow_mut().clear()); + POLICY_AGENT_ID.with(|agent| *agent.borrow_mut() = None); LAST_SERVING_PROVIDER.with(|p| *p.borrow_mut() = None); RETRY_BASE_MS.with(|c| c.set(500)); NETWORK_MAX_RETRIES.with(|c| c.set(3)); @@ -4299,7 +4716,6 @@ pub fn register_llm_builtins(env: &Env, sandbox: &sema_core::Sandbox) { } } - // ── SYNC path: inline provider call (byte-identical to before) ───── let responses = with_provider(|p| { let reqs: Vec = requests .into_iter() @@ -4497,6 +4913,11 @@ pub fn register_llm_builtins(env: &Env, sandbox: &sema_core::Sandbox) { .map(|scope| scope.borrow().decide(&cassette_key)); match decision { Some(crate::cassette::Decision::Replay(entry)) => { + enforce_stored_model_policy( + &entry.provider, + &entry.model, + PolicySource::Cassette, + )?; // Replay made no provider call: finalize the span inline, // account, and return without suspending. let resp = EmbedResponse { @@ -4526,8 +4947,6 @@ pub fn register_llm_builtins(env: &Env, sandbox: &sema_core::Sandbox) { } let recording = matches!(decision, Some(crate::cassette::Decision::Record)); - // Clone an Arc off the thread-local registry on THIS thread, - // release the borrow, and move it into the offloaded future. let provider = PROVIDER_REGISTRY.with(|reg| { let reg = reg.borrow(); reg.embedding_provider().or_else(|| reg.default_provider()) @@ -4538,6 +4957,11 @@ pub fn register_llm_builtins(env: &Env, sandbox: &sema_core::Sandbox) { .to_string(), )); }; + let model = request + .model + .as_deref() + .unwrap_or_else(|| provider.default_model()); + model_target_allowed(provider.name(), model, PolicySource::Request, false)?; // The provider name + canonical price are needed on the VM thread in // the decoder; capture them before the Arc is moved into the worker. @@ -4608,15 +5032,13 @@ pub fn register_llm_builtins(env: &Env, sandbox: &sema_core::Sandbox) { } } - // ── SYNC path: inline provider call (byte-identical to before) ───── - // CLIENT embeddings span (bypasses do_complete). Input tokens only. + // Synchronous embedding calls bypass do_complete. let span = sema_otel::llm_span("embeddings"); - // Advertise the input texts (content-gated; OpenInference embedding.* keys). span.set_embedding_input(&request.texts); - // Cassette interception (mirrors run_completion, for the embeddings seam). let decision = cassette_decide(&cassette_key); let response = match decision { Some(crate::cassette::Decision::Replay(entry)) => { + enforce_stored_model_policy(&entry.provider, &entry.model, PolicySource::Cassette)?; let resp = EmbedResponse { embeddings: entry.embeddings, model: entry.model.clone(), @@ -4638,7 +5060,12 @@ pub fn register_llm_builtins(env: &Env, sandbox: &sema_core::Sandbox) { Some(crate::cassette::Decision::Miss(k)) => return Err(cassette_miss_error(&k)), other => { let recording = matches!(other, Some(crate::cassette::Decision::Record)); - let resp = with_embedding_provider(|p| { + let (resp, provider_name) = with_embedding_provider(|p| { + let model = request + .model + .as_deref() + .unwrap_or_else(|| p.default_model()); + model_target_allowed(p.name(), model, PolicySource::Request, false)?; let resp = match p.embed(request) { Ok(r) => r, Err(e) => { @@ -4654,11 +5081,12 @@ pub fn register_llm_builtins(env: &Env, sandbox: &sema_core::Sandbox) { cost_usd: pricing::calculate_cost_for(p.name(), &resp.usage), ..Default::default() }); - Ok(resp) + Ok((resp, p.name().to_string())) })?; if recording { cassette_record(crate::cassette::TapeEntry::from_embed( &cassette_key, + &provider_name, &resp.model, &resp.embeddings, resp.usage.prompt_tokens, @@ -4752,6 +5180,16 @@ pub fn register_llm_builtins(env: &Env, sandbox: &sema_core::Sandbox) { }), } })?; + let resolved_model = request + .model + .as_deref() + .unwrap_or_else(|| resolved_provider.default_model()); + model_target_allowed( + resolved_provider.name(), + resolved_model, + PolicySource::Request, + false, + )?; // Root-main and spawned tasks suspend on an External wait; the decoder // builds the reordered output on the VM thread when it lands. @@ -4806,12 +5244,16 @@ pub fn register_llm_builtins(env: &Env, sandbox: &sema_core::Sandbox) { } } - // ── SYNC path: inline provider call (byte-identical to before) ───── // OpenInference RERANKER span (no-op unless telemetry + compat are on). let span = sema_otel::reranker_span(&query, model.as_deref().unwrap_or(""), top_k); span.set_input(&documents); let resp = with_rerank_provider(provider.as_deref(), |p| { + let resolved_model = request + .model + .as_deref() + .unwrap_or_else(|| p.default_model()); + model_target_allowed(p.name(), resolved_model, PolicySource::Request, false)?; p.rerank(request).map_err(|e| { span.record_error(llm_error_kind(&e), &e.to_string()); SemaError::Llm(e.to_string()) @@ -6728,6 +7170,7 @@ pub fn register_llm_builtins(env: &Env, sandbox: &sema_core::Sandbox) { // JSON-coerce the arguments (lossily) so a direct invocation hands the // handler exactly what an agent-driven tool call would. let json_args = sema_core::value_to_json_lossy(&args[1]); + enforce_direct_tool_policy(&tool_def.name, &json_args)?; let handler_args = json_args_to_sema(&tool_def.parameters, &json_args, &tool_def.handler); Box::new(ToolInvokeContinuation { tool_name: tool_def.name.clone(), @@ -7083,6 +7526,11 @@ fn compute_cache_key(request: &ChatRequest) -> String { hasher.update(schema.as_bytes()); } } + let policy_fingerprint = effective_policy_fingerprint(); + if !policy_fingerprint.is_empty() { + hasher.update(b"\x00policy\x00"); + hasher.update(policy_fingerprint.as_bytes()); + } format!("{:x}", hasher.finalize()) } @@ -7132,9 +7580,10 @@ fn read_cached_from_disk(path: &std::path::Path) -> Option { serde_json::from_str(&data).ok() } -fn store_cached(key: &str, response: &ChatResponse) { +fn store_cached(key: &str, response: &ChatResponse, provider: &str) { let cached = CachedResponse { content: response.content.clone(), + provider: provider.to_string(), model: response.model.clone(), prompt_tokens: response.usage.prompt_tokens, completion_tokens: response.usage.completion_tokens, @@ -7428,11 +7877,7 @@ fn do_complete(request: ChatRequest) -> Result { if !cache_enabled { return run_completion(request, &span); } - // Compute the cache key from the model the request will *logically* use, but - // without mutating the request that flows into the fallback loop. Pre-filling - // `request.model` here would make it non-empty and defeat the per-provider - // default/override substitution in `do_complete_with_provider` — sending the - // wrong provider's model id down the chain (the original cache+fallback bug). + // Keep request.model unchanged so fallback entries can apply their own model. let key_model = if request.model.is_empty() { primary_model_for_cache()? } else { @@ -7443,6 +7888,7 @@ fn do_complete(request: ChatRequest) -> Result { let cache_key = compute_cache_key(&key_request); if let Some(cached) = load_cached(&cache_key) { if is_cache_valid(&cached) { + enforce_stored_model_policy(&cached.provider, &cached.model, PolicySource::Cache)?; CACHE_HITS.with(|c| c.set(c.get() + 1)); // A cache hit makes no provider call: no tokens are consumed and no money // is spent. Report ZERO usage so the caller's `track_usage` does not @@ -7457,7 +7903,8 @@ fn do_complete(request: ChatRequest) -> Result { } CACHE_MISSES.with(|c| c.set(c.get() + 1)); let response = run_completion(request, &span)?; - store_cached(&cache_key, &response); + let serving_provider = LAST_SERVING_PROVIDER.with(|p| p.borrow().clone().unwrap_or_default()); + store_cached(&cache_key, &response, &serving_provider); Ok(response) } @@ -7465,8 +7912,8 @@ fn do_complete(request: ChatRequest) -> Result { /// option. Opens the same per-completion `chat` span/scope, but drives /// `stream_with_dispatch` and delivers each text delta to the Sema `on_text` /// callback. Returns the assembled [`ChatResponse`] so the loop's tool-call -/// handling and `track_usage` accounting are byte-identical to the non-streaming -/// path. Streaming bypasses the completion cache (like `llm/stream`). +/// handling and `track_usage` accounting match the non-streaming path. Streaming +/// bypasses the completion cache (like `llm/stream`). fn do_complete_streaming( ctx: &EvalContext, request: ChatRequest, @@ -7639,7 +8086,6 @@ fn complete_offload_prep(request: ChatRequest) -> Result Result Result { + enforce_stored_model_policy(&entry.provider, &entry.model, PolicySource::Cassette)?; let resp = entry.to_response(); span.set_dispatch("cassette", &resp.model); span.set_response(&response_facts("cassette", &resp)); @@ -7800,12 +8248,12 @@ fn finalize_complete_success( drop(span); // ends the span set_serving_provider(&serving_provider); if let Some(key) = &cache_key { - store_cached(key, &resp); + store_cached(key, &resp, &serving_provider); } if let Some(key) = &cassette_record_key { cassette_scope_record( &cassette_scope, - crate::cassette::TapeEntry::from_response(key, &resp), + crate::cassette::TapeEntry::from_response(key, &serving_provider, &resp), ); } // Fold this completion into the LEAF'S OWN captured accumulator frame — the @@ -8019,6 +8467,14 @@ impl RuntimeCompleteDriver { } else if request.model.is_empty() { request.model = provider.default_model().to_string(); } + if !model_target_allowed( + &provider_name, + &request.model, + PolicySource::Request, + self.plan.chain.len() > 1, + )? { + continue; + } if provider.runs_on_vm_thread() { let callback = match lisp_provider_complete_callback(&provider_name) { @@ -8085,6 +8541,7 @@ impl RuntimeCompleteDriver { ) -> sema_core::runtime::NativeResult { if let Some(cached) = disk { if is_cache_valid(&cached) { + enforce_stored_model_policy(&cached.provider, &cached.model, PolicySource::Cache)?; CACHE_HITS.with(|c| c.set(c.get() + 1)); let Self { plan, finalize, .. } = *self; if let Some(key) = &plan.cache_key { @@ -8677,6 +9134,7 @@ impl sema_core::runtime::CompletionDecoder for EmbedDecoder { &self.cassette_scope, crate::cassette::TapeEntry::from_embed( &self.key, + &self.provider_name, &resp.model, &resp.embeddings, resp.usage.prompt_tokens, @@ -9006,6 +9464,7 @@ fn run_completion( let decision = cassette_decide(&key).expect("cassette scope checked above"); match decision { crate::cassette::Decision::Replay(entry) => { + enforce_stored_model_policy(&entry.provider, &entry.model, PolicySource::Cassette)?; // A replayed call is a stand-in for a real one: emit the span with the // recorded facts and let the caller's usage/cost accounting run on the // recorded tokens (distinct from a cache hit, which reports zero usage). @@ -9017,7 +9476,10 @@ fn run_completion( crate::cassette::Decision::Miss(k) => Err(cassette_miss_error(&k)), crate::cassette::Decision::Record => { let resp = do_complete_inner(request, span)?; - cassette_record(crate::cassette::TapeEntry::from_response(&key, &resp)); + let provider = LAST_SERVING_PROVIDER.with(|p| p.borrow().clone().unwrap_or_default()); + cassette_record(crate::cassette::TapeEntry::from_response( + &key, &provider, &resp, + )); Ok(resp) } } @@ -9032,13 +9494,45 @@ fn cassette_miss_error(key: &str) -> SemaError { )) } -/// Streaming counterpart to `run_completion`: replays the recorded chunk sequence -/// (feeding the caller's `on_chunk` so boundaries match) and final response, or -/// records a fresh stream by capturing chunks as they arrive. Transparent -/// passthrough with no active cassette. Sits below the otel span, above the provider. -fn stream_with_cassette( +enum StreamCassettePlan { + Replay(ChatResponse), + Live { record_key: Option }, +} + +fn prepare_stream_cassette( + request: &ChatRequest, + chunk_cb: &mut dyn FnMut(&str) -> Result<(), crate::types::LlmError>, + span: &sema_otel::LlmSpan, +) -> Result { + if current_cassette_scope().is_none() { + return Ok(StreamCassettePlan::Live { record_key: None }); + } + + let key = compute_cache_key(request); + match cassette_decide(&key).expect("cassette scope checked above") { + crate::cassette::Decision::Replay(entry) => { + enforce_stored_model_policy(&entry.provider, &entry.model, PolicySource::Cassette)?; + for chunk in &entry.chunks { + chunk_cb(chunk).map_err(|error| SemaError::Llm(error.to_string()))?; + } + let provider = entry.provider.clone(); + let response = entry.to_response(); + span.set_dispatch("cassette", &response.model); + span.set_response(&response_facts("cassette", &response)); + set_serving_provider(&provider); + Ok(StreamCassettePlan::Replay(response)) + } + crate::cassette::Decision::Miss(key) => Err(cassette_miss_error(&key)), + crate::cassette::Decision::Record => Ok(StreamCassettePlan::Live { + record_key: Some(key), + }), + } +} + +fn stream_live( p: &dyn LlmProvider, request: ChatRequest, + record_key: Option<&str>, chunk_cb: &mut dyn FnMut(&str) -> Result<(), crate::types::LlmError>, span: &sema_otel::LlmSpan, ) -> Result { @@ -9061,41 +9555,26 @@ fn stream_with_cassette( }) }; - if current_cassette_scope().is_none() { - let resp = stream_real(request.clone(), chunk_cb)?; - span.set_dispatch(p.name(), &request.model); - span.set_response(&response_facts(p.name(), &resp)); - return Ok(resp); - } - - let key = compute_cache_key(&request); - let decision = cassette_decide(&key).expect("cassette scope checked above"); - match decision { - crate::cassette::Decision::Replay(entry) => { - for ch in &entry.chunks { - chunk_cb(ch).map_err(|e| SemaError::Llm(e.to_string()))?; - } - let resp = entry.to_response(); - span.set_dispatch("cassette", &resp.model); - span.set_response(&response_facts("cassette", &resp)); - Ok(resp) - } - crate::cassette::Decision::Miss(k) => Err(cassette_miss_error(&k)), - crate::cassette::Decision::Record => { - let mut collected: Vec = Vec::new(); - let mut wrap = |chunk: &str| -> Result<(), crate::types::LlmError> { - collected.push(chunk.to_string()); - chunk_cb(chunk) - }; - let resp = stream_real(request.clone(), &mut wrap)?; - cassette_record(crate::cassette::TapeEntry::from_stream( - &key, &collected, &resp, - )); - span.set_dispatch(p.name(), &request.model); - span.set_response(&response_facts(p.name(), &resp)); - Ok(resp) - } - } + let response = if let Some(key) = record_key { + let mut chunks = Vec::new(); + let mut collect = |chunk: &str| -> Result<(), crate::types::LlmError> { + chunks.push(chunk.to_string()); + chunk_cb(chunk) + }; + let response = stream_real(request.clone(), &mut collect)?; + cassette_record(crate::cassette::TapeEntry::from_stream( + key, + p.name(), + &chunks, + &response, + )); + response + } else { + stream_real(request.clone(), chunk_cb)? + }; + span.set_dispatch(p.name(), &request.model); + span.set_response(&response_facts(p.name(), &response)); + Ok(response) } /// Cassette key for an embeddings request (model + the input texts). @@ -9109,12 +9588,16 @@ fn compute_embed_key(request: &EmbedRequest) -> String { hasher.update(t.as_bytes()); hasher.update(b"\0"); } + let policy_fingerprint = effective_policy_fingerprint(); + if !policy_fingerprint.is_empty() { + hasher.update(b"\0policy\0"); + hasher.update(policy_fingerprint.as_bytes()); + } format!("{:x}", hasher.finalize()) } -/// Encode an `EmbedResponse`'s vectors into the SAME `Value` the synchronous -/// `llm/embed` returns (single → bytevector; multi → list of bytevectors), so the -/// concurrent (async) and sync paths are byte-identical: both decode through here. +/// Encode an `EmbedResponse` for both synchronous and async calls. A single +/// vector becomes a bytevector; multiple vectors become a list of bytevectors. fn embed_value_from_response(resp: &EmbedResponse, single: bool) -> Value { if single { let embedding = resp.embeddings.first().cloned().unwrap_or_default(); @@ -9133,10 +9616,8 @@ fn embed_value_from_response(resp: &EmbedResponse, single: bool) -> Value { } } -/// Encode a `RerankResponse`'s reordered results into the SAME `Value` the -/// synchronous `llm/rerank` returns (a list of `{:index :score :document}`, highest -/// relevance first), so the concurrent (async) and sync paths are byte-identical: -/// both decode through here. +/// Encode a `RerankResponse` for both synchronous and async calls. Results are +/// ordered by relevance and contain `:index`, `:score`, and `:document`. fn rerank_value_from_response(resp: &RerankResponse, documents: &[String]) -> Value { Value::list( resp.results @@ -9527,7 +10008,8 @@ fn do_complete_inner( let mut last_error = None; for entry in &chain { match do_complete_with_provider(entry, request.clone(), span) { - Ok(resp) => return Ok(resp), + Ok(Some(resp)) => return Ok(resp), + Ok(None) => continue, Err(e) => { eprintln!( "Provider '{}' failed: {}, trying next...", @@ -9824,7 +10306,7 @@ fn do_complete_with_provider( entry: &FallbackEntry, mut request: ChatRequest, span: &sema_otel::LlmSpan, -) -> Result { +) -> Result, SemaError> { PROVIDER_REGISTRY.with(|reg| { let reg = reg.borrow(); let provider = reg.get(&entry.provider).ok_or_else(|| { @@ -9839,6 +10321,9 @@ fn do_complete_with_provider( } else if request.model.is_empty() { request.model = provider.default_model().to_string(); } + if !model_target_allowed(&entry.provider, &request.model, PolicySource::Request, true)? { + return Ok(None); + } let max_retries = NETWORK_MAX_RETRIES.with(|c| c.get()); let resp = complete_with_retry(&*provider, &request, max_retries) .map_err(|e| SemaError::Llm(e.to_string()))?; @@ -9856,7 +10341,7 @@ fn do_complete_with_provider( .map(|s| content_json("system", s)) .as_deref(), ); - Ok(resp) + Ok(Some(resp)) }) } @@ -9871,8 +10356,7 @@ type StreamArgs = ( /// Parse `llm/stream`-shaped args — prompt/messages, then an optional callback /// (any procedure) and an optional opts map in either order — into the /// `ChatRequest` plus the raw callback/opts. Shared by the blocking native -/// (`__llm-stream-blocking`) and the non-blocking `__stream-begin`, so both -/// paths accept byte-identical calls. +/// (`__llm-stream-blocking`) and the non-blocking `__stream-begin`. fn parse_stream_args(args: &[Value]) -> Result { if args.is_empty() || args.len() > 3 { return Err(SemaError::arity("llm/stream", "1-3", args.len())); @@ -9961,7 +10445,7 @@ fn stream_one_provider( mut request: ChatRequest, chunk_cb: &mut dyn FnMut(&str) -> Result<(), crate::types::LlmError>, span: &sema_otel::LlmSpan, -) -> Result { +) -> Result, SemaError> { PROVIDER_REGISTRY.with(|reg| { let reg = reg.borrow(); let provider = reg.get(&entry.provider).ok_or_else(|| { @@ -9972,9 +10456,16 @@ fn stream_one_provider( } else if request.model.is_empty() { request.model = provider.default_model().to_string(); } - let resp = stream_with_cassette(&*provider, request, chunk_cb, span)?; + let record_key = match prepare_stream_cassette(&request, chunk_cb, span)? { + StreamCassettePlan::Replay(response) => return Ok(Some(response)), + StreamCassettePlan::Live { record_key } => record_key, + }; + if !model_target_allowed(&entry.provider, &request.model, PolicySource::Request, true)? { + return Ok(None); + } + let resp = stream_live(&*provider, request, record_key.as_deref(), chunk_cb, span)?; set_serving_provider(&entry.provider); - Ok(resp) + Ok(Some(resp)) }) } @@ -10005,7 +10496,8 @@ fn stream_with_dispatch( stream_one_provider(entry, request.clone(), &mut wrapped, span) }; match result { - Ok(resp) => return Ok(resp), + Ok(Some(resp)) => return Ok(resp), + Ok(None) => continue, Err(e) if emitted => { // Mid-stream failure: surface; do NOT fail over (would duplicate). span.record_error("provider_error", &e.to_string()); @@ -10029,12 +10521,16 @@ fn stream_with_dispatch( if req.model.is_empty() { req.model = p.default_model().to_string(); } - stream_with_cassette(p, req, chunk_cb, span) + let record_key = match prepare_stream_cassette(&req, chunk_cb, span)? { + StreamCassettePlan::Replay(response) => return Ok(response), + StreamCassettePlan::Live { record_key } => record_key, + }; + model_target_allowed(p.name(), &req.model, PolicySource::Request, false)?; + stream_live(p, req, record_key.as_deref(), chunk_cb, span) }), } } -/// Original do_complete logic (provider dispatch + rate-limit retry). fn do_complete_uncached( mut request: ChatRequest, span: &sema_otel::LlmSpan, @@ -10045,6 +10541,7 @@ fn do_complete_uncached( if request.model.is_empty() { request.model = p.default_model().to_string(); } + model_target_allowed(p.name(), &request.model, PolicySource::Request, false)?; let resp = complete_with_retry(p, &request, max_retries) .map_err(|e| SemaError::Llm(e.to_string()))?; set_serving_provider(p.name()); @@ -10714,7 +11211,7 @@ fn agent_begin(args: &[Value]) -> Result { /// mirroring `run_tool_loop`'s own setup (a caller-id-or-fresh conversation scope + /// a nameless agent span) rather than `agent_begin`'s (which threads a defagent's /// identity + `:session`/`:memory` resolution through). The options parsing below -/// is intentionally byte-identical to `__llm-chat-blocking`'s. +/// matches `__llm-chat-blocking`. /// /// Returns nil when no tool loop is needed — the same `tools.is_empty() || /// tool_mode == "none"` condition `__llm-chat-blocking` checks — so the prelude @@ -10984,6 +11481,7 @@ fn agent_exec_tools(ctx: &EvalContext, token: u64) -> sema_core::runtime::Native let pending = std::mem::take(&mut st.pending_tool_calls); Ok::<_, SemaError>((pending, st.tools.clone(), st.on_tool_call.clone())) })?; + let denied = preflight_tool_calls(&pending)?; // Cooperative runtime path (Task 04/06): a tool handler may SUSPEND (e.g. // `mcp/call`'s runtime external wait, or an `async/await` inside the handler), @@ -10996,10 +11494,14 @@ fn agent_exec_tools(ctx: &EvalContext, token: u64) -> sema_core::runtime::Native // per-tool OTel span + `:on-tool-call` start/end events + correlated tool // results (with the same error-recovery) the synchronous `run_tool_loop` does. if sema_core::in_runtime_quantum() { - return exec_tools_cooperative_start(token, tools, on_tool_call, pending); + return exec_tools_cooperative_start(token, tools, on_tool_call, pending, denied); } for tc in &pending { + if let Some(error) = denied.get(&tc.id) { + record_tool_result(token, tc, error.clone(), true); + continue; + } let args_value = sema_core::json_to_value(&tc.arguments); if let Some(callback) = on_tool_call.as_ref() { @@ -11137,6 +11639,7 @@ struct ExecToolsContinuation { on_tool_call: Option, /// Tool calls not yet dispatched (front = next). remaining: std::collections::VecDeque, + denied: BTreeMap, /// The call currently in flight, plus which `Call` the next `resume` settles. active: Option, phase: ToolPhase, @@ -11327,6 +11830,10 @@ impl ExecToolsContinuation { let Some(tc) = self.remaining.pop_front() else { return Ok(NativeOutcome::Return(Value::nil())); }; + if let Some(error) = self.denied.remove(&tc.id) { + record_tool_result(self.token, &tc, error, true); + return self.advance(); + } let args_value = sema_core::json_to_value(&tc.arguments); let prepared = prepare_tool_call_cooperative(&self.tools, &tc.name, &tc.arguments); let (pending_handler, pending_error, validation_steps) = match prepared { @@ -11475,12 +11982,14 @@ fn exec_tools_cooperative_start( tools: Vec, on_tool_call: Option, pending: Vec, + denied: BTreeMap, ) -> sema_core::runtime::NativeResult { let continuation = Box::new(ExecToolsContinuation { token, tools, on_tool_call, remaining: pending.into(), + denied, active: None, phase: ToolPhase::Handler, }); @@ -11816,19 +12325,10 @@ fn resolve_stream_chain() -> Result, SemaError> { }) } -/// Start a non-blocking stream run: budget pre-gate and cassette decision happen -/// on the VM thread. Replay pre-fills the run; a real dispatch stores an owned -/// provider plan for `__stream-next` to drive one provider at a time. `span` is -/// the caller's detached chat span and is finalized when `Done` lands. -/// -/// The rate-limit gate sits AFTER the cassette decision (unlike the sync -/// `stream_with_dispatch`, which always calls `enforce_rate_limit` up front): -/// a replay makes no provider call, so it does not consume a pacing slot. +/// Start a non-blocking stream run. Cassette replay does not reserve a rate-limit slot. fn stream_run_begin(request: ChatRequest, span: sema_otel::LlmSpan) -> Result { stream_budget_pregate()?; - // Keyed by the request as-is (no default-model resolution), matching the - // synchronous `stream_with_cassette` so record/replay agree across paths. let cassette_scope = current_cassette_scope(); let cassette_decision = cassette_scope.as_ref().map(|scope| { let key = compute_cache_key(&request); @@ -11839,6 +12339,7 @@ fn stream_run_begin(request: ChatRequest, span: sema_otel::LlmSpan) -> Result { + enforce_stored_model_policy(&entry.provider, &entry.model, PolicySource::Cassette)?; for ch in &entry.chunks { buffered.push_back(StreamEvent::Delta(ch.clone())); } @@ -11942,6 +12443,7 @@ impl RuntimeStreamDriver { enum Action { Pace(u64), + Skip, Sema { provider: String, model: String, @@ -11993,6 +12495,14 @@ impl RuntimeStreamDriver { } else if request.model.is_empty() { request.model = entry.provider.default_model().to_string(); } + if !model_target_allowed( + &entry.name, + &request.model, + PolicySource::Request, + dispatch.chain.len() > 1, + )? { + return Ok(Action::Skip); + } if entry.provider.runs_on_vm_thread() { Ok(Action::Sema { @@ -12006,6 +12516,7 @@ impl RuntimeStreamDriver { })?; match action { + Action::Skip => continue, Action::Pace(wait_ms) => { self.phase = RuntimeStreamPhase::Pacing; return Ok(NativeOutcome::Suspend(NativeSuspend { @@ -12193,7 +12704,7 @@ fn stream_finalize( if let Some(key) = &cassette_record_key { cassette_scope_record( &cassette_scope, - crate::cassette::TapeEntry::from_stream(key, collected, &resp), + crate::cassette::TapeEntry::from_stream(key, &done.provider, collected, &resp), ); } // Fold into THIS run's captured accumulator frame, then suppress @@ -12691,6 +13202,10 @@ fn run_tool_loop( _agent_span.set_trace_io(&first_input, &last_content); return Ok((last_content, messages)); } + // Gate the entire batch before any callback, validation predicate, or handler. + // A hard denial aborts the round with zero tool side effects; `:tool-error` + // denials become correlated tool results while allowed siblings may proceed. + let denied = preflight_tool_calls(&response.tool_calls)?; // Echo the assistant turn that invoked the tools, carrying the tool_calls // so the provider can correlate the tool results that follow. This MUST be @@ -12703,6 +13218,22 @@ fn run_tool_loop( // Execute each tool call and add results for tc in &response.tool_calls { + if let Some(error) = denied.get(&tc.id) { + consecutive_errors += 1; + messages.push(ChatMessage::tool_result( + tc.id.clone(), + tc.name.clone(), + error.clone(), + )); + if consecutive_errors >= MAX_CONSECUTIVE_TOOL_ERRORS { + let msg = format!( + "aborting agent run after {consecutive_errors} consecutive tool errors" + ); + _agent_span.record_error("tool_error", &msg); + return Err(SemaError::Llm(msg)); + } + continue; + } // Build args map for callback let args_value = sema_core::json_to_value(&tc.arguments); @@ -13241,6 +13772,7 @@ mod tests { tools: vec![Value::int(1), Value::int(2)], on_tool_call: Some(Value::int(3)), remaining: std::collections::VecDeque::new(), + denied: BTreeMap::new(), active: None, phase: ToolPhase::Handler, }; @@ -14060,7 +14592,7 @@ mod tests { usage: Usage::default(), stop_reason: Some("tool_use".to_string()), }; - store_cached(key, &response); + store_cached(key, &response, "fake"); let cached = CACHE_MEM .with(|c| c.borrow().get(key).cloned()) diff --git a/crates/sema-llm/src/cassette.rs b/crates/sema-llm/src/cassette.rs index be824568..ec9a4089 100644 --- a/crates/sema-llm/src/cassette.rs +++ b/crates/sema-llm/src/cassette.rs @@ -58,6 +58,10 @@ pub struct TapeEntry { /// Request hash (the matching key). pub key: String, pub content: String, + /// Provider that served the interaction. An empty value marks a legacy tape + /// entry, which an active policy rejects. + #[serde(default, skip_serializing_if = "String::is_empty")] + pub provider: String, #[serde(default = "default_role")] pub role: String, pub model: String, @@ -91,12 +95,13 @@ fn default_role() -> String { impl TapeEntry { /// Build a tape entry from a live response under `key`. - pub fn from_response(key: &str, resp: &ChatResponse) -> TapeEntry { + pub fn from_response(key: &str, provider: &str, resp: &ChatResponse) -> TapeEntry { TapeEntry { v: 1, kind: "complete".to_string(), key: key.to_string(), content: resp.content.clone(), + provider: provider.to_string(), role: resp.role.clone(), model: resp.model.clone(), tool_calls: resp.tool_calls.clone(), @@ -119,6 +124,7 @@ impl TapeEntry { kind: "mcp-call".to_string(), key: key.to_string(), content: String::new(), + provider: String::new(), role: default_role(), model: String::new(), tool_calls: Vec::new(), @@ -134,8 +140,13 @@ impl TapeEntry { } /// Tape entry for a streamed completion: the chunk sequence plus the final response. - pub fn from_stream(key: &str, chunks: &[String], resp: &ChatResponse) -> TapeEntry { - let mut entry = TapeEntry::from_response(key, resp); + pub fn from_stream( + key: &str, + provider: &str, + chunks: &[String], + resp: &ChatResponse, + ) -> TapeEntry { + let mut entry = TapeEntry::from_response(key, provider, resp); entry.kind = "stream".to_string(); entry.chunks = chunks.to_vec(); entry @@ -144,6 +155,7 @@ impl TapeEntry { /// Tape entry for an embeddings call: the vectors plus the model and input tokens. pub fn from_embed( key: &str, + provider: &str, model: &str, embeddings: &[Vec], prompt_tokens: u32, @@ -153,6 +165,7 @@ impl TapeEntry { kind: "embed".to_string(), key: key.to_string(), content: String::new(), + provider: provider.to_string(), role: default_role(), model: model.to_string(), tool_calls: Vec::new(), @@ -445,7 +458,7 @@ mod tests { #[test] fn entry_round_trips_response_with_usage() { let r = resp("hello", 12, 34); - let e = TapeEntry::from_response("k1", &r); + let e = TapeEntry::from_response("k1", "fake", &r); let back = e.to_response(); assert_eq!(back.content, "hello"); assert_eq!(back.usage.prompt_tokens, 12); @@ -475,7 +488,11 @@ mod tests { persisted_entries: 0, }; assert!(matches!(cass.decide("k"), Decision::Record)); - cass.record_entry(TapeEntry::from_response("k", &resp("recorded", 5, 6))); + cass.record_entry(TapeEntry::from_response( + "k", + "fake", + &resp("recorded", 5, 6), + )); match cass.decide("k") { Decision::Replay(e) => { let r = e.to_response(); @@ -495,8 +512,8 @@ mod tests { )); let mut first = Cassette::load(path.clone(), CassetteMode::Record); let mut second = Cassette::load(path.clone(), CassetteMode::Record); - first.record_entry(TapeEntry::from_response("first", &resp("a", 1, 1))); - second.record_entry(TapeEntry::from_response("second", &resp("b", 1, 1))); + first.record_entry(TapeEntry::from_response("first", "fake", &resp("a", 1, 1))); + second.record_entry(TapeEntry::from_response("second", "fake", &resp("b", 1, 1))); first.save().expect("append first task's entry"); second.save().expect("append second task's entry"); @@ -517,6 +534,7 @@ mod tests { let mut cassette = Cassette::load(path.clone(), CassetteMode::Record); cassette.record_entry(TapeEntry::from_response( "survives-retry", + "fake", &resp("answer", 1, 1), )); @@ -540,7 +558,7 @@ mod tests { line!() )); let mut cass = Cassette::load(path.clone(), CassetteMode::Record); - cass.record_entry(TapeEntry::from_response("k", &resp("v", 1, 1))); + cass.record_entry(TapeEntry::from_response("k", "fake", &resp("v", 1, 1))); // The VM-thread half renders the pending NDJSON and marks it persisted. let (rendered_path, encoded) = cass.take_pending_append().expect("pending entry"); @@ -563,8 +581,8 @@ mod tests { let dir = std::env::temp_dir().join(format!("sema-cassette-test-{}", std::process::id())); let path = dir.join("tape.jsonl"); let mut tape = Tape::default(); - tape.record(TapeEntry::from_response("a", &resp("one", 1, 2))); - tape.record(TapeEntry::from_response("b", &resp("two", 3, 4))); + tape.record(TapeEntry::from_response("a", "fake", &resp("one", 1, 2))); + tape.record(TapeEntry::from_response("b", "fake", &resp("two", 3, 4))); tape.save(&path).unwrap(); let loaded = Tape::load(&path); diff --git a/crates/sema-llm/src/fake.rs b/crates/sema-llm/src/fake.rs index 1cb7a5d2..844bf7af 100644 --- a/crates/sema-llm/src/fake.rs +++ b/crates/sema-llm/src/fake.rs @@ -218,16 +218,31 @@ impl FakeProviderBuilder { /// Script an assistant turn that emits a single tool call (empty text content, /// `tool_use` stop reason) — mirrors how OpenAI/Anthropic return tool calls. pub fn tool_call(mut self, id: &str, name: &str, arguments: serde_json::Value) -> Self { + self.push_tool_calls(vec![ToolCall { + id: id.to_string(), + name: name.to_string(), + arguments, + thought_signature: None, + }]); + self + } + + /// Script one assistant turn containing a batch of tool calls. + /// + /// This is useful for testing batch preflight and sibling-call behavior that + /// cannot be represented by repeated [`Self::tool_call`] calls (those are + /// separate assistant turns). + pub fn tool_calls(mut self, calls: Vec) -> Self { + self.push_tool_calls(calls); + self + } + + fn push_tool_calls(&mut self, calls: Vec) { let resp = ChatResponse { content: String::new(), role: "assistant".to_string(), model: self.default_model.clone(), - tool_calls: vec![ToolCall { - id: id.to_string(), - name: name.to_string(), - arguments, - thought_signature: None, - }], + tool_calls: calls, usage: Usage { prompt_tokens: 10, completion_tokens: 5, @@ -237,7 +252,6 @@ impl FakeProviderBuilder { stop_reason: Some("tool_use".to_string()), }; self.script.push_back(FakeReply::Chat(resp)); - self } /// Script a streamed reply: `chunks` are delivered to `on_chunk`, then the diff --git a/crates/sema-stdlib/Cargo.toml b/crates/sema-stdlib/Cargo.toml index 981066db..15cd4226 100644 --- a/crates/sema-stdlib/Cargo.toml +++ b/crates/sema-stdlib/Cargo.toml @@ -41,6 +41,7 @@ similar.workspace = true sema-io.workspace = true sema-workflow.workspace = true sema-llm.workspace = true +sema-policy.workspace = true tokio.workspace = true reqwest.workspace = true # Enables rustls's `ring` feature in the unified graph: with exactly one provider diff --git a/crates/sema-stdlib/src/workflow.rs b/crates/sema-stdlib/src/workflow.rs index e436bb30..74168172 100644 --- a/crates/sema-stdlib/src/workflow.rs +++ b/crates/sema-stdlib/src/workflow.rs @@ -28,9 +28,14 @@ use sema_core::runtime::{ ResumeInput, SendPayload, TaskContextHandle, Trace, WaitKind, }; use sema_core::{SemaError, Value}; +use sema_llm::builtins::{ + PolicyAttributionScope, PolicyBypassScope, PolicyDecisionSink, PolicyObservation, + PolicyObservationKind, PolicyScope, +}; use sema_workflow::context; use sema_workflow::event::WorkflowEvent; use std::collections::BTreeMap; +use std::path::{Path, PathBuf}; use std::rc::Rc; use std::sync::mpsc::Receiver; use std::time::{Duration, Instant}; @@ -54,6 +59,112 @@ fn opt_str(v: &Value, key: &str) -> String { .unwrap_or_default() } +fn opt_value(v: &Value, key: &str) -> Option { + v.as_map_rc() + .and_then(|m| m.get(&Value::keyword(key)).cloned()) +} + +fn compile_policy(container: &Value) -> Result>, SemaError> { + opt_value(container, "policy") + .map(|policy| { + sema_policy::CompiledPolicy::compile(&policy) + .map(Rc::new) + .map_err(|error| SemaError::eval(format!("invalid workflow policy: {error}"))) + }) + .transpose() +} + +fn policy_sink(ctx: &Rc) -> PolicyDecisionSink { + let weak = Rc::downgrade(ctx); + Rc::new(move |observation| { + let Some(ctx) = weak.upgrade() else { + return; + }; + emit_policy_observation(&ctx, observation); + }) +} + +fn emit_policy_observation(ctx: &context::WorkflowCtx, observation: PolicyObservation) { + let PolicyObservation { + kind, + policy, + policy_digest, + boundary, + subject, + subject_digest, + rule, + action, + reason, + source, + agent_id, + } = observation; + let seq = ctx.next_seq(); + let ts = ctx.ts(); + let phase_seq = ctx.phase_seq(); + let boundary = boundary.as_str().to_string(); + let source = source.as_str().to_string(); + + let event = match kind { + PolicyObservationKind::Checked => WorkflowEvent::PolicyChecked { + seq, + ts, + phase_seq, + agent_id, + policy, + policy_digest, + boundary, + subject, + subject_digest, + rule, + source, + }, + PolicyObservationKind::Violation => WorkflowEvent::PolicyViolation { + seq, + ts, + phase_seq, + agent_id, + policy, + policy_digest, + boundary, + subject, + subject_digest, + rule, + action: action.unwrap_or_else(|| "fail".to_string()), + reason: reason.unwrap_or_else(|| "denied".to_string()), + source, + }, + PolicyObservationKind::Bypassed => WorkflowEvent::PolicyBypassed { + seq, + ts, + phase_seq, + agent_id, + policy, + policy_digest, + boundary, + subject, + subject_digest, + rule, + reason: reason.unwrap_or_else(|| "unspecified".to_string()), + source, + }, + }; + ctx.emit(event); +} + +fn open_compiled_policy( + policy: Option>, + ctx: &Rc, + workspace_root: &Path, +) -> Option { + policy.map(|policy| { + sema_llm::builtins::open_policy_scope( + policy, + workspace_root.to_path_buf(), + policy_sink(ctx), + ) + }) +} + /// The workflow's declared phase plan from `defworkflow` meta `:phases` (a list or /// vector of names — keyword OR string items, via `as_name`). Empty when absent. Lets /// the dashboard show ALL phases up front instead of only those that have started. @@ -93,18 +204,13 @@ fn cap_text(s: &str) -> String { } } -/// Max bytes of a value's compact form the journal renders inline before truncating. -/// Golden values are tiny (far below this), so [`capped_render`] returns `pretty_print` -/// verbatim for them and the goldens stay byte-identical; only a pathologically large -/// value is truncated — and it is NEVER materialized in full (the compact form is -/// bounded-checked via `context::compact_capped`, which aborts at the cap). +/// Maximum size of a compact journal value before truncation. The bounded +/// renderer does not materialize an over-limit value in full. const RENDERED_VALUE_MAX_BYTES: usize = 8192; /// Render a value for the journal so the dashboard can show the real data, byte-budgeted -/// so one huge value can't materialize a multi-MB string on the VM thread. A value that -/// fits renders exactly as before (`pretty_print(v, 100)`) — keeping goldens -/// byte-identical; an over-cap value is rendered from its bounded compact prefix + a -/// truncation marker. +/// so one huge value cannot materialize a multi-MB string on the VM thread. Small values +/// use `pretty_print`; larger values use a bounded compact prefix and a truncation marker. fn capped_render(v: &Value) -> String { let (compact, truncated) = sema_workflow::context::compact_capped(v, RENDERED_VALUE_MAX_BYTES); if truncated { @@ -413,6 +519,8 @@ struct StepTeardown { content_key: String, start: Instant, usage_scope: sema_llm::builtins::UsageScope, + _policy_scope: Option, + _attribution_scope: PolicyAttributionScope, } /// Journal a `workflow/step` leaf's result: emit `agent.result`, attribute usage via a @@ -475,8 +583,49 @@ fn finish_step( result.map(NativeOutcome::Return) } -/// Pre-thunk work for `workflow/step` — see the original inline documentation preserved -/// in `finish_step` and the event emissions below. +struct PolicyBypassTeardown { + _bypass_scope: PolicyBypassScope, +} + +fn policy_bypass_plan( + task_context: Option<&TaskContextHandle>, + args: &[Value], +) -> Result, SemaError> { + if args.len() != 2 { + return Err(SemaError::arity("workflow/policy-without", "2", args.len())); + } + if context::current_for(task_context).is_none() || !sema_llm::builtins::policy_active() { + return Err(SemaError::eval( + "policy/without requires an active workflow policy", + )); + } + let reason = args[0] + .as_str() + .ok_or_else(|| SemaError::type_error("string", args[0].type_name()))? + .trim() + .to_string(); + if reason.is_empty() || reason.chars().count() > 256 { + return Err(SemaError::eval( + "policy/without reason must contain 1 to 256 characters", + )); + } + Ok(ThunkPlan::Run { + thunk: args[1].clone(), + teardown: PolicyBypassTeardown { + _bypass_scope: sema_llm::builtins::open_policy_bypass(reason), + }, + }) +} + +fn finish_policy_bypass( + _task_context: Option<&TaskContextHandle>, + _teardown: PolicyBypassTeardown, + result: Result, + _durable: bool, +) -> NativeResult { + result.map(NativeOutcome::Return) +} + fn step_plan( task_context: Option<&TaskContextHandle>, args: &[Value], @@ -489,6 +638,11 @@ fn step_plan( let label = agent_role(&args[0]); let thunk = args[1].clone(); let Some(ctx) = context::current_for(task_context) else { + if opt_value(&args[0], "policy").is_some() { + return Err(SemaError::eval( + "workflow/step: :policy requires an enclosing workflow/run", + )); + } // Outside a run: transparent — just call the thunk (still cooperatively, so an // async op inside it works), with no journaling teardown. return Ok(ThunkPlan::Run { @@ -496,6 +650,10 @@ fn step_plan( teardown: None, }); }; + let step_policy = compile_policy(&args[0])?; + let workspace_root = std::env::current_dir() + .map_err(|error| SemaError::eval(format!("workflow/step: current directory: {error}")))?; + let policy_scope = open_compiled_policy(step_policy, &ctx, &workspace_root); // Resume short-circuit FIRST (before the budget latch): a memoized leaf replays for // FREE. This MUST precede the budget check: a replay makes no provider call, so a // tripped cap must not refuse it. The key is computed on EVERY leaf so its occurrence @@ -513,6 +671,7 @@ fn step_plan( &opt_str(&args[0], "__schema-repr"), &label, &ctx.cur_phase_label(), + &sema_llm::builtins::effective_policy_fingerprint(), ); if ctx.resuming() { if let Some(v) = ctx.memo_lookup(&content_key) { @@ -525,6 +684,7 @@ fn step_plan( } // Unique per-invocation id (the dashboard correlates started→result→budget by it). let agent_id = ctx.next_agent_id(&label); + let attribution_scope = sema_llm::builtins::open_policy_attribution(agent_id.clone()); ctx.emit(WorkflowEvent::AgentStarted { seq: ctx.next_seq(), ts: ctx.ts(), @@ -550,6 +710,8 @@ fn step_plan( content_key, start, usage_scope, + _policy_scope: policy_scope, + _attribution_scope: attribution_scope, }), }) } @@ -621,16 +783,9 @@ fn finish_checkpoint( Ok(NativeOutcome::Return(value)) } -/// Post-thunk teardown state for `workflow/run`. Holds the scope guard (whose Drop -/// removes the exact scope token, LAST — after `run.ended` + `result.json`) and, until -/// closed exactly once, the resolver + open MCP handles (the handles are `Value`s — -/// traced). struct RunTeardown { - // A pure RAII drop guard: never read by name (a type with a manual `Drop` cannot be - // destructured), it exists solely so its own `Drop` removes the exact scope token - // whenever the `RunTeardown` is dropped — on `finish_run`, or via the backstop. - #[allow(dead_code)] - guard: context::WorkflowGuard, + _guard: context::WorkflowGuard, + _policy_scope: Option, mcp: Option, } @@ -866,10 +1021,7 @@ impl CancelHook for FlushCancelHook { } } -/// Pre-thunk work for `workflow/run`: open the run scope, journal `run.started`, resolve -/// any declared `:mcp` servers (a pre-body gate that can end the run before the body ever -/// runs), and hand back the body thunk plus the teardown state. Mirrors the original -/// inline builtin; the post-body work moved to `finish_run`. +/// Open the run scope, journal `run.started`, and resolve declared MCP servers. fn run_plan( task_context: Option<&TaskContextHandle>, args: &[Value], @@ -886,6 +1038,9 @@ fn run_plan( let doc = args[1].as_str().unwrap_or("").to_string(); let meta = args[2].clone(); let thunk = args[3].clone(); + let policy = compile_policy(&meta)?; + let workspace_root = std::env::current_dir() + .map_err(|error| SemaError::eval(format!("workflow/run: current directory: {error}")))?; // Open the run scope: sets up the journal sink under ./.sema/runs//, installs // the thread-local WorkflowCtx, and returns a panic-safe Drop guard that reaps the @@ -909,10 +1064,6 @@ fn run_plan( }); } - // ── Implicit :mcp auth-resolution step, before the body thunk ───────── - // A workflow with no :mcp meta key parses to an empty Vec here (O(1) on the absent - // key), so every branch below is skipped and the body runs exactly as it did before - // this feature — byte-identical for the no-:mcp case. let decls = match workflow_mcp::declared_mcp(&meta) { Ok(d) => d, Err(e) => { @@ -930,12 +1081,17 @@ fn run_plan( } }; - // A workflow with no `:mcp` runs the body straight away — byte-identical to the - // pre-feature path. if decls.is_empty() { + let ctx = context::current_for(task_context) + .ok_or_else(|| SemaError::eval("workflow/run: scope not established"))?; + let policy_scope = open_compiled_policy(policy, &ctx, &workspace_root); return Ok(ThunkPlan::Run { thunk, - teardown: RunTeardown { guard, mcp: None }, + teardown: RunTeardown { + _guard: guard, + _policy_scope: policy_scope, + mcp: None, + }, }); } @@ -974,13 +1130,23 @@ fn run_plan( guard, thunk, resolver, + policy, + workspace_root, }), })); } // Host arm (outside a runtime quantum): `io_block_on` is legal — resolve inline. let resolutions = resolver.resolve(&decls, &name, &run_id); - match apply_resolutions(task_context, guard, thunk, resolver, resolutions)? { + match apply_resolutions( + task_context, + guard, + thunk, + resolver, + resolutions, + policy, + workspace_root, + )? { ResolveGate::Exit { envelope, ack } => Ok(terminal_plan(task_context, envelope, ack)), ResolveGate::Proceed { thunk, teardown } => Ok(ThunkPlan::Run { thunk, teardown }), } @@ -1006,6 +1172,8 @@ fn apply_resolutions( thunk: Value, resolver: Rc, resolutions: Vec, + policy: Option>, + workspace_root: PathBuf, ) -> Result { let ctx = context::current_for(task_context) .ok_or_else(|| SemaError::eval("workflow/run: scope not established"))?; @@ -1101,10 +1269,12 @@ fn apply_resolutions( // Every declared server connected: publish handles for workflow/mcp-handle, and // remember (resolver, handles) so `finish_run` closes them EXACTLY once. ctx.set_mcp_handles(connected); + let policy_scope = open_compiled_policy(policy, &ctx, &workspace_root); Ok(ResolveGate::Proceed { thunk, teardown: RunTeardown { - guard, + _guard: guard, + _policy_scope: policy_scope, mcp: Some(McpClose { resolver, handles: connected_handles, @@ -1137,6 +1307,8 @@ struct ResolveContinuation { guard: context::WorkflowGuard, thunk: Value, resolver: Rc, + policy: Option>, + workspace_root: PathBuf, } impl Trace for ResolveContinuation { @@ -1157,11 +1329,21 @@ impl NativeContinuation for ResolveContinuation { guard, thunk, resolver, + policy, + workspace_root, } = *self; match input { ResumeInput::Returned(value) => { let resolutions = workflow_mcp::decode_resolutions(&value); - match apply_resolutions(Some(&task_context), guard, thunk, resolver, resolutions)? { + match apply_resolutions( + Some(&task_context), + guard, + thunk, + resolver, + resolutions, + policy, + workspace_root, + )? { ResolveGate::Exit { envelope, ack } => Ok(NativeOutcome::Suspend( build_flush_ack_suspend(envelope, ack), )), @@ -1275,6 +1457,14 @@ pub fn register(env: &sema_core::Env) { }, ); + register_thunk_fn( + env, + "workflow/policy-without", + policy_bypass_plan, + finish_policy_bypass, + |_teardown, _sink| {}, + ); + // (workflow/tool-call tool-name [args]) — journal a tool call by the current // agent (the dashboard renders these as tool twigs in the agent's drill-in). // No-op (returns nil) outside a workflow/step. `args` is an opaque/gated diff --git a/crates/sema-stdlib/src/workflow_check.rs b/crates/sema-stdlib/src/workflow_check.rs index f5bc2057..44193654 100644 --- a/crates/sema-stdlib/src/workflow_check.rs +++ b/crates/sema-stdlib/src/workflow_check.rs @@ -5,7 +5,7 @@ //! it is instant, side-effect-free, and safe to run on untrusted source. It exists to give //! a workflow author (often a coding agent) a fast feedback loop that catches the traps the //! runtime only surfaces at eval time — chiefly the `(phase "x" body…)` arity trap, since -//! `phase` is a one-argument marker. +//! `phase` is a one-argument marker, plus malformed literal workflow policies. //! //! Design (kept deliberately simple): one recursive visitor carries an `in_workflow` flag. //! Marker checks (`phase`/`checkpoint`/`step`/`parallel`/`pipeline`) fire ONLY inside a @@ -108,7 +108,7 @@ pub fn check_source(src: &str) -> Vec { diags.push(Diag::error(span, "E-PARSE", message)); } for form in &forms { - find_workflows(form, &spans, &mut diags); + find_workflows_and_policies(form, &spans, &mut diags); } diags } @@ -167,20 +167,55 @@ fn permission_spec_string(key: &str, value: &Value) -> Result { .ok_or_else(|| format!("defworkflow {key} must be a sandbox string")) } -/// Walk the top-level forms looking for `(defworkflow …)` (which may be nested inside a -/// `(do …)` or similar), and check each one. Non-workflow code is left untouched. -fn find_workflows(form: &Value, spans: &SpanMap, out: &mut Vec) { +/// Walk executable forms looking for `defworkflow`/`defpolicy` declarations (which may +/// be nested inside a `(do …)` or similar). Quoted data is left untouched. +fn find_workflows_and_policies(form: &Value, spans: &SpanMap, out: &mut Vec) { + if head_symbol(form).is_some_and(|(head, _)| head == "quote" || head == "quasiquote") { + return; + } if let Some(items) = list_head(form, "defworkflow") { check_workflow(&items, form, spans, out); return; } + if let Some(items) = list_head(form, "defpolicy") { + let span = span_of(form, spans); + if items.len() != 3 || items[1].as_symbol().is_none() { + out.push( + Diag::error( + span, + "E-POLICY-SHAPE", + "defpolicy needs a bare name and one literal policy map", + ) + .with_hint("(defpolicy safe {:models {...} :tools {...}})"), + ); + } else if let Some(policy) = items[2].as_map_ref() { + check_literal_policy(&Value::map(policy.clone()), span, out); + } else { + out.push(Diag::error( + span, + "E-POLICY-SHAPE", + "defpolicy rules must be a literal map", + )); + } + return; + } if let Some(seq) = form.as_seq() { for sub in seq { - find_workflows(sub, spans, out); + find_workflows_and_policies(sub, spans, out); } } } +fn check_literal_policy(policy: &Value, span: Option, out: &mut Vec) { + if let Err(error) = sema_policy::CompiledPolicy::compile(policy) { + out.push(Diag::error( + span, + "E-POLICY", + format!("invalid policy: {error}"), + )); + } +} + /// Check one `(defworkflow name doc meta . body)` form. fn check_workflow(items: &[Value], form: &Value, spans: &SpanMap, out: &mut Vec) { let wf_span = span_of(form, spans); @@ -293,6 +328,12 @@ fn check_workflow(items: &[Value], form: &Value, spans: &SpanMap, out: &mut Vec< // tolerance as (b)/(c) above; a computed :mcp value is left to the runtime). if let Some(meta) = &meta { check_mcp_decls(meta, wf_span, out); + if let Some(policy) = meta + .get(&Value::keyword("policy")) + .filter(|value| value.as_map_ref().is_some()) + { + check_literal_policy(policy, wf_span, out); + } } // Marker arity/opts checks across the whole body (including nested forms). @@ -401,6 +442,9 @@ fn check_mcp_decls(meta: &BTreeMap, span: Option, out: &mut /// Recursively check marker arities/opts. Only reached from within a workflow body. fn walk_markers(form: &Value, spans: &SpanMap, out: &mut Vec) { if let Some((head, items)) = head_symbol(form) { + if head == "quote" || head == "quasiquote" { + return; + } let span = span_of(form, spans); match head.as_str() { // phase is a ONE-arg marker — the #1 trap. (phase "x" body) is an arity error. @@ -465,6 +509,12 @@ fn walk_markers(form: &Value, spans: &SpanMap, out: &mut Vec) { )); } } + if let Some(policy) = opts + .get(&Value::keyword("policy")) + .filter(|value| value.as_map_ref().is_some()) + { + check_literal_policy(policy, span, out); + } // :agent runs a configured defagent and owns its own tools/model; the // step must not also declare inline :tools/:model (they'd be ignored — // the routing takes the :agent branch). Warn so the author picks one. @@ -487,6 +537,24 @@ fn walk_markers(form: &Value, spans: &SpanMap, out: &mut Vec) { } } } + "policy/without" => { + if items.len() < 3 { + out.push(Diag::error( + span, + "E-POLICY-BYPASS", + "policy/without needs a reason string and at least one body form", + )); + } else if items[1] + .as_str() + .is_none_or(|reason| reason.trim().is_empty() || reason.chars().count() > 256) + { + out.push(Diag::error( + span, + "E-POLICY-BYPASS", + "policy/without reason must be a non-empty string of at most 256 characters", + )); + } + } // parallel/pipeline are structural — at least one argument beyond the head. "parallel" | "pipeline" if items.len() < 2 => { out.push(Diag::warn( @@ -790,6 +858,81 @@ mod tests { assert!(c.contains(&"W-STEP-AGENT-MODEL"), "got {c:?}"); } + #[test] + fn valid_policy_declarations_and_inline_policies_are_checked() { + let src = r#" + (defpolicy safe + {:models {:default :deny + :allow ["fake/fake-model"]} + :tools {:default :deny + :allow {"read-file" {:paths ["src/**"]}}}}) + (defworkflow d "d" + {:policy {:models {:default :deny :allow ["fake/*"]}}} + (phase "P") + (step "go" + {:policy {:tools {:default :deny + :allow {"read-file" {:paths ["src/**"]}}}}}) + {:status :ok}) + "#; + let c = codes(src); + assert!( + !c.iter().any(|code| code.starts_with("E-POLICY")), + "got {c:?}" + ); + } + + #[test] + fn malformed_policy_declarations_and_rules_error() { + let bad_shape = codes("(defpolicy \"safe\" [])"); + assert!(bad_shape.contains(&"E-POLICY-SHAPE"), "got {bad_shape:?}"); + + let bad_rule = codes( + r#"(defpolicy bad + {:models {:allow ["*/model"]}}) + (defworkflow d "d" {} {:status :ok})"#, + ); + assert!(bad_rule.contains(&"E-POLICY"), "got {bad_rule:?}"); + } + + #[test] + fn quoted_policy_forms_are_not_checked_as_declarations_or_bypasses() { + let c = codes( + r#" + '(defpolicy "not-a-name" {:models {:allow ["*/bad"]}}) + (defworkflow d "d" {} + '(policy/without "") + {:status :ok}) + "#, + ); + assert!( + !c.iter().any(|code| code.starts_with("E-POLICY")), + "quoted data is not executable syntax: {c:?}" + ); + } + + #[test] + fn policy_without_requires_a_bounded_literal_reason_and_body() { + let missing_body = codes( + r#"(defworkflow d "d" {} + (policy/without "maintenance") + {:status :ok})"#, + ); + assert!( + missing_body.contains(&"E-POLICY-BYPASS"), + "got {missing_body:?}" + ); + + let computed_reason = codes( + r#"(defworkflow d "d" {} + (policy/without reason (step "go")) + {:status :ok})"#, + ); + assert!( + computed_reason.contains(&"E-POLICY-BYPASS"), + "got {computed_reason:?}" + ); + } + #[test] fn empty_fanout_warns() { let c = codes(r#"(defworkflow d "d" {} (phase "P") (pipeline) {:status :ok})"#); diff --git a/crates/sema-vm/src/vm.rs b/crates/sema-vm/src/vm.rs index f8058808..60852850 100644 --- a/crates/sema-vm/src/vm.rs +++ b/crates/sema-vm/src/vm.rs @@ -5859,6 +5859,20 @@ fn error_to_value(err: &SemaError) -> Value { map.insert(Value::keyword("function"), Value::string(function)); map.insert(Value::keyword("path"), Value::string(path)); } + SemaError::PolicyDenied { + boundary, + subject, + rule, + } => { + map.insert(Value::keyword("type"), Value::keyword("policy-denied")); + map.insert( + Value::keyword("message"), + Value::string(&format!("Policy denied {boundary} '{subject}' ({rule})")), + ); + map.insert(Value::keyword("boundary"), Value::string(boundary)); + map.insert(Value::keyword("subject"), Value::string(subject)); + map.insert(Value::keyword("rule"), Value::string(rule)); + } SemaError::WithTrace { .. } | SemaError::WithContext { .. } => { unreachable!("inner() already unwraps these") } diff --git a/crates/sema-workflow/src/context.rs b/crates/sema-workflow/src/context.rs index a02cc0f7..4b66f147 100644 --- a/crates/sema-workflow/src/context.rs +++ b/crates/sema-workflow/src/context.rs @@ -460,14 +460,15 @@ impl WorkflowCtx { } /// Content-key for an agent leaf: a stable hash over (kind, code-version, args, - /// phase, name, prompt, schema-repr) plus an occurrence ordinal. Length-prefixed - /// so `("a","bc")` and `("ab","c")` never collide. + /// phase, name, prompt, schema-repr, effective-policy) plus an occurrence ordinal. + /// Length-prefixed so `("a","bc")` and `("ab","c")` never collide. pub fn agent_content_key( &self, prompt: &str, schema_repr: &str, name: &str, phase: &str, + policy_fingerprint: &str, ) -> String { let cv = self.code_version.borrow().clone(); let base = hash_fields(&[ @@ -478,6 +479,7 @@ impl WorkflowCtx { name, prompt, schema_repr, + policy_fingerprint, ]); format!("{base}_{}", self.next_occurrence(&base)) } @@ -1210,12 +1212,12 @@ mod tests { let ctx = WorkflowCtx::new("wf_t".into(), Journal::null(), BTreeMap::new()); ctx.set_code_version("v1".into()); // First occurrence of each distinct input is stable; differing inputs differ. - let k_a = ctx.agent_content_key("audit a.php", "[:list :string]", "auditor", "Audit"); - let k_b = ctx.agent_content_key("audit b.php", "[:list :string]", "auditor", "Audit"); + let k_a = ctx.agent_content_key("audit a.php", "[:list :string]", "auditor", "Audit", ""); + let k_b = ctx.agent_content_key("audit b.php", "[:list :string]", "auditor", "Audit", ""); assert_ne!(k_a, k_b, "different prompts ⇒ different keys"); // Length-prefixing: ('a','bc') must not collide with ('ab','c'). - let k1 = ctx.agent_content_key("a", "bc", "n", "p"); - let k2 = ctx.agent_content_key("ab", "c", "n", "p"); + let k1 = ctx.agent_content_key("a", "bc", "n", "p", ""); + let k2 = ctx.agent_content_key("ab", "c", "n", "p", ""); assert_ne!( k1, k2, "length-prefixed fields can't collide via concatenation" @@ -1236,8 +1238,8 @@ mod tests { let ctx2 = WorkflowCtx::new("b".into(), Journal::null(), BTreeMap::new()); ctx2.set_code_version("v2".into()); assert_ne!( - ctx1.agent_content_key("p", "s", "n", "ph"), - ctx2.agent_content_key("p", "s", "n", "ph"), + ctx1.agent_content_key("p", "s", "n", "ph", ""), + ctx2.agent_content_key("p", "s", "n", "ph", ""), "a changed code-version produces different content-keys (auto-invalidation)" ); } diff --git a/crates/sema-workflow/src/event.rs b/crates/sema-workflow/src/event.rs index e4778553..da25a791 100644 --- a/crates/sema-workflow/src/event.rs +++ b/crates/sema-workflow/src/event.rs @@ -14,8 +14,9 @@ //! Field ordering convention: `seq` then `ts` lead every variant (so a human or //! `jq` scan sees ordering+time first), followed by the variant-specific payload. //! -//! This vocabulary is FROZEN. Add fields to existing variants (append-only, all -//! `Option`/skippable to keep old goldens valid) rather than inventing new variants. +//! Existing variants are FROZEN. Additive variants are allowed. Fields added to an +//! existing variant must be append-only and optional/skippable so old goldens remain +//! valid. use serde::Serialize; @@ -232,6 +233,66 @@ pub enum WorkflowEvent { /// material. reason: String, }, + + /// A policy layer allowed one protected model or tool boundary. + #[serde(rename = "policy.checked")] + PolicyChecked { + seq: u64, + ts: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + phase_seq: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + agent_id: Option, + policy: String, + policy_digest: String, + boundary: String, + subject: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + subject_digest: Option, + rule: String, + source: String, + }, + + /// A policy layer denied one protected model or tool boundary. + #[serde(rename = "policy.violation")] + PolicyViolation { + seq: u64, + ts: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + phase_seq: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + agent_id: Option, + policy: String, + policy_digest: String, + boundary: String, + subject: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + subject_digest: Option, + rule: String, + action: String, + reason: String, + source: String, + }, + + /// A trusted lexical `policy/without` scope bypassed the effective policy stack. + #[serde(rename = "policy.bypassed")] + PolicyBypassed { + seq: u64, + ts: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + phase_seq: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + agent_id: Option, + policy: String, + policy_digest: String, + boundary: String, + subject: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + subject_digest: Option, + rule: String, + reason: String, + source: String, + }, } #[cfg(test)] @@ -406,4 +467,50 @@ mod tests { r#"{"event":"auth.failed","seq":7,"ts":"0","server":"asana","reason":"consent_denied"}"# ); } + + #[test] + fn policy_events_are_additive_and_keep_tool_arguments_opaque() { + let checked = WorkflowEvent::PolicyChecked { + seq: 8, + ts: "0".into(), + phase_seq: Some(2), + agent_id: Some("coder_1".into()), + policy: "safe".into(), + policy_digest: "policy-sha".into(), + boundary: "tool".into(), + subject: "read-file".into(), + subject_digest: Some("args-sha".into()), + rule: "tools.read-file.allow".into(), + source: "live".into(), + }; + assert_eq!( + serde_json::to_string(&checked).unwrap(), + r#"{"event":"policy.checked","seq":8,"ts":"0","phase_seq":2,"agent_id":"coder_1","policy":"safe","policy_digest":"policy-sha","boundary":"tool","subject":"read-file","subject_digest":"args-sha","rule":"tools.read-file.allow","source":"live"}"# + ); + + let violation = WorkflowEvent::PolicyViolation { + seq: 9, + ts: "0".into(), + phase_seq: None, + agent_id: None, + policy: "safe".into(), + policy_digest: "policy-sha".into(), + boundary: "model".into(), + subject: "openai/gpt-5".into(), + subject_digest: None, + rule: "models.default-deny".into(), + action: "fail".into(), + reason: "not allowlisted".into(), + source: "cache".into(), + }; + let line = serde_json::to_string(&violation).unwrap(); + assert_eq!( + line, + r#"{"event":"policy.violation","seq":9,"ts":"0","policy":"safe","policy_digest":"policy-sha","boundary":"model","subject":"openai/gpt-5","rule":"models.default-deny","action":"fail","reason":"not allowlisted","source":"cache"}"# + ); + assert!( + !line.contains("args_json"), + "policy events must never expose raw tool arguments" + ); + } } diff --git a/crates/sema/src/workflow_view/index.html b/crates/sema/src/workflow_view/index.html index eff3f9d8..dffb2f45 100644 --- a/crates/sema/src/workflow_view/index.html +++ b/crates/sema/src/workflow_view/index.html @@ -333,8 +333,10 @@ item_count/, no per-agent usage inside agent.result; budget events carry an OPTIONAL agent_id (the only way per-agent tokens become attributable). - Frozen vocab (scoping §3.5): run.started, phase.started, phase.ended, - agent.started, agent.result, agent.tool_call, checkpoint, budget, run.ended. + Existing event shapes are frozen; additive kinds are supported. Core vocab: + run.started, phase.started, phase.ended, agent.started, agent.result, + agent.tool_call, checkpoint, budget, policy.checked, policy.violation, + policy.bypassed, run.ended. ========================================================================= */ // Live data — fetched from the viewer server in load(); see init() at the bottom. let EVENTS = []; @@ -713,6 +715,9 @@ case "agent.tool_call": return `${G.twig}`; case "checkpoint": return `${G.cp}`; case "budget": return `${G.bud}`; + case "policy.checked": return `${G.ok}`; + case "policy.violation": return `${G.fail}`; + case "policy.bypassed": return `${G.skip}`; default: return `${G.bud}`; } } @@ -727,6 +732,9 @@ case "agent.tool_call": return `${esc(e.agent_id)} ${esc(e.tool_name)} args ${e.args_json==="gated"?"(gated)":esc(e.args_json)}`; case "checkpoint": return `${esc(e.key)} content_key ${esc(e.content_key)} digest ${esc(e.value_digest)}`; case "budget": return `${e.agent_id?esc(e.agent_id)+" ":""}in ${e.input_tokens} out ${e.output_tokens} cost ${e.cost_usd==null?"—":"$"+e.cost_usd.toFixed(4)}`; + case "policy.checked": return `${esc(e.policy)} allowed ${esc(e.boundary)} ${esc(e.subject)} · ${esc(e.rule)} · ${esc(e.source)}`; + case "policy.violation": return `${esc(e.policy)} denied ${esc(e.boundary)} ${esc(e.subject)} · ${esc(e.action)} · ${esc(e.reason)}`; + case "policy.bypassed": return `${esc(e.policy)} bypassed ${esc(e.boundary)} ${esc(e.subject)} · ${esc(e.reason)}`; default: return ""; } } diff --git a/crates/sema/src/workflow_view/ingest.rs b/crates/sema/src/workflow_view/ingest.rs index 401112d0..e2234e66 100644 --- a/crates/sema/src/workflow_view/ingest.rs +++ b/crates/sema/src/workflow_view/ingest.rs @@ -82,6 +82,13 @@ pub fn init_schema(conn: &Connection) -> rusqlite::Result<()> { input_tokens INTEGER, output_tokens INTEGER, cost_usd REAL, -- nullable! PRIMARY KEY (run_id, seg, seq) ); + CREATE TABLE IF NOT EXISTS policy_events ( + run_id TEXT, seg INTEGER, seq INTEGER, event TEXT, phase_seq INTEGER, + agent_id TEXT, policy TEXT, policy_digest TEXT, boundary TEXT, + subject TEXT, subject_digest TEXT, rule TEXT, action TEXT, reason TEXT, + source TEXT, + PRIMARY KEY (run_id, seg, seq) + ); -- One cursor per journal FILE (key = run_id for the primary, run_id::resume-n -- for a segment), so each file resumes from its own byte offset. CREATE TABLE IF NOT EXISTS ingest_cursor ( @@ -194,6 +201,7 @@ fn wipe_run(conn: &Connection, run_id: &str) -> rusqlite::Result<()> { "tool_calls", "checkpoints", "usage", + "policy_events", "ingest_cursor", ] { conn.execute(&format!("DELETE FROM {t} WHERE run_id=?1"), params![run_id])?; @@ -334,6 +342,31 @@ fn project_event( ], )?; } + event @ ("policy.checked" | "policy.violation" | "policy.bypassed") => { + conn.execute( + "INSERT OR IGNORE INTO policy_events( + run_id,seg,seq,event,phase_seq,agent_id,policy,policy_digest,boundary, + subject,subject_digest,rule,action,reason,source + ) VALUES(?1,?2,?3,?4,?5,?6,?7,?8,?9,?10,?11,?12,?13,?14,?15)", + params![ + run_id, + seg, + seq, + event, + i(e, "phase_seq"), + s(e, "agent_id"), + s(e, "policy"), + s(e, "policy_digest"), + s(e, "boundary"), + s(e, "subject"), + s(e, "subject_digest"), + s(e, "rule"), + s(e, "action"), + s(e, "reason"), + s(e, "source"), + ], + )?; + } _ => {} } Ok(()) @@ -554,4 +587,51 @@ mod tests { assert_eq!(first, third, "re-ingest must not change row counts"); } + + #[test] + fn ingests_policy_events_without_requiring_raw_arguments() { + let mut dir = std::env::temp_dir(); + dir.push(format!("sema-wf-policy-ingest-{}", std::process::id())); + let run = dir.join("policy-run"); + std::fs::create_dir_all(&run).unwrap(); + std::fs::write( + run.join("events.jsonl"), + concat!( + r#"{"event":"run.started","seq":0,"ts":"0","workflow":"wf","run_id":"embedded"}"#, + "\n", + r#"{"event":"policy.checked","seq":1,"ts":"0","policy":"safe","policy_digest":"p","boundary":"tool","subject":"read-file","subject_digest":"args-sha","rule":"tools.read-file.allow","source":"request"}"#, + "\n", + r#"{"event":"policy.violation","seq":2,"ts":"0","policy":"safe","policy_digest":"p","boundary":"model","subject":"other/model","rule":"models.default-deny","action":"fail","reason":"not allowlisted","source":"cache"}"#, + "\n", + r#"{"event":"policy.bypassed","seq":3,"ts":"0","policy":"effective-policy","policy_digest":"p","boundary":"tool","subject":"legacy-tool","subject_digest":"legacy-sha","rule":"policy.without","reason":"migration","source":"request"}"#, + "\n", + ), + ) + .unwrap(); + + let conn = Connection::open_in_memory().unwrap(); + init_schema(&conn).unwrap(); + sync_run(&conn, &dir, "policy-run").unwrap(); + + assert_eq!(count(&conn, "policy_events"), 3); + let checked: (String, String, String, Option) = conn + .query_row( + "SELECT event,subject,rule,subject_digest + FROM policy_events WHERE seq=1", + [], + |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?)), + ) + .unwrap(); + assert_eq!( + checked, + ( + "policy.checked".into(), + "read-file".into(), + "tools.read-file.allow".into(), + Some("args-sha".into()) + ) + ); + + let _ = std::fs::remove_dir_all(&dir); + } } From 8a59e4803094fe02c798e3de85d69d150fe026b7 Mon Sep 17 00:00:00 2001 From: Helge Sverre Date: Fri, 31 Jul 2026 07:56:01 +0200 Subject: [PATCH 03/11] document and test workflow policies --- crates/sema-docs/builtin_docs.generated.json | 49 +- .../entries/stdlib/workflow/defpolicy.md | 33 + .../entries/stdlib/workflow/defworkflow.md | 4 +- .../entries/stdlib/workflow/policy-without.md | 21 + .../sema-docs/entries/stdlib/workflow/step.md | 6 +- .../entries/stdlib/workflow/workflow-check.md | 6 +- .../workflow/workflow-policy-without.md | 24 + .../entries/stdlib/workflow/workflow-run.md | 4 +- .../sema/tests/suites/workflow_policy_test.rs | 596 ++++++++++++++++++ crates/sema/tests/workflow_suite.rs | 2 + examples/workflows/policy.sema | 60 ++ website/docs/llm/workflows.md | 138 +++- 12 files changed, 919 insertions(+), 24 deletions(-) create mode 100644 crates/sema-docs/entries/stdlib/workflow/defpolicy.md create mode 100644 crates/sema-docs/entries/stdlib/workflow/policy-without.md create mode 100644 crates/sema-docs/entries/stdlib/workflow/workflow-policy-without.md create mode 100644 crates/sema/tests/suites/workflow_policy_test.rs create mode 100644 examples/workflows/policy.sema diff --git a/crates/sema-docs/builtin_docs.generated.json b/crates/sema-docs/builtin_docs.generated.json index ac5aaa84..72afcaf4 100644 --- a/crates/sema-docs/builtin_docs.generated.json +++ b/crates/sema-docs/builtin_docs.generated.json @@ -13847,15 +13847,26 @@ ], "body": "Record or read a keyed step value within a workflow run. `(checkpoint :k v)` stores `v` under key `:k`, emits a `checkpoint` event (with a `content_key` and opaque value digest), and returns `v` — so it threads naturally through a `let` or as a phase's last form. On `--resume`, a memoized checkpoint returns the stored value before evaluating `v`, so expensive or side-effecting write expressions do not rerun. `(checkpoint :k)` reads the previously-stored value back (or `nil` if unset), letting a later phase consume what an earlier one produced. It doubles as the run-scoped state bag. Errors if called outside a `workflow/run`.\n\n`phase` is a one-argument marker, so the `checkpoint` calls follow it as siblings (not\nnested inside it):\n\n```sema\n(phase \"Inventory\")\n(checkpoint :files (list \"a.php\" \"b.php\" \"c.php\")) ; record + return\n\n(phase \"Audit\")\n(count (checkpoint :files)) ; read back => 3\n```\n\nSee also: `workflow/checkpoint`, `workflow/run`, `workflow/phase`." }, + { + "name": "defpolicy", + "module": "workflow", + "section": "Dynamic Workflows", + "summary": "Define a reusable model and tool policy. Model rules match exact `\"provider/model\"` identities or the `\"provider/*\"` wildcard. Tool rules can allow or deny tool names and constrain model-supplied path, URL, and command arguments. A present `:models` or `:tools` section defaults to `:deny`.", + "examples": [ + "(defpolicy repository-auditor\n {:models {:default :deny\n :allow [\"openai/gpt-5\" \"anthropic/*\"]}\n :tools {:default :deny\n :allow\n {\"read-file\" {:paths [\"src/**\" \"Cargo.toml\"]}\n \"run-command\" {:commands [\"cargo test\" \"cargo check\"]}}}})\n\n(defworkflow audit \"Guarded audit\" {:policy repository-auditor}\n (phase \"Audit\")\n (step \"Inspect the repository.\"\n {:tools [read-file run-command]})\n {:status :success})" + ], + "body": "Define a reusable model and tool policy. Model rules match exact\n`\"provider/model\"` identities or the `\"provider/*\"` wildcard. Tool rules can\nallow or deny tool names and constrain model-supplied path, URL, and command\narguments. A present `:models` or `:tools` section defaults to `:deny`.\n\n```sema\n(defpolicy repository-auditor\n {:models {:default :deny\n :allow [\"openai/gpt-5\" \"anthropic/*\"]}\n :tools {:default :deny\n :allow\n {\"read-file\" {:paths [\"src/**\" \"Cargo.toml\"]}\n \"run-command\" {:commands [\"cargo test\" \"cargo check\"]}}}})\n\n(defworkflow audit \"Guarded audit\" {:policy repository-auditor}\n (phase \"Audit\")\n (step \"Inspect the repository.\"\n {:tools [read-file run-command]})\n {:status :success})\n```\n\nAttach a policy with workflow or step `:policy`. Active workflow and step\npolicies compose with logical AND. `:permissions` and the CLI sandbox remain the\nouter capability limit.\n\nSee also: `defworkflow`, `step`, `policy/without`, `workflow/check`.", + "syntax": "(defpolicy name policy-map)" + }, { "name": "defworkflow", "module": "workflow", "section": "Dynamic Workflows", - "summary": "Macro: define and run a sequential, journaled workflow. `(defworkflow name \"doc\" meta body…)` expands to `(workflow/run \"name\" \"doc\" meta (lambda () body…))` — so the form *is* the run: it opens the run directory, journals every event, and returns the `{:status …}` envelope. `meta` is a metadata map (`{:phases … :budget … :permissions … :args …}`) recorded into `metadata.json`; list `:phases` so the dashboard can show them before they start. A `:budget` submap caps spend — `{:tokens N}` (deterministic) and/or `{:usd N}` (best-effort, pricing-table dependent); exceeding a cap latches the run, refuses to launch further `step` leaves, and ends `{:status :failed :reason \"budget exceeded\"}`. A `:permissions` string tightens the CLI sandbox for `sema workflow run` using the same syntax as `--sandbox` (for example `\"no-fs-write,no-network\"`). Valid permission values are `none`, `strict`, `all`, `no-fs-read`, `no-fs-write`, `no-shell`, `no-network`, `no-env-read`, `no-env-write`, `no-process`, `no-llm`, and `no-serial`; capability names also parse without the `no-` prefix. The body is ordinary Sema code — a flat sequence of forms with `phase` **markers** interleaved, ending in a `{:status …}` map. Shared values flow through ordinary `def`; `step` leaves return typed data that `pipeline`/`parallel` fan out. Keeping `defworkflow` a prelude macro leaves the VM untouched.", + "summary": "Macro: define and run a sequential, journaled workflow. `(defworkflow name \"doc\" meta body…)` expands to `(workflow/run \"name\" \"doc\" meta (lambda () body…))` — so the form *is* the run: it opens the run directory, journals every event, and returns the `{:status …}` envelope. `meta` is a metadata map (`{:phases … :budget … :permissions … :policy … :args …}`) recorded into `metadata.json`; list `:phases` so the dashboard can show them before they start. A `:budget` submap caps spend — `{:tokens N}` (deterministic) and/or `{:usd N}` (best-effort, pricing-table dependent); exceeding a cap latches the run, refuses to launch further `step` leaves, and ends `{:status :failed :reason \"budget exceeded\"}`. A `:permissions` string tightens the CLI sandbox for `sema workflow run` using the same syntax as `--sandbox` (for example `\"no-fs-write,no-network\"`). A `:policy` value constrains resolved models and model-requested tools for the full workflow body. Valid permission values are `none`, `strict`, `all`, `no-fs-read`, `no-fs-write`, `no-shell`, `no-network`, `no-env-read`, `no-env-write`, `no-process`, `no-llm`, and `no-serial`; capability names also parse without the `no-` prefix. The body is ordinary Sema code — a flat sequence of forms with `phase` **markers** interleaved, ending in a `{:status …}` map. Shared values flow through ordinary `def`; `step` leaves return typed data that `pipeline`/`parallel` fan out. Keeping `defworkflow` a prelude macro leaves the VM untouched.", "examples": [ "(defworkflow audit-auth\n \"Audit a codebase for missing authorization checks.\"\n {:phases [\"Inventory\" \"Audit\" \"Report\"]\n :permissions \"no-fs-write\"}\n\n (phase \"Inventory\")\n (def files (step \"List auth-relevant files under src/.\" {:schema [:list :string]}))\n\n (phase \"Audit\")\n (def findings\n (pipeline files\n (fn (f) (step (str \"Audit \" f) {:schema finding}))\n (fn (x) (step (str \"Verify \" (:claim x)) {:schema verdict}))))\n\n (phase \"Report\")\n {:status :success :confirmed (filter (fn (x) (:real x)) findings)})" ], - "body": "Macro: define and run a sequential, journaled workflow. `(defworkflow name \"doc\" meta body…)` expands to `(workflow/run \"name\" \"doc\" meta (lambda () body…))` — so the form *is* the run: it opens the run directory, journals every event, and returns the `{:status …}` envelope. `meta` is a metadata map (`{:phases … :budget … :permissions … :args …}`) recorded into `metadata.json`; list `:phases` so the dashboard can show them before they start. A `:budget` submap caps spend — `{:tokens N}` (deterministic) and/or `{:usd N}` (best-effort, pricing-table dependent); exceeding a cap latches the run, refuses to launch further `step` leaves, and ends `{:status :failed :reason \"budget exceeded\"}`. A `:permissions` string tightens the CLI sandbox for `sema workflow run` using the same syntax as `--sandbox` (for example `\"no-fs-write,no-network\"`). Valid permission values are `none`, `strict`, `all`, `no-fs-read`, `no-fs-write`, `no-shell`, `no-network`, `no-env-read`, `no-env-write`, `no-process`, `no-llm`, and `no-serial`; capability names also parse without the `no-` prefix. The body is ordinary Sema code — a flat sequence of forms with `phase` **markers** interleaved, ending in a `{:status …}` map. Shared values flow through ordinary `def`; `step` leaves return typed data that `pipeline`/`parallel` fan out. Keeping `defworkflow` a prelude macro leaves the VM untouched.\n\n```sema\n(defworkflow audit-auth\n \"Audit a codebase for missing authorization checks.\"\n {:phases [\"Inventory\" \"Audit\" \"Report\"]\n :permissions \"no-fs-write\"}\n\n (phase \"Inventory\")\n (def files (step \"List auth-relevant files under src/.\" {:schema [:list :string]}))\n\n (phase \"Audit\")\n (def findings\n (pipeline files\n (fn (f) (step (str \"Audit \" f) {:schema finding}))\n (fn (x) (step (str \"Verify \" (:claim x)) {:schema verdict}))))\n\n (phase \"Report\")\n {:status :success :confirmed (filter (fn (x) (:real x)) findings)})\n```\n\nRun a workflow file with `sema workflow run --args `.\n\nSee also: `workflow/run`, `phase`, `checkpoint`.", + "body": "Macro: define and run a sequential, journaled workflow. `(defworkflow name \"doc\" meta body…)` expands to `(workflow/run \"name\" \"doc\" meta (lambda () body…))` — so the form *is* the run: it opens the run directory, journals every event, and returns the `{:status …}` envelope. `meta` is a metadata map (`{:phases … :budget … :permissions … :policy … :args …}`) recorded into `metadata.json`; list `:phases` so the dashboard can show them before they start. A `:budget` submap caps spend — `{:tokens N}` (deterministic) and/or `{:usd N}` (best-effort, pricing-table dependent); exceeding a cap latches the run, refuses to launch further `step` leaves, and ends `{:status :failed :reason \"budget exceeded\"}`. A `:permissions` string tightens the CLI sandbox for `sema workflow run` using the same syntax as `--sandbox` (for example `\"no-fs-write,no-network\"`). A `:policy` value constrains resolved models and model-requested tools for the full workflow body. Valid permission values are `none`, `strict`, `all`, `no-fs-read`, `no-fs-write`, `no-shell`, `no-network`, `no-env-read`, `no-env-write`, `no-process`, `no-llm`, and `no-serial`; capability names also parse without the `no-` prefix. The body is ordinary Sema code — a flat sequence of forms with `phase` **markers** interleaved, ending in a `{:status …}` map. Shared values flow through ordinary `def`; `step` leaves return typed data that `pipeline`/`parallel` fan out. Keeping `defworkflow` a prelude macro leaves the VM untouched.\n\n```sema\n(defworkflow audit-auth\n \"Audit a codebase for missing authorization checks.\"\n {:phases [\"Inventory\" \"Audit\" \"Report\"]\n :permissions \"no-fs-write\"}\n\n (phase \"Inventory\")\n (def files (step \"List auth-relevant files under src/.\" {:schema [:list :string]}))\n\n (phase \"Audit\")\n (def findings\n (pipeline files\n (fn (f) (step (str \"Audit \" f) {:schema finding}))\n (fn (x) (step (str \"Verify \" (:claim x)) {:schema verdict}))))\n\n (phase \"Report\")\n {:status :success :confirmed (filter (fn (x) (:real x)) findings)})\n```\n\nRun a workflow file with `sema workflow run --args `.\n\nSee also: `workflow/run`, `defpolicy`, `policy/without`, `phase`, `checkpoint`.", "syntax": "(defworkflow name doc meta body ...)" }, { @@ -13869,26 +13880,37 @@ "body": "Macro: a journaled phase **marker** inside a workflow body (Claude Code `workflow.js`\nsemantics). `(phase label)` expands to `(workflow/phase label)`: it closes the\npreviously-open phase and opens `label`. Every `step`/`checkpoint` that follows belongs\nto this phase until the next `(phase …)` marker or the run end. A phase is a journaling\nboundary, not control flow — markers sit between the body's top-level forms rather than\nwrapping them.\n\n```sema\n(phase \"Inventory\")\n(checkpoint :files (list \"a.php\" \"b.php\" \"c.php\"))\n\n(phase \"Audit\")\n(checkpoint :findings (count (checkpoint :files)))\n```\n\nSee also: `defworkflow`, `workflow/phase`, `checkpoint`.", "syntax": "(phase label)" }, + { + "name": "policy/without", + "module": "workflow", + "section": "Dynamic Workflows", + "summary": "Bypass active model and tool policies for a trusted lexical scope. `reason` must be a non-empty literal string of at most 256 characters, and the form must contain at least one body expression. Each protected boundary emits a `policy.bypassed` journal event with the reason.", + "examples": [ + "(policy/without \"read the migration fixture\"\n (step \"Inspect the legacy fixture.\" {:tools [read-file]}))" + ], + "body": "Bypass active model and tool policies for a trusted lexical scope. `reason`\nmust be a non-empty literal string of at most 256 characters, and the form must\ncontain at least one body expression. Each protected boundary emits a\n`policy.bypassed` journal event with the reason.\n\n```sema\n(policy/without \"read the migration fixture\"\n (step \"Inspect the legacy fixture.\" {:tools [read-file]}))\n```\n\nThe bypass is task-local and applies only to its body. It does not bypass\nworkflow `:permissions`, the CLI sandbox, or allowed-path limits.\n\nSee also: `defpolicy`, `defworkflow`, `workflow/check`.", + "syntax": "(policy/without reason body ...)" + }, { "name": "step", "module": "workflow", "section": "Dynamic Workflows", - "summary": "Macro: a journaled **step** — a workflow's atomic orchestration unit (Claude Code `workflow.js` `step(prompt, {…})` semantics). A step is an anonymous, workflow-owned call site; the named, reusable counterpart is an `agent`. Runs `prompt` through the configured provider and returns **typed data** when `opts` carries a `:schema` (validated via `llm/extract`), or the completion text otherwise — so the next stage of a `pipeline` can consume the result directly without re-parsing. `opts` also carries `:name`, the role label shown in the dashboard (default `\"step\"`).", + "summary": "Macro: a journaled **step** — a workflow's atomic orchestration unit (Claude Code `workflow.js` `step(prompt, {…})` semantics). A step is an anonymous, workflow-owned call site; the named, reusable counterpart is an `agent`. Runs `prompt` through the configured provider and returns **typed data** when `opts` carries a `:schema` (validated via `llm/extract`), or the completion text otherwise — so the next stage of a `pipeline` can consume the result directly without re-parsing. `opts` also carries `:name`, the role label shown in the dashboard (default `\"step\"`), and `:policy`, which adds a policy layer for this step. A step policy can tighten an enclosing workflow policy but cannot loosen it.", "examples": [ ";; typed: returns the parsed list of strings\n(step \"List the auth-relevant source files under src/.\"\n {:name \"scout\" :schema [:list :string]})\n\n;; untyped: returns completion text\n(step \"Summarize the changelog in one line.\")\n\n;; run a configured defagent as a step\n(step \"Review file Y\" {:agent code-reviewer :schema verdict})\n\n;; fanned out — one row per item, two stages overlapping across items\n(pipeline files\n (fn (f) (step (str \"Audit \" f) {:name \"auditor\" :schema finding}))\n (fn (x) (step (str \"Verify \" (:claim x)) {:name \"verifier\" :schema verdict})))" ], - "body": "Macro: a journaled **step** — a workflow's atomic orchestration unit (Claude Code\n`workflow.js` `step(prompt, {…})` semantics). A step is an anonymous, workflow-owned call\nsite; the named, reusable counterpart is an `agent`. Runs `prompt` through the configured\nprovider and returns **typed data** when `opts` carries a `:schema` (validated via\n`llm/extract`), or the completion text otherwise — so the next stage of a `pipeline`\ncan consume the result directly without re-parsing. `opts` also carries `:name`, the role\nlabel shown in the dashboard (default `\"step\"`).\n\nThe call is wrapped by `workflow/step`, which emits `agent.started`/`agent.result`\nplus a per-step `budget` event, so each invocation becomes a correlated row under the\ncurrent phase. (The `agent.*` event names are the journal's frozen internal contract and\npredate the step rename.) Outside a `workflow/run` the journaling is transparent — the LLM\ncall still runs.\n\nRouting on `opts` (`:agent` and inline `:tools`/`:model` are mutually exclusive — the agent\nowns those):\n\n- `:agent A` — run the configured `defagent` `A` **as** this step via `agent/run` (its\n own system prompt + tools + model + max-turns), with `prompt` as the user message. The\n agent's genuine tool calls still journal as `agent.tool_call`. `:name` defaults to `A`'s\n own name. With `:schema`, `A`'s text is validated.\n- `:tools [...]` (a list of `deftool` values) — run the real multi-round tool loop and\n journal **each genuine tool call** as an `agent.tool_call` event (a tool twig in the\n drill-in). With no `:schema` it returns the loop's final text; with `:schema` the text is\n validated. Per-step budget for a multi-round tool loop is best-effort (the Budget event\n reflects the final round's usage).\n- `:schema S` — `llm/extract` (typed data).\n- otherwise — `llm/complete` (text).\n\n```sema\n;; typed: returns the parsed list of strings\n(step \"List the auth-relevant source files under src/.\"\n {:name \"scout\" :schema [:list :string]})\n\n;; untyped: returns completion text\n(step \"Summarize the changelog in one line.\")\n\n;; run a configured defagent as a step\n(step \"Review file Y\" {:agent code-reviewer :schema verdict})\n\n;; fanned out — one row per item, two stages overlapping across items\n(pipeline files\n (fn (f) (step (str \"Audit \" f) {:name \"auditor\" :schema finding}))\n (fn (x) (step (str \"Verify \" (:claim x)) {:name \"verifier\" :schema verdict})))\n```\n\nSee also: `agent`, `workflow/step`, `pipeline`, `parallel`, `defworkflow`, `checkpoint`.", + "body": "Macro: a journaled **step** — a workflow's atomic orchestration unit (Claude Code\n`workflow.js` `step(prompt, {…})` semantics). A step is an anonymous, workflow-owned call\nsite; the named, reusable counterpart is an `agent`. Runs `prompt` through the configured\nprovider and returns **typed data** when `opts` carries a `:schema` (validated via\n`llm/extract`), or the completion text otherwise — so the next stage of a `pipeline`\ncan consume the result directly without re-parsing. `opts` also carries `:name`, the role\nlabel shown in the dashboard (default `\"step\"`), and `:policy`, which adds a policy layer\nfor this step. A step policy can tighten an enclosing workflow policy but cannot loosen it.\n\nThe call is wrapped by `workflow/step`, which emits `agent.started`/`agent.result`\nplus a per-step `budget` event, so each invocation becomes a correlated row under the\ncurrent phase. (The `agent.*` event names are the journal's frozen internal contract and\npredate the step rename.) Outside a `workflow/run` the journaling is transparent — the LLM\ncall still runs.\n\nRouting on `opts` (`:agent` and inline `:tools`/`:model` are mutually exclusive — the agent\nowns those):\n\n- `:agent A` — run the configured `defagent` `A` **as** this step via `agent/run` (its\n own system prompt + tools + model + max-turns), with `prompt` as the user message. The\n agent's genuine tool calls still journal as `agent.tool_call`. `:name` defaults to `A`'s\n own name. With `:schema`, `A`'s text is validated.\n- `:tools [...]` (a list of `deftool` values) — run the real multi-round tool loop and\n journal **each genuine tool call** as an `agent.tool_call` event (a tool twig in the\n drill-in). With no `:schema` it returns the loop's final text; with `:schema` the text is\n validated. Per-step budget for a multi-round tool loop is best-effort (the Budget event\n reflects the final round's usage).\n- `:schema S` — `llm/extract` (typed data).\n- `:policy P` — add model and tool restrictions for this step.\n- otherwise — `llm/complete` (text).\n\n```sema\n;; typed: returns the parsed list of strings\n(step \"List the auth-relevant source files under src/.\"\n {:name \"scout\" :schema [:list :string]})\n\n;; untyped: returns completion text\n(step \"Summarize the changelog in one line.\")\n\n;; run a configured defagent as a step\n(step \"Review file Y\" {:agent code-reviewer :schema verdict})\n\n;; fanned out — one row per item, two stages overlapping across items\n(pipeline files\n (fn (f) (step (str \"Audit \" f) {:name \"auditor\" :schema finding}))\n (fn (x) (step (str \"Verify \" (:claim x)) {:name \"verifier\" :schema verdict})))\n```\n\nSee also: `agent`, `workflow/step`, `pipeline`, `parallel`, `defworkflow`, `defpolicy`, `checkpoint`.", "syntax": "(step prompt [opts])" }, { "name": "workflow/check", "module": "workflow", "section": "Dynamic Workflows", - "summary": "Static-analyse a workflow source string (or any value, which is pretty-printed to source) and return diagnostics as a list of maps — **no evaluation, no LLM calls, no I/O**. An empty list means the source is clean.", + "summary": "Static-analyse a workflow source string (or any value, which is pretty-printed to source) and return diagnostics as a list of maps — **no evaluation, no LLM calls, no I/O**. An empty list means the source is clean. The checker validates literal `defpolicy`, workflow `:policy`, step `:policy`, and `policy/without` forms in addition to workflow shape and marker rules.", "examples": [ ";; check a source string\n(workflow/check \"(defworkflow bad \\\"doc\\\" {} (phase))\")\n; => ({:severity :error :code \"E-PHASE-ARITY\" :message \"...\" :line 1 :col 38 :hint \"...\"})\n\n;; check a live form value (pretty-printed to source)\n(define wf '(defworkflow ok \"doc\" {} (phase \"Inventory\") {:status :success}))\n(workflow/check wf) ; => ()\n\n;; gate a self-rewrite loop: only run if clean\n(let ((diags (workflow/check generated-src)))\n (if (null? diags)\n (workflow/run-form (read-many generated-src))\n (println (str \"check failed: \" (count diags) \" issues\"))))" ], - "body": "Static-analyse a workflow source string (or any value, which is pretty-printed to source)\nand return diagnostics as a list of maps — **no evaluation, no LLM calls, no I/O**. An\nempty list means the source is clean.\n\nEach diagnostic map has the keys:\n\n- `:severity` — `:error` or `:warning`.\n- `:code` — a short code string (e.g. `\"E-PHASE-ARITY\"`).\n- `:message` — human-readable description.\n- `:line` — 1-based line number, or `nil` when no span is available.\n- `:col` — 1-based column, or `nil` when no span is available.\n- `:hint` — optional actionable guidance string, or `nil`.\n\n```sema\n;; check a source string\n(workflow/check \"(defworkflow bad \\\"doc\\\" {} (phase))\")\n; => ({:severity :error :code \"E-PHASE-ARITY\" :message \"...\" :line 1 :col 38 :hint \"...\"})\n\n;; check a live form value (pretty-printed to source)\n(define wf '(defworkflow ok \"doc\" {} (phase \"Inventory\") {:status :success}))\n(workflow/check wf) ; => ()\n\n;; gate a self-rewrite loop: only run if clean\n(let ((diags (workflow/check generated-src)))\n (if (null? diags)\n (workflow/run-form (read-many generated-src))\n (println (str \"check failed: \" (count diags) \" issues\"))))\n```\n\nSee also: `workflow/run-form`, `defworkflow`.", + "body": "Static-analyse a workflow source string (or any value, which is pretty-printed to source)\nand return diagnostics as a list of maps — **no evaluation, no LLM calls, no I/O**. An\nempty list means the source is clean. The checker validates literal `defpolicy`,\nworkflow `:policy`, step `:policy`, and `policy/without` forms in addition to workflow\nshape and marker rules.\n\nEach diagnostic map has the keys:\n\n- `:severity` — `:error` or `:warning`.\n- `:code` — a short code string (e.g. `\"E-PHASE-ARITY\"`).\n- `:message` — human-readable description.\n- `:line` — 1-based line number, or `nil` when no span is available.\n- `:col` — 1-based column, or `nil` when no span is available.\n- `:hint` — optional actionable guidance string, or `nil`.\n\n```sema\n;; check a source string\n(workflow/check \"(defworkflow bad \\\"doc\\\" {} (phase))\")\n; => ({:severity :error :code \"E-PHASE-ARITY\" :message \"...\" :line 1 :col 38 :hint \"...\"})\n\n;; check a live form value (pretty-printed to source)\n(define wf '(defworkflow ok \"doc\" {} (phase \"Inventory\") {:status :success}))\n(workflow/check wf) ; => ()\n\n;; gate a self-rewrite loop: only run if clean\n(let ((diags (workflow/check generated-src)))\n (if (null? diags)\n (workflow/run-form (read-many generated-src))\n (println (str \"check failed: \" (count diags) \" issues\"))))\n```\n\nSee also: `workflow/run-form`, `defworkflow`, `defpolicy`, `policy/without`.", "syntax": "(workflow/check src)" }, { @@ -13921,15 +13943,26 @@ ], "body": "Open a journaled phase **marker** inside a workflow body (not a wrapper, not control\nflow). `(workflow/phase label)` closes the previously-open phase — emitting its\n`phase.ended` — then emits `phase.started` for `label`; the checkpoints and steps that\nfollow attribute to this phase until the next `(workflow/phase …)` or the run end (which\n`workflow/run` closes automatically). Returns `nil`. Usually written via the\n`phase` macro.\n\n```sema\n(phase \"Inventory\")\n(checkpoint :files (list \"a.php\" \"b.php\" \"c.php\"))\n\n(phase \"Audit\") ; closes \"Inventory\", opens \"Audit\"\n(checkpoint :findings (count (checkpoint :files)))\n```\n\nSee also: `phase`, `workflow/run`, `checkpoint`." }, + { + "name": "workflow/policy-without", + "module": "workflow", + "section": "Dynamic Workflows", + "summary": "Run `thunk` with active model and tool policies bypassed, and emit a `policy.bypassed` event for each protected boundary. `reason` must be a non-empty string of at most 256 characters. This low-level thunk form requires an active workflow policy.", + "examples": [ + "(policy/without \"read the migration fixture\"\n (step \"Inspect the legacy fixture.\" {:tools [read-file]}))" + ], + "body": "Run `thunk` with active model and tool policies bypassed, and emit a\n`policy.bypassed` event for each protected boundary. `reason` must be a\nnon-empty string of at most 256 characters. This low-level thunk form requires\nan active workflow policy.\n\nUse the `policy/without` macro in application code. It requires a literal\nreason and accepts ordinary body forms:\n\n```sema\n(policy/without \"read the migration fixture\"\n (step \"Inspect the legacy fixture.\" {:tools [read-file]}))\n```\n\nThe bypass does not change workflow `:permissions`, the CLI sandbox, or\nallowed-path limits.\n\nSee also: `policy/without`, `defpolicy`, `workflow/run`.", + "syntax": "(workflow/policy-without reason thunk)" + }, { "name": "workflow/run", "module": "workflow", "section": "Dynamic Workflows", - "summary": "Run a sequential, journaled workflow and return its discriminated-union `{:status …}` result. `(workflow/run name doc meta thunk)` opens a run directory under `./.sema/runs//`, emits a `run.started` event, evaluates `thunk` (the workflow body), then emits `run.ended` and writes `result.json`. `meta` may declare `:phases`, `:budget`, `:permissions`, and `:args`; `:permissions` tightens the CLI sandbox before the run starts. If the body's last value is already a `{:status …}` map it is returned verbatim (its keys land at the top level of `result.json`); otherwise the value is wrapped as `{:status :success :value …}`. An error in the body produces `{:status :failed :error \"…\"}`. Usually written via the `defworkflow` macro rather than called directly.", + "summary": "Run a sequential, journaled workflow and return its discriminated-union `{:status …}` result. `(workflow/run name doc meta thunk)` opens a run directory under `./.sema/runs//`, emits a `run.started` event, evaluates `thunk` (the workflow body), then emits `run.ended` and writes `result.json`. `meta` may declare `:phases`, `:budget`, `:permissions`, `:policy`, and `:args`; `:permissions` tightens the CLI sandbox before the run starts, and `:policy` constrains resolved models and model-requested tools. If the body's last value is already a `{:status …}` map it is returned verbatim (its keys land at the top level of `result.json`); otherwise the value is wrapped as `{:status :success :value …}`. An error in the body produces `{:status :failed :error \"…\"}`. Usually written via the `defworkflow` macro rather than called directly.", "examples": [ "(defworkflow hello \"demo\" {:args {:name :string}}\n (phase \"Inventory\") ; marker — body forms follow as siblings\n (checkpoint :files (list \"a\" \"b\"))\n {:status :success :files (checkpoint :files)})" ], - "body": "Run a sequential, journaled workflow and return its discriminated-union `{:status …}` result. `(workflow/run name doc meta thunk)` opens a run directory under `./.sema/runs//`, emits a `run.started` event, evaluates `thunk` (the workflow body), then emits `run.ended` and writes `result.json`. `meta` may declare `:phases`, `:budget`, `:permissions`, and `:args`; `:permissions` tightens the CLI sandbox before the run starts. If the body's last value is already a `{:status …}` map it is returned verbatim (its keys land at the top level of `result.json`); otherwise the value is wrapped as `{:status :success :value …}`. An error in the body produces `{:status :failed :error \"…\"}`. Usually written via the `defworkflow` macro rather than called directly.\n\n```sema\n(defworkflow hello \"demo\" {:args {:name :string}}\n (phase \"Inventory\") ; marker — body forms follow as siblings\n (checkpoint :files (list \"a\" \"b\"))\n {:status :success :files (checkpoint :files)})\n```\n\nThe run journal (`events.jsonl`) is the system of record; run with `sema workflow run --args `.\n\nSee also: `defworkflow`, `workflow/phase`, `checkpoint`." + "body": "Run a sequential, journaled workflow and return its discriminated-union `{:status …}` result. `(workflow/run name doc meta thunk)` opens a run directory under `./.sema/runs//`, emits a `run.started` event, evaluates `thunk` (the workflow body), then emits `run.ended` and writes `result.json`. `meta` may declare `:phases`, `:budget`, `:permissions`, `:policy`, and `:args`; `:permissions` tightens the CLI sandbox before the run starts, and `:policy` constrains resolved models and model-requested tools. If the body's last value is already a `{:status …}` map it is returned verbatim (its keys land at the top level of `result.json`); otherwise the value is wrapped as `{:status :success :value …}`. An error in the body produces `{:status :failed :error \"…\"}`. Usually written via the `defworkflow` macro rather than called directly.\n\n```sema\n(defworkflow hello \"demo\" {:args {:name :string}}\n (phase \"Inventory\") ; marker — body forms follow as siblings\n (checkpoint :files (list \"a\" \"b\"))\n {:status :success :files (checkpoint :files)})\n```\n\nThe run journal (`events.jsonl`) is the system of record; run with `sema workflow run --args `.\n\nSee also: `defworkflow`, `defpolicy`, `policy/without`, `workflow/phase`, `checkpoint`." }, { "name": "workflow/run-form", diff --git a/crates/sema-docs/entries/stdlib/workflow/defpolicy.md b/crates/sema-docs/entries/stdlib/workflow/defpolicy.md new file mode 100644 index 00000000..98d1334a --- /dev/null +++ b/crates/sema-docs/entries/stdlib/workflow/defpolicy.md @@ -0,0 +1,33 @@ +--- +name: "defpolicy" +module: "workflow" +section: "Dynamic Workflows" +syntax: "(defpolicy name policy-map)" +--- + +Define a reusable model and tool policy. Model rules match exact +`"provider/model"` identities or the `"provider/*"` wildcard. Tool rules can +allow or deny tool names and constrain model-supplied path, URL, and command +arguments. A present `:models` or `:tools` section defaults to `:deny`. + +```sema +(defpolicy repository-auditor + {:models {:default :deny + :allow ["openai/gpt-5" "anthropic/*"]} + :tools {:default :deny + :allow + {"read-file" {:paths ["src/**" "Cargo.toml"]} + "run-command" {:commands ["cargo test" "cargo check"]}}}}) + +(defworkflow audit "Guarded audit" {:policy repository-auditor} + (phase "Audit") + (step "Inspect the repository." + {:tools [read-file run-command]}) + {:status :success}) +``` + +Attach a policy with workflow or step `:policy`. Active workflow and step +policies compose with logical AND. `:permissions` and the CLI sandbox remain the +outer capability limit. + +See also: `defworkflow`, `step`, `policy/without`, `workflow/check`. diff --git a/crates/sema-docs/entries/stdlib/workflow/defworkflow.md b/crates/sema-docs/entries/stdlib/workflow/defworkflow.md index beb082e7..ad042af6 100644 --- a/crates/sema-docs/entries/stdlib/workflow/defworkflow.md +++ b/crates/sema-docs/entries/stdlib/workflow/defworkflow.md @@ -5,7 +5,7 @@ section: "Dynamic Workflows" syntax: "(defworkflow name doc meta body ...)" --- -Macro: define and run a sequential, journaled workflow. `(defworkflow name "doc" meta body…)` expands to `(workflow/run "name" "doc" meta (lambda () body…))` — so the form *is* the run: it opens the run directory, journals every event, and returns the `{:status …}` envelope. `meta` is a metadata map (`{:phases … :budget … :permissions … :args …}`) recorded into `metadata.json`; list `:phases` so the dashboard can show them before they start. A `:budget` submap caps spend — `{:tokens N}` (deterministic) and/or `{:usd N}` (best-effort, pricing-table dependent); exceeding a cap latches the run, refuses to launch further `step` leaves, and ends `{:status :failed :reason "budget exceeded"}`. A `:permissions` string tightens the CLI sandbox for `sema workflow run` using the same syntax as `--sandbox` (for example `"no-fs-write,no-network"`). Valid permission values are `none`, `strict`, `all`, `no-fs-read`, `no-fs-write`, `no-shell`, `no-network`, `no-env-read`, `no-env-write`, `no-process`, `no-llm`, and `no-serial`; capability names also parse without the `no-` prefix. The body is ordinary Sema code — a flat sequence of forms with `phase` **markers** interleaved, ending in a `{:status …}` map. Shared values flow through ordinary `def`; `step` leaves return typed data that `pipeline`/`parallel` fan out. Keeping `defworkflow` a prelude macro leaves the VM untouched. +Macro: define and run a sequential, journaled workflow. `(defworkflow name "doc" meta body…)` expands to `(workflow/run "name" "doc" meta (lambda () body…))` — so the form *is* the run: it opens the run directory, journals every event, and returns the `{:status …}` envelope. `meta` is a metadata map (`{:phases … :budget … :permissions … :policy … :args …}`) recorded into `metadata.json`; list `:phases` so the dashboard can show them before they start. A `:budget` submap caps spend — `{:tokens N}` (deterministic) and/or `{:usd N}` (best-effort, pricing-table dependent); exceeding a cap latches the run, refuses to launch further `step` leaves, and ends `{:status :failed :reason "budget exceeded"}`. A `:permissions` string tightens the CLI sandbox for `sema workflow run` using the same syntax as `--sandbox` (for example `"no-fs-write,no-network"`). A `:policy` value constrains resolved models and model-requested tools for the full workflow body. Valid permission values are `none`, `strict`, `all`, `no-fs-read`, `no-fs-write`, `no-shell`, `no-network`, `no-env-read`, `no-env-write`, `no-process`, `no-llm`, and `no-serial`; capability names also parse without the `no-` prefix. The body is ordinary Sema code — a flat sequence of forms with `phase` **markers** interleaved, ending in a `{:status …}` map. Shared values flow through ordinary `def`; `step` leaves return typed data that `pipeline`/`parallel` fan out. Keeping `defworkflow` a prelude macro leaves the VM untouched. ```sema (defworkflow audit-auth @@ -28,4 +28,4 @@ Macro: define and run a sequential, journaled workflow. `(defworkflow name "doc" Run a workflow file with `sema workflow run --args `. -See also: `workflow/run`, `phase`, `checkpoint`. +See also: `workflow/run`, `defpolicy`, `policy/without`, `phase`, `checkpoint`. diff --git a/crates/sema-docs/entries/stdlib/workflow/policy-without.md b/crates/sema-docs/entries/stdlib/workflow/policy-without.md new file mode 100644 index 00000000..ff3bec51 --- /dev/null +++ b/crates/sema-docs/entries/stdlib/workflow/policy-without.md @@ -0,0 +1,21 @@ +--- +name: "policy/without" +module: "workflow" +section: "Dynamic Workflows" +syntax: "(policy/without reason body ...)" +--- + +Bypass active model and tool policies for a trusted lexical scope. `reason` +must be a non-empty literal string of at most 256 characters, and the form must +contain at least one body expression. Each protected boundary emits a +`policy.bypassed` journal event with the reason. + +```sema +(policy/without "read the migration fixture" + (step "Inspect the legacy fixture." {:tools [read-file]})) +``` + +The bypass is task-local and applies only to its body. It does not bypass +workflow `:permissions`, the CLI sandbox, or allowed-path limits. + +See also: `defpolicy`, `defworkflow`, `workflow/check`. diff --git a/crates/sema-docs/entries/stdlib/workflow/step.md b/crates/sema-docs/entries/stdlib/workflow/step.md index b2892c44..d6e5a4e2 100644 --- a/crates/sema-docs/entries/stdlib/workflow/step.md +++ b/crates/sema-docs/entries/stdlib/workflow/step.md @@ -11,7 +11,8 @@ site; the named, reusable counterpart is an `agent`. Runs `prompt` through the c provider and returns **typed data** when `opts` carries a `:schema` (validated via `llm/extract`), or the completion text otherwise — so the next stage of a `pipeline` can consume the result directly without re-parsing. `opts` also carries `:name`, the role -label shown in the dashboard (default `"step"`). +label shown in the dashboard (default `"step"`), and `:policy`, which adds a policy layer +for this step. A step policy can tighten an enclosing workflow policy but cannot loosen it. The call is wrapped by `workflow/step`, which emits `agent.started`/`agent.result` plus a per-step `budget` event, so each invocation becomes a correlated row under the @@ -32,6 +33,7 @@ owns those): validated. Per-step budget for a multi-round tool loop is best-effort (the Budget event reflects the final round's usage). - `:schema S` — `llm/extract` (typed data). +- `:policy P` — add model and tool restrictions for this step. - otherwise — `llm/complete` (text). ```sema @@ -51,4 +53,4 @@ owns those): (fn (x) (step (str "Verify " (:claim x)) {:name "verifier" :schema verdict}))) ``` -See also: `agent`, `workflow/step`, `pipeline`, `parallel`, `defworkflow`, `checkpoint`. +See also: `agent`, `workflow/step`, `pipeline`, `parallel`, `defworkflow`, `defpolicy`, `checkpoint`. diff --git a/crates/sema-docs/entries/stdlib/workflow/workflow-check.md b/crates/sema-docs/entries/stdlib/workflow/workflow-check.md index 1e581b58..d84aa7bd 100644 --- a/crates/sema-docs/entries/stdlib/workflow/workflow-check.md +++ b/crates/sema-docs/entries/stdlib/workflow/workflow-check.md @@ -7,7 +7,9 @@ syntax: "(workflow/check src)" Static-analyse a workflow source string (or any value, which is pretty-printed to source) and return diagnostics as a list of maps — **no evaluation, no LLM calls, no I/O**. An -empty list means the source is clean. +empty list means the source is clean. The checker validates literal `defpolicy`, +workflow `:policy`, step `:policy`, and `policy/without` forms in addition to workflow +shape and marker rules. Each diagnostic map has the keys: @@ -34,4 +36,4 @@ Each diagnostic map has the keys: (println (str "check failed: " (count diags) " issues")))) ``` -See also: `workflow/run-form`, `defworkflow`. +See also: `workflow/run-form`, `defworkflow`, `defpolicy`, `policy/without`. diff --git a/crates/sema-docs/entries/stdlib/workflow/workflow-policy-without.md b/crates/sema-docs/entries/stdlib/workflow/workflow-policy-without.md new file mode 100644 index 00000000..86933c06 --- /dev/null +++ b/crates/sema-docs/entries/stdlib/workflow/workflow-policy-without.md @@ -0,0 +1,24 @@ +--- +name: "workflow/policy-without" +module: "workflow" +section: "Dynamic Workflows" +syntax: "(workflow/policy-without reason thunk)" +--- + +Run `thunk` with active model and tool policies bypassed, and emit a +`policy.bypassed` event for each protected boundary. `reason` must be a +non-empty string of at most 256 characters. This low-level thunk form requires +an active workflow policy. + +Use the `policy/without` macro in application code. It requires a literal +reason and accepts ordinary body forms: + +```sema +(policy/without "read the migration fixture" + (step "Inspect the legacy fixture." {:tools [read-file]})) +``` + +The bypass does not change workflow `:permissions`, the CLI sandbox, or +allowed-path limits. + +See also: `policy/without`, `defpolicy`, `workflow/run`. diff --git a/crates/sema-docs/entries/stdlib/workflow/workflow-run.md b/crates/sema-docs/entries/stdlib/workflow/workflow-run.md index f2f7aa26..a33a9aee 100644 --- a/crates/sema-docs/entries/stdlib/workflow/workflow-run.md +++ b/crates/sema-docs/entries/stdlib/workflow/workflow-run.md @@ -4,7 +4,7 @@ module: "workflow" section: "Dynamic Workflows" --- -Run a sequential, journaled workflow and return its discriminated-union `{:status …}` result. `(workflow/run name doc meta thunk)` opens a run directory under `./.sema/runs//`, emits a `run.started` event, evaluates `thunk` (the workflow body), then emits `run.ended` and writes `result.json`. `meta` may declare `:phases`, `:budget`, `:permissions`, and `:args`; `:permissions` tightens the CLI sandbox before the run starts. If the body's last value is already a `{:status …}` map it is returned verbatim (its keys land at the top level of `result.json`); otherwise the value is wrapped as `{:status :success :value …}`. An error in the body produces `{:status :failed :error "…"}`. Usually written via the `defworkflow` macro rather than called directly. +Run a sequential, journaled workflow and return its discriminated-union `{:status …}` result. `(workflow/run name doc meta thunk)` opens a run directory under `./.sema/runs//`, emits a `run.started` event, evaluates `thunk` (the workflow body), then emits `run.ended` and writes `result.json`. `meta` may declare `:phases`, `:budget`, `:permissions`, `:policy`, and `:args`; `:permissions` tightens the CLI sandbox before the run starts, and `:policy` constrains resolved models and model-requested tools. If the body's last value is already a `{:status …}` map it is returned verbatim (its keys land at the top level of `result.json`); otherwise the value is wrapped as `{:status :success :value …}`. An error in the body produces `{:status :failed :error "…"}`. Usually written via the `defworkflow` macro rather than called directly. ```sema (defworkflow hello "demo" {:args {:name :string}} @@ -15,4 +15,4 @@ Run a sequential, journaled workflow and return its discriminated-union `{:statu The run journal (`events.jsonl`) is the system of record; run with `sema workflow run --args `. -See also: `defworkflow`, `workflow/phase`, `checkpoint`. +See also: `defworkflow`, `defpolicy`, `policy/without`, `workflow/phase`, `checkpoint`. diff --git a/crates/sema/tests/suites/workflow_policy_test.rs b/crates/sema/tests/suites/workflow_policy_test.rs new file mode 100644 index 00000000..305f3ce4 --- /dev/null +++ b/crates/sema/tests/suites/workflow_policy_test.rs @@ -0,0 +1,596 @@ +//! End-to-end workflow policy tests. +//! +//! These use the real workflow, LLM, agent, tool, journal, and resume paths +//! against a deterministic `FakeProvider`. No network access or API key is +//! required. + +use crate::workflow_common as wc; +use crate::workflow_common::{run_workflow, temp_run_dir, RunOpts}; + +use sema_llm::fake::FakeProvider; +use sema_llm::types::ToolCall; + +fn fake_with_reply(text: &str) -> FakeProvider { + FakeProvider::builder("fake") + .model("fake-model") + .reply(text) + .build() +} + +#[test] +fn workflow_policy_allows_the_resolved_model_and_journals_the_check() { + let src = r#" + (defpolicy safe + {:models {:default :deny :allow ["fake/fake-model"]}}) + (defworkflow guarded "model allowlist" {:policy safe} + (phase "Run") + (def result (step "say hello" {:name "writer"})) + {:status :success :result result}) + "#; + + let out = wc::run_once(src, fake_with_reply("hello"), "wf_policy_model_allow"); + assert_eq!(out.result["status"], "success"); + assert_eq!(out.recorder.call_count(), 1); + + let checks = wc::events_of(&out.events, "policy.checked"); + assert_eq!( + checks.len(), + 1, + "one provider boundary must produce one policy check" + ); + assert!( + checks.iter().any(|event| { + event["policy"] == "safe" + && event["boundary"] == "model" + && event["subject"] == "fake/fake-model" + && event["rule"] == "models.allow" + }), + "expected the resolved provider/model check, got {checks:?}" + ); +} + +#[test] +fn model_skip_still_fails_a_non_fallback_call_before_provider_access() { + let src = r#" + (defpolicy safe + {:models {:default :deny + :allow ["other/*"] + :on-deny :skip}}) + (defworkflow guarded "model deny" {:policy safe} + (phase "Run") + (step "must not run" {:name "writer"}) + {:status :success}) + "#; + + let out = wc::run_once(src, fake_with_reply("unexpected"), "wf_policy_model_deny"); + assert_eq!( + out.recorder.call_count(), + 0, + "a denied model must not reach the provider" + ); + let violations = wc::events_of(&out.events, "policy.violation"); + assert!( + violations.iter().any(|event| { + event["boundary"] == "model" + && event["subject"] == "fake/fake-model" + && event["action"] == "fail" + }), + "expected a model violation, got {violations:?}" + ); + assert_eq!( + wc::events_of(&out.events, "run.ended")[0]["status"], + "failed" + ); +} + +#[test] +fn model_skip_skips_only_denied_fallback_targets() { + let src = r#" + (llm/define-provider :blocked + {:default-model "model" + :complete (lambda (_request) "blocked")}) + (llm/define-provider :allowed + {:default-model "model" + :complete (lambda (_request) "allowed")}) + (defpolicy fallback-safe + {:models {:default :deny + :allow ["allowed/model"] + :on-deny :skip}}) + (defworkflow guarded "fallback skip" {:policy fallback-safe} + (phase "Run") + (def result + (llm/with-fallback [:blocked :allowed] + (lambda () (llm/complete "choose")))) + {:status :success :result result}) + "#; + + let fake = FakeProvider::builder("fake").model("fake-model").build(); + let out = wc::run_once(src, fake, "wf_policy_fallback_skip"); + assert_eq!(out.result["status"], "success"); + assert_eq!(out.result["result"], "allowed"); + assert!( + wc::events_of(&out.events, "policy.violation") + .iter() + .any(|event| { event["subject"] == "blocked/model" && event["action"] == "skip" }), + "the denied fallback should be skipped and audited" + ); + assert!(wc::events_of(&out.events, "policy.checked") + .iter() + .any(|event| event["subject"] == "allowed/model")); +} + +#[test] +fn stream_embed_and_rerank_are_denied_before_provider_or_callback() { + let base = temp_run_dir("policy-model-surfaces"); + let marker = base.join("stream-callback"); + let path = marker + .to_string_lossy() + .replace('\\', "\\\\") + .replace('"', "\\\""); + let src = format!( + r#" + (defpolicy locked {{:models {{:default :deny}}}}) + (defworkflow guarded "all model surfaces" {{:policy locked}} + (phase "Run") + (def embed-result + (try (llm/embed "secret") (catch _ :denied))) + (def rerank-result + (try (llm/rerank "query" (list "document")) + (catch _ :denied))) + (def stream-result + (try + (llm/stream "secret" + (lambda (chunk) (file/write "{path}" chunk))) + (catch _ :denied))) + {{:status :success + :results (list embed-result rerank-result stream-result)}}) + "# + ); + let fake = FakeProvider::builder("fake") + .model("fake-model") + .embed(vec![vec![0.1, 0.2]]) + .rerank(&[(0, 0.9)]) + .stream(&["must", "not", "stream"]) + .build(); + let out = run_workflow( + &src, + fake, + RunOpts::fresh("wf_policy_model_surfaces", &base), + ); + + assert_eq!(out.result["status"], "success"); + assert_eq!(out.recorder.call_count(), 0, "stream must not open"); + assert!(out.recorder.embeds().is_empty(), "embed must not dispatch"); + assert!( + out.recorder.reranks().is_empty(), + "rerank must not dispatch" + ); + assert!( + !marker.exists(), + "stream callbacks must not run for a denied model" + ); + assert!( + wc::events_of(&out.events, "policy.violation").len() >= 3, + "each denied model surface should be audited" + ); + + let _ = std::fs::remove_dir_all(&base); +} + +const BATCH_TOOLS: &str = r#" + (deftool allowed-tool + "Write a marker" + {:path {:type :string}} + (lambda (path) (file/write path "allowed"))) + (deftool blocked-tool + "Write a marker that must never execute" + {:path {:type :string}} + (lambda (path) (file/write path "blocked"))) +"#; + +fn batched_tool_provider(path: &str) -> FakeProvider { + FakeProvider::builder("fake") + .model("fake-model") + .tool_calls(vec![ + ToolCall { + id: "allowed_1".into(), + name: "allowed-tool".into(), + arguments: serde_json::json!({"path": path}), + thought_signature: None, + }, + ToolCall { + id: "blocked_1".into(), + name: "blocked-tool".into(), + arguments: serde_json::json!({"path": path}), + thought_signature: None, + }, + ]) + .reply("finished") + .build() +} + +fn batch_workflow(action: &str) -> String { + format!( + r#" + {BATCH_TOOLS} + (defpolicy safe + {{:models {{:default :deny :allow ["fake/fake-model"]}} + :tools {{:default :deny + :allow {{"allowed-tool" {{}}}} + :deny ["blocked-tool"] + :on-deny :{action}}}}}) + (defworkflow guarded "tool batch" {{:policy safe}} + (phase "Run") + (def result + (step "use both tools" + {{:name "coder" :tools [allowed-tool blocked-tool]}})) + {{:status :success :result result}}) + "# + ) +} + +#[test] +fn hard_tool_denial_preflights_the_batch_and_runs_no_sibling() { + let base = temp_run_dir("policy-tool-fail"); + let marker = base.join("allowed-marker"); + let src = batch_workflow("fail"); + let out = run_workflow( + &src, + batched_tool_provider(marker.to_string_lossy().as_ref()), + RunOpts::fresh("wf_policy_tool_fail", &base), + ); + + assert!( + !marker.exists(), + "hard denial must prevent an allowed sibling handler from running" + ); + assert_eq!( + wc::events_of(&out.events, "agent.tool_call").len(), + 0, + "preflight failure happens before tool callbacks" + ); + let violations = wc::events_of(&out.events, "policy.violation"); + assert!( + violations + .iter() + .any(|event| event["subject"] == "blocked-tool" && event["action"] == "fail"), + "expected blocked-tool violation, got {violations:?}" + ); + + let _ = std::fs::remove_dir_all(&base); +} + +#[test] +fn tool_error_denial_runs_allowed_siblings_without_journaling_denied_call() { + let base = temp_run_dir("policy-tool-error"); + let marker = base.join("allowed-marker"); + let src = batch_workflow("tool-error"); + let out = run_workflow( + &src, + batched_tool_provider(marker.to_string_lossy().as_ref()), + RunOpts::fresh("wf_policy_tool_error", &base), + ); + + assert!( + marker.exists(), + "the allowed sibling should run under :tool-error" + ); + assert_eq!(out.result["status"], "success"); + let tool_calls = wc::events_of(&out.events, "agent.tool_call"); + assert_eq!( + tool_calls.len(), + 1, + "only the allowed call reaches the observer" + ); + assert_eq!(tool_calls[0]["tool_name"], "allowed-tool"); + assert!(wc::events_of(&out.events, "policy.violation") + .iter() + .any(|event| { event["subject"] == "blocked-tool" && event["action"] == "tool-error" })); + + let _ = std::fs::remove_dir_all(&base); +} + +#[test] +fn direct_tool_invoke_is_gated_before_the_handler() { + let base = temp_run_dir("policy-direct-tool"); + let marker = base.join("direct-marker"); + let path = marker + .to_string_lossy() + .replace('\\', "\\\\") + .replace('"', "\\\""); + let src = format!( + r#" + (deftool direct-tool + "Write a marker" + {{:path {{:type :string}}}} + (lambda (path) (file/write path "ran"))) + (defpolicy safe + {{:tools {{:default :deny :on-deny :tool-error}}}}) + (defworkflow guarded "direct tool" {{:policy safe}} + (phase "Run") + (tool/invoke direct-tool {{:path "{path}"}}) + {{:status :success}}) + "# + ); + let fake = FakeProvider::builder("fake").model("fake-model").build(); + let out = run_workflow(&src, fake, RunOpts::fresh("wf_policy_direct_tool", &base)); + + assert!( + !marker.exists(), + "direct tool policy denial must happen before its handler" + ); + assert_eq!( + wc::events_of(&out.events, "run.ended")[0]["status"], + "failed" + ); + assert!(wc::events_of(&out.events, "policy.violation") + .iter() + .any(|event| { + event["subject"] == "direct-tool" + && event["boundary"] == "tool" + && event["action"] == "fail" + })); + + let _ = std::fs::remove_dir_all(&base); +} + +#[test] +fn step_policy_can_tighten_but_not_loosen_the_workflow_policy() { + let src = r#" + (defpolicy workflow-safe + {:models {:default :deny :allow ["fake/*"]}}) + (defworkflow guarded "logical AND" + {:policy workflow-safe} + (phase "Run") + (step "must not run" + {:name "writer" + :policy {:models {:default :deny :allow ["other/*"]}}}) + {:status :success}) + "#; + + let out = wc::run_once(src, fake_with_reply("unexpected"), "wf_policy_step_tighten"); + assert_eq!(out.recorder.call_count(), 0); + assert!( + wc::events_of(&out.events, "policy.checked") + .iter() + .any(|event| event["policy"] == "workflow-safe"), + "the outer layer should allow before the inner layer denies" + ); + assert!( + wc::events_of(&out.events, "policy.violation") + .iter() + .any(|event| event["policy"] == "inline-policy"), + "the step layer should deny the same boundary" + ); +} + +#[test] +fn stricter_layer_action_is_the_effective_journaled_action() { + let src = r#" + (defpolicy outer + {:models {:default :deny :on-deny :skip}}) + (defworkflow guarded "strictest action wins" {:policy outer} + (phase "Run") + (step "must not run" + {:name "writer" + :policy {:models {:default :deny :on-deny :fail}}}) + {:status :success}) + "#; + + let out = wc::run_once(src, fake_with_reply("unexpected"), "wf_policy_strictest"); + assert_eq!(out.recorder.call_count(), 0); + let violations = wc::events_of(&out.events, "policy.violation"); + assert_eq!(violations.len(), 2, "both denying layers are journaled"); + assert!( + violations.iter().all(|event| event["action"] == "fail"), + "the effective hard-fail action should be visible on every violation: {violations:?}" + ); +} + +#[test] +fn lexical_bypass_is_audited_and_does_not_call_the_denied_gate() { + let src = r#" + (defpolicy locked + {:models {:default :deny}}) + (defworkflow guarded "trusted exception" {:policy locked} + (phase "Run") + (def result + (policy/without "legacy migration fixture" + (step "read the fixture" {:name "migrator"}))) + {:status :success :result result}) + "#; + + let out = wc::run_once(src, fake_with_reply("legacy"), "wf_policy_bypass"); + assert_eq!(out.result["status"], "success"); + assert_eq!(out.recorder.call_count(), 1); + let bypassed = wc::events_of(&out.events, "policy.bypassed"); + assert!( + bypassed.iter().any(|event| { + event["boundary"] == "model" + && event["reason"] == "legacy migration fixture" + && event["rule"] == "policy.without" + }), + "expected an audited model bypass, got {bypassed:?}" + ); +} + +#[test] +fn changing_only_policy_invalidates_a_resumed_step_memo() { + let base = temp_run_dir("policy-resume"); + let first = r#" + (defpolicy safe + {:models {:default :deny :allow ["fake/fake-model"]}}) + (defworkflow guarded "resume policy" {:policy safe} + (phase "Run") + (def result (step "summarize" {:name "writer"})) + {:status :success :result result}) + "#; + let second = r#" + (defpolicy safe + {:models {:default :deny :allow ["fake/*"]}}) + (defworkflow guarded "resume policy" {:policy safe} + (phase "Run") + (def result (step "summarize" {:name "writer"})) + {:status :success :result result}) + "#; + + let first_run = run_workflow( + first, + fake_with_reply("same answer"), + RunOpts::fresh("wf_policy_resume", &base), + ); + assert_eq!(first_run.recorder.call_count(), 1); + + let resumed = run_workflow( + second, + fake_with_reply("same answer"), + RunOpts { + run_id: "wf_policy_resume", + run_dir: &base, + resume: true, + code_version: "", + args_json: "{}", + }, + ); + assert_eq!( + resumed.recorder.call_count(), + 1, + "a changed effective policy must miss the prior step memo" + ); + + let _ = std::fs::remove_dir_all(&base); +} + +#[test] +fn cassette_replay_rechecks_the_recorded_provider_identity() { + let base = temp_run_dir("policy-cassette"); + let tape = base.join("policy-tape.jsonl"); + let tape_path = tape + .to_string_lossy() + .replace('\\', "\\\\") + .replace('"', "\\\""); + let src = format!( + r#" + (defpolicy safe + {{:models {{:default :deny :allow ["fake/m"]}}}}) + (defworkflow guarded "cassette policy" {{:policy safe}} + (phase "Run") + (def result + (llm/with-cassette "{tape_path}" {{:mode :record}} + (lambda () (llm/complete "prompt" {{:model "m"}})))) + {{:status :success :result result}}) + "# + ); + let recorded = run_workflow( + &src, + FakeProvider::builder("fake") + .model("m") + .reply("recorded") + .build(), + RunOpts::fresh("wf_policy_cassette_record", &base), + ); + assert_eq!(recorded.result["status"], "success"); + + let tape_body = std::fs::read_to_string(&tape).expect("recorded policy tape"); + assert!( + tape_body.contains(r#""provider":"fake""#), + "policy-safe replay requires the serving provider on tape: {tape_body}" + ); + std::fs::write( + &tape, + tape_body.replace(r#""provider":"fake""#, r#""provider":"other""#), + ) + .unwrap(); + + let replay_src = src.replace(":mode :record", ":mode :replay"); + let replay = run_workflow( + &replay_src, + FakeProvider::builder("fake") + .model("m") + .error(sema_llm::types::LlmError::Api { + status: 500, + message: "provider must not be called".into(), + }) + .build(), + RunOpts::fresh("wf_policy_cassette_replay", &base), + ); + assert_eq!(replay.recorder.call_count(), 0); + assert_eq!( + wc::events_of(&replay.events, "run.ended")[0]["status"], + "failed" + ); + assert!( + wc::events_of(&replay.events, "policy.violation") + .iter() + .any(|event| { + event["subject"] == "other/m" + && event["source"] == "cassette" + && event["action"] == "fail" + }), + "the tampered recorded provider must be rejected before replay" + ); + + let _ = std::fs::remove_dir_all(&base); +} + +#[test] +fn cassette_replay_uses_the_recorded_provider_not_the_current_route() { + let base = temp_run_dir("policy-cassette-route"); + let tape = base.join("policy-route-tape.jsonl"); + let tape_path = tape + .to_string_lossy() + .replace('\\', "\\\\") + .replace('"', "\\\""); + let src = format!( + r#" + (llm/define-provider :allowed + {{:default-model "model" + :complete (lambda (_request) "recorded")}}) + (llm/define-provider :blocked + {{:default-model "model" + :complete (lambda (_request) "must not run")}}) + (defpolicy replay-safe + {{:models {{:default :deny :allow ["allowed/model"]}}}}) + (defworkflow guarded "cassette route" {{:policy replay-safe}} + (phase "Run") + (def recorded + (llm/with-fallback [:allowed] + (lambda () + (llm/with-cassette "{tape_path}" {{:mode :record}} + (lambda () (llm/complete "prompt" {{:model "model"}})))))) + (def replayed + (llm/with-fallback [:blocked] + (lambda () + (llm/with-cassette "{tape_path}" {{:mode :replay}} + (lambda () (llm/complete "prompt" {{:model "model"}})))))) + {{:status :success :recorded recorded :replayed replayed}}) + "# + ); + let fake = FakeProvider::builder("fake").model("fake-model").build(); + let out = run_workflow( + &src, + fake, + RunOpts::fresh("wf_policy_cassette_route", &base), + ); + + assert_eq!(out.result["status"], "success"); + assert_eq!(out.result["recorded"], "recorded"); + assert_eq!(out.result["replayed"], "recorded"); + let checks = wc::events_of(&out.events, "policy.checked"); + assert_eq!( + checks + .iter() + .filter(|event| event["subject"] == "allowed/model") + .count(), + 2, + "record and replay should each check the provider they use" + ); + assert!( + !checks + .iter() + .any(|event| event["subject"] == "blocked/model"), + "the replay route does not serve the recorded response" + ); + + let _ = std::fs::remove_dir_all(&base); +} diff --git a/crates/sema/tests/workflow_suite.rs b/crates/sema/tests/workflow_suite.rs index 1b45af95..748a6d72 100644 --- a/crates/sema/tests/workflow_suite.rs +++ b/crates/sema/tests/workflow_suite.rs @@ -14,6 +14,8 @@ mod workflow_budget_test; mod workflow_cookbook_test; #[path = "suites/workflow_mcp_seam_test.rs"] mod workflow_mcp_seam_test; +#[path = "suites/workflow_policy_test.rs"] +mod workflow_policy_test; #[path = "suites/workflow_resume_test.rs"] mod workflow_resume_test; #[path = "suites/workflow_selfrewrite_test.rs"] diff --git a/examples/workflows/policy.sema b/examples/workflows/policy.sema new file mode 100644 index 00000000..e57b34ae --- /dev/null +++ b/examples/workflows/policy.sema @@ -0,0 +1,60 @@ +;; Least-privilege workflow policy example. +;; +;; The names in :tools :allow must match ToolDefinitions passed to an agent. +;; Replace the example model identities with providers/models configured in your +;; environment before running this workflow. + +(deftool read-file + "Read one repository file." + {:path {:type :string :description "Workspace-relative path"}} + (lambda (path) (file/read path))) + +(deftool fetch-url + "Fetch one HTTPS URL." + {:url {:type :string :description "Absolute HTTPS URL"}} + (lambda (url) (http/get url))) + +(deftool run-command + "Run one exact allowlisted command." + {:command {:type :string :description "Exact command string"}} + (lambda (command) (shell command))) + +(defpolicy repository-auditor + {:models + {:default :deny + :allow ["openai/gpt-5" "anthropic/*"] + :on-deny :fail} + + :tools + {:default :deny + :allow + {"read-file" + {:paths ["Cargo.toml" "src/**" "crates/**"]} + + "fetch-url" + {:domains {:allow ["api.example.com" "*.example.com"] + :schemes ["https"] + :ports [443]}} + + "run-command" + {:commands ["cargo check" "cargo test"]}} + :deny ["delete-file"] + :on-deny :tool-error}}) + +(defworkflow policy-demo + "Demonstrate model/tool policy composition." + {:phases ["Audit"] + :permissions "no-fs-write" + :policy repository-auditor} + + (phase "Audit") + (def report + (step "Inspect this repository without modifying it." + {:name "auditor" + :tools [read-file fetch-url run-command] + ;; A step policy can only tighten the workflow policy. + :policy {:tools + {:default :deny + :allow + {"read-file" {:paths ["src/**" "crates/**"]}}}}})) + {:status :success :report report}) diff --git a/website/docs/llm/workflows.md b/website/docs/llm/workflows.md index fef3d683..6208d146 100644 --- a/website/docs/llm/workflows.md +++ b/website/docs/llm/workflows.md @@ -47,6 +47,7 @@ The `meta-map` supports: | `:phases` | `[:string …]` | Declared phase plan — the dashboard shows all phases up front | | `:budget` | `{:tokens N :usd M}` | Spend caps (see [Budget Enforcement](#budget-enforcement)) | | `:permissions` | string | Sandbox restrictions for `sema workflow run`, using the same syntax as `--sandbox` | +| `:policy` | policy | Model/tool allowlist for this workflow (see [Model and tool policies](#model-and-tool-policies)) | | `:args` | map | Argument schema (informational; the actual args come from `--args`) | The body is ordinary Sema code. `phase` markers interleave with `def`, @@ -109,6 +110,7 @@ The opts map supports: | `:schema` | schema spec | Typed extraction — the step returns a validated map, not text | | `:tools` | `[tool …]` | Tool-calling loop — the step runs `llm/chat` with tool dispatch | | `:agent` | `defagent` | Run a configured `defagent` as this step via `agent/run` | +| `:policy` | policy | Additional restrictions for this step; it cannot loosen the workflow policy | When `:agent` is present, the defagent owns its own tools and model — inline `:tools`/`:model` are ignored (the static checker warns if both are given). @@ -184,9 +186,9 @@ Every `sema workflow run` creates a run directory under `.sema/runs//`: ### Event vocabulary -The event vocabulary is **frozen** — add fields (append-only, all -`Option`/skippable) but never change existing ones. Old runs stay readable -forever. +Existing event shapes are **frozen** — add fields only as append-only, +optional/skippable fields, and add new event kinds without changing old ones. +Old runs stay readable forever. | Event | Key fields | Description | |-------|-----------|-------------| @@ -196,6 +198,9 @@ forever. | `agent.started` | `agent_id`, `agent_name`, `model` | An agent leaf began | | `agent.result` | `agent_id`, `status`, `output`, `dur_ms`, `model` | An agent leaf produced a result | | `agent.tool_call` | `agent_id`, `tool_name`, `args_json` | An agent invoked a tool | +| `policy.checked` | `policy`, `boundary`, `subject`, `rule`, `source` | A policy layer allowed a protected boundary | +| `policy.violation` | `policy`, `boundary`, `subject`, `rule`, `action`, `source` | A policy layer denied a protected boundary | +| `policy.bypassed` | `policy`, `boundary`, `subject`, `reason`, `source` | A lexical `policy/without` scope bypassed a protected boundary | | `checkpoint` | `key`, `content_key`, `value_digest`, `value` | A checkpoint was recorded | | `budget` | `agent_id`, `input_tokens`, `output_tokens`, `cost_usd`, `budget_limit` | A per-leaf budget observation | | `run.ended` | `status`, `reason`, `dur_ms` | Last line of every run | @@ -213,9 +218,11 @@ memoized leaves — they replay for free. ### How content keys work Each step leaf's content key is a hash of `(kind, code-version, args, phase, -step-name, prompt, schema)`. Checkpoints use `(kind, code-version, args, -phase, key)`. Same inputs → same key → memo hit → no re-call. An occurrence -ordinal distinguishes identical repeats in source order. +step-name, prompt, schema, effective-policy)`. Checkpoints use `(kind, +code-version, args, phase, key)`. Same inputs → same key → memo hit → no +re-call. An occurrence ordinal distinguishes identical repeats in source +order. Tightening or otherwise changing the effective step policy invalidates +that step's memo. ### Automatic invalidation @@ -311,11 +318,126 @@ denial list. Workflow permissions can only remove capabilities from the caller's sandbox; they cannot loosen a stricter `--sandbox` or `--allowed-paths` setting. +## Model and tool policies + +Policies constrain the resolved model and model-requested tool calls inside a +workflow. Define one with `defpolicy`, then attach it to a workflow: + +```sema +(defpolicy safe-agent + {:models + {:default :deny + :allow ["openai/gpt-5" "anthropic/*"] + :deny ["anthropic/deprecated-model"] + :on-deny :fail} + + :tools + {:default :deny + :allow + {"read-file" {:paths ["src/**" "Cargo.toml"]} + "fetch-url" {:domains {:allow ["api.example.com" "*.example.com"] + :schemes ["https"] + :ports [443]}} + "run-command" {:commands ["cargo test" "cargo check"]}} + :deny ["delete-file"] + :on-deny :tool-error}}) + +(defworkflow guarded-audit + "Audit with a least-privilege model and tool envelope." + {:phases ["Audit"] + :permissions "no-fs-write" + :policy safe-agent} + + (phase "Audit") + (def result + (step "Inspect the Rust sources." + {:name "auditor" + :tools [read-file fetch-url run-command]})) + {:status :success :result result}) +``` + +Model rules use an exact `provider/model` identity. The only wildcard form is +`provider/*`; provider wildcards and partial model globs are rejected. Deny +rules win over allow rules. When `:models` or `:tools` is present, +`:default` defaults to `:deny`. + +Tool allow entries may be unconstrained (`{}`) or constrain named JSON +arguments: + +| Constraint | Shorthand argument | Match | +|------------|--------------------|-------| +| `:paths` | `"path"` | Workspace-relative literal, `*`, and `**` patterns; absolute paths and root/symlink escapes are denied | +| `:domains` | `"url"` | Parsed HTTP(S) URLs matched by normalized hostname, scheme, and optional effective port | +| `:commands` | `"command"` | Exact command strings only; no wildcard or shell-prefix matching | + +A leading `*.` matches subdomains only, so list both `"example.com"` and +`"*.example.com"` when both the apex and its subdomains are allowed. URLs +containing credentials are always denied. + +Use explicit selectors when a tool uses different argument names or has +multiple path-like arguments: + +```sema +{:tools + {:allow + {"copy-file" + {:paths [{:arg :source :allow ["src/**"]} + {:arg :destination + :allow ["generated/**"] + :deny ["generated/private/**"]}]}}}} +``` + +### Composition and denial behavior + +A step policy is combined with the workflow policy using logical AND: every +active layer must allow the boundary. A step may tighten its workflow but +cannot loosen it. The strictest denial action across active layers wins. + +| Boundary | `:on-deny` | Behavior | +|----------|------------|----------| +| Model | `:fail` (default) | Fail before cache, cassette, callback, or provider access | +| Model | `:skip` | Skip a denied fallback target; a non-fallback call still fails | +| Tool | `:fail` (default) | Preflight the whole requested batch and run none when any call is denied | +| Tool | `:tool-error` | In an agent loop, return a correlated tool error for the denied call while allowed siblings run | + +The model gate covers completion, chat, extraction, classification, streaming, +fallbacks, embeddings, and reranking. The tool gate covers `ToolDefinition` +dispatch through agents and direct `tool/invoke`, including tools discovered +through MCP. Checks happen before cache/cassette replay and before user +callbacks, schema predicates, or tool handlers. Cache/cassette keys and resume +keys include the effective policy fingerprint; replay also rechecks the stored +provider identity. + +`policy.checked`, `policy.violation`, and `policy.bypassed` events identify the +policy, boundary, matched rule, enforcement action, and whether the source was +a request, cache, or cassette. Tool arguments are represented only by a digest in +policy events; raw paths, URLs, and commands are not recorded there. + +### Trusted lexical bypass + +Trusted workflow code can bypass model/tool policy for a narrow lexical scope: + +```sema +(policy/without "read the legacy migration fixture" + (step "Inspect the fixture." {:tools [read-file]})) +``` + +The reason must be a non-empty literal string of at most 256 characters. The +bypass is task-local, applies only to its body, and emits `policy.bypassed` for +each protected boundary. It never bypasses the outer sandbox. + +Policies govern LLM/model boundaries and model-invoked tools. Ordinary author +code such as direct filesystem, shell, HTTP, or raw MCP calls remains governed +by `:permissions`, the CLI sandbox, and allowed-path settings. Keep both: +policy controls what the model may choose; the sandbox remains the hard outer +capability ceiling. + ## `sema workflow check` Statically validate a workflow file **without evaluating it or calling any -LLM**. Catches arity traps, bad options, and layout issues before you spend a -token. +LLM**. Catches arity traps, bad options, invalid literal policy maps, +`defpolicy` shape errors, unsafe matcher syntax, and invalid +`policy/without` reasons before you spend a token. ```bash $ sema workflow check audit.sema From cc35e71c00a8d3815608d59c5346e47367feadab Mon Sep 17 00:00:00 2001 From: Helge Sverre Date: Fri, 31 Jul 2026 10:03:29 +0200 Subject: [PATCH 04/11] fix: enforce model policy across LLM dispatch paths --- crates/sema-llm/src/builtins.rs | 90 +++++++++-------- .../sema/tests/suites/workflow_policy_test.rs | 98 +++++++++++++++++++ 2 files changed, 147 insertions(+), 41 deletions(-) diff --git a/crates/sema-llm/src/builtins.rs b/crates/sema-llm/src/builtins.rs index 5edea9ea..a4eb15b8 100644 --- a/crates/sema-llm/src/builtins.rs +++ b/crates/sema-llm/src/builtins.rs @@ -335,6 +335,28 @@ fn model_target_allowed( } } +/// Resolve and check every batch target before the provider starts any request. +fn resolve_batch_models( + provider: &dyn LlmProvider, + requests: impl IntoIterator, +) -> Result, SemaError> { + requests + .into_iter() + .map(|mut request| { + if request.model.is_empty() { + request.model = provider.default_model().to_string(); + } + model_target_allowed( + provider.name(), + &request.model, + PolicySource::Request, + false, + )?; + Ok(request) + }) + .collect() +} + fn enforce_stored_model_policy( provider: &str, model: &str, @@ -4555,15 +4577,7 @@ pub fn register_llm_builtins(env: &Env, sandbox: &sema_core::Sandbox) { .collect::>(); let responses = with_provider(|provider| { - let requests = requests - .into_iter() - .map(|mut request| { - if request.model.is_empty() { - request.model = provider.default_model().to_string(); - } - request - }) - .collect(); + let requests = resolve_batch_models(provider, requests)?; Ok(provider.batch_complete(requests)) })?; responses @@ -4653,12 +4667,13 @@ pub fn register_llm_builtins(env: &Env, sandbox: &sema_core::Sandbox) { .to_string(), )); }; + let resolved_requests = resolve_batch_models(&*provider, requests.iter().cloned())?; if provider.runs_on_vm_thread() { return Box::new(SemaBatchDriver { provider: provider.name().to_string(), default_model: provider.default_model().to_string(), - requests, + requests: resolved_requests, next_request: 0, active_model: None, responses: Vec::new(), @@ -4668,17 +4683,6 @@ pub fn register_llm_builtins(env: &Env, sandbox: &sema_core::Sandbox) { .advance(); } - let reqs: Vec = requests - .iter() - .cloned() - .map(|mut r| { - if r.model.is_empty() { - r.model = provider.default_model().to_string(); - } - r - }) - .collect(); - // Capture the dispatch-time budget + leaf-usage frames (ASYNC-1), so the // decoder charges the frames active now, not whatever scope is installed // when the future lands. Mirrors the completion and embedding paths. @@ -4707,7 +4711,7 @@ pub fn register_llm_builtins(env: &Env, sandbox: &sema_core::Sandbox) { kind, decoder, resource, - move || Ok(Box::new(p_job.batch_complete(reqs)) as SendPayload), + move || Ok(Box::new(p_job.batch_complete(resolved_requests)) as SendPayload), ); return Ok(NativeOutcome::Suspend(NativeSuspend { wait: WaitKind::External(Box::new(prepared)), @@ -4717,15 +4721,7 @@ pub fn register_llm_builtins(env: &Env, sandbox: &sema_core::Sandbox) { } let responses = with_provider(|p| { - let reqs: Vec = requests - .into_iter() - .map(|mut r| { - if r.model.is_empty() { - r.model = p.default_model().to_string(); - } - r - }) - .collect(); + let reqs = resolve_batch_models(p, requests)?; Ok(p.batch_complete(reqs)) })?; @@ -8029,6 +8025,8 @@ enum CompletePrep { #[cfg(not(target_arch = "wasm32"))] struct CompleteOffloadPlan { chain: Vec, + /// Model `:skip` applies to every explicit fallback chain, including one entry. + explicit_fallback: bool, request: ChatRequest, max_retries: u32, retry_base_ms: u64, @@ -8152,9 +8150,10 @@ fn complete_offload_prep(request: ChatRequest) -> Result = PROVIDER_REGISTRY.with(|reg| { let reg = reg.borrow(); - let fallback = FALLBACK_CHAIN.with(|c| c.borrow().clone()); match fallback { Some(entries) if !entries.is_empty() => entries .iter() @@ -8191,6 +8190,7 @@ fn complete_offload_prep(request: ChatRequest) -> Result 1, + self.plan.explicit_fallback, )? { continue; } @@ -12125,6 +12125,8 @@ struct StreamDone { #[cfg(not(target_arch = "wasm32"))] struct StreamDispatchState { chain: Vec, + /// Model `:skip` applies to every explicit fallback chain, including one entry. + explicit_fallback: bool, request: ChatRequest, next_provider: usize, last_error: Option<(LlmError, String)>, @@ -12286,11 +12288,13 @@ fn stream_wire_attempt( } /// Resolve the active fallback chain (or the default provider) into owned `Arc` -/// clones on the VM thread, so the offloaded wire walk touches no thread-locals. -fn resolve_stream_chain() -> Result, SemaError> { - PROVIDER_REGISTRY.with(|reg| { +/// clones on the VM thread. The boolean records whether the chain was explicit, +/// so the offloaded wire walk touches no thread-locals. +fn resolve_stream_chain() -> Result<(Vec, bool), SemaError> { + let fallback = FALLBACK_CHAIN.with(|c| c.borrow().clone()); + let explicit_fallback = fallback.as_ref().is_some_and(|entries| !entries.is_empty()); + let chain = PROVIDER_REGISTRY.with(|reg| { let reg = reg.borrow(); - let fallback = FALLBACK_CHAIN.with(|c| c.borrow().clone()); match fallback { Some(entries) if !entries.is_empty() => entries .iter() @@ -12322,7 +12326,8 @@ fn resolve_stream_chain() -> Result, SemaError> { }]) } } - }) + })?; + Ok((chain, explicit_fallback)) } /// Start a non-blocking stream run. Cassette replay does not reserve a rate-limit slot. @@ -12358,8 +12363,10 @@ fn stream_run_begin(request: ChatRequest, span: sema_otel::LlmSpan) -> Result Result(); if rate_limit_wait_ms > 0 { sema_core::blocking_sleep_ms(rate_limit_wait_ms); @@ -12499,7 +12506,7 @@ impl RuntimeStreamDriver { &entry.name, &request.model, PolicySource::Request, - dispatch.chain.len() > 1, + dispatch.explicit_fallback, )? { return Ok(Action::Skip); } @@ -14192,6 +14199,7 @@ mod tests { let driver = RuntimeCompleteDriver { plan: CompleteOffloadPlan { chain: Vec::new(), + explicit_fallback: false, request: ChatRequest::new(String::new(), Vec::new()), max_retries: 0, retry_base_ms: 0, diff --git a/crates/sema/tests/suites/workflow_policy_test.rs b/crates/sema/tests/suites/workflow_policy_test.rs index 305f3ce4..847587ac 100644 --- a/crates/sema/tests/suites/workflow_policy_test.rs +++ b/crates/sema/tests/suites/workflow_policy_test.rs @@ -119,6 +119,104 @@ fn model_skip_skips_only_denied_fallback_targets() { .any(|event| event["subject"] == "allowed/model")); } +#[test] +fn single_entry_fallback_preserves_skip_for_completion_and_stream() { + let src = r#" + (defpolicy fallback-safe + {:models {:default :deny :on-deny :skip}}) + (defworkflow guarded "single fallback skip" {:policy fallback-safe} + (phase "Run") + (def completion-type + (try + (llm/with-fallback [:fake] + (lambda () (llm/complete "complete"))) + (catch error (:type error)))) + (def stream-type + (try + (llm/with-fallback [:fake] + (lambda () + (llm/stream "stream" (lambda (_chunk) nil)))) + (catch error (:type error)))) + {:status :success + :types (list completion-type stream-type)}) + "#; + + let fake = FakeProvider::builder("fake").model("fake-model").build(); + let out = wc::run_once(src, fake, "wf_policy_single_fallback_skip"); + assert_eq!(out.result["status"], "success"); + assert_eq!(out.result["types"], serde_json::json!(["llm", "llm"])); + assert_eq!( + out.recorder.call_count(), + 0, + "a denied fallback target must not reach the provider" + ); + + let violations = wc::events_of(&out.events, "policy.violation"); + assert_eq!( + violations.len(), + 2, + "completion and stream should each audit one denial" + ); + assert!( + violations + .iter() + .all(|event| { event["subject"] == "fake/fake-model" && event["action"] == "skip" }), + "a one-entry fallback must retain fallback skip behavior: {violations:?}" + ); +} + +#[test] +fn batch_and_pmap_check_model_policy_before_provider_access() { + let src = r#" + (defpolicy locked {:models {:default :deny}}) + (defworkflow guarded "batch model policy" {:policy locked} + (phase "Run") + (def batch-result + (try + (llm/batch (list "batch")) + (catch _ :denied))) + (def pmap-result + (try + (llm/pmap str (list "pmap")) + (catch _ :denied))) + {:status :success + :results (list batch-result pmap-result)}) + "#; + + let out = wc::run_once( + src, + FakeProvider::builder("fake") + .model("fake-model") + .reply("unexpected") + .reply("unexpected") + .build(), + "wf_policy_batch_pmap", + ); + assert_eq!(out.result["status"], "success"); + assert_eq!( + out.result["results"], + serde_json::json!(["denied", "denied"]) + ); + assert_eq!( + out.recorder.call_count(), + 0, + "denied batch requests must not reach the provider" + ); + + let violations = wc::events_of(&out.events, "policy.violation"); + assert_eq!( + violations.len(), + 2, + "llm/batch and llm/pmap should each audit one denial" + ); + assert!( + violations + .iter() + .all(|event| { event["subject"] == "fake/fake-model" && event["action"] == "fail" }), + "batch model denials should be hard failures: {violations:?}" + ); +} + #[test] fn stream_embed_and_rerank_are_denied_before_provider_or_callback() { let base = temp_run_dir("policy-model-surfaces"); From 948706060b1a9978c8de5fb1908127ea813c07ff Mon Sep 17 00:00:00 2001 From: Helge Sverre Date: Fri, 31 Jul 2026 10:08:04 +0200 Subject: [PATCH 05/11] feat(policy): compose policy layers in one scope --- crates/sema-llm/src/builtins.rs | 18 +++---- crates/sema-stdlib/src/workflow.rs | 48 +++++++++++++++---- .../sema/tests/suites/workflow_policy_test.rs | 40 ++++++++++++++++ 3 files changed, 88 insertions(+), 18 deletions(-) diff --git a/crates/sema-llm/src/builtins.rs b/crates/sema-llm/src/builtins.rs index a4eb15b8..0602ace8 100644 --- a/crates/sema-llm/src/builtins.rs +++ b/crates/sema-llm/src/builtins.rs @@ -220,19 +220,21 @@ impl Drop for PolicyAttributionScope { } } -/// Install a compiled policy for the dynamic extent of a workflow or step. -pub fn open_policy_scope( - policy: Rc, +/// Install compiled policy layers atomically for the dynamic extent of a workflow or step. +pub fn open_policy_scopes( + policies_to_add: Vec>, workspace_root: PathBuf, sink: PolicyDecisionSink, ) -> PolicyScope { let previous = ACTIVE_POLICIES.with(|policies| { let previous = policies.borrow().clone(); - policies.borrow_mut().push(ActivePolicy { - policy, - workspace_root, - sink, - }); + policies + .borrow_mut() + .extend(policies_to_add.into_iter().map(|policy| ActivePolicy { + policy, + workspace_root: workspace_root.clone(), + sink: sink.clone(), + })); previous }); PolicyScope { diff --git a/crates/sema-stdlib/src/workflow.rs b/crates/sema-stdlib/src/workflow.rs index 74168172..b2774772 100644 --- a/crates/sema-stdlib/src/workflow.rs +++ b/crates/sema-stdlib/src/workflow.rs @@ -64,12 +64,40 @@ fn opt_value(v: &Value, key: &str) -> Option { .and_then(|m| m.get(&Value::keyword(key)).cloned()) } -fn compile_policy(container: &Value) -> Result>, SemaError> { +fn compile_policy( + container: &Value, +) -> Result>>, SemaError> { opt_value(container, "policy") .map(|policy| { - sema_policy::CompiledPolicy::compile(&policy) - .map(Rc::new) - .map_err(|error| SemaError::eval(format!("invalid workflow policy: {error}"))) + let values = if policy.as_map_rc().is_some() { + vec![policy] + } else { + let policies = policy.as_seq().ok_or_else(|| { + SemaError::eval( + "invalid workflow policy: :policy must be a map or nonempty sequence of maps", + ) + })?; + if policies.is_empty() { + return Err(SemaError::eval( + "invalid workflow policy: :policy sequence must not be empty", + )); + } + policies.to_vec() + }; + + values + .iter() + .enumerate() + .map(|(index, value)| { + sema_policy::CompiledPolicy::compile(value) + .map(Rc::new) + .map_err(|error| { + SemaError::eval(format!( + "invalid workflow policy layer {index}: {error}" + )) + }) + }) + .collect() }) .transpose() } @@ -152,13 +180,13 @@ fn emit_policy_observation(ctx: &context::WorkflowCtx, observation: PolicyObserv } fn open_compiled_policy( - policy: Option>, + policies: Option>>, ctx: &Rc, workspace_root: &Path, ) -> Option { - policy.map(|policy| { - sema_llm::builtins::open_policy_scope( - policy, + policies.map(|policies| { + sema_llm::builtins::open_policy_scopes( + policies, workspace_root.to_path_buf(), policy_sink(ctx), ) @@ -1172,7 +1200,7 @@ fn apply_resolutions( thunk: Value, resolver: Rc, resolutions: Vec, - policy: Option>, + policy: Option>>, workspace_root: PathBuf, ) -> Result { let ctx = context::current_for(task_context) @@ -1307,7 +1335,7 @@ struct ResolveContinuation { guard: context::WorkflowGuard, thunk: Value, resolver: Rc, - policy: Option>, + policy: Option>>, workspace_root: PathBuf, } diff --git a/crates/sema/tests/suites/workflow_policy_test.rs b/crates/sema/tests/suites/workflow_policy_test.rs index 847587ac..481a4baf 100644 --- a/crates/sema/tests/suites/workflow_policy_test.rs +++ b/crates/sema/tests/suites/workflow_policy_test.rs @@ -7,6 +7,7 @@ use crate::workflow_common as wc; use crate::workflow_common::{run_workflow, temp_run_dir, RunOpts}; +use sema_eval::Interpreter; use sema_llm::fake::FakeProvider; use sema_llm::types::ToolCall; @@ -462,6 +463,45 @@ fn step_policy_can_tighten_but_not_loosen_the_workflow_policy() { ); } +#[test] +fn workflow_policy_sequence_composes_without_loosening() { + let src = r#" + (defpolicy models + {:models {:default :deny :allow ["fake/fake-model"]}}) + (defpolicy tools + {:tools {:default :deny}}) + (defworkflow guarded "composed policy" {:policy [models tools]} + (phase "Run") + (llm/complete "hello")) + "#; + + let out = wc::run_once(src, fake_with_reply("ok"), "wf_policy_sequence_composes"); + assert_eq!(out.result["status"], "success"); + assert!(out + .events + .iter() + .any(|event| event["event"] == "policy.checked" && event["policy"] == "models")); +} + +#[test] +fn workflow_policy_sequence_rejects_empty_and_nonmap_layers() { + for (suffix, policy) in [("empty", "[]"), ("nonmap", "[{:models {}} 42]")] { + let src = format!( + r#" + (defworkflow guarded "invalid composed policy" {{:policy {policy}}} + :unreachable) + "# + ); + let error = Interpreter::new() + .eval_str_compiled(&src) + .expect_err("invalid policy sequence"); + assert!( + error.to_string().contains("invalid workflow policy"), + "{suffix}: {error}" + ); + } +} + #[test] fn stricter_layer_action_is_the_effective_journaled_action() { let src = r#" From fe5aa9c8e89125bb1ed6f8bc3b178a3b745fa2ca Mon Sep 17 00:00:00 2001 From: Helge Sverre Date: Fri, 31 Jul 2026 10:31:35 +0200 Subject: [PATCH 06/11] feat(policy): add semantic subjects and content guards --- Cargo.lock | 1 + crates/sema-core/src/lib.rs | 10 +- crates/sema-core/src/value.rs | 32 + crates/sema-eval/src/eval.rs | 14 +- crates/sema-eval/src/special_forms.rs | 110 +- crates/sema-llm/src/builtins.rs | 377 +++++- crates/sema-mcp/src/builtins.rs | 1 + crates/sema-policy/Cargo.toml | 1 + crates/sema-policy/src/content.rs | 306 +++++ crates/sema-policy/src/lib.rs | 1045 ++++++++++++++++- crates/sema-stdlib/src/secret.rs | 191 +-- crates/sema-stdlib/src/workflow.rs | 33 + crates/sema-vm/src/compiler.rs | 9 +- crates/sema-vm/src/core_expr.rs | 1 + crates/sema-vm/src/lower.rs | 11 +- crates/sema-vm/src/optimize.rs | 2 + crates/sema-vm/src/resolve.rs | 8 + crates/sema-workflow/src/event.rs | 43 + .../sema/tests/suites/workflow_policy_test.rs | 42 + 19 files changed, 1993 insertions(+), 244 deletions(-) create mode 100644 crates/sema-policy/src/content.rs diff --git a/Cargo.lock b/Cargo.lock index 54649d4d..55147f58 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3684,6 +3684,7 @@ name = "sema-policy" version = "1.33.0" dependencies = [ "globset", + "regex", "sema-core", "serde_json", "sha2 0.10.9", diff --git a/crates/sema-core/src/lib.rs b/crates/sema-core/src/lib.rs index 354e38bb..deff3608 100644 --- a/crates/sema-core/src/lib.rs +++ b/crates/sema-core/src/lib.rs @@ -73,11 +73,11 @@ pub use text_util::truncate_chars; pub use value::{ bits_to_spur, compare_spurs, intern, interner_stats, next_gensym, pretty_print, resolve, resolve_multimethod_handler, select_multimethod_handler, spur_to_bits, with_resolved, Agent, - AsyncPromise, Channel, Conversation, Env, ImageAttachment, Lambda, Macro, Message, MultiMethod, - MutableArray, MutableCell, NativeFn, NativeSuspensionClass, PromiseState, Prompt, Record, Role, - SemaStream, StreamBox, SyntaxRules, Thunk, ToolDefinition, Value, ValueView, ValueViewRef, - NAN_INT_SIGN_BIT, NAN_INT_SMALL_PATTERN, NAN_PAYLOAD_BITS, NAN_PAYLOAD_MASK, NAN_TAG_MASK, - TAG_NATIVE_FN, + AsyncPromise, Channel, Conversation, Env, FileAccess, ImageAttachment, Lambda, Macro, Message, + MultiMethod, MutableArray, MutableCell, NativeFn, NativeSuspensionClass, PromiseState, Prompt, + Record, Role, SemaStream, StreamBox, SyntaxRules, Thunk, ToolDefinition, ToolPolicySubject, + Value, ValueView, ValueViewRef, NAN_INT_SIGN_BIT, NAN_INT_SMALL_PATTERN, NAN_PAYLOAD_BITS, + NAN_PAYLOAD_MASK, NAN_TAG_MASK, TAG_NATIVE_FN, }; pub mod runtime; diff --git a/crates/sema-core/src/value.rs b/crates/sema-core/src/value.rs index 4687954b..fd388310 100644 --- a/crates/sema-core/src/value.rs +++ b/crates/sema-core/src/value.rs @@ -727,9 +727,41 @@ pub struct ToolDefinition { pub name: String, pub description: String, pub parameters: Value, + pub policy_subjects: Vec, pub handler: Value, } +/// Static, inspectable description of the security-relevant subject a tool acts on. +/// +/// Argument names refer to the tool's JSON schema. The policy runtime resolves +/// them before invoking the handler and never infers authority from the tool name. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum ToolPolicySubject { + File { + access: FileAccess, + path_arg: String, + }, + NetworkRequest { + method: Option, + url_arg: String, + }, + Command { + command_arg: String, + }, + ExternalAction { + action: String, + target_arg: Option, + }, +} + +/// File-system authority represented by a tool policy subject. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum FileAccess { + Read, + Write, + Delete, +} + /// An agent: system prompt + tools + config for autonomous loops. #[derive(Debug, Clone)] pub struct Agent { diff --git a/crates/sema-eval/src/eval.rs b/crates/sema-eval/src/eval.rs index a1d46f47..c25612ca 100644 --- a/crates/sema-eval/src/eval.rs +++ b/crates/sema-eval/src/eval.rs @@ -3923,24 +3923,30 @@ pub fn register_vm_delegates(env: &Rc, ctx: &Rc) { })), ); - // __vm-deftool: the VM has already evaluated description/parameters/handler + // __vm-deftool: the VM has already evaluated description/parameters/options/handler // and passes them as values, so build the tool directly. let tool_env = Rc::downgrade(env); env.set( intern("__vm-deftool"), Value::native_fn(NativeFn::simple("__vm-deftool", move |args| { - if args.len() != 4 { - return Err(SemaError::arity("deftool", "4", args.len())); + if !matches!(args.len(), 4 | 5) { + return Err(SemaError::arity("deftool", "4 or 5", args.len())); } let name = args[0] .as_symbol() .ok_or_else(|| SemaError::eval("deftool: name must be a symbol"))?; + let (options, handler) = if args.len() == 5 { + (args[3].clone(), args[4].clone()) + } else { + (Value::nil(), args[3].clone()) + }; let tool_env = upgrade_delegate_env(&tool_env)?; special_forms::register_tool( &name, args[1].clone(), args[2].clone(), - args[3].clone(), + options, + handler, &tool_env, ) })), diff --git a/crates/sema-eval/src/special_forms.rs b/crates/sema-eval/src/special_forms.rs index a8423a41..1afedaa3 100644 --- a/crates/sema-eval/src/special_forms.rs +++ b/crates/sema-eval/src/special_forms.rs @@ -1,7 +1,8 @@ use std::rc::Rc; use sema_core::{ - intern, resolve, Agent, Env, EvalContext, Record, SemaError, Spur, ToolDefinition, Value, + intern, resolve, Agent, Env, EvalContext, FileAccess, Record, SemaError, Spur, ToolDefinition, + ToolPolicySubject, Value, }; use crate::eval::{self, Trampoline}; @@ -70,11 +71,12 @@ pub const SPECIAL_FORM_NAMES: &[&str] = &[ /// Build a `ToolDefinition` from already-evaluated values and bind it in `env`. /// The VM's `__vm-deftool` native passes the pre-evaluated description / -/// parameters / handler straight here. +/// parameters / options / handler straight here. pub(crate) fn register_tool( name: &str, description: Value, parameters: Value, + options: Value, handler: Value, env: &Env, ) -> Result { @@ -82,16 +84,120 @@ pub(crate) fn register_tool( .as_str() .ok_or_else(|| SemaError::type_error("string", description.type_name()))? .to_string(); + let policy_subjects = parse_tool_policy_subjects(&options)?; let tool = Value::tool_def(ToolDefinition { name: name.to_string(), description, parameters, + policy_subjects, handler, }); env.set(intern(name), tool.clone()); Ok(tool) } +fn parse_tool_policy_subjects(options: &Value) -> Result, SemaError> { + if options.is_nil() { + return Ok(Vec::new()); + } + let map = options + .as_map_rc() + .ok_or_else(|| SemaError::type_error("map", options.type_name()))?; + for key in map.keys() { + if key.as_keyword().as_deref() != Some("policy-subjects") { + return Err(SemaError::eval(format!("deftool: unknown option {key}"))); + } + } + let Some(subjects) = map.get(&Value::keyword("policy-subjects")) else { + return Ok(Vec::new()); + }; + let subjects = subjects + .as_seq() + .ok_or_else(|| SemaError::type_error("sequence", subjects.type_name()))?; + subjects + .iter() + .map(parse_tool_policy_subject) + .collect::, _>>() +} + +fn parse_tool_policy_subject(value: &Value) -> Result { + let map = value + .as_map_rc() + .ok_or_else(|| SemaError::type_error("map", value.type_name()))?; + let kind = subject_name(map.get(&Value::keyword("kind"))) + .ok_or_else(|| SemaError::eval("deftool: policy subject requires :kind"))?; + let required_arg = |key: &str| { + subject_name(map.get(&Value::keyword(key))).ok_or_else(|| { + SemaError::eval(format!("deftool: policy subject {kind:?} requires :{key}")) + }) + }; + match kind.as_str() { + "file-read" | "file-write" | "file-delete" => { + reject_subject_keys(&map, &["kind", "path-arg"])?; + let access = match kind.as_str() { + "file-read" => FileAccess::Read, + "file-write" => FileAccess::Write, + "file-delete" => FileAccess::Delete, + _ => unreachable!("matched file subject kind"), + }; + Ok(ToolPolicySubject::File { + access, + path_arg: required_arg("path-arg")?, + }) + } + "network-request" => { + reject_subject_keys(&map, &["kind", "url-arg", "method"])?; + Ok(ToolPolicySubject::NetworkRequest { + method: subject_name(map.get(&Value::keyword("method"))), + url_arg: required_arg("url-arg")?, + }) + } + "command" => { + reject_subject_keys(&map, &["kind", "command-arg"])?; + Ok(ToolPolicySubject::Command { + command_arg: required_arg("command-arg")?, + }) + } + "external-action" => { + reject_subject_keys(&map, &["kind", "action", "target-arg"])?; + Ok(ToolPolicySubject::ExternalAction { + action: required_arg("action")?, + target_arg: subject_name(map.get(&Value::keyword("target-arg"))), + }) + } + _ => Err(SemaError::eval(format!( + "deftool: unsupported policy subject kind {kind:?}" + ))), + } +} + +fn subject_name(value: Option<&Value>) -> Option { + value.and_then(|value| { + value + .as_keyword() + .or_else(|| value.as_str().map(str::to_string)) + }) +} + +fn reject_subject_keys( + map: &std::collections::BTreeMap, + allowed: &[&str], +) -> Result<(), SemaError> { + for key in map.keys() { + let Some(key) = key.as_keyword() else { + return Err(SemaError::eval( + "deftool: policy subject keys must be keywords", + )); + }; + if !allowed.contains(&key.as_str()) { + return Err(SemaError::eval(format!( + "deftool: unknown policy subject option :{key}" + ))); + } + } + Ok(()) +} + /// Build an `Agent` from an already-evaluated options map and bind it in `env`. /// The VM's `__vm-defagent` native passes the pre-evaluated options map here. pub(crate) fn register_agent(name: &str, opts: Value, env: &Env) -> Result { diff --git a/crates/sema-llm/src/builtins.rs b/crates/sema-llm/src/builtins.rs index 0602ace8..a7a5c0bc 100644 --- a/crates/sema-llm/src/builtins.rs +++ b/crates/sema-llm/src/builtins.rs @@ -21,7 +21,7 @@ use crate::pricing; use crate::provider::{LlmProvider, ProviderRegistry}; use crate::types::{ ChatMessage, ChatRequest, ChatResponse, ContentBlock, EmbedRequest, EmbedResponse, LlmError, - RerankRequest, RerankResponse, ToolCall, ToolSchema, Usage, + MessageContent, RerankRequest, RerankResponse, ToolCall, ToolSchema, Usage, }; use crate::vector_store::{VectorDocument, VectorStore}; @@ -114,6 +114,8 @@ pub struct LastUsage { pub enum PolicyBoundary { Model, Tool, + LlmInput, + LlmOutput, } impl PolicyBoundary { @@ -121,6 +123,8 @@ impl PolicyBoundary { match self { Self::Model => "model", Self::Tool => "tool", + Self::LlmInput => "llm.input", + Self::LlmOutput => "llm.output", } } } @@ -153,6 +157,8 @@ pub struct PolicyObservation { pub subject: String, pub subject_digest: Option, pub rule: String, + pub label: Option, + pub count: Option, pub action: Option, pub reason: Option, pub source: PolicySource, @@ -162,6 +168,8 @@ pub struct PolicyObservation { #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum PolicyObservationKind { Checked, + Flagged, + Redacted, Violation, Bypassed, } @@ -377,13 +385,24 @@ fn enforce_stored_model_policy( model_target_allowed(provider, model, source, false).map(|_| ()) } -fn preflight_tool_calls(calls: &[ToolCall]) -> Result, SemaError> { +fn preflight_tool_calls( + calls: &[ToolCall], + tools: &[Value], +) -> Result, SemaError> { let mut denied = BTreeMap::new(); let mut hard_denial = None; for call in calls { + let definition = tools.iter().find_map(|tool| { + tool.as_tool_def_rc() + .filter(|definition| definition.name == call.name) + }); + let policy_subjects = definition + .as_deref() + .map_or(&[][..], |definition| definition.policy_subjects.as_slice()); match check_tool_policy( &call.name, &call.arguments, + policy_subjects, sema_policy::ToolDenyAction::ToolError, ) { PolicyGate::Allow => {} @@ -404,8 +423,17 @@ fn preflight_tool_calls(calls: &[ToolCall]) -> Result, Ok(denied) } -fn enforce_direct_tool_policy(tool: &str, arguments: &serde_json::Value) -> Result<(), SemaError> { - match check_tool_policy(tool, arguments, sema_policy::ToolDenyAction::Fail) { +fn enforce_direct_tool_policy( + tool: &str, + arguments: &serde_json::Value, + policy_subjects: &[sema_core::ToolPolicySubject], +) -> Result<(), SemaError> { + match check_tool_policy( + tool, + arguments, + policy_subjects, + sema_policy::ToolDenyAction::Fail, + ) { PolicyGate::Allow => Ok(()), PolicyGate::Deny(_) => Err(policy_denied(PolicyBoundary::Tool, tool, "tools.denied")), } @@ -415,6 +443,7 @@ fn enforce_direct_tool_policy(tool: &str, arguments: &serde_json::Value) -> Resu fn check_tool_policy( tool: &str, arguments: &serde_json::Value, + policy_subjects: &[sema_core::ToolPolicySubject], minimum_action: sema_policy::ToolDenyAction, ) -> PolicyGate { let subject_digest = policy_value_digest(arguments); @@ -426,7 +455,7 @@ fn check_tool_policy( |layer| { layer .policy - .check_tool(tool, arguments, &layer.workspace_root) + .check_tool(tool, arguments, policy_subjects, &layer.workspace_root) }, |layer| layer.policy.tool_action().max(minimum_action), ) @@ -477,6 +506,8 @@ fn check_active_policies( subject: subject.to_string(), subject_digest, rule: "policy.without".to_string(), + label: None, + count: None, action: Some("bypass".to_string()), reason: Some(reason), source, @@ -509,6 +540,8 @@ fn check_active_policies( subject: subject.to_string(), subject_digest: subject_digest.clone(), rule: result.rule, + label: None, + count: None, // Journal what the boundary will actually do. A stricter denial in // any active layer upgrades every violation observation to that // effective action. @@ -530,6 +563,212 @@ fn policy_value_digest(value: &serde_json::Value) -> String { format!("sha256:{:x}", hasher.finalize()) } +fn policy_text_digest(text: &str) -> String { + let mut hasher = Sha256::new(); + hasher.update(text.as_bytes()); + format!("sha256:{:x}", hasher.finalize()) +} + +fn apply_text_policy( + text: &str, + boundary: PolicyBoundary, + subject: &str, + source: PolicySource, + output_stage: Option, +) -> Result { + let policies = ACTIVE_POLICIES.with(|policies| policies.borrow().clone()); + let policies: Vec<_> = policies + .into_iter() + .filter(|layer| match boundary { + PolicyBoundary::LlmInput => layer.policy.has_input_policy(), + PolicyBoundary::LlmOutput => layer.policy.has_output_policy(), + PolicyBoundary::Model | PolicyBoundary::Tool => false, + }) + .collect(); + if policies.is_empty() { + return Ok(text.to_string()); + } + if text.len() > sema_policy::content::INPUT_BYTE_CAP { + return Err(policy_denied(boundary, subject, "content.input-too-large")); + } + let subject_digest = Some(policy_text_digest(text)); + let agent_id = POLICY_AGENT_ID.with(|agent| agent.borrow().clone()); + if let Some(reason) = POLICY_BYPASS.with(|bypass| bypass.borrow().last().cloned()) { + let observation = PolicyObservation { + kind: PolicyObservationKind::Bypassed, + policy: "effective-policy".to_string(), + policy_digest: effective_policy_fingerprint(), + boundary, + subject: subject.to_string(), + subject_digest, + rule: "policy.without".to_string(), + label: None, + count: None, + action: Some("bypass".to_string()), + reason: Some(reason), + source, + agent_id, + }; + (policies.last().expect("nonempty content policy stack").sink)(observation); + return Ok(text.to_string()); + } + + let outcomes: Vec<_> = policies + .iter() + .map(|layer| { + let outcome = match boundary { + PolicyBoundary::LlmInput => layer.policy.check_input(text), + PolicyBoundary::LlmOutput => layer.policy.check_output( + text, + output_stage.unwrap_or(sema_policy::OutputStage::Final), + ), + PolicyBoundary::Model | PolicyBoundary::Tool => { + unreachable!("content policy called for non-content boundary") + } + }; + (layer, outcome) + }) + .collect(); + let effective_action = outcomes + .iter() + .map(|(_, outcome)| outcome.action) + .max() + .unwrap_or(sema_policy::ContentAction::Allow); + + for (layer, outcome) in &outcomes { + if outcome.findings.is_empty() { + (layer.sink)(PolicyObservation { + kind: PolicyObservationKind::Checked, + policy: layer.policy.name().to_string(), + policy_digest: layer.policy.fingerprint().to_string(), + boundary, + subject: subject.to_string(), + subject_digest: subject_digest.clone(), + rule: format!("{}.checked", boundary.as_str()), + label: None, + count: None, + action: None, + reason: None, + source, + agent_id: agent_id.clone(), + }); + continue; + } + for finding in &outcome.findings { + let kind = match effective_action { + sema_policy::ContentAction::Block => PolicyObservationKind::Violation, + sema_policy::ContentAction::Redact => PolicyObservationKind::Redacted, + sema_policy::ContentAction::Audit => PolicyObservationKind::Flagged, + sema_policy::ContentAction::Allow => PolicyObservationKind::Checked, + }; + (layer.sink)(PolicyObservation { + kind, + policy: layer.policy.name().to_string(), + policy_digest: layer.policy.fingerprint().to_string(), + boundary, + subject: subject.to_string(), + subject_digest: subject_digest.clone(), + rule: finding.rule_id.clone(), + label: Some(finding.label.clone()), + count: Some(finding.count), + action: Some(effective_action.as_str().to_string()), + reason: (effective_action == sema_policy::ContentAction::Block) + .then(|| "deterministic content policy matched".to_string()), + source, + agent_id: agent_id.clone(), + }); + } + } + + match effective_action { + sema_policy::ContentAction::Block => { + let rule = outcomes + .iter() + .flat_map(|(_, outcome)| &outcome.findings) + .next() + .map_or("content.denied", |finding| finding.rule_id.as_str()); + Err(policy_denied(boundary, subject, rule)) + } + sema_policy::ContentAction::Redact => { + let redactions = outcomes + .iter() + .flat_map(|(_, outcome)| outcome.redactions.iter().cloned()) + .collect::>(); + Ok(sema_policy::content::redact(text, &redactions)) + } + sema_policy::ContentAction::Allow | sema_policy::ContentAction::Audit => { + Ok(text.to_string()) + } + } +} + +fn apply_input_policy_to_request(request: &mut ChatRequest) -> Result<(), SemaError> { + let mut system = request.system.clone(); + if let Some(value) = &mut system { + *value = apply_text_policy( + value, + PolicyBoundary::LlmInput, + "system", + PolicySource::Request, + None, + )?; + } + let mut messages = request.messages.clone(); + for (message_index, message) in messages.iter_mut().enumerate() { + let subject = format!("message.{message_index}.{}", message.role); + match &mut message.content { + MessageContent::Text(text) => { + *text = apply_text_policy( + text, + PolicyBoundary::LlmInput, + &subject, + PolicySource::Request, + None, + )?; + } + MessageContent::Blocks(blocks) => { + for (block_index, block) in blocks.iter_mut().enumerate() { + if let ContentBlock::Text { text } = block { + *text = apply_text_policy( + text, + PolicyBoundary::LlmInput, + &format!("{subject}.block.{block_index}"), + PolicySource::Request, + None, + )?; + } + } + } + } + } + request.system = system; + request.messages = messages; + Ok(()) +} + +fn apply_output_policy_to_response( + response: &mut ChatResponse, + source: PolicySource, +) -> Result<(), SemaError> { + let stage = if response.tool_calls.is_empty() { + sema_policy::OutputStage::Final + } else { + sema_policy::OutputStage::Round + }; + let subject = match stage { + sema_policy::OutputStage::Round => "assistant.round", + sema_policy::OutputStage::Final => "assistant.final", + }; + response.content = apply_text_policy( + &response.content, + PolicyBoundary::LlmOutput, + subject, + source, + Some(stage), + )?; + Ok(()) +} + /// Clear the per-thread last-usage slot. The workflow runtime calls this at the START /// of each agent leaf so that [`last_usage_snapshot`] read afterwards reflects ONLY a /// completion this leaf made — a leaf whose call fails (or makes none) reports `None` @@ -5564,6 +5803,21 @@ pub fn register_llm_builtins(env: &Env, sandbox: &sema_core::Sandbox) { Ok(t.parameters.clone()) }); + register_fn(env, "tool/policy-subjects", |args| { + if args.len() != 1 { + return Err(SemaError::arity("tool/policy-subjects", "1", args.len())); + } + let tool = args[0] + .as_tool_def_rc() + .ok_or_else(|| SemaError::type_error("tool", args[0].type_name()))?; + Ok(Value::vector( + tool.policy_subjects + .iter() + .map(tool_policy_subject_to_value) + .collect(), + )) + }); + // (agent {:system "…" :tools […] :model "…" :max-turns N}) — build an anonymous, // reusable actor value (system prompt + tools + model + max-turns) without binding // it. The named form is `defagent`; this is the plain constructor used inline (e.g. @@ -7168,7 +7422,7 @@ pub fn register_llm_builtins(env: &Env, sandbox: &sema_core::Sandbox) { // JSON-coerce the arguments (lossily) so a direct invocation hands the // handler exactly what an agent-driven tool call would. let json_args = sema_core::value_to_json_lossy(&args[1]); - enforce_direct_tool_policy(&tool_def.name, &json_args)?; + enforce_direct_tool_policy(&tool_def.name, &json_args, &tool_def.policy_subjects)?; let handler_args = json_args_to_sema(&tool_def.parameters, &json_args, &tool_def.handler); Box::new(ToolInvokeContinuation { tool_name: tool_def.name.clone(), @@ -7829,7 +8083,8 @@ fn apply_call_telemetry_agent(span: &sema_otel::AgentSpan) { }); } -fn do_complete(request: ChatRequest) -> Result { +fn do_complete(mut request: ChatRequest) -> Result { + apply_input_policy_to_request(&mut request)?; // Standalone completions get their own conversation id so every chat span carries // gen_ai.conversation.id; agent-nested completions inherit the agent's scope. let _conv = if sema_otel::current_conversation_id().is_none() { @@ -7891,7 +8146,8 @@ fn do_complete(request: ChatRequest) -> Result { // A cache hit makes no provider call: no tokens are consumed and no money // is spent. Report ZERO usage so the caller's `track_usage` does not // re-charge session cost or burn the budget for a cached response. - let resp = cache_hit_response(cached, key_request.model.clone()); + let mut resp = cache_hit_response(cached, key_request.model.clone()); + apply_output_policy_to_response(&mut resp, PolicySource::Cache)?; // Cache-hit span: no provider served it; tag gen_ai.cache.hit=true with // zero usage (matches the zero-usage accounting invariant). span.set_dispatch("", &resp.model); @@ -9457,7 +9713,13 @@ fn run_completion( span: &sema_otel::LlmSpan, ) -> Result { if current_cassette_scope().is_none() { - return do_complete_inner(request, span); + let mut response = do_complete_inner(request.clone(), span)?; + if let Err(error) = apply_output_policy_to_response(&mut response, PolicySource::Request) { + track_usage(&response.usage)?; + return Err(error); + } + set_guarded_response_telemetry(span, &request, "", &response); + return Ok(response); } // Key by the request as-is (no default-model resolution) so record and replay // produce the same key for an identical call, even with no provider configured @@ -9470,14 +9732,19 @@ fn run_completion( // A replayed call is a stand-in for a real one: emit the span with the // recorded facts and let the caller's usage/cost accounting run on the // recorded tokens (distinct from a cache hit, which reports zero usage). - let resp = entry.to_response(); - span.set_dispatch("cassette", &resp.model); - span.set_response(&response_facts("cassette", &resp)); - Ok(resp) + let mut response = entry.to_response(); + apply_output_policy_to_response(&mut response, PolicySource::Cassette)?; + set_guarded_response_telemetry(span, &request, "cassette", &response); + Ok(response) } crate::cassette::Decision::Miss(k) => Err(cassette_miss_error(&k)), crate::cassette::Decision::Record => { - let resp = do_complete_inner(request, span)?; + let mut resp = do_complete_inner(request.clone(), span)?; + if let Err(error) = apply_output_policy_to_response(&mut resp, PolicySource::Request) { + track_usage(&resp.usage)?; + return Err(error); + } + set_guarded_response_telemetry(span, &request, "", &resp); let provider = LAST_SERVING_PROVIDER.with(|p| p.borrow().clone().unwrap_or_default()); cassette_record(crate::cassette::TapeEntry::from_response( &key, &provider, &resp, @@ -9487,6 +9754,30 @@ fn run_completion( } } +fn set_guarded_response_telemetry( + span: &sema_otel::LlmSpan, + request: &ChatRequest, + provider_override: &str, + response: &ChatResponse, +) { + let provider = if provider_override.is_empty() { + LAST_SERVING_PROVIDER.with(|provider| provider.borrow().clone().unwrap_or_default()) + } else { + provider_override.to_string() + }; + span.set_dispatch(&provider, &response.model); + span.set_response(&response_facts(&provider, response)); + span.set_messages( + &messages_json(&request.messages), + &content_json("assistant", &response.content), + request + .system + .as_deref() + .map(|system| content_json("system", system)) + .as_deref(), + ); +} + /// The hard error raised on a `:replay`-mode cassette miss (no recorded interaction /// for this request). Shared by the complete, stream, and embed seams. fn cassette_miss_error(key: &str) -> SemaError { @@ -10333,16 +10624,6 @@ fn do_complete_with_provider( // Provider + model + response are all in scope here, before track_usage // consumes the serving-provider stamp. span.set_dispatch(&entry.provider, &request.model); - span.set_response(&response_facts(&entry.provider, &resp)); - span.set_messages( - &messages_json(&request.messages), - &content_json("assistant", &resp.content), - request - .system - .as_deref() - .map(|s| content_json("system", s)) - .as_deref(), - ); Ok(Some(resp)) }) } @@ -10549,16 +10830,6 @@ fn do_complete_uncached( set_serving_provider(p.name()); // Capture provider/model/response before track_usage consumes the stamp. span.set_dispatch(p.name(), &request.model); - span.set_response(&response_facts(p.name(), &resp)); - span.set_messages( - &messages_json(&request.messages), - &content_json("assistant", &resp.content), - request - .system - .as_deref() - .map(|s| content_json("system", s)) - .as_deref(), - ); Ok(resp) }) } @@ -10669,6 +10940,40 @@ fn build_tool_schemas(tools: &[Value]) -> Result, SemaError> { Ok(schemas) } +fn tool_policy_subject_to_value(subject: &sema_core::ToolPolicySubject) -> Value { + let mut map = BTreeMap::new(); + match subject { + sema_core::ToolPolicySubject::File { access, path_arg } => { + let kind = match access { + sema_core::FileAccess::Read => "file-read", + sema_core::FileAccess::Write => "file-write", + sema_core::FileAccess::Delete => "file-delete", + }; + map.insert(Value::keyword("kind"), Value::keyword(kind)); + map.insert(Value::keyword("path-arg"), Value::keyword(path_arg)); + } + sema_core::ToolPolicySubject::NetworkRequest { method, url_arg } => { + map.insert(Value::keyword("kind"), Value::keyword("network-request")); + map.insert(Value::keyword("url-arg"), Value::keyword(url_arg)); + if let Some(method) = method { + map.insert(Value::keyword("method"), Value::string(method)); + } + } + sema_core::ToolPolicySubject::Command { command_arg } => { + map.insert(Value::keyword("kind"), Value::keyword("command")); + map.insert(Value::keyword("command-arg"), Value::keyword(command_arg)); + } + sema_core::ToolPolicySubject::ExternalAction { action, target_arg } => { + map.insert(Value::keyword("kind"), Value::keyword("external-action")); + map.insert(Value::keyword("action"), Value::keyword(action)); + if let Some(target_arg) = target_arg { + map.insert(Value::keyword("target-arg"), Value::keyword(target_arg)); + } + } + } + Value::map(map) +} + /// Convert a Sema schema map into a JSON Schema object for the LLM API. fn sema_value_to_json_schema(val: &Value) -> serde_json::Value { if let Some(map) = val.as_map_rc() { @@ -11483,7 +11788,7 @@ fn agent_exec_tools(ctx: &EvalContext, token: u64) -> sema_core::runtime::Native let pending = std::mem::take(&mut st.pending_tool_calls); Ok::<_, SemaError>((pending, st.tools.clone(), st.on_tool_call.clone())) })?; - let denied = preflight_tool_calls(&pending)?; + let denied = preflight_tool_calls(&pending, &tools)?; // Cooperative runtime path (Task 04/06): a tool handler may SUSPEND (e.g. // `mcp/call`'s runtime external wait, or an `async/await` inside the handler), @@ -13214,7 +13519,7 @@ fn run_tool_loop( // Gate the entire batch before any callback, validation predicate, or handler. // A hard denial aborts the round with zero tool side effects; `:tool-error` // denials become correlated tool results while allowed siblings may proceed. - let denied = preflight_tool_calls(&response.tool_calls)?; + let denied = preflight_tool_calls(&response.tool_calls, tools)?; // Echo the assistant turn that invoked the tools, carrying the tool_calls // so the provider can correlate the tool results that follow. This MUST be diff --git a/crates/sema-mcp/src/builtins.rs b/crates/sema-mcp/src/builtins.rs index f4801eb6..36226cd2 100644 --- a/crates/sema-mcp/src/builtins.rs +++ b/crates/sema-mcp/src/builtins.rs @@ -2493,6 +2493,7 @@ fn tool_defs_to_value( name: tool.name, description: tool.description, parameters, + policy_subjects: Vec::new(), handler, })); } diff --git a/crates/sema-policy/Cargo.toml b/crates/sema-policy/Cargo.toml index 7803b4ac..0b852a43 100644 --- a/crates/sema-policy/Cargo.toml +++ b/crates/sema-policy/Cargo.toml @@ -10,6 +10,7 @@ description = "Deterministic policy compiler and matcher for Sema workflows" [dependencies] sema-core.workspace = true globset.workspace = true +regex.workspace = true serde_json.workspace = true sha2.workspace = true thiserror.workspace = true diff --git a/crates/sema-policy/src/content.rs b/crates/sema-policy/src/content.rs new file mode 100644 index 00000000..7cdb1154 --- /dev/null +++ b/crates/sema-policy/src/content.rs @@ -0,0 +1,306 @@ +//! Shared deterministic secret and personal-data scanners. + +use regex::Regex; +use std::collections::BTreeMap; +use std::sync::OnceLock; + +/// Maximum text size accepted by policy content scanners. +pub const INPUT_BYTE_CAP: usize = 16 * 1024 * 1024; + +/// A deterministic detector exposed by the policy DSL. +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] +pub enum DetectorKind { + Secret, + Email, + Phone, + Ipv4, + PaymentCard, +} + +impl DetectorKind { + pub fn as_str(self) -> &'static str { + match self { + Self::Secret => "secret", + Self::Email => "email", + Self::Phone => "phone", + Self::Ipv4 => "ipv4", + Self::PaymentCard => "payment-card", + } + } +} + +/// One private scanner finding. Callers must not serialize the matched span. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Finding { + pub label: &'static str, + pub start: usize, + pub end: usize, +} + +/// Scan one detector family and return non-overlapping byte spans. +pub fn scan(text: &str, detector: DetectorKind) -> Vec { + match detector { + DetectorKind::Secret => detect_secrets(text), + DetectorKind::Email => detect_regex(text, "email", email_re()), + DetectorKind::Phone => detect_regex(text, "phone", phone_re()), + DetectorKind::Ipv4 => detect_regex(text, "ipv4", ipv4_re()), + DetectorKind::PaymentCard => detect_payment_cards(text), + } +} + +/// Scan the public PII detector set used by `pii/detect`. +pub fn detect_pii(text: &str) -> Vec { + merge_findings( + [DetectorKind::Email, DetectorKind::Ipv4, DetectorKind::Phone] + .into_iter() + .flat_map(|detector| scan(text, detector)), + ) +} + +/// Run all deterministic secret matchers. +pub fn detect_secrets(text: &str) -> Vec { + let mut findings = Vec::new(); + for (regex, label) in [ + (aws_re(), "aws-access-key"), + (private_key_re(), "private-key"), + (jwt_re(), "jwt"), + (slack_re(), "slack-token"), + (github_re(), "github-token"), + ] { + for matched in regex.find_iter(text) { + push_if_free(&mut findings, label, matched.start(), matched.end()); + } + } + for captures in generic_re().captures_iter(text) { + let whole = captures + .get(0) + .expect("generic secret regex has whole match"); + let value = captures + .get(2) + .expect("generic secret regex has value capture"); + if shannon_entropy(value.as_str()) >= ENTROPY_THRESHOLD { + push_if_free(&mut findings, "api-key", whole.start(), whole.end()); + } + } + for matched in high_entropy_re().find_iter(text) { + if shannon_entropy(matched.as_str()) >= ENTROPY_THRESHOLD { + push_if_free( + &mut findings, + "high-entropy", + matched.start(), + matched.end(), + ); + } + } + findings.sort_by_key(|finding| finding.start); + findings +} + +/// Replace findings right-to-left with deterministic typed markers. +pub fn redact(text: &str, findings: &[Finding]) -> String { + let mut findings = findings.to_vec(); + findings.sort_by_key(|finding| finding.start); + let mut accepted = Vec::new(); + let mut last_end = 0; + for finding in findings { + if finding.start >= last_end { + last_end = finding.end; + accepted.push(finding); + } + } + let mut output = text.to_string(); + for finding in accepted.into_iter().rev() { + output.replace_range( + finding.start..finding.end, + &format!("«redacted:{}»", finding.label), + ); + } + output +} + +fn detect_regex(text: &str, label: &'static str, regex: &Regex) -> Vec { + regex + .find_iter(text) + .map(|matched| Finding { + label, + start: matched.start(), + end: matched.end(), + }) + .collect() +} + +fn detect_payment_cards(text: &str) -> Vec { + payment_card_re() + .find_iter(text) + .filter(|matched| { + let digits: String = matched + .as_str() + .chars() + .filter(char::is_ascii_digit) + .collect(); + (13..=19).contains(&digits.len()) && luhn_valid(&digits) + }) + .map(|matched| Finding { + label: "payment-card", + start: matched.start(), + end: matched.end(), + }) + .collect() +} + +fn luhn_valid(digits: &str) -> bool { + let sum: u32 = digits + .bytes() + .rev() + .enumerate() + .map(|(index, byte)| { + let mut digit = u32::from(byte - b'0'); + if index % 2 == 1 { + digit *= 2; + if digit > 9 { + digit -= 9; + } + } + digit + }) + .sum(); + sum % 10 == 0 +} + +fn merge_findings(findings: impl IntoIterator) -> Vec { + let mut merged = Vec::new(); + for finding in findings { + push_if_free(&mut merged, finding.label, finding.start, finding.end); + } + merged.sort_by_key(|finding| finding.start); + merged +} + +fn push_if_free(findings: &mut Vec, label: &'static str, start: usize, end: usize) { + if findings + .iter() + .any(|finding| start < finding.end && finding.start < end) + { + return; + } + findings.push(Finding { label, start, end }); +} + +fn shannon_entropy(value: &str) -> f64 { + if value.is_empty() { + return 0.0; + } + let mut counts = BTreeMap::new(); + for character in value.chars() { + *counts.entry(character).or_insert(0usize) += 1; + } + let length = value.chars().count() as f64; + counts.values().fold(0.0, |entropy, count| { + let probability = *count as f64 / length; + entropy - probability * probability.log2() + }) +} + +const ENTROPY_THRESHOLD: f64 = 3.5; + +fn aws_re() -> &'static Regex { + static REGEX: OnceLock = OnceLock::new(); + REGEX.get_or_init(|| Regex::new(r"AKIA[0-9A-Z]{16}").expect("valid AWS regex")) +} + +fn generic_re() -> &'static Regex { + static REGEX: OnceLock = OnceLock::new(); + REGEX.get_or_init(|| { + Regex::new(r#"(?i)(api[_-]?key|secret|token|password)\s*[:=]\s*['"]?([A-Za-z0-9_\-]{16,})"#) + .expect("valid generic secret regex") + }) +} + +fn private_key_re() -> &'static Regex { + static REGEX: OnceLock = OnceLock::new(); + REGEX.get_or_init(|| { + Regex::new(r"-----BEGIN [A-Z ]*PRIVATE KEY-----").expect("valid private-key regex") + }) +} + +fn jwt_re() -> &'static Regex { + static REGEX: OnceLock = OnceLock::new(); + REGEX.get_or_init(|| { + Regex::new(r"eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+").expect("valid JWT regex") + }) +} + +fn slack_re() -> &'static Regex { + static REGEX: OnceLock = OnceLock::new(); + REGEX.get_or_init(|| Regex::new(r"xox[baprs]-[A-Za-z0-9-]+").expect("valid Slack regex")) +} + +fn github_re() -> &'static Regex { + static REGEX: OnceLock = OnceLock::new(); + REGEX.get_or_init(|| { + Regex::new(r"gh[pousr]_[A-Za-z0-9]{36,}").expect("valid GitHub token regex") + }) +} + +fn high_entropy_re() -> &'static Regex { + static REGEX: OnceLock = OnceLock::new(); + REGEX.get_or_init(|| Regex::new(r"[A-Za-z0-9+/=_\-]{32,}").expect("valid high-entropy regex")) +} + +fn email_re() -> &'static Regex { + static REGEX: OnceLock = OnceLock::new(); + REGEX.get_or_init(|| { + Regex::new(r"[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}").expect("valid email regex") + }) +} + +fn ipv4_re() -> &'static Regex { + static REGEX: OnceLock = OnceLock::new(); + REGEX.get_or_init(|| { + Regex::new( + r"\b(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\b", + ) + .expect("valid IPv4 regex") + }) +} + +fn phone_re() -> &'static Regex { + static REGEX: OnceLock = OnceLock::new(); + REGEX.get_or_init(|| { + Regex::new(r"(?:\+?1[\s.\-]?)?\(?\d{3}\)?[\s.\-]?\d{3}[\s.\-]?\d{4}") + .expect("valid phone regex") + }) +} + +fn payment_card_re() -> &'static Regex { + static REGEX: OnceLock = OnceLock::new(); + REGEX.get_or_init(|| { + Regex::new(r"\b(?:[0-9][ -]?){12,18}[0-9]\b").expect("valid payment-card regex") + }) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn payment_cards_require_luhn_validation() { + assert_eq!( + scan("card 4111 1111 1111 1111", DetectorKind::PaymentCard).len(), + 1 + ); + assert!(scan("card 4111 1111 1111 1112", DetectorKind::PaymentCard).is_empty()); + } + + #[test] + fn redaction_is_typed_and_idempotent() { + let text = "contact me@example.com"; + let findings = scan(text, DetectorKind::Email); + let redacted = redact(text, &findings); + assert_eq!(redacted, "contact «redacted:email»"); + assert_eq!( + redact(&redacted, &scan(&redacted, DetectorKind::Email)), + redacted + ); + } +} diff --git a/crates/sema-policy/src/lib.rs b/crates/sema-policy/src/lib.rs index fdab675c..9e2b6a33 100644 --- a/crates/sema-policy/src/lib.rs +++ b/crates/sema-policy/src/lib.rs @@ -5,8 +5,11 @@ //! model-supplied tool arguments, and returns decisions for the workflow/LLM //! integration layers to enforce and journal. +pub mod content; + use globset::{GlobBuilder, GlobMatcher}; -use sema_core::Value; +use regex::Regex; +use sema_core::{FileAccess, ToolPolicySubject, Value}; use sha2::{Digest, Sha256}; use std::collections::{BTreeMap, BTreeSet}; use std::path::{Component, Path, PathBuf}; @@ -69,6 +72,62 @@ impl PolicyCheck { } } +/// Strictness lattice for deterministic content findings. +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] +pub enum ContentAction { + Allow, + Audit, + Redact, + Block, +} + +impl ContentAction { + pub fn as_str(self) -> &'static str { + match self { + Self::Allow => "allow", + Self::Audit => "audit", + Self::Redact => "redact", + Self::Block => "block", + } + } +} + +/// Whether output validation is running on an intermediate tool-call round or +/// the terminal assistant response. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum OutputStage { + Round, + Final, +} + +/// Safe, aggregate content finding. It contains no matched text or byte offsets. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct PolicyFinding { + pub rule_id: String, + pub label: String, + pub action: ContentAction, + pub count: usize, +} + +/// Result of evaluating one policy layer against one original text value. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ContentOutcome { + pub action: ContentAction, + pub findings: Vec, + /// Private transformation data for the enforcement layer; never journal it. + pub redactions: Vec, +} + +impl ContentOutcome { + fn allow() -> Self { + Self { + action: ContentAction::Allow, + findings: Vec::new(), + redactions: Vec::new(), + } + } +} + /// One compiled, named policy layer. #[derive(Debug)] pub struct CompiledPolicy { @@ -76,6 +135,9 @@ pub struct CompiledPolicy { fingerprint: String, models: Option, tools: Option, + subjects: Option, + input: Option, + output: Option, } impl CompiledPolicy { @@ -84,7 +146,15 @@ impl CompiledPolicy { let map = require_map(value, "policy")?; reject_unknown_keys( map, - &["__policy-name", "__policy-version", "models", "tools"], + &[ + "__policy-name", + "__policy-version", + "models", + "tools", + "subjects", + "input", + "output", + ], "policy", )?; @@ -108,6 +178,13 @@ impl CompiledPolicy { let models = get(map, "models").map(ModelPolicy::compile).transpose()?; let tools = get(map, "tools").map(ToolPolicy::compile).transpose()?; + let subjects = get(map, "subjects") + .map(SubjectPolicy::compile) + .transpose()?; + let input = get(map, "input") + .map(|value| DetectorPolicy::compile(value, ":input", true)) + .transpose()?; + let output = get(map, "output").map(OutputPolicy::compile).transpose()?; let fingerprint = fingerprint(value, &name); Ok(Self { @@ -115,6 +192,9 @@ impl CompiledPolicy { fingerprint, models, tools, + subjects, + input, + output, }) } @@ -152,13 +232,41 @@ impl CompiledPolicy { &self, tool: &str, arguments: &serde_json::Value, + policy_subjects: &[ToolPolicySubject], workspace_root: &Path, ) -> PolicyCheck { - self.tools.as_ref().map_or_else( + let named = self.tools.as_ref().map_or_else( || PolicyCheck::allow("tools.unrestricted"), |policy| policy.check(tool, arguments, workspace_root), + ); + if !named.allowed { + return named; + } + self.subjects.as_ref().map_or_else( + || PolicyCheck::allow("subjects.unrestricted"), + |policy| policy.check(policy_subjects, arguments, workspace_root), ) } + + pub fn has_input_policy(&self) -> bool { + self.input.is_some() + } + + pub fn has_output_policy(&self) -> bool { + self.output.is_some() + } + + pub fn check_input(&self, text: &str) -> ContentOutcome { + self.input + .as_ref() + .map_or_else(ContentOutcome::allow, |policy| policy.check(text)) + } + + pub fn check_output(&self, text: &str, stage: OutputStage) -> ContentOutcome { + self.output + .as_ref() + .map_or_else(ContentOutcome::allow, |policy| policy.check(text, stage)) + } } #[derive(Debug)] @@ -256,6 +364,472 @@ impl ModelPattern { } } +#[derive(Debug)] +struct DetectorPolicy { + rules: Vec<(content::DetectorKind, ContentAction)>, + rule_prefix: &'static str, +} + +impl DetectorPolicy { + fn compile(value: &Value, context: &'static str, input: bool) -> Result { + let map = require_map(value, context)?; + reject_unknown_keys(map, &["detect", "actions"], context)?; + Self::compile_from_map(map, context, input) + } + + fn compile_from_map( + map: &BTreeMap, + context: &'static str, + input: bool, + ) -> Result { + let detectors = parse_detectors(get(map, "detect"), &format!("{context} :detect"))?; + let actions = match get(map, "actions") { + None => BTreeMap::new(), + Some(value) => { + let action_map = require_map(value, &format!("{context} :actions"))?; + let mut actions = BTreeMap::new(); + for (key, value) in action_map { + let detector = parse_detector(key, &format!("{context} :actions"))?; + if !detectors.contains(&detector) { + return Err(invalid(format!( + "{context} :actions key :{} is not declared in :detect", + detector.as_str() + ))); + } + let action = parse_content_action(value, &format!("{context} :actions"))?; + if action == ContentAction::Allow { + return Err(invalid(format!( + "{context} detector actions must be :audit, :redact, or :block" + ))); + } + actions.insert(detector, action); + } + actions + } + }; + Ok(Self { + rules: detectors + .into_iter() + .map(|detector| { + let action = actions + .get(&detector) + .copied() + .unwrap_or(ContentAction::Block); + (detector, action) + }) + .collect(), + rule_prefix: if input { + "input.detect" + } else { + "output.detect" + }, + }) + } + + fn check(&self, text: &str) -> ContentOutcome { + let mut outcome = ContentOutcome::allow(); + for (detector, action) in &self.rules { + let findings = content::scan(text, *detector); + if findings.is_empty() { + continue; + } + outcome.action = outcome.action.max(*action); + let mut counts = BTreeMap::new(); + for finding in &findings { + *counts.entry(finding.label).or_insert(0usize) += 1; + } + outcome + .findings + .extend(counts.into_iter().map(|(label, count)| PolicyFinding { + rule_id: format!("{}.{}", self.rule_prefix, detector.as_str()), + label: label.to_string(), + action: *action, + count, + })); + if *action == ContentAction::Redact { + outcome.redactions.extend(findings); + } + } + outcome + } +} + +#[derive(Debug)] +struct OutputPolicy { + detectors: DetectorPolicy, + schema: Option, + required: BTreeSet, + max_length: Option, + forbid: Vec, + action: ContentAction, +} + +impl OutputPolicy { + fn compile(value: &Value) -> Result { + let map = require_map(value, ":output")?; + reject_unknown_keys( + map, + &[ + "detect", + "actions", + "schema", + "require", + "max-length", + "forbid", + "action", + ], + ":output", + )?; + let action = get(map, "action") + .map(|value| parse_content_action(value, ":output :action")) + .transpose()? + .unwrap_or(ContentAction::Block); + if !matches!(action, ContentAction::Audit | ContentAction::Block) { + return Err(invalid( + ":output :action must be :audit or :block; only detector spans may be redacted", + )); + } + let max_length = get(map, "max-length") + .map(|value| { + value + .as_int() + .and_then(|value| usize::try_from(value).ok()) + .filter(|value| *value > 0) + .ok_or_else(|| invalid(":output :max-length must be a positive integer")) + }) + .transpose()?; + Ok(Self { + detectors: DetectorPolicy::compile_from_map(map, ":output", false)?, + schema: get(map, "schema").map(OutputSchema::compile).transpose()?, + required: parse_name_set(get(map, "require"), ":output :require")?, + max_length, + forbid: parse_forbid_rules(get(map, "forbid"))?, + action, + }) + } + + fn check(&self, text: &str, stage: OutputStage) -> ContentOutcome { + let mut outcome = self.detectors.check(text); + for rule in &self.forbid { + let count = rule.count(text); + if count == 0 { + continue; + } + outcome.action = outcome.action.max(self.action); + outcome.findings.push(PolicyFinding { + rule_id: format!("output.forbid.{}", rule.id), + label: rule.id.clone(), + action: self.action, + count, + }); + } + if stage == OutputStage::Round { + return outcome; + } + + if self + .max_length + .is_some_and(|maximum| text.chars().count() > maximum) + { + push_structural_finding(&mut outcome, "output.max-length", "max-length", self.action); + } + + if self.schema.is_none() && self.required.is_empty() { + return outcome; + } + let parsed = match serde_json::from_str::(text) { + Ok(parsed) => parsed, + Err(_) => { + push_structural_finding( + &mut outcome, + "output.schema.json", + "invalid-json", + self.action, + ); + return outcome; + } + }; + if let Some(schema) = &self.schema { + for finding in schema.validate(&parsed) { + push_structural_finding( + &mut outcome, + &format!("output.schema.{finding}"), + &finding, + self.action, + ); + } + } + let Some(object) = parsed.as_object() else { + if !self.required.is_empty() { + push_structural_finding( + &mut outcome, + "output.require.object", + "required-fields", + self.action, + ); + } + return outcome; + }; + for key in &self.required { + if object.get(key).is_none_or(is_empty_json) { + push_structural_finding( + &mut outcome, + &format!("output.require.{key}"), + key, + self.action, + ); + } + } + outcome + } +} + +fn push_structural_finding( + outcome: &mut ContentOutcome, + rule_id: &str, + label: &str, + action: ContentAction, +) { + outcome.action = outcome.action.max(action); + outcome.findings.push(PolicyFinding { + rule_id: rule_id.to_string(), + label: label.to_string(), + action, + count: 1, + }); +} + +#[derive(Debug)] +struct ForbidRule { + id: String, + matcher: ForbidMatcher, +} + +impl ForbidRule { + fn compile(value: &Value, index: usize) -> Result { + let context = format!(":output :forbid[{index}]"); + let map = require_map(value, &context)?; + reject_unknown_keys(map, &["id", "contains", "regex"], &context)?; + let id = get(map, "id") + .and_then(value_name) + .filter(|id| !id.trim().is_empty()) + .ok_or_else(|| invalid(format!("{context} requires a nonempty :id")))?; + let contains = get(map, "contains").and_then(Value::as_str); + let regex = get(map, "regex").and_then(Value::as_str); + let matcher = match (contains, regex) { + (Some(literal), None) if !literal.is_empty() => { + ForbidMatcher::Contains(literal.to_string()) + } + (None, Some(pattern)) if !pattern.is_empty() => ForbidMatcher::Regex( + Regex::new(pattern) + .map_err(|error| invalid(format!("{context} invalid regex: {error}")))?, + ), + _ => { + return Err(invalid(format!( + "{context} requires exactly one nonempty :contains or :regex" + ))) + } + }; + Ok(Self { id, matcher }) + } + + fn count(&self, text: &str) -> usize { + match &self.matcher { + ForbidMatcher::Contains(literal) => text.match_indices(literal).count(), + ForbidMatcher::Regex(regex) => regex.find_iter(text).count(), + } + } +} + +#[derive(Debug)] +enum ForbidMatcher { + Contains(String), + Regex(Regex), +} + +fn parse_forbid_rules(value: Option<&Value>) -> Result, PolicyError> { + let Some(value) = value else { + return Ok(Vec::new()); + }; + let rules = require_seq(value, ":output :forbid")?; + let mut ids = BTreeSet::new(); + rules + .iter() + .enumerate() + .map(|(index, value)| { + let rule = ForbidRule::compile(value, index)?; + if !ids.insert(rule.id.clone()) { + return Err(invalid(format!( + ":output :forbid has duplicate :id {:?}", + rule.id + ))); + } + Ok(rule) + }) + .collect() +} + +#[derive(Debug)] +struct OutputSchema { + fields: BTreeMap, +} + +impl OutputSchema { + fn compile(value: &Value) -> Result { + let map = require_map(value, ":output :schema")?; + let mut fields = BTreeMap::new(); + for (key, value) in map { + let key = value_name(key) + .filter(|key| !key.is_empty()) + .ok_or_else(|| invalid(":output :schema field names must be names or strings"))?; + if fields + .insert(key.clone(), SchemaField::compile(value, &key)?) + .is_some() + { + return Err(invalid(format!( + ":output :schema has duplicate field {key:?}" + ))); + } + } + Ok(Self { fields }) + } + + fn validate(&self, value: &serde_json::Value) -> Vec { + let Some(object) = value.as_object() else { + return vec!["object".to_string()]; + }; + self.fields + .iter() + .filter_map(|(name, field)| match object.get(name) { + None if !field.optional => Some(format!("{name}.missing")), + Some(value) if !field.kind.matches(value) => Some(format!("{name}.type")), + _ => None, + }) + .collect() + } +} + +#[derive(Debug)] +struct SchemaField { + kind: SchemaKind, + optional: bool, +} + +impl SchemaField { + fn compile(value: &Value, name: &str) -> Result { + if let Some(kind) = value_name(value) { + return Ok(Self { + kind: SchemaKind::parse(&kind, name)?, + optional: false, + }); + } + let map = require_map(value, &format!(":output :schema field {name:?}"))?; + reject_unknown_keys( + map, + &["type", "optional"], + &format!(":output :schema field {name:?}"), + )?; + let kind = get(map, "type") + .and_then(value_name) + .ok_or_else(|| invalid(format!(":output :schema field {name:?} requires :type")))?; + let optional = get(map, "optional") + .map(|value| { + value.as_bool().ok_or_else(|| { + invalid(format!( + ":output :schema field {name:?} :optional must be boolean" + )) + }) + }) + .transpose()? + .unwrap_or(false); + Ok(Self { + kind: SchemaKind::parse(&kind, name)?, + optional, + }) + } +} + +#[derive(Debug)] +enum SchemaKind { + String, + Number, + Boolean, + List, +} + +impl SchemaKind { + fn parse(value: &str, name: &str) -> Result { + match value { + "string" => Ok(Self::String), + "number" => Ok(Self::Number), + "boolean" => Ok(Self::Boolean), + "list" | "array" => Ok(Self::List), + _ => Err(invalid(format!( + ":output :schema field {name:?} has unsupported type {value:?}" + ))), + } + } + + fn matches(&self, value: &serde_json::Value) -> bool { + match self { + Self::String => value.is_string(), + Self::Number => value.is_number(), + Self::Boolean => value.is_boolean(), + Self::List => value.is_array(), + } + } +} + +fn is_empty_json(value: &serde_json::Value) -> bool { + match value { + serde_json::Value::Null => true, + serde_json::Value::String(value) => value.trim().is_empty(), + serde_json::Value::Array(value) => value.is_empty(), + serde_json::Value::Object(value) => value.is_empty(), + serde_json::Value::Bool(_) | serde_json::Value::Number(_) => false, + } +} + +fn parse_detectors( + value: Option<&Value>, + context: &str, +) -> Result, PolicyError> { + let Some(value) = value else { + return Ok(BTreeSet::new()); + }; + require_seq(value, context)? + .iter() + .map(|value| parse_detector(value, context)) + .collect() +} + +fn parse_detector(value: &Value, context: &str) -> Result { + match value_name(value).as_deref() { + Some("secret") => Ok(content::DetectorKind::Secret), + Some("email") => Ok(content::DetectorKind::Email), + Some("phone") => Ok(content::DetectorKind::Phone), + Some("ipv4") => Ok(content::DetectorKind::Ipv4), + Some("payment-card") => Ok(content::DetectorKind::PaymentCard), + Some(other) => Err(invalid(format!( + "{context} has unsupported detector {other:?}" + ))), + None => Err(invalid(format!("{context} entries must be detector names"))), + } +} + +fn parse_content_action(value: &Value, context: &str) -> Result { + match value_name(value).as_deref() { + Some("allow") => Ok(ContentAction::Allow), + Some("audit") => Ok(ContentAction::Audit), + Some("redact") => Ok(ContentAction::Redact), + Some("block") => Ok(ContentAction::Block), + Some(other) => Err(invalid(format!( + "{context} action must be :audit, :redact, or :block, got {other:?}" + ))), + None => Err(invalid(format!("{context} action must be a name"))), + } +} + #[derive(Debug)] struct ToolPolicy { default: DefaultEffect, @@ -329,6 +903,310 @@ impl ToolPolicy { } } +#[derive(Debug)] +struct SubjectPolicy { + default: DefaultEffect, + allow: Vec, + deny: Vec, +} + +impl SubjectPolicy { + fn compile(value: &Value) -> Result { + let map = require_map(value, ":subjects")?; + reject_unknown_keys(map, &["default", "allow", "deny"], ":subjects")?; + Ok(Self { + default: parse_default(get(map, "default"), ":subjects")?, + allow: parse_subject_rules(get(map, "allow"), ":subjects :allow")?, + deny: parse_subject_rules(get(map, "deny"), ":subjects :deny")?, + }) + } + + fn check( + &self, + specs: &[ToolPolicySubject], + arguments: &serde_json::Value, + workspace_root: &Path, + ) -> PolicyCheck { + let Some(arguments) = arguments.as_object() else { + return PolicyCheck::deny("subjects.arguments", "tool arguments must be a JSON object"); + }; + if specs.is_empty() { + return match self.default { + DefaultEffect::Allow => PolicyCheck::allow("subjects.default-allow"), + DefaultEffect::Deny => { + PolicyCheck::deny("subjects.missing", "tool has no declared policy subjects") + } + }; + } + + for spec in specs { + let subject = match ResolvedSubject::resolve(spec, arguments) { + Ok(subject) => subject, + Err(reason) => { + return PolicyCheck::deny("subjects.arguments", reason); + } + }; + if self + .deny + .iter() + .any(|rule| rule.matches(&subject, workspace_root)) + { + return PolicyCheck::deny( + format!("subjects.{}.deny", subject.kind().as_str()), + format!( + "{} subject matches an explicit deny rule", + subject.kind().as_str() + ), + ); + } + if self + .allow + .iter() + .any(|rule| rule.matches(&subject, workspace_root)) + { + continue; + } + if self.default == DefaultEffect::Deny { + return PolicyCheck::deny( + format!("subjects.{}.default-deny", subject.kind().as_str()), + format!("{} subject is not allowlisted", subject.kind().as_str()), + ); + } + } + PolicyCheck::allow("subjects.allow") + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum SubjectKind { + FileRead, + FileWrite, + FileDelete, + NetworkRequest, + Command, + ExternalAction, +} + +impl SubjectKind { + fn parse(value: &Value, context: &str) -> Result { + match value_name(value).as_deref() { + Some("file-read") => Ok(Self::FileRead), + Some("file-write") => Ok(Self::FileWrite), + Some("file-delete") => Ok(Self::FileDelete), + Some("network-request") => Ok(Self::NetworkRequest), + Some("command") => Ok(Self::Command), + Some("external-action") => Ok(Self::ExternalAction), + Some(other) => Err(invalid(format!( + "{context} has unsupported :kind {other:?}" + ))), + None => Err(invalid(format!( + "{context} :kind must be a keyword or string" + ))), + } + } + + fn as_str(self) -> &'static str { + match self { + Self::FileRead => "file-read", + Self::FileWrite => "file-write", + Self::FileDelete => "file-delete", + Self::NetworkRequest => "network-request", + Self::Command => "command", + Self::ExternalAction => "external-action", + } + } +} + +#[derive(Debug)] +struct SubjectRule { + kind: SubjectKind, + constraint: Option, + methods: BTreeSet, + actions: BTreeSet, +} + +impl SubjectRule { + fn compile(value: &Value, context: &str) -> Result { + let map = require_map(value, context)?; + reject_unknown_keys( + map, + &["kind", "paths", "domains", "commands", "methods", "actions"], + context, + )?; + let kind = SubjectKind::parse( + get(map, "kind").ok_or_else(|| invalid(format!("{context} requires :kind")))?, + context, + )?; + let constraint = match kind { + SubjectKind::FileRead | SubjectKind::FileWrite | SubjectKind::FileDelete => { + get(map, "paths") + .map(|value| compile_subject_constraint(value, ConstraintKind::Path, context)) + .transpose()? + } + SubjectKind::NetworkRequest => get(map, "domains") + .map(|value| compile_subject_constraint(value, ConstraintKind::Domain, context)) + .transpose()?, + SubjectKind::Command => get(map, "commands") + .map(|value| compile_subject_constraint(value, ConstraintKind::Command, context)) + .transpose()?, + SubjectKind::ExternalAction => None, + }; + if kind != SubjectKind::NetworkRequest && get(map, "methods").is_some() { + return Err(invalid(format!( + "{context} :methods is valid only for :network-request" + ))); + } + if kind != SubjectKind::ExternalAction && get(map, "actions").is_some() { + return Err(invalid(format!( + "{context} :actions is valid only for :external-action" + ))); + } + Ok(Self { + kind, + constraint, + methods: parse_name_set(get(map, "methods"), &format!("{context} :methods"))? + .into_iter() + .map(|method| method.to_ascii_uppercase()) + .collect(), + actions: parse_name_set(get(map, "actions"), &format!("{context} :actions"))?, + }) + } + + fn matches(&self, subject: &ResolvedSubject, workspace_root: &Path) -> bool { + if self.kind != subject.kind() { + return false; + } + match subject { + ResolvedSubject::File { path, .. } => self + .constraint + .as_ref() + .is_none_or(|constraint| constraint.check(path, workspace_root).is_ok()), + ResolvedSubject::NetworkRequest { method, url } => { + (self.methods.is_empty() + || method + .as_deref() + .is_some_and(|method| self.methods.contains(method))) + && self + .constraint + .as_ref() + .is_none_or(|constraint| constraint.check(url, workspace_root).is_ok()) + } + ResolvedSubject::Command(command) => self + .constraint + .as_ref() + .is_none_or(|constraint| constraint.check(command, workspace_root).is_ok()), + ResolvedSubject::ExternalAction { action, .. } => { + self.actions.is_empty() || self.actions.contains(action) + } + } + } +} + +#[derive(Debug)] +enum ResolvedSubject { + File { + kind: SubjectKind, + path: serde_json::Value, + }, + NetworkRequest { + method: Option, + url: serde_json::Value, + }, + Command(serde_json::Value), + ExternalAction { + action: String, + _target: Option, + }, +} + +impl ResolvedSubject { + fn resolve( + spec: &ToolPolicySubject, + arguments: &serde_json::Map, + ) -> Result { + let required = |name: &str| { + arguments + .get(name) + .cloned() + .ok_or_else(|| format!("required policy subject argument {name:?} is missing")) + }; + match spec { + ToolPolicySubject::File { access, path_arg } => Ok(Self::File { + kind: match access { + FileAccess::Read => SubjectKind::FileRead, + FileAccess::Write => SubjectKind::FileWrite, + FileAccess::Delete => SubjectKind::FileDelete, + }, + path: required(path_arg)?, + }), + ToolPolicySubject::NetworkRequest { method, url_arg } => Ok(Self::NetworkRequest { + method: method.as_ref().map(|method| method.to_ascii_uppercase()), + url: required(url_arg)?, + }), + ToolPolicySubject::Command { command_arg } => Ok(Self::Command(required(command_arg)?)), + ToolPolicySubject::ExternalAction { action, target_arg } => Ok(Self::ExternalAction { + action: action.clone(), + _target: target_arg.as_deref().map(required).transpose()?, + }), + } + } + + fn kind(&self) -> SubjectKind { + match self { + Self::File { kind, .. } => *kind, + Self::NetworkRequest { .. } => SubjectKind::NetworkRequest, + Self::Command(_) => SubjectKind::Command, + Self::ExternalAction { .. } => SubjectKind::ExternalAction, + } + } +} + +fn parse_subject_rules( + value: Option<&Value>, + context: &str, +) -> Result, PolicyError> { + let Some(value) = value else { + return Ok(Vec::new()); + }; + require_seq(value, context)? + .iter() + .enumerate() + .map(|(index, value)| SubjectRule::compile(value, &format!("{context}[{index}]"))) + .collect() +} + +fn compile_subject_constraint( + value: &Value, + kind: ConstraintKind, + context: &str, +) -> Result { + let selector = if let Some(map) = value.as_map_ref() { + map.clone() + } else { + let values = require_seq(value, context)?; + if !values.iter().all(|value| value.as_str().is_some()) { + return Err(invalid(format!( + "{context} constraint must be a selector map or string sequence" + ))); + } + shorthand_selector(&values) + }; + let allowed_keys: &[&str] = match kind { + ConstraintKind::Path | ConstraintKind::Command => &["allow", "deny"], + ConstraintKind::Domain => &["allow", "deny", "schemes", "ports"], + }; + reject_unknown_keys(&selector, allowed_keys, context)?; + match kind { + ConstraintKind::Path => PathConstraint::compile(&selector).map(CompiledConstraint::Path), + ConstraintKind::Domain => { + DomainConstraint::compile(&selector).map(CompiledConstraint::Domain) + } + ConstraintKind::Command => { + CommandConstraint::compile(&selector).map(CompiledConstraint::Command) + } + } +} + #[derive(Debug, Default)] struct ToolRule { constraints: Vec, @@ -899,6 +1777,19 @@ fn parse_string_set(value: Option<&Value>, context: &str) -> Result, context: &str) -> Result, PolicyError> { + let Some(value) = value else { + return Ok(BTreeSet::new()); + }; + require_seq(value, context)? + .iter() + .map(|value| { + value_name(value) + .ok_or_else(|| invalid(format!("{context} entries must be names or strings"))) + }) + .collect() +} + fn parse_string_list(value: Option<&Value>, context: &str) -> Result, PolicyError> { let Some(value) = value else { return Ok(Vec::new()); @@ -1039,12 +1930,149 @@ mod tests { assert_eq!(policy.model_action(), ModelDenyAction::Fail); assert!( !policy - .check_tool("read-file", &serde_json::json!({}), Path::new(".")) + .check_tool("read-file", &serde_json::json!({}), &[], Path::new(".")) .allowed ); assert_eq!(policy.tool_action(), ToolDenyAction::Fail); } + #[test] + fn semantic_subject_rules_use_declared_argument_mappings() { + let root = std::env::temp_dir().join(format!("sema-policy-subject-{}", std::process::id())); + fs::create_dir_all(root.join("src")).unwrap(); + let policy = CompiledPolicy::compile(&named_policy([( + "subjects", + map([( + "allow", + Value::vector(vec![map([ + ("kind", Value::keyword("file-read")), + ("paths", strings(&["src/**"])), + ])]), + )]), + )])) + .unwrap(); + let subjects = [ToolPolicySubject::File { + access: FileAccess::Read, + path_arg: "location".to_string(), + }]; + + assert!( + policy + .check_tool( + "arbitrary-name", + &serde_json::json!({"location":"src/lib.rs"}), + &subjects, + &root, + ) + .allowed + ); + assert!( + !policy + .check_tool( + "arbitrary-name", + &serde_json::json!({"location":"Cargo.toml"}), + &subjects, + &root, + ) + .allowed + ); + assert!( + !policy + .check_tool( + "arbitrary-name", + &serde_json::json!({"location":"src/lib.rs"}), + &[], + &root, + ) + .allowed + ); + let _ = fs::remove_dir_all(root); + } + + #[test] + fn input_detectors_compile_to_safe_aggregate_findings() { + let policy = CompiledPolicy::compile(&named_policy([( + "input", + map([ + ( + "detect", + Value::vector(vec![Value::keyword("secret"), Value::keyword("email")]), + ), + ( + "actions", + map([ + ("secret", Value::keyword("block")), + ("email", Value::keyword("redact")), + ]), + ), + ]), + )])) + .unwrap(); + let text = "send me@example.com and AKIAIOSFODNN7EXAMPLE"; + let outcome = policy.check_input(text); + + assert_eq!(outcome.action, ContentAction::Block); + assert!(outcome + .findings + .iter() + .all(|finding| !finding.label.contains('@'))); + assert_eq!( + content::redact(text, &outcome.redactions), + "send «redacted:email» and AKIAIOSFODNN7EXAMPLE" + ); + } + + #[test] + fn terminal_output_enforces_schema_required_length_and_patterns() { + let policy = CompiledPolicy::compile(&named_policy([( + "output", + map([ + ( + "schema", + map([ + ("answer", Value::keyword("string")), + ( + "citations", + map([ + ("type", Value::keyword("list")), + ("optional", Value::bool(true)), + ]), + ), + ]), + ), + ("require", Value::vector(vec![Value::keyword("citations")])), + ("max-length", Value::int(120)), + ( + "forbid", + Value::vector(vec![map([ + ("id", Value::keyword("absolute")), + ("contains", Value::string("guaranteed")), + ])]), + ), + ]), + )])) + .unwrap(); + + let round = policy.check_output("guaranteed", OutputStage::Round); + assert_eq!(round.action, ContentAction::Block); + let final_outcome = + policy.check_output(r#"{"answer":"ok","citations":[]}"#, OutputStage::Final); + assert_eq!(final_outcome.action, ContentAction::Block); + assert!(final_outcome + .findings + .iter() + .any(|finding| finding.rule_id == "output.require.citations")); + assert_eq!( + policy + .check_output( + r#"{"answer":"ok","citations":["source-1"]}"#, + OutputStage::Final, + ) + .action, + ContentAction::Allow + ); + } + #[test] fn unknown_keys_are_rejected_instead_of_being_ignored() { let error = CompiledPolicy::compile(&named_policy([( @@ -1087,6 +2115,7 @@ mod tests { .check_tool( "read-file", &serde_json::json!({"path":"../outside"}), + &[], Path::new(".") ) .allowed @@ -1135,12 +2164,12 @@ mod tests { .unwrap(); assert!( !policy - .check_tool("read-file", &serde_json::json!({}), Path::new(".")) + .check_tool("read-file", &serde_json::json!({}), &[], Path::new(".")) .allowed ); assert!( !policy - .check_tool("write-file", &serde_json::json!({}), Path::new(".")) + .check_tool("write-file", &serde_json::json!({}), &[], Path::new(".")) .allowed ); } @@ -1184,6 +2213,7 @@ mod tests { .check_tool( "read-file", &serde_json::json!({"path":"src/lib.rs"}), + &[], &root ) .allowed @@ -1193,6 +2223,7 @@ mod tests { .check_tool( "read-file", &serde_json::json!({"path":"Cargo.toml"}), + &[], &root ) .allowed @@ -1202,6 +2233,7 @@ mod tests { .check_tool( "copy-file", &serde_json::json!({"source":"src/lib.rs","destination":"tmp/lib.rs"}), + &[], &root ) .allowed @@ -1211,6 +2243,7 @@ mod tests { .check_tool( "copy-file", &serde_json::json!({"source":"src/lib.rs"}), + &[], &root ) .allowed diff --git a/crates/sema-stdlib/src/secret.rs b/crates/sema-stdlib/src/secret.rs index cf89252b..45485de3 100644 --- a/crates/sema-stdlib/src/secret.rs +++ b/crates/sema-stdlib/src/secret.rs @@ -25,10 +25,11 @@ //! shape. use std::collections::BTreeMap; -use std::sync::OnceLock; -use regex::Regex; use sema_core::{check_arity, SemaError, Value}; +use sema_policy::content::{ + detect_pii, detect_secrets, redact as redact_findings, Finding, INPUT_BYTE_CAP, +}; use sha2::{Digest, Sha256}; use crate::register_fn; @@ -42,7 +43,7 @@ use {crate::register_runtime_fn, sema_core::runtime::NativeOutcome}; /// ceiling (16 MiB) is tighter than `diff`'s — still far above any realistic /// credential-scan input. #[cfg(not(target_arch = "wasm32"))] -const SECRET_INPUT_BYTE_CAP: u64 = 16 * 1024 * 1024; +const SECRET_INPUT_BYTE_CAP: u64 = INPUT_BYTE_CAP as u64; #[cfg(not(target_arch = "wasm32"))] thread_local! { @@ -103,175 +104,10 @@ fn detect_pair_to_value(pair: (String, Vec)) -> Value { findings_to_list(&text, &findings) } -/// A single detected secret/PII finding. Offsets plus a `&'static str` kind, so -/// it is `Send` and can cross the offload thread boundary (no `Value`/`Env`). -struct Finding { - kind: &'static str, - start: usize, - end: usize, -} - -/// Shannon entropy in bits per character. Used to suppress low-entropy -/// (and therefore probably-not-secret) candidates for the generic and -/// high-entropy matchers. -fn shannon_entropy(s: &str) -> f64 { - if s.is_empty() { - return 0.0; - } - let mut counts: BTreeMap = BTreeMap::new(); - for c in s.chars() { - *counts.entry(c).or_insert(0) += 1; - } - let len = s.chars().count() as f64; - let mut entropy = 0.0; - for &count in counts.values() { - let p = count as f64 / len; - entropy -= p * p.log2(); - } - entropy -} - -/// Minimum bits/char of entropy for a generic or high-entropy candidate to be -/// treated as a real secret. -const ENTROPY_THRESHOLD: f64 = 3.5; - -fn aws_re() -> &'static Regex { - static RE: OnceLock = OnceLock::new(); - RE.get_or_init(|| Regex::new(r"AKIA[0-9A-Z]{16}").unwrap()) -} - -fn generic_re() -> &'static Regex { - static RE: OnceLock = OnceLock::new(); - // Capture group 2 is the secret value; the whole match (incl. the key and - // operator) is what we report/redact. - RE.get_or_init(|| { - Regex::new(r#"(?i)(api[_-]?key|secret|token|password)\s*[:=]\s*['"]?([A-Za-z0-9_\-]{16,})"#) - .unwrap() - }) -} - -fn private_key_re() -> &'static Regex { - static RE: OnceLock = OnceLock::new(); - RE.get_or_init(|| Regex::new(r"-----BEGIN [A-Z ]*PRIVATE KEY-----").unwrap()) -} - -fn jwt_re() -> &'static Regex { - static RE: OnceLock = OnceLock::new(); - RE.get_or_init(|| Regex::new(r"eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+").unwrap()) -} - -fn slack_re() -> &'static Regex { - static RE: OnceLock = OnceLock::new(); - RE.get_or_init(|| Regex::new(r"xox[baprs]-[A-Za-z0-9-]+").unwrap()) -} - -fn github_re() -> &'static Regex { - static RE: OnceLock = OnceLock::new(); - RE.get_or_init(|| Regex::new(r"gh[pousr]_[A-Za-z0-9]{36,}").unwrap()) -} - -fn high_entropy_re() -> &'static Regex { - static RE: OnceLock = OnceLock::new(); - // Long hex or base64-ish runs (>= 32 chars). Entropy gate applied after. - RE.get_or_init(|| Regex::new(r"[A-Za-z0-9+/=_\-]{32,}").unwrap()) -} - -fn email_re() -> &'static Regex { - static RE: OnceLock = OnceLock::new(); - RE.get_or_init(|| Regex::new(r"[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}").unwrap()) -} - -fn ipv4_re() -> &'static Regex { - static RE: OnceLock = OnceLock::new(); - // Octet 0-255 with word boundaries so we don't grab digits mid-number. - RE.get_or_init(|| { - Regex::new( - r"\b(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\b", - ) - .unwrap() - }) -} - -fn phone_re() -> &'static Regex { - static RE: OnceLock = OnceLock::new(); - // US-style: optional +1, optional separators, 3-3-4 grouping. - RE.get_or_init(|| { - Regex::new(r"(?:\+?1[\s.\-]?)?\(?\d{3}\)?[\s.\-]?\d{3}[\s.\-]?\d{4}").unwrap() - }) -} - -/// Push a finding only if it does not overlap an already-recorded one. Earlier -/// matchers (more specific patterns) win over the broad high-entropy matcher. -fn push_if_free(findings: &mut Vec, kind: &'static str, start: usize, end: usize) { - let overlaps = findings.iter().any(|f| start < f.end && f.start < end); - if !overlaps { - findings.push(Finding { kind, start, end }); - } -} - -/// Run all secret matchers over `text`, returning non-overlapping findings -/// sorted by start offset. Order of matchers matters: specific patterns are -/// recorded first so the generic / high-entropy matchers can't shadow them. -fn detect_secrets(text: &str) -> Vec { - let mut findings: Vec = Vec::new(); - - for m in aws_re().find_iter(text) { - push_if_free(&mut findings, "aws-access-key", m.start(), m.end()); - } - for m in private_key_re().find_iter(text) { - push_if_free(&mut findings, "private-key", m.start(), m.end()); - } - for m in jwt_re().find_iter(text) { - push_if_free(&mut findings, "jwt", m.start(), m.end()); - } - for m in slack_re().find_iter(text) { - push_if_free(&mut findings, "slack-token", m.start(), m.end()); - } - for m in github_re().find_iter(text) { - push_if_free(&mut findings, "github-token", m.start(), m.end()); - } - // Generic `key = value` assignments — gate the captured value on entropy. - for caps in generic_re().captures_iter(text) { - let whole = caps.get(0).unwrap(); - let value = caps.get(2).unwrap(); - if shannon_entropy(value.as_str()) >= ENTROPY_THRESHOLD { - push_if_free(&mut findings, "api-key", whole.start(), whole.end()); - } - } - // Bare high-entropy blobs (hex/base64) that none of the above caught. - for m in high_entropy_re().find_iter(text) { - if shannon_entropy(m.as_str()) >= ENTROPY_THRESHOLD { - push_if_free(&mut findings, "high-entropy", m.start(), m.end()); - } - } - - findings.sort_by_key(|f| f.start); - findings -} - -/// Run all PII matchers over `text`, returning non-overlapping findings sorted -/// by start offset. -fn detect_pii(text: &str) -> Vec { - let mut findings: Vec = Vec::new(); - - for m in email_re().find_iter(text) { - push_if_free(&mut findings, "email", m.start(), m.end()); - } - for m in ipv4_re().find_iter(text) { - push_if_free(&mut findings, "ipv4", m.start(), m.end()); - } - for m in phone_re().find_iter(text) { - push_if_free(&mut findings, "phone", m.start(), m.end()); - } - - findings.sort_by_key(|f| f.start); - findings -} - /// Build the `{:type :match :start :end}` result map for a finding. fn finding_to_map(text: &str, f: &Finding) -> Value { let mut m = BTreeMap::new(); - m.insert(Value::keyword("type"), Value::string(f.kind)); + m.insert(Value::keyword("type"), Value::string(f.label)); m.insert( Value::keyword("match"), Value::string(&text[f.start..f.end]), @@ -281,17 +117,6 @@ fn finding_to_map(text: &str, f: &Finding) -> Value { Value::map(m) } -/// Replace each finding's span with `«redacted:»`, working right-to-left -/// so byte offsets of not-yet-applied edits stay valid. -fn redact_findings(text: &str, findings: &[Finding]) -> String { - let mut out = text.to_string(); - for f in findings.iter().rev() { - let replacement = format!("\u{ab}redacted:{}\u{bb}", f.kind); - out.replace_range(f.start..f.end, &replacement); - } - out -} - /// Turn a scan's `(text, findings)` pair into the `[{:type :match :start /// :end} ...]` list `Value`. Shared by the sync and offloaded-async paths of /// `secret/detect` and `pii/detect` so both build the identical result. @@ -709,12 +534,6 @@ mod tests { ); } - #[test] - fn entropy_low_for_repetitive() { - assert!(shannon_entropy("aaaaaaaa") < 1.0); - assert!(shannon_entropy("a8Fk3Lm9Zq2Wx7Bv1Nc4Pd6") >= ENTROPY_THRESHOLD); - } - #[cfg(not(target_arch = "wasm32"))] #[test] fn secret_limit_accepts_boundary_and_rejects_one_over() { diff --git a/crates/sema-stdlib/src/workflow.rs b/crates/sema-stdlib/src/workflow.rs index b2774772..1ab5c6ad 100644 --- a/crates/sema-stdlib/src/workflow.rs +++ b/crates/sema-stdlib/src/workflow.rs @@ -121,6 +121,8 @@ fn emit_policy_observation(ctx: &context::WorkflowCtx, observation: PolicyObserv subject, subject_digest, rule, + label, + count, action, reason, source, @@ -146,6 +148,37 @@ fn emit_policy_observation(ctx: &context::WorkflowCtx, observation: PolicyObserv rule, source, }, + PolicyObservationKind::Flagged => WorkflowEvent::PolicyFlagged { + seq, + ts, + phase_seq, + agent_id, + policy, + policy_digest, + boundary, + subject, + subject_digest, + rule, + label: label.unwrap_or_else(|| "finding".to_string()), + count: count.unwrap_or(1), + action: action.unwrap_or_else(|| "audit".to_string()), + source, + }, + PolicyObservationKind::Redacted => WorkflowEvent::PolicyRedacted { + seq, + ts, + phase_seq, + agent_id, + policy, + policy_digest, + boundary, + subject, + subject_digest, + rule, + label: label.unwrap_or_else(|| "finding".to_string()), + count: count.unwrap_or(1), + source, + }, PolicyObservationKind::Violation => WorkflowEvent::PolicyViolation { seq, ts, diff --git a/crates/sema-vm/src/compiler.rs b/crates/sema-vm/src/compiler.rs index 9ab0d3c6..f9b8ed5f 100644 --- a/crates/sema-vm/src/compiler.rs +++ b/crates/sema-vm/src/compiler.rs @@ -228,11 +228,13 @@ fn scan_global_rebinds(expr: &ResolvedExpr, f: &mut impl FnMut(Spur, bool)) { E::Deftool { description, parameters, + options, handler, .. } => { scan_global_rebinds(description, f); scan_global_rebinds(parameters, f); + scan_global_rebinds(options, f); scan_global_rebinds(handler, f); } E::Defagent { options, .. } => scan_global_rebinds(options, f), @@ -546,8 +548,9 @@ impl Compiler { name, description, parameters, + options, handler, - } => self.compile_deftool(*name, description, parameters, handler), + } => self.compile_deftool(*name, description, parameters, options, handler), ResolvedExpr::Defagent { name, options } => self.compile_defagent(*name, options), ResolvedExpr::Delay(expr) => self.compile_delay(expr), ResolvedExpr::Force(expr) => self.compile_force(expr), @@ -1491,15 +1494,17 @@ impl Compiler { name: Spur, description: &ResolvedExpr, parameters: &ResolvedExpr, + options: &ResolvedExpr, handler: &ResolvedExpr, ) -> Result<(), SemaError> { self.emit_load_global(intern("__vm-deftool"))?; self.emit.emit_const(Value::symbol_from_spur(name))?; self.compile_expr(description)?; self.compile_expr(parameters)?; + self.compile_expr(options)?; self.compile_expr(handler)?; self.emit.emit_op(Op::Call); - self.emit.emit_u16(4); + self.emit.emit_u16(5); Ok(()) } diff --git a/crates/sema-vm/src/core_expr.rs b/crates/sema-vm/src/core_expr.rs index e83a3b5f..d0e5f215 100644 --- a/crates/sema-vm/src/core_expr.rs +++ b/crates/sema-vm/src/core_expr.rs @@ -138,6 +138,7 @@ pub enum Expr { name: Spur, description: Box>, parameters: Box>, + options: Box>, handler: Box>, }, /// Agent definition (LLM) diff --git a/crates/sema-vm/src/lower.rs b/crates/sema-vm/src/lower.rs index 30e58334..f5d8c56e 100644 --- a/crates/sema-vm/src/lower.rs +++ b/crates/sema-vm/src/lower.rs @@ -1968,17 +1968,22 @@ fn lower_message(args: &[Value]) -> Result { } fn lower_deftool(args: &[Value]) -> Result { - if args.len() < 4 { - return Err(SemaError::arity("deftool", "4", args.len())); + if !matches!(args.len(), 4 | 5) { + return Err(SemaError::arity("deftool", "4 or 5", args.len())); } let name = require_symbol(&args[0], "deftool")?; let description = lower_expr(&args[1], false)?; let parameters = lower_expr(&args[2], false)?; - let handler = lower_expr(&args[3], false)?; + let (options, handler) = if args.len() == 5 { + (lower_expr(&args[3], false)?, lower_expr(&args[4], false)?) + } else { + (CoreExpr::Const(Value::nil()), lower_expr(&args[3], false)?) + }; Ok(CoreExpr::Deftool { name, description: Box::new(description), parameters: Box::new(parameters), + options: Box::new(options), handler: Box::new(handler), }) } diff --git a/crates/sema-vm/src/optimize.rs b/crates/sema-vm/src/optimize.rs index 083fce86..7ffd73c4 100644 --- a/crates/sema-vm/src/optimize.rs +++ b/crates/sema-vm/src/optimize.rs @@ -320,11 +320,13 @@ fn optimize_inner(expr: CoreExpr, shadowed: &[String]) -> CoreExpr { name, description, parameters, + options, handler, } => CoreExpr::Deftool { name, description: Box::new(optimize_inner(*description, shadowed)), parameters: Box::new(optimize_inner(*parameters, shadowed)), + options: Box::new(optimize_inner(*options, shadowed)), handler: Box::new(optimize_inner(*handler, shadowed)), }, CoreExpr::Defagent { name, options } => CoreExpr::Defagent { diff --git a/crates/sema-vm/src/resolve.rs b/crates/sema-vm/src/resolve.rs index d63002e3..011f53d0 100644 --- a/crates/sema-vm/src/resolve.rs +++ b/crates/sema-vm/src/resolve.rs @@ -407,11 +407,13 @@ fn resolve_expr_inner(expr: &CoreExpr, r: &mut Resolver) -> Result Ok(ResolvedExpr::Deftool { name: *name, description: Box::new(resolve_expr(description, r)?), parameters: Box::new(resolve_expr(parameters, r)?), + options: Box::new(resolve_expr(options, r)?), handler: Box::new(resolve_expr(handler, r)?), }), @@ -580,11 +582,13 @@ fn collect_rebinds( CoreExpr::Deftool { description, parameters, + options, handler, .. } => { collect_rebinds(description, false, rebound, defined); collect_rebinds(parameters, false, rebound, defined); + collect_rebinds(options, false, rebound, defined); collect_rebinds(handler, false, rebound, defined); } CoreExpr::Defagent { options, .. } => collect_rebinds(options, false, rebound, defined), @@ -895,11 +899,13 @@ fn scan_self_tail(e: &ResolvedExpr, self_uv: u16) -> bool { E::Deftool { description, parameters, + options, handler, .. } => { scan_self_tail(description, self_uv) && scan_self_tail(parameters, self_uv) + && scan_self_tail(options, self_uv) && scan_self_tail(handler, self_uv) } E::Defagent { options, .. } => scan_self_tail(options, self_uv), @@ -1037,11 +1043,13 @@ fn rewrite_self_refs(e: &mut ResolvedExpr, self_uv: u16) { E::Deftool { description, parameters, + options, handler, .. } => { rewrite_self_refs(description, self_uv); rewrite_self_refs(parameters, self_uv); + rewrite_self_refs(options, self_uv); rewrite_self_refs(handler, self_uv); } E::Defagent { options, .. } => rewrite_self_refs(options, self_uv), diff --git a/crates/sema-workflow/src/event.rs b/crates/sema-workflow/src/event.rs index da25a791..dd5738bd 100644 --- a/crates/sema-workflow/src/event.rs +++ b/crates/sema-workflow/src/event.rs @@ -253,6 +253,49 @@ pub enum WorkflowEvent { source: String, }, + /// A deterministic policy rule observed content in audit-only mode. + #[serde(rename = "policy.flagged")] + PolicyFlagged { + seq: u64, + ts: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + phase_seq: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + agent_id: Option, + policy: String, + policy_digest: String, + boundary: String, + subject: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + subject_digest: Option, + rule: String, + label: String, + count: usize, + action: String, + source: String, + }, + + /// A deterministic policy rule mechanically redacted one or more spans. + #[serde(rename = "policy.redacted")] + PolicyRedacted { + seq: u64, + ts: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + phase_seq: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + agent_id: Option, + policy: String, + policy_digest: String, + boundary: String, + subject: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + subject_digest: Option, + rule: String, + label: String, + count: usize, + source: String, + }, + /// A policy layer denied one protected model or tool boundary. #[serde(rename = "policy.violation")] PolicyViolation { diff --git a/crates/sema/tests/suites/workflow_policy_test.rs b/crates/sema/tests/suites/workflow_policy_test.rs index 481a4baf..50b667fa 100644 --- a/crates/sema/tests/suites/workflow_policy_test.rs +++ b/crates/sema/tests/suites/workflow_policy_test.rs @@ -433,6 +433,48 @@ fn direct_tool_invoke_is_gated_before_the_handler() { let _ = std::fs::remove_dir_all(&base); } +#[test] +fn semantic_tool_subjects_are_name_and_argument_independent() { + let src = r#" + (deftool arbitrary-reader + "read through a deployment-specific argument" + {:location {:type :string}} + {:policy-subjects [{:kind :file-read :path-arg :location}]} + (fn (_location) "read-ok")) + (deftool arbitrary-writer + "write through a deployment-specific argument" + {:destination {:type :string}} + {:policy-subjects [{:kind :file-write :path-arg :destination}]} + (fn (_destination) "write-ran")) + (defpolicy readonly + {:subjects + {:default :deny + :allow [{:kind :file-read :paths ["src/**"]}]}}) + (defworkflow guarded "semantic subjects" {:policy readonly} + (def read-result + (tool/invoke arbitrary-reader {:location "src/lib.rs"})) + (def write-result + (try + (tool/invoke arbitrary-writer {:destination "src/lib.rs"}) + (catch error (:type error)))) + {:status :success + :read read-result + :write write-result + :subjects (tool/policy-subjects arbitrary-reader)}) + "#; + + let out = wc::run_once( + src, + fake_with_reply("unused"), + "wf_policy_semantic_subjects", + ); + assert_eq!(out.result["status"], "success"); + assert_eq!(out.result["read"], "read-ok"); + assert_eq!(out.result["write"], "policy-denied"); + assert_eq!(out.result["subjects"][0]["kind"], "file-read"); + assert_eq!(out.result["subjects"][0]["path-arg"], "location"); +} + #[test] fn step_policy_can_tighten_but_not_loosen_the_workflow_policy() { let src = r#" From 95ce9c9254843082693df5a9d1d3223d471f9828 Mon Sep 17 00:00:00 2001 From: Helge Sverre Date: Fri, 31 Jul 2026 11:53:23 +0200 Subject: [PATCH 07/11] feat(policy): complete guardrails and package compatibility --- crates/sema-core/src/error.rs | 305 ++++++- crates/sema-core/src/lib.rs | 2 +- crates/sema-docs/builtin_docs.generated.json | 32 +- .../entries/stdlib/tool/policy-subjects.md | 26 + .../entries/stdlib/workflow/defpolicy.md | 17 + .../stdlib/workflow/workflow-tool-result.md | 25 + crates/sema-eval/src/eval.rs | 85 +- crates/sema-eval/src/prelude.rs | 11 +- crates/sema-eval/src/special_forms.rs | 150 +++- crates/sema-llm/src/builtins.rs | 558 +++++++++--- crates/sema-lsp/src/helpers.rs | 12 +- crates/sema-mcp/src/tools.rs | 34 +- crates/sema-policy/src/content.rs | 2 +- crates/sema-policy/src/lib.rs | 359 ++++++-- crates/sema-stdlib/src/io.rs | 2 +- crates/sema-stdlib/src/json.rs | 2 +- crates/sema-stdlib/src/list.rs | 8 +- crates/sema-stdlib/src/reflect.rs | 1 + crates/sema-stdlib/src/string.rs | 44 +- crates/sema-stdlib/src/workflow.rs | 155 +++- crates/sema-stdlib/src/workflow_check.rs | 11 +- crates/sema-vm/src/lower.rs | 8 +- crates/sema-vm/src/vm.rs | 50 +- crates/sema-wasm/src/driver.rs | 24 +- crates/sema-wasm/src/lib.rs | 69 +- crates/sema-workflow/src/context.rs | 14 + crates/sema-workflow/src/event.rs | 36 + crates/sema/src/import_tracer.rs | 39 +- crates/sema/src/lib.rs | 1 + crates/sema/src/main.rs | 226 +++-- crates/sema/src/pkg.rs | 421 ++++++++- crates/sema/src/repl/commands.rs | 2 +- crates/sema/src/repl/mod.rs | 4 +- crates/sema/src/web/mod.rs | 4 +- crates/sema/src/workflow_evidence.rs | 285 +++++++ crates/sema/tests/integration_test.rs | 2 +- crates/sema/tests/pmap_async_test.rs | 4 +- crates/sema/tests/suites/eval_stdlib_test.rs | 41 + crates/sema/tests/suites/eval_test.rs | 2 +- crates/sema/tests/suites/stream_async_test.rs | 2 +- .../sema/tests/suites/workflow_policy_test.rs | 236 +++++ .../runtime-match-map.tsv | 804 +++++++++--------- website/docs/llm/workflows.md | 27 + 43 files changed, 3140 insertions(+), 1002 deletions(-) create mode 100644 crates/sema-docs/entries/stdlib/tool/policy-subjects.md create mode 100644 crates/sema-docs/entries/stdlib/workflow/workflow-tool-result.md create mode 100644 crates/sema/src/workflow_evidence.rs diff --git a/crates/sema-core/src/error.rs b/crates/sema-core/src/error.rs index b9bce6cc..5b367b12 100644 --- a/crates/sema-core/src/error.rs +++ b/crates/sema-core/src/error.rs @@ -147,6 +147,42 @@ impl fmt::Display for StackTrace { /// Maps Rc pointer addresses to source spans for expression tracking. pub type SpanMap = HashMap; +/// Structured details for a policy denial. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct PolicyDenial { + pub policy: Option, + pub boundary: String, + pub subject: String, + pub rule: String, + pub reason: String, + pub action: String, + pub source: String, +} + +impl fmt::Display for PolicyDenial { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + if let Some(policy) = &self.policy { + write!( + f, + "Policy '{policy}' denied {} '{}': {}", + self.boundary, self.subject, self.reason + ) + } else { + write!( + f, + "Policy denied {} '{}': {}", + self.boundary, self.subject, self.reason + ) + } + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct TypeContext { + pub function: String, + pub argument: Option, +} + #[derive(Debug, Clone, thiserror::Error)] pub enum SemaError { #[error("Reader error at {span}: {message}")] @@ -155,14 +191,18 @@ pub enum SemaError { #[error("Eval error: {0}")] Eval(String), - #[error("Type error: expected {expected}, got {got}{}", got_value.as_ref().map(|v| format!(" ({v})")).unwrap_or_default())] + #[error("Type error: {}expected {expected}, got {got}{}", type_context(context.as_deref()), got_value.as_ref().map(|v| format!(" ({v})")).unwrap_or_default())] Type { + context: Option>, expected: String, got: String, got_value: Option, }, - #[error("Arity error: {name} expects {expected} args, got {got}")] + #[error( + "Arity error: {name} expects {}, got {got}", + format_expected_arity(expected) + )] Arity { name: String, expected: String, @@ -187,12 +227,11 @@ pub enum SemaError { #[error("Permission denied: {function} — path '{path}' is outside allowed directories")] PathDenied { function: String, path: String }, - #[error("Policy denied {boundary} '{subject}' ({rule})")] - PolicyDenied { - boundary: String, - subject: String, - rule: String, - }, + #[error("{0}")] + PolicyDenied(Box), + + #[error("Internal error: {0}")] + Internal(String), #[error("User exception: {0}")] UserException(Value), @@ -220,6 +259,50 @@ pub enum SemaError { }, } +fn type_context(context: Option<&TypeContext>) -> String { + match context { + Some(TypeContext { + function, + argument: Some(argument), + }) => format!("{function} argument {argument} "), + Some(TypeContext { + function, + argument: None, + }) => format!("{function} "), + None => String::new(), + } +} + +fn format_expected_arity(expected: &str) -> String { + if let Some(minimum) = expected.strip_suffix('+') { + return format!("{minimum} or more arguments"); + } + if let Some((minimum, maximum)) = expected.split_once('-') { + return format!("{minimum} to {maximum} arguments"); + } + if expected.contains(" or ") { + return format!("{expected} arguments"); + } + match expected { + "0" => "no arguments".to_string(), + "1" => "1 argument".to_string(), + _ => format!("{expected} arguments"), + } +} + +fn type_message( + context: Option<&TypeContext>, + expected: &str, + got: &str, + got_value: Option<&str>, +) -> String { + let value = got_value.map_or_else(String::new, |value| format!(" ({value})")); + format!( + "{}expected {expected}, got {got}{value}", + type_context(context) + ) +} + /// Compute the Levenshtein edit distance between two strings. fn edit_distance(a: &str, b: &str) -> usize { let a_len = a.len(); @@ -338,6 +421,7 @@ const CONDITION_TYPES: &[&str] = &[ "reader", "permission-denied", "policy-denied", + "internal", "cancelled", "timeout", ]; @@ -397,16 +481,14 @@ impl SemaError { SemaError::Eval(msg.into()) } - pub fn policy_denied( - boundary: impl Into, - subject: impl Into, - rule: impl Into, - ) -> Self { - SemaError::PolicyDenied { - boundary: boundary.into(), - subject: subject.into(), - rule: rule.into(), - } + pub fn policy_denied(denial: PolicyDenial) -> Self { + let rule = denial.rule.clone(); + SemaError::PolicyDenied(Box::new(denial)).with_note(format!("policy rule: {rule}")) + } + + pub fn internal(message: impl Into) -> Self { + SemaError::Internal(message.into()) + .with_hint("report this as a Sema bug and include the stack trace") } #[allow(clippy::too_many_arguments)] @@ -477,6 +559,7 @@ impl SemaError { pub fn type_error(expected: impl Into, got: impl Into) -> Self { SemaError::Type { + context: None, expected: expected.into(), got: got.into(), got_value: None, @@ -488,16 +571,50 @@ impl SemaError { got: impl Into, value: &Value, ) -> Self { + SemaError::Type { + context: None, + expected: expected.into(), + got: got.into(), + got_value: Some(Self::value_preview(value)), + } + } + + pub fn argument_type( + function: impl Into, + argument: usize, + expected: impl Into, + value: &Value, + ) -> Self { + SemaError::Type { + context: Some(Box::new(TypeContext { + function: function.into(), + argument: Some(argument), + })), + expected: expected.into(), + got: value.type_name().to_string(), + got_value: None, + } + } + + pub fn argument_type_with_value( + function: impl Into, + argument: usize, + expected: impl Into, + value: &Value, + ) -> Self { + let mut error = Self::argument_type(function, argument, expected, value); + if let SemaError::Type { got_value, .. } = &mut error { + *got_value = Some(Self::value_preview(value)); + } + error + } + + fn value_preview(value: &Value) -> String { let display = format!("{value}"); - let truncated = if display.len() > 40 { + if display.len() > 40 { format!("{}…", crate::text_util::truncate_chars(&display, 39)) } else { display - }; - SemaError::Type { - expected: expected.into(), - got: got.into(), - got_value: Some(truncated), } } @@ -618,6 +735,79 @@ impl SemaError { other => other, } } + + /// Return the primary user-facing message without wrapper prefixes. + pub fn user_message(&self) -> String { + match self.inner() { + SemaError::Reader { message, .. } | SemaError::Eval(message) => message.clone(), + SemaError::Type { + context, + expected, + got, + got_value, + } => type_message(context.as_deref(), expected, got, got_value.as_deref()), + SemaError::Arity { + name, + expected, + got, + } => format!( + "{name} expects {}, got {got}", + format_expected_arity(expected) + ), + SemaError::Unbound(name) => format!("Unbound variable: {name}"), + SemaError::Llm(message) => format!("LLM error: {message}"), + SemaError::Io(message) => format!("I/O error: {message}"), + SemaError::PermissionDenied { + function, + capability, + } => format!("Permission denied: {function} requires '{capability}' capability"), + SemaError::PathDenied { function, path } => format!( + "Permission denied: {function} — path '{path}' is outside allowed directories" + ), + SemaError::PolicyDenied(denial) => denial.to_string(), + SemaError::Internal(message) => format!("Internal error: {message}"), + SemaError::UserException(value) => format!("User exception: {value}"), + SemaError::Condition(condition) => condition_message(condition), + SemaError::WithTrace { .. } | SemaError::WithContext { .. } => { + unreachable!("inner() already unwraps wrappers") + } + } + } + + /// Format a diagnostic message without source location or stack frames. + pub fn format_diagnostic(&self) -> String { + let mut message = self.user_message(); + if let Some(hint) = self.hint() { + message.push_str("\n hint: "); + message.push_str(hint); + } + if let Some(note) = self.note() { + message.push_str("\n note: "); + message.push_str(note); + } + message + } + + /// Format an error for a plain-text channel. + pub fn format_plain(&self) -> String { + let mut message = self.user_message(); + if let SemaError::Reader { span, .. } = self.inner() { + message.push_str(&format!("\n at :{span}")); + } + if let Some(trace) = self.stack_trace() { + message.push('\n'); + message.push_str(trace.to_string().trim_end()); + } + if let Some(hint) = self.hint() { + message.push_str("\n hint: "); + message.push_str(hint); + } + if let Some(note) = self.note() { + message.push_str("\n note: "); + message.push_str(note); + } + message + } } #[cfg(test)] @@ -703,7 +893,7 @@ mod tests { assert!( matches!( &e, - SemaError::Type { expected, got, got_value } + SemaError::Type { expected, got, got_value, .. } if expected == "string" && got == "integer" && got_value.is_none() ), "expected Type variant with expected='string', got='integer', got_value=None, got {e:?}" @@ -726,7 +916,10 @@ mod tests { "expected Arity variant with name='my-fn', expected='2', got=5, got {e:?}" ); // Display check (intentionally testing Display format) - assert_eq!(e.to_string(), "Arity error: my-fn expects 2 args, got 5"); + assert_eq!( + e.to_string(), + "Arity error: my-fn expects 2 arguments, got 5" + ); } // 6. with_hint attaches hint retrievable via .hint() @@ -963,7 +1156,7 @@ mod tests { assert!( matches!( &e, - SemaError::Type { expected, got, got_value } + SemaError::Type { expected, got, got_value, .. } if expected == "string" && got == "integer" && got_value.as_deref() == Some("42") ), "expected Type variant with expected='string', got='integer', got_value=Some(\"42\"), got {e:?}" @@ -990,4 +1183,62 @@ mod tests { // Display check (intentionally testing Display format) assert_eq!(e.to_string(), "Type error: expected string, got integer"); } + + #[test] + fn argument_type_includes_call_context() { + let e = SemaError::argument_type_with_value("string/split", 1, "string", &Value::int(42)); + assert_eq!( + e.user_message(), + "string/split argument 1 expected string, got int (42)" + ); + } + + #[test] + fn arity_expectations_use_readable_grammar() { + let cases = [ + ("0", "f expects no arguments, got 9"), + ("1", "f expects 1 argument, got 9"), + ("2", "f expects 2 arguments, got 9"), + ("1+", "f expects 1 or more arguments, got 9"), + ("2-4", "f expects 2 to 4 arguments, got 9"), + ("2 or 3", "f expects 2 or 3 arguments, got 9"), + ]; + for (expected, message) in cases { + assert_eq!(SemaError::arity("f", expected, 9).user_message(), message); + } + } + + #[test] + fn policy_denial_preserves_details_and_renders_context() { + let e = SemaError::policy_denied(PolicyDenial { + policy: Some("safe-agent".to_string()), + boundary: "tool".to_string(), + subject: "shell/run".to_string(), + rule: "tools.shell.deny".to_string(), + reason: "command execution is not allowed".to_string(), + action: "fail".to_string(), + source: "request".to_string(), + }); + assert_eq!( + e.user_message(), + "Policy 'safe-agent' denied tool 'shell/run': command execution is not allowed" + ); + assert_eq!(e.note(), Some("policy rule: tools.shell.deny")); + } + + #[test] + fn plain_format_orders_trace_hint_and_note() { + let e = SemaError::eval("failed") + .with_stack_trace(StackTrace(vec![CallFrame { + name: "main".to_string(), + file: None, + span: Some(Span::point(2, 3)), + }])) + .with_hint("try again") + .with_note("extra context"); + assert_eq!( + e.format_plain(), + "failed\n at main (:2:3)\n hint: try again\n note: extra context" + ); + } } diff --git a/crates/sema-core/src/lib.rs b/crates/sema-core/src/lib.rs index deff3608..f6598ff8 100644 --- a/crates/sema-core/src/lib.rs +++ b/crates/sema-core/src/lib.rs @@ -50,7 +50,7 @@ pub use cycle::{ GcPassEvent, GcStats, GcTrigger, NodePtr, OpaqueSeverFn, OpaqueTraceFn, PayloadTracer, RuntimeInteriorHooks, }; -pub use error::{CallFrame, SemaError, Span, SpanMap, StackTrace}; +pub use error::{suggest_similar, CallFrame, PolicyDenial, SemaError, Span, SpanMap, StackTrace}; pub use home::sema_home; pub use io_backend::{ io_backend, io_block_on, io_spawn, io_spawn_blocking, set_io_backend, AbortHook, BoxIoFuture, diff --git a/crates/sema-docs/builtin_docs.generated.json b/crates/sema-docs/builtin_docs.generated.json index 72afcaf4..26c761b5 100644 --- a/crates/sema-docs/builtin_docs.generated.json +++ b/crates/sema-docs/builtin_docs.generated.json @@ -13068,6 +13068,22 @@ ], "body": "Return the parameter schema of a tool definition (the map describing the tool's accepted arguments).\n\n```sema\n(tool/parameters get-weather)\n```" }, + { + "name": "tool/policy-subjects", + "module": "tool", + "summary": "Return the semantic policy subjects declared by a tool definition.", + "params": [ + { + "name": "tool", + "type": "tool" + } + ], + "returns": "vector", + "examples": [ + "(deftool read-source\n \"Read a source file.\"\n {:path {:type :string}}\n {:policy-subjects [{:kind :file-read :path-arg :path}]}\n (fn (path) (file/read path)))\n\n(tool/policy-subjects read-source)\n; => [{:kind :file-read :path-arg :path}]" + ], + "body": "Return the semantic policy subjects declared by a tool definition.\n\nEach subject is a map with a `:kind`. File subjects include `:path-arg`,\nnetwork subjects include `:url-arg` and optional `:method`, command subjects\ninclude `:command-arg`, and external-action subjects include `:action` and an\noptional `:target-arg`.\n\n```sema\n(deftool read-source\n \"Read a source file.\"\n {:path {:type :string}}\n {:policy-subjects [{:kind :file-read :path-arg :path}]}\n (fn (path) (file/read path)))\n\n(tool/policy-subjects read-source)\n; => [{:kind :file-read :path-arg :path}]\n```\n\nSee also: `deftool`, `tool/name`, `tool/parameters`, `defpolicy`." + }, { "name": "f64-array", "module": "typed-arrays", @@ -13853,9 +13869,10 @@ "section": "Dynamic Workflows", "summary": "Define a reusable model and tool policy. Model rules match exact `\"provider/model\"` identities or the `\"provider/*\"` wildcard. Tool rules can allow or deny tool names and constrain model-supplied path, URL, and command arguments. A present `:models` or `:tools` section defaults to `:deny`.", "examples": [ - "(defpolicy repository-auditor\n {:models {:default :deny\n :allow [\"openai/gpt-5\" \"anthropic/*\"]}\n :tools {:default :deny\n :allow\n {\"read-file\" {:paths [\"src/**\" \"Cargo.toml\"]}\n \"run-command\" {:commands [\"cargo test\" \"cargo check\"]}}}})\n\n(defworkflow audit \"Guarded audit\" {:policy repository-auditor}\n (phase \"Audit\")\n (step \"Inspect the repository.\"\n {:tools [read-file run-command]})\n {:status :success})" + "(defpolicy repository-auditor\n {:models {:default :deny\n :allow [\"openai/gpt-5\" \"anthropic/*\"]}\n :tools {:default :deny\n :allow\n {\"read-file\" {:paths [\"src/**\" \"Cargo.toml\"]}\n \"run-command\" {:commands [\"cargo test\" \"cargo check\"]}}}})\n\n(defworkflow audit \"Guarded audit\" {:policy repository-auditor}\n (phase \"Audit\")\n (step \"Inspect the repository.\"\n {:tools [read-file run-command]})\n {:status :success})", + "(try\n (llm/complete \"Review this change.\")\n (catch denial\n {:policy (:policy denial)\n :rule (:rule denial)\n :reason (:reason denial)}))" ], - "body": "Define a reusable model and tool policy. Model rules match exact\n`\"provider/model\"` identities or the `\"provider/*\"` wildcard. Tool rules can\nallow or deny tool names and constrain model-supplied path, URL, and command\narguments. A present `:models` or `:tools` section defaults to `:deny`.\n\n```sema\n(defpolicy repository-auditor\n {:models {:default :deny\n :allow [\"openai/gpt-5\" \"anthropic/*\"]}\n :tools {:default :deny\n :allow\n {\"read-file\" {:paths [\"src/**\" \"Cargo.toml\"]}\n \"run-command\" {:commands [\"cargo test\" \"cargo check\"]}}}})\n\n(defworkflow audit \"Guarded audit\" {:policy repository-auditor}\n (phase \"Audit\")\n (step \"Inspect the repository.\"\n {:tools [read-file run-command]})\n {:status :success})\n```\n\nAttach a policy with workflow or step `:policy`. Active workflow and step\npolicies compose with logical AND. `:permissions` and the CLI sandbox remain the\nouter capability limit.\n\nSee also: `defworkflow`, `step`, `policy/without`, `workflow/check`.", + "body": "Define a reusable model and tool policy. Model rules match exact\n`\"provider/model\"` identities or the `\"provider/*\"` wildcard. Tool rules can\nallow or deny tool names and constrain model-supplied path, URL, and command\narguments. A present `:models` or `:tools` section defaults to `:deny`.\n\n```sema\n(defpolicy repository-auditor\n {:models {:default :deny\n :allow [\"openai/gpt-5\" \"anthropic/*\"]}\n :tools {:default :deny\n :allow\n {\"read-file\" {:paths [\"src/**\" \"Cargo.toml\"]}\n \"run-command\" {:commands [\"cargo test\" \"cargo check\"]}}}})\n\n(defworkflow audit \"Guarded audit\" {:policy repository-auditor}\n (phase \"Audit\")\n (step \"Inspect the repository.\"\n {:tools [read-file run-command]})\n {:status :success})\n```\n\nAttach a policy with workflow or step `:policy`. Active workflow and step\npolicies compose with logical AND. `:permissions` and the CLI sandbox remain the\nouter capability limit.\n\nPolicy denials raise a `:policy-denied` condition. The condition contains\n`:message`, `:policy`, `:boundary`, `:subject`, `:rule`, `:reason`, `:action`,\nand `:source`. This lets a `catch` handler use the exact deciding policy layer:\n\n```sema\n(try\n (llm/complete \"Review this change.\")\n (catch denial\n {:policy (:policy denial)\n :rule (:rule denial)\n :reason (:reason denial)}))\n```\n\nInvalid policy maps identify the invalid field or one-based list entry. Unknown\nkeys suggest a close valid key when possible. Invalid enum values list the\naccepted keywords.\n\nSee also: `defworkflow`, `step`, `policy/without`, `workflow/check`.", "syntax": "(defpolicy name policy-map)" }, { @@ -13994,6 +14011,17 @@ "(workflow/step \"assembler\"\n (fn ()\n (workflow/tool-call \"file/read\" \"drafts/intro.md\")\n (workflow/tool-call \"file/read\" \"drafts/scheduler.md\")\n (assemble-index (checkpoint :drafts))))" ], "body": "Journal a tool call made by the step currently executing. `(workflow/tool-call tool-name [args])` emits an `agent.tool_call` event attributed to the enclosing [`workflow/step`], so the dashboard renders it as a tool twig in that step's drill-in. `args` is an opaque/gated descriptor string (omit it for the `\"gated\"` sentinel — content is not captured). It is a no-op (returns `nil`) outside a `workflow/step`. Use it to make a leaf's tool usage visible in the run journal.\n\n```sema\n(workflow/step \"assembler\"\n (fn ()\n (workflow/tool-call \"file/read\" \"drafts/intro.md\")\n (workflow/tool-call \"file/read\" \"drafts/scheduler.md\")\n (assemble-index (checkpoint :drafts))))\n```\n\nSee also: `workflow/step`, `step`, `pipeline`." + }, + { + "name": "workflow/tool-result", + "module": "workflow", + "section": "Dynamic Workflows", + "summary": "Journal a successful tool completion for the step currently executing. `tool-name` is a keyword or string. The event records only the `\"gated\"` sentinel and does not store the tool result.", + "examples": [ + "(workflow/step \"custom tool\"\n (fn ()\n (workflow/tool-call \"lookup\" {:id 42})\n (def result (lookup 42))\n (workflow/tool-result \"lookup\")\n result))" + ], + "body": "Journal a successful tool completion for the step currently executing.\n`tool-name` is a keyword or string. The event records only the `\"gated\"`\nsentinel and does not store the tool result.\n\nThe function returns `nil`. It is a no-op outside a `workflow/step`. Agent and\ntool steps call it automatically after a successful tool invocation, so direct\nuse is only needed by custom workflow integrations.\n\n```sema\n(workflow/step \"custom tool\"\n (fn ()\n (workflow/tool-call \"lookup\" {:id 42})\n (def result (lookup 42))\n (workflow/tool-result \"lookup\")\n result))\n```\n\nSee also: `workflow/tool-call`, `workflow/step`, `step`.", + "syntax": "(workflow/tool-result tool-name)" } ] } diff --git a/crates/sema-docs/entries/stdlib/tool/policy-subjects.md b/crates/sema-docs/entries/stdlib/tool/policy-subjects.md new file mode 100644 index 00000000..0a578d91 --- /dev/null +++ b/crates/sema-docs/entries/stdlib/tool/policy-subjects.md @@ -0,0 +1,26 @@ +--- +name: "tool/policy-subjects" +module: "tool" +params: [{ name: tool, type: tool }] +returns: "vector" +--- + +Return the semantic policy subjects declared by a tool definition. + +Each subject is a map with a `:kind`. File subjects include `:path-arg`, +network subjects include `:url-arg` and optional `:method`, command subjects +include `:command-arg`, and external-action subjects include `:action` and an +optional `:target-arg`. + +```sema +(deftool read-source + "Read a source file." + {:path {:type :string}} + {:policy-subjects [{:kind :file-read :path-arg :path}]} + (fn (path) (file/read path))) + +(tool/policy-subjects read-source) +; => [{:kind :file-read :path-arg :path}] +``` + +See also: `deftool`, `tool/name`, `tool/parameters`, `defpolicy`. diff --git a/crates/sema-docs/entries/stdlib/workflow/defpolicy.md b/crates/sema-docs/entries/stdlib/workflow/defpolicy.md index 98d1334a..2f6efa4f 100644 --- a/crates/sema-docs/entries/stdlib/workflow/defpolicy.md +++ b/crates/sema-docs/entries/stdlib/workflow/defpolicy.md @@ -30,4 +30,21 @@ Attach a policy with workflow or step `:policy`. Active workflow and step policies compose with logical AND. `:permissions` and the CLI sandbox remain the outer capability limit. +Policy denials raise a `:policy-denied` condition. The condition contains +`:message`, `:policy`, `:boundary`, `:subject`, `:rule`, `:reason`, `:action`, +and `:source`. This lets a `catch` handler use the exact deciding policy layer: + +```sema +(try + (llm/complete "Review this change.") + (catch denial + {:policy (:policy denial) + :rule (:rule denial) + :reason (:reason denial)})) +``` + +Invalid policy maps identify the invalid field or one-based list entry. Unknown +keys suggest a close valid key when possible. Invalid enum values list the +accepted keywords. + See also: `defworkflow`, `step`, `policy/without`, `workflow/check`. diff --git a/crates/sema-docs/entries/stdlib/workflow/workflow-tool-result.md b/crates/sema-docs/entries/stdlib/workflow/workflow-tool-result.md new file mode 100644 index 00000000..27ecddd4 --- /dev/null +++ b/crates/sema-docs/entries/stdlib/workflow/workflow-tool-result.md @@ -0,0 +1,25 @@ +--- +name: "workflow/tool-result" +module: "workflow" +section: "Dynamic Workflows" +syntax: "(workflow/tool-result tool-name)" +--- + +Journal a successful tool completion for the step currently executing. +`tool-name` is a keyword or string. The event records only the `"gated"` +sentinel and does not store the tool result. + +The function returns `nil`. It is a no-op outside a `workflow/step`. Agent and +tool steps call it automatically after a successful tool invocation, so direct +use is only needed by custom workflow integrations. + +```sema +(workflow/step "custom tool" + (fn () + (workflow/tool-call "lookup" {:id 42}) + (def result (lookup 42)) + (workflow/tool-result "lookup") + result)) +``` + +See also: `workflow/tool-call`, `workflow/step`, `step`. diff --git a/crates/sema-eval/src/eval.rs b/crates/sema-eval/src/eval.rs index c25612ca..cb2057a1 100644 --- a/crates/sema-eval/src/eval.rs +++ b/crates/sema-eval/src/eval.rs @@ -19,6 +19,10 @@ pub enum Trampoline { pub type EvalResult = Result; +fn runtime_internal(message: &str, detail: impl std::fmt::Debug) -> SemaError { + SemaError::internal(message).with_note(format!("runtime detail: {detail:?}")) +} + /// Create an isolated module env: child of root (global/stdlib) env pub fn create_module_env(env: &Env) -> Env { // Walk parent chain to find root @@ -447,7 +451,9 @@ impl Interpreter { .expect("runtime is present outside of Drop"); runtime .submit_root_with_options(vm, &opts) - .map_err(|e| SemaError::eval(format!("root submission failed: {e:?}"))) + .map_err(|error| { + runtime_internal("could not submit the evaluation to the runtime", error) + }) } fn submit_exprs( @@ -481,7 +487,9 @@ impl Interpreter { .expect("runtime is present outside of Drop"); runtime .submit_root_with_options(vm, &opts) - .map_err(|e| SemaError::eval(format!("root submission failed: {e:?}"))) + .map_err(|error| { + runtime_internal("could not submit the evaluation to the runtime", error) + }) } /// Drive an already-submitted root (from [`submit_str`](Self::submit_str) @@ -508,7 +516,7 @@ impl Interpreter { let budget = sema_vm::runtime::DriveBudget::host_default(); runtime .drive(&budget) - .map_err(|e| SemaError::eval(format!("runtime fault: {e:?}"))) + .map_err(|error| runtime_internal("the runtime could not drive the evaluation", error)) } /// Drive one bounded turn while executing VM quanta only for `roots`. @@ -525,7 +533,7 @@ impl Interpreter { let budget = sema_vm::runtime::DriveBudget::host_default(); runtime .drive_roots(&budget, roots) - .map_err(|e| SemaError::eval(format!("runtime fault: {e:?}"))) + .map_err(|error| runtime_internal("the runtime could not drive the evaluation", error)) } /// Drain every [`OutputEvent`](sema_vm::runtime::OutputEvent) captured so @@ -565,7 +573,7 @@ impl Interpreter { ) -> Result { let result = self.runtime().shutdown(&opts); let _ = self.ctx.try_run_interpreter_teardown_hooks(); - result.map_err(|fault| SemaError::eval(format!("runtime fault during shutdown: {fault:?}"))) + result.map_err(|fault| runtime_internal("the runtime could not shut down cleanly", fault)) } /// Submit an already-seeded VM as a fresh root on this interpreter's @@ -628,9 +636,9 @@ impl Interpreter { .as_ref() .expect("runtime is present outside of Drop"); self.ensure_synchronous_runtime_entry_allowed()?; - let handle = runtime - .submit_root(vm) - .map_err(|e| SemaError::eval(format!("root submission failed: {e:?}")))?; + let handle = runtime.submit_root(vm).map_err(|error| { + runtime_internal("could not submit the evaluation to the runtime", error) + })?; self.drive_handle_to_settlement(&handle) } @@ -674,9 +682,14 @@ impl Interpreter { // that the common case; this keeps the drain going for any // teardown the drive scan still owes. loop { - match drive_runtime_root(runtime, &budget, handle.id()) - .map_err(|e| SemaError::eval(format!("runtime fault: {e:?}")))? - { + match drive_runtime_root(runtime, &budget, handle.id()).map_err( + |error| { + runtime_internal( + "the runtime could not drive the evaluation", + error, + ) + }, + )? { DriveState::Progress { ready_remaining: true, .. @@ -693,15 +706,18 @@ impl Interpreter { } RootPoll::Pending => {} RootPoll::Aborted(fault) => { - return Err(SemaError::eval(format!("root aborted: {fault:?}"))); + return Err(runtime_internal( + "the runtime aborted the evaluation", + fault, + )); } RootPoll::RuntimeDropped | RootPoll::InvariantViolation => { - return Err(SemaError::eval("runtime invariant violation")); + return Err(SemaError::internal("the runtime state is inconsistent")); } } - match drive_runtime_root(runtime, &budget, handle.id()) - .map_err(|e| SemaError::eval(format!("runtime fault: {e:?}")))? - { + match drive_runtime_root(runtime, &budget, handle.id()).map_err(|error| { + runtime_internal("the runtime could not drive the evaluation", error) + })? { DriveState::Progress { .. } => {} #[cfg(target_arch = "wasm32")] DriveState::Idle { .. } => { @@ -715,10 +731,11 @@ impl Interpreter { break; } if !matches!( - drive_runtime_root(runtime, &budget, handle.id()).map_err(|e| { - SemaError::eval(format!( - "runtime fault while cancelling suspended WASM root: {e:?}" - )) + drive_runtime_root(runtime, &budget, handle.id()).map_err(|error| { + runtime_internal( + "the runtime could not cancel a suspended WebAssembly evaluation", + error, + ) })?, DriveState::Progress { .. } ) { @@ -747,9 +764,10 @@ impl Interpreter { if !runtime.block_on_inbox(next_deadline) && next_deadline.is_none() { // The inbox closed with no completion and no timer to fall // back on: the parked task can never be resumed. - return Err(SemaError::eval( - "eval_via_runtime: external wait cannot be completed (executor inbox closed)", - )); + return Err(SemaError::internal( + "the runtime could not complete an external wait", + ) + .with_note("runtime detail: executor inbox closed")); } } // The root is parked purely on a timer (`async/sleep`): the only @@ -793,17 +811,24 @@ impl Interpreter { } => { if !runtime .settle_deadlocked_root(handle.id()) - .map_err(|e| SemaError::eval(format!("runtime fault: {e:?}")))? + .map_err(|error| { + runtime_internal( + "the runtime could not settle a deadlocked evaluation", + error, + ) + })? { - return Err(SemaError::eval( - "eval_via_runtime: root did not settle (unsupported suspension on the runtime path)", - )); + return Err(SemaError::internal( + "the runtime could not settle the evaluation", + ) + .with_note("runtime detail: unsupported suspension")); } } _ => { - return Err(SemaError::eval( - "eval_via_runtime: root did not settle (unsupported suspension on the runtime path)", - )); + return Err( + SemaError::internal("the runtime could not settle the evaluation") + .with_note("runtime detail: unsupported suspension"), + ); } } } diff --git a/crates/sema-eval/src/prelude.rs b/crates/sema-eval/src/prelude.rs index 2fb9bc9d..5cdbe8a6 100644 --- a/crates/sema-eval/src/prelude.rs +++ b/crates/sema-eval/src/prelude.rs @@ -461,10 +461,15 @@ pub const PRELUDE: &str = r#" (keys s#))) #t))) ;; the `:on-tool-call` shim — journals each genuine tool call as an - ;; agent.tool_call event. Shared by the `:agent` and `:tools` branches. + ;; agent.tool_call event and each successful completion as + ;; agent.tool_result. Shared by the `:agent` and `:tools` branches. (st-on-tool# (fn (ev#) - (when (= (:event ev#) "start") - (workflow/tool-call (:tool ev#) (:args ev#)))))) + (cond + ((= (:event ev#) "start") + (workflow/tool-call (:tool ev#) (:args ev#))) + ((and (= (:event ev#) "end") + (not (:error ev#))) + (workflow/tool-result (:tool ev#))))))) ;; validate the final text against `:schema` (no-op text passthrough when ;; no schema). Shared by the `:agent` and `:tools` branches. (let ((st-validate# (fn (txt# sch#) diff --git a/crates/sema-eval/src/special_forms.rs b/crates/sema-eval/src/special_forms.rs index 1afedaa3..4fcae1a1 100644 --- a/crates/sema-eval/src/special_forms.rs +++ b/crates/sema-eval/src/special_forms.rs @@ -1,8 +1,8 @@ use std::rc::Rc; use sema_core::{ - intern, resolve, Agent, Env, EvalContext, FileAccess, Record, SemaError, Spur, ToolDefinition, - ToolPolicySubject, Value, + intern, resolve, suggest_similar, Agent, Env, EvalContext, FileAccess, Record, SemaError, Spur, + ToolDefinition, ToolPolicySubject, Value, }; use crate::eval::{self, Trampoline}; @@ -82,7 +82,7 @@ pub(crate) fn register_tool( ) -> Result { let description = description .as_str() - .ok_or_else(|| SemaError::type_error("string", description.type_name()))? + .ok_or_else(|| SemaError::argument_type("deftool", 2, "string", &description))? .to_string(); let policy_subjects = parse_tool_policy_subjects(&options)?; let tool = Value::tool_def(ToolDefinition { @@ -100,40 +100,58 @@ fn parse_tool_policy_subjects(options: &Value) -> Result, if options.is_nil() { return Ok(Vec::new()); } - let map = options - .as_map_rc() - .ok_or_else(|| SemaError::type_error("map", options.type_name()))?; + let map = options.as_map_rc().ok_or_else(|| { + SemaError::eval(format!( + "deftool: options must be a map, got {}", + options.type_name() + )) + })?; for key in map.keys() { - if key.as_keyword().as_deref() != Some("policy-subjects") { - return Err(SemaError::eval(format!("deftool: unknown option {key}"))); + let Some(key) = key.as_keyword() else { + return Err(SemaError::eval(format!( + "deftool: option keys must be keywords, got {}", + key.type_name() + ))); + }; + if key != "policy-subjects" { + let error = SemaError::eval(format!("deftool: unknown option :{key}")); + return Err(match suggest_similar(&key, &["policy-subjects"]) { + Some(candidate) => error.with_hint(format!("did you mean :{candidate}?")), + None => error.with_hint("the valid option is :policy-subjects"), + }); } } let Some(subjects) = map.get(&Value::keyword("policy-subjects")) else { return Ok(Vec::new()); }; - let subjects = subjects - .as_seq() - .ok_or_else(|| SemaError::type_error("sequence", subjects.type_name()))?; + let subjects = subjects.as_seq().ok_or_else(|| { + SemaError::eval(format!( + "deftool: :policy-subjects must be a list or vector, got {}", + subjects.type_name() + )) + })?; subjects .iter() - .map(parse_tool_policy_subject) + .enumerate() + .map(|(index, value)| parse_tool_policy_subject(value, index + 1)) .collect::, _>>() } -fn parse_tool_policy_subject(value: &Value) -> Result { - let map = value - .as_map_rc() - .ok_or_else(|| SemaError::type_error("map", value.type_name()))?; - let kind = subject_name(map.get(&Value::keyword("kind"))) - .ok_or_else(|| SemaError::eval("deftool: policy subject requires :kind"))?; - let required_arg = |key: &str| { - subject_name(map.get(&Value::keyword(key))).ok_or_else(|| { - SemaError::eval(format!("deftool: policy subject {kind:?} requires :{key}")) - }) - }; +fn parse_tool_policy_subject( + value: &Value, + subject_index: usize, +) -> Result { + let context = format!("deftool: policy subject {subject_index}"); + let map = value.as_map_rc().ok_or_else(|| { + SemaError::eval(format!( + "{context} must be a map, got {}", + value.type_name() + )) + })?; + let kind = required_subject_name(&map, "kind", &context)?; match kind.as_str() { "file-read" | "file-write" | "file-delete" => { - reject_subject_keys(&map, &["kind", "path-arg"])?; + reject_subject_keys(&map, &["kind", "path-arg"], &context)?; let access = match kind.as_str() { "file-read" => FileAccess::Read, "file-write" => FileAccess::Write, @@ -142,57 +160,95 @@ fn parse_tool_policy_subject(value: &Value) -> Result { - reject_subject_keys(&map, &["kind", "url-arg", "method"])?; + reject_subject_keys(&map, &["kind", "url-arg", "method"], &context)?; Ok(ToolPolicySubject::NetworkRequest { - method: subject_name(map.get(&Value::keyword("method"))), - url_arg: required_arg("url-arg")?, + method: optional_subject_name(&map, "method", &context)?, + url_arg: required_subject_name(&map, "url-arg", &context)?, }) } "command" => { - reject_subject_keys(&map, &["kind", "command-arg"])?; + reject_subject_keys(&map, &["kind", "command-arg"], &context)?; Ok(ToolPolicySubject::Command { - command_arg: required_arg("command-arg")?, + command_arg: required_subject_name(&map, "command-arg", &context)?, }) } "external-action" => { - reject_subject_keys(&map, &["kind", "action", "target-arg"])?; + reject_subject_keys(&map, &["kind", "action", "target-arg"], &context)?; Ok(ToolPolicySubject::ExternalAction { - action: required_arg("action")?, - target_arg: subject_name(map.get(&Value::keyword("target-arg"))), + action: required_subject_name(&map, "action", &context)?, + target_arg: optional_subject_name(&map, "target-arg", &context)?, }) } _ => Err(SemaError::eval(format!( - "deftool: unsupported policy subject kind {kind:?}" - ))), + "{context} has unsupported :kind :{kind}" + )) + .with_hint( + "valid kinds are :file-read, :file-write, :file-delete, :network-request, :command, and :external-action", + )), } } -fn subject_name(value: Option<&Value>) -> Option { - value.and_then(|value| { - value - .as_keyword() - .or_else(|| value.as_str().map(str::to_string)) - }) +fn required_subject_name( + map: &std::collections::BTreeMap, + key: &str, + context: &str, +) -> Result { + map.get(&Value::keyword(key)) + .ok_or_else(|| SemaError::eval(format!("{context} is missing :{key}"))) + .and_then(|value| subject_name(value, key, context)) +} + +fn optional_subject_name( + map: &std::collections::BTreeMap, + key: &str, + context: &str, +) -> Result, SemaError> { + map.get(&Value::keyword(key)) + .map(|value| subject_name(value, key, context)) + .transpose() +} + +fn subject_name(value: &Value, key: &str, context: &str) -> Result { + value + .as_keyword() + .or_else(|| value.as_str().map(str::to_string)) + .ok_or_else(|| { + SemaError::eval(format!( + "{context} :{key} must be a keyword or string, got {}", + value.type_name() + )) + }) } fn reject_subject_keys( map: &std::collections::BTreeMap, allowed: &[&str], + context: &str, ) -> Result<(), SemaError> { for key in map.keys() { let Some(key) = key.as_keyword() else { - return Err(SemaError::eval( - "deftool: policy subject keys must be keywords", - )); - }; - if !allowed.contains(&key.as_str()) { return Err(SemaError::eval(format!( - "deftool: unknown policy subject option :{key}" + "{context} keys must be keywords, got {}", + key.type_name() ))); + }; + if !allowed.contains(&key.as_str()) { + let error = SemaError::eval(format!("{context} has unknown key :{key}")); + return Err(match suggest_similar(&key, allowed) { + Some(candidate) => error.with_hint(format!("did you mean :{candidate}?")), + None => error.with_hint(format!( + "valid keys are {}", + allowed + .iter() + .map(|key| format!(":{key}")) + .collect::>() + .join(", ") + )), + }); } } Ok(()) diff --git a/crates/sema-llm/src/builtins.rs b/crates/sema-llm/src/builtins.rs index a7a5c0bc..ecaecd77 100644 --- a/crates/sema-llm/src/builtins.rs +++ b/crates/sema-llm/src/builtins.rs @@ -6,8 +6,8 @@ use std::rc::Rc; use sema_core::runtime::RuntimeTaskId; use sema_core::{ - resolve, Agent, Conversation, Env, EvalContext, ImageAttachment, Message, NativeFn, Prompt, - Role, SemaError, Value, ValueView, + resolve, Agent, Conversation, Env, EvalContext, ImageAttachment, Message, NativeFn, + PolicyDenial, Prompt, Role, SemaError, Value, ValueView, }; use sha2::{Digest, Sha256}; @@ -185,10 +185,16 @@ struct ActivePolicy { } /// Effective result of checking all active policy layers. -#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[derive(Debug, Clone, PartialEq, Eq)] enum PolicyGate { Allow, - Deny(T), + Deny(PolicyDecision), +} + +#[derive(Debug, Clone, PartialEq, Eq)] +struct PolicyDecision { + action: T, + denial: PolicyDenial, } /// RAII guard for one workflow or step policy layer. @@ -314,8 +320,27 @@ fn check_model_policy( ) } -fn policy_denied(boundary: PolicyBoundary, subject: &str, rule: &str) -> SemaError { - SemaError::policy_denied(boundary.as_str(), subject, rule) +fn policy_denied(denial: PolicyDenial) -> SemaError { + SemaError::policy_denied(denial) +} + +fn unnamed_policy_denial( + boundary: PolicyBoundary, + subject: impl Into, + rule: impl Into, + reason: impl Into, + action: impl Into, + source: PolicySource, +) -> PolicyDenial { + PolicyDenial { + policy: None, + boundary: boundary.as_str().to_string(), + subject: subject.into(), + rule: rule.into(), + reason: reason.into(), + action: action.into(), + source: source.as_str().to_string(), + } } /// Check a resolved model target. `Ok(false)` means a fallback-only `:skip` @@ -333,15 +358,12 @@ fn model_target_allowed( }; match check_model_policy(provider, model, source, minimum_action) { PolicyGate::Allow => Ok(true), - PolicyGate::Deny(sema_policy::ModelDenyAction::Skip) if fallback_target => Ok(false), - PolicyGate::Deny(_) => { - let subject = format!("{provider}/{model}"); - Err(policy_denied( - PolicyBoundary::Model, - &subject, - "models.denied", - )) + PolicyGate::Deny(decision) + if decision.action == sema_policy::ModelDenyAction::Skip && fallback_target => + { + Ok(false) } + PolicyGate::Deny(decision) => Err(policy_denied(decision.denial)), } } @@ -353,6 +375,7 @@ fn resolve_batch_models( requests .into_iter() .map(|mut request| { + apply_input_policy_to_request(&mut request)?; if request.model.is_empty() { request.model = provider.default_model().to_string(); } @@ -376,11 +399,14 @@ fn enforce_stored_model_policy( return Ok(()); } if provider.is_empty() { - return Err(policy_denied( + return Err(policy_denied(unnamed_policy_denial( PolicyBoundary::Model, model, - &format!("{}.missing-provider", source.as_str()), - )); + format!("{}.missing-provider", source.as_str()), + "stored model metadata does not identify a provider", + "fail", + source, + ))); } model_target_allowed(provider, model, source, false).map(|_| ()) } @@ -406,19 +432,24 @@ fn preflight_tool_calls( sema_policy::ToolDenyAction::ToolError, ) { PolicyGate::Allow => {} - PolicyGate::Deny(sema_policy::ToolDenyAction::ToolError) => { + PolicyGate::Deny(decision) + if decision.action == sema_policy::ToolDenyAction::ToolError => + { denied.insert( call.id.clone(), - format!("Error: policy denied tool '{}'", call.name), + format!( + "tool '{}' was blocked: {}", + call.name, decision.denial.reason + ), ); } - PolicyGate::Deny(sema_policy::ToolDenyAction::Fail) => { - hard_denial.get_or_insert_with(|| call.name.clone()); + PolicyGate::Deny(decision) => { + hard_denial.get_or_insert(decision.denial); } } } - if let Some(tool) = hard_denial { - return Err(policy_denied(PolicyBoundary::Tool, &tool, "tools.denied")); + if let Some(denial) = hard_denial { + return Err(policy_denied(denial)); } Ok(denied) } @@ -435,7 +466,7 @@ fn enforce_direct_tool_policy( sema_policy::ToolDenyAction::Fail, ) { PolicyGate::Allow => Ok(()), - PolicyGate::Deny(_) => Err(policy_denied(PolicyBoundary::Tool, tool, "tools.denied")), + PolicyGate::Deny(decision) => Err(policy_denied(decision.denial)), } } @@ -526,6 +557,29 @@ fn check_active_policies( }) .collect(); let denied_action = decisions.iter().filter_map(|(_, action)| *action).max(); + let denial = denied_action.and_then(|effective_action| { + policies + .iter() + .zip(&decisions) + .find(|(_, (result, configured_action))| { + !result.allowed && *configured_action == Some(effective_action) + }) + .map(|(layer, (result, _))| PolicyDecision { + action: effective_action, + denial: PolicyDenial { + policy: Some(layer.policy.name().to_string()), + boundary: boundary.as_str().to_string(), + subject: subject.to_string(), + rule: result.rule.clone(), + reason: result + .reason + .clone() + .unwrap_or_else(|| "the active policy denied this operation".to_string()), + action: effective_action.name().to_string(), + source: source.as_str().to_string(), + }, + }) + }); for (layer, (result, configured_action)) in policies.iter().zip(decisions) { let observation = PolicyObservation { @@ -554,7 +608,7 @@ fn check_active_policies( }; (layer.sink)(observation); } - denied_action.map_or(PolicyGate::Allow, PolicyGate::Deny) + denial.map_or(PolicyGate::Allow, PolicyGate::Deny) } fn policy_value_digest(value: &serde_json::Value) -> String { @@ -569,6 +623,15 @@ fn policy_text_digest(text: &str) -> String { format!("sha256:{:x}", hasher.finalize()) } +fn output_policy_active() -> bool { + ACTIVE_POLICIES.with(|policies| { + policies + .borrow() + .iter() + .any(|layer| layer.policy.has_output_policy()) + }) +} + fn apply_text_policy( text: &str, boundary: PolicyBoundary, @@ -589,7 +652,17 @@ fn apply_text_policy( return Ok(text.to_string()); } if text.len() > sema_policy::content::INPUT_BYTE_CAP { - return Err(policy_denied(boundary, subject, "content.input-too-large")); + return Err(policy_denied(unnamed_policy_denial( + boundary, + subject, + "content.input-too-large", + format!( + "content exceeds the {}-byte policy limit", + sema_policy::content::INPUT_BYTE_CAP + ), + "block", + source, + ))); } let subject_digest = Some(policy_text_digest(text)); let agent_id = POLICY_AGENT_ID.with(|agent| agent.borrow().clone()); @@ -682,12 +755,40 @@ fn apply_text_policy( match effective_action { sema_policy::ContentAction::Block => { - let rule = outcomes + let denial = outcomes .iter() - .flat_map(|(_, outcome)| &outcome.findings) - .next() - .map_or("content.denied", |finding| finding.rule_id.as_str()); - Err(policy_denied(boundary, subject, rule)) + .filter(|(_, outcome)| outcome.action == sema_policy::ContentAction::Block) + .find_map(|(layer, outcome)| { + outcome.findings.first().map(|finding| PolicyDenial { + policy: Some(layer.policy.name().to_string()), + boundary: boundary.as_str().to_string(), + subject: subject.to_string(), + rule: finding.rule_id.clone(), + reason: format!( + "content matched {} ({} {})", + finding.label, + finding.count, + if finding.count == 1 { + "finding" + } else { + "findings" + } + ), + action: effective_action.as_str().to_string(), + source: source.as_str().to_string(), + }) + }) + .unwrap_or_else(|| { + unnamed_policy_denial( + boundary, + subject, + "content.denied", + "content policy blocked this value", + effective_action.as_str(), + source, + ) + }); + Err(policy_denied(denial)) } sema_policy::ContentAction::Redact => { let redactions = outcomes @@ -769,6 +870,29 @@ fn apply_output_policy_to_response( Ok(()) } +fn apply_input_policy_to_texts( + texts: &mut [String], + subject_prefix: &str, +) -> Result<(), SemaError> { + let transformed = texts + .iter() + .enumerate() + .map(|(index, text)| { + apply_text_policy( + text, + PolicyBoundary::LlmInput, + &format!("{subject_prefix}[{index}]"), + PolicySource::Request, + None, + ) + }) + .collect::, _>>()?; + for (text, safe) in texts.iter_mut().zip(transformed) { + *text = safe; + } + Ok(()) +} + /// Clear the per-thread last-usage slot. The workflow runtime calls this at the START /// of each agent leaf so that [`last_usage_snapshot`] read afterwards reflects ONLY a /// completion this leaf made — a leaf whose call fails (or makes none) reports `None` @@ -4824,7 +4948,13 @@ pub fn register_llm_builtins(env: &Env, sandbox: &sema_core::Sandbox) { responses .into_iter() .map(|response| { - let response = response.map_err(|error| SemaError::Llm(error.to_string()))?; + let mut response = response.map_err(|error| SemaError::Llm(error.to_string()))?; + if let Err(error) = + apply_output_policy_to_response(&mut response, PolicySource::Request) + { + track_usage(&response.usage)?; + return Err(error); + } track_usage(&response.usage)?; Ok(Value::string(&response.content)) }) @@ -4968,7 +5098,11 @@ pub fn register_llm_builtins(env: &Env, sandbox: &sema_core::Sandbox) { let mut results = Vec::with_capacity(responses.len()); for resp_result in responses { - let resp = resp_result.map_err(|e| SemaError::Llm(e.to_string()))?; + let mut resp = resp_result.map_err(|e| SemaError::Llm(e.to_string()))?; + if let Err(error) = apply_output_policy_to_response(&mut resp, PolicySource::Request) { + track_usage(&resp.usage)?; + return Err(error); + } track_usage(&resp.usage)?; results.push(Value::string(&resp.content)); } @@ -5127,7 +5261,8 @@ pub fn register_llm_builtins(env: &Env, sandbox: &sema_core::Sandbox) { None }; - let request = EmbedRequest { texts, model }; + let mut request = EmbedRequest { texts, model }; + apply_input_policy_to_texts(&mut request.texts, "embedding.input")?; let req_model = request.model.clone().unwrap_or_default(); let cassette_key = compute_embed_key(&request); @@ -5348,33 +5483,85 @@ pub fn register_llm_builtins(env: &Env, sandbox: &sema_core::Sandbox) { if args.len() < 2 || args.len() > 3 { return Err(SemaError::arity("llm/rerank", "2-3", args.len())); } - let query = args[0] + let mut query = args[0] .as_str() - .ok_or_else(|| SemaError::type_error("string query", args[0].type_name()))? + .ok_or_else(|| SemaError::argument_type("llm/rerank", 1, "string query", &args[0]))? .to_string(); - let documents: Vec = args[1] + let mut documents: Vec = args[1] .as_seq() - .ok_or_else(|| SemaError::type_error("list of strings", args[1].type_name()))? + .ok_or_else(|| { + SemaError::argument_type("llm/rerank", 2, "list or vector of strings", &args[1]) + })? .iter() - .map(|d| { - d.as_str() - .map(|s| s.to_string()) - .ok_or_else(|| SemaError::type_error("string document", d.type_name())) + .enumerate() + .map(|(index, document)| { + document.as_str().map(str::to_string).ok_or_else(|| { + SemaError::eval(format!( + "llm/rerank argument 2 entry {} must be a string, got {}", + index + 1, + document.type_name() + )) + }) }) .collect::>()?; if documents.is_empty() { return Ok(NativeOutcome::Return(Value::list(vec![]))); } + query = apply_text_policy( + &query, + PolicyBoundary::LlmInput, + "rerank.query", + PolicySource::Request, + None, + )?; + apply_input_policy_to_texts(&mut documents, "rerank.document")?; let mut top_k = None; let mut model = None; let mut provider = None; - if let Some(opts) = args.get(2).and_then(|v| v.as_map_rc()) { - top_k = get_opt_u32(&opts, "top-k").map(|n| n as usize); - model = get_opt_string(&opts, "model"); + if let Some(options) = args.get(2) { + let opts = options + .as_map_rc() + .ok_or_else(|| SemaError::argument_type("llm/rerank", 3, "map", options))?; + top_k = opts + .get(&Value::keyword("top-k")) + .map(|value| { + value + .as_int() + .and_then(|value| usize::try_from(value).ok()) + .filter(|value| *value > 0) + .ok_or_else(|| { + SemaError::eval(format!( + "llm/rerank option :top-k must be a positive integer, got {value}" + )) + }) + }) + .transpose()?; + model = opts + .get(&Value::keyword("model")) + .map(|value| { + value.as_str().map(str::to_string).ok_or_else(|| { + SemaError::eval(format!( + "llm/rerank option :model must be a string, got {}", + value.type_name() + )) + }) + }) + .transpose()?; provider = opts .get(&Value::keyword("provider")) - .and_then(|p| p.as_keyword().or_else(|| p.as_str().map(|s| s.to_string()))); + .map(|value| { + value + .as_keyword() + .or_else(|| value.as_str().map(str::to_string)) + .ok_or_else(|| { + SemaError::eval(format!( + "llm/rerank option :provider must be a keyword or string, got {}", + value.type_name() + )) + }) + }) + .transpose()?; } let request = RerankRequest { @@ -8303,7 +8490,8 @@ struct CompleteOffloadPlan { /// runtime completion paths use this stage to keep cache, cassette, and retry /// behavior aligned. #[cfg(not(target_arch = "wasm32"))] -fn complete_offload_prep(request: ChatRequest) -> Result { +fn complete_offload_prep(mut request: ChatRequest) -> Result { + apply_input_policy_to_request(&mut request)?; // Standalone completions get their own conversation scope (so the chat span // carries gen_ai.conversation.id); agent-nested ones inherit. The detached span // captures the conversation id at creation, so the guard need only live across @@ -8361,9 +8549,9 @@ fn complete_offload_prep(request: ChatRequest) -> Result Result { enforce_stored_model_policy(&entry.provider, &entry.model, PolicySource::Cassette)?; - let resp = entry.to_response(); - span.set_dispatch("cassette", &resp.model); - span.set_response(&response_facts("cassette", &resp)); + let mut resp = entry.to_response(); + apply_output_policy_to_response(&mut resp, PolicySource::Cassette)?; + set_guarded_response_telemetry(&span, &request, "cassette", &resp); drop(span); return Ok(CompletePrep::Inline(resp)); } @@ -8481,7 +8669,7 @@ fn finalize_complete_success( finalize: CompleteFinalize, ) -> sema_core::runtime::NativeResult { let CompleteOutcome { - resp, + mut resp, serving_provider, serving_model, retry_events, @@ -8493,6 +8681,17 @@ fn finalize_complete_success( emit_retry_spans(&retry_events); }); span.set_dispatch(&serving_provider, &serving_model); + if let Err(error) = apply_output_policy_to_response(&mut resp, PolicySource::Request) { + span.record_error("policy", &error.to_string()); + drop(span); + account_complete_usage( + &serving_provider, + &resp.usage, + usage_accum_slot.as_ref(), + budget_slot, + )?; + return Err(error); + } span.set_response(&response_facts(&serving_provider, &resp)); span.set_messages( &messages_json(&request_for_messages.messages), @@ -8514,33 +8713,40 @@ fn finalize_complete_success( crate::cassette::TapeEntry::from_response(key, &serving_provider, &resp), ); } + account_complete_usage( + &serving_provider, + &resp.usage, + usage_accum_slot.as_ref(), + budget_slot, + )?; + finalize.finish(resp) +} + +#[cfg(not(target_arch = "wasm32"))] +fn account_complete_usage( + serving_provider: &str, + usage: &Usage, + usage_accum_slot: Option<&Rc>>, + budget_slot: Option>>, +) -> Result<(), SemaError> { // Fold this completion into the LEAF'S OWN captured accumulator frame — the // `Rc` snapshotted at dispatch, not whatever scope is active when the offload - // lands (the finalize runs outside the per-task install boundary). Price it the - // same way `track_usage` does, then suppress `track_usage`'s own active-frame - // fold so this completion is counted exactly once. - if let Some(slot) = &usage_accum_slot { - let cost = pricing::calculate_cost_for(&serving_provider, &resp.usage); - accumulate_into(slot, &resp.usage, cost); - } - // Account on the VM thread, then shape the value. Install THIS completion's - // captured budget frame as active around `track_usage` so the charge + limit - // check land on the dispatch-time frame (shared by `Rc` across the fan-out), - // then restore whatever was active. - let track_result = { - let prev_budget = - ACTIVE_BUDGET.with(|b| std::mem::replace(&mut *b.borrow_mut(), budget_slot.clone())); - let r = USAGE_ACCUM_SUPPRESS.with(|s| { - s.set(true); - let r = track_usage(&resp.usage); - s.set(false); - r - }); - ACTIVE_BUDGET.with(|b| *b.borrow_mut() = prev_budget); - r - }; - track_result?; - finalize.finish(resp) + // lands. Suppress `track_usage`'s ambient accumulator fold so the completion + // is counted exactly once. + if let Some(slot) = usage_accum_slot { + let cost = pricing::calculate_cost_for(serving_provider, usage); + accumulate_into(slot, usage, cost); + } + let previous_budget = + ACTIVE_BUDGET.with(|active| std::mem::replace(&mut *active.borrow_mut(), budget_slot)); + let result = USAGE_ACCUM_SUPPRESS.with(|suppress| { + suppress.set(true); + let result = track_usage(usage); + suppress.set(false); + result + }); + ACTIVE_BUDGET.with(|active| *active.borrow_mut() = previous_budget); + result } /// Completion-kind tag for an agent/chat provider round offloaded through the @@ -8806,9 +9012,9 @@ impl RuntimeCompleteDriver { CACHE_MEM.with(|c| c.borrow_mut().insert(key.clone(), cached.clone())); } let usage_model = cached.model.clone(); - let resp = cache_hit_response(cached, usage_model); - plan.span.set_dispatch("", &resp.model); - plan.span.set_response(&response_facts("", &resp)); + let mut resp = cache_hit_response(cached, usage_model); + apply_output_policy_to_response(&mut resp, PolicySource::Cache)?; + set_guarded_response_telemetry(&plan.span, &plan.request_for_messages, "", &resp); drop(plan.span); track_usage(&resp.usage)?; return finalize.finish(resp); @@ -9605,7 +9811,8 @@ fn finalize_batch_responses( ) -> Result { let mut results = Vec::with_capacity(responses.len()); for resp_result in responses { - let resp = resp_result.map_err(|error| SemaError::Llm(error.to_string()))?; + let mut resp = resp_result.map_err(|error| SemaError::Llm(error.to_string()))?; + let policy_result = apply_output_policy_to_response(&mut resp, PolicySource::Request); // Priced with an empty provider, matching the sync path (which never // stamps a serving provider for `llm/batch`). if let Some(slot) = &usage_accum_slot { @@ -9622,6 +9829,7 @@ fn finalize_batch_responses( }); ACTIVE_BUDGET.with(|active| *active.borrow_mut() = prev_budget); track_result?; + policy_result?; results.push(Value::string(&resp.content)); } Ok(Value::list(results)) @@ -9805,11 +10013,19 @@ fn prepare_stream_cassette( match cassette_decide(&key).expect("cassette scope checked above") { crate::cassette::Decision::Replay(entry) => { enforce_stored_model_policy(&entry.provider, &entry.model, PolicySource::Cassette)?; - for chunk in &entry.chunks { - chunk_cb(chunk).map_err(|error| SemaError::Llm(error.to_string()))?; - } let provider = entry.provider.clone(); - let response = entry.to_response(); + let mut response = entry.to_response(); + if output_policy_active() { + apply_output_policy_to_response(&mut response, PolicySource::Cassette)?; + if !response.content.is_empty() { + chunk_cb(&response.content) + .map_err(|error| SemaError::Llm(error.to_string()))?; + } + } else { + for chunk in &entry.chunks { + chunk_cb(chunk).map_err(|error| SemaError::Llm(error.to_string()))?; + } + } span.set_dispatch("cassette", &response.model); span.set_response(&response_facts("cassette", &response)); set_serving_provider(&provider); @@ -9848,7 +10064,11 @@ fn stream_live( }) }; - let response = if let Some(key) = record_key { + let defer_output = output_policy_active(); + let mut response = if defer_output { + let mut discarded = |_chunk: &str| -> Result<(), crate::types::LlmError> { Ok(()) }; + stream_real(request.clone(), &mut discarded)? + } else if let Some(key) = record_key { let mut chunks = Vec::new(); let mut collect = |chunk: &str| -> Result<(), crate::types::LlmError> { chunks.push(chunk.to_string()); @@ -9865,6 +10085,28 @@ fn stream_live( } else { stream_real(request.clone(), chunk_cb)? }; + if defer_output { + if let Err(error) = apply_output_policy_to_response(&mut response, PolicySource::Request) { + track_usage(&response.usage)?; + return Err(error); + } + if let Some(key) = record_key { + let chunks = if response.content.is_empty() { + Vec::new() + } else { + vec![response.content.clone()] + }; + cassette_record(crate::cassette::TapeEntry::from_stream( + key, + p.name(), + &chunks, + &response, + )); + } + if !response.content.is_empty() { + chunk_cb(&response.content).map_err(|error| SemaError::Llm(error.to_string()))?; + } + } span.set_dispatch(p.name(), &request.model); span.set_response(&response_facts(p.name(), &response)); Ok(response) @@ -10758,10 +11000,11 @@ fn stream_one_provider( /// surfaces (failing over would re-emit the already-delivered partial — see the spike test /// `spike_mid_stream_failure_behaviour`). fn stream_with_dispatch( - request: ChatRequest, + mut request: ChatRequest, chunk_cb: &mut dyn FnMut(&str) -> Result<(), crate::types::LlmError>, span: &sema_otel::LlmSpan, ) -> Result { + apply_input_policy_to_request(&mut request)?; stream_budget_pregate()?; enforce_rate_limit(); @@ -12470,6 +12713,9 @@ struct StreamRunState { cassette_scope: Option, /// Every delta drained so far (cassette recording preserves boundaries). collected: Vec, + /// Output policies require terminal buffering so an unsafe prefix can never + /// escape before the assembled response is checked. + defer_deltas: bool, first_token_seen: bool, /// The assembled response, set once `Done(Ok)` has been finalized. response: Option, @@ -12481,7 +12727,7 @@ struct StreamRunState { /// A failure that arrived in a batch that still carried deltas: stored so the /// driver delivers those deltas to the callback first, then raised (and the /// entry dropped) on the next `__stream-next`/`__stream-finish`. - pending_error: Option, + pending_error: Option, } impl Drop for StreamRunState { @@ -12638,8 +12884,13 @@ fn resolve_stream_chain() -> Result<(Vec, bool), SemaError> { } /// Start a non-blocking stream run. Cassette replay does not reserve a rate-limit slot. -fn stream_run_begin(request: ChatRequest, span: sema_otel::LlmSpan) -> Result { +fn stream_run_begin( + mut request: ChatRequest, + span: sema_otel::LlmSpan, +) -> Result { + apply_input_policy_to_request(&mut request)?; stream_budget_pregate()?; + let defer_deltas = output_policy_active(); let cassette_scope = current_cassette_scope(); let cassette_decision = cassette_scope.as_ref().map(|scope| { @@ -12712,6 +12963,7 @@ fn stream_run_begin(request: ChatRequest, span: sema_otel::LlmSpan) -> Result Result { /// serving-provider stamp, cassette record, per-leaf usage fold, and /// budget-installed `track_usage` (exactly once per streamed completion). /// Returns the response, or the error message to surface. -fn stream_finalize( - done: StreamDone, +struct StreamFinalizeContext { span: Option, usage_accum_slot: Option>>, budget_slot: Option>>, cassette_record_key: Option, cassette_scope: Option, - collected: &[String], -) -> Result { + collected: Vec, + defer_deltas: bool, +} + +fn stream_finalize( + done: StreamDone, + context: StreamFinalizeContext, +) -> Result { + let StreamFinalizeContext { + span, + usage_accum_slot, + budget_slot, + cassette_record_key, + cassette_scope, + collected, + defer_deltas, + } = context; match done.result { - Ok(resp) => { + Ok(mut resp) => { + if defer_deltas { + let source = if done.provider == "cassette" { + PolicySource::Cassette + } else { + PolicySource::Request + }; + if let Err(error) = apply_output_policy_to_response(&mut resp, source) { + if let Some(span) = span { + span.set_dispatch(&done.provider, &resp.model); + span.record_error("policy", &error.to_string()); + } + if let Some(slot) = &usage_accum_slot { + let cost = pricing::calculate_cost_for(&done.provider, &resp.usage); + accumulate_into(slot, &resp.usage, cost); + } + let previous_budget = ACTIVE_BUDGET + .with(|active| std::mem::replace(&mut *active.borrow_mut(), budget_slot)); + let track_result = USAGE_ACCUM_SUPPRESS.with(|suppress| { + suppress.set(true); + let result = track_usage(&resp.usage); + suppress.set(false); + result + }); + ACTIVE_BUDGET.with(|active| *active.borrow_mut() = previous_budget); + track_result?; + return Err(error); + } + } if let Some(span) = span { span.set_dispatch(&done.provider, &resp.model); span.set_response(&response_facts(&done.provider, &resp)); @@ -13016,9 +13310,25 @@ fn stream_finalize( set_serving_provider(&done.provider); } if let Some(key) = &cassette_record_key { + let guarded_chunks; + let recorded_chunks = if defer_deltas { + guarded_chunks = if resp.content.is_empty() { + Vec::new() + } else { + vec![resp.content.clone()] + }; + guarded_chunks.as_slice() + } else { + &collected + }; cassette_scope_record( &cassette_scope, - crate::cassette::TapeEntry::from_stream(key, &done.provider, collected, &resp), + crate::cassette::TapeEntry::from_stream( + key, + &done.provider, + recorded_chunks, + &resp, + ), ); } // Fold into THIS run's captured accumulator frame, then suppress @@ -13040,16 +13350,13 @@ fn stream_finalize( ACTIVE_BUDGET.with(|b| *b.borrow_mut() = prev_budget); r }; - match track_result { - Ok(()) => Ok(resp), - Err(e) => Err(e.to_string()), - } + track_result.map(|()| resp) } Err(e) => { if let Some(span) = span { span.record_error(llm_error_kind(&e), &e.to_string()); } - Err(e.to_string()) + Err(SemaError::Llm(e.to_string())) } } } @@ -13117,7 +13424,9 @@ fn stream_poll_batch(token: u64, blocking: bool) -> Result, SemaEr span.mark_first_token(); } } - batch.push(Value::string(&s)); + if !st.defer_deltas { + batch.push(Value::string(&s)); + } st.collected.push(s); } Some(StreamEvent::Done(d)) => { @@ -13178,22 +13487,31 @@ fn stream_poll_batch(token: u64, blocking: bool) -> Result, SemaEr st.cassette_record_key.take(), st.cassette_scope.take(), std::mem::take(&mut st.collected), + st.defer_deltas, ) }) }); - let Some((span, usage_slot, budget_slot, record_key, cassette_scope, collected)) = ctx else { + let Some((span, usage_slot, budget_slot, record_key, cassette_scope, collected, defer_deltas)) = + ctx + else { return Err(SemaError::Llm("stream-run handle not found".to_string())); }; match stream_finalize( *done, - span, - usage_slot, - budget_slot, - record_key, - cassette_scope, - &collected, + StreamFinalizeContext { + span, + usage_accum_slot: usage_slot, + budget_slot, + cassette_record_key: record_key, + cassette_scope, + collected, + defer_deltas, + }, ) { Ok(resp) => { + if defer_deltas && !resp.content.is_empty() { + batch.push(Value::string(&resp.content)); + } STREAM_RUNS.with(|r| { if let Some(st) = r.borrow_mut().get_mut(&token) { st.response = Some(resp); @@ -13202,10 +13520,10 @@ fn stream_poll_batch(token: u64, blocking: bool) -> Result, SemaEr }); Ok(Some(stream_batch_map(batch, true))) } - Err(msg) => { + Err(error) => { STREAM_RUNS.with(|r| { if let Some(st) = r.borrow_mut().get_mut(&token) { - st.pending_error = Some(msg); + st.pending_error = Some(error); } }); Ok(Some(stream_batch_map(batch, false))) @@ -13334,7 +13652,7 @@ fn stream_next(token: u64) -> sema_core::runtime::NativeResult { use sema_core::runtime::NativeOutcome; enum Pre { - Err(String), + Err(SemaError), Done, Run { prefilled: bool }, } @@ -13343,11 +13661,11 @@ fn stream_next(token: u64) -> sema_core::runtime::NativeResult { let st = slab .get_mut(&token) .ok_or_else(|| SemaError::Llm("stream-run handle not found".to_string()))?; - if let Some(msg) = st.pending_error.take() { + if let Some(error) = st.pending_error.take() { // The deltas that preceded this failure were delivered last batch; // the run is over — drop the entry and surface. slab.remove(&token); - return Ok(Pre::Err(msg)); + return Ok(Pre::Err(error)); } if st.done { return Ok(Pre::Done); @@ -13360,7 +13678,7 @@ fn stream_next(token: u64) -> sema_core::runtime::NativeResult { })?; let prefilled = match pre { - Pre::Err(msg) => return Err(SemaError::Llm(msg)), + Pre::Err(error) => return Err(error), Pre::Done => return Ok(NativeOutcome::Return(stream_batch_map(Vec::new(), true))), Pre::Run { prefilled } => prefilled, }; @@ -13405,8 +13723,8 @@ fn stream_finish(token: u64) -> Result { let mut st = STREAM_RUNS .with(|r| r.borrow_mut().remove(&token)) .ok_or_else(|| SemaError::Llm("stream-run handle not found".to_string()))?; - if let Some(msg) = st.pending_error.take() { - return Err(SemaError::Llm(msg)); + if let Some(error) = st.pending_error.take() { + return Err(error); } let resp = st .response @@ -13424,8 +13742,8 @@ fn agent_stream_apply(agent_token: u64, stream_token: u64) -> Result Range { /// Build a diagnostic message from a `SemaError`, appending hint/note if present. pub(crate) fn format_error_message(err: &SemaError) -> String { - let mut message = match err.inner() { - SemaError::Reader { message, .. } => message.clone(), - other => other.to_string(), - }; - if let Some(hint) = err.hint() { - message.push_str(&format!("\nhint: {hint}")); - } - if let Some(note) = err.note() { - message.push_str(&format!("\nnote: {note}")); - } - message + err.format_diagnostic() } /// Convert a SemaError into a diagnostic with the given severity. diff --git a/crates/sema-mcp/src/tools.rs b/crates/sema-mcp/src/tools.rs index 0ce5b87e..b3a67318 100644 --- a/crates/sema-mcp/src/tools.rs +++ b/crates/sema-mcp/src/tools.rs @@ -520,22 +520,7 @@ where let captured = buf.lock().map(|b| b.clone()).unwrap_or_default(); match result { - // Keep structured hint/note: Display on WithContext is "{inner}" only, - // so plain "{e}" silently drops the VM's did-you-mean suggestions that - // the CLI prints — exactly the guidance an MCP client needs most. - Ok(r) => ( - r.map_err(|e| { - let mut message = e.to_string(); - if let Some(hint) = e.hint() { - message.push_str(&format!("\nhint: {hint}")); - } - if let Some(note) = e.note() { - message.push_str(&format!("\nnote: {note}")); - } - message - }), - captured, - ), + Ok(r) => (r.map_err(|e| e.format_plain()), captured), Err(panic) => std::panic::resume_unwind(panic), } } @@ -977,12 +962,14 @@ fn call_mcp_tool_inner( Interpreter::new_with_sandbox(&sema_core::Sandbox::allow_all()); let result = match compile_interpreter.compile_to_bytecode(&source) { Ok(r) => r, - Err(e) => return error_result(format!("Compile error: {}", e.inner())), + Err(e) => return error_result(format!("compilation failed: {}", e.format_plain())), }; let bytes = match sema_vm::serialize_to_bytes(&result, source_hash) { Ok(b) => b, - Err(e) => return error_result(format!("Serialization error: {}", e.inner())), + Err(e) => { + return error_result(format!("serialization failed: {}", e.format_plain())) + } }; let out_path = match output_path { @@ -1126,7 +1113,12 @@ fn call_mcp_tool_inner( let compile_result = if sema_vm::is_bytecode_file(&bytes) { match sema_vm::deserialize_from_bytes(&bytes) { Ok(r) => r, - Err(e) => return error_result(format!("Deserialization error: {}", e.inner())), + Err(e) => { + return error_result(format!( + "deserialization failed: {}", + e.format_plain() + )) + } } } else { let source = match std::str::from_utf8(&bytes) { @@ -1137,7 +1129,9 @@ fn call_mcp_tool_inner( Interpreter::new_with_sandbox(&sema_core::Sandbox::allow_all()); match compile_interpreter.compile_to_bytecode(source) { Ok(r) => r, - Err(e) => return error_result(format!("Compile error: {}", e.inner())), + Err(e) => { + return error_result(format!("compilation failed: {}", e.format_plain())) + } } }; diff --git a/crates/sema-policy/src/content.rs b/crates/sema-policy/src/content.rs index 7cdb1154..90153307 100644 --- a/crates/sema-policy/src/content.rs +++ b/crates/sema-policy/src/content.rs @@ -164,7 +164,7 @@ fn luhn_valid(digits: &str) -> bool { digit }) .sum(); - sum % 10 == 0 + sum.is_multiple_of(10) } fn merge_findings(findings: impl IntoIterator) -> Vec { diff --git a/crates/sema-policy/src/lib.rs b/crates/sema-policy/src/lib.rs index 9e2b6a33..27524ed0 100644 --- a/crates/sema-policy/src/lib.rs +++ b/crates/sema-policy/src/lib.rs @@ -9,7 +9,7 @@ pub mod content; use globset::{GlobBuilder, GlobMatcher}; use regex::Regex; -use sema_core::{FileAccess, ToolPolicySubject, Value}; +use sema_core::{suggest_similar, FileAccess, ToolPolicySubject, Value}; use sha2::{Digest, Sha256}; use std::collections::{BTreeMap, BTreeSet}; use std::path::{Component, Path, PathBuf}; @@ -20,9 +20,16 @@ const POLICY_VERSION: i64 = 1; /// A policy definition or matcher compilation error. #[derive(Debug, Error, Clone, PartialEq, Eq)] -pub enum PolicyError { - #[error("{0}")] - Invalid(String), +#[error("{message}")] +pub struct PolicyError { + message: String, + hint: Option, +} + +impl PolicyError { + pub fn hint(&self) -> Option<&str> { + self.hint.as_deref() + } } /// The default effect when no explicit rule matches. @@ -138,6 +145,8 @@ pub struct CompiledPolicy { subjects: Option, input: Option, output: Option, + metadata: Option, + completion: Option, } impl CompiledPolicy { @@ -154,6 +163,8 @@ impl CompiledPolicy { "subjects", "input", "output", + "metadata", + "completion", ], "policy", )?; @@ -185,6 +196,12 @@ impl CompiledPolicy { .map(|value| DetectorPolicy::compile(value, ":input", true)) .transpose()?; let output = get(map, "output").map(OutputPolicy::compile).transpose()?; + let metadata = get(map, "metadata") + .map(MetadataPolicy::compile) + .transpose()?; + let completion = get(map, "completion") + .map(CompletionPolicy::compile) + .transpose()?; let fingerprint = fingerprint(value, &name); Ok(Self { @@ -195,6 +212,8 @@ impl CompiledPolicy { subjects, input, output, + metadata, + completion, }) } @@ -267,6 +286,80 @@ impl CompiledPolicy { .as_ref() .map_or_else(ContentOutcome::allow, |policy| policy.check(text, stage)) } + + pub fn required_metadata(&self) -> impl Iterator { + self.metadata + .iter() + .flat_map(|policy| policy.required.iter().map(String::as_str)) + } + + pub fn required_completion_events(&self) -> impl Iterator { + self.completion + .iter() + .flat_map(|policy| policy.required_events.iter().map(String::as_str)) + } +} + +#[derive(Debug)] +struct MetadataPolicy { + required: BTreeSet, +} + +impl MetadataPolicy { + fn compile(value: &Value) -> Result { + let map = require_map(value, ":metadata")?; + reject_unknown_keys(map, &["require"], ":metadata")?; + let required = parse_name_set(get(map, "require"), ":metadata :require")?; + if required.is_empty() { + return Err(invalid(":metadata :require must not be empty")); + } + Ok(Self { required }) + } +} + +#[derive(Debug)] +struct CompletionPolicy { + required_events: BTreeSet, +} + +impl CompletionPolicy { + fn compile(value: &Value) -> Result { + let map = require_map(value, ":completion")?; + reject_unknown_keys(map, &["require-events"], ":completion")?; + let required_events = + parse_name_set(get(map, "require-events"), ":completion :require-events")?; + if required_events.is_empty() { + return Err(invalid(":completion :require-events must not be empty")); + } + const SUPPORTED_EVENTS: &[&str] = &[ + "run.started", + "phase.started", + "phase.ended", + "agent.started", + "agent.result", + "agent.tool_call", + "agent.tool_result", + "checkpoint", + "budget", + "auth.required", + "auth.granted", + "auth.failed", + "policy.checked", + "policy.flagged", + "policy.redacted", + "policy.violation", + "policy.bypassed", + ]; + for event in &required_events { + if !SUPPORTED_EVENTS.contains(&event.as_str()) { + return Err(invalid_with_hint( + format!(":completion requires unsupported event {event:?}"), + format!("valid events are {}", SUPPORTED_EVENTS.join(", ")), + )); + } + } + Ok(Self { required_events }) + } } #[derive(Debug)] @@ -285,14 +378,24 @@ impl ModelPolicy { default: parse_default(get(map, "default"), ":models")?, allow: parse_model_patterns(get(map, "allow"), ":models :allow")?, deny: parse_model_patterns(get(map, "deny"), ":models :deny")?, - on_deny: match get(map, "on-deny").and_then(value_name).as_deref() { - None | Some("fail") => ModelDenyAction::Fail, - Some("skip") => ModelDenyAction::Skip, - Some(other) => { - return Err(invalid(format!( - ":models :on-deny must be :fail or :skip, got {other:?}" - ))) - } + on_deny: match get(map, "on-deny") { + None => ModelDenyAction::Fail, + Some(value) => match value_name(value).as_deref() { + Some("fail") => ModelDenyAction::Fail, + Some("skip") => ModelDenyAction::Skip, + Some(other) => { + return Err(invalid_with_hint( + format!(":models :on-deny has unsupported value :{other}"), + "valid values are :fail and :skip", + )) + } + None => { + return Err(invalid(format!( + ":models :on-deny must be a keyword or string, got {}", + value.type_name() + ))) + } + }, }, }) } @@ -495,7 +598,11 @@ impl OutputPolicy { .as_int() .and_then(|value| usize::try_from(value).ok()) .filter(|value| *value > 0) - .ok_or_else(|| invalid(":output :max-length must be a positive integer")) + .ok_or_else(|| { + invalid(format!( + ":output :max-length must be a positive integer, got {value}" + )) + }) }) .transpose()?; Ok(Self { @@ -607,7 +714,7 @@ struct ForbidRule { impl ForbidRule { fn compile(value: &Value, index: usize) -> Result { - let context = format!(":output :forbid[{index}]"); + let context = format!(":output :forbid entry {}", index + 1); let map = require_map(value, &context)?; reject_unknown_keys(map, &["id", "contains", "regex"], &context)?; let id = get(map, "id") @@ -799,7 +906,8 @@ fn parse_detectors( }; require_seq(value, context)? .iter() - .map(|value| parse_detector(value, context)) + .enumerate() + .map(|(index, value)| parse_detector(value, &format!("{context} entry {}", index + 1))) .collect() } @@ -810,10 +918,14 @@ fn parse_detector(value: &Value, context: &str) -> Result Ok(content::DetectorKind::Phone), Some("ipv4") => Ok(content::DetectorKind::Ipv4), Some("payment-card") => Ok(content::DetectorKind::PaymentCard), - Some(other) => Err(invalid(format!( - "{context} has unsupported detector {other:?}" + Some(other) => Err(invalid_with_hint( + format!("{context} has unsupported detector :{other}"), + "valid detectors are :secret, :email, :phone, :ipv4, and :payment-card", + )), + None => Err(invalid(format!( + "{context} must be a keyword or string, got {}", + value.type_name() ))), - None => Err(invalid(format!("{context} entries must be detector names"))), } } @@ -823,10 +935,14 @@ fn parse_content_action(value: &Value, context: &str) -> Result Ok(ContentAction::Audit), Some("redact") => Ok(ContentAction::Redact), Some("block") => Ok(ContentAction::Block), - Some(other) => Err(invalid(format!( - "{context} action must be :audit, :redact, or :block, got {other:?}" + Some(other) => Err(invalid_with_hint( + format!("{context} action has unsupported value :{other}"), + "valid actions are :allow, :audit, :redact, and :block", + )), + None => Err(invalid(format!( + "{context} action must be a keyword or string, got {}", + value.type_name() ))), - None => Err(invalid(format!("{context} action must be a name"))), } } @@ -861,14 +977,24 @@ impl ToolPolicy { } }; let deny = parse_string_set(get(map, "deny"), ":tools :deny")?; - let on_deny = match get(map, "on-deny").and_then(value_name).as_deref() { - None | Some("fail") => ToolDenyAction::Fail, - Some("tool-error") => ToolDenyAction::ToolError, - Some(other) => { - return Err(invalid(format!( - ":tools :on-deny must be :fail or :tool-error, got {other:?}" - ))) - } + let on_deny = match get(map, "on-deny") { + None => ToolDenyAction::Fail, + Some(value) => match value_name(value).as_deref() { + Some("fail") => ToolDenyAction::Fail, + Some("tool-error") => ToolDenyAction::ToolError, + Some(other) => { + return Err(invalid_with_hint( + format!(":tools :on-deny has unsupported value :{other}"), + "valid values are :fail and :tool-error", + )) + } + None => { + return Err(invalid(format!( + ":tools :on-deny must be a keyword or string, got {}", + value.type_name() + ))) + } + }, }; Ok(Self { default: parse_default(get(map, "default"), ":tools")?, @@ -996,11 +1122,13 @@ impl SubjectKind { Some("network-request") => Ok(Self::NetworkRequest), Some("command") => Ok(Self::Command), Some("external-action") => Ok(Self::ExternalAction), - Some(other) => Err(invalid(format!( - "{context} has unsupported :kind {other:?}" - ))), + Some(other) => Err(invalid_with_hint( + format!("{context} has unsupported :kind :{other}"), + "valid kinds are :file-read, :file-write, :file-delete, :network-request, :command, and :external-action", + )), None => Err(invalid(format!( - "{context} :kind must be a keyword or string" + "{context} :kind must be a keyword or string, got {}", + value.type_name() ))), } } @@ -1754,11 +1882,19 @@ fn fingerprint(value: &Value, name: &str) -> String { } fn parse_default(value: Option<&Value>, context: &str) -> Result { - match value.and_then(value_name).as_deref() { - None | Some("deny") => Ok(DefaultEffect::Deny), + let Some(value) = value else { + return Ok(DefaultEffect::Deny); + }; + match value_name(value).as_deref() { + Some("deny") => Ok(DefaultEffect::Deny), Some("allow") => Ok(DefaultEffect::Allow), - Some(other) => Err(invalid(format!( - "{context} :default must be :allow or :deny, got {other:?}" + Some(other) => Err(invalid_with_hint( + format!("{context} :default has unsupported value :{other}"), + "valid values are :allow and :deny", + )), + None => Err(invalid(format!( + "{context} :default must be a keyword or string, got {}", + value.type_name() ))), } } @@ -1783,9 +1919,15 @@ fn parse_name_set(value: Option<&Value>, context: &str) -> Result, context: &str) -> Result }; require_seq(value, context)? .iter() - .map(|value| { - value - .as_str() - .map(str::to_string) - .ok_or_else(|| invalid(format!("{context} entries must be strings"))) + .enumerate() + .map(|(index, value)| { + value.as_str().map(str::to_string).ok_or_else(|| { + invalid(format!( + "{context} entry {} must be a string, got {}", + index + 1, + value.type_name() + )) + }) }) .collect() } fn require_seq(value: &Value, context: &str) -> Result, PolicyError> { - value - .as_seq() - .map(|values| values.to_vec()) - .ok_or_else(|| invalid(format!("{context} must be a list or vector"))) + value.as_seq().map(|values| values.to_vec()).ok_or_else(|| { + invalid(format!( + "{context} must be a list or vector, got {}", + value.type_name() + )) + }) } fn require_map<'a>( value: &'a Value, context: &str, ) -> Result<&'a BTreeMap, PolicyError> { - value - .as_map_ref() - .ok_or_else(|| invalid(format!("{context} must be a map"))) + value.as_map_ref().ok_or_else(|| { + invalid(format!( + "{context} must be a map, got {}", + value.type_name() + )) + }) } fn get<'a>(map: &'a BTreeMap, key: &str) -> Option<&'a Value> { @@ -1842,23 +1993,49 @@ fn reject_unknown_keys( ) -> Result<(), PolicyError> { let mut seen = BTreeSet::new(); for key in map.keys() { - let key = value_name(key).ok_or_else(|| { + let key_name = value_name(key).ok_or_else(|| { invalid(format!( - "{context} keys must be keywords, strings, or symbols" + "{context} keys must be keywords, strings, or symbols, got {}", + key.type_name() )) })?; - if !allowed.contains(&key.as_str()) { - return Err(invalid(format!("{context} has unknown key :{key}"))); + if !allowed.contains(&key_name.as_str()) { + let hint = suggest_similar(&key_name, allowed) + .map(|candidate| format!("did you mean :{candidate}?")) + .unwrap_or_else(|| { + format!( + "valid keys are {}", + allowed + .iter() + .map(|key| format!(":{key}")) + .collect::>() + .join(", ") + ) + }); + return Err(invalid_with_hint( + format!("{context} has unknown key :{key_name}"), + hint, + )); } - if !seen.insert(key.clone()) { - return Err(invalid(format!("{context} has duplicate key {key:?}"))); + if !seen.insert(key_name.clone()) { + return Err(invalid(format!("{context} has duplicate key :{key_name}"))); } } Ok(()) } fn invalid(message: impl Into) -> PolicyError { - PolicyError::Invalid(message.into()) + PolicyError { + message: message.into(), + hint: None, + } +} + +fn invalid_with_hint(message: impl Into, hint: impl Into) -> PolicyError { + PolicyError { + message: message.into(), + hint: Some(hint.into()), + } } #[cfg(test)] @@ -2073,6 +2250,39 @@ mod tests { ); } + #[test] + fn metadata_and_completion_requirements_are_strict_and_stable() { + let policy = CompiledPolicy::compile(&named_policy([ + ( + "metadata", + map([("require", strings(&["owner", "risk-tier"]))]), + ), + ( + "completion", + map([( + "require-events", + strings(&["agent.tool_result", "checkpoint"]), + )]), + ), + ])) + .unwrap(); + assert_eq!( + policy.required_metadata().collect::>(), + vec!["owner", "risk-tier"] + ); + assert_eq!( + policy.required_completion_events().collect::>(), + vec!["agent.tool_result", "checkpoint"] + ); + + let error = CompiledPolicy::compile(&named_policy([( + "completion", + map([("require-events", strings(&["made.up"]))]), + )])) + .unwrap_err(); + assert!(error.to_string().contains("unsupported event")); + } + #[test] fn unknown_keys_are_rejected_instead_of_being_ignored() { let error = CompiledPolicy::compile(&named_policy([( @@ -2081,6 +2291,37 @@ mod tests { )])) .unwrap_err(); assert!(error.to_string().contains("unknown key :alow")); + assert_eq!(error.hint(), Some("did you mean :allow?")); + } + + #[test] + fn list_errors_include_one_based_index_and_actual_type() { + let error = CompiledPolicy::compile(&named_policy([( + "models", + map([( + "allow", + Value::vector(vec![Value::string("fake/*"), Value::int(42)]), + )]), + )])) + .unwrap_err(); + assert_eq!( + error.to_string(), + ":models :allow entry 2 must be a string, got int" + ); + } + + #[test] + fn enum_errors_use_keyword_notation_and_list_valid_values() { + let error = CompiledPolicy::compile(&named_policy([( + "tools", + map([("on-deny", Value::keyword("ignore"))]), + )])) + .unwrap_err(); + assert_eq!( + error.to_string(), + ":tools :on-deny has unsupported value :ignore" + ); + assert_eq!(error.hint(), Some("valid values are :fail and :tool-error")); } #[test] diff --git a/crates/sema-stdlib/src/io.rs b/crates/sema-stdlib/src/io.rs index 39e0ef21..aadc4118 100644 --- a/crates/sema-stdlib/src/io.rs +++ b/crates/sema-stdlib/src/io.rs @@ -2635,7 +2635,7 @@ pub fn register(env: &sema_core::Env, sandbox: &sema_core::Sandbox) { check_arity!(args, "file/read", 1); let path = args[0] .as_str() - .ok_or_else(|| SemaError::type_error("string", args[0].type_name()))?; + .ok_or_else(|| SemaError::argument_type("file/read", 1, "string", &args[0]))?; if let Some(data) = sema_core::vfs::vfs_read(path) { return String::from_utf8(data) .map_err(|e| SemaError::Io(format!("file/read {path}: invalid UTF-8 in VFS: {e}"))) diff --git a/crates/sema-stdlib/src/json.rs b/crates/sema-stdlib/src/json.rs index 5058dc35..1cf4e268 100644 --- a/crates/sema-stdlib/src/json.rs +++ b/crates/sema-stdlib/src/json.rs @@ -26,7 +26,7 @@ pub fn register(env: &sema_core::Env) { register_fn(env, "json/decode", |args| { check_arity!(args, "json/decode", 1); let s = args[0].as_str().ok_or_else(|| { - SemaError::type_error("string", args[0].type_name()) + SemaError::argument_type("json/decode", 1, "string", &args[0]) .with_hint("json/decode: argument 1 must be a JSON-encoded string") })?; let json: serde_json::Value = serde_json::from_str(s).map_err(|e| { diff --git a/crates/sema-stdlib/src/list.rs b/crates/sema-stdlib/src/list.rs index 265883dd..c40cafe1 100644 --- a/crates/sema-stdlib/src/list.rs +++ b/crates/sema-stdlib/src/list.rs @@ -2010,7 +2010,7 @@ pub fn register(env: &sema_core::Env) { } else { "nth: argument order is (nth collection index); the index must be an integer" }; - SemaError::type_error("int", args[1].type_name()).with_hint(hint) + SemaError::argument_type("nth", 2, "int", &args[1]).with_hint(hint) })?; if idx_i < 0 { return Err( @@ -2036,8 +2036,10 @@ pub fn register(env: &sema_core::Env) { )) }) } else { - Err(SemaError::type_error("list or vector", args[0].type_name()) - .with_hint("nth: argument 1 must be a list, vector, or mutable-array")) + Err( + SemaError::argument_type("nth", 1, "list, vector, or mutable-array", &args[0]) + .with_hint("nth: argument 1 must be a list, vector, or mutable-array"), + ) } }); diff --git a/crates/sema-stdlib/src/reflect.rs b/crates/sema-stdlib/src/reflect.rs index a639a48c..7cad4d3d 100644 --- a/crates/sema-stdlib/src/reflect.rs +++ b/crates/sema-stdlib/src/reflect.rs @@ -38,6 +38,7 @@ fn diagnostic(e: &SemaError) -> Value { SemaError::Unbound(_) => "unbound-symbol", SemaError::Arity { .. } => "arity", SemaError::Type { .. } => "type", + SemaError::Internal(_) => "internal", _ => "error", }; m.insert(kw("code"), Value::string(code)); diff --git a/crates/sema-stdlib/src/string.rs b/crates/sema-stdlib/src/string.rs index 28055238..bbf40d3d 100644 --- a/crates/sema-stdlib/src/string.rs +++ b/crates/sema-stdlib/src/string.rs @@ -245,7 +245,7 @@ pub fn register(env: &sema_core::Env) { check_arity!(args, "string-length", 1); let s = args[0] .as_str() - .ok_or_else(|| SemaError::type_error("string", args[0].type_name()))?; + .ok_or_else(|| SemaError::argument_type("string-length", 1, "string", &args[0]))?; Ok(Value::int(s.chars().count() as i64)) }); @@ -253,10 +253,10 @@ pub fn register(env: &sema_core::Env) { check_arity!(args, "string-ref", 2); let s = args[0] .as_str() - .ok_or_else(|| SemaError::type_error("string", args[0].type_name()))?; + .ok_or_else(|| SemaError::argument_type("string-ref", 1, "string", &args[0]))?; let idx_signed = args[1] .as_int() - .ok_or_else(|| SemaError::type_error("int", args[1].type_name()))?; + .ok_or_else(|| SemaError::argument_type("string-ref", 2, "int", &args[1]))?; if idx_signed < 0 { return Err(SemaError::eval(format!( "string-ref: index {idx_signed} must be non-negative" @@ -276,10 +276,10 @@ pub fn register(env: &sema_core::Env) { check_arity!(args, "substring", 2..=3); let s = args[0] .as_str() - .ok_or_else(|| SemaError::type_error("string", args[0].type_name()))?; + .ok_or_else(|| SemaError::argument_type("substring", 1, "string", &args[0]))?; let start_signed = args[1] .as_int() - .ok_or_else(|| SemaError::type_error("int", args[1].type_name()))?; + .ok_or_else(|| SemaError::argument_type("substring", 2, "int", &args[1]))?; if start_signed < 0 { return Err(SemaError::eval(format!( "substring: start index {start_signed} must be non-negative" @@ -290,7 +290,7 @@ pub fn register(env: &sema_core::Env) { let end = if args.len() == 3 { let end_signed = args[2] .as_int() - .ok_or_else(|| SemaError::type_error("int", args[2].type_name()))?; + .ok_or_else(|| SemaError::argument_type("substring", 3, "int", &args[2]))?; if end_signed < 0 { return Err(SemaError::eval(format!( "substring: end index {end_signed} must be non-negative" @@ -320,10 +320,10 @@ pub fn register(env: &sema_core::Env) { check_arity!(args, "string/split", 2); let s = args[0] .as_str() - .ok_or_else(|| SemaError::type_error("string", args[0].type_name()))?; + .ok_or_else(|| SemaError::argument_type("string/split", 1, "string", &args[0]))?; let sep = args[1] .as_str() - .ok_or_else(|| SemaError::type_error("string", args[1].type_name()))?; + .ok_or_else(|| SemaError::argument_type("string/split", 2, "string", &args[1]))?; let parts: Vec = s.split(sep).map(Value::string).collect(); Ok(Value::list(parts)) }); @@ -334,7 +334,7 @@ pub fn register(env: &sema_core::Env) { check_arity!(args, "string/lines", 1); let s = args[0] .as_str() - .ok_or_else(|| SemaError::type_error("string", args[0].type_name()))?; + .ok_or_else(|| SemaError::argument_type("string/lines", 1, "string", &args[0]))?; Ok(Value::list(s.lines().map(Value::string).collect())) }); @@ -342,7 +342,7 @@ pub fn register(env: &sema_core::Env) { check_arity!(args, "string/trim", 1); let s = args[0] .as_str() - .ok_or_else(|| SemaError::type_error("string", args[0].type_name()))?; + .ok_or_else(|| SemaError::argument_type("string/trim", 1, "string", &args[0]))?; Ok(Value::string(s.trim())) }); @@ -350,21 +350,21 @@ pub fn register(env: &sema_core::Env) { check_arity!(args, "string/contains?", 2); let s = args[0] .as_str() - .ok_or_else(|| SemaError::type_error("string", args[0].type_name()))?; + .ok_or_else(|| SemaError::argument_type("string/contains?", 1, "string", &args[0]))?; let sub = args[1] .as_str() - .ok_or_else(|| SemaError::type_error("string", args[1].type_name()))?; + .ok_or_else(|| SemaError::argument_type("string/contains?", 2, "string", &args[1]))?; Ok(Value::bool(s.contains(sub))) }); register_fn(env, "string/starts-with?", |args| { check_arity!(args, "string/starts-with?", 2); - let s = args[0] - .as_str() - .ok_or_else(|| SemaError::type_error("string", args[0].type_name()))?; - let prefix = args[1] - .as_str() - .ok_or_else(|| SemaError::type_error("string", args[1].type_name()))?; + let s = args[0].as_str().ok_or_else(|| { + SemaError::argument_type("string/starts-with?", 1, "string", &args[0]) + })?; + let prefix = args[1].as_str().ok_or_else(|| { + SemaError::argument_type("string/starts-with?", 2, "string", &args[1]) + })?; Ok(Value::bool(s.starts_with(prefix))) }); @@ -372,10 +372,10 @@ pub fn register(env: &sema_core::Env) { check_arity!(args, "string/ends-with?", 2); let s = args[0] .as_str() - .ok_or_else(|| SemaError::type_error("string", args[0].type_name()))?; + .ok_or_else(|| SemaError::argument_type("string/ends-with?", 1, "string", &args[0]))?; let suffix = args[1] .as_str() - .ok_or_else(|| SemaError::type_error("string", args[1].type_name()))?; + .ok_or_else(|| SemaError::argument_type("string/ends-with?", 2, "string", &args[1]))?; Ok(Value::bool(s.ends_with(suffix))) }); @@ -383,7 +383,7 @@ pub fn register(env: &sema_core::Env) { check_arity!(args, "string/upper", 1); let s = args[0] .as_str() - .ok_or_else(|| SemaError::type_error("string", args[0].type_name()))?; + .ok_or_else(|| SemaError::argument_type("string/upper", 1, "string", &args[0]))?; Ok(Value::string_owned(s.to_uppercase())) }); @@ -391,7 +391,7 @@ pub fn register(env: &sema_core::Env) { check_arity!(args, "string/lower", 1); let s = args[0] .as_str() - .ok_or_else(|| SemaError::type_error("string", args[0].type_name()))?; + .ok_or_else(|| SemaError::argument_type("string/lower", 1, "string", &args[0]))?; Ok(Value::string_owned(s.to_lowercase())) }); diff --git a/crates/sema-stdlib/src/workflow.rs b/crates/sema-stdlib/src/workflow.rs index 1ab5c6ad..1d7d6dbf 100644 --- a/crates/sema-stdlib/src/workflow.rs +++ b/crates/sema-stdlib/src/workflow.rs @@ -27,7 +27,7 @@ use sema_core::runtime::{ NativeContinuation, NativeOutcome, NativeResult, NativeSuspend, PreparedExternalOperation, ResumeInput, SendPayload, TaskContextHandle, Trace, WaitKind, }; -use sema_core::{SemaError, Value}; +use sema_core::{PolicyDenial, SemaError, Value}; use sema_llm::builtins::{ PolicyAttributionScope, PolicyBypassScope, PolicyDecisionSink, PolicyObservation, PolicyObservationKind, PolicyScope, @@ -73,9 +73,10 @@ fn compile_policy( vec![policy] } else { let policies = policy.as_seq().ok_or_else(|| { - SemaError::eval( - "invalid workflow policy: :policy must be a map or nonempty sequence of maps", - ) + SemaError::eval(format!( + "invalid workflow policy: :policy must be a map or nonempty sequence of maps, got {}", + policy.type_name() + )) })?; if policies.is_empty() { return Err(SemaError::eval( @@ -92,9 +93,16 @@ fn compile_policy( sema_policy::CompiledPolicy::compile(value) .map(Rc::new) .map_err(|error| { - SemaError::eval(format!( - "invalid workflow policy layer {index}: {error}" - )) + let hint = error.hint().map(str::to_string); + let error = SemaError::eval(format!( + "invalid workflow policy layer {}: {error}", + index + 1 + )); + if let Some(hint) = hint { + error.with_hint(hint) + } else { + error + } }) }) .collect() @@ -102,6 +110,71 @@ fn compile_policy( .transpose() } +fn value_is_present(value: &Value) -> bool { + if value.is_nil() { + return false; + } + if let Some(text) = value.as_str() { + return !text.trim().is_empty(); + } + if let Some(items) = value.as_seq() { + return !items.is_empty(); + } + if let Some(map) = value.as_map_rc() { + return !map.is_empty(); + } + true +} + +fn validate_required_metadata( + policies: Option<&[Rc]>, + meta: &Value, +) -> Result<(), SemaError> { + let map = meta.as_map_rc(); + for policy in policies.into_iter().flatten() { + let missing = policy + .required_metadata() + .filter(|key| { + map.as_ref() + .and_then(|metadata| metadata.get(&Value::keyword(key))) + .is_none_or(|value| !value_is_present(value)) + }) + .collect::>(); + if missing.is_empty() { + continue; + } + let missing = missing.into_iter().collect::>(); + return Err(SemaError::policy_denied(PolicyDenial { + policy: Some(policy.name().to_string()), + boundary: "workflow.metadata".to_string(), + subject: "workflow".to_string(), + rule: format!("metadata.missing.{}", missing.join(",")), + reason: format!( + "required workflow metadata is missing: {}", + missing + .iter() + .map(|key| format!(":{key}")) + .collect::>() + .join(", ") + ), + action: "fail".to_string(), + source: "request".to_string(), + })); + } + Ok(()) +} + +fn required_completion_events(policies: Option<&[Rc]>) -> Vec { + policies + .into_iter() + .flatten() + .flat_map(|policy| policy.required_completion_events()) + .map(str::to_string) + .collect::>() + .into_iter() + .collect() +} + fn policy_sink(ctx: &Rc) -> PolicyDecisionSink { let weak = Rc::downgrade(ctx); Rc::new(move |observation| { @@ -300,6 +373,13 @@ fn success_envelope(value: Value) -> Value { Value::map(m) } +fn envelope_status(envelope: &Value) -> Option { + envelope + .as_map_rc()? + .get(&Value::keyword("status")) + .and_then(as_name) +} + /// Close the currently-open marker phase, if any, emitting its `phase.ended` with the /// given status. No-op when no phase is open (a workflow with no `(phase …)` markers, /// or after the last phase already closed). Called both by the `(phase …)` marker (to @@ -662,7 +742,7 @@ fn policy_bypass_plan( } let reason = args[0] .as_str() - .ok_or_else(|| SemaError::type_error("string", args[0].type_name()))? + .ok_or_else(|| SemaError::argument_type("policy/without", 1, "string", &args[0]))? .trim() .to_string(); if reason.is_empty() || reason.chars().count() > 256 { @@ -847,6 +927,7 @@ fn finish_checkpoint( struct RunTeardown { _guard: context::WorkflowGuard, _policy_scope: Option, + required_events: Vec, mcp: Option, } @@ -893,9 +974,13 @@ fn finish_run( durable: bool, ) -> NativeResult { let (mut status, mut envelope, mut reason) = match &result { - Ok(v) => ("success", success_envelope(v.clone()), None), + Ok(v) => { + let envelope = success_envelope(v.clone()); + let status = envelope_status(&envelope).unwrap_or_else(|| "success".to_string()); + (status, envelope, None) + } Err(e) => ( - "failed", + "failed".to_string(), failed_envelope(&e.to_string()), Some("workflow body returned an error".to_string()), ), @@ -906,15 +991,32 @@ fn finish_run( let ack = if let Some(ctx) = &ctx { // A tripped budget cap fails the run regardless of the body's own outcome. if ctx.over_budget() { - status = "failed"; + status = "failed".to_string(); envelope = budget_failed_envelope(); reason = Some("budget exceeded".to_string()); } - close_open_phase(ctx, status); + if status == "success" { + let missing = teardown + .required_events + .iter() + .filter(|event| !ctx.has_event(event)) + .cloned() + .collect::>(); + if !missing.is_empty() { + status = "failed".to_string(); + let message = format!( + "completion policy missing required events: {}", + missing.join(", ") + ); + envelope = failed_envelope(&message); + reason = Some(message); + } + } + close_open_phase(ctx, &status); ctx.emit(WorkflowEvent::RunEnded { seq: ctx.next_seq(), ts: ctx.ts(), - status: status.into(), + status, reason, dur_ms: ctx.dur_ms(), }); @@ -1100,6 +1202,7 @@ fn run_plan( let meta = args[2].clone(); let thunk = args[3].clone(); let policy = compile_policy(&meta)?; + validate_required_metadata(policy.as_deref(), &meta)?; let workspace_root = std::env::current_dir() .map_err(|error| SemaError::eval(format!("workflow/run: current directory: {error}")))?; @@ -1145,12 +1248,14 @@ fn run_plan( if decls.is_empty() { let ctx = context::current_for(task_context) .ok_or_else(|| SemaError::eval("workflow/run: scope not established"))?; + let required_events = required_completion_events(policy.as_deref()); let policy_scope = open_compiled_policy(policy, &ctx, &workspace_root); return Ok(ThunkPlan::Run { thunk, teardown: RunTeardown { _guard: guard, _policy_scope: policy_scope, + required_events, mcp: None, }, }); @@ -1330,12 +1435,14 @@ fn apply_resolutions( // Every declared server connected: publish handles for workflow/mcp-handle, and // remember (resolver, handles) so `finish_run` closes them EXACTLY once. ctx.set_mcp_handles(connected); + let required_events = required_completion_events(policy.as_deref()); let policy_scope = open_compiled_policy(policy, &ctx, &workspace_root); Ok(ResolveGate::Proceed { thunk, teardown: RunTeardown { _guard: guard, _policy_scope: policy_scope, + required_events, mcp: Some(McpClose { resolver, handles: connected_handles, @@ -1560,6 +1667,28 @@ pub fn register(env: &sema_core::Env) { Ok(Value::nil()) }); + // Successful tool completion evidence. The event deliberately carries only + // a gated sentinel, never the callback's result preview. + register_scoped_fn(env, "workflow/tool-result", |task_context, args| { + if args.len() != 1 { + return Err(SemaError::arity("workflow/tool-result", "1", args.len())); + } + let tool_name = as_name(&args[0]) + .ok_or_else(|| SemaError::type_error("keyword or string", args[0].type_name()))?; + if let Some(ctx) = context::current_for(task_context) { + if let Some(agent_id) = context::cur_agent_for(task_context) { + ctx.emit(WorkflowEvent::AgentToolResult { + seq: ctx.next_seq(), + ts: ctx.ts(), + agent_id, + tool_name, + result_digest: "gated".to_string(), + }); + } + } + Ok(Value::nil()) + }); + // (workflow/checkpoint :k thunk) records+returns (thunk) and emits a checkpoint // event; (workflow/checkpoint :k) reads the stored value (nil if unset). The // public (checkpoint :k v) macro delays v into the thunk, so a resume memo hit can diff --git a/crates/sema-stdlib/src/workflow_check.rs b/crates/sema-stdlib/src/workflow_check.rs index 44193654..2d328fc7 100644 --- a/crates/sema-stdlib/src/workflow_check.rs +++ b/crates/sema-stdlib/src/workflow_check.rs @@ -208,11 +208,12 @@ fn find_workflows_and_policies(form: &Value, spans: &SpanMap, out: &mut Vec, out: &mut Vec) { if let Err(error) = sema_policy::CompiledPolicy::compile(policy) { - out.push(Diag::error( - span, - "E-POLICY", - format!("invalid policy: {error}"), - )); + let hint = error.hint().map(str::to_string); + let diagnostic = Diag::error(span, "E-POLICY", format!("invalid policy: {error}")); + out.push(match hint { + Some(hint) => diagnostic.with_hint(hint), + None => diagnostic, + }); } } diff --git a/crates/sema-vm/src/lower.rs b/crates/sema-vm/src/lower.rs index f5d8c56e..cb5e462c 100644 --- a/crates/sema-vm/src/lower.rs +++ b/crates/sema-vm/src/lower.rs @@ -2803,7 +2803,9 @@ mod tests { let err = lower(&vals[0], Some(&span_map)).expect_err("define with 3 args should fail"); // Message is unchanged (WithTrace displays its inner error). - assert!(err.to_string().contains("define expects 2 args, got 3")); + assert!(err + .to_string() + .contains("define expects 2 arguments, got 3")); let trace = err.stack_trace().expect("error should carry a stack trace"); let frame = trace.0.first().expect("trace should have a frame"); @@ -2819,7 +2821,9 @@ mod tests { let (vals, _span_map) = sema_reader::read_many_with_spans(input).unwrap(); let err = lower(&vals[0], None).expect_err("define with 3 args should fail"); assert!(err.stack_trace().is_none()); - assert!(err.to_string().contains("define expects 2 args, got 3")); + assert!(err + .to_string() + .contains("define expects 2 arguments, got 3")); } #[test] diff --git a/crates/sema-vm/src/vm.rs b/crates/sema-vm/src/vm.rs index 60852850..35f54163 100644 --- a/crates/sema-vm/src/vm.rs +++ b/crates/sema-vm/src/vm.rs @@ -5786,14 +5786,28 @@ fn error_to_value(err: &SemaError) -> Value { map.insert(Value::keyword("type"), Value::keyword("eval")); map.insert(Value::keyword("message"), Value::string(msg)); } - SemaError::Type { expected, got, .. } => { + SemaError::Type { + context, + expected, + got, + got_value, + } => { map.insert(Value::keyword("type"), Value::keyword("type-error")); map.insert( Value::keyword("message"), - Value::string(&format!("expected {expected}, got {got}")), + Value::string(&inner.user_message()), ); map.insert(Value::keyword("expected"), Value::string(expected)); map.insert(Value::keyword("got"), Value::string(got)); + if let Some(context) = context { + map.insert(Value::keyword("function"), Value::string(&context.function)); + if let Some(argument) = context.argument { + map.insert(Value::keyword("argument"), Value::int(argument as i64)); + } + } + if let Some(got_value) = got_value { + map.insert(Value::keyword("value"), Value::string(got_value)); + } } SemaError::Arity { name, @@ -5803,8 +5817,11 @@ fn error_to_value(err: &SemaError) -> Value { map.insert(Value::keyword("type"), Value::keyword("arity")); map.insert( Value::keyword("message"), - Value::string(&format!("{name} expects {expected} args, got {got}")), + Value::string(&inner.user_message()), ); + map.insert(Value::keyword("function"), Value::string(name)); + map.insert(Value::keyword("expected"), Value::string(expected)); + map.insert(Value::keyword("got"), Value::int(*got as i64)); } SemaError::Unbound(name) => { map.insert(Value::keyword("type"), Value::keyword("unbound")); @@ -5859,19 +5876,28 @@ fn error_to_value(err: &SemaError) -> Value { map.insert(Value::keyword("function"), Value::string(function)); map.insert(Value::keyword("path"), Value::string(path)); } - SemaError::PolicyDenied { - boundary, - subject, - rule, - } => { + SemaError::PolicyDenied(denial) => { map.insert(Value::keyword("type"), Value::keyword("policy-denied")); map.insert( Value::keyword("message"), - Value::string(&format!("Policy denied {boundary} '{subject}' ({rule})")), + Value::string(&denial.to_string()), + ); + if let Some(policy) = &denial.policy { + map.insert(Value::keyword("policy"), Value::string(policy)); + } + map.insert(Value::keyword("boundary"), Value::string(&denial.boundary)); + map.insert(Value::keyword("subject"), Value::string(&denial.subject)); + map.insert(Value::keyword("rule"), Value::string(&denial.rule)); + map.insert(Value::keyword("reason"), Value::string(&denial.reason)); + map.insert(Value::keyword("action"), Value::keyword(&denial.action)); + map.insert(Value::keyword("source"), Value::keyword(&denial.source)); + } + SemaError::Internal(message) => { + map.insert(Value::keyword("type"), Value::keyword("internal")); + map.insert( + Value::keyword("message"), + Value::string(&format!("Internal error: {message}")), ); - map.insert(Value::keyword("boundary"), Value::string(boundary)); - map.insert(Value::keyword("subject"), Value::string(subject)); - map.insert(Value::keyword("rule"), Value::string(rule)); } SemaError::WithTrace { .. } | SemaError::WithContext { .. } => { unreachable!("inner() already unwraps these") diff --git a/crates/sema-wasm/src/driver.rs b/crates/sema-wasm/src/driver.rs index b03c1309..b1fe16a1 100644 --- a/crates/sema-wasm/src/driver.rs +++ b/crates/sema-wasm/src/driver.rs @@ -1281,17 +1281,7 @@ fn resolve_debug_immediately(resolve: &Function, result: JsValue) { } fn format_debug_error(error: &SemaError) -> String { - let mut message = format!("{}", error.inner()); - if let Some(trace) = error.stack_trace() { - message.push_str(&format!("\n{trace}")); - } - if let Some(hint) = error.hint() { - message.push_str(&format!("\n hint: {hint}")); - } - if let Some(note) = error.note() { - message.push_str(&format!("\n note: {note}")); - } - message + error.format_plain() } fn resolve_with_value(resolve: &Function, value: &Value) { @@ -1311,17 +1301,7 @@ fn resolve_with_value(resolve: &Function, value: &Value) { /// wrapper can recover full fidelity from a plain `JsFuture` rejection /// without a second, parallel error-detail channel. fn reject_with_error(reject: &Function, error: &SemaError) { - let mut message = format!("{}", error.inner()); - if let Some(trace) = error.stack_trace() { - message.push_str(&format!("\n{trace}")); - } - if let Some(hint) = error.hint() { - message.push_str(&format!("\n hint: {hint}")); - } - if let Some(note) = error.note() { - message.push_str(&format!("\n note: {note}")); - } - reject_with_message(reject, &message); + reject_with_message(reject, &error.format_plain()); } fn reject_with_message(reject: &Function, message: &str) { diff --git a/crates/sema-wasm/src/lib.rs b/crates/sema-wasm/src/lib.rs index dfc5aff3..b3645a3e 100644 --- a/crates/sema-wasm/src/lib.rs +++ b/crates/sema-wasm/src/lib.rs @@ -1901,16 +1901,7 @@ impl WasmInterpreter { } Err(e) => { let output = take_output(); - let mut err_str = format!("{}", e.inner()); - if let Some(trace) = e.stack_trace() { - err_str.push_str(&format!("\n{trace}")); - } - if let Some(hint) = e.hint() { - err_str.push_str(&format!("\n hint: {hint}")); - } - if let Some(note) = e.note() { - err_str.push_str(&format!("\n note: {note}")); - } + let err_str = e.format_plain(); format!( "{{\"value\":null,\"output\":[{}],\"error\":\"{}\"}}", output @@ -2072,16 +2063,7 @@ impl WasmInterpreter { } Err(e) => { let output = take_output(); - let mut err_str = format!("{}", e.inner()); - if let Some(trace) = e.stack_trace() { - err_str.push_str(&format!("\n{trace}")); - } - if let Some(hint) = e.hint() { - err_str.push_str(&format!("\n hint: {hint}")); - } - if let Some(note) = e.note() { - err_str.push_str(&format!("\n note: {note}")); - } + let err_str = e.format_plain(); format!( "{{\"value\":null,\"output\":[{}],\"error\":\"{}\"}}", output @@ -2122,16 +2104,7 @@ impl WasmInterpreter { } Err(e) => { let output = take_output(); - let mut err_str = format!("{}", e.inner()); - if let Some(trace) = e.stack_trace() { - err_str.push_str(&format!("\n{trace}")); - } - if let Some(hint) = e.hint() { - err_str.push_str(&format!("\n hint: {hint}")); - } - if let Some(note) = e.note() { - err_str.push_str(&format!("\n note: {note}")); - } + let err_str = e.format_plain(); format!( "{{\"value\":null,\"output\":[{}],\"error\":\"{}\"}}", output @@ -2955,7 +2928,7 @@ impl WasmInterpreter { &self.callback_ids_by_value, &self.next_callback_id, )), - Err(e) => Err(JsValue::from_str(&format!("{}", e.inner()))), + Err(e) => Err(JsValue::from_str(&e.format_plain())), } } @@ -2988,7 +2961,7 @@ impl WasmInterpreter { &self.callback_ids_by_value, &self.next_callback_id, )), - Err(e) => Err(JsValue::from_str(&format!("{}", e.inner()))), + Err(e) => Err(JsValue::from_str(&e.format_plain())), } } @@ -3054,7 +3027,7 @@ impl WasmInterpreter { Ok(()) => r#"{"ok":true,"error":null}"#.to_string(), Err(e) => format!( r#"{{"ok":false,"error":"{}"}}"#, - escape_json(&format!("{}", e.inner())) + escape_json(&e.format_plain()) ), }; js_sys::JSON::parse(&json_str).unwrap_or(JsValue::NULL) @@ -3109,7 +3082,7 @@ impl WasmInterpreter { ), Err(e) => format!( "{{\"ok\":false,\"entryPoint\":null,\"fileCount\":0,\"semaVersion\":null,\"buildTarget\":null,\"buildTimestamp\":null,\"error\":\"{}\"}}", - escape_json(&format!("{}", e.inner())) + escape_json(&e.format_plain()) ), }; js_sys::JSON::parse(&json_str).unwrap_or(JsValue::NULL) @@ -3246,7 +3219,7 @@ impl WasmInterpreter { pub fn write_file(&self, path: &str, content: &str) -> JsValue { let path = match normalize_path(path) { Ok(p) => p, - Err(e) => return JsValue::from_str(&format!("{}", e.inner())), + Err(e) => return JsValue::from_str(&e.format_plain()), }; match vfs_check_quota(&path, content.len()) { Ok(()) => { @@ -3264,10 +3237,7 @@ impl WasmInterpreter { }); JsValue::NULL } - Err(e) => { - let msg = format!("{}", e.inner()); - JsValue::from_str(&msg) - } + Err(e) => JsValue::from_str(&e.format_plain()), } } @@ -3493,16 +3463,7 @@ impl WasmInterpreter { fn eval_error_result(&self, e: &sema_core::SemaError) -> JsValue { let output = take_output(); - let mut err_str = format!("{}", e.inner()); - if let Some(trace) = e.stack_trace() { - err_str.push_str(&format!("\n{trace}")); - } - if let Some(hint) = e.hint() { - err_str.push_str(&format!("\n hint: {hint}")); - } - if let Some(note) = e.note() { - err_str.push_str(&format!("\n note: {note}")); - } + let err_str = e.format_plain(); let json_str = format!( "{{\"value\":null,\"output\":[{}],\"error\":\"{}\"}}", output @@ -3641,13 +3602,7 @@ impl WasmInterpreter { fn debug_error_result(&self, e: &sema_core::SemaError) -> JsValue { let output = take_output(); - let mut err_str = format!("{}", e.inner()); - if let Some(trace) = e.stack_trace() { - err_str.push_str(&format!("\n{trace}")); - } - if let Some(hint) = e.hint() { - err_str.push_str(&format!("\n hint: {hint}")); - } + let err_str = e.format_plain(); let output_json = output .iter() .map(|s| format!("\"{}\"", escape_json(s))) @@ -3831,7 +3786,7 @@ pub fn format_code(code: &str, width: usize, indent: usize, align: bool) -> JsVa Err(e) => { let json_str = format!( "{{\"formatted\":null,\"error\":\"{}\"}}", - escape_json(&format!("{}", e.inner())) + escape_json(&e.format_plain()) ); js_sys::JSON::parse(&json_str).unwrap_or(JsValue::NULL) } diff --git a/crates/sema-workflow/src/context.rs b/crates/sema-workflow/src/context.rs index 4b66f147..af2a5739 100644 --- a/crates/sema-workflow/src/context.rs +++ b/crates/sema-workflow/src/context.rs @@ -134,6 +134,8 @@ pub struct WorkflowCtx { state: Rc>>, /// Monotonic event sequence counter (0-based; first `next_seq()` returns 0). seq: Cell, + /// Bounded completion ledger keyed only by the frozen event vocabulary. + event_counts: RefCell>, /// Wall-clock origin for `dur_ms`. Ignored when the fixed-ts seam is active. start: Instant, /// Parsed spend caps (absent ⇒ that dimension is unenforced). `usd` is best-effort @@ -238,6 +240,7 @@ impl WorkflowCtx { journal: Rc::new(RefCell::new(journal)), state: Rc::new(RefCell::new(BTreeMap::new())), seq: Cell::new(0), + event_counts: RefCell::new(BTreeMap::new()), start: Instant::now(), cost_limit, token_limit, @@ -334,9 +337,20 @@ impl WorkflowCtx { /// Append one event to the journal. Write errors are swallowed by the journal /// (same trust model as the OTel file exporter); journaling never aborts the run. pub fn emit(&self, event: WorkflowEvent) { + let kind = event.kind(); + let mut counts = self.event_counts.borrow_mut(); + *counts.entry(kind).or_insert(0) += 1; + drop(counts); self.journal.borrow().write(&event); } + pub fn has_event(&self, kind: &str) -> bool { + self.event_counts + .borrow() + .get(kind) + .is_some_and(|count| *count > 0) + } + /// True under the fixed-timestamp test seam (`SEMA_WORKFLOW_FIXED_TS`). Callers /// that measure their own per-leaf durations force them to 0 in this mode so /// goldens stay byte-identical. diff --git a/crates/sema-workflow/src/event.rs b/crates/sema-workflow/src/event.rs index dd5738bd..a09e7125 100644 --- a/crates/sema-workflow/src/event.rs +++ b/crates/sema-workflow/src/event.rs @@ -117,6 +117,17 @@ pub enum WorkflowEvent { args_json: String, }, + /// A tool handler returned successfully. The result is an opaque digest or + /// gated sentinel; raw tool output never enters the workflow journal. + #[serde(rename = "agent.tool_result")] + AgentToolResult { + seq: u64, + ts: String, + agent_id: String, + tool_name: String, + result_digest: String, + }, + /// A `checkpoint` recorded a keyed step value. The value itself is NOT stored in /// the event stream — only a (lossy) digest — and a `content_key` resume hash. #[serde(rename = "checkpoint")] @@ -338,6 +349,31 @@ pub enum WorkflowEvent { }, } +impl WorkflowEvent { + pub fn kind(&self) -> &'static str { + match self { + Self::RunStarted { .. } => "run.started", + Self::PhaseStarted { .. } => "phase.started", + Self::PhaseEnded { .. } => "phase.ended", + Self::AgentStarted { .. } => "agent.started", + Self::AgentResult { .. } => "agent.result", + Self::AgentToolCall { .. } => "agent.tool_call", + Self::AgentToolResult { .. } => "agent.tool_result", + Self::Checkpoint { .. } => "checkpoint", + Self::Budget { .. } => "budget", + Self::RunEnded { .. } => "run.ended", + Self::AuthRequired { .. } => "auth.required", + Self::AuthGranted { .. } => "auth.granted", + Self::AuthFailed { .. } => "auth.failed", + Self::PolicyChecked { .. } => "policy.checked", + Self::PolicyFlagged { .. } => "policy.flagged", + Self::PolicyRedacted { .. } => "policy.redacted", + Self::PolicyViolation { .. } => "policy.violation", + Self::PolicyBypassed { .. } => "policy.bypassed", + } + } +} + #[cfg(test)] mod tests { use super::*; diff --git a/crates/sema/src/import_tracer.rs b/crates/sema/src/import_tracer.rs index 5ea51e9c..6477d192 100644 --- a/crates/sema/src/import_tracer.rs +++ b/crates/sema/src/import_tracer.rs @@ -37,8 +37,13 @@ pub fn trace_imports(root_file: &Path) -> Result>, Strin let source = std::fs::read_to_string(&root_file) .map_err(|e| format!("cannot read root file {}: {e}", root_file.display()))?; - let exprs = sema_reader::read_many(&source) - .map_err(|e| format!("parse error in {}: {}", root_file.display(), e.inner()))?; + let exprs = sema_reader::read_many(&source).map_err(|e| { + format!( + "parse failed in {}: {}", + root_file.display(), + e.format_plain() + ) + })?; trace_file_imports(&exprs, &root_file, &root_dir, &mut visited, &mut result)?; @@ -86,12 +91,12 @@ fn extract_imports( process_import(path_str, current_file, root_dir, visited, result)?; } else { // Dynamic import -- cannot resolve statically. - eprintln!( - "warning: dynamic {} in {} cannot be resolved statically; \ + crate::print_cli_warning(format!( + "dynamic {} in {} cannot be resolved statically; \ use --include to add it manually", head, current_file.display() - ); + )); } } // Don't recurse further into import/load forms. @@ -148,12 +153,12 @@ fn process_import( let canonical = match resolved.canonicalize() { Ok(c) => c, Err(_) => { - eprintln!( - " warning: import \"{}\" (from {}) couldn't be resolved at build time; \ + crate::print_cli_warning(format!( + "import \"{}\" (from {}) could not be resolved at build time; \ not bundled — it will be resolved at runtime (filesystem/VFS)", import_path, current_file.display() - ); + )); return Ok(()); } }; @@ -168,11 +173,11 @@ fn process_import( let contents = match std::fs::read(&canonical) { Ok(c) => c, Err(_) => { - eprintln!( - " warning: import \"{}\" couldn't be read at build time; not bundled \ + crate::print_cli_warning(format!( + "import \"{}\" could not be read at build time; not bundled \ (resolved at runtime)", canonical.display() - ); + )); return Ok(()); } }; @@ -190,21 +195,21 @@ fn process_import( } else if let Ok(rel) = canonical.strip_prefix(root_dir) { rel.to_string_lossy().replace('\\', "/") } else { - eprintln!( - " warning: imported file {} is outside the project and packages \ + crate::print_cli_warning(format!( + "imported file {} is outside the project and packages \ directories; not bundled (resolved at runtime)", canonical.display() - ); + )); return Ok(()); } } else if let Ok(rel) = canonical.strip_prefix(root_dir) { rel.to_string_lossy().replace('\\', "/") } else { - eprintln!( - " warning: imported file {} is outside the project directory; not \ + crate::print_cli_warning(format!( + "imported file {} is outside the project directory; not \ bundled (resolved at runtime)", canonical.display() - ); + )); return Ok(()); } }; diff --git a/crates/sema/src/lib.rs b/crates/sema/src/lib.rs index ae7d710e..fe98f612 100644 --- a/crates/sema/src/lib.rs +++ b/crates/sema/src/lib.rs @@ -14,6 +14,7 @@ use std::rc::Rc; +pub mod workflow_evidence; pub mod workflow_mcp; // `sema workflow view` — the dashboard server. Lives in the library (not just // `main.rs`) so `crates/sema/tests/*.rs` integration tests can drive it diff --git a/crates/sema/src/main.rs b/crates/sema/src/main.rs index 6e3ed3ed..786ed680 100644 --- a/crates/sema/src/main.rs +++ b/crates/sema/src/main.rs @@ -611,6 +611,19 @@ enum WorkflowCommands { #[arg(long, default_value = ".sema/runs")] run_dir: String, }, + /// Export a deterministic evidence bundle for one completed workflow run. + Export { + /// Run id (the single directory name under `--run-dir`). + run_id: String, + + /// Base directory holding `/events.jsonl` run journals. + #[arg(long, default_value = ".sema/runs")] + run_dir: String, + + /// Output directory. Defaults to `//evidence`. + #[arg(long)] + out_dir: Option, + }, /// Open the web viewer for a run directory's workflow journals View { /// Base directory holding `/events.jsonl` run journals. @@ -843,7 +856,7 @@ fn main() { let sandbox = match &cli.sandbox { Some(value) => sema_core::Sandbox::parse_cli(value).unwrap_or_else(|e| { - eprintln!("Error: {e}"); + print_cli_error(e); std::process::exit(1); }), None => sema_core::Sandbox::allow_all(), @@ -897,7 +910,7 @@ fn main() { docs::PagerMode::Auto }; if let Err(msg) = run_doc(command, symbol, pager) { - eprintln!("Error: {msg}"); + print_cli_error(msg); std::process::exit(1); } } @@ -928,7 +941,7 @@ fn main() { } }; if let Err(e) = result { - eprintln!("Error: {e}"); + print_cli_error(e); std::process::exit(1); } } @@ -957,7 +970,7 @@ fn main() { no_cache, BuildOutputOpts { verbose, json }, ) { - eprintln!("Error: {e}"); + print_cli_error(e); std::process::exit(1); } } @@ -1021,7 +1034,7 @@ fn main() { McpAuthCommands::List => sema_mcp::mcp_list(), }; if let Err(e) = result { - eprintln!("mcp: {e}"); + print_cli_error(format!("MCP command failed: {e}")); std::process::exit(1); } return; @@ -1043,7 +1056,7 @@ fn main() { // exactly that behavior. let sandbox = match mcp_sandbox.as_deref() { Some(value) => sema_core::Sandbox::parse_cli(value).unwrap_or_else(|e| { - eprintln!("mcp: invalid --sandbox: {e}"); + print_cli_error(format!("invalid MCP --sandbox value: {e}")); std::process::exit(1); }), None => sandbox, @@ -1056,12 +1069,12 @@ fn main() { match read_source_file(&file) { Ok(content) => { if let Err(e) = interpreter.eval_str_compiled(&content) { - eprintln!("Error loading tool file {file}: {e}"); + print_cli_error(format!("could not load tool file {file}: {e}")); std::process::exit(1); } } Err(e) => { - eprintln!("Error reading tool file {file}: {e}"); + print_cli_error(format!("could not read tool file {file}: {e}")); std::process::exit(1); } } @@ -1071,7 +1084,7 @@ fn main() { // runtime, llm/* builtins hit io_block_on's runtime-in-runtime // panic and killed the server on the first LLM tool call. if let Err(e) = sema_mcp::run_mcp_server_sync(interpreter, inc_tools, exc_tools) { - eprintln!("MCP server error: {e}"); + print_cli_error(format!("MCP server failed: {e}")); std::process::exit(1); } } @@ -1086,7 +1099,7 @@ fn main() { no_llm, } => { if let Err(e) = web::run(&file, &host, port, !no_open, !no_llm) { - eprintln!("sema web: {e}"); + print_cli_error(format!("sema web failed: {e}")); std::process::exit(1); } } @@ -1115,7 +1128,7 @@ fn main() { yes, }; if let Err(e) = update::run(opts) { - eprintln!("Error: {e}"); + print_cli_error(e); std::process::exit(1); } } @@ -1173,7 +1186,7 @@ fn main() { } } Err(msg) => { - eprintln!("error: {msg}"); + print_cli_error(msg); std::process::exit(1); } } @@ -1264,11 +1277,13 @@ fn main() { } } Err(msg) if msg.starts_with("file not found:") => { - eprintln!("error: file not found: '{file}' (not a file or command)\n\nRun 'sema --help' for available commands."); + print_cli_error(format!( + "file not found: '{file}' (not a file or command)\n\nRun 'sema --help' for available commands." + )); std::process::exit(1); } Err(msg) => { - eprintln!("error: {msg}"); + print_cli_error(msg); std::process::exit(1); } } @@ -1319,11 +1334,37 @@ fn run_workflow_command(command: WorkflowCommands, sandbox: &sema_core::Sandbox) rows.len(), root.join(sema_workflow::INDEX_DB).display() ), - Err(e) => eprintln!("warning: index summary: {e}"), + Err(e) => print_cli_warning(format!("could not summarize index: {e}")), } } Err(e) => { - eprintln!("error: cannot open index db: {e}"); + print_cli_error(format!("cannot open index database: {e}")); + std::process::exit(1); + } + } + return; + } + WorkflowCommands::Export { + run_id, + run_dir, + out_dir, + } => { + match sema::workflow_evidence::export( + &PathBuf::from(run_dir), + &run_id, + out_dir.as_deref().map(std::path::Path::new), + ) { + Ok(bundle) => { + println!( + "exported workflow evidence → {}", + bundle.directory.display() + ); + println!(" {}", bundle.evidence_json.display()); + println!(" {}", bundle.evidence_markdown.display()); + println!(" {}", bundle.manifest_json.display()); + } + Err(error) => { + print_cli_error(format!("cannot export workflow evidence: {error}")); std::process::exit(1); } } @@ -1333,7 +1374,7 @@ fn run_workflow_command(command: WorkflowCommands, sandbox: &sema_core::Sandbox) let src = match read_source_file(&file) { Ok(s) => s, Err(msg) => { - eprintln!("error: {msg}"); + print_cli_error(msg); std::process::exit(2); } }; @@ -1366,12 +1407,14 @@ fn run_workflow_command(command: WorkflowCommands, sandbox: &sema_core::Sandbox) || run_id.contains('\\') || run_id.contains("..") { - eprintln!("error: --resume run-id must be a bare directory name (no path separators)"); + print_cli_error( + "--resume run-id must be a bare directory name without path separators", + ); std::process::exit(1); } let prior = PathBuf::from(&run_dir).join(run_id).join("events.jsonl"); if !prior.exists() { - eprintln!("error: no prior run to resume at {}", prior.display()); + print_cli_error(format!("no prior run to resume at {}", prior.display())); std::process::exit(1); } std::env::set_var("SEMA_WORKFLOW_RUN_ID", run_id); @@ -1383,7 +1426,7 @@ fn run_workflow_command(command: WorkflowCommands, sandbox: &sema_core::Sandbox) let content = match read_source_file(&file) { Ok(c) => c, Err(msg) => { - eprintln!("error: {msg}"); + print_cli_error(msg); std::process::exit(1); } }; @@ -1392,13 +1435,13 @@ fn run_workflow_command(command: WorkflowCommands, sandbox: &sema_core::Sandbox) let permission_specs = match workflow_check::declared_permission_specs(&content) { Ok(specs) => specs, Err(e) => { - eprintln!("error: invalid workflow permissions: {e}"); + print_cli_error(format!("invalid workflow permissions: {e}")); std::process::exit(1); } }; for spec in permission_specs { let declared = sema_core::Sandbox::parse_cli(&spec).unwrap_or_else(|e| { - eprintln!("error: invalid defworkflow :permissions {spec:?}: {e}"); + print_cli_error(format!("invalid defworkflow :permissions {spec:?}: {e}")); std::process::exit(1); }); effective_sandbox = effective_sandbox.with_more_denied(declared.denied); @@ -1424,7 +1467,7 @@ fn run_workflow_command(command: WorkflowCommands, sandbox: &sema_core::Sandbox) ) .await { - eprintln!("warning: --view could not start the viewer: {e}"); + print_cli_warning(format!("--view could not start the viewer: {e}")); } }); }); @@ -1447,7 +1490,7 @@ fn run_workflow_command(command: WorkflowCommands, sandbox: &sema_core::Sandbox) let args_value = match serde_json::from_str::(&args) { Ok(json) => sema_core::json::json_to_value(&json), Err(e) => { - eprintln!("error: --args is not valid JSON: {e}"); + print_cli_error(format!("--args is not valid JSON: {e}")); std::process::exit(1); } }; @@ -1477,7 +1520,7 @@ fn run_workflow_command(command: WorkflowCommands, sandbox: &sema_core::Sandbox) .and_then(|s| s.as_keyword()); match status.as_deref() { Some("failed") => { - eprintln!("workflow failed: {}", pretty_print(&envelope, 80)); + print_cli_error(format!("workflow failed: {}", pretty_print(&envelope, 80))); 1 } // The headless-precursor gate (docs/plans/2026-06-24-workflow-mcp-auth.md @@ -1614,7 +1657,7 @@ fn run_notebook_command(command: NotebookCommands) { let mut engine = match sema_notebook::Engine::from_file(path) { Ok(e) => e, Err(e) => { - eprintln!("Error: {e}"); + print_cli_error(e); std::process::exit(1); } }; @@ -1668,7 +1711,7 @@ fn run_notebook_command(command: NotebookCommands) { } } Err(e) => { - eprintln!("[{}/{}] Error: {e}", i + 1, total); + print_cli_error(format!("[{}/{}] {e}", i + 1, total)); had_error = true; } } @@ -1676,7 +1719,7 @@ fn run_notebook_command(command: NotebookCommands) { // Save updated outputs back to the file if let Err(e) = engine.notebook.save(path) { - eprintln!("Warning: failed to save: {e}"); + print_cli_warning(format!("could not save: {e}")); } if had_error { @@ -1692,7 +1735,7 @@ fn run_notebook_command(command: NotebookCommands) { let notebook = match sema_notebook::Notebook::load(path) { Ok(nb) => nb, Err(e) => { - eprintln!("Error: {e}"); + print_cli_error(e); std::process::exit(1); } }; @@ -1700,7 +1743,9 @@ fn run_notebook_command(command: NotebookCommands) { let content = match format.as_str() { "md" | "markdown" => sema_notebook::render::export_markdown(¬ebook), other => { - eprintln!("Unknown export format: {other}. Supported: md"); + print_cli_error(format!( + "unknown export format: {other}; supported format: md" + )); std::process::exit(1); } }; @@ -1708,7 +1753,7 @@ fn run_notebook_command(command: NotebookCommands) { match output { Some(out_path) => { if let Err(e) = std::fs::write(&out_path, &content) { - eprintln!("Error writing {out_path}: {e}"); + print_cli_error(format!("could not write {out_path}: {e}")); std::process::exit(1); } eprintln!("Exported to {out_path}"); @@ -1727,7 +1772,7 @@ fn run_notebook_command(command: NotebookCommands) { // Add a starter code cell notebook.add_code_cell("; Welcome to your Sema notebook!\n(+ 1 2)"); if let Err(e) = notebook.save(path) { - eprintln!("Error: {e}"); + print_cli_error(e); std::process::exit(1); } eprintln!("Created notebook: {file}"); @@ -1764,7 +1809,7 @@ fn run_eval( elapsed_ms: 0, }); } else { - eprintln!("Error reading stdin: {e}"); + print_cli_error(format!("could not read stdin: {e}")); } std::process::exit(1); }); @@ -1785,7 +1830,7 @@ fn run_eval( elapsed_ms: 0, }); } else { - eprintln!("Error: either --stdin or --expr is required"); + print_cli_error("either --stdin or --expr is required"); } std::process::exit(1); }; @@ -1806,7 +1851,7 @@ fn run_eval( elapsed_ms: 0, }); } else { - eprintln!("Error: {e}"); + print_cli_error(e); } std::process::exit(1); }), @@ -1885,7 +1930,7 @@ fn run_eval( } Err(e) => { let inner = e.inner(); - let msg = inner.to_string(); + let msg = e.user_message(); let hint = e.hint().map(|s| s.to_string()); // Extract line+col from Reader span or first stack trace frame let (line, col) = match inner { @@ -2023,7 +2068,7 @@ fn run_compile(file: &str, output: Option<&str>) { let source = match read_source_file(path) { Ok(s) => s, Err(msg) => { - eprintln!("error: {msg}"); + print_cli_error(msg); std::process::exit(1); } }; @@ -2038,7 +2083,7 @@ fn run_compile(file: &str, output: Option<&str>) { let result = match interpreter.compile_to_bytecode(&source) { Ok(r) => r, Err(e) => { - eprintln!("Compile error: {}", e.inner()); + print_cli_error(format!("compilation failed: {}", e.format_plain())); std::process::exit(1); } }; @@ -2047,7 +2092,7 @@ fn run_compile(file: &str, output: Option<&str>) { let bytes = match sema_vm::serialize_to_bytes(&result, source_hash) { Ok(b) => b, Err(e) => { - eprintln!("Serialization error: {}", e.inner()); + print_cli_error(format!("serialization failed: {}", e.format_plain())); std::process::exit(1); } }; @@ -2058,7 +2103,7 @@ fn run_compile(file: &str, output: Option<&str>) { None => path.with_extension("semac"), }; if let Err(e) = std::fs::write(&out_path, &bytes) { - eprintln!("Error writing {}: {e}", out_path.display()); + print_cli_error(format!("could not write {}: {e}", out_path.display())); std::process::exit(1); } } @@ -2087,7 +2132,7 @@ fn try_run_embedded() -> Option { let arch = match archive::deserialize_archive_from_bytes(&archive_data) { Ok(a) => a, Err(e) => { - eprintln!("Error: failed to load embedded archive: {e}"); + print_cli_error(format!("could not load embedded archive: {e}")); return Some(1); } }; @@ -2102,7 +2147,9 @@ fn try_run_embedded() -> Option { let bytecode = match arch.files.get(&entry_point) { Some(b) => b.clone(), None => { - eprintln!("Error: entry point '{entry_point}' not found in embedded archive"); + print_cli_error(format!( + "entry point '{entry_point}' was not found in the embedded archive" + )); return Some(1); } }; @@ -2155,7 +2202,7 @@ fn try_run_embedded() -> Option { // Same no-ambient-runtime rule as the CLI mcp arm (llm/* + io_block_on). if let Err(e) = sema_mcp::run_mcp_server_sync(interpreter, inc_tools, exc_tools) { - eprintln!("MCP server error: {e}"); + print_cli_error(format!("MCP server failed: {e}")); std::process::exit(1); } Some(0) @@ -2392,9 +2439,9 @@ fn build_archive( let result = interpreter .compile_to_bytecode(&source) - .map_err(|e| format!("compile error: {}", e.inner()))?; + .map_err(|e| format!("compile failed: {}", e.format_plain()))?; let bytecode = sema_vm::serialize_to_bytes(&result, source_hash) - .map_err(|e| format!("serialization error: {}", e.inner()))?; + .map_err(|e| format!("serialization failed: {}", e.format_plain()))?; if opts.verbose { eprintln!("[2/4] Tracing imports..."); @@ -2410,7 +2457,7 @@ fn build_archive( for (rel_path, contents) in &imports { if let Err(e) = sema_core::vfs::validate_vfs_path(rel_path) { - eprintln!("Warning: skipping import with invalid VFS path: {e}"); + print_cli_warning(format!("skipping import with invalid VFS path: {e}")); continue; } files.insert(rel_path.clone(), contents.clone()); @@ -2432,7 +2479,7 @@ fn build_archive( .to_string_lossy() .to_string(); if let Err(e) = sema_core::vfs::validate_vfs_path(&rel) { - eprintln!("Warning: skipping {include}: {e}"); + print_cli_warning(format!("skipping {include}: {e}")); continue; } match std::fs::read(inc_path) { @@ -2440,11 +2487,11 @@ fn build_archive( files.insert(rel, data); } Err(e) => { - eprintln!("Warning: cannot read {include}: {e}"); + print_cli_warning(format!("cannot read {include}: {e}")); } } } else { - eprintln!("Warning: --include path not found: {include}"); + print_cli_warning(format!("--include path not found: {include}")); } } @@ -2802,12 +2849,12 @@ fn compile_source_to_bytecode(source: &str) -> Result, String> { let interpreter = Interpreter::new_with_sandbox(&sandbox); interpreter .eval_str_in_global(include_str!("web_prelude.sema")) - .map_err(|e| format!("web prelude error: {}", e.inner()))?; + .map_err(|e| format!("web prelude failed: {}", e.format_plain()))?; let result = interpreter .compile_to_bytecode(source) - .map_err(|e| format!("compile error: {}", e.inner()))?; + .map_err(|e| format!("compile failed: {}", e.format_plain()))?; sema_vm::serialize_to_bytes(&result, source_hash) - .map_err(|e| format!("serialization error: {}", e.inner())) + .map_err(|e| format!("serialization failed: {}", e.format_plain())) } fn should_compile_traced_import(rel_path: &str) -> bool { @@ -2865,7 +2912,7 @@ pub(crate) fn build_web_archive( for (rel_path, contents) in &imports { if let Err(e) = sema_core::vfs::validate_vfs_path(rel_path) { - eprintln!("Warning: skipping import with invalid VFS path: {e}"); + print_cli_warning(format!("skipping import with invalid VFS path: {e}")); continue; } @@ -2900,7 +2947,7 @@ pub(crate) fn build_web_archive( .to_string_lossy() .to_string(); if let Err(e) = sema_core::vfs::validate_vfs_path(&rel) { - eprintln!("Warning: skipping {include}: {e}"); + print_cli_warning(format!("skipping {include}: {e}")); continue; } match std::fs::read(inc_path) { @@ -2908,11 +2955,11 @@ pub(crate) fn build_web_archive( files.insert(rel, data); } Err(e) => { - eprintln!("Warning: cannot read {include}: {e}"); + print_cli_warning(format!("cannot read {include}: {e}")); } } } else { - eprintln!("Warning: --include path not found: {include}"); + print_cli_warning(format!("--include path not found: {include}")); } } @@ -3233,7 +3280,7 @@ fn collect_directory_files( let entries = match std::fs::read_dir(dir) { Ok(e) => e, Err(e) => { - eprintln!("Warning: cannot read directory {}: {e}", dir.display()); + print_cli_warning(format!("cannot read directory {}: {e}", dir.display())); return; } }; @@ -3251,7 +3298,7 @@ fn collect_directory_files( collect_directory_files(&entry_path, &vfs_path, files); } else if entry_path.is_file() { if let Err(e) = sema_core::vfs::validate_vfs_path(&vfs_path) { - eprintln!("Warning: skipping {}: {e}", entry_path.display()); + print_cli_warning(format!("skipping {}: {e}", entry_path.display())); continue; } match std::fs::read(&entry_path) { @@ -3259,7 +3306,7 @@ fn collect_directory_files( files.insert(vfs_path, data); } Err(e) => { - eprintln!("Warning: cannot read {}: {e}", entry_path.display()); + print_cli_warning(format!("cannot read {}: {e}", entry_path.display())); } } } @@ -3278,13 +3325,13 @@ fn run_check(file: &str) { let bytes = match std::fs::read(file) { Ok(b) => b, Err(e) => { - eprintln!("✗ {file}: {e}"); + print_cli_error(format!("could not read {file}: {e}")); std::process::exit(1); } }; if !sema_vm::is_bytecode_file(&bytes) { - eprintln!("✗ {file}: not a valid .semac bytecode file"); + print_cli_error(format!("{file} is not a valid .semac bytecode file")); std::process::exit(1); } @@ -3304,7 +3351,7 @@ fn run_check(file: &str) { ); } Err(e) => { - eprintln!("✗ {file}: {}", e.inner()); + print_cli_error(format!("{file} is invalid: {}", e.format_plain())); std::process::exit(1); } } @@ -3319,20 +3366,20 @@ fn run_disasm(file: &str, json: bool) { std::io::ErrorKind::PermissionDenied => format!("permission denied: {file}"), _ => format!("reading {file}: {e}"), }; - eprintln!("error: {msg}"); + print_cli_error(msg); std::process::exit(1); } }; if !sema_vm::is_bytecode_file(&bytes) { - eprintln!("Error: {file} is not a valid .semac bytecode file"); + print_cli_error(format!("{file} is not a valid .semac bytecode file")); std::process::exit(1); } let result = match sema_vm::deserialize_from_bytes(&bytes) { Ok(r) => r, Err(e) => { - eprintln!("Deserialization error: {}", e.inner()); + print_cli_error(format!("deserialization failed: {}", e.format_plain())); std::process::exit(1); } }; @@ -3652,7 +3699,7 @@ fn run_fmt( }) ); } else { - eprintln!("Error reading stdin: {e}"); + print_cli_error(format!("could not read stdin: {e}")); } std::process::exit(1); } @@ -3680,7 +3727,7 @@ fn run_fmt( }) ); } else { - eprintln!("Error formatting stdin: {e}"); + print_cli_error(format!("could not format stdin: {e}")); } std::process::exit(1); } @@ -3698,7 +3745,7 @@ fn run_fmt( .filter(|p| !is_ignored(p)) .collect::>(), Err(e) => { - eprintln!("Error: invalid glob pattern: {e}"); + print_cli_error(format!("invalid glob pattern: {e}")); std::process::exit(1); } } @@ -3718,7 +3765,7 @@ fn run_fmt( } } Err(e) => { - eprintln!("Error: invalid glob pattern '{pattern}': {e}"); + print_cli_error(format!("invalid glob pattern '{pattern}': {e}")); std::process::exit(1); } } @@ -3755,7 +3802,7 @@ fn run_fmt( }) ); } else { - eprintln!("error: {msg}"); + print_cli_error(msg); } errors += 1; continue; @@ -3775,7 +3822,7 @@ fn run_fmt( }) ); } else { - eprintln!("Error formatting {file}: {e}"); + print_cli_error(format!("could not format {file}: {e}")); } errors += 1; continue; @@ -3810,7 +3857,7 @@ fn run_fmt( } else { // Write formatted output back if let Err(e) = std::fs::write(file, &formatted) { - eprintln!("Error writing {file}: {e}"); + print_cli_error(format!("could not write {file}: {e}")); errors += 1; continue; } @@ -3841,7 +3888,7 @@ fn run_fmt( } if errors > 0 { - eprintln!("{errors} error(s)"); + print_cli_error(format!("{errors} file(s) could not be formatted")); std::process::exit(1); } @@ -3890,17 +3937,17 @@ fn run_ast(file: Option, eval: Option, json: bool) { (Some(path), None) => match read_source_file(path) { Ok(content) => content, Err(msg) => { - eprintln!("error: {msg}"); + print_cli_error(msg); std::process::exit(1); } }, (None, Some(expr)) => expr.clone(), (Some(_), Some(_)) => { - eprintln!("Error: cannot specify both a file and --eval"); + print_cli_error("cannot specify both a file and --eval"); std::process::exit(1); } (None, None) => { - eprintln!("Error: provide a file or --eval expression"); + print_cli_error("provide a file or --eval expression"); std::process::exit(1); } }; @@ -3908,7 +3955,7 @@ fn run_ast(file: Option, eval: Option, json: bool) { let exprs = match sema_reader::read_many(&source) { Ok(exprs) => exprs, Err(e) => { - eprintln!("Parse error: {}", e.inner()); + print_cli_error(format!("parsing failed: {}", e.format_plain())); std::process::exit(1); } }; @@ -4150,9 +4197,17 @@ pub(crate) fn format_source_snippet( Some(out) } +pub(crate) fn print_cli_error(message: impl std::fmt::Display) { + eprintln!("{} {message}", colors::red_bold("Error:")); +} + +pub(crate) fn print_cli_warning(message: impl std::fmt::Display) { + eprintln!("{} {message}", colors::yellow("Warning:")); +} + pub(crate) fn print_error(e: &SemaError) { let inner = e.inner(); - eprintln!("{} {}", colors::red_bold("Error:"), inner); + print_cli_error(e.user_message()); // Show source snippet for reader errors if let SemaError::Reader { span, .. } = inner { @@ -4370,7 +4425,7 @@ fn install_completions(shell: Shell) { let home = match std::env::var("HOME").or_else(|_| std::env::var("USERPROFILE")) { Ok(h) => PathBuf::from(h), Err(_) => { - eprintln!("Error: could not determine home directory"); + print_cli_error("could not determine the home directory"); std::process::exit(1); } }; @@ -4381,28 +4436,31 @@ fn install_completions(shell: Shell) { Shell::Fish => home.join(".config/fish/completions/sema.fish"), Shell::Elvish => home.join(".config/elvish/lib/sema.elv"), Shell::PowerShell => { - eprintln!( + print_cli_error( "Auto-install is not supported for PowerShell.\n\ - Run manually: sema completions powershell >> $PROFILE" + Run manually: sema completions powershell >> $PROFILE", ); std::process::exit(1); } _ => { - eprintln!("Auto-install is not supported for this shell."); + print_cli_error("auto-install is not supported for this shell"); std::process::exit(1); } }; if let Some(parent) = path.parent() { std::fs::create_dir_all(parent).unwrap_or_else(|e| { - eprintln!("Error creating directory {}: {e}", parent.display()); + print_cli_error(format!( + "could not create directory {}: {e}", + parent.display() + )); std::process::exit(1); }); } let completions = generate_completions(shell); std::fs::write(&path, completions).unwrap_or_else(|e| { - eprintln!("Error writing {}: {e}", path.display()); + print_cli_error(format!("could not write {}: {e}", path.display())); std::process::exit(1); }); diff --git a/crates/sema/src/pkg.rs b/crates/sema/src/pkg.rs index 45ddfaa0..ba8f8c4a 100644 --- a/crates/sema/src/pkg.rs +++ b/crates/sema/src/pkg.rs @@ -68,6 +68,81 @@ fn find_all_packages(pkg_dir: &Path) -> Vec { packages } +fn validate_package_manifest_sema(dir: &Path, package: &str) -> Result<(), String> { + let manifest = dir.join("sema.toml"); + if !manifest.is_file() { + return Ok(()); + } + let content = std::fs::read_to_string(&manifest) + .map_err(|error| format!("Failed to read {}: {error}", manifest.display()))?; + validate_package_manifest_sema_content(&content, &manifest.display().to_string(), package) +} + +fn validate_package_manifest_sema_content( + content: &str, + source: &str, + package: &str, +) -> Result<(), String> { + let document: toml::Value = + toml::from_str(content).map_err(|error| format!("Failed to parse {source}: {error}"))?; + let requirement = document + .get("package") + .and_then(|package| package.get("sema_version_req")) + .map(|value| { + value + .as_str() + .ok_or_else(|| format!("{source} [package].sema_version_req must be a string")) + }) + .transpose()? + .map(str::trim) + .filter(|requirement| !requirement.is_empty()); + let Some(requirement) = requirement else { + return Ok(()); + }; + if requirement.len() > 128 { + return Err(format!( + "{package} has invalid sema_version_req: must be at most 128 characters" + )); + } + let parsed = semver::VersionReq::parse(requirement).map_err(|error| { + format!("{package} has invalid sema_version_req {requirement:?}: {error}") + })?; + let current = current_sema_version(); + if parsed.matches(¤t) { + Ok(()) + } else { + Err(format!( + "{package} requires Sema {requirement}, but this is Sema {current}" + )) + } +} + +fn validate_git_ref_manifest(dir: &Path, git_ref: &str, package: &str) -> Result<(), String> { + let candidates = [ + format!("refs/remotes/origin/{git_ref}"), + format!("refs/tags/{git_ref}"), + git_ref.to_string(), + ]; + let Some(resolved) = candidates + .iter() + .find(|candidate| run_git(Some(dir), &["rev-parse", "--verify", candidate]).is_ok()) + .cloned() + else { + // Checkout reports a missing ref with the normal git diagnostic. + return Ok(()); + }; + let object = format!("{resolved}:sema.toml"); + if run_git(Some(dir), &["cat-file", "-e", &object]).is_err() { + return Ok(()); + } + let content = run_git(Some(dir), &["show", &object])?; + validate_package_manifest_sema_content( + &content, + &format!("{package}@{git_ref}:sema.toml"), + package, + ) +} + fn collect_packages(dir: &Path, packages: &mut Vec) { let entries = match std::fs::read_dir(dir) { Ok(e) => e, @@ -111,24 +186,28 @@ pub fn cmd_add(spec: &str, registry: Option<&str>) -> Result<(), String> { fn install_git(spec: &sema_core::resolve::PackageSpec) -> Result<(String, String), String> { let pkg_dir = packages_dir(); let dest = spec.dest_dir(&pkg_dir); + let existed = dest.exists(); - if dest.exists() { + if existed { run_git(Some(&dest), &["fetch", "origin"])?; run_git(Some(&dest), &["fetch", "--tags"])?; - run_git(Some(&dest), &["checkout", &spec.git_ref])?; - let current = current_git_ref(&dest); - println!("✓ Updated {} → {current}", spec.path); } else { if let Some(parent) = dest.parent() { std::fs::create_dir_all(parent) .map_err(|e| format!("Failed to create directory: {e}"))?; } run_git(None, &["clone", &spec.clone_url(), &dest.to_string_lossy()])?; - run_git(Some(&dest), &["checkout", &spec.git_ref])?; - let current = current_git_ref(&dest); - println!("✓ Installed {} → {current}", spec.path); } + if let Err(error) = validate_git_ref_manifest(&dest, &spec.git_ref, spec.path.as_str()) { + if !existed { + let _ = std::fs::remove_dir_all(&dest); + } + return Err(error); + } + run_git(Some(&dest), &["checkout", &spec.git_ref])?; + let current = current_git_ref(&dest); + println!("✓ Installed {} → {current}", spec.path); let commit = run_git(Some(&dest), &["rev-parse", "HEAD"])?; let git_ref = spec.git_ref.clone(); Ok((git_ref, commit)) @@ -141,8 +220,9 @@ fn install_git_locked( ) -> Result<(), String> { let pkg_dir = packages_dir(); let dest = spec.dest_dir(&pkg_dir); + let existed = dest.exists(); - if dest.exists() { + if existed { run_git(Some(&dest), &["fetch", "origin"])?; run_git(Some(&dest), &["fetch", "--tags"])?; } else { @@ -153,6 +233,12 @@ fn install_git_locked( run_git(None, &["clone", &spec.clone_url(), &dest.to_string_lossy()])?; } + if let Err(error) = validate_git_ref_manifest(&dest, expected_commit, spec.path.as_str()) { + if !existed { + let _ = std::fs::remove_dir_all(&dest); + } + return Err(error); + } run_git(Some(&dest), &["checkout", "--detach", expected_commit])?; let actual = run_git(Some(&dest), &["rev-parse", "HEAD"])?; if actual != expected_commit { @@ -174,7 +260,7 @@ fn cmd_add_git(spec: &str) -> Result<(), String> { match add_dep_to_toml(toml_path, spec.path.as_str(), &git_ref) { Ok(true) => println!("✓ Added {} = \"{}\" to sema.toml", spec.path, git_ref), Ok(false) => {} - Err(e) => eprintln!("Warning: could not update sema.toml: {e}"), + Err(e) => crate::print_cli_warning(format!("could not update sema.toml: {e}")), } match update_lock_entry( @@ -186,7 +272,7 @@ fn cmd_add_git(spec: &str) -> Result<(), String> { }, ) { Ok(()) => println!("✓ Updated sema.lock"), - Err(e) => eprintln!("Warning: could not update sema.lock: {e}"), + Err(e) => crate::print_cli_warning(format!("could not update sema.lock: {e}")), } // Pull in this package's own dependencies, if any (transitive resolution). @@ -207,8 +293,9 @@ fn cmd_add_registry(spec: &str, registry: Option<&str>) -> Result<(), String> { Some(v) => v, None => { let info = registry_package_info(&name, ®istry_url)?; - latest_version(&info) - .ok_or_else(|| format!("No published versions found for '{name}'"))? + latest_compatible_version(&name, &info)?.ok_or_else(|| { + format!("No non-yanked version of '{name}' supports this Sema release") + })? } }; @@ -221,7 +308,7 @@ fn cmd_add_registry(spec: &str, registry: Option<&str>) -> Result<(), String> { match add_dep_to_toml(toml_path, &name, &version) { Ok(true) => println!("✓ Added {name} = \"{version}\" to sema.toml"), Ok(false) => {} - Err(e) => eprintln!("Warning: could not update sema.toml: {e}"), + Err(e) => crate::print_cli_warning(format!("could not update sema.toml: {e}")), } match update_lock_entry( @@ -234,7 +321,7 @@ fn cmd_add_registry(spec: &str, registry: Option<&str>) -> Result<(), String> { }, ) { Ok(()) => println!("✓ Updated sema.lock"), - Err(e) => eprintln!("Warning: could not update sema.lock: {e}"), + Err(e) => crate::print_cli_warning(format!("could not update sema.lock: {e}")), } // Pull in this package's own dependencies, if any (transitive resolution). @@ -682,7 +769,9 @@ pub fn cmd_install(locked: bool) -> Result<(), String> { )?; for name in &pruned { - eprintln!("Warning: '{name}' is no longer required, removing from sema.lock"); + crate::print_cli_warning(format!( + "'{name}' is no longer required; removing it from sema.lock" + )); } for note in ¬es { print_resolution_note(note); @@ -737,7 +826,7 @@ pub fn cmd_update(name: Option<&str>) -> Result<(), String> { continue; } if let Err(e) = update_single_package(&pkg_dir, dir) { - eprintln!("✗ Failed to update {}: {e}", rel.display()); + crate::print_cli_error(format!("could not update {}: {e}", rel.display())); } } } @@ -777,8 +866,9 @@ fn update_single_package(pkg_dir: &Path, dir: &Path) -> Result<(), String> { .unwrap_or(DEFAULT_REGISTRY); let info = registry_package_info(&name, registry)?; - let latest = - latest_version(&info).ok_or_else(|| format!("No versions found for '{name}'"))?; + let latest = latest_compatible_version(&name, &info)?.ok_or_else(|| { + format!("No non-yanked version of '{name}' supports this Sema release") + })?; if latest == current_ver { println!(" {} already at latest ({current_ver})", rel.display()); @@ -807,9 +897,15 @@ fn update_single_package(pkg_dir: &Path, dir: &Path) -> Result<(), String> { } else if dir.join(".git").is_dir() { // Git package — fetch and update to latest on the tracking ref run_git(Some(dir), &["fetch", "origin"])?; + run_git(Some(dir), &["fetch", "--tags"])?; // Read the tracking ref from sema.toml (needed if HEAD is detached after --locked install) let tracking_ref = read_dep_ref_from_toml(&rel_str); + validate_git_ref_manifest( + dir, + tracking_ref.as_deref().unwrap_or("FETCH_HEAD"), + &rel_str, + )?; if let Some(ref git_ref) = tracking_ref { // Checkout the branch/tag first so pull works let _ = run_git(Some(dir), &["checkout", git_ref]); @@ -858,7 +954,7 @@ pub fn cmd_remove(name: &str) -> Result<(), String> { match remove_dep_from_toml(toml_path, &rel_path) { Ok(true) => removed_from_toml = true, Ok(false) => {} - Err(e) => eprintln!("Warning: could not update sema.toml: {e}"), + Err(e) => crate::print_cli_warning(format!("could not update sema.toml: {e}")), } } @@ -916,7 +1012,7 @@ pub fn cmd_remove(name: &str) -> Result<(), String> { match remove_lock_entry(&rel_path) { Ok(true) => println!("✓ Removed {rel_path} from sema.lock"), Ok(false) => {} - Err(e) => eprintln!("Warning: could not update sema.lock: {e}"), + Err(e) => crate::print_cli_warning(format!("could not update sema.lock: {e}")), } Ok(()) @@ -1421,6 +1517,7 @@ fn install_tarball_atomic( // a broken tarball never leaves a corrupt tree behind. let build = || -> Result<(), String> { extract_tarball(tarball, &temp_dir)?; + validate_package_manifest_sema(&temp_dir, &format!("{name}@{version}"))?; write_pkg_meta(&temp_dir, name, version, registry_url, checksum)?; Ok(()) }; @@ -1452,6 +1549,7 @@ fn registry_install(name: &str, version: &str, registry_url: &str) -> Result Result<(), String> { validate_package_spec(name).map_err(|e| e.to_string())?; + validate_registry_version(name, version, registry_url)?; let (tarball, checksum) = registry_download(name, version, registry_url)?; if checksum != expected_checksum { @@ -1661,15 +1760,108 @@ fn registry_package_info(name: &str, registry_url: &str) -> Result Option { - info.get("versions")? - .as_array()? - .iter() - .filter(|v| !v.get("yanked").and_then(|y| y.as_bool()).unwrap_or(false)) - .filter_map(|v| v.get("version").and_then(|s| s.as_str())) - .next() - .map(|s| s.to_string()) +fn current_sema_version() -> semver::Version { + semver::Version::parse(env!("CARGO_PKG_VERSION")) + .expect("the Sema crate version is valid semver") +} + +fn version_metadata<'a>( + package: &str, + version: &str, + info: &'a serde_json::Value, +) -> Result<&'a serde_json::Value, String> { + info.get("versions") + .and_then(serde_json::Value::as_array) + .and_then(|versions| { + versions.iter().find(|candidate| { + candidate.get("version").and_then(serde_json::Value::as_str) == Some(version) + }) + }) + .ok_or_else(|| format!("Registry metadata has no version '{package}@{version}'")) +} + +fn ensure_version_supports_sema( + package: &str, + version: &str, + metadata: &serde_json::Value, +) -> Result, String> { + let requirement = match metadata.get("sema_version_req") { + None | Some(serde_json::Value::Null) => None, + Some(serde_json::Value::String(requirement)) => { + let requirement = requirement.trim(); + (!requirement.is_empty()).then_some(requirement) + } + Some(_) => { + return Err(format!( + "Registry metadata for {package}@{version} has invalid sema_version_req: \ + expected a string" + )) + } + }; + let Some(requirement) = requirement else { + return Ok(None); + }; + if requirement.len() > 128 { + return Err(format!( + "Registry metadata for {package}@{version} has invalid sema_version_req: \ + must be at most 128 characters" + )); + } + let parsed = semver::VersionReq::parse(requirement).map_err(|error| { + format!( + "Registry metadata for {package}@{version} has invalid sema_version_req \ + {requirement:?}: {error}" + ) + })?; + let current = current_sema_version(); + if !parsed.matches(¤t) { + return Err(format!( + "{package}@{version} requires Sema {requirement}, but this is Sema {current}" + )); + } + Ok(Some(requirement.to_string())) +} + +fn validate_registry_version( + package: &str, + version: &str, + registry_url: &str, +) -> Result, String> { + let info = registry_package_info(package, registry_url)?; + let metadata = version_metadata(package, version, &info)?; + ensure_version_supports_sema(package, version, metadata) +} + +/// Select the latest non-yanked version compatible with this Sema release. +fn latest_compatible_version( + package: &str, + info: &serde_json::Value, +) -> Result, String> { + let Some(versions) = info.get("versions").and_then(serde_json::Value::as_array) else { + return Ok(None); + }; + let mut invalid_requirement = None; + for metadata in versions.iter().filter(|version| { + !version + .get("yanked") + .and_then(serde_json::Value::as_bool) + .unwrap_or(false) + }) { + let Some(version) = metadata.get("version").and_then(serde_json::Value::as_str) else { + continue; + }; + match ensure_version_supports_sema(package, version, metadata) { + Ok(_) => return Ok(Some(version.to_string())), + Err(error) if error.contains("invalid sema_version_req") => { + invalid_requirement.get_or_insert(error); + } + Err(_) => {} + } + } + if let Some(error) = invalid_requirement { + return Err(error); + } + Ok(None) } fn validate_version(version: &str) -> Result { @@ -1702,6 +1894,26 @@ pub fn cmd_publish(registry: Option<&str>) -> Result<(), String> { .ok_or("sema.toml [package] missing 'version'")?; validate_version(version)?; + let sema_version_req = pkg + .get("sema_version_req") + .map(|value| { + value + .as_str() + .ok_or("sema.toml [package].sema_version_req must be a string") + }) + .transpose()? + .map(str::trim) + .filter(|requirement| !requirement.is_empty()); + if let Some(requirement) = sema_version_req { + if requirement.len() > 128 { + return Err( + "Invalid sema_version_req in sema.toml: must be at most 128 characters".to_string(), + ); + } + semver::VersionReq::parse(requirement).map_err(|error| { + format!("Invalid sema_version_req {requirement:?} in sema.toml: {error}") + })?; + } let token = read_token().ok_or("Not logged in. Run `sema pkg login --token ` first.")?; let registry_url = effective_registry(registry); @@ -1716,7 +1928,7 @@ pub fn cmd_publish(registry: Option<&str>) -> Result<(), String> { let metadata = serde_json::json!({ "description": pkg.get("description").and_then(|v| v.as_str()).unwrap_or(""), "repository_url": pkg.get("repository").and_then(|v| v.as_str()), - "sema_version_req": pkg.get("sema_version_req").and_then(|v| v.as_str()), + "sema_version_req": sema_version_req, }); // Upload. The multipart Form is single-use, so rebuild it (from owned bytes) @@ -2157,6 +2369,155 @@ mod tests { use std::fs; use std::io::Write; + #[test] + fn registry_version_selection_skips_incompatible_releases() { + let current = current_sema_version(); + let incompatible = format!(">{}.0.0", current.major + 1); + let compatible = format!(">={}.0.0", current.major); + let info = serde_json::json!({ + "versions": [ + { + "version": "2.0.0", + "yanked": false, + "sema_version_req": incompatible + }, + { + "version": "1.0.0", + "yanked": false, + "sema_version_req": compatible + } + ] + }); + assert_eq!( + latest_compatible_version("policies", &info).unwrap(), + Some("1.0.0".to_string()) + ); + } + + #[test] + fn explicit_registry_versions_fail_closed_on_invalid_requirements() { + let info = serde_json::json!({ + "versions": [{ + "version": "1.0.0", + "yanked": false, + "sema_version_req": "definitely not semver" + }] + }); + let metadata = version_metadata("policies", "1.0.0", &info).unwrap(); + let error = ensure_version_supports_sema("policies", "1.0.0", metadata).unwrap_err(); + assert!(error.contains("invalid sema_version_req")); + } + + #[test] + fn explicit_registry_versions_fail_closed_on_non_string_requirements() { + let info = serde_json::json!({ + "versions": [{ + "version": "1.0.0", + "yanked": false, + "sema_version_req": 34 + }] + }); + let metadata = version_metadata("policies", "1.0.0", &info).unwrap(); + let error = ensure_version_supports_sema("policies", "1.0.0", metadata).unwrap_err(); + assert!(error.contains("invalid sema_version_req")); + assert!(error.contains("expected a string")); + } + + #[test] + fn explicit_registry_versions_reject_incompatible_requirements() { + let current = current_sema_version(); + let incompatible = format!(">{}.0.0", current.major + 1); + let info = serde_json::json!({ + "versions": [{ + "version": "1.0.0", + "yanked": false, + "sema_version_req": incompatible + }] + }); + let metadata = version_metadata("policies", "1.0.0", &info).unwrap(); + let error = ensure_version_supports_sema("policies", "1.0.0", metadata).unwrap_err(); + assert!(error.contains("requires Sema")); + assert!(error.contains(¤t.to_string())); + } + + #[test] + fn installed_manifests_fail_closed_on_invalid_or_incompatible_requirements() { + let dir = tmpdir("manifest-sema-version"); + let current = current_sema_version(); + let incompatible = format!(">{}.0.0", current.major + 1); + + fs::write( + dir.join("sema.toml"), + "[package]\nname = \"policies\"\nsema_version_req = \"not semver\"\n", + ) + .unwrap(); + let invalid = validate_package_manifest_sema(&dir, "policies").unwrap_err(); + assert!(invalid.contains("invalid sema_version_req")); + + fs::write( + dir.join("sema.toml"), + "[package]\nname = \"policies\"\nsema_version_req = 34\n", + ) + .unwrap(); + let wrong_type = validate_package_manifest_sema(&dir, "policies").unwrap_err(); + assert!(wrong_type.contains("must be a string")); + + fs::write( + dir.join("sema.toml"), + format!("[package]\nname = \"policies\"\nsema_version_req = \"{incompatible}\"\n"), + ) + .unwrap(); + let incompatible = validate_package_manifest_sema(&dir, "policies").unwrap_err(); + assert!(incompatible.contains("requires Sema")); + assert!(incompatible.contains(¤t.to_string())); + + fs::write( + dir.join("sema.toml"), + format!( + "[package]\nname = \"policies\"\nsema_version_req = \">={}.0.0\"\n", + current.major + ), + ) + .unwrap(); + validate_package_manifest_sema(&dir, "policies").unwrap(); + let _ = fs::remove_dir_all(&dir); + } + + #[test] + fn git_refs_are_validated_before_checkout() { + let dir = tmpdir("git-sema-version"); + run_git(Some(&dir), &["init"]).unwrap(); + run_git(Some(&dir), &["config", "user.email", "test@test.com"]).unwrap(); + run_git(Some(&dir), &["config", "user.name", "Test"]).unwrap(); + run_git(Some(&dir), &["checkout", "-b", "main"]).unwrap(); + fs::write( + dir.join("sema.toml"), + "[package]\nname = \"policies\"\nsema_version_req = \"*\"\n", + ) + .unwrap(); + run_git(Some(&dir), &["add", "sema.toml"]).unwrap(); + run_git(Some(&dir), &["commit", "-m", "compatible"]).unwrap(); + run_git(Some(&dir), &["checkout", "-b", "incompatible"]).unwrap(); + let current = current_sema_version(); + fs::write( + dir.join("sema.toml"), + format!( + "[package]\nname = \"policies\"\nsema_version_req = \">{}.0.0\"\n", + current.major + 1 + ), + ) + .unwrap(); + run_git(Some(&dir), &["add", "sema.toml"]).unwrap(); + run_git(Some(&dir), &["commit", "-m", "incompatible"]).unwrap(); + run_git(Some(&dir), &["checkout", "main"]).unwrap(); + + let error = validate_git_ref_manifest(&dir, "incompatible", "policies").unwrap_err(); + assert!(error.contains("requires Sema")); + assert_eq!(current_git_ref(&dir), "main"); + + fs::remove_dir_all(&dir).unwrap(); + } + #[test] fn registry_install_rejects_path_traversal_name() { // Must fail at validation, before any network/filesystem work, so the diff --git a/crates/sema/src/repl/commands.rs b/crates/sema/src/repl/commands.rs index 3641dc95..b8cb2d98 100644 --- a/crates/sema/src/repl/commands.rs +++ b/crates/sema/src/repl/commands.rs @@ -91,7 +91,7 @@ pub fn dispatch( match interpreter.eval_str_in_global(rest) { Ok(val) => { if let Err(e) = super::inspector::run(val, rest) { - eprintln!("inspector error: {e}"); + crate::print_cli_error(format!("inspector failed: {e}")); } } Err(e) => print_error(&e), diff --git a/crates/sema/src/repl/mod.rs b/crates/sema/src/repl/mod.rs index 5fc91655..5f1190c3 100644 --- a/crates/sema/src/repl/mod.rs +++ b/crates/sema/src/repl/mod.rs @@ -70,7 +70,7 @@ pub fn run(interpreter: Interpreter, quiet: bool, sandbox_mode: Option<&str>) { println!("Goodbye!"); } Err(msg) => { - eprintln!("error: {msg}"); + crate::print_cli_error(msg); std::process::exit(1); } } @@ -131,7 +131,7 @@ pub fn run(interpreter: Interpreter, quiet: bool, sandbox_mode: Option<&str>) { continue; } Err(e) => { - eprintln!("Error: {e}"); + crate::print_cli_error(e); break; } } diff --git a/crates/sema/src/web/mod.rs b/crates/sema/src/web/mod.rs index cdba2a1a..3aa6617f 100644 --- a/crates/sema/src/web/mod.rs +++ b/crates/sema/src/web/mod.rs @@ -76,7 +76,7 @@ pub fn run(entry: &str, host: &str, port: u16, open: bool, llm: bool) -> Result< let interp = Interpreter::new_with_sandbox(&sandbox); interp .eval_str_in_global(&format!("(define __web-config-json {config_literal})")) - .map_err(|e| format!("web config injection failed: {}", e.inner()))?; + .map_err(|e| format!("web config injection failed: {}", e.format_plain()))?; // Configure LLM providers from env keys (as the CLI does) so the proxy can // reach real providers. Harmless when no keys are set. if llm { @@ -103,7 +103,7 @@ pub fn run(entry: &str, host: &str, port: u16, open: bool, llm: bool) -> Result< interp .eval_str_in_global(include_str!("dev_server.sema")) - .map_err(|e| format!("dev server error: {}", e.inner()))?; + .map_err(|e| format!("dev server failed: {}", e.format_plain()))?; Ok(()) } diff --git a/crates/sema/src/workflow_evidence.rs b/crates/sema/src/workflow_evidence.rs new file mode 100644 index 00000000..6bf7ac2d --- /dev/null +++ b/crates/sema/src/workflow_evidence.rs @@ -0,0 +1,285 @@ +//! Deterministic, provider-neutral workflow evidence bundles. + +use serde::Serialize; +use sha2::{Digest, Sha256}; +use std::collections::BTreeMap; +use std::fs; +use std::io; +use std::path::{Component, Path, PathBuf}; + +#[derive(Debug, Serialize)] +struct Evidence { + schema_version: u32, + run_id: String, + status: Option, + metadata: serde_json::Value, + result: serde_json::Value, + event_counts: BTreeMap, + events: Vec, +} + +#[derive(Debug, Serialize)] +struct Manifest { + schema_version: u32, + run_id: String, + files: Vec, +} + +#[derive(Debug, Serialize)] +struct ManifestFile { + path: String, + bytes: usize, + sha256: String, +} + +pub struct ExportedEvidence { + pub directory: PathBuf, + pub evidence_json: PathBuf, + pub evidence_markdown: PathBuf, + pub manifest_json: PathBuf, +} + +pub fn export( + runs_root: &Path, + run_id: &str, + output_directory: Option<&Path>, +) -> io::Result { + validate_run_id(run_id)?; + let run_directory = runs_root.join(run_id); + if !run_directory.is_dir() { + return Err(io::Error::new( + io::ErrorKind::NotFound, + format!("workflow run not found: {}", run_directory.display()), + )); + } + let output_directory = output_directory + .map(Path::to_path_buf) + .unwrap_or_else(|| run_directory.join("evidence")); + fs::create_dir_all(&output_directory)?; + + let metadata = read_json_or_null(&run_directory.join("metadata.json"))?; + let result = read_json_or_null(&run_directory.join("result.json"))?; + let journal_paths = journal_paths(&run_directory)?; + let mut events = Vec::new(); + let mut event_counts = BTreeMap::new(); + for path in &journal_paths { + for line in fs::read_to_string(path)?.lines() { + if line.trim().is_empty() { + continue; + } + let event: serde_json::Value = serde_json::from_str(line).map_err(|error| { + io::Error::new( + io::ErrorKind::InvalidData, + format!("{}: {error}", path.display()), + ) + })?; + if let Some(kind) = event.get("event").and_then(serde_json::Value::as_str) { + *event_counts.entry(kind.to_string()).or_insert(0) += 1; + } + events.push(event); + } + } + let status = result + .get("status") + .and_then(serde_json::Value::as_str) + .map(str::to_string); + let evidence = Evidence { + schema_version: 1, + run_id: run_id.to_string(), + status, + metadata, + result, + event_counts, + events, + }; + + let evidence_json = output_directory.join("evidence.json"); + let evidence_markdown = output_directory.join("evidence.md"); + let manifest_json = output_directory.join("manifest.json"); + let json_bytes = serde_json::to_vec_pretty(&evidence).map_err(io::Error::other)?; + fs::write(&evidence_json, &json_bytes)?; + let markdown = render_markdown(&evidence); + fs::write(&evidence_markdown, markdown.as_bytes())?; + + let mut manifest_sources = vec![ + run_directory.join("metadata.json"), + run_directory.join("result.json"), + ]; + manifest_sources.extend(journal_paths); + manifest_sources.push(evidence_json.clone()); + manifest_sources.push(evidence_markdown.clone()); + let files = manifest_sources + .into_iter() + .filter(|path| path.is_file()) + .map(|path| manifest_file(&path, &run_directory, &output_directory)) + .collect::>>()?; + let manifest = Manifest { + schema_version: 1, + run_id: run_id.to_string(), + files, + }; + fs::write( + &manifest_json, + serde_json::to_vec_pretty(&manifest).map_err(io::Error::other)?, + )?; + + Ok(ExportedEvidence { + directory: output_directory, + evidence_json, + evidence_markdown, + manifest_json, + }) +} + +fn validate_run_id(run_id: &str) -> io::Result<()> { + let mut components = Path::new(run_id).components(); + let valid = matches!(components.next(), Some(Component::Normal(_))) + && components.next().is_none() + && run_id != "." + && run_id != ".."; + if valid { + Ok(()) + } else { + Err(io::Error::new( + io::ErrorKind::InvalidInput, + "run id must be exactly one safe path component", + )) + } +} + +fn read_json_or_null(path: &Path) -> io::Result { + match fs::read(path) { + Ok(bytes) => serde_json::from_slice(&bytes).map_err(|error| { + io::Error::new( + io::ErrorKind::InvalidData, + format!("{}: {error}", path.display()), + ) + }), + Err(error) if error.kind() == io::ErrorKind::NotFound => Ok(serde_json::Value::Null), + Err(error) => Err(error), + } +} + +fn journal_paths(run_directory: &Path) -> io::Result> { + let mut paths = Vec::new(); + let primary = run_directory.join("events.jsonl"); + if primary.is_file() { + paths.push(primary); + } + let mut resumes = fs::read_dir(run_directory)? + .filter_map(Result::ok) + .map(|entry| entry.path()) + .filter(|path| { + path.file_name() + .and_then(|name| name.to_str()) + .is_some_and(|name| name.starts_with("events.resume-") && name.ends_with(".jsonl")) + }) + .collect::>(); + resumes.sort_by_key(|path| { + path.file_stem() + .and_then(|stem| stem.to_str()) + .and_then(|stem| stem.strip_prefix("events.resume-")) + .and_then(|number| number.parse::().ok()) + .unwrap_or(u64::MAX) + }); + paths.extend(resumes); + Ok(paths) +} + +fn render_markdown(evidence: &Evidence) -> String { + let mut markdown = format!( + "# Workflow evidence\n\n- Run: `{}`\n- Status: `{}`\n- Events: {}\n\n## Event counts\n\n| Event | Count |\n| --- | ---: |\n", + evidence.run_id, + evidence.status.as_deref().unwrap_or("unknown"), + evidence.events.len() + ); + for (event, count) in &evidence.event_counts { + markdown.push_str(&format!("| `{event}` | {count} |\n")); + } + markdown.push_str( + "\nThe machine-readable bundle is `evidence.json`; file integrity is recorded in `manifest.json`.\n", + ); + markdown +} + +fn manifest_file( + path: &Path, + run_directory: &Path, + output_directory: &Path, +) -> io::Result { + let bytes = fs::read(path)?; + let display = path + .strip_prefix(run_directory) + .or_else(|_| path.strip_prefix(output_directory)) + .unwrap_or(path) + .to_string_lossy() + .replace('\\', "/"); + Ok(ManifestFile { + path: display, + bytes: bytes.len(), + sha256: format!("{:x}", Sha256::digest(&bytes)), + }) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn test_directory(name: &str) -> PathBuf { + std::env::temp_dir().join(format!( + "sema-workflow-evidence-{name}-{}", + std::process::id() + )) + } + + #[test] + fn rejects_path_like_run_ids() { + assert!(validate_run_id("../run").is_err()); + assert!(validate_run_id("nested/run").is_err()); + assert!(validate_run_id("run-1").is_ok()); + } + + #[test] + fn exports_ordered_events_and_integrity_manifest() { + let root = test_directory("bundle"); + let _ = fs::remove_dir_all(&root); + let run = root.join("run-1"); + fs::create_dir_all(&run).unwrap(); + fs::write(run.join("metadata.json"), r#"{"name":"demo"}"#).unwrap(); + fs::write(run.join("result.json"), r#"{"status":"success"}"#).unwrap(); + fs::write( + run.join("events.jsonl"), + "{\"event\":\"run.started\",\"seq\":1}\n", + ) + .unwrap(); + fs::write( + run.join("events.resume-1.jsonl"), + "{\"event\":\"checkpoint\",\"seq\":2}\n", + ) + .unwrap(); + + let bundle = export(&root, "run-1", None).unwrap(); + let evidence: serde_json::Value = + serde_json::from_slice(&fs::read(&bundle.evidence_json).unwrap()).unwrap(); + assert_eq!(evidence["status"], "success"); + assert_eq!(evidence["event_counts"]["run.started"], 1); + assert_eq!(evidence["event_counts"]["checkpoint"], 1); + assert_eq!(evidence["events"][0]["seq"], 1); + assert_eq!(evidence["events"][1]["seq"], 2); + + let manifest: serde_json::Value = + serde_json::from_slice(&fs::read(&bundle.manifest_json).unwrap()).unwrap(); + let files = manifest["files"].as_array().unwrap(); + let evidence_entry = files + .iter() + .find(|entry| entry["path"] == "evidence/evidence.json") + .unwrap(); + let evidence_bytes = fs::read(&bundle.evidence_json).unwrap(); + assert_eq!( + evidence_entry["sha256"], + format!("{:x}", Sha256::digest(&evidence_bytes)) + ); + + fs::remove_dir_all(&root).unwrap(); + } +} diff --git a/crates/sema/tests/integration_test.rs b/crates/sema/tests/integration_test.rs index caa58616..6af5f595 100644 --- a/crates/sema/tests/integration_test.rs +++ b/crates/sema/tests/integration_test.rs @@ -5323,7 +5323,7 @@ fn test_ast_parse_error() { assert!(!output.status.success()); let stderr = String::from_utf8_lossy(&output.stderr); assert!( - stderr.contains("Parse error"), + stderr.contains("parsing failed") && stderr.contains("unterminated list"), "expected parse error: {stderr}" ); } diff --git a/crates/sema/tests/pmap_async_test.rs b/crates/sema/tests/pmap_async_test.rs index 622196f9..f0382ba4 100644 --- a/crates/sema/tests/pmap_async_test.rs +++ b/crates/sema/tests/pmap_async_test.rs @@ -407,7 +407,7 @@ fn pmap_preserves_exact_arity_errors() { assert!(zero_args .expect_err("zero-argument pmap must fail") .to_string() - .contains("llm/pmap expects 2-3 args, got 0")); + .contains("llm/pmap expects 2 to 3 arguments, got 0")); assert_eq!(recorder.call_count(), 0); let fake = FakeProvider::builder("fake").model("fake-chat").build(); @@ -415,7 +415,7 @@ fn pmap_preserves_exact_arity_errors() { assert!(four_args .expect_err("four-argument pmap must fail") .to_string() - .contains("llm/pmap expects 2-3 args, got 4")); + .contains("llm/pmap expects 2 to 3 arguments, got 4")); assert_eq!(recorder.call_count(), 0); } diff --git a/crates/sema/tests/suites/eval_stdlib_test.rs b/crates/sema/tests/suites/eval_stdlib_test.rs index cdca36ec..090b800d 100644 --- a/crates/sema/tests/suites/eval_stdlib_test.rs +++ b/crates/sema/tests/suites/eval_stdlib_test.rs @@ -214,11 +214,52 @@ eval_tests! { // A handler that suspends parks on the runtime and resumes; the raw value // (a keyword, which has no JSON form) passes through unstringified. tool_invoke_suspending_handler: r#"(begin (deftool slow "Sleep then return" {} (lambda () (async/sleep 1) :done)) (tool/invoke slow {}))"# => Value::keyword("done"), + string_split_type_condition_fields: + r#"(try (string/split 42 ",") (catch error (list (:type error) (:function error) (:argument error) (:expected error) (:got error))))"# + => Value::list(vec![ + Value::keyword("type-error"), + Value::string("string/split"), + Value::int(1), + Value::string("string"), + Value::string("int"), + ]), + string_split_arity_condition_fields: + r#"(try (string/split "x") (catch error (list (:type error) (:function error) (:expected error) (:got error))))"# + => Value::list(vec![ + Value::keyword("arity"), + Value::string("string/split"), + Value::string("2"), + Value::int(1), + ]), } eval_error_tests! { tool_invoke_invalid_args: r#"(begin (deftool calc "Add" {:x {:type :number}} (lambda (x) x)) (tool/invoke calc {}))"# => "invalid arguments for tool 'calc': missing key: x", tool_invoke_validate_fail: r#"(begin (deftool check "Check" {:x {:type :number :validate (lambda (v) (> v 0)) :message "must be positive"}} (lambda (x) x)) (tool/invoke check {:x -1}))"# => "invalid arguments for tool 'check': key x: must be positive", + deftool_options_type_has_context: + r#"(deftool bad "Bad" {} 42 (lambda () nil))"# + => "deftool: options must be a map, got int", + deftool_subjects_type_has_context: + r#"(deftool bad "Bad" {} {:policy-subjects 42} (lambda () nil))"# + => "deftool: :policy-subjects must be a list or vector, got int", + deftool_subject_missing_kind: + r#"(deftool bad "Bad" {} {:policy-subjects [{}]} (lambda () nil))"# + => "deftool: policy subject 1 is missing :kind", + deftool_subject_field_type_and_index: + r#"(deftool bad "Bad" {} {:policy-subjects [{:kind :command :command-arg :cmd} {:kind :file-read :path-arg 42}]} (lambda () nil))"# + => "deftool: policy subject 2 :path-arg must be a keyword or string, got int", + deftool_subject_kind_lists_valid_values: + r#"(deftool bad "Bad" {} {:policy-subjects [{:kind :database :target-arg :db}]} (lambda () nil))"# + => "deftool: policy subject 1 has unsupported :kind :database", + deftool_subject_unknown_key: + r#"(deftool bad "Bad" {} {:policy-subjects [{:kind :file-read :path-ag :path}]} (lambda () nil))"# + => "deftool: policy subject 1 has unknown key :path-ag", + string_split_type_names_function_and_argument: + r#"(string/split 42 ",")"# + => "string/split argument 1 expected string, got int", + string_split_arity_uses_readable_grammar: + r#"(string/split "x")"# + => "string/split expects 2 arguments, got 1", } // ============================================================ diff --git a/crates/sema/tests/suites/eval_test.rs b/crates/sema/tests/suites/eval_test.rs index 7e1cbd94..fb5897f5 100644 --- a/crates/sema/tests/suites/eval_test.rs +++ b/crates/sema/tests/suites/eval_test.rs @@ -2985,7 +2985,7 @@ eval_tests! { eval_error_tests! { // Arity is still checked on the self-call frame path. - call_self_arity_error: "(define (f n) (if (= n 0) 0 (+ 1 (f)))) (f 1)" => "expects 1 args, got 0", + call_self_arity_error: "(define (f n) (if (= n 0) 0 (+ 1 (f)))) (f 1)" => "expects 1 argument, got 0", } // ============================================================ diff --git a/crates/sema/tests/suites/stream_async_test.rs b/crates/sema/tests/suites/stream_async_test.rs index 401f12c0..8e57bc4d 100644 --- a/crates/sema/tests/suites/stream_async_test.rs +++ b/crates/sema/tests/suites/stream_async_test.rs @@ -796,7 +796,7 @@ fn blocking_stream_compatibility_native_preserves_public_arity_error() { .expect("arity error message") .to_string(); assert!( - message.contains("llm/stream expects 1-3 args, got 0"), + message.contains("llm/stream expects 1 to 3 arguments, got 0"), "unexpected zero-arity error: {message}" ); assert_eq!( diff --git a/crates/sema/tests/suites/workflow_policy_test.rs b/crates/sema/tests/suites/workflow_policy_test.rs index 50b667fa..bb09e008 100644 --- a/crates/sema/tests/suites/workflow_policy_test.rs +++ b/crates/sema/tests/suites/workflow_policy_test.rs @@ -84,6 +84,47 @@ fn model_skip_still_fails_a_non_fallback_call_before_provider_access() { ); } +#[test] +fn caught_model_denial_preserves_structured_policy_details() { + let src = r#" + (defpolicy safe + {:models {:default :deny}}) + (defworkflow guarded "structured model denial" {:policy safe} + (phase "Run") + (def denial + (try + (llm/complete "must not run") + (catch error error))) + {:status :success :denial denial}) + "#; + + let out = wc::run_once( + src, + fake_with_reply("unexpected"), + "wf_policy_structured_denial", + ); + assert_eq!(out.result["status"], "success"); + assert_eq!( + out.recorder.call_count(), + 0, + "a denied model must not reach the provider" + ); + + let denial = &out.result["denial"]; + assert_eq!(denial["type"], "policy-denied"); + assert_eq!(denial["policy"], "safe"); + assert_eq!(denial["boundary"], "model"); + assert_eq!(denial["subject"], "fake/fake-model"); + assert_eq!(denial["rule"], "models.default-deny"); + assert_eq!(denial["reason"], "model fake/fake-model is not allowlisted"); + assert_eq!(denial["action"], "fail"); + assert_eq!(denial["source"], "request"); + assert_eq!( + denial["message"], + "Policy 'safe' denied model 'fake/fake-model': model fake/fake-model is not allowlisted" + ); +} + #[test] fn model_skip_skips_only_denied_fallback_targets() { let src = r#" @@ -276,6 +317,187 @@ fn stream_embed_and_rerank_are_denied_before_provider_or_callback() { let _ = std::fs::remove_dir_all(&base); } +#[test] +fn input_policy_redacts_before_provider_dispatch() { + let src = r#" + (defpolicy private + {:input {:detect [:email] + :actions {:email :redact}}}) + (defworkflow guarded "input redaction" {:policy private} + (phase "Run") + (def result (step "Email alice@example.com" {:name "writer"})) + {:status :success :result result}) + "#; + + let out = wc::run_once( + src, + fake_with_reply("accepted"), + "wf_policy_input_redaction", + ); + assert_eq!(out.result["status"], "success"); + let requests = out.recorder.requests(); + assert_eq!(requests.len(), 1); + let provider_input = requests[0].messages[0].content.to_text(); + assert!(!provider_input.contains("alice@example.com")); + assert!(provider_input.contains("«redacted:email»")); + assert!( + wc::events_of(&out.events, "policy.redacted") + .iter() + .any(|event| { + event["boundary"] == "llm.input" && event["label"] == "email" && event["count"] == 1 + }), + "the safe aggregate finding should be journaled" + ); +} + +#[test] +fn output_policy_buffers_streams_and_blocks_before_callbacks() { + let base = temp_run_dir("policy-output-block"); + let marker = base.join("stream-callback"); + let path = marker + .to_string_lossy() + .replace('\\', "\\\\") + .replace('"', "\\\""); + let src = format!( + r#" + (defpolicy private + {{:output {{:detect [:email] + :actions {{:email :block}}}}}}) + (defworkflow guarded "output block" {{:policy private}} + (phase "Run") + (def completion + (try (llm/complete "complete") (catch error (:type error)))) + (def streaming + (try + (llm/stream "stream" + (lambda (chunk) (file/write "{path}" chunk))) + (catch error (:type error)))) + {{:status :success :types (list completion streaming)}}) + "# + ); + let fake = FakeProvider::builder("fake") + .model("fake-model") + .reply("alice@example.com") + .stream(&["alice@", "example.com"]) + .build(); + let out = run_workflow(&src, fake, RunOpts::fresh("wf_policy_output_block", &base)); + + assert_eq!(out.result["status"], "success"); + assert_eq!( + out.result["types"], + serde_json::json!(["policy-denied", "policy-denied"]) + ); + assert!( + !marker.exists(), + "a governed stream must not deliver unsafe prefixes" + ); + assert_eq!( + wc::events_of(&out.events, "policy.violation") + .iter() + .filter(|event| event["boundary"] == "llm.output") + .count(), + 2 + ); + + let _ = std::fs::remove_dir_all(&base); +} + +#[test] +fn output_policy_returns_only_redacted_content() { + let src = r#" + (defpolicy private + {:output {:detect [:email] + :actions {:email :redact}}}) + (defworkflow guarded "output redaction" {:policy private} + (phase "Run") + (def result (llm/complete "complete")) + {:status :success :result result}) + "#; + let out = wc::run_once( + src, + fake_with_reply("Contact alice@example.com"), + "wf_policy_output_redaction", + ); + + assert_eq!(out.result["status"], "success"); + assert_eq!(out.result["result"], "Contact «redacted:email»"); + assert!( + !serde_json::to_string(&out.events) + .expect("events serialize") + .contains("alice@example.com"), + "journals must contain only safe finding metadata and digests" + ); +} + +#[test] +fn completion_policy_fails_a_nominal_success_when_evidence_is_missing() { + let src = r#" + (defpolicy evidenced + {:metadata {:require [:owner]} + :completion {:require-events [:checkpoint]}}) + (defworkflow guarded "completion evidence" + {:policy evidenced :owner "risk-team"} + (phase "Run") + {:status :success}) + "#; + let out = wc::run_once( + src, + fake_with_reply("unused"), + "wf_policy_completion_missing", + ); + + assert_eq!(out.result["status"], "failed"); + assert!(out.result["error"] + .as_str() + .is_some_and(|message| message.contains("checkpoint"))); + let ended = &wc::events_of(&out.events, "run.ended")[0]; + assert_eq!(ended["status"], "failed"); + assert!(ended["reason"] + .as_str() + .is_some_and(|message| message.contains("checkpoint"))); +} + +#[test] +fn successful_tool_results_satisfy_completion_evidence() { + let src = r#" + (deftool ping "Return pong" {} (lambda () "pong")) + (defpolicy evidenced + {:completion {:require-events [:agent.tool_result]}}) + (defworkflow guarded "tool evidence" {:policy evidenced} + (phase "Run") + (def result (step "Call ping" {:tools [ping]})) + {:status :success :result result}) + "#; + let fake = FakeProvider::builder("fake") + .model("fake-model") + .tool_call("call_1", "ping", serde_json::json!({})) + .reply("done") + .build(); + let out = wc::run_once(src, fake, "wf_policy_tool_result_evidence"); + + assert_eq!(out.result["status"], "success"); + let results = wc::events_of(&out.events, "agent.tool_result"); + assert_eq!(results.len(), 1); + assert_eq!(results[0]["tool_name"], "ping"); + assert_eq!(results[0]["result_digest"], "gated"); +} + +#[test] +fn run_ended_status_mirrors_an_explicit_failed_envelope() { + let src = r#" + (defworkflow guarded "explicit failure" {} + (phase "Run") + {:status :failed :reason "review failed"}) + "#; + let out = wc::run_once(src, fake_with_reply("unused"), "wf_policy_explicit_failure"); + + assert_eq!(out.result["status"], "failed"); + assert_eq!( + wc::events_of(&out.events, "run.ended")[0]["status"], + "failed" + ); +} + const BATCH_TOOLS: &str = r#" (deftool allowed-tool "Write a marker" @@ -385,6 +607,20 @@ fn tool_error_denial_runs_allowed_siblings_without_journaling_denied_call() { assert!(wc::events_of(&out.events, "policy.violation") .iter() .any(|event| { event["subject"] == "blocked-tool" && event["action"] == "tool-error" })); + let requests = out.recorder.requests(); + let denied_result = requests + .iter() + .flat_map(|request| request.messages.iter()) + .find(|message| message.tool_call_id.as_deref() == Some("blocked_1")) + .expect("the denied call must return a correlated tool result"); + assert_eq!( + denied_result.content.as_text(), + Some("tool 'blocked-tool' was blocked: tool blocked-tool matches an explicit deny rule") + ); + assert!( + !denied_result.content.to_text().contains("Error:"), + "tool results must not embed a second presentation prefix" + ); let _ = std::fs::remove_dir_all(&base); } diff --git a/docs/plans/evidence/unified-cooperative-runtime/runtime-match-map.tsv b/docs/plans/evidence/unified-cooperative-runtime/runtime-match-map.tsv index c9fc11d3..75f91929 100644 --- a/docs/plans/evidence/unified-cooperative-runtime/runtime-match-map.tsv +++ b/docs/plans/evidence/unified-cooperative-runtime/runtime-match-map.tsv @@ -70,12 +70,12 @@ F22 crates/sema-core/src/output_hook.rs:71:thread_local! { F24 crates/sema-core/src/runtime/native.rs:393: /// `Value::async_promise_id(id)` — `async/spawn`'s own default. The spawn F18 crates/sema-core/src/value.rs:173: /// "requires runtime invocation" hard-error stub (async/spawn, channel/*, F18 crates/sema-core/src/value.rs:175: /// `with_ctx_runtime`, e.g. `async/sleep`, `__llm-chat-blocking`) has a real -C17 crates/sema-core/src/value.rs:2868:thread_local! { C17 crates/sema-core/src/value.rs:28:thread_local! { +C17 crates/sema-core/src/value.rs:2900:thread_local! { F18 crates/sema-core/src/value.rs:492: /// (`async/spawn`, `channel/*`, `async/resolved`, …). Callback-driving F15 crates/sema-core/src/value.rs:573:/// the user explicitly cancels via `async/cancel` is *not* a normal rejection F15 crates/sema-core/src/value.rs:575:/// `async/cancelled?` be precise without string-matching, and lets -F32 crates/sema-core/src/value.rs:767: let dispatch_val = crate::call_callback(ctx, &mm.dispatch_fn, args)?; +F32 crates/sema-core/src/value.rs:799: let dispatch_val = crate::call_callback(ctx, &mm.dispatch_fn, args)?; C17 crates/sema-core/src/value.rs:94:thread_local! { H04 crates/sema-dap/src/server.rs:1059: while let Ok(cmd) = ds.command_rx.recv() { H04 crates/sema-dap/src/server.rs:263: reply_rx.recv().await.unwrap_or_default() @@ -86,318 +86,318 @@ H04 crates/sema-dap/src/server.rs:903: while let Ok(evt) = db H04 crates/sema-dap/src/server.rs:94: Some(event) = event_bridge_rx.recv() => { H04 crates/sema-dap/src/server.rs:995: // with no `RuntimeState` borrow held. Async ops (async/await, F33 crates/sema-eval/src/debug_session.rs:16:thread_local! { -F31 crates/sema-eval/src/eval.rs:150: // `Rc` and `Value` edges (a still-parked/detached `async/spawn` -F32 crates/sema-eval/src/eval.rs:220: sema_core::set_eval_callback(&ctx, eval_value_vm); -F32 crates/sema-eval/src/eval.rs:221: sema_core::set_call_callback(&ctx, call_value); -F32 crates/sema-eval/src/eval.rs:222: sema_core::set_call_owned_callback(&ctx, call_value_owned); -F32 crates/sema-eval/src/eval.rs:241: sema_core::set_eval_callback(&ctx, eval_value_vm); -F32 crates/sema-eval/src/eval.rs:242: sema_core::set_call_callback(&ctx, call_value); -F32 crates/sema-eval/src/eval.rs:243: sema_core::set_call_owned_callback(&ctx, call_value_owned); -F32 crates/sema-eval/src/eval.rs:3450: sema_core::call_callback(context, &thunk.body, &[])? -F31 crates/sema-eval/src/eval.rs:4520: .eval_str("(defmacro sleeping-transformer () (async/sleep 1) '42)") -F31 crates/sema-eval/src/eval.rs:4564: b"(defmacro loaded-sleeper () (async/sleep 1) '42)\ -F31 crates/sema-eval/src/eval.rs:4636: .eval_str("(defmacro late-force-macro () (async/sleep 1) '42)") -F31 crates/sema-eval/src/eval.rs:4655: .eval_str("(defmacro macroexpand-sleeper () (async/sleep 1) '42)") -F31 crates/sema-eval/src/eval.rs:4678: "(defmacro spawn-transformer () (async/spawn (fn () 42)))", -F31 crates/sema-eval/src/eval.rs:5043: (async/spawn (fn () (async/sleep 1) (channel/send ch 42))) \ -F31 crates/sema-eval/src/eval.rs:5044: (force (delay (channel/recv ch))))", -F31 crates/sema-eval/src/eval.rs:5060: (async/sleep 1) \ -F31 crates/sema-eval/src/eval.rs:5079: (async/sleep 10) \ -F31 crates/sema-eval/src/eval.rs:5083: (async/await \ -F31 crates/sema-eval/src/eval.rs:5084: (async/all (list (async (force p)) (async (force p))))) \ -F31 crates/sema-eval/src/eval.rs:5105: (async/sleep 20) -F31 crates/sema-eval/src/eval.rs:5127: std::thread::sleep(std::time::Duration::from_millis(25)); -F31 crates/sema-eval/src/eval.rs:5147: (async/sleep 1) \ -F31 crates/sema-eval/src/eval.rs:5165: (define p (delay (begin (async/sleep 1) (mutable-array/new)))) \ -F31 crates/sema-eval/src/eval.rs:5182: (define force-promise (delay (channel/recv force-gate))))", -F31 crates/sema-eval/src/eval.rs:5218: (channel/send entered :entered) \ -F31 crates/sema-eval/src/eval.rs:5219: (channel/recv body-gate) \ -F31 crates/sema-eval/src/eval.rs:5223: (channel/recv entered) \ -F31 crates/sema-eval/src/eval.rs:5225: (async/sleep 1) \ -F31 crates/sema-eval/src/eval.rs:5226: (async/cancel first) \ -F31 crates/sema-eval/src/eval.rs:5227: (channel/send body-gate :continue) \ -F31 crates/sema-eval/src/eval.rs:5250: (channel/send entered :q) -F31 crates/sema-eval/src/eval.rs:5251: (channel/recv hold) -F31 crates/sema-eval/src/eval.rs:5254: (channel/recv entered) -F31 crates/sema-eval/src/eval.rs:5257: (async/sleep 5) -F31 crates/sema-eval/src/eval.rs:5258: (async/cancel p-owner) -F31 crates/sema-eval/src/eval.rs:5259: (channel/send hold :go) -F31 crates/sema-eval/src/eval.rs:5315: (delay (channel/recv force-deadlock-gate))))", -F31 crates/sema-eval/src/eval.rs:5327: (async (channel/send force-deadlock-gate 9)) \ -F31 crates/sema-eval/src/eval.rs:5556: // `async/sleep` returns a structural timer suspension. The runtime parks its -F31 crates/sema-eval/src/eval.rs:5564: .eval_str_via_runtime("(async/sleep 2)") -F31 crates/sema-eval/src/eval.rs:5565: .expect("async/sleep settles through the runtime"); -F31 crates/sema-eval/src/eval.rs:5575: .eval_str_via_runtime("(begin (async/sleep 2) (+ 40 2))") -F31 crates/sema-eval/src/eval.rs:5576: .expect("program continues past async/sleep"); -F31 crates/sema-eval/src/eval.rs:5580: // `async/spawn` + `async/await` round-trip through the runtime: spawn a -F31 crates/sema-eval/src/eval.rs:5588: .eval_str_via_runtime("(await (async/spawn (fn () (+ 40 2))))") -F31 crates/sema-eval/src/eval.rs:5602: (define a (async/spawn (fn () (+ 1 2)))) \ -F31 crates/sema-eval/src/eval.rs:5603: (define b (async/spawn (fn () (* 4 5)))) \ -F31 crates/sema-eval/src/eval.rs:5610: // A spawned task that itself parks on a timer (`async/sleep`) and resumes: -F31 crates/sema-eval/src/eval.rs:5617: .eval_str_via_runtime("(await (async/spawn (fn () (async/sleep 2) 7)))") -F31 crates/sema-eval/src/eval.rs:5630: // detached task (parked on its `async/sleep` timer at the end of call one) -F31 crates/sema-eval/src/eval.rs:5639: .eval_str_via_runtime("(define p (async/spawn (fn () (async/sleep 2) 42)))") -F31 crates/sema-eval/src/eval.rs:5696: r#"(await (async/spawn (fn () (load "./dep.sema"))))"#, -F31 crates/sema-eval/src/eval.rs:5712: b"(channel/recv runtime-load-gate) (define runtime-loaded 42) runtime-loaded".to_vec(), -F31 crates/sema-eval/src/eval.rs:5728: .eval_str_via_runtime("(channel/send runtime-load-gate :continue)") -F31 crates/sema-eval/src/eval.rs:5747: b"(module blocking (export answer) (set! runtime-import-count (+ runtime-import-count 1)) (channel/recv runtime-import-gate) (define answer 42))".to_vec(), -F31 crates/sema-eval/src/eval.rs:5783: .eval_str_via_runtime("(channel/send runtime-import-gate :continue)") -F31 crates/sema-eval/src/eval.rs:5811: b"(module sync-runtime-overlap (export overlap-answer) (set! overlap-count (+ overlap-count 1)) (channel/recv overlap-gate) (define overlap-answer 42))".to_vec(), -F31 crates/sema-eval/src/eval.rs:5850: .eval_str_via_runtime("(channel/send overlap-gate :continue)") -F31 crates/sema-eval/src/eval.rs:5871: b"(module foreign-runtime-import (export foreign-answer) (set! foreign-import-count (+ foreign-import-count 1)) (channel/recv foreign-import-gate) (define foreign-answer 42))".to_vec(), -F31 crates/sema-eval/src/eval.rs:5906: .eval_str_via_runtime("(channel/send foreign-import-gate :continue)") -F31 crates/sema-eval/src/eval.rs:5991: b"(channel/recv gate-cancel-channel)".to_vec(), -F31 crates/sema-eval/src/eval.rs:6027: b"(module single-flight-source (export source-answer) (set! source-import-count (+ source-import-count 1)) (channel/recv source-import-gate) (define source-answer 42))".to_vec(), -F31 crates/sema-eval/src/eval.rs:6063: .eval_str_via_runtime("(channel/send source-import-gate :continue)") -F31 crates/sema-eval/src/eval.rs:6091: "(module single-flight-bytecode (export bytecode-answer) (set! bytecode-import-count (+ bytecode-import-count 1)) (channel/recv bytecode-import-gate) (define bytecode-answer 42))", -F31 crates/sema-eval/src/eval.rs:60: /// context would route the VM's `call_callback` through unregistered -F31 crates/sema-eval/src/eval.rs:6128: .eval_str_via_runtime("(channel/send bytecode-import-gate :continue)") -F31 crates/sema-eval/src/eval.rs:6151: b"(module cancelled-owner-import (export cancelled-owner-answer) (set! cancelled-owner-count (+ cancelled-owner-count 1)) (if (= cancelled-owner-count 1) (channel/recv cancelled-owner-gate) nil) (define cancelled-owner-answer 42))".to_vec(), -F31 crates/sema-eval/src/eval.rs:6202: b"(module failed-owner-import (export failed-owner-answer) (set! failed-owner-count (+ failed-owner-count 1)) (if (= failed-owner-count 1) (begin (channel/recv failed-owner-gate) (error \"expected first-owner failure\")) nil) (define failed-owner-answer 42))".to_vec(), -F31 crates/sema-eval/src/eval.rs:6232: .eval_str_via_runtime("(channel/send failed-owner-gate :continue)") -F31 crates/sema-eval/src/eval.rs:6255: b"(channel/recv cancelled-load-gate) :loaded".to_vec(), -F31 crates/sema-eval/src/eval.rs:6276: .eval_str_via_runtime("(channel/send cancelled-load-gate :retry)") -F31 crates/sema-eval/src/eval.rs:6294: b"(module cancelled-import (export cancelled-import-answer) (channel/recv cancelled-import-gate) (define cancelled-import-answer 42))".to_vec(), -F31 crates/sema-eval/src/eval.rs:6319: .eval_str_via_runtime("(channel/send cancelled-import-gate :retry)") -F31 crates/sema-eval/src/eval.rs:6368: b"(channel/recv compile-failure-import-gate) (if #t)".to_vec(), -F31 crates/sema-eval/src/eval.rs:6385: .eval_str_via_runtime("(channel/send compile-failure-import-gate :continue)") -F31 crates/sema-eval/src/eval.rs:6412: b"(channel/recv callback-failure-import-gate) (error \"expected module callback failure\")".to_vec(), -F31 crates/sema-eval/src/eval.rs:6429: .eval_str_via_runtime("(channel/send callback-failure-import-gate :continue)") -F31 crates/sema-eval/src/eval.rs:6487: b"(module outer (export answer) (async/sleep 2) (import \"./inner.sema\" inner-value) (define answer (+ inner-value 2)))".to_vec(), -F31 crates/sema-eval/src/eval.rs:6504: "(module bytecode (export answer) (async/sleep 2) (define answer 42))", -F31 crates/sema-eval/src/eval.rs:6614: (channel/recv root-context-gate) -F31 crates/sema-eval/src/eval.rs:6665: "(channel/send root-context-gate :go)", -F31 crates/sema-eval/src/eval.rs:6704: (channel/send ready :ready) -F31 crates/sema-eval/src/eval.rs:6705: (channel/recv gate) -F31 crates/sema-eval/src/eval.rs:6710: (channel/recv ready) -F31 crates/sema-eval/src/eval.rs:6718: (channel/send gate :go) -F31 crates/sema-eval/src/eval.rs:67: /// `async/spawn` tasks, timers, promises and channels survive *between* -F31 crates/sema-eval/src/eval.rs:6824: (async/sleep 2) -F31 crates/sema-eval/src/eval.rs:6851: (channel/send ready :ready) -F31 crates/sema-eval/src/eval.rs:6852: (channel/recv go) -F31 crates/sema-eval/src/eval.rs:6854: (channel/recv ready) -F31 crates/sema-eval/src/eval.rs:6858: (channel/send go :go) -F31 crates/sema-eval/src/eval.rs:6859: (async/sleep 2) -F31 crates/sema-eval/src/eval.rs:6878: (async/sleep 2) -F31 crates/sema-eval/src/eval.rs:6897: (fn () (async/sleep 2) (context/clear) 42))"#, -F31 crates/sema-eval/src/eval.rs:6915: (fn () (async/sleep 2) (error "expected failure")))"#, -F31 crates/sema-eval/src/eval.rs:6936: (fn () (channel/recv (channel/new 1))))"#, -F31 crates/sema-eval/src/eval.rs:6974: "(context/with {:scoped :inner-a} (fn () (channel/recv context-gate) (context/get :scoped)))", -F31 crates/sema-eval/src/eval.rs:6980: "(context/with {:scoped :inner-b} (fn () (channel/recv context-gate) (context/get :scoped)))", -F31 crates/sema-eval/src/eval.rs:7002: .eval_str_via_runtime("(channel/send context-gate :go)") -F31 crates/sema-eval/src/eval.rs:7075: (channel/recv (channel/new 1)))"#, -F31 crates/sema-eval/src/eval.rs:7166: .eval_str_via_runtime("(async/spawn (fn () (async/sleep 100000) 1)) 7") -F31 crates/sema-eval/src/eval.rs:7185: let result = interp.eval_str_via_runtime("(await (async/spawn (fn () (error \"boom\"))))"); -F31 crates/sema-eval/src/eval.rs:7197: .eval_str_via_runtime("(let ((p (async/spawn (fn () 5)))) (async/sleep 5) (await p))") -F31 crates/sema-eval/src/eval.rs:7210: (define p (async/spawn (fn () 99))) \ -F31 crates/sema-eval/src/eval.rs:7211: (define a (async/spawn (fn () (await p)))) \ -F31 crates/sema-eval/src/eval.rs:7212: (define b (async/spawn (fn () (await p)))) \ -F31 crates/sema-eval/src/eval.rs:7224: .eval_str_via_runtime("(await (async/spawn (fn () (await (async/spawn (fn () 42))))))") -F31 crates/sema-eval/src/eval.rs:7235: .eval_str_via_runtime("(begin (async/spawn (fn () 1)) 99)") -F31 crates/sema-eval/src/eval.rs:7249: (set! p (async/spawn (fn () (async/sleep 1) (await p)))) \ -F31 crates/sema-eval/src/eval.rs:7283: match rx.recv_timeout(std::time::Duration::from_secs(30)) { -F31 crates/sema-eval/src/eval.rs:7309: // GATE — top-level `channel/recv` on an empty channel with no sender parks -F31 crates/sema-eval/src/eval.rs:7311: // it with the legacy "channel/recv: channel is empty". -F31 crates/sema-eval/src/eval.rs:7314: assert_runtime_deadlock_matches_oracle("(channel/recv (channel/new 1))"); -F31 crates/sema-eval/src/eval.rs:7317: // GATE — top-level `channel/send` on a full channel with no receiver parks -F31 crates/sema-eval/src/eval.rs:7318: // the root; the drive loop settles it with the legacy "channel/send: channel -F31 crates/sema-eval/src/eval.rs:7324: "(begin (define ch (channel/new 1)) (channel/send ch 1) (channel/send ch 2))", -F31 crates/sema-eval/src/eval.rs:7337: (set! pa (async/spawn (fn () (async/sleep 1) (await pb)))) \ -F31 crates/sema-eval/src/eval.rs:7338: (set! pb (async/spawn (fn () (async/sleep 1) (await pa)))) \ -F31 crates/sema-eval/src/eval.rs:7356: .eval_str_via_runtime("(async/spawn (fn () (async/sleep 5000) 1))") -F31 crates/sema-eval/src/eval.rs:7367: // awaited promise is still Pending at the moment `async/await` runs, the -F31 crates/sema-eval/src/eval.rs:7382: "(try (await (async/spawn (fn () (async/sleep 2) (error \"x\")))) \ -F31 crates/sema-eval/src/eval.rs:7395: .eval_str_via_runtime("(await (async/spawn (fn () (async/sleep 2) (error \"boom\"))))"); -F31 crates/sema-eval/src/eval.rs:7417: "(async/all (list (async/spawn (fn () 1)) \ -F31 crates/sema-eval/src/eval.rs:7418: (async/spawn (fn () 2)) \ -F31 crates/sema-eval/src/eval.rs:7419: (async/spawn (fn () 3))))", -F31 crates/sema-eval/src/eval.rs:7421: .expect("async/all resolves through the runtime"); -F31 crates/sema-eval/src/eval.rs:7429: .eval_str_via_runtime("(async/all (list))") -F31 crates/sema-eval/src/eval.rs:7430: .expect("async/all of empty input"); -F31 crates/sema-eval/src/eval.rs:7443: (define sib (async/spawn (fn () (async/sleep 4) (channel/send ch 77) 1))) \ -F31 crates/sema-eval/src/eval.rs:7444: (define bad (async/spawn (fn () (error \"boom\")))) \ -F31 crates/sema-eval/src/eval.rs:7445: (define outcome (try (async/all (list bad sib)) (catch e :caught))) \ -F31 crates/sema-eval/src/eval.rs:7446: (list outcome (await sib) (channel/recv ch)))", -F31 crates/sema-eval/src/eval.rs:7459: (define fast (async/spawn (fn () 10))) \ -F31 crates/sema-eval/src/eval.rs:7460: (define slow (async/spawn (fn () (async/sleep 5) (channel/send ch 88) 20))) \ -F31 crates/sema-eval/src/eval.rs:7461: (define winner (async/race (list fast slow))) \ -F31 crates/sema-eval/src/eval.rs:7462: (list winner (await slow) (channel/recv ch)))", -F31 crates/sema-eval/src/eval.rs:7472: .eval_str_via_runtime("(async/timeout 10000 (async/spawn (fn () (async/sleep 1) 5)))") -F31 crates/sema-eval/src/eval.rs:747: if !runtime.block_on_inbox(next_deadline) && next_deadline.is_none() { -F31 crates/sema-eval/src/eval.rs:7484: (define slow (async/spawn (fn () (async/sleep 20) (channel/send ch 55) 9))) \ -F31 crates/sema-eval/src/eval.rs:7485: (define outcome (try (async/timeout 1 slow) (catch e :timeout))) \ -F31 crates/sema-eval/src/eval.rs:7486: (list outcome (await slow) (channel/recv ch)))", -F31 crates/sema-eval/src/eval.rs:7494: // yield seam. Unlike the earlier async/all|race|timeout channel uses (which -F31 crates/sema-eval/src/eval.rs:7507: (async/spawn (fn () (channel/send ch 42))) \ -F31 crates/sema-eval/src/eval.rs:7508: (channel/recv ch))", -F31 crates/sema-eval/src/eval.rs:7523: (channel/send ch 1) (channel/send ch 2) (channel/send ch 3) \ -F31 crates/sema-eval/src/eval.rs:7524: (list (channel/recv ch) (channel/recv ch) (channel/recv ch)))", -F31 crates/sema-eval/src/eval.rs:7541: (define p (async/spawn (fn () \ -F31 crates/sema-eval/src/eval.rs:7542: (channel/send ch 1) (channel/send ch 2) (channel/send ch 3) :done))) \ -F31 crates/sema-eval/src/eval.rs:7543: (define out (list (channel/recv ch) (channel/recv ch) (channel/recv ch))) \ -F31 crates/sema-eval/src/eval.rs:7553: fn runtime_channel_blocking_recv_parks_until_sent() { -F31 crates/sema-eval/src/eval.rs:7559: (async/spawn (fn () (async/sleep 2) (channel/send ch 77))) \ -F31 crates/sema-eval/src/eval.rs:755: // The root is parked purely on a timer (`async/sleep`): the only -F31 crates/sema-eval/src/eval.rs:7560: (channel/recv ch))", -F31 crates/sema-eval/src/eval.rs:7573: (channel/send ch 1) \ -F31 crates/sema-eval/src/eval.rs:7575: (list (channel/recv ch) (channel/recv ch)))", -F31 crates/sema-eval/src/eval.rs:7588: (try (channel/send ch 9) (catch e :send-failed)))", -F08A crates/sema-eval/src/eval.rs:758: // than a raw `thread::sleep` — no external op is registered, so -F31 crates/sema-eval/src/eval.rs:7623: (channel/send ch 10) \ -F31 crates/sema-eval/src/eval.rs:7624: (channel/send ch 20) \ -F31 crates/sema-eval/src/eval.rs:7636: (channel/send ch 10) \ -F31 crates/sema-eval/src/eval.rs:7637: (channel/send ch 20) \ -F31 crates/sema-eval/src/eval.rs:7648: (channel/send ch 1) \ -F31 crates/sema-eval/src/eval.rs:7649: (channel/send ch 2) \ -F31 crates/sema-eval/src/eval.rs:7659: (channel/send ch 7) \ -F31 crates/sema-eval/src/eval.rs:7667: // GATE 1: `async/cancel` returns `#t` ONLY for the FIRST cancellation request -F31 crates/sema-eval/src/eval.rs:7675: "(let ((p (async/spawn (fn () (async/sleep 100000) 42)))) \ -F31 crates/sema-eval/src/eval.rs:7676: (list (async/cancel p) (async/cancel p)))", -F31 crates/sema-eval/src/eval.rs:7678: .expect("async/cancel of a sleeping spawned task drives through the runtime"); -F31 crates/sema-eval/src/eval.rs:7686: // GATE 1b: `async/cancel` returns `#f` for a synthetic promise (no backing -F31 crates/sema-eval/src/eval.rs:7692: .eval_str_via_runtime("(async/cancel (async/resolved 5))") -F31 crates/sema-eval/src/eval.rs:7705: "(let ((p (async/spawn (fn () (async/sleep 100000) 42)))) \ -F31 crates/sema-eval/src/eval.rs:7706: (async/cancel p) \ -F31 crates/sema-eval/src/eval.rs:7723: "(let ((p (async/spawn (fn () (async/sleep 100000) 42)))) \ -F31 crates/sema-eval/src/eval.rs:7724: (async/cancel p) \ -F31 crates/sema-eval/src/eval.rs:7735: // GATE 3: a task blocked on a LONG `async/sleep`, when cancelled, actually -F31 crates/sema-eval/src/eval.rs:7737: // NOT after the full (100s) sleep. The promise reports `async/cancelled?` -F31 crates/sema-eval/src/eval.rs:7745: "(let ((p (async/spawn (fn () (async/sleep 100000) 42)))) \ -F31 crates/sema-eval/src/eval.rs:7746: (async/cancel p) \ -F31 crates/sema-eval/src/eval.rs:7748: (async/cancelled? p))", -F31 crates/sema-eval/src/eval.rs:7765: // `channel/recv` is tracked ONLY in `channel_waits`, with a wait key that is -F31 crates/sema-eval/src/eval.rs:7774: // PROMPTLY; `async/cancelled?` is #t and `await` raises a catchable -F31 crates/sema-eval/src/eval.rs:7782: "(let ((p (async/spawn (fn () (channel/recv (channel/new 1)))))) \ -F31 crates/sema-eval/src/eval.rs:7783: (async/cancel p) \ -F31 crates/sema-eval/src/eval.rs:7784: (list (try (await p) (catch e (:type e))) (async/cancelled? p)))", -F31 crates/sema-eval/src/eval.rs:778: runtime.block_on_inbox(Some(deadline)); -F31 crates/sema-eval/src/eval.rs:7799: // GATE B: THE HANG PROOF. A detached task left parked on `channel/recv` when -F31 crates/sema-eval/src/eval.rs:7812: .eval_str_via_runtime("(async/spawn (fn () (channel/recv (channel/new 1)))) 42") -F31 crates/sema-eval/src/eval.rs:7832: "(async/spawn (fn () (let ((c (channel/new 1))) (channel/send c 1) (channel/send c 99)))) 7", -F31 crates/sema-eval/src/eval.rs:7843: // GATE D: owned fail-fast that cancels a worker parked on `channel/recv` -F31 crates/sema-eval/src/eval.rs:7854: (try (async/spawn-all \ -F31 crates/sema-eval/src/eval.rs:7856: (fn () (channel/recv ch)))) \ -F31 crates/sema-eval/src/eval.rs:785: // legacy-parity error (`channel/recv: channel is empty` / -F31 crates/sema-eval/src/eval.rs:786: // `channel/send: channel is full` for a top-level channel op, or -F31 crates/sema-eval/src/eval.rs:7874: // observational `async/all`/`race`/`timeout` gates above, where the supplied -F31 crates/sema-eval/src/eval.rs:7877: // async/spawn-all GATE 1 — happy path: values in INPUT order. -F31 crates/sema-eval/src/eval.rs:7882: .eval_str_via_runtime("(async/spawn-all (list (fn () 1) (fn () 2) (fn () 3)))") -F31 crates/sema-eval/src/eval.rs:7887: // async/spawn-all GATE 1b — empty input → empty list. -F31 crates/sema-eval/src/eval.rs:7892: .eval_str_via_runtime("(async/spawn-all (list))") -F31 crates/sema-eval/src/eval.rs:7897: // async/spawn-all GATE 2 — fail-fast OWNERSHIP: one child errors immediately; -F31 crates/sema-eval/src/eval.rs:7909: (try (async/spawn-all \ -F31 crates/sema-eval/src/eval.rs:7910: (list (fn () (async/sleep 60) (set! flag 77) 1) \ -F31 crates/sema-eval/src/eval.rs:7913: (async/sleep 200) \ -F31 crates/sema-eval/src/eval.rs:7945: (begin (async/sleep 60) (set! flag x) x))) \ -F31 crates/sema-eval/src/eval.rs:7948: (async/sleep 200) \ -F31 crates/sema-eval/src/eval.rs:7969: (async/sleep 15) \ -F31 crates/sema-eval/src/eval.rs:8015: (if (= x 1) (begin (async/sleep 5) (error \"boom\")) \ -F31 crates/sema-eval/src/eval.rs:8016: (begin (async/sleep 60) (set! flag x) x))) \ -F31 crates/sema-eval/src/eval.rs:8019: (async/sleep 200) \ -F31 crates/sema-eval/src/eval.rs:8026: // async/race-owned GATE 1 — first settlement wins AND the loser is CANCELLED -F31 crates/sema-eval/src/eval.rs:8037: (async/race-owned \ -F31 crates/sema-eval/src/eval.rs:8039: (fn () (async/sleep 60) (set! flag 99) 20)))) \ -F31 crates/sema-eval/src/eval.rs:8040: (async/sleep 200) \ -F31 crates/sema-eval/src/eval.rs:8051: // async/race-owned GATE 2 — empty input is an argument error. -F31 crates/sema-eval/src/eval.rs:8057: .eval_str_via_runtime("(try (async/race-owned (list)) (catch e :empty))",) -F31 crates/sema-eval/src/eval.rs:8063: // async/race-owned GATE 3 — the first settlement being an error re-raises it. -F31 crates/sema-eval/src/eval.rs:8069: "(try (async/race-owned (list (fn () (error \"boom\")) \ -F31 crates/sema-eval/src/eval.rs:8070: (fn () (async/sleep 100) 2))) \ -F31 crates/sema-eval/src/eval.rs:8088: (fn () (async/sleep 200) (set! flag 5) :done)) \ -F31 crates/sema-eval/src/eval.rs:8090: (async/sleep 300) \ -F31 crates/sema-eval/src/eval.rs:8106: .eval_str_via_runtime("(async/with-timeout 10000 (fn () (async/sleep 1) 42))") -F31 crates/sema-eval/src/eval.rs:8127: // at bytecode level via `__spawn-apply` rather than `(map async/spawn …)`. -F31 crates/sema-eval/src/eval.rs:8129: // `(map async/spawn …)` shape would raise "async yield outside of scheduler -F31 crates/sema-eval/src/eval.rs:8184: "(map (fn (x) (async/await (async/spawn (fn () (* x x))))) (list 1 2 3))", -F31 crates/sema-eval/src/eval.rs:8193: // The embedding-style shape: each `async` desugars to `(async/spawn (fn () -F31 crates/sema-eval/src/eval.rs:8194: // …))`, so `map` produces a list of promises which `async/all` then awaits. -F31 crates/sema-eval/src/eval.rs:8195: // The callback's `async/spawn` yield must be serviced cooperatively. -F31 crates/sema-eval/src/eval.rs:8200: .eval_str_via_runtime("(async/all (map (fn (x) (async (* x x))) (list 1 2 3)))") -F31 crates/sema-eval/src/eval.rs:8201: .expect("async/all over a mapped list of spawns resolves"); -F31 crates/sema-eval/src/eval.rs:8220: "(filter (fn (x) (async/await (async/spawn (fn () (> x 1))))) (list 1 2 3))", -F31 crates/sema-eval/src/eval.rs:8236: "(foldl (fn (acc x) (async/await (async/spawn (fn () (+ acc x))))) 0 \ -F31 crates/sema-eval/src/eval.rs:8253: "(foldl (fn (acc x) (async/await (async/spawn (fn () (+ acc x))))) 99 (list))", -F31 crates/sema-eval/src/eval.rs:8264: "(reduce (fn (acc x) (async/await (async/spawn (fn () (+ acc x))))) \ -F31 crates/sema-eval/src/eval.rs:8281: "(reduce (fn (acc x) (async/await (async/spawn (fn () (+ acc x))))) (list 42))", -F31 crates/sema-eval/src/eval.rs:8293: "(sort-by (fn (x) (async/await (async/spawn (fn () (- x))))) (list 3 1 2))", -F31 crates/sema-eval/src/eval.rs:8315: (for-each (fn (x) (async/await (async/spawn (fn () (channel/send ch (* x 10)))))) \ -F31 crates/sema-eval/src/eval.rs:8318: (list (channel/recv ch) (channel/recv ch) (channel/recv ch))", -F31 crates/sema-eval/src/eval.rs:8346: // still-live `Tracked` cell, mirroring `async/spawn`) every escaping open -F31 crates/sema-eval/src/eval.rs:8521: .eval_str_via_runtime("(async/spawn (fn () (sleep 100000) 1)) 7") -F31 crates/sema-eval/src/eval.rs:8556: // observable synchronously via `async/cancelled?`. -F31 crates/sema-eval/src/eval.rs:8563: (let ((p (async (channel/recv ch)))) \ -F31 crates/sema-eval/src/eval.rs:8564: (async/cancel p) \ -F31 crates/sema-eval/src/eval.rs:8565: (async/cancelled? p)))", -F31 crates/sema-eval/src/eval.rs:8577: "(let ((p (async (async/sleep 100)))) \ -F31 crates/sema-eval/src/eval.rs:8578: (async/cancel p) \ -F31 crates/sema-eval/src/eval.rs:8579: (list (async/cancelled? p) (async/rejected? p) \ -F31 crates/sema-eval/src/eval.rs:8594: // A yielding native (`channel/recv`) passed DIRECTLY as a HOF callback now -F31 crates/sema-eval/src/eval.rs:8596: // continuation ABI (the tool-loop/HOF migration): `(map channel/recv …)` -F31 crates/sema-eval/src/eval.rs:8604: (let ((producer (async (channel/send ch 1) (channel/close ch))) \ -F31 crates/sema-eval/src/eval.rs:8605: (consumer (async (map channel/recv (list ch))))) \ -F31 crates/sema-eval/src/eval.rs:8612: // `async/run` inside an async task suspends cooperatively and preserves the -F31 crates/sema-eval/src/eval.rs:8620: (await (async (async/run) (channel/send ch 42) (channel/recv ch))))", -F31 crates/sema-eval/src/eval.rs:8628: // A 0 ms `async/timeout` must still let synchronously-ready work finish: the -F31 crates/sema-eval/src/eval.rs:8635: .eval_str_via_runtime("(async/timeout 0 (async 42))") -F31 crates/sema-eval/src/eval.rs:8640: // `retry` backoff in a runtime quantum yields cooperatively (via `async/sleep`) -F31 crates/sema-eval/src/eval.rs:8649: (async/all \ -F31 crates/sema-eval/src/eval.rs:8650: (list (async/spawn (fn () \ -F31 crates/sema-eval/src/eval.rs:8654: (channel/send out :slow))) \ -F31 crates/sema-eval/src/eval.rs:8655: (async/spawn (fn () (async/sleep 10) (channel/send out :fast))))) \ -F31 crates/sema-eval/src/eval.rs:8656: (list (channel/recv out) (channel/recv out)))", -F31 crates/sema-eval/src/eval.rs:8674: (begin (async (channel/send ch :ran)) :end)", -F31 crates/sema-eval/src/eval.rs:8680: .eval_str_via_runtime("(channel/recv ch)") -F34A crates/sema-eval/src/prelude.rs:1016:;; connection, spawned via `async/spawn`'s runtime ABI, which requires a -F34A crates/sema-eval/src/prelude.rs:1020:;; being `async/spawn`'s trivial promise-handle mapping — -F34A crates/sema-eval/src/prelude.rs:1047: (let ((factory (fn (h req responder) (async/spawn (fn () (responder (h req))))))) +F31 crates/sema-eval/src/eval.rs:154: // `Rc` and `Value` edges (a still-parked/detached `async/spawn` +F32 crates/sema-eval/src/eval.rs:224: sema_core::set_eval_callback(&ctx, eval_value_vm); +F32 crates/sema-eval/src/eval.rs:225: sema_core::set_call_callback(&ctx, call_value); +F32 crates/sema-eval/src/eval.rs:226: sema_core::set_call_owned_callback(&ctx, call_value_owned); +F32 crates/sema-eval/src/eval.rs:245: sema_core::set_eval_callback(&ctx, eval_value_vm); +F32 crates/sema-eval/src/eval.rs:246: sema_core::set_call_callback(&ctx, call_value); +F32 crates/sema-eval/src/eval.rs:247: sema_core::set_call_owned_callback(&ctx, call_value_owned); +F32 crates/sema-eval/src/eval.rs:3475: sema_core::call_callback(context, &thunk.body, &[])? +F31 crates/sema-eval/src/eval.rs:4551: .eval_str("(defmacro sleeping-transformer () (async/sleep 1) '42)") +F31 crates/sema-eval/src/eval.rs:4595: b"(defmacro loaded-sleeper () (async/sleep 1) '42)\ +F31 crates/sema-eval/src/eval.rs:4667: .eval_str("(defmacro late-force-macro () (async/sleep 1) '42)") +F31 crates/sema-eval/src/eval.rs:4686: .eval_str("(defmacro macroexpand-sleeper () (async/sleep 1) '42)") +F31 crates/sema-eval/src/eval.rs:4709: "(defmacro spawn-transformer () (async/spawn (fn () 42)))", +F31 crates/sema-eval/src/eval.rs:5074: (async/spawn (fn () (async/sleep 1) (channel/send ch 42))) \ +F31 crates/sema-eval/src/eval.rs:5075: (force (delay (channel/recv ch))))", +F31 crates/sema-eval/src/eval.rs:5091: (async/sleep 1) \ +F31 crates/sema-eval/src/eval.rs:5110: (async/sleep 10) \ +F31 crates/sema-eval/src/eval.rs:5114: (async/await \ +F31 crates/sema-eval/src/eval.rs:5115: (async/all (list (async (force p)) (async (force p))))) \ +F31 crates/sema-eval/src/eval.rs:5136: (async/sleep 20) +F31 crates/sema-eval/src/eval.rs:5158: std::thread::sleep(std::time::Duration::from_millis(25)); +F31 crates/sema-eval/src/eval.rs:5178: (async/sleep 1) \ +F31 crates/sema-eval/src/eval.rs:5196: (define p (delay (begin (async/sleep 1) (mutable-array/new)))) \ +F31 crates/sema-eval/src/eval.rs:5213: (define force-promise (delay (channel/recv force-gate))))", +F31 crates/sema-eval/src/eval.rs:5249: (channel/send entered :entered) \ +F31 crates/sema-eval/src/eval.rs:5250: (channel/recv body-gate) \ +F31 crates/sema-eval/src/eval.rs:5254: (channel/recv entered) \ +F31 crates/sema-eval/src/eval.rs:5256: (async/sleep 1) \ +F31 crates/sema-eval/src/eval.rs:5257: (async/cancel first) \ +F31 crates/sema-eval/src/eval.rs:5258: (channel/send body-gate :continue) \ +F31 crates/sema-eval/src/eval.rs:5281: (channel/send entered :q) +F31 crates/sema-eval/src/eval.rs:5282: (channel/recv hold) +F31 crates/sema-eval/src/eval.rs:5285: (channel/recv entered) +F31 crates/sema-eval/src/eval.rs:5288: (async/sleep 5) +F31 crates/sema-eval/src/eval.rs:5289: (async/cancel p-owner) +F31 crates/sema-eval/src/eval.rs:5290: (channel/send hold :go) +F31 crates/sema-eval/src/eval.rs:5346: (delay (channel/recv force-deadlock-gate))))", +F31 crates/sema-eval/src/eval.rs:5358: (async (channel/send force-deadlock-gate 9)) \ +F31 crates/sema-eval/src/eval.rs:5587: // `async/sleep` returns a structural timer suspension. The runtime parks its +F31 crates/sema-eval/src/eval.rs:5595: .eval_str_via_runtime("(async/sleep 2)") +F31 crates/sema-eval/src/eval.rs:5596: .expect("async/sleep settles through the runtime"); +F31 crates/sema-eval/src/eval.rs:5606: .eval_str_via_runtime("(begin (async/sleep 2) (+ 40 2))") +F31 crates/sema-eval/src/eval.rs:5607: .expect("program continues past async/sleep"); +F31 crates/sema-eval/src/eval.rs:5611: // `async/spawn` + `async/await` round-trip through the runtime: spawn a +F31 crates/sema-eval/src/eval.rs:5619: .eval_str_via_runtime("(await (async/spawn (fn () (+ 40 2))))") +F31 crates/sema-eval/src/eval.rs:5633: (define a (async/spawn (fn () (+ 1 2)))) \ +F31 crates/sema-eval/src/eval.rs:5634: (define b (async/spawn (fn () (* 4 5)))) \ +F31 crates/sema-eval/src/eval.rs:5641: // A spawned task that itself parks on a timer (`async/sleep`) and resumes: +F31 crates/sema-eval/src/eval.rs:5648: .eval_str_via_runtime("(await (async/spawn (fn () (async/sleep 2) 7)))") +F31 crates/sema-eval/src/eval.rs:5661: // detached task (parked on its `async/sleep` timer at the end of call one) +F31 crates/sema-eval/src/eval.rs:5670: .eval_str_via_runtime("(define p (async/spawn (fn () (async/sleep 2) 42)))") +F31 crates/sema-eval/src/eval.rs:5727: r#"(await (async/spawn (fn () (load "./dep.sema"))))"#, +F31 crates/sema-eval/src/eval.rs:5743: b"(channel/recv runtime-load-gate) (define runtime-loaded 42) runtime-loaded".to_vec(), +F31 crates/sema-eval/src/eval.rs:5759: .eval_str_via_runtime("(channel/send runtime-load-gate :continue)") +F31 crates/sema-eval/src/eval.rs:5778: b"(module blocking (export answer) (set! runtime-import-count (+ runtime-import-count 1)) (channel/recv runtime-import-gate) (define answer 42))".to_vec(), +F31 crates/sema-eval/src/eval.rs:5814: .eval_str_via_runtime("(channel/send runtime-import-gate :continue)") +F31 crates/sema-eval/src/eval.rs:5842: b"(module sync-runtime-overlap (export overlap-answer) (set! overlap-count (+ overlap-count 1)) (channel/recv overlap-gate) (define overlap-answer 42))".to_vec(), +F31 crates/sema-eval/src/eval.rs:5881: .eval_str_via_runtime("(channel/send overlap-gate :continue)") +F31 crates/sema-eval/src/eval.rs:5902: b"(module foreign-runtime-import (export foreign-answer) (set! foreign-import-count (+ foreign-import-count 1)) (channel/recv foreign-import-gate) (define foreign-answer 42))".to_vec(), +F31 crates/sema-eval/src/eval.rs:5937: .eval_str_via_runtime("(channel/send foreign-import-gate :continue)") +F31 crates/sema-eval/src/eval.rs:6022: b"(channel/recv gate-cancel-channel)".to_vec(), +F31 crates/sema-eval/src/eval.rs:6058: b"(module single-flight-source (export source-answer) (set! source-import-count (+ source-import-count 1)) (channel/recv source-import-gate) (define source-answer 42))".to_vec(), +F31 crates/sema-eval/src/eval.rs:6094: .eval_str_via_runtime("(channel/send source-import-gate :continue)") +F31 crates/sema-eval/src/eval.rs:6122: "(module single-flight-bytecode (export bytecode-answer) (set! bytecode-import-count (+ bytecode-import-count 1)) (channel/recv bytecode-import-gate) (define bytecode-answer 42))", +F31 crates/sema-eval/src/eval.rs:6159: .eval_str_via_runtime("(channel/send bytecode-import-gate :continue)") +F31 crates/sema-eval/src/eval.rs:6182: b"(module cancelled-owner-import (export cancelled-owner-answer) (set! cancelled-owner-count (+ cancelled-owner-count 1)) (if (= cancelled-owner-count 1) (channel/recv cancelled-owner-gate) nil) (define cancelled-owner-answer 42))".to_vec(), +F31 crates/sema-eval/src/eval.rs:6233: b"(module failed-owner-import (export failed-owner-answer) (set! failed-owner-count (+ failed-owner-count 1)) (if (= failed-owner-count 1) (begin (channel/recv failed-owner-gate) (error \"expected first-owner failure\")) nil) (define failed-owner-answer 42))".to_vec(), +F31 crates/sema-eval/src/eval.rs:6263: .eval_str_via_runtime("(channel/send failed-owner-gate :continue)") +F31 crates/sema-eval/src/eval.rs:6286: b"(channel/recv cancelled-load-gate) :loaded".to_vec(), +F31 crates/sema-eval/src/eval.rs:6307: .eval_str_via_runtime("(channel/send cancelled-load-gate :retry)") +F31 crates/sema-eval/src/eval.rs:6325: b"(module cancelled-import (export cancelled-import-answer) (channel/recv cancelled-import-gate) (define cancelled-import-answer 42))".to_vec(), +F31 crates/sema-eval/src/eval.rs:6350: .eval_str_via_runtime("(channel/send cancelled-import-gate :retry)") +F31 crates/sema-eval/src/eval.rs:6399: b"(channel/recv compile-failure-import-gate) (if #t)".to_vec(), +F31 crates/sema-eval/src/eval.rs:6416: .eval_str_via_runtime("(channel/send compile-failure-import-gate :continue)") +F31 crates/sema-eval/src/eval.rs:6443: b"(channel/recv callback-failure-import-gate) (error \"expected module callback failure\")".to_vec(), +F31 crates/sema-eval/src/eval.rs:6460: .eval_str_via_runtime("(channel/send callback-failure-import-gate :continue)") +F31 crates/sema-eval/src/eval.rs:64: /// context would route the VM's `call_callback` through unregistered +F31 crates/sema-eval/src/eval.rs:6518: b"(module outer (export answer) (async/sleep 2) (import \"./inner.sema\" inner-value) (define answer (+ inner-value 2)))".to_vec(), +F31 crates/sema-eval/src/eval.rs:6535: "(module bytecode (export answer) (async/sleep 2) (define answer 42))", +F31 crates/sema-eval/src/eval.rs:6645: (channel/recv root-context-gate) +F31 crates/sema-eval/src/eval.rs:6696: "(channel/send root-context-gate :go)", +F31 crates/sema-eval/src/eval.rs:6735: (channel/send ready :ready) +F31 crates/sema-eval/src/eval.rs:6736: (channel/recv gate) +F31 crates/sema-eval/src/eval.rs:6741: (channel/recv ready) +F31 crates/sema-eval/src/eval.rs:6749: (channel/send gate :go) +F31 crates/sema-eval/src/eval.rs:6855: (async/sleep 2) +F31 crates/sema-eval/src/eval.rs:6882: (channel/send ready :ready) +F31 crates/sema-eval/src/eval.rs:6883: (channel/recv go) +F31 crates/sema-eval/src/eval.rs:6885: (channel/recv ready) +F31 crates/sema-eval/src/eval.rs:6889: (channel/send go :go) +F31 crates/sema-eval/src/eval.rs:6890: (async/sleep 2) +F31 crates/sema-eval/src/eval.rs:6909: (async/sleep 2) +F31 crates/sema-eval/src/eval.rs:6928: (fn () (async/sleep 2) (context/clear) 42))"#, +F31 crates/sema-eval/src/eval.rs:6946: (fn () (async/sleep 2) (error "expected failure")))"#, +F31 crates/sema-eval/src/eval.rs:6967: (fn () (channel/recv (channel/new 1))))"#, +F31 crates/sema-eval/src/eval.rs:7005: "(context/with {:scoped :inner-a} (fn () (channel/recv context-gate) (context/get :scoped)))", +F31 crates/sema-eval/src/eval.rs:7011: "(context/with {:scoped :inner-b} (fn () (channel/recv context-gate) (context/get :scoped)))", +F31 crates/sema-eval/src/eval.rs:7033: .eval_str_via_runtime("(channel/send context-gate :go)") +F31 crates/sema-eval/src/eval.rs:7106: (channel/recv (channel/new 1)))"#, +F31 crates/sema-eval/src/eval.rs:7197: .eval_str_via_runtime("(async/spawn (fn () (async/sleep 100000) 1)) 7") +F31 crates/sema-eval/src/eval.rs:71: /// `async/spawn` tasks, timers, promises and channels survive *between* +F31 crates/sema-eval/src/eval.rs:7216: let result = interp.eval_str_via_runtime("(await (async/spawn (fn () (error \"boom\"))))"); +F31 crates/sema-eval/src/eval.rs:7228: .eval_str_via_runtime("(let ((p (async/spawn (fn () 5)))) (async/sleep 5) (await p))") +F31 crates/sema-eval/src/eval.rs:7241: (define p (async/spawn (fn () 99))) \ +F31 crates/sema-eval/src/eval.rs:7242: (define a (async/spawn (fn () (await p)))) \ +F31 crates/sema-eval/src/eval.rs:7243: (define b (async/spawn (fn () (await p)))) \ +F31 crates/sema-eval/src/eval.rs:7255: .eval_str_via_runtime("(await (async/spawn (fn () (await (async/spawn (fn () 42))))))") +F31 crates/sema-eval/src/eval.rs:7266: .eval_str_via_runtime("(begin (async/spawn (fn () 1)) 99)") +F31 crates/sema-eval/src/eval.rs:7280: (set! p (async/spawn (fn () (async/sleep 1) (await p)))) \ +F31 crates/sema-eval/src/eval.rs:7314: match rx.recv_timeout(std::time::Duration::from_secs(30)) { +F31 crates/sema-eval/src/eval.rs:7340: // GATE — top-level `channel/recv` on an empty channel with no sender parks +F31 crates/sema-eval/src/eval.rs:7342: // it with the legacy "channel/recv: channel is empty". +F31 crates/sema-eval/src/eval.rs:7345: assert_runtime_deadlock_matches_oracle("(channel/recv (channel/new 1))"); +F31 crates/sema-eval/src/eval.rs:7348: // GATE — top-level `channel/send` on a full channel with no receiver parks +F31 crates/sema-eval/src/eval.rs:7349: // the root; the drive loop settles it with the legacy "channel/send: channel +F31 crates/sema-eval/src/eval.rs:7355: "(begin (define ch (channel/new 1)) (channel/send ch 1) (channel/send ch 2))", +F31 crates/sema-eval/src/eval.rs:7368: (set! pa (async/spawn (fn () (async/sleep 1) (await pb)))) \ +F31 crates/sema-eval/src/eval.rs:7369: (set! pb (async/spawn (fn () (async/sleep 1) (await pa)))) \ +F31 crates/sema-eval/src/eval.rs:7387: .eval_str_via_runtime("(async/spawn (fn () (async/sleep 5000) 1))") +F31 crates/sema-eval/src/eval.rs:7398: // awaited promise is still Pending at the moment `async/await` runs, the +F31 crates/sema-eval/src/eval.rs:7413: "(try (await (async/spawn (fn () (async/sleep 2) (error \"x\")))) \ +F31 crates/sema-eval/src/eval.rs:7426: .eval_str_via_runtime("(await (async/spawn (fn () (async/sleep 2) (error \"boom\"))))"); +F31 crates/sema-eval/src/eval.rs:7448: "(async/all (list (async/spawn (fn () 1)) \ +F31 crates/sema-eval/src/eval.rs:7449: (async/spawn (fn () 2)) \ +F31 crates/sema-eval/src/eval.rs:7450: (async/spawn (fn () 3))))", +F31 crates/sema-eval/src/eval.rs:7452: .expect("async/all resolves through the runtime"); +F31 crates/sema-eval/src/eval.rs:7460: .eval_str_via_runtime("(async/all (list))") +F31 crates/sema-eval/src/eval.rs:7461: .expect("async/all of empty input"); +F31 crates/sema-eval/src/eval.rs:7474: (define sib (async/spawn (fn () (async/sleep 4) (channel/send ch 77) 1))) \ +F31 crates/sema-eval/src/eval.rs:7475: (define bad (async/spawn (fn () (error \"boom\")))) \ +F31 crates/sema-eval/src/eval.rs:7476: (define outcome (try (async/all (list bad sib)) (catch e :caught))) \ +F31 crates/sema-eval/src/eval.rs:7477: (list outcome (await sib) (channel/recv ch)))", +F31 crates/sema-eval/src/eval.rs:7490: (define fast (async/spawn (fn () 10))) \ +F31 crates/sema-eval/src/eval.rs:7491: (define slow (async/spawn (fn () (async/sleep 5) (channel/send ch 88) 20))) \ +F31 crates/sema-eval/src/eval.rs:7492: (define winner (async/race (list fast slow))) \ +F31 crates/sema-eval/src/eval.rs:7493: (list winner (await slow) (channel/recv ch)))", +F31 crates/sema-eval/src/eval.rs:7503: .eval_str_via_runtime("(async/timeout 10000 (async/spawn (fn () (async/sleep 1) 5)))") +F31 crates/sema-eval/src/eval.rs:7515: (define slow (async/spawn (fn () (async/sleep 20) (channel/send ch 55) 9))) \ +F31 crates/sema-eval/src/eval.rs:7516: (define outcome (try (async/timeout 1 slow) (catch e :timeout))) \ +F31 crates/sema-eval/src/eval.rs:7517: (list outcome (await slow) (channel/recv ch)))", +F31 crates/sema-eval/src/eval.rs:7525: // yield seam. Unlike the earlier async/all|race|timeout channel uses (which +F31 crates/sema-eval/src/eval.rs:7538: (async/spawn (fn () (channel/send ch 42))) \ +F31 crates/sema-eval/src/eval.rs:7539: (channel/recv ch))", +F31 crates/sema-eval/src/eval.rs:7554: (channel/send ch 1) (channel/send ch 2) (channel/send ch 3) \ +F31 crates/sema-eval/src/eval.rs:7555: (list (channel/recv ch) (channel/recv ch) (channel/recv ch)))", +F31 crates/sema-eval/src/eval.rs:7572: (define p (async/spawn (fn () \ +F31 crates/sema-eval/src/eval.rs:7573: (channel/send ch 1) (channel/send ch 2) (channel/send ch 3) :done))) \ +F31 crates/sema-eval/src/eval.rs:7574: (define out (list (channel/recv ch) (channel/recv ch) (channel/recv ch))) \ +F31 crates/sema-eval/src/eval.rs:7584: fn runtime_channel_blocking_recv_parks_until_sent() { +F31 crates/sema-eval/src/eval.rs:7590: (async/spawn (fn () (async/sleep 2) (channel/send ch 77))) \ +F31 crates/sema-eval/src/eval.rs:7591: (channel/recv ch))", +F31 crates/sema-eval/src/eval.rs:7604: (channel/send ch 1) \ +F31 crates/sema-eval/src/eval.rs:7606: (list (channel/recv ch) (channel/recv ch)))", +F31 crates/sema-eval/src/eval.rs:7619: (try (channel/send ch 9) (catch e :send-failed)))", +F31 crates/sema-eval/src/eval.rs:764: if !runtime.block_on_inbox(next_deadline) && next_deadline.is_none() { +F31 crates/sema-eval/src/eval.rs:7654: (channel/send ch 10) \ +F31 crates/sema-eval/src/eval.rs:7655: (channel/send ch 20) \ +F31 crates/sema-eval/src/eval.rs:7667: (channel/send ch 10) \ +F31 crates/sema-eval/src/eval.rs:7668: (channel/send ch 20) \ +F31 crates/sema-eval/src/eval.rs:7679: (channel/send ch 1) \ +F31 crates/sema-eval/src/eval.rs:7680: (channel/send ch 2) \ +F31 crates/sema-eval/src/eval.rs:7690: (channel/send ch 7) \ +F31 crates/sema-eval/src/eval.rs:7698: // GATE 1: `async/cancel` returns `#t` ONLY for the FIRST cancellation request +F31 crates/sema-eval/src/eval.rs:7706: "(let ((p (async/spawn (fn () (async/sleep 100000) 42)))) \ +F31 crates/sema-eval/src/eval.rs:7707: (list (async/cancel p) (async/cancel p)))", +F31 crates/sema-eval/src/eval.rs:7709: .expect("async/cancel of a sleeping spawned task drives through the runtime"); +F31 crates/sema-eval/src/eval.rs:7717: // GATE 1b: `async/cancel` returns `#f` for a synthetic promise (no backing +F31 crates/sema-eval/src/eval.rs:7723: .eval_str_via_runtime("(async/cancel (async/resolved 5))") +F31 crates/sema-eval/src/eval.rs:7736: "(let ((p (async/spawn (fn () (async/sleep 100000) 42)))) \ +F31 crates/sema-eval/src/eval.rs:7737: (async/cancel p) \ +F31 crates/sema-eval/src/eval.rs:773: // The root is parked purely on a timer (`async/sleep`): the only +F31 crates/sema-eval/src/eval.rs:7754: "(let ((p (async/spawn (fn () (async/sleep 100000) 42)))) \ +F31 crates/sema-eval/src/eval.rs:7755: (async/cancel p) \ +F31 crates/sema-eval/src/eval.rs:7766: // GATE 3: a task blocked on a LONG `async/sleep`, when cancelled, actually +F31 crates/sema-eval/src/eval.rs:7768: // NOT after the full (100s) sleep. The promise reports `async/cancelled?` +F08A crates/sema-eval/src/eval.rs:776: // than a raw `thread::sleep` — no external op is registered, so +F31 crates/sema-eval/src/eval.rs:7776: "(let ((p (async/spawn (fn () (async/sleep 100000) 42)))) \ +F31 crates/sema-eval/src/eval.rs:7777: (async/cancel p) \ +F31 crates/sema-eval/src/eval.rs:7779: (async/cancelled? p))", +F31 crates/sema-eval/src/eval.rs:7796: // `channel/recv` is tracked ONLY in `channel_waits`, with a wait key that is +F31 crates/sema-eval/src/eval.rs:7805: // PROMPTLY; `async/cancelled?` is #t and `await` raises a catchable +F31 crates/sema-eval/src/eval.rs:7813: "(let ((p (async/spawn (fn () (channel/recv (channel/new 1)))))) \ +F31 crates/sema-eval/src/eval.rs:7814: (async/cancel p) \ +F31 crates/sema-eval/src/eval.rs:7815: (list (try (await p) (catch e (:type e))) (async/cancelled? p)))", +F31 crates/sema-eval/src/eval.rs:7830: // GATE B: THE HANG PROOF. A detached task left parked on `channel/recv` when +F31 crates/sema-eval/src/eval.rs:7843: .eval_str_via_runtime("(async/spawn (fn () (channel/recv (channel/new 1)))) 42") +F31 crates/sema-eval/src/eval.rs:7863: "(async/spawn (fn () (let ((c (channel/new 1))) (channel/send c 1) (channel/send c 99)))) 7", +F31 crates/sema-eval/src/eval.rs:7874: // GATE D: owned fail-fast that cancels a worker parked on `channel/recv` +F31 crates/sema-eval/src/eval.rs:7885: (try (async/spawn-all \ +F31 crates/sema-eval/src/eval.rs:7887: (fn () (channel/recv ch)))) \ +F31 crates/sema-eval/src/eval.rs:7905: // observational `async/all`/`race`/`timeout` gates above, where the supplied +F31 crates/sema-eval/src/eval.rs:7908: // async/spawn-all GATE 1 — happy path: values in INPUT order. +F31 crates/sema-eval/src/eval.rs:7913: .eval_str_via_runtime("(async/spawn-all (list (fn () 1) (fn () 2) (fn () 3)))") +F31 crates/sema-eval/src/eval.rs:7918: // async/spawn-all GATE 1b — empty input → empty list. +F31 crates/sema-eval/src/eval.rs:7923: .eval_str_via_runtime("(async/spawn-all (list))") +F31 crates/sema-eval/src/eval.rs:7928: // async/spawn-all GATE 2 — fail-fast OWNERSHIP: one child errors immediately; +F31 crates/sema-eval/src/eval.rs:7940: (try (async/spawn-all \ +F31 crates/sema-eval/src/eval.rs:7941: (list (fn () (async/sleep 60) (set! flag 77) 1) \ +F31 crates/sema-eval/src/eval.rs:7944: (async/sleep 200) \ +F31 crates/sema-eval/src/eval.rs:796: runtime.block_on_inbox(Some(deadline)); +F31 crates/sema-eval/src/eval.rs:7976: (begin (async/sleep 60) (set! flag x) x))) \ +F31 crates/sema-eval/src/eval.rs:7979: (async/sleep 200) \ +F31 crates/sema-eval/src/eval.rs:8000: (async/sleep 15) \ +F31 crates/sema-eval/src/eval.rs:803: // legacy-parity error (`channel/recv: channel is empty` / +F31 crates/sema-eval/src/eval.rs:8046: (if (= x 1) (begin (async/sleep 5) (error \"boom\")) \ +F31 crates/sema-eval/src/eval.rs:8047: (begin (async/sleep 60) (set! flag x) x))) \ +F31 crates/sema-eval/src/eval.rs:804: // `channel/send: channel is full` for a top-level channel op, or +F31 crates/sema-eval/src/eval.rs:8050: (async/sleep 200) \ +F31 crates/sema-eval/src/eval.rs:8057: // async/race-owned GATE 1 — first settlement wins AND the loser is CANCELLED +F31 crates/sema-eval/src/eval.rs:8068: (async/race-owned \ +F31 crates/sema-eval/src/eval.rs:8070: (fn () (async/sleep 60) (set! flag 99) 20)))) \ +F31 crates/sema-eval/src/eval.rs:8071: (async/sleep 200) \ +F31 crates/sema-eval/src/eval.rs:8082: // async/race-owned GATE 2 — empty input is an argument error. +F31 crates/sema-eval/src/eval.rs:8088: .eval_str_via_runtime("(try (async/race-owned (list)) (catch e :empty))",) +F31 crates/sema-eval/src/eval.rs:8094: // async/race-owned GATE 3 — the first settlement being an error re-raises it. +F31 crates/sema-eval/src/eval.rs:8100: "(try (async/race-owned (list (fn () (error \"boom\")) \ +F31 crates/sema-eval/src/eval.rs:8101: (fn () (async/sleep 100) 2))) \ +F31 crates/sema-eval/src/eval.rs:8119: (fn () (async/sleep 200) (set! flag 5) :done)) \ +F31 crates/sema-eval/src/eval.rs:8121: (async/sleep 300) \ +F31 crates/sema-eval/src/eval.rs:8137: .eval_str_via_runtime("(async/with-timeout 10000 (fn () (async/sleep 1) 42))") +F31 crates/sema-eval/src/eval.rs:8158: // at bytecode level via `__spawn-apply` rather than `(map async/spawn …)`. +F31 crates/sema-eval/src/eval.rs:8160: // `(map async/spawn …)` shape would raise "async yield outside of scheduler +F31 crates/sema-eval/src/eval.rs:8215: "(map (fn (x) (async/await (async/spawn (fn () (* x x))))) (list 1 2 3))", +F31 crates/sema-eval/src/eval.rs:8224: // The embedding-style shape: each `async` desugars to `(async/spawn (fn () +F31 crates/sema-eval/src/eval.rs:8225: // …))`, so `map` produces a list of promises which `async/all` then awaits. +F31 crates/sema-eval/src/eval.rs:8226: // The callback's `async/spawn` yield must be serviced cooperatively. +F31 crates/sema-eval/src/eval.rs:8231: .eval_str_via_runtime("(async/all (map (fn (x) (async (* x x))) (list 1 2 3)))") +F31 crates/sema-eval/src/eval.rs:8232: .expect("async/all over a mapped list of spawns resolves"); +F31 crates/sema-eval/src/eval.rs:8251: "(filter (fn (x) (async/await (async/spawn (fn () (> x 1))))) (list 1 2 3))", +F31 crates/sema-eval/src/eval.rs:8267: "(foldl (fn (acc x) (async/await (async/spawn (fn () (+ acc x))))) 0 \ +F31 crates/sema-eval/src/eval.rs:8284: "(foldl (fn (acc x) (async/await (async/spawn (fn () (+ acc x))))) 99 (list))", +F31 crates/sema-eval/src/eval.rs:8295: "(reduce (fn (acc x) (async/await (async/spawn (fn () (+ acc x))))) \ +F31 crates/sema-eval/src/eval.rs:8312: "(reduce (fn (acc x) (async/await (async/spawn (fn () (+ acc x))))) (list 42))", +F31 crates/sema-eval/src/eval.rs:8324: "(sort-by (fn (x) (async/await (async/spawn (fn () (- x))))) (list 3 1 2))", +F31 crates/sema-eval/src/eval.rs:8346: (for-each (fn (x) (async/await (async/spawn (fn () (channel/send ch (* x 10)))))) \ +F31 crates/sema-eval/src/eval.rs:8349: (list (channel/recv ch) (channel/recv ch) (channel/recv ch))", +F31 crates/sema-eval/src/eval.rs:8377: // still-live `Tracked` cell, mirroring `async/spawn`) every escaping open +F31 crates/sema-eval/src/eval.rs:8552: .eval_str_via_runtime("(async/spawn (fn () (sleep 100000) 1)) 7") +F31 crates/sema-eval/src/eval.rs:8587: // observable synchronously via `async/cancelled?`. +F31 crates/sema-eval/src/eval.rs:8594: (let ((p (async (channel/recv ch)))) \ +F31 crates/sema-eval/src/eval.rs:8595: (async/cancel p) \ +F31 crates/sema-eval/src/eval.rs:8596: (async/cancelled? p)))", +F31 crates/sema-eval/src/eval.rs:8608: "(let ((p (async (async/sleep 100)))) \ +F31 crates/sema-eval/src/eval.rs:8609: (async/cancel p) \ +F31 crates/sema-eval/src/eval.rs:8610: (list (async/cancelled? p) (async/rejected? p) \ +F31 crates/sema-eval/src/eval.rs:8625: // A yielding native (`channel/recv`) passed DIRECTLY as a HOF callback now +F31 crates/sema-eval/src/eval.rs:8627: // continuation ABI (the tool-loop/HOF migration): `(map channel/recv …)` +F31 crates/sema-eval/src/eval.rs:8635: (let ((producer (async (channel/send ch 1) (channel/close ch))) \ +F31 crates/sema-eval/src/eval.rs:8636: (consumer (async (map channel/recv (list ch))))) \ +F31 crates/sema-eval/src/eval.rs:8643: // `async/run` inside an async task suspends cooperatively and preserves the +F31 crates/sema-eval/src/eval.rs:8651: (await (async (async/run) (channel/send ch 42) (channel/recv ch))))", +F31 crates/sema-eval/src/eval.rs:8659: // A 0 ms `async/timeout` must still let synchronously-ready work finish: the +F31 crates/sema-eval/src/eval.rs:8666: .eval_str_via_runtime("(async/timeout 0 (async 42))") +F31 crates/sema-eval/src/eval.rs:8671: // `retry` backoff in a runtime quantum yields cooperatively (via `async/sleep`) +F31 crates/sema-eval/src/eval.rs:8680: (async/all \ +F31 crates/sema-eval/src/eval.rs:8681: (list (async/spawn (fn () \ +F31 crates/sema-eval/src/eval.rs:8685: (channel/send out :slow))) \ +F31 crates/sema-eval/src/eval.rs:8686: (async/spawn (fn () (async/sleep 10) (channel/send out :fast))))) \ +F31 crates/sema-eval/src/eval.rs:8687: (list (channel/recv out) (channel/recv out)))", +F31 crates/sema-eval/src/eval.rs:8705: (begin (async (channel/send ch :ran)) :end)", +F31 crates/sema-eval/src/eval.rs:8711: .eval_str_via_runtime("(channel/recv ch)") +F34C crates/sema-eval/src/prelude.rs:1006:;; CONTEXT — a callback that itself suspends (async/sleep, channel ops, await) is +F34A crates/sema-eval/src/prelude.rs:1039:;; connection, spawned via `async/spawn`'s runtime ABI, which requires a +F34A crates/sema-eval/src/prelude.rs:1043:;; being `async/spawn`'s trivial promise-handle mapping — +F34A crates/sema-eval/src/prelude.rs:1070: (let ((factory (fn (h req responder) (async/spawn (fn () (responder (h req))))))) F34D crates/sema-eval/src/prelude.rs:137:;; (async/await (ws/listen sock {:on-message (fn (c m) (println m))})) F34A crates/sema-eval/src/prelude.rs:146: (async/spawn -F34A crates/sema-eval/src/prelude.rs:505:;; The OWNED combinators (`async/spawn-all`, `async/map`, `async/pool-map`, -F34B crates/sema-eval/src/prelude.rs:506:;; `async/race-owned`, `async/with-timeout`) OWN the tasks they create: on a -F34A crates/sema-eval/src/prelude.rs:509:;; observational `async/all`/`async/race`/`async/timeout`, which never cancel the -F34A crates/sema-eval/src/prelude.rs:514:;; A hard constraint drives the helper shape: `async/spawn`/`async/cancel` issue -F34A crates/sema-eval/src/prelude.rs:518:;; bytecode level via explicit recursion, never `(map async/spawn …)`. Pure list -F34A crates/sema-eval/src/prelude.rs:526: (let ((p (async/spawn (car thunks)))) -F34A crates/sema-eval/src/prelude.rs:538: (let ((p (async/spawn (fn () (wf item))))) -F34A crates/sema-eval/src/prelude.rs:547: (begin (async/cancel (car promises)) -F34A crates/sema-eval/src/prelude.rs:551:;; order. Fail-fast + OWNED: `async/all` raises on the FIRST child failure/ -F34A crates/sema-eval/src/prelude.rs:554:;; before its side effects — the ownership property the observational `async/all` -F34A crates/sema-eval/src/prelude.rs:560: (try (async/all children) -F34A crates/sema-eval/src/prelude.rs:566:;; (bytecode-level channel/send — capacity is exactly k so none block). -F34A crates/sema-eval/src/prelude.rs:570: (begin (channel/send sem #t) -F34A crates/sema-eval/src/prelude.rs:586:;; pre-filled with `n` tokens: each spawned task first `(channel/recv sem)` -F34A crates/sema-eval/src/prelude.rs:592:;; semaphore or mid-`f`) before re-raising — unlike the observational `async/all`. -F34A crates/sema-eval/src/prelude.rs:607: (channel/recv pool-sem#) ; acquire a slot (parks if full) -F34A crates/sema-eval/src/prelude.rs:610: (channel/send pool-sem# #t) ; release on BOTH paths -F34A crates/sema-eval/src/prelude.rs:624:;; async/spawn …)`): `async/spawn` issues a structural runtime request that a -F34A crates/sema-eval/src/prelude.rs:633: (for-range (i# 0 ,n) (channel/send fo-sem# #t)) ; n concurrency tokens -F34A crates/sema-eval/src/prelude.rs:636: (channel/recv fo-sem#) ; acquire (parks when full) -F34A crates/sema-eval/src/prelude.rs:639: (channel/send fo-sem# #t) ; release on BOTH paths -F34A crates/sema-eval/src/prelude.rs:641: (async/all (__spawn-apply fo-worker# fo-items#))))) -F34B crates/sema-eval/src/prelude.rs:710:;; On throw: sleeps base-ms * factor^(n-1) via (async/sleep …) — cooperative, parks -F34B crates/sema-eval/src/prelude.rs:730: (async/sleep delay#) ; cooperative backoff -F34B crates/sema-eval/src/prelude.rs:739:;; so in async context the loop lives here and backs off via `async/sleep` while -F34A crates/sema-eval/src/prelude.rs:741:;; blocking native. At top level the blocking native uses real `thread::sleep`. -F34B crates/sema-eval/src/prelude.rs:751: (when (> __retry-delay 0) (async/sleep __retry-delay)) -F34A crates/sema-eval/src/prelude.rs:805:;; async/spawn-all: spawn a list of zero-arg thunks as concurrent tasks and await -F34A crates/sema-eval/src/prelude.rs:809:;; before propagating (fail-fast), unlike the observational `async/all`. Empty -F34A crates/sema-eval/src/prelude.rs:812:;; (async/spawn-all (list (fn () (http/get a)) (fn () (http/get b)))) ; both at once -F34A crates/sema-eval/src/prelude.rs:813:(defmacro async/spawn-all (thunks) -F34A crates/sema-eval/src/prelude.rs:825:;; async/race-owned: run a list of zero-arg thunks concurrently and settle on the -F34A crates/sema-eval/src/prelude.rs:828:;; the observational `async/race` (which leaves losers running). Requires ≥1 thunk. -F34A crates/sema-eval/src/prelude.rs:830:;; (async/race-owned (list (fn () (http/get mirror-a)) (fn () (http/get mirror-b)))) -F34A crates/sema-eval/src/prelude.rs:831:(define (async/race-owned thunks) -F34A crates/sema-eval/src/prelude.rs:833: (error "async/race-owned: requires at least one thunk") -F34A crates/sema-eval/src/prelude.rs:835: ;; `async/race` settles on the FIRST child (value or error); either way we -F34A crates/sema-eval/src/prelude.rs:838: (try (let ((winner (async/race children))) -F34A crates/sema-eval/src/prelude.rs:852: (let ((child (async/spawn thunk)) -F34A crates/sema-eval/src/prelude.rs:854: ;; child tells the two apart without relying on `async/timeout` (which -F34B crates/sema-eval/src/prelude.rs:856: (timer (async/spawn (fn () (async/sleep ms) :__with-timeout-elapsed)))) -F34B crates/sema-eval/src/prelude.rs:857: (let ((outcome (try {:v (async/race (list child timer))} -F34A crates/sema-eval/src/prelude.rs:860: (async/cancel child) -F34B crates/sema-eval/src/prelude.rs:861: (async/cancel timer) -F34A crates/sema-eval/src/prelude.rs:871:;; sibling tasks overlap and `async/timeout`/`async/cancel` can cut the loop at -F34C crates/sema-eval/src/prelude.rs:983:;; CONTEXT — a callback that itself suspends (async/sleep, channel ops, await) is +F34A crates/sema-eval/src/prelude.rs:528:;; The OWNED combinators (`async/spawn-all`, `async/map`, `async/pool-map`, +F34B crates/sema-eval/src/prelude.rs:529:;; `async/race-owned`, `async/with-timeout`) OWN the tasks they create: on a +F34A crates/sema-eval/src/prelude.rs:532:;; observational `async/all`/`async/race`/`async/timeout`, which never cancel the +F34A crates/sema-eval/src/prelude.rs:537:;; A hard constraint drives the helper shape: `async/spawn`/`async/cancel` issue +F34A crates/sema-eval/src/prelude.rs:541:;; bytecode level via explicit recursion, never `(map async/spawn …)`. Pure list +F34A crates/sema-eval/src/prelude.rs:549: (let ((p (async/spawn (car thunks)))) +F34A crates/sema-eval/src/prelude.rs:561: (let ((p (async/spawn (fn () (wf item))))) +F34A crates/sema-eval/src/prelude.rs:570: (begin (async/cancel (car promises)) +F34A crates/sema-eval/src/prelude.rs:574:;; order. Fail-fast + OWNED: `async/all` raises on the FIRST child failure/ +F34A crates/sema-eval/src/prelude.rs:577:;; before its side effects — the ownership property the observational `async/all` +F34A crates/sema-eval/src/prelude.rs:583: (try (async/all children) +F34A crates/sema-eval/src/prelude.rs:589:;; (bytecode-level channel/send — capacity is exactly k so none block). +F34A crates/sema-eval/src/prelude.rs:593: (begin (channel/send sem #t) +F34A crates/sema-eval/src/prelude.rs:609:;; pre-filled with `n` tokens: each spawned task first `(channel/recv sem)` +F34A crates/sema-eval/src/prelude.rs:615:;; semaphore or mid-`f`) before re-raising — unlike the observational `async/all`. +F34A crates/sema-eval/src/prelude.rs:630: (channel/recv pool-sem#) ; acquire a slot (parks if full) +F34A crates/sema-eval/src/prelude.rs:633: (channel/send pool-sem# #t) ; release on BOTH paths +F34A crates/sema-eval/src/prelude.rs:647:;; async/spawn …)`): `async/spawn` issues a structural runtime request that a +F34A crates/sema-eval/src/prelude.rs:656: (for-range (i# 0 ,n) (channel/send fo-sem# #t)) ; n concurrency tokens +F34A crates/sema-eval/src/prelude.rs:659: (channel/recv fo-sem#) ; acquire (parks when full) +F34A crates/sema-eval/src/prelude.rs:662: (channel/send fo-sem# #t) ; release on BOTH paths +F34A crates/sema-eval/src/prelude.rs:664: (async/all (__spawn-apply fo-worker# fo-items#))))) +F34B crates/sema-eval/src/prelude.rs:733:;; On throw: sleeps base-ms * factor^(n-1) via (async/sleep …) — cooperative, parks +F34B crates/sema-eval/src/prelude.rs:753: (async/sleep delay#) ; cooperative backoff +F34B crates/sema-eval/src/prelude.rs:762:;; so in async context the loop lives here and backs off via `async/sleep` while +F34A crates/sema-eval/src/prelude.rs:764:;; blocking native. At top level the blocking native uses real `thread::sleep`. +F34B crates/sema-eval/src/prelude.rs:774: (when (> __retry-delay 0) (async/sleep __retry-delay)) +F34A crates/sema-eval/src/prelude.rs:828:;; async/spawn-all: spawn a list of zero-arg thunks as concurrent tasks and await +F34A crates/sema-eval/src/prelude.rs:832:;; before propagating (fail-fast), unlike the observational `async/all`. Empty +F34A crates/sema-eval/src/prelude.rs:835:;; (async/spawn-all (list (fn () (http/get a)) (fn () (http/get b)))) ; both at once +F34A crates/sema-eval/src/prelude.rs:836:(defmacro async/spawn-all (thunks) +F34A crates/sema-eval/src/prelude.rs:848:;; async/race-owned: run a list of zero-arg thunks concurrently and settle on the +F34A crates/sema-eval/src/prelude.rs:851:;; the observational `async/race` (which leaves losers running). Requires ≥1 thunk. +F34A crates/sema-eval/src/prelude.rs:853:;; (async/race-owned (list (fn () (http/get mirror-a)) (fn () (http/get mirror-b)))) +F34A crates/sema-eval/src/prelude.rs:854:(define (async/race-owned thunks) +F34A crates/sema-eval/src/prelude.rs:856: (error "async/race-owned: requires at least one thunk") +F34A crates/sema-eval/src/prelude.rs:858: ;; `async/race` settles on the FIRST child (value or error); either way we +F34A crates/sema-eval/src/prelude.rs:861: (try (let ((winner (async/race children))) +F34A crates/sema-eval/src/prelude.rs:875: (let ((child (async/spawn thunk)) +F34A crates/sema-eval/src/prelude.rs:877: ;; child tells the two apart without relying on `async/timeout` (which +F34B crates/sema-eval/src/prelude.rs:879: (timer (async/spawn (fn () (async/sleep ms) :__with-timeout-elapsed)))) +F34B crates/sema-eval/src/prelude.rs:880: (let ((outcome (try {:v (async/race (list child timer))} +F34A crates/sema-eval/src/prelude.rs:883: (async/cancel child) +F34B crates/sema-eval/src/prelude.rs:884: (async/cancel timer) +F34A crates/sema-eval/src/prelude.rs:894:;; sibling tasks overlap and `async/timeout`/`async/cancel` can cut the loop at F35B crates/sema-io/src/executor.rs:11://! burning one worker apiece — the ceiling the old blocking-tier `io_block_on` F35A crates/sema-io/src/executor.rs:379: std::thread::sleep(Duration::from_millis(ms)); F35A crates/sema-io/src/executor.rs:409: rx.recv_timeout(Duration::from_secs(2)) @@ -421,56 +421,56 @@ C07D crates/sema-llm/src/anthropic.rs:540: sema_io::io_block_on(self.comp C07D crates/sema-llm/src/anthropic.rs:556: // io_block_on drives ON THIS thread: `on_chunk` may touch non-Send Sema C07D crates/sema-llm/src/anthropic.rs:558: sema_io::io_block_on(self.stream_complete_async(request, on_chunk)) C07D crates/sema-llm/src/anthropic.rs:562: sema_io::io_block_on(async { -C07D crates/sema-llm/src/builtins.rs:10079: // synchronous caller thread (the provider's own block_on has already -C10 crates/sema-llm/src/builtins.rs:10084: std::thread::sleep(std::time::Duration::from_millis(sleep_ms)); -C10 crates/sema-llm/src/builtins.rs:10100:/// offloaded future, or a `std::thread::sleep` on a pool worker) so sibling -C11 crates/sema-llm/src/builtins.rs:10436:thread_local! { -C07B crates/sema-llm/src/builtins.rs:10932: // `async/cancel` cuts the loop at an inter-round park. -C07B crates/sema-llm/src/builtins.rs:10989: // `mcp/call`'s runtime external wait, or an `async/await` inside the handler), -C07C crates/sema-llm/src/builtins.rs:11010: let _ = sema_core::call_callback(ctx, callback, &[Value::map(event_map)]); -C07C crates/sema-llm/src/builtins.rs:11046: let _ = sema_core::call_callback(ctx, callback, &[Value::map(event_map)]); -C07C crates/sema-llm/src/builtins.rs:1124: let result = sema_core::call_callback( -C07C crates/sema-llm/src/builtins.rs:1138: results.push(sema_core::call_callback( -C07C crates/sema-llm/src/builtins.rs:1150: let result = sema_core::call_callback( -C11 crates/sema-llm/src/builtins.rs:11682:thread_local! { -C07C crates/sema-llm/src/builtins.rs:1168: if sema_core::call_callback(ctx, &plan.callback, std::slice::from_ref(&argument))? -C11 crates/sema-llm/src/builtins.rs:12267: match rx.recv() { -C10 crates/sema-llm/src/builtins.rs:12497: std::thread::sleep(std::time::Duration::from_millis(STREAM_POLL_INTERVAL_MS)); -C07C crates/sema-llm/src/builtins.rs:12715: let _ = sema_core::call_callback(ctx, callback, &[Value::map(event_map)]); -C07C crates/sema-llm/src/builtins.rs:12768: let _ = sema_core::call_callback(ctx, callback, &[Value::map(event_map)]); -C07C crates/sema-llm/src/builtins.rs:12841: let result = sema_core::call_callback(ctx, &tool_def.handler, &sema_args)?; -C07B crates/sema-llm/src/builtins.rs:1392:/// `NativeOutcome::Call`, so an async op inside the thunk (`async/spawn`, -C07C crates/sema-llm/src/builtins.rs:1394:/// `call_callback` re-entry would suspend the runtime quantum and hit the -C07C crates/sema-llm/src/builtins.rs:1396:/// synchronous `call_callback` extent): a thunk that only builds a promise tears down -C07C crates/sema-llm/src/builtins.rs:1416: let result = sema_core::call_callback(ctx, &body_fn, &[]); -C07C crates/sema-llm/src/builtins.rs:1927: sema_core::call_callback(ctx, &complete_fn, &[request_map]) -C08 crates/sema-llm/src/builtins.rs:266:// `async/spawn` and swaps it around every task step. Read-only flags ride as value -C11 crates/sema-llm/src/builtins.rs:27:thread_local! { -C07C crates/sema-llm/src/builtins.rs:3184: sema_core::call_callback(ctx, cb, &[Value::string(chunk)]) -C07B crates/sema-llm/src/builtins.rs:3976: // is not `async/cancel`-addressable). The prelude `agent/run` / `llm/chat` -C07B crates/sema-llm/src/builtins.rs:3981: // `async/await` inside it) parks on the active task and resumes through the -C07C crates/sema-llm/src/builtins.rs:4121: let result = sema_core::call_callback(ctx, func, std::slice::from_ref(item))?; -C11 crates/sema-llm/src/builtins.rs:539:thread_local! { -C07C crates/sema-llm/src/builtins.rs:6126: let result = sema_core::call_callback(ctx, &body_fn, &[]); -C10 crates/sema-llm/src/builtins.rs:6707: std::thread::sleep(std::time::Duration::from_millis(ms)); -C11 crates/sema-llm/src/builtins.rs:68:/// so they satisfy the `'static` bound required by `thread_local!`. -C07C crates/sema-llm/src/builtins.rs:6922: sema_core::call_callback(ctx, &callable, std::slice::from_ref(&argument)) -C11 crates/sema-llm/src/builtins.rs:7313:thread_local! { -C07B crates/sema-llm/src/builtins.rs:747:// `async/timeout` or a pool error-path) still runs to completion and decrements the -C07C crates/sema-llm/src/builtins.rs:7493: sema_core::call_callback(ctx, on_text, &[Value::string(chunk)]) -C07D crates/sema-llm/src/builtins.rs:8535:/// async tier drives futures with `block_on` (no task-abort). Lives on the runtime -C11 crates/sema-llm/src/builtins.rs:9554:thread_local! { -C07D crates/sema-llm/src/builtins.rs:9634:/// Synchronous-path loop (the VM thread; provider `block_on` already returned -C10 crates/sema-llm/src/builtins.rs:9635:/// before the backoff `thread::sleep`); the async wire stage uses the twin -C10 crates/sema-llm/src/builtins.rs:9658: std::thread::sleep(std::time::Duration::from_millis(wait)); +C08 crates/sema-llm/src/builtins.rs:1053:// `async/spawn` and swaps it around every task step. Read-only flags ride as value +C11 crates/sema-llm/src/builtins.rs:10571:thread_local! { +C07D crates/sema-llm/src/builtins.rs:10651:/// Synchronous-path loop (the VM thread; provider `block_on` already returned +C10 crates/sema-llm/src/builtins.rs:10652:/// before the backoff `thread::sleep`); the async wire stage uses the twin +C10 crates/sema-llm/src/builtins.rs:10675: std::thread::sleep(std::time::Duration::from_millis(wait)); +C07D crates/sema-llm/src/builtins.rs:11092: // synchronous caller thread (the provider's own block_on has already +C10 crates/sema-llm/src/builtins.rs:11097: std::thread::sleep(std::time::Duration::from_millis(sleep_ms)); +C10 crates/sema-llm/src/builtins.rs:11113:/// offloaded future, or a `std::thread::sleep` on a pool worker) so sibling +C11 crates/sema-llm/src/builtins.rs:11483:thread_local! { +C07B crates/sema-llm/src/builtins.rs:11979: // `async/cancel` cuts the loop at an inter-round park. +C07B crates/sema-llm/src/builtins.rs:12037: // `mcp/call`'s runtime external wait, or an `async/await` inside the handler), +C07C crates/sema-llm/src/builtins.rs:12062: let _ = sema_core::call_callback(ctx, callback, &[Value::map(event_map)]); +C07C crates/sema-llm/src/builtins.rs:12098: let _ = sema_core::call_callback(ctx, callback, &[Value::map(event_map)]); +C11 crates/sema-llm/src/builtins.rs:12746:thread_local! { +C11 crates/sema-llm/src/builtins.rs:13399: match rx.recv() { +C11 crates/sema-llm/src/builtins.rs:1340:thread_local! { +C10 crates/sema-llm/src/builtins.rs:13640: std::thread::sleep(std::time::Duration::from_millis(STREAM_POLL_INTERVAL_MS)); +C07C crates/sema-llm/src/builtins.rs:13878: let _ = sema_core::call_callback(ctx, callback, &[Value::map(event_map)]); +C07C crates/sema-llm/src/builtins.rs:13931: let _ = sema_core::call_callback(ctx, callback, &[Value::map(event_map)]); +C07C crates/sema-llm/src/builtins.rs:14004: let result = sema_core::call_callback(ctx, &tool_def.handler, &sema_args)?; +C07B crates/sema-llm/src/builtins.rs:1548:// `async/timeout` or a pool error-path) still runs to completion and decrements the +C07C crates/sema-llm/src/builtins.rs:1928: let result = sema_core::call_callback( +C07C crates/sema-llm/src/builtins.rs:1942: results.push(sema_core::call_callback( +C07C crates/sema-llm/src/builtins.rs:1954: let result = sema_core::call_callback( +C07C crates/sema-llm/src/builtins.rs:1972: if sema_core::call_callback(ctx, &plan.callback, std::slice::from_ref(&argument))? +C07B crates/sema-llm/src/builtins.rs:2196:/// `NativeOutcome::Call`, so an async op inside the thunk (`async/spawn`, +C07C crates/sema-llm/src/builtins.rs:2198:/// `call_callback` re-entry would suspend the runtime quantum and hit the +C07C crates/sema-llm/src/builtins.rs:2200:/// synchronous `call_callback` extent): a thunk that only builds a promise tears down +C07C crates/sema-llm/src/builtins.rs:2220: let result = sema_core::call_callback(ctx, &body_fn, &[]); +C07C crates/sema-llm/src/builtins.rs:2731: sema_core::call_callback(ctx, &complete_fn, &[request_map]) +C11 crates/sema-llm/src/builtins.rs:28:thread_local! { +C07C crates/sema-llm/src/builtins.rs:3988: sema_core::call_callback(ctx, cb, &[Value::string(chunk)]) +C07B crates/sema-llm/src/builtins.rs:4780: // is not `async/cancel`-addressable). The prelude `agent/run` / `llm/chat` +C07B crates/sema-llm/src/builtins.rs:4785: // `async/await` inside it) parks on the active task and resumes through the +C07C crates/sema-llm/src/builtins.rs:4925: let result = sema_core::call_callback(ctx, func, std::slice::from_ref(item))?; +C07C crates/sema-llm/src/builtins.rs:7007: let result = sema_core::call_callback(ctx, &body_fn, &[]); +C10 crates/sema-llm/src/builtins.rs:7588: std::thread::sleep(std::time::Duration::from_millis(ms)); +C07C crates/sema-llm/src/builtins.rs:7804: sema_core::call_callback(ctx, &callable, std::slice::from_ref(&argument)) +C11 crates/sema-llm/src/builtins.rs:79:/// so they satisfy the `'static` bound required by `thread_local!`. +C11 crates/sema-llm/src/builtins.rs:8201:thread_local! { +C07C crates/sema-llm/src/builtins.rs:8381: sema_core::call_callback(ctx, on_text, &[Value::string(chunk)]) +C07D crates/sema-llm/src/builtins.rs:9456:/// async tier drives futures with `block_on` (no task-abort). Lives on the runtime C07D crates/sema-llm/src/embeddings.rs:237: sema_io::io_block_on(self.embed_async(request)) C07D crates/sema-llm/src/embeddings.rs:247: Some(dialect) => sema_io::io_block_on(self.rerank_async(request, dialect)), C07D crates/sema-llm/src/embeddings.rs:392: sema_io::io_block_on(self.embed_async(request)) C07D crates/sema-llm/src/embeddings.rs:401: sema_io::io_block_on(self.rerank_async(request)) -C18 crates/sema-llm/src/fake.rs:504: std::thread::sleep(std::time::Duration::from_millis(self.chat_delay_ms)); -C18 crates/sema-llm/src/fake.rs:537: std::thread::sleep(std::time::Duration::from_millis(self.stream_chunk_delay_ms)); -C18 crates/sema-llm/src/fake.rs:580: std::thread::sleep(std::time::Duration::from_millis(self.embed_delay_ms)); -C18 crates/sema-llm/src/fake.rs:597: std::thread::sleep(std::time::Duration::from_millis(self.rerank_delay_ms)); +C18 crates/sema-llm/src/fake.rs:518: std::thread::sleep(std::time::Duration::from_millis(self.chat_delay_ms)); +C18 crates/sema-llm/src/fake.rs:551: std::thread::sleep(std::time::Duration::from_millis(self.stream_chunk_delay_ms)); +C18 crates/sema-llm/src/fake.rs:594: std::thread::sleep(std::time::Duration::from_millis(self.embed_delay_ms)); +C18 crates/sema-llm/src/fake.rs:611: std::thread::sleep(std::time::Duration::from_millis(self.rerank_delay_ms)); C07D crates/sema-llm/src/gemini.rs:476: sema_io::io_block_on(self.complete_async(request)) C07D crates/sema-llm/src/gemini.rs:492: // io_block_on drives ON THIS thread: `on_chunk` may touch non-Send Sema C07D crates/sema-llm/src/gemini.rs:494: sema_io::io_block_on(self.stream_complete_async(request, on_chunk)) @@ -504,15 +504,15 @@ C13 crates/sema-mcp/src/builtins.rs:1811: let payload = sema_io::io_b C13 crates/sema-mcp/src/builtins.rs:2292: sema_io::io_block_on(run_transport_task(async move { C13 crates/sema-mcp/src/builtins.rs:2308: sema_io::io_block_on(run_transport_task(async move { C13 crates/sema-mcp/src/builtins.rs:24://! the same transport futures through [`block_on`]. -C13 crates/sema-mcp/src/builtins.rs:2522: let result = block_on(list_tools_async(&mut conn)); -C13 crates/sema-mcp/src/builtins.rs:2644: let payload = sema_io::io_block_on(run_transport_task(async move { -C13 crates/sema-mcp/src/builtins.rs:2709:/// `io_block_on` would hit its active-quantum guard AND block the cooperative -C13 crates/sema-mcp/src/builtins.rs:2718: let _ = block_on(close_async(&mut conn)); -C13 crates/sema-mcp/src/builtins.rs:2723:/// where `io_block_on` is legal (no active runtime quantum on that thread). Kept -C13 crates/sema-mcp/src/builtins.rs:2725:/// the `io_block_on` lives on the worker, not the VM thread, so it must not sit -C13 crates/sema-mcp/src/builtins.rs:2731: let _ = sema_io::io_block_on(close_async(&mut conn)); -C13 crates/sema-mcp/src/builtins.rs:2764: let result = block_on(close_async(&mut conn)); -C13 crates/sema-mcp/src/builtins.rs:2888: let error = sema_io::io_block_on(crate::oauth::login::login( +C13 crates/sema-mcp/src/builtins.rs:2523: let result = block_on(list_tools_async(&mut conn)); +C13 crates/sema-mcp/src/builtins.rs:2645: let payload = sema_io::io_block_on(run_transport_task(async move { +C13 crates/sema-mcp/src/builtins.rs:2710:/// `io_block_on` would hit its active-quantum guard AND block the cooperative +C13 crates/sema-mcp/src/builtins.rs:2719: let _ = block_on(close_async(&mut conn)); +C13 crates/sema-mcp/src/builtins.rs:2724:/// where `io_block_on` is legal (no active runtime quantum on that thread). Kept +C13 crates/sema-mcp/src/builtins.rs:2726:/// the `io_block_on` lives on the worker, not the VM thread, so it must not sit +C13 crates/sema-mcp/src/builtins.rs:2732: let _ = sema_io::io_block_on(close_async(&mut conn)); +C13 crates/sema-mcp/src/builtins.rs:2765: let result = block_on(close_async(&mut conn)); +C13 crates/sema-mcp/src/builtins.rs:2889: let error = sema_io::io_block_on(crate::oauth::login::login( C13 crates/sema-mcp/src/builtins.rs:321:/// non-runtime) path. Routes through `sema_io::io_block_on`, the ADR C13 crates/sema-mcp/src/builtins.rs:326:/// offered both: "keep TOKIO_RT/block_on... or route through the sanctioned C13 crates/sema-mcp/src/builtins.rs:334:/// from inside `async/spawn` could not be driven on a private runtime). Routing every @@ -534,7 +534,7 @@ C13 crates/sema-mcp/src/client_auth.rs:96: rt.block_on(async { C13 crates/sema-mcp/src/oauth/flow.rs:276: let request = server.recv().expect("receive token request"); H07 crates/sema-mcp/src/oauth/loopback.rs:98: .recv_timeout(remaining.min(OPENER_ERROR_POLL)) C13 crates/sema-mcp/src/server.rs:27:/// synchronously and LLM builtins reach `sema_io::io_block_on`, which panics -H07 crates/sema-mcp/src/tools.rs:581: // runtime, the sole async engine, so async/await, channels, and timers work +H07 crates/sema-mcp/src/tools.rs:566: // runtime, the sole async engine, so async/await, channels, and timers work H06 crates/sema-notebook/src/bridge.rs:138: while let Some(req) = rt.block_on(rx.recv()) { H06 crates/sema-notebook/src/engine.rs:144: /// whichever cell this engine is currently driving (`async/sleep 60000` H06 crates/sema-notebook/src/engine.rs:627: (channel/send ch (list ch)) @@ -651,10 +651,10 @@ R22A crates/sema-stdlib/src/io.rs:3275: acc = sema_core::call R22A crates/sema-stdlib/src/io.rs:3333: acc = sema_core::call_callback_owned(ctx, &func, &mut cb_args)?; R08C crates/sema-stdlib/src/io.rs:85:thread_local! { R09A crates/sema-stdlib/src/kv.rs:127:thread_local! { -R22A crates/sema-stdlib/src/list.rs:3596:/// A runtime-only native (`async/spawn`, `channel/*`, `async/resolved`, …) can -R22A crates/sema-stdlib/src/list.rs:3637: sema_core::call_callback(ctx, func, args) -R22A crates/sema-stdlib/src/list.rs:3641: sema_core::with_stdlib_ctx(|ctx| sema_core::call_callback(ctx, func, args)) -R22A crates/sema-stdlib/src/list.rs:3650: sema_core::with_stdlib_ctx(|ctx| sema_core::call_callback_owned(ctx, func, args)) +R22A crates/sema-stdlib/src/list.rs:3598:/// A runtime-only native (`async/spawn`, `channel/*`, `async/resolved`, …) can +R22A crates/sema-stdlib/src/list.rs:3639: sema_core::call_callback(ctx, func, args) +R22A crates/sema-stdlib/src/list.rs:3643: sema_core::with_stdlib_ctx(|ctx| sema_core::call_callback(ctx, func, args)) +R22A crates/sema-stdlib/src/list.rs:3652: sema_core::with_stdlib_ctx(|ctx| sema_core::call_callback_owned(ctx, func, args)) R21A crates/sema-stdlib/src/markup.rs:42:thread_local! { R09C crates/sema-stdlib/src/memory.rs:158:thread_local! { R22A crates/sema-stdlib/src/meta.rs:116: // nonblocking-agent-run.md`) — so this real `thread::sleep` loop is @@ -680,7 +680,7 @@ F09B crates/sema-stdlib/src/runtime_offload.rs:363:/// running its future via [` F09B crates/sema-stdlib/src/runtime_offload.rs:371:/// async reactor (a synchronous library call under `io_block_on`) pick this; F09B crates/sema-stdlib/src/runtime_offload.rs:473: let out = sema_io::io_block_on(make_future()); F09B crates/sema-stdlib/src/runtime_offload.rs:666:// and cannot be reclaimed — best-effort, matching the retired `IoHandle` -R13A crates/sema-stdlib/src/secret.rs:48:thread_local! { +R13A crates/sema-stdlib/src/secret.rs:49:thread_local! { R14B crates/sema-stdlib/src/serial.rs:163:thread_local! { R14B crates/sema-stdlib/src/serial.rs:8://! VM thread for the operation's whole duration. Inside an `async/spawn`'d R15B crates/sema-stdlib/src/server.rs:1123: use sema_core::{call_callback, EvalContext, NativeFn}; @@ -744,14 +744,14 @@ R18C crates/sema-stdlib/src/system.rs:930: // VM thread — two `async/spawn` R18C crates/sema-stdlib/src/system.rs:931: // on the VM thread (unlike `async/sleep`, which is a virtual timer). Outside R18C crates/sema-stdlib/src/system.rs:944: std::thread::sleep(std::time::Duration::from_millis(ms as u64)); R19 crates/sema-stdlib/src/terminal.rs:84: /// bare `thread::sleep` frame loop, whose sleeping thread could only be -R23B crates/sema-stdlib/src/workflow.rs:249:/// `async/spawn`, an offloaded `llm/chat` tool loop, `channel/*`) parks on the active -R23B crates/sema-stdlib/src/workflow.rs:283: // The host arm resolves `:mcp` synchronously (its `io_block_on` is legal -R23B crates/sema-stdlib/src/workflow.rs:723: let _ = ack_rx.recv_timeout(HOST_FLUSH_ACK_TIMEOUT); -R23B crates/sema-stdlib/src/workflow.rs:737:// awaits the writer's ack on a blocking-tier worker (no `io_block_on`, no fs on the VM -R23B crates/sema-stdlib/src/workflow.rs:765: let _ = ack_rx.recv(); -R23B crates/sema-stdlib/src/workflow.rs:786: let _ = ack.recv_timeout(HOST_FLUSH_ACK_TIMEOUT); -R23B crates/sema-stdlib/src/workflow.rs:967: // `io_block_on`'s active-quantum guard, so offload it structurally — the blocking -R23B crates/sema-stdlib/src/workflow.rs:981: // Host arm (outside a runtime quantum): `io_block_on` is legal — resolve inline. +R23B crates/sema-stdlib/src/workflow.rs:1041: let _ = ack_rx.recv_timeout(HOST_FLUSH_ACK_TIMEOUT); +R23B crates/sema-stdlib/src/workflow.rs:1055:// awaits the writer's ack on a blocking-tier worker (no `io_block_on`, no fs on the VM +R23B crates/sema-stdlib/src/workflow.rs:1083: let _ = ack_rx.recv(); +R23B crates/sema-stdlib/src/workflow.rs:1104: let _ = ack.recv_timeout(HOST_FLUSH_ACK_TIMEOUT); +R23B crates/sema-stdlib/src/workflow.rs:1289: // `io_block_on`'s active-quantum guard, so offload it structurally — the blocking +R23B crates/sema-stdlib/src/workflow.rs:1305: // Host arm (outside a runtime quantum): `io_block_on` is legal — resolve inline. +R23B crates/sema-stdlib/src/workflow.rs:496:/// `async/spawn`, an offloaded `llm/chat` tool loop, `channel/*`) parks on the active +R23B crates/sema-stdlib/src/workflow.rs:530: // The host arm resolves `:mcp` synchronously (its `io_block_on` is legal R23B crates/sema-stdlib/src/workflow_mcp.rs:473: /// I/O through `io_block_on`, which rejects an active runtime quantum. Inside R23B crates/sema-stdlib/src/workflow_mcp.rs:480: /// synchronous [`resolve`](Self::resolve) would hit `io_block_on`'s R23B crates/sema-stdlib/src/workflow_mcp.rs:482: /// resolve off the VM thread (a plain worker where `io_block_on` is legal); @@ -888,32 +888,32 @@ H10A crates/sema-wasm/src/driver.rs:775:/// honor a pending `WaitKind::Timer` de H09 crates/sema-wasm/src/driver.rs:82:thread_local! { H09 crates/sema-wasm/src/lib.rs:132:thread_local! { H09 crates/sema-wasm/src/lib.rs:16:thread_local! { -H09 crates/sema-wasm/src/lib.rs:1930: /// with an `Error` on failure. The body runs once; `async/sleep` and -H09 crates/sema-wasm/src/lib.rs:1977: /// `http/get`/`async/sleep` inside it get the real, single-execution -H09 crates/sema-wasm/src/lib.rs:2767: sema_core::set_eval_callback(&ctx, sema_eval::eval_value_vm); -H09 crates/sema-wasm/src/lib.rs:2768: sema_core::set_call_callback(&ctx, sema_eval::call_value); -H09 crates/sema-wasm/src/lib.rs:2769: sema_core::set_call_owned_callback(&ctx, sema_eval::call_value_owned); -H10A crates/sema-wasm/src/lib.rs:3184: /// replays, and `http/get`/`async/sleep` resume the original root in place. +H09 crates/sema-wasm/src/lib.rs:1921: /// with an `Error` on failure. The body runs once; `async/sleep` and +H09 crates/sema-wasm/src/lib.rs:1968: /// `http/get`/`async/sleep` inside it get the real, single-execution +H09 crates/sema-wasm/src/lib.rs:2740: sema_core::set_eval_callback(&ctx, sema_eval::eval_value_vm); +H09 crates/sema-wasm/src/lib.rs:2741: sema_core::set_call_callback(&ctx, sema_eval::call_value); +H09 crates/sema-wasm/src/lib.rs:2742: sema_core::set_call_owned_callback(&ctx, sema_eval::call_value_owned); +H10A crates/sema-wasm/src/lib.rs:3157: /// replays, and `http/get`/`async/sleep` resume the original root in place. C12 crates/sema-workflow/src/context.rs:114:thread_local! { C12 crates/sema-workflow/src/journal.rs:150: let _ = ack.recv_timeout(HOST_FLUSH_TIMEOUT); C12 crates/sema-workflow/src/writer.rs:152: while let Ok(msg) = rx.recv() { C12 crates/sema-workflow/src/writer.rs:211:// `Condvar`, NEVER `thread::sleep`) before draining each message. Tests use it to hold a -H01 crates/sema/src/lib.rs:133: sema_core::set_eval_callback(&ctx, sema_eval::eval_value_vm); -H01 crates/sema/src/lib.rs:134: sema_core::set_call_callback(&ctx, sema_eval::call_value); -H01 crates/sema/src/lib.rs:135: sema_core::set_call_owned_callback(&ctx, sema_eval::call_value_owned); -H02 crates/sema/src/main.rs:1071: // runtime, llm/* builtins hit io_block_on's runtime-in-runtime +H01 crates/sema/src/lib.rs:134: sema_core::set_eval_callback(&ctx, sema_eval::eval_value_vm); +H01 crates/sema/src/lib.rs:135: sema_core::set_call_callback(&ctx, sema_eval::call_value); +H01 crates/sema/src/lib.rs:136: sema_core::set_call_owned_callback(&ctx, sema_eval::call_value_owned); +H02 crates/sema/src/main.rs:1002: .block_on(sema_lsp::run_server()); +H02 crates/sema/src/main.rs:1009: .block_on(sema_dap::run_server()); H02 crates/sema/src/main.rs:107:thread_local! { -H02 crates/sema/src/main.rs:1308: .block_on(workflow_view::serve(PathBuf::from(run_dir), &host, port)); -H02 crates/sema/src/main.rs:1418: .block_on(async { -H02 crates/sema/src/main.rs:1435: std::thread::sleep(std::time::Duration::from_millis(250)); -H02 crates/sema/src/main.rs:1505: std::thread::sleep(std::time::Duration::from_secs(3600)); -H02 crates/sema/src/main.rs:1610: .block_on(sema_notebook::serve(path, &host, port)); -H02 crates/sema/src/main.rs:2156: // Same no-ambient-runtime rule as the CLI mcp arm (llm/* + io_block_on). -H02 crates/sema/src/main.rs:3596: // runtime, the sole async engine, so async/await, channels, and timers work -H02 crates/sema/src/main.rs:989: .block_on(sema_lsp::run_server()); -H02 crates/sema/src/main.rs:996: .block_on(sema_dap::run_server()); -H02 crates/sema/src/pkg.rs:1539: std::thread::sleep(jittered(wait)); -H02 crates/sema/src/pkg.rs:1552: std::thread::sleep(jittered(backoff)); +H02 crates/sema/src/main.rs:1084: // runtime, llm/* builtins hit io_block_on's runtime-in-runtime +H02 crates/sema/src/main.rs:1323: .block_on(workflow_view::serve(PathBuf::from(run_dir), &host, port)); +H02 crates/sema/src/main.rs:1461: .block_on(async { +H02 crates/sema/src/main.rs:1478: std::thread::sleep(std::time::Duration::from_millis(250)); +H02 crates/sema/src/main.rs:1548: std::thread::sleep(std::time::Duration::from_secs(3600)); +H02 crates/sema/src/main.rs:1653: .block_on(sema_notebook::serve(path, &host, port)); +H02 crates/sema/src/main.rs:2203: // Same no-ambient-runtime rule as the CLI mcp arm (llm/* + io_block_on). +H02 crates/sema/src/main.rs:3643: // runtime, the sole async engine, so async/await, channels, and timers work +H02 crates/sema/src/pkg.rs:1637: std::thread::sleep(jittered(wait)); +H02 crates/sema/src/pkg.rs:1650: std::thread::sleep(jittered(backoff)); H03 crates/sema/src/repl/completer.rs:16:thread_local! { H08 crates/sema/src/web/mod.rs:154: std::thread::sleep(std::time::Duration::from_millis(100)); H13 crates/sema/src/web/runtime.rs:414: "installAtomicsSleep", diff --git a/website/docs/llm/workflows.md b/website/docs/llm/workflows.md index 6208d146..571213b1 100644 --- a/website/docs/llm/workflows.md +++ b/website/docs/llm/workflows.md @@ -400,6 +400,29 @@ cannot loosen it. The strictest denial action across active layers wins. | Tool | `:fail` (default) | Preflight the whole requested batch and run none when any call is denied | | Tool | `:tool-error` | In an agent loop, return a correlated tool error for the denied call while allowed siblings run | +`:fail` raises a `:policy-denied` condition. Its message names the policy, +boundary, and denied subject. Catch the condition when code needs the exact +decision: + +```sema +(try + (llm/complete "Review this change.") + (catch denial + {:type (:type denial) ; :policy-denied + :policy (:policy denial) ; "safe-agent" + :boundary (:boundary denial) ; "model" + :subject (:subject denial) + :rule (:rule denial) + :reason (:reason denial) + :action (:action denial) ; :fail + :source (:source denial)})) ; :request, :cache, or :cassette +``` + +For example, a denied model reports: +`Policy 'safe-agent' denied model 'openai/unlisted': model openai/unlisted is not allowlisted`. +Tool errors returned to a model contain only the tool name and safe denial +reason. They do not include an extra CLI `Error:` prefix. + The model gate covers completion, chat, extraction, classification, streaming, fallbacks, embeddings, and reranking. The tool gate covers `ToolDefinition` dispatch through agents and direct `tool/invoke`, including tools discovered @@ -439,6 +462,10 @@ LLM**. Catches arity traps, bad options, invalid literal policy maps, `defpolicy` shape errors, unsafe matcher syntax, and invalid `policy/without` reasons before you spend a token. +Policy diagnostics identify the invalid field or one-based list entry. Unknown +keys include a suggested replacement when one is close, or list the valid keys. +Invalid enum values list the accepted Sema keywords. + ```bash $ sema workflow check audit.sema error[WF-PHASE-ARITY]: phase expects exactly 1 argument (a label), got 3 From 4e24be9e8ff80c22ef078c0090e2d4db4cd0dc3c Mon Sep 17 00:00:00 2001 From: Helge Sverre Date: Fri, 31 Jul 2026 12:08:51 +0200 Subject: [PATCH 08/11] fix(wasm): include policy scanners in web builds --- crates/sema-stdlib/Cargo.toml | 2 +- crates/sema-stdlib/src/secret.rs | 6 ++-- crates/sema/src/web/assets/sema_wasm.js | 34 +++++++++---------- crates/sema/src/web/assets/sema_wasm_bg.wasm | Bin 5124015 -> 5154092 bytes crates/sema/web-runtime.lock | 6 ++-- 5 files changed, 24 insertions(+), 24 deletions(-) diff --git a/crates/sema-stdlib/Cargo.toml b/crates/sema-stdlib/Cargo.toml index 15cd4226..07241b03 100644 --- a/crates/sema-stdlib/Cargo.toml +++ b/crates/sema-stdlib/Cargo.toml @@ -12,6 +12,7 @@ readme = "README.md" sema-core.workspace = true sema-reader.workspace = true sema-otel.workspace = true +sema-policy.workspace = true num-bigint = "0.4" num-integer = "0.1" regex.workspace = true @@ -41,7 +42,6 @@ similar.workspace = true sema-io.workspace = true sema-workflow.workspace = true sema-llm.workspace = true -sema-policy.workspace = true tokio.workspace = true reqwest.workspace = true # Enables rustls's `ring` feature in the unified graph: with exactly one provider diff --git a/crates/sema-stdlib/src/secret.rs b/crates/sema-stdlib/src/secret.rs index 45485de3..e795c5d2 100644 --- a/crates/sema-stdlib/src/secret.rs +++ b/crates/sema-stdlib/src/secret.rs @@ -27,9 +27,9 @@ use std::collections::BTreeMap; use sema_core::{check_arity, SemaError, Value}; -use sema_policy::content::{ - detect_pii, detect_secrets, redact as redact_findings, Finding, INPUT_BYTE_CAP, -}; +#[cfg(not(target_arch = "wasm32"))] +use sema_policy::content::INPUT_BYTE_CAP; +use sema_policy::content::{detect_pii, detect_secrets, redact as redact_findings, Finding}; use sha2::{Digest, Sha256}; use crate::register_fn; diff --git a/crates/sema/src/web/assets/sema_wasm.js b/crates/sema/src/web/assets/sema_wasm.js index 2dacf40b..a9073bd1 100644 --- a/crates/sema/src/web/assets/sema_wasm.js +++ b/crates/sema/src/web/assets/sema_wasm.js @@ -798,7 +798,7 @@ function __wbg_get_imports() { const a = state0.a; state0.a = 0; try { - return wasm_bindgen_99a98757d426b094___convert__closures_____invoke___js_sys_82c2e4c9bb939c97___Function_fn_wasm_bindgen_99a98757d426b094___JsValue_____wasm_bindgen_99a98757d426b094___sys__Undefined___js_sys_82c2e4c9bb939c97___Function_fn_wasm_bindgen_99a98757d426b094___JsValue_____wasm_bindgen_99a98757d426b094___sys__Undefined_______true_(a, state0.b, arg0, arg1); + return wasm_bindgen_ebd8a114a503ff65___convert__closures_____invoke___js_sys_767414036c389fc4___Function_fn_wasm_bindgen_ebd8a114a503ff65___JsValue_____wasm_bindgen_ebd8a114a503ff65___sys__Undefined___js_sys_767414036c389fc4___Function_fn_wasm_bindgen_ebd8a114a503ff65___JsValue_____wasm_bindgen_ebd8a114a503ff65___sys__Undefined_______true_(a, state0.b, arg0, arg1); } finally { state0.a = a; } @@ -824,7 +824,7 @@ function __wbg_get_imports() { const a = state0.a; state0.a = 0; try { - return wasm_bindgen_99a98757d426b094___convert__closures_____invoke___js_sys_82c2e4c9bb939c97___Function_fn_wasm_bindgen_99a98757d426b094___JsValue_____wasm_bindgen_99a98757d426b094___sys__Undefined___js_sys_82c2e4c9bb939c97___Function_fn_wasm_bindgen_99a98757d426b094___JsValue_____wasm_bindgen_99a98757d426b094___sys__Undefined_______true_(a, state0.b, arg0, arg1); + return wasm_bindgen_ebd8a114a503ff65___convert__closures_____invoke___js_sys_767414036c389fc4___Function_fn_wasm_bindgen_ebd8a114a503ff65___JsValue_____wasm_bindgen_ebd8a114a503ff65___sys__Undefined___js_sys_767414036c389fc4___Function_fn_wasm_bindgen_ebd8a114a503ff65___JsValue_____wasm_bindgen_ebd8a114a503ff65___sys__Undefined_______true_(a, state0.b, arg0, arg1); } finally { state0.a = a; } @@ -974,23 +974,23 @@ function __wbg_get_imports() { return ret; }, __wbindgen_cast_0000000000000001: function(arg0, arg1) { - // Cast intrinsic for `Closure(Closure { dtor_idx: 9, function: Function { arguments: [Externref], shim_idx: 67, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`. - const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_99a98757d426b094___closure__destroy___dyn_core_7d5f0a2ba6a62c33___ops__function__FnMut__wasm_bindgen_99a98757d426b094___JsValue____Output___core_7d5f0a2ba6a62c33___result__Result_____wasm_bindgen_99a98757d426b094___JsError___, wasm_bindgen_99a98757d426b094___convert__closures_____invoke___wasm_bindgen_99a98757d426b094___JsValue__core_7d5f0a2ba6a62c33___result__Result_____wasm_bindgen_99a98757d426b094___JsError___true_); + // Cast intrinsic for `Closure(Closure { dtor_idx: 9, function: Function { arguments: [Externref], shim_idx: 66, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`. + const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_ebd8a114a503ff65___closure__destroy___dyn_core_7d5f0a2ba6a62c33___ops__function__FnMut__wasm_bindgen_ebd8a114a503ff65___JsValue____Output___core_7d5f0a2ba6a62c33___result__Result_____wasm_bindgen_ebd8a114a503ff65___JsError___, wasm_bindgen_ebd8a114a503ff65___convert__closures_____invoke___wasm_bindgen_ebd8a114a503ff65___JsValue__core_7d5f0a2ba6a62c33___result__Result_____wasm_bindgen_ebd8a114a503ff65___JsError___true_); return ret; }, __wbindgen_cast_0000000000000002: function(arg0, arg1) { // Cast intrinsic for `Closure(Closure { dtor_idx: 9, function: Function { arguments: [F64, Externref, Externref], shim_idx: 12, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`. - const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_99a98757d426b094___closure__destroy___dyn_core_7d5f0a2ba6a62c33___ops__function__FnMut__wasm_bindgen_99a98757d426b094___JsValue____Output___core_7d5f0a2ba6a62c33___result__Result_____wasm_bindgen_99a98757d426b094___JsError___, wasm_bindgen_99a98757d426b094___convert__closures_____invoke___f64__wasm_bindgen_99a98757d426b094___JsValue__wasm_bindgen_99a98757d426b094___JsValue______true_); + const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_ebd8a114a503ff65___closure__destroy___dyn_core_7d5f0a2ba6a62c33___ops__function__FnMut__wasm_bindgen_ebd8a114a503ff65___JsValue____Output___core_7d5f0a2ba6a62c33___result__Result_____wasm_bindgen_ebd8a114a503ff65___JsError___, wasm_bindgen_ebd8a114a503ff65___convert__closures_____invoke___f64__wasm_bindgen_ebd8a114a503ff65___JsValue__wasm_bindgen_ebd8a114a503ff65___JsValue______true_); return ret; }, __wbindgen_cast_0000000000000003: function(arg0, arg1) { // Cast intrinsic for `Closure(Closure { dtor_idx: 9, function: Function { arguments: [F64], shim_idx: 10, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`. - const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_99a98757d426b094___closure__destroy___dyn_core_7d5f0a2ba6a62c33___ops__function__FnMut__wasm_bindgen_99a98757d426b094___JsValue____Output___core_7d5f0a2ba6a62c33___result__Result_____wasm_bindgen_99a98757d426b094___JsError___, wasm_bindgen_99a98757d426b094___convert__closures_____invoke___f64______true_); + const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_ebd8a114a503ff65___closure__destroy___dyn_core_7d5f0a2ba6a62c33___ops__function__FnMut__wasm_bindgen_ebd8a114a503ff65___JsValue____Output___core_7d5f0a2ba6a62c33___result__Result_____wasm_bindgen_ebd8a114a503ff65___JsError___, wasm_bindgen_ebd8a114a503ff65___convert__closures_____invoke___f64______true_); return ret; }, __wbindgen_cast_0000000000000004: function(arg0, arg1) { // Cast intrinsic for `Closure(Closure { dtor_idx: 9, function: Function { arguments: [], shim_idx: 14, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`. - const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_99a98757d426b094___closure__destroy___dyn_core_7d5f0a2ba6a62c33___ops__function__FnMut__wasm_bindgen_99a98757d426b094___JsValue____Output___core_7d5f0a2ba6a62c33___result__Result_____wasm_bindgen_99a98757d426b094___JsError___, wasm_bindgen_99a98757d426b094___convert__closures_____invoke_______true_); + const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_ebd8a114a503ff65___closure__destroy___dyn_core_7d5f0a2ba6a62c33___ops__function__FnMut__wasm_bindgen_ebd8a114a503ff65___JsValue____Output___core_7d5f0a2ba6a62c33___result__Result_____wasm_bindgen_ebd8a114a503ff65___JsError___, wasm_bindgen_ebd8a114a503ff65___convert__closures_____invoke_______true_); return ret; }, __wbindgen_cast_0000000000000005: function(arg0) { @@ -1019,27 +1019,27 @@ function __wbg_get_imports() { }; } -function wasm_bindgen_99a98757d426b094___convert__closures_____invoke_______true_(arg0, arg1) { - wasm.wasm_bindgen_99a98757d426b094___convert__closures_____invoke_______true_(arg0, arg1); +function wasm_bindgen_ebd8a114a503ff65___convert__closures_____invoke_______true_(arg0, arg1) { + wasm.wasm_bindgen_ebd8a114a503ff65___convert__closures_____invoke_______true_(arg0, arg1); } -function wasm_bindgen_99a98757d426b094___convert__closures_____invoke___wasm_bindgen_99a98757d426b094___JsValue__core_7d5f0a2ba6a62c33___result__Result_____wasm_bindgen_99a98757d426b094___JsError___true_(arg0, arg1, arg2) { - const ret = wasm.wasm_bindgen_99a98757d426b094___convert__closures_____invoke___wasm_bindgen_99a98757d426b094___JsValue__core_7d5f0a2ba6a62c33___result__Result_____wasm_bindgen_99a98757d426b094___JsError___true_(arg0, arg1, arg2); +function wasm_bindgen_ebd8a114a503ff65___convert__closures_____invoke___wasm_bindgen_ebd8a114a503ff65___JsValue__core_7d5f0a2ba6a62c33___result__Result_____wasm_bindgen_ebd8a114a503ff65___JsError___true_(arg0, arg1, arg2) { + const ret = wasm.wasm_bindgen_ebd8a114a503ff65___convert__closures_____invoke___wasm_bindgen_ebd8a114a503ff65___JsValue__core_7d5f0a2ba6a62c33___result__Result_____wasm_bindgen_ebd8a114a503ff65___JsError___true_(arg0, arg1, arg2); if (ret[1]) { throw takeFromExternrefTable0(ret[0]); } } -function wasm_bindgen_99a98757d426b094___convert__closures_____invoke___js_sys_82c2e4c9bb939c97___Function_fn_wasm_bindgen_99a98757d426b094___JsValue_____wasm_bindgen_99a98757d426b094___sys__Undefined___js_sys_82c2e4c9bb939c97___Function_fn_wasm_bindgen_99a98757d426b094___JsValue_____wasm_bindgen_99a98757d426b094___sys__Undefined_______true_(arg0, arg1, arg2, arg3) { - wasm.wasm_bindgen_99a98757d426b094___convert__closures_____invoke___js_sys_82c2e4c9bb939c97___Function_fn_wasm_bindgen_99a98757d426b094___JsValue_____wasm_bindgen_99a98757d426b094___sys__Undefined___js_sys_82c2e4c9bb939c97___Function_fn_wasm_bindgen_99a98757d426b094___JsValue_____wasm_bindgen_99a98757d426b094___sys__Undefined_______true_(arg0, arg1, arg2, arg3); +function wasm_bindgen_ebd8a114a503ff65___convert__closures_____invoke___js_sys_767414036c389fc4___Function_fn_wasm_bindgen_ebd8a114a503ff65___JsValue_____wasm_bindgen_ebd8a114a503ff65___sys__Undefined___js_sys_767414036c389fc4___Function_fn_wasm_bindgen_ebd8a114a503ff65___JsValue_____wasm_bindgen_ebd8a114a503ff65___sys__Undefined_______true_(arg0, arg1, arg2, arg3) { + wasm.wasm_bindgen_ebd8a114a503ff65___convert__closures_____invoke___js_sys_767414036c389fc4___Function_fn_wasm_bindgen_ebd8a114a503ff65___JsValue_____wasm_bindgen_ebd8a114a503ff65___sys__Undefined___js_sys_767414036c389fc4___Function_fn_wasm_bindgen_ebd8a114a503ff65___JsValue_____wasm_bindgen_ebd8a114a503ff65___sys__Undefined_______true_(arg0, arg1, arg2, arg3); } -function wasm_bindgen_99a98757d426b094___convert__closures_____invoke___f64______true_(arg0, arg1, arg2) { - wasm.wasm_bindgen_99a98757d426b094___convert__closures_____invoke___f64______true_(arg0, arg1, arg2); +function wasm_bindgen_ebd8a114a503ff65___convert__closures_____invoke___f64______true_(arg0, arg1, arg2) { + wasm.wasm_bindgen_ebd8a114a503ff65___convert__closures_____invoke___f64______true_(arg0, arg1, arg2); } -function wasm_bindgen_99a98757d426b094___convert__closures_____invoke___f64__wasm_bindgen_99a98757d426b094___JsValue__wasm_bindgen_99a98757d426b094___JsValue______true_(arg0, arg1, arg2, arg3, arg4) { - wasm.wasm_bindgen_99a98757d426b094___convert__closures_____invoke___f64__wasm_bindgen_99a98757d426b094___JsValue__wasm_bindgen_99a98757d426b094___JsValue______true_(arg0, arg1, arg2, arg3, arg4); +function wasm_bindgen_ebd8a114a503ff65___convert__closures_____invoke___f64__wasm_bindgen_ebd8a114a503ff65___JsValue__wasm_bindgen_ebd8a114a503ff65___JsValue______true_(arg0, arg1, arg2, arg3, arg4) { + wasm.wasm_bindgen_ebd8a114a503ff65___convert__closures_____invoke___f64__wasm_bindgen_ebd8a114a503ff65___JsValue__wasm_bindgen_ebd8a114a503ff65___JsValue______true_(arg0, arg1, arg2, arg3, arg4); } diff --git a/crates/sema/src/web/assets/sema_wasm_bg.wasm b/crates/sema/src/web/assets/sema_wasm_bg.wasm index 73b61b355a77a97959e651c275f81f2f84895423..2561b56f59fd4d08ced4bbf093c36257acd4801a 100644 GIT binary patch delta 1303251 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%0AG4=cMJ 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

-C4B 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

cEqmn>+I@_;LjyPer7HB6_@dm?!9o@!~Fs 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⪚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 delta 1279050 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

>>vzx0{q186 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 Date: Fri, 31 Jul 2026 12:13:46 +0200 Subject: [PATCH 09/11] test(web): align arity diagnostic assertion --- packages/sema-web/tests/resource-sema.test.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/sema-web/tests/resource-sema.test.ts b/packages/sema-web/tests/resource-sema.test.ts index a5857ef0..a88c7612 100644 --- a/packages/sema-web/tests/resource-sema.test.ts +++ b/packages/sema-web/tests/resource-sema.test.ts @@ -234,6 +234,6 @@ describeWithWasm("resource bindings under a real interpreter", () => { const screen = await boot('(def user (resource "user" (fn (previous) "/api/user")))'); await screen.flush(); - expect(screen.run("(:error @user)")).toMatch(/expects 1 args, got 0/); + expect(screen.run("(:error @user)")).toMatch(/expects 1 argument, got 0/); }); }); From 59ee304fe9e6fb6fd4a40486f7330fbd9c9a0dbe Mon Sep 17 00:00:00 2001 From: Helge Sverre Date: Sat, 1 Aug 2026 20:08:51 +0200 Subject: [PATCH 10/11] fix(policy): report each content action accurately --- crates/sema-llm/src/builtins.rs | 6 ++-- .../sema/tests/suites/workflow_policy_test.rs | 33 +++++++++++++++++++ 2 files changed, 36 insertions(+), 3 deletions(-) diff --git a/crates/sema-llm/src/builtins.rs b/crates/sema-llm/src/builtins.rs index ecaecd77..6bbf290e 100644 --- a/crates/sema-llm/src/builtins.rs +++ b/crates/sema-llm/src/builtins.rs @@ -728,7 +728,7 @@ fn apply_text_policy( continue; } for finding in &outcome.findings { - let kind = match effective_action { + let kind = match outcome.action { sema_policy::ContentAction::Block => PolicyObservationKind::Violation, sema_policy::ContentAction::Redact => PolicyObservationKind::Redacted, sema_policy::ContentAction::Audit => PolicyObservationKind::Flagged, @@ -744,8 +744,8 @@ fn apply_text_policy( rule: finding.rule_id.clone(), label: Some(finding.label.clone()), count: Some(finding.count), - action: Some(effective_action.as_str().to_string()), - reason: (effective_action == sema_policy::ContentAction::Block) + action: Some(outcome.action.as_str().to_string()), + reason: (outcome.action == sema_policy::ContentAction::Block) .then(|| "deterministic content policy matched".to_string()), source, agent_id: agent_id.clone(), diff --git a/crates/sema/tests/suites/workflow_policy_test.rs b/crates/sema/tests/suites/workflow_policy_test.rs index bb09e008..830408b1 100644 --- a/crates/sema/tests/suites/workflow_policy_test.rs +++ b/crates/sema/tests/suites/workflow_policy_test.rs @@ -429,6 +429,39 @@ fn output_policy_returns_only_redacted_content() { ); } +#[test] +fn composed_output_policies_report_each_layer_action() { + let src = r#" + (defpolicy audit-email + {:output {:detect [:email] + :actions {:email :audit}}}) + (defpolicy redact-phone + {:output {:detect [:phone] + :actions {:phone :redact}}}) + (defworkflow guarded "composed output actions" + {:policy [audit-email redact-phone]} + (phase "Run") + (def result (step "answer")) + {:status :success :result result}) + "#; + let out = wc::run_once( + src, + fake_with_reply("alice@example.com +1 212-555-0199"), + "wf_policy_composed_output_actions", + ); + + assert_eq!(out.result["result"], "alice@example.com «redacted:phone»"); + assert!(wc::events_of(&out.events, "policy.flagged") + .iter() + .any(|event| event["policy"] == "audit-email" && event["label"] == "email")); + assert!(wc::events_of(&out.events, "policy.redacted") + .iter() + .any(|event| event["policy"] == "redact-phone" && event["label"] == "phone")); + assert!(!wc::events_of(&out.events, "policy.redacted") + .iter() + .any(|event| event["policy"] == "audit-email" && event["label"] == "email")); +} + #[test] fn completion_policy_fails_a_nominal_success_when_evidence_is_missing() { let src = r#" From 23630c662c67d03896a3f22ae06f065463a2bde8 Mon Sep 17 00:00:00 2001 From: Helge Sverre Date: Sat, 1 Aug 2026 20:12:02 +0200 Subject: [PATCH 11/11] chore(policy): refresh web runtime lock --- crates/sema/web-runtime.lock | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/sema/web-runtime.lock b/crates/sema/web-runtime.lock index a3ccf160..66f70aa2 100644 --- a/crates/sema/web-runtime.lock +++ b/crates/sema/web-runtime.lock @@ -1,5 +1,5 @@ { - "inputs": "66a72554e400a5695379a312c9c8309203de45a10adcb7452f8edf2f375f64f3", + "inputs": "c51538bd2f0bd3efdddd745de53e115e45bc5a9a3bb3dee874da8c1260914065", "assets": "69172cc58d01f9327f6eb15dcf5c7b7484837183809cca4678ab1b49c952bf34", "input_count": 203, "asset_count": 12

W4Nw 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 W* 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