Tools/Notes
1
0
Fork 0
mirror of https://github.com/TriliumNext/Notes.git synced 2025-09-18 17:31:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix(llm): have the model_selection_stage use the instance of the aiServiceManager

Browse Source
This commit is contained in:
perf3ct 2025-06-04 20:23:06 +00:00
parent a20e36f4ee
commit fe15a0378a
No known key found for this signature in database
GPG Key ID: 569C4EEC436F5232
1 changed files with 49 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

170
apps/server/src/services/llm/pipeline/stages/model_selection_stage.ts
View File

@ -100,25 +100,28 @@ export class ModelSelectionStage extends BasePipelineStage<ModelSelectionInput,
// Get selected provider and model using the new configuration system // Get selected provider and model using the new configuration system
try { try {
// Use the new configuration helpers - no string parsing! // Use the configuration helpers to get a validated model config
const selectedProvider = await getSelectedProvider(); const selectedProvider = await getSelectedProvider();
if (!selectedProvider) { if (!selectedProvider) {
throw new Error('No AI provider is selected. Please select a provider in your AI settings.'); throw new Error('No AI provider is selected. Please select a provider in your AI settings.');
} }
const modelName = await getDefaultModelForProvider(selectedProvider); // First try to get a valid model config (this checks both selection and configuration)
const { getValidModelConfig } = await import('../../config/configuration_helpers.js');
const modelConfig = await getValidModelConfig(selectedProvider);
if (!modelName) { if (modelConfig) {
// Try to fetch and set a default model from the provider // We have a valid configured model
updatedOptions.model = modelConfig.model;
} else {
// No model configured, try to fetch and set a default from the service
const fetchedModel = await this.fetchAndSetDefaultModel(selectedProvider); const fetchedModel = await this.fetchAndSetDefaultModel(selectedProvider);
if (!fetchedModel) { if (!fetchedModel) {
throw new Error(`No default model configured for provider ${selectedProvider}. Please set a default model in your AI settings.`); throw new Error(`No default model configured for provider ${selectedProvider}. Please set a default model in your AI settings or ensure the provider service is available.`);
} }
// Use the fetched model // Use the fetched model
updatedOptions.model = fetchedModel; updatedOptions.model = fetchedModel;
} else {
updatedOptions.model = modelName;
} }
log.info(`Selected provider: ${selectedProvider}, model: ${updatedOptions.model}`); log.info(`Selected provider: ${selectedProvider}, model: ${updatedOptions.model}`);
@ -217,25 +220,27 @@ export class ModelSelectionStage extends BasePipelineStage<ModelSelectionInput,
/** /**
* Determine model based on selected provider using the new configuration system * Determine model based on selected provider using the new configuration system
* This method is now simplified and delegates to the main model selection logic
*/ */
private async determineDefaultModel(input: ModelSelectionInput): Promise<string> { private async determineDefaultModel(input: ModelSelectionInput): Promise<string> {
try { try {
// Use the new single provider configuration system // Use the same logic as the main process method
const { getValidModelConfig, getSelectedProvider } = await import('../../config/configuration_helpers.js');
const selectedProvider = await getSelectedProvider(); const selectedProvider = await getSelectedProvider();
if (!selectedProvider) { if (!selectedProvider) {
throw new Error('No AI provider is selected. Please select a provider in your AI settings.'); throw new Error('No AI provider is selected. Please select a provider in your AI settings.');
} }
// Check if the provider is available // Check if the provider is available through the service manager
if (!aiServiceManager.isProviderAvailable(selectedProvider)) { if (!aiServiceManager.isProviderAvailable(selectedProvider)) {
throw new Error(`Selected provider ${selectedProvider} is not available`); throw new Error(`Selected provider ${selectedProvider} is not available`);
} }
// Get the default model for the selected provider // Try to get a valid model config
const defaultModel = await getDefaultModelForProvider(selectedProvider); const modelConfig = await getValidModelConfig(selectedProvider);
if (!defaultModel) { if (!modelConfig) {
throw new Error(`No default model configured for provider ${selectedProvider}. Please configure a default model in your AI settings.`); throw new Error(`No default model configured for provider ${selectedProvider}. Please configure a default model in your AI settings.`);
} }
@ -243,12 +248,12 @@ export class ModelSelectionStage extends BasePipelineStage<ModelSelectionInput,
if (!input.options.providerMetadata) { if (!input.options.providerMetadata) {
input.options.providerMetadata = { input.options.providerMetadata = {
provider: selectedProvider as 'openai' | 'anthropic' | 'ollama' | 'local', provider: selectedProvider as 'openai' | 'anthropic' | 'ollama' | 'local',
modelId: defaultModel modelId: modelConfig.model
}; };
} }
log.info(`Selected default model ${defaultModel} from provider ${selectedProvider}`); log.info(`Selected default model ${modelConfig.model} from provider ${selectedProvider}`);
return defaultModel; return modelConfig.model;
} catch (error) { } catch (error) {
log.error(`Error determining default model: ${error}`); log.error(`Error determining default model: ${error}`);
throw error; // Don't provide fallback defaults, let the error propagate throw error; // Don't provide fallback defaults, let the error propagate
@ -279,124 +284,47 @@ export class ModelSelectionStage extends BasePipelineStage<ModelSelectionInput,
} }
/** /**
* Fetch available models from provider and set a default model * Use AI service manager to get a configured model for the provider
* This eliminates duplication and uses the existing service layer
*/ */
private async fetchAndSetDefaultModel(provider: ProviderType): Promise<string | null> { private async fetchAndSetDefaultModel(provider: ProviderType): Promise<string | null> {
try { try {
log.info(`Fetching available models for provider ${provider}`); log.info(`Getting default model for provider ${provider} using AI service manager`);
// Import server-side options to update the default model // Use the existing AI service manager instead of duplicating API calls
const optionService = (await import('../../../options.js')).default; const service = aiServiceManager.getInstance().getService(provider);
switch (provider) { if (!service || !service.isAvailable()) {
case 'openai': log.info(`Provider ${provider} service is not available`);
const openaiModels = await this.fetchOpenAIModels(); return null;
if (openaiModels.length > 0) { }
// Use the first available model without any preferences
const selectedModel = openaiModels[0]; // Check if the service has a method to get available models
if (typeof (service as any).getAvailableModels === 'function') {
try {
const models = await (service as any).getAvailableModels();
if (models && models.length > 0) {
// Use the first available model - no hardcoded preferences
const selectedModel = models[0];
await optionService.setOption('openaiDefaultModel', selectedModel); // Import server-side options to update the default model
log.info(`Set default OpenAI model to: ${selectedModel}`); const optionService = (await import('../../../options.js')).default;
const optionKey = `${provider}DefaultModel` as const;
await optionService.setOption(optionKey, selectedModel);
log.info(`Set default ${provider} model to: ${selectedModel}`);
return selectedModel; return selectedModel;
} }
break; } catch (modelError) {
log.error(`Error fetching models from ${provider} service: ${modelError}`);
case 'anthropic': }
const anthropicModels = await this.fetchAnthropicModels();
if (anthropicModels.length > 0) {
// Use the first available model without any preferences
const selectedModel = anthropicModels[0];
await optionService.setOption('anthropicDefaultModel', selectedModel);
log.info(`Set default Anthropic model to: ${selectedModel}`);
return selectedModel;
}
break;
case 'ollama':
const ollamaModels = await this.fetchOllamaModels();
if (ollamaModels.length > 0) {
// Use the first available model without any preferences
const selectedModel = ollamaModels[0];
await optionService.setOption('ollamaDefaultModel', selectedModel);
log.info(`Set default Ollama model to: ${selectedModel}`);
return selectedModel;
}
break;
} }
log.info(`No models available for provider ${provider}`); log.info(`Provider ${provider} does not support dynamic model fetching`);
return null; return null;
} catch (error) { } catch (error) {
log.error(`Error fetching models for provider ${provider}: ${error}`); log.error(`Error getting default model for provider ${provider}: ${error}`);
return null; return null;
} }
} }
/**
* Fetch available OpenAI models
*/
private async fetchOpenAIModels(): Promise<string[]> {
try {
// Use the provider service to get available models
const aiServiceManager = (await import('../../ai_service_manager.js')).default;
const service = aiServiceManager.getInstance().getService('openai');
if (service && typeof (service as any).getAvailableModels === 'function') {
return await (service as any).getAvailableModels();
}
// No fallback - return empty array if models can't be fetched
log.info('OpenAI service does not support getAvailableModels method');
return [];
} catch (error) {
log.error(`Error fetching OpenAI models: ${error}`);
return [];
}
}
/**
* Fetch available Anthropic models
*/
private async fetchAnthropicModels(): Promise<string[]> {
try {
// Use the provider service to get available models
const aiServiceManager = (await import('../../ai_service_manager.js')).default;
const service = aiServiceManager.getInstance().getService('anthropic');
if (service && typeof (service as any).getAvailableModels === 'function') {
return await (service as any).getAvailableModels();
}
// No fallback - return empty array if models can't be fetched
log.info('Anthropic service does not support getAvailableModels method');
return [];
} catch (error) {
log.error(`Error fetching Anthropic models: ${error}`);
return [];
}
}
/**
* Fetch available Ollama models
*/
private async fetchOllamaModels(): Promise<string[]> {
try {
// Use the provider service to get available models
const aiServiceManager = (await import('../../ai_service_manager.js')).default;
const service = aiServiceManager.getInstance().getService('ollama');
if (service && typeof (service as any).getAvailableModels === 'function') {
return await (service as any).getAvailableModels();
}
// No fallback - return empty array if models can't be fetched
log.info('Ollama service does not support getAvailableModels method');
return [];
} catch (error) {
log.error(`Error fetching Ollama models: ${error}`);
return [];
}
}
} }