@roj-ai/sdk 0.1.36 → 0.2.1

package/src/core/llm/provider-integration.test.ts

@@ -1,408 +0,0 @@
-/**
- * Integration tests for LLM providers against real APIs.
- *
- * Uses snapshot-caching fetch: first run hits the real API and saves the
- * request+response; subsequent runs with the same request use the cache.
- *
- * Env vars: ANTHROPIC_API_KEY, OPENROUTER_API_KEY
- * When snapshots exist, tests run without API keys (using cached responses).
- * API keys are only needed to record new snapshots.
- */
-
-import { describe, expect, test } from 'bun:test'
-import { existsSync } from 'node:fs'
-import { join } from 'node:path'
-import z4 from 'zod/v4'
-import type { LLMMessage } from '~/core/agents/state.js'
-import type { ImageProcessor } from '~/core/image/types.js'
-import type { ToolDefinition } from '~/core/tools/definition.js'
-import { ToolCallId } from '~/core/tools/schema.js'
-import { AnthropicProvider } from './anthropic.js'
-import { OpenRouterProvider } from './openrouter.js'
-import type { InferenceRequest, InferenceResponse, LLMProvider } from './provider.js'
-import { ModelId } from './schema.js'
-import { createSnapshotFetch } from './snapshot-fetch.js'
-
-// ============================================================================
-// Setup
-// ============================================================================
-
-const SNAPSHOTS_DIR = join(import.meta.dir, '__snapshots__')
-
-const anthropicApiKey = process.env.ANTHROPIC_API_KEY ?? 'snapshot-only'
-const openRouterApiKey = process.env.OPENROUTER_API_KEY ?? 'snapshot-only'
-
-const noopImageProcessor: ImageProcessor = {
-	resolveContent: async (content) => content,
-}
-
-// 1x1 red pixel PNG
-const TINY_PNG = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg=='
-
-const weatherTool: ToolDefinition<{ city: string }> = {
-	name: 'get_weather',
-	description: 'Get current weather for a city',
-	input: z4.object({ city: z4.string() }),
-	execute: async () => ({ ok: true, value: 'not implemented' }),
-}
-
-const searchTool: ToolDefinition<{ query: string }> = {
-	name: 'search',
-	description: 'Search the web',
-	input: z4.object({ query: z4.string() }),
-	execute: async () => ({ ok: true, value: 'not implemented' }),
-}
-
-// ============================================================================
-// Provider factories
-// ============================================================================
-
-interface ProviderSetup {
-	name: string
-	model: ModelId
-	hasApiKey: boolean
-	snapshotPrefix: string
-	create: (testName: string) => LLMProvider
-}
-
-const providers: ProviderSetup[] = [
-	{
-		name: 'Anthropic',
-		model: ModelId('claude-haiku-4-5-20251001'),
-		hasApiKey: !!process.env.ANTHROPIC_API_KEY,
-		snapshotPrefix: 'anthropic',
-		create: (testName) =>
-			new AnthropicProvider({
-				apiKey: anthropicApiKey!,
-				imageProcessor: noopImageProcessor,
-				defaultModel: 'claude-haiku-4-5-20251001',
-				fetch: createSnapshotFetch(SNAPSHOTS_DIR, `anthropic-${testName}`),
-			}),
-	},
-	{
-		name: 'OpenRouter',
-		model: ModelId('anthropic/claude-haiku-4.5'),
-		hasApiKey: !!process.env.OPENROUTER_API_KEY,
-		snapshotPrefix: 'openrouter',
-		create: (testName) =>
-			new OpenRouterProvider({
-				apiKey: openRouterApiKey!,
-				imageProcessor: noopImageProcessor,
-				defaultModel: 'anthropic/claude-haiku-4.5',
-				fetch: createSnapshotFetch(SNAPSHOTS_DIR, `openrouter-${testName}`),
-			}),
-	},
-]
-
-// ============================================================================
-// Test scenarios
-// ============================================================================
-
-interface Scenario {
-	name: string
-	request: Omit<InferenceRequest, 'model'>
-	assert: (response: InferenceResponse) => void
-}
-
-const scenarios: Scenario[] = [
-	// --- Basic messages ---
-
-	{
-		name: 'simple-user-message',
-		request: {
-			systemPrompt: 'You are a helpful assistant. Reply with exactly one word.',
-			messages: [{ role: 'user', content: 'What color is the sky? Reply with one word.' }],
-		},
-		assert: (r) => {
-			expect(r.content).toBeTruthy()
-			expect(r.finishReason).toBe('stop')
-			expect(r.metrics.promptTokens).toBeGreaterThan(0)
-			expect(r.metrics.completionTokens).toBeGreaterThan(0)
-			expect(r.providerRequestId).toBeTruthy()
-		},
-	},
-
-	{
-		name: 'system-message-in-conversation',
-		request: {
-			systemPrompt: 'You are a helpful assistant.',
-			messages: [
-				{ role: 'user', content: 'Hi' },
-				{ role: 'assistant', content: 'Hello!' },
-				{ role: 'system', content: 'The user prefers Czech language.' },
-				{ role: 'user', content: 'How are you?' },
-			],
-		},
-		assert: (r) => {
-			expect(r.content).toBeTruthy()
-			expect(r.finishReason).toBe('stop')
-		},
-	},
-
-	// --- Tool calls ---
-
-	{
-		name: 'tool-call',
-		request: {
-			systemPrompt: 'You have access to tools. Use the get_weather tool to answer weather questions.',
-			messages: [{ role: 'user', content: 'What is the weather in Prague?' }],
-			tools: [weatherTool],
-		},
-		assert: (r) => {
-			expect(r.finishReason).toBe('tool_calls')
-			expect(r.toolCalls.length).toBeGreaterThan(0)
-			expect(r.toolCalls[0].name).toBe('get_weather')
-			expect(r.toolCalls[0].input).toHaveProperty('city')
-			expect(r.toolCalls[0].id).toBeTruthy()
-		},
-	},
-
-	{
-		name: 'tool-roundtrip',
-		request: {
-			systemPrompt: 'You have access to tools. Use them as needed. Be brief.',
-			messages: [
-				{ role: 'user', content: 'What is the weather in Prague?' },
-				{
-					role: 'assistant',
-					content: '',
-					toolCalls: [{ id: ToolCallId('call_001'), name: 'get_weather', input: { city: 'Prague' } }],
-				},
-				{
-					role: 'tool',
-					toolCallId: ToolCallId('call_001'),
-					content: 'Sunny, 22°C',
-				},
-			],
-			tools: [weatherTool],
-		},
-		assert: (r) => {
-			expect(r.content).toBeTruthy()
-			expect(r.finishReason).toBe('stop')
-		},
-	},
-
-	{
-		name: 'tool-error-result',
-		request: {
-			systemPrompt: 'You have access to tools. If a tool fails, explain the error to the user briefly.',
-			messages: [
-				{ role: 'user', content: 'What is the weather in Prague?' },
-				{
-					role: 'assistant',
-					content: '',
-					toolCalls: [{ id: ToolCallId('call_001'), name: 'get_weather', input: { city: 'Prague' } }],
-				},
-				{
-					role: 'tool',
-					toolCallId: ToolCallId('call_001'),
-					content: 'Service unavailable: weather API is down',
-					isError: true,
-				},
-			],
-			tools: [weatherTool],
-		},
-		assert: (r) => {
-			expect(r.content).toBeTruthy()
-			expect(r.finishReason).toBe('stop')
-		},
-	},
-
-	{
-		name: 'assistant-text-with-tool-calls',
-		request: {
-			systemPrompt: 'You have access to tools. When asked about weather, first say you will check, then use the tool.',
-			messages: [
-				{ role: 'user', content: 'What is the weather in Prague and London?' },
-				{
-					role: 'assistant',
-					content: 'Let me check the weather for both cities.',
-					toolCalls: [
-						{ id: ToolCallId('call_001'), name: 'get_weather', input: { city: 'Prague' } },
-						{ id: ToolCallId('call_002'), name: 'get_weather', input: { city: 'London' } },
-					],
-				},
-				{
-					role: 'tool',
-					toolCallId: ToolCallId('call_001'),
-					content: 'Sunny, 22°C',
-				},
-				{
-					role: 'tool',
-					toolCallId: ToolCallId('call_002'),
-					content: 'Rainy, 14°C',
-				},
-			],
-			tools: [weatherTool],
-		},
-		assert: (r) => {
-			expect(r.content).toBeTruthy()
-			expect(r.finishReason).toBe('stop')
-		},
-	},
-
-	{
-		name: 'multiple-tool-calls-requested',
-		request: {
-			systemPrompt: 'You have access to tools. Use ALL relevant tools in a SINGLE response. Always call both tools when asked about weather and search.',
-			messages: [{ role: 'user', content: 'Search for "Prague weather forecast" and also get the current weather in Prague using the weather tool.' }],
-			tools: [weatherTool, searchTool],
-		},
-		assert: (r) => {
-			expect(r.finishReason).toBe('tool_calls')
-			expect(r.toolCalls.length).toBeGreaterThanOrEqual(2)
-			const toolNames = r.toolCalls.map((tc) => tc.name)
-			expect(toolNames).toContain('get_weather')
-			expect(toolNames).toContain('search')
-		},
-	},
-
-	// --- Images ---
-
-	{
-		name: 'image-data-url',
-		request: {
-			systemPrompt: 'Describe images briefly. One sentence.',
-			messages: [{
-				role: 'user',
-				content: [
-					{ type: 'text', text: 'What do you see in this image?' },
-					{ type: 'image_url', imageUrl: { url: `data:image/png;base64,${TINY_PNG}` } },
-				],
-			}],
-		},
-		assert: (r) => {
-			expect(r.content).toBeTruthy()
-			expect(r.finishReason).toBe('stop')
-		},
-	},
-
-	{
-		name: 'image-http-url',
-		request: {
-			systemPrompt: 'Describe images briefly. One sentence.',
-			messages: [{
-				role: 'user',
-				content: [
-					{ type: 'text', text: 'What do you see in this image?' },
-					{ type: 'image_url', imageUrl: { url: 'https://www.google.com/images/branding/googlelogo/2x/googlelogo_color_272x92dp.png' } },
-				],
-			}],
-		},
-		assert: (r) => {
-			expect(r.content).toBeTruthy()
-			expect(r.finishReason).toBe('stop')
-		},
-	},
-
-	{
-		name: 'multiple-images',
-		request: {
-			systemPrompt: 'Describe what you see. Be brief.',
-			messages: [{
-				role: 'user',
-				content: [
-					{ type: 'text', text: 'How many images do you see? What colors?' },
-					{ type: 'image_url', imageUrl: { url: `data:image/png;base64,${TINY_PNG}` } },
-					{ type: 'image_url', imageUrl: { url: `data:image/png;base64,${TINY_PNG}` } },
-				],
-			}],
-		},
-		assert: (r) => {
-			expect(r.content).toBeTruthy()
-			expect(r.finishReason).toBe('stop')
-		},
-	},
-
-	{
-		name: 'tool-result-with-image',
-		request: {
-			systemPrompt: 'You have access to tools. Describe tool results briefly.',
-			messages: [
-				{ role: 'user', content: 'Take a screenshot' },
-				{
-					role: 'assistant',
-					content: '',
-					toolCalls: [{ id: ToolCallId('call_001'), name: 'search', input: { query: 'screenshot' } }],
-				},
-				{
-					role: 'tool',
-					toolCallId: ToolCallId('call_001'),
-					content: [
-						{ type: 'text', text: 'Here is the screenshot:' },
-						{ type: 'image_url', imageUrl: { url: `data:image/png;base64,${TINY_PNG}` } },
-					],
-				},
-			],
-			tools: [searchTool],
-		},
-		assert: (r) => {
-			expect(r.content).toBeTruthy()
-			expect(r.finishReason).toBe('stop')
-		},
-	},
-
-	// --- Edge cases / message merging ---
-
-	{
-		name: 'consecutive-tool-results',
-		request: {
-			systemPrompt: 'You have access to tools. Summarize all results briefly.',
-			messages: [
-				{ role: 'user', content: 'Get weather in Prague and London.' },
-				{
-					role: 'assistant',
-					content: '',
-					toolCalls: [
-						{ id: ToolCallId('call_001'), name: 'get_weather', input: { city: 'Prague' } },
-						{ id: ToolCallId('call_002'), name: 'get_weather', input: { city: 'London' } },
-					],
-				},
-				{
-					role: 'tool',
-					toolCallId: ToolCallId('call_001'),
-					content: 'Sunny, 22°C',
-				},
-				{
-					role: 'tool',
-					toolCallId: ToolCallId('call_002'),
-					content: 'Rainy, 14°C',
-				},
-			],
-			tools: [weatherTool],
-		},
-		assert: (r) => {
-			expect(r.content).toBeTruthy()
-			expect(r.finishReason).toBe('stop')
-		},
-	},
-]
-
-// ============================================================================
-// Run all scenarios against all providers
-// ============================================================================
-
-for (const provider of providers) {
-	describe(`${provider.name} integration`, () => {
-		for (const scenario of scenarios) {
-			const snapshotPath = join(SNAPSHOTS_DIR, `${provider.snapshotPrefix}-${scenario.name}.json`)
-			const hasSnapshot = existsSync(snapshotPath)
-			const shouldSkip = !provider.hasApiKey && !hasSnapshot
-
-			test.skipIf(shouldSkip)(scenario.name, async () => {
-				const llm = provider.create(scenario.name)
-
-				const result = await llm.inference({
-					model: provider.model,
-					...scenario.request,
-				})
-
-				if (!result.ok) {
-					throw new Error(`LLM inference failed: ${JSON.stringify(result.error)}`)
-				}
-
-				scenario.assert(result.value)
-			})
-		}
-	})
-}

package/src/core/llm/reasoning-details.test.ts

@@ -1,177 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import type { LLMMessage } from '~/core/agents/state.js'
-import { isOk } from '~/lib/utils/result.js'
-import { ToolCallId } from '~/core/tools/schema.js'
-import { OpenRouterProvider } from './openrouter.js'
-import type { InferenceRequest, RawInferenceRequest } from './provider.js'
-import { ModelId } from './schema.js'
-
-// ============================================================================
-// reasoning_details round trip
-// ============================================================================
-//
-// OpenRouter returns `reasoning_details` on an assistant message and expects the
-// exact sequence back on the following requests, or a reasoning model loses its
-// chain of thought at every tool call. The blocks are opaque, so what matters is
-// that they come back byte-identical — and that a model which never reasons
-// keeps producing the same request bytes, since the prompt cache is keyed on them.
-
-const testModel = ModelId('openai/gpt-5.6-luna')
-
-/** Shape taken from the OpenRouter docs; treated as opaque everywhere in the SDK. */
-const REASONING_DETAILS = [
-	{
-		type: 'reasoning.summary',
-		summary: 'Analyzed the problem by breaking it into components',
-		id: 'reasoning-summary-1',
-		format: 'anthropic-claude-v1',
-		index: 0,
-	},
-	{
-		type: 'reasoning.encrypted',
-		data: 'EroBCkYIBRgCKkCr0hZ0opaque',
-		id: 'reasoning-encrypted-1',
-		format: 'openai-responses-v1',
-		index: 1,
-	},
-]
-
-type FetchFn = (input: string | URL | Request, init?: RequestInit) => Promise<Response>
-
-const createProvider = (fetchFn?: FetchFn) =>
-	new OpenRouterProvider({
-		apiKey: 'test-key',
-		imageProcessor: { resolveContent: async (content) => content },
-		defaultModel: String(testModel),
-		fetch: fetchFn,
-	})
-
-const respondWith = (message: Record<string, unknown>): FetchFn => async () =>
-	new Response(
-		JSON.stringify({
-			id: 'gen-1',
-			model: String(testModel),
-			choices: [{ message, finish_reason: 'stop' }],
-			usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 },
-		}),
-		{ status: 200, headers: { 'content-type': 'application/json' } },
-	)
-
-const inferenceRequest = (): InferenceRequest => ({
-	model: testModel,
-	systemPrompt: 'You are helpful.',
-	messages: [{ role: 'user', content: 'What is the weather?' }],
-})
-
-const rawRequest = (messages: LLMMessage[]): RawInferenceRequest => ({
-	model: testModel,
-	systemPrompt: 'You are helpful.',
-	messages,
-})
-
-describe('OpenRouter reasoning_details capture', () => {
-	test('captures the blocks and the plaintext reasoning from a response', async () => {
-		const provider = createProvider(respondWith({
-			content: 'It is sunny.',
-			reasoning: 'The user asked about weather, so I check the tool first.',
-			reasoning_details: REASONING_DETAILS,
-		}))
-
-		const result = await provider.inference(inferenceRequest())
-
-		expect(isOk(result)).toBe(true)
-		if (!isOk(result)) return
-		expect(result.value.reasoningDetails).toEqual(REASONING_DETAILS)
-		expect(result.value.reasoning).toBe('The user asked about weather, so I check the tool first.')
-	})
-
-	test('leaves both fields unset for a model that does not reason', async () => {
-		const provider = createProvider(respondWith({ content: 'It is sunny.' }))
-
-		const result = await provider.inference(inferenceRequest())
-
-		expect(isOk(result)).toBe(true)
-		if (!isOk(result)) return
-		expect(result.value.reasoningDetails).toBeUndefined()
-		expect(result.value.reasoning).toBeUndefined()
-	})
-
-	test('normalizes an empty block list to undefined, so nothing is echoed back', async () => {
-		const provider = createProvider(respondWith({ content: 'It is sunny.', reasoning_details: [] }))
-
-		const result = await provider.inference(inferenceRequest())
-
-		expect(isOk(result)).toBe(true)
-		if (!isOk(result)) return
-		expect(result.value.reasoningDetails).toBeUndefined()
-	})
-})
-
-describe('OpenRouter reasoning_details echo', () => {
-	test('sends the blocks back verbatim on the assistant message', async () => {
-		const http = await createProvider().buildHttpRequest(rawRequest([
-			{ role: 'user', content: 'What is the weather?' },
-			{
-				role: 'assistant',
-				content: '',
-				toolCalls: [{ id: ToolCallId('call_1'), name: 'get_weather', input: { city: 'Prague' } }],
-				reasoningDetails: REASONING_DETAILS,
-			},
-			{ role: 'tool', toolCallId: ToolCallId('call_1'), content: 'Sunny' },
-		]))
-
-		// Serialized comparison, because "verbatim" is a claim about the bytes on the
-		// wire — a deep-equal check would pass even if the blocks were rebuilt.
-		const assistant = '{"role":"assistant","content":"","tool_calls":['
-			+ '{"id":"call_1","type":"function","function":{"name":"get_weather","arguments":"{\\"city\\":\\"Prague\\"}"}}'
-			+ `],"reasoning_details":${JSON.stringify(REASONING_DETAILS)}}`
-		expect(JSON.stringify(http.body)).toContain(assistant)
-	})
-
-	test('echoes the blocks on an assistant message that made no tool call', async () => {
-		const http = await createProvider().buildHttpRequest(rawRequest([
-			{ role: 'user', content: 'Think about it.' },
-			{ role: 'assistant', content: 'Thought about it.', reasoningDetails: REASONING_DETAILS },
-			{ role: 'user', content: 'And now?' },
-		]))
-
-		expect(JSON.stringify(http.body)).toContain(
-			`{"role":"assistant","content":"Thought about it.","reasoning_details":${JSON.stringify(REASONING_DETAILS)}}`,
-		)
-	})
-})
-
-describe('OpenRouter request bytes without reasoning', () => {
-	// The prompt cache is keyed on the serialized prefix, so a key that appears
-	// even as `null`/`undefined` for a non-reasoning model would rewrite it.
-	test('adds nothing to a plain assistant message', async () => {
-		const http = await createProvider().buildHttpRequest(rawRequest([
-			{ role: 'user', content: 'What is 2+2?' },
-			{ role: 'assistant', content: '4' },
-			{ role: 'user', content: 'And 3+3?' },
-		]))
-
-		const body = JSON.stringify(http.body)
-		expect(body).toContain('{"role":"assistant","content":"4"}')
-		expect(body).not.toContain('reasoning')
-	})
-
-	test('adds nothing to an assistant message with tool calls', async () => {
-		const http = await createProvider().buildHttpRequest(rawRequest([
-			{ 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' },
-		]))
-
-		const body = JSON.stringify(http.body)
-		expect(body).toContain(
-			'{"role":"assistant","content":"","tool_calls":['
-			+ '{"id":"call_1","type":"function","function":{"name":"get_weather","arguments":"{\\"city\\":\\"Prague\\"}"}}]}',
-		)
-		expect(body).not.toContain('reasoning')
-	})
-})

package/src/core/llm/routing-provider.test.ts

@@ -1,113 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import type { Result } from '~/lib/utils/result.js'
-import { Ok } from '~/lib/utils/result.js'
-import type { InferenceContext, InferenceRequest, InferenceResponse, LLMError, LLMProvider } from './provider.js'
-import type { RoutableLLMProvider } from './routing-provider.js'
-import { RoutingLLMProvider } from './routing-provider.js'
-import { ModelId } from './schema.js'
-
-// ============================================================================
-// Helpers
-// ============================================================================
-
-const createRequest = (model: string): InferenceRequest => ({
-	model: ModelId(model),
-	systemPrompt: 'test',
-	messages: [{ role: 'user', content: 'Hello' }],
-})
-
-const createMockProvider = (name: string, prefix: string): RoutableLLMProvider & { lastModel?: string } => {
-	const provider: RoutableLLMProvider & { lastModel?: string } = {
-		name,
-		canHandle: (model: string) => model.startsWith(prefix),
-		normalizeModel: (model: string) => model.startsWith(`${prefix}/`) ? model.slice(prefix.length + 1) : model,
-		async inference(request: InferenceRequest): Promise<Result<InferenceResponse, LLMError>> {
-			provider.lastModel = request.model
-			return Ok({
-				content: `Response from ${name}`,
-				toolCalls: [],
-				finishReason: 'stop',
-				metrics: { promptTokens: 10, completionTokens: 5, totalTokens: 15, latencyMs: 100, model: request.model },
-			})
-		},
-	}
-	return provider
-}
-
-const createMockFallback = (name: string): LLMProvider & { lastModel?: string } => {
-	const provider: LLMProvider & { lastModel?: string } = {
-		name,
-		async inference(request: InferenceRequest): Promise<Result<InferenceResponse, LLMError>> {
-			provider.lastModel = request.model
-			return Ok({
-				content: `Response from ${name}`,
-				toolCalls: [],
-				finishReason: 'stop',
-				metrics: { promptTokens: 10, completionTokens: 5, totalTokens: 15, latencyMs: 100, model: request.model },
-			})
-		},
-	}
-	return provider
-}
-
-// ============================================================================
-// Tests
-// ============================================================================
-
-describe('RoutingLLMProvider', () => {
-	test('routes to matching provider', async () => {
-		const anthropic = createMockProvider('anthropic', 'anthropic')
-		const fallback = createMockFallback('openrouter')
-
-		const router = new RoutingLLMProvider([anthropic], fallback)
-		const result = await router.inference(createRequest('anthropic/claude-sonnet-4.5'))
-
-		expect(result.ok).toBe(true)
-		if (result.ok) {
-			expect(result.value.content).toBe('Response from anthropic')
-		}
-		// Model should be normalized (prefix stripped)
-		expect(anthropic.lastModel).toBe('claude-sonnet-4.5')
-	})
-
-	test('falls back to fallback provider when no match', async () => {
-		const anthropic = createMockProvider('anthropic', 'anthropic')
-		const fallback = createMockFallback('openrouter')
-
-		const router = new RoutingLLMProvider([anthropic], fallback)
-		const result = await router.inference(createRequest('openai/gpt-4o'))
-
-		expect(result.ok).toBe(true)
-		if (result.ok) {
-			expect(result.value.content).toBe('Response from openrouter')
-		}
-		// Model should be passed through unchanged to fallback
-		expect(fallback.lastModel).toBe('openai/gpt-4o')
-	})
-
-	test('returns error when no provider matches and no fallback', async () => {
-		const anthropic = createMockProvider('anthropic', 'anthropic')
-
-		const router = new RoutingLLMProvider([anthropic])
-		const result = await router.inference(createRequest('openai/gpt-4o'))
-
-		expect(result.ok).toBe(false)
-		if (!result.ok) {
-			expect(result.error.type).toBe('invalid_request')
-		}
-	})
-
-	test('first matching provider wins', async () => {
-		const provider1 = createMockProvider('provider1', 'claude')
-		const provider2 = createMockProvider('provider2', 'claude')
-		const fallback = createMockFallback('fallback')
-
-		const router = new RoutingLLMProvider([provider1, provider2], fallback)
-		const result = await router.inference(createRequest('claude-sonnet-4.5'))
-
-		expect(result.ok).toBe(true)
-		if (result.ok) {
-			expect(result.value.content).toBe('Response from provider1')
-		}
-	})
-})