Change tool paramters to input and make sure parameters stills works to keep backwards compatibility (microsoft#232248)

fixes microsoft#232143

Author: jrieken

src/vs/workbench/api/common/extHostLanguageModelTools.ts

@@ -15,6 +15,16 @@ import { IPreparedToolInvocation, isToolInvocationContext, IToolInvocation, IToo
 import { ExtHostLanguageModelToolsShape, IMainContext, IToolDataDto, MainContext, MainThreadLanguageModelToolsShape } from './extHost.protocol.js';
 import * as typeConvert from './extHostTypeConverters.js';
 
+/**
+ * @deprecated
+ */
+type CompatLanguageModelToolInvocationOptions<T = any> = vscode.LanguageModelToolInvocationOptions<T> & { parameters?: any };
+
+/**
+ * @deprecated
+ */
+type CompactLanguageModelToolInvocationPrepareOptions<T> = vscode.LanguageModelToolInvocationPrepareOptions<T> & { parameters: any };
+
 export class ExtHostLanguageModelTools implements ExtHostLanguageModelToolsShape {
 	/** A map of tools that were registered in this EH */
 	private readonly _registeredTools = new Map<string, { extension: IExtensionDescription; tool: vscode.LanguageModelTool<Object> }>();
@@ -43,7 +53,7 @@ export class ExtHostLanguageModelTools implements ExtHostLanguageModelToolsShape
 		return await fn(input, token);
 	}
 
-	async invokeTool(toolId: string, options: vscode.LanguageModelToolInvocationOptions<any>, token?: CancellationToken): Promise<vscode.LanguageModelToolResult> {
+	async invokeTool(toolId: string, options: CompatLanguageModelToolInvocationOptions<any>, token?: CancellationToken): Promise<vscode.LanguageModelToolResult> {
 		const callId = generateUuid();
 		if (options.tokenizationOptions) {
 			this._tokenCountFuncs.set(callId, options.tokenizationOptions.countTokens);
@@ -58,7 +68,7 @@ export class ExtHostLanguageModelTools implements ExtHostLanguageModelToolsShape
 			const result = await this._proxy.$invokeTool({
 				toolId,
 				callId,
-				parameters: options.parameters,
+				parameters: options.input ?? options.parameters,
 				tokenBudget: options.tokenizationOptions?.tokenBudget,
 				context: options.toolInvocationToken as IToolInvocationContext | undefined,
 			}, token);
@@ -86,7 +96,7 @@ export class ExtHostLanguageModelTools implements ExtHostLanguageModelToolsShape
 			throw new Error(`Unknown tool ${dto.toolId}`);
 		}
 
-		const options: vscode.LanguageModelToolInvocationOptions<Object> = { parameters: dto.parameters, toolInvocationToken: dto.context as vscode.ChatParticipantToolToken | undefined };
+		const options: CompatLanguageModelToolInvocationOptions<Object> = { input: dto.parameters, parameters: dto.parameters, toolInvocationToken: dto.context as vscode.ChatParticipantToolToken | undefined };
 		if (dto.tokenBudget !== undefined) {
 			options.tokenizationOptions = {
 				tokenBudget: dto.tokenBudget,
@@ -113,7 +123,8 @@ export class ExtHostLanguageModelTools implements ExtHostLanguageModelToolsShape
 			return undefined;
 		}
 
-		const result = await item.tool.prepareInvocation({ parameters }, token);
+		const options: CompactLanguageModelToolInvocationPrepareOptions<any> = { parameters, input: parameters };
+		const result = await item.tool.prepareInvocation(options, token);
 		if (!result) {
 			return undefined;
 		}

src/vs/workbench/api/common/extHostLanguageModels.ts

@@ -206,7 +206,7 @@ export class ExtHostLanguageModels implements ExtHostLanguageModelsShape {
 
 			let part: IChatResponsePart | undefined;
 			if (fragment.part instanceof extHostTypes.LanguageModelToolCallPart) {
-				part = { type: 'tool_use', name: fragment.part.name, parameters: fragment.part.parameters, toolCallId: fragment.part.callId };
+				part = { type: 'tool_use', name: fragment.part.name, parameters: fragment.part.input ?? fragment.part.parameters, toolCallId: fragment.part.callId };
 			} else if (fragment.part instanceof extHostTypes.LanguageModelTextPart) {
 				part = { type: 'text', value: fragment.part.value };
 			}
@@ -382,6 +382,19 @@ export class ExtHostLanguageModels implements ExtHostLanguageModelsShape {
 			}
 		}
 
+		if (options.tools) {
+			// TODO@API backwards compat, remove
+			// when getting tools passed massage them to have inputSchema set
+			type OldChatTool = vscode.LanguageModelChatTool & { parametersSchema?: object };
+			options.tools = options.tools.map((tool: OldChatTool) => {
+				return {
+					...tool,
+					inputSchema: tool.inputSchema ?? tool.parametersSchema,
+					parametersSchema: tool.inputSchema ?? tool.parametersSchema,
+				};
+			});
+		}
+
 		try {
 			const requestId = (Math.random() * 1e6) | 0;
 			const res = new LanguageModelResponse();

src/vs/workbench/api/common/extHostTypeConverters.ts

@@ -2407,7 +2407,7 @@ export namespace LanguageModelChatMessage {
 					type: 'tool_use',
 					toolCallId: c.callId,
 					name: c.name,
-					parameters: c.parameters
+					parameters: c.input ?? c.parameters
 				};
 			} else if (c instanceof types.LanguageModelTextPart) {
 				return {
@@ -2973,12 +2973,13 @@ export namespace DebugTreeItem {
 }
 
 export namespace LanguageModelToolDescription {
-	export function to(item: IToolData): vscode.LanguageModelToolInformation {
+	export function to(item: IToolData): vscode.LanguageModelToolInformation & { parametersSchema: any } {
 		return {
 			// Note- the reason this is a unique 'name' is just to avoid confusion with the toolCallId
 			name: item.id,
 			description: item.modelDescription,
-			parametersSchema: item.parametersSchema,
+			inputSchema: item.inputSchema,
+			parametersSchema: item.inputSchema, // TODO@API backwards compat, remove
 			tags: item.tags ?? [],
 		};
 	}

src/vs/workbench/api/common/extHostTypes.ts

@@ -4657,9 +4657,12 @@ export class LanguageModelChatMessage implements vscode.LanguageModelChatMessage
 export class LanguageModelToolCallPart implements vscode.LanguageModelToolCallPart {
 	callId: string;
 	name: string;
+	input: any;
+
+	/** @deprecated */
 	parameters: any;
 
-	constructor(callId: string, name: string, parameters: any) {
+	constructor(callId: string, name: string, input: any) {
 		// TODO TEMP- swapped the order of these two arguments, trying to preserve the behavior for a build or two
 		if (name.startsWith('call_')) {
 			this.name = callId;
@@ -4669,7 +4672,9 @@ export class LanguageModelToolCallPart implements vscode.LanguageModelToolCallPa
 			this.name = name;
 		}
 
-		this.parameters = parameters;
+		this.input = input;
+		// TODO@API backwards compat, remove
+		this.parameters = input;
 	}
 }
 

src/vs/workbench/contrib/chat/common/languageModelToolsService.ts

@@ -22,7 +22,7 @@ export interface IToolData {
 	displayName: string;
 	userDescription?: string;
 	modelDescription: string;
-	parametersSchema?: IJSONSchema;
+	inputSchema?: IJSONSchema;
 	canBeReferencedInPrompt?: boolean;
 }
 

src/vs/workbench/contrib/chat/common/tools/languageModelToolsContribution.ts

@@ -26,6 +26,12 @@ export interface IRawToolContribution {
 	when?: string;
 	tags?: string[];
 	userDescription?: string;
+	inputSchema?: IJSONSchema;
+
+	/**
+	 * TODO@API backwards compat, remove
+	 * @deprecated
+	 */
 	parametersSchema?: IJSONSchema;
 	canBeReferencedInPrompt?: boolean;
 }
@@ -47,10 +53,10 @@ const languageModelToolsExtensionPoint = extensionsRegistry.ExtensionsRegistry.r
 				body: {
 					name: '${1}',
 					modelDescription: '${2}',
-					parametersSchema: {
+					inputSchema: {
 						type: 'object',
 						properties: {
-							'${3:paramName}': {
+							'${3:name}': {
 								type: 'string',
 								description: '${4:description}'
 							}
@@ -83,8 +89,8 @@ const languageModelToolsExtensionPoint = extensionsRegistry.ExtensionsRegistry.r
 					description: localize('toolModelDescription', "A description of this tool that may be used by a language model to select it."),
 					type: 'string'
 				},
-				parametersSchema: {
-					description: localize('parametersSchema', "A JSON schema for the parameters this tool accepts. The parameters must be an object at the top level. A particular language model may not support all JSON schema features. See the documentation for the language model family you are using for more information."),
+				inputSchema: {
+					description: localize('parametersSchema', "A JSON schema for the input this tool accepts. The input must be an object at the top level. A particular language model may not support all JSON schema features. See the documentation for the language model family you are using for more information."),
 					$ref: toolsParametersSchemaSchemaId,
 				},
 				canBeReferencedInPrompt: {
@@ -173,6 +179,7 @@ export class LanguageModelToolsExtensionPointHandler implements IWorkbenchContri
 
 					const tool: IToolData = {
 						...rawTool,
+						inputSchema: rawTool.inputSchema ?? rawTool.parametersSchema, // BACKWARDS compatibility
 						id: rawTool.name,
 						icon,
 						when: rawTool.when ? ContextKeyExpr.deserialize(rawTool.when) : undefined,

src/vscode-dts/vscode.d.ts

@@ -19096,7 +19096,7 @@ declare module 'vscode' {
 		 * The list of tools that the user attached to their request.
 		 *
 		 * When a tool reference is present, the chat participant should make a chat request using
-		 * {@link LanguageModelChatToolMode.Required} to force the language model to generate parameters for the tool. Then, the
+		 * {@link LanguageModelChatToolMode.Required} to force the language model to generate input for the tool. Then, the
 		 * participant can use {@link lm.invokeTool} to use the tool attach the result to its request for the user's prompt. The
 		 * tool may contribute useful extra context for the user's request.
 		 */
@@ -19703,12 +19703,12 @@ declare module 'vscode' {
 
 		/**
 		 * A list of all available tools that were registered by all extensions using {@link lm.registerTool}. They can be called
-		 * with {@link lm.invokeTool} with a set of parameters that match their declared `parametersSchema`.
+		 * with {@link lm.invokeTool} with input that match their declared `inputSchema`.
 		 */
 		export const tools: readonly LanguageModelToolInformation[];
 
 		/**
-		 * Invoke a tool listed in {@link lm.tools} by name with the given parameters. The parameters will be validated against
+		 * Invoke a tool listed in {@link lm.tools} by name with the given input. The input will be validated against
 		 * the schema declared by the tool
 		 *
 		 * A tool can be invoked by a chat participant, in the context of handling a chat request, or globally by any extension in
@@ -19774,9 +19774,9 @@ declare module 'vscode' {
 		description: string;
 
 		/**
-		 * A JSON schema for the parameters this tool accepts.
+		 * A JSON schema for the input this tool accepts.
 		 */
-		parametersSchema?: object;
+		inputSchema?: object;
 	}
 
 	/**
@@ -19811,18 +19811,18 @@ declare module 'vscode' {
 		name: string;
 
 		/**
-		 * The parameters with which to call the tool.
+		 * The input with which to call the tool.
 		 */
-		parameters: object;
+		input: object;
 
 		/**
 		 * Create a new LanguageModelToolCallPart.
 		 *
 		 * @param callId The ID of the tool call.
 		 * @param name The name of the tool to call.
-		 * @param parameters The parameters with which to call the tool.
+		 * @param input The input with which to call the tool.
 		 */
-		constructor(callId: string, name: string, parameters: object);
+		constructor(callId: string, name: string, input: object);
 	}
 
 	/**
@@ -19924,10 +19924,10 @@ declare module 'vscode' {
 		toolInvocationToken: ChatParticipantToolToken | undefined;
 
 		/**
-		 * The parameters with which to invoke the tool. The parameters must match the schema defined in
-		 * {@link LanguageModelToolInformation.parametersSchema}
+		 * The input with which to invoke the tool. The input must match the schema defined in
+		 * {@link LanguageModelToolInformation.inputSchema}
 		 */
-		parameters: T;
+		input: T;
 
 		/**
 		 * Options to hint at how many tokens the tool should return in its response, and enable the tool to count tokens
@@ -19969,9 +19969,9 @@ declare module 'vscode' {
 		readonly description: string;
 
 		/**
-		 * A JSON schema for the parameters this tool accepts.
+		 * A JSON schema for the input this tool accepts.
 		 */
-		readonly parametersSchema: object | undefined;
+		readonly inputSchema: object | undefined;
 
 		/**
 		 * A set of tags, declared by the tool, that roughly describe the tool's capabilities. A tool user may use these to filter
@@ -19985,25 +19985,25 @@ declare module 'vscode' {
 	 */
 	export interface LanguageModelToolInvocationPrepareOptions<T> {
 		/**
-		 * The parameters that the tool is being invoked with.
+		 * The input that the tool is being invoked with.
 		 */
-		parameters: T;
+		input: T;
 	}
 
 	/**
 	 * A tool that can be invoked by a call to a {@link LanguageModelChat}.
 	 */
 	export interface LanguageModelTool<T> {
 		/**
-		 * Invoke the tool with the given parameters and return a result.
+		 * Invoke the tool with the given input and return a result.
 		 *
-		 * The provided {@link LanguageModelToolInvocationOptions.parameters} have been validated against the declared schema.
+		 * The provided {@link LanguageModelToolInvocationOptions.input} has been validated against the declared schema.
 		 */
 		invoke(options: LanguageModelToolInvocationOptions<T>, token: CancellationToken): ProviderResult<LanguageModelToolResult>;
 
 		/**
 		 * Called once before a tool is invoked. It's recommended to implement this to customize the progress message that appears
-		 * while the tool is running, and to provide a more useful message with context from the invocation parameters. Can also
+		 * while the tool is running, and to provide a more useful message with context from the invocation input. Can also
 		 * signal that a tool needs user confirmation before running, if appropriate.
 		 *
 		 * * *Note 1:* Must be free of side-effects.