lc_callbacks/

langsmith_client.rs

// lc-callbacks/src/langsmith_client.rs
//! LangSmith API client

use reqwest::Client;
use std::env;
use std::time::Duration;

/// M-18: a trace POST/PATCH must never hang the agent forever. Observability
/// is a side channel — a slow or dead endpoint degrades to a logged error
/// instead of blocking the run indefinitely. The caller still sees the error
/// and, if the handler runs in the sync (default) mode, is only delayed by
/// this bound rather than stalled.
const LANGSMITH_TIMEOUT: Duration = Duration::from_secs(15);

use super::run_tree::{RunCreate, RunTree, RunUpdate};

/// LangSmith configuration
#[derive(Debug, Clone)]
pub struct LangSmithConfig {
    /// API key (starts with "ls_")
    pub api_key: String,

    /// API endpoint URL
    pub api_url: String,

    /// Workspace ID (required for org accounts)
    pub workspace_id: Option<String>,

    /// Project name
    pub project_name: String,

    /// Whether tracing is enabled
    pub tracing_enabled: bool,
}

impl LangSmithConfig {
    /// Create config from environment variables
    pub fn from_env() -> Result<Self, LangSmithError> {
        let api_key = env::var("LANGSMITH_API_KEY").map_err(|_| {
            LangSmithError::Config("LANGSMITH_API_KEY environment variable not set".to_string())
        })?;

        let tracing_enabled = env::var("LANGSMITH_TRACING")
            .map(|v| v == "true")
            .unwrap_or(true);

        let project_name = env::var("LANGSMITH_PROJECT").unwrap_or_else(|_| "default".to_string());

        let api_url = env::var("LANGSMITH_ENDPOINT")
            .unwrap_or_else(|_| "https://api.smith.langchain.com".to_string());

        let workspace_id = env::var("LANGSMITH_WORKSPACE_ID").ok();

        Ok(Self {
            api_key,
            api_url,
            workspace_id,
            project_name,
            tracing_enabled,
        })
    }

    /// Create config with API key
    pub fn new(api_key: impl Into<String>) -> Self {
        Self {
            api_key: api_key.into(),
            api_url: "https://api.smith.langchain.com".to_string(),
            workspace_id: None,
            project_name: "default".to_string(),
            tracing_enabled: true,
        }
    }

    /// Set project name
    pub fn with_project(mut self, project: impl Into<String>) -> Self {
        self.project_name = project.into();
        self
    }

    /// Set workspace ID
    pub fn with_workspace(mut self, workspace_id: impl Into<String>) -> Self {
        self.workspace_id = Some(workspace_id.into());
        self
    }

    /// Set API endpoint
    pub fn with_endpoint(mut self, endpoint: impl Into<String>) -> Self {
        self.api_url = endpoint.into();
        self
    }

    /// Enable or disable tracing
    pub fn with_tracing(mut self, enabled: bool) -> Self {
        self.tracing_enabled = enabled;
        self
    }
}

/// LangSmith API client
pub struct LangSmithClient {
    /// Configuration
    pub config: LangSmithConfig,
    http_client: Client,
}

impl LangSmithClient {
    /// Create a new client
    pub fn new(config: LangSmithConfig) -> Self {
        // M-18: `Client::new()` sets no request timeout, so a hung endpoint
        // blocks the `.send().await` forever. Bound the whole request cycle
        // (connect + send + response body) so the agent degrades to an error.
        let http_client = Client::builder()
            .connect_timeout(Duration::from_secs(5))
            .timeout(LANGSMITH_TIMEOUT)
            .build()
            // A builder failure here is a programming error (invalid TLS / too
            // many redirects config), not a runtime condition — a plain reqwest
            // client from valid static settings never fails to build. Falling
            // back keeps `new()` infallible.
            .unwrap_or_else(|_| Client::new());
        Self {
            config,
            http_client,
        }
    }

    /// Create client from environment variables
    pub fn from_env() -> Result<Self, LangSmithError> {
        let config = LangSmithConfig::from_env()?;
        Ok(Self::new(config))
    }

    /// Check if tracing is enabled
    pub fn is_tracing_enabled(&self) -> bool {
        self.config.tracing_enabled
    }

    /// Get the project name
    pub fn project_name(&self) -> &str {
        &self.config.project_name
    }

    /// Create a run (POST /runs)
    pub async fn create_run(&self, run: &RunTree) -> Result<(), LangSmithError> {
        if !self.config.tracing_enabled {
            return Ok(());
        }

        let url = format!("{}/runs", self.config.api_url);
        let mut run_create = RunCreate::from(run);
        if run_create.session_name.is_none() {
            run_create.session_name = Some(self.config.project_name.clone());
        }

        let mut request = self
            .http_client
            .post(&url)
            .header("x-api-key", &self.config.api_key)
            .json(&run_create);

        if let Some(workspace_id) = &self.config.workspace_id {
            request = request.header("x-tenant-id", workspace_id);
        }

        let response = request
            .send()
            .await
            .map_err(|e| LangSmithError::Http(e.to_string()))?;

        if !response.status().is_success() {
            let status = response.status();
            let body = response.text().await.unwrap_or_default();
            return Err(LangSmithError::Api(format!("HTTP {}: {}", status, body)));
        }

        Ok(())
    }

    /// Update a run (PATCH /runs/{run_id})
    pub async fn update_run(&self, run: &RunTree) -> Result<(), LangSmithError> {
        if !self.config.tracing_enabled {
            return Ok(());
        }

        let url = format!("{}/runs/{}", self.config.api_url, run.id);
        let body = RunUpdate::from(run);

        let mut request = self
            .http_client
            .patch(&url)
            .header("x-api-key", &self.config.api_key)
            .json(&body);

        if let Some(workspace_id) = &self.config.workspace_id {
            request = request.header("x-tenant-id", workspace_id);
        }

        let response = request
            .send()
            .await
            .map_err(|e| LangSmithError::Http(e.to_string()))?;

        if !response.status().is_success() {
            let status = response.status();
            let body = response.text().await.unwrap_or_default();
            return Err(LangSmithError::Api(format!("HTTP {}: {}", status, body)));
        }

        Ok(())
    }
}

/// LangSmith error type
#[derive(Debug)]
#[non_exhaustive]
pub enum LangSmithError {
    /// HTTP request error.
    Http(String),
    /// API returned an error.
    Api(String),
    /// Configuration error.
    Config(String),
}

impl std::fmt::Display for LangSmithError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Http(msg) => write!(f, "HTTP error: {}", msg),
            Self::Api(msg) => write!(f, "API error: {}", msg),
            Self::Config(msg) => write!(f, "Config error: {}", msg),
        }
    }
}

impl std::error::Error for LangSmithError {}