Skip to content

The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.

3.2 KB
Raw Blame
import type { RunMode } from '../../store/runModeSlice';

type ComposerSendBlockReason =
  | 'empty_input'
  | 'missing_thread'
  | 'composer_blocked'
  | 'usage_limit_reached'
  | 'socket_disconnected';

export type SlashCommandDecision =
  | { kind: 'new_or_clear' }
  | { kind: 'run_mode'; mode: RunMode }
  | { kind: 'stop' }
  | { kind: 'not_handled' };

interface ComposerSendDecisionArgs {
  rawText: string;
  selectedThreadId: string | null;
  composerInteractionBlocked: boolean;
  isAtLimit: boolean;
  socketStatus: string;
}

interface ComposerSendDecision {
  shouldSend: boolean;
  trimmedText: string;
  blockReason?: ComposerSendBlockReason;
}

interface ComposerBlockedSendFeedback {
  error: { code: 'usage_limit_reached' | 'socket_disconnected'; message: string };
}

interface ComposerKeyDownEventLike {
  key: string;
  shiftKey?: boolean;
  isComposing?: boolean;
  keyCode?: number;
  nativeEvent?: { isComposing?: boolean; keyCode?: number };
}

export const handleComposerSlashCommand = (command: string): SlashCommandDecision => {
  const cmd = command.toLowerCase();
  if (cmd === '/new' || cmd === '/clear') {
    return { kind: 'new_or_clear' };
  }
  if (cmd === '/plan' || cmd === '/build') {
    return { kind: 'run_mode', mode: cmd === '/plan' ? 'plan' : 'build' };
  }
  if (cmd === '/stop') {
    return { kind: 'stop' };
  }
  return { kind: 'not_handled' };
};

export const evaluateComposerSend = (args: ComposerSendDecisionArgs): ComposerSendDecision => {
  const trimmedText = args.rawText.trim();

  if (!trimmedText) {
    return { shouldSend: false, trimmedText, blockReason: 'empty_input' };
  }

  if (!args.selectedThreadId) {
    return { shouldSend: false, trimmedText, blockReason: 'missing_thread' };
  }

  if (args.composerInteractionBlocked) {
    return { shouldSend: false, trimmedText, blockReason: 'composer_blocked' };
  }

  if (args.isAtLimit) {
    return { shouldSend: false, trimmedText, blockReason: 'usage_limit_reached' };
  }

  if (args.socketStatus !== 'connected') {
    return { shouldSend: false, trimmedText, blockReason: 'socket_disconnected' };
  }

  return { shouldSend: true, trimmedText };
};

const isComposerImeComposing = (
  event: ComposerKeyDownEventLike,
  compositionActive = false
): boolean =>
  compositionActive ||
  event.isComposing === true ||
  event.keyCode === 229 ||
  event.nativeEvent?.isComposing === true ||
  event.nativeEvent?.keyCode === 229;

export const shouldSendComposerKeyDown = (
  event: ComposerKeyDownEventLike,
  compositionActive = false
): boolean =>
  event.key === 'Enter' && !event.shiftKey && !isComposerImeComposing(event, compositionActive);

export const getComposerBlockedSendFeedback = (
  blockReason: ComposerSendBlockReason | undefined
): ComposerBlockedSendFeedback | null => {
  if (blockReason === 'usage_limit_reached') {
    return {
      error: {
        code: 'usage_limit_reached',
        message: 'Included budget exhausted. Top up credits or upgrade to continue.',
      },
    };
  }

  if (blockReason === 'socket_disconnected') {
    return {
      error: {
        code: 'socket_disconnected',
        message:
          'Realtime socket is not connected — responses cannot be delivered without a client ID.',
      },
    };
  }

  return null;
};