@vscode/chat-lib 0.0.1

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

@@ -0,0 +1,442 @@
+/*---------------------------------------------------------------------------------------------
+ *  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

@@ -0,0 +1,273 @@
+/*---------------------------------------------------------------------------------------------
+ *  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[];
+}