libtenx 0.0.4

A library for building AI-assisted coding tools, with session management, patch validation, and multiple model support.
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

use async_trait::async_trait;
use serde::{Deserialize, Serialize};
use tokio::sync::mpsc;

use super::ModelProvider;
use crate::{
    config::Config, dialect::DialectProvider, events::Event, session::ModelResponse,
    session::Session, Result,
};

use std::collections::HashMap;

/// A dummy usage struct for testing purposes.
#[derive(Debug, Serialize, Deserialize, Clone, Default, PartialEq, Eq)]
pub struct DummyUsage {
    pub dummy_counter: u32,
}

impl DummyUsage {
    pub fn values(&self) -> HashMap<String, u64> {
        let mut map = HashMap::new();
        map.insert("dummy_counter".to_string(), self.dummy_counter as u64);
        map
    }

    pub fn totals(&self) -> (u64, u64) {
        (self.dummy_counter as u64, self.dummy_counter as u64)
    }
}

/// A dummy model for testing purposes.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DummyModel {
    model_response: Result<ModelResponse>,
}

impl DummyModel {
    /// Creates a new Dummy model with predefined operations.
    pub fn from_model_response(mr: ModelResponse) -> Self {
        Self {
            model_response: Ok(mr),
        }
    }
}

impl Default for DummyModel {
    fn default() -> Self {
        Self {
            model_response: Ok(ModelResponse::default()),
        }
    }
}

#[async_trait]
impl ModelProvider for DummyModel {
    fn name(&self) -> String {
        "dummy".to_string()
    }

    fn api_model(&self) -> String {
        "dummy".to_string()
    }

    async fn send(
        &mut self,
        _config: &Config,
        _state: &Session,
        _sender: Option<mpsc::Sender<Event>>,
    ) -> Result<ModelResponse> {
        let mut resp = self.model_response.clone()?;
        resp.usage = Some(super::Usage::Dummy(DummyUsage { dummy_counter: 1 }));
        Ok(resp)
    }

    fn render(&self, config: &Config, session: &Session) -> Result<String> {
        let dialect = config.dialect()?;
        let mut out = String::new();

        // Add immutable context
        out.push_str("=== Context ===\n");
        out.push_str(&dialect.render_context(config, session)?);
        out.push('\n');

        // Add request context
        for (i, step) in session.steps().iter().enumerate() {
            out.push_str(&format!("=== Step {} ===\n", i));
            out.push_str(&dialect.render_step_request(config, session, i)?);
            if let Some(_response) = &step.model_response {
                out.push_str(&dialect.render_step_response(config, session, i)?);
            }
            out.push('\n');
        }

        Ok(out)
    }
}