genai 0.5.3

Multi-AI Providers Library for Rust. (OpenAI, Gemini, Anthropic, xAI, Ollama, Groq, DeepSeek, Grok)
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

use derive_more::From;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// A map of HTTP headers (single value per name).
/// Headers can be layered; later values override earlier ones.
///
/// Note: This type keeps a single value per header name, which is the most
/// intuitive behavior for genai. It enables straightforward auth and other
/// overrides.
#[derive(Debug, Default, Clone, From, Serialize, Deserialize)]
#[serde(transparent)]
pub struct Headers {
	inner: HashMap<String, String>,
}

impl Headers {
	/// Merge headers from overlay into self, consuming overlay.
	/// Later values override existing ones.
	/// Use [`Headers::merge_with`] for a borrowed overlay.
	pub fn merge(&mut self, overlay: impl Into<Headers>) {
		let overlay = overlay.into();

		// Insert or replace each single-value override:
		for (k, v) in overlay.inner {
			self.inner.insert(k, v);
		}
	}

	/// Merge headers from overlay into self without consuming it.
	/// Later values override existing ones.
	pub fn merge_with(&mut self, overlay: &Headers) {
		// Insert or replace each single-value override:
		for (k, v) in &overlay.inner {
			self.inner.insert(k.clone(), v.clone());
		}
	}

	/// Apply self on top of target, consuming both, and return the result.
	/// Values in self override those in target.
	pub fn applied_to(self, target: impl Into<Headers>) -> Headers {
		let mut target = target.into();
		for (k, v) in self.inner {
			target.inner.insert(k, v);
		}
		target
	}
}

// region:    --- Froms
impl<K, V> From<(K, V)> for Headers
where
	K: Into<String>,
	V: Into<String>,
{
	fn from((k, v): (K, V)) -> Self {
		let mut inner = HashMap::new();
		inner.insert(k.into(), v.into());
		Headers { inner }
	}
}

impl<K, V> From<Vec<(K, V)>> for Headers
where
	K: Into<String>,
	V: Into<String>,
{
	fn from(vec: Vec<(K, V)>) -> Self {
		let inner = vec.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
		Headers { inner }
	}
}

impl<K, V, const N: usize> From<[(K, V); N]> for Headers
where
	K: Into<String>,
	V: Into<String>,
{
	fn from(arr: [(K, V); N]) -> Self {
		let inner = arr.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
		Headers { inner }
	}
}

// endregion: --- Froms

// region:    --- Iterators

use std::collections::hash_map::{IntoIter, Iter, IterMut};

impl Headers {
	/// Returns an iterator over (name, value) pairs.
	pub fn iter(&self) -> Iter<'_, String, String> {
		self.inner.iter()
	}

	/// Returns a mutable iterator over (name, value) pairs.
	pub fn iter_mut(&mut self) -> IterMut<'_, String, String> {
		self.inner.iter_mut()
	}
}

// IntoIterator for owned Headers
impl IntoIterator for Headers {
	type Item = (String, String);
	type IntoIter = IntoIter<String, String>;

	fn into_iter(self) -> Self::IntoIter {
		self.inner.into_iter()
	}
}

// IntoIterator for &Headers
impl<'a> IntoIterator for &'a Headers {
	type Item = (&'a String, &'a String);
	type IntoIter = Iter<'a, String, String>;

	fn into_iter(self) -> Self::IntoIter {
		self.inner.iter()
	}
}

// IntoIterator for &mut Headers
impl<'a> IntoIterator for &'a mut Headers {
	type Item = (&'a String, &'a mut String);
	type IntoIter = IterMut<'a, String, String>;

	fn into_iter(self) -> Self::IntoIter {
		self.inner.iter_mut()
	}
}

// endregion: --- Iterators