@vscode/chat-lib 0.0.1 → 0.0.2

package/src/_internal/platform/networking/common/networking.ts

@@ -1,442 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { RequestMetadata } from '@vscode/copilot-api';
-import { Raw } from '@vscode/prompt-tsx';
-import type { CancellationToken } from 'vscode';
-import { createServiceIdentifier } from '../../../util/common/services';
-import { ITokenizer, TokenizerType } from '../../../util/common/tokenizer';
-import { AsyncIterableObject } from '../../../util/vs/base/common/async';
-import { CancellationError } from '../../../util/vs/base/common/errors';
-import { Source } from '../../chat/common/chatMLFetcher';
-import type { ChatLocation, ChatResponse } from '../../chat/common/commonTypes';
-import { ICAPIClientService } from '../../endpoint/common/capiClient';
-import { IDomainService } from '../../endpoint/common/domainService';
-import { IEnvService } from '../../env/common/envService';
-import { ILogService } from '../../log/common/logService';
-import { ITelemetryService, TelemetryProperties } from '../../telemetry/common/telemetry';
-import { TelemetryData } from '../../telemetry/common/telemetryData';
-import { FinishedCallback, OpenAiFunctionTool, OpenAiResponsesFunctionTool, OptionalChatRequestParams } from './fetch';
-import { FetchOptions, IAbortController, IFetcherService, Response } from './fetcherService';
-import { ChatCompletion, RawMessageConversionCallback, rawMessageToCAPI } from './openai';
-
-/**
- * Encapsulates all the functionality related to making GET/POST requests using
- * different libraries (and in the future, different environments like web vs
- * node).
- */
-export interface IFetcher {
-	getUserAgentLibrary(): string;
-	fetch(url: string, options: FetchOptions): Promise<Response>;
-	disconnectAll(): Promise<unknown>;
-	makeAbortController(): IAbortController;
-	isAbortError(e: any): boolean;
-	isInternetDisconnectedError(e: any): boolean;
-	isFetcherError(err: any): boolean;
-	getUserMessageForFetcherError(err: any): string;
-}
-
-export const userAgentLibraryHeader = 'X-VSCode-User-Agent-Library-Version';
-
-export type ReqHeaders = { [key: string]: string };
-/**
- * The HeaderContributor provides the interface which allows implmentors
- * to decorate a request's `headers` object with additional key / value pairs.
- */
-export interface HeaderContributor {
-	contributeHeaderValues(headers: ReqHeaders): void;
-}
-
-// The maximum time to wait for a request to complete.
-const requestTimeoutMs = 30 * 1000; // 30 seconds
-
-
-/**
- * Rough shape of an endpoint body. A superset of the parameters of any request,
- * but provided to at least have rough typings.
- */
-export interface IEndpointBody {
-	/** General or completions: */
-	tools?: (OpenAiFunctionTool | OpenAiResponsesFunctionTool)[];
-	model?: string;
-	previous_response_id?: string;
-	max_tokens?: number;
-	max_output_tokens?: number;
-	max_completion_tokens?: number;
-	temperature?: number;
-	top_p?: number;
-	stream?: boolean;
-	messages?: any[];
-	n?: number;
-	reasoning?: { effort?: string; summary?: string };
-	tool_choice?: OptionalChatRequestParams['tool_choice'] | { type: 'function'; name: string };
-	top_logprobs?: number;
-	intent?: boolean;
-	intent_threshold?: number;
-	state?: 'enabled';
-	snippy?: { enabled: boolean };
-	stream_options?: { include_usage?: boolean };
-	prompt?: string;
-	/** Embeddings endpoints only: */
-	dimensions?: number;
-	embed?: boolean;
-	/** Chunking endpoints: */
-	qos?: any;
-	content?: string;
-	path?: string;
-	local_hashes?: string[];
-	language_id?: number;
-	/** docs search */
-	query?: string;
-	scopingQuery?: string;
-	limit?: number;
-	similarity?: number;
-	/** Code search: */
-	scoping_query?: string;
-
-	/** Responses API: */
-	input?: readonly any[];
-	truncation?: 'auto' | 'disabled';
-	include?: ['reasoning.encrypted_content'];
-	store?: boolean;
-}
-
-export interface IEndpoint {
-	readonly urlOrRequestMetadata: string | RequestMetadata;
-	getExtraHeaders?(): Record<string, string>;
-	interceptBody?(body: IEndpointBody | undefined): void;
-	acquireTokenizer(): ITokenizer;
-	readonly modelMaxPromptTokens: number;
-	readonly name: string;
-	readonly version: string;
-	readonly family: string;
-	readonly tokenizer: TokenizerType;
-}
-
-export function stringifyUrlOrRequestMetadata(urlOrRequestMetadata: string | RequestMetadata): string {
-	if (typeof urlOrRequestMetadata === 'string') {
-		return urlOrRequestMetadata;
-	}
-	return JSON.stringify(urlOrRequestMetadata);
-}
-
-export interface IMakeChatRequestOptions {
-	/** The debug name for this request */
-	debugName: string;
-	/** The array of chat messages to send */
-	messages: Raw.ChatMessage[];
-	// todo
-	ignoreStatefulMarker?: boolean;
-	/** Streaming callback for each response part. */
-	finishedCb: FinishedCallback | undefined;
-	/** Location where the chat message is being sent. */
-	location: ChatLocation;
-	/** Optional source of the chat request */
-	source?: Source;
-	/** Additional request options */
-	requestOptions?: Omit<OptionalChatRequestParams, 'n'>;
-	/** Indicates if the request was user-initiated */
-	userInitiatedRequest?: boolean;
-	/** (CAPI-only) Optional telemetry properties for analytics */
-	telemetryProperties?: TelemetryProperties;
-	/** Whether this request is retrying a filtered response */
-	isFilterRetry?: boolean;
-}
-
-export interface ICreateEndpointBodyOptions extends IMakeChatRequestOptions {
-	requestId: string;
-	postOptions: OptionalChatRequestParams;
-}
-
-export interface IChatEndpoint extends IEndpoint {
-	readonly maxOutputTokens: number;
-	/** The model ID- this may change and will be `copilot-base` for the base model. Use `family` to switch behavior based on model type. */
-	readonly model: string;
-	readonly apiType?: string;
-	readonly supportsToolCalls: boolean;
-	readonly supportsVision: boolean;
-	readonly supportsPrediction: boolean;
-	readonly showInModelPicker: boolean;
-	readonly isPremium?: boolean;
-	readonly multiplier?: number;
-	readonly restrictedToSkus?: string[];
-	readonly isDefault: boolean;
-	readonly isFallback: boolean;
-	readonly policy: 'enabled' | { terms: string };
-	/**
-	 * Handles processing of responses from a chat endpoint. Each endpoint can have different response formats.
-	 * @param telemetryService The telemetry service
-	 * @param logService The log service
-	 * @param response The response from the chat endpoint
-	 * @param expectedNumChoices The expected number of choices in the response
-	 * @param finishCallback A finish callback to indicate when the response should be complete
-	 * @param telemetryData GH telemetry data from the originating request, will be extended with request information
-	 * @param cancellationToken A cancellation tokenf for cancelling the request
-	 * @returns An async iterable object of chat completions
-	 */
-	processResponseFromChatEndpoint(
-		telemetryService: ITelemetryService,
-		logService: ILogService,
-		response: Response,
-		expectedNumChoices: number,
-		finishCallback: FinishedCallback,
-		telemetryData: TelemetryData,
-		cancellationToken?: CancellationToken
-	): Promise<AsyncIterableObject<ChatCompletion>>;
-
-	/**
-	 * Accepts the chat policy for the given endpoint, enabling its usage.
-	 * @returns A promise that resolves to true if the chat policy was accepted, false otherwise.
-	 */
-	acceptChatPolicy(): Promise<boolean>;
-
-	/**
-	 * Flights a request from the chat endpoint returning a chat response.
-	 * Most of the time this is ChatMLFetcher#fetchOne, but it can be overridden for special cases.
-	 * TODO @lramos15 - Support multiple completions in the future, we don't use this at the moment.
-	 *
-	 * @param userInitiatedRequest Is only applicable to CAPI requests
-	 * @param telemetryProperties An object containing various properties for telemetry, e.g., can contain a field `requestId` that sets the header request ID
-	 */
-	makeChatRequest(
-		debugName: string,
-		messages: Raw.ChatMessage[],
-		finishedCb: FinishedCallback | undefined,
-		token: CancellationToken,
-		location: ChatLocation,
-		source?: Source,
-		requestOptions?: Omit<OptionalChatRequestParams, 'n'>,
-		userInitiatedRequest?: boolean,
-		telemetryProperties?: TelemetryProperties,
-	): Promise<ChatResponse>;
-
-	/**
-	 * Flights a request from the chat endpoint returning a chat response.
-	 * Most of the time this is ChatMLFetcher#fetchOne, but it can be overridden for special cases.
-	 */
-	makeChatRequest2(options: IMakeChatRequestOptions, token: CancellationToken): Promise<ChatResponse>;
-
-	/**
-	 * Creates the request body to be sent to the endpoint based on the request.
-	 */
-	createRequestBody(options: ICreateEndpointBodyOptions): IEndpointBody;
-
-	cloneWithTokenOverride(modelMaxPromptTokens: number): IChatEndpoint;
-}
-
-/** Function to create a standard request body for CAPI completions */
-export function createCapiRequestBody(options: ICreateEndpointBodyOptions, model: string, callback?: RawMessageConversionCallback) {
-	// FIXME@ulugbekna: need to investigate why language configs have such stop words, eg
-	// python has `\ndef` and `\nclass` which must be stop words for ghost text
-	// const stops = getLanguageConfig<string[]>(accessor, ConfigKey.Stops);
-
-	const request: IEndpointBody = {
-		messages: rawMessageToCAPI(options.messages, callback),
-		model,
-		// stop: stops,
-	};
-
-	if (options.postOptions) {
-		Object.assign(request, options.postOptions);
-	}
-
-	return request;
-}
-
-function networkRequest(
-	fetcher: IFetcher,
-	envService: IEnvService,
-	telemetryService: ITelemetryService,
-	domainService: IDomainService,
-	capiClientService: ICAPIClientService,
-	requestType: 'GET' | 'POST',
-	endpointOrUrl: IEndpoint | string | RequestMetadata,
-	secretKey: string,
-	hmac: string | undefined,
-	intent: string,
-	requestId: string,
-	body?: IEndpointBody,
-	additionalHeaders?: Record<string, string>,
-	cancelToken?: CancellationToken
-): Promise<Response> {
-	// TODO @lramos15 Eventually don't even construct this fake endpoint object.
-	const endpoint = typeof endpointOrUrl === 'string' || 'type' in endpointOrUrl ? {
-		modelMaxPromptTokens: 0,
-		urlOrRequestMetadata: endpointOrUrl,
-		family: '',
-		tokenizer: TokenizerType.O200K,
-		acquireTokenizer: () => {
-			throw new Error('Method not implemented.');
-		},
-		name: '',
-		version: '',
-	} satisfies IEndpoint : endpointOrUrl;
-	const headers: ReqHeaders = {
-		Authorization: `Bearer ${secretKey}`,
-		'X-Request-Id': requestId,
-		'X-Interaction-Type': intent,
-		'OpenAI-Intent': intent, // Tells CAPI who flighted this request. Helps find buggy features
-		'X-GitHub-Api-Version': '2025-05-01',
-		...additionalHeaders,
-		...(endpoint.getExtraHeaders ? endpoint.getExtraHeaders() : {}),
-	};
-
-	if (endpoint.interceptBody) {
-		endpoint.interceptBody(body);
-	}
-
-	const request: FetchOptions = {
-		method: requestType,
-		headers: headers,
-		json: body,
-		timeout: requestTimeoutMs,
-	};
-
-	if (cancelToken) {
-		const abort = fetcher.makeAbortController();
-		cancelToken.onCancellationRequested(() => {
-			// abort the request when the token is canceled
-			telemetryService.sendGHTelemetryEvent('networking.cancelRequest', {
-				headerRequestId: requestId,
-			});
-			abort.abort();
-		});
-		// pass the controller abort signal to the request
-		request.signal = abort.signal;
-	}
-	if (typeof endpoint.urlOrRequestMetadata === 'string') {
-		const requestPromise = fetcher.fetch(endpoint.urlOrRequestMetadata, request).catch(reason => {
-			if (canRetryOnceNetworkError(reason)) {
-				// disconnect and retry the request once if the connection was reset
-				telemetryService.sendGHTelemetryEvent('networking.disconnectAll');
-				return fetcher.disconnectAll().then(() => {
-					return fetcher.fetch(endpoint.urlOrRequestMetadata as string, request);
-				});
-			} else if (fetcher.isAbortError(reason)) {
-				throw new CancellationError();
-			} else {
-				throw reason;
-			}
-		});
-		return requestPromise;
-	} else {
-		return capiClientService.makeRequest(request, endpoint.urlOrRequestMetadata as RequestMetadata);
-	}
-}
-
-export function canRetryOnceNetworkError(reason: any) {
-	return [
-		'ECONNRESET',
-		'ETIMEDOUT',
-		'ERR_NETWORK_CHANGED',
-		'ERR_HTTP2_INVALID_SESSION',
-		'ERR_HTTP2_STREAM_CANCEL',
-		'ERR_HTTP2_GOAWAY_SESSION',
-		'ERR_HTTP2_PROTOCOL_ERROR',
-	].includes(reason?.code);
-}
-
-export function postRequest(
-	fetcherService: IFetcherService,
-	envService: IEnvService,
-	telemetryService: ITelemetryService,
-	domainService: IDomainService,
-	capiClientService: ICAPIClientService,
-	endpointOrUrl: IEndpoint | string | RequestMetadata,
-	secretKey: string,
-	hmac: string | undefined,
-	intent: string,
-	requestId: string,
-	body?: IEndpointBody,
-	additionalHeaders?: Record<string, string>,
-	cancelToken?: CancellationToken
-): Promise<Response> {
-	return networkRequest(fetcherService,
-		envService,
-		telemetryService,
-		domainService,
-		capiClientService,
-		'POST',
-		endpointOrUrl,
-		secretKey,
-		hmac,
-		intent,
-		requestId,
-		body,
-		additionalHeaders,
-		cancelToken
-	);
-}
-
-export function getRequest(
-	fetcherService: IFetcher,
-	envService: IEnvService,
-	telemetryService: ITelemetryService,
-	domainService: IDomainService,
-	capiClientService: ICAPIClientService,
-	endpointOrUrl: IEndpoint | string | RequestMetadata,
-	secretKey: string,
-	hmac: string | undefined,
-	intent: string,
-	requestId: string,
-	body?: IEndpointBody,
-	additionalHeaders?: Record<string, string>,
-	cancelToken?: CancellationToken
-): Promise<Response> {
-	return networkRequest(fetcherService,
-		envService,
-		telemetryService,
-		domainService,
-		capiClientService,
-		'GET',
-		endpointOrUrl,
-		secretKey,
-		hmac,
-		intent,
-		requestId,
-		body,
-		additionalHeaders,
-		cancelToken
-	);
-}
-
-export const IHeaderContributors = createServiceIdentifier<HeaderContributors>('headerContributors');
-
-export interface IHeaderContributors {
-	readonly _serviceBrand: undefined;
-	add(contributor: HeaderContributor): void;
-	remove(contributor: HeaderContributor): void;
-	contributeHeaders(headers: ReqHeaders): void;
-	size(): number;
-}
-
-export class HeaderContributors implements IHeaderContributors {
-	declare readonly _serviceBrand: undefined;
-	private readonly contributors: HeaderContributor[] = [];
-
-	add(contributor: HeaderContributor) {
-		this.contributors.push(contributor);
-	}
-
-	remove(contributor: HeaderContributor) {
-		const index = this.contributors.indexOf(contributor);
-
-		if (index === -1) {
-			return;
-		}
-
-		this.contributors.splice(index, 1);
-	}
-
-	contributeHeaders(headers: ReqHeaders) {
-		for (const contributor of this.contributors) {
-			contributor.contributeHeaderValues(headers);
-		}
-	}
-
-	size() {
-		return this.contributors.length;
-	}
-}

package/src/_internal/platform/networking/common/openai.ts

@@ -1,273 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { OpenAI, OutputMode, Raw, toMode } from '@vscode/prompt-tsx';
-import { ChatCompletionContentPartKind } from '@vscode/prompt-tsx/dist/base/output/rawTypes';
-import { rawPartAsThinkingData } from '../../endpoint/common/thinkingDataContainer';
-import { TelemetryData } from '../../telemetry/common/telemetryData';
-import { ThinkingData, ThinkingDataInMessage } from '../../thinking/common/thinking';
-import { ICopilotReference, RequestId } from './fetch';
-
-/**
- * How the logprobs field looks in the OpenAI API chunks.
- */
-export interface APILogprobs {
-	text_offset: number[];
-	token_logprobs: number[];
-	top_logprobs?: { [key: string]: number }[];
-	tokens: string[];
-}
-
-/**
- * Usage statistics for the completion request.
- */
-export interface APIUsage {
-	/**
-	 * Number of tokens in the prompt.
-	 */
-	prompt_tokens: number;
-	/**
-	 * Number of tokens in the generated completion.
-	 */
-	completion_tokens: number;
-	/**
-	 * Total number of tokens used in the request (prompt + completion).
-	 */
-	total_tokens: number;
-	/**
-	 * Breakdown of tokens used in the prompt.
-	 */
-	prompt_tokens_details?: {
-		cached_tokens: number;
-	};
-	/**
-	 * Breakdown of tokens used in a completion.
-	 *
-	 * @remark it's an optional field because Copilot Proxy returns this information but not CAPI as of 18 Jun 2025
-	 */
-	completion_tokens_details?: {
-		/**
-		 * Tokens generated by the model for reasoning.
-		 */
-		reasoning_tokens: number;
-		/**
-		 * When using Predicted Outputs, the number of tokens in the prediction that appeared in the completion.
-		 */
-		accepted_prediction_tokens: number;
-		/**
-		 * When using Predicted Outputs, the number of tokens in the prediction that did not appear in the completion.
-		 * However, like reasoning tokens, these tokens are still counted in the total completion tokens for purposes of billing,
-		 * output, and context window limits.
-		 */
-		rejected_prediction_tokens: number;
-	};
-}
-
-export function isApiUsage(obj: unknown): obj is APIUsage {
-	return typeof (obj as APIUsage).prompt_tokens === 'number' &&
-		typeof (obj as APIUsage).completion_tokens === 'number' &&
-		typeof (obj as APIUsage).total_tokens === 'number';
-}
-
-
-export interface APIJsonData {
-	text: string;
-	/* Joining this together produces `text`, due to the way the proxy works. */
-	tokens: readonly string[];
-	/* These are only generated in certain situations. */
-	logprobs?: APILogprobs;
-}
-
-export interface APIErrorResponse {
-	code: number;
-	message: string;
-	metadata?: Record<string, any>;
-}
-
-
-export enum ChatRole {
-	System = 'system',
-	User = 'user',
-	Assistant = 'assistant',
-	Function = 'function',
-	Tool = 'tool'
-}
-
-
-export type CAPIChatMessage = OpenAI.ChatMessage & {
-	/**
-	 * CAPI references used in this message.
-	 */
-	copilot_references?: ICopilotReference[];
-	/**
-	 * CAPI confirmations used in this message.
-	 */
-	copilot_confirmations?: { state: string; confirmation: any }[];
-
-	copilot_cache_control?: {
-		'type': 'ephemeral';
-	};
-} & ThinkingDataInMessage;
-
-export function getCAPITextPart(content: string | OpenAI.ChatCompletionContentPart[] | OpenAI.ChatCompletionContentPart): string {
-	if (Array.isArray(content)) {
-		return content.map((part) => getCAPITextPart(part)).join('');
-	} else if (typeof content === 'string') {
-		return content;
-	} else if (typeof content === 'object' && 'text' in content) {
-		return content.text;
-	} else {
-		return '';
-	}
-}
-
-export type RawMessageConversionCallback = (message: CAPIChatMessage, thinkingData?: ThinkingData) => void;
-/**
- * Converts a raw TSX chat message to CAPI's format.
- *
- * **Extra:** the raw message can have `copilot_references` and
- * `copilot_confirmations` properties, which are copied to the CAPI message.
- */
-export function rawMessageToCAPI(message: Raw.ChatMessage, callback?: RawMessageConversionCallback): CAPIChatMessage;
-export function rawMessageToCAPI(message: Raw.ChatMessage[], callback?: RawMessageConversionCallback): CAPIChatMessage[];
-export function rawMessageToCAPI(message: Raw.ChatMessage[] | Raw.ChatMessage, callback?: RawMessageConversionCallback): CAPIChatMessage | CAPIChatMessage[] {
-	if (Array.isArray(message)) {
-		return message.map(m => rawMessageToCAPI(m, callback));
-	}
-
-	const out: CAPIChatMessage = toMode(OutputMode.OpenAI, message);
-	if ('copilot_references' in message) {
-		out.copilot_references = (message as any).copilot_references;
-	}
-	if ('copilot_confirmations' in message) {
-		out.copilot_confirmations = (message as any).copilot_confirmations;
-	}
-	if (typeof out.content === 'string') {
-		out.content = out.content.trimEnd();
-	} else {
-		for (const part of out.content) {
-			if (part.type === 'text') {
-				part.text = part.text.trimEnd();
-			}
-		}
-	}
-
-	if (message.content.find(part => part.type === ChatCompletionContentPartKind.CacheBreakpoint)) {
-		out.copilot_cache_control = { type: 'ephemeral' };
-	}
-
-	for (const content of message.content) {
-		if (content.type === Raw.ChatCompletionContentPartKind.Opaque) {
-			const data = rawPartAsThinkingData(content);
-			if (callback && data) {
-				callback(out, data);
-			}
-		}
-	}
-
-	return out;
-}
-
-export enum FinishedCompletionReason {
-	/**
-	 * Reason generated by the server. See https://platform.openai.com/docs/guides/gpt/chat-completions-api
-	 */
-	Stop = 'stop',
-	/**
-	 * Reason generated by the server. See https://platform.openai.com/docs/guides/gpt/chat-completions-api
-	 */
-	Length = 'length',
-	/**
-	 * Reason generated by the server. See https://platform.openai.com/docs/guides/gpt/chat-completions-api
-	 */
-	FunctionCall = 'function_call',
-	/**
-	 * Reason generated by the server. See https://platform.openai.com/docs/guides/gpt/chat-completions-api
-	 */
-	ToolCalls = 'tool_calls',
-	/**
-	 * Reason generated by the server. See https://platform.openai.com/docs/guides/gpt/chat-completions-api
-	 */
-	ContentFilter = 'content_filter',
-	/**
-	 * Reason generated by the server (CAPI). Happens when the stream cannot be completed and the server must terminate the response.
-	 */
-	ServerError = 'error',
-	/**
-	 * Reason generated by the client when the finish callback asked for processing to stop.
-	 */
-	ClientTrimmed = 'client-trimmed',
-	/**
-	 * Reason generated by the client when we never received a finish_reason for this particular completion (indicates a server-side bug)
-	 */
-	ClientIterationDone = 'Iteration Done',
-	/**
-	 * Reason generated by the client when we never received a finish_reason for this particular completion (indicates a server-side bug)
-	 */
-	ClientDone = 'DONE',
-}
-
-export interface IToolCall {
-	index: number;
-	id?: string;
-	function?: { name: string; arguments: string };
-}
-
-/**
- * Contains the possible reasons a response can be filtered
- */
-export enum FilterReason {
-	/**
-	 * Content deemed to be hateful
-	 */
-	Hate = 'hate',
-	/**
-	 * Content deemed to cause self harm
-	 */
-	SelfHarm = 'self_harm',
-	/**
-	 * Content deemed to be sexual in nature
-	 */
-	Sexual = 'sexual',
-	/**
-	 * Content deemed to be violent in nature
-	 */
-	Violence = 'violence',
-	/**
-	 * Content contains copyrighted material
-	 */
-	Copyright = 'snippy',
-	/**
-	 * The prompt was filtered, the reason was not provided
-	 */
-	Prompt = 'prompt'
-}
-
-export interface ChatCompletion {
-	message: Raw.ChatMessage;
-	choiceIndex: number;
-	requestId: RequestId;
-	tokens: readonly string[];
-	usage: APIUsage | undefined;
-	blockFinished: boolean; // Whether the block completion was determined to be finished
-	finishReason: FinishedCompletionReason;
-	filterReason?: FilterReason; // optional filter reason if the completion was filtered
-	telemetryData: TelemetryData; // optional telemetry data providing background
-	error?: APIErrorResponse; // optional, error was encountered during the response
-}
-
-export interface ChoiceLogProbs {
-	content: ChoiceLogProbsContent[];
-}
-
-export interface TokenLogProb {
-	bytes: number[];
-	token: string;
-	logprob: number;
-}
-
-export interface ChoiceLogProbsContent extends TokenLogProb {
-	top_logprobs: TokenLogProb[];
-}