Merge remote-tracking branch 'origin/main'

Author: nschaetti

.github/workflows/rust.yml

@@ -0,0 +1,22 @@
+name: Rust
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Build
+      run: cargo build --verbose
+    - name: Run tests
+      run: cargo test --verbose

config/pulse-default.yaml

@@ -0,0 +1,8 @@
+colors:
+  foreground: white
+  background: black
+  primary: cyan
+
+widgets:
+  textbox_prefix: "[ "
+  textbox_suffix: " ]"

python/example_langchain_toolcalling.py

@@ -0,0 +1,51 @@
+from langchain_fireworks import ChatFireworks
+from langchain_core.tools import tool
+from langchain_core.messages import HumanMessage
+
+# 1. Définir un tool simple
+@tool
+def multiply(a: int, b: int) -> int:
+    """Multiply two integers."""
+    return a * b
+
+
+# 2. Initialiser le modèle
+llm = ChatFireworks(
+    model="accounts/fireworks/models/minimax-m2p1",
+    temperature=0.0,
+)
+
+# 3. Lier les tools au modèle
+llm_with_tools = llm.bind_tools([multiply])
+
+# 4. Message utilisateur
+messages = [
+    HumanMessage(content="What is 6 times 7?")
+]
+
+# 5. Appel du modèle
+response = llm_with_tools.invoke(messages)
+
+# 6. Vérifier si le modèle demande un tool
+if response.tool_calls:
+    for tool_call in response.tool_calls:
+        if tool_call["name"] == "multiply":
+            args = tool_call["args"]
+            result = multiply.invoke(args)
+
+            print("Tool result:", result)
+
+            # 7. Réinjecter le résultat au modèle (optionnel ici)
+            final = llm.invoke([
+                messages[0],
+                response,
+                {
+                    "role": "tool",
+                    "tool_call_id": tool_call["id"],
+                    "content": str(result),
+                }
+            ])
+
+            print("Final answer:", final.content)
+else:
+    print("Model answer:", response.content)

src/cli.rs

@@ -26,7 +26,23 @@ pub enum Commands {
     Embeddings {
         #[arg(short = 't', long = "text")]
         text_path: PathBuf,
-        #[arg(short = 'm', long = "model", default_value = "nomic-ai/nomic-embed-text-v1.5")]
+        #[arg(
+            short = 'm',
+            long = "model",
+            default_value = "nomic-ai/nomic-embed-text-v1.5"
+        )]
         model: String,
     },
+    Calc {
+        #[arg(short = 'p', long = "prompt", default_value = "What is 6 times 7?")]
+        prompt: String,
+        #[arg(
+            short = 'm',
+            long = "model",
+            default_value = "accounts/fireworks/models/minimax-m2p1"
+        )]
+        model: String,
+        #[arg(short = 't', long = "temperature", default_value_t = 0.0)]
+        temperature: f64,
+    },
 }

src/commands/calc.rs

@@ -0,0 +1,68 @@
+use std::error::Error;
+
+use turingflow::rchain::chat_models::{ChatFireworks, ChatMessage};
+use turingflow::rchain::tools::{ToolDefinition, ToolFunction, ToolParam, ToolParamType};
+
+fn multiply(a: i64, b: i64) -> i64 {
+    a * b
+}
+
+pub fn run_calc(
+    prompt: impl Into<String>,
+    model: impl Into<String>,
+    temperature: f64,
+) -> Result<(), Box<dyn Error>> {
+    let tool = ToolDefinition::from_function(
+        ToolFunction::new("multiply", "Multiply two integers.")
+            .with_param(ToolParam::new(
+                "a",
+                ToolParamType::Integer,
+                true,
+                Some("First factor.".to_string()),
+            ))
+            .with_param(ToolParam::new(
+                "b",
+                ToolParamType::Integer,
+                true,
+                Some("Second factor.".to_string()),
+            )),
+    );
+
+    let llm = ChatFireworks::new(model, temperature)?.bind_tools(vec![tool]);
+    let user_message = ChatMessage::user_text(prompt.into());
+    let response = llm.invoke_messages(&[user_message.clone()])?;
+
+    if response.tool_calls.is_empty() {
+        println!("Model answer: {}", response.content);
+        return Ok(());
+    }
+
+    for tool_call in &response.tool_calls {
+        if tool_call.name != "multiply" {
+            continue;
+        }
+        let a = tool_call
+            .args
+            .get("a")
+            .and_then(|value| value.as_i64())
+            .ok_or("Missing integer argument 'a' for multiply")?;
+        let b = tool_call
+            .args
+            .get("b")
+            .and_then(|value| value.as_i64())
+            .ok_or("Missing integer argument 'b' for multiply")?;
+        let result = multiply(a, b);
+
+        println!("Tool result: {}", result);
+
+        let final_response = llm.invoke_messages(&[
+            user_message.clone(),
+            ChatMessage::assistant_from_ai(&response),
+            ChatMessage::tool_result(tool_call.id.clone(), result.to_string()),
+        ])?;
+
+        println!("Final answer: {}", final_response.content);
+    }
+
+    Ok(())
+}

src/commands/image.rs

@@ -41,8 +41,8 @@ pub fn run_image(
     ]);
 
     let response = llm.invoke(&[message])?;
-    let parsed: serde_json::Value = serde_json::from_str(&response.content)
-        .map_err(|_| "LLM response is not valid JSON")?;
+    let parsed: serde_json::Value =
+        serde_json::from_str(&response.content).map_err(|_| "LLM response is not valid JSON")?;
     let pretty = serde_json::to_string_pretty(&parsed)?;
     println!("{}", pretty);
 

src/commands/mod.rs

@@ -1,2 +1,3 @@
-pub mod image;
+pub mod calc;
 pub mod embeddings;
+pub mod image;

src/lib.rs

@@ -1,2 +1,3 @@
+pub mod pulse;
 pub mod rchain;
 pub mod tfpv1;

src/main.rs

@@ -24,6 +24,13 @@ fn main() -> Result<(), Box<dyn Error>> {
         Commands::Embeddings { text_path, model } => {
             commands::embeddings::run_embeddings(text_path, model)?;
         }
+        Commands::Calc {
+            prompt,
+            model,
+            temperature,
+        } => {
+            commands::calc::run_calc(prompt, model, temperature)?;
+        }
     }
 
     Ok(())

src/pulse/app.rs

@@ -0,0 +1,44 @@
+use std::error::Error;
+use std::path::Path;
+
+use crate::pulse::theme::Theme;
+use crate::pulse::widget::WidgetNode;
+
+#[derive(Debug, Clone)]
+pub struct PulseApp {
+    root: WidgetNode,
+    theme: Theme,
+}
+
+impl PulseApp {
+    pub fn new(root: impl Into<WidgetNode>) -> Self {
+        Self {
+            root: root.into(),
+            theme: Theme::default(),
+        }
+    }
+
+    pub fn with_theme(mut self, theme: Theme) -> Self {
+        self.theme = theme;
+        self
+    }
+
+    pub fn with_theme_file(mut self, path: impl AsRef<Path>) -> Result<Self, Box<dyn Error>> {
+        self.theme = Theme::from_file(path)?;
+        Ok(self)
+    }
+
+    pub fn render_to_string(&self) -> String {
+        let mut output = String::new();
+        output.push_str(&format!(
+            "theme(fg={}, bg={}, primary={})\n",
+            self.theme.colors.foreground, self.theme.colors.background, self.theme.colors.primary
+        ));
+        output.push_str(&self.root.render_lines(&self.theme).join("\n"));
+        output
+    }
+
+    pub fn run(&self) {
+        println!("{}", self.render_to_string());
+    }
+}