feat(backend): adding Azure AI Foundry OpenAPI support

crates/http-api-bindings/src/chat/mod.rs

@@ -12,31 +12,48 @@ pub async fn create(model: &HttpModelConfig) -> Arc<dyn ChatCompletionStream> {
         .api_endpoint
         .as_deref()
         .expect("api_endpoint is required");
-    let config = OpenAIConfig::default()
-        .with_api_base(api_endpoint)
-        .with_api_key(model.api_key.clone().unwrap_or_default());
-
-    let mut builder = ExtendedOpenAIConfig::builder();
-
-    builder
-        .base(config)
-        .supported_models(model.supported_models.clone())
-        .model_name(model.model_name.as_deref().expect("Model name is required"));
-
-    if model.kind == "openai/chat" {
-        // Do nothing
-    } else if model.kind == "mistral/chat" {
-        builder.fields_to_remove(ExtendedOpenAIConfig::mistral_fields_to_remove());
-    } else {
-        panic!("Unsupported model kind: {}", model.kind);
-    }
-
-    let config = builder.build().expect("Failed to build config");
-
-    let engine = Box::new(
-        async_openai_alt::Client::with_config(config)
-            .with_http_client(create_reqwest_client(api_endpoint)),
-    );
+
+    let engine: Box<dyn ChatCompletionStream> = match model.kind.as_str() {
+        "azure/chat" => {
+            let config = async_openai_alt::config::AzureConfig::new()
+                .with_api_base(api_endpoint)
+                .with_api_key(model.api_key.clone().unwrap_or_default())
+                .with_api_version(
+                    model
+                        .api_version
+                        .clone()
+                        .unwrap_or("2024-05-01-preview".to_string()),
+                )
+                .with_deployment_id(model.model_name.as_deref().expect("Model name is required"));
+            Box::new(
+                async_openai_alt::Client::with_config(config)
+                    .with_http_client(create_reqwest_client(api_endpoint)),
+            )
+        }
+        "openai/chat" | "mistral/chat" => {
+            let config = OpenAIConfig::default()
+                .with_api_base(api_endpoint)
+                .with_api_key(model.api_key.clone().unwrap_or_default());
+
+            let mut builder = ExtendedOpenAIConfig::builder();
+            builder
+                .base(config)
+                .supported_models(model.supported_models.clone())
+                .model_name(model.model_name.as_deref().expect("Model name is required"));
+
+            if model.kind == "mistral/chat" {
+                builder.fields_to_remove(ExtendedOpenAIConfig::mistral_fields_to_remove());
+            }
+
+            Box::new(
+                async_openai_alt::Client::with_config(
+                    builder.build().expect("Failed to build config"),
+                )
+                .with_http_client(create_reqwest_client(api_endpoint)),
+            )
+        }
+        _ => panic!("Unsupported model kind: {}", model.kind),
+    };
 
     Arc::new(rate_limit::new_chat(
         engine,

crates/tabby-common/src/config.rs

@@ -310,6 +310,11 @@ pub struct HttpModelConfig {
 
     #[builder(default)]
     pub additional_stop_words: Option<Vec<String>>,
+
+    /// Used For Azure API to specify the api version
+    #[builder(default)]
+    #[serde(default)]
+    pub api_version: Option<String>,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]

crates/tabby-inference/src/chat.rs

@@ -125,3 +125,20 @@ impl ChatCompletionStream for async_openai_alt::Client<ExtendedOpenAIConfig> {
         self.chat().create_stream(request).await
     }
 }
+
+#[async_trait]
+impl ChatCompletionStream for async_openai_alt::Client<async_openai_alt::config::AzureConfig> {
+    async fn chat(
+        &self,
+        request: CreateChatCompletionRequest,
+    ) -> Result<CreateChatCompletionResponse, OpenAIError> {
+        self.chat().create(request).await
+    }
+
+    async fn chat_stream(
+        &self,
+        request: CreateChatCompletionRequest,
+    ) -> Result<ChatCompletionResponseStream, OpenAIError> {
+        self.chat().create_stream(request).await
+    }
+}