Store the extension registry directly in its builder (#36744)

## What changed

Make `ExtensionRegistryBuilder` wrap an `ExtensionRegistry` and register
contributors directly on it. Return the wrapped registry from `build()` instead
of copying each field into a new value.

GitOrigin-RevId: ae04de99c17ea951156f9892151b4196c70026bf

codex-rs/ext/extension-api/src/registry.rs

@@ -20,37 +20,27 @@ use crate::TurnLifecycleContributor;
 
 /// Mutable registry used while hosts register typed runtime contributions.
 pub struct ExtensionRegistryBuilder<C: Sync> {
-    event_sink: Arc<dyn ExtensionEventSink>,
-    thread_lifecycle_contributors: Vec<Arc<dyn ThreadLifecycleContributor<C>>>,
-    turn_lifecycle_contributors: Vec<Arc<dyn TurnLifecycleContributor>>,
-    config_contributors: Vec<Arc<dyn ConfigContributor<C>>>,
-    token_usage_contributors: Vec<Arc<dyn TokenUsageContributor>>,
-    skill_invocation_contributors: Vec<Arc<dyn SkillInvocationContributor>>,
-    context_contributors: Vec<Arc<dyn ContextContributor>>,
-    mcp_server_contributors: Vec<Arc<dyn McpServerContributor<C>>>,
-    turn_input_contributors: Vec<Arc<dyn TurnInputContributor>>,
-    tool_contributors: Vec<Arc<dyn ToolContributor>>,
-    tool_lifecycle_contributors: Vec<Arc<dyn ToolLifecycleContributor>>,
-    turn_item_contributors: Vec<Arc<dyn TurnItemContributor>>,
-    approval_review_contributors: Vec<Arc<dyn ApprovalReviewContributor>>,
+    registry: ExtensionRegistry<C>,
 }
 
 impl<C: Sync> Default for ExtensionRegistryBuilder<C> {
     fn default() -> Self {
         Self {
-            event_sink: Arc::new(NoopExtensionEventSink),
-            thread_lifecycle_contributors: Vec::new(),
-            turn_lifecycle_contributors: Vec::new(),
-            config_contributors: Vec::new(),
-            token_usage_contributors: Vec::new(),
-            skill_invocation_contributors: Vec::new(),
-            approval_review_contributors: Vec::new(),
-            context_contributors: Vec::new(),
-            mcp_server_contributors: Vec::new(),
-            turn_input_contributors: Vec::new(),
-            tool_contributors: Vec::new(),
-            tool_lifecycle_contributors: Vec::new(),
-            turn_item_contributors: Vec::new(),
+            registry: ExtensionRegistry {
+                event_sink: Arc::new(NoopExtensionEventSink),
+                thread_lifecycle_contributors: Vec::new(),
+                turn_lifecycle_contributors: Vec::new(),
+                config_contributors: Vec::new(),
+                token_usage_contributors: Vec::new(),
+                skill_invocation_contributors: Vec::new(),
+                approval_review_contributors: Vec::new(),
+                context_contributors: Vec::new(),
+                mcp_server_contributors: Vec::new(),
+                turn_input_contributors: Vec::new(),
+                tool_contributors: Vec::new(),
+                tool_lifecycle_contributors: Vec::new(),
+                turn_item_contributors: Vec::new(),
+            },
         }
     }
 }
@@ -63,20 +53,19 @@ impl<C: Sync> ExtensionRegistryBuilder<C> {
 
     /// Creates an empty registry builder with a host-provided event sink.
     pub fn with_event_sink(event_sink: Arc<dyn ExtensionEventSink>) -> Self {
-        Self {
-            event_sink,
-            ..Self::default()
-        }
+        let mut builder = Self::default();
+        builder.registry.event_sink = event_sink;
+        builder
     }
 
     /// Returns the host event sink to pass into extension constructors.
     pub fn event_sink(&self) -> Arc<dyn ExtensionEventSink> {
-        Arc::clone(&self.event_sink)
+        Arc::clone(&self.registry.event_sink)
     }
 
     /// Registers one approval-review contributor.
     pub fn approval_review_contributor(&mut self, contributor: Arc<dyn ApprovalReviewContributor>) {
-        self.approval_review_contributors.push(contributor);
+        self.registry.approval_review_contributors.push(contributor);
     }
 
     /// Registers one thread-lifecycle contributor.
@@ -84,22 +73,24 @@ impl<C: Sync> ExtensionRegistryBuilder<C> {
         &mut self,
         contributor: Arc<dyn ThreadLifecycleContributor<C>>,
     ) {
-        self.thread_lifecycle_contributors.push(contributor);
+        self.registry
+            .thread_lifecycle_contributors
+            .push(contributor);
     }
 
     /// Registers one turn-lifecycle contributor.
     pub fn turn_lifecycle_contributor(&mut self, contributor: Arc<dyn TurnLifecycleContributor>) {
-        self.turn_lifecycle_contributors.push(contributor);
+        self.registry.turn_lifecycle_contributors.push(contributor);
     }
 
     /// Registers one config contributor.
     pub fn config_contributor(&mut self, contributor: Arc<dyn ConfigContributor<C>>) {
-        self.config_contributors.push(contributor);
+        self.registry.config_contributors.push(contributor);
     }
 
     /// Registers one token-usage contributor.
     pub fn token_usage_contributor(&mut self, contributor: Arc<dyn TokenUsageContributor>) {
-        self.token_usage_contributors.push(contributor);
+        self.registry.token_usage_contributors.push(contributor);
     }
 
     /// Registers one skill-invocation contributor.
@@ -107,56 +98,44 @@ impl<C: Sync> ExtensionRegistryBuilder<C> {
         &mut self,
         contributor: Arc<dyn SkillInvocationContributor>,
     ) {
-        self.skill_invocation_contributors.push(contributor);
+        self.registry
+            .skill_invocation_contributors
+            .push(contributor);
     }
 
     /// Registers one prompt contributor.
     pub fn prompt_contributor(&mut self, contributor: Arc<dyn ContextContributor>) {
-        self.context_contributors.push(contributor);
+        self.registry.context_contributors.push(contributor);
     }
 
     /// Registers one runtime MCP server contributor.
     pub fn mcp_server_contributor(&mut self, contributor: Arc<dyn McpServerContributor<C>>) {
-        self.mcp_server_contributors.push(contributor);
+        self.registry.mcp_server_contributors.push(contributor);
     }
 
     /// Registers one turn-input contributor.
     pub fn turn_input_contributor(&mut self, contributor: Arc<dyn TurnInputContributor>) {
-        self.turn_input_contributors.push(contributor);
+        self.registry.turn_input_contributors.push(contributor);
     }
 
     /// Registers one native tool contributor.
     pub fn tool_contributor(&mut self, contributor: Arc<dyn ToolContributor>) {
-        self.tool_contributors.push(contributor);
+        self.registry.tool_contributors.push(contributor);
     }
 
     /// Registers one tool-lifecycle contributor.
     pub fn tool_lifecycle_contributor(&mut self, contributor: Arc<dyn ToolLifecycleContributor>) {
-        self.tool_lifecycle_contributors.push(contributor);
+        self.registry.tool_lifecycle_contributors.push(contributor);
     }
 
     /// Registers one ordered turn-item contributor.
     pub fn turn_item_contributor(&mut self, contributor: Arc<dyn TurnItemContributor>) {
-        self.turn_item_contributors.push(contributor);
+        self.registry.turn_item_contributors.push(contributor);
     }
 
     /// Finishes construction and returns the immutable registry.
     pub fn build(self) -> ExtensionRegistry<C> {
-        ExtensionRegistry {
-            event_sink: self.event_sink,
-            thread_lifecycle_contributors: self.thread_lifecycle_contributors,
-            turn_lifecycle_contributors: self.turn_lifecycle_contributors,
-            config_contributors: self.config_contributors,
-            token_usage_contributors: self.token_usage_contributors,
-            skill_invocation_contributors: self.skill_invocation_contributors,
-            approval_review_contributors: self.approval_review_contributors,
-            context_contributors: self.context_contributors,
-            mcp_server_contributors: self.mcp_server_contributors,
-            turn_input_contributors: self.turn_input_contributors,
-            tool_contributors: self.tool_contributors,
-            tool_lifecycle_contributors: self.tool_lifecycle_contributors,
-            turn_item_contributors: self.turn_item_contributors,
-        }
+        self.registry
     }
 }