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)))
)))
);
```
Les résultats sont mis en cache après le premier appel, tout comme le comportement par défaut. Le gestionnaire remplace complètement le RPC de l’interface en ligne de commande (CLI), sans recours au serveur.
## Limitations
### Limitations des fonctionnalités
Certaines fonctionnalités Copilot peuvent se comporter différemment avec BYOK :
* **Disponibilité** des modèles - Seuls les modèles pris en charge par votre fournisseur sont disponibles
* **Limitation du taux de requêtes** - Soumis aux limites de taux de requêtes de votre fournisseur, et non à celles de Copilot
* **Usage tracking** : l’utilisation est suivie par votre fournisseur, et non GitHub Copilot
* **Requêtes Premium** - Ne sont pas décomptées des quotas de requêtes Premium de Copilot
### Limitations spécifiques au fournisseur
| Provider | Limitations |
| -------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
| [Microsoft Foundry Local](https://foundrylocal.ai) | Local uniquement ; la disponibilité du modèle dépend du matériel de l’appareil ; aucune clé API requise |
| Ollama | Aucune clé API ; local uniquement ; La prise en charge des modèles varie |
| OpenAI | Soumis aux limitations de débit et aux quotas d’OpenAI |
## Résolution des problèmes
### Erreur « Modèle non spécifié »
Lorsque vous utilisez BYOK, le `model` paramètre est **requis** :
```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: "..." },
});
```
### Confusion du type de point de terminaison Azure
Pour Azure points de terminaison OpenAI (`*.openai.azure.com`), utilisez le type correct :
```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",
}
```
Toutefois, si votre déploiement Microsoft Foundry fournit un chemin de point de terminaison compatible OpenAI (par exemple, `/openai/v1/`), utilisez `type: "openai"`:
```typescript
// ✅ Correct: OpenAI-compatible Microsoft Foundry endpoint
provider: {
type: "openai",
baseUrl: "https://your-resource.openai.azure.com/openai/v1/",
}
```
### Connexion refusée (Ollama)
Vérifiez que Ollama est en cours d’exécution et accessible :
```bash
# Check Ollama is running
curl http://localhost:11434/v1/models
# Start Ollama if not running
ollama serve
```
### Connexion refusée (Foundry Local)
Foundry Local utilise un port dynamique qui peut changer entre les redémarrages. Confirmez le port actif :
```bash
# Check the service status and port
foundry service status
```
Mettez à jour votre `baseUrl` pour qu’il corresponde au port affiché dans le résultat. Si le service n’est pas en cours d’exécution, démarrez un modèle pour le lancer :
```bash
foundry model run phi-4-mini
```
### Échec de l’authentification
1. Vérifiez que votre clé API est correcte et non expirée
2. Vérifiez que le `baseUrl` correspond au format attendu par votre fournisseur
3. Pour les jetons de porteur, assurez-vous que le jeton complet est fourni (et non pas seulement un préfixe)
## Étapes suivantes
* [Authentification](/fr/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/auth) - En savoir plus sur toutes les méthodes d’authentification
* [Créez votre première application avec Copilot](/fr/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/getting-started) - Créez votre première application basée sur Copilot