Rename ToolConfig to ApiConfiguration and Provider to ModelProvider across the codebase to better reflect their purpose

Author: robertpiosik

apps/editor/src/commands/apply-chat-response-command/handlers/active-editor-intelligent-update-handler.ts

@@ -9,7 +9,7 @@ import { sanitize_file_name, create_safe_path } from '@/utils/path-sanitizer'
 import { Logger } from '@shared/utils/logger'
 import { OriginalFileState } from '@/commands/apply-chat-response-command/types/original-file-state'
 import {
-  ToolConfig,
+  ApiConfiguration,
   ModelProvidersManager
 } from '@/services/model-providers-manager'
 import { PanelProvider } from '@/views/panel/backend/panel-provider'
@@ -22,7 +22,7 @@ import {
 export const handle_active_editor_intelligent_update = async (params: {
   endpoint_url: string
   api_key: string
-  config: ToolConfig
+  api_configuration: ApiConfiguration
   chat_response: string
   context: vscode.ExtensionContext
   is_single_root_folder_workspace: boolean
@@ -122,14 +122,14 @@ export const handle_active_editor_intelligent_update = async (params: {
     const updated_content = await process_file({
       endpoint_url: params.endpoint_url,
       api_key: params.api_key,
-      provider: {
-        name: params.config.provider_name,
+      model_provider: {
+        name: params.api_configuration.model_provider_name,
         base_url: params.endpoint_url,
         api_key: params.api_key
       },
-      model: params.config.model,
-      temperature: params.config.temperature,
-      reasoning_effort: params.config.reasoning_effort,
+      model: params.api_configuration.model,
+      temperature: params.api_configuration.temperature,
+      reasoning_effort: params.api_configuration.reasoning_effort,
       file_path: target_file_path,
       file_content: original_content,
       instruction: file_item.content,
@@ -200,18 +200,18 @@ export const handle_active_editor_intelligent_update = async (params: {
       )
 
       const api_providers_manager = new ModelProvidersManager(params.context)
-      const config_result = await get_intelligent_update_config(
+      const api_configuration_result = await get_intelligent_update_config(
         api_providers_manager,
         true,
         params.context
       )
 
-      if (config_result) {
+      if (api_configuration_result) {
         return await handle_active_editor_intelligent_update({
           ...params,
-          endpoint_url: config_result.provider.base_url,
-          api_key: config_result.provider.api_key,
-          config: config_result.config
+          endpoint_url: api_configuration_result.model_provider.base_url,
+          api_key: api_configuration_result.model_provider.api_key,
+          api_configuration: api_configuration_result.api_configuration
         })
       }
     }

apps/editor/src/commands/apply-chat-response-command/response-processor.ts

@@ -525,24 +525,24 @@ export const process_chat_response = async (params: {
           const api_providers_manager = new ModelProvidersManager(
             params.context
           )
-          const config_result = await get_intelligent_update_config(
+          const api_configuration_result = await get_intelligent_update_config(
             api_providers_manager,
             false,
             params.context
           )
 
-          if (!config_result) {
+          if (!api_configuration_result) {
             return null
           }
 
-          const { provider, config: intelligent_update_config } = config_result
-          const endpoint_url = provider.base_url
+          const { model_provider, api_configuration: intelligent_update_api_configuration } = api_configuration_result
+          const endpoint_url = model_provider.base_url
 
           const intelligent_update_states =
             await handle_active_editor_intelligent_update({
               endpoint_url,
-              api_key: provider.api_key,
-              config: intelligent_update_config,
+              api_key: model_provider.api_key,
+              api_configuration: intelligent_update_api_configuration,
               chat_response: fake_chat_response,
               context: params.context,
               is_single_root_folder_workspace,

apps/editor/src/commands/code-at-cursor-command/utils/get-code-at-cursor-config.ts

@@ -1,131 +1,131 @@
 import * as vscode from 'vscode'
 import {
   ModelProvidersManager,
-  get_tool_config_id,
-  ToolConfig
+  get_api_configuration_id,
+  ApiConfiguration
 } from '../../../services/model-providers-manager'
 import { Logger } from '@shared/utils/logger'
 import { RECENTLY_USED_CODE_AT_CURSOR_CONFIG_IDS_STATE_KEY } from '@/constants/state-keys'
 import { PanelProvider } from '@/views/panel/backend/panel-provider'
 import { dictionary } from '@shared/constants/dictionary'
 import { t } from '@/i18n'
 
-export const get_code_at_cursor_config = async (params: {
+export const get_code_at_cursor_api_configuration = async (params: {
   api_providers_manager: ModelProvidersManager
   show_quick_pick?: boolean
   context: vscode.ExtensionContext
-  config_id?: string
+  api_configuration_id?: string
   panel_provider?: PanelProvider
-}): Promise<{ provider: any; config: any } | undefined> => {
-  const code_at_cursor_configs =
-    await params.api_providers_manager.get_tool_configs()
+}): Promise<{ model_provider: any; api_configuration: any } | undefined> => {
+  const code_at_cursor_api_configurations =
+    await params.api_providers_manager.get_api_configurations()
 
-  if (code_at_cursor_configs.length == 0) {
+  if (code_at_cursor_api_configurations.length == 0) {
     vscode.commands.executeCommand('codeWebChat.settings')
     vscode.window.showInformationMessage(
       dictionary.information_message.NO_CODE_AT_CURSOR_CONFIGURATIONS_FOUND
     )
     return
   }
 
-  let selected_config: ToolConfig | null = null
+  let selected_api_configuration: ApiConfiguration | null = null
 
-  if (params.config_id !== undefined) {
-    selected_config =
-      code_at_cursor_configs.find(
-        (c) => get_tool_config_id(c) === params.config_id
+  if (params.api_configuration_id !== undefined) {
+    selected_api_configuration =
+      code_at_cursor_api_configurations.find(
+        (c) => get_api_configuration_id(c) === params.api_configuration_id
       ) || null
   } else if (!params.show_quick_pick) {
-    const default_config =
-      await params.api_providers_manager.get_default_code_completions_config()
-    if (default_config) {
-      selected_config = default_config
+    const default_api_configuration =
+      await params.api_providers_manager.get_default_code_completions_api_configuration()
+    if (default_api_configuration) {
+      selected_api_configuration = default_api_configuration
     } else {
       const recents = params.context.workspaceState.get<string[]>(
         RECENTLY_USED_CODE_AT_CURSOR_CONFIG_IDS_STATE_KEY
       )
       const last_selected_id = recents?.[0]
       if (last_selected_id) {
-        selected_config =
-          code_at_cursor_configs.find(
-            (c) => get_tool_config_id(c) == last_selected_id
+        selected_api_configuration =
+          code_at_cursor_api_configurations.find(
+            (c) => get_api_configuration_id(c) == last_selected_id
           ) || null
       }
-      if (!selected_config && code_at_cursor_configs.length > 0) {
-        selected_config = code_at_cursor_configs[0]
+      if (!selected_api_configuration && code_at_cursor_api_configurations.length > 0) {
+        selected_api_configuration = code_at_cursor_api_configurations[0]
       }
     }
   }
 
-  if (!selected_config || params.show_quick_pick) {
+  if (!selected_api_configuration || params.show_quick_pick) {
     const create_items = () => {
       const recent_ids =
         params.context.workspaceState.get<string[]>(
           RECENTLY_USED_CODE_AT_CURSOR_CONFIG_IDS_STATE_KEY
         ) || []
 
-      const matched_recent_configs: ToolConfig[] = []
-      const remaining_configs: ToolConfig[] = []
+      const matched_recent_api_configurations: ApiConfiguration[] = []
+      const remaining_api_configurations: ApiConfiguration[] = []
 
-      code_at_cursor_configs.forEach((config) => {
-        const id = get_tool_config_id(config)
+      code_at_cursor_api_configurations.forEach((api_configuration) => {
+        const id = get_api_configuration_id(api_configuration)
         if (recent_ids.includes(id)) {
-          matched_recent_configs.push(config)
+          matched_recent_api_configurations.push(api_configuration)
         } else {
-          remaining_configs.push(config)
+          remaining_api_configurations.push(api_configuration)
         }
       })
 
-      matched_recent_configs.sort((a, b) => {
-        const id_a = get_tool_config_id(a)
-        const id_b = get_tool_config_id(b)
+      matched_recent_api_configurations.sort((a, b) => {
+        const id_a = get_api_configuration_id(a)
+        const id_b = get_api_configuration_id(b)
         return recent_ids.indexOf(id_a) - recent_ids.indexOf(id_b)
       })
 
-      const recent_configs = matched_recent_configs
-      const other_configs = remaining_configs
+      const recent_api_configurations = matched_recent_api_configurations
+      const other_api_configurations = remaining_api_configurations
 
-      const map_config_to_item = (config: ToolConfig) => {
-        const description_parts = [config.provider_name]
-        if (config.temperature != null) {
-          description_parts.push(`${config.temperature}`)
+      const map_api_configuration_to_item = (api_configuration: ApiConfiguration) => {
+        const description_parts = [api_configuration.model_provider_name]
+        if (api_configuration.temperature != null) {
+          description_parts.push(`${api_configuration.temperature}`)
         }
-        if (config.reasoning_effort) {
-          description_parts.push(`${config.reasoning_effort}`)
+        if (api_configuration.reasoning_effort) {
+          description_parts.push(`${api_configuration.reasoning_effort}`)
         }
 
         const buttons: vscode.QuickInputButton[] = []
 
         return {
-          label: config.model,
+          label: api_configuration.model,
           description: description_parts.join(' · '),
           buttons,
-          config,
-          id: get_tool_config_id(config)
+          api_configuration,
+          id: get_api_configuration_id(api_configuration)
         }
       }
 
       const items: (vscode.QuickPickItem & {
-        config?: ToolConfig
+        api_configuration?: ApiConfiguration
         id?: string
       })[] = []
 
-      if (recent_configs.length > 0) {
+      if (recent_api_configurations.length > 0) {
         items.push({
           label: t('common.separator.recently-used'),
           kind: vscode.QuickPickItemKind.Separator
         })
-        items.push(...recent_configs.map(map_config_to_item))
+        items.push(...recent_api_configurations.map(map_api_configuration_to_item))
       }
 
-      if (other_configs.length > 0) {
-        if (recent_configs.length > 0) {
+      if (other_api_configurations.length > 0) {
+        if (recent_api_configurations.length > 0) {
           items.push({
             label: t('common.config.other'),
             kind: vscode.QuickPickItemKind.Separator
           })
         }
-        items.push(...other_configs.map(map_config_to_item))
+        items.push(...other_api_configurations.map(map_api_configuration_to_item))
       }
 
       return items
@@ -154,7 +154,7 @@ export const get_code_at_cursor_config = async (params: {
       }
     }
 
-    return new Promise<{ provider: any; config: any } | undefined>(
+    return new Promise<{ model_provider: any; api_configuration: any } | undefined>(
       (resolve) => {
         quick_pick.onDidTriggerButton((button) => {
           if (button.tooltip == t('common.close')) {
@@ -167,7 +167,7 @@ export const get_code_at_cursor_config = async (params: {
           const selected = quick_pick.selectedItems[0] as any
           quick_pick.hide()
 
-          if (!selected || !selected.config) {
+          if (!selected || !selected.api_configuration) {
             resolve(undefined)
             return
           }
@@ -190,10 +190,10 @@ export const get_code_at_cursor_config = async (params: {
             })
           }
 
-          const provider = await params.api_providers_manager.get_provider(
-            selected.config.provider_name
+          const model_provider = await params.api_providers_manager.get_model_provider(
+            selected.api_configuration.model_provider_name
           )
-          if (!provider) {
+          if (!model_provider) {
             vscode.window.showErrorMessage(
               dictionary.error_message.API_PROVIDER_NOT_FOUND
             )
@@ -202,8 +202,8 @@ export const get_code_at_cursor_config = async (params: {
           }
 
           resolve({
-            provider,
-            config: selected.config
+            model_provider,
+            api_configuration: selected.api_configuration
           })
         })
 
@@ -217,23 +217,23 @@ export const get_code_at_cursor_config = async (params: {
     )
   }
 
-  const provider = await params.api_providers_manager.get_provider(
-    selected_config.provider_name
+  const model_provider = await params.api_providers_manager.get_model_provider(
+    selected_api_configuration.model_provider_name
   )
 
-  if (!provider) {
+  if (!model_provider) {
     vscode.window.showErrorMessage(
       dictionary.error_message.API_PROVIDER_NOT_FOUND
     )
     Logger.warn({
-      function_name: 'get_code_at_cursor_config',
+      function_name: 'get_code_at_cursor_api_configuration',
       message: 'API provider not found for Code Completions tool.'
     })
     return
   }
 
   return {
-    provider,
-    config: selected_config
+    model_provider,
+    api_configuration: selected_api_configuration
   }
 }