From 58ed4dbda0b906ca024c3e53bf2a76fc751acd44 Mon Sep 17 00:00:00 2001
From: agatha197 <kimsujin@lablup.com>
Date: Tue, 5 Aug 2025 19:13:32 +0900
Subject: [PATCH] feat(FR-1318): add button to start model service after
 cloning folder

- Add ModelTryContentButton to ModelCardModal with run model functionality
- Implement folder cloning and service creation workflow
- Add validation for model-definition.yaml and service-definition.toml files
- Support both cloning new folders and using existing folders
- Add proper error handling and user confirmation dialogs
- Update internationalization files with new translation keys
---
 react/src/components/FolderExplorer.tsx       |   9 +
 react/src/components/ModelCardModal.tsx       |  27 +-
 .../src/components/ModelTryContentButton.tsx  | 824 ++++++++++--------
 react/src/hooks/useBAINotification.tsx        |   2 +
 resources/i18n/de.json                        |  14 +
 resources/i18n/el.json                        |  14 +
 resources/i18n/en.json                        |  13 +
 resources/i18n/es.json                        |  14 +
 resources/i18n/fi.json                        |  14 +
 resources/i18n/fr.json                        |  14 +
 resources/i18n/id.json                        |  14 +
 resources/i18n/it.json                        |  14 +
 resources/i18n/ja.json                        |  14 +
 resources/i18n/ko.json                        |  13 +
 resources/i18n/mn.json                        |  14 +
 resources/i18n/ms.json                        |  14 +
 resources/i18n/pl.json                        |  14 +
 resources/i18n/pt-BR.json                     |  14 +
 resources/i18n/pt.json                        |  14 +
 resources/i18n/ru.json                        |  14 +
 resources/i18n/th.json                        |  14 +
 resources/i18n/tr.json                        |  14 +
 resources/i18n/vi.json                        |  14 +
 resources/i18n/zh-CN.json                     |  14 +
 resources/i18n/zh-TW.json                     |   7 +
 resources/model_card_metadata.json            |   2 +-
 26 files changed, 791 insertions(+), 358 deletions(-)

diff --git a/react/src/components/FolderExplorer.tsx b/react/src/components/FolderExplorer.tsx
index e56d55a8cb..fdde7520f6 100644
--- a/react/src/components/FolderExplorer.tsx
+++ b/react/src/components/FolderExplorer.tsx
@@ -39,6 +39,15 @@ export interface FolderExplorerElement extends HTMLDivElement {
   handleUpload: (name: 'file' | 'folder') => void;
 }
 
+export interface FileItem {
+  name: string;
+  type: string;
+  size: number;
+  mode: string;
+  created: string;
+  modified: string;
+}
+
 interface FolderExplorerProps extends BAIModalProps {
   vfolderID: string;
   onRequestClose: () => void;
diff --git a/react/src/components/ModelCardModal.tsx b/react/src/components/ModelCardModal.tsx
index 8d786657d3..c5e0e4a6ae 100644
--- a/react/src/components/ModelCardModal.tsx
+++ b/react/src/components/ModelCardModal.tsx
@@ -3,7 +3,7 @@ import { useBackendAIImageMetaData } from '../hooks';
 import { useModelCardMetadata } from '../hooks/useModelCardMetadata';
 import ModelCardChat from './ModelCardChat';
 import ModelCloneModal from './ModelCloneModal';
-// import ModelTryContentButton from './ModelTryContentButton';
+import ModelTryContentButton from './ModelTryContentButton';
 import ResourceNumber from './ResourceNumber';
 import { BankOutlined, FileOutlined, CopyOutlined } from '@ant-design/icons';
 import {
@@ -17,6 +17,7 @@ import {
   Typography,
   theme,
   Skeleton,
+  Tooltip,
 } from 'antd';
 import { BAIFlex, BAIModal, BAIModalProps } from 'backend.ai-ui';
 import dayjs from 'dayjs';
@@ -112,16 +113,22 @@ const ModelCardModal: React.FC<ModelCardModalProps> = ({
             : '90%'
       }
       footer={[
-        // FIXME: ModelTryContentButton is not working properly
-        // It should be fixed in the future.
         // This button is used to clone-and-create/create the model service with the content of the model card.
-        /*<ModelTryContentButton
-          vfolderNode={model_card?.vfolder_node || null}
-          modelStorageHost={model_card?.vfolder?.host as string}
-          modelCardMetadata={model || null}
-          modelName={model_card?.name as string}
-          key="try"
-        />,*/
+        <Suspense
+          key="model-try-content-button"
+          fallback={
+            <Tooltip title={t('modelStore.CheckingSettings')}>
+              <Button loading disabled />
+            </Tooltip>
+          }
+        >
+          <ModelTryContentButton
+            vfolderNode={model_card?.vfolder_node || null}
+            modelStorageHost={model_card?.vfolder?.host ?? ''}
+            modelName={model_card?.name ?? ''}
+            key="try"
+          />
+        </Suspense>,
         <Button
           key="clone"
           type="primary"
diff --git a/react/src/components/ModelTryContentButton.tsx b/react/src/components/ModelTryContentButton.tsx
index bd6867a738..9d3bd88668 100644
--- a/react/src/components/ModelTryContentButton.tsx
+++ b/react/src/components/ModelTryContentButton.tsx
@@ -2,67 +2,360 @@ import { ModelTryContentButtonVFolderFragment$key } from '../__generated__/Model
 import { ModelTryContentButtonVFolderNodeListQuery } from '../__generated__/ModelTryContentButtonVFolderNodeListQuery.graphql';
 import {
   baiSignedRequestWithPromise,
-  compareNumberWithUnits,
   generateRandomString,
   useBaiSignedRequestWithPromise,
 } from '../helper';
 import {
+  INITIAL_FETCH_KEY,
   useCurrentDomainValue,
   useSuspendedBackendaiClient,
   useUpdatableState,
 } from '../hooks';
 import { useSuspenseTanQuery, useTanMutation } from '../hooks/reactQueryAlias';
-import { useSetBAINotification } from '../hooks/useBAINotification';
+import {
+  useSetBAINotification,
+  useBAINotificationState,
+} from '../hooks/useBAINotification';
 import {
   useCurrentProjectValue,
   useCurrentResourceGroupValue,
 } from '../hooks/useCurrentProject';
-import { ModelCard } from '../hooks/useModelCardMetadata';
+import { FileItem } from './FolderExplorer';
 import {
   ServiceCreateType,
   ServiceLauncherFormValue,
 } from './ServiceLauncherPageContent';
-import { Button } from 'antd';
-import { ESMClientErrorResponse } from 'backend.ai-ui';
+import { PlayCircleOutlined } from '@ant-design/icons';
+import { App, Button, Tooltip } from 'antd';
+import {
+  toLocalId,
+  compareNumberWithUnits,
+  ESMClientErrorResponse,
+} from 'backend.ai-ui';
 import _ from 'lodash';
-import React from 'react';
-import { useTranslation } from 'react-i18next';
+import React, { useRef, useEffect } from 'react';
+import { Trans, useTranslation } from 'react-i18next';
 import { graphql, useFragment, useLazyLoadQuery } from 'react-relay';
+import { useCurrentUserRole } from 'src/hooks/backendai';
 
 interface ModelTryContentButtonProps {
   modelStorageHost?: string;
-  modelCardMetadata?: ModelCard | null;
   modelName?: string;
-  title?: string;
   vfolderNode: ModelTryContentButtonVFolderFragment$key | null;
 }
 
+interface CloneVFolderInput {
+  permission: string;
+  target_host?: string;
+  target_name: string;
+  usage_mode: string;
+  cloneable?: boolean;
+}
+
+interface CloneResponse {
+  bgtask_id: string;
+  id: string;
+}
+
+interface ServiceResult {
+  endpoint_id?: string;
+}
+
+const MAX_RETRIES = 12; // 12 retries * 5 seconds = 1 minute max
+const RETRY_INTERVAL = 5000;
+
+// Helper function to create service input
+function createServiceInput(
+  modelName: string,
+  vfolderID: string,
+  resourceGroup: string,
+): ServiceLauncherFormValue {
+  return {
+    serviceName: `${modelName}-${generateRandomString(4)}`,
+    replicas: 1,
+    environments: {
+      environment: '',
+      version: '',
+      image: null,
+    },
+    runtimeVariant: 'vllm',
+    cluster_size: 1,
+    cluster_mode: 'single-node',
+    openToPublic: true,
+    resourceGroup: resourceGroup,
+    resource: {
+      cpu: 4,
+      mem: '32g',
+      accelerator: 10,
+      acceleratorType: 'cuda.shares',
+      shmem: '1g',
+    },
+    vFolderID: vfolderID,
+    modelMountDestination: '/models',
+    modelDefinitionPath: '',
+    mount_id_map: {},
+    envvars: [],
+    enabledAutomaticShmem: false,
+  };
+}
+
 const ModelTryContentButton: React.FC<ModelTryContentButtonProps> = ({
   modelName,
-  modelCardMetadata,
   modelStorageHost,
   vfolderNode,
 }) => {
   const { t } = useTranslation();
-  // const { token } = theme.useToken();
+  const { modal } = App.useApp();
   const baiClient = useSuspendedBackendaiClient();
+  const userRole = useCurrentUserRole();
   const baiRequestWithPromise = useBaiSignedRequestWithPromise();
   const currentDomain = useCurrentDomainValue();
   const currentProject = useCurrentProjectValue();
   const currentResourceGroupByProject = useCurrentResourceGroupValue();
-  const [fetchKey] = useUpdatableState('first');
+  const [fetchKey] = useUpdatableState(INITIAL_FETCH_KEY);
   const { upsertNotification } = useSetBAINotification();
+  const [notifications] = useBAINotificationState();
+
+  const mutationToCreateService = useTanMutation<
+    ServiceResult,
+    {
+      message?: string;
+      error_code?: string;
+    },
+    ServiceLauncherFormValue
+  >({
+    mutationFn: (values) => {
+      const environ: { [key: string]: string } = {};
+      if (values.envvars) {
+        values.envvars.forEach((v) => (environ[v.variable] = v.value));
+      }
+      // These fields are replaced with contents from service-definition.toml
+      const body: ServiceCreateType = {
+        name: values.serviceName,
+        desired_session_count: values.replicas,
+        image:
+          `${values.environments.image?.registry}/${values.environments.image?.name}:${values.environments.image?.tag}` as string,
+        architecture: values.environments.image?.architecture as string,
+        runtime_variant: values.runtimeVariant,
+        group: baiClient.current_group, // current Project Group,
+        domain: currentDomain, // current Domain Group,
+        cluster_size: values.cluster_size,
+        cluster_mode: values.cluster_mode,
+        open_to_public: values.openToPublic,
+        config: {
+          model: values.vFolderID,
+          model_version: 1,
+          model_mount_destination: '/models',
+          environ,
+          scaling_group: currentResourceGroupByProject ?? '',
+          resources: {
+            // FIXME: manually convert to string since server-side only allows [str,str] tuple
+            cpu: values.resource.cpu.toString(),
+            mem: values.resource.mem,
+            ...(values.resource.accelerator > 0
+              ? {
+                  [values.resource.acceleratorType]:
+                    // FIXME: manually convert to string since server-side only allows [str,str] tuple
+                    values.resource.accelerator.toString(),
+                }
+              : undefined),
+          },
+          resource_opts: {
+            shmem:
+              compareNumberWithUnits(values.resource.mem, '4g') > 0 &&
+              compareNumberWithUnits(values.resource.shmem, '1g') < 0
+                ? '1g'
+                : values.resource.shmem,
+          },
+        },
+      };
+      return baiSignedRequestWithPromise({
+        method: 'POST',
+        url: '/services',
+        body,
+        client: baiClient,
+      });
+    },
+  });
+
+  // Helper function to create service notification
+  const createServiceNotificationMsg = (
+    result: ServiceResult,
+    modelId: string,
+    notificationKey: string,
+  ) => {
+    let interval: NodeJS.Timeout | null = null;
+
+    upsertNotification({
+      key: notificationKey,
+      open: true,
+      message: t('modelService.StartingModelService'),
+      description: null,
+      duration: 0,
+      backgroundTask: {
+        promise: new Promise<void>((resolve, reject) => {
+          let progress = 0;
+          let retryCount = 0;
+          interval = setInterval(async () => {
+            try {
+              retryCount++;
+              progress += _.random(2, 5);
+              upsertNotification({
+                key: notificationKey,
+                backgroundTask: {
+                  status: 'pending',
+                  percent: progress > 100 ? 100 : progress,
+                },
+              });
+              const routingStatus = await baiRequestWithPromise({
+                method: 'GET',
+                url: `/services/${result?.endpoint_id}`,
+              });
+
+              // Success: service has active routes
+              if (routingStatus.active_routes?.length > 0) {
+                clearInterval(interval!);
+                return resolve();
+              }
+
+              // Timeout: exceeded maximum retries
+              if (retryCount >= MAX_RETRIES) {
+                clearInterval(interval!);
+                return reject(
+                  new Error(t('modelService.ModelServiceFailedToStart')),
+                );
+              }
+            } catch (error) {
+              clearInterval(interval!);
+              return reject(error);
+            }
+          }, RETRY_INTERVAL);
+        }),
+        cleanup: () => {
+          if (interval) {
+            clearInterval(interval);
+            interval = null;
+          }
+        },
+        onChange: {
+          pending: {
+            message: t('modelService.StartingModelService'),
+            description: null,
+          },
+          resolved: {
+            duration: 0,
+            open: true,
+            key: notificationKey,
+            backgroundTask: {
+              status: 'resolved',
+              percent: 100,
+            },
+            message: t('modelService.StartingModelService'),
+            description: null,
+            to: `/chat?${new URLSearchParams({
+              endpointId: result?.endpoint_id ?? '',
+              modelId: modelId,
+            }).toString()}`,
+            toText: t('modelService.PlayYourModelNow'),
+          },
+          rejected: {
+            duration: 0,
+            key: notificationKey,
+            backgroundTask: {
+              status: 'rejected',
+              percent: 99,
+            },
+            message: t('modelService.StartingModelService'),
+            description: null,
+            to: `/serving/${result?.endpoint_id}`,
+            toText: t('modelService.GoToServiceDetailPage'),
+          },
+        },
+        status: 'pending',
+        percent: 0,
+      },
+    });
+  };
+
+  // Track clone completion to trigger service creation
+  const pendingCloneRef = useRef<{
+    randomTargetName: string;
+    clonedFolderId: string;
+    modelId: string;
+  } | null>(null);
+
+  // Listen to clone notification completion and start service creation
+  useEffect(() => {
+    // Skip if no pending clone or mutation is already running
+    if (!pendingCloneRef.current || mutationToCreateService.isPending) return;
+
+    const cloneNotificationKey = `modelStore.clone.${pendingCloneRef.current.randomTargetName}`;
+    const cloneNotification = _.find(notifications, {
+      key: cloneNotificationKey,
+    });
+
+    if (cloneNotification?.backgroundTask?.status === 'resolved') {
+      const { randomTargetName, clonedFolderId, modelId } =
+        pendingCloneRef.current;
+
+      // Clear the ref BEFORE starting mutation to prevent duplicate execution
+      pendingCloneRef.current = null;
+
+      // Start service creation
+      mutationToCreateService.mutate(
+        createServiceInput(
+          modelName ?? '',
+          clonedFolderId,
+          currentResourceGroupByProject as string,
+        ),
+        {
+          onSuccess: (result: ServiceResult) => {
+            // Close the clone notification
+            upsertNotification({
+              key: cloneNotificationKey,
+              open: false,
+            });
+            // Create service notification with different key
+            createServiceNotificationMsg(
+              result,
+              modelId,
+              `modelStore.create.${randomTargetName}`,
+            );
+          },
+          onError: (error) => {
+            // Close the clone notification
+            upsertNotification({
+              key: cloneNotificationKey,
+              open: false,
+            });
+            // Show service creation error with different key
+            upsertNotification({
+              key: `modelStore.create.${randomTargetName}`,
+              open: true,
+              message: t('modelService.ModelServiceFailedToStart'),
+              description: error?.message || null,
+              backgroundTask: {
+                status: 'rejected',
+                percent: 0,
+              },
+            });
+          },
+        },
+      );
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [notifications, modelName, currentResourceGroupByProject]);
 
   const { vfolder_nodes } =
     useLazyLoadQuery<ModelTryContentButtonVFolderNodeListQuery>(
       graphql`
         query ModelTryContentButtonVFolderNodeListQuery(
-          $projectId: UUID!
+          $scope_id: ScopeField
           $filter: String
           $permission: VFolderPermissionValueField
         ) {
           vfolder_nodes(
-            project_id: $projectId
+            scope_id: $scope_id
             filter: $filter
             permission: $permission
           ) {
@@ -79,12 +372,13 @@ const ModelTryContentButton: React.FC<ModelTryContentButtonProps> = ({
         }
       `,
       {
-        projectId: currentProject.id,
-        filter: `usage_mode == "model" & status != "DELETE_PENDING" & status != "DELETE_ONGOING" & status != "DELETE_ERROR" & status != "DELETE_COMPLETE"${modelName ? ` & name ilike "%${modelName}%"` : ''}`,
+        scope_id: `project:${currentProject.id}`,
+        filter: `usage_mode == "model" & status != "DELETE_PENDING" & status != "DELETE_ONGOING" & status != "DELETE_ERROR" & status != "DELETE_COMPLETE"${modelName ? ` & name like "%${modelName}%"` : ''}`,
         permission: 'read_attribute',
       },
       {
-        fetchPolicy: 'network-only',
+        fetchPolicy:
+          fetchKey === INITIAL_FETCH_KEY ? 'store-and-network' : 'network-only',
         fetchKey,
       },
     );
@@ -102,12 +396,43 @@ const ModelTryContentButton: React.FC<ModelTryContentButtonProps> = ({
       vfolderNode,
     );
 
-  console.log('ModelTryContentButton Debug:', {
-    currentProject: currentProject,
-    modelName: modelName,
-    vfolder_nodes: vfolder_nodes,
+  // Get the first available vfolder from the query results
+  const availableVFolder = vfolder_nodes?.edges?.[0]?.node;
+
+  // Check if definition files exist using query
+  const { data: folderFiles } = useSuspenseTanQuery<Array<FileItem>>({
+    queryKey: [
+      'ModelTryContentButton',
+      'folderFiles',
+      availableVFolder?.row_id || modelStoreVFolder?.row_id,
+    ],
+    queryFn: () => {
+      const folderId = availableVFolder?.row_id || modelStoreVFolder?.row_id;
+      if (!folderId) {
+        return [];
+      }
+      return baiClient.vfolder
+        .list_files('.', folderId)
+        .then((res: { items: Array<FileItem> }) => {
+          return res.items || [];
+        });
+    },
+    staleTime: 1000,
   });
 
+  // Check if required definition files exist in the folder files
+  const hasModelDefinition = _.some(
+    folderFiles,
+    (file: { name?: string }) => file?.name === 'model-definition.yaml',
+  );
+  const hasServiceDefinition = _.some(
+    folderFiles,
+    (file: { name?: string }) => file?.name === 'service-definition.toml',
+  );
+
+  // Both files are required for the button to be enabled
+  const definitionFilesExist = hasModelDefinition && hasServiceDefinition;
+
   /* FIXME: need to check if the modelStorageHost is accessible & cloneable
   const { data: accessibleStorageHostList } = useSuspenseTanQuery({
     queryKey: ['accessibleStorageHostList', fetchKey, currentProject.id],
@@ -129,140 +454,38 @@ const ModelTryContentButton: React.FC<ModelTryContentButtonProps> = ({
   */
 
   const mutationToClone = useTanMutation<
-    {
-      bgtask_id: string;
-      id: string;
-    },
+    CloneResponse,
     ESMClientErrorResponse,
     {
-      input: any;
+      input: CloneVFolderInput;
       name: string;
     }
   >({
-    // @ts-ignore
-    mutationFn: ({ input, name }: { input: any; name: string }) => {
+    mutationFn: ({
+      input,
+      name,
+    }: {
+      input: CloneVFolderInput;
+      name: string;
+    }) => {
       return baiClient.vfolder.clone(input, name);
     },
   });
 
-  //@ts-ignore
-  const { data: availableRuntimes } = useSuspenseTanQuery<{
-    runtimes: { name: string; human_readable_name: string }[];
-  }>({
-    queryKey: ['baiClient.modelService.runtime.list'],
-    //@ts-ignore
-    queryFn: () => {
-      return baiClient.isManagerVersionCompatibleWith('24.03.5')
-        ? baiRequestWithPromise({
-            method: 'GET',
-            url: `/services/_/runtimes`,
-          })
-        : Promise.resolve({
-            runtimes: _.map(availableRuntimes?.runtimes, (runtime) => {
-              return {
-                value: runtime.name,
-                label: runtime.human_readable_name,
-              };
-            }),
-          });
-    },
-    staleTime: 1000,
-  });
-
-  const mutationToCreateService = useTanMutation<
-    unknown,
-    {
-      message?: string;
-    },
-    ServiceLauncherFormValue
-  >({
-    mutationFn: (values) => {
-      const environ: { [key: string]: string } = {};
-      if (values.envvars) {
-        values.envvars.forEach((v) => (environ[v.variable] = v.value));
-      }
-      const body: ServiceCreateType = {
-        name: values.serviceName,
-        desired_session_count: values.replicas,
-        image:
-          `${values.environments.image?.registry}/${values.environments.image?.name}:${values.environments.image?.tag}` as string,
-        architecture: values.environments.image?.architecture as string,
-        runtime_variant: values.runtimeVariant,
-        group: baiClient.current_group, // current Project Group,
-        domain: currentDomain, // current Domain Group,
-        cluster_size: values.cluster_size,
-        cluster_mode: values.cluster_mode,
-        open_to_public: values.openToPublic,
-        config: {
-          model: values.vFolderID,
-          model_version: 1,
-          model_mount_destination: '/models',
-          environ,
-          scaling_group: currentResourceGroupByProject ?? '',
-          resources: {
-            // FIXME: manually convert to string since server-side only allows [str,str] tuple
-            cpu: values.resource.cpu.toString(),
-            mem: values.resource.mem,
-            ...(values.resource.accelerator > 0
-              ? {
-                  [values.resource.acceleratorType]:
-                    // FIXME: manually convert to string since server-side only allows [str,str] tuple
-                    values.resource.accelerator.toString(),
-                }
-              : undefined),
-          },
-          resource_opts: {
-            shmem:
-              compareNumberWithUnits(values.resource.mem, '4g') > 0 &&
-              compareNumberWithUnits(values.resource.shmem, '1g') < 0
-                ? '1g'
-                : values.resource.shmem,
-          },
-        },
-      };
-      return baiSignedRequestWithPromise({
-        method: 'POST',
-        url: '/services',
-        body,
-        client: baiClient,
+  // Main function to handle folder clone or service creation
+  const cloneOrCreateModelService = async (runtimeVariant: string) => {
+    // Validate modelName
+    if (!modelName?.trim()) {
+      upsertNotification({
+        key: 'modelStore.error.noModelName',
+        open: true,
+        message: t('modelStore.InvalidModelName'),
+        description: t('modelStore.ModelNameIsRequired'),
+        type: 'error',
       });
-    },
-  });
-
-  const getServiceInputByModelNameAndVFolderId = (
-    modelName: string,
-    vfolderID: string,
-  ): ServiceLauncherFormValue => {
-    return {
-      serviceName: `${modelName}-${generateRandomString(4)}`,
-      replicas: 1,
-      environments: modelCardMetadata?.environments || {
-        environment: '',
-        version: '',
-        image: null,
-      },
-      runtimeVariant: modelCardMetadata?.runtimeVariant || 'custom',
-      cluster_size: 1,
-      cluster_mode: 'single-node',
-      openToPublic: true,
-      resourceGroup: currentResourceGroupByProject as string,
-      resource: modelCardMetadata?.resource || {
-        cpu: 4,
-        mem: '32g',
-        accelerator: 10,
-        acceleratorType: 'cuda.shares',
-        shmem: '1g',
-      },
-      vFolderID: vfolderID, // TODO: add cloned folder result
-      modelMountDestination: '/models',
-      modelDefinitionPath: '',
-      mount_id_map: {},
-      envvars: modelCardMetadata?.envvars || [],
-      enabledAutomaticShmem: false,
-    };
-  };
+      return;
+    }
 
-  const cloneOrCreateModelService = (runtimeVariant: string) => {
     let modelId = 'vllm-model';
     switch (runtimeVariant) {
       case 'vllm':
@@ -275,25 +498,51 @@ const ModelTryContentButton: React.FC<ModelTryContentButtonProps> = ({
         modelId = 'custom';
         break;
     }
-    if (!vfolder_nodes || vfolder_nodes.edges.length === 0) {
+
+    const randomTargetName = `${modelName}-${generateRandomString(4)}`;
+
+    if (!availableVFolder) {
+      // No similar folder found - need to clone
+      const confirmed = await modal.confirm({
+        title: t('modelStore.CloneRequired'),
+        content: (
+          <Trans
+            i18nKey={t('modelService.CloneModelFolderConfirm', {
+              folderName: randomTargetName,
+            })}
+          />
+        ),
+      });
+
+      if (!confirmed) return;
+
+      // Clone the model folder
       mutationToClone.mutate(
         {
           input: {
             permission: 'wd', // write-delete permission
             target_host: modelStorageHost, // lowestUsageHost, // clone to accessible and lowest usage storage host
-            target_name: `${modelCardMetadata?.serviceName || modelName}`, // TODO: add suffix to avoid name conflict
+            target_name: randomTargetName,
             usage_mode: 'model',
           },
           name: modelStoreVFolder?.row_id ?? '', // TODO: set the name of the cloned folder
         },
         {
           onSuccess: (data) => {
+            // Store clone info for service creation after completion
+            pendingCloneRef.current = {
+              randomTargetName,
+              clonedFolderId: data.id,
+              modelId,
+            };
+
             upsertNotification({
-              key: `modelStore.clone. + ${modelName}-1`,
+              key: `modelStore.clone.${randomTargetName}`,
               open: true,
+              message: t('data.folders.FolderClonePending'),
               onClose: () => {
                 upsertNotification({
-                  key: `modelStore.clone. + ${modelName}-1`,
+                  key: `modelStore.clone.${randomTargetName}`,
                   open: false,
                   backgroundTask: {
                     percent: 0,
@@ -303,237 +552,118 @@ const ModelTryContentButton: React.FC<ModelTryContentButtonProps> = ({
                   toText: '',
                 });
               },
-              extraDescription: '(1 / 2)',
               backgroundTask: {
                 status: 'pending',
                 percent: 50,
                 taskId: data.bgtask_id,
                 onChange: {
-                  pending: t('data.folders.DownloadingModel'),
-                  resolved: (cloneData: any, _notification: any) => {
-                    mutationToCreateService.mutate(
-                      getServiceInputByModelNameAndVFolderId(
-                        modelCardMetadata?.serviceName ?? '',
-                        cloneData?.id || data?.id,
-                      ),
-                      {
-                        onSuccess: (result: any) => {
-                          upsertNotification({
-                            key: result?.endpoint_id,
-                            open: true,
-                            message: t('modelService.StartingModelService'),
-                            duration: 0,
-                            backgroundTask: {
-                              promise: new Promise<void>((resolve, reject) => {
-                                let progress = 0;
-                                const interval = setInterval(async () => {
-                                  try {
-                                    progress += _.random(2, 5);
-                                    upsertNotification({
-                                      key: result?.endpoint_id,
-                                      backgroundTask: {
-                                        status: 'pending',
-                                        percent:
-                                          progress > 100 ? 100 : progress,
-                                      },
-                                    });
-                                    const routingStatus =
-                                      await baiRequestWithPromise({
-                                        method: 'GET',
-                                        url: `/services/${result?.endpoint_id}`,
-                                      });
-                                    if (
-                                      routingStatus.active_routes.length > 0
-                                    ) {
-                                      clearInterval(interval);
-                                      return resolve();
-                                    }
-                                    if (progress >= 100) {
-                                      throw new Error(
-                                        t(
-                                          'modelService.ModelServiceFailedToStart',
-                                        ),
-                                      );
-                                    }
-                                  } catch (error) {
-                                    clearInterval(interval);
-                                    return reject();
-                                  }
-                                }, 5000);
-                              }),
-                              status: 'pending',
-                              percent: 0,
-                              onChange: {
-                                pending: t('modelService.StartingModelService'),
-                                resolved: (_data, _notification) => ({
-                                  open: true,
-                                  duration: 0,
-                                  key: result?.endpoint_id,
-                                  backgroundTask: {
-                                    status: 'resolved',
-                                    percent: 100,
-                                  },
-                                  message: '',
-                                  to: `/chat?${new URLSearchParams({
-                                    endpointId: result?.endpoint_id ?? '',
-                                    modelId: 'vllm-model',
-                                  }).toString()}`,
-                                  toText: t('modelService.PlayYourModelNow'),
-                                }),
-                                rejected: (_data, _notification) => ({
-                                  key: result?.endpoint_id,
-                                  duration: 0,
-                                  backgroundTask: {
-                                    status: 'rejected',
-                                    percent: 99,
-                                  },
-                                  message: '',
-                                  to: `/serving/${result?.endpoint_id}`,
-                                  toText: t(
-                                    'modelService.GoToServiceDetailPage',
-                                  ),
-                                }),
-                              },
-                            },
-                          });
-                        },
-                        onError: () => {
-                          // TODO: show a notification to go to service detail page
-                        },
-                      },
-                    );
-                    return {
-                      duration: 0,
-                      open: true,
-                      key: data?.bgtask_id,
-                      backgroundTask: {
-                        status: 'resolved',
-                        percent: 100,
-                      },
-                      message: '',
-                      to: `/chat?${new URLSearchParams({
-                        endpointId: data?.bgtask_id ?? '',
-                        modelId: 'vllm-model',
-                      }).toString()}`,
-                      toText: t('modelService.PlayYourModelNow'),
-                    };
+                  pending: t('data.folders.FolderClonePending'),
+                  resolved: {
+                    key: `modelStore.clone.${randomTargetName}`,
+                    message: t('data.folders.FolderCloned'),
+                    description: null,
+                    open: true,
+                    duration: 0,
+                    backgroundTask: {
+                      status: 'resolved',
+                      percent: 100,
+                    },
                   },
                   rejected: t('data.folders.FolderCloneFailed'),
                 },
               },
             });
           },
-          onError: () => {
-            // TODO: show a notification for clone error
+          onError: (error) => {
+            upsertNotification({
+              key: `modelStore.clone.${randomTargetName}`,
+              open: true,
+              message: t('data.folders.FolderCloneFailed'),
+              description: error?.message || null,
+              backgroundTask: {
+                status: 'rejected',
+                percent: 0,
+              },
+            });
           },
         },
       );
     } else {
-      const availableVFolder = vfolder_nodes.edges[0]?.node;
+      // Similar folder exists - skip cloning and directly create service
+      const confirmed = await modal.confirm({
+        title: t('modelService.AFolderWithSimilarNameExists'),
+        content: t('modelService.UseExistingFolderConfirm', {
+          folderName: availableVFolder.name,
+        }),
+      });
+
+      if (!confirmed) {
+        return;
+      }
+
+      // Create service with existing folder (skip cloning)
       mutationToCreateService.mutate(
-        getServiceInputByModelNameAndVFolderId(
-          modelCardMetadata?.serviceName ?? '',
-          availableVFolder?.id || '',
+        createServiceInput(
+          modelName,
+          toLocalId(availableVFolder?.id) || '',
+          currentResourceGroupByProject as string,
         ),
         {
-          onSuccess: (result: any) => {
+          onSuccess: (result: ServiceResult) => {
+            createServiceNotificationMsg(
+              result,
+              modelId,
+              `modelStore.create.${randomTargetName}`,
+            );
+          },
+          onError: (error) => {
             upsertNotification({
-              key: result?.endpoint_id,
+              key: `modelStore.create.${randomTargetName}`,
               open: true,
-              message: t('modelService.StartingModelService'),
-              duration: 0,
+              message: t('modelService.ModelServiceFailedToStart'),
+              description: error?.message || null,
               backgroundTask: {
-                promise: new Promise<void>((resolve, reject) => {
-                  let progress = 0;
-                  const interval = setInterval(async () => {
-                    try {
-                      progress += _.random(2, 5);
-                      upsertNotification({
-                        key: result?.endpoint_id,
-                        backgroundTask: {
-                          status: 'pending',
-                          percent: progress > 100 ? 100 : progress,
-                        },
-                      });
-                      const routingStatus = await baiRequestWithPromise({
-                        method: 'GET',
-                        url: `/services/${result?.endpoint_id}`,
-                      });
-                      if (routingStatus.active_routes.length > 0) {
-                        clearInterval(interval);
-                        return resolve();
-                      }
-                      if (progress >= 100) {
-                        throw new Error(
-                          t('modelService.ModelServiceFailedToStart'),
-                        );
-                      }
-                    } catch (error) {
-                      clearInterval(interval);
-                      return reject();
-                    }
-                  }, 5000);
-                }),
-                onChange: {
-                  pending: t('modelService.StartingModelService'),
-                  resolved: (_data, _notification) => {
-                    return {
-                      duration: 0,
-                      open: true,
-                      key: result?.endpoint_id,
-                      backgroundTask: {
-                        status: 'resolved',
-                        percent: 100,
-                      },
-                      message: '',
-                      to: `/chat?${new URLSearchParams({
-                        endpointId: result?.endpoint_id ?? '',
-                        modelId: modelId,
-                      }).toString()}`, // PATH to playground page
-                      toText: t('modelService.PlayYourModelNow'),
-                    };
-                  },
-                  rejected: (_data, _notification) => {
-                    return {
-                      duration: 0,
-                      key: result?.endpoint_id,
-                      backgroundTask: {
-                        status: 'rejected',
-                        percent: 99,
-                      },
-                      message: '',
-                      to: `/serving/${result?.endpoint_id}`,
-                      toText: t('modelService.GoToServiceDetailPage'),
-                    };
-                  },
-                },
-                status: 'pending',
+                status: 'rejected',
                 percent: 0,
               },
             });
           },
-          onError: () => {
-            // TODO: show a notification to go to service detail page
-          },
         },
       );
     }
   };
 
   return (
-    <Button
-      type="primary"
-      onClick={() => {
-        cloneOrCreateModelService(
-          modelCardMetadata?.runtimeVariant || 'custom',
-        );
-      }}
-      style={{
-        width: 'auto',
-      }}
+    <Tooltip
+      title={
+        !definitionFilesExist
+          ? !hasModelDefinition && !hasServiceDefinition
+            ? t('modelService.BothDefinitionFilesRequired')
+            : !hasModelDefinition
+              ? t('modelService.ModelDefinitionRequired')
+              : t('modelService.ServiceDefinitionRequired')
+          : ''
+      }
     >
-      {t('modelService.RunThisModel')}
-    </Button>
+      <Button
+        type="primary"
+        disabled={
+          !definitionFilesExist ||
+          mutationToClone.isPending ||
+          mutationToCreateService.isPending
+        }
+        loading={mutationToClone.isPending || mutationToCreateService.isPending}
+        onClick={() => cloneOrCreateModelService('vllm')}
+        style={{
+          width: 'auto',
+          display:
+            !definitionFilesExist && userRole === 'user' ? 'none' : undefined,
+        }}
+        icon={<PlayCircleOutlined />}
+      >
+        {t('modelService.RunThisModel')}
+      </Button>
+    </Tooltip>
   );
 };
 
diff --git a/react/src/hooks/useBAINotification.tsx b/react/src/hooks/useBAINotification.tsx
index 960dde6cfc..804402b0a5 100644
--- a/react/src/hooks/useBAINotification.tsx
+++ b/react/src/hooks/useBAINotification.tsx
@@ -63,6 +63,7 @@ export interface NotificationState
     };
     renderDataMessage?: (message?: string) => React.ReactNode;
     promise?: Promise<unknown> | null;
+    cleanup?: () => void;
   };
   extraDescription?: string | null;
   onCancel?: (() => void) | null;
@@ -149,6 +150,7 @@ export const useBAINotificationEffect = () => {
             });
           })
           .finally(() => {
+            notification.backgroundTask?.cleanup?.();
             listeningPromiseKeysRef.current = _.without(
               listeningPromiseKeysRef.current,
               notification.key,
diff --git a/resources/i18n/de.json b/resources/i18n/de.json
index c5e2ba629c..652ff2f551 100644
--- a/resources/i18n/de.json
+++ b/resources/i18n/de.json
@@ -914,16 +914,19 @@
     "64chars": "(maximal 64 Zeichen)"
   },
   "modelService": {
+    "AFolderWithSimilarNameExists": "Ein Ordner mit einem ähnlichen Namen gibt es bereits",
     "Active": "Aktiv",
     "Active/Total": "Aktiv/Gesamt",
     "AddRules": "Fügen Sie Regeln hinzu",
     "AdditionalMounts": "Zusätzliche Halterungen",
     "AutoScalingRules": "Automatische Skalierungsregeln",
     "BasePath": "Basispfad",
+    "BothDefinitionFilesRequired": "Die modelldefinitions.yaml und die dienste definition.toml-Dateien sind erforderlich.",
     "Cancel": "Stornieren",
     "CannotValidateNow": "Der Dienst kann derzeit nicht validiert werden. \nBitte überprüfen Sie die Ressourcenzuweisung oder andere Konfigurationen.",
     "Chatting": "Chatten",
     "ClearErrors": "Fehler löschen und erneut versuchen",
+    "CloneModelFolderConfirm": "Um den Modelldienst auszuführen, muss der Ordner geklont werden. \nMöchten Sie es als <strong>\"{{folderName}}\"</strong> klonen und den Dienst starten?",
     "Controls": "Kontrolliert",
     "CreatedAt": "Erstellt am",
     "CurrentTime": "Aktuelle Uhrzeit",
@@ -950,7 +953,10 @@
     "GoToServiceDetailPage": "Gehen Sie zur Service -Detail -Seite",
     "Image": "Bild",
     "ModelDefinitionPath": "Pfad der Modelldefinitionsdatei",
+    "ModelDefinitionRequired": "Modelldefinition.yaml-Datei ist erforderlich.",
     "ModelMountDestination": "Mount-Ziel für Modellordner",
+    "ModelServiceCreationHasBeenCanceled": "Die Erstellung des Modelldienstes wurde storniert.",
+    "ModelServiceFailedToStart": "Den Modelldienst nicht starten.",
     "NoExtraMounts": "Keine zusätzlichen Halterungen",
     "NoServiceEndpoint": "Kein Dienst-Endpunkt",
     "NumberOfReplicas": "Anzahl der Replikate",
@@ -973,7 +979,10 @@
     "RuntimeVariant": "Inferenz Laufzeitvariante",
     "SeeContainerLogs": "Siehe Containerprotokolle",
     "ServiceAlreadyExists": "Servicename existiert bereits",
+    "ServiceConfigurationNotValid": "Die Dienstkonfiguration ist ungültig. \nBitte wenden Sie sich an den Administrator.",
     "ServiceCreated": "Der Modelldienst {{ name }} wurde erfolgreich erstellt.",
+    "ServiceDefinitionNotFound": "Service -Definitionsdatei nicht gefunden. \nNur Klonen sind verfügbar.",
+    "ServiceDefinitionRequired": "Service-Definition.toml-Datei ist erforderlich.",
     "ServiceDelegatedFrom": "Der Modelldienst wird von {{ createdUser }} erstellt, aber das Eigentum an der Sitzung wird an {{ sessionOwner }} delegiert.",
     "ServiceEndpoint": "Dienst-Endpunkt",
     "ServiceInfo": "Service-Informationen",
@@ -1006,14 +1015,17 @@
     "TokenGenerationFailed": "Token-Generierung fehlgeschlagen. Bitte versuchen Sie es erneut.",
     "TrafficRatio": "Verkehrsdichte",
     "UpdateService": "Update-Service",
+    "UseExistingFolderConfirm": "Möchten Sie den Dienst mit dem vorhandenen Ordner {{folderName}} starten?",
     "Validate": "Bestätigen",
     "ValidationInfo": "Validierungsinformationen"
   },
   "modelStore": {
     "Author": "Autor",
     "Category": "Kategorien",
+    "CheckingSettings": "Einstellungen überprüfen ...",
     "CloneAsFolder": "Als Ordner klonen",
     "CloneInfo": "Er wird als Ihr Benutzertyp-Ordner geklont.",
+    "CloneRequired": "Klon erforderlich",
     "CloneSuccess": "Die Klonanfrage wurde erfolgreich gesendet.",
     "CloneToFolder": "In einen Ordner klonen",
     "Created": "Erstellt",
@@ -1023,12 +1035,14 @@
     "FolderAlreadyExists": "Ein Ordner mit diesem Namen existiert bereits.",
     "Framework": "Rahmenwerk",
     "HealthCheck": "Gesundheitskontrolle",
+    "InvalidModelName": "Ungültiger Modellname",
     "Label": "Etikett",
     "LastModified": "Zuletzt bearbeitet",
     "MaxRetries": "Max. Wiederholungsversuche",
     "Metadata": "Metadaten",
     "MinResource": "Min. Ressource",
     "Model": "Modell",
+    "ModelNameIsRequired": "Zum Erstellen eines Dienstes ist ein Modellname erforderlich",
     "ModelPath": "Modellpfad",
     "Path": "Weg",
     "Port": "Hafen",
diff --git a/resources/i18n/el.json b/resources/i18n/el.json
index 77120418ae..4abdf08f11 100644
--- a/resources/i18n/el.json
+++ b/resources/i18n/el.json
@@ -911,16 +911,19 @@
     "64chars": "(έως 64 χαρακτήρες)"
   },
   "modelService": {
+    "AFolderWithSimilarNameExists": "Υπάρχει ήδη ένας φάκελος με παρόμοιο όνομα",
     "Active": "Ενεργός",
     "Active/Total": "Ενεργό/Σύνολο",
     "AddRules": "Προσθέστε κανόνες",
     "AdditionalMounts": "Πρόσθετες βάσεις",
     "AutoScalingRules": "Κανόνες αυτόματης κλιμάκωσης",
     "BasePath": "Διαδρομή βάσης",
+    "BothDefinitionFilesRequired": "Τα αρχεία μοντέλων-definition.yaml και service-definition.toml απαιτούνται.",
     "Cancel": "Ματαίωση",
     "CannotValidateNow": "Δεν είναι δυνατή η επικύρωση της υπηρεσίας τώρα. \nΕλέγξτε την κατανομή πόρων ή άλλες διαμορφώσεις.",
     "Chatting": "Συζήτηση",
     "ClearErrors": "Εκκαθάριση σφάλματος και επανάληψη",
+    "CloneModelFolderConfirm": "Για να εκτελέσετε την υπηρεσία μοντέλου, ο φάκελος πρέπει να κλωνοποιηθεί. \nΘα θέλατε να το κλωνοποιήσετε ως <strong>\"{{folderName}}\"</strong> και να ξεκινήσετε την υπηρεσία;",
     "Controls": "Έλεγχοι",
     "CreatedAt": "Δημιουργήθηκε στο",
     "CurrentTime": "Τρέχουσα ώρα",
@@ -947,7 +950,10 @@
     "GoToServiceDetailPage": "Μεταβείτε στη σελίδα λεπτομερειών υπηρεσίας",
     "Image": "Εικόνα",
     "ModelDefinitionPath": "Διαδρομή αρχείου ορισμού μοντέλου",
+    "ModelDefinitionRequired": "Απαιτείται αρχείο μοντέλου-definition.yaml.",
     "ModelMountDestination": "Προσάρτηση προορισμού για φάκελο μοντέλου",
+    "ModelServiceCreationHasBeenCanceled": "Η δημιουργία υπηρεσιών μοντέλου έχει ακυρωθεί.",
+    "ModelServiceFailedToStart": "Αποτυχία εκκίνησης της υπηρεσίας μοντέλου.",
     "NoExtraMounts": "Χωρίς επιπλέον βάσεις",
     "NoServiceEndpoint": "Δεν υπάρχει τελικό σημείο υπηρεσίας",
     "NumberOfReplicas": "Αριθμός αντιγράφων",
@@ -970,7 +976,10 @@
     "RuntimeVariant": "Παραλλαγή χρόνου εκτέλεσης εξαγωγής συμπερασμάτων",
     "SeeContainerLogs": "Βλέπε αρχεία καταγραφής κοντέινερ",
     "ServiceAlreadyExists": "Το όνομα της υπηρεσίας υπάρχει ήδη",
+    "ServiceConfigurationNotValid": "Η διαμόρφωση της υπηρεσίας δεν είναι έγκυρη. \nΕπικοινωνήστε με τον διαχειριστή.",
     "ServiceCreated": "Η υπηρεσία μοντέλου {{ όνομα }} δημιουργήθηκε με επιτυχία.",
+    "ServiceDefinitionNotFound": "Το αρχείο ορισμού υπηρεσιών δεν βρέθηκε. \nΔιατίθεται μόνο κλωνοποίηση.",
+    "ServiceDefinitionRequired": "Απαιτείται αρχείο Service-Definition.toml.",
     "ServiceDelegatedFrom": "Το μοντέλο υπηρεσίας δημιουργείται από τον {{ createdUser }}, αλλά η ιδιοκτησία της συνεδρίας θα ανατεθεί στον {{ sessionOwner }}",
     "ServiceEndpoint": "Τελικό σημείο υπηρεσίας",
     "ServiceInfo": "Πληροφορίες υπηρεσίας",
@@ -1003,14 +1012,17 @@
     "TokenGenerationFailed": "Η δημιουργία του Token απέτυχε. παρακαλώ προσπαθήστε ξανά.",
     "TrafficRatio": "Αναλογία κυκλοφορίας",
     "UpdateService": "Υπηρεσία ενημέρωσης",
+    "UseExistingFolderConfirm": "Θα θέλατε να ξεκινήσετε την υπηρεσία χρησιμοποιώντας το υπάρχον φάκελο {{folderName}};",
     "Validate": "Επικυρώνω",
     "ValidationInfo": "Πληροφορίες επικύρωσης"
   },
   "modelStore": {
     "Author": "Συγγραφέας",
     "Category": "Κατηγορίες",
+    "CheckingSettings": "Ρυθμίσεις ελέγχου ...",
     "CloneAsFolder": "Clone as Folder",
     "CloneInfo": "Θα κλωνοποιηθεί ως φάκελος τύπου χρήστη.",
+    "CloneRequired": "Απαιτείται κλώνος",
     "CloneSuccess": "Η αίτηση κλωνοποίησης έχει σταλεί με επιτυχία.",
     "CloneToFolder": "Κλωνοποίηση σε φάκελο",
     "Created": "Δημιουργήθηκε",
@@ -1020,12 +1032,14 @@
     "FolderAlreadyExists": "Ένας φάκελος με αυτό το όνομα υπάρχει ήδη.",
     "Framework": "Πλαίσιο",
     "HealthCheck": "Ελεγχος υγείας",
+    "InvalidModelName": "Μη έγκυρο όνομα μοντέλου",
     "Label": "Ετικέτα",
     "LastModified": "Τελευταία τροποποίηση",
     "MaxRetries": "Μέγιστες επαναλήψεις",
     "Metadata": "Μεταδεδομένα",
     "MinResource": "Ελάχιστος πόρος",
     "Model": "Μοντέλο",
+    "ModelNameIsRequired": "Το όνομα μοντέλου απαιτείται για τη δημιουργία μιας υπηρεσίας",
     "ModelPath": "Μοντέλο Μονοπάτι",
     "Path": "Μονοπάτι",
     "Port": "Λιμάνι",
diff --git a/resources/i18n/en.json b/resources/i18n/en.json
index 6d50feee90..537f3a515a 100644
--- a/resources/i18n/en.json
+++ b/resources/i18n/en.json
@@ -918,16 +918,19 @@
     "64chars": "(maximum 64 chars)"
   },
   "modelService": {
+    "AFolderWithSimilarNameExists": "A folder with a similar name already exists",
     "Active": "Active",
     "Active/Total": "Active/Total",
     "AddRules": "Add Rules",
     "AdditionalMounts": "Additional Mounts",
     "AutoScalingRules": "Auto Scaling Rules",
     "BasePath": "Base Path",
+    "BothDefinitionFilesRequired": "The model-definition.yaml and service-definition.toml files are needed.",
     "Cancel": "Cancel",
     "CannotValidateNow": "Cannot validate service now. Please check resource allocation or other configurations.",
     "Chatting": "Chatting",
     "ClearErrors": "Clear error and retry",
+    "CloneModelFolderConfirm": "To run the model service, the folder needs to be cloned. Would you like to clone it as <strong>\"{{folderName}}\"</strong> and start the service?",
     "Controls": "Controls",
     "CreatedAt": "Created At",
     "CurrentTime": "Current time",
@@ -954,7 +957,9 @@
     "GoToServiceDetailPage": "Go to service detail page",
     "Image": "Image",
     "ModelDefinitionPath": "Model Definition File Path",
+    "ModelDefinitionRequired": "model-definition.yaml file is needed.",
     "ModelMountDestination": "Mount Destination For Model Folder",
+    "ModelServiceCreationHasBeenCanceled": "Model service creation has been canceled.",
     "ModelServiceFailedToStart": "Failed to start model service.",
     "NoExtraMounts": "No extra mounts",
     "NoServiceEndpoint": "No Service Endpoint",
@@ -978,7 +983,10 @@
     "RuntimeVariant": "Inference Runtime Variant",
     "SeeContainerLogs": "See Container Logs",
     "ServiceAlreadyExists": "Service name already exists",
+    "ServiceConfigurationNotValid": "The service configuration is invalid. Please contact the administrator.",
     "ServiceCreated": "Model service {{ name }} has been created successfully.",
+    "ServiceDefinitionNotFound": "Service definition file not found. Only cloning is available.",
+    "ServiceDefinitionRequired": "service-definition.toml file is needed.",
     "ServiceDelegatedFrom": "Model service is created by {{ createdUser }} but the session ownership will be delegated to {{ sessionOwner }}",
     "ServiceEndpoint": "Service Endpoint",
     "ServiceInfo": "Service Info",
@@ -1011,14 +1019,17 @@
     "TokenGenerationFailed": "Token generation failed. please try again.",
     "TrafficRatio": "Traffic Ratio",
     "UpdateService": "Update Service",
+    "UseExistingFolderConfirm": "Would you like to start the service using the existing {{folderName}} folder?",
     "Validate": "Validate",
     "ValidationInfo": "Validation Info"
   },
   "modelStore": {
     "Author": "Author",
     "Category": "Category",
+    "CheckingSettings": "Checking settings...",
     "CloneAsFolder": "Clone as Folder",
     "CloneInfo": "It will be cloned as your user type folder.",
+    "CloneRequired": "Clone Required",
     "CloneSuccess": "The clone request has been sent successfully.",
     "CloneToFolder": "Clone to a folder",
     "Created": "Created",
@@ -1028,12 +1039,14 @@
     "FolderAlreadyExists": "A folder with this name already exists.",
     "Framework": "Framework",
     "HealthCheck": "Health Check",
+    "InvalidModelName": "Invalid model name",
     "Label": "Label",
     "LastModified": "Last Modified",
     "MaxRetries": "Max Retries",
     "Metadata": "Metadata",
     "MinResource": "Min Resource",
     "Model": "Model",
+    "ModelNameIsRequired": "Model name is required to create a service",
     "ModelPath": "Model Path",
     "Path": "Path",
     "Port": "Port",
diff --git a/resources/i18n/es.json b/resources/i18n/es.json
index 6eff7ba8f1..bd4e957843 100644
--- a/resources/i18n/es.json
+++ b/resources/i18n/es.json
@@ -914,16 +914,19 @@
     "64chars": "(máximo 64 caracteres)"
   },
   "modelService": {
+    "AFolderWithSimilarNameExists": "Ya existe una carpeta con un nombre similar",
     "Active": "Activo",
     "Active/Total": "Activo/Total",
     "AddRules": "Agregar reglas",
     "AdditionalMounts": "Montajes adicionales",
     "AutoScalingRules": "Reglas de escala automática",
     "BasePath": "Ruta base",
+    "BothDefinitionFilesRequired": "Se requieren modelos-Definition.yaml y Service-DeFinition.TOML.",
     "Cancel": "Cancelar",
     "CannotValidateNow": "No se puede validar el servicio ahora. \nVerifique la asignación de recursos u otras configuraciones.",
     "Chatting": "Charlando",
     "ClearErrors": "Borrar error y reintentar",
+    "CloneModelFolderConfirm": "Para ejecutar el servicio modelo, la carpeta debe ser clonada. \n¿Le gustaría clonarlo como <strong>\"{{folderName}}\"</strong> e iniciar el servicio?",
     "Controls": "Controla",
     "CreatedAt": "Creado en",
     "CurrentTime": "Hora actual",
@@ -950,7 +953,10 @@
     "GoToServiceDetailPage": "Vaya a la página Detalle del servicio",
     "Image": "Imagen",
     "ModelDefinitionPath": "Ruta del archivo de definición del modelo",
+    "ModelDefinitionRequired": "se necesita modelo-definición.yaml.",
     "ModelMountDestination": "Destino de montaje para carpeta de modelo",
+    "ModelServiceCreationHasBeenCanceled": "La creación del servicio modelo ha sido cancelado.",
+    "ModelServiceFailedToStart": "No se pudo iniciar el servicio de modelos.",
     "NoExtraMounts": "Sin soportes adicionales",
     "NoServiceEndpoint": "Sin punto final de servicio",
     "NumberOfReplicas": "Número de réplicas",
@@ -973,7 +979,10 @@
     "RuntimeVariant": "Variante de tiempo de ejecución de la inferencia",
     "SeeContainerLogs": "Ver registros de contenedores",
     "ServiceAlreadyExists": "El nombre del servicio ya existe",
+    "ServiceConfigurationNotValid": "La configuración del servicio no es válida. \nPóngase en contacto con el administrador.",
     "ServiceCreated": "El servicio modelo {{ name }} se ha creado correctamente.",
+    "ServiceDefinitionNotFound": "Archivo de definición de servicio no encontrado. \nSolo la clonación está disponible.",
+    "ServiceDefinitionRequired": "Service-DeFinition.TOML File es necesario.",
     "ServiceDelegatedFrom": "El servicio modelo es creado por {{ createdUser }} pero la propiedad de la sesión será delegada a {{ sessionOwner }}",
     "ServiceEndpoint": "Punto final del servicio",
     "ServiceInfo": "Información de servicio",
@@ -1006,14 +1015,17 @@
     "TokenGenerationFailed": "Generación de token fallida. Por favor, inténtelo de nuevo.",
     "TrafficRatio": "Ratio de tráfico",
     "UpdateService": "Servicio de actualización",
+    "UseExistingFolderConfirm": "¿Le gustaría comenzar el servicio utilizando la carpeta existente {{folderName}}?",
     "Validate": "Validar",
     "ValidationInfo": "Información de validación"
   },
   "modelStore": {
     "Author": "Autor",
     "Category": "Categorías",
+    "CheckingSettings": "Configuración de verificación ...",
     "CloneAsFolder": "Clonar como carpeta",
     "CloneInfo": "Se clonará como su carpeta de tipo de usuario.",
+    "CloneRequired": "Requerido clon",
     "CloneSuccess": "La solicitud de clonación se ha enviado correctamente.",
     "CloneToFolder": "Clonar en una carpeta",
     "Created": "Creado",
@@ -1023,12 +1035,14 @@
     "FolderAlreadyExists": "Ya existe una carpeta con este nombre.",
     "Framework": "Marco",
     "HealthCheck": "Chequeo de salud",
+    "InvalidModelName": "Nombre de modelo no válido",
     "Label": "Etiqueta",
     "LastModified": "Última modificación",
     "MaxRetries": "Reintentos máximos",
     "Metadata": "Metadatos",
     "MinResource": "Recurso mínimo",
     "Model": "Modelo",
+    "ModelNameIsRequired": "Se requiere el nombre del modelo para crear un servicio.",
     "ModelPath": "Ruta del modelo",
     "Path": "Camino",
     "Port": "Puerto",
diff --git a/resources/i18n/fi.json b/resources/i18n/fi.json
index f6eecd1043..7b03bdf2f0 100644
--- a/resources/i18n/fi.json
+++ b/resources/i18n/fi.json
@@ -914,15 +914,18 @@
     "64chars": "(enintään 64 merkkiä)"
   },
   "modelService": {
+    "AFolderWithSimilarNameExists": "Kansio, jolla on samanlainen nimi, on jo olemassa",
     "Active": "Aktiivinen",
     "Active/Total": "Aktiivinen/Kokonaismäärä",
     "AddRules": "Lisää sääntöjä",
     "AdditionalMounts": "Lisäkiinnikkeet",
     "AutoScalingRules": "Automaattiset skaalaussäännöt",
     "BasePath": "Peruspolku",
+    "BothDefinitionFilesRequired": "Malli-Definition.yaml ja palvelun ja definition.Toml-tiedostot vaaditaan.",
     "Cancel": "Peruuttaa",
     "CannotValidateNow": "Palvelua ei voi vahvistaa nyt. \nTarkista resurssien allokaatio tai muut asetukset.",
     "ClearErrors": "Tyhjennä virhe ja yritä uudelleen",
+    "CloneModelFolderConfirm": "Mallipalvelun suorittamiseksi kansio on kloonata. \nHaluatko kloonata sen <strong>\"{{folderName}}\"</strong> ja aloittaa palvelun?",
     "Controls": "Ohjaimet",
     "CreatedAt": "Created at",
     "CurrentTime": "Nykyinen aika",
@@ -949,7 +952,10 @@
     "GoToServiceDetailPage": "Siirry Service Detail -sivulle",
     "Image": "Kuva",
     "ModelDefinitionPath": "Mallin määritelmän tiedostopolku",
+    "ModelDefinitionRequired": "Malli-definition.yaml-tiedosto tarvitaan.",
     "ModelMountDestination": "Kiinnityskohde mallikansioon",
+    "ModelServiceCreationHasBeenCanceled": "Mallipalvelun luominen on peruutettu.",
+    "ModelServiceFailedToStart": "Mallipalvelun aloittaminen epäonnistui.",
     "NoExtraMounts": "Ei ylimääräisiä kiinnikkeitä",
     "NoServiceEndpoint": "Ei palvelun päätepistettä",
     "NumberOfReplicas": "Kopioiden määrä",
@@ -972,7 +978,10 @@
     "RuntimeVariant": "Päättelyn suoritusaikamuunnos",
     "SeeContainerLogs": "Katso Säilön lokit",
     "ServiceAlreadyExists": "Palvelun nimi on jo olemassa",
+    "ServiceConfigurationNotValid": "Palvelun kokoonpano on virheellinen. \nOta yhteyttä järjestelmänvalvojaan.",
     "ServiceCreated": "Mallipalvelun {{ name }} luominen onnistui.",
+    "ServiceDefinitionNotFound": "Palvelun määritelmätiedostoa ei löydy. \nVain kloonaus on saatavana.",
+    "ServiceDefinitionRequired": "Palvelu-definition.Toml-tiedosto tarvitaan.",
     "ServiceDelegatedFrom": "Mallipalvelun luo {{ createdUser }}, mutta istunnon omistusoikeus siirretään {{ sessionOwner }}:lle.",
     "ServiceEndpoint": "Palvelun päätepiste",
     "ServiceInfo": "Palvelun tiedot",
@@ -1005,14 +1014,17 @@
     "TokenGenerationFailed": "Tokenin luominen epäonnistui. yritä uudelleen.",
     "TrafficRatio": "Liikennesuhde",
     "UpdateService": "Päivityspalvelu",
+    "UseExistingFolderConfirm": "Haluatko aloittaa palvelun käyttämällä olemassa olevaa {{folderName}} -kansiota?",
     "Validate": "Vahvista",
     "ValidationInfo": "Vahvistustiedot"
   },
   "modelStore": {
     "Author": "Tekijä",
     "Category": "Kategoria",
+    "CheckingSettings": "Asetukset ...",
     "CloneAsFolder": "Kloonaa kansioksi",
     "CloneInfo": "Se kloonataan käyttäjätyypin kansioksi.",
+    "CloneRequired": "Klooni vaaditaan",
     "CloneSuccess": "Kloonipyyntö on lähetetty onnistuneesti.",
     "CloneToFolder": "Kloonaa kansioon",
     "Created": "Luotu",
@@ -1022,12 +1034,14 @@
     "FolderAlreadyExists": "Tämän niminen kansio on jo olemassa.",
     "Framework": "puitteet",
     "HealthCheck": "Terveystarkastus",
+    "InvalidModelName": "Virheellinen mallin nimi",
     "Label": "Label",
     "LastModified": "Viimeksi muokattu",
     "MaxRetries": "Max Uudelleenyritykset",
     "Metadata": "Metatiedot",
     "MinResource": "Vähimmäisresurssi",
     "Model": "Malli",
+    "ModelNameIsRequired": "Mallin nimi vaaditaan palvelun luomiseen",
     "ModelPath": "Mallin polku",
     "Path": "Polku",
     "Port": "Portti",
diff --git a/resources/i18n/fr.json b/resources/i18n/fr.json
index 3b964c4180..8e4e64d08e 100644
--- a/resources/i18n/fr.json
+++ b/resources/i18n/fr.json
@@ -914,16 +914,19 @@
     "64chars": "(maximum 64 caractères)"
   },
   "modelService": {
+    "AFolderWithSimilarNameExists": "Un dossier avec un nom similaire existe déjà",
     "Active": "Actif",
     "Active/Total": "Actif/Total",
     "AddRules": "Ajouter des règles",
     "AdditionalMounts": "Supports supplémentaires",
     "AutoScalingRules": "Règles de mise à l'échelle automatique",
     "BasePath": "Chemin de base",
+    "BothDefinitionFilesRequired": "Les fichiers Model-Definition.yaml et Service-Definition.toml sont nécessaires.",
     "Cancel": "Annuler",
     "CannotValidateNow": "Impossible de valider le service maintenant. \nVeuillez vérifier l'allocation des ressources ou d'autres configurations.",
     "Chatting": "Bavardage",
     "ClearErrors": "Effacer l'erreur et réessayer",
+    "CloneModelFolderConfirm": "Pour exécuter le service modèle, le dossier doit être cloné. \nSouhaitez-vous le cloner comme <strong>\"{{folderName}}\"</strong> et démarrer le service?",
     "Controls": "Contrôles",
     "CreatedAt": "Créé à",
     "CurrentTime": "Heure actuelle",
@@ -950,7 +953,10 @@
     "GoToServiceDetailPage": "Aller à la page de détail du service",
     "Image": "Image",
     "ModelDefinitionPath": "Chemin du fichier de définition du modèle",
+    "ModelDefinitionRequired": "Le fichier modèle-définition.yaml est nécessaire.",
     "ModelMountDestination": "Destination de montage pour le dossier modèle",
+    "ModelServiceCreationHasBeenCanceled": "La création de services modèles a été annulée.",
+    "ModelServiceFailedToStart": "Échec du démarrage du service du modèle.",
     "NoExtraMounts": "Pas de montures supplémentaires",
     "NoServiceEndpoint": "Pas de point final de service",
     "NumberOfReplicas": "Nombre de répliques",
@@ -973,7 +979,10 @@
     "RuntimeVariant": "Variante d'exécution de l'inférence",
     "SeeContainerLogs": "Voir les journaux de conteneur",
     "ServiceAlreadyExists": "Le nom du service existe déjà",
+    "ServiceConfigurationNotValid": "La configuration du service n'est pas valide. \nVeuillez contacter l'administrateur.",
     "ServiceCreated": "Le service modèle {{ name }} a été créé avec succès.",
+    "ServiceDefinitionNotFound": "Fichier de définition de service introuvable. \nSeul le clonage est disponible.",
+    "ServiceDefinitionRequired": "Le fichier service-définition.toml est nécessaire.",
     "ServiceDelegatedFrom": "Le service modèle est créé par {{ createdUser }} mais la propriété de la session sera déléguée à {{ sessionOwner }}.",
     "ServiceEndpoint": "Point final du service",
     "ServiceInfo": "Informations sur le service",
@@ -1006,14 +1015,17 @@
     "TokenGenerationFailed": "La génération de jetons a échoué. Veuillez réessayer.",
     "TrafficRatio": "Ratio de trafic",
     "UpdateService": "Service de mise à jour",
+    "UseExistingFolderConfirm": "Souhaitez-vous démarrer le service en utilisant le dossier {{folderName}} existant?",
     "Validate": "Valider",
     "ValidationInfo": "Informations de validation"
   },
   "modelStore": {
     "Author": "Auteur",
     "Category": "Catégories",
+    "CheckingSettings": "Paramètres de vérification ...",
     "CloneAsFolder": "Cloner en tant que dossier",
     "CloneInfo": "Il sera cloné en tant que dossier de votre type d'utilisateur.",
+    "CloneRequired": "Clone requis",
     "CloneSuccess": "La demande de clone a été envoyée avec succès.",
     "CloneToFolder": "Cloner dans un dossier",
     "Created": "Créé",
@@ -1023,12 +1035,14 @@
     "FolderAlreadyExists": "Un dossier portant ce nom existe déjà.",
     "Framework": "Le cadre",
     "HealthCheck": "Bilan de santé",
+    "InvalidModelName": "Nom de modèle invalide",
     "Label": "Étiquette",
     "LastModified": "Dernière modification",
     "MaxRetries": "Nombre maximal de tentatives",
     "Metadata": "Métadonnées",
     "MinResource": "Ressource minimale",
     "Model": "Modèle",
+    "ModelNameIsRequired": "Le nom du modèle est requis pour créer un service",
     "ModelPath": "Chemin du modèle",
     "Path": "Chemin",
     "Port": "Port",
diff --git a/resources/i18n/id.json b/resources/i18n/id.json
index 9e09cb1d58..917eaf9d0b 100644
--- a/resources/i18n/id.json
+++ b/resources/i18n/id.json
@@ -913,15 +913,18 @@
     "64chars": "(maksimum 64 karakter)"
   },
   "modelService": {
+    "AFolderWithSimilarNameExists": "Folder dengan nama serupa sudah ada",
     "Active": "Aktif",
     "Active/Total": "Aktif/Total",
     "AddRules": "Tambahkan aturan",
     "AdditionalMounts": "Pemasangan Tambahan",
     "AutoScalingRules": "Aturan penskalaan otomatis",
     "BasePath": "Jalur Dasar",
+    "BothDefinitionFilesRequired": "File Model-Definition.YAML dan Layanan-Definisi.toml diperlukan.",
     "CannotValidateNow": "Tidak dapat memvalidasi layanan sekarang. \nSilakan periksa alokasi sumber daya atau konfigurasi lainnya.",
     "Chatting": "Mengobrol",
     "ClearErrors": "Hapus kesalahan dan coba lagi",
+    "CloneModelFolderConfirm": "Untuk menjalankan layanan model, folder perlu dikloning. \nApakah Anda ingin mengkloningnya sebagai <strong>\"{{folderName}}\"</strong> dan memulai layanan?",
     "Controls": "Kontrol",
     "CreatedAt": "Dibuat di",
     "CurrentTime": "Waktu saat ini",
@@ -948,7 +951,10 @@
     "GoToServiceDetailPage": "Pergi ke Halaman Detail Layanan",
     "Image": "Gambar",
     "ModelDefinitionPath": "Jalur File Definisi Model",
+    "ModelDefinitionRequired": "Model-Definition.yaml diperlukan file.",
     "ModelMountDestination": "Pasang Tujuan Untuk Folder Model",
+    "ModelServiceCreationHasBeenCanceled": "Pembuatan Layanan Model telah dibatalkan.",
+    "ModelServiceFailedToStart": "Gagal memulai layanan model.",
     "NoExtraMounts": "Tidak ada tunggangan tambahan",
     "NoServiceEndpoint": "Tidak Ada Titik Akhir Layanan",
     "NumberOfReplicas": "Jumlah replika",
@@ -971,7 +977,10 @@
     "RuntimeVariant": "Varian Runtime Inferensi",
     "SeeContainerLogs": "Lihat Log Kontainer",
     "ServiceAlreadyExists": "Nama layanan sudah ada",
+    "ServiceConfigurationNotValid": "Konfigurasi layanan tidak valid. \nSilakan hubungi administrator.",
     "ServiceCreated": "Layanan model {{ name }} telah berhasil dibuat.",
+    "ServiceDefinitionNotFound": "File definisi layanan tidak ditemukan. \nHanya kloning yang tersedia.",
+    "ServiceDefinitionRequired": "File layanan-definisi.toml diperlukan.",
     "ServiceDelegatedFrom": "Layanan model dibuat oleh {{ createdUser }} namun kepemilikan sesi akan didelegasikan ke {{ sessionOwner }}",
     "ServiceEndpoint": "Titik Akhir Layanan",
     "ServiceInfo": "Info Layanan",
@@ -1004,14 +1013,17 @@
     "TokenGenerationFailed": "Pembuatan token gagal. silakan coba lagi.",
     "TrafficRatio": "Rasio Lalu Lintas",
     "UpdateService": "Layanan Pembaruan",
+    "UseExistingFolderConfirm": "Apakah Anda ingin memulai layanan menggunakan folder {{folderName}} yang ada?",
     "Validate": "Mengesahkan",
     "ValidationInfo": "Info Validasi"
   },
   "modelStore": {
     "Author": "Pengarang",
     "Category": "Kategori",
+    "CheckingSettings": "Memeriksa Pengaturan ...",
     "CloneAsFolder": "Mengkloning sebagai Folder",
     "CloneInfo": "Ini akan dikloning sebagai folder tipe pengguna Anda.",
+    "CloneRequired": "Klon diperlukan",
     "CloneSuccess": "Permintaan kloning telah berhasil dikirim.",
     "CloneToFolder": "Mengkloning ke folder",
     "Created": "Dibuat",
@@ -1021,12 +1033,14 @@
     "FolderAlreadyExists": "Folder dengan nama ini sudah ada.",
     "Framework": "Kerangka kerja",
     "HealthCheck": "Cek kesehatan",
+    "InvalidModelName": "Nama model tidak valid",
     "Label": "Label",
     "LastModified": "Terakhir diubah",
     "MaxRetries": "Percobaan Ulang Maks",
     "Metadata": "Metadata",
     "MinResource": "Sumber Daya Minimal",
     "Model": "Model",
+    "ModelNameIsRequired": "Nama model diperlukan untuk membuat layanan",
     "ModelPath": "Jalur Model",
     "Path": "Jalur",
     "Port": "Pelabuhan",
diff --git a/resources/i18n/it.json b/resources/i18n/it.json
index 38c13b2a9b..a8f05a8dc6 100644
--- a/resources/i18n/it.json
+++ b/resources/i18n/it.json
@@ -913,15 +913,18 @@
     "64chars": "(massimo 64 caratteri)"
   },
   "modelService": {
+    "AFolderWithSimilarNameExists": "Una cartella con un nome simile esiste già",
     "Active": "Attivo",
     "Active/Total": "Attivo/Totale",
     "AddRules": "Aggiungi regole",
     "AdditionalMounts": "Supporti aggiuntivi",
     "AutoScalingRules": "Regole di ridimensionamento automatico",
     "BasePath": "Percorso base",
+    "BothDefinitionFilesRequired": "Sono richiesti i file del modello definizione.yaml e del servizio definizione.toml.",
     "CannotValidateNow": "Impossibile convalidare il servizio adesso. \nControlla l'allocazione delle risorse o altre configurazioni.",
     "Chatting": "Chiacchierando",
     "ClearErrors": "Cancellare l'errore e riprovare",
+    "CloneModelFolderConfirm": "Per eseguire il servizio modello, la cartella deve essere clonata. \nVorresti clonarlo come <strong>\"{{folderName}}\"</strong> e avviare il servizio?",
     "Controls": "Controlli",
     "CreatedAt": "Creato a",
     "CurrentTime": "Ora corrente",
@@ -948,7 +951,10 @@
     "GoToServiceDetailPage": "Vai alla pagina dei dettagli del servizio",
     "Image": "Immagine",
     "ModelDefinitionPath": "Percorso del file di definizione del modello",
+    "ModelDefinitionRequired": "È necessario il file Model-Definition.yaml.",
     "ModelMountDestination": "Destinazione di montaggio per la cartella del modello",
+    "ModelServiceCreationHasBeenCanceled": "La creazione del servizio modello è stata annullata.",
+    "ModelServiceFailedToStart": "Impossibile avviare il servizio modello.",
     "NoExtraMounts": "Nessun supporto aggiuntivo",
     "NoServiceEndpoint": "Nessun punto finale del servizio",
     "NumberOfReplicas": "Numero di repliche",
@@ -971,7 +977,10 @@
     "RuntimeVariant": "Variante di runtime dell'inferenza",
     "SeeContainerLogs": "Consulta Log del contenitore",
     "ServiceAlreadyExists": "Il nome del servizio esiste già",
+    "ServiceConfigurationNotValid": "La configurazione del servizio non è valida. \nSi prega di contattare l'amministratore.",
     "ServiceCreated": "Il servizio modello {{ name }} è stato creato correttamente.",
+    "ServiceDefinitionNotFound": "File di definizione del servizio non trovato. \nÈ disponibile solo la clonazione.",
+    "ServiceDefinitionRequired": "È necessario il file Service Definition.Toml.",
     "ServiceDelegatedFrom": "Il servizio modello è creato da {{ createdUser }}, ma la proprietà della sessione sarà delegata a {{ sessionOwner }}.",
     "ServiceEndpoint": "Punto finale del servizio",
     "ServiceInfo": "Info sul servizio",
@@ -1004,14 +1013,17 @@
     "TokenGenerationFailed": "La generazione del token non è riuscita. Riprovare.",
     "TrafficRatio": "Rapporto di traffico",
     "UpdateService": "Servizio di aggiornamento",
+    "UseExistingFolderConfirm": "Vorresti avviare il servizio utilizzando la cartella {{folderName}} esistente?",
     "Validate": "Convalidare",
     "ValidationInfo": "Informazioni sulla convalida"
   },
   "modelStore": {
     "Author": "Autore",
     "Category": "Categorie",
+    "CheckingSettings": "Controllo delle impostazioni ...",
     "CloneAsFolder": "Clonare come cartella",
     "CloneInfo": "Verrà clonata come cartella del tipo di utente.",
+    "CloneRequired": "Clone richiesto",
     "CloneSuccess": "La richiesta di clonazione è stata inviata con successo.",
     "CloneToFolder": "Clonare in una cartella",
     "Created": "Creato",
@@ -1021,12 +1033,14 @@
     "FolderAlreadyExists": "Una cartella con questo nome esiste già.",
     "Framework": "Struttura",
     "HealthCheck": "Controllo della salute",
+    "InvalidModelName": "Nome del modello non valido",
     "Label": "Etichetta",
     "LastModified": "Ultima modifica",
     "MaxRetries": "Numero massimo di tentativi",
     "Metadata": "Metadati",
     "MinResource": "Risorsa minima",
     "Model": "Modello",
+    "ModelNameIsRequired": "Il nome del modello è obbligatorio per creare un servizio",
     "ModelPath": "Percorso del modello",
     "Path": "Sentiero",
     "Port": "Porta",
diff --git a/resources/i18n/ja.json b/resources/i18n/ja.json
index 24b1940c8a..fba34d0200 100644
--- a/resources/i18n/ja.json
+++ b/resources/i18n/ja.json
@@ -913,16 +913,19 @@
     "64chars": "（最大64文字）"
   },
   "modelService": {
+    "AFolderWithSimilarNameExists": "同様の名前のフォルダーがすでに存在しています",
     "Active": "アクティブ",
     "Active/Total": "アクティブ/全体",
     "AddRules": "ルールを追加します",
     "AdditionalMounts": "追加のマウント",
     "AutoScalingRules": "自動スケーリングルール",
     "BasePath": "ベースパス",
+    "BothDefinitionFilesRequired": "Model-Definition.yamlおよびservice-definition.tomlファイルが必要です。",
     "Cancel": "キャンセル",
     "CannotValidateNow": "現在サービスを検証できません。\nリソース割り当てまたはその他の構成を確認してください。",
     "Chatting": "おしゃべり",
     "ClearErrors": "エラーをクリアして再試行",
+    "CloneModelFolderConfirm": "モデルサービスを実行するには、フォルダーをクローン化する必要があります。 \n<strong>\"{{folderName}}\"</strong>としてクローンしてサービスを開始しますか？",
     "Controls": "操作",
     "CreatedAt": "作成時間",
     "CurrentTime": "現在時刻",
@@ -949,7 +952,10 @@
     "GoToServiceDetailPage": "サービスの詳細ページに移動します",
     "Image": "イメージ",
     "ModelDefinitionPath": "モデル定義ファイルのパス",
+    "ModelDefinitionRequired": "model-definition.yamlファイルが必要です。",
     "ModelMountDestination": "モデルフォルダーのマウント先",
+    "ModelServiceCreationHasBeenCanceled": "モデルサービスの作成がキャンセルされました。",
+    "ModelServiceFailedToStart": "モデルサービスを開始できませんでした。",
     "NoExtraMounts": "余分なマウントはありません",
     "NoServiceEndpoint": "サービスエンドポイントがありません。",
     "NumberOfReplicas": "レプリカ数",
@@ -972,7 +978,10 @@
     "RuntimeVariant": "推論ランタイム・バリアント",
     "SeeContainerLogs": "コンテナログを参照",
     "ServiceAlreadyExists": "サービス名はすでに存在します",
+    "ServiceConfigurationNotValid": "サービス構成は無効です。\n管理者に連絡してください。",
     "ServiceCreated": "モデル サービス {{ name }} が正常に作成されました。",
+    "ServiceDefinitionNotFound": "サービス定義ファイルが見つかりません。\nクローニングのみが利用可能です。",
+    "ServiceDefinitionRequired": "service-definition.tomlファイルが必要です。",
     "ServiceDelegatedFrom": "モデルサービスは{{ createdUser }}によって作成されますが、セッションの所有権は{{ sessionOwner }}に委譲されます。",
     "ServiceEndpoint": "サービスエンドポイント",
     "ServiceInfo": "サービス情報",
@@ -1005,14 +1014,17 @@
     "TokenGenerationFailed": "トークン生成に失敗しました。しばらくしてから再試行してください。",
     "TrafficRatio": "トラフィック率",
     "UpdateService": "アップデートサービス",
+    "UseExistingFolderConfirm": "既存の{{folderName}}フォルダーを使用してサービスを開始しますか？",
     "Validate": "確認",
     "ValidationInfo": "検証情報"
   },
   "modelStore": {
     "Author": "著者",
     "Category": "カテゴリー",
+    "CheckingSettings": "設定の確認...",
     "CloneAsFolder": "フォルダとしてクローン",
     "CloneInfo": "ユーザータイプのフォルダとしてクローンされます。",
+    "CloneRequired": "クローンが必要です",
     "CloneSuccess": "クローン要求は正常に送信された。",
     "CloneToFolder": "フォルダへのクローン",
     "Created": "作成した",
@@ -1022,12 +1034,14 @@
     "FolderAlreadyExists": "この名前のフォルダはすでに存在する。",
     "Framework": "フレームワーク",
     "HealthCheck": "健康診断",
+    "InvalidModelName": "無効なモデル名です",
     "Label": "ラベル",
     "LastModified": "最終更新日",
     "MaxRetries": "最大再試行回数",
     "Metadata": "メタデータ",
     "MinResource": "最小リソース",
     "Model": "モデル",
+    "ModelNameIsRequired": "サービスを作成するにはモデル名が必要です",
     "ModelPath": "モデルパス",
     "Path": "パス",
     "Port": "ポート",
diff --git a/resources/i18n/ko.json b/resources/i18n/ko.json
index 259514a071..587d50c13c 100644
--- a/resources/i18n/ko.json
+++ b/resources/i18n/ko.json
@@ -917,16 +917,19 @@
     "64chars": "(최대 길이 64자)"
   },
   "modelService": {
+    "AFolderWithSimilarNameExists": "비슷한 이름의 폴더가 존재합니다",
     "Active": "실행중",
     "Active/Total": "활성/전체",
     "AddRules": "규칙 추가",
     "AdditionalMounts": "추가 마운트",
     "AutoScalingRules": "오토스케일링 규칙",
     "BasePath": "기본 경로",
+    "BothDefinitionFilesRequired": "model-definition.yaml과 service-definition.toml 파일이 필요합니다.",
     "Cancel": "취소",
     "CannotValidateNow": "지금은 서비스를 확인할 수 없습니다. \n리소스 할당이나 기타 구성을 확인하세요.",
     "Chatting": "채팅",
     "ClearErrors": "오류 지우고 재시도",
+    "CloneModelFolderConfirm": "모델 서비스를 실행하려면 폴더를 클론해야 합니다. <strong>\"{{folderName}}\"</strong> 으로 클론 후 서비스를 시작할까요?",
     "Controls": "제어",
     "CreatedAt": "생성 시간",
     "CurrentTime": "현재 시각",
@@ -953,7 +956,9 @@
     "GoToServiceDetailPage": "모델 서비스 상세 페이지로 이동",
     "Image": "이미지",
     "ModelDefinitionPath": "모델 정의 파일 경로",
+    "ModelDefinitionRequired": "model-definition.yaml 파일이 필요합니다.",
     "ModelMountDestination": "모델 폴더 마운트할 경로",
+    "ModelServiceCreationHasBeenCanceled": "모델 서비스 생성이 취소되었습니다.",
     "ModelServiceFailedToStart": "모델 서비스 생성에 실패했습니다.",
     "NoExtraMounts": "추가 마운트 없음",
     "NoServiceEndpoint": "서비스 엔드포인트가 존재하지 않습니다.",
@@ -977,7 +982,10 @@
     "RuntimeVariant": "인퍼런스 런타임 종류",
     "SeeContainerLogs": "컨테이너 로그 보기",
     "ServiceAlreadyExists": "같은 이름의 서비스가 이미 존재합니다",
+    "ServiceConfigurationNotValid": "서비스 설정이 올바르지 않습니다. 관리자에게 문의하세요.",
     "ServiceCreated": "모델 서비스 {{ name }}이(가) 생성되었습니다.",
+    "ServiceDefinitionNotFound": "서비스 정의 파일을 찾을 수 없습니다. \n폴더 클론만 가능합니다.",
+    "ServiceDefinitionRequired": "service-definition.toml 파일이 필요합니다.",
     "ServiceDelegatedFrom": "모델 서비스는 {{ createdUser }}에 의해 생성되지만 세션 소유권은 {{ sessionOwner }}에 위임됩니다.",
     "ServiceEndpoint": "서비스 엔드포인트",
     "ServiceInfo": "서비스 정보",
@@ -1010,14 +1018,17 @@
     "TokenGenerationFailed": "토큰 생성에 실패했습니다. 잠시 후 다시 시도해 주세요.",
     "TrafficRatio": "트래픽 비율",
     "UpdateService": "서비스 업데이트",
+    "UseExistingFolderConfirm": "이미 존재하는 {{ folderName }} 폴더를 이용해서 서비스를 시작할까요?",
     "Validate": "유효성 검사",
     "ValidationInfo": "유효성 검사 결과"
   },
   "modelStore": {
     "Author": "작가",
     "Category": "카테고리",
+    "CheckingSettings": "설정 확인중...",
     "CloneAsFolder": "새 폴더로 복제",
     "CloneInfo": "새로운 사용자 폴더로 복제됩니다.",
+    "CloneRequired": "폴더 클론 필요",
     "CloneSuccess": "복제 요청을 보냈습니다.",
     "CloneToFolder": "폴더로 복제",
     "Created": "생성",
@@ -1027,12 +1038,14 @@
     "FolderAlreadyExists": "같은 이름의 폴더가 존재합니다.",
     "Framework": "프레임워크",
     "HealthCheck": "건강 체크",
+    "InvalidModelName": "잘못된 모델 이름",
     "Label": "레이블",
     "LastModified": "마지막 수정",
     "MaxRetries": "최대 재시도 횟수",
     "Metadata": "메타데이터",
     "MinResource": "최소 리소스",
     "Model": "모델",
+    "ModelNameIsRequired": "서비스를 만들려면 모델 이름이 필요합니다.",
     "ModelPath": "모델 경로",
     "Path": "길",
     "Port": "포트",
diff --git a/resources/i18n/mn.json b/resources/i18n/mn.json
index c31588a753..86ec1e2800 100644
--- a/resources/i18n/mn.json
+++ b/resources/i18n/mn.json
@@ -912,16 +912,19 @@
     "64chars": "(хамгийн ихдээ 64 тэмдэгт)"
   },
   "modelService": {
+    "AFolderWithSimilarNameExists": "Үүнтэй ижил нэртэй хавтас аль хэдийн байна",
     "Active": "Идэвхтэй",
     "Active/Total": "Идэвхтэй/Нийт",
     "AddRules": "Дүрмийг нэмэх",
     "AdditionalMounts": "Нэмэлт бэхэлгээ",
     "AutoScalingRules": "Автомат масштабын дүрэм",
     "BasePath": "ВЭДИЙН Хог байхгүй",
+    "BothDefinitionFilesRequired": "Загвар-тодорхойлолт. Тодорхойлолт.",
     "Cancel": "Цуцлах",
     "CannotValidateNow": "Одоо үйлчилгээг баталгаажуулах боломжгүй байна. \nНөөцийн хуваарилалт эсвэл бусад тохиргоог шалгана уу.",
     "Chatting": "Чатлаж байна",
     "ClearErrors": "Алдааг арилгаад дахин оролдоно уу",
+    "CloneModelFolderConfirm": "Загвар үйлчилгээг ажиллуулахын тулд фолдерыг хувилах хэрэгтэй. \n<strong>\"{{folderName}}\"</strong> -г эхлүүлэх үү?",
     "Controls": "Хяналтууд",
     "CreatedAt": "Үүсгэсэн",
     "CurrentTime": "Одоогийн цаг",
@@ -948,7 +951,10 @@
     "GoToServiceDetailPage": "Үйлчилгээний дэлгэрэнгүй хуудсанд очно уу",
     "Image": "Зураг",
     "ModelDefinitionPath": "Загварын тодорхойлолтын файлын зам",
+    "ModelDefinitionRequired": "Загвар-тодорхойлолт ..yaml файл шаардлагатай байна.",
     "ModelMountDestination": "Загварын хавтасыг холбох газар",
+    "ModelServiceCreationHasBeenCanceled": "Загвар үйлчилгээний бүтээлийг цуцаллаа.",
+    "ModelServiceFailedToStart": "Загвар үйлчилгээг эхлүүлж чадсангүй.",
     "NoExtraMounts": "Нэмэлт бэхэлгээ байхгүй",
     "NoServiceEndpoint": "Үйлчилгээний эцсийн цэг байхгүй",
     "NumberOfReplicas": "Хуулбаруудын тоо",
@@ -971,7 +977,10 @@
     "RuntimeVariant": "Дүгнэлт Runtime Variant",
     "SeeContainerLogs": "Контейнерийн бүртгэлийг үзнэ үү",
     "ServiceAlreadyExists": "Үйлчилгээний нэр аль хэдийн байна",
+    "ServiceConfigurationNotValid": "Үйлчилгээний тохиргоо буруу байна. \nАдминтай холбоо барина уу.",
     "ServiceCreated": "Загвар үйлчилгээ {{ name }} амжилттай үүсгэгдсэн.",
+    "ServiceDefinitionNotFound": "Үйлчилгээний тодорхойлолтын файл олдсонгүй. \nЗөвхөн Cloning хийх боломжтой.",
+    "ServiceDefinitionRequired": "Үйлчилгээний тодорхойлолт ..toml файл шаардлагатай байна.",
     "ServiceDelegatedFrom": "Загвар үйлчилгээг {{ createdUser }} үүсгэсэн боловч сессийн эрхийг {{ sessionOwner }}-д шилжүүлнэ.",
     "ServiceEndpoint": "Үйлчилгээний эцсийн цэг",
     "ServiceInfo": "Үйлчилгээний мэдээлэл",
@@ -1004,14 +1013,17 @@
     "TokenGenerationFailed": "Токен үүсгэх амжилтгүй болсон. \nдахин оролдоно уу.",
     "TrafficRatio": "Замын хөдөлгөөний харьцаа",
     "UpdateService": "Үйлчилгээг шинэчлэх",
+    "UseExistingFolderConfirm": "Одоо байгаа {{folderName}} хавтас ашиглан үйлчилгээг эхлүүлэхийг хүсч байна уу?",
     "Validate": "Баталгаажуулах",
     "ValidationInfo": "Баталгаажуулалтын мэдээлэл"
   },
   "modelStore": {
     "Author": "Зохиогч",
     "Category": "ангилал",
+    "CheckingSettings": "Тохиргоог шалгах ...",
     "CloneAsFolder": "Хавтас болгон хуваах",
     "CloneInfo": "Үүнийг таны хэрэглэгчийн төрлийн хавтас болгон хувилах болно.",
+    "CloneRequired": "Clone шаардлагатай",
     "CloneSuccess": "Хувилах хүсэлтийг амжилттай илгээлээ.",
     "CloneToFolder": "Хавтас руу клон хийх",
     "Created": "Үүсгэсэн",
@@ -1021,12 +1033,14 @@
     "FolderAlreadyExists": "Ийм нэртэй хавтас аль хэдийн байна.",
     "Framework": "Хүрээ",
     "HealthCheck": "Эрүүл мэндийн үзлэг",
+    "InvalidModelName": "Буруу загварын нэр",
     "Label": "Шошго",
     "LastModified": "Сүүлд өөрчилсөн",
     "MaxRetries": "Макс дахин оролдоно",
     "Metadata": "Мета өгөгдөл",
     "MinResource": "Хамгийн бага нөөц",
     "Model": "Загвар",
+    "ModelNameIsRequired": "Үйлчилгээ үүсгэхийн тулд загварын нэр шаардлагатай",
     "ModelPath": "Загварын зам",
     "Path": "Зам",
     "Port": "Порт",
diff --git a/resources/i18n/ms.json b/resources/i18n/ms.json
index 204c1e342d..35eb8171ca 100644
--- a/resources/i18n/ms.json
+++ b/resources/i18n/ms.json
@@ -913,16 +913,19 @@
     "64chars": "(maksimum 64 watak)"
   },
   "modelService": {
+    "AFolderWithSimilarNameExists": "Folder dengan nama yang serupa sudah ada",
     "Active": "Aktif",
     "Active/Total": "Aktif/Jumlah",
     "AddRules": "Tambah peraturan",
     "AdditionalMounts": "Lekapan Tambahan",
     "AutoScalingRules": "Peraturan penskalaan automatik",
     "BasePath": "Laluan asas",
+    "BothDefinitionFilesRequired": "Model definisi.yaml dan fail definisi.toml diperlukan.",
     "Cancel": "Batal",
     "CannotValidateNow": "Tidak dapat mengesahkan perkhidmatan sekarang. \nSila semak peruntukan sumber atau konfigurasi lain.",
     "Chatting": "Berbual",
     "ClearErrors": "Kosongkan ralat dan cuba semula",
+    "CloneModelFolderConfirm": "Untuk menjalankan perkhidmatan model, folder perlu diklon. \nAdakah anda ingin mengklonkannya sebagai <strong>\"{{folderName}}\"</strong> dan memulakan perkhidmatan?",
     "Controls": "Kawalan",
     "CreatedAt": "Dicipta Pada",
     "CurrentTime": "Masa semasa",
@@ -949,7 +952,10 @@
     "GoToServiceDetailPage": "Pergi ke halaman perincian perkhidmatan",
     "Image": "Gambar",
     "ModelDefinitionPath": "Laluan Fail Definisi Model",
+    "ModelDefinitionRequired": "Fail definisi model.yaml diperlukan.",
     "ModelMountDestination": "Lekapkan Destinasi Untuk Folder Model",
+    "ModelServiceCreationHasBeenCanceled": "Penciptaan perkhidmatan model telah dibatalkan.",
+    "ModelServiceFailedToStart": "Gagal memulakan perkhidmatan model.",
     "NoExtraMounts": "Tiada pelekap tambahan",
     "NoServiceEndpoint": "Tiada Titik Akhir Perkhidmatan",
     "NumberOfReplicas": "Bilangan replika",
@@ -972,7 +978,10 @@
     "RuntimeVariant": "Varian Masa Jalan Inferens",
     "SeeContainerLogs": "Lihat Log Bekas",
     "ServiceAlreadyExists": "Nama perkhidmatan sudah ada",
+    "ServiceConfigurationNotValid": "Konfigurasi perkhidmatan tidak sah. \nSila hubungi pentadbir.",
     "ServiceCreated": "Perkhidmatan model {{ name }} telah berjaya dibuat.",
+    "ServiceDefinitionNotFound": "Fail definisi perkhidmatan tidak dijumpai. \nHanya pengklonan yang tersedia.",
+    "ServiceDefinitionRequired": "Fail definisi.toml perkhidmatan diperlukan.",
     "ServiceDelegatedFrom": "Perkhidmatan model dicipta oleh {{ createdUser }} tetapi pemilikan sesi akan diwakilkan kepada {{ sessionOwner }}",
     "ServiceEndpoint": "Titik Akhir Perkhidmatan",
     "ServiceInfo": "Maklumat Perkhidmatan",
@@ -1005,14 +1014,17 @@
     "TokenGenerationFailed": "Penjanaan token gagal. \nsila cuba lagi.",
     "TrafficRatio": "Nisbah Trafik",
     "UpdateService": "Perkhidmatan Kemas Kini",
+    "UseExistingFolderConfirm": "Adakah anda ingin memulakan perkhidmatan menggunakan folder {{folderName}} yang sedia ada?",
     "Validate": "Sahkan",
     "ValidationInfo": "Maklumat Pengesahan"
   },
   "modelStore": {
     "Author": "Pengarang",
     "Category": "kategori",
+    "CheckingSettings": "Memeriksa tetapan ...",
     "CloneAsFolder": "Klon sebagai Folder",
     "CloneInfo": "Ia akan diklonkan sebagai folder jenis pengguna anda.",
+    "CloneRequired": "Klon diperlukan",
     "CloneSuccess": "Permintaan klon telah berjaya dihantar.",
     "CloneToFolder": "Klon ke folder",
     "Created": "Dicipta",
@@ -1022,12 +1034,14 @@
     "FolderAlreadyExists": "Folder dengan nama ini sudah wujud.",
     "Framework": "Rangka kerja",
     "HealthCheck": "Pemeriksaan kesihatan",
+    "InvalidModelName": "Nama model tidak sah",
     "Label": "Label",
     "LastModified": "Terakhir Diubah Suai",
     "MaxRetries": "Max Cuba Semula",
     "Metadata": "Metadata",
     "MinResource": "Sumber Min",
     "Model": "Model",
+    "ModelNameIsRequired": "Nama model diperlukan untuk membuat perkhidmatan",
     "ModelPath": "Laluan Model",
     "Path": "Laluan",
     "Port": "Pelabuhan",
diff --git a/resources/i18n/pl.json b/resources/i18n/pl.json
index c066063710..8154448cef 100644
--- a/resources/i18n/pl.json
+++ b/resources/i18n/pl.json
@@ -913,16 +913,19 @@
     "64chars": "(maksymalnie 64 znaki)"
   },
   "modelService": {
+    "AFolderWithSimilarNameExists": "Folder o podobnej nazwie już istnieje",
     "Active": "Aktywny",
     "Active/Total": "Aktywny/Ogółem",
     "AddRules": "Dodaj zasady",
     "AdditionalMounts": "Dodatkowe mocowania",
     "AutoScalingRules": "Reguły automatycznego skalowania",
     "BasePath": "Ścieżka podstawowa",
+    "BothDefinitionFilesRequired": "Wymagane są pliki modelu-definition.yaml i service-definition.toml.",
     "Cancel": "Anulować",
     "CannotValidateNow": "Nie można teraz zweryfikować usługi. \nSprawdź alokację zasobów lub inne konfiguracje.",
     "Chatting": "Czatowanie",
     "ClearErrors": "Usuń błąd i ponów próbę",
+    "CloneModelFolderConfirm": "Aby uruchomić usługę modelową, folder musi zostać sklonowany. \nCzy chciałbyś to klonizować jako <strong>\"{{folderName}}\"</strong> i uruchomić usługę?",
     "Controls": "Elementy sterujące",
     "CreatedAt": "Utworzono w",
     "CurrentTime": "Aktualny czas",
@@ -949,7 +952,10 @@
     "GoToServiceDetailPage": "Przejdź do strony szczegółów serwisowych",
     "Image": "Obraz",
     "ModelDefinitionPath": "Ścieżka pliku definicji modelu",
+    "ModelDefinitionRequired": "Potrzebny jest plik model-definition.yaml.",
     "ModelMountDestination": "Miejsce docelowe montażu dla folderu modelu",
+    "ModelServiceCreationHasBeenCanceled": "Modelowe tworzenie usług zostało anulowane.",
+    "ModelServiceFailedToStart": "Nie udało się uruchomić Model Service.",
     "NoExtraMounts": "Żadnych dodatkowych mocowań",
     "NoServiceEndpoint": "Brak punktu końcowego usługi",
     "NumberOfReplicas": "Liczba replik",
@@ -972,7 +978,10 @@
     "RuntimeVariant": "Inference Runtime Variant",
     "SeeContainerLogs": "Zobacz dzienniki kontenerów",
     "ServiceAlreadyExists": "Nazwa usługi już istnieje",
+    "ServiceConfigurationNotValid": "Konfiguracja usługi jest nieprawidłowa. \nSkontaktuj się z administratorem.",
     "ServiceCreated": "Usługa modelowa {{ name }} została pomyślnie utworzona.",
+    "ServiceDefinitionNotFound": "Plik definicji usługi nie został znaleziony. \nDostępne jest tylko klonowanie.",
+    "ServiceDefinitionRequired": "Potrzebny jest plik serwis-definition.toml.",
     "ServiceDelegatedFrom": "Usługa modelu jest tworzona przez {{ createdUser }}, ale własność sesji będzie delegowana do {{ sessionOwner }}.",
     "ServiceEndpoint": "Punkt końcowy usługi",
     "ServiceInfo": "Informacje o usłudze",
@@ -1005,14 +1014,17 @@
     "TokenGenerationFailed": "Generowanie tokena nie powiodło się. Spróbuj ponownie.",
     "TrafficRatio": "Współczynnik ruchu",
     "UpdateService": "Aktualizuj usługę",
+    "UseExistingFolderConfirm": "Czy chciałbyś rozpocząć usługę za pomocą istniejącego folderu {{folderName}}?",
     "Validate": "Uprawomocnić",
     "ValidationInfo": "Informacje o weryfikacji"
   },
   "modelStore": {
     "Author": "Autor",
     "Category": "Kategoria",
+    "CheckingSettings": "Sprawdzanie ustawień ...",
     "CloneAsFolder": "Sklonuj jako Folder",
     "CloneInfo": "Zostanie on sklonowany jako folder typu użytkownika.",
+    "CloneRequired": "Wymagany klon",
     "CloneSuccess": "Żądanie klonowania zostało wysłane pomyślnie.",
     "CloneToFolder": "Klonowanie do folderu",
     "Created": "Utworzony",
@@ -1022,12 +1034,14 @@
     "FolderAlreadyExists": "Folder o tej nazwie już istnieje.",
     "Framework": "Ramy",
     "HealthCheck": "Kontrola zdrowia",
+    "InvalidModelName": "Nieprawidłowa nazwa modelu",
     "Label": "Etykieta",
     "LastModified": "Ostatnio zmodyfikowany",
     "MaxRetries": "Maksymalna liczba ponownych prób",
     "Metadata": "Metadane",
     "MinResource": "Minimalny zasób",
     "Model": "Model",
+    "ModelNameIsRequired": "Aby utworzyć usługę, wymagana jest nazwa modelu",
     "ModelPath": "Ścieżka modelu",
     "Path": "Ścieżka",
     "Port": "Port",
diff --git a/resources/i18n/pt-BR.json b/resources/i18n/pt-BR.json
index 400ff49631..a170b3b68e 100644
--- a/resources/i18n/pt-BR.json
+++ b/resources/i18n/pt-BR.json
@@ -914,16 +914,19 @@
     "64chars": "(máximo de 64 caracteres)"
   },
   "modelService": {
+    "AFolderWithSimilarNameExists": "Uma pasta com um nome semelhante já existe",
     "Active": "Ativo",
     "Active/Total": "Ativo/Total",
     "AddRules": "Adicione regras",
     "AdditionalMounts": "Montarias Adicionais",
     "AutoScalingRules": "Regras de escala automática",
     "BasePath": "Trajetória de base",
+    "BothDefinitionFilesRequired": "Os arquivos Model-Definition.yaml e Service-Definition.TOML são necessários.",
     "Cancel": "Cancelar",
     "CannotValidateNow": "Não é possível validar o serviço agora. \nVerifique a alocação de recursos ou outras configurações.",
     "Chatting": "Conversando",
     "ClearErrors": "Limpar o erro e tentar de novo",
+    "CloneModelFolderConfirm": "Para executar o serviço de modelo, a pasta precisa ser clonada. \nVocê gostaria de cloná -lo como <strong>\"{{folderName}}\"</strong> e iniciar o serviço?",
     "Controls": "Controlos",
     "CreatedAt": "Criado em",
     "CurrentTime": "Hora atual",
@@ -950,7 +953,10 @@
     "GoToServiceDetailPage": "Vá para a página de detalhes do serviço",
     "Image": "Imagem",
     "ModelDefinitionPath": "Caminho do arquivo de definição de modelo",
+    "ModelDefinitionRequired": "é necessário o arquivo model-definition.yaml.",
     "ModelMountDestination": "Montar destino para pasta de modelo",
+    "ModelServiceCreationHasBeenCanceled": "A criação do serviço de modelo foi cancelada.",
+    "ModelServiceFailedToStart": "Falha ao iniciar o serviço de modelo.",
     "NoExtraMounts": "Sem montagens extras",
     "NoServiceEndpoint": "Nenhum ponto final de serviço",
     "NumberOfReplicas": "Número de réplicas",
@@ -973,7 +979,10 @@
     "RuntimeVariant": "Variante de tempo de execução de inferência",
     "SeeContainerLogs": "Consulte os registros do contêiner",
     "ServiceAlreadyExists": "O nome do serviço já existe",
+    "ServiceConfigurationNotValid": "A configuração do serviço é inválida. \nEntre em contato com o administrador.",
     "ServiceCreated": "O serviço de modelo {{ name }} foi criado com sucesso.",
+    "ServiceDefinitionNotFound": "Arquivo de definição de serviço não encontrado. \nSomente clonagem está disponível.",
+    "ServiceDefinitionRequired": "é necessário o arquivo de serviço de definição.toml.",
     "ServiceDelegatedFrom": "O serviço de modelo é criado por {{ createdUser }} mas a propriedade da sessão será delegada a {{ sessionOwner }}",
     "ServiceEndpoint": "Ponto final do serviço",
     "ServiceInfo": "Informações sobre o serviço",
@@ -1006,14 +1015,17 @@
     "TokenGenerationFailed": "A geração de tokens falhou. Por favor, tente novamente.",
     "TrafficRatio": "Rácio de tráfego",
     "UpdateService": "Serviço de atualização",
+    "UseExistingFolderConfirm": "Gostaria de iniciar o serviço usando a pasta {{folderName}} existente?",
     "Validate": "Validar",
     "ValidationInfo": "Informações de validação"
   },
   "modelStore": {
     "Author": "Autor",
     "Category": "Categoria",
+    "CheckingSettings": "Verificando as configurações ...",
     "CloneAsFolder": "Clonar como Pasta",
     "CloneInfo": "Será clonada como a pasta do seu tipo de utilizador.",
+    "CloneRequired": "Clone necessário",
     "CloneSuccess": "O pedido de clone foi enviado com sucesso.",
     "CloneToFolder": "Clonar para uma pasta",
     "Created": "Criada",
@@ -1023,12 +1035,14 @@
     "FolderAlreadyExists": "Já existe uma pasta com este nome.",
     "Framework": "Enquadramento",
     "HealthCheck": "Exame de saúde",
+    "InvalidModelName": "Nome de modelo inválido",
     "Label": "Etiqueta",
     "LastModified": "Última modificação",
     "MaxRetries": "Máximo de tentativas",
     "Metadata": "Metadados",
     "MinResource": "Recurso mínimo",
     "Model": "Modelo",
+    "ModelNameIsRequired": "O nome do modelo é obrigatório para criar um serviço",
     "ModelPath": "Caminho do modelo",
     "Path": "Caminho",
     "Port": "Porta",
diff --git a/resources/i18n/pt.json b/resources/i18n/pt.json
index 09629d02ff..253fed3f3a 100644
--- a/resources/i18n/pt.json
+++ b/resources/i18n/pt.json
@@ -914,16 +914,19 @@
     "64chars": "(máximo de 64 caracteres)"
   },
   "modelService": {
+    "AFolderWithSimilarNameExists": "Uma pasta com um nome semelhante já existe",
     "Active": "Ativo",
     "Active/Total": "Ativo/Total",
     "AddRules": "Adicione regras",
     "AdditionalMounts": "Montarias Adicionais",
     "AutoScalingRules": "Regras de escala automática",
     "BasePath": "Trajetória de base",
+    "BothDefinitionFilesRequired": "Os arquivos Model-Definition.yaml e Service-Definition.TOML são necessários.",
     "Cancel": "Cancelar",
     "CannotValidateNow": "Não é possível validar o serviço agora. \nVerifique a alocação de recursos ou outras configurações.",
     "Chatting": "Conversando",
     "ClearErrors": "Limpar o erro e tentar de novo",
+    "CloneModelFolderConfirm": "Para executar o serviço de modelo, a pasta precisa ser clonada. \nVocê gostaria de cloná -lo como <strong>\"{{folderName}}\"</strong> e iniciar o serviço?",
     "Controls": "Controlos",
     "CreatedAt": "Criado em",
     "CurrentTime": "Hora atual",
@@ -950,7 +953,10 @@
     "GoToServiceDetailPage": "Vá para a página de detalhes do serviço",
     "Image": "Imagem",
     "ModelDefinitionPath": "Caminho do arquivo de definição de modelo",
+    "ModelDefinitionRequired": "é necessário o arquivo model-definition.yaml.",
     "ModelMountDestination": "Montar destino para pasta de modelo",
+    "ModelServiceCreationHasBeenCanceled": "A criação do serviço de modelo foi cancelada.",
+    "ModelServiceFailedToStart": "Falha ao iniciar o serviço de modelo.",
     "NoExtraMounts": "Sem montagens extras",
     "NoServiceEndpoint": "Nenhum ponto final de serviço",
     "NumberOfReplicas": "Número de réplicas",
@@ -972,7 +978,10 @@
     "RuntimeVariant": "Variante de tempo de execução de inferência",
     "SeeContainerLogs": "Consulte os registros do contêiner",
     "ServiceAlreadyExists": "O nome do serviço já existe",
+    "ServiceConfigurationNotValid": "A configuração do serviço é inválida. \nEntre em contato com o administrador.",
     "ServiceCreated": "O serviço de modelo {{ name }} foi criado com sucesso.",
+    "ServiceDefinitionNotFound": "Arquivo de definição de serviço não encontrado. \nSomente clonagem está disponível.",
+    "ServiceDefinitionRequired": "é necessário o arquivo de serviço de definição.toml.",
     "ServiceDelegatedFrom": "O serviço de modelo é criado por {{ createdUser }} mas a propriedade da sessão será delegada a {{ sessionOwner }}",
     "ServiceEndpoint": "Ponto final do serviço",
     "ServiceInfo": "Informações sobre o serviço",
@@ -1005,14 +1014,17 @@
     "TokenGenerationFailed": "A geração de tokens falhou. Por favor, tente novamente.",
     "TrafficRatio": "Rácio de tráfego",
     "UpdateService": "Serviço de atualização",
+    "UseExistingFolderConfirm": "Gostaria de iniciar o serviço usando a pasta {{folderName}} existente?",
     "Validate": "Validar",
     "ValidationInfo": "Informações de validação"
   },
   "modelStore": {
     "Author": "Autor",
     "Category": "Categoria",
+    "CheckingSettings": "Verificando as configurações ...",
     "CloneAsFolder": "Clonar como Pasta",
     "CloneInfo": "Ele será clonado como sua pasta de tipo de usuário.",
+    "CloneRequired": "Clone necessário",
     "CloneSuccess": "O pedido de clone foi enviado com sucesso.",
     "CloneToFolder": "Clonar para uma pasta",
     "Created": "Criada",
@@ -1022,12 +1034,14 @@
     "FolderAlreadyExists": "Já existe uma pasta com este nome.",
     "Framework": "Enquadramento",
     "HealthCheck": "Exame de saúde",
+    "InvalidModelName": "Nome de modelo inválido",
     "Label": "Etiqueta",
     "LastModified": "Última modificação",
     "MaxRetries": "Máximo de tentativas",
     "Metadata": "Metadados",
     "MinResource": "Recurso mínimo",
     "Model": "Modelo",
+    "ModelNameIsRequired": "O nome do modelo é obrigatório para criar um serviço",
     "ModelPath": "Caminho do modelo",
     "Path": "Caminho",
     "Port": "Porta",
diff --git a/resources/i18n/ru.json b/resources/i18n/ru.json
index c2e4ae40cb..e94cf10667 100644
--- a/resources/i18n/ru.json
+++ b/resources/i18n/ru.json
@@ -913,16 +913,19 @@
     "64chars": "(максимум 64 символа)"
   },
   "modelService": {
+    "AFolderWithSimilarNameExists": "Папка с аналогичным именем уже существует",
     "Active": "Активный",
     "Active/Total": "Активный/Всего",
     "AddRules": "Добавить правила",
     "AdditionalMounts": "Дополнительные крепления",
     "AutoScalingRules": "Автоматические правила",
     "BasePath": "Базовый путь",
+    "BothDefinitionFilesRequired": "Модель-определения. YAML и Service-Definition.TOML Файлы требуются.",
     "Cancel": "Отмена",
     "CannotValidateNow": "Невозможно проверить услугу сейчас. \nПожалуйста, проверьте распределение ресурсов или другие конфигурации.",
     "Chatting": "Общение",
     "ClearErrors": "Очистить ошибку и повторить попытку",
+    "CloneModelFolderConfirm": "Чтобы запустить услугу модели, папку нужно клонировать. \nХотели бы вы клонировать его как <strong>\"{{folderName}}\"</strong> и запустить службу?",
     "Controls": "Средства управления",
     "CreatedAt": "Создано в",
     "CurrentTime": "Текущее время",
@@ -949,7 +952,10 @@
     "GoToServiceDetailPage": "Перейти на страницу сведений об обслуживании",
     "Image": "Изображение",
     "ModelDefinitionPath": "Путь к файлу определения модели",
+    "ModelDefinitionRequired": "Необходим файл модели.",
     "ModelMountDestination": "Место установки папки модели",
+    "ModelServiceCreationHasBeenCanceled": "Создание услуг моделей было отменено.",
+    "ModelServiceFailedToStart": "Не удалось запустить модельную службу.",
     "NoExtraMounts": "Никаких дополнительных креплений",
     "NoServiceEndpoint": "Отсутствие конечной точки обслуживания",
     "NumberOfReplicas": "Количество реплик",
@@ -972,7 +978,10 @@
     "RuntimeVariant": "Вариант времени выполнения вывода",
     "SeeContainerLogs": "См. журналы контейнеров",
     "ServiceAlreadyExists": "Название услуги уже существует",
+    "ServiceConfigurationNotValid": "Конфигурация службы недействительна. \nПожалуйста, свяжитесь с администратором.",
     "ServiceCreated": "Сервис модели {{ name }} успешно создан.",
+    "ServiceDefinitionNotFound": "Файл определения службы не найден. \nДоступно только клонирование.",
+    "ServiceDefinitionRequired": "необходим файл service-definition.toml.",
     "ServiceDelegatedFrom": "Сервис модели создается {{ createdUser }}, но право владения сессией будет передано {{ sessionOwner }}.",
     "ServiceEndpoint": "Конечная точка обслуживания",
     "ServiceInfo": "Служебная информация",
@@ -1005,14 +1014,17 @@
     "TokenGenerationFailed": "Не удалось сгенерировать токен. Пожалуйста, попробуйте еще раз.",
     "TrafficRatio": "Коэффициент трафика",
     "UpdateService": "Служба обновлений",
+    "UseExistingFolderConfirm": "Хотели бы вы запустить службу, используя существующую папку {{folderName}}?",
     "Validate": "Подтвердить",
     "ValidationInfo": "Информация о проверке"
   },
   "modelStore": {
     "Author": "Автор",
     "Category": "Категория",
+    "CheckingSettings": "Проверка настроек ...",
     "CloneAsFolder": "клонировать как папку",
     "CloneInfo": "Она будет клонирована как папка вашего типа пользователя.",
+    "CloneRequired": "Требуется клон",
     "CloneSuccess": "Запрос на клонирование успешно отправлен.",
     "CloneToFolder": "Клонирование в папку",
     "Created": "Созданный",
@@ -1022,12 +1034,14 @@
     "FolderAlreadyExists": "Папка с таким именем уже существует.",
     "Framework": "Рамка",
     "HealthCheck": "Проверка здоровья",
+    "InvalidModelName": "Неверное название модели",
     "Label": "Этикетка",
     "LastModified": "Последнее изменение",
     "MaxRetries": "Макс. повторов",
     "Metadata": "Метаданные",
     "MinResource": "Минимальный ресурс",
     "Model": "Модель",
+    "ModelNameIsRequired": "Для создания службы необходимо имя модели.",
     "ModelPath": "Путь модели",
     "Path": "Путь",
     "Port": "Порт",
diff --git a/resources/i18n/th.json b/resources/i18n/th.json
index 6492dceb99..fc30f614cd 100644
--- a/resources/i18n/th.json
+++ b/resources/i18n/th.json
@@ -903,16 +903,19 @@
     "64chars": "(สูงสุด 64 ตัวอักษร)"
   },
   "modelService": {
+    "AFolderWithSimilarNameExists": "โฟลเดอร์ที่มีชื่อคล้ายกันอยู่แล้ว",
     "Active": "คล่องแคล่ว",
     "Active/Total": "ใช้งาน/ทั้งหมด",
     "AddRules": "เพิ่มกฎ",
     "AdditionalMounts": "การเมาท์เพิ่มเติม",
     "AutoScalingRules": "กฎการปรับขนาดอัตโนมัติ",
     "BasePath": "เส้นทางฐาน",
+    "BothDefinitionFilesRequired": "จำเป็นต้องใช้ไฟล์ model-definition.yaml และ service-definition.toml",
     "Cancel": "ยกเลิก",
     "CannotValidateNow": "ไม่สามารถตรวจสอบบริการได้ในขณะนี้ กรุณาตรวจสอบการจัดสรรทรัพยากรหรือการกำหนดค่าอื่น ๆ",
     "Chatting": "การแชท",
     "ClearErrors": "ล้างข้อผิดพลาดและลองใหม่",
+    "CloneModelFolderConfirm": "ในการเรียกใช้บริการรุ่นโฟลเดอร์จะต้องถูกโคลน \nคุณต้องการโคลนเป็น <strong>\"{{folderName}}\"</strong> และเริ่มบริการหรือไม่?",
     "Controls": "การควบคุม",
     "CreatedAt": "สร้างเมื่อ",
     "CurrentTime": "เวลาปัจจุบัน",
@@ -939,7 +942,10 @@
     "GoToServiceDetailPage": "ไปที่หน้ารายละเอียดบริการ",
     "Image": "อิมเมจ",
     "ModelDefinitionPath": "เส้นทางไฟล์กำหนดโมเดล",
+    "ModelDefinitionRequired": "จำเป็นต้องใช้ไฟล์ model-definition.yaml",
     "ModelMountDestination": "ปลายทางการเมาท์สำหรับโฟลเดอร์โมเดล",
+    "ModelServiceCreationHasBeenCanceled": "การสร้างบริการแบบจำลองได้ถูกยกเลิก",
+    "ModelServiceFailedToStart": "ไม่สามารถเริ่มบริการรุ่น",
     "NoExtraMounts": "ไม่มีการเมาท์เพิ่มเติม",
     "NoServiceEndpoint": "ไม่มีจุดสิ้นสุดบริการ",
     "NumberOfReplicas": "จำนวนแบบจำลอง",
@@ -962,7 +968,10 @@
     "RuntimeVariant": "ตัวแปรรันไทม์การอนุมาน",
     "SeeContainerLogs": "ดูบันทึกคอนเทนเนอร์",
     "ServiceAlreadyExists": "ชื่อบริการมีอยู่แล้ว",
+    "ServiceConfigurationNotValid": "การกำหนดค่าบริการไม่ถูกต้อง \nกรุณาติดต่อผู้ดูแลระบบ",
     "ServiceCreated": "สร้างบริการโมเดล {{ name }} สำเร็จแล้ว",
+    "ServiceDefinitionNotFound": "ไม่พบไฟล์นิยามบริการ \nมีเพียงการโคลนนิ่งเท่านั้น",
+    "ServiceDefinitionRequired": "ต้องการไฟล์ service-definition.toml",
     "ServiceDelegatedFrom": "บริการโมเดลถูกสร้างโดย {{ createdUser }} แต่ความเป็นเจ้าของเซสชันจะถูกมอบหมายให้ {{ sessionOwner }}",
     "ServiceEndpoint": "จุดสิ้นสุดบริการ",
     "ServiceInfo": "ข้อมูลบริการ",
@@ -995,14 +1004,17 @@
     "TokenGenerationFailed": "การสร้างโทเคนล้มเหลว กรุณาลองอีกครั้ง",
     "TrafficRatio": "สัดส่วนการจราจร",
     "UpdateService": "อัปเดตบริการ",
+    "UseExistingFolderConfirm": "คุณต้องการเริ่มบริการโดยใช้โฟลเดอร์ {{folderName}} ที่มีอยู่หรือไม่?",
     "Validate": "ตรวจสอบ",
     "ValidationInfo": "ข้อมูลการตรวจสอบ"
   },
   "modelStore": {
     "Author": "ผู้เขียน",
     "Category": "หมวดหมู่",
+    "CheckingSettings": "ตรวจสอบการตั้งค่า ...",
     "CloneAsFolder": "โคลนเป็นโฟลเดอร์",
     "CloneInfo": "จะถูกโคลนเป็นโฟลเดอร์ประเภทผู้ใช้ของคุณ",
+    "CloneRequired": "จำเป็นต้องใช้โคลน",
     "CloneSuccess": "ส่งคำขอโคลนสำเร็จแล้ว",
     "CloneToFolder": "โคลนไปยังโฟลเดอร์",
     "Created": "สร้างเมื่อ",
@@ -1012,12 +1024,14 @@
     "FolderAlreadyExists": "มีโฟลเดอร์ชื่อนี้อยู่แล้ว",
     "Framework": "เฟรมเวิร์ก",
     "HealthCheck": "ตรวจสอบสถานะ",
+    "InvalidModelName": "ชื่อรุ่นไม่ถูกต้อง",
     "Label": "ป้ายกำกับ",
     "LastModified": "แก้ไขล่าสุด",
     "MaxRetries": "จำนวนครั้งที่ลองใหม่สูงสุด",
     "Metadata": "ข้อมูลเมตา",
     "MinResource": "ทรัพยากรขั้นต่ำ",
     "Model": "โมเดล",
+    "ModelNameIsRequired": "ต้องระบุชื่อรุ่นเพื่อสร้างบริการ",
     "ModelPath": "เส้นทางโมเดล",
     "Path": "เส้นทาง",
     "Port": "พอร์ต",
diff --git a/resources/i18n/tr.json b/resources/i18n/tr.json
index 9b68f596af..03dfc93a14 100644
--- a/resources/i18n/tr.json
+++ b/resources/i18n/tr.json
@@ -914,16 +914,19 @@
     "64chars": "(maksimum 64 karakter)"
   },
   "modelService": {
+    "AFolderWithSimilarNameExists": "Benzer bir isme sahip bir klasör zaten var",
     "Active": "Aktif",
     "Active/Total": "Aktif/Toplam",
     "AddRules": "Kurallar Ekle",
     "AdditionalMounts": "Ek Montajlar",
     "AutoScalingRules": "Otomatik Ölçeklendirme Kuralları",
     "BasePath": "Temel Yol",
+    "BothDefinitionFilesRequired": "Model-Definition.yaml ve Service-Definition.toml dosyaları gereklidir.",
     "Cancel": "İptal etmek",
     "CannotValidateNow": "Hizmet şu anda doğrulanamıyor. \nLütfen kaynak tahsisini veya diğer yapılandırmaları kontrol edin.",
     "Chatting": "Sohbet",
     "ClearErrors": "Hatayı temizle ve yeniden dene",
+    "CloneModelFolderConfirm": "Model hizmetini çalıştırmak için klasörün klonlanması gerekir. \nBunu <strong>\"{{folderName}}\"</strong> olarak klonlamak ve hizmeti başlatmak ister misiniz?",
     "Controls": "Kontroller",
     "CreatedAt": "Şu Adreste Oluşturuldu",
     "CurrentTime": "Geçerli saat",
@@ -950,7 +953,10 @@
     "GoToServiceDetailPage": "Servis Ayrıntısı sayfasına gidin",
     "Image": "Resim",
     "ModelDefinitionPath": "Model Tanımı Dosya Yolu",
+    "ModelDefinitionRequired": "Model-Definition.YAML dosyası gereklidir.",
     "ModelMountDestination": "Model Klasörü İçin Montaj Hedefi",
+    "ModelServiceCreationHasBeenCanceled": "Model hizmet oluşturma iptal edildi.",
+    "ModelServiceFailedToStart": "Model hizmeti başlatılamadı.",
     "NoExtraMounts": "Ekstra montaj yok",
     "NoServiceEndpoint": "Hizmet Uç Noktası Yok",
     "NumberOfReplicas": "Kopya sayısı",
@@ -973,7 +979,10 @@
     "RuntimeVariant": "Çıkarım Çalışma Zamanı Varyantı",
     "SeeContainerLogs": "Konteyner Günlüklerini görün",
     "ServiceAlreadyExists": "Hizmet Adı zaten var",
+    "ServiceConfigurationNotValid": "Hizmet yapılandırması geçersiz. \nLütfen yöneticiyle iletişime geçin.",
     "ServiceCreated": "Model hizmeti {{ name }} başarıyla oluşturuldu.",
+    "ServiceDefinitionNotFound": "Hizmet Tanımı Dosyası bulunamadı. \nSadece klonlama mevcuttur.",
+    "ServiceDefinitionRequired": "Service-Definition.toml dosyası gereklidir.",
     "ServiceDelegatedFrom": "Model hizmeti {{ createdUser }} tarafından oluşturulur ancak oturum sahipliği {{ sessionOwner }}'a devredilir.",
     "ServiceEndpoint": "Hizmet Uç Noktası",
     "ServiceInfo": "Servis Bilgileri",
@@ -1006,14 +1015,17 @@
     "TokenGenerationFailed": "Jeton üretimi başarısız oldu. lütfen tekrar deneyin.",
     "TrafficRatio": "Trafik Oranı",
     "UpdateService": "Güncelleme Hizmeti",
+    "UseExistingFolderConfirm": "Hizmeti mevcut {{folderName}} klasörünü kullanarak başlatmak ister misiniz?",
     "Validate": "Doğrula",
     "ValidationInfo": "Doğrulama Bilgisi"
   },
   "modelStore": {
     "Author": "Yazar",
     "Category": "Kategori",
+    "CheckingSettings": "Ayarları kontrol etme ...",
     "CloneAsFolder": "Klasör olarak klonla",
     "CloneInfo": "Kullanıcı tipi klasörünüz olarak klonlanacaktır.",
+    "CloneRequired": "Klon gerekli",
     "CloneSuccess": "Klonlama isteği başarıyla gönderildi.",
     "CloneToFolder": "Bir klasöre klonlama",
     "Created": "Oluşturuldu",
@@ -1023,12 +1035,14 @@
     "FolderAlreadyExists": "Bu isimde bir klasör zaten mevcut.",
     "Framework": "Çerçeve",
     "HealthCheck": "Sağlık kontrolü",
+    "InvalidModelName": "Geçersiz model adı",
     "Label": "Etiket",
     "LastModified": "Son düzenleme",
     "MaxRetries": "Maksimum Yeniden Deneme Sayısı",
     "Metadata": "Meta veriler",
     "MinResource": "Minimum Kaynak",
     "Model": "Modeli",
+    "ModelNameIsRequired": "Hizmet oluşturmak için model adı gereklidir",
     "ModelPath": "Model Yolu",
     "Path": "Yol",
     "Port": "Liman",
diff --git a/resources/i18n/vi.json b/resources/i18n/vi.json
index 5c2ce67f96..6ea10fddf9 100644
--- a/resources/i18n/vi.json
+++ b/resources/i18n/vi.json
@@ -914,16 +914,19 @@
     "64chars": "(tối đa 64 ký tự)"
   },
   "modelService": {
+    "AFolderWithSimilarNameExists": "Một thư mục có tên tương tự đã tồn tại",
     "Active": "Tích cực",
     "Active/Total": "Đang hoạt động/Tổng cộng",
     "AddRules": "Thêm quy tắc",
     "AdditionalMounts": "Gắn kết bổ sung",
     "AutoScalingRules": "Quy tắc mở rộng tự động",
     "BasePath": "Đường cơ sở",
+    "BothDefinitionFilesRequired": "Các tệp-định nghĩa mô hình.yaml và dịch vụ-định nghĩa.toml là bắt buộc.",
     "Cancel": "Hủy bỏ",
     "CannotValidateNow": "Không thể xác nhận dịch vụ bây giờ. \nVui lòng kiểm tra phân bổ tài nguyên hoặc các cấu hình khác.",
     "Chatting": "Trò chuyện",
     "ClearErrors": "Xóa lỗi và thử lại",
+    "CloneModelFolderConfirm": "Để chạy dịch vụ mô hình, thư mục cần được nhân bản. \nBạn có muốn sao chép nó dưới dạng <strong>\"{{folderName}}\"</strong> và bắt đầu dịch vụ không?",
     "Controls": "Điều khiển",
     "CreatedAt": "Được tạo tại",
     "CurrentTime": "Thời điểm hiện tại",
@@ -950,7 +953,10 @@
     "GoToServiceDetailPage": "Đi đến trang chi tiết dịch vụ",
     "Image": "Hình ảnh",
     "ModelDefinitionPath": "Đường dẫn tệp định nghĩa mô hình",
+    "ModelDefinitionRequired": "Cần định nghĩa mô hình.YAML.",
     "ModelMountDestination": "Mount đích cho thư mục mẫu",
+    "ModelServiceCreationHasBeenCanceled": "Tạo dịch vụ mô hình đã bị hủy bỏ.",
+    "ModelServiceFailedToStart": "Không thể bắt đầu dịch vụ mô hình.",
     "NoExtraMounts": "Không có gắn kết bổ sung",
     "NoServiceEndpoint": "Không có điểm cuối dịch vụ",
     "NumberOfReplicas": "Số lượng bản sao",
@@ -973,7 +979,10 @@
     "RuntimeVariant": "Biến thể thời gian chạy suy luận",
     "SeeContainerLogs": "Xem nhật ký vùng chứa",
     "ServiceAlreadyExists": "Tên dịch vụ đã tồn tại",
+    "ServiceConfigurationNotValid": "Cấu hình dịch vụ không hợp lệ. \nVui lòng liên hệ với quản trị viên.",
     "ServiceCreated": "Dịch vụ mẫu {{ name }} đã được tạo thành công.",
+    "ServiceDefinitionNotFound": "Tệp định nghĩa dịch vụ không tìm thấy. \nChỉ nhân bản có sẵn.",
+    "ServiceDefinitionRequired": "Cần định nghĩa dịch vụ.TOML.",
     "ServiceDelegatedFrom": "Dịch vụ mô hình được tạo bởi {{ createUser }} nhưng quyền sở hữu phiên sẽ được ủy quyền cho {{ sessionOwner }}",
     "ServiceEndpoint": "Điểm cuối dịch vụ",
     "ServiceInfo": "Thông tin dịch vụ",
@@ -1006,14 +1015,17 @@
     "TokenGenerationFailed": "Tạo mã thông báo không thành công. \nvui lòng thử lại.",
     "TrafficRatio": "Tỷ lệ lưu lượng truy cập",
     "UpdateService": "Dịch vụ cập nhật",
+    "UseExistingFolderConfirm": "Bạn có muốn bắt đầu dịch vụ bằng thư mục {{folderName}} hiện có không?",
     "Validate": "Xác thực",
     "ValidationInfo": "Thông tin xác thực"
   },
   "modelStore": {
     "Author": "Tác giả",
     "Category": "Loại",
+    "CheckingSettings": "Kiểm tra cài đặt ...",
     "CloneAsFolder": "Sao chép dưới dạng Thư mục",
     "CloneInfo": "Nó sẽ được sao chép thành thư mục loại người dùng của bạn.",
+    "CloneRequired": "Nhân bản cần thiết",
     "CloneSuccess": "Yêu cầu nhân bản đã được gửi thành công.",
     "CloneToFolder": "Sao chép vào một thư mục",
     "Created": "Tạo",
@@ -1023,12 +1035,14 @@
     "FolderAlreadyExists": "Một thư mục có tên này đã tồn tại.",
     "Framework": "Khung",
     "HealthCheck": "Kiểm tra sức khỏe",
+    "InvalidModelName": "Tên mẫu không hợp lệ",
     "Label": "Nhãn",
     "LastModified": "Sửa đổi lần cuối",
     "MaxRetries": "Số lần thử lại tối đa",
     "Metadata": "metadata",
     "MinResource": "Tài nguyên tối thiểu",
     "Model": "Người mẫu",
+    "ModelNameIsRequired": "Cần có tên mẫu để tạo dịch vụ",
     "ModelPath": "Đường dẫn mẫu",
     "Path": "Con đường",
     "Port": "Hải cảng",
diff --git a/resources/i18n/zh-CN.json b/resources/i18n/zh-CN.json
index 4dba80a3cb..2024a79da8 100644
--- a/resources/i18n/zh-CN.json
+++ b/resources/i18n/zh-CN.json
@@ -914,16 +914,19 @@
     "64chars": "（最多 64 个字符）"
   },
   "modelService": {
+    "AFolderWithSimilarNameExists": "一个具有相似名称的文件夹已经存在",
     "Active": "积极的",
     "Active/Total": "活动/总数",
     "AddRules": "添加规则",
     "AdditionalMounts": "附加安装座",
     "AutoScalingRules": "自动缩放规则",
     "BasePath": "基地路径",
+    "BothDefinitionFilesRequired": "需要模型定义。yAML和Service-definition.toml文件。",
     "Cancel": "取消",
     "CannotValidateNow": "现在无法验证服务。\n请检查资源分配或其他配置。",
     "Chatting": "聊天",
     "ClearErrors": "清除错误并重试",
+    "CloneModelFolderConfirm": "要运行模型服务，需要克隆文件夹。\n您想将其克隆为<strong>\"{{folderName}}\"</strong>并启动服务吗？",
     "Controls": "控制装置",
     "CreatedAt": "创建于",
     "CurrentTime": "当前时间",
@@ -950,7 +953,10 @@
     "GoToServiceDetailPage": "转到服务详细信息页面",
     "Image": "图片",
     "ModelDefinitionPath": "模型定义文件路径",
+    "ModelDefinitionRequired": "需要模型定义。yaml文件。",
     "ModelMountDestination": "模型文件夹的安装目标",
+    "ModelServiceCreationHasBeenCanceled": "模型服务创建已被取消。",
+    "ModelServiceFailedToStart": "无法启动模型服务。",
     "NoExtraMounts": "没有额外的安装座",
     "NoServiceEndpoint": "无服务端点",
     "NumberOfReplicas": "副本数量",
@@ -973,7 +979,10 @@
     "RuntimeVariant": "推理运行时变量",
     "SeeContainerLogs": "查看容器日志",
     "ServiceAlreadyExists": "服务名称已经存在",
+    "ServiceConfigurationNotValid": "服务配置无效。\n请联系管理员。",
     "ServiceCreated": "模型服务 {{ name }} 已成功创建。",
+    "ServiceDefinitionNotFound": "服务定义文件找不到。\n只有克隆可用。",
+    "ServiceDefinitionRequired": "需要服务定义。toml文件。",
     "ServiceDelegatedFrom": "模型服务由 {{ createdUser }} 创建，但会话所有权将委托给 {{ sessionOwner }}",
     "ServiceEndpoint": "服务端点",
     "ServiceInfo": "服务信息",
@@ -1006,14 +1015,17 @@
     "TokenGenerationFailed": "令牌生成失败，请重试。",
     "TrafficRatio": "交通比率",
     "UpdateService": "更新服务",
+    "UseExistingFolderConfirm": "您想使用现有{{folderName}}文件夹启动服务吗？",
     "Validate": "证实",
     "ValidationInfo": "验证信息"
   },
   "modelStore": {
     "Author": "作者",
     "Category": "类别",
+    "CheckingSettings": "检查设置...",
     "CloneAsFolder": "克隆为文件夹",
     "CloneInfo": "它将被克隆为用户类型文件夹。",
+    "CloneRequired": "需要克隆",
     "CloneSuccess": "克隆请求已成功发送。",
     "CloneToFolder": "克隆到文件夹",
     "Created": "已创建",
@@ -1023,12 +1035,14 @@
     "FolderAlreadyExists": "该名称的文件夹已经存在。",
     "Framework": "框架",
     "HealthCheck": "健康检查",
+    "InvalidModelName": "型号名称无效",
     "Label": "标签",
     "LastModified": "上一次更改",
     "MaxRetries": "最大重试次数",
     "Metadata": "元数据",
     "MinResource": "最小资源",
     "Model": "模型",
+    "ModelNameIsRequired": "创建服务时需要模型名称",
     "ModelPath": "模型路径",
     "Path": "小路",
     "Port": "港口",
diff --git a/resources/i18n/zh-TW.json b/resources/i18n/zh-TW.json
index cc02375d03..8bcee4ca50 100644
--- a/resources/i18n/zh-TW.json
+++ b/resources/i18n/zh-TW.json
@@ -913,6 +913,7 @@
     "64chars": "（最多 64 個字符）"
   },
   "modelService": {
+    "AFolderWithSimilarNameExists": "一個具有相似名稱的文件夾已經存在",
     "Active": "積極的",
     "Active/Total": "活动/总数",
     "AddRules": "添加規則",
@@ -923,6 +924,7 @@
     "CannotValidateNow": "現在無法驗證服務。\n請檢查資源分配或其他配置。",
     "Chatting": "聊天",
     "ClearErrors": "清除错误并重试",
+    "CloneModelFolderConfirm": "要運行模型服務，需要克隆文件夾。您想將其克隆為{{folderName}}並啟動服務嗎？",
     "Controls": "控制装置",
     "CreatedAt": "创建于",
     "CurrentTime": "当前时间",
@@ -973,6 +975,7 @@
     "SeeContainerLogs": "查看容器日誌",
     "ServiceAlreadyExists": "服務名稱已經存在",
     "ServiceCreated": "模型服務 {{ name }} 已成功建立。",
+    "ServiceDefinitionNotFound": "服務定義文件找不到。只有克隆可用。",
     "ServiceDelegatedFrom": "模型服务由 {{ createdUser }} 创建，但会话所有权将委托给 {{ sessionOwner }}",
     "ServiceEndpoint": "服务端点",
     "ServiceInfo": "服务信息",
@@ -1005,6 +1008,7 @@
     "TokenGenerationFailed": "令牌生成失败，请重试。",
     "TrafficRatio": "交通比率",
     "UpdateService": "更新服務",
+    "UseExistingFolderConfirm": "您想使用現有{{folderName}}文件夾啟動服務嗎？",
     "Validate": "證實",
     "ValidationInfo": "驗證訊息"
   },
@@ -1013,6 +1017,7 @@
     "Category": "类别",
     "CloneAsFolder": "克隆为文件夹",
     "CloneInfo": "它将被克隆为用户类型文件夹。",
+    "CloneRequired": "需要克隆",
     "CloneSuccess": "克隆请求已成功发送。",
     "CloneToFolder": "克隆到文件夹",
     "Created": "已創建",
@@ -1022,12 +1027,14 @@
     "FolderAlreadyExists": "该名称的文件夹已经存在。",
     "Framework": "框架",
     "HealthCheck": "健康檢查",
+    "InvalidModelName": "型號名稱無效",
     "Label": "标签",
     "LastModified": "上一次更改",
     "MaxRetries": "最大重試次數",
     "Metadata": "元數據",
     "MinResource": "最小資源",
     "Model": "模型",
+    "ModelNameIsRequired": "創建服務時需要模型名稱",
     "ModelPath": "模型路徑",
     "Path": "小路",
     "Port": "港口",
diff --git a/resources/model_card_metadata.json b/resources/model_card_metadata.json
index 9e26dfeeb6..0967ef424b 100644
--- a/resources/model_card_metadata.json
+++ b/resources/model_card_metadata.json
@@ -1 +1 @@
-{}
\ No newline at end of file
+{}