Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

9.5 KB
Raw Blame
mod bash_code_execution;
#[cfg(test)]
mod test;
mod text_editor_code_execution;

pub use bash_code_execution::BashCodeExecution;
pub use text_editor_code_execution::TextEditorCodeExecution;

use crate::client::Client;
use crate::types::request::{
    CreateMessageRequestBody, RequestContent, RequestMessage, Role, ServerTool, SystemPrompt, Tool,
};
use crate::types::response::{Content, MessageResponse, ResponseContentKind};
use ai_toolset::{AsyncToolCollection, RequestContext, ToolCallError};
use ai_usage::financial::{
    FinalizeInvocation, InvocationId, ProviderModel, ProviderOutcome, ProviderRequestId, RunId,
    TrustedTokenUsage, UnresolvedReason, UsageEvidence,
};
use ai_usage::{TrackedInvocation, UsageContext, UsageRecorder};
use chrono::Utc;
use std::sync::Arc;

/// Service context for Anthropic server tools.
pub struct AnthropicToolContext {
    /// The Anthropic API client.
    pub client: Arc<Client>,
    /// The model to use for server tool invocations.
    pub model: String,
    /// Admission for the authenticated caller before any provider execution.
    pub admission: Arc<dyn ai_billing::domain::admission::AiAdmissionService>,
    /// Analytics injection also exposes the separate observational journal.
    pub recorder: Arc<dyn UsageRecorder>,
    /// Inherited feature/entity only; each call replaces the user from RequestContext.
    pub usage_context: UsageContext,
}

impl Clone for AnthropicToolContext {
    fn clone(&self) -> Self {
        Self {
            client: self.client.clone(),
            model: self.model.clone(),
            admission: self.admission.clone(),
            recorder: self.recorder.clone(),
            usage_context: self.usage_context.clone(),
        }
    }
}

impl AnthropicToolContext {
    /// Create a new context from a client and model name.
    pub fn new(client: Client, model: String) -> Self {
        Self {
            client: Arc::new(client),
            model,
            admission: Arc::new(ai_billing::domain::admission::DisabledAiAdmissionService),
            recorder: Arc::new(ai_usage::NoOpUsageRecorder),
            usage_context: UsageContext::system(ai_usage::AiFeature::Chat),
        }
    }
}

fn tool_error(error: impl Into<anyhow::Error>) -> ToolCallError {
    let error = error.into();
    ToolCallError {
        description: format!("Anthropic API error: {error:?}"),
        internal_error: error,
    }
}

fn response_usage(value: &serde_json::Value) -> UsageEvidence {
    let Some(usage) = value.get("usage").filter(|usage| !usage.is_null()) else {
        return UsageEvidence::Missing(UnresolvedReason::UsageNotReported);
    };
    let tokens = (|| {
        let optional = |key| match usage.get(key) {
            None | Some(serde_json::Value::Null) => Some(0),
            Some(value) => value.as_u64(),
        };
        if let Some(cache) = usage.get("cache_creation").filter(|cache| !cache.is_null()) {
            let cache = cache.as_object()?;
            if cache
                .get("ephemeral_1h_input_tokens")
                .is_some_and(|value| !value.is_null() && value.as_u64() != Some(0))
            {
                return None;
            }
        }
        Some(TrustedTokenUsage::from_disjoint(
            usage.get("input_tokens")?.as_u64()?,
            usage.get("output_tokens")?.as_u64()?,
            optional("cache_read_input_tokens")?,
            optional("cache_creation_input_tokens")?,
            0, // Anthropic output already includes thinking.
        ))
    })();
    tokens
        .map(UsageEvidence::Reported)
        .unwrap_or(UsageEvidence::Missing(
            UnresolvedReason::UnsupportedDimensions,
        ))
}

/// Create the Anthropic server tools toolset.
pub fn anthropic_toolset() -> AsyncToolCollection<AnthropicToolContext> {
    AsyncToolCollection::new()
        .add_tool::<BashCodeExecution, AnthropicToolContext>()
        .add_tool::<TextEditorCodeExecution, AnthropicToolContext>()
}

pub(crate) async fn invoke_server_tool(
    context: &AnthropicToolContext,
    request_context: &RequestContext,
    server_tool: ServerTool,
    input: &str,
) -> Result<Vec<ResponseContentKind>, ToolCallError> {
    context
        .admission
        .admit(&request_context.user_id, context.usage_context.feature)
        .await
        .map_err(|error| ToolCallError {
            description: format!("{}: {error}", error.code()),
            internal_error: error.into(),
        })?;

    let request = CreateMessageRequestBody {
        model: context.model.clone(),
        messages: vec![RequestMessage {
            role: Role::User,
            content: RequestContent::Text(input.to_string()),
        }],
        max_tokens: 16000,
        tools: Some(vec![Tool::Server(server_tool)]),
        system: Some(SystemPrompt::Text(
            "Use the provided tool to fulfill the user's request.".into(),
        )),
        ..Default::default()
    };

    let client = context.client.clone();
    let (tracking, model) = match (
        context.recorder.tracking(),
        ProviderModel::new("anthropic", &context.model),
    ) {
        (Some(tracking), Ok(model)) => (tracking, model),
        (_, model) => {
            let _ = model.inspect_err(|error| {
                tracing::error!(error = ?error, "cannot identify tool provider; observation not persisted");
            });
            let response = client.chat().create(request).await.map_err(tool_error)?;
            return Ok(match response.content {
                Some(Content::Array(blocks)) => blocks,
                _ => Vec::new(),
            });
        }
    };
    let attribution = TrackedInvocation {
        run_id: RunId::new(),
        invocation_id: InvocationId::new(),
        user: request_context.user_id.clone(),
        feature: context.usage_context.feature,
        entity: context.usage_context.entity,
        model,
        occurred_at: Utc::now(),
    };
    let _ = tracking.begin(attribution.clone()).await.inspect_err(|error| {
        tracing::error!(error = ?error, invocation_id = ?attribution.invocation_id, "tool observation begin failed");
    });
    // The client performs one HTTP execution, with no hidden retries. Keep it
    // alive after tool cancellation so already-incurred usage can be recorded.
    let (caller_alive, cancelled) = tokio::sync::oneshot::channel::<()>();
    let response = tokio::spawn(async move {
        let execution = async {
            let response = client.post_response("/v1/messages", request).await?;
            let status = response.status();
            let request_id = response
                .headers()
                .get("request-id")
                .and_then(|id| id.to_str().ok())
                .and_then(|id| ProviderRequestId::new(id).ok());
            let value = response.json::<serde_json::Value>().await?;
            Ok::<_, anyhow::Error>((status, request_id, value))
        };
        tokio::pin!(execution);
        let result = tokio::select! {
            result = &mut execution => result,
            _ = cancelled => match tokio::time::timeout(
                std::time::Duration::from_secs(300), execution
            ).await {
                Ok(result) => result,
                Err(error) => Err(error.into()),
            },
        };
        let (usage, provider_request_id, outcome) = match &result {
            Ok((status, request_id, value)) => {
                let request_id = request_id.clone().or_else(|| {
                    value
                        .get("id")
                        .and_then(serde_json::Value::as_str)
                        .and_then(|id| ProviderRequestId::new(id).ok())
                });
                let outcome = if status.is_success() {
                    ProviderOutcome::Succeeded
                } else {
                    ProviderOutcome::Failed
                };
                (response_usage(value), request_id, outcome)
            }
            Err(_) => (
                UsageEvidence::Missing(UnresolvedReason::Interrupted),
                None,
                ProviderOutcome::Unknown,
            ),
        };
        let evidence = FinalizeInvocation {
            invocation_id: attribution.invocation_id,
            occurred_at: Utc::now(),
            provider_request_id,
            outcome,
            usage,
        };
        for _ in 0..3 {
            let recorded = match tracking.begin(attribution.clone()).await {
                Ok(_) => tracking.finalize(evidence.clone()).await,
                Err(error) => Err(error),
            };
            if recorded
                .inspect_err(|error| {
                    tracing::error!(
                        error = ?error,
                        invocation_id = ?attribution.invocation_id,
                        "tool observation delivery failed"
                    );
                })
                .is_ok()
            {
                break;
            }
        }
        let (status, _, value) = result?;
        if !status.is_success() {
            let api_error = serde_json::from_value::<crate::prelude::ApiError>(value)?;
            return Err(crate::error::AnthropicError::ApiError {
                api_error,
                status_code: status,
            }
            .into());
        }
        Ok::<_, anyhow::Error>(value)
    })
    .await
    .map_err(tool_error)?
    .map_err(tool_error)?;
    drop(caller_alive);
    // Observe before result parsing: a malformed tool result can still incur tokens.
    let response: MessageResponse = serde_json::from_value(response).map_err(tool_error)?;

    match response.content {
        Some(Content::Array(blocks)) => Ok(blocks),
        _ => Ok(Vec::new()),
    }
}