Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

27.8 KB
Raw Blame
import { useMobileI18n } from "../../lib/i18n";
import type {
  EnvironmentId,
  MessageId,
  ModelSelection,
  OrchestrationThreadShell,
  RuntimeMode,
  ServerConfig as T3ServerConfig,
} from "@akeru/contracts";
import { useAtomValue } from "@effect/atom-react";
import {
  detectComposerTrigger,
  replaceTextRange,
  serializeComposerFileLink,
  type ComposerTrigger,
} from "@akeru/shared/composerTrigger";
import { memo, useCallback, useEffect, useMemo, useRef, useState, type RefObject } from "react";
import { Image, Platform, Pressable, StyleSheet, View } from "react-native";
import ImageViewing from "react-native-image-viewing";
import { SymbolView } from "../../components/AppSymbol";
import Animated, { FadeIn, FadeOut } from "react-native-reanimated";
import { useThemeColor } from "../../lib/useThemeColor";
import { themeColorWithAlpha } from "../../lib/mobileTheme";
import { scopedThreadKey } from "../../lib/scopedEntities";
import { AppText as Text } from "../../components/AppText";
import { ComposerAttachmentStrip } from "../../components/ComposerAttachmentStrip";
import { composerActionIsDictation } from "@akeru/client-runtime/dictation";
import { DictationControls } from "../../components/DictationControls";
import { useEnvironmentComposerDictation } from "../../lib/useEnvironmentComposerDictation";
import {
  ComposerEditor,
  type ComposerEditorHandle,
  type ComposerEditorSelection,
} from "../../components/ComposerEditor";
import {
  ComposerInlineControl,
  ComposerToolbarButton,
  ComposerToolbarRow,
  ComposerToolbarScroller,
} from "../../components/ComposerToolbar";
import { ControlPill } from "../../components/ControlPill";
import { ProviderIcon } from "../../components/ProviderIcon";
import type { DraftComposerImageAttachment } from "../../lib/composerImages";
import { resolveModelSendBlock } from "../../lib/modelOptions";
import { useScaledTextRole } from "../settings/appearance/useScaledTextRole";
import { useAppearancePreferences } from "../settings/appearance/AppearancePreferencesProvider";
import type { RemoteClientConnectionState } from "../../lib/connection";
import { useComposerPathSearch } from "../../state/use-composer-path-search";
import { environmentBotsAtom, environmentGroupsAtom } from "../../state/bots";
import { providerBotName } from "./thread-list-v2-items";
import { resolveThreadIdentity } from "./threadIdentity";
import { serverEnvironment } from "../../state/server";
import { useEnvironmentQuery } from "../../state/query";
import { ComposerCommandPopover, type ComposerCommandItem } from "./ComposerCommandPopover";
import { buildComposerCommandItems } from "./composer-command-items";
import { composerMentionItemToken, isThreadMentionQuery } from "./composerMentionItems";
import { ComposerMentionPopover } from "./ComposerMentionPopover";
import { useExistingThreadSettingsRoutePresentation } from "./ThreadSettingsSheet";
import { useThreadSettingsSheetRoute } from "./use-thread-settings-sheet-presentation";
import { useThreadComposerSettings } from "./use-thread-composer-settings";
import {
  ComposerConnectionStatusPill,
  composerConnectionStatus,
} from "./composer-connection-status";
import { COMPOSER_LAYOUT_TRANSITION, ComposerSurface } from "./composer-surface";

export {
  COMPOSER_COLLAPSED_CHROME,
  COMPOSER_EXPANDED_CHROME,
  ComposerSurface,
} from "./composer-surface";

export interface ThreadComposerProps {
  readonly draftMessage: string;
  readonly draftAttachments: ReadonlyArray<DraftComposerImageAttachment>;
  readonly placeholder: string;
  readonly contentMaxWidth?: number;
  readonly bottomInset?: number;
  readonly connectionState: RemoteClientConnectionState;
  readonly connectionError: string | null;
  readonly environmentLabel: string | null;
  /**
   * Message sync phase for the selected thread (drives the status pill):
   * "loading" = first fetch, nothing to show yet; "syncing" = cached messages
   * are on screen while they reconcile with the server.
   */
  readonly threadSyncPhase?: "loading" | "syncing" | null;
  readonly selectedThread: OrchestrationThreadShell;
  readonly serverConfig: T3ServerConfig | null;
  readonly queueCount: number;
  readonly environmentId: EnvironmentId;
  readonly projectCwd: string | null;
  readonly editorRef?: RefObject<ComposerEditorHandle | null>;
  readonly onChangeDraftMessage: (value: string) => void;
  readonly onPickDraftImages: () => Promise<void>;
  readonly onNativePasteImages: (uris: ReadonlyArray<string>) => Promise<void>;
  readonly onRemoveDraftImage: (imageId: string) => void;
  readonly onStopThread: () => void;
  readonly onSendMessage: () => Promise<MessageId | null>;
  readonly onUpdateModelSelection: (modelSelection: ModelSelection) => void;
  readonly onUpdateRuntimeMode: (runtimeMode: RuntimeMode) => void;
  readonly onReconnectEnvironment: () => void;
  readonly onExpandedChange?: (expanded: boolean) => void;
  /** Fires on editor focus/blur; hosts use it to vet stale keyboard state. */
  readonly onEditorFocusChange?: (focused: boolean) => void;
}

const NO_PROVIDERS: NonNullable<ThreadComposerProps["serverConfig"]>["providers"] = [];

export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposerProps) {
  const { t, plural } = useMobileI18n();
  const { themeAppearance } = useAppearancePreferences();
  const isDarkMode = themeAppearance === "dark";
  const foregroundColor = useThemeColor("--color-foreground");
  const mutedColor = useThemeColor("--color-icon-muted");
  const bodyText = useScaledTextRole("body");
  const fallbackInputRef = useRef<ComposerEditorHandle>(null);
  const inputRef = props.editorRef ?? fallbackInputRef;
  const [isFocused, setIsFocused] = useState(false);
  const settingsRoutePresentation = useExistingThreadSettingsRoutePresentation();
  const settingsOwnerId = scopedThreadKey(props.environmentId, props.selectedThread.id);

  const clearSettingsRouteSession = useCallback(
    () => settingsRoutePresentation.clear(settingsOwnerId),
    [settingsOwnerId, settingsRoutePresentation.clear],
  );

  const settingsSheetPresentation = useThreadSettingsSheetRoute({
    editorRef: inputRef,
    isEditorFocused: isFocused,
    routeName: "ThreadSettingsSheet",
    onDismissed: clearSettingsRouteSession,
  });

  const bots = useAtomValue(environmentBotsAtom(props.environmentId));

  const subscriptionAuth = useEnvironmentQuery(
    serverEnvironment.subscriptionAuth({ environmentId: props.environmentId, input: {} }),
  );

  const subscriptionStatuses = subscriptionAuth.data?.providers;
  const bot = bots.find((candidate) => candidate.id === props.selectedThread.botId);
  const groups = useAtomValue(environmentGroupsAtom(props.environmentId));

  // Group chats address the group, direct chats the bot. Threads without a
  // configured bot still read as a named teammate: fall back to the provider
  // identity. Until either is known the caller's neutral placeholder stands
  // in, so the composer never asks a bot called "Bot".
  const composerProviderDriver =
    props.serverConfig?.providers.find(
      (candidate) =>
        candidate.instanceId ===
        (props.selectedThread.session?.providerInstanceId ??
          props.selectedThread.modelSelection.instanceId),
    )?.driver ?? null;

  const composerIdentity = resolveThreadIdentity({
    thread: props.selectedThread,
    bots,
    groups,
    providerDriver: composerProviderDriver,
    providerName: providerBotName,
  });

  // Plain chats without a bot or group get no name prompt — the composer
  // placeholder stays neutral rather than echoing the chat title.
  const composerBotName = composerIdentity.isGroup
    ? composerIdentity.title
    : (bot?.name ?? providerBotName(composerProviderDriver));

  const wasExpandedBeforePreviewRef = useRef(false);
  const inFlightThreadIdsRef = useRef(new Set<string>());
  const { onExpandedChange } = props;

  const [previewImageUri, setPreviewImageUri] = useState<string | null>(null);
  const hasContent = props.draftMessage.trim().length > 0 || props.draftAttachments.length > 0;
  // Opening and presentation count as active so the composer stays expanded
  // while focus moves between its native editor and the settings picker.
  const isExpanded = isFocused || settingsSheetPresentation.isActive;

  // The chat keeps its saved model even when it cannot run; Send stays off
  // and the reason shows above the composer until the provider is repaired.
  const sendBlock = useMemo(
    () =>
      resolveModelSendBlock(
        props.serverConfig,
        props.selectedThread.modelSelection,
        t,
        subscriptionStatuses,
      ),
    [props.serverConfig, props.selectedThread.modelSelection, subscriptionStatuses, t],
  );

  const canSend = hasContent && sendBlock === null;

  const sendBlockHint = sendBlock
    ? t("{title}. {description}", { title: sendBlock.title, description: sendBlock.description })
    : undefined;

  // Notify the parent from the derived value, not focus events: the parent
  // sizes the feed inset from this, and blur-during-sheet would otherwise
  // report collapsed while the composer still renders expanded.
  useEffect(() => {
    onExpandedChange?.(isExpanded);
  }, [isExpanded, onExpandedChange]);

  const onPressImage = useCallback(
    (uri: string) => {
      wasExpandedBeforePreviewRef.current = isFocused;
      setPreviewImageUri(uri);
    },
    [isFocused],
  );

  const closePreview = useCallback(() => {
    setPreviewImageUri(null);

    if (wasExpandedBeforePreviewRef.current) {
      setTimeout(() => inputRef.current?.focus(), 100);
    }
  }, [inputRef]);

  const onEditorFocusChange = props.onEditorFocusChange;

  const handleFocus = useCallback(() => {
    setIsFocused(true);
    onEditorFocusChange?.(true);
  }, [onEditorFocusChange]);

  const handleBlur = useCallback(() => {
    setIsFocused(false);
    onEditorFocusChange?.(false);
  }, [onEditorFocusChange]);

  const showStopAction =
    props.selectedThread.session?.status === "running" ||
    props.selectedThread.session?.status === "starting";

  const sendLabel =
    props.connectionState !== "connected" || props.queueCount > 0 ? "Queue" : "Send";

  const connectionStatus = composerConnectionStatus({
    connectionError: props.connectionError,
    connectionState: props.connectionState,
    environmentLabel: props.environmentLabel,
    threadSyncPhase: props.threadSyncPhase,
  });

  const toolbarSurface = String(useThemeColor("--color-card"));
  const backdropSurface = String(useThemeColor("--color-screen"));
  const toolbarFadeOpaque = themeColorWithAlpha(toolbarSurface, 0.95);
  const toolbarFadeTransparent = themeColorWithAlpha(toolbarSurface, 0);
  const backdropGradient = `linear-gradient(to bottom, ${themeColorWithAlpha(backdropSurface, 0)} 0%, ${themeColorWithAlpha(backdropSurface, 0.6)} 55%, ${themeColorWithAlpha(backdropSurface, 0.9)} 100%)`;

  const selectedProviderStatus = useMemo(() => {
    if (!props.serverConfig) return null;

    return (
      props.serverConfig.providers.find(
        (p) => p.instanceId === props.selectedThread.modelSelection.instanceId,
      ) ?? null
    );
  }, [props.serverConfig, props.selectedThread.modelSelection.instanceId]);

  // ── Trigger detection ────────────────────────────────────
  const [composerSelection, setComposerSelection] = useState(() => ({
    start: props.draftMessage.length,
    end: props.draftMessage.length,
  }));

  const [dictationGeneration, setDictationGeneration] = useState(0);

  const dictation = useEnvironmentComposerDictation({
    environmentId: props.environmentId,
    connected: props.connectionState === "connected",
    threadId: props.selectedThread.id,
    draftId: props.selectedThread.id,
    generation: dictationGeneration,
    getDraft: () => ({ text: props.draftMessage, selection: composerSelection }),
    applyDraft: (next) => {
      props.onChangeDraftMessage(next.text);
      setComposerSelection(next.selection);
      inputRef.current?.setSelection(next.selection);
    },
  });

  const showDictation = composerActionIsDictation({
    hasDraft: props.draftMessage.trim().length > 0 || props.draftAttachments.length > 0,
    status: dictation.status,
  });

  useEffect(() => {
    setDictationGeneration((generation) => generation + 1);
  }, [props.environmentId, props.selectedThread.id]);

  // The composer owns dictation, so focusing it and swapping the collapsed
  // control for the expanded one keeps recording. Only the collapsed Stop
  // action takes the slot away; dictation it hides is cancelled.
  const dictationBusy =
    dictation.status === "requesting" ||
    dictation.status === "recording" ||
    dictation.status === "transcribing";

  const dictationHidden = !isExpanded && showStopAction;
  const cancelDictation = dictation.onCancel;
  useEffect(() => {
    if (dictationHidden && dictationBusy) cancelDictation();
  }, [cancelDictation, dictationBusy, dictationHidden]);

  const handleSelectionChange = useCallback((selection: ComposerEditorSelection) => {
    setComposerSelection(selection);
  }, []);

  useEffect(() => {
    const end = props.draftMessage.length;
    setComposerSelection((selection) => {
      const start = Math.min(selection.start, end);
      const selectionEnd = Math.min(selection.end, end);

      if (start === selection.start && selectionEnd === selection.end) {
        return selection;
      }

      return { start, end: selectionEnd };
    });
  }, [props.draftMessage.length]);

  const composerTrigger = useMemo<ComposerTrigger | null>(() => {
    if (composerSelection.start !== composerSelection.end) {
      return null;
    }

    return detectComposerTrigger(props.draftMessage, composerSelection.end);
  }, [composerSelection, props.draftMessage]);

  const mentionQuery = composerTrigger?.kind === "path" ? composerTrigger.query : null;

  const pathSearch = useComposerPathSearch({
    environmentId: props.environmentId,
    cwd: mentionQuery !== null && !isThreadMentionQuery(mentionQuery) ? props.projectCwd : null,
    query: mentionQuery !== null && !isThreadMentionQuery(mentionQuery) ? mentionQuery : null,
  });

  const composerMenuItems = useMemo(
    () => buildComposerCommandItems(composerTrigger, pathSearch.entries, selectedProviderStatus),
    [composerTrigger, pathSearch.entries, selectedProviderStatus],
  );

  // ── Handle command selection ──────────────────────────────
  const { onChangeDraftMessage, draftMessage, onSendMessage } = props;

  const handleSend = useCallback(async () => {
    const threadKey = scopedThreadKey(props.environmentId, props.selectedThread.id);

    if (inFlightThreadIdsRef.current.has(threadKey)) return;
    inFlightThreadIdsRef.current.add(threadKey);

    try {
      const messageId = await onSendMessage();

      if (messageId === null) {
        return;
      }

      setDictationGeneration((generation) => generation + 1);
    } finally {
      inFlightThreadIdsRef.current.delete(threadKey);
    }
  }, [onSendMessage, props.environmentId, props.selectedThread.id]);

  const handleCommandSelect = useCallback(
    (item: ComposerCommandItem) => {
      if (!composerTrigger) return;

      let replacement = "";

      if (item.type === "path") {
        replacement = `${serializeComposerFileLink(item.path)} `;
      } else if (item.type === "skill") {
        replacement = `$${item.skill.name} `;
      } else if (item.type === "slash-command") {
        replacement = `/${item.command} `;
      } else if (item.type === "provider-slash-command") {
        replacement = `/${item.command.name} `;
      } else {
        const token = composerMentionItemToken(item);

        if (token !== null) replacement = `${token} `;
      }

      const result = replaceTextRange(
        draftMessage,
        composerTrigger.rangeStart,
        composerTrigger.rangeEnd,
        replacement,
      );

      setComposerSelection({ start: result.cursor, end: result.cursor });
      onChangeDraftMessage(result.text);
    },
    [composerTrigger, draftMessage, onChangeDraftMessage],
  );

  const { currentModelSelection, currentModelOption, openSettings } = useThreadComposerSettings({
    environmentId: props.environmentId,
    selectedThread: props.selectedThread,
    serverConfig: props.serverConfig,
    subscriptionStatuses,
    bot,
    settingsOwnerId,
    settingsRoutePresentation,
    settingsSheetPresentation,
    onUpdateModelSelection: props.onUpdateModelSelection,
    onUpdateRuntimeMode: props.onUpdateRuntimeMode,
  });

  return (
    <Animated.View
      className="px-4"
      layout={COMPOSER_LAYOUT_TRANSITION}
      style={{
        paddingTop: isExpanded ? 8 : 6,
        paddingBottom: (props.bottomInset ?? 0) + (isExpanded ? 8 : 6),
      }}
    >
      {/* The backdrop gradient lives on a plain View: Reanimated's Animated.View
          silently drops experimental_backgroundImage on Android, which left this
          strip fully transparent and the feed text legible through the composer. */}
      <View
        pointerEvents="none"
        style={[
          StyleSheet.absoluteFill,
          {
            experimental_backgroundImage: backdropGradient,
          },
        ]}
      />
      <Animated.View
        className="relative w-full self-center"
        layout={COMPOSER_LAYOUT_TRANSITION}
        style={{ maxWidth: props.contentMaxWidth }}
      >
        {composerTrigger?.kind === "path" && !composerTrigger.query.startsWith('"') ? (
          <ComposerMentionPopover
            environmentId={props.environmentId}
            threadId={props.selectedThread.id}
            projectId={props.selectedThread.projectId}
            groupId={props.selectedThread.groupId ?? null}
            browserAvailable={props.serverConfig?.settings.enableAgentBrowserAccess === true}
            providers={props.serverConfig?.providers ?? NO_PROVIDERS}
            query={composerTrigger.query}
            fileItems={composerMenuItems}
            isLoading={pathSearch.isPending}
            onSelect={handleCommandSelect}
          />
        ) : composerTrigger &&
          // `$` stays open when empty so a missing provider or skill is stated, not silent.
          (composerMenuItems.length > 0 || composerTrigger.kind === "skill") ? (
          <View className="absolute inset-x-0 bottom-full z-10 mb-2">
            <ComposerCommandPopover
              items={composerMenuItems}
              triggerKind={composerTrigger.kind}
              isLoading={pathSearch.isPending}
              {...(composerTrigger.kind === "skill" && selectedProviderStatus === null
                ? { emptyText: t("Connect a provider to use skills.") }
                : {})}
              onSelect={handleCommandSelect}
            />
          </View>
        ) : null}

        {connectionStatus ? (
          <ComposerConnectionStatusPill
            status={connectionStatus}
            onPress={props.onReconnectEnvironment}
          />
        ) : sendBlock ? (
          // In flow, not absolute: the overlay's measured height becomes the
          // feed's bottom inset, so the notice stacks above the pill instead
          // of painting over the feed and the waiting line.
          <View
            accessibilityRole="alert"
            className="mb-2 rounded-2xl border border-border bg-card px-4 py-2"
            pointerEvents="none"
          >
            <Text className="text-center text-xs text-foreground-muted">
              <Text className="text-xs font-t3-bold text-foreground">
                {t("{title}.", { title: sendBlock.title })}
              </Text>{" "}
              {sendBlock.description}
            </Text>
          </View>
        ) : null}

        <ComposerSurface
          isDarkMode={isDarkMode}
          style={
            isExpanded
              ? {
                  borderRadius: 26,
                  minHeight: 140,
                  overflow: "hidden" as const,
                  paddingBottom: 6,
                  paddingHorizontal: 14,
                  paddingTop: 14,
                }
              : {
                  borderRadius: 999,
                  overflow: "hidden" as const,
                  flexDirection: "row" as const,
                  alignItems: "center" as const,
                  paddingLeft: 18,
                  paddingRight: 5,
                  paddingVertical: 5,
                }
          }
        >
          {/* Attachment strip — inside the card, above the text input */}
          {isExpanded ? (
            <Animated.View
              className={props.draftAttachments.length > 0 ? "pb-2.5" : undefined}
              entering={FadeIn.duration(160)}
              exiting={FadeOut.duration(120)}
            >
              <ComposerAttachmentStrip
                attachments={props.draftAttachments}
                onRemove={props.onRemoveDraftImage}
                onPressImage={onPressImage}
              />
            </Animated.View>
          ) : null}

          {!isExpanded ? (
            <Pressable
              accessibilityLabel="Add attachment"
              accessibilityRole="button"
              className="mr-1 size-9 items-center justify-center rounded-full bg-subtle"
              hitSlop={6}
              onPress={() => void props.onPickDraftImages()}
              style={({ pressed }) => ({ opacity: pressed ? 0.55 : 1 })}
            >
              <SymbolView name="plus" size={18} tintColor={mutedColor} type="monochrome" />
            </Pressable>
          ) : null}
          {!isExpanded && !hasContent ? (
            <Pressable
              accessibilityLabel="Model and reasoning settings"
              accessibilityRole="button"
              className="mr-1 max-w-[112px] flex-row items-center gap-1.5 rounded-full bg-subtle px-2.5 py-2"
              onPress={openSettings}
              style={({ pressed }) => ({ opacity: pressed ? 0.55 : 1 })}
            >
              <ProviderIcon provider={currentModelOption?.providerDriver} size={15} />
              <Text
                className="shrink text-xs font-t3-medium text-foreground-muted"
                numberOfLines={1}
              >
                {currentModelOption?.label ?? "Model"}
              </Text>
            </Pressable>
          ) : null}
          <View className={isExpanded ? undefined : "min-w-0 flex-1"}>
            <ComposerEditor
              ref={inputRef}
              multiline
              value={props.draftMessage}
              skills={selectedProviderStatus?.skills ?? []}
              selection={composerSelection}
              onChangeText={props.onChangeDraftMessage}
              onSelectionChange={handleSelectionChange}
              onPasteImages={(uris) => void props.onNativePasteImages(uris)}
              placeholder={
                composerBotName ? t("Message {name}", { name: composerBotName }) : props.placeholder
              }
              onFocus={handleFocus}
              onBlur={handleBlur}
              onSubmit={handleSend}
              scrollEnabled={isExpanded}
              // Android: collapsed single line centers natively (gravity) in
              // a pill-height box matching the send button; iOS keeps insets.
              singleLineCentered={!isExpanded}
              contentInsetVertical={isExpanded || Platform.OS === "android" ? 0 : 6}
              style={
                isExpanded
                  ? {
                      minHeight: 72,
                      maxHeight: 160,
                      paddingHorizontal: 4,
                      paddingVertical: 4,
                    }
                  : {
                      height: 36,
                    }
              }
              textStyle={{
                ...bodyText,
                color: foregroundColor,
              }}
            />
          </View>
          {!isExpanded && props.draftAttachments.length > 0 ? (
            <View className="flex-row gap-1 pl-1">
              {props.draftAttachments.slice(0, 3).map((image) => (
                <Pressable key={image.id} onPress={() => onPressImage(image.previewUri)}>
                  <Image
                    source={{ uri: image.previewUri }}
                    className="size-[30px] rounded-lg bg-subtle"
                    resizeMode="cover"
                  />
                </Pressable>
              ))}
              {props.draftAttachments.length > 3 ? (
                <View className="size-[30px] items-center justify-center rounded-lg bg-subtle-strong">
                  <Text className="text-foreground-muted text-2xs font-t3-bold">
                    +{props.draftAttachments.length - 3}
                  </Text>
                </View>
              ) : null}
            </View>
          ) : null}
          {!isExpanded ? (
            <Animated.View entering={FadeIn.duration(180)} exiting={FadeOut.duration(100)}>
              {showStopAction ? (
                <ControlPill icon="stop.fill" variant="danger" onPress={props.onStopThread} />
              ) : showDictation ? (
                <DictationControls appearance="send-slot" {...dictation} />
              ) : (
                <ControlPill
                  accessibilityLabel={sendLabel}
                  accessibilityHint={sendBlockHint}
                  icon="arrow.up"
                  variant="primary"
                  disabled={!canSend}
                  onPress={handleSend}
                />
              )}
            </Animated.View>
          ) : null}
          {isExpanded ? (
            <ComposerToolbarRow paddingBottom={0} paddingHorizontal={0} paddingTop={4}>
              <ComposerToolbarScroller
                fadeOpaque={toolbarFadeOpaque}
                fadeTransparent={toolbarFadeTransparent}
                contentPaddingRight={8}
              >
                <ComposerToolbarButton
                  accessibilityLabel={t("Add attachment")}
                  icon="plus"
                  onPress={() => void props.onPickDraftImages()}
                  showChevron={false}
                />
                <ComposerInlineControl
                  accessibilityLabel={t("Model and reasoning settings")}
                  emphasized
                  iconNode={
                    <ProviderIcon provider={currentModelOption?.providerDriver} size={16} />
                  }
                  label={currentModelOption?.label ?? currentModelSelection.model}
                  maxWidth={152}
                  onPress={openSettings}
                />
                {showStopAction ? (
                  <ComposerToolbarButton
                    accessibilityLabel={t("Stop")}
                    icon="stop.fill"
                    variant="danger"
                    onPress={props.onStopThread}
                    showChevron={false}
                  />
                ) : null}
              </ComposerToolbarScroller>
              {showDictation ? (
                <DictationControls appearance="send-slot" {...dictation} />
              ) : (
                <ComposerToolbarButton
                  accessibilityLabel={sendLabel}
                  accessibilityHint={sendBlockHint}
                  icon="arrow.up"
                  variant="primary"
                  disabled={!canSend}
                  onPress={handleSend}
                  showChevron={false}
                />
              )}
            </ComposerToolbarRow>
          ) : null}
        </ComposerSurface>

        {/* Queue count */}
        {props.queueCount > 0 ? (
          <Animated.View entering={FadeIn.duration(180)} exiting={FadeOut.duration(120)}>
            <Text className="pt-2 text-xs text-foreground-muted">
              {plural(props.queueCount, {
                one: "{count} queued message will send automatically.",
                other: "{count} queued messages will send automatically.",
              })}
            </Text>
          </Animated.View>
        ) : null}
      </Animated.View>

      <ImageViewing
        images={previewImageUri ? [{ uri: previewImageUri }] : []}
        imageIndex={0}
        visible={previewImageUri !== null}
        onRequestClose={closePreview}
        swipeToCloseEnabled
        doubleTapToZoomEnabled
      />
    </Animated.View>
  );
});