Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

5.2 KB
Raw Blame
import keyBy from 'lodash/keyBy';
import {
  agentParamSettings,
  tConversationSchema,
  applyModelAwareDefaults,
  getEndpointField,
  getSettingsKeys,
  normalizeEndpointName,
  resolveDropParamsUIKeys,
  ReasoningParameterFormat,
} from 'librechat-data-provider';
import type {
  AgentModelParameters,
  SettingDefinition,
  TModelReasoning,
  TEndpointsConfig,
  TStartupConfig,
} from 'librechat-data-provider';

export type AgentParameterConfig = {
  endpointsConfig?: TEndpointsConfig | null;
  startupConfig?: Pick<TStartupConfig, 'endpointsDropParamsMap'> | null;
};

export type ResolvedAgentParameterSettings = {
  /**
   * Every parameter the endpoint schema defines after administrator drops. Pruning reads
   * this, so a value hidden by the model or role is still recognised and preserved:
   * dropping it here would delete another user's configuration on an unrelated
   * save by someone without the permission.
   */
  parameters: SettingDefinition[];
  /** The subset that gets a control. Model-hidden and role-gated parameters are absent. */
  visibleParameters: SettingDefinition[];
  schemaResolved: boolean;
};

const NON_CONTROL_PARAMETER_KEYS = new Set<keyof AgentModelParameters>(['model']);
const REASONING_PARAMETER_KEYS = new Set([
  'include_reasoning',
  'reasoning_effort',
  'reasoning_summary',
  'reasoning_mode',
  'reasoning_context',
]);

export function resolveAgentParameterSettings({
  endpointsConfig,
  model,
  provider,
  startupConfig,
  webSearchAllowed,
  modelReasoning,
}: AgentParameterConfig & {
  model: string;
  provider: string;
  /** `WEB_SEARCH.USE`. `web_search` is a default model parameter for the OpenAI,
   *  Anthropic and Google column sets, so without this the builder offers a
   *  switch the server will refuse. Narrows `visibleParameters` only. */
  webSearchAllowed: boolean;
  /** Provider-reported efforts for `model` on an OpenRouter endpoint; `undefined` while unknown. */
  modelReasoning?: TModelReasoning | null;
}): ResolvedAgentParameterSettings {
  const resolvedEndpointsConfig = endpointsConfig ?? {};
  const endpointType = getEndpointField(resolvedEndpointsConfig, provider, 'type');
  const customParams = resolvedEndpointsConfig[provider]?.customParams;
  const [combinedKey, endpointKey] = getSettingsKeys(endpointType ?? provider, model);
  const overriddenEndpointKey = customParams?.defaultParamsEndpoint ?? endpointKey;
  const dropParamsMap = startupConfig?.endpointsDropParamsMap;
  const dropParamsEntry =
    dropParamsMap?.[provider] ?? dropParamsMap?.[normalizeEndpointName(provider)];
  const resolvedDropParams = Array.isArray(dropParamsEntry)
    ? dropParamsEntry
    : dropParamsEntry?.[model];
  const dropParamsSet = resolveDropParamsUIKeys(
    Array.isArray(resolvedDropParams) ? resolvedDropParams : undefined,
    overriddenEndpointKey,
  );
  const defaultParams =
    agentParamSettings[combinedKey] ?? agentParamSettings[overriddenEndpointKey];
  const overriddenParams = customParams?.paramDefinitions;
  const overriddenParamsMap = keyBy(overriddenParams ?? [], 'key');
  /** Keep endpoint-recognized keys independent of model visibility. Only explicit
   * administrator drops remove keys from the schema used by both save paths. */
  const declaredExtras = (overriddenParams ?? []).filter(
    (param): param is SettingDefinition =>
      param.key != null &&
      param.type != null &&
      param.component != null &&
      !Object.prototype.hasOwnProperty.call(tConversationSchema.shape, param.key),
  );
  const endpointParams = [...(defaultParams ?? []), ...declaredExtras].filter(
    (param) => param != null && !dropParamsSet.has(param.key),
  );
  const applyOverride = (param: SettingDefinition) =>
    (overriddenParamsMap[param.key] as SettingDefinition) ?? param;
  const parameters = endpointParams.map(applyOverride);
  const visibleParameters = applyModelAwareDefaults(
    endpointParams,
    overriddenEndpointKey,
    model,
    resolvedEndpointsConfig[provider]?.responsesApiRouting,
    modelReasoning,
  )
    .map(applyOverride)
    .filter((param) => param.key !== 'web_search' || webSearchAllowed)
    .filter(
      (param) =>
        customParams?.reasoningFormat !== ReasoningParameterFormat.disabled ||
        !REASONING_PARAMETER_KEYS.has(param.key),
    );

  return {
    schemaResolved: defaultParams != null || overriddenParams != null,
    parameters,
    visibleParameters,
  };
}

export function pruneAgentModelParameters(
  currentParameters: AgentModelParameters | undefined,
  settings: ResolvedAgentParameterSettings,
): AgentModelParameters {
  const normalizedParameters = currentParameters ?? ({} as AgentModelParameters);
  if (!settings.schemaResolved) {
    return normalizedParameters;
  }

  const parameterKeys = new Set(settings.parameters.map((setting) => setting.key));
  const currentKeys = Object.keys(normalizedParameters) as Array<keyof AgentModelParameters>;
  let prunedParameters: Partial<AgentModelParameters> | undefined;

  for (const key of currentKeys) {
    if (
      NON_CONTROL_PARAMETER_KEYS.has(key) ||
      parameterKeys.has(key) ||
      normalizedParameters[key] == null
    ) {
      continue;
    }

    prunedParameters ??= { ...normalizedParameters };
    delete prunedParameters[key];
  }

  return (prunedParameters ?? normalizedParameters) as AgentModelParameters;
}