lash_core/tool_dispatch/
context.rs

1use std::sync::{Arc, Mutex};
2
3use tokio::sync::mpsc;
4
5use crate::plugin::{
6    PluginSession, SessionGraphService, SessionLifecycleService, SessionStateService,
7};
8use crate::{
9    PreparedToolCall, SessionEvent, ToolCallRecord, ToolFailure, ToolFailureClass, ToolProvider,
10    ToolResult, ToolSurface,
11};
12
13#[derive(Clone, Default)]
14pub(crate) struct CheckpointMessageBuffer {
15    queue: Arc<Mutex<Vec<crate::PluginMessage>>>,
16}
17
18impl CheckpointMessageBuffer {
19    pub(crate) fn enqueue(&self, messages: Vec<crate::PluginMessage>) -> Result<(), String> {
20        let mut queue = self
21            .queue
22            .lock()
23            .map_err(|_| "checkpoint message buffer poisoned".to_string())?;
24        queue.extend(messages);
25        Ok(())
26    }
27
28    pub(crate) fn drain(&self) -> Result<Vec<crate::PluginMessage>, String> {
29        let mut queue = self
30            .queue
31            .lock()
32            .map_err(|_| "checkpoint message buffer poisoned".to_string())?;
33        Ok(queue.drain(..).collect())
34    }
35}
36
37#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
38pub struct ToolHostEventEffectOutcome {
39    pub resource_type: String,
40    pub alias: String,
41    pub event: String,
42    pub source_type: String,
43    pub source_key: String,
44    pub occurrence_id: String,
45    #[serde(default)]
46    pub payload: serde_json::Value,
47    pub started_process_ids: Vec<String>,
48}
49
50#[derive(Clone, Default)]
51pub(crate) struct ToolHostEventOutcomeBuffer {
52    queue: Arc<Mutex<Vec<ToolHostEventEffectOutcome>>>,
53}
54
55impl ToolHostEventOutcomeBuffer {
56    pub(crate) fn enqueue(&self, outcome: ToolHostEventEffectOutcome) -> Result<(), String> {
57        let mut queue = self
58            .queue
59            .lock()
60            .map_err(|_| "tool host event outcome buffer poisoned".to_string())?;
61        queue.push(outcome);
62        Ok(())
63    }
64
65    pub(crate) fn drain(&self) -> Result<Vec<ToolHostEventEffectOutcome>, String> {
66        let mut queue = self
67            .queue
68            .lock()
69            .map_err(|_| "tool host event outcome buffer poisoned".to_string())?;
70        Ok(queue.drain(..).collect())
71    }
72}
73
74#[derive(Clone)]
75pub struct ToolDispatchContext<'run> {
76    pub plugins: Arc<PluginSession>,
77    pub tools: Arc<dyn ToolProvider>,
78    pub surface: Arc<ToolSurface>,
79    pub sessions: Arc<dyn SessionStateService>,
80    pub session_lifecycle: Arc<dyn SessionLifecycleService>,
81    pub session_graph: Arc<dyn SessionGraphService>,
82    pub processes: Arc<dyn crate::ProcessService>,
83    pub process_cancel_ability: Arc<dyn crate::ProcessCancelAbility>,
84    pub host_event_router: Option<crate::HostEventRouter>,
85    pub(crate) effect_controller: crate::runtime::RuntimeEffectControllerHandle<'run>,
86    pub(crate) direct_completions: crate::DirectCompletionClient<'run>,
87    pub(crate) parent_invocation: Option<crate::RuntimeInvocation>,
88    pub session_id: String,
89    pub agent_frame_id: crate::AgentFrameId,
90    pub event_tx: mpsc::Sender<SessionEvent>,
91    pub(crate) checkpoint_messages: CheckpointMessageBuffer,
92    pub(crate) host_event_outcomes: ToolHostEventOutcomeBuffer,
93    pub attachment_store: Arc<dyn crate::AttachmentStore>,
94    pub turn_context: crate::TurnContext,
95}
96
97impl<'run> ToolDispatchContext<'run> {
98    pub fn process_scope(&self) -> crate::ProcessOpScope<'_> {
99        crate::ProcessOpScope::new(self.effect_controller.scoped())
100            .with_parent_invocation(self.parent_invocation.clone())
101            .with_agent_frame_id(Some(self.agent_frame_id.clone()))
102    }
103}
104
105#[derive(Clone)]
106pub(crate) struct ToolDispatchOutcome {
107    pub record: ToolCallRecord,
108}
109
110pub(crate) enum ToolPreparationOutcome {
111    Prepared(PreparedToolCall),
112    Completed(Box<ToolDispatchOutcome>),
113}
114
115pub(super) fn completed_preparation(outcome: ToolDispatchOutcome) -> ToolPreparationOutcome {
116    ToolPreparationOutcome::Completed(Box::new(outcome))
117}
118pub(super) fn outcome(
119    tool_name: String,
120    args: serde_json::Value,
121    result: ToolResult,
122    duration_ms: u64,
123) -> ToolDispatchOutcome {
124    let record = ToolCallRecord {
125        call_id: None,
126        tool: tool_name,
127        args,
128        output: result.into_output(),
129        duration_ms,
130    };
131    ToolDispatchOutcome { record }
132}
133
134pub(super) fn runtime_failure(
135    class: ToolFailureClass,
136    code: impl Into<String>,
137    message: impl Into<String>,
138) -> ToolResult {
139    ToolResult::failure(ToolFailure::runtime(class, code, message))
140}
lash_core/tool_dispatch/context.rs

lash_core/tool_dispatch/
context.rs
