feat(provider): add support for custom provider URLs

README.md

@@ -50,6 +50,9 @@ Forge is a comprehensive coding agent that integrates AI capabilities with your
     - [Agent Configuration Options](#agent-configuration-options)
     - [Built-in Templates](#built-in-templates)
     - [Example Workflow Configuration](#example-workflow-configuration)
+- [Provider Configuration](#provider-configuration)
+  - [Supported Providers](#supported-providers)
+  - [Custom Provider URLs](#custom-provider-urls)
 - [Why Shell?](#why-shell)
 - [Community](#community)
 - [Support Us](#support-us)
@@ -86,6 +89,9 @@ wget -qO- https://raw.githubusercontent.com/antinomyhq/forge/main/install.sh | b
    ```bash
    # Your API key for accessing AI models (see Environment Configuration section)
    OPENROUTER_API_KEY=<Enter your Open Router Key>
+
+   # Optional: Set a custom URL for OpenAI-compatible providers
+   #OPENAI_URL=https://custom-openai-provider.com/v1
    ```
 
    _You can get a Key at [Open Router](https://openrouter.ai/)_
@@ -239,6 +245,58 @@ tail -f /Users/tushar/Library/Application Support/forge/logs/forge.log.2025-03-0
 
 This displays the logs in a nicely color-coded structure that's much easier to analyze, helping you quickly identify patterns, errors, or specific behavior during development and debugging.
 
+## Provider Configuration
+
+Forge supports multiple AI providers and allows custom configuration to meet your specific needs.
+
+### Supported Providers
+
+Forge automatically detects and uses your API keys from environment variables in the following priority order:
+
+1. `FORGE_KEY` - Antinomy's provider (OpenAI-compatible)
+2. `OPENROUTER_API_KEY` - Open Router provider (aggregates multiple models)
+3. `OPENAI_API_KEY` - Official OpenAI provider
+4. `ANTHROPIC_API_KEY` - Official Anthropic provider
+
+To use a specific provider, set the corresponding environment variable in your `.env` file.
+
+```bash
+# Examples of different provider configurations (use only one)
+
+# For Open Router (recommended, provides access to multiple models)
+OPENROUTER_API_KEY=your_openrouter_key_here
+
+# For official OpenAI
+OPENAI_API_KEY=your_openai_key_here
+
+# For official Anthropic
+ANTHROPIC_API_KEY=your_anthropic_key_here
+
+# For Antinomy's provider
+FORGE_KEY=your_forge_key_here
+```
+
+### Custom Provider URLs
+
+For OpenAI-compatible providers (including Open Router), you can customize the API endpoint URL by setting the `OPENAI_URL` environment variable:
+
+```bash
+# Custom OpenAI-compatible provider
+OPENAI_API_KEY=your_api_key_here
+OPENAI_URL=https://your-custom-provider.com/v1
+
+# Or with Open Router but custom endpoint
+OPENROUTER_API_KEY=your_openrouter_key_here
+OPENAI_URL=https://alternative-openrouter-endpoint.com/v1
+```
+
+This is particularly useful when:
+
+- Using self-hosted models with OpenAI-compatible APIs
+- Connecting to enterprise OpenAI deployments
+- Using proxy services or API gateways
+- Working with regional API endpoints
+
 ## Custom Workflows and Multi-Agent Systems
 
 For complex tasks, a single agent may not be sufficient. Forge allows you to create custom workflows with multiple specialized agents working together to accomplish sophisticated tasks.

crates/forge_domain/src/context.rs

@@ -220,9 +220,12 @@ impl Context {
     }
 
     pub fn add_tool_results(mut self, results: Vec<ToolResult>) -> Self {
-        debug!(results = ?results, "Adding tool results to context");
-        self.messages
-            .extend(results.into_iter().map(ContextMessage::tool_result));
+        if !results.is_empty() {
+            debug!(results = ?results, "Adding tool results to context");
+            self.messages
+                .extend(results.into_iter().map(ContextMessage::tool_result));
+        }
+
         self
     }
 

crates/forge_domain/src/provider.rs

@@ -9,28 +9,38 @@ pub enum Provider {
 }
 
 impl Provider {
-    pub fn antinomy(key: impl Into<String>) -> Provider {
+    /// Sets the OpenAI URL if the provider is an OpenAI compatible provider
+    pub fn open_ai_url(&mut self, url: String) {
+        match self {
+            Provider::OpenAI { url: set_url, .. } => {
+                *set_url = Url::parse(&url).unwrap();
+            }
+            Provider::Anthropic { .. } => {}
+        }
+    }
+
+    pub fn antinomy(key: &str) -> Provider {
         Provider::OpenAI {
             url: Url::parse(Provider::ANTINOMY_URL).unwrap(),
             key: Some(key.into()),
         }
     }
 
-    pub fn openai(key: impl Into<String>) -> Provider {
+    pub fn openai(key: &str) -> Provider {
         Provider::OpenAI {
             url: Url::parse(Provider::OPENAI_URL).unwrap(),
             key: Some(key.into()),
         }
     }
 
-    pub fn open_router(key: impl Into<String>) -> Provider {
+    pub fn open_router(key: &str) -> Provider {
         Provider::OpenAI {
             url: Url::parse(Provider::OPEN_ROUTER_URL).unwrap(),
             key: Some(key.into()),
         }
     }
 
-    pub fn anthropic(key: impl Into<String>) -> Provider {
+    pub fn anthropic(key: &str) -> Provider {
         Provider::Anthropic { key: key.into() }
     }
 

crates/forge_infra/src/env.rs

@@ -38,19 +38,10 @@ impl ForgeEnvironmentService {
     /// Panics if no API key is found in the environment
     fn resolve_provider(&self) -> Provider {
         let keys: [ProviderSearch; 4] = [
-            ("FORGE_KEY", Box::new(|key: &str| Provider::antinomy(key))),
-            (
-                "OPENROUTER_API_KEY",
-                Box::new(|key: &str| Provider::open_router(key)),
-            ),
-            (
-                "OPENAI_API_KEY",
-                Box::new(|key: &str| Provider::openai(key)),
-            ),
-            (
-                "ANTHROPIC_API_KEY",
-                Box::new(|key: &str| Provider::anthropic(key)),
-            ),
+            ("FORGE_KEY", Box::new(Provider::antinomy)),
+            ("OPENROUTER_API_KEY", Box::new(Provider::open_router)),
+            ("OPENAI_API_KEY", Box::new(Provider::openai)),
+            ("ANTHROPIC_API_KEY", Box::new(Provider::anthropic)),
         ];
 
         let env_variables = keys
@@ -60,7 +51,17 @@ impl ForgeEnvironmentService {
             .join(", ");
 
         keys.into_iter()
-            .find_map(|(key, fun)| std::env::var(key).ok().map(|key| fun(&key)))
+            .find_map(|(key, fun)| {
+                std::env::var(key).ok().map(|key| {
+                    let mut provider = fun(&key);
+
+                    if let Ok(url) = std::env::var("OPENAI_URL") {
+                        provider.open_ai_url(url);
+                    }
+
+                    provider
+                })
+            })
             .unwrap_or_else(|| panic!("No API key found. Please set one of: {}", env_variables))
     }