Sorting on models page by Last Modified is reflecting changes in versions as well

frontend/src/api/modelRegistry/__tests__/custom.spec.ts

@@ -118,7 +118,7 @@ describe('createModelVersionForRegisteredModel', () => {
         state: ModelState.LIVE,
         customProperties: {},
       }),
-    ).toBe(mockResultPromise);
+    ).toEqual(mockResultPromise);
     expect(proxyCREATEMock).toHaveBeenCalledTimes(1);
     expect(proxyCREATEMock).toHaveBeenCalledWith(
       'hostPath',

frontend/src/api/modelRegistry/custom.ts

@@ -9,9 +9,10 @@ import {
   RegisteredModelList,
   RegisteredModel,
 } from '~/concepts/modelRegistry/types';
+import { MODEL_REGISTRY_API_VERSION } from '~/concepts/modelRegistry/const';
+import { bumpRegisteredModelTimestamp } from '~/concepts/modelRegistry/utils/updateTimestamps';
 import { proxyCREATE, proxyGET, proxyPATCH } from '~/api/proxyUtils';
 import { K8sAPIOptions } from '~/k8sTypes';
-import { MODEL_REGISTRY_API_VERSION } from '~/concepts/modelRegistry/const';
 import { handleModelRegistryFailures } from './errorUtils';
 
 export const createRegisteredModel =
@@ -41,12 +42,12 @@ export const createModelVersion =
     );
 export const createModelVersionForRegisteredModel =
   (hostpath: string) =>
-  (
+  async (
     opts: K8sAPIOptions,
     registeredModelId: string,
     data: CreateModelVersionData,
-  ): Promise<ModelVersion> =>
-    handleModelRegistryFailures(
+  ): Promise<ModelVersion> => {
+    const newVersion = await handleModelRegistryFailures<ModelVersion>(
       proxyCREATE(
         hostpath,
         `/api/model_registry/${MODEL_REGISTRY_API_VERSION}/registered_models/${registeredModelId}/versions`,
@@ -56,6 +57,25 @@ export const createModelVersionForRegisteredModel =
       ),
     );
 
+    // Use the established timestamp update utility
+    await bumpRegisteredModelTimestamp(
+      {
+        patchRegisteredModel: (apiOpts, patchData, id) =>
+          handleModelRegistryFailures(
+            proxyPATCH(
+              hostpath,
+              `/api/model_registry/${MODEL_REGISTRY_API_VERSION}/registered_models/${id}`,
+              patchData,
+              apiOpts,
+            ),
+          ),
+      },
+      registeredModelId,
+    );
+
+    return newVersion;
+  };
+
 export const createModelArtifact =
   (hostPath: string) =>
   (opts: K8sAPIOptions, data: CreateModelArtifactData): Promise<ModelArtifact> =>
@@ -194,7 +214,7 @@ export const patchRegisteredModel =
     data: Partial<RegisteredModel>,
     registeredModelId: string,
   ): Promise<RegisteredModel> =>
-    handleModelRegistryFailures(
+    handleModelRegistryFailures<RegisteredModel>(
       proxyPATCH(
         hostPath,
         `/api/model_registry/${MODEL_REGISTRY_API_VERSION}/registered_models/${registeredModelId}`,
@@ -208,12 +228,12 @@ export const patchModelVersion =
   (
     opts: K8sAPIOptions,
     data: Partial<ModelVersion>,
-    modelversionId: string,
+    modelVersionId: string,
   ): Promise<ModelVersion> =>
-    handleModelRegistryFailures(
+    handleModelRegistryFailures<ModelVersion>(
       proxyPATCH(
         hostPath,
-        `/api/model_registry/${MODEL_REGISTRY_API_VERSION}/model_versions/${modelversionId}`,
+        `/api/model_registry/${MODEL_REGISTRY_API_VERSION}/model_versions/${modelVersionId}`,
         data,
         opts,
       ),

frontend/src/concepts/modelRegistry/apiHooks/useModelVersionCreation.ts

@@ -0,0 +1,37 @@
+import * as React from 'react';
+import { CreateModelVersionData, ModelVersion, ModelState } from '~/concepts/modelRegistry/types';
+import { useModelRegistryAPI } from '~/concepts/modelRegistry/context/ModelRegistryContext';
+
+export const useModelVersionCreation = (): {
+  createVersionWithTimestampUpdate: (
+    registeredModelId: string,
+    data: CreateModelVersionData,
+    opts?: Record<string, unknown>,
+  ) => Promise<ModelVersion>;
+  apiAvailable: boolean;
+} => {
+  const { api, apiAvailable } = useModelRegistryAPI();
+
+  const createVersionWithTimestampUpdate = React.useCallback(
+    async (
+      registeredModelId: string,
+      data: CreateModelVersionData,
+      opts: Record<string, unknown> = {},
+    ): Promise<ModelVersion> => {
+      const newVersion = await api.createModelVersionForRegisteredModel(
+        opts,
+        registeredModelId,
+        data,
+      );
+      await api.patchRegisteredModel(opts, { state: ModelState.LIVE }, registeredModelId);
+
+      return newVersion;
+    },
+    [api],
+  );
+
+  return {
+    createVersionWithTimestampUpdate,
+    apiAvailable,
+  };
+};

frontend/src/concepts/modelRegistry/context/ModelRegistryContext.tsx

@@ -8,6 +8,7 @@ import { ContextResourceData, CustomWatchK8sResult } from '~/types';
 import { TemplateKind } from '~/k8sTypes';
 import { DEFAULT_CONTEXT_DATA, DEFAULT_LIST_WATCH_RESULT } from '~/utilities/const';
 import useTemplateDisablement from '~/pages/modelServing/customServingRuntimes/useTemplateDisablement';
+import { ModelVersion, RegisteredModel } from '~/concepts/modelRegistry/types';
 import useModelRegistryAPIState, { ModelRegistryAPIState } from './useModelRegistryAPIState';
 
 export type ModelRegistryContextType = {
@@ -67,6 +68,11 @@ export const ModelRegistryContextProvider = conditionalArea<ModelRegistryContext
 
 type UseModelRegistryAPI = ModelRegistryAPIState & {
   refreshAllAPI: () => void;
+  patchModelVersion: (modelVersionId: string, updates: Partial<ModelVersion>) => Promise<void>;
+  patchRegisteredModel: (
+    registeredModelId: string,
+    updates: Partial<RegisteredModel>,
+  ) => Promise<void>;
 };
 
 export const useModelRegistryAPI = (): UseModelRegistryAPI => {
@@ -75,5 +81,9 @@ export const useModelRegistryAPI = (): UseModelRegistryAPI => {
   return {
     refreshAllAPI,
     ...apiState,
+    patchModelVersion: (modelVersionId: string, updates: Partial<ModelVersion>) =>
+      apiState.api.patchModelVersion({}, updates, modelVersionId).then(() => undefined),
+    patchRegisteredModel: (registeredModelId: string, updates: Partial<RegisteredModel>) =>
+      apiState.api.patchRegisteredModel({}, updates, registeredModelId).then(() => undefined),
   };
 };

frontend/src/concepts/modelRegistry/utils/updateTimestamps.ts

@@ -0,0 +1,70 @@
+import {
+  ModelRegistryAPIs,
+  ModelState,
+  ModelRegistryMetadataType,
+} from '~/concepts/modelRegistry/types';
+
+type MinimalModelRegistryAPI = Pick<ModelRegistryAPIs, 'patchRegisteredModel'>;
+
+export const bumpModelVersionTimestamp = async (
+  api: ModelRegistryAPIs,
+  modelVersionId: string,
+): Promise<void> => {
+  if (!modelVersionId) {
+    throw new Error('Model version ID is required');
+  }
+
+  try {
+    await api.patchModelVersion({}, { state: ModelState.LIVE }, modelVersionId);
+  } catch (error) {
+    throw new Error(
+      `Failed to update model version timestamp: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    );
+  }
+};
+
+export const bumpRegisteredModelTimestamp = async (
+  api: MinimalModelRegistryAPI,
+  registeredModelId: string,
+): Promise<void> => {
+  if (!registeredModelId) {
+    throw new Error('Registered model ID is required');
+  }
+
+  try {
+    const currentTime = new Date().toISOString();
+    await api.patchRegisteredModel(
+      {},
+      {
+        state: ModelState.LIVE,
+        customProperties: {
+          _lastModified: {
+            metadataType: ModelRegistryMetadataType.STRING,
+            // eslint-disable-next-line camelcase
+            string_value: currentTime,
+          },
+        },
+      },
+      registeredModelId,
+    );
+  } catch (error) {
+    throw new Error(
+      `Failed to update registered model timestamp: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    );
+  }
+};
+
+export const bumpBothTimestamps = async (
+  api: ModelRegistryAPIs,
+  modelVersionId: string,
+  registeredModelId: string,
+): Promise<void> => {
+  await Promise.all([
+    bumpModelVersionTimestamp(api, modelVersionId),
+    bumpRegisteredModelTimestamp(api, registeredModelId),
+  ]);
+};