Prototype: model_router_v0 with remote classifier service

.esbuild.ts

@@ -40,6 +40,7 @@ const baseNodeBuildOptions = {
 		'sqlite3',
 		'node-pty', // Required by @github/copilot
 		'@github/copilot',
+		'sharp', // Image processing with native bindings
 		...(isDev ? [] : ['dotenv', 'source-map-support'])
 	],
 	platform: 'node',

package.json

@@ -2,7 +2,7 @@
 	"name": "copilot-chat",
 	"displayName": "GitHub Copilot Chat",
 	"description": "AI chat features powered by Copilot",
-	"version": "0.34.0",
+	"version": "0.34.0-model-router-v0",
 	"build": "1",
 	"internalAIKey": "1058ec22-3c95-4951-8443-f26c1f325911",
 	"completionsCoreVersion": "1.378.1799",

src/platform/endpoint/node/automodeService.ts

@@ -12,10 +12,29 @@ import { IInstantiationService } from '../../../util/vs/platform/instantiation/c
 import { ChatLocation } from '../../../vscodeTypes';
 import { IAuthenticationService } from '../../authentication/common/authentication';
 import { ILogService } from '../../log/common/logService';
+import { IFetcherService } from '../../networking/common/fetcherService';
 import { IChatEndpoint } from '../../networking/common/networking';
 import { IExperimentationService } from '../../telemetry/common/nullExperimentationService';
 import { ICAPIClientService } from '../common/capiClient';
 import { AutoChatEndpoint } from './autoChatEndpoint';
+import { ReasoningClassifier } from './reasoningClassifier';
+
+// Exact model names for reasoning-capable models (more capable, expensive models)
+const REASONING_MODELS = [
+	'claude-sonnet-4.5',
+	'gpt-5-codex',
+	'gpt-5',
+	'gemini-3-pro-preview'
+] as const;
+
+// Exact model names for low/no reasoning models (fast, cheaper models)
+const LOW_REASONING_MODELS = [
+	'claude-haiku-4.5',
+	'gpt-5-mini',
+	'gpt-4.1',
+	'gpt-5-nano',
+	'grok-code-fast-1'
+] as const;
 
 interface AutoModeAPIResponse {
 	available_models: string[];
@@ -106,13 +125,15 @@ export class AutomodeService extends Disposable implements IAutomodeService {
 	readonly _serviceBrand: undefined;
 	private readonly _autoModelCache: Map<string, { endpoint: IChatEndpoint; tokenBank: AutoModeTokenBank }> = new Map();
 	private _reserveTokens: DisposableMap<ChatLocation, AutoModeTokenBank> = new DisposableMap();
+	private readonly _reasoningClassifier: ReasoningClassifier;
 
 	constructor(
 		@ICAPIClientService private readonly _capiClientService: ICAPIClientService,
 		@IAuthenticationService private readonly _authService: IAuthenticationService,
 		@ILogService private readonly _logService: ILogService,
 		@IInstantiationService private readonly _instantiationService: IInstantiationService,
-		@IExperimentationService private readonly _expService: IExperimentationService
+		@IExperimentationService private readonly _expService: IExperimentationService,
+		@IFetcherService private readonly _fetcherService: IFetcherService
 	) {
 		super();
 		this._register(this._authService.onDidAuthenticationChange(() => {
@@ -127,6 +148,9 @@ export class AutomodeService extends Disposable implements IAutomodeService {
 			}
 		}));
 		this._serviceBrand = undefined;
+
+		// Initialize reasoning classifier (uses remote API)
+		this._reasoningClassifier = this._register(new ReasoningClassifier(this._fetcherService, this._logService));
 	}
 
 	override dispose(): void {
@@ -148,15 +172,6 @@ export class AutomodeService extends Disposable implements IAutomodeService {
 
 		const conversationId = getConversationId(chatRequest);
 		const entry = this._autoModelCache.get(conversationId);
-		if (entry) {
-			const entryToken = await entry.tokenBank.getToken();
-			if (entry.endpoint.model !== entryToken.selected_model) {
-				// Model changed during a token refresh -> map to new endpoint
-				const newModel = knownEndpoints.find(e => e.model === entryToken.selected_model) || knownEndpoints[0];
-				entry.endpoint = this._instantiationService.createInstance(AutoChatEndpoint, newModel, entryToken.session_token, entryToken.discounted_costs?.[newModel.model] || 0, this._calculateDiscountRange(entryToken.discounted_costs));
-			}
-			return entry.endpoint;
-		}
 
 		// No entry yet -> Promote reserve token to active and repopulate reserve
 		const location = chatRequest?.location ?? ChatLocation.Panel;
@@ -167,7 +182,31 @@ export class AutomodeService extends Disposable implements IAutomodeService {
 		reserveTokenBank.debugName = conversationId;
 
 		const reserveToken = await reserveTokenBank.getToken();
-		const selectedModel = knownEndpoints.find(e => e.model === reserveToken.selected_model) || knownEndpoints[0];
+
+		// Check if a low reasoning model should be used based on the user's query
+		const shouldUseLowReasoning = await this._shouldUseLowReasoningModel(chatRequest);
+
+		// Check the current entry's model against the reasoning requirements and availability
+		if (entry) {
+			const targetModels = shouldUseLowReasoning ? LOW_REASONING_MODELS : REASONING_MODELS;
+			const currentModel = entry.endpoint.model;
+
+			// If current model is still available and matches reasoning requirements, keep it
+			if (reserveToken.available_models.includes(currentModel) &&
+				(targetModels as readonly string[]).includes(currentModel)) {
+				this._logService.info(`Keeping current model ${currentModel} - still available and matches ${shouldUseLowReasoning ? 'low reasoning' : 'reasoning'} requirements`);
+				return entry.endpoint;
+			}
+
+			this._logService.info(`Current model ${currentModel} needs to be changed - available: ${reserveToken.available_models.includes(currentModel)}, matches reasoning requirements: ${(targetModels as readonly string[]).includes(currentModel)}`);
+		}
+
+		const selectedModel = this._selectModelBasedOnReasoning(
+			knownEndpoints,
+			reserveToken,
+			shouldUseLowReasoning
+		);
+
 		const autoEndpoint = this._instantiationService.createInstance(AutoChatEndpoint, selectedModel, reserveToken.session_token, reserveToken.discounted_costs?.[selectedModel.model] || 0, this._calculateDiscountRange(reserveToken.discounted_costs));
 		this._autoModelCache.set(conversationId, { endpoint: autoEndpoint, tokenBank: reserveTokenBank });
 		return autoEndpoint;
@@ -192,6 +231,64 @@ export class AutomodeService extends Disposable implements IAutomodeService {
 		}
 		return hasValues ? { low, high } : { low: 0, high: 0 };
 	}
+
+	/**
+	 * Determines if the user's query should use a low reasoning model (for simple queries)
+	 */
+	private async _shouldUseLowReasoningModel(chatRequest: ChatRequest | undefined): Promise<boolean> {
+		if (!chatRequest || !chatRequest.prompt || chatRequest.prompt.trim().length === 0) {
+			return true;
+		}
+
+		try {
+			// Use ModernBERT classifier to determine if query needs reasoning
+			// Classifier outputs: 0 = reasoning required, 1 = non-reasoning (simple)
+			const isSimpleQuery = await this._reasoningClassifier.classify(chatRequest.prompt);
+
+			this._logService.info(`Low reasoning model should be used: ${isSimpleQuery}`);
+			return isSimpleQuery;
+		} catch (error) {
+			this._logService.error('Failed to determine reasoning model requirement', error);
+			return false;
+		}
+	}
+
+	/**
+	 * Selects the appropriate model based on reasoning requirements
+	 */
+	private _selectModelBasedOnReasoning(
+		knownEndpoints: IChatEndpoint[],
+		autoModeResponse: AutoModeAPIResponse,
+		shouldUseLowReasoning: boolean
+	): IChatEndpoint {
+		const targetModels = shouldUseLowReasoning ? LOW_REASONING_MODELS : REASONING_MODELS;
+		const modelType = shouldUseLowReasoning ? 'low reasoning' : 'reasoning';
+
+		// First check if the server's selected_model already matches our requirements
+		if ((targetModels as readonly string[]).includes(autoModeResponse.selected_model)) {
+			const selectedEndpoint = knownEndpoints.find(e => e.model === autoModeResponse.selected_model);
+			if (selectedEndpoint) {
+				this._logService.info(`Using server's selected ${modelType} model: ${selectedEndpoint.model}`);
+				return selectedEndpoint;
+			}
+		}
+
+		// If selected_model doesn't match, search available_models for a match
+		for (const modelName of targetModels) {
+			if (autoModeResponse.available_models.includes(modelName)) {
+				const endpoint = knownEndpoints.find(e => e.model === modelName);
+				if (endpoint) {
+					this._logService.info(`Selected ${modelType} model from available_models: ${endpoint.model}`);
+					return endpoint;
+				}
+			}
+		}
+
+		// Fallback to the server's selected model or first available
+		this._logService.info(`No matching ${modelType} model found, using server's selection: ${autoModeResponse.selected_model}`);
+		return knownEndpoints.find(e => e.model === autoModeResponse.selected_model) || knownEndpoints[0];
+	}
+
 }
 
 /**

src/platform/endpoint/node/reasoningClassifier.ts

@@ -0,0 +1,70 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Disposable } from '../../../util/vs/base/common/lifecycle';
+import { ILogService } from '../../log/common/logService';
+import { IFetcherService } from '../../networking/common/fetcherService';
+
+// Remote reasoning classifier configuration
+export const REASONING_CLASSIFIER_API_URL = 'https://model-router-v0.yellowforest-598004f3.westus3.azurecontainerapps.io/predict';
+
+interface ReasoningClassifierResponse {
+	text: string;
+	predicted_label: 'needs_reasoning' | 'no_reasoning';
+	confidence: number;
+	scores: {
+		needs_reasoning: number;
+		no_reasoning: number;
+	};
+}
+
+/**
+ * Remote reasoning classifier that calls an external API to determine
+ * whether a query requires reasoning or not.
+ * Output: true if non-reasoning (simple query), false if reasoning required
+ */
+export class ReasoningClassifier extends Disposable {
+	constructor(
+		private readonly _fetcherService: IFetcherService,
+		private readonly _logService: ILogService
+	) {
+		super();
+	}
+
+	/**
+	 * Classify a query as reasoning or non-reasoning by calling remote API
+	 * @param query The user's query text
+	 * @returns true if non-reasoning (simple query), false if reasoning required
+	 */
+	async classify(query: string): Promise<boolean> {
+		try {
+			const response = await this._fetcherService.fetch(REASONING_CLASSIFIER_API_URL, {
+				method: 'POST',
+				headers: {
+					'Content-Type': 'application/json'
+				},
+				body: JSON.stringify({ text: query })
+			});
+
+			if (!response.ok) {
+				throw new Error(`Reasoning classifier API request failed: ${response.statusText}`);
+			}
+
+			const body = await response.text();
+			const result: ReasoningClassifierResponse = JSON.parse(body);
+
+			const isNonReasoning = result.predicted_label === 'no_reasoning';
+			const confidence = result.confidence;
+
+			this._logService.trace(`Reasoning classifier prediction: ${result.predicted_label} (confidence: ${(confidence * 100).toFixed(1)}%, scores: needs_reasoning=${(result.scores.needs_reasoning * 100).toFixed(1)}%, no_reasoning=${(result.scores.no_reasoning * 100).toFixed(1)}%)`);
+
+			return isNonReasoning;
+		} catch (error) {
+			this._logService.error('Reasoning classification failed', error);
+			throw error;
+		}
+	}
+}
+

src/platform/endpoint/node/test/eval_data_100.json

@@ -0,0 +1,100 @@
+{"text":"What is the syntax for a for loop in Python?","label":1}
+{"text":"How do I declare a variable in JavaScript?","label":1}
+{"text":"What is the difference between let and const?","label":1}
+{"text":"How do I print Hello World in Java?","label":1}
+{"text":"What is the file extension for TypeScript files?","label":1}
+{"text":"How do I create a new array in JavaScript?","label":1}
+{"text":"What is the command to install npm packages?","label":1}
+{"text":"How do I comment out code in Python?","label":1}
+{"text":"What is the shortcut to format code in VS Code?","label":1}
+{"text":"How do I check the Node.js version?","label":1}
+{"text":"What does the === operator do in JavaScript?","label":1}
+{"text":"How do I import a module in Python?","label":1}
+{"text":"What is the git command to check status?","label":1}
+{"text":"How do I create a function in JavaScript?","label":1}
+{"text":"What is the syntax for an if statement in C#?","label":1}
+{"text":"How do I convert a string to integer in Python?","label":1}
+{"text":"What is the command to run a Python script?","label":1}
+{"text":"How do I add an element to a list in Python?","label":1}
+{"text":"What is the default port for React development server?","label":1}
+{"text":"How do I exit vim?","label":1}
+{"text":"What is the syntax for a switch statement in Java?","label":1}
+{"text":"How do I check if a key exists in a dictionary?","label":1}
+{"text":"What is the git command to create a new branch?","label":1}
+{"text":"How do I read a file in Python?","label":1}
+{"text":"What is the keyboard shortcut to open terminal in VS Code?","label":1}
+{"text":"How do I reverse a string in JavaScript?","label":1}
+{"text":"What is the syntax for try-catch in Python?","label":1}
+{"text":"How do I install a specific version of a package with npm?","label":1}
+{"text":"What is the command to initialize a git repository?","label":1}
+{"text":"How do I get the length of a list in Python?","label":1}
+{"text":"What does async/await do?","label":1}
+{"text":"How do I concatenate strings in Java?","label":1}
+{"text":"What is the syntax for a lambda function in Python?","label":1}
+{"text":"How do I sort an array in JavaScript?","label":1}
+{"text":"What is the command to start a Docker container?","label":1}
+{"text":"How do I remove duplicates from a list in Python?","label":1}
+{"text":"What is the syntax for string interpolation in C#?","label":1}
+{"text":"How do I check the type of a variable in Python?","label":1}
+{"text":"What is the command to build a TypeScript project?","label":1}
+{"text":"How do I use map function in JavaScript?","label":1}
+{"text":"What is the syntax for destructuring in JavaScript?","label":1}
+{"text":"How do I parse JSON in Python?","label":1}
+{"text":"What is the git command to undo last commit?","label":1}
+{"text":"How do I create a class in Python?","label":1}
+{"text":"What is the difference between == and equals() in Java?","label":1}
+{"text":"How do I use spread operator in JavaScript?","label":1}
+{"text":"What is the command to run tests with pytest?","label":1}
+{"text":"How do I handle null values in TypeScript?","label":1}
+{"text":"What is the syntax for a list comprehension in Python?","label":1}
+{"text":"How do I make an HTTP request in JavaScript?","label":1}
+{"text":"Design a scalable microservices architecture for an e-commerce platform with high availability and fault tolerance","label":0}
+{"text":"Help me architect a real-time collaborative document editing system like Google Docs","label":0}
+{"text":"Create a comprehensive strategy for migrating a monolithic application to microservices without downtime","label":0}
+{"text":"Design a machine learning pipeline for detecting fraudulent transactions with explainability requirements","label":0}
+{"text":"Develop a caching strategy for a multi-region distributed application with consistency guarantees","label":0}
+{"text":"Architect a serverless event-driven system for processing millions of IoT sensor readings per second","label":0}
+{"text":"Design a secure authentication and authorization system with SSO, MFA, and role-based access control","label":0}
+{"text":"Create a data lake architecture for analytics with real-time and batch processing capabilities","label":0}
+{"text":"Help me design a recommendation engine that balances personalization with diversity and fairness","label":0}
+{"text":"Architect a CI/CD pipeline with canary deployments, feature flags, and automated rollback capabilities","label":0}
+{"text":"Design a distributed consensus algorithm for a blockchain-based voting system","label":0}
+{"text":"Create an API versioning and deprecation strategy for a public API with thousands of consumers","label":0}
+{"text":"Help me architect a multi-tenant SaaS platform with data isolation and customization options","label":0}
+{"text":"Design a disaster recovery strategy with RTO of 15 minutes and RPO of 5 minutes","label":0}
+{"text":"Develop a testing strategy for a complex distributed system with eventual consistency","label":0}
+{"text":"Architect a search system that handles fuzzy matching, relevance ranking, and personalization","label":0}
+{"text":"Design a rate limiting and throttling system that handles bursty traffic fairly","label":0}
+{"text":"Create a monitoring and observability strategy for a Kubernetes-based microservices platform","label":0}
+{"text":"Help me design a data synchronization system between mobile apps and backend with conflict resolution","label":0}
+{"text":"Architect a notification system that delivers messages across multiple channels with delivery guarantees","label":0}
+{"text":"Design a workflow orchestration engine for complex business processes with compensation logic","label":0}
+{"text":"Create a content delivery strategy for a global video streaming platform with adaptive bitrate","label":0}
+{"text":"Help me architect a financial trading system with sub-millisecond latency requirements","label":0}
+{"text":"Design an A/B testing framework that handles feature interactions and statistical significance","label":0}
+{"text":"Develop a schema evolution strategy for a large-scale data warehouse with backward compatibility","label":0}
+{"text":"Architect a secrets management system with automatic rotation and audit logging","label":0}
+{"text":"Design a queue-based system for processing long-running jobs with priority and fairness","label":0}
+{"text":"Create a database sharding strategy for a social network with complex relationship queries","label":0}
+{"text":"Help me design a plugin architecture that allows third-party extensions while maintaining security","label":0}
+{"text":"Architect an image processing pipeline that handles millions of uploads with resizing and optimization","label":0}
+{"text":"Design a compliance and audit logging system that meets GDPR and SOC2 requirements","label":0}
+{"text":"Create a load balancing strategy for WebSocket connections with sticky sessions and failover","label":0}
+{"text":"Help me architect a real-time analytics dashboard with sub-second query latency on petabyte data","label":0}
+{"text":"Design a configuration management system for distributed applications with feature flags and gradual rollout","label":0}
+{"text":"Develop a cost optimization strategy for a multi-cloud infrastructure with reserved and spot instances","label":0}
+{"text":"Architect a billing and subscription management system with usage-based pricing and invoicing","label":0}
+{"text":"Design a graph database schema for a knowledge graph with efficient traversal queries","label":0}
+{"text":"Create a blue-green deployment strategy for stateful services with zero-downtime database migrations","label":0}
+{"text":"Help me design a service mesh architecture with mTLS, traffic management, and observability","label":0}
+{"text":"Architect a document storage system with versioning, access control, and full-text search","label":0}
+{"text":"Design a machine learning model serving infrastructure with A/B testing and model versioning","label":0}
+{"text":"Create a data governance framework for a regulated industry with data lineage and quality checks","label":0}
+{"text":"Help me architect a geospatial data platform for real-time location tracking and route optimization","label":0}
+{"text":"Design an event sourcing system with CQRS pattern for a banking application","label":0}
+{"text":"Develop a capacity planning strategy for a rapidly growing SaaS platform with predictable scaling","label":0}
+{"text":"Architect a federated identity system that integrates with multiple enterprise identity providers","label":0}
+{"text":"Design a chaos engineering framework for testing system resilience in production","label":0}
+{"text":"Create a data pipeline architecture that handles schema-on-read with data quality validation","label":0}
+{"text":"Help me design an API gateway with request transformation, rate limiting, and circuit breaking","label":0}
+{"text":"Architect a distributed tracing system for debugging requests across hundreds of microservices","label":0}