@@ -132,6 +132,97 @@
         "language": "powershell"
       }
     ],
+    "languageModelTools": [
+      {
+        "name": "powershell_get_command",
+        "toolReferenceName": "getPowerShellCommand",
+        "displayName": "Get PowerShell Command",
+        "modelDescription": "Get the commands (cmdlets, functions, and scripts) available in the user's active PowerShell session, scoped by name and/or module. You must provide a 'name' and/or 'module' filter (at least one is required). Returns each matching command's name, module, default parameter set, and parameter names. Use this to discover the exact name, module, and parameters of a PowerShell command instead of guessing.",
+        "userDescription": "Lists commands available in the active PowerShell session.",
+        "canBeReferencedInPrompt": true,
+        "icon": "$(symbol-method)",
+        "tags": [
+          "powershell"
+        ],
+        "inputSchema": {
+          "type": "object",
+          "properties": {
+            "name": {
+              "type": "string",
+              "description": "Only return commands whose name matches this value (supports wildcards; bare text is matched as a substring), e.g. 'Get-ChildItem', 'ChildItem', or 'Get-*'. Provide this and/or 'module'."
+            },
+            "module": {
+              "type": "string",
+              "description": "Only return commands from this module (supports wildcards), e.g. 'Microsoft.PowerShell.Management'. Provide this and/or 'name'."
+            }
+          }
+        }
+      },
+      {
+        "name": "powershell_get_help",
+        "toolReferenceName": "getPowerShellHelp",
+        "displayName": "Get PowerShell Help",
+        "modelDescription": "Get the full help (Get-Help -Full) for a specific PowerShell command from the user's active session, including synopsis, syntax, parameter descriptions, and examples. Use this to ground answers about how a PowerShell command works and what parameters it accepts, instead of guessing.",
+        "userDescription": "Retrieves the full help for a PowerShell command.",
+        "canBeReferencedInPrompt": true,
+        "icon": "$(question)",
+        "tags": [
+          "powershell"
+        ],
+        "inputSchema": {
+          "type": "object",
+          "properties": {
+            "command": {
+              "type": "string",
+              "description": "The name of the PowerShell command to get help for, e.g. 'Get-ChildItem'."
+            }
+          },
+          "required": [
+            "command"
+          ]
+        }
+      },
+      {
+        "name": "powershell_get_environment",
+        "toolReferenceName": "getPowerShellEnvironment",
+        "displayName": "Get PowerShell Environment",
+        "modelDescription": "Get details about the user's active PowerShell session, including the PowerShell version, edition (Core or Desktop), and process architecture. Use this before constructing version- or edition-specific PowerShell so that suggestions match the user's actual environment.",
+        "userDescription": "Reports the active PowerShell version, edition, and architecture.",
+        "canBeReferencedInPrompt": true,
+        "icon": "$(terminal-powershell)",
+        "tags": [
+          "powershell"
+        ],
+        "inputSchema": {
+          "type": "object",
+          "properties": {}
+        }
+      },
+      {
+        "name": "powershell_expand_alias",
+        "toolReferenceName": "expandPowerShellAlias",
+        "displayName": "Expand PowerShell Aliases",
+        "modelDescription": "Expand the aliases in a PowerShell script to their full command names (for example 'gci' becomes 'Get-ChildItem' and '?' becomes 'Where-Object') using the user's active PowerShell session. Use this to normalize or clarify aliased PowerShell before explaining or editing it.",
+        "userDescription": "Expands aliases in a PowerShell script to full command names.",
+        "canBeReferencedInPrompt": true,
+        "icon": "$(symbol-string)",
+        "tags": [
+          "powershell"
+        ],
+        "inputSchema": {
+          "type": "object",
+          "properties": {
+            "text": {
+              "type": "string",
+              "description": "The PowerShell script text whose aliases should be expanded."
+            }
+          },
+          "required": [
+            "text"
+          ]
+        }
+      }
+    ],
     "viewsContainers": {
       "activitybar": [
         {
 
@@ -20,6 +20,7 @@ import {
 import { GetCommandsFeature } from "./features/GetCommands";
 import { HelpCompletionFeature } from "./features/HelpCompletion";
 import { ISECompatibilityFeature } from "./features/ISECompatibility";
+import { LanguageModelToolsFeature } from "./features/LanguageModelTools";
 import { OpenInISEFeature } from "./features/OpenInISE";
 import { PesterTestsFeature } from "./features/PesterTests";
 import { RemoteFilesFeature } from "./features/RemoteFiles";
@@ -193,6 +194,7 @@ export async function activate(
         new RemoteFilesFeature(),
         new DebugSessionFeature(context, sessionManager, logger),
         new HelpCompletionFeature(),
+        new LanguageModelToolsFeature(),
     ];
 
     sessionManager.setLanguageClientConsumers(languageClientConsumers);
 
@@ -0,0 +1,185 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import * as vscode from "vscode";
+import type { LanguageClient } from "vscode-languageclient/node";
+import { LanguageClientConsumer } from "../languageClientConsumer";
+import { PowerShellVersionRequestType } from "../session";
+import { ExpandAliasRequestType } from "./ExpandAlias";
+import { GetCommandRequestType } from "./GetCommands";
+import { ShowHelpRequestType } from "./ShowHelp";
+
+function toToolResult(text: string): vscode.LanguageModelToolResult {
+    return new vscode.LanguageModelToolResult([
+        new vscode.LanguageModelTextPart(text),
+    ]);
+}
+
+interface IGetCommandInput {
+    name?: string;
+    module?: string;
+}
+
+// Lists commands available in the active PowerShell session (backed by the
+// existing powerShell/getCommand request), scoped by name and/or module. At
+// least one filter is required so we never serialize the entire command table,
+// which is prohibitively expensive.
+class GetCommandTool implements vscode.LanguageModelTool<IGetCommandInput> {
+    public async invoke(
+        options: vscode.LanguageModelToolInvocationOptions<IGetCommandInput>,
+        token: vscode.CancellationToken,
+    ): Promise<vscode.LanguageModelToolResult> {
+        const name = options.input.name?.trim();
+        const module = options.input.module?.trim();
+
+        if (!name && !module) {
+            return toToolResult(
+                "Provide a 'name' and/or 'module' filter to look up PowerShell commands.",
+            );
+        }
+
+        // Get-Command -Name matches literally, so wrap bare text in wildcards to
+        // get intuitive "contains" matching while leaving explicit wildcards
+        // (and module names) untouched.
+        const namePattern = name && !/[*?[\]]/.test(name) ? `*${name}*` : name;
+
+        const client = await LanguageClientConsumer.getLanguageClient();
+        const matches = await client.sendRequest(
+            GetCommandRequestType,
+            {
+                name: namePattern,
+                module,
+            },
+            token,
+        );
+
+        if (matches.length === 0) {
+            return toToolResult(
+                "No matching PowerShell commands were found in the current session.",
+            );
+        }
+
+        const limit = 50;
+        const limited = matches.slice(0, limit);
+        const blocks = limited.map((command) => {
+            const parameters = Object.keys(command.parameters ?? {});
+            return [
+                `Name: ${command.name}`,
+                `Module: ${command.moduleName || "(none)"}`,
+                `DefaultParameterSet: ${command.defaultParameterSet ?? "(none)"}`,
+                `Parameters: ${parameters.length > 0 ? parameters.join(", ") : "(none)"}`,
+            ].join("\n");
+        });
+
+        let output = blocks.join("\n\n");
+        if (matches.length > limit) {
+            output += `\n\n(Showing ${limit} of ${matches.length} matching commands. Provide a more specific name or module filter to narrow the results.)`;
+        }
+
+        return toToolResult(output);
+    }
+}
+
+interface IGetHelpInput {
+    command: string;
+}
+
+// A tool that takes no input.
+type EmptyInput = Record<string, never>;
+
+// Returns the full Get-Help text for a command (backed by the powerShell/showHelp request).
+class GetHelpTool implements vscode.LanguageModelTool<IGetHelpInput> {
+    public async invoke(
+        options: vscode.LanguageModelToolInvocationOptions<IGetHelpInput>,
+        token: vscode.CancellationToken,
+    ): Promise<vscode.LanguageModelToolResult> {
+        const client = await LanguageClientConsumer.getLanguageClient();
+        const result = await client.sendRequest(
+            ShowHelpRequestType,
+            {
+                text: options.input.command,
+            },
+            token,
+        );
+        return toToolResult(
+            result.helpText || `No help found for '${options.input.command}'.`,
+        );
+    }
+}
+
+// Reports the active PowerShell version/edition/architecture (backed by powerShell/getVersion).
+class GetEnvironmentTool implements vscode.LanguageModelTool<EmptyInput> {
+    public async invoke(
+        _options: vscode.LanguageModelToolInvocationOptions<EmptyInput>,
+        token: vscode.CancellationToken,
+    ): Promise<vscode.LanguageModelToolResult> {
+        const client = await LanguageClientConsumer.getLanguageClient();
+        const version = await client.sendRequest(
+            PowerShellVersionRequestType,
+            token,
+        );
+        const output = [
+            `PowerShell version: ${version.version}`,
+            `Edition: ${version.edition}`,
+            `Architecture: ${version.architecture}`,
+            `Commit: ${version.commit}`,
+        ].join("\n");
+        return toToolResult(output);
+    }
+}
+
+interface IExpandAliasInput {
+    text: string;
+}
+
+// Expands aliases in a script to full command names (backed by powerShell/expandAlias).
+class ExpandAliasTool implements vscode.LanguageModelTool<IExpandAliasInput> {
+    public async invoke(
+        options: vscode.LanguageModelToolInvocationOptions<IExpandAliasInput>,
+        token: vscode.CancellationToken,
+    ): Promise<vscode.LanguageModelToolResult> {
+        const client = await LanguageClientConsumer.getLanguageClient();
+        const result = await client.sendRequest(
+            ExpandAliasRequestType,
+            {
+                text: options.input.text,
+            },
+            token,
+        );
+        return toToolResult(result.text);
+    }
+}
+
+export class LanguageModelToolsFeature extends LanguageClientConsumer {
+    private tools: vscode.Disposable[];
+
+    constructor() {
+        super();
+        this.tools = [
+            vscode.lm.registerTool(
+                "powershell_get_command",
+                new GetCommandTool(),
+            ),
+            vscode.lm.registerTool("powershell_get_help", new GetHelpTool()),
+            vscode.lm.registerTool(
+                "powershell_get_environment",
+                new GetEnvironmentTool(),
+            ),
+            vscode.lm.registerTool(
+                "powershell_expand_alias",
+                new ExpandAliasTool(),
+            ),
+        ];
+    }
+
+    public override onLanguageClientSet(
+        _languageClient: LanguageClient,
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+    ): void {}
+
+    public dispose(): void {
+        for (const tool of this.tools) {
+            tool.dispose();
+        }
+    }
+}
@@ -0,0 +1,86 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import * as assert from "assert";
+import * as vscode from "vscode";
+import utils = require("../utils");
+
+function getToolResultText(result: vscode.LanguageModelToolResult): string {
+    return result.content
+        .filter(
+            (part): part is vscode.LanguageModelTextPart =>
+                part instanceof vscode.LanguageModelTextPart,
+        )
+        .map((part) => part.value)
+        .join("");
+}
+
+async function invokeTool(name: string, input: object): Promise<string> {
+    const result = await vscode.lm.invokeTool(name, {
+        input,
+        toolInvocationToken: undefined,
+    });
+    return getToolResultText(result);
+}
+
+describe("Language model tools feature", function () {
+    before(async function () {
+        await utils.ensureEditorServicesIsConnected();
+    });
+
+    const expectedTools = [
+        "powershell_get_command",
+        "powershell_get_help",
+        "powershell_get_environment",
+        "powershell_expand_alias",
+    ];
+
+    for (const name of expectedTools) {
+        it(`Registers the ${name} tool`, function () {
+            assert.ok(
+                vscode.lm.tools.some((tool) => tool.name === name),
+                `Expected tool '${name}' to be registered.`,
+            );
+        });
+    }
+
+    it("Gets the PowerShell environment", async function () {
+        const text = await invokeTool("powershell_get_environment", {});
+        assert.match(text, /PowerShell version:/);
+        assert.match(text, /Edition:/);
+    });
+
+    it("Finds a command by name", async function () {
+        const text = await invokeTool("powershell_get_command", {
+            name: "Get-Command",
+        });
+        assert.match(text, /Get-Command/);
+    });
+
+    it("Finds commands by module", async function () {
+        const text = await invokeTool("powershell_get_command", {
+            module: "Microsoft.PowerShell.Management",
+        });
+        assert.match(text, /Microsoft\.PowerShell\.Management/);
+    });
+
+    it("Requires a filter for get_command", async function () {
+        const text = await invokeTool("powershell_get_command", {});
+        assert.match(text, /Provide a 'name' and\/or 'module' filter/);
+    });
+
+    it("Gets help for a command", async function () {
+        const text = await invokeTool("powershell_get_help", {
+            command: "Get-Command",
+        });
+        assert.ok(text.length > 0, "Expected non-empty help text.");
+        assert.match(text, /Get-Command/);
+    });
+
+    it("Expands an alias", async function () {
+        const text = await invokeTool("powershell_expand_alias", {
+            text: "gci",
+        });
+        assert.match(text, /Get-ChildItem/);
+    });
+});