add model update and delete

llama_stack/apis/models/client.py

@@ -7,7 +7,7 @@
 import asyncio
 import json
 
-from typing import List, Optional
+from typing import Any, Dict, List, Optional
 
 import fire
 import httpx
@@ -61,6 +61,36 @@ class ModelsClient(Models):
                 return None
             return Model(**j)
 
+    async def update_model(
+        self,
+        model_id: str,
+        provider_model_id: Optional[str] = None,
+        provider_id: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Model:
+        async with httpx.AsyncClient() as client:
+            response = await client.put(
+                f"{self.base_url}/models/update",
+                json={
+                    "model_id": model_id,
+                    "provider_model_id": provider_model_id,
+                    "provider_id": provider_id,
+                    "metadata": metadata,
+                },
+                headers={"Content-Type": "application/json"},
+            )
+            response.raise_for_status()
+            return Model(**response.json())
+
+    async def delete_model(self, model_id: str) -> None:
+        async with httpx.AsyncClient() as client:
+            response = await client.delete(
+                f"{self.base_url}/models/delete",
+                params={"model_id": model_id},
+                headers={"Content-Type": "application/json"},
+            )
+            response.raise_for_status()
+
 
 async def run_main(host: str, port: int, stream: bool):
     client = ModelsClient(f"http://{host}:{port}")

llama_stack/apis/models/models.py

@@ -54,3 +54,15 @@ class Models(Protocol):
         provider_id: Optional[str] = None,
         metadata: Optional[Dict[str, Any]] = None,
     ) -> Model: ...
+
+    @webmethod(route="/models/update", method="PUT")
+    async def update_model(
+        self,
+        model_id: str,
+        provider_model_id: Optional[str] = None,
+        provider_id: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Model: ...
+
+    @webmethod(route="/models/delete", method="DELETE")
+    async def delete_model(self, model_id: str) -> None: ...

llama_stack/distribution/routers/routing_tables.py

@@ -152,6 +152,10 @@ class CommonRoutingTableImpl(RoutingTable):
         assert len(objects) == 1
         return objects[0]
 
+    async def delete_object(self, obj: RoutableObjectWithProvider) -> None:
+        await self.dist_registry.delete(obj.type, obj.identifier)
+        # TODO: delete from provider
+
     async def register_object(
         self, obj: RoutableObjectWithProvider
     ) -> RoutableObjectWithProvider:
@@ -225,6 +229,33 @@ class ModelsRoutingTable(CommonRoutingTableImpl, Models):
         registered_model = await self.register_object(model)
         return registered_model
 
+    async def update_model(
+        self,
+        model_id: str,
+        provider_model_id: Optional[str] = None,
+        provider_id: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Model:
+        existing_model = await self.get_model(model_id)
+        if existing_model is None:
+            raise ValueError(f"Model {model_id} not found")
+
+        updated_model = Model(
+            identifier=model_id,
+            provider_resource_id=provider_model_id
+            or existing_model.provider_resource_id,
+            provider_id=provider_id or existing_model.provider_id,
+            metadata=metadata or existing_model.metadata,
+        )
+        registered_model = await self.register_object(updated_model)
+        return registered_model
+
+    async def delete_model(self, model_id: str) -> None:
+        existing_model = await self.get_model(model_id)
+        if existing_model is None:
+            raise ValueError(f"Model {model_id} not found")
+        await self.delete_object(existing_model)
+
 
 class ShieldsRoutingTable(CommonRoutingTableImpl, Shields):
     async def list_shields(self) -> List[Shield]:

llama_stack/distribution/store/registry.py

@@ -36,6 +36,8 @@ class DistributionRegistry(Protocol):
     # The current approach could lead to inconsistencies if the same logical object has different data across providers.
     async def register(self, obj: RoutableObjectWithProvider) -> bool: ...
 
+    async def delete(self, type: str, identifier: str) -> None: ...
+
 
 REGISTER_PREFIX = "distributions:registry"
 KEY_VERSION = "v1"
@@ -120,6 +122,9 @@ class DiskDistributionRegistry(DistributionRegistry):
         )
         return True
 
+    async def delete(self, type: str, identifier: str) -> None:
+        await self.kvstore.delete(KEY_FORMAT.format(type=type, identifier=identifier))
+
 
 class CachedDiskDistributionRegistry(DiskDistributionRegistry):
     def __init__(self, kvstore: KVStore):
@@ -206,6 +211,13 @@ class CachedDiskDistributionRegistry(DiskDistributionRegistry):
 
         return success
 
+    async def delete(self, type: str, identifier: str) -> None:
+        await super().delete(type, identifier)
+        cache_key = (type, identifier)
+        async with self._locked_cache() as cache:
+            if cache_key in cache:
+                del cache[cache_key]
+
 
 async def create_dist_registry(
     metadata_store: Optional[KVStoreConfig],