aidale-layer 0.1.0

Built-in layers for Aidale (logging, retry, caching, etc.)
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

# aidale-layer

Built-in middleware layers for Aidale (logging, retry, caching, etc.).

[![Crates.io](https://img.shields.io/crates/v/aidale-layer.svg)](https://crates.io/crates/aidale-layer)
[![Documentation](https://docs.rs/aidale-layer/badge.svg)](https://docs.rs/aidale-layer)
[![License](https://img.shields.io/badge/license-MIT%2FApache--2.0-blue.svg)](../LICENSE)

## Overview

`aidale-layer` provides composable middleware layers following the AOP (Aspect-Oriented Programming) pattern:

- **LoggingLayer**: Request/response logging with timing
- **RetryLayer**: Exponential backoff retry with jitter
- More layers coming soon (caching, rate limiting, etc.)

## Available Layers

### LoggingLayer

Logs all requests and responses with timing information:

```rust
use aidale_layer::LoggingLayer;

let executor = RuntimeExecutor::builder(provider)
    .layer(LoggingLayer::new())
    .finish();
```

Output example:
```
[AI Request] model=gpt-3.5-turbo messages=2
[AI Response] duration=1.2s tokens=150
```

### RetryLayer

Automatic retry with exponential backoff:

```rust
use aidale_layer::RetryLayer;
use std::time::Duration;

let executor = RuntimeExecutor::builder(provider)
    .layer(RetryLayer::new()
        .with_max_retries(3)
        .with_initial_delay(Duration::from_millis(100))
        .with_max_delay(Duration::from_secs(10)))
    .finish();
```

Features:
- Configurable max retries
- Exponential backoff with jitter
- Configurable delay bounds
- Only retries on transient errors (5xx, network errors)

## Composition

Layers are composed in order from outermost to innermost:

```rust
let executor = RuntimeExecutor::builder(provider)
    .layer(LoggingLayer::new())      // Executes first (outer)
    .layer(RetryLayer::new()          // Executes second
        .with_max_retries(3))
    .finish();
```

Execution flow:
```
Request  → LoggingLayer → RetryLayer → Provider
Response ← LoggingLayer ← RetryLayer ← Provider
```

## Zero-Cost Abstraction

Layers use compile-time composition with static dispatch:

- No virtual dispatch (no `dyn Trait`)
- No heap allocation for layer chain
- All composition resolved at compile time
- Type-level recursion for layer nesting

This means **zero runtime overhead** compared to manual implementation!

## Usage

Via the main `aidale` crate:

```toml
[dependencies]
aidale = { version = "0.1", features = ["layers"] }
```

Directly:

```toml
[dependencies]
aidale-layer = "0.1"
aidale-core = "0.1"
```

## Custom Layers

Implement the `Layer` trait from `aidale-core`:

```rust
use aidale_core::{Layer, Provider, ChatCompletionParams, ChatCompletionResponse};
use async_trait::async_trait;

pub struct MyCustomLayer {
    // Your fields
}

#[async_trait]
impl<P: Provider> Layer<P> for MyCustomLayer {
    async fn call(
        &self,
        provider: &P,
        model: &str,
        params: ChatCompletionParams,
    ) -> Result<ChatCompletionResponse> {
        // Pre-processing
        println!("Before request");

        // Call next layer or provider
        let response = provider.chat_completion(model, params).await?;

        // Post-processing
        println!("After request");

        Ok(response)
    }
}
```

## Planned Layers

- **CachingLayer**: Response caching with TTL
- **RateLimitLayer**: Request rate limiting
- **CircuitBreakerLayer**: Circuit breaker pattern
- **MetricsLayer**: Prometheus metrics export
- **TracingLayer**: OpenTelemetry distributed tracing

## Related Crates

- [`aidale-core`](../aidale-core) - Core traits and runtime
- [`aidale-provider`](../aidale-provider) - Provider implementations
- [`aidale-plugin`](../aidale-plugin) - Plugin system

## License

MIT OR Apache-2.0