Runtime Rust
para AI-Protocol.
Runtime Rust de alto rendimiento para AI-Protocol (v1.0.1). Ruta: manifiesto → Pipeline → HttpTransport. Workspace E/P (ai-lib-core + ai-lib-contact), 13 códigos de error V2 y módulos por feature.
ai-lib-rust = "1.0.1" Características clave
Códigos de error V2 y feature flags
13 códigos de error estándar V2 para un manejo coherente entre proveedores. Módulos por feature: 7 opcionales más un meta-feature full para builds mínimos o completos.
Pipeline basado en operadores
Las respuestas en streaming pasan por operadores componibles: Decoder → Selector → Accumulator → FanOut → EventMapper. Cada etapa se configura por protocolo.
Protocolo + Pipeline
AiClient carga manifiestos y ejecuta el pipeline de operadores
(Decoder → Selector → Accumulator → EventMapper). Compatibilidad con rutas V1 y V2.
Workspace E/P
ai-lib-core (ejecución) y ai-lib-contact (política) se publican
como crates separados; ai-lib-rust reexporta una fachada estable.
Resilience
Backpressure max_inflight integrado en AiClient. Reintentos,
límite de tasa y circuit breaker viven en ai_lib_rust::resilience opt-in.
Embeddings y vectores
EmbeddingClient with vector operations ?cosine similarity, Euclidean distance, dot product. Construye búsqueda semántica y RAG de forma nativa.
Caché y lotes
Caché de respuestas con TTL (memoria). Ejecución por lotes con concurrencia, timeout y varias estrategias configurables.
Sistema de plugins
Arquitectura de plugins extensible con hooks y cadena de middleware. Añade comportamiento sin modificar el núcleo. Guardrails para filtrado de contenido y detección de PII.
API simple y unificada
El mismo código funciona con los 37+ proveedores. Solo cambia el identificador del modelo ?el manifiesto del protocolo gestiona el resto: endpoint, autenticación, mapeo de parámetros y formato de streaming.
El patrón builder ofrece una API fluida para construir peticiones. Los resultados en stream
llegan como StreamingEvent unificados, independientemente del proveedor.
use ai_lib_rust::{AiClient, Message, StreamingEvent};
use futures::StreamExt;
// Works with ANY provider ?protocol-driven
let client = AiClient::new(
"anthropic/claude-3-5-sonnet"
).await?;
// Builder pattern for chat requests
let mut stream = client.chat()
.messages(vec![Message::user("Hello")])
.temperature(0.7)
.max_tokens(1000)
.stream()
.execute_stream()
.await?;
// Unified streaming events
while let Some(event) = stream.next().await {
match event? {
StreamingEvent::PartialContentDelta { content, .. }
=> print!("{content}"),
StreamingEvent::StreamEnd { stats, .. }
=> println!("\nTokens: {}",
stats.total_tokens),
_ => {} // ToolCall, Metadata, etc.
}
} Arquitectura interna
Cinco capas desde la API de usuario hasta el transporte HTTP. El pipeline de streaming es el corazón del sistema.
Resumen de módulos
client/ + error_code/
AiClient, AiClientBuilder, ChatRequestBuilder, lógica de ejecución, motor de políticas, comprobaciones previas, clasificación de errores, CallStats, CancelHandle.
protocol/
ProtocolLoader (local/URL/GitHub), validador JSON Schema, estructura ProtocolManifest, compilación de UnifiedRequest y tipos de configuración.
pipeline/
Decoder (SSE, JSON Lines), Selector (JSONPath), Accumulator (llamadas a herramientas), FanOut, EventMapper y operadores Retry / Fallback.
transport/
HttpTransport (reqwest), resolución de API key (keyring + variables de entorno), proxy/timeout y middleware.
resilience/
Circuit breaker (open/half-open/closed), limitador token bucket y backpressure max-inflight.
embeddings/
EmbeddingClient, EmbeddingClientBuilder y operaciones vectoriales (similitud coseno, distancia euclídea, producto punto).
cache/ + batch/
CacheManager con TTL (MemoryCache, NullCache). BatchCollector y BatchExecutor con control de concurrencia y varias estrategias.
plugins/ + guardrails/ + structured/
Plugin trait, PluginRegistry, HookManager y cadena de middleware. Guardrails con filtros por palabra/patrón y detección de PII.