fix(web_search): gate web tools on model SIZE, not coder-ness (fixes Auto->llama3)

Testing "check online ... SpaceX IPO" in AUTO mode surfaced a distinct bug from
the qwen2.5-coder path. Auto resolved to a capable GENERAL model (llama3:8b),
which was DENIED web_search and fell back to stale training knowledge:

  Search the web "SpaceX IPO date"
  Error: The web_search tool isn't available for this model. Use one of: read_file, ...
  -> "SpaceX has not gone public through an IPO..."  (WRONG)

Root cause: web tools (web_search/browse_url) were gated on isCapableLocalCoder
-- a CODER >=7B (codingModelScoreBonus>=25 AND >=7B). llama3:8b is capable but
not a coder, so it got the COMPACT toolset (no web). Web search is a GENERAL
capability, not coding-specific -- any sufficiently large local model should
have it.

Fix: new size-only gate isCapableLocalModel (>=7B, or unnumbered/flagship tag),
used for the web-tool toolset decision at BOTH the prompt catalog
(convertToLLMMessageService) AND the execution chokepoint (chatThreadService).
Renamed the threaded toolset boolean isCapableLocalCoder -> isCapableLocalModel
through prompts.ts/chatThreadService/convertToLLMMessageService for honesty;
isCapableLocalCoder the FUNCTION stays (onboarding/routing still want a coder).

Live-verified over CDP (fresh thread each, real chat):
- Auto -> qwen2.5-coder:7b (7.6B): gate true, answers "June 12, 2026" correctly.
- llama3:latest (8.0B, GENERAL, the original failure): gate now true at BOTH the
  chokepoint and the prompt; searches "SpaceX IPO date" (5 results) and answers
  "Based on the search results ... IPO on June 12, 2026 ... ticker SPCX." CORRECT.
- llama3.2:3b (3.2B): gate correctly FALSE -- small models stay web-less.

909->913 node tests (+4 isCapableLocalModel cases incl. the llama3:8b regression),
tsgo 0.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: Tajudeen

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

@@ -12,7 +12,7 @@ import { URI } from '../../../../base/common/uri.js';
 import { Emitter, Event } from '../../../../base/common/event.js';
 import { ILLMMessageService } from '../common/sendLLMMessageService.js';
 import { chat_userMessageContent, isABuiltinToolName, builtinToolNames, localToolsetFor, READ_ONLY_SUBAGENT_TOOLS } from '../common/prompt/prompts.js';
-import { isCapableLocalCoder } from '../common/routing/codingModelScore.js';
+import { isCapableLocalModel } from '../common/routing/codingModelScore.js';
 import { AnthropicReasoning, getErrorMessage, RawToolCallObj, RawToolParamsObj } from '../common/sendLLMMessageTypes.js';
 import { generateUuid } from '../../../../base/common/uuid.js';
 import { ChatMode, FeatureName, ModelSelection, ModelSelectionOptions, ProviderName, localProviderNames, isAutoModelSelection } from '../common/cortexideSettingsTypes.js';
@@ -2344,7 +2344,7 @@ Output ONLY the JSON, no other text. Start with { and end with }.`
 		opts: { preapproved: true, unvalidatedToolParams: RawToolParamsObj, validatedParams: ToolCallParams<ToolName> } | { preapproved: false, unvalidatedToolParams: RawToolParamsObj },
 		isLocal: boolean = false,
 		chatMode: ChatMode = 'agent',
-		isCapableLocalCoder: boolean = false,
+		isCapableLocalModel: boolean = false,
 	): Promise<{ awaitingUserApproval?: boolean, interrupted?: boolean, completionSignaled?: boolean }> => {
 
 		// compute these below
@@ -2633,7 +2633,7 @@ Output ONLY the JSON, no other text. Start with { and end with }.`
 				// Hard curation for local/weak models: even if a non-curated tool (web_search, terminals, ...)
 				// slipped past the catalog and was parsed, do NOT execute it — return a recoverable result so a
 				// weak model can't get distracted by tools it shouldn't use.
-				const localSet = localToolsetFor(isCapableLocalCoder)
+				const localSet = localToolsetFor(isCapableLocalModel)
 				if (isLocal && !(localSet as Set<string>).has(toolName)) {
 					throw new Error(`The ${toolName} tool isn't available for this model. Use one of: ${[...localSet].join(', ')}.`)
 				}
@@ -2680,7 +2680,7 @@ Output ONLY the JSON, no other text. Start with { and end with }.`
 					// instead of the misleading raw "MCP tool X not found".
 					// List the tools the model was actually OFFERED (curated for local models), so this
 					// error doesn't re-introduce the tools curation deliberately hid from a weak model.
-					const offered = isLocal ? [...localToolsetFor(isCapableLocalCoder)] : [...builtinToolNames, ...(mcpTools?.map(t => t.name) ?? [])]
+					const offered = isLocal ? [...localToolsetFor(isCapableLocalModel)] : [...builtinToolNames, ...(mcpTools?.map(t => t.name) ?? [])]
 					throw new Error(`No tool named "${toolName}". Use one of the available tools: ${offered.join(', ')}`)
 				}
 
@@ -3265,7 +3265,7 @@ Output ONLY the JSON, no other text. Start with { and end with }.`
 		// with cloud caps and the local tool-curation gate disabled — findings #5/#6.)
 		let chatMode: ChatMode = userChatMode
 		let isLocalModel = false
-		let isCapableLocalCoderModel = false
+		let isCapableLocalModelFlag = false
 		let maxAgentIterations = MAX_AGENT_LOOP_ITERATIONS
 		let maxConsecutiveToolErrors = MAX_CONSECUTIVE_TOOL_ERRORS
 		const recomputeModelState = (m: ModelSelection | null) => {
@@ -3278,10 +3278,12 @@ Output ONLY the JSON, no other text. Start with { and end with }.`
 				maxLocalConsecutiveToolErrors: MAX_LOCAL_CONSECUTIVE_TOOL_ERRORS,
 			})
 			isLocalModel = caps.isLocalModel
-			// A capable local coder (>=7B) also gets the web tools (web_search/browse_url) at both the prompt
-			// catalog and the execution chokepoint, so "check online" works locally instead of hallucinating.
-			isCapableLocalCoderModel = caps.isLocalModel && !!m && m.providerName !== 'auto'
-				&& isCapableLocalCoder(m.modelName.toLowerCase(), this._settingsService.state.settingsOfProvider[m.providerName]?.models?.find((mm: { modelName: string; parameterSize?: string }) => mm.modelName === m.modelName)?.parameterSize)
+			// A capable local model (>=7B -- coder OR general, e.g. llama3:8b that Auto may resolve to) also
+			// gets the web tools (web_search/browse_url) at both the prompt catalog and the execution
+			// chokepoint, so "check online" works locally instead of hallucinating. Web search is a general
+			// capability, gated on SIZE not coder-ness (isCapableLocalModel).
+			isCapableLocalModelFlag = caps.isLocalModel && !!m && m.providerName !== 'auto'
+				&& isCapableLocalModel(m.modelName.toLowerCase(), this._settingsService.state.settingsOfProvider[m.providerName]?.models?.find((mm: { modelName: string; parameterSize?: string }) => mm.modelName === m.modelName)?.parameterSize)
 			maxAgentIterations = caps.maxAgentIterations
 			maxConsecutiveToolErrors = caps.maxConsecutiveToolErrors
 		}
@@ -4626,7 +4628,7 @@ Output ONLY the JSON, no other text. Start with { and end with }.`
 									{ preapproved: false, unvalidatedToolParams: toolParams },
 									isLocalModel, // enforce local-model tool curation on synthesized calls too (else a local model can run a non-curated tool it can't recover from)
 									chatMode, // dispatch-level mode enforcement (read-only modes block writes/terminal even for synthesized calls)
-									isCapableLocalCoderModel, // a capable local coder (>=7B) is allowed the web tools at the chokepoint too
+									isCapableLocalModelFlag, // a capable local model (>=7B, coder or general) is allowed the web tools at the chokepoint too
 								)
 
 								if (interrupted) {
@@ -4711,7 +4713,7 @@ Output ONLY the JSON, no other text. Start with { and end with }.`
 								{ preapproved: false, unvalidatedToolParams: toolParams },
 								isLocalModel, // keep local-model curation consistent across all tool-dispatch paths
 								chatMode, // dispatch-level mode enforcement (read-only modes block writes/terminal even for synthesized calls)
-								isCapableLocalCoderModel, // a capable local coder (>=7B) is allowed the web tools at the chokepoint too
+								isCapableLocalModelFlag, // a capable local model (>=7B, coder or general) is allowed the web tools at the chokepoint too
 							)
 
 							if (interrupted) {
@@ -4835,7 +4837,7 @@ Output ONLY the JSON, no other text. Start with { and end with }.`
 					const mcpTools = this._mcpService.getMCPTools()
 					const mcpTool = mcpTools?.find(t => t.name === toolCall.name)
 
-					const { awaitingUserApproval, interrupted, completionSignaled } = await this._runToolCall(threadId, toolCall.name, toolCall.id, mcpTool?.mcpServerName, { preapproved: false, unvalidatedToolParams: toolCall.rawParams }, isLocalModel, chatMode, isCapableLocalCoderModel)
+					const { awaitingUserApproval, interrupted, completionSignaled } = await this._runToolCall(threadId, toolCall.name, toolCall.id, mcpTool?.mcpServerName, { preapproved: false, unvalidatedToolParams: toolCall.rawParams }, isLocalModel, chatMode, isCapableLocalModelFlag)
 					if (interrupted) {
 						this._setStreamState(threadId, undefined)
 						if (activePlanTracking?.currentStep) {

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

@@ -55,7 +55,7 @@ function uint8ArrayToBase64(data: Uint8Array): string {
 }
 import { getIsReasoningEnabledState, getReservedOutputTokenSpace, getModelCapabilities } from '../common/modelCapabilities.js';
 import { reParsedToolXMLString, chat_systemMessage, chat_systemMessage_local } from '../common/prompt/prompts.js';
-import { isCapableLocalCoder } from '../common/routing/codingModelScore.js';
+import { isCapableLocalModel } from '../common/routing/codingModelScore.js';
 import { AnthropicLLMChatMessage, AnthropicReasoning, GeminiLLMChatMessage, LLMChatMessage, LLMFIMMessage, OpenAILLMChatMessage, RawToolParamsObj } from '../common/sendLLMMessageTypes.js';
 import { ICortexideSettingsService } from '../common/cortexideSettingsService.js';
 import { ChatMode, FeatureName, ModelSelection, ProviderName } from '../common/cortexideSettingsTypes.js';
@@ -1541,13 +1541,15 @@ class ConvertToLLMMessageService extends Disposable implements IConvertToLLMMess
 
 		// For local models, use minimal system message template instead of truncating
 		const isLocal = isLocalProvider(validProviderName, this.cortexideSettingsService.state.settingsOfProvider)
-		// A capable local coder (>=7B) additionally gets the web tools (so "check online" actually works);
-		// small local models stay on the compact set. Param size comes from the provider's reported model
-		// details (ollama details.parameter_size), same source the router uses.
+		// A capable local model (>=7B -- coder OR general) additionally gets the web tools (so "check online"
+		// actually works); small local models stay on the compact set. Param size comes from the provider's
+		// reported model details (ollama details.parameter_size), same source the router uses.
 		const realParamSizeLocal: string | undefined = isLocal
 			? this.cortexideSettingsService.state.settingsOfProvider[validProviderName]?.models?.find((m: { modelName: string; parameterSize?: string }) => m.modelName === modelName)?.parameterSize
 			: undefined
-		const isCapableLocalCoderModel = isLocal && isCapableLocalCoder(modelName.toLowerCase(), realParamSizeLocal)
+		// Web tools are gated on model CAPABILITY (>=7B), not coder-ness -- a capable general model
+		// (e.g. llama3:8b, which Auto may resolve to) should also get web_search, not just coders.
+		const isCapableLocalModelFlag = isLocal && isCapableLocalModel(modelName.toLowerCase(), realParamSizeLocal)
 
 		let systemMessage: string
 		if (disableSystemMessage) {
@@ -1600,7 +1602,7 @@ class ConvertToLLMMessageService extends Disposable implements IConvertToLLMMess
 
 			const activeFileURILocal = this.editorService.activeEditor?.resource;
 			const projectRulesLocal = this._getCombinedAIInstructions(activeFileURILocal) || undefined;
-			systemMessage = chat_systemMessage_local({ workspaceFolders, openedURIs, directoryStr, activeURI, persistentTerminalIDs, chatMode, mcpTools, includeXMLToolDefinitions, relevantMemories, projectRules: projectRulesLocal, subagentSystemPrompt, allowedToolNames, isCapableLocalCoder: isCapableLocalCoderModel })
+			systemMessage = chat_systemMessage_local({ workspaceFolders, openedURIs, directoryStr, activeURI, persistentTerminalIDs, chatMode, mcpTools, includeXMLToolDefinitions, relevantMemories, projectRules: projectRulesLocal, subagentSystemPrompt, allowedToolNames, isCapableLocalModel: isCapableLocalModelFlag })
 		} else {
 			// Use full system message for cloud models
 			systemMessage = await this._generateChatMessagesSystemMessage(chatMode, specialToolFormat, subagentSystemPrompt, allowedToolNames)

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

@@ -556,15 +556,17 @@ export const COMPACT_LOCAL_TOOLSET = new Set<BuiltinToolName>([
 	'todo_write', 'attempt_completion', 'run_command',
 ])
 
-// A CAPABLE local coder (>=7B, e.g. qwen2.5-coder:7b) additionally gets the web tools, so an explicit
-// "check online" request actually goes online instead of falling back to a codebase search and then
-// hallucinating. Small local models stay on COMPACT_LOCAL_TOOLSET (they tend to misuse web tools). The
-// >=7B gate is isCapableLocalCoder (common/routing/codingModelScore.ts).
+// A CAPABLE local model (>=7B, e.g. qwen2.5-coder:7b OR a general model like llama3:8b) additionally
+// gets the web tools, so an explicit "check online" request actually goes online instead of falling
+// back to a codebase search / stale training knowledge and then hallucinating. Web search is a general
+// capability, NOT coder-specific -- the gate is SIZE (isCapableLocalModel), so Auto resolving to a
+// capable general model still gets web access. Small local models (<=3B) stay on COMPACT_LOCAL_TOOLSET
+// (they tend to misuse web tools). Gate: isCapableLocalModel (common/routing/codingModelScore.ts).
 export const CAPABLE_LOCAL_TOOLSET = new Set<BuiltinToolName>([...COMPACT_LOCAL_TOOLSET, 'web_search', 'browse_url'])
 
-/** The local-model toolset for a given capability: capable coders also get web tools. */
-export const localToolsetFor = (isCapableLocalCoder: boolean | undefined): Set<BuiltinToolName> =>
-	isCapableLocalCoder ? CAPABLE_LOCAL_TOOLSET : COMPACT_LOCAL_TOOLSET
+/** The local-model toolset for a given capability: capable (>=7B) models also get the web tools. */
+export const localToolsetFor = (isCapableLocalModel: boolean | undefined): Set<BuiltinToolName> =>
+	isCapableLocalModel ? CAPABLE_LOCAL_TOOLSET : COMPACT_LOCAL_TOOLSET
 
 // Read-only builtin tools a PARALLEL sub-agent is restricted to (run_parallel_subagents). No edits,
 // no run_command, no terminals — so N can run concurrently with zero file-system collision risk.
@@ -575,7 +577,7 @@ export const READ_ONLY_SUBAGENT_TOOLS: string[] = [
 	'go_to_definition', 'find_references', 'search_symbols', 'attempt_completion',
 ]
 
-export const availableTools = (chatMode: ChatMode | null, mcpTools: InternalToolInfo[] | undefined, opts?: { isLocal?: boolean, isCapableLocalCoder?: boolean, allowedToolNames?: string[] }) => {
+export const availableTools = (chatMode: ChatMode | null, mcpTools: InternalToolInfo[] | undefined, opts?: { isLocal?: boolean, isCapableLocalModel?: boolean, allowedToolNames?: string[] }) => {
 
 	let builtinToolNames: BuiltinToolName[] | undefined = chatMode === 'normal' ? undefined
 		: chatMode === 'gather' ? (Object.keys(builtinTools) as BuiltinToolName[]).filter(toolName =>
@@ -587,7 +589,7 @@ export const availableTools = (chatMode: ChatMode | null, mcpTools: InternalTool
 	// Weak/local models get a curated subset (and no MCP) so they can't hallucinate/misuse the
 	// long tail of tools (persistent terminals, web, refactors). See COMPACT_LOCAL_TOOLSET.
 	if (opts?.isLocal && builtinToolNames) {
-		const localSet = localToolsetFor(opts.isCapableLocalCoder)
+		const localSet = localToolsetFor(opts.isCapableLocalModel)
 		builtinToolNames = builtinToolNames.filter(toolName => localSet.has(toolName))
 	}
 
@@ -637,8 +639,8 @@ export const reParsedToolXMLString = (toolName: ToolName, toolParams: RawToolPar
 
 /* We expect tools to come at the end - not a hard limit, but that's just how we process them, and the flow makes more sense that way. */
 // - You are allowed to call multiple tools by specifying them consecutively. However, there should be NO text or writing between tool calls or after them.
-const systemToolsXMLPrompt = (chatMode: ChatMode, mcpTools: InternalToolInfo[] | undefined, isLocal?: boolean, allowedToolNames?: string[], isCapableLocalCoder?: boolean) => {
-	const tools = availableTools(chatMode, mcpTools, { isLocal, isCapableLocalCoder, allowedToolNames })
+const systemToolsXMLPrompt = (chatMode: ChatMode, mcpTools: InternalToolInfo[] | undefined, isLocal?: boolean, allowedToolNames?: string[], isCapableLocalModel?: boolean) => {
+	const tools = availableTools(chatMode, mcpTools, { isLocal, isCapableLocalModel, allowedToolNames })
 	if (!tools || tools.length === 0) return null
 
 	const toolXMLDefinitions = (`\
@@ -840,7 +842,7 @@ ${toolDefinitions}
 
 // Minimal chat system message for local models (drastically reduced)
 // Used for local models to minimize token usage and latency
-export const chat_systemMessage_local = ({ workspaceFolders, openedURIs, activeURI, chatMode: mode, includeXMLToolDefinitions, relevantMemories, mcpTools, projectRules, subagentSystemPrompt, allowedToolNames, isCapableLocalCoder }: { workspaceFolders: string[], directoryStr: string, openedURIs: string[], activeURI: string | undefined, persistentTerminalIDs: string[], chatMode: ChatMode, mcpTools: InternalToolInfo[] | undefined, includeXMLToolDefinitions: boolean, relevantMemories?: string, projectRules?: string, subagentSystemPrompt?: string, allowedToolNames?: string[], isCapableLocalCoder?: boolean }) => {
+export const chat_systemMessage_local = ({ workspaceFolders, openedURIs, activeURI, chatMode: mode, includeXMLToolDefinitions, relevantMemories, mcpTools, projectRules, subagentSystemPrompt, allowedToolNames, isCapableLocalModel }: { workspaceFolders: string[], directoryStr: string, openedURIs: string[], activeURI: string | undefined, persistentTerminalIDs: string[], chatMode: ChatMode, mcpTools: InternalToolInfo[] | undefined, includeXMLToolDefinitions: boolean, relevantMemories?: string, projectRules?: string, subagentSystemPrompt?: string, allowedToolNames?: string[], isCapableLocalModel?: boolean }) => {
 	const header = (mode === 'agent' || mode === 'plan')
 		? 'Coding agent. Use tools for actions.'
 		: mode === 'gather'
@@ -850,13 +852,13 @@ export const chat_systemMessage_local = ({ workspaceFolders, openedURIs, activeU
 	const sysInfo = `System: ${os} | Today: ${new Date().toDateString()}\nWorkspace: ${workspaceFolders.join(', ') || 'none'}\nActive: ${activeURI || 'none'}\nOpen: ${openedURIs.slice(0, 3).join(', ') || 'none'}${openedURIs.length > 3 ? '...' : ''}`
 
 	// Local/weak model -> curated tool subset; capable coders (>=7B) also get the web tools.
-	const toolDefinitions = includeXMLToolDefinitions ? systemToolsXMLPrompt(mode, mcpTools, true, allowedToolNames, isCapableLocalCoder) : null
+	const toolDefinitions = includeXMLToolDefinitions ? systemToolsXMLPrompt(mode, mcpTools, true, allowedToolNames, isCapableLocalModel) : null
 
 	const details: string[] = []
 	if (mode === 'agent' || mode === 'plan') {
-		// Only claim web access when the web tools are actually offered (capable coders); otherwise a small
-		// model is told it can browse but has no tool, and it fabricates an answer.
-		details.push(isCapableLocalCoder
+		// Only claim web access when the web tools are actually offered (capable >=7B models); otherwise a
+		// small model is told it can browse but has no tool, and it fabricates an answer.
+		details.push(isCapableLocalModel
 			? 'Use tools to read/edit files, run commands, or fetch current/web info (web_search/browse_url). Answer general-knowledge or conceptual questions directly, without tools.'
 			: 'Use tools to read/edit files and run commands. You do NOT have web access; if asked to check online or look up current info, say you cannot (suggest switching to a cloud model). Answer general-knowledge or conceptual questions directly, without tools.')
 		// Anti-hallucination guard: never invent facts to fill a gap.

src/vs/workbench/contrib/cortexide/common/routing/codingModelScore.ts

@@ -111,6 +111,22 @@ export function isCapableLocalCoder(modelNameLower: string, realParamSize?: stri
 	return params >= 7;
 }
 
+/**
+ * Is this LOCAL model capable enough (by SIZE alone) to be offered the WEB tools (web_search,
+ * browse_url)? Unlike isCapableLocalCoder this does NOT require a coder -- web search is a general
+ * capability, so any sufficiently large local model (>= 7B, or an unnumbered/flagship ":latest" tag
+ * whose real size we don't have -> assume capable) qualifies. Small/weak models (<= ~3B) still get
+ * only the COMPACT toolset (no web) because they fumble the agentic loop.
+ *
+ * Fixes Auto resolving to a capable GENERAL model (e.g. llama3:8b) which was then denied web_search
+ * by the coder-only gate and answered "SpaceX has not gone public" from stale training knowledge.
+ */
+export function isCapableLocalModel(modelNameLower: string, realParamSize?: string): boolean {
+	const params = parseParamSizeBillions(realParamSize) ?? parseParamSizeBillions(modelNameLower);
+	if (params == null) { return true; } // unnumbered/flagship (":latest") -> assume capable
+	return params >= 7;
+}
+
 /**
  * Pick the most capable coder from a list of model NAMES (tags) for a LOCAL provider, reusing the
  * same coder + size signal the router uses. Prefers a code-tuned name, breaks ties by larger param