gaschz/trilium
1
0
Fork 0
mirror of https://github.com/zadam/trilium.git synced 2025-11-04 13:39:01 +01:00
Code Issues Actions 18 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
try {
// Use the new configuration helpers - no string parsing!
// Use the configuration helpers to get a validated model config
const selectedProvider = await getSelectedProvider();
if (!selectedProvider) {
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) {
// Try to fetch and set a default model from the provider
if (modelConfig) {
// 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);
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
updatedOptions.model = fetchedModel;
} else {
updatedOptions.model = modelName;
}
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
* This method is now simplified and delegates to the main model selection logic
*/
private async determineDefaultModel(input: ModelSelectionInput): Promise<string> {
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();
if (!selectedProvider) {
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)) {
throw new Error(`Selected provider ${selectedProvider} is not available`);
}
// Get the default model for the selected provider
const defaultModel = await getDefaultModelForProvider(selectedProvider);
if (!defaultModel) {
// Try to get a valid model config
const modelConfig = await getValidModelConfig(selectedProvider);
if (!modelConfig) {
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) {
input.options.providerMetadata = {
provider: selectedProvider as 'openai' | 'anthropic' | 'ollama' | 'local',
modelId: defaultModel
modelId: modelConfig.model
};
}
log.info(`Selected default model ${defaultModel} from provider ${selectedProvider}`);
return defaultModel;
log.info(`Selected default model ${modelConfig.model} from provider ${selectedProvider}`);
return modelConfig.model;
} catch (error) {
log.error(`Error determining default model: ${error}`);
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> {
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
const optionService = (await import('../../../options.js')).default;
// Use the existing AI service manager instead of duplicating API calls
const service = aiServiceManager.getInstance().getService(provider);
switch (provider) {
case 'openai':
const openaiModels = await this.fetchOpenAIModels();
if (openaiModels.length > 0) {
// Use the first available model without any preferences
const selectedModel = openaiModels[0];
if (!service || !service.isAvailable()) {
log.info(`Provider ${provider} service is not available`);
return null;
}
// 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);
log.info(`Set default OpenAI model to: ${selectedModel}`);
// Import server-side options to update the default model
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;
}
break;
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;
} catch (modelError) {
log.error(`Error fetching models from ${provider} service: ${modelError}`);
}
}
log.info(`No models available for provider ${provider}`);
log.info(`Provider ${provider} does not support dynamic model fetching`);
return null;
} catch (error) {
log.error(`Error fetching models for provider ${provider}: ${error}`);
log.error(`Error getting default model for provider ${provider}: ${error}`);
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 [];
}
}
}