refactor(config): cache ForgeConfig and pass through stack

Author: tusharmath

crates/forge_api/src/api.rs

@@ -3,7 +3,6 @@ use std::path::PathBuf;
 use anyhow::Result;
 use forge_app::dto::ToolsOverview;
 use forge_app::{User, UserUsage};
-use forge_config::ForgeConfig;
 use forge_domain::{AgentId, Effort, ModelId, ProviderModels};
 use forge_stream::MpscStream;
 use futures::stream::BoxStream;
@@ -51,9 +50,6 @@ pub trait API: Sync + Send {
     /// Returns the current environment
     fn environment(&self) -> Environment;
 
-    /// Returns the full application configuration.
-    fn get_config(&self) -> ForgeConfig;
-
     /// Adds a new conversation to the conversation store
     async fn upsert_conversation(&self, conversation: Conversation) -> Result<()>;
 

crates/forge_api/src/forge_api.rs

@@ -25,19 +25,20 @@ use crate::API;
 pub struct ForgeAPI<S, F> {
     services: Arc<S>,
     infra: Arc<F>,
+    config: forge_config::ForgeConfig,
 }
 
 impl<A, F> ForgeAPI<A, F> {
-    pub fn new(services: Arc<A>, infra: Arc<F>) -> Self {
-        Self { services, infra }
+    pub fn new(services: Arc<A>, infra: Arc<F>, config: forge_config::ForgeConfig) -> Self {
+        Self { services, infra, config }
     }
 
     /// Creates a ForgeApp instance with the current services
     fn app(&self) -> ForgeApp<A>
     where
         A: Services,
     {
-        ForgeApp::new(self.services.clone())
+        ForgeApp::new(self.services.clone(), self.config.clone())
     }
 }
 
@@ -51,8 +52,8 @@ impl ForgeAPI<ForgeServices<ForgeRepo<ForgeInfra>>, ForgeRepo<ForgeInfra>> {
     pub fn init(cwd: PathBuf, config: ForgeConfig, services_url: Url) -> Self {
         let infra = Arc::new(ForgeInfra::new(cwd, config.clone(), services_url));
         let repo = Arc::new(ForgeRepo::new(infra.clone(), config.clone()));
-        let app = Arc::new(ForgeServices::new(repo.clone(), config));
-        ForgeAPI::new(app, repo)
+        let app = Arc::new(ForgeServices::new(repo.clone(), config.clone()));
+        ForgeAPI::new(app, repo, config)
     }
 
     pub async fn get_skills_internal(&self) -> Result<Vec<Skill>> {
@@ -98,7 +99,7 @@ impl<A: Services, F: CommandInfra + EnvironmentInfra + SkillRepository + GrpcInf
         diff: Option<String>,
         additional_context: Option<String>,
     ) -> Result<forge_app::CommitResult> {
-        let git_app = GitApp::new(self.services.clone());
+        let git_app = GitApp::new(self.services.clone(), self.config.clone());
         let result = git_app
             .commit_message(max_diff_size, diff, additional_context)
             .await?;
@@ -154,10 +155,6 @@ impl<A: Services, F: CommandInfra + EnvironmentInfra + SkillRepository + GrpcInf
         self.services.get_environment().clone()
     }
 
-    fn get_config(&self) -> ForgeConfig {
-        self.services.get_config()
-    }
-
     async fn conversation(
         &self,
         conversation_id: &ConversationId,

crates/forge_app/src/agent.rs

@@ -30,6 +30,7 @@ pub trait AgentService: Send + Sync + 'static {
         agent: &Agent,
         context: &ToolCallContext,
         call: ToolCallFull,
+        config: &ForgeConfig,
     ) -> ToolResult;
 
     /// Synchronize the on-going conversation
@@ -60,8 +61,9 @@ impl<T: Services> AgentService for T {
         agent: &Agent,
         context: &ToolCallContext,
         call: ToolCallFull,
+        config: &ForgeConfig,
     ) -> ToolResult {
-        let registry = ToolRegistry::new(Arc::new(self.clone()));
+        let registry = ToolRegistry::new(Arc::new(self.clone()), config.clone());
         registry.call(agent, context, call).await
     }
 

crates/forge_app/src/agent_executor.rs

@@ -10,18 +10,21 @@ use forge_template::Element;
 use futures::StreamExt;
 use tokio::sync::RwLock;
 
+use forge_config::ForgeConfig;
+
 use crate::error::Error;
 use crate::{AgentRegistry, ConversationService, Services};
 
 #[derive(Clone)]
 pub struct AgentExecutor<S> {
     services: Arc<S>,
+    config: ForgeConfig,
     pub tool_agents: Arc<RwLock<Option<Vec<ToolDefinition>>>>,
 }
 
 impl<S: Services> AgentExecutor<S> {
-    pub fn new(services: Arc<S>) -> Self {
-        Self { services, tool_agents: Arc::new(RwLock::new(None)) }
+    pub fn new(services: Arc<S>, config: ForgeConfig) -> Self {
+        Self { services, config, tool_agents: Arc::new(RwLock::new(None)) }
     }
 
     /// Returns a list of tool definitions for all available agents.
@@ -63,7 +66,7 @@ impl<S: Services> AgentExecutor<S> {
             .upsert_conversation(conversation.clone())
             .await?;
         // Execute the request through the ForgeApp
-        let app = crate::ForgeApp::new(self.services.clone());
+        let app = crate::ForgeApp::new(self.services.clone(), self.config.clone());
         let mut response_stream = app
             .chat(
                 agent_id.clone(),

crates/forge_app/src/app.rs

@@ -44,12 +44,13 @@ pub(crate) fn build_template_config(config: &ForgeConfig) -> forge_domain::Templ
 pub struct ForgeApp<S> {
     services: Arc<S>,
     tool_registry: ToolRegistry<S>,
+    config: ForgeConfig,
 }
 
 impl<S: Services> ForgeApp<S> {
-    /// Creates a new ForgeApp instance with the provided services.
-    pub fn new(services: Arc<S>) -> Self {
-        Self { tool_registry: ToolRegistry::new(services.clone()), services }
+    /// Creates a new ForgeApp instance with the provided services and config.
+    pub fn new(services: Arc<S>, config: ForgeConfig) -> Self {
+        Self { tool_registry: ToolRegistry::new(services.clone(), config.clone()), services, config }
     }
 
     /// Executes a chat request and returns a stream of responses.
@@ -69,7 +70,7 @@ impl<S: Services> ForgeApp<S> {
             .expect("conversation for the request should've been created at this point.");
 
         // Discover files using the discovery service
-        let forge_config = services.get_config();
+        let forge_config = self.config.clone();
         let environment = services.get_environment();
 
         let files = services.list_current_directory().await?;
@@ -157,7 +158,7 @@ impl<S: Services> ForgeApp<S> {
 
         let retry_config = forge_config.retry.clone().unwrap_or_default();
 
-        let orch = Orchestrator::new(services.clone(), retry_config, conversation, agent)
+        let orch = Orchestrator::new(services.clone(), retry_config, conversation, agent, forge_config)
             .error_tracker(ToolErrorTracker::new(max_tool_failure_per_turn))
             .tool_definitions(tool_definitions)
             .models(models)
@@ -219,7 +220,7 @@ impl<S: Services> ForgeApp<S> {
         let original_messages = context.messages.len();
         let original_token_count = *context.token_count();
 
-        let forge_config = self.services.get_config();
+        let forge_config = self.config.clone();
 
         // Get agent and apply workflow config
         let agent = self.services.get_agent(&active_agent_id).await?;

crates/forge_app/src/git_app.rs

@@ -22,6 +22,7 @@ pub enum GitAppError {
 /// GitApp handles git-related operations like commit message generation.
 pub struct GitApp<S> {
     services: Arc<S>,
+    config: forge_config::ForgeConfig,
 }
 
 /// Result of a commit operation
@@ -66,9 +67,9 @@ struct DiffContext {
 }
 
 impl<S> GitApp<S> {
-    /// Creates a new GitApp instance with the provided services.
-    pub fn new(services: Arc<S>) -> Self {
-        Self { services }
+    /// Creates a new GitApp instance with the provided services and config.
+    pub fn new(services: Arc<S>, config: forge_config::ForgeConfig) -> Self {
+        Self { services, config }
     }
 
     /// Truncates diff content if it exceeds the maximum size
@@ -213,7 +214,7 @@ impl<S: Services> GitApp<S>
             additional_context,
         };
 
-        let retry_config = self.services.get_config().retry.unwrap_or_default();
+        let retry_config = self.config.retry.clone().unwrap_or_default();
         crate::retry::retry_with_config(
             &retry_config,
             || self.generate_message_from_diff(ctx.clone()),
@@ -224,7 +225,7 @@ impl<S: Services> GitApp<S>
 
     /// Fetches git context (branch name and recent commits)
     async fn fetch_git_context(&self, cwd: &Path) -> Result<(String, String)> {
-        let max_commit_count = self.services.get_config().max_commit_count;
+        let max_commit_count = self.config.max_commit_count;
         let git_log_cmd =
             format!("git log --pretty=format:%s --abbrev-commit --max-count={max_commit_count}");
         let (recent_commits, branch_name) = tokio::join!(

crates/forge_app/src/hooks/title_generation.rs

@@ -189,6 +189,7 @@ mod tests {
             _agent: &Agent,
             _context: &ToolCallContext,
             _call: ToolCallFull,
+            _config: &forge_config::ForgeConfig,
         ) -> ToolResult {
             unreachable!("Not used in tests")
         }

crates/forge_app/src/orch.rs

@@ -25,6 +25,7 @@ pub struct Orchestrator<S> {
     agent: Agent,
     error_tracker: ToolErrorTracker,
     hook: Arc<Hook>,
+    config: forge_config::ForgeConfig,
 }
 
 impl<S: AgentService> Orchestrator<S> {
@@ -33,12 +34,14 @@ impl<S: AgentService> Orchestrator<S> {
         retry_config: RetryConfig,
         conversation: Conversation,
         agent: Agent,
+        config: forge_config::ForgeConfig,
     ) -> Self {
         Self {
             conversation,
             retry_config,
             services,
             agent,
+            config,
             sender: Default::default(),
             tool_definitions: Default::default(),
             models: Default::default(),
@@ -97,7 +100,7 @@ impl<S: AgentService> Orchestrator<S> {
             // Execute the tool
             let tool_result = self
                 .services
-                .call(&self.agent, tool_context, tool_call.clone())
+                .call(&self.agent, tool_context, tool_call.clone(), &self.config)
                 .await;
 
             // Fire the ToolcallEnd lifecycle event (fires on both success and failure)

crates/forge_app/src/orch_spec/orch_runner.rs

@@ -120,7 +120,7 @@ impl Runner {
         let conversation = SetConversationId.apply(conversation);
 
         let retry_config = setup.config.retry.clone().unwrap_or_default();
-        let orch = Orchestrator::new(services.clone(), retry_config, conversation, agent)
+        let orch = Orchestrator::new(services.clone(), retry_config, conversation, agent, setup.config.clone())
             .error_tracker(ToolErrorTracker::new(3))
             .tool_definitions(system_tools)
             .hook(Arc::new(
@@ -171,6 +171,7 @@ impl AgentService for Runner {
         _: &forge_domain::Agent,
         _: &forge_domain::ToolCallContext,
         test_call: forge_domain::ToolCallFull,
+        _: &forge_config::ForgeConfig,
     ) -> forge_domain::ToolResult {
         let name = test_call.name.clone();
         let mut guard = self.test_tool_calls.lock().await;

crates/forge_app/src/services.rs

@@ -604,12 +604,6 @@ pub trait Services: Send + Sync + 'static + Clone + EnvironmentInfra {
     fn provider_auth_service(&self) -> &Self::ProviderAuthService;
     fn workspace_service(&self) -> &Self::WorkspaceService;
     fn skill_fetch_service(&self) -> &Self::SkillFetchService;
-
-    /// Returns the current application configuration snapshot.
-    ///
-    /// Config is read once at startup and passed via constructor. Values are
-    /// not re-read from disk dynamically.
-    fn get_config(&self) -> forge_config::ForgeConfig;
 }
 
 #[async_trait::async_trait]