Skip to content

The open alternative to Salesforce, designed for AI.

fix(ai): keep catalog efforts under an AI_PROVIDERS override and fix tier UI findings (#25753)

Félix Malfait5a03d6a2a5d8
diff --git a/packages/twenty-front/src/hooks/useNavigateApp.ts b/packages/twenty-front/src/hooks/useNavigateApp.ts
index bf5a743982c..80f798eb344 100644
--- a/packages/twenty-front/src/hooks/useNavigateApp.ts
+++ b/packages/twenty-front/src/hooks/useNavigateApp.ts
@@ -1,19 +1,26 @@
+import { useCallback } from 'react';
import { useNavigate } from 'react-router-dom';
import { type AppPath, type NavigateOptions } from 'twenty-shared/types';
import { getAppPath } from 'twenty-shared/utils';
type NavigateAppOptions = NavigateOptions;
+// Stable across renders so an effect can list it as a dependency without
+// re-running every time the caller renders.
export const useNavigateApp = () => {
const navigate = useNavigate();
- return <T extends AppPath>(
- to: T,
- params?: Parameters<typeof getAppPath<T>>[1],
- queryParams?: Record<string, any>,
- options?: NavigateAppOptions,
- ) => {
- const path = getAppPath(to, params, queryParams);
- return navigate(path, options);
- };
+ return useCallback(
+ <T extends AppPath>(
+ to: T,
+ params?: Parameters<typeof getAppPath<T>>[1],
+ queryParams?: Record<string, any>,
+ options?: NavigateAppOptions,
+ ) => {
+ const path = getAppPath(to, params, queryParams);
+
+ return navigate(path, options);
+ },
+ [navigate],
+ );
};
diff --git a/packages/twenty-front/src/modules/ai/components/AiModelTierBars.tsx b/packages/twenty-front/src/modules/ai/components/AiModelTierBars.tsx
index 346d7e7ee4d..d33ca3c91b6 100644
--- a/packages/twenty-front/src/modules/ai/components/AiModelTierBars.tsx
+++ b/packages/twenty-front/src/modules/ai/components/AiModelTierBars.tsx
@@ -43,7 +43,9 @@ type AiModelTierBarsProps = {
};
// One bar per tier, filled up to the selected one, so the composer shows the
-// level without spending the space a label would take.
+// level without spending the space a label would take. A native button, like
+// every other dropdown trigger, so it is focusable and ignores clicks when
+// disabled; the dropdown's wrapper is not.
export const AiModelTierBars = ({
selectedTier,
label,
diff --git a/packages/twenty-front/src/modules/ai/hooks/useAiModelTiers.ts b/packages/twenty-front/src/modules/ai/hooks/useAiModelTiers.ts
index 8ef25af8004..44bae772797 100644
--- a/packages/twenty-front/src/modules/ai/hooks/useAiModelTiers.ts
+++ b/packages/twenty-front/src/modules/ai/hooks/useAiModelTiers.ts
@@ -5,6 +5,7 @@ import { isDefined } from 'twenty-shared/utils';
import { type ResolvedAiModelTier } from '@/ai/types/ResolvedAiModelTier';
import { getAiModelTierLabel } from '@/ai/utils/getAiModelTierLabel';
import { getPercentDelta } from '@/ai/utils/getPercentDelta';
+import { hasCostPerTaskForEveryModel } from '@/ai/utils/hasCostPerTaskForEveryModel';
import { currentWorkspaceState } from '@/auth/states/currentWorkspaceState';
import { aiModelTiersState } from '@/client-config/states/aiModelTiersState';
import { aiModelsState } from '@/client-config/states/aiModelsState';
@@ -14,27 +15,26 @@ import { type ClientAiModelConfig } from '~/generated-metadata/graphql';
const REFERENCE_TIER: AiModelTier = 'balanced';
-// Both sides of a cost comparison must use the same basis: the publisher's
-// cost per task when both models have one, the catalog price otherwise.
+// Every tier's cost delta must use the same basis: the publisher's cost per
+// task when every tier has one, the catalog price otherwise.
const getCostDeltaPercent = ({
model,
referenceModel,
+ hasCostPerTaskForEveryTier,
}: {
model: ClientAiModelConfig | undefined;
referenceModel: ClientAiModelConfig | undefined;
+ hasCostPerTaskForEveryTier: boolean;
}) => {
if (!isDefined(model) || !isDefined(referenceModel)) {
return undefined;
}
- const hasCostPerTask =
- isDefined(model.costPerTask) && isDefined(referenceModel.costPerTask);
-
return getPercentDelta({
- value: hasCostPerTask
+ value: hasCostPerTaskForEveryTier
? model.costPerTask
: getAiModelBlendedCostPerMillionTokens(model),
- reference: hasCostPerTask
+ reference: hasCostPerTaskForEveryTier
? referenceModel.costPerTask
: getAiModelBlendedCostPerMillionTokens(referenceModel),
});
@@ -76,6 +76,9 @@ export const useAiModelTiers = (): ResolvedAiModelTier[] => {
const referenceModel = resolvedModels.find(
(resolved) => resolved.tier === REFERENCE_TIER,
)?.model;
+ const hasCostPerTaskForEveryTier = hasCostPerTaskForEveryModel(
+ resolvedModels.map(({ model }) => model),
+ );
return resolvedModels.map(({ tier, model, isPinned }) => ({
tier,
@@ -90,7 +93,11 @@ export const useAiModelTiers = (): ResolvedAiModelTier[] => {
value: model?.intelligenceIndex,
reference: referenceModel?.intelligenceIndex,
}),
- costDeltaPercent: getCostDeltaPercent({ model, referenceModel }),
+ costDeltaPercent: getCostDeltaPercent({
+ model,
+ referenceModel,
+ hasCostPerTaskForEveryTier,
+ }),
}));
}, [aiModels, aiModelTiers, isAutoModelSelectionEnabled, aiModelIdByTier]);
};
diff --git a/packages/twenty-front/src/modules/ai/utils/__tests__/hasCostPerTaskForEveryModel.test.ts b/packages/twenty-front/src/modules/ai/utils/__tests__/hasCostPerTaskForEveryModel.test.ts
new file mode 100644
index 00000000000..6ced9a1b5cb
--- /dev/null
+++ b/packages/twenty-front/src/modules/ai/utils/__tests__/hasCostPerTaskForEveryModel.test.ts
@@ -0,0 +1,23 @@
+import { hasCostPerTaskForEveryModel } from '@/ai/utils/hasCostPerTaskForEveryModel';
+
+describe('hasCostPerTaskForEveryModel', () => {
+ it('is true when every resolved model carries a cost per task', () => {
+ expect(
+ hasCostPerTaskForEveryModel([{ costPerTask: 0.1 }, { costPerTask: 2.3 }]),
+ ).toBe(true);
+ });
+
+ it('is false as soon as one resolved model has no cost per task', () => {
+ expect(hasCostPerTaskForEveryModel([{ costPerTask: 0.1 }, {}])).toBe(false);
+ });
+
+ it('ignores tiers that resolved to no model', () => {
+ expect(hasCostPerTaskForEveryModel([undefined, { costPerTask: 0.1 }])).toBe(
+ true,
+ );
+ });
+
+ it('is true with nothing to compare', () => {
+ expect(hasCostPerTaskForEveryModel([])).toBe(true);
+ });
+});
diff --git a/packages/twenty-front/src/modules/ai/utils/hasCostPerTaskForEveryModel.ts b/packages/twenty-front/src/modules/ai/utils/hasCostPerTaskForEveryModel.ts
new file mode 100644
index 00000000000..7bc590e7281
--- /dev/null
+++ b/packages/twenty-front/src/modules/ai/utils/hasCostPerTaskForEveryModel.ts
@@ -0,0 +1,10 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { type ClientAiModelConfig } from '~/generated-metadata/graphql';
+
+// Cost per task and price per token are different bases, so a comparison
+// across tiers uses cost per task only when every resolved model has one.
+export const hasCostPerTaskForEveryModel = (
+ models: (Pick<ClientAiModelConfig, 'costPerTask'> | undefined)[],
+): boolean =>
+ models.every((model) => !isDefined(model) || isDefined(model.costPerTask));
diff --git a/packages/twenty-front/src/pages/settings/ai/components/SettingsAiModelTiersPreview.tsx b/packages/twenty-front/src/pages/settings/ai/components/SettingsAiModelTiersPreview.tsx
index 84e9ab3791c..9f641e9644a 100644
--- a/packages/twenty-front/src/pages/settings/ai/components/SettingsAiModelTiersPreview.tsx
+++ b/packages/twenty-front/src/pages/settings/ai/components/SettingsAiModelTiersPreview.tsx
@@ -7,6 +7,7 @@ import { AppTooltip, TooltipDelay } from 'twenty-ui/surfaces';
import { themeCssVariables } from 'twenty-ui/theme-constants';
import { useAiModelTiers } from '@/ai/hooks/useAiModelTiers';
+import { hasCostPerTaskForEveryModel } from '@/ai/utils/hasCostPerTaskForEveryModel';
import { type ResolvedAiModelTier } from '@/ai/types/ResolvedAiModelTier';
import { getAiModelBlendedCostPerMillionTokens } from '@/settings/ai/utils/getAiModelBlendedCostPerMillionTokens';
import { Table } from '@/ui/layout/table/components/Table';
@@ -46,14 +47,20 @@ const formatIntelligence = (tier: ResolvedAiModelTier) =>
: EMPTY_VALUE;
// Artificial Analysis measures a cost per task at the same time as the index.
-// Where a model has no such reading, the catalog prices give a blended price
-// per million tokens instead, so the unit is spelled out on every row.
-const formatCost = (tier: ResolvedAiModelTier) => {
+// The column only uses it when every tier has one; otherwise the rows would
+// mix a price per task with a price per million tokens and stop comparing.
+const formatCost = ({
+ tier,
+ hasCostPerTaskForEveryTier,
+}: {
+ tier: ResolvedAiModelTier;
+ hasCostPerTaskForEveryTier: boolean;
+}) => {
if (!isDefined(tier.model)) {
return EMPTY_VALUE;
}
- if (isDefined(tier.model.costPerTask)) {
+ if (hasCostPerTaskForEveryTier && isDefined(tier.model.costPerTask)) {
return t`$${formatNumber(tier.model.costPerTask, { decimals: 2 })} / task`;
}
@@ -66,6 +73,9 @@ const formatCost = (tier: ResolvedAiModelTier) => {
export const SettingsAiModelTiersPreview = () => {
const tiers = useAiModelTiers();
+ const hasCostPerTaskForEveryTier = hasCostPerTaskForEveryModel(
+ tiers.map((tier) => tier.model),
+ );
return (
<Section>
@@ -93,7 +103,9 @@ export const SettingsAiModelTiersPreview = () => {
<TableCell align="right">
{renderBenchmarkValue(tier, formatIntelligence(tier))}
</TableCell>
- <TableCell align="right">{formatCost(tier)}</TableCell>
+ <TableCell align="right">
+ {formatCost({ tier, hasCostPerTaskForEveryTier })}
+ </TableCell>
</TableRow>
))}
</Table>
diff --git a/packages/twenty-front/src/pages/settings/ai/hooks/useSettingsAgentFormState.ts b/packages/twenty-front/src/pages/settings/ai/hooks/useSettingsAgentFormState.ts
index 8f7f63a2aae..6292c25103c 100644
--- a/packages/twenty-front/src/pages/settings/ai/hooks/useSettingsAgentFormState.ts
+++ b/packages/twenty-front/src/pages/settings/ai/hooks/useSettingsAgentFormState.ts
@@ -1,4 +1,4 @@
-import { useState } from 'react';
+import { useCallback, useState } from 'react';
import { AUTO_SELECT_WORKSPACE_DEFAULT_MODEL_ID } from 'twenty-shared/ai';
import { isDefined } from 'twenty-shared/utils';
import { type z } from 'zod';
@@ -37,35 +37,44 @@ export const useSettingsAgentFormState = (mode: 'create' | 'edit') => {
}
};
- const handleFieldChange = (
- field: keyof SettingsAiAgentFormValues,
- value: SettingsAiAgentFormValues[keyof SettingsAiAgentFormValues],
- ) => {
- setFormValues((prev) => ({ ...prev, [field]: value }));
- };
+ const handleFieldChange = useCallback(
+ (
+ field: keyof SettingsAiAgentFormValues,
+ value: SettingsAiAgentFormValues[keyof SettingsAiAgentFormValues],
+ ) => {
+ setFormValues((prev) => ({ ...prev, [field]: value }));
+ },
+ [],
+ );
- const resetForm = (values?: Partial<SettingsAiAgentFormValues>) => {
- if (isDefined(values)) {
- setFormValues((prev) => ({ ...prev, ...values }));
- } else {
- setFormValues({
- name: '',
- label: '',
- description: '',
- icon: 'IconLego',
- modelId: mode === 'edit' ? '' : AUTO_SELECT_WORKSPACE_DEFAULT_MODEL_ID,
- role: '',
- prompt: '',
- isCustom: true,
- modelConfiguration: {},
- responseFormat: {
- // TODO: Keep text default until legacy text agents are migrated in production.
- type: 'text',
- },
- evaluationInputs: [],
- });
- }
- };
+ // Stable so the effect that loads an agent into the form can list it as a
+ // dependency without re-running, and re-setting state, on every render.
+ const resetForm = useCallback(
+ (values?: Partial<SettingsAiAgentFormValues>) => {
+ if (isDefined(values)) {
+ setFormValues((prev) => ({ ...prev, ...values }));
+ } else {
+ setFormValues({
+ name: '',
+ label: '',
+ description: '',
+ icon: 'IconLego',
+ modelId:
+ mode === 'edit' ? '' : AUTO_SELECT_WORKSPACE_DEFAULT_MODEL_ID,
+ role: '',
+ prompt: '',
+ isCustom: true,
+ modelConfiguration: {},
+ responseFormat: {
+ // TODO: Keep text default until legacy text agents are migrated in production.
+ type: 'text',
+ },
+ evaluationInputs: [],
+ });
+ }
+ },
+ [mode],
+ );
return {
formValues,
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-models/services/ai-model-registry.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-models/services/ai-model-registry.service.ts
index d68c42ae171..2c6517f9460 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-models/services/ai-model-registry.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-models/services/ai-model-registry.service.ts
@@ -38,6 +38,7 @@ import { isAutoSelectModelId, isDefined } from 'twenty-shared/utils';
import { DEFAULT_MAX_OUTPUT_TOKENS } from 'src/engine/metadata-modules/ai/ai-models/types/default-max-output-tokens.const';
import { buildCompositeModelId } from 'src/engine/metadata-modules/ai/ai-models/utils/composite-model-id.util';
+import { getAiModelTiersByDistance } from 'src/engine/metadata-modules/ai/ai-models/utils/get-ai-model-tiers-by-distance.util';
import { getAvailableEfforts } from 'src/engine/metadata-modules/ai/ai-models/utils/get-available-efforts.util';
import { getPositiveTokenLimitOrDefault } from 'src/engine/metadata-modules/ai/ai-models/utils/get-positive-token-limit-or-default.util';
import { inferModelFamily } from 'src/engine/metadata-modules/ai/ai-models/utils/infer-model-family.util';
@@ -428,13 +429,28 @@ export class AiModelRegistryService {
return undefined;
}
- // The last resort is any model the admin still allows: a chain that names
- // only disabled models must not hand a disabled one to the client.
+ // A rung whose chain names nothing available borrows the nearest rung's
+ // chain, so an instance with two models lands on the neighbouring tier
+ // rather than on whatever the catalog happens to list first. The last
+ // resort is any model the admin still allows, a current one before a
+ // deprecated one: a chain that names only disabled models must not hand a
+ // disabled one to the client.
findDefaultModelForTier(tier: AiModelTier): RegisteredAiModel | undefined {
+ for (const candidateTier of getAiModelTiersByDistance(tier)) {
+ const model = this.getFirstAvailableModelFromList(
+ this.preferencesService.getDefaultModelIdsForTier(candidateTier),
+ );
+
+ if (isDefined(model)) {
+ return model;
+ }
+ }
+
+ const allowedModels = this.getAdminFilteredModels();
+
return (
- this.getFirstAvailableModelFromList(
- this.preferencesService.getDefaultModelIdsForTier(tier),
- ) ?? this.getAdminFilteredModels()[0]
+ allowedModels.find((model) => model.isDeprecated !== true) ??
+ allowedModels[0]
);
}
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-models/services/provider-config.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-models/services/provider-config.service.ts
index ba383b15868..f3ff86f1b72 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-models/services/provider-config.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-models/services/provider-config.service.ts
@@ -7,6 +7,7 @@ import { DefaultAiCatalogService } from 'src/engine/metadata-modules/ai/ai-model
import { type AiProviderConfig } from 'src/engine/metadata-modules/ai/ai-models/types/ai-provider-config.type';
import { type AiProvidersConfig } from 'src/engine/metadata-modules/ai/ai-models/types/ai-providers-config.type';
import { extractConfigVariableName } from 'src/engine/metadata-modules/ai/ai-models/utils/extract-config-variable-name.util';
+import { mergeCustomProvidersIntoCatalog } from 'src/engine/metadata-modules/ai/ai-models/utils/merge-custom-providers-into-catalog.util';
@Injectable()
export class ProviderConfigService {
@@ -35,9 +36,10 @@ export class ProviderConfigService {
return catalog;
}
- const custom = this.twentyConfigService.get('AI_PROVIDERS');
-
- return { ...catalog, ...custom };
+ return mergeCustomProvidersIntoCatalog({
+ catalog,
+ custom: this.twentyConfigService.get('AI_PROVIDERS'),
+ });
}
private resolveTemplates(providers: AiProvidersConfig): AiProvidersConfig {
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-models/utils/__tests__/get-ai-model-tiers-by-distance.util.spec.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-models/utils/__tests__/get-ai-model-tiers-by-distance.util.spec.ts
new file mode 100644
index 00000000000..50e79aa3909
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-models/utils/__tests__/get-ai-model-tiers-by-distance.util.spec.ts
@@ -0,0 +1,23 @@
+import { getAiModelTiersByDistance } from 'src/engine/metadata-modules/ai/ai-models/utils/get-ai-model-tiers-by-distance.util';
+
+describe('getAiModelTiersByDistance', () => {
+ it('starts with the tier itself and walks outward, lower rung first', () => {
+ expect(getAiModelTiersByDistance('balanced')).toEqual([
+ 'balanced',
+ 'fast',
+ 'smart',
+ 'extraFast',
+ 'extraSmart',
+ ]);
+ });
+
+ it('walks down the whole ladder from the top rung', () => {
+ expect(getAiModelTiersByDistance('extraSmart')).toEqual([
+ 'extraSmart',
+ 'smart',
+ 'balanced',
+ 'fast',
+ 'extraFast',
+ ]);
+ });
+});
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-models/utils/__tests__/merge-custom-providers-into-catalog.util.spec.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-models/utils/__tests__/merge-custom-providers-into-catalog.util.spec.ts
new file mode 100644
index 00000000000..6eebd63b237
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-models/utils/__tests__/merge-custom-providers-into-catalog.util.spec.ts
@@ -0,0 +1,197 @@
+import { type AiProvidersConfig } from 'src/engine/metadata-modules/ai/ai-models/types/ai-providers-config.type';
+import { mergeCustomProvidersIntoCatalog } from 'src/engine/metadata-modules/ai/ai-models/utils/merge-custom-providers-into-catalog.util';
+
+const catalog: AiProvidersConfig = {
+ openai: {
+ npm: '@ai-sdk/openai',
+ label: 'OpenAI',
+ apiKey: '{{OPENAI_API_KEY}}',
+ models: [
+ {
+ name: 'gpt-5.6-luna',
+ label: 'GPT-5.6 Luna',
+ efforts: ['low', 'medium', 'high'],
+ benchmark: { intelligenceIndex: 37.5 },
+ inputCostPerMillionTokens: 0.2,
+ outputCostPerMillionTokens: 1.2,
+ },
+ {
+ name: 'gpt-5.6-sol',
+ label: 'GPT-5.6 Sol',
+ inputCostPerMillionTokens: 4,
+ outputCostPerMillionTokens: 20,
+ },
+ ],
+ },
+} as unknown as AiProvidersConfig;
+
+describe('mergeCustomProvidersIntoCatalog', () => {
+ it('keeps catalog efforts and benchmarks on a custom model the catalog knows', () => {
+ const merged = mergeCustomProvidersIntoCatalog({
+ catalog,
+ custom: {
+ openai: {
+ npm: '@ai-sdk/openai',
+ label: 'OpenAI (gateway)',
+ apiKey: 'sk-custom',
+ models: [
+ {
+ name: 'gpt-5.6-luna',
+ label: 'Luna via gateway',
+ inputCostPerMillionTokens: 0.3,
+ outputCostPerMillionTokens: 1.5,
+ },
+ ],
+ },
+ } as unknown as AiProvidersConfig,
+ });
+
+ expect(merged.openai.label).toBe('OpenAI (gateway)');
+ expect(merged.openai.apiKey).toBe('sk-custom');
+ expect(merged.openai.models).toHaveLength(1);
+ expect(merged.openai.models?.[0]).toMatchObject({
+ name: 'gpt-5.6-luna',
+ label: 'Luna via gateway',
+ efforts: ['low', 'medium', 'high'],
+ benchmark: { intelligenceIndex: 37.5 },
+ inputCostPerMillionTokens: 0.3,
+ outputCostPerMillionTokens: 1.5,
+ });
+ });
+
+ it('completes a custom reading with the catalog readings it does not set', () => {
+ const catalogWithReadings = {
+ openai: {
+ ...catalog.openai,
+ models: [
+ {
+ name: 'gpt-5.6-luna',
+ label: 'GPT-5.6 Luna',
+ efforts: ['low', 'high'],
+ benchmark: { intelligenceIndex: 37.5, outputTokensPerSecond: 120 },
+ benchmarkByEffort: {
+ low: { intelligenceIndex: 21.8 },
+ high: { intelligenceIndex: 32.9 },
+ },
+ },
+ ],
+ },
+ } as unknown as AiProvidersConfig;
+
+ const merged = mergeCustomProvidersIntoCatalog({
+ catalog: catalogWithReadings,
+ custom: {
+ openai: {
+ ...catalog.openai,
+ models: [
+ {
+ name: 'gpt-5.6-luna',
+ label: 'GPT-5.6 Luna',
+ benchmark: { costPerTask: 0.1 },
+ benchmarkByEffort: { high: { intelligenceIndex: 33 } },
+ },
+ ],
+ },
+ } as unknown as AiProvidersConfig,
+ });
+
+ expect(merged.openai.models?.[0]).toMatchObject({
+ efforts: ['low', 'high'],
+ benchmark: {
+ intelligenceIndex: 37.5,
+ outputTokensPerSecond: 120,
+ costPerTask: 0.1,
+ },
+ benchmarkByEffort: {
+ low: { intelligenceIndex: 21.8 },
+ high: { intelligenceIndex: 33 },
+ },
+ });
+ });
+
+ it('leaves a model the catalog does not know untouched', () => {
+ const merged = mergeCustomProvidersIntoCatalog({
+ catalog,
+ custom: {
+ openai: {
+ npm: '@ai-sdk/openai',
+ label: 'OpenAI',
+ apiKey: 'sk-custom',
+ models: [{ name: 'gpt-7', label: 'GPT-7' }],
+ },
+ } as unknown as AiProvidersConfig,
+ });
+
+ expect(merged.openai.models).toEqual([{ name: 'gpt-7', label: 'GPT-7' }]);
+ });
+
+ it('gives a route outside the catalog the readings of the model it serves, never its prices', () => {
+ const merged = mergeCustomProvidersIntoCatalog({
+ catalog,
+ custom: {
+ 'amazon-bedrock': {
+ npm: '@ai-sdk/amazon-bedrock',
+ label: 'Bedrock',
+ models: [
+ {
+ name: 'eu.openai.gpt-5.6-luna-v1:0',
+ label: 'Luna on Bedrock',
+ inputCostPerMillionTokens: 0.25,
+ outputCostPerMillionTokens: 1.5,
+ },
+ { name: 'eu.mistral.pixtral-large', label: 'Pixtral' },
+ ],
+ },
+ } as unknown as AiProvidersConfig,
+ });
+
+ expect(merged['amazon-bedrock'].models?.[0]).toEqual({
+ name: 'eu.openai.gpt-5.6-luna-v1:0',
+ label: 'Luna on Bedrock',
+ inputCostPerMillionTokens: 0.25,
+ outputCostPerMillionTokens: 1.5,
+ efforts: ['low', 'medium', 'high'],
+ benchmark: { intelligenceIndex: 37.5 },
+ benchmarkByEffort: undefined,
+ });
+ expect(merged['amazon-bedrock'].models?.[1]).toEqual({
+ name: 'eu.mistral.pixtral-large',
+ label: 'Pixtral',
+ efforts: undefined,
+ benchmark: undefined,
+ benchmarkByEffort: undefined,
+ });
+ expect(merged.openai).toBe(catalog.openai);
+ });
+
+ it('matches a dotted model name to itself before stripping route segments', () => {
+ const catalogWithDottedName = {
+ openai: {
+ ...catalog.openai,
+ models: [
+ {
+ name: 'gpt-4.1',
+ label: 'GPT-4.1',
+ benchmark: { intelligenceIndex: 12.7 },
+ },
+ { name: '1', label: 'One', benchmark: { intelligenceIndex: 1 } },
+ ],
+ },
+ } as unknown as AiProvidersConfig;
+
+ const merged = mergeCustomProvidersIntoCatalog({
+ catalog: catalogWithDottedName,
+ custom: {
+ 'azure-foundry': {
+ npm: '@ai-sdk/azure',
+ label: 'Azure',
+ models: [{ name: 'gpt-4.1', label: 'GPT-4.1 on Azure' }],
+ },
+ } as unknown as AiProvidersConfig,
+ });
+
+ expect(merged['azure-foundry'].models?.[0]?.benchmark).toEqual({
+ intelligenceIndex: 12.7,
+ });
+ });
+});
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-models/utils/get-ai-model-tiers-by-distance.util.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-models/utils/get-ai-model-tiers-by-distance.util.ts
new file mode 100644
index 00000000000..52f21d90d73
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-models/utils/get-ai-model-tiers-by-distance.util.ts
@@ -0,0 +1,16 @@
+import { AI_MODEL_TIERS, type AiModelTier } from 'twenty-shared/ai';
+
+// The tier itself first, then its neighbours by distance, the lower rung
+// before the higher one at equal distance so a missing rung borrows the
+// cheaper side of the ladder.
+export const getAiModelTiersByDistance = (tier: AiModelTier): AiModelTier[] => {
+ const tierIndex = AI_MODEL_TIERS.indexOf(tier);
+ const distanceOf = (candidate: AiModelTier) =>
+ Math.abs(AI_MODEL_TIERS.indexOf(candidate) - tierIndex);
+
+ return [...AI_MODEL_TIERS].sort(
+ (first, second) =>
+ distanceOf(first) - distanceOf(second) ||
+ AI_MODEL_TIERS.indexOf(first) - AI_MODEL_TIERS.indexOf(second),
+ );
+};
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-models/utils/merge-custom-providers-into-catalog.util.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-models/utils/merge-custom-providers-into-catalog.util.ts
new file mode 100644
index 00000000000..cc920b94803
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-models/utils/merge-custom-providers-into-catalog.util.ts
@@ -0,0 +1,147 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { type AiProviderConfig } from 'src/engine/metadata-modules/ai/ai-models/types/ai-provider-config.type';
+import { type AiProviderModelConfig } from 'src/engine/metadata-modules/ai/ai-models/types/ai-provider-model-config.type';
+import { type AiProvidersConfig } from 'src/engine/metadata-modules/ai/ai-models/types/ai-providers-config.type';
+
+// A custom reading completes the catalog's rather than replacing it, so one
+// effort or one metric set by hand keeps the others the sync measured.
+const mergeDefined = <TValue extends Record<string, unknown>>({
+ catalogValue,
+ customValue,
+}: {
+ catalogValue: TValue | undefined;
+ customValue: TValue | undefined;
+}): TValue | undefined =>
+ isDefined(catalogValue) && isDefined(customValue)
+ ? { ...catalogValue, ...customValue }
+ : (customValue ?? catalogValue);
+
+// Publishers and routes spell one model differently (`claude-haiku-4-5`,
+// `claude_haiku_4.5`, `claude-haiku-4-5-v1:0`), so names are compared with
+// separators and a trailing deployment version dropped.
+const normalizeModelName = (modelName: string): string =>
+ modelName
+ .toLowerCase()
+ .replace(/-v\d+(?::\d+)?$/, '')
+ .replace(/[\s.\-_]/g, '');
+
+// Bedrock and Azure prefix a model with the region and vendor that serve it
+// (`eu.anthropic.claude-opus-4-7`). Dropping leading dot-separated segments
+// one at a time lets a route fall back to the model it serves, while a name
+// such as `gpt-4.1` still matches itself first.
+const routeCandidates = (modelName: string): string[] => {
+ const segments = modelName.split('.');
+
+ return segments.map((_, index) => segments.slice(index).join('.'));
+};
+
+const withCatalogReadings = ({
+ catalogModel,
+ customModel,
+}: {
+ catalogModel: AiProviderModelConfig;
+ customModel: AiProviderModelConfig;
+}): AiProviderModelConfig => ({
+ ...customModel,
+ efforts: customModel.efforts ?? catalogModel.efforts,
+ benchmark: mergeDefined({
+ catalogValue: catalogModel.benchmark,
+ customValue: customModel.benchmark,
+ }),
+ benchmarkByEffort: mergeDefined({
+ catalogValue: catalogModel.benchmarkByEffort,
+ customValue: customModel.benchmarkByEffort,
+ }),
+});
+
+const mergeModels = ({
+ catalogModels,
+ customModels,
+}: {
+ catalogModels: AiProviderModelConfig[];
+ customModels: AiProviderModelConfig[];
+}): AiProviderModelConfig[] =>
+ customModels.map((customModel) => {
+ const catalogModel = catalogModels.find(
+ (model) => model.name === customModel.name,
+ );
+
+ return isDefined(catalogModel)
+ ? withCatalogReadings({
+ catalogModel,
+ customModel: { ...catalogModel, ...customModel },
+ })
+ : customModel;
+ });
+
+// A provider the catalog does not know (a gateway, Bedrock, Azure) serves
+// models the catalog does know under another route. Its prices are its own,
+// so only what describes the model itself carries over: the efforts it takes
+// and the readings measured for it.
+const withReadingsFromAnyProvider = ({
+ catalog,
+ customModels,
+}: {
+ catalog: AiProvidersConfig;
+ customModels: AiProviderModelConfig[];
+}): AiProviderModelConfig[] => {
+ const catalogModelsByName = new Map<string, AiProviderModelConfig>();
+
+ for (const provider of Object.values(catalog)) {
+ for (const model of provider.models ?? []) {
+ catalogModelsByName.set(normalizeModelName(model.name), model);
+ }
+ }
+
+ return customModels.map((customModel) => {
+ const catalogModel = routeCandidates(customModel.name)
+ .map((candidate) =>
+ catalogModelsByName.get(normalizeModelName(candidate)),
+ )
+ .find(isDefined);
+
+ return isDefined(catalogModel)
+ ? withCatalogReadings({ catalogModel, customModel })
+ : customModel;
+ });
+};
+
+// A custom entry replaces the catalog provider of the same name, but an entry
+// written before the catalog carried efforts and benchmarks would then strip
+// both from every model it lists, and the tier chains could no longer name
+// an effort on it. A model the catalog knows keeps the catalog fields it does
+// not set itself; the custom entry still decides which models exist.
+export const mergeCustomProvidersIntoCatalog = ({
+ catalog,
+ custom,
+}: {
+ catalog: AiProvidersConfig;
+ custom: AiProvidersConfig;
+}): AiProvidersConfig => {
+ const merged: AiProvidersConfig = { ...catalog };
+
+ for (const [providerName, customProvider] of Object.entries(custom)) {
+ const catalogProvider: AiProviderConfig | undefined = catalog[providerName];
+
+ if (!isDefined(customProvider.models)) {
+ merged[providerName] = customProvider;
+ continue;
+ }
+
+ merged[providerName] = {
+ ...customProvider,
+ models: isDefined(catalogProvider)
+ ? mergeModels({
+ catalogModels: catalogProvider.models ?? [],
+ customModels: customProvider.models,
+ })
+ : withReadingsFromAnyProvider({
+ catalog,
+ customModels: customProvider.models,
+ }),
+ };
+ }
+
+ return merged;
+};