@roj-ai/sdk 0.1.35 → 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/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')
-		}
-	})
-})

package/src/core/llm/snapshot-middleware.test.ts

@@ -1,168 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
-import { mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { Err, Ok, isErr, isOk } from '~/lib/utils/result.js'
-import { applyMiddleware } from './middleware.js'
-import { MockLLMProvider } from './mock.js'
-import type { InferenceRequest, InferenceResponse } from './provider.js'
-import { ModelId } from './schema.js'
-import { createSnapshotLLMMiddleware } from './snapshot-middleware.js'
-
-describe('SnapshotLLMMiddleware', () => {
-	let dir: string
-
-	beforeEach(() => {
-		dir = mkdtempSync(join(tmpdir(), 'roj-snap-'))
-	})
-
-	afterEach(() => {
-		rmSync(dir, { recursive: true, force: true })
-	})
-
-	const request = (overrides: Partial<InferenceRequest> = {}): InferenceRequest => ({
-		model: ModelId('test-model'),
-		systemPrompt: 'You are a test assistant.',
-		messages: [{ role: 'user', content: 'Hello' }],
-		...overrides,
-	})
-
-	const fixedResponse: InferenceResponse = {
-		content: 'Recorded response',
-		toolCalls: [],
-		finishReason: 'stop',
-		metrics: MockLLMProvider.defaultMetrics(),
-	}
-
-	test('records on miss and replays on hit without calling next', async () => {
-		const downstream = new MockLLMProvider(() => fixedResponse)
-		const wrapped = applyMiddleware(downstream, [createSnapshotLLMMiddleware({ snapshotsDir: dir })])
-
-		const first = await wrapped.inference(request())
-		expect(isOk(first)).toBe(true)
-		expect(downstream.getCallCount()).toBe(1)
-
-		// Snapshot file created
-		const files = readdirSync(dir)
-		expect(files.length).toBe(1)
-		expect(files[0]).toMatch(/^[0-9a-f]{16}\.json$/)
-
-		// Replay — downstream NOT called again
-		const second = await wrapped.inference(request())
-		expect(isOk(second)).toBe(true)
-		if (isOk(second)) {
-			expect(second.value.content).toBe('Recorded response')
-		}
-		expect(downstream.getCallCount()).toBe(1)
-	})
-
-	test('distinct requests produce distinct snapshot files', async () => {
-		const downstream = new MockLLMProvider(() => fixedResponse)
-		const wrapped = applyMiddleware(downstream, [createSnapshotLLMMiddleware({ snapshotsDir: dir })])
-
-		await wrapped.inference(request({ messages: [{ role: 'user', content: 'A' }] }))
-		await wrapped.inference(request({ messages: [{ role: 'user', content: 'B' }] }))
-
-		expect(readdirSync(dir).length).toBe(2)
-		expect(downstream.getCallCount()).toBe(2)
-	})
-
-	test('hash is stable across key-order differences', async () => {
-		const downstream = new MockLLMProvider(() => fixedResponse)
-		const wrapped = applyMiddleware(downstream, [createSnapshotLLMMiddleware({ snapshotsDir: dir })])
-
-		// Two requests identical in content but constructed with different key order
-		await wrapped.inference({
-			model: ModelId('m'),
-			systemPrompt: 's',
-			messages: [{ role: 'user', content: 'x' }],
-			temperature: 0.5,
-			maxTokens: 100,
-		})
-		await wrapped.inference({
-			maxTokens: 100,
-			temperature: 0.5,
-			messages: [{ role: 'user', content: 'x' }],
-			systemPrompt: 's',
-			model: ModelId('m'),
-		})
-
-		// Same hash → single snapshot file → downstream called once
-		expect(readdirSync(dir).length).toBe(1)
-		expect(downstream.getCallCount()).toBe(1)
-	})
-
-	test('replay mode errors on miss', async () => {
-		const downstream = new MockLLMProvider(() => fixedResponse)
-		const wrapped = applyMiddleware(downstream, [
-			createSnapshotLLMMiddleware({ snapshotsDir: dir, mode: 'replay' }),
-		])
-
-		const result = await wrapped.inference(request())
-		expect(isErr(result)).toBe(true)
-		if (isErr(result)) {
-			expect(result.error.type).toBe('invalid_request')
-			expect(result.error.message).toContain('Snapshot not found')
-		}
-		expect(downstream.getCallCount()).toBe(0)
-	})
-
-	test('replay mode serves existing snapshot', async () => {
-		// Pre-seed a snapshot by running once in auto mode
-		const downstream1 = new MockLLMProvider(() => fixedResponse)
-		const recording = applyMiddleware(downstream1, [createSnapshotLLMMiddleware({ snapshotsDir: dir })])
-		await recording.inference(request())
-
-		// Now a replay-only chain must hit it
-		const downstream2 = new MockLLMProvider(() => {
-			throw new Error('should not be called')
-		})
-		const replaying = applyMiddleware(downstream2, [
-			createSnapshotLLMMiddleware({ snapshotsDir: dir, mode: 'replay' }),
-		])
-		const result = await replaying.inference(request())
-		expect(isOk(result)).toBe(true)
-		if (isOk(result)) {
-			expect(result.value.content).toBe('Recorded response')
-		}
-	})
-
-	test('record mode overwrites existing snapshot', async () => {
-		// Seed with response A
-		const downstream1 = new MockLLMProvider(() => ({ ...fixedResponse, content: 'A' }))
-		const first = applyMiddleware(downstream1, [createSnapshotLLMMiddleware({ snapshotsDir: dir })])
-		await first.inference(request())
-
-		// Force re-record with response B
-		const downstream2 = new MockLLMProvider(() => ({ ...fixedResponse, content: 'B' }))
-		const second = applyMiddleware(downstream2, [
-			createSnapshotLLMMiddleware({ snapshotsDir: dir, mode: 'record' }),
-		])
-		await second.inference(request())
-
-		// Read back
-		const downstream3 = new MockLLMProvider(() => {
-			throw new Error('should not be called')
-		})
-		const third = applyMiddleware(downstream3, [
-			createSnapshotLLMMiddleware({ snapshotsDir: dir, mode: 'replay' }),
-		])
-		const result = await third.inference(request())
-		expect(isOk(result)).toBe(true)
-		if (isOk(result)) {
-			expect(result.value.content).toBe('B')
-		}
-	})
-
-	test('does not persist error responses', async () => {
-		const downstream = new MockLLMProvider(() => {
-			const err = { type: 'rate_limit' as const, message: 'throttled' }
-			throw err
-		})
-		const wrapped = applyMiddleware(downstream, [createSnapshotLLMMiddleware({ snapshotsDir: dir })])
-
-		const result = await wrapped.inference(request())
-		expect(isErr(result)).toBe(true)
-		expect(readdirSync(dir).length).toBe(0)
-	})
-})