@kaelio/ktx 0.0.0 → 0.1.0-rc.0

package/node_modules/@ktx/llm/dist/message-builder.test.js

@@ -0,0 +1,97 @@
+import { describe, expect, it } from 'vitest';
+import { KtxMessageBuilder } 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');
+    });
+});

package/node_modules/@ktx/llm/dist/model-health.d.ts

@@ -0,0 +1,18 @@
+import { generateText } from 'ai';
+import { type KtxLlmProviderFactoryDeps } from './model-provider.js';
+import type { KtxLlmConfig } from './types.js';
+export type KtxLlmHealthCheckResult = {
+    ok: true;
+} | {
+    ok: false;
+    message: string;
+};
+export interface KtxLlmHealthCheckDeps extends Omit<KtxLlmProviderFactoryDeps, 'generateText'> {
+    generateText?: (options: Parameters<typeof generateText>[0]) => Promise<unknown>;
+}
+export interface KtxLlmHealthCheckOptions {
+    prompt?: string;
+    timeoutMs?: number;
+    deps?: KtxLlmHealthCheckDeps;
+}
+export declare function runKtxLlmHealthCheck(config: KtxLlmConfig, options?: KtxLlmHealthCheckOptions): Promise<KtxLlmHealthCheckResult>;

package/node_modules/@ktx/llm/dist/model-health.js

@@ -0,0 +1,38 @@
+import { generateText } from 'ai';
+import { createKtxLlmProvider } from './model-provider.js';
+function redactHealthCheckMessage(message, config) {
+    const secrets = [config.anthropic?.apiKey, config.gateway?.apiKey].filter((value) => typeof value === 'string' && value.length > 0);
+    return secrets.reduce((current, secret) => current.split(secret).join('[redacted]'), message);
+}
+async function withTimeout(promise, timeoutMs) {
+    let timeout;
+    const timeoutPromise = new Promise((_resolve, reject) => {
+        timeout = setTimeout(() => reject(new Error(`LLM health check timed out after ${timeoutMs}ms`)), timeoutMs);
+    });
+    try {
+        return await Promise.race([promise, timeoutPromise]);
+    }
+    finally {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+    }
+}
+export async function runKtxLlmHealthCheck(config, options = {}) {
+    try {
+        const { generateText: runGenerateTextOverride, ...providerDeps } = options.deps ?? {};
+        const provider = createKtxLlmProvider(config, providerDeps);
+        const runGenerateText = runGenerateTextOverride ?? generateText;
+        await withTimeout(runGenerateText({
+            model: provider.getModel('default'),
+            prompt: options.prompt ?? 'Reply with exactly: ok',
+            temperature: 0,
+            maxOutputTokens: 8,
+        }), options.timeoutMs ?? 15_000);
+        return { ok: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { ok: false, message: redactHealthCheckMessage(message, config) };
+    }
+}

package/node_modules/@ktx/llm/dist/model-health.test.d.ts

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

package/node_modules/@ktx/llm/dist/model-health.test.js

@@ -0,0 +1,41 @@
+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));
+        await expect(runKtxLlmHealthCheck({
+            backend: 'anthropic',
+            anthropic: { apiKey: 'sk-ant-test' },
+            modelSlots: { default: 'claude-sonnet-4-6' },
+        }, { deps: { createAnthropic, generateText } })).resolves.toEqual({ ok: true });
+        expect(createAnthropic).toHaveBeenCalledWith(expect.objectContaining({
+            apiKey: 'sk-ant-test',
+        }));
+        expect(generateText).toHaveBeenCalledWith(expect.objectContaining({
+            model: anthropicModel,
+            prompt: 'Reply with exactly: ok',
+            temperature: 0,
+            maxOutputTokens: 8,
+        }));
+    });
+    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' },
+            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]',
+        });
+    });
+});

package/node_modules/@ktx/llm/dist/model-provider.d.ts

@@ -0,0 +1,18 @@
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createVertexAnthropic } from '@ai-sdk/google-vertex/anthropic';
+import { createGateway, generateText, type LanguageModel } from 'ai';
+import type { KtxLlmConfig, KtxLlmProvider } from './types.js';
+type AnthropicFactory = typeof createAnthropic;
+type AnthropicModelFactory = (modelId: string) => LanguageModel;
+type VertexAnthropicFactory = (options?: Parameters<typeof createVertexAnthropic>[0]) => AnthropicModelFactory;
+type GatewayFactory = (options?: Parameters<typeof createGateway>[0]) => AnthropicModelFactory;
+export interface KtxLlmProviderFactoryDeps {
+    createAnthropic?: (options?: Parameters<AnthropicFactory>[0]) => AnthropicModelFactory;
+    createVertexAnthropic?: VertexAnthropicFactory;
+    createGateway?: GatewayFactory;
+    generateText?: typeof generateText;
+}
+export declare function modelIdFromLanguageModel(model: LanguageModel | string): string;
+export declare function isAnthropicProtocolModel(model: LanguageModel | string): boolean;
+export declare function createKtxLlmProvider(config: KtxLlmConfig, deps?: KtxLlmProviderFactoryDeps): KtxLlmProvider;
+export {};

package/node_modules/@ktx/llm/dist/model-provider.js

@@ -0,0 +1,111 @@
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createVertexAnthropic } from '@ai-sdk/google-vertex/anthropic';
+import { createGateway, generateText } from 'ai';
+import { createKtxToolCallRepairHandler } from './repair.js';
+const DEFAULT_PROMPT_CACHING = {
+    enabled: true,
+    systemTtl: '1h',
+    toolsTtl: '1h',
+    historyTtl: '5m',
+    cacheSystem: true,
+    cacheTools: true,
+    cacheHistory: true,
+    vertexFallbackTo5m: false,
+};
+const DIRECT_ANTHROPIC_BETA_HEADER = 'interleaved-thinking-2025-05-14,extended-cache-ttl-2025-04-11';
+function resolvePromptCaching(config) {
+    return { ...DEFAULT_PROMPT_CACHING, ...config.promptCaching };
+}
+export function modelIdFromLanguageModel(model) {
+    return typeof model === 'string' ? model : (model.modelId ?? '');
+}
+export function isAnthropicProtocolModel(model) {
+    const modelId = modelIdFromLanguageModel(model);
+    return modelId.startsWith('claude-') || modelId.startsWith('anthropic/') || modelId.includes('/claude-');
+}
+class DefaultKtxLlmProvider {
+    config;
+    promptCaching;
+    getModelByResolvedName;
+    runGenerateText;
+    constructor(config, deps) {
+        this.config = config;
+        this.promptCaching = resolvePromptCaching(config);
+        this.runGenerateText = deps.generateText ?? generateText;
+        this.getModelByResolvedName = this.createModelFactory(config, deps);
+    }
+    getModel(role) {
+        return this.getModelByName(this.resolveRole(role));
+    }
+    getModelByName(modelId) {
+        return this.getModelByResolvedName(modelId);
+    }
+    cacheMarker(ttl, model) {
+        if (!this.promptCaching.enabled) {
+            return undefined;
+        }
+        if (model && !isAnthropicProtocolModel(model)) {
+            return undefined;
+        }
+        return { anthropic: { cacheControl: { type: 'ephemeral', ttl } } };
+    }
+    repairToolCallHandler(options = {}) {
+        return createKtxToolCallRepairHandler({
+            source: options.source ?? 'ktx-llm',
+            getRepairModel: () => this.getModel('repair'),
+            generateText: this.runGenerateText,
+        });
+    }
+    thinkingProviderOptions(_role, budgetTokens) {
+        return {
+            anthropic: {
+                thinking: { type: 'enabled', budgetTokens },
+            },
+        };
+    }
+    telemetryConfig() {
+        return this.config.telemetry?.experimentalTelemetry;
+    }
+    promptCachingConfig() {
+        return this.promptCaching;
+    }
+    activeBackend() {
+        return this.config.backend;
+    }
+    resolveRole(role) {
+        return this.config.modelSlots[role] ?? this.config.modelSlots.default;
+    }
+    createModelFactory(config, deps) {
+        if (config.backend === 'anthropic') {
+            const anthropic = (deps.createAnthropic ?? createAnthropic)({
+                ...(config.anthropic?.apiKey ? { apiKey: config.anthropic.apiKey } : {}),
+                ...(config.anthropic?.baseURL ? { baseURL: config.anthropic.baseURL } : {}),
+                headers: {
+                    'anthropic-beta': DIRECT_ANTHROPIC_BETA_HEADER,
+                },
+            });
+            return (modelId) => anthropic(modelId);
+        }
+        if (config.backend === 'vertex') {
+            if (!config.vertex?.location) {
+                throw new Error('vertex.location is required when KTX LLM backend is vertex');
+            }
+            const vertex = (deps.createVertexAnthropic ?? createVertexAnthropic)({
+                ...(config.vertex.project ? { project: config.vertex.project } : {}),
+                location: config.vertex.location,
+            });
+            return (modelId) => vertex(modelId);
+        }
+        const gateway = (deps.createGateway ?? createGateway)({
+            ...(config.gateway?.apiKey ? { apiKey: config.gateway.apiKey } : {}),
+            ...(config.gateway?.baseURL ? { baseURL: config.gateway.baseURL } : {}),
+        });
+        return (modelId) => gateway(modelId);
+    }
+}
+export function createKtxLlmProvider(config, deps = {}) {
+    if (!config.modelSlots.default) {
+        throw new Error('modelSlots.default is required');
+    }
+    return new DefaultKtxLlmProvider(config, deps);
+}

package/node_modules/@ktx/llm/dist/model-provider.test.d.ts

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

package/node_modules/@ktx/llm/dist/model-provider.test.js

@@ -0,0 +1,127 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createKtxLlmProvider } from './model-provider.js';
+const languageModel = (modelId, provider = 'test') => ({ modelId, provider });
+describe('createKtxLlmProvider', () => {
+    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 });
+        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 });
+        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 });
+        expect(provider.getModel('curator')).toBe(gatewayModel);
+        expect(createGateway).toHaveBeenCalledWith({
+            apiKey: 'gateway-key', // pragma: allowlist secret
+            baseURL: 'https://gateway.test/v1',
+        });
+        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();
+    });
+});

package/node_modules/@ktx/llm/dist/package-exports.test.d.ts

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

package/node_modules/@ktx/llm/dist/package-exports.test.js

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest';
+describe('@ktx/llm package exports', () => {
+    it('exports the canonical LLM and embedding surfaces', async () => {
+        const llm = await import('./index.js');
+        expect(llm.KTX_MODEL_ROLES).toEqual([
+            'default',
+            'triage',
+            'candidateExtraction',
+            'curator',
+            'reconcile',
+            'repair',
+        ]);
+        expect(llm.createKtxLlmProvider).toBeTypeOf('function');
+        expect(llm.KtxMessageBuilder).toBeTypeOf('function');
+        expect(llm.createKtxEmbeddingProvider).toBeTypeOf('function');
+    });
+});

package/node_modules/@ktx/llm/dist/repair.d.ts

@@ -0,0 +1,8 @@
+import { type LanguageModel, type ToolCallRepairFunction, type ToolSet, generateText } from 'ai';
+interface KtxToolCallRepairHandlerInput {
+    source: string;
+    getRepairModel: () => LanguageModel;
+    generateText?: typeof generateText;
+}
+export declare function createKtxToolCallRepairHandler(input: KtxToolCallRepairHandlerInput): ToolCallRepairFunction<ToolSet>;
+export {};

package/node_modules/@ktx/llm/dist/repair.js

@@ -0,0 +1,75 @@
+import { NoSuchToolError, generateText } from 'ai';
+function extractJsonFromText(text) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+        return null;
+    }
+    try {
+        JSON.parse(trimmed);
+        return trimmed;
+    }
+    catch { }
+    let start = trimmed.indexOf('{');
+    while (start >= 0) {
+        let end = trimmed.lastIndexOf('}');
+        while (end > start) {
+            const candidate = trimmed.slice(start, end + 1);
+            try {
+                JSON.parse(candidate);
+                return candidate;
+            }
+            catch { }
+            end = trimmed.lastIndexOf('}', end - 1);
+        }
+        start = trimmed.indexOf('{', start + 1);
+    }
+    return null;
+}
+export function createKtxToolCallRepairHandler(input) {
+    const runGenerateText = input.generateText ?? generateText;
+    return async ({ toolCall, tools, inputSchema, error }) => {
+        if (NoSuchToolError.isInstance(error)) {
+            return null;
+        }
+        if (typeof toolCall.input === 'string') {
+            const extracted = extractJsonFromText(toolCall.input);
+            if (extracted) {
+                return {
+                    type: 'tool-call',
+                    toolName: toolCall.toolName,
+                    toolCallId: toolCall.toolCallId,
+                    input: extracted,
+                };
+            }
+        }
+        if (!(toolCall.toolName in tools)) {
+            return null;
+        }
+        try {
+            const schema = await inputSchema({ toolName: toolCall.toolName });
+            const { text } = await runGenerateText({
+                model: input.getRepairModel(),
+                prompt: `The model tried to call the tool "${toolCall.toolName}" with the following inputs:
+${JSON.stringify(toolCall.input)}
+
+However, this caused a validation error: ${error.message}
+
+The tool accepts the following schema:
+${JSON.stringify(schema)}
+
+Please generate corrected inputs that match the schema. Return ONLY valid JSON, no explanation or markdown formatting.`,
+            });
+            const cleaned = extractJsonFromText(text) ?? text.trim();
+            const parsed = JSON.parse(cleaned);
+            return {
+                type: 'tool-call',
+                toolName: toolCall.toolName,
+                toolCallId: toolCall.toolCallId,
+                input: JSON.stringify(parsed),
+            };
+        }
+        catch {
+            return null;
+        }
+    };
+}

package/node_modules/@ktx/llm/dist/repair.test.d.ts

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

package/node_modules/@ktx/llm/dist/repair.test.js

@@ -0,0 +1,78 @@
+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"'),
+        }));
+    });
+});