feat(gpu-service): restrict non-stopped instance edit, drop recreate

- non-stopped edit: only displayName and SSH public keys editable;
  type/template/storage sections disabled (stopped edit keeps all editable)
- remove recreate feature and the realAction prop it required:
  entry, delete-then-create submit path, warning banner, locale keys

.claude/skills/form-patterns/SKILL.md

@@ -97,6 +97,38 @@ const handleBChange = (b) => {
 };
 ```
 
+## 4. Controlled input with derived fields
+
+When a controlled field's value comes from **both** user input and a programmatic default (e.g. a percentage picked on a slider, and a default seeded on select / mode-switch), funnel both through **one commit function** — don't duplicate "write field + recompute derived" per call site.
+
+- The `Form.Item`-bound input's `onChange(value)` forwards the value to the commit fn (the field is antd-bound, but pass the value explicitly so the default path can reuse the same fn instead of reading the store).
+- Seed defaults by calling the **same** commit fn with the computed value.
+- Separate the **commit action** (write field + recompute dependents) from the **render-derive** (read the field → recompute dependents). Keeping the derive standalone lets it re-run on reload/edit where there's no user event.
+
+```ts
+// commit action — slider onChange AND default both call this
+const commitRatio = (value: number) => {
+  form.setFieldsValue({ spec: { resources: { ratio: value, cores: 100 } } });
+  rescaleDerived(); // reads ratio from the form, sets the disabled cpu/ram
+};
+
+// render-derive — also called from the edit/reload effect
+const rescaleDerived = () => {
+  const ratio = form.getFieldValue(['spec', 'resources', 'ratio']);
+  form.setFieldsValue({
+    spec: {
+      resources: {
+        cpu: floorScale(unit.cpu, ratio),
+        ram: floorScale(unit.ram, ratio)
+      }
+    }
+  });
+};
+
+// default seeding reuses the commit fn — one path, not a second copy
+const applyDefaults = (item) => commitRatio(Math.min(10, item.maxRatio) || 10);
+```
+
 ## Related
 
 - Module/file structure for forms lives in the **create-crud-page** skill (section 3).

CLAUDE.md

@@ -98,6 +98,10 @@ Compose layout with Ant components, not hand-written `display: flex`.
 
 Drive spacing with the theme scale (`Flex`/`Space` `gap`, or `var(--ant-*)` spacing tokens), not scattered `px` literals.
 
+## Tables
+
+- **Horizontally scrollable table**: set `scroll={{ x: 'max-content' }}` **and** add `className="scroll-table"` on the `Table`. The class styles the horizontal scroll to match the design; without it the scroll works but looks off.
+
 # Naming conventions
 
 A page module lives under `src/pages/{module}` with this sub-structure: `components/`, `config/`, `forms/`, `hooks/`, `services/`, `index.tsx`. File naming:

config/routes.ts

@@ -211,6 +211,16 @@ const baseRoutes = [
         defaultIcon: 'icon-cloud-outlined',
         component: './gpu-service/instances'
       },
+      {
+        name: 'instanceTypes',
+        path: '/gpu-service/instance-types',
+        key: 'gpuServiceInstanceTypes',
+        icon: 'icon-outline-gpu',
+        access: 'canSeeOrgAdmin',
+        selectedIcon: 'icon-filled-gpu',
+        defaultIcon: 'icon-outline-gpu',
+        component: './gpu-service/instance-types'
+      },
       {
         name: 'templates',
         path: '/gpu-service/templates',

src/locales/en-US/common.ts

@@ -222,6 +222,12 @@ export default {
   'common.title.delete.confirm': 'Confirm deletion',
   'common.title.stop.confirm': 'Confirm stop',
   'common.title.start.confirm': 'Confirm start',
+  'common.title.activate.confirm': 'Confirm activate',
+  'common.title.deactivate.confirm': 'Confirm deactivate',
+  'common.activate.single.confirm':
+    'Are you sure you want to activate? \n <span style="font-size: 13px;font-weight: 700">{name}</span>',
+  'common.deactivate.single.confirm':
+    'Are you sure you want to deactivate? \n <span style="font-size: 13px;font-weight: 700">{name}</span>',
   'common.title.recreate.confirm': 'Confirm recreate',
   'common.button.addLabel': 'Add Label',
   'common.button.addSelector': 'Add Selector',

src/locales/en-US/gpuservice.ts

@@ -119,12 +119,44 @@ export default {
     'No available GPU resources, please choose another instance type.',
   'gpuservice.instance.gpuCount.zero':
     'CPU-only setup for environment preparation.',
+  'gpuservice.instance.mode.whole': 'Full GPU',
+  'gpuservice.instance.mode.sliced': 'By Ratio',
+  'gpuservice.instance.slice.memoryPercentage': 'VRAM Percentage (%)',
+  'gpuservice.instance.slice.percentage': 'Percentage (%)',
+  'gpuservice.instance.slice.coresPercentage': 'Compute Percentage (%)',
+  'gpuservice.instance.slice.cores.min':
+    'The compute ratio must be no less than the VRAM ratio ({count}%)',
+  'gpuservice.instance.slice.fullCores': '100% Compute',
+  'gpuservice.instance.slice.percentage.required':
+    'Please select or enter a percentage',
+  'gpuservice.instance.slice.percentage.max':
+    'The ratio must be between 1% and {count}%',
   'gpuservice.instance.stock': 'Stock',
   'gpuservice.instance.sliced': 'Sliced',
+  'gpuservice.instance.sliceable': 'Sliceable',
   'gpuservice.instance.memory': 'VRAM',
   'gpuservice.instance.ram': 'RAM',
   'gpuservice.instance.os': 'OS',
   'gpuservice.instance.arch': 'Arch',
+  'gpuservice.instanceType': 'GPU Instance Type',
+  'gpuservice.instanceType.add': 'Add Instance Type',
+  'gpuservice.instanceType.flavor': 'Flavor',
+  'gpuservice.instanceType.flavor.required':
+    'Please select an instance type flavor',
+  'gpuservice.instanceType.flavor.gpuGroup': 'GPU Compute',
+  'gpuservice.instanceType.flavor.cpuGroup': 'CPU Compute',
+  'gpuservice.instanceType.activate': 'Activate',
+  'gpuservice.instanceType.deactivate': 'Deactivate',
+  'gpuservice.instanceType.platform': 'Platform',
+  'gpuservice.instanceType.product': 'Product',
+  'gpuservice.instanceType.unitCpu': 'Unit CPU',
+  'gpuservice.instanceType.unitCpu.tip': 'CPU allocated per GPU',
+  'gpuservice.instanceType.unitRam': 'Unit RAM',
+  'gpuservice.instanceType.unitRam.tip': 'RAM allocated per GPU',
+  'gpuservice.instanceType.localStorage': 'Storage',
+  'gpuservice.instanceType.localStorage.tip': 'Maximum available disk',
+  'gpuservice.instanceType.notSliceable': 'Not Sliceable',
+  'gpuservice.instanceType.filter.name': 'Search by name',
   'gpuservice.instance.disk': 'Disk',
   'gpuservice.table.count': 'Count',
   'gpuservice.instance.disk.system': 'System Disk',
@@ -146,9 +178,6 @@ export default {
     'Only events from the last hour are shown',
   'gpuservice.instance.event.tab.instance': 'Instance Events',
   'gpuservice.instance.event.tab.volume': 'Volume Events',
-  'gpuservice.instance.recreate.confirm.title': 'Confirm recreation',
-  'gpuservice.instance.recreate.confirm.content':
-    'The current instance will be deleted first, then recreated with the current configuration.\n <span style="font-size: 13px;font-weight: 700">{name}</span>',
   'gpuservice.storage': 'Storage',
   'gpuservice.storage.add': 'Add Storage',
   'gpuservice.storage.edit': 'Edit Storage',

src/locales/en-US/menu.ts

@@ -47,6 +47,7 @@ export default {
   'menu.models.backendsList': 'Inference Backends',
   'menu.gpuService': 'GPU Service',
   'menu.gpuService.instances': 'GPU Instances',
+  'menu.gpuService.instanceTypes': 'Instance Types',
   'menu.gpuService.templates': 'Instance Templates',
   'menu.gpuService.storage': 'Storage',
   'menu.gpuService.storageTypes': 'Storage Types',

src/locales/en-US/no-result.ts

@@ -68,6 +68,10 @@ export default {
   'noresult.gpuservice.storage.title': 'No Storage',
   'noresult.gpuservice.storage.subTitle': 'No storage has been added yet.',
   'noresult.gpuservice.storage.nofound': 'No matching storage found.',
+  'noresult.gpuservice.instanceType.title': 'No Instance Types',
+  'noresult.gpuservice.instanceType.subTitle':
+    'Create an instance type to get started',
+  'noresult.gpuservice.instanceType.nofound': 'No instance types found',
   'noresult.gpuservice.storageType.title': 'No Storage Types',
   'noresult.gpuservice.storageType.subTitle':
     'No storage types have been added yet.',

src/locales/ja-JP/common.ts

@@ -221,6 +221,12 @@ export default {
   'common.title.delete.confirm': '削除を確認',
   'common.title.stop.confirm': '停止を確認',
   'common.title.start.confirm': '開始を確認',
+  'common.title.activate.confirm': '有効化を確認',
+  'common.title.deactivate.confirm': '無効化を確認',
+  'common.activate.single.confirm':
+    '<span style="font-size: 13px;font-weight: 700">{name}</span> を有効化してもよろしいですか？',
+  'common.deactivate.single.confirm':
+    '<span style="font-size: 13px;font-weight: 700">{name}</span> を無効化してもよろしいですか？',
   'common.title.recreate.confirm': '再作成を確認',
   'common.button.addLabel': 'ラベルを追加',
   'common.button.addSelector': 'セレクターを追加',

src/locales/ja-JP/gpuservice.ts

@@ -118,12 +118,44 @@ export default {
   'gpuservice.instance.gpuCount.noAvailable':
     '利用可能な GPU リソースがありません。別のインスタンスタイプを選択してください。',
   'gpuservice.instance.gpuCount.zero': 'CPU のみを使用し、環境準備用です。',
+  'gpuservice.instance.mode.whole': 'GPU 全体',
+  'gpuservice.instance.mode.sliced': '比率で',
+  'gpuservice.instance.slice.memoryPercentage': 'VRAM の割合（%）',
+  'gpuservice.instance.slice.percentage': '割合（%）',
+  'gpuservice.instance.slice.coresPercentage': '演算能力の割合（%）',
+  'gpuservice.instance.slice.cores.min':
+    '演算能力の割合は VRAM の割合（{count}%）以上である必要があります',
+  'gpuservice.instance.slice.fullCores': '100% コンピュート',
+  'gpuservice.instance.slice.percentage.required':
+    'パーセンテージを選択または入力してください',
+  'gpuservice.instance.slice.percentage.max':
+    '比率は 1% から {count}% の間で指定してください',
   'gpuservice.instance.stock': '在庫',
   'gpuservice.instance.sliced': '分割',
+  'gpuservice.instance.sliceable': '分割可能',
   'gpuservice.instance.memory': 'VRAM',
   'gpuservice.instance.ram': 'RAM',
   'gpuservice.instance.os': 'OS',
   'gpuservice.instance.arch': 'アーキテクチャ',
+  'gpuservice.instanceType': 'GPU Instance Type',
+  'gpuservice.instanceType.add': 'Add Instance Type',
+  'gpuservice.instanceType.flavor': 'Flavor',
+  'gpuservice.instanceType.flavor.required':
+    'Please select an instance type flavor',
+  'gpuservice.instanceType.flavor.gpuGroup': 'GPU Compute',
+  'gpuservice.instanceType.flavor.cpuGroup': 'CPU Compute',
+  'gpuservice.instanceType.activate': 'Activate',
+  'gpuservice.instanceType.deactivate': 'Deactivate',
+  'gpuservice.instanceType.platform': 'Platform',
+  'gpuservice.instanceType.product': 'Product',
+  'gpuservice.instanceType.unitCpu': 'Unit CPU',
+  'gpuservice.instanceType.unitCpu.tip': 'CPU allocated per GPU',
+  'gpuservice.instanceType.unitRam': 'Unit RAM',
+  'gpuservice.instanceType.unitRam.tip': 'RAM allocated per GPU',
+  'gpuservice.instanceType.localStorage': 'Storage',
+  'gpuservice.instanceType.localStorage.tip': 'Maximum available disk',
+  'gpuservice.instanceType.notSliceable': 'Not Sliceable',
+  'gpuservice.instanceType.filter.name': 'Search by name',
   'gpuservice.instance.disk': 'ディスク',
   'gpuservice.table.count': '数量',
   'gpuservice.instance.disk.system': 'システムディスク',
@@ -145,9 +177,6 @@ export default {
     '直近 1 時間のイベントのみ表示されます',
   'gpuservice.instance.event.tab.instance': 'インスタンスイベント',
   'gpuservice.instance.event.tab.volume': 'ボリュームイベント',
-  'gpuservice.instance.recreate.confirm.title': '再作成を確認しますか',
-  'gpuservice.instance.recreate.confirm.content':
-    '現在のインスタンスを削除した後、現在の構成で再作成します。\n <span style="font-size: 13px;font-weight: 700">{name}</span>',
   'gpuservice.storage': 'ストレージ',
   'gpuservice.storage.add': 'ストレージを追加',
   'gpuservice.storage.edit': 'ストレージを編集',

src/locales/ja-JP/menu.ts

@@ -47,6 +47,7 @@ export default {
   'menu.models.backendsList': 'Inference Backends',
   'menu.gpuService': 'GPU Service',
   'menu.gpuService.instances': 'GPU Instances',
+  'menu.gpuService.instanceTypes': 'Instance Types',
   'menu.gpuService.templates': 'Instance Templates',
   'menu.gpuService.storage': 'Storage',
   'menu.gpuService.storageTypes': 'ストレージタイプ',

src/locales/ja-JP/no-result.ts

@@ -70,6 +70,10 @@ export default {
   'noresult.gpuservice.storage.subTitle':
     'ストレージはまだ追加されていません。',
   'noresult.gpuservice.storage.nofound': '一致するストレージが見つかりません。',
+  'noresult.gpuservice.instanceType.title': 'No Instance Types',
+  'noresult.gpuservice.instanceType.subTitle':
+    'Create an instance type to get started',
+  'noresult.gpuservice.instanceType.nofound': 'No instance types found',
   'noresult.gpuservice.storageType.title': 'ストレージタイプなし',
   'noresult.gpuservice.storageType.subTitle':
     'ストレージタイプはまだ追加されていません。',

src/locales/ru-RU/common.ts

@@ -219,6 +219,12 @@ export default {
   'common.title.delete.confirm': 'Подтверждение удаления',
   'common.title.stop.confirm': 'Подтверждение остановки',
   'common.title.start.confirm': 'Подтверждение запуска',
+  'common.title.activate.confirm': 'Подтверждение активации',
+  'common.title.deactivate.confirm': 'Подтверждение деактивации',
+  'common.activate.single.confirm':
+    'Вы уверены, что хотите активировать <span style="font-size: 13px;font-weight: 700">{name}</span>?',
+  'common.deactivate.single.confirm':
+    'Вы уверены, что хотите деактивировать <span style="font-size: 13px;font-weight: 700">{name}</span>?',
   'common.title.recreate.confirm': 'Подтверждение пересоздания',
   'common.button.addLabel': 'Добавить метку',
   'common.button.addSelector': 'Добавить селектор',

src/locales/ru-RU/gpuservice.ts

@@ -117,12 +117,44 @@ export default {
   'gpuservice.instance.gpuCount.noAvailable':
     'Нет доступных ресурсов GPU, выберите другой тип экземпляра.',
   'gpuservice.instance.gpuCount.zero': 'Только CPU, для подготовки окружения.',
+  'gpuservice.instance.mode.whole': 'Весь GPU',
+  'gpuservice.instance.mode.sliced': 'По доле',
+  'gpuservice.instance.slice.memoryPercentage': 'Доля VRAM (%)',
+  'gpuservice.instance.slice.percentage': 'Доля (%)',
+  'gpuservice.instance.slice.coresPercentage': 'Доля вычислений (%)',
+  'gpuservice.instance.slice.cores.min':
+    'Доля вычислений должна быть не меньше доли VRAM ({count}%)',
+  'gpuservice.instance.slice.fullCores': '100% вычислений',
+  'gpuservice.instance.slice.percentage.required':
+    'Выберите или введите процент',
+  'gpuservice.instance.slice.percentage.max':
+    'Доля должна быть от 1% до {count}%',
   'gpuservice.instance.stock': 'Остаток',
   'gpuservice.instance.sliced': 'Разделено',
+  'gpuservice.instance.sliceable': 'Делимый',
   'gpuservice.instance.memory': 'VRAM',
   'gpuservice.instance.ram': 'RAM',
   'gpuservice.instance.os': 'ОС',
   'gpuservice.instance.arch': 'Архитектура',
+  'gpuservice.instanceType': 'GPU Instance Type',
+  'gpuservice.instanceType.add': 'Add Instance Type',
+  'gpuservice.instanceType.flavor': 'Flavor',
+  'gpuservice.instanceType.flavor.required':
+    'Please select an instance type flavor',
+  'gpuservice.instanceType.flavor.gpuGroup': 'GPU Compute',
+  'gpuservice.instanceType.flavor.cpuGroup': 'CPU Compute',
+  'gpuservice.instanceType.activate': 'Activate',
+  'gpuservice.instanceType.deactivate': 'Deactivate',
+  'gpuservice.instanceType.platform': 'Platform',
+  'gpuservice.instanceType.product': 'Product',
+  'gpuservice.instanceType.unitCpu': 'Unit CPU',
+  'gpuservice.instanceType.unitCpu.tip': 'CPU allocated per GPU',
+  'gpuservice.instanceType.unitRam': 'Unit RAM',
+  'gpuservice.instanceType.unitRam.tip': 'RAM allocated per GPU',
+  'gpuservice.instanceType.localStorage': 'Storage',
+  'gpuservice.instanceType.localStorage.tip': 'Maximum available disk',
+  'gpuservice.instanceType.notSliceable': 'Not Sliceable',
+  'gpuservice.instanceType.filter.name': 'Search by name',
   'gpuservice.instance.disk': 'Диск',
   'gpuservice.table.count': 'Количество',
   'gpuservice.instance.disk.system': 'Системный диск',
@@ -144,9 +176,6 @@ export default {
     'Отображаются только события за последний час',
   'gpuservice.instance.event.tab.instance': 'События экземпляра',
   'gpuservice.instance.event.tab.volume': 'События тома',
-  'gpuservice.instance.recreate.confirm.title': 'Подтвердить пересоздание',
-  'gpuservice.instance.recreate.confirm.content':
-    'Текущий экземпляр будет сначала удалён, а затем пересоздан с текущей конфигурацией.\n <span style="font-size: 13px;font-weight: 700">{name}</span>',
   'gpuservice.storage': 'Хранилище',
   'gpuservice.storage.add': 'Добавить хранилище',
   'gpuservice.storage.edit': 'Редактировать хранилище',

src/locales/ru-RU/menu.ts

@@ -47,6 +47,7 @@ export default {
   'menu.settings': 'Settings',
   'menu.gpuService': 'GPU Service',
   'menu.gpuService.instances': 'GPU Instances',
+  'menu.gpuService.instanceTypes': 'Instance Types',
   'menu.gpuService.templates': 'Instance Templates',
   'menu.gpuService.storage': 'Storage',
   'menu.gpuService.storageTypes': 'Типы хранилищ',

src/locales/ru-RU/no-result.ts

@@ -69,6 +69,10 @@ export default {
   'noresult.gpuservice.storage.title': 'Нет хранилищ',
   'noresult.gpuservice.storage.subTitle': 'Хранилища ещё не добавлены.',
   'noresult.gpuservice.storage.nofound': 'Подходящие хранилища не найдены.',
+  'noresult.gpuservice.instanceType.title': 'No Instance Types',
+  'noresult.gpuservice.instanceType.subTitle':
+    'Create an instance type to get started',
+  'noresult.gpuservice.instanceType.nofound': 'No instance types found',
   'noresult.gpuservice.storageType.title': 'Нет типов хранилищ',
   'noresult.gpuservice.storageType.subTitle': 'Типы хранилищ ещё не добавлены.',
   'noresult.gpuservice.storageType.nofound':

src/locales/tr-TR/common.ts

@@ -224,6 +224,12 @@ export default {
   'common.title.delete.confirm': 'Silme onayı',
   'common.title.stop.confirm': 'Durdurma onayı',
   'common.title.start.confirm': 'Başlatma onayı',
+  'common.title.activate.confirm': 'Etkinleştirme onayı',
+  'common.title.deactivate.confirm': 'Devre dışı bırakma onayı',
+  'common.activate.single.confirm':
+    'Etkinleştirmek istediğinizden emin misiniz? \n <span style="font-size: 13px;font-weight: 700">{name}</span>',
+  'common.deactivate.single.confirm':
+    'Devre dışı bırakmak istediğinizden emin misiniz? \n <span style="font-size: 13px;font-weight: 700">{name}</span>',
   'common.title.recreate.confirm': 'Yeniden oluşturma onayı',
   'common.button.addLabel': 'Etiket Ekle',
   'common.button.addSelector': 'Seçici Ekle',

src/locales/tr-TR/gpuservice.ts

@@ -113,12 +113,44 @@ export default {
   'gpuservice.instance.gpuCount.noAvailable':
     'Kullanılabilir GPU kaynağı yok, lütfen başka bir örnek türü seçin.',
   'gpuservice.instance.gpuCount.zero': 'Yalnızca CPU, ortam hazırlığı için.',
+  'gpuservice.instance.mode.whole': 'Tam GPU',
+  'gpuservice.instance.mode.sliced': 'Orana Göre',
+  'gpuservice.instance.slice.memoryPercentage': 'VRAM Yüzdesi (%)',
+  'gpuservice.instance.slice.percentage': 'Yüzde (%)',
+  'gpuservice.instance.slice.coresPercentage': 'İşlem Gücü Yüzdesi (%)',
+  'gpuservice.instance.slice.cores.min':
+    'İşlem gücü oranı VRAM oranından ({count}%) küçük olamaz',
+  'gpuservice.instance.slice.fullCores': '%100 İşlem Gücü',
+  'gpuservice.instance.slice.percentage.required':
+    'Lütfen bir yüzde seçin veya girin',
+  'gpuservice.instance.slice.percentage.max':
+    'Oran %1 ile %{count} arasında olmalıdır',
   'gpuservice.instance.stock': 'Stok',
   'gpuservice.instance.sliced': 'Bölünmüş',
+  'gpuservice.instance.sliceable': 'Bölünebilir',
   'gpuservice.instance.memory': 'VRAM',
   'gpuservice.instance.ram': 'RAM',
   'gpuservice.instance.os': 'OS',
   'gpuservice.instance.arch': 'Mimari',
+  'gpuservice.instanceType': 'GPU Instance Type',
+  'gpuservice.instanceType.add': 'Add Instance Type',
+  'gpuservice.instanceType.flavor': 'Flavor',
+  'gpuservice.instanceType.flavor.required':
+    'Please select an instance type flavor',
+  'gpuservice.instanceType.flavor.gpuGroup': 'GPU Compute',
+  'gpuservice.instanceType.flavor.cpuGroup': 'CPU Compute',
+  'gpuservice.instanceType.activate': 'Activate',
+  'gpuservice.instanceType.deactivate': 'Deactivate',
+  'gpuservice.instanceType.platform': 'Platform',
+  'gpuservice.instanceType.product': 'Product',
+  'gpuservice.instanceType.unitCpu': 'Unit CPU',
+  'gpuservice.instanceType.unitCpu.tip': 'CPU allocated per GPU',
+  'gpuservice.instanceType.unitRam': 'Unit RAM',
+  'gpuservice.instanceType.unitRam.tip': 'RAM allocated per GPU',
+  'gpuservice.instanceType.localStorage': 'Storage',
+  'gpuservice.instanceType.localStorage.tip': 'Maximum available disk',
+  'gpuservice.instanceType.notSliceable': 'Not Sliceable',
+  'gpuservice.instanceType.filter.name': 'Search by name',
   'gpuservice.instance.disk': 'Disk',
   'gpuservice.table.count': 'Sayı',
   'gpuservice.instance.disk.system': 'Sistem Diski',
@@ -140,10 +172,6 @@ export default {
     'Yalnızca son bir saatteki olaylar gösterilir',
   'gpuservice.instance.event.tab.instance': 'Örnek Olayları',
   'gpuservice.instance.event.tab.volume': 'Birim Olayları',
-  'gpuservice.instance.recreate.confirm.title':
-    'Yeniden oluşturma onaylansın mı',
-  'gpuservice.instance.recreate.confirm.content':
-    'Mevcut örnek önce silinecek, ardından mevcut yapılandırmayla yeniden oluşturulacaktır.\n <span style="font-size: 13px;font-weight: 700">{name}</span>',
   'gpuservice.storage': 'Depolama',
   'gpuservice.storage.add': 'Depolama Ekle',
   'gpuservice.storage.edit': 'Depolamayı Düzenle',

src/locales/tr-TR/menu.ts

@@ -47,6 +47,7 @@ export default {
   'menu.settings': 'Settings',
   'menu.gpuService': 'GPU Service',
   'menu.gpuService.instances': 'GPU Instances',
+  'menu.gpuService.instanceTypes': 'Instance Types',
   'menu.gpuService.templates': 'Instance Templates',
   'menu.gpuService.storage': 'Storage',
   'menu.gpuService.storageTypes': 'Depolama Türleri',

src/locales/tr-TR/no-result.ts

@@ -67,6 +67,10 @@ export default {
   'noresult.gpuservice.storage.title': 'Depolama Yok',
   'noresult.gpuservice.storage.subTitle': 'Henüz depolama eklenmedi.',
   'noresult.gpuservice.storage.nofound': 'Eşleşen depolama bulunamadı.',
+  'noresult.gpuservice.instanceType.title': 'No Instance Types',
+  'noresult.gpuservice.instanceType.subTitle':
+    'Create an instance type to get started',
+  'noresult.gpuservice.instanceType.nofound': 'No instance types found',
   'noresult.gpuservice.storageType.title': 'Depolama Türü Yok',
   'noresult.gpuservice.storageType.subTitle': 'Henüz depolama türü eklenmedi.',
   'noresult.gpuservice.storageType.nofound':

src/locales/zh-CN/common.ts

@@ -212,6 +212,12 @@ export default {
   'common.title.delete.confirm': '确认删除',
   'common.title.stop.confirm': '确认停止',
   'common.title.start.confirm': '确认启动',
+  'common.title.activate.confirm': '确认启用',
+  'common.title.deactivate.confirm': '确认停用',
+  'common.activate.single.confirm':
+    '确定启用 <span style="font-size: 13px;font-weight: 700">{name}？</span>',
+  'common.deactivate.single.confirm':
+    '确定停用 <span style="font-size: 13px;font-weight: 700">{name}？</span>',
   'common.title.recreate.confirm': '确认重新创建',
   'common.button.addLabel': '添加标签',
   'common.button.addSelector': '添加选择器',

src/locales/zh-CN/gpuservice.ts

@@ -108,12 +108,40 @@ export default {
   'gpuservice.instance.gpuCount.noAvailable':
     '没有可用的 GPU 资源，请选择其他实例类型。',
   'gpuservice.instance.gpuCount.zero': '仅使用 CPU，用于环境准备。',
+  'gpuservice.instance.mode.whole': '整卡',
+  'gpuservice.instance.mode.sliced': '按比例',
+  'gpuservice.instance.slice.memoryPercentage': '显存占比（%）',
+  'gpuservice.instance.slice.percentage': '占比（%）',
+  'gpuservice.instance.slice.coresPercentage': '算力占比（%）',
+  'gpuservice.instance.slice.cores.min': '算力占比需不小于显存占比 {count}%',
+  'gpuservice.instance.slice.fullCores': '100% 算力',
+  'gpuservice.instance.slice.percentage.required': '请选择或输入百分比',
+  'gpuservice.instance.slice.percentage.max': '比例需在 1% 到 {count}% 之间',
   'gpuservice.instance.stock': '库存',
   'gpuservice.instance.sliced': '切分',
+  'gpuservice.instance.sliceable': '可切分',
   'gpuservice.instance.memory': '显存',
   'gpuservice.instance.ram': '内存',
   'gpuservice.instance.os': '系统',
   'gpuservice.instance.arch': '架构',
+  'gpuservice.instanceType': 'GPU 实例类型',
+  'gpuservice.instanceType.add': '添加实例类型',
+  'gpuservice.instanceType.flavor': '规格',
+  'gpuservice.instanceType.flavor.required': '请选择实例类型规格',
+  'gpuservice.instanceType.flavor.gpuGroup': 'GPU 算力',
+  'gpuservice.instanceType.flavor.cpuGroup': 'CPU 算力',
+  'gpuservice.instanceType.activate': '启用',
+  'gpuservice.instanceType.deactivate': '停用',
+  'gpuservice.instanceType.platform': '平台',
+  'gpuservice.instanceType.product': '商品',
+  'gpuservice.instanceType.unitCpu': '单位 CPU',
+  'gpuservice.instanceType.unitCpu.tip': '每 GPU 对应多少 CPU',
+  'gpuservice.instanceType.unitRam': '单位内存',
+  'gpuservice.instanceType.unitRam.tip': '每 GPU 对应多少内存',
+  'gpuservice.instanceType.localStorage': '存储',
+  'gpuservice.instanceType.localStorage.tip': '最大可用磁盘',
+  'gpuservice.instanceType.notSliceable': '不可切分',
+  'gpuservice.instanceType.filter.name': '按名称搜索',
   'gpuservice.instance.disk': '磁盘',
   'gpuservice.table.count': '数量',
   'gpuservice.instance.disk.system': '系统盘',
@@ -134,9 +162,6 @@ export default {
   'gpuservice.instance.event.recentHourTip': '仅显示最近一小时的事件。',
   'gpuservice.instance.event.tab.instance': '实例事件',
   'gpuservice.instance.event.tab.volume': '存储卷事件',
-  'gpuservice.instance.recreate.confirm.title': '确认重新创建',
-  'gpuservice.instance.recreate.confirm.content':
-    '系统将先删除当前实例，然后使用当前配置重新创建。\n <span style="font-size: 13px;font-weight: 700">{name}</span>',
   'gpuservice.storage': '存储',
   'gpuservice.storage.add': '添加存储',
   'gpuservice.storage.edit': '编辑存储',

src/locales/zh-CN/menu.ts

@@ -47,6 +47,7 @@ export default {
   'menu.models.backendsList': '推理后端',
   'menu.gpuService': 'GPU 服务',
   'menu.gpuService.instances': 'GPU 实例',
+  'menu.gpuService.instanceTypes': '实例类型',
   'menu.gpuService.templates': '实例模板',
   'menu.gpuService.storage': '存储',
   'menu.gpuService.storageTypes': '存储类型',

src/locales/zh-CN/no-result.ts

@@ -63,6 +63,9 @@ export default {
   'noresult.gpuservice.storage.title': '暂无存储',
   'noresult.gpuservice.storage.subTitle': '尚未添加任何存储。',
   'noresult.gpuservice.storage.nofound': '未找到匹配的存储',
+  'noresult.gpuservice.instanceType.title': '暂无实例类型',
+  'noresult.gpuservice.instanceType.subTitle': '创建一个实例类型以开始使用',
+  'noresult.gpuservice.instanceType.nofound': '未找到实例类型',
   'noresult.gpuservice.storageType.title': '暂无存储类型',
   'noresult.gpuservice.storageType.subTitle': '尚未添加任何存储类型。',
   'noresult.gpuservice.storageType.nofound': '未找到匹配的存储类型',

src/pages/_components/number-selection/index.tsx

@@ -23,6 +23,11 @@ interface NumberSelectionProps {
   labelExtra?: React.ReactNode;
   maxCount?: number;
   tips?: string;
+  // Explicit preset tick values (e.g. [10,20,...,100] for percentage slicing).
+  // Overrides the default 1..maxCount sequence.
+  presetValues?: number[];
+  // Force the free-input box to show regardless of max/maxCount.
+  alwaysShowInput?: boolean;
   onChange?: (value: number) => void;
 }
 
@@ -39,17 +44,18 @@ const NumberSelection: React.FC<NumberSelectionProps> = ({
   className,
   maxCount = 8,
   tips,
+  presetValues,
+  alwaysShowInput,
   style,
   onChange
 }) => {
   const intl = useIntl();
 
-  const showCustomInput = max > maxCount;
+  const showCustomInput = alwaysShowInput || max > maxCount;
-  const presetItems = Array.from(
+  const presetItems =
-    { length: Math.max(0, maxCount) },
+    presetValues ??
-    (_, i) => i + 1
+    Array.from({ length: Math.max(0, maxCount) }, (_, i) => i + 1);
-  );
+  if (!presetValues && min <= 0) {
-  if (min <= 0) {
     presetItems.unshift(0);
   }
   const items = presetItems;

src/pages/_components/number-selection/styles.less

@@ -39,9 +39,20 @@
     display: flex;
     align-items: center;
     padding: 0 12px;
+    padding-right: 2px;
     color: var(--ant-color-text-tertiary);
     white-space: nowrap;
     padding-block: 6px;
+    width: 100%;
+
+    // Spread the label and its labelExtra (e.g. the whole/sliced Segmented)
+    // to opposite ends of the row.
+    :global(.label-text) {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      width: 100%;
+    }
   }
   .contentWrapper {
     width: 100%;

src/pages/cluster-management/hooks/use-cluster-columns.tsx

@@ -153,7 +153,7 @@ const useClusterColumns = (
         span: 3,
         render: (text: string, record: ClusterListItem) => (
           <>
-            <AutoTooltip ghost title={text}>
+            <AutoTooltip ghost title={text} minWidth={20}>
               <span className="text-primary">{record.name}</span>
             </AutoTooltip>
             {record.is_default && (
@@ -186,23 +186,24 @@ const useClusterColumns = (
       {
         title: intl.formatMessage({ id: 'dashboard.totalgpus' }),
         dataIndex: 'gpus',
-        span: 2,
-        sorter: tableSorter(3),
         width: 100,
+        sorter: tableSorter(3),
         render: (value: number) => <span>{value}</span>
       },
       {
         title: intl.formatMessage({ id: 'clusters.table.deployments' }),
         dataIndex: 'models',
         sorter: tableSorter(4),
-        width: 100,
+        span: spans.deployments,
+        maxWidth: 150,
         render: (value: number) => <span>{value}</span>
       },
       {
         title: intl.formatMessage({ id: 'resources.nodes' }),
         dataIndex: 'workers',
+        minWidth: 100,
+        maxWidth: 120,
         sorter: tableSorter(5),
-        width: 100,
         render: (value: number, record: ClusterListItem) => (
           <span>
             {record.ready_workers} / {record.workers}
@@ -213,6 +214,7 @@ const useClusterColumns = (
         title: intl.formatMessage({ id: 'common.table.status' }),
         dataIndex: 'state',
         span: spans.status,
+        minWidth: 80,
         align: 'center',
         render: (value: number, record: ClusterListItem) => (
           <StatusTag

src/pages/gpu-service/instance-types/apis/index.ts

@@ -0,0 +1,76 @@
+import { request } from '@umijs/max';
+import { FlavorItem, FormData, ListItem } from '../config/types';
+
+export const GPU_INSTANCE_TYPES_API = '/gpu-instance-types';
+
+export const GPU_INSTANCE_TYPE_FLAVORS_API = '/gpu-instance-type-flavors';
+
+// GET /gpu-instance-types?cluster_id — instance types defined on a cluster.
+export async function queryGPUInstanceTypes(
+  params: { cluster_id: number },
+  options?: any
+) {
+  return request<{ items: ListItem[] }>(GPU_INSTANCE_TYPES_API, {
+    method: 'GET',
+    params,
+    cancelToken: options?.token
+  });
+}
+
+// GET /gpu-instance-type-flavors?cluster_id — the hardware flavors a new
+// instance type can be based on.
+export async function queryGPUInstanceTypeFlavors(
+  params: { cluster_id: number },
+  options?: any
+) {
+  return request<{ items: FlavorItem[] }>(GPU_INSTANCE_TYPE_FLAVORS_API, {
+    method: 'GET',
+    params,
+    cancelToken: options?.token
+  });
+}
+
+// POST /gpu-instance-types?cluster_id (GPUInstanceTypeCreate).
+export async function createGPUInstanceType(params: {
+  cluster_id: number;
+  data: FormData;
+}) {
+  return request<ListItem>(GPU_INSTANCE_TYPES_API, {
+    method: 'POST',
+    params: { cluster_id: params.cluster_id },
+    data: params.data
+  });
+}
+
+// DELETE /gpu-instance-types/{name}?cluster_id.
+export async function deleteGPUInstanceType(params: {
+  name: string;
+  cluster_id: number;
+}) {
+  return request(`${GPU_INSTANCE_TYPES_API}/${params.name}`, {
+    method: 'DELETE',
+    params: { cluster_id: params.cluster_id }
+  });
+}
+
+// PUT /gpu-instance-types/{name}/activate?cluster_id — activate an instance type.
+export async function activateGPUInstanceType(params: {
+  name: string;
+  cluster_id: number;
+}) {
+  return request(`${GPU_INSTANCE_TYPES_API}/${params.name}/activate`, {
+    method: 'PUT',
+    params: { cluster_id: params.cluster_id }
+  });
+}
+
+// PUT /gpu-instance-types/{name}/deactivate?cluster_id — deactivate an instance type.
+export async function deactivateGPUInstanceType(params: {
+  name: string;
+  cluster_id: number;
+}) {
+  return request(`${GPU_INSTANCE_TYPES_API}/${params.name}/deactivate`, {
+    method: 'PUT',
+    params: { cluster_id: params.cluster_id }
+  });
+}

src/pages/gpu-service/instance-types/components/add-instance-type-modal.tsx

@@ -0,0 +1,114 @@
+import useSubmitLock from '@/hooks/use-submit-lock';
+import { ColumnWrapper, GSDrawer, ModalFooter } from '@gpustack/core-ui';
+import { useIntl } from '@umijs/max';
+import { message } from 'antd';
+import { useEffect, useRef, useState } from 'react';
+import { FlavorItem, FormData } from '../config/types';
+import GPUServiceInstanceTypeForm from '../forms';
+import useQueryFlavors from '../services/use-query-flavors';
+
+type AddInstanceTypeModalProps = {
+  title: string;
+  open: boolean;
+  clusterId?: number;
+  onOk: (values: FormData) => void;
+  onCancel: () => void;
+};
+
+const AddInstanceTypeModal: React.FC<AddInstanceTypeModalProps> = ({
+  title,
+  open,
+  clusterId,
+  onOk,
+  onCancel
+}) => {
+  const intl = useIntl();
+  const form = useRef<any>(null);
+  const { loading, guard, run, release } = useSubmitLock();
+  const [selectedFlavor, setSelectedFlavor] = useState<FlavorItem | null>(null);
+  const {
+    dataList: flavorList,
+    loading: flavorLoading,
+    fetchFlavors
+  } = useQueryFlavors();
+
+  // Fetch flavors when the drawer opens and auto-select the first one, so the
+  // form's flavor-derived fields (group / acceleratable) are always set.
+  useEffect(() => {
+    if (!open) {
+      setSelectedFlavor(null);
+      return;
+    }
+    if (!clusterId) return;
+    const load = async () => {
+      const list = await fetchFlavors(clusterId);
+      setSelectedFlavor(list?.[0] ?? null);
+    };
+    load();
+  }, [open, clusterId]);
+
+  const handleSubmit = () => {
+    if (!selectedFlavor) {
+      message.warning(
+        intl.formatMessage({ id: 'gpuservice.instanceType.flavor.required' })
+      );
+      return;
+    }
+    guard(() => form.current?.submit());
+  };
+
+  const handleCancel = () => {
+    form.current?.resetFields();
+    onCancel();
+  };
+
+  const onFinish = async (values: FormData) => {
+    await run(() => onOk({ ...values }));
+  };
+
+  return (
+    <GSDrawer
+      title={title}
+      open={open}
+      onClose={handleCancel}
+      destroyOnHidden
+      closeIcon={false}
+      mask={{ closable: false }}
+      keyboard={false}
+      styles={{
+        wrapper: { width: 'min(600px, calc(100vw - 220px))' },
+        body: { overflowY: 'hidden' }
+      }}
+      footer={false}
+    >
+      <ColumnWrapper
+        styles={{ container: { paddingBlock: 0 } }}
+        footer={
+          <ModalFooter
+            onOk={handleSubmit}
+            onCancel={handleCancel}
+            loading={loading}
+            style={{
+              padding: '16px 24px 8px',
+              display: 'flex',
+              justifyContent: 'flex-end'
+            }}
+          />
+        }
+      >
+        <GPUServiceInstanceTypeForm
+          ref={form}
+          open={open}
+          selectedFlavor={selectedFlavor}
+          flavorList={flavorList}
+          flavorLoading={flavorLoading}
+          onFlavorChange={setSelectedFlavor}
+          onFinish={onFinish}
+          onFinishFailed={release}
+        />
+      </ColumnWrapper>
+    </GSDrawer>
+  );
+};
+
+export default AddInstanceTypeModal;

src/pages/gpu-service/instance-types/components/flavor-display.tsx

@@ -0,0 +1,118 @@
+import { AutoTooltip, ThemeTag } from '@gpustack/core-ui';
+import { useIntl } from '@umijs/max';
+import { Flex } from 'antd';
+import { formatMemoryDisplay } from '../../instances/config';
+import { manufactureColorMap } from '../../templates/config';
+import { formatManufacturer } from '../../utils';
+
+// The subset of a flavor / instance-type display shape the flavor renderers
+// read. Flavor specs satisfy it directly (minus sliceable, which the API
+// removed from flavors); the management list builds it from spec.acceleratable
+// + status.detail, deriving sliceable from slicedDetail.
+interface FlavorSpecLike {
+  manufacturer?: string | null;
+  product?: string | null;
+  memory?: string | null;
+  sliceable?: boolean;
+  acceleratable?: boolean;
+}
+
+// A flavor's title mirrors the flavor card: a generic (no product, no/`generic`
+// manufacturer, non-acceleratable) flavor reads as "CPU-only".
+export const getFlavorTitle = (
+  spec: FlavorSpecLike = {},
+  fallbackName?: string | null
+) => {
+  const manufacturer = spec.manufacturer || '';
+  const isCpuOnly =
+    !spec.acceleratable &&
+    !spec.product &&
+    (!manufacturer || manufacturer.toLowerCase() === 'generic');
+  return isCpuOnly ? 'CPU-only' : spec.product || fallbackName || '-';
+};
+
+// Secondary line, dot-separated: manufacturer · memory · sliceable. memory and
+// sliceable apply to accelerator (GPU) flavors only; sliceable stays a tag.
+// Returns null when a (generic) flavor has nothing to show.
+export const FlavorMeta: React.FC<{ spec?: FlavorSpecLike }> = ({
+  spec = {}
+}) => {
+  const intl = useIntl();
+  const manufacturer = spec.manufacturer || '';
+  const color = manufactureColorMap[manufacturer] ?? 'purple';
+  const memory = spec.acceleratable
+    ? formatMemoryDisplay(spec.memory ?? undefined)
+    : '';
+
+  const pieces: React.ReactNode[] = [];
+  if (manufacturer) {
+    pieces.push(
+      <ThemeTag
+        key="vendor"
+        color={color}
+        style={{ fontWeight: 400, marginInlineEnd: 0 }}
+      >
+        {formatManufacturer(manufacturer)}
+      </ThemeTag>
+    );
+  }
+  if (memory) {
+    pieces.push(<span key="memory">{memory}</span>);
+  }
+  if (!pieces.length) return null;
+
+  return (
+    <Flex
+      align="center"
+      gap={8}
+      style={{
+        minWidth: 0,
+        color: 'var(--ant-color-text-tertiary)',
+        fontSize: 12
+      }}
+    >
+      {pieces.flatMap((piece, index) =>
+        index === 0
+          ? [piece]
+          : [
+              <span
+                key={`dot-${index}`}
+                style={{ color: 'var(--ant-color-text-quaternary)' }}
+              >
+                ·
+              </span>,
+              piece
+            ]
+      )}
+    </Flex>
+  );
+};
+
+// Two-line flavor display: title on top, meta row below. Shared by the create
+// drawer's dropdown option and the management list's flavor cell.
+export const FlavorOption: React.FC<{
+  spec?: FlavorSpecLike;
+  fallbackName?: string | null;
+  maxWidth?: number | string;
+}> = ({ spec = {}, fallbackName, maxWidth = '100%' }) => (
+  <Flex vertical gap={4} style={{ minWidth: 0, padding: '2px 0' }}>
+    <AutoTooltip ghost minWidth={20} maxWidth={maxWidth}>
+      {getFlavorTitle(spec, fallbackName)}
+    </AutoTooltip>
+    <FlavorMeta spec={spec} />
+  </Flex>
+);
+
+// Single-line flavor display: title then meta inline. Used for the collapsed
+// selected value in the create drawer's Select.
+export const FlavorSelected: React.FC<{
+  spec?: FlavorSpecLike;
+  fallbackName?: string | null;
+}> = ({ spec = {}, fallbackName }) => (
+  <Flex align="center" gap={8} style={{ minWidth: 0 }}>
+    <AutoTooltip ghost minWidth={20} maxWidth={200}>
+      {getFlavorTitle(spec, fallbackName)}
+    </AutoTooltip>
+    <FlavorMeta spec={spec} />
+  </Flex>
+);

src/pages/gpu-service/instance-types/components/flavor-list.tsx

@@ -0,0 +1,120 @@
+import { FileSkeletonRows } from '@/pages/llmodels/components/model-source/file-skeleton';
+import {
+  AutoTooltip,
+  IconFont,
+  TemplateCard,
+  ThemeTag
+} from '@gpustack/core-ui';
+import { useIntl } from '@umijs/max';
+import { Empty, Flex, Spin, Typography } from 'antd';
+import _ from 'lodash';
+import { formatMemoryDisplay } from '../../instances/config';
+import { manufactureColorMap } from '../../templates/config';
+import { FlavorItem } from '../config/types';
+import styles from '../styles/instance-types.module.less';
+
+const { Text } = Typography;
+
+interface FlavorListProps {
+  value?: string;
+  dataList: FlavorItem[];
+  loading?: boolean;
+  onChange?: (item: FlavorItem) => void;
+}
+
+const MetaItem: React.FC<{
+  icon: string;
+  label: string;
+  value?: React.ReactNode;
+}> = ({ icon, label, value }) => {
+  return (
+    <span className={styles.metaLabel}>
+      <IconFont className="icon" type={icon} />
+      {label}: <span className={styles.metaValue}>{value ?? '-'}</span>
+    </span>
+  );
+};
+
+const FlavorList: React.FC<FlavorListProps> = ({
+  value,
+  dataList,
+  loading,
+  onChange
+}) => {
+  const intl = useIntl();
+
+  if (!dataList.length) {
+    if (loading) {
+      return (
+        <Spin spinning size="middle">
+          <Flex vertical gap={16} style={{ minHeight: 200 }}>
+            {_.times(6, (index: number) => (
+              <FileSkeletonRows key={index} counts={2} itemHeight={96} />
+            ))}
+          </Flex>
+        </Spin>
+      );
+    }
+    return <Empty image={Empty.PRESENTED_IMAGE_SIMPLE} />;
+  }
+
+  return (
+    <Flex vertical gap={16}>
+      {dataList.map((item) => {
+        const spec = item.spec || {};
+        const manufacturer = spec.manufacturer || '';
+        const color = manufactureColorMap[manufacturer] ?? 'purple';
+        // A generic (no product, no/`generic` manufacturer) flavor is shown as
+        // "CPU-only" instead of falling back to the raw flavor name.
+        const isCpuOnly =
+          !spec.acceleratable &&
+          !spec.product &&
+          (!manufacturer || manufacturer.toLowerCase() === 'generic');
+        const title = isCpuOnly ? 'CPU-only' : spec.product || item.name || '-';
+        return (
+          <TemplateCard
+            key={item.name}
+            className={styles.flavorCard}
+            clickable
+            ghost
+            hoverable
+            active={value === item.name}
+            onClick={() => onChange?.(item)}
+          >
+            <Flex vertical gap={12} style={{ width: '100%' }}>
+              <Flex align="center" justify="space-between" gap={8}>
+                <div style={{ minWidth: 0, fontWeight: 500 }}>
+                  <AutoTooltip ghost minWidth={20}>
+                    <Text>{title}</Text>
+                  </AutoTooltip>
+                </div>
+                {manufacturer && (
+                  <ThemeTag color={color} style={{ fontWeight: 400 }}>
+                    {manufacturer.toUpperCase()}
+                  </ThemeTag>
+                )}
+              </Flex>
+              {/* Memory only applies to accelerator (GPU) flavors; a
+                  non-acceleratable (generic) flavor has none. (Sliceable is no
+                  longer a flavor field — it is observed per instance type on
+                  status.detail.slicedDetail.) */}
+              {spec.acceleratable && (
+                <Flex wrap gap={16}>
+                  <MetaItem
+                    icon="icon-ram-02"
+                    label={intl.formatMessage({
+                      id: 'gpuservice.instance.memory'
+                    })}
+                    value={formatMemoryDisplay(spec.memory ?? undefined) ?? '-'}
+                  />
+                </Flex>
+              )}
+            </Flex>
+          </TemplateCard>
+        );
+      })}
+    </Flex>
+  );
+};
+
+export default FlavorList;

src/pages/gpu-service/instance-types/components/instance-type-card.tsx

@@ -0,0 +1,151 @@
+import {
+  AutoTooltip,
+  DropdownActions,
+  IconFont,
+  StatusTag,
+  TemplateCard,
+  ThemeTag
+} from '@gpustack/core-ui';
+import { useIntl } from '@umijs/max';
+import { Button } from 'antd';
+import _ from 'lodash';
+import { formatMemoryDisplay, isSliceableDetail } from '../../instances/config';
+import { manufactureColorMap } from '../../templates/config';
+import { ceilMilliToCore, parseQuantityToGi } from '../../utils';
+import {
+  InstanceTypePhaseLabelMap,
+  status as phaseStatusMap,
+  rowActionList
+} from '../config';
+import { ListItem } from '../config/types';
+import styles from '../styles/instance-types.module.less';
+
+interface InstanceTypeCardProps {
+  data: ListItem;
+  onDelete?: (record: ListItem) => void;
+}
+
+const InstanceTypeCard: React.FC<InstanceTypeCardProps> = ({
+  data,
+  onDelete
+}) => {
+  const intl = useIntl();
+  const spec = data.spec || {};
+  // Observed hardware (manufacturer / memory / sliced capability, …) comes
+  // from status.detail and may be absent until the operator backfills status.
+  const detail = data.status?.detail || {};
+  const unit = spec.unitResources || {};
+  const phase = data.status?.phase || '';
+  const manufacturer = detail.manufacturer || '';
+  const manufacturerColor = manufactureColorMap[manufacturer] ?? 'purple';
+  const sliceable = isSliceableDetail(detail.slicedDetail);
+
+  const memoryText = formatMemoryDisplay(detail.memory ?? undefined);
+
+  // Base resources, formatted into a single "·"-separated line. Falsy parts
+  // (e.g. a CPU-only type without VRAM) drop out rather than showing "-".
+  const cpuCores = ceilMilliToCore(unit.cpu ?? null)?.cores;
+  const ramGi = parseQuantityToGi(unit.ram ?? null)?.value;
+  const storageGi = parseQuantityToGi(spec.localStorage ?? null)?.value;
+  const osLabel = _.capitalize(spec.os || '');
+  const archLabel = _.toUpper(spec.arch || '');
+  const storageWord = intl.formatMessage({
+    id: 'gpuservice.instanceType.localStorage'
+  });
+  const footerParts = [
+    cpuCores != null ? `${cpuCores} vCPU` : null,
+    ramGi != null ? `${ramGi} GiB RAM` : null,
+    storageGi != null ? `${storageGi} GiB ${storageWord}` : null,
+    osLabel ? `${osLabel}${archLabel ? ` (${archLabel})` : ''}` : null
+  ].filter(Boolean) as string[];
+
+  const handleAction = (item: any) => {
+    if (item.key === 'delete') {
+      onDelete?.(data);
+    }
+  };
+
+  return (
+    <TemplateCard
+      className={styles.listCard}
+      clickable={false}
+      hoverable
+      ghost
+      header={
+        <div className={styles.header}>
+          <span className={styles.product}>
+            <AutoTooltip ghost minWidth={20}>
+              {detail.product || data.name || '-'}
+            </AutoTooltip>
+          </span>
+          <span className={styles.headerRight}>
+            <span onClick={(e) => e.stopPropagation()}>
+              <DropdownActions
+                menu={{ items: rowActionList, onClick: handleAction }}
+              >
+                <Button
+                  icon={<IconFont type="icon-more" />}
+                  size="small"
+                  type="text"
+                />
+              </DropdownActions>
+            </span>
+          </span>
+        </div>
+      }
+    >
+      <div className={styles.card}>
+        <div className={styles.hero}>
+          <span className={styles.name}>
+            <AutoTooltip ghost minWidth={20}>
+              {data.name || '-'}
+            </AutoTooltip>
+          </span>
+          <span className={styles.memory}>{memoryText || '—'}</span>
+        </div>
+
+        <div className={styles.subline}>
+          {manufacturer && (
+            <ThemeTag color={manufacturerColor} style={{ fontWeight: 400 }}>
+              {manufacturer.toUpperCase()}
+            </ThemeTag>
+          )}
+          {phase ? (
+            <StatusTag
+              statusValue={{
+                status: phaseStatusMap[phase],
+                text: InstanceTypePhaseLabelMap[phase] || phase,
+                message: data.status?.phaseMessage || ''
+              }}
+            />
+          ) : null}
+          {detail.clockSpeed ? <span>{detail.clockSpeed}</span> : null}
+          <span
+            className={`${styles.tag} ${
+              sliceable ? styles.tagSliceable : styles.tagPlain
+            }`}
+          >
+            {sliceable
+              ? intl.formatMessage({ id: 'gpuservice.instance.sliceable' })
+              : intl.formatMessage({
+                  id: 'gpuservice.instanceType.notSliceable'
+                })}
+          </span>
+        </div>
+
+        <div className={styles.divider} />
+
+        <div className={styles.footer}>
+          {footerParts.map((part, index) => (
+            <span key={part}>
+              {index > 0 && <span className={styles.dotSep}>·</span>}
+              {part}
+            </span>
+          ))}
+        </div>
+      </div>
+    </TemplateCard>
+  );
+};
+
+export default InstanceTypeCard;

src/pages/gpu-service/instance-types/components/instance-type-list.tsx

@@ -0,0 +1,31 @@
+import { ResizeContainer } from '@gpustack/core-ui';
+import { Spin } from 'antd';
+import { ListItem } from '../config/types';
+import InstanceTypeCard from './instance-type-card';
+
+interface InstanceTypeListProps {
+  dataList: ListItem[];
+  loading: boolean;
+  onDelete?: (record: ListItem) => void;
+}
+
+const InstanceTypeList: React.FC<InstanceTypeListProps> = ({
+  dataList,
+  loading,
+  onDelete
+}) => {
+  return (
+    <Spin spinning={loading} size="middle">
+      <ResizeContainer
+        defaultSpan={8}
+        resizable
+        dataList={dataList}
+        renderItem={(item: ListItem) => (
+          <InstanceTypeCard data={item} onDelete={onDelete} />
+        )}
+      />
+    </Spin>
+  );
+};
+
+export default InstanceTypeList;

src/pages/gpu-service/instance-types/config/index.ts

@@ -0,0 +1,47 @@
+import { StatusMaps } from '@/config';
+import { StatusType } from '@/config/types';
+import { icons } from '@gpustack/core-ui';
+
+// os is fixed to lowercase "linux" on the wire; the form only ever shows Linux.
+export const GPU_INSTANCE_TYPE_OS = 'linux';
+
+export const InstanceTypePhaseValueMap = {
+  Active: 'Active',
+  Inactive: 'Inactive',
+  Draining: 'Draining'
+};
+
+export const InstanceTypePhaseLabelMap: Record<string, string> = {
+  [InstanceTypePhaseValueMap.Active]: 'Active',
+  [InstanceTypePhaseValueMap.Inactive]: 'Inactive',
+  [InstanceTypePhaseValueMap.Draining]: 'Draining'
+};
+
+export const status: Record<string, StatusType> = {
+  [InstanceTypePhaseValueMap.Active]: StatusMaps.success,
+  [InstanceTypePhaseValueMap.Inactive]: StatusMaps.inactive,
+  [InstanceTypePhaseValueMap.Draining]: StatusMaps.transitioning
+};
+
+export const ArchOptions = [
+  { label: 'AMD64', value: 'amd64' },
+  { label: 'ARM64', value: 'arm64' }
+];
+
+// ``icon`` is narrowed to ``any`` so the inferred type doesn't reach into
+// the antd icon component's internal path.
+export const rowActionList: Array<{
+  label: string;
+  key: string;
+  locale: boolean;
+  icon: any;
+  danger?: boolean;
+}> = [
+  {
+    label: 'common.button.delete',
+    key: 'delete',
+    locale: true,
+    icon: icons.DeleteOutlined,
+    danger: true
+  }
+];

src/pages/gpu-service/instance-types/config/types.ts

@@ -0,0 +1,73 @@
+import {
+  InstanceTypeDetail,
+  InstanceTypeResource
+} from '../../instances/config/types';
+
+export interface UnitResources {
+  cpu?: string | null;
+  ram?: string | null;
+}
+
+// spec carries user-defined fields only; observed hardware (manufacturer,
+// memory, sliced capability, …) lives on status.detail.
+export interface InstanceTypeSpec {
+  displayName?: string | null;
+  os?: string | null;
+  arch?: string | null;
+  acceleratable?: boolean;
+  acceleratorGroup?: string | null;
+  generalGroup?: string | null;
+  unitResources?: UnitResources | null;
+  localStorage?: string | null;
+}
+
+export interface InstanceTypeStatus {
+  // Observed hardware descriptor; absent until the operator backfills status.
+  detail?: InstanceTypeDetail | null;
+  phase?: string | null;
+  phaseMessage?: string | null;
+  // Per-mode resource accounting ({onceMaxRequest, remaining, capacity}).
+  accelerator?: InstanceTypeResource | null;
+  acceleratorShared?: InstanceTypeResource | null;
+  acceleratorSliced?: InstanceTypeResource | null;
+  cpu?: InstanceTypeResource | null;
+}
+
+// Row shape for the management list (GET /gpu-instance-types).
+export interface ListItem {
+  name: string;
+  spec: InstanceTypeSpec;
+  status?: InstanceTypeStatus;
+}
+
+// Selectable flavor shown in the create drawer's first column
+// (GET /gpu-instance-type-flavors). Its acceleratorGroup / generalGroup /
+// acceleratable are copied into the created instance type.
+export interface FlavorItem {
+  name: string;
+  spec: {
+    manufacturer?: string | null;
+    product?: string | null;
+    family?: string | null;
+    memory?: string | null;
+    cores?: string | null;
+    acceleratable?: boolean;
+    acceleratorGroup?: string | null;
+    generalGroup?: string | null;
+  };
+}
+
+// Body for POST /gpu-instance-types (GPUInstanceTypeCreate).
+export interface FormData {
+  name: string;
+  spec: {
+    displayName?: string | null;
+    acceleratorGroup?: string | null;
+    generalGroup?: string | null;
+    acceleratable?: boolean;
+    os: string;
+    arch?: string | null;
+    unitResources?: UnitResources;
+    localStorage?: string | null;
+  };
+}

src/pages/gpu-service/instance-types/forms/index.tsx

@@ -0,0 +1,327 @@
+import { validateLabelNameRegxFor63 } from '@/config';
+import {
+  Input as CInput,
+  InputNumber,
+  Select as SealSelect,
+  useAppUtils
+} from '@gpustack/core-ui';
+import { useIntl } from '@umijs/max';
+import { Form } from 'antd';
+import { forwardRef, useEffect, useImperativeHandle } from 'react';
+import {
+  FlavorOption,
+  FlavorSelected,
+  getFlavorTitle
+} from '../components/flavor-display';
+import { ArchOptions, GPU_INSTANCE_TYPE_OS } from '../config';
+import { FlavorItem, FormData } from '../config/types';
+import styles from '../styles/instance-types.module.less';
+
+// RAM / storage are entered as a plain number in GB but stored/submitted as a
+// "Gi" quantity string. These drive the FormItem's submit (`normalize`) and
+// display (`getValueProps`) conversions.
+const giNormalize = (value?: number | string | null) =>
+  value ? `${value}Gi` : undefined;
+const giValueProps = (value?: string | null) => ({
+  value: value ? String(value).replace(/Gi$/i, '') : ''
+});
+
+interface InstanceTypeFormProps {
+  ref?: any;
+  open: boolean;
+  // The flavor picked from the flavor Select. Its acceleratorGroup /
+  // generalGroup / acceleratable are copied into the created instance type.
+  selectedFlavor?: FlavorItem | null;
+  flavorList: FlavorItem[];
+  flavorLoading?: boolean;
+  onFlavorChange: (flavor: FlavorItem | null) => void;
+  onFinish: (values: FormData) => Promise<void>;
+  onFinishFailed?: (errorInfo: any) => void;
+}
+
+const GPUServiceInstanceTypeForm: React.FC<InstanceTypeFormProps> = forwardRef(
+  (props, ref) => {
+    const {
+      open,
+      selectedFlavor,
+      flavorList,
+      flavorLoading,
+      onFlavorChange,
+      onFinish,
+      onFinishFailed
+    } = props;
+    const intl = useIntl();
+    const { getRuleMessage } = useAppUtils();
+    const [form] = Form.useForm<FormData>();
+
+    // A non-acceleratable (generic) flavor has no per-GPU concept, so unit CPU
+    // is fixed to 1 and the field is disabled.
+    const acceleratable = !!selectedFlavor?.spec?.acceleratable;
+
+    useEffect(() => {
+      if (!open) {
+        form.resetFields();
+        return;
+      }
+      form.setFieldsValue({
+        spec: {
+          arch: ArchOptions[0].value
+        }
+      } as any);
+    }, [open, form]);
+
+    // Force unit CPU to 1 whenever the picked flavor is not acceleratable.
+    useEffect(() => {
+      if (!open || acceleratable) return;
+      form.setFieldValue(['spec', 'unitResources', 'cpu'], 1);
+    }, [open, acceleratable, form]);
+
+    useImperativeHandle(ref, () => ({
+      submit: () => {
+        form.submit();
+      },
+      resetFields: () => {
+        form.resetFields();
+      }
+    }));
+
+    // Split flavors into two groups: CPU compute (generic) and GPU compute
+    // (accelerator). Groups render as labeled sections in the dropdown.
+    const toFlavorOption = (flavor: FlavorItem) => ({
+      value: flavor.name,
+      label: getFlavorTitle(flavor.spec, flavor.name),
+      flavor
+    });
+    const cpuFlavors = flavorList.filter(
+      (flavor) => !flavor.spec?.acceleratable
+    );
+    const gpuFlavors = flavorList.filter(
+      (flavor) => flavor.spec?.acceleratable
+    );
+    const flavorOptions = [
+      cpuFlavors.length && {
+        label: intl.formatMessage({
+          id: 'gpuservice.instanceType.flavor.cpuGroup'
+        }),
+        title: 'cpu',
+        options: cpuFlavors.map(toFlavorOption)
+      },
+      gpuFlavors.length && {
+        label: intl.formatMessage({
+          id: 'gpuservice.instanceType.flavor.gpuGroup'
+        }),
+        title: 'gpu',
+        options: gpuFlavors.map(toFlavorOption)
+      }
+    ].filter(Boolean) as any;
+
+    const handleFinish = async (values: FormData) => {
+      // The hardware group / acceleratable flags are not user-editable; they
+      // come from the chosen flavor. os is fixed to lowercase "linux". ram /
+      // localStorage already carry the "Gi" suffix from the FormItem normalize.
+      const cpu = values.spec?.unitResources?.cpu;
+      await onFinish({
+        name: values.name,
+        spec: {
+          displayName: values.spec?.displayName?.trim() || null,
+          acceleratorGroup: selectedFlavor?.spec?.acceleratorGroup ?? null,
+          generalGroup: selectedFlavor?.spec?.generalGroup ?? null,
+          acceleratable: selectedFlavor?.spec?.acceleratable ?? false,
+          os: GPU_INSTANCE_TYPE_OS,
+          arch: values.spec?.arch ?? null,
+          unitResources: {
+            cpu: cpu != null && cpu !== '' ? String(cpu) : null,
+            ram: values.spec?.unitResources?.ram ?? null
+          },
+          localStorage: values.spec?.localStorage ?? null
+        }
+      });
+    };
+
+    return (
+      <Form
+        name="gpuServiceInstanceTypeForm"
+        form={form}
+        onFinish={handleFinish}
+        onFinishFailed={onFinishFailed}
+        preserve={false}
+      >
+        <Form.Item<FormData>
+          name="name"
+          rules={[
+            {
+              required: true,
+              message: getRuleMessage('input', 'common.table.name')
+            },
+            {
+              pattern: validateLabelNameRegxFor63,
+              message: intl.formatMessage({ id: 'gpuservice.form.rule.name' })
+            }
+          ]}
+        >
+          <CInput.Input
+            label={intl.formatMessage({ id: 'common.table.name' })}
+            required
+          />
+        </Form.Item>
+
+        <Form.Item<FormData>
+          name={['spec', 'displayName']}
+          rules={[
+            {
+              max: 63,
+              message: intl.formatMessage({
+                id: 'gpuservice.template.displayName.max'
+              })
+            }
+          ]}
+        >
+          <CInput.Input
+            trim={false}
+            label={intl.formatMessage({
+              id: 'gpuservice.template.displayName'
+            })}
+          />
+        </Form.Item>
+
+        <Form.Item>
+          <SealSelect
+            label={intl.formatMessage({ id: 'gpuservice.instanceType.flavor' })}
+            required
+            showSearch
+            optionFilterProp="label"
+            classNames={{ popup: { root: styles.flavorDropdown } }}
+            loading={flavorLoading}
+            value={selectedFlavor?.name}
+            options={flavorOptions}
+            onChange={(val: string) =>
+              onFlavorChange(
+                flavorList.find((flavor) => flavor.name === val) ?? null
+              )
+            }
+            optionRender={(option: any) => {
+              const flavor: FlavorItem = option.data.flavor;
+              return (
+                <FlavorOption spec={flavor.spec} fallbackName={flavor.name} />
+              );
+            }}
+            labelRender={({ value }) => {
+              const flavor = flavorList.find((item) => item.name === value);
+              return flavor ? (
+                <FlavorSelected spec={flavor.spec} fallbackName={flavor.name} />
+              ) : (
+                ((value ?? '') as React.ReactNode)
+              );
+            }}
+          />
+        </Form.Item>
+
+        <Form.Item>
+          <CInput.Input
+            disabled
+            value="Linux"
+            label={intl.formatMessage({ id: 'gpuservice.instance.os' })}
+          />
+        </Form.Item>
+
+        <Form.Item<FormData>
+          name={['spec', 'arch']}
+          rules={[
+            {
+              required: true,
+              message: getRuleMessage('select', 'gpuservice.instance.arch')
+            }
+          ]}
+        >
+          <SealSelect
+            label={intl.formatMessage({ id: 'gpuservice.instance.arch' })}
+            required
+            options={ArchOptions}
+          />
+        </Form.Item>
+
+        <Form.Item<FormData>
+          name={['spec', 'unitResources', 'cpu']}
+          rules={[
+            {
+              required: true,
+              message: getRuleMessage(
+                'input',
+                'gpuservice.instanceType.unitCpu'
+              )
+            }
+          ]}
+        >
+          <InputNumber
+            min={0}
+            disabled={!acceleratable}
+            style={{ width: '100%' }}
+            label={intl.formatMessage({
+              id: 'gpuservice.instanceType.unitCpu'
+            })}
+            description={intl.formatMessage({
+              id: 'gpuservice.instanceType.unitCpu.tip'
+            })}
+            required
+          />
+        </Form.Item>
+
+        <Form.Item<FormData>
+          name={['spec', 'unitResources', 'ram']}
+          normalize={giNormalize}
+          getValueProps={giValueProps}
+          rules={[
+            {
+              required: true,
+              message: getRuleMessage(
+                'input',
+                'gpuservice.instanceType.unitRam'
+              )
+            }
+          ]}
+        >
+          <InputNumber
+            min={0}
+            style={{ width: '100%' }}
+            label={`${intl.formatMessage({
+              id: 'gpuservice.instanceType.unitRam'
+            })} (GB)`}
+            description={intl.formatMessage({
+              id: 'gpuservice.instanceType.unitRam.tip'
+            })}
+            required
+          />
+        </Form.Item>
+
+        <Form.Item<FormData>
+          name={['spec', 'localStorage']}
+          normalize={giNormalize}
+          getValueProps={giValueProps}
+          rules={[
+            {
+              required: true,
+              message: getRuleMessage(
+                'input',
+                'gpuservice.instanceType.localStorage'
+              )
+            }
+          ]}
+        >
+          <InputNumber
+            min={0}
+            style={{ width: '100%' }}
+            label={`${intl.formatMessage({
+              id: 'gpuservice.instanceType.localStorage'
+            })} (GB)`}
+            description={intl.formatMessage({
+              id: 'gpuservice.instanceType.localStorage.tip'
+            })}
+            required
+          />
+        </Form.Item>
+      </Form>
+    );
+  }
+);
+
+export default GPUServiceInstanceTypeForm;

src/pages/gpu-service/instance-types/hooks/use-create-instance-type-modal.ts

@@ -0,0 +1,37 @@
+import useBodyScroll from '@/hooks/use-body-scroll';
+import { useState } from 'react';
+
+const useCreateInstanceTypeModal = () => {
+  const { saveScrollHeight, restoreScrollHeight } = useBodyScroll();
+  const [openModalStatus, setOpenModalStatus] = useState<{
+    open: boolean;
+    title: string;
+  }>({
+    open: false,
+    title: ''
+  });
+
+  const openModal = (title: string) => {
+    setOpenModalStatus({
+      open: true,
+      title
+    });
+    saveScrollHeight();
+  };
+
+  const closeModal = () => {
+    setOpenModalStatus({
+      open: false,
+      title: ''
+    });
+    restoreScrollHeight();
+  };
+
+  return {
+    openInstanceTypeModalStatus: openModalStatus,
+    openInstanceTypeModal: openModal,
+    closeInstanceTypeModal: closeModal
+  };
+};
+
+export default useCreateInstanceTypeModal;

src/pages/gpu-service/instance-types/hooks/use-instance-type-columns.tsx

@@ -0,0 +1,232 @@
+import { QuestionCircleOutlined } from '@ant-design/icons';
+import {
+  AutoTooltip,
+  DropdownButtons,
+  icons,
+  StatusTag
+} from '@gpustack/core-ui';
+import { useIntl } from '@umijs/max';
+import { Space, Tooltip } from 'antd';
+import type { ColumnsType } from 'antd/lib/table';
+import _ from 'lodash';
+import { useMemo } from 'react';
+import { isSliceableDetail } from '../../instances/config';
+import { ceilMilliToCore, parseQuantityToGi } from '../../utils';
+import { FlavorOption } from '../components/flavor-display';
+import {
+  InstanceTypePhaseLabelMap,
+  InstanceTypePhaseValueMap,
+  status as phaseStatusMap
+} from '../config';
+import { ListItem } from '../config/types';
+
+interface ColumnsHookProps {
+  handleSelect: (val: string, record: ListItem) => void;
+}
+
+// DropdownButtons reads `locale` / `props` at runtime; its `items` prop is
+// typed as antd's MenuProps['items'], so cast the config to satisfy it. The
+// activate / deactivate action is chosen from the row's current phase: Active
+// types can be deactivated, Inactive ones activated (none while Preparing).
+const buildRowActions = (record: ListItem) => {
+  const phase = record.status?.phase;
+  const actions: any[] = [];
+  if (phase === InstanceTypePhaseValueMap.Active) {
+    actions.push({
+      label: 'gpuservice.instanceType.deactivate',
+      key: 'deactivate',
+      locale: true,
+      icon: icons.Disabled
+    });
+  } else if (phase === InstanceTypePhaseValueMap.Inactive) {
+    actions.push({
+      label: 'gpuservice.instanceType.activate',
+      key: 'activate',
+      locale: true,
+      icon: icons.Charger
+    });
+  }
+  actions.push({
+    label: 'common.button.delete',
+    key: 'delete',
+    locale: true,
+    icon: icons.DeleteOutlined,
+    props: { danger: true }
+  });
+  return actions;
+};
+
+// Column header with an info tooltip (used for the per-GPU resource columns).
+const TitleWithTip: React.FC<{ title: string; tip: string }> = ({
+  title,
+  tip
+}) => (
+  <Space size={4}>
+    <span>{title}</span>
+    <Tooltip title={tip}>
+      <QuestionCircleOutlined
+        style={{ color: 'var(--ant-color-text-tertiary)' }}
+      />
+    </Tooltip>
+  </Space>
+);
+
+const useInstanceTypeColumns = ({
+  handleSelect
+}: ColumnsHookProps): ColumnsType<ListItem> => {
+  const intl = useIntl();
+
+  return useMemo(() => {
+    return [
+      {
+        title: intl.formatMessage({ id: 'common.table.name' }),
+        dataIndex: 'name',
+        key: 'name',
+        ellipsis: { showTitle: false },
+        // Prefer the friendly display name, fall back to the resource name.
+        render: (text: string, record: ListItem) => {
+          const label = record.spec?.displayName || text;
+          return (
+            <AutoTooltip ghost minWidth={20} maxWidth={200} title={label}>
+              <span className="text-primary">{label || '-'}</span>
+            </AutoTooltip>
+          );
+        }
+      },
+      {
+        // Flavor cell mirrors the create drawer's dropdown: product name on
+        // top, manufacturer · memory · sliceable on the meta line below.
+        // Observed hardware comes from status.detail (absent until the
+        // operator backfills status); sliceable is derived from slicedDetail.
+        title: intl.formatMessage({ id: 'gpuservice.instanceType.flavor' }),
+        dataIndex: ['status', 'detail', 'product'],
+        key: 'product',
+        ellipsis: { showTitle: false },
+        render: (_text: string, record: ListItem) => {
+          const detail = record.status?.detail;
+          return (
+            <FlavorOption
+              spec={{
+                acceleratable: record.spec?.acceleratable,
+                manufacturer: detail?.manufacturer,
+                product: detail?.product,
+                memory: detail?.memory,
+                sliceable: isSliceableDetail(detail?.slicedDetail)
+              }}
+              fallbackName={record.name}
+              maxWidth={200}
+            />
+          );
+        }
+      },
+      {
+        title: (
+          <TitleWithTip
+            title={intl.formatMessage({
+              id: 'gpuservice.instanceType.unitCpu'
+            })}
+            tip={intl.formatMessage({
+              id: 'gpuservice.instanceType.unitCpu.tip'
+            })}
+          />
+        ),
+        dataIndex: ['spec', 'unitResources', 'cpu'],
+        key: 'cpu',
+        ellipsis: { showTitle: false },
+        render: (value: string) => {
+          const cores = ceilMilliToCore(value ?? null)?.cores;
+          return cores != null ? `${cores} vCPU` : '-';
+        }
+      },
+      {
+        title: (
+          <TitleWithTip
+            title={intl.formatMessage({
+              id: 'gpuservice.instanceType.unitRam'
+            })}
+            tip={intl.formatMessage({
+              id: 'gpuservice.instanceType.unitRam.tip'
+            })}
+          />
+        ),
+        dataIndex: ['spec', 'unitResources', 'ram'],
+        key: 'ram',
+        ellipsis: { showTitle: false },
+        render: (value: string) => {
+          const gi = parseQuantityToGi(value ?? null)?.value;
+          return gi != null ? `${gi} GB` : '-';
+        }
+      },
+      {
+        title: (
+          <TitleWithTip
+            title={intl.formatMessage({
+              id: 'gpuservice.instanceType.localStorage'
+            })}
+            tip={intl.formatMessage({
+              id: 'gpuservice.instanceType.localStorage.tip'
+            })}
+          />
+        ),
+        dataIndex: ['spec', 'localStorage'],
+        key: 'localStorage',
+        ellipsis: { showTitle: false },
+        render: (value: string) => {
+          const gi = parseQuantityToGi(value ?? null)?.value;
+          return gi != null ? `${gi} GB` : '-';
+        }
+      },
+      {
+        title: intl.formatMessage({ id: 'gpuservice.instanceType.platform' }),
+        key: 'os',
+        ellipsis: { showTitle: false },
+        render: (_text, record: ListItem) => {
+          const os = _.capitalize(record.spec?.os || '');
+          const arch = _.toUpper(record.spec?.arch || '');
+          if (!os) return '-';
+          return (
+            <AutoTooltip
+              ghost
+              maxWidth={240}
+              title={arch ? `${os}/${arch}` : os}
+            >
+              {arch ? `${os}/${arch}` : os}
+            </AutoTooltip>
+          );
+        }
+      },
+      {
+        title: intl.formatMessage({ id: 'common.table.status' }),
+        dataIndex: ['status', 'phase'],
+        key: 'status',
+        ellipsis: { showTitle: false },
+        render: (value: string, record: ListItem) =>
+          value ? (
+            <StatusTag
+              statusValue={{
+                status: phaseStatusMap[value],
+                text: InstanceTypePhaseLabelMap[value] || value,
+                message: record.status?.phaseMessage || ''
+              }}
+            />
+          ) : (
+            '-'
+          )
+      },
+      {
+        title: intl.formatMessage({ id: 'common.table.operation' }),
+        key: 'operation',
+        dataIndex: 'operation',
+        ellipsis: { showTitle: false },
+        render: (_text, record: ListItem) => (
+          <DropdownButtons
+            items={buildRowActions(record)}
+            onSelect={(val: string) => handleSelect(val, record)}
+          />
+        )
+      }
+    ];
+  }, [handleSelect, intl]);
+};
+
+export default useInstanceTypeColumns;

src/pages/gpu-service/instance-types/index.tsx

@@ -0,0 +1,271 @@
+import { ProviderValueMap } from '@/pages/cluster-management/config';
+import { useQueryClusterList } from '@/pages/cluster-management/services/use-query-cluster-list';
+import {
+  BaseSelect,
+  DeleteModal,
+  FilterBar,
+  IconFont,
+  NoResult
+} from '@gpustack/core-ui';
+import { useIntl } from '@umijs/max';
+import { useMemoizedFn } from 'ahooks';
+import { ConfigProvider, Divider, Flex, Table, message } from 'antd';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import PageBox, { HeaderLeft } from '../../_components/page-box';
+import {
+  activateGPUInstanceType,
+  deactivateGPUInstanceType,
+  deleteGPUInstanceType
+} from './apis';
+import AddInstanceTypeModal from './components/add-instance-type-modal';
+import { FormData, ListItem } from './config/types';
+import useCreateInstanceTypeModal from './hooks/use-create-instance-type-modal';
+import useInstanceTypeColumns from './hooks/use-instance-type-columns';
+import useCreateInstanceType from './services/use-create-instance-type';
+import useQueryInstanceTypes from './services/use-query-instance-types';
+
+const GPUServiceInstanceTypes: React.FC = () => {
+  const intl = useIntl();
+  const deleteModalRef = useRef<any>(null);
+  const [clusterId, setClusterId] = useState<number | undefined>();
+  const [keyword, setKeyword] = useState('');
+  const [loaded, setLoaded] = useState(false);
+
+  const {
+    clusterList,
+    fetchClusterList,
+    loading: clusterLoading
+  } = useQueryClusterList();
+  const {
+    dataList,
+    loading: instanceTypesLoading,
+    fetchInstanceTypes,
+    startWatch
+  } = useQueryInstanceTypes();
+  const { fetchData: createInstanceType } = useCreateInstanceType();
+  const {
+    openInstanceTypeModalStatus,
+    openInstanceTypeModal,
+    closeInstanceTypeModal
+  } = useCreateInstanceTypeModal();
+
+  // Only Kubernetes clusters own GPU instance types.
+  const k8sClusters = useMemo(
+    () => clusterList.filter((c) => c.provider === ProviderValueMap.Kubernetes),
+    [clusterList]
+  );
+
+  // Fetch the visible clusters, default to the first Kubernetes one, then load
+  // its instance types. Action-driven: subsequent loads fire from the cluster
+  // picker / refresh, never from an effect dependency.
+  useEffect(() => {
+    const init = async () => {
+      const items = await fetchClusterList({ page: -1 });
+      const firstK8s = (items || []).find(
+        (c: any) => c.provider === ProviderValueMap.Kubernetes
+      );
+      if (firstK8s?.id != null) {
+        setClusterId(firstK8s.id);
+        await fetchInstanceTypes(firstK8s.id);
+        startWatch(firstK8s.id);
+      }
+      setLoaded(true);
+    };
+    init();
+  }, []);
+
+  const handleClusterChange = useMemoizedFn(async (value: number) => {
+    setClusterId(value);
+    setKeyword('');
+    await fetchInstanceTypes(value);
+    startWatch(value);
+  });
+
+  const handleRefresh = useMemoizedFn(() => {
+    if (clusterId != null) {
+      fetchInstanceTypes(clusterId);
+    }
+  });
+
+  const handleNameChange = useMemoizedFn(
+    (e: React.ChangeEvent<HTMLInputElement>) => {
+      setKeyword(e.target.value);
+    }
+  );
+
+  const handleAdd = useMemoizedFn(() => {
+    openInstanceTypeModal(
+      intl.formatMessage({ id: 'gpuservice.instanceType.add' })
+    );
+  });
+
+  const handleModalOk = useMemoizedFn(async (data: FormData) => {
+    if (clusterId == null) return;
+    try {
+      await createInstanceType({ cluster_id: clusterId, data });
+      closeInstanceTypeModal();
+      message.success(intl.formatMessage({ id: 'common.message.success' }));
+      fetchInstanceTypes(clusterId);
+    } catch (error) {
+      // handled by the request interceptor
+    }
+  });
+
+  const handleDelete = useMemoizedFn((record: ListItem) => {
+    if (clusterId == null) return;
+    deleteModalRef.current?.show({
+      content: intl.formatMessage({ id: 'gpuservice.instanceType' }),
+      operation: 'common.delete.single.confirm',
+      name: record.name,
+      async onOk() {
+        await deleteGPUInstanceType({
+          name: record.name,
+          cluster_id: clusterId
+        });
+        fetchInstanceTypes(clusterId);
+      }
+    });
+  });
+
+  const handleToggleActive = useMemoizedFn(
+    (record: ListItem, activate: boolean) => {
+      if (clusterId == null) return;
+      const action = activate
+        ? activateGPUInstanceType
+        : deactivateGPUInstanceType;
+      deleteModalRef.current?.show({
+        content: intl.formatMessage({ id: 'gpuservice.instanceType' }),
+        title: activate
+          ? 'common.title.activate.confirm'
+          : 'common.title.deactivate.confirm',
+        okText: activate
+          ? 'gpuservice.instanceType.activate'
+          : 'gpuservice.instanceType.deactivate',
+        operation: activate
+          ? 'common.activate.single.confirm'
+          : 'common.deactivate.single.confirm',
+        name: record.spec?.displayName || record.name,
+        async onOk() {
+          await action({ name: record.name, cluster_id: clusterId });
+          message.success(intl.formatMessage({ id: 'common.message.success' }));
+          fetchInstanceTypes(clusterId);
+        }
+      });
+    }
+  );
+
+  const handleSelect = useMemoizedFn((val: string, record: ListItem) => {
+    if (val === 'delete') {
+      handleDelete(record);
+    } else if (val === 'activate') {
+      handleToggleActive(record, true);
+    } else if (val === 'deactivate') {
+      handleToggleActive(record, false);
+    }
+  });
+
+  const columns = useInstanceTypeColumns({ handleSelect });
+
+  const filteredList = useMemo(() => {
+    const trimmed = keyword.trim().toLowerCase();
+    if (!trimmed) return dataList;
+    return dataList.filter((item) => item.name.toLowerCase().includes(trimmed));
+  }, [dataList, keyword]);
+
+  const hasK8sCluster = k8sClusters.length > 0;
+
+  const renderEmpty = (type?: string) => {
+    if (type !== 'Table') return;
+    return (
+      <NoResult
+        loading={instanceTypesLoading || clusterLoading}
+        loadend={loaded}
+        dataSource={filteredList}
+        image={<IconFont type="icon-gpu1" />}
+        filters={keyword ? { search: keyword } : undefined}
+        noFoundText={intl.formatMessage({
+          id: 'noresult.gpuservice.instanceType.nofound'
+        })}
+        title={intl.formatMessage({
+          id: 'noresult.gpuservice.instanceType.title'
+        })}
+        subTitle={
+          hasK8sCluster
+            ? intl.formatMessage({
+                id: 'noresult.gpuservice.instanceType.subTitle'
+              })
+            : intl.formatMessage({ id: 'noresult.resources.k8sCluster' })
+        }
+        {...(hasK8sCluster
+          ? {
+              onClick: handleAdd,
+              buttonText: intl.formatMessage({ id: 'noresult.button.add' })
+            }
+          : {})}
+      />
+    );
+  };
+
+  return (
+    <>
+      <HeaderLeft>
+        <Flex align="center">
+          <span className="font-600">
+            {intl.formatMessage({ id: 'gpuservice.instance.types' })}
+          </span>
+          <Divider orientation="vertical" style={{ margin: '0 16px' }} />
+          <BaseSelect
+            size="small"
+            variant="borderless"
+            style={{ minWidth: 160 }}
+            popupMatchSelectWidth={false}
+            options={k8sClusters}
+            value={clusterId}
+            onChange={handleClusterChange}
+          />
+        </Flex>
+      </HeaderLeft>
+      <PageBox>
+        <FilterBar
+          marginBottom={22}
+          marginTop={30}
+          showSelect={false}
+          inputHolder={intl.formatMessage({
+            id: 'gpuservice.instanceType.filter.name'
+          })}
+          buttonText={intl.formatMessage({
+            id: 'gpuservice.instanceType.add'
+          })}
+          handleSearch={handleRefresh}
+          handleClickPrimary={hasK8sCluster ? handleAdd : undefined}
+          handleInputChange={handleNameChange}
+          widths={{ input: 300 }}
+        />
+        <ConfigProvider renderEmpty={renderEmpty}>
+          <Table
+            columns={columns}
+            dataSource={filteredList}
+            scroll={{ x: 'max-content' }}
+            className={'scroll-table'}
+            loading={{
+              spinning: instanceTypesLoading || clusterLoading,
+              size: 'middle'
+            }}
+            rowKey={(record) => record.name}
+            pagination={false}
+          />
+        </ConfigProvider>
+      </PageBox>
+      <AddInstanceTypeModal
+        open={openInstanceTypeModalStatus.open}
+        title={openInstanceTypeModalStatus.title}
+        clusterId={clusterId}
+        onCancel={closeInstanceTypeModal}
+        onOk={handleModalOk}
+      />
+      <DeleteModal ref={deleteModalRef} />
+    </>
+  );
+};
+
+export default GPUServiceInstanceTypes;

src/pages/gpu-service/instance-types/services/use-create-instance-type.ts

@@ -0,0 +1,35 @@
+import { useQueryData } from '@gpustack/core-ui';
+import { useCallback } from 'react';
+import { createGPUInstanceType } from '../apis';
+import { FormData, ListItem } from '../config/types';
+
+interface CreateInstanceTypeParams {
+  cluster_id: number;
+  data: FormData;
+}
+
+export default function useCreateInstanceType() {
+  const fetchDetail = useCallback(
+    (params: CreateInstanceTypeParams) =>
+      createGPUInstanceType({
+        cluster_id: params.cluster_id,
+        data: params.data
+      }),
+    []
+  );
+
+  const { detailData, loading, cancelRequest, fetchData } = useQueryData<
+    ListItem,
+    CreateInstanceTypeParams
+  >({
+    fetchDetail,
+    key: 'createInstanceType'
+  });
+
+  return {
+    detailData,
+    loading,
+    cancelRequest,
+    fetchData
+  };
+}

src/pages/gpu-service/instance-types/services/use-query-flavors.ts

@@ -0,0 +1,58 @@
+import { createAxiosToken } from '@/hooks/use-chunk-request';
+import { useRequest } from 'ahooks';
+import { CancelTokenSource } from 'axios';
+import { useEffect, useRef, useState } from 'react';
+import { queryGPUInstanceTypeFlavors } from '../apis';
+import { FlavorItem } from '../config/types';
+
+// Cluster-scoped flavors for the create drawer's first column. Fetched when
+// the drawer opens (and on cluster change), never via an effect dependency.
+export default function useQueryFlavors() {
+  const tokenRef = useRef<CancelTokenSource | null>(null);
+  const [dataList, setDataList] = useState<FlavorItem[]>([]);
+
+  const {
+    runAsync: fetchFlavors,
+    loading,
+    cancel
+  } = useRequest(
+    async (clusterId: number) => {
+      tokenRef.current?.cancel();
+      tokenRef.current = createAxiosToken();
+      const res = await queryGPUInstanceTypeFlavors(
+        { cluster_id: clusterId },
+        { token: tokenRef.current.token }
+      );
+      const list = res?.items || [];
+      setDataList(list);
+      return list;
+    },
+    {
+      manual: true,
+      onError: (error: any) => {
+        if (error?.message === 'CANCEL_PREVIOUS_REQUEST') return;
+        setDataList([]);
+      }
+    }
+  );
+
+  const cancelRequest = () => {
+    cancel();
+    tokenRef.current?.cancel('CANCEL_PREVIOUS_REQUEST');
+  };
+
+  useEffect(() => {
+    return () => {
+      cancel();
+      tokenRef.current?.cancel();
+    };
+  }, []);
+
+  return {
+    dataList,
+    loading,
+    fetchFlavors,
+    cancelRequest,
+    setDataList
+  };
+}

src/pages/gpu-service/instance-types/services/use-query-instance-types.ts

@@ -0,0 +1,113 @@
+import { WatchEventType } from '@/config';
+import useSetChunkRequest, {
+  createAxiosToken
+} from '@/hooks/use-chunk-request';
+import { useRequest } from 'ahooks';
+import { CancelTokenSource } from 'axios';
+import qs from 'query-string';
+import { useEffect, useRef, useState } from 'react';
+import { GPU_INSTANCE_TYPES_API, queryGPUInstanceTypes } from '../apis';
+import { ListItem } from '../config/types';
+
+// Merge a batch of watch events into the current name-keyed list. Instance
+// types have no numeric id, so we upsert / remove by `name` rather than reuse
+// the shared id-based chunked-list helper.
+const mergeWatchEvents = (current: ListItem[], events: any[]) => {
+  let list = [...current];
+  events.forEach((event: any) => {
+    const collection: ListItem[] = event?.collection || [];
+    if (event?.type === WatchEventType.DELETE) {
+      const names = collection.map((item) => item.name);
+      list = list.filter((item) => !names.includes(item.name));
+    } else if (
+      event?.type === WatchEventType.CREATE ||
+      event?.type === WatchEventType.UPDATE
+    ) {
+      collection.forEach((item) => {
+        const index = list.findIndex((it) => it.name === item.name);
+        if (index > -1) {
+          list[index] = item;
+        } else {
+          list = [item, ...list];
+        }
+      });
+    }
+  });
+  return list;
+};
+
+// Cluster-scoped instance types for the management list. Action-driven:
+// call fetchInstanceTypes(clusterId) from the cluster picker / refresh, not
+// via an effect dependency. startWatch(clusterId) opens a chunked watch that
+// keeps the list in sync with live create/update/delete events.
+export default function useQueryInstanceTypes() {
+  const tokenRef = useRef<CancelTokenSource | null>(null);
+  const chunkRequestRef = useRef<any>(null);
+  const { setChunkRequest } = useSetChunkRequest();
+  const [dataList, setDataList] = useState<ListItem[]>([]);
+
+  const {
+    runAsync: fetchInstanceTypes,
+    loading,
+    cancel
+  } = useRequest(
+    async (clusterId: number) => {
+      tokenRef.current?.cancel();
+      tokenRef.current = createAxiosToken();
+      const res = await queryGPUInstanceTypes(
+        { cluster_id: clusterId },
+        { token: tokenRef.current.token }
+      );
+      const list = res?.items || [];
+      setDataList(list);
+      return list;
+    },
+    {
+      manual: true,
+      onError: (error: any) => {
+        // Ignore the synthetic cancel error from switching clusters quickly.
+        if (error?.message === 'CANCEL_PREVIOUS_REQUEST') return;
+        setDataList([]);
+      }
+    }
+  );
+
+  const cancelRequest = () => {
+    cancel();
+    tokenRef.current?.cancel('CANCEL_PREVIOUS_REQUEST');
+  };
+
+  const stopWatch = () => {
+    chunkRequestRef.current?.current?.cancel?.();
+  };
+
+  const startWatch = (clusterId: number) => {
+    stopWatch();
+    chunkRequestRef.current = setChunkRequest({
+      url: `${GPU_INSTANCE_TYPES_API}?${qs.stringify({
+        cluster_id: clusterId
+      })}`,
+      handler: (events: any[]) => {
+        setDataList((pre) => mergeWatchEvents(pre, events));
+      }
+    });
+  };
+
+  useEffect(() => {
+    return () => {
+      cancel();
+      tokenRef.current?.cancel();
+      stopWatch();
+    };
+  }, []);
+
+  return {
+    dataList,
+    loading,
+    fetchInstanceTypes,
+    cancelRequest,
+    startWatch,
+    stopWatch,
+    setDataList
+  };
+}

src/pages/gpu-service/instance-types/styles/instance-types.module.less

@@ -0,0 +1,168 @@
+// ============ create drawer (two-column: flavors | form) ============
+.container {
+  display: flex;
+  height: 100%;
+  min-height: 0;
+}
+
+.colWrapper {
+  display: flex;
+  flex: 1;
+  min-width: 0;
+  min-height: 0;
+}
+
+.formWrapper {
+  display: flex;
+  flex: 1;
+  min-width: 0;
+  min-height: 0;
+}
+
+.panelBody {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+  height: 100%;
+  min-height: 0;
+}
+
+.stickyHead {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+  position: sticky;
+  top: 0;
+  z-index: 10;
+  background-color: var(--ant-color-bg-elevated);
+}
+
+.flavorCard {
+  height: auto !important;
+  min-height: 96px;
+}
+
+// ============ flavor select dropdown ============
+.flavorDropdown {
+  :global {
+    // tighten the indent of grouped options
+    .ant-select-item-option-grouped {
+      padding-inline-start: 12px;
+    }
+    // divider between options
+    .ant-select-item-option {
+      border-block-end: 1px solid var(--ant-color-border-secondary);
+
+      &:last-child {
+        border-block-end: none;
+      }
+    }
+  }
+}
+
+// ============ list card (Linear-style, minimal) ============
+.listCard {
+  height: auto !important;
+}
+
+.card {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+}
+
+// --- level 1: identity + status + actions ---
+.header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  min-width: 0;
+  width: 100%;
+}
+
+.name {
+  min-width: 0;
+  font-size: 13px;
+  color: var(--ant-color-text-tertiary);
+}
+
+.headerRight {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex-shrink: 0;
+}
+
+// --- level 2: hero (model + memory) ---
+.hero {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 12px;
+  margin-top: 18px;
+}
+
+.product {
+  min-width: 0;
+  font-size: 14px;
+  font-weight: 500;
+  line-height: 1.4;
+  color: var(--ant-color-text);
+}
+
+.memory {
+  flex-shrink: 0;
+  font-size: 14px;
+  font-weight: 500;
+  line-height: 1.4;
+  color: var(--ant-color-text);
+}
+
+.subline {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-top: 8px;
+  min-height: 22px;
+  font-size: 13px;
+  color: var(--ant-color-text-tertiary);
+}
+
+.tag {
+  display: inline-flex;
+  align-items: center;
+  height: 22px;
+  padding: 0 8px;
+  border-radius: var(--ant-border-radius-sm);
+  font-size: 12px;
+  line-height: 1;
+}
+
+.tagSliceable {
+  color: var(--ant-color-primary);
+  background-color: var(--ant-color-primary-bg);
+}
+
+.tagPlain {
+  color: var(--ant-color-text-tertiary);
+  background-color: var(--ant-color-fill-tertiary);
+}
+
+// --- level 3: base resources ---
+.divider {
+  height: 1px;
+  margin: 16px 0;
+  background-color: var(--ant-color-border-secondary);
+  opacity: 0.6;
+}
+
+.footer {
+  font-size: 14px;
+  color: var(--ant-color-text-tertiary);
+}
+
+.dotSep {
+  margin: 0 8px;
+  color: var(--ant-color-text-quaternary);
+}

src/pages/gpu-service/instances/apis/index.ts

@@ -12,7 +12,7 @@ import {
 
 export const GPU_SERVICE_INSTANCES_API = '/gpu-instances';
 
-export const GPU_SERVICE_INSTANCES_TYPE_API = '/gpu-instance-types';
+export const GPU_SERVICE_INSTANCES_TYPE_API = '/gpu-instance-types/aggregated';
 
 // View logs / events still go through the K8s proxy until the /v2
 // /gpu-instances API exposes equivalents. clusterID and namespace come

src/pages/gpu-service/instances/components/add-modal.tsx

@@ -5,23 +5,19 @@ import useUserDirectory from '@/pages/gpu-service/hooks/use-user-directory';
 import Separator from '@/pages/llmodels/components/separator';
 import { getGPUStackPlugin } from '@/plugins';
 import { SearchOutlined } from '@ant-design/icons';
-import {
+import { ColumnWrapper, GSDrawer, ModalFooter } from '@gpustack/core-ui';
-  AlertBlockInfo,
-  ColumnWrapper,
-  GSDrawer,
-  ModalFooter
-} from '@gpustack/core-ui';
 import { useIntl, useModel } from '@umijs/max';
 import { Input, Typography } from 'antd';
-import _ from 'lodash';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { ListItem as TemplateItem } from '../../templates/config/types';
 import useQueryTemplates from '../../templates/services/use-query-templates';
+import { InstanceStatusValueMap } from '../config';
 import { FormData, InstanceTypeItem, ListItem } from '../config/types';
 import GPUServiceInstanceForm from '../forms';
 import TemplateSelector, { TemplateGroup } from '../forms/template-selector';
 import useQueryInstanceTypes from '../services/use-query-instance-types';
 import styles from '../styles/instances.module.less';
+import { saveInstanceDataInDescription } from '../utils/instance-description';
 import InstanceTypeList from './instance-type-list';
 
 type AddModalProps = {
@@ -29,7 +25,6 @@ type AddModalProps = {
   action: PageActionType;
   open: boolean;
   width?: number | string;
-  realAction?: string;
   clusterList?: Array<{
     label: string;
     value: number;
@@ -83,8 +78,7 @@ const AddModal: React.FC<AddModalProps> = ({
   data,
   onCancel,
   width,
-  clusterList = [],
+  clusterList = []
-  realAction
 }) => {
   const intl = useIntl();
   const { initialState } = useModel('@@initialState') || {};
@@ -103,6 +97,12 @@ const AddModal: React.FC<AddModalProps> = ({
     manufacturer: undefined
   });
   const [templateId, setTemplateId] = useState<number | undefined>();
+  // Re-selected instance type on a stopped-instance edit. Kept separate from
+  // `instanceTypeSelection` (the create card selection) so the two flows don't
+  // couple; starts empty each open (no default highlight).
+  const [editSelectedType, setEditSelectedType] = useState<string | undefined>(
+    undefined
+  );
   const [instanceKeyword, setInstanceKeyword] = useState('');
   const [templateKeyword, setTemplateKeyword] = useState('');
   const { loading, guard, run, release } = useSubmitLock();
@@ -166,9 +166,18 @@ const AddModal: React.FC<AddModalProps> = ({
   );
   // const readonly = action === PageAction.VIEW;
   const readonly = false;
-  const isRecreate = realAction === PageAction.CREATE;
+  const showResourceSelectors = action === PageAction.CREATE;
-  const showResourceSelectors = action === PageAction.CREATE || isRecreate;
+  // Only a stopped instance can be re-typed on edit. It shows the instance-type
-  const shouldAutoSelectResource = action === PageAction.CREATE && !isRecreate;
+  // column (but not the template column) beside the form; the create card
+  // columns render for CREATE.
+  const isStoppedEdit =
+    action === PageAction.EDIT &&
+    data?.status?.phase === InstanceStatusValueMap.Stopped;
+  const showInstanceTypeColumn = showResourceSelectors || isStoppedEdit;
+  // Editing a non-stopped instance is restricted: only displayName and the
+  // SSH public keys stay editable; the type / template / storage sections
+  // render disabled. A stopped instance edits everything.
+  const isRestrictedEdit = action === PageAction.EDIT && !isStoppedEdit;
 
   const findTemplateByManufacturer = (
     manufacturer: string | undefined,
@@ -179,24 +188,13 @@ const AddModal: React.FC<AddModalProps> = ({
       : undefined;
   };
 
-  const saveInstanceDataInDescription = (instanceType: InstanceTypeItem) => {
+  // GPU types carry their accelerator vendor on status.detail (observed — may
-    return JSON.stringify({
+  // be absent until the operator backfills status); non-acceleratable (CPU)
-      name: instanceType.name,
+  // types all map to the single 'cpu' bucket used to match templates.
-      spec: {
-        ..._.omit(instanceType.spec, ['cache', 'cpu']),
-        cpu: _.pick(instanceType.spec?.cpu, [
-          'manufacturer',
-          'product',
-          'family'
-        ])
-      }
-    });
-  };
-
-  // GPU types carry their accelerator vendor; non-acceleratable (CPU) types
-  // all map to the single 'cpu' bucket used to match templates.
   const manufacturerOf = (instanceType: InstanceTypeItem) =>
-    instanceType.spec.acceleratable ? instanceType.spec?.manufacturer : 'cpu';
+    instanceType.spec.acceleratable
+      ? (instanceType.status?.detail?.manufacturer ?? undefined)
+      : 'cpu';
 
   // apply the selection of instance type and template
   const applySelection = (
@@ -263,43 +261,12 @@ const AddModal: React.FC<AddModalProps> = ({
     );
   };
 
-  const findAggregateOf = (
-    candidateName: string | undefined,
-    clusterId: number | null | undefined,
-    instanceTypes: InstanceTypeItem[]
-  ): InstanceTypeItem | undefined => {
-    if (!candidateName) return undefined;
-    return instanceTypes.find((item) =>
-      (item.status?.tiers ?? []).some((tier) =>
-        (tier.candidates ?? []).some(
-          (c) => c.name === candidateName && Number(c.cluster) === clusterId
-        )
-      )
-    );
-  };
-
   // initial for first
   const applyAutoSelection = (
     instanceTypes: InstanceTypeItem[],
     templates: TemplateItem[],
     orgId?: number | null
   ) => {
-    // On edit / view, surface the persisted selection in the card list.
-    if (!shouldAutoSelectResource) {
-      const aggregate = findAggregateOf(
-        data?.spec?.type,
-        data?.clusterId,
-        instanceTypes
-      );
-      if (aggregate) {
-        setInstanceTypeSelection({
-          instanceType: aggregate.name,
-          manufacturer: manufacturerOf(aggregate)
-        });
-      }
-      return;
-    }
-
     // Scope to clusters the chosen org owns (admin "All" view).
     const owned = filterTypesByOwner(instanceTypes, orgId);
 
@@ -359,6 +326,7 @@ const AddModal: React.FC<AddModalProps> = ({
         manufacturer: undefined
       });
       setTemplateId(undefined);
+      setEditSelectedType(undefined);
       setInstanceKeyword('');
       setTemplateKeyword('');
       setScopeOrgId(undefined);
@@ -367,8 +335,12 @@ const AddModal: React.FC<AddModalProps> = ({
 
     if (action === PageAction.CREATE) {
       loadCreateResources();
+    } else if (action === PageAction.EDIT) {
+      // Edit has no card columns, but the change-type overlay still needs the
+      // full instance-type list to re-type a stopped instance.
+      fetchData({ page: -1 });
     }
-  }, [open, shouldAutoSelectResource, action]);
+  }, [open, action]);
 
   // filter instance types (already scoped to the chosen org's clusters)
   const filteredInstanceTypes = ownedInstanceTypes.filter((item) =>
@@ -506,6 +478,17 @@ const AddModal: React.FC<AddModalProps> = ({
     applySelection(item, template);
   };
 
+  // Stopped-edit re-type. Decoupled from applySelection (the create flow): it
+  // only snapshots the type into `description` and applies it to the form — no
+  // template selection or filtering.
+  const handleEditInstanceTypeChange = (item: InstanceTypeItem) => {
+    setEditSelectedType(item.name);
+    form.current?.setFieldsValue({
+      description: saveInstanceDataInDescription(item)
+    });
+    form.current?.applyInstanceType?.(item);
+  };
+
   const handleTemplateChange = (id: number, item: TemplateItem) => {
     setTemplateId(id);
     const formValues = form.current?.getFieldsValue();
@@ -543,104 +526,108 @@ const AddModal: React.FC<AddModalProps> = ({
       footer={false}
     >
       <div className={styles.container}>
+        {showInstanceTypeColumn && (
+          <div
+            className={styles.colWrapper}
+            // The 33% cap suits the 3-column create layout; in the 2-column
+            // stopped-edit layout, split the space evenly with the form column.
+            style={isStoppedEdit ? { flex: 1, maxWidth: 'none' } : undefined}
+          >
+            <ColumnWrapper styles={{ container: { paddingBlock: 0 } }}>
+              <div className={styles.panelBody}>
+                <div
+                  style={{
+                    display: 'flex',
+                    flexDirection: 'column',
+                    gap: 16,
+                    position: 'sticky',
+                    top: 0,
+                    zIndex: 10,
+                    backgroundColor: 'var(--ant-color-bg-elevated)'
+                  }}
+                >
+                  <ColTitle style={{ paddingBottom: 0 }}>
+                    {intl.formatMessage({
+                      id: 'gpuservice.instance.types'
+                    })}
+                  </ColTitle>
+                  <Input
+                    allowClear
+                    prefix={<SearchOutlined className="text-tertiary" />}
+                    placeholder={intl.formatMessage({
+                      id: 'gpuservice.instance.search.type.placeholder'
+                    })}
+                    value={instanceKeyword}
+                    onChange={(e) => setInstanceKeyword(e.target.value)}
+                  />
+                </div>
+                <InstanceTypeList
+                  // Edit (stopped) re-selection is decoupled from create's
+                  // card selection: separate highlight state + apply handler.
+                  value={
+                    isStoppedEdit
+                      ? editSelectedType
+                      : instanceTypeSelection.instanceType
+                  }
+                  dataList={filteredInstanceTypes}
+                  loading={instanceTypesLoading}
+                  onChange={
+                    isStoppedEdit
+                      ? handleEditInstanceTypeChange
+                      : handleInstanceTypeChange
+                  }
+                />
+              </div>
+            </ColumnWrapper>
+            <Separator></Separator>
+          </div>
+        )}
         {showResourceSelectors && (
-          <>
+          <div className={styles.colWrapper}>
-            <div className={styles.colWrapper}>
+            <ColumnWrapper styles={{ container: { paddingBlock: 0 } }}>
-              <ColumnWrapper styles={{ container: { paddingBlock: 0 } }}>
+              <div className={styles.panelBody}>
-                <div className={styles.panelBody}>
+                <div
-                  <div
+                  style={{
-                    style={{
+                    display: 'flex',
-                      display: 'flex',
+                    flexDirection: 'column',
-                      flexDirection: 'column',
+                    gap: 16,
-                      gap: 16,
+                    position: 'sticky',
-                      position: 'sticky',
+                    top: 0,
-                      top: 0,
+                    zIndex: 10,
-                      zIndex: 10,
+                    backgroundColor: 'var(--ant-color-bg-elevated)'
-                      backgroundColor: 'var(--ant-color-bg-elevated)'
+                  }}
-                    }}
+                >
-                  >
+                  <ColTitle style={{ paddingBottom: 0 }}>
-                    <ColTitle style={{ paddingBottom: 0 }}>
+                    {intl.formatMessage({
-                      {intl.formatMessage({
+                      id: 'gpuservice.instance.templates'
-                        id: 'gpuservice.instance.types'
+                    })}
-                      })}
+                  </ColTitle>
-                    </ColTitle>
+                  <Input
-                    <Input
+                    allowClear
-                      allowClear
+                    prefix={<SearchOutlined className="text-tertiary" />}
-                      prefix={<SearchOutlined className="text-tertiary" />}
+                    placeholder={intl.formatMessage({
-                      placeholder={intl.formatMessage({
+                      id: 'gpuservice.instance.search.template.placeholder'
-                        id: 'gpuservice.instance.search.type.placeholder'
+                    })}
-                      })}
+                    value={templateKeyword}
-                      value={instanceKeyword}
+                    onChange={(e) => setTemplateKeyword(e.target.value)}
-                      onChange={(e) => setInstanceKeyword(e.target.value)}
-                    />
-                  </div>
-                  <InstanceTypeList
-                    value={instanceTypeSelection.instanceType}
-                    dataList={filteredInstanceTypes}
-                    loading={instanceTypesLoading}
-                    onChange={handleInstanceTypeChange}
                   />
                 </div>
-              </ColumnWrapper>
+                <TemplateSelector
-              <Separator></Separator>
+                  value={templateId}
-            </div>
+                  loading={templateLoading || !initialized}
-            <div className={styles.colWrapper}>
+                  groups={templateGroups}
-              <ColumnWrapper styles={{ container: { paddingBlock: 0 } }}>
+                  onChange={handleTemplateChange}
-                <div className={styles.panelBody}>
+                />
-                  <div
+              </div>
-                    style={{
+            </ColumnWrapper>
-                      display: 'flex',
+            <Separator></Separator>
-                      flexDirection: 'column',
+          </div>
-                      gap: 16,
-                      position: 'sticky',
-                      top: 0,
-                      zIndex: 10,
-                      backgroundColor: 'var(--ant-color-bg-elevated)'
-                    }}
-                  >
-                    <ColTitle style={{ paddingBottom: 0 }}>
-                      {intl.formatMessage({
-                        id: 'gpuservice.instance.templates'
-                      })}
-                    </ColTitle>
-                    <Input
-                      allowClear
-                      prefix={<SearchOutlined className="text-tertiary" />}
-                      placeholder={intl.formatMessage({
-                        id: 'gpuservice.instance.search.template.placeholder'
-                      })}
-                      value={templateKeyword}
-                      onChange={(e) => setTemplateKeyword(e.target.value)}
-                    />
-                  </div>
-                  <TemplateSelector
-                    value={templateId}
-                    loading={templateLoading || !initialized}
-                    groups={templateGroups}
-                    onChange={handleTemplateChange}
-                  />
-                </div>
-              </ColumnWrapper>
-              <Separator></Separator>
-            </div>
-          </>
         )}
         <div className={styles.formWrapper}>
           <ColumnWrapper
             styles={{ container: { paddingBlock: 0 } }}
             footer={
               <>
-                {isRecreate && open && (
-                  <div style={{ marginInline: 24, paddingTop: 8 }}>
-                    <AlertBlockInfo
-                      type="warning"
-                      contentStyle={{ paddingInline: 0 }}
-                      message={intl.formatMessage({
-                        id: 'gpuservice.instance.recreate.confirm.content'
-                      })}
-                    />
-                  </div>
-                )}
                 <ModalFooter
                   onOk={handleSubmit}
                   onCancel={handleCancel}
@@ -664,9 +651,9 @@ const AddModal: React.FC<AddModalProps> = ({
               <GPUServiceInstanceForm
                 ref={form}
                 action={action}
-                realAction={realAction}
                 currentData={data}
                 disabled={readonly}
+                restrictedEdit={isRestrictedEdit}
                 onFinish={onFinish}
                 onFinishFailed={release}
                 onScopeChange={handleScopeChange}

src/pages/gpu-service/instances/components/instance-type-item.tsx

@@ -5,10 +5,13 @@ import { Flex, Tag } from 'antd';
 import _ from 'lodash';
 import styled from 'styled-components';
 import { manufactureColorMap } from '../../templates/config';
+import { formatManufacturer } from '../../utils';
 import { formatMemoryDisplay } from '../config';
-import { InstanceTypeItem as InstanceTypeItemModel } from '../config/types';
+import {
-
+  InstanceTypeItem as InstanceTypeItemModel,
-const Vendors = ['intel'] as const;
+  InstanceTypeSnapshotSpec
+} from '../config/types';
+import { buildInstanceTypeSnapshotSpec } from '../utils/instance-description';
 
 const Title = styled.div`
   display: flex;
@@ -55,10 +58,17 @@ const Meta = styled.div<{ $columns?: number }>`
 
 interface InstanceTypeItemProps {
   item: InstanceTypeItemModel;
+  action?: React.ReactNode;
 }
 
 interface MetadataSectionProps {
-  spec: InstanceTypeItemModel['spec'];
+  // The flat snapshot / display model — built from a live item with
+  // buildInstanceTypeSnapshotSpec, or parsed back from a persisted
+  // `description` snapshot (readonly edit card).
+  spec: InstanceTypeSnapshotSpec;
+  // status.onceMaxRequest.acceleratorSliced (max sliceable percentage). Shown
+  // next to Max for sliceable types.
+  slicedMaxPercentage?: number;
 }
 
 const MetaItem: React.FC<{
@@ -101,8 +111,14 @@ const CPUManufacturerTag: React.FC<{ manufacturer?: string }> = ({
   );
 };
 
-function getInstanceDerived(item: InstanceTypeItemModel) {
+// Derives the display fields from the flat snapshot spec (the UI document
-  const spec = item.spec || {};
+// format — built from a live item with buildInstanceTypeSnapshotSpec, or
+// parsed back from a persisted `description` snapshot). Observed hardware
+// (manufacturer / product / memory / cpu) originates from status.detail.
+function getInstanceDerived(
+  spec: InstanceTypeSnapshotSpec = {},
+  fallbackName?: string
+) {
   const acceleratable = spec.acceleratable;
 
   const cpuManufacturer = acceleratable
@@ -113,122 +129,113 @@ function getInstanceDerived(item: InstanceTypeItemModel) {
     acceleratable,
     isGPU: acceleratable,
     manufacturer: acceleratable ? spec.manufacturer || '' : 'cpu', // GPU manufacturer or 'cpu' for non-acceleratable types
-    displayName: acceleratable ? spec.product || item.name : 'CPU Only',
+    displayName: acceleratable
+      ? spec.displayName || spec.product || fallbackName
+      : spec.displayName || 'CPU-only',
     ramUnit: spec.unitResourcesParsed?.ram?.value,
     os: _.capitalize(spec.os) || '',
     arch: spec.arch,
-    cpuManufacturer: Vendors.includes(cpuManufacturer as any)
+    cpuManufacturer: formatManufacturer(cpuManufacturer),
-      ? _.capitalize(cpuManufacturer)
-      : _.toUpper(cpuManufacturer),
     cpuUnitCores: spec.unitResourcesParsed?.cpu?.cores
   };
 }
 
+type MetaEntry = { icon: string; label?: string; value: React.ReactNode };
+
+// All rows share a single grid so columns — and therefore icons — line up
+// vertically. Each item is 3 cells (icon/label/value); every item past the
+// first adds a leading dot cell, so a row of k items spans 4k-1 cells. A short
+// row is padded with a spanning spacer so the next row restarts at column 1.
+const renderMetaRow = (items: MetaEntry[], columns: number, rowKey: string) => {
+  const cells = items.map((item, index) => (
+    <MetaItem
+      key={`${rowKey}-${item.icon}`}
+      showDot={index > 0}
+      icon={item.icon}
+      label={item.label}
+      value={item.value}
+    />
+  ));
+  const remaining = columns - (4 * items.length - 1);
+  if (remaining > 0) {
+    cells.push(
+      <span
+        key={`${rowKey}-spacer`}
+        style={{ gridColumn: `span ${remaining}` }}
+      />
+    );
+  }
+  return cells;
+};
+
 export const InstanceMetadataSection: React.FC<MetadataSectionProps> = ({
-  spec
+  spec,
+  slicedMaxPercentage
 }) => {
   const intl = useIntl();
 
-  const { ramUnit, cpuUnitCores, isGPU, os, arch } = getInstanceDerived({
+  const { ramUnit, cpuUnitCores, isGPU, arch } = getInstanceDerived(spec);
-    spec
+
-  } as InstanceTypeItemModel);
+  // Sliceable types append a "Sliceable {n}%" cell to the second row.
+  const showSliceable = !!spec.sliceable && (slicedMaxPercentage ?? 0) > 0;
+
+  const cpuItem: MetaEntry = {
+    icon: 'icon-cpu',
+    label: 'CPU',
+    value: cpuUnitCores || '-'
+  };
+  const ramItem: MetaEntry = {
+    icon: 'icon-ram-02',
+    label: intl.formatMessage({ id: 'gpuservice.instance.ram' }),
+    value: ramUnit ? `${ramUnit} GB` : '-'
+  };
+  const memoryItem: MetaEntry = {
+    icon: 'icon-gpu1',
+    label: intl.formatMessage({ id: 'gpuservice.instance.memory' }),
+    value: formatMemoryDisplay(spec?.memory ?? undefined) ?? '-'
+  };
+  const archItem: MetaEntry = {
+    icon: 'icon-cube',
+    label: intl.formatMessage({ id: 'gpuservice.instance.arch' }),
+    value: _.toUpper(arch) || '-'
+  };
+  const maxItem: MetaEntry = {
+    icon: 'icon-database',
+    label: intl.formatMessage({ id: 'common.max' }, { count: '' }),
+    value: `${spec.maxComputeUnitCount || 0}`
+  };
+  const slicedItem: MetaEntry = {
+    icon: 'icon-sliced',
+    label: intl.formatMessage({ id: 'gpuservice.instance.sliceable' }),
+    value: `${slicedMaxPercentage}%`
+  };
+
+  // GPU: 3 items/row → 11 cols. CPU: 2 items/row → 7 cols.
+  const columns = isGPU ? 11 : 7;
+  const rows: MetaEntry[][] = isGPU
+    ? [
+        [ramItem, memoryItem, cpuItem],
+        showSliceable ? [archItem, maxItem, slicedItem] : [archItem, maxItem]
+      ]
+    : [[ramItem], [archItem, maxItem]];
 
   return (
-    <Meta $columns={isGPU ? 11 : 7}>
+    <Meta $columns={columns}>
-      {isGPU && (
+      {rows.map((row, index) => renderMetaRow(row, columns, `row-${index}`))}
-        <>
-          {/* row 1: Memory | Max | RAM */}
-          <MetaItem
-            show={isGPU}
-            showDot={false}
-            icon="icon-gpu1"
-            label={intl.formatMessage({ id: 'gpuservice.instance.memory' })}
-            value={formatMemoryDisplay(spec?.memory ?? undefined) ?? '-'}
-          />
-          <MetaItem
-            showDot={true}
-            icon="icon-ram-02"
-            label={intl.formatMessage({ id: 'gpuservice.instance.ram' })}
-            value={ramUnit ? `${ramUnit} GB` : '-'}
-          />
-          <MetaItem
-            icon="icon-database"
-            label={intl.formatMessage(
-              {
-                id: 'common.max'
-              },
-              { count: '' }
-            )}
-            value={`${spec.maxComputeUnitCount || 0}`}
-          />
-          {/* row 2: OS | Arch | CPU */}
-          <MetaItem
-            showDot={false}
-            icon="icon-server02"
-            label={intl.formatMessage({ id: 'gpuservice.instance.os' })}
-            value={os || '-'}
-          />
-          <MetaItem
-            icon="icon-cube"
-            label={intl.formatMessage({ id: 'gpuservice.instance.arch' })}
-            value={_.toUpper(arch) || '-'}
-          />
-          <MetaItem
-            show={isGPU}
-            showDot={true}
-            icon="icon-cpu"
-            label="CPU"
-            value={
-              <Flex gap={4} align="center">
-                <span>{cpuUnitCores || '-'}</span>
-              </Flex>
-            }
-          />
-        </>
-      )}
-
-      {!isGPU && (
-        <>
-          {/* row 1: RAM | Max */}
-          <MetaItem
-            showDot={false}
-            icon="icon-ram-02"
-            label={intl.formatMessage({ id: 'gpuservice.instance.ram' })}
-            value={ramUnit ? `${ramUnit} GB` : '-'}
-          />
-          <MetaItem
-            icon="icon-database"
-            label={intl.formatMessage(
-              {
-                id: 'common.max'
-              },
-              { count: '' }
-            )}
-            value={`${spec.maxComputeUnitCount || 0}`}
-          />
-          {/* row 2: OS | Arch */}
-          <MetaItem
-            showDot={false}
-            icon="icon-server02"
-            label={intl.formatMessage({ id: 'gpuservice.instance.os' })}
-            value={os || '-'}
-          />
-          <MetaItem
-            icon="icon-cube"
-            label={intl.formatMessage({ id: 'gpuservice.instance.arch' })}
-            value={_.toUpper(arch) || '-'}
-          />
-        </>
-      )}
     </Meta>
   );
 };
 
-const InstanceTypeItem: React.FC<InstanceTypeItemProps> = ({ item }) => {
+const InstanceTypeItem: React.FC<InstanceTypeItemProps> = ({
-  const specData = item.spec || {};
+  item,
+  action
+}) => {
+  // Fold the live (API-shaped) item into the flat display model: definition
+  // fields from spec, observed hardware from status.detail.
+  const specData = buildInstanceTypeSnapshotSpec(item);
 
   const { acceleratable, manufacturer, displayName, cpuManufacturer } =
-    getInstanceDerived(item);
+    getInstanceDerived(specData, item.name);
 
   const manufacturerColor = manufactureColorMap[manufacturer] ?? 'purple';
   const showManufacturerTag = acceleratable && !!manufacturer;
@@ -260,7 +267,7 @@ const InstanceTypeItem: React.FC<InstanceTypeItemProps> = ({ item }) => {
               disabled={false}
               style={{ fontWeight: 400 }}
             >
-              {manufacturer?.toUpperCase()}
+              {formatManufacturer(manufacturer)}
             </ThemeTag>
           )}
           {showCpuManufacturerTag && (
@@ -276,9 +283,15 @@ const InstanceTypeItem: React.FC<InstanceTypeItemProps> = ({ item }) => {
             name="InstanceTypeBillingBadge"
             context={{ instanceType: item }}
           />
+          {action && <div style={{ marginLeft: 8 }}>{action}</div>}
         </Flex>
       </Title>
-      <InstanceMetadataSection spec={specData}></InstanceMetadataSection>
+      <InstanceMetadataSection
+        spec={specData}
+        slicedMaxPercentage={
+          Number(item.status?.onceMaxRequest?.acceleratorSliced) || 0
+        }
+      ></InstanceMetadataSection>
     </Flex>
   );
 };

src/pages/gpu-service/instances/components/instance-type-list.tsx

@@ -4,6 +4,7 @@ import { TemplateCard } from '@gpustack/core-ui';
 import { Empty, Flex, Spin } from 'antd';
 import _ from 'lodash';
 import { InstanceTypeItem as InstanceTypeItemModel } from '../config/types';
+import styles from '../styles/instances.module.less';
 import InstanceTypeItem from './instance-type-item';
 
 interface InstanceTypeListProps {
@@ -50,10 +51,10 @@ const InstanceTypeList: React.FC<InstanceTypeListProps> = ({
         return (
           <TemplateCard
             key={name}
+            className={styles.instanceTypeCard}
             clickable
             ghost
             hoverable
-            height={106}
             active={value === name}
             disabled={item.disabled}
             onClick={() => handleSelect(item)}

src/pages/gpu-service/instances/config/index.ts

@@ -3,7 +3,15 @@ import { StatusType } from '@/config/types';
 import { IconFont, icons } from '@gpustack/core-ui';
 import _ from 'lodash';
 import React from 'react';
-import { ListItem } from '../config/types';
+import { AcceleratorSlicedDetail, ListItem } from '../config/types';
+
+// Whether a type can be sliced, per the API contract (replaces the removed
+// `spec.sliceable` boolean): logical (soft) slicing reports per-card capacity
+// or physical (e.g. MIG) profiles exist. Every level of slicedDetail may be
+// absent (exclude_none responses).
+export const isSliceableDetail = (detail?: AcceleratorSlicedDetail | null) =>
+  (detail?.logical?.count ?? 0) > 0 ||
+  (detail?.physical?.profiles?.length ?? 0) > 0;
 
 export const InstanceStatusValueMap = {
   Scheduling: 'Scheduling',
@@ -251,7 +259,7 @@ const parseQuantity = (value?: string | null): number => {
 // Returns the slider max for the accelerator count: the largest
 // tier.onceMaxRequest.accelerator across all tiers (not from candidates).
 export const getAcceleratorMax = (
-  tiers?: { onceMaxRequest: { accelerator?: string } }[] | null
+  tiers?: { onceMaxRequest: { accelerator?: string | null } }[] | null
 ) => {
   if (!tiers?.length) return 0;
   return tiers.reduce((acc, tier) => {
@@ -262,32 +270,46 @@ export const getAcceleratorMax = (
 
 // Picks the candidate (cluster + type name) that should fulfill a requested
 // accelerator count: the first candidate of the smallest tier whose
-// onceMaxRequest.accelerator is >= the requested count and whose cpu/ram/localStorage
+// onceMaxRequest.accelerator is >= the requested count. Only Active candidates
-// remaining are all > 0.
+// are eligible. Accelerated types are not gated on CPU remaining (only CPU-only
+// types are); in sliced mode the candidate's acceleratorSliced remaining must
+// also be > 0.
 export const pickCandidateForAccelerator = <
   C extends {
     cluster: string;
     name: string;
+    phase?: string | null;
     cpu?: { remaining?: string | null } | null;
-    ram?: { remaining?: string | null } | null;
+    acceleratorSliced?: { remaining?: string | null } | null;
-    localStorage?: { remaining?: string | null } | null;
   }
 >(
   tiers:
     | {
-        onceMaxRequest: { accelerator?: string };
+        onceMaxRequest: {
+          accelerator?: string | null;
+          acceleratorSliced?: string | null;
+        };
         candidates?: C[] | null;
       }[]
     | undefined
     | null,
-  { count, acceleratable }: { count: number; acceleratable?: boolean }
+  {
+    count,
+    acceleratable,
+    sliced
+  }: { count: number; acceleratable?: boolean; sliced?: boolean }
 ): C | null => {
   if (!tiers?.length) return null;
 
-  const hasResources = (c: C) =>
+  const hasResources = (c: C) => {
-    parseQuantity(c.cpu?.remaining) > 0 &&
+    // Only Active candidates can serve new instances.
-    parseQuantity(c.ram?.remaining) > 0 &&
+    if (c.phase !== InstanceTypePhaseValueMap.Active) return false;
-    parseQuantity(c.localStorage?.remaining) > 0;
+    // Accelerated types are not gated on CPU remaining; CPU-only types are.
+    if (!acceleratable && parseQuantity(c.cpu?.remaining) <= 0) return false;
+    if (sliced && parseQuantity(c.acceleratorSliced?.remaining) <= 0)
+      return false;
+    return true;
+  };
 
   const sorted = [...tiers].sort(
     (a, b) =>
@@ -298,9 +320,14 @@ export const pickCandidateForAccelerator = <
   // count === 0 ? parseQuantity(tier.onceMaxRequest.accelerator) > count; this is CPU-only case.
   for (const tier of sorted) {
     const acceleratorCount = parseQuantity(tier.onceMaxRequest?.accelerator);
-    const fits = acceleratable
+    // Sliced mode requests a fraction of a single card, so the tier's
-      ? acceleratorCount >= count
+    // whole-card accelerator count (0 for a slice-only type) can't gate it;
-      : acceleratorCount === 0;
+    // fit on the tier's sliced capacity instead.
+    const fits = sliced
+      ? parseQuantity(tier.onceMaxRequest?.acceleratorSliced) > 0
+      : acceleratable
+        ? acceleratorCount >= count
+        : acceleratorCount === 0;
     if (!fits) continue;
     const candidate = tier.candidates?.find(hasResources);
     if (candidate) return candidate;

src/pages/gpu-service/instances/config/types.ts

@@ -45,6 +45,11 @@ export interface FormData {
       ram: string | null | number;
       localStorage: string | null | number;
       accelerator: number | string | null;
+      // Sliced (percentage) mode only. Memory (VRAM) percentage bound to the
+      // 10-100 selector + free input; cores (compute) percentage bound to the
+      // "100% compute" checkbox (100 when checked, mirrors memory otherwise).
+      acceleratorSlicedMemoryPercentage?: number;
+      acceleratorSlicedCoresPercentage?: number;
     };
     volume: {
       ephemeral?: {
@@ -126,70 +131,129 @@ export interface InstanceTypeResource {
 export interface InstanceTypeCandidate {
   cluster: string;
   name: string;
-  accelerator: InstanceTypeResource;
+  accelerator?: InstanceTypeResource | null;
-  cpu: InstanceTypeResource;
+  cpu?: InstanceTypeResource | null;
-  ram: InstanceTypeResource;
+  // Shared-mode available resource (not shown in the GPU Instance form).
-  localStorage: InstanceTypeResource;
+  acceleratorShared?: InstanceTypeResource | null;
+  // Sliced-mode available resource.
+  acceleratorSliced?: InstanceTypeResource | null;
+  // This candidate's sliced (partitioning) capability.
+  acceleratorSlicedDetail?: AcceleratorSlicedDetail | null;
+  phase?: 'Active' | 'Inactive' | 'Draining' | null;
 }
 
-export interface InstanceTypeTierOnceMaxRequestResource {
+// Per-mode maxima as plain number strings — the shape of the aggregated
-  accelerator?: string;
+// status.onceMaxRequest / status.remaining AND of tier onceMaxRequest /
-  cpu: QuanityCPU;
+// remaining (they are identical in the API). accelerator counts whole cards,
-  ram: QuanityMemory;
+// acceleratorShared / acceleratorSliced are percentages, cpu is cores. The
-  localStorage: QuanityLocalStorage;
+// API carries no ram / localStorage here — RAM caps derive from
+// spec.unitResources, disk from spec.localStorage.
+export interface InstanceTypeOverviewResource {
+  accelerator?: `${number}` | null;
+  acceleratorShared?: `${number}` | null;
+  acceleratorSliced?: `${number}` | null;
+  cpu?: QuanityCPU | null;
 }
 
 export interface InstanceTypeTier {
-  onceMaxRequest: InstanceTypeTierOnceMaxRequestResource;
+  onceMaxRequest: InstanceTypeOverviewResource;
+  remaining?: InstanceTypeOverviewResource | null;
+  // The tier's aggregated sliced (partitioning) capability.
+  acceleratorSlicedDetail?: AcceleratorSlicedDetail | null;
   candidates?: InstanceTypeCandidate[] | null;
 }
 
-export interface InstanceTypeOnceMaxRequestResource {
-  accelerator?: `${number}` | null;
-  cpu: QuanityCPU;
-  ram: QuanityMemory;
-  localStorage: QuanityLocalStorage;
-}
-
 export interface CPUCache {
-  l1i: string;
+  l1i?: string | null;
-  l1d: string;
+  l1d?: string | null;
-  l2: string;
+  l2?: string | null;
-  l3: string;
+  l3?: string | null;
 }
 
 export interface CPUInfo {
-  physicalCores: string;
+  physicalCores?: string | null;
-  threadsPerPhysicalCore: string;
+  threadsPerPhysicalCore?: string | null;
-  logicalCores: string;
+  logicalCores?: string | null;
-  stepping: string | null;
+  stepping?: string | null;
-  clockSpeed: string | null;
+  clockSpeed?: string | null;
-  maxClockSpeed: string | null;
+  maxClockSpeed?: string | null;
-  cacheLine: string;
+  cacheLine?: string | null;
-  cache: CPUCache;
+  cache?: CPUCache | null;
-  manufacturer: string;
+  manufacturer?: string | null;
-  product: string;
+  product?: string | null;
-  family: string;
+  family?: string | null;
 }
 
-export interface InstanceTypeSpec {
+// Sliced (partitioning) capability descriptor. Replaces the removed
-  group: string;
+// `spec.sliceable` boolean: a type is sliceable when logical (soft) slicing
-  acceleratable: boolean;
+// reports capacity or physical (e.g. MIG) profiles exist — see
-  manufacturer: string;
+// isSliceableDetail in ./index. Appears as status.detail.slicedDetail and as
+// tier / candidate `acceleratorSlicedDetail` in the aggregated view.
+export interface AcceleratorSlicedLogicalDetail {
+  coresPercentageOvercommit?: boolean;
+  // Max soft slices per card; 0 → soft slicing unsupported.
+  count?: number | null;
+}
+
+export interface AcceleratorSlicedPhysicalDetailProfile {
+  name?: string | null;
+  count?: number | null;
+}
+
+export interface AcceleratorSlicedPhysicalDetail {
+  profiles?: AcceleratorSlicedPhysicalDetailProfile[] | null;
+  count?: number | null;
+}
+
+export interface AcceleratorSlicedDetail {
+  logical?: AcceleratorSlicedLogicalDetail | null;
+  physical?: AcceleratorSlicedPhysicalDetail | null;
+}
+
+// status.detail — the observed hardware descriptor. The API moved these off
+// spec (spec keeps user-defined fields only). The whole object is absent until
+// the operator backfills status, and every response is exclude_none — treat
+// every key as possibly missing.
+export interface InstanceTypeDetail {
+  // Device identity.
+  manufacturer?: string | null;
   product?: string | null;
-  memory?: string | null;
   family?: string | null;
+  // Host node CPU (flat fields, as opposed to the nested `cpu` below).
+  physicalCores?: string | null;
+  threadsPerPhysicalCore?: string | null;
+  logicalCores?: string | null;
+  stepping?: string | null;
+  clockSpeed?: string | null;
+  maxClockSpeed?: string | null;
+  cacheLine?: string | null;
+  cache?: CPUCache | null;
+  // Accelerator hardware.
+  memory?: string | null;
+  cores?: string | null;
   computeCapability?: string | null;
-  sliced?: string | null;
+  slicedDetail?: AcceleratorSlicedDetail | null;
-  maxComputeUnitCount?: number;
+  // The accelerator's own CPU (distinct from the flat host CPU fields above).
+  cpu?: CPUInfo | null;
+}
+
+// Mirrors the API spec object exactly (user-defined fields only — observed
+// hardware lives on status.detail), plus two UI-computed enrichments filled by
+// use-query-instance-types whose names exist nowhere in the API.
+export interface InstanceTypeSpec {
+  displayName?: string | null;
+  acceleratorGroup?: string | null;
+  generalGroup?: string | null;
+  acceleratable?: boolean;
+  os?: string;
+  arch?: string;
+  localStorage?: QuanityLocalStorage;
   unitResources?: {
     cpu: QuanityCPU;
     ram: QuanityMemory;
   };
-  os?: string;
+  // ---- UI-computed (not part of the API contract) ----
-  arch?: string;
+  // spec.unitResources parsed to numbers.
-  cpu?: CPUInfo;
-  cache?: Record<string, string>;
   unitResourcesParsed?: {
     cpu: {
       cores?: number;
@@ -202,10 +266,31 @@ export interface InstanceTypeSpec {
       num: number;
     } | null;
   };
+  // Max requestable unit (card / core) count, derived from status.
+  maxComputeUnitCount?: number;
+}
+
+// Flat spec snapshot persisted in a GPU instance's `description` field at
+// create time (see utils/instance-description.ts) and reused as the display
+// model of the type card / metadata section. It merges the definition spec
+// with the observed hardware from status.detail and the derived `sliceable`.
+// The flat shape is a UI document format — do NOT confuse it with the API
+// InstanceTypeSpec; it stays flat for compatibility with snapshots persisted
+// by older instances.
+export interface InstanceTypeSnapshotSpec extends InstanceTypeSpec {
+  manufacturer?: string | null;
+  product?: string | null;
+  family?: string | null;
+  memory?: string | null;
+  sliceable?: boolean;
+  // Accelerator CPU identity only (from status.detail.cpu).
+  cpu?: Pick<CPUInfo, 'manufacturer' | 'product' | 'family'> | null;
 }
 
 export interface InstanceTypeStatus {
-  onceMaxRequest: InstanceTypeOnceMaxRequestResource;
+  detail?: InstanceTypeDetail | null;
+  onceMaxRequest: InstanceTypeOverviewResource;
+  remaining?: InstanceTypeOverviewResource | null;
   tiers?: InstanceTypeTier[] | null;
 }
 

src/pages/gpu-service/instances/forms/index.tsx

@@ -35,7 +35,11 @@ import { DefaultImagePullPolicy } from '../../templates/config';
 import TemplateBasicForm, {
   BasicResourceMax
 } from '../../templates/forms/basic';
-import { pickCandidateForAccelerator, StorageModeValueMap } from '../config';
+import {
+  isSliceableDetail,
+  pickCandidateForAccelerator,
+  StorageModeValueMap
+} from '../config';
 import { FormContext } from '../config/form-context';
 import { FormData, InstanceTypeItem, ListItem } from '../config/types';
 import instanceStyles from '../styles/instances.module.less';
@@ -55,7 +59,7 @@ interface InstanceFormProps {
   ref?: any;
   open: boolean;
   action: PageActionType;
-  realAction?: PageActionType | string;
+  // Present on edit / view.
   currentData?: ListItem | null;
   namespace?: string;
   instanceTypeList?: InstanceTypeItem[];
@@ -63,6 +67,9 @@ interface InstanceFormProps {
   // surfaces a "no available instance type" message in the scheduling tab.
   noAvailableInstanceTypes?: boolean;
   disabled?: boolean;
+  // Editing a non-stopped instance: only displayName and the SSH public keys
+  // stay editable; the type / template / storage sections render disabled.
+  restrictedEdit?: boolean;
   // Fired when the create-scope picker retargets the form to another
   // org (or Global). Only emitted on genuine changes — never on the
   // initial mount, and never in builds where the picker isn't mounted
@@ -107,9 +114,9 @@ const GPUServiceInstanceForm: React.FC<InstanceFormProps> = forwardRef(
   (props, ref) => {
     const {
       action,
-      realAction,
       currentData,
       disabled,
+      restrictedEdit,
       open,
       instanceTypeList = [],
       noAvailableInstanceTypes,
@@ -121,8 +128,9 @@ const GPUServiceInstanceForm: React.FC<InstanceFormProps> = forwardRef(
     const { getRuleMessage } = useAppUtils();
     const [form] = Form.useForm<InstanceFormValues>();
     const scrollTabsRef = useRef<any>(null);
-    const formAction =
+    // Restricted (non-stopped) edit disables the type / template / storage
-      realAction === PageAction.CREATE ? PageAction.CREATE : action;
+    // sections; displayName and the SSH public keys keep following `disabled`.
+    const sectionDisabled = disabled || restrictedEdit;
     const sshEnabled = Form.useWatch('enable_ssh', form);
     const description = Form.useWatch(['description'], form);
     // `organization_id` is owned by the create-scope picker slot; it only
@@ -273,33 +281,132 @@ const GPUServiceInstanceForm: React.FC<InstanceFormProps> = forwardRef(
 
     const buildResourcesDataForSubmit = (values: FormData) => {
       const unitResourcesParsed = getUnitResources();
-      const accelerator = _.toNumber(values.spec?.resources?.accelerator) || 0;
+      const resources = values.spec?.resources ?? ({} as any);
-      const cpuCount = _.toNumber(values.spec?.resources?.cpu) || 0;
+      const accelerator = _.toNumber(resources.accelerator) || 0;
+      const cpuCount = _.toNumber(resources.cpu) || 0;
 
       const cpuNum = unitResourcesParsed?.cpu?.num;
       const ramNum = unitResourcesParsed?.ram?.num;
 
-      const fallbackCpu = values.spec?.resources?.cpu;
+      const fallbackCpu = resources.cpu;
 
-      const factor = isGPUType ? accelerator : cpuCount;
+      const percentage = _.toNumber(
+        resources.acceleratorSlicedMemoryPercentage
+      );
+      const sliced = isGPUType && percentage > 0;
+      const wholeFactor = isGPUType ? accelerator : cpuCount;
 
+      // Sliced mode: scale a single card's unit resources by the chosen
+      // percentage, submitted as whole cores / whole Gi (floored, min 1) so
+      // the payload matches what the disabled CPU / RAM inputs display —
+      // e.g. 10% of a 4-core / 16Gi card → "1" / "1Gi".
+      if (sliced && unitResourcesParsed) {
+        const cpuCores = unitResourcesParsed.cpu?.cores ?? 0;
+        const ramValue = unitResourcesParsed.ram?.value ?? 0;
+        return {
+          cpu: `${Math.max(1, _.floor((cpuCores * percentage) / 100))}`,
+          ram: `${Math.max(1, _.floor((ramValue * percentage) / 100))}Gi`
+        };
+      }
+
+      // Whole / CPU mode: multiply the unit by the count.
       return {
         cpu: cpuNum
-          ? `${factor * cpuNum}${unitResourcesParsed?.cpu?.unit || ''}`
+          ? `${wholeFactor * cpuNum}${unitResourcesParsed?.cpu?.unit || ''}`
           : // Don't stringify an unset value — `${undefined}` becomes the
             // literal "undefined", which fails k8s quantity validation.
             fallbackCpu
             ? `${fallbackCpu}`
             : undefined,
         ram: ramNum
-          ? `${factor * ramNum}${unitResourcesParsed?.ram?.unit || ''}`
+          ? `${wholeFactor * ramNum}${unitResourcesParsed?.ram?.unit || ''}`
-          : values.spec?.resources?.ram
+          : resources.ram
       };
     };
 
+    // Sliced display: set the (disabled) CPU / RAM inputs to a single card's
+    // unit resources scaled by the chosen percentage, floored. Reads the
+    // percentage straight from the form so it can be re-run after any slider
+    // change without threading values through.
+    const applySlicedResourceScaling = () => {
+      const unitResourcesParsed = getUnitResources();
+      const cpuCores = unitResourcesParsed?.cpu?.cores;
+      const ramValue = unitResourcesParsed?.ram?.value;
+      const percentage = _.toNumber(
+        form.getFieldValue([
+          'spec',
+          'resources',
+          'acceleratorSlicedMemoryPercentage'
+        ])
+      );
+
+      form.setFieldsValue({
+        spec: {
+          resources: {
+            // Floor the scaled unit resources to whole units, never below 1 —
+            // a small slice (e.g. 8 GB × 10%) still shows a usable 1 vCPU /
+            // 1 GB instead of 0. Display-only: the submit path recomputes
+            // both precisely in millicores / Mi.
+            cpu:
+              cpuCores != null && percentage > 0
+                ? Math.max(1, _.floor((cpuCores * percentage) / 100))
+                : null,
+            ram:
+              ramValue != null && percentage > 0
+                ? Math.max(1, _.floor((ramValue * percentage) / 100))
+                : null
+          }
+        }
+      } as any);
+    };
+
+    // Whether the selected type allows the compute (cores) ratio to exceed
+    // the memory ratio. Without overcommit there is no cores selector and the
+    // cores ratio is locked to (mirrors) the memory ratio.
+    const coresOvercommit =
+      !!selectedInstanceType?.status?.detail?.slicedDetail?.logical
+        ?.coresPercentageOvercommit;
+
+    // Single entry point for the sliced memory ratio: write the ratio and
+    // rescale CPU / RAM off it. With cores overcommit the compute ratio must
+    // stay >= memory (bump it up when memory overtakes it); without it the
+    // compute ratio always mirrors memory. Reused by the slider onChange.
+    const applySliceMemoryPercentage = (value: number) => {
+      const currentCores = _.toNumber(
+        form.getFieldValue([
+          'spec',
+          'resources',
+          'acceleratorSlicedCoresPercentage'
+        ])
+      );
+      const coresPercentage = coresOvercommit
+        ? Math.max(currentCores, value)
+        : value;
+      form.setFieldsValue({
+        spec: {
+          resources: {
+            acceleratorSlicedMemoryPercentage: value,
+            acceleratorSlicedCoresPercentage: coresPercentage
+          }
+        }
+      } as any);
+      applySlicedResourceScaling();
+    };
+
+    // Compute (cores) ratio — a GPU-slice-only parameter that rides along on
+    // submit. It does not scale CPU / RAM (those track the memory ratio), so
+    // just write the field.
+    const applySliceCoresPercentage = (value: number) => {
+      form.setFieldValue(
+        ['spec', 'resources', 'acceleratorSlicedCoresPercentage'],
+        value
+      );
+    };
+
     const resolveAndApply = (
       instanceType: InstanceTypeItem | undefined,
-      count: number
+      count: number,
+      sliced?: boolean
     ) => {
       if (!instanceType) {
         setSelectedInstanceType(undefined);
@@ -328,17 +435,23 @@ const GPUServiceInstanceForm: React.FC<InstanceFormProps> = forwardRef(
         instanceType.status?.tiers,
         {
           count,
-          acceleratable: instanceType.spec?.acceleratable
+          acceleratable: instanceType.spec?.acceleratable,
+          sliced
         }
       );
 
       console.log('picked candidate', candidate, instanceType, count);
 
+      // The API carries no RAM max on onceMaxRequest — derive it from the
+      // per-unit RAM × the max requestable unit count (RAM always scales with
+      // the unit count). Disk max comes from spec.localStorage (UI-only cap).
+      const unitRamGi = instanceType.spec?.unitResourcesParsed?.ram?.value;
+      const maxUnits = instanceType.spec?.maxComputeUnitCount || 0;
       setOnceMaxRequest({
         cpu: ceilMilliToCore(candidate?.cpu?.onceMaxRequest)?.cores,
-        memory: parseQuantityToGi(candidate?.ram?.onceMaxRequest)?.value,
+        memory: unitRamGi && maxUnits ? unitRamGi * maxUnits : null,
-        localStorage: parseQuantityToGi(candidate?.localStorage?.onceMaxRequest)
+        localStorage:
-          ?.value
+          parseQuantityToGi(instanceType.spec?.localStorage)?.value ?? null
       });
 
       form.setFieldsValue({
@@ -354,8 +467,89 @@ const GPUServiceInstanceForm: React.FC<InstanceFormProps> = forwardRef(
       });
     };
 
+    // Whole-card (exclusive) vs sliced (percentage) mode. Only meaningful for
+    // sliceable accelerator types; derived (no persisted field) — on edit it
+    // is inferred from acceleratorSlicedMemoryPercentage > 0.
+    const [sliceMode, setSliceMode] = useState<'whole' | 'sliced'>('whole');
+
     const handleAcceleratorChange = (count: number) => {
-      resolveAndApply(selectedInstanceType, count);
+      resolveAndApply(selectedInstanceType, count, false);
+    };
+
+    // Seed the sliced-mode defaults for an instance type: memory ratio at 10%
+    // (never above the type's max sliceable ratio, status.onceMaxRequest
+    // .acceleratorSliced), and the cores ratio defaulting to the same value
+    // (cores >= memory). Set both together so a fresh selection doesn't carry a
+    // stale cores value from a previous type.
+    const applySlicedDefaults = (instanceType?: InstanceTypeItem) => {
+      const slicedMax =
+        _.toNumber(instanceType?.status?.onceMaxRequest?.acceleratorSliced) ||
+        0;
+      const memoryPercentage = slicedMax ? Math.min(10, slicedMax) : 10;
+      form.setFieldsValue({
+        spec: {
+          resources: {
+            acceleratorSlicedMemoryPercentage: memoryPercentage,
+            acceleratorSlicedCoresPercentage: memoryPercentage
+          }
+        }
+      } as any);
+      applySlicedResourceScaling();
+    };
+
+    // Toggle between whole-card and sliced mode. Sliced fixes the accelerator
+    // count to 1 (a single card is partitioned by percentage) and clears the
+    // slice-percentage fields when leaving sliced mode.
+    const handleSliceModeChange = (mode: 'whole' | 'sliced') => {
+      setSliceMode(mode);
+      if (mode === 'sliced') {
+        resolveAndApply(selectedInstanceType, 1, true);
+        applySlicedDefaults(selectedInstanceType);
+      } else {
+        form.setFieldsValue({
+          spec: {
+            resources: {
+              acceleratorSlicedMemoryPercentage: undefined,
+              acceleratorSlicedCoresPercentage: undefined
+            }
+          }
+        } as any);
+        resolveAndApply(selectedInstanceType, 1, false);
+      }
+    };
+
+    // Apply a chosen instance type to the form: default to sliced mode for a
+    // sliceable type with no whole-card capacity, otherwise whole-card with a
+    // count of 1. Shared by the create card selection (imperative handle) and
+    // the edit change-type overlay.
+    const applyInstanceType = (instanceType?: InstanceTypeItem) => {
+      if (!instanceType) {
+        setSliceMode('whole');
+        resolveAndApply(undefined, 0);
+        return;
+      }
+
+      // A sliceable type with no whole-card capacity (Max < 1) defaults to
+      // sliced mode — whole mode would have nothing selectable.
+      const wholeMax = instanceType.spec?.maxComputeUnitCount ?? 0;
+      const slicedMax =
+        _.toNumber(instanceType.status?.onceMaxRequest?.acceleratorSliced) || 0;
+      const defaultSliced =
+        isSliceableDetail(instanceType.status?.detail?.slicedDetail) &&
+        wholeMax < 1 &&
+        slicedMax > 0;
+
+      if (defaultSliced) {
+        setSliceMode('sliced');
+        resolveAndApply(instanceType, 1, true);
+        applySlicedDefaults(instanceType);
+        return;
+      }
+
+      // Otherwise default to whole-card mode (a new type may not be
+      // sliceable); set count to 1 for all instance types: GPU or non-GPU.
+      setSliceMode('whole');
+      resolveAndApply(instanceType, 1);
     };
 
     const onTargetChange = (key: string) => {
@@ -392,11 +586,8 @@ const GPUServiceInstanceForm: React.FC<InstanceFormProps> = forwardRef(
         return;
       }
 
-      if (
+      // Prefill from the source row on edit / view.
-        action === PageAction.EDIT ||
+      if (currentData) {
-        action === PageAction.VIEW ||
-        realAction === PageAction.CREATE
-      ) {
         console.log('currentData', currentData);
         const currentSpec = parseJsonSafe(
           currentData?.description || '{}',
@@ -407,6 +598,14 @@ const GPUServiceInstanceForm: React.FC<InstanceFormProps> = forwardRef(
           ? _.toNumber(currentData?.spec?.resources?.accelerator)
           : _.toNumber(currentData?.spec?.resources?.cpu) || 0;
 
+        // Infer the mode from the persisted slice percentage (edit/view
+        // render a readonly card).
+        const persistedSliced =
+          _.toNumber(
+            currentData?.spec?.resources?.acceleratorSlicedMemoryPercentage
+          ) > 0;
+        setSliceMode(persistedSliced ? 'sliced' : 'whole');
+
         form.setFieldsValue({
           ...currentData,
           spec: {
@@ -424,8 +623,14 @@ const GPUServiceInstanceForm: React.FC<InstanceFormProps> = forwardRef(
           enable_ssh: !!currentData?.spec?.sshPublicKeys?.length,
           storageMode: detectMode(currentData?.spec?.volume)
         });
+
+        // buildResourcesData above filled CPU / RAM for the whole card; rescale
+        // them off the persisted percentages for a sliced instance.
+        if (persistedSliced) {
+          applySlicedResourceScaling();
+        }
       }
-    }, [action, currentData, form, open, realAction, instanceTypeList]);
+    }, [action, currentData, form, open, instanceTypeList]);
 
     const getUnitResources = () => {
       if (selectedInstanceType?.spec?.unitResourcesParsed) {
@@ -490,15 +695,7 @@ const GPUServiceInstanceForm: React.FC<InstanceFormProps> = forwardRef(
         form.setFieldsValue(values as any);
       },
       getFieldsValue: () => form.getFieldsValue(),
-      applyInstanceType: (instanceType?: InstanceTypeItem) => {
+      applyInstanceType
-        if (!instanceType) {
-          resolveAndApply(undefined, 0);
-          return;
-        }
-
-        // set default  to 1, for all instance types: GPU or non-GPU
-        resolveAndApply(instanceType, 1);
-      }
     }));
 
     const handleAddSSHKey = () => {
@@ -540,7 +737,7 @@ const GPUServiceInstanceForm: React.FC<InstanceFormProps> = forwardRef(
       >
         <FormContext.Provider
           value={{
-            action: formAction,
+            action: action,
             currentData: currentData,
             isGPUType: isGPUType
           }}
@@ -584,7 +781,7 @@ const GPUServiceInstanceForm: React.FC<InstanceFormProps> = forwardRef(
               storageMode: StorageModeValueMap.Temporary
             }}
           >
-            <Basic action={formAction} disabled={disabled} />
+            <Basic action={action} disabled={disabled} />
             <Form.Item name="clusterId" hidden>
               <CInput.Input />
             </Form.Item>
@@ -601,12 +798,16 @@ const GPUServiceInstanceForm: React.FC<InstanceFormProps> = forwardRef(
                   forceRender: true,
                   children: (
                     <InstanceTypeFormItem
-                      action={formAction}
+                      action={action}
-                      disabled={disabled}
+                      disabled={sectionDisabled}
                       selectedInstanceType={selectedInstanceType}
                       currentData={currentData as any}
                       onceMaxRequest={onceMaxRequest}
                       noAvailableTypes={noAvailableInstanceTypes}
+                      sliceMode={sliceMode}
+                      onSliceModeChange={handleSliceModeChange}
+                      onSliceMemoryPercentageChange={applySliceMemoryPercentage}
+                      onSliceCoresPercentageChange={applySliceCoresPercentage}
                       onGPUCountChange={handleAcceleratorChange}
                     />
                   )
@@ -620,7 +821,7 @@ const GPUServiceInstanceForm: React.FC<InstanceFormProps> = forwardRef(
                   children: (
                     <TemplateBasicForm
                       page="instance"
-                      disabled={disabled || formAction === PageAction.EDIT}
+                      disabled={sectionDisabled}
                       onceMaxRequest={onceMaxRequest}
                     />
                   )
@@ -632,10 +833,7 @@ const GPUServiceInstanceForm: React.FC<InstanceFormProps> = forwardRef(
                   }),
                   forceRender: true,
                   children: (
-                    <StorageVolume
+                    <StorageVolume disabled={sectionDisabled} action={action} />
-                      disabled={disabled || formAction === PageAction.EDIT}
-                      action={formAction}
-                    />
                   )
                 }
               ]}

src/pages/gpu-service/instances/forms/instance-type.tsx

@@ -3,7 +3,7 @@ import { PageActionType } from '@/config/types';
 import NumberSelection from '@/pages/_components/number-selection';
 import { InputNumber } from '@gpustack/core-ui';
 import { useIntl } from '@umijs/max';
-import { Flex, Form } from 'antd';
+import { Flex, Form, Segmented } from 'antd';
 import _ from 'lodash';
 import { useContext, useMemo } from 'react';
 import styled from 'styled-components';
@@ -12,6 +12,7 @@ import { parseJsonSafe } from '../../utils';
 import InstanceTypeItem, {
   InstanceMetadataSection
 } from '../components/instance-type-item';
+import { isSliceableDetail } from '../config';
 import { FormContext } from '../config/form-context';
 import {
   FormData,
@@ -57,6 +58,24 @@ const InstanceTypePicker: React.FC<InstanceTypePickerProps> = ({
   );
 };
 
+// Fixed 10-tick percentage scale (10..100) for the sliced (percentage) mode.
+const SLICE_PERCENT_TICKS = [10, 20, 30, 50];
+
+// The paired VRAM + Compute selectors (cores overcommit) are grouped in a
+// bordered card; a lone "Percentage" selector (no overcommit) renders bare so
+// it matches the whole-card GPU Count block's styling.
+const SliceFieldWrapper: React.FC<{
+  withCard: boolean;
+  children: React.ReactNode;
+}> = ({ withCard, children }) =>
+  withCard ? (
+    <FieldBlock>
+      <SelectedCard style={{ padding: 0 }}>{children}</SelectedCard>
+    </FieldBlock>
+  ) : (
+    <>{children}</>
+  );
+
 interface InstanceTypeFormItemProps {
   action: PageActionType;
   disabled?: boolean;
@@ -67,6 +86,14 @@ interface InstanceTypeFormItemProps {
   // org owns no clusters. Surface a "no available" message instead of the
   // "please select" placeholder + empty CPU / memory inputs.
   noAvailableTypes?: boolean;
+  // Whole-card (exclusive) vs sliced (percentage) mode. Owned by the parent
+  // form (it drives candidate picking + the fixed accelerator=1 for sliced).
+  sliceMode?: 'whole' | 'sliced';
+  onSliceModeChange?: (mode: 'whole' | 'sliced') => void;
+  // Commit a new sliced memory ratio (writes the field + rescales CPU / RAM).
+  onSliceMemoryPercentageChange?: (value: number) => void;
+  // Commit a new sliced compute (cores) ratio (writes the field only).
+  onSliceCoresPercentageChange?: (value: number) => void;
   onGPUCountChange?: (value: number) => void;
 }
 
@@ -77,13 +104,24 @@ const InstanceTypeFormItem: React.FC<InstanceTypeFormItemProps> = ({
   selectedInstanceType,
   onceMaxRequest,
   noAvailableTypes,
+  sliceMode = 'whole',
+  onSliceModeChange,
+  onSliceMemoryPercentageChange,
+  onSliceCoresPercentageChange,
   onGPUCountChange
 }) => {
   const intl = useIntl();
+  const form = Form.useFormInstance();
   const { isGPUType } = useContext(FormContext);
 
+  // In edit mode the type card is read-only until a type is re-picked from the
+  // instance-type column (stopped instances only); once selected the section
+  // behaves like create (editable count / slice controls, live capacity
+  // labels).
+  const readonlyType = action === PageAction.EDIT && !selectedInstanceType;
+
   const maxComputeUnitCount = useMemo(() => {
-    if (action === PageAction.EDIT) {
+    if (readonlyType) {
       const description = parseJsonSafe(
         currentData?.description || '{}',
         {} as any
@@ -91,19 +129,91 @@ const InstanceTypeFormItem: React.FC<InstanceTypeFormItemProps> = ({
       return description.spec?.maxComputeUnitCount || 0;
     }
     return selectedInstanceType?.spec?.maxComputeUnitCount || 0;
-  }, [action, currentData, selectedInstanceType]);
+  }, [readonlyType, currentData, selectedInstanceType]);
-
-  const isGPU = useMemo(() => {
-    if (action === PageAction.EDIT) {
-      return _.toNumber(currentData?.spec?.resources?.accelerator) > 0;
-    }
-    return selectedInstanceType?.spec?.acceleratable;
-  }, [selectedInstanceType, action]);
 
   const handleOnGPUCountChange = (value: number) => {
     onGPUCountChange?.(value);
   };
 
+  // Sliced mode is only offered for sliceable accelerator types, and only when
+  // the section is editable (create, or edit after re-picking a type; a
+  // not-yet-re-typed edit renders a readonly card).
+  const showModeSwitch =
+    !readonlyType &&
+    isGPUType &&
+    isSliceableDetail(selectedInstanceType?.status?.detail?.slicedDetail);
+
+  const handleModeChange = (value: string) => {
+    onSliceModeChange?.(value as 'whole' | 'sliced');
+  };
+
+  // Memory (VRAM) percentage changed via the slider/input — forward the new
+  // value so the parent writes the field and rescales CPU / RAM.
+  const handleMemoryPercentageChange = (value: number) => {
+    onSliceMemoryPercentageChange?.(value);
+  };
+
+  // Compute (cores) percentage changed — forward the new value.
+  const handleCoresPercentageChange = (value: number) => {
+    onSliceCoresPercentageChange?.(value);
+  };
+
+  // The cores ratio must be >= the memory ratio, so ticks below the current
+  // memory percentage are disabled (min). Cores range is a fixed 10..100.
+  const slicedMemoryPercentage =
+    _.toNumber(
+      Form.useWatch(
+        ['spec', 'resources', 'acceleratorSlicedMemoryPercentage'],
+        form
+      )
+    ) || 1;
+
+  // Max selectable ratio in sliced mode: status.onceMaxRequest.acceleratorSliced
+  // (a percentage). Ticks above it stay visible but disabled.
+  const slicedMaxPercentage =
+    _.toNumber(
+      selectedInstanceType?.status?.onceMaxRequest?.acceleratorSliced
+    ) || 0;
+
+  // Whether the compute (cores) ratio may exceed the memory ratio. When the
+  // type doesn't support overcommit, cores are locked to the memory ratio —
+  // no cores selector, and the memory selector reads as a plain "Percentage".
+  const coresOvercommit =
+    !!selectedInstanceType?.status?.detail?.slicedDetail?.logical
+      ?.coresPercentageOvercommit;
+
+  const modeSegmented = showModeSwitch ? (
+    <Segmented
+      size="middle"
+      type="rounded"
+      style={{ fontSize: 12 }}
+      value={sliceMode}
+      disabled={disabled}
+      onChange={handleModeChange}
+      options={[
+        {
+          label: intl.formatMessage({ id: 'gpuservice.instance.mode.whole' }),
+          value: 'whole'
+        },
+        {
+          label: intl.formatMessage({ id: 'gpuservice.instance.mode.sliced' }),
+          value: 'sliced',
+          // No sliced capacity → keep the option visible but unselectable.
+          disabled: slicedMaxPercentage <= 0
+        }
+      ]}
+    />
+  ) : null;
+
+  const isSliced = showModeSwitch && sliceMode === 'sliced';
+
+  // When the max ratio is below 10%, switch the ticks to a finer 1..10 scale
+  // so small slices are still selectable; otherwise use the 10..100 scale.
+  const sliceTicks: number[] =
+    slicedMaxPercentage < 10
+      ? [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+      : SLICE_PERCENT_TICKS;
+
   const renderMaxLabel = (
     label: React.ReactNode,
     max?: number | null
@@ -122,7 +232,7 @@ const InstanceTypeFormItem: React.FC<InstanceTypeFormItemProps> = ({
   };
 
   const renderMemoryLabel = (): React.ReactNode => {
-    if (isGPUType || action === PageAction.EDIT || !onceMaxRequest?.memory) {
+    if (isGPUType || readonlyType || !onceMaxRequest?.memory) {
       return intl.formatMessage({ id: 'gpuservice.template.memory' });
     }
 
@@ -154,8 +264,8 @@ const InstanceTypeFormItem: React.FC<InstanceTypeFormItemProps> = ({
             }}
           >
             {description.acceleratable
-              ? `${description.product} x ${currentData?.spec?.resources?.accelerator}`
+              ? `${description.displayName || description.product} x ${currentData?.spec?.resources?.accelerator}`
-              : 'CPU'}
+              : description.displayName || 'CPU'}
           </span>
           <InstanceMetadataSection spec={description}></InstanceMetadataSection>
         </Flex>
@@ -188,15 +298,21 @@ const InstanceTypeFormItem: React.FC<InstanceTypeFormItemProps> = ({
             }
           ]}
         >
-          {action === PageAction.CREATE && (
+          {readonlyType ? (
+            renderInstanceType()
+          ) : (
             <InstanceTypePicker
               selectedInstanceType={selectedInstanceType}
               noAvailable={noAvailableTypes}
             />
           )}
-          {action === PageAction.EDIT && renderInstanceType()}
         </Form.Item>
       </FieldBlock>
+      {showModeSwitch && (
+        <div>
+          <div style={{ marginBlock: 8 }}>{modeSegmented}</div>
+        </div>
+      )}
       {!noAvailableTypes && (
         <Form.Item<FormData>
           key={isGPUType ? 'accelerator' : 'cpu'}
@@ -206,7 +322,7 @@ const InstanceTypeFormItem: React.FC<InstanceTypeFormItemProps> = ({
               : ['spec', 'resources', 'cpu']
           }
           preserve
-          hidden={action === PageAction.EDIT}
+          hidden={readonlyType || isSliced}
           normalize={(value) => (value != null ? _.toString(value) : undefined)}
           getValueProps={(value) => ({
             value: value != null ? _.toNumber(value) : undefined
@@ -247,7 +363,7 @@ const InstanceTypeFormItem: React.FC<InstanceTypeFormItemProps> = ({
             max={maxComputeUnitCount}
             step={1}
             required
-            disabled={disabled || action === PageAction.EDIT}
+            disabled={disabled || readonlyType}
             label={`${intl.formatMessage({ id: 'common.max.count' }, { label: numberSelectionLabel.label })} (${intl.formatMessage(
               {
                 id: 'common.max'
@@ -257,6 +373,158 @@ const InstanceTypeFormItem: React.FC<InstanceTypeFormItemProps> = ({
           />
         </Form.Item>
       )}
+      {!noAvailableTypes && isSliced && (
+        <SliceFieldWrapper withCard={coresOvercommit}>
+          <>
+            <Form.Item<FormData>
+              name={['spec', 'resources', 'acceleratorSlicedMemoryPercentage']}
+              // Grouped with the compute selector inside one card — tighten
+              // the default 24px gap between the pair.
+              style={coresOvercommit ? { marginBottom: 0 } : undefined}
+              getValueProps={(value) => ({
+                value: value != null ? _.toNumber(value) : undefined
+              })}
+              rules={[
+                {
+                  required: true,
+                  validator: (_, value) => {
+                    const num = Number(value);
+                    if (value == null || value === '' || Number.isNaN(num)) {
+                      return Promise.reject(
+                        new Error(
+                          intl.formatMessage({
+                            id: 'gpuservice.instance.slice.percentage.required'
+                          })
+                        )
+                      );
+                    }
+                    if (num > slicedMaxPercentage || num <= 0) {
+                      return Promise.reject(
+                        new Error(
+                          intl.formatMessage(
+                            {
+                              id: 'gpuservice.instance.slice.percentage.max'
+                            },
+                            { count: slicedMaxPercentage }
+                          )
+                        )
+                      );
+                    }
+                    return Promise.resolve();
+                  }
+                }
+              ]}
+            >
+              <NumberSelection
+                min={1}
+                max={slicedMaxPercentage}
+                step={1}
+                maxCount={sliceTicks.length}
+                presetValues={sliceTicks}
+                alwaysShowInput
+                required
+                disabled={disabled}
+                // Inside the card the selector drops its own border; the bare
+                // (no-overcommit) variant keeps it, like the GPU Count block.
+                style={coresOvercommit ? { border: 'none' } : undefined}
+                onChange={handleMemoryPercentageChange}
+                label={intl.formatMessage({
+                  // Without cores overcommit this single ratio drives both
+                  // VRAM and compute, so drop the "VRAM" qualifier.
+                  id: coresOvercommit
+                    ? 'gpuservice.instance.slice.memoryPercentage'
+                    : 'gpuservice.instance.slice.percentage'
+                })}
+              />
+            </Form.Item>
+            {/* Compute (cores) percentage. Fixed 10..100 ticks; ticks below the
+              chosen memory ratio are disabled (cores must be >= memory). Only
+              types with cores overcommit get the selector — without it the
+              ratio is locked to the memory percentage (the parent mirrors it),
+              carried by a hidden field so it still rides the submit. */}
+            {coresOvercommit ? (
+              <Form.Item<FormData>
+                name={['spec', 'resources', 'acceleratorSlicedCoresPercentage']}
+                style={{ marginBottom: 0 }}
+                getValueProps={(value) => ({
+                  value: value != null ? _.toNumber(value) : undefined
+                })}
+                rules={[
+                  {
+                    required: true,
+                    validator: (_, value) => {
+                      const num = Number(value);
+                      if (value == null || value === '' || Number.isNaN(num)) {
+                        return Promise.reject(
+                          new Error(
+                            intl.formatMessage({
+                              id: 'gpuservice.instance.slice.percentage.required'
+                            })
+                          )
+                        );
+                      }
+                      if (num < slicedMemoryPercentage || num > 100) {
+                        return Promise.reject(
+                          new Error(
+                            intl.formatMessage(
+                              { id: 'gpuservice.instance.slice.cores.min' },
+                              { count: slicedMemoryPercentage }
+                            )
+                          )
+                        );
+                      }
+                      return Promise.resolve();
+                    }
+                  }
+                ]}
+              >
+                <NumberSelection
+                  min={slicedMemoryPercentage}
+                  max={100}
+                  step={10}
+                  maxCount={SLICE_PERCENT_TICKS.length}
+                  presetValues={SLICE_PERCENT_TICKS}
+                  alwaysShowInput
+                  required
+                  disabled={disabled}
+                  onChange={handleCoresPercentageChange}
+                  style={{ border: 'none' }}
+                  label={intl.formatMessage({
+                    id: 'gpuservice.instance.slice.coresPercentage'
+                  })}
+                />
+              </Form.Item>
+            ) : (
+              <Form.Item<FormData>
+                name={['spec', 'resources', 'acceleratorSlicedCoresPercentage']}
+                style={{ marginBottom: 0 }}
+                hidden
+              >
+                <InputNumber />
+              </Form.Item>
+            )}
+          </>
+        </SliceFieldWrapper>
+      )}
+      {/* A not-yet-re-typed edit renders a readonly card (no sliced UI), so
+          register the slice percentages as hidden fields — otherwise their
+          persisted values are dropped from the submit payload. */}
+      {readonlyType && (
+        <>
+          <Form.Item<FormData>
+            name={['spec', 'resources', 'acceleratorSlicedMemoryPercentage']}
+            hidden
+          >
+            <InputNumber />
+          </Form.Item>
+          <Form.Item<FormData>
+            name={['spec', 'resources', 'acceleratorSlicedCoresPercentage']}
+            hidden
+          >
+            <InputNumber />
+          </Form.Item>
+        </>
+      )}
       {!noAvailableTypes && (
         <Flex gap={12}>
           <div style={{ flex: 1 }}>
@@ -281,11 +549,7 @@ const InstanceTypeFormItem: React.FC<InstanceTypeFormItemProps> = ({
                 key="cpu_input"
                 preserve
               >
-                <InputNumber
+                <InputNumber label={'CPU'} disabled={true} />
-                  label={'CPU'}
-                  max={onceMaxRequest?.cpu ?? undefined}
-                  disabled={true}
-                />
               </Form.Item>
             </div>
           )}

src/pages/gpu-service/instances/hooks/use-create-instance.ts

@@ -3,6 +3,7 @@ import type { PageActionType } from '@/config/types';
 import useBodyScroll from '@/hooks/use-body-scroll';
 import { useIntl } from '@umijs/max';
 import { useState } from 'react';
+import { InstanceStatusValueMap } from '../config';
 import type { ListItem } from '../config/types';
 
 const useCreateInstance = () => {
@@ -14,30 +15,26 @@ const useCreateInstance = () => {
     title: string;
     currentData?: ListItem | null;
     width?: number | string;
-    realAction?: string;
   }>({
     action: PageAction.CREATE,
     title: '',
     open: false,
     width: undefined,
-    currentData: null,
+    currentData: null
-    realAction: undefined
   });
 
   const openModal = (
     action: PageActionType,
     title: string,
     currentData?: ListItem | null,
-    width?: number | string,
+    width?: number | string
-    realAction?: string
   ) => {
     setOpenModalStatus({
       action,
       title,
       open: true,
       currentData,
-      width,
+      width
-      realAction
     });
     saveScrollHeight();
   };
@@ -52,11 +49,14 @@ const useCreateInstance = () => {
   };
 
   const openEditInstanceModal = (row: ListItem) => {
+    // A stopped instance can be re-typed, so it needs the two-column layout
+    // (instance-type list + form); other statuses edit in a single column.
+    const isStopped = row.status?.phase === InstanceStatusValueMap.Stopped;
     openModal(
       PageAction.EDIT,
       intl.formatMessage({ id: 'gpuservice.instance.edit' }),
       row,
-      600
+      isStopped ? 'min(1040px, calc(100vw - 220px))' : 600
     );
   };
 
@@ -69,23 +69,12 @@ const useCreateInstance = () => {
     );
   };
 
-  const openRecreateInstanceModal = (row: ListItem) => {
-    openModal(
-      PageAction.EDIT,
-      intl.formatMessage({ id: 'common.button.recreate' }),
-      row,
-      'calc(100vw - 220px)',
-      PageAction.CREATE
-    );
-  };
-
   const closeModal = () => {
     setOpenModalStatus({
       ...openModalStatus,
       title: '',
       open: false,
-      currentData: null,
+      currentData: null
-      realAction: undefined
     });
     restoreScrollHeight();
   };
@@ -97,7 +86,6 @@ const useCreateInstance = () => {
     openCreateInstanceModal,
     openEditInstanceModal,
     openViewInstanceModal,
-    openRecreateInstanceModal,
     closeInstanceModal: closeModal
   };
 };

src/pages/gpu-service/instances/index.tsx

@@ -86,7 +86,6 @@ const GPUService: React.FC = () => {
     openCreateInstanceModal,
     openEditInstanceModal,
     openViewInstanceModal,
-    openRecreateInstanceModal,
     closeInstanceModal
   } = useCreateInstance();
   const { openViewLogsModal, closeViewLogsModal, openViewLogsModalStatus } =
@@ -136,13 +135,7 @@ const GPUService: React.FC = () => {
 
   const handleModalOk = async (data: FormData) => {
     try {
-      if (openInstanceModalStatus.realAction === PageAction.CREATE) {
+      if (openInstanceModalStatus.action === PageAction.EDIT) {
-        await deleteGPUServiceInstance(openInstanceModalStatus.currentData!.id);
-        await new Promise((resolve) => {
-          setTimeout(resolve, 300);
-        });
-        await createInstance({ data });
-      } else if (openInstanceModalStatus.action === PageAction.EDIT) {
         await updateInstance({
           id: openInstanceModalStatus.currentData!.id,
           data
@@ -243,8 +236,6 @@ const GPUService: React.FC = () => {
       openEditInstanceModal(row);
     } else if (val === 'delete') {
       handleDelete({ ...row });
-    } else if (val === 'recreate') {
-      openRecreateInstanceModal(row);
     } else if (val === 'viewlog') {
       openViewLogsModal(row);
     } else if (val === 'viewevent') {
@@ -391,7 +382,6 @@ const GPUService: React.FC = () => {
         title={openInstanceModalStatus.title}
         data={openInstanceModalStatus.currentData}
         width={openInstanceModalStatus.width}
-        realAction={openInstanceModalStatus.realAction}
         clusterList={clusterList}
         onCancel={closeInstanceModal}
         onOk={handleModalOk}

src/pages/gpu-service/instances/services/use-query-instance-types.ts

@@ -2,7 +2,7 @@ import { useQueryData } from '@gpustack/core-ui';
 import React from 'react';
 import { ceilMilliToCore, parseQuantityToGi } from '../../utils';
 import { queryGPUServiceInstanceTypes } from '../apis';
-import { getAcceleratorMax } from '../config';
+import { getAcceleratorMax, isSliceableDetail } from '../config';
 import { InstanceTypeItem } from '../config/types';
 
 type InstanceType = InstanceTypeItem & {
@@ -36,6 +36,20 @@ export default function useQueryInstanceTypes() {
     }
 
     const max = getAcceleratorMax(item.status?.tiers);
+
+    // Sliceable types stay selectable as long as either whole-card or sliced
+    // capacity remains; unavailable only when both status.onceMaxRequest
+    // .accelerator and .acceleratorSliced are 0.
+    if (isSliceableDetail(item.status?.detail?.slicedDetail)) {
+      const wholeMax = Number(item.status?.onceMaxRequest?.accelerator) || 0;
+      const slicedMax =
+        Number(item.status?.onceMaxRequest?.acceleratorSliced) || 0;
+      return {
+        maxComputeUnitCount: max || 0,
+        available: wholeMax > 0 || slicedMax > 0
+      };
+    }
+
     return {
       maxComputeUnitCount: max || 0,
       available: (max || 0) > 0
@@ -63,17 +77,11 @@ export default function useQueryInstanceTypes() {
         },
         status: {
           ...item.status,
+          // Normalize cpu (possibly millicores) to a whole-core count string;
+          // the other onceMaxRequest fields are plain number strings already.
           onceMaxRequest: {
             ...rawMax,
-            cpu: rawMax?.cpu
+            cpu: rawMax?.cpu ? `${ceilMilliToCore(rawMax.cpu)?.cores || 0}` : ''
-              ? `${ceilMilliToCore(rawMax.cpu)?.cores || 0}`
-              : '',
-            ram: rawMax?.ram
-              ? `${parseQuantityToGi(rawMax.ram)?.value || 0}`
-              : '',
-            localStorage: rawMax?.localStorage
-              ? `${parseQuantityToGi(rawMax.localStorage)?.value || 0}`
-              : ''
           }
         },
 

src/pages/gpu-service/instances/styles/instances.module.less

@@ -45,3 +45,10 @@
   font-weight: 400;
   font-size: 12px;
 }
+
+// TemplateCard applies a fixed inline height; override to let sliceable cards
+// (with the extra Sliceable row) grow while keeping a 106px floor.
+.instanceTypeCard {
+  height: auto !important;
+  min-height: 106px;
+}

src/pages/gpu-service/instances/utils/instance-description.ts

@@ -0,0 +1,35 @@
+import _ from 'lodash';
+import { isSliceableDetail } from '../config';
+import { InstanceTypeItem, InstanceTypeSnapshotSpec } from '../config/types';
+
+// Build the flat snapshot spec from a live (API-shaped) instance type:
+// definition fields from spec, observed hardware from status.detail, plus the
+// derived `sliceable`. This flat shape is the UI document format persisted in
+// the instance's `description` (older instances already carry it flat) and
+// doubles as the display model of the type card / metadata section.
+export const buildInstanceTypeSnapshotSpec = (
+  instanceType: InstanceTypeItem
+): InstanceTypeSnapshotSpec => {
+  const detail = instanceType.status?.detail;
+  return {
+    ...instanceType.spec,
+    ..._.pick(detail, ['manufacturer', 'product', 'family', 'memory']),
+    sliceable: isSliceableDetail(detail?.slicedDetail),
+    // Accelerator CPU identity only — the full CPU descriptor is too bulky to
+    // persist and the UI only shows who made it.
+    cpu: _.pick(detail?.cpu, ['manufacturer', 'product', 'family'])
+  };
+};
+
+// Serialize the chosen instance type into the instance's `description` field —
+// a persisted spec snapshot the form reads back to render the type card and
+// derive unit resources. Shared by the create flow (card selection) and the
+// edit flow (change-type overlay).
+export const saveInstanceDataInDescription = (
+  instanceType: InstanceTypeItem
+): string => {
+  return JSON.stringify({
+    name: instanceType.name,
+    spec: buildInstanceTypeSnapshotSpec(instanceType)
+  });
+};

src/pages/gpu-service/instances/utils/render-instance-type.tsx

@@ -11,10 +11,10 @@
  * with ``buildInstanceTypeRecordFromMiB`` and feed it here.
  */
 import _ from 'lodash';
-import { parseJsonSafe } from '../../utils';
+import { ceilMilliToCore, parseJsonSafe, parseQuantityToGi } from '../../utils';
 import InstanceTypeCell from '../components/instance-type-cell';
 import { formatMemoryDisplay } from '../config';
-import { InstanceTypeSpec, ListItem } from '../config/types';
+import { InstanceTypeSnapshotSpec, ListItem } from '../config/types';
 
 // Minimal shape of the ``useIntl()`` result we depend on — keeps this module
 // free of an intl package import.
@@ -25,7 +25,7 @@ const toGB = (v?: string | number) =>
 
 const buildResourcesData = (
   instanceType: {
-    spec: InstanceTypeSpec;
+    spec: InstanceTypeSnapshotSpec;
   },
   options: {
     count: number;
@@ -49,8 +49,12 @@ const buildResourcesData = (
   return {};
 };
 
+// Memory (VRAM) percentage for a sliced instance; 0 when not sliced.
+const getSliceMemoryPercentage = (record: ListItem) =>
+  _.toNumber(record.spec?.resources?.acceleratorSlicedMemoryPercentage) || 0;
+
 const formatResources = (
-  instanceTypeSpec: { spec: InstanceTypeSpec },
+  instanceTypeSpec: { spec: InstanceTypeSnapshotSpec },
   record: ListItem
 ) => {
   const resources = buildResourcesData(instanceTypeSpec, {
@@ -71,9 +75,40 @@ const formatResources = (
     };
   }
 
+  const sliceMemoryPercentage = getSliceMemoryPercentage(record);
+
+  // Sliced: CPU / RAM carry the already-scaled values on spec.resources —
+  // whole cores / whole Gi for instances created by the current form; parse
+  // (instead of echoing the raw quantity) so legacy instances persisted as
+  // millicores / Mi (e.g. "400m" / "1638Mi") render as whole units too. VRAM
+  // is the per-card memory scaled by the memory percentage (floored, min 1) —
+  // not the whole card's size.
+  if (sliceMemoryPercentage > 0) {
+    const vramGi = parseQuantityToGi(instanceTypeSpec.spec?.memory)?.value;
+    const vram =
+      vramGi != null
+        ? `${Math.max(1, _.floor((vramGi * sliceMemoryPercentage) / 100))} GB`
+        : undefined;
+    const cpuCores = ceilMilliToCore(
+      _.toString(record.spec?.resources?.cpu) || null
+    )?.cores;
+    const ramGi = parseQuantityToGi(
+      _.toString(record.spec?.resources?.ram) || null
+    )?.value;
+
+    return {
+      cpu: cpuCores != null ? `${Math.max(1, cpuCores)} vCPU` : '-',
+      ram: ramGi != null ? `${Math.max(1, ramGi)} GB` : '-',
+      vram,
+      localStorage: record.spec?.resources?.localStorage
+        ? toGB(record.spec?.resources?.localStorage)
+        : undefined
+    };
+  }
+
   // VRAM = per-card GPU memory (a single card's size; not aggregated across
   // cards — the model's marquee spec).
-  const vram = formatMemoryDisplay((instanceTypeSpec.spec as any)?.memory);
+  const vram = formatMemoryDisplay(instanceTypeSpec.spec?.memory ?? undefined);
 
   return {
     cpu: resources.cpu ? `${resources.cpu} vCPU` : '-',
@@ -99,7 +134,7 @@ export const renderInstanceType = (
     // Types breakdown only wants CPU + RAM, for example.
     categories?: SpecCategory[];
     // Override the primary label (default: derived "<product> x <count>" /
-    // "CPU Only"). The Instance Types breakdown keeps its plain product name.
+    // "CPU-only"). The Instance Types breakdown keeps its plain product name.
     title?: string;
   }
 ) => {
@@ -108,11 +143,19 @@ export const renderInstanceType = (
     parseJsonSafe<any>(record?.description || '{}', {}).spec || {};
   const resources = formatResources({ spec: description }, record);
   const accelerator = record.spec?.resources?.accelerator;
+  const sliceMemoryPercentage = getSliceMemoryPercentage(record);
+  const isSliced = description.acceleratable && sliceMemoryPercentage > 0;
+  // Type label (primary cell label and the popover's "Type" row) prefers the
+  // user-defined displayName persisted in the description snapshot, falling
+  // back to the hardware product.
+  const typeLabel = description.displayName || description.product;
   const title =
     options.title ??
     (description.acceleratable
-      ? `${description.product} x ${accelerator}`
+      ? isSliced
-      : 'CPU Only');
+        ? `${typeLabel} (${sliceMemoryPercentage}%)`
+        : `${typeLabel} x ${accelerator}`
+      : description.displayName || 'CPU-only');
 
   const volume = (record.spec as any)?.volume;
   // Spec popover grouped by category (GPU / CPU / Memory / Disk), mirroring
@@ -131,13 +174,19 @@ export const renderInstanceType = (
       icon: 'icon-gpu',
       name: 'GPU',
       rows: [
-        [
+        // Sliced instances show the ratio instead of a card count (always 1).
-          intl.formatMessage({ id: 'gpuservice.table.count' }),
+        isSliced
-          accelerator ? `${accelerator}` : undefined
+          ? [
-        ],
+              intl.formatMessage({ id: 'gpuservice.instance.sliced' }),
+              `${sliceMemoryPercentage}%`
+            ]
+          : [
+              intl.formatMessage({ id: 'gpuservice.table.count' }),
+              accelerator ? `${accelerator}` : undefined
+            ],
         [
           intl.formatMessage({ id: 'gpuservice.instance.section.type' }),
-          description.product
+          typeLabel
         ],
         [
           intl.formatMessage({ id: 'gpuservice.instance.memory' }),
@@ -209,7 +258,7 @@ const mibToGiQuantity = (mib?: number): string | undefined =>
 export interface InstanceTypeMiB {
   name?: string;
   product?: string;
-  // accelerator (GPU card) count; 0/undefined → CPU-only ("CPU Only").
+  // accelerator (GPU card) count; 0/undefined → CPU-only.
   gpuCount?: number;
   // Per-card values.
   unitCpuMilli?: number;

src/pages/gpu-service/templates/components/template-card.tsx

@@ -56,7 +56,7 @@ const matchImageLogo = (
   isDark: boolean
 ): { logo: string; type: string } | null => {
   if (!image) return null;
-  const logoMap = imageLogoLightMap;
+  const logoMap = isDark ? imageLogoDarkMap : imageLogoLightMap;
   const lower = image.toLowerCase();
   let matched: keyof typeof logoMap | null = null;
   let earliest = Infinity;

src/pages/gpu-service/utils.ts

@@ -1,5 +1,17 @@
 import _ from 'lodash';
 
+// Manufacturer display: most vendors read best all-caps (NVIDIA, AMD), but a
+// few read better capitalized (Intel). Shared by the instance-type list and the
+// create-instance drawer so both render the vendor identically.
+const CapitalizedVendors = ['intel'];
+
+export const formatManufacturer = (manufacturer?: string | null): string => {
+  if (!manufacturer) return '';
+  return CapitalizedVendors.includes(manufacturer.toLowerCase())
+    ? _.capitalize(manufacturer)
+    : _.toUpper(manufacturer);
+};
+
 export const omitPathParams = <T extends Record<string, any>>(
   params: T
 ): Omit<T, 'namespace' | 'clusterID'> => {

src/pages/usage/apis/resource.ts

@@ -93,7 +93,7 @@ export interface ResourceBreakdownItem extends ResourceBreakdownSummary {
   unit_memory_mib?: number;
   vram_mib?: number;
   // Instance totals (requested cpu/ram) — the real size, so CPU instance types
-  // show "CPU Only · 2 vCPU · 4 GB" instead of just the per-unit spec.
+  // show "CPU-only · 2 vCPU · 4 GB" instead of just the per-unit spec.
   cpu_milli?: number;
   memory_mib?: number;
   // Per-instance rows also carry the card count + ephemeral disk so the
@@ -382,7 +382,7 @@ function flattenItem(
   if (it.creator_deleted != null) flat.user_deleted = !!it.creator_deleted;
   // Instance-type grouped trend: the series label (``group``) defaults to the
   // raw flavor slug. Instance Types are grouped by actual shape, so label each
-  // series by that shape — "<product> x <cards>" / "CPU Only · 3 vCPU · 6 GB" —
+  // series by that shape — "<product> x <cards>" / "CPU-only · 3 vCPU · 6 GB" —
   // matching the table and keeping every shape a distinct series (#5700).
   // ``groupBy`` is the unmapped frontend dimension; the instance-type axis is
   // ``gpu_type`` (→ backend ``instance_type`` via GROUP_BY_MAP).

src/pages/usage/instances-tab/tables/use-instances-columns.tsx

@@ -39,7 +39,7 @@ const useInstancesColumns = (groupKey: GroupKey) => {
       }
     ];
     // Instance Types breakdown: the pretty product name (or flavor slug for
-    // older rows; "CPU Only" when no GPU cards) plus a CPU + RAM spec popover —
+    // older rows; "CPU-only" when no GPU cards) plus a CPU + RAM spec popover —
     // rendered through the canonical renderer so the formatting matches the GPU
     // Instances list, but limited to the CPU/RAM categories.
     const instanceTypeColType = {
@@ -64,7 +64,7 @@ const useInstancesColumns = (groupKey: GroupKey) => {
             intl,
             categories: ['cpu', 'ram'],
             // Each row is one shape: GPU "<product> x <cards>", CPU
-            // "CPU Only · <spec>".
+            // "CPU-only · <spec>".
             title: instanceTypeSeriesLabel(row)
           }
         );
@@ -95,7 +95,7 @@ const useInstancesColumns = (groupKey: GroupKey) => {
             persistentMib: row.persistent_mib
           }),
           // Label by shape directly (consistent with the Instance Types
-          // column); avoids renderInstanceType's "CPU Only" fallback when a
+          // column); avoids renderInstanceType's "CPU-only" fallback when a
           // GPU row has vram but a missing/zero gpu_count.
           { intl, title: instanceTypeSeriesLabel(row) }
         );

src/pages/usage/utils/format-instance-type.ts

@@ -32,16 +32,16 @@ export const formatCpuSpec = (
   return parts.join(' · ');
 };
 
-// CPU instance-type label: "CPU Only" plus its real size when known, e.g.
+// CPU instance-type label: "CPU-only" plus its real size when known, e.g.
-// "CPU Only · 2 vCPU · 4 GB". Used by both the table column and the trend
+// "CPU-only · 2 vCPU · 4 GB". Used by both the table column and the trend
 // legend so they read identically.
 export const cpuOnlyLabel = (row?: Partial<ResourceBreakdownItem>): string => {
   const spec = formatCpuSpec(row?.cpu_milli, row?.memory_mib);
-  return spec ? `CPU Only · ${spec}` : 'CPU Only';
+  return spec ? `CPU-only · ${spec}` : 'CPU-only';
 };
 
 // Instance Types are grouped by actual shape, so each row is one concrete
-// type: a GPU shows "<product> x <cards>", a CPU shows "CPU Only · <spec>".
+// type: a GPU shows "<product> x <cards>", a CPU shows "CPU-only · <spec>".
 // One label for the table column and the trend legend so they read the same
 // and each shape is a distinct series. (" x " matches the GPU Instances list.)
 export const instanceTypeSeriesLabel = (