@@ -1,6 +1,6 @@
 [package]
 name = "agent-protocols"
-version = "0.6.0"
+version = "0.7.0"
 edition.workspace = true
 license.workspace = true
 repository.workspace = true
 
@@ -556,23 +556,33 @@ impl DelegationClient {
     }
 
     /// Public queries are existence checks and carry both `subject` and
-    /// `principal_id`. Pass `allow_enumeration` only for a request the service
-    /// has authorized to enumerate one side.
+    /// `principal_id`. Passing a request JWT authorizes an enumeration query,
+    /// which a service must otherwise refuse.
     pub async fn query_delegations(
         &self,
         request: &DelegationQueryRequest,
-        allow_enumeration: bool,
+        jwt: Option<&str>,
     ) -> Result<DelegationQueryResponse> {
-        crate::delegation::validate_delegation_query_request(request, allow_enumeration)?;
-        Ok(self
-            .inner
-            .post(self.url("/v1/delegations/query"))
-            .json(request)
-            .send()
-            .await?
-            .error_for_status()?
-            .json()
-            .await?)
+        self.query_delegations_at(&self.url("/v1/delegations/query"), request, jwt)
+            .await
+    }
+
+    /// Queries the endpoint a principal document names in its
+    /// `delegation_query_url`. That is how a relying party reaches the
+    /// authoritative service for a principal without trusting a URL supplied
+    /// by whoever presented the credential.
+    pub async fn query_delegations_at(
+        &self,
+        query_url: &str,
+        request: &DelegationQueryRequest,
+        jwt: Option<&str>,
+    ) -> Result<DelegationQueryResponse> {
+        crate::delegation::validate_delegation_query_request(request, jwt.is_some())?;
+        let mut builder = self.inner.post(query_url).json(request);
+        if let Some(jwt) = jwt {
+            builder = builder.bearer_auth(jwt);
+        }
+        Ok(builder.send().await?.error_for_status()?.json().await?)
     }
 
     fn url(&self, path: &str) -> String {
 
@@ -44,14 +44,21 @@ use serde::Serialize;
 use serde_json::{json, Value};
 use std::collections::BTreeMap;
 
+use crate::delegation::{
+    delegation_grant_event, delegation_revoke_event, is_principal_alias,
+    validate_delegation_grant_payload, DelegationGrantPayload, DelegationQueryRequest,
+    DelegationRevokePayload, PrincipalDescriptor, PrincipalDocument,
+};
 use crate::discourse::{
     discourse_event, event_type, room_create_event, validate_discourse_envelope,
     validate_room_path, verify_server_record, AgentStatusInput, JoinRequestStatus,
     MessageCreatePayload, ReasonPayload, Role, RoomCreatePayload, RoomJoinPayload,
     RoomJoinRequestInput, RoomJoinReviewPayload, RoomResponse, ServerRecord, Visibility,
 };
 use crate::error::{Result, SdkError};
-use crate::http_client::{DiscourseClient, ProfileClient, PublicRoomsOptions, RoomEventsOptions};
+use crate::http_client::{
+    DelegationClient, DiscourseClient, ProfileClient, PublicRoomsOptions, RoomEventsOptions,
+};
 use crate::identity::{
     unix_ms, unix_secs, AgentId, AgentSigner, ClientNonceManager, Envelope, RequestBinding,
     RequestJwtClaims, DEFAULT_REQUEST_JWT_TTL_SECS,
@@ -220,6 +227,11 @@ impl LocalConnector {
         match name {
             TOOL_IDENTITY_CURRENT => self.identity_current(),
             TOOL_HOSTS_LIST => self.hosts_list(),
+            TOOL_PRINCIPAL_RESOLVE => self.principal_resolve(parse_input(input)?).await,
+            TOOL_DELEGATION_CHECK => self.delegation_check(parse_input(input)?).await,
+            TOOL_DELEGATIONS_LIST => self.delegations_list(parse_input(input)?).await,
+            TOOL_DELEGATION_GRANT => self.delegation_grant(parse_input(input)?).await,
+            TOOL_DELEGATION_REVOKE => self.delegation_revoke(parse_input(input)?).await,
             TOOL_ROOMS_SEARCH => self.rooms_search(parse_input(input)?).await,
             TOOL_ROOMS_LIST => self.rooms_list(parse_input(input)?),
             TOOL_ROOM_OPEN => self.room_open(parse_input(input)?).await,
@@ -875,6 +887,132 @@ impl LocalConnector {
         }))
     }
 
+    /// Resolves a principal per Agent Delegation Section 5.3 and reports
+    /// whether the requested URL is an alias the principal acknowledges. Any
+    /// origin can redirect to any principal, so an unlisted URL is never
+    /// presented as a name for it.
+    async fn resolve_principal(&self, url: &str) -> Result<(PrincipalDocument, bool)> {
+        let document = DelegationClient::new(url).principal(Some(url)).await?;
+        let alias = document.id != url && is_principal_alias(&document, url);
+        Ok((document, alias))
+    }
+
+    /// Resolves the principal and refuses when the active Agent ID is not one
+    /// of its controller keys, so a grant that could never be accepted is not
+    /// signed or transmitted.
+    async fn controller_principal(&self, principal_id: &str) -> Result<PrincipalDocument> {
+        let (document, _) = self.resolve_principal(principal_id).await?;
+        let active = self.agent_id();
+        if !document.controllers.contains(&active) {
+            return Err(SdkError::InvalidPayload(format!(
+                "active agent {active} is not a controller key of {}",
+                document.id
+            )));
+        }
+        Ok(document)
+    }
+
+    async fn principal_resolve(&self, input: PrincipalResolveInput) -> Result<Value> {
+        let (document, alias) = self.resolve_principal(&input.url).await?;
+        json_result(json!({
+            "canonical_id": document.id,
+            "requested_url": input.url,
+            "alias": alias,
+            "principal": document,
+        }))
+    }
+
+    async fn delegation_check(&self, input: DelegationCheckInput) -> Result<Value> {
+        let (document, _) = self.resolve_principal(&input.principal_id).await?;
+        // The authoritative service is the one the principal names, never one
+        // supplied by whoever presented a credential.
+        let query_url = document.delegation_query_url.clone().ok_or_else(|| {
+            SdkError::InvalidPayload(format!(
+                "principal {} publishes no delegation_query_url",
+                document.id
+            ))
+        })?;
+        let request = DelegationQueryRequest {
+            subject: Some(input.subject.unwrap_or_else(|| self.agent_id())),
+            principal_id: Some(document.id.clone()),
+            id: input.id,
+            status: input.status,
+            limit: None,
+        };
+        let response = DelegationClient::new(&query_url)
+            .query_delegations_at(&query_url, &request, None)
+            .await?;
+        json_result(json!({
+            "canonical_id": document.id,
+            "query_url": query_url,
+            "delegations": response.result,
+        }))
+    }
+
+    async fn delegations_list(&self, input: DelegationsListInput) -> Result<Value> {
+        // Enumerating one subject requires authorization; the connector proves
+        // the active identity and never enumerates anyone else.
+        let jwt = self.request_jwt(&input.delegation_service)?;
+        let request = DelegationQueryRequest {
+            subject: Some(self.agent_id()),
+            principal_id: None,
+            id: None,
+            status: input.status,
+            limit: input.limit,
+        };
+        let response = DelegationClient::new(&input.delegation_service)
+            .query_delegations(&request, Some(&jwt))
+            .await?;
+        json_result(json!({ "delegations": response.result }))
+    }
+
+    async fn delegation_grant(&mut self, input: DelegationGrantInput) -> Result<Value> {
+        let principal = self.controller_principal(&input.principal_id).await?;
+        let mut payload = DelegationGrantPayload::new(
+            input.id,
+            PrincipalDescriptor::new(principal.id),
+            input.subject,
+            input.scopes,
+        );
+        payload.relationship = input.relationship;
+        payload.constraints = input.constraints;
+        payload.not_before = input.not_before;
+        payload.expires_at = input.expires_at;
+        let created_at = unix_ms();
+        validate_delegation_grant_payload(&payload, Some(created_at))?;
+        let event = delegation_grant_event(
+            self.agent_id(),
+            created_at,
+            self.nonce_manager.next_nonce()?,
+            payload,
+        );
+        let envelope = self.signer.sign_event(event)?;
+        let credential = DelegationClient::new(&input.delegation_service)
+            .submit_delegation_event(&envelope)
+            .await?;
+        json_result(json!({ "credential": credential, "envelope": envelope }))
+    }
+
+    async fn delegation_revoke(&mut self, input: DelegationRevokeInput) -> Result<Value> {
+        let principal = self.controller_principal(&input.principal_id).await?;
+        let payload = DelegationRevokePayload {
+            id: input.id,
+            principal_id: principal.id,
+            reason: input.reason,
+        };
+        let event = delegation_revoke_event(
+            self.agent_id(),
+            unix_ms(),
+            self.nonce_manager.next_nonce()?,
+            payload,
+        );
+        let envelope = self.signer.sign_event(event)?;
+        let result = DelegationClient::new(&input.delegation_service)
+            .submit_delegation_event(&envelope)
+            .await?;
+        json_result(json!({ "result": result, "envelope": envelope }))
+    }
+
     async fn profile_update(&mut self, input: ProfileUpdateInput) -> Result<Value> {
         let mut profile = input.profile;
         let object = profile
 
@@ -8,6 +8,11 @@ use serde_json::{json, Value};
 
 pub const TOOL_IDENTITY_CURRENT: &str = "agent_protocols_identity_current";
 pub const TOOL_HOSTS_LIST: &str = "agent_protocols_hosts_list";
+pub const TOOL_PRINCIPAL_RESOLVE: &str = "agent_protocols_principal_resolve";
+pub const TOOL_DELEGATION_CHECK: &str = "agent_protocols_delegation_check";
+pub const TOOL_DELEGATIONS_LIST: &str = "agent_protocols_delegations_list";
+pub const TOOL_DELEGATION_GRANT: &str = "agent_protocols_delegation_grant";
+pub const TOOL_DELEGATION_REVOKE: &str = "agent_protocols_delegation_revoke";
 pub const TOOL_ROOMS_SEARCH: &str = "agent_protocols_rooms_search";
 pub const TOOL_ROOMS_LIST: &str = "agent_protocols_rooms_list";
 pub const TOOL_ROOM_OPEN: &str = "agent_protocols_room_open";
@@ -79,6 +84,41 @@ pub fn standard_tool_definitions() -> Vec<LocalConnectorToolDefinition> {
             true,
             false,
         ),
+        (
+            TOOL_PRINCIPAL_RESOLVE,
+            "Resolve a principal URL to its canonical identifier and controller keys.",
+            true,
+            true,
+            true,
+        ),
+        (
+            TOOL_DELEGATION_CHECK,
+            "Check whether an agent holds a delegation from a principal.",
+            true,
+            true,
+            true,
+        ),
+        (
+            TOOL_DELEGATIONS_LIST,
+            "List the active local agent's own delegation credentials.",
+            true,
+            true,
+            true,
+        ),
+        (
+            TOOL_DELEGATION_GRANT,
+            "Sign and submit delegation.grant as a controller key of the principal.",
+            false,
+            false,
+            true,
+        ),
+        (
+            TOOL_DELEGATION_REVOKE,
+            "Sign and submit delegation.revoke as a controller key of the principal.",
+            false,
+            false,
+            true,
+        ),
         (
             TOOL_ROOMS_SEARCH,
             "Search public rooms on an allowed host.",
 
@@ -6,11 +6,63 @@ use serde::Deserialize;
 use serde_json::Value;
 use std::collections::BTreeMap;
 
+use crate::delegation::DelegationStatus;
 use crate::discourse::{JoinDecision, Role, TypeDeclaration, Visibility};
 use crate::identity::AgentId;
 
 use super::views::{DraftAction, HeadMismatchPolicy, RoomMemberStatus};
 
+#[derive(Deserialize)]
+pub(crate) struct PrincipalResolveInput {
+    pub url: String,
+}
+
+#[derive(Deserialize)]
+pub(crate) struct DelegationCheckInput {
+    pub principal_id: String,
+    #[serde(default)]
+    pub subject: Option<AgentId>,
+    #[serde(default)]
+    pub id: Option<String>,
+    #[serde(default)]
+    pub status: Option<DelegationStatus>,
+}
+
+#[derive(Deserialize)]
+pub(crate) struct DelegationsListInput {
+    pub delegation_service: String,
+    #[serde(default)]
+    pub status: Option<DelegationStatus>,
+    #[serde(default)]
+    pub limit: Option<u32>,
+}
+
+#[derive(Deserialize)]
+pub(crate) struct DelegationGrantInput {
+    pub delegation_service: String,
+    pub id: String,
+    pub principal_id: String,
+    pub subject: AgentId,
+    #[serde(default)]
+    pub relationship: Option<String>,
+    pub scopes: Vec<String>,
+    #[serde(default)]
+    pub constraints: BTreeMap<String, Value>,
+    #[serde(default)]
+    pub not_before: Option<i64>,
+    #[serde(default)]
+    pub expires_at: Option<i64>,
+}
+
+#[derive(Deserialize)]
+pub(crate) struct DelegationRevokeInput {
+    pub delegation_service: String,
+    pub id: String,
+    pub principal_id: String,
+    #[serde(default)]
+    pub reason: Option<String>,
+}
+
 #[derive(Deserialize)]
 pub(crate) struct RoomsSearchInput {
     pub host: String,