hippox 0.7.0

🦛A reliable, autonomous LLM runtime and skill orchestration engine, Capable of processing natural language and automatically executing OS-native atomic skills, fundamentally enabling the LLM to truly take over the computer.
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

//! Core WorkflowExecutor implementation
use super::types::*;
use crate::driver_scheduler::DriverScheduler;
use crate::prompts::{build_driver_md_prompt, build_react_prompt};
use crate::{execute_batch_with_categories, execute_chain_with_categories, execute_plan_and_execute_with_categories, execute_react_with_categories};
use hippox_drivers::{DriverCallback, Executor};
use std::sync::Arc;
const MAX_NUMBER_OF_REACT: usize = 10;
#[derive(Debug, Clone)]
pub(crate) struct WorkflowExecutor {
    pub(crate) mode: WorkflowMode,
    pub(crate) executor: Executor,
    pub(crate) max_iterations: usize,
    pub(crate) task_id: Option<String>,
    pub(crate) workflow_callback: Option<Arc<dyn WorkflowCallback>>,
    pub(crate) driver_callback: Option<Arc<dyn DriverCallback>>,
}
impl WorkflowExecutor {
    pub fn new(mode: WorkflowMode) -> Self {
        Self { mode, executor: Executor::new(), max_iterations: MAX_NUMBER_OF_REACT, task_id: None, workflow_callback: None, driver_callback: None }
    }
    pub fn with_driver_callback(mut self, driver_callback: Arc<dyn DriverCallback>) -> Self {
        self.driver_callback = Some(driver_callback);
        self
    }
    pub fn get_driver_callback(&self) -> Option<Arc<dyn DriverCallback>> {
        self.driver_callback.clone()
    }
    pub fn with_task_id(mut self, task_id: String) -> Self {
        self.task_id = Some(task_id);
        self
    }
    pub fn get_task_id(&self) -> Option<&str> {
        self.task_id.as_deref()
    }
    pub fn with_workflow_callback(mut self, callback: Arc<dyn WorkflowCallback>) -> Self {
        self.workflow_callback = Some(callback);
        self
    }
    pub fn with_max_iterations(mut self, max: usize) -> Self {
        self.max_iterations = max;
        self
    }
    pub fn get_mode(&self) -> WorkflowMode {
        self.mode
    }
    pub fn get_executor(&self) -> &Executor {
        &self.executor
    }
    pub fn get_workflow_callback(&self) -> &Option<Arc<dyn WorkflowCallback>> {
        &self.workflow_callback
    }
    pub async fn execute_with_categories(
        &self,
        scheduler: &DriverScheduler,
        input: &str,
        categories: &[String],
        disabled_drivers: Option<&[String]>,
    ) -> WorkflowExecutionResult {
        match self.mode {
            WorkflowMode::ReAct => execute_react_with_categories(self, scheduler, input, categories, disabled_drivers).await,
            WorkflowMode::Batch => execute_batch_with_categories(self, scheduler, input, categories, disabled_drivers).await,
            WorkflowMode::Chain => execute_chain_with_categories(self, scheduler, input, categories, disabled_drivers).await,
            WorkflowMode::PlanAndExecute => execute_plan_and_execute_with_categories(self, scheduler, input, categories, disabled_drivers).await,
        }
    }
    pub fn extract_json(text: &str) -> String {
        if let Some(start) = text.find("```json") {
            let after_start = &text[start + 7..];
            if let Some(end) = after_start.find("```") {
                return after_start[..end].trim().to_string();
            }
        }
        if let Some(start) = text.find("```") {
            let after_start = &text[start + 3..];
            if let Some(end) = after_start.find("```") {
                return after_start[..end].trim().to_string();
            }
        }
        if let Some(start) = text.find('{') {
            if let Some(end) = text.rfind('}') {
                return text[start..=end].to_string();
            }
        }
        text.to_string()
    }
}