Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
feat(auth): record whether a user credential is a Macro API JWT (#8535)
Wolf Mermelstein4a6d5edae94a
diff --git a/crates/agent_harness/src/inbound/repositories/test.rs b/crates/agent_harness/src/inbound/repositories/test.rsindex 87cfe05769..118bf70b6a 100644--- a/crates/agent_harness/src/inbound/repositories/test.rs+++ b/crates/agent_harness/src/inbound/repositories/test.rs@@ -31,6 +31,15 @@ impl MacroAuthorizationService for TestAuthorizationService {})}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_internal(&self,_provided_key: &str,diff --git a/crates/agent_harness/src/inbound/runtime_gateway/test.rs b/crates/agent_harness/src/inbound/runtime_gateway/test.rsindex 40acaab52e..3ae2fb1c0b 100644--- a/crates/agent_harness/src/inbound/runtime_gateway/test.rs+++ b/crates/agent_harness/src/inbound/runtime_gateway/test.rs@@ -23,13 +23,19 @@ const HARNESS_TOKEN: &str = "mhns_self_test";struct FakeJwtValidator;impl JwtValidator for FakeJwtValidator {- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {- Ok(ValidatedIdentity {- agent_id: None,- user_id: jwt.to_string(),- fusion_user_id: "fusion-user".to_string(),- organization_id: None,- permissions: None,+ fn validate_credential(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ Ok(macro_authorization::ValidatedCredential {+ origin: macro_authorization::CredentialOrigin::Session,+ identity: ValidatedIdentity {+ agent_id: None,+ user_id: jwt.to_string(),+ fusion_user_id: "fusion-user".to_string(),+ organization_id: None,+ permissions: None,+ },})}}@@ -57,6 +63,7 @@ impl HarnessAuthorizer for SelfHarnessAuthorizer {user_id: user_id.clone(),},acting_user: MacroUserAuthentication {+ origin: macro_authorization::CredentialOrigin::Harness,agent_id: None,macro_user_id,user_context: model_user::UserContext {diff --git a/crates/agent_session/src/inbound/axum_router/test.rs b/crates/agent_session/src/inbound/axum_router/test.rsindex 7a9412a577..bded5efcbb 100644--- a/crates/agent_session/src/inbound/axum_router/test.rs+++ b/crates/agent_session/src/inbound/axum_router/test.rs@@ -98,13 +98,19 @@ const TEAM_ID: Uuid = Uuid::from_u128(0x7EA3);struct FakeJwtValidator;impl JwtValidator for FakeJwtValidator {- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {- Ok(ValidatedIdentity {- agent_id: None,- user_id: jwt.to_string(),- fusion_user_id: "fusion-user".to_string(),- organization_id: None,- permissions: None,+ fn validate_credential(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ Ok(macro_authorization::ValidatedCredential {+ origin: macro_authorization::CredentialOrigin::Session,+ identity: ValidatedIdentity {+ agent_id: None,+ user_id: jwt.to_string(),+ fusion_user_id: "fusion-user".to_string(),+ organization_id: None,+ permissions: None,+ },})}}@@ -128,6 +134,7 @@ impl BotAuthorizer for SelfBotAuthorizer {let macro_user_id = MacroUserIdStr::try_from(user_id.clone()).map_err(|_| Report::new(MacroAuthorizationError::ActingUserNotAuthorized))?;Some(MacroUserAuthentication {+ origin: macro_authorization::CredentialOrigin::Bot,agent_id: None,macro_user_id,user_context: model_user::UserContext {@@ -175,6 +182,7 @@ impl HarnessAuthorizer for SelfHarnessAuthorizer {user_id: user_id.clone(),},acting_user: MacroUserAuthentication {+ origin: macro_authorization::CredentialOrigin::Harness,agent_id: None,macro_user_id,user_context: model_user::UserContext {diff --git a/crates/agent_session/src/inbound/coding_agents/test.rs b/crates/agent_session/src/inbound/coding_agents/test.rsindex 98a7d2920f..c84464e978 100644--- a/crates/agent_session/src/inbound/coding_agents/test.rs+++ b/crates/agent_session/src/inbound/coding_agents/test.rs@@ -17,13 +17,19 @@ const KEY: &str = "coding-test-internal-key";struct UserCredentials;impl JwtValidator for UserCredentials {- fn validate(&self, _: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {- Ok(ValidatedIdentity {- agent_id: None,- user_id: USER.into(),- fusion_user_id: "fusion-owner".into(),- organization_id: None,- permissions: None,+ fn validate_credential(+ &self,+ _: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ Ok(macro_authorization::ValidatedCredential {+ origin: macro_authorization::CredentialOrigin::Session,+ identity: ValidatedIdentity {+ agent_id: None,+ user_id: USER.into(),+ fusion_user_id: "fusion-owner".into(),+ organization_id: None,+ permissions: None,+ },})}}diff --git a/crates/agent_session/src/inbound/routine_sessions/test.rs b/crates/agent_session/src/inbound/routine_sessions/test.rsindex 39e27a83e2..c439d51f0d 100644--- a/crates/agent_session/src/inbound/routine_sessions/test.rs+++ b/crates/agent_session/src/inbound/routine_sessions/test.rs@@ -25,13 +25,19 @@ const OPERATIONS: [&str; 5] = ["validate", "prepare", "prompt", "status", "cancestruct Credentials;impl JwtValidator for Credentials {- fn validate(&self, _: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {- Ok(ValidatedIdentity {- agent_id: None,- user_id: OWNER.into(),- fusion_user_id: "fusion-owner".into(),- organization_id: None,- permissions: None,+ fn validate_credential(+ &self,+ _: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ Ok(macro_authorization::ValidatedCredential {+ origin: macro_authorization::CredentialOrigin::Session,+ identity: ValidatedIdentity {+ agent_id: None,+ user_id: OWNER.into(),+ fusion_user_id: "fusion-owner".into(),+ organization_id: None,+ permissions: None,+ },})}}@@ -66,6 +72,7 @@ impl HarnessAuthorizer for Credentials {user_id: OWNER.into(),},acting_user: MacroUserAuthentication {+ origin: macro_authorization::CredentialOrigin::Harness,agent_id: None,macro_user_id: MacroUserIdStr::try_from(OWNER).unwrap(),user_context: model_user::UserContext {diff --git a/crates/ai_projections/src/inbound/axum_router/test.rs b/crates/ai_projections/src/inbound/axum_router/test.rsindex af07a6129c..95f077a5c1 100644--- a/crates/ai_projections/src/inbound/axum_router/test.rs+++ b/crates/ai_projections/src/inbound/axum_router/test.rs@@ -39,6 +39,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {Ok(test_user_context())}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_internal(&self,_provided_key: &str,diff --git a/crates/ai_tools/src/test/booking_links.rs b/crates/ai_tools/src/test/booking_links.rsindex ddd43d1e3c..f7b0c44515 100644--- a/crates/ai_tools/src/test/booking_links.rs+++ b/crates/ai_tools/src/test/booking_links.rs@@ -36,6 +36,15 @@ impl MacroAuthorizationService for NoAuth {async fn authorize(&self, _: &str) -> Result<UserContext, Report<MacroAuthorizationError>> {Err(Report::new(MacroAuthorizationError::InvalidCredentials))}++ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }async fn authorize_internal(&self,_: &str,diff --git a/crates/bots/src/inbound/axum_router/tests.rs b/crates/bots/src/inbound/axum_router/tests.rsindex c17af61382..0ebfe618aa 100644--- a/crates/bots/src/inbound/axum_router/tests.rs+++ b/crates/bots/src/inbound/axum_router/tests.rs@@ -419,17 +419,23 @@ impl EntityAccessService for TestAccessService {struct FakeJwtValidator;impl JwtValidator for FakeJwtValidator {- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {+ fn validate_credential(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {if jwt == INVALID_BEARER_TOKEN {return Err(Report::new(MacroAuthorizationError::InvalidCredentials));}- Ok(ValidatedIdentity {- agent_id: None,- user_id: jwt.to_string(),- fusion_user_id: "fusion-user".to_string(),- organization_id: None,- permissions: None,+ Ok(macro_authorization::ValidatedCredential {+ origin: macro_authorization::CredentialOrigin::Session,+ identity: ValidatedIdentity {+ agent_id: None,+ user_id: jwt.to_string(),+ fusion_user_id: "fusion-user".to_string(),+ organization_id: None,+ permissions: None,+ },})}}diff --git a/crates/bots/src/inbound/channel_webhook_router/tests.rs b/crates/bots/src/inbound/channel_webhook_router/tests.rsindex 33c89321be..f51140cbe2 100644--- a/crates/bots/src/inbound/channel_webhook_router/tests.rs+++ b/crates/bots/src/inbound/channel_webhook_router/tests.rs@@ -733,13 +733,19 @@ impl BotAuthorizer for TestBotAuthorizer {struct FakeJwtValidator;impl JwtValidator for FakeJwtValidator {- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {- Ok(ValidatedIdentity {- agent_id: None,- user_id: jwt.to_string(),- fusion_user_id: "fusion-user".to_string(),- organization_id: None,- permissions: None,+ fn validate_credential(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ Ok(macro_authorization::ValidatedCredential {+ origin: macro_authorization::CredentialOrigin::Session,+ identity: ValidatedIdentity {+ agent_id: None,+ user_id: jwt.to_string(),+ fusion_user_id: "fusion-user".to_string(),+ organization_id: None,+ permissions: None,+ },})}}@@ -823,6 +829,7 @@ fn bot_authentication_with_acting_user(bot_id: BotId) -> BotAuthentication {bot_scope: BotScope::User,team_id: None,acting_user: Some(MacroUserAuthentication {+ origin: macro_authorization::CredentialOrigin::Bot,agent_id: None,macro_user_id: MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap(),user_context: Default::default(),diff --git a/crates/calendar_scheduling/src/domain/service/test/http_administration.rs b/crates/calendar_scheduling/src/domain/service/test/http_administration.rsindex 070dfa22e6..7d6b058a1b 100644--- a/crates/calendar_scheduling/src/domain/service/test/http_administration.rs+++ b/crates/calendar_scheduling/src/domain/service/test/http_administration.rs@@ -20,6 +20,15 @@ impl MacroAuthorizationService for Identity {async fn authorize(&self, _: &str) -> Result<UserContext, Report<MacroAuthorizationError>> {Err(Report::new(MacroAuthorizationError::InvalidCredentials))}++ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }async fn authorize_internal(&self,key: &str,diff --git a/crates/calendar_scheduling/src/inbound/router/test.rs b/crates/calendar_scheduling/src/inbound/router/test.rsindex cb74a298e5..c282d8f84f 100644--- a/crates/calendar_scheduling/src/inbound/router/test.rs+++ b/crates/calendar_scheduling/src/inbound/router/test.rs@@ -25,6 +25,15 @@ impl MacroAuthorizationService for Identity {..Default::default()})}++ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }async fn authorize_internal(&self,_: &str,diff --git a/crates/channels/src/inbound/axum_router/test.rs b/crates/channels/src/inbound/axum_router/test.rsindex 7748b27aa9..1e88456385 100644--- a/crates/channels/src/inbound/axum_router/test.rs+++ b/crates/channels/src/inbound/axum_router/test.rs@@ -706,7 +706,10 @@ impl FakeJwtValidator {}impl JwtValidator for FakeJwtValidator {- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {+ fn validate_credential(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {self.validation_count.fetch_add(1, Ordering::SeqCst);let organization_id = match jwt {@@ -716,12 +719,15 @@ impl JwtValidator for FakeJwtValidator {_ => return Err(Report::new(MacroAuthorizationError::InvalidCredentials)),};- Ok(ValidatedIdentity {- agent_id: None,- user_id: TEST_USER_ID.to_string(),- fusion_user_id: "test-fusion-user".to_string(),- organization_id,- permissions: None,+ Ok(macro_authorization::ValidatedCredential {+ origin: macro_authorization::CredentialOrigin::Session,+ identity: ValidatedIdentity {+ agent_id: None,+ user_id: TEST_USER_ID.to_string(),+ fusion_user_id: "test-fusion-user".to_string(),+ organization_id,+ permissions: None,+ },})}}diff --git a/crates/channels/src/inbound/list_router/test.rs b/crates/channels/src/inbound/list_router/test.rsindex c51199ffed..a017b47a19 100644--- a/crates/channels/src/inbound/list_router/test.rs+++ b/crates/channels/src/inbound/list_router/test.rs@@ -111,14 +111,20 @@ impl ChannelListService for FakeChannelListService {struct FakeJwtValidator;impl JwtValidator for FakeJwtValidator {- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {+ fn validate_credential(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {match jwt {- VALID_BEARER_TOKEN => Ok(ValidatedIdentity {- agent_id: None,- user_id: BEARER_USER_ID.to_string(),- fusion_user_id: "fusion-user-id".to_string(),- organization_id: None,- permissions: None,+ VALID_BEARER_TOKEN => Ok(macro_authorization::ValidatedCredential {+ origin: macro_authorization::CredentialOrigin::Session,+ identity: ValidatedIdentity {+ agent_id: None,+ user_id: BEARER_USER_ID.to_string(),+ fusion_user_id: "fusion-user-id".to_string(),+ organization_id: None,+ permissions: None,+ },}),EXPIRED_BEARER_TOKEN => Err(Report::new(MacroAuthorizationError::CredentialsExpired)),_ => Err(Report::new(MacroAuthorizationError::InvalidCredentials)),diff --git a/crates/chat/src/inbound/test.rs b/crates/chat/src/inbound/test.rsindex 9f6e8b75c7..f370977a09 100644--- a/crates/chat/src/inbound/test.rs+++ b/crates/chat/src/inbound/test.rs@@ -517,6 +517,18 @@ impl MacroAuthorizationService for FakeAuthorizationService {})}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> std::result::Result<+ macro_authorization::ValidatedCredential,+ Report<MacroAuthorizationError>,+ > {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_internal(&self,_provided_key: &str,@@ -543,6 +555,7 @@ impl MacroAuthorizationService for FakeAuthorizationService {acting_user: acting_user.and_then(|claims| claims.user_id).map(|user_id| MacroUserAuthentication {+ origin: macro_authorization::CredentialOrigin::Bot,agent_id: None,macro_user_id: MacroUserIdStr::try_from(user_id.clone()).expect("test user id should be valid"),diff --git a/crates/complete_graph/src/schema/test.rs b/crates/complete_graph/src/schema/test.rsindex 13b618e0a7..73614dcbf2 100644--- a/crates/complete_graph/src/schema/test.rs+++ b/crates/complete_graph/src/schema/test.rs@@ -1265,6 +1265,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {}}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_internal(&self,provided_key: &str,diff --git a/crates/contacts/src/inbound/http/test.rs b/crates/contacts/src/inbound/http/test.rsindex a1b5b9ae6f..6fd0f42583 100644--- a/crates/contacts/src/inbound/http/test.rs+++ b/crates/contacts/src/inbound/http/test.rs@@ -63,7 +63,10 @@ impl FakeJwtValidator {}impl JwtValidator for FakeJwtValidator {- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {+ fn validate_credential(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {self.validation_count.fetch_add(1, Ordering::SeqCst);let user_id = match jwt {@@ -73,12 +76,15 @@ impl JwtValidator for FakeJwtValidator {_ => return Err(Report::new(MacroAuthorizationError::InvalidCredentials)),};- Ok(ValidatedIdentity {- agent_id: None,- user_id: user_id.to_string(),- fusion_user_id: "fusion-user-id".to_string(),- permissions: None,- organization_id: None,+ Ok(macro_authorization::ValidatedCredential {+ origin: macro_authorization::CredentialOrigin::Session,+ identity: ValidatedIdentity {+ agent_id: None,+ user_id: user_id.to_string(),+ fusion_user_id: "fusion-user-id".to_string(),+ permissions: None,+ organization_id: None,+ },})}}diff --git a/crates/crm/src/inbound/axum_extractors/test.rs b/crates/crm/src/inbound/axum_extractors/test.rsindex 2ad34fd123..d60e24dd89 100644--- a/crates/crm/src/inbound/axum_extractors/test.rs+++ b/crates/crm/src/inbound/axum_extractors/test.rs@@ -56,14 +56,20 @@ const TEAM_ID: &str = "55555555-5555-4555-8555-555555555555";struct FakeJwtValidator;impl JwtValidator for FakeJwtValidator {- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {+ fn validate_credential(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {match jwt {- VALID_TOKEN => Ok(ValidatedIdentity {- agent_id: None,- user_id: USER_ID.to_string(),- fusion_user_id: "test-fusion-user".to_string(),- organization_id: None,- permissions: None,+ VALID_TOKEN => Ok(macro_authorization::ValidatedCredential {+ origin: macro_authorization::CredentialOrigin::Session,+ identity: ValidatedIdentity {+ agent_id: None,+ user_id: USER_ID.to_string(),+ fusion_user_id: "test-fusion-user".to_string(),+ organization_id: None,+ permissions: None,+ },}),"expired" => Err(Report::new(MacroAuthorizationError::CredentialsExpired)),_ => Err(Report::new(MacroAuthorizationError::InvalidCredentials)),diff --git a/crates/crm/tests/pipelines.rs b/crates/crm/tests/pipelines.rsindex d9cad85d57..26b96955b4 100644--- a/crates/crm/tests/pipelines.rs+++ b/crates/crm/tests/pipelines.rs@@ -727,21 +727,27 @@ async fn http_creation_listing_schema_and_records_use_pipeline_access(pool: PgPo#[derive(Clone)]struct Token;impl JwtValidator for Token {- fn validate(+ fn validate_credential(&self,jwt: &str,- ) -> Result<ValidatedIdentity, rootcause::Report<MacroAuthorizationError>> {+ ) -> Result<+ macro_authorization::ValidatedCredential,+ rootcause::Report<MacroAuthorizationError>,+ > {if jwt != "owner" && jwt != "outsider" {return Err(rootcause::Report::new(MacroAuthorizationError::InvalidCredentials,));}- Ok(ValidatedIdentity {- agent_id: None,- user_id: if jwt == "owner" { OWNER } else { OUTSIDER }.into(),- fusion_user_id: "test-fusion-user".into(),- organization_id: None,- permissions: None,+ Ok(macro_authorization::ValidatedCredential {+ origin: macro_authorization::CredentialOrigin::Session,+ identity: ValidatedIdentity {+ agent_id: None,+ user_id: if jwt == "owner" { OWNER } else { OUTSIDER }.into(),+ fusion_user_id: "test-fusion-user".into(),+ organization_id: None,+ permissions: None,+ },})}}diff --git a/crates/databases/src/inbound/axum_router/test/fakes.rs b/crates/databases/src/inbound/axum_router/test/fakes.rsindex 832ba1d51e..b1b1f8e8d3 100644--- a/crates/databases/src/inbound/axum_router/test/fakes.rs+++ b/crates/databases/src/inbound/axum_router/test/fakes.rs@@ -42,14 +42,20 @@ const USER: &str = "macro|[email protected]";struct ValidToken;impl JwtValidator for ValidToken {- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {+ fn validate_credential(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {match jwt {- "valid" => Ok(ValidatedIdentity {- agent_id: None,- user_id: USER.to_string(),- fusion_user_id: "fusion-ops-router".to_string(),- organization_id: None,- permissions: None,+ "valid" => Ok(macro_authorization::ValidatedCredential {+ origin: macro_authorization::CredentialOrigin::Session,+ identity: ValidatedIdentity {+ agent_id: None,+ user_id: USER.to_string(),+ fusion_user_id: "fusion-ops-router".to_string(),+ organization_id: None,+ permissions: None,+ },}),_ => Err(Report::new(MacroAuthorizationError::InvalidCredentials)),}diff --git a/crates/databases_sql/src/service/test/http.rs b/crates/databases_sql/src/service/test/http.rsindex e8522a94a4..e2f74890d6 100644--- a/crates/databases_sql/src/service/test/http.rs+++ b/crates/databases_sql/src/service/test/http.rs@@ -16,10 +16,11 @@ use tower::ServiceExt;struct Token;impl JwtValidator for Token {- fn validate(+ fn validate_credential(&self,jwt: &str,- ) -> Result<ValidatedIdentity, rootcause::Report<MacroAuthorizationError>> {+ ) -> Result<macro_authorization::ValidatedCredential, rootcause::Report<MacroAuthorizationError>>+ {let user_id = match jwt {"owner" => OWNER,"viewer" => VIEWER,@@ -29,12 +30,15 @@ impl JwtValidator for Token {));}};- Ok(ValidatedIdentity {- agent_id: None,- user_id: user_id.into(),- fusion_user_id: "fusion-sql-test".into(),- organization_id: None,- permissions: None,+ Ok(macro_authorization::ValidatedCredential {+ origin: macro_authorization::CredentialOrigin::Session,+ identity: ValidatedIdentity {+ agent_id: None,+ user_id: user_id.into(),+ fusion_user_id: "fusion-sql-test".into(),+ organization_id: None,+ permissions: None,+ },})}}diff --git a/crates/dictation/src/inbound/axum_router/test.rs b/crates/dictation/src/inbound/axum_router/test.rsindex a4f2227df9..e4d869ab6e 100644--- a/crates/dictation/src/inbound/axum_router/test.rs+++ b/crates/dictation/src/inbound/axum_router/test.rs@@ -118,6 +118,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {})}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_internal(&self,provided_key: &str,diff --git a/crates/documents/src/inbound/axum_router/tests.rs b/crates/documents/src/inbound/axum_router/tests.rsindex 4ef1d8f700..d165421b8c 100644--- a/crates/documents/src/inbound/axum_router/tests.rs+++ b/crates/documents/src/inbound/axum_router/tests.rs@@ -863,6 +863,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {Ok(user_context(JWT_USER_ID))}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_internal(&self,provided_key: &str,@@ -901,6 +910,7 @@ impl MacroAuthorizationService for FakeAuthorizationService {acting_user: acting_user.and_then(|claims| claims.user_id).map(|user_id| MacroUserAuthentication {+ origin: macro_authorization::CredentialOrigin::Bot,agent_id: None,macro_user_id: user(&user_id),user_context: user_context(&user_id),diff --git a/crates/entity_access/src/inbound/axum_extractors/call/test.rs b/crates/entity_access/src/inbound/axum_extractors/call/test.rsindex f985114ce1..4d5ccfcafd 100644--- a/crates/entity_access/src/inbound/axum_extractors/call/test.rs+++ b/crates/entity_access/src/inbound/axum_extractors/call/test.rs@@ -292,6 +292,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {}}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_bot(&self,token: &str,diff --git a/crates/entity_access/src/inbound/axum_extractors/channel/test.rs b/crates/entity_access/src/inbound/axum_extractors/channel/test.rsindex c1d4baf287..125f61e3e1 100644--- a/crates/entity_access/src/inbound/axum_extractors/channel/test.rs+++ b/crates/entity_access/src/inbound/axum_extractors/channel/test.rs@@ -231,6 +231,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {}}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_bot(&self,token: &str,diff --git a/crates/entity_access/src/inbound/axum_extractors/chat/test.rs b/crates/entity_access/src/inbound/axum_extractors/chat/test.rsindex d79a27ba52..ce2f4d7ec3 100644--- a/crates/entity_access/src/inbound/axum_extractors/chat/test.rs+++ b/crates/entity_access/src/inbound/axum_extractors/chat/test.rs@@ -56,6 +56,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {}}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_bot(&self,token: &str,diff --git a/crates/entity_access/src/inbound/axum_extractors/document/test.rs b/crates/entity_access/src/inbound/axum_extractors/document/test.rsindex 5d0badce0c..129324c2d5 100644--- a/crates/entity_access/src/inbound/axum_extractors/document/test.rs+++ b/crates/entity_access/src/inbound/axum_extractors/document/test.rs@@ -65,6 +65,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {}}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_bot(&self,token: &str,diff --git a/crates/entity_access/src/inbound/axum_extractors/entity_permission/test.rs b/crates/entity_access/src/inbound/axum_extractors/entity_permission/test.rsindex cc58ba8ada..225f6f4305 100644--- a/crates/entity_access/src/inbound/axum_extractors/entity_permission/test.rs+++ b/crates/entity_access/src/inbound/axum_extractors/entity_permission/test.rs@@ -257,6 +257,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {}}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_bot(&self,token: &str,diff --git a/crates/entity_access/src/inbound/axum_extractors/initiative/test.rs b/crates/entity_access/src/inbound/axum_extractors/initiative/test.rsindex 3ba3ce9f28..14afd60f69 100644--- a/crates/entity_access/src/inbound/axum_extractors/initiative/test.rs+++ b/crates/entity_access/src/inbound/axum_extractors/initiative/test.rs@@ -85,6 +85,7 @@ async fn response_body(response: axum::response::Response) -> String {fn user_authentication(user_id: &str) -> MacroUserAuthentication {MacroUserAuthentication {+ origin: macro_authorization::CredentialOrigin::Session,agent_id: None,macro_user_id: MacroUserIdStr::try_from(user_id.to_string()).expect("valid user id"),user_context: UserContext {diff --git a/crates/entity_access/src/inbound/axum_extractors/principal/test.rs b/crates/entity_access/src/inbound/axum_extractors/principal/test.rsindex 7f89f95274..d80cac7d85 100644--- a/crates/entity_access/src/inbound/axum_extractors/principal/test.rs+++ b/crates/entity_access/src/inbound/axum_extractors/principal/test.rs@@ -17,6 +17,7 @@ async fn signed_agent_uses_owner_scope_and_preserves_both_identities() {let agent_id = bot_id::MACRO_NEW_BOT_ID;let owner = "macro|[email protected]".to_string().try_into().unwrap();let principal = MacroAuthorization::User(MacroUserAuthentication {+ origin: macro_authorization::CredentialOrigin::MacroApiJwt,agent_id: Some(agent_id),macro_user_id: owner,user_context: UserContext {@@ -58,6 +59,7 @@ async fn signed_agent_uses_owner_scope_and_preserves_both_identities() {async fn signed_agent_cannot_send_without_owner_access() {let service = FakeEntityAccessService::new(None);let principal = MacroAuthorization::User(MacroUserAuthentication {+ origin: macro_authorization::CredentialOrigin::MacroApiJwt,agent_id: Some(bot_id::MACRO_NEW_BOT_ID),macro_user_id: "macro|[email protected]".to_string().try_into().unwrap(),user_context: UserContext {@@ -83,6 +85,7 @@ async fn signed_agent_cannot_send_without_owner_access() {async fn signed_agent_does_not_change_caller_identity_for_existing_messages() {let service = FakeEntityAccessService::new(Some(AccessLevel::Edit));let principal = MacroAuthorization::User(MacroUserAuthentication {+ origin: macro_authorization::CredentialOrigin::MacroApiJwt,agent_id: Some(bot_id::MACRO_NEW_BOT_ID),macro_user_id: "macro|[email protected]".to_string().try_into().unwrap(),user_context: UserContext {diff --git a/crates/entity_access/src/inbound/axum_extractors/project/test.rs b/crates/entity_access/src/inbound/axum_extractors/project/test.rsindex 80d823aab4..2ee5ec08fb 100644--- a/crates/entity_access/src/inbound/axum_extractors/project/test.rs+++ b/crates/entity_access/src/inbound/axum_extractors/project/test.rs@@ -225,6 +225,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {}}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_bot(&self,token: &str,diff --git a/crates/entity_access/src/inbound/axum_extractors/team/test.rs b/crates/entity_access/src/inbound/axum_extractors/team/test.rsindex e144c7b680..6c630b36cb 100644--- a/crates/entity_access/src/inbound/axum_extractors/team/test.rs+++ b/crates/entity_access/src/inbound/axum_extractors/team/test.rs@@ -250,6 +250,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {}}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_bot(&self,token: &str,diff --git a/crates/entity_access/src/inbound/axum_extractors/test_support.rs b/crates/entity_access/src/inbound/axum_extractors/test_support.rsindex e73017736a..8013c6b362 100644--- a/crates/entity_access/src/inbound/axum_extractors/test_support.rs+++ b/crates/entity_access/src/inbound/axum_extractors/test_support.rs@@ -241,6 +241,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {}}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_bot(&self,token: &str,@@ -281,6 +290,7 @@ pub(super) fn user_scoped_bot_authentication() -> BotAuthentication {bot_scope: BotScope::User,team_id: None,acting_user: Some(MacroUserAuthentication {+ origin: macro_authorization::CredentialOrigin::Bot,agent_id: None,macro_user_id: MacroUserIdStr::try_from(BOT_ACTING_USER_ID.to_string()).expect("valid bot acting user id"),diff --git a/crates/entity_access/src/inbound/axum_extractors/thread/test.rs b/crates/entity_access/src/inbound/axum_extractors/thread/test.rsindex 514d9cd585..75152d3370 100644--- a/crates/entity_access/src/inbound/axum_extractors/thread/test.rs+++ b/crates/entity_access/src/inbound/axum_extractors/thread/test.rs@@ -60,6 +60,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {}}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_bot(&self,token: &str,diff --git a/crates/entity_registry/entity_registry/src/domain/creation_principal/test.rs b/crates/entity_registry/entity_registry/src/domain/creation_principal/test.rsindex 15215f4f3d..4bf76f26d0 100644--- a/crates/entity_registry/entity_registry/src/domain/creation_principal/test.rs+++ b/crates/entity_registry/entity_registry/src/domain/creation_principal/test.rs@@ -17,6 +17,7 @@ fn user_id() -> MacroUserIdStr<'static> {fn user() -> MacroUserAuthentication {MacroUserAuthentication {+ origin: macro_authorization::CredentialOrigin::Session,agent_id: None,macro_user_id: user_id(),user_context: Default::default(),diff --git a/crates/favorites/src/inbound/axum_router/test.rs b/crates/favorites/src/inbound/axum_router/test.rsindex d947b8235d..15eba53e7d 100644--- a/crates/favorites/src/inbound/axum_router/test.rs+++ b/crates/favorites/src/inbound/axum_router/test.rs@@ -35,6 +35,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {})}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_internal(&self,_provided_key: &str,diff --git a/crates/foreign_entity/src/inbound/axum_router/tests.rs b/crates/foreign_entity/src/inbound/axum_router/tests.rsindex b72400f8c4..b7d2bf06ba 100644--- a/crates/foreign_entity/src/inbound/axum_router/tests.rs+++ b/crates/foreign_entity/src/inbound/axum_router/tests.rs@@ -318,6 +318,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {unreachable!("internal requests should not authorize user credentials")}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_internal(&self,provided_key: &str,diff --git a/crates/forms/src/inbound/axum_router/test/fakes.rs b/crates/forms/src/inbound/axum_router/test/fakes.rsindex 23da59f633..33d4e46c66 100644--- a/crates/forms/src/inbound/axum_router/test/fakes.rs+++ b/crates/forms/src/inbound/axum_router/test/fakes.rs@@ -40,18 +40,24 @@ pub(super) const ROW: RowId = RowId::from_uuid(Uuid::from_u128(0x40));pub(super) struct Tokens;impl JwtValidator for Tokens {- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {+ fn validate_credential(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {let user_id = match jwt {"owner" => OWNER,"respondent" => RESPONDENT,_ => return Err(Report::new(MacroAuthorizationError::InvalidCredentials)),};- Ok(ValidatedIdentity {- agent_id: None,- user_id: user_id.to_string(),- fusion_user_id: format!("fusion-{jwt}"),- organization_id: None,- permissions: None,+ Ok(macro_authorization::ValidatedCredential {+ origin: macro_authorization::CredentialOrigin::Session,+ identity: ValidatedIdentity {+ agent_id: None,+ user_id: user_id.to_string(),+ fusion_user_id: format!("fusion-{jwt}"),+ organization_id: None,+ permissions: None,+ },})}}diff --git a/crates/github/src/inbound/github_sync_router/test.rs b/crates/github/src/inbound/github_sync_router/test.rsindex 861ff7c09f..48ebb3a468 100644--- a/crates/github/src/inbound/github_sync_router/test.rs+++ b/crates/github/src/inbound/github_sync_router/test.rs@@ -51,6 +51,15 @@ impl MacroAuthorizationService for TestAuthorizationService {})}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_internal(&self,_provided_key: &str,diff --git a/crates/graphql_common/src/authorization/test.rs b/crates/graphql_common/src/authorization/test.rsindex 16294ee0e9..b590e3fb8a 100644--- a/crates/graphql_common/src/authorization/test.rs+++ b/crates/graphql_common/src/authorization/test.rs@@ -49,6 +49,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {})}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_bot(&self,token: &str,diff --git a/crates/gtm_invite/src/inbound/axum_router/test.rs b/crates/gtm_invite/src/inbound/axum_router/test.rsindex 64ff068e10..6d1b36396b 100644--- a/crates/gtm_invite/src/inbound/axum_router/test.rs+++ b/crates/gtm_invite/src/inbound/axum_router/test.rs@@ -50,6 +50,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {}}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_internal(&self,_provided_key: &str,diff --git a/crates/import/src/inbound/axum_router/test.rs b/crates/import/src/inbound/axum_router/test.rsindex 6a728a70cf..af37e7a607 100644--- a/crates/import/src/inbound/axum_router/test.rs+++ b/crates/import/src/inbound/axum_router/test.rs@@ -32,6 +32,18 @@ impl MacroAuthorizationService for FakeAuthorization {})}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> std::result::Result<+ macro_authorization::ValidatedCredential,+ Report<MacroAuthorizationError>,+ > {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_internal(&self,_provided_key: &str,diff --git a/crates/initiative/src/inbound/axum_router/test.rs b/crates/initiative/src/inbound/axum_router/test.rsindex 71d9e0ee92..e18e107772 100644--- a/crates/initiative/src/inbound/axum_router/test.rs+++ b/crates/initiative/src/inbound/axum_router/test.rs@@ -112,6 +112,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {Ok(user_context())}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_internal(&self,_provided_key: &str,diff --git a/crates/macro_authorization/AGENTS.md b/crates/macro_authorization/AGENTS.mdindex e91df4e1c8..a494c33f83 100644--- a/crates/macro_authorization/AGENTS.md+++ b/crates/macro_authorization/AGENTS.md@@ -48,7 +48,18 @@ by policy.- `cargo test -p macro_authorization` (`SQLX_OFFLINE` unset).-`authorize_identity` retains signed agent attribution on user authentication. It+`ValidatedIdentity` contains identity facts; `ValidatedCredential` and+`MacroUserAuthentication` additionally carry `CredentialOrigin` (session, Macro API+JWT, user API key, or the acting user of a bot, harness or internal caller), set+where the credential is verified. Every `JwtValidator` implements+`validate_credential` (`validate` derives from it) and every+`MacroAuthorizationService` implements `authorize_identity`; neither has a default+that assumes a session. Session-only fakes use `ValidatedCredential::session`. The+production `MacroAuthJwtValidator` derives origin from the verified token enum in+one decode.+Personal-session-only capabilities match `origin == Session` (and no agent+attribution) instead of sniffing request headers. `authorize_identity` retains+verified origin and signed agent attribution on user authentication. Itdoes not turn a user credential into bot authority or change endpoint policies.## Gotchasdiff --git a/crates/macro_authorization/src/domain/bot_authorizer.rs b/crates/macro_authorization/src/domain/bot_authorizer.rsindex 2b44039338..dfbbe3508e 100644--- a/crates/macro_authorization/src/domain/bot_authorizer.rs+++ b/crates/macro_authorization/src/domain/bot_authorizer.rs@@ -10,7 +10,7 @@ use rootcause::Report;use super::{models::{BotActingUserClaims, BotAuthentication, BotAuthorizationOwner, BotScope,- BotTokenAuthorization, MacroAuthorizationError, MacroUserAuthentication,+ BotTokenAuthorization, CredentialOrigin, MacroAuthorizationError, MacroUserAuthentication,ResolvedBotActingUser,},ports::{BotAuthorizationRepo, BotAuthorizer},@@ -153,6 +153,7 @@ wherefn user_authentication(acting_user: ResolvedBotActingUser) -> MacroUserAuthentication {let user_id = acting_user.macro_user_id.as_ref().to_owned();MacroUserAuthentication {+ origin: CredentialOrigin::Bot,agent_id: None,macro_user_id: acting_user.macro_user_id,user_context: UserContext {diff --git a/crates/macro_authorization/src/domain/harness_authorizer.rs b/crates/macro_authorization/src/domain/harness_authorizer.rsindex 8d255e45a1..bbfebc43e9 100644--- a/crates/macro_authorization/src/domain/harness_authorizer.rs+++ b/crates/macro_authorization/src/domain/harness_authorizer.rs@@ -8,8 +8,9 @@ use rootcause::Report;use super::{models::{- HarnessAuthentication, HarnessAuthorizationOwner, HarnessTokenAuthorization,- MacroAuthorizationError, MacroUserAuthentication, ResolvedBotActingUser,+ CredentialOrigin, HarnessAuthentication, HarnessAuthorizationOwner,+ HarnessTokenAuthorization, MacroAuthorizationError, MacroUserAuthentication,+ ResolvedBotActingUser,},ports::{HarnessAuthorizationRepo, HarnessAuthorizer},};@@ -110,6 +111,7 @@ wherefn user_authentication(acting_user: ResolvedBotActingUser) -> MacroUserAuthentication {let user_id = acting_user.macro_user_id.as_ref().to_owned();MacroUserAuthentication {+ origin: CredentialOrigin::Harness,agent_id: None,macro_user_id: acting_user.macro_user_id,user_context: UserContext {diff --git a/crates/macro_authorization/src/domain/models.rs b/crates/macro_authorization/src/domain/models.rsindex 0801603f4e..b0e5c86704 100644--- a/crates/macro_authorization/src/domain/models.rs+++ b/crates/macro_authorization/src/domain/models.rs@@ -13,6 +13,8 @@ use uuid::Uuid;/// A user identity that has been authenticated or verified for a bot.#[derive(Clone, Debug)]pub struct MacroUserAuthentication {+ /// The kind of credential that established this user.+ pub origin: CredentialOrigin,/// Signed agent attribution for user-authorized SDK messages, not a bot credential.pub agent_id: Option<BotId>,/// The user's parsed Macro identifier.@@ -21,6 +23,25 @@ pub struct MacroUserAuthentication {pub user_context: UserContext,}+/// The kind of credential that authenticated a user, set where the credential+/// is verified. Policies that need a person's own session match on it rather+/// than on request hints.+#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub enum CredentialOrigin {+ /// A personal session JWT.+ Session,+ /// A verified Macro API JWT (SDK, MCP), with or without agent attribution.+ MacroApiJwt,+ /// A user API key.+ UserApiKey,+ /// The acting user of a verified bot credential.+ Bot,+ /// The acting user of a verified harness credential.+ Harness,+ /// The acting user claimed by a verified internal service caller.+ Internal,+}+/// The access scope selected for a bot-authorized request.#[derive(Clone, Copy, Debug, Eq, PartialEq)]pub enum BotScope {@@ -267,6 +288,31 @@ pub struct ValidatedIdentity {pub permissions: Option<HashSet<String>>,}+/// A validated identity together with its cryptographically established origin.+#[derive(Clone, Debug, Eq, PartialEq)]+pub struct ValidatedCredential {+ /// Identity established by credential validation.+ pub identity: ValidatedIdentity,+ /// The kind of credential that was verified.+ pub origin: CredentialOrigin,+}++impl ValidatedCredential {+ /// A personal session for this user context, with no agent attribution.+ pub fn session(context: UserContext) -> Self {+ Self {+ origin: CredentialOrigin::Session,+ identity: ValidatedIdentity {+ agent_id: None,+ user_id: context.user_id,+ fusion_user_id: context.fusion_user_id,+ organization_id: context.organization_id,+ permissions: context.permissions,+ },+ }+ }+}+/// Errors returned when a credential cannot authorize a caller.////// The variants deliberately omit validation implementation details so callersdiff --git a/crates/macro_authorization/src/domain/models/test.rs b/crates/macro_authorization/src/domain/models/test.rsindex 95f16dbb49..da78445e6d 100644--- a/crates/macro_authorization/src/domain/models/test.rs+++ b/crates/macro_authorization/src/domain/models/test.rs@@ -14,6 +14,7 @@ const TEAM_ID: Uuid = Uuid::from_u128(3);fn user_authentication() -> MacroUserAuthentication {MacroUserAuthentication {+ origin: crate::CredentialOrigin::Session,agent_id: None,macro_user_id: MacroUserIdStr::try_from("macro|[email protected]".to_string()).expect("valid Macro user id"),diff --git a/crates/macro_authorization/src/domain/ports.rs b/crates/macro_authorization/src/domain/ports.rsindex ebb3211d65..0878db8828 100644--- a/crates/macro_authorization/src/domain/ports.rs+++ b/crates/macro_authorization/src/domain/ports.rs@@ -6,7 +6,7 @@ use rootcause::Report;use super::models::{BotActingUserClaims, BotAuthentication, BotScope, BotTokenAuthorization, HarnessAuthentication,HarnessTokenAuthorization, InternalIdentityClaims, MacroAuthorizationError, ResolvedApiKeyUser,- ResolvedBotActingUser, ValidatedIdentity,+ ResolvedBotActingUser, ValidatedCredential, ValidatedIdentity,};use uuid::Uuid;@@ -166,8 +166,19 @@ impl HarnessAuthorizer for NoHarnessAuthorizer {/// Implementations resolve any required secrets during startup, allowing this/// operation to remain synchronous.pub trait JwtValidator: Clone + Send + Sync + 'static {+ /// Validate a credential and return its identity together with the kind+ /// of credential it was, derived from the cryptographically validated+ /// token, never from request hints.+ fn validate_credential(+ &self,+ jwt: &str,+ ) -> Result<ValidatedCredential, Report<MacroAuthorizationError>>;+/// Validate a credential and return its transport-independent identity.- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>>;+ fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {+ self.validate_credential(jwt)+ .map(|credential| credential.identity)+ }}/// Authorizes credentials and constructs application user contexts.@@ -181,24 +192,13 @@ pub trait MacroAuthorizationService: Clone + Send + Sync + 'static {jwt: &str,) -> impl Future<Output = Result<UserContext, Report<MacroAuthorizationError>>> + Send;- /// Authorize a user credential while retaining signed agent attribution.- /// Context-only authorizers establish no agent identity.+ /// Authorize a user credential while retaining its verified origin and+ /// signed agent attribution. Every authorizer states the origin of the+ /// credentials it accepts; there is no default that assumes a session.fn authorize_identity(&self,jwt: &str,- ) -> impl Future<Output = Result<ValidatedIdentity, Report<MacroAuthorizationError>>> + Send- {- async {- let context = self.authorize(jwt).await?;- Ok(ValidatedIdentity {- agent_id: None,- user_id: context.user_id,- fusion_user_id: context.fusion_user_id,- organization_id: context.organization_id,- permissions: context.permissions,- })- }- }+ ) -> impl Future<Output = Result<ValidatedCredential, Report<MacroAuthorizationError>>> + Send;/// Authorize a bot token, verifying any acting-user claims.///diff --git a/crates/macro_authorization/src/domain/service.rs b/crates/macro_authorization/src/domain/service.rsindex 0f4a5fef24..00a24290ae 100644--- a/crates/macro_authorization/src/domain/service.rs+++ b/crates/macro_authorization/src/domain/service.rs@@ -11,7 +11,7 @@ use tracing::Level;use super::{models::{BotActingUserClaims, BotAuthentication, BotScope, HarnessAuthentication,- InternalAuthConfig, InternalIdentityClaims, MacroAuthorizationError, ValidatedIdentity,+ InternalAuthConfig, InternalIdentityClaims, MacroAuthorizationError, ValidatedCredential,},ports::{BotAuthorizer, HarnessAuthorizer, JwtValidator, MacroAuthorizationService,@@ -159,8 +159,8 @@ whereasync fn authorize_identity(&self,jwt: &str,- ) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {- self.validator.validate(jwt)+ ) -> Result<ValidatedCredential, Report<MacroAuthorizationError>> {+ self.validator.validate_credential(jwt)}#[tracing::instrument(diff --git a/crates/macro_authorization/src/domain/service/test.rs b/crates/macro_authorization/src/domain/service/test.rsindex 587bc95802..e6bc014c39 100644--- a/crates/macro_authorization/src/domain/service/test.rs+++ b/crates/macro_authorization/src/domain/service/test.rs@@ -12,9 +12,9 @@ use uuid::Uuid;use super::MacroAuthorizationServiceImpl;use crate::domain::{models::{- BotActingUserClaims, BotAuthentication, BotScope, InternalAuthConfig,+ BotActingUserClaims, BotAuthentication, BotScope, CredentialOrigin, InternalAuthConfig,InternalIdentityClaims, MacroAuthorizationError, MacroUserAuthentication,- ValidatedIdentity,+ ValidatedCredential, ValidatedIdentity,},ports::{BotAuthorizer, JwtValidator, MacroAuthorizationService, NoBotAuthorizer,@@ -24,11 +24,14 @@ use crate::domain::{#[derive(Clone)]struct FakeJwtValidator {- result: Result<ValidatedIdentity, MacroAuthorizationError>,+ result: Result<ValidatedCredential, MacroAuthorizationError>,}impl JwtValidator for FakeJwtValidator {- fn validate(&self, _jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {+ fn validate_credential(+ &self,+ _jwt: &str,+ ) -> Result<ValidatedCredential, Report<MacroAuthorizationError>> {self.result.clone().map_err(Report::new)}}@@ -120,6 +123,15 @@ impl MacroAuthorizationService for DefaultRejectingAuthorizationService {Err(Report::new(MacroAuthorizationError::InvalidCredentials))}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(crate::ValidatedCredential::session)+ }+async fn authorize_internal(&self,_provided_key: &str,@@ -161,6 +173,7 @@ fn bot_authentication() -> BotAuthentication {bot_scope: BotScope::Team,team_id: Some(TEAM_ID),acting_user: Some(MacroUserAuthentication {+ origin: crate::CredentialOrigin::Bot,agent_id: None,macro_user_id: MacroUserIdStr::try_from("macro|[email protected]".to_string()).expect("valid Macro user id"),@@ -308,12 +321,15 @@ async fn authorize_constructs_user_context_from_validated_identity() {let permissions = HashSet::from(["documents:read".to_string(), "documents:write".to_string()]);let service = MacroAuthorizationServiceImpl::new(FakeJwtValidator {- result: Ok(ValidatedIdentity {- agent_id: None,- user_id: "macro|[email protected]".to_string(),- fusion_user_id: "fusion-user-id".to_string(),- organization_id: Some(42),- permissions: Some(permissions.clone()),+ result: Ok(ValidatedCredential {+ origin: CredentialOrigin::Session,+ identity: ValidatedIdentity {+ agent_id: None,+ user_id: "macro|[email protected]".to_string(),+ fusion_user_id: "fusion-user-id".to_string(),+ organization_id: Some(42),+ permissions: Some(permissions.clone()),+ },}),},internal_auth_config(None),@@ -530,19 +546,24 @@ async fn authorize_user_api_key_passes_through_authorizer_errors() {async fn authorize_identity_keeps_verified_agent_and_owner() {let service = MacroAuthorizationServiceImpl::new(FakeJwtValidator {- result: Ok(ValidatedIdentity {- agent_id: Some(bot_id::MACRO_NEW_BOT_ID),- user_id: "macro|[email protected]".into(),- fusion_user_id: "fusion-owner".into(),- organization_id: Some(42),- permissions: None,+ result: Ok(ValidatedCredential {+ origin: CredentialOrigin::MacroApiJwt,+ identity: ValidatedIdentity {+ agent_id: Some(bot_id::MACRO_NEW_BOT_ID),+ user_id: "macro|[email protected]".into(),+ fusion_user_id: "fusion-owner".into(),+ organization_id: Some(42),+ permissions: None,+ },}),},internal_auth_config(None),NoBotAuthorizer,NoUserApiKeyAuthorizer,);- let identity = service.authorize_identity("signed-token").await.unwrap();+ let credential = service.authorize_identity("signed-token").await.unwrap();+ assert_eq!(credential.origin, CredentialOrigin::MacroApiJwt);+ let identity = credential.identity;assert_eq!(identity.agent_id, Some(bot_id::MACRO_NEW_BOT_ID));assert_eq!(identity.user_id, "macro|[email protected]");assert_eq!(diff --git a/crates/macro_authorization/src/inbound/axum.rs b/crates/macro_authorization/src/inbound/axum.rsindex a3dc6c2fbd..aa0093e5d3 100644--- a/crates/macro_authorization/src/inbound/axum.rs+++ b/crates/macro_authorization/src/inbound/axum.rs@@ -24,7 +24,9 @@ use model_error_response::ErrorResponse;use model_user::UserContext;use rootcause::Report;-use crate::{MacroAuthorization, MacroAuthorizationError, MacroUserAuthentication};+use crate::{+ CredentialOrigin, MacroAuthorization, MacroAuthorizationError, MacroUserAuthentication,+};pub use bot::{BOT_FOR_FUSIONAUTH_USER_ID_HEADER, BOT_FOR_MACRO_USER_ID_HEADER,@@ -134,6 +136,7 @@ impl<Svc> Clone for MacroAuthorizationState<Svc> {pub(super) fn authenticated_user(user_context: UserContext,+ origin: CredentialOrigin,) -> Result<MacroUserAuthentication, MacroAuthorizationRejection> {let macro_user_id = MacroUserIdStr::parse_from_str(&user_context.user_id).map(CowLike::into_owned)@@ -143,6 +146,7 @@ pub(super) fn authenticated_user(})?;Ok(MacroUserAuthentication {+ origin,agent_id: None,macro_user_id,user_context,diff --git a/crates/macro_authorization/src/inbound/axum/internal.rs b/crates/macro_authorization/src/inbound/axum/internal.rsindex ec146a4196..5886a4b2f3 100644--- a/crates/macro_authorization/src/inbound/axum/internal.rs+++ b/crates/macro_authorization/src/inbound/axum/internal.rs@@ -5,7 +5,8 @@ use ::axum::{use rootcause::Report;use crate::{- InternalIdentityClaims, MacroAuthorization, MacroAuthorizationError, MacroAuthorizationService,+ CredentialOrigin, InternalIdentityClaims, MacroAuthorization, MacroAuthorizationError,+ MacroAuthorizationService,};use super::{@@ -74,7 +75,9 @@ where.authorize_internal(provided_key, claims).await.map_err(internal_authorization_rejection)?;- let acting_user = user_context.map(authenticated_user).transpose()?;+ let acting_user = user_context+ .map(|user_context| authenticated_user(user_context, CredentialOrigin::Internal))+ .transpose()?;Ok(Some(MacroAuthorization::Internal(acting_user)))}diff --git a/crates/macro_authorization/src/inbound/axum/test.rs b/crates/macro_authorization/src/inbound/axum/test.rsindex 655c4236cb..ad8a51c3d0 100644--- a/crates/macro_authorization/src/inbound/axum/test.rs+++ b/crates/macro_authorization/src/inbound/axum/test.rs@@ -87,6 +87,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {}}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<crate::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(crate::ValidatedCredential::session)+ }+async fn authorize_user_api_key(&self,api_key: &str,@@ -179,6 +188,7 @@ fn bot_authentication(bot_scope: BotScope, acting_user_id: Option<&str>) -> BotAbot_scope,team_id: (bot_scope == BotScope::Team).then_some(BOT_TEAM_ID),acting_user: acting_user_id.map(|user_id| MacroUserAuthentication {+ origin: crate::CredentialOrigin::Bot,agent_id: None,macro_user_id: MacroUserIdStr::try_from(user_id.to_owned()).expect("valid bot acting user id"),@@ -276,6 +286,7 @@ async fn user_handler("acting_entity": acting_entity,"macro_user_id": extractor.authorization.macro_user_id.to_string(),"user_context": extractor.authorization.user_context,+ "origin": format!("{:?}", extractor.authorization.origin),}))}@@ -1337,6 +1348,9 @@ async fn user_api_key_authenticates_as_the_user() {.await;assert_eq!(status, StatusCode::OK, "path {path}");assert_eq!(body["acting_entity"], API_KEY_USER_ID);+ if path == "/user" {+ assert_eq!(body["origin"], "UserApiKey");+ }if path != "/required/user-only" {assert_eq!(body["macro_user_id"], API_KEY_USER_ID);}@@ -2203,6 +2217,7 @@ fn policies_report_typed_acting_entity_variants_with_display_parity() {fn macro_user_authentication(user_id: &str) -> MacroUserAuthentication {MacroUserAuthentication {+ origin: crate::CredentialOrigin::Session,agent_id: None,macro_user_id: MacroUserIdStr::try_from(user_id.to_owned()).expect("valid Macro user ID"),user_context: user_context(user_id, None),diff --git a/crates/macro_authorization/src/inbound/axum/user.rs b/crates/macro_authorization/src/inbound/axum/user.rsindex 514a780fe0..d165ee0c9c 100644--- a/crates/macro_authorization/src/inbound/axum/user.rs+++ b/crates/macro_authorization/src/inbound/axum/user.rs@@ -56,7 +56,7 @@ where#[cfg(feature = "local_auth")]if let Some(user_context) = local_user_context() {- return authenticated_user(user_context).map(Some);+ return authenticated_user(user_context, crate::CredentialOrigin::Session).map(Some);}let Some(token) = extract_ambient_user_token(parts, state).await else {@@ -138,18 +138,22 @@ whereSvc: MacroAuthorizationService,{let authorization = MacroAuthorizationState::<Svc>::from_ref(state);- let identity = authorization+ let credential = authorization.service.authorize_identity(token).await.map_err(authorization_rejection)?;- let mut user = authenticated_user(model_user::UserContext {- user_id: identity.user_id,- fusion_user_id: identity.fusion_user_id,- organization_id: identity.organization_id,- permissions: identity.permissions,- })?;+ let identity = credential.identity;+ let mut user = authenticated_user(+ model_user::UserContext {+ user_id: identity.user_id,+ fusion_user_id: identity.fusion_user_id,+ organization_id: identity.organization_id,+ permissions: identity.permissions,+ },+ credential.origin,+ )?;user.agent_id = identity.agent_id;Ok(user)}diff --git a/crates/macro_authorization/src/inbound/axum/user/test.rs b/crates/macro_authorization/src/inbound/axum/user/test.rsindex f4851525ac..65ebf1c764 100644--- a/crates/macro_authorization/src/inbound/axum/user/test.rs+++ b/crates/macro_authorization/src/inbound/axum/user/test.rs@@ -1,17 +1,31 @@use super::*;use crate::{- BotOnly, InternalAuthConfig, JwtValidator, MacroAuthorizationExtractor,+ BotOnly, CredentialOrigin, InternalAuthConfig, JwtValidator, MacroAuthorizationExtractor,MacroAuthorizationServiceImpl, NoBotAuthorizer, NoUserApiKeyAuthorizer, UserOnly,- ValidatedIdentity,+ ValidatedCredential, ValidatedIdentity,};use std::sync::Arc;#[derive(Clone)]struct Validator;impl JwtValidator for Validator {+ fn validate_credential(+ &self,+ jwt: &str,+ ) -> Result<ValidatedCredential, Report<MacroAuthorizationError>> {+ self.validate(jwt).map(|identity| ValidatedCredential {+ identity,+ origin: if jwt == "user" {+ CredentialOrigin::Session+ } else {+ CredentialOrigin::MacroApiJwt+ },+ })+ }+fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {match jwt {- "execution" | "user" => Ok(ValidatedIdentity {+ "execution" | "api" | "user" => Ok(ValidatedIdentity {agent_id: (jwt == "execution").then_some(bot_id::MACRO_NEW_BOT_ID),user_id: "macro|[email protected]".into(),fusion_user_id: "fusion-owner".into(),@@ -38,6 +52,7 @@ async fn bearer_agent_attribution_survives_user_policy_without_becoming_bot_auth)));for (token, agent) in [("execution", Some(bot_id::MACRO_NEW_BOT_ID)),+ ("api", None),("user", None),] {let (mut parts, _) = axum::http::Request::builder()@@ -52,6 +67,14 @@ async fn bearer_agent_attribution_survives_user_policy_without_becoming_bot_auth.await.unwrap();assert_eq!(caller.authorization.agent_id, agent);+ assert_eq!(+ caller.authorization.origin,+ if token == "user" {+ CredentialOrigin::Session+ } else {+ CredentialOrigin::MacroApiJwt+ }+ );assert_eq!(caller.authorization.macro_user_id.as_ref(),"macro|[email protected]"diff --git a/crates/macro_authorization/src/inbound/axum/user_api_key.rs b/crates/macro_authorization/src/inbound/axum/user_api_key.rsindex 35c556a1df..b666630bfa 100644--- a/crates/macro_authorization/src/inbound/axum/user_api_key.rs+++ b/crates/macro_authorization/src/inbound/axum/user_api_key.rs@@ -4,7 +4,9 @@ use ::axum::{};use rootcause::Report;-use crate::{MacroAuthorizationError, MacroAuthorizationService, MacroUserAuthentication};+use crate::{+ CredentialOrigin, MacroAuthorizationError, MacroAuthorizationService, MacroUserAuthentication,+};use super::{MacroAuthorizationRejection, MacroAuthorizationState, authenticated_user,@@ -30,7 +32,7 @@ where.await.map_err(user_api_key_authorization_rejection)?;- authenticated_user(user_context)+ authenticated_user(user_context, CredentialOrigin::UserApiKey)}fn user_api_key(headers: &HeaderMap) -> Result<String, MacroAuthorizationRejection> {diff --git a/crates/macro_authorization/src/lib.rs b/crates/macro_authorization/src/lib.rsindex 299783dbac..e76421e2c1 100644--- a/crates/macro_authorization/src/lib.rs+++ b/crates/macro_authorization/src/lib.rs@@ -63,10 +63,10 @@ pub use domain::{harness_authorizer::HarnessAuthorizerService,models::{BotActingUserClaims, BotAuthentication, BotAuthorizationOwner, BotScope,- BotTokenAuthorization, HarnessAuthentication, HarnessAuthorizationOwner,+ BotTokenAuthorization, CredentialOrigin, HarnessAuthentication, HarnessAuthorizationOwner,HarnessTokenAuthorization, InternalAuthConfig, InternalIdentityClaims, MacroAuthorization,MacroAuthorizationError, MacroUserAuthentication, ResolvedApiKeyUser,- ResolvedBotActingUser, ValidatedIdentity,+ ResolvedBotActingUser, ValidatedCredential, ValidatedIdentity,},ports::{BotAuthorizationRepo, BotAuthorizer, HarnessAuthorizationRepo, HarnessAuthorizer,diff --git a/crates/macro_authorization/src/outbound/macro_auth.rs b/crates/macro_authorization/src/outbound/macro_auth.rsindex 2ae838d900..d732bef7b1 100644--- a/crates/macro_authorization/src/outbound/macro_auth.rs+++ b/crates/macro_authorization/src/outbound/macro_auth.rs@@ -9,7 +9,7 @@ use rootcause::Report;use tracing::Level;use crate::domain::{- models::{MacroAuthorizationError, ValidatedIdentity},+ models::{CredentialOrigin, MacroAuthorizationError, ValidatedCredential, ValidatedIdentity},ports::JwtValidator,};@@ -34,14 +34,21 @@ impl MacroAuthJwtValidator {impl JwtValidator for MacroAuthJwtValidator {#[tracing::instrument(err(level = Level::DEBUG), skip(self, jwt))]- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {+ fn validate_credential(+ &self,+ jwt: &str,+ ) -> Result<ValidatedCredential, Report<MacroAuthorizationError>> {decode_jwt::handler(&self.jwt_validation_args, jwt).map(identity_from_token).map_err(validation_error)}}-fn identity_from_token(token: JwtToken) -> ValidatedIdentity {+fn identity_from_token(token: JwtToken) -> ValidatedCredential {+ let origin = match &token {+ JwtToken::MacroAccessToken(_) => CredentialOrigin::Session,+ JwtToken::MacroApiToken(_) => CredentialOrigin::MacroApiJwt,+ };let (user_id, fusion_user_id, organization_id, agent_id) = match token {JwtToken::MacroAccessToken(token) => (token.macro_user_id,@@ -57,12 +64,15 @@ fn identity_from_token(token: JwtToken) -> ValidatedIdentity {),};- ValidatedIdentity {- agent_id,- user_id,- fusion_user_id,- organization_id,- permissions: None,+ ValidatedCredential {+ origin,+ identity: ValidatedIdentity {+ agent_id,+ user_id,+ fusion_user_id,+ organization_id,+ permissions: None,+ },}}diff --git a/crates/macro_authorization/src/outbound/macro_auth/test.rs b/crates/macro_authorization/src/outbound/macro_auth/test.rsindex 229004f710..53a005d2f6 100644--- a/crates/macro_authorization/src/outbound/macro_auth/test.rs+++ b/crates/macro_authorization/src/outbound/macro_auth/test.rs@@ -63,7 +63,9 @@ fn macro_auth_cause(report: &Report<MacroAuthorizationError>) -> &MacroAuthErrorfn validates_access_token() {let token = access_token("", unix_timestamp() + 3_600, None, None);- let identity = validator().validate(&token).unwrap();+ let credential = validator().validate_credential(&token).unwrap();+ assert_eq!(credential.origin, CredentialOrigin::Session);+ let identity = credential.identity;assert_eq!(identity.user_id, MACRO_USER_ID);assert_eq!(identity.fusion_user_id, FUSION_USER_ID);@@ -139,7 +141,7 @@ fn preserves_access_token_organization_id() {#[test]fn maps_macro_api_token_claims() {- let identity = identity_from_token(JwtToken::MacroApiToken(MacroApiToken {+ let credential = identity_from_token(JwtToken::MacroApiToken(MacroApiToken {agent_id: None,exp: unix_timestamp() + 3_600,iss: String::new(),@@ -148,6 +150,8 @@ fn maps_macro_api_token_claims() {macro_organization_id: Some(84),}));+ assert_eq!(credential.origin, CredentialOrigin::MacroApiJwt);+ let identity = credential.identity;assert_eq!(identity.user_id, MACRO_USER_ID);assert_eq!(identity.fusion_user_id, FUSION_USER_ID);assert_eq!(identity.organization_id, Some(84));@@ -158,7 +162,7 @@ fn maps_macro_api_token_claims() {#[test]fn maps_signed_agent_without_changing_owner_identity() {let agent = bot_id::MACRO_NEW_BOT_ID;- let identity = identity_from_token(JwtToken::MacroApiToken(MacroApiToken {+ let credential = identity_from_token(JwtToken::MacroApiToken(MacroApiToken {agent_id: Some(agent.as_uuid()),exp: unix_timestamp() + 60,iss: String::new(),@@ -166,6 +170,8 @@ fn maps_signed_agent_without_changing_owner_identity() {macro_user_id: MACRO_USER_ID.into(),macro_organization_id: Some(42),}));+ assert_eq!(credential.origin, CredentialOrigin::MacroApiJwt);+ let identity = credential.identity;assert_eq!(identity.agent_id, Some(agent));assert_eq!(identity.user_id, MACRO_USER_ID);assert_eq!(identity.organization_id, Some(42));diff --git a/crates/macro_authorization/src/outbound/noop.rs b/crates/macro_authorization/src/outbound/noop.rsindex 0450b5f427..5e5d431487 100644--- a/crates/macro_authorization/src/outbound/noop.rs+++ b/crates/macro_authorization/src/outbound/noop.rs@@ -4,18 +4,21 @@ mod test;use rootcause::Report;use crate::domain::{- models::{MacroAuthorizationError, ValidatedIdentity},+ models::{MacroAuthorizationError, ValidatedCredential},ports::JwtValidator,};/// JWT validator for services that only support internal authorization.///-/// Calling [`JwtValidator::validate`] is a configuration error and will panic.+/// Calling [`JwtValidator::validate_credential`] is a configuration error and will panic.#[derive(Clone, Copy, Debug, Default)]pub struct NoopMacroAuthJwtValidator;impl JwtValidator for NoopMacroAuthJwtValidator {- fn validate(&self, _jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {+ fn validate_credential(+ &self,+ _jwt: &str,+ ) -> Result<ValidatedCredential, Report<MacroAuthorizationError>> {unimplemented!("NoopMacroAuthJwtValidator cannot validate JWTs")}}diff --git a/crates/notification/src/inbound/http/test.rs b/crates/notification/src/inbound/http/test.rsindex 90c56dd24f..c2b42a8c02 100644--- a/crates/notification/src/inbound/http/test.rs+++ b/crates/notification/src/inbound/http/test.rs@@ -76,6 +76,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {})}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_internal(&self,provided_key: &str,diff --git a/crates/projects/src/inbound/axum_router/tests.rs b/crates/projects/src/inbound/axum_router/tests.rsindex 7bb59f2c94..fee5d05f8e 100644--- a/crates/projects/src/inbound/axum_router/tests.rs+++ b/crates/projects/src/inbound/axum_router/tests.rs@@ -403,6 +403,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {Ok(user_context(USER_ID))}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_internal(&self,provided_key: &str,@@ -431,6 +440,7 @@ impl MacroAuthorizationService for FakeAuthorizationService {acting_user: acting_user.and_then(|claims| claims.user_id).map(|user_id| MacroUserAuthentication {+ origin: macro_authorization::CredentialOrigin::Bot,agent_id: None,macro_user_id: user(&user_id),user_context: user_context(&user_id),diff --git a/crates/properties/src/inbound/axum_router/test.rs b/crates/properties/src/inbound/axum_router/test.rsindex 3b7d529e34..6a7df38893 100644--- a/crates/properties/src/inbound/axum_router/test.rs+++ b/crates/properties/src/inbound/axum_router/test.rs@@ -221,14 +221,20 @@ impl EntityAccessService for FakeEntityAccessService {struct FakeJwtValidator;impl JwtValidator for FakeJwtValidator {- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {+ fn validate_credential(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {match jwt {- "valid" => Ok(ValidatedIdentity {- agent_id: None,- user_id: VALID_USER_ID.to_string(),- fusion_user_id: "fusion-valid-user".to_string(),- organization_id: Some(ORGANIZATION_ID),- permissions: None,+ "valid" => Ok(macro_authorization::ValidatedCredential {+ origin: macro_authorization::CredentialOrigin::Session,+ identity: ValidatedIdentity {+ agent_id: None,+ user_id: VALID_USER_ID.to_string(),+ fusion_user_id: "fusion-valid-user".to_string(),+ organization_id: Some(ORGANIZATION_ID),+ permissions: None,+ },}),"expired" => Err(Report::new(MacroAuthorizationError::CredentialsExpired)),_ => Err(Report::new(MacroAuthorizationError::InvalidCredentials)),diff --git a/crates/referral/src/inbound/axum_router/test.rs b/crates/referral/src/inbound/axum_router/test.rsindex 50398a0b74..7c1626f853 100644--- a/crates/referral/src/inbound/axum_router/test.rs+++ b/crates/referral/src/inbound/axum_router/test.rs@@ -39,6 +39,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {Ok(test_user_context(TEST_USER_ID))}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_internal(&self,provided_key: &str,diff --git a/crates/reminders/src/inbound/axum_router/test.rs b/crates/reminders/src/inbound/axum_router/test.rsindex 300b3e2ddb..81893bbf20 100644--- a/crates/reminders/src/inbound/axum_router/test.rs+++ b/crates/reminders/src/inbound/axum_router/test.rs@@ -83,6 +83,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {Ok(user_context())}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_internal(&self,_provided_key: &str,diff --git a/crates/scheduled_action/src/inbound/axum_router/test.rs b/crates/scheduled_action/src/inbound/axum_router/test.rsindex d30d2326a5..d74c918c7c 100644--- a/crates/scheduled_action/src/inbound/axum_router/test.rs+++ b/crates/scheduled_action/src/inbound/axum_router/test.rs@@ -133,6 +133,15 @@ impl MacroAuthorizationService for FakeAuth {}}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_bot(&self,bot_token: &str,@@ -153,6 +162,7 @@ impl MacroAuthorizationService for FakeAuth {let macro_user_id = MacroUserIdStr::try_from(user_id).expect("acting user id");MacroUserAuthentication {agent_id: None,+ origin: macro_authorization::CredentialOrigin::Bot,user_context: UserContext {user_id: macro_user_id.to_string(),..Default::default()diff --git a/crates/scheduled_action/tests/event_routines.rs b/crates/scheduled_action/tests/event_routines.rsindex 74d01f1906..a16bc1b2d2 100644--- a/crates/scheduled_action/tests/event_routines.rs+++ b/crates/scheduled_action/tests/event_routines.rs@@ -89,6 +89,15 @@ impl MacroAuthorizationService for FakeAuth {..Default::default()})}++ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }async fn authorize_internal(&self,_: &str,diff --git a/crates/slack_integration/src/inbound/axum_router/test.rs b/crates/slack_integration/src/inbound/axum_router/test.rsindex 0dbead2e38..365ec484e8 100644--- a/crates/slack_integration/src/inbound/axum_router/test.rs+++ b/crates/slack_integration/src/inbound/axum_router/test.rs@@ -40,6 +40,15 @@ impl MacroAuthorizationService for Auth {organization_id: None,})}++ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }async fn authorize_internal(&self,_: &str,diff --git a/crates/soup/src/inbound/axum_router/tests.rs b/crates/soup/src/inbound/axum_router/tests.rsindex abc4ff4d40..f9f992b62d 100644--- a/crates/soup/src/inbound/axum_router/tests.rs+++ b/crates/soup/src/inbound/axum_router/tests.rs@@ -597,6 +597,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {}}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_internal(&self,provided_key: &str,diff --git a/crates/teams/src/inbound/axum_router/test.rs b/crates/teams/src/inbound/axum_router/test.rsindex 21b89df409..e809915ca4 100644--- a/crates/teams/src/inbound/axum_router/test.rs+++ b/crates/teams/src/inbound/axum_router/test.rs@@ -667,6 +667,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {Err(Report::new(MacroAuthorizationError::InvalidCredentials))}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_internal(&self,provided_key: &str,diff --git a/crates/webhook/src/inbound/axum_router/test.rs b/crates/webhook/src/inbound/axum_router/test.rsindex a3d714fa3a..e1977bfbed 100644--- a/crates/webhook/src/inbound/axum_router/test.rs+++ b/crates/webhook/src/inbound/axum_router/test.rs@@ -102,6 +102,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {})}+ async fn authorize_identity(+ &self,+ jwt: &str,+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {+ self.authorize(jwt)+ .await+ .map(macro_authorization::ValidatedCredential::session)+ }+async fn authorize_bot(&self,bot_token: &str,@@ -114,6 +123,7 @@ impl MacroAuthorizationService for FakeAuthorizationService {let acting_user = acting_user.and_then(|claims| claims.user_id).map(|user_id| macro_authorization::MacroUserAuthentication {+ origin: macro_authorization::CredentialOrigin::Bot,agent_id: None,macro_user_id: MacroUserIdStr::try_from(user_id).unwrap(),user_context: UserContext::default(),