data-flow-control 0.1.0__tar.gz → 0.1.3__tar.gz

{data_flow_control-0.1.0 → data_flow_control-0.1.3}/Cargo.lock

@@ -1594,7 +1594,7 @@ dependencies = [
 
 [[package]]
 name = "passant-cli"
-version = "0.1.0"
+version = "0.1.3"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -1606,7 +1606,7 @@ dependencies = [
 
 [[package]]
 name = "passant-core"
-version = "0.1.0"
+version = "0.1.3"
 dependencies = [
  "anyhow",
  "criterion",
@@ -1624,7 +1624,7 @@ dependencies = [
 
 [[package]]
 name = "passant-py"
-version = "0.1.0"
+version = "0.1.3"
 dependencies = [
  "passant-core",
  "pyo3",

{data_flow_control-0.1.0 → data_flow_control-0.1.3}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["passant-core", "passant-py"]
 resolver = "2"
 
 [workspace.package]
-version = "0.1.0"
+version = "0.1.3"
 edition = "2024"
 license = "MIT"
 authors = ["Charlie Summers"]

data_flow_control-0.1.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dataflowcontrol
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{data_flow_control-0.1.0 → data_flow_control-0.1.3}/PKG-INFO

@@ -1,12 +1,14 @@
 Metadata-Version: 2.4
 Name: data-flow-control
-Version: 0.1.0
+Version: 0.1.3
 Requires-Dist: boto3>=1.26.0
 Requires-Dist: duckdb>=1.3.0
+Requires-Dist: langchain>=1.3,<2
+Requires-Dist: langchain-core>=1.3,<2
 Requires-Dist: numpy>=1.24.4
 Requires-Dist: sqlglot==28.3.0
 Requires-Dist: clickhouse-connect>=0.7.0 ; extra == 'clickhouse'
-Requires-Dist: datafusion>=53.0.0 ; python_full_version >= '3.10' and extra == 'datafusion'
+Requires-Dist: datafusion>=53.0.0 ; extra == 'datafusion'
 Requires-Dist: pyarrow>=14.0.0 ; extra == 'datafusion'
 Requires-Dist: maturin>=1.7.0 ; extra == 'dev'
 Requires-Dist: pytest>=8.4.2 ; extra == 'dev'
@@ -16,5 +18,7 @@ Provides-Extra: clickhouse
 Provides-Extra: datafusion
 Provides-Extra: dev
 Provides-Extra: postgres
+License-File: LICENSE
 Summary: Rust-backed Data Flow Control rewrite engine
-Requires-Python: >=3.9
+License-Expression: MIT
+Requires-Python: >=3.10

{data_flow_control-0.1.0 → data_flow_control-0.1.3}/passant-core/src/catalog.rs

@@ -16,6 +16,7 @@ use crate::policy::{PolicyIr, Resolution};
 use crate::policy_compile::{
     ParsedPolicyConstraint, parse_policy_constraint, parse_policy_constraint_with_registry,
 };
+use crate::sql::collect_query_projection_column_names;
 
 /// Catalog facts supplied at policy registration time (from any adapter snapshot).
 #[derive(Debug, Default, Clone)]
@@ -389,6 +390,24 @@ fn validate_pgn_policy_parsed(
         dimension_columns.insert(TableKey::new(alias), columns.clone());
         dimension_columns.insert(TableKey::new(base), columns);
     }
+    for (alias, query_sql) in dimension_queries {
+        let columns = collect_query_projection_column_names(query_sql)
+            .map_err(|err| {
+                RewriteError::catalog_with_context(
+                    ErrorKind::UnknownColumn,
+                    format!(
+                        "Dimension subquery '{alias}' has invalid projection for catalog validation: {err}"
+                    ),
+                    Some(alias.clone()),
+                    None,
+                    Some(constraint.to_string()),
+                    Some("catalog_validation"),
+                )
+            })?
+            .into_iter()
+            .collect::<HashSet<_>>();
+        dimension_columns.insert(TableKey::new(alias), columns);
+    }
 
     let source_names = sources
         .iter()
@@ -495,6 +514,7 @@ fn validate_pgn_policy_parsed(
             &table_key,
             dimension_tables,
             dimension_aliases,
+            dimension_queries,
             &dimension_columns,
         ) {
             if !columns.contains(&column_key) {
@@ -544,6 +564,7 @@ fn resolve_dimension_columns<'a>(
     table_key: &TableKey,
     dimension_tables: &[String],
     dimension_aliases: &HashMap<String, String>,
+    dimension_queries: &HashMap<String, String>,
     dimension_columns: &'a HashMap<TableKey, HashSet<String>>,
 ) -> Option<&'a HashSet<String>> {
     if dimension_tables
@@ -552,7 +573,13 @@ fn resolve_dimension_columns<'a>(
     {
         return dimension_columns.get(table_key);
     }
+    if dimension_queries.contains_key(table_key.as_str()) {
+        return dimension_columns.get(table_key);
+    }
     if let Some(base) = dimension_aliases.get(table_key.as_str()) {
+        if dimension_queries.contains_key(base) {
+            return dimension_columns.get(table_key);
+        }
         return dimension_columns.get(&TableKey::new(base));
     }
     dimension_columns.get(table_key)
@@ -1054,6 +1081,63 @@ mod tests {
             .expect("dimension alias column should validate");
     }
 
+    #[test]
+    fn validates_constraint_columns_through_dimension_subquery_alias() {
+        let catalog = sample_catalog();
+        let mut dimension_aliases = HashMap::new();
+        dimension_aliases.insert("u".to_string(), "u".to_string());
+        let mut dimension_queries = HashMap::new();
+        dimension_queries.insert(
+            "u".to_string(),
+            "(SELECT user_id FROM session_user)".to_string(),
+        );
+        let policy = PolicyIr::Pgn {
+            sources: vec!["foo".into()],
+            required_sources: Vec::new(),
+            dimension_tables: Vec::new(),
+            dimension_aliases,
+            dimension_queries,
+            sink: None,
+            sink_alias: None,
+            source_aliases: HashMap::new(),
+            constraint: "max(foo.id) > 1 AND u.user_id = 1".into(),
+            on_fail: Resolution::Remove,
+            description: None,
+        };
+        catalog
+            .validate_policy(&policy, &sample_registry())
+            .expect("dimension subquery alias column should validate");
+    }
+
+    #[test]
+    fn rejects_unknown_dimension_subquery_column() {
+        let catalog = sample_catalog();
+        let mut dimension_aliases = HashMap::new();
+        dimension_aliases.insert("u".to_string(), "u".to_string());
+        let mut dimension_queries = HashMap::new();
+        dimension_queries.insert(
+            "u".to_string(),
+            "(SELECT user_id FROM session_user)".to_string(),
+        );
+        let policy = PolicyIr::Pgn {
+            sources: vec!["foo".into()],
+            required_sources: Vec::new(),
+            dimension_tables: Vec::new(),
+            dimension_aliases,
+            dimension_queries,
+            sink: None,
+            sink_alias: None,
+            source_aliases: HashMap::new(),
+            constraint: "max(foo.id) > 1 AND u.missing = 1".into(),
+            on_fail: Resolution::Remove,
+            description: None,
+        };
+        let err = catalog
+            .validate_policy(&policy, &sample_registry())
+            .unwrap_err();
+        assert_eq!(err.kind(), ErrorKind::UnknownColumn);
+    }
+
     #[test]
     fn rejects_unknown_dimension_column() {
         let mut catalog = sample_catalog();

{data_flow_control-0.1.0 → data_flow_control-0.1.3}/passant-core/src/policy_store/compiled.rs

@@ -140,6 +140,7 @@ impl PolicyStore {
                 &compiled.ast,
                 policy.dimension_tables(),
                 policy.dimension_aliases(),
+                policy.dimension_queries(),
                 &source_key_set,
             )
         });
@@ -226,6 +227,7 @@ pub(crate) fn compile_branch_policy(
                 &constraint_ast,
                 policy.dimension_tables(),
                 policy.dimension_aliases(),
+                policy.dimension_queries(),
                 &source_key_set,
             )
         };

{data_flow_control-0.1.0 → data_flow_control-0.1.3}/passant-core/src/rewrite_stats.rs

@@ -36,7 +36,7 @@ impl From<RewriteStats> for RewriteStatsExport {
     }
 }
 
-/// Optional rewrite instrumentation counters (see `passant/docs/performance.md`).
+/// Optional rewrite instrumentation counters (see `developer-docs/performance.md`).
 #[derive(Debug, Default, Clone)]
 pub struct RewriteStats {
     pub total_policies: usize,

{data_flow_control-0.1.0 → data_flow_control-0.1.3}/passant-core/src/rewriter/dimensions.rs

@@ -56,6 +56,7 @@ pub(crate) fn inject_policy_dimensions(
             constraint,
             dimension_tables,
             dimension_aliases,
+            dimension_queries,
             &source_keys,
         )?
     };
@@ -175,11 +176,9 @@ pub(crate) fn inject_policy_dimensions(
             append_dimension_join(select, factor, join.on)?;
             joined_keys.insert(table_key);
         } else {
-            skipped.push(alias.clone());
-            warnings.push(format!(
-                "Dimension subquery '{alias}' was not joined: no equality link to the query or \
-                 another dimension in the policy constraint and catalog row count is not 1"
-            ));
+            warnings.push(expansion_warning(alias));
+            append_dimension_join(select, factor, None)?;
+            joined_keys.insert(table_key);
         }
     }
 
@@ -405,9 +404,10 @@ pub(crate) fn compile_dimension_join_plan(
     constraint_ast: &Expr,
     dimension_tables: &[String],
     dimension_aliases: &HashMap<String, String>,
+    dimension_queries: &HashMap<String, String>,
     source_keys: &HashSet<TableKey>,
 ) -> Option<DimensionJoinPlan> {
-    if dimension_tables.is_empty() {
+    if dimension_tables.is_empty() && dimension_queries.is_empty() {
         return None;
     }
     let mut dimension_keys = HashSet::new();
@@ -419,6 +419,9 @@ pub(crate) fn compile_dimension_join_plan(
             }
         }
     }
+    for alias in dimension_queries.keys() {
+        dimension_keys.insert(TableKey::new(alias));
+    }
     let mut source_conditions = HashMap::new();
     let mut dimension_edges = Vec::new();
     collect_dimension_join_graph(
@@ -454,17 +457,24 @@ fn dimension_join_graph(
     constraint: &str,
     dimension_tables: &[String],
     dimension_aliases: &HashMap<String, String>,
+    dimension_queries: &HashMap<String, String>,
     source_keys: &HashSet<TableKey>,
 ) -> Result<(HashMap<TableKey, Expr>, Vec<DimensionJoinEdge>), RewriteError> {
     let constraint = preprocess_policy_constraint(constraint);
     let expr = parse_projection_expr(&constraint).map_err(|err| {
         RewriteError::unsupported_statement(format!("dimension join analysis: {err}"))
     })?;
-    let plan = compile_dimension_join_plan(&expr, dimension_tables, dimension_aliases, source_keys)
-        .unwrap_or(DimensionJoinPlan {
-            source_conditions: HashMap::new(),
-            dimension_edges: Vec::new(),
-        });
+    let plan = compile_dimension_join_plan(
+        &expr,
+        dimension_tables,
+        dimension_aliases,
+        dimension_queries,
+        source_keys,
+    )
+    .unwrap_or(DimensionJoinPlan {
+        source_conditions: HashMap::new(),
+        dimension_edges: Vec::new(),
+    });
     Ok((plan.source_conditions, plan.dimension_edges))
 }
 

{data_flow_control-0.1.0 → data_flow_control-0.1.3}/passant-core/src/sql/columns.rs

@@ -1,10 +1,13 @@
 //! Qualified-column extraction from constraint ASTs.
 
 use sqlparser::ast::{
-    Array, Expr, Function, FunctionArg, FunctionArgExpr, FunctionArguments, Map, Subscript,
+    Array, Expr, Function, FunctionArg, FunctionArgExpr, FunctionArguments, Map, SelectItem,
+    SetExpr, Statement, Subscript,
 };
 
-use crate::identifiers::QualifiedColumn;
+use crate::diagnostics::RewriteError;
+use crate::identifiers::{ColumnName, QualifiedColumn};
+use crate::parser::parse_query;
 
 pub fn collect_qualified_columns_from_expr(expr: &Expr) -> Vec<QualifiedColumn> {
     let mut found = Vec::new();
@@ -12,6 +15,66 @@ pub fn collect_qualified_columns_from_expr(expr: &Expr) -> Vec<QualifiedColumn>
     found
 }
 
+/// Output column names from a dimension subquery SELECT list.
+pub fn collect_query_projection_column_names(query_sql: &str) -> Result<Vec<String>, RewriteError> {
+    let select = dimension_subquery_select(query_sql)?;
+    let mut names = Vec::new();
+    for item in &select.projection {
+        match item {
+            SelectItem::UnnamedExpr(expr) => {
+                let Some(name) = projection_column_name(expr) else {
+                    return Err(RewriteError::unsupported_statement(format!(
+                        "dimension subquery projection must name columns explicitly: {item}"
+                    )));
+                };
+                names.push(ColumnName::new(name).key());
+            }
+            SelectItem::ExprWithAlias { alias, .. } => {
+                names.push(ColumnName::new(alias.value.as_str()).key());
+            }
+            SelectItem::Wildcard(_) | SelectItem::QualifiedWildcard(_, _) => {
+                return Err(RewriteError::unsupported_statement(
+                    "dimension subquery projections with * are not supported for catalog validation",
+                ));
+            }
+        }
+    }
+    if names.is_empty() {
+        return Err(RewriteError::unsupported_statement(
+            "dimension subquery must project at least one column",
+        ));
+    }
+    Ok(names)
+}
+
+fn dimension_subquery_select(query_sql: &str) -> Result<sqlparser::ast::Select, RewriteError> {
+    let statement = parse_query(query_sql)?;
+    let Statement::Query(query) = statement else {
+        return Err(RewriteError::unsupported_statement(
+            "dimension subquery must be a query",
+        ));
+    };
+    select_from_set_expr(*query.body)
+}
+
+fn select_from_set_expr(body: SetExpr) -> Result<sqlparser::ast::Select, RewriteError> {
+    match body {
+        SetExpr::Select(select) => Ok(*select),
+        SetExpr::Query(query) => select_from_set_expr(*query.body),
+        other => Err(RewriteError::unsupported_statement(format!(
+            "dimension subquery must be a SELECT, got {other}"
+        ))),
+    }
+}
+
+fn projection_column_name(expr: &Expr) -> Option<String> {
+    match expr {
+        Expr::Identifier(ident) => Some(ident.value.clone()),
+        Expr::CompoundIdentifier(parts) => parts.last().map(|ident| ident.value.clone()),
+        _ => None,
+    }
+}
+
 fn visit_expr(expr: &Expr, found: &mut Vec<QualifiedColumn>) {
     if let Some(column) = QualifiedColumn::from_expr(expr) {
         found.push(column);

{data_flow_control-0.1.0 → data_flow_control-0.1.3}/passant-core/src/sql/mod.rs

@@ -25,5 +25,5 @@ pub use builders::{
     query_from_select, sanitize_projection_alias, scalar_subquery, statement_from_query,
     string_concat, string_literal, table_alias, table_factor, with_ctes, wrap_table_with_filter,
 };
-pub use columns::collect_qualified_columns_from_expr;
+pub use columns::{collect_qualified_columns_from_expr, collect_query_projection_column_names};
 pub use expr::{rename_table_refs, replace_expr_subtrees, unqualify_table_refs};

{data_flow_control-0.1.0 → data_flow_control-0.1.3}/passant-core/tests/gaps/dimensions.rs

@@ -132,6 +132,43 @@ fn dimension_alias_qualifiers_rewrite_after_injection() {
     );
 }
 
+#[test]
+fn dimension_subquery_alias_in_constraint_rewrites() {
+    let mut catalog = TableCatalog::new();
+    catalog.register_table("foo", vec!["id".to_string()]);
+    catalog.register_table("session_user", vec!["user_id".to_string()]);
+    catalog.register_table_row_count("session_user", 1);
+    let mut dimension_aliases = HashMap::new();
+    dimension_aliases.insert("u".to_string(), "u".to_string());
+    let mut dimension_queries = HashMap::new();
+    dimension_queries.insert(
+        "u".to_string(),
+        "(SELECT user_id FROM session_user)".to_string(),
+    );
+    let policy = PolicyIr::Pgn {
+        sources: vec!["foo".to_string()],
+        required_sources: Vec::new(),
+        dimension_tables: Vec::new(),
+        dimension_aliases,
+        dimension_queries,
+        sink: None,
+        sink_alias: None,
+        source_aliases: HashMap::new(),
+        constraint: "max(foo.id) > 0 AND u.user_id = 1".to_string(),
+        on_fail: Resolution::Remove,
+        description: None,
+    };
+    let sql = rewrite_with_catalog("SELECT foo.id FROM foo", &[policy], catalog);
+    assert!(
+        sql.contains("u.user_id = 1"),
+        "expected dimension subquery alias in rewritten SQL: {sql}"
+    );
+    assert!(
+        sql.contains("SELECT user_id FROM session_user") || sql.contains("session_user"),
+        "expected dimension subquery injected: {sql}"
+    );
+}
+
 #[test]
 fn catalog_rejects_unknown_dimension_table() {
     let mut catalog = TableCatalog::new();

{data_flow_control-0.1.0 → data_flow_control-0.1.3}/pyproject.toml

@@ -1,11 +1,15 @@
 [project]
 name = "data-flow-control"
-version = "0.1.0"
+version = "0.1.3"
 description = "Rust-backed Data Flow Control rewrite engine"
-requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
 dependencies = [
     "boto3>=1.26.0",
     "duckdb>=1.3.0",
+    "langchain>=1.3,<2",
+    "langchain-core>=1.3,<2",
     "numpy>=1.24.4",
     "sqlglot==28.3.0",
 ]
@@ -23,7 +27,7 @@ clickhouse = [
     "clickhouse-connect>=0.7.0",
 ]
 datafusion = [
-    "datafusion>=53.0.0; python_version >= '3.10'",
+    "datafusion>=53.0.0",
     "pyarrow>=14.0.0",
 ]
 
@@ -45,10 +49,16 @@ markers = [
     "postgres: requires psycopg and Passant docker postgres service",
     "clickhouse: requires clickhouse-connect and Passant docker clickhouse service",
     "umbra: requires psycopg and Passant docker umbra service",
-    "flock: optional Flock DuckDB extension tests (see passant/scripts/setup_flock.sh)",
+    "flock: optional Flock DuckDB extension tests (see scripts/setup_flock.sh)",
     "ui_extension: optional extended_duckdb UI stream union tests",
+    "langchain: LangChain tool-use integration tests",
 ]
 
+[tool.ruff.lint.per-file-ignores]
+"python/tests/test_langchain*.py" = ["E402"]
+"python/tests/test_call_tool_with_dataflow.py" = ["E402"]
+
 [tool.ruff]
 line-length = 100
-target-version = "py39"
+target-version = "py310"
+exclude = ["extended_duckdb"]

data_flow_control-0.1.3/python/data_flow_control/__init__.py

@@ -0,0 +1,31 @@
+from ._passant import PassantRewriteError
+from .connection import dfc
+from .dialect import Dialect
+from .options import RewriteOptions, UiUpdateMode
+from .policy import Policy, Resolution
+from .ui import UiViolationEvent
+
+__all__ = [
+    "create_agent",
+    "dfc",
+    "Dialect",
+    "langchain_dfc",
+    "Policy",
+    "Resolution",
+    "RewriteOptions",
+    "UiUpdateMode",
+    "PassantRewriteError",
+    "UiViolationEvent",
+]
+
+
+def __getattr__(name: str):
+    if name == "create_agent":
+        from .langchain import create_agent as _create_agent
+
+        return _create_agent
+    if name == "langchain_dfc":
+        from .langchain import langchain_dfc as _langchain_dfc
+
+        return _langchain_dfc
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

data_flow_control-0.1.3/python/data_flow_control/langchain/__init__.py

@@ -0,0 +1,8 @@
+"""LangChain integration for Passant data flow control."""
+
+from __future__ import annotations
+
+from .agent import create_agent, store_langchain_agent_config
+from .wrapper import LangChainDFC, langchain_dfc
+
+__all__ = ["LangChainDFC", "create_agent", "langchain_dfc", "store_langchain_agent_config"]

data_flow_control-0.1.3/python/data_flow_control/langchain/agent.py

@@ -0,0 +1,114 @@
+"""LangChain agent configuration for Passant wrapping."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from langchain.agents import create_agent as _langchain_create_agent
+
+from .middleware import CALL_TOOL_WITH_DATAFLOW_NAME
+from .tool_spec import ToolSpec, tools_to_specs
+
+PASSANT_CONFIG_ATTR = "_passant_langchain_config"
+
+
+class UnsupportedAgentError(ValueError):
+    """Raised when an agent cannot be wrapped through public LangChain hooks."""
+
+
+@dataclass
+class AgentConfig:
+    model: Any
+    tools: list[Any]
+    middleware: list[Any] = field(default_factory=list)
+    system_prompt: str | None = None
+    create_agent_kwargs: dict[str, Any] = field(default_factory=dict)
+
+
+def create_agent(
+    model: Any,
+    tools: list[Any],
+    *,
+    middleware: list[Any] | None = None,
+    system_prompt: str | None = None,
+    **create_agent_kwargs: Any,
+) -> Any:
+    """Create a LangChain agent and attach Passant wrap configuration."""
+    agent = _langchain_create_agent(
+        model=model,
+        tools=tools,
+        middleware=tuple(middleware or ()),
+        system_prompt=system_prompt,
+        **create_agent_kwargs,
+    )
+    return store_langchain_agent_config(
+        agent,
+        model=model,
+        tools=tools,
+        middleware=middleware,
+        system_prompt=system_prompt,
+        **create_agent_kwargs,
+    )
+
+
+def store_langchain_agent_config(
+    agent: Any,
+    *,
+    model: Any,
+    tools: list[Any],
+    middleware: list[Any] | None = None,
+    system_prompt: str | None = None,
+    **create_agent_kwargs: Any,
+) -> Any:
+    """Attach Passant agent configuration using only public create_agent inputs."""
+    config = AgentConfig(
+        model=model,
+        tools=list(tools),
+        middleware=list(middleware or []),
+        system_prompt=system_prompt,
+        create_agent_kwargs=dict(create_agent_kwargs),
+    )
+    setattr(agent, PASSANT_CONFIG_ATTR, config)
+    return agent
+
+
+def resolve_agent_config(agent: Any) -> AgentConfig:
+    stored = getattr(agent, PASSANT_CONFIG_ATTR, None)
+    if stored is not None:
+        return stored
+
+    raise UnsupportedAgentError(
+        "Could not resolve LangChain agent configuration for the provided agent. "
+        "Create the agent with data_flow_control.langchain.create_agent(...), or call "
+        "store_langchain_agent_config(agent, model=..., tools=...) after create_agent(...). "
+        "Passant does not introspect private LangGraph state."
+    )
+
+
+def build_wrapped_agent(
+    config: AgentConfig,
+    *,
+    visible_tools: list[Any],
+    middleware: list[Any],
+) -> Any:
+    wrapped = _langchain_create_agent(
+        model=config.model,
+        tools=visible_tools,
+        system_prompt=config.system_prompt,
+        middleware=[*config.middleware, *middleware],
+        **config.create_agent_kwargs,
+    )
+    setattr(wrapped, PASSANT_CONFIG_ATTR, config)
+    return wrapped
+
+
+def specs_from_agent_tools(
+    tools: list[Any],
+    *,
+    output_schemas: dict[str, Any] | None,
+) -> list[ToolSpec]:
+    filtered = [
+        tool for tool in tools if getattr(tool, "name", None) != CALL_TOOL_WITH_DATAFLOW_NAME
+    ]
+    return tools_to_specs(filtered, output_schemas=output_schemas)