use std::collections::BTreeMap;
use std::sync::Arc;
use arabica_model::ToolCallItem;
use arabica_protocol::{RunId, ToolPermissionOutcome, ToolPermissionScope, ToolPermissionSource};
use tokio::sync::{mpsc, oneshot, watch};
#[derive(Clone, Debug)]
pub struct RunCancellation(Arc<watch::Sender<bool>>);
impl RunCancellation {
pub fn new() -> Self {
let (sender, _) = watch::channel(false);
Self(Arc::new(sender))
}
pub fn cancel(&self) {
self.0.send_replace(true);
}
pub fn is_cancelled(&self) -> bool {
*self.0.borrow()
}
pub async fn cancelled(&self) {
let mut receiver = self.0.subscribe();
let _ = receiver.wait_for(|cancelled| *cancelled).await;
}
}
impl Default for RunCancellation {
fn default() -> Self {
Self::new()
}
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub enum ToolPermissionRule {
Allow,
#[default]
Ask,
Deny,
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct ToolPermissionPolicy {
pub default: ToolPermissionRule,
pub by_tool: BTreeMap<String, ToolPermissionRule>,
pub argument_rules: Vec<ToolArgumentPermissionRule>,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ToolArgumentPermissionRule {
pub tool: String,
pub parameter: String,
pub pattern: String,
pub rule: ToolPermissionRule,
}
impl ToolPermissionPolicy {
pub fn rule_for(&self, tool: &str, arguments: &serde_json::Value) -> ToolPermissionRule {
for rule in &self.argument_rules {
if rule.tool != tool {
continue;
}
let Some(value) = argument_value(arguments, &rule.parameter) else {
continue;
};
if crate::cached_regex_is_match(&rule.pattern, &value) {
return rule.rule;
}
}
self.by_tool.get(tool).copied().unwrap_or(self.default)
}
}
fn argument_value(arguments: &serde_json::Value, parameter: &str) -> Option<String> {
let value = if parameter == "*" {
arguments
} else {
parameter.split('.').try_fold(arguments, |value, segment| {
value
.as_object()
.and_then(|object| object.get(segment))
.or_else(|| {
segment
.parse::<usize>()
.ok()
.and_then(|index| value.get(index))
})
})?
};
match value {
serde_json::Value::String(value) => Some(value.clone()),
_ => Some(value.to_string()),
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct PermissionDecision {
pub outcome: ToolPermissionOutcome,
pub scope: ToolPermissionScope,
pub source: ToolPermissionSource,
}
impl PermissionDecision {
pub const fn allow_once() -> Self {
Self {
outcome: ToolPermissionOutcome::Allowed,
scope: ToolPermissionScope::Once,
source: ToolPermissionSource::User,
}
}
pub const fn allow_for_session() -> Self {
Self {
outcome: ToolPermissionOutcome::Allowed,
scope: ToolPermissionScope::Session,
source: ToolPermissionSource::User,
}
}
pub const fn deny_once() -> Self {
Self {
outcome: ToolPermissionOutcome::Denied,
scope: ToolPermissionScope::Once,
source: ToolPermissionSource::User,
}
}
pub const fn cancelled() -> Self {
Self {
outcome: ToolPermissionOutcome::Cancelled,
scope: ToolPermissionScope::Once,
source: ToolPermissionSource::User,
}
}
pub(crate) const fn approver_unavailable() -> Self {
Self {
outcome: ToolPermissionOutcome::Denied,
scope: ToolPermissionScope::Once,
source: ToolPermissionSource::ApproverUnavailable,
}
}
}
#[derive(Debug)]
pub struct PermissionRequest {
pub run_id: RunId,
pub call: ToolCallItem,
pub reply: oneshot::Sender<PermissionDecision>,
}
#[derive(Clone, Debug, Default)]
pub struct ToolPermissionGate {
pub policy: ToolPermissionPolicy,
pub approver: Option<mpsc::UnboundedSender<PermissionRequest>>,
}
#[derive(Clone, Debug, Default)]
pub struct RunControl {
pub cancellation: Option<RunCancellation>,
pub permissions: Option<ToolPermissionGate>,
}
impl RunControl {
pub fn is_cancelled(&self) -> bool {
self.cancellation
.as_ref()
.is_some_and(RunCancellation::is_cancelled)
}
}