Skip to content

Automate browser based workflows with AI

5.8 KB
Raw Blame
import { HelpTooltip } from "@/components/HelpTooltip";
import { Label } from "@/components/ui/label";
import {
  Select,
  SelectTrigger,
  SelectContent,
  SelectValue,
  SelectItem,
} from "@/components/ui/select";
import { getClient } from "@/api/AxiosClient";
import { useQuery } from "@tanstack/react-query";
import { useCredentialGetter } from "@/hooks/useCredentialGetter";
import { ModelsResponse } from "@/api/types";
import { WorkflowModel } from "@/routes/workflows/types/workflowTypes";
import { useWorkflowScopeReadOnly } from "@/routes/workflows/editor/WorkflowScopeContext";
import { BadgeLabel } from "@/components/BadgeLabel";

type Props = {
  className?: string;
  clearable?: boolean;
  value: WorkflowModel | null;
  // --
  onChange: (value: WorkflowModel | null) => void;
};

const constants = {
  SkyvernOptimized: "Skyvern Optimized",
} as const;

const deprecatedModelNames = new Set<string>([
  "gemini-3-pro-preview",
  "gemini-3.0-flash",
  "gemini-3.5-flash",
  "azure/gpt-4.1",
  "azure/gpt-5",
  "azure/gpt-5-mini",
  "azure/gpt-5.2",
  "azure/gpt-5.4",
  "azure/gpt-5.6-sol",
  "azure/gpt-5.6-terra",
  "azure/gpt-5.6-luna",
  "azure/o3",
  "claude-haiku-4-5-20251001",
  "claude-opus-4-5-20251101",
  "claude-sonnet-4-5-20250929",
  "claude-opus-4-6",
  "claude-opus-5",
  "claude-fable-5",
  "mercury-2",
]);

const enterpriseModelNames = new Set<string>([
  "us.anthropic.claude-opus-4-20250514-v1:0",
  "claude-opus-4-5-20251101",
  "claude-opus-4-6",
  "claude-opus-4-7",
  "claude-opus-4-8",
  "claude-opus-5",
  "claude-opus-5-5",
]);

function ModelSelector({
  clearable = true,
  value,
  onChange,
  className,
}: Props) {
  const credentialGetter = useCredentialGetter();
  const scopeReadOnly = useWorkflowScopeReadOnly();

  const { data: availableModels } = useQuery<ModelsResponse>({
    queryKey: ["models"],
    queryFn: async () => {
      const client = await getClient(credentialGetter);
      return client.get("/models").then((res) => res.data);
    },
    enabled: !scopeReadOnly,
  });

  const rawModels = availableModels?.models ?? {};
  const models = Object.fromEntries(
    Object.entries(rawModels).map(([modelName, label]) => [
      modelName,
      deprecatedModelNames.has(modelName) ? `${label} (deprecated)` : label,
    ]),
  );

  const visibleEntries = Object.entries(models).filter(
    ([modelName]) =>
      !deprecatedModelNames.has(modelName) || value?.model_name === modelName,
  );

  const reverseMap = visibleEntries.reduce(
    (acc, [modelName, label]) => {
      acc[label] = modelName;
      return acc;
    },
    {} as Record<string, string>,
  );
  const labels = Object.keys(reverseMap);

  const chosen = value
    ? (models[value.model_name] ?? constants.SkyvernOptimized)
    : constants.SkyvernOptimized;
  const choices = [constants.SkyvernOptimized, ...labels];

  // Read-only diff shows the stored model verbatim, not remapped through the gated-off /models list.
  if (scopeReadOnly) {
    return (
      <div className="flex items-center justify-between">
        <div className="flex gap-2">
          <Label className="text-xs font-normal text-slate-300">Model</Label>
          <HelpTooltip content="The LLM model to use for this block" />
        </div>
        <div
          data-testid="model-selector-readonly"
          className={
            "flex h-9 items-center rounded-md border border-input px-3 text-sm text-slate-300 " +
            (className || "")
          }
        >
          {value?.model_name ?? constants.SkyvernOptimized}
        </div>
      </div>
    );
  }

  return (
    <div className="flex items-center justify-between">
      <div className="flex gap-2">
        <Label className="text-xs font-normal text-slate-300">Model</Label>
        <HelpTooltip content="The LLM model to use for this block" />
      </div>
      <div className="relative flex items-center">
        <Select
          value={chosen}
          onValueChange={(v) => {
            const newValue = v === constants.SkyvernOptimized ? null : v;
            const modelName = newValue ? reverseMap[newValue] : null;
            const value = modelName ? { model_name: modelName } : null;
            onChange(value);
          }}
        >
          <SelectTrigger
            className={(className || "") + (value && clearable ? " pr-10" : "")}
          >
            <SelectValue placeholder={constants.SkyvernOptimized} />
          </SelectTrigger>
          <SelectContent>
            {choices.map((m) => {
              const modelName = reverseMap[m];
              return (
                <SelectItem key={m} value={m}>
                  {m === constants.SkyvernOptimized ? (
                    <span>Skyvern Optimized ✨</span>
                  ) : (
                    <BadgeLabel
                      label={m}
                      badge={
                        modelName && enterpriseModelNames.has(modelName)
                          ? "Enterprise"
                          : undefined
                      }
                      badgeVariant="warning"
                    />
                  )}
                </SelectItem>
              );
            })}
          </SelectContent>
        </Select>
        {value && clearable && (
          <>
            <div
              className="pointer-events-none absolute right-8 top-1/2 h-5 w-px -translate-y-1/2 bg-slate-200 opacity-70 dark:bg-slate-700"
              aria-hidden="true"
            />
            <button
              type="button"
              aria-label="Clear selection"
              className="absolute right-0 z-10 flex h-9 w-8 items-center justify-center text-slate-400 hover:text-red-500 focus:outline-none"
              onClick={() => onChange(null)}
              tabIndex={0}
            >
              ×
            </button>
          </>
        )}
      </div>
    </div>
  );
}

ModelSelector.displayName = "ModelSelector";

export { ModelSelector };