@roj-ai/sdk 0.1.36 → 0.2.1

package/src/core/llm/anthropic.test.ts

@@ -1,546 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import type { LLMMessage } from '~/core/agents/state.js'
-import { ModelId } from '~/core/llm/schema.js'
-import { ToolCallId } from '~/core/tools/schema.js'
-import { AnthropicProvider } from './anthropic.js'
-import { applyCacheBreakpoint } from './cache-breakpoints.js'
-import type { RawInferenceRequest } from './provider.js'
-
-// ============================================================================
-// Helpers — access private methods via prototype for testing
-// ============================================================================
-
-const createProvider = () =>
-	new AnthropicProvider({
-		apiKey: 'test-key',
-		imageProcessor: {
-			resolveContent: async (content) => content,
-		},
-	})
-
-// Access private methods for unit testing the mapping logic
-const provider = createProvider()
-const mapMessage = (provider as any).mapMessage.bind(provider) as (msg: LLMMessage) => Promise<{ role: string; content: unknown }>
-const mergeConsecutiveMessages = (provider as any).mergeConsecutiveMessages.bind(provider) as (
-	msgs: { role: string; content: unknown }[],
-) => { role: string; content: unknown }[]
-const mapStopReason = (provider as any).mapStopReason.bind(provider) as (reason: string | null) => string
-const mapError = (provider as any).mapError.bind(provider) as (err: unknown) => unknown
-
-// ============================================================================
-// Message Mapping
-// ============================================================================
-
-describe('AnthropicProvider message mapping', () => {
-	test('maps user message with string content', async () => {
-		const result = await mapMessage({ role: 'user', content: 'Hello' })
-		expect(result).toEqual({ role: 'user', content: 'Hello' })
-	})
-
-	test('maps user message with multimodal content', async () => {
-		const result = await mapMessage({
-			role: 'user',
-			content: [
-				{ type: 'text', text: 'Look at this image' },
-				{ type: 'image_url', imageUrl: { url: 'data:image/png;base64,abc123' } },
-			],
-		})
-		expect(result).toEqual({
-			role: 'user',
-			content: [
-				{ type: 'text', text: 'Look at this image' },
-				{ type: 'image', source: { type: 'base64', media_type: 'image/png', data: 'abc123' } },
-			],
-		})
-	})
-
-	test('maps user message with HTTP image URL', async () => {
-		const result = await mapMessage({
-			role: 'user',
-			content: [
-				{ type: 'image_url', imageUrl: { url: 'https://example.com/img.jpg' } },
-			],
-		})
-		expect(result).toEqual({
-			role: 'user',
-			content: [
-				{ type: 'image', source: { type: 'url', url: 'https://example.com/img.jpg' } },
-			],
-		})
-	})
-
-	test('maps assistant message with content only', async () => {
-		const result = await mapMessage({ role: 'assistant', content: 'Hello back' })
-		expect(result).toEqual({
-			role: 'assistant',
-			content: [{ type: 'text', text: 'Hello back' }],
-		})
-	})
-
-	test('maps assistant message with tool calls', async () => {
-		const result = await mapMessage({
-			role: 'assistant',
-			content: 'Let me help',
-			toolCalls: [{ id: ToolCallId('tc_1'), name: 'search', input: { query: 'test' } }],
-		})
-		expect(result).toEqual({
-			role: 'assistant',
-			content: [
-				{ type: 'text', text: 'Let me help' },
-				{ type: 'tool_use', id: 'tc_1', name: 'search', input: { query: 'test' } },
-			],
-		})
-	})
-
-	test('maps assistant message with empty content and tool calls', async () => {
-		const result = await mapMessage({
-			role: 'assistant',
-			content: '',
-			toolCalls: [{ id: ToolCallId('tc_1'), name: 'search', input: { query: 'test' } }],
-		})
-		expect(result).toEqual({
-			role: 'assistant',
-			content: [
-				{ type: 'tool_use', id: 'tc_1', name: 'search', input: { query: 'test' } },
-			],
-		})
-	})
-
-	test('maps tool result to user role with tool_result block', async () => {
-		const result = await mapMessage({
-			role: 'tool',
-			content: 'result data',
-			toolCallId: ToolCallId('tc_1'),
-		})
-		expect(result).toEqual({
-			role: 'user',
-			content: [{ type: 'tool_result', tool_use_id: 'tc_1', content: 'result data' }],
-		})
-	})
-
-	test('maps tool error result with ERROR prefix', async () => {
-		const result = await mapMessage({
-			role: 'tool',
-			content: 'something failed',
-			toolCallId: ToolCallId('tc_1'),
-			isError: true,
-		})
-		expect(result).toEqual({
-			role: 'user',
-			content: [{ type: 'tool_result', tool_use_id: 'tc_1', content: '[ERROR] something failed' }],
-		})
-	})
-
-	test('maps system message to user with [System] prefix', async () => {
-		const result = await mapMessage({ role: 'system', content: 'Context information' })
-		expect(result).toEqual({
-			role: 'user',
-			content: [{ type: 'text', text: '[System] Context information' }],
-		})
-	})
-})
-
-// ============================================================================
-// Message Alternation
-// ============================================================================
-
-describe('AnthropicProvider message alternation', () => {
-	test('merges consecutive user messages', () => {
-		const messages = [
-			{ role: 'user' as const, content: 'Hello' },
-			{ role: 'user' as const, content: 'How are you?' },
-		]
-		const result = mergeConsecutiveMessages(messages)
-		expect(result).toEqual([{
-			role: 'user',
-			content: [
-				{ type: 'text', text: 'Hello' },
-				{ type: 'text', text: 'How are you?' },
-			],
-		}])
-	})
-
-	test('merges consecutive user messages with mixed content types', () => {
-		const messages = [
-			{ role: 'user' as const, content: [{ type: 'tool_result' as const, tool_use_id: 'tc_1', content: 'result1' }] },
-			{ role: 'user' as const, content: [{ type: 'tool_result' as const, tool_use_id: 'tc_2', content: 'result2' }] },
-		]
-		const result = mergeConsecutiveMessages(messages)
-		expect(result).toHaveLength(1)
-		expect(result[0].role).toBe('user')
-		expect(Array.isArray(result[0].content)).toBe(true)
-		expect((result[0].content as any[]).length).toBe(2)
-	})
-
-	test('does not merge messages with different roles', () => {
-		const messages = [
-			{ role: 'user' as const, content: 'Hello' },
-			{ role: 'assistant' as const, content: 'Hi' },
-			{ role: 'user' as const, content: 'How are you?' },
-		]
-		const result = mergeConsecutiveMessages(messages)
-		expect(result).toHaveLength(3)
-	})
-
-	test('handles empty input', () => {
-		expect(mergeConsecutiveMessages([])).toEqual([])
-	})
-})
-
-// ============================================================================
-// Cache Breakpoints
-// ============================================================================
-
-describe('applyCacheBreakpoint (shared helper)', () => {
-	test('marks the last message when uncachedSuffixCount is 0', () => {
-		const messages: LLMMessage[] = [
-			{ role: 'user', content: 'Hello' },
-			{ role: 'assistant', content: 'Hi' },
-			{ role: 'user', content: 'Question' },
-		]
-		const result = applyCacheBreakpoint(messages, 0)
-		expect(result[2].cacheControl).toEqual({ type: 'ephemeral' })
-		expect(result[0].cacheControl).toBeUndefined()
-		expect(result[1].cacheControl).toBeUndefined()
-	})
-
-	test('marks second-to-last when uncachedSuffixCount is 1', () => {
-		const messages: LLMMessage[] = [
-			{ role: 'user', content: 'Hello' },
-			{ role: 'assistant', content: 'Hi' },
-			{ role: 'user', content: 'Question' },
-		]
-		const result = applyCacheBreakpoint(messages, 1)
-		expect(result[1].cacheControl).toEqual({ type: 'ephemeral' })
-		expect(result[2].cacheControl).toBeUndefined()
-	})
-
-	test('no-op when suffix exceeds message count', () => {
-		const messages: LLMMessage[] = [{ role: 'user', content: 'Hello' }]
-		const result = applyCacheBreakpoint(messages, 5)
-		expect(result[0].cacheControl).toBeUndefined()
-	})
-})
-
-describe('AnthropicProvider cache breakpoint placement', () => {
-	test('adds cache_control to last block of flagged user string message', async () => {
-		const result = await mapMessage({
-			role: 'user',
-			content: 'Hello',
-			cacheControl: { type: 'ephemeral' },
-		})
-		expect(Array.isArray(result.content)).toBe(true)
-		const content = result.content as Array<{ type: string; cache_control?: unknown }>
-		expect(content[content.length - 1].cache_control).toEqual({ type: 'ephemeral' })
-	})
-
-	test('adds cache_control to outer tool_result block (not inner content)', async () => {
-		const result = await mapMessage({
-			role: 'tool',
-			content: 'result data',
-			toolCallId: ToolCallId('tc_1'),
-			cacheControl: { type: 'ephemeral' },
-		})
-		const content = result.content as Array<{ type: string; cache_control?: unknown }>
-		expect(content).toHaveLength(1)
-		expect(content[0].type).toBe('tool_result')
-		expect(content[0].cache_control).toEqual({ type: 'ephemeral' })
-	})
-
-	test('adds cache_control to last block of assistant with text + tool_use', async () => {
-		const result = await mapMessage({
-			role: 'assistant',
-			content: 'Let me help',
-			toolCalls: [{ id: ToolCallId('tc_1'), name: 'search', input: { query: 'test' } }],
-			cacheControl: { type: 'ephemeral' },
-		})
-		const content = result.content as Array<{ type: string; cache_control?: unknown }>
-		// Last block is the tool_use — that's where cache_control must land
-		expect(content[content.length - 1].type).toBe('tool_use')
-		expect(content[content.length - 1].cache_control).toEqual({ type: 'ephemeral' })
-	})
-
-	test('no cache_control on messages without flag', async () => {
-		const result = await mapMessage({ role: 'user', content: 'Hello' })
-		expect(result).toEqual({ role: 'user', content: 'Hello' })
-	})
-})
-
-// ============================================================================
-// End-to-end buildHttpRequest with cache breakpoints
-// ============================================================================
-//
-// Covers the bug scenarios that the old provider-level `applyCacheBreakpoints`
-// silently no-op'd on: pure tool_result target, assistant with tool_use last,
-// and the agent-side pipeline (applyCacheBreakpoint + mergeConsecutiveMessages).
-
-type AnyBlock = { type: string; cache_control?: { type: 'ephemeral' }; [key: string]: unknown }
-type AnthropicMessage = { role: string; content: AnyBlock[] }
-
-const testModel = ModelId('claude-haiku-4-5-20251001')
-
-const buildRequest = (messages: LLMMessage[]): RawInferenceRequest => ({
-	model: testModel,
-	systemPrompt: 'You are helpful.',
-	messages,
-})
-
-const getBodyMessages = (body: unknown): AnthropicMessage[] => {
-	const b = body as { messages: AnthropicMessage[] }
-	return b.messages
-}
-
-describe('AnthropicProvider buildHttpRequest cache placement', () => {
-	test('pure tool_result target: cache_control lands on outer tool_result block', async () => {
-		const messages = applyCacheBreakpoint([
-			{ role: 'user', content: 'What is the weather?' },
-			{
-				role: 'assistant',
-				content: '',
-				toolCalls: [{ id: ToolCallId('call_1'), name: 'get_weather', input: { city: 'Prague' } }],
-			},
-			{ role: 'tool', toolCallId: ToolCallId('call_1'), content: 'Sunny, 22°C' },
-		], 0)
-
-		const http = await createProvider().buildHttpRequest(buildRequest(messages))
-		const msgs = getBodyMessages(http.body)
-
-		// Last message is the merged user containing the tool_result
-		const last = msgs[msgs.length - 1]
-		expect(last.role).toBe('user')
-		expect(Array.isArray(last.content)).toBe(true)
-		const lastBlock = last.content[last.content.length - 1]
-		expect(lastBlock.type).toBe('tool_result')
-		expect(lastBlock.cache_control).toEqual({ type: 'ephemeral' })
-	})
-
-	test('consecutive tool_results merged: cache_control lands on LAST merged tool_result', async () => {
-		const messages = applyCacheBreakpoint([
-			{ role: 'user', content: 'Check two cities' },
-			{
-				role: 'assistant',
-				content: '',
-				toolCalls: [
-					{ id: ToolCallId('call_1'), name: 'get_weather', input: { city: 'Prague' } },
-					{ id: ToolCallId('call_2'), name: 'get_weather', input: { city: 'London' } },
-				],
-			},
-			{ role: 'tool', toolCallId: ToolCallId('call_1'), content: 'Sunny' },
-			{ role: 'tool', toolCallId: ToolCallId('call_2'), content: 'Rainy' },
-		], 0)
-
-		const http = await createProvider().buildHttpRequest(buildRequest(messages))
-		const msgs = getBodyMessages(http.body)
-
-		const last = msgs[msgs.length - 1]
-		expect(last.role).toBe('user')
-		// Two tool_results merged into one user message
-		expect(last.content.length).toBe(2)
-		expect(last.content[0].type).toBe('tool_result')
-		expect(last.content[1].type).toBe('tool_result')
-		expect(last.content[0].cache_control).toBeUndefined()
-		// cache_control is on the LAST tool_result (the target message's block after merge)
-		expect(last.content[1].cache_control).toEqual({ type: 'ephemeral' })
-	})
-
-	test('assistant [text, tool_use, tool_use] target: cache_control lands on LAST tool_use', async () => {
-		const messages = applyCacheBreakpoint([
-			{ role: 'user', content: 'Check weather and search' },
-			{
-				role: 'assistant',
-				content: 'Let me check both',
-				toolCalls: [
-					{ id: ToolCallId('call_1'), name: 'get_weather', input: { city: 'Prague' } },
-					{ id: ToolCallId('call_2'), name: 'search', input: { query: 'weather' } },
-				],
-			},
-			{ role: 'tool', toolCallId: ToolCallId('call_1'), content: 'Sunny' },
-			{ role: 'tool', toolCallId: ToolCallId('call_2'), content: 'Found results' },
-		], 2)
-
-		const http = await createProvider().buildHttpRequest(buildRequest(messages))
-		const msgs = getBodyMessages(http.body)
-
-		const assistant = msgs[msgs.length - 2]
-		expect(assistant.role).toBe('assistant')
-		expect(assistant.content.length).toBe(3) // text + 2 tool_use
-		expect(assistant.content[0].type).toBe('text')
-		expect(assistant.content[0].cache_control).toBeUndefined()
-		expect(assistant.content[1].type).toBe('tool_use')
-		expect(assistant.content[1].cache_control).toBeUndefined()
-		// cache_control lands on the LAST block (last tool_use), not the first text block
-		expect(assistant.content[2].type).toBe('tool_use')
-		expect(assistant.content[2].cache_control).toEqual({ type: 'ephemeral' })
-	})
-
-	test('ephemeral suffix: breakpoint at idx-1, ephemeral user merges after as uncached suffix', async () => {
-		const history: LLMMessage[] = [
-			{ role: 'user', content: 'Initial question' },
-			{
-				role: 'assistant',
-				content: '',
-				toolCalls: [{ id: ToolCallId('call_1'), name: 'get_weather', input: { city: 'Prague' } }],
-			},
-			{ role: 'tool', toolCallId: ToolCallId('call_1'), content: 'Sunny' },
-			// simulate agent.ts pushing ephemeral session context last
-			{ role: 'user', content: '<session-context>plugin status</session-context>' },
-		]
-		const messages = applyCacheBreakpoint(history, 1) // uncachedSuffixCount = 1 (ephemeral tail)
-
-		const http = await createProvider().buildHttpRequest(buildRequest(messages))
-		const msgs = getBodyMessages(http.body)
-
-		// mergeConsecutiveMessages folds the tool_result and ephemeral into one user message
-		const last = msgs[msgs.length - 1]
-		expect(last.role).toBe('user')
-		// Content: [tool_result (cached), text (ephemeral, uncached)]
-		expect(last.content.length).toBe(2)
-		expect(last.content[0].type).toBe('tool_result')
-		expect(last.content[0].cache_control).toEqual({ type: 'ephemeral' })
-		expect(last.content[1].type).toBe('text')
-		// Ephemeral comes AFTER the cache checkpoint, so it's fresh each call
-		expect(last.content[1].cache_control).toBeUndefined()
-	})
-
-	test('stable prefix + tail: TWO cache_control blocks survive into the HTTP body', async () => {
-		// Mirrors the agent flow: an immutable preamble followed by a churning
-		// conversation tail. applyCacheBreakpoint with cachedPrefixCount marks
-		// BOTH the last preamble message and the tail — both must reach the wire.
-		// Roles alternate so mergeConsecutiveMessages doesn't fold them together.
-		const messages = applyCacheBreakpoint(
-			[
-				{ role: 'user', content: 'preamble part A' },
-				{ role: 'assistant', content: 'preamble part B' }, // last preamble msg → prefix breakpoint
-				{ role: 'user', content: 'conversation turn' },
-				{ role: 'assistant', content: 'tail reply' }, // tail breakpoint
-				{ role: 'user', content: 'tail continuation' },
-			],
-			1, // one uncached user suffix → tailIdx = 3
-			undefined,
-			2, // cachedPrefixCount → prefixIdx = 1
-		)
-
-		const http = await createProvider().buildHttpRequest(buildRequest(messages))
-		const msgs = getBodyMessages(http.body)
-
-		expect(msgs.length).toBe(5)
-		// Prefix breakpoint on the last preamble message
-		const prefix = msgs[1]
-		expect(prefix.role).toBe('assistant')
-		expect(prefix.content[prefix.content.length - 1].cache_control).toEqual({ type: 'ephemeral' })
-		// Tail breakpoint on the final message
-		const tail = msgs[3]
-		expect(tail.role).toBe('assistant')
-		expect(tail.content[tail.content.length - 1].cache_control).toEqual({ type: 'ephemeral' })
-		// Messages between the two breakpoints stay uncached
-		expect(msgs[0].content[msgs[0].content.length - 1].cache_control).toBeUndefined()
-		expect(msgs[2].content[msgs[2].content.length - 1].cache_control).toBeUndefined()
-	})
-
-	test('no flag on any message: only system prompt has cache_control', async () => {
-		const http = await createProvider().buildHttpRequest(buildRequest([
-			{ role: 'user', content: 'What is 2+2?' },
-			{ role: 'assistant', content: '4' },
-			{ role: 'user', content: 'And 3+3?' },
-		]))
-		const msgs = getBodyMessages(http.body)
-
-		for (const msg of msgs) {
-			for (const block of msg.content) {
-				expect(block.cache_control).toBeUndefined()
-			}
-		}
-		// System still has cache_control (hardcoded in provider)
-		const system = (http.body as { system: AnyBlock[] }).system
-		expect(system[0].cache_control).toEqual({ type: 'ephemeral' })
-	})
-})
-
-// ============================================================================
-// Stop Reason Mapping
-// ============================================================================
-
-describe('AnthropicProvider stop reason mapping', () => {
-	test('maps end_turn to stop', () => {
-		expect(mapStopReason('end_turn')).toBe('stop')
-	})
-
-	test('maps tool_use to tool_calls', () => {
-		expect(mapStopReason('tool_use')).toBe('tool_calls')
-	})
-
-	test('maps max_tokens to length', () => {
-		expect(mapStopReason('max_tokens')).toBe('length')
-	})
-
-	test('maps null to stop', () => {
-		expect(mapStopReason(null)).toBe('stop')
-	})
-
-	test('maps unknown reason to stop', () => {
-		expect(mapStopReason('something_new')).toBe('stop')
-	})
-})
-
-// ============================================================================
-// Error Mapping
-// ============================================================================
-
-describe('AnthropicProvider error mapping', () => {
-	test('maps AbortError', () => {
-		const err = new Error('aborted')
-		err.name = 'AbortError'
-		const result = mapError(err) as any
-		expect(result.type).toBe('aborted')
-	})
-
-	test('maps unknown error to network_error', () => {
-		const result = mapError(new Error('something')) as any
-		expect(result.type).toBe('network_error')
-		expect(result.message).toBe('something')
-	})
-
-	test('maps string error', () => {
-		const result = mapError('boom') as any
-		expect(result.type).toBe('network_error')
-		expect(result.message).toBe('boom')
-	})
-})
-
-// ============================================================================
-// Model Routing (canHandle / normalizeModel)
-// ============================================================================
-
-describe('AnthropicProvider model routing', () => {
-	test('handles anthropic/ prefixed models', () => {
-		expect(provider.canHandle('anthropic/claude-sonnet-4.5')).toBe(true)
-		expect(provider.canHandle('anthropic/claude-haiku-4.5')).toBe(true)
-		expect(provider.canHandle('anthropic/claude-3.5-haiku')).toBe(true)
-	})
-
-	test('handles claude- prefixed models without vendor prefix', () => {
-		expect(provider.canHandle('claude-sonnet-4-5-20250514')).toBe(true)
-		expect(provider.canHandle('claude-3-5-haiku-20241022')).toBe(true)
-	})
-
-	test('does not handle non-Anthropic models', () => {
-		expect(provider.canHandle('openai/gpt-4o')).toBe(false)
-		expect(provider.canHandle('google/gemini-pro')).toBe(false)
-		expect(provider.canHandle('meta-llama/llama-3')).toBe(false)
-	})
-
-	test('strips anthropic/ prefix and converts dots to dashes', () => {
-		expect(provider.normalizeModel('anthropic/claude-opus-4.6')).toBe('claude-opus-4-6')
-		expect(provider.normalizeModel('anthropic/claude-sonnet-4.5')).toBe('claude-sonnet-4-5')
-		expect(provider.normalizeModel('anthropic/claude-haiku-4.5')).toBe('claude-haiku-4-5')
-	})
-
-	test('converts dots to dashes without prefix', () => {
-		expect(provider.normalizeModel('claude-opus-4.6')).toBe('claude-opus-4-6')
-	})
-
-	test('keeps model ID as-is when already in Anthropic format', () => {
-		expect(provider.normalizeModel('claude-sonnet-4-5-20250514')).toBe('claude-sonnet-4-5-20250514')
-		expect(provider.normalizeModel('claude-opus-4-6')).toBe('claude-opus-4-6')
-	})
-})

package/src/core/llm/cache-breakpoints.test.ts

@@ -1,85 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import type { LLMMessage } from '~/core/agents/state.js'
-import { applyCacheBreakpoint } from './cache-breakpoints.js'
-
-const userMessages = (count: number): LLMMessage[] =>
-	Array.from({ length: count }, (_, i) => ({ role: 'user', content: `m${i}` }))
-
-const cachedIndices = (messages: LLMMessage[]): number[] =>
-	messages.flatMap((m, i) => ('cacheControl' in m && m.cacheControl ? [i] : []))
-
-describe('applyCacheBreakpoint', () => {
-	test('cachedPrefixCount = 0 → single tail breakpoint only (unchanged behaviour)', () => {
-		const messages = userMessages(5)
-		const result = applyCacheBreakpoint(messages, 1)
-		// tail = length - 1 - suffix = 5 - 1 - 1 = 3
-		expect(cachedIndices(result)).toEqual([3])
-	})
-
-	test('cachedPrefixCount > 0 → two breakpoints: prefix end and tail', () => {
-		const messages = userMessages(10)
-		const result = applyCacheBreakpoint(messages, 1, undefined, 3)
-		// prefix = 3 - 1 = 2, tail = 10 - 1 - 1 = 8
-		expect(cachedIndices(result)).toEqual([2, 8])
-	})
-
-	test('prefixIdx === tailIdx → only one breakpoint, no duplicate', () => {
-		// preamble is the whole list, no suffix: tail = 3 - 1 - 0 = 2, prefix = 3 - 1 = 2
-		const messages = userMessages(3)
-		const result = applyCacheBreakpoint(messages, 0, undefined, 3)
-		expect(cachedIndices(result)).toEqual([2])
-	})
-
-	test('cachedPrefixCount larger than messages.length → out-of-range prefix ignored, tail still applied', () => {
-		const messages = userMessages(4)
-		const result = applyCacheBreakpoint(messages, 0, undefined, 99)
-		// prefix = 98 (out of range, ignored), tail = 4 - 1 - 0 = 3
-		expect(cachedIndices(result)).toEqual([3])
-	})
-
-	// prefix = 1, tail = 5 for userMessages(6) with suffix 0 and cachedPrefixCount 2
-	const ttlsOf = (messages: LLMMessage[]) => [1, 5].map((idx) => {
-		const m = messages[idx]
-		return 'cacheControl' in m && m.cacheControl ? m.cacheControl.ttl : undefined
-	})
-
-	test('a bare tier applies to both breakpoints', () => {
-		const result = applyCacheBreakpoint(userMessages(6), 0, '1h', 2)
-		expect(ttlsOf(result)).toEqual(['1h', '1h'])
-	})
-
-	test('{ prefix } leaves the tail on the default tier', () => {
-		// Usually the paying configuration for an interactive agent: the immutable
-		// preamble survives human pauses, the churning tail stays cheap to write.
-		const result = applyCacheBreakpoint(userMessages(6), 0, { prefix: '1h' }, 2)
-		expect(ttlsOf(result)).toEqual(['1h', undefined])
-	})
-
-	test('{ prefix, tail } sets each breakpoint independently', () => {
-		const result = applyCacheBreakpoint(userMessages(6), 0, { prefix: '1h', tail: '5m' }, 2)
-		expect(ttlsOf(result)).toEqual(['1h', '5m'])
-	})
-
-	test('{ tail } alone is honoured — the SDK does not second-guess the caller', () => {
-		const result = applyCacheBreakpoint(userMessages(6), 0, { tail: '1h' }, 2)
-		expect(ttlsOf(result)).toEqual([undefined, '1h'])
-	})
-
-	test('prefixIdx === tailIdx → the single mark covers the preamble, so it takes the prefix ttl', () => {
-		const result = applyCacheBreakpoint(userMessages(3), 0, { prefix: '1h' }, 3)
-		expect(cachedIndices(result)).toEqual([2])
-		const only = result[2]
-		expect('cacheControl' in only && only.cacheControl).toEqual({ type: 'ephemeral', ttl: '1h' })
-	})
-
-	test('no ttl → neither breakpoint carries one', () => {
-		const result = applyCacheBreakpoint(userMessages(6), 0, undefined, 2)
-		expect(ttlsOf(result)).toEqual([undefined, undefined])
-	})
-
-	test('does not mutate the input array', () => {
-		const messages = userMessages(5)
-		applyCacheBreakpoint(messages, 0, undefined, 2)
-		expect(cachedIndices(messages)).toEqual([])
-	})
-})