Align agent task registration auth

Author: adrian-openai

codex-rs/core/src/agent_identity.rs

@@ -737,6 +737,7 @@ mod tests {
                     chatgpt_plan_type: None,
                     chatgpt_user_id: user_id.map(ToOwned::to_owned),
                     chatgpt_account_id: Some(account_id.to_string()),
+                    is_org_owner: None,
                     raw_jwt: fake_id_token(account_id, user_id),
                 },
                 access_token: format!("access-token-{account_id}"),

codex-rs/core/src/agent_identity/task_registration.rs

@@ -52,12 +52,14 @@ impl AgentIdentityManager {
         };
 
         let client = create_client();
-        let url =
-            agent_task_registration_url(&self.chatgpt_base_url, &stored_identity.agent_runtime_id);
+        let url = agent_task_registration_url(
+            &self.agent_identity_base_url,
+            &stored_identity.agent_runtime_id,
+        );
+        let human_biscuit = self.mint_human_biscuit(&binding).await?;
         let response = client
             .post(&url)
-            .bearer_auth(&binding.access_token)
-            .header("chatgpt-account-id", &binding.chatgpt_account_id)
+            .header("X-OpenAI-Authorization", human_biscuit)
             .json(&request_body)
             .timeout(AGENT_TASK_REGISTRATION_TIMEOUT)
             .send()
@@ -124,13 +126,9 @@ fn curve25519_secret_key_from_signing_key(signing_key: &SigningKey) -> Curve2551
     Curve25519SecretKey::from(secret_key)
 }
 
-fn agent_task_registration_url(chatgpt_base_url: &str, agent_runtime_id: &str) -> String {
-    let trimmed = chatgpt_base_url.trim_end_matches('/');
-    let path = format!("/v1/agent/{agent_runtime_id}/task/register");
-    if let Some(root) = trimmed.strip_suffix("/backend-api") {
-        return format!("{root}{path}");
-    }
-    format!("{trimmed}{path}")
+fn agent_task_registration_url(agent_identity_base_url: &str, agent_runtime_id: &str) -> String {
+    let trimmed = agent_identity_base_url.trim_end_matches('/');
+    format!("{trimmed}/v1/agent/{agent_runtime_id}/task/register")
 }
 
 #[cfg(test)]
@@ -201,6 +199,7 @@ mod tests {
     #[tokio::test]
     async fn register_task_registers_and_decrypts_plaintext_task_id() {
         let server = MockServer::start().await;
+        mount_human_biscuit(&server).await;
         let tempdir = tempfile::tempdir().expect("tempdir");
         let keyring_store = Arc::new(MockKeyringStore::default());
         let secrets_manager = SecretsManager::new_with_keyring_store(
@@ -213,7 +212,7 @@ mod tests {
         let manager = AgentIdentityManager::new_for_tests(
             auth_manager,
             /*feature_enabled*/ true,
-            format!("{}/backend-api/", server.uri()),
+            server.uri(),
             SessionSource::Cli,
             secrets_manager.clone(),
         );
@@ -224,8 +223,7 @@ mod tests {
 
         Mock::given(method("POST"))
             .and(path("/v1/agent/agent-123/task/register"))
-            .and(header("authorization", "Bearer access-token-account-123"))
-            .and(header("chatgpt-account-id", "account-123"))
+            .and(header("x-openai-authorization", "human-biscuit"))
             .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
                 "encrypted_task_id": encrypted_task_id,
             })))
@@ -250,8 +248,9 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn register_task_uses_canonical_registration_url() {
+    async fn register_task_uses_agent_identity_base_url() {
         let server = MockServer::start().await;
+        mount_human_biscuit(&server).await;
         let tempdir = tempfile::tempdir().expect("tempdir");
         let keyring_store = Arc::new(MockKeyringStore::default());
         let secrets_manager = SecretsManager::new_with_keyring_store(
@@ -264,7 +263,7 @@ mod tests {
         let manager = AgentIdentityManager::new_for_tests(
             auth_manager,
             /*feature_enabled*/ true,
-            format!("{}/backend-api/", server.uri()),
+            server.uri(),
             SessionSource::Cli,
             secrets_manager.clone(),
         );
@@ -275,6 +274,7 @@ mod tests {
 
         Mock::given(method("POST"))
             .and(path("/v1/agent/agent-fallback/task/register"))
+            .and(header("x-openai-authorization", "human-biscuit"))
             .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
                 "encrypted_task_id": encrypted_task_id,
             })))
@@ -292,6 +292,20 @@ mod tests {
         assert_eq!(task.task_id, "task_fallback");
     }
 
+    async fn mount_human_biscuit(server: &MockServer) {
+        Mock::given(method("GET"))
+            .and(path("/authenticate_app_v2"))
+            .and(header("authorization", "Bearer access-token-account-123"))
+            .and(header("x-original-method", "GET"))
+            .and(header("x-original-url", AGENT_IDENTITY_BISCUIT_TARGET_URL))
+            .respond_with(
+                ResponseTemplate::new(200).insert_header("x-openai-authorization", "human-biscuit"),
+            )
+            .expect(1)
+            .mount(server)
+            .await;
+    }
+
     fn seed_stored_identity(
         manager: &AgentIdentityManager,
         secrets_manager: &SecretsManager,
@@ -350,6 +364,7 @@ mod tests {
                     chatgpt_plan_type: None,
                     chatgpt_user_id: user_id.map(ToOwned::to_owned),
                     chatgpt_account_id: Some(account_id.to_string()),
+                    is_org_owner: None,
                     raw_jwt: fake_id_token(account_id, user_id),
                 },
                 access_token: format!("access-token-{account_id}"),

codex-rs/core/src/codex.rs

@@ -6316,6 +6316,8 @@ pub(crate) async fn run_turn(
     }
     if let Err(error) = sess.ensure_agent_task_registered().await {
         warn!(error = %error, "agent task registration failed");
+        sess.fail_agent_identity_registration(error).await;
+        return None;
     }
 
     if !skill_items.is_empty() {