diff --git a/src/frontend/src/content/docs/app-host/hot-reload-and-watch.mdx b/src/frontend/src/content/docs/app-host/hot-reload-and-watch.mdx
index 8b65e3886..74a9329ce 100644
--- a/src/frontend/src/content/docs/app-host/hot-reload-and-watch.mdx
+++ b/src/frontend/src/content/docs/app-host/hot-reload-and-watch.mdx
@@ -178,6 +178,8 @@ Use an IDE workflow when you want the IDE to manage debugging or hot reload for
Use the Aspire extension for Visual Studio Code when you want VS Code to start the AppHost, attach debuggers, and manage supported resource debugging experiences. VS Code hot reload or framework-specific refresh behavior still belongs to the debugger or framework backing the resource, not to Aspire restart, rebuild, or watch behavior.
+Coding agents can call the extension's `aspire_hot_reload_status` language model tool to check whether C# Dev Kit Hot Reload can reach a resource. Having Hot Reload enabled doesn't mean that it applies to every resource. It applies only to .NET project resources that this VS Code window launched under the debugger. Resources started with **Run Without Debugging**, and resources in AppHosts that run outside the window, such as with `aspire start`, don't qualify. If an edit doesn't take effect, restart the resource first. If that doesn't help, rebuild and restart the AppHost. For the tool's inputs and outcomes, see the [language model tool reference](/get-started/aspire-vscode-extension/#language-model-tool-reference).
+
### Visual Studio
Use Visual Studio when you want its built-in debugging and hot reload experience for supported resources. Visual Studio can run and debug Aspire apps, but IDE hot reload is still separate from Aspire restart, rebuild, and watch behavior.
diff --git a/src/frontend/src/content/docs/get-started/aspire-vscode-extension.mdx b/src/frontend/src/content/docs/get-started/aspire-vscode-extension.mdx
index f618809aa..7776831ca 100644
--- a/src/frontend/src/content/docs/get-started/aspire-vscode-extension.mdx
+++ b/src/frontend/src/content/docs/get-started/aspire-vscode-extension.mdx
@@ -83,7 +83,7 @@ When you create or initialize an Aspire project, you can choose to configure AI
## Let coding agents use Aspire language model tools
-The Aspire extension provides VS Code language model tools that let coding agents manage AppHosts, inspect resources, and attach debuggers. Aspire 13.6 added the start and stop tools; Aspire 17.0 added the rest:
+The Aspire extension provides VS Code language model tools that let coding agents manage AppHosts, inspect resources, and attach debuggers. Aspire 13.6 added the start and stop tools; Aspire 17.0 added the rest. The resource debug tool requires Aspire extension v1.25.0 or later, and the other 17.0 tools require v1.24.0 or later:
| Tool | Chat reference | Action |
| ------------------------------- | ----------------------------- | ----------------------------------------------------------------------------------------------------------------- |
@@ -118,7 +118,7 @@ The start tool accepts these inputs:
| `isolated` | No | Use `true` for randomized ports and isolated user secrets or `false` to disable isolation. Linked Git worktrees use isolation when omitted. |
| `launchProfile` | No | The exact profile name from the AppHost's `launchSettings.json` file. |
-The tools accept only buildable AppHosts returned by the extension's discovery service, not arbitrary filesystem paths supplied by an agent. If a selector is unknown or ambiguous, the result includes `knownAppHosts` so the agent can choose a discovered target. Multi-root workspaces use folder-qualified selectors.
+The tools accept only buildable AppHosts returned by the extension's discovery service, not arbitrary filesystem paths supplied by an agent. If a start or stop selector is unknown or ambiguous, the result includes `knownAppHosts` so the agent can choose a discovered target. Multi-root workspaces use folder-qualified selectors.
Before starting, the extension checks its own sessions and running AppHosts to avoid duplicate launches. A successful new launch reports the effective isolation setting. Results for an AppHost that was already starting or running omit that setting because the tool didn't create a new process.
@@ -132,6 +132,123 @@ The workspace must be trusted, and the VS Code host must support the language mo
See [Use AI coding agents with Aspire](/get-started/ai-coding-agents/).
+### Language model tool reference
+
+The tools in this reference return a JSON result with `tool`, `success`, and `outcome` fields. Besides the outcomes listed for each tool, each of these tools can report `workspaceNotTrusted`, `invalidInput`, cancellation, or a failure. Expand a tool to see its inputs and main outcomes.
+
+
+aspire_resource_debug (extension v1.25.0 or later)
+
+| Input | Required | Description |
+| -------------- | -------- | ------------------------------------------------------------------ |
+| `appHostPath` | Yes | The workspace-relative path of a discovered AppHost. |
+| `resourceName` | Yes | The name of the resource to attach to. |
+| `strategy` | No | `auto` (default) or `attach`. Both attach to the running resource. |
+
+The confirmation names the resource and the AppHost, and it's bound to the AppHost that was resolved when you approved it. If the path points to a different AppHost before the debugger attaches, the tool refuses the operation. Retry after discovery finds the intended AppHost, and confirm again.
+
+| Outcome | Meaning |
+| ------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `started` | The debugger attached. `provider` is `dotnet` or `go`. |
+| `alreadyDebugging` | A debugger is already attached to the resource. No new session starts. |
+| `resourceNotRunning` | The resource isn't running. The tool never starts or restarts a resource. |
+| `debuggerExtensionMissing` | A required debugger extension is missing or disabled. `debuggerExtensions` lists each extension's `id` and `label`. Install or enable it, and then retry. |
+| `unsupportedResource` | The resource isn't a .NET project or Go resource that Aspire can attach to. |
+| `resourceNotFound` | The AppHost has no resource with that name. |
+| `appHostNotFound` | The AppHost isn't running, or Aspire can't match it to exactly one running AppHost. |
+| `unknownAppHost`, `ambiguousAppHost` | `appHostPath` doesn't match exactly one discovered AppHost. |
+| `error` | The attach failed. `errorKind` identifies the failing step, such as `debuggerStartDeclined` or `debuggerStartFailed`. |
+
+After installing or enabling a missing debugger extension, the AppHost doesn't need to restart. For attach requirements and limitations, see [Attach a debugger to a running resource](#attach-a-debugger-to-a-running-resource).
+
+
+
+
+aspire_debug_session_status
+
+| Input | Required | Description |
+| -------------- | -------- | ----------------------------------------------------------------------- |
+| `appHostPath` | Yes | The workspace-relative path of a discovered AppHost. |
+| `resourceName` | No | A resource to report on. When omitted, the tool reports on the AppHost. |
+
+| Outcome | Meaning |
+| --------------------------------------- | -------------------------------------------------------------------------- |
+| `running`, `starting`, `stopping` | The state of the AppHost, or of the editor session that runs the resource. |
+| `notDebugging` | The AppHost isn't running, or no editor session runs the resource. |
+| `multipleSessions` | More than one editor session matches. |
+| `resourceNotFound`, `resourceAmbiguous` | The resource name matches no resource, or more than one. |
+
+The result's `controller` is `editor` when this VS Code window runs the AppHost, or `external` when it runs elsewhere, such as from `aspire start`. `mode` is `run`, `debug`, or `other`. Resource results also include the resource's type, state, health, exit code, and source.
+
+
+
+
+aspire_list_debug_sessions
+
+This tool has no inputs. It returns `sessionsFound` with the `appHost`, `state`, `mode`, and `controller` of each AppHost that this VS Code window runs, or `noSessions` when there are none. The list includes up to 20 AppHosts. When more are active, the result includes `truncated: true`.
+
+
+
+
+aspire_explain_launch_failure
+
+The only input is the required `appHostPath`.
+
+The extension keeps only the latest launch failure for each AppHost, in memory, for 30 minutes. It stores a sanitized summary instead of raw output. A `failureFound` result includes:
+
+- `stage`: where the launch failed. The value is `discovery`, `validation`, `cliLaunch`, `build`, `dcpStartup`, `debugSession`, or `dashboard`.
+- `category`: the kind of failure, such as `buildFailed`, `missingDependency`, `cliUnavailable`, `portConflict`, `permissionDenied`, or `timeout`.
+- `recommendedActions`: fixed actions for the category, such as `fixBuildErrors`, `checkDependencies`, `installAspireCli`, `freeRequiredPort`, `checkPermissions`, `retryLaunch`, or `checkAspireOutput`.
+- `controller`, `mode`, and `exitCodeBucket`, which is `none`, `zero`, `one`, `signal`, or `other`.
+
+The outcome is `noRecordedFailure` when no failure is recorded for the AppHost. The tool never returns compiler errors, logs, or other raw output. To read them, open the **Output** panel on the **Aspire Extension** channel and check the [CLI logs](/get-started/troubleshooting/#cli-logs).
+
+
+
+
+aspire_hot_reload_status
+
+| Input | Required | Description |
+| -------------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `resourceName` | No | The resource to check. When omitted, the tool answers only if exactly one resource runs in an editor session. |
+| `appHostPath` | No | The AppHost to check. When omitted, the tool checks every AppHost that this VS Code window runs. Use it to disambiguate a resource name. |
+
+The result separates two questions:
+
+- `hotReloadEnabled` is `true` when C# Dev Kit is installed and its Hot Reload setting, `csharp.experimental.debug.hotReload`, is enabled. Enabled doesn't mean that Hot Reload can reach the resource.
+- `outcome` is `applicable` only when Hot Reload is enabled and the resource is a .NET project resource that this VS Code window launched under the debugger, after the debug session has started. Resources started with **Run Without Debugging** and resources in other languages report `notApplicable`.
+
+The `evidence` field explains the answer. The `fallback` field is always `restartResource` and then `rebuildAndRestartAppHost`: if an edit doesn't take effect, restart the resource first, and rebuild and restart the AppHost only if that doesn't help. The tool only reports. It never applies or verifies an edit.
+
+Other outcomes:
+
+| Outcome | Meaning |
+| --------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
+| `noEditorControlledResource` | No editor session runs a resource in scope, or `appHostPath` names an AppHost that runs outside this VS Code window. |
+| `appHostNotRunning` | The AppHost named by `appHostPath` isn't running. |
+| `resourceNotFound`, `resourceAmbiguous` | The resource name matches no resource, or more than one. Supply `appHostPath` to disambiguate. |
+| `tooManyActiveAppHosts` | Too many AppHosts are active to check them all. Supply `appHostPath`. |
+
+
+
+
+aspire_open_dashboard
+
+The only input is the required `appHostPath`. The tool doesn't ask for confirmation.
+
+The tool opens the dashboard only for a running AppHost that this VS Code window started. It uses the `dashboardBrowser` value from the launch configuration or the **Aspire: Dashboard Browser** setting (`aspire.dashboardBrowser`). When neither selects a browser, the dashboard opens in your external browser. An `opened` result reports the `presentation` that was used. The tool never returns the dashboard URL, because the URL contains a login token.
+
+Other outcomes include `dashboardUnavailable` and `appHostNotRunning`.
+
+
+
+
+aspire_open_output
+
+This tool has no inputs. After you confirm, it opens the **Output** panel on the **Aspire Extension** channel and returns `opened`. It doesn't read the channel or return its contents.
+
+
+
## Live editor integration
When an AppHost is running, the extension paints live state directly into your editor.
@@ -161,7 +278,7 @@ When no AppHost is detected in the workspace, the view's empty state offers a **
This makes project onboarding discoverable directly from the Aspire pane without requiring the Command Palette.
:::
-Each resource shows its type, state, health summary, and exit code, plus a health-aware icon and a markdown tooltip listing endpoint URLs. Resources with health checks expose an expandable **Health Checks** group; use **Expand all** on the AppHost item to open everything at once. You can right-click a resource to start, stop, or restart it, view its logs, run resource-specific commands, open the dashboard, open the resource's source with **Open resource source** (for resources backed by a source file or project), or open an interactive terminal session (for resources configured with [`WithTerminal()`](/app-host/with-terminal/)).
+Each resource shows its type, state, health summary, and exit code, plus a health-aware icon and a markdown tooltip listing endpoint URLs. Resources with health checks expose an expandable **Health Checks** group; use **Expand all** on the AppHost item to open everything at once. You can right-click a resource to start, stop, or restart it, view its logs, run resource-specific commands, open the dashboard, open the resource's source with **Open resource source** (for resources backed by a source file or project), or open an interactive terminal session (for resources configured with [`WithTerminal()`](/app-host/with-terminal/)). Running .NET project and Go resources also show **Attach debugger**. For details, see [Attach a debugger to a running resource](#attach-a-debugger-to-a-running-resource).
Expand an idle AppHost or open its right-click menu to select **Deploy AppHost**, **Publish AppHost**, **Run pipeline step**, or **Debug pipeline step**. The pipeline actions prompt you to choose a step. Wait for the operation to finish before starting another for the same AppHost. For launch configuration options, see [Run, debug, and deploy](#run-debug-and-deploy).
@@ -274,6 +391,54 @@ Finally, you can specify `env` and `args` to set environment variables and comma
For more information, see [Aspire publishing and deployment overview](/deployment/deploy-with-aspire/).
+## Attach a debugger to a running resource
+
+You can attach the VS Code debugger to a .NET project or Go resource that's already running. Attaching requires Aspire extension v1.25.0 or later and a trusted workspace.
+
+Attach works for resources that run without a debugger. That includes resources started with **Run Without Debugging** in VS Code and resources in an AppHost started from the CLI, such as with [`aspire start`](/reference/cli/commands/aspire-start/).
+
+Install the debugger extension for the resource's language first:
+
+- .NET project resources need the [C#](https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.csharp) extension (`ms-dotnettools.csharp`). [C# Dev Kit](https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.csdevkit) installs it for you.
+- Go resources need the [Go](https://marketplace.visualstudio.com/items?itemName=golang.go) extension (`golang.go`) and [Delve](https://github.com/go-delve/delve). They also need the Aspire 17.0 Go hosting integration. For build flag guidance, see [Attach to a running Go resource](/integrations/frameworks/go/go-host/#attach-to-a-running-go-resource-vs-code).
+
+To attach a debugger:
+
+
+
+1. In the Aspire view, expand the running AppHost.
+1. Right-click a running .NET project or Go resource and select **Attach debugger**.
+1. Wait for the **Attaching debugger** progress notification to finish. To stop attaching, select **Cancel** on the notification.
+1. Set breakpoints and debug as usual. To detach, select **Disconnect** on the debug toolbar.
+
+
+
+The debugger attaches to the application process, not to the `dotnet run`, `dotnet watch`, or `go run` process that launched it. Attaching and detaching don't restart the resource or the AppHost, and attach never starts a resource that isn't running. If a debugger is already attached to the resource, VS Code reports that and doesn't start another session.
+
+If the required debugger extension is missing or disabled, VS Code shows a notification with an **Open Extensions** action. Install or enable the extension, and then select **Attach debugger** again. The AppHost doesn't need to restart.
+
+Coding agents can attach the same way with the `aspire_resource_debug` tool (`#aspireDebugResource`). For its inputs and outcomes, see the [language model tool reference](#language-model-tool-reference).
+
+Attach has these limitations:
+
+- You can't attach to a .NET resource launched by `dotnet watch` when arguments follow its first `--`. SDK versions interpret that separator differently, so Aspire declines instead of guessing which build output is running. The resource keeps running, and `dotnet run` launches aren't affected.
+- Go resources configured with `WithDelveServer` don't offer **Attach debugger**. Connect your debugger to the [headless Delve server](/integrations/frameworks/go/go-host/#headless-delve-server) instead.
+- Coding agents can't detach a debugger because there's no detach tool. Detach from the debug toolbar instead. For the feature request, see [microsoft/aspire#22154](https://github.com/microsoft/aspire/issues/22154).
+
+:::note[Go attach permissions on Linux and macOS]
+On Linux, Delve uses `ptrace` to attach. Many distributions, including Ubuntu, set `kernel.yama.ptrace_scope` to `1` by default, which only lets a process trace its own descendants. Delve didn't launch the Go resource, so the attach fails with this setting.
+
+To allow attach until the next reboot, run:
+
+```bash title="Terminal"
+sudo sysctl -w kernel.yama.ptrace_scope=0
+```
+
+A value of `0` lets any process trace other processes that run as the same user, so a compromised process could read data from them. Only make this change on a development machine where you accept that risk. Otherwise, press to start the AppHost with debugging, so that the Go extension launches the resource under Delve.
+
+On macOS, if your account isn't in the `_developer` group, macOS might ask you to authorize Developer Tools Access when Delve attaches.
+:::
+
## Language coverage
The extension detects each resource's language and attaches the right debugger:
@@ -290,6 +455,8 @@ The extension detects each resource's language and attaches the right debugger:
For TypeScript or JavaScript Azure Functions apps, the Aspire extension reserves a loopback Node inspector port until task launch, starts Azure Functions Core Tools as a task, and attaches VS Code's built-in `pwa-node` debugger. Stopping the Aspire debug session also stops the Functions task. The Azure Functions VS Code extension isn't required for these apps.
+To attach the debugger to a .NET project or Go resource that's already running, see [Attach a debugger to a running resource](#attach-a-debugger-to-a-running-resource).
+
## Feedback and issues
Found a bug or have an idea? File it on the [microsoft/aspire](https://github.com/microsoft/aspire/issues) repo:
diff --git a/src/frontend/src/content/docs/integrations/frameworks/go/go-host.mdx b/src/frontend/src/content/docs/integrations/frameworks/go/go-host.mdx
index 33ff47469..0a4ac9d2b 100644
--- a/src/frontend/src/content/docs/integrations/frameworks/go/go-host.mdx
+++ b/src/frontend/src/content/docs/integrations/frameworks/go/go-host.mdx
@@ -467,6 +467,65 @@ The Aspire VS Code extension detects the `golang.go` extension and, when you sta
When is applied to a resource, VS Code debugging is disabled for that resource. The two modes are mutually exclusive: `WithDelveServer` starts a headless Delve server that an IDE attaches to manually, while VS Code debugging hands control of launch and build to the `golang.go` extension.
:::
+### Attach to a running Go resource (VS Code)
+
+Starting with Aspire 17.0, you can attach the VS Code debugger to a Go resource that's already running. Attach requires Aspire extension v1.25.0 or later, the `golang.go` extension, and Delve (`dlv`).
+
+Start the AppHost with **Run Without Debugging** or `aspire start`. In both cases, Aspire runs the resource with `go run`. Then right-click the running Go resource in the Aspire view and select **Attach debugger**. The debugger attaches to your app process, not to `go run`. Attaching and detaching don't restart the resource or the AppHost.
+
+Source breakpoints need the symbols and DWARF debug information in your binary. Local `AddGoApp` / `addGoApp` launches keep this information by default, including under `aspire start`, so no opt-in is required. Aspire preserves other linker options from `GOFLAGS`, but explicit `-s` and `-w` flags take precedence. Published Docker builds keep the linker flags that you configure.
+
+When you set custom `ldFlags`, include `-s=false -w=false`, and don't pass `-s` or `-w`. For example, the `-s -w` flags in [Configure build options](#configure-build-options) strip the information that source breakpoints need. For predictable stepping, also set `gcFlags: "all=-N -l"` to turn off compiler optimizations and inlining:
+
+
+
+
+```csharp title="AppHost.cs"
+var builder = DistributedApplication.CreateBuilder(args);
+
+var api = builder.AddGoApp(
+ name: "api",
+ appDirectory: "./api",
+ ldFlags: "-X main.version=1.2.3 -s=false -w=false",
+ gcFlags: "all=-N -l");
+
+builder.Build().Run();
+```
+
+
+
+
+```typescript title="apphost.mts"
+import { createBuilder } from './.aspire/modules/aspire.mjs';
+
+const builder = await createBuilder();
+
+const api = await builder.addGoApp('api', './api', {
+ ldFlags: '-X main.version=1.2.3 -s=false -w=false',
+ gcFlags: 'all=-N -l',
+});
+
+await builder.build().run();
+```
+
+
+
+
+```go title="apphost.go"
+builder.AddGoApp("api", "./api",
+ aspire.AddGoAppLdFlags("-X main.version=1.2.3 -s=false -w=false"),
+ aspire.AddGoAppGcFlags("all=-N -l"))
+```
+
+
+
+
+Attach isn't available for resources that use `WithDelveServer` / `withDelveServer`, because those resources run under a [headless Delve server](#headless-delve-server) instead.
+
+
+ For attach steps, troubleshooting, and Linux and macOS permission requirements, see [Attach a debugger to a running resource](/get-started/aspire-vscode-extension/#attach-a-debugger-to-a-running-resource).
+
+
### Headless Delve server
For GoLand, VS Code attach mode, or another Delve-compatible client, use `WithDelveServer` / `withDelveServer`. This replaces the application command with a headless Delve server, such as `dlv --headless=true --listen=127.0.0.1:2345 --api-version=2 debug .`.
diff --git a/src/frontend/src/content/docs/reference/cli/commands/aspire-describe.mdx b/src/frontend/src/content/docs/reference/cli/commands/aspire-describe.mdx
index 267444ac7..6b2298443 100644
--- a/src/frontend/src/content/docs/reference/cli/commands/aspire-describe.mdx
+++ b/src/frontend/src/content/docs/reference/cli/commands/aspire-describe.mdx
@@ -69,6 +69,13 @@ The following options are available:
`Mermaid` output is an unfenced `flowchart LR` diagram with deterministic node identifiers, escaped resource labels, and directed relationships based on resource references. Parameters, endpoints, configuration values, and resource state are not exported, and references outside the selected resource set are omitted. Progress and informational messages are written to stderr, so redirecting stdout captures only the diagram source. `--follow` isn't supported with `Mermaid` output. Each invocation captures one snapshot.
+ Starting with Aspire 17.0, the `properties` object of a .NET project resource describes how the project was launched:
+
+ - `project.launchCommand` is `run` for `dotnet run`, `watch` for `dotnet watch`, `ide` for an IDE-managed launch, or `direct` when Aspire builds the project and then starts the built app directly. The value is `null` when the launch command can't be classified.
+ - `project.configuration` and `project.targetFramework` report the build configuration and target framework, when they're known.
+
+ For `ide` and `direct` launches, `executable.pid` identifies the app process rather than a `dotnet run` or `dotnet watch` launcher.
+
-
-
diff --git a/src/frontend/src/content/docs/whats-new/aspire-17.mdx b/src/frontend/src/content/docs/whats-new/aspire-17.mdx
index 179026c9c..b1ef74f2a 100644
--- a/src/frontend/src/content/docs/whats-new/aspire-17.mdx
+++ b/src/frontend/src/content/docs/whats-new/aspire-17.mdx
@@ -25,6 +25,7 @@ This release introduces:
- A redesigned dashboard with a resource table home page, a Terminals page, Mermaid export, and first-run telemetry guidance.
- A CLI that adds shell completion, environment-specific secrets, team template, integration, and skill sources, plus a preview tray companion.
- Generally available Go AppHosts with templates, debugging, `aspire doctor` checks, and SDK export.
+- A VS Code extension that attaches the debugger to running .NET and Go resources, plus new language model tools for coding agents.
- AppHost updates including optional parameters, browser-origin references, TypeScript Azure Functions, and graduated APIs.
- New Microsoft Entra ID and Azure API Management integrations, plus Azure AI client packages built on the OpenAI SDK.
- Stable Kubernetes deployment with Helm 4, AKS Standard tier and OS SKU selection, and cert-manager External Account Binding.
@@ -380,6 +381,20 @@ Throughout aspire.dev, the landing page, AppHost builder, and hosting integratio
helpers, and error handling.
+## 🧰 Visual Studio Code extension
+
+The Aspire extension for VS Code can attach a debugger to resources that are already running, and it gives coding agents new tools to inspect your app:
+
+- **Attach debugger**: Right-click a running .NET project or Go resource in the Aspire view and select **Attach debugger**. Attach works for resources started with **Run Without Debugging** or `aspire start`, and it doesn't restart the resource. Agents can request the same action with the `aspire_resource_debug` language model tool. This feature requires extension v1.25.0 or later, and Go resources also require Aspire 17.0 hosting.
+- **Editor-assistance tools**: Six new language model tools let agents check debug session status, list the AppHosts that VS Code runs, explain the latest launch failure, and check whether Hot Reload applies to a resource. Agents can also open the dashboard and the Aspire output channel. These tools require extension v1.24.0 or later.
+- **Safe results**: The tools return summarized state instead of raw logs, compiler output, environment variables, or dashboard login URLs.
+
+
+ See [Attach a debugger to a running resource](/get-started/aspire-vscode-extension/#attach-a-debugger-to-a-running-resource),
+ the [language model tool reference](/get-started/aspire-vscode-extension/#language-model-tool-reference),
+ and [Attach to a running Go resource](/integrations/frameworks/go/go-host/#attach-to-a-running-go-resource-vs-code).
+
+
## 🧩 AppHost updates
Aspire 17.0 raises its minimum supported .NET version to **.NET 10**. Review your AppHost and Aspire package target frameworks before updating. This requirement doesn't mean every workload orchestrated by Aspire must target .NET 10.