From 29aa50cfb8f94456c615ddf66002213a93ee0ee3 Mon Sep 17 00:00:00 2001
From: Henrik Bakke Dukefoss <henrikdukef@gmail.com>
Date: Thu, 15 Oct 2026 14:01:03 +0200
Subject: [PATCH] fix(provider): add Standard Compute as a built-in provider

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 README.md                                     | 10 +++++++
 crates/forge_domain/src/provider.rs           | 24 +++++++++++++++++
 crates/forge_repo/src/provider/provider.json  |  9 +++++++
 .../forge_repo/src/provider/provider_repo.rs  | 26 +++++++++++++++++++
 4 files changed, 69 insertions(+)

diff --git a/README.md b/README.md
index 1e7e66626d..c3b5459a94 100644
--- a/README.md
+++ b/README.md
@@ -590,6 +590,16 @@ ORCAROUTER_API_KEY=<your_orcarouter_api_key>
 
 </details>
 
+<details>
+<summary><strong>Standard Compute</strong></summary>
+
+```bash
+# .env
+STANDARDCOMPUTE_API_KEY=<your_standardcompute_api_key>
+```
+
+</details>
+
 <details>
 <summary><strong>Meta</strong></summary>
 
diff --git a/crates/forge_domain/src/provider.rs b/crates/forge_domain/src/provider.rs
index 0cdff67c96..d9372e890d 100644
--- a/crates/forge_domain/src/provider.rs
+++ b/crates/forge_domain/src/provider.rs
@@ -88,6 +88,7 @@ impl ProviderId {
     pub const KIMI_CODING: ProviderId = ProviderId(Cow::Borrowed("kimi_coding"));
     pub const MOONSHOT: ProviderId = ProviderId(Cow::Borrowed("moonshot"));
     pub const ALIBABA_TOKEN_PLAN: ProviderId = ProviderId(Cow::Borrowed("alibaba_token_plan"));
+    pub const STANDARD_COMPUTE: ProviderId = ProviderId(Cow::Borrowed("standard_compute"));
 
     /// Returns all built-in provider IDs
     ///
@@ -135,6 +136,7 @@ impl ProviderId {
             ProviderId::KIMI_CODING,
             ProviderId::MOONSHOT,
             ProviderId::ALIBABA_TOKEN_PLAN,
+            ProviderId::STANDARD_COMPUTE,
         ]
     }
 
@@ -173,6 +175,7 @@ impl ProviderId {
             "neuralwatt" => "Neuralwatt".to_string(),
             "orca_router" => "OrcaRouter".to_string(),
             "meta" => "Meta".to_string(),
+            "standard_compute" => "StandardCompute".to_string(),
             _ => {
                 // For other providers, use UpperCamelCase conversion
                 use convert_case::{Case, Casing};
@@ -235,6 +238,7 @@ impl std::str::FromStr for ProviderId {
             "kimi_coding" => ProviderId::KIMI_CODING,
             "moonshot" => ProviderId::MOONSHOT,
             "alibaba_token_plan" => ProviderId::ALIBABA_TOKEN_PLAN,
+            "standard_compute" => ProviderId::STANDARD_COMPUTE,
             // For custom providers, use Cow::Owned to avoid memory leaks
             custom => ProviderId(Cow::Owned(custom.to_string())),
         };
@@ -614,6 +618,7 @@ mod tests {
         assert_eq!(ProviderId::AMBIENT.to_string(), "Ambient");
         assert_eq!(ProviderId::ORCA_ROUTER.to_string(), "OrcaRouter");
         assert_eq!(ProviderId::META.to_string(), "Meta");
+        assert_eq!(ProviderId::STANDARD_COMPUTE.to_string(), "StandardCompute");
     }
 
     #[test]
@@ -657,6 +662,7 @@ mod tests {
         assert!(built_in.contains(&ProviderId::AMBIENT));
         assert!(built_in.contains(&ProviderId::ORCA_ROUTER));
         assert!(built_in.contains(&ProviderId::META));
+        assert!(built_in.contains(&ProviderId::STANDARD_COMPUTE));
     }
 
     #[test]
@@ -774,6 +780,24 @@ mod tests {
         assert!(built_in.contains(&ProviderId::ORCA_ROUTER));
     }
 
+    #[test]
+    fn test_standard_compute_from_str() {
+        let actual = ProviderId::from_str("standard_compute").unwrap();
+        let expected = ProviderId::STANDARD_COMPUTE;
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_standard_compute_display_name() {
+        assert_eq!(ProviderId::STANDARD_COMPUTE.to_string(), "StandardCompute");
+    }
+
+    #[test]
+    fn test_standard_compute_in_built_in_providers() {
+        let built_in = ProviderId::built_in_providers();
+        assert!(built_in.contains(&ProviderId::STANDARD_COMPUTE));
+    }
+
     #[test]
     fn test_meta_from_str() {
         let actual = ProviderId::from_str("meta").unwrap();
diff --git a/crates/forge_repo/src/provider/provider.json b/crates/forge_repo/src/provider/provider.json
index d99127ce53..3715d9c301 100644
--- a/crates/forge_repo/src/provider/provider.json
+++ b/crates/forge_repo/src/provider/provider.json
@@ -4122,5 +4122,14 @@
       }
     ],
     "auth_methods": ["api_key"]
+  },
+  {
+    "id": "standard_compute",
+    "api_key_vars": "STANDARDCOMPUTE_API_KEY",
+    "url_param_vars": [],
+    "response_type": "OpenAI",
+    "url": "https://api.stdcmpt.com/v1/chat/completions",
+    "models": "https://api.stdcmpt.com/v1/models",
+    "auth_methods": ["api_key"]
   }
 ]
diff --git a/crates/forge_repo/src/provider/provider_repo.rs b/crates/forge_repo/src/provider/provider_repo.rs
index 7f4329315a..504948d581 100644
--- a/crates/forge_repo/src/provider/provider_repo.rs
+++ b/crates/forge_repo/src/provider/provider_repo.rs
@@ -971,6 +971,32 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_standard_compute_config() {
+        let configs = get_provider_configs();
+        let config = configs
+            .iter()
+            .find(|c| c.id == ProviderId::STANDARD_COMPUTE)
+            .unwrap();
+        assert_eq!(config.id, ProviderId::STANDARD_COMPUTE);
+        assert_eq!(
+            config.api_key_vars,
+            Some("STANDARDCOMPUTE_API_KEY".to_string())
+        );
+        assert!(config.url_param_vars.is_empty());
+        assert_eq!(config.response_type, Some(ProviderResponse::OpenAI));
+        assert_eq!(
+            config.url.as_str(),
+            "https://api.stdcmpt.com/v1/chat/completions"
+        );
+        match config.models.as_ref().expect("models should be present") {
+            Models::Url(model_url) => {
+                assert_eq!(model_url, "https://api.stdcmpt.com/v1/models");
+            }
+            other => panic!("expected URL-driven models, got {other:?}"),
+        }
+    }
+
     #[test]
     fn test_meta_config() {
         let configs = get_provider_configs();