feat: add agent publishing foundation

2026-03-29 22:10:15 +03:00
parent d757adb192
commit 7b7699cf8b
18 changed files with 1520 additions and 105 deletions
@@ -1,17 +1,19 @@
 use std::path::PathBuf;

 use crank_core::{
-    AuthConfig, AuthKind, AuthProfile, AuthProfileId, ConfigExport, ExportMode, GeneratedDraft,
-    GeneratedDraftStatus, OperationId, OperationStatus, Protocol, SampleId, Samples, Target,
-    Workspace, WorkspaceId, WorkspaceStatus,
+    Agent, AgentId, AgentOperationBinding, AgentStatus, AgentVersion, AuthConfig, AuthKind,
+    AuthProfile, AuthProfileId, ConfigExport, ExportMode, GeneratedDraft, GeneratedDraftStatus,
+    OperationId, OperationStatus, Protocol, SampleId, Samples, Target, Workspace, WorkspaceId,
+    WorkspaceStatus,
 };
 use crank_mapping::{JsonPathRoot, MappingSet, infer_mapping_from_samples};
 use crank_proto::{ProtoService, services_from_descriptor_set_bytes};
 use crank_registry::{
-    CreateVersionRequest, CreateWorkspaceRequest, OperationSampleMetadata, OperationSummary,
-    OperationVersionRecord, PostgresRegistry, PublishRequest, RegistryOperation, SampleKind,
-    SaveAuthProfileRequest, SaveDescriptorMetadataRequest, SaveSampleMetadataRequest,
-    UpdateWorkspaceRequest, WorkspaceRecord,
+    AgentSummary, AgentVersionRecord, CreateAgentRequest, CreateVersionRequest,
+    CreateWorkspaceRequest, OperationSampleMetadata, OperationSummary, OperationVersionRecord,
+    PostgresRegistry, PublishAgentRequest, PublishRequest, RegistryOperation, SampleKind,
+    SaveAgentBindingsRequest, SaveAuthProfileRequest, SaveDescriptorMetadataRequest,
+    SaveSampleMetadataRequest, UpdateWorkspaceRequest, WorkspaceRecord,
 };
 use crank_runtime::{PreparedRequest, RuntimeError, RuntimeExecutor, RuntimeOperation};
 use crank_schema::Schema;
@@ -94,6 +96,44 @@ pub struct UpdateWorkspacePayload {
    pub settings: Option<Value>,
 }

+#[derive(Clone, Debug, Deserialize)]
+pub struct AgentPayload {
+    pub slug: String,
+    pub display_name: String,
+    pub description: String,
+    #[serde(default)]
+    pub instructions: Value,
+    #[serde(default)]
+    pub tool_selection_policy: Value,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+pub struct AgentBindingPayload {
+    pub operation_id: String,
+    pub operation_version: u32,
+    pub tool_name: String,
+    pub tool_title: String,
+    pub tool_description_override: Option<String>,
+    #[serde(default = "default_enabled")]
+    pub enabled: bool,
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct CreatedAgentResponse {
+    pub agent_id: String,
+    pub workspace_id: String,
+    pub version: u32,
+    pub status: AgentStatus,
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct PublishAgentResponse {
+    pub agent_id: String,
+    pub workspace_id: String,
+    pub published_version: u32,
+    pub published_at: String,
+}
+
 #[derive(Clone, Debug, Deserialize)]
 pub struct GenerateDraftPayload {
    #[serde(default)]
@@ -493,6 +533,173 @@ impl AdminService {
        Ok(self.registry.list_auth_profiles(workspace_id).await?)
    }

+    #[instrument(skip(self))]
+    pub async fn list_agents(
+        &self,
+        workspace_id: &WorkspaceId,
+    ) -> Result<Vec<AgentSummary>, ApiError> {
+        self.ensure_workspace_exists(workspace_id).await?;
+        Ok(self.registry.list_agents(workspace_id).await?)
+    }
+
+    #[instrument(skip(self))]
+    pub async fn get_agent(
+        &self,
+        workspace_id: &WorkspaceId,
+        agent_id: &AgentId,
+    ) -> Result<AgentSummary, ApiError> {
+        self.registry
+            .get_agent_summary(workspace_id, agent_id)
+            .await?
+            .ok_or_else(|| {
+                ApiError::not_found(format!("agent {} was not found", agent_id.as_str()))
+            })
+    }
+
+    #[instrument(skip(self))]
+    pub async fn get_agent_version(
+        &self,
+        workspace_id: &WorkspaceId,
+        agent_id: &AgentId,
+        version: u32,
+    ) -> Result<AgentVersionRecord, ApiError> {
+        self.registry
+            .get_agent_version(workspace_id, agent_id, version)
+            .await?
+            .ok_or_else(|| {
+                ApiError::not_found(format!(
+                    "agent version {version} for {} was not found",
+                    agent_id.as_str()
+                ))
+            })
+    }
+
+    #[instrument(skip(self, payload), fields(workspace_id = %workspace_id.as_str(), agent_slug = %payload.slug))]
+    pub async fn create_agent(
+        &self,
+        workspace_id: &WorkspaceId,
+        payload: AgentPayload,
+    ) -> Result<CreatedAgentResponse, ApiError> {
+        self.ensure_workspace_exists(workspace_id).await?;
+
+        if self
+            .find_agent_by_slug(workspace_id, &payload.slug)
+            .await?
+            .is_some()
+        {
+            return Err(ApiError::conflict(format!(
+                "agent with slug {} already exists",
+                payload.slug
+            )));
+        }
+
+        let now = now_string()?;
+        let agent_id = AgentId::new(new_prefixed_id("agent"));
+        let agent = Agent {
+            id: agent_id.clone(),
+            workspace_id: workspace_id.clone(),
+            slug: payload.slug,
+            display_name: payload.display_name,
+            description: payload.description,
+            status: AgentStatus::Draft,
+            current_draft_version: 1,
+            latest_published_version: None,
+            created_at: now.clone(),
+            updated_at: now.clone(),
+            published_at: None,
+        };
+        let version = AgentVersion {
+            agent_id: agent_id.clone(),
+            version: 1,
+            status: AgentStatus::Draft,
+            instructions: payload.instructions,
+            tool_selection_policy: payload.tool_selection_policy,
+            created_at: now,
+        };
+
+        self.registry
+            .create_agent(CreateAgentRequest {
+                agent: &agent,
+                version: &version,
+                bindings: &[],
+            })
+            .await?;
+        info!(agent_id = %agent_id.as_str(), version = 1, "agent created");
+
+        Ok(CreatedAgentResponse {
+            agent_id: agent_id.as_str().to_owned(),
+            workspace_id: workspace_id.as_str().to_owned(),
+            version: 1,
+            status: AgentStatus::Draft,
+        })
+    }
+
+    #[instrument(skip(self, payload), fields(workspace_id = %workspace_id.as_str(), agent_id = %agent_id.as_str()))]
+    pub async fn save_agent_bindings(
+        &self,
+        workspace_id: &WorkspaceId,
+        agent_id: &AgentId,
+        payload: Vec<AgentBindingPayload>,
+    ) -> Result<AgentVersionRecord, ApiError> {
+        let agent = self.get_agent(workspace_id, agent_id).await?;
+        let bindings = payload
+            .into_iter()
+            .map(|binding| AgentOperationBinding {
+                operation_id: OperationId::new(binding.operation_id),
+                operation_version: binding.operation_version,
+                tool_name: binding.tool_name,
+                tool_title: binding.tool_title,
+                tool_description_override: binding.tool_description_override,
+                enabled: binding.enabled,
+            })
+            .collect::<Vec<_>>();
+
+        self.registry
+            .save_agent_bindings(SaveAgentBindingsRequest {
+                workspace_id,
+                agent_id,
+                agent_version: agent.current_draft_version,
+                bindings: &bindings,
+            })
+            .await?;
+        info!(
+            agent_id = %agent_id.as_str(),
+            version = agent.current_draft_version,
+            binding_count = bindings.len(),
+            "agent bindings saved"
+        );
+
+        self.get_agent_version(workspace_id, agent_id, agent.current_draft_version)
+            .await
+    }
+
+    #[instrument(skip(self), fields(workspace_id = %workspace_id.as_str(), agent_id = %agent_id.as_str(), version))]
+    pub async fn publish_agent(
+        &self,
+        workspace_id: &WorkspaceId,
+        agent_id: &AgentId,
+        version: u32,
+    ) -> Result<PublishAgentResponse, ApiError> {
+        let published_at = now_string()?;
+        self.registry
+            .publish_agent(PublishAgentRequest {
+                workspace_id,
+                agent_id,
+                version,
+                published_at: &published_at,
+                published_by: None,
+            })
+            .await?;
+        info!(agent_id = %agent_id.as_str(), version, "agent published");
+
+        Ok(PublishAgentResponse {
+            agent_id: agent_id.as_str().to_owned(),
+            workspace_id: workspace_id.as_str().to_owned(),
+            published_version: version,
+            published_at,
+        })
+    }
+
    #[instrument(skip(self, payload), fields(operation_id = %operation_id.as_str(), source_name = source_name.unwrap_or("descriptor-set.bin")))]
    pub async fn upload_descriptor_set(
        &self,
@@ -940,6 +1147,19 @@ impl AdminService {
            .find(|operation| operation.name == name))
    }

+    async fn find_agent_by_slug(
+        &self,
+        workspace_id: &WorkspaceId,
+        slug: &str,
+    ) -> Result<Option<AgentSummary>, ApiError> {
+        Ok(self
+            .registry
+            .list_agents(workspace_id)
+            .await?
+            .into_iter()
+            .find(|agent| agent.slug == slug))
+    }
+
    async fn ensure_workspace_exists(&self, workspace_id: &WorkspaceId) -> Result<(), ApiError> {
        self.get_workspace(workspace_id).await.map(|_| ())
    }
@@ -1012,6 +1232,10 @@ fn default_export_mode() -> ExportMode {
    ExportMode::Portable
 }

+fn default_enabled() -> bool {
+    true
+}
+
 fn new_prefixed_id(prefix: &str) -> String {
    format!("{prefix}_{}", Uuid::now_v7().simple())
 }