@namzu/sdk 14.0.7 → 15.0.0

package/src/provider/__tests__/mock-script.test.ts

@@ -1,179 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import { collect } from '../../provider/collect.js'
-import type { ChatCompletionParams } from '../../types/provider/index.js'
-import { MOCK_CAPABILITIES } from '../mock-register.js'
-import { MockLLMProvider } from '../mock.js'
-
-/**
- * The mock could only emit text, and declared `supportsTools: false`, so
- * capability negotiation stripped the tool surface before a request was even
- * built. No consumer could test that the agent loop calls their tool — and
- * namzu's own maintainers hand-rolled eight `implements LLMProvider` fakes
- * across seven test files to work around exactly that. Six of those are now
- * gone; the two that remain are in `registry.test.ts`, which tests that the
- * registry accepts arbitrary provider CONSTRUCTORS — collapsing those onto
- * this mock would defeat what they check.
- *
- * These cases assert the mock produces the frame sequence a REAL driver
- * produces, so a test written against it exercises the consumer path rather
- * than a shortcut through it.
- */
-
-const PARAMS = { model: 'mock', messages: [] } as unknown as ChatCompletionParams
-
-describe('MockLLMProvider — scripted tool calls', () => {
-	it('declares tool support, so capability negotiation does not strip tools', () => {
-		expect(MOCK_CAPABILITIES.supportsTools).toBe(true)
-		expect(MOCK_CAPABILITIES.supportsFunctionCalling).toBe(true)
-	})
-
-	it('emits a tool call the aggregator can reassemble', async () => {
-		const provider = new MockLLMProvider({
-			turns: [{ toolCalls: [{ name: 'read', args: { path: 'a.txt' } }] }],
-		})
-
-		const response = await collect(provider.chatStream(PARAMS))
-
-		expect(response.finishReason).toBe('tool_calls')
-		expect(response.message.toolCalls).toHaveLength(1)
-		const call = response.message.toolCalls?.[0]
-		expect(call?.function.name).toBe('read')
-		expect(JSON.parse(call?.function.arguments ?? '{}')).toEqual({ path: 'a.txt' })
-	})
-
-	it('streams arguments in fragments — the buffering path is real, not bypassed', async () => {
-		const provider = new MockLLMProvider({
-			turns: [{ toolCalls: [{ name: 'grep', args: { pattern: 'needle' }, argChunkSize: 2 }] }],
-		})
-
-		const fragments: string[] = []
-		for await (const chunk of provider.chatStream(PARAMS)) {
-			const args = chunk.delta.toolCalls?.[0]?.function?.arguments
-			if (args) fragments.push(args)
-		}
-
-		expect(fragments.length).toBeGreaterThan(3)
-		expect(JSON.parse(fragments.join(''))).toEqual({ pattern: 'needle' })
-	})
-
-	it('opens each block with id + name and closes it with toolCallEnd', async () => {
-		const provider = new MockLLMProvider({
-			turns: [{ toolCalls: [{ name: 'ls', id: 'call_x' }] }],
-		})
-
-		let opened = false
-		let closed = false
-		for await (const chunk of provider.chatStream(PARAMS)) {
-			const tc = chunk.delta.toolCalls?.[0]
-			if (tc?.id === 'call_x' && tc.function?.name === 'ls') opened = true
-			if (chunk.delta.toolCallEnd?.id === 'call_x') closed = true
-		}
-
-		expect(opened).toBe(true)
-		expect(closed).toBe(true)
-	})
-
-	it('can emit several tool calls in one turn, each on its own index', async () => {
-		const provider = new MockLLMProvider({
-			turns: [{ toolCalls: [{ name: 'a' }, { name: 'b' }, { name: 'c' }] }],
-		})
-		const response = await collect(provider.chatStream(PARAMS))
-		expect(response.message.toolCalls?.map((t) => t.function.name)).toEqual(['a', 'b', 'c'])
-	})
-
-	it('reproduces a tool call cut off mid-JSON', async () => {
-		const provider = new MockLLMProvider({
-			turns: [{ toolCalls: [{ name: 'write', args: { content: 'x' }, truncateArguments: true }] }],
-		})
-
-		let sawEnd = false
-		for await (const chunk of provider.chatStream(PARAMS)) {
-			if (chunk.delta.toolCallEnd) sawEnd = true
-		}
-		// No block-close signal — the consumer must infer truncation.
-		expect(sawEnd).toBe(false)
-	})
-})
-
-describe('MockLLMProvider — multi-turn scripts', () => {
-	it('plays turns in order', async () => {
-		const provider = new MockLLMProvider({
-			turns: [{ toolCalls: [{ name: 'read' }] }, { text: 'all done' }],
-		})
-
-		const first = await collect(provider.chatStream(PARAMS))
-		const second = await collect(provider.chatStream(PARAMS))
-
-		expect(first.message.toolCalls).toHaveLength(1)
-		expect(second.message.content).toBe('all done')
-		expect(second.finishReason).toBe('stop')
-	})
-
-	it('repeats the last turn rather than exhausting, so a loop bug reads as repetition', async () => {
-		const provider = new MockLLMProvider({ turns: [{ text: 'only' }] })
-		await collect(provider.chatStream(PARAMS))
-		const third = await collect(provider.chatStream(PARAMS))
-		expect(third.message.content).toBe('only')
-	})
-
-	it('nextTurn can decide from the request it just received', async () => {
-		const provider = new MockLLMProvider({
-			nextTurn: (_params, i) =>
-				i === 0 ? { toolCalls: [{ name: 'read' }] } : { text: `turn ${i}` },
-		})
-		expect((await collect(provider.chatStream(PARAMS))).message.toolCalls).toHaveLength(1)
-		expect((await collect(provider.chatStream(PARAMS))).message.content).toBe('turn 1')
-	})
-
-	it('captures requests so a test can assert on tools / toolChoice / cacheControl', async () => {
-		const onRequest = vi.fn()
-		const provider = new MockLLMProvider({ turns: [{ text: 'hi' }], onRequest })
-
-		await collect(provider.chatStream({ ...PARAMS, toolChoice: 'none' }))
-
-		expect(onRequest).toHaveBeenCalledTimes(1)
-		expect(provider.requests[0]?.toolChoice).toBe('none')
-	})
-
-	it('reset() rewinds the script and clears captured requests', async () => {
-		const provider = new MockLLMProvider({ turns: [{ text: 'first' }, { text: 'second' }] })
-		await collect(provider.chatStream(PARAMS))
-		provider.reset()
-		expect((await collect(provider.chatStream(PARAMS))).message.content).toBe('first')
-		expect(provider.requests).toHaveLength(1)
-	})
-})
-
-describe('MockLLMProvider — failure injection', () => {
-	it('can fail a request outright with a status, for retry tests', async () => {
-		const provider = new MockLLMProvider({
-			turns: [{ error: { message: 'rate limited', status: 429 } }],
-		})
-		await expect(collect(provider.chatStream(PARAMS))).rejects.toMatchObject({ status: 429 })
-	})
-
-	it('can fail mid-stream after N chunks, for recovery tests', async () => {
-		const provider = new MockLLMProvider({
-			turns: [{ text: 'abcdefghijkl', chunkSize: 4, throwAfterChunks: 2 }],
-		})
-
-		const seen: string[] = []
-		await expect(
-			(async () => {
-				for await (const chunk of provider.chatStream(PARAMS)) {
-					if (chunk.delta.content) seen.push(chunk.delta.content)
-				}
-			})(),
-		).rejects.toThrow('mock stream failure')
-
-		expect(seen).toEqual(['abcd', 'efgh'])
-	})
-})
-
-describe('MockLLMProvider — back-compat', () => {
-	it('still accepts the old responseText shorthand', async () => {
-		const provider = new MockLLMProvider({ responseText: 'legacy' })
-		expect((await collect(provider.chatStream(PARAMS))).message.content).toBe('legacy')
-	})
-})

package/src/provider/__tests__/model-version.test.ts

@@ -1,93 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { modelVersionAtLeast, parseVersionedModelId } from '../model-version.js'
-import type { ModelIdGrammar } from '../model-version.js'
-
-/**
- * The defect this module exists to end: the minor-version group was `\d+`, so
- * it swallowed the 8-digit release date. An id naming no minor therefore
- * parsed as `major.<the date>` and compared as enormously NEWER than one that
- * does, inverting every capability gate keyed on `minor >= n` — a model was
- * told it supported features it does not.
- *
- * Three drivers had each written the same matcher, and all three had it. The
- * vocabulary below is deliberately invented: the shape is what lives here, and
- * a test that needed real product names would be testing the wrong layer.
- */
-
-const GRAMMAR: ModelIdGrammar = {
-	product: 'widget',
-	families: ['small', 'large'],
-	routingPrefix: 'vendor/',
-}
-
-describe('a date suffix is not a minor version', () => {
-	it.each([
-		['widget-small-4-20250514', 'small', 4, 0],
-		['widget-large-4-20250514', 'large', 4, 0],
-		['widget-small-3-20240307', 'small', 3, 0],
-	])('%s parses as %s %d.%d', (id, family, major, minor) => {
-		expect(parseVersionedModelId(id, GRAMMAR)).toEqual({ family, major, minor })
-	})
-
-	it('still reads a real minor that is followed by a date', () => {
-		expect(parseVersionedModelId('widget-large-4-1-20250805', GRAMMAR)).toEqual({
-			family: 'large',
-			major: 4,
-			minor: 1,
-		})
-		expect(parseVersionedModelId('widget-small-4-5-20250929', GRAMMAR)?.minor).toBe(5)
-	})
-
-	it('treats a missing minor as .0 rather than as absent', () => {
-		expect(parseVersionedModelId('widget-large-5', GRAMMAR)).toEqual({
-			family: 'large',
-			major: 5,
-			minor: 0,
-		})
-	})
-
-	it('tolerates the routing prefix, the other separators, and case', () => {
-		expect(parseVersionedModelId('vendor/widget-large-4-5', GRAMMAR)?.minor).toBe(5)
-		expect(parseVersionedModelId('widget-large-4.5', GRAMMAR)?.minor).toBe(5)
-		expect(parseVersionedModelId('WIDGET-LARGE-4-5', GRAMMAR)?.major).toBe(4)
-	})
-
-	it('returns undefined for what the grammar does not describe', () => {
-		for (const id of ['other-large-4', 'widget', 'widget-large', 'widget-medium-4', '']) {
-			expect(parseVersionedModelId(id, GRAMMAR)).toBeUndefined()
-		}
-	})
-
-	it('escapes regex metacharacters in the grammar', () => {
-		// A product or prefix containing `.` or `+` must match literally, not
-		// as a wildcard. `.map(escape)` — the global, deprecated one — would
-		// percent-encode instead, and pass every other test in this file
-		// because no ordinary name contains a character it changes.
-		const odd: ModelIdGrammar = { product: 'a.b', families: ['c+d'] }
-
-		expect(parseVersionedModelId('a.b-c+d-4', odd)?.major).toBe(4)
-		expect(parseVersionedModelId('axb-cxd-4', odd)).toBeUndefined()
-	})
-})
-
-describe('modelVersionAtLeast', () => {
-	it('does not let a dated id clear a gate it is below', () => {
-		// The whole point. With the old `\d+` minor this was `true`, because
-		// 4.20250514 >= 4.5.
-		expect(modelVersionAtLeast('widget-small-4-20250514', GRAMMAR, 4, 5)).toBe(false)
-		expect(modelVersionAtLeast('widget-large-4-20250514', GRAMMAR, 4, 7)).toBe(false)
-	})
-
-	it('admits versions that genuinely clear it', () => {
-		expect(modelVersionAtLeast('widget-small-4-5-20250929', GRAMMAR, 4, 5)).toBe(true)
-		expect(modelVersionAtLeast('widget-large-5', GRAMMAR, 4, 7)).toBe(true)
-		expect(modelVersionAtLeast('widget-large-4-1', GRAMMAR, 4, 5)).toBe(false)
-	})
-
-	it('refuses a name it cannot parse rather than opening the gate', () => {
-		// Fail-safe: a capability gate must not open for an id it does not
-		// understand.
-		expect(modelVersionAtLeast('something-else', GRAMMAR, 4, 5)).toBe(false)
-	})
-})

package/src/provider/__tests__/registry.test.ts

@@ -1,420 +0,0 @@
-import { beforeEach, describe, expect, it } from 'vitest'
-import type {
-	LLMProvider,
-	LazyProviderModule,
-	ProviderCapabilities,
-} from '../../types/provider/index.js'
-import { PERMISSIVE_PROVIDER_CAPABILITIES, resolveProviderCapabilities } from '../capabilities.js'
-import { registerMock } from '../mock-register.js'
-import { MockLLMProvider } from '../mock.js'
-import {
-	DuplicateProviderError,
-	LazyProviderLoadError,
-	LazyProviderSyncCreateError,
-	ProviderRegistry,
-	UnknownProviderError,
-	__resetProviderRegistryInternal,
-} from '../registry.js'
-
-// Simulate a downstream provider package's type registration via module augmentation.
-// This is the pattern every driver package uses in its own code.
-interface TestProviderConfig {
-	type: 'test'
-	value?: string
-}
-
-interface LazyTestProviderConfig {
-	type: 'lazytest'
-	value?: string
-}
-
-declare module '../../types/provider/config.js' {
-	interface ProviderConfigRegistry {
-		test: TestProviderConfig
-		lazytest: LazyTestProviderConfig
-	}
-}
-
-class TestProvider implements LLMProvider {
-	readonly id = 'test'
-	readonly name = 'Test'
-	constructor(public readonly config: TestProviderConfig) {}
-	async chat() {
-		return {
-			id: 'x',
-			model: 'm',
-			message: { role: 'assistant' as const, content: 'ok' },
-			finishReason: 'stop' as const,
-			usage: {
-				promptTokens: 0,
-				completionTokens: 0,
-				totalTokens: 0,
-				cachedTokens: 0,
-				cacheWriteTokens: 0,
-			},
-		}
-	}
-	async *chatStream() {
-		yield { id: 'x', delta: { content: 'ok' } }
-	}
-}
-
-const TEST_CAPS: ProviderCapabilities = {
-	supportsTools: false,
-	supportsStreaming: true,
-	supportsFunctionCalling: false,
-}
-
-class LazyTestProvider implements LLMProvider {
-	readonly id = 'lazytest'
-	readonly name = 'Lazy Test'
-	constructor(
-		public readonly config: LazyTestProviderConfig,
-		readonly capabilities?: ProviderCapabilities,
-	) {}
-	async *chatStream() {
-		yield { id: 'x', delta: { content: 'ok' } }
-	}
-}
-
-const HINT_CAPS: ProviderCapabilities = {
-	supportsTools: false,
-	supportsStreaming: false,
-	supportsFunctionCalling: false,
-}
-
-const MODULE_CAPS: ProviderCapabilities = {
-	supportsTools: true,
-	supportsStreaming: true,
-	supportsFunctionCalling: true,
-	supportsVision: false,
-}
-
-function deferred<T>() {
-	let resolve!: (value: T) => void
-	let reject!: (reason?: unknown) => void
-	const promise = new Promise<T>((res, rej) => {
-		resolve = res
-		reject = rej
-	})
-	return { promise, resolve, reject }
-}
-
-describe('ProviderRegistry', () => {
-	beforeEach(() => {
-		__resetProviderRegistryInternal()
-		registerMock()
-	})
-
-	describe('register', () => {
-		it('registers a provider and stores capabilities', () => {
-			ProviderRegistry.register('test', TestProvider, {
-				supportsTools: true,
-				supportsStreaming: false,
-				supportsFunctionCalling: true,
-			})
-
-			expect(ProviderRegistry.isSupported('test')).toBe(true)
-			expect(ProviderRegistry.getCapabilities('test').supportsTools).toBe(true)
-		})
-
-		it('throws DuplicateProviderError on re-register without replace', () => {
-			ProviderRegistry.register('test', TestProvider, TEST_CAPS)
-			expect(() => ProviderRegistry.register('test', TestProvider, TEST_CAPS)).toThrowError(
-				DuplicateProviderError,
-			)
-		})
-
-		it('allows replacement when { replace: true }', () => {
-			ProviderRegistry.register('test', TestProvider, TEST_CAPS)
-			const newCaps: ProviderCapabilities = {
-				supportsTools: true,
-				supportsStreaming: true,
-				supportsFunctionCalling: true,
-			}
-			expect(() =>
-				ProviderRegistry.register('test', TestProvider, newCaps, { replace: true }),
-			).not.toThrow()
-			expect(ProviderRegistry.getCapabilities('test').supportsTools).toBe(true)
-		})
-	})
-
-	describe('create', () => {
-		it('instantiates the registered provider with typed config', () => {
-			const { provider, capabilities } = ProviderRegistry.create({
-				type: 'mock',
-				model: 'test-model',
-			})
-			expect(provider).toBeInstanceOf(MockLLMProvider)
-			expect(capabilities.supportsStreaming).toBe(true)
-		})
-
-		it('throws UnknownProviderError for unregistered type', () => {
-			expect(() =>
-				ProviderRegistry.create({ type: 'nonexistent' } as unknown as { type: 'mock' }),
-			).toThrowError(UnknownProviderError)
-		})
-	})
-
-	describe('isSupported', () => {
-		it('returns true for registered types', () => {
-			expect(ProviderRegistry.isSupported('mock')).toBe(true)
-		})
-
-		it('returns false for unregistered types', () => {
-			expect(ProviderRegistry.isSupported('nope')).toBe(false)
-		})
-	})
-
-	describe('unregister', () => {
-		it('removes provider and capabilities', () => {
-			ProviderRegistry.register('test', TestProvider, TEST_CAPS)
-			expect(ProviderRegistry.unregister('test')).toBe(true)
-			expect(ProviderRegistry.isSupported('test')).toBe(false)
-		})
-
-		it('returns false when type is not registered', () => {
-			expect(ProviderRegistry.unregister('test')).toBe(false)
-		})
-	})
-
-	describe('listTypes', () => {
-		it('returns all registered types', () => {
-			ProviderRegistry.register('test', TestProvider, TEST_CAPS)
-			const types = ProviderRegistry.listTypes()
-			expect(types).toContain('mock')
-			expect(types).toContain('test')
-		})
-	})
-
-	describe('error types', () => {
-		it('UnknownProviderError preserves type', () => {
-			const err = new UnknownProviderError('foo')
-			expect(err.providerType).toBe('foo')
-			expect(err.name).toBe('UnknownProviderError')
-		})
-
-		it('DuplicateProviderError preserves type', () => {
-			const err = new DuplicateProviderError('bar')
-			expect(err.providerType).toBe('bar')
-			expect(err.name).toBe('DuplicateProviderError')
-		})
-	})
-
-	describe('registerLazy', () => {
-		it('does not invoke the loader at registration time', () => {
-			let calls = 0
-			ProviderRegistry.registerLazy('lazytest', async () => {
-				calls++
-				return { create: (config) => new LazyTestProvider(config) }
-			})
-
-			expect(calls).toBe(0)
-			expect(ProviderRegistry.isSupported('lazytest')).toBe(true)
-			expect(ProviderRegistry.listTypes()).toContain('lazytest')
-		})
-
-		it('throws DuplicateProviderError over an existing eager registration', () => {
-			ProviderRegistry.register('test', TestProvider, TEST_CAPS)
-			expect(() =>
-				ProviderRegistry.registerLazy('test', async () => ({
-					create: (config) => new TestProvider(config),
-				})),
-			).toThrowError(DuplicateProviderError)
-		})
-
-		it('throws DuplicateProviderError over an existing lazy registration', () => {
-			const loader = async (): Promise<LazyProviderModule<LazyTestProviderConfig>> => ({
-				create: (config) => new LazyTestProvider(config),
-			})
-			ProviderRegistry.registerLazy('lazytest', loader)
-			expect(() => ProviderRegistry.registerLazy('lazytest', loader)).toThrowError(
-				DuplicateProviderError,
-			)
-		})
-
-		it('replace: true swaps between eager and lazy registrations', async () => {
-			ProviderRegistry.register('lazytest', LazyTestProvider, TEST_CAPS)
-			ProviderRegistry.registerLazy(
-				'lazytest',
-				async () => ({ create: (config) => new LazyTestProvider(config) }),
-				{ replace: true },
-			)
-			expect(() => ProviderRegistry.createProvider({ type: 'lazytest' })).toThrowError(
-				LazyProviderSyncCreateError,
-			)
-
-			ProviderRegistry.register('lazytest', LazyTestProvider, TEST_CAPS, { replace: true })
-			expect(ProviderRegistry.createProvider({ type: 'lazytest' })).toBeInstanceOf(LazyTestProvider)
-		})
-
-		it('sync create()/createProvider() always throws for lazy types, even after load', async () => {
-			ProviderRegistry.registerLazy('lazytest', async () => ({
-				create: (config) => new LazyTestProvider(config),
-			}))
-
-			expect(() => ProviderRegistry.create({ type: 'lazytest' })).toThrowError(
-				LazyProviderSyncCreateError,
-			)
-
-			await ProviderRegistry.createAsync({ type: 'lazytest' })
-			expect(() => ProviderRegistry.createProvider({ type: 'lazytest' })).toThrowError(
-				LazyProviderSyncCreateError,
-			)
-		})
-
-		it('unregister removes a lazy registration', () => {
-			ProviderRegistry.registerLazy('lazytest', async () => ({
-				create: (config) => new LazyTestProvider(config),
-			}))
-			expect(ProviderRegistry.unregister('lazytest')).toBe(true)
-			expect(ProviderRegistry.isSupported('lazytest')).toBe(false)
-		})
-	})
-
-	describe('createAsync', () => {
-		it('first create invokes the loader once; subsequent creates reuse the cached factory', async () => {
-			let calls = 0
-			ProviderRegistry.registerLazy('lazytest', async () => {
-				calls++
-				return { create: (config) => new LazyTestProvider(config) }
-			})
-
-			const first = await ProviderRegistry.createAsync({ type: 'lazytest', value: 'a' })
-			const second = await ProviderRegistry.createAsync({ type: 'lazytest', value: 'b' })
-
-			expect(calls).toBe(1)
-			expect(first.provider).toBeInstanceOf(LazyTestProvider)
-			expect(second.provider).toBeInstanceOf(LazyTestProvider)
-			expect((second.provider as LazyTestProvider).config.value).toBe('b')
-		})
-
-		it('concurrent first-creates share a single loader invocation', async () => {
-			let calls = 0
-			const gate = deferred<void>()
-			ProviderRegistry.registerLazy('lazytest', async () => {
-				calls++
-				await gate.promise
-				return { create: (config) => new LazyTestProvider(config) }
-			})
-
-			const a = ProviderRegistry.createAsync({ type: 'lazytest' })
-			const b = ProviderRegistry.createAsync({ type: 'lazytest' })
-			gate.resolve()
-
-			const [ra, rb] = await Promise.all([a, b])
-			expect(calls).toBe(1)
-			expect(ra.provider).toBeInstanceOf(LazyTestProvider)
-			expect(rb.provider).toBeInstanceOf(LazyTestProvider)
-		})
-
-		it('loader rejection surfaces as LazyProviderLoadError and the next create retries', async () => {
-			let calls = 0
-			ProviderRegistry.registerLazy('lazytest', async () => {
-				calls++
-				if (calls === 1) {
-					throw new Error('transient network failure')
-				}
-				return { create: (config) => new LazyTestProvider(config) }
-			})
-
-			const failure = await ProviderRegistry.createAsync({ type: 'lazytest' }).catch(
-				(err: unknown) => err,
-			)
-			expect(failure).toBeInstanceOf(LazyProviderLoadError)
-			expect((failure as LazyProviderLoadError).providerType).toBe('lazytest')
-			expect(((failure as LazyProviderLoadError).cause as Error).message).toBe(
-				'transient network failure',
-			)
-
-			const { provider } = await ProviderRegistry.createAsync({ type: 'lazytest' })
-			expect(calls).toBe(2)
-			expect(provider).toBeInstanceOf(LazyTestProvider)
-		})
-
-		it('rejects with LazyProviderLoadError when the loader resolves an invalid module shape', async () => {
-			ProviderRegistry.registerLazy(
-				'lazytest',
-				async () => ({}) as unknown as LazyProviderModule<LazyTestProviderConfig>,
-			)
-			await expect(ProviderRegistry.createAsync({ type: 'lazytest' })).rejects.toThrowError(
-				LazyProviderLoadError,
-			)
-		})
-
-		it('works for eagerly registered types too', async () => {
-			const { provider, capabilities } = await ProviderRegistry.createAsync({
-				type: 'mock',
-				model: 'test-model',
-			})
-			expect(provider).toBeInstanceOf(MockLLMProvider)
-			expect(capabilities.supportsStreaming).toBe(true)
-		})
-
-		it('rejects with UnknownProviderError for unregistered types', async () => {
-			await expect(
-				ProviderRegistry.createAsync({ type: 'nonexistent' } as unknown as { type: 'mock' }),
-			).rejects.toThrowError(UnknownProviderError)
-		})
-	})
-
-	describe('lazy capabilities', () => {
-		it('answers with the registration hint before load, without invoking the loader', () => {
-			let calls = 0
-			ProviderRegistry.registerLazy(
-				'lazytest',
-				async () => {
-					calls++
-					return { create: (config) => new LazyTestProvider(config) }
-				},
-				{ capabilities: HINT_CAPS },
-			)
-
-			expect(ProviderRegistry.getCapabilities('lazytest')).toEqual(HINT_CAPS)
-			expect(calls).toBe(0)
-		})
-
-		it('answers permissively before load when no hint was given', () => {
-			ProviderRegistry.registerLazy('lazytest', async () => ({
-				create: (config) => new LazyTestProvider(config),
-			}))
-			expect(ProviderRegistry.getCapabilities('lazytest')).toEqual(PERMISSIVE_PROVIDER_CAPABILITIES)
-		})
-
-		it('module capabilities replace the hint after load', async () => {
-			ProviderRegistry.registerLazy(
-				'lazytest',
-				async () => ({
-					create: (config) => new LazyTestProvider(config),
-					capabilities: MODULE_CAPS,
-				}),
-				{ capabilities: HINT_CAPS },
-			)
-
-			const { capabilities } = await ProviderRegistry.createAsync({ type: 'lazytest' })
-			expect(capabilities).toEqual(MODULE_CAPS)
-			expect(ProviderRegistry.getCapabilities('lazytest')).toEqual(MODULE_CAPS)
-		})
-
-		it('the constructed instance own capabilities win at run time over any hint', async () => {
-			const instanceCaps: ProviderCapabilities = {
-				supportsTools: true,
-				supportsStreaming: true,
-				supportsFunctionCalling: false,
-				supportsVision: false,
-			}
-			ProviderRegistry.registerLazy(
-				'lazytest',
-				async () => ({ create: (config) => new LazyTestProvider(config, instanceCaps) }),
-				{ capabilities: HINT_CAPS },
-			)
-
-			const { provider } = await ProviderRegistry.createAsync({ type: 'lazytest' })
-			// The query runtime negotiates against the instance, not the registry:
-			const resolved = resolveProviderCapabilities(provider)
-			expect(resolved.supportsTools).toBe(true)
-			expect(resolved.supportsFunctionCalling).toBe(false)
-			expect(resolved.supportsVision).toBe(false)
-		})
-	})
-})