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

8.1 KB
Raw Blame
import { memo, useCallback, useMemo, useState } from 'react';
import { Button } from '@librechat/client';
import { subagentStatusIcon, subagentStatusLabelKey } from '@librechat/chat/react';
import {
  SystemEventHeader,
  SystemEventIcon,
  systemEventHeaderClasses,
} from '@librechat/chat/components';
import type { WakeupDisplay, WakeupTask } from '@librechat/chat';
import type { TranslationKeys } from '~/hooks';
import { useLocalize, useExpandCollapse, useLazyCollapseBody } from '~/hooks';
import { useMessagePartsHost } from '~/Providers/MessagePartsHostContext';
import { useSubagentTaskPanel } from '~/components/Chat/Subagents/task';
import { useMCPIconMap, useMCPServerNames } from '~/hooks/MCP';
import BackgroundTaskCard from './BackgroundTaskCard';
import { cn, getToolDisplayLabel } from '~/utils';
import { StackedToolIcons } from './ToolOutput';
import MarkdownLite from './MarkdownLite';

const SUBAGENT_HEADER_KEYS = {
  completed: 'com_ui_wakeup_subagent_completed',
  error: 'com_ui_wakeup_subagent_errored',
  cancelled: 'com_ui_wakeup_subagent_cancelled',
} as const satisfies Record<WakeupTask['status'], TranslationKeys>;

const threadStatus = (status: WakeupTask['status']) =>
  status === 'error' ? ('failed' as const) : status;

/** The outcome glyph, colored for success only: a failure already paints the
 *  header label with the warning role. */
function SubagentOutcomeIcon({ status }: { status: ReturnType<typeof threadStatus> }) {
  const StatusIcon = subagentStatusIcon(status);
  return (
    <SystemEventIcon>
      <StatusIcon size={14} className={cn(status === 'completed' && 'text-status-success')} />
    </SystemEventIcon>
  );
}

function WakeupTaskCard({
  task,
  conversationId,
}: {
  task: WakeupTask;
  conversationId?: string | null;
}) {
  const localize = useLocalize();
  const durableTask = useMemo(
    () => ({
      threadId: task.threadId,
      taskId: task.taskId,
      subagentType: task.subagentType,
      settled: task.status === 'completed',
    }),
    [task.status, task.subagentType, task.taskId, task.threadId],
  );
  const { selection, open: openActivity } = useSubagentTaskPanel(durableTask, conversationId);
  const status = threadStatus(task.status);
  const StatusIcon = subagentStatusIcon(status);
  const hasResult = task.result.trim() !== '';

  return (
    <div className="my-1.5 min-w-0">
      <div className="text-text-secondary flex min-h-6 items-center gap-1.5 text-xs">
        <StatusIcon
          size={13}
          aria-hidden
          className={cn('shrink-0', status === 'failed' && 'text-status-error')}
        />
        <span className="shrink-0">{localize(subagentStatusLabelKey(status))}</span>
        {selection != null && openActivity != null && (
          /** The trigger identity attributes let the panel's close handler
           *  return keyboard focus to this button. */
          <Button
            type="button"
            variant="ghost"
            size="sm"
            onClick={openActivity}
            data-subagent-tool-call={selection.toolCallId}
            data-subagent-parent-message={selection.parentMessageId}
            data-subagent-part-index={selection.partIndex}
            className="ms-auto h-6 shrink-0 px-2 text-xs"
          >
            {localize('com_ui_wakeup_view_activity')}
          </Button>
        )}
      </div>
      {hasResult && (
        <div className="markdown prose prose-sm message-content light text-text-primary mt-2 max-h-96 w-full max-w-none overflow-y-auto pe-1 break-words">
          <MarkdownLite content={task.result} codeExecution={false} />
        </div>
      )}
    </div>
  );
}

/**
 * Collapsible task card for a host-authored wake-up continuation: the durable
 * result that woke this agent, rendered in the tool-call visual family instead
 * of the raw model-facing prompt.
 */
const Wakeup = memo(function Wakeup({
  display,
  conversationId,
}: {
  display: WakeupDisplay;
  conversationId?: string | null;
}) {
  const localize = useLocalize();
  const mcpIconMap = useMCPIconMap();
  const mcpServerNames = useMCPServerNames();
  const autoExpand = useMessagePartsHost().useAutoExpandTools();
  const [isExpanded, setIsExpanded] = useState(autoExpand);
  const { style: expandStyle, ref: expandRef } = useExpandCollapse(isExpanded);
  const { shouldRenderBody, mountBody, handleTransitionEnd } = useLazyCollapseBody(isExpanded);

  const handleToggle = useCallback(() => {
    mountBody();
    setIsExpanded((previous) => !previous);
  }, [mountBody]);

  const anyFailed = display.tasks.some((task) => task.status !== 'completed');
  const headerLabel = useMemo(() => {
    if (display.kind === 'subagent') {
      const status = display.tasks[0]?.status ?? 'completed';
      return localize(SUBAGENT_HEADER_KEYS[status]);
    }
    if (display.tasks.length > 1) {
      return localize('com_ui_wakeup_tasks_finished', { 0: String(display.tasks.length) });
    }
    if (display.tasks[0]?.status === 'cancelled') {
      return localize('com_ui_wakeup_task_cancelled');
    }
    if (display.tasks[0]?.status === 'error') {
      return localize('com_ui_wakeup_task_errored');
    }
    return localize('com_ui_wakeup_task_finished');
  }, [display.kind, display.tasks, localize]);

  /** A subagent's report is headed by the agent's own name and face on its row,
   *  so its header line carries only the outcome. */
  const nameSummary = useMemo(() => {
    if (display.kind === 'subagent') {
      return '';
    }
    const seen = new Set<string>();
    const labels: string[] = [];
    for (const task of display.tasks) {
      if (task.toolName == null || task.toolName === '') continue;
      const label = getToolDisplayLabel(task.toolName, localize, mcpServerNames);
      if (seen.has(label)) continue;
      seen.add(label);
      labels.push(label);
    }
    if (labels.length > 3) {
      return `${labels.slice(0, 3).join(', ')}, +${labels.length - 3}`;
    }
    return labels.join(', ');
  }, [display.kind, display.tasks, localize, mcpServerNames]);

  const toolIconNames = useMemo(
    () => display.tasks.map((task) => task.toolName ?? ''),
    [display.tasks],
  );

  return (
    <div className={cn('max-w-full', shouldRenderBody && 'w-[36rem]')}>
      <Button
        variant="disclosure"
        type="button"
        className={systemEventHeaderClasses}
        onClick={handleToggle}
        aria-expanded={isExpanded}
        aria-label={headerLabel}
      >
        <SystemEventHeader
          live
          icon={
            display.kind === 'subagent' ? (
              <SubagentOutcomeIcon status={threadStatus(display.tasks[0]?.status ?? 'completed')} />
            ) : (
              <StackedToolIcons toolNames={toolIconNames} mcpIconMap={mcpIconMap} maxIcons={4} />
            )
          }
          label={headerLabel}
          detail={nameSummary}
          expanded={isExpanded}
          warning={anyFailed}
        />
      </Button>
      <div
        style={expandStyle}
        onTransitionEnd={handleTransitionEnd}
        aria-hidden={!isExpanded}
        data-testid="wakeup-panel"
      >
        {shouldRenderBody && (
          <div className="overflow-hidden" ref={expandRef}>
            <div className="pb-1">
              {display.kind === 'subagent' && (
                <div className="text-text-secondary mt-1 text-xs">
                  {localize('com_ui_wakeup_explainer')}
                </div>
              )}
              {display.tasks.map((task) =>
                display.kind === 'background_tool' ? (
                  <div key={task.taskId} className="my-2 ps-7">
                    <BackgroundTaskCard
                      task={{
                        taskId: task.taskId,
                        toolName: task.toolName ?? '',
                        status: task.status,
                        result: task.result,
                      }}
                      mcpIconMap={mcpIconMap}
                      mcpServerNames={mcpServerNames}
                    />
                  </div>
                ) : (
                  <WakeupTaskCard key={task.taskId} task={task} conversationId={conversationId} />
                ),
              )}
            </div>
          </div>
        )}
      </div>
    </div>
  );
});

export default Wakeup;