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

6.1 KB
Raw Blame
import { useEffect, useRef } from 'react';
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
import { dataService, MutationKeys, QueryKeys } from 'librechat-data-provider';
import {
  isQueuedTurnSuccessorOwed,
  isDefiniteQueuedTurnRejection,
  isDefiniteQueuedTurnsUnsupported,
} from '@librechat/chat';
import type {
  TAgentQueuedTurnReceipt,
  TEnqueueAgentQueuedTurnRequest,
} from 'librechat-data-provider';
import { useChatTransport } from '~/Providers/ChatTransportContext';

export {
  isQueuedTurnSuccessorOwed,
  isDefiniteQueuedTurnRejection,
  isDefiniteQueuedTurnsUnsupported,
};

export type AgentQueuedTurnReceipt = TAgentQueuedTurnReceipt;
export type EnqueueAgentQueuedTurnRequest = TEnqueueAgentQueuedTurnRequest;

/** Keep one cache authority for a conversation. Known receipt ids change the
 * server projection, not the identity of the durable queue. Giving every id
 * set its own key can resurrect an older cached projection after an id is
 * retired. */
export const agentQueuedTurnsQueryKey = (conversationId: string) =>
  [QueryKeys.agentQueuedTurns, conversationId] as const;

export async function fetchAgentQueuedTurns(
  conversationId: string,
  clientRequestIds?: string[],
): Promise<AgentQueuedTurnReceipt[]> {
  const response = await dataService.listAgentQueuedTurns(conversationId, clientRequestIds);
  return response.queuedTurns;
}

export async function enqueueAgentQueuedTurn(
  input: EnqueueAgentQueuedTurnRequest,
): Promise<AgentQueuedTurnReceipt> {
  const response = await dataService.enqueueAgentQueuedTurn(input);
  return response.receipt;
}

export async function cancelAgentQueuedTurn(input: {
  conversationId: string;
  queuedTurnId: string;
}): Promise<AgentQueuedTurnReceipt> {
  const response = await dataService.cancelAgentQueuedTurn(input.queuedTurnId);
  return response.receipt;
}

/** Indeterminate admission deliberately retains its durable claim until exact
 * source evidence arrives. It can still be refreshed on mount/focus, but a
 * two-second loop cannot resolve it and disguises permanent quarantine as
 * ordinary progress. */
export function shouldPollAgentQueuedTurns(
  receipts: unknown,
  reconcileUntil?: number,
  observedAt = Date.now(),
  expectsReceipts = false,
): boolean {
  return (
    expectsReceipts ||
    (reconcileUntil != null && observedAt < reconcileUntil) ||
    (Array.isArray(receipts) &&
      receipts.some(
        (item: AgentQueuedTurnReceipt) =>
          item.status === 'queued' ||
          (item.status === 'claimed' && item.failure?.code !== 'ADMISSION_INDETERMINATE'),
      ))
  );
}

/**
 * `expectsReceipts` keeps the poll alive while the caller still holds a
 * server-owned row the projection has not settled. A snapshot fetched while
 * the enqueue is still committing can come back empty, and a poll that stops
 * on that answer would leave a fast successor unnoticed until the next focus.
 */
export function useAgentQueuedTurns(
  conversationId: string,
  enabled: boolean,
  clientRequestIds: string[] = [],
  reconcileUntil?: number,
  expectsReceipts = false,
) {
  const queryClient = useQueryClient();
  const transport = useChatTransport();
  const knownIds = [...new Set(clientRequestIds)].sort();
  const knownIdsSignature = knownIds.join('\u0000');
  const previousRequest = useRef({ conversationId, knownIdsSignature });
  const query = useQuery({
    queryKey: agentQueuedTurnsQueryKey(conversationId),
    queryFn: () => transport.listQueued(conversationId, knownIds),
    enabled: enabled && conversationId.length > 0,
    staleTime: 1_000,
    /** A stopped indeterminate row can receive exact proof at any time. Its
     * cache may still be inside `staleTime`, so mount/focus must bypass the
     * ordinary freshness gate rather than waiting for another user cycle. */
    refetchOnMount: 'always',
    refetchOnWindowFocus: 'always',
    refetchInterval: (receipts) =>
      shouldPollAgentQueuedTurns(receipts, reconcileUntil, Date.now(), expectsReceipts)
        ? 2_000
        : false,
    retry: false,
  });
  const { refetch } = query;

  useEffect(() => {
    const previous = previousRequest.current;
    previousRequest.current = { conversationId, knownIdsSignature };
    if (
      !enabled ||
      conversationId.length === 0 ||
      previous.conversationId !== conversationId ||
      previous.knownIdsSignature === knownIdsSignature
    ) {
      return;
    }

    let superseded = false;
    const refreshProjection = async () => {
      /** React Query cannot replace an initial fetch that has no cached data
       * through `refetch` alone. Cancel it explicitly so the next request
       * captures the current reconciliation identities. */
      await queryClient.cancelQueries({
        queryKey: agentQueuedTurnsQueryKey(conversationId),
        exact: true,
      });
      if (!superseded) {
        await refetch({ cancelRefetch: true });
      }
    };
    void refreshProjection();

    return () => {
      superseded = true;
    };
  }, [conversationId, enabled, knownIdsSignature, queryClient, refetch]);

  return query;
}

export function useEnqueueAgentQueuedTurnMutation() {
  const queryClient = useQueryClient();
  const transport = useChatTransport();
  return useMutation({
    mutationKey: [MutationKeys.enqueueAgentQueuedTurn],
    mutationFn: transport.enqueue,
    /** A retry can encounter admission middleware while the first request is
     * still committing. Reconcile ambiguous outcomes through the read-only
     * known-id projection instead of issuing a second mutating POST. */
    retry: false,
    onSettled: (_receipt, _error, input) =>
      queryClient.invalidateQueries({
        queryKey: [QueryKeys.agentQueuedTurns, input.conversationId],
      }),
  });
}

export function useCancelAgentQueuedTurnMutation() {
  const queryClient = useQueryClient();
  const transport = useChatTransport();
  return useMutation({
    mutationKey: [MutationKeys.cancelAgentQueuedTurn],
    mutationFn: transport.cancelQueued,
    onSuccess: (_receipt, input) =>
      queryClient.invalidateQueries({
        queryKey: [QueryKeys.agentQueuedTurns, input.conversationId],
      }),
  });
}