flowproof 0.6.0__tar.gz → 0.7.0__tar.gz

{flowproof-0.6.0 → flowproof-0.7.0}/Cargo.lock

@@ -760,7 +760,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-adapters"
-version = "0.6.0"
+version = "0.7.0"
 dependencies = [
  "anyhow",
  "flowproof-driver",
@@ -779,7 +779,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-agent"
-version = "0.6.0"
+version = "0.7.0"
 dependencies = [
  "chrono",
  "flowproof-driver",
@@ -795,7 +795,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-cli"
-version = "0.6.0"
+version = "0.7.0"
 dependencies = [
  "ab_glyph",
  "chrono",
@@ -816,7 +816,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-driver"
-version = "0.6.0"
+version = "0.7.0"
 dependencies = [
  "image",
  "postgres",
@@ -830,7 +830,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-python"
-version = "0.6.0"
+version = "0.7.0"
 dependencies = [
  "flowproof-agent",
  "flowproof-cli",
@@ -842,7 +842,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-replay"
-version = "0.6.0"
+version = "0.7.0"
 dependencies = [
  "chrono",
  "flowproof-agent",
@@ -856,7 +856,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-trace"
-version = "0.6.0"
+version = "0.7.0"
 dependencies = [
  "jsonschema",
  "regex",

{flowproof-0.6.0 → flowproof-0.7.0}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/flowproof-driver", "crates/flowproof-trace", "crates/flowproof-replay", "crates/flowproof-agent", "crates/flowproof-adapters", "crates/flowproof-cli", "crates/flowproof-python"]
 
 [workspace.package]
-version = "0.6.0"
+version = "0.7.0"
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/automators-com/flowproof"

{flowproof-0.6.0 → flowproof-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowproof
-Version: 0.6.0
+Version: 0.7.0
 Classifier: Development Status :: 2 - Pre-Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
@@ -8,7 +8,7 @@ Classifier: Programming Language :: Rust
 Classifier: Topic :: Software Development :: Testing
 Requires-Dist: mcp>=1.2 ; python_full_version >= '3.10' and extra == 'mcp'
 Provides-Extra: mcp
-Summary: Generic open-source automation framework for the AI-agent era: automated testing and agentic process automation across web, desktop, and Citrix.
+Summary: Deterministic tests for AI agents: record a run once, replay it with zero LLM calls. Assert which tools an agent called, with which arguments, in which order.
 Author-email: Automators <hello@automators.com>
 License-Expression: Apache-2.0
 Requires-Python: >=3.9
@@ -18,9 +18,12 @@ Project-URL: Repository, https://github.com/automators-com/flowproof
 
 # flowproof
 
-A generic open-source automation framework for the AI-agent era:
-automated testing and agentic process automation across web, desktop,
-and Citrix.
+Run your AI agent once, keep the recording, and assert against it from then
+on. flowproof captures the run at the model boundary - every request and
+every tool-call decision - and serves it back on later runs, so replay makes
+**zero LLM calls**. You assert which tools were called, with which arguments,
+in which order, and which were not. The same engine drives web, desktop and
+Citrix.
 
 **Agents author, a deterministic engine executes.** A flow is described in
 YAML with natural-language steps, recorded once against the live app, and

{flowproof-0.6.0 → flowproof-0.7.0}/README.md

@@ -1,8 +1,11 @@
 # flowproof
 
-A generic open-source automation framework for the AI-agent era:
-automated testing and agentic process automation across web, desktop,
-and Citrix.
+Run your AI agent once, keep the recording, and assert against it from then
+on. flowproof captures the run at the model boundary - every request and
+every tool-call decision - and serves it back on later runs, so replay makes
+**zero LLM calls**. You assert which tools were called, with which arguments,
+in which order, and which were not. The same engine drives web, desktop and
+Citrix.
 
 **Agents author, a deterministic engine executes.** A flow is described in
 YAML with natural-language steps, recorded once against the live app, and

{flowproof-0.6.0 → flowproof-0.7.0}/crates/flowproof-adapters/src/agent_runner.rs

@@ -277,12 +277,54 @@ fn configure(
     child.env("FLOWPROOF_LLM_PROXY", base);
     // The spec's own env goes on LAST so a flow can override any of the
     // above; it knows its client better than this module does.
+    //
+    // Values may reference runtime handles the spec cannot know when it is
+    // written, because the proxy binds an ephemeral port. Without this, an
+    // agent whose client reads a non-standard variable (an AI gateway URL,
+    // say) cannot be pointed at the proxy from the spec at all, and every
+    // such adopter writes the same wrapper script.
     for (key, value) in env {
-        child.env(key, value);
+        child.env(key, substitute_runtime_handles(value, base, env));
     }
     Ok(child)
 }
 
+/// Replace the `${flowproof.*}` handles with values only known at spawn time.
+///
+/// - `${flowproof.proxy_url}` - the model proxy, `/v1` included, the form
+///   OpenAI-compatible clients expect.
+/// - `${flowproof.proxy_url_no_v1}` - the same origin without `/v1`, for a
+///   client that appends its own path (the Anthropic SDK does).
+/// - `${flowproof.mcp_url.<name>}` - the stand-in URL for that MCP server,
+///   for a client that builds its endpoints from a base rather than taking
+///   one URL per server.
+///
+/// Anything else is left untouched: an unknown handle is far more likely to
+/// be a value that happens to look like one than a typo worth failing on,
+/// and `${VAR}` secret refs have already been resolved by this point.
+fn substitute_runtime_handles(value: &str, base: &str, env: &BTreeMap<String, String>) -> String {
+    if !value.contains("${flowproof.") {
+        return value.to_string();
+    }
+    let mut out = value
+        .replace("${flowproof.proxy_url_no_v1}", &anthropic_base(base))
+        .replace("${flowproof.proxy_url}", base);
+    // The MCP stand-in URLs are already in this same map, injected as
+    // `FLOWPROOF_MCP_URL_<NAME>`; this is a friendlier spelling of the same
+    // value, so the two can never disagree.
+    for (key, url) in env {
+        if let Some(name) = key.strip_prefix("FLOWPROOF_MCP_URL_") {
+            out = out.replace(&format!("${{flowproof.mcp_url.{name}}}"), url);
+            // Server names are lowercase in the spec; the env var is upper.
+            out = out.replace(
+                &format!("${{flowproof.mcp_url.{}}}", name.to_ascii_lowercase()),
+                url,
+            );
+        }
+    }
+    out
+}
+
 /// Wait for `child` to the deadline, killing it at the timeout. Returns the
 /// exit status (`None` if killed or unwaitable) and whether it timed out.
 fn wait_to_deadline(
@@ -434,6 +476,77 @@ pub fn run_against_contained(
 
 #[cfg(test)]
 mod tests {
+
+    /// The gap a real adopter hit: their client reads AI_GATEWAY_URL, and
+    /// the proxy's port is not known when the spec is written, so a static
+    /// `agent.env` value could not reach it.
+    #[test]
+    fn the_proxy_url_is_addressable_from_a_spec_env_value() {
+        let env = BTreeMap::new();
+        let got =
+            substitute_runtime_handles("${flowproof.proxy_url}", "http://127.0.0.1:51234/v1", &env);
+        assert_eq!(got, "http://127.0.0.1:51234/v1");
+    }
+
+    /// Some clients append their own `/v1`, so handing them the suffixed
+    /// form produces `/v1/v1`. The no-suffix handle is for those.
+    #[test]
+    fn the_no_v1_handle_strips_the_suffix() {
+        let env = BTreeMap::new();
+        let got = substitute_runtime_handles(
+            "${flowproof.proxy_url_no_v1}",
+            "http://127.0.0.1:51234/v1",
+            &env,
+        );
+        assert_eq!(got, "http://127.0.0.1:51234");
+    }
+
+    /// A client that builds several endpoints off one base (`<base>/mcp`,
+    /// `<base>/mcp-exec/sap`) has no per-server variable to override, so it
+    /// needs the stand-in's base by name.
+    #[test]
+    fn an_mcp_stand_in_is_addressable_by_server_name() {
+        let mut env = BTreeMap::new();
+        env.insert(
+            "FLOWPROOF_MCP_URL_DATAMAKER_EXEC".to_string(),
+            "http://127.0.0.1:44100/mcp".to_string(),
+        );
+        // Upper (as the var is spelled) and lower (as the spec names it).
+        for handle in [
+            "${flowproof.mcp_url.DATAMAKER_EXEC}",
+            "${flowproof.mcp_url.datamaker_exec}",
+        ] {
+            let got = substitute_runtime_handles(handle, "http://127.0.0.1:1/v1", &env);
+            assert_eq!(got, "http://127.0.0.1:44100/mcp", "{handle}");
+        }
+    }
+
+    /// Handles interpolate INTO a larger value, because that is how a base
+    /// URL is actually used.
+    #[test]
+    fn a_handle_substitutes_inside_a_longer_value() {
+        let env = BTreeMap::new();
+        let got = substitute_runtime_handles(
+            "${flowproof.proxy_url_no_v1}/custom/path",
+            "http://127.0.0.1:9/v1",
+            &env,
+        );
+        assert_eq!(got, "http://127.0.0.1:9/custom/path");
+    }
+
+    /// A value that is not a handle must survive untouched - including one
+    /// that merely looks shell-ish. Failing on an unknown handle would be
+    /// worse than passing it through.
+    #[test]
+    fn ordinary_values_and_unknown_handles_pass_through() {
+        let env = BTreeMap::new();
+        for value in ["plain", "$HOME/x", "${flowproof.not_a_handle}"] {
+            assert_eq!(
+                substitute_runtime_handles(value, "http://127.0.0.1:1/v1", &env),
+                value
+            );
+        }
+    }
     use super::*;
     use flowproof_trace::cassette::{Message, ToolCall, Turn, TurnRequest, TurnResponse};
 

{flowproof-0.6.0 → flowproof-0.7.0}/crates/flowproof-cli/src/agent_flow.rs

@@ -1007,7 +1007,8 @@ fn unprotected_tool_warning(spec: &FlowSpec, plan: &Plan, phase: &str) -> Option
          intercept tool execution - {consequence}.\n         \
          For a tool with real side effects, declare it under `mcp:` with a `result:` \
          (flowproof answers it and the real server never runs it), or stub/sandbox it \
-         author-side. See docs/agent-testing.md."
+         author-side. See \
+         https://github.com/automators-com/flowproof/blob/main/docs/agent-testing.md."
     ))
 }
 

flowproof-0.7.0/crates/flowproof-cli/tests/examples_resolve.rs

@@ -0,0 +1,191 @@
+//! Shipped examples must stay honest: every step parses and resolves
+//! through the deterministic rules — no live system needed, no model
+//! backend. This is the same role `documented_grammar_examples_all_
+//! resolve` plays for docs/authoring.md.
+
+use flowproof_agent::{FlowSpec, SuiteManifest};
+
+const FIORI_SPEC: &str = include_str!("../../../examples/fiori/manage-info-records.flow.yaml");
+const FIORI_SUITE: &str = include_str!("../../../examples/fiori/suite.yaml");
+const CONN_TEST_SPEC: &str = include_str!("../../../examples/api/connection-test.flow.yaml");
+/// The npm-path agent quickstart. It is the first example a reader coming
+/// from `npx flowproof` runs, so it has to keep parsing.
+const AGENT_NODE_SPEC: &str = include_str!("../../../examples/agent-demo/weather-node.flow.yaml");
+const AGENT_PY_SPEC: &str = include_str!("../../../examples/agent-demo/weather.flow.yaml");
+const DEMO_SPEC: &str = include_str!("../../../scripts/demo/order-status.flow.yaml");
+
+#[test]
+fn connection_test_example_resolves_with_body_and_headers() {
+    let spec = FlowSpec::parse(CONN_TEST_SPEC).expect("example parses");
+    assert_eq!(spec.app.id(), "api");
+    let actions =
+        flowproof_agent::rules::resolve_step(spec.app.id(), &spec.steps[0]).expect("step resolves");
+    let flowproof_agent::rules::ResolvedAction::AssertApi {
+        headers,
+        body,
+        status,
+        ..
+    } = &actions[0]
+    else {
+        panic!("expected AssertApi");
+    };
+    // Raw refs in the resolved action — resolution is probe-time only.
+    assert_eq!(
+        headers.get("Authorization").map(String::as_str),
+        Some("Bearer ${DM_SESSION_TOKEN}")
+    );
+    let body = body.as_ref().expect("body present");
+    assert_eq!(body["connectionString"], "${TEST_CONN_STRING}");
+    // Pinned to the real DataMaker /connections/test contract the example
+    // mirrors (the api_pipeline mock speaks the same shape): the field is
+    // `type`, and an unsupported provider answers 500. Drift fails here.
+    assert_eq!(body["type"], "postgres");
+    assert_eq!(*status, Some(500));
+}
+
+#[test]
+fn fiori_example_resolves_entirely_via_rules() {
+    let spec = FlowSpec::parse(FIORI_SPEC).expect("example parses");
+    assert_eq!(spec.app.id(), "web", "Fiori is a browser app");
+    assert!(
+        spec.url
+            .as_deref()
+            .unwrap_or_default()
+            .contains("${FIORI_BASE_URL}"),
+        "launch URL stays a ${{VAR}} reference"
+    );
+    for step in &spec.steps {
+        let actions = flowproof_agent::rules::resolve_step(spec.app.id(), step)
+            .unwrap_or_else(|e| panic!("step '{}' must resolve via rules: {e}", step.intent()));
+        assert!(
+            !actions.is_empty(),
+            "step '{}' yields actions",
+            step.intent()
+        );
+    }
+}
+
+#[test]
+fn fiori_suite_manifest_declares_the_data_leg() {
+    let manifest: SuiteManifest = serde_yaml::from_str(FIORI_SUITE).expect("suite.yaml parses");
+    let cmd = manifest.env_from.expect("env_from present");
+    assert!(
+        cmd.contains("datamaker"),
+        "data comes from the DataMaker CLI"
+    );
+    assert!(manifest.env.contains_key("FIORI_BASE_URL"));
+}
+
+/// The quickstart's two agent demos must stay runnable and stay TWINS: the
+/// docs present them as the same flow in two languages, so a change to one
+/// that is not mirrored in the other makes the documentation lie.
+#[test]
+fn both_agent_demos_resolve_and_assert_the_same_thing() {
+    let node = FlowSpec::parse(AGENT_NODE_SPEC).expect("node example parses");
+    let py = FlowSpec::parse(AGENT_PY_SPEC).expect("python example parses");
+
+    for spec in [&node, &py] {
+        assert_eq!(spec.app.id(), "agent");
+        // A mocked tool is what makes replay deterministic here; without a
+        // result the demo would depend on a live timestamp.
+        let mocked = spec
+            .tools
+            .iter()
+            .find(|t| t.name == "get_weather")
+            .expect("get_weather declared");
+        assert!(!mocked.result.is_null(), "get_weather must carry a result:");
+    }
+
+    // Same trajectory, same assertions - only the runtime differs.
+    assert_eq!(
+        node.steps.len(),
+        py.steps.len(),
+        "the two demos must stay the same flow"
+    );
+
+    // The Node demo must not need Python, which is the entire reason it
+    // exists: the npm install path has to stand on its own.
+    let command = node
+        .agent
+        .as_ref()
+        .and_then(|a| a.command.clone())
+        .expect("node demo has a command");
+    assert!(
+        command.starts_with("node "),
+        "the npm-path demo must run under node, got: {command}"
+    );
+    assert!(
+        !command.contains("python"),
+        "the npm-path demo must not need Python: {command}"
+    );
+}
+
+/// The two quickstarts are the most-read prose we have and they are now the
+/// front door for the npm audience, so their YAML must not drift from the file
+/// they claim to quote. A reader who copies a block that no longer parses is
+/// the worst possible first experience. Both the README and
+/// docs/getting-started.md open on the same shipped example, so both are held
+/// to it here.
+#[test]
+fn the_quickstart_quotes_the_shipped_agent_example_verbatim() {
+    const README: &str = include_str!("../../../README.md");
+    const DOC: &str = include_str!("../../../docs/getting-started.md");
+
+    // The shipped file, minus its comment header.
+    let shipped: String = AGENT_NODE_SPEC
+        .lines()
+        .filter(|l| !l.starts_with('#'))
+        .collect::<Vec<_>>()
+        .join("\n");
+
+    for (name, prose) in [("README.md", README), ("docs/getting-started.md", DOC)] {
+        // Pull the fenced block that names the example file.
+        let marker = "```yaml\n# examples/agent-demo/weather-node.flow.yaml\n";
+        let start = prose
+            .find(marker)
+            .unwrap_or_else(|| panic!("{name} quotes the node example"))
+            + marker.len();
+        let block = &prose[start..];
+        let block = &block[..block.find("```").expect("fence closes")];
+
+        assert_eq!(
+            block.trim(),
+            shipped.trim(),
+            "{name} has drifted from examples/agent-demo/weather-node.flow.yaml"
+        );
+
+        // And it must still parse, so the block a reader copies actually runs.
+        FlowSpec::parse(block).expect("the quoted quickstart block parses");
+    }
+}
+
+/// The flow behind the README's demo GIF. The GIF is a capture of this spec
+/// running, so a grammar change that breaks it would silently make the README's
+/// hero image a picture of something that no longer works.
+#[test]
+fn readme_demo_spec_resolves() {
+    let spec = FlowSpec::parse(DEMO_SPEC).expect("demo spec parses");
+    assert_eq!(spec.app.id(), "agent");
+
+    // Deliberately unmocked: the demo's tool returns a deterministic result, so
+    // replay needs no substitution and the run earns no unprotected-tool
+    // warning. That is what keeps the captured output to five lines.
+    let tool = spec
+        .tools
+        .iter()
+        .find(|t| t.name == "lookup_order")
+        .expect("lookup_order declared");
+    assert!(
+        tool.result.is_null(),
+        "the demo tool must stay declaration-only"
+    );
+
+    // Paths are relative to the repository root, because that is where the GIF
+    // runs its commands and therefore what a reader copies.
+    let command = spec
+        .agent
+        .as_ref()
+        .and_then(|a| a.command.clone())
+        .expect("demo has a command");
+    assert_eq!(command, "python3 scripts/demo/support_agent.py");
+}

{flowproof-0.6.0 → flowproof-0.7.0}/crates/flowproof-trace/src/cassette.rs

@@ -203,11 +203,35 @@ fn message_divergence(recorded: &[Message], incoming: &[Message]) -> Option<Stri
                     .collect::<Vec<_>>()
                     .join(", ")
             };
+            // When the SAME tools were called and only their arguments
+            // moved, the two name lists are identical and printing them
+            // says nothing at all - the reader is told something changed
+            // and left to find it. Name the argument PATH instead.
+            let (want_names, got_names) = (names(&want.tool_calls), names(&got.tool_calls));
+            if want_names == got_names {
+                let changes: Vec<String> = want
+                    .tool_calls
+                    .iter()
+                    .zip(&got.tool_calls)
+                    .flat_map(|(a, b)| {
+                        crate::cassette_diff::argument_changes(a, b)
+                            .into_iter()
+                            .map(move |(path, before, after)| {
+                                format!("{}.{path}: recorded {before}, replayed {after}", a.name)
+                            })
+                    })
+                    .collect();
+                if !changes.is_empty() {
+                    return Some(format!(
+                        "message {i} ({}) tool call arguments changed\n  {}",
+                        want.role,
+                        changes.join("\n  "),
+                    ));
+                }
+            }
             return Some(format!(
                 "message {i} ({}) tool calls changed\n  recorded: [{}]\n  replayed: [{}]",
-                want.role,
-                names(&want.tool_calls),
-                names(&got.tool_calls),
+                want.role, want_names, got_names,
             ));
         }
         return Some(format!("message {i} ({}) changed", want.role));
@@ -380,6 +404,68 @@ mod tests {
         }
     }
 
+    /// An argument-only change used to print two IDENTICAL tool-name lists
+    /// ("recorded: [book] / replayed: [book]"), telling the reader that
+    /// something moved but not what. It names the PATH now.
+    #[test]
+    fn an_argument_only_change_names_the_path_that_moved() {
+        let recorded = assistant_with(vec![call("book", r#"{"flight":{"id":"KQ311"},"seats":2}"#)]);
+        let replayed = assistant_with(vec![call("book", r#"{"flight":{"id":"KQ999"},"seats":2}"#)]);
+        let detail =
+            message_divergence(&[recorded], &[replayed]).expect("a change is a divergence");
+        assert!(
+            detail.contains("book.flight.id"),
+            "names the path: {detail}"
+        );
+        assert!(
+            detail.contains("KQ311"),
+            "shows what was recorded: {detail}"
+        );
+        assert!(
+            detail.contains("KQ999"),
+            "shows what was replayed: {detail}"
+        );
+        // The unchanged argument must not be listed as noise.
+        assert!(!detail.contains("seats"), "only the moved path: {detail}");
+    }
+
+    /// An argument that APPEARS is drift too, and the most likely shape of
+    /// a real regression: an agent starts passing something extra.
+    #[test]
+    fn an_added_argument_is_reported_as_absent_before() {
+        let recorded = assistant_with(vec![call("book", r#"{"id":"KQ311"}"#)]);
+        let replayed = assistant_with(vec![call("book", r#"{"id":"KQ311","override":true}"#)]);
+        let detail =
+            message_divergence(&[recorded], &[replayed]).expect("an added argument diverges");
+        assert!(detail.contains("book.override"), "{detail}");
+        assert!(detail.contains("absent"), "{detail}");
+    }
+
+    /// A DIFFERENT tool is a different failure and must keep the name lists,
+    /// which are the useful thing in that case.
+    #[test]
+    fn a_different_tool_still_reports_the_names() {
+        let recorded = assistant_with(vec![call("book", "{}")]);
+        let replayed = assistant_with(vec![call("cancel", "{}")]);
+        let detail =
+            message_divergence(&[recorded], &[replayed]).expect("a different tool diverges");
+        assert!(detail.contains("tool calls changed"), "{detail}");
+        assert!(
+            detail.contains("book") && detail.contains("cancel"),
+            "{detail}"
+        );
+    }
+
+    /// Arguments that are not JSON cannot be diffed field by field. Say the
+    /// whole thing moved rather than pretending to be precise about it.
+    #[test]
+    fn unparseable_arguments_report_the_whole_payload() {
+        let recorded = assistant_with(vec![call("book", "not json")]);
+        let replayed = assistant_with(vec![call("book", "also not json")]);
+        let detail = message_divergence(&[recorded], &[replayed]).expect("still a divergence");
+        assert!(detail.contains("book.arguments"), "{detail}");
+    }
+
     /// A two-turn booking trajectory: the model asks for a tool, the tool
     /// result comes back, the model replies.
     fn booking() -> Cassette {

{flowproof-0.6.0 → flowproof-0.7.0}/crates/flowproof-trace/src/cassette_diff.rs

@@ -271,7 +271,10 @@ fn prompt_change(before: &[Message], after: &[Message]) -> Option<String> {
 ///
 /// Field-level on purpose. Two JSON blobs side by side make a reviewer do
 /// the diffing; `flight.id KQ311 -> KQ999` is the finding itself.
-fn argument_changes(before: &ToolCall, after: &ToolCall) -> Vec<(String, String, String)> {
+pub(crate) fn argument_changes(
+    before: &ToolCall,
+    after: &ToolCall,
+) -> Vec<(String, String, String)> {
     let (Some(old), Some(new)) = (before.arguments_json(), after.arguments_json()) else {
         // Unparseable arguments cannot be compared field by field. Say
         // the whole thing moved rather than pretending to be precise.

{flowproof-0.6.0 → flowproof-0.7.0}/flowproof/__init__.py

@@ -24,7 +24,7 @@ from flowproof.flow import (
     run,
 )
 
-__version__ = "0.6.0"
+__version__ = "0.7.0"
 
 __all__ = [
     "ClarificationNeeded",

{flowproof-0.6.0 → flowproof-0.7.0}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "maturin"
 
 [project]
 name = "flowproof"
-version = "0.6.0"
-description = "Generic open-source automation framework for the AI-agent era: automated testing and agentic process automation across web, desktop, and Citrix."
+version = "0.7.0"
+description = "Deterministic tests for AI agents: record a run once, replay it with zero LLM calls. Assert which tools an agent called, with which arguments, in which order."
 readme = "README.md"
 license = "Apache-2.0"
 requires-python = ">=3.9"

flowproof-0.6.0/crates/flowproof-cli/tests/examples_resolve.rs

@@ -1,72 +0,0 @@
-//! Shipped examples must stay honest: every step parses and resolves
-//! through the deterministic rules — no live system needed, no model
-//! backend. This is the same role `documented_grammar_examples_all_
-//! resolve` plays for docs/authoring.md.
-
-use flowproof_agent::{FlowSpec, SuiteManifest};
-
-const FIORI_SPEC: &str = include_str!("../../../examples/fiori/manage-info-records.flow.yaml");
-const FIORI_SUITE: &str = include_str!("../../../examples/fiori/suite.yaml");
-const CONN_TEST_SPEC: &str = include_str!("../../../examples/api/connection-test.flow.yaml");
-
-#[test]
-fn connection_test_example_resolves_with_body_and_headers() {
-    let spec = FlowSpec::parse(CONN_TEST_SPEC).expect("example parses");
-    assert_eq!(spec.app.id(), "api");
-    let actions =
-        flowproof_agent::rules::resolve_step(spec.app.id(), &spec.steps[0]).expect("step resolves");
-    let flowproof_agent::rules::ResolvedAction::AssertApi {
-        headers,
-        body,
-        status,
-        ..
-    } = &actions[0]
-    else {
-        panic!("expected AssertApi");
-    };
-    // Raw refs in the resolved action — resolution is probe-time only.
-    assert_eq!(
-        headers.get("Authorization").map(String::as_str),
-        Some("Bearer ${DM_SESSION_TOKEN}")
-    );
-    let body = body.as_ref().expect("body present");
-    assert_eq!(body["connectionString"], "${TEST_CONN_STRING}");
-    // Pinned to the real DataMaker /connections/test contract the example
-    // mirrors (the api_pipeline mock speaks the same shape): the field is
-    // `type`, and an unsupported provider answers 500. Drift fails here.
-    assert_eq!(body["type"], "postgres");
-    assert_eq!(*status, Some(500));
-}
-
-#[test]
-fn fiori_example_resolves_entirely_via_rules() {
-    let spec = FlowSpec::parse(FIORI_SPEC).expect("example parses");
-    assert_eq!(spec.app.id(), "web", "Fiori is a browser app");
-    assert!(
-        spec.url
-            .as_deref()
-            .unwrap_or_default()
-            .contains("${FIORI_BASE_URL}"),
-        "launch URL stays a ${{VAR}} reference"
-    );
-    for step in &spec.steps {
-        let actions = flowproof_agent::rules::resolve_step(spec.app.id(), step)
-            .unwrap_or_else(|e| panic!("step '{}' must resolve via rules: {e}", step.intent()));
-        assert!(
-            !actions.is_empty(),
-            "step '{}' yields actions",
-            step.intent()
-        );
-    }
-}
-
-#[test]
-fn fiori_suite_manifest_declares_the_data_leg() {
-    let manifest: SuiteManifest = serde_yaml::from_str(FIORI_SUITE).expect("suite.yaml parses");
-    let cmd = manifest.env_from.expect("env_from present");
-    assert!(
-        cmd.contains("datamaker"),
-        "data comes from the DataMaker CLI"
-    );
-    assert!(manifest.env.contains_key("FIORI_BASE_URL"));
-}