@codingame/monaco-vscode-api 37.1.0 → 37.2.0

package/vscode/src/vs/workbench/contrib/chat/common/chatDebugService.d.ts

@@ -1,253 +0,0 @@
-import { URI } from "../../../../base/common/uri.js";
-import { RawContextKey } from "../../../../platform/contextkey/common/contextkey.js";
-import { CancellationToken } from "../../../../base/common/cancellation.js";
-export declare const CHAT_DEBUG_HAS_ACTIVE_SESSION: RawContextKey<boolean>;
-export declare const CHAT_DEBUG_ACTIVE_SESSION_IS_AGENT_HOST: RawContextKey<boolean>;
-/**
- * The severity level of a chat debug log event.
- */
-export declare enum ChatDebugLogLevel {
-    Trace = 0,
-    Info = 1,
-    Warning = 2,
-    Error = 3
-}
-/**
- * The result of a hook execution.
- */
-export declare enum ChatDebugHookResult {
-    /** The hook executed successfully (exit code 0). */
-    Success = 0,
-    /** The hook returned a blocking error (exit code 2). */
-    Error = 1,
-    /** The hook returned a non-blocking warning (other non-zero exit codes). */
-    NonBlockingError = 2
-}
-/**
- * Common properties shared by all chat debug event types.
- */
-export interface IChatDebugEventCommon {
-    readonly id?: string;
-    readonly sessionResource: URI;
-    readonly created: Date;
-    readonly parentEventId?: string;
-}
-/**
- * A tool call event in the chat debug log.
- */
-export interface IChatDebugToolCallEvent extends IChatDebugEventCommon {
-    readonly kind: "toolCall";
-    readonly toolName: string;
-    readonly toolCallId?: string;
-    readonly input?: string;
-    readonly output?: string;
-    readonly result?: "success" | "error";
-    readonly durationInMillis?: number;
-}
-/**
- * A model turn event representing an LLM request/response.
- */
-export interface IChatDebugModelTurnEvent extends IChatDebugEventCommon {
-    readonly kind: "modelTurn";
-    readonly model?: string;
-    readonly requestName?: string;
-    readonly inputTokens?: number;
-    readonly outputTokens?: number;
-    readonly cachedTokens?: number;
-    readonly totalTokens?: number;
-    readonly copilotUsageNanoAiu?: number;
-    readonly durationInMillis?: number;
-}
-/**
- * A generic log event for unstructured or miscellaneous messages.
- */
-export interface IChatDebugGenericEvent extends IChatDebugEventCommon {
-    readonly kind: "generic";
-    readonly name: string;
-    readonly details?: string;
-    readonly level: ChatDebugLogLevel;
-    readonly category?: string;
-}
-/**
- * A subagent invocation event, representing a spawned sub-agent within a session.
- */
-export interface IChatDebugSubagentInvocationEvent extends IChatDebugEventCommon {
-    readonly kind: "subagentInvocation";
-    readonly agentName: string;
-    readonly description?: string;
-    readonly status?: "running" | "completed" | "failed";
-    readonly durationInMillis?: number;
-    readonly toolCallCount?: number;
-    readonly modelTurnCount?: number;
-}
-/**
- * A named section within a user message or agent response.
- */
-export interface IChatDebugMessageSection {
-    readonly name: string;
-    readonly content: string;
-}
-/**
- * A user message event, representing the full prompt sent by the user.
- */
-export interface IChatDebugUserMessageEvent extends IChatDebugEventCommon {
-    readonly kind: "userMessage";
-    readonly message: string;
-    readonly sections: readonly IChatDebugMessageSection[];
-}
-/**
- * An agent response event, representing the agent's response.
- */
-export interface IChatDebugAgentResponseEvent extends IChatDebugEventCommon {
-    readonly kind: "agentResponse";
-    readonly message: string;
-    readonly sections: readonly IChatDebugMessageSection[];
-}
-/**
- * Union of all internal chat debug event types.
- */
-export type IChatDebugEvent = IChatDebugToolCallEvent | IChatDebugModelTurnEvent | IChatDebugGenericEvent | IChatDebugSubagentInvocationEvent | IChatDebugUserMessageEvent | IChatDebugAgentResponseEvent;
-/**
- * Plain text content for a resolved debug event.
- */
-export interface IChatDebugEventTextContent {
-    readonly kind: "text";
-    readonly value: string;
-}
-/**
- * The status of a file in a file list content.
- */
-export type ChatDebugFileStatus = "loaded" | "skipped";
-/**
- * A single file entry in a file list content.
- */
-export interface IChatDebugFileEntry {
-    readonly uri: URI;
-    readonly name?: string;
-    readonly status: ChatDebugFileStatus;
-    readonly storage?: string;
-    readonly extensionId?: string;
-    readonly skipReason?: string;
-    readonly errorMessage?: string;
-    readonly duplicateOf?: URI;
-}
-/**
- * A source folder entry in a file list content.
- */
-export interface IChatDebugSourceFolderEntry {
-    readonly uri: URI;
-    readonly storage: string;
-}
-/**
- * Structured file list content for a resolved debug event.
- * Contains resolved files and skipped/failed paths for rich rendering.
- */
-export interface IChatDebugEventFileListContent {
-    readonly kind: "fileList";
-    readonly discoveryType: string;
-    readonly durationInMillis: number;
-    readonly files: readonly IChatDebugFileEntry[];
-    readonly sourceFolders?: readonly IChatDebugSourceFolderEntry[];
-}
-/**
- * Structured message content for a resolved debug event,
- * containing collapsible sections.
- */
-export interface IChatDebugEventMessageContent {
-    readonly kind: "message";
-    readonly type: "user" | "agent";
-    readonly message: string;
-    readonly sections: readonly IChatDebugMessageSection[];
-}
-/**
- * Structured tool call content for a resolved debug event.
- * Contains the tool name, status, arguments, and output for rich rendering.
- */
-export interface IChatDebugEventToolCallContent {
-    readonly kind: "toolCall";
-    readonly toolName: string;
-    readonly result?: "success" | "error";
-    readonly durationInMillis?: number;
-    readonly input?: string;
-    readonly output?: string;
-}
-/**
- * Structured model turn content for a resolved debug event.
- * Contains request metadata, token usage, and timing for rich rendering.
- */
-export interface IChatDebugEventModelTurnContent {
-    readonly kind: "modelTurn";
-    readonly requestName: string;
-    readonly model?: string;
-    readonly status?: string;
-    readonly durationInMillis?: number;
-    readonly timeToFirstTokenInMillis?: number;
-    readonly requestId?: string;
-    readonly maxInputTokens?: number;
-    readonly maxOutputTokens?: number;
-    readonly inputTokens?: number;
-    readonly outputTokens?: number;
-    readonly cachedTokens?: number;
-    readonly totalTokens?: number;
-    readonly requestOptions?: string;
-    readonly errorMessage?: string;
-    readonly sections?: readonly IChatDebugMessageSection[];
-}
-/**
- * Structured hook execution content for a resolved debug event.
- * Contains the hook type, command, input, output, and result for rich rendering.
- */
-export interface IChatDebugEventHookContent {
-    readonly kind: "hook";
-    readonly hookType: string;
-    readonly command?: string;
-    readonly result?: ChatDebugHookResult;
-    readonly durationInMillis?: number;
-    readonly input?: string;
-    readonly output?: string;
-    readonly exitCode?: number;
-    readonly errorMessage?: string;
-}
-/**
- * A single entry in the customization resolution log.
- */
-export interface IChatDebugCustomizationLogEntry {
-    readonly category: "applying" | "skipped" | "referenced" | "skill" | "custom-agent" | "hook";
-    readonly name: string;
-    readonly uri?: URI;
-    readonly reason?: string;
-}
-/**
- * Structured customization summary content for a resolved debug event.
- * Contains per-file resolution logs showing how applyTo patterns, agent
- * instructions, and referenced files were resolved by the instructions
- * context computer.
- */
-export interface IChatDebugEventCustomizationSummaryContent {
-    readonly kind: "customizationSummary";
-    /** Per-file resolution detail entries. */
-    readonly resolutionLogs: readonly IChatDebugCustomizationLogEntry[];
-    /** Total wall-clock time of the collect() call in milliseconds. */
-    readonly durationInMillis: number;
-    /** Counts by type for the summary header. */
-    readonly counts: {
-        readonly instructions: number;
-        readonly skills: number;
-        readonly agents: number;
-        readonly hooks: number;
-        readonly skipped: number;
-    };
-}
-/**
- * Union of all resolved event content types.
- */
-export type IChatDebugResolvedEventContent = IChatDebugEventTextContent | IChatDebugEventFileListContent | IChatDebugEventMessageContent | IChatDebugEventToolCallContent | IChatDebugEventModelTurnContent | IChatDebugEventHookContent | IChatDebugEventCustomizationSummaryContent;
-/**
- * Provider interface for debug events.
- */
-export interface IChatDebugLogProvider {
-    provideChatDebugLog(sessionResource: URI, token: CancellationToken): Promise<IChatDebugEvent[] | undefined>;
-    resolveChatDebugLogEvent?(eventId: string, token: CancellationToken): Promise<IChatDebugResolvedEventContent | undefined>;
-    provideChatDebugLogExport?(sessionResource: URI, token: CancellationToken): Promise<Uint8Array | undefined>;
-    resolveChatDebugLogImport?(data: Uint8Array, token: CancellationToken): Promise<URI | undefined>;
-}

package/vscode/src/vs/workbench/contrib/chat/common/chatDebugService.js

@@ -1,20 +0,0 @@
-
-import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
-
-const CHAT_DEBUG_HAS_ACTIVE_SESSION = ( new RawContextKey("chatDebug.hasActiveSession", false));
-const CHAT_DEBUG_ACTIVE_SESSION_IS_AGENT_HOST = ( new RawContextKey("chatDebug.activeSessionIsAgentHost", false));
-var ChatDebugLogLevel;
-(function(ChatDebugLogLevel) {
-    ChatDebugLogLevel[ChatDebugLogLevel["Trace"] = 0] = "Trace";
-    ChatDebugLogLevel[ChatDebugLogLevel["Info"] = 1] = "Info";
-    ChatDebugLogLevel[ChatDebugLogLevel["Warning"] = 2] = "Warning";
-    ChatDebugLogLevel[ChatDebugLogLevel["Error"] = 3] = "Error";
-})(ChatDebugLogLevel || (ChatDebugLogLevel = {}));
-var ChatDebugHookResult;
-(function(ChatDebugHookResult) {
-    ChatDebugHookResult[ChatDebugHookResult["Success"] = 0] = "Success";
-    ChatDebugHookResult[ChatDebugHookResult["Error"] = 1] = "Error";
-    ChatDebugHookResult[ChatDebugHookResult["NonBlockingError"] = 2] = "NonBlockingError";
-})(ChatDebugHookResult || (ChatDebugHookResult = {}));
-
-export { CHAT_DEBUG_ACTIVE_SESSION_IS_AGENT_HOST, CHAT_DEBUG_HAS_ACTIVE_SESSION, ChatDebugHookResult, ChatDebugLogLevel };

package/vscode/src/vs/workbench/contrib/chat/common/chatImageExtraction.d.ts

@@ -1,34 +0,0 @@
-import { VSBuffer } from "../../../../base/common/buffer.js";
-import { IMarkdownString } from "../../../../base/common/htmlContent.js";
-import { URI } from "../../../../base/common/uri.js";
-import { IChatResponseViewModel, IChatRequestViewModel } from "./model/chatViewModel.js";
-import { IChatToolInvocation, IChatToolInvocationSerialized } from "./chatService/chatService.js";
-import { type IChatRequestVariableEntry } from "./attachments/chatVariableEntries.js";
-export interface IChatExtractedImage {
-    readonly id: string;
-    readonly uri: URI;
-    readonly name: string;
-    readonly mimeType: string;
-    readonly data: VSBuffer;
-    readonly source: string;
-    readonly caption: string | IMarkdownString | undefined;
-}
-export interface IChatExtractedImageCollection {
-    readonly id: string;
-    readonly title: string;
-    readonly images: IChatExtractedImage[];
-}
-/**
- * Extract all images from a chat response's tool invocations and inline references.
- * Tool invocation images are extracted from output details and message URIs.
- * Inline reference images (file URIs) are read via the provided {@link readFile} callback.
- */
-export declare function extractImagesFromChatResponse(response: IChatResponseViewModel, readFile: (uri: URI) => Promise<VSBuffer>): Promise<IChatExtractedImageCollection>;
-export declare function extractImagesFromToolInvocationOutputDetails(toolInvocation: IChatToolInvocation | IChatToolInvocationSerialized, sessionResource: URI): IChatExtractedImage[];
-export declare function extractImagesFromToolInvocationMessages(toolInvocation: IChatToolInvocation | IChatToolInvocationSerialized, readFile: (uri: URI) => Promise<VSBuffer>): Promise<IChatExtractedImage[]>;
-export declare function coerceImageBuffer(value: unknown): Uint8Array | undefined;
-/**
- * Extract images from a chat request's variable attachments (user-attached images).
- */
-export declare function extractImagesFromChatRequest(request: IChatRequestViewModel): IChatExtractedImage[];
-export declare function extractImagesFromChatVariables(variables: readonly IChatRequestVariableEntry[]): IChatExtractedImage[];

package/vscode/src/vs/workbench/contrib/chat/common/chatImageExtraction.js

@@ -1,194 +0,0 @@
-
-import { decodeBase64, VSBuffer } from '../../../../base/common/buffer.js';
-import { getExtensionForMimeType, getMediaMime } from '../../../../base/common/mime.js';
-import { URI } from '../../../../base/common/uri.js';
-import { localize } from '../../../../nls.js';
-import { isLocation } from '../../../../editor/common/languages.js';
-import { isRequestVM } from './model/chatViewModel.js';
-import { ChatResponseResource } from './model/chatModel.js';
-import { IChatToolInvocation } from './chatService/chatService.js';
-import { isToolResultInputOutputDetails, isToolResultOutputDetails } from './tools/languageModelToolsService.js';
-import { getExplicitFileOrImageAttachmentSummary, isImageVariableEntry } from './attachments/chatVariableEntries.js';
-
-async function extractImagesFromChatResponse(response, readFile) {
-    const allImages = [];
-    for (const item of response.response.value) {
-        if (item.kind === "toolInvocation" || item.kind === "toolInvocationSerialized") {
-            const images = extractImagesFromToolInvocationOutputDetails(item, response.sessionResource);
-            allImages.push(...images);
-            const messageImages = await extractImagesFromToolInvocationMessages(item, readFile);
-            allImages.push(...messageImages);
-        } else if (item.kind === "inlineReference") {
-            const image = await extractImageFromInlineReference(item, readFile);
-            if (image) {
-                allImages.push(image);
-            }
-        }
-    }
-    const request = response.session.getItems().find(item => isRequestVM(item) && item.id === response.requestId);
-    const title = request ? request.messageText.trim() || getExplicitFileOrImageAttachmentSummary(request.variables) || ( localize(10410, "Images")) : ( localize(10410, "Images"));
-    return {
-        id: ( response.sessionResource.toString()) + "_" + response.id,
-        title,
-        images: allImages
-    };
-}
-function extractImagesFromToolInvocationOutputDetails(toolInvocation, sessionResource) {
-    const images = [];
-    const resultDetails = IChatToolInvocation.resultDetails(toolInvocation);
-    const caption = toolInvocation.pastTenseMessage ?? toolInvocation.invocationMessage;
-    const pushImage = (mimeType, data, outputIndex) => {
-        const ext = getExtensionForMimeType(mimeType);
-        const permalinkBasename = ext ? `file${ext}` : "file.bin";
-        const uri = ChatResponseResource.createUri(sessionResource, toolInvocation.toolCallId, outputIndex, permalinkBasename);
-        images.push({
-            id: `${toolInvocation.toolCallId}_${outputIndex}`,
-            uri,
-            name: ( localize(10411, "Image {0}", images.length + 1)),
-            mimeType,
-            data,
-            source: ( localize(10412, "Tool: {0}", toolInvocation.toolId)),
-            caption
-        });
-    };
-    if (isToolResultInputOutputDetails(resultDetails)) {
-        for (let i = 0; i < resultDetails.output.length; i++) {
-            const outputItem = resultDetails.output[i];
-            if (outputItem.type === "embed" && outputItem.mimeType?.startsWith("image/") && !outputItem.isText) {
-                pushImage(outputItem.mimeType, decodeBase64(outputItem.value), i);
-            }
-        }
-    } else if (isToolResultOutputDetails(resultDetails)) {
-        const output = resultDetails.output;
-        if (output.mimeType?.startsWith("image/")) {
-            const data = getImageDataFromOutputDetails(resultDetails, toolInvocation);
-            if (data) {
-                pushImage(output.mimeType, data, 0);
-            }
-        }
-    }
-    return images;
-}
-async function extractImagesFromToolInvocationMessages(toolInvocation, readFile) {
-    const message = toolInvocation.pastTenseMessage ?? toolInvocation.invocationMessage;
-    if (!message || typeof message === "string" || !message.uris || ( Object.keys(message.uris)).length === 0) {
-        return [];
-    }
-    const images = [];
-    for (const uriComponents of ( Object.values(message.uris))) {
-        const uri = URI.revive(uriComponents);
-        const mimeType = getMediaMime(uri.path);
-        if (mimeType?.startsWith("image/")) {
-            let data;
-            try {
-                data = await readFile(uri);
-            } catch {
-                continue;
-            }
-            const name = uri.path.split("/").pop() ?? "image";
-            images.push({
-                id: ( uri.toString()),
-                uri,
-                name,
-                mimeType,
-                data,
-                source: ( localize(10412, "Tool: {0}", toolInvocation.toolId)),
-                caption: message
-            });
-        }
-    }
-    return images;
-}
-function getImageDataFromOutputDetails(resultDetails, toolInvocation) {
-    if (toolInvocation.kind === "toolInvocationSerialized") {
-        const serializedDetails = resultDetails;
-        if (serializedDetails.output.base64Data) {
-            return decodeBase64(serializedDetails.output.base64Data);
-        }
-        return undefined;
-    } else {
-        return resultDetails.output.value;
-    }
-}
-async function extractImageFromInlineReference(part, readFile) {
-    const ref = part.inlineReference;
-    const refUri = URI.isUri(ref) ? ref : isLocation(ref) ? ref.uri : ref.location.uri;
-    const mime = getMediaMime(refUri.path);
-    if (!mime?.startsWith("image/")) {
-        return undefined;
-    }
-    let data;
-    try {
-        data = await readFile(refUri);
-    } catch {
-        return undefined;
-    }
-    const name = part.name ?? refUri.path.split("/").pop() ?? "image";
-    return {
-        id: ( refUri.toString()),
-        uri: refUri,
-        name,
-        mimeType: mime,
-        data,
-        source: ( localize(10413, "File")),
-        caption: undefined
-    };
-}
-function coerceImageBuffer(value) {
-    if (value instanceof Uint8Array) {
-        return value;
-    }
-    if (value instanceof ArrayBuffer) {
-        return ( new Uint8Array(value));
-    }
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return undefined;
-    }
-    const record = value;
-    const keys = ( Object.keys(record)).sort((a, b) => Number(a) - Number(b));
-    if (keys.length === 0) {
-        return undefined;
-    }
-    const result = ( new Uint8Array(keys.length));
-    for (let index = 0; index < keys.length; index++) {
-        const byte = record[keys[index]];
-        if (keys[index] !== String(index) || typeof byte !== "number" || !Number.isInteger(byte) || byte < 0 || byte > 255) {
-            return undefined;
-        }
-        result[index] = byte;
-    }
-    return result;
-}
-function extractImagesFromChatRequest(request) {
-    return extractImagesFromChatVariables(request.variables);
-}
-function extractImagesFromChatVariables(variables) {
-    const images = [];
-    for (const variable of variables) {
-        if (!isImageVariableEntry(variable)) {
-            continue;
-        }
-        const buffer = coerceImageBuffer(variable.value);
-        if (!buffer) {
-            continue;
-        }
-        const mimeType = variable.mimeType ?? getMediaMime(variable.name) ?? "image/png";
-        const uri = variable.references?.[0]?.reference;
-        const imageUri = URI.isUri(uri) ? uri : ( URI.from({
-            scheme: "data",
-            path: `${variable.id}/${encodeURIComponent(variable.name)}`
-        }));
-        images.push({
-            id: ( imageUri.toString()),
-            uri: imageUri,
-            name: variable.name,
-            mimeType,
-            data: VSBuffer.wrap(buffer),
-            source: ( localize(10414, "Attachment")),
-            caption: undefined
-        });
-    }
-    return images;
-}
-
-export { coerceImageBuffer, extractImagesFromChatRequest, extractImagesFromChatResponse, extractImagesFromChatVariables, extractImagesFromToolInvocationMessages, extractImagesFromToolInvocationOutputDetails };

package/vscode/src/vs/workbench/contrib/chat/common/chatSelectedModel.d.ts

@@ -1,87 +0,0 @@
-import { IContextKeyService } from "../../../../platform/contextkey/common/contextkey.service.js";
-import { StorageScope, StorageTarget } from "../../../../platform/storage/common/storage.js";
-import { IStorageService } from "../../../../platform/storage/common/storage.service.js";
-import { ILanguageModelChatMetadata } from "./languageModels.js";
-import { ILanguageModelsService } from "./languageModels.service.js";
-/**
- * Storage key prefix for persisted model selections.
- * Full key format: `chat.currentLanguageModel.{location}[.{modelTarget}]`
- */
-export declare const SELECTED_MODEL_STORAGE_KEY_PREFIX = "chat.currentLanguageModel.";
-export declare const SELECTED_MODEL_STORAGE_SCOPE = StorageScope.PROFILE;
-export declare const SELECTED_MODEL_STORAGE_TARGET = StorageTarget.USER;
-/**
- * Builds the storage key used to persist the selected language model for a
- * given chat location and optional model target.
- *
- * Shared by model-selection surfaces so they can read and write the explicit
- * remembered preference without depending on widget internals.
- */
-export declare function getSelectedModelStorageKey(location: string, modelTarget?: string): string;
-export declare function storeSelectedModel(storageService: IStorageService, location: string, modelTarget: string | undefined, identifier: string): void;
-/** Reads the selected model and lazily migrates the previous application-scoped value. */
-export declare function getStoredSelectedModel(storageService: IStorageService, location: string, modelTarget?: string): string | undefined;
-/**
- * Resolves the currently selected chat model identifier using a two-step
- * strategy:
- *
- * 1. Read the `chatModelId` context key (set when a chat widget is active).
- * 2. Fall back to the persisted explicit model preference.
- *
- * Returns the raw model identifier string (may include a vendor prefix like
- * `"copilot/gpt-4.1"` from storage, or a short id like `"gpt-4.1"` from
- * the context key), or `undefined` if no selection is available.
- */
-export declare function getSelectedModelIdentifier(contextKeyService: IContextKeyService, storageService: IStorageService): string | undefined;
-/**
- * Reads the persisted, fully-qualified model identifier written by a model
- * selection surface (e.g. `"copilot/gpt-4.1"` or `"customendpoint/ANT/gpt-4.1"`).
- *
- * Unlike the `chatModelId` context key (which holds only the short, lower-cased
- * model id), the persisted identifier carries the vendor and therefore
- * disambiguates the same model served via BYOK vs CAPI. Returns `undefined`
- * when no selection has been persisted.
- */
-export declare function getPersistedSelectedModelIdentifier(contextKeyService: IContextKeyService, storageService: IStorageService): string | undefined;
-/**
- * Resolves the registered metadata of the currently selected chat model.
- *
- * The selected identifier may be a fully-qualified id (e.g. `"copilot/gpt-4.1"`
- * from persisted storage) or a short, lower-cased model id (e.g. `"gpt-4.1"`
- * from the `chatModelId` context key, which is set to `metadata.id`). The short
- * id cannot disambiguate the same model served via BYOK vs CAPI, so when a
- * direct registry lookup fails we fall back to the persisted, fully-qualified
- * identifier (which carries the vendor) rather than matching on the short id.
- *
- * Returns `undefined` when no model is selected or the selection cannot be
- * resolved to a registered model (e.g. the provider has not been activated
- * yet); callers that only need the vendor can fall back to
- * {@link getSelectedModelVendor}.
- */
-export declare function getSelectedModelMetadata(contextKeyService: IContextKeyService, storageService: IStorageService, languageModelsService: ILanguageModelsService): ILanguageModelChatMetadata | undefined;
-/**
- * Resolves the vendor of the currently selected chat model.
- *
- * Tries the language model registry first (authoritative when models are
- * registered), then falls back to extracting the vendor prefix from the
- * persisted model identifier (e.g. `"copilot/gpt-4.1"` → `"copilot"`).
- *
- * Returns `undefined` if no model selection is available.
- */
-export declare function getSelectedModelVendor(contextKeyService: IContextKeyService, storageService: IStorageService, languageModelsService: ILanguageModelsService): string | undefined;
-/**
- * Returns whether the given model is "bring your own key", i.e. served with the user's own
- * credentials. Agent-host copies carry `byokModelIdentifier` instead of setting `isBYOK`.
- */
-export declare function isByokModel(metadata: ILanguageModelChatMetadata): boolean;
-/**
- * Returns whether the currently selected chat model is a Copilot model
- * (i.e. not BYOK).
- *
- * When the selection resolves to registered metadata this is the inverse of
- * {@link isByokModel}, so agent-host (CAPI-backed) models count as Copilot.
- * When no model is selected yet (widget not initialized) this returns `true`
- * so quota-style surfaces treat the unknown case as Copilot. As a last
- * resort, an unregistered selection is classified by its vendor prefix.
- */
-export declare function isSelectedModelCopilot(contextKeyService: IContextKeyService, storageService: IStorageService, languageModelsService: ILanguageModelsService): boolean;

package/vscode/src/vs/workbench/contrib/chat/common/chatSelectedModel.js

@@ -1,69 +0,0 @@
-
-import { StorageScope, StorageTarget } from '../../../../platform/storage/common/storage.js';
-import { ChatContextKeys } from './actions/chatContextKeys.js';
-import './languageModels.js';
-
-const SELECTED_MODEL_STORAGE_KEY_PREFIX = 'chat.currentLanguageModel.';
-const SELECTED_MODEL_STORAGE_SCOPE = StorageScope.PROFILE;
-const SELECTED_MODEL_STORAGE_TARGET = StorageTarget.USER;
-function getSelectedModelStorageKey(location, modelTarget) {
-    if (modelTarget) {
-        return `${SELECTED_MODEL_STORAGE_KEY_PREFIX}${location}.${modelTarget}`;
-    }
-    return `${SELECTED_MODEL_STORAGE_KEY_PREFIX}${location}`;
-}
-function storeSelectedModel(storageService, location, modelTarget, identifier) {
-    storageService.store(getSelectedModelStorageKey(location, modelTarget), identifier, SELECTED_MODEL_STORAGE_SCOPE, SELECTED_MODEL_STORAGE_TARGET);
-}
-function getStoredSelectedModel(storageService, location, modelTarget) {
-    const key = getSelectedModelStorageKey(location, modelTarget);
-    const isDefaultKey = `${key}.isDefault`;
-    const identifier = storageService.get(key, SELECTED_MODEL_STORAGE_SCOPE);
-    if (identifier) {
-        const wasAutomaticDefault = storageService.getBoolean(isDefaultKey, SELECTED_MODEL_STORAGE_SCOPE);
-        storageService.remove(isDefaultKey, SELECTED_MODEL_STORAGE_SCOPE);
-        if (wasAutomaticDefault) {
-            storageService.remove(key, SELECTED_MODEL_STORAGE_SCOPE);
-            return undefined;
-        }
-        return identifier;
-    }
-    const legacyIdentifier = storageService.get(key, StorageScope.APPLICATION);
-    if (!legacyIdentifier) {
-        return undefined;
-    }
-    const wasAutomaticDefault = storageService.getBoolean(isDefaultKey, StorageScope.APPLICATION, true);
-    storageService.remove(key, StorageScope.APPLICATION);
-    storageService.remove(isDefaultKey, StorageScope.APPLICATION);
-    if (wasAutomaticDefault) {
-        return undefined;
-    }
-    storeSelectedModel(storageService, location, modelTarget, legacyIdentifier);
-    return legacyIdentifier;
-}
-function getSelectedModelIdentifier(contextKeyService, storageService) {
-    const contextKeyModelId = contextKeyService.getContextKeyValue(ChatContextKeys.chatModelId.key);
-    if (contextKeyModelId) {
-        return contextKeyModelId;
-    }
-    return getPersistedSelectedModelIdentifier(contextKeyService, storageService);
-}
-function getPersistedSelectedModelIdentifier(contextKeyService, storageService) {
-    const location = contextKeyService.getContextKeyValue(ChatContextKeys.location.key) ?? 'panel';
-    const sessionType = contextKeyService.getContextKeyValue(ChatContextKeys.chatSessionType.key) ?? '';
-    const candidateKeys = sessionType
-        ? [sessionType, undefined]
-        : [undefined];
-    for (const modelTarget of candidateKeys) {
-        const persisted = getStoredSelectedModel(storageService, location, modelTarget);
-        if (persisted) {
-            return persisted;
-        }
-    }
-    return undefined;
-}
-function isByokModel(metadata) {
-    return metadata.isBYOK === true || metadata.byokModelIdentifier !== undefined;
-}
-
-export { SELECTED_MODEL_STORAGE_KEY_PREFIX, SELECTED_MODEL_STORAGE_SCOPE, SELECTED_MODEL_STORAGE_TARGET, getPersistedSelectedModelIdentifier, getSelectedModelIdentifier, getSelectedModelStorageKey, getStoredSelectedModel, isByokModel, storeSelectedModel };