cognis-core 0.1.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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use async_trait::async_trait;
use serde_json::Value;

use crate::error::Result;
use crate::runnables::base::Runnable;
use crate::runnables::config::RunnableConfig;

use super::base::OutputParser;

/// Parses comma-separated values from LLM output.
pub struct CommaSeparatedListOutputParser;

impl OutputParser for CommaSeparatedListOutputParser {
    fn parse(&self, text: &str) -> Result<Value> {
        let items: Vec<Value> = text
            .split(',')
            .map(|s| Value::String(s.trim().to_string()))
            .filter(|v| v.as_str() != Some(""))
            .collect();
        Ok(Value::Array(items))
    }

    fn get_format_instructions(&self) -> Option<String> {
        Some(
            "Your response should be a list of comma separated values, \
             eg: `foo, bar, baz`"
                .into(),
        )
    }

    fn parser_type(&self) -> &str {
        "comma_separated_list"
    }
}

#[async_trait]
impl Runnable for CommaSeparatedListOutputParser {
    fn name(&self) -> &str {
        "CommaSeparatedListOutputParser"
    }

    async fn invoke(&self, input: Value, _config: Option<&RunnableConfig>) -> Result<Value> {
        let text = match &input {
            Value::String(s) => s.clone(),
            other => other.to_string(),
        };
        self.parse(&text)
    }
}

/// Parses numbered list items from LLM output (e.g., "1. foo\n2. bar").
pub struct NumberedListOutputParser;

impl OutputParser for NumberedListOutputParser {
    fn parse(&self, text: &str) -> Result<Value> {
        let items: Vec<Value> = text
            .lines()
            .filter_map(|line| {
                let trimmed = line.trim();
                // Match patterns like "1. item" or "1) item"
                let rest = trimmed
                    .strip_prefix(|c: char| c.is_ascii_digit())
                    .and_then(|s| {
                        // Skip remaining digits
                        let s = s.trim_start_matches(|c: char| c.is_ascii_digit());
                        s.strip_prefix(". ").or_else(|| s.strip_prefix(") "))
                    });
                rest.map(|s| Value::String(s.trim().to_string()))
            })
            .collect();
        Ok(Value::Array(items))
    }

    fn get_format_instructions(&self) -> Option<String> {
        Some(
            "Your response should be a numbered list, eg:\n\
             1. foo\n\
             2. bar\n\
             3. baz"
                .into(),
        )
    }

    fn parser_type(&self) -> &str {
        "numbered_list"
    }
}

#[async_trait]
impl Runnable for NumberedListOutputParser {
    fn name(&self) -> &str {
        "NumberedListOutputParser"
    }

    async fn invoke(&self, input: Value, _config: Option<&RunnableConfig>) -> Result<Value> {
        let text = match &input {
            Value::String(s) => s.clone(),
            other => other.to_string(),
        };
        self.parse(&text)
    }
}

/// Parses markdown list items (lines starting with `- ` or `* `).
pub struct MarkdownListOutputParser;

impl OutputParser for MarkdownListOutputParser {
    fn parse(&self, text: &str) -> Result<Value> {
        let items: Vec<Value> = text
            .lines()
            .filter_map(|line| {
                let trimmed = line.trim();
                trimmed
                    .strip_prefix("- ")
                    .or_else(|| trimmed.strip_prefix("* "))
                    .map(|s| Value::String(s.trim().to_string()))
            })
            .collect();
        Ok(Value::Array(items))
    }

    fn get_format_instructions(&self) -> Option<String> {
        Some(
            "Your response should be a markdown list, eg:\n\
             - foo\n\
             - bar\n\
             - baz"
                .into(),
        )
    }

    fn parser_type(&self) -> &str {
        "markdown_list"
    }
}

#[async_trait]
impl Runnable for MarkdownListOutputParser {
    fn name(&self) -> &str {
        "MarkdownListOutputParser"
    }

    async fn invoke(&self, input: Value, _config: Option<&RunnableConfig>) -> Result<Value> {
        let text = match &input {
            Value::String(s) => s.clone(),
            other => other.to_string(),
        };
        self.parse(&text)
    }
}