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)))
)))
);
```
Los resultados se almacenan en caché después de la primera llamada, al igual que el comportamiento predeterminado. El controlador reemplaza completamente la RPC de `models.list` la CLI; no ocurre ningún mecanismo de respaldo al servidor.
## Limitaciones
### Limitaciones de características
Algunas características de Copilot pueden comportarse de forma diferente con BYOK:
* **Disponibilidad del modelo** : solo están disponibles los modelos admitidos por el proveedor.
* **Limitación de tasa** - Sujeto a los límites de tasa de tu proveedor, no a los de Copilot
* **Usage tracking**: el proveedor realiza un seguimiento del uso, no GitHub Copilot
* **Solicitudes premium** - No cuentan para las cuotas de solicitudes premium de Copilot
### Limitaciones específicas del proveedor
| Provider | Limitaciones |
| -------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
| [Microsoft Foundry Local](https://foundrylocal.ai) | Solo local; la disponibilidad del modelo depende del hardware del dispositivo; no se requiere ninguna clave de API |
| Ollama | Sin clave de API; solo local; La compatibilidad del modelo varía |
| OpenAI | Sujeto a límites y cuotas de tasa de OpenAI |
## Solución de problemas
### Error "No se ha especificado el modelo"
Cuando se usa BYOK, se `model` el \*\*\*\* parámetro :
```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: "..." },
});
```
### Confusión del tipo de punto de conexión de Azure
Para los puntos de conexión de Azure OpenAI (`*.openai.azure.com`), use el tipo correcto:
```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",
}
```
Sin embargo, si la implementación de Microsoft Foundry proporciona una ruta de acceso de un punto de conexión compatible con OpenAI (por ejemplo, `/openai/v1/`), use `type: "openai"`:
```typescript
// ✅ Correct: OpenAI-compatible Microsoft Foundry endpoint
provider: {
type: "openai",
baseUrl: "https://your-resource.openai.azure.com/openai/v1/",
}
```
### Conexión rechazada (Ollama)
Asegúrese de que Ollama está en ejecución y accesible:
```bash
# Check Ollama is running
curl http://localhost:11434/v1/models
# Start Ollama if not running
ollama serve
```
### Conexión rechazada (Fundición Local)
Foundry Local usa un puerto dinámico que puede cambiar entre reinicios. Confirme el puerto activo:
```bash
# Check the service status and port
foundry service status
```
Actualiza tu `baseUrl` para que coincida con el puerto que se muestra en la salida. Si el servicio no se está ejecutando, inicie un modelo para iniciarlo:
```bash
foundry model run phi-4-mini
```
### Error de autenticación
1. Compruebe que la clave de API es correcta y no ha expirado
2. Compruebe que coincide con el `baseUrl` formato esperado del proveedor
3. Para los tokens de portador, asegúrese de que se proporciona el token completo (no solo un prefijo).
## Pasos siguientes
* [Autenticación](/es/copilot/how-tos/copilot-sdk/auth) : obtenga información sobre todos los métodos de autenticación.
* [Crea tu primera aplicación con tecnología Copilot](/es/copilot/how-tos/copilot-sdk/getting-started): compile la primera aplicación con tecnología de Copilot