kwaak 0.19.0

Run a team of autonomous agents on your code, right from your terminal
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

use std::{borrow::Cow, sync::Arc};

use async_trait::async_trait;
use derive_builder::Builder;
use serde::Deserialize;
use swiftide::{
    chat_completion::{self, Tool, ToolCall, ToolOutput, ToolSpec, errors::ToolError},
    traits::AgentContext,
};

use crate::agent::{running_agent::RunningAgent, session::Session};

/// A tool that delegates to an agent
///
/// For convenience, its assumed the agent is already set up (a `RunningAgent`).
///
/// The tool takes a tool spec, agent and session during creating, so that it can be utilized to
/// delegate to any agent.
///
/// After delegation, the agent invoking the tool is stopped, but not destroyed.
#[derive(Clone, Builder)]
pub struct DelegateAgent {
    session: Arc<Session>,
    agent: RunningAgent,

    tool_spec: ToolSpec,
}

impl DelegateAgent {
    #[must_use]
    pub fn builder() -> DelegateAgentBuilder {
        DelegateAgentBuilder::default()
    }

    pub async fn delegate_agent(
        &self,
        _context: &dyn AgentContext,
        task: &str,
    ) -> Result<ToolOutput, ToolError> {
        self.session.swap_agent(self.agent.clone())?;
        self.agent.query(task).await?;

        tracing::info!("Delegated task to agent");
        Ok(ToolOutput::stop())
    }
}

#[derive(Deserialize)]
struct DelegateArgs {
    task: String,
}

#[async_trait]
impl Tool for DelegateAgent {
    async fn invoke(
        &self,
        agent_context: &dyn AgentContext,
        tool_call: &ToolCall,
    ) -> Result<ToolOutput, ToolError> {
        let Some(args) = tool_call.args() else {
            return Err(ToolError::missing_arguments(format!(
                "No arguments provided for {}",
                self.name()
            )));
        };

        let args: DelegateArgs = serde_json::from_str(&args)?;
        return self.delegate_agent(agent_context, &args.task).await;
    }

    fn tool_spec(&self) -> chat_completion::ToolSpec {
        self.tool_spec.clone()
    }

    fn name(&self) -> Cow<'_, str> {
        self.tool_spec().name.into()
    }
}