appimage

Onboarding, SSH

HOW_TO_CONTRIBUTE.md

@@ -12,11 +12,9 @@ There are a few ways to contribute:
 
 ### Codebase Guide
 
-We [highly recommend reading this](https://github.com/microsoft/vscode/wiki/Source-Code-Organization) article on VSCode's sourcecode organization too. Void's codebase is pretty simple when you know what a service is and what `browser/` and `common/` mean, and the article covers all the jargon.
+We [highly recommend reading this](https://github.com/voideditor/void/blob/main/VOID_CODEBASE_GUIDE.md) guide that we put together on Void's sourcecode if you'd like to contribute!
 
-<!-- ADD BLOG HERE
-We wrote a [guide to working in VSCode].
--->
+The repo is not as intimidating as it first seems if you read the guide!
 
 Most of Void's code lives in the folder `src/vs/workbench/contrib/void/`.
 
@@ -90,7 +88,7 @@ Alternatively, if you want to build Void from the terminal, instead of pressing
 - If you get `"TypeError: Failed to fetch dynamically imported module"`, make sure all imports end with `.js`.
 - If you see missing styles, wait a few seconds and then reload.
 - If you have any questions, feel free to [submit an issue](https://github.com/voideditor/void/issues/new). You can also refer to VSCode's complete [How to Contribute](https://github.com/microsoft/vscode/wiki/How-to-Contribute) page.
-
+- If you get errors like `npm error libtool:   error: unrecognised option: '-static'`, make sure you have GNU libtool instead of BSD libtool (BSD is the default in macos)
 
 
 ## Packaging
@@ -104,12 +102,11 @@ We don't usually recommend packaging. Instead, you should probably just build. I
 
 ### Windows
 - `npm run gulp vscode-win32-x64` - most common
-- `npm run gulp vscode-win32-ia32`
+- `npm run gulp vscode-win32-arm64`
 
 ### Linux
 - `npm run gulp vscode-linux-x64` - most common
-- `npm run gulp vscode-linux-arm`
-- `npm run gulp vscode-linux-ia32`
+- `npm run gulp vscode-linux-arm64`
 
 
 ### Output

README.md

@@ -15,25 +15,26 @@ This repo contains the full sourcecode for Void. We are currently in [open beta]
 
 - 👋 [Discord](https://discord.gg/RSNjgaugJs)
 
-- 🔨 [Contribute](https://github.com/voideditor/void/blob/main/CONTRIBUTING.md)
+- 🔨 [Contribute](https://github.com/voideditor/void/blob/main/HOW_TO_CONTRIBUTE.md)
 
 - 🚙 [Roadmap](https://github.com/orgs/voideditor/projects/2)
 
 - 📝 [Changelog](https://voideditor.com/changelog)
 
+- 🧭 [Codebase Guide](https://github.com/voideditor/void/blob/main/VOID_CODEBASE_GUIDE.md)
 
 ## Contributing
 
 1. Feel free to attend a weekly meeting in our Discord channel if you'd like to contribute!
 
-2. To get started working on Void, see [Contributing](https://github.com/voideditor/void/blob/main/CONTRIBUTING.md).
+2. To get started working on Void, see [here](https://github.com/voideditor/void/blob/main/HOW_TO_CONTRIBUTE.md).
 
 3. We're open to collaborations and suggestions of all types - just reach out.
 
 
 ## Reference
 
-Void is a fork of the [vscode](https://github.com/microsoft/vscode) repository. For some useful links on VSCode, see [`VOID_USEFUL_LINKS.md`](https://github.com/voideditor/void/blob/main/VOID_USEFUL_LINKS.md).
+Void is a fork of the [vscode](https://github.com/microsoft/vscode) repository. For a guide to the VSCode/Void codebase, see [our Codebase Guide](https://github.com/voideditor/void/blob/main/VOID_CODEBASE_GUIDE.md).
 
 ## Support
 Feel free to reach out in our Discord or contact us via email: hello@voideditor.com.

VOID_CODEBASE_GUIDE.md

@@ -0,0 +1,162 @@
+# Void Codebase Guide
+
+The Void codebase is not as intimidating as it seems!
+
+Most of Void's code lives in the folder `src/vs/workbench/contrib/void/`.
+
+The purpose of this document is to explain how Void's codebase works. If you want build instructions, see [Contributing](https://github.com/voideditor/void/blob/main/HOW_TO_CONTRIBUTE.md).
+
+
+
+## Void Codebase Guide
+
+### Terminology
+
+Here is some important terminology you should know if you're working inside VSCode:
+- An **Editor** is the thing that you type your code in. If you have 10 tabs open, that's just one editor! Editors contain tabs (or "models").
+- A **Model** is an internal representation of a file's contents. It's shared between editors (for example, if you press `Cmd+\` to make a new editor, then the model of a file like `A.ts` is shared between them. Two editors, one model. That's how changes sync.).
+- Each model has a **URI** it represents, like `/Users/.../my_file.txt`. (A URI or "resource" is generally just a path).
+- The **Workbench** is the wrapper that contains all the editors, the terminal, the file system tree, etc.
+- Usually you use the `ITextModel` type for models and the `ICodeEditor` type for editors. There aren't that many other types.
+
+
+
+### Minimal VSCode Rundown
+Here's a minimal VSCode rundown if you're just getting started with Void:
+
+- VSCode is (and therefore Void is) an Electron app. Electron runs two processes: a **main** process (for internals) and a **browser** process (browser means HTML in general, not just "web browser").
+- Code in a  `browser/` folder always lives on the browser process, and it can use `window` and other browser items.
+- Code in an `electron-main/` folder always lives on the main process, and it can import `node_modules`.
+- Code in `common/` can be used by either process, but doesn't get any special imports.
+- The browser environment is not allowed to import `node_modules`, but there are two workarounds:
+  1. Bundle the raw node_module code to the browser - we're doing this for React.
+  2. Implement the code on `electron-main/` and set up a channel between main/browser - we're doing this for sendLLMMessage.
+
+
+
+VSCode is organized into "Services". A service is just a class that mounts a single time (in computer science theory this is called a "singleton"). You can register services with `registerSingleton` so that you can easily use them in any constructor with `@<Service>`. See _dummyContrib for an example we put together on how to register them. The registration is the same every time.
+
+Services are always lazily created, even if you register them as Eager. If you want something that always runs on Void's mount, you should use a "workbench contribution". See _dummyContrib for this. Very similar to a Service, just registered slightly differently.
+
+Actions or "commands" are functions you register on VSCode so that either you or the user can call them later. You can run actions as a user by pressing Cmd+Shift+P (opens the command pallete), or you can run them internally by using the commandService to call them by ID. We use actions to register keybinding listeners like Cmd+L, Cmd+K, etc. The nice thing about actions is the user can change the keybindings.
+
+
+See [here](https://github.com/microsoft/vscode/wiki/Source-Code-Organization) for a decent VSCode guide with even more info.
+
+
+Each section below contains an overview of a core part of Void's sourcecode. You might want to scroll to find the item that's relevant to you.
+
+### Internal LLM Message Pipeline
+
+Here's a picture of all the dependencies that are relevent between the time you first send a message through Void's sidebar, and the time a request is sent to your provider.
+Sending LLM messages from the main process avoids CSP issues with local providers and lets us use node_modules more easily.
+
+
+<div align="center">
+	<img width="100%" src="https://github.com/user-attachments/assets/9cf54dbb-82c4-4488-97a2-bd8dea890b50">
+</div>
+
+
+
+**Notes:** `modelCapabilities` is an important file that must be updated when new models come out! 
+
+
+### Apply
+
+Void has two types of Apply: **Fast Apply** (uses Search/Replace, see below), and **Slow Apply** (rewrites whole file).
+
+When you click Apply and Fast Apply is enabled, we prompt the LLM to output Search/Replace block(s) like this:
+```
+<<<<<<< ORIGINAL
+// original code goes here 
+=======
+// replaced code goes here
+>>>>>>> UPDATED
+```
+This is what allows Void to quickly apply code even on 1000-line files. It's the same as asking the LLM to press Ctrl+F and enter in a search/replace query. 
+
+### Apply Inner Workings
+
+The `editCodeService` file runs Apply. The same exact code is also used when the LLM calls the Edit tool, and when you submit Cmd+K. Just different versions of Fast/Slow Apply mode. 
+
+Here is some important terminology:
+- A **DiffZone** is a {startLine, endLine} region in which we show Diffs (red/green areas). We update it when the user types, so it's always accurate.
+- A **DiffArea** is a generalization that tracks line numbers like a DiffZone.
+- The only type of zone that can "stream" is a DiffZone. Each DiffZone has an llmCancelToken if it's streaming.
+- When you click Apply, we create a **DiffZone** over that the full file so that any changes that the LLM makes will show up in red/green. We then stream the change.
+- When an LLM calls Edit, it's really calling Apply.
+- When you submit Cmd+K, it's the same as Apply except we create a smaller DiffZone (not on the whole file).
+
+### Writing Files Inner Workings
+When Void wants to change your code, it just writes to a text model. This means all you need to know to write to a file is its URI - you don't have to load it, save it, etc. There are some annoying background URI/model things to think about to get this to work, but we handled them all in `voidModelService`.
+
+### Void Settings Inner Workings
+We have a service `voidSettingsService` that stores all your Void settings (providers, models, global Void settings, etc). Imagine this as an implicit dependency for any of the core Void services:
+
+<div align="center">
+	<img width="800" src="https://github.com/user-attachments/assets/9f3cb68c-a61b-4810-8429-bb90b992b3fa">
+</div>
+
+Here's a guide to some of the terminology we're using:
+- **FeatureName**: Autocomplete | Chat | CtrlK | Apply
+- **ModelSelection**: a {providerName, modelName} pair.
+- **ProviderName**: The name of a provider: `'ollama'`, `'openAI'`, etc.
+- **ModelName**: The name of a model (string type, eg `'gpt-4o'`). 
+- **RefreshProvider**: a provider that we ping repeatedly to update the models list.
+- **ChatMode** = normal | gather | agent
+
+
+
+### Approval State
+`editCodeService`'s data structures contain all the information about changes that the user needs to review. However, they don't store that information in a useful format. We wrote the following service to get a more useful derived state:
+
+<div align="center">
+	<img width="600" src="https://github.com/user-attachments/assets/f3645355-dff6-467c-bc38-ffe52077c08b">
+</div>
+
+
+
+### Build process
+If you want to know how our build pipeline works, see our build repo [here](https://github.com/voideditor/void-builder).
+
+
+
+## VSCode Codebase Guide (Not Void)
+
+The Void team put together this list of links to get up and running with VSCode's sourcecode, the foundation of Void. We hope it's helpful!
+
+#### Links for Beginners
+
+- [VSCode UI guide](https://code.visualstudio.com/docs/getstarted/userinterface)  - covers auxbar, panels, etc.
+
+- [UX guide](https://code.visualstudio.com/api/ux-guidelines/overview) - covers Containers, Views, Items, etc.
+
+#### Links for Contributors
+
+- [How VSCode's sourcecode is organized](https://github.com/microsoft/vscode/wiki/Source-Code-Organization) - this explains where the entry point files are, what `browser/` and `common/` mean, etc. This is the most important read on this whole list! We recommend reading the whole thing.
+
+- [Built-in VSCode styles](https://code.visualstudio.com/api/references/theme-color) - CSS variables that are built into VSCode. Use `var(--vscode-{theme but replacing . with -})`. You can also see their [Webview theming guide](https://code.visualstudio.com/api/extension-guides/webview#theming-webview-content).
+
+
+#### Misc
+
+- [Every command](https://code.visualstudio.com/api/references/commands) built-in to VSCode - not used often, but here for reference.
+
+- Note: VSCode's repo is the source code for the Monaco editor! An "editor" is a Monaco editor, and it shares the code for ITextModel, etc.
+
+
+#### VSCode's Extension API
+
+Void is no longer an extension, so these links are no longer required, but they might be useful if we ever build an extension again.
+
+- [Files you need in an extension](https://code.visualstudio.com/api/get-started/extension-anatomy).
+
+- [An extension's `package.json` schema](https://code.visualstudio.com/api/references/extension-manifest).
+
+- ["Contributes" Guide](https://code.visualstudio.com/api/references/contribution-points) - the `"contributes"` part of `package.json` is how an extension mounts.
+
+- [The Full VSCode Extension API](https://code.visualstudio.com/api/references/vscode-api) - look on the right side for organization. The [bottom](https://code.visualstudio.com/api/references/vscode-api#api-patterns) of the page is easy to miss but is useful - cancellation tokens, events, disposables.
+
+- [Activation events](https://code.visualstudio.com/api/references/activation-events) you can define in `package.json` (not the most useful).
+
+

VOID_USEFUL_LINKS.md

@@ -1,39 +0,0 @@
-# Useful links
-
-The Void team put together this list of links to get up and running with VSCode's sourcecode. We hope it's helpful!
-
-For a complete guide on building Void, see [Contributing](https://github.com/voideditor/void/blob/main/CONTRIBUTING.md).
-
-## Contributing
-
-- [How VSCode's sourcecode is organized](https://github.com/microsoft/vscode/wiki/Source-Code-Organization) - this explains where the entry point files are, what `browser/` and `common/` mean, etc. This is the most important read on this whole list! We recommend reading the whole thing.
-
-- [Built-in VSCode styles](https://code.visualstudio.com/api/references/theme-color) - CSS variables that are built into VSCode. Use `var(--vscode-{theme but replacing . with -})`. You can also see their [Webview theming guide](https://code.visualstudio.com/api/extension-guides/webview#theming-webview-content).
-
-## Beginners / Getting started
-
-- [VSCode UI guide](https://code.visualstudio.com/docs/getstarted/userinterface)  - covers auxbar, panels, etc.
-
-- [UX guide](https://code.visualstudio.com/api/ux-guidelines/overview) - covers Containers, Views, Items, etc.
-
-
-## Misc
-
-- [Every command](https://code.visualstudio.com/api/references/commands) built-in to VSCode - not used often, but here for reference.
-
-
-## VSCode's Extension API
-
-Void is no longer an extension, so these links are no longer required, but they might be useful if we ever build an extension again.
-
-- [Files you need in an extension](https://code.visualstudio.com/api/get-started/extension-anatomy).
-
-- [An extension's `package.json` schema](https://code.visualstudio.com/api/references/extension-manifest).
-
-- ["Contributes" Guide](https://code.visualstudio.com/api/references/contribution-points) - the `"contributes"` part of `package.json` is how an extension mounts.
-
-- [The Full VSCode Extension API](https://code.visualstudio.com/api/references/vscode-api) - look on the right side for organization. The [bottom](https://code.visualstudio.com/api/references/vscode-api#api-patterns) of the page is easy to miss but is useful - cancellation tokens, events, disposables.
-
-- [Activation events](https://code.visualstudio.com/api/references/activation-events) you can define in `package.json` (not the most useful).
-
-

build/filters.js

@@ -139,6 +139,7 @@ module.exports.indentationFilter = [
 	'!extensions/simple-browser/media/*.js',
 
 	'!extensions/open-remote-ssh/out/*.js', // Void added this
+	'!extensions/open-remote-wsl/out/*.js', // Void added this
 ];
 
 module.exports.copyrightFilter = [

build/gulpfile.extensions.js

@@ -73,6 +73,7 @@ const compilations = [
 	'.vscode/extensions/vscode-selfhost-import-aid/tsconfig.json',
 
 	'extensions/open-remote-ssh/tsconfig.json', // Void added this
+	'extensions/open-remote-wsl/tsconfig.json', // Void added this
 
 ];
 

build/gulpfile.vscode.linux.js

@@ -86,7 +86,7 @@ function prepareDebPackage(arch) {
 				const dependencies = await dependenciesGenerator.getDependencies('deb', binaryDir, product.applicationName, debArch);
 				gulp.src('resources/linux/debian/control.template', { base: '.' })
 					.pipe(replace('@@NAME@@', product.applicationName))
-					.pipe(replace('@@VERSION@@', `${packageJson.version}.${packageJson.release}`))
+					.pipe(replace('@@VERSION@@', `${product.voidVersion}.${packageJson.release}`))
 					.pipe(replace('@@ARCHITECTURE@@', debArch))
 					.pipe(replace('@@DEPENDS@@', dependencies.join(', ')))
 					.pipe(replace('@@RECOMMENDS@@', debianRecommendedDependencies.join(', ')))
@@ -201,7 +201,7 @@ function prepareRpmPackage(arch) {
 					.pipe(replace('@@NAME@@', product.applicationName))
 					.pipe(replace('@@NAME_LONG@@', product.nameLong))
 					.pipe(replace('@@ICON@@', product.linuxIconName))
-					.pipe(replace('@@VERSION@@', `${packageJson.version}.${packageJson.release}`))
+					.pipe(replace('@@VERSION@@', `${product.voidVersion}.${packageJson.release}`))
 					.pipe(replace('@@ARCHITECTURE@@', rpmArch))
 					.pipe(replace('@@LICENSE@@', product.licenseName))
 					.pipe(replace('@@QUALITY@@', product.quality || '@@QUALITY@@'))
@@ -277,7 +277,7 @@ function prepareSnapPackage(arch) {
 
 		const snapcraft = gulp.src('resources/linux/snap/snapcraft.yaml', { base: '.' })
 			.pipe(replace('@@NAME@@', product.applicationName))
-			.pipe(replace('@@VERSION@@', `${packageJson.version}.${packageJson.release}`))
+			.pipe(replace('@@VERSION@@', `${product.voidVersion}.${packageJson.release}`))
 			// Possible run-on values https://snapcraft.io/docs/architectures
 			.pipe(replace('@@ARCHITECTURE@@', arch === 'x64' ? 'amd64' : arch))
 			.pipe(rename('snap/snapcraft.yaml'));

build/npm/dirs.js

@@ -55,6 +55,7 @@ const dirs = [
 	'.vscode/extensions/vscode-selfhost-import-aid',
 	'.vscode/extensions/vscode-selfhost-test-provider',
 	'extensions/open-remote-ssh', // Void added this
+	'extensions/open-remote-wsl', // Void added this
 
 ];
 

extensions/open-remote-wsl/README.md

@@ -0,0 +1,3 @@
+# Remote - WSL Support
+
+Inherited for Void from [Open Remote - WSL](https://github.com/jeanp413/open-remote-wsl).

extensions/open-remote-wsl/extension-browser.webpack.config.js

@@ -0,0 +1,17 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+//@ts-check
+
+'use strict';
+
+const withBrowserDefaults = require('../shared.webpack.config').browser;
+
+module.exports = withBrowserDefaults({
+	context: __dirname,
+	entry: {
+		extension: './src/extension.ts'
+	}
+});

extensions/open-remote-wsl/extension.webpack.config.js

@@ -0,0 +1,20 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+//@ts-check
+
+'use strict';
+
+const withDefaults = require('../shared.webpack.config');
+
+module.exports = withDefaults({
+	context: __dirname,
+	resolve: {
+		mainFields: ['module', 'main']
+	},
+	entry: {
+		extension: './src/extension.ts',
+	}
+});

extensions/open-remote-wsl/package-lock.json

@@ -0,0 +1,15 @@
+{
+	"name": "open-remote-wsl",
+	"version": "0.0.4",
+	"lockfileVersion": 3,
+	"requires": true,
+	"packages": {
+		"": {
+			"name": "open-remote-wsl",
+			"version": "0.0.4",
+			"engines": {
+				"vscode": "^1.70.2"
+			}
+		}
+	}
+}

extensions/open-remote-wsl/package.json

@@ -0,0 +1,281 @@
+{
+	"name": "open-remote-wsl",
+	"displayName": "Remote - WSL",
+	"description": "Open any folder in the Windows Subsystem for Linux (WSL).",
+	"version": "0.0.4",
+	"icon": "resources/icon.png",
+	"engines": {
+		"vscode": "^1.70.2"
+	},
+	"extensionKind": [
+		"ui"
+	],
+	"enabledApiProposals": [
+		"resolvers",
+		"contribViewsRemote"
+	],
+	"keywords": [
+		"remote development",
+		"remote",
+		"wsl"
+	],
+	"api": "none",
+	"activationEvents": [
+		"onCommand:openremotewsl.connect",
+		"onCommand:openremotewsl.connectInNewWindow",
+		"onCommand:openremotewsl.connectUsingDistro",
+		"onCommand:openremotewsl.connectUsingDistroInNewWindow",
+		"onCommand:openremotewsl.showLog",
+		"onResolveRemoteAuthority:wsl",
+		"onView:wslTargets"
+	],
+	"main": "./out/extension.js",
+	"contributes": {
+		"configuration": {
+			"title": "WSL",
+			"properties": {
+				"remote.WSL.serverDownloadUrlTemplate": {
+					"type": "string",
+					"description": "The URL from where the vscode server will be downloaded. You can use the following variables and they will be replaced dynamically:\n- ${quality}: vscode server quality, e.g. stable or insiders\n- ${version}: vscode server version, e.g. 1.69.0\n- ${commit}: vscode server release commit\n- ${arch}: vscode server arch, e.g. x64, armhf, arm64\n- ${release}: release number",
+					"scope": "application",
+					"default": "https://github.com/voideditor/binaries/releases/download/${version}.${release}/void-reh-${os}-${arch}-${version}.${release}.tar.gz"
+				}
+			}
+		},
+		"views": {
+			"remote": [
+				{
+					"id": "wslTargets",
+					"name": "WSL Targets",
+					"group": "targets@1",
+					"when": "(isWindows && !isWeb)",
+					"remoteName": "wsl"
+				}
+			]
+		},
+		"commands": [
+			{
+				"command": "openremotewsl.connect",
+				"title": "Connect to WSL",
+				"category": "Remote-WSL"
+			},
+			{
+				"command": "openremotewsl.connectInNewWindow",
+				"title": "Connect to WSL in New Window",
+				"category": "Remote-WSL"
+			},
+			{
+				"command": "openremotewsl.connectUsingDistro",
+				"title": "Connect to WSL using Distro...",
+				"category": "Remote-WSL"
+			},
+			{
+				"command": "openremotewsl.connectUsingDistroInNewWindow",
+				"title": "Connect to WSL using Distro in New Window...",
+				"category": "Remote-WSL"
+			},
+			{
+				"command": "openremotewsl.showLog",
+				"title": "Show Log",
+				"category": "Remote-WSL"
+			},
+			{
+				"command": "openremotewsl.explorer.emptyWindowInNewWindow",
+				"title": "Connect in New Window",
+				"icon": "$(empty-window)"
+			},
+			{
+				"command": "openremotewsl.explorer.emptyWindowInCurrentWindow",
+				"title": "Connect in Current Window"
+			},
+			{
+				"command": "openremotewsl.explorer.reopenFolderInCurrentWindow",
+				"title": "Open in Current Window"
+			},
+			{
+				"command": "openremotewsl.explorer.reopenFolderInNewWindow",
+				"title": "Open in New Window",
+				"icon": "$(folder-opened)"
+			},
+			{
+				"command": "openremotewsl.explorer.deleteFolderHistoryItem",
+				"title": "Remove From Recent List",
+				"icon": "$(x)"
+			},
+			{
+				"command": "openremotewsl.explorer.refresh",
+				"title": "Refresh",
+				"icon": "$(refresh)"
+			},
+			{
+				"command": "openremotewsl.explorer.addDistro",
+				"title": "Add a Distro",
+				"icon": "$(plus)"
+			},
+			{
+				"command": "openremotewsl.explorer.setDefaultDistro",
+				"title": "Set as Default Distro"
+			},
+			{
+				"command": "openremotewsl.explorer.deleteDistro",
+				"title": "Delete Distro"
+			}
+		],
+		"resourceLabelFormatters": [
+			{
+				"scheme": "vscode-remote",
+				"authority": "wsl+*",
+				"formatting": {
+					"label": "${path}",
+					"separator": "/",
+					"tildify": true,
+					"workspaceSuffix": "WSL"
+				}
+			}
+		],
+		"menus": {
+			"statusBar/remoteIndicator": [
+				{
+					"command": "openremotewsl.connect",
+					"when": "(isWindows && !isWeb)",
+					"group": "remote_20_wsl_1general@1"
+				},
+				{
+					"command": "openremotewsl.connectUsingDistro",
+					"when": "(isWindows && !isWeb)",
+					"group": "remote_20_wsl_1general@2"
+				},
+				{
+					"command": "openremotewsl.showLog",
+					"when": "remoteName =~ /^wsl$/",
+					"group": "remote_20_wsl_1general@4"
+				}
+			],
+			"commandPalette": [
+				{
+					"command": "openremotewsl.connect",
+					"when": "(isWindows && !isWeb)"
+				},
+				{
+					"command": "openremotewsl.connectInNewWindow",
+					"when": "(isWindows && !isWeb)"
+				},
+				{
+					"command": "openremotewsl.connectUsingDistro",
+					"when": "(isWindows && !isWeb)"
+				},
+				{
+					"command": "openremotewsl.connectUsingDistroInNewWindow",
+					"when": "(isWindows && !isWeb)"
+				},
+				{
+					"command": "openremotewsl.explorer.refresh",
+					"when": "false"
+				},
+				{
+					"command": "openremotewsl.explorer.addDistro",
+					"when": "false"
+				},
+				{
+					"command": "openremotewsl.explorer.emptyWindowInNewWindow",
+					"when": "false"
+				},
+				{
+					"command": "openremotewsl.explorer.emptyWindowInCurrentWindow",
+					"when": "false"
+				},
+				{
+					"command": "openremotewsl.explorer.reopenFolderInCurrentWindow",
+					"when": "false"
+				},
+				{
+					"command": "openremotewsl.explorer.reopenFolderInNewWindow",
+					"when": "false"
+				},
+				{
+					"command": "openremotewsl.explorer.deleteFolderHistoryItem",
+					"when": "false"
+				},
+				{
+					"command": "openremotewsl.explorer.setDefaultDistro",
+					"when": "false"
+				},
+				{
+					"command": "openremotewsl.explorer.deleteDistro",
+					"when": "false"
+				}
+			],
+			"view/title": [
+				{
+					"command": "openremotewsl.explorer.addDistro",
+					"when": "view == wslTargets",
+					"group": "navigation"
+				},
+				{
+					"command": "openremotewsl.explorer.refresh",
+					"when": "view == wslTargets",
+					"group": "navigation"
+				}
+			],
+			"view/item/context": [
+				{
+					"command": "openremotewsl.explorer.emptyWindowInNewWindow",
+					"when": "viewItem =~ /^openremotewsl.explorer.distro$/",
+					"group": "inline@1"
+				},
+				{
+					"command": "openremotewsl.explorer.emptyWindowInNewWindow",
+					"when": "viewItem =~ /^openremotewsl.explorer.distro$/",
+					"group": "navigation@2"
+				},
+				{
+					"command": "openremotewsl.explorer.emptyWindowInCurrentWindow",
+					"when": "viewItem =~ /^openremotewsl.explorer.distro$/",
+					"group": "navigation@1"
+				},
+				{
+					"command": "openremotewsl.explorer.setDefaultDistro",
+					"when": "viewItem =~ /^openremotewsl.explorer.distro$/",
+					"group": "management@1"
+				},
+				{
+					"command": "openremotewsl.explorer.deleteDistro",
+					"when": "viewItem =~ /^openremotewsl.explorer.distro$/",
+					"group": "management@2"
+				},
+				{
+					"command": "openremotewsl.explorer.reopenFolderInNewWindow",
+					"when": "viewItem == openremotewsl.explorer.folder",
+					"group": "inline@1"
+				},
+				{
+					"command": "openremotewsl.explorer.reopenFolderInNewWindow",
+					"when": "viewItem == openremotewsl.explorer.folder",
+					"group": "navigation@2"
+				},
+				{
+					"command": "openremotewsl.explorer.reopenFolderInCurrentWindow",
+					"when": "viewItem == openremotewsl.explorer.folder",
+					"group": "navigation@1"
+				},
+				{
+					"command": "openremotewsl.explorer.deleteFolderHistoryItem",
+					"when": "viewItem =~ /^openremotewsl.explorer.folder/",
+					"group": "navigation@3"
+				},
+				{
+					"command": "openremotewsl.explorer.deleteFolderHistoryItem",
+					"when": "viewItem =~ /^openremotewsl.explorer.folder/",
+					"group": "inline@2"
+				}
+			]
+		}
+	},
+	"scripts": {
+    "vscode:prepublish": "npm run compile",
+    "compile": "gulp compile-extension:open-remote-wsl",
+    "compile-web": "npx webpack-cli --config extension-browser.webpack.config --mode none",
+    "watch": "gulp watch-extension:open-remote-wsl",
+    "watch-web": "npx webpack-cli --config extension-browser.webpack.config --mode none --watch --info-verbosity verbose"
+	}
+}

extensions/open-remote-wsl/src/authResolver.ts

@@ -0,0 +1,121 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import Log from './common/logger';
+import { installCodeServer, ServerInstallError } from './serverSetup';
+import { WSLManager } from './wsl/wslManager';
+
+export const REMOTE_WSL_AUTHORITY = 'wsl';
+
+export function getRemoteAuthority(distro: string) {
+	return `${REMOTE_WSL_AUTHORITY}+${distro}`;
+}
+
+class Tunnel implements vscode.Tunnel {
+	private _onDidDisposeEmitter = new vscode.EventEmitter<void>();
+
+	readonly onDidDispose = this._onDidDisposeEmitter.event;
+
+	constructor(
+		readonly remoteAddress: { port: number; host: string },
+		readonly localAddress: { port: number; host: string }
+	) {
+		// If ipv6 localhost 0:0:0:0:0:0:0:1 or [::1] replace with localhost
+		if (localAddress.host !== 'localhost' && localAddress.host !== '127.0.0.1') {
+			localAddress.host = 'localhost';
+		}
+	}
+
+	dispose() {
+		this._onDidDisposeEmitter.fire();
+	}
+}
+
+export class RemoteWSLResolver implements vscode.RemoteAuthorityResolver, vscode.Disposable {
+
+	private labelFormatterDisposable: vscode.Disposable | undefined;
+
+	constructor(
+		private readonly wslManager: WSLManager,
+		private readonly logger: Log
+	) {
+	}
+
+	resolve(authority: string, context: vscode.RemoteAuthorityResolverContext): Thenable<vscode.ResolverResult> {
+		const [type, distroName] = authority.split('+');
+		if (type !== REMOTE_WSL_AUTHORITY) {
+			throw new Error(`Invalid authority type for WSL resolver: ${type}`);
+		}
+
+		this.logger.info(`Resolving wsl remote authority '${authority}' (attemp #${context.resolveAttempt})`);
+
+		// It looks like default values are not loaded yet when resolving a remote,
+		// so let's hardcode the default values here
+		const remoteSSHconfig = vscode.workspace.getConfiguration('remote.WSL');
+		const serverDownloadUrlTemplate = remoteSSHconfig.get<string>('serverDownloadUrlTemplate');
+
+		return vscode.window.withProgress({
+			title: `Setting up WSL Distro: ${distroName}`,
+			location: vscode.ProgressLocation.Notification,
+			cancellable: false
+		}, async () => {
+			try {
+				const installResult = await installCodeServer(this.wslManager, distroName, serverDownloadUrlTemplate, [], [], this.logger);
+
+				this.labelFormatterDisposable?.dispose();
+				this.labelFormatterDisposable = vscode.workspace.registerResourceLabelFormatter({
+					scheme: 'vscode-remote',
+					authority: `${REMOTE_WSL_AUTHORITY}+*`,
+					formatting: {
+						label: '${path}',
+						separator: '/',
+						tildify: true,
+						workspaceSuffix: `WSL: ${distroName}`,
+						workspaceTooltip: `Running in ${distroName}`
+					}
+				});
+
+				return new vscode.ResolvedAuthority('127.0.0.1', installResult.listeningOn, installResult.connectionToken);
+			} catch (e: unknown) {
+				this.logger.error(`Error resolving authority`, e);
+
+				// Initial connection
+				if (context.resolveAttempt === 1) {
+					this.logger.show();
+
+					const closeRemote = 'Close Remote';
+					const retry = 'Retry';
+					const result = await vscode.window.showErrorMessage(`Could not establish connection to WSL distro "${distroName}"`, { modal: true }, closeRemote, retry);
+					if (result === closeRemote) {
+						await vscode.commands.executeCommand('workbench.action.remote.close');
+					} else if (result === retry) {
+						await vscode.commands.executeCommand('workbench.action.reloadWindow');
+					}
+				}
+
+				if (e instanceof ServerInstallError || !(e instanceof Error)) {
+					throw vscode.RemoteAuthorityResolverError.NotAvailable(e instanceof Error ? e.message : String(e));
+				} else {
+					throw vscode.RemoteAuthorityResolverError.TemporarilyNotAvailable(e.message);
+				}
+			}
+		});
+	}
+
+	async tunnelFactory(tunnelOptions: vscode.TunnelOptions) {
+		return new Tunnel(
+			tunnelOptions.remoteAddress,
+			{
+				host: tunnelOptions.remoteAddress.host,
+				port: tunnelOptions.localAddressPort ?? tunnelOptions.remoteAddress.port
+			}
+		);
+	}
+
+	dispose() {
+		this.labelFormatterDisposable?.dispose();
+	}
+}

extensions/open-remote-wsl/src/commands.ts

@@ -0,0 +1,86 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import { getRemoteAuthority } from './authResolver';
+import { WSLDistro, WSLManager, WSLOnlineDistro } from './wsl/wslManager';
+import wslTerminal from './wsl/wslTerminal';
+
+async function showDistrosPicker(wslManager: WSLManager, placeHolder: string): Promise<WSLDistro | undefined> {
+	const pickItemsPromise = wslManager.listDistros()
+		.then(distros => distros.map(distroData => {
+			return {
+				...distroData,
+				label: `${distroData.name}`,
+				detail: distroData.isDefault ? 'default distro' : undefined,
+			};
+		}));
+
+	const picked = await vscode.window.showQuickPick(pickItemsPromise, { canPickMany: false, placeHolder });
+	return picked;
+}
+
+async function showOnlineDistrosPicker(wslManager: WSLManager, placeHolder: string): Promise<WSLOnlineDistro | undefined> {
+	const pickItemsPromise = Promise.all([wslManager.listOnlineDistros(), wslManager.listDistros()])
+		.then(([onlineDistros, localDistros]) => {
+			const distroToInstall = onlineDistros.filter(d => !localDistros.some(l => l.name === d.name));
+			return distroToInstall.map(distroData => {
+				return {
+					...distroData,
+					label: `${distroData.friendlyName}`,
+				};
+			});
+		});
+
+	const picked = await vscode.window.showQuickPick(pickItemsPromise, { canPickMany: false, placeHolder });
+	return picked;
+}
+
+export async function promptOpenRemoteWSLWindow(wslManager: WSLManager, useDefault: boolean, reuseWindow: boolean) {
+	let distroName: string | undefined;
+	if (useDefault) {
+		const distros = await wslManager.listDistros();
+		distroName = distros.find(distro => distro.isDefault)?.name;
+	} else {
+		distroName = (await showDistrosPicker(wslManager, 'Select WSL distro'))?.name;
+	}
+
+	if (!distroName) {
+		return;
+	}
+
+	openRemoteWSLWindow(distroName, reuseWindow);
+}
+
+export async function promptInstallNewWSLDistro(wslManager: WSLManager) {
+	const distroName = (await showOnlineDistrosPicker(wslManager, 'Select the WSL distro to install'))?.name;
+	if (!distroName) {
+		return;
+	}
+
+	wslTerminal.runCommand(`wsl.exe --install -d ${distroName}`);
+}
+
+export function openRemoteWSLWindow(distro: string, reuseWindow: boolean) {
+	vscode.commands.executeCommand('vscode.newWindow', { remoteAuthority: getRemoteAuthority(distro), reuseWindow });
+}
+
+export function openRemoteWSLLocationWindow(distro: string, path: string, reuseWindow: boolean) {
+	vscode.commands.executeCommand('vscode.openFolder', vscode.Uri.from({ scheme: 'vscode-remote', authority: getRemoteAuthority(distro), path }), { forceNewWindow: !reuseWindow });
+}
+
+export async function setDefaultWSLDistro(wslManager: WSLManager, distroName: string) {
+	await wslManager.setDefaultDistro(distroName);
+}
+
+export async function deleteWSLDistro(wslManager: WSLManager, distroName: string) {
+	const deleteAction = 'Delete';
+	const resp = await vscode.window.showInformationMessage(`Are you sure you want to permanently delete the distro "${distroName}" including all its data?`, { modal: true }, deleteAction);
+	if (resp === deleteAction) {
+		await wslManager.deleteDistro(distroName);
+		return true;
+	}
+	return false;
+}

extensions/open-remote-wsl/src/common/async.ts

@@ -0,0 +1,28 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export function timeout(millis: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, millis));
+}
+
+export interface ITask<T> {
+	(): T;
+}
+
+export async function retry<T>(task: ITask<Promise<T>>, delay: number, retries: number): Promise<T> {
+	let lastError: Error | undefined;
+
+	for (let i = 0; i < retries; i++) {
+		try {
+			return await task();
+		} catch (error) {
+			lastError = error;
+
+			await timeout(delay);
+		}
+	}
+
+	throw lastError;
+}

extensions/open-remote-wsl/src/common/disposable.ts

@@ -0,0 +1,42 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+
+export function disposeAll(disposables: vscode.Disposable[]): void {
+	while (disposables.length) {
+		const item = disposables.pop();
+		if (item) {
+			item.dispose();
+		}
+	}
+}
+
+export abstract class Disposable {
+	private _isDisposed = false;
+
+	protected _disposables: vscode.Disposable[] = [];
+
+	public dispose(): any {
+		if (this._isDisposed) {
+			return;
+		}
+		this._isDisposed = true;
+		disposeAll(this._disposables);
+	}
+
+	protected _register<T extends vscode.Disposable>(value: T): T {
+		if (this._isDisposed) {
+			value.dispose();
+		} else {
+			this._disposables.push(value);
+		}
+		return value;
+	}
+
+	protected get isDisposed(): boolean {
+		return this._isDisposed;
+	}
+}

extensions/open-remote-wsl/src/common/event.ts

@@ -0,0 +1,142 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export interface IDisposable {
+	dispose(): void;
+}
+
+export interface Event<T> {
+	(listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[]): IDisposable;
+}
+
+/**
+ * Returns a promise that resolves when the event fires, or when cancellation
+ * is requested, whichever happens first.
+ */
+export function toPromise<T>(event: Event<T>): Promise<T>;
+export function toPromise<T>(event: Event<T>, signal: AbortSignal): Promise<T | undefined>;
+export function toPromise<T>(event: Event<T>, signal?: AbortSignal): Promise<T | undefined> {
+	if (!signal) {
+		return new Promise<T>((resolve) => once(event, resolve));
+	}
+
+	if (signal.aborted) {
+		return Promise.resolve(undefined);
+	}
+
+	return new Promise((resolve) => {
+		const d2 = once(event, (data) => {
+			(signal as any).removeEventListener('abort', d1);
+			resolve(data);
+		});
+
+		const d1 = () => {
+			d2.dispose();
+			(signal as any).removeEventListener('abort', d1);
+			resolve(undefined);
+		};
+
+		(signal as any).addEventListener('abort', d1);
+	});
+}
+
+/**
+ * Adds a handler that handles one event on the emitter, then disposes itself.
+ */
+export const once = <T>(event: Event<T>, listener: (data: T) => void): IDisposable => {
+	const disposable = event((value) => {
+		listener(value);
+		disposable.dispose();
+	});
+
+	return disposable;
+};
+
+/**
+ * Base event emitter. Calls listeners when data is emitted.
+ */
+export class EventEmitter<T> {
+	private listeners?: Array<(data: T) => void> | ((data: T) => void);
+
+	/**
+	 * Event<T> function.
+	 */
+	public readonly event: Event<T> = (listener, thisArgs, disposables) => {
+		const d = this.add(thisArgs ? listener.bind(thisArgs) : listener);
+		disposables?.push(d);
+		return d;
+	};
+
+	/**
+	 * Gets the number of event listeners.
+	 */
+	public get size() {
+		if (!this.listeners) {
+			return 0;
+		} else if (typeof this.listeners === 'function') {
+			return 1;
+		} else {
+			return this.listeners.length;
+		}
+	}
+
+	/**
+	 * Emits event data.
+	 */
+	public fire(value: T) {
+		if (!this.listeners) {
+			// no-op
+		} else if (typeof this.listeners === 'function') {
+			this.listeners(value);
+		} else {
+			for (const listener of this.listeners) {
+				listener(value);
+			}
+		}
+	}
+
+	/**
+	 * Disposes of the emitter.
+	 */
+	public dispose() {
+		this.listeners = undefined;
+	}
+
+	private add(listener: (data: T) => void): IDisposable {
+		if (!this.listeners) {
+			this.listeners = listener;
+		} else if (typeof this.listeners === 'function') {
+			this.listeners = [this.listeners, listener];
+		} else {
+			this.listeners.push(listener);
+		}
+
+		return { dispose: () => this.rm(listener) };
+	}
+
+	private rm(listener: (data: T) => void) {
+		if (!this.listeners) {
+			return;
+		}
+
+		if (typeof this.listeners === 'function') {
+			if (this.listeners === listener) {
+				this.listeners = undefined;
+			}
+			return;
+		}
+
+		const index = this.listeners.indexOf(listener);
+		if (index === -1) {
+			return;
+		}
+
+		if (this.listeners.length === 2) {
+			this.listeners = index === 0 ? this.listeners[1] : this.listeners[0];
+		} else {
+			this.listeners = this.listeners.slice(0, index).concat(this.listeners.slice(index + 1));
+		}
+	}
+}

extensions/open-remote-wsl/src/common/files.ts

@@ -0,0 +1,26 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as fs from 'fs';
+import * as os from 'os';
+
+const homeDir = os.homedir();
+
+export async function exists(path: string) {
+	try {
+		await fs.promises.access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export function untildify(path: string) {
+	return path.replace(/^~(?=$|\/|\\)/, homeDir);
+}
+
+export function normalizeToSlash(path: string) {
+	return path.replace(/\\/g, '/');
+}

extensions/open-remote-wsl/src/common/logger.ts

@@ -0,0 +1,64 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+
+type LogLevel = 'Trace' | 'Info' | 'Error';
+
+export default class Log {
+	private output: vscode.OutputChannel;
+
+	constructor(name: string) {
+		this.output = vscode.window.createOutputChannel(name);
+	}
+
+	private data2String(data: any): string {
+		if (data instanceof Error) {
+			return data.stack || data.message;
+		}
+		if (data.success === false && data.message) {
+			return data.message;
+		}
+		return data.toString();
+	}
+
+	public trace(message: string, data?: any): void {
+		this.logLevel('Trace', message, data);
+	}
+
+	public info(message: string, data?: any): void {
+		this.logLevel('Info', message, data);
+	}
+
+	public error(message: string, data?: any): void {
+		this.logLevel('Error', message, data);
+	}
+
+	public logLevel(level: LogLevel, message: string, data?: any): void {
+		this.output.appendLine(`[${level}  - ${this.now()}] ${message}`);
+		if (data) {
+			this.output.appendLine(this.data2String(data));
+		}
+	}
+
+	private now(): string {
+		const now = new Date();
+		return padLeft(now.getUTCHours() + '', 2, '0')
+			+ ':' + padLeft(now.getMinutes() + '', 2, '0')
+			+ ':' + padLeft(now.getUTCSeconds() + '', 2, '0') + '.' + now.getMilliseconds();
+	}
+
+	public show() {
+		this.output.show();
+	}
+
+	public dispose() {
+		this.output.dispose();
+	}
+}
+
+function padLeft(s: string, n: number, pad = ' ') {
+	return pad.repeat(Math.max(0, n - s.length)) + s;
+}

extensions/open-remote-wsl/src/common/platform.ts

@@ -0,0 +1,8 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export const isWindows = process.platform === 'win32';
+export const isMacintosh = process.platform === 'darwin';
+export const isLinux = process.platform === 'linux';

extensions/open-remote-wsl/src/common/ports.ts

@@ -0,0 +1,134 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as net from 'net';
+
+/**
+ * Finds a random unused port assigned by the operating system. Will reject in case no free port can be found.
+ */
+export function findRandomPort(): Promise<number> {
+	return new Promise((resolve, reject) => {
+		const server = net.createServer({ pauseOnConnect: true });
+		server.on('error', reject);
+		server.on('listening', () => {
+			const port = (server.address() as net.AddressInfo).port;
+			server.close(() => resolve(port));
+		});
+		server.listen(0, '127.0.0.1');
+	});
+}
+
+/**
+ * Given a start point and a max number of retries, will find a port that
+ * is openable. Will return 0 in case no free port can be found.
+ */
+export function findFreePort(startPort: number, giveUpAfter: number, timeout: number, stride = 1): Promise<number> {
+	let done = false;
+
+	return new Promise(resolve => {
+		const timeoutHandle = setTimeout(() => {
+			if (!done) {
+				done = true;
+				return resolve(0);
+			}
+		}, timeout);
+
+		doFindFreePort(startPort, giveUpAfter, stride, (port) => {
+			if (!done) {
+				done = true;
+				clearTimeout(timeoutHandle);
+				return resolve(port);
+			}
+		});
+	});
+}
+
+function doFindFreePort(startPort: number, giveUpAfter: number, stride: number, clb: (port: number) => void): void {
+	if (giveUpAfter === 0) {
+		return clb(0);
+	}
+
+	const client = new net.Socket();
+
+	// If we can connect to the port it means the port is already taken so we continue searching
+	client.once('connect', () => {
+		dispose(client);
+
+		return doFindFreePort(startPort + stride, giveUpAfter - 1, stride, clb);
+	});
+
+	client.once('data', () => {
+		// this listener is required since node.js 8.x
+	});
+
+	client.once('error', (err: Error & { code?: string }) => {
+		dispose(client);
+
+		// If we receive any non ECONNREFUSED error, it means the port is used but we cannot connect
+		if (err.code !== 'ECONNREFUSED') {
+			return doFindFreePort(startPort + stride, giveUpAfter - 1, stride, clb);
+		}
+
+		// Otherwise it means the port is free to use!
+		return clb(startPort);
+	});
+
+	client.connect(startPort, '127.0.0.1');
+}
+
+/**
+ * Uses listen instead of connect. Is faster, but if there is another listener on 0.0.0.0 then this will take 127.0.0.1 from that listener.
+ */
+export function findFreePortFaster(startPort: number, giveUpAfter: number, timeout: number): Promise<number> {
+	let resolved = false;
+	let timeoutHandle: NodeJS.Timeout | undefined = undefined;
+	let countTried = 1;
+	const server = net.createServer({ pauseOnConnect: true });
+	function doResolve(port: number, resolve: (port: number) => void) {
+		if (!resolved) {
+			resolved = true;
+			server.removeAllListeners();
+			server.close();
+			if (timeoutHandle) {
+				clearTimeout(timeoutHandle);
+			}
+			resolve(port);
+		}
+	}
+	return new Promise<number>(resolve => {
+		timeoutHandle = setTimeout(() => {
+			doResolve(0, resolve);
+		}, timeout);
+
+		server.on('listening', () => {
+			doResolve(startPort, resolve);
+		});
+		server.on('error', err => {
+			if (err && ((<any>err).code === 'EADDRINUSE' || (<any>err).code === 'EACCES') && (countTried < giveUpAfter)) {
+				startPort++;
+				countTried++;
+				server.listen(startPort, '127.0.0.1');
+			} else {
+				doResolve(0, resolve);
+			}
+		});
+		server.on('close', () => {
+			doResolve(0, resolve);
+		});
+		server.listen(startPort, '127.0.0.1');
+	});
+}
+
+function dispose(socket: net.Socket): void {
+	try {
+		socket.removeAllListeners('connect');
+		socket.removeAllListeners('error');
+		socket.end();
+		socket.destroy();
+		socket.unref();
+	} catch (error) {
+		console.error(error); // otherwise this error would get lost in the callback chain
+	}
+}

extensions/open-remote-wsl/src/distroTreeView.ts

@@ -0,0 +1,109 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import * as path from 'path';
+import { RemoteLocationHistory } from './remoteLocationHistory';
+import { Disposable } from './common/disposable';
+import { openRemoteWSLWindow, openRemoteWSLLocationWindow, promptInstallNewWSLDistro, deleteWSLDistro, setDefaultWSLDistro } from './commands';
+import { WSLManager } from './wsl/wslManager';
+
+class DistroItem {
+	constructor(
+		public name: string,
+		public isDefault: boolean,
+		public locations: string[]
+	) {
+	}
+}
+
+class DistroLocationItem {
+	constructor(
+		public path: string,
+		public name: string
+	) {
+	}
+}
+
+type DataTreeItem = DistroItem | DistroLocationItem;
+
+export class DistroTreeDataProvider extends Disposable implements vscode.TreeDataProvider<DataTreeItem> {
+
+	private readonly _onDidChangeTreeData = this._register(new vscode.EventEmitter<DataTreeItem | DataTreeItem[] | void>());
+	public readonly onDidChangeTreeData = this._onDidChangeTreeData.event;
+
+	constructor(
+		private readonly locationHistory: RemoteLocationHistory,
+		private readonly wslManager: WSLManager
+	) {
+		super();
+
+		this._register(vscode.commands.registerCommand('openremotewsl.explorer.addDistro', () => promptInstallNewWSLDistro(wslManager)));
+		this._register(vscode.commands.registerCommand('openremotewsl.explorer.refresh', () => this.refresh()));
+		this._register(vscode.commands.registerCommand('openremotewsl.explorer.emptyWindowInNewWindow', e => this.openRemoteWSLWindow(e, false)));
+		this._register(vscode.commands.registerCommand('openremotewsl.explorer.emptyWindowInCurrentWindow', e => this.openRemoteWSLWindow(e, true)));
+		this._register(vscode.commands.registerCommand('openremotewsl.explorer.reopenFolderInNewWindow', e => this.openRemoteWSLocationWindow(e, false)));
+		this._register(vscode.commands.registerCommand('openremotewsl.explorer.reopenFolderInCurrentWindow', e => this.openRemoteWSLocationWindow(e, true)));
+		this._register(vscode.commands.registerCommand('openremotewsl.explorer.deleteFolderHistoryItem', e => this.deleteDistroLocation(e)));
+		this._register(vscode.commands.registerCommand('openremotewsl.explorer.setDefaultDistro', e => this.setDefaultDistro(e)));
+		this._register(vscode.commands.registerCommand('openremotewsl.explorer.deleteDistro', e => this.deleteDistro(e)));
+	}
+
+	getTreeItem(element: DataTreeItem): vscode.TreeItem {
+		if (element instanceof DistroLocationItem) {
+			const label = path.posix.basename(element.path).replace(/\.code-workspace$/, ' (Workspace)');
+			const treeItem = new vscode.TreeItem(label);
+			treeItem.description = path.posix.dirname(element.path);
+			treeItem.iconPath = new vscode.ThemeIcon('folder');
+			treeItem.contextValue = 'openremotewsl.explorer.folder';
+			return treeItem;
+		}
+
+		const treeItem = new vscode.TreeItem(element.name);
+		treeItem.description = element.isDefault ? 'default distro' : undefined;
+		treeItem.collapsibleState = element.locations.length ? vscode.TreeItemCollapsibleState.Collapsed : vscode.TreeItemCollapsibleState.None;
+		treeItem.iconPath = new vscode.ThemeIcon('vm');
+		treeItem.contextValue = 'openremotewsl.explorer.distro';
+		return treeItem;
+	}
+
+	async getChildren(element?: DistroItem): Promise<DataTreeItem[]> {
+		if (!element) {
+			const distros = await this.wslManager.listDistros();
+			return distros.map(distro => new DistroItem(distro.name, distro.isDefault, this.locationHistory.getHistory(distro.name)));
+		}
+		if (element instanceof DistroItem) {
+			return element.locations.map(location => new DistroLocationItem(location, element.name));
+		}
+		return [];
+	}
+
+	private refresh() {
+		this._onDidChangeTreeData.fire();
+	}
+
+	private async deleteDistroLocation(element: DistroLocationItem) {
+		await this.locationHistory.removeLocation(element.name, element.path);
+		this.refresh();
+	}
+
+	private async openRemoteWSLWindow(element: DistroItem, reuseWindow: boolean) {
+		openRemoteWSLWindow(element.name, reuseWindow);
+	}
+
+	private async openRemoteWSLocationWindow(element: DistroLocationItem, reuseWindow: boolean) {
+		openRemoteWSLLocationWindow(element.name, element.path, reuseWindow);
+	}
+
+	private async setDefaultDistro(element: DistroItem) {
+		await setDefaultWSLDistro(this.wslManager, element.name);
+		this.refresh();
+	}
+
+	private async deleteDistro(element: DistroItem) {
+		await deleteWSLDistro(this.wslManager, element.name);
+		this.refresh();
+	}
+}

extensions/open-remote-wsl/src/extension.ts

@@ -0,0 +1,46 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import Log from './common/logger';
+import { RemoteWSLResolver, REMOTE_WSL_AUTHORITY } from './authResolver';
+import { promptOpenRemoteWSLWindow } from './commands';
+import { DistroTreeDataProvider } from './distroTreeView';
+import { getRemoteWorkspaceLocationData, RemoteLocationHistory } from './remoteLocationHistory';
+import { WSLManager } from './wsl/wslManager';
+import { isWindows } from './common/platform';
+
+export async function activate(context: vscode.ExtensionContext) {
+	if (!isWindows) {
+		return;
+	}
+
+	const logger = new Log('Remote - WSL');
+	context.subscriptions.push(logger);
+
+	const wslManager = new WSLManager(logger);
+	const remoteWSLResolver = new RemoteWSLResolver(wslManager, logger);
+	context.subscriptions.push(vscode.workspace.registerRemoteAuthorityResolver(REMOTE_WSL_AUTHORITY, remoteWSLResolver));
+	context.subscriptions.push(remoteWSLResolver);
+
+	const locationHistory = new RemoteLocationHistory(context);
+	const locationData = getRemoteWorkspaceLocationData();
+	if (locationData) {
+		await locationHistory.addLocation(locationData[0], locationData[1]);
+	}
+
+	const distroTreeDataProvider = new DistroTreeDataProvider(locationHistory, wslManager);
+	context.subscriptions.push(vscode.window.createTreeView('wslTargets', { treeDataProvider: distroTreeDataProvider }));
+	context.subscriptions.push(distroTreeDataProvider);
+
+	context.subscriptions.push(vscode.commands.registerCommand('openremotewsl.connect', () => promptOpenRemoteWSLWindow(wslManager, true, true)));
+	context.subscriptions.push(vscode.commands.registerCommand('openremotewsl.connectInNewWindow', () => promptOpenRemoteWSLWindow(wslManager, true, false)));
+	context.subscriptions.push(vscode.commands.registerCommand('openremotewsl.connectUsingDistro', () => promptOpenRemoteWSLWindow(wslManager, false, true)));
+	context.subscriptions.push(vscode.commands.registerCommand('openremotewsl.connectUsingDistroInNewWindow', () => promptOpenRemoteWSLWindow(wslManager, false, false)));
+	context.subscriptions.push(vscode.commands.registerCommand('openremotewsl.showLog', () => logger.show()));
+}
+
+export function deactivate() {
+}

extensions/open-remote-wsl/src/remoteLocationHistory.ts

@@ -0,0 +1,56 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import { REMOTE_WSL_AUTHORITY } from './authResolver';
+
+export class RemoteLocationHistory {
+	private static STORAGE_KEY = 'remoteLocationHistory_v0';
+
+	private remoteLocationHistory: Record<string, string[]> = {};
+
+	constructor(private context: vscode.ExtensionContext) {
+		// context.globalState.update(RemoteLocationHistory.STORAGE_KEY, undefined);
+		this.remoteLocationHistory = context.globalState.get(RemoteLocationHistory.STORAGE_KEY) || {};
+	}
+
+	getHistory(host: string): string[] {
+		return this.remoteLocationHistory[host] || [];
+	}
+
+	async addLocation(host: string, path: string) {
+		const hostLocations = this.remoteLocationHistory[host] || [];
+		if (!hostLocations.includes(path)) {
+			hostLocations.unshift(path);
+			this.remoteLocationHistory[host] = hostLocations;
+
+			await this.context.globalState.update(RemoteLocationHistory.STORAGE_KEY, this.remoteLocationHistory);
+		}
+	}
+
+	async removeLocation(host: string, path: string) {
+		let hostLocations = this.remoteLocationHistory[host] || [];
+		hostLocations = hostLocations.filter(l => l !== path);
+		this.remoteLocationHistory[host] = hostLocations;
+
+		await this.context.globalState.update(RemoteLocationHistory.STORAGE_KEY, this.remoteLocationHistory);
+	}
+}
+
+export function getRemoteWorkspaceLocationData(): [string, string] | undefined {
+	let location = vscode.workspace.workspaceFile;
+	if (location && location.scheme === 'vscode-remote' && location.authority.startsWith(REMOTE_WSL_AUTHORITY) && location.path.endsWith('.code-workspace')) {
+		const [, distroName] = location.authority.split('+');
+		return [distroName, location.path];
+	}
+
+	location = vscode.workspace.workspaceFolders?.[0].uri;
+	if (location && location.scheme === 'vscode-remote' && location.authority.startsWith(REMOTE_WSL_AUTHORITY)) {
+		const [, distroName] = location.authority.split('+');
+		return [distroName, location.path];
+	}
+
+	return undefined;
+}

extensions/open-remote-wsl/src/serverConfig.ts

@@ -0,0 +1,44 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import * as fs from 'fs';
+import * as path from 'path';
+
+let vscodeProductJson: any;
+async function getVSCodeProductJson() {
+	if (!vscodeProductJson) {
+		const productJsonStr = await fs.promises.readFile(path.join(vscode.env.appRoot, 'product.json'), 'utf8');
+		vscodeProductJson = JSON.parse(productJsonStr);
+	}
+
+	return vscodeProductJson;
+}
+
+export interface IServerConfig {
+	version: string;
+	commit: string;
+	quality: string;
+	release?: string; // void-like specific
+	serverApplicationName: string;
+	serverDataFolderName: string;
+	serverDownloadUrlTemplate?: string; // void-like specific
+}
+
+export async function getVSCodeServerConfig(): Promise<IServerConfig> {
+	const productJson = await getVSCodeProductJson();
+
+	return {
+		// version: vscode.version.replace('-insider', ''),
+		commit: productJson.commit,
+		quality: productJson.quality,
+		release: productJson.release,
+		serverApplicationName: productJson.serverApplicationName,
+		serverDataFolderName: productJson.serverDataFolderName,
+		serverDownloadUrlTemplate: productJson.serverDownloadUrlTemplate,
+		// Void changed this
+		version: productJson.voidVersion
+	};
+}

extensions/open-remote-wsl/src/serverSetup.ts

@@ -0,0 +1,353 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as crypto from 'crypto';
+import Log from './common/logger';
+import { getVSCodeServerConfig } from './serverConfig';
+import { WSLManager } from './wsl/wslManager';
+
+export interface ServerInstallOptions {
+	id: string;
+	quality: string;
+	commit: string;
+	version: string;
+	release?: string; // void specific
+	extensionIds: string[];
+	envVariables: string[];
+	serverApplicationName: string;
+	serverDataFolderName: string;
+	serverDownloadUrlTemplate: string;
+}
+
+export interface ServerInstallResult {
+	exitCode: number;
+	listeningOn: number;
+	connectionToken: string;
+	logFile: string;
+	osReleaseId: string;
+	arch: string;
+	platform: string;
+	tmpDir: string;
+	[key: string]: any;
+}
+
+export class ServerInstallError extends Error {
+	constructor(message: string) {
+		super(message);
+	}
+}
+
+const DEFAULT_DOWNLOAD_URL_TEMPLATE = 'https://github.com/voideditor/binaries/releases/download/${version}.${release}/void-reh-${os}-${arch}-${version}.${release}.tar.gz';
+
+export async function installCodeServer(wslManager: WSLManager, distroName: string, serverDownloadUrlTemplate: string | undefined, extensionIds: string[], envVariables: string[], logger: Log): Promise<ServerInstallResult> {
+	const scriptId = crypto.randomBytes(12).toString('hex');
+
+	const vscodeServerConfig = await getVSCodeServerConfig();
+	const installOptions: ServerInstallOptions = {
+		id: scriptId,
+		version: vscodeServerConfig.version,
+		commit: vscodeServerConfig.commit,
+		quality: vscodeServerConfig.quality,
+		release: vscodeServerConfig.release,
+		extensionIds,
+		envVariables,
+		serverApplicationName: vscodeServerConfig.serverApplicationName,
+		serverDataFolderName: vscodeServerConfig.serverDataFolderName,
+		serverDownloadUrlTemplate: serverDownloadUrlTemplate ?? vscodeServerConfig.serverDownloadUrlTemplate ?? DEFAULT_DOWNLOAD_URL_TEMPLATE,
+	};
+
+	const installServerScript = generateBashInstallScript(installOptions);
+
+	// Fish shell does not support heredoc so let's workaround it using -c option,
+	// also replace single quotes (') within the script with ('\'') as there's no quoting within single quotes, see https://unix.stackexchange.com/a/24676
+	const resp = await wslManager.exec('bash', ['-c', `'${installServerScript.replace(/'/g, `'\\''`)}'`], distroName);
+
+	const endScriptRegex = new RegExp(`${scriptId}: Server installation script done`, 'm');
+	const commandOutput = await Promise.race([
+		resp.exitPromise.then(result => ({ stdout: resp.stdout, stderr: resp.stderr, exitCode: result.exitCode })),
+		new Promise<{ stdout: string; stderr: string; exitCode: number }>((resolve) => {
+			resp.onStdoutData(buffer => {
+				if (endScriptRegex.test(buffer.toString('utf8'))) {
+					resolve({ stdout: resp.stdout, stderr: resp.stderr, exitCode: 0 });
+				}
+			});
+		})
+	]);
+
+	if (commandOutput.exitCode) {
+		logger.trace('Server install command stderr:', commandOutput.stderr);
+	}
+	logger.trace('Server install command stdout:', commandOutput.stdout);
+
+	const resultMap = parseServerInstallOutput(commandOutput.stdout, scriptId);
+	if (!resultMap) {
+		throw new ServerInstallError(`Failed parsing install script output`);
+	}
+
+	const exitCode = parseInt(resultMap.exitCode, 10);
+	if (exitCode !== 0) {
+		throw new ServerInstallError(`Couldn't install void server on remote server, install script returned non-zero exit status`);
+	}
+
+	const listeningOn = parseInt(resultMap.listeningOn, 10);
+
+	const remoteEnvVars = Object.fromEntries(Object.entries(resultMap).filter(([key,]) => envVariables.includes(key)));
+
+	return {
+		exitCode,
+		listeningOn,
+		connectionToken: resultMap.connectionToken,
+		logFile: resultMap.logFile,
+		osReleaseId: resultMap.osReleaseId,
+		arch: resultMap.arch,
+		platform: resultMap.platform,
+		tmpDir: resultMap.tmpDir,
+		...remoteEnvVars
+	};
+}
+
+function parseServerInstallOutput(str: string, scriptId: string): { [k: string]: string } | undefined {
+	const startResultStr = `${scriptId}: start`;
+	const endResultStr = `${scriptId}: end`;
+
+	const startResultIdx = str.indexOf(startResultStr);
+	if (startResultIdx < 0) {
+		return undefined;
+	}
+
+	const endResultIdx = str.indexOf(endResultStr, startResultIdx + startResultStr.length);
+	if (endResultIdx < 0) {
+		return undefined;
+	}
+
+	const installResult = str.substring(startResultIdx + startResultStr.length, endResultIdx);
+
+	const resultMap: { [k: string]: string } = {};
+	const resultArr = installResult.split(/\r?\n/);
+	for (const line of resultArr) {
+		const [key, value] = line.split('==');
+		resultMap[key] = value;
+	}
+
+	return resultMap;
+}
+
+function generateBashInstallScript({ id, quality, version, commit, release, extensionIds, envVariables, serverApplicationName, serverDataFolderName, serverDownloadUrlTemplate }: ServerInstallOptions) {
+	const extensions = extensionIds.map(id => '--install-extension ' + id).join(' ');
+	return `
+# Server installation script
+
+TMP_DIR="\${XDG_RUNTIME_DIR:-"/tmp"}"
+
+DISTRO_VERSION="${version}"
+DISTRO_COMMIT="${commit}"
+DISTRO_QUALITY="${quality}"
+DISTRO_VSCODIUM_RELEASE="${release ?? ''}"
+
+SERVER_APP_NAME="${serverApplicationName}"
+SERVER_INITIAL_EXTENSIONS="${extensions}"
+SERVER_LISTEN_FLAG="--port=0"
+SERVER_DATA_DIR="$HOME/${serverDataFolderName}"
+SERVER_DIR="$SERVER_DATA_DIR/bin/$DISTRO_COMMIT"
+SERVER_SCRIPT="$SERVER_DIR/bin/$SERVER_APP_NAME"
+SERVER_LOGFILE="$SERVER_DATA_DIR/.$DISTRO_COMMIT.log"
+SERVER_PIDFILE="$SERVER_DATA_DIR/.$DISTRO_COMMIT.pid"
+SERVER_TOKENFILE="$SERVER_DATA_DIR/.$DISTRO_COMMIT.token"
+SERVER_OS=
+SERVER_ARCH=
+SERVER_CONNECTION_TOKEN=
+SERVER_DOWNLOAD_URL=
+
+LISTENING_ON=
+OS_RELEASE_ID=
+ARCH=
+PLATFORM=
+
+# Mimic output from logs of remote-ssh extension
+print_install_results_and_exit() {
+	echo "${id}: start"
+	echo "exitCode==$1=="
+	echo "listeningOn==$LISTENING_ON=="
+	echo "connectionToken==$SERVER_CONNECTION_TOKEN=="
+	echo "logFile==$SERVER_LOGFILE=="
+	echo "osReleaseId==$OS_RELEASE_ID=="
+	echo "arch==$ARCH=="
+	echo "platform==$PLATFORM=="
+	echo "tmpDir==$TMP_DIR=="
+	${envVariables.map(envVar => `echo "${envVar}==$${envVar}=="`).join('\n')}
+	echo "${id}: end"
+	exit 0
+}
+
+# Check if platform is supported
+PLATFORM="$(uname -s)"
+case $PLATFORM in
+	Linux)
+		SERVER_OS="linux"
+		;;
+	*)
+		echo "Error platform not supported: $PLATFORM"
+		print_install_results_and_exit 1
+		;;
+esac
+
+# Check machine architecture
+ARCH="$(uname -m)"
+case $ARCH in
+	x86_64 | amd64)
+		SERVER_ARCH="x64"
+		;;
+	armv7l | armv8l)
+		SERVER_ARCH="armhf"
+		;;
+	arm64 | aarch64)
+		SERVER_ARCH="arm64"
+		;;
+	*)
+		echo "Error architecture not supported: $ARCH"
+		print_install_results_and_exit 1
+		;;
+esac
+
+# https://www.freedesktop.org/software/systemd/man/os-release.html
+OS_RELEASE_ID="$(grep -i '^ID=' /etc/os-release 2>/dev/null | sed 's/^ID=//gi' | sed 's/"//g')"
+if [[ -z $OS_RELEASE_ID ]]; then
+	OS_RELEASE_ID="$(grep -i '^ID=' /usr/lib/os-release 2>/dev/null | sed 's/^ID=//gi' | sed 's/"//g')"
+	if [[ -z $OS_RELEASE_ID ]]; then
+		OS_RELEASE_ID="unknown"
+	fi
+fi
+
+# Create installation folder
+if [[ ! -d $SERVER_DIR ]]; then
+	mkdir -p $SERVER_DIR
+	if (( $? > 0 )); then
+		echo "Error creating server install directory"
+		print_install_results_and_exit 1
+	fi
+fi
+
+SERVER_DOWNLOAD_URL="$(echo "${serverDownloadUrlTemplate.replace(/\$\{/g, '\\${')}" | sed "s/\\\${quality}/$DISTRO_QUALITY/g" | sed "s/\\\${version}/$DISTRO_VERSION/g" | sed "s/\\\${commit}/$DISTRO_COMMIT/g" | sed "s/\\\${os}/$SERVER_OS/g" | sed "s/\\\${arch}/$SERVER_ARCH/g" | sed "s/\\\${release}/$DISTRO_VSCODIUM_RELEASE/g")"
+
+# Check if server script is already installed
+if [[ ! -f $SERVER_SCRIPT ]]; then
+	if [[ "$SERVER_OS" = "dragonfly" ]] || [[ "$SERVER_OS" = "freebsd" ]]; then
+		echo "Error "$SERVER_OS" needs manual installation of remote extension host"
+		print_install_results_and_exit 1
+	fi
+
+	pushd $SERVER_DIR > /dev/null
+
+	if [[ ! -z $(which wget) ]]; then
+		wget --tries=3 --timeout=10 --continue --no-verbose -O vscode-server.tar.gz $SERVER_DOWNLOAD_URL
+	elif [[ ! -z $(which curl) ]]; then
+		curl --retry 3 --connect-timeout 10 --location --show-error --silent --output vscode-server.tar.gz $SERVER_DOWNLOAD_URL
+	else
+		echo "Error no tool to download server binary"
+		print_install_results_and_exit 1
+	fi
+
+	if (( $? > 0 )); then
+		echo "Error downloading server from $SERVER_DOWNLOAD_URL"
+		print_install_results_and_exit 1
+	fi
+
+	tar -xf vscode-server.tar.gz --strip-components 1
+	if (( $? > 0 )); then
+		echo "Error while extracting server contents"
+		print_install_results_and_exit 1
+	fi
+
+	if [[ ! -f $SERVER_SCRIPT ]]; then
+		echo "Error server contents are corrupted"
+		print_install_results_and_exit 1
+	fi
+
+	rm -f vscode-server.tar.gz
+
+	popd > /dev/null
+else
+	echo "Server script already installed in $SERVER_SCRIPT"
+fi
+
+# Try to find if server is already running
+if [[ -f $SERVER_PIDFILE ]]; then
+	SERVER_PID="$(cat $SERVER_PIDFILE)"
+	SERVER_RUNNING_PROCESS="$(ps -o pid,args -p $SERVER_PID | grep $SERVER_SCRIPT)"
+else
+	SERVER_RUNNING_PROCESS="$(ps -o pid,args -A | grep $SERVER_SCRIPT | grep -v grep)"
+fi
+
+if [[ -z $SERVER_RUNNING_PROCESS ]]; then
+	if [[ -f $SERVER_LOGFILE ]]; then
+		rm $SERVER_LOGFILE
+	fi
+	if [[ -f $SERVER_TOKENFILE ]]; then
+		rm $SERVER_TOKENFILE
+	fi
+
+	touch $SERVER_TOKENFILE
+	chmod 600 $SERVER_TOKENFILE
+	SERVER_CONNECTION_TOKEN="${crypto.randomUUID()}"
+	echo $SERVER_CONNECTION_TOKEN > $SERVER_TOKENFILE
+
+	$SERVER_SCRIPT --start-server --host=127.0.0.1 $SERVER_LISTEN_FLAG $SERVER_INITIAL_EXTENSIONS --connection-token-file $SERVER_TOKENFILE --telemetry-level off --use-host-proxy --disable-websocket-compression --without-browser-env-var --enable-remote-auto-shutdown --accept-server-license-terms &> $SERVER_LOGFILE &
+	echo $! > $SERVER_PIDFILE
+else
+	echo "Server script is already running $SERVER_SCRIPT"
+fi
+
+if [[ -f $SERVER_TOKENFILE ]]; then
+	SERVER_CONNECTION_TOKEN="$(cat $SERVER_TOKENFILE)"
+else
+	echo "Error server token file not found $SERVER_TOKENFILE"
+	print_install_results_and_exit 1
+fi
+
+if [[ -f $SERVER_LOGFILE ]]; then
+	for i in {1..5}; do
+		LISTENING_ON="$(cat $SERVER_LOGFILE | grep -E 'Extension host agent listening on .+' | sed 's/Extension host agent listening on //')"
+		if [[ -n $LISTENING_ON ]]; then
+			break
+		fi
+		sleep 0.5
+	done
+
+	if [[ -z $LISTENING_ON ]]; then
+		echo "Error server did not start sucessfully"
+		print_install_results_and_exit 1
+	fi
+else
+	echo "Error server log file not found $SERVER_LOGFILE"
+	print_install_results_and_exit 1
+fi
+
+# Finish server setup and keep script running
+if [[ -z $SERVER_RUNNING_PROCESS ]]; then
+	echo "${id}: start"
+	echo "exitCode==0=="
+	echo "listeningOn==$LISTENING_ON=="
+	echo "connectionToken==$SERVER_CONNECTION_TOKEN=="
+	echo "logFile==$SERVER_LOGFILE=="
+	echo "osReleaseId==$OS_RELEASE_ID=="
+	echo "arch==$ARCH=="
+	echo "platform==$PLATFORM=="
+	echo "tmpDir==$TMP_DIR=="
+	${envVariables.map(envVar => `echo "${envVar}==$${envVar}=="`).join('\n')}
+	echo "${id}: end"
+
+	echo "${id}: Server installation script done"
+
+	SERVER_PID="$(cat $SERVER_PIDFILE)"
+	SERVER_RUNNING_PROCESS="$(ps -o pid,args -p $SERVER_PID | grep $SERVER_SCRIPT)"
+	while [[ -n $SERVER_RUNNING_PROCESS ]]; do
+		sleep 300;
+		SERVER_RUNNING_PROCESS="$(ps -o pid,args -p $SERVER_PID | grep $SERVER_SCRIPT)"
+	done
+else
+	print_install_results_and_exit 0
+fi
+`;
+}

extensions/open-remote-wsl/src/wsl/wslManager.ts

@@ -0,0 +1,150 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as cp from 'child_process';
+import Log from '../common/logger';
+import { EventEmitter } from '../common/event';
+
+const wslBinary = 'wsl.exe';
+
+export interface WSLDistro {
+	isDefault: boolean;
+	name: string;
+	state: string;
+	version: string;
+}
+
+export interface WSLOnlineDistro {
+	name: string;
+	friendlyName: string;
+}
+
+export class WSLManager {
+	constructor(private readonly logger: Log) {
+	}
+
+	async listDistros() {
+		const resp = this._runWSLCommand(['--list', '--verbose'], 'utf16le');
+		const { exitCode } = await resp.exitPromise;
+		const { stdout, stderr } = resp;
+		if (exitCode) {
+			this.logger.trace(`Command wsl listDistros exited with code ${exitCode}`, stdout + '\n\n' + stderr);
+			throw new Error(`Command wsl listDistros exited with code ${exitCode}`);
+		}
+
+		const regex = /(?<default>\*|\s)\s+(?<name>[\w\.-]+)\s+(?<state>[\w]+)\s+(?<version>\d)/;
+		const distros: WSLDistro[] = [];
+		for (const line of stdout.split(/\r?\n/)) {
+			const matches = line.match(regex);
+			if (matches && matches.groups) {
+				distros.push({
+					isDefault: matches.groups.default === '*',
+					name: matches.groups.name,
+					state: matches.groups.state,
+					version: matches.groups.version,
+				});
+			}
+		}
+
+		return distros;
+	}
+
+	async listOnlineDistros() {
+		const resp = this._runWSLCommand(['--list', '--online'], 'utf16le');
+		const { exitCode } = await resp.exitPromise;
+		const { stdout, stderr } = resp;
+		if (exitCode) {
+			this.logger.trace(`Command wsl listOnlineDistros exited with code ${exitCode}`, stdout + '\n\n' + stderr);
+			throw new Error(`Command wsl listOnlineDistros exited with code ${exitCode}`);
+		}
+
+		let lines = stdout.split(/\r?\n/);
+		const idx = lines.findIndex(l => /\s*NAME\s+FRIENDLY NAME\s*/.test(l));
+		lines = lines.slice(idx + 1);
+
+		const regex = /(?<name>[\w\.-]+)\s+(?<friendlyName>\w.+\w)/;
+		const distros: WSLOnlineDistro[] = [];
+		for (const line of lines) {
+			const matches = line.match(regex);
+			if (matches && matches.groups) {
+				distros.push({
+					name: matches.groups.name,
+					friendlyName: matches.groups.friendlyName,
+				});
+			}
+		}
+
+		return distros;
+	}
+
+	async setDefaultDistro(distroName: string) {
+		const resp = this._runWSLCommand(['--set-default', distroName], 'utf16le');
+		const { exitCode } = await resp.exitPromise;
+		const { stdout, stderr } = resp;
+		if (exitCode) {
+			this.logger.trace(`Command wsl setDefaultDistro exited with code ${exitCode}`, stdout + '\n\n' + stderr);
+			throw new Error(`Command wsl setDefaultDistro exited with code ${exitCode}`);
+		}
+	}
+
+	async deleteDistro(distroName: string) {
+		const resp = this._runWSLCommand(['--unregister', distroName], 'utf16le');
+		const { exitCode } = await resp.exitPromise;
+		const { stdout, stderr } = resp;
+		if (exitCode) {
+			this.logger.trace(`Command wsl deleteDistro exited with code ${exitCode}`, stdout + '\n\n' + stderr);
+			throw new Error(`Command wsl deleteDistro exited with code ${exitCode}`);
+		}
+	}
+
+	async exec(cmd: string, args: string[], distro: string) {
+		return this._runWSLCommand(['--distribution', distro, '--', cmd, ...args], 'utf8');
+	}
+
+	private _runWSLCommand(args: string[], encoding: 'utf8' | 'utf16le') {
+		this.logger.trace(`Running WSL command: ${wslBinary} ${args.join(' ')}`);
+
+		const cmd = cp.spawn(wslBinary, args, { windowsHide: true, windowsVerbatimArguments: true });
+
+		const stdoutDataEmitter = new EventEmitter<Buffer>();
+		const stdoutData: Buffer[] = [];
+		const stderrDataEmitter = new EventEmitter<Buffer>();
+		const stderrData: Buffer[] = [];
+		cmd.stdout.on('data', (data: Buffer) => {
+			stdoutData.push(data);
+			stdoutDataEmitter.fire(data);
+		});
+		cmd.stderr.on('data', (data: Buffer) => {
+			stderrData.push(data);
+			stderrDataEmitter.fire(data);
+		});
+
+		const exitPromise = new Promise<{ exitCode: number }>((resolve, reject) => {
+			cmd.on('error', (err) => {
+				this.logger.error(`Error running WSL command: ${wslBinary} ${args.join(' ')}`, err);
+				reject(err);
+			});
+			cmd.on('exit', (code, _signal) => {
+				resolve({ exitCode: code ?? 0 });
+			});
+		});
+
+		return {
+			get stdout() {
+				return Buffer.concat(stdoutData).toString(encoding);
+			},
+			get stderr() {
+				return Buffer.concat(stderrData).toString(encoding);
+			},
+			get onStdoutData() {
+				return stdoutDataEmitter.event;
+			},
+			get onStderrData() {
+				return stderrDataEmitter.event;
+			},
+			exitPromise
+		};
+	}
+}

extensions/open-remote-wsl/src/wsl/wslTerminal.ts

@@ -0,0 +1,26 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+
+class WSLTerminal {
+	static NAME = 'WSL';
+
+	private getTerminal() {
+		const wslTerminal = vscode.window.terminals.find(t => t.name === WSLTerminal.NAME);
+		if (wslTerminal) {
+			return wslTerminal;
+		}
+		return vscode.window.createTerminal(WSLTerminal.NAME);
+	}
+
+	runCommand(command: string) {
+		const wslTerminal = this.getTerminal();
+		wslTerminal.show(false);
+		wslTerminal.sendText(command, true);
+	}
+}
+
+export default new WSLTerminal();

extensions/open-remote-wsl/tsconfig.json

@@ -0,0 +1,12 @@
+{
+	"extends": "../tsconfig.base.json",
+	"compilerOptions": {
+		"outDir": "./out",
+	},
+	"include": [
+		"src/**/*",
+		"../../src/vscode-dts/vscode.d.ts",
+		"../../src/vscode-dts/vscode.proposed.resolvers.d.ts",
+		"../../src/vscode-dts/vscode.proposed.contribViewsRemote.d.ts",
+	]
+}

package-lock.json

@@ -62,6 +62,7 @@
         "posthog-node": "^4.8.1",
         "react": "^19.0.0",
         "react-dom": "^19.0.0",
+        "react-tooltip": "^5.28.1",
         "tas-client-umd": "0.2.0",
         "v8-inspect-profiler": "^0.1.1",
         "vscode-html-languageservice": "^5.3.1",
@@ -6621,6 +6622,12 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/classnames": {
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/classnames/-/classnames-2.5.1.tgz",
+      "integrity": "sha512-saHYOzhIQs6wy2sVxTM6bUDsQO4F50V9RQ22qBpEdCW+I+/Wmke2HOl6lS6dTpdxVhb88/I6+Hs+438c3lfUow==",
+      "license": "MIT"
+    },
     "node_modules/cli-cursor": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-4.0.0.tgz",
@@ -15094,10 +15101,11 @@
       }
     },
     "node_modules/nan": {
-      "version": "2.14.2",
-      "resolved": "https://registry.npmjs.org/nan/-/nan-2.14.2.tgz",
-      "integrity": "sha512-M2ufzIiINKCuDfBSAUr1vWQ+vuVcA9kqx8JJUsbQi6yf1uGRyb7HfpdfUr5qLXf3B/t8dPvcjhKMmlfnP47EzQ==",
+      "version": "2.22.2",
+      "resolved": "https://registry.npmjs.org/nan/-/nan-2.22.2.tgz",
+      "integrity": "sha512-DANghxFkS1plDdRsX0X9pm0Z6SJNN6gBdtXfanwoZ8hooC5gosGFSBGRYHUVPz1asKA/kMRqDRdHrluZ61SpBQ==",
       "dev": true,
+      "license": "MIT",
       "optional": true
     },
     "node_modules/nanoid": {
@@ -17999,6 +18007,20 @@
       "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==",
       "license": "MIT"
     },
+    "node_modules/react-tooltip": {
+      "version": "5.28.1",
+      "resolved": "https://registry.npmjs.org/react-tooltip/-/react-tooltip-5.28.1.tgz",
+      "integrity": "sha512-ZA4oHwoIIK09TS7PvSLFcRlje1wGZaxw6xHvfrzn6T82UcMEfEmHVCad16Gnr4NDNDh93HyN037VK4HDi5odfQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@floating-ui/dom": "^1.6.1",
+        "classnames": "^2.3.0"
+      },
+      "peerDependencies": {
+        "react": ">=16.14.0",
+        "react-dom": ">=16.14.0"
+      }
+    },
     "node_modules/read-cache": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz",
@@ -18807,10 +18829,11 @@
       }
     },
     "node_modules/sax": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz",
-      "integrity": "sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==",
-      "dev": true
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/sax/-/sax-1.4.1.tgz",
+      "integrity": "sha512-+aWOz7yVScEGoKNd4PA10LZ8sk0A/z5+nXQG5giUO5rprX9jgYsTdov9qCchZiPIZezbZH+jRut8nPodFAX4Jg==",
+      "dev": true,
+      "license": "ISC"
     },
     "node_modules/scheduler": {
       "version": "0.25.0",

package.json

@@ -123,6 +123,7 @@
     "posthog-node": "^4.8.1",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
+    "react-tooltip": "^5.28.1",
     "tas-client-umd": "0.2.0",
     "v8-inspect-profiler": "^0.1.1",
     "vscode-html-languageservice": "^5.3.1",

product.json

@@ -1,7 +1,7 @@
 {
 	"nameShort": "Void",
 	"nameLong": "Void",
-	"voidVersion": "1.0.3",
+	"voidVersion": "1.2.3",
 	"applicationName": "void",
 	"dataFolderName": ".void-editor",
 	"win32MutexName": "voideditor",

scripts/appimage/create-appimage-old.sh

@@ -34,11 +34,8 @@ mkdir -pv "$APP_DIR/usr/share/icons/hicolor/256x256/apps"
 
 # Exclude create-appimage.sh and appimagetool-x86_64.AppImage from being copied
 echo "Copying files excluding create-appimage.sh and appimagetool-x86_64.AppImage..."
-for file in ./*; do
-    if [[ "$file" != "./create-appimage.sh" && "$file" != "./appimagetool-x86_64.AppImage" ]]; then
-        cp -rv "$file" "$APP_DIR/usr/bin/"
-    fi
-done
+
+cp -v ./void "$APP_DIR/usr/bin/"
 
 # Copy the icon to required locations
 cp -v ./void.png "$APP_DIR/void.png"

scripts/appimage/readme.md

@@ -1,3 +1,16 @@
+
+
+# README
+
+This is a community-made AppImage creation script.
+
+There are some reported bugs with it.
+
+To generate an AppImage yourself, feel free to look at
+stable-linux.yml in the separate `void-builder/` repo,
+which runs a GitHub Action that builds the AppImage you see on our website.
+
+
 # Void AppImage Creation Script
 
 This script automates the process of creating an AppImage for the  Void Editor using Docker. It works on macOS and Linux platforms.

src/bootstrap-fork.ts

@@ -3,6 +3,9 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+// This bootstrap-fork module handles the initialization of a forked process in VS Code.
+// It sets up logging, exception handling, and loads the ESM module system.
+
 import * as performance from './vs/base/common/performance.js';
 import { removeGlobalNodeJsModuleLookupPaths, devInjectNodeModuleLookupPath } from './bootstrap-node.js';
 import { bootstrapESM } from './bootstrap-esm.js';

src/vs/editor/contrib/smartSelect/browser/smartSelect.ts

@@ -121,6 +121,93 @@ export class SmartSelectController implements IEditorContribution {
 		}
 		this._state = this._state.map(state => state.mov(forward));
 		const newSelections = this._state.map(state => Selection.fromPositions(state.ranges[state.index].getStartPosition(), state.ranges[state.index].getEndPosition()));
+
+		// Void changed this to skip over added whitespace when using smartSelect
+		// // Store the original selections for comparison
+		// const originalSelections = selections;
+
+		// // Keep skipping while we're only adding/removing whitespace
+		// let keepSkipping = true;
+		// let skipCount = 0;
+		// const MAX_SKIPS = 5; // Avoid infinite loops by setting a reasonable limit
+
+		// while (keepSkipping && skipCount < MAX_SKIPS) {
+		// 	keepSkipping = false; // Reset for each iteration
+
+		// 	// Check if all selections only added/removed whitespace
+		// 	if (originalSelections.length === newSelections.length) {
+		// 		for (let i = 0; i < originalSelections.length; i++) {
+		// 			const oldSel = originalSelections[i];
+		// 			const newSel = newSelections[i];
+
+		// 			if (forward) { // For expanding (^+Shift+Right)
+		// 				// Skip if only whitespace was added
+		// 				const oldText = model.getValueInRange(oldSel).trim();
+		// 				const newText = model.getValueInRange(newSel).trim();
+		// 				const onlyWhitespaceAdded = oldText === newText && oldText.length > 0;
+
+		// 				if (onlyWhitespaceAdded) {
+		// 					console.log(`SMART SELECT - SKIPPING (EXPAND) [${skipCount + 1}]:`, {
+		// 						reason: 'only whitespace added',
+		// 						oldText: model.getValueInRange(oldSel),
+		// 						newText: model.getValueInRange(newSel)
+		// 					});
+		// 					keepSkipping = true;
+		// 					break;
+		// 				}
+		// 			} else { // For shrinking (^+Shift+Left)
+		// 				// Skip if only whitespace was removed
+		// 				const oldText = model.getValueInRange(oldSel).trim();
+		// 				const newText = model.getValueInRange(newSel).trim();
+		// 				const onlyWhitespaceRemoved = oldText === newText && newText.length > 0;
+
+		// 				if (onlyWhitespaceRemoved) {
+		// 					console.log(`SMART SELECT - SKIPPING (SHRINK) [${skipCount + 1}]:`, {
+		// 						reason: 'only whitespace removed',
+		// 						oldText: model.getValueInRange(oldSel),
+		// 						newText: model.getValueInRange(newSel)
+		// 					});
+		// 					keepSkipping = true;
+		// 					break;
+		// 				}
+		// 			}
+		// 		}
+		// 	}
+
+		// 	// If we need to skip, move one more time
+		// 	if (keepSkipping) {
+		// 		skipCount++;
+
+		// 		// Try to move to the next range
+		// 		const prevState = this._state;
+		// 		this._state = this._state.map(state => state.mov(forward));
+
+		// 		// Check if we've reached the end of available ranges
+		// 		const stateUnchanged = this._state.every((state, idx) =>
+		// 			state.index === prevState[idx].index
+		// 		);
+
+		// 		if (stateUnchanged) {
+		// 			// We can't move any further, so stop skipping
+		// 			keepSkipping = false;
+		// 		} else {
+		// 			// Update selections for the next iteration
+		// 			newSelections = this._state.map(state => Selection.fromPositions(
+		// 				state.ranges[state.index].getStartPosition(),
+		// 				state.ranges[state.index].getEndPosition()
+		// 			));
+		// 		}
+		// 	}
+		// }
+
+		// // Print AFTER selection (before actually setting it)
+		// console.log('SMART SELECT - AFTER:', newSelections.map(s => {
+		// 	return {
+		// 		range: `(${s.startLineNumber},${s.startColumn}) -> (${s.endLineNumber},${s.endColumn})`,
+		// 		text: model.getValueInRange(s)
+		// 	};
+		// }));
+
 		this._ignoreSelection = true;
 		try {
 			this._editor.setSelections(newSelections);

src/vs/workbench/browser/parts/auxiliarybar/auxiliaryBarPart.ts

@@ -52,7 +52,7 @@ export class AuxiliaryBarPart extends AbstractPaneCompositePart {
 	static readonly viewContainersWorkspaceStateKey = 'workbench.auxiliarybar.viewContainersWorkspaceState';
 
 	// Use the side bar dimensions
-	override readonly minimumWidth: number = 230; // Void changed this (was 170)
+	override readonly minimumWidth: number = 280; // Void changed this (was 170)
 	override readonly maximumWidth: number = Number.POSITIVE_INFINITY;
 	override readonly minimumHeight: number = 0;
 	override readonly maximumHeight: number = Number.POSITIVE_INFINITY;

src/vs/workbench/browser/parts/editor/editorGroupWatermark.ts

@@ -22,10 +22,12 @@ import { ColorScheme } from '../../web.api.js';
 import { OpenFileFolderAction, OpenFolderAction } from '../../actions/workspaceActions.js';
 import { IWindowOpenable } from '../../../../platform/window/common/window.js';
 import { splitRecentLabel } from '../../../../base/common/labels.js';
+import { IViewsService } from '../../../services/views/common/viewsService.js';
 
 /* eslint-disable */ // Void
 import { VOID_CTRL_K_ACTION_ID, VOID_CTRL_L_ACTION_ID } from '../../../contrib/void/browser/actionIDs.js';
 import { VOID_OPEN_SETTINGS_ACTION_ID } from '../../../contrib/void/browser/voidSettingsPane.js';
+import { VIEWLET_ID as REMOTE_EXPLORER_VIEWLET_ID } from '../../../contrib/remote/browser/remoteExplorer.js';
 /* eslint-enable */
 
 // interface WatermarkEntry {
@@ -98,6 +100,7 @@ export class EditorGroupWatermark extends Disposable {
 		@ICommandService private readonly commandService: ICommandService,
 		@IHostService private readonly hostService: IHostService,
 		@ILabelService private readonly labelService: ILabelService,
+		@IViewsService private readonly viewsService: IViewsService,
 	) {
 		super();
 
@@ -182,14 +185,21 @@ export class EditorGroupWatermark extends Disposable {
 			// Void - if the workbench is empty, show open
 			if (this.contextService.getWorkbenchState() === WorkbenchState.EMPTY) {
 
+				// Create a flex container for buttons with vertical direction
+				const buttonContainer = $('div');
+				buttonContainer.style.display = 'flex';
+				buttonContainer.style.flexDirection = 'column'; // Change to column for vertical stacking
+				buttonContainer.style.alignItems = 'center'; // Center the buttons horizontally
+				buttonContainer.style.gap = '8px'; // Reduce gap between buttons from 16px to 8px
+				buttonContainer.style.marginBottom = '16px';
+				voidIconBox.appendChild(buttonContainer);
+
 				// Open a folder
 				const openFolderButton = h('button')
-				openFolderButton.root.classList.add('void-watermark-button')
+				openFolderButton.root.classList.add('void-openfolder-button')
 				openFolderButton.root.style.display = 'block'
-				openFolderButton.root.style.marginLeft = 'auto'
-				openFolderButton.root.style.marginRight = 'auto'
-				openFolderButton.root.style.marginBottom = '16px'
-				openFolderButton.root.textContent = 'Open a folder'
+				openFolderButton.root.style.width = '124px' // Set width to 124px as requested
+				openFolderButton.root.textContent = 'Open Folder'
 				openFolderButton.root.onclick = () => {
 					this.commandService.executeCommand(isMacintosh && isNative ? OpenFileFolderAction.ID : OpenFolderAction.ID)
 					// if (this.contextKeyService.contextMatchesRules(ContextKeyExpr.and(WorkbenchStateContext.isEqualTo('workspace')))) {
@@ -198,7 +208,19 @@ export class EditorGroupWatermark extends Disposable {
 					// 	this.commandService.executeCommand(isMacintosh ? 'workbench.action.files.openFileFolder' : 'workbench.action.files.openFolder');
 					// }
 				}
-				voidIconBox.appendChild(openFolderButton.root);
+				buttonContainer.appendChild(openFolderButton.root);
+
+				// Open SSH button
+				const openSSHButton = h('button')
+				openSSHButton.root.classList.add('void-openssh-button')
+				openSSHButton.root.style.display = 'block'
+				openSSHButton.root.style.backgroundColor = '#5a5a5a' // Made darker than the default gray
+				openSSHButton.root.style.width = '124px' // Set width to 124px as requested
+				openSSHButton.root.textContent = 'Open SSH'
+				openSSHButton.root.onclick = () => {
+					this.viewsService.openViewContainer(REMOTE_EXPLORER_VIEWLET_ID);
+				}
+				buttonContainer.appendChild(openSSHButton.root);
 
 
 				// Recents
@@ -244,6 +266,9 @@ export class EditorGroupWatermark extends Disposable {
 
 							const dirSpan = $('span');
 							dirSpan.style.paddingLeft = '4px';
+							dirSpan.style.whiteSpace = 'nowrap';
+							dirSpan.style.overflow = 'hidden';
+							dirSpan.style.maxWidth = '300px';
 							dirSpan.innerText = parentPath;
 							dirSpan.title = fullPath;
 

src/vs/workbench/browser/parts/editor/media/editorgroupview.css

@@ -50,6 +50,7 @@
 }
 
 /* light */
+.void-void-icon,
 .monaco-workbench .part.editor > .content .editor-group-container > .editor-group-watermark > .letterpress {
 	width: 100%;
 	max-height: 100%;
@@ -60,14 +61,17 @@
 	background-repeat: no-repeat;
 }
 
+.void-void-icon,
 .monaco-workbench.vs-dark .part.editor > .content .editor-group-container .editor-group-watermark > .letterpress {
 	background-image: url('./void_cube_noshadow.png'); /* // Void */
 }
 
+.void-void-icon,
 .monaco-workbench.hc-light .part.editor > .content .editor-group-container .editor-group-watermark > .letterpress {
 	background-image: url('./void_cube_noshadow.png'); /* // Void */
 }
 
+.void-void-icon,
 .monaco-workbench.hc-black .part.editor > .content .editor-group-container .editor-group-watermark > .letterpress {
 	background-image: url('./void_cube_noshadow.png'); /* // Void */
 }

src/vs/workbench/browser/workbench.contribution.ts

@@ -612,7 +612,7 @@ const registry = Registry.as<IConfigurationRegistry>(ConfigurationExtensions.Con
 				'description': localize('workbench.hover.delay', "Controls the delay in milliseconds after which the hover is shown for workbench items (ex. some extension provided tree view items). Already visible items may require a refresh before reflecting this setting change."),
 				// Testing has indicated that on Windows and Linux 500 ms matches the native hovers most closely.
 				// On Mac, the delay is 1500.
-				'default': isMacintosh ? 1500 : 500,
+				'default': 300, // Void changed this from isMacintosh ? 1500 : 500,
 				'minimum': 0
 			},
 			'workbench.reduceMotion': {

src/vs/workbench/contrib/chat/browser/actions/chatActions.ts

@@ -648,15 +648,18 @@ const defaultChat = {
 	providerSetting: product.defaultChatAgent?.providerSetting ?? '',
 };
 
+// Void commented this out - copilot head
 // Add next to the command center if command center is disabled
-MenuRegistry.appendMenuItem(MenuId.CommandCenter, {
+/* MenuRegistry.appendMenuItem(MenuId.CommandCenter, {
 	submenu: MenuId.ChatTitleBarMenu,
 	title: localize('title4', "Copilot"),
 	icon: Codicon.copilot,
-	when: ContextKeyExpr.and(
-		ChatContextKeys.supported,
-		ContextKeyExpr.has('config.chat.commandCenter.enabled')
-	),
+	// Void commented this out - copilot head
+	when: ContextKeyExpr.false(),
+	// when: ContextKeyExpr.and(
+	// 	ChatContextKeys.supported,
+	// 	ContextKeyExpr.has('config.chat.commandCenter.enabled')
+	// ),
 	order: 10001 // to the right of command center
 });
 
@@ -666,13 +669,15 @@ MenuRegistry.appendMenuItem(MenuId.TitleBar, {
 	title: localize('title4', "Copilot"),
 	group: 'navigation',
 	icon: Codicon.copilot,
-	when: ContextKeyExpr.and(
-		ChatContextKeys.supported,
-		ContextKeyExpr.has('config.chat.commandCenter.enabled'),
-		ContextKeyExpr.has('config.window.commandCenter').negate(),
-	),
+	when: ContextKeyExpr.false(),
+	// Void commented this out - copilot head
+	// when: ContextKeyExpr.and(
+	// 	ChatContextKeys.supported,
+	// 	ContextKeyExpr.has('config.chat.commandCenter.enabled'),
+	// 	ContextKeyExpr.has('config.window.commandCenter').negate(),
+	// ),
 	order: 1
-});
+}); */
 
 registerAction2(class ToggleCopilotControl extends ToggleTitleBarConfigAction {
 	constructor() {

src/vs/workbench/contrib/void/browser/_dummyContrib.ts

@@ -6,6 +6,7 @@
 import { KeyCode, KeyMod } from '../../../../base/common/keyCodes.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
 import { ServicesAccessor } from '../../../../editor/browser/editorExtensions.js';
+import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.js';
 import { localize2 } from '../../../../nls.js';
 import { Action2, registerAction2 } from '../../../../platform/actions/common/actions.js';
 import { InstantiationType, registerSingleton } from '../../../../platform/instantiation/common/extensions.js';
@@ -14,15 +15,16 @@ import { KeybindingWeight } from '../../../../platform/keybinding/common/keybind
 import { IWorkbenchContribution, registerWorkbenchContribution2, WorkbenchPhase } from '../../../common/contributions.js';
 
 
+// to change this, just Cmd+Shift+F and replace DummyService with YourServiceName, and create a unique ID below
 export interface IDummyService {
-	readonly _serviceBrand: undefined;
+	readonly _serviceBrand: undefined; // services need this, just leave it undefined
 }
 
 export const IDummyService = createDecorator<IDummyService>('DummyService');
 
 
 
-
+// An example of an action (delete if you're not using an action):
 registerAction2(class extends Action2 {
 	constructor() {
 		super({
@@ -42,18 +44,21 @@ registerAction2(class extends Action2 {
 	}
 })
 
-// on mount
+
 class DummyService extends Disposable implements IWorkbenchContribution, IDummyService {
-	static readonly ID = 'workbench.contrib.void.dummy'
+	static readonly ID = 'workbench.contrib.void.dummy' // workbenchContributions need this, services do not
 	_serviceBrand: undefined;
 
 	constructor(
+		@ICodeEditorService codeEditorService: ICodeEditorService,
 	) {
 		super()
 
 	}
 }
 
+
+// pick one and delete the other:
 registerSingleton(IDummyService, DummyService, InstantiationType.Eager);
 
 registerWorkbenchContribution2(DummyService.ID, DummyService, WorkbenchPhase.BlockRestore);

src/vs/workbench/contrib/void/browser/aiRegexService.ts

@@ -34,7 +34,7 @@
 // 	// 			const result = await new Promise((res, rej) => {
 // 	// 				sendLLMMessage({
 // 	// 					messages,
-// 	// 					tools: ['search_files'],
+// 	// 					tools: ['search_for_files'],
 // 	// 					onFinalMessage: ({ result: r, }) => {
 // 	// 						res(r)
 // 	// 					},
@@ -73,7 +73,7 @@
 // 	// 	const result = new Promise((res, rej) => {
 // 	// 		sendLLMMessage({
 // 	// 			messages,
-// 	// 			tools: ['search_files'],
+// 	// 			tools: ['search_for_files'],
 // 	// 			onResult: (r) => {
 // 	// 				res(r)
 // 	// 			}

src/vs/workbench/contrib/void/browser/autocompleteService.ts

@@ -8,8 +8,7 @@ import { ILanguageFeaturesService } from '../../../../editor/common/services/lan
 import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
 import { ITextModel } from '../../../../editor/common/model.js';
 import { Position } from '../../../../editor/common/core/position.js';
-import { InlineCompletion, InlineCompletionContext, } from '../../../../editor/common/languages.js';
-import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { InlineCompletion, } from '../../../../editor/common/languages.js';
 import { Range } from '../../../../editor/common/core/range.js';
 import { IEditorService } from '../../../services/editor/common/editorService.js';
 import { isCodeEditor } from '../../../../editor/browser/editorBrowser.js';
@@ -21,6 +20,7 @@ import { ILLMMessageService } from '../common/sendLLMMessageService.js';
 import { isWindows } from '../../../../base/common/platform.js';
 import { IVoidSettingsService } from '../common/voidSettingsService.js';
 import { FeatureName } from '../common/voidSettingsTypes.js';
+import { IConvertToLLMMessageService } from './convertToLLMMessageService.js';
 // import { IContextGatheringService } from './contextGatheringService.js';
 
 
@@ -633,8 +633,6 @@ export class AutocompleteService extends Disposable implements IAutocompleteServ
 	async _provideInlineCompletionItems(
 		model: ITextModel,
 		position: Position,
-		context: InlineCompletionContext,
-		token: CancellationToken,
 	): Promise<InlineCompletion[]> {
 
 		const isEnabled = this._settingsService.state.globalSettings.enableAutocomplete
@@ -795,17 +793,18 @@ export class AutocompleteService extends Disposable implements IAutocompleteServ
 		const modelSelection = this._settingsService.state.modelSelectionOfFeature[featureName]
 		const modelSelectionOptions = modelSelection ? this._settingsService.state.optionsOfModelSelection[featureName][modelSelection.providerName]?.[modelSelection.modelName] : undefined
 
-
 		// set parameters of `newAutocompletion` appropriately
 		newAutocompletion.llmPromise = new Promise((resolve, reject) => {
 
 			const requestId = this._llmMessageService.sendLLMMessage({
 				messagesType: 'FIMMessage',
-				messages: {
-					prefix: llmPrefix,
-					suffix: llmSuffix,
-					stopTokens: stopTokens,
-				},
+				messages: this._convertToLLMMessageService.prepareFIMMessage({
+					messages: {
+						prefix: llmPrefix,
+						suffix: llmSuffix,
+						stopTokens: stopTokens,
+					}
+				}),
 				modelSelection,
 				modelSelectionOptions,
 				logging: { loggingName: 'Autocomplete' },
@@ -852,7 +851,7 @@ export class AutocompleteService extends Disposable implements IAutocompleteServ
 					newAutocompletion.status = 'error'
 					reject(message)
 				},
-				onAbort: () => { },
+				onAbort: () => { reject('Aborted autocomplete') },
 			})
 			newAutocompletion.requestId = requestId
 
@@ -893,13 +892,14 @@ export class AutocompleteService extends Disposable implements IAutocompleteServ
 		@IEditorService private readonly _editorService: IEditorService,
 		@IModelService private readonly _modelService: IModelService,
 		@IVoidSettingsService private readonly _settingsService: IVoidSettingsService,
+		@IConvertToLLMMessageService private readonly _convertToLLMMessageService: IConvertToLLMMessageService
 		// @IContextGatheringService private readonly _contextGatheringService: IContextGatheringService,
 	) {
 		super()
 
-		this._langFeatureService.inlineCompletionsProvider.register('*', {
+		this._register(this._langFeatureService.inlineCompletionsProvider.register('*', {
 			provideInlineCompletions: async (model, position, context, token) => {
-				const items = await this._provideInlineCompletionItems(model, position, context, token)
+				const items = await this._provideInlineCompletionItems(model, position)
 
 				// console.log('item: ', items?.[0]?.insertText)
 				return { items: items, }
@@ -936,7 +936,7 @@ export class AutocompleteService extends Disposable implements IAutocompleteServ
 				});
 
 			},
-		})
+		}))
 	}
 
 

src/vs/workbench/contrib/void/browser/chatThreadService.ts

@@ -11,32 +11,53 @@ import { IStorageService, StorageScope, StorageTarget } from '../../../../platfo
 import { URI } from '../../../../base/common/uri.js';
 import { Emitter, Event } from '../../../../base/common/event.js';
 import { ILLMMessageService } from '../common/sendLLMMessageService.js';
-import { chat_userMessageContent, chat_systemMessage, voidTools } from '../common/prompt/prompts.js';
-import { getErrorMessage, LLMChatMessage, ToolCallType } from '../common/sendLLMMessageTypes.js';
-import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { chat_userMessageContent, ToolName, } from '../common/prompt/prompts.js';
+import { getErrorMessage, RawToolCallObj, RawToolParamsObj } from '../common/sendLLMMessageTypes.js';
 import { generateUuid } from '../../../../base/common/uuid.js';
-import { ChatMode, FeatureName, ModelSelection, ModelSelectionOptions } from '../common/voidSettingsTypes.js';
+import { FeatureName, ModelSelection, ModelSelectionOptions } from '../common/voidSettingsTypes.js';
 import { IVoidSettingsService } from '../common/voidSettingsService.js';
-import { ToolName, ToolCallParams, ToolResultType, toolNamesThatRequireApproval, InternalToolInfo } from '../common/toolsServiceTypes.js';
+import { ToolCallParams, ToolResultType, toolNamesThatRequireApproval } from '../common/toolsServiceTypes.js';
 import { IToolsService } from './toolsService.js';
 import { CancellationToken } from '../../../../base/common/cancellation.js';
 import { ILanguageFeaturesService } from '../../../../editor/common/services/languageFeatures.js';
 import { ChatMessage, CheckpointEntry, CodespanLocationLink, StagingSelectionItem, ToolMessage } from '../common/chatThreadServiceTypes.js';
 import { Position } from '../../../../editor/common/core/position.js';
-import { ITerminalToolService } from './terminalToolService.js';
 import { IMetricsService } from '../common/metricsService.js';
 import { shorten } from '../../../../base/common/labels.js';
 import { IVoidModelService } from '../common/voidModelService.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.js';
 import { findLast, findLastIdx } from '../../../../base/common/arraysFind.js';
 import { IEditCodeService } from './editCodeServiceInterface.js';
 import { VoidFileSnapshot } from '../common/editCodeServiceTypes.js';
 import { INotificationService, Severity } from '../../../../platform/notification/common/notification.js';
-import { IModelService } from '../../../../editor/common/services/model.js';
-import { IDirectoryStrService } from './directoryStrService.js';
 import { truncate } from '../../../../base/common/strings.js';
 import { THREAD_STORAGE_KEY } from '../common/storageKeys.js';
+import { IConvertToLLMMessageService } from './convertToLLMMessageService.js';
+
+export const findStagingSelectionIndex = (currentSelections: StagingSelectionItem[] | undefined, newSelection: StagingSelectionItem): number | null => {
+	if (!currentSelections) return null
+
+	for (let i = 0; i < currentSelections.length; i += 1) {
+		const s = currentSelections[i]
+
+		if (s.uri.fsPath !== newSelection.uri.fsPath) continue
+
+		if (s.type === 'File' && newSelection.type === 'File') {
+			return i
+		}
+		if (s.type === 'CodeSelection' && newSelection.type === 'CodeSelection') {
+			if (s.uri.fsPath !== newSelection.uri.fsPath) continue
+			// if there's any collision return true
+			const [oldStart, oldEnd] = s.range
+			const [newStart, newEnd] = newSelection.range
+			if (oldStart !== newStart || oldEnd !== newEnd) continue
+			return i
+		}
+		if (s.type === 'Folder' && newSelection.type === 'Folder') {
+			return i
+		}
+	}
+	return null
+}
 
 
 /*
@@ -61,28 +82,6 @@ A checkpoint appears before every LLM message, and before every user message (be
 */
 
 
-const toLLMChatMessages = (chatMessages: ChatMessage[]): LLMChatMessage[] => {
-	const llmChatMessages: LLMChatMessage[] = []
-	for (const c of chatMessages) {
-		if (c.role === 'user') {
-			llmChatMessages.push({ role: c.role, content: c.content })
-		}
-		else if (c.role === 'assistant')
-			llmChatMessages.push({ role: c.role, content: c.content, anthropicReasoning: c.anthropicReasoning })
-		else if (c.role === 'tool')
-			llmChatMessages.push({ role: c.role, id: c.id, name: c.name, params: c.paramsStr, content: c.content })
-		else if (c.role === 'decorative_canceled_tool') { // pass
-		}
-		else if (c.role === 'checkpoint') { // pass
-		}
-		else {
-			throw new Error(`Role ${(c as any).role} not recognized.`)
-		}
-	}
-	return llmChatMessages
-}
-
-
 type UserMessageType = ChatMessage & { role: 'user' }
 type UserMessageState = UserMessageType['state']
 const defaultMessageState: UserMessageState = {
@@ -139,10 +138,9 @@ export type ThreadStreamState = {
 
 		// streaming related - when streaming message
 		streamingToken?: string;
-		messageSoFar?: string;
+		displayContentSoFar?: string;
 		reasoningSoFar?: string;
-		toolNameSoFar?: string;
-		toolParamsSoFar?: string;
+		toolCallSoFar?: RawToolCallObj;
 	}
 }
 
@@ -243,17 +241,12 @@ class ChatThreadService extends Disposable implements IChatThreadService {
 		@IVoidModelService private readonly _voidModelService: IVoidModelService,
 		@ILLMMessageService private readonly _llmMessageService: ILLMMessageService,
 		@IToolsService private readonly _toolsService: IToolsService,
-		@IWorkspaceContextService private readonly _workspaceContextService: IWorkspaceContextService,
 		@IVoidSettingsService private readonly _settingsService: IVoidSettingsService,
 		@ILanguageFeaturesService private readonly _languageFeaturesService: ILanguageFeaturesService,
-		@ITerminalToolService private readonly _terminalToolService: ITerminalToolService,
 		@IMetricsService private readonly _metricsService: IMetricsService,
-		@IEditorService private readonly _editorService: IEditorService,
-		@ICodeEditorService private readonly _codeEditorService: ICodeEditorService,
 		@IEditCodeService private readonly _editCodeService: IEditCodeService,
 		@INotificationService private readonly _notificationService: INotificationService,
-		@IModelService private readonly _modelService: IModelService,
-		@IDirectoryStrService private readonly _directoryStrService: IDirectoryStrService,
+		@IConvertToLLMMessageService private readonly _convertToLLMMessagesService: IConvertToLLMMessageService,
 	) {
 		super()
 		this.state = { allThreads: {}, currentThreadId: null as unknown as string } // default state
@@ -269,9 +262,6 @@ class ChatThreadService extends Disposable implements IChatThreadService {
 		// always be in a thread
 		this.openNewThread()
 
-		// when the user changes files, automatically add the new file as a stagingSelection
-		this._register(this._editorService.onDidActiveEditorChange(() => this._addCurrentFileAsStagingSelectionDuringFileChange()));
-
 
 		// keep track of user-modified files
 		// const disposablesOfModelId: { [modelId: string]: IDisposable[] } = {}
@@ -291,38 +281,6 @@ class ChatThreadService extends Disposable implements IChatThreadService {
 	}
 
 
-	// add the current file to the thread being edited
-	private _addCurrentFileAsStagingSelectionDuringFileChange() {
-		const newModel = this._codeEditorService.getActiveCodeEditor()?.getModel() ?? null
-		if (!newModel) { return }
-
-		const isCurrentlyFocusing = this.isCurrentlyFocusingMessage()
-		if (isCurrentlyFocusing) return
-
-		// only add if the user hasn't sent a message yet
-		if (this.getCurrentThread().messages.length !== 0) return
-
-		const newStagingSelection: StagingSelectionItem = {
-			type: 'File',
-			uri: newModel.uri,
-			language: newModel.getLanguageId(),
-			state: { wasAddedAsCurrentFile: true }
-		}
-
-		const oldStagingSelections = this.getCurrentThreadState().stagingSelections || [];
-		const fileIsAlreadyHere = oldStagingSelections.some(s => s.type === 'File' && s.uri.fsPath === newStagingSelection.uri.fsPath)
-		if (fileIsAlreadyHere) return
-
-		// remove all old selectons that are marked as `wasAddedAsCurrentFile`, and add new selection
-		const newStagingSelections: StagingSelectionItem[] = [
-			...oldStagingSelections.filter(s => !s.state?.wasAddedAsCurrentFile),
-			newStagingSelection
-		]
-		this.setCurrentThreadState({ stagingSelections: newStagingSelections });
-
-	}
-
-
 	// !!! this is important for properly restoring URIs from storage
 	// should probably re-use code from void/src/vs/base/common/marshalling.ts instead. but this is simple enough
 	private _convertThreadDataFromStorage(threadsStr: string): ChatThreads {
@@ -380,9 +338,9 @@ class ChatThreadService extends Disposable implements IChatThreadService {
 			else if (behavior === 'set') {
 				this.streamState[threadId] = state
 			}
+			else throw new Error(`setStreamState`)
 		}
 
-
 		this._onDidChangeStreamState.fire({ threadId })
 	}
 
@@ -391,36 +349,6 @@ class ChatThreadService extends Disposable implements IChatThreadService {
 
 
 
-	editUserMessageAndStreamResponse: IChatThreadService['editUserMessageAndStreamResponse'] = async ({ userMessage, messageIdx, threadId }) => {
-
-		const thread = this.state.allThreads[threadId]
-		if (!thread) return // should never happen
-
-		if (thread.messages?.[messageIdx]?.role !== 'user') {
-			throw new Error(`Error: editing a message with role !=='user'`)
-		}
-
-		// get prev and curr selections before clearing the message
-		const currSelns = thread.messages[messageIdx].state.stagingSelections || [] // staging selections for the edited message
-
-		// clear messages up to the index
-		const slicedMessages = thread.messages.slice(0, messageIdx)
-		this._setState({
-			allThreads: {
-				...this.state.allThreads,
-				[thread.id]: {
-					...thread,
-					messages: slicedMessages
-				}
-			}
-		}, true)
-
-		// re-add the message and stream it
-		this.addUserMessageAndStreamResponse({ userMessage, _chatSelections: currSelns, threadId })
-
-	}
-
-
 	private _currentModelSelectionProps = () => {
 		// these settings should not change throughout the loop (eg anthropic breaks if you change its thinking mode and it's using tools)
 		const featureName: FeatureName = 'Chat'
@@ -442,7 +370,7 @@ class ChatThreadService extends Disposable implements IChatThreadService {
 		}
 		return false
 	}
-	private _updateLatestToolTo = (threadId: string, tool: ChatMessage & { role: 'tool' }) => {
+	private _updateLatestTool = (threadId: string, tool: ChatMessage & { role: 'tool' }) => {
 		const swapped = this._swapOutLatestStreamingToolWithResult(threadId, tool)
 		if (swapped) return
 		this._addMessageToThread(threadId, tool)
@@ -452,33 +380,15 @@ class ChatThreadService extends Disposable implements IChatThreadService {
 		const thread = this.state.allThreads[threadId]
 		if (!thread) return // should never happen
 
-
 		const lastMsg = thread.messages[thread.messages.length - 1]
 		if (!(
 			lastMsg.role === 'tool' && (lastMsg.type === 'tool_request')
 		)) return // should never happen
 
-		const lastUserMsgIdx = findLastIdx(thread.messages, m => m.role === 'user')
-		const lastUserMessage = thread.messages[lastUserMsgIdx] as ChatMessage & { role: 'user' }
-		if (lastUserMsgIdx === -1 || !lastUserMessage) return // should never happen
-
-		const instructions = lastUserMessage.displayContent || ''
-
 		const callThisToolFirst: ToolMessage<ToolName> = lastMsg
 
-		this._updateLatestToolTo(threadId, {
-			role: 'tool',
-			type: 'running_now',
-			name: lastMsg.name,
-			paramsStr: lastMsg.paramsStr,
-			id: lastMsg.id,
-			params: lastMsg.params,
-			content: '(value not received yet...)', // this typically shouldn't ever get read
-			result: null
-		})
-
 		this._wrapRunAgentToNotify(
-			this._runChatAgent({ callThisToolFirst, threadId, userMessageContent: instructions, ...this._currentModelSelectionProps() })
+			this._runChatAgent({ callThisToolFirst, threadId, ...this._currentModelSelectionProps() })
 			, threadId
 		)
 	}
@@ -494,29 +404,13 @@ class ChatThreadService extends Disposable implements IChatThreadService {
 		}
 		else return
 
-		const { name, paramsStr, id } = lastMsg
+		const { name, id, rawParams } = lastMsg
 
 		const errorMessage = this.errMsgs.rejected
-		this._updateLatestToolTo(threadId, { role: 'tool', type: 'rejected', params: params, name: name, paramsStr: paramsStr, id, content: errorMessage, result: null })
+		this._updateLatestTool(threadId, { role: 'tool', type: 'rejected', params: params, name: name, content: errorMessage, result: null, id, rawParams })
 		this._setStreamState(threadId, {}, 'set')
 	}
 
-	// private _rejectLatestStreamingTool(threadId: string) {
-	// 	const thread = this.state.allThreads[threadId]
-	// 	if (!thread) return // should never happen
-
-	// 	const lastMessage = thread.messages[thread.messages.length - 1]
-	// 	if (lastMessage.role !== 'tool') return
-	// 	const { name, paramsStr, id, result } = lastMessage
-	// 	if (result.type !== 'running_now') return
-	// 	const { params } = result
-
-	// 	const errorMessage = this.errMsgs.rejected
-	// 	this._swapOutLatestStreamingToolWithResult(threadId, { role: 'tool', name: name, paramsStr: paramsStr, id, content: errorMessage, result: { type: 'rejected', params: params }, })
-	// 	this._setStreamState(threadId, {}, 'set')
-
-	// }
-
 	stopRunning(threadId: string) {
 		const thread = this.state.allThreads[threadId]
 		if (!thread) return // should never happen
@@ -531,19 +425,20 @@ class ChatThreadService extends Disposable implements IChatThreadService {
 		const isRunning = this.streamState[threadId]?.isRunning
 		if (isRunning === 'LLM') {
 			// abort the stream first so it doesn't change any state
-			const messageSoFar = this.streamState[threadId]?.messageSoFar ?? ''
+			const displayContentSoFar = this.streamState[threadId]?.displayContentSoFar ?? ''
 			const reasoningSoFar = this.streamState[threadId]?.reasoningSoFar ?? ''
-			const toolInProgress = this.streamState[threadId]?.toolNameSoFar
-			console.log('toolInProgress', toolInProgress)
+			const toolCallSoFar = this.streamState[threadId]?.toolCallSoFar
 
 			const llmCancelToken = this.streamState[threadId]?.streamingToken
 			if (llmCancelToken !== undefined) { this._llmMessageService.abort(llmCancelToken) }
 
-			this._addMessageToThread(threadId, { role: 'assistant', content: messageSoFar, reasoning: reasoningSoFar, anthropicReasoning: null })
+			this._addMessageToThread(threadId, { role: 'assistant', displayContent: displayContentSoFar, reasoning: reasoningSoFar, anthropicReasoning: null })
 
-			if (toolInProgress) {
-				this._addMessageToThread(threadId, { role: 'decorative_canceled_tool', name: toolInProgress })
+			if (toolCallSoFar) {
+				this._addMessageToThread(threadId, { role: 'interrupted_streaming_tool', name: toolCallSoFar.name })
 			}
+
+			this._addUserCheckpoint({ threadId })
 		}
 
 		this._setStreamState(threadId, {}, 'set')
@@ -551,18 +446,6 @@ class ChatThreadService extends Disposable implements IChatThreadService {
 
 
 
-	private _tools = (chatMode: ChatMode) => {
-		const toolNames: ToolName[] | undefined = chatMode === 'normal' ? undefined
-			: chatMode === 'gather' ? (Object.keys(voidTools) as ToolName[]).filter(toolName => !toolNamesThatRequireApproval.has(toolName))
-				: chatMode === 'agent' ? Object.keys(voidTools) as ToolName[]
-					: undefined
-
-		const tools: InternalToolInfo[] | undefined = toolNames?.map(toolName => voidTools[toolName])
-		return tools
-	}
-
-
-
 	private readonly errMsgs = {
 		rejected: 'Tool call was rejected by the user.',
 		errWhenStringifying: (error: any) => `Tool call succeeded, but there was an error stringifying the output.\n${getErrorMessage(error)}`
@@ -571,140 +454,109 @@ class ChatThreadService extends Disposable implements IChatThreadService {
 
 	private readonly _currentlyRunningToolInterruptor: { [threadId: string]: (() => void) | undefined } = {}
 
+
+	// returns true when the tool call is waiting for user approval
+	private _runToolCall = async (
+		threadId: string,
+		toolName: ToolName,
+		toolId: string,
+		opts: { preapproved: true, unvalidatedToolParams: RawToolParamsObj, validatedParams: ToolCallParams[ToolName] } | { preapproved: false, unvalidatedToolParams: RawToolParamsObj },
+	): Promise<{ awaitingUserApproval?: boolean, interrupted?: boolean }> => {
+
+		// compute these below
+		let toolParams: ToolCallParams[ToolName]
+		let toolResult: Awaited<ToolResultType[typeof toolName]>
+		let toolResultStr: string
+
+		if (!opts.preapproved) { // skip this if pre-approved
+			// 1. validate tool params
+			try {
+				const params = await this._toolsService.validateParams[toolName](opts.unvalidatedToolParams)
+				toolParams = params
+			} catch (error) {
+				const errorMessage = getErrorMessage(error)
+				this._addMessageToThread(threadId, { role: 'tool', type: 'invalid_params', rawParams: opts.unvalidatedToolParams, result: null, name: toolName, content: errorMessage, id: toolId, })
+				return {}
+			}
+			// once validated, add checkpoint for edit
+			if (toolName === 'edit_file') { this._addToolEditCheckpoint({ threadId, uri: (toolParams as ToolCallParams['edit_file']).uri }) }
+
+			// 2. if tool requires approval, break from the loop, awaiting approval
+			const toolRequiresApproval = toolNamesThatRequireApproval.has(toolName)
+			if (toolRequiresApproval) {
+				const autoApprove = this._settingsService.state.globalSettings.autoApprove
+				// add a tool_request because we use it for UI if a tool is loading (this should be improved in the future)
+				this._addMessageToThread(threadId, { role: 'tool', type: 'tool_request', content: '(never)', result: null, name: toolName, params: toolParams, id: toolId, rawParams: opts.unvalidatedToolParams })
+				if (!autoApprove) {
+					return { awaitingUserApproval: true }
+				}
+			}
+		}
+		else {
+			toolParams = opts.validatedParams
+		}
+
+
+
+		// 3. call the tool
+		this._setStreamState(threadId, { isRunning: 'tool' }, 'merge')
+		this._updateLatestTool(threadId, { role: 'tool', type: 'running_now', name: toolName, params: toolParams, content: '(value not received yet...)', result: null, id: toolId, rawParams: opts.unvalidatedToolParams })
+
+		let interrupted = false
+		try {
+			const { result, interruptTool } = await this._toolsService.callTool[toolName](toolParams as any)
+			this._currentlyRunningToolInterruptor[threadId] = () => {
+				interrupted = true;
+				interruptTool?.();
+				delete this._currentlyRunningToolInterruptor[threadId];
+			}
+			toolResult = await result // ts is bad... await is needed
+
+			if (interrupted) { return { interrupted: true } } // the tool result is added where we interrupt, not here
+		}
+		catch (error) {
+			if (interrupted) { return { interrupted: true } } // the tool result is added where we interrupt, not here
+
+
+			const errorMessage = getErrorMessage(error)
+			this._updateLatestTool(threadId, { role: 'tool', type: 'tool_error', params: toolParams, result: errorMessage, name: toolName, content: errorMessage, id: toolId, rawParams: opts.unvalidatedToolParams })
+			return {}
+		}
+
+		// 4. stringify the result to give to the LLM
+		try {
+			toolResultStr = this._toolsService.stringOfResult[toolName](toolParams as any, toolResult as any)
+		} catch (error) {
+			const errorMessage = this.errMsgs.errWhenStringifying(error)
+			this._updateLatestTool(threadId, { role: 'tool', type: 'tool_error', params: toolParams, result: errorMessage, name: toolName, content: errorMessage, id: toolId, rawParams: opts.unvalidatedToolParams })
+			return {}
+		}
+
+		// 5. add to history and keep going
+		this._updateLatestTool(threadId, { role: 'tool', type: 'success', params: toolParams, result: toolResult, name: toolName, content: toolResultStr, id: toolId, rawParams: opts.unvalidatedToolParams })
+
+		return {}
+	};
+
+
+
+
 	private async _runChatAgent({
 		threadId,
 		modelSelection,
 		modelSelectionOptions,
-		userMessageContent,
 		callThisToolFirst,
 	}: {
 		threadId: string,
 		modelSelection: ModelSelection | null,
 		modelSelectionOptions: ModelSelectionOptions | undefined,
-		userMessageContent: string, // content of LATEST user message
 
 		callThisToolFirst?: ToolMessage<ToolName> & { type: 'tool_request' }
 	}) {
-		const userMessageFullContent = userMessageContent
-		const getLatestMessages = async () => {
-			// replace last userMessage with userMessageFullContent (which contains all the files too)
-			const thread = this.state.allThreads[threadId]
-			const latestMessages = thread?.messages ?? []
-			const messages_ = toLLMChatMessages(latestMessages)
-			const lastUserMsgIdx = findLastIdx(messages_, m => m.role === 'user')
-			if (lastUserMsgIdx === -1) return [] // should never happen (or how did they send the message?!)
 
-			// system message
-			const workspaceFolders = this._workspaceContextService.getWorkspace().folders.map(f => f.uri.fsPath)
-
-			const openedURIs = this._modelService.getModels().filter(m => m.isAttachedToEditor()).map(m => m.uri.fsPath) || [];
-			const activeURI = this._editorService.activeEditor?.resource?.fsPath;
-
-			const { wasCutOff, str: directoryStr_ } = await this._directoryStrService.getAllDirectoriesStr()
-
-			const directoryStr = wasCutOff ? (
-				chatMode === 'agent' || chatMode === 'gather' ? `${directoryStr_}\nString cut off, use tools to read more.`
-					: `${directoryStr_}\nString cut off, ask user for more if necessary.`
-			) : directoryStr_
-
-			const runningTerminalIds = this._terminalToolService.listTerminalIds()
-			const systemMessage = chat_systemMessage({ workspaceFolders, openedURIs, directoryStr, activeURI, runningTerminalIds, chatMode })
-
-			// all messages so far in the chat history (including tools)
-			const messages: LLMChatMessage[] = [
-				{ role: 'system', content: systemMessage, },
-				...messages_.slice(0, lastUserMsgIdx),
-				{ role: 'user', content: userMessageFullContent },
-				...messages_.slice(lastUserMsgIdx + 1, Infinity),
-			]
-			// console.log('MESSAGES!!!', messages)
-			return messages
-		}
-
-
-
-		// returns true when the tool call is waiting for user approval
-		const handleToolCall = async (
-			tool: ToolCallType,
-			opts?: { preapproved: true, toolParams: ToolCallParams[ToolName] },
-		): Promise<{ awaitingUserApproval?: boolean, interrupted?: boolean }> => {
-			const toolName: ToolName = tool.name
-			const toolParamsStr = tool.paramsStr
-			const toolId = tool.id
-
-			// compute these below
-			let toolParams: ToolCallParams[ToolName]
-			let toolResult: ToolResultType[typeof toolName]
-			let toolResultStr: string
-
-			if (!opts?.preapproved) { // skip this if pre-approved
-				// 1. validate tool params
-				try {
-					const params = await this._toolsService.validateParams[toolName](toolParamsStr)
-					toolParams = params
-				} catch (error) {
-					const errorMessage = getErrorMessage(error)
-					this._addMessageToThread(threadId, { role: 'tool', type: 'invalid_params', params: null, result: null, name: toolName, paramsStr: toolParamsStr, id: toolId, content: errorMessage, })
-					return {}
-				}
-				// once validated, add checkpoint for edit
-				if (toolName === 'edit_file') { this._addToolEditCheckpoint({ threadId, uri: (toolParams as ToolCallParams['edit_file']).uri }) }
-
-				// 2. if tool requires approval, break from the loop, awaiting approval
-				const requiresApproval = toolNamesThatRequireApproval.has(toolName)
-				if (requiresApproval) {
-					const autoApprove = this._settingsService.state.globalSettings.autoApprove
-					// add a tool_request because we use it for UI if a tool is loading (this should be improved in the future)
-					this._addMessageToThread(threadId, { role: 'tool', type: 'tool_request', content: '(never)', result: null, name: toolName, paramsStr: toolParamsStr, params: toolParams, id: toolId })
-					if (!autoApprove) {
-						return { awaitingUserApproval: true }
-					}
-				}
-			}
-			else {
-				toolParams = opts.toolParams
-			}
-
-			// 3. call the tool
-			this._setStreamState(threadId, { isRunning: 'tool' }, 'merge')
-			let interrupted = false
-			try {
-				const { result, interruptTool } = await this._toolsService.callTool[toolName](toolParams as any)
-				this._currentlyRunningToolInterruptor[threadId] = () => {
-					interrupted = true;
-					interruptTool?.();
-					delete this._currentlyRunningToolInterruptor[threadId];
-				}
-				toolResult = await result // ts is bad... await is needed
-			}
-			catch (error) {
-				if (interrupted) {
-					// the tool result is added when we stop running
-					return { interrupted: true }
-				}
-				const errorMessage = getErrorMessage(error)
-				this._updateLatestToolTo(threadId, { role: 'tool', type: 'tool_error', params: toolParams, result: errorMessage, name: toolName, paramsStr: toolParamsStr, id: toolId, content: errorMessage, })
-				return {}
-			}
-
-			// 4. stringify the result to give to the LLM
-			try {
-				toolResultStr = this._toolsService.stringOfResult[toolName](toolParams as any, toolResult as any)
-			} catch (error) {
-				const errorMessage = this.errMsgs.errWhenStringifying(error)
-				this._updateLatestToolTo(threadId, { role: 'tool', type: 'tool_error', params: toolParams, result: errorMessage, name: toolName, paramsStr: toolParamsStr, id: toolId, content: errorMessage, })
-				return {}
-			}
-
-			// 5. add to history and keep going
-			this._updateLatestToolTo(threadId, { role: 'tool', type: 'success', params: toolParams, result: toolResult, name: toolName, paramsStr: toolParamsStr, id: toolId, content: toolResultStr, })
-
-			return {}
-		};
 
 		// above just defines helpers, below starts the actual function
 		const { chatMode } = this._settingsService.state.globalSettings // should not change as we loop even if user changes it, so it goes here
-		const tools = this._tools(chatMode)
 
 		// clear any previous error
 		this._setStreamState(threadId, { error: undefined }, 'set')
@@ -716,7 +568,7 @@ class ChatThreadService extends Disposable implements IChatThreadService {
 
 		// before enter loop, call tool
 		if (callThisToolFirst) {
-			const { interrupted } = await handleToolCall(callThisToolFirst, { preapproved: true, toolParams: callThisToolFirst.params })
+			const { interrupted } = await this._runToolCall(threadId, callThisToolFirst.name, callThisToolFirst.id, { preapproved: true, unvalidatedToolParams: callThisToolFirst.rawParams, validatedParams: callThisToolFirst.params })
 			if (interrupted) return
 		}
 
@@ -727,34 +579,41 @@ class ChatThreadService extends Disposable implements IChatThreadService {
 			isRunningWhenEnd = undefined
 			nMessagesSent += 1
 
-			let resMessageIsDonePromise: (toolCalls?: ToolCallType[] | undefined) => void // resolves when user approves this tool use (or if tool doesn't require approval)
-			const messageIsDonePromise = new Promise<ToolCallType[] | undefined>((res, rej) => { resMessageIsDonePromise = res })
+			let resMessageIsDonePromise: (toolCall?: RawToolCallObj | undefined) => void // resolves when user approves this tool use (or if tool doesn't require approval)
+			const messageIsDonePromise = new Promise<RawToolCallObj | undefined>((res, rej) => { resMessageIsDonePromise = res })
 
 			// send llm message
 			this._setStreamState(threadId, { isRunning: 'LLM' }, 'merge')
-			const messages = await getLatestMessages()
+
+			const chatMessages = this.state.allThreads[threadId]?.messages ?? []
+			const { messages, separateSystemMessage } = await this._convertToLLMMessagesService.prepareLLMChatMessages({
+				chatMessages,
+				modelSelection,
+				chatMode
+			})
+
 			const llmCancelToken = this._llmMessageService.sendLLMMessage({
 				messagesType: 'chatMessages',
-				messages,
-				tools: tools,
+				chatMode,
+				messages: messages,
 				modelSelection,
 				modelSelectionOptions,
 				logging: { loggingName: `Chat - ${chatMode}`, loggingExtras: { threadId, nMessagesSent, chatMode } },
-				onText: ({ fullText, fullReasoning, fullToolName, fullToolParams }) => {
-					this._setStreamState(threadId, { messageSoFar: fullText, reasoningSoFar: fullReasoning, toolNameSoFar: fullToolName, toolParamsSoFar: fullToolParams }, 'merge')
+				separateSystemMessage: separateSystemMessage,
+				onText: ({ fullText, fullReasoning, toolCall }) => {
+					this._setStreamState(threadId, { displayContentSoFar: fullText, reasoningSoFar: fullReasoning, toolCallSoFar: toolCall }, 'merge')
 				},
-				onFinalMessage: async ({ fullText, toolCalls, fullReasoning, anthropicReasoning }) => {
-					this._addMessageToThread(threadId, { role: 'assistant', content: fullText, reasoning: fullReasoning, anthropicReasoning })
-					// added to history and no longer streaming this, so clear messages so far and streamingToken (but do not stop isRunning)
-					this._setStreamState(threadId, { messageSoFar: undefined, reasoningSoFar: undefined, streamingToken: undefined, toolNameSoFar: undefined, toolParamsSoFar: undefined }, 'merge')
-					// resolve with tool calls
-					resMessageIsDonePromise(toolCalls)
+				onFinalMessage: async ({ fullText, fullReasoning, toolCall, anthropicReasoning, }) => {
+					this._addMessageToThread(threadId, { role: 'assistant', displayContent: fullText, reasoning: fullReasoning, anthropicReasoning })
+					this._setStreamState(threadId, { displayContentSoFar: undefined, reasoningSoFar: undefined, streamingToken: undefined, toolCallSoFar: undefined }, 'merge')
+					resMessageIsDonePromise(toolCall) // resolve with tool calls
 				},
 				onError: (error) => {
-					const messageSoFar = this.streamState[threadId]?.messageSoFar ?? ''
+					const messageSoFar = this.streamState[threadId]?.displayContentSoFar ?? ''
 					const reasoningSoFar = this.streamState[threadId]?.reasoningSoFar ?? ''
+					// const toolCallSoFar = this.streamState[threadId]?.toolCallSoFar
 					// add assistant's message to chat history, and clear selection
-					this._addMessageToThread(threadId, { role: 'assistant', content: messageSoFar, reasoning: reasoningSoFar, anthropicReasoning: null })
+					this._addMessageToThread(threadId, { role: 'assistant', displayContent: messageSoFar, reasoning: reasoningSoFar, anthropicReasoning: null })
 					this._setStreamState(threadId, { error }, 'set')
 					resMessageIsDonePromise()
 				},
@@ -774,14 +633,14 @@ class ChatThreadService extends Disposable implements IChatThreadService {
 				break
 			}
 			this._setStreamState(threadId, { streamingToken: llmCancelToken }, 'merge') // new stream token for the new message
-			const toolCalls = await messageIsDonePromise // wait for message to complete
+			const toolCall = await messageIsDonePromise // wait for message to complete
 			if (aborted) { return }
 			this._setStreamState(threadId, { streamingToken: undefined }, 'merge') // streaming message is done
 
 			// call tool if there is one
-			const tool: ToolCallType | undefined = toolCalls?.[0]
+			const tool: RawToolCallObj | undefined = toolCall
 			if (tool) {
-				const { awaitingUserApproval, interrupted } = await handleToolCall(tool)
+				const { awaitingUserApproval, interrupted } = await this._runToolCall(threadId, tool.name, tool.id, { preapproved: false, unvalidatedToolParams: tool.rawParams })
 
 				// stop if interrupted. we don't have to do this for llmMessage because we have a stream token for it and onAbort gets called, but we don't have the equivalent for tools.
 				// just detect tool interruption which is the same as chat interruption right now
@@ -1006,15 +865,14 @@ A,B,C are all files.
 x means a checkpoint where the file changed.
 
 A B C D E F G H I
-x x x x x x x x x
-| | | | | | | | |
-x | | | | | | | x
----x-|-|-|-x-|-x-|-----     <-- to
- x | | | | | x
-   | | x x |
-   | |   | |
--------x-|---x-x-------     <-- from
-	 x
+  x x x x x   x           <-- you can't always go up to find the "before" version; sometimes you need to go down
+  | | | | |   | x
+--x-|-|-|-x---x-|-----     <-- to
+	| | | | x   x
+	| | x x |
+	| |   | |
+----x-|---x-x-------     <-- from
+	  x
 
 We need to revert anything that happened between to+1 and from.
 **We do this by finding the last x from 0...`to` for each file and applying those contents.**
@@ -1022,9 +880,19 @@ We only need to do it for files that were edited since `to`, ie files between to
 */
 		if (toIdx < fromIdx) {
 			const { lastIdxOfURI } = this._getCheckpointsBetween({ threadId, loIdx: toIdx + 1, hiIdx: fromIdx })
+
+			const idxes = function* () {
+				for (let k = toIdx; k >= 0; k -= 1) { // first go up
+					yield k
+				}
+				for (let k = toIdx + 1; k < thread.messages.length; k += 1) { // then go down
+					yield k
+				}
+			}
+
 			for (const fsPath in lastIdxOfURI) {
-				// apply lowest down content for each uri (or original if not found)
-				for (let k = toIdx; k >= 0; k -= 1) {
+				// find the first instance of this file starting at toIdx (go up to latest file; if there is none, go down)
+				for (const k of idxes()) {
 					const message = thread.messages[k]
 					if (message.role !== 'checkpoint') continue
 					const res = this._getCheckpointInfo(message, fsPath, { includeUserModifiedChanges: jumpToUserModified })
@@ -1040,16 +908,16 @@ We only need to do it for files that were edited since `to`, ie files between to
 		/*
 if redoing
 
-A B C D E F G H I
-x x x x x x x x x
-| | | | | | | | |
-x | | | | | | | x
----x-|-|-|-x-|-x-|-----     <-- from
- x | | | | | x
-   | | x x |
-   | |   | |
--------x-|---x-x-------     <-- to
-	 x
+A B C D E F G H I J
+  x x x x x   x     x
+  | | | | |   | x x x
+--x-|-|-|-x---x-|-|---     <-- from
+	| | | | x   x
+	| | x x |
+	| |   | |
+----x-|---x-x-----|---     <-- to
+	  x           x
+
 
 We need to apply latest change for anything that happened between from+1 and to.
 We only need to do it for files that were edited since `from`, ie files between from+1...to.
@@ -1065,7 +933,6 @@ We only need to do it for files that were edited since `from`, ie files between
 					if (!res) continue
 					const { voidFileSnapshot } = res
 					if (!voidFileSnapshot) continue
-
 					this._editCodeService.restoreVoidFileSnapshot(URI.file(fsPath), voidFileSnapshot)
 					break
 				}
@@ -1089,6 +956,7 @@ We only need to do it for files that were edited since `from`, ie files between
 				severity: error ? Severity.Warning : Severity.Info,
 				message: error ? `Error: ${error} ` : `A new Chat result is ready.`,
 				source: messageContent,
+				sticky: true,
 				actions: {
 					primary: [{
 						id: 'void.goToChat',
@@ -1113,20 +981,28 @@ We only need to do it for files that were edited since `from`, ie files between
 		})
 	}
 
-	async addUserMessageAndStreamResponse({ userMessage, _chatSelections, threadId }: { userMessage: string, _chatSelections?: StagingSelectionItem[], threadId: string }) {
+	dismissStreamError(threadId: string): void {
+		this._setStreamState(threadId, { error: undefined }, 'merge')
+	}
+
+
+	private async _addUserMessageAndStreamResponse({ userMessage, _chatSelections, threadId }: { userMessage: string, _chatSelections?: StagingSelectionItem[], threadId: string }) {
 		const thread = this.state.allThreads[threadId]
 		if (!thread) return // should never happen
 
+		const llmCancelToken = this.streamState[threadId]?.streamingToken // currently streaming LLM on this thread
+		if (llmCancelToken === undefined && this.streamState[threadId]?.isRunning === 'LLM') {
+			// if about to call the other LLM, just wait for it by stopping right now
+			return
+		}
+		// stop it (this simply resolves the promise to free up space)
+		if (llmCancelToken !== undefined) this._llmMessageService.abort(llmCancelToken)
 
 		// add dummy before this message to keep checkpoint before user message idea consistent
 		if (thread.messages.length === 0) {
 			this._addUserCheckpoint({ threadId })
 		}
 
-		// if the current thread is already streaming, stop it (this simply resolves the promise to free up space)
-		const llmCancelToken = this.streamState[threadId]?.streamingToken
-		if (llmCancelToken !== undefined) this._llmMessageService.abort(llmCancelToken)
-
 		const { chatMode } = this._settingsService.state.globalSettings
 
 		// add user's message to chat history
@@ -1141,16 +1017,66 @@ We only need to do it for files that were edited since `from`, ie files between
 		this._setThreadState(threadId, { currCheckpointIdx: null }) // no longer at a checkpoint because started streaming
 
 		this._wrapRunAgentToNotify(
-			this._runChatAgent({ threadId, userMessageContent, ...this._currentModelSelectionProps(), }),
+			this._runChatAgent({ threadId, ...this._currentModelSelectionProps(), }),
 			threadId,
 		)
 	}
 
-	dismissStreamError(threadId: string): void {
-		this._setStreamState(threadId, { error: undefined }, 'merge')
+
+	async addUserMessageAndStreamResponse({ userMessage, _chatSelections, threadId }: { userMessage: string, _chatSelections?: StagingSelectionItem[], threadId: string }) {
+		const thread = this.state.allThreads[threadId];
+		if (!thread) return
+
+		// if there's a current checkpoint, delete all messages after it
+		if (thread.state.currCheckpointIdx !== null) {
+			const checkpointIdx = thread.state.currCheckpointIdx;
+			const newMessages = thread.messages.slice(0, checkpointIdx + 1);
+
+			// Update the thread with truncated messages
+			const newThreads = {
+				...this.state.allThreads,
+				[threadId]: {
+					...thread,
+					lastModified: new Date().toISOString(),
+					messages: newMessages,
+				}
+			};
+			this._storeAllThreads(newThreads);
+			this._setState({ allThreads: newThreads }, true);
+		}
+
+		// Now call the original method to add the user message and stream the response
+		await this._addUserMessageAndStreamResponse({ userMessage, _chatSelections, threadId });
+
 	}
 
+	editUserMessageAndStreamResponse: IChatThreadService['editUserMessageAndStreamResponse'] = async ({ userMessage, messageIdx, threadId }) => {
 
+		const thread = this.state.allThreads[threadId]
+		if (!thread) return // should never happen
+
+		if (thread.messages?.[messageIdx]?.role !== 'user') {
+			throw new Error(`Error: editing a message with role !=='user'`)
+		}
+
+		// get prev and curr selections before clearing the message
+		const currSelns = thread.messages[messageIdx].state.stagingSelections || [] // staging selections for the edited message
+
+		// clear messages up to the index
+		const slicedMessages = thread.messages.slice(0, messageIdx)
+		this._setState({
+			allThreads: {
+				...this.state.allThreads,
+				[thread.id]: {
+					...thread,
+					messages: slicedMessages
+				}
+			}
+		}, true)
+
+		// re-add the message and stream it
+		this._addUserMessageAndStreamResponse({ userMessage, _chatSelections: currSelns, threadId })
+	}
 
 	// ---------- the rest ----------
 
@@ -1245,7 +1171,7 @@ We only need to do it for files that were edited since `from`, ie files between
 			// else search codebase for `target`
 			let uris: URI[] = []
 			try {
-				const { result } = await this._toolsService.callTool['search_pathnames_only']({ queryStr: target, include: null, pageNumber: 0 })
+				const { result } = await this._toolsService.callTool['search_pathnames_only']({ queryStr: target, searchInFolder: null, pageNumber: 0 })
 				uris = result.uris
 			} catch (e) {
 				return null
@@ -1448,21 +1374,6 @@ We only need to do it for files that were edited since `from`, ie files between
 				// switch to the thread
 				this.switchToThread(threadId)
 
-				// add the current file as a staging selection
-				const model = this._codeEditorService.getActiveCodeEditor()?.getModel()
-				if (model) {
-					this._setThreadState(this.state.currentThreadId, {
-						stagingSelections: [{
-							type: 'File',
-							uri: model.uri,
-							language: model.getLanguageId(),
-							state: {
-								wasAddedAsCurrentFile: true
-							}
-						}]
-					})
-				}
-				return;
 			}
 		}
 		// otherwise, start a new thread
@@ -1517,6 +1428,10 @@ We only need to do it for files that were edited since `from`, ie files between
 				}
 			}
 		}, true)
+
+		// // when change focused message idx, jump - do not jump back when click edit, too confusing.
+		// if (messageIdx !== undefined)
+		// 	this.jumpToCheckpointBeforeMessageIdx({ threadId, messageIdx, jumpToUserModified: true })
 	}
 
 	// set message.state

src/vs/workbench/contrib/void/browser/convertToLLMMessageService.ts

@@ -0,0 +1,643 @@
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { deepClone } from '../../../../base/common/objects.js';
+import { IModelService } from '../../../../editor/common/services/model.js';
+import { registerSingleton, InstantiationType } from '../../../../platform/instantiation/common/extensions.js';
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { ChatMessage } from '../common/chatThreadServiceTypes.js';
+import { getIsReasoningEnabledState, getMaxOutputTokens, getModelCapabilities } from '../common/modelCapabilities.js';
+import { reParsedToolXMLString, chat_systemMessage, ToolName } from '../common/prompt/prompts.js';
+import { AnthropicLLMChatMessage, AnthropicReasoning, LLMChatMessage, LLMFIMMessage, OpenAILLMChatMessage, RawToolParamsObj } from '../common/sendLLMMessageTypes.js';
+import { IVoidSettingsService } from '../common/voidSettingsService.js';
+import { ChatMode, FeatureName, ModelSelection } from '../common/voidSettingsTypes.js';
+import { IDirectoryStrService } from './directoryStrService.js';
+import { ITerminalToolService } from './terminalToolService.js';
+import { IVoidModelService } from '../common/voidModelService.js';
+import { URI } from '../../../../base/common/uri.js';
+
+
+
+
+type SimpleLLMMessage = {
+	role: 'tool';
+	content: string;
+	id: string;
+	name: ToolName;
+	rawParams: RawToolParamsObj;
+} | {
+	role: 'user';
+	content: string;
+} | {
+	role: 'assistant';
+	content: string;
+	anthropicReasoning: AnthropicReasoning[] | null;
+}
+
+
+
+
+const EMPTY_MESSAGE = '(empty message)'
+
+const CHARS_PER_TOKEN = 4
+const TRIM_TO_LEN = 60
+
+
+
+
+// convert messages as if about to send to openai
+/*
+reference - https://platform.openai.com/docs/guides/function-calling#function-calling-steps
+openai MESSAGE (role=assistant):
+"tool_calls":[{
+	"type": "function",
+	"id": "call_12345xyz",
+	"function": {
+	"name": "get_weather",
+	"arguments": "{\"latitude\":48.8566,\"longitude\":2.3522}"
+}]
+
+openai RESPONSE (role=user):
+{   "role": "tool",
+	"tool_call_id": tool_call.id,
+	"content": str(result)    }
+
+also see
+openai on prompting - https://platform.openai.com/docs/guides/reasoning#advice-on-prompting
+openai on developer system message - https://cdn.openai.com/spec/model-spec-2024-05-08.html#follow-the-chain-of-command
+*/
+
+
+const prepareMessages_openai_tools = (messages: SimpleLLMMessage[]): LLMChatMessage[] => {
+
+	const newMessages: OpenAILLMChatMessage[] = [];
+
+	for (let i = 0; i < messages.length; i += 1) {
+		const currMsg = messages[i]
+
+		if (currMsg.role !== 'tool') {
+			newMessages.push(currMsg)
+			continue
+		}
+
+		// edit previous assistant message to have called the tool
+		const prevMsg = 0 <= i - 1 && i - 1 <= newMessages.length ? newMessages[i - 1] : undefined
+		if (prevMsg?.role === 'assistant') {
+			prevMsg.tool_calls = [{
+				type: 'function',
+				id: currMsg.id,
+				function: {
+					name: currMsg.name,
+					arguments: JSON.stringify(currMsg.rawParams)
+				}
+			}]
+		}
+
+		// add the tool
+		newMessages.push({
+			role: 'tool',
+			tool_call_id: currMsg.id,
+			content: currMsg.content,
+		})
+	}
+	return newMessages
+
+}
+
+
+
+// convert messages as if about to send to anthropic
+/*
+https://docs.anthropic.com/en/docs/build-with-claude/tool-use#tool-use-examples
+anthropic MESSAGE (role=assistant):
+"content": [{
+	"type": "text",
+	"text": "<thinking>I need to call the get_weather function, and the user wants SF, which is likely San Francisco, CA.</thinking>"
+}, {
+	"type": "tool_use",
+	"id": "toolu_01A09q90qw90lq917835lq9",
+	"name": "get_weather",
+	"input": { "location": "San Francisco, CA", "unit": "celsius" }
+}]
+anthropic RESPONSE (role=user):
+"content": [{
+	"type": "tool_result",
+	"tool_use_id": "toolu_01A09q90qw90lq917835lq9",
+	"content": "15 degrees"
+}]
+
+
+Converts:
+assistant: ...content
+tool: (id, name, params)
+->
+assistant: ...content, call(name, id, params)
+user: ...content, result(id, content)
+*/
+
+
+const prepareMessages_anthropic_tools = (messages: SimpleLLMMessage[], supportsAnthropicReasoning: boolean): LLMChatMessage[] => {
+	const newMessages: (AnthropicLLMChatMessage | (SimpleLLMMessage & { role: 'tool' }))[] = messages;
+
+	for (let i = 0; i < messages.length; i += 1) {
+		const currMsg = messages[i]
+
+		// add anthropic reasoning
+		if (currMsg.role === 'assistant') {
+			if (currMsg.anthropicReasoning && supportsAnthropicReasoning) {
+				const content = currMsg.content
+				newMessages[i] = {
+					role: 'assistant',
+					content: content ? [...currMsg.anthropicReasoning, { type: 'text' as const, text: content }] : currMsg.anthropicReasoning
+				}
+			}
+			else {
+				newMessages[i] = {
+					role: 'assistant',
+					content: currMsg.content,
+					// strip away anthropicReasoning
+				}
+			}
+			continue
+		}
+
+		if (currMsg.role === 'user') {
+			newMessages[i] = {
+				role: 'user',
+				content: currMsg.content,
+			}
+			continue
+		}
+
+		if (currMsg.role === 'tool') {
+			// add anthropic tools
+			const prevMsg = 0 <= i - 1 && i - 1 <= newMessages.length ? newMessages[i - 1] : undefined
+
+			// make it so the assistant called the tool
+			if (prevMsg?.role === 'assistant') {
+				if (typeof prevMsg.content === 'string') prevMsg.content = [{ type: 'text', text: prevMsg.content }]
+				prevMsg.content.push({ type: 'tool_use', id: currMsg.id, name: currMsg.name, input: currMsg.rawParams })
+			}
+
+			// turn each tool into a user message with tool results at the end
+			newMessages[i] = {
+				role: 'user',
+				content: [{ type: 'tool_result', tool_use_id: currMsg.id, content: currMsg.content }]
+			}
+			continue
+		}
+
+	}
+
+	// we just removed the tools
+	return newMessages as AnthropicLLMChatMessage[]
+}
+
+
+const prepareMessages_XML_tools = (messages: SimpleLLMMessage[], supportsAnthropicReasoning: boolean): LLMChatMessage[] => {
+
+	const llmChatMessages: LLMChatMessage[] = [];
+	for (let i = 0; i < messages.length; i += 1) {
+
+		const c = messages[i]
+		const next = 0 <= i + 1 && i + 1 <= messages.length - 1 ? messages[i + 1] : null
+
+		if (c.role === 'assistant') {
+			// if called a tool (message after it), re-add its XML to the message
+			// alternatively, could just hold onto the original output, but this way requires less piping raw strings everywhere
+			let content: LLMChatMessage['content'] = c.content
+			if (next?.role === 'tool') {
+				content = `${content}\n\n${reParsedToolXMLString(next.name, next.rawParams)}`
+			}
+
+			// anthropic reasoning
+			if (c.anthropicReasoning && supportsAnthropicReasoning) {
+				content = content ? [...c.anthropicReasoning, { type: 'text' as const, text: content }] : c.anthropicReasoning
+			}
+			llmChatMessages.push({
+				role: 'assistant',
+				content
+			})
+		}
+		// add user or tool to the previous user message
+		else if (c.role === 'user' || c.role === 'tool') {
+			if (c.role === 'tool')
+				c.content = `<${c.name}_result>\n${c.content}\n</${c.name}_result>`
+
+			if (llmChatMessages.length === 0 || llmChatMessages[llmChatMessages.length - 1].role !== 'user')
+				llmChatMessages.push({
+					role: 'user',
+					content: c.content
+				})
+			else
+				llmChatMessages[llmChatMessages.length - 1].content += '\n\n' + c.content
+		}
+	}
+	return llmChatMessages
+}
+
+
+
+const prepareMessages_providerSpecific = (messages: SimpleLLMMessage[], specialToolFormat: 'openai-style' | 'anthropic-style' | undefined, supportsAnthropicReasoning: boolean): LLMChatMessage[] => {
+	const llmChatMessages: LLMChatMessage[] = []
+	if (!specialToolFormat) { // XML tool behavior
+		return prepareMessages_XML_tools(messages, supportsAnthropicReasoning)
+	}
+	else if (specialToolFormat === 'anthropic-style') {
+		return prepareMessages_anthropic_tools(messages, supportsAnthropicReasoning)
+	}
+	else if (specialToolFormat === 'openai-style') {
+		return prepareMessages_openai_tools(messages)
+	}
+	return llmChatMessages
+}
+
+
+// --- CHAT ---
+
+const prepareMessages = ({
+	messages,
+	systemMessage,
+	aiInstructions,
+	supportsSystemMessage,
+	specialToolFormat,
+	supportsAnthropicReasoning,
+	contextWindow,
+	maxOutputTokens,
+}: {
+	messages: SimpleLLMMessage[],
+	systemMessage: string,
+	aiInstructions: string,
+	supportsSystemMessage: false | 'system-role' | 'developer-role' | 'separated',
+	specialToolFormat: 'openai-style' | 'anthropic-style' | undefined,
+	supportsAnthropicReasoning: boolean,
+	contextWindow: number,
+	maxOutputTokens: number | null | undefined,
+}): { messages: LLMChatMessage[], separateSystemMessage: string | undefined } => {
+	maxOutputTokens = maxOutputTokens ?? 4_096 // default to 4096
+
+	// ================ trim ================
+
+	messages = deepClone(messages)
+	messages = messages.map(m => ({ ...m, content: m.role !== 'tool' ? m.content.trim() : m.content }))
+
+	// ================ fit into context ================
+
+	// the higher the weight, the higher the desire to truncate - TRIM HIGHEST WEIGHT MESSAGES
+	const alreadyTrimmedIdxes = new Set<number>()
+	const weight = (message: SimpleLLMMessage, messages: SimpleLLMMessage[], idx: number) => {
+		const base = message.content.length
+
+		let multiplier: number
+		multiplier = 1 + (messages.length - 1 - idx) / messages.length // slow rampdown from 2 to 1 as index increases
+		if (message.role === 'user') {
+			multiplier *= 1
+		}
+		else {
+			multiplier *= 10 // llm tokens are far less valuable than user tokens
+		}
+		// 1st message, last 3 msgs, any already modified message should be low in weight
+		if (idx === 0 || idx >= messages.length - 1 - 3 || alreadyTrimmedIdxes.has(idx)) {
+			multiplier *= .05
+		}
+		return base * multiplier
+	}
+
+	const _findLargestByWeight = (messages: SimpleLLMMessage[]) => {
+		let largestIndex = -1
+		let largestWeight = -Infinity
+		for (let i = 0; i < messages.length; i += 1) {
+			const m = messages[i]
+			const w = weight(m, messages, i)
+			if (w > largestWeight) {
+				largestWeight = w
+				largestIndex = i
+			}
+		}
+		return largestIndex
+	}
+
+	let totalLen = 0
+	for (const m of messages) { totalLen += m.content.length }
+	const charsNeedToTrim = totalLen - (contextWindow - maxOutputTokens) * CHARS_PER_TOKEN
+
+	// <----------------------------------------->
+	// 0                      |    |             |
+	//                        |    contextWindow |
+	//                     contextWindow - maxOut|putTokens
+	//                                          totalLen
+	let remainingCharsToTrim = charsNeedToTrim
+	let i = 0
+
+	while (remainingCharsToTrim > 0) {
+		i += 1
+		if (i > 100) break
+
+		const trimIdx = _findLargestByWeight(messages)
+		const m = messages[trimIdx]
+
+		// if can finish here, do
+		const numCharsWillTrim = m.content.length - TRIM_TO_LEN
+		if (numCharsWillTrim > remainingCharsToTrim) {
+			m.content = m.content.slice(0, m.content.length - remainingCharsToTrim).trim()
+			break
+		}
+
+		remainingCharsToTrim -= numCharsWillTrim
+		m.content = m.content.substring(0, TRIM_TO_LEN - 3) + '...'
+		alreadyTrimmedIdxes.add(trimIdx)
+	}
+
+	// ================ tools and anthropicReasoning ================
+	const llmMessages: LLMChatMessage[] = prepareMessages_providerSpecific(messages, specialToolFormat, supportsAnthropicReasoning)
+
+	// ================ system message concat ================
+
+	// find system messages and concatenate them
+	const newSystemMessage = aiInstructions ?
+		`${(systemMessage ? `${systemMessage}\n\n` : '')}GUIDELINES\n${aiInstructions}`
+		: systemMessage
+
+	let separateSystemMessageStr: string | undefined = undefined
+
+	// if supports system message
+	if (supportsSystemMessage) {
+		if (supportsSystemMessage === 'separated')
+			separateSystemMessageStr = newSystemMessage
+		else if (supportsSystemMessage === 'system-role')
+			llmMessages.unshift({ role: 'system', content: newSystemMessage }) // add new first message
+		else if (supportsSystemMessage === 'developer-role')
+			llmMessages.unshift({ role: 'developer', content: newSystemMessage }) // add new first message
+	}
+	// if does not support system message
+	else {
+		const newFirstMessage = {
+			role: 'user',
+			content: `<SYSTEM_MESSAGE>\n${newSystemMessage}\n</SYSTEM_MESSAGE>\n${llmMessages[0].content}`
+		} as const
+		llmMessages.splice(0, 1) // delete first message
+		llmMessages.unshift(newFirstMessage) // add new first message
+	}
+
+
+	// ================ no empty message ================
+	for (const currMsg of llmMessages) {
+		if (currMsg.role === 'tool') continue
+
+		// if content is a string, replace string with empty msg
+		if (typeof currMsg.content === 'string')
+			currMsg.content = currMsg.content || EMPTY_MESSAGE
+		else {
+			// if content is an array, replace any empty text entries with empty msg, and make sure there's at least 1 entry
+			for (const c of currMsg.content) {
+				if (c.type === 'text') c.text = c.text || EMPTY_MESSAGE
+			}
+			if (currMsg.content.length === 0) currMsg.content = [{ type: 'text', text: EMPTY_MESSAGE }]
+		}
+	}
+
+	return {
+		messages: llmMessages,
+		separateSystemMessage: separateSystemMessageStr,
+	} as const
+}
+
+
+
+
+
+
+
+
+
+
+
+export interface IConvertToLLMMessageService {
+	readonly _serviceBrand: undefined;
+	prepareLLMSimpleMessages: (opts: { simpleMessages: SimpleLLMMessage[], systemMessage: string, modelSelection: ModelSelection | null, featureName: FeatureName }) => { messages: LLMChatMessage[], separateSystemMessage: string | undefined }
+	prepareLLMChatMessages: (opts: { chatMessages: ChatMessage[], chatMode: ChatMode, modelSelection: ModelSelection | null }) => Promise<{ messages: LLMChatMessage[], separateSystemMessage: string | undefined }>
+	prepareFIMMessage(opts: { messages: LLMFIMMessage, }): { prefix: string, suffix: string, stopTokens: string[] }
+
+}
+
+export const IConvertToLLMMessageService = createDecorator<IConvertToLLMMessageService>('ConvertToLLMMessageService');
+
+
+class ConvertToLLMMessageService extends Disposable implements IConvertToLLMMessageService {
+	_serviceBrand: undefined;
+
+	constructor(
+		@IModelService private readonly modelService: IModelService,
+		@IWorkspaceContextService private readonly workspaceContextService: IWorkspaceContextService,
+		@IEditorService private readonly editorService: IEditorService,
+		@IDirectoryStrService private readonly directoryStrService: IDirectoryStrService,
+		@ITerminalToolService private readonly terminalToolService: ITerminalToolService,
+		@IVoidSettingsService private readonly voidSettingsService: IVoidSettingsService,
+		@IVoidModelService private readonly voidModelService: IVoidModelService,
+	) {
+		super()
+	}
+
+	// Read .voidinstructions files from workspace folders
+	private _getVoidInstructionsFileContents(): string {
+		const workspaceFolders = this.workspaceContextService.getWorkspace().folders;
+		let voidInstructions = '';
+		for (const folder of workspaceFolders) {
+			const uri = URI.joinPath(folder.uri, '.voidinstructions')
+			const { model } = this.voidModelService.getModel(uri)
+			if (!model) continue
+			voidInstructions += model.getValue() + '\n\n';
+		}
+		return voidInstructions.trim();
+	}
+
+	// Get combined AI instructions from settings and .voidinstructions files
+	private _getCombinedAIInstructions(): string {
+		const globalAIInstructions = this.voidSettingsService.state.globalSettings.aiInstructions;
+		const voidInstructionsFileContent = this._getVoidInstructionsFileContents();
+
+		const ans: string[] = []
+		if (globalAIInstructions) ans.push(globalAIInstructions)
+		if (voidInstructionsFileContent) ans.push(voidInstructionsFileContent)
+		return ans.join('\n\n')
+	}
+
+
+	// system message
+	private _generateChatMessagesSystemMessage = async (chatMode: ChatMode, specialToolFormat: 'openai-style' | 'anthropic-style' | undefined) => {
+		const workspaceFolders = this.workspaceContextService.getWorkspace().folders.map(f => f.uri.fsPath)
+
+		const openedURIs = this.modelService.getModels().filter(m => m.isAttachedToEditor()).map(m => m.uri.fsPath) || [];
+		const activeURI = this.editorService.activeEditor?.resource?.fsPath;
+
+		const directoryStr = await this.directoryStrService.getAllDirectoriesStr({
+			cutOffMessage: chatMode === 'agent' || chatMode === 'gather' ?
+				`...Directories string cut off, use tools to read more...`
+				: `...Directories string cut off, ask user for more if necessary...`
+		})
+		const includeXMLToolDefinitions = !specialToolFormat
+
+		const runningTerminalIds = this.terminalToolService.listTerminalIds()
+		const systemMessage = chat_systemMessage({ workspaceFolders, openedURIs, directoryStr, activeURI, runningTerminalIds, chatMode, includeXMLToolDefinitions })
+		return systemMessage
+	}
+
+
+
+
+	// --- LLM Chat messages ---
+
+	private _chatMessagesToSimpleMessages(chatMessages: ChatMessage[]): SimpleLLMMessage[] {
+		const simpleLLMMessages: SimpleLLMMessage[] = []
+
+		for (const m of chatMessages) {
+			if (m.role === 'checkpoint') continue
+			if (m.role === 'interrupted_streaming_tool') continue
+			if (m.role === 'assistant') {
+				simpleLLMMessages.push({
+					role: m.role,
+					content: m.displayContent,
+					anthropicReasoning: m.anthropicReasoning,
+				})
+			}
+			else if (m.role === 'tool') {
+				simpleLLMMessages.push({
+					role: m.role,
+					content: m.content,
+					name: m.name,
+					id: m.id,
+					rawParams: m.rawParams,
+				})
+			}
+			else if (m.role === 'user') {
+				simpleLLMMessages.push({
+					role: m.role,
+					content: m.content,
+				})
+			}
+		}
+		return simpleLLMMessages
+	}
+
+	prepareLLMSimpleMessages: IConvertToLLMMessageService['prepareLLMSimpleMessages'] = ({ simpleMessages, systemMessage, modelSelection, featureName }) => {
+		if (modelSelection === null) return { messages: [], separateSystemMessage: undefined }
+		const { providerName, modelName } = modelSelection
+		const {
+			specialToolFormat,
+			contextWindow,
+			supportsSystemMessage,
+		} = getModelCapabilities(providerName, modelName)
+
+		const modelSelectionOptions = this.voidSettingsService.state.optionsOfModelSelection[featureName][modelSelection.providerName]?.[modelSelection.modelName]
+
+		// Get combined AI instructions
+		const aiInstructions = this._getCombinedAIInstructions();
+
+		const isReasoningEnabled = getIsReasoningEnabledState(featureName, providerName, modelName, modelSelectionOptions)
+		const maxOutputTokens = getMaxOutputTokens(providerName, modelName, { isReasoningEnabled })
+
+		const { messages, separateSystemMessage } = prepareMessages({
+			messages: simpleMessages,
+			systemMessage,
+			aiInstructions,
+			supportsSystemMessage,
+			specialToolFormat,
+			supportsAnthropicReasoning: providerName === 'anthropic',
+			contextWindow,
+			maxOutputTokens,
+		})
+		return { messages, separateSystemMessage };
+	}
+	prepareLLMChatMessages: IConvertToLLMMessageService['prepareLLMChatMessages'] = async ({ chatMessages, chatMode, modelSelection }) => {
+		if (modelSelection === null) return { messages: [], separateSystemMessage: undefined }
+		const { providerName, modelName } = modelSelection
+		const {
+			specialToolFormat,
+			contextWindow,
+			supportsSystemMessage,
+		} = getModelCapabilities(providerName, modelName)
+		const systemMessage = await this._generateChatMessagesSystemMessage(chatMode, specialToolFormat)
+
+		const modelSelectionOptions = this.voidSettingsService.state.optionsOfModelSelection['Chat'][modelSelection.providerName]?.[modelSelection.modelName]
+
+		// Get combined AI instructions
+		const aiInstructions = this._getCombinedAIInstructions();
+
+		const isReasoningEnabled = getIsReasoningEnabledState('Chat', providerName, modelName, modelSelectionOptions)
+		const maxOutputTokens = getMaxOutputTokens(providerName, modelName, { isReasoningEnabled })
+		const llmMessages = this._chatMessagesToSimpleMessages(chatMessages)
+
+		const { messages, separateSystemMessage } = prepareMessages({
+			messages: llmMessages,
+			systemMessage,
+			aiInstructions,
+			supportsSystemMessage,
+			specialToolFormat,
+			supportsAnthropicReasoning: providerName === 'anthropic',
+			contextWindow,
+			maxOutputTokens,
+		})
+		return { messages, separateSystemMessage };
+	}
+
+
+	// --- FIM ---
+
+	prepareFIMMessage: IConvertToLLMMessageService['prepareFIMMessage'] = ({ messages }) => {
+		// Get combined AI instructions with the provided aiInstructions as the base
+		const combinedInstructions = this._getCombinedAIInstructions();
+
+		let prefix = `\
+${!combinedInstructions ? '' : `\
+// Instructions:
+// Do not output an explanation. Try to avoid outputting comments. Only output the middle code.
+${combinedInstructions.split('\n').map(line => `//${line}`).join('\n')}`}
+
+${messages.prefix}`
+
+		const suffix = messages.suffix
+		const stopTokens = messages.stopTokens
+		return { prefix, suffix, stopTokens }
+	}
+
+
+}
+
+
+registerSingleton(IConvertToLLMMessageService, ConvertToLLMMessageService, InstantiationType.Eager);
+
+
+
+
+
+
+
+
+/*
+Gemini has this, but they're openai-compat so we don't need to implement this
+gemini request:
+{   "role": "assistant",
+	"content": null,
+	"function_call": {
+		"name": "get_weather",
+		"arguments": {
+			"latitude": 48.8566,
+			"longitude": 2.3522
+		}
+	}
+}
+
+gemini response:
+{   "role": "assistant",
+	"function_response": {
+		"name": "get_weather",
+			"response": {
+			"temperature": "15°C",
+				"condition": "Cloudy"
+		}
+	}
+}
+*/
+
+
+

src/vs/workbench/contrib/void/browser/convertToLLMMessageWorkbenchContrib.ts

@@ -0,0 +1,37 @@
+/*--------------------------------------------------------------------------------------
+ *  Copyright 2025 Glass Devtools, Inc. All rights reserved.
+ *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
+ *--------------------------------------------------------------------------------------*/
+
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { URI } from '../../../../base/common/uri.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { IWorkbenchContribution, registerWorkbenchContribution2, WorkbenchPhase } from '../../../common/contributions.js';
+import { IVoidModelService } from '../common/voidModelService.js';
+
+class ConvertContribWorkbenchContribution extends Disposable implements IWorkbenchContribution {
+	static readonly ID = 'workbench.contrib.void.convertcontrib'
+	_serviceBrand: undefined;
+
+	constructor(
+		@IVoidModelService private readonly voidModelService: IVoidModelService,
+		@IWorkspaceContextService private readonly workspaceContext: IWorkspaceContextService,
+	) {
+		super()
+
+		const initializeURI = (uri: URI) => {
+			this.workspaceContext.getWorkspace()
+			const voidInstrsURI = URI.joinPath(uri, '.voidinstructions')
+			this.voidModelService.initializeModel(voidInstrsURI)
+		}
+
+		// call
+		this._register(this.workspaceContext.onDidChangeWorkspaceFolders((e) => {
+			[...e.changed, ...e.added].forEach(w => { initializeURI(w.uri) })
+		}))
+		this.workspaceContext.getWorkspace().folders.forEach(w => { initializeURI(w.uri) })
+	}
+}
+
+
+registerWorkbenchContribution2(ConvertContribWorkbenchContribution.ID, ConvertContribWorkbenchContribution, WorkbenchPhase.BlockRestore);

src/vs/workbench/contrib/void/browser/directoryStrService.ts

@@ -14,19 +14,23 @@ import { MAX_CHILDREN_URIs_PAGE } from './toolsService.js';
 import { IExplorerService } from '../../files/browser/files.js';
 import { SortOrder } from '../../files/common/files.js';
 import { ExplorerItem } from '../../files/common/explorerModel.js';
-import { VoidDirectoryItem } from '../common/directoryStrTypes.js';
+import { MAX_DIRSTR_CHARS_TOTAL_BEGINNING, MAX_DIRSTR_CHARS_TOTAL_TOOL } from '../common/prompt/prompts.js';
 
 
-const MAX_CHARS_TOTAL_BEGINNING = 20_000
-const MAX_CHARS_TOTAL_TOOL = 20_000
-// const MAX_FILES_TOTAL = 200
+const MAX_FILES_TOTAL = 300;
+
+const DEFAULT_MAX_DEPTH = 3;
+const DEFAULT_MAX_ITEMS_PER_DIR = 3;
+
+const START_MAX_DEPTH = Infinity;
+const START_MAX_ITEMS_PER_DIR = Infinity; // Add start value as Infinity
 
 
 export interface IDirectoryStrService {
 	readonly _serviceBrand: undefined;
 
-	getDirectoryStrTool(uri: URI): Promise<{ wasCutOff: boolean, str: string }>
-	getAllDirectoriesStr(): Promise<{ wasCutOff: boolean, str: string }>
+	getDirectoryStrTool(uri: URI, options?: { maxItemsPerDir?: number }): Promise<string>
+	getAllDirectoriesStr(opts: { cutOffMessage: string, maxItemsPerDir?: number }): Promise<string>
 
 }
 export const IDirectoryStrService = createDecorator<IDirectoryStrService>('voidDirectoryStrService');
@@ -54,11 +58,17 @@ const shouldExcludeDirectory = (item: ExplorerItem) => {
 		item.name === 'obj' ||
 		item.name === 'vendor' ||
 		item.name === 'logs' ||
-		item.name === 'cache'
+		item.name === 'cache' ||
+		item.name === 'resource' ||
+		item.name === 'resources'
 
 	) {
 		return true;
 	}
+
+	if (item.name.match(/\bout\b/)) return true
+	if (item.name.match(/\bbuild\b/)) return true
+
 	return false;
 }
 
@@ -129,130 +139,175 @@ export const stringifyDirectoryTree1Deep = (params: ToolCallParams['ls_dir'], re
 
 // ---------- IN GENERAL ----------
 
-
-// if the filter exists use it to filter out files and folders when creating the tree
-const computeDirectoryTree = async (
+// Remove the old computeDirectoryTree function and replace with a combined version that handles both computation and rendering
+const computeAndStringifyDirectoryTree = async (
 	eItem: ExplorerItem,
-	explorerService: IExplorerService
-): Promise<VoidDirectoryItem> => {
-	// Fetch children with default sort order
-	const eChildren = await eItem.fetchChildren(SortOrder.FilesFirst);
-
-	const isGitIgnoredDirectory = eItem.isDirectory && shouldExcludeDirectory(eItem)
-
-	// Process children recursively
-	const children = !isGitIgnoredDirectory ? await Promise.all(
-		eChildren.map(async c => await computeDirectoryTree(c, explorerService))
-	) : null
-
-	// Create our directory item
-	const item: VoidDirectoryItem = {
-		uri: eItem.resource,
-		name: eItem.name,
-		isDirectory: eItem.isDirectory,
-		isSymbolicLink: eItem.isSymbolicLink,
-		children,
-		isGitIgnoredDirectory: isGitIgnoredDirectory && { numChildren: eItem.children.size },
-	};
-
-	return item;
-};
-
-
-const stringifyDirectoryTree = (
-	node: VoidDirectoryItem,
+	explorerService: IExplorerService,
 	MAX_CHARS: number,
-): { content: string, wasCutOff: boolean } => {
-	let content = '';
-	let wasCutOff = false;
+	fileCount: { count: number } = { count: 0 },
+	options: { maxDepth?: number, currentDepth?: number, maxItemsPerDir?: number } = {}
+): Promise<{ content: string, wasCutOff: boolean }> => {
+	// Set default values for options
+	const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+	const currentDepth = options.currentDepth ?? 0;
+	const maxItemsPerDir = options.maxItemsPerDir ?? DEFAULT_MAX_ITEMS_PER_DIR;
+
+	// Check if we've reached the max depth
+	if (currentDepth > maxDepth) {
+		return { content: '', wasCutOff: true };
+	}
+
+	// Check if we've reached the file limit
+	if (fileCount.count >= MAX_FILES_TOTAL) {
+		return { content: '', wasCutOff: true };
+	}
 
 	// If we're already exceeding the max characters, return immediately
 	if (MAX_CHARS <= 0) {
-		return { content, wasCutOff: true };
+		return { content: '', wasCutOff: true };
 	}
 
+	// Increment file count
+	fileCount.count++;
+
 	// Add the root node first (without tree characters)
-	const nodeLine = `${node.name}${node.isDirectory ? '/' : ''}${node.isSymbolicLink ? ' (symbolic link)' : ''}\n`;
+	const nodeLine = `${eItem.name}${eItem.isDirectory ? '/' : ''}${eItem.isSymbolicLink ? ' (symbolic link)' : ''}\n`;
 
 	if (nodeLine.length > MAX_CHARS) {
 		return { content: '', wasCutOff: true };
 	}
 
-	content += nodeLine;
+	let content = nodeLine;
+	let wasCutOff = false;
 	let remainingChars = MAX_CHARS - nodeLine.length;
 
-	// Then recursively add all children with proper tree formatting
-	if (node.children && node.children.length > 0) {
-		const { childrenContent, childrenCutOff } = renderChildren(
-			node.children,
-			remainingChars,
-			''
-		);
-		content += childrenContent;
-		wasCutOff = childrenCutOff;
+	// Check if it's a directory we should skip
+	const isGitIgnoredDirectory = eItem.isDirectory && shouldExcludeDirectory(eItem);
+
+	// Fetch and process children if not a filtered directory
+	if (eItem.isDirectory && !isGitIgnoredDirectory) {
+		// Fetch children with Modified sort order to show recently modified first
+		const eChildren = await eItem.fetchChildren(SortOrder.Modified);
+
+		// Then recursively add all children with proper tree formatting
+		if (eChildren && eChildren.length > 0) {
+			const { childrenContent, childrenCutOff } = await renderChildrenCombined(
+				eChildren,
+				remainingChars,
+				'',
+				explorerService,
+				fileCount,
+				{ maxDepth, currentDepth, maxItemsPerDir } // Pass maxItemsPerDir to the render function
+			);
+			content += childrenContent;
+			wasCutOff = childrenCutOff;
+		}
 	}
+
 	return { content, wasCutOff };
 };
 
 // Helper function to render children with proper tree formatting
-const renderChildren = (
-	children: VoidDirectoryItem[],
+const renderChildrenCombined = async (
+	children: ExplorerItem[],
 	maxChars: number,
-	parentPrefix: string
-): { childrenContent: string, childrenCutOff: boolean } => {
+	parentPrefix: string,
+	explorerService: IExplorerService,
+	fileCount: { count: number },
+	options: { maxDepth: number, currentDepth: number, maxItemsPerDir?: number }
+): Promise<{ childrenContent: string, childrenCutOff: boolean }> => {
+	const { maxDepth, currentDepth } = options; // Remove maxItemsPerDir from destructuring
+	// Get maxItemsPerDir separately and make sure we use it
+	// For first level (currentDepth = 0), always use Infinity regardless of what was passed
+	const maxItemsPerDir = currentDepth === 0 ?
+		Infinity :
+		(options.maxItemsPerDir ?? DEFAULT_MAX_ITEMS_PER_DIR);
+	const nextDepth = currentDepth + 1;
+
 	let childrenContent = '';
 	let childrenCutOff = false;
+	let remainingChars = maxChars;
 
-	for (let i = 0; i < children.length; i++) {
-		const child = children[i];
-		const isLast = i === children.length - 1;
+	// Check if we've reached max depth
+	if (nextDepth > maxDepth) {
+		return { childrenContent: '', childrenCutOff: true };
+	}
+
+	// Apply maxItemsPerDir limit - only process the specified number of items
+	const itemsToProcess = maxItemsPerDir === Infinity ? children : children.slice(0, maxItemsPerDir);
+	const hasMoreItems = children.length > itemsToProcess.length;
+
+	for (let i = 0; i < itemsToProcess.length; i++) {
+		// Check if we've reached the file limit
+		if (fileCount.count >= MAX_FILES_TOTAL) {
+			childrenCutOff = true;
+			break;
+		}
+
+		const child = itemsToProcess[i];
+		const isLast = (i === itemsToProcess.length - 1) && !hasMoreItems;
 
 		// Create the tree branch symbols
 		const branchSymbol = isLast ? '└── ' : '├── ';
 		const childLine = `${parentPrefix}${branchSymbol}${child.name}${child.isDirectory ? '/' : ''}${child.isSymbolicLink ? ' (symbolic link)' : ''}\n`;
 
 		// Check if adding this line would exceed the limit
-		if (childrenContent.length + childLine.length > maxChars) {
+		if (childLine.length > remainingChars) {
 			childrenCutOff = true;
 			break;
 		}
+
 		childrenContent += childLine;
+		remainingChars -= childLine.length;
+		fileCount.count++;
 
 		const nextLevelPrefix = parentPrefix + (isLast ? '    ' : '│   ');
 
-
-		// if gitignored, just say the number of children
-		if (child.isDirectory && child.isGitIgnoredDirectory && child.isGitIgnoredDirectory.numChildren > 0) {
-			childrenContent += `${nextLevelPrefix}└── ... (${child.isGitIgnoredDirectory.numChildren} children) ...\n`
-		}
+		// Skip processing children for git ignored directories
+		const isGitIgnoredDirectory = child.isDirectory && shouldExcludeDirectory(child);
 
 		// Create the prefix for the next level (continuation line or space)
-		else if (child.children && child.children.length > 0) {
+		if (child.isDirectory && !isGitIgnoredDirectory) {
+			// Fetch children with Modified sort order to show recently modified first
+			const eChildren = await child.fetchChildren(SortOrder.Modified);
 
-			const {
-				childrenContent: grandChildrenContent,
-				childrenCutOff: grandChildrenCutOff
-			} = renderChildren(
-				child.children,
-				maxChars,
-				nextLevelPrefix
-			);
+			if (eChildren && eChildren.length > 0) {
+				const {
+					childrenContent: grandChildrenContent,
+					childrenCutOff: grandChildrenCutOff
+				} = await renderChildrenCombined(
+					eChildren,
+					remainingChars,
+					nextLevelPrefix,
+					explorerService,
+					fileCount,
+					{ maxDepth, currentDepth: nextDepth, maxItemsPerDir }
+				);
 
-			// If adding grandchildren content would exceed the limit
-			if (childrenContent.length + grandChildrenContent.length > maxChars) {
-				childrenCutOff = true;
-				break;
-			}
+				if (grandChildrenContent.length > 0) {
+					childrenContent += grandChildrenContent;
+					remainingChars -= grandChildrenContent.length;
+				}
 
-			childrenContent += grandChildrenContent;
-
-			if (grandChildrenCutOff) {
-				childrenCutOff = true;
-				break;
+				if (grandChildrenCutOff) {
+					childrenCutOff = true;
+				}
 			}
 		}
 	}
 
+	// Add a message if we truncated the items due to maxItemsPerDir
+	if (hasMoreItems) {
+		const remainingCount = children.length - itemsToProcess.length;
+		const truncatedLine = `${parentPrefix}└── (${remainingCount} more items not shown...)\n`;
+
+		if (truncatedLine.length <= remainingChars) {
+			childrenContent += truncatedLine;
+			remainingChars -= truncatedLine.length;
+		}
+		childrenCutOff = true;
+	}
+
 	return { childrenContent, childrenCutOff };
 };
 
@@ -270,23 +325,54 @@ class DirectoryStrService extends Disposable implements IDirectoryStrService {
 		super();
 	}
 
-	async getDirectoryStrTool(uri: URI) {
+	async getDirectoryStrTool(uri: URI, options?: { maxItemsPerDir?: number }) {
 		const eRoot = this.explorerService.findClosest(uri)
 		if (!eRoot) throw new Error(`There was a problem reading the URI: ${uri.fsPath}.`)
 
-		const dirTree = await computeDirectoryTree(eRoot, this.explorerService);
-		const { content, wasCutOff } = stringifyDirectoryTree(dirTree, MAX_CHARS_TOTAL_TOOL);
+		const maxItemsPerDir = options?.maxItemsPerDir ?? START_MAX_ITEMS_PER_DIR; // Use START_MAX_ITEMS_PER_DIR
 
-		return {
-			str: `Directory of ${uri.fsPath}:\n${content}`,
-			wasCutOff,
+		// First try with START_MAX_DEPTH
+		const { content: initialContent, wasCutOff: initialCutOff } = await computeAndStringifyDirectoryTree(
+			eRoot,
+			this.explorerService,
+			MAX_DIRSTR_CHARS_TOTAL_TOOL,
+			{ count: 0 },
+			{ maxDepth: START_MAX_DEPTH, currentDepth: 0, maxItemsPerDir }
+		);
+
+		// If cut off, try again with DEFAULT_MAX_DEPTH and DEFAULT_MAX_ITEMS_PER_DIR
+		let content, wasCutOff;
+		if (initialCutOff) {
+			const result = await computeAndStringifyDirectoryTree(
+				eRoot,
+				this.explorerService,
+				MAX_DIRSTR_CHARS_TOTAL_TOOL,
+				{ count: 0 },
+				{ maxDepth: DEFAULT_MAX_DEPTH, currentDepth: 0, maxItemsPerDir: DEFAULT_MAX_ITEMS_PER_DIR }
+			);
+			content = result.content;
+			wasCutOff = result.wasCutOff;
+		} else {
+			content = initialContent;
+			wasCutOff = initialCutOff;
 		}
+
+		let c = content.substring(0, MAX_DIRSTR_CHARS_TOTAL_TOOL)
+		c = `Directory of ${uri.fsPath}:\n${content}`
+		if (wasCutOff) c = `${c}\n...Result was truncated...`
+
+		return c
 	}
 
-	async getAllDirectoriesStr() {
+	async getAllDirectoriesStr({ cutOffMessage, maxItemsPerDir }: { cutOffMessage: string, maxItemsPerDir?: number }) {
 		let str: string = '';
 		let cutOff = false;
 		const folders = this.workspaceContextService.getWorkspace().folders;
+		if (folders.length === 0)
+			return '(NO WORKSPACE OPEN)';
+
+		// Use START_MAX_ITEMS_PER_DIR if not specified
+		const startMaxItemsPerDir = maxItemsPerDir ?? START_MAX_ITEMS_PER_DIR;
 
 		for (let i = 0; i < folders.length; i += 1) {
 			if (i > 0) str += '\n';
@@ -299,10 +385,32 @@ class DirectoryStrService extends Disposable implements IDirectoryStrService {
 			const eRoot = this.explorerService.findClosestRoot(rootURI);
 			if (!eRoot) continue;
 
-			// Use our new approach with direct explorer service
-			const dirTree = await computeDirectoryTree(eRoot, this.explorerService);
-			console.log('dirtree', dirTree)
-			const { content, wasCutOff } = stringifyDirectoryTree(dirTree, MAX_CHARS_TOTAL_BEGINNING - str.length);
+			// First try with START_MAX_DEPTH and startMaxItemsPerDir
+			const { content: initialContent, wasCutOff: initialCutOff } = await computeAndStringifyDirectoryTree(
+				eRoot,
+				this.explorerService,
+				MAX_DIRSTR_CHARS_TOTAL_BEGINNING - str.length,
+				{ count: 0 },
+				{ maxDepth: START_MAX_DEPTH, currentDepth: 0, maxItemsPerDir: startMaxItemsPerDir }
+			);
+
+			// If cut off, try again with DEFAULT_MAX_DEPTH and DEFAULT_MAX_ITEMS_PER_DIR
+			let content, wasCutOff;
+			if (initialCutOff) {
+				const result = await computeAndStringifyDirectoryTree(
+					eRoot,
+					this.explorerService,
+					MAX_DIRSTR_CHARS_TOTAL_BEGINNING - str.length,
+					{ count: 0 },
+					{ maxDepth: DEFAULT_MAX_DEPTH, currentDepth: 0, maxItemsPerDir: DEFAULT_MAX_ITEMS_PER_DIR }
+				);
+				content = result.content;
+				wasCutOff = result.wasCutOff;
+			} else {
+				content = initialContent;
+				wasCutOff = initialCutOff;
+			}
+
 			str += content;
 			if (wasCutOff) {
 				cutOff = true;
@@ -310,7 +418,11 @@ class DirectoryStrService extends Disposable implements IDirectoryStrService {
 			}
 		}
 
-		return { wasCutOff: cutOff, str };
+		if (cutOff) {
+			return `${str}\n${cutOffMessage}`
+		}
+
+		return str
 	}
 }
 

src/vs/workbench/contrib/void/browser/editCodeService.ts

@@ -44,10 +44,10 @@ import { IEditCodeService, AddCtrlKOpts, StartApplyingOpts, CallBeforeStartApply
 import { IVoidSettingsService } from '../common/voidSettingsService.js';
 import { FeatureName } from '../common/voidSettingsTypes.js';
 import { IVoidModelService } from '../common/voidModelService.js';
-import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
 import { deepClone } from '../../../../base/common/objects.js';
 import { acceptBg, acceptBorder, buttonFontSize, buttonTextColor, rejectBg, rejectBorder } from '../common/helpers/colors.js';
 import { DiffArea, Diff, CtrlKZone, VoidFileSnapshot, DiffAreaSnapshotEntry, diffAreaSnapshotKeys, DiffZone, TrackingZone, ComputedDiff } from '../common/editCodeServiceTypes.js';
+import { IConvertToLLMMessageService } from './convertToLLMMessageService.js';
 
 const configOfBG = (color: Color) => {
 	return { dark: color, light: color, hcDark: color, hcLight: color, }
@@ -72,6 +72,21 @@ registerColor('void.sweepIdxBG', configOfBG(sweepIdxBG), '', true);
 
 const numLinesOfStr = (str: string) => str.split('\n').length
 
+
+export const getLengthOfTextPx = ({ tabWidth, spaceWidth, content }: { tabWidth: number, spaceWidth: number, content: string }) => {
+	let lengthOfTextPx = 0;
+	for (const char of content) {
+		if (char === '\t') {
+			lengthOfTextPx += tabWidth
+		} else {
+			lengthOfTextPx += spaceWidth;
+		}
+	}
+
+	return lengthOfTextPx
+}
+
+
 const getLeadingWhitespacePx = (editor: ICodeEditor, startLine: number): number => {
 
 	const model = editor.getModel();
@@ -95,16 +110,14 @@ const getLeadingWhitespacePx = (editor: ICodeEditor, startLine: number): number
 	const spaceWidth = editor.getOption(EditorOption.fontInfo).spaceWidth;
 	const tabWidth = numSpacesInTab * spaceWidth;
 
-	let paddingLeft = 0;
-	for (const char of leadingWhitespace) {
-		if (char === '\t') {
-			paddingLeft += tabWidth
-		} else if (char === ' ') {
-			paddingLeft += spaceWidth;
-		}
-	}
+	const leftWhitespacePx = getLengthOfTextPx({
+		tabWidth,
+		spaceWidth,
+		content: leadingWhitespace
+	});
 
-	return paddingLeft;
+
+	return leftWhitespacePx;
 };
 
 
@@ -190,7 +203,7 @@ class EditCodeService extends Disposable implements IEditCodeService {
 		@IVoidSettingsService private readonly _settingsService: IVoidSettingsService,
 		// @IFileService private readonly _fileService: IFileService,
 		@IVoidModelService private readonly _voidModelService: IVoidModelService,
-		@ITextFileService private readonly _textFileService: ITextFileService,
+		@IConvertToLLMMessageService private readonly _convertToLLMMessageService: IConvertToLLMMessageService,
 	) {
 		super();
 
@@ -245,6 +258,22 @@ class EditCodeService extends Disposable implements IEditCodeService {
 			this._realignAllDiffAreasLines(uri, change.text, change.range)
 		}
 		this._refreshStylesAndDiffsInURI(uri)
+
+		// if diffarea has no diffs after a user edit, delete it
+		const diffAreasToDelete: DiffZone[] = []
+		for (const diffareaid of this.diffAreasOfURI[uri.fsPath] ?? []) {
+			const diffArea = this.diffAreaOfId[diffareaid] ?? null
+			const shouldDelete = diffArea?.type === 'DiffZone' && Object.keys(diffArea._diffOfId).length === 0
+			if (shouldDelete) {
+				diffAreasToDelete.push(diffArea)
+			}
+		}
+		if (diffAreasToDelete.length !== 0) {
+			const { onFinishEdit } = this._addToHistory(uri)
+			diffAreasToDelete.forEach(da => this._deleteDiffZone(da))
+			onFinishEdit()
+		}
+
 	}
 
 
@@ -720,16 +749,14 @@ class EditCodeService extends Disposable implements IEditCodeService {
 			resource: uri,
 			label: 'Void Agent',
 			code: 'undoredo.editCode',
-			undo: () => { opts?.onWillUndo?.(); this._restoreVoidFileSnapshot(uri, beforeSnapshot); },
-			redo: () => { if (afterSnapshot) this._restoreVoidFileSnapshot(uri, afterSnapshot) }
+			undo: async () => { opts?.onWillUndo?.(); await this._restoreVoidFileSnapshot(uri, beforeSnapshot) },
+			redo: async () => { if (afterSnapshot) await this._restoreVoidFileSnapshot(uri, afterSnapshot) }
 		}
 		this._undoRedoService.pushElement(elt)
 
 		const onFinishEdit = async () => {
 			afterSnapshot = this._getCurrentVoidFileSnapshot(uri)
-			await this._textFileService.save(uri, { // we want [our change] -> [save] so it's all treated as one change.
-				skipSaveParticipants: true // avoid triggering extensions etc (if they reformat the page, it will add another item to the undo stack)
-			})
+			await this._voidModelService.saveModel(uri)
 		}
 		return { onFinishEdit }
 	}
@@ -1105,6 +1132,7 @@ class EditCodeService extends Disposable implements IEditCodeService {
 		const uri = this._getURIBeforeStartApplying(opts)
 		if (!uri) return
 		await this._voidModelService.initializeModel(uri)
+		await this._voidModelService.saveModel(uri) // save the URI
 	}
 
 
@@ -1223,7 +1251,6 @@ class EditCodeService extends Disposable implements IEditCodeService {
 			_removeStylesFns: new Set(),
 		}
 
-		console.log('FIRING START STREAMING IN DIFFZONE!!!')
 		const diffZone = this._addDiffArea(adding)
 		this._onDidChangeStreamingInDiffZone.fire({ uri, diffareaid: diffZone.diffareaid })
 		this._onDidAddOrDeleteDiffZones.fire({ uri })
@@ -1257,6 +1284,10 @@ class EditCodeService extends Disposable implements IEditCodeService {
 	private _initializeWriteoverStream(opts: StartApplyingOpts): [DiffZone, Promise<void>] | undefined {
 
 		const { from, } = opts
+		const featureName: FeatureName = opts.from === 'ClickApply' ? 'Apply' : 'Ctrl+K'
+		const modelSelection = this._settingsService.state.modelSelectionOfFeature[featureName]
+		const modelSelectionOptions = modelSelection ? this._settingsService.state.optionsOfModelSelection[featureName][modelSelection.providerName]?.[modelSelection.modelName] : undefined
+
 
 		const uri = this._getURIBeforeStartApplying(opts)
 		if (!uri) return
@@ -1290,12 +1321,16 @@ class EditCodeService extends Disposable implements IEditCodeService {
 		const originalCode = startRange === 'fullFile' ? originalFileCode : originalFileCode.split('\n').slice((startRange[0] - 1), (startRange[1] - 1) + 1).join('\n')
 		const language = model.getLanguageId()
 		let messages: LLMChatMessage[]
+		let separateSystemMessage: string | undefined
 		if (from === 'ClickApply') {
-			const userContent = rewriteCode_userMessage({ originalCode, applyStr: opts.applyStr, language })
-			messages = [
-				{ role: 'system', content: rewriteCode_systemMessage, },
-				{ role: 'user', content: userContent, }
-			]
+			const { messages: a, separateSystemMessage: b } = this._convertToLLMMessageService.prepareLLMSimpleMessages({
+				systemMessage: rewriteCode_systemMessage,
+				simpleMessages: [{ role: 'user', content: rewriteCode_userMessage({ originalCode, applyStr: opts.applyStr, language }), }],
+				featureName,
+				modelSelection,
+			})
+			messages = a
+			separateSystemMessage = b
 		}
 		else if (from === 'QuickEdit') {
 			if (!ctrlKZoneIfQuickEdit) return
@@ -1305,12 +1340,17 @@ class EditCodeService extends Disposable implements IEditCodeService {
 			const startLine = startRange === 'fullFile' ? 1 : startRange[0]
 			const endLine = startRange === 'fullFile' ? model.getLineCount() : startRange[1]
 			const { prefix, suffix } = voidPrefixAndSuffix({ fullFileStr: originalFileCode, startLine, endLine })
-			const userContent = ctrlKStream_userMessage({ selection: originalCode, instructions: instructions, prefix, suffix, isOllamaFIM: false, fimTags: quickEditFIMTags, language })
-			// type: 'messages',
-			messages = [
-				{ role: 'system', content: ctrlKStream_systemMessage({ quickEditFIMTags: quickEditFIMTags }), },
-				{ role: 'user', content: userContent, }
-			]
+			const userContent = ctrlKStream_userMessage({ selection: originalCode, instructions: instructions, prefix, suffix, fimTags: quickEditFIMTags, language })
+
+			const { messages: a, separateSystemMessage: b } = this._convertToLLMMessageService.prepareLLMSimpleMessages({
+				systemMessage: ctrlKStream_systemMessage({ quickEditFIMTags: quickEditFIMTags }),
+				simpleMessages: [{ role: 'user', content: userContent, }],
+				featureName,
+				modelSelection,
+			})
+			messages = a
+			separateSystemMessage = b
+
 		}
 		else { throw new Error(`featureName ${from} is invalid`) }
 
@@ -1374,10 +1414,6 @@ class EditCodeService extends Disposable implements IEditCodeService {
 
 		const latestStreamLocationMutable: StreamLocationMutable = { line: diffZone.startLine, addedSplitYet: false, col: 1, originalCodeStartLine: 1 }
 
-		const featureName: FeatureName = opts.from === 'ClickApply' ? 'Apply' : 'Ctrl+K'
-		const modelSelection = this._settingsService.state.modelSelectionOfFeature[featureName]
-		const modelSelectionOptions = modelSelection ? this._settingsService.state.optionsOfModelSelection[featureName][modelSelection.providerName]?.[modelSelection.modelName] : undefined
-
 		// allowed to throw errors - this is called inside a promise that handles everything
 		const runWriteover = async () => {
 			let shouldSendAnotherMessage = true
@@ -1400,6 +1436,8 @@ class EditCodeService extends Disposable implements IEditCodeService {
 					messages,
 					modelSelection,
 					modelSelectionOptions,
+					separateSystemMessage,
+					chatMode: null, // not chat
 					onText: (params) => {
 						const { fullText: fullText_ } = params
 						const newText_ = fullText_.substring(fullTextSoFar.length, Infinity)
@@ -1474,6 +1512,9 @@ class EditCodeService extends Disposable implements IEditCodeService {
 
 	private _initializeSearchAndReplaceStream(opts: StartApplyingOpts & { from: 'ClickApply' }): [DiffZone, Promise<void>] | undefined {
 		const { from, applyStr, } = opts
+		const featureName: FeatureName = 'Apply'
+		const modelSelection = this._settingsService.state.modelSelectionOfFeature[featureName]
+		const modelSelectionOptions = modelSelection ? this._settingsService.state.optionsOfModelSelection[featureName][modelSelection.providerName]?.[modelSelection.modelName] : undefined
 
 		const uri = this._getURIBeforeStartApplying(opts)
 		if (!uri) return
@@ -1487,10 +1528,13 @@ class EditCodeService extends Disposable implements IEditCodeService {
 		// build messages - ask LLM to generate search/replace block text
 		const originalFileCode = model.getValue(EndOfLinePreference.LF)
 		const userMessageContent = searchReplace_userMessage({ originalCode: originalFileCode, applyStr: applyStr })
-		const messages: LLMChatMessage[] = [
-			{ role: 'system', content: searchReplace_systemMessage },
-			{ role: 'user', content: userMessageContent },
-		]
+
+		const { messages, separateSystemMessage: separateSystemMessage } = this._convertToLLMMessageService.prepareLLMSimpleMessages({
+			systemMessage: searchReplace_systemMessage,
+			simpleMessages: [{ role: 'user', content: userMessageContent, }],
+			featureName,
+			modelSelection,
+		})
 
 		// if URI is already streaming, return (should never happen, caller is responsible for checking)
 		if (this._uriIsStreaming(uri)) return
@@ -1534,20 +1578,22 @@ class EditCodeService extends Disposable implements IEditCodeService {
 		}
 
 
-		const errContentOfInvalidStr = (str: string & ReturnType<typeof findTextInCode>, blockOrig: string, blockNum: number, blocks: ExtractedSearchReplaceBlock[]) => {
+		const errContentOfInvalidStr = (str: 'Not found' | 'Not unique' | 'Has overlap', blockOrig: string) => {
 
 			const descStr = str === `Not found` ?
 				`The most recent ORIGINAL code could not be found in the file, so you were interrupted. The text in ORIGINAL must EXACTLY match lines of code. The problematic ORIGINAL code was:\n${JSON.stringify(blockOrig)}`
 				: str === `Not unique` ?
 					`The most recent ORIGINAL code shows up multiple times in the file, so you were interrupted. You might want to expand the ORIGINAL excerpt so it's unique. The problematic ORIGINAL code was:\n${JSON.stringify(blockOrig)}`
-					: ``
+					: str === 'Has overlap' ?
+						`The most recent ORIGINAL code has overlap with another ORIGINAL code block that you outputted. Do NOT output any overlapping edits. The problematic ORIGINAL code was:\n${JSON.stringify(blockOrig)}`
+						: ``
 
 			// string of <<<<< ORIGINAL >>>>> REPLACE blocks so far so LLM can understand what it currently has
 			// const blocksSoFarStr = blocks.slice(0, blockNum).map(block => `${ORIGINAL}\n${block.orig}\n${DIVIDER}\n${block.final}\n${FINAL}`).join('\n')
 			// const soFarStr = blocksSoFarStr ? `These are the Search/Replace blocks that have been applied so far:${tripleTick[0]}\n${blocksSoFarStr}\n${tripleTick[1]}` : ''
 			// const continueMsg = soFarStr ? `${soFarStr}Please continue outputting SEARCH/REPLACE blocks starting where this leaves off.` : ''
 			// const errMsg = `${descStr}${continueMsg ? `\n${continueMsg}` : ''}`
-			const soFarStr = 'All of your previous outputs have been ignored. Please re-output ALL SEARCH/REPLACE blocks starting from the first one, and avoid the error.'
+			const soFarStr = 'All of your previous outputs have been ignored. Please re-output ALL SEARCH/REPLACE blocks starting from the first one, and avoid the error this time.'
 			const errMsg = `${descStr}\n${soFarStr}`
 			return errMsg
 
@@ -1582,11 +1628,7 @@ class EditCodeService extends Disposable implements IEditCodeService {
 		const addedTrackingZoneOfBlockNum: TrackingZone<SearchReplaceDiffAreaMetadata>[] = []
 		diffZone._streamState.line = 1
 
-		const featureName: FeatureName = 'Apply'
-		const modelSelection = this._settingsService.state.modelSelectionOfFeature[featureName]
-		const modelSelectionOptions = modelSelection ? this._settingsService.state.optionsOfModelSelection[featureName][modelSelection.providerName]?.[modelSelection.modelName] : undefined
-
-		const N_RETRIES = 5
+		const N_RETRIES = 4
 
 		// allowed to throw errors - this is called inside a promise that handles everything
 		const runSearchReplace = async () => {
@@ -1617,6 +1659,8 @@ class EditCodeService extends Disposable implements IEditCodeService {
 					messages,
 					modelSelection,
 					modelSelectionOptions,
+					separateSystemMessage,
+					chatMode: null, // not chat
 					onText: (params) => {
 						const { fullText } = params
 						// blocks are [done done done ... {writingFinal|writingOriginal}]
@@ -1658,19 +1702,27 @@ class EditCodeService extends Disposable implements IEditCodeService {
 							// if this is the first time we're seeing this block, add it as a diffarea so we can start streaming in it
 							if (!(blockNum in addedTrackingZoneOfBlockNum)) {
 
-
 								const originalBounds = findTextInCode(block.orig, originalFileCode, true)
 								// if error
-								if (typeof originalBounds === 'string') {
+								// Check for overlap with existing modified ranges
+								const hasOverlap = addedTrackingZoneOfBlockNum.some(trackingZone => {
+									const [existingStart, existingEnd] = trackingZone.metadata.originalBounds;
+									const hasNoOverlap = endLine < existingStart || startLine > existingEnd
+									return !hasNoOverlap
+								});
+
+								if (typeof originalBounds === 'string' || hasOverlap) {
+									const errorMessage = typeof originalBounds === 'string' ? originalBounds : 'Has overlap' as const
+
 									console.log('--------------Error finding text in code:')
 									console.log('originalFileCode', { originalFileCode })
 									console.log('fullText', { fullText })
-									console.log('error:', originalBounds)
+									console.log('error:', errorMessage)
 									console.log('block.orig:', block.orig)
 									console.log('---------')
-									const content = errContentOfInvalidStr(originalBounds, block.orig, blockNum, blocks)
+									const content = errContentOfInvalidStr(errorMessage, block.orig)
 									messages.push(
-										{ role: 'assistant', content: fullText, anthropicReasoning: null }, // latest output
+										{ role: 'assistant', content: fullText }, // latest output
 										{ role: 'user', content: content } // user explanation of what's wrong
 									)
 
@@ -1876,6 +1928,8 @@ class EditCodeService extends Disposable implements IEditCodeService {
 
 
 	interruptURIStreaming({ uri }: { uri: URI }) {
+		if (!this._uriIsStreaming(uri)) return
+		this._undoHistory(uri)
 		// brute force for now is OK
 		for (const diffareaid of this.diffAreasOfURI[uri.fsPath] || []) {
 			const diffArea = this.diffAreaOfId[diffareaid]
@@ -1883,7 +1937,6 @@ class EditCodeService extends Disposable implements IEditCodeService {
 			if (!diffArea._streamState.isStreaming) continue
 			this._stopIfStreaming(diffArea)
 		}
-		this._undoHistory(uri)
 	}
 
 

src/vs/workbench/contrib/void/browser/media/void.css

@@ -3,7 +3,7 @@
  *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
  *--------------------------------------------------------------------------------------*/
 
- .monaco-editor .void-sweepIdxBG {
+.monaco-editor .void-sweepIdxBG {
 	background-color: var(--vscode-void-sweepIdxBG);
 }
 
@@ -23,10 +23,30 @@
 	background-color: var(--vscode-void-redBG);
 }
 
-.void-watermark-button {
-    margin: 8px 0;
+
+/* Renamed from void-watermark-button to void-openfolder-button */
+.void-openfolder-button {
     padding: 8px 20px;
-    background-color: #3b82f6;
+    background-color: #306dce;
+    color: white;
+    border: none;
+    border-radius: 4px;
+    outline: none !important;
+	box-shadow: none !important;
+	cursor: pointer;
+	transition: background-color 0.2s ease;
+}
+.void-openfolder-button:hover {
+    background-color: #2563eb;
+}
+.void-openfolder-button:active {
+    background-color: #2563eb;
+}
+
+/* Added for Open SSH button with slightly darker color */
+.void-openssh-button {
+    padding: 8px 20px;
+    background-color: #656565; /* Slightly darker than the #5a5a5a in the TS file */
     color: white;
     border: none;
     border-radius: 4px;
@@ -35,134 +55,150 @@
     cursor: pointer;
     transition: background-color 0.2s ease;
 }
-.void-watermark-button:hover {
-    background-color: #2563eb;
+.void-openssh-button:hover {
+    background-color: #474747; /* Darker on hover */
 }
-.void-watermark-button:active {
-    background-color: #2563eb;
+.void-openssh-button:active {
+    background-color: #474747;
 }
 
 
-
-
 .void-settings-watermark-button {
-    margin: 8px 0;
-    padding: 8px 20px;
-    background-color: var(--vscode-input-background);
+	margin: 8px 0;
+	padding: 8px 20px;
+	background-color: var(--vscode-input-background);
 	color: var(--vscode-input-foreground);
-    border: none;
-    border-radius: 4px;
-    outline: none !important;
+	border: none;
+	border-radius: 4px;
+	outline: none !important;
 	box-shadow: none !important;
-    cursor: pointer;
-    transition: all 0.2s ease;
+	cursor: pointer;
+	transition: all 0.2s ease;
 }
+
 .void-settings-watermark-button:hover {
 	filter: brightness(1.1);
 }
+
 .void-settings-watermark-button:active {
 	filter: brightness(1.1);
 }
 
-
-
-
 .void-link {
 	color: #3b82f6;
 	cursor: pointer;
 	transition: all 0.2s ease;
 }
+
 .void-link:hover {
 	opacity: 80%;
 }
 
+/* styles for all containers used by void */
+.void-scope {
+	--scrollbar-vertical-width: 8px;
+	--scrollbar-horizontal-height: 6px;
+}
 
+/* Target both void-scope and all its descendants with scrollbars */
+.void-scope,
+.void-scope * {
+	scrollbar-width: thin !important;
+	scrollbar-color: var(--void-bg-1) var(--void-bg-3) !important;
+	/* For Firefox */
+}
 
+.void-scope::-webkit-scrollbar,
+.void-scope *::-webkit-scrollbar {
+	width: var(--scrollbar-vertical-width) !important;
+	height: var(--scrollbar-horizontal-height) !important;
+	background-color: var(--void-bg-3) !important;
+}
 
+.void-scope::-webkit-scrollbar-thumb,
+.void-scope *::-webkit-scrollbar-thumb {
+	background-color: var(--void-bg-1) !important;
+	border-radius: 4px !important;
+	border: none !important;
+	-webkit-box-shadow: none !important;
+	box-shadow: none !important;
+}
+
+.void-scope::-webkit-scrollbar-thumb:hover,
+.void-scope *::-webkit-scrollbar-thumb:hover {
+	background-color: var(--void-bg-1) !important;
+	filter: brightness(1.1) !important;
+}
+
+.void-scope::-webkit-scrollbar-thumb:active,
+.void-scope *::-webkit-scrollbar-thumb:active {
+	background-color: var(--void-bg-1) !important;
+	filter: brightness(1.2) !important;
+}
+
+.void-scope::-webkit-scrollbar-track,
+.void-scope *::-webkit-scrollbar-track {
+	background-color: var(--void-bg-3) !important;
+	border: none !important;
+}
+
+.void-scope::-webkit-scrollbar-corner,
+.void-scope *::-webkit-scrollbar-corner {
+	background-color: var(--void-bg-3) !important;
+}
+
+/* Add void-scrollable-element styles to match */
+.void-scrollable-element {
+	background-color: var(--vscode-editor-background);
+	--scrollbar-vertical-width: 14px;
+	--scrollbar-horizontal-height: 6px;
+	overflow: auto;
+	/* Ensure scrollbars are shown when needed */
+}
+
+.void-scrollable-element,
+.void-scrollable-element * {
+	scrollbar-width: thin !important;
+	/* For Firefox */
+	scrollbar-color: var(--void-bg-1) var(--void-bg-3) !important;
+	/* For Firefox */
+}
 
 .void-scrollable-element::-webkit-scrollbar,
 .void-scrollable-element *::-webkit-scrollbar {
-    width: 14px !important;
-    height: 4px !important;
-}
-
-.void-scrollable-element::-webkit-scrollbar-track,
-.void-scrollable-element *::-webkit-scrollbar-track {
-    background: transparent !important;
+	width: var(--scrollbar-vertical-width) !important;
+	height: var(--scrollbar-horizontal-height) !important;
+	background-color: var(--void-bg-3) !important;
 }
 
 .void-scrollable-element::-webkit-scrollbar-thumb,
 .void-scrollable-element *::-webkit-scrollbar-thumb {
-    background-color: transparent !important;
-    border-radius: 0px !important;
+	background-color: var(--void-bg-1) !important;
+	border-radius: 4px !important;
+	border: none !important;
+	-webkit-box-shadow: none !important;
+	box-shadow: none !important;
 }
 
 .void-scrollable-element::-webkit-scrollbar-thumb:hover,
 .void-scrollable-element *::-webkit-scrollbar-thumb:hover {
-    background-color: var(--vscode-scrollbarSlider-hoverBackground) !important;
+	background-color: var(--void-bg-1) !important;
+	filter: brightness(1.1) !important;
 }
 
 .void-scrollable-element::-webkit-scrollbar-thumb:active,
 .void-scrollable-element *::-webkit-scrollbar-thumb:active {
-    background-color: var(--vscode-scrollbarSlider-activeBackground) !important;
+	background-color: var(--void-bg-1) !important;
+	filter: brightness(1.2) !important;
+}
+
+.void-scrollable-element::-webkit-scrollbar-track,
+.void-scrollable-element *::-webkit-scrollbar-track {
+	background-color: var(--void-bg-3) !important;
+	border: none !important;
 }
 
 .void-scrollable-element::-webkit-scrollbar-corner,
 .void-scrollable-element *::-webkit-scrollbar-corner {
-    background-color: transparent !important;
-}
-
-.void-scrollable-element.show-scrollbar-0::-webkit-scrollbar-thumb,
-.void-scrollable-element.show-scrollbar-0 *::-webkit-scrollbar-thumb {
-    background-color: color-mix(in srgb, var(--vscode-scrollbarSlider-background) 0%, transparent) !important;
-}
-
-.void-scrollable-element.show-scrollbar-1::-webkit-scrollbar-thumb,
-.void-scrollable-element.show-scrollbar-1 *::-webkit-scrollbar-thumb {
-    background-color: color-mix(in srgb, var(--vscode-scrollbarSlider-background) 10%, transparent) !important;
-}
-
-.void-scrollable-element.show-scrollbar-2::-webkit-scrollbar-thumb,
-.void-scrollable-element.show-scrollbar-2 *::-webkit-scrollbar-thumb {
-    background-color: color-mix(in srgb, var(--vscode-scrollbarSlider-background) 20%, transparent) !important;
-}
-
-.void-scrollable-element.show-scrollbar-3::-webkit-scrollbar-thumb,
-.void-scrollable-element.show-scrollbar-3 *::-webkit-scrollbar-thumb {
-    background-color: color-mix(in srgb, var(--vscode-scrollbarSlider-background) 30%, transparent) !important;
-}
-
-.void-scrollable-element.show-scrollbar-4::-webkit-scrollbar-thumb,
-.void-scrollable-element.show-scrollbar-4 *::-webkit-scrollbar-thumb {
-    background-color: color-mix(in srgb, var(--vscode-scrollbarSlider-background) 40%, transparent) !important;
-}
-
-.void-scrollable-element.show-scrollbar-5::-webkit-scrollbar-thumb,
-.void-scrollable-element.show-scrollbar-5 *::-webkit-scrollbar-thumb {
-    background-color: color-mix(in srgb, var(--vscode-scrollbarSlider-background) 50%, transparent) !important;
-}
-
-.void-scrollable-element.show-scrollbar-6::-webkit-scrollbar-thumb,
-.void-scrollable-element.show-scrollbar-6 *::-webkit-scrollbar-thumb {
-    background-color: color-mix(in srgb, var(--vscode-scrollbarSlider-background) 60%, transparent) !important;
-}
-
-.void-scrollable-element.show-scrollbar-7::-webkit-scrollbar-thumb,
-.void-scrollable-element.show-scrollbar-7 *::-webkit-scrollbar-thumb {
-    background-color: color-mix(in srgb, var(--vscode-scrollbarSlider-background) 70%, transparent) !important;
-}
-
-.void-scrollable-element.show-scrollbar-8::-webkit-scrollbar-thumb,
-.void-scrollable-element.show-scrollbar-8 *::-webkit-scrollbar-thumb {
-    background-color: color-mix(in srgb, var(--vscode-scrollbarSlider-background) 80%, transparent) !important;
-}
-
-.void-scrollable-element.show-scrollbar-9::-webkit-scrollbar-thumb,
-.void-scrollable-element.show-scrollbar-9 *::-webkit-scrollbar-thumb {
-    background-color: color-mix(in srgb, var(--vscode-scrollbarSlider-background) 90%, transparent) !important;
-}
-
-.void-scrollable-element.show-scrollbar-10::-webkit-scrollbar-thumb,
-.void-scrollable-element.show-scrollbar-10 *::-webkit-scrollbar-thumb {
-    background-color: var(--vscode-scrollbarSlider-background) !important;
+	background-color: var(--void-bg-3) !important;
 }

src/vs/workbench/contrib/void/browser/react/build.js

@@ -74,7 +74,7 @@ function saveStylesFile() {
 		} catch (err) {
 			console.error('[scope-tailwind] Error saving styles.css:', err);
 		}
-	}, 4000);
+	}, 6000);
 }
 
 const args = process.argv.slice(2);

src/vs/workbench/contrib/void/browser/react/src/markdown/ApplyBlockHoverButtons.tsx

@@ -11,6 +11,7 @@ import { URI } from '../../../../../../../base/common/uri.js'
 import { FileSymlink, LucideIcon, RotateCw, Terminal } from 'lucide-react'
 import { Check, X, Square, Copy, Play, } from 'lucide-react'
 import { getBasename, ListableToolItem, ToolChildrenWrapper } from '../sidebar-tsx/SidebarChat.js'
+import { PlacesType, VariantType } from 'react-tooltip'
 
 enum CopyButtonText {
 	Idle = 'Copy',
@@ -20,30 +21,28 @@ enum CopyButtonText {
 
 
 type IconButtonProps = {
-	onClick: () => void;
 	Icon: LucideIcon
-	disabled?: boolean
-	className?: string
 }
 
-export const IconShell1 = ({ onClick, Icon, disabled, className }: IconButtonProps) => (
+export const IconShell1 = ({ onClick, Icon, disabled, className, ...props }: IconButtonProps & React.ButtonHTMLAttributes<HTMLButtonElement>) => (
 	<button
 		disabled={disabled}
 		onClick={(e) => {
 			e.preventDefault();
 			e.stopPropagation();
-			onClick?.();
+			onClick?.(e);
 		}}
+		// border border-void-border-1 rounded
 		className={`
-            size-[22px]
-			p-[4px]
+            size-[18px]
+			p-[2px]
             flex items-center justify-center
-            text-sm bg-void-bg-3 text-void-fg-1
+            text-sm bg-void-bg-3 text-void-fg-3
             hover:brightness-110
-            border border-void-border-1 rounded
             disabled:opacity-50 disabled:cursor-not-allowed
 			${className}
         `}
+		{...props}
 	>
 		<Icon />
 	</button>
@@ -94,13 +93,14 @@ export const CopyButton = ({ codeStr }: { codeStr: string }) => {
 	return <IconShell1
 		Icon={copyButtonText === CopyButtonText.Copied ? Check : copyButtonText === CopyButtonText.Error ? X : Copy}
 		onClick={onCopy}
+		{...tooltipPropsForApplyBlock({ tooltipName: 'Copy' })}
 	/>
 }
 
 
 
 
-export const JumpToFileButton = ({ uri }: { uri: URI | 'current' }) => {
+export const JumpToFileButton = ({ uri, ...props }: { uri: URI | 'current' } & React.ButtonHTMLAttributes<HTMLButtonElement>) => {
 	const accessor = useAccessor()
 	const commandService = accessor.get('ICommandService')
 
@@ -110,6 +110,8 @@ export const JumpToFileButton = ({ uri }: { uri: URI | 'current' }) => {
 			onClick={() => {
 				commandService.executeCommand('vscode.open', uri, { preview: true })
 			}}
+			{...tooltipPropsForApplyBlock({ tooltipName: 'Go to file' })}
+			{...props}
 		/>
 	)
 	return jumpToFileButton
@@ -122,7 +124,6 @@ export const JumpToTerminalButton = ({ onClick }: { onClick: () => void }) => {
 		<IconShell1
 			Icon={Terminal}
 			onClick={onClick}
-			className="text-void-fg-1"
 		/>
 	)
 }
@@ -161,12 +162,12 @@ export const useApplyButtonState = ({ applyBoxId, uri }: { applyBoxId: string, u
 		)
 		if (shouldUpdate) {
 			rerender(c => c + 1)
-			console.log('rerendering....')
 		}
-	}, [applyBoxId, applyBoxId, uri]))
+	}, [applyBoxId, uri]))
 
 	const currStreamState = getStreamState()
 
+
 	return {
 		getStreamState,
 		isDisabled,
@@ -175,22 +176,61 @@ export const useApplyButtonState = ({ applyBoxId, uri }: { applyBoxId: string, u
 }
 
 
-export const StatusIndicatorHTML = ({ applyBoxId, uri }: { applyBoxId: string, uri: URI | 'current' }) => {
+type IndicatorColor = 'green' | 'orange' | 'dark' | 'yellow' | null
+export const StatusIndicator = ({ indicatorColor, title, className, ...props }: { indicatorColor: IndicatorColor, title?: React.ReactNode, className?: string } & React.HTMLAttributes<HTMLDivElement>) => {
+	return (
+		<div className={`flex flex-row text-void-fg-3 text-xs items-center gap-1.5 ${className}`} {...props}>
+			{title && <span className='opacity-80'>{title}</span>}
+			<div
+				className={` size-1.5 rounded-full border
+					${indicatorColor === 'dark' ? 'bg-void-bg-3 border-void-border-1' :
+						indicatorColor === 'orange' ? 'bg-orange-500 border-orange-500 shadow-[0_0_4px_0px_rgba(234,88,12,0.6)]' :
+							indicatorColor === 'green' ? 'bg-green-500 border-green-500 shadow-[0_0_4px_0px_rgba(22,163,74,0.6)]' :
+								indicatorColor === 'yellow' ? 'bg-yellow-500 border-yellow-500 shadow-[0_0_4px_0px_rgba(22,163,74,0.6)]' :
+									'bg-void-border-1 border-void-border-1'
+					}
+				`}
+			/>
+		</div>
+	);
+};
+
+const tooltipPropsForApplyBlock = ({ tooltipName, color = undefined, position = 'top', offset = undefined }: { tooltipName: string, color?: IndicatorColor, position?: PlacesType, offset?: number }) => ({
+	'data-tooltip-id': color === 'orange' ? `void-tooltip-orange` : color === 'green' ? 'void-tooltip-green' : 'void-tooltip',
+	'data-tooltip-place': position as PlacesType,
+	'data-tooltip-content': `${tooltipName}`,
+	'data-tooltip-offset': offset,
+})
+
+
+export const StatusIndicatorForApplyButton = ({ applyBoxId, uri }: { applyBoxId: string, uri: URI | 'current' } & React.HTMLAttributes<HTMLDivElement>) => {
+
 	const { currStreamState } = useApplyButtonState({ applyBoxId, uri })
 
-	return <div className='flex flex-row items-center min-h-4 max-h-4 min-w-4 max-w-4'>
-		<div
-			className={` size-1.5 rounded-full border
-		 ${currStreamState === 'idle-no-changes' ? 'bg-void-bg-3 border-void-border-1' :
-					currStreamState === 'streaming' ? 'bg-orange-500 border-orange-500 shadow-[0_0_4px_0px_rgba(234,88,12,0.6)]' :
-						currStreamState === 'idle-has-changes' ? 'bg-green-500 border-green-500 shadow-[0_0_4px_0px_rgba(22,163,74,0.6)]' :
-							'bg-void-border-1 border-void-border-1'
-				}`
-			}
-		/>
-	</div>
+	const color = (
+		currStreamState === 'idle-no-changes' ? 'dark' :
+			currStreamState === 'streaming' ? 'orange' :
+				currStreamState === 'idle-has-changes' ? 'green' :
+					null
+	)
+
+	const tooltipName = (
+		currStreamState === 'idle-no-changes' ? 'Done' :
+			currStreamState === 'streaming' ? 'Applying' :
+				currStreamState === 'idle-has-changes' ? 'Done' : // also 'Done'? 'Applied' looked bad
+					''
+	)
+
+	const statusIndicatorHTML = <StatusIndicator
+		key={currStreamState}
+		className='mx-2'
+		indicatorColor={color}
+		{...tooltipPropsForApplyBlock({ tooltipName, color, position: 'top', offset: 12 })}
+	/>
+	return statusIndicatorHTML
 }
 
+
 export const ApplyButtonsHTML = ({ codeStr, applyBoxId, reapplyIcon, uri }: { codeStr: string, applyBoxId: string, reapplyIcon: boolean, uri: URI | 'current' }) => {
 	const accessor = useAccessor()
 	const editCodeService = accessor.get('IEditCodeService')
@@ -216,7 +256,10 @@ export const ApplyButtonsHTML = ({ codeStr, applyBoxId, reapplyIcon, uri }: { co
 		const [newApplyingUri, applyDonePromise] = editCodeService.startApplying(opts) ?? []
 
 		// catch any errors by interrupting the stream
-		applyDonePromise?.catch(e => { if (newApplyingUri) editCodeService.interruptURIStreaming({ uri: newApplyingUri }) })
+		applyDonePromise?.catch(e => {
+			const uri = getUriBeingApplied(applyBoxId)
+			if (uri) editCodeService.interruptURIStreaming({ uri: uri })
+		})
 
 		applyingURIOfApplyBoxIdRef.current[applyBoxId] = newApplyingUri ?? undefined
 
@@ -251,11 +294,22 @@ export const ApplyButtonsHTML = ({ codeStr, applyBoxId, reapplyIcon, uri }: { co
 
 
 	if (currStreamState === 'streaming') {
-		return <IconShell1 Icon={Square} onClick={onInterrupt} />
+		return <IconShell1
+
+			Icon={Square}
+			onClick={onInterrupt}
+
+			{...tooltipPropsForApplyBlock({ tooltipName: 'Stop' })}
+		/>
 	}
 
 	if (currStreamState === 'idle-no-changes') {
-		return <IconShell1 Icon={reapplyIcon ? RotateCw : Play} onClick={onClickSubmit} />
+
+		return <IconShell1
+			Icon={reapplyIcon ? RotateCw : Play}
+			onClick={onClickSubmit}
+			{...tooltipPropsForApplyBlock({ tooltipName: reapplyIcon ? 'Reapply' : 'Apply' })}
+		/>
 	}
 
 	if (currStreamState === 'idle-has-changes') {
@@ -267,19 +321,18 @@ export const ApplyButtonsHTML = ({ codeStr, applyBoxId, reapplyIcon, uri }: { co
 			<IconShell1
 				Icon={X}
 				onClick={onReject}
-				className="text-red-600"
+				{...tooltipPropsForApplyBlock({ tooltipName: 'Remove' })}
 			/>
 			<IconShell1
 				Icon={Check}
 				onClick={onAccept}
-				className="text-green-600"
+				{...tooltipPropsForApplyBlock({ tooltipName: 'Keep' })}
 			/>
 		</>
 	}
 
 }
 
-
 export const BlockCodeApplyWrapper = ({
 	children,
 	initValue,
@@ -314,7 +367,7 @@ export const BlockCodeApplyWrapper = ({
 		{/* header */}
 		<div className=" select-none flex justify-between items-center py-1 px-2 border-b border-void-border-3 cursor-default">
 			<div className="flex items-center">
-				<StatusIndicatorHTML uri={uri} applyBoxId={applyBoxId} />
+				<StatusIndicatorForApplyButton uri={uri} applyBoxId={applyBoxId} />
 				<span className="text-[13px] font-light text-void-fg-3">
 					{name}
 				</span>

src/vs/workbench/contrib/void/browser/react/src/markdown/ChatMarkdownRender.tsx

@@ -57,7 +57,7 @@ const CodespanWithLink = ({ text, rawText, chatMessageLocation }: { text: string
 	const [didComputeCodespanLink, setDidComputeCodespanLink] = useState<boolean>(false)
 
 	let link = undefined
-	if (rawText.endsWith("`")) { // if codespan was completed
+	if (rawText.endsWith('`')) { // if codespan was completed
 
 		// get link from cache
 		link = chatThreadService.getCodespanLink({ codespanStr: text, messageIdx, threadId })
@@ -120,11 +120,11 @@ const RenderToken = ({ token, inPTag, codeURI, chatMessageLocation, tokenIdx, ..
 		return null;
 	}
 
-	if (t.type === "space") {
+	if (t.type === 'space') {
 		return <span>{t.raw}</span>
 	}
 
-	if (t.type === "code") {
+	if (t.type === 'code') {
 		const [firstLine, remainingContents] = separateOutFirstLine(t.text)
 		const firstLineIsURI = isValidUri(firstLine) && !codeURI
 		const contents = firstLineIsURI ? (remainingContents?.trimStart() || '') : t.text // exclude first-line URI from contents
@@ -152,7 +152,7 @@ const RenderToken = ({ token, inPTag, codeURI, chatMessageLocation, tokenIdx, ..
 		}
 
 		if (options.isApplyEnabled && chatMessageLocation) {
-			const isCodeblockClosed = t.raw.trimEnd().endsWith('```') // user should only be able to Apply when the code has been closed (t.raw ends with "```")
+			const isCodeblockClosed = t.raw.trimEnd().endsWith('```') // user should only be able to Apply when the code has been closed (t.raw ends with '```')
 
 			const applyBoxId = getApplyBoxId({
 				threadId: chatMessageLocation.threadId,
@@ -179,7 +179,7 @@ const RenderToken = ({ token, inPTag, codeURI, chatMessageLocation, tokenIdx, ..
 		/>
 	}
 
-	if (t.type === "heading") {
+	if (t.type === 'heading') {
 
 		const HeadingTag = `h${t.depth}` as keyof JSX.IntrinsicElements
 
@@ -188,7 +188,7 @@ const RenderToken = ({ token, inPTag, codeURI, chatMessageLocation, tokenIdx, ..
 		</HeadingTag>
 	}
 
-	if (t.type === "table") {
+	if (t.type === 'table') {
 		return (
 			<div>
 				<table>
@@ -217,14 +217,14 @@ const RenderToken = ({ token, inPTag, codeURI, chatMessageLocation, tokenIdx, ..
 		)
 		// return (
 		// 	<div>
-		// 		<table className={"min-w-full border border-void-bg-2"}>
+		// 		<table className={'min-w-full border border-void-bg-2'}>
 		// 			<thead>
-		// 				<tr className="bg-void-bg-1">
+		// 				<tr className='bg-void-bg-1'>
 		// 					{t.header.map((cell: any, index: number) => (
 		// 						<th
 		// 							key={index}
-		// 							className="px-4 py-2 border border-void-bg-2 font-semibold"
-		// 							style={{ textAlign: t.align[index] || "left" }}
+		// 							className='px-4 py-2 border border-void-bg-2 font-semibold'
+		// 							style={{ textAlign: t.align[index] || 'left' }}
 		// 						>
 		// 							{cell.raw}
 		// 						</th>
@@ -237,8 +237,8 @@ const RenderToken = ({ token, inPTag, codeURI, chatMessageLocation, tokenIdx, ..
 		// 						{row.map((cell: any, cellIndex: number) => (
 		// 							<td
 		// 								key={cellIndex}
-		// 								className={"px-4 py-2 border border-void-bg-2"}
-		// 								style={{ textAlign: t.align[cellIndex] || "left" }}
+		// 								className={'px-4 py-2 border border-void-bg-2'}
+		// 								style={{ textAlign: t.align[cellIndex] || 'left' }}
 		// 							>
 		// 								{cell.raw}
 		// 							</td>
@@ -251,32 +251,32 @@ const RenderToken = ({ token, inPTag, codeURI, chatMessageLocation, tokenIdx, ..
 		// )
 	}
 
-	if (t.type === "hr") {
+	if (t.type === 'hr') {
 		return <hr />
 	}
 
-	if (t.type === "blockquote") {
+	if (t.type === 'blockquote') {
 		return <blockquote>{t.text}</blockquote>
 	}
 
 	if (t.type === 'list_item') {
 		return <li>
-			<input type="checkbox" checked={t.checked} readOnly />
+			<input type='checkbox' checked={t.checked} readOnly />
 			<span>
 				<ChatMarkdownRender chatMessageLocation={chatMessageLocation} string={t.text} inPTag={true} codeURI={codeURI} {...options} />
 			</span>
 		</li>
 	}
 
-	if (t.type === "list") {
-		const ListTag = t.ordered ? "ol" : "ul"
+	if (t.type === 'list') {
+		const ListTag = t.ordered ? 'ol' : 'ul'
 
 		return (
 			<ListTag start={t.start ? t.start : undefined}>
 				{t.items.map((item, index) => (
 					<li key={index}>
 						{item.task && (
-							<input type="checkbox" checked={item.checked} readOnly />
+							<input type='checkbox' checked={item.checked} readOnly />
 						)}
 						<span>
 							<ChatMarkdownRender chatMessageLocation={chatMessageLocation} string={item.text} inPTag={true} {...options} />
@@ -287,7 +287,7 @@ const RenderToken = ({ token, inPTag, codeURI, chatMessageLocation, tokenIdx, ..
 		)
 	}
 
-	if (t.type === "paragraph") {
+	if (t.type === 'paragraph') {
 		const contents = <>
 			{t.tokens.map((token, index) => (
 				<RenderToken key={index}
@@ -304,34 +304,28 @@ const RenderToken = ({ token, inPTag, codeURI, chatMessageLocation, tokenIdx, ..
 		return <p>{contents}</p>
 	}
 
-	if (t.type === "html") {
-		const contents = t.raw
-		if (inPTag) return <span className='block'>{contents}</span>
-		return <p>{contents}</p>
-	}
-
-	if (t.type === "text" || t.type === "escape") {
+	if (t.type === 'text' || t.type === 'escape' || t.type === 'html') {
 		return <span>{t.raw}</span>
 	}
 
-	if (t.type === "def") {
+	if (t.type === 'def') {
 		return <></> // Definitions are typically not rendered
 	}
 
-	if (t.type === "link") {
+	if (t.type === 'link') {
 		return (
 			<a
 				onClick={() => { window.open(t.href) }}
 				href={t.href}
 				title={t.title ?? undefined}
-				className='underline cursor-pointer hover:brightness-90 transition-all duration-200'
+				className='underline cursor-pointer hover:brightness-90 transition-all duration-200 text-void-fg-2'
 			>
 				{t.text}
 			</a>
 		)
 	}
 
-	if (t.type === "image") {
+	if (t.type === 'image') {
 		return <img
 			src={t.href}
 			alt={t.text}
@@ -340,16 +334,16 @@ const RenderToken = ({ token, inPTag, codeURI, chatMessageLocation, tokenIdx, ..
 		/>
 	}
 
-	if (t.type === "strong") {
+	if (t.type === 'strong') {
 		return <strong>{t.text}</strong>
 	}
 
-	if (t.type === "em") {
+	if (t.type === 'em') {
 		return <em>{t.text}</em>
 	}
 
 	// inline code
-	if (t.type === "codespan") {
+	if (t.type === 'codespan') {
 
 		if (options.isLinkDetectionEnabled && chatMessageLocation) {
 			return <CodespanWithLink
@@ -363,18 +357,18 @@ const RenderToken = ({ token, inPTag, codeURI, chatMessageLocation, tokenIdx, ..
 		return <Codespan text={t.text} />
 	}
 
-	if (t.type === "br") {
+	if (t.type === 'br') {
 		return <br />
 	}
 
 	// strikethrough
-	if (t.type === "del") {
+	if (t.type === 'del') {
 		return <del>{t.text}</del>
 	}
 	// default
 	return (
-		<div className="bg-orange-50 rounded-sm overflow-hidden p-2">
-			<span className="text-sm text-orange-500">Unknown token rendered...</span>
+		<div className='bg-orange-50 rounded-sm overflow-hidden p-2'>
+			<span className='text-sm text-orange-500'>Unknown token rendered...</span>
 		</div>
 	)
 }

src/vs/workbench/contrib/void/browser/react/src/quick-edit-tsx/QuickEditChat.tsx

@@ -10,7 +10,6 @@ import { QuickEditPropsType } from '../../../quickEditActions.js';
 import { ButtonStop, ButtonSubmit, IconX, VoidChatArea } from '../sidebar-tsx/SidebarChat.js';
 import { VOID_CTRL_K_ACTION_ID } from '../../../actionIDs.js';
 import { useRefState } from '../util/helpers.js';
-import { useScrollbarStyles } from '../util/useScrollbarStyles.js';
 import { isFeatureNameDisabled } from '../../../../../../../workbench/contrib/void/common/voidSettingsTypes.js';
 
 export const QuickEditChat = ({
@@ -89,8 +88,6 @@ export const QuickEditChat = ({
 		editCodeService.removeCtrlKZone({ diffareaid })
 	}, [editCodeService, diffareaid])
 
-	useScrollbarStyles(sizerRef)
-
 	const keybindingString = accessor.get('IKeybindingService').lookupKeybinding(VOID_CTRL_K_ACTION_ID)?.getLabel()
 
 	const chatAreaRef = useRef<HTMLDivElement | null>(null)

src/vs/workbench/contrib/void/browser/react/src/sidebar-tsx/ErrorBoundary.tsx

@@ -5,6 +5,7 @@
 
 import React, { Component, ErrorInfo, ReactNode } from 'react';
 import { ErrorDisplay } from './ErrorDisplay.js';
+import { WarningBox } from '../void-settings-tsx/WarningBox.js';
 
 interface Props {
 	children: ReactNode;
@@ -51,11 +52,12 @@ class ErrorBoundary extends Component<Props, State> {
 
 			// Use ErrorDisplay component as the default error UI
 			return (
-				<ErrorDisplay
-					message={this.state.error + ''}
-					fullError={this.state.error}
-					onDismiss={this.props.onDismiss || null}
-				/>
+				<WarningBox text={this.state.error + ''} />
+				// <ErrorDisplay
+				// 	message={this.state.error + ''}
+				// 	fullError={this.state.error}
+				// 	onDismiss={this.props.onDismiss || null}
+				// />
 			);
 		}
 

src/vs/workbench/contrib/void/browser/react/src/sidebar-tsx/SidebarThreadSelector.tsx

@@ -90,7 +90,7 @@ export const SidebarThreadSelector = () => {
 							// 	secondMsg = truncate(pastThread.messages[secondMsgIdx].displayContent ?? '');
 							// }
 
-							const numMessages = pastThread.messages.filter((msg) => msg.role !== 'tool_request').length;
+							const numMessages = pastThread.messages.filter((msg) => msg.role === 'assistant' || msg.role === 'user').length;
 
 							return (
 								<li key={pastThread.id}>

src/vs/workbench/contrib/void/browser/react/src/styles.css

@@ -11,7 +11,7 @@
 	--void-bg-1: var(--vscode-input-background);
 	--void-bg-1-alt: var(--vscode-badge-background);
 	--void-bg-2: var(--vscode-sideBar-background);
-	--void-bg-2-alt: color-mix(in srgb, var(--vscode-sideBar-background) 30%, var(--vscode-editor-background) 70%);
+	--void-bg-2-alt: color-mix(in srgb, var(--vscode-editor-background) 30%, var(--vscode-sideBar-background) 70%);
 	--void-bg-3: var(--vscode-editor-background);
 
 	--void-fg-0: color-mix(in srgb, var(--vscode-tab-activeForeground) 90%, black 10%);

src/vs/workbench/contrib/void/browser/react/src/util/inputs.tsx

@@ -106,6 +106,7 @@ export const VoidInputBox2 = forwardRef<HTMLTextAreaElement, InputBox2Props>(fun
 
 	return (
 		<textarea
+			autoFocus={false}
 			ref={useCallback((r: HTMLTextAreaElement | null) => {
 				if (fnsRef)
 					fnsRef.current = fns
@@ -153,12 +154,13 @@ export const VoidInputBox2 = forwardRef<HTMLTextAreaElement, InputBox2Props>(fun
 })
 
 
-export const VoidSimpleInputBox = ({ value, onChangeValue, placeholder, className, disabled, passwordBlur, ...inputProps }: {
+export const VoidSimpleInputBox = ({ value, onChangeValue, placeholder, className, disabled, passwordBlur, compact, ...inputProps }: {
 	value: string;
 	onChangeValue: (value: string) => void;
 	placeholder: string;
 	className?: string;
 	disabled?: boolean;
+	compact?: boolean;
 	passwordBlur?: boolean;
 } & React.InputHTMLAttributes<HTMLInputElement>) => {
 
@@ -168,7 +170,11 @@ export const VoidSimpleInputBox = ({ value, onChangeValue, placeholder, classNam
 			onChange={(e) => onChangeValue(e.target.value)}
 			placeholder={placeholder}
 			disabled={disabled}
-			className={`w-full resize-none text-void-fg-1 placeholder:text-void-fg-3 px-2 py-1 rounded-sm
+			// className='max-w-44 w-full border border-void-border-2 bg-void-bg-1 text-void-fg-3 text-root'
+			// className={`w-full resize-none text-void-fg-1 placeholder:text-void-fg-3 px-2 py-1 rounded-sm
+			className={`w-full resize-none bg-void-bg-1 text-void-fg-1 placeholder:text-void-fg-3 border border-void-border-2 focus:border-void-border-1
+				${compact ? 'py-1 px-2' : 'py-2 px-4 '}
+				rounded
 				${disabled ? 'opacity-50 cursor-not-allowed' : ''}
 				${className}`}
 			style={{
@@ -412,6 +418,7 @@ export const VoidSwitch = ({
 	onChange,
 	size = 'md',
 	disabled = false,
+	...props
 }: {
 	value: boolean;
 	onChange: (value: boolean) => void;
@@ -419,7 +426,7 @@ export const VoidSwitch = ({
 	size?: 'xxs' | 'xs' | 'sm' | 'sm+' | 'md';
 }) => {
 	return (
-		<label className="inline-flex items-center">
+		<label className="inline-flex items-center" {...props}>
 			<div
 				onClick={() => !disabled && onChange(!value)}
 				className={`
@@ -635,7 +642,7 @@ export const VoidCustomDropdownBox = <T extends NonNullable<any>>({
 				className="flex items-center h-4 bg-transparent whitespace-nowrap hover:brightness-90 w-full"
 				onClick={() => setIsOpen(!isOpen)}
 			>
-				<span className={`max-w-[120px] truncate ${arrowTouchesText ? 'mr-1' : ''}`}>
+				<span className={`truncate ${arrowTouchesText ? 'mr-1' : ''}`}>
 					{getOptionDisplayName(selectedOption)}
 				</span>
 				<svg
@@ -657,57 +664,60 @@ export const VoidCustomDropdownBox = <T extends NonNullable<any>>({
 			{isOpen && (
 				<div
 					ref={refs.setFloating}
-					className="z-10 bg-void-bg-1 border-void-border-1 border overflow-hidden rounded shadow-lg"
+					className="z-10 bg-void-bg-1 border-void-border-3 border rounded shadow-lg"
 					style={{
 						position: strategy,
 						top: y ?? 0,
 						left: x ?? 0,
-						width: matchInputWidth
+						width: (matchInputWidth
 							? (refs.reference.current instanceof HTMLElement ? refs.reference.current.offsetWidth : 0)
 							: Math.max(
 								(refs.reference.current instanceof HTMLElement ? refs.reference.current.offsetWidth : 0),
 								(measureRef.current instanceof HTMLElement ? measureRef.current.offsetWidth : 0)
-							),
+							))
 					}}
-				>
-					{options.map((option) => {
-						const thisOptionIsSelected = getOptionsEqual(option, selectedOption);
-						const optionName = getOptionDropdownName(option);
-						const optionDetail = getOptionDropdownDetail?.(option) || '';
+					onWheel={(e) => e.stopPropagation()}
+				><div className='overflow-auto max-h-80'>
 
-						return (
-							<div
-								key={optionName}
-								className={`flex items-center px-2 py-1 cursor-pointer whitespace-nowrap
+						{options.map((option) => {
+							const thisOptionIsSelected = getOptionsEqual(option, selectedOption);
+							const optionName = getOptionDropdownName(option);
+							const optionDetail = getOptionDropdownDetail?.(option) || '';
+
+							return (
+								<div
+									key={optionName}
+									className={`flex items-center px-2 py-1 pr-4 cursor-pointer whitespace-nowrap
 									transition-all duration-100
-									bg-void-bg-1
-									${thisOptionIsSelected ? 'bg-void-bg-2' : 'hover:bg-void-bg-2'}
+									${thisOptionIsSelected ? 'bg-void-bg-2' : 'bg-void-bg-2-alt hover:bg-void-bg-2'}
 								`}
-								onClick={() => {
-									onChangeOption(option);
-									setIsOpen(false);
-								}}
-							>
-								<div className="w-4 flex justify-center flex-shrink-0">
-									{thisOptionIsSelected && (
-										<svg className="size-3" viewBox="0 0 12 12" fill="none">
-											<path
-												d="M10 3L4.5 8.5L2 6"
-												stroke="currentColor"
-												strokeWidth="1.5"
-												strokeLinecap="round"
-												strokeLinejoin="round"
-											/>
-										</svg>
-									)}
+									onClick={() => {
+										onChangeOption(option);
+										setIsOpen(false);
+									}}
+								>
+									<div className="w-4 flex justify-center flex-shrink-0">
+										{thisOptionIsSelected && (
+											<svg className="size-3" viewBox="0 0 12 12" fill="none">
+												<path
+													d="M10 3L4.5 8.5L2 6"
+													stroke="currentColor"
+													strokeWidth="1.5"
+													strokeLinecap="round"
+													strokeLinejoin="round"
+												/>
+											</svg>
+										)}
+									</div>
+									<span className="flex justify-between w-full">
+										<span>{optionName}</span>
+										<span className='text-void-fg-4 opacity-60'>{optionDetail}</span>
+									</span>
 								</div>
-								<span className="flex justify-between w-full">
-									<span>{optionName}</span>
-									<span className='text-void-fg-4 opacity-60'>{optionDetail}</span>
-								</span>
-							</div>
-						);
-					})}
+							);
+						})}
+					</div>
+
 				</div>
 			)}
 		</div>
@@ -954,9 +964,9 @@ export const BlockCode = ({ initValue, language, maxHeight, showScrollbars }: Bl
 }
 
 
-export const VoidButton = ({ children, disabled, onClick }: { children: React.ReactNode; disabled?: boolean; onClick: () => void }) => {
+export const VoidButtonBgDarken = ({ children, disabled, onClick, className }: { children: React.ReactNode; disabled?: boolean; onClick: () => void; className?: string }) => {
 	return <button disabled={disabled}
-		className='px-3 py-1 bg-black/10 dark:bg-white/10 rounded-sm overflow-hidden whitespace-nowrap'
+		className={`px-3 py-1 bg-black/10 dark:bg-white/10 rounded-sm overflow-hidden whitespace-nowrap flex items-center justify-center ${className || ''}`}
 		onClick={onClick}
 	>{children}</button>
 }

src/vs/workbench/contrib/void/browser/react/src/util/services.tsx

@@ -47,6 +47,7 @@ import { IWorkspaceContextService } from '../../../../../../../platform/workspac
 import { IVoidCommandBarService } from '../../../voidCommandBarService.js'
 import { INativeHostService } from '../../../../../../../platform/native/common/native.js';
 import { IEditCodeService } from '../../../editCodeServiceInterface.js'
+import { IToolsService } from '../../../toolsService.js'
 
 
 // normally to do this you'd use a useEffect that calls .onDidChangeState(), but useEffect mounts too late and misses initial state changes
@@ -215,6 +216,7 @@ const getReactAccessor = (accessor: ServicesAccessor) => {
 
 		IVoidCommandBarService: accessor.get(IVoidCommandBarService),
 		INativeHostService: accessor.get(INativeHostService),
+		IToolsService: accessor.get(IToolsService),
 
 	} as const
 	return reactAccessor
@@ -350,9 +352,9 @@ export const useCommandBarURIListener = (listener: (uri: URI) => void) => {
 export const useCommandBarState = () => {
 	const accessor = useAccessor()
 	const commandBarService = accessor.get('IVoidCommandBarService')
-	const [s, ss] = useState({ state: commandBarService.stateOfURI, sortedURIs: commandBarService.sortedURIs });
+	const [s, ss] = useState({ stateOfURI: commandBarService.stateOfURI, sortedURIs: commandBarService.sortedURIs });
 	const listener = useCallback(() => {
-		ss({ state: commandBarService.stateOfURI, sortedURIs: commandBarService.sortedURIs });
+		ss({ stateOfURI: commandBarService.stateOfURI, sortedURIs: commandBarService.sortedURIs });
 	}, [commandBarService])
 	useCommandBarURIListener(listener)
 

src/vs/workbench/contrib/void/browser/react/src/util/useScrollbarStyles.tsx

@@ -1,128 +1,130 @@
-import { useEffect } from 'react';
+// Get rid of this as it was causing lag
 
-export const useScrollbarStyles = (containerRef: React.MutableRefObject<HTMLDivElement | null>) => {
-	useEffect(() => {
-		if (!containerRef.current) return;
+// import { useEffect } from 'react';
 
-		// Create selector for specific overflow classes
-		const overflowSelector = [
-			'[class*="overflow-auto"]',
-			'[class*="overflow-x-auto"]',
-			'[class*="overflow-y-auto"]'
-		].join(',');
+// export const useScrollbarStyles = (containerRef: React.RefObject<HTMLDivElement | null>) => {
+// 	useEffect(() => {
+// 		if (!containerRef.current) return;
 
-		// Function to initialize scrollbar styles for elements
-		const initializeScrollbarStyles = () => {
-			// Get all matching elements within the container, including the container itself
-			const scrollElements = [
-				...(containerRef.current?.matches(overflowSelector) ? [containerRef.current] : []),
-				...Array.from(containerRef.current?.querySelectorAll(overflowSelector) || [])
-			];
+// 		// Create selector for specific overflow classes
+// 		const overflowSelector = [
+// 			'[class*="overflow-auto"]',
+// 			'[class*="overflow-x-auto"]',
+// 			'[class*="overflow-y-auto"]'
+// 		].join(',');
 
-			// Apply basic styling to all elements
-			scrollElements.forEach(element => {
-				element.classList.add('void-scrollable-element');
-			});
+// 		// Function to initialize scrollbar styles for elements
+// 		const initializeScrollbarStyles = () => {
+// 			// Get all matching elements within the container, including the container itself
+// 			const scrollElements = [
+// 				...(containerRef.current?.matches(overflowSelector) ? [containerRef.current] : []),
+// 				...Array.from(containerRef.current?.querySelectorAll(overflowSelector) || [])
+// 			];
 
-			// Only initialize fade effects for elements that haven't been initialized yet
-			scrollElements.forEach(element => {
-				if (!(element as any).__scrollbarCleanup) {
-					let fadeTimeout: NodeJS.Timeout | null = null;
-					let fadeInterval: NodeJS.Timeout | null = null;
+// 			// Apply basic styling to all elements
+// 			scrollElements.forEach(element => {
+// 				element.classList.add('void-scrollable-element');
+// 			});
 
-					const fadeIn = () => {
-						if (fadeInterval) clearInterval(fadeInterval);
+// 			// Only initialize fade effects for elements that haven't been initialized yet
+// 			scrollElements.forEach(element => {
+// 				if (!(element as any).__scrollbarCleanup) {
+// 					let fadeTimeout: NodeJS.Timeout | null = null;
+// 					let fadeInterval: NodeJS.Timeout | null = null;
 
-						let step = 0;
-						fadeInterval = setInterval(() => {
-							if (step <= 10) {
-								element.classList.remove(`show-scrollbar-${step - 1}`);
-								element.classList.add(`show-scrollbar-${step}`);
-								step++;
-							} else {
-								clearInterval(fadeInterval!);
-							}
-						}, 10);
-					};
+// 					const fadeIn = () => {
+// 						if (fadeInterval) clearInterval(fadeInterval);
 
-					const fadeOut = () => {
-						if (fadeInterval) clearInterval(fadeInterval);
+// 						let step = 0;
+// 						fadeInterval = setInterval(() => {
+// 							if (step <= 10) {
+// 								element.classList.remove(`show-scrollbar-${step - 1}`);
+// 								element.classList.add(`show-scrollbar-${step}`);
+// 								step++;
+// 							} else {
+// 								clearInterval(fadeInterval!);
+// 							}
+// 						}, 10);
+// 					};
 
-						let step = 10;
-						fadeInterval = setInterval(() => {
-							if (step >= 0) {
-								element.classList.remove(`show-scrollbar-${step + 1}`);
-								element.classList.add(`show-scrollbar-${step}`);
-								step--;
-							} else {
-								clearInterval(fadeInterval!);
-							}
-						}, 60);
-					};
+// 					const fadeOut = () => {
+// 						if (fadeInterval) clearInterval(fadeInterval);
 
-					const onMouseEnter = () => {
-						if (fadeTimeout) clearTimeout(fadeTimeout);
-						if (fadeInterval) clearInterval(fadeInterval);
-						fadeIn();
-					};
+// 						let step = 10;
+// 						fadeInterval = setInterval(() => {
+// 							if (step >= 0) {
+// 								element.classList.remove(`show-scrollbar-${step + 1}`);
+// 								element.classList.add(`show-scrollbar-${step}`);
+// 								step--;
+// 							} else {
+// 								clearInterval(fadeInterval!);
+// 							}
+// 						}, 60);
+// 					};
 
-					const onMouseLeave = () => {
-						if (fadeTimeout) clearTimeout(fadeTimeout);
-						fadeTimeout = setTimeout(() => {
-							fadeOut();
-						}, 10);
-					};
+// 					const onMouseEnter = () => {
+// 						if (fadeTimeout) clearTimeout(fadeTimeout);
+// 						if (fadeInterval) clearInterval(fadeInterval);
+// 						fadeIn();
+// 					};
 
-					element.addEventListener('mouseenter', onMouseEnter);
-					element.addEventListener('mouseleave', onMouseLeave);
+// 					const onMouseLeave = () => {
+// 						if (fadeTimeout) clearTimeout(fadeTimeout);
+// 						fadeTimeout = setTimeout(() => {
+// 							fadeOut();
+// 						}, 10);
+// 					};
 
-					// Store cleanup function
-					const cleanup = () => {
-						element.removeEventListener('mouseenter', onMouseEnter);
-						element.removeEventListener('mouseleave', onMouseLeave);
-						if (fadeTimeout) clearTimeout(fadeTimeout);
-						if (fadeInterval) clearInterval(fadeInterval);
-						element.classList.remove('void-scrollable-element');
-						// Remove any remaining show-scrollbar classes
-						for (let i = 0; i <= 10; i++) {
-							element.classList.remove(`show-scrollbar-${i}`);
-						}
-					};
+// 					element.addEventListener('mouseenter', onMouseEnter);
+// 					element.addEventListener('mouseleave', onMouseLeave);
 
-					// Store the cleanup function on the element for later use
-					(element as any).__scrollbarCleanup = cleanup;
-				}
-			});
-		};
+// 					// Store cleanup function
+// 					const cleanup = () => {
+// 						element.removeEventListener('mouseenter', onMouseEnter);
+// 						element.removeEventListener('mouseleave', onMouseLeave);
+// 						if (fadeTimeout) clearTimeout(fadeTimeout);
+// 						if (fadeInterval) clearInterval(fadeInterval);
+// 						element.classList.remove('void-scrollable-element');
+// 						// Remove any remaining show-scrollbar classes
+// 						for (let i = 0; i <= 10; i++) {
+// 							element.classList.remove(`show-scrollbar-${i}`);
+// 						}
+// 					};
 
-		// Initialize for the first time
-		initializeScrollbarStyles();
+// 					// Store the cleanup function on the element for later use
+// 					(element as any).__scrollbarCleanup = cleanup;
+// 				}
+// 			});
+// 		};
 
-		// Set up mutation observer to do the same
-		const observer = new MutationObserver(() => {
-			initializeScrollbarStyles();
-		});
+// 		// Initialize for the first time
+// 		initializeScrollbarStyles();
 
-		// Start observing the container for child changes
-		observer.observe(containerRef.current, {
-			childList: true,
-			subtree: true
-		});
+// 		// Set up mutation observer to do the same
+// 		const observer = new MutationObserver(() => {
+// 			initializeScrollbarStyles();
+// 		});
 
-		return () => {
-			observer.disconnect();
-			// Your existing cleanup code...
-			if (containerRef.current) {
-				const scrollElements = [
-					...(containerRef.current.matches(overflowSelector) ? [containerRef.current] : []),
-					...Array.from(containerRef.current.querySelectorAll(overflowSelector))
-				];
-				scrollElements.forEach(element => {
-					if ((element as any).__scrollbarCleanup) {
-						(element as any).__scrollbarCleanup();
-					}
-				});
-			}
-		};
-	}, [containerRef]);
-};
+// 		// Start observing the container for child changes
+// 		observer.observe(containerRef.current, {
+// 			childList: true,
+// 			subtree: true
+// 		});
+
+// 		return () => {
+// 			observer.disconnect();
+// 			// Your existing cleanup code...
+// 			if (containerRef.current) {
+// 				const scrollElements = [
+// 					...(containerRef.current.matches(overflowSelector) ? [containerRef.current] : []),
+// 					...Array.from(containerRef.current.querySelectorAll(overflowSelector))
+// 				];
+// 				scrollElements.forEach(element => {
+// 					if ((element as any).__scrollbarCleanup) {
+// 						(element as any).__scrollbarCleanup();
+// 					}
+// 				});
+// 			}
+// 		};
+// 	}, [containerRef]);
+// };

src/vs/workbench/contrib/void/browser/react/src/void-editor-widgets-tsx/VoidCommandBar.tsx

@@ -9,8 +9,9 @@ import { useAccessor, useCommandBarState, useIsDark } from '../util/services.js'
 import '../styles.css'
 import { useCallback, useEffect, useState, useRef } from 'react';
 import { ScrollType } from '../../../../../../../editor/common/editorCommon.js';
-import { acceptAllBg, acceptBorder, buttonFontSize, buttonTextColor, rejectAllBg, rejectBorder } from '../../../../common/helpers/colors.js';
+import { acceptAllBg, acceptBorder, buttonFontSize, buttonTextColor, rejectBg, rejectBorder } from '../../../../common/helpers/colors.js';
 import { VoidCommandBarProps } from '../../../voidCommandBarService.js';
+import { AcceptAllButtonWrapper, RejectAllButtonWrapper } from '../sidebar-tsx/SidebarChat.js';
 
 export const VoidCommandBarMain = ({ uri, editor }: VoidCommandBarProps) => {
 	const isDark = useIsDark()
@@ -39,7 +40,7 @@ const VoidCommandBar = ({ uri, editor }: VoidCommandBarProps) => {
 	const commandService = accessor.get('ICommandService')
 	const commandBarService = accessor.get('IVoidCommandBarService')
 	const voidModelService = accessor.get('IVoidModelService')
-	const { state: commandBarState, sortedURIs: sortedCommandBarURIs } = useCommandBarState()
+	const { stateOfURI: commandBarState, sortedURIs: sortedCommandBarURIs } = useCommandBarState()
 
 
 	// useEffect(() => {
@@ -110,7 +111,7 @@ const VoidCommandBar = ({ uri, editor }: VoidCommandBarProps) => {
 		const { model } = await voidModelService.getModelSafe(nextURI)
 		if (model) {
 			// switch to the URI
-			editorService.openCodeEditor({ resource: nextURI, options: { revealIfVisible: true } }, editor)
+			editorService.openCodeEditor({ resource: model.uri, options: { revealIfVisible: true } }, editor)
 		}
 	}
 
@@ -211,38 +212,47 @@ const VoidCommandBar = ({ uri, editor }: VoidCommandBarProps) => {
 
 	if (!isADiffZoneInAnyFile) return null
 
-	const acceptAllButton = <button
-		className='text-nowrap'
+	// const acceptAllButton = <button
+	// 	className='text-nowrap'
+	// 	onClick={onAcceptAll}
+	// 	style={{
+	// 		backgroundColor: acceptAllBg,
+	// 		border: acceptBorder,
+	// 		color: buttonTextColor,
+	// 		fontSize: buttonFontSize,
+	// 		padding: '2px 4px',
+	// 		borderRadius: '6px',
+	// 		cursor: 'pointer'
+	// 	}}
+	// >
+	// 	Accept File
+	// </button>
+
+	// const rejectAllButton = <button
+	// 	className='text-nowrap'
+	// 	onClick={onRejectAll}
+	// 	style={{
+	// 		backgroundColor: rejectBg,
+	// 		border: rejectBorder,
+	// 		color: 'white',
+	// 		fontSize: buttonFontSize,
+	// 		padding: '2px 4px',
+	// 		borderRadius: '6px',
+	// 		cursor: 'pointer'
+	// 	}}
+	// >
+	// 	Reject File
+	// </button>
+
+	const acceptAllButton = <AcceptAllButtonWrapper
+		text={'Keep Changes'}
 		onClick={onAcceptAll}
-		style={{
-			backgroundColor: acceptAllBg,
-			border: acceptBorder,
-			color: buttonTextColor,
-			fontSize: buttonFontSize,
-			padding: '2px 4px',
-			borderRadius: '6px',
-			cursor: 'pointer'
-		}}
-	>
-		Accept File
-	</button>
+	/>
 
-
-	const rejectAllButton = <button
-		className='text-nowrap'
+	const rejectAllButton = <RejectAllButtonWrapper
+		text={'Reject All'}
 		onClick={onRejectAll}
-		style={{
-			backgroundColor: rejectAllBg,
-			border: rejectBorder,
-			color: 'white',
-			fontSize: buttonFontSize,
-			padding: '2px 4px',
-			borderRadius: '6px',
-			cursor: 'pointer'
-		}}
-	>
-		Reject File
-	</button>
+	/>
 
 	const acceptRejectAllButtons = <div className="flex items-center gap-1 text-sm">
 		{acceptAllButton}
@@ -273,7 +283,7 @@ const VoidCommandBar = ({ uri, editor }: VoidCommandBarProps) => {
 			<div className={`${!isADiffZoneInThisFile ? 'hidden' : ''} flex items-center ${upDownDisabled ? 'opacity-50' : ''}`}>
 				{upButton}
 				{downButton}
-				<span className="min-w-16 px-2 text-xs">
+				<span className="min-w-16 px-2 text-xs leading-[1]">
 					{isADiffInThisFile ?
 						`Diff ${(currDiffIdx ?? 0) + 1} of ${sortedDiffIds.length}`
 						: streamState === 'streaming' ?
@@ -289,7 +299,7 @@ const VoidCommandBar = ({ uri, editor }: VoidCommandBarProps) => {
 				{/* <div className="w-px h-3 bg-void-border-3 mx-0.5 shadow-sm"></div> */}
 				{rightButton}
 				{/* <div className="w-px h-3 bg-void-border-3 mx-0.5 shadow-sm"></div> */}
-				<span className="min-w-16 px-2 text-xs">
+				<span className="min-w-16 px-2 text-xs leading-[1]">
 					{currFileIdx !== null ?
 						`File ${currFileIdx + 1} of ${sortedCommandBarURIs.length}`
 						: `${sortedCommandBarURIs.length} file${sortedCommandBarURIs.length === 1 ? '' : 's'} changed`
@@ -299,7 +309,7 @@ const VoidCommandBar = ({ uri, editor }: VoidCommandBarProps) => {
 		</div>
 	</div>
 
-	return <div className={`flex flex-col items-center gap-y-2 mx-2 pointer-events-auto`}>
+	return <div className={`flex flex-col items-center gap-y-2 pointer-events-auto`}>
 		{showAcceptRejectAll && acceptRejectAllButtons}
 		{leftRightUpDownButtons}
 

src/vs/workbench/contrib/void/browser/react/src/void-editor-widgets-tsx/VoidSelectionHelper.tsx

@@ -0,0 +1,170 @@
+/*--------------------------------------------------------------------------------------
+ *  Copyright 2025 Glass Devtools, Inc. All rights reserved.
+ *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
+ *--------------------------------------------------------------------------------------*/
+
+
+import { useAccessor, useActiveURI, useIsDark, useSettingsState } from '../util/services.js';
+
+import '../styles.css'
+import { VOID_CTRL_K_ACTION_ID, VOID_CTRL_L_ACTION_ID } from '../../../actionIDs.js';
+import { Circle, MoreVertical } from 'lucide-react';
+import { useEffect, useState } from 'react';
+
+import { VoidSelectionHelperProps } from '../../../../../../contrib/void/browser/voidSelectionHelperWidget.js';
+import { VOID_OPEN_SETTINGS_ACTION_ID } from '../../../voidSettingsPane.js';
+
+
+export const VoidSelectionHelperMain = (props: VoidSelectionHelperProps) => {
+
+	const isDark = useIsDark()
+
+	return <div
+		className={`@@void-scope ${isDark ? 'dark' : ''}`}
+	>
+		<VoidSelectionHelper {...props} />
+	</div>
+}
+
+
+
+const VoidSelectionHelper = ({ rerenderKey }: VoidSelectionHelperProps) => {
+
+
+	const accessor = useAccessor()
+	const keybindingService = accessor.get('IKeybindingService')
+	const commandService = accessor.get('ICommandService')
+
+	const ctrlLKeybind = keybindingService.lookupKeybinding(VOID_CTRL_L_ACTION_ID)
+	const ctrlKKeybind = keybindingService.lookupKeybinding(VOID_CTRL_K_ACTION_ID)
+
+	const dividerHTML = <div className='w-[0.5px] bg-void-border-3'></div>
+
+	const [reactRerenderCount, setReactRerenderKey] = useState(rerenderKey)
+	const [clickState, setClickState] = useState<'init' | 'clickedOption' | 'clickedMore'>('init')
+
+	useEffect(() => {
+		const disposable = commandService.onWillExecuteCommand(e => {
+			if (e.commandId === VOID_CTRL_L_ACTION_ID || e.commandId === VOID_CTRL_K_ACTION_ID) {
+				setClickState('clickedOption')
+			}
+		});
+
+		return () => {
+			disposable.dispose();
+		};
+	}, [commandService, setClickState]);
+
+
+	// rerender when the key changes
+	if (reactRerenderCount !== rerenderKey) {
+		setReactRerenderKey(rerenderKey)
+		setClickState('init')
+	}
+	// useEffect(() => {
+	// }, [rerenderKey, reactRerenderCount, setReactRerenderKey, setClickState])
+
+	// if the user selected an option, close
+
+
+	if (clickState === 'clickedOption') {
+		return null
+	}
+
+	const defaultHTML = <>
+		{ctrlLKeybind &&
+			<div
+				className='
+					flex items-center px-2 py-1.5
+					cursor-pointer
+				'
+				onClick={() => {
+					commandService.executeCommand(VOID_CTRL_L_ACTION_ID)
+					setClickState('clickedOption');
+				}}
+			>
+				<span>Add to Chat</span>
+				<span className='ml-1 px-1 rounded bg-[var(--vscode-keybindingLabel-background)] text-[var(--vscode-keybindingLabel-foreground)] border border-[var(--vscode-keybindingLabel-border)]'>
+					{ctrlLKeybind.getLabel()}
+				</span>
+			</div>
+		}
+		{ctrlLKeybind && ctrlKKeybind &&
+			dividerHTML
+		}
+		{ctrlKKeybind &&
+			<div
+				className='
+					flex items-center px-2 py-1.5
+					cursor-pointer
+				'
+				onClick={() => {
+					commandService.executeCommand(VOID_CTRL_K_ACTION_ID)
+					setClickState('clickedOption');
+				}}
+			>
+				<span className='ml-1'>Edit Inline</span>
+				<span className='ml-1 px-1 rounded bg-[var(--vscode-keybindingLabel-background)] text-[var(--vscode-keybindingLabel-foreground)] border border-[var(--vscode-keybindingLabel-border)]'>
+					{ctrlKKeybind.getLabel()}
+				</span>
+			</div>
+		}
+
+		{dividerHTML}
+
+		<div
+			className='
+				flex items-center px-0.5
+				cursor-pointer
+			'
+			onClick={() => {
+				setClickState('clickedMore');
+			}}
+		>
+			<MoreVertical className="w-4" />
+		</div>
+	</>
+
+
+	const moreOptionsHTML = <>
+		<div
+			className='
+				flex items-center px-2 py-1.5
+				cursor-pointer
+			'
+			onClick={() => {
+				commandService.executeCommand(VOID_OPEN_SETTINGS_ACTION_ID);
+				setClickState('clickedOption');
+			}}
+		>
+			Disable Suggestions?
+		</div>
+
+		{dividerHTML}
+
+		<div
+			className='
+				flex items-center px-0.5
+				cursor-pointer
+			'
+			onClick={() => {
+				setClickState('init');
+			}}
+		>
+			<MoreVertical className="w-4" />
+		</div>
+	</>
+
+	return <div className='
+		pointer-events-auto select-none
+		z-[1000]
+		rounded-sm shadow-md flex flex-nowrap text-nowrap
+		border border-void-border-3 bg-void-bg-2
+		transition-all duration-200
+	'>
+		{clickState === 'init' ? defaultHTML
+			: clickState === 'clickedMore' ? moreOptionsHTML
+				: <></>
+		}
+	</div>
+}

src/vs/workbench/contrib/void/browser/react/src/void-editor-widgets-tsx/index.tsx

@@ -5,5 +5,9 @@
 
 import { mountFnGenerator } from '../util/mountFnGenerator.js'
 import { VoidCommandBarMain } from './VoidCommandBar.js'
+import { VoidSelectionHelperMain } from './VoidSelectionHelper.js'
 
 export const mountVoidCommandBar = mountFnGenerator(VoidCommandBarMain)
+
+export const mountVoidSelectionHelper = mountFnGenerator(VoidSelectionHelperMain)
+

src/vs/workbench/contrib/void/browser/react/src/void-onboarding/VoidOnboarding.tsx

@@ -0,0 +1,870 @@
+/*--------------------------------------------------------------------------------------
+ *  Copyright 2025 Glass Devtools, Inc. All rights reserved.
+ *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
+ *--------------------------------------------------------------------------------------*/
+
+import { useEffect, useRef, useState } from 'react';
+import { useAccessor, useIsDark, useSettingsState } from '../util/services.js';
+import { Brain, Check, ChevronRight, DollarSign, ExternalLink, Lock, X } from 'lucide-react';
+import { displayInfoOfProviderName, ProviderName, providerNames, refreshableProviderNames } from '../../../../common/voidSettingsTypes.js';
+import { getModelCapabilities, ollamaRecommendedModels } from '../../../../common/modelCapabilities.js';
+import { ChatMarkdownRender } from '../markdown/ChatMarkdownRender.js';
+import { AddModelInputBox, AnimatedCheckmarkButton, ollamaSetupInstructions, OneClickSwitchButton, SettingsForProvider } from '../void-settings-tsx/Settings.js';
+import { ColorScheme } from '../../../../../../../platform/theme/common/theme.js';
+
+const OVERRIDE_VALUE = false
+
+export const VoidOnboarding = () => {
+
+	const voidSettingsState = useSettingsState()
+	const isOnboardingComplete = voidSettingsState.globalSettings.isOnboardingComplete || OVERRIDE_VALUE
+
+	const isDark = useIsDark()
+
+	return (
+		<div className={`@@void-scope ${isDark ? 'dark' : ''}`}>
+			<div
+				className={`
+					bg-void-bg-3 fixed top-0 right-0 bottom-0 left-0 width-full h-full z-[99999]
+					transition-all duration-1000 ${isOnboardingComplete ? 'opacity-0 pointer-events-none' : 'opacity-100 pointer-events-auto'}
+				`}
+			>
+				<VoidOnboardingContent />
+			</div>
+		</div>
+	)
+}
+
+const VoidIcon = () => {
+	const accessor = useAccessor()
+	const themeService = accessor.get('IThemeService')
+
+	const divRef = useRef<HTMLDivElement | null>(null)
+
+	useEffect(() => {
+		// void icon style
+		const updateTheme = () => {
+			const theme = themeService.getColorTheme().type
+			const isDark = theme === ColorScheme.DARK || theme === ColorScheme.HIGH_CONTRAST_DARK
+			if (divRef.current) {
+				divRef.current.style.maxWidth = '220px'
+				divRef.current.style.opacity = '50%'
+				divRef.current.style.filter = isDark ? '' : 'invert(1)' //brightness(.5)
+			}
+		}
+		updateTheme()
+		const d = themeService.onDidColorThemeChange(updateTheme)
+		return () => d.dispose()
+	}, [])
+
+	return <div ref={divRef} className='@@void-void-icon' />
+}
+
+const FADE_DURATION_MS = 2000
+
+const FadeIn = ({ children, className, delayMs = 0, durationMs, ...props }: { children: React.ReactNode, delayMs?: number, durationMs?: number, className?: string } & React.HTMLAttributes<HTMLDivElement>) => {
+
+	const [opacity, setOpacity] = useState(0)
+
+	const effectiveDurationMs = durationMs ?? FADE_DURATION_MS
+
+	useEffect(() => {
+
+		const timeout = setTimeout(() => {
+			setOpacity(1)
+		}, delayMs)
+
+		return () => clearTimeout(timeout)
+	}, [setOpacity, delayMs])
+
+
+	return (
+		<div className={className} style={{ opacity, transition: `opacity ${effectiveDurationMs}ms ease-in-out` }} {...props}>
+			{children}
+		</div>
+	)
+}
+
+// Onboarding
+// 	OnboardingPage
+// 		title:
+// 			div
+// 				"Welcome to Void"
+// 			image
+// 		content:<></>
+// 		title
+// 		content
+// 		prev/next
+
+// 	OnboardingPage
+// 		title:
+// 			div
+// 				"How would you like to use Void?"
+// 		content:
+// 			ModelQuestionContent
+// 				|
+// 					div
+// 						"I want to:"
+// 					div
+// 						"Use the smartest models"
+// 						"Keep my data fully private"
+// 						"Save money"
+// 						"I don't know"
+// 				| div
+// 					| div
+// 						"We recommend using "
+// 						"Set API"
+// 					| div
+// 						""
+// 					| div
+//
+// 		title
+// 		content
+// 		prev/next
+//
+// 	OnboardingPage
+// 		title
+// 		content
+// 		prev/next
+
+const NextButton = ({ onClick, ...props }: { onClick: () => void } & React.ButtonHTMLAttributes<HTMLButtonElement>) => {
+	return (
+		<button
+			onClick={onClick}
+			className="px-6 py-2 bg-zinc-100 enabled:hover:bg-zinc-100 disabled:bg-zinc-100/40 disabled:cursor-not-allowed rounded text-black duration-600 transition-all"
+			{...props.disabled && {
+				'data-tooltip-id': 'void-tooltip',
+				'data-tooltip-content': 'Please enter all required fields or choose another provider',
+				'data-tooltip-place': 'top',
+			}}
+			{...props}
+		>
+			Next
+		</button>
+	)
+}
+
+const PreviousButton = ({ onClick, ...props }: { onClick: () => void } & React.ButtonHTMLAttributes<HTMLButtonElement>) => {
+	return (
+		<button
+			onClick={onClick}
+			className="px-6 py-2 rounded text-void-fg-3 opacity-80 hover:brightness-115 duration-600 transition-all"
+			{...props}
+		>
+			Back
+		</button>
+	)
+}
+
+
+
+const OnboardingPageShell = ({ top, bottom, content, hasMaxWidth = true, className = '', }: {
+	top?: React.ReactNode,
+	bottom?: React.ReactNode,
+	content?: React.ReactNode,
+	hasMaxWidth?: boolean,
+	className?: string,
+}) => {
+	return (
+		<div className={`min-h-full text-lg flex flex-col gap-4 w-full mx-auto ${hasMaxWidth ? 'max-w-[600px]' : ''} ${className}`}>
+			{top && <FadeIn className='w-full mb-auto pt-16'>{top}</FadeIn>}
+			{content && <FadeIn className='w-full my-auto'>{content}</FadeIn>}
+			{bottom && <div className='w-full pb-8'>{bottom}</div>}
+		</div>
+	)
+}
+
+const OllamaDownloadOrRemoveModelButton = ({ modelName, isModelInstalled, sizeGb }: { modelName: string, isModelInstalled: boolean, sizeGb: number | false | 'not-known' }) => {
+
+
+	// for now just link to the ollama download page
+	return <a
+		href={`https://ollama.com/library/${modelName}`}
+		target="_blank"
+		rel="noopener noreferrer"
+		className="flex items-center justify-center text-void-fg-2 hover:text-void-fg-1"
+	>
+		<ExternalLink className="w-3.5 h-3.5" />
+	</a>
+
+	// if (isModelInstalled) {
+	// 	return <div className="flex items-center">
+
+	// 		<span className="flex items-center">Uninstall</span>
+
+	// 		<IconShell1
+	// 			className="ml-1"
+	// 			Icon={Trash}
+	// 			onClick={() => {
+
+	// 				setIsModelInstalling(false);
+	// 			}}
+	// 		/>
+
+	// 	</div>
+	// }
+
+
+
+	// else if (isModelInstalling) {
+	// 	return <div className="flex items-center">
+
+	// 		<span className="flex items-center">{`Download? ${typeof sizeGb === 'number' ? `(${sizeGb} Gb)` : ''}`}</span>
+
+	// 		<IconShell1
+	// 			className="ml-1"
+	// 			Icon={Square}
+	// 			onClick={() => {
+	// 				// abort()
+
+	// 				// TODO!!!!!!!!!!! don't do this
+	// 				setIsModelInstalling(false);
+	// 			}}
+	// 		/>
+
+	// 	</div>
+	// }
+
+
+	// else if (!isModelInstalled) {
+
+	// 	return <div className="flex items-center">
+
+	// 		<span className="flex items-center">Download ({sizeGb} Gb)</span>
+
+	// 		<IconShell1
+	// 			className="ml-1"
+	// 			Icon={Download}
+	// 			onClick={() => {
+	// 				// this is a check for whether the model was installed:
+
+	// 				if (isModelInstalling) return
+
+
+	// 				// TODO!!!!!! don't do this
+
+
+	// 				// install(modelname), callback = setIsModelInstalling(false);
+
+	// 				setIsModelInstalling(true);
+	// 			}}
+	// 		/>
+
+	// 	</div>
+
+	// }
+
+	// return <></>
+
+
+}
+
+
+const YesNoText = ({ val }: { val: boolean | null }) => {
+
+	return <div
+		className={
+			val === true ? "text text-emerald-500"
+				: val === false ? 'text-rose-600'
+					: "text text-amber-300"
+		}
+	>
+		{
+			val === true ? "Yes"
+				: val === false ? 'No'
+					: "Yes*"
+		}
+	</div>
+
+}
+
+
+
+const abbreviateNumber = (num: number): string => {
+	if (num >= 1000000) {
+		// For millions
+		return Math.floor(num / 1000000) + 'M';
+	} else if (num >= 1000) {
+		// For thousands
+		return Math.floor(num / 1000) + 'K';
+	} else {
+		// For numbers less than 1000
+		return num.toString();
+	}
+}
+
+const TableOfModelsForProvider = ({ providerName }: { providerName: ProviderName }) => {
+
+	const accessor = useAccessor()
+	const voidSettingsService = accessor.get('IVoidSettingsService')
+	const voidSettingsState = useSettingsState()
+	const isDetectableLocally = (refreshableProviderNames as ProviderName[]).includes(providerName)
+	// const providerCapabilities = getProviderCapabilities(providerName)
+
+
+	// info used to show the table
+	const infoOfModelName: Record<string, { showAsDefault: boolean, isDownloaded: boolean }> = {}
+
+	voidSettingsState.settingsOfProvider[providerName].models.forEach(m => {
+		infoOfModelName[m.modelName] = {
+			showAsDefault: m.isDefault,
+			isDownloaded: true
+		}
+	})
+
+	// special case  columns for ollama; show recommended models as default
+	if (providerName === 'ollama') {
+		for (const modelName of ollamaRecommendedModels) {
+			if (modelName in infoOfModelName) continue
+			infoOfModelName[modelName] = {
+				...infoOfModelName[modelName],
+				showAsDefault: true,
+			}
+		}
+	}
+
+	return <table className="table-fixed border-collapse mb-6 bg-void-bg-2 text-sm mx-auto select-text">
+		<thead>
+			<tr className="border-b border-void-border-1 text-nowrap text-ellipsis">
+				<th className="text-left py-2 px-3 font-normal text-void-fg-3 min-w-[200px]">Models Offered</th>
+				<th className="text-left py-2 px-3 font-normal text-void-fg-3 min-w-[10%]">Cost/M</th>
+				<th className="text-left py-2 px-3 font-normal text-void-fg-3 min-w-[10%]">Context</th>
+				<th className="text-left py-2 px-3 font-normal text-void-fg-3 min-w-[10%]">Chat</th>
+				<th className="text-left py-2 px-3 font-normal text-void-fg-3 min-w-[10%]">Agent</th>
+				<th className="text-left py-2 px-3 font-normal text-void-fg-3 min-w-[10%]">Autotab</th>
+				{/* <th className="text-left py-2 px-3 font-normal text-void-fg-3 min-w-[10%]">Reasoning</th> */}
+				{isDetectableLocally && <th className="text-left py-2 px-3 font-normal text-void-fg-3 min-w-[10%]">Detected</th>}
+				{providerName === 'ollama' && <th className="text-left py-2 px-3 font-normal text-void-fg-3">Download</th>}
+			</tr>
+		</thead>
+		<tbody>
+			{Object.keys(infoOfModelName).map(modelName => {
+				const { showAsDefault, isDownloaded } = infoOfModelName[modelName]
+
+
+				const capabilities = getModelCapabilities(providerName, modelName)
+				const {
+					downloadable,
+					cost,
+					supportsFIM,
+					reasoningCapabilities,
+					contextWindow,
+
+					isUnrecognizedModel,
+					maxOutputTokens,
+					supportsSystemMessage,
+				} = capabilities
+
+				// TODO update this when tools work
+
+				const removeModelButton = <button
+					className="absolute -left-1 top-1/2 transform -translate-y-1/2 -translate-x-full text-void-fg-3 hover:text-void-fg-1 text-xs"
+					onClick={() => voidSettingsService.deleteModel(providerName, modelName)}
+				>
+					<X className="w-3.5 h-3.5" />
+				</button>
+
+
+
+				return (
+					<tr key={modelName} className="border-b border-void-border-1 hover:bg-void-bg-3/50">
+						<td className="py-2 px-3 relative">
+							{!showAsDefault && removeModelButton}
+							{modelName}
+						</td>
+						<td className="py-2 px-3">${cost.output ?? ''}</td>
+						<td className="py-2 px-3">{contextWindow ? abbreviateNumber(contextWindow) : ''}</td>
+						<td className="py-2 px-3"><YesNoText val={true} /></td>
+						<td className="py-2 px-3"><YesNoText val={!!true} /></td>
+						<td className="py-2 px-3"><YesNoText val={!!supportsFIM} /></td>
+						{/* <td className="py-2 px-3"><YesNoText val={!!reasoningCapabilities} /></td> */}
+						{isDetectableLocally && <td className="py-2 px-3 flex items-center justify-center">{!!isDownloaded ? <Check className="w-4 h-4" /> : <></>}</td>}
+						{providerName === 'ollama' && <th className="py-2 px-3">
+							<OllamaDownloadOrRemoveModelButton modelName={modelName} isModelInstalled={infoOfModelName[modelName].isDownloaded} sizeGb={downloadable && downloadable.sizeGb} />
+						</th>}
+
+					</tr>
+				)
+			})}
+			<tr className="hover:bg-void-bg-3/50">
+				<td className="py-2 px-3 text-void-accent">
+					<AddModelInputBox
+						key={providerName}
+						providerName={providerName}
+						compact={true} />
+				</td>
+				<td colSpan={4}></td>
+			</tr>
+		</tbody>
+	</table>
+}
+
+
+
+const PrimaryActionButton = ({ children, className, ringSize, ...props }: { children: React.ReactNode, ringSize?: undefined | 'xl' | 'screen' } & React.ButtonHTMLAttributes<HTMLButtonElement>) => {
+
+
+	return (
+		<button
+			type='button'
+			className={`
+				flex items-center justify-center
+
+				text-white dark:text-black
+				bg-black/90 dark:bg-white/90
+
+				${ringSize === 'xl' ? `
+					gap-2 px-16 py-8
+					hover:ring-8 active:ring-8
+					transition-all duration-300 ease-in-out
+					`
+					: ringSize === 'screen' ? `
+					gap-2 px-16 py-8
+					ring-[3000px]
+					transition-all duration-1000 ease-in-out
+					`: ringSize === undefined ? `
+					gap-1 px-4 py-2
+					hover:ring-2 active:ring-2
+					transition-all duration-300 ease-in-out
+				`: ''}
+
+				hover:ring-black/90 dark:hover:ring-white/90
+				active:ring-black/90 dark:active:ring-white/90
+
+				rounded-lg
+				group
+				${className}
+			`}
+			{...props}
+		>
+			{children}
+			<ChevronRight
+				className={`
+					transition-all duration-300 ease-in-out
+
+					transform
+					group-hover:translate-x-1
+					group-active:translate-x-1
+				`}
+			/>
+		</button>
+	)
+}
+
+
+type WantToUseOption = 'smart' | 'private' | 'cheap' | 'all'
+
+const VoidOnboardingContent = () => {
+
+
+	const accessor = useAccessor()
+	const voidSettingsService = accessor.get('IVoidSettingsService')
+
+	const voidSettingsState = useSettingsState()
+
+	const [pageIndex, setPageIndex] = useState(0)
+
+
+	// page 1 state
+	const [wantToUseOption, setWantToUseOption] = useState<WantToUseOption>('smart')
+
+	// Replace the single selectedProviderName with four separate states
+	// page 2 state - each tab gets its own state
+	const [selectedIntelligentProvider, setSelectedIntelligentProvider] = useState<ProviderName>('anthropic');
+	const [selectedPrivateProvider, setSelectedPrivateProvider] = useState<ProviderName>('ollama');
+	const [selectedAffordableProvider, setSelectedAffordableProvider] = useState<ProviderName>('gemini');
+	const [selectedAllProvider, setSelectedAllProvider] = useState<ProviderName>('anthropic');
+
+	// Helper function to get the current selected provider based on active tab
+	const getSelectedProvider = (): ProviderName => {
+		switch (wantToUseOption) {
+			case 'smart': return selectedIntelligentProvider;
+			case 'private': return selectedPrivateProvider;
+			case 'cheap': return selectedAffordableProvider;
+			case 'all': return selectedAllProvider;
+		}
+	}
+
+	// Helper function to set the selected provider for the current tab
+	const setSelectedProvider = (provider: ProviderName) => {
+		switch (wantToUseOption) {
+			case 'smart': setSelectedIntelligentProvider(provider); break;
+			case 'private': setSelectedPrivateProvider(provider); break;
+			case 'cheap': setSelectedAffordableProvider(provider); break;
+			case 'all': setSelectedAllProvider(provider); break;
+		}
+	}
+
+	const providerNamesOfWantToUseOption: { [wantToUseOption in WantToUseOption]: ProviderName[] } = {
+		smart: ['anthropic', 'openAI', 'gemini', 'openRouter'],
+		private: ['ollama', 'vLLM', 'openAICompatible'],
+		cheap: ['gemini', 'deepseek', 'openRouter', 'ollama', 'vLLM'],
+		all: providerNames,
+	}
+
+
+	const selectedProviderName = getSelectedProvider();
+	const didFillInProviderSettings = selectedProviderName && voidSettingsState.settingsOfProvider[selectedProviderName]._didFillInProviderSettings
+	const isApiKeyLongEnoughIfApiKeyExists = selectedProviderName && voidSettingsState.settingsOfProvider[selectedProviderName].apiKey ? voidSettingsState.settingsOfProvider[selectedProviderName].apiKey.length > 15 : true
+	const isAtLeastOneModel = selectedProviderName && voidSettingsState.settingsOfProvider[selectedProviderName].models.length >= 1
+
+	const didFillInSelectedProviderSettings = !!(didFillInProviderSettings && isApiKeyLongEnoughIfApiKeyExists && isAtLeastOneModel)
+
+	const prevAndNextButtons = <div className="max-w-[600px] w-full mx-auto flex flex-col items-end">
+		<div className="flex items-center gap-2">
+			<PreviousButton
+				onClick={() => { setPageIndex(pageIndex - 1) }}
+			/>
+			<NextButton
+				onClick={() => { setPageIndex(pageIndex + 1) }}
+				disabled={pageIndex === 2 && !didFillInSelectedProviderSettings}
+			/>
+		</div>
+	</div>
+
+
+	const lastPagePrevAndNextButtons = <div className="max-w-[600px] w-full mx-auto flex flex-col items-end">
+		<div className="flex items-center gap-2">
+			<PreviousButton
+				onClick={() => { setPageIndex(pageIndex - 1) }}
+			/>
+			<PrimaryActionButton
+				onClick={() => { voidSettingsService.setGlobalSetting('isOnboardingComplete', true); }}
+				ringSize={voidSettingsState.globalSettings.isOnboardingComplete ? 'screen' : undefined}
+			>Enter the Void</PrimaryActionButton>
+		</div>
+	</div>
+
+
+	// cannot be md
+	const basicDescOfWantToUseOption: { [wantToUseOption in WantToUseOption]: string } = {
+		smart: "Models with the best performance on benchmarks.",
+		private: "Host on your computer or local network for full data privacy.",
+		cheap: "Free and affordable options.",
+		all: "",
+	}
+
+	// can be md
+	const detailedDescOfWantToUseOption: { [wantToUseOption in WantToUseOption]: string } = {
+		smart: "Most intelligent and best for agent mode.",
+		private: "Private-hosted so your data never leaves your computer or network. [Email us](mailto:founders@voideditor.com) for help setting up at your company.",
+		cheap: "Use great deals like Gemini 2.5 Pro, or self-host a model with Ollama or vLLM for free.",
+		all: "",
+	}
+
+	// Modified: initialize separate provider states on initial render instead of watching wantToUseOption changes
+	useEffect(() => {
+		if (selectedIntelligentProvider === undefined) {
+			setSelectedIntelligentProvider(providerNamesOfWantToUseOption['smart'][0]);
+		}
+		if (selectedPrivateProvider === undefined) {
+			setSelectedPrivateProvider(providerNamesOfWantToUseOption['private'][0]);
+		}
+		if (selectedAffordableProvider === undefined) {
+			setSelectedAffordableProvider(providerNamesOfWantToUseOption['cheap'][0]);
+		}
+		if (selectedAllProvider === undefined) {
+			setSelectedAllProvider(providerNamesOfWantToUseOption['all'][0]);
+		}
+	}, []);
+
+	// reset the page to page 0 if the user redos onboarding
+	useEffect(() => {
+		if (!voidSettingsState.globalSettings.isOnboardingComplete) {
+			setPageIndex(0)
+		}
+	}, [setPageIndex, voidSettingsState.globalSettings.isOnboardingComplete])
+
+
+	const contentOfIdx: { [pageIndex: number]: React.ReactNode } = {
+		0: <OnboardingPageShell
+			content={
+				<div className='flex flex-col items-center gap-8'>
+					<div className="text-5xl font-light text-center">Welcome to Void</div>
+
+					{/* Slice of Void image */}
+					<div className='max-w-md w-full h-[30vh] mx-auto flex items-center justify-center'>
+						<VoidIcon />
+					</div>
+
+
+					<FadeIn
+						delayMs={1000}
+					>
+						<PrimaryActionButton
+							onClick={() => { setPageIndex(pageIndex + 1) }}
+						>
+							Get Started
+						</PrimaryActionButton>
+					</FadeIn>
+
+				</div>
+			}
+		/>,
+		1: <OnboardingPageShell
+
+			hasMaxWidth={false}
+			top={<></>}
+			content={<div className='flex flex-col items-center -translate-y-[20vh]'>
+				{/* <div className="text-5xl text-center mb-8">AI Preferences</div> */}
+
+				<div className="text-4xl text-void-fg-2 mb-8 text-center">Model Preferences</div>
+
+
+				<div className="grid grid-cols-1 md:grid-cols-3 gap-6 w-full max-w-[800px] mx-auto mt-8">
+					<button
+						onClick={() => { setWantToUseOption('smart'); setPageIndex(pageIndex + 1); }}
+						className="flex flex-col p-6 rounded bg-void-bg-2 border border-void-border-3 hover:brightness-110  transition-colors focus:outline-none focus:border-void-accent-border relative overflow-hidden min-h-[160px]"
+					>
+						<div className="flex items-center mb-3">
+							<Brain size={24} className="text-void-fg-2 mr-2" />
+							<div className="text-lg font-medium text-void-fg-1">Intelligent</div>
+						</div>
+						<div className="text-sm text-void-fg-2 text-left">{basicDescOfWantToUseOption['smart']}</div>
+					</button>
+
+					<button
+						onClick={() => { setWantToUseOption('private'); setPageIndex(pageIndex + 1); }}
+						className="flex flex-col p-6 rounded bg-void-bg-2 border border-void-border-3 hover:brightness-110  transition-colors focus:outline-none focus:border-void-accent-border relative overflow-hidden min-h-[160px]"
+					>
+						<div className="flex items-center mb-3">
+							<Lock size={24} className="text-void-fg-2 mr-2" />
+							<div className="text-lg font-medium text-void-fg-1">Private</div>
+						</div>
+						<div className="text-sm text-void-fg-2 text-left">{basicDescOfWantToUseOption['private']}</div>
+					</button>
+
+					<button
+						onClick={() => { setWantToUseOption('cheap'); setPageIndex(pageIndex + 1); }}
+						className="flex flex-col p-6 rounded bg-void-bg-2 border border-void-border-3 hover:brightness-110  transition-colors focus:outline-none focus:border-void-accent-border relative overflow-hidden min-h-[160px]"
+					>
+						<div className="flex items-center mb-3">
+							<DollarSign size={24} className="text-void-fg-2 mr-2" />
+							<div className="text-lg font-medium text-void-fg-1">Affordable</div>
+						</div>
+						<div className="text-sm text-void-fg-2 text-left">{basicDescOfWantToUseOption['cheap']}</div>
+					</button>
+				</div>
+
+
+			</div>}
+			bottom={
+				<div className='mx-auto w-full max-w-[800px]'>
+					<PreviousButton onClick={() => { setPageIndex(pageIndex - 1) }} />
+				</div>
+			}
+		/>,
+		2: <OnboardingPageShell
+			top={
+				<>
+					{/* Title */}
+
+					<div className="text-5xl font-light text-center mt-[10vh] mb-6">Choose a Provider</div>
+
+					{/* Preference Selector */}
+
+					<div
+						className="mb-6 w-fit mx-auto flex items-center overflow-hidden bg-zinc-700/5 dark:bg-zinc-300/5 rounded-md"
+					>
+						{[
+							{ id: 'smart', label: 'Intelligent' },
+							{ id: 'private', label: 'Private' },
+							{ id: 'cheap', label: 'Affordable' },
+							{ id: 'all', label: 'All' }
+						].map(option => (
+							<button
+								key={option.id}
+								onClick={() => setWantToUseOption(option.id as WantToUseOption)}
+								className={`py-1 px-2 text-xs cursor-pointer whitespace-nowrap rounded-sm transition-colors ${wantToUseOption === option.id
+									? 'dark:text-white text-black font-medium'
+									: 'text-void-fg-3 hover:text-void-fg-2'
+									}`}
+								data-tooltip-id='void-tooltip'
+								data-tooltip-content={`${option.label} providers`}
+								data-tooltip-place='bottom'
+							>
+								{option.label}
+							</button>
+						))}
+					</div>
+
+
+
+					{/* Provider Buttons - Modified to use separate components for each tab */}
+					<div className="mb-2 w-full">
+						{/* Intelligent tab */}
+						<div className={`flex flex-wrap items-center w-full ${wantToUseOption === 'smart' ? 'flex' : 'hidden'}`}>
+							{providerNamesOfWantToUseOption['smart'].map((providerName) => {
+								const isSelected = selectedIntelligentProvider === providerName;
+								return (
+									<button
+										key={providerName}
+										onClick={() => setSelectedIntelligentProvider(providerName)}
+										className={`py-[2px] px-2 mx-0.5 my-0.5 text-xs font-medium cursor-pointer relative rounded-full transition-all duration-300
+											${isSelected ? 'bg-zinc-100 text-zinc-900 shadow-sm border-white/80' : 'bg-zinc-100/40 hover:bg-zinc-100/50 text-zinc-900 border-white/20'}`}
+									>
+										{displayInfoOfProviderName(providerName).title}
+									</button>
+								);
+							})}
+						</div>
+
+						{/* Private tab */}
+						<div className={`flex flex-wrap items-center w-full ${wantToUseOption === 'private' ? 'flex' : 'hidden'}`}>
+							{providerNamesOfWantToUseOption['private'].map((providerName) => {
+								const isSelected = selectedPrivateProvider === providerName;
+								return (
+									<button
+										key={providerName}
+										onClick={() => setSelectedPrivateProvider(providerName)}
+										className={`py-[2px] px-2 mx-0.5 my-0.5 text-xs font-medium cursor-pointer relative rounded-full transition-all duration-300
+											${isSelected ? 'bg-zinc-100 text-zinc-900 shadow-sm border-white/80' : 'bg-zinc-100/40 hover:bg-zinc-100/50 text-zinc-900 border-white/20'}`}
+									>
+										{displayInfoOfProviderName(providerName).title}
+									</button>
+								);
+							})}
+						</div>
+
+						{/* Affordable tab */}
+						<div className={`flex flex-wrap items-center w-full ${wantToUseOption === 'cheap' ? 'flex' : 'hidden'}`}>
+							{providerNamesOfWantToUseOption['cheap'].map((providerName) => {
+								const isSelected = selectedAffordableProvider === providerName;
+								return (
+									<button
+										key={providerName}
+										onClick={() => setSelectedAffordableProvider(providerName)}
+										className={`py-[2px] px-2 mx-0.5 my-0.5 text-xs font-medium cursor-pointer relative rounded-full transition-all duration-300
+											${isSelected ? 'bg-zinc-100 text-zinc-900 shadow-sm border-white/80' : 'bg-zinc-100/40 hover:bg-zinc-100/50 text-zinc-900 border-white/20'}`}
+									>
+										{displayInfoOfProviderName(providerName).title}
+									</button>
+								);
+							})}
+						</div>
+
+						{/* All tab */}
+						<div className={`flex flex-wrap items-center w-full ${wantToUseOption === 'all' ? 'flex' : 'hidden'}`}>
+							{providerNames.map((providerName) => {
+								const isSelected = selectedAllProvider === providerName;
+								return (
+									<button
+										key={providerName}
+										onClick={() => setSelectedAllProvider(providerName)}
+										className={`py-[2px] px-2 mx-0.5 my-0.5 text-xs font-medium cursor-pointer relative rounded-full transition-all duration-300
+											${isSelected ? 'bg-zinc-100 text-zinc-900 shadow-sm border-white/80' : 'bg-zinc-100/40 hover:bg-zinc-100/50 text-zinc-900 border-white/20'}`}
+									>
+										{displayInfoOfProviderName(providerName).title}
+									</button>
+								);
+							})}
+						</div>
+					</div>
+
+					{/* Description */}
+					<div className="text-left self-start text-sm text-void-fg-3 px-2 py-1">
+						<ChatMarkdownRender string={detailedDescOfWantToUseOption[wantToUseOption]} chatMessageLocation={undefined} />
+					</div>
+
+
+					{/* ModelsTable and ProviderFields */}
+					{selectedProviderName && <div className='mt-4 w-fit mx-auto'>
+
+
+						{/* Models Table */}
+						<TableOfModelsForProvider providerName={selectedProviderName} />
+
+
+						{/* Add provider section - simplified styling */}
+						<div className='mb-5 mt-8 mx-auto'>
+							<div className=''>
+								Add {displayInfoOfProviderName(selectedProviderName).title}
+
+								<div className='my-4'>
+									{selectedProviderName === 'ollama' ? ollamaSetupInstructions : ''}
+								</div>
+
+							</div>
+
+							{selectedProviderName &&
+								<SettingsForProvider providerName={selectedProviderName} showProviderTitle={false} showProviderSuggestions={false} />
+							}
+
+							{/* Button and status indicators */}
+							{!didFillInProviderSettings ? <p className="text-xs text-void-fg-3 mt-2">Please fill in all fields to continue</p>
+								: !isAtLeastOneModel ? <p className="text-xs text-void-fg-3 mt-2">Please add a model to continue</p>
+									: !isApiKeyLongEnoughIfApiKeyExists ? <p className="text-xs text-void-fg-3 mt-2">Please enter a valid API key</p>
+										: <AnimatedCheckmarkButton className='text-xs text-void-fg-3 mt-2' text='Added' />}
+						</div>
+
+					</div>}
+				</>
+			}
+
+			bottom={
+				<FadeIn delayMs={50} durationMs={10}>
+					{prevAndNextButtons}
+				</FadeIn>
+
+			}
+
+		/>,
+
+		// 2.5: <div className="max-w-[600px] w-full h-full text-left mx-auto flex flex-col items-center justify-between">
+		// 	<FadeIn>
+		// 		<div className="text-5xl font-light mb-6 mt-12 text-center">Autocomplete</div>
+
+		// 		<div className="text-center flex flex-col gap-4 w-full max-w-md mx-auto">
+		// 			<h4 className="text-void-fg-3 mb-2">Void offers free autocomplete with locally hosted models</h4>
+		// 			<h4 className="text-void-fg-3 mb-2">[have buttons for Ollama install Qwen2.5coder3b and memory requirements] </h4>
+
+		// 		</div>
+		// 	</FadeIn>
+
+		// 	{prevAndNextButtons}
+		// </div>,
+		3: <OnboardingPageShell
+
+			content={
+				<div>
+					<div className="text-5xl font-light text-center">Settings and Themes</div>
+
+					<div className="mt-8 text-center flex flex-col items-center gap-4 w-full max-w-md mx-auto">
+						<h4 className="text-void-fg-3 mb-4">Transfer your settings from an existing editor?</h4>
+						<OneClickSwitchButton className='w-full px-4 py-2' fromEditor="VS Code" />
+						<OneClickSwitchButton className='w-full px-4 py-2' fromEditor="Cursor" />
+						<OneClickSwitchButton className='w-full px-4 py-2' fromEditor="Windsurf" />
+					</div>
+				</div>
+			}
+			bottom={lastPagePrevAndNextButtons}
+		// bottom={prevAndNextButtons}
+		/>,
+		// 4: <OnboardingPageShell
+		// 	content={
+		// 		<>
+		// 			<div
+		// 				className='flex justify-center'
+		// 			>
+		// 				<PrimaryActionButton
+		// 					onClick={() => { voidSettingsService.setGlobalSetting('isOnboardingComplete', true); }}
+		// 					ringSize={voidSettingsState.globalSettings.isOnboardingComplete ? 'screen' : undefined}
+		// 					className='text-4xl'
+		// 				>Enter the Void</PrimaryActionButton>
+		// 			</div>
+		// 		</>
+		// 	}
+		// 	bottom={
+		// 		<PreviousButton
+		// 			onClick={() => { setPageIndex(pageIndex - 1) }}
+		// 		/>
+		// 	}
+		// />,
+	}
+
+
+	return <div key={pageIndex} className="w-full h-full text-left mx-auto overflow-y-scroll flex flex-col items-center justify-around">
+		{contentOfIdx[pageIndex]}
+	</div>
+
+}

src/vs/workbench/contrib/void/browser/react/src/void-onboarding/index.tsx

@@ -0,0 +1,9 @@
+/*--------------------------------------------------------------------------------------
+ *  Copyright 2025 Glass Devtools, Inc. All rights reserved.
+ *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
+ *--------------------------------------------------------------------------------------*/
+
+import { mountFnGenerator } from '../util/mountFnGenerator.js'
+import { VoidOnboarding } from './VoidOnboarding.js'
+
+export const mountVoidOnboarding = mountFnGenerator(VoidOnboarding)

src/vs/workbench/contrib/void/browser/react/src/void-settings-tsx/ModelDropdown.tsx

@@ -12,6 +12,7 @@ import { IconWarning } from '../sidebar-tsx/SidebarChat.js'
 import { VOID_OPEN_SETTINGS_ACTION_ID, VOID_TOGGLE_SETTINGS_ACTION_ID } from '../../../voidSettingsPane.js'
 import { modelFilterOfFeatureName, ModelOption } from '../../../../../../../workbench/contrib/void/common/voidSettingsService.js'
 import { WarningBox } from './WarningBox.js'
+import ErrorBoundary from '../sidebar-tsx/ErrorBoundary.js'
 
 const optionsEqual = (m1: ModelOption[], m2: ModelOption[]) => {
 	if (m1.length !== m2.length) return false
@@ -44,37 +45,6 @@ const ModelSelectBox = ({ options, featureName, className }: { options: ModelOpt
 		matchInputWidth={false}
 	/>
 }
-// const ModelSelectBox = ({ options, featureName }: { options: ModelOption[], featureName: FeatureName }) => {
-// 	const accessor = useAccessor()
-
-// 	const voidSettingsService = accessor.get('IVoidSettingsService')
-
-// 	let weChangedText = false
-
-// 	return <VoidSelectBox
-// 		className='@@[&_select]:!void-text-xs text-void-fg-3'
-// 		options={options}
-// 		onChangeSelection={useCallback((newVal: ModelSelection) => {
-// 			if (weChangedText) return
-// 			voidSettingsService.setModelSelectionOfFeature(featureName, newVal)
-// 		}, [voidSettingsService, featureName])}
-// 		// we are responsible for setting the initial state here. always sync instance when state changes.
-// 		onCreateInstance={useCallback((instance: SelectBox) => {
-// 			const syncInstance = () => {
-// 				const modelsListRef = voidSettingsService.state._modelOptions // as a ref
-// 				const settingsAtProvider = voidSettingsService.state.modelSelectionOfFeature[featureName]
-// 				const selectionIdx = settingsAtProvider === null ? -1 : modelsListRef.findIndex(v => modelSelectionsEqual(v.value, settingsAtProvider))
-// 				weChangedText = true
-// 				instance.select(selectionIdx === -1 ? 0 : selectionIdx)
-// 				weChangedText = false
-// 			}
-// 			syncInstance()
-// 			const disposable = voidSettingsService.onDidChangeState(syncInstance)
-// 			return [disposable]
-// 		}, [voidSettingsService, featureName])}
-// 	/>
-// }
-
 
 
 const MemoizedModelDropdown = ({ featureName, className }: { featureName: FeatureName, className: string }) => {
@@ -123,5 +93,7 @@ export const ModelDropdown = ({ featureName, className }: { featureName: Feature
 							: 'Provider required'
 		} />
 
-	return <MemoizedModelDropdown featureName={featureName} className={className} />
+	return <ErrorBoundary>
+		<MemoizedModelDropdown featureName={featureName} className={className} />
+	</ErrorBoundary>
 }

src/vs/workbench/contrib/void/browser/react/src/void-tooltip/VoidTooltip.tsx

@@ -0,0 +1,125 @@
+/*--------------------------------------------------------------------------------------
+ *  Copyright 2025 Glass Devtools, Inc. All rights reserved.
+ *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
+ *--------------------------------------------------------------------------------------*/
+
+import '../styles.css'
+import { Tooltip } from 'react-tooltip';
+import 'react-tooltip/dist/react-tooltip.css';
+import { useIsDark } from '../util/services.js';
+
+/**
+ * Creates a configured global tooltip component with consistent styling
+ * To use:
+ * 1. Mount a Tooltip with some id eg id='void-tooltip'
+ * 2. Add data-tooltip-id="void-tooltip" and data-tooltip-content="Your tooltip text" to any element
+ */
+export const VoidTooltip = () => {
+
+
+	const isDark = useIsDark()
+
+	return (
+
+		// use native colors so we don't have to worry about @@void-scope styles
+		// --void-bg-1: var(--vscode-input-background);
+		// --void-bg-1-alt: var(--vscode-badge-background);
+		// --void-bg-2: var(--vscode-sideBar-background);
+		// --void-bg-2-alt: color-mix(in srgb, var(--vscode-sideBar-background) 30%, var(--vscode-editor-background) 70%);
+		// --void-bg-3: var(--vscode-editor-background);
+
+		// --void-fg-0: color-mix(in srgb, var(--vscode-tab-activeForeground) 90%, black 10%);
+		// --void-fg-1: var(--vscode-editor-foreground);
+		// --void-fg-2: var(--vscode-input-foreground);
+		// --void-fg-3: var(--vscode-input-placeholderForeground);
+		// /* --void-fg-4: var(--vscode-tab-inactiveForeground); */
+		// --void-fg-4: var(--vscode-list-deemphasizedForeground);
+
+		// --void-warning: var(--vscode-charts-yellow);
+
+		// --void-border-1: var(--vscode-commandCenter-activeBorder);
+		// --void-border-2: var(--vscode-commandCenter-border);
+		// --void-border-3: var(--vscode-commandCenter-inactiveBorder);
+		// --void-border-4: var(--vscode-editorGroup-border);
+
+		<>
+			<style>
+				{`
+				#void-tooltip, #void-tooltip-orange, #void-tooltip-green, #void-tooltip-ollama-settings {
+					font-size: 12px;
+					padding: 0px 8px;
+					border-radius: 6px;
+					z-index: 999999;
+				}
+
+				#void-tooltip {
+					background-color: var(--vscode-editor-background);
+					color: var(--vscode-input-foreground);
+				}
+
+				#void-tooltip-orange {
+					background-color: #F6762A;
+					color: white;
+				}
+
+				#void-tooltip-green {
+					background-color: #228B22;
+					color: white;
+				}
+
+				#void-tooltip-ollama-settings {
+					background-color: var(--vscode-editor-background);
+					color: var(--vscode-input-foreground);
+				}
+
+				.react-tooltip-arrow {
+					z-index: -1 !important; /* Keep arrow behind content (somehow this isnt done automatically) */
+				}
+				`}
+			</style>
+
+
+			<Tooltip
+				id="void-tooltip"
+				// border='1px solid var(--vscode-editorGroup-border)'
+				border='1px solid rgba(100,100,100,.2)'
+				opacity={1}
+				delayShow={50}
+			/>
+			<Tooltip
+				id="void-tooltip-orange"
+				border='1px solid rgba(200,200,200,.3)'
+				opacity={1}
+				delayShow={50}
+			/>
+			<Tooltip
+				id="void-tooltip-green"
+				border='1px solid rgba(200,200,200,.3)'
+				opacity={1}
+				delayShow={50}
+			/>
+			<Tooltip
+				id="void-tooltip-ollama-settings"
+				border='1px solid rgba(100,100,100,.2)'
+				opacity={1}
+				openEvents={{ mouseover: true, click: true, focus: true }}
+				place='right'
+				style={{ pointerEvents: 'all', userSelect: 'text', fontSize: 11 }}
+			>
+				<div style={{ padding: '8px 10px' }}>
+					<div style={{ opacity: 0.8, textAlign: 'center', fontWeight: 'bold', marginBottom: 8 }}>
+						Good starter models
+					</div>
+					<div style={{ marginBottom: 4 }}>
+						<span style={{ opacity: 0.8 }}>For chat:{` `}</span>
+						<span style={{ opacity: 0.8, fontWeight: 'bold' }}>llama3.1</span>
+					</div>
+					<div>
+						<span style={{ opacity: 0.8 }}>For autocomplete:{` `}</span>
+						<span style={{ opacity: 0.8, fontWeight: 'bold' }}>qwen2.5-coder:1.5b</span>
+					</div>
+				</div>
+			</Tooltip>
+		</>
+	);
+};

src/vs/workbench/contrib/void/browser/react/src/void-tooltip/index.tsx

@@ -0,0 +1,9 @@
+/*--------------------------------------------------------------------------------------
+ *  Copyright 2025 Glass Devtools, Inc. All rights reserved.
+ *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
+ *--------------------------------------------------------------------------------------*/
+
+import { mountFnGenerator } from '../util/mountFnGenerator.js'
+import { VoidTooltip } from './VoidTooltip.js'
+
+export const mountVoidTooltip = mountFnGenerator(VoidTooltip)

src/vs/workbench/contrib/void/browser/react/tsup.config.js

@@ -7,9 +7,11 @@ import { defineConfig } from 'tsup'
 
 export default defineConfig({
 	entry: [
-		'./src2/void-command-bar-tsx/index.tsx',
+		'./src2/void-editor-widgets-tsx/index.tsx',
 		'./src2/sidebar-tsx/index.tsx',
 		'./src2/void-settings-tsx/index.tsx',
+		'./src2/void-tooltip/index.tsx',
+		'./src2/void-onboarding/index.tsx',
 		'./src2/quick-edit-tsx/index.tsx',
 		'./src2/diff/index.tsx',
 	],

src/vs/workbench/contrib/void/browser/searchReplaceCacheService.ts

@@ -1,44 +0,0 @@
-/*--------------------------------------------------------------------------------------
- *  Copyright 2025 Glass Devtools, Inc. All rights reserved.
- *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
- *--------------------------------------------------------------------------------------*/
-
-import { Emitter, Event } from '../../../../base/common/event.js';
-import { Disposable } from '../../../../base/common/lifecycle.js';
-import { InstantiationType, registerSingleton } from '../../../../platform/instantiation/common/extensions.js';
-import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
-
-
-
-export interface ISearchReplaceService {
-	readonly _serviceBrand: undefined;
-}
-
-export const ISearchReplaceService = createDecorator<ISearchReplaceService>('SearchReplaceCacheService');
-export class SearchReplaceService extends Disposable implements ISearchReplaceService {
-	_serviceBrand: undefined;
-
-	private readonly _onDidChangeState = new Emitter<void>();
-	readonly onDidChangeState: Event<void> = this._onDidChangeState.event;
-
-	constructor(
-		// @ILLMMessageService private readonly llmMessageService: ILLMMessageService,
-	) {
-		super()
-	}
-
-	// send(params: ServiceSendLLMMessageParams & { onText: (p: { newText: string, fullText: string }) => { retry: boolean } }) {
-	// 	this.llmMessageService.sendLLMMessage({
-	// 		...params as ServiceSendLLMMessageParams,
-	// 		onText: (p) => {
-	// 			const { retry } = params.onText(p)
-	// 			if (retry) {
-
-	// 			}
-	// 		}
-	// 	})
-	// }
-
-}
-
-registerSingleton(ISearchReplaceService, SearchReplaceService, InstantiationType.Eager);

src/vs/workbench/contrib/void/browser/sidebarActions.ts

@@ -25,10 +25,37 @@ import { Disposable } from '../../../../base/common/lifecycle.js';
 import { localize2 } from '../../../../nls.js';
 import { StagingSelectionItem } from '../common/chatThreadServiceTypes.js';
 import { IChatThreadService } from './chatThreadService.js';
+import { getActiveWindow } from '../../../../base/browser/dom.js';
 
 // ---------- Register commands and keybindings ----------
 
 
+const findStagingSelectionIndex = (currentSelections: StagingSelectionItem[] | undefined, newSelection: StagingSelectionItem): number | null => {
+	if (!currentSelections) return null
+
+	for (let i = 0; i < currentSelections.length; i += 1) {
+		const s = currentSelections[i]
+
+		if (s.uri.fsPath !== newSelection.uri.fsPath) continue
+
+		if (s.type === 'File' && newSelection.type === 'File') {
+			return i
+		}
+		if (s.type === 'CodeSelection' && newSelection.type === 'CodeSelection') {
+			if (s.uri.fsPath !== newSelection.uri.fsPath) continue
+			// if there's any collision return true
+			const [oldStart, oldEnd] = s.range
+			const [newStart, newEnd] = newSelection.range
+			if (oldStart !== newStart || oldEnd !== newEnd) continue
+			return i
+		}
+		if (s.type === 'Folder' && newSelection.type === 'Folder') {
+			return i
+		}
+	}
+	return null
+}
+
 export const roundRangeToLines = (range: IRange | null | undefined, options: { emptySelectionBehavior: 'null' | 'line' }) => {
 	if (!range)
 		return null
@@ -63,31 +90,6 @@ export const roundRangeToLines = (range: IRange | null | undefined, options: { e
 // }
 
 
-const findStagingItemToReplace = (currentSelections: StagingSelectionItem[] | undefined, newSelection: StagingSelectionItem): [number, StagingSelectionItem] | null => {
-	if (!currentSelections) return null
-
-	for (let i = 0; i < currentSelections.length; i += 1) {
-		const s = currentSelections[i]
-
-		if (s.uri.fsPath !== newSelection.uri.fsPath) continue
-
-		if (s.type === 'File' && newSelection.type === 'File') {
-			return [i, s] as const
-		}
-		if (s.type === 'CodeSelection' && newSelection.type === 'CodeSelection') {
-			if (s.uri.fsPath !== newSelection.uri.fsPath) continue
-			// if there's any collision return true
-			const [oldStart, oldEnd] = s.range
-			const [newStart, newEnd] = newSelection.range
-			if (oldStart !== newStart || oldEnd !== newEnd) continue
-			return [i, s] as const
-		}
-		if (s.type === 'Folder' && newSelection.type === 'Folder') {
-			return [i, s] as const
-		}
-	}
-	return null
-}
 
 const VOID_OPEN_SIDEBAR_ACTION_ID = 'void.sidebar.open'
 registerAction2(class extends Action2 {
@@ -132,7 +134,7 @@ registerAction2(class extends Action2 {
 		}
 
 
-		const selection: StagingSelectionItem = !selectionRange || (selectionRange.startLineNumber > selectionRange.endLineNumber) ? {
+		const newSelection: StagingSelectionItem = !selectionRange || (selectionRange.startLineNumber > selectionRange.endLineNumber) ? {
 			type: 'File',
 			uri: model.uri,
 			language: model.getLanguageId(),
@@ -163,21 +165,17 @@ registerAction2(class extends Action2 {
 		}
 
 		// if matches with existing selection, overwrite (since text may change)
-		const replaceRes = findStagingItemToReplace(selections, selection)
-		if (replaceRes) {
-			const [idx, newSel] = replaceRes
-
-			if (idx !== undefined && idx !== -1) {
-				setSelections([
-					...selections!.slice(0, idx),
-					newSel,
-					...selections!.slice(idx + 1, Infinity)
-				])
-			}
+		const idx = findStagingSelectionIndex(selections, newSelection)
+		if (idx !== null && idx !== -1) {
+			setSelections([
+				...selections!.slice(0, idx),
+				newSelection,
+				...selections!.slice(idx + 1, Infinity)
+			])
 		}
 		// if no match, add it
 		else {
-			setSelections([...(selections ?? []), selection])
+			setSelections([...(selections ?? []), newSelection])
 		}
 
 	}
@@ -189,7 +187,7 @@ registerAction2(class extends Action2 {
 		super({
 			id: VOID_CTRL_L_ACTION_ID,
 			f1: true,
-			title: localize2('voidCtrlL', 'Void: Add Select to Chat'),
+			title: localize2('voidCtrlL', 'Void: Add Selection to Chat'),
 			keybinding: {
 				primary: KeyMod.CtrlCmd | KeyCode.KeyL,
 				weight: KeybindingWeight.VoidExtension
@@ -228,9 +226,13 @@ registerAction2(class extends Action2 {
 		metricsService.capture('Chat Navigation', { type: 'New Chat' })
 
 		stateService.setState({ isHistoryOpen: false, currentTab: 'chat' })
-		stateService.fireFocusChat()
 		const chatThreadService = accessor.get(IChatThreadService)
 		chatThreadService.openNewThread()
+
+		// focus
+		stateService.fireFocusChat()
+		const window = getActiveWindow()
+		window.requestAnimationFrame(() => stateService.fireFocusChat())
 	}
 })
 

src/vs/workbench/contrib/void/browser/sidebarPane.ts

@@ -108,7 +108,7 @@ export const VOID_VIEW_ID = VOID_VIEW_CONTAINER_ID
 const viewContainerRegistry = Registry.as<IViewContainersRegistry>(ViewContainerExtensions.ViewContainersRegistry);
 const container = viewContainerRegistry.registerViewContainer({
 	id: VOID_VIEW_CONTAINER_ID,
-	title: nls.localize2('voidContainer', 'Void Chat'), // this is used to say "Void" (Ctrl + L)
+	title: nls.localize2('voidContainer', 'Chat'), // this is used to say "Void" (Ctrl + L)
 	ctorDescriptor: new SyncDescriptor(ViewPaneContainer, [VOID_VIEW_CONTAINER_ID, {
 		mergeViewWithContainerWhenSingleView: true,
 		orientation: Orientation.HORIZONTAL,

src/vs/workbench/contrib/void/browser/toolsService.ts

@@ -8,14 +8,17 @@ import { QueryBuilder } from '../../../services/search/common/queryBuilder.js'
 import { ISearchService } from '../../../services/search/common/search.js'
 import { IEditCodeService } from './editCodeServiceInterface.js'
 import { ITerminalToolService } from './terminalToolService.js'
-import { ToolCallParams, ToolName, ToolResultType } from '../common/toolsServiceTypes.js'
+import { LintErrorItem, ToolCallParams, ToolResultType } from '../common/toolsServiceTypes.js'
 import { IVoidModelService } from '../common/voidModelService.js'
 import { EndOfLinePreference } from '../../../../editor/common/model.js'
 import { basename } from '../../../../base/common/path.js'
 import { IVoidCommandBarService } from './voidCommandBarService.js'
 import { computeDirectoryTree1Deep, IDirectoryStrService, stringifyDirectoryTree1Deep } from './directoryStrService.js'
-import { IMarkerService } from '../../../../platform/markers/common/markers.js'
+import { IMarkerService, MarkerSeverity } from '../../../../platform/markers/common/markers.js'
 import { timeout } from '../../../../base/common/async.js'
+import { RawToolParamsObj } from '../common/sendLLMMessageTypes.js'
+import { ToolName } from '../common/prompt/prompts.js'
+import { IVoidSettingsService } from '../common/voidSettingsService.js'
 
 
 // tool use for AI
@@ -23,7 +26,7 @@ import { timeout } from '../../../../base/common/async.js'
 
 
 
-type ValidateParams = { [T in ToolName]: (p: string) => Promise<ToolCallParams[T]> }
+type ValidateParams = { [T in ToolName]: (p: RawToolParamsObj) => ToolCallParams[T] }
 type CallTool = { [T in ToolName]: (p: ToolCallParams[T]) => Promise<{ result: ToolResultType[T], interruptTool?: () => void }> }
 type ToolResultToString = { [T in ToolName]: (p: ToolCallParams[T], result: Awaited<ToolResultType[T]>) => string }
 
@@ -31,38 +34,19 @@ type ToolResultToString = { [T in ToolName]: (p: ToolCallParams[T], result: Awai
 
 
 // pagination info
-export const MAX_FILE_CHARS_PAGE = 50_000
+export const MAX_FILE_CHARS_PAGE = Infinity
 export const MAX_CHILDREN_URIs_PAGE = 500
 export const MAX_TERMINAL_CHARS_PAGE = 20_000
-export const TERMINAL_TIMEOUT_TIME = 15
+export const TERMINAL_TIMEOUT_TIME = 5 // seconds
 export const TERMINAL_BG_WAIT_TIME = 1
 
 
-
-
-
-const validateJSON = (s: string): { [s: string]: unknown } => {
-	try {
-		const o = JSON.parse(s)
-		if (typeof o !== 'object') throw new Error()
-
-		if ('result' in o) { // openrouter sometimes wraps the result with { 'result': ... }
-			return o.result
-		}
-
-		return o
-	}
-	catch (e) {
-		throw new Error(`Invalid LLM output format: Tool parameter was not a string of a valid JSON: "${s}".`)
-	}
-}
-
 const isFalsy = (u: unknown) => {
 	return !u || u === 'null' || u === 'undefined'
 }
 
 const validateStr = (argName: string, value: unknown) => {
-	if (typeof value !== 'string') throw new Error(`Invalid LLM output format: ${argName} must be a string.`)
+	if (typeof value !== 'string') throw new Error(`Invalid LLM output format: ${argName} must be a string, but it's a ${typeof value}. Value: ${value}.`)
 	return value
 }
 
@@ -70,7 +54,7 @@ const validateStr = (argName: string, value: unknown) => {
 // We are NOT checking to make sure in workspace
 // TODO!!!! check to make sure folder/file exists
 const validateURI = (uriStr: unknown) => {
-	if (typeof uriStr !== 'string') throw new Error('Invalid LLM output format: Provided uri must be a string.')
+	if (typeof uriStr !== 'string') throw new Error(`Invalid LLM output format: Provided uri must be a string, but it's a ${typeof uriStr}. Value: ${uriStr}.`)
 	const uri = URI.file(uriStr)
 	return uri
 }
@@ -109,6 +93,7 @@ const validateNumber = (numStr: unknown, opts: { default: number | null }) => {
 }
 
 const validateRecursiveParamStr = (paramsUnknown: unknown) => {
+	if (!paramsUnknown) return false
 	if (typeof paramsUnknown !== 'string') throw new Error('Invalid LLM output format: Error calling tool: provided params must be a string.')
 	const params = paramsUnknown
 	const isRecursive = params.includes('r')
@@ -167,60 +152,58 @@ export class ToolsService implements IToolsService {
 		@IVoidCommandBarService private readonly commandBarService: IVoidCommandBarService,
 		@IDirectoryStrService private readonly directoryStrService: IDirectoryStrService,
 		@IMarkerService private readonly markerService: IMarkerService,
+		@IVoidSettingsService private readonly voidSettingsService: IVoidSettingsService,
 	) {
 
 		const queryBuilder = instantiationService.createInstance(QueryBuilder);
 
 		this.validateParams = {
-			read_file: async (params: string) => {
-				const o = validateJSON(params)
-				const { uri: uriStr, startLine: startLineUnknown, endLine: endLineUnknown, pageNumber: pageNumberUnknown } = o
-
+			read_file: (params: RawToolParamsObj) => {
+				const { uri: uriStr, start_line: startLineUnknown, end_line: endLineUnknown, page_number: pageNumberUnknown } = params
 				const uri = validateURI(uriStr)
 				const pageNumber = validatePageNum(pageNumberUnknown)
 
-				const startLine = validateNumber(startLineUnknown, { default: null })
-				const endLine = validateNumber(endLineUnknown, { default: null })
+				let startLine = validateNumber(startLineUnknown, { default: null })
+				let endLine = validateNumber(endLineUnknown, { default: null })
+
+				if (startLine !== null && startLine < 1) startLine = null
+				if (endLine !== null && endLine < 1) endLine = null
 
 				return { uri, startLine, endLine, pageNumber }
 			},
-			ls_dir: async (params: string) => {
-				const o = validateJSON(params)
-				const { uri: uriStr, pageNumber: pageNumberUnknown } = o
+			ls_dir: (params: RawToolParamsObj) => {
+				const { uri: uriStr, page_number: pageNumberUnknown } = params
 
 				const uri = validateURI(uriStr)
 				const pageNumber = validatePageNum(pageNumberUnknown)
 				return { rootURI: uri, pageNumber }
 			},
-			get_dir_structure: async (params: string) => {
-				const o = validateJSON(params)
-				const { uri: uriStr, } = o
+			get_dir_structure: (params: RawToolParamsObj) => {
+				const { uri: uriStr, } = params
 				const uri = validateURI(uriStr)
 				return { rootURI: uri }
 			},
-			search_pathnames_only: async (params: string) => {
-				const o = validateJSON(params)
+			search_pathnames_only: (params: RawToolParamsObj) => {
 				const {
 					query: queryUnknown,
-					include: includeUnknown,
-					pageNumber: pageNumberUnknown
-				} = o
+					search_in_folder: includeUnknown,
+					page_number: pageNumberUnknown
+				} = params
 
 				const queryStr = validateStr('query', queryUnknown)
 				const pageNumber = validatePageNum(pageNumberUnknown)
-				const include = validateOptionalStr('include', includeUnknown)
+				const searchInFolder = validateOptionalStr('search_in_folder', includeUnknown)
 
-				return { queryStr, include, pageNumber }
+				return { queryStr, searchInFolder, pageNumber }
 
 			},
-			search_files: async (params: string) => {
-				const o = validateJSON(params)
+			search_for_files: (params: RawToolParamsObj) => {
 				const {
 					query: queryUnknown,
-					searchInFolder: searchInFolderUnknown,
-					isRegex: isRegexUnknown,
-					pageNumber: pageNumberUnknown
-				} = o
+					search_in_folder: searchInFolderUnknown,
+					is_regex: isRegexUnknown,
+					page_number: pageNumberUnknown
+				} = params
 
 				const queryStr = validateStr('query', queryUnknown)
 				const pageNumber = validatePageNum(pageNumberUnknown)
@@ -231,20 +214,26 @@ export class ToolsService implements IToolsService {
 				return { queryStr, searchInFolder, isRegex, pageNumber }
 			},
 
+			read_lint_errors: (params: RawToolParamsObj) => {
+				const {
+					uri: uriUnknown,
+				} = params
+				const uri = validateURI(uriUnknown)
+				return { uri }
+			},
+
 			// ---
 
-			create_file_or_folder: async (params: string) => {
-				const o = validateJSON(params)
-				const { uri: uriUnknown } = o
+			create_file_or_folder: (params: RawToolParamsObj) => {
+				const { uri: uriUnknown } = params
 				const uri = validateURI(uriUnknown)
 				const uriStr = validateStr('uri', uriUnknown)
 				const isFolder = checkIfIsFolder(uriStr)
 				return { uri, isFolder }
 			},
 
-			delete_file_or_folder: async (params: string) => {
-				const o = validateJSON(params)
-				const { uri: uriUnknown, params: paramsStr } = o
+			delete_file_or_folder: (params: RawToolParamsObj) => {
+				const { uri: uriUnknown, params: paramsStr } = params
 				const uri = validateURI(uriUnknown)
 				const isRecursive = validateRecursiveParamStr(paramsStr)
 				const uriStr = validateStr('uri', uriUnknown)
@@ -252,17 +241,15 @@ export class ToolsService implements IToolsService {
 				return { uri, isRecursive, isFolder }
 			},
 
-			edit_file: async (params: string) => {
-				const o = validateJSON(params)
-				const { uri: uriStr, changeDescription: changeDescriptionUnknown } = o
+			edit_file: (params: RawToolParamsObj) => {
+				const { uri: uriStr, change_description: changeDescriptionUnknown } = params
 				const uri = validateURI(uriStr)
 				const changeDescription = validateStr('changeDescription', changeDescriptionUnknown)
 				return { uri, changeDescription }
 			},
 
-			run_terminal_command: async (s: string) => {
-				const o = validateJSON(s)
-				const { command: commandUnknown, terminalId: terminalIdUnknown, waitForCompletion: waitForCompletionUnknown } = o
+			run_terminal_command: (params: RawToolParamsObj) => {
+				const { command: commandUnknown, terminal_id: terminalIdUnknown, wait_for_completion: waitForCompletionUnknown } = params
 				const command = validateStr('command', commandUnknown)
 				const proposedTerminalId = validateProposedTerminalId(terminalIdUnknown)
 				const waitForCompletion = validateBoolean(waitForCompletionUnknown, { default: true })
@@ -292,8 +279,8 @@ export class ToolsService implements IToolsService {
 				const toIdx = MAX_FILE_CHARS_PAGE * pageNumber - 1
 				const fileContents = contents.slice(fromIdx, toIdx + 1) // paginate
 				const hasNextPage = (contents.length - 1) - toIdx >= 1
-
-				return { result: { fileContents, hasNextPage } }
+				const totalFileLen = contents.length
+				return { result: { fileContents, totalFileLen, hasNextPage } }
 			},
 
 			ls_dir: async ({ rootURI, pageNumber }) => {
@@ -302,17 +289,15 @@ export class ToolsService implements IToolsService {
 			},
 
 			get_dir_structure: async ({ rootURI }) => {
-				const result = await this.directoryStrService.getDirectoryStrTool(rootURI)
-				let str = result.str
-				if (result.wasCutOff) str += '\n(Result was truncated)'
+				const str = await this.directoryStrService.getDirectoryStrTool(rootURI)
 				return { result: { str } }
 			},
 
-			search_pathnames_only: async ({ queryStr, include, pageNumber }) => {
+			search_pathnames_only: async ({ queryStr, searchInFolder, pageNumber }) => {
 
 				const query = queryBuilder.file(workspaceContextService.getWorkspace().folders.map(f => f.uri), {
 					filePattern: queryStr,
-					includePattern: include ?? undefined,
+					includePattern: searchInFolder ?? undefined,
 				})
 				const data = await searchService.fileSearch(query, CancellationToken.None)
 
@@ -326,7 +311,7 @@ export class ToolsService implements IToolsService {
 				return { result: { uris, hasNextPage } }
 			},
 
-			search_files: async ({ queryStr, isRegex, searchInFolder, pageNumber }) => {
+			search_for_files: async ({ queryStr, isRegex, searchInFolder, pageNumber }) => {
 				const searchFolders = searchInFolder === null ?
 					workspaceContextService.getWorkspace().folders.map(f => f.uri)
 					: [searchInFolder]
@@ -348,6 +333,12 @@ export class ToolsService implements IToolsService {
 				return { result: { queryStr, uris, hasNextPage } }
 			},
 
+			read_lint_errors: async ({ uri }) => {
+				await timeout(1000)
+				const { lintErrors } = this._getLintErrors(uri)
+				return { result: { lintErrors } }
+			},
+
 			// ---
 
 			create_file_or_folder: async ({ uri, isFolder }) => {
@@ -385,15 +376,11 @@ export class ToolsService implements IToolsService {
 					editCodeService.interruptURIStreaming({ uri: diffZoneURI })
 				}
 
+				// at end, get lint errors
 				const lintErrorsPromise = applyDonePromise.then(async () => {
-					await timeout(500)
-					const lintErrorsStr = this.markerService
-						.read({ resource: uri })
-						.map(l => l.message)
-						.join('\n')
-
-					if (!lintErrorsStr) return { lintErrorsStr: null }
-					return { lintErrorsStr }
+					await timeout(2000)
+					const { lintErrors } = this._getLintErrors(uri)
+					return { lintErrors }
 				})
 
 				return { result: lintErrorsPromise, interruptTool }
@@ -407,10 +394,16 @@ export class ToolsService implements IToolsService {
 
 		const nextPageStr = (hasNextPage: boolean) => hasNextPage ? '\n\n(more on next page...)' : ''
 
+		const stringifyLintErrors = (lintErrors: LintErrorItem[]) => {
+			return lintErrors
+				.map((e, i) => `Error ${i + 1}:\nLines Affected: ${e.startLineNumber}-${e.endLineNumber}\nError message:${e.message}`)
+				.join('\n\n')
+		}
+
 		// given to the LLM after the call
 		this.stringOfResult = {
 			read_file: (params, result) => {
-				return result.fileContents + nextPageStr(result.hasNextPage)
+				return `${params.uri.fsPath}\n\`\`\`\n${result.fileContents}\n\`\`\`${nextPageStr(result.hasNextPage)}`
 			},
 			ls_dir: (params, result) => {
 				const dirTreeStr = stringifyDirectoryTree1Deep(params, result)
@@ -422,9 +415,14 @@ export class ToolsService implements IToolsService {
 			search_pathnames_only: (params, result) => {
 				return result.uris.map(uri => uri.fsPath).join('\n') + nextPageStr(result.hasNextPage)
 			},
-			search_files: (params, result) => {
+			search_for_files: (params, result) => {
 				return result.uris.map(uri => uri.fsPath).join('\n') + nextPageStr(result.hasNextPage)
 			},
+			read_lint_errors: (params, result) => {
+				return result.lintErrors ?
+					stringifyLintErrors(result.lintErrors)
+					: 'No lint errors found.'
+			},
 			// ---
 			create_file_or_folder: (params, result) => {
 				return `URI ${params.uri.fsPath} successfully created.`
@@ -433,8 +431,13 @@ export class ToolsService implements IToolsService {
 				return `URI ${params.uri.fsPath} successfully deleted.`
 			},
 			edit_file: (params, result) => {
-				const additionalStr = result.lintErrorsStr ? `Lint errors found after change:\n${result.lintErrorsStr}.\nIf this is related to a change made while calling this tool, you might want to fix the error.` : `No lint errors found.`
-				return `Change successfully made to ${params.uri.fsPath}. ${additionalStr}`
+				const lintErrsString = (
+					this.voidSettingsService.state.globalSettings.includeToolLintErrors ?
+						(result.lintErrors ? ` Lint errors found after change:\n${stringifyLintErrors(result.lintErrors)}.\nIf this is related to a change made while calling this tool, you might want to fix the error.`
+							: ` No lint errors found.`)
+						: '')
+
+				return `Change successfully made to ${params.uri.fsPath}.${lintErrsString}`
 			},
 			run_terminal_command: (params, result) => {
 				const {
@@ -447,7 +450,7 @@ export class ToolsService implements IToolsService {
 				const terminalDesc = `terminal ${terminalId}${didCreateTerminal ? ` (a newly-created terminal)` : ''}`
 
 				if (resolveReason.type === 'timeout') {
-					return `Terminal command ran in ${terminalDesc}, but timed out after ${TERMINAL_TIMEOUT_TIME} seconds. Result:\n${result_}`
+					return `Terminal command ran in ${terminalDesc}, but did not complete after ${TERMINAL_TIMEOUT_TIME} seconds. Result:\n${result_}`
 				}
 				else if (resolveReason.type === 'bgtask') {
 					return `Terminal command is running in the background in ${terminalDesc}. Here were the outputs after ${TERMINAL_BG_WAIT_TIME} seconds:\n${result_}`
@@ -468,6 +471,22 @@ export class ToolsService implements IToolsService {
 	}
 
 
+	private _getLintErrors(uri: URI): { lintErrors: LintErrorItem[] | null } {
+		const lintErrors = this.markerService
+			.read({ resource: uri })
+			.filter(l => l.severity === MarkerSeverity.Error || l.severity === MarkerSeverity.Warning)
+			.map(l => ({
+				code: typeof l.code === 'string' ? l.code : l.code?.value || '',
+				message: (l.severity === MarkerSeverity.Error ? '(error) ' : '(warning) ') + l.message,
+				startLineNumber: l.startLineNumber,
+				endLineNumber: l.endLineNumber,
+			} satisfies LintErrorItem))
+
+		if (!lintErrors.length) return { lintErrors: null }
+		return { lintErrors, }
+	}
+
+
 }
 
 registerSingleton(IToolsService, ToolsService, InstantiationType.Eager);

src/vs/workbench/contrib/void/browser/tooltipService.ts

@@ -0,0 +1,55 @@
+/*--------------------------------------------------------------------------------------
+ *  Copyright 2025 Glass Devtools, Inc. All rights reserved.
+ *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
+ *--------------------------------------------------------------------------------------*/
+
+import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IWorkbenchContribution, registerWorkbenchContribution2, WorkbenchPhase } from '../../../common/contributions.js';
+import { ServicesAccessor } from '../../../../editor/browser/editorExtensions.js';
+import { mountVoidTooltip } from './react/out/void-tooltip/index.js';
+import { h, getActiveWindow } from '../../../../base/browser/dom.js';
+
+// Tooltip contribution that mounts the component at startup
+export class TooltipContribution extends Disposable implements IWorkbenchContribution {
+	static readonly ID = 'workbench.contrib.voidTooltip';
+
+	constructor(
+		@IInstantiationService private readonly instantiationService: IInstantiationService,
+	) {
+		super();
+		this.initializeTooltip();
+	}
+
+	private initializeTooltip(): void {
+		// Get the active window reference for multi-window support
+		const targetWindow = getActiveWindow();
+
+		// Find the monaco-workbench element using the proper window reference
+		const workbench = targetWindow.document.querySelector('.monaco-workbench');
+
+		if (workbench) {
+			// Create a container element for the tooltip using h function
+			const tooltipContainer = h('div.void-tooltip-container').root;
+			workbench.appendChild(tooltipContainer);
+
+			// Mount the React component
+			this.instantiationService.invokeFunction((accessor: ServicesAccessor) => {
+				const result = mountVoidTooltip(tooltipContainer, accessor);
+				if (result && typeof result.dispose === 'function') {
+					this._register(toDisposable(result.dispose));
+				}
+			});
+
+			// Register cleanup for the DOM element
+			this._register(toDisposable(() => {
+				if (tooltipContainer.parentElement) {
+					tooltipContainer.parentElement.removeChild(tooltipContainer);
+				}
+			}));
+		}
+	}
+}
+
+// Register the contribution to be initialized during the AfterRestored phase
+registerWorkbenchContribution2(TooltipContribution.ID, TooltipContribution, WorkbenchPhase.AfterRestored);

src/vs/workbench/contrib/void/browser/void.contribution.ts

@@ -32,6 +32,7 @@ import './media/void.css'
 // update (frontend part, also see platform/)
 import './voidUpdateActions.js'
 
+import './convertToLLMMessageWorkbenchContrib.js'
 
 // tools
 import './toolsService.js'
@@ -46,6 +47,15 @@ import './metricsPollService.js'
 // helper services
 import './helperServices/consistentItemService.js'
 
+// register selection helper
+import './voidSelectionHelperWidget.js'
+
+// register tooltip service
+import './tooltipService.js'
+
+// register onboarding service
+import './voidOnboardingService.js'
+
 // ---------- common (unclear if these actually need to be imported, because they're already imported wherever they're used) ----------
 
 // llmMessage

src/vs/workbench/contrib/void/browser/voidCommandBarService.ts

@@ -11,7 +11,7 @@ import { Widget } from '../../../../base/browser/ui/widget.js';
 import { IOverlayWidget, ICodeEditor, OverlayWidgetPositionPreference } from '../../../../editor/browser/editorBrowser.js';
 import { Emitter, Event } from '../../../../base/common/event.js';
 import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.js';
-import { mountVoidCommandBar } from './react/out/void-command-bar-tsx/index.js'
+import { mountVoidCommandBar } from './react/out/void-editor-widgets-tsx/index.js'
 import { deepClone } from '../../../../base/common/objects.js';
 import { InstantiationType, registerSingleton } from '../../../../platform/instantiation/common/extensions.js';
 import { IEditCodeService } from './editCodeServiceInterface.js';
@@ -362,8 +362,6 @@ export class VoidCommandBarService extends Disposable implements IVoidCommandBar
 
 registerSingleton(IVoidCommandBarService, VoidCommandBarService, InstantiationType.Delayed); // delayed is needed here :(
 
-// registerWorkbenchContribution2(VoidCommandBarService.ID, VoidCommandBarService, WorkbenchPhase.BlockRestore);
-
 
 export type VoidCommandBarProps = {
 	uri: URI | null;

src/vs/workbench/contrib/void/browser/voidOnboardingService.ts

@@ -0,0 +1,52 @@
+/*--------------------------------------------------------------------------------------
+ *  Copyright 2025 Glass Devtools, Inc. All rights reserved.
+ *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
+ *--------------------------------------------------------------------------------------*/
+
+import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IWorkbenchContribution, registerWorkbenchContribution2, WorkbenchPhase } from '../../../common/contributions.js';
+import { ServicesAccessor } from '../../../../editor/browser/editorExtensions.js';
+import { mountVoidOnboarding } from './react/out/void-onboarding/index.js'
+import { h, getActiveWindow } from '../../../../base/browser/dom.js';
+
+// Onboarding contribution that mounts the component at startup
+export class OnboardingContribution extends Disposable implements IWorkbenchContribution {
+	static readonly ID = 'workbench.contrib.voidOnboarding';
+
+	constructor(
+		@IInstantiationService private readonly instantiationService: IInstantiationService,
+	) {
+		super();
+		this.initialize();
+	}
+
+	private initialize(): void {
+		// Get the active window reference for multi-window support
+		const targetWindow = getActiveWindow();
+
+		// Find the monaco-workbench element using the proper window reference
+		const workbench = targetWindow.document.querySelector('.monaco-workbench');
+
+		if (workbench) {
+
+			const onboardingContainer = h('div.void-onboarding-container').root;
+			workbench.appendChild(onboardingContainer);
+			this.instantiationService.invokeFunction((accessor: ServicesAccessor) => {
+				const result = mountVoidOnboarding(onboardingContainer, accessor);
+				if (result && typeof result.dispose === 'function') {
+					this._register(toDisposable(result.dispose));
+				}
+			});
+			// Register cleanup for the DOM element
+			this._register(toDisposable(() => {
+				if (onboardingContainer.parentElement) {
+					onboardingContainer.parentElement.removeChild(onboardingContainer);
+				}
+			}));
+		}
+	}
+}
+
+// Register the contribution to be initialized during the AfterRestored phase
+registerWorkbenchContribution2(OnboardingContribution.ID, OnboardingContribution, WorkbenchPhase.AfterRestored);

src/vs/workbench/contrib/void/browser/voidSelectionHelperWidget.ts

@@ -0,0 +1,282 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Disposable, IDisposable } from '../../../../base/common/lifecycle.js';
+import { ICodeEditor, IOverlayWidget, IOverlayWidgetPosition } from '../../../../editor/browser/editorBrowser.js';
+import { EditorContributionInstantiation, registerEditorContribution } from '../../../../editor/browser/editorExtensions.js';
+import { ICursorSelectionChangedEvent } from '../../../../editor/common/cursorEvents.js';
+import { IEditorContribution } from '../../../../editor/common/editorCommon.js';
+import { Selection } from '../../../../editor/common/core/selection.js';
+import { RunOnceScheduler } from '../../../../base/common/async.js';
+import * as dom from '../../../../base/browser/dom.js';
+import { mountVoidSelectionHelper } from './react/out/void-editor-widgets-tsx/index.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IVoidSettingsService } from '../common/voidSettingsService.js';
+import { EditorOption } from '../../../../editor/common/config/editorOptions.js';
+import { getLengthOfTextPx } from './editCodeService.js';
+
+
+const minDistanceFromRightPx = 400;
+const minLeftPx = 60;
+
+
+export type VoidSelectionHelperProps = {
+	rerenderKey: number // alternates between 0 and 1
+}
+
+
+export class SelectionHelperContribution extends Disposable implements IEditorContribution, IOverlayWidget {
+	public static readonly ID = 'editor.contrib.voidSelectionHelper';
+	// react
+	private _rootHTML: HTMLElement;
+	private _rerender: (props?: any) => void = () => { };
+	private _rerenderKey: number = 0;
+	private _reactComponentDisposable: IDisposable | null = null;
+
+	// internal
+	private _isVisible = false;
+	private _showScheduler: RunOnceScheduler;
+	private _lastSelection: Selection | null = null;
+
+	constructor(
+		private readonly _editor: ICodeEditor,
+		@IInstantiationService private readonly _instantiationService: IInstantiationService,
+		@IVoidSettingsService private readonly _voidSettingsService: IVoidSettingsService
+	) {
+		super();
+
+		// Create the container element for React component
+		const { root, content } = dom.h('div@root', [
+			dom.h('div@content', [])
+		]);
+
+		// Set styles for container
+		root.style.position = 'absolute';
+		root.style.display = 'none'; // Start hidden
+		root.style.pointerEvents = 'none';
+		root.style.marginLeft = '16px';
+
+		// Initialize React component
+		this._instantiationService.invokeFunction(accessor => {
+			if (this._reactComponentDisposable) {
+				this._reactComponentDisposable.dispose();
+			}
+			const res = mountVoidSelectionHelper(content, accessor);
+			if (!res) return;
+
+			this._reactComponentDisposable = res;
+			this._rerender = res.rerender;
+
+			this._register(this._reactComponentDisposable);
+
+
+		});
+
+		this._rootHTML = root;
+
+		// Register as overlay widget
+		this._editor.addOverlayWidget(this);
+
+		// Use scheduler to debounce showing widget
+		this._showScheduler = new RunOnceScheduler(() => {
+			if (this._lastSelection) {
+				this._showHelperForSelection(this._lastSelection);
+			}
+		}, 50);
+
+		// Register event listeners
+		this._register(this._editor.onDidChangeCursorSelection(e => this._onSelectionChange(e)));
+
+		// Add a flag to track if mouse is over the widget
+		let isMouseOverWidget = false;
+		this._rootHTML.addEventListener('mouseenter', () => {
+			isMouseOverWidget = true;
+		});
+		this._rootHTML.addEventListener('mouseleave', () => {
+			isMouseOverWidget = false;
+		});
+
+		// Only hide helper when text editor loses focus and mouse is not over the widget
+		this._register(this._editor.onDidBlurEditorText(() => {
+			if (!isMouseOverWidget) {
+				this._hideHelper();
+			}
+		}));
+
+		this._register(this._editor.onDidScrollChange(() => this._updatePositionIfVisible()));
+		this._register(this._editor.onDidLayoutChange(() => this._updatePositionIfVisible()));
+	}
+
+	// IOverlayWidget implementation
+	public getId(): string {
+		return SelectionHelperContribution.ID;
+	}
+
+	public getDomNode(): HTMLElement {
+		return this._rootHTML;
+	}
+
+	public getPosition(): IOverlayWidgetPosition | null {
+		return null; // We position manually
+	}
+
+	private _onSelectionChange(e: ICursorSelectionChangedEvent): void {
+		if (!this._editor.hasModel()) {
+			return;
+		}
+
+		if (this._editor.getModel().uri.scheme !== 'file') {
+			return;
+		}
+
+		const selection = this._editor.getSelection();
+
+		if (!selection || selection.isEmpty()) {
+			this._hideHelper();
+			return;
+		}
+
+		// Get selection text to check if it's worth showing the helper
+		const text = this._editor.getModel()!.getValueInRange(selection);
+		if (text.length < 3) {
+			this._hideHelper();
+			return;
+		}
+
+		// Store selection
+		this._lastSelection = new Selection(
+			selection.startLineNumber,
+			selection.startColumn,
+			selection.endLineNumber,
+			selection.endColumn
+		);
+
+		this._showScheduler.schedule();
+	}
+
+	// Update the _showHelperForSelection method to work with the React component
+	private _showHelperForSelection(selection: Selection): void {
+		if (!this._editor.hasModel()) {
+			return;
+		}
+
+		const model = this._editor.getModel()!;
+
+		// get the longest length of the nearest neighbors of the target
+		const { tabSize: numSpacesInTab } = model.getFormattingOptions();
+		const spaceWidth = this._editor.getOption(EditorOption.fontInfo).spaceWidth;
+		const tabWidth = numSpacesInTab * spaceWidth;
+		const numLinesModel = model.getLineCount()
+
+		// Calculate right edge of visible editor area
+		const editorWidthPx = this._editor.getLayoutInfo().width;
+		const maxLeftPx = editorWidthPx - minDistanceFromRightPx
+
+		// returns the position where the box should go on the targetLine
+		const getBoxPosition = (targetLine: number): { top: number, left: number } => {
+
+			const targetPosition = this._editor.getScrolledVisiblePosition({ lineNumber: targetLine, column: 1 }) ?? { left: 0, top: 0 };
+
+			const { top: targetTop, left: targetLeft } = targetPosition
+
+			let targetWidth = 0;
+			for (let i = targetLine; i <= targetLine + 1; i++) {
+
+				// if not in range, continue
+				if (!(i >= 1) || !(i <= numLinesModel)) continue;
+
+				const content = model.getLineContent(i);
+				const currWidth = getLengthOfTextPx({
+					tabWidth,
+					spaceWidth,
+					content
+				})
+
+				targetWidth = Math.max(targetWidth, currWidth);
+			}
+
+			return {
+				top: targetTop,
+				left: targetLeft + targetWidth,
+			};
+
+		}
+
+
+		// Calculate the middle line of the selection
+		const startLine = selection.startLineNumber;
+		const endLine = selection.endLineNumber;
+		// const middleLine = Math.floor(startLine + (endLine - startLine) / 2);
+		const targetLine = endLine - startLine + 1 <= 2 ? startLine : startLine + 2;
+
+		let boxPos = getBoxPosition(targetLine);
+
+		// if the position of the box is too far to the right, keep searching for a good position
+		const lineDeltasToTry = [-1, -2, -3, 1, 2, 3];
+
+		if (boxPos.left > maxLeftPx) {
+			for (const lineDelta of lineDeltasToTry) {
+
+				boxPos = getBoxPosition(targetLine + lineDelta);
+				if (boxPos.left <= maxLeftPx) {
+					break;
+				}
+			}
+		}
+		if (boxPos.left > maxLeftPx) { // if still not found, make it 2 lines before
+			boxPos = getBoxPosition(targetLine - 2)
+		}
+
+
+		// Position the helper element at the end of the middle line but ensure it's visible
+		const xPosition = Math.max(Math.min(boxPos.left, maxLeftPx), minLeftPx);
+		const yPosition = boxPos.top;
+
+		// Update the React component position
+		this._rootHTML.style.left = `${xPosition}px`;
+		this._rootHTML.style.top = `${yPosition}px`;
+		this._rootHTML.style.display = 'flex'; // Show the container
+
+		this._isVisible = true;
+
+		// rerender
+		const enabled = this._voidSettingsService.state.globalSettings.showInlineSuggestions
+			&& this._editor.hasTextFocus() // needed since VS Code counts unfocused selections as selections, which causes this to rerender when it shouldnt (bad ux)
+
+		if (enabled) {
+			this._rerender({ rerenderKey: this._rerenderKey } satisfies VoidSelectionHelperProps)
+			this._rerenderKey = (this._rerenderKey + 1) % 2;
+			// this._reactComponentRerender();
+		}
+
+	}
+
+	private _hideHelper(): void {
+		this._rootHTML.style.display = 'none';
+		this._isVisible = false;
+		this._lastSelection = null;
+	}
+
+	private _updatePositionIfVisible(): void {
+		if (!this._isVisible || !this._lastSelection || !this._editor.hasModel()) {
+			return;
+		}
+
+		this._showHelperForSelection(this._lastSelection);
+	}
+
+	override dispose(): void {
+		this._hideHelper();
+		if (this._reactComponentDisposable) {
+			this._reactComponentDisposable.dispose();
+		}
+		this._editor.removeOverlayWidget(this);
+		this._showScheduler.dispose();
+		super.dispose();
+	}
+}
+
+// Register the contribution
+registerEditorContribution(SelectionHelperContribution.ID, SelectionHelperContribution, EditorContributionInstantiation.Eager);

src/vs/workbench/contrib/void/browser/voidUpdateActions.ts

@@ -8,57 +8,121 @@ import Severity from '../../../../base/common/severity.js';
 import { ServicesAccessor } from '../../../../editor/browser/editorExtensions.js';
 import { localize2 } from '../../../../nls.js';
 import { Action2, registerAction2 } from '../../../../platform/actions/common/actions.js';
-import { INotificationService } from '../../../../platform/notification/common/notification.js';
+import { INotificationActions, INotificationService } from '../../../../platform/notification/common/notification.js';
 import { IMetricsService } from '../common/metricsService.js';
 import { IVoidUpdateService } from '../common/voidUpdateService.js';
 import { IWorkbenchContribution, registerWorkbenchContribution2, WorkbenchPhase } from '../../../common/contributions.js';
 import * as dom from '../../../../base/browser/dom.js';
+import { IUpdateService } from '../../../../platform/update/common/update.js';
+import { VoidCheckUpdateRespose } from '../common/voidUpdateServiceTypes.js';
+import { IAction } from '../../../../base/common/actions.js';
 
 
 
 
-const notifyYesUpdate = (notifService: INotificationService, res: { message?: string } = {}) => {
+const notifyUpdate = (res: VoidCheckUpdateRespose & { message: string }, notifService: INotificationService, updateService: IUpdateService) => {
 	const message = res?.message || 'This is a very old version of Void, please download the latest version! [Void Editor](https://voideditor.com/download-beta)!'
-	const notifController = notifService.notify({
-		severity: Severity.Info,
-		message: message,
-		sticky: true,
-		progress: { worked: 0, total: 100 },
-		actions: {
-			primary: [{
-				id: 'void.updater.update',
-				enabled: true,
+
+	let actions: INotificationActions | undefined
+
+	if (res?.action) {
+		const primary: IAction[] = []
+
+		if (res.action === 'reinstall') {
+			primary.push({
 				label: `Reinstall`,
+				id: 'void.updater.reinstall',
+				enabled: true,
 				tooltip: '',
 				class: undefined,
 				run: () => {
 					const { window } = dom.getActiveWindow()
 					window.open('https://voideditor.com/download-beta')
 				}
-			},
-			{
-				id: 'void.updater.site',
+			})
+		}
+
+		if (res.action === 'download') {
+			primary.push({
+				label: `Download`,
+				id: 'void.updater.download',
 				enabled: true,
-				label: `Void Site`,
 				tooltip: '',
 				class: undefined,
 				run: () => {
-					const { window } = dom.getActiveWindow()
-					window.open('https://voideditor.com/')
+					updateService.downloadUpdate()
+				}
+			})
+		}
+
+
+		if (res.action === 'apply') {
+			primary.push({
+				label: `Apply`,
+				id: 'void.updater.apply',
+				enabled: true,
+				tooltip: '',
+				class: undefined,
+				run: () => {
+					updateService.applyUpdate()
+				}
+			})
+		}
+
+		if (res.action === 'restart') {
+			primary.push({
+				label: `Restart`,
+				id: 'void.updater.restart',
+				enabled: true,
+				tooltip: '',
+				class: undefined,
+				run: () => {
+					updateService.quitAndInstall()
+				}
+			})
+		}
+
+		primary.push({
+			id: 'void.updater.site',
+			enabled: true,
+			label: `Void Site`,
+			tooltip: '',
+			class: undefined,
+			run: () => {
+				const { window } = dom.getActiveWindow()
+				window.open('https://voideditor.com/')
+			}
+		})
+
+		actions = {
+			primary: primary,
+			secondary: [{
+				id: 'void.updater.close',
+				enabled: true,
+				label: `Keep current version`,
+				tooltip: '',
+				class: undefined,
+				run: () => {
+					notifController.close()
 				}
 			}]
-		},
-	})
-	const d = notifController.onDidClose(() => {
-		notifyYesUpdate(notifService, res)
-		d.dispose()
-	})
-}
-const notifyNoUpdate = (notifService: INotificationService) => {
-	notifService.notify({
+		}
+	}
+	else {
+		actions = undefined
+	}
+
+	const notifController = notifService.notify({
 		severity: Severity.Info,
-		message: 'Void is up-to-date!',
+		message: message,
+		sticky: true,
+		progress: actions ? { worked: 0, total: 100 } : undefined,
+		actions: actions,
 	})
+	// const d = notifController.onDidClose(() => {
+	// 	notifyYesUpdate(notifService, res)
+	// 	d.dispose()
+	// })
 }
 const notifyErrChecking = (notifService: INotificationService) => {
 	const message = `Void Error: There was an error checking for updates. If this persists, please get in touch or reinstall Void [here](https://voideditor.com/download-beta)!`
@@ -70,6 +134,34 @@ const notifyErrChecking = (notifService: INotificationService) => {
 }
 
 
+const performVoidCheck = async (
+	explicit: boolean,
+	notifService: INotificationService,
+	voidUpdateService: IVoidUpdateService,
+	metricsService: IMetricsService,
+	updateService: IUpdateService,
+) => {
+
+	const metricsTag = explicit ? 'Manual' : 'Auto'
+
+	metricsService.capture(`Void Update ${metricsTag}: Checking...`, {})
+	const res = await voidUpdateService.check(explicit)
+	if (!res) {
+		notifyErrChecking(notifService);
+		metricsService.capture(`Void Update ${metricsTag}: Error`, { res })
+	}
+	else {
+		if (res.message) {
+			notifyUpdate(res, notifService, updateService)
+			metricsService.capture(`Void Update ${metricsTag}: Yes`, { res })
+		}
+		else {
+			metricsService.capture(`Void Update ${metricsTag}: No`, { res })
+			return
+		}
+	}
+}
+
 
 // Action
 registerAction2(class extends Action2 {
@@ -84,12 +176,8 @@ registerAction2(class extends Action2 {
 		const voidUpdateService = accessor.get(IVoidUpdateService)
 		const notifService = accessor.get(INotificationService)
 		const metricsService = accessor.get(IMetricsService)
-
-		metricsService.capture('Void Update Manual: Checking...', {})
-		const res = await voidUpdateService.check()
-		if (!res) { notifyErrChecking(notifService); metricsService.capture('Void Update Manual: Error', { res }) }
-		else if (res.hasUpdate) { notifyYesUpdate(notifService, res); metricsService.capture('Void Update Manual: Yes', { res }) }
-		else if (!res.hasUpdate) { notifyNoUpdate(notifService); metricsService.capture('Void Update Manual: No', { res }) }
+		const updateService = accessor.get(IUpdateService)
+		performVoidCheck(true, notifService, voidUpdateService, metricsService, updateService)
 	}
 })
 
@@ -97,17 +185,15 @@ registerAction2(class extends Action2 {
 class VoidUpdateWorkbenchContribution extends Disposable implements IWorkbenchContribution {
 	static readonly ID = 'workbench.contrib.void.voidUpdate'
 	constructor(
-		@IVoidUpdateService private readonly voidUpdateService: IVoidUpdateService,
-		@IMetricsService private readonly metricsService: IMetricsService,
-		@INotificationService private readonly notifService: INotificationService,
+		@IVoidUpdateService voidUpdateService: IVoidUpdateService,
+		@IMetricsService metricsService: IMetricsService,
+		@INotificationService notifService: INotificationService,
+		@IUpdateService updateService: IUpdateService,
 	) {
 		super()
-		const autoCheck = async () => {
-			this.metricsService.capture('Void Update Startup: Checking...', {})
-			const res = await this.voidUpdateService.check()
-			if (!res) { notifyErrChecking(this.notifService); this.metricsService.capture('Void Update Startup: Error', { res }) }
-			else if (res.hasUpdate) { notifyYesUpdate(this.notifService, res); this.metricsService.capture('Void Update Startup: Yes', { res }) }
-			else if (!res.hasUpdate) { this.metricsService.capture('Void Update Startup: No', { res }) } // display nothing if up to date
+
+		const autoCheck = () => {
+			performVoidCheck(false, notifService, voidUpdateService, metricsService, updateService)
 		}
 
 		// check once 5 seconds after mount

src/vs/workbench/contrib/void/common/chatThreadServiceTypes.ts

@@ -5,40 +5,33 @@
 
 import { URI } from '../../../../base/common/uri.js';
 import { VoidFileSnapshot } from './editCodeServiceTypes.js';
-import { AnthropicReasoning } from './sendLLMMessageTypes.js';
-import { ToolName, ToolCallParams, ToolResultType } from './toolsServiceTypes.js';
+import { ToolName } from './prompt/prompts.js';
+import { AnthropicReasoning, RawToolParamsObj } from './sendLLMMessageTypes.js';
+import { ToolCallParams, ToolResultType } from './toolsServiceTypes.js';
 
 export type ToolMessage<T extends ToolName> = {
 	role: 'tool';
-	paramsStr: string; // internal use
-	id: string; // apis require this tool use id
 	content: string; // give this result to LLM (string of value)
+	id: string;
+	rawParams: RawToolParamsObj;
 } & (
 		// in order of events:
-		| { type: 'invalid_params', result: null, params: null, name: string }
+		| { type: 'invalid_params', result: null, name: T, }
 
 		| { type: 'tool_request', result: null, name: T, params: ToolCallParams[T], }  // params were validated, awaiting user
 
 		| { type: 'running_now', result: null, name: T, params: ToolCallParams[T], }
 
 		| { type: 'tool_error', result: string, name: T, params: ToolCallParams[T], } // error when tool was running
-		| { type: 'success', result: ToolResultType[T], name: T, params: ToolCallParams[T], }
-		| { type: 'rejected', result: null, name: T, params: ToolCallParams[T], }
+		| { type: 'success', result: Awaited<ToolResultType[T]>, name: T, params: ToolCallParams[T], }
+		| { type: 'rejected', result: null, name: T, params: ToolCallParams[T] }
 	) // user rejected
 
 export type DecorativeCanceledTool = {
-	role: 'decorative_canceled_tool';
-	name: string;
+	role: 'interrupted_streaming_tool';
+	name: ToolName;
 }
 
-// export type ToolRequestApproval<T extends ToolName> = {
-// 	role: 'tool_request';
-// 	name: T; // internal use
-// 	params: ToolCallParams[T]; // internal use
-// 	paramsStr: string; // internal use - this is what the LLM outputted, not necessarily JSON.stringify(params)
-// 	id: string; // proposed tool's id
-// }
-
 
 // checkpoints
 export type CheckpointEntry = {
@@ -65,7 +58,7 @@ export type ChatMessage =
 		}
 	} | {
 		role: 'assistant';
-		content: string; // content received from LLM  - allowed to be '', will be replaced with (empty)
+		displayContent: string; // content received from LLM  - allowed to be '', will be replaced with (empty)
 		reasoning: string; // reasoning from the LLM, used for step-by-step thinking
 
 		anthropicReasoning: AnthropicReasoning[] | null; // anthropic reasoning

src/vs/workbench/contrib/void/common/helpers/extractCodeFromResult.ts

@@ -3,10 +3,8 @@
  *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
  *--------------------------------------------------------------------------------------*/
 
-import { OnText } from '../sendLLMMessageTypes.js'
 import { DIVIDER, FINAL, ORIGINAL } from '../prompt/prompts.js'
-
-class SurroundingsRemover {
+export class SurroundingsRemover {
 	readonly originalS: string
 	i: number
 	j: number
@@ -60,12 +58,13 @@ class SurroundingsRemover {
 	// 	return offset === suffix.length
 	// }
 
+	// either removes all or nothing
 	removeFromStartUntilFullMatch = (until: string, alsoRemoveUntilStr: boolean) => {
 		const index = this.originalS.indexOf(until, this.i)
 
 		if (index === -1) {
-			this.i = this.j + 1
-			return null
+			// this.i = this.j + 1
+			return false
 		}
 		// console.log('index', index, until.length)
 
@@ -174,7 +173,7 @@ export type ExtractedSearchReplaceBlock = {
 // JS substring swaps indices, so "ab".substr(1,0) will NOT be '', it will be 'a'!
 const voidSubstr = (str: string, start: number, end: number) => end < start ? '' : str.substring(start, end)
 
-const endsWithAnyPrefixOf = (str: string, anyPrefix: string) => {
+export const endsWithAnyPrefixOf = (str: string, anyPrefix: string) => {
 	// for each prefix
 	for (let i = anyPrefix.length; i >= 1; i--) { // i >= 1 because must not be empty string
 		const prefix = anyPrefix.slice(0, i)
@@ -250,122 +249,6 @@ export const extractSearchReplaceBlocks = (str: string) => {
 
 
 
-// could simplify this - this assumes we can never add a tag without committing it to the user's screen, but that's not true
-export const extractReasoningOnTextWrapper = (onText: OnText, thinkTags: [string, string]): OnText => {
-	let latestAddIdx = 0 // exclusive index in fullText_
-	let foundTag1 = false
-	let foundTag2 = false
-
-	let fullTextSoFar = ''
-	let fullReasoningSoFar = ''
-
-	let onText_ = onText
-	onText = (params) => {
-		onText_(params)
-	}
-
-	const newOnText: OnText = ({ fullText: fullText_, ...p }) => {
-		// until found the first think tag, keep adding to fullText
-		if (!foundTag1) {
-			const endsWithTag1 = endsWithAnyPrefixOf(fullText_, thinkTags[0])
-			if (endsWithTag1) {
-				// console.log('endswith1', { fullTextSoFar, fullReasoningSoFar, fullText_ })
-				// wait until we get the full tag or know more
-				return
-			}
-			// if found the first tag
-			const tag1Index = fullText_.indexOf(thinkTags[0])
-			if (tag1Index !== -1) {
-				// console.log('tag1Index !==1', { tag1Index, fullTextSoFar, fullReasoningSoFar, thinkTags, fullText_ })
-				foundTag1 = true
-				// Add text before the tag to fullTextSoFar
-				fullTextSoFar += fullText_.substring(0, tag1Index)
-				// Update latestAddIdx to after the first tag
-				latestAddIdx = tag1Index + thinkTags[0].length
-				onText({ ...p, fullText: fullTextSoFar, fullReasoning: fullReasoningSoFar })
-				return
-			}
-
-			// console.log('adding to text A', { fullTextSoFar, fullReasoningSoFar })
-			// add the text to fullText
-			fullTextSoFar = fullText_
-			latestAddIdx = fullText_.length
-			onText({ ...p, fullText: fullTextSoFar, fullReasoning: fullReasoningSoFar })
-			return
-		}
-
-		// at this point, we found <tag1>
-
-		// until found the second think tag, keep adding to fullReasoning
-		if (!foundTag2) {
-			const endsWithTag2 = endsWithAnyPrefixOf(fullText_, thinkTags[1])
-			if (endsWithTag2) {
-				// console.log('endsWith2', { fullTextSoFar, fullReasoningSoFar })
-				// wait until we get the full tag or know more
-				return
-			}
-
-			// if found the second tag
-			const tag2Index = fullText_.indexOf(thinkTags[1], latestAddIdx)
-			if (tag2Index !== -1) {
-				// console.log('tag2Index !== -1', { fullTextSoFar, fullReasoningSoFar })
-				foundTag2 = true
-				// Add everything between first and second tag to reasoning
-				fullReasoningSoFar += fullText_.substring(latestAddIdx, tag2Index)
-				// Update latestAddIdx to after the second tag
-				latestAddIdx = tag2Index + thinkTags[1].length
-				onText({ ...p, fullText: fullTextSoFar, fullReasoning: fullReasoningSoFar })
-				return
-			}
-
-			// add the text to fullReasoning (content after first tag but before second tag)
-			// console.log('adding to text B', { fullTextSoFar, fullReasoningSoFar })
-
-			// If we have more text than we've processed, add it to reasoning
-			if (fullText_.length > latestAddIdx) {
-				fullReasoningSoFar += fullText_.substring(latestAddIdx)
-				latestAddIdx = fullText_.length
-			}
-
-			onText({ ...p, fullText: fullTextSoFar, fullReasoning: fullReasoningSoFar })
-			return
-		}
-
-		// at this point, we found <tag2> - content after the second tag is normal text
-		// console.log('adding to text C', { fullTextSoFar, fullReasoningSoFar })
-
-		// Add any new text after the closing tag to fullTextSoFar
-		if (fullText_.length > latestAddIdx) {
-			fullTextSoFar += fullText_.substring(latestAddIdx)
-			latestAddIdx = fullText_.length
-		}
-
-		onText({ ...p, fullText: fullTextSoFar, fullReasoning: fullReasoningSoFar })
-	}
-
-	return newOnText
-}
-
-
-export const extractReasoningOnFinalMessage = (fullText_: string, thinkTags: [string, string]): { fullText: string, fullReasoning: string } => {
-	const tag1Idx = fullText_.indexOf(thinkTags[0])
-	const tag2Idx = fullText_.indexOf(thinkTags[1])
-	if (tag1Idx === -1) return { fullText: fullText_, fullReasoning: '' } // never started reasoning
-	if (tag2Idx === -1) return { fullText: '', fullReasoning: fullText_ } // never stopped reasoning
-
-	const fullReasoning = fullText_.substring(tag1Idx + thinkTags[0].length, tag2Idx)
-	const fullText = fullText_.substring(0, tag1Idx) + fullText_.substring(tag2Idx + thinkTags[1].length, Infinity)
-	return { fullText, fullReasoning }
-}
-
-
-
-
-
-
-
-
-
 
 
 

src/vs/workbench/contrib/void/common/modelCapabilities.ts

@@ -6,13 +6,59 @@
 import { FeatureName, ModelSelectionOptions, ProviderName } from './voidSettingsTypes.js';
 
 
+
+
+
+export const defaultProviderSettings = {
+	anthropic: {
+		apiKey: '',
+	},
+	openAI: {
+		apiKey: '',
+	},
+	deepseek: {
+		apiKey: '',
+	},
+	ollama: {
+		endpoint: 'http://127.0.0.1:11434',
+	},
+	vLLM: {
+		endpoint: 'http://localhost:8000',
+	},
+	openRouter: {
+		apiKey: '',
+	},
+	openAICompatible: {
+		endpoint: '',
+		apiKey: '',
+	},
+	gemini: {
+		apiKey: '',
+	},
+	groq: {
+		apiKey: '',
+	},
+	xAI: {
+		apiKey: '',
+	},
+	mistral: {
+		apiKey: '',
+	}
+} as const
+
+
+
+
 export const defaultModelsOfProvider = {
 	openAI: [ // https://platform.openai.com/docs/models/gp
+		'gpt-4.1',
+		'gpt-4.1-mini',
+		'gpt-4.1-nano',
 		'o3-mini',
-		'o1',
-		'o1-mini',
-		'gpt-4o',
-		'gpt-4o-mini',
+		// 'o1',
+		// 'o1-mini',
+		// 'gpt-4o',
+		// 'gpt-4o-mini',
 	],
 	anthropic: [ // https://docs.anthropic.com/en/docs/about-claude/models
 		'claude-3-7-sonnet-latest',
@@ -38,12 +84,19 @@ export const defaultModelsOfProvider = {
 	vLLM: [ // autodetected
 	],
 	openRouter: [ // https://openrouter.ai/models
-		'anthropic/claude-3.7-sonnet:thinking',
+		// 'anthropic/claude-3.7-sonnet:thinking',
 		'anthropic/claude-3.7-sonnet',
 		'anthropic/claude-3.5-sonnet',
 		'deepseek/deepseek-r1',
-		'mistralai/codestral-2501',
-		'qwen/qwen-2.5-coder-32b-instruct',
+		'deepseek/deepseek-r1-zero:free',
+		'openrouter/quasar-alpha',
+		'google/gemini-2.5-pro-preview-03-25',
+		// 'mistralai/codestral-2501',
+		// 'qwen/qwen-2.5-coder-32b-instruct',
+		// 'mistralai/mistral-small-3.1-24b-instruct:free',
+		// 'google/gemini-2.0-flash-lite-preview-02-05:free',
+		// 'google/gemini-2.0-pro-exp-02-05:free',
+		// 'google/gemini-2.0-flash-exp:free',
 	],
 	groq: [ // https://console.groq.com/docs/models
 		'qwen-qwq-32b',
@@ -51,32 +104,33 @@ export const defaultModelsOfProvider = {
 		'llama-3.1-8b-instant',
 		// 'qwen-2.5-coder-32b', // preview mode (experimental)
 	],
-	// not supporting mistral right now- it's last on Void usage, and a huge pain to set up since it's nonstandard (it supports codestral FIM but it's on v1/fim/completions, etc)
-	// mistral: [ // https://docs.mistral.ai/getting-started/models/models_overview/
-	// 	'codestral-latest',
-	// 	'mistral-large-latest',
-	// 	'ministral-3b-latest',
-	// 	'ministral-8b-latest',
-	// ],
+	mistral: [ // https://docs.mistral.ai/getting-started/models/models_overview/
+		'codestral-latest',
+		'mistral-large-latest',
+		'ministral-3b-latest',
+		'ministral-8b-latest',
+	],
 	openAICompatible: [], // fallback
 } as const satisfies Record<ProviderName, string[]>
 
 
 
-
-
-
-type ModelOptions = {
+export type VoidStaticModelInfo = { // not stateful
 	contextWindow: number; // input tokens
 	maxOutputTokens: number | null; // output tokens, defaults to 4092
-	cost: {                                             // <-- UNUSED
+	cost: { // <-- UNUSED
 		input: number;
 		output: number;
 		cache_read?: number;
 		cache_write?: number;
 	}
-	supportsSystemMessage: false | 'system-role' | 'developer-role' | 'separated';
-	supportsTools: false | 'anthropic-style' | 'openai-style';
+
+	downloadable: false | {
+		sizeGb: number | 'not-known'
+	}
+
+	supportsSystemMessage: false | 'system-role' | 'developer-role' | 'separated'; // separated = anthropic where "system" is a special paramete
+	specialToolFormat?: 'openai-style' | 'anthropic-style', // null defaults to XML
 	supportsFIM: boolean;
 
 	reasoningCapabilities: false | {
@@ -104,70 +158,61 @@ type ProviderReasoningIOSettings = {
 	| { nameOfFieldInDelta?: undefined, needsManualParse?: true, };
 }
 
-type ProviderSettings = {
+type VoidStaticProviderInfo = { // doesn't change (not stateful)
 	providerReasoningIOSettings?: ProviderReasoningIOSettings; // input/output settings around thinking (allowed to be empty) - only applied if the model supports reasoning output
-	modelOptions: { [key: string]: ModelOptions };
-	modelOptionsFallback: (modelName: string) => (ModelOptions & { modelName: string }) | null;
+	modelOptions: { [key: string]: VoidStaticModelInfo };
+	modelOptionsFallback: (modelName: string, fallbackKnownValues?: Partial<VoidStaticModelInfo>) => (VoidStaticModelInfo & { modelName: string }) | null;
 }
 
 
 
-const modelOptionsDefaults: ModelOptions = {
+const modelOptionsDefaults: VoidStaticModelInfo = {
 	contextWindow: 32_000,
 	maxOutputTokens: 4_096,
 	cost: { input: 0, output: 0 },
+	downloadable: false,
 	supportsSystemMessage: false,
-	supportsTools: false,
 	supportsFIM: false,
 	reasoningCapabilities: false,
 }
 
-
-
 // TODO!!! double check all context sizes below
 // TODO!!! add openrouter common models
 // TODO!!! allow user to modify capabilities and tell them if autodetected model or falling back
-
 const openSourceModelOptions_assumingOAICompat = {
 	'deepseekR1': {
 		supportsFIM: false,
 		supportsSystemMessage: false,
-		supportsTools: false,
 		reasoningCapabilities: { supportsReasoning: true, canTurnOffReasoning: false, canIOReasoning: true, openSourceThinkTags: ['<think>', '</think>'] },
 		contextWindow: 32_000, maxOutputTokens: 4_096,
 	},
 	'deepseekCoderV3': {
 		supportsFIM: false,
 		supportsSystemMessage: false, // unstable
-		supportsTools: false,
 		reasoningCapabilities: false,
 		contextWindow: 32_000, maxOutputTokens: 4_096,
 	},
 	'deepseekCoderV2': {
 		supportsFIM: false,
 		supportsSystemMessage: false, // unstable
-		supportsTools: false,
 		reasoningCapabilities: false,
 		contextWindow: 32_000, maxOutputTokens: 4_096,
 	},
 	'codestral': {
 		supportsFIM: true,
 		supportsSystemMessage: 'system-role',
-		supportsTools: 'openai-style',
 		reasoningCapabilities: false,
 		contextWindow: 32_000, maxOutputTokens: 4_096,
 	},
 	'openhands-lm-32b': { // https://www.all-hands.dev/blog/introducing-openhands-lm-32b----a-strong-open-coding-agent-model
 		supportsFIM: false,
 		supportsSystemMessage: 'system-role',
-		supportsTools: 'openai-style',
 		reasoningCapabilities: false, // built on qwen 2.5 32B instruct
 		contextWindow: 128_000, maxOutputTokens: 4_096
 	},
 	'phi4': {
 		supportsFIM: false,
 		supportsSystemMessage: 'system-role',
-		supportsTools: false,
 		reasoningCapabilities: false,
 		contextWindow: 16_000, maxOutputTokens: 4_096,
 	},
@@ -175,7 +220,6 @@ const openSourceModelOptions_assumingOAICompat = {
 	'gemma': { // https://news.ycombinator.com/item?id=43451406
 		supportsFIM: false,
 		supportsSystemMessage: 'system-role',
-		supportsTools: false,
 		reasoningCapabilities: false,
 		contextWindow: 32_000, maxOutputTokens: 4_096,
 	},
@@ -183,14 +227,12 @@ const openSourceModelOptions_assumingOAICompat = {
 	'llama4-scout': {
 		supportsFIM: false,
 		supportsSystemMessage: 'system-role',
-		supportsTools: 'openai-style',
 		reasoningCapabilities: false,
 		contextWindow: 10_000_000, maxOutputTokens: 4_096,
 	},
 	'llama4-maverick': {
 		supportsFIM: false,
 		supportsSystemMessage: 'system-role',
-		supportsTools: 'openai-style',
 		reasoningCapabilities: false,
 		contextWindow: 10_000_000, maxOutputTokens: 4_096,
 	},
@@ -199,28 +241,24 @@ const openSourceModelOptions_assumingOAICompat = {
 	'llama3': {
 		supportsFIM: false,
 		supportsSystemMessage: 'system-role',
-		supportsTools: 'openai-style',
 		reasoningCapabilities: false,
 		contextWindow: 32_000, maxOutputTokens: 4_096,
 	},
 	'llama3.1': {
 		supportsFIM: false,
 		supportsSystemMessage: 'system-role',
-		supportsTools: 'openai-style',
 		reasoningCapabilities: false,
 		contextWindow: 32_000, maxOutputTokens: 4_096,
 	},
 	'llama3.2': {
 		supportsFIM: false,
 		supportsSystemMessage: 'system-role',
-		supportsTools: 'openai-style',
 		reasoningCapabilities: false,
 		contextWindow: 32_000, maxOutputTokens: 4_096,
 	},
 	'llama3.3': {
 		supportsFIM: false,
 		supportsSystemMessage: 'system-role',
-		supportsTools: 'openai-style',
 		reasoningCapabilities: false,
 		contextWindow: 32_000, maxOutputTokens: 4_096,
 	},
@@ -228,14 +266,12 @@ const openSourceModelOptions_assumingOAICompat = {
 	'qwen2.5coder': {
 		supportsFIM: true,
 		supportsSystemMessage: 'system-role',
-		supportsTools: 'openai-style',
 		reasoningCapabilities: false,
 		contextWindow: 32_000, maxOutputTokens: 4_096,
 	},
 	'qwq': {
 		supportsFIM: false, // no FIM, yes reasoning
 		supportsSystemMessage: 'system-role',
-		supportsTools: 'openai-style',
 		reasoningCapabilities: { supportsReasoning: true, canTurnOffReasoning: false, canIOReasoning: true, openSourceThinkTags: ['<think>', '</think>'] },
 		contextWindow: 128_000, maxOutputTokens: 8_192,
 	},
@@ -243,7 +279,6 @@ const openSourceModelOptions_assumingOAICompat = {
 	'starcoder2': {
 		supportsFIM: true,
 		supportsSystemMessage: false,
-		supportsTools: false,
 		reasoningCapabilities: false,
 		contextWindow: 128_000, maxOutputTokens: 8_192,
 
@@ -251,31 +286,36 @@ const openSourceModelOptions_assumingOAICompat = {
 	'codegemma:2b': {
 		supportsFIM: true,
 		supportsSystemMessage: false,
-		supportsTools: false,
 		reasoningCapabilities: false,
 		contextWindow: 128_000, maxOutputTokens: 8_192,
 
 	},
-} as const satisfies { [s: string]: Omit<ModelOptions, 'cost'> }
+	'quasar': { // openrouter/quasar-alpha
+		supportsFIM: false,
+		supportsSystemMessage: 'system-role',
+		reasoningCapabilities: false,
+		contextWindow: 1_000_000, maxOutputTokens: 32_000,
+	}
+} as const satisfies { [s: string]: Partial<VoidStaticModelInfo> }
 
 
 
 
-const extensiveModelFallback: ProviderSettings['modelOptionsFallback'] = (modelName) => {
+const extensiveModelFallback: VoidStaticProviderInfo['modelOptionsFallback'] = (modelName, fallbackKnownValues) => {
+
 
 	const lower = modelName.toLowerCase()
 
-	const toFallback = (opts: Omit<ModelOptions, 'cost'>): ModelOptions & { modelName: string } => {
+	const toFallback = (opts: Omit<VoidStaticModelInfo, 'cost' | 'downloadable'>): VoidStaticModelInfo & { modelName: string } => {
 		return {
 			modelName,
 			...opts,
 			supportsSystemMessage: opts.supportsSystemMessage ? 'system-role' : false,
 			cost: { input: 0, output: 0 },
+			downloadable: false,
+			...fallbackKnownValues
 		}
 	}
-	if (Object.keys(openSourceModelOptions_assumingOAICompat).map(k => k.toLowerCase()).includes(lower))
-		return toFallback(openSourceModelOptions_assumingOAICompat[lower as keyof typeof openSourceModelOptions_assumingOAICompat])
-
 	if (lower.includes('gemini') && (lower.includes('2.5') || lower.includes('2-5'))) return toFallback(geminiModelOptions['gemini-2.5-pro-exp-03-25'])
 
 	if (lower.includes('claude-3-5') || lower.includes('claude-3.5')) return toFallback(anthropicModelOptions['claude-3-5-sonnet-20241022'])
@@ -306,12 +346,21 @@ const extensiveModelFallback: ProviderSettings['modelOptionsFallback'] = (modelN
 
 	if (lower.includes('openhands')) return toFallback({ ...openSourceModelOptions_assumingOAICompat['openhands-lm-32b'], }) // max output unclear
 
+	if (lower.includes('quasar') || lower.includes('quaser')) return toFallback({ ...openSourceModelOptions_assumingOAICompat['quasar'] })
+
+	if (lower.includes('gpt') && lower.includes('mini') && (lower.includes('4.1') || lower.includes('4-1'))) return toFallback(openAIModelOptions['gpt-4.1-mini'])
+	if (lower.includes('gpt') && lower.includes('nano') && (lower.includes('4.1') || lower.includes('4-1'))) return toFallback(openAIModelOptions['gpt-4.1-nano'])
+	if (lower.includes('gpt') && (lower.includes('4.1') || lower.includes('4-1'))) return toFallback(openAIModelOptions['gpt-4.1'])
+
 	if (lower.includes('4o') && lower.includes('mini')) return toFallback(openAIModelOptions['gpt-4o-mini'])
 	if (lower.includes('4o')) return toFallback(openAIModelOptions['gpt-4o'])
+
 	if (lower.includes('o1') && lower.includes('mini')) return toFallback(openAIModelOptions['o1-mini'])
 	if (lower.includes('o1')) return toFallback(openAIModelOptions['o1'])
 	if (lower.includes('o3') && lower.includes('mini')) return toFallback(openAIModelOptions['o3-mini'])
-	// if (lower.includes('o3')) return toFallback(openAIModelOptions['o3'])
+
+	if (Object.keys(openSourceModelOptions_assumingOAICompat).map(k => k.toLowerCase()).includes(lower))
+		return toFallback(openSourceModelOptions_assumingOAICompat[lower as keyof typeof openSourceModelOptions_assumingOAICompat])
 
 	return toFallback(modelOptionsDefaults)
 }
@@ -327,9 +376,10 @@ const anthropicModelOptions = {
 		contextWindow: 200_000,
 		maxOutputTokens: 8_192,
 		cost: { input: 3.00, cache_read: 0.30, cache_write: 3.75, output: 15.00 },
+		downloadable: false,
 		supportsFIM: false,
+		specialToolFormat: 'anthropic-style',
 		supportsSystemMessage: 'separated',
-		supportsTools: 'anthropic-style',
 		reasoningCapabilities: {
 			supportsReasoning: true,
 			canTurnOffReasoning: true,
@@ -337,45 +387,50 @@ const anthropicModelOptions = {
 			reasoningMaxOutputTokens: 64_000, // can bump it to 128_000 with beta mode output-128k-2025-02-19
 			reasoningBudgetSlider: { type: 'slider', min: 1024, max: 32_000, default: 1024 }, // they recommend batching if max > 32_000
 		},
+
 	},
 	'claude-3-5-sonnet-20241022': {
 		contextWindow: 200_000,
 		maxOutputTokens: 8_192,
 		cost: { input: 3.00, cache_read: 0.30, cache_write: 3.75, output: 15.00 },
+		downloadable: false,
 		supportsFIM: false,
+		specialToolFormat: 'anthropic-style',
 		supportsSystemMessage: 'separated',
-		supportsTools: 'anthropic-style',
 		reasoningCapabilities: false,
 	},
 	'claude-3-5-haiku-20241022': {
 		contextWindow: 200_000,
 		maxOutputTokens: 8_192,
 		cost: { input: 0.80, cache_read: 0.08, cache_write: 1.00, output: 4.00 },
+		downloadable: false,
 		supportsFIM: false,
+		specialToolFormat: 'anthropic-style',
 		supportsSystemMessage: 'separated',
-		supportsTools: 'anthropic-style',
 		reasoningCapabilities: false,
 	},
 	'claude-3-opus-20240229': {
 		contextWindow: 200_000,
 		maxOutputTokens: 4_096,
 		cost: { input: 15.00, cache_read: 1.50, cache_write: 18.75, output: 75.00 },
+		downloadable: false,
 		supportsFIM: false,
+		specialToolFormat: 'anthropic-style',
 		supportsSystemMessage: 'separated',
-		supportsTools: 'anthropic-style',
 		reasoningCapabilities: false,
 	},
 	'claude-3-sonnet-20240229': { // no point of using this, but including this for people who put it in
 		contextWindow: 200_000, cost: { input: 3.00, output: 15.00 },
+		downloadable: false,
 		maxOutputTokens: 4_096,
 		supportsFIM: false,
+		specialToolFormat: 'anthropic-style',
 		supportsSystemMessage: 'separated',
-		supportsTools: 'anthropic-style',
 		reasoningCapabilities: false,
 	}
-} as const satisfies { [s: string]: ModelOptions }
+} as const satisfies { [s: string]: VoidStaticModelInfo }
 
-const anthropicSettings: ProviderSettings = {
+const anthropicSettings: VoidStaticProviderInfo = {
 	providerReasoningIOSettings: {
 		input: {
 			includeInPayload: (reasoningInfo) => {
@@ -403,12 +458,42 @@ const anthropicSettings: ProviderSettings = {
 
 // ---------------- OPENAI ----------------
 const openAIModelOptions = { // https://platform.openai.com/docs/pricing
+	'gpt-4.1': {
+		contextWindow: 1_047_576,
+		maxOutputTokens: 32_768,
+		cost: { input: 2.00, output: 8.00, cache_read: 0.50 },
+		downloadable: false,
+		supportsFIM: false,
+		specialToolFormat: 'openai-style',
+		supportsSystemMessage: 'developer-role',
+		reasoningCapabilities: false,
+	},
+	'gpt-4.1-mini': {
+		contextWindow: 1_047_576,
+		maxOutputTokens: 32_768,
+		cost: { input: 0.40, output: 1.60, cache_read: 0.10 },
+		downloadable: false,
+		supportsFIM: false,
+		specialToolFormat: 'openai-style',
+		supportsSystemMessage: 'developer-role',
+		reasoningCapabilities: false,
+	},
+	'gpt-4.1-nano': {
+		contextWindow: 1_047_576,
+		maxOutputTokens: 32_768,
+		cost: { input: 0.10, output: 0.40, cache_read: 0.03 },
+		downloadable: false,
+		supportsFIM: false,
+		specialToolFormat: 'openai-style',
+		supportsSystemMessage: 'developer-role',
+		reasoningCapabilities: false,
+	},
 	'o1': {
 		contextWindow: 128_000,
 		maxOutputTokens: 100_000,
 		cost: { input: 15.00, cache_read: 7.50, output: 60.00, },
+		downloadable: false,
 		supportsFIM: false,
-		supportsTools: false,
 		supportsSystemMessage: 'developer-role',
 		reasoningCapabilities: { supportsReasoning: true, canIOReasoning: false, canTurnOffReasoning: false }, // it doesn't actually output reasoning, but our logic is fine with it
 	},
@@ -416,8 +501,8 @@ const openAIModelOptions = { // https://platform.openai.com/docs/pricing
 		contextWindow: 200_000,
 		maxOutputTokens: 100_000,
 		cost: { input: 1.10, cache_read: 0.55, output: 4.40, },
+		downloadable: false,
 		supportsFIM: false,
-		supportsTools: false,
 		supportsSystemMessage: 'developer-role',
 		reasoningCapabilities: { supportsReasoning: true, canIOReasoning: false, canTurnOffReasoning: false },
 	},
@@ -425,8 +510,9 @@ const openAIModelOptions = { // https://platform.openai.com/docs/pricing
 		contextWindow: 128_000,
 		maxOutputTokens: 16_384,
 		cost: { input: 2.50, cache_read: 1.25, output: 10.00, },
+		downloadable: false,
 		supportsFIM: false,
-		supportsTools: 'openai-style',
+		specialToolFormat: 'openai-style',
 		supportsSystemMessage: 'system-role',
 		reasoningCapabilities: false,
 	},
@@ -434,8 +520,8 @@ const openAIModelOptions = { // https://platform.openai.com/docs/pricing
 		contextWindow: 128_000,
 		maxOutputTokens: 65_536,
 		cost: { input: 1.10, cache_read: 0.55, output: 4.40, },
+		downloadable: false,
 		supportsFIM: false,
-		supportsTools: false,
 		supportsSystemMessage: false, // does not support any system
 		reasoningCapabilities: { supportsReasoning: true, canIOReasoning: false, canTurnOffReasoning: false },
 	},
@@ -443,15 +529,16 @@ const openAIModelOptions = { // https://platform.openai.com/docs/pricing
 		contextWindow: 128_000,
 		maxOutputTokens: 16_384,
 		cost: { input: 0.15, cache_read: 0.075, output: 0.60, },
+		downloadable: false,
 		supportsFIM: false,
-		supportsTools: 'openai-style',
+		specialToolFormat: 'openai-style',
 		supportsSystemMessage: 'system-role', // ??
 		reasoningCapabilities: false,
 	},
-} as const satisfies { [s: string]: ModelOptions }
+} as const satisfies { [s: string]: VoidStaticModelInfo }
 
 
-const openAISettings: ProviderSettings = {
+const openAISettings: VoidStaticProviderInfo = {
 	modelOptions: openAIModelOptions,
 	modelOptionsFallback: (modelName) => {
 		const lower = modelName.toLowerCase()
@@ -470,14 +557,23 @@ const xAIModelOptions = {
 		contextWindow: 131_072,
 		maxOutputTokens: null, // 131_072,
 		cost: { input: 2.00, output: 10.00 },
+		downloadable: false,
 		supportsFIM: false,
 		supportsSystemMessage: 'system-role',
-		supportsTools: 'openai-style',
 		reasoningCapabilities: false,
 	},
-} as const satisfies { [s: string]: ModelOptions }
+	// 'grok-3': {
+	// 	contextWindow: 1_000_000,
+	// 	maxOutputTokens: null,
+	// 	cost: {},
+	// 	downloadable: false,
+	// 	supportsFIM: false,
+	// 	supportsSystemMessage: 'system-role',
+	// 	reasoningCapabilities: {canIOReasoning:false, canTurnOffReasoning:true,},
+	// }
+} as const satisfies { [s: string]: VoidStaticModelInfo }
 
-const xAISettings: ProviderSettings = {
+const xAISettings: VoidStaticProviderInfo = {
 	modelOptions: xAIModelOptions,
 	modelOptionsFallback: (modelName) => {
 		const lower = modelName.toLowerCase()
@@ -495,59 +591,59 @@ const geminiModelOptions = { // https://ai.google.dev/gemini-api/docs/pricing
 		contextWindow: 1_048_576,
 		maxOutputTokens: 8_192,
 		cost: { input: 0, output: 0 },
+		downloadable: false,
 		supportsFIM: false,
 		supportsSystemMessage: 'system-role',
-		supportsTools: 'openai-style', // we are assuming OpenAI SDK when calling gemini
 		reasoningCapabilities: false,
 	},
 	'gemini-2.0-flash': {
 		contextWindow: 1_048_576,
 		maxOutputTokens: 8_192, // 8_192,
 		cost: { input: 0.10, output: 0.40 },
+		downloadable: false,
 		supportsFIM: false,
 		supportsSystemMessage: 'system-role',
-		supportsTools: 'openai-style', // we are assuming OpenAI SDK when calling gemini
 		reasoningCapabilities: false,
 	},
 	'gemini-2.0-flash-lite-preview-02-05': {
 		contextWindow: 1_048_576,
 		maxOutputTokens: 8_192, // 8_192,
 		cost: { input: 0.075, output: 0.30 },
+		downloadable: false,
 		supportsFIM: false,
 		supportsSystemMessage: 'system-role',
-		supportsTools: 'openai-style',
 		reasoningCapabilities: false,
 	},
 	'gemini-1.5-flash': {
 		contextWindow: 1_048_576,
 		maxOutputTokens: 8_192, // 8_192,
 		cost: { input: 0.075, output: 0.30 },  // TODO!!! price doubles after 128K tokens, we are NOT encoding that info right now
+		downloadable: false,
 		supportsFIM: false,
 		supportsSystemMessage: 'system-role',
-		supportsTools: 'openai-style',
 		reasoningCapabilities: false,
 	},
 	'gemini-1.5-pro': {
 		contextWindow: 2_097_152,
 		maxOutputTokens: 8_192,
 		cost: { input: 1.25, output: 5.00 },  // TODO!!! price doubles after 128K tokens, we are NOT encoding that info right now
+		downloadable: false,
 		supportsFIM: false,
 		supportsSystemMessage: 'system-role',
-		supportsTools: 'openai-style',
 		reasoningCapabilities: false,
 	},
 	'gemini-1.5-flash-8b': {
 		contextWindow: 1_048_576,
 		maxOutputTokens: 8_192,
 		cost: { input: 0.0375, output: 0.15 },  // TODO!!! price doubles after 128K tokens, we are NOT encoding that info right now
+		downloadable: false,
 		supportsFIM: false,
 		supportsSystemMessage: 'system-role',
-		supportsTools: 'openai-style',
 		reasoningCapabilities: false,
 	},
-} as const satisfies { [s: string]: ModelOptions }
+} as const satisfies { [s: string]: VoidStaticModelInfo }
 
-const geminiSettings: ProviderSettings = {
+const geminiSettings: VoidStaticProviderInfo = {
 	modelOptions: geminiModelOptions,
 	modelOptionsFallback: (modelName) => { return null }
 }
@@ -561,17 +657,19 @@ const deepseekModelOptions = {
 		contextWindow: 64_000, // https://api-docs.deepseek.com/quick_start/pricing
 		maxOutputTokens: 8_000, // 8_000,
 		cost: { cache_read: .07, input: .27, output: 1.10, },
+		downloadable: false,
 	},
 	'deepseek-reasoner': {
 		...openSourceModelOptions_assumingOAICompat.deepseekCoderV2,
 		contextWindow: 64_000,
 		maxOutputTokens: 8_000, // 8_000,
 		cost: { cache_read: .14, input: .55, output: 2.19, },
+		downloadable: false,
 	},
-} as const satisfies { [s: string]: ModelOptions }
+} as const satisfies { [s: string]: VoidStaticModelInfo }
 
 
-const deepseekSettings: ProviderSettings = {
+const deepseekSettings: VoidStaticProviderInfo = {
 	modelOptions: deepseekModelOptions,
 	providerReasoningIOSettings: {
 		// reasoning: OAICompat +  response.choices[0].delta.reasoning_content // https://api-docs.deepseek.com/guides/reasoning_model
@@ -580,46 +678,95 @@ const deepseekSettings: ProviderSettings = {
 	modelOptionsFallback: (modelName) => { return null }
 }
 
+
+
+// ---------------- MISTRAL ----------------
+
+const mistralModelOptions = { // https://mistral.ai/products/la-plateforme#pricing https://docs.mistral.ai/getting-started/models/models_overview/#premier-models
+	'mistral-large-latest': {
+		contextWindow: 131_000,
+		maxOutputTokens: 8_192,
+		cost: { input: 2.00, output: 6.00 },
+		supportsFIM: false,
+		downloadable: { sizeGb: 73 },
+		supportsSystemMessage: 'system-role',
+		reasoningCapabilities: false,
+	},
+	'codestral-latest': {
+		contextWindow: 256_000,
+		maxOutputTokens: 8_192,
+		cost: { input: 0.30, output: 0.90 },
+		supportsFIM: true,
+		downloadable: { sizeGb: 13 },
+		supportsSystemMessage: 'system-role',
+		reasoningCapabilities: false,
+	},
+	'ministral-8b-latest': { // ollama 'mistral'
+		contextWindow: 131_000,
+		maxOutputTokens: 4_096,
+		cost: { input: 0.10, output: 0.10 },
+		supportsFIM: false,
+		downloadable: { sizeGb: 4.1 },
+		supportsSystemMessage: 'system-role',
+		reasoningCapabilities: false,
+	},
+	'ministral-3b-latest': {
+		contextWindow: 131_000,
+		maxOutputTokens: 4_096,
+		cost: { input: 0.04, output: 0.04 },
+		supportsFIM: false,
+		downloadable: { sizeGb: 'not-known' },
+		supportsSystemMessage: 'system-role',
+		reasoningCapabilities: false,
+	},
+} as const satisfies { [s: string]: VoidStaticModelInfo }
+
+const mistralSettings: VoidStaticProviderInfo = {
+	modelOptions: mistralModelOptions,
+	modelOptionsFallback: (modelName) => { return null },
+}
+
+
 // ---------------- GROQ ----------------
 const groqModelOptions = { // https://console.groq.com/docs/models, https://groq.com/pricing/
 	'llama-3.3-70b-versatile': {
 		contextWindow: 128_000,
 		maxOutputTokens: 32_768, // 32_768,
 		cost: { input: 0.59, output: 0.79 },
+		downloadable: false,
 		supportsFIM: false,
 		supportsSystemMessage: 'system-role',
-		supportsTools: 'openai-style',
 		reasoningCapabilities: false,
 	},
 	'llama-3.1-8b-instant': {
 		contextWindow: 128_000,
 		maxOutputTokens: 8_192,
 		cost: { input: 0.05, output: 0.08 },
+		downloadable: false,
 		supportsFIM: false,
 		supportsSystemMessage: 'system-role',
-		supportsTools: 'openai-style',
 		reasoningCapabilities: false,
 	},
 	'qwen-2.5-coder-32b': {
 		contextWindow: 128_000,
 		maxOutputTokens: null, // not specified?
 		cost: { input: 0.79, output: 0.79 },
+		downloadable: false,
 		supportsFIM: false, // unfortunately looks like no FIM support on groq
 		supportsSystemMessage: 'system-role',
-		supportsTools: 'openai-style',
 		reasoningCapabilities: false,
 	},
 	'qwen-qwq-32b': { // https://huggingface.co/Qwen/QwQ-32B
 		contextWindow: 128_000,
 		maxOutputTokens: null, // not specified?
 		cost: { input: 0.29, output: 0.39 },
+		downloadable: false,
 		supportsFIM: false,
 		supportsSystemMessage: 'system-role',
-		supportsTools: 'openai-style',
 		reasoningCapabilities: { supportsReasoning: true, canIOReasoning: true, canTurnOffReasoning: false, openSourceThinkTags: ['<think>', '</think>'] }, // we're using reasoning_format:parsed so really don't need to know openSourceThinkTags
 	},
-} as const satisfies { [s: string]: ModelOptions }
-const groqSettings: ProviderSettings = {
+} as const satisfies { [s: string]: VoidStaticModelInfo }
+const groqSettings: VoidStaticProviderInfo = {
 	providerReasoningIOSettings: {
 		input: {
 			includeInPayload: (reasoningInfo) => {
@@ -635,23 +782,76 @@ const groqSettings: ProviderSettings = {
 	modelOptionsFallback: (modelName) => { return null }
 }
 
+const ollamaModelOptions = {
+	'qwen2.5-coder:1.5b': {
+		contextWindow: 32_000,
+		maxOutputTokens: null,
+		cost: { input: 0, output: 0 },
+		downloadable: { sizeGb: 1.9 },
+		supportsFIM: true,
+		supportsSystemMessage: 'system-role',
+		reasoningCapabilities: false,
+	},
+	'llama3.1': {
+		contextWindow: 128_000,
+		maxOutputTokens: null,
+		cost: { input: 0, output: 0 },
+		downloadable: { sizeGb: 4.9 },
+		supportsFIM: false,
+		supportsSystemMessage: 'system-role',
+		reasoningCapabilities: false,
+	},
+	'qwen2.5-coder': {
+		contextWindow: 128_000,
+		maxOutputTokens: null,
+		cost: { input: 0, output: 0 },
+		downloadable: { sizeGb: 4.7 },
+		supportsFIM: false,
+		supportsSystemMessage: 'system-role',
+		reasoningCapabilities: false,
+	},
+	'qwq': {
+		contextWindow: 128_000,
+		maxOutputTokens: 32_000,
+		cost: { input: 0, output: 0 },
+		downloadable: { sizeGb: 20 },
+		supportsFIM: false,
+		supportsSystemMessage: 'system-role',
+		reasoningCapabilities: { supportsReasoning: true, canIOReasoning: false, canTurnOffReasoning: false, openSourceThinkTags: ['<think>', '</think>'] },
+	},
+	'deepseek-r1': {
+		contextWindow: 128_000,
+		maxOutputTokens: null,
+		cost: { input: 0, output: 0 },
+		downloadable: { sizeGb: 4.7 },
+		supportsFIM: false,
+		supportsSystemMessage: 'system-role',
+		reasoningCapabilities: { supportsReasoning: true, canIOReasoning: false, canTurnOffReasoning: false, openSourceThinkTags: ['<think>', '</think>'] },
+	},
+
+} as const satisfies Record<string, VoidStaticModelInfo>
+
+export const ollamaRecommendedModels = ['qwen2.5-coder:1.5b', 'llama3.1', 'qwq', 'deepseek-r1'] as const satisfies (keyof typeof ollamaModelOptions)[]
+
+
 
 // ---------------- VLLM, OLLAMA, OPENAICOMPAT (self-hosted / local) ----------------
-const vLLMSettings: ProviderSettings = {
+
+const vLLMSettings: VoidStaticProviderInfo = {
 	// reasoning: OAICompat + response.choices[0].delta.reasoning_content // https://docs.vllm.ai/en/stable/features/reasoning_outputs.html#streaming-chat-completions
 	providerReasoningIOSettings: { output: { nameOfFieldInDelta: 'reasoning_content' }, },
-	modelOptionsFallback: (modelName) => extensiveModelFallback(modelName),
-	modelOptions: {},
+	modelOptionsFallback: (modelName) => extensiveModelFallback(modelName, { downloadable: { sizeGb: 'not-known' } }),
+	modelOptions: {}, // TODO
 }
 
-const ollamaSettings: ProviderSettings = {
+const ollamaSettings: VoidStaticProviderInfo = {
 	// reasoning: we need to filter out reasoning <think> tags manually
 	providerReasoningIOSettings: { output: { needsManualParse: true }, },
-	modelOptionsFallback: (modelName) => extensiveModelFallback(modelName),
-	modelOptions: {},
+	modelOptionsFallback: (modelName) => extensiveModelFallback(modelName, { downloadable: { sizeGb: 'not-known' } }),
+	modelOptions: ollamaModelOptions,
 }
 
-const openaiCompatible: ProviderSettings = {
+const openaiCompatible: VoidStaticProviderInfo = {
 	// reasoning: we have no idea what endpoint they used, so we can't consistently parse out reasoning
 	modelOptionsFallback: (modelName) => extensiveModelFallback(modelName),
 	modelOptions: {},
@@ -660,19 +860,56 @@ const openaiCompatible: ProviderSettings = {
 
 // ---------------- OPENROUTER ----------------
 const openRouterModelOptions_assumingOpenAICompat = {
+	'mistralai/mistral-small-3.1-24b-instruct:free': {
+		contextWindow: 128_000,
+		maxOutputTokens: null,
+		cost: { input: 0, output: 0 },
+		downloadable: false,
+		supportsFIM: false,
+		supportsSystemMessage: 'system-role',
+		reasoningCapabilities: false,
+	},
+	'google/gemini-2.0-flash-lite-preview-02-05:free': {
+		contextWindow: 1_048_576,
+		maxOutputTokens: null,
+		cost: { input: 0, output: 0 },
+		downloadable: false,
+		supportsFIM: false,
+		supportsSystemMessage: 'system-role',
+		reasoningCapabilities: false,
+	},
+	'google/gemini-2.0-pro-exp-02-05:free': {
+		contextWindow: 1_048_576,
+		maxOutputTokens: null,
+		cost: { input: 0, output: 0 },
+		downloadable: false,
+		supportsFIM: false,
+		supportsSystemMessage: 'system-role',
+		reasoningCapabilities: false,
+	},
+	'google/gemini-2.0-flash-exp:free': {
+		contextWindow: 1_048_576,
+		maxOutputTokens: null,
+		cost: { input: 0, output: 0 },
+		downloadable: false,
+		supportsFIM: false,
+		supportsSystemMessage: 'system-role',
+		reasoningCapabilities: false,
+	},
 	'deepseek/deepseek-r1': {
 		...openSourceModelOptions_assumingOAICompat.deepseekR1,
 		contextWindow: 128_000,
 		maxOutputTokens: null,
 		cost: { input: 0.8, output: 2.4 },
+		downloadable: false,
 	},
 	'anthropic/claude-3.7-sonnet:thinking': {
 		contextWindow: 200_000,
 		maxOutputTokens: null,
 		cost: { input: 3.00, output: 15.00 },
+		downloadable: false,
 		supportsFIM: false,
 		supportsSystemMessage: 'system-role',
-		supportsTools: 'openai-style',
 		reasoningCapabilities: { // same as anthropic, see above
 			supportsReasoning: true,
 			canTurnOffReasoning: false,
@@ -685,18 +922,18 @@ const openRouterModelOptions_assumingOpenAICompat = {
 		contextWindow: 200_000,
 		maxOutputTokens: null,
 		cost: { input: 3.00, output: 15.00 },
+		downloadable: false,
 		supportsFIM: false,
 		supportsSystemMessage: 'system-role',
-		supportsTools: 'openai-style',
 		reasoningCapabilities: false, // stupidly, openrouter separates thinking from non-thinking
 	},
 	'anthropic/claude-3.5-sonnet': {
 		contextWindow: 200_000,
 		maxOutputTokens: null,
 		cost: { input: 3.00, output: 15.00 },
+		downloadable: false,
 		supportsFIM: false,
 		supportsSystemMessage: 'system-role',
-		supportsTools: 'openai-style',
 		reasoningCapabilities: false,
 	},
 	'mistralai/codestral-2501': {
@@ -704,26 +941,26 @@ const openRouterModelOptions_assumingOpenAICompat = {
 		contextWindow: 256_000,
 		maxOutputTokens: null,
 		cost: { input: 0.3, output: 0.9 },
-		supportsTools: 'openai-style',
+		downloadable: false,
 		reasoningCapabilities: false,
 	},
 	'qwen/qwen-2.5-coder-32b-instruct': {
 		...openSourceModelOptions_assumingOAICompat['qwen2.5coder'],
 		contextWindow: 33_000,
 		maxOutputTokens: null,
-		supportsTools: false, // openrouter qwen doesn't seem to support tools...?
 		cost: { input: 0.07, output: 0.16 },
+		downloadable: false,
 	},
 	'qwen/qwq-32b': {
 		...openSourceModelOptions_assumingOAICompat['qwq'],
 		contextWindow: 33_000,
 		maxOutputTokens: null,
-		supportsTools: false, // openrouter qwen doesn't seem to support tools...?
 		cost: { input: 0.07, output: 0.16 },
+		downloadable: false,
 	}
-} as const satisfies { [s: string]: ModelOptions }
+} as const satisfies { [s: string]: VoidStaticModelInfo }
 
-const openRouterSettings: ProviderSettings = {
+const openRouterSettings: VoidStaticProviderInfo = {
 	// reasoning: OAICompat + response.choices[0].delta.reasoning : payload should have {include_reasoning: true} https://openrouter.ai/announcements/reasoning-tokens-for-thinking-models
 	providerReasoningIOSettings: {
 		input: {
@@ -750,7 +987,7 @@ const openRouterSettings: ProviderSettings = {
 
 // ---------------- model settings of everything above ----------------
 
-const modelSettingsOfProvider: { [providerName in ProviderName]: ProviderSettings } = {
+const modelSettingsOfProvider: { [providerName in ProviderName]: VoidStaticProviderInfo } = {
 	openAI: openAISettings,
 	anthropic: anthropicSettings,
 	xAI: xAISettings,
@@ -765,8 +1002,7 @@ const modelSettingsOfProvider: { [providerName in ProviderName]: ProviderSetting
 	vLLM: vLLMSettings,
 	ollama: ollamaSettings,
 	openAICompatible: openaiCompatible,
-
-	// TODO!!!
+	mistral: mistralSettings,
 	// googleVertex: {},
 	// microsoftAzure: {},
 	// openHands: {},
@@ -776,8 +1012,10 @@ const modelSettingsOfProvider: { [providerName in ProviderName]: ProviderSetting
 // ---------------- exports ----------------
 
 // returns the capabilities and the adjusted modelName if it was a fallback
-export const getModelCapabilities = (providerName: ProviderName, modelName: string): ModelOptions & { modelName: string; isUnrecognizedModel: boolean } => {
+export const getModelCapabilities = (providerName: ProviderName, modelName: string): VoidStaticModelInfo & { modelName: string; isUnrecognizedModel: boolean } => {
+
 	const lowercaseModelName = modelName.toLowerCase()
+
 	const { modelOptions, modelOptionsFallback } = modelSettingsOfProvider[providerName]
 
 	// search model options object directly first
@@ -824,6 +1062,14 @@ export const getIsReasoningEnabledState = (
 }
 
 
+export const getMaxOutputTokens = (providerName: ProviderName, modelName: string, opts: { isReasoningEnabled: boolean }) => {
+	const {
+		reasoningCapabilities,
+		maxOutputTokens
+	} = getModelCapabilities(providerName, modelName)
+	return opts.isReasoningEnabled && reasoningCapabilities ? reasoningCapabilities.reasoningMaxOutputTokens : maxOutputTokens
+}
+
 // used to force reasoning state (complex) into something simple we can just read from when sending a message
 export const getSendableReasoningInfo = (
 	featureName: FeatureName,

src/vs/workbench/contrib/void/common/prompt/prompts.ts

@@ -3,16 +3,29 @@
  *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
  *--------------------------------------------------------------------------------------*/
 
-import { os } from '../helpers/systemInfo.js';
-import { StagingSelectionItem } from '../chatThreadServiceTypes.js';
-import { ChatMode } from '../voidSettingsTypes.js';
-import { InternalToolInfo } from '../toolsServiceTypes.js';
-import { IVoidModelService } from '../voidModelService.js';
 import { EndOfLinePreference } from '../../../../../editor/common/model.js';
+import { StagingSelectionItem } from '../chatThreadServiceTypes.js';
+import { os } from '../helpers/systemInfo.js';
+import { RawToolParamsObj } from '../sendLLMMessageTypes.js';
+import { toolNamesThatRequireApproval } from '../toolsServiceTypes.js';
+import { IVoidModelService } from '../voidModelService.js';
+import { ChatMode } from '../voidSettingsTypes.js';
 
-// this is just for ease of readability
+// Triple backtick wrapper used throughout the prompts for code blocks
 export const tripleTick = ['```', '```']
 
+// Maximum limits for directory structure information
+export const MAX_DIRSTR_CHARS_TOTAL_BEGINNING = 20_000
+export const MAX_DIRSTR_CHARS_TOTAL_TOOL = 20_000
+export const MAX_DIRSTR_RESULTS_TOTAL_BEGINNING = 100
+export const MAX_DIRSTR_RESULTS_TOTAL_TOOL = 100
+
+
+// Maximum character limits for prefix and suffix context
+export const MAX_PREFIX_SUFFIX_CHARS = 20_000
+
+
+// ======================================================== tools ========================================================
 const changesExampleContent = `\
 // ... existing code ...
 // {{change 1}}
@@ -22,35 +35,34 @@ const changesExampleContent = `\
 // {{change 3}}
 // ... existing code ...`
 
-const editToolDescription = `\
+const editToolDescriptionExample = `\
 ${tripleTick[0]}
 ${changesExampleContent}
 ${tripleTick[1]}`
 
-const fileNameEdit = `${tripleTick[0]}typescript
+const fileNameEditExample = `${tripleTick[0]}typescript
 /Users/username/Dekstop/my_project/app.ts
 ${changesExampleContent}
 ${tripleTick[1]}`
 
 
 
+export type InternalToolInfo = {
+	name: string,
+	description: string,
+	params: {
+		[paramName: string]: { description: string }
+	},
+}
 
 
-// ======================================================== tools ========================================================
-
-const paginationHelper = {
-	desc: `Very large results may be paginated (a note will always be included if pagination took place). Pagination fails gracefully if out of bounds or invalid page number.`,
-	param: { pageNumber: { type: 'number', description: 'The page number (default is the first page = 1).' }, }
-} as const
 
 const uriParam = (object: string) => ({
-	uri: { type: 'string', description: `The FULL path to the ${object}.` }
+	uri: { description: `The FULL path to the ${object}.` }
 })
 
-
-const searchParams = {
-	searchInFolder: { type: 'string', description: 'Only search files in this given folder. Leave as empty to search all available files.' },
-	isRegex: { type: 'string', description: 'Whether to treat the query as a regular expression. Default is "false".' },
+const paginationParam = {
+	page_number: { description: 'Optional. The page number of the result. Default is 1.' }
 } as const
 
 
@@ -59,49 +71,64 @@ export const voidTools = {
 
 	read_file: {
 		name: 'read_file',
-		description: `Returns file contents of a given URI. ${paginationHelper.desc}`,
+		description: `Returns full contents of a given file.`,
 		params: {
 			...uriParam('file'),
-			startLine: { type: 'string', description: 'Line to start reading from. Default is "null", treated as 1.' },
-			endLine: { type: 'string', description: 'Line to stop reading from (inclusive). Default is "null", treated as Infinity.' },
-			...paginationHelper.param,
+			start_line: { description: 'Optional. Only fill this in if you already know the line numbers you need to search. Defaults to 1.' },
+			end_line: { description: 'Optional. Only fill this in if you already know the line numbers you need to search. Defaults to Infinity.' },
+			...paginationParam,
 		},
 	},
 
 	ls_dir: {
 		name: 'ls_dir',
-		description: `Returns all file names and folder names in a given folder. ${paginationHelper.desc}`,
+		description: `Lists all files and folders in the given URI.`,
 		params: {
-			...uriParam('folder'),
-			...paginationHelper.param,
+			uri: { description: `Optional. The FULL path to the ${'folder'}. Leave this as empty or "" to search all folders.` },
+			...paginationParam,
 		},
 	},
 
 	get_dir_structure: {
 		name: 'get_dir_structure',
-		description: `This is a very effective way to learn about the user's codebase. You might want to use this instead of ls_dir. Returns a tree diagram of all the files and folders in the given folder URI. If results are large, the given string will be truncated (this will be indicated), in which case you might want to call this tool on a lower folder to get better results, or just use ls_dir which supports pagination.`,
+		description: `This is a very effective way to learn about the user's codebase. Returns a tree diagram of all the files and folders in the given folder. `,
 		params: {
 			...uriParam('folder')
 		}
 	},
 
+	// pathname_search: {
+	// 	name: 'pathname_search',
+	// 	description: `Returns all pathnames that match a given \`find\`-style query over the entire workspace. ONLY searches file names. ONLY searches the current workspace. You should use this when looking for a file with a specific name or path. ${paginationHelper.desc}`,
+
 	search_pathnames_only: {
 		name: 'search_pathnames_only',
-		description: `Returns all pathnames that match a given query (searches ONLY file names). You should use this when looking for a file with a specific name or path. ${paginationHelper.desc}`,
+		description: `Returns all pathnames that match a given query (searches ONLY file names). You should use this when looking for a file with a specific name or path.`,
 		params: {
-			query: { type: 'string', description: undefined },
-			...searchParams,
-			...paginationHelper.param,
+			query: { description: `Your query for the search.` },
+			search_in_folder: { description: 'Optional. Only fill this in if you need to limit your search because there were too many results.' },
+			...paginationParam,
 		},
 	},
 
-	search_files: {
-		name: 'search_files',
-		description: `Returns all pathnames that match a given \`grep\`-style query (searches ONLY file contents). The query can be any regex. This is often followed by the \`read_file\` tool to view the full file contents of results. ${paginationHelper.desc}`,
+
+
+	search_for_files: {
+		name: 'search_for_files',
+		description: `Returns a list of file names whose content matches the given query. The query can be any substring or regex.`,
 		params: {
-			query: { type: 'string', description: undefined },
-			...searchParams,
-			...paginationHelper.param,
+			query: { description: `Your query for the search.` },
+			search_in_folder: { description: 'Optional. Only fill this in if you need to limit your search because there were too many results.' },
+			is_regex: { description: 'Optional. Default is false. Whether query is a regex.' },
+			...paginationParam,
+		},
+	},
+
+	read_lint_errors: {
+		name: 'read_lint_errors',
+		description: `Returns all lint errors on a given file.`,
+		params: {
+			...uriParam('file'),
 		},
 	},
 
@@ -109,7 +136,7 @@ export const voidTools = {
 
 	create_file_or_folder: {
 		name: 'create_file_or_folder',
-		description: `Create a file or folder at the given path. To create a folder, ensure the path ends with a trailing slash. Fails gracefully if the file already exists. Missing ancestors in the path will be recursively created automatically.`,
+		description: `Create a file or folder at the given path. To create a folder, the path MUST end with a trailing slash.`,
 		params: {
 			...uriParam('file or folder'),
 		},
@@ -117,25 +144,24 @@ export const voidTools = {
 
 	delete_file_or_folder: {
 		name: 'delete_file_or_folder',
-		description: `Delete a file or folder at the given path. Fails gracefully if the file or folder does not exist.`,
+		description: `Delete a file or folder at the given path.`,
 		params: {
 			...uriParam('file or folder'),
-			params: { type: 'string', description: 'Return -r here to delete recursively (if applicable). Default is the empty string.' }
+			params: { description: 'Optional. Return -r here to delete recursively.' }
 		},
 	},
 
 	edit_file: { // APPLY TOOL
 		name: 'edit_file',
-		description: `Edits the contents of a file, given the file's URI and a description. Fails gracefully if the file does not exist.`,
+		description: `Edits the contents of a file given the file's URI and a description.`,
 		params: {
 			...uriParam('file'),
-			changeDescription: {
-				type: 'string', description: `\
-- Your changeDescription should be a brief code description of the change you want to make, with comments like "// ... existing code ..." to condense your writing.
-- NEVER re-write the whole file, and ALWAYS use comments like "// ... existing code ...". Bias towards writing as little as possible.
-- Your description will be handed to a dumber, faster model that will quickly apply the change, so it should be clear and concise.
-- You must output your description in triple backticks.
-Here's an example of a good description:\n${editToolDescription}.`
+			change_description: {
+				description: `\
+Your description MUST be wrapped in triple backticks. \
+A code description of the change you want to make, with comments like "// ... existing code ..." to condense your writing. \
+NEVER re-write the whole file. Bias towards writing as little as possible. \
+Here's an example of a good description:\n${editToolDescriptionExample}`
 			}
 		},
 	},
@@ -144,161 +170,197 @@ Here's an example of a good description:\n${editToolDescription}.`
 		name: 'run_terminal_command',
 		description: `Executes a terminal command.`,
 		params: {
-			command: { type: 'string', description: 'The terminal command to execute. Typically you should pipe to cat to avoid pagination.' },
-			waitForCompletion: { type: 'string', description: `Whether or not to await the command to complete and get the final result. Default is true. Make this value false when you want a command to run indefinitely without waiting for it.` },
-			terminalId: { type: 'string', description: 'Optional (value must be an integer >= 1, or empty which will go with the default). This is the ID of the terminal instance to execute the command in. The primary purpose of this is to start a new terminal for background processes or tasks that run indefinitely (e.g. if you want to run a server locally). Fails gracefully if a terminal ID does not exist, by creating a new terminal instance. Defaults to the preferred terminal ID.' },
+			command: { description: 'The terminal command to execute. If working with tools like git that can paginate, you should pipe to cat so results are not truncated.' },
+			wait_for_completion: { description: `Optional. Default is true. Make this value false when you want a command to run without waiting for it to complete.` },
+			terminal_id: { description: 'Optional. The ID of the terminal instance that should execute the command (if not provided, defaults to the preferred terminal ID). The primary purpose of this is to let you open a new terminal for testing or background processes (e.g. running a dev server for the user in a separate terminal). Must be an integer >= 1.' },
 		},
 	},
 
-
 	// go_to_definition
 	// go_to_usages
 
 } satisfies { [name: string]: InternalToolInfo }
 
 
+export type ToolName = keyof typeof voidTools
+export const toolNames = Object.keys(voidTools) as ToolName[]
 
+type ToolParamNameOfTool<T extends ToolName> = keyof (typeof voidTools)[T]['params']
+export type ToolParamName = { [T in ToolName]: ToolParamNameOfTool<T> }[ToolName]
 
+const toolNamesSet = new Set<string>(toolNames)
+
+export const isAToolName = (toolName: string): toolName is ToolName => {
+	const isAToolName = toolNamesSet.has(toolName)
+	return isAToolName
+}
+
+export const availableTools = (chatMode: ChatMode) => {
+	const toolNames: ToolName[] | undefined = chatMode === 'normal' ? undefined
+		: chatMode === 'gather' ? (Object.keys(voidTools) as ToolName[]).filter(toolName => !toolNamesThatRequireApproval.has(toolName))
+			: chatMode === 'agent' ? Object.keys(voidTools) as ToolName[]
+				: undefined
+
+	const tools: InternalToolInfo[] | undefined = toolNames?.map(toolName => voidTools[toolName])
+	return tools
+}
+
+const toolCallDefinitionsXMLString = (tools: InternalToolInfo[]) => {
+	return `${tools.map((t, i) => {
+		const params = Object.keys(t.params).map(paramName => `<${paramName}>${t.params[paramName].description}</${paramName}>`).join('\n')
+		return `\
+${i + 1}. ${t.name}
+Description: ${t.description}
+Format:
+<${t.name}>${!params ? '' : `\n${params}`}
+</${t.name}>`
+	}).join('\n\n')}`
+}
+
+export const reParsedToolXMLString = (toolName: ToolName, toolParams: RawToolParamsObj) => {
+	const params = Object.keys(toolParams).map(paramName => `<${paramName}>${toolParams[paramName as ToolParamName]}</${paramName}>`).join('\n')
+	return `\
+<${toolName}>${!params ? '' : `\n${params}`}
+</${toolName}>`
+		.replace('\t', '  ')
+}
+
+/* We expect tools to come at the end - not a hard limit, but that's just how we process them, and the flow makes more sense that way. */
+// - You are allowed to call multiple tools by specifying them consecutively. However, there should be NO text or writing between tool calls or after them.
+const systemToolsXMLPrompt = (chatMode: ChatMode) => {
+	const tools = availableTools(chatMode)
+	if (!tools || tools.length === 0) return null
+
+	const toolXMLDefinitions = (`\
+Available tools:
+
+${toolCallDefinitionsXMLString(tools)}`)
+
+	const toolCallXMLGuidelines = (`\
+Tool calling details:
+- To call a tool, write its name and parameters in one of the XML formats specified above.
+- After you write the tool call, you must STOP and WAIT for the result.
+- All parameters are REQUIRED unless noted otherwise.
+- You are only allowed to output ONE tool call, and it must be at the END of your response.
+- Your tool call will be executed immediately, and the results will appear in the following user message.`)
+
+	return `\
+${toolXMLDefinitions}
+
+${toolCallXMLGuidelines}`
+}
 
 // ======================================================== chat (normal, gather, agent) ========================================================
 
 
+export const chat_systemMessage = ({ workspaceFolders, openedURIs, activeURI, runningTerminalIds, directoryStr, chatMode: mode, includeXMLToolDefinitions }: { workspaceFolders: string[], directoryStr: string, openedURIs: string[], activeURI: string | undefined, runningTerminalIds: string[], chatMode: ChatMode, includeXMLToolDefinitions: boolean }) => {
+	const header = (`You are an expert coding ${mode === 'agent' ? 'agent' : 'assistant'} whose job is \
+${mode === 'agent' ? `to help the user develop, run, and make changes to their codebase.`
+			: mode === 'gather' ? `to search, understand, and reference files in the user's codebase.`
+				: mode === 'normal' ? `to assist the user with their coding tasks.`
+					: ''}
+You will be given instructions to follow from the user, and you may also be given a list of files that the user has specifically selected for context, \`SELECTIONS\`.
+Please assist the user with their query.`)
 
-export const chat_systemMessage = ({ workspaceFolders, openedURIs, activeURI, runningTerminalIds, directoryStr, chatMode: mode }: { workspaceFolders: string[], directoryStr: string, openedURIs: string[], activeURI: string | undefined, runningTerminalIds: string[], chatMode: ChatMode }) => `\
-You are an expert coding ${mode === 'agent' ? 'agent' : 'assistant'} that runs in the user's IDE called Void. Your job is \
-${mode === 'agent' ? `to help the user develop, run, deploy, and make changes to their codebase. You should ALWAYS bring user's task to completion to the fullest extent possible, calling tools to make all necessary changes.`
-		: mode === 'gather' ? `to search and understand the user's codebase. You MUST use tools to read files and help the user understand the codebase, even if you were initially given files.`
-			: mode === 'normal' ? `to assist the user with their coding tasks.`
-				: ''}
-You will be given instructions to follow from the user, \`INSTRUCTIONS\`. You may also be given a list of files that the user has specifically selected, \`SELECTIONS\`.
-Please assist the user with their query. The user's query is never invalid.
-${/* system info */''}
-The user's system information is as follows:
+
+
+	const sysInfo = (`Here is the user's system information:
+<system_info>
 - ${os}
-- Open workspace(s): ${workspaceFolders.join(', ') || 'NO WORKSPACE OPEN'}
-- Open tab(s): ${openedURIs.join(', ') || 'NO OPENED EDITORS'}
-- Active tab: ${activeURI}
-${(mode === 'agent') && runningTerminalIds.length !== 0 ? `
+
+- Open workspaces:
+${workspaceFolders.join('\n') || 'NO WORKSPACE OPEN'}
+
+- Active file:
+${activeURI}
+
+- Open files:
+${openedURIs.join('\n') || 'NO OPENED EDITORS'}${''/* separator */}${mode === 'agent' && runningTerminalIds.length !== 0 ? `
+
 - Existing terminal IDs: ${runningTerminalIds.join(', ')}` : ''}
-
-${/* tool use */ mode === 'agent' || mode === 'gather' ? `\
-You will be given tools you can call.
-${mode === 'agent' ? `\
-- Only use tools if they help you accomplish the user's goal. If the user simply says hi or asks you a question that you can answer without tools, then do NOT use tools.
-- ALWAYS use tools to take actions. For example, if you would like to edit a file, you MUST use a tool.
-- You will OFTEN need to gather context before making a change. Do not immediately make a change unless you have ALL relevant context.
-- ALWAYS have maximal certainty in a change BEFORE you make it. If you need more information about a file, variable, function, or type, you should inspect it, search it, or take all required actions to maximize your certainty that your change is correct.`
-			: mode === 'gather' ? `\
-- Your primary use of tools should be to gather information to help the user understand the codebase and answer their query.
-- You should extensively read files, types, etc and gather relevant context.`
-				: ''}
-- If you think you should use tools, you do not need to ask for permission. Feel free to call tools whenever you'd like. You can use them to understand the codebase, ${mode === 'agent' ? 'run terminal commands, edit files, ' : 'gather relevant files and information, '}etc.
-- NEVER refer to a tool by name when speaking with the user (NEVER say something like "I'm going to use \`tool_name\`"). Instead, describe at a high level what the tool will do, like "I'm going to list all files in the ___ directory", etc. Also do not refer to "pages" of results, just say you're getting more results.
-- Some tools only work if the user has a workspace open.${mode === 'agent' ? `
-- NEVER modify a file outside the user's workspace(s) without permission from the user.` : ''}
-\
-`: `\
-You're allowed to ask for more context. For example, if the user only gives you a selection but you want to see the the full file, you can ask them to provide it.
-\
-`}
-${/* code blocks */ mode === 'agent' ? `\
-Behavior:
-- Always use tools (edit, terminal, etc) to take actions and implement changes. Don't just describe them.
-- Prioritize taking as many steps as you need to complete your request over stopping early.\
-`: `\
-If you think it's appropriate to suggest an edit to a file, then you must describe your suggestion in CODE BLOCK(S) (wrapped in triple backticks).
-- The first line of the code block must be the FULL PATH of the file you want to change.
-- The remaining contents should be a brief code description of the change you want to make, with comments like "// ... existing code ..." to condense your writing.
-- NEVER re-write the whole file, and ALWAYS use comments like "// ... existing code ...". Bias towards writing as little as possible.
-- Your description will be handed to a dumber, faster model that will quickly apply the change, so it should be clear and concise.
-Here's an example of a good code block:\n${fileNameEdit}.
-
-If you write a code block that's related to a specific file, please use the same format as above:
-- The first line of the code block must be the FULL PATH of the related file if known.
-- The remaining contents of the file should proceed as usual.
-\
-`}
-${/* misc */''}
-Misc:
-- Do not make things up.
-- Do not be lazy.
-- NEVER re-write the entire file.
-- Always wrap any code you produce in triple backticks, and specify a language if possible. For example, ${tripleTick[0]}typescript\n...\n${tripleTick[1]}.
-- Today's date is ${new Date().toDateString()}
-The user's codebase is structured as follows:\n${directoryStr}
-\
-`
-// agent mode doesn't know about 1st line paths yet
-// - If you wrote triple ticks and ___, then include the file's full path in the first line of the triple ticks. This is only for display purposes to the user, and it's preferred but optional. Never do this in a tool parameter, or if there's ambiguity about the full path.
+</system_info>`)
 
 
-// type FileSelnLocal = { fileURI: URI, language: string, content: string }
-// const stringifyFileSelection = ({ fileURI, language, content }: FileSelnLocal) => {
-// 	return `\
-// ${fileURI.fsPath}
-// ${tripleTick[0]}${language}
-// ${content}
-// ${tripleTick[1]}
-// `
-// }
-// const stringifyCodeSelection = ({ uri, language, range }: StagingSelectionItem & { type: 'CodeSelection' }) => {
-// 	return `\
+	const fsInfo = (`Here is an overview of the user's file system:
+<files_overview>
+${directoryStr}
+</files_overview>`)
 
-// ${tripleTick[0]}${language}
-// ${selectionStr}
-// ${tripleTick[1]}
-// `
+
+	const toolDefinitions = includeXMLToolDefinitions ? systemToolsXMLPrompt(mode) : null
+
+	const details: string[] = []
+
+	if (mode === 'agent' || mode === 'gather') {
+		details.push(`Only call tools if they help you accomplish the user's goal. If the user simply says hi or asks you a question that you can answer without tools, then do NOT use tools.`)
+		details.push('Only use ONE tool call at a time, and always wait for the result before proceeding.') // XML
+		details.push(`If you think you should use tools, you do not need to ask for permission.`)
+		details.push(`NEVER say something like "I'm going to use \`tool_name\`". Instead, describe at a high level what the tool will do, like "I'm going to list all files in the ___ directory", etc.`)
+		details.push(`Many tools only work if the user has a workspace open.`)
+	}
+	else {
+		details.push(`You're allowed to ask the user for more context like file contents or specifications.`)
+	}
+
+	if (mode === 'agent') {
+		details.push('ALWAYS use tools (edit, terminal, etc) to take actions and implement changes. For example, if you would like to edit a file, you MUST use a tool.')
+		details.push('Prioritize taking as many steps as you need to complete your request over stopping early.')
+		details.push(`You will OFTEN need to gather context before making a change. Do not immediately make a change unless you have ALL relevant context.`)
+		details.push(`ALWAYS have maximal certainty in a change BEFORE you make it. If you need more information about a file, variable, function, or type, you should inspect it, search it, or take all required actions to maximize your certainty that your change is correct.`)
+		details.push(`NEVER modify a file outside the user's workspace(s) without permission from the user.`)
+	}
+
+	if (mode === 'gather') {
+		details.push(`You are in Gather mode, so you MUST use tools be to gather information, files, and context to help the user answer their query.`)
+		details.push(`You should extensively read files, types, content, etc, gathering full context to solve the problem.`)
+	}
+
+
+	if (mode === 'gather' || mode === 'normal') {
+		details.push(`If you write any code blocks, please use this format:
+- The first line of the code block must be the FULL PATH of the related file if known (otherwise omit).
+- The remaining contents of the file should proceed as usual.`)
+
+		details.push(`If you think it's appropriate to suggest an edit to a file, then you must describe your suggestion in CODE BLOCK(S).
+- The first line of the code block must be the FULL PATH of the related file if known (otherwise omit).
+- The remaining contents should be \
+a brief code description of the change you want to make, with comments like "// ... existing code ..." to condense your writing. \
+NEVER re-write the whole file. Instead, use comments like  "// ... existing code ...". Bias towards writing as little as possible. \
+Here's an example of a good edit suggestion:
+${fileNameEditExample}.`)
+	}
+
+	details.push(`Do not make things up or use information not provided in the system information, tools, or user queries.`)
+	details.push(`Today's date is ${new Date().toDateString()}.`)
+
+	const importantDetails = (`Important notes:
+${details.map((d, i) => `${i + 1}. ${d}`).join('\n\n')}`)
+
+
+	// return answer
+	const ansStrs: string[] = []
+	ansStrs.push(header)
+	ansStrs.push(sysInfo)
+	if (toolDefinitions) ansStrs.push(toolDefinitions)
+	ansStrs.push(importantDetails)
+	ansStrs.push(fsInfo)
+
+	const fullSystemMsgStr = ansStrs
+		.join('\n\n\n')
+		.trim()
+		.replace('\t', '  ')
+
+	return fullSystemMsgStr
+
+}
+
+
+// // log all prompts
+// for (const chatMode of ['agent', 'gather', 'normal'] satisfies ChatMode[]) {
+// 	console.log(`========================================= SYSTEM MESSAGE FOR ${chatMode} ===================================\n`,
+// 		chat_systemMessage({ chatMode, workspaceFolders: [], openedURIs: [], activeURI: 'pee', runningTerminalIds: [], directoryStr: 'lol', }))
 // }
 
-// const failToReadStr = 'Could not read content. This file may have been deleted. If you expected content here, you can tell the user about this as they might not know.'
-// const stringifyFileSelections = async (fileSelections: FileSelection[], voidModelService: IVoidModelService) => {
-// 	if (fileSelections.length === 0) return null
-// 	const fileSlns: FileSelnLocal[] = await Promise.all(fileSelections.map(async (sel) => {
-// 		const { model } = await voidModelService.getModelSafe(sel.fileURI)
-// 		const content = model?.getValue(EndOfLinePreference.LF) ?? failToReadStr
-// 		return { ...sel, content }
-// 	}))
-// 	return fileSlns.map(sel => stringifyFileSelection(sel)).join('\n')
-// }
-
-
-
-
-// export const chat_selectionsString = async (
-// 	prevSelns: StagingSelectionItem[] | null, currSelns: StagingSelectionItem[] | null,
-// 	voidModelService: IVoidModelService,
-// ) => {
-
-// 	// ADD IN FILES AT TOP
-// 	const allSelections = [...currSelns || [], ...prevSelns || []]
-
-// 	if (allSelections.length === 0) return null
-
-// 	for (const selection of allSelections) {
-// 		if (selection.type === 'Selection') {
-// 			codeSelections.push(selection)
-// 		}
-// 		else if (selection.type === 'File') {
-// 			const fileSelection = selection
-// 			const path = fileSelection.fileURI.fsPath
-// 			if (!filesURIs.has(path)) {
-// 				filesURIs.add(path)
-// 				fileSelections.push(fileSelection)
-// 			}
-// 		}
-// 	}
-
-// 	const filesStr = await stringifyFileSelections(fileSelections, voidModelService)
-// 	const selnsStr = stringifyCodeSelections(codeSelections)
-
-// 	const fileContents = [filesStr, selnsStr].filter(Boolean).join('\n')
-// 	return fileContents || null
-// }
-
-// export const chat_lastUserMessageWithFilesAdded = (userMessage: string, selectionsString: string | null) => {
-// 	if (userMessage) return `${userMessage}${selectionsString ? `\n${selectionsString}` : ''}`
-// 	else return userMessage
-// }
 
 export const chat_userMessageContent = async (instructions: string, currSelns: StagingSelectionItem[] | null,
 	opts: { type: 'references' } | { type: 'fullCode', voidModelService: IVoidModelService }
@@ -400,13 +462,13 @@ Output SEARCH/REPLACE blocks to edit the file according to the desired change. Y
 
 Directions:
 1. Your OUTPUT should consist ONLY of SEARCH/REPLACE blocks. Do NOT output any text or explanations before or after this.
-2. The "ORIGINAL" code in each SEARCH/REPLACE block must EXACTLY match lines in the original file. This includes whitespace, comments, and other details.
-3. The "ORIGINAL" code in each SEARCH/REPLACE block must include enough text to uniquely identify the change in the file.
+2. The "ORIGINAL" code in each SEARCH/REPLACE block must EXACTLY match lines in the original file. The original code must NOT includes any new whitespace, comments, or any other modifications from the original code.
+3. The "ORIGINAL" code in each SEARCH/REPLACE block must include enough text to uniquely identify the change in the file, but please bias towards writing as little as possible.
 4. The "ORIGINAL" code in each SEARCH/REPLACE block must be disjoint from all other blocks.
 
 The SEARCH/REPLACE blocks you generate will be applied immediately, and so they **MUST** produce a file that the user can run IMMEDIATELY.
 - Make sure you add all necessary imports.
-- Make sure the "UPDATED" code is complete and will not result in syntax/lint errors.
+- Make sure the "UPDATED" code is ready for production as-is, and fix any relevant lint errors.
 
 Follow coding conventions of the user (spaces, semilcolons, comments, etc). If the user spaces or formats things a certain way, CONTINUE formatting it that way, even if you prefer otherwise.
 
@@ -453,8 +515,6 @@ export const voidPrefixAndSuffix = ({ fullFileStr, startLine, endLine }: { fullF
 
 	const fullFileLines = fullFileStr.split('\n')
 
-	// we can optimize this later
-	const MAX_PREFIX_SUFFIX_CHARS = 20_000
 	/*
 
 	a
@@ -527,10 +587,16 @@ Instructions:
 `
 }
 
-export const ctrlKStream_userMessage = ({ selection, prefix, suffix, instructions, fimTags, isOllamaFIM, language }: {
-	selection: string, prefix: string, suffix: string, instructions: string, fimTags: QuickEditFimTagsType, language: string,
-	isOllamaFIM: false, // we require this be false for clarity
-}) => {
+export const ctrlKStream_userMessage = ({
+	selection,
+	prefix,
+	suffix,
+	instructions,
+	// isOllamaFIM: false, // Remove unused variable
+	fimTags,
+	language }: {
+		selection: string, prefix: string, suffix: string, instructions: string, fimTags: QuickEditFimTagsType, language: string,
+	}) => {
 	const { preTag, sufTag, midTag } = fimTags
 
 	// prompt the model artifically on how to do FIM
@@ -560,6 +626,7 @@ ${tripleTick[1]}).`
 
 
 
+
 /*
 // ======================================================== ai search/replace ========================================================
 

src/vs/workbench/contrib/void/common/sendLLMMessageService.ts

@@ -13,7 +13,6 @@ import { generateUuid } from '../../../../base/common/uuid.js';
 import { Event } from '../../../../base/common/event.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
 import { IVoidSettingsService } from './voidSettingsService.js';
-// import { INotificationService } from '../../notification/common/notification.js';
 
 // calls channel to implement features
 export const ILLMMessageService = createDecorator<ILLMMessageService>('llmMessageService');
@@ -98,6 +97,7 @@ export class LLMMessageService extends Disposable implements ILLMMessageService
 			return null
 		}
 
+		const { settingsOfProvider, } = this.voidSettingsService.state
 
 		// add state for request id
 		const requestId = generateUuid();
@@ -106,13 +106,9 @@ export class LLMMessageService extends Disposable implements ILLMMessageService
 		this.llmMessageHooks.onError[requestId] = onError
 		this.llmMessageHooks.onAbort[requestId] = onAbort // used internally only
 
-		const { aiInstructions } = this.voidSettingsService.state.globalSettings
-		const { settingsOfProvider, } = this.voidSettingsService.state
-
 		// params will be stripped of all its functions over the IPC channel
 		this.channel.call('sendLLMMessage', {
 			...proxyParams,
-			aiInstructions,
 			requestId,
 			settingsOfProvider,
 			modelSelection,

src/vs/workbench/contrib/void/common/sendLLMMessageTypes.ts

@@ -3,8 +3,8 @@
  *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
  *--------------------------------------------------------------------------------------*/
 
-import { ToolName, InternalToolInfo } from './toolsServiceTypes.js'
-import { ModelSelection, ModelSelectionOptions, ProviderName, SettingsOfProvider } from './voidSettingsTypes.js'
+import { ToolName, ToolParamName } from './prompt/prompts.js'
+import { ChatMode, ModelSelection, ModelSelectionOptions, ProviderName, SettingsOfProvider } from './voidSettingsTypes.js'
 
 
 export const errorDetails = (fullError: Error | null): string | null => {
@@ -27,38 +27,33 @@ export const getErrorMessage: (error: unknown) => string = (error) => {
 }
 
 
-export type LLMChatMessage = {
-	role: 'system';
-	content: string;
+
+export type AnthropicLLMChatMessage = {
+	role: 'assistant',
+	content: string | (AnthropicReasoning | { type: 'text'; text: string }
+		| { type: 'tool_use'; name: string; input: Record<string, any>; id: string; }
+	)[];
 } | {
-	role: 'user';
+	role: 'user',
+	content: string | (
+		{ type: 'text'; text: string; } | { type: 'tool_result'; tool_use_id: string; content: string; }
+	)[]
+}
+export type OpenAILLMChatMessage = {
+	role: 'system' | 'user' | 'developer';
 	content: string;
 } | {
 	role: 'assistant',
-	content: string; // text content
-	anthropicReasoning: AnthropicReasoning[] | null;
+	content: string | (AnthropicReasoning | { type: 'text'; text: string })[];
+	tool_calls?: { type: 'function'; id: string; function: { name: string; arguments: string; } }[];
 } | {
-	role: 'tool';
-	content: string; // result
-	name: string;
-	params: string;
-	id: string;
+	role: 'tool',
+	content: string;
+	tool_call_id: string;
 }
+export type LLMChatMessage = AnthropicLLMChatMessage | OpenAILLMChatMessage
 
 
-export type ToolCallType = {
-	name: ToolName;
-	paramsStr: string;
-	id: string;
-}
-
-export type AnthropicReasoning = ({ type: 'thinking'; thinking: any; signature: string; } | { type: 'redacted_thinking', data: any })
-
-export type OnText = (p: { fullText: string; fullReasoning: string; fullToolName: string; fullToolParams: string; }) => void
-export type OnFinalMessage = (p: { fullText: string; fullReasoning: string; toolCalls?: ToolCallType[]; anthropicReasoning: AnthropicReasoning[] | null }) => void // id is tool_use_id
-export type OnError = (p: { message: string; fullError: Error | null }) => void
-export type OnAbort = () => void
-export type AbortRef = { current: (() => void) | null }
 
 
 export type LLMFIMMessage = {
@@ -67,17 +62,39 @@ export type LLMFIMMessage = {
 	stopTokens: string[];
 }
 
+
+export type RawToolParamsObj = {
+	[paramName in ToolParamName]?: string;
+}
+export type RawToolCallObj = {
+	name: ToolName;
+	rawParams: RawToolParamsObj;
+	doneParams: ToolParamName[];
+	id: string;
+	isDone: boolean;
+};
+
+export type AnthropicReasoning = ({ type: 'thinking'; thinking: any; signature: string; } | { type: 'redacted_thinking', data: any })
+
+export type OnText = (p: { fullText: string; fullReasoning: string; toolCall?: RawToolCallObj }) => void
+export type OnFinalMessage = (p: { fullText: string; fullReasoning: string; toolCall?: RawToolCallObj; anthropicReasoning: AnthropicReasoning[] | null }) => void // id is tool_use_id
+export type OnError = (p: { message: string; fullError: Error | null }) => void
+export type OnAbort = () => void
+export type AbortRef = { current: (() => void) | null }
+
+
+// service types
 type SendLLMType = {
 	messagesType: 'chatMessages';
-	messages: LLMChatMessage[];
-	tools?: InternalToolInfo[];
+	messages: LLMChatMessage[]; // the type of raw chat messages that we send to Anthropic, OAI, etc
+	separateSystemMessage: string | undefined;
+	chatMode: ChatMode | null;
 } | {
 	messagesType: 'FIMMessage';
 	messages: LLMFIMMessage;
-	tools?: undefined;
+	separateSystemMessage?: undefined;
+	chatMode?: undefined;
 }
-
-// service types
 export type ServiceSendLLMMessageParams = {
 	onText: OnText;
 	onFinalMessage: OnFinalMessage;
@@ -96,8 +113,6 @@ export type SendLLMMessageParams = {
 	logging: { loggingName: string, loggingExtras?: { [k: string]: any } };
 	abortRef: AbortRef;
 
-	aiInstructions: string;
-
 	modelSelection: ModelSelection;
 	modelSelectionOptions: ModelSelectionOptions | undefined;
 

src/vs/workbench/contrib/void/common/toolsServiceTypes.ts

@@ -1,11 +1,12 @@
 import { URI } from '../../../../base/common/uri.js'
-import { voidTools } from './prompt/prompts.js';
-
+import { ToolName } from './prompt/prompts.js';
 
 
 
 export type TerminalResolveReason = { type: 'toofull' | 'timeout' | 'bgtask' } | { type: 'done', exitCode: number }
 
+export type LintErrorItem = { code: string, message: string, startLineNumber: number, endLineNumber: number }
+
 // Partial of IFileStat
 export type ShallowDirectoryItem = {
 	uri: URI;
@@ -14,26 +15,6 @@ export type ShallowDirectoryItem = {
 	isSymbolicLink: boolean;
 }
 
-// we do this using Anthropic's style and convert to OpenAI style later
-export type InternalToolInfo = {
-	name: string,
-	description: string,
-	params: {
-		[paramName: string]: { type: string, description: string | undefined } // name -> type
-	},
-}
-
-
-
-
-export type ToolName = keyof typeof voidTools
-export const toolNames = Object.keys(voidTools) as ToolName[]
-
-const toolNamesSet = new Set<string>(toolNames)
-export const isAToolName = (toolName: string): toolName is ToolName => {
-	const isAToolName = toolNamesSet.has(toolName)
-	return isAToolName
-}
 
 
 const toolNamesWithApproval = ['create_file_or_folder', 'delete_file_or_folder', 'edit_file', 'run_terminal_command'] as const satisfies readonly ToolName[]
@@ -45,8 +26,9 @@ export type ToolCallParams = {
 	'read_file': { uri: URI, startLine: number | null, endLine: number | null, pageNumber: number },
 	'ls_dir': { rootURI: URI, pageNumber: number },
 	'get_dir_structure': { rootURI: URI },
-	'search_pathnames_only': { queryStr: string, include: string | null, pageNumber: number },
-	'search_files': { queryStr: string, isRegex: boolean, searchInFolder: URI | null, pageNumber: number },
+	'search_pathnames_only': { queryStr: string, searchInFolder: string | null, pageNumber: number },
+	'search_for_files': { queryStr: string, isRegex: boolean, searchInFolder: URI | null, pageNumber: number },
+	'read_lint_errors': { uri: URI },
 	// ---
 	'edit_file': { uri: URI, changeDescription: string },
 	'create_file_or_folder': { uri: URI, isFolder: boolean },
@@ -57,13 +39,14 @@ export type ToolCallParams = {
 
 // RESULT OF TOOL CALL
 export type ToolResultType = {
-	'read_file': { fileContents: string, hasNextPage: boolean },
+	'read_file': { fileContents: string, totalFileLen: number, hasNextPage: boolean },
 	'ls_dir': { children: ShallowDirectoryItem[] | null, hasNextPage: boolean, hasPrevPage: boolean, itemsRemaining: number },
 	'get_dir_structure': { str: string, },
 	'search_pathnames_only': { uris: URI[], hasNextPage: boolean },
-	'search_files': { uris: URI[], hasNextPage: boolean },
+	'search_for_files': { uris: URI[], hasNextPage: boolean },
+	'read_lint_errors': { lintErrors: LintErrorItem[] | null },
 	// ---
-	'edit_file': Promise<{ lintErrorsStr: string | null }>,
+	'edit_file': Promise<{ lintErrors: LintErrorItem[] | null }>,
 	'create_file_or_folder': {},
 	'delete_file_or_folder': {},
 	'run_terminal_command': { terminalId: string, didCreateTerminal: boolean, result: string; resolveReason: TerminalResolveReason; },

src/vs/workbench/contrib/void/common/voidModelService.ts

@@ -4,6 +4,7 @@ import { ITextModel } from '../../../../editor/common/model.js';
 import { IResolvedTextEditorModel, ITextModelService } from '../../../../editor/common/services/resolverService.js';
 import { registerSingleton, InstantiationType } from '../../../../platform/instantiation/common/extensions.js';
 import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
 
 type VoidModelType = {
 	model: ITextModel | null;
@@ -16,6 +17,8 @@ export interface IVoidModelService {
 	getModel(uri: URI): VoidModelType;
 	getModelFromFsPath(fsPath: string): VoidModelType;
 	getModelSafe(uri: URI): Promise<VoidModelType>;
+	saveModel(uri: URI): Promise<void>;
+
 }
 
 export const IVoidModelService = createDecorator<IVoidModelService>('voidVoidModelService');
@@ -27,10 +30,17 @@ class VoidModelService extends Disposable implements IVoidModelService {
 
 	constructor(
 		@ITextModelService private readonly _textModelService: ITextModelService,
+		@ITextFileService private readonly _textFileService: ITextFileService,
 	) {
 		super();
 	}
 
+	saveModel = async (uri: URI) => {
+		await this._textFileService.save(uri, { // we want [our change] -> [save] so it's all treated as one change.
+			skipSaveParticipants: true // avoid triggering extensions etc (if they reformat the page, it will add another item to the undo stack)
+		})
+	}
+
 	initializeModel = async (uri: URI) => {
 		if (uri.fsPath in this._modelRefOfURI) return;
 		const editorModelRef = await this._textModelService.createModelReference(uri);

src/vs/workbench/contrib/void/common/voidSettingsService.ts

@@ -11,9 +11,9 @@ import { registerSingleton, InstantiationType } from '../../../../platform/insta
 import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
 import { IStorageService, StorageScope, StorageTarget } from '../../../../platform/storage/common/storage.js';
 import { IMetricsService } from './metricsService.js';
-import { getModelCapabilities } from './modelCapabilities.js';
+import { defaultProviderSettings, getModelCapabilities } from './modelCapabilities.js';
 import { VOID_SETTINGS_STORAGE_KEY } from './storageKeys.js';
-import { defaultSettingsOfProvider, FeatureName, ProviderName, ModelSelectionOfFeature, SettingsOfProvider, SettingName, providerNames, ModelSelection, modelSelectionsEqual, featureNames, VoidModelInfo, GlobalSettings, GlobalSettingName, defaultGlobalSettings, defaultProviderSettings, ModelSelectionOptions, OptionsOfModelSelection, ChatMode } from './voidSettingsTypes.js';
+import { defaultSettingsOfProvider, FeatureName, ProviderName, ModelSelectionOfFeature, SettingsOfProvider, SettingName, providerNames, ModelSelection, modelSelectionsEqual, featureNames, VoidStatefulModelInfo, GlobalSettings, GlobalSettingName, defaultGlobalSettings, ModelSelectionOptions, OptionsOfModelSelection, ChatMode } from './voidSettingsTypes.js';
 
 
 // name is the name in the dropdown
@@ -71,10 +71,10 @@ export interface IVoidSettingsService {
 
 
 
-const _updatedModelsAfterDefaultModelsChange = (defaultModelNames: string[], options: { existingModels: VoidModelInfo[] }) => {
-	const { existingModels } = options
+const _updatedModelsAfterDefaultModelsChange = (defaultModelNames: string[], options: { existingModels: VoidStatefulModelInfo[], didAutoDetect: boolean }) => {
+	const { existingModels, didAutoDetect } = options
 
-	const existingModelsMap: Record<string, VoidModelInfo> = {}
+	const existingModelsMap: Record<string, VoidStatefulModelInfo> = {}
 	for (const existingModel of existingModels) {
 		existingModelsMap[existingModel.modelName] = existingModel
 	}
@@ -82,7 +82,7 @@ const _updatedModelsAfterDefaultModelsChange = (defaultModelNames: string[], opt
 	const newDefaultModels = defaultModelNames.map((modelName, i) => ({
 		modelName,
 		isDefault: true,
-		isAutodetected: true,
+		isAutodetected: didAutoDetect,
 		isHidden: !!existingModelsMap[modelName]?.isHidden,
 	}))
 
@@ -95,13 +95,36 @@ const _updatedModelsAfterDefaultModelsChange = (defaultModelNames: string[], opt
 
 export const modelFilterOfFeatureName: { [featureName in FeatureName]: { filter: (o: ModelSelection, opts: { chatMode: ChatMode }) => boolean; emptyMessage: null | { message: string, priority: 'always' | 'fallback' } } } = {
 	'Autocomplete': { filter: (o) => getModelCapabilities(o.providerName, o.modelName).supportsFIM, emptyMessage: { message: 'No models support FIM', priority: 'always' } },
-	'Chat': { filter: (o, { chatMode }) => chatMode === 'normal' ? true : !!getModelCapabilities(o.providerName, o.modelName).supportsTools, emptyMessage: { message: 'No models support tool use', priority: 'fallback' } },
+	'Chat': { filter: o => true, emptyMessage: null, },
 	'Ctrl+K': { filter: o => true, emptyMessage: null, },
 	'Apply': { filter: o => true, emptyMessage: null, },
 }
 
 
-const _validatedModelState = (state: Omit<VoidSettingsState, '_modelOptions'>) => {
+const _stateWithUpdatedDefaultModels = (state: VoidSettingsState): VoidSettingsState => {
+	let newSettingsOfProvider = state.settingsOfProvider
+
+	// recompute default models
+	for (const providerName of providerNames) {
+		const defaultModels = defaultSettingsOfProvider[providerName]?.models ?? []
+		const currentModels = newSettingsOfProvider[providerName]?.models ?? []
+		const defaultModelNames = defaultModels.map(m => m.modelName)
+		const newModels = _updatedModelsAfterDefaultModelsChange(defaultModelNames, { existingModels: currentModels, didAutoDetect: false })
+		newSettingsOfProvider = {
+			...newSettingsOfProvider,
+			[providerName]: {
+				...newSettingsOfProvider[providerName],
+				models: newModels,
+			},
+		}
+	}
+	return {
+		...state,
+		settingsOfProvider: newSettingsOfProvider,
+	}
+}
+
+const _validatedModelState = (state: Omit<VoidSettingsState, '_modelOptions'>): VoidSettingsState => {
 
 	let newSettingsOfProvider = state.settingsOfProvider
 
@@ -211,11 +234,32 @@ class VoidSettingsService extends Disposable implements IVoidSettingsService {
 	}
 
 	async readAndInitializeState() {
-		const readS = await this._readState();
+		let readS: VoidSettingsState
+		try {
+			readS = await this._readState();
+			// 1.0.3 addition, remove when enough users have had this code run
+			if (readS.globalSettings.includeToolLintErrors === undefined) readS.globalSettings.includeToolLintErrors = true
+		}
+		catch (e) {
+			readS = defaultState()
+		}
 
 		// the stored data structure might be outdated, so we need to update it here
-		const finalState = readS
-		this.state = _validatedModelState(finalState);
+		readS = {
+			...readS,
+			settingsOfProvider: {
+				...defaultSettingsOfProvider,
+				...readS.settingsOfProvider,
+				mistral: { // we added mistral
+					...defaultSettingsOfProvider.mistral,
+					...readS.settingsOfProvider.mistral,
+				},
+			} // we added mistral
+		}
+		this.state = readS
+		this.state = _stateWithUpdatedDefaultModels(this.state)
+		this.state = _validatedModelState(this.state);
+
 
 		this._resolver();
 		this._onDidChangeState.fire();
@@ -345,7 +389,7 @@ class VoidSettingsService extends Disposable implements IVoidSettingsService {
 		const { models } = this.state.settingsOfProvider[providerName]
 		const oldModelNames = models.map(m => m.modelName)
 
-		const newModels = _updatedModelsAfterDefaultModelsChange(autodetectedModelNames, { existingModels: models })
+		const newModels = _updatedModelsAfterDefaultModelsChange(autodetectedModelNames, { existingModels: models, didAutoDetect: true })
 		this.setSettingOfProvider(providerName, 'models', newModels)
 
 		// if the models changed, log it
@@ -363,7 +407,7 @@ class VoidSettingsService extends Disposable implements IVoidSettingsService {
 		const modelIdx = models.findIndex(m => m.modelName === modelName)
 		if (modelIdx === -1) return
 		const newIsHidden = !models[modelIdx].isHidden
-		const newModels: VoidModelInfo[] = [
+		const newModels: VoidStatefulModelInfo[] = [
 			...models.slice(0, modelIdx),
 			{ ...models[modelIdx], isHidden: newIsHidden },
 			...models.slice(modelIdx + 1, Infinity)

src/vs/workbench/contrib/void/common/voidSettingsTypes.ts

@@ -4,49 +4,13 @@
  *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
  *--------------------------------------------------------------------------------------*/
 
-import { defaultModelsOfProvider } from './modelCapabilities.js';
+import { defaultModelsOfProvider, defaultProviderSettings } from './modelCapabilities.js';
 import { VoidSettingsState } from './voidSettingsService.js'
 
 
 type UnionOfKeys<T> = T extends T ? keyof T : never;
 
 
-export const defaultProviderSettings = {
-	anthropic: {
-		apiKey: '',
-	},
-	openAI: {
-		apiKey: '',
-	},
-	deepseek: {
-		apiKey: '',
-	},
-	ollama: {
-		endpoint: 'http://127.0.0.1:11434',
-	},
-	vLLM: {
-		endpoint: 'http://localhost:8000',
-	},
-	openRouter: {
-		apiKey: '',
-	},
-	openAICompatible: {
-		endpoint: '',
-		apiKey: '',
-	},
-	gemini: {
-		apiKey: '',
-	},
-	groq: {
-		apiKey: '',
-	},
-	xAI: {
-		apiKey: ''
-	},
-} as const
-
-
-
 
 export type ProviderName = keyof typeof defaultProviderSettings
 export const providerNames = Object.keys(defaultProviderSettings) as ProviderName[]
@@ -64,7 +28,7 @@ export const customSettingNamesOfProvider = (providerName: ProviderName) => {
 
 
 
-export type VoidModelInfo = { // <-- STATEFUL
+export type VoidStatefulModelInfo = { // <-- STATEFUL
 	modelName: string,
 	isDefault: boolean, // whether or not it's a default for its provider
 	isHidden: boolean, // whether or not the user is hiding it (switched off)
@@ -75,7 +39,7 @@ export type VoidModelInfo = { // <-- STATEFUL
 
 type CommonProviderSettings = {
 	_didFillInProviderSettings: boolean | undefined, // undefined initially, computed when user types in all fields
-	models: VoidModelInfo[],
+	models: VoidStatefulModelInfo[],
 }
 
 export type SettingsAtProvider<providerName extends ProviderName> = CustomProviderSettings<providerName> & CommonProviderSettings
@@ -106,7 +70,8 @@ export const displayInfoOfProviderName = (providerName: ProviderName): DisplayIn
 	}
 	else if (providerName === 'deepseek') {
 		return {
-			title: 'DeepSeek.com API',
+			// title: 'DeepSeek.com API',
+			title: 'DeepSeek',
 		}
 	}
 	else if (providerName === 'openRouter') {
@@ -131,17 +96,26 @@ export const displayInfoOfProviderName = (providerName: ProviderName): DisplayIn
 	}
 	else if (providerName === 'gemini') {
 		return {
-			title: 'Gemini API',
+			// title: 'Gemini API',
+			title: 'Gemini',
 		}
 	}
 	else if (providerName === 'groq') {
 		return {
-			title: 'Groq.com API',
+			// title: 'Groq.com API',
+			title: 'Groq',
 		}
 	}
 	else if (providerName === 'xAI') {
 		return {
-			title: 'Grok (xAI)',
+			// title: 'Grok (xAI)',
+			title: 'xAI',
+		}
+	}
+	else if (providerName === 'mistral') {
+		return {
+			// title: 'Mistral API',
+			title: 'Mistral',
 		}
 	}
 
@@ -170,7 +144,8 @@ export const displayInfoOfSettingName = (providerName: ProviderName, settingName
 								providerName === 'groq' ? 'gsk_key...' :
 									providerName === 'openAICompatible' ? 'sk-key...' :
 										providerName === 'xAI' ? 'xai-key...' :
-											'',
+											providerName === 'mistral' ? 'api-key...' :
+												'',
 
 			subTextMd: providerName === 'anthropic' ? 'Get your [API Key here](https://console.anthropic.com/settings/keys).' :
 				providerName === 'openAI' ? 'Get your [API Key here](https://platform.openai.com/api-keys).' :
@@ -179,8 +154,9 @@ export const displayInfoOfSettingName = (providerName: ProviderName, settingName
 							providerName === 'gemini' ? 'Get your [API Key here](https://aistudio.google.com/apikey).' :
 								providerName === 'groq' ? 'Get your [API Key here](https://console.groq.com/keys).' :
 									providerName === 'xAI' ? 'Get your [API Key here](https://console.x.ai).' :
-										providerName === 'openAICompatible' ? undefined :
-											'',
+										providerName === 'mistral' ? 'Get your [API Key here](https://console.mistral.ai/api-keys).' :
+											providerName === 'openAICompatible' ? `Use any OpenAI-compatible endpoint (LM Studio, LiteLM, etc).` :
+												'',
 			isPasswordField: true,
 		}
 	}
@@ -227,7 +203,7 @@ const defaultCustomSettings: Record<CustomSettingName, undefined> = {
 }
 
 
-const modelInfoOfDefaultModelNames = (defaultModelNames: string[]): { models: VoidModelInfo[] } => {
+const modelInfoOfDefaultModelNames = (defaultModelNames: string[]): { models: VoidStatefulModelInfo[] } => {
 	return {
 		models: defaultModelNames.map((modelName, i) => ({
 			modelName,
@@ -270,31 +246,37 @@ export const defaultSettingsOfProvider: SettingsOfProvider = {
 		...modelInfoOfDefaultModelNames(defaultModelsOfProvider.xAI),
 		_didFillInProviderSettings: undefined,
 	},
-	groq: { // aggregator
+	mistral: {
+		...defaultCustomSettings,
+		...defaultProviderSettings.mistral,
+		...modelInfoOfDefaultModelNames(defaultModelsOfProvider.mistral),
+		_didFillInProviderSettings: undefined,
+	},
+	groq: { // aggregator (serves models from multiple providers)
 		...defaultCustomSettings,
 		...defaultProviderSettings.groq,
 		...modelInfoOfDefaultModelNames(defaultModelsOfProvider.groq),
 		_didFillInProviderSettings: undefined,
 	},
-	openRouter: { // aggregator
+	openRouter: { // aggregator (serves models from multiple providers)
 		...defaultCustomSettings,
 		...defaultProviderSettings.openRouter,
 		...modelInfoOfDefaultModelNames(defaultModelsOfProvider.openRouter),
 		_didFillInProviderSettings: undefined,
 	},
-	openAICompatible: { // aggregator
+	openAICompatible: { // aggregator (serves models from multiple providers)
 		...defaultCustomSettings,
 		...defaultProviderSettings.openAICompatible,
 		...modelInfoOfDefaultModelNames(defaultModelsOfProvider.openAICompatible),
 		_didFillInProviderSettings: undefined,
 	},
-	ollama: { // aggregator
+	ollama: { // aggregator (serves models from multiple providers)
 		...defaultCustomSettings,
 		...defaultProviderSettings.ollama,
 		...modelInfoOfDefaultModelNames(defaultModelsOfProvider.ollama),
 		_didFillInProviderSettings: undefined,
 	},
-	vLLM: { // aggregator
+	vLLM: { // aggregator (serves models from multiple providers)
 		...defaultCustomSettings,
 		...defaultProviderSettings.vLLM,
 		...modelInfoOfDefaultModelNames(defaultModelsOfProvider.vLLM),
@@ -334,6 +316,8 @@ export const displayInfoOfFeatureName = (featureName: FeatureName) => {
 export const refreshableProviderNames = localProviderNames
 export type RefreshableProviderName = typeof refreshableProviderNames[number]
 
+// models that come with download buttons
+export const hasDownloadButtonsOnModelsProviderNames = ['ollama'] as const satisfies ProviderName[]
 
 
 
@@ -389,6 +373,9 @@ export type GlobalSettings = {
 	enableFastApply: boolean;
 	chatMode: ChatMode;
 	autoApprove: boolean;
+	showInlineSuggestions: boolean;
+	includeToolLintErrors: boolean;
+	isOnboardingComplete: boolean;
 }
 
 export const defaultGlobalSettings: GlobalSettings = {
@@ -399,6 +386,9 @@ export const defaultGlobalSettings: GlobalSettings = {
 	enableFastApply: true,
 	chatMode: 'agent',
 	autoApprove: false,
+	showInlineSuggestions: true,
+	includeToolLintErrors: true,
+	isOnboardingComplete: false,
 }
 
 export type GlobalSettingName = keyof GlobalSettings

src/vs/workbench/contrib/void/common/voidUpdateService.ts

@@ -7,12 +7,13 @@ import { ProxyChannel } from '../../../../base/parts/ipc/common/ipc.js';
 import { registerSingleton, InstantiationType } from '../../../../platform/instantiation/common/extensions.js';
 import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
 import { IMainProcessService } from '../../../../platform/ipc/common/mainProcessService.js';
+import { VoidCheckUpdateRespose } from './voidUpdateServiceTypes.js';
 
 
 
 export interface IVoidUpdateService {
 	readonly _serviceBrand: undefined;
-	check: () => Promise<{ hasUpdate: true, message: string } | { hasUpdate: false } | null>;
+	check: (explicit: boolean) => Promise<VoidCheckUpdateRespose>;
 }
 
 
@@ -34,8 +35,8 @@ export class VoidUpdateService implements IVoidUpdateService {
 
 
 	// anything transmitted over a channel must be async even if it looks like it doesn't have to be
-	check: IVoidUpdateService['check'] = async () => {
-		const res = await this.voidUpdateService.check()
+	check: IVoidUpdateService['check'] = async (explicit) => {
+		const res = await this.voidUpdateService.check(explicit)
 		return res
 	}
 }

src/vs/workbench/contrib/void/common/voidUpdateServiceTypes.ts

@@ -0,0 +1,14 @@
+/*--------------------------------------------------------------------------------------
+ *  Copyright 2025 Glass Devtools, Inc. All rights reserved.
+ *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
+ *--------------------------------------------------------------------------------------*/
+
+export type VoidCheckUpdateRespose = {
+	message: string,
+	action?: 'reinstall' | 'restart' | 'download' | 'apply'
+} | {
+	message: null,
+	actions?: undefined,
+} | null
+
+

src/vs/workbench/contrib/void/electron-main/llmMessage/extractGrammar.ts

@@ -0,0 +1,373 @@
+/*--------------------------------------------------------------------------------------
+ *  Copyright 2025 Glass Devtools, Inc. All rights reserved.
+ *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
+ *--------------------------------------------------------------------------------------*/
+
+import { generateUuid } from '../../../../../base/common/uuid.js'
+import { endsWithAnyPrefixOf, SurroundingsRemover } from '../../common/helpers/extractCodeFromResult.js'
+import { availableTools, InternalToolInfo, ToolName, ToolParamName } from '../../common/prompt/prompts.js'
+import { OnFinalMessage, OnText, RawToolCallObj, RawToolParamsObj } from '../../common/sendLLMMessageTypes.js'
+import { ChatMode } from '../../common/voidSettingsTypes.js'
+
+
+// =============== reasoning ===============
+
+// could simplify this - this assumes we can never add a tag without committing it to the user's screen, but that's not true
+export const extractReasoningWrapper = (
+	onText: OnText, onFinalMessage: OnFinalMessage, thinkTags: [string, string]
+): { newOnText: OnText, newOnFinalMessage: OnFinalMessage } => {
+	let latestAddIdx = 0 // exclusive index in fullText_
+	let foundTag1 = false
+	let foundTag2 = false
+
+	let fullTextSoFar = ''
+	let fullReasoningSoFar = ''
+
+	let onText_ = onText
+	onText = (params) => {
+		onText_(params)
+	}
+
+	const newOnText: OnText = ({ fullText: fullText_, ...p }) => {
+
+		// until found the first think tag, keep adding to fullText
+		if (!foundTag1) {
+			const endsWithTag1 = endsWithAnyPrefixOf(fullText_, thinkTags[0])
+			if (endsWithTag1) {
+				// console.log('endswith1', { fullTextSoFar, fullReasoningSoFar, fullText_ })
+				// wait until we get the full tag or know more
+				return
+			}
+			// if found the first tag
+			const tag1Index = fullText_.indexOf(thinkTags[0])
+			if (tag1Index !== -1) {
+				// console.log('tag1Index !==1', { tag1Index, fullTextSoFar, fullReasoningSoFar, thinkTags, fullText_ })
+				foundTag1 = true
+				// Add text before the tag to fullTextSoFar
+				fullTextSoFar += fullText_.substring(0, tag1Index)
+				// Update latestAddIdx to after the first tag
+				latestAddIdx = tag1Index + thinkTags[0].length
+				onText({ ...p, fullText: fullTextSoFar, fullReasoning: fullReasoningSoFar })
+				return
+			}
+
+			// console.log('adding to text A', { fullTextSoFar, fullReasoningSoFar })
+			// add the text to fullText
+			fullTextSoFar = fullText_
+			latestAddIdx = fullText_.length
+			onText({ ...p, fullText: fullTextSoFar, fullReasoning: fullReasoningSoFar })
+			return
+		}
+
+		// at this point, we found <tag1>
+
+		// until found the second think tag, keep adding to fullReasoning
+		if (!foundTag2) {
+			const endsWithTag2 = endsWithAnyPrefixOf(fullText_, thinkTags[1])
+			if (endsWithTag2) {
+				// console.log('endsWith2', { fullTextSoFar, fullReasoningSoFar })
+				// wait until we get the full tag or know more
+				return
+			}
+
+			// if found the second tag
+			const tag2Index = fullText_.indexOf(thinkTags[1], latestAddIdx)
+			if (tag2Index !== -1) {
+				// console.log('tag2Index !== -1', { fullTextSoFar, fullReasoningSoFar })
+				foundTag2 = true
+				// Add everything between first and second tag to reasoning
+				fullReasoningSoFar += fullText_.substring(latestAddIdx, tag2Index)
+				// Update latestAddIdx to after the second tag
+				latestAddIdx = tag2Index + thinkTags[1].length
+				onText({ ...p, fullText: fullTextSoFar, fullReasoning: fullReasoningSoFar })
+				return
+			}
+
+			// add the text to fullReasoning (content after first tag but before second tag)
+			// console.log('adding to text B', { fullTextSoFar, fullReasoningSoFar })
+
+			// If we have more text than we've processed, add it to reasoning
+			if (fullText_.length > latestAddIdx) {
+				fullReasoningSoFar += fullText_.substring(latestAddIdx)
+				latestAddIdx = fullText_.length
+			}
+
+			onText({ ...p, fullText: fullTextSoFar, fullReasoning: fullReasoningSoFar })
+			return
+		}
+
+		// at this point, we found <tag2> - content after the second tag is normal text
+		// console.log('adding to text C', { fullTextSoFar, fullReasoningSoFar })
+
+		// Add any new text after the closing tag to fullTextSoFar
+		if (fullText_.length > latestAddIdx) {
+			fullTextSoFar += fullText_.substring(latestAddIdx)
+			latestAddIdx = fullText_.length
+		}
+
+		onText({ ...p, fullText: fullTextSoFar, fullReasoning: fullReasoningSoFar })
+	}
+
+
+	const getOnFinalMessageParams = () => {
+		const fullText_ = fullTextSoFar
+		const tag1Idx = fullText_.indexOf(thinkTags[0])
+		const tag2Idx = fullText_.indexOf(thinkTags[1])
+		if (tag1Idx === -1) return { fullText: fullText_, fullReasoning: '' } // never started reasoning
+		if (tag2Idx === -1) return { fullText: '', fullReasoning: fullText_ } // never stopped reasoning
+
+		const fullReasoning = fullText_.substring(tag1Idx + thinkTags[0].length, tag2Idx)
+		const fullText = fullText_.substring(0, tag1Idx) + fullText_.substring(tag2Idx + thinkTags[1].length, Infinity)
+
+		return { fullText, fullReasoning }
+	}
+
+	const newOnFinalMessage: OnFinalMessage = (params) => {
+
+		// treat like just got text before calling onFinalMessage (or else we sometimes miss the final chunk that's new to finalMessage)
+		newOnText({ ...params })
+
+		const { fullText, fullReasoning } = getOnFinalMessageParams()
+		onFinalMessage({ ...params, fullText, fullReasoning })
+	}
+
+	return { newOnText, newOnFinalMessage }
+}
+
+
+// =============== tools (XML) ===============
+
+
+
+const findPartiallyWrittenToolTagAtEnd = (fullText: string, toolTags: string[]) => {
+	for (const toolTag of toolTags) {
+		const foundPrefix = endsWithAnyPrefixOf(fullText, toolTag)
+		if (foundPrefix) {
+			return [foundPrefix, toolTag] as const
+		}
+	}
+	return false
+}
+
+const findIndexOfAny = (fullText: string, matches: string[]) => {
+	for (const str of matches) {
+		const idx = fullText.indexOf(str);
+		if (idx !== -1) {
+			return [idx, str] as const
+		}
+	}
+	return null
+}
+
+
+type ToolOfToolName = { [toolName: string]: InternalToolInfo | undefined }
+const parseXMLPrefixToToolCall = (toolName: ToolName, toolId: string, str: string, toolOfToolName: ToolOfToolName): RawToolCallObj => {
+	const paramsObj: RawToolParamsObj = {}
+	const doneParams: ToolParamName[] = []
+	let isDone = false
+
+	const getAnswer = (): RawToolCallObj => {
+		// trim off all whitespace at and before first \n and after last \n for each param
+		for (const p in paramsObj) {
+			const paramName = p as ToolParamName
+			const orig = paramsObj[paramName]
+			if (orig === undefined) continue
+			paramsObj[paramName] = trimBeforeAndAfterNewLines(orig)
+		}
+
+		// return tool call
+		const ans: RawToolCallObj = {
+			name: toolName,
+			rawParams: paramsObj,
+			doneParams: doneParams,
+			isDone: isDone,
+			id: toolId,
+		}
+		return ans
+	}
+
+	// find first toolName tag
+	const openToolTag = `<${toolName}>`
+	let i = str.indexOf(openToolTag)
+	if (i === -1) return getAnswer()
+	let j = str.lastIndexOf(`</${toolName}>`)
+	if (j === -1) j = Infinity
+	else isDone = true
+
+
+	str = str.substring(i + openToolTag.length, j)
+
+	const pm = new SurroundingsRemover(str)
+
+	const allowedParams = Object.keys(toolOfToolName[toolName]?.params ?? {}) as ToolParamName[]
+	if (allowedParams.length === 0) return getAnswer()
+	let latestMatchedOpenParam: null | ToolParamName = null
+	let n = 0
+	while (true) {
+		n += 1
+		if (n > 10) return getAnswer() // just for good measure as this code is early
+
+		// find the param name opening tag
+		let matchedOpenParam: null | ToolParamName = null
+		for (const paramName of allowedParams) {
+			const removed = pm.removeFromStartUntilFullMatch(`<${paramName}>`, true)
+			if (removed) {
+				matchedOpenParam = paramName
+				break
+			}
+		}
+		// if did not find a new param, stop
+		if (matchedOpenParam === null) {
+			if (latestMatchedOpenParam !== null) {
+				paramsObj[latestMatchedOpenParam] += pm.value()
+			}
+			return getAnswer()
+		}
+		else {
+			latestMatchedOpenParam = matchedOpenParam
+		}
+
+		paramsObj[latestMatchedOpenParam] = ''
+
+		// find the param name closing tag
+		let matchedCloseParam: boolean = false
+		let paramContents = ''
+		for (const paramName of allowedParams) {
+			const i = pm.i
+			const closeTag = `</${paramName}>`
+			const removed = pm.removeFromStartUntilFullMatch(closeTag, true)
+			if (removed) {
+				const i2 = pm.i
+				paramContents = pm.originalS.substring(i, i2 - closeTag.length)
+				matchedCloseParam = true
+				break
+			}
+		}
+		// if did not find a new close tag, stop
+		if (!matchedCloseParam) {
+			paramsObj[latestMatchedOpenParam] += pm.value()
+			return getAnswer()
+		}
+		else {
+			doneParams.push(latestMatchedOpenParam)
+		}
+
+		paramsObj[latestMatchedOpenParam] += paramContents
+	}
+}
+
+export const extractXMLToolsWrapper = (
+	onText: OnText, onFinalMessage: OnFinalMessage, chatMode: ChatMode | null
+): { newOnText: OnText, newOnFinalMessage: OnFinalMessage } => {
+
+	if (!chatMode) return { newOnText: onText, newOnFinalMessage: onFinalMessage }
+	const tools = availableTools(chatMode)
+	if (!tools) return { newOnText: onText, newOnFinalMessage: onFinalMessage }
+
+	const toolOfToolName: ToolOfToolName = {}
+	const toolOpenTags = tools.map(t => `<${t.name}>`)
+	for (const t of tools) { toolOfToolName[t.name] = t }
+
+	const toolId = generateUuid()
+
+	// detect <availableTools[0]></availableTools[0]>, etc
+	let fullText = '';
+	let trueFullText = ''
+	let latestToolCall: RawToolCallObj | undefined = undefined
+
+	let foundOpenTag: { idx: number, toolName: ToolName } | null = null
+	let openToolTagBuffer = '' // the characters we've seen so far that come after a < with no space afterwards, not yet added to fullText
+
+	let prevFullTextLen = 0
+	const newOnText: OnText = (params) => {
+		const newText = params.fullText.substring(prevFullTextLen)
+		prevFullTextLen = params.fullText.length
+		trueFullText = params.fullText
+
+		// console.log('NEWTEXT', JSON.stringify(newText))
+
+
+		if (foundOpenTag === null) {
+			const newFullText = openToolTagBuffer + newText
+			// ensure the code below doesn't run if only half a tag has been written
+			const isPartial = findPartiallyWrittenToolTagAtEnd(newFullText, toolOpenTags)
+			if (isPartial) {
+				// console.log('--- partial!!!')
+				openToolTagBuffer += newText
+			}
+			// if no tooltag is partially written at the end, attempt to get the index
+			else {
+				// we will instantly retroactively remove this if it's a tag match
+				fullText += openToolTagBuffer
+				openToolTagBuffer = ''
+				fullText += newText
+
+				const i = findIndexOfAny(fullText, toolOpenTags)
+				if (i !== null) {
+					const [idx, toolTag] = i
+					const toolName = toolTag.substring(1, toolTag.length - 1) as ToolName
+					// console.log('found ', toolName)
+					foundOpenTag = { idx, toolName }
+
+					// do not count anything at or after i in fullText
+					fullText = fullText.substring(0, idx)
+				}
+
+
+			}
+		}
+
+		// toolTagIdx is not null, so parse the XML
+		if (foundOpenTag !== null) {
+			latestToolCall = parseXMLPrefixToToolCall(
+				foundOpenTag.toolName,
+				toolId,
+				trueFullText.substring(foundOpenTag.idx, Infinity),
+				toolOfToolName,
+			)
+		}
+
+		onText({
+			...params,
+			fullText,
+			toolCall: latestToolCall,
+		});
+	};
+
+
+	const newOnFinalMessage: OnFinalMessage = (params) => {
+		// treat like just got text before calling onFinalMessage (or else we sometimes miss the final chunk that's new to finalMessage)
+		newOnText({ ...params })
+
+		fullText = fullText.trimEnd()
+		const toolCall = latestToolCall
+
+		// console.log('final message!!!', trueFullText)
+		// console.log('----- returning ----\n', fullText)
+		// console.log('----- tools ----\n', JSON.stringify(firstToolCallRef.current, null, 2))
+		// console.log('----- toolCall ----\n', JSON.stringify(toolCall, null, 2))
+
+		onFinalMessage({ ...params, fullText, toolCall: toolCall })
+	}
+	return { newOnText, newOnFinalMessage };
+}
+
+
+
+// trim all whitespace up until the first newline, and all whitespace up until the last newline
+const trimBeforeAndAfterNewLines = (s: string) => {
+	if (!s) return s;
+
+	const firstNewLineIndex = s.indexOf('\n');
+
+	if (firstNewLineIndex !== -1 && s.substring(0, firstNewLineIndex).trim() === '') {
+		s = s.substring(firstNewLineIndex + 1, Infinity)
+	}
+
+	const lastNewLineIndex = s.lastIndexOf('\n');
+	if (lastNewLineIndex !== -1 && s.substring(lastNewLineIndex + 1, Infinity).trim() === '') {
+		s = s.substring(0, lastNewLineIndex)
+	}
+
+	return s
+}

src/vs/workbench/contrib/void/electron-main/llmMessage/preprocessLLMMessages.ts

@@ -1,554 +0,0 @@
-/*--------------------------------------------------------------------------------------
- *  Copyright 2025 Glass Devtools, Inc. All rights reserved.
- *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
- *--------------------------------------------------------------------------------------*/
-
-import { AnthropicReasoning, LLMChatMessage, LLMFIMMessage } from '../../common/sendLLMMessageTypes.js';
-import { deepClone } from '../../../../../base/common/objects.js';
-
-
-export const parseObject = (args: unknown) => {
-	if (typeof args === 'object')
-		return args
-	if (typeof args === 'string')
-		try { return JSON.parse(args) }
-		catch (e) { return { args } }
-	return {}
-}
-
-
-type InternalLLMChatMessage = {
-	role: 'system' | 'user';
-	content: string;
-} | {
-	role: 'assistant',
-	content: string | (AnthropicReasoning | { type: 'text'; text: string })[];
-} | {
-	role: 'tool';
-	content: string; // result
-	name: string;
-	params: string;
-	id: string;
-}
-
-
-const EMPTY_MESSAGE = '(empty message)'
-const EMPTY_TOOL_CONTENT = '(empty content)'
-
-const prepareMessages_normalize = ({ messages: messages_ }: { messages: LLMChatMessage[] }): { messages: LLMChatMessage[] } => {
-	const messages = deepClone(messages_)
-	const newMessages: LLMChatMessage[] = []
-	if (messages.length >= 0) newMessages.push(messages[0])
-
-	// remove duplicate roles - we used to do this, but we don't anymore
-	for (let i = 1; i < messages.length; i += 1) {
-		const m = messages[i]
-		newMessages.push(m)
-	}
-	const finalMessages = newMessages.map(m => ({ ...m, content: m.content.trim() }))
-	return { messages: finalMessages }
-}
-
-
-
-
-
-
-const CHARS_PER_TOKEN = 4
-const TRIM_TO_LEN = 60
-
-const prepareMessages_fitIntoContext = ({ messages, contextWindow, maxOutputTokens }: { messages: LLMChatMessage[], contextWindow: number, maxOutputTokens: number }): { messages: LLMChatMessage[] } => {
-
-	// the higher the weight, the higher the desire to truncate
-	const alreadyTrimmedIdxes = new Set<number>()
-	const weight = (message: LLMChatMessage, messages: LLMChatMessage[], idx: number) => {
-		const base = message.content.length
-
-		let multiplier: number
-		if (message.role === 'system')
-			return 0 // never erase system message
-
-		multiplier = 1 + (messages.length - 1 - idx) / messages.length // slow rampdown from 2 to 1 as index increases
-		if (message.role === 'user') {
-			multiplier *= 1
-		}
-		else {
-			multiplier *= 10 // llm tokens are far less valuable than user tokens
-		}
-
-		// 1st message, last 3 msgs, any already modified message should be low in weight
-		if (idx === 0 || idx >= messages.length - 1 - 3 || alreadyTrimmedIdxes.has(idx)) {
-			multiplier *= .05
-		}
-
-		return base * multiplier
-
-	}
-	const _findLargestByWeight = (messages: LLMChatMessage[]) => {
-		let largestIndex = -1
-		let largestWeight = -Infinity
-		for (let i = 0; i < messages.length; i += 1) {
-			const m = messages[i]
-			const w = weight(m, messages, i)
-			if (w > largestWeight) {
-				largestWeight = w
-				largestIndex = i
-			}
-		}
-		return largestIndex
-	}
-
-	let totalLen = 0
-	for (const m of messages) { totalLen += m.content.length }
-	const charsNeedToTrim = totalLen - (contextWindow - maxOutputTokens) * CHARS_PER_TOKEN
-	if (charsNeedToTrim <= 0) return { messages }
-
-	// <----------------------------------------->
-	// 0                      |    |             |
-	//                        |    contextWindow |
-	//                     contextWindow - maxOut|putTokens
-	//                                           |
-	//                                          totalLen
-
-
-	// TRIM HIGHEST WEIGHT MESSAGES
-	let remainingCharsToTrim = charsNeedToTrim
-	let i = 0
-
-	while (remainingCharsToTrim > 0) {
-		i += 1
-		if (i > 100) break
-
-		const trimIdx = _findLargestByWeight(messages)
-		const m = messages[trimIdx]
-
-		// if can finish here, do
-		const numCharsWillTrim = m.content.length - TRIM_TO_LEN
-		if (numCharsWillTrim > remainingCharsToTrim) {
-			m.content = m.content.slice(0, m.content.length - remainingCharsToTrim)
-			break
-		}
-
-		remainingCharsToTrim -= numCharsWillTrim
-		m.content = m.content.substring(0, TRIM_TO_LEN - 3) + '...'
-		alreadyTrimmedIdxes.add(trimIdx)
-	}
-
-	return { messages }
-
-}
-
-
-
-
-
-
-
-// no matter whether the model supports a system message or not (or what format it supports), add it in some way
-const prepareMessages_systemMessage = ({
-	messages,
-	aiInstructions,
-	supportsSystemMessage,
-}: {
-	messages: InternalLLMChatMessage[],
-	aiInstructions: string,
-	supportsSystemMessage: false | 'system-role' | 'developer-role' | 'separated',
-})
-	: { separateSystemMessageStr?: string, messages: any[] } => {
-
-	// find system messages and concatenate them
-	let systemMessageStr = messages
-		.filter(msg => msg.role === 'system')
-		.map(msg => msg.content)
-		.join('\n') || undefined;
-
-	if (aiInstructions)
-		systemMessageStr = `${(systemMessageStr ? `${systemMessageStr}\n\n` : '')}GUIDELINES\n${aiInstructions}`
-
-	let separateSystemMessageStr: string | undefined = undefined
-
-	// remove all system messages
-	const newMessages: (InternalLLMChatMessage | { role: 'developer', content: string })[] = messages.filter(msg => msg.role !== 'system')
-
-
-	// if it has a system message (if doesn't, we obviously don't care about whether it supports system message or not...)
-	if (systemMessageStr) {
-		// if supports system message
-		if (supportsSystemMessage) {
-			if (supportsSystemMessage === 'separated')
-				separateSystemMessageStr = systemMessageStr
-			else if (supportsSystemMessage === 'system-role')
-				newMessages.unshift({ role: 'system', content: systemMessageStr }) // add new first message
-			else if (supportsSystemMessage === 'developer-role')
-				newMessages.unshift({ role: 'developer', content: systemMessageStr }) // add new first message
-		}
-		// if does not support system message
-		else {
-			const newFirstMessage = {
-				role: 'user',
-				content: (''
-					+ '<SYSTEM_MESSAGE>\n'
-					+ systemMessageStr
-					+ '\n'
-					+ '</SYSTEM_MESSAGE>\n'
-					+ newMessages[0].content
-				)
-			} as const
-			newMessages.splice(0, 1) // delete first message
-			newMessages.unshift(newFirstMessage) // add new first message
-		}
-	}
-
-	return { messages: newMessages, separateSystemMessageStr }
-}
-
-
-
-
-
-// convert messages as if about to send to openai
-/*
-reference - https://platform.openai.com/docs/guides/function-calling#function-calling-steps
-openai MESSAGE (role=assistant):
-"tool_calls":[{
-	"type": "function",
-	"id": "call_12345xyz",
-	"function": {
-	"name": "get_weather",
-	"arguments": "{\"latitude\":48.8566,\"longitude\":2.3522}"
-}]
-
-openai RESPONSE (role=user):
-{   "role": "tool",
-	"tool_call_id": tool_call.id,
-	"content": str(result)    }
-
-also see
-openai on prompting - https://platform.openai.com/docs/guides/reasoning#advice-on-prompting
-openai on developer system message - https://cdn.openai.com/spec/model-spec-2024-05-08.html#follow-the-chain-of-command
-*/
-
-type PrepareMessagesToolsOpenAI = (
-	Exclude<InternalLLMChatMessage, { role: 'assistant' | 'tool' }> | {
-		role: 'assistant',
-		content: string | (AnthropicReasoning | { type: 'text'; text: string })[];
-		tool_calls?: {
-			type: 'function';
-			id: string;
-			function: {
-				name: string;
-				arguments: string;
-			}
-		}[]
-	} | {
-		role: 'tool',
-		tool_call_id: string;
-		content: string;
-	}
-)[]
-const prepareMessages_tools_openai = ({ messages }: { messages: InternalLLMChatMessage[], }) => {
-
-	const newMessages: PrepareMessagesToolsOpenAI = [];
-
-	for (let i = 0; i < messages.length; i += 1) {
-		const currMsg = messages[i]
-
-		if (currMsg.role !== 'tool') {
-			newMessages.push(currMsg)
-			continue
-		}
-
-		// edit previous assistant message to have called the tool
-		const prevMsg = 0 <= i - 1 && i - 1 <= newMessages.length ? newMessages[i - 1] : undefined
-		if (prevMsg?.role === 'assistant') {
-			prevMsg.tool_calls = [{
-				type: 'function',
-				id: currMsg.id,
-				function: {
-					name: currMsg.name,
-					arguments: JSON.stringify(currMsg.params)
-				}
-			}]
-		}
-
-		// add the tool
-		newMessages.push({
-			role: 'tool',
-			tool_call_id: currMsg.id,
-			content: currMsg.content || EMPTY_TOOL_CONTENT,
-		})
-	}
-	return { messages: newMessages }
-
-}
-
-
-// convert messages as if about to send to anthropic
-/*
-https://docs.anthropic.com/en/docs/build-with-claude/tool-use#tool-use-examples
-anthropic MESSAGE (role=assistant):
-"content": [{
-	"type": "text",
-	"text": "<thinking>I need to call the get_weather function, and the user wants SF, which is likely San Francisco, CA.</thinking>"
-}, {
-	"type": "tool_use",
-	"id": "toolu_01A09q90qw90lq917835lq9",
-	"name": "get_weather",
-	"input": { "location": "San Francisco, CA", "unit": "celsius" }
-}]
-anthropic RESPONSE (role=user):
-"content": [{
-	"type": "tool_result",
-	"tool_use_id": "toolu_01A09q90qw90lq917835lq9",
-	"content": "15 degrees"
-}]
-*/
-
-type PrepareMessagesToolsAnthropic = (
-	Exclude<InternalLLMChatMessage, { role: 'assistant' | 'user' }> | {
-		role: 'assistant',
-		content: string | (
-			| AnthropicReasoning
-			| {
-				type: 'text';
-				text: string;
-			}
-			| {
-				type: 'tool_use';
-				name: string;
-				input: Record<string, any>;
-				id: string;
-			})[]
-	} | {
-		role: 'user',
-		content: string | ({
-			type: 'text';
-			text: string;
-		} | {
-			type: 'tool_result';
-			tool_use_id: string;
-			content: string;
-		})[]
-	}
-)[]
-/*
-Converts:
-
-assistant: ...content
-tool: (id, name, params)
-->
-assistant: ...content, call(name, id, params)
-user: ...content, result(id, content)
-*/
-const prepareMessages_tools_anthropic = ({ messages }: { messages: InternalLLMChatMessage[], }) => {
-	const newMessages: PrepareMessagesToolsAnthropic = messages;
-
-
-	for (let i = 0; i < newMessages.length; i += 1) {
-		const currMsg = newMessages[i]
-
-		if (currMsg.role !== 'tool') continue
-
-		const prevMsg = 0 <= i - 1 && i - 1 <= newMessages.length ? newMessages[i - 1] : undefined
-
-		if (prevMsg?.role === 'assistant') {
-			if (typeof prevMsg.content === 'string') prevMsg.content = [{ type: 'text', text: prevMsg.content }]
-			prevMsg.content.push({ type: 'tool_use', id: currMsg.id, name: currMsg.name, input: parseObject(currMsg.params) })
-		}
-
-		// turn each tool into a user message with tool results at the end
-		newMessages[i] = {
-			role: 'user',
-			content: [
-				...[{ type: 'tool_result', tool_use_id: currMsg.id, content: currMsg.content || EMPTY_TOOL_CONTENT }] as const,
-			]
-		}
-	}
-	return { messages: newMessages }
-}
-
-
-
-
-type PrepareMessagesTools = PrepareMessagesToolsAnthropic | PrepareMessagesToolsOpenAI
-
-const prepareMessages_tools = ({ messages, supportsTools }: { messages: InternalLLMChatMessage[], supportsTools: false | 'anthropic-style' | 'openai-style' }): { messages: PrepareMessagesTools } => {
-	if (!supportsTools) {
-		return { messages: messages }
-	}
-	else if (supportsTools === 'anthropic-style') {
-		return prepareMessages_tools_anthropic({ messages })
-	}
-	else if (supportsTools === 'openai-style') {
-		return prepareMessages_tools_openai({ messages })
-	}
-	else {
-		throw new Error(`supportsTools type not recognized`)
-	}
-}
-
-
-// remove rawAnthropicAssistantContent, and make content equal to it if supportsAnthropicContent
-const prepareMessages_anthropicContent = ({ messages, supportsAnthropicReasoningSignature }: { messages: LLMChatMessage[], supportsAnthropicReasoningSignature: boolean }) => {
-	const newMessages: InternalLLMChatMessage[] = []
-	for (const m of messages) {
-		if (m.role !== 'assistant') {
-			newMessages.push(m)
-			continue
-		}
-		let newMessage: InternalLLMChatMessage
-		if (supportsAnthropicReasoningSignature && m.anthropicReasoning) {
-			const content = m.content ? [...m.anthropicReasoning, { type: 'text' as const, text: m.content }] : m.anthropicReasoning
-			newMessage = { role: 'assistant', content: content }
-		}
-		else {
-			newMessage = { role: 'assistant', content: m.content }
-		}
-		newMessages.push(newMessage)
-	}
-	return { messages: newMessages }
-}
-
-
-
-
-
-// do this at end
-const prepareMessages_noEmptyMessage = ({ messages }: { messages: PrepareMessagesTools }): { messages: PrepareMessagesTools } => {
-	for (const currMsg of messages) {
-
-		// don't do this for tools
-		if (currMsg.role === 'tool') continue
-
-		// don't do this for assistant or user messages that have tool_calls or tool_results
-		const oai = currMsg as PrepareMessagesToolsOpenAI[0]
-		if (oai.role === 'assistant') {
-			if (oai.tool_calls) continue
-		}
-		const anth = currMsg as PrepareMessagesToolsAnthropic[0]
-		if (anth.role === 'assistant' || anth.role === 'user') {
-			if (typeof anth.content !== 'string') {
-				const hasContent = anth.content.find(c => c.type === 'tool_use' || c.type === 'tool_result')
-				if (hasContent) continue
-			}
-		}
-
-
-		if (typeof currMsg.content === 'string') {
-			currMsg.content = currMsg.content || EMPTY_MESSAGE
-		}
-		else {
-			for (const c of currMsg.content) {
-				if (c.type === 'text') c.text = c.text || EMPTY_MESSAGE
-				else if (c.type === 'tool_use') { }
-				else if (c.type === 'tool_result') { }
-			}
-			if (currMsg.content.length === 0) currMsg.content = [{ type: 'text', text: EMPTY_MESSAGE }]
-		}
-
-	}
-	return { messages }
-}
-
-
-
-// --- CHAT ---
-
-export const prepareMessages = ({
-	messages,
-	aiInstructions,
-	supportsSystemMessage,
-	supportsTools,
-	supportsAnthropicReasoningSignature,
-	contextWindow,
-	maxOutputTokens,
-}: {
-	messages: LLMChatMessage[],
-	aiInstructions: string,
-	supportsSystemMessage: false | 'system-role' | 'developer-role' | 'separated',
-	supportsTools: false | 'anthropic-style' | 'openai-style',
-	supportsAnthropicReasoningSignature: boolean,
-	contextWindow: number,
-	maxOutputTokens: number | null | undefined,
-}) => {
-	maxOutputTokens = maxOutputTokens ?? 4_096 // default to 4096
-
-	const { messages: messages0 } = prepareMessages_normalize({ messages })
-	const { messages: messages1 } = prepareMessages_fitIntoContext({ messages: messages0, contextWindow, maxOutputTokens })
-	const { messages: messages2 } = prepareMessages_anthropicContent({ messages: messages1, supportsAnthropicReasoningSignature })
-	const { messages: messages3, separateSystemMessageStr } = prepareMessages_systemMessage({ messages: messages2, aiInstructions, supportsSystemMessage })
-	const { messages: messages4 } = prepareMessages_tools({ messages: messages3, supportsTools })
-	const { messages: messages5 } = prepareMessages_noEmptyMessage({ messages: messages4 })
-
-	return {
-		messages: messages5 as any,
-		separateSystemMessageStr
-	} as const
-}
-
-
-
-
-
-
-
-// --- FIM ---
-
-export const prepareFIMMessage = ({
-	messages,
-	aiInstructions,
-}: {
-	messages: LLMFIMMessage,
-	aiInstructions: string,
-}) => {
-
-	let prefix = `\
-${!aiInstructions ? '' : `\
-// Instructions:
-// Do not output an explanation. Try to avoid outputting comments. Only output the middle code.
-${aiInstructions.split('\n').map(line => `//${line}`).join('\n')}`}
-
-${messages.prefix}`
-
-	const suffix = messages.suffix
-	const stopTokens = messages.stopTokens
-	const ret = { prefix, suffix, stopTokens, maxTokens: 300 } as const
-	return ret
-}
-
-
-
-
-
-
-
-/*
-Gemini has this, but they're openai-compat so we don't need to implement this
-gemini request:
-{   "role": "assistant",
-	"content": null,
-	"function_call": {
-		"name": "get_weather",
-		"arguments": {
-			"latitude": 48.8566,
-			"longitude": 2.3522
-		}
-	}
-}
-
-gemini response:
-{   "role": "assistant",
-	"function_response": {
-		"name": "get_weather",
-			"response": {
-			"temperature": "15°C",
-				"condition": "Cloudy"
-		}
-	}
-}
-*/
-
-
-
-
-

src/vs/workbench/contrib/void/electron-main/llmMessage/sendLLMMessage.impl.ts

@@ -3,20 +3,23 @@
  *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
  *--------------------------------------------------------------------------------------*/
 
+// disable foreign import complaints
+/* eslint-disable */
 import Anthropic from '@anthropic-ai/sdk';
 import { Ollama } from 'ollama';
 import OpenAI, { ClientOptions } from 'openai';
+import { MistralCore } from '@mistralai/mistralai/core.js';
+import { fimComplete } from '@mistralai/mistralai/funcs/fimComplete.js';
+/* eslint-enable */
 
-import { extractReasoningOnFinalMessage, extractReasoningOnTextWrapper } from '../../common/helpers/extractCodeFromResult.js';
-import { LLMChatMessage, LLMFIMMessage, ModelListParams, OllamaModelResponse, OnError, OnFinalMessage, OnText } from '../../common/sendLLMMessageTypes.js';
-import { defaultProviderSettings, displayInfoOfProviderName, ModelSelectionOptions, ProviderName, SettingsOfProvider } from '../../common/voidSettingsTypes.js';
-import { prepareFIMMessage, prepareMessages } from './preprocessLLMMessages.js';
-import { getSendableReasoningInfo, getModelCapabilities, getProviderCapabilities } from '../../common/modelCapabilities.js';
-import { InternalToolInfo, ToolName, isAToolName } from '../../common/toolsServiceTypes.js';
+import { AnthropicLLMChatMessage, LLMChatMessage, LLMFIMMessage, ModelListParams, OllamaModelResponse, OnError, OnFinalMessage, OnText, RawToolCallObj, RawToolParamsObj } from '../../common/sendLLMMessageTypes.js';
+import { ChatMode, displayInfoOfProviderName, ModelSelectionOptions, ProviderName, SettingsOfProvider } from '../../common/voidSettingsTypes.js';
+import { getSendableReasoningInfo, getModelCapabilities, getProviderCapabilities, defaultProviderSettings, getMaxOutputTokens } from '../../common/modelCapabilities.js';
+import { extractReasoningWrapper, extractXMLToolsWrapper } from './extractGrammar.js';
+import { availableTools, InternalToolInfo, isAToolName, ToolParamName, voidTools } from '../../common/prompt/prompts.js';
 
 
 type InternalCommonMessageParams = {
-	aiInstructions: string;
 	onText: OnText;
 	onFinalMessage: OnFinalMessage;
 	onError: OnError;
@@ -27,42 +30,14 @@ type InternalCommonMessageParams = {
 	_setAborter: (aborter: () => void) => void;
 }
 
-type SendChatParams_Internal = InternalCommonMessageParams & { messages: LLMChatMessage[]; tools?: InternalToolInfo[] }
-type SendFIMParams_Internal = InternalCommonMessageParams & { messages: LLMFIMMessage; }
+type SendChatParams_Internal = InternalCommonMessageParams & { messages: LLMChatMessage[]; separateSystemMessage: string | undefined; chatMode: ChatMode | null; }
+type SendFIMParams_Internal = InternalCommonMessageParams & { messages: LLMFIMMessage; separateSystemMessage: string | undefined; }
 export type ListParams_Internal<ModelResponse> = ModelListParams<ModelResponse>
 
 
 const invalidApiKeyMessage = (providerName: ProviderName) => `Invalid ${displayInfoOfProviderName(providerName).title} API key.`
 
 // ------------ OPENAI-COMPATIBLE (HELPERS) ------------
-const toOpenAICompatibleTool = (toolInfo: InternalToolInfo) => {
-	const { name, description, params } = toolInfo
-	return {
-		type: 'function',
-		function: {
-			name: name,
-			strict: true, // strict mode - https://platform.openai.com/docs/guides/function-calling?api-mode=chat
-			description: description,
-			parameters: {
-				type: 'object',
-				properties: params,
-				required: Object.keys(params), // in strict mode, all params are required and additionalProperties is false
-				additionalProperties: false,
-			},
-		}
-	} satisfies OpenAI.Chat.Completions.ChatCompletionTool
-}
-
-type ToolCallOfIndex = { [index: string]: { name: string, paramsStr: string, id: string } } // type used to stream tool calls as they come in
-type ToolCallsFrom_ReturnType = { name: ToolName, id: string, paramsStr: string }[] // return type of toolCallsFrom_<PROVIDER>
-
-const toolCallsFrom_OpenAICompat = (toolCallOfIndex: ToolCallOfIndex): ToolCallsFrom_ReturnType => {
-	return Object.keys(toolCallOfIndex).map(index => {
-		const tool = toolCallOfIndex[index]
-		return isAToolName(tool.name) ? { name: tool.name, id: tool.id, paramsStr: tool.paramsStr } : null
-	}).filter(t => !!t)
-}
-
 
 const newOpenAICompatibleSDK = ({ settingsOfProvider, providerName, includeInPayload }: { settingsOfProvider: SettingsOfProvider, providerName: ProviderName, includeInPayload?: { [s: string]: any } }) => {
 	const commonPayloadOpts: ClientOptions = {
@@ -95,7 +70,7 @@ const newOpenAICompatibleSDK = ({ settingsOfProvider, providerName, includeInPay
 	}
 	else if (providerName === 'gemini') {
 		const thisConfig = settingsOfProvider[providerName]
-		return new OpenAI({ baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai', apiKey: thisConfig.apiKey, ...commonPayloadOpts })
+		return new OpenAI({ baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai/', apiKey: thisConfig.apiKey, ...commonPayloadOpts })
 	}
 	else if (providerName === 'deepseek') {
 		const thisConfig = settingsOfProvider[providerName]
@@ -113,12 +88,16 @@ const newOpenAICompatibleSDK = ({ settingsOfProvider, providerName, includeInPay
 		const thisConfig = settingsOfProvider[providerName]
 		return new OpenAI({ baseURL: 'https://api.x.ai/v1', apiKey: thisConfig.apiKey, ...commonPayloadOpts })
 	}
+	else if (providerName === 'mistral') {
+		const thisConfig = settingsOfProvider[providerName]
+		return new OpenAI({ baseURL: 'https://api.mistral.ai/v1', apiKey: thisConfig.apiKey, ...commonPayloadOpts })
+	}
 
 	else throw new Error(`Void providerName was invalid: ${providerName}.`)
 }
 
 
-const _sendOpenAICompatibleFIM = ({ messages: messages_, onFinalMessage, onError, settingsOfProvider, modelName: modelName_, _setAborter, providerName, aiInstructions, }: SendFIMParams_Internal) => {
+const _sendOpenAICompatibleFIM = ({ messages: { prefix, suffix, stopTokens }, onFinalMessage, onError, settingsOfProvider, modelName: modelName_, _setAborter, providerName, }: SendFIMParams_Internal) => {
 	const { modelName, supportsFIM } = getModelCapabilities(providerName, modelName_)
 	if (!supportsFIM) {
 		if (modelName === modelName_)
@@ -128,16 +107,14 @@ const _sendOpenAICompatibleFIM = ({ messages: messages_, onFinalMessage, onError
 		return
 	}
 
-	const messages = prepareFIMMessage({ messages: messages_, aiInstructions, })
-
 	const openai = newOpenAICompatibleSDK({ providerName, settingsOfProvider })
 	openai.completions
 		.create({
 			model: modelName,
-			prompt: messages.prefix,
-			suffix: messages.suffix,
-			stop: messages.stopTokens,
-			max_tokens: messages.maxTokens,
+			prompt: prefix,
+			suffix: suffix,
+			stop: stopTokens,
+			max_tokens: 300,
 		})
 		.then(async response => {
 			const fullText = response.choices[0]?.text
@@ -150,15 +127,61 @@ const _sendOpenAICompatibleFIM = ({ messages: messages_, onFinalMessage, onError
 }
 
 
+const toOpenAICompatibleTool = (toolInfo: InternalToolInfo) => {
+	const { name, description, params } = toolInfo
+	return {
+		type: 'function',
+		function: {
+			name: name,
+			// strict: true, // strict mode - https://platform.openai.com/docs/guides/function-calling?api-mode=chat
+			description: description,
+			parameters: {
+				type: 'object',
+				properties: params,
+				// required: Object.keys(params), // in strict mode, all params are required and additionalProperties is false
+				// additionalProperties: false,
+			},
+		}
+	} satisfies OpenAI.Chat.Completions.ChatCompletionTool
+}
+
+const openAITools = (chatMode: ChatMode) => {
+	const allowedTools = availableTools(chatMode)
+	if (!allowedTools || Object.keys(allowedTools).length === 0) return null
+
+	const openAITools: OpenAI.Chat.Completions.ChatCompletionTool[] = []
+	for (const t in allowedTools ?? {}) {
+		openAITools.push(toOpenAICompatibleTool(allowedTools[t]))
+	}
+	return openAITools
+}
+
+const openAIToolToRawToolCallObj = (name: string, toolParamsStr: string, id: string): RawToolCallObj | null => {
+	if (!isAToolName(name)) return null
+	const rawParams: RawToolParamsObj = {}
+	let input: unknown
+	try {
+		input = JSON.parse(toolParamsStr)
+	}
+	catch (e) {
+		return null
+	}
+	if (input === null) return null
+	if (typeof input !== 'object') return null
+	for (const paramName in voidTools[name].params) {
+		rawParams[paramName as ToolParamName] = (input as any)[paramName]
+	}
+	return { id, name, rawParams, doneParams: Object.keys(rawParams) as ToolParamName[], isDone: true }
+}
 
 
-const _sendOpenAICompatibleChat = ({ messages: messages_, onText, onFinalMessage, onError, settingsOfProvider, modelSelectionOptions, modelName: modelName_, _setAborter, providerName, aiInstructions, tools: tools_ }: SendChatParams_Internal) => {
+// ------------ OPENAI-COMPATIBLE ------------
+
+
+const _sendOpenAICompatibleChat = ({ messages, onText, onFinalMessage, onError, settingsOfProvider, modelSelectionOptions, modelName: modelName_, _setAborter, providerName, chatMode, separateSystemMessage }: SendChatParams_Internal) => {
 	const {
 		modelName,
-		supportsSystemMessage,
-		supportsTools,
-		contextWindow,
-		maxOutputTokens,
+		specialToolFormat,
 		reasoningCapabilities,
 	} = getModelCapabilities(providerName, modelName_)
 
@@ -170,58 +193,65 @@ const _sendOpenAICompatibleChat = ({ messages: messages_, onText, onFinalMessage
 	const includeInPayload = providerReasoningIOSettings?.input?.includeInPayload?.(reasoningInfo) || {}
 
 	// tools
-	const tools = (supportsTools && ((tools_?.length ?? 0) !== 0)) ? tools_?.map(tool => toOpenAICompatibleTool(tool)) : undefined
-	const toolsObj = tools ? { tools: tools, tool_choice: 'auto', parallel_tool_calls: false, } as const : {}
-
-	// max tokens
-	const maxTokens = reasoningInfo?.isReasoningEnabled && reasoningCapabilities ? reasoningCapabilities.reasoningMaxOutputTokens : maxOutputTokens
+	const potentialTools = chatMode !== null ? openAITools(chatMode) : null
+	const nativeToolsObj = potentialTools && specialToolFormat === 'openai-style' ?
+		{ tools: potentialTools } as const
+		: {}
 
 	// instance
-	const { messages } = prepareMessages({ messages: messages_, aiInstructions, supportsSystemMessage, supportsTools, supportsAnthropicReasoningSignature: false, contextWindow, maxOutputTokens: maxTokens })
 	const openai: OpenAI = newOpenAICompatibleSDK({ providerName, settingsOfProvider, includeInPayload })
 	const options: OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming = {
 		model: modelName,
-		messages: messages,
+		messages: messages as any,
 		stream: true,
+		...nativeToolsObj,
 		// max_completion_tokens: maxTokens,
-		...toolsObj,
 	}
 
 	// open source models - manually parse think tokens
 	const { needsManualParse: needsManualReasoningParse, nameOfFieldInDelta: nameOfReasoningFieldInDelta } = providerReasoningIOSettings?.output ?? {}
 	const manuallyParseReasoning = needsManualReasoningParse && canIOReasoning && openSourceThinkTags
 	if (manuallyParseReasoning) {
-		onText = extractReasoningOnTextWrapper(onText, openSourceThinkTags)
+		const { newOnText, newOnFinalMessage } = extractReasoningWrapper(onText, onFinalMessage, openSourceThinkTags)
+		onText = newOnText
+		onFinalMessage = newOnFinalMessage
+	}
+
+	// manually parse out tool results if XML
+	if (!specialToolFormat) {
+		const { newOnText, newOnFinalMessage } = extractXMLToolsWrapper(onText, onFinalMessage, chatMode)
+		onText = newOnText
+		onFinalMessage = newOnFinalMessage
 	}
 
 	let fullReasoningSoFar = ''
 	let fullTextSoFar = ''
 
-	let fullToolName = ''
-	let fullToolParams = ''
+	let toolName = ''
+	let toolId = ''
+	let toolParamsStr = ''
 
-	const toolCallOfIndex: ToolCallOfIndex = {}
 	openai.chat.completions
 		.create(options)
 		.then(async response => {
 			_setAborter(() => response.controller.abort())
 			// when receive text
 			for await (const chunk of response) {
-				// tool call
-				for (const tool of chunk.choices[0]?.delta?.tool_calls ?? []) {
-					const index = tool.index
-					if (!toolCallOfIndex[index]) toolCallOfIndex[index] = { name: '', paramsStr: '', id: '' }
-					toolCallOfIndex[index].name += tool.function?.name ?? ''
-					toolCallOfIndex[index].paramsStr += tool.function?.arguments ?? '';
-					toolCallOfIndex[index].id += tool.id ?? ''
-
-					fullToolName += tool.function?.name ?? ''
-					fullToolParams += tool.function?.arguments ?? ''
-				}
 				// message
 				const newText = chunk.choices[0]?.delta?.content ?? ''
 				fullTextSoFar += newText
 
+				// tool call
+				for (const tool of chunk.choices[0]?.delta?.tool_calls ?? []) {
+					const index = tool.index
+					if (index !== 0) continue
+
+					toolName += tool.function?.name ?? ''
+					toolParamsStr += tool.function?.arguments ?? '';
+					toolId += tool.id ?? ''
+				}
+
+
 				// reasoning
 				let newReasoning = ''
 				if (nameOfReasoningFieldInDelta) {
@@ -230,20 +260,21 @@ const _sendOpenAICompatibleChat = ({ messages: messages_, onText, onFinalMessage
 					fullReasoningSoFar += newReasoning
 				}
 
-				onText({ fullText: fullTextSoFar, fullReasoning: fullReasoningSoFar, fullToolName, fullToolParams })
+				onText({
+					fullText: fullTextSoFar,
+					fullReasoning: fullReasoningSoFar,
+					toolCall: isAToolName(toolName) ? { name: toolName, rawParams: {}, isDone: false, doneParams: [], id: toolId } : undefined,
+				})
+
 			}
 			// on final
-			const toolCalls = toolCallsFrom_OpenAICompat(toolCallOfIndex)
-			if (!fullTextSoFar && !fullReasoningSoFar && toolCalls.length === 0) {
+			if (!fullTextSoFar && !fullReasoningSoFar && !toolName) {
 				onError({ message: 'Void: Response from model was empty.', fullError: null })
 			}
 			else {
-				if (manuallyParseReasoning) {
-					const { fullText, fullReasoning } = extractReasoningOnFinalMessage(fullTextSoFar, openSourceThinkTags)
-					onFinalMessage({ fullText, fullReasoning, toolCalls, anthropicReasoning: null });
-				} else {
-					onFinalMessage({ fullText: fullTextSoFar, fullReasoning: fullReasoningSoFar, toolCalls, anthropicReasoning: null });
-				}
+				const toolCall = openAIToolToRawToolCallObj(toolName, toolParamsStr, toolId)
+				const toolCallObj = toolCall ? { toolCall } : {}
+				onFinalMessage({ fullText: fullTextSoFar, fullReasoning: fullReasoningSoFar, anthropicReasoning: null, ...toolCallObj });
 			}
 		})
 		// when error/fail - this catches errors of both .create() and .then(for await)
@@ -291,7 +322,7 @@ const _openaiCompatibleList = async ({ onSuccess: onSuccess_, onError: onError_,
 
 
 
-// ------------ ANTHROPIC ------------
+// ------------ ANTHROPIC (HELPERS) ------------
 const toAnthropicTool = (toolInfo: InternalToolInfo) => {
 	const { name, description, params } = toolInfo
 	return {
@@ -300,27 +331,39 @@ const toAnthropicTool = (toolInfo: InternalToolInfo) => {
 		input_schema: {
 			type: 'object',
 			properties: params,
-			required: Object.keys(params),
+			// required: Object.keys(params),
 		},
 	} satisfies Anthropic.Messages.Tool
 }
 
-const toolCallsFrom_Anthropic = (content: Anthropic.Messages.ContentBlock[]): ToolCallsFrom_ReturnType => {
-	return content.map(c => {
-		if (c.type !== 'tool_use') return null
-		if (!isAToolName(c.name)) return null
-		return c.type === 'tool_use' ? { name: c.name, paramsStr: JSON.stringify(c.input), id: c.id } : null
-	}).filter(t => !!t)
+const anthropicTools = (chatMode: ChatMode) => {
+	const allowedTools = availableTools(chatMode)
+	if (!allowedTools || Object.keys(allowedTools).length === 0) return null
+
+	const anthropicTools: Anthropic.Messages.ToolUnion[] = []
+	for (const t in allowedTools ?? {}) {
+		anthropicTools.push(toAnthropicTool(allowedTools[t]))
+	}
+	return anthropicTools
 }
 
-const sendAnthropicChat = ({ messages: messages_, providerName, onText, onFinalMessage, onError, settingsOfProvider, modelSelectionOptions, modelName: modelName_, _setAborter, aiInstructions, tools: tools_ }: SendChatParams_Internal) => {
+const anthropicToolToRawToolCallObj = (toolBlock: Anthropic.Messages.ToolUseBlock): RawToolCallObj | null => {
+	const { id, name, input } = toolBlock
+	if (!isAToolName(name)) return null
+	const rawParams: RawToolParamsObj = {}
+	if (input === null) return null
+	if (typeof input !== 'object') return null
+	for (const paramName in voidTools[name].params) {
+		rawParams[paramName as ToolParamName] = (input as any)[paramName]
+	}
+	return { id, name, rawParams, doneParams: Object.keys(rawParams) as ToolParamName[], isDone: true }
+}
+
+// ------------ ANTHROPIC ------------
+const sendAnthropicChat = ({ messages, providerName, onText, onFinalMessage, onError, settingsOfProvider, modelSelectionOptions, modelName: modelName_, _setAborter, separateSystemMessage, chatMode }: SendChatParams_Internal) => {
 	const {
 		modelName,
-		supportsSystemMessage,
-		contextWindow,
-		supportsTools,
-		maxOutputTokens,
-		reasoningCapabilities,
+		specialToolFormat,
 	} = getModelCapabilities(providerName, modelName_)
 
 	const thisConfig = settingsOfProvider.anthropic
@@ -330,32 +373,39 @@ const sendAnthropicChat = ({ messages: messages_, providerName, onText, onFinalM
 	const reasoningInfo = getSendableReasoningInfo('Chat', providerName, modelName_, modelSelectionOptions) // user's modelName_ here
 	const includeInPayload = providerReasoningIOSettings?.input?.includeInPayload?.(reasoningInfo) || {}
 
-	// tools
-	const tools = ((tools_?.length ?? 0) !== 0) ? tools_?.map(tool => toAnthropicTool(tool)) : undefined
-	const toolsObj: Partial<Anthropic.Messages.MessageStreamParams> = tools ? {
-		tools: tools,
-		tool_choice: { type: 'auto', disable_parallel_tool_use: true } // one tool at a time
-	} : {}
-
 	// anthropic-specific - max tokens
-	const maxTokens = reasoningInfo?.isReasoningEnabled && reasoningCapabilities ? reasoningCapabilities.reasoningMaxOutputTokens : maxOutputTokens
+	const maxTokens = getMaxOutputTokens(providerName, modelName_, { isReasoningEnabled: !!reasoningInfo?.isReasoningEnabled })
+
+	// tools
+	const potentialTools = chatMode !== null ? anthropicTools(chatMode) : null
+	const nativeToolsObj = potentialTools && specialToolFormat === 'anthropic-style' ?
+		{ tools: potentialTools, tool_choice: { type: 'auto' } } as const
+		: {}
+
 
 	// instance
-	const { messages, separateSystemMessageStr } = prepareMessages({ messages: messages_, aiInstructions, supportsSystemMessage, supportsTools, supportsAnthropicReasoningSignature: true, contextWindow, maxOutputTokens: maxTokens })
 	const anthropic = new Anthropic({
 		apiKey: thisConfig.apiKey,
 		dangerouslyAllowBrowser: true
 	});
 
 	const stream = anthropic.messages.stream({
-		system: separateSystemMessageStr,
-		messages: messages,
+		system: separateSystemMessage ?? undefined,
+		messages: messages as AnthropicLLMChatMessage[],
 		model: modelName,
 		max_tokens: maxTokens ?? 4_096, // anthropic requires this
-		...toolsObj,
 		...includeInPayload,
+		...nativeToolsObj,
+
 	})
 
+	// manually parse out tool results
+	if (!specialToolFormat) {
+		const { newOnText, newOnFinalMessage } = extractXMLToolsWrapper(onText, onFinalMessage, chatMode)
+		onText = newOnText
+		onFinalMessage = newOnFinalMessage
+	}
+
 	// when receive text
 	let fullText = ''
 	let fullReasoning = ''
@@ -363,6 +413,14 @@ const sendAnthropicChat = ({ messages: messages_, providerName, onText, onFinalM
 	let fullToolName = ''
 	let fullToolParams = ''
 
+
+	const runOnText = () => {
+		onText({
+			fullText,
+			fullReasoning,
+			toolCall: isAToolName(fullToolName) ? { name: fullToolName, rawParams: {}, isDone: false, doneParams: [], id: 'dummy' } : undefined,
+		})
+	}
 	// there are no events for tool_use, it comes in at the end
 	stream.on('streamEvent', e => {
 		// start block
@@ -370,22 +428,22 @@ const sendAnthropicChat = ({ messages: messages_, providerName, onText, onFinalM
 			if (e.content_block.type === 'text') {
 				if (fullText) fullText += '\n\n' // starting a 2nd text block
 				fullText += e.content_block.text
-				onText({ fullText, fullReasoning, fullToolName, fullToolParams })
+				runOnText()
 			}
 			else if (e.content_block.type === 'thinking') {
 				if (fullReasoning) fullReasoning += '\n\n' // starting a 2nd reasoning block
 				fullReasoning += e.content_block.thinking
-				onText({ fullText, fullReasoning, fullToolName, fullToolParams })
+				runOnText()
 			}
 			else if (e.content_block.type === 'redacted_thinking') {
 				console.log('delta', e.content_block.type)
 				if (fullReasoning) fullReasoning += '\n\n' // starting a 2nd reasoning block
 				fullReasoning += '[redacted_thinking]'
-				onText({ fullText, fullReasoning, fullToolName, fullToolParams })
+				runOnText()
 			}
 			else if (e.content_block.type === 'tool_use') {
 				fullToolName += e.content_block.name ?? '' // anthropic gives us the tool name in the start block
-				onText({ fullText, fullReasoning, fullToolName, fullToolParams })
+				runOnText()
 			}
 		}
 
@@ -393,24 +451,26 @@ const sendAnthropicChat = ({ messages: messages_, providerName, onText, onFinalM
 		else if (e.type === 'content_block_delta') {
 			if (e.delta.type === 'text_delta') {
 				fullText += e.delta.text
-				onText({ fullText, fullReasoning, fullToolName, fullToolParams })
+				runOnText()
 			}
 			else if (e.delta.type === 'thinking_delta') {
 				fullReasoning += e.delta.thinking
-				onText({ fullText, fullReasoning, fullToolName, fullToolParams })
+				runOnText()
 			}
 			else if (e.delta.type === 'input_json_delta') { // tool use
 				fullToolParams += e.delta.partial_json ?? '' // anthropic gives us the partial delta (string) here - https://docs.anthropic.com/en/api/messages-streaming
-				onText({ fullText, fullReasoning, fullToolName, fullToolParams })
+				runOnText()
 			}
 		}
 	})
 
 	// on done - (or when error/fail) - this is called AFTER last streamEvent
 	stream.on('finalMessage', (response) => {
-		const toolCalls = toolCallsFrom_Anthropic(response.content)
 		const anthropicReasoning = response.content.filter(c => c.type === 'thinking' || c.type === 'redacted_thinking')
-		onFinalMessage({ fullText, fullReasoning, toolCalls, anthropicReasoning })
+		const tools = response.content.filter(c => c.type === 'tool_use')
+		const toolCall = tools[0] && anthropicToolToRawToolCallObj(tools[0])
+		const toolCallObj = toolCall ? { toolCall } : {}
+		onFinalMessage({ fullText, fullReasoning, anthropicReasoning, ...toolCallObj })
 	})
 	// on error
 	stream.on('error', (error) => {
@@ -420,21 +480,41 @@ const sendAnthropicChat = ({ messages: messages_, providerName, onText, onFinalM
 	_setAborter(() => stream.controller.abort())
 }
 
-// //  in future, can do tool_use streaming in anthropic, but it's pretty fast even without streaming...
-// const toolCallOfIndex: { [index: string]: { name: string, args: string } } = {}
-// stream.on('streamEvent', e => {
-// 	if (e.type === 'content_block_start') {
-// 		if (e.content_block.type !== 'tool_use') return
-// 		const index = e.index
-// 		if (!toolCallOfIndex[index]) toolCallOfIndex[index] = { name: '', args: '' }
-// 		toolCallOfIndex[index].name += e.content_block.name ?? ''
-// 		toolCallOfIndex[index].args += e.content_block.input ?? ''
-// 	}
-// 	else if (e.type === 'content_block_delta') {
-// 		if (e.delta.type !== 'input_json_delta') return
-// 		toolCallOfIndex[e.index].args += e.delta.partial_json
-// 	}
-// })
+
+
+// ------------ MISTRAL ------------
+// https://docs.mistral.ai/api/#tag/fim
+const sendMistralFIM = ({ messages, onFinalMessage, onError, settingsOfProvider, modelName: modelName_, _setAborter, providerName }: SendFIMParams_Internal) => {
+	const { modelName, supportsFIM } = getModelCapabilities(providerName, modelName_)
+	if (!supportsFIM) {
+		if (modelName === modelName_)
+			onError({ message: `Model ${modelName} does not support FIM.`, fullError: null })
+		else
+			onError({ message: `Model ${modelName_} (${modelName}) does not support FIM.`, fullError: null })
+		return
+	}
+
+	const mistral = new MistralCore({ apiKey: settingsOfProvider.mistral.apiKey })
+	fimComplete(mistral,
+		{
+			model: modelName,
+			prompt: messages.prefix,
+			suffix: messages.suffix,
+			stream: false,
+			maxTokens: 300,
+			stop: messages.stopTokens,
+		})
+		.then(async response => {
+			let content = response?.ok ? response.value.choices?.[0]?.message?.content ?? '' : '';
+			const fullText = typeof content === 'string' ? content
+				: content.map(chunk => (chunk.type === 'text' ? chunk.text : '')).join('')
+
+			onFinalMessage({ fullText, fullReasoning: '', anthropicReasoning: null });
+		})
+		.catch(error => {
+			onError({ message: error + '', fullError: error });
+		})
+}
 
 
 // ------------ OLLAMA ------------
@@ -469,12 +549,10 @@ const ollamaList = async ({ onSuccess: onSuccess_, onError: onError_, settingsOf
 	}
 }
 
-const sendOllamaFIM = ({ messages: messages_, onFinalMessage, onError, settingsOfProvider, modelName, aiInstructions, _setAborter }: SendFIMParams_Internal) => {
+const sendOllamaFIM = ({ messages, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter }: SendFIMParams_Internal) => {
 	const thisConfig = settingsOfProvider.ollama
 	const ollama = newOllamaSDK({ endpoint: thisConfig.endpoint })
 
-	const messages = prepareFIMMessage({ messages: messages_, aiInstructions, })
-
 	let fullText = ''
 	ollama.generate({
 		model: modelName,
@@ -482,7 +560,7 @@ const sendOllamaFIM = ({ messages: messages_, onFinalMessage, onError, settingsO
 		suffix: messages.suffix,
 		options: {
 			stop: messages.stopTokens,
-			num_predict: messages.maxTokens, // max tokens
+			num_predict: 300, // max tokens
 			// repeat_penalty: 1,
 		},
 		raw: true,
@@ -533,11 +611,11 @@ export const sendLLMMessageToProviderImplementation = {
 		sendFIM: null,
 		list: null,
 	},
-	// mistral: {
-	// 	sendChat: , // TODO
-	// 	sendFIM: , // TODO // https://docs.mistral.ai/api/#tag/fim
-	// 	list: null,
-	// },
+	mistral: {
+		sendChat: (params) => _sendOpenAICompatibleChat(params),
+		sendFIM: (params) => sendMistralFIM(params),
+		list: null,
+	},
 	ollama: {
 		sendChat: (params) => _sendOpenAICompatibleChat(params),
 		sendFIM: sendOllamaFIM,

src/vs/workbench/contrib/void/electron-main/llmMessage/sendLLMMessage.ts

@@ -11,7 +11,6 @@ import { sendLLMMessageToProviderImplementation } from './sendLLMMessage.impl.js
 
 export const sendLLMMessage = ({
 	messagesType,
-	aiInstructions,
 	messages: messages_,
 	onText: onText_,
 	onFinalMessage: onFinalMessage_,
@@ -21,7 +20,8 @@ export const sendLLMMessage = ({
 	settingsOfProvider,
 	modelSelection,
 	modelSelectionOptions,
-	tools,
+	chatMode,
+	separateSystemMessage,
 }: SendLLMMessageParams,
 
 	metricsService: IMetricsService
@@ -108,12 +108,12 @@ export const sendLLMMessage = ({
 		}
 		const { sendFIM, sendChat } = implementation
 		if (messagesType === 'chatMessages') {
-			sendChat({ messages: messages_, onText, onFinalMessage, onError, settingsOfProvider, modelSelectionOptions, modelName, _setAborter, providerName, aiInstructions, tools })
+			sendChat({ messages: messages_, onText, onFinalMessage, onError, settingsOfProvider, modelSelectionOptions, modelName, _setAborter, providerName, separateSystemMessage, chatMode })
 			return
 		}
 		if (messagesType === 'FIMMessage') {
 			if (sendFIM) {
-				sendFIM({ messages: messages_, onText, onFinalMessage, onError, settingsOfProvider, modelSelectionOptions, modelName, _setAborter, providerName, aiInstructions })
+				sendFIM({ messages: messages_, onText, onFinalMessage, onError, settingsOfProvider, modelSelectionOptions, modelName, _setAborter, providerName, separateSystemMessage })
 				return
 			}
 			onError({ message: `Error: This provider does not support Autocomplete yet.`, fullError: null })

src/vs/workbench/contrib/void/electron-main/voidUpdateMainService.ts

@@ -6,8 +6,9 @@
 import { Disposable } from '../../../../base/common/lifecycle.js';
 import { IEnvironmentMainService } from '../../../../platform/environment/electron-main/environmentMainService.js';
 import { IProductService } from '../../../../platform/product/common/productService.js';
-
+import { IUpdateService, StateType } from '../../../../platform/update/common/update.js';
 import { IVoidUpdateService } from '../common/voidUpdateService.js';
+import { VoidCheckUpdateRespose } from '../common/voidUpdateServiceTypes.js';
 
 
 
@@ -17,33 +18,128 @@ export class VoidMainUpdateService extends Disposable implements IVoidUpdateServ
 	constructor(
 		@IProductService private readonly _productService: IProductService,
 		@IEnvironmentMainService private readonly _envMainService: IEnvironmentMainService,
+		@IUpdateService private readonly _updateService: IUpdateService,
 	) {
 		super()
 	}
 
-	async check() {
+
+	async check(explicit: boolean): Promise<VoidCheckUpdateRespose> {
+
 		const isDevMode = !this._envMainService.isBuilt // found in abstractUpdateService.ts
 
 		if (isDevMode) {
-			return { hasUpdate: false } as const
+			return { message: null } as const
 		}
 
+		this._updateService.checkForUpdates(false) // implicity check, then handle result ourselves
+
+		console.log('updateState', this._updateService.state)
+
+		if (this._updateService.state.type === StateType.Uninitialized) {
+			// The update service hasn't been initialized yet
+			return { message: explicit ? 'Checking for updates soon...' : null, action: explicit ? 'reinstall' : undefined } as const
+		}
+
+		if (this._updateService.state.type === StateType.Idle) {
+			// No updates currently available
+			return { message: explicit ? 'No updates found!' : null, action: explicit ? 'reinstall' : undefined } as const
+		}
+
+		if (this._updateService.state.type === StateType.CheckingForUpdates) {
+			// Currently checking for updates
+			return { message: explicit ? 'Checking for updates...' : null } as const
+		}
+
+		if (this._updateService.state.type === StateType.AvailableForDownload) {
+			// Update available but requires manual download (mainly for Linux)
+			return { message: 'A new update is available!', action: 'download', } as const
+		}
+
+		if (this._updateService.state.type === StateType.Downloading) {
+			// Update is currently being downloaded
+			return { message: explicit ? 'Currently downloading update...' : null } as const
+		}
+
+		if (this._updateService.state.type === StateType.Downloaded) {
+			// Update has been downloaded but not yet ready
+			return { message: explicit ? 'An update is ready to be applied!' : null, action: 'apply' } as const
+		}
+
+		if (this._updateService.state.type === StateType.Updating) {
+			// Update is being applied
+			return { message: explicit ? 'Applying update...' : null } as const
+		}
+
+		if (this._updateService.state.type === StateType.Ready) {
+			// Update is ready
+			return { message: 'Restart Void to update!', action: 'restart' } as const
+		}
+
+		if (this._updateService.state.type === StateType.Disabled) {
+			return await this._manualCheckGHTagIfDisabled(explicit)
+		}
+		return null
+	}
+
+
+
+
+
+
+	private async _manualCheckGHTagIfDisabled(explicit: boolean): Promise<VoidCheckUpdateRespose> {
 		try {
-			const res = await fetch(`https://updates.voideditor.dev/api/v0/${this._productService.commit}`)
-			const resJSON = await res.json()
+			const response = await fetch('https://api.github.com/repos/voideditor/binaries/releases/latest');
 
-			if (!resJSON) return null
+			const data = await response.json();
+			const version = data.tag_name;
 
-			const { hasUpdate, downloadMessage } = resJSON ?? {}
-			if (hasUpdate === undefined)
-				return null
+			const myVersion = `${this._productService.voidVersion}.${this._productService.release}`
+			const latestVersion = version
 
-			const after = (downloadMessage || '') + ''
-			return { hasUpdate: !!hasUpdate, message: after }
+			const isUpToDate = myVersion === latestVersion // only makes sense if response.ok
+
+			let message: string | null
+			let action: 'reinstall' | undefined
+
+			// explicit
+			if (explicit) {
+				if (response.ok) {
+					if (!isUpToDate) {
+						message = 'A new version of Void is available! Please reinstall (auto-updates are disabled on this OS) - it only takes a second!'
+						action = 'reinstall'
+					}
+					else {
+						message = 'Void is up-to-date!'
+					}
+				}
+				else {
+					message = `An error occurred when fetching the latest GitHub release tag. Please try again in ~5 minutes, or reinstall.`
+					action = 'reinstall'
+				}
+			}
+			// not explicit
+			else {
+				if (response.ok && !isUpToDate) {
+					message = 'A new version of Void is available! Please reinstall (auto-updates are disabled on this OS) - it only takes a second!'
+					action = 'reinstall'
+				}
+				else {
+					message = null
+				}
+			}
+			return { message, action } as const
 		}
 		catch (e) {
-			return null
+			if (explicit) {
+				return {
+					message: `An error occurred when fetching the latest GitHub release tag: ${e}. Please try again in ~5 minutes.`,
+					action: 'reinstall',
+				}
+			}
+			else {
+				return { message: null } as const
+			}
 		}
 	}
 }
-