Adding a minimal Azure OpenAI Inference SDK.

.vscode/cspell.json

@@ -32,13 +32,15 @@
     "downcasted",
     "downcasting",
     "entra",
+    "endregion",
     "etag",
     "eventhub",
     "eventhubs",
     "hmac",
     "iothub",
     "keyvault",
     "msrc",
+    "openai",
     "pageable",
     "pkce",
     "pkcs",

Cargo.toml

@@ -12,6 +12,7 @@ members = [
   "eng/test/mock_transport",
   "sdk/storage",
   "sdk/storage/azure_storage_blob",
+  "sdk/openai/inference",
 ]
 
 [workspace.package]

sdk/openai/inference/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "azure_openai_inference"
+version = "1.0.0-beta.1"
+description = "Rust client library for Azure OpenAI Inference"
+readme = "README.md"
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+keywords = ["sdk", "azure", "rest"]
+categories = ["api-bindings"]
+
+[lints]
+workspace = true
+
+[dependencies]
+azure_core = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+async-trait = { workspace = true }
+futures = { workspace = true }
+bytes = { workspace = true }
+typespec_client_core = { workspace = true, features = ["derive"] }
+
+[dev-dependencies]
+azure_core = { workspace = true, features = ["reqwest"] }
+azure_identity = { workspace = true }
+reqwest = { workspace = true }
+tokio = { workspace = true }

sdk/openai/inference/README.md

@@ -0,0 +1,39 @@
+# Azure OpenAI Inference SDK for Rust
+
+## Introduction
+
+This SDK provides Rust types to interact with both OpenAI and Azure OpenAI services.
+
+Note: Currently request and response models have as few fields as possible, leveraging the server side defaults wherever they can.
+
+### Features
+
+All features are showcased in the `example` folder of this crate. The following is a list of what is currently supported:
+
+- Supporting both usage with OpenAI and Azure OpenAI services by using `OpenAIClient` or `AzureOpenAIClient`, respectively.
+- Key credential authentication is supported.
+- [Azure Only] Azure Active Directory (AAD) authentication is supported.
+- `ChatCompletions` operation supported (limited fields).
+- Streaming for `ChatCompletions` is supported
+
+## Authentication methods
+
+### Azure Active Directory
+
+This authentication method is only supported for Azure OpenAI services.
+
+```rust
+AzureOpenAIClient::new(
+    endpoint,
+    Arc::new(DefaultAzureCredentialBuilder::new().build()?),
+    None,
+)?
+```
+
+### Key Credentials
+
+This method of authentication is supported both for Azure and non-Azure OpenAI services.
+
+```rust
+OpenAIClient::with_key_credential(secret, None)?
+```

sdk/openai/inference/examples/azure_chat_completions.rs

@@ -0,0 +1,48 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+use azure_openai_inference::{
+    clients::{AzureOpenAIClient, AzureOpenAIClientMethods, ChatCompletionsClientMethods},
+    AzureOpenAIClientOptions, AzureServiceVersion, CreateChatCompletionsRequest,
+};
+
+// This example illustrates how to use Azure OpenAI with key credential authentication to generate a chat completion.
+#[tokio::main]
+pub async fn main() {
+    let endpoint =
+        std::env::var("AZURE_OPENAI_ENDPOINT").expect("Set AZURE_OPENAI_ENDPOINT env variable");
+    let secret = std::env::var("AZURE_OPENAI_KEY").expect("Set AZURE_OPENAI_KEY env variable");
+
+    let chat_completions_client = AzureOpenAIClient::with_key_credential(
+        endpoint,
+        secret,
+        Some(
+            AzureOpenAIClientOptions::builder()
+                .with_api_version(AzureServiceVersion::V2023_12_01Preview)
+                .build(),
+        ),
+    )
+    .unwrap()
+    .chat_completions_client();
+
+    let chat_completions_request = CreateChatCompletionsRequest::with_user_message(
+        "gpt-4-1106-preview",
+        "Tell me a joke about pineapples",
+    );
+
+    let response = chat_completions_client
+        .create_chat_completions(&chat_completions_request.model, &chat_completions_request)
+        .await;
+
+    match response {
+        Ok(chat_completions_response) => {
+            let chat_completions = chat_completions_response
+                .deserialize_body()
+                .await
+                .expect("Failed to deserialize response");
+            println!("{:#?}", &chat_completions);
+        }
+        Err(e) => {
+            println!("Error: {}", e);
+        }
+    };
+}

sdk/openai/inference/examples/azure_chat_completions_aad.rs

@@ -0,0 +1,50 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+use azure_identity::DefaultAzureCredentialBuilder;
+use azure_openai_inference::{
+    clients::{AzureOpenAIClient, AzureOpenAIClientMethods, ChatCompletionsClientMethods},
+    AzureOpenAIClientOptions, AzureServiceVersion, CreateChatCompletionsRequest,
+};
+
+/// This example illustrates how to use Azure OpenAI Chat Completions with Azure Active Directory authentication.
+#[tokio::main]
+async fn main() {
+    let endpoint =
+        std::env::var("AZURE_OPENAI_ENDPOINT").expect("Set AZURE_OPENAI_ENDPOINT env variable");
+
+    let chat_completions_client = AzureOpenAIClient::new(
+        endpoint,
+        DefaultAzureCredentialBuilder::new()
+            .build()
+            .expect("Failed to create Azure credential"),
+        Some(
+            AzureOpenAIClientOptions::builder()
+                .with_api_version(AzureServiceVersion::V2023_12_01Preview)
+                .build(),
+        ),
+    )
+    .unwrap()
+    .chat_completions_client();
+
+    let chat_completions_request = CreateChatCompletionsRequest::with_user_message(
+        "gpt-4-1106-preview",
+        "Tell me a joke about pineapples",
+    );
+
+    let response = chat_completions_client
+        .create_chat_completions(&chat_completions_request.model, &chat_completions_request)
+        .await;
+
+    match response {
+        Ok(chat_completions_response) => {
+            let chat_completions = chat_completions_response
+                .deserialize_body()
+                .await
+                .expect("Failed to deserialize response");
+            println!("{:#?}", &chat_completions);
+        }
+        Err(e) => {
+            println!("Error: {}", e);
+        }
+    };
+}

sdk/openai/inference/examples/azure_chat_completions_stream.rs

@@ -0,0 +1,57 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+use azure_openai_inference::{
+    clients::{AzureOpenAIClient, AzureOpenAIClientMethods, ChatCompletionsClientMethods},
+    AzureOpenAIClientOptions, AzureServiceVersion, CreateChatCompletionsRequest,
+};
+use futures::stream::StreamExt;
+use std::io::{self, Write};
+
+/// This example illustrates how to use Azure OpenAI with key credential authentication to stream chat completions.
+#[tokio::main]
+async fn main() {
+    let endpoint =
+        std::env::var("AZURE_OPENAI_ENDPOINT").expect("Set AZURE_OPENAI_ENDPOINT env variable");
+    let secret = std::env::var("AZURE_OPENAI_KEY").expect("Set AZURE_OPENAI_KEY env variable");
+
+    let chat_completions_client = AzureOpenAIClient::with_key_credential(
+        endpoint,
+        secret,
+        Some(
+            AzureOpenAIClientOptions::builder()
+                .with_api_version(AzureServiceVersion::V2023_12_01Preview)
+                .build(),
+        ),
+    )
+    .unwrap()
+    .chat_completions_client();
+
+    let chat_completions_request = CreateChatCompletionsRequest::with_user_message_and_stream(
+        "gpt-4-1106-preview",
+        "Write me an essay that is at least 200 words long on the nutritional values (or lack thereof) of fast food.
+        Start the essay by stating 'this essay will be x many words long' where x is the number of words in the essay.",);
+
+    let response = chat_completions_client
+        .stream_chat_completions(&chat_completions_request.model, &chat_completions_request)
+        .await
+        .unwrap();
+
+    // this pins the stream to the stack so it is safe to poll it (namely, it won't be de-allocated or moved)
+    futures::pin_mut!(response);
+
+    while let Some(result) = response.next().await {
+        match result {
+            Ok(delta) => {
+                if let Some(choice) = delta.choices.get(0) {
+                    choice.delta.as_ref().map(|d| {
+                        d.content.as_ref().map(|c| {
+                            print!("{}", c);
+                            let _ = io::stdout().flush();
+                        });
+                    });
+                }
+            }
+            Err(e) => println!("Error: {:?}", e),
+        }
+    }
+}

sdk/openai/inference/examples/chat_completions.rs

@@ -0,0 +1,38 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+use azure_openai_inference::{
+    clients::{ChatCompletionsClientMethods, OpenAIClient, OpenAIClientMethods},
+    CreateChatCompletionsRequest,
+};
+
+/// This example illustrates how to use OpenAI to generate a chat completion.
+#[tokio::main]
+pub async fn main() {
+    let secret = std::env::var("OPENAI_KEY").expect("Set OPENAI_KEY env variable");
+
+    let chat_completions_client = OpenAIClient::with_key_credential(secret, None)
+        .unwrap()
+        .chat_completions_client();
+
+    let chat_completions_request = CreateChatCompletionsRequest::with_user_message(
+        "gpt-3.5-turbo-1106",
+        "Tell me a joke about pineapples",
+    );
+
+    let response = chat_completions_client
+        .create_chat_completions(&chat_completions_request.model, &chat_completions_request)
+        .await;
+
+    match response {
+        Ok(chat_completions_response) => {
+            let chat_completions = chat_completions_response
+                .deserialize_body()
+                .await
+                .expect("Failed to deserialize response");
+            println!("{:#?}", &chat_completions);
+        }
+        Err(e) => {
+            println!("Error: {}", e);
+        }
+    };
+}

sdk/openai/inference/examples/chat_completions_stream.rs

@@ -0,0 +1,47 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+use azure_openai_inference::{
+    clients::{ChatCompletionsClientMethods, OpenAIClient, OpenAIClientMethods},
+    CreateChatCompletionsRequest,
+};
+use futures::stream::StreamExt;
+use std::io::{self, Write};
+
+/// This example illustrates how to use OpenAI to stream chat completions.
+#[tokio::main]
+async fn main() {
+    let secret = std::env::var("OPENAI_KEY").expect("Set OPENAI_KEY env variable");
+
+    let chat_completions_client = OpenAIClient::with_key_credential(secret, None)
+        .unwrap()
+        .chat_completions_client();
+
+    let chat_completions_request = CreateChatCompletionsRequest::with_user_message_and_stream(
+        "gpt-3.5-turbo-1106",
+        "Write me an essay that is at least 200 words long on the nutritional values (or lack thereof) of fast food.
+        Start the essay by stating 'this essay will be x many words long' where x is the number of words in the essay.",);
+
+    let response = chat_completions_client
+        .stream_chat_completions(&chat_completions_request.model, &chat_completions_request)
+        .await
+        .unwrap();
+
+    // this pins the stream to the stack so it is safe to poll it (namely, it won't be de-allocated or moved)
+    futures::pin_mut!(response);
+
+    while let Some(result) = response.next().await {
+        match result {
+            Ok(delta) => {
+                if let Some(choice) = delta.choices.get(0) {
+                    choice.delta.as_ref().map(|d| {
+                        d.content.as_ref().map(|c| {
+                            print!("{}", c);
+                            let _ = io::stdout().flush();
+                        });
+                    });
+                }
+            }
+            Err(e) => println!("Error: {:?}", e),
+        }
+    }
+}