Language Model Chat Provider API

Die Language Model Chat Provider API ermöglicht es Ihnen, eigene Sprachmodelle für den Chat in Visual Studio Code beizusteuern.

Wichtig

Über diese API bereitgestellte Modelle sind derzeit nur für Benutzer mit individuellen GitHub Copilot-Plänen verfügbar.

Übersicht

Die LanguageModelChatProvider-Schnittstelle folgt einer Eins-Anbieter-zu-viele-Modelle-Beziehung, die es Anbietern ermöglicht, mehrere Modelle anzubieten. Jeder Anbieter ist verantwortlich für

Das Entdecken und Vorbereiten verfügbarer Sprachmodelle
Das Behandeln von Chat-Anfragen für seine Modelle
Das Bereitstellen von Token-Zählungsfunktionalität

Sprachmodellinformationen

Jedes Sprachmodell muss Metadaten über die LanguageModelChatInformation-Schnittstelle bereitstellen. Die Methode provideLanguageModelChatInformation gibt ein Array dieser Objekte zurück, um VS Code über die verfügbaren Modelle zu informieren.

interface LanguageModelChatInformation {
  readonly id: string; // Unique identifier for the model - unique within the provider
  readonly name: string; // Human-readable name of the language model - shown in the model picker
  readonly family: string; // Model family name
  readonly version: string; // Version string
  readonly maxInputTokens: number; // Maximum number of tokens the model can accept as input
  readonly maxOutputTokens: number; // Maximum number of tokens the model is capable of producing
  readonly tooltip?: string; // Optional tooltip text when hovering the model in the UI
  readonly detail?: string; // Human-readable text that is rendered alongside the model
  readonly capabilities: {
    readonly imageInput?: boolean; // Supports image inputs
    readonly toolCalling?: boolean | number; // Supports tool calling
  };
}

Registrieren des Anbieters

Der erste Schritt besteht darin, den Anbieter in Ihrer package.json im Abschnitt contributes.languageModelChatProviders zu registrieren. Geben Sie eine eindeutige vendor-ID und einen displayName an.

{
  "contributes": {
    "languageModelChatProviders": [
      {
        "vendor": "my-provider",
        "displayName": "My Provider"
      }
    ]
  }
}

Registrieren Sie als Nächstes in Ihrer Erweiterungsaktivierungsfunktion Ihren Sprachmodell-Anbieter mit der Methode lm.registerLanguageModelChatProvider.

Stellen Sie die Anbieter-ID bereit, die Sie in der package.json verwendet haben, und eine Instanz Ihrer Anbieterklasse
```
import * as vscode from 'vscode';
import { SampleChatModelProvider } from './provider';

export function activate(_: vscode.ExtensionContext) {
  vscode.lm.registerLanguageModelChatProvider('my-provider', new SampleChatModelProvider());
}
```
Optional können Sie in Ihrer package.json einen contributes.languageModelChatProviders.managementCommand angeben, damit Benutzer den Sprachmodell-Anbieter verwalten können.

Der Wert der Eigenschaft managementCommand muss ein Befehl sein, der im Abschnitt contributes.commands Ihrer package.json definiert ist. Registrieren Sie in Ihrer Erweiterung den Befehl (vscode.commands.registerCommand) und implementieren Sie die Logik für die Verwaltung des Anbieters, wie z. B. die Konfiguration von API-Schlüsseln oder anderen Einstellungen.
```
{
  "contributes": {
    "languageModelChatProviders": [
      {
        "vendor": "my-provider",
        "displayName": "My Provider",
        "managementCommand": "my-provider.manage"
      }
    ],
    "commands": [
      {
        "command": "my-provider.manage",
        "title": "Manage My Provider"
      }
    ]
  }
}
```

Implementieren des Anbieters

Ein Sprachmodell-Anbieter muss die LanguageModelChatProvider-Schnittstelle implementieren, die drei Hauptmethoden hat

provideLanguageModelChatInformation: Gibt die Liste der verfügbaren Modelle zurück
provideLanguageModelChatResponse: Behandelt Chat-Anfragen und streamt Antworten
provideTokenCount: Implementiert die Token-Zählungsfunktionalität

Vorbereiten von Sprachmodellinformationen

Die Methode provideLanguageModelChatInformation wird von VS Code aufgerufen, um die verfügbaren Modelle zu entdecken und gibt eine Liste von LanguageModelChatInformation-Objekten zurück.

Verwenden Sie den Parameter options.silent, um zu steuern, ob der Benutzer nach Anmeldeinformationen oder zusätzlicher Konfiguration gefragt werden soll

async provideLanguageModelChatInformation(
    options: { silent: boolean },
    token: CancellationToken
): Promise<LanguageModelChatInformation[]> {
    if (options.silent) {
        return []; // Don't prompt user in silent mode
    } else {
        await this.promptForApiKey(); // Prompt user for credentials
    }

    // Fetch available models from your service
    const models = await this.fetchAvailableModels();

    // Map your models to LanguageModelChatInformation format
    return models.map(model => ({
        id: model.id,
        name: model.displayName,
        family: model.family,
        version: '1.0.0',
        maxInputTokens: model.contextWindow - model.maxOutput,
        maxOutputTokens: model.maxOutput,
        capabilities: {
            imageInput: model.supportsImages,
            toolCalling: model.supportsTools
        }
    }));
}

Behandeln von Chat-Anfragen

Die Methode provideLanguageModelChatResponse behandelt tatsächliche Chat-Anfragen. Der Anbieter erhält ein Array von Nachrichten im LanguageModelChatRequestMessage-Format und Sie können diese optional in das für Ihre Sprachmodell-API erforderliche Format konvertieren (siehe Nachrichtenformat und Konvertierung).

Verwenden Sie den Parameter progress, um Antwortteile zu streamen. Die Antwort kann Textteile, Tool-Aufrufe und Tool-Ergebnisse enthalten (siehe Antwortteile).

async provideLanguageModelChatResponse(
    model: LanguageModelChatInformation,
    messages: readonly LanguageModelChatRequestMessage[],
    options: ProvideLanguageModelChatResponseOptions,
    progress: Progress<LanguageModelResponsePart>,
    token: CancellationToken
): Promise<void> {

    // TODO: Implement message conversion, processing, and response streaming

    // Optionally, differentiate behavior based on model ID
    if (model.id === "my-model-a") {
        progress.report(new LanguageModelTextPart("This is my A response."));
    } else {
        progress.report(new LanguageModelTextPart("Unknown model."));
    }
}

Bereitstellen der Token-Anzahl

Die Methode provideTokenCount ist für die Schätzung der Anzahl von Tokens in einer gegebenen Texteingabe verantwortlich

async provideTokenCount(
    model: LanguageModelChatInformation,
    text: string | LanguageModelChatRequestMessage,
    token: CancellationToken
): Promise<number> {
    // TODO: Implement token counting for your models

    // Example estimation for strings
    return Math.ceil(text.toString().length / 4);
}

Nachrichtenformat und Konvertierung

Ihr Anbieter erhält Nachrichten im LanguageModelChatRequestMessage-Format, die Sie normalerweise in das API-Format Ihres Dienstes konvertieren müssen. Der Nachrichteninhalt kann eine Mischung aus Textteilen, Tool-Aufrufen und Tool-Ergebnissen sein.

interface LanguageModelChatRequestMessage {
  readonly role: LanguageModelChatMessageRole;
  readonly content: ReadonlyArray<LanguageModelInputPart | unknown>;
  readonly name: string | undefined;
}

Konvertieren Sie diese Nachrichten optional entsprechend für Ihre Sprachmodell-API

private convertMessages(messages: readonly LanguageModelChatRequestMessage[]) {
    return messages.map(msg => ({
        role: msg.role === vscode.LanguageModelChatMessageRole.User ? 'user' : 'assistant',
        content: msg.content
            .filter(part => part instanceof vscode.LanguageModelTextPart)
            .map(part => (part as vscode.LanguageModelTextPart).value)
            .join('')
    }));
}

Antwortteile

Ihr Anbieter kann verschiedene Arten von Antwortteilen über den Fortschrittsrückruf über den Typ LanguageModelResponsePart melden, der einer der folgenden sein kann

LanguageModelTextPart - Textinhalt
LanguageModelToolCallPart - Tool/Funktionsaufrufe
LanguageModelToolResultPart - Tool-Ergebnisinhalt

Erste Schritte

Sie können mit einem grundlegenden Beispielprojekt loslegen.

12/10/2025