juncture 0.1.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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

//! LLM integration module.
//!
//! This module provides a unified interface for working with various LLM providers
//! including Anthropic, `OpenAI`, and `Ollama`. It implements the `ChatModel` trait
//! which abstracts over different provider APIs while providing a consistent interface.
//!
//! # Features
//!
//! - **Unified API**: Single `ChatModel` trait for all providers
//! - **Streaming support**: Real-time token streaming via `MessageChunk`
//! - **Tool calling**: Native support for function/tool calling
//! - **Error handling**: Comprehensive error types with retry logic
//! - **Provider-specific**: Optimized implementations for each provider
//!
//! # Example
//!
//! ```ignore
//! use juncture::llm::{ChatModel, ChatAnthropic};
//! use juncture::Message;
//!
//! #[tokio::main]
//! async fn main() -> Result<(), Box<dyn std::error::Error>> {
//!     let model = ChatAnthropic::from_env()?;
//!     let messages = vec![
//!         Message::human("Hello, how are you?"),
//!     ];
//!
//!     let response = model.invoke(&messages, None).await?;
//!     // Process response
//!     Ok(())
//! }
//! ```
//!
//! # Module Structure
//!
//! - `trait_`: Core `ChatModel` trait and error types
//! - `message`: Message type definitions and re-exports
//! - `anthropic`: Anthropic Claude provider implementation
//! - `openai`: `OpenAI` GPT provider implementation
//! - `ollama`: Ollama local model provider implementation
//! - `mock`: Mock implementation for testing
//! - `pricing`: Model pricing information
//! - `retry`: Retry wrapper for resilient LLM calls
//! - `structured`: Structured output extraction

// Re-export core types from juncture-core
pub use juncture_core::{
    state::messages::{Content, ContentPart, ImageData, ImageSource, Message, Role, ToolCall},
    stream::{MessageChunk, ToolCallChunk},
};

mod circuit_breaker;
mod message;
mod middleware;
mod mock;
mod pricing;
mod retry;
mod trait_;

// Provider implementations (feature-gated)
#[cfg(feature = "anthropic")]
mod anthropic;

#[cfg(feature = "openai")]
mod openai;

#[cfg(feature = "ollama")]
mod ollama;

#[cfg(feature = "structured-output")]
mod structured;

// Public exports
pub use circuit_breaker::*;
pub use message::*;
pub use middleware::*;
pub use mock::MockChatModel;
pub use pricing::{ModelPricing, PricingTable};
pub use retry::RetryingModel;
pub use trait_::*;

// Provider exports
#[cfg(feature = "anthropic")]
pub use anthropic::ChatAnthropic;

#[cfg(feature = "openai")]
pub use openai::ChatOpenAI;

#[cfg(feature = "ollama")]
pub use ollama::ChatOllama;

#[cfg(feature = "structured-output")]
pub use structured::StructuredOutputModel;

// Rust guideline compliant 2026-05-19