@vscode/chat-lib 0.0.1 → 0.0.2

package/src/_internal/platform/endpoint/node/responsesApi.ts

@@ -1,326 +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 { Raw } from '@vscode/prompt-tsx';
-import { ClientHttp2Stream } from 'http2';
-import { OpenAI } from 'openai';
-import { Response } from '../../../platform/networking/common/fetcherService';
-import { coalesce } from '../../../util/vs/base/common/arrays';
-import { AsyncIterableObject } from '../../../util/vs/base/common/async';
-import { binaryIndexOf } from '../../../util/vs/base/common/buffer';
-import { Lazy } from '../../../util/vs/base/common/lazy';
-import { SSEParser } from '../../../util/vs/base/common/sseParser';
-import { isDefined } from '../../../util/vs/base/common/types';
-import { generateUuid } from '../../../util/vs/base/common/uuid';
-import { IInstantiationService, ServicesAccessor } from '../../../util/vs/platform/instantiation/common/instantiation';
-import { ConfigKey, IConfigurationService } from '../../configuration/common/configurationService';
-import { ILogService } from '../../log/common/logService';
-import { FinishedCallback, IResponseDelta, OpenAiResponsesFunctionTool } from '../../networking/common/fetch';
-import { ICreateEndpointBodyOptions, IEndpointBody } from '../../networking/common/networking';
-import { ChatCompletion, FinishedCompletionReason, TokenLogProb } from '../../networking/common/openai';
-import { ITelemetryService } from '../../telemetry/common/telemetry';
-import { TelemetryData } from '../../telemetry/common/telemetryData';
-import { IChatModelInformation } from '../common/endpointProvider';
-import { getStatefulMarkerAndIndex } from '../common/statefulMarkerContainer';
-import { rawPartAsThinkingData } from '../common/thinkingDataContainer';
-
-export function createResponsesRequestBody(accessor: ServicesAccessor, options: ICreateEndpointBodyOptions, model: string, modelInfo: IChatModelInformation): IEndpointBody {
-	const configService = accessor.get(IConfigurationService);
-	const logService = accessor.get(ILogService);
-	const body: IEndpointBody = {
-		model,
-		...rawMessagesToResponseAPI(model, options.messages, !!options.ignoreStatefulMarker),
-		stream: true,
-		tools: options.requestOptions?.tools?.map((tool): OpenAI.Responses.FunctionTool & OpenAiResponsesFunctionTool => ({
-			...tool.function,
-			type: 'function',
-			strict: false,
-			parameters: (tool.function.parameters || {}) as Record<string, unknown>,
-		})),
-		// Only a subset of completion post options are supported, and some
-		// are renamed. Handle them manually:
-		top_p: options.postOptions.top_p,
-		max_output_tokens: options.postOptions.max_tokens,
-		tool_choice: typeof options.postOptions.tool_choice === 'object'
-			? { type: 'function', name: options.postOptions.tool_choice.function.name }
-			: options.postOptions.tool_choice,
-		top_logprobs: options.postOptions.logprobs ? 3 : undefined,
-		store: false
-	};
-
-	body.truncation = configService.getConfig(ConfigKey.Internal.UseResponsesApiTruncation) ?
-		'auto' :
-		'disabled';
-	const reasoningConfig = configService.getConfig(ConfigKey.Internal.ResponsesApiReasoning);
-	if (reasoningConfig === true) {
-		body.reasoning = {
-			'effort': 'high',
-			'summary': 'detailed'
-		};
-	} else if (typeof reasoningConfig === 'string') {
-		try {
-			body.reasoning = JSON.parse(reasoningConfig);
-		} catch (e) {
-			logService.error(e, 'Failed to parse responses reasoning setting');
-		}
-	}
-
-	body.include = ['reasoning.encrypted_content'];
-
-	return body;
-}
-
-function rawMessagesToResponseAPI(modelId: string, messages: readonly Raw.ChatMessage[], ignoreStatefulMarker: boolean): { input: OpenAI.Responses.ResponseInputItem[]; previous_response_id?: string } {
-	const statefulMarkerAndIndex = !ignoreStatefulMarker && getStatefulMarkerAndIndex(modelId, messages);
-	let previousResponseId: string | undefined;
-	if (statefulMarkerAndIndex) {
-		previousResponseId = statefulMarkerAndIndex.statefulMarker;
-		messages = messages.slice(statefulMarkerAndIndex.index + 1);
-	}
-
-	const input: OpenAI.Responses.ResponseInputItem[] = [];
-	for (const message of messages) {
-		switch (message.role) {
-			case Raw.ChatRole.Assistant:
-				if (message.content.length) {
-					input.push(...extractThinkingData(message.content));
-					input.push({
-						role: 'assistant',
-						content: message.content.map(rawContentToResponsesOutputContent).filter(isDefined),
-						// I don't think this needs to be round-tripped.
-						id: 'msg_123',
-						status: 'completed',
-						type: 'message',
-					} satisfies OpenAI.Responses.ResponseOutputMessage);
-				}
-				if (message.toolCalls) {
-					for (const toolCall of message.toolCalls) {
-						input.push({ type: 'function_call', name: toolCall.function.name, arguments: toolCall.function.arguments, call_id: toolCall.id });
-					}
-				}
-				break;
-			case Raw.ChatRole.Tool:
-				if (message.toolCallId) {
-					const asText = message.content
-						.filter(c => c.type === Raw.ChatCompletionContentPartKind.Text)
-						.map(c => c.text)
-						.join('');
-					const asImages = message.content
-						.filter(c => c.type === Raw.ChatCompletionContentPartKind.Image)
-						.map((c): OpenAI.Responses.ResponseInputImage => ({
-							type: 'input_image',
-							detail: c.imageUrl.detail || 'auto',
-							image_url: c.imageUrl.url,
-						}));
-
-					// todod@connor4312: hack while responses API only supports text output from tools
-					input.push({ type: 'function_call_output', call_id: message.toolCallId, output: asText });
-					if (asImages.length) {
-						input.push({ role: 'user', content: [{ type: 'input_text', text: 'Image associated with the above tool call:' }, ...asImages] });
-					}
-				}
-				break;
-			case Raw.ChatRole.User:
-				input.push({ role: 'user', content: message.content.map(rawContentToResponsesContent).filter(isDefined) });
-				break;
-			case Raw.ChatRole.System:
-				input.push({ role: 'system', content: message.content.map(rawContentToResponsesContent).filter(isDefined) });
-				break;
-		}
-	}
-
-	return { input, previous_response_id: previousResponseId };
-}
-
-function rawContentToResponsesContent(part: Raw.ChatCompletionContentPart): OpenAI.Responses.ResponseInputContent | undefined {
-	switch (part.type) {
-		case Raw.ChatCompletionContentPartKind.Text:
-			return { type: 'input_text', text: part.text };
-		case Raw.ChatCompletionContentPartKind.Image:
-			return { type: 'input_image', detail: part.imageUrl.detail || 'auto', image_url: part.imageUrl.url };
-		case Raw.ChatCompletionContentPartKind.Opaque: {
-			const maybeCast = part.value as OpenAI.Responses.ResponseInputContent;
-			if (maybeCast.type === 'input_text' || maybeCast.type === 'input_image' || maybeCast.type === 'input_file') {
-				return maybeCast;
-			}
-		}
-	}
-}
-
-function rawContentToResponsesOutputContent(part: Raw.ChatCompletionContentPart): OpenAI.Responses.ResponseOutputText | OpenAI.Responses.ResponseOutputRefusal | undefined {
-	switch (part.type) {
-		case Raw.ChatCompletionContentPartKind.Text:
-			return { type: 'output_text', text: part.text, annotations: [] };
-	}
-}
-
-function extractThinkingData(content: Raw.ChatCompletionContentPart[]): OpenAI.Responses.ResponseReasoningItem[] {
-	return coalesce(content.map(part => {
-		if (part.type === Raw.ChatCompletionContentPartKind.Opaque) {
-			const thinkingData = rawPartAsThinkingData(part);
-			if (thinkingData) {
-				return {
-					type: 'reasoning',
-					id: thinkingData.id,
-					summary: [],
-					encrypted_content: thinkingData.encrypted,
-				} satisfies OpenAI.Responses.ResponseReasoningItem;
-			}
-		}
-	}));
-}
-
-export async function processResponseFromChatEndpoint(instantiationService: IInstantiationService, telemetryService: ITelemetryService, logService: ILogService, response: Response, expectedNumChoices: number, finishCallback: FinishedCallback, telemetryData: TelemetryData): Promise<AsyncIterableObject<ChatCompletion>> {
-	const body = (await response.body()) as ClientHttp2Stream;
-	return new AsyncIterableObject<ChatCompletion>(async feed => {
-		const requestId = response.headers.get('X-Request-ID') ?? generateUuid();
-		const processor = instantiationService.createInstance(OpenAIResponsesProcessor, telemetryData, requestId);
-		const parser = new SSEParser((ev) => {
-			try {
-				logService.trace(`SSE: ${ev.data}`);
-				const completion = processor.push({ type: ev.type, ...JSON.parse(ev.data) }, finishCallback);
-				if (completion) {
-					feed.emitOne(completion);
-				}
-			} catch (e) {
-				feed.reject(e);
-			}
-		});
-
-		for await (const chunk of body) {
-			parser.feed(chunk);
-		}
-	}, () => {
-		body.destroy();
-	});
-}
-
-class OpenAIResponsesProcessor {
-	private textAccumulator: string = '';
-	private hasReceivedReasoningSummary = false;
-
-	constructor(
-		private readonly telemetryData: TelemetryData,
-		private readonly requestId: string,
-	) { }
-
-	public push(chunk: OpenAI.Responses.ResponseStreamEvent, _onProgress: FinishedCallback): ChatCompletion | undefined {
-		const onProgress = (delta: IResponseDelta): undefined => {
-			this.textAccumulator += delta.text;
-			_onProgress(this.textAccumulator, 0, delta);
-		};
-
-		switch (chunk.type) {
-			case 'error':
-				return onProgress({ text: '', copilotErrors: [{ agent: 'openai', code: chunk.code || 'unknown', message: chunk.message, type: 'error', identifier: chunk.param || undefined }] });
-			case 'response.output_text.delta': {
-				const haystack = new Lazy(() => new TextEncoder().encode(chunk.delta));
-				return onProgress({
-					text: chunk.delta,
-					logprobs: { content: chunk.logprobs.map(lp => ({ ...mapLogProp(haystack, lp), top_logprobs: lp.top_logprobs?.map(l => mapLogProp(haystack, l)) || [] })) },
-				});
-			}
-			case 'response.output_item.added':
-				if (chunk.item.type === 'function_call') {
-					onProgress({
-						text: '',
-						beginToolCalls: [{ name: chunk.item.name }]
-					});
-				}
-				return;
-			case 'response.output_item.done':
-				if (chunk.item.type === 'function_call') {
-					onProgress({
-						text: '',
-						copilotToolCalls: [{
-							id: chunk.item.call_id,
-							name: chunk.item.name,
-							arguments: chunk.item.arguments,
-						}],
-					});
-				} else if (chunk.item.type === 'reasoning') {
-					onProgress({
-						text: '',
-						thinking: chunk.item.encrypted_content ? {
-							id: chunk.item.id,
-							// CAPI models don't stream the reasoning summary for some reason, byok do, so don't duplicate it
-							text: this.hasReceivedReasoningSummary ?
-								undefined :
-								chunk.item.summary.map(s => s.text),
-							encrypted: chunk.item.encrypted_content,
-						} : undefined
-					});
-				}
-				return;
-			case 'response.reasoning_summary_text.delta':
-				this.hasReceivedReasoningSummary = true;
-				return onProgress({
-					text: '',
-					thinking: {
-						id: chunk.item_id,
-						text: chunk.delta,
-					}
-				});
-			case 'response.reasoning_summary_part.done':
-				this.hasReceivedReasoningSummary = true;
-				return onProgress({
-					text: '',
-					thinking: {
-						id: chunk.item_id
-					}
-				});
-			case 'response.completed':
-				onProgress({ text: '', statefulMarker: chunk.response.id });
-				return {
-					blockFinished: true,
-					choiceIndex: 0,
-					tokens: [],
-					telemetryData: this.telemetryData,
-					requestId: { headerRequestId: this.requestId, completionId: chunk.response.id, created: chunk.response.created_at, deploymentId: '', serverExperiments: '' },
-					usage: {
-						prompt_tokens: chunk.response.usage?.input_tokens ?? 0,
-						completion_tokens: chunk.response.usage?.output_tokens ?? 0,
-						total_tokens: chunk.response.usage?.total_tokens ?? 0,
-						prompt_tokens_details: {
-							cached_tokens: chunk.response.usage?.input_tokens_details.cached_tokens ?? 0,
-						},
-						completion_tokens_details: {
-							reasoning_tokens: chunk.response.usage?.output_tokens_details.reasoning_tokens ?? 0,
-							accepted_prediction_tokens: 0,
-							rejected_prediction_tokens: 0,
-						},
-					},
-					finishReason: FinishedCompletionReason.Stop,
-					message: {
-						role: Raw.ChatRole.Assistant,
-						content: chunk.response.output.map((item): Raw.ChatCompletionContentPart | undefined => {
-							if (item.type === 'message') {
-								return { type: Raw.ChatCompletionContentPartKind.Text, text: item.content.map(c => c.type === 'output_text' ? c.text : c.refusal).join('') };
-							} else if (item.type === 'image_generation_call' && item.result) {
-								return { type: Raw.ChatCompletionContentPartKind.Image, imageUrl: { url: item.result } };
-							}
-						}).filter(isDefined),
-					}
-				};
-		}
-	}
-}
-function mapLogProp(text: Lazy<Uint8Array>, lp: OpenAI.Responses.ResponseTextDeltaEvent.Logprob.TopLogprob): TokenLogProb {
-	let bytes: number[] = [];
-	if (lp.token) {
-		const needle = new TextEncoder().encode(lp.token);
-		const haystack = text.value;
-		const idx = binaryIndexOf(haystack, needle);
-		if (idx !== -1) {
-			bytes = [idx, idx + needle.length];
-		}
-	}
-
-	return {
-		token: lp.token!,
-		bytes,
-		logprob: lp.logprob!,
-	};
-}

package/src/_internal/platform/env/common/envService.ts

@@ -1,134 +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 { createServiceIdentifier } from '../../../util/common/services';
-import { env } from '../../../util/vs/base/common/process';
-import { URI } from '../../../util/vs/base/common/uri';
-import { isPreRelease, isProduction, packageJson } from './packagejson';
-
-export enum OperatingSystem {
-	Windows = 'Windows',
-	Macintosh = 'Mac',
-	Linux = 'Linux'
-}
-
-
-export class NameAndVersion {
-	constructor(
-		readonly name: string,
-		readonly version: string
-	) { }
-
-	format(): string {
-		return `${this.name}/${this.version}`;
-	}
-}
-
-
-export const IEnvService = createServiceIdentifier<IEnvService>('IEnvService');
-
-export interface IEnvService {
-	readonly _serviceBrand: undefined;
-	readonly language: string | undefined;
-	readonly sessionId: string;
-	readonly machineId: string;
-	readonly vscodeVersion: string;
-	/**
-	 * Whether the current session is considered active
-	 * @see vscode.window.state.active
-	 */
-	readonly isActive: boolean;
-	/**
-	 * @see vscode.env.remoteName
-	 */
-	readonly remoteName: string | undefined;
-	readonly OS: OperatingSystem;
-	readonly uriScheme: string;
-	readonly extensionId: string;
-	readonly appRoot: string;
-	readonly shell: string;
-	isProduction(): boolean;
-	isPreRelease(): boolean;
-	isSimulation(): boolean;
-	getBuildType(): 'prod' | 'dev';
-	getVersion(): string;
-	getBuild(): string;
-	getName(): string;
-	getEditorInfo(): NameAndVersion;
-	getEditorPluginInfo(): NameAndVersion;
-	openExternal(target: URI): Promise<boolean>;
-}
-
-export abstract class AbstractEnvService implements IEnvService {
-	language: string | undefined;
-	declare _serviceBrand: undefined;
-
-	abstract get sessionId(): string;
-	abstract get vscodeVersion(): string;
-	abstract get extensionId(): string;
-	abstract get machineId(): string;
-	abstract get remoteName(): string | undefined;
-	abstract get OS(): OperatingSystem;
-	abstract get uriScheme(): string;
-	abstract get appRoot(): string;
-	abstract get shell(): string;
-	abstract get isActive(): boolean;
-
-	/**
-	 * @returns true if this is a build for end users.
-	 */
-	isProduction(): boolean {
-		return isProduction;
-	}
-
-	isPreRelease(): boolean {
-		return isPreRelease;
-	}
-
-	isSimulation(): boolean {
-		return env['SIMULATION'] === '1';
-	}
-
-	getBuildType(): 'prod' | 'dev' {
-		return packageJson.buildType;
-	}
-
-	getVersion(): string {
-		return packageJson.version;
-	}
-
-	getBuild(): string {
-		return packageJson.build;
-	}
-
-	getName(): string {
-		return packageJson.name;
-	}
-
-	/**
-	 * The name and version of the editor itself.
-	 * `{ name : 'vscode', version: '1.63.2' }`.
-	 */
-	abstract getEditorInfo(): NameAndVersion;
-
-	/**
-	 * The name and version of the Copilot chat plugin.
-	 * or `{ name: 'copilot-chat', version: '1.7.21' }`.
-	 */
-	abstract getEditorPluginInfo(): NameAndVersion;
-
-	getEditorVersionHeaders(): { [key: string]: string } {
-		return {
-			'Editor-Version': this.getEditorInfo().format(),
-			'Editor-Plugin-Version': this.getEditorPluginInfo().format(),
-		};
-	}
-
-	abstract openExternal(target: URI): Promise<boolean>;
-}
-
-// FIXME: This needs to be used in locations where the EnvService is not yet available, so it's
-//        not part of the env service itself.
-export const isScenarioAutomation = env['IS_SCENARIO_AUTOMATION'] === '1';

package/src/_internal/platform/env/common/nullEnvService.ts

@@ -1,68 +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 { URI } from '../../../util/vs/base/common/uri';
-import { AbstractEnvService, NameAndVersion, OperatingSystem } from './envService';
-import { packageJson } from './packagejson';
-
-export class NullEnvService extends AbstractEnvService {
-	declare readonly _serviceBrand: undefined;
-
-	static readonly Instance = new NullEnvService();
-
-	override readonly language: string = 'en';
-
-	override get extensionId(): string {
-		return 'test-extension-id';
-	}
-
-	get vscodeVersion(): string {
-		return 'test-version';
-	}
-
-	override get isActive(): boolean {
-		return true;
-	}
-
-	override get sessionId(): string {
-		return 'test-session';
-	}
-
-	override get machineId(): string {
-		return 'test-machine';
-	}
-
-	override get remoteName(): string | undefined {
-		return undefined;
-	}
-
-	override get uriScheme(): string {
-		return 'code-null';
-	}
-
-	override get appRoot(): string {
-		return '';
-	}
-
-	override get shell(): string {
-		return 'zsh';
-	}
-
-	override get OS(): OperatingSystem {
-		return OperatingSystem.Linux;
-	}
-
-	override getEditorInfo(): NameAndVersion {
-		return new NameAndVersion('simulation-tests-editor', packageJson.engines.vscode.match(/\d+\.\d+/)?.[0] ?? '1.89');
-	}
-
-	override getEditorPluginInfo(): NameAndVersion {
-		return new NameAndVersion('simulation-tests-plugin', '2');
-	}
-
-	override openExternal(target: URI): Promise<boolean> {
-		return Promise.resolve(false);
-	}
-}

package/src/_internal/platform/env/common/packagejson.ts

@@ -1,49 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-export interface PackageJSONShape {
-	isPreRelease?: boolean;
-	buildType: 'prod' | 'dev';
-	version: string;
-	completionsCoreVersion: string;
-	build: string;
-	publisher: string;
-	name: string;
-	engines: {
-		vscode: string;
-	};
-	contributes: {
-		configuration: {
-			title: string;
-			id: string;
-			properties: {
-				[key: string]: {
-					default?: any;
-					tags?: string[];
-				};
-			};
-		}[];
-		languageModelTools: {
-			name: string;
-			toolReferenceName: string;
-			displayName: string;
-			modelDescription: string;
-			inputSchema: any;
-			canBeReferencedInPrompt: boolean;
-			tags?: string[];
-		}[];
-		languageModelToolSets: {
-			name: string;
-			tools: string[];
-		}[];
-	};
-}
-
-declare const require: any; // TODO@bpasero we need package.json support in web via bundling
-
-export const packageJson: PackageJSONShape = require('../../../../package.json');
-export const isProduction = (packageJson.buildType !== 'dev');
-export const isPreRelease = (packageJson.isPreRelease || !isProduction);
-export const vscodeEngineVersion = packageJson.engines.vscode;

package/src/_internal/platform/git/common/gitExtensionService.ts

@@ -1,21 +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 type * as vscode from 'vscode';
-import { createServiceIdentifier } from '../../../util/common/services';
-import { API } from '../vscode/git';
-
-export const IGitExtensionService = createServiceIdentifier<IGitExtensionService>('IGitExtensionService');
-
-export interface IGitExtensionService {
-
-	readonly _serviceBrand: undefined;
-
-	onDidChange: vscode.Event<{ enabled: boolean }>;
-
-	readonly extensionAvailable: boolean;
-
-	getExtensionApi(): API | undefined;
-}

package/src/_internal/platform/git/common/nullGitExtensionService.ts

@@ -1,20 +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 type * as vscode from 'vscode';
-import { Event } from '../../../util/vs/base/common/event';
-import { IGitExtensionService } from './gitExtensionService';
-
-export class NullGitExtensionService implements IGitExtensionService {
-	declare readonly _serviceBrand: undefined;
-
-	onDidChange: vscode.Event<{ enabled: boolean }> = Event.None;
-
-	readonly extensionAvailable: boolean = false;
-
-	getExtensionApi(): undefined {
-		return undefined;
-	}
-}