refactor: remove deprecated method from ProviderService

Remove deprecated  method from the ProviderService trait and all its implementations.
The method was marked as deprecated because tool support is now determined by the  field
in the Agent struct instead of querying the provider.

This change includes:
- Removing the method from the trait definition in forge_domain
- Removing implementations in OpenRouter, Anthropic, Client, and ForgeProviderService
- Cleaning up related code (imports, cache field, unused helper methods)

Related issue: #123 (placeholder issue number)

Author: tusharmath

crates/forge_app/src/provider.rs

@@ -2,18 +2,15 @@ use std::sync::Arc;
 
 use anyhow::{Context, Result};
 use forge_domain::{
-    ChatCompletionMessage, Context as ChatContext, Model, ModelId, Parameters, ProviderService,
-    ResultStream,
+    ChatCompletionMessage, Context as ChatContext, Model, ModelId, ProviderService, ResultStream,
 };
 use forge_open_router::Client;
-use moka2::future::Cache;
 
 use crate::{EnvironmentService, Infrastructure};
 
 pub struct ForgeProviderService {
     // The provider service implementation
     client: Client,
-    cache: Cache<ModelId, Parameters>,
 }
 
 impl ForgeProviderService {
@@ -24,10 +21,7 @@ impl ForgeProviderService {
             .get_environment()
             .provider
             .clone();
-        Self {
-            client: Client::new(provider).unwrap(),
-            cache: Cache::new(1024),
-        }
+        Self { client: Client::new(provider).unwrap() }
     }
 }
 
@@ -47,16 +41,4 @@ impl ProviderService for ForgeProviderService {
     async fn models(&self) -> Result<Vec<Model>> {
         self.client.models().await
     }
-
-    async fn parameters(&self, model: &ModelId) -> anyhow::Result<Parameters> {
-        self.cache
-            .try_get_with_by_ref(model, async {
-                self.client
-                    .parameters(model)
-                    .await
-                    .with_context(|| format!("Failed to get parameters for model: {}", model))
-            })
-            .await
-            .map_err(|e| anyhow::anyhow!(e))
-    }
 }

crates/forge_domain/src/lib.rs

@@ -63,17 +63,6 @@ pub trait ProviderService: Send + Sync + 'static {
         context: Context,
     ) -> ResultStream<ChatCompletionMessage, anyhow::Error>;
     async fn models(&self) -> anyhow::Result<Vec<Model>>;
-
-    /// Returns parameters for the specified model
-    ///
-    /// Deprecated: Tool support is now determined by the `tool_supported` field
-    /// in the Agent struct instead of querying the provider. This method
-    /// will be removed in a future version.
-    #[deprecated(
-        since = "next",
-        note = "Use the `tool_supported` field in the Agent struct instead"
-    )]
-    async fn parameters(&self, model: &ModelId) -> anyhow::Result<Parameters>;
 }
 
 #[async_trait::async_trait]

crates/forge_open_router/src/anthropic/provider.rs

@@ -1,8 +1,6 @@
 use anyhow::Context as _;
 use derive_builder::Builder;
-use forge_domain::{
-    ChatCompletionMessage, Context, Model, ModelId, Parameters, ProviderService, ResultStream,
-};
+use forge_domain::{ChatCompletionMessage, Context, Model, ModelId, ProviderService, ResultStream};
 use reqwest::header::{HeaderMap, HeaderValue};
 use reqwest::{Client, Url};
 use reqwest_eventsource::{Event, RequestBuilderExt};
@@ -116,15 +114,6 @@ impl ProviderService for Anthropic {
         let response: ListModelResponse = serde_json::from_str(&text)?;
         Ok(response.data.into_iter().map(Into::into).collect())
     }
-    #[deprecated(
-        since = "next",
-        note = "Use the `tool_supported` field in the Agent struct instead"
-    )]
-    async fn parameters(&self, _model: &ModelId) -> anyhow::Result<Parameters> {
-        // TODO: anthropic provider doesn't have this API, so for now allowing tool
-        // calls for all models.
-        Ok(Parameters { tool_supported: true })
-    }
 }
 
 #[cfg(test)]

crates/forge_open_router/src/builder.rs

@@ -2,8 +2,7 @@
 
 use anyhow::{Context as _, Result};
 use forge_domain::{
-    ChatCompletionMessage, Context, Model, ModelId, Parameters, Provider, ProviderService,
-    ResultStream,
+    ChatCompletionMessage, Context, Model, ModelId, Provider, ProviderService, ResultStream,
 };
 
 use crate::anthropic::Anthropic;
@@ -59,11 +58,4 @@ impl ProviderService for Client {
             Client::Anthropic(provider) => provider.models().await,
         }
     }
-
-    async fn parameters(&self, model: &ModelId) -> anyhow::Result<Parameters> {
-        match self {
-            Client::OpenAICompat(provider) => provider.parameters(model).await,
-            Client::Anthropic(provider) => provider.parameters(model).await,
-        }
-    }
 }

crates/forge_open_router/src/open_router/api.rs

@@ -1,8 +1,8 @@
 use anyhow::{Context as _, Result};
 use derive_builder::Builder;
 use forge_domain::{
-    self, ChatCompletionMessage, Context as ChatContext, Model, ModelId, Parameters, Provider,
-    ProviderService, ResultStream,
+    self, ChatCompletionMessage, Context as ChatContext, Model, ModelId, Provider, ProviderService,
+    ResultStream,
 };
 use reqwest::header::{HeaderMap, HeaderValue, AUTHORIZATION};
 use reqwest::{Client, Url};
@@ -11,7 +11,6 @@ use tokio_stream::StreamExt;
 use tracing::debug;
 
 use super::model::{ListModelResponse, OpenRouterModel};
-use super::parameters::ParameterResponse;
 use super::request::OpenRouterRequest;
 use super::response::OpenRouterResponse;
 use crate::open_router::transformers::{ProviderPipeline, Transformer};
@@ -56,23 +55,6 @@ impl OpenRouter {
         headers.insert("X-Title", HeaderValue::from_static("code-forge"));
         headers
     }
-
-    // Fetches parameters from the API and returns the raw text response
-    async fn fetch_parameters(&self, path: &str) -> Result<String> {
-        let url = self.url(path)?;
-        let text = self
-            .client
-            .get(url)
-            .headers(self.headers())
-            .send()
-            .await?
-            .error_for_status()
-            .with_context(|| "Failed to complete parameter request")?
-            .text()
-            .await?;
-
-        Ok(text)
-    }
 }
 
 #[async_trait::async_trait]
@@ -164,39 +146,6 @@ impl ProviderService for OpenRouter {
             Ok(data.data.into_iter().map(Into::into).collect())
         }
     }
-
-    #[deprecated(
-        since = "next",
-        note = "Use the `tool_supported` field in the Agent struct instead"
-    )]
-    async fn parameters(&self, model: &ModelId) -> Result<Parameters> {
-        if self.provider.is_open_router() | self.provider.is_antinomy() {
-            // For Eg: https://openrouter.ai/api/v1/parameters/google/gemini-pro-1.5-exp
-            let path = if self.provider.is_open_router() {
-                format!("parameters/{}", model)
-            } else {
-                format!("model/{}/parameters", model)
-            };
-
-            let text = self.fetch_parameters(&path).await?;
-
-            let response: ParameterResponse = serde_json::from_str(&text)
-                .with_context(|| "Failed to parse parameter response".to_string())?;
-
-            Ok(Parameters {
-                tool_supported: response
-                    .data
-                    .supported_parameters
-                    .iter()
-                    .flat_map(|parameter| parameter.iter())
-                    .any(|parameter| parameter == "tools"),
-            })
-        } else if self.provider.is_open_ai() {
-            return Ok(Parameters { tool_supported: true });
-        } else {
-            return Ok(Parameters { tool_supported: false });
-        }
-    }
 }
 
 impl From<OpenRouterModel> for Model {