@kaelio/ktx 0.5.0 → 0.7.0

package/dist/llm/embedding-provider.test.js

@@ -1,84 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createKtxEmbeddingProvider } from './embedding-provider.js';
-describe('createKtxEmbeddingProvider', () => {
-    it('rejects deterministic embeddings', () => {
-        const config = JSON.parse(JSON.stringify({
-            backend: 'deterministic',
-            model: 'sha256',
-            dimensions: 6,
-        }));
-        expect(() => createKtxEmbeddingProvider(config)).toThrow('Unsupported KTX embedding backend: deterministic');
-    });
-    it('rejects gateway embeddings', () => {
-        const config = JSON.parse(JSON.stringify({
-            backend: 'gateway',
-            model: 'provider/text-embedding',
-            dimensions: 2,
-            gateway: { apiKey: 'gateway-key' }, // pragma: allowlist secret
-        }));
-        expect(() => createKtxEmbeddingProvider(config)).toThrow('Unsupported KTX embedding backend: gateway');
-    });
-    it('uses OpenAI embeddings with configured dimensions', async () => {
-        const createOpenAIClient = vi.fn(() => ({
-            embeddings: {
-                create: vi.fn().mockResolvedValue({
-                    data: [{ index: 0, embedding: [0.1, 0.2] }],
-                    usage: { total_tokens: 7 },
-                }),
-            },
-        }));
-        const provider = createKtxEmbeddingProvider({
-            backend: 'openai',
-            model: 'text-embedding-3-small',
-            dimensions: 2,
-            openai: { apiKey: 'openai-key', baseURL: 'https://openai.test/v1' }, // pragma: allowlist secret
-        }, { createOpenAIClient });
-        await expect(provider.embed('hello')).resolves.toEqual([0.1, 0.2]);
-        expect(createOpenAIClient).toHaveBeenCalledWith({
-            apiKey: 'openai-key', // pragma: allowlist secret
-            baseURL: 'https://openai.test/v1',
-        });
-    });
-    it('supports sentence-transformers pathPrefix defaults and explicit empty prefix', async () => {
-        const fetch = vi
-            .fn()
-            .mockResolvedValueOnce(new Response(JSON.stringify({ embedding: [0.1, 0.2] }), { status: 200 }))
-            .mockResolvedValueOnce(new Response(JSON.stringify({ embedding: [0.3, 0.4] }), { status: 200 }));
-        const provider = createKtxEmbeddingProvider({
-            backend: 'sentence-transformers',
-            model: 'all-MiniLM-L6-v2',
-            dimensions: 2,
-            sentenceTransformers: { baseURL: 'https://python.test/' },
-        }, { fetch });
-        await expect(provider.embed('hello')).resolves.toEqual([0.3, 0.4]);
-        expect(fetch).toHaveBeenNthCalledWith(1, 'https://python.test/api/embeddings/compute', expect.objectContaining({ method: 'POST' }));
-        expect(fetch).toHaveBeenNthCalledWith(2, 'https://python.test/api/embeddings/compute', expect.objectContaining({ method: 'POST' }));
-        const daemonFetch = vi
-            .fn()
-            .mockResolvedValueOnce(new Response(JSON.stringify({ embedding: [0.1, 0.2] }), { status: 200 }))
-            .mockResolvedValueOnce(new Response(JSON.stringify({ embeddings: [[0.5, 0.6]] }), { status: 200 }));
-        const daemonProvider = createKtxEmbeddingProvider({
-            backend: 'sentence-transformers',
-            model: 'all-MiniLM-L6-v2',
-            dimensions: 2,
-            sentenceTransformers: { baseURL: 'https://daemon.test/base/', pathPrefix: '' },
-        }, { fetch: daemonFetch });
-        await expect(daemonProvider.embedMany(['hello'])).resolves.toEqual([[0.5, 0.6]]);
-        expect(daemonFetch).toHaveBeenNthCalledWith(1, 'https://daemon.test/base/embeddings/compute', expect.objectContaining({ method: 'POST' }));
-        expect(daemonFetch).toHaveBeenNthCalledWith(2, 'https://daemon.test/base/embeddings/compute-bulk', expect.objectContaining({ method: 'POST' }));
-    });
-    it('reports local HTTP daemon failures without a ktx-daemon spawn fallback cascade', async () => {
-        const fetch = vi
-            .fn()
-            .mockResolvedValue(new Response('Embedding compute failed: httpx.InvalidURL: Invalid port', { status: 500 }));
-        const provider = createKtxEmbeddingProvider({
-            backend: 'sentence-transformers',
-            model: 'all-MiniLM-L6-v2',
-            dimensions: 2,
-            sentenceTransformers: { baseURL: 'http://127.0.0.1:8765', pathPrefix: '' },
-        }, { fetch });
-        await expect(provider.embed('hello')).rejects.toThrow('Embedding provider sentence-transformers request failed with HTTP 500: Embedding compute failed: httpx.InvalidURL: Invalid port');
-        await expect(provider.embed('hello')).rejects.not.toThrow('ktx-daemon fallback failed');
-        expect(fetch).toHaveBeenCalledTimes(1);
-    });
-});

package/dist/llm/message-builder.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/llm/message-builder.test.js

@@ -1,127 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { KtxMessageBuilder, splitKtxSystemMessages } from './message-builder.js';
-import { createKtxLlmProvider } from './model-provider.js';
-function makeBuilder(overrides = {}) {
-    const provider = createKtxLlmProvider({
-        backend: 'gateway',
-        gateway: { baseURL: 'https://gateway.test' },
-        modelSlots: { default: 'anthropic/claude-sonnet-4-6' },
-        promptCaching: { enabled: true, ...overrides },
-    });
-    return new KtxMessageBuilder(provider);
-}
-describe('KtxMessageBuilder.build', () => {
-    it('caches static system, last sorted tool, and last history message', () => {
-        const builder = makeBuilder();
-        const out = builder.build({
-            parts: { staticSystem: 'STATIC', dynamicSystem: 'DYNAMIC' },
-            history: [
-                { role: 'user', content: 'first' },
-                { role: 'assistant', content: [{ type: 'text', text: 'reply A' }, { type: 'text', text: 'reply B' }] },
-            ],
-            currentMessage: { role: 'user', content: 'now' },
-            tools: {
-                zoo: { description: 'z' },
-                apple: { description: 'a' },
-            },
-            model: 'anthropic/claude-sonnet-4-6',
-        });
-        expect(out.messages[0]).toMatchObject({
-            role: 'system',
-            content: 'STATIC',
-            providerOptions: { anthropic: { cacheControl: { type: 'ephemeral', ttl: '1h' } } },
-        });
-        expect(out.messages[1]).toMatchObject({ role: 'system', content: 'DYNAMIC' });
-        expect(out.messages[1].providerOptions).toBeUndefined();
-        expect(out.messages[3].content[1].providerOptions).toEqual({
-            anthropic: { cacheControl: { type: 'ephemeral', ttl: '5m' } },
-        });
-        expect(Object.keys(out.tools)).toEqual(['apple', 'zoo']);
-        expect(out.tools.zoo.providerOptions).toEqual({
-            anthropic: { cacheControl: { type: 'ephemeral', ttl: '1h' } },
-        });
-    });
-    it('wraps leading user context onto currentMessage as a system reminder part', () => {
-        const builder = makeBuilder();
-        const out = builder.build({
-            parts: { staticSystem: 'STATIC', leadingUserContext: 'current_date: 2026-05-04' },
-            history: [],
-            currentMessage: { role: 'user', content: 'question' },
-            tools: {},
-            model: 'anthropic/claude-sonnet-4-6',
-        });
-        expect(out.messages[out.messages.length - 1]).toMatchObject({
-            role: 'user',
-            content: [
-                { type: 'text', text: '<system-reminder>\ncurrent_date: 2026-05-04\n</system-reminder>' },
-                { type: 'text', text: 'question' },
-            ],
-        });
-    });
-    it('omits cache markers for non-Anthropic protocol models', () => {
-        const builder = makeBuilder();
-        const out = builder.wrapSimple({
-            system: 'SYS',
-            messages: [{ role: 'user', content: 'q' }],
-            tools: { z: {} },
-            model: 'gpt-5',
-        });
-        expect(out.messages[0].providerOptions).toBeUndefined();
-        expect(out.tools.z.providerOptions).toBeUndefined();
-    });
-    it('clamps every TTL to 5m for Vertex when vertexFallbackTo5m is enabled', () => {
-        const provider = createKtxLlmProvider({
-            backend: 'vertex',
-            vertex: { project: 'ktx-test', location: 'us-east5' },
-            modelSlots: { default: 'claude-sonnet-4-6' },
-            promptCaching: {
-                enabled: true,
-                systemTtl: '1h',
-                toolsTtl: '1h',
-                historyTtl: '1h',
-                vertexFallbackTo5m: true,
-            },
-        });
-        const builder = new KtxMessageBuilder(provider);
-        const out = builder.build({
-            parts: { staticSystem: 'STATIC' },
-            history: [{ role: 'user', content: 'history' }],
-            currentMessage: { role: 'user', content: 'now' },
-            tools: { z: {} },
-            model: 'claude-sonnet-4-6',
-        });
-        expect(out.messages[0].providerOptions.anthropic.cacheControl.ttl).toBe('5m');
-        expect(out.messages[1].content[0].providerOptions.anthropic.cacheControl.ttl).toBe('5m');
-        expect(out.tools.z.providerOptions.anthropic.cacheControl.ttl).toBe('5m');
-    });
-});
-describe('splitKtxSystemMessages', () => {
-    it('returns undefined system when no system messages are present', () => {
-        const split = splitKtxSystemMessages([
-            { role: 'user', content: 'hello' },
-            { role: 'assistant', content: 'hi' },
-        ]);
-        expect(split.system).toBeUndefined();
-        expect(split.messages).toHaveLength(2);
-    });
-    it('returns a single system message object when one system message is present, preserving providerOptions', () => {
-        const systemMessage = {
-            role: 'system',
-            content: 'You are helpful.',
-            providerOptions: { anthropic: { cacheControl: { type: 'ephemeral' } } },
-        };
-        const split = splitKtxSystemMessages([systemMessage, { role: 'user', content: 'hello' }]);
-        expect(split.system).toBe(systemMessage);
-        expect(split.messages).toEqual([{ role: 'user', content: 'hello' }]);
-    });
-    it('returns an array of system messages when multiple are present, in order', () => {
-        const split = splitKtxSystemMessages([
-            { role: 'system', content: 'cached' },
-            { role: 'system', content: 'fresh' },
-            { role: 'user', content: 'hello' },
-        ]);
-        expect(Array.isArray(split.system)).toBe(true);
-        expect(split.system).toHaveLength(2);
-        expect(split.messages).toEqual([{ role: 'user', content: 'hello' }]);
-    });
-});

package/dist/llm/model-health.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/llm/model-health.test.js

@@ -1,55 +0,0 @@
-import { wrapLanguageModel as defaultWrapLanguageModel } from 'ai';
-import { describe, expect, it, vi } from 'vitest';
-import { runKtxLlmHealthCheck } from './model-health.js';
-const anthropicModel = { modelId: 'claude-sonnet-4-6' };
-describe('KTX LLM health check', () => {
-    it('runs a minimal non-streaming model call through the configured provider', async () => {
-        const generateText = vi.fn(async () => ({ text: 'ok' }));
-        const createAnthropic = vi.fn(() => vi.fn(() => anthropicModel));
-        const wrapLanguageModel = vi.fn(defaultWrapLanguageModel);
-        await expect(runKtxLlmHealthCheck({
-            backend: 'anthropic',
-            anthropic: { apiKey: 'sk-ant-test' }, // pragma: allowlist secret
-            modelSlots: { default: 'claude-sonnet-4-6' },
-        }, { deps: { createAnthropic, generateText, devtoolsEnabled: true, wrapLanguageModel } })).resolves.toEqual({ ok: true });
-        expect(createAnthropic).toHaveBeenCalledWith(expect.objectContaining({
-            apiKey: 'sk-ant-test', // pragma: allowlist secret
-        }));
-        expect(generateText).toHaveBeenCalledWith(expect.objectContaining({
-            model: anthropicModel,
-            prompt: 'Reply with exactly: ok',
-            temperature: 0,
-            maxOutputTokens: 8,
-        }));
-        expect(wrapLanguageModel).not.toHaveBeenCalled();
-    });
-    it('returns a failed result without exposing secret values', async () => {
-        const generateText = vi.fn(async () => {
-            throw new Error('401 invalid x-api-key sk-ant-secret');
-        });
-        await expect(runKtxLlmHealthCheck({
-            backend: 'anthropic',
-            anthropic: { apiKey: 'sk-ant-secret' }, // pragma: allowlist secret
-            modelSlots: { default: 'claude-sonnet-4-6' },
-        }, {
-            deps: {
-                createAnthropic: vi.fn(() => vi.fn(() => anthropicModel)),
-                generateText,
-            },
-        })).resolves.toEqual({
-            ok: false,
-            message: '401 invalid x-api-key [redacted]',
-        });
-    });
-    it('reports claude-code as unsupported by the AI SDK health check', async () => {
-        const result = await runKtxLlmHealthCheck({
-            backend: 'claude-code',
-            modelSlots: { default: 'sonnet' },
-            promptCaching: { enabled: false },
-        });
-        expect(result).toEqual({
-            ok: false,
-            message: expect.stringContaining('claude-code is not an AI SDK LanguageModel backend'),
-        });
-    });
-});

package/dist/llm/model-provider.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/llm/model-provider.test.js

@@ -1,246 +0,0 @@
-import { devToolsMiddleware as defaultDevToolsMiddleware } from '@ai-sdk/devtools';
-import { wrapLanguageModel as defaultWrapLanguageModel } from 'ai';
-import { describe, expect, it, vi } from 'vitest';
-import { createKtxLlmProvider } from './model-provider.js';
-const languageModel = (modelId, provider = 'test') => ({ modelId, provider });
-const devtoolsMiddleware = () => ({ specificationVersion: 'v3' });
-const wrapWith = (model) => vi.fn((_options) => model);
-describe('createKtxLlmProvider', () => {
-    it('wraps language models with DevTools middleware when explicitly enabled', () => {
-        const anthropicModel = languageModel('claude-sonnet-4-6', 'anthropic');
-        const wrappedModel = languageModel('claude-sonnet-4-6', 'anthropic-devtools');
-        const middleware = devtoolsMiddleware();
-        const wrapLanguageModel = wrapWith(wrappedModel);
-        const devToolsMiddleware = vi.fn(devtoolsMiddleware);
-        const provider = createKtxLlmProvider({
-            backend: 'anthropic',
-            anthropic: { apiKey: 'test-anthropic-key' }, // pragma: allowlist secret
-            modelSlots: { default: 'claude-sonnet-4-6' },
-            promptCaching: { enabled: false },
-        }, {
-            createAnthropic: vi.fn(() => vi.fn(() => anthropicModel)),
-            devtoolsEnabled: true,
-            wrapLanguageModel,
-            devToolsMiddleware,
-        });
-        expect(provider.getModel('default')).toBe(wrappedModel);
-        expect(devToolsMiddleware).toHaveBeenCalledTimes(1);
-        expect(wrapLanguageModel).toHaveBeenCalledWith({
-            model: anthropicModel,
-            middleware,
-            modelId: 'claude-sonnet-4-6',
-            providerId: 'anthropic',
-        });
-    });
-    it('does not wrap language models by default', () => {
-        const anthropicModel = languageModel('claude-sonnet-4-6', 'anthropic');
-        const wrapLanguageModel = vi.fn(defaultWrapLanguageModel);
-        const devToolsMiddleware = vi.fn(defaultDevToolsMiddleware);
-        const provider = createKtxLlmProvider({
-            backend: 'anthropic',
-            anthropic: { apiKey: 'test-anthropic-key' }, // pragma: allowlist secret
-            modelSlots: { default: 'claude-sonnet-4-6' },
-            promptCaching: { enabled: false },
-        }, {
-            createAnthropic: vi.fn(() => vi.fn(() => anthropicModel)),
-            devtoolsEnabled: false,
-            wrapLanguageModel,
-            devToolsMiddleware,
-        });
-        expect(provider.getModel('default')).toBe(anthropicModel);
-        expect(wrapLanguageModel).not.toHaveBeenCalled();
-        expect(devToolsMiddleware).not.toHaveBeenCalled();
-    });
-    it('wraps language models when KTX_AI_DEVTOOLS_ENABLED is true', () => {
-        const originalEnv = process.env.KTX_AI_DEVTOOLS_ENABLED;
-        process.env.KTX_AI_DEVTOOLS_ENABLED = 'true';
-        try {
-            const gatewayModel = languageModel('anthropic/claude-sonnet-4-6', 'gateway');
-            const wrappedModel = languageModel('anthropic/claude-sonnet-4-6', 'gateway-devtools');
-            const wrapLanguageModel = wrapWith(wrappedModel);
-            const provider = createKtxLlmProvider({
-                backend: 'gateway',
-                gateway: { baseURL: 'https://gateway.test/v1' },
-                modelSlots: { default: 'anthropic/claude-sonnet-4-6' },
-                promptCaching: { enabled: false },
-            }, {
-                createGateway: vi.fn(() => vi.fn(() => gatewayModel)),
-                wrapLanguageModel,
-                devToolsMiddleware: vi.fn(devtoolsMiddleware),
-            });
-            expect(provider.getModel('default')).toBe(wrappedModel);
-            expect(wrapLanguageModel).toHaveBeenCalledTimes(1);
-        }
-        finally {
-            if (originalEnv === undefined) {
-                delete process.env.KTX_AI_DEVTOOLS_ENABLED;
-            }
-            else {
-                process.env.KTX_AI_DEVTOOLS_ENABLED = originalEnv;
-            }
-        }
-    });
-    it('does not wrap language models in production even when enabled', () => {
-        const originalNodeEnv = process.env.NODE_ENV;
-        process.env.NODE_ENV = 'production';
-        try {
-            const anthropicModel = languageModel('claude-sonnet-4-6', 'anthropic');
-            const wrapLanguageModel = vi.fn(defaultWrapLanguageModel);
-            const devToolsMiddleware = vi.fn(defaultDevToolsMiddleware);
-            const provider = createKtxLlmProvider({
-                backend: 'anthropic',
-                anthropic: { apiKey: 'test-anthropic-key' }, // pragma: allowlist secret
-                modelSlots: { default: 'claude-sonnet-4-6' },
-                promptCaching: { enabled: false },
-            }, {
-                createAnthropic: vi.fn(() => vi.fn(() => anthropicModel)),
-                devtoolsEnabled: true,
-                wrapLanguageModel,
-                devToolsMiddleware,
-            });
-            expect(provider.getModel('default')).toBe(anthropicModel);
-            expect(wrapLanguageModel).not.toHaveBeenCalled();
-            expect(devToolsMiddleware).not.toHaveBeenCalled();
-        }
-        finally {
-            if (originalNodeEnv === undefined) {
-                delete process.env.NODE_ENV;
-            }
-            else {
-                process.env.NODE_ENV = originalNodeEnv;
-            }
-        }
-    });
-    it('uses direct Anthropic with both beta headers', () => {
-        const anthropicModel = languageModel('claude-sonnet-4-6', 'anthropic');
-        const anthropic = vi.fn(() => anthropicModel);
-        const createAnthropic = vi.fn(() => anthropic);
-        const provider = createKtxLlmProvider({
-            backend: 'anthropic',
-            anthropic: { apiKey: 'test-anthropic-key', baseURL: 'https://anthropic.test' }, // pragma: allowlist secret
-            modelSlots: { default: 'claude-sonnet-4-6' },
-            promptCaching: { enabled: false },
-        }, { createAnthropic, devtoolsEnabled: false });
-        expect(provider.getModel('default')).toBe(anthropicModel);
-        expect(createAnthropic).toHaveBeenCalledWith({
-            apiKey: 'test-anthropic-key', // pragma: allowlist secret
-            baseURL: 'https://anthropic.test',
-            headers: {
-                'anthropic-beta': 'interleaved-thinking-2025-05-14,extended-cache-ttl-2025-04-11',
-            },
-        });
-        expect(anthropic).toHaveBeenCalledWith('claude-sonnet-4-6');
-    });
-    it('uses Vertex Anthropic without the direct-Anthropic beta header', () => {
-        const vertexModel = languageModel('claude-sonnet-4-6', 'vertex');
-        const vertex = vi.fn(() => vertexModel);
-        const createVertexAnthropic = vi.fn(() => vertex);
-        const provider = createKtxLlmProvider({
-            backend: 'vertex',
-            vertex: { project: 'ktx-test', location: 'us-east5' },
-            modelSlots: { default: 'claude-sonnet-4-6' },
-            promptCaching: { enabled: false },
-        }, { createVertexAnthropic, devtoolsEnabled: false });
-        expect(provider.getModel('default')).toBe(vertexModel);
-        expect(createVertexAnthropic).toHaveBeenCalledWith({ project: 'ktx-test', location: 'us-east5' });
-        expect(vertex).toHaveBeenCalledWith('claude-sonnet-4-6');
-    });
-    it('uses Gateway and supports role fallback to default', () => {
-        const gatewayModel = languageModel('anthropic/claude-sonnet-4-6', 'gateway');
-        const gateway = vi.fn(() => gatewayModel);
-        const createGateway = vi.fn(() => gateway);
-        const provider = createKtxLlmProvider({
-            backend: 'gateway',
-            gateway: { apiKey: 'gateway-key', baseURL: 'https://gateway.test/v1' }, // pragma: allowlist secret
-            modelSlots: { default: 'anthropic/claude-sonnet-4-6' },
-            promptCaching: { enabled: false },
-        }, { createGateway, devtoolsEnabled: false });
-        expect(provider.getModel('curator')).toBe(gatewayModel);
-        expect(createGateway).toHaveBeenCalledWith({
-            apiKey: 'gateway-key', // pragma: allowlist secret
-            baseURL: 'https://gateway.test/v1',
-            headers: {
-                'anthropic-beta': 'interleaved-thinking-2025-05-14,extended-cache-ttl-2025-04-11',
-            },
-        });
-        expect(gateway).toHaveBeenCalledWith('anthropic/claude-sonnet-4-6');
-    });
-    it('uses explicit role overrides before default', () => {
-        const anthropic = vi.fn((modelId) => languageModel(modelId, 'anthropic'));
-        const provider = createKtxLlmProvider({
-            backend: 'anthropic',
-            anthropic: { apiKey: 'test-anthropic-key' }, // pragma: allowlist secret
-            modelSlots: {
-                default: 'claude-sonnet-4-6',
-                triage: 'claude-haiku-4-5',
-                repair: 'claude-opus-4-7',
-            },
-            promptCaching: { enabled: false },
-        }, { createAnthropic: vi.fn(() => anthropic) });
-        expect(provider.getModel('triage').modelId).toBe('claude-haiku-4-5');
-        expect(provider.getModel('repair').modelId).toBe('claude-opus-4-7');
-        expect(provider.getModel('reconcile').modelId).toBe('claude-sonnet-4-6');
-    });
-    it('emits cache markers only when enabled and the model speaks Anthropic protocol', () => {
-        const provider = createKtxLlmProvider({
-            backend: 'gateway',
-            gateway: { baseURL: 'https://gateway.test/v1' },
-            modelSlots: { default: 'anthropic/claude-sonnet-4-6' },
-            promptCaching: { enabled: true },
-        }, { createGateway: vi.fn(() => vi.fn((modelId) => languageModel(modelId, 'gateway'))) });
-        expect(provider.cacheMarker('1h', 'anthropic/claude-sonnet-4-6')).toEqual({
-            anthropic: { cacheControl: { type: 'ephemeral', ttl: '1h' } },
-        });
-        expect(provider.cacheMarker('1h', 'gpt-5')).toBeUndefined();
-    });
-    it('returns Anthropic thinking provider options', () => {
-        const provider = createKtxLlmProvider({
-            backend: 'anthropic',
-            anthropic: { apiKey: 'test-anthropic-key' }, // pragma: allowlist secret
-            modelSlots: { default: 'claude-sonnet-4-6' },
-            promptCaching: { enabled: false },
-        }, { createAnthropic: vi.fn(() => vi.fn((modelId) => languageModel(modelId, 'anthropic'))) });
-        expect(provider.thinkingProviderOptions('default', 12000)).toEqual({
-            anthropic: {
-                thinking: { type: 'enabled', budgetTokens: 12000 },
-            },
-        });
-    });
-    it('defaults prompt caching to enabled with canonical TTLs', () => {
-        const provider = createKtxLlmProvider({
-            backend: 'gateway',
-            gateway: { baseURL: 'https://gateway.test/v1' },
-            modelSlots: { default: 'anthropic/claude-sonnet-4-6' },
-        }, { createGateway: vi.fn(() => vi.fn((modelId) => languageModel(modelId, 'gateway'))) });
-        expect(provider.promptCachingConfig()).toEqual({
-            enabled: true,
-            systemTtl: '1h',
-            toolsTtl: '1h',
-            historyTtl: '5m',
-            cacheSystem: true,
-            cacheTools: true,
-            cacheHistory: true,
-            vertexFallbackTo5m: false,
-        });
-        expect(provider.cacheMarker('1h', 'anthropic/claude-sonnet-4-6')).toEqual({
-            anthropic: { cacheControl: { type: 'ephemeral', ttl: '1h' } },
-        });
-    });
-    it('preserves explicit prompt caching opt-out', () => {
-        const provider = createKtxLlmProvider({
-            backend: 'anthropic',
-            anthropic: { apiKey: 'test-anthropic-key' }, // pragma: allowlist secret
-            modelSlots: { default: 'claude-sonnet-4-6' },
-            promptCaching: { enabled: false },
-        }, { createAnthropic: vi.fn(() => vi.fn((modelId) => languageModel(modelId, 'anthropic'))) });
-        expect(provider.promptCachingConfig().enabled).toBe(false);
-        expect(provider.cacheMarker('1h', 'claude-sonnet-4-6')).toBeUndefined();
-    });
-    it('throws instead of falling through when an unsupported LLM backend is passed to the AI SDK provider factory', () => {
-        expect(() => createKtxLlmProvider({
-            backend: 'claude-code',
-            modelSlots: { default: 'sonnet' },
-            promptCaching: { enabled: false },
-        })).toThrow('claude-code is not an AI SDK LanguageModel backend');
-    });
-});

package/dist/llm/repair.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/llm/repair.test.js

@@ -1,78 +0,0 @@
-import { NoSuchToolError } from 'ai';
-import { describe, expect, it, vi } from 'vitest';
-import { createKtxToolCallRepairHandler } from './repair.js';
-const repairModel = { modelId: 'claude-repair', provider: 'anthropic' };
-describe('createKtxToolCallRepairHandler', () => {
-    it('returns null for NoSuchToolError', async () => {
-        const handler = createKtxToolCallRepairHandler({
-            source: 'unit',
-            getRepairModel: () => repairModel,
-            generateText: vi.fn(),
-        });
-        await expect(handler({
-            system: undefined,
-            messages: [],
-            toolCall: { type: 'tool-call', toolName: 'missing', toolCallId: 'tc_1', input: '{}' },
-            tools: {},
-            inputSchema: async () => ({}),
-            error: new NoSuchToolError({ toolName: 'missing' }),
-        })).resolves.toBeNull();
-    });
-    it('repairs string input by local JSON extraction without an LLM call', async () => {
-        const generateText = vi.fn();
-        const handler = createKtxToolCallRepairHandler({
-            source: 'unit',
-            getRepairModel: () => repairModel,
-            generateText,
-        });
-        await expect(handler({
-            system: undefined,
-            messages: [],
-            toolCall: {
-                type: 'tool-call',
-                toolName: 'write_source',
-                toolCallId: 'tc_2',
-                input: 'prefix {"path":"orders.yaml"} suffix',
-            },
-            tools: { write_source: {} },
-            inputSchema: async () => ({ type: 'object' }),
-            error: new Error('Invalid tool input'),
-        })).resolves.toEqual({
-            type: 'tool-call',
-            toolName: 'write_source',
-            toolCallId: 'tc_2',
-            input: '{"path":"orders.yaml"}',
-        });
-        expect(generateText).not.toHaveBeenCalled();
-    });
-    it('falls back to the repair model when local extraction fails', async () => {
-        const generateText = vi.fn().mockResolvedValue({ text: '{"path":"customers.yaml"}' });
-        const handler = createKtxToolCallRepairHandler({
-            source: 'unit',
-            getRepairModel: () => repairModel,
-            generateText,
-        });
-        await expect(handler({
-            system: undefined,
-            messages: [],
-            toolCall: {
-                type: 'tool-call',
-                toolName: 'write_source',
-                toolCallId: 'tc_3',
-                input: 'not json',
-            },
-            tools: { write_source: {} },
-            inputSchema: async () => ({ type: 'object', properties: { path: { type: 'string' } } }),
-            error: new Error('Invalid tool input'),
-        })).resolves.toEqual({
-            type: 'tool-call',
-            toolName: 'write_source',
-            toolCallId: 'tc_3',
-            input: '{"path":"customers.yaml"}',
-        });
-        expect(generateText).toHaveBeenCalledWith(expect.objectContaining({
-            model: repairModel,
-            prompt: expect.stringContaining('The model tried to call the tool "write_source"'),
-        }));
-    });
-});

package/dist/local-adapters.test.d.ts

@@ -1 +0,0 @@
-export {};