cognis-core 0.2.0

Core traits and types for the Cognis LLM framework
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

pub mod assign;
pub mod base;
pub mod batch;
pub mod batch_processor;
pub mod binding;
pub mod branch;
pub mod cache;
pub mod config;
pub mod configurable;
pub mod each;
pub mod error_handling;
pub mod events;
pub mod ext;
pub mod fallbacks;
pub mod graph;
pub mod history;
pub mod lambda;
pub mod middleware;
pub mod parallel;
pub mod passthrough;
pub mod pipe;
pub mod pipeline;
pub mod rate_limit;
pub mod retry;
pub mod router;
pub mod router_ext;
pub mod schema;
pub mod scoped_callbacks;
pub mod sequence;
pub mod serialization;
pub mod timeout;
pub mod tracing;
pub mod typed;

use std::pin::Pin;

use futures::Stream;
use serde_json::Value;

use crate::error::Result;

/// A pinned, boxed stream of runnable results.
pub type RunnableStream = Pin<Box<dyn Stream<Item = Result<Value>> + Send>>;

// Re-exports
pub use assign::{RunnableAssign, RunnablePick};
pub use base::Runnable;
pub use batch::{batch_invoke, RunnableBatch};
pub use batch_processor::{
    batch_process, BatchConfig, BatchItemResult, BatchProgress, BatchResult, ChunkIterator,
    RunnableBatchProcessor,
};
pub use binding::RunnableBinding;
pub use branch::RunnableBranch;
pub use cache::{
    CacheConfig, CacheEntry, CacheInvalidator, CacheKey, CacheStats, CachedRunnable,
    EvictionPolicy, RunnableCache,
};
pub use config::{
    ensure_config, get_config_list, merge_configs, patch_config, ConfigPatch, RunnableConfig,
};
pub use configurable::{
    ConfigurableAlternatives, ConfigurableField, ConfigurableFieldType, ConfigurableSpec,
    RunnableConfigurableFields,
};
pub use each::RunnableEach;
pub use error_handling::{
    CircuitBreaker, CircuitState, ClassifiedError, ErrorAction, ErrorChain, ErrorClassifier,
    ErrorHandler, ErrorKind, MapErrorHandler, PatternErrorClassifier, RecoveryHandler,
};
pub use events::{EventEmitter, EventFilter, EventTrace, RunEvent, RunEventType};
pub use ext::RunnableExt;
pub use fallbacks::{with_fallbacks, RunnableWithFallbacks};
pub use graph::{
    AsciiExporter, Branch, DotExporter, DotOptions, Edge, Graph, GraphEdge, GraphNode,
    MermaidExporter, Node, NodeData, NodeType, RunnableGraph,
};
pub use history::{ConfigurableFieldSpec, RunnableWithMessageHistory};
pub use lambda::RunnableLambda;
pub use middleware::{
    LoggingMiddleware, MiddlewareAction, MiddlewareChain, RetryMiddleware, RunnableMiddleware,
    RunnableWithMiddleware, TimingMiddleware, TransformMiddleware, ValidationMiddleware,
};
pub use parallel::RunnableParallel;
pub use passthrough::RunnablePassthrough;
pub use pipe::{pipe as pipe_fn, PipeBuilder, RunnablePipe, RunnableRef};
pub use pipeline::{
    ParallelPipeline, Pipeline, PipelineBuilder, PipelineMetrics, PipelineResult, PipelineStage,
};
pub use rate_limit::{
    ConcurrencyGuard, ConcurrencyLimiter, RateLimitConfig, RateLimiter, RunnableRateLimit,
    RunnableThrottle, SlidingWindowCounter,
};
pub use retry::RunnableRetry;
pub use router::{RouterRunnable, RunnableFnBranch, RunnableRouter};
pub use router_ext::{
    ConditionalBranch, ContentRouter, FallbackRouter, KeyRouter, RegexRouter, RoutingTable,
};
pub use schema::{
    EventData, RunnableSchema, SchemaContract, SchemaError, SchemaField, SchemaInference,
    SchemaType, SchemaValidationResult, StreamEvent,
};
pub use scoped_callbacks::{
    merge_callback_configs, with_callbacks, CallbackDispatcher, CallbackEvent, CallbackScope,
    RunnableWithCallbacks, ScopeGuard, ScopedCallbackConfig,
};
pub use sequence::RunnableSequence;
pub use serialization::{
    ConfigDiff, ConfigMigration, ConfigRegistry, ConfigSchema, ParamSpec, ParamType,
    SerializableConfig, SerializableConfigBuilder,
};
pub use timeout::{RunnableDeadline, RunnableTimeout, TimeoutBehavior, TimeoutConfig};
pub use tracing::{
    CompactTraceFormatter, JsonTraceFormatter, SpanResult, TextTraceFormatter, TraceCollector,
    TraceEntry, TraceExporter, TraceFormatter, TraceLevel, TraceSpan,
};
pub use typed::{DynRunnable, FromDynRunnable, TypedRunnable, TypedSequence, TypedStream};

/// Creates a `RunnableSequence` from a list of runnables.
///
/// # Example
/// ```ignore
/// let seq = chain!(lambda1, lambda2, lambda3);
/// ```
#[macro_export]
macro_rules! chain {
    ($($step:expr),+ $(,)?) => {
        $crate::runnables::RunnableSequence::new(vec![
            $(std::sync::Arc::new($step) as std::sync::Arc<dyn $crate::runnables::Runnable>,)+
        ])
    };
}