@kaelio/ktx 0.0.0 → 0.1.0-rc.0

package/node_modules/@ktx/context/dist/scan/description-generation.js

@@ -0,0 +1,376 @@
+import { generateKtxText } from '../llm/index.js';
+function descriptionSources(rawDescriptions) {
+    if (!rawDescriptions) {
+        return [];
+    }
+    return Object.entries(rawDescriptions).filter(([source, text]) => source !== 'ai' && source !== 'user' && !!text);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function toTableRef(table) {
+    return {
+        catalog: table.catalog,
+        db: table.db,
+        name: table.name,
+    };
+}
+async function runWithConcurrency(items, concurrencyLimit, worker) {
+    const results = [];
+    let nextIndex = 0;
+    const workerCount = Math.max(1, Math.min(concurrencyLimit, items.length || 1));
+    await Promise.all(Array.from({ length: workerCount }, async () => {
+        while (nextIndex < items.length) {
+            const index = nextIndex;
+            nextIndex += 1;
+            const item = items[index];
+            if (item !== undefined) {
+                results[index] = await worker(item, index);
+            }
+        }
+    }));
+    return results;
+}
+export function appendKtxWordLimitInstruction(prompt, maxWords) {
+    return `${prompt}\n\nPlease provide a concise description in ${maxWords} words or less.`;
+}
+export function buildKtxColumnDescriptionPrompt(input) {
+    const sampleValues = input.columnValues.slice(0, 5);
+    const valuesStr = sampleValues
+        .filter((value) => value !== null && value !== undefined)
+        .map((value) => String(value))
+        .join(', ');
+    let prompt = `Analyze this database column and provide a concise description:
+
+<table_context> ${input.tableContext} </table_context>
+
+<column_name> ${input.columnName} </column_name>
+
+<sample_values> ${valuesStr} </sample_values>
+`;
+    const sources = descriptionSources(input.rawDescriptions);
+    if (sources.length > 0) {
+        prompt += '\nExisting descriptions from other sources:\n';
+        for (const [source, text] of sources) {
+            prompt += `<${source}_documentation> ${text} </${source}_documentation>\n`;
+        }
+        prompt +=
+            '\nSynthesize a description that captures the most important information from all sources. Prioritize the sources as authoritative context.\n';
+    }
+    prompt += `
+Provide a brief description of what this column contains without repeating the column name.
+Focus on the data's meaning and business purpose. Start directly with the content description.
+Example:
+"first names of individuals, likely employees or contacts" instead of "The column contains first names..."
+"Job titles or roles of individuals..." instead of "This column contains job titles..."
+`;
+    if (input.dataSourceType === 'BIGQUERY' && input.supportsNestedAnalysis) {
+        const hasNestedData = sampleValues.some((value) => {
+            const text = String(value);
+            return text.includes('nested') || text.includes('{') || text.includes('[');
+        });
+        if (hasNestedData) {
+            prompt +=
+                '\nNote: This column contains nested/structured data (JSON, STRUCT, or ARRAY) - describe its general business purpose and data organization.';
+        }
+    }
+    return prompt.trim();
+}
+export function buildKtxTableDescriptionPrompt(input) {
+    const columnInfo = [];
+    for (let index = 0; index < Math.min(input.sampleData.headers.length, 10); index += 1) {
+        const header = input.sampleData.headers[index];
+        const sampleValues = input.sampleData.rows
+            .slice(0, 3)
+            .map((row) => row[index])
+            .filter((value) => value !== null && value !== undefined);
+        columnInfo.push(`${header}: ${sampleValues.map((value) => String(value)).join(', ')}`);
+    }
+    let prompt = `
+        Analyze this database table and provide a concise description:
+
+        Table: ${input.tableName}
+        Columns and sample data: ${columnInfo.join(' | ')}
+        Total rows in sample: ${input.sampleData.rows.length}
+        Data source type: ${input.dataSourceType}
+        `;
+    const sources = descriptionSources(input.rawDescriptions);
+    if (sources.length > 0) {
+        prompt += '\n        Existing descriptions from other sources:\n';
+        for (const [source, text] of sources) {
+            prompt += `        ${source}: ${text}\n`;
+        }
+        prompt +=
+            '\n        Synthesize a description that captures the most important information from all sources. Prioritize the sources as authoritative context.\n';
+    }
+    if (input.dataSourceType === 'BIGQUERY') {
+        prompt +=
+            "\nNote (Don't include this note in the final answer.): This is a BigQuery table which may contain nested structures, arrays, or other complex data types.";
+    }
+    prompt += `
+
+        Provide a brief description of what this table represents and its business purpose.
+        Do NOT list or describe individual columns or fields.
+        Start directly with the content description without mentioning the table name.
+        Focus on the data's meaning and business purpose.
+        Example: "Information about healthcare professionals used for workforce management" instead of "The blahblah table contains information about healthcare professionals including their names, titles..."
+        `;
+    return prompt.trim();
+}
+export function buildKtxDataSourceDescriptionPrompt(input) {
+    const tablesText = input.tableSamples
+        .map(([tableName, sampleData]) => `${tableName} (${sampleData.headers.length} columns, ${sampleData.rows.length} sample rows)`)
+        .join(' | ');
+    let prompt = `
+        Analyze this database and provide a concise description:
+
+        Tables: ${tablesText}
+        Total tables analyzed: ${input.tableSamples.length}
+        Data source type: ${input.dataSourceType}
+        `;
+    if (input.dataSourceType === 'BIGQUERY') {
+        prompt +=
+            "\nNote (Don't include this note in the final answer): This is a BigQuery dataset which may contain large-scale analytics data, nested structures, and complex data types.";
+    }
+    prompt += `
+
+        Provide a direct, concise description of what this database represents and its business purpose.
+        Do NOT start with phrases like "This database appears to represent" or "This BigQuery dataset".
+        Start directly with the domain or business area description.
+        Focus on the overall data model and its intended use.
+        Example: "Healthcare-related database with a focus on patient management..." instead of "This database appears to represent a healthcare-related system..."
+        `;
+    return prompt.trim();
+}
+export class KtxDescriptionGenerator {
+    llmProvider;
+    cache;
+    logger;
+    settings;
+    constructor(options) {
+        this.llmProvider = options.llmProvider;
+        this.cache = options.cache;
+        this.logger = options.logger;
+        this.settings = {
+            columnMaxWords: options.settings.columnMaxWords,
+            tableMaxWords: options.settings.tableMaxWords,
+            dataSourceMaxWords: options.settings.dataSourceMaxWords,
+            ...(options.settings.temperature !== undefined ? { temperature: options.settings.temperature } : {}),
+            concurrencyLimit: options.settings.concurrencyLimit ?? 5,
+        };
+    }
+    async generateColumnDescriptions(input) {
+        const columnsToProcess = input.table.columns;
+        const tableContext = `Table: ${input.table.name} | Columns: ${columnsToProcess.map((column) => column.name).join(', ')} | Data source: ${input.dataSourceType}`;
+        const results = await runWithConcurrency(columnsToProcess, this.settings.concurrencyLimit, async (column) => this.generateOneColumnDescription(input, column, tableContext));
+        const columnDescriptions = [];
+        const processedColumns = [];
+        const skippedColumns = [];
+        for (const result of results) {
+            columnDescriptions.push([result.columnName, result.description]);
+            if (result.skipped) {
+                skippedColumns.push(result.columnName);
+            }
+            else if (result.processed) {
+                processedColumns.push(result.columnName);
+            }
+        }
+        return {
+            columnDescriptions,
+            processedColumns,
+            skippedColumns,
+        };
+    }
+    async generateTableDescription(input) {
+        const tableRef = toTableRef(input.table);
+        const cacheKey = this.cache?.buildTableKey(tableRef);
+        if (cacheKey) {
+            const cached = await this.cache?.get(cacheKey);
+            if (cached) {
+                return cached;
+            }
+        }
+        if (!input.connector.sampleTable) {
+            this.logger?.warn('KTX scan connector does not support table sampling for table description generation', {
+                connectorId: input.connector.id,
+                table: input.table.name,
+            });
+            return 'Table not found';
+        }
+        try {
+            const sampleData = await input.connector.sampleTable({
+                connectionId: input.connectionId,
+                table: tableRef,
+                limit: 20,
+            }, input.context);
+            const prompt = buildKtxTableDescriptionPrompt({
+                tableName: input.table.name,
+                sampleData,
+                dataSourceType: input.dataSourceType,
+                rawDescriptions: input.table.rawDescriptions,
+            });
+            const description = await this.generateAiDescription(prompt, this.settings.tableMaxWords, 'ktx-table-description');
+            if (cacheKey) {
+                await this.cache?.set(cacheKey, description);
+            }
+            return description;
+        }
+        catch (error) {
+            this.logger?.error(`Error generating table description: ${errorMessage(error)}`);
+            return 'Table not found';
+        }
+    }
+    async generateDataSourceDescription(input) {
+        if (input.tables.length === 0) {
+            return 'No tables found in database';
+        }
+        const cacheKey = input.connectionName ? this.cache?.buildConnectionKey(input.connectionName) : undefined;
+        if (cacheKey) {
+            const cached = await this.cache?.get(cacheKey);
+            if (cached) {
+                return cached;
+            }
+        }
+        if (!input.connector.sampleTable) {
+            this.logger?.warn('KTX scan connector does not support table sampling for data-source description generation', {
+                connectorId: input.connector.id,
+            });
+            return 'No accessible tables found in database';
+        }
+        const tablesToAnalyze = input.tables.slice(0, 10);
+        const tableSamples = await runWithConcurrency(tablesToAnalyze, this.settings.concurrencyLimit, async (table) => {
+            try {
+                const sampleData = await input.connector.sampleTable({
+                    connectionId: input.connectionId,
+                    table: toTableRef(table),
+                    limit: 5,
+                }, input.context);
+                return [table.name, sampleData];
+            }
+            catch (error) {
+                this.logger?.warn(`Failed to sample table '${table.name}' for data source analysis - ${errorMessage(error)}`);
+                return null;
+            }
+        });
+        const accessibleSamples = tableSamples.filter((sample) => sample !== null);
+        if (accessibleSamples.length === 0) {
+            return 'No accessible tables found in database';
+        }
+        try {
+            const prompt = buildKtxDataSourceDescriptionPrompt({
+                tableSamples: accessibleSamples,
+                dataSourceType: input.dataSourceType,
+            });
+            const description = await this.generateAiDescription(prompt, this.settings.dataSourceMaxWords, 'ktx-data-source-description');
+            if (cacheKey) {
+                await this.cache?.set(cacheKey, description);
+            }
+            return description;
+        }
+        catch (error) {
+            this.logger?.error(`Error generating data source description: ${errorMessage(error)}`);
+            return 'Failed to generate data source description';
+        }
+    }
+    async generateOneColumnDescription(input, column, tableContext) {
+        const existingDescription = input.existingDescriptions?.[column.name];
+        if (input.skipExisting && existingDescription) {
+            return {
+                columnName: column.name,
+                description: existingDescription,
+                skipped: true,
+                processed: false,
+            };
+        }
+        const tableRef = toTableRef(input.table);
+        const cacheKey = this.cache?.buildColumnKey(tableRef, column.name);
+        if (cacheKey) {
+            const cached = await this.cache?.get(cacheKey);
+            if (cached) {
+                return {
+                    columnName: column.name,
+                    description: cached,
+                    skipped: true,
+                    processed: false,
+                };
+            }
+        }
+        try {
+            let columnValues = column.sampleValues;
+            if (!columnValues || columnValues.length === 0) {
+                if (!input.connector.sampleColumn) {
+                    this.logger?.warn('KTX scan connector does not support column sampling for column description generation', {
+                        connectorId: input.connector.id,
+                        table: input.table.name,
+                        column: column.name,
+                    });
+                    return {
+                        columnName: column.name,
+                        description: null,
+                        skipped: false,
+                        processed: false,
+                    };
+                }
+                const sample = await input.connector.sampleColumn({
+                    connectionId: input.connectionId,
+                    table: tableRef,
+                    column: column.name,
+                    limit: 50,
+                }, input.context);
+                columnValues = sample.values;
+            }
+            const nonNullValues = (columnValues ?? []).filter((value) => value !== null && value !== undefined);
+            if (nonNullValues.length === 0) {
+                return {
+                    columnName: column.name,
+                    description: null,
+                    skipped: false,
+                    processed: false,
+                };
+            }
+            const prompt = buildKtxColumnDescriptionPrompt({
+                columnName: column.name,
+                columnValues: nonNullValues,
+                tableContext,
+                dataSourceType: input.dataSourceType,
+                supportsNestedAnalysis: input.supportsNestedAnalysis,
+                rawDescriptions: column.rawDescriptions,
+            });
+            const description = await this.generateAiDescription(prompt, this.settings.columnMaxWords, 'ktx-column-description');
+            if (cacheKey) {
+                await this.cache?.set(cacheKey, description);
+            }
+            return {
+                columnName: column.name,
+                description,
+                skipped: false,
+                processed: true,
+            };
+        }
+        catch (error) {
+            this.logger?.error(`Error analyzing column '${column.name}': ${errorMessage(error)}`);
+            return {
+                columnName: column.name,
+                description: `Error generating description: ${errorMessage(error)}`,
+                skipped: false,
+                processed: false,
+            };
+        }
+    }
+    async generateAiDescription(prompt, maxWords, _operationName) {
+        try {
+            const text = await generateKtxText({
+                llmProvider: this.llmProvider,
+                role: 'candidateExtraction',
+                prompt: appendKtxWordLimitInstruction(prompt, maxWords),
+                temperature: this.settings.temperature,
+            });
+            const description = text.trim();
+            return description || 'Failed to generate description';
+        }
+        catch (error) {
+            this.logger?.error(`Error generating AI description: ${errorMessage(error)}`);
+            return `Error generating description: ${errorMessage(error)}`;
+        }
+    }
+}

package/node_modules/@ktx/context/dist/scan/description-generation.test.d.ts

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

package/node_modules/@ktx/context/dist/scan/description-generation.test.js

@@ -0,0 +1,271 @@
+import { describe, expect, it, vi } from 'vitest';
+vi.mock('ai', async (importOriginal) => {
+    const actual = await importOriginal();
+    return { ...actual, generateText: vi.fn() };
+});
+import { generateText } from 'ai';
+import { buildKtxColumnDescriptionPrompt, buildKtxDataSourceDescriptionPrompt, buildKtxTableDescriptionPrompt, KtxDescriptionGenerator, } from './description-generation.js';
+import { createKtxConnectorCapabilities } from './types.js';
+function createCache(initial = {}) {
+    const data = new Map(Object.entries(initial));
+    return {
+        buildTableKey: (table) => [table.catalog, table.db, table.name].filter(Boolean).join('.'),
+        buildColumnKey: (table, columnName) => [table.catalog, table.db, table.name, columnName].filter(Boolean).join('.'),
+        buildConnectionKey: (connectionName) => `__connection:${connectionName}`,
+        get: vi.fn(async (key) => data.get(key) ?? null),
+        set: vi.fn(async (key, value) => {
+            data.set(key, value);
+        }),
+    };
+}
+function createLlmProvider(text = 'generated description') {
+    vi.mocked(generateText).mockResolvedValue({ text });
+    return {
+        getModel: vi.fn().mockReturnValue({ modelId: 'claude-sonnet-4-6', provider: 'anthropic' }),
+        getModelByName: vi.fn(),
+        cacheMarker: vi.fn(),
+        repairToolCallHandler: vi.fn(),
+        thinkingProviderOptions: vi.fn(),
+        telemetryConfig: vi.fn(),
+        promptCachingConfig: vi.fn(() => ({
+            enabled: false,
+            systemTtl: '1h',
+            toolsTtl: '1h',
+            historyTtl: '5m',
+            cacheSystem: true,
+            cacheTools: true,
+            cacheHistory: true,
+            vertexFallbackTo5m: false,
+        })),
+        activeBackend: vi.fn(() => 'anthropic'),
+    };
+}
+function createConnector() {
+    return {
+        id: 'test-connector',
+        driver: 'postgres',
+        capabilities: createKtxConnectorCapabilities({
+            tableSampling: true,
+            columnSampling: true,
+            nestedAnalysis: true,
+        }),
+        introspect: vi.fn(async () => {
+            throw new Error('introspection is not used by description generation');
+        }),
+        sampleColumn: vi.fn(async () => ({
+            values: ['paid', 'refunded', null],
+            nullCount: 1,
+            distinctCount: 2,
+        })),
+        sampleTable: vi.fn(async () => ({
+            headers: ['id', 'status', 'amount'],
+            rows: [
+                [1, 'paid', 20],
+                [2, 'refunded', 10],
+            ],
+            totalRows: 2,
+        })),
+    };
+}
+describe('KTX description prompt builders', () => {
+    it('builds column prompts with sample values, source descriptions, and nested BigQuery guidance', () => {
+        const prompt = buildKtxColumnDescriptionPrompt({
+            columnName: 'payload',
+            columnValues: [{ nested: true }, '[1,2]'],
+            tableContext: 'Table: events | Columns: payload | Data source: BIGQUERY',
+            dataSourceType: 'BIGQUERY',
+            supportsNestedAnalysis: true,
+            rawDescriptions: { db: 'Raw event payload', ai: 'Old AI text', user: 'User text' },
+        });
+        expect(prompt).toContain('<table_context> Table: events | Columns: payload | Data source: BIGQUERY </table_context>');
+        expect(prompt).toContain('<column_name> payload </column_name>');
+        expect(prompt).toContain('<sample_values> [object Object], [1,2] </sample_values>');
+        expect(prompt).toContain('<db_documentation> Raw event payload </db_documentation>');
+        expect(prompt).not.toContain('Old AI text');
+        expect(prompt).not.toContain('User text');
+        expect(prompt).toContain('nested/structured data');
+    });
+    it('builds table and data-source prompts from sampled rows', () => {
+        const sample = {
+            headers: ['id', 'status'],
+            rows: [
+                [1, 'paid'],
+                [2, 'refunded'],
+            ],
+            totalRows: 2,
+        };
+        expect(buildKtxTableDescriptionPrompt({
+            tableName: 'orders',
+            sampleData: sample,
+            dataSourceType: 'POSTGRESQL',
+            rawDescriptions: { dbt: 'Fact table for commerce orders' },
+        })).toContain('status: paid, refunded');
+        expect(buildKtxDataSourceDescriptionPrompt({
+            tableSamples: [['orders', sample]],
+            dataSourceType: 'POSTGRESQL',
+        })).toContain('orders (2 columns, 2 sample rows)');
+    });
+});
+describe('KtxDescriptionGenerator', () => {
+    it('generates column descriptions with pre-fetched values, cache hits, and word-limit metadata', async () => {
+        const cache = createCache({ 'warehouse.public.orders.cached_status': 'Cached status description' });
+        const llmProvider = createLlmProvider('Payment state');
+        const connector = createConnector();
+        const generator = new KtxDescriptionGenerator({
+            llmProvider,
+            cache,
+            settings: {
+                columnMaxWords: 12,
+                tableMaxWords: 18,
+                dataSourceMaxWords: 24,
+                temperature: 0.2,
+                concurrencyLimit: 2,
+            },
+        });
+        const result = await generator.generateColumnDescriptions({
+            connectionId: 'conn-1',
+            connector,
+            context: { runId: 'run-1' },
+            dataSourceType: 'POSTGRESQL',
+            supportsNestedAnalysis: false,
+            table: {
+                catalog: 'warehouse',
+                db: 'public',
+                name: 'orders',
+                columns: [
+                    { name: 'status', sampleValues: ['paid', 'refunded'], rawDescriptions: { db: 'Payment lifecycle' } },
+                    { name: 'cached_status', sampleValues: ['open'] },
+                ],
+            },
+            skipExisting: false,
+            existingDescriptions: {},
+        });
+        expect(result).toEqual({
+            columnDescriptions: [
+                ['status', 'Payment state'],
+                ['cached_status', 'Cached status description'],
+            ],
+            processedColumns: ['status'],
+            skippedColumns: ['cached_status'],
+        });
+        expect(connector.sampleColumn).not.toHaveBeenCalled();
+        expect(generateText).toHaveBeenCalledWith(expect.objectContaining({
+            temperature: 0.2,
+            messages: expect.arrayContaining([
+                expect.objectContaining({
+                    role: 'user',
+                    content: expect.stringContaining('Please provide a concise description in 12 words or less.'),
+                }),
+            ]),
+        }));
+    });
+    it('samples through the connector when column values are not pre-fetched', async () => {
+        const connector = createConnector();
+        const generator = new KtxDescriptionGenerator({
+            llmProvider: createLlmProvider('Current order state'),
+            settings: {
+                columnMaxWords: 12,
+                tableMaxWords: 18,
+                dataSourceMaxWords: 24,
+            },
+        });
+        const result = await generator.generateColumnDescriptions({
+            connectionId: 'conn-1',
+            connector,
+            context: { runId: 'run-1' },
+            dataSourceType: 'POSTGRESQL',
+            supportsNestedAnalysis: false,
+            table: {
+                catalog: null,
+                db: 'public',
+                name: 'orders',
+                columns: [{ name: 'status' }],
+            },
+        });
+        expect(connector.sampleColumn).toHaveBeenCalledWith({
+            connectionId: 'conn-1',
+            table: { catalog: null, db: 'public', name: 'orders' },
+            column: 'status',
+            limit: 50,
+        }, { runId: 'run-1' });
+        expect(result.columnDescriptions).toEqual([['status', 'Current order state']]);
+    });
+    it('samples through a description sampling port without requiring structural introspection', async () => {
+        const sampler = {
+            id: 'description-sampler:conn-1',
+            sampleColumn: vi.fn(async () => ({
+                values: ['paid', 'refunded'],
+                nullCount: null,
+                distinctCount: null,
+            })),
+            sampleTable: vi.fn(async () => ({
+                headers: ['id', 'status'],
+                rows: [[1, 'paid']],
+                totalRows: 1,
+            })),
+        };
+        const generator = new KtxDescriptionGenerator({
+            llmProvider: createLlmProvider('Generated through sampler'),
+            settings: {
+                columnMaxWords: 12,
+                tableMaxWords: 18,
+                dataSourceMaxWords: 24,
+            },
+        });
+        const result = await generator.generateColumnDescriptions({
+            connectionId: 'conn-1',
+            connector: sampler,
+            context: { runId: 'run-1' },
+            dataSourceType: 'POSTGRESQL',
+            supportsNestedAnalysis: false,
+            table: {
+                catalog: null,
+                db: 'public',
+                name: 'orders',
+                columns: [{ name: 'status' }],
+            },
+        });
+        expect(result.columnDescriptions).toEqual([['status', 'Generated through sampler']]);
+        expect(sampler.sampleColumn).toHaveBeenCalledWith({
+            connectionId: 'conn-1',
+            table: { catalog: null, db: 'public', name: 'orders' },
+            column: 'status',
+            limit: 50,
+        }, { runId: 'run-1' });
+        expect('introspect' in sampler).toBe(false);
+    });
+    it('generates and caches table and data-source descriptions', async () => {
+        const cache = createCache();
+        const connector = createConnector();
+        const generator = new KtxDescriptionGenerator({
+            llmProvider: createLlmProvider('Commerce orders'),
+            cache,
+            settings: {
+                columnMaxWords: 12,
+                tableMaxWords: 18,
+                dataSourceMaxWords: 24,
+                concurrencyLimit: 2,
+            },
+        });
+        await expect(generator.generateTableDescription({
+            connectionId: 'conn-1',
+            connector,
+            context: { runId: 'run-1' },
+            dataSourceType: 'POSTGRESQL',
+            table: { catalog: 'warehouse', db: 'public', name: 'orders', rawDescriptions: { db: 'Raw orders' } },
+        })).resolves.toBe('Commerce orders');
+        await expect(generator.generateDataSourceDescription({
+            connectionId: 'conn-1',
+            connector,
+            context: { runId: 'run-1' },
+            dataSourceType: 'POSTGRESQL',
+            tables: [
+                { catalog: 'warehouse', db: 'public', name: 'orders' },
+                { catalog: 'warehouse', db: 'public', name: 'customers' },
+            ],
+            connectionName: 'Warehouse',
+        })).resolves.toBe('Commerce orders');
+        expect(cache.set).toHaveBeenCalledWith('warehouse.public.orders', 'Commerce orders');
+        expect(cache.set).toHaveBeenCalledWith('__connection:Warehouse', 'Commerce orders');
+    });
+});

package/node_modules/@ktx/context/dist/scan/embedding-text.d.ts

@@ -0,0 +1,21 @@
+export interface KtxColumnEmbeddingForeignKeys {
+    outgoing: Array<{
+        toTable: string;
+        toColumn: string;
+    }>;
+    incoming: Array<{
+        fromTable: string;
+        fromColumn: string;
+    }>;
+}
+export interface KtxColumnEmbeddingTextInput {
+    tableName: string;
+    columnName: string;
+    columnType: string;
+    resolvedDescription: string | null;
+    sampleValues?: readonly string[] | null;
+    resolvedTableDescription?: string | null;
+    foreignKeys?: KtxColumnEmbeddingForeignKeys | null;
+    maxSampleValues?: number;
+}
+export declare function buildKtxColumnEmbeddingText(input: KtxColumnEmbeddingTextInput): string;