.NET

```csharp using Azure.Core; using Azure.Identity; using GitHub.Copilot; DefaultAzureCredential credential = new( DefaultAzureCredential.DefaultEnvironmentVariableName); await using CopilotClient client = new(); string foundryUrl = Environment.GetEnvironmentVariable("FOUNDRY_RESOURCE_URL")!; await using CopilotSession session = await client.CreateSessionAsync(new SessionConfig { Model = "gpt-5.5", Provider = new ProviderConfig { Type = "openai", BaseUrl = $"{foundryUrl}/openai/v1/", BearerTokenProvider = async _ => { AccessToken token = await credential.GetTokenAsync( new TokenRequestContext(["https://ai.azure.com/.default"])); return token.Token; }, WireApi = "responses", }, }); AssistantMessageEvent? response = await session.SendAndWaitAsync( new MessageOptions { Prompt = "Hello from Managed Identity!" }); Console.WriteLine(response?.Data.Content); ```

Go

```golang package main import ( "context" "fmt" "log" "os" "time" "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy" "github.com/Azure/azure-sdk-for-go/sdk/azidentity" copilot "github.com/github/copilot-sdk/go" ) func main() { opts := azidentity.DefaultAzureCredentialOptions{RequireAzureTokenCredentials: true} credential, err := azidentity.NewDefaultAzureCredential(&opts) if err != nil { log.Fatal(err) } getBearerToken := func(args copilot.ProviderTokenArgs) (string, error) { token, err := credential.GetToken(context.Background(), policy.TokenRequestOptions{ Scopes: []string{"https://ai.azure.com/.default"}, }) if err != nil { return "", err } return token.Token, nil } client := copilot.NewClient(nil) if err := client.Start(context.Background()); err != nil { log.Fatal(err) } defer client.Stop() foundryURL := os.Getenv("FOUNDRY_RESOURCE_URL") session, err := client.CreateSession(context.Background(), &copilot.SessionConfig{ Model: "gpt-5.5", Provider: &copilot.ProviderConfig{ Type: "openai", BaseURL: fmt.Sprintf("%s/openai/v1/", foundryURL), BearerTokenProvider: getBearerToken, WireAPI: "responses", }, }) if err != nil { log.Fatal(err) } defer session.Disconnect() ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second) defer cancel() response, err := session.SendAndWait(ctx, copilot.MessageOptions{ Prompt: "Hello from Managed Identity!", }) if err != nil { log.Fatal(err) } if response != nil { if data, ok := response.Data.(*copilot.AssistantMessageData); ok { fmt.Println(data.Content) } } } ```

Java

```java import com.azure.core.credential.TokenRequestContext; import com.azure.identity.AzureIdentityEnvVars; import com.azure.identity.DefaultAzureCredentialBuilder; import com.github.copilot.CopilotClient; import com.github.copilot.generated.AssistantMessageEvent; import com.github.copilot.rpc.BearerTokenProvider; import com.github.copilot.rpc.MessageOptions; import com.github.copilot.rpc.ProviderConfig; import com.github.copilot.rpc.SessionConfig; public class ManagedIdentityExample { public static void main(String[] args) throws Exception { var credential = new DefaultAzureCredentialBuilder() .requireEnvVars(AzureIdentityEnvVars.AZURE_TOKEN_CREDENTIALS) .build(); BearerTokenProvider tokenProvider = providerArgs -> credential .getToken(new TokenRequestContext().addScopes("https://ai.azure.com/.default")) .map(accessToken -> accessToken.getToken()) .toFuture(); String foundryUrl = System.getenv("FOUNDRY_RESOURCE_URL"); try (var client = new CopilotClient()) { client.start().get(); var session = client.createSession(new SessionConfig() .setModel("gpt-5.5") .setProvider(new ProviderConfig() .setType("openai") .setBaseUrl(foundryUrl + "/openai/v1/") .setBearerTokenProvider(tokenProvider) .setWireApi("responses"))) .get(); AssistantMessageEvent response = session .sendAndWait(new MessageOptions().setPrompt("Hello from Managed Identity!")) .get(); System.out.println(response.getData().content()); session.disconnect().get(); } } } ```

Python

```python import asyncio import os from azure.identity.aio import DefaultAzureCredential from copilot import CopilotClient from copilot.session import PermissionHandler, ProviderConfig async def main(): credential = DefaultAzureCredential(require_envvar=True) async def get_bearer_token(_args) -> str: token = await credential.get_token("https://ai.azure.com/.default") return token.token foundry_url = os.environ["FOUNDRY_RESOURCE_URL"] client = CopilotClient() await client.start() session = await client.create_session( on_permission_request=PermissionHandler.approve_all, model="gpt-5.5", provider=ProviderConfig( type="openai", base_url=f"{foundry_url.rstrip('/')}/openai/v1/", bearer_token_provider=get_bearer_token, wire_api="responses", ), ) response = await session.send_and_wait("Hello from Managed Identity!") print(response.data.content) await client.stop() await credential.close() asyncio.run(main()) ```

Rust

```rust use std::sync::Arc; use azure_core::credentials::TokenCredential; use azure_identity::{DeveloperToolsCredential, ManagedIdentityCredential}; use github_copilot_sdk::{BearerTokenError, Client, ClientOptions, MessageOptions, ProviderTokenArgs}; use github_copilot_sdk::types::{ProviderConfig, SessionConfig}; fn credential_for_environment() -> azure_core::Result> { match std::env::var("AZURE_TOKEN_CREDENTIALS").as_deref() { Ok("ManagedIdentityCredential") => Ok(ManagedIdentityCredential::new(None)?), _ => Ok(DeveloperToolsCredential::new(None)?), } } #[tokio::main] async fn main() -> Result<(), Box> { let credential = credential_for_environment()?; let foundry_url = std::env::var("FOUNDRY_RESOURCE_URL")?; let get_bearer_token = { let credential = credential.clone(); move |_args: ProviderTokenArgs| { let credential = credential.clone(); async move { let token = credential .get_token(&["https://ai.azure.com/.default"], None) .await .map_err(|err| BearerTokenError::message(err.to_string()))?; Ok(token.token.secret().to_string()) } } }; let mut provider = ProviderConfig::default(); provider.provider_type = Some("openai".to_string()); provider.base_url = format!("{}/openai/v1/", foundry_url.trim_end_matches('/')); provider.bearer_token_provider = Some(Arc::new(get_bearer_token)); provider.wire_api = Some("responses".to_string()); let mut config = SessionConfig::default(); config.model = Some("gpt-5.5".to_string()); config.provider = Some(provider); let client = Client::start(ClientOptions::default()).await?; let session = client.create_session(config).await?; session .send_and_wait(MessageOptions::new("Hello from Managed Identity!")) .await?; session.disconnect().await?; client.stop().await?; Ok(()) } ```

TypeScript

```typescript import { DefaultAzureCredential } from "@azure/identity"; import { CopilotClient } from "@github/copilot-sdk"; const credential = new DefaultAzureCredential({ requiredEnvVars: ["AZURE_TOKEN_CREDENTIALS"], }); const getBearerToken = async () => { const tokenResponse = await credential.getToken("https://ai.azure.com/.default"); return tokenResponse.token; }; const client = new CopilotClient(); const session = await client.createSession({ model: "gpt-5.5", provider: { type: "openai", baseUrl: `${process.env.FOUNDRY_RESOURCE_URL}/openai/v1/`, bearerTokenProvider: getBearerToken, wireApi: "responses", }, }); const response = await session.sendAndWait({ prompt: "Hello from Managed Identity!" }); console.log(response?.data.content); await client.stop(); ```