juncture 0.2.0

Typed state machine framework for LLM agents - Rust implementation of LangGraph
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

//! Tools module for LLM function calling
//!
//! This module provides the Tool trait and related infrastructure for
//! executing function calls from LLM agents, including:
//!
//! - [`Tool`] trait for defining executable tools
//! - [`ToolNode`] for executing tools from AI messages
//! - [`ToolInterceptor`] for pre/post execution hooks
//! - [`ToolCallTransformer`] for argument transformation
//! - [`ToolError`] for error handling
//! - [`tools_condition`] for conditional routing
//!
//! # Example
//!
//! ```ignore
//! use juncture::tools::{Tool, ToolNode};
//! use async_trait::async_trait;
//! use serde_json::json;
//!
//! struct MyTool;
//!
//! #[async_trait]
//! impl Tool for MyTool {
//!     fn name(&self) -> &str {
//!         "my_tool"
//!     }
//!
//!     fn description(&self) -> &str {
//!         "Does something useful"
//!     }
//!
//!     fn schema(&self) -> serde_json::Value {
//!         json!({
//!             "type": "object",
//!             "properties": {
//!                 "input": {"type": "string"}
//!             },
//!             "required": ["input"]
//!         })
//!     }
//!
//!     async fn invoke(&self, input: serde_json::Value) -> Result<String, ToolError> {
//!         Ok("Result".to_string())
//!     }
//! }
//!
//! // Create tool node
//! let tool_node = ToolNode::new(vec![Box::new(MyTool)]);
//!
//! // Execute tools from AI messages
//! let results = tool_node.execute(&messages).await?;
//! ```

pub mod builtin;
mod condition;
mod error;
mod interceptor;
mod node;
mod permission;
mod runtime;
mod trait_;
mod transformer;
mod validation;

pub use builtin::ThinkTool;
#[cfg(feature = "reqwest")]
pub use builtin::WebFetchTool;
pub use condition::{tools_condition, tools_condition_from_messages};
pub use error::ToolError;
pub use interceptor::{CompositeInterceptor, NopToolInterceptor, ToolInterceptor};
pub use node::{ToolExecutionTrace, ToolNode, ToolNodeConfig};
pub use permission::*;
pub use runtime::ToolRuntime;
pub use trait_::{StatefulTool, Tool, ToolDefinition};
pub use transformer::{CompositeTransformer, NopToolTransformer, ToolCallTransformer};
pub use validation::ValidationNode;

// Rust guideline compliant 2026-05-19