a3s-code-core 3.0.0

A3S Code Core - Embeddable AI agent library with tool execution
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

use super::execution_state::ExecutionLoopState;
use super::{AgentEvent, AgentLoop};
use crate::llm::{Message, ToolCall};
use tokio::sync::mpsc;

impl AgentLoop {
    /// Handles pre-execution guards that feed an immediate tool result back to the LLM.
    ///
    /// Returns `true` when the tool call has been fully handled and should not continue
    /// through safety gating or execution.
    pub(super) async fn handle_tool_preflight_guard(
        &self,
        tool_call: &ToolCall,
        state: &mut ExecutionLoopState,
        event_tx: &Option<mpsc::Sender<AgentEvent>>,
    ) -> anyhow::Result<bool> {
        if let Some((duplicate_count, error_msg)) = state.duplicate_tool_call(
            &tool_call.name,
            &tool_call.args,
            self.config.duplicate_tool_call_threshold,
        ) {
            tracing::warn!(
                tool_name = tool_call.name.as_str(),
                duplicate_count = duplicate_count,
                threshold = self.config.duplicate_tool_call_threshold,
                "Duplicate tool call threshold exceeded"
            );

            if let Some(tx) = event_tx {
                tx.send(AgentEvent::Error {
                    message: error_msg.clone(),
                })
                .await
                .ok();
            }

            state
                .messages
                .push(Message::tool_result(&tool_call.id, &error_msg, true));
            return Ok(true);
        }

        if let Some(parse_error) = tool_call.args.get("__parse_error").and_then(|v| v.as_str()) {
            let parse_outcome =
                state.record_parse_error(parse_error, self.config.max_parse_retries);
            tracing::warn!(
                tool = tool_call.name.as_str(),
                parse_error_count = parse_outcome.count,
                max_parse_retries = self.config.max_parse_retries,
                "Malformed tool arguments from LLM"
            );

            if let Some(tx) = event_tx {
                tx.send(AgentEvent::ToolEnd {
                    id: tool_call.id.clone(),
                    name: tool_call.name.clone(),
                    output: parse_outcome.output.clone(),
                    exit_code: 1,
                    metadata: None,
                    error_kind: None,
                })
                .await
                .ok();
            }

            state.messages.push(Message::tool_result(
                &tool_call.id,
                &parse_outcome.output,
                true,
            ));

            if let Some(msg) = parse_outcome.fatal_message {
                tracing::error!("{}", msg);
                if let Some(tx) = event_tx {
                    tx.send(AgentEvent::Error {
                        message: msg.clone(),
                    })
                    .await
                    .ok();
                }
                anyhow::bail!(msg);
            }
            return Ok(true);
        }

        state.reset_parse_errors();
        Ok(false)
    }
}