@roj-ai/sdk 0.1.35 → 0.2.1

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

@@ -1,402 +0,0 @@
-import { beforeEach, describe, expect, test } from 'bun:test'
-import z from 'zod/v4'
-import { isErr, isOk } from '~/lib/utils/result.js'
-import { MockLLMProvider, RequestMatchers } from './mock.js'
-import type { InferenceRequest, LLMError } from './provider.js'
-import { ModelId } from './schema.js'
-
-describe('MockLLMProvider', () => {
-	const createRequest = (
-		overrides: Partial<InferenceRequest> = {},
-	): InferenceRequest => ({
-		model: ModelId('test-model'),
-		systemPrompt: 'You are a test assistant.',
-		messages: [{ role: 'user', content: 'Hello' }],
-		...overrides,
-	})
-
-	describe('basic inference', () => {
-		test('calls handler and returns response', async () => {
-			const provider = new MockLLMProvider(() => ({
-				content: 'Hello, world!',
-				toolCalls: [],
-				finishReason: 'stop',
-				metrics: MockLLMProvider.defaultMetrics(),
-			}))
-
-			const result = await provider.inference(createRequest())
-
-			expect(isOk(result)).toBe(true)
-			if (isOk(result)) {
-				expect(result.value.content).toBe('Hello, world!')
-				expect(result.value.finishReason).toBe('stop')
-			}
-		})
-
-		test('supports async handlers', async () => {
-			const provider = new MockLLMProvider(async () => {
-				await new Promise((resolve) => setTimeout(resolve, 10))
-				return {
-					content: 'Async response',
-					toolCalls: [],
-					finishReason: 'stop',
-					metrics: MockLLMProvider.defaultMetrics(),
-				}
-			})
-
-			const result = await provider.inference(createRequest())
-
-			expect(isOk(result)).toBe(true)
-			if (isOk(result)) {
-				expect(result.value.content).toBe('Async response')
-			}
-		})
-
-		test('catches handler errors and returns server_error', async () => {
-			const provider = new MockLLMProvider(() => {
-				throw new Error('Something went wrong')
-			})
-
-			const result = await provider.inference(createRequest())
-
-			expect(isErr(result)).toBe(true)
-			if (isErr(result)) {
-				expect(result.error.type).toBe('server_error')
-				expect(result.error.message).toBe('Something went wrong')
-			}
-		})
-
-		test('passes through LLMError from handler', async () => {
-			const llmError: LLMError = {
-				type: 'rate_limit',
-				message: 'Too many requests',
-				retryAfterMs: 5000,
-			}
-
-			const provider = new MockLLMProvider(() => {
-				throw llmError
-			})
-
-			const result = await provider.inference(createRequest())
-
-			expect(isErr(result)).toBe(true)
-			if (isErr(result)) {
-				expect(result.error.type).toBe('rate_limit')
-				expect(result.error.message).toBe('Too many requests')
-				expect(result.error.retryAfterMs).toBe(5000)
-			}
-		})
-	})
-
-	describe('test helpers', () => {
-		let provider: MockLLMProvider
-
-		beforeEach(() => {
-			provider = new MockLLMProvider(() => ({
-				content: 'Test response',
-				toolCalls: [],
-				finishReason: 'stop',
-				metrics: MockLLMProvider.defaultMetrics(),
-			}))
-		})
-
-		test('getCallHistory returns copy of call history', async () => {
-			const request1 = createRequest({ systemPrompt: 'Prompt 1' })
-			const request2 = createRequest({ systemPrompt: 'Prompt 2' })
-
-			await provider.inference(request1)
-			await provider.inference(request2)
-
-			const history = provider.getCallHistory()
-			expect(history).toHaveLength(2)
-			expect(history[0]?.systemPrompt).toBe('Prompt 1')
-			expect(history[1]?.systemPrompt).toBe('Prompt 2')
-
-			// Verify it's a copy
-			history.pop()
-			expect(provider.getCallHistory()).toHaveLength(2)
-		})
-
-		test('getCallCount returns correct count', async () => {
-			expect(provider.getCallCount()).toBe(0)
-
-			await provider.inference(createRequest())
-			expect(provider.getCallCount()).toBe(1)
-
-			await provider.inference(createRequest())
-			await provider.inference(createRequest())
-			expect(provider.getCallCount()).toBe(3)
-		})
-
-		test('clearHistory clears all recorded calls', async () => {
-			await provider.inference(createRequest())
-			await provider.inference(createRequest())
-			expect(provider.getCallCount()).toBe(2)
-
-			provider.clearHistory()
-
-			expect(provider.getCallCount()).toBe(0)
-			expect(provider.getCallHistory()).toEqual([])
-		})
-
-		test('getLastRequest returns the last request', async () => {
-			expect(provider.getLastRequest()).toBeUndefined()
-
-			await provider.inference(createRequest({ systemPrompt: 'First' }))
-			expect(provider.getLastRequest()?.systemPrompt).toBe('First')
-
-			await provider.inference(createRequest({ systemPrompt: 'Second' }))
-			expect(provider.getLastRequest()?.systemPrompt).toBe('Second')
-		})
-	})
-
-	describe('factory methods', () => {
-		describe('withFixedResponse', () => {
-			test('returns same response every time', async () => {
-				const provider = MockLLMProvider.withFixedResponse({
-					content: 'Fixed response',
-				})
-
-				const result1 = await provider.inference(createRequest())
-				const result2 = await provider.inference(createRequest())
-
-				expect(isOk(result1)).toBe(true)
-				expect(isOk(result2)).toBe(true)
-				if (isOk(result1) && isOk(result2)) {
-					expect(result1.value.content).toBe('Fixed response')
-					expect(result2.value.content).toBe('Fixed response')
-				}
-			})
-
-			test('fills in default values for missing fields', async () => {
-				const provider = MockLLMProvider.withFixedResponse({
-					content: 'Just content',
-				})
-
-				const result = await provider.inference(createRequest())
-
-				expect(isOk(result)).toBe(true)
-				if (isOk(result)) {
-					expect(result.value.content).toBe('Just content')
-					expect(result.value.toolCalls).toEqual([])
-					expect(result.value.finishReason).toBe('stop')
-					expect(result.value.metrics).toEqual(MockLLMProvider.defaultMetrics())
-				}
-			})
-		})
-
-		describe('withSequence', () => {
-			test('returns responses in sequence', async () => {
-				const provider = MockLLMProvider.withSequence([
-					{ content: 'First' },
-					{ content: 'Second' },
-					{ content: 'Third' },
-				])
-
-				const result1 = await provider.inference(createRequest())
-				const result2 = await provider.inference(createRequest())
-				const result3 = await provider.inference(createRequest())
-
-				expect(isOk(result1) && result1.value.content).toBe('First')
-				expect(isOk(result2) && result2.value.content).toBe('Second')
-				expect(isOk(result3) && result3.value.content).toBe('Third')
-			})
-
-			test('throws when sequence is exhausted', async () => {
-				const provider = MockLLMProvider.withSequence([{ content: 'Only one' }])
-
-				await provider.inference(createRequest())
-				const result = await provider.inference(createRequest())
-
-				expect(isErr(result)).toBe(true)
-				if (isErr(result)) {
-					expect(result.error.message).toBe('No more mock responses available')
-				}
-			})
-		})
-
-		describe('withError', () => {
-			test('always returns the specified error', async () => {
-				const error: LLMError = {
-					type: 'context_length',
-					message: 'Context too long',
-				}
-				const provider = MockLLMProvider.withError(error)
-
-				const result1 = await provider.inference(createRequest())
-				const result2 = await provider.inference(createRequest())
-
-				expect(isErr(result1)).toBe(true)
-				expect(isErr(result2)).toBe(true)
-				if (isErr(result1)) {
-					expect(result1.error.type).toBe('context_length')
-					expect(result1.error.message).toBe('Context too long')
-				}
-			})
-		})
-
-		describe('withMatcher', () => {
-			test('matches based on request content', async () => {
-				const provider = MockLLMProvider.withMatcher([
-					{
-						match: (req) => {
-							const content = req.messages[0]?.content
-							return typeof content === 'string' && content.includes('hello')
-						},
-						response: { content: 'Hello response' },
-					},
-					{
-						match: (req) => {
-							const content = req.messages[0]?.content
-							return typeof content === 'string' && content.includes('bye')
-						},
-						response: { content: 'Goodbye response' },
-					},
-				])
-
-				const helloResult = await provider.inference(
-					createRequest({ messages: [{ role: 'user', content: 'hello there' }] }),
-				)
-				const byeResult = await provider.inference(
-					createRequest({ messages: [{ role: 'user', content: 'bye now' }] }),
-				)
-
-				expect(isOk(helloResult) && helloResult.value.content).toBe(
-					'Hello response',
-				)
-				expect(isOk(byeResult) && byeResult.value.content).toBe(
-					'Goodbye response',
-				)
-			})
-
-			test('uses first matching response', async () => {
-				const provider = MockLLMProvider.withMatcher([
-					{
-						match: () => true,
-						response: { content: 'First matcher' },
-					},
-					{
-						match: () => true,
-						response: { content: 'Second matcher' },
-					},
-				])
-
-				const result = await provider.inference(createRequest())
-
-				expect(isOk(result) && result.value.content).toBe('First matcher')
-			})
-
-			test('uses default response when no matcher matches', async () => {
-				const provider = MockLLMProvider.withMatcher(
-					[
-						{
-							match: (req) => {
-								const content = req.messages[0]?.content
-								return typeof content === 'string' && content.includes('specific')
-							},
-							response: { content: 'Specific response' },
-						},
-					],
-					{ content: 'Default response' },
-				)
-
-				const result = await provider.inference(
-					createRequest({ messages: [{ role: 'user', content: 'generic message' }] }),
-				)
-
-				expect(isOk(result) && result.value.content).toBe('Default response')
-			})
-
-			test('throws when no match and no default', async () => {
-				const provider = MockLLMProvider.withMatcher([
-					{
-						match: (req) => {
-							const content = req.messages[0]?.content
-							return typeof content === 'string' && content.includes('specific')
-						},
-						response: { content: 'Specific response' },
-					},
-				])
-
-				const result = await provider.inference(
-					createRequest({ messages: [{ role: 'user', content: 'generic message' }] }),
-				)
-
-				expect(isErr(result)).toBe(true)
-				if (isErr(result)) {
-					expect(result.error.message).toBe('No matching mock response found')
-				}
-			})
-		})
-	})
-
-	describe('RequestMatchers', () => {
-		describe('lastMessageContains', () => {
-			test('matches when last message contains text', () => {
-				const matcher = RequestMatchers.lastMessageContains('hello')
-
-				const matchingRequest = createRequest({
-					messages: [
-						{ role: 'user', content: 'first' },
-						{ role: 'user', content: 'hello world' },
-					],
-				})
-				const nonMatchingRequest = createRequest({
-					messages: [{ role: 'user', content: 'goodbye' }],
-				})
-				const emptyRequest = createRequest({ messages: [] })
-
-				expect(matcher(matchingRequest)).toBe(true)
-				expect(matcher(nonMatchingRequest)).toBe(false)
-				expect(matcher(emptyRequest)).toBe(false)
-			})
-		})
-
-		describe('systemPromptContains', () => {
-			test('matches when system prompt contains text', () => {
-				const matcher = RequestMatchers.systemPromptContains('assistant')
-
-				const matchingRequest = createRequest({
-					systemPrompt: 'You are a helpful assistant.',
-				})
-				const nonMatchingRequest = createRequest({
-					systemPrompt: 'You are a bot.',
-				})
-
-				expect(matcher(matchingRequest)).toBe(true)
-				expect(matcher(nonMatchingRequest)).toBe(false)
-			})
-		})
-
-		describe('hasTool', () => {
-			test('matches when tool is available', () => {
-				const matcher = RequestMatchers.hasTool('search')
-
-				const matchingRequest = createRequest({
-					tools: [
-						{ name: 'search', description: 'Search for information', input: z.unknown(), execute: async () => ({ ok: true, value: '' }) },
-					],
-				})
-				const nonMatchingRequest = createRequest({
-					tools: [
-						{ name: 'calculate', description: 'Do math', input: z.unknown(), execute: async () => ({ ok: true, value: '' }) },
-					],
-				})
-				const noToolsRequest = createRequest({ tools: undefined })
-
-				expect(matcher(matchingRequest)).toBe(true)
-				expect(matcher(nonMatchingRequest)).toBe(false)
-				expect(matcher(noToolsRequest)).toBe(false)
-			})
-		})
-
-		describe('always', () => {
-			test('always returns true', () => {
-				const matcher = RequestMatchers.always()
-
-				expect(matcher(createRequest())).toBe(true)
-				expect(matcher(createRequest({ systemPrompt: 'anything' }))).toBe(true)
-			})
-		})
-	})
-})

package/src/core/llm/openrouter-mapping.test.ts

@@ -1,210 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import type { LLMMessage } from '~/core/agents/state.js'
-import { ToolCallId } from '~/core/tools/schema.js'
-import { applyCacheBreakpoint } from './cache-breakpoints.js'
-import { OpenRouterProvider } from './openrouter.js'
-import type { RawInferenceRequest } from './provider.js'
-import { ModelId } from './schema.js'
-
-// ============================================================================
-// End-to-end buildHttpRequest with cache breakpoints
-// ============================================================================
-//
-// Mirrors anthropic.test.ts cache placement coverage for OpenRouter, verifying
-// that `cacheControl` on an LLMMessage translates to `cache_control` on the
-// LAST block of the mapped output — regardless of block type.
-
-const createProvider = () =>
-	new OpenRouterProvider({
-		apiKey: 'test-key',
-		imageProcessor: { resolveContent: async (content) => content },
-		defaultModel: 'anthropic/claude-haiku-4.5',
-	})
-
-type AnyBlock = { type: string; cache_control?: { type: 'ephemeral'; ttl?: '5m' | '1h' }; [key: string]: unknown }
-type OpenRouterMessage = {
-	role: string
-	content: string | AnyBlock[]
-	tool_calls?: unknown
-	tool_call_id?: string
-}
-
-const testModel = ModelId('anthropic/claude-haiku-4.5')
-
-const buildRequest = (messages: LLMMessage[]): RawInferenceRequest => ({
-	model: testModel,
-	systemPrompt: 'You are helpful.',
-	messages,
-})
-
-const getBodyMessages = (body: unknown): OpenRouterMessage[] => {
-	const b = body as { messages: OpenRouterMessage[] }
-	return b.messages
-}
-
-const asBlocks = (content: string | AnyBlock[]): AnyBlock[] => {
-	if (typeof content === 'string') throw new Error('expected block array, got string')
-	return content
-}
-
-describe('OpenRouterProvider buildHttpRequest', () => {
-	test('includes inline provider routing preferences', async () => {
-		const request = buildRequest([{ role: 'user', content: 'Hello' }])
-		request.openrouter = {
-			providers: {
-				ignore: ['amazon-bedrock'],
-				allow_fallbacks: true,
-			},
-		}
-
-		const http = await createProvider().buildHttpRequest(request)
-
-		expect(http.body).toEqual(expect.objectContaining({
-			provider: {
-				ignore: ['amazon-bedrock'],
-				allow_fallbacks: true,
-			},
-		}))
-	})
-
-	test('pure tool_result target: cache_control lands on the tool role message content', 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)
-
-		// OpenRouter keeps the tool role as-is (doesn't merge like anthropic)
-		const last = msgs[msgs.length - 1]
-		expect(last.role).toBe('tool')
-		// String content got wrapped into [{text, cache_control}] by applyCacheControlToLastBlock
-		const blocks = asBlocks(last.content)
-		expect(blocks).toHaveLength(1)
-		expect(blocks[0].type).toBe('text')
-		expect(blocks[0].cache_control).toEqual({ type: 'ephemeral' })
-	})
-
-	test('assistant [text, tool_use, tool_use] target: cache_control on the last tool_call content block', async () => {
-		// OpenRouter assistant messages put tool calls in a SEPARATE `tool_calls` field
-		// rather than as content blocks — so for assistant the cache checkpoint lands
-		// on the (text) content block, which is what OpenRouter's cache expects for
-		// checkpoint + tool_calls.
-		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 - 3]
-		expect(assistant.role).toBe('assistant')
-		expect(assistant.tool_calls).toBeDefined()
-		// String content got wrapped so cache_control has a place to live
-		const blocks = asBlocks(assistant.content)
-		expect(blocks).toHaveLength(1)
-		expect(blocks[0].type).toBe('text')
-		expect(blocks[0].cache_control).toEqual({ type: 'ephemeral' })
-	})
-
-	test('ephemeral suffix: breakpoint at idx-1 (tool_result), ephemeral user comes after uncached', 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' },
-			{ role: 'user', content: '<session-context>plugin status</session-context>' },
-		]
-		const messages = applyCacheBreakpoint(history, 1)
-
-		const http = await createProvider().buildHttpRequest(buildRequest(messages))
-		const msgs = getBodyMessages(http.body)
-
-		// The tool message (idx-1) is the breakpoint target
-		const toolMsg = msgs.find((m) => m.role === 'tool')
-		expect(toolMsg).toBeDefined()
-		const toolBlocks = asBlocks(toolMsg!.content)
-		expect(toolBlocks[toolBlocks.length - 1].cache_control).toEqual({ type: 'ephemeral' })
-
-		// The last message is the ephemeral user — no cache_control
-		const last = msgs[msgs.length - 1]
-		expect(last.role).toBe('user')
-		// Without flag, user content stays as plain string (no block wrap, no cache_control)
-		expect(last.content).toBe('<session-context>plugin status</session-context>')
-	})
-
-	test('ttl reaches the wire and the system block matches it', async () => {
-		// The whole point of the fix: OpenRouter dropped `ttl` on the floor, so a
-		// preset asking for the 1-hour tier silently ran on the 5-minute default.
-		const messages = applyCacheBreakpoint([
-			{ role: 'user', content: 'preamble' },
-			{ role: 'assistant', content: 'ok' },
-			{ role: 'user', content: 'work' },
-		], 0, { prefix: '1h' }, 1)
-
-		const http = await createProvider().buildHttpRequest(buildRequest(messages))
-		const msgs = getBodyMessages(http.body)
-
-		// System precedes every message, so it must carry the longest TTL in use —
-		// Anthropic rejects a longer entry that follows a shorter one.
-		const systemBlocks = asBlocks(msgs[0].content)
-		expect(systemBlocks[0].cache_control).toEqual({ type: 'ephemeral', ttl: '1h' })
-
-		// prefix breakpoint (message index 0 → body index 1) carries 1h
-		expect(asBlocks(msgs[1].content)[0].cache_control).toEqual({ type: 'ephemeral', ttl: '1h' })
-		// tail breakpoint stays on the cheap short tier
-		expect(asBlocks(msgs[3].content)[0].cache_control).toEqual({ type: 'ephemeral' })
-	})
-
-	test('no ttl requested: system block stays on the default tier', async () => {
-		const messages = applyCacheBreakpoint([
-			{ role: 'user', content: 'preamble' },
-			{ role: 'user', content: 'work' },
-		], 0, undefined, 1)
-
-		const http = await createProvider().buildHttpRequest(buildRequest(messages))
-		const msgs = getBodyMessages(http.body)
-
-		expect(asBlocks(msgs[0].content)[0].cache_control).toEqual({ type: 'ephemeral' })
-		expect(asBlocks(msgs[1].content)[0].cache_control).toEqual({ type: 'ephemeral' })
-	})
-
-	test('no flag on any message: only system 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)
-
-		// system is the first message in OpenRouter body
-		const system = msgs[0]
-		expect(system.role).toBe('system')
-		const systemBlocks = asBlocks(system.content)
-		expect(systemBlocks[0].cache_control).toEqual({ type: 'ephemeral' })
-
-		// All other messages: plain string content, no cache_control anywhere
-		for (const msg of msgs.slice(1)) {
-			expect(typeof msg.content).toBe('string')
-		}
-	})
-})