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

24.5 KB
Raw Blame
import { useEffect, useCallback, useRef, useState, useMemo } from 'react';
import isEqual from 'lodash/isEqual';
import { useRecoilValue } from 'recoil';
import { useLocation, useSearchParams } from 'react-router-dom';
import { useQuery, useQueryClient } from '@tanstack/react-query';
import {
  QueryKeys,
  Constants,
  parseConvo,
  EModelEndpoint,
  PermissionBits,
  getEndpointField,
  getDefaultParamsEndpoint,
} from 'librechat-data-provider';
import type {
  AgentListResponse,
  TEndpointsConfig,
  TMessage,
  TConversation,
  TStartupConfig,
  TPreset,
} from 'librechat-data-provider';
import type { QueryClient } from '@tanstack/react-query';
import {
  clearModelForNonEphemeralAgent,
  removeUnavailableTools,
  specDisplayFieldReset,
  processValidSettings,
  mergeQuerySettingsWithSpec,
  getModelSpecPreset,
  getConvoSwitchLogic,
  logger,
} from '~/utils';
import { useAuthContext, useAgentsMap, useDefaultConvo, useSubmitMessage } from '~/hooks';
import { startupConfigKey, useGetAgentByIdQuery } from '~/data-provider';
import { useChatContext, useChatFormContext } from '~/Providers';
import { isHistoryRevalidating } from '~/hooks/Chat/ask/guards';
import { consumeComposerQuery } from '~/utils/drafts';
import store from '~/store';

const PROJECT_ID_SEARCH_PARAM = 'projectId';

const injectAgentIntoAgentsMap = (
  queryClient: QueryClient,
  agent: AgentListResponse['data'][number],
) => {
  const editCacheKey = [QueryKeys.agents, { requiredPermission: PermissionBits.EDIT }];
  const editCache = queryClient.getQueryData<AgentListResponse>(editCacheKey);

  if (editCache?.data && !editCache.data.some((cachedAgent) => cachedAgent.id === agent.id)) {
    // Inject agent into EDIT cache so dropdown can display it
    const updatedCache = {
      ...editCache,
      data: [agent, ...editCache.data],
    };
    queryClient.setQueryData(editCacheKey, updatedCache);
    logger.log('agent', 'Injected URL agent into cache:', agent);
  }
};

/** Stages URL prompts, then auto-submits once normalized conversation settings match. */
export default function useQueryParams({
  textAreaRef,
  routePending = false,
  onBeforePrompt,
  onPromptSettled,
}: {
  textAreaRef: React.RefObject<HTMLTextAreaElement>;
  routePending?: boolean;
  onBeforePrompt?: () => void;
  onPromptSettled?: (text: string, conversationId: string | null | undefined) => void;
}) {
  const maxAttempts = 50;
  const attemptsRef = useRef(0);
  const MAX_SETTINGS_WAIT_MS = 3000;
  const processedRef = useRef(false);
  const pendingSubmitRef = useRef(false);
  const validatingRef = useRef(false);
  const submissionHandledRef = useRef(false);
  const promptTextRef = useRef<string | null>(null);
  const validSettingsRef = useRef<TPreset | null>(null);
  const settingsTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
  const awaitingHistoryRef = useRef(false);
  const requestIdRef = useRef(0);
  const [submissionStatus, setSubmissionStatus] = useState<'idle' | 'preparing' | 'failed'>('idle');

  const routePendingRef = useRef(routePending);
  routePendingRef.current = routePending;
  const onPromptSettledRef = useRef(onPromptSettled);
  onPromptSettledRef.current = onPromptSettled;
  const methods = useChatFormContext();
  const [searchParams, setSearchParams] = useSearchParams();
  const setSearchParamsRef = useRef(setSearchParams);
  setSearchParamsRef.current = setSearchParams;
  const location = useLocation();
  const searchIdentity = useMemo(() => {
    const params = new URLSearchParams(searchParams);
    params.sort();
    return params.toString();
  }, [searchParams]);
  const requestIdentity = useMemo(() => {
    const params = new URLSearchParams(searchIdentity);
    params.delete(PROJECT_ID_SEARCH_PARAM);
    return params.toString();
  }, [searchIdentity]);
  const previousRequestIdentityRef = useRef(requestIdentity);
  const route = {
    pathname: location.pathname,
    search: searchIdentity,
    projectId: searchParams.get(PROJECT_ID_SEARCH_PARAM),
  };
  const originRouteRef = useRef(route);
  const routeRef = useRef(route);
  routeRef.current = route;
  const originConversationRef = useRef<string | null | undefined>(null);
  const destinationRef = useRef<{
    conversationId: string;
    chatProjectId: TConversation['chatProjectId'];
    route: typeof route;
  } | null>(null);
  const cancelledRef = useRef(false);
  const mountedRef = useRef(true);
  const getDefaultConversation = useDefaultConvo();
  const modularChat = useRecoilValue(store.modularChat);
  const availableTools = useRecoilValue(store.availableTools);
  const { submitMessage } = useSubmitMessage();
  const submitMessageRef = useRef(submitMessage);
  submitMessageRef.current = submitMessage;

  const queryClient = useQueryClient();
  const { conversation, newConversation, index = 0 } = useChatContext();

  const urlAgentId = searchParams.get('agent_id') || '';
  const { data: urlAgent } = useGetAgentByIdQuery(urlAgentId);

  const getPreservedSearchParams = useCallback(() => {
    const preservedParams = new URLSearchParams();
    const projectId = routeRef.current.projectId;
    if (projectId) {
      preservedParams.set(PROJECT_ID_SEARCH_PARAM, projectId);
    }
    return preservedParams;
  }, []);

  const conversationRef = useRef(conversation);
  conversationRef.current = conversation;

  const clearConsumedSearchParams = useCallback(() => {
    const params = getPreservedSearchParams();
    consumeComposerQuery(
      index,
      conversationRef.current?.conversationId ?? Constants.NEW_CONVO,
      routeRef.current.pathname,
      routeRef.current.search,
      params.toString(),
    );
    setSearchParamsRef.current(params, { replace: true });
  }, [index, getPreservedSearchParams]);

  const ownsComposer = useCallback(() => {
    const currentId = conversationRef.current?.conversationId;
    const current = routeRef.current;
    return (
      ((current.projectId === originRouteRef.current.projectId &&
        current.pathname === originRouteRef.current.pathname) ||
        (destinationRef.current != null &&
          current.pathname === destinationRef.current.route.pathname &&
          current.projectId === destinationRef.current.route.projectId)) &&
      (!processedRef.current ||
        currentId == null ||
        currentId === originConversationRef.current ||
        currentId === destinationRef.current?.conversationId) &&
      (destinationRef.current == null ||
        currentId !== destinationRef.current.conversationId ||
        (conversationRef.current?.chatProjectId ?? null) === destinationRef.current.chatProjectId)
    );
  }, []);

  const ownsRequest = useCallback(
    (requestId = requestIdRef.current) =>
      requestId === requestIdRef.current &&
      mountedRef.current &&
      !cancelledRef.current &&
      ((routeRef.current.pathname === originRouteRef.current.pathname &&
        routeRef.current.search === originRouteRef.current.search) ||
        (routeRef.current.pathname === destinationRef.current?.route.pathname &&
          routeRef.current.search === destinationRef.current.route.search)) &&
      ownsComposer(),
    [ownsComposer],
  );

  /** Match the route that useNewConvo writes, including its inherited project. */
  const expectDestination = useCallback((template: Partial<TConversation>) => {
    const conversationId = template.conversationId ?? 'new';
    const params = new URLSearchParams(originRouteRef.current.search);
    params.delete(PROJECT_ID_SEARCH_PARAM);
    const projectId = conversationId === 'new' ? template.chatProjectId || null : null;
    if (projectId) {
      params.set(PROJECT_ID_SEARCH_PARAM, projectId);
    }
    params.sort();
    destinationRef.current = {
      conversationId,
      chatProjectId: template.chatProjectId ?? null,
      route: { pathname: `/c/${conversationId}`, search: params.toString(), projectId },
    };
  }, []);

  /** Existing chats refuse sends until their history has loaded and settled. */
  const isHistoryPending = useCallback(() => {
    const conversationId = conversationRef.current?.conversationId;
    if (conversationId == null || conversationId === Constants.NEW_CONVO) {
      return false;
    }
    const state = queryClient.getQueryState([QueryKeys.messages, conversationId]);
    if (state?.status === 'error') {
      return false;
    }
    return state?.data == null || isHistoryRevalidating(queryClient, conversationId);
  }, [queryClient]);

  const cancelRequest = useCallback(() => {
    requestIdRef.current += 1;
    cancelledRef.current = true;
    processedRef.current = true;
    submissionHandledRef.current = true;
    pendingSubmitRef.current = false;
    validatingRef.current = false;
    if (settingsTimeoutRef.current) {
      clearTimeout(settingsTimeoutRef.current);
      settingsTimeoutRef.current = null;
    }
    setSubmissionStatus('idle');
  }, []);

  useEffect(() => {
    const identityChanged = previousRequestIdentityRef.current !== requestIdentity;
    previousRequestIdentityRef.current = requestIdentity;
    const prompt = searchParams.get('prompt') || searchParams.get('q');
    if (identityChanged && prompt) {
      /** Project rewrites retain this identity; a new prompt URL starts a separate request. */
      if (settingsTimeoutRef.current) {
        clearTimeout(settingsTimeoutRef.current);
        settingsTimeoutRef.current = null;
      }
      requestIdRef.current += 1;
      attemptsRef.current = 0;
      awaitingHistoryRef.current = false;
      processedRef.current = false;
      submissionHandledRef.current = false;
      pendingSubmitRef.current = false;
      validatingRef.current = false;
      promptTextRef.current = null;
      validSettingsRef.current = null;
      originConversationRef.current = null;
      destinationRef.current = null;
      originRouteRef.current = routeRef.current;
      cancelledRef.current = false;
      setSubmissionStatus('idle');
    }
    if (
      ((!submissionHandledRef.current || validatingRef.current) && !ownsRequest()) ||
      (submissionStatus === 'failed' && !ownsComposer())
    ) {
      cancelRequest();
    }
  }, [
    location,
    conversation,
    searchIdentity,
    requestIdentity,
    searchParams,
    submissionStatus,
    ownsComposer,
    ownsRequest,
    cancelRequest,
  ]);

  const areSettingsApplied = useCallback(() => {
    const convo = conversationRef.current;
    if (!validSettingsRef.current || !convo) {
      return false;
    }

    const endpointsConfig = queryClient.getQueryData<TEndpointsConfig>([QueryKeys.endpoints]) ?? {};
    const normalizedSettings = convo.endpoint
      ? parseConvo({
          endpoint: convo.endpoint,
          endpointType: convo.endpointType,
          conversation: validSettingsRef.current,
          defaultParamsEndpoint: getDefaultParamsEndpoint(endpointsConfig, convo.endpoint),
        })
      : validSettingsRef.current;

    for (const [key, value] of Object.entries(validSettingsRef.current)) {
      if (['presetOverride', 'iconURL', 'modelLabel'].includes(key)) {
        continue;
      }

      let expectedValue = normalizedSettings?.[key];
      if (key === 'endpoint' || (key === 'tools' && value != null)) {
        expectedValue = value;
      } else if (key === 'endpointType') {
        expectedValue = value ?? getEndpointField(endpointsConfig, convo.endpoint, 'type');
      }
      if (!isEqual(convo[key], expectedValue)) {
        return false;
      }
    }

    return true;
  }, [queryClient]);

  /**
   * Applies settings from URL query parameters to create a new conversation.
   * Handles model spec lookup, endpoint normalization, and conversation switching logic.
   * Ensures tools compatibility and preserves existing conversation when appropriate.
   */
  const newQueryConvo = useCallback(
    (_newPreset?: TPreset) => {
      if (!_newPreset) {
        return;
      }
      let newPreset = removeUnavailableTools(_newPreset, availableTools);
      if (newPreset.spec != null && newPreset.spec !== '') {
        const startupConfig = queryClient.getQueryData<TStartupConfig>(startupConfigKey(true));
        const modelSpecs = startupConfig?.modelSpecs?.list ?? [];
        const spec = modelSpecs.find((s) => s.name === newPreset.spec);
        if (spec) {
          newPreset = mergeQuerySettingsWithSpec(getModelSpecPreset(spec), newPreset);
        }
        /** Hidden specs remain opaque here and are resolved server-side by name. */
      }

      let newEndpoint = newPreset.endpoint ?? '';
      const endpointsConfig = queryClient.getQueryData<TEndpointsConfig>([QueryKeys.endpoints]);

      if (newEndpoint && endpointsConfig && !endpointsConfig[newEndpoint]) {
        const normalizedNewEndpoint = newEndpoint.toLowerCase();
        for (const [key, value] of Object.entries(endpointsConfig)) {
          if (
            value &&
            value.type === EModelEndpoint.custom &&
            key.toLowerCase() === normalizedNewEndpoint
          ) {
            newEndpoint = key;
            newPreset.endpoint = key;
            newPreset.endpointType = EModelEndpoint.custom;
            break;
          }
        }
      }

      clearModelForNonEphemeralAgent(newPreset);
      validSettingsRef.current = newPreset;
      if (areSettingsApplied()) {
        return true;
      }

      const {
        template,
        shouldSwitch,
        isNewModular,
        newEndpointType,
        isCurrentModular,
        isExistingConversation,
      } = getConvoSwitchLogic({
        newEndpoint,
        modularChat,
        conversation,
        endpointsConfig,
      });

      const resetFields = newPreset.spec == null ? specDisplayFieldReset : {};
      if (newPreset.spec == null) {
        Object.assign(template, specDisplayFieldReset);
        newPreset = { ...newPreset, ...specDisplayFieldReset };
      }

      // Sync agent_id from newPreset to template, then clear model if non-ephemeral agent
      if (newPreset.agent_id) {
        template.agent_id = newPreset.agent_id;
      }
      clearModelForNonEphemeralAgent(template);

      const isModular = isCurrentModular && isNewModular && shouldSwitch;
      if (isExistingConversation && isModular) {
        template.endpointType = newEndpointType as EModelEndpoint | undefined;

        const currentConvo = getDefaultConversation({
          /* target endpointType is necessary to avoid endpoint mixing */
          conversation: {
            ...(conversation ?? {}),
            endpointType: template.endpointType,
            ...resetFields,
          },
          preset: template,
          cleanOutput: newPreset.spec != null && newPreset.spec !== '',
        });

        /* We don't reset the latest message, only when changing settings mid-converstion */
        logger.log('conversation', 'Switching conversation from query params', currentConvo);
        expectDestination(currentConvo);
        newConversation({
          template: currentConvo,
          preset: newPreset,
          keepAddedConvos: true,
          keepComposerState: true,
        });
        return true;
      }

      const newTemplate = {
        chatProjectId: conversation?.chatProjectId ?? null,
        ...(newPreset.agent_id ? { agent_id: newPreset.agent_id } : {}),
      };
      expectDestination(newTemplate);
      newConversation({
        template: newTemplate,
        preset: newPreset,
        keepAddedConvos: true,
        keepComposerState: true,
      });
      return true;
    },
    [
      areSettingsApplied,
      expectDestination,
      queryClient,
      modularChat,
      conversation,
      availableTools,
      newConversation,
      getDefaultConversation,
    ],
  );

  const restoreUrlPrompt = useCallback(() => {
    const prompt = promptTextRef.current;
    if (ownsRequest() && prompt != null && methods.getValues('text') !== prompt) {
      methods.setValue('text', prompt, { shouldValidate: true });
    }
  }, [methods, ownsRequest]);

  const settlePrompt = useCallback(() => {
    if (!ownsRequest() || promptTextRef.current == null) {
      return;
    }
    onPromptSettledRef.current?.(
      methods.getValues('text'),
      destinationRef.current?.conversationId ?? conversationRef.current?.conversationId,
    );
  }, [methods, ownsRequest]);

  /** Consumes an auto-submit once, leaving a refused submission in the composer. */
  const processSubmission = useCallback(() => {
    if (
      submissionHandledRef.current ||
      !pendingSubmitRef.current ||
      !promptTextRef.current ||
      !ownsRequest()
    ) {
      return;
    }

    setSubmissionStatus('preparing');
    if (settingsTimeoutRef.current) {
      clearTimeout(settingsTimeoutRef.current);
      settingsTimeoutRef.current = null;
    }

    awaitingHistoryRef.current = isHistoryPending();
    if (awaitingHistoryRef.current) {
      return;
    }

    submissionHandledRef.current = true;
    pendingSubmitRef.current = false;

    restoreUrlPrompt();
    const requestId = requestIdRef.current;
    validatingRef.current = true;
    const cleanUp = () => {
      if (requestId !== requestIdRef.current) {
        return;
      }
      validatingRef.current = false;
      if (ownsRequest(requestId)) {
        clearConsumedSearchParams();
      }
    };
    methods.handleSubmit(
      (data) => {
        if (!ownsRequest(requestId)) {
          return;
        }
        if (validSettingsRef.current && !areSettingsApplied()) {
          setSubmissionStatus('failed');
          settlePrompt();
          cleanUp();
          return;
        }
        setSubmissionStatus('idle');
        if (data.text?.trim() && submitMessageRef.current(data) !== false) {
          logger.log('conversation', 'Message submitted from query params');
        } else {
          settlePrompt();
        }
        cleanUp();
      },
      () => {
        if (ownsRequest(requestId)) {
          setSubmissionStatus('idle');
          settlePrompt();
        }
        cleanUp();
      },
    )();
  }, [
    methods,
    ownsRequest,
    isHistoryPending,
    areSettingsApplied,
    clearConsumedSearchParams,
    restoreUrlPrompt,
    settlePrompt,
  ]);

  /** Observes the history the composer sends from, so a retry runs after the
   * render that derives the latest message from it, not during the cache write. */
  const historyKey = [QueryKeys.messages, conversation?.conversationId ?? ''];
  const history = useQuery<TMessage[]>(
    historyKey,
    async () => queryClient.getQueryData<TMessage[]>(historyKey) ?? [],
    { enabled: false },
  );
  useEffect(() => {
    if (awaitingHistoryRef.current && !isHistoryPending()) {
      processSubmission();
    }
  }, [
    history.status,
    history.fetchStatus,
    history.dataUpdatedAt,
    isHistoryPending,
    processSubmission,
  ]);

  useEffect(() => {
    const processQueryParams = () => {
      const queryParams: Record<string, string> = {};
      searchParams.forEach((value, key) => {
        queryParams[key] = value;
      });

      // Support both 'prompt' and 'q' as query parameters, with 'prompt' taking precedence
      const decodedPrompt = queryParams.prompt || queryParams.q || '';
      const shouldAutoSubmit = queryParams.submit?.toLowerCase() === 'true';
      delete queryParams.prompt;
      delete queryParams.q;
      delete queryParams.submit;
      delete queryParams[PROJECT_ID_SEARCH_PARAM];
      const validSettings = processValidSettings(queryParams);

      return { decodedPrompt, validSettings, shouldAutoSubmit };
    };

    const requestId = requestIdRef.current;
    const intervalId = setInterval(() => {
      if (requestId !== requestIdRef.current) {
        clearInterval(intervalId);
        return;
      }
      if (processedRef.current || attemptsRef.current >= maxAttempts) {
        clearInterval(intervalId);
        if (attemptsRef.current >= maxAttempts) {
          console.warn('Max attempts reached, failed to process parameters');
        }
        return;
      }

      if (!ownsRequest()) {
        cancelRequest();
        clearInterval(intervalId);
        return;
      }

      const currentConversation = conversationRef.current;
      if (
        routePendingRef.current ||
        !currentConversation ||
        (currentConversation.conversationId != null &&
          routeRef.current.pathname !== `/c/${currentConversation.conversationId}`)
      ) {
        return;
      }
      attemptsRef.current += 1;
      if (!textAreaRef.current) {
        return;
      }
      const { decodedPrompt, validSettings, shouldAutoSubmit } = processQueryParams();
      if (decodedPrompt && promptTextRef.current == null) {
        promptTextRef.current = decodedPrompt;
        onBeforePrompt?.();
        methods.setValue('text', decodedPrompt, { shouldValidate: true });
        textAreaRef.current.focus();
        textAreaRef.current.setSelectionRange(decodedPrompt.length, decodedPrompt.length);
      }

      const startupConfig = queryClient.getQueryData<TStartupConfig>(startupConfigKey(true));
      if (!startupConfig) {
        return;
      }
      const hasSettings = Object.keys(validSettings).length > 0;

      const autoSubmitAllowed = startupConfig.interface?.autoSubmitFromUrl !== false;
      const willAutoSubmit = shouldAutoSubmit && autoSubmitAllowed;

      if (!willAutoSubmit) {
        submissionHandledRef.current = true;
      }

      /** Mark processing as complete and clean up as needed */
      const success = () => {
        processedRef.current = true;
        logger.log('conversation', 'Query parameters processed successfully');
        clearInterval(intervalId);

        // Defer URL cleanup until after submission completes (processSubmission handles it)
        if ((!willAutoSubmit || !decodedPrompt.trim()) && ownsRequest()) {
          settlePrompt();
          clearConsumedSearchParams();
        }
      };

      originConversationRef.current = conversationRef.current?.conversationId;
      const settingsAccepted = !hasSettings || newQueryConvo(validSettings) === true;
      if (willAutoSubmit && decodedPrompt.trim()) {
        pendingSubmitRef.current = true;
        if (!settingsAccepted) {
          pendingSubmitRef.current = false;
          submissionHandledRef.current = true;
          setSubmissionStatus('failed');
        } else if (!hasSettings || areSettingsApplied()) {
          processSubmission();
        } else {
          setSubmissionStatus('preparing');
          settingsTimeoutRef.current = setTimeout(() => {
            if (requestId !== requestIdRef.current) {
              return;
            }
            settingsTimeoutRef.current = null;
            if (!ownsRequest()) {
              cancelRequest();
              return;
            }
            if (!submissionHandledRef.current && pendingSubmitRef.current) {
              restoreUrlPrompt();
              pendingSubmitRef.current = false;
              submissionHandledRef.current = true;
              setSubmissionStatus('failed');
              logger.log('conversation', 'Settings application timeout, retaining prompt');
              settlePrompt();
              clearConsumedSearchParams();
            }
          }, MAX_SETTINGS_WAIT_MS);
        }
      } else {
        submissionHandledRef.current = true;
      }

      success();
    }, 100);

    return () => {
      clearInterval(intervalId);
    };
  }, [
    searchParams,
    requestIdentity,
    methods,
    textAreaRef,
    onBeforePrompt,
    routePending,
    settlePrompt,
    newQueryConvo,
    newConversation,
    submitMessage,
    clearConsumedSearchParams,
    queryClient,
    processSubmission,
    areSettingsApplied,
    restoreUrlPrompt,
    ownsRequest,
    cancelRequest,
  ]);

  useEffect(() => {
    // Only proceed if we've already processed URL parameters but haven't yet handled submission
    if (
      !processedRef.current ||
      submissionHandledRef.current ||
      !pendingSubmitRef.current ||
      !validSettingsRef.current ||
      !conversation ||
      !ownsRequest()
    ) {
      return;
    }

    restoreUrlPrompt();
    if (areSettingsApplied()) {
      logger.log('conversation', 'Settings fully applied, processing submission');
      processSubmission();
    }
  }, [conversation, processSubmission, areSettingsApplied, restoreUrlPrompt, ownsRequest]);

  useEffect(() => {
    mountedRef.current = true;
    return () => {
      mountedRef.current = false;
      if (settingsTimeoutRef.current) {
        clearTimeout(settingsTimeoutRef.current);
      }
    };
  }, []);

  const { isAuthenticated } = useAuthContext();
  const agentsMap = useAgentsMap({ isAuthenticated });
  useEffect(() => {
    if (urlAgent) {
      injectAgentIntoAgentsMap(queryClient, urlAgent);
    }
  }, [urlAgent, queryClient, agentsMap]);

  const clearSettingsError = useCallback(() => setSubmissionStatus('idle'), []);

  return {
    clearSettingsError,
    isPreparing: submissionStatus === 'preparing' && ownsRequest(),
    settingsError: submissionStatus === 'failed' && ownsComposer(),
  };
}