Skip to content

AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.

5.6 KB
Raw Blame
"use client";
import { ChatContainer } from "./components/ChatContainer/ChatContainer";
import type { FloatingControls } from "./components/ChatMessagesContainer/components/ThreadHeader";
import { ProviderLimitDialog } from "./components/ProviderLimitDialog/ProviderLimitDialog";
import { RateLimitGate } from "./components/RateLimitResetDialog/RateLimitGate";
import { useCopilotPage } from "./useCopilotPage";
import { FlaskConicalIcon } from "@hugeicons/core-free-icons";
import { Icon } from "@/components/atoms/Icon/Icon";
import { Flag, useGetFlag } from "@/services/feature-flags/use-get-flag";
import { useUsageExperience } from "@/services/usageExperience/useUsageExperience";
import { useRateLimitRefresh } from "./components/RateLimitResetDialog/useRateLimitRefresh";

interface Props {
  droppedFiles: File[];
  onDroppedFilesConsumed: () => void;
  /** Which layout floats its controls over the chat's top-left corner on
   *  small viewports. */
  floatingControls?: FloatingControls;
}

/**
 * Session-scoped chat host. Parent mounts this with `key={sessionId}` so
 * session-local view state resets on switch, while the stream itself is
 * preserved in a per-session runtime registry. Keyed again by the stream
 * flag, so flags resolving after mount swap the stream hook by remounting.
 */
export function CopilotChatHost(props: Props) {
  const isStreamRuntime = useGetFlag(Flag.COPILOT_STREAM_RUNTIME) === true;
  return (
    <ChatHostBody
      key={isStreamRuntime ? "stream-runtime" : "ai-sdk"}
      {...props}
      isStreamRuntime={isStreamRuntime}
    />
  );
}

function ChatHostBody({
  droppedFiles,
  onDroppedFilesConsumed,
  floatingControls,
  isStreamRuntime,
}: Props & { isStreamRuntime: boolean }) {
  const {
    sessionId,
    messages,
    status,
    error,
    stop,
    isReconnecting,
    isFinishProbing,
    isRestoringActiveSession,
    restoreStatusMessage,
    activeStreamStartedAt,
    isUserStopping,
    createSession,
    onSend,
    onStartTask,
    onEnqueue,
    queuedMessages,
    isLoadingSession,
    isSessionError,
    isSessionNotFound,
    isCreatingSession,
    isUploadingFiles,
    pendingSend,
    hasMoreMessages,
    isLoadingMore,
    loadMore,
    turnStats,
    rateLimitMessage,
    platformLimitFailure,
    dismissRateLimit,
    providerLimit,
    dismissProviderLimit,
    sessionDryRun,
    sessionChatStatus,
    sessionSentFrom,
    sessionAutopilotMode,
    chatLlmAuthProvider,
    expertIdentity,
    isResolvingExpertIdentity,
    isAdoptingExpertSession,
    isKickoffStarting,
    followBackendTurn,
  } = useCopilotPage({ isStreamRuntime });
  const usage = useUsageExperience();
  const usageRefresh = useRateLimitRefresh(rateLimitMessage, usage.retry);
  function dismissAfterProviderChange() {
    usageRefresh.release();
    dismissRateLimit();
  }

  return (
    <>
      {/* Only shown when the CURRENT session is confirmed dry_run via its
          immutable metadata. Never based on the global isDryRun preference
          (which only predicts future sessions). */}
      {sessionId && sessionDryRun && (
        <div className="flex items-center justify-center gap-1.5 bg-amber-50 px-3 py-1.5 text-xs font-medium text-amber-800">
          <Icon icon={FlaskConicalIcon} size={13} />
          Test mode — this session runs workflows as simulation
        </div>
      )}
      <div className="min-h-0 flex-1 overflow-hidden">
        <ChatContainer
          isUsageRefused={!!rateLimitMessage || usageRefresh.guarded}
          usageFailure={platformLimitFailure}
          onDismissUsage={dismissAfterProviderChange}
          usageRefresh={usageRefresh}
          usage={usage}
          chatAuthProvider={chatLlmAuthProvider}
          messages={messages}
          status={status}
          error={error}
          sessionId={sessionId}
          sessionChatStatus={sessionChatStatus}
          sessionSentFrom={sessionSentFrom}
          sessionAutopilotMode={sessionAutopilotMode}
          isLoadingSession={isLoadingSession}
          isSessionError={isSessionError}
          isSessionNotFound={isSessionNotFound}
          isCreatingSession={isCreatingSession}
          isReconnecting={isReconnecting}
          isFinishProbing={isFinishProbing}
          isRestoringActiveSession={isRestoringActiveSession}
          restoreStatusMessage={restoreStatusMessage}
          activeStreamStartedAt={activeStreamStartedAt}
          isUserStopping={isUserStopping}
          onCreateSession={createSession}
          onSend={onSend}
          onStartTask={onStartTask}
          onStop={stop}
          onEnqueue={onEnqueue}
          queuedMessages={queuedMessages}
          isUploadingFiles={isUploadingFiles}
          pendingSend={pendingSend}
          hasMoreMessages={hasMoreMessages}
          isLoadingMore={isLoadingMore}
          onLoadMore={loadMore}
          droppedFiles={droppedFiles}
          onDroppedFilesConsumed={onDroppedFilesConsumed}
          turnStats={turnStats}
          expertIdentity={expertIdentity}
          isResolvingExpertIdentity={isResolvingExpertIdentity}
          isAdoptingExpertSession={isAdoptingExpertSession}
          isKickoffStarting={isKickoffStarting}
          onBackendTurn={followBackendTurn}
          floatingControls={floatingControls}
        />
      </div>
      <RateLimitGate
        refreshState={usageRefresh}
        rateLimitMessage={rateLimitMessage}
        failure={platformLimitFailure}
        sessionId={sessionId}
        onDismiss={dismissRateLimit}
        onSendNow={onSend}
      />
      <ProviderLimitDialog
        failure={providerLimit}
        sessionId={sessionId}
        onDismiss={dismissProviderLimit}
      />
    </>
  );
}