@codingame/monaco-vscode-chat-service-override 37.1.0 → 37.2.0

package/vscode/src/vs/workbench/contrib/chat/common/tools/builtinTools/manageTodoListTool.js

@@ -0,0 +1,298 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { ToolDataSource, ToolInvocationPresentation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IChatTodoListService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/chatTodoListService.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+
+const ManageTodoListToolToolId = "manage_todo_list";
+function createManageTodoListToolData() {
+    const inputSchema = {
+        type: "object",
+        properties: {
+            todoList: {
+                type: "array",
+                description: "Complete array of all todo items. Must include ALL items - both existing and new.",
+                items: {
+                    type: "object",
+                    properties: {
+                        id: {
+                            type: "number",
+                            description: "Unique identifier for the todo. Use sequential numbers starting from 1."
+                        },
+                        title: {
+                            type: "string",
+                            description: "Concise action-oriented todo label (3-7 words). Displayed in UI."
+                        },
+                        status: {
+                            type: "string",
+                            enum: ["not-started", "in-progress", "completed"],
+                            description: "not-started: Not begun | in-progress: Currently working (max 1) | completed: Fully finished with no blockers"
+                        }
+                    },
+                    required: ["id", "title", "status"]
+                }
+            }
+        },
+        required: ["todoList"]
+    };
+    return {
+        id: ManageTodoListToolToolId,
+        toolReferenceName: "todo",
+        legacyToolReferenceFullNames: ["todos"],
+        canBeReferencedInPrompt: true,
+        icon: ThemeIcon.fromId(Codicon.checklist.id),
+        displayName: ( localize(10876, "Manage and track todo items for task planning")),
+        userDescription: ( localize(10877, "Manage and track todo items for task planning")),
+        modelDescription: "Manage a structured todo list to track progress and plan tasks throughout your coding session. Use this tool VERY frequently to ensure task visibility and proper planning.\n\nWhen to use this tool:\n- Complex multi-step work requiring planning and tracking\n- When user provides multiple tasks or requests (numbered/comma-separated)\n- After receiving new instructions that require multiple steps\n- BEFORE starting work on any todo (mark as in-progress)\n- IMMEDIATELY after completing each todo (mark completed individually)\n- When breaking down larger tasks into smaller actionable steps\n- To give users visibility into your progress and planning\n\nWhen NOT to use:\n- Single, trivial tasks that can be completed in one step\n- Purely conversational/informational requests\n- When just reading files or performing simple searches\n\nCRITICAL workflow:\n1. Plan tasks by writing todo list with specific, actionable items\n2. Mark ONE todo as in-progress before starting work\n3. Complete the work for that specific todo\n4. Mark that todo as completed IMMEDIATELY\n5. Move to next todo and repeat\n\nTodo states:\n- not-started: Todo not yet begun\n- in-progress: Currently working (limit ONE at a time)\n- completed: Finished successfully\n\nIMPORTANT: Mark todos completed as soon as they are done. Do not batch completions.",
+        source: ToolDataSource.Internal,
+        inputSchema: inputSchema
+    };
+}
+createManageTodoListToolData();
+let ManageTodoListTool = class ManageTodoListTool extends Disposable {
+    constructor(chatTodoListService, logService, telemetryService) {
+        super();
+        this.chatTodoListService = chatTodoListService;
+        this.logService = logService;
+        this.telemetryService = telemetryService;
+    }
+    async invoke(invocation, _countTokens, _progress, _token) {
+        const args = invocation.parameters;
+        let chatSessionResource = invocation.context?.sessionResource;
+        if (!chatSessionResource && args.operation === "read" && args.chatSessionResource) {
+            try {
+                chatSessionResource = ( URI.parse(args.chatSessionResource));
+            } catch (error) {
+                this.logService.error("ManageTodoListTool: Invalid chatSessionResource URI", error);
+            }
+        }
+        if (!chatSessionResource) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: "Error: No session resource available"
+                }]
+            };
+        }
+        this.logService.debug(`ManageTodoListTool: Invoking with options ${JSON.stringify(args)}`);
+        try {
+            if (args.operation === "read") {
+                return this.handleReadOperation(chatSessionResource);
+            } else {
+                return this.handleWriteOperation(args, chatSessionResource);
+            }
+        } catch (error) {
+            const errorMessage = `Error: ${error instanceof Error ? error.message : "Unknown error"}`;
+            return {
+                content: [{
+                    kind: "text",
+                    value: errorMessage
+                }]
+            };
+        }
+    }
+    async prepareToolInvocation(context, _token) {
+        const args = context.parameters;
+        const chatSessionResource = context.chatSessionResource;
+        if (!chatSessionResource) {
+            return undefined;
+        }
+        const currentTodoItems = this.chatTodoListService.getTodos(chatSessionResource);
+        let message;
+        if (args.operation === "read") {
+            message = ( localize(10878, "Read todo list"));
+        } else if (args.todoList) {
+            message = this.generatePastTenseMessage(currentTodoItems, args.todoList);
+        }
+        const items = args.todoList ?? currentTodoItems;
+        const todoList = ( items.map(todo => ({
+            id: ( todo.id.toString()),
+            title: todo.title,
+            status: todo.status
+        })));
+        const invocationLabel = message?.replace(/^(Starting|Completed): /i, "") ?? ( localize(10879, "Updating todo list"));
+        const invocationMessage = ( new MarkdownString(invocationLabel));
+        return {
+            invocationMessage,
+            presentation: items.length ? undefined : ToolInvocationPresentation.Hidden,
+            pastTenseMessage: ( new MarkdownString(message ?? ( localize(10880, "Updated todo list")))),
+            toolSpecificData: {
+                kind: "todoList",
+                todoList: todoList
+            }
+        };
+    }
+    generatePastTenseMessage(currentTodos, newTodos) {
+        if (currentTodos.length === 0 && newTodos.length > 0) {
+            return newTodos.length === 1 ? ( localize(10881, "Created 1 todo")) : ( localize(10882, "Created {0} todos", newTodos.length));
+        }
+        const currentTodoMap = ( new Map(( currentTodos.map(todo => [todo.id, todo]))));
+        const startedTodos = newTodos.filter(newTodo => {
+            const currentTodo = currentTodoMap.get(newTodo.id);
+            return currentTodo && currentTodo.status !== "in-progress" && newTodo.status === "in-progress";
+        });
+        if (startedTodos.length > 0) {
+            const startedTodo = startedTodos[0];
+            const totalTodos = newTodos.length;
+            const currentPosition = newTodos.findIndex(todo => todo.id === startedTodo.id) + 1;
+            return localize(
+                10883,
+                "Starting: *{0}* ({1}/{2})",
+                startedTodo.title,
+                currentPosition,
+                totalTodos
+            );
+        }
+        const completedTodos = newTodos.filter(newTodo => {
+            const currentTodo = currentTodoMap.get(newTodo.id);
+            return currentTodo && currentTodo.status !== "completed" && newTodo.status === "completed";
+        });
+        if (completedTodos.length > 0) {
+            const completedTodo = completedTodos[0];
+            const totalTodos = newTodos.length;
+            const currentPosition = newTodos.findIndex(todo => todo.id === completedTodo.id) + 1;
+            return localize(
+                10884,
+                "Completed: *{0}* ({1}/{2})",
+                completedTodo.title,
+                currentPosition,
+                totalTodos
+            );
+        }
+        const addedTodos = newTodos.filter(newTodo => !( currentTodoMap.has(newTodo.id)));
+        if (addedTodos.length > 0) {
+            return addedTodos.length === 1 ? ( localize(10885, "Added 1 todo")) : ( localize(10886, "Added {0} todos", addedTodos.length));
+        }
+        return localize(10887, "Updated todo list");
+    }
+    handleRead(todoItems, sessionResource) {
+        if (todoItems.length === 0) {
+            return "No todo list found.";
+        }
+        const markdownTaskList = this.formatTodoListAsMarkdownTaskList(todoItems);
+        return `# Todo List\n\n${markdownTaskList}`;
+    }
+    handleReadOperation(chatSessionResource) {
+        const todoItems = this.chatTodoListService.getTodos(chatSessionResource);
+        const readResult = this.handleRead(todoItems, chatSessionResource);
+        const statusCounts = this.calculateStatusCounts(todoItems);
+        this.telemetryService.publicLog2("todoListToolInvoked", {
+            operation: "read",
+            notStartedCount: statusCounts.notStartedCount,
+            inProgressCount: statusCounts.inProgressCount,
+            completedCount: statusCounts.completedCount
+        });
+        return {
+            content: [{
+                kind: "text",
+                value: readResult
+            }]
+        };
+    }
+    handleWriteOperation(args, chatSessionResource) {
+        if (!args.todoList) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: "Error: todoList is required for write operation"
+                }]
+            };
+        }
+        const todoList = ( args.todoList.map(parsedTodo => ({
+            id: parsedTodo.id,
+            title: parsedTodo.title,
+            status: parsedTodo.status
+        })));
+        const existingTodos = this.chatTodoListService.getTodos(chatSessionResource);
+        const changes = this.calculateTodoChanges(existingTodos, todoList);
+        this.chatTodoListService.setTodos(chatSessionResource, todoList);
+        const statusCounts = this.calculateStatusCounts(todoList);
+        const warnings = [];
+        if (todoList.length < 3) {
+            warnings.push(
+                "Warning: Small todo list (<3 items). This task might not need a todo list."
+            );
+        } else if (todoList.length > 10) {
+            warnings.push(
+                "Warning: Large todo list (>10 items). Consider keeping the list focused and actionable."
+            );
+        }
+        if (changes > 3) {
+            warnings.push(
+                "Warning: Did you mean to update so many todos at the same time? Consider working on them one by one."
+            );
+        }
+        this.telemetryService.publicLog2("todoListToolInvoked", {
+            operation: "write",
+            notStartedCount: statusCounts.notStartedCount,
+            inProgressCount: statusCounts.inProgressCount,
+            completedCount: statusCounts.completedCount
+        });
+        return {
+            content: [{
+                kind: "text",
+                value: `Successfully wrote todo list${warnings.length ? "\n\n" + warnings.join("\n") : ""}`
+            }],
+            toolMetadata: {
+                warnings: warnings
+            }
+        };
+    }
+    calculateStatusCounts(todos) {
+        const notStartedCount = todos.filter(todo => todo.status === "not-started").length;
+        const inProgressCount = todos.filter(todo => todo.status === "in-progress").length;
+        const completedCount = todos.filter(todo => todo.status === "completed").length;
+        return {
+            notStartedCount,
+            inProgressCount,
+            completedCount
+        };
+    }
+    formatTodoListAsMarkdownTaskList(todoList) {
+        if (todoList.length === 0) {
+            return "";
+        }
+        return ( todoList.map(todo => {
+            let checkbox;
+            switch (todo.status) {
+            case "completed":
+                checkbox = "[x]";
+                break;
+            case "in-progress":
+                checkbox = "[-]";
+                break;
+            case "not-started":
+            default:
+                checkbox = "[ ]";
+                break;
+            }
+            const lines = [`- ${checkbox} ${todo.title}`];
+            return lines.join("\n");
+        })).join("\n");
+    }
+    calculateTodoChanges(oldList, newList) {
+        let modified = 0;
+        const minLen = Math.min(oldList.length, newList.length);
+        for (let i = 0; i < minLen; i++) {
+            const o = oldList[i];
+            const n = newList[i];
+            if (o.title !== n.title || o.status !== n.status) {
+                modified++;
+            }
+        }
+        const added = Math.max(0, newList.length - oldList.length);
+        const removed = Math.max(0, oldList.length - newList.length);
+        const totalChanges = added + removed + modified;
+        return totalChanges;
+    }
+};
+ManageTodoListTool = ( __decorate([( __param(0, IChatTodoListService)), ( __param(1, ILogService)), ( __param(2, ITelemetryService))], ManageTodoListTool));
+
+export { ManageTodoListTool, ManageTodoListToolToolId, createManageTodoListToolData };

package/vscode/src/vs/workbench/contrib/chat/common/tools/builtinTools/reviewPlanTool.d.ts

@@ -0,0 +1,25 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IChatPlanApprovalAction } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
+export declare const ReviewPlanToolId = "vscode_reviewPlan";
+export interface IReviewPlanParams {
+    readonly title?: string;
+    readonly plan?: string;
+    readonly content: string;
+    readonly actions: IChatPlanApprovalAction[];
+    readonly canProvideFeedback: boolean;
+}
+export declare function createReviewPlanToolData(): IToolData;
+export declare const ReviewPlanToolData: IToolData;
+export declare class ReviewPlanTool extends Disposable implements IToolImpl {
+    private readonly chatService;
+    private readonly logService;
+    constructor(chatService: IChatService, logService: ILogService);
+    invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
+    prepareToolInvocation(context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+    private toResult;
+    private getRequest;
+}

package/vscode/src/vs/workbench/contrib/chat/common/tools/builtinTools/reviewPlanTool.js

@@ -0,0 +1,177 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { raceCancellation } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { ChatPlanReviewData } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatProgressTypes/chatPlanReviewData';
+import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+
+const ReviewPlanToolId = "vscode_reviewPlan";
+function createReviewPlanToolData() {
+    const approvalActionSchema = {
+        type: "object",
+        properties: {
+            label: {
+                type: "string",
+                description: "Short action label shown in the dropdown button."
+            },
+            description: {
+                type: "string",
+                description: "Optional detail shown below the label in the dropdown list."
+            },
+            default: {
+                type: "boolean",
+                description: "Whether this action should be selected by default."
+            },
+            permissionLevel: {
+                type: "string",
+                enum: ["autopilot"],
+                description: "When set to \"autopilot\", a confirmation dialog is shown before proceeding."
+            }
+        },
+        required: ["label"]
+    };
+    const inputSchema = {
+        type: "object",
+        properties: {
+            title: {
+                type: "string",
+                description: "Title displayed in the widget header. Defaults to \"Plan summary\" if omitted."
+            },
+            plan: {
+                type: "string",
+                description: "Optional URI of an editable plan file. An Edit button in the widget header opens it in the editor."
+            },
+            content: {
+                type: "string",
+                description: "Markdown content rendered in the body of the widget. May be the plan summary or full plan text."
+            },
+            actions: {
+                type: "array",
+                description: "List of approval actions offered in the primary dropdown button. Order is preserved.",
+                items: approvalActionSchema,
+                minItems: 1
+            },
+            canProvideFeedback: {
+                type: "boolean",
+                description: "When true, an additional feedback textarea is shown below the plan content."
+            }
+        },
+        required: ["content", "actions", "canProvideFeedback"]
+    };
+    return {
+        id: ReviewPlanToolId,
+        toolReferenceName: "reviewPlan",
+        canBeReferencedInPrompt: false,
+        icon: ThemeIcon.fromId(Codicon.checklist.id),
+        displayName: ( localize(10888, "Review Plan")),
+        userDescription: ( localize(10889, "Ask the user to review and approve a plan before proceeding.")),
+        modelDescription: "Use this tool to present a plan to the user for review. Provide the plan content as markdown, a list of approval actions (with optional default), and whether the user can provide freeform feedback. Optionally provide a URI to the backing plan file so the user can edit it. The tool returns the chosen action, whether the plan was rejected, and any feedback.",
+        source: ToolDataSource.Internal,
+        inputSchema
+    };
+}
+const ReviewPlanToolData = createReviewPlanToolData();
+let ReviewPlanTool = class ReviewPlanTool extends Disposable {
+    constructor(chatService, logService) {
+        super();
+        this.chatService = chatService;
+        this.logService = logService;
+    }
+    async invoke(invocation, _countTokens, _progress, token) {
+        const parameters = invocation.parameters;
+        const {
+            title,
+            plan,
+            content,
+            actions,
+            canProvideFeedback
+        } = parameters;
+        if (!actions || actions.length === 0) {
+            throw ( new Error(( localize(10890, "At least one approval action must be provided."))));
+        }
+        const {
+            request
+        } = this.getRequest(invocation.context?.sessionResource, invocation.chatRequestId);
+        if (!request) {
+            this.logService.warn("[ReviewPlanTool] Missing chat context; returning rejected result.");
+            return this.toResult({
+                rejected: true
+            });
+        }
+        let planUri;
+        if (plan) {
+            try {
+                planUri = ( URI.parse(plan));
+            } catch {
+                try {
+                    planUri = URI.file(plan);
+                } catch {
+                    planUri = undefined;
+                }
+            }
+        }
+        const reviewData = ( new ChatPlanReviewData(title ?? ( localize(10891, "Plan summary")), content, actions, canProvideFeedback, planUri?.toJSON(), generateUuid()));
+        this.chatService.appendProgress(request, reviewData);
+        const result = await raceCancellation(reviewData.completion.p, token);
+        if (token.isCancellationRequested) {
+            reviewData.dismiss();
+            throw ( new CancellationError());
+        }
+        return this.toResult(result ?? {
+            rejected: true
+        });
+    }
+    async prepareToolInvocation(context, _token) {
+        const parameters = context.parameters;
+        if (!parameters.actions || parameters.actions.length === 0) {
+            throw ( new Error(( localize(10890, "At least one approval action must be provided."))));
+        }
+        return {
+            invocationMessage: ( new MarkdownString(( localize(10892, "Asking you to review the plan")))),
+            pastTenseMessage: ( new MarkdownString(( localize(10893, "Asked you to review the plan"))))
+        };
+    }
+    toResult(result) {
+        return {
+            content: [{
+                kind: "text",
+                value: JSON.stringify(result)
+            }]
+        };
+    }
+    getRequest(chatSessionResource, chatRequestId) {
+        if (!chatSessionResource) {
+            return {
+                request: undefined
+            };
+        }
+        const model = this.chatService.getSession(chatSessionResource);
+        if (!model) {
+            return {
+                request: undefined
+            };
+        }
+        let request;
+        if (chatRequestId) {
+            request = model.getRequests().find(r => r.id === chatRequestId);
+        }
+        if (!request) {
+            request = model.getRequests().at(-1);
+        }
+        return {
+            request
+        };
+    }
+};
+ReviewPlanTool = ( __decorate([( __param(0, IChatService)), ( __param(1, ILogService))], ReviewPlanTool));
+
+export { ReviewPlanTool, ReviewPlanToolData, ReviewPlanToolId, createReviewPlanToolData };

package/vscode/src/vs/workbench/contrib/chat/common/tools/builtinTools/runSubagentTool.d.ts

@@ -0,0 +1,73 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { type Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
+import { IChatAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents.service";
+import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service";
+import { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service";
+export interface IRunSubagentToolInputParams {
+    prompt: string;
+    description: string;
+    agentName?: string;
+    model?: string;
+}
+export declare const RUN_SUBAGENT_MAX_NESTING_DEPTH = 5;
+export declare class RunSubagentTool extends Disposable implements IToolImpl {
+    private readonly chatAgentService;
+    private readonly chatService;
+    private readonly languageModelToolsService;
+    private readonly languageModelsService;
+    private readonly logService;
+    private readonly configurationService;
+    private readonly promptsService;
+    private readonly instantiationService;
+    private readonly productService;
+    private readonly telemetryService;
+    static readonly Id = "runSubagent";
+    private readonly _onDidUpdateToolData;
+    readonly onDidUpdateToolData: Event<void>;
+    /** Hack to port data between prepare/invoke */
+    private readonly _resolvedModels;
+    /** Tracks the current subagent nesting depth per session to detect and limit recursion. */
+    private readonly _sessionDepth;
+    private _autoModelResolution;
+    constructor(chatAgentService: IChatAgentService, chatService: IChatService, languageModelToolsService: ILanguageModelToolsService, languageModelsService: ILanguageModelsService, logService: ILogService, configurationService: IConfigurationService, promptsService: IPromptsService, instantiationService: IInstantiationService, productService: IProductService, telemetryService: ITelemetryService);
+    getToolData(): IToolData;
+    invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
+    private getSubAgentByName;
+    /**
+     * Checks if a model exceeds the main model's cost tier based on multiplier.
+     * @returns An object with `exceeds: true` and a reason string if blocked, or `exceeds: false` if allowed.
+     */
+    private checkMultiplierConstraint;
+    /**
+     * Returns information about available models for error messages.
+     * Includes which models are unavailable due to multiplier restrictions.
+     */
+    private getAvailableModelsInfo;
+    /**
+     * Resolves the model to be used by a subagent.
+     * @param explicitModelQualifiedName Optional explicit model specified by the caller.
+     *        If provided and not found or not allowed, throws an error with available models.
+     * @param currentModeInstructions The current agent inherited when no subagent is requested.
+     *        Its configured model keeps precedence over the Auto default.
+     * @throws Error if the requested model is not found or exceeds the main model's cost tier.
+     */
+    private resolveSubagentModel;
+    private inheritedAgentHasModel;
+    private isSelectableForAgentMode;
+    private findEligibleAutoModelId;
+    private resolveAutoModelId;
+    private activateAutoModel;
+    prepareToolInvocation(context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+    private normalizeRequestedAgentName;
+    private getCurrentModeInstructions;
+    private validateSubagentAllowed;
+}