Add model configuration feature to Cursor Whisper extension

- Introduced a new command to configure the OpenAI model for prompt transformation.
- Updated package.json to include the new command and model options.
- Enhanced VSCodeConfigRepository to manage the transformation model setting.
- Modified OpenAIPromptTransformer to utilize the selected model during prompt transformation.
- Updated pnpm-lock.yaml to include new dependencies for GitHub Copilot integration.

Author: efraespada

cursor-whisper-0.1.0.vsix

@@ -54,6 +54,10 @@
       {
         "command": "cursor-whisper.configureApiKey",
         "title": "Cursor Whisper: Configure API Key"
+      },
+      {
+        "command": "cursor-whisper.configureModel",
+        "title": "Cursor Whisper: Configure Model"
       }
     ],
     "keybindings": [
@@ -93,6 +97,25 @@
           "default": true,
           "description": "Enable AI-powered prompt transformation (requires GPT-4 API access, costs ~$0.01 per transformation)"
         },
+        "cursorWhisper.transformationModel": {
+          "type": "string",
+          "default": "gpt-4o",
+          "enum": [
+            "gpt-4o",
+            "gpt-4o-mini",
+            "gpt-4-turbo",
+            "gpt-4",
+            "gpt-3.5-turbo"
+          ],
+          "enumDescriptions": [
+            "GPT-4o — fast, cost-effective (recommended default)",
+            "GPT-4o mini — lower cost, slightly reduced quality",
+            "GPT-4 Turbo — high intelligence with large context",
+            "GPT-4 — original GPT-4 model",
+            "GPT-3.5 Turbo — cheapest option, lower quality"
+          ],
+          "description": "OpenAI model used for prompt transformation. Use 'Cursor Whisper: Configure Model' to pick from models available on your API key."
+        },
         "cursorWhisper.audioQuality": {
           "type": "string",
           "enum": [

package.json

@@ -14,6 +14,11 @@ export interface Config {
    */
   enablePromptTransformation: boolean;
 
+  /**
+   * OpenAI model ID used for prompt transformation (default: gpt-4o).
+   */
+  transformationModel: string;
+
   /**
    * Audio recording quality ('low' | 'medium' | 'high').
    */

pnpm-lock.yaml

@@ -5,6 +5,7 @@ import { VSCodeOutputChannelLogger } from './infrastructure/logging/VSCodeOutput
 import { VSCodeConfigRepository } from './infrastructure/configuration/VSCodeConfigRepository';
 import { OpenAIWhisperService } from './infrastructure/transcription/OpenAIWhisperService';
 import { OpenAIPromptTransformer } from './infrastructure/transformation/OpenAIPromptTransformer';
+import { OpenAIModelService } from './infrastructure/openai/OpenAIModelService';
 import { ChatParticipantInserter } from './infrastructure/insertion/ChatParticipantInserter';
 import { EditorTextInserter } from './infrastructure/insertion/EditorTextInserter';
 import { FallbackTextInserter } from './infrastructure/insertion/FallbackTextInserter';
@@ -23,6 +24,7 @@ import { registerStartRecordingCommand } from './presentation/commands/StartReco
 import { registerStopRecordingCommand } from './presentation/commands/StopRecordingCommand';
 import { registerCancelRecordingCommand } from './presentation/commands/CancelRecordingCommand';
 import { registerConfigureApiKeyCommand } from './presentation/commands/ConfigureApiKeyCommand';
+import { registerConfigureModelCommand } from './presentation/commands/ConfigureModelCommand';
 import { RecordingStatusBarItem } from './presentation/ui/RecordingStatusBarItem';
 
 let activeAudioRecorder: NativeAudioRecorder | null = null;
@@ -56,8 +58,14 @@ export function activate(context: vscode.ExtensionContext): void {
     return config.apiKey;
   };
 
+  const getModel = async (): Promise<string | undefined> => {
+    const config = await configRepository.getConfig();
+    return config.transformationModel;
+  };
+
   const whisperService = new OpenAIWhisperService(getApiKey, logger);
-  const promptTransformer = new OpenAIPromptTransformer(getApiKey, logger);
+  const promptTransformer = new OpenAIPromptTransformer(getApiKey, getModel, logger);
+  const modelService = new OpenAIModelService(getApiKey, logger);
 
   // Text Insertion (Chain of Responsibility)
   const inserters = [
@@ -117,8 +125,20 @@ export function activate(context: vscode.ExtensionContext): void {
   });
   const cancelCommand = registerCancelRecordingCommand(context, cancelRecordingUseCase);
   const configureCommand = registerConfigureApiKeyCommand(context, configRepository);
+  const configureModelCommand = registerConfigureModelCommand(
+    context,
+    configRepository,
+    modelService,
+    logger
+  );
 
-  context.subscriptions.push(startCommand, stopCommand, cancelCommand, configureCommand);
+  context.subscriptions.push(
+    startCommand,
+    stopCommand,
+    cancelCommand,
+    configureCommand,
+    configureModelCommand
+  );
 
   // ========================================
   // STARTUP CHECKS

src/application/ports/IConfigRepository.ts

@@ -6,6 +6,7 @@ export class VSCodeConfigRepository implements IConfigRepository {
   private static readonly SECTION = 'cursorWhisper';
   private static readonly SECRET_KEY = 'cursor-whisper.openai.apiKey';
   private static readonly LEGACY_SECRET_KEY = 'openai-api-key';
+  static readonly DEFAULT_TRANSFORMATION_MODEL = 'gpt-4o';
   private callbacks: Array<(config: Config) => void> = [];
 
   constructor(
@@ -40,6 +41,10 @@ export class VSCodeConfigRepository implements IConfigRepository {
       apiKey,
       transcriptionLanguage: config.get<string>('transcriptionLanguage', 'auto'),
       enablePromptTransformation: config.get<boolean>('enablePromptTransformation', false),
+      transformationModel: config.get<string>(
+        'transformationModel',
+        VSCodeConfigRepository.DEFAULT_TRANSFORMATION_MODEL
+      ),
       audioQuality: config.get<'low' | 'medium' | 'high'>('audioQuality', 'high'),
       maxRecordingDuration: config.get<number>('maxRecordingDuration', 120),
       showNotifications: config.get<boolean>('showNotifications', true),
@@ -93,6 +98,16 @@ export class VSCodeConfigRepository implements IConfigRepository {
       );
     }
 
+    if (partialConfig.transformationModel !== undefined) {
+      updates.push(
+        config.update(
+          'transformationModel',
+          partialConfig.transformationModel,
+          vscode.ConfigurationTarget.Global
+        )
+      );
+    }
+
     if (partialConfig.audioQuality !== undefined) {
       updates.push(
         config.update('audioQuality', partialConfig.audioQuality, vscode.ConfigurationTarget.Global)

src/extension.ts

@@ -0,0 +1,72 @@
+import OpenAI from 'openai';
+import { ApiKey } from '../../domain/value-objects/ApiKey';
+import { ILogger } from '../../application/ports/ILogger';
+
+export class OpenAIModelServiceError extends Error {
+  constructor(message: string, public readonly cause?: Error) {
+    super(message);
+    this.name = 'OpenAIModelServiceError';
+  }
+}
+
+/** Models unsuitable for chat completion prompt transformation. */
+const EXCLUDED_MODEL_PATTERNS = [
+  /whisper/i,
+  /tts/i,
+  /dall-e/i,
+  /embedding/i,
+  /moderation/i,
+  /realtime/i,
+  /audio/i,
+  /transcribe/i,
+  /search-preview/i,
+  /instruct/i,
+];
+
+/**
+ * Fetches GPT chat models available to the user's OpenAI API key.
+ */
+export class OpenAIModelService {
+  constructor(
+    private readonly getApiKey: () => Promise<string | undefined>,
+    private readonly logger: ILogger
+  ) {}
+
+  async listGptModels(): Promise<string[]> {
+    const apiKeyStr = await this.getApiKey();
+    if (!apiKeyStr) {
+      throw new OpenAIModelServiceError('OpenAI API key not configured');
+    }
+
+    const apiKey = new ApiKey(apiKeyStr);
+    const client = new OpenAI({ apiKey: apiKey.toString() });
+
+    try {
+      this.logger.debug('Fetching available OpenAI models');
+      const response = await client.models.list();
+      const modelIds = response.data.map(model => model.id);
+
+      const gptModels = modelIds
+        .filter(id => id.startsWith('gpt-'))
+        .filter(id => !EXCLUDED_MODEL_PATTERNS.some(pattern => pattern.test(id)))
+        .sort((a, b) => a.localeCompare(b));
+
+      this.logger.info('Fetched GPT models from OpenAI API', { count: gptModels.length });
+
+      return gptModels;
+    } catch (error) {
+      this.logger.error('Failed to fetch OpenAI models', error as Error);
+
+      if (error instanceof Error) {
+        if (error.message.includes('invalid_api_key')) {
+          throw new OpenAIModelServiceError('Invalid API key', error);
+        }
+      }
+
+      throw new OpenAIModelServiceError(
+        'Failed to fetch models from OpenAI',
+        error instanceof Error ? error : undefined
+      );
+    }
+  }
+}