Skip to content

The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.

11.2 KB
Raw Blame
//! Scope-bound callbacks used by TinyFlows authoring and catalog operations.

use std::future::Future;
use std::sync::Arc;

use serde_json::Value;
use tinybus::Result as BusResult;
use tinyflows_bus::catalog::{self, ClassifyManifestCandidatesRequest};
use tinyflows_bus::{AuthoringHost, ToolContract};

use crate::config::Config;
use crate::core::runtime::{CoreContext, DispatchCtx};
use crate::flows::ops;
use crate::modules::tinyflows as module;

#[derive(Clone)]
struct Callbacks {
    config: Arc<Config>,
    context: DispatchCtx,
    runtime: Option<tokio::runtime::Handle>,
}

impl Callbacks {
    async fn in_context<T, F>(&self, work: F) -> Result<T, String>
    where
        T: Send + 'static,
        F: Future<Output = Result<T, String>> + Send + 'static,
    {
        let context = self.context.clone();
        let work = async move {
            if let Some(core) = context.core().cloned() {
                CoreContext::scope(core, work).await
            } else {
                work.await
            }
        };
        match &self.runtime {
            Some(runtime) => runtime
                .spawn(work)
                .await
                .map_err(|error| format!("authoring host callback did not finish: {error}"))?,
            None => work.await,
        }
    }
}

#[tinybus::interface(name = "ai.tinyhumans.tinyflows.AuthoringHost")]
impl Callbacks {
    async fn resolve_workflow(&self, workflow_id: String) -> BusResult<Option<Value>> {
        let config = Arc::clone(&self.config);
        let context = self.context.clone();
        self.in_context(async move {
            let graph = context
                .spawn_blocking(move || ops::load_flow_graph(&config, &workflow_id))
                .await
                .map_err(|error| format!("workflow resolver task failed: {error}"))??;
            Ok(graph.map(|graph| serde_json::to_value(graph).expect("graph serializes")))
        })
        .await
        .map_err(tinybus::Error::failed)
    }

    async fn check_gate(&self, stage: String, graph: Value) -> BusResult<Vec<String>> {
        let config = Arc::clone(&self.config);
        let context = self.context.clone();
        self.in_context(async move {
            crate::flows::host_gates::validate_host_gate_input_shape(&graph)?;
            match stage.as_str() {
                tinyflows_bus::host::TOOL_POLICY => {
                    Ok(crate::flows::host_gates::validate_upload_paths(&graph))
                }
                tinyflows_bus::host::AGENT_REFERENCES => Ok(
                    crate::flows::host_gates::validate_agent_refs(&context, &config, &graph).await,
                ),
                tinyflows_bus::host::CONNECTIONS => Ok(
                    crate::flows::host_gates::validate_connection_refs(&context, &config, &graph)
                        .await,
                ),
                tinyflows_bus::host::TOOL_CONTRACTS => {
                    Ok(crate::flows::host_gates::validate_tool_contracts(&config, &graph).await)
                }
                _ => Err(format!("unknown TinyFlows authoring gate `{stage}`")),
            }
        })
        .await
        .map_err(tinybus::Error::failed)
    }

    async fn lookup_tool_contract(&self, slug: String) -> BusResult<Option<ToolContract>> {
        let config = Arc::clone(&self.config);
        self.in_context(async move {
            let Ok((contract, _)) =
                crate::integrations::composio::catalog::lookup_contract(&config, &slug).await
            else {
                return Ok(None);
            };
            Ok(Some(ToolContract {
                output_fields: contract.output_fields,
                output_schema: contract.output_schema,
                primary_array_path: contract.primary_array_path,
                envelope_prefix: Some("data".into()),
                metadata_fields: vec![
                    "successful".into(),
                    "error".into(),
                    "costUsd".into(),
                    "markdownFormatted".into(),
                ],
            }))
        })
        .await
        .map_err(tinybus::Error::failed)
    }
}

#[tinybus::interface(name = "ai.tinyhumans.tinyflows.ApprovalManifestHost")]
impl ApprovalCallbacks {
    async fn classify_manifest_candidates(
        &self,
        request: ClassifyManifestCandidatesRequest,
    ) -> BusResult<catalog::ClassifyManifestCandidatesResponse> {
        let config = Arc::clone(&self.0.config);
        self.0
            .in_context(async move {
                use crate::flows::caps_host::classify_composio_action_for_tier;
                use crate::security::policy::CommandClass;
                use crate::security::{GateDecision, SecurityPolicy};
                use tinyflows_bus::catalog::{ManifestCandidate, ManifestClass};

                let security = SecurityPolicy::from_config(
                    &config.autonomy,
                    &config.workspace_dir,
                    &config.action_dir,
                );
                let gated = |class: CommandClass| {
                    Some(ManifestClass {
                        name: format!("{class:?}"),
                        blocked: security.gate_decision(class) == GateDecision::Block,
                        skip: false,
                    })
                };
                let mut classes = Vec::with_capacity(request.candidates.len());
                for candidate in request.candidates {
                    let class = match candidate {
                        ManifestCandidate::Http { .. } => gated(CommandClass::Network),
                        ManifestCandidate::Code { .. } => gated(CommandClass::Write),
                        ManifestCandidate::NativeTool {
                            tool_name, args, ..
                        } => {
                            let class = crate::tools::native_ops::classify_tool_call(
                                &config, &tool_name, &args,
                            )
                            .unwrap_or(CommandClass::Network);
                            gated(class)
                        }
                        ManifestCandidate::ConnectorTool { slug, .. } => {
                            let class = classify_composio_action_for_tier(&slug).await;
                            Some(ManifestClass {
                                name: format!("{class:?}"),
                                blocked: security.gate_decision(class) == GateDecision::Block,
                                skip: class == CommandClass::Read,
                            })
                        }
                        ManifestCandidate::DynamicTool { .. } | ManifestCandidate::Agent { .. } => {
                            None
                        }
                    };
                    classes.push(class);
                }
                Ok(classes)
            })
            .await
            .map_err(tinybus::Error::failed)
    }
}

#[derive(Clone)]
struct ApprovalCallbacks(Callbacks);

#[derive(Clone)]
struct DraftPromotionCallbacks(Callbacks);

#[tinybus::interface(name = "ai.tinyhumans.tinyflows.DraftPromotionHost")]
impl DraftPromotionCallbacks {
    async fn save_promoted_draft(
        &self,
        request: catalog::SavePromotedDraftRequest,
    ) -> BusResult<catalog::SavePromotedDraftResponse> {
        let config = Arc::clone(&self.0.config);
        let context = self.0.context.clone();
        let response = self
            .0
            .in_context(async move {
                use catalog::{DraftPromotionOperation, SavePromotedDraftResponse};

                let outcome = match request.operation {
                    DraftPromotionOperation::Create {
                        name,
                        graph,
                        require_approval,
                    } => {
                        ops::flows_create_with_context(
                            &context,
                            &config,
                            name,
                            graph,
                            require_approval,
                        )
                        .await?
                    }
                    DraftPromotionOperation::Update {
                        id,
                        name,
                        graph,
                        require_approval,
                        expected_version,
                    } => {
                        ops::flows_update_with_context(
                            &context,
                            &config,
                            &id,
                            Some(name),
                            Some(graph),
                            require_approval,
                            expected_version,
                        )
                        .await?
                    }
                };
                let workflow: catalog::Workflow = outcome.value;
                Ok(SavePromotedDraftResponse::Ok(
                    catalog::SavePromotedDraftResult {
                        workflow,
                        metadata: serde_json::json!({"logs": outcome.logs}),
                    },
                ))
            })
            .await;
        Ok(match response {
            Ok(response) => response,
            Err(message) => {
                catalog::SavePromotedDraftResponse::Error(catalog::DraftPromotionFailure {
                    code: "workflow_save_failed".into(),
                    message,
                    details: None,
                })
            }
        })
    }
}

/// A callback registration whose lifetime is bounded by one authoring call.
pub(crate) struct Registration {
    _registration: module::ServedObjectRegistration,
    _draft_promotion_registration: module::ServedObjectRegistration,
    pub(crate) authoring: AuthoringHost,
    pub(crate) catalog: catalog::CallbackAddress,
    pub(crate) draft_promotion: catalog::CallbackAddress,
}

pub(crate) async fn register(
    config: Arc<Config>,
    context: DispatchCtx,
) -> Result<Registration, String> {
    let path = format!(
        "/ai/tinyhumans/openhuman/AuthoringHost/h{}",
        uuid::Uuid::new_v4().simple()
    );
    let callbacks = Callbacks {
        config,
        context,
        runtime: tokio::runtime::Handle::try_current().ok(),
    };
    let registration = module::serve_pair(
        path.clone(),
        callbacks.clone(),
        ApprovalCallbacks(callbacks.clone()),
    )
    .await?;
    let draft_promotion_path = format!(
        "/ai/tinyhumans/openhuman/DraftPromotionHost/h{}",
        uuid::Uuid::new_v4().simple()
    );
    let draft_promotion_registration = module::serve_registered(
        draft_promotion_path.clone(),
        DraftPromotionCallbacks(callbacks),
    )
    .await?;
    Ok(Registration {
        _registration: registration,
        _draft_promotion_registration: draft_promotion_registration,
        authoring: AuthoringHost {
            bus_name: module::HOST_BUS_NAME.to_string(),
            object_path: path.clone(),
        },
        catalog: catalog::CallbackAddress {
            destination: module::HOST_BUS_NAME.to_string(),
            object_path: path,
        },
        draft_promotion: catalog::CallbackAddress {
            destination: module::HOST_BUS_NAME.to_string(),
            object_path: draft_promotion_path,
        },
    })
}

#[cfg(test)]
#[path = "authoring_host_tests.rs"]
mod tests;