babelforce_manager_sdk/resources/

tasks.rs

use crate::error::{map_task_automation_err as map_err, ManagerError};
use crate::gen::task_automation::apis::configuration::Configuration;
use crate::gen::task_automation::apis::{
    account_configuration_api as cfg_api, action_test_api, agent_api, logs_api, manager_api,
    metrics_api, scripts_api, secrets_api, usage_api,
};
use crate::gen::task_automation::models;
use crate::retry::{with_retry, RetryPolicy};
use crate::token::SharedCfg;
use std::collections::HashMap;

/// Task automation (v3) — `/api/v3/tasks`, with nested `scripts`, `secrets`, `selection_config`,
/// and `metrics` sub-resources.
pub struct TasksResource {
    pub(crate) cfg: SharedCfg<Configuration>,
    pub(crate) retry: RetryPolicy,
    /// Custom scripts by type.
    pub scripts: TaskScriptsResource,
    /// Account secrets, grouped by prefix.
    pub secrets: TaskSecretsResource,
    /// Account task-selection configuration.
    pub selection_config: TaskSelectionConfigResource,
    /// Task & agent metrics.
    pub metrics: TaskMetricsResource,
}

impl TasksResource {
    /// List tasks (one page), optionally filtered.
    pub async fn list(&self, filter: Option<&str>) -> Result<models::TaskList, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, true, || {
            manager_api::tasks(cfg, filter, None, None)
        })
        .await
        .map_err(map_err)
    }

    /// Submit a new task.
    pub async fn create(&self, body: models::SubmitTask) -> Result<models::Task, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            manager_api::submit_task(cfg, body.clone())
        })
        .await
        .map_err(map_err)
    }

    /// Submit a task from a named template, supplying the template variables.
    pub async fn create_from_template(
        &self,
        template: &str,
        variables: serde_json::Value,
    ) -> Result<models::Task, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            manager_api::submit_task_template(cfg, template, variables.clone(), None)
        })
        .await
        .map_err(map_err)
    }

    /// Get a task by id.
    pub async fn get(&self, task_id: &str) -> Result<models::Task, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, true, || manager_api::task(cfg, task_id))
            .await
            .map_err(map_err)
    }

    /// Update a task.
    pub async fn update(
        &self,
        task_id: &str,
        body: models::Task,
    ) -> Result<models::Task, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            manager_api::update_task(cfg, task_id, body.clone())
        })
        .await
        .map_err(map_err)
    }

    /// Interrupt a task, moving it to a target state.
    pub async fn interrupt(
        &self,
        task_id: &str,
        interrupt_to: models::InterruptionTargetStates,
        action: Option<models::ManualActionRequest>,
    ) -> Result<(), ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            manager_api::manager_interrupt_on_task(cfg, task_id, interrupt_to, action.clone())
        })
        .await
        .map_err(map_err)
    }

    /// Change a task's state.
    ///
    /// The underlying generated operation is marked deprecated upstream, but it remains part of the
    /// spec and is wrapped here for parity with the TypeScript/Go SDKs.
    #[allow(deprecated)]
    pub async fn change_state(
        &self,
        task_id: &str,
        state: models::TaskState,
    ) -> Result<(), ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            manager_api::change_task_state(cfg, task_id, state)
        })
        .await
        .map_err(map_err)
    }

    /// Perform an agent action on a task (accept/reject/complete, …).
    pub async fn agent_action(
        &self,
        task_id: &str,
        action: models::AgentActions,
        manual_action: Option<models::ManualActionRequest>,
    ) -> Result<models::Task, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            agent_api::agent_action_on_task(cfg, task_id, action, manual_action.clone())
        })
        .await
        .map_err(map_err)
    }

    /// Lock or unlock the current agent.
    pub async fn set_agent_lock(
        &self,
        lock_state: models::AgentLocking,
    ) -> Result<models::AgentLockState, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            agent_api::change_agent_lock(cfg, lock_state)
        })
        .await
        .map_err(map_err)
    }

    /// Task usage (time series).
    pub async fn usage(&self) -> Result<models::TaskTimeSeries, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, true, || {
            usage_api::task_usage(cfg, None, None, None, None)
        })
        .await
        .map_err(map_err)
    }

    /// The set of task usage types.
    pub async fn usage_types(&self) -> Result<Vec<String>, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, true, || {
            usage_api::task_usage_types(cfg, None, None)
        })
        .await
        .map_err(map_err)
    }

    /// Read the customer task logs.
    pub async fn logs(&self) -> Result<models::LogsResponse, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, true, || {
            logs_api::list(cfg, None, None, None, None, None, None)
        })
        .await
        .map_err(map_err)
    }

    /// Test an action without dispatching it.
    pub async fn test_action(
        &self,
        body: models::TestAction,
    ) -> Result<models::TestActionResult, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            action_test_api::testing(cfg, body.clone())
        })
        .await
        .map_err(map_err)
    }
}

/// Custom scripts by type — `/api/v3/scripts`.
pub struct TaskScriptsResource {
    pub(crate) cfg: SharedCfg<Configuration>,
    pub(crate) retry: RetryPolicy,
}

impl TaskScriptsResource {
    /// List scripts of a type.
    pub async fn list(
        &self,
        script_type: models::ScriptType,
    ) -> Result<models::ScriptList, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, true, || {
            scripts_api::list_scripts(cfg, script_type, None, None, None)
        })
        .await
        .map_err(map_err)
    }

    /// Get a script by id.
    pub async fn get(
        &self,
        script_type: models::ScriptType,
        code_id: &str,
    ) -> Result<models::ScriptResponses, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, true, || {
            scripts_api::get_script(cfg, code_id, script_type, None)
        })
        .await
        .map_err(map_err)
    }

    /// Submit a new script.
    pub async fn submit(
        &self,
        script_type: models::ScriptType,
        body: models::Script,
    ) -> Result<models::ScriptResponses, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            scripts_api::submit_script(cfg, script_type, body.clone())
        })
        .await
        .map_err(map_err)
    }

    /// Update a script.
    pub async fn update(
        &self,
        script_type: models::ScriptType,
        code_id: &str,
        body: models::Script,
    ) -> Result<models::ScriptResponses, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            scripts_api::update_script(cfg, code_id, script_type, body.clone())
        })
        .await
        .map_err(map_err)
    }

    /// Delete a script.
    pub async fn delete(
        &self,
        script_type: models::ScriptType,
        code_id: &str,
    ) -> Result<(), ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            scripts_api::delete_script(cfg, code_id, script_type)
        })
        .await
        .map_err(map_err)
    }
}

/// Account secrets, grouped by prefix — `/api/v3/secrets`.
pub struct TaskSecretsResource {
    pub(crate) cfg: SharedCfg<Configuration>,
    pub(crate) retry: RetryPolicy,
}

impl TaskSecretsResource {
    /// List the secret prefixes.
    pub async fn list_prefixes(&self) -> Result<Vec<String>, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, true, || secrets_api::list_secret_prefixes(cfg))
            .await
            .map_err(map_err)
    }

    /// List the keys under a prefix.
    pub async fn list_keys(&self, prefix: &str) -> Result<Vec<String>, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, true, || {
            secrets_api::list_secret_keys(cfg, prefix)
        })
        .await
        .map_err(map_err)
    }

    /// Create secrets under a prefix.
    pub async fn create(
        &self,
        prefix: &str,
        secrets: HashMap<String, serde_json::Value>,
    ) -> Result<(), ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            secrets_api::create_secrets(cfg, prefix, Some(secrets.clone()))
        })
        .await
        .map_err(map_err)
    }

    /// Patch (merge) secrets under a prefix.
    pub async fn patch(
        &self,
        prefix: &str,
        secrets: HashMap<String, serde_json::Value>,
    ) -> Result<(), ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            secrets_api::patch_secrets(cfg, prefix, Some(secrets.clone()))
        })
        .await
        .map_err(map_err)
    }

    /// Delete keys under a prefix.
    pub async fn delete_keys(&self, prefix: &str, keys: Vec<String>) -> Result<(), ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            secrets_api::delete_secret_keys(cfg, prefix, Some(keys.clone()))
        })
        .await
        .map_err(map_err)
    }
}

/// Account task-selection configuration — `/api/v3/account/selection`.
pub struct TaskSelectionConfigResource {
    pub(crate) cfg: SharedCfg<Configuration>,
    pub(crate) retry: RetryPolicy,
}

impl TaskSelectionConfigResource {
    /// Read the selection configuration.
    pub async fn read(&self) -> Result<models::AccountSelectionConfiguration, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, true, || {
            cfg_api::read_selection_configuration(cfg)
        })
        .await
        .map_err(map_err)
    }

    /// Create the selection configuration.
    pub async fn create(
        &self,
        body: models::AccountSelectionConfiguration,
    ) -> Result<models::AccountSelectionConfiguration, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            cfg_api::create_selection_configuration(cfg, Some(body.clone()))
        })
        .await
        .map_err(map_err)
    }

    /// Update the selection configuration.
    pub async fn update(
        &self,
        body: models::AccountSelectionConfiguration,
    ) -> Result<models::AccountSelectionConfiguration, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            cfg_api::update_selection_configuration(cfg, Some(body.clone()))
        })
        .await
        .map_err(map_err)
    }

    /// Delete the selection configuration.
    pub async fn delete(&self) -> Result<(), ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            cfg_api::delete_selection_configuration(cfg)
        })
        .await
        .map_err(map_err)
    }
}

/// Task & agent metrics — `/api/v3/metrics`.
pub struct TaskMetricsResource {
    pub(crate) cfg: SharedCfg<Configuration>,
    pub(crate) retry: RetryPolicy,
}

impl TaskMetricsResource {
    /// The journal for a task.
    pub async fn task_journal(&self, task_id: &str) -> Result<models::TaskJournal, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, true, || {
            metrics_api::task_journal(cfg, task_id)
        })
        .await
        .map_err(map_err)
    }

    /// The interaction journal for an agent.
    pub async fn agent_journal(
        &self,
        agent_id: &str,
    ) -> Result<models::AgentJournal, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, true, || {
            metrics_api::agent_interactions(cfg, agent_id)
        })
        .await
        .map_err(map_err)
    }

    /// An agent's interaction durations.
    pub async fn agent_interaction_durations(
        &self,
        agent_id: &str,
    ) -> Result<models::InteractionDurations, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, true, || {
            metrics_api::agent_interaction_duration(cfg, agent_id)
        })
        .await
        .map_err(map_err)
    }
}