Merge pull request #290 from voideditor/model-selection

Tool use progress
2026-05-23 17:38:23 +00:00 · 2025-02-19 00:03:01 -08:00 · 2025-02-19 00:03:01 -08:00 · 7206209743
commit 7206209743
parent ea6e025511 02f64b7ff6
37 changed files with 2639 additions and 1167 deletions
--- a/src/vs/workbench/contrib/void/browser/MarkerCheckService.ts
+++ b/src/vs/workbench/contrib/void/browser/MarkerCheckService.ts
@ -0,0 +1,119 @@
+/*--------------------------------------------------------------------------------------
+ *  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 { InstantiationType, registerSingleton } from '../../../../platform/instantiation/common/extensions.js';
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+import { IMarkerService, MarkerSeverity } from '../../../../platform/markers/common/markers.js';
+import { ILanguageFeaturesService } from '../../../../editor/common/services/languageFeatures.js';
+import { ITextModelService } from '../../../../editor/common/services/resolverService.js';
+import { Range } from '../../../../editor/common/core/range.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { CodeActionContext, CodeActionTriggerType } from '../../../../editor/common/languages.js';
+
+export interface IMarkerCheckService {
+	readonly _serviceBrand: undefined;
+}
+
+export const IMarkerCheckService = createDecorator<IMarkerCheckService>('markerCheckService');
+
+class MarkerCheckService extends Disposable implements IMarkerCheckService {
+	_serviceBrand: undefined;
+
+	constructor(
+		@IMarkerService private readonly _markerService: IMarkerService,
+		@ILanguageFeaturesService private readonly _languageFeaturesService: ILanguageFeaturesService,
+		@ITextModelService private readonly _textModelService: ITextModelService,
+	) {
+		super();
+
+		setInterval(async () => {
+			const allMarkers = this._markerService.read();
+			const errors = allMarkers.filter(marker => marker.severity === MarkerSeverity.Error);
+
+			if (errors.length > 0) {
+				for (const error of errors) {
+
+					console.log(`----------------------------------------------`);
+
+					console.log(`${error.resource.toString()}: ${error.startLineNumber} ${error.message} ${error.severity}`); // ! all errors in the file
+
+					try {
+						// Get the text model for the file
+						const modelReference = await this._textModelService.createModelReference(error.resource);
+						const model = modelReference.object.textEditorModel;
+
+						// Create a range from the marker
+						const range = new Range(
+							error.startLineNumber,
+							error.startColumn,
+							error.endLineNumber,
+							error.endColumn
+						);
+
+						// Get code action providers for this model
+						const codeActionProvider = this._languageFeaturesService.codeActionProvider;
+						const providers = codeActionProvider.ordered(model);
+
+						if (providers.length > 0) {
+							// Request code actions from each provider
+							for (const provider of providers) {
+								const context: CodeActionContext = {
+									trigger: CodeActionTriggerType.Invoke, // keeping 'trigger' since it works
+									only: 'quickfix'  // adding this to filter for quick fixes
+								};
+
+								const actions = await provider.provideCodeActions(
+									model,
+									range,
+									context,
+									CancellationToken.None
+								);
+
+								if (actions?.actions?.length) {
+
+									const quickFixes = actions.actions.filter(action => action.isPreferred);  // ! all quickFixes for the error
+									const quickFixesForImports = actions.actions.filter(action => action.isPreferred && action.title.includes('import'));  // ! all possible imports
+									quickFixesForImports
+
+									if (quickFixes.length > 0) {
+										console.log('Available Quick Fixes:');
+										quickFixes.forEach(action => {
+											console.log(`- ${action.title}`);
+										});
+									}
+								}
+							}
+						}
+
+						// Dispose the model reference
+						modelReference.dispose();
+					} catch (e) {
+						console.error('Error getting quick fixes:', e);
+					}
+				}
+			}
+		}, 5000);
+	}
+
+
+	// private _onMarkersChanged = (changedResources: readonly URI[]): void => {
+	// 	for (const resource of changedResources) {
+	// 		const markers = this._markerService.read({ resource });
+
+	// 		if (markers.length === 0) {
+	// 			console.log(`${resource.toString()}: No diagnostics`);
+	// 			continue;
+	// 		}
+
+	// 		console.log(`Diagnostics for ${resource.toString()}:`);
+	// 		markers.forEach(marker => this._logMarker(marker));
+	// 	}
+	// };
+
+
+}
+
+registerSingleton(IMarkerCheckService, MarkerCheckService, InstantiationType.Eager);
--- a/src/vs/workbench/contrib/void/browser/aiRegexService.ts
+++ b/src/vs/workbench/contrib/void/browser/aiRegexService.ts
@ -0,0 +1,187 @@
+/*--------------------------------------------------------------------------------------
+ *  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 { URI } from '../../../../base/common/uri.js';
+import { InstantiationType, registerSingleton } from '../../../../platform/instantiation/common/extensions.js';
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+// import { IToolService, ToolService } from '../common/toolsService.js';
+
+
+
+export type ChatMessageLocation = {
+	threadId: string;
+	messageIdx: number;
+}
+
+
+export type SearchAndReplaceBlock = {
+	search: string;
+	replace: string;
+}
+
+// service that manages state
+export type ApplyState = {
+	[applyBoxId: string]: {
+		searchAndReplaceBlocks: SearchAndReplaceBlock;
+	}
+}
+
+// the purpose of this service is to generate search and replace blocks for a given codeblock `codeblockId` and on a file `fileName` and version `fileVersion`
+
+export interface IFastApplyService {
+	readonly _serviceBrand: undefined;
+
+	// readonly state: ApplyState; // readonly to the user
+	// setState(newState: Partial<ApplyState>): void;
+	// onDidChangeState: Event<void>;
+}
+
+export const IVoidFastApplyService = createDecorator<IFastApplyService>('voidFastApplyService');
+class VoidFastApplyService extends Disposable implements IFastApplyService {
+	_serviceBrand: undefined;
+
+	// static readonly ID = 'voidFastApplyService';
+
+	private readonly _onDidChangeState = new Emitter<void>();
+	readonly onDidChangeState: Event<void> = this._onDidChangeState.event;
+
+
+	// state
+	// state: ApplyState
+
+	constructor(
+		// @IToolService private readonly toolService: ToolService
+	) {
+		super()
+
+		// initial state
+		// this.state = { currentUri: undefined }
+	}
+
+	setState(newState: Partial<ApplyState>) {
+
+		// this.state = { ...this.state, ...newState }
+		this._onDidChangeState.fire()
+	}
+
+	aiSearch(searchStr: string) {
+
+	}
+
+	aiReplace(searchStr: string, replaceStr: string) {
+
+	}
+
+
+	// 1. search(ai)
+	// - tool use to find all possible changes
+	// - if search only: is this file related to the search?
+	// - if search + replace: should I modify this file?
+	// 2. replace(ai)
+	// - what changes to make?
+	// 3. postprocess errors
+	// -fastapply changes simultaneously
+	// -iterate on syntax errors (all files can be changed from a syntax error, not just the one with the error)
+
+
+	// private async _searchUsingAI({ searchClause }: { searchClause: string }) {
+
+	// 	// 		const relevantURIs: URI[] = []
+	// 	// 		const gatherPrompt = `\
+	// 	// asdasdas
+	// 	// `
+	// 	// 		const filterPrompt = `\
+	// 	// Is this file relevant?
+	// 	// `
+
+
+	// 	// 		// optimizations (DO THESE LATER!!!!!!)
+	// 	// 		// if tool includes a uri in uriSet, skip it obviously
+	// 	// 		let uriSet = new Set<URI>()
+	// 	// 		// gather
+	// 	// 		let messages = []
+	// 	// 		while (true) {
+	// 	// 			const result = await new Promise((res, rej) => {
+	// 	// 				sendLLMMessage({
+	// 	// 					messages,
+	// 	// 					tools: ['search'],
+	// 	// 					onFinalMessage: ({ result: r, }) => {
+	// 	// 						res(r)
+	// 	// 					},
+	// 	// 					onError: (error) => {
+	// 	// 						rej(error)
+	// 	// 					}
+	// 	// 				})
+	// 	// 			})
+
+	// 	// 			messages.push({ role: 'tool', content: turnToString(result) })
+
+	// 	// 			sendLLMMessage({
+	// 	// 				messages: { 'Output ': result },
+	// 	// 				onFinalMessage: (r) => {
+	// 	// 					// output is file1\nfile2\nfile3\n...
+	// 	// 				}
+	// 	// 			})
+
+	// 	// 			uriSet.add(...)
+	// 	// 		}
+
+	// 	// 		// writes
+	// 	// 		if (!replaceClause) return
+
+	// 	// 		for (const uri of uriSet) {
+	// 	// 			// in future, batch these
+	// 	// 			applyWorkflow({ uri, applyStr: replaceClause })
+	// 	// 		}
+
+
+
+
+
+
+	// 	// while (true) {
+	// 	// 	const result = new Promise((res, rej) => {
+	// 	// 		sendLLMMessage({
+	// 	// 			messages,
+	// 	// 			tools: ['search'],
+	// 	// 			onResult: (r) => {
+	// 	// 				res(r)
+	// 	// 			}
+	// 	// 		})
+	// 	// 	})
+
+	// 	// 	messages.push(result)
+
+	// 	// }
+
+
+	// }
+
+
+	// private async _replaceUsingAI({ searchClause, replaceClause, relevantURIs }: { searchClause: string, replaceClause: string, relevantURIs: URI[] }) {
+
+	// 	for (const uri of relevantURIs) {
+
+	// 		uri
+
+	// 	}
+
+
+
+	// 	// should I change this file?
+	// 	// if so what changes to make?
+
+
+
+	// 	// fast apply the changes
+	// }
+
+
+
+}
+
+registerSingleton(IVoidFastApplyService, VoidFastApplyService, InstantiationType.Eager);
--- a/src/vs/workbench/contrib/void/browser/chatThreadService.ts
+++ b/src/vs/workbench/contrib/void/browser/chatThreadService.ts
@ -13,7 +13,22 @@ import { Emitter, Event } from '../../../../base/common/event.js';
 import { IRange } from '../../../../editor/common/core/range.js';
 import { ILLMMessageService } from '../common/llmMessageService.js';
 import { IModelService } from '../../../../editor/common/services/model.js';
-import { chat_userMessage, chat_systemMessage } from './prompt/prompts.js';
+import { chat_userMessageContent, chat_systemMessage, chat_userMessageContentWithAllFilesToo as chat_userMessageContentWithAllFiles, chat_selectionsString } from './prompt/prompts.js';
+import { IFileService } from '../../../../platform/files/common/files.js';
+import { InternalToolInfo, IToolsService, ToolCallReturnType, ToolFns, ToolName, voidTools } from '../common/toolsService.js';
+import { toLLMChatMessage } from '../common/llmMessageTypes.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+
+
+const findLastIndex = <T>(arr: T[], condition: (t: T) => boolean): number => {
+	for (let i = arr.length - 1; i >= 0; i--) {
+		if (condition(arr[i])) {
+			return i;
+		}
+	}
+	return -1;
+}
+

 // one of the square items that indicates a selection in a chat bubble (NOT a file, a Selection of text)
 export type CodeSelection = {
@ -33,33 +48,46 @@ export type FileSelection = {
 export type StagingSelectionItem = CodeSelection | FileSelection


-export type StagingInfo = {
-	isBeingEdited: boolean;
-	selections: StagingSelectionItem[] | null; // staging selections in edit mode
+type ToolMessage<T extends ToolName> = {
+	role: 'tool';
+	name: T; // internal use
+	params: string; // internal use
+	id: string; // apis require this tool use id
+	content: string; // result
+	result: ToolCallReturnType<T>; // text message of result
 }

-const defaultStaging: StagingInfo = { isBeingEdited: false, selections: [] }
-

 // WARNING: changing this format is a big deal!!!!!! need to migrate old format to new format on users' computers so people don't get errors.
 export type ChatMessage =
 	| {
+		role: 'system';
+		content: string;
+		displayContent?: undefined;
+	} | {
 		role: 'user';
-		content: string | null; // content sent to the llm - allowed to be '', will be replaced with (empty)
+		content: string | null; // content displayed to the LLM on future calls - allowed to be '', will be replaced with (empty)
 		displayContent: string | null; // content displayed to user  - allowed to be '', will be ignored
 		selections: StagingSelectionItem[] | null; // the user's selection
-		staging: StagingInfo | null
+		state: {
+			stagingSelections: StagingSelectionItem[];
+			isBeingEdited: boolean;
+		}
 	}
 	| {
 		role: 'assistant';
 		content: string | null; // content received from LLM  - allowed to be '', will be replaced with (empty)
 		displayContent: string | null; // content displayed to user (this is the same as content for now) - allowed to be '', will be ignored
 	}
-	| {
-		role: 'system';
-		content: string;
-		displayContent?: undefined;
-	}
+	| ToolMessage<ToolName>
+
+type UserMessageType = ChatMessage & { role: 'user' }
+type UserMessageState = UserMessageType['state']
+
+export const defaultMessageState: UserMessageState = {
+	stagingSelections: [],
+	isBeingEdited: false
+}

 // a 'thread' means a chat message history
 export type ChatThreads = {
@ -68,11 +96,18 @@ export type ChatThreads = {
 		createdAt: string; // ISO string
 		lastModified: string; // ISO string
 		messages: ChatMessage[];
-		staging: StagingInfo | null;
-		focusedMessageIdx?: number | undefined; // index of the message that is being edited (undefined if none)
+		state: {
+			stagingSelections: StagingSelectionItem[];
+			focusedMessageIdx: number | undefined; // index of the message that is being edited (undefined if none)
+			isCheckedOfSelectionId: { [selectionId: string]: boolean };
+		}
 	};
 }

+type ThreadType = ChatThreads[string]
+
+const defaultThreadState: ThreadType['state'] = { stagingSelections: [], focusedMessageIdx: undefined, isCheckedOfSelectionId: {} }
+
 export type ThreadsState = {
 	allThreads: ChatThreads;
 	currentThreadId: string; // intended for internal use only
@ -94,19 +129,22 @@ const newThreadObject = () => {
 		createdAt: now,
 		lastModified: now,
 		messages: [],
-		focusedMessageIdx: undefined,
-		staging: {
-			isBeingEdited: true,
-			selections: [],
-		}
+		state: {
+			stagingSelections: [],
+			focusedMessageIdx: undefined,
+			isCheckedOfSelectionId: {}
+		},
+
 	} satisfies ChatThreads[string]
 }

 const THREAD_VERSION_KEY = 'void.chatThreadVersion'
-const THREAD_VERSION = 'v2'
+const LATEST_THREAD_VERSION = 'v2'

 const THREAD_STORAGE_KEY = 'void.chatThreadStorage'

+
+type ChatMode = 'agent' | 'chat'
 export interface IChatThreadService {
 	readonly _serviceBrand: undefined;

@ -124,10 +162,12 @@ export interface IChatThreadService {
 	isFocusingMessage(): boolean;
 	setFocusedMessageIdx(messageIdx: number | undefined): void;

-	_useFocusedStagingState(messageIdx?: number | undefined): readonly [StagingInfo, (stagingInfo: StagingInfo) => void];
+	// _useFocusedStagingState(messageIdx?: number | undefined): readonly [StagingInfo, (stagingInfo: StagingInfo) => void];
+	_useCurrentThreadState(): readonly [ThreadType['state'], (newState: Partial<ThreadType['state']>) => void];
+	_useCurrentMessageState(messageIdx: number): readonly [UserMessageState, (newState: Partial<UserMessageState>) => void];

-	editUserMessageAndStreamResponse(userMessage: string, messageIdx: number): Promise<void>;
-	addUserMessageAndStreamResponse(userMessage: string): Promise<void>;
+	editUserMessageAndStreamResponse({ userMessage, chatMode, messageIdx }: { userMessage: string, chatMode: ChatMode, messageIdx: number }): Promise<void>;
+	addUserMessageAndStreamResponse({ userMessage, chatMode }: { userMessage: string, chatMode: ChatMode }): Promise<void>;
 	cancelStreaming(threadId: string): void;
 	dismissStreamError(threadId: string): void;

@ -150,84 +190,83 @@ class ChatThreadService extends Disposable implements IChatThreadService {
 	constructor(
 		@IStorageService private readonly _storageService: IStorageService,
 		@IModelService private readonly _modelService: IModelService,
+		@IFileService private readonly _fileService: IFileService,
 		@ILLMMessageService private readonly _llmMessageService: ILLMMessageService,
+		@IToolsService private readonly _toolsService: IToolsService,
+		@IWorkspaceContextService private readonly _workspaceContextService: IWorkspaceContextService,
 	) {
 		super()

+		const oldVersionNum = this._storageService.get(THREAD_VERSION_KEY, StorageScope.APPLICATION)
+
+
+		const readThreads = this._readAllThreads()
+		const updatedThreads = this._updatedThreadsToVersion(readThreads, oldVersionNum)
+
+		if (updatedThreads !== null) {
+			this._storeAllThreads(updatedThreads)
+		}
+
+		const allThreads = updatedThreads ?? readThreads
 		this.state = {
-			allThreads: this._readAllThreads(),
+			allThreads: allThreads,
 			currentThreadId: null as unknown as string, // gets set in startNewThread()
 		}

 		// always be in a thread
 		this.openNewThread()

-		// for now just write the version, anticipating bigger changes in the future where we'll want to access this
-		this._storageService.store(THREAD_VERSION_KEY, THREAD_VERSION, StorageScope.APPLICATION, StorageTarget.USER)
+		this._storageService.store(THREAD_VERSION_KEY, LATEST_THREAD_VERSION, StorageScope.APPLICATION, StorageTarget.USER)

 	}


 	private _readAllThreads(): ChatThreads {
-		// PUT ANY VERSION CHANGE FORMAT CONVERSION CODE HERE
-		// CAN ADD "v0" TAG IN STORAGE AND CONVERT
-
-
 		const threadsStr = this._storageService.get(THREAD_STORAGE_KEY, StorageScope.APPLICATION)
-
 		const threads: ChatThreads = threadsStr ? JSON.parse(threadsStr) : {}

-		this._updateThreadsToVersion(threads, THREAD_VERSION)
-
 		return threads
 	}


-	private _updateThreadsToVersion(oldThreadsObject: any, toVersion: string) {
+	// returns if should update
+	private _updatedThreadsToVersion(oldThreadsObject: any, oldVersion: string | undefined): ChatThreads | null {

-		if (toVersion === 'v2') {
+		if (!oldVersion) {

-			const threads: ChatThreads = oldThreadsObject
-
-			/** v1 -> v2
-				- threadsState.currentStagingSelections: CodeStagingSelection[] | null;
-				+ thread.staging: StagingInfo
-				+ thread.focusedMessageIdx?: number | undefined;
+			// unknown, just reset chat?
+			return null
+		}

+		/** v1 -> v2
+				- threads.state.currentStagingSelections: CodeStagingSelection[] | null;
+				+ thread[threadIdx].state
+				+ message.state
 				+ chatMessage.staging: StagingInfo | null
-			*/
-
-			// check if we need to update
-			let shouldUpdate = false
-			for (const thread of Object.values(threads)) {
-				if (!thread.staging) {
-					shouldUpdate = true
-				}
-				for (const chatMessage of Object.values(thread.messages)) {
-					if (chatMessage.role === 'user' && !chatMessage.staging) {
-						shouldUpdate = true
-					}
-				}
-			}
-
-			if (!shouldUpdate) return;
-
+				*/
+		else if (oldVersion === 'v1') {
+			const threads = oldThreadsObject as Omit<ChatThreads, 'staging' | 'focusedMessageIdx'>
 			// update the threads
 			for (const thread of Object.values(threads)) {
-				if (!thread.staging) {
-					thread.staging = defaultStaging
-					thread.focusedMessageIdx = undefined
+				if (!thread.state) {
+					thread.state = defaultThreadState
 				}
 				for (const chatMessage of Object.values(thread.messages)) {
-					if (chatMessage.role === 'user' && !chatMessage.staging) {
-						chatMessage.staging = defaultStaging
+					if (chatMessage.role === 'user' && !chatMessage.state) {
+						chatMessage.state = defaultMessageState
 					}
 				}
 			}

 			// push the update
-			this._storeAllThreads(threads)
+			return threads
 		}
+		else if (oldVersion === 'v2') {
+			return null
+		}
+
+		// up to date
+		return null

 	}

@ -245,6 +284,17 @@ class ChatThreadService extends Disposable implements IChatThreadService {
 			this._onDidChangeCurrentThread.fire()
 	}

+	private _getAllSelections() {
+		const thread = this.getCurrentThread()
+		return thread.messages.flatMap(m => m.role === 'user' && m.selections || [])
+	}
+
+	private _getSelectionsUpToMessageIdx(messageIdx: number) {
+		const thread = this.getCurrentThread()
+		const prevMessages = thread.messages.slice(0, messageIdx)
+		return prevMessages.flatMap(m => m.role === 'user' && m.selections || [])
+	}
+
 	private _setStreamState(threadId: string, state: Partial<NonNullable<ThreadStreamState[string]>>) {
 		this.streamState[threadId] = {
 			...this.streamState[threadId],
@ -256,24 +306,27 @@ class ChatThreadService extends Disposable implements IChatThreadService {

 	// ---------- streaming ----------

-	finishStreaming = (threadId: string, content: string, error?: { message: string, fullError: Error | null }) => {
+	private _finishStreamingTextMessage = (threadId: string, content: string, error?: { message: string, fullError: Error | null }) => {
 		// add assistant's message to chat history, and clear selection
-		const assistantHistoryElt: ChatMessage = { role: 'assistant', content, displayContent: content || null }
-		this._addMessageToThread(threadId, assistantHistoryElt)
+		this._addMessageToThread(threadId, { role: 'assistant', content, displayContent: content || null })
 		this._setStreamState(threadId, { messageSoFar: undefined, streamingToken: undefined, error })
 	}


-	async editUserMessageAndStreamResponse(userMessage: string, messageIdx: number) {
+
+
+	async editUserMessageAndStreamResponse({ userMessage, chatMode, messageIdx }: { userMessage: string, chatMode: ChatMode, messageIdx: number }) {

 		const thread = this.getCurrentThread()

-		const messageToReplace = thread.messages[messageIdx]
-		if (messageToReplace?.role !== 'user') {
-			console.log(`Error: tried to edit non-user message. messageIdx=${messageIdx}, numMessages=${thread.messages.length}`)
-			return
+		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 prevSelns = this._getSelectionsUpToMessageIdx(messageIdx)
+		const currSelns = thread.messages[messageIdx].selections || []
+
 		// clear messages up to the index
 		const slicedMessages = thread.messages.slice(0, messageIdx)
 		this._setState({
@ -286,58 +339,137 @@ class ChatThreadService extends Disposable implements IChatThreadService {
 			}
 		}, true)

-		// stream the edit
-		this.addUserMessageAndStreamResponse(userMessage, messageToReplace.staging)
+		// re-add the message and stream it
+		this.addUserMessageAndStreamResponse({ userMessage, chatMode, chatSelections: { prevSelns, currSelns } })

 	}

-	async addUserMessageAndStreamResponse(userMessage: string, stagingOverride?: StagingInfo | null) {


+	async addUserMessageAndStreamResponse({ userMessage, chatMode, chatSelections }: { userMessage: string, chatMode: ChatMode, chatSelections?: { prevSelns?: StagingSelectionItem[], currSelns?: StagingSelectionItem[] } }) {
+
 		const thread = this.getCurrentThread()
 		const threadId = thread.id

-		let threadStaging = thread.staging
-
-		const currStaging = stagingOverride ?? threadStaging ?? defaultStaging // don't use _useFocusedStagingState to avoid race conditions with focusing
-		const { selections: currSelns, } = currStaging
+		// selections in all past chats, then in current chat (can have many duplicates here)
+		const prevSelns: StagingSelectionItem[] = chatSelections?.prevSelns ?? this._getAllSelections()
+		const currSelns: StagingSelectionItem[] = chatSelections?.currSelns ?? thread.state.stagingSelections

 		// add user's message to chat history
 		const instructions = userMessage
-		const content = await chat_userMessage(instructions, currSelns, this._modelService)
-		const userHistoryElt: ChatMessage = { role: 'user', content: content, displayContent: instructions, selections: currSelns, staging: null, }
+		const userMessageContent = await chat_userMessageContent(instructions, currSelns)
+		const selectionsStr = await chat_selectionsString(prevSelns, currSelns, this._modelService, this._fileService)
+		const userMessageFullContent = chat_userMessageContentWithAllFiles(userMessageContent, selectionsStr)
+
+		const userHistoryElt: ChatMessage = { role: 'user', content: userMessageContent, displayContent: instructions, selections: currSelns, state: defaultMessageState }
 		this._addMessageToThread(threadId, userHistoryElt)

 		this._setStreamState(threadId, { error: undefined })

-		const llmCancelToken = this._llmMessageService.sendLLMMessage({
-			messagesType: 'chatMessages',
-			logging: { loggingName: 'Chat' },
-			useProviderFor: 'Ctrl+L',
-			messages: [
-				{ role: 'system', content: chat_systemMessage },
-				...this.getCurrentThread().messages.map(m => ({ role: m.role, content: m.content || '(empty model output)' })),
-			],
-			onText: ({ newText, fullText }) => {
-				this._setStreamState(threadId, { messageSoFar: fullText })
-			},
-			onFinalMessage: ({ fullText: content }) => {
-				this.finishStreaming(threadId, content)
-			},
-			onError: (error) => {
-				this.finishStreaming(threadId, this.streamState[threadId]?.messageSoFar ?? '', error)
-			},

-		})
-		if (llmCancelToken === null) return
-		this._setStreamState(threadId, { streamingToken: llmCancelToken })
+		const tools: InternalToolInfo[] | undefined = (
+			chatMode === 'chat' ? undefined
+				: chatMode === 'agent' ? Object.keys(voidTools).map(toolName => voidTools[toolName as ToolName])
+					: undefined)
+
+		// agent loop
+		const agentLoop = async () => {
+
+			let shouldSendAnotherMessage = true
+			let nMessagesSent = 0
+
+			while (shouldSendAnotherMessage) {
+				shouldSendAnotherMessage = false
+				nMessagesSent += 1
+
+				let res_: () => void
+				const awaitable = new Promise<void>((res, rej) => { res_ = res })
+
+				// replace last userMessage with userMessageFullContent (which contains all the files too)
+				const messages_ = this.getCurrentThread().messages.map(m => (toLLMChatMessage(m)))
+				const lastUserMsgIdx = findLastIndex(messages_, m => m.role === 'user')
+				let messages = messages_
+				if (lastUserMsgIdx !== -1) { // should never be -1
+					messages = [
+						...messages.slice(0, lastUserMsgIdx),
+						{ role: 'user', content: userMessageFullContent },
+						...messages.slice(lastUserMsgIdx + 1, Infinity)]
+				}
+
+				const llmCancelToken = this._llmMessageService.sendLLMMessage({
+					messagesType: 'chatMessages',
+					useProviderFor: 'Ctrl+L',
+					logging: { loggingName: `Agent` },
+					messages: [
+						{ role: 'system', content: chat_systemMessage(this._workspaceContextService.getWorkspace().folders.map(f => f.uri.fsPath)) },
+						...messages,
+					],
+
+					tools: tools,
+
+					onText: ({ fullText }) => {
+						this._setStreamState(threadId, { messageSoFar: fullText })
+					},
+					onFinalMessage: async ({ fullText, toolCalls }) => {
+
+						if ((toolCalls?.length ?? 0) === 0) {
+							this._finishStreamingTextMessage(threadId, fullText)
+						}
+						else {
+							this._addMessageToThread(threadId, { role: 'assistant', content: fullText, displayContent: fullText })
+							this._setStreamState(threadId, { messageSoFar: undefined }) // clear streaming message
+							for (const tool of toolCalls ?? []) {
+								const toolName = tool.name as ToolName
+
+								// 1.
+								let toolResult: Awaited<ReturnType<ToolFns[ToolName]>>
+								let toolResultVal: ToolCallReturnType<ToolName>
+								try {
+									toolResult = await this._toolsService.toolFns[toolName](tool.params)
+									toolResultVal = toolResult[0]
+								} catch (error) {
+									this._setStreamState(threadId, { error })
+									shouldSendAnotherMessage = false
+									break
+								}
+
+								// 2.
+								let toolResultStr: string
+								try {
+									toolResultStr = this._toolsService.toolResultToString[toolName](toolResult as any) // typescript is so bad it doesn't even couple the type of ToolResult with the type of the function being called here
+								} catch (error) {
+									this._setStreamState(threadId, { error })
+									shouldSendAnotherMessage = false
+									break
+								}
+
+								this._addMessageToThread(threadId, { role: 'tool', name: toolName, params: tool.params, id: tool.id, content: toolResultStr, result: toolResultVal, })
+								shouldSendAnotherMessage = true
+							}
+
+						}
+						res_()
+					},
+					onError: (error) => {
+						this._finishStreamingTextMessage(threadId, this.streamState[threadId]?.messageSoFar ?? '', error)
+						res_()
+					},
+				})
+				if (llmCancelToken === null) break
+				this._setStreamState(threadId, { streamingToken: llmCancelToken })
+
+				await awaitable
+			}
+		}
+
+		agentLoop() // DO NOT AWAIT THIS, this fn should resolve when ready to clear inputs

 	}

 	cancelStreaming(threadId: string) {
 		const llmCancelToken = this.streamState[threadId]?.streamingToken
 		if (llmCancelToken !== undefined) this._llmMessageService.abort(llmCancelToken)
-		this.finishStreaming(threadId, this.streamState[threadId]?.messageSoFar ?? '')
+		this._finishStreamingTextMessage(threadId, this.streamState[threadId]?.messageSoFar ?? '')
 	}

 	dismissStreamError(threadId: string): void {
@ -357,13 +489,13 @@ class ChatThreadService extends Disposable implements IChatThreadService {
 		const thread = this.getCurrentThread()

 		// get the focusedMessageIdx
-		const focusedMessageIdx = thread.focusedMessageIdx
+		const focusedMessageIdx = thread.state.focusedMessageIdx
 		if (focusedMessageIdx === undefined) return;

 		// check that the message is actually being edited
 		const focusedMessage = thread.messages[focusedMessageIdx]
 		if (focusedMessage.role !== 'user') return;
-		if (!focusedMessage.staging?.isBeingEdited) return;
+		if (!focusedMessage.state) return;

 		return focusedMessageIdx
 	}
@ -429,28 +561,34 @@ class ChatThreadService extends Disposable implements IChatThreadService {
 				...this.state.allThreads,
 				[threadId]: {
 					...thread,
-					focusedMessageIdx: messageIdx
+					state: {
+						...thread.state,
+						focusedMessageIdx: messageIdx,
+					}
 				}
 			}
 		}, true)
 	}

-	// set thread.messages[messageIdx].stagingSelections
-	private setEditMessageStaging(staging: StagingInfo, messageIdx: number): void {
+	// set message.state
+	private _setCurrentMessageState(state: Partial<UserMessageState>, messageIdx: number): void {

-		const thread = this.getCurrentThread()
-		const message = thread.messages[messageIdx]
-		if (message.role !== 'user') return;
+		const threadId = this.state.currentThreadId
+		const thread = this.state.allThreads[threadId]
+		if (!thread) return

 		this._setState({
 			allThreads: {
 				...this.state.allThreads,
-				[thread.id]: {
+				[threadId]: {
 					...thread,
 					messages: thread.messages.map((m, i) =>
-						i === messageIdx ? {
+						i === messageIdx && m.role === 'user' ? {
 							...m,
-							staging,
+							state: {
+								...m.state,
+								...state
+							},
 						} : m
 					)
 				}
@ -459,17 +597,22 @@ class ChatThreadService extends Disposable implements IChatThreadService {

 	}

-	// set thread.stagingSelections
-	private setDefaultStaging(staging: StagingInfo): void {
+	// set thread.state
+	private _setCurrentThreadState(state: Partial<ThreadType['state']>): void {

-		const thread = this.getCurrentThread()
+		const threadId = this.state.currentThreadId
+		const thread = this.state.allThreads[threadId]
+		if (!thread) return

 		this._setState({
 			allThreads: {
 				...this.state.allThreads,
 				[thread.id]: {
 					...thread,
-					staging,
+					state: {
+						...thread.state,
+						...state
+					}
 				}
 			}
 		}, true)
@ -477,30 +620,31 @@ class ChatThreadService extends Disposable implements IChatThreadService {
 	}

 	// gets `staging` and `setStaging` of the currently focused element, given the index of the currently selected message (or undefined if no message is selected)
-	_useFocusedStagingState(messageIdx?: number | undefined) {

-		const defaultStaging = { isBeingEdited: false, selections: [], text: '' }
-
-		let staging: StagingInfo = defaultStaging
-		let setStaging: (selections: StagingInfo) => void = () => { }
+	_useCurrentMessageState(messageIdx: number) {

 		const thread = this.getCurrentThread()
-		const isFocusingMessage = messageIdx !== undefined
-		if (isFocusingMessage) { // is editing message
+		const messages = thread.messages
+		const currMessage = messages[messageIdx]

-			const message = thread.messages[messageIdx!]
-			if (message.role === 'user') {
-				staging = message.staging || defaultStaging
-				setStaging = (s) => this.setEditMessageStaging(s, messageIdx)
-			}
-
-		}
-		else { // is editing the default input box
-			staging = thread.staging || defaultStaging
-			setStaging = this.setDefaultStaging.bind(this)
+		if (currMessage.role !== 'user') {
+			return [defaultMessageState, (s: any) => { }] as const
 		}

-		return [staging, setStaging] as const
+		const state = currMessage.state
+		const setState = (newState: Partial<UserMessageState>) => this._setCurrentMessageState(newState, messageIdx)
+
+		return [state, setState] as const
+
+	}
+
+	_useCurrentThreadState() {
+		const thread = this.getCurrentThread()
+
+		const state = thread.state
+		const setState = this._setCurrentThreadState.bind(this)
+
+		return [state, setState] as const
 	}


--- a/src/vs/workbench/contrib/void/browser/inlineDiffsService.ts
+++ b/src/vs/workbench/contrib/void/browser/inlineDiffsService.ts
@ -25,12 +25,12 @@ import * as dom from '../../../../base/browser/dom.js';
 import { Widget } from '../../../../base/browser/ui/widget.js';
 import { URI } from '../../../../base/common/uri.js';
 import { IConsistentEditorItemService, IConsistentItemService } from './helperServices/consistentItemService.js';
-import { voidPrefixAndSuffix, ctrlKStream_userMessage, ctrlKStream_systemMessage, fastApply_rewritewholething_userMessage, fastApply_rewritewholething_systemMessage, defaultQuickEditFimTags, tripleTick } from './prompt/prompts.js';
+import { voidPrefixAndSuffix, ctrlKStream_userMessage, ctrlKStream_systemMessage, defaultQuickEditFimTags, rewriteCode_systemMessage, rewriteCode_userMessage, searchReplace_systemMessage, searchReplace_userMessage, } from './prompt/prompts.js';

-import { mountCtrlK } from '../browser/react/out/quick-edit-tsx/index.js'
+import { mountCtrlK } from './react/out/quick-edit-tsx/index.js'
 import { QuickEditPropsType } from './quickEditActions.js';
 import { IModelContentChangedEvent } from '../../../../editor/common/textModelEvents.js';
-import { extractCodeFromFIM, extractCodeFromRegular } from './helpers/extractCodeFromResult.js';
+import { extractCodeFromFIM, extractCodeFromRegular, ExtractedSearchReplaceBlock, extractSearchReplaceBlocks } from './helpers/extractCodeFromResult.js';
 import { filenameToVscodeLanguage } from './helpers/detectLanguage.js';
 import { INotificationService, Severity } from '../../../../platform/notification/common/notification.js';
 import { isMacintosh } from '../../../../base/common/platform.js';
@ -39,9 +39,10 @@ import { Emitter } from '../../../../base/common/event.js';
 import { VOID_OPEN_SETTINGS_ACTION_ID } from './voidSettingsPane.js';
 import { ICommandService } from '../../../../platform/commands/common/commands.js';
 import { ILLMMessageService } from '../common/llmMessageService.js';
-import { LLMChatMessage, _InternalLLMChatMessage, errorDetails } from '../common/llmMessageTypes.js';
+import { LLMChatMessage, errorDetails } from '../common/llmMessageTypes.js';
 import { IMetricsService } from '../common/metricsService.js';
 import { VSReadFile } from './helpers/readFile.js';
+import { IFileService } from '../../../../platform/files/common/files.js';

 const configOfBG = (color: Color) => {
 	return { dark: color, light: color, hcDark: color, hcLight: color, }
@ -65,7 +66,6 @@ registerColor('void.sweepIdxBG', configOfBG(sweepIdxBG), '', true);



-
 const getLeadingWhitespacePx = (editor: ICodeEditor, startLine: number): number => {

 	const model = editor.getModel();
@ -138,12 +138,6 @@ export type Diff = {



-type ExtractedCodeBlock = {
-	state: 'writingOriginal' | 'writingFinal' | 'done',
-	orig: string,
-	final: string,
-}
-
 // _ means anything we don't include if we clone it
 // DiffArea.originalStartLine is the line in originalCode (not the file)

@ -217,7 +211,11 @@ type HistorySnapshot = {



-export interface IInlineDiffsService {
+// line/col is the location, originalCodeStartLine is the start line of the original code being displayed
+type StreamLocationMutable = { line: number, col: number, addedSplitYet: boolean, originalCodeStartLine: number }
+
+
+export interface IEditCodeService {
 	readonly _serviceBrand: undefined;
 	startApplying(opts: StartApplyingOpts): number | undefined;
 	interruptStreaming(diffareaid: number): void;
@ -226,9 +224,9 @@ export interface IInlineDiffsService {
 	// testDiffs(): void;
 }

-export const IInlineDiffsService = createDecorator<IInlineDiffsService>('inlineDiffAreasService');
+export const IEditCodeService = createDecorator<IEditCodeService>('editCodeService');

-class InlineDiffsService extends Disposable implements IInlineDiffsService {
+class EditCodeService extends Disposable implements IEditCodeService {
 	_serviceBrand: undefined;


@ -257,6 +255,7 @@ class InlineDiffsService extends Disposable implements IInlineDiffsService {
 		@IMetricsService private readonly _metricsService: IMetricsService,
 		@INotificationService private readonly _notificationService: INotificationService,
 		@ICommandService private readonly _commandService: ICommandService,
+		@IFileService private readonly _fileService: IFileService,
 	) {
 		super();

@ -702,7 +701,7 @@ class InlineDiffsService extends Disposable implements IInlineDiffsService {
 	}

 	weAreWriting = false
-	private async _writeText(uri: URI, text: string, range: IRange, { shouldRealignDiffAreas }: { shouldRealignDiffAreas: boolean }) {
+	private _writeText(uri: URI, text: string, range: IRange, { shouldRealignDiffAreas }: { shouldRealignDiffAreas: boolean }) {
 		const model = this._getModel(uri)
 		if (!model) return
 		const uriStr = this._readURI(uri, range)
@ -812,7 +811,7 @@ class InlineDiffsService extends Disposable implements IInlineDiffsService {
 			type: UndoRedoElementType.Resource,
 			resource: uri,
 			label: 'Void Changes',
-			code: 'undoredo.inlineDiffs',
+			code: 'undoredo.editCode',
 			undo: () => { restoreDiffAreas(beforeSnapshot) },
 			redo: () => { if (afterSnapshot) restoreDiffAreas(afterSnapshot) }
 		}
@ -1002,7 +1001,7 @@ class InlineDiffsService extends Disposable implements IInlineDiffsService {


 	// @throttle(100)
-	private _writeStreamedDiffZoneLLMText(diffZone: DiffZone, llmText: string, deltaText: string, latestMutable: { line: number, col: number, addedSplitYet: boolean, originalCodeStartLine: number }) {
+	private _writeStreamedDiffZoneLLMText(diffZone: DiffZone, llmText: string, deltaText: string, latestMutable: StreamLocationMutable) {

 		// ----------- 1. Write the new code to the document -----------
 		// figure out where to highlight based on where the AI is in the stream right now, use the last diff to figure that out
@ -1140,6 +1139,10 @@ class InlineDiffsService extends Disposable implements IInlineDiffsService {



+
+
+
+
 	public startApplying(opts: StartApplyingOpts) {

 		if (opts.type === 'rewrite') {
@ -1175,235 +1178,232 @@ class InlineDiffsService extends Disposable implements IInlineDiffsService {


 	private async _initializeSearchAndReplaceStream({ applyStr }: { applyStr: string }) {
-		const ORIGINAL = `<<<<<<< ORIGINAL`
-		const DIVIDER = `=======`
-		const FINAL = `>>>>>>> UPDATED`
-
-		const searchReplaceSysMessage = `\
-You are a coding assistant that generates SEARCH/REPLACE code blocks that will be used to edit a file.
-
-A SEARCH/REPLACE block describes the code before and after a change. Here is the format:
-${ORIGINAL}
-// ... original code goes here
-${DIVIDER}
-// ... final code goes here
-${FINAL}
-
-You will be given the original file \`ORIGINAL_FILE\` and a description of a change \`CHANGE\` to make.
-Output SEARCH/REPLACE blocks to edit the file according to the desired change. You may output multiple SEARCH/REPLACE blocks.
-
-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 of code in the original file.
-3. The "original" code in each SEARCH/REPLACE block should include enough text to uniquely identify the change in the file.
-4. 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 "final" code is complete and will not result in syntax/lint errors.
-5. Follow coding convention (spaces, semilcolons, comments, etc).
-
-## EXAMPLE 1
-ORIGINAL_FILE
-${tripleTick[0]}
-let w = 5
-let x = 6
-let y = 7
-let z = 8
-${tripleTick[1]}
-
-CHANGE
-Make x equal to 6.5, not 6.
-${tripleTick[0]}
-// ... existing code
-let x = 6.5
-// ... existing code
-${tripleTick[1]}
-
-
-## ACCEPTED OUTPUT
-${tripleTick[0]}
-${ORIGINAL}
-let x = 6
-${DIVIDER}
-let x = 6.5
-${FINAL}
-${tripleTick[1]}
-`

 		const uri_ = this._getActiveEditorURI()
 		if (!uri_) return
 		const uri = uri_

 		// generate search/replace block text
-		const fileContents = await VSReadFile(this._modelService, uri)
-		if (fileContents === null) return
+		const origFileContents = await VSReadFile(uri, this._modelService, this._fileService)
+		if (origFileContents === null) return


-		const searchReplaceUserMessage = ({ originalCode, applyStr }: { originalCode: string, applyStr: string }) => `\
-ORIGINAL_FILE
-${originalCode}
+		// 	// reject all diffZones on this URI, adding to history (there can't possibly be overlap after this)
+		// 	this.removeDiffAreas({ uri, behavior: 'reject', removeCtrlKs: true })

-CHANGE
-${applyStr}
-
-INSTRUCTIONS
-Please output SEARCH/REPLACE blocks to make the change. Return ONLY your suggested SEARCH/REPLACE blocks, without any explanation.
-`
-
-		const endsWithAnyPrefixOf = (str: string, anyPrefix: string) => {
-			// for each prefix
-			for (let i = anyPrefix.length; i >= 0; i--) {
-				const prefix = anyPrefix.slice(0, i)
-				if (str.endsWith(prefix)) return prefix
-			}
-			return null
-		}
-
-		const extractBlocks = (str: string) => {
-
-			const ORIGINAL_ = ORIGINAL + `\n`
-			const DIVIDER_ = '\n' + DIVIDER + `\n`
-			const FINAL_ = '\n' + FINAL
-
-
-			const blocks: ExtractedCodeBlock[] = []
-
-			let i = 0 // search i and beyond (this is done by plain index, not by line number. much simpler this way)
-			while (true) {
-				let origStart = str.indexOf(ORIGINAL_, i)
-				if (origStart === -1) { return blocks }
-				origStart += ORIGINAL_.length
-				i = origStart
-				// wrote <<<< ORIGINAL
-
-				let dividerStart = str.indexOf(DIVIDER_, i)
-				if (dividerStart === -1) { // if didnt find DIVIDER_, either writing originalStr or DIVIDER_ right now
-					const isWritingDIVIDER = endsWithAnyPrefixOf(str, DIVIDER_)
-					blocks.push({
-						orig: str.substring(origStart, str.length - (isWritingDIVIDER?.length ?? 0)),
-						final: '',
-						state: 'writingOriginal'
-					})
-					return blocks
-				}
-				const origStrDone = str.substring(origStart, dividerStart)
-				dividerStart += DIVIDER_.length
-				i = dividerStart
-				// wrote =====
-
-				let finalStart = str.indexOf(FINAL_, i)
-				if (finalStart === -1) { // if didnt find FINAL_, either writing finalStr or FINAL_ right now
-					const isWritingFINAL = endsWithAnyPrefixOf(str, FINAL_)
-					blocks.push({
-						orig: origStrDone,
-						final: str.substring(origStart, str.length - (isWritingFINAL?.length ?? 0)),
-						state: 'writingFinal'
-					})
-					return blocks
-				}
-				const finalStrDone = str.substring(dividerStart, finalStart)
-				finalStart += FINAL_.length
-				i = finalStart
-				// wrote >>>>> FINAL
-
-				blocks.push({
-					orig: origStrDone,
-					final: finalStrDone,
-					state: 'done'
-				})
-			}
-		}
-
-
-		// reject all diffZones on this URI, adding to history (there can't possibly be overlap after this)
-		this.removeDiffAreas({ uri, behavior: 'reject', removeCtrlKs: true })
-
-		const userMessageContent = searchReplaceUserMessage({ originalCode: fileContents, applyStr: applyStr })
+		const userMessageContent = searchReplace_userMessage({ originalCode: origFileContents, applyStr: applyStr })
 		const messages: LLMChatMessage[] = [
-			{ role: 'system', content: searchReplaceSysMessage },
-			{ role: 'user', content: userMessageContent }
+			{ role: 'system', content: searchReplace_systemMessage },
+			{ role: 'user', content: userMessageContent },
 		]
 		let streamRequestIdRef: { current: string | null } = { current: null }

 		const diffareaidOfBlockNum: number[] = []
+		const diffAreaOriginalLines: [number, number][] = []

-		const onText = ({ newText, fullText }: { newText: string, fullText: string }) => {
-			const blocks = extractBlocks(fullText)
+		// TODO replace all these with whatever block we're on initially if already started
+		let latestStreamLocationMutable: StreamLocationMutable | null = null
+		let currStreamingBlockNum = 0
+		let oldBlocks: ExtractedSearchReplaceBlock[] = []

-			// find block.orig in fileContents and return its range in file
-			const findTextInCode = (text: string, fileContents: string) => {
-				const idx = fileContents.indexOf(text)
-				if (idx === -1) return 'Not found' as const
-				const lastIdx = fileContents.lastIndexOf(text)
-				if (lastIdx !== idx) return 'Not unique' as const
-				const startLine = fileContents.substring(0, idx).split('\n').length
-				const numLines = text.split('\n').length
-				const endLine = startLine + numLines - 1
-				return [startLine, endLine]
-			}
+		// find block.orig in fileContents and return its range in file
+		const findTextInCode = (text: string, fileContents: string) => {
+			const idx = fileContents.indexOf(text)
+			if (idx === -1) return 'Not found' as const
+			const lastIdx = fileContents.lastIndexOf(text)
+			if (lastIdx !== idx) return 'Not unique' as const
+			const startLine = fileContents.substring(0, idx).split('\n').length
+			const numLines = text.split('\n').length
+			const endLine = startLine + numLines - 1
+			return [startLine, endLine]
+		}

-			let latestStreamInfoMutable: any = {}
+		let { onFinishEdit } = this._addToHistory(uri)

-			for (let blockNum = 0; blockNum < blocks.length; blockNum += 1) {
-				const block = blocks[blockNum]
-				if (block.state === 'writingOriginal') continue
-
-				const foundInCode = findTextInCode(block.orig, fileContents)
-				if (typeof foundInCode === 'string') {
-					console.log('ERROR!!!!', foundInCode)
-					continue
-				}
-
-				const [startLine, endLine] = foundInCode
-
-				// if should add new diffarea
-				if (blockNum > diffareaidOfBlockNum.length) {
-					const adding: Omit<DiffZone, 'diffareaid'> = {
-						type: 'DiffZone',
-						originalCode: block.orig,
-						startLine,
-						endLine,
-						_URI: uri,
-						_streamState: {
-							isStreaming: true,
-							streamRequestIdRef,
-							line: startLine,
-						},
-						_diffOfId: {}, // added later
-						_removeStylesFns: new Set(),
-					}
-					const diffZone = this._addDiffArea(adding)
-					this._onDidChangeStreaming.fire({ uri, diffareaid: diffZone.diffareaid })
-					this._onDidAddOrDeleteDiffZones.fire({ uri })
-
-					diffareaidOfBlockNum.push(diffZone.diffareaid)
-
-					latestStreamInfoMutable = { line: diffZone.startLine, addedSplitYet: false, col: 1, originalCodeStartLine: 1 }
-				}
+		const revertAndContinueHistory = () => {
+			this._undoHistory(uri)
+			const { onFinishEdit: onFinishEdit_ } = this._addToHistory(uri)
+			onFinishEdit = onFinishEdit_
+		}

+		const onDone = (errorMessage: false | string) => {
+			for (const blockNum in diffareaidOfBlockNum) {
 				const diffareaid = diffareaidOfBlockNum[blockNum]
 				const diffZone = this.diffAreaOfId[diffareaid]
-				if (diffZone.type !== 'DiffZone') continue
+				if (diffZone?.type !== 'DiffZone') continue
+				diffZone._streamState = { isStreaming: false, }
+				this._onDidChangeStreaming.fire({ uri, diffareaid: diffZone.diffareaid })
+			}
+			this._refreshStylesAndDiffsInURI(uri)
+			if (errorMessage) {
+				this._notificationService.info(`Void had an error when running Apply: ${errorMessage}.\nIf this persists, feel free to [report](https://github.com/voideditor/void/issues/new) this error.`)
+				this._metricsService.capture('Error - Apply', { errorMessage })
+				this._undoHistory(uri)
+			}
+			onFinishEdit()
+		}

-				this._writeStreamedDiffZoneLLMText(diffZone, fullText, newText, latestStreamInfoMutable)
-				this._refreshStylesAndDiffsInURI(uri)
+
+		const onNewBlockStart = (blockNum: number, block: ExtractedSearchReplaceBlock): { errorStartingBlock?: undefined } | { errorStartingBlock: string } => {
+			console.log('STARTING BLOCK', JSON.stringify(block, null, 2))
+
+
+			const foundInCode = findTextInCode(block.orig, origFileContents)
+			if (typeof foundInCode === 'string') {
+				console.log('Apply error:', foundInCode, '; trying again.')
+				return { errorStartingBlock: foundInCode }
+			}
+			const [originalStart, originalEnd] = foundInCode
+
+			let lineOffset = 0
+			// compute line offset given multiple changes
+			for (let i = 0; i < blockNum; i += 1) {
+				const [diffAreaOriginalStart, diffAreaOriginalEnd] = diffAreaOriginalLines[i]
+				console.log('ROIGGINAL!!!', diffAreaOriginalStart, diffAreaOriginalEnd)
+				if (diffAreaOriginalStart > originalEnd) continue
+
+				const diffareaid = diffareaidOfBlockNum[i]
+				const diffArea = this.diffAreaOfId[diffareaid]
+
+
+				const numNewLines = diffArea.endLine - diffArea.startLine
+				const numOldLines = diffAreaOriginalEnd - diffAreaOriginalStart
+				console.log('NUM NEW', numNewLines, numOldLines)
+
+				lineOffset += numNewLines - numOldLines
 			}

+			const startLine = originalStart + lineOffset
+			const endLine = originalEnd + lineOffset
+			console.log('adding to', startLine, endLine)
+
+			const adding: Omit<DiffZone, 'diffareaid'> = {
+				type: 'DiffZone',
+				originalCode: block.orig,
+				startLine,
+				endLine,
+				_URI: uri,
+				_streamState: {
+					isStreaming: true,
+					streamRequestIdRef,
+					line: startLine,
+				},
+				_diffOfId: {}, // added later
+				_removeStylesFns: new Set(),
+			}
+			const diffZone = this._addDiffArea(adding)
+			this._onDidChangeStreaming.fire({ uri, diffareaid: diffZone.diffareaid })
+			this._onDidAddOrDeleteDiffZones.fire({ uri })
+
+			diffareaidOfBlockNum.push(diffZone.diffareaid)
+			diffAreaOriginalLines.push([originalStart, originalEnd])
+
+			latestStreamLocationMutable = { line: diffZone.startLine, addedSplitYet: false, col: 1, originalCodeStartLine: 1 }
+			return { errorStartingBlock: undefined }
 		}




-		// TODO turn this into a service and provide it
-		streamRequestIdRef.current = this._llmMessageService.sendLLMMessage({
-			messagesType: 'chatMessages',
-			useProviderFor: 'FastApply',
-			logging: { loggingName: `generateSearchAndReplace` },
-			messages,
-			onText: ({ newText, fullText }) => { onText({ newText, fullText }) },
-			onFinalMessage: ({ fullText }) => { },
-			onError: (e) => { console.log('ERROR', e) },

-		})
+
+		let shouldSendAnotherMessage = true
+		let nMessagesSent = 0
+		// this generates >>>>>>> ORIGINAL <<<<<<< REPLACE blocks and and simultaneously applies it
+		while (shouldSendAnotherMessage) {
+			shouldSendAnotherMessage = false
+			nMessagesSent += 1
+
+			streamRequestIdRef.current = this._llmMessageService.sendLLMMessage({
+				messagesType: 'chatMessages',
+				useProviderFor: 'Apply',
+				logging: { loggingName: `generateSearchAndReplace` },
+				messages,
+				onText: ({ fullText }) => {
+					const blocks = extractSearchReplaceBlocks(fullText)
+
+					for (let blockNum = currStreamingBlockNum; blockNum < blocks.length; blockNum += 1) {
+						const block = blocks[blockNum]
+
+						if (block.state === 'done')
+							currStreamingBlockNum = blockNum
+
+						if (block.state === 'writingOriginal') // must be done writing original
+							continue
+
+						// if this is the first time we're seeing this block, add it as a diffarea
+						if (!(blockNum in diffareaidOfBlockNum)) {
+							console.log('FULLTEXT!!!!!\n', fullText)
+							const { errorStartingBlock } = onNewBlockStart(blockNum, block)
+
+							if (errorStartingBlock) {
+								console.log('ERROR STARTING BLOCK SPOT!!!!!', errorStartingBlock)
+
+								const errMsgForLLM = errorStartingBlock === 'Not found' ?
+									'I interrupted you because the latest ORIGINAL code could not be found in the file. Please output all SEARCH/REPLACE blocks again, making sure the code in ORIGINAL is identical to a code snippet in the file.'
+									: errorStartingBlock === 'Not unique' ?
+										'I interrupted you because the latest ORIGINAL code shows up multiple times in the file. Please output all SEARCH/REPLACE blocks again, making sure the code in each ORIGINAL section is unique in the file.'
+										: ''
+
+								messages.push(
+									{ role: 'assistant', content: fullText }, // latest output
+									{ role: 'user', content: errMsgForLLM } // user explanation of what's wrong
+								)
+								if (streamRequestIdRef.current) this._llmMessageService.abort(streamRequestIdRef.current)
+
+								shouldSendAnotherMessage = true
+								revertAndContinueHistory()
+								return
+							}
+
+						}
+						const deltaFinalText = block.final.substring((oldBlocks[blockNum]?.final ?? '').length, Infinity)
+						oldBlocks = blocks
+
+						// write new text to diffarea
+						const diffareaid = diffareaidOfBlockNum[blockNum]
+						const diffZone = this.diffAreaOfId[diffareaid]
+						if (diffZone?.type !== 'DiffZone') continue
+
+
+						if (!latestStreamLocationMutable) continue
+						this._writeStreamedDiffZoneLLMText(diffZone, block.final, deltaFinalText, latestStreamLocationMutable)
+					} // end for
+
+					this._refreshStylesAndDiffsInURI(uri)
+				},
+				onFinalMessage: async ({ fullText }) => {
+					console.log('final message!!', fullText)
+
+					// 1. wait 500ms and fix lint errors - call lint error workflow
+					// (update react state to say "Fixing errors")
+					const blocks = extractSearchReplaceBlocks(fullText)
+
+					if (blocks.length === 0) {
+						this._notificationService.info(`Void: When running Apply, your model didn't output any changes we recognized. You might need to use a smarter model for Apply.`)
+					}
+
+					for (let blockNum = 0; blockNum < blocks.length; blockNum += 1) {
+						const block = blocks[blockNum]
+						const diffareaid = diffareaidOfBlockNum[blockNum]
+						const diffZone = this.diffAreaOfId[diffareaid]
+						if (diffZone?.type !== 'DiffZone') continue
+
+						this._writeText(uri, block.final,
+							{ startLineNumber: diffZone.startLine, startColumn: 1, endLineNumber: diffZone.endLine, endColumn: Number.MAX_SAFE_INTEGER }, // 1-indexed
+							{ shouldRealignDiffAreas: true }
+						)
+					}
+					onDone(false)
+				},
+				onError: (e) => {
+					console.log('ERROR in SearchReplace:', e.message)
+					onDone(e.message)
+				},
+
+			})
+		}
+

 	}

@ -1492,9 +1492,9 @@ Please output SEARCH/REPLACE blocks to make the change. Return ONLY your suggest
 		let messages: LLMChatMessage[]

 		if (from === 'ClickApply') {
-			const userContent = fastApply_rewritewholething_userMessage({ originalCode, applyStr: opts.applyStr, uri })
+			const userContent = rewriteCode_userMessage({ originalCode, applyStr: opts.applyStr, uri })
 			messages = [
-				{ role: 'system', content: fastApply_rewritewholething_systemMessage, },
+				{ role: 'system', content: rewriteCode_systemMessage, },
 				{ role: 'user', content: userContent, }
 			]
 		}
@ -1550,7 +1550,7 @@ Please output SEARCH/REPLACE blocks to make the change. Return ONLY your suggest
 			throw 1
 		}

-		const latestStreamInfoMutable = { line: diffZone.startLine, addedSplitYet: false, col: 1, originalCodeStartLine: 1 }
+		const latestStreamInfoMutable: StreamLocationMutable = { line: diffZone.startLine, addedSplitYet: false, col: 1, originalCodeStartLine: 1 }

 		// state used in onText:
 		let fullText = ''
@ -1558,25 +1558,25 @@ Please output SEARCH/REPLACE blocks to make the change. Return ONLY your suggest

 		streamRequestIdRef.current = this._llmMessageService.sendLLMMessage({
 			messagesType: 'chatMessages',
-			useProviderFor: opts.from === 'ClickApply' ? 'FastApply' : 'Ctrl+K',
+			useProviderFor: opts.from === 'ClickApply' ? 'Apply' : 'Ctrl+K',
 			logging: { loggingName: `startApplying - ${from}` },
 			messages,
 			onText: ({ newText: newText_ }) => {

 				const newText = prevIgnoredSuffix + newText_ // add the previously ignored suffix because it's no longer the suffix!
-				fullText += prevIgnoredSuffix + newText
+				fullText += prevIgnoredSuffix + newText // full text, including ```, etc

-				const [text, deltaText, ignoredSuffix] = extractText(fullText, newText.length)
-				this._writeStreamedDiffZoneLLMText(diffZone, text, deltaText, latestStreamInfoMutable)
+				const [croppedText, deltaCroppedText, croppedSuffix] = extractText(fullText, newText.length)
+				this._writeStreamedDiffZoneLLMText(diffZone, croppedText, deltaCroppedText, latestStreamInfoMutable)
 				this._refreshStylesAndDiffsInURI(uri)

-				prevIgnoredSuffix = ignoredSuffix
+				prevIgnoredSuffix = croppedSuffix
 			},
 			onFinalMessage: ({ fullText }) => {
 				// console.log('DONE! FULL TEXT\n', extractText(fullText), diffZone.startLine, diffZone.endLine)
 				// at the end, re-write whole thing to make sure no sync errors
-				const [text, _] = extractText(fullText, 0)
-				this._writeText(uri, text,
+				const [croppedText, _1, _2] = extractText(fullText, 0)
+				this._writeText(uri, croppedText,
 					{ startLineNumber: diffZone.startLine, startColumn: 1, endLineNumber: diffZone.endLine, endColumn: Number.MAX_SAFE_INTEGER }, // 1-indexed
 					{ shouldRealignDiffAreas: true }
 				)
@ -1894,7 +1894,7 @@ Please output SEARCH/REPLACE blocks to make the change. Return ONLY your suggest

 }

-registerSingleton(IInlineDiffsService, InlineDiffsService, InstantiationType.Eager);
+registerSingleton(IEditCodeService, EditCodeService, InstantiationType.Eager);

 const acceptBg = '#1a7431'
 const acceptAllBg = '#1e8538'
@ -2098,17 +2098,3 @@ class AcceptAllRejectAllWidget extends Widget implements IOverlayWidget {



-// registerAction2(class extends Action2 {
-// 	constructor() {
-// 		super({
-// 			id: 'void.testDiff',
-// 			title: localize2('voidTestDiff', 'Void Test Diff'),
-// 			f1: true,
-// 		});
-// 	}
-// 	async run(accessor: ServicesAccessor): Promise<void> {
-// 		const inlineDiffsService = accessor.get(IInlineDiffsService)
-// 		// inlineDiffsService.testDiffs()
-
-// 	}
-// })
--- a/src/vs/workbench/contrib/void/browser/helpers/detectLanguage.ts
+++ b/src/vs/workbench/contrib/void/browser/helpers/detectLanguage.ts
@ -1,3 +1,7 @@
+/*--------------------------------------------------------------------------------------
+ *  Copyright 2025 Glass Devtools, Inc. All rights reserved.
+ *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
+ *--------------------------------------------------------------------------------------*/

 // eg "bash" -> "shell"
 export const nameToVscodeLanguage: { [key: string]: string } = {
--- a/src/vs/workbench/contrib/void/browser/helpers/extractCodeFromResult.ts
+++ b/src/vs/workbench/contrib/void/browser/helpers/extractCodeFromResult.ts
@ -3,6 +3,8 @@
 *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
 *--------------------------------------------------------------------------------------*/

+import { DIVIDER, FINAL, ORIGINAL } from '../prompt/prompts.js'
+
 class SurroundingsRemover {
 	readonly originalS: string
 	i: number
@ -175,3 +177,77 @@ export const extractCodeFromFIM = ({ text, recentlyAddedTextLen, midTag, }: { te

 }

+
+
+
+export type ExtractedSearchReplaceBlock = {
+	state: 'writingOriginal' | 'writingFinal' | 'done',
+	orig: string,
+	final: string,
+}
+
+
+const endsWithAnyPrefixOf = (str: string, anyPrefix: string) => {
+	// for each prefix
+	for (let i = anyPrefix.length; i >= 0; i--) {
+		const prefix = anyPrefix.slice(0, i)
+		if (str.endsWith(prefix)) return prefix
+	}
+	return null
+}
+
+// guarantees if you keep adding text, array length will strictly grow and state will progress without going back
+export const extractSearchReplaceBlocks = (str: string) => {
+
+	const ORIGINAL_ = ORIGINAL + `\n`
+	const DIVIDER_ = '\n' + DIVIDER + `\n`
+	const FINAL_ = '\n' + FINAL
+
+
+	const blocks: ExtractedSearchReplaceBlock[] = []
+
+	let i = 0 // search i and beyond (this is done by plain index, not by line number. much simpler this way)
+	while (true) {
+		let origStart = str.indexOf(ORIGINAL_, i)
+		if (origStart === -1) { return blocks }
+		origStart += ORIGINAL_.length
+		i = origStart
+		// wrote <<<< ORIGINAL
+
+		let dividerStart = str.indexOf(DIVIDER_, i)
+		if (dividerStart === -1) { // if didnt find DIVIDER_, either writing originalStr or DIVIDER_ right now
+			const isWritingDIVIDER = endsWithAnyPrefixOf(str, DIVIDER_)
+			blocks.push({
+				orig: str.substring(origStart, str.length - (isWritingDIVIDER?.length ?? 0)),
+				final: '',
+				state: 'writingOriginal'
+			})
+			return blocks
+		}
+		const origStrDone = str.substring(origStart, dividerStart)
+		dividerStart += DIVIDER_.length
+		i = dividerStart
+		// wrote =====
+
+		let finalStart = str.indexOf(FINAL_, i)
+		if (finalStart === -1) { // if didnt find FINAL_, either writing finalStr or FINAL_ right now
+			const isWritingFINAL = endsWithAnyPrefixOf(str, FINAL_)
+			blocks.push({
+				orig: origStrDone,
+				final: str.substring(dividerStart, str.length - (isWritingFINAL?.length ?? 0)),
+				state: 'writingFinal'
+			})
+			return blocks
+		}
+		const finalStrDone = str.substring(dividerStart, finalStart)
+		finalStart += FINAL_.length
+		i = finalStart
+		// wrote >>>>> FINAL
+
+		blocks.push({
+			orig: origStrDone,
+			final: finalStrDone,
+			state: 'done'
+		})
+	}
+}
--- a/src/vs/workbench/contrib/void/browser/helpers/readFile.ts
+++ b/src/vs/workbench/contrib/void/browser/helpers/readFile.ts
@ -1,17 +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 { URI } from '../../../../../base/common/uri'
 import { EndOfLinePreference } from '../../../../../editor/common/model'
 import { IModelService } from '../../../../../editor/common/services/model.js'
 import { IFileService } from '../../../../../platform/files/common/files'

-// read files from VSCode. preferred (but appears to only work if the model of this URI already exists. If it doesn't use the other function.)
-export const VSReadFile = async (modelService: IModelService, uri: URI): Promise<string | null> => {
-	const model = modelService.getModel(uri)
-	if (!model) return null
-	return model.getValue(EndOfLinePreference.LF)
+
+// attempts to read URI of currently opened model, then of raw file
+export const VSReadFile = async (uri: URI, modelService: IModelService, fileService: IFileService) => {
+
+	const modelResult = await _VSReadModel(modelService, uri)
+	if (modelResult) return modelResult
+
+	const fileResult = await _VSReadFileRaw(fileService, uri)
+	if (fileResult) return fileResult
+
+	return ''
+
 }

-export const VSReadFileRaw = async (fileService: IFileService, uri: URI) => {
-	const res = await fileService.readFile(uri)
-	const str = res.value.toString()
-	return str
+// read files from VSCode. preferred (but appears to only work if the model of this URI already exists. If it doesn't use the other function.)
+const _VSReadModel = async (modelService: IModelService, uri: URI): Promise<string | null> => {
+
+	// attempt to read saved model (doesn't work if application was reloaded...)
+	const model = modelService.getModel(uri)
+	if (model) {
+		return model.getValue(EndOfLinePreference.LF)
+	}
+
+	// backup logic - look at all opened models and check if they have the same `fsPath`
+	const models = modelService.getModels()
+	for (const model of models) {
+		if (model.uri.fsPath === uri.fsPath)
+			return model.getValue(EndOfLinePreference.LF);
+	}
+
+	return null
+}
+
+const _VSReadFileRaw = async (fileService: IFileService, uri: URI) => {
+	try {
+		const res = await fileService.readFile(uri)
+		const str = res.value.toString()
+		return str
+	} catch (e) {
+		return null
+	}
 }
--- a/src/vs/workbench/contrib/void/browser/helpers/systemInfo.ts
+++ b/src/vs/workbench/contrib/void/browser/helpers/systemInfo.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.
+ *--------------------------------------------------------------------------------------*/
+
+import { isLinux, isMacintosh, isWindows } from '../../../../../base/common/platform.js';
+
+// import { OS, OperatingSystem } from '../../../../../base/common/platform.js';
+// alternatively could use ^ and OS === OperatingSystem.Windows ? ...
+
+
+
+export const os = isWindows ? 'windows' : isMacintosh ? 'mac' : isLinux ? 'linux' : null
+
--- a/src/vs/workbench/contrib/void/browser/prompt/prompts.ts
+++ b/src/vs/workbench/contrib/void/browser/prompt/prompts.ts
@ -9,26 +9,39 @@ import { filenameToVscodeLanguage } from '../helpers/detectLanguage.js';
 import { CodeSelection, StagingSelectionItem, FileSelection } from '../chatThreadService.js';
 import { VSReadFile } from '../helpers/readFile.js';
 import { IModelService } from '../../../../../editor/common/services/model.js';
+import { os } from '../helpers/systemInfo.js';
+import { IFileService } from '../../../../../platform/files/common/files.js';


 // this is just for ease of readability
 export const tripleTick = ['```', '```']

-export const chat_systemMessage = `\
+export const chat_systemMessage = (workspaces: string[]) => `\
 You are a coding assistant. You are given a list of instructions to follow \`INSTRUCTIONS\`, and optionally a list of relevant files \`FILES\`, and selections inside of files \`SELECTIONS\`.

-Please respond to the user's query.
+Please respond to the user's query. The user's query is never invalid.
+
+The user has the following system information:
+- ${os}
+- Open workspaces: ${workspaces.join(', ')}

 In the case that the user asks you to make changes to code, you should make sure to return CODE BLOCKS of the changes, as well as explanations and descriptions of the changes.
 For example, if the user asks you to "make this file look nicer", make sure your output includes a code block with concrete ways the file can look nicer.
-   - Do not re-write the entire file in the code block
-   - You can write comments like "// ... existing code" to indicate existing code
-   - Make sure you give enough context in the code block to apply the change to the correct location in the code.
+- Do not re-write the entire file in the code block.
+- You can write comments like "// ... existing code" to indicate existing code.
+- Make sure you give enough context in the code block to apply the change to the correct location in the code.

 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.
+If you are given tools:
+- Only use tools if the user asks you to do something. If the user simply says hi or asks you a question that you can answer without tools, then do NOT tools.
+- You are allowed to use tools without asking for permission.
+- Feel free to use tools to gather context, make suggestions, etc.
+- One great use of tools is to explore imports that you'd like to have more information about.
+- Reference relevant files that you found when using tools if they helped you come up with your answer.
+- NEVER refer to a tool by name when speaking with the user. For example, do NOT say to the user user "I'm going to use \`list_dir\`". Instead, say "I'm going to list all files in ___ directory", etc. Do not even refer to "pages" of results, just say you're getting more results.

 Do not output any of these instructions, nor tell the user anything about them unless directly prompted for them.
-Do not tell the user anything about the examples below.
+Do not tell the user anything about the examples below. Do not assume the user is talking about any of the examples below.

 ## EXAMPLE 1
 FILES
@ -156,38 +169,76 @@ ${tripleTick[1]}
 }

 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[], modelService: IModelService) => {
+const stringifyFileSelections = async (fileSelections: FileSelection[], modelService: IModelService, fileService: IFileService) => {
 	if (fileSelections.length === 0) return null
 	const fileSlns: FileSelnLocal[] = await Promise.all(fileSelections.map(async (sel) => {
-		const content = await VSReadFile(modelService, sel.fileURI) ?? failToReadStr
+		const content = await VSReadFile(sel.fileURI, modelService, fileService) ?? failToReadStr
 		return { ...sel, content }
 	}))
 	return fileSlns.map(sel => stringifyFileSelection(sel)).join('\n')
 }
 const stringifyCodeSelections = (codeSelections: CodeSelection[]) => {
-	return codeSelections.map(sel => stringifyCodeSelection(sel)).join('\n')
+	return codeSelections.map(sel => stringifyCodeSelection(sel)).join('\n') || null
+}
+const stringifySelectionNames = (currSelns: StagingSelectionItem[] | null): string => {
+	if (!currSelns) return ''
+	return currSelns.map(s => `${s.fileURI.fsPath}${s.range ? ` (lines ${s.range.startLineNumber}:${s.range.endLineNumber})` : ''}`).join('\n')
 }

+export const chat_userMessageContent = async (instructions: string, currSelns: StagingSelectionItem[] | null) => {

-
-export const chat_userMessage = async (instructions: string, selections: StagingSelectionItem[] | null, modelService: IModelService) => {
-	const fileSelections = selections?.filter(s => s.type === 'File') as FileSelection[]
-	const codeSelections = selections?.filter(s => s.type === 'Selection') as CodeSelection[]
-
-	const filesStr = await stringifyFileSelections(fileSelections, modelService)
-	const codeStr = stringifyCodeSelections(codeSelections)
+	const selnsStr = stringifySelectionNames(currSelns)

 	let str = ''
-	if (filesStr) str += `FILES\n${filesStr}\n`
-	if (codeStr) str += `SELECTIONS\n${codeStr}\n`
-	str += `INSTRUCTIONS\n${instructions}`
+	if (selnsStr) { str += `SELECTIONS\n${selnsStr}\n` }
+	str += `\nINSTRUCTIONS\n${instructions}`
 	return str;
 };

+export const chat_selectionsString = async (prevSelns: StagingSelectionItem[] | null, currSelns: StagingSelectionItem[] | null, modelService: IModelService, fileService: IFileService) => {
+
+	// ADD IN FILES AT TOP
+	const allSelections = [...currSelns || [], ...prevSelns || []]
+
+	if (allSelections.length === 0) return null
+
+	const codeSelections: CodeSelection[] = []
+	const fileSelections: FileSelection[] = []
+	const filesURIs = new Set<string>()
+
+	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, modelService, fileService)
+	const selnsStr = stringifyCodeSelections(codeSelections)


+	if (filesStr || selnsStr) return `\
+ALL FILE CONTENTS
+${filesStr}
+${selnsStr}`

-export const fastApply_rewritewholething_systemMessage = `\
+	return null
+}
+
+export const chat_userMessageContentWithAllFilesToo = (userMessage: string, selectionsString: string | null) => {
+	if (userMessage) return `${userMessage}${selectionsString ? `\n${selectionsString}` : ''}`
+	else return userMessage
+}
+
+
+export const rewriteCode_systemMessage = `\
 You are a coding assistant that re-writes an entire file to make a change. You are given the original file \`ORIGINAL_FILE\` and a change \`CHANGE\`.

 Directions:
@ -199,7 +250,7 @@ Directions:



-export const fastApply_rewritewholething_userMessage = ({ originalCode, applyStr, uri }: { originalCode: string, applyStr: string, uri: URI }) => {
+export const rewriteCode_userMessage = ({ originalCode, applyStr, uri }: { originalCode: string, applyStr: string, uri: URI }) => {

 	const language = filenameToVscodeLanguage(uri.fsPath) ?? ''

@ -224,7 +275,138 @@ Please finish writing the new file by applying the change to the original file.



+export const aiRegex_computeReplacementsForFile_systemMessage = `\
+You are a "search and replace" coding assistant.

+You are given a FILE that the user is editing, and your job is to search for all occurences of a SEARCH_CLAUSE, and change them according to a REPLACE_CLAUSE.
+
+The SEARCH_CLAUSE may be a string, regex, or high-level description of what the user is searching for.
+
+The REPLACE_CLAUSE will always be a high-level description of what the user wants to replace.
+
+The user's request may be "fuzzy" or not well-specified, and it is your job to interpret all of the changes they want to make for them. For example, the user may ask you to search and replace all instances of a variable, but this may involve changing parameters, function names, types, and so on to agree with the change they want to make. Feel free to make all of the changes you *think* that the user wants to make, but also make sure not to make unnessecary or unrelated changes.
+
+## Instructions
+
+1. If you do not want to make any changes, you should respond with the word "no".
+
+2. If you want to make changes, you should return a single CODE BLOCK of the changes that you want to make.
+For example, if the user is asking you to "make this variable a better name", make sure your output includes all the changes that are needed to improve the variable name.
+- Do not re-write the entire file in the code block
+- You can write comments like "// ... existing code" to indicate existing code
+- Make sure you give enough context in the code block to apply the changes to the correct location in the code`
+
+
+export const aiRegex_computeReplacementsForFile_userMessage = async ({ searchClause, replaceClause, fileURI, modelService, fileService }: { searchClause: string, replaceClause: string, fileURI: URI, modelService: IModelService, fileService: IFileService }) => {
+
+	// we may want to do this in batches
+	const fileSelection: FileSelection = { type: 'File', fileURI, selectionStr: null, range: null }
+
+	const file = await stringifyFileSelections([fileSelection], modelService, fileService)
+
+	return `\
+## FILE
+${file}
+
+## SEARCH_CLAUSE
+Here is what the user is searching for:
+${searchClause}
+
+## REPLACE_CLAUSE
+Here is what the user wants to replace it with:
+${replaceClause}
+
+## INSTRUCTIONS
+Please return the changes you want to make to the file in a codeblock, or return "no" if you do not want to make changes.`
+}
+
+
+
+
+// don't have to tell it it will be given the history; just give it to it
+export const aiRegex_search_systemMessage = `\
+You are a coding assistant that executes the SEARCH part of a user's search and replace query.
+
+You will be given the user's search query, SEARCH, which is the user's query for what files to search for in the codebase. You may also be given the user's REPLACE query for additional context.
+
+Output
+- Regex query
+- Files to Include (optional)
+- Files to Exclude? (optional)
+
+`
+
+
+
+export const ORIGINAL = `<<<<<<< ORIGINAL`
+export const DIVIDER = `=======`
+export const FINAL = `>>>>>>> UPDATED`
+
+export const searchReplace_systemMessage = `\
+You are a coding assistant that generates SEARCH/REPLACE code blocks that will be used to edit a file.
+
+A SEARCH/REPLACE block describes the code before and after a change. Here is the format:
+${tripleTick[0]}
+${ORIGINAL}
+// ... original code goes here
+${DIVIDER}
+// ... final code goes here
+${FINAL}
+${tripleTick[1]}
+
+You will be given the original file \`ORIGINAL_FILE\` and a description of a change \`CHANGE\` to make.
+Output SEARCH/REPLACE blocks to edit the file according to the desired change. You may output multiple SEARCH/REPLACE blocks.
+
+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 of code in the original file.
+3. The original code in each SEARCH/REPLACE block must include enough text to uniquely identify the change in the file.
+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 "final" code is complete and will not result in syntax/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.
+
+## EXAMPLE 1
+ORIGINAL_FILE
+${tripleTick[0]}
+let w = 5
+let x = 6
+let y = 7
+let z = 8
+${tripleTick[1]}
+
+CHANGE
+Make x equal to 6.5, not 6.
+${tripleTick[0]}
+// ... existing code
+let x = 6.5
+// ... existing code
+${tripleTick[1]}
+
+
+## ACCEPTED OUTPUT
+${tripleTick[0]}
+${ORIGINAL}
+let x = 6
+${DIVIDER}
+let x = 6.5
+${FINAL}
+${tripleTick[1]}
+`
+
+export const searchReplace_userMessage = ({ originalCode, applyStr }: { originalCode: string, applyStr: string }) => `\
+ORIGINAL_FILE
+${originalCode}
+
+CHANGE
+${applyStr}
+
+INSTRUCTIONS
+Please output SEARCH/REPLACE blocks to make the change. Return ONLY your suggested SEARCH/REPLACE blocks, without any explanation.
+`



--- a/src/vs/workbench/contrib/void/browser/quickEditActions.ts
+++ b/src/vs/workbench/contrib/void/browser/quickEditActions.ts
@ -8,7 +8,7 @@ import { Action2, registerAction2 } from '../../../../platform/actions/common/ac
 import { ServicesAccessor } from '../../../../platform/instantiation/common/instantiation.js';
 import { KeybindingWeight } from '../../../../platform/keybinding/common/keybindingsRegistry.js';
 import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.js';
-import { IInlineDiffsService } from './inlineDiffsService.js';
+import { IEditCodeService } from './editCodeService.js';
 import { roundRangeToLines } from './sidebarActions.js';
 import { VOID_CTRL_K_ACTION_ID } from './actionIDs.js';
 import { localize2 } from '../../../../nls.js';
@ -63,7 +63,7 @@ registerAction2(class extends Action2 {

 		const { startLineNumber: startLine, endLineNumber: endLine } = selection

-		const inlineDiffsService = accessor.get(IInlineDiffsService)
-		inlineDiffsService.addCtrlKZone({ startLine, endLine, editor })
+		const editCodeService = accessor.get(IEditCodeService)
+		editCodeService.addCtrlKZone({ startLine, endLine, editor })
 	}
 });
--- a/src/vs/workbench/contrib/void/browser/react/src/markdown/ChatMarkdownRender.tsx
+++ b/src/vs/workbench/contrib/void/browser/react/src/markdown/ChatMarkdownRender.tsx
@ -7,7 +7,7 @@ import React, { JSX, useCallback, useEffect, useState } from 'react'
 import { marked, MarkedToken, Token } from 'marked'
 import { BlockCode } from './BlockCode.js'
 import { useAccessor, useChatThreadsState, useChatThreadsStreamState } from '../util/services.js'
-import { ChatMessageLocation, } from '../../../searchAndReplaceService.js'
+import { ChatMessageLocation, } from '../../../aiRegexService.js'
 import { nameToVscodeLanguage } from '../../../helpers/detectLanguage.js'


@ -21,7 +21,7 @@ const COPY_FEEDBACK_TIMEOUT = 1000 // amount of time to say 'Copied!'



-type ApplyBoxLocation = ChatMessageLocation & { tokenIdx: number }
+type ApplyBoxLocation = ChatMessageLocation & { tokenIdx: string }

 const getApplyBoxId = ({ threadId, messageIdx, tokenIdx }: ApplyBoxLocation) => {
 	return `${threadId}-${messageIdx}-${tokenIdx}`
@ -29,11 +29,11 @@ const getApplyBoxId = ({ threadId, messageIdx, tokenIdx }: ApplyBoxLocation) =>



-const ApplyButtonsOnHover = ({ applyStr, applyBoxId }: { applyStr: string, applyBoxId: string }) => {
+const ApplyButtonsOnHover = ({ applyStr }: { applyStr: string }) => {
 	const accessor = useAccessor()

 	const [copyButtonState, setCopyButtonState] = useState(CopyButtonState.Copy)
-	const inlineDiffService = accessor.get('IInlineDiffsService')
+	const editCodeService = accessor.get('IEditCodeService')
 	const clipboardService = accessor.get('IClipboardService')
 	const metricsService = accessor.get('IMetricsService')

@ -56,13 +56,13 @@ const ApplyButtonsOnHover = ({ applyStr, applyBoxId }: { applyStr: string, apply

 	const onApply = useCallback(() => {

-		inlineDiffService.startApplying({
+		editCodeService.startApplying({
 			from: 'ClickApply',
 			type: 'searchReplace',
 			applyStr,
 		})
 		metricsService.capture('Apply Code', { length: applyStr.length }) // capture the length only
-	}, [metricsService, inlineDiffService, applyStr])
+	}, [metricsService, editCodeService, applyStr])

 	const isSingleLine = !applyStr.includes('\n')

@ -97,12 +97,11 @@ export const CodeSpan = ({ children, className }: { children: React.ReactNode, c
 	</code>
 }

-const RenderToken = ({ token, nested = false, noSpace = false, chatMessageLocation: chatLocation, tokenIdx }: { token: Token | string, nested?: boolean, noSpace?: boolean, chatMessageLocation?: ChatMessageLocation, tokenIdx: number }): JSX.Element => {
+const RenderToken = ({ token, nested = false, noSpace = false, chatMessageLocation, tokenIdx }: { token: Token | string, nested?: boolean, noSpace?: boolean, chatMessageLocation?: ChatMessageLocation, tokenIdx: string }): JSX.Element => {


 	// deal with built-in tokens first (assume marked token)
 	const t = token as MarkedToken
-	console.log(t.raw)

 	if (t.type === "space") {
 		return <span>{t.raw}</span>
@ -111,16 +110,17 @@ const RenderToken = ({ token, nested = false, noSpace = false, chatMessageLocati
 	if (t.type === "code") {
 		const isCodeblockClosed = t.raw?.startsWith('```') && t.raw?.endsWith('```');

-		const applyBoxId = getApplyBoxId({
-			threadId: chatLocation!.threadId,
-			messageIdx: chatLocation!.messageIdx,
+		// this should never be
+		const applyBoxId = chatMessageLocation ? getApplyBoxId({
+			threadId: chatMessageLocation.threadId,
+			messageIdx: chatMessageLocation.messageIdx,
 			tokenIdx: tokenIdx,
-		})
+		}) : null

 		return <BlockCode
 			initValue={t.text}
 			language={t.lang === undefined ? undefined : nameToVscodeLanguage[t.lang]}
-			buttonsOnHover={<ApplyButtonsOnHover applyStr={t.text} applyBoxId={applyBoxId} />}
+			buttonsOnHover={applyBoxId && <ApplyButtonsOnHover applyStr={t.text} />}
 		/>
 	}

@ -195,7 +195,7 @@ const RenderToken = ({ token, nested = false, noSpace = false, chatMessageLocati
 							<input type="checkbox" checked={item.checked} readOnly className="mr-2 form-checkbox" />
 						)}
 						<span className="ml-1">
-							<ChatMarkdownRender string={item.text} nested={true} />
+							<ChatMarkdownRender chatMessageLocation={chatMessageLocation} string={item.text} nested={true} />
 						</span>
 					</li>
 				))}
@ -206,7 +206,7 @@ const RenderToken = ({ token, nested = false, noSpace = false, chatMessageLocati
 	if (t.type === "paragraph") {
 		const contents = <>
 			{t.tokens.map((token, index) => (
-				<RenderToken key={index} token={token} tokenIdx={index} /> // assign a unique tokenId to nested components
+				<RenderToken key={index} token={token} tokenIdx={`${tokenIdx ? `${tokenIdx}-` : ''}${index}`} /> // assign a unique tokenId to nested components
 			))}
 		</>
 		if (nested) return contents
@ -294,7 +294,7 @@ export const ChatMarkdownRender = ({ string, nested = false, noSpace, chatMessag
 	return (
 		<>
 			{tokens.map((token, index) => (
-				<RenderToken key={index} token={token} nested={nested} noSpace={noSpace} chatMessageLocation={chatMessageLocation} tokenIdx={index} />
+				<RenderToken key={index} token={token} nested={nested} noSpace={noSpace} chatMessageLocation={chatMessageLocation} tokenIdx={index + ''} />
 			))}
 		</>
 	)
--- a/src/vs/workbench/contrib/void/browser/react/src/quick-edit-tsx/QuickEditChat.tsx
+++ b/src/vs/workbench/contrib/void/browser/react/src/quick-edit-tsx/QuickEditChat.tsx
@ -24,7 +24,7 @@ export const QuickEditChat = ({
 }: QuickEditPropsType) => {

 	const accessor = useAccessor()
-	const inlineDiffsService = accessor.get('IInlineDiffsService')
+	const editCodeService = accessor.get('IEditCodeService')
 	const sizerRef = useRef<HTMLDivElement | null>(null)
 	const textAreaRef = useRef<HTMLTextAreaElement | null>(null)
 	const textAreaFnsRef = useRef<TextAreaFns | null>(null)
@ -57,26 +57,26 @@ export const QuickEditChat = ({
 		if (currStreamingDiffZoneRef.current !== null) return
 		textAreaFnsRef.current?.disable()

-		const id = inlineDiffsService.startApplying({
+		const id = editCodeService.startApplying({
 			from: 'QuickEdit',
 			type:'rewrite',
 			diffareaid: diffareaid,
 		})
 		setCurrentlyStreamingDiffZone(id ?? null)
-	}, [currStreamingDiffZoneRef, setCurrentlyStreamingDiffZone, isDisabled, inlineDiffsService, diffareaid])
+	}, [currStreamingDiffZoneRef, setCurrentlyStreamingDiffZone, isDisabled, editCodeService, diffareaid])

 	const onInterrupt = useCallback(() => {
 		if (currStreamingDiffZoneRef.current === null) return
-		inlineDiffsService.interruptStreaming(currStreamingDiffZoneRef.current)
+		editCodeService.interruptStreaming(currStreamingDiffZoneRef.current)
 		setCurrentlyStreamingDiffZone(null)
 		textAreaFnsRef.current?.enable()
-	}, [currStreamingDiffZoneRef, setCurrentlyStreamingDiffZone, inlineDiffsService])
+	}, [currStreamingDiffZoneRef, setCurrentlyStreamingDiffZone, editCodeService])


 	const onX = useCallback(() => {
 		onInterrupt()
-		inlineDiffsService.removeCtrlKZone({ diffareaid })
-	}, [inlineDiffsService, diffareaid])
+		editCodeService.removeCtrlKZone({ diffareaid })
+	}, [editCodeService, diffareaid])

 	useScrollbarStyles(sizerRef)

--- a/src/vs/workbench/contrib/void/browser/react/src/sidebar-tsx/SidebarChat.tsx
+++ b/src/vs/workbench/contrib/void/browser/react/src/sidebar-tsx/SidebarChat.tsx
@ -7,7 +7,7 @@ import React, { ButtonHTMLAttributes, FormEvent, FormHTMLAttributes, Fragment, K


 import { useAccessor, useSidebarState, useChatThreadsState, useChatThreadsStreamState, useUriState, useSettingsState } from '../util/services.js';
-import { ChatMessage, StagingInfo, StagingSelectionItem } from '../../../chatThreadService.js';
+import { ChatMessage, StagingSelectionItem } from '../../../chatThreadService.js';

 import { BlockCode } from '../markdown/BlockCode.js';
 import { ChatMarkdownRender } from '../markdown/ChatMarkdownRender.js';
@ -24,7 +24,7 @@ import { VOID_OPEN_SETTINGS_ACTION_ID } from '../../../voidSettingsPane.js';
 import { Pencil, X } from 'lucide-react';
 import { FeatureName, isFeatureNameDisabled } from '../../../../../../../workbench/contrib/void/common/voidSettingsTypes.js';
 import { WarningBox } from '../void-settings-tsx/WarningBox.js';
-import { ChatMessageLocation } from '../../../searchAndReplaceService.js';
+import { ChatMessageLocation } from '../../../aiRegexService.js';



@ -156,8 +156,8 @@ interface VoidChatAreaProps {
 	showSelections?: boolean;
 	showProspectiveSelections?: boolean;

-	staging?: StagingInfo
-	setStaging?: (s: StagingInfo) => void
+	selections?: StagingSelectionItem[]
+	setSelections?: (s: StagingSelectionItem[]) => void
 	// selections?: any[];
 	// onSelectionsChange?: (selections: any[]) => void;

@ -180,8 +180,8 @@ export const VoidChatArea: React.FC<VoidChatAreaProps> = ({
 	featureName,
 	showSelections = false,
 	showProspectiveSelections = true,
-	staging,
-	setStaging,
+	selections,
+	setSelections,
 }) => {
 	return (
 		<div
@ -199,11 +199,11 @@ export const VoidChatArea: React.FC<VoidChatAreaProps> = ({
 			}}
 		>
 			{/* Selections section */}
-			{showSelections && staging && setStaging && (
+			{showSelections && selections && setSelections && (
 				<SelectedFiles
 					type='staging'
-					selections={staging.selections || []}
-					setSelections={(selections) => setStaging({ ...staging, selections })}
+					selections={selections}
+					setSelections={setSelections}
 					showProspectiveSelections={showProspectiveSelections}
 				/>
 			)}
@ -550,9 +550,23 @@ const ChatBubble = ({ chatMessage, isLoading, messageIdx }: { chatMessage: ChatM
 	const accessor = useAccessor()
 	const chatThreadsService = accessor.get('IChatThreadService')

-	// edit mode state
-	const [staging, setStaging] = chatThreadsService._useFocusedStagingState(messageIdx)
-	const mode: ChatBubbleMode = staging.isBeingEdited ? 'edit' : 'display'
+	// global state
+	let isBeingEdited = false
+	let setIsBeingEdited = (v: boolean) => { }
+	let stagingSelections: StagingSelectionItem[] = []
+	let setStagingSelections = (s: StagingSelectionItem[]) => { }
+
+	if (messageIdx !== undefined) {
+		const [_state, _setState] = chatThreadsService._useCurrentMessageState(messageIdx)
+		isBeingEdited = _state.isBeingEdited
+		setIsBeingEdited = (v) => _setState({ isBeingEdited: v })
+		stagingSelections = _state.stagingSelections
+		setStagingSelections = (s) => { _setState({ stagingSelections: s }) }
+	}
+
+
+	// local state
+	const mode: ChatBubbleMode = isBeingEdited ? 'edit' : 'display'
 	const [isFocused, setIsFocused] = useState(false)
 	const [isHovered, setIsHovered] = useState(false)
 	const [isDisabled, setIsDisabled] = useState(false)
@ -565,10 +579,8 @@ const ChatBubble = ({ chatMessage, isLoading, messageIdx }: { chatMessage: ChatM
 		const canInitialize = role === 'user' && mode === 'edit' && textAreaRefState
 		const shouldInitialize = _justEnabledEdit.current || _mustInitialize.current
 		if (canInitialize && shouldInitialize) {
-			setStaging({
-				...staging,
-				selections: chatMessage.selections || [],
-			})
+			setStagingSelections(chatMessage.selections || [])
+
 			if (textAreaFnsRef.current)
 				textAreaFnsRef.current.setValue(chatMessage.displayContent || '')

@ -581,14 +593,14 @@ const ChatBubble = ({ chatMessage, isLoading, messageIdx }: { chatMessage: ChatM
 	}, [role, mode, _justEnabledEdit, textAreaRefState, textAreaFnsRef.current, _justEnabledEdit.current, _mustInitialize.current])
 	const EditSymbol = mode === 'display' ? Pencil : X
 	const onOpenEdit = () => {
-		setStaging({ ...staging, isBeingEdited: true })
+		setIsBeingEdited(true)
 		chatThreadsService.setFocusedMessageIdx(messageIdx)
 		_justEnabledEdit.current = true
 	}
 	const onCloseEdit = () => {
 		setIsFocused(false)
 		setIsHovered(false)
-		setStaging({ ...staging, isBeingEdited: false })
+		setIsBeingEdited(false)
 		chatThreadsService.setFocusedMessageIdx(undefined)

 	}
@ -614,12 +626,12 @@ const ChatBubble = ({ chatMessage, isLoading, messageIdx }: { chatMessage: ChatM
 				chatThreadsService.cancelStreaming(thread.id)

 				// reset state
-				setStaging({ ...staging, isBeingEdited: false })
+				setIsBeingEdited(false)
 				chatThreadsService.setFocusedMessageIdx(undefined)

 				// stream the edit
 				const userMessage = textAreaRefState.value;
-				await chatThreadsService.editUserMessageAndStreamResponse(userMessage, messageIdx)
+				await chatThreadsService.editUserMessageAndStreamResponse({ userMessage, chatMode: 'agent', messageIdx })
 			}

 			const onAbort = () => {
@ -649,8 +661,8 @@ const ChatBubble = ({ chatMessage, isLoading, messageIdx }: { chatMessage: ChatM
 					showSelections={true}
 					showProspectiveSelections={false}
 					featureName="Ctrl+L"
-					staging={staging}
-					setStaging={setStaging}
+					selections={stagingSelections}
+					setSelections={setStagingSelections}
 				>
 					<VoidInputBox2
 						ref={setTextAreaRef}
@ -682,6 +694,9 @@ const ChatBubble = ({ chatMessage, isLoading, messageIdx }: { chatMessage: ChatM

 		chatbubbleContents = <ChatMarkdownRender string={chatMessage.displayContent ?? ''} chatMessageLocation={chatMessageLocation} />
 	}
+	else if (role === 'tool') {
+		chatbubbleContents = chatMessage.name
+	}

 	return <div
 		// align chatbubble accoridng to role
@ -691,7 +706,6 @@ const ChatBubble = ({ chatMessage, isLoading, messageIdx }: { chatMessage: ChatM
 				: role === 'user' ? `px-2 self-end w-fit max-w-full whitespace-pre-wrap` // user words should be pre
 					: role === 'assistant' ? `px-2 self-start w-full max-w-full` : ''
 			}
-			${role !== 'assistant' ? 'my-2' : ''}
 		`}
 		onMouseEnter={() => setIsHovered(true)}
 		onMouseLeave={() => setIsHovered(false)}
@ -765,7 +779,10 @@ export const SidebarChat = () => {

 	const currentThread = chatThreadsService.getCurrentThread()
 	const previousMessages = currentThread?.messages ?? []
-	const [staging, setStaging] = chatThreadsService._useFocusedStagingState()
+
+	const [_state, _setState] = chatThreadsService._useCurrentThreadState()
+	const selections = _state.stagingSelections
+	const setSelections = (s: StagingSelectionItem[]) => { _setState({ stagingSelections: s }) }

 	// stream state
 	const currThreadStreamState = useChatThreadsStreamState(chatThreadsState.currentThreadId)
@ -795,13 +812,13 @@ export const SidebarChat = () => {

 		// send message to LLM
 		const userMessage = textAreaRef.current?.value ?? ''
-		await chatThreadsService.addUserMessageAndStreamResponse(userMessage)
+		await chatThreadsService.addUserMessageAndStreamResponse({ userMessage, chatMode: 'agent' })

-		setStaging({ ...staging, selections: [], }) // clear staging
+		setSelections([]) // clear staging
 		textAreaFnsRef.current?.setValue('')
 		textAreaRef.current?.focus() // focus input after submit

-	}, [chatThreadsService, isDisabled, isStreaming, textAreaRef, textAreaFnsRef, staging, setStaging])
+	}, [chatThreadsService, isDisabled, isStreaming, textAreaRef, textAreaFnsRef, selections, setSelections])

 	const onAbort = () => {
 		const threadId = currentThread.id
@ -822,7 +839,7 @@ export const SidebarChat = () => {

 	const prevMessagesHTML = useMemo(() => {
 		return previousMessages.map((message, i) =>
-			<ChatBubble key={`${message.displayContent}-${i}`} chatMessage={message} messageIdx={i} />
+			<ChatBubble key={i} chatMessage={message} messageIdx={i} />
 		)
 	}, [previousMessages])

@ -836,6 +853,7 @@ export const SidebarChat = () => {


 	const messagesHTML = <ScrollToBottomContainer
+		key={currentThread.id} // force rerender on all children if id changes
 		scrollContainerRef={scrollContainerRef}
 		className={`
 		w-full h-auto
@ -887,8 +905,8 @@ export const SidebarChat = () => {
 			isDisabled={isDisabled}
 			showSelections={true}
 			showProspectiveSelections={prevMessagesHTML.length === 0}
-			staging={staging}
-			setStaging={setStaging}
+			selections={selections}
+			setSelections={setSelections}
 			onClickAnywhere={() => { textAreaRef.current?.focus() }}
 			featureName="Ctrl+L"
 		>
--- a/src/vs/workbench/contrib/void/browser/react/src/util/services.tsx
+++ b/src/vs/workbench/contrib/void/browser/react/src/util/services.tsx
@ -28,7 +28,7 @@ import { IThemeService } from '../../../../../../../platform/theme/common/themeS
 import { ILLMMessageService } from '../../../../../../../workbench/contrib/void/common/llmMessageService.js';
 import { IRefreshModelService } from '../../../../../../../workbench/contrib/void/common/refreshModelService.js';
 import { IVoidSettingsService } from '../../../../../../../workbench/contrib/void/common/voidSettingsService.js';
-import { IInlineDiffsService } from '../../../inlineDiffsService.js';
+import { IEditCodeService } from '../../../editCodeService.js';
 import { IVoidUriStateService } from '../../../voidUriStateService.js';
 import { IQuickEditStateService } from '../../../quickEditStateService.js';
 import { ISidebarStateService } from '../../../sidebarStateService.js';
@ -103,10 +103,10 @@ export const _registerServices = (accessor: ServicesAccessor) => {
 		settingsStateService: accessor.get(IVoidSettingsService),
 		refreshModelService: accessor.get(IRefreshModelService),
 		themeService: accessor.get(IThemeService),
-		inlineDiffsService: accessor.get(IInlineDiffsService),
+		editCodeService: accessor.get(IEditCodeService),
 	}

-	const { uriStateService, sidebarStateService, quickEditStateService, settingsStateService, chatThreadsStateService, refreshModelService, themeService, inlineDiffsService } = stateServices
+	const { uriStateService, sidebarStateService, quickEditStateService, settingsStateService, chatThreadsStateService, refreshModelService, themeService, editCodeService } = stateServices

 	uriState = uriStateService.state
 	disposables.push(
@ -192,7 +192,7 @@ const getReactAccessor = (accessor: ServicesAccessor) => {
 		ILLMMessageService: accessor.get(ILLMMessageService),
 		IRefreshModelService: accessor.get(IRefreshModelService),
 		IVoidSettingsService: accessor.get(IVoidSettingsService),
-		IInlineDiffsService: accessor.get(IInlineDiffsService),
+		IEditCodeService: accessor.get(IEditCodeService),
 		IVoidUriStateService: accessor.get(IVoidUriStateService),
 		IQuickEditStateService: accessor.get(IQuickEditStateService),
 		ISidebarStateService: accessor.get(ISidebarStateService),
--- a/src/vs/workbench/contrib/void/browser/react/src/util/useScrollbarStyles.tsx
+++ b/src/vs/workbench/contrib/void/browser/react/src/util/useScrollbarStyles.tsx
@ -1,7 +1,6 @@
 import { useEffect } from 'react';

 export const useScrollbarStyles = (containerRef: React.MutableRefObject<HTMLDivElement | null>) => {
-
 	useEffect(() => {
 		if (!containerRef.current) return;

@ -12,90 +11,118 @@ export const useScrollbarStyles = (containerRef: React.MutableRefObject<HTMLDivE
 			'[class*="overflow-y-auto"]'
 		].join(',');

-		// 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))
-		];
+		// 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) || [])
+			];

-		// Apply styles and listeners to each scroll element
-		scrollElements.forEach(element => {
-			// Add the scrollable class directly to the overflow element
-			element.classList.add('void-scrollable-element');
-
-			let fadeTimeout: NodeJS.Timeout | null = null;
-			let fadeInterval: NodeJS.Timeout | null = null;
-
-			const fadeIn = () => {
-				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);
-			};
-
-			const fadeOut = () => {
-				if (fadeInterval) clearInterval(fadeInterval);
-
-				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 onMouseEnter = () => {
-				if (fadeTimeout) clearTimeout(fadeTimeout);
-				if (fadeInterval) clearInterval(fadeInterval);
-				fadeIn();
-			};
-
-			const onMouseLeave = () => {
-				if (fadeTimeout) clearTimeout(fadeTimeout);
-				fadeTimeout = setTimeout(() => {
-					fadeOut();
-				}, 10);
-			};
-
-			element.addEventListener('mouseenter', onMouseEnter);
-			element.addEventListener('mouseleave', onMouseLeave);
-
-			// 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}`);
-				}
-			};
-
-			// Store the cleanup function on the element for later use
-			(element as any).__scrollbarCleanup = cleanup;
-		});
-
-		return () => {
-			// Clean up all scroll elements
+			// Apply basic styling to all elements
 			scrollElements.forEach(element => {
-				if ((element as any).__scrollbarCleanup) {
-					(element as any).__scrollbarCleanup();
+				element.classList.add('void-scrollable-element');
+			});
+
+			// 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;
+
+					const fadeIn = () => {
+						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);
+					};
+
+					const fadeOut = () => {
+						if (fadeInterval) clearInterval(fadeInterval);
+
+						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 onMouseEnter = () => {
+						if (fadeTimeout) clearTimeout(fadeTimeout);
+						if (fadeInterval) clearInterval(fadeInterval);
+						fadeIn();
+					};
+
+					const onMouseLeave = () => {
+						if (fadeTimeout) clearTimeout(fadeTimeout);
+						fadeTimeout = setTimeout(() => {
+							fadeOut();
+						}, 10);
+					};
+
+					element.addEventListener('mouseenter', onMouseEnter);
+					element.addEventListener('mouseleave', onMouseLeave);
+
+					// 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}`);
+						}
+					};
+
+					// Store the cleanup function on the element for later use
+					(element as any).__scrollbarCleanup = cleanup;
 				}
 			});
 		};
+
+		// Initialize for the first time
+		initializeScrollbarStyles();
+
+		// Set up mutation observer to do the same
+		const observer = new MutationObserver(() => {
+			initializeScrollbarStyles();
+		});
+
+		// 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]);
 };
--- a/src/vs/workbench/contrib/void/browser/react/src/void-settings-tsx/Settings.tsx
+++ b/src/vs/workbench/contrib/void/browser/react/src/void-settings-tsx/Settings.tsx
@ -17,6 +17,7 @@ import { env } from '../../../../../../../base/common/process.js'
 import { ModelDropdown } from './ModelDropdown.js'
 import { ChatMarkdownRender } from '../markdown/ChatMarkdownRender.js'
 import { WarningBox } from './WarningBox.js'
+import { os } from '../../../helpers/systemInfo.js'

 const SubtleButton = ({ onClick, text, icon, disabled }: { onClick: () => void, text: string, icon: React.ReactNode, disabled: boolean }) => {

@ -385,7 +386,7 @@ export const AIInstructionsBox = () => {
 	return <VoidInputBox2
 		className='min-h-[81px] p-3 rounded-sm'
 		initValue={voidSettingsState.globalSettings.aiInstructions}
-		placeholder={`Do not change my indentation or delete my comments. When writing TS or JS, do not add ;'s. Respond to all queries in French. `}
+		placeholder={`Do not change my indentation or delete my comments. When writing TS or JS, do not add ;'s. Write new code using Rust if possible. `}
 		multiline
 		onChangeText={(newText) => {
 			voidSettingsService.setGlobalSetting('aiInstructions', newText)
@ -395,7 +396,16 @@ export const AIInstructionsBox = () => {

 export const FeaturesTab = () => {
 	return <>
-		<h2 className={`text-3xl mb-2`}>Local Providers</h2>
+		<h2 className={`text-3xl mb-2`}>Models</h2>
+		<ErrorBoundary>
+			<AutoRefreshToggle />
+			<RefreshableModels />
+			<ModelDump />
+			<AddModelMenuFull />
+		</ErrorBoundary>
+
+
+		<h2 className={`text-3xl mb-2 mt-12`}>Local Providers</h2>
 		{/* <h3 className={`opacity-50 mb-2`}>{`Keep your data private by hosting AI locally on your computer.`}</h3> */}
 		{/* <h3 className={`opacity-50 mb-2`}>{`Instructions:`}</h3> */}
 		{/* <h3 className={`mb-2`}>{`Void can access any model that you host locally. We automatically detect your local models by default.`}</h3> */}
@ -420,13 +430,20 @@ export const FeaturesTab = () => {
 			<VoidProviderSettings providerNames={nonlocalProviderNames} />
 		</ErrorBoundary>

-		<h2 className={`text-3xl mb-2 mt-12`}>Models</h2>
+
+
+		<h2 className={`text-3xl mb-2 mt-12`}>Feature Options</h2>
 		<ErrorBoundary>
-			<AutoRefreshToggle />
-			<RefreshableModels />
-			<ModelDump />
-			<AddModelMenuFull />
+			{featureNames.map(featureName =>
+				<div key={featureName}
+					className='mb-2'
+				>
+					<h4 className={`text-void-fg-3`}>{displayInfoOfFeatureName(featureName)}</h4>
+					<ModelDropdown featureName={featureName} />
+				</div>
+			)}
 		</ErrorBoundary>
+
 	</>
 }

@ -489,7 +506,7 @@ const transferTheseFilesOfOS = (os: 'mac' | 'windows' | 'linux' | null): Transfe
 	throw new Error(`os '${os}' not recognized`)
 }

-const os = isWindows ? 'windows' : isMacintosh ? 'mac' : isLinux ? 'linux' : null
+
 let transferTheseFiles: TransferFilesInfo = []
 let transferError: string | null = null

@ -588,17 +605,6 @@ const GeneralTab = () => {
 			<AIInstructionsBox />
 		</div>

-		<div className='mt-12'>
-			<h2 className={`text-3xl mb-2`}>Model Selection</h2>
-			{featureNames.map(featureName =>
-				<div key={featureName}
-					className='mb-2'
-				>
-					<h4 className={`text-void-fg-3`}>{displayInfoOfFeatureName(featureName)}</h4>
-					<ModelDropdown featureName={featureName} />
-				</div>
-			)}
-		</div>

 	</>
 }
--- a/src/vs/workbench/contrib/void/browser/searchAndReplaceService.ts
+++ b/src/vs/workbench/contrib/void/browser/searchAndReplaceService.ts
@ -1,71 +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 type ChatMessageLocation = {
-	threadId: string;
-	messageIdx: number;
-}
-
-
-export type SearchAndReplaceBlock = {
-	search: string;
-	replace: string;
-}
-
-// service that manages state
-export type ApplyState = {
-	[applyBoxId: string]: {
-		searchAndReplaceBlocks: SearchAndReplaceBlock;
-	}
-}
-
-// the purpose of this service is to generate search and replace blocks for a given codeblock `codeblockId` and on a file `fileName` and version `fileVersion`
-
-export interface IFastApplyService {
-	readonly _serviceBrand: undefined;
-
-	// readonly state: ApplyState; // readonly to the user
-	// setState(newState: Partial<ApplyState>): void;
-	// onDidChangeState: Event<void>;
-}
-
-export const IVoidFastApplyService = createDecorator<IFastApplyService>('voidFastApplyService');
-class VoidFastApplyService extends Disposable implements IFastApplyService {
-	_serviceBrand: undefined;
-
-	static readonly ID = 'voidFastApplyService';
-
-	private readonly _onDidChangeState = new Emitter<void>();
-	readonly onDidChangeState: Event<void> = this._onDidChangeState.event;
-
-
-	// state
-	// state: ApplyState
-
-	constructor(
-	) {
-		super()
-
-		// initial state
-		// this.state = { currentUri: undefined }
-	}
-
-	setState(newState: Partial<ApplyState>) {
-
-		// this.state = { ...this.state, ...newState }
-		this._onDidChangeState.fire()
-	}
-
-
-}
-
-registerSingleton(IVoidFastApplyService, VoidFastApplyService, InstantiationType.Eager);
--- a/src/vs/workbench/contrib/void/browser/searchReplaceCacheService.ts
+++ b/src/vs/workbench/contrib/void/browser/searchReplaceCacheService.ts
@ -0,0 +1,46 @@
+/*--------------------------------------------------------------------------------------
+ *  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';
+import { ILLMMessageService } from '../common/llmMessageService.js';
+import { ServiceSendLLMMessageParams } from '../common/llmMessageTypes.js';
+
+
+
+export interface ISearchReplaceService {
+	readonly _serviceBrand: undefined;
+}
+
+export const ISearchReplaceService = createDecorator<ISearchReplaceService>('SearchReplaceCacheService');
+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: Omit<ServiceSendLLMMessageParams, 'onText'> & { 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);
--- a/src/vs/workbench/contrib/void/browser/sidebarActions.ts
+++ b/src/vs/workbench/contrib/void/browser/sidebarActions.ts
@ -135,9 +135,20 @@ registerAction2(class extends Action2 {
 		const chatThreadService = accessor.get(IChatThreadService)

 		const focusedMessageIdx = chatThreadService.getFocusedMessageIdx()
-		const [staging, setStaging] = chatThreadService._useFocusedStagingState(focusedMessageIdx)
-		const selections = staging.selections || []
-		const setSelections = (s: StagingSelectionItem[]) => setStaging({ ...staging, selections: s })
+
+		// set the selections to the proper value
+		let selections: StagingSelectionItem[] = []
+		let setSelections = (s: StagingSelectionItem[]) => { }
+
+		if (focusedMessageIdx === undefined) {
+			const [state, setState] = chatThreadService._useCurrentThreadState()
+			selections = state.stagingSelections
+			setSelections = (s) => setState({ stagingSelections: s })
+		} else {
+			const [state, setState] = chatThreadService._useCurrentMessageState(focusedMessageIdx)
+			selections = state.stagingSelections
+			setSelections = (s) => setState({ stagingSelections: s })
+		}

 		// if matches with existing selection, overwrite (since text may change)
 		const matchingStagingEltIdx = findMatchingStagingIndex(selections, selection)
--- a/src/vs/workbench/contrib/void/browser/void.contribution.ts
+++ b/src/vs/workbench/contrib/void/browser/void.contribution.ts
@ -5,7 +5,7 @@


 // register inline diffs
-import './inlineDiffsService.js'
+import './editCodeService.js'

 // register Sidebar pane, state, actions (keybinds, menus) (Ctrl+L)
 import './sidebarActions.js'
@ -22,7 +22,7 @@ import './chatThreadService.js'
 import './autocompleteService.js'

 // register Context services
-import './contextGatheringService.js'
+// import './contextGatheringService.js'
 // import './contextUserChangesService.js'

 // settings pane
--- a/src/vs/workbench/contrib/void/common/llmMessageTypes.ts
+++ b/src/vs/workbench/contrib/void/common/llmMessageTypes.ts
@ -3,6 +3,8 @@
 *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
 *--------------------------------------------------------------------------------------*/

+import { ChatMessage } from '../browser/chatThreadService.js'
+import { InternalToolInfo, ToolName } from './toolsService.js'
 import { FeatureName, ProviderName, SettingsOfProvider } from './voidSettingsTypes.js'


@ -20,20 +22,48 @@ export const errorDetails = (fullError: Error | null): string | null => {
 	return null
 }

+
+export type LLMChatMessage = {
+	role: 'system' | 'user';
+	content: string;
+} | {
+	role: 'assistant',
+	content: string;
+} | {
+	role: 'tool';
+	content: string; // result
+	name: string;
+	params: string;
+	id: string;
+}
+
+
+export type ToolCallType = {
+	name: ToolName;
+	params: string;
+	id: string;
+}
+
+
 export type OnText = (p: { newText: string, fullText: string }) => void
-export type OnFinalMessage = (p: { fullText: string }) => void
+export type OnFinalMessage = (p: { fullText: string, toolCalls?: ToolCallType[] }) => void // id is tool_use_id
 export type OnError = (p: { message: string, fullError: Error | null }) => void
 export type AbortRef = { current: (() => void) | null }

-export type LLMChatMessage = {
-	role: 'system' | 'user' | 'assistant';
-	content: string;
+
+export const toLLMChatMessage = (c: ChatMessage): LLMChatMessage => {
+	if (c.role === 'system' || c.role === 'user') {
+		return { role: c.role, content: c.content || '(empty message)' }
+	}
+	else if (c.role === 'assistant')
+		return { role: c.role, content: c.content || '(empty message)' }
+	else if (c.role === 'tool')
+		return { role: c.role, id: c.id, name: c.name, params: c.params, content: c.content || '(empty output)' }
+	else {
+		throw 1
+	}
 }

-export type _InternalLLMChatMessage = {
-	role: 'user' | 'assistant';
-	content: string;
-}

 type _InternalSendFIMMessage = {
 	prefix: string;
@ -44,9 +74,11 @@ type _InternalSendFIMMessage = {
 type SendLLMType = {
 	messagesType: 'chatMessages';
 	messages: LLMChatMessage[];
+	tools?: InternalToolInfo[];
 } | {
 	messagesType: 'FIMMessage';
 	messages: _InternalSendFIMMessage;
+	tools?: undefined;
 }

 // service types
@ -88,6 +120,8 @@ export type EventLLMMessageOnErrorParams = Parameters<OnError>[0] & { requestId:

 export type _InternalSendLLMChatMessageFnType = (
 	params: {
+		aiInstructions: string;
+
 		onText: OnText;
 		onFinalMessage: OnFinalMessage;
 		onError: OnError;
@ -96,7 +130,9 @@ export type _InternalSendLLMChatMessageFnType = (
 		modelName: string;
 		_setAborter: (aborter: () => void) => void;

-		messages: _InternalLLMChatMessage[];
+		tools?: InternalToolInfo[],
+
+		messages: LLMChatMessage[];
 	}
 ) => void

--- a/src/vs/workbench/contrib/void/common/refreshModelService.ts
+++ b/src/vs/workbench/contrib/void/common/refreshModelService.ts
@ -45,6 +45,7 @@ export type RefreshModelStateOfProvider = Record<RefreshableProviderName, Refres

 const refreshBasedOn: { [k in RefreshableProviderName]: (keyof SettingsOfProvider[k])[] } = {
 	ollama: ['_didFillInProviderSettings', 'endpoint'],
+	vLLM: ['_didFillInProviderSettings', 'endpoint'],
 	// openAICompatible: ['_didFillInProviderSettings', 'endpoint', 'apiKey'],
 }
 const REFRESH_INTERVAL = 5_000
@ -140,10 +141,11 @@ export class RefreshModelService extends Disposable implements IRefreshModelServ

 	state: RefreshModelStateOfProvider = {
 		ollama: { state: 'init', timeoutId: null },
+		vLLM: { state: 'init', timeoutId: null },
 	}


-	// start listening for models (and don't stop until success)
+	// start listening for models (and don't stop)
 	startRefreshingModels: IRefreshModelService['startRefreshingModels'] = (providerName, options) => {

 		this._clearProviderTimeout(providerName)
@ -158,8 +160,9 @@ export class RefreshModelService extends Disposable implements IRefreshModelServ
 			}
 		}
 		const listFn = providerName === 'ollama' ? this.llmMessageService.ollamaList
-			: providerName === 'openAICompatible' ? this.llmMessageService.openAICompatibleList
-				: () => { }
+			: providerName === 'vLLM' ? this.llmMessageService.openAICompatibleList
+				: providerName === 'openAICompatible' ? this.llmMessageService.openAICompatibleList
+					: () => { }

 		listFn({
 			onSuccess: ({ models }) => {
@ -169,6 +172,7 @@ export class RefreshModelService extends Disposable implements IRefreshModelServ
 					providerName,
 					models.map(model => {
 						if (providerName === 'ollama') return (model as OllamaModelResponse).name;
+						else if (providerName === 'vLLM') return (model as OpenaiCompatibleModelResponse).id;
 						else if (providerName === 'openAICompatible') return (model as OpenaiCompatibleModelResponse).id;
 						else throw new Error('refreshMode fn: unknown provider', providerName);
 					}),
--- a/src/vs/workbench/contrib/void/common/toolsService.ts
+++ b/src/vs/workbench/contrib/void/common/toolsService.ts
@ -1,10 +1,11 @@
 import { CancellationToken } from '../../../../base/common/cancellation.js'
 import { URI } from '../../../../base/common/uri.js'
-import { IFileService, IFileStat } from '../../../../platform/files/common/files.js'
+import { IModelService } from '../../../../editor/common/services/model.js'
+import { IFileService } from '../../../../platform/files/common/files.js'
 import { registerSingleton, InstantiationType } from '../../../../platform/instantiation/common/extensions.js'
 import { createDecorator, IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js'
 import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js'
-import { VSReadFileRaw } from '../../../../workbench/contrib/void/browser/helpers/readFile.js'
+import { VSReadFile } from '../../../../workbench/contrib/void/browser/helpers/readFile.js'
 import { QueryBuilder } from '../../../../workbench/services/search/common/queryBuilder.js'
 import { ISearchService } from '../../../../workbench/services/search/common/search.js'

@ -15,6 +16,7 @@ import { ISearchService } from '../../../../workbench/services/search/common/sea

 // 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
@ -23,13 +25,14 @@ export type InternalToolInfo = {
 }

 // helper
-const pagination = {
+const paginationHelper = {
 	desc: `Very large results may be paginated (indicated in the result). Pagination fails gracefully if out of bounds or invalid page number.`,
 	param: { pageNumber: { type: 'number', description: 'The page number (optional, default is 1).' }, }
 } as const

-export const contextTools = {
+export const voidTools = {
 	read_file: {
+		name: 'read_file',
 		description: 'Returns file contents of a given URI.',
 		params: {
 			uri: { type: 'string', description: undefined },
@ -38,28 +41,31 @@ export const contextTools = {
 	},

 	list_dir: {
-		description: `Returns all file names and folder names in a given URI. ${pagination.desc}`,
+		name: 'list_dir',
+		description: `Returns all file names and folder names in a given URI. ${paginationHelper.desc}`,
 		params: {
 			uri: { type: 'string', description: undefined },
-			...pagination.param
+			...paginationHelper.param
 		},
 		required: ['uri'],
 	},

 	pathname_search: {
-		description: `Returns all pathnames that match a given grep query. You should use this when looking for a file with a specific name or path. This does NOT search file content. ${pagination.desc}`,
+		name: 'pathname_search',
+		description: `Returns all pathnames that match a given grep query. You should use this when looking for a file with a specific name or path. This does NOT search file content. ${paginationHelper.desc}`,
 		params: {
 			query: { type: 'string', description: undefined },
-			...pagination.param,
+			...paginationHelper.param,
 		},
 		required: ['query']
 	},

 	search: {
-		description: `Returns all code excerpts containing the given string or grep query. This does NOT search pathname. As a follow-up, you may want to use read_file to view the full file contents of the results. ${pagination.desc}`,
+		name: 'search',
+		description: `Returns all code excerpts containing the given string or grep query. This does NOT search pathname. As a follow-up, you may want to use read_file to view the full file contents of the results. ${paginationHelper.desc}`,
 		params: {
 			query: { type: 'string', description: undefined },
-			...pagination.param,
+			...paginationHelper.param,
 		},
 		required: ['query'],
 	},
@ -68,115 +74,229 @@ export const contextTools = {
 	// 	description: 'Searches files semantically for the given string query.',
 	// 	// RAG
 	// },
+} satisfies { [name: string]: InternalToolInfo }

-} as const satisfies { [name: string]: InternalToolInfo }
+export type ToolName = keyof typeof voidTools
+export const toolNames = Object.keys(voidTools) as ToolName[]

-export type ContextToolName = keyof typeof contextTools
-type ContextToolParamNames<T extends ContextToolName> = keyof typeof contextTools[T]['params']
-type ContextToolParams<T extends ContextToolName> = { [paramName in ContextToolParamNames<T>]: unknown }
+export type ToolParamNames<T extends ToolName> = keyof typeof voidTools[T]['params']
+export type ToolParamsObj<T extends ToolName> = { [paramName in ToolParamNames<T>]: unknown }

-type AllContextToolCallFns = {
-	[ToolName in ContextToolName]: ((p: (ContextToolParams<ToolName>)) => Promise<string>)
+
+export type ToolCallReturnType<T extends ToolName>
+	= T extends 'read_file' ? string
+	: T extends 'list_dir' ? string
+	: T extends 'pathname_search' ? string | URI[]
+	: T extends 'search' ? string | URI[]
+	: never
+
+export type ToolFns = { [T in ToolName]: (p: string) => Promise<[ToolCallReturnType<T>, boolean]> }
+export type ToolResultToString = { [T in ToolName]: (result: [ToolCallReturnType<T>, boolean]) => string }
+
+
+// pagination info
+const MAX_FILE_CHARS_PAGE = 50_000
+const MAX_CHILDREN_URIs_PAGE = 500
+
+const MAX_DEPTH = 1
+async function generateDirectoryTreeMd(fileService: IFileService, rootURI: URI, pageNumber: number): Promise<[string, boolean]> {
+	let output = '';
+
+	const indentation = (depth: number, isLast: boolean): string => {
+		if (depth === 0) return '';
+		return `${'|   '.repeat(depth - 1)}${isLast ? '└── ' : '├── '}`;
+	};
+
+	let hasNextPage = false
+
+	async function traverseChildren(uri: URI, depth: number, isLast: boolean) {
+		const stat = await fileService.resolve(uri, { resolveMetadata: false });
+
+		// we might want to say where symlink links to
+		if ((depth === 0 && pageNumber === 1) || depth !== 0)
+			output += `${indentation(depth, isLast)}${stat.name}${stat.isDirectory ? '/' : ''}${stat.isSymbolicLink ? ` (symbolic link)` : ''}\n`;
+
+		// list children
+		const originalChildrenLength = stat.children?.length ?? 0
+		const fromChildIdx = MAX_CHILDREN_URIs_PAGE * (pageNumber - 1)
+		const toChildIdx = MAX_CHILDREN_URIs_PAGE * pageNumber - 1 // INCLUSIVE
+		const listChildren = stat.children?.slice(fromChildIdx, toChildIdx + 1) ?? [];
+
+		if (!stat.isDirectory) return;
+
+		if (listChildren.length === 0) return
+		if (depth === MAX_DEPTH) return // right now MAX_DEPTH=1 to make pagination work nicely
+
+		for (let i = 0; i < Math.min(listChildren.length, MAX_CHILDREN_URIs_PAGE); i++) {
+			await traverseChildren(listChildren[i].resource, depth + 1, i === listChildren.length - 1);
+		}
+		const nCutoffResults = (originalChildrenLength - 1) - toChildIdx
+		if (nCutoffResults >= 1) {
+			output += `${indentation(depth + 1, true)}(${nCutoffResults} results remaining...)\n`
+			hasNextPage = true
+		}
+
+	}
+
+	await traverseChildren(rootURI, 0, false);
+
+	return [output, hasNextPage]
+}
+
+
+const validateJSON = (s: string): { [s: string]: unknown } => {
+	try {
+		const o = JSON.parse(s)
+		return o
+	}
+	catch (e) {
+		throw new Error(`Tool parameter was not a valid JSON: "${s}".`)
+	}
 }



-
-
-
-
-// TODO check to make sure in workspace
-// TODO check to make sure is not gitignored
-
-
-async function generateDirectoryTreeMd(fileService: IFileService, rootURI: URI): Promise<string> {
-	let output = ''
-	function traverseChildren(children: IFileStat[], depth: number) {
-		const indentation = '  '.repeat(depth);
-		for (const child of children) {
-			output += `${indentation}- ${child.name}\n`;
-			traverseChildren(child.children ?? [], depth + 1);
-		}
-	}
-	const stat = await fileService.resolve(rootURI, { resolveMetadata: false });
-
-	// kickstart recursion
-	output += `${stat.name}\n`;
-	traverseChildren(stat.children ?? [], 1);
-
-	return output;
+const validateQueryStr = (queryStr: unknown) => {
+	if (typeof queryStr !== 'string') throw new Error('Error calling tool: provided query must be a string.')
+	return queryStr
 }


 const validateURI = (uriStr: unknown) => {
-	if (typeof uriStr !== 'string') throw new Error('(uri was not a string)')
+	if (typeof uriStr !== 'string') throw new Error('Error calling tool: provided uri must be a string.')
 	const uri = URI.file(uriStr)
 	return uri
 }

-export interface IToolService {
+const validatePageNum = (pageNumberUnknown: unknown) => {
+	const proposedPageNum = Number.parseInt(pageNumberUnknown + '')
+	const num = Number.isInteger(proposedPageNum) ? proposedPageNum : 1
+	const pageNumber = num < 1 ? 1 : num
+	return pageNumber
+}
+export interface IToolsService {
 	readonly _serviceBrand: undefined;
-	callContextTool: <T extends ContextToolName>(toolName: T, params: ContextToolParams<T>) => Promise<string>
+	toolFns: ToolFns;
+	toolResultToString: ToolResultToString;
 }

-export const IToolService = createDecorator<IToolService>('ToolService');
+export const IToolsService = createDecorator<IToolsService>('ToolsService');

-export class ToolService implements IToolService {
+export class ToolsService implements IToolsService {

 	readonly _serviceBrand: undefined;

-	contextToolCallFns: AllContextToolCallFns
+	public toolFns: ToolFns
+	public toolResultToString: ToolResultToString
+

 	constructor(
 		@IFileService fileService: IFileService,
+		@IModelService modelService: IModelService,
 		@IWorkspaceContextService workspaceContextService: IWorkspaceContextService,
 		@ISearchService searchService: ISearchService,
 		@IInstantiationService instantiationService: IInstantiationService,
 	) {

-
 		const queryBuilder = instantiationService.createInstance(QueryBuilder);

-		this.contextToolCallFns = {
-			read_file: async ({ uri: uriStr }) => {
+		this.toolFns = {
+			read_file: async (s: string) => {
+				const o = validateJSON(s)
+				const { uri: uriStr, pageNumber: pageNumberUnknown } = o
+
 				const uri = validateURI(uriStr)
-				const fileContents = await VSReadFileRaw(fileService, uri)
-				return fileContents ?? '(could not read file)'
+				const pageNumber = validatePageNum(pageNumberUnknown)
+
+				const readFileContents = await VSReadFile(uri, modelService, fileService)
+
+				const fromIdx = MAX_FILE_CHARS_PAGE * (pageNumber - 1)
+				const toIdx = MAX_FILE_CHARS_PAGE * pageNumber - 1
+				let fileContents = readFileContents.slice(fromIdx, toIdx + 1) // paginate
+				const hasNextPage = (readFileContents.length - 1) - toIdx >= 1
+
+				return [fileContents || '(empty)', hasNextPage]
 			},
-			list_dir: async ({ uri: uriStr }) => {
+			list_dir: async (s: string) => {
+				const o = validateJSON(s)
+				const { uri: uriStr, pageNumber: pageNumberUnknown } = o
+
 				const uri = validateURI(uriStr)
-				const treeStr = await generateDirectoryTreeMd(fileService, uri)
-				return treeStr
-			},
-			pathname_search: async ({ query: queryStr }) => {
-				if (typeof queryStr !== 'string') return '(Error: query was not a string)'
-				const query = queryBuilder.file(workspaceContextService.getWorkspace().folders.map(f => f.uri), { filePattern: queryStr, });
+				const pageNumber = validatePageNum(pageNumberUnknown)

-				const data = await searchService.fileSearch(query, CancellationToken.None);
-				const str = data.results.map(({ resource, results }) => resource.fsPath).join('\n')
-				return str
+				// TODO!!!! check to make sure in workspace
+				const [treeStr, hasNextPage] = await generateDirectoryTreeMd(fileService, uri, pageNumber)
+				return [treeStr, hasNextPage]
 			},
-			search: async ({ query: queryStr }) => {
-				if (typeof queryStr !== 'string') return '(Error: query was not a string)'
-				const query = queryBuilder.text({ pattern: queryStr, }, workspaceContextService.getWorkspace().folders.map(f => f.uri));
+			pathname_search: async (s: string) => {
+				const o = validateJSON(s)
+				const { query: queryUnknown, pageNumber: pageNumberUnknown } = o

-				const data = await searchService.textSearch(query, CancellationToken.None);
-				const str = data.results.map(({ resource, results }) => resource.fsPath).join('\n')
-				return str
+				const queryStr = validateQueryStr(queryUnknown)
+				const pageNumber = validatePageNum(pageNumberUnknown)
+
+				const query = queryBuilder.file(workspaceContextService.getWorkspace().folders.map(f => f.uri), { filePattern: queryStr, })
+				const data = await searchService.fileSearch(query, CancellationToken.None)
+
+				const fromIdx = MAX_CHILDREN_URIs_PAGE * (pageNumber - 1)
+				const toIdx = MAX_CHILDREN_URIs_PAGE * pageNumber - 1
+				const URIs = data.results
+					.slice(fromIdx, toIdx + 1) // paginate
+					.map(({ resource, results }) => resource)
+
+				const hasNextPage = (data.results.length - 1) - toIdx >= 1
+
+				return [URIs, hasNextPage]
+			},
+			search: async (s: string) => {
+				const o = validateJSON(s)
+				const { query: queryUnknown, pageNumber: pageNumberUnknown } = o
+
+				const queryStr = validateQueryStr(queryUnknown)
+				const pageNumber = validatePageNum(pageNumberUnknown)
+
+				const query = queryBuilder.text({ pattern: queryStr, }, workspaceContextService.getWorkspace().folders.map(f => f.uri))
+				const data = await searchService.textSearch(query, CancellationToken.None)
+
+				const fromIdx = MAX_CHILDREN_URIs_PAGE * (pageNumber - 1)
+				const toIdx = MAX_CHILDREN_URIs_PAGE * pageNumber - 1
+				const URIs = data.results
+					.slice(fromIdx, toIdx + 1) // paginate
+					.map(({ resource, results }) => resource)
+
+				const hasNextPage = (data.results.length - 1) - toIdx >= 1
+
+				return [URIs, hasNextPage]
 			},

 		}


+		const nextPageStr = (hasNextPage: boolean) => hasNextPage ? '\n\n(more on next page...)' : ''
+
+		this.toolResultToString = {
+			read_file: ([fileContents, hasNextPage]) => {
+				return fileContents + nextPageStr(hasNextPage)
+			},
+			list_dir: ([dirTreeStr, hasNextPage]) => {
+				return dirTreeStr + nextPageStr(hasNextPage)
+			},
+			pathname_search: ([URIs, hasNextPage]) => {
+				if (typeof URIs === 'string') return URIs
+				return URIs.map(uri => uri.fsPath).join('\n') + nextPageStr(hasNextPage)
+			},
+			search: ([URIs, hasNextPage]) => {
+				if (typeof URIs === 'string') return URIs
+				return URIs.map(uri => uri.fsPath).join('\n') + nextPageStr(hasNextPage)
+			},
+		}
+
+

 	}

-	callContextTool: IToolService['callContextTool'] = (toolName, params) => {
-		return this.contextToolCallFns[toolName](params)
-	}
-

 }

-registerSingleton(IToolService, ToolService, InstantiationType.Eager);
+registerSingleton(IToolsService, ToolsService, InstantiationType.Eager);

--- a/src/vs/workbench/contrib/void/common/voidSettingsService.ts
+++ b/src/vs/workbench/contrib/void/common/voidSettingsService.ts
@ -11,7 +11,7 @@ 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 { defaultSettingsOfProvider, FeatureName, ProviderName, ModelSelectionOfFeature, SettingsOfProvider, SettingName, providerNames, ModelSelection, modelSelectionsEqual, featureNames, modelInfoOfDefaultModelNames, VoidModelInfo, GlobalSettings, GlobalSettingName, defaultGlobalSettings, displayInfoOfProviderName, defaultProviderSettings } from './voidSettingsTypes.js';
+import { defaultSettingsOfProvider, FeatureName, ProviderName, ModelSelectionOfFeature, SettingsOfProvider, SettingName, providerNames, ModelSelection, modelSelectionsEqual, featureNames, VoidModelInfo, GlobalSettings, GlobalSettingName, defaultGlobalSettings, defaultProviderSettings, developerInfoOfModelName, modelInfoOfAutodetectedModelNames } from './voidSettingsTypes.js';


 const STORAGE_KEY = 'void.settingsServiceStorage'
@ -89,7 +89,7 @@ const _updatedValidatedState = (state: Omit<VoidSettingsState, '_modelOptions'>)
 	// update model options
 	let newModelOptions: ModelOption[] = []
 	for (const providerName of providerNames) {
-		const providerTitle = displayInfoOfProviderName(providerName).title.toLowerCase() // looks better lowercase, best practice to not use raw providerName
+		const providerTitle = providerName // displayInfoOfProviderName(providerName).title.toLowerCase() // looks better lowercase, best practice to not use raw providerName
 		if (!newSettingsOfProvider[providerName]._didFillInProviderSettings) continue // if disabled, don't display model options
 		for (const { modelName, isHidden } of newSettingsOfProvider[providerName].models) {
 			if (isHidden) continue
@ -131,7 +131,7 @@ const _updatedValidatedState = (state: Omit<VoidSettingsState, '_modelOptions'>)
 const defaultState = () => {
 	const d: VoidSettingsState = {
 		settingsOfProvider: deepClone(defaultSettingsOfProvider),
-		modelSelectionOfFeature: { 'Ctrl+L': null, 'Ctrl+K': null, 'Autocomplete': null, 'FastApply': null },
+		modelSelectionOfFeature: { 'Ctrl+L': null, 'Ctrl+K': null, 'Autocomplete': null, 'Apply': null },
 		globalSettings: deepClone(defaultGlobalSettings),
 		_modelOptions: [], // computed later
 	}
@ -175,6 +175,13 @@ class VoidSettingsService extends Disposable implements IVoidSettingsService {
 				// A HACK BECAUSE WE ADDED MISTRAL (did not exist before, comes before readS)
 				...{ mistral: defaultSettingsOfProvider.mistral },

+				// A HACK BECAUSE WE ADDED XAI (did not exist before, comes before readS)
+				...{ xAI: defaultSettingsOfProvider.xAI },
+
+				// A HACK BECAUSE WE ADDED VLLM (did not exist before, comes before readS)
+				...{ vLLM: defaultSettingsOfProvider.vLLM },
+
+
 				...readS.settingsOfProvider,

 				// A HACK BECAUSE WE ADDED NEW GEMINI MODELS (existed before, comes after readS)
@ -189,7 +196,7 @@ class VoidSettingsService extends Disposable implements IVoidSettingsService {

 			const newModelSelectionOfFeature = {
 				// A HACK BECAUSE WE ADDED FastApply
-				...{ 'FastApply': null },
+				...{ 'Apply': null },
 				...readS.modelSelectionOfFeature,
 			}

@ -289,27 +296,26 @@ class VoidSettingsService extends Disposable implements IVoidSettingsService {



-	setAutodetectedModels(providerName: ProviderName, newDefaultModelNames: string[], logging: object) {
+	setAutodetectedModels(providerName: ProviderName, autodetectedModelNames: string[], logging: object) {

 		const { models } = this.state.settingsOfProvider[providerName]
-
 		const oldModelNames = models.map(m => m.modelName)

-		const newDefaultModelInfo = modelInfoOfDefaultModelNames(newDefaultModelNames, { isAutodetected: true, existingModels: models })
-		const newModelInfo = [
-			...newDefaultModelInfo, // swap out all the default models for the new default models
-			...models.filter(m => !m.isDefault), // keep any non-defaul (custom) models
+
+		const newDefaultModels = modelInfoOfAutodetectedModelNames(autodetectedModelNames, { existingModels: models })
+		const newModels = [
+			...newDefaultModels, // swap out all the default models for the new default models
+			...models.filter(m => !m.isDefault), // keep any non-default (custom) models
 		]

-
-		this.setSettingOfProvider(providerName, 'models', newModelInfo)
+		this.setSettingOfProvider(providerName, 'models', newModels)

 		// if the models changed, log it
-		const new_names = newModelInfo.map(m => m.modelName)
+		const new_names = newModels.map(m => m.modelName)
 		if (!(oldModelNames.length === new_names.length
 			&& oldModelNames.every((_, i) => oldModelNames[i] === new_names[i]))
 		) {
-			this._metricsService.capture('Autodetect Models', { providerName, newModels: newModelInfo, ...logging })
+			this._metricsService.capture('Autodetect Models', { providerName, newModels: newModels, ...logging })
 		}
 	}
 	toggleModelHidden(providerName: ProviderName, modelName: string) {
@ -335,7 +341,7 @@ class VoidSettingsService extends Disposable implements IVoidSettingsService {
 		if (existingIdx !== -1) return // if exists, do nothing
 		const newModels = [
 			...models,
-			{ modelName, isDefault: false, isHidden: false }
+			{ ...developerInfoOfModelName(modelName), modelName, isDefault: false, isHidden: false }
 		]
 		this.setSettingOfProvider(providerName, 'models', newModels)

--- a/src/vs/workbench/contrib/void/common/voidSettingsTypes.ts
+++ b/src/vs/workbench/contrib/void/common/voidSettingsTypes.ts
@ -7,45 +7,264 @@
 import { VoidSettingsState } from './voidSettingsService.js'


-export type VoidModelInfo = {
+
+// developer info used in sendLLMMessage
+export type DeveloperInfoAtModel = {
+	// USED:
+	supportsSystemMessage: 'developer' | boolean, // if null, we will just do a string of system message. this is independent from separateSystemMessage, which takes priority and is passed directly in each provider's implementation.
+	supportsTools: boolean, // we will just do a string of tool use if it doesn't support
+
+	// UNUSED (coming soon):
+	// TODO!!! think tokens - deepseek
+	_recognizedModelName: RecognizedModelName, // used to show user if model was auto-recognized
+	_supportsStreaming: boolean, // we will just dump the final result if doesn't support it
+	_supportsAutocompleteFIM: boolean, // we will just do a description of FIM if it doens't support <|fim_hole|>
+	_maxTokens: number, // required
+}
+
+export type DeveloperInfoAtProvider = {
+	overrideSettingsForAllModels?: Partial<DeveloperInfoAtModel>; // any overrides for models that a provider might have (e.g. if a provider always supports tool use, even if we don't recognize the model we can set tools to true)
+}
+
+
+
+
+
+export type VoidModelInfo = { // <-- 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)
 	isAutodetected?: boolean, // whether the model was autodetected by polling
+} & DeveloperInfoAtModel
+
+
+
+
+
+export const recognizedModels = [
+	// chat
+	'OpenAI 4o',
+	'Anthropic Claude',
+	'Llama 3.x',
+	'Deepseek Chat', // deepseek coder v2 is now merged into chat (V3) https://api-docs.deepseek.com/updates#deepseek-coder--deepseek-chat-upgraded-to-deepseek-v25-model
+	'xAI Grok',
+	// 'xAI Grok',
+	// 'Google Gemini, Gemma',
+	// 'Microsoft Phi4',
+
+
+	// coding (autocomplete)
+	'Alibaba Qwen2.5 Coder Instruct', // we recommend this over Qwen2.5
+	'Mistral Codestral',
+
+	// thinking
+	'OpenAI o1',
+	'Deepseek R1',
+
+	// general
+	// 'Mixtral 8x7b'
+	// 'Qwen2.5',
+
+] as const
+
+type RecognizedModelName = (typeof recognizedModels)[number] | '<GENERAL>'
+
+
+export function recognizedModelOfModelName(modelName: string): RecognizedModelName {
+	const lower = modelName.toLowerCase();
+
+	if (lower.includes('gpt-4o'))
+		return 'OpenAI 4o';
+	if (lower.includes('claude'))
+		return 'Anthropic Claude';
+	if (lower.includes('llama'))
+		return 'Llama 3.x';
+	if (lower.includes('qwen2.5-coder'))
+		return 'Alibaba Qwen2.5 Coder Instruct';
+	if (lower.includes('mistral'))
+		return 'Mistral Codestral';
+	if (/\bo1\b/.test(lower) || /\bo3\b/.test(lower)) // o1, o3
+		return 'OpenAI o1';
+	if (lower.includes('deepseek-r1') || lower.includes('deepseek-reasoner'))
+		return 'Deepseek R1';
+	if (lower.includes('deepseek'))
+		return 'Deepseek Chat'
+	if (lower.includes('grok'))
+		return 'xAI Grok'
+
+	return '<GENERAL>';
 }

+
+const developerInfoAtProvider: { [providerName in ProviderName]: DeveloperInfoAtProvider } = {
+	'anthropic': {
+		overrideSettingsForAllModels: {
+			supportsSystemMessage: true,
+			supportsTools: true,
+			_supportsAutocompleteFIM: false,
+			_supportsStreaming: true,
+		}
+	},
+	'deepseek': {
+		overrideSettingsForAllModels: {
+		}
+	},
+	'ollama': {
+	},
+	'openRouter': {
+	},
+	'openAICompatible': {
+	},
+	'openAI': {
+	},
+	'gemini': {
+	},
+	'mistral': {
+	},
+	'groq': {
+	},
+	'xAI': {
+	},
+	'vLLM': {
+	},
+}
+export const developerInfoOfProviderName = (providerName: ProviderName): Partial<DeveloperInfoAtProvider> => {
+	return developerInfoAtProvider[providerName] ?? {}
+}
+
+
+
+
+// providerName is optional, but gives some extra fallbacks if provided
+const developerInfoOfRecognizedModelName: { [recognizedModel in RecognizedModelName]: Omit<DeveloperInfoAtModel, '_recognizedModelName'> } = {
+	'OpenAI 4o': {
+		supportsSystemMessage: true,
+		supportsTools: true,
+		_supportsAutocompleteFIM: false,
+		_supportsStreaming: true,
+		_maxTokens: 4096,
+	},
+
+	'Anthropic Claude': {
+		supportsSystemMessage: true,
+		supportsTools: false,
+		_supportsAutocompleteFIM: false,
+		_supportsStreaming: false,
+		_maxTokens: 4096,
+	},
+
+	'Llama 3.x': {
+		supportsSystemMessage: true,
+		supportsTools: true,
+		_supportsAutocompleteFIM: false,
+		_supportsStreaming: false,
+		_maxTokens: 4096,
+	},
+
+	'xAI Grok': {
+		supportsSystemMessage: true,
+		supportsTools: true,
+		_supportsAutocompleteFIM: false,
+		_supportsStreaming: true,
+		_maxTokens: 4096,
+
+	},
+
+	'Deepseek Chat': {
+		supportsSystemMessage: true,
+		supportsTools: false,
+		_supportsAutocompleteFIM: false,
+		_supportsStreaming: false,
+		_maxTokens: 4096,
+	},
+
+	'Alibaba Qwen2.5 Coder Instruct': {
+		supportsSystemMessage: true,
+		supportsTools: true,
+		_supportsAutocompleteFIM: false,
+		_supportsStreaming: false,
+		_maxTokens: 4096,
+	},
+
+	'Mistral Codestral': {
+		supportsSystemMessage: true,
+		supportsTools: true,
+		_supportsAutocompleteFIM: false,
+		_supportsStreaming: false,
+		_maxTokens: 4096,
+	},
+
+	'OpenAI o1': {
+		supportsSystemMessage: 'developer',
+		supportsTools: false,
+		_supportsAutocompleteFIM: false,
+		_supportsStreaming: true,
+		_maxTokens: 4096,
+	},
+
+	'Deepseek R1': {
+		supportsSystemMessage: false,
+		supportsTools: false,
+		_supportsAutocompleteFIM: false,
+		_supportsStreaming: false,
+		_maxTokens: 4096,
+	},
+
+
+	'<GENERAL>': {
+		supportsSystemMessage: false,
+		supportsTools: false,
+		_supportsAutocompleteFIM: false,
+		_supportsStreaming: false,
+		_maxTokens: 4096,
+	},
+}
+export const developerInfoOfModelName = (modelName: string, overrides?: Partial<DeveloperInfoAtModel>): DeveloperInfoAtModel => {
+	const recognizedModelName = recognizedModelOfModelName(modelName)
+	return {
+		_recognizedModelName: recognizedModelName,
+		...developerInfoOfRecognizedModelName[recognizedModelName],
+		...overrides
+	}
+}
+
+
+
+
+
+
 // creates `modelInfo` from `modelNames`
-export const modelInfoOfDefaultModelNames = (defaultModelNames: string[], options?: { isAutodetected: true, existingModels: VoidModelInfo[] }): VoidModelInfo[] => {
+export const modelInfoOfDefaultModelNames = (defaultModelNames: string[]): VoidModelInfo[] => {
+	return defaultModelNames.map((modelName, i) => ({
+		modelName,
+		isDefault: true,
+		isAutodetected: false,
+		isHidden: defaultModelNames.length >= 10, // hide all models if there are a ton of them, and make user enable them individually
+		...developerInfoOfModelName(modelName),
+	}))
+}

-	const { isAutodetected, existingModels } = options ?? {}
-
-	if (!existingModels) { // default settings
-
-		return defaultModelNames.map((modelName, i) => ({
-			modelName,
-			isDefault: true,
-			isAutodetected: isAutodetected,
-			isHidden: defaultModelNames.length >= 10 // hide all models if there are a ton of them, and make user enable them individually
-		}))
-
-	} else { // settings if there are existing models (keep existing `isHidden` property)
-
-		const existingModelsMap: Record<string, VoidModelInfo> = {}
-		for (const existingModel of existingModels) {
-			existingModelsMap[existingModel.modelName] = existingModel
-		}
-
-		return defaultModelNames.map((modelName, i) => ({
-			modelName,
-			isDefault: true,
-			isAutodetected: isAutodetected,
-			isHidden: !!existingModelsMap[modelName]?.isHidden,
-		}))
+export const modelInfoOfAutodetectedModelNames = (defaultModelNames: string[], options: { existingModels: VoidModelInfo[] }) => {
+	const { existingModels } = options

+	const existingModelsMap: Record<string, VoidModelInfo> = {}
+	for (const existingModel of existingModels) {
+		existingModelsMap[existingModel.modelName] = existingModel
 	}

+	return defaultModelNames.map((modelName, i) => ({
+		modelName,
+		isDefault: true,
+		isAutodetected: true,
+		isHidden: !!existingModelsMap[modelName]?.isHidden,
+		...developerInfoOfModelName(modelName)
+	}))
 }

+
+
+
+
 // https://docs.anthropic.com/en/docs/about-claude/models
 export const defaultAnthropicModels = modelInfoOfDefaultModelNames([
 	'claude-3-5-sonnet-20241022',
@ -115,6 +334,10 @@ export const defaultMistralModels = modelInfoOfDefaultModelNames([
 	"mistral-small-latest",
 ])

+export const defaultXAIModels = modelInfoOfDefaultModelNames([
+	'grok-2-latest',
+	'grok-3-latest',
+])
 // export const parseMaxTokensStr = (maxTokensStr: string) => {
 // 	// parse the string but only if the full string is a valid number, eg parseInt('100abc') should return NaN
 // 	const int = isNaN(Number(maxTokensStr)) ? undefined : parseInt(maxTokensStr)
@ -155,6 +378,9 @@ export const defaultProviderSettings = {
 	ollama: {
 		endpoint: 'http://127.0.0.1:11434',
 	},
+	vLLM: {
+		endpoint: 'http://localhost:8000',
+	},
 	openRouter: {
 		apiKey: '',
 	},
@ -170,13 +396,16 @@ export const defaultProviderSettings = {
 	},
 	mistral: {
 		apiKey: ''
-	}
+	},
+	xAI: {
+		apiKey: ''
+	},
 } as const

 export type ProviderName = keyof typeof defaultProviderSettings
 export const providerNames = Object.keys(defaultProviderSettings) as ProviderName[]

-export const localProviderNames = ['ollama'] satisfies ProviderName[] // all local names
+export const localProviderNames = ['ollama', 'vLLM'] satisfies ProviderName[] // all local names
 export const nonlocalProviderNames = providerNames.filter((name) => !(localProviderNames as string[]).includes(name)) // all non-local names

 type CustomSettingName = UnionOfKeys<typeof defaultProviderSettings[ProviderName]>
@ -238,7 +467,11 @@ export const displayInfoOfProviderName = (providerName: ProviderName): DisplayIn
 	else if (providerName === 'ollama') {
 		return {
 			title: 'Ollama',
-
+		}
+	}
+	else if (providerName === 'vLLM') {
+		return {
+			title: 'vLLM',
 		}
 	}
 	else if (providerName === 'openAICompatible') {
@ -261,6 +494,12 @@ export const displayInfoOfProviderName = (providerName: ProviderName): DisplayIn
 			title: 'Mistral API',
 		}
 	}
+	else if (providerName === 'xAI') {
+		return {
+			title: 'xAI API',
+		}
+	}
+

 	throw new Error(`descOfProviderName: Unknown provider name: "${providerName}"`)
 }
@ -285,7 +524,8 @@ export const displayInfoOfSettingName = (providerName: ProviderName, settingName
 								providerName === 'groq' ? 'gsk_key...' :
 									providerName === 'mistral' ? 'key...' :
 										providerName === 'openAICompatible' ? 'sk-key...' :
-											'',
+											providerName === 'xAI' ? 'xai-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).' :
@ -294,22 +534,26 @@ 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 === 'mistral' ? 'Get your [API Key here](https://console.mistral.ai/api-keys/).' :
-										providerName === 'openAICompatible' ? undefined :
-											'',
+										providerName === 'xAI' ? 'Get your [API Key here](https://console.x.ai).' :
+											providerName === 'openAICompatible' ? undefined :
+												'',
 		}
 	}
 	else if (settingName === 'endpoint') {
 		return {
 			title: providerName === 'ollama' ? 'Endpoint' :
-				providerName === 'openAICompatible' ? 'baseURL' // (do not include /chat/completions)
-					: '(never)',
+				providerName === 'vLLM' ? 'Endpoint' :
+					providerName === 'openAICompatible' ? 'baseURL' :// (do not include /chat/completions)
+						'(never)',

 			placeholder: providerName === 'ollama' ? defaultProviderSettings.ollama.endpoint
-				: providerName === 'openAICompatible' ? 'https://my-website.com/v1'
-					: '(never)',
+				: providerName === 'vLLM' ? defaultProviderSettings.vLLM.endpoint
+					: providerName === 'openAICompatible' ? 'https://my-website.com/v1'
+						: '(never)',

 			subTextMd: providerName === 'ollama' ? 'If you would like to change this endpoint, please read more about [Endpoints here](https://github.com/ollama/ollama/blob/main/docs/faq.md#how-can-i-expose-ollama-on-my-network).' :
-				undefined,
+				providerName === 'vLLM' ? 'If you would like to change this endpoint, please read more about [Endpoints here](https://docs.vllm.ai/en/latest/getting_started/quickstart.html#openai-compatible-server).' :
+					undefined,
 		}
 	}
 	else if (settingName === '_didFillInProviderSettings') {
@ -352,6 +596,9 @@ export const voidInitModelOptions = {
 	ollama: {
 		models: [],
 	},
+	vLLM: {
+		models: [],
+	},
 	openRouter: {
 		models: [], // any string
 	},
@ -366,8 +613,11 @@ export const voidInitModelOptions = {
 	},
 	mistral: {
 		models: defaultMistralModels,
+	},
+	xAI: {
+		models: defaultXAIModels,
 	}
-}
+} satisfies Record<ProviderName, any>


 // used when waiting and for a type reference
@ -402,6 +652,12 @@ export const defaultSettingsOfProvider: SettingsOfProvider = {
 		...voidInitModelOptions.mistral,
 		_didFillInProviderSettings: undefined,
 	},
+	xAI: {
+		...defaultCustomSettings,
+		...defaultProviderSettings.xAI,
+		...voidInitModelOptions.xAI,
+		_didFillInProviderSettings: undefined,
+	},
 	groq: { // aggregator
 		...defaultCustomSettings,
 		...defaultProviderSettings.groq,
@ -426,6 +682,12 @@ export const defaultSettingsOfProvider: SettingsOfProvider = {
 		...voidInitModelOptions.ollama,
 		_didFillInProviderSettings: undefined,
 	},
+	vLLM: { // aggregator
+		...defaultCustomSettings,
+		...defaultProviderSettings.vLLM,
+		...voidInitModelOptions.vLLM,
+		_didFillInProviderSettings: undefined,
+	},
 }


@ -436,18 +698,20 @@ export const modelSelectionsEqual = (m1: ModelSelection, m2: ModelSelection) =>
 }

 // this is a state
-export const featureNames = ['Ctrl+L', 'Ctrl+K', 'Autocomplete', 'FastApply'] as const
+export const featureNames = ['Ctrl+L', 'Ctrl+K', 'Autocomplete', 'Apply'] as const
 export type ModelSelectionOfFeature = Record<(typeof featureNames)[number], ModelSelection | null>
 export type FeatureName = keyof ModelSelectionOfFeature

 export const displayInfoOfFeatureName = (featureName: FeatureName) => {
+	// editor:
 	if (featureName === 'Autocomplete')
 		return 'Autocomplete'
 	else if (featureName === 'Ctrl+K')
-		return 'Quick-Edit'
+		return 'Quick Edit'
+	// sidebar:
 	else if (featureName === 'Ctrl+L')
 		return 'Chat'
-	else if (featureName === 'FastApply')
+	else if (featureName === 'Apply')
 		return 'Apply'
 	else
 		throw new Error(`Feature Name ${featureName} not allowed`)
@ -528,77 +792,3 @@ export const globalSettingNames = Object.keys(defaultGlobalSettings) as GlobalSe



-
-
-
-export const recognizedModels = [
-
-	// chat
-	'OpenAI 4o',
-	'Anthropic Claude',
-	'Llama 3.x',
-	'Deepseek Chat', // deepseek coder v2 is now merged into chat (V3) https://api-docs.deepseek.com/updates#deepseek-coder--deepseek-chat-upgraded-to-deepseek-v25-model
-	// 'xAI Grok',
-	// 'Google Gemini, Gemma',
-	// 'Microsoft Phi4',
-
-
-	// coding (autocomplete)
-	'Alibaba Qwen2.5 Coder Instruct', // we recommend this over Qwen2.5
-	'Mistral Codestral',
-
-	// thinking
-	'OpenAI o1, o3',
-	'Deepseek R1',
-
-	// general
-	'<General>'
-	// 'Mixtral 8x7b'
-	// 'Qwen2.5',
-
-] as const
-
-
-
-
-type RecognizedModel = (typeof recognizedModels)[number]
-
-
-// const modelCapabilities: { [recognizedModel in RecognizedModel]: ({ }) => string } = {
-// 	'OpenAI 4o': {
-// 		template: ({ prefix, suffix, }: { prefix: string; suffix: string; }) => `\
-// `
-// 	}
-// }
-
-export function getRecognizedModel(modelName: string): RecognizedModel {
-	const lower = modelName.toLowerCase();
-
-	if (lower.includes('gpt-4o')) {
-		return 'OpenAI 4o';
-	}
-	if (lower.includes('claude')) {
-		return 'Anthropic Claude';
-	}
-	if (lower.includes('llama')) {
-		return 'Llama 3.x';
-	}
-	if (lower.includes('qwen2.5-coder')) {
-		return 'Alibaba Qwen2.5 Coder Instruct';
-	}
-	if (lower.includes('mistral')) {
-		return 'Mistral Codestral';
-	}
-	// Check for "o1" or "o3"
-	if (/\bo1\b/.test(lower) || /\bo3\b/.test(lower)) {
-		return 'OpenAI o1, o3';
-	}
-	if (lower.includes('deepseek-r1') || lower.includes('deepseek-reasoner')) {
-		return 'Deepseek R1';
-	}
-
-
-
-	// Fallback:
-	return '<General>';
-}
--- a/src/vs/workbench/contrib/void/electron-main/llmMessage/_old.ts
+++ b/src/vs/workbench/contrib/void/electron-main/llmMessage/_old.ts
@ -0,0 +1,96 @@
+// /*--------------------------------------------------------------------------------------
+//  *  Copyright 2025 Glass Devtools, Inc. All rights reserved.
+//  *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
+//  *--------------------------------------------------------------------------------------*/
+
+// import Groq from 'groq-sdk';
+// import { _InternalSendLLMChatMessageFnType } from '../../common/llmMessageTypes.js';
+
+// // Groq
+// export const sendGroqChat: _InternalSendLLMChatMessageFnType = async ({ messages, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter }) => {
+// 	let fullText = '';
+
+// 	const thisConfig = settingsOfProvider.groq
+
+// 	const groq = new Groq({
+// 		apiKey: thisConfig.apiKey,
+// 		dangerouslyAllowBrowser: true
+// 	});
+
+// 	await groq.chat.completions
+// 		.create({
+// 			messages: messages,
+// 			model: modelName,
+// 			stream: true,
+// 		})
+// 		.then(async response => {
+// 			_setAborter(() => response.controller.abort())
+// 			// when receive text
+// 			for await (const chunk of response) {
+// 				const newText = chunk.choices[0]?.delta?.content || '';
+// 				fullText += newText;
+// 				onText({ newText, fullText });
+// 			}
+
+// 			onFinalMessage({ fullText, tools: [] });
+// 		})
+// 		.catch(error => {
+// 			onError({ message: error + '', fullError: error });
+// 		})
+
+
+// };
+
+
+
+// /*--------------------------------------------------------------------------------------
+//  *  Copyright 2025 Glass Devtools, Inc. All rights reserved.
+//  *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
+//  *--------------------------------------------------------------------------------------*/
+
+// import { Mistral } from '@mistralai/mistralai';
+// import { _InternalSendLLMChatMessageFnType } from '../../common/llmMessageTypes.js';
+
+// // Mistral
+// export const sendMistralChat: _InternalSendLLMChatMessageFnType = async ({ messages, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter }) => {
+// 	let fullText = '';
+
+// 	const thisConfig = settingsOfProvider.mistral;
+
+// 	const mistral = new Mistral({
+// 		apiKey: thisConfig.apiKey,
+// 	})
+
+// 	await mistral.chat
+// 		.stream({
+// 			messages: messages,
+// 			model: modelName,
+// 			stream: true,
+// 		})
+// 		.then(async response => {
+// 			// Mistral has a really nonstandard API - no interrupt and weird stream types
+// 			_setAborter(() => { console.log('Mistral does not support interrupts! Further messages will just be ignored.') });
+// 			// when receive text
+// 			for await (const chunk of response) {
+// 				const c = chunk.data.choices[0].delta.content || ''
+// 				const newText = (
+// 					typeof c === 'string' ? c
+// 						: c?.map(c => c.type === 'text' ? c.text : c.type).join('\n')
+// 				)
+// 				fullText += newText;
+// 				onText({ newText, fullText });
+// 			}
+
+// 			onFinalMessage({ fullText, tools: [] });
+// 		})
+// 		.catch(error => {
+// 			onError({ message: error + '', fullError: error });
+// 		})
+// }
+
+
+
+
+
+
+
--- a/src/vs/workbench/contrib/void/electron-main/llmMessage/anthropic.ts
+++ b/src/vs/workbench/contrib/void/electron-main/llmMessage/anthropic.ts
@ -5,16 +5,18 @@

 import Anthropic from '@anthropic-ai/sdk';
 import { _InternalSendLLMChatMessageFnType } from '../../common/llmMessageTypes.js';
-import { anthropicMaxPossibleTokens } from '../../common/voidSettingsTypes.js';
+import { anthropicMaxPossibleTokens, developerInfoOfModelName, developerInfoOfProviderName } from '../../common/voidSettingsTypes.js';
 import { InternalToolInfo } from '../../common/toolsService.js';
+import { addSystemMessageAndToolSupport } from './preprocessLLMMessages.js';
+import { isAToolName } from './postprocessToolCalls.js';




-export const toAnthropicTool = (toolName: string, toolInfo: InternalToolInfo) => {
-	const { description, params, required } = toolInfo
+export const toAnthropicTool = (toolInfo: InternalToolInfo) => {
+	const { name, description, params, required } = toolInfo
 	return {
-		name: toolName,
+		name: name,
 		description: description,
 		input_schema: {
 			type: 'object',
@ -28,7 +30,7 @@ export const toAnthropicTool = (toolName: string, toolInfo: InternalToolInfo) =>



-export const sendAnthropicChat: _InternalSendLLMChatMessageFnType = ({ messages, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter }) => {
+export const sendAnthropicChat: _InternalSendLLMChatMessageFnType = ({ messages: messages_, providerName, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter, aiInstructions, tools: tools_ }) => {

 	const thisConfig = settingsOfProvider.anthropic

@ -38,14 +40,23 @@ export const sendAnthropicChat: _InternalSendLLMChatMessageFnType = ({ messages,
 		return
 	}

+	const { messages, separateSystemMessageStr } = addSystemMessageAndToolSupport(modelName, providerName, messages_, aiInstructions, { separateSystemMessage: true })
+
+	const { overrideSettingsForAllModels } = developerInfoOfProviderName(providerName)
+	const { supportsTools } = developerInfoOfModelName(modelName, overrideSettingsForAllModels)
+
 	const anthropic = new Anthropic({ apiKey: thisConfig.apiKey, dangerouslyAllowBrowser: true });

+	const tools = (supportsTools && ((tools_?.length ?? 0) !== 0)) ? tools_?.map(tool => toAnthropicTool(tool)) : undefined
+
 	const stream = anthropic.messages.stream({
-		// system: systemMessage,
+		system: separateSystemMessageStr,
 		messages: messages,
 		model: modelName,
 		max_tokens: maxTokens,
-	});
+		tools: tools,
+		tool_choice: tools ? { type: 'auto', disable_parallel_tool_use: true } : undefined // one tool use at a time
+	})


 	// when receive text
@ -53,11 +64,38 @@ export const sendAnthropicChat: _InternalSendLLMChatMessageFnType = ({ messages,
 		onText({ newText, fullText })
 	})

+
+	// // can do tool use 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
+	// 	}
+	// 	// TODO!!!!!
+	// 	// onText({})
+	// })
+
 	// when we get the final message on this stream (or when error/fail)
-	stream.on('finalMessage', (claude_response) => {
+	stream.on('finalMessage', (response) => {
 		// stringify the response's content
-		const content = claude_response.content.map(c => c.type === 'text' ? c.text : c.type).join('\n');
-		onFinalMessage({ fullText: content })
+		const content = response.content.map(c => c.type === 'text' ? c.text : '').join('\n\n')
+		const toolCalls = response.content
+			.map(c => {
+				if (c.type !== 'tool_use') return null
+				if (!isAToolName(c.name)) return null
+				return c.type === 'tool_use' ? { name: c.name, params: JSON.stringify(c.input), id: c.id } : null
+			})
+			.filter(t => !!t)
+
+		onFinalMessage({ fullText: content, toolCalls })
 	})

 	stream.on('error', (error) => {
--- a/src/vs/workbench/contrib/void/electron-main/llmMessage/gemini.ts
+++ b/src/vs/workbench/contrib/void/electron-main/llmMessage/gemini.ts
@ -1,43 +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 { Content, GoogleGenerativeAI } from '@google/generative-ai';
-import { _InternalSendLLMChatMessageFnType } from '../../common/llmMessageTypes.js';
-
-// Gemini
-export const sendGeminiChat: _InternalSendLLMChatMessageFnType = async ({ messages, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter }) => {
-
-	let fullText = ''
-
-	const thisConfig = settingsOfProvider.gemini
-
-	const genAI = new GoogleGenerativeAI(thisConfig.apiKey);
-	const model = genAI.getGenerativeModel({ model: modelName });
-
-	// Convert messages to Gemini format
-	const geminiMessages: Content[] = messages
-		.map((msg, i) => ({
-			parts: [{ text: msg.content }],
-			role: msg.role === 'assistant' ? 'model' : 'user'
-		}))
-
-	model.generateContentStream({
-		// systemInstruction: systemMessage,
-		contents: geminiMessages,
-	})
-		.then(async response => {
-			_setAborter(() => response.stream.return(fullText))
-
-			for await (const chunk of response.stream) {
-				const newText = chunk.text();
-				fullText += newText;
-				onText({ newText, fullText });
-			}
-			onFinalMessage({ fullText });
-		})
-		.catch((error) => {
-			onError({ message: error + '', fullError: error })
-		})
-}
--- a/src/vs/workbench/contrib/void/electron-main/llmMessage/groq.ts
+++ b/src/vs/workbench/contrib/void/electron-main/llmMessage/groq.ts
@ -1,42 +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 Groq from 'groq-sdk';
-import { _InternalSendLLMChatMessageFnType } from '../../common/llmMessageTypes.js';
-
-// Groq
-export const sendGroqChat: _InternalSendLLMChatMessageFnType = async ({ messages, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter }) => {
-	let fullText = '';
-
-	const thisConfig = settingsOfProvider.groq
-
-	const groq = new Groq({
-		apiKey: thisConfig.apiKey,
-		dangerouslyAllowBrowser: true
-	});
-
-	await groq.chat.completions
-		.create({
-			messages: messages,
-			model: modelName,
-			stream: true,
-		})
-		.then(async response => {
-			_setAborter(() => response.controller.abort())
-			// when receive text
-			for await (const chunk of response) {
-				const newText = chunk.choices[0]?.delta?.content || '';
-				fullText += newText;
-				onText({ newText, fullText });
-			}
-
-			onFinalMessage({ fullText });
-		})
-		.catch(error => {
-			onError({ message: error + '', fullError: error });
-		})
-
-
-};
--- a/src/vs/workbench/contrib/void/electron-main/llmMessage/mistral.ts
+++ b/src/vs/workbench/contrib/void/electron-main/llmMessage/mistral.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 { Mistral } from '@mistralai/mistralai';
-import { _InternalSendLLMChatMessageFnType } from '../../common/llmMessageTypes.js';
-
-// Mistral
-export const sendMistralChat: _InternalSendLLMChatMessageFnType = async ({ messages, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter }) => {
-	let fullText = '';
-
-	const thisConfig = settingsOfProvider.mistral;
-
-	const mistral = new Mistral({
-		apiKey: thisConfig.apiKey,
-	})
-
-	await mistral.chat
-		.stream({
-			messages: messages,
-			model: modelName,
-			stream: true,
-		})
-		.then(async response => {
-			// Mistral has a really nonstandard API - no interrupt and weird stream types
-			_setAborter(() => { console.log('Mistral does not support interrupts! Further messages will just be ignored.') });
-			// when receive text
-			for await (const chunk of response) {
-				const c = chunk.data.choices[0].delta.content || ''
-				const newText = (
-					typeof c === 'string' ? c
-						: c?.map(c => c.type === 'text' ? c.text : c.type).join('\n')
-				)
-				fullText += newText;
-				onText({ newText, fullText });
-			}
-
-			onFinalMessage({ fullText });
-		})
-		.catch(error => {
-			onError({ message: error + '', fullError: error });
-		})
-}
--- a/src/vs/workbench/contrib/void/electron-main/llmMessage/ollama.ts
+++ b/src/vs/workbench/contrib/void/electron-main/llmMessage/ollama.ts
@ -1,3 +1,4 @@
+
 /*--------------------------------------------------------------------------------------
 *  Copyright 2025 Glass Devtools, Inc. All rights reserved.
 *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
@ -38,80 +39,86 @@ export const ollamaList: _InternalModelListFnType<OllamaModelResponse> = async (
 }


-export const sendOllamaFIM: _InternalSendLLMFIMMessageFnType = ({ messages, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter }) => {
-
-	const thisConfig = settingsOfProvider.ollama
-	// if endpoint is empty, normally ollama will send to 11434, but we want it to fail - the user should type it in
-	if (!thisConfig.endpoint) throw new Error(`Ollama Endpoint was empty (please enter ${defaultProviderSettings.ollama.endpoint} if you want the default).`)
-
-	let fullText = ''
-
-	const ollama = new Ollama({ host: thisConfig.endpoint })
-
-	ollama.generate({
-		model: modelName,
-		prompt: messages.prefix,
-		suffix: messages.suffix,
-		options: {
-			stop: messages.stopTokens,
-			num_predict: 300, // max tokens
-			// repeat_penalty: 1,
-		},
-		raw: true,
-		stream: true,
-	})
-		.then(async stream => {
-			_setAborter(() => stream.abort())
-			// iterate through the stream
-			for await (const chunk of stream) {
-				const newText = chunk.response;
-				fullText += newText;
-				onText({ newText, fullText });
-			}
-			onFinalMessage({ fullText });
-		})
-		// when error/fail
-		.catch((error) => {
-			onError({ message: error + '', fullError: error })
-		})
-};


-// Ollama
-export const sendOllamaChat: _InternalSendLLMChatMessageFnType = ({ messages, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter }) => {
+// export const sendOllamaFIM: _InternalSendLLMFIMMessageFnType = ({ messages, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter }) => {

-	const thisConfig = settingsOfProvider.ollama
-	// if endpoint is empty, normally ollama will send to 11434, but we want it to fail - the user should type it in
-	if (!thisConfig.endpoint) throw new Error(`Ollama Endpoint was empty (please enter ${defaultProviderSettings.ollama.endpoint} if you want the default).`)
+// 	const thisConfig = settingsOfProvider.ollama
+// 	// if endpoint is empty, normally ollama will send to 11434, but we want it to fail - the user should type it in
+// 	if (!thisConfig.endpoint) throw new Error(`Ollama Endpoint was empty (please enter ${defaultProviderSettings.ollama.endpoint} if you want the default).`)

-	let fullText = ''
+// 	let fullText = ''

-	const ollama = new Ollama({ host: thisConfig.endpoint })
+// 	const ollama = new Ollama({ host: thisConfig.endpoint })

-	ollama.chat({
-		model: modelName,
-		messages: messages,
-		stream: true,
-		// options: { num_predict: parseMaxTokensStr(thisConfig.maxTokens) } // this is max_tokens
-	})
-		.then(async stream => {
-			_setAborter(() => stream.abort())
-			// iterate through the stream
-			for await (const chunk of stream) {
-				const newText = chunk.message.content;
-				fullText += newText;
-				onText({ newText, fullText });
-			}
-			onFinalMessage({ fullText });
+// 	ollama.generate({
+// 		model: modelName,
+// 		prompt: messages.prefix,
+// 		suffix: messages.suffix,
+// 		options: {
+// 			stop: messages.stopTokens,
+// 			num_predict: 300, // max tokens
+// 			// repeat_penalty: 1,
+// 		},
+// 		raw: true,
+// 		stream: true,
+// 	})
+// 		.then(async stream => {
+// 			_setAborter(() => stream.abort())
+// 			// iterate through the stream
+// 			for await (const chunk of stream) {
+// 				const newText = chunk.response;
+// 				fullText += newText;
+// 				onText({ newText, fullText });
+// 			}
+// 			onFinalMessage({ fullText, tools: [] });
+// 		})
+// 		// when error/fail
+// 		.catch((error) => {
+// 			onError({ message: error + '', fullError: error })
+// 		})
+// };

-		})
-		// when error/fail
-		.catch((error) => {
-			onError({ message: error + '', fullError: error })
-		})

-};
+// // Ollama
+// export const sendOllamaChat: _InternalSendLLMChatMessageFnType = ({ messages, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter }) => {
+
+// 	const thisConfig = settingsOfProvider.ollama
+// 	// if endpoint is empty, normally ollama will send to 11434, but we want it to fail - the user should type it in
+// 	if (!thisConfig.endpoint) throw new Error(`Ollama Endpoint was empty (please enter ${defaultProviderSettings.ollama.endpoint} if you want the default).`)
+
+// 	let fullText = ''
+
+// 	const ollama = new Ollama({ host: thisConfig.endpoint })
+
+// 	ollama.chat({
+// 		model: modelName,
+// 		messages: messages,
+// 		stream: true,
+// 		// options: { num_predict: parseMaxTokensStr(thisConfig.maxTokens) } // this is max_tokens
+// 	})
+// 		.then(async stream => {
+// 			_setAborter(() => stream.abort())
+// 			// iterate through the stream
+// 			for await (const chunk of stream) {
+// 				const newText = chunk.message.content;
+
+// 				// chunk.message.tool_calls[0].function.arguments
+
+// 				fullText += newText;
+// 				onText({ newText, fullText });
+// 			}
+
+// 			onFinalMessage({ fullText, tools: [] });
+
+// 		})
+// 		// when error/fail
+// 		.catch((error) => {
+// 			onError({ message: error + '', fullError: error })
+// 		})
+
+// };



-// ['codestral', 'qwen2.5-coder', 'qwen2.5-coder:0.5b', 'qwen2.5-coder:1.5b', 'qwen2.5-coder:3b', 'qwen2.5-coder:7b', 'qwen2.5-coder:14b', 'qwen2.5-coder:32b', 'codegemma', 'codegemma:2b', 'codegemma:7b', 'codellama', 'codellama:7b', 'codellama:13b', 'codellama:34b', 'codellama:70b', 'codellama:code', 'codellama:python', 'command-r', 'command-r:35b', 'command-r-plus', 'command-r-plus:104b', 'deepseek-coder-v2', 'deepseek-coder-v2:16b', 'deepseek-coder-v2:236b', 'falcon2', 'falcon2:11b', 'firefunction-v2', 'firefunction-v2:70b', 'gemma', 'gemma:2b', 'gemma:7b', 'gemma2', 'gemma2:2b', 'gemma2:9b', 'gemma2:27b', 'llama2', 'llama2:7b', 'llama2:13b', 'llama2:70b', 'llama3', 'llama3:8b', 'llama3:70b', 'llama3-chatqa', 'llama3-chatqa:8b', 'llama3-chatqa:70b', 'llama3-gradient', 'llama3-gradient:8b', 'llama3-gradient:70b', 'llama3.1', 'llama3.1:8b', 'llama3.1:70b', 'llama3.1:405b', 'llava', 'llava:7b', 'llava:13b', 'llava:34b', 'llava-llama3', 'llava-llama3:8b', 'llava-phi3', 'llava-phi3:3.8b', 'mistral', 'mistral:7b', 'mistral-large', 'mistral-large:123b', 'mistral-nemo', 'mistral-nemo:12b', 'mixtral', 'mixtral:8x7b', 'mixtral:8x22b', 'moondream', 'moondream:1.8b', 'openhermes', 'openhermes:v2.5', 'phi3', 'phi3:3.8b', 'phi3:14b', 'phi3.5', 'phi3.5:3.8b', 'qwen', 'qwen:7b', 'qwen:14b', 'qwen:32b', 'qwen:72b', 'qwen:110b', 'qwen2', 'qwen2:0.5b', 'qwen2:1.5b', 'qwen2:7b', 'qwen2:72b', 'smollm', 'smollm:135m', 'smollm:360m', 'smollm:1.7b',]
+// // ['codestral', 'qwen2.5-coder', 'qwen2.5-coder:0.5b', 'qwen2.5-coder:1.5b', 'qwen2.5-coder:3b', 'qwen2.5-coder:7b', 'qwen2.5-coder:14b', 'qwen2.5-coder:32b', 'codegemma', 'codegemma:2b', 'codegemma:7b', 'codellama', 'codellama:7b', 'codellama:13b', 'codellama:34b', 'codellama:70b', 'codellama:code', 'codellama:python', 'command-r', 'command-r:35b', 'command-r-plus', 'command-r-plus:104b', 'deepseek-coder-v2', 'deepseek-coder-v2:16b', 'deepseek-coder-v2:236b', 'falcon2', 'falcon2:11b', 'firefunction-v2', 'firefunction-v2:70b', 'gemma', 'gemma:2b', 'gemma:7b', 'gemma2', 'gemma2:2b', 'gemma2:9b', 'gemma2:27b', 'llama2', 'llama2:7b', 'llama2:13b', 'llama2:70b', 'llama3', 'llama3:8b', 'llama3:70b', 'llama3-chatqa', 'llama3-chatqa:8b', 'llama3-chatqa:70b', 'llama3-gradient', 'llama3-gradient:8b', 'llama3-gradient:70b', 'llama3.1', 'llama3.1:8b', 'llama3.1:70b', 'llama3.1:405b', 'llava', 'llava:7b', 'llava:13b', 'llava:34b', 'llava-llama3', 'llava-llama3:8b', 'llava-phi3', 'llava-phi3:3.8b', 'mistral', 'mistral:7b', 'mistral-large', 'mistral-large:123b', 'mistral-nemo', 'mistral-nemo:12b', 'mixtral', 'mixtral:8x7b', 'mixtral:8x22b', 'moondream', 'moondream:1.8b', 'openhermes', 'openhermes:v2.5', 'phi3', 'phi3:3.8b', 'phi3:14b', 'phi3.5', 'phi3.5:3.8b', 'qwen', 'qwen:7b', 'qwen:14b', 'qwen:32b', 'qwen:72b', 'qwen:110b', 'qwen2', 'qwen2:0.5b', 'qwen2:1.5b', 'qwen2:7b', 'qwen2:72b', 'smollm', 'smollm:135m', 'smollm:360m', 'smollm:1.7b',]
--- a/src/vs/workbench/contrib/void/electron-main/llmMessage/openai.ts
+++ b/src/vs/workbench/contrib/void/electron-main/llmMessage/openai.ts
@ -7,6 +7,9 @@ import OpenAI from 'openai';
 import { _InternalModelListFnType, _InternalSendLLMFIMMessageFnType, _InternalSendLLMChatMessageFnType } from '../../common/llmMessageTypes.js';
 import { Model } from 'openai/resources/models.js';
 import { InternalToolInfo } from '../../common/toolsService.js';
+import { addSystemMessageAndToolSupport } from './preprocessLLMMessages.js';
+import { developerInfoOfModelName, developerInfoOfProviderName } from '../../common/voidSettingsTypes.js';
+import { isAToolName } from './postprocessToolCalls.js';
 // import { parseMaxTokensStr } from './util.js';


@ -14,12 +17,12 @@ import { InternalToolInfo } from '../../common/toolsService.js';
 // prompting - https://platform.openai.com/docs/guides/reasoning#advice-on-prompting


-export const toOpenAITool = (toolName: string, toolInfo: InternalToolInfo) => {
-	const { description, params, required } = toolInfo
+export const toOpenAITool = (toolInfo: InternalToolInfo) => {
+	const { name, description, params, required } = toolInfo
 	return {
 		type: 'function',
 		function: {
-			name: toolName,
+			name: name,
 			description: description,
 			parameters: {
 				type: 'object',
@ -38,11 +41,25 @@ type NewParams = Pick<Parameters<_InternalSendLLMChatMessageFnType>[0] & Paramet
 const newOpenAI = ({ settingsOfProvider, providerName }: NewParams) => {

 	if (providerName === 'openAI') {
-		const thisConfig = settingsOfProvider.openAI
-		return new OpenAI({ apiKey: thisConfig.apiKey, dangerouslyAllowBrowser: true });
+		const thisConfig = settingsOfProvider[providerName]
+		return new OpenAI({
+			apiKey: thisConfig.apiKey, dangerouslyAllowBrowser: true
+		})
+	}
+	else if (providerName === 'ollama') {
+		const thisConfig = settingsOfProvider[providerName]
+		return new OpenAI({
+			baseURL: `${thisConfig.endpoint}/v1`, apiKey: 'noop', dangerouslyAllowBrowser: true,
+		})
+	}
+	else if (providerName === 'vLLM') {
+		const thisConfig = settingsOfProvider[providerName]
+		return new OpenAI({
+			baseURL: `${thisConfig.endpoint}/v1`, apiKey: 'noop', dangerouslyAllowBrowser: true,
+		})
 	}
 	else if (providerName === 'openRouter') {
-		const thisConfig = settingsOfProvider.openRouter
+		const thisConfig = settingsOfProvider[providerName]
 		return new OpenAI({
 			baseURL: 'https://openrouter.ai/api/v1', apiKey: thisConfig.apiKey, dangerouslyAllowBrowser: true,
 			defaultHeaders: {
@ -51,22 +68,45 @@ const newOpenAI = ({ settingsOfProvider, providerName }: NewParams) => {
 			},
 		})
 	}
+	else if (providerName === 'gemini') {
+		const thisConfig = settingsOfProvider[providerName]
+		return new OpenAI({
+			baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai', apiKey: thisConfig.apiKey, dangerouslyAllowBrowser: true,
+		})
+	}
 	else if (providerName === 'deepseek') {
-		const thisConfig = settingsOfProvider.deepseek
+		const thisConfig = settingsOfProvider[providerName]
 		return new OpenAI({
 			baseURL: 'https://api.deepseek.com/v1', apiKey: thisConfig.apiKey, dangerouslyAllowBrowser: true,
 		})
-
 	}
 	else if (providerName === 'openAICompatible') {
-		const thisConfig = settingsOfProvider.openAICompatible
+		const thisConfig = settingsOfProvider[providerName]
 		return new OpenAI({
-			baseURL: thisConfig.endpoint, apiKey: thisConfig.apiKey, dangerouslyAllowBrowser: true
+			baseURL: thisConfig.endpoint, apiKey: thisConfig.apiKey, dangerouslyAllowBrowser: true,
+		})
+	}
+	else if (providerName === 'mistral') {
+		const thisConfig = settingsOfProvider[providerName]
+		return new OpenAI({
+			baseURL: 'https://api.mistral.ai/v1', apiKey: thisConfig.apiKey, dangerouslyAllowBrowser: true,
+		})
+	}
+	else if (providerName === 'groq') {
+		const thisConfig = settingsOfProvider[providerName]
+		return new OpenAI({
+			baseURL: 'https://api.groq.com/openai/v1', apiKey: thisConfig.apiKey, dangerouslyAllowBrowser: true,
+		})
+	}
+	else if (providerName === 'xAI') {
+		const thisConfig = settingsOfProvider[providerName]
+		return new OpenAI({
+			baseURL: 'https://api.x.ai/v1', apiKey: thisConfig.apiKey, dangerouslyAllowBrowser: true,
 		})
 	}
 	else {
-		console.error(`sendOpenAIMsg: invalid providerName: ${providerName}`)
-		throw new Error(`providerName was invalid: ${providerName}`)
+		console.error(`sendOpenAICompatibleMsg: invalid providerName: ${providerName}`)
+		throw new Error(`Void providerName was invalid: ${providerName}`)
 	}
 }

@ -111,40 +151,71 @@ export const sendOpenAIFIM: _InternalSendLLMFIMMessageFnType = ({ messages, onTe

 	// openai.completions has a FIM parameter called `suffix`, but it's deprecated and only works for ~GPT 3 era models

-	onFinalMessage({ fullText: 'TODO' })
+

 }



 // OpenAI, OpenRouter, OpenAICompatible
-export const sendOpenAIChat: _InternalSendLLMChatMessageFnType = ({ messages, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter, providerName }) => {
+export const sendOpenAIChat: _InternalSendLLMChatMessageFnType = ({ messages: messages_, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter, providerName, aiInstructions, tools: tools_ }) => {

 	let fullText = ''
+	const toolCallOfIndex: { [index: string]: { name: string, params: string, id: string } } = {}
+
+	const { overrideSettingsForAllModels } = developerInfoOfProviderName(providerName)
+	const { supportsTools } = developerInfoOfModelName(modelName, overrideSettingsForAllModels)
+
+	const { messages } = addSystemMessageAndToolSupport(modelName, providerName, messages_, aiInstructions, { separateSystemMessage: false })
+
+	const tools = (supportsTools && ((tools_?.length ?? 0) !== 0)) ? tools_?.map(tool => toOpenAITool(tool)) : undefined

 	const openai: OpenAI = newOpenAI({ providerName, settingsOfProvider })
 	const options: OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming = {
 		model: modelName,
 		messages: messages,
 		stream: true,
-		// tools: Object.keys(contextTools).map(name => toOpenAITool(name, contextTools[name as ContextToolName])),
+		tools: tools,
+		tool_choice: tools ? 'auto' : undefined,
+		parallel_tool_calls: tools ? false : undefined,
 	}

 	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: '', params: '', id: '' }
+					toolCallOfIndex[index].name += tool.function?.name ?? ''
+					toolCallOfIndex[index].params += tool.function?.arguments ?? '';
+					toolCallOfIndex[index].id = tool.id ?? ''
+
+				}
+
+				// message
 				let newText = ''
-				newText += chunk.choices[0]?.delta?.tool_calls?.[0]?.function?.name ?? ''
-				newText += chunk.choices[0]?.delta?.tool_calls?.[0]?.function?.arguments ?? ''
 				newText += chunk.choices[0]?.delta?.content ?? ''
 				fullText += newText;
+
 				onText({ newText, fullText });
 			}
-			onFinalMessage({ fullText });
+			onFinalMessage({
+				fullText,
+				toolCalls: Object.keys(toolCallOfIndex)
+					.map(index => {
+						const tool = toolCallOfIndex[index]
+						if (isAToolName(tool.name))
+							return { name: tool.name, id: tool.id, params: tool.params }
+						return null
+					})
+					.filter(t => !!t)
+			});
 		})
 		// when error/fail - this catches errors of both .create() and .then(for await)
 		.catch(error => {
@ -156,4 +227,4 @@ export const sendOpenAIChat: _InternalSendLLMChatMessageFnType = ({ messages, on
 			}
 		})

-};
+}
--- a/src/vs/workbench/contrib/void/electron-main/llmMessage/postprocessToolCalls.ts
+++ b/src/vs/workbench/contrib/void/electron-main/llmMessage/postprocessToolCalls.ts
@ -0,0 +1,10 @@
+import { ToolName, toolNames } from '../../common/toolsService.js';
+
+
+
+const toolNamesSet = new Set<string>(toolNames)
+
+export const isAToolName = (toolName: string): toolName is ToolName => {
+	const isAToolName = toolNamesSet.has(toolName)
+	return isAToolName
+}
--- a/src/vs/workbench/contrib/void/electron-main/llmMessage/preprocessLLMMessages.ts
+++ b/src/vs/workbench/contrib/void/electron-main/llmMessage/preprocessLLMMessages.ts
@ -0,0 +1,303 @@
+
+
+import { LLMChatMessage } from '../../common/llmMessageTypes.js';
+import { developerInfoOfModelName, developerInfoOfProviderName, ProviderName } from '../../common/voidSettingsTypes.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 {}
+}
+
+// no matter whether the model supports a system message or not (or what format it supports), add it in some way
+// also take into account tools if the model doesn't support tool use
+export const addSystemMessageAndToolSupport = (modelName: string, providerName: ProviderName, messages_: LLMChatMessage[], aiInstructions: string, { separateSystemMessage }: { separateSystemMessage: boolean }): { separateSystemMessageStr?: string, messages: any[] } => {
+
+	const messages = deepClone(messages_).map(m => ({ ...m, content: m.content.trim(), }))
+
+	const { overrideSettingsForAllModels } = developerInfoOfProviderName(providerName)
+	const { supportsSystemMessage, supportsTools } = developerInfoOfModelName(modelName, overrideSettingsForAllModels)
+
+	// 1. SYSTEM MESSAGE
+	// 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: (LLMChatMessage | { role: 'developer', content: string })[] = messages.filter(msg => msg.role !== 'system')
+
+
+	// if (!supportsTools) {
+	// 	if (!systemMessageStr) systemMessageStr = ''
+	// 	systemMessageStr += '' // TODO!!! add tool use system message here
+	// }
+
+
+	if (systemMessageStr) {
+		// if supports system message
+		if (supportsSystemMessage) {
+			if (separateSystemMessage)
+				separateSystemMessageStr = systemMessageStr
+			else {
+				newMessages.unshift({ role: supportsSystemMessage === 'developer' ? 'developer' : 'system', content: systemMessageStr }) // add new first message
+			}
+		}
+		// if does not support system message
+		else {
+			if (supportsSystemMessage) {
+				if (newMessages.length === 0)
+					newMessages.push({ role: 'user', content: systemMessageStr })
+				// add system mesasges to first message (should be a user 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
+				}
+			}
+		}
+	}
+
+
+
+
+
+
+	// 2. MAKE TOOLS FORMAT CORRECT in messages
+	let finalMessages: any[]
+	if (!supportsTools) {
+		// do nothing
+		finalMessages = newMessages
+	}
+
+	// 	anthropic assistant message will have: https://docs.anthropic.com/en/docs/build-with-claude/tool-use#tool-use-examples
+	// 	"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 user message response will be:
+	// 	"content": [
+	// 		{
+	// 			"type": "tool_result",
+	// 			"tool_use_id": "toolu_01A09q90qw90lq917835lq9",
+	// 			"content": "15 degrees"
+	// 		}
+	// 	]
+
+
+	else if (providerName === 'anthropic') { // convert role:'tool' to anthropic's type
+		const newMessagesTools: (
+			Exclude<typeof newMessages[0], { role: 'assistant' | 'user' }> | {
+				role: 'assistant',
+				content: string | ({
+					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;
+				})[]
+			}
+		)[] = newMessages;
+
+
+		for (let i = 0; i < newMessagesTools.length; i += 1) {
+			const currMsg = newMessagesTools[i]
+
+			if (currMsg.role !== 'tool') continue
+
+			const prevMsg = 0 <= i - 1 && i - 1 <= newMessagesTools.length ? newMessagesTools[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
+			newMessagesTools[i] = {
+				role: 'user',
+				content: [
+					...[{ type: 'tool_result', tool_use_id: currMsg.id, content: currMsg.content }] as const,
+					...currMsg.content ? [{ type: 'text', text: currMsg.content }] as const : [],
+				]
+			}
+		}
+
+		finalMessages = newMessagesTools
+	}
+
+	// openai assistant message will have: https://platform.openai.com/docs/guides/function-calling#function-calling-steps
+	// "tool_calls":[
+	// {
+	// "type": "function",
+	// "id": "call_12345xyz",
+	// "function": {
+	// "name": "get_weather",
+	// "arguments": "{\"latitude\":48.8566,\"longitude\":2.3522}"
+	// }
+	// }]
+
+	// openai user response will be:
+	// {
+	// "role": "tool",
+	// "tool_call_id": tool_call.id,
+	// "content": str(result)
+	// }
+
+	// treat all other providers like openai tool message for now
+	else {
+
+		const newMessagesTools: (
+			Exclude<typeof newMessages[0], { role: 'assistant' | 'tool' }> | {
+				role: 'assistant',
+				content: string;
+				tool_calls?: {
+					type: 'function';
+					id: string;
+					function: {
+						name: string;
+						arguments: string;
+					}
+				}[]
+			} | {
+				role: 'tool',
+				id: string; // old val
+				tool_call_id: string; // new val
+				content: string;
+			}
+		)[] = [];
+
+		for (let i = 0; i < newMessages.length; i += 1) {
+			const currMsg = newMessages[i]
+
+			if (currMsg.role !== 'tool') {
+				newMessagesTools.push(currMsg)
+				continue
+			}
+
+			// edit previous assistant message to have called the tool
+			const prevMsg = 0 <= i - 1 && i - 1 <= newMessagesTools.length ? newMessagesTools[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
+			newMessagesTools.push({
+				role: 'tool',
+				id: currMsg.id,
+				content: currMsg.content,
+				tool_call_id: currMsg.id,
+			})
+		}
+		finalMessages = newMessagesTools
+	}
+
+
+
+
+	// 3. CROP MESSAGES SO EVERYTHING FITS IN CONTEXT
+	// TODO!!!
+
+
+	console.log('SYSMG', separateSystemMessage)
+	console.log('FINAL MESSAGES', JSON.stringify(finalMessages, null, 2))
+
+
+	return {
+		separateSystemMessageStr,
+		messages: finalMessages,
+	}
+}
+
+
+
+
+
+
+/*
+
+
+ACCORDING TO 4o: gemini: similar to openai, but function_call, and only 1 call per message (no id because only 1 message)
+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"
+}
+}
+}
+
+
+ anthropic
+
+ openai-compat (4)
+ gemini
+
+ollama
+
+
+mistral: same as openai
+
+*/
--- a/src/vs/workbench/contrib/void/electron-main/llmMessage/sendLLMMessage.ts
+++ b/src/vs/workbench/contrib/void/electron-main/llmMessage/sendLLMMessage.ts
@ -3,50 +3,12 @@
 *  Licensed under the Apache License, Version 2.0. See LICENSE.txt for more information.
 *--------------------------------------------------------------------------------------*/

-import { SendLLMMessageParams, OnText, OnFinalMessage, OnError, LLMChatMessage, _InternalLLMChatMessage } from '../../common/llmMessageTypes.js';
+import { SendLLMMessageParams, OnText, OnFinalMessage, OnError } from '../../common/llmMessageTypes.js';
 import { IMetricsService } from '../../common/metricsService.js';
-
-import { sendAnthropicChat } from './anthropic.js';
-import { sendOllamaFIM, sendOllamaChat } from './ollama.js';
-import { sendOpenAIChat, sendOpenAIFIM } from './openai.js';
-import { sendGeminiChat } from './gemini.js';
-import { sendGroqChat } from './groq.js';
-import { sendMistralChat } from './mistral.js';
 import { displayInfoOfProviderName } from '../../common/voidSettingsTypes.js';

-
-const cleanChatMessages = (messages: LLMChatMessage[]): _InternalLLMChatMessage[] => {
-	// trim message content (Anthropic and other providers give an error if there is trailing whitespace)
-	messages = messages.map(m => ({ ...m, content: m.content.trim() }))
-
-	// find system messages and concatenate them
-	const systemMessage = messages
-		.filter(msg => msg.role === 'system')
-		.map(msg => msg.content)
-		.join('\n') || undefined;
-
-	// remove all system messages
-	const noSystemMessages = messages
-		.filter(msg => msg.role !== 'system') as _InternalLLMChatMessage[]
-
-	// add system mesasges to first message (should be a user message)
-	if (systemMessage && (noSystemMessages.length !== 0)) {
-		const newFirstMessage = {
-			role: noSystemMessages[0].role,
-			content: (''
-				+ '<SYSTEM_MESSAGE>\n'
-				+ systemMessage
-				+ '\n'
-				+ '</SYSTEM_MESSAGE>\n'
-				+ noSystemMessages[0].content
-			)
-		}
-		noSystemMessages.splice(0, 1) // delete first message
-		noSystemMessages.unshift(newFirstMessage) // add new first message
-	}
-
-	return noSystemMessages
-}
+import { sendAnthropicChat } from './anthropic.js';
+import { sendOpenAIChat } from './openai.js';


 export const sendLLMMessage = ({
@ -61,18 +23,12 @@ export const sendLLMMessage = ({
 	settingsOfProvider,
 	providerName,
 	modelName,
+	tools,
 }: SendLLMMessageParams,

 	metricsService: IMetricsService
 ) => {

-	let messagesArr: _InternalLLMChatMessage[] = []
-	if (messagesType === 'chatMessages') {
-		messagesArr = cleanChatMessages([
-			{ role: 'system', content: aiInstructions },
-			...messages_
-		])
-	}

 	// only captures number of messages and message "shape", no actual code, instructions, prompts, etc
 	const captureLLMEvent = (eventId: string, extras?: object) => {
@ -80,8 +36,8 @@ export const sendLLMMessage = ({
 			providerName,
 			modelName,
 			...messagesType === 'chatMessages' ? {
-				numMessages: messagesArr?.length,
-				messagesShape: messagesArr?.map(msg => ({ role: msg.role, length: msg.content.length })),
+				numMessages: messages_?.length,
+				messagesShape: messages_?.map(msg => ({ role: msg.role, length: msg.content.length })),
 				origNumMessages: messages_?.length,
 				origMessagesShape: messages_?.map(msg => ({ role: msg.role, length: msg.content.length })),

@ -106,10 +62,10 @@ export const sendLLMMessage = ({
 		_fullTextSoFar = fullText
 	}

-	const onFinalMessage: OnFinalMessage = ({ fullText }) => {
+	const onFinalMessage: OnFinalMessage = ({ fullText, toolCalls }) => {
 		if (_didAbort) return
 		captureLLMEvent(`${loggingName} - Received Full Message`, { messageLength: fullText.length, duration: new Date().getMilliseconds() - submit_time.getMilliseconds() })
-		onFinalMessage_({ fullText })
+		onFinalMessage_({ fullText, toolCalls })
 	}

 	const onError: OnError = ({ message: error, fullError }) => {
@ -132,7 +88,10 @@ export const sendLLMMessage = ({
 	}
 	abortRef_.current = onAbort

-	captureLLMEvent(`${loggingName} - Sending Message`, { messageLength: messagesArr[messagesArr.length - 1]?.content.length })
+	if (messagesType === 'chatMessages')
+		captureLLMEvent(`${loggingName} - Sending Message`, { messageLength: messages_[messages_.length - 1]?.content.length })
+	else if (messagesType === 'FIMMessage')
+		captureLLMEvent(`${loggingName} - Sending FIM`, {}) // TODO!!! add more metrics

 	try {
 		switch (providerName) {
@ -140,28 +99,18 @@ export const sendLLMMessage = ({
 			case 'openRouter':
 			case 'deepseek':
 			case 'openAICompatible':
-				if (messagesType === 'FIMMessage') sendOpenAIFIM({ messages: messages_, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter, providerName });
-				else /*                         */ sendOpenAIChat({ messages: messagesArr, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter, providerName });
-				break;
+			case 'mistral':
 			case 'ollama':
-				if (messagesType === 'FIMMessage') sendOllamaFIM({ messages: messages_, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter, providerName })
-				else /*                         */ sendOllamaChat({ messages: messagesArr, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter, providerName })
+			case 'vLLM':
+			case 'groq':
+			case 'gemini':
+			case 'xAI':
+				if (messagesType === 'FIMMessage') onFinalMessage({ fullText: 'TODO - OpenAI API FIM', toolCalls: [] })
+				else /*                         */ sendOpenAIChat({ messages: messages_, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter, providerName, aiInstructions, tools });
 				break;
 			case 'anthropic':
-				if (messagesType === 'FIMMessage') onFinalMessage({ fullText: 'TODO - Anthropic FIM' })
-				else /*                         */ sendAnthropicChat({ messages: messagesArr, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter, providerName });
-				break;
-			case 'gemini':
-				if (messagesType === 'FIMMessage') onFinalMessage({ fullText: 'TODO - Gemini FIM' })
-				else /*                         */ sendGeminiChat({ messages: messagesArr, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter, providerName });
-				break;
-			case 'groq':
-				if (messagesType === 'FIMMessage') onFinalMessage({ fullText: 'TODO - Groq FIM' })
-				else /*                         */ sendGroqChat({ messages: messagesArr, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter, providerName });
-				break;
-			case 'mistral':
-				if (messagesType === 'FIMMessage') onFinalMessage({ fullText: 'TODO - Mistral FIM' })
-				else /*                         */ sendMistralChat({ messages: messagesArr, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter, providerName });
+				if (messagesType === 'FIMMessage') onFinalMessage({ fullText: 'TODO - Anthropic FIM', toolCalls: [] })
+				else /*                         */ sendAnthropicChat({ messages: messages_, onText, onFinalMessage, onError, settingsOfProvider, modelName, _setAborter, providerName, aiInstructions, tools });
 				break;
 			default:
 				onError({ message: `Error: Void provider was "${providerName}", which is not recognized.`, fullError: null })
--- a/src/vs/workbench/contrib/void/electron-main/llmMessageChannel.ts
+++ b/src/vs/workbench/contrib/void/electron-main/llmMessageChannel.ts
@ -100,7 +100,7 @@ export class LLMMessageChannel implements IServerChannel {
 		const mainThreadParams: SendLLMMessageParams = {
 			...params,
 			onText: ({ newText, fullText }) => { this._onText_llm.fire({ requestId, newText, fullText }); },
-			onFinalMessage: ({ fullText }) => { this._onFinalMessage_llm.fire({ requestId, fullText }); },
+			onFinalMessage: ({ fullText, toolCalls }) => { this._onFinalMessage_llm.fire({ requestId, fullText, toolCalls }); },
 			onError: ({ message: error, fullError }) => { console.log('sendLLM: firing err'); this._onError_llm.fire({ requestId, message: error, fullError }); },
 			abortRef: this._abortRefOfRequestId_llm[requestId],
 		}
--- a/src/vs/workbench/contrib/void/electron-main/templates/templates.ts
+++ b/src/vs/workbench/contrib/void/electron-main/templates/templates.ts
@ -1,13 +0,0 @@
-/*
-
-modelName -> {
-	system_message_type: 'system' | 'developer' (openai) | null // if null, we will just do a string of system message
-	supports_tools: boolean // we will just do a string of tool use if it doesn't support
-	supports_autocomplete_FIM (suffix) // we will just do a description of FIM if it doens't support <|fim_hole|>
-
-	supports_streaming: boolean // (o1 does NOT) we will just dump the final result if doesn't support it
-	max_tokens: number // required, DEFAULT is Infinity
-
-}
-
-*/