TypeScript
```typescript
import { CopilotClient } from "@github/copilot-sdk";
import type { ModelInfo } from "@github/copilot-sdk";
const client = new CopilotClient({
onListModels: () => [
{
id: "my-custom-model",
name: "My Custom Model",
capabilities: {
supports: { vision: false, reasoningEffort: false },
limits: { max_context_window_tokens: 128000 },
},
},
],
});
```
Python
```python
from copilot import CopilotClient
from copilot.client import ModelInfo, ModelCapabilities, ModelSupports, ModelLimits
client = CopilotClient(
on_list_models=lambda: [
ModelInfo(
id="my-custom-model",
name="My Custom Model",
capabilities=ModelCapabilities(
supports=ModelSupports(vision=False, reasoning_effort=False),
limits=ModelLimits(max_context_window_tokens=128000),
),
)
],
)
```
Go
```golang
package main
import (
"context"
copilot "github.com/github/copilot-sdk/go"
)
func main() {
client := copilot.NewClient(&copilot.ClientOptions{
OnListModels: func(ctx context.Context) ([]copilot.ModelInfo, error) {
return []copilot.ModelInfo{
{
ID: "my-custom-model",
Name: "My Custom Model",
Capabilities: copilot.ModelCapabilities{
Supports: copilot.ModelSupports{Vision: false, ReasoningEffort: false},
Limits: copilot.ModelLimits{MaxContextWindowTokens: copilot.Int(128000)},
},
},
}, nil
},
})
_ = client
}
```
.NET
```csharp
using GitHub.Copilot;
var client = new CopilotClient(new CopilotClientOptions
{
OnListModels = (ct) => Task.FromResult
>(new List
{
new()
{
Id = "my-custom-model",
Name = "My Custom Model",
Capabilities = new ModelCapabilities
{
Supports = new ModelSupports { Vision = false, ReasoningEffort = false },
Limits = new ModelLimits { MaxContextWindowTokens = 128000 }
}
}
})
});
```
Java
```java
import com.github.copilot.CopilotClient;
import com.github.copilot.rpc.*;
import java.util.List;
import java.util.concurrent.CompletableFuture;
var client = new CopilotClient(new CopilotClientOptions()
.setOnListModels(() -> CompletableFuture.completedFuture(List.of(
new ModelInfo()
.setId("my-custom-model")
.setName("My Custom Model")
.setCapabilities(new ModelCapabilities()
.setSupports(new ModelSupports().setVision(false).setReasoningEffort(false))
.setLimits(new ModelLimits().setMaxContextWindowTokens(128000)))
)))
);
```
Results are cached after the first call, just like the default behavior. The handler completely replaces the CLI's `models.list` RPC—no fallback to the server occurs.
## Limitations
### Feature limitations
Some Copilot features may behave differently with BYOK:
* **Model availability** - Only models supported by your provider are available
* **Rate limiting** - Subject to your provider's rate limits, not Copilot's
* **Usage tracking** - Usage is tracked by your provider, not GitHub Copilot
* **Premium requests** - Do not count against Copilot premium request quotas
### Provider-specific limitations
| Provider | Limitations |
| -------------------------------------------------- | ------------------------------------------------------------------------------ |
| [Microsoft Foundry Local](https://foundrylocal.ai) | Local only; model availability depends on device hardware; no API key required |
| Ollama | No API key; local only; model support varies |
| OpenAI | Subject to OpenAI rate limits and quotas |
## Troubleshooting
### "Model not specified" error
When using BYOK, the `model` parameter is **required**:
```typescript
// ❌ Error: Model required with custom provider
const session = await client.createSession({
provider: { type: "openai", baseUrl: "..." },
});
// ✅ Correct: Model specified
const session = await client.createSession({
model: "gpt-4", // Required!
provider: { type: "openai", baseUrl: "..." },
});
```
### Azure endpoint type confusion
For Azure OpenAI endpoints (`*.openai.azure.com`), use the correct type:
```typescript
// ❌ Wrong: Using "openai" type with native Azure endpoint
provider: {
type: "openai", // This won't work correctly
baseUrl: "https://my-resource.openai.azure.com",
}
// ✅ Correct: Using "azure" type
provider: {
type: "azure",
baseUrl: "https://my-resource.openai.azure.com",
}
```
However, if your Microsoft Foundry deployment provides an OpenAI-compatible endpoint path (for example, `/openai/v1/`), use `type: "openai"`:
```typescript
// ✅ Correct: OpenAI-compatible Microsoft Foundry endpoint
provider: {
type: "openai",
baseUrl: "https://your-resource.openai.azure.com/openai/v1/",
}
```
### Connection refused (Ollama)
Ensure Ollama is running and accessible:
```bash
# Check Ollama is running
curl http://localhost:11434/v1/models
# Start Ollama if not running
ollama serve
```
### Connection refused (Foundry Local)
Foundry Local uses a dynamic port that may change between restarts. Confirm the active port:
```bash
# Check the service status and port
foundry service status
```
Update your `baseUrl` to match the port shown in the output. If the service is not running, start a model to launch it:
```bash
foundry model run phi-4-mini
```
### Authentication failed
1. Verify your API key is correct and not expired
2. Check the `baseUrl` matches your provider's expected format
3. For bearer tokens, ensure the full token is provided (not just a prefix)
## Next steps
* [Authentication](/en/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/auth) - Learn about all authentication methods
* [Build your first Copilot-powered app](/en/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/getting-started) - Build your first Copilot-powered app