volition-core 0.2.0

Core library for the Volition AI agent
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

// volition-agent-core/src/strategies/complete_task.rs
// Removed unused Agent import
use crate::errors::AgentError;
// Removed unused ChatMessage import
use crate::UserInteraction;
use crate::models::chat::ApiResponse;
use crate::strategies::{NextStep, Strategy};
use anyhow::{Result, anyhow};
use async_trait::async_trait;
use tracing::info;

#[derive(Default)]
pub struct CompleteTaskStrategy;

#[async_trait]
impl<UI: UserInteraction + 'static> Strategy<UI> for CompleteTaskStrategy {
    fn name(&self) -> &'static str {
        "CompleteTask"
    }

    fn initialize_interaction(
        &mut self,
        state: &mut crate::AgentState,
    ) -> Result<NextStep, AgentError> {
        info!("Initializing CompleteTask strategy.");
        Ok(NextStep::CallApi(state.clone()))
    }

    fn process_api_response(
        &mut self,
        state: &mut crate::AgentState,
        response: ApiResponse,
    ) -> Result<NextStep, AgentError> {
        info!("Processing API response for CompleteTask.");
        let choice = response
            .choices
            .into_iter()
            .next()
            .ok_or(AgentError::Api(anyhow!("No choices returned from API")))?;

        state.add_message(choice.message.clone());

        if let Some(tool_calls) = choice.message.tool_calls {
            state.set_tool_calls(tool_calls);
            Ok(NextStep::CallTools(state.clone()))
        } else {
            let final_content = choice
                .message
                .content
                .unwrap_or_else(|| "Task completed.".to_string());
            Ok(NextStep::Completed(final_content))
        }
    }

    fn process_tool_results(
        &mut self,
        state: &mut crate::AgentState,
        results: Vec<crate::ToolResult>,
    ) -> Result<NextStep, AgentError> {
        info!("Processing tool results for CompleteTask.");
        state.add_tool_results(results);
        Ok(NextStep::CallApi(state.clone()))
    }

    fn process_delegation_result(
        &mut self,
        _state: &mut crate::AgentState,
        _result: crate::DelegationResult,
    ) -> Result<NextStep, AgentError> {
        Err(AgentError::Strategy(
            "Delegation not supported by CompleteTaskStrategy".to_string(),
        ))
    }
}