Update a context cache

fromdatetimeimport datetime as dt
fromdatetimeimport timezone as tz
fromdatetimeimport timedelta
fromgoogleimport genai
fromgoogle.genai.typesimport HttpOptions, UpdateCachedContentConfig
client = genai.Client(http_options=HttpOptions(api_version="v1"))
# Get content cache by name
# cache_name = "projects/.../locations/.../cachedContents/1111111111111111111"
content_cache = client.caches.get(name=cache_name)
print("Expire time", content_cache.expire_time)
# Example response
# Expire time 2025年02月20日 15:50:18.434482+00:00
# Update expire time using TTL
content_cache = client.caches.update(
 name=cache_name, config=UpdateCachedContentConfig(ttl="36000s")
)
time_diff = content_cache.expire_time - dt.now(tz.utc)
print("Expire time(after update):", content_cache.expire_time)
print("Expire time(in seconds):", time_diff.seconds)
# Example response
# Expire time(after update): 2025年02月14日 01:51:42.571696+00:00
# Expire time(in seconds): 35999
# Update expire time using specific time stamp
next_week_utc = dt.now(tz.utc) + timedelta(days=7)
content_cache = client.caches.update(
 name=cache_name, config=UpdateCachedContentConfig(expireTime=next_week_utc)
)
print("Expire time(after update):", content_cache.expire_time)
# Example response
# Expire time(after update): 2025年02月20日 15:51:42.614968+00:00

import(
	"context"
	"fmt"
	"io"
	"time"
	genai "google.golang.org/genai"
)
// updateContentCache shows how to update content cache expiration time.
func updateContentCache(w io.Writer, cacheName string) error {
	ctx := context.Background()
	client, err := genai.NewClient(ctx, &genai.ClientConfig{
		HTTPOptions: genai.HTTPOptions{APIVersion: "v1"},
	})
	if err != nil {
		return fmt.Errorf("failed to create genai client: %w", err)
	}
	// Update expire time using TTL
	resp, err := client.Caches.Update(ctx, cacheName, &genai.UpdateCachedContentConfig{
		TTL: time.Duration(time.Duration.Seconds(36000)),
	})
	if err != nil {
		return fmt.Errorf("failed to update content cache exp. time with TTL: %w", err)
	}
	fmt.Fprintf(w, "Cache expires in: %s\n", time.Until(resp.ExpireTime))
	// Example response:
	// Cache expires in: 10h0m0.005875s
	// Update expire time using specific time stamp
	inSevenDays := time.Now().Add(7 * 24 * time.Hour)
	resp, err = client.Caches.Update(ctx, cacheName, &genai.UpdateCachedContentConfig{
		ExpireTime: inSevenDays,
	})
	if err != nil {
		return fmt.Errorf("failed to update content cache expire time: %w", err)
	}
	fmt.Fprintf(w, "Cache expires in: %s\n", time.Until(resp.ExpireTime))
	// Example response:
	// Cache expires in: 167h59m59.80327s
	return nil
}

importcom.google.genai.Client;
importcom.google.genai.types.CachedContent;
importcom.google.genai.types.HttpOptions;
importcom.google.genai.types.UpdateCachedContentConfig;
importjava.time.Duration;
importjava.time.Instant;
importjava.time.temporal.ChronoUnit;
public classContentCacheUpdate {
 public static void main(String[] args) {
 // TODO(developer): Replace these variables before running the sample.
 // E.g cacheName = "projects/111111111111/locations/global/cachedContents/1111111111111111111"
 String cacheName = "your-cache-name";
 contentCacheUpdate(cacheName);
 }
 // Updates the cache using the specified cache resource name
 public static void contentCacheUpdate(String cacheName) {
 // Initialize client that will be used to send requests. This client only needs to be created
 // once, and can be reused for multiple requests.
 try (Client client =
 Client.builder()
 .location("global")
 .vertexAI(true)
 .httpOptions(HttpOptions.builder().apiVersion("v1").build())
 .build()) {
 // Get info of the cached content
 CachedContent cachedContent = client.caches.get(cacheName, null);
 cachedContent.expireTime()
 .ifPresent(expireTime -> System.out.println("Expire time: " + expireTime));
 // Example response
 // Expire time: 2025-07-29T23:39:49.227291Z
 // Update expire time using TTL
 CachedContent updatedCachedContent =
 client.caches.update(
 cacheName,
 UpdateCachedContentConfig.builder().ttl(Duration.ofSeconds(36000)).build());
 updatedCachedContent.expireTime()
 .ifPresent(expireTime -> System.out.println("Expire time after update: " + expireTime));
 // Example response
 // Expire time after update: 2025-07-30T08:40:33.537205Z
 // Update expire time using specific time stamp
 Instant nextWeek = Instant.now().plus(7, ChronoUnit.DAYS);
 updatedCachedContent =
 client.caches.update(
 cacheName, UpdateCachedContentConfig.builder().expireTime(nextWeek).build());
 updatedCachedContent
 .expireTime()
 .ifPresent(expireTime -> System.out.println("Expire time after update: " + expireTime));
 // Example response
 // Expire time after update: 2025-08-05T22:40:33.713988900Z
 System.out.println("Updated cache: " + cacheName);
 }
 }
}

const{GoogleGenAI}=require('@google/genai');
const{DateTime}=require('luxon');
constGOOGLE_CLOUD_PROJECT=process.env.GOOGLE_CLOUD_PROJECT;
constGOOGLE_CLOUD_LOCATION=process.env.GOOGLE_CLOUD_LOCATION||'global';
asyncfunctionupdateContentCache(
projectId=GOOGLE_CLOUD_PROJECT,
location=GOOGLE_CLOUD_LOCATION,
cacheName='example-cache'
){
constclient=newGoogleGenAI({
vertexai:true,
project:projectId,
location:location,
httpOptions:{
apiVersion:'v1',
},
});
letcontentCache=awaitclient.caches.get({
name:cacheName,
});
console.log('Expire time',contentCache.expireTime);
contentCache=awaitclient.caches.update({
name:cacheName,
config:{
ttl:'36000s',
},
});
constexpireTime=DateTime.fromISO(contentCache.expireTime,{zone:'utc'});
constnow=DateTime.utc();
consttimeDiff=expireTime.diff(now,['seconds']);
console.log('Expire time (after update):',expireTime.toISO());
console.log('Expire time (in seconds):',Math.floor(timeDiff.seconds));
constnextWeekUtc=DateTime.utc().plus({days:7});
console.log('Next week (UTC):',nextWeekUtc.toISO());
contentCache=awaitclient.caches.update({
name:cacheName,
config:{
expireTime:nextWeekUtc,
},
});
console.log('Expire time (after update):',contentCache.expireTime);
returncontentCache;
}
//Exampleresponse
//Expiretime(afterupdate):2025-02-2015:51:42.614968+00:00