feat: persist prompts and cache TTL

Restore dropped chat input when a target task disappears, autosave prompt history drafts, and send Bedrock cache point TTLs for eligible Claude models.

Author: allquixotic

packages/types/src/__tests__/bedrock.spec.ts

@@ -59,6 +59,12 @@ describe("Bedrock model catalog", () => {
 		expect((bedrockModels["anthropic.claude-sonnet-4-5-20250929-v1:0"] as ModelInfo).maxTokens).toBe(64_000)
 		expect((bedrockModels["anthropic.claude-haiku-4-5-20251001-v1:0"] as ModelInfo).maxTokens).toBe(64_000)
 	})
+
+	it("marks AWS-documented Claude 4.5 models for 1-hour Bedrock prompt cache TTL", () => {
+		expect((bedrockModels["anthropic.claude-sonnet-4-5-20250929-v1:0"] as ModelInfo).promptCacheTtl).toBe("1h")
+		expect((bedrockModels["anthropic.claude-haiku-4-5-20251001-v1:0"] as ModelInfo).promptCacheTtl).toBe("1h")
+		expect((bedrockModels["anthropic.claude-opus-4-5-20251101-v1:0"] as ModelInfo).promptCacheTtl).toBe("1h")
+	})
 })
 
 describe("resolveBedrockModelInfo", () => {

packages/types/src/model.ts

@@ -98,6 +98,8 @@ export const modelInfoSchema = z.object({
 	outputPrice: z.number().optional(),
 	cacheWritesPrice: z.number().optional(),
 	cacheReadsPrice: z.number().optional(),
+	// Bedrock Converse cachePoint TTL values. Omitted means provider default.
+	promptCacheTtl: z.enum(["5m", "1h"]).optional(),
 	longContextPricing: z
 		.object({
 			thresholdTokens: z.number(),

packages/types/src/providers/bedrock.ts

@@ -27,6 +27,7 @@ export const bedrockModels = {
 		minTokensPerCachePoint: 1024,
 		maxCachePoints: 4,
 		cachableFields: ["system", "messages", "tools"],
+		promptCacheTtl: "1h",
 	},
 	"anthropic.claude-sonnet-4-6": {
 		// Mirrors anthropic-direct cap; AWS Bedrock accepts the same upstream maximum.
@@ -220,6 +221,7 @@ export const bedrockModels = {
 		minTokensPerCachePoint: 1024,
 		maxCachePoints: 4,
 		cachableFields: ["system", "messages", "tools"],
+		promptCacheTtl: "1h",
 	},
 	"anthropic.claude-opus-4-20250514-v1:0": {
 		maxTokens: 8192,
@@ -289,6 +291,7 @@ export const bedrockModels = {
 		minTokensPerCachePoint: 2048,
 		maxCachePoints: 4,
 		cachableFields: ["system", "messages", "tools"],
+		promptCacheTtl: "1h",
 	},
 	"anthropic.claude-3-5-sonnet-20240620-v1:0": {
 		maxTokens: 8192,

src/api/providers/__tests__/bedrock.spec.ts

@@ -1252,6 +1252,8 @@ describe("AwsBedrockHandler", () => {
 		// System prompt must exceed minTokensPerCachePoint (1024) for cache points to be placed
 		const longSystemPrompt = "You are a helpful assistant. ".repeat(200)
 		const messages: Anthropic.Messages.MessageParam[] = [{ role: "user", content: "Hello" }]
+		const findCachePointBlock = (blocks: any[] | undefined) =>
+			blocks?.find((block: any) => block.cachePoint !== undefined)
 
 		it("should enable prompt caching by default when awsUsePromptCache is undefined", async () => {
 			const defaultHandler = new AwsBedrockHandler({
@@ -1274,6 +1276,44 @@ describe("AwsBedrockHandler", () => {
 			expect(hasCachePoint).toBe(true)
 		})
 
+		it("should set 1h ttl on system cache points for Claude 4.5 models", async () => {
+			const claude45Handler = new AwsBedrockHandler({
+				apiModelId: "anthropic.claude-sonnet-4-5-20250929-v1:0",
+				awsAccessKey: "test-access-key",
+				awsSecretKey: "test-secret-key",
+				awsRegion: "us-east-1",
+			})
+
+			const generator = claude45Handler.createMessage(longSystemPrompt, messages)
+			await generator.next()
+
+			expect(mockConverseStreamCommand).toHaveBeenCalled()
+			const commandArg = mockConverseStreamCommand.mock.calls[0][0] as any
+
+			expect(findCachePointBlock(commandArg.system)?.cachePoint).toEqual({ type: "default", ttl: "1h" })
+		})
+
+		it("should set 1h ttl on message cache points for Claude 4.5 models", async () => {
+			const claude45Handler = new AwsBedrockHandler({
+				apiModelId: "anthropic.claude-sonnet-4-5-20250929-v1:0",
+				awsAccessKey: "test-access-key",
+				awsSecretKey: "test-secret-key",
+				awsRegion: "us-east-1",
+			})
+			const longUserPrompt = Array.from({ length: 1_000 }, (_, index) => `cacheable${index}`).join(" ")
+
+			const generator = claude45Handler.createMessage("", [{ role: "user", content: longUserPrompt }])
+			await generator.next()
+
+			expect(mockConverseStreamCommand).toHaveBeenCalled()
+			const commandArg = mockConverseStreamCommand.mock.calls[0][0] as any
+
+			expect(findCachePointBlock(commandArg.messages?.[0]?.content)?.cachePoint).toEqual({
+				type: "default",
+				ttl: "1h",
+			})
+		})
+
 		it("should disable prompt caching when awsUsePromptCache is explicitly false", async () => {
 			const disabledHandler = new AwsBedrockHandler({
 				apiModelId: "anthropic.claude-3-5-sonnet-20241022-v2:0",

src/api/providers/bedrock.ts

@@ -43,7 +43,7 @@ import { BaseProvider } from "./base-provider"
 import { logger } from "../../utils/logging"
 import { Package } from "../../shared/package"
 import { MultiPointStrategy } from "../transform/cache-strategy/multi-point-strategy"
-import { ModelInfo as CacheModelInfo } from "../transform/cache-strategy/types"
+import type { ModelInfo as CacheModelInfo, CachePointTtl } from "../transform/cache-strategy/types"
 import { convertToBedrockConverseMessages as sharedConverter } from "../transform/bedrock-converse-format"
 import { getModelParams } from "../transform/model-params"
 import { shouldUseReasoningBudget } from "../../shared/api"
@@ -119,6 +119,16 @@ function normalizeReasoningEffortForBedrock(value: unknown): "low" | "medium" |
 	return undefined
 }
 
+function normalizeBedrockPromptCacheTtl(value: unknown): CachePointTtl | undefined {
+	return value === "5m" || value === "1h" ? value : undefined
+}
+
+function createBedrockCachePointContentBlock(ttl?: CachePointTtl): ContentBlock {
+	return {
+		cachePoint: ttl ? { type: "default", ttl } : { type: "default" },
+	} as unknown as ContentBlock
+}
+
 // Extended payload type that includes service_tier as a top-level parameter
 // AWS Bedrock service tiers (STANDARD, FLEX, PRIORITY) are specified at the top level
 // https://docs.aws.amazon.com/bedrock/latest/userguide/service-tiers-inference.html
@@ -959,13 +969,15 @@ export class AwsBedrockHandler extends BaseProvider implements SingleCompletionH
 		}
 
 		// Convert model info to expected format for cache strategy
+		const promptCacheTtl = normalizeBedrockPromptCacheTtl(modelInfo?.promptCacheTtl)
 		const cacheModelInfo: CacheModelInfo = {
 			maxTokens: modelInfo?.maxTokens || 8192,
 			contextWindow: modelInfo?.contextWindow || 200_000,
 			supportsPromptCache: modelInfo?.supportsPromptCache || false,
 			maxCachePoints: modelInfo?.maxCachePoints || 0,
 			minTokensPerCachePoint: modelInfo?.minTokensPerCachePoint || 50,
 			cachableFields: modelInfo?.cachableFields || [],
+			promptCacheTtl,
 		}
 
 		// Get previous cache point placements for this conversation if available
@@ -998,7 +1010,7 @@ export class AwsBedrockHandler extends BaseProvider implements SingleCompletionH
 			if (placement) {
 				return {
 					...msg,
-					content: [...(msg.content || []), { cachePoint: { type: "default" } } as ContentBlock],
+					content: [...(msg.content || []), createBedrockCachePointContentBlock(promptCacheTtl)],
 				}
 			}
 			return msg

src/api/transform/cache-strategy/__tests__/cache-strategy.spec.ts

@@ -41,6 +41,13 @@ const hasCachePoint = (block: ContentBlock | SystemContentBlock): boolean => {
 	)
 }
 
+const getCachePoint = (block: ContentBlock | SystemContentBlock): { type?: string; ttl?: string } | undefined => {
+	if (!("cachePoint" in block) || typeof block.cachePoint !== "object" || block.cachePoint === null) {
+		return undefined
+	}
+	return block.cachePoint as { type?: string; ttl?: string }
+}
+
 // Create a mock object to store the last config passed to convertToBedrockConverseMessages
 interface CacheConfig {
 	modelInfo: any
@@ -176,6 +183,25 @@ describe("Cache Strategy", () => {
 					expect(hasCachePoint(result.system[1])).toBe(true)
 				})
 
+				it("adds configured ttl to system cache blocks", () => {
+					const shortSystemPrompt = "You are a helpful assistant"
+
+					const config = createConfig({
+						messages: [{ role: "user", content: "Hello" }],
+						systemPrompt: shortSystemPrompt,
+						modelInfo: {
+							...defaultModelInfo,
+							minTokensPerCachePoint: 1,
+							promptCacheTtl: "1h",
+						},
+					})
+
+					const strategy = new MultiPointStrategy(config)
+					const result = strategy.determineOptimalCachePoints()
+
+					expect(getCachePoint(result.system[1])).toMatchObject({ type: "default", ttl: "1h" })
+				})
+
 				it("does not add system cache block when system prompt is too short", () => {
 					const shortSystemPrompt = "You are a helpful assistant"
 
@@ -660,6 +686,11 @@ describe("Cache Strategy", () => {
 			}
 		}
 
+		const createWordMessage = (role: "user" | "assistant", wordCount: number) => ({
+			role,
+			content: Array.from({ length: wordCount }, (_, index) => `word${index}`).join(" "),
+		})
+
 		// Helper to log cache point placements for debugging
 		const logPlacements = (placements: any[]) => {
 			console.log(
@@ -669,6 +700,70 @@ describe("Cache Strategy", () => {
 		}
 
 		describe("Example 1: Initial Cache Point Placement", () => {
+			it("should place a cache point after a single first-turn user message that meets the threshold", () => {
+				const messages = [createWordMessage("user", 60)]
+
+				const config = createConfig({
+					modelInfo: multiPointModelInfo,
+					systemPrompt: "",
+					messages,
+					usePromptCache: true,
+				})
+
+				const strategy = new MultiPointStrategy(config)
+				const result = strategy.determineOptimalCachePoints()
+
+				expect(result.messageCachePointPlacements).toEqual([
+					expect.objectContaining({
+						index: 0,
+						type: "message",
+					}),
+				])
+				expect(result.messageCachePointPlacements?.[0].tokensCovered).toBeGreaterThanOrEqual(
+					multiPointModelInfo.minTokensPerCachePoint,
+				)
+				expect(result.messages[0].content?.some((block) => hasCachePoint(block))).toBe(true)
+			})
+
+			it("should add a cache point for a single new user message after a previous placement", () => {
+				const messages = [
+					createWordMessage("user", 60),
+					createWordMessage("assistant", 5),
+					createWordMessage("user", 60),
+				]
+
+				const previousCachePointPlacements: CachePointPlacement[] = [
+					{
+						index: 0,
+						type: "message",
+						tokensCovered: 88,
+					},
+				]
+
+				const config = createConfig({
+					modelInfo: multiPointModelInfo,
+					systemPrompt: "",
+					messages,
+					usePromptCache: true,
+					previousCachePointPlacements,
+				})
+
+				const strategy = new MultiPointStrategy(config)
+				const result = strategy.determineOptimalCachePoints()
+
+				expect(result.messageCachePointPlacements).toEqual([
+					expect.objectContaining({
+						index: 0,
+						type: "message",
+					}),
+					expect.objectContaining({
+						index: 2,
+						type: "message",
+					}),
+				])
+				expect(result.messages[2].content?.some((block) => hasCachePoint(block))).toBe(true)
+			})
+
 			it("should place a cache point after the second user message", () => {
 				// Create messages matching Example 1 from documentation
 				const messages = [

src/api/transform/cache-strategy/base-strategy.ts

@@ -1,6 +1,6 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import { ContentBlock, SystemContentBlock, Message, ConversationRole } from "@aws-sdk/client-bedrock-runtime"
-import { CacheStrategyConfig, CacheResult, CachePointPlacement } from "./types"
+import { CacheStrategyConfig, CacheResult, CachePointPlacement, CachePoint } from "./types"
 
 export abstract class CacheStrategy {
 	/**
@@ -51,7 +51,13 @@ export abstract class CacheStrategy {
 	 * Create a cache point content block
 	 */
 	protected createCachePoint(): ContentBlock {
-		return { cachePoint: { type: "default" } } as unknown as ContentBlock
+		const cachePoint: CachePoint = { type: "default" }
+
+		if (this.config.modelInfo.promptCacheTtl) {
+			cachePoint.ttl = this.config.modelInfo.promptCacheTtl
+		}
+
+		return { cachePoint } as unknown as ContentBlock
 	}
 
 	/**

src/api/transform/cache-strategy/multi-point-strategy.ts

@@ -64,7 +64,7 @@ export class MultiPointStrategy extends CacheStrategy {
 		minTokensPerPoint: number,
 		remainingCachePoints: number,
 	): CachePointPlacement[] {
-		if (this.config.messages.length <= 1) {
+		if (remainingCachePoints <= 0) {
 			return []
 		}
 
@@ -250,7 +250,7 @@ export class MultiPointStrategy extends CacheStrategy {
 		endIndex: number,
 		minTokensPerPoint: number,
 	): CachePointPlacement | null {
-		if (startIndex >= endIndex) {
+		if (startIndex > endIndex) {
 			return null
 		}
 

src/api/transform/cache-strategy/types.ts

@@ -4,6 +4,8 @@ import { SystemContentBlock, Message } from "@aws-sdk/client-bedrock-runtime"
 /**
  * Information about a model's capabilities and constraints
  */
+export type CachePointTtl = "5m" | "1h"
+
 export interface ModelInfo {
 	/** Maximum number of tokens the model can generate */
 	maxTokens: number
@@ -17,6 +19,8 @@ export interface ModelInfo {
 	minTokensPerCachePoint: number
 	/** Fields that can be cached */
 	cachableFields: Array<"system" | "messages" | "tools">
+	/** Optional Bedrock cachePoint TTL to request */
+	promptCacheTtl?: CachePointTtl
 }
 
 /**
@@ -25,6 +29,8 @@ export interface ModelInfo {
 export interface CachePoint {
 	/** Type of cache point */
 	type: "default"
+	/** Optional Bedrock cachePoint TTL */
+	ttl?: CachePointTtl
 }
 
 /**