@kaelio/ktx 0.15.0 → 0.16.0

package/dist/context/core/config-reference.js

@@ -1,6 +1,7 @@
 import { readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { resolve } from 'node:path';
+import { KtxExpectedError } from '../../errors.js';
 /** @internal */
 export function resolveKtxHomePath(path) {
     if (path === '~') {
@@ -22,7 +23,16 @@ export function resolveKtxConfigReference(value, env) {
     }
     if (value.startsWith('file:')) {
         const filePath = resolveKtxHomePath(value.slice('file:'.length).trim());
-        const fileValue = readFileSync(filePath, 'utf8').trim();
+        let fileValue;
+        try {
+            fileValue = readFileSync(filePath, 'utf8').trim();
+        }
+        catch (error) {
+            // A `file:` secret whose target is missing or unreadable is a config
+            // problem (secrets/ is gitignored, so absent after a clone), not a ktx
+            // fault — classify it so it stays out of Error Tracking.
+            throw new KtxExpectedError(`Could not read the secret file referenced in ktx.yaml: ${filePath}`, { cause: error });
+        }
         return fileValue.length > 0 ? fileValue : undefined;
     }
     const trimmed = value.trim();

package/dist/context/daemon/semantic-layer-compute.d.ts

@@ -1,4 +1,20 @@
 import type { ResolvedSemanticLayerSource, SemanticLayerQueryInput } from '../sl/types.js';
+/**
+ * A ktx-daemon compute call failed. `inputRejected` is true when the daemon
+ * refused the request as invalid (a caller-driven outcome) rather than faulting;
+ * callers can promote those to an expected KtxQueryError while letting genuine
+ * daemon crashes reach Error Tracking. `detail` is the daemon's own message,
+ * unwrapped for surfacing to the caller.
+ */
+export declare class KtxDaemonComputeError extends Error {
+    readonly inputRejected: boolean;
+    readonly detail: string;
+    constructor(message: string, options: {
+        inputRejected: boolean;
+        detail: string;
+        cause?: unknown;
+    });
+}
 interface KtxSemanticLayerComputeQueryResult {
     sql: string;
     dialect: string;

package/dist/context/daemon/semantic-layer-compute.js

@@ -2,6 +2,41 @@ import { request as httpRequest } from 'node:http';
 import { request as httpsRequest } from 'node:https';
 import { URL } from 'node:url';
 import { spawn } from 'node:child_process';
+// The daemon signals "the caller sent a well-formed request I refused as
+// invalid" with a distinct subprocess exit code (INPUT_REJECTED_EXIT_CODE in
+// python/ktx-daemon/__main__.py) or HTTP 400. Kept in sync across the boundary.
+const DAEMON_INPUT_REJECTED_EXIT_CODE = 3;
+const DAEMON_INPUT_REJECTED_HTTP_STATUS = 400;
+/**
+ * A ktx-daemon compute call failed. `inputRejected` is true when the daemon
+ * refused the request as invalid (a caller-driven outcome) rather than faulting;
+ * callers can promote those to an expected KtxQueryError while letting genuine
+ * daemon crashes reach Error Tracking. `detail` is the daemon's own message,
+ * unwrapped for surfacing to the caller.
+ */
+export class KtxDaemonComputeError extends Error {
+    inputRejected;
+    detail;
+    constructor(message, options) {
+        super(message, options.cause !== undefined ? { cause: options.cause } : undefined);
+        this.name = 'KtxDaemonComputeError';
+        this.inputRejected = options.inputRejected;
+        this.detail = options.detail;
+    }
+}
+/** The daemon reports HTTP failures as `{ "detail": "…" }`; fall back to the raw body. */
+function daemonHttpErrorDetail(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object' && typeof parsed.detail === 'string') {
+            return parsed.detail;
+        }
+    }
+    catch {
+        // Non-JSON body (e.g. a proxy error page) — surface it verbatim.
+    }
+    return raw;
+}
 function parseJsonObject(raw, subcommand) {
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
@@ -25,7 +60,11 @@ function runProcessJson(options) {
             const stdoutText = Buffer.concat(stdout).toString('utf8').trim();
             const stderrText = Buffer.concat(stderr).toString('utf8').trim();
             if (code !== 0) {
-                reject(new Error(`ktx-daemon ${subcommand} failed: ${stderrText || `exit code ${code}`}`));
+                const detail = stderrText || `exit code ${code}`;
+                reject(new KtxDaemonComputeError(`ktx-daemon ${subcommand} failed: ${detail}`, {
+                    inputRejected: code === DAEMON_INPUT_REJECTED_EXIT_CODE,
+                    detail,
+                }));
                 return;
             }
             try {
@@ -60,7 +99,10 @@ function postJson(baseUrl) {
                 const text = Buffer.concat(chunks).toString('utf8');
                 const statusCode = response.statusCode ?? 0;
                 if (statusCode < 200 || statusCode >= 300) {
-                    reject(new Error(`ktx-daemon HTTP ${path} failed with ${statusCode}: ${text}`));
+                    reject(new KtxDaemonComputeError(`ktx-daemon HTTP ${path} failed with ${statusCode}: ${text}`, {
+                        inputRejected: statusCode === DAEMON_INPUT_REJECTED_HTTP_STATUS,
+                        detail: daemonHttpErrorDetail(text),
+                    }));
                     return;
                 }
                 try {

package/dist/context/ingest/adapters/looker/mapping.d.ts

@@ -10,6 +10,7 @@ declare const LOOKER_DIALECT_TO_CONNECTION_TYPE: {
     readonly sqlite: "SQLITE";
     readonly sqlserver: "SQLSERVER";
     readonly clickhouse: "CLICKHOUSE";
+    readonly awsathena: "ATHENA";
 };
 /** @internal */
 export type LookerWarehouseTargetConnectionType = (typeof LOOKER_DIALECT_TO_CONNECTION_TYPE)[keyof typeof LOOKER_DIALECT_TO_CONNECTION_TYPE];

package/dist/context/ingest/adapters/looker/mapping.js

@@ -1,3 +1,4 @@
+import { warehouseTargetDialect } from '../../../connections/connection-type-dialect.js';
 const LOOKER_DIALECT_TO_CONNECTION_TYPE = {
     bigquery: 'BIGQUERY',
     bigquery_standard_sql: 'BIGQUERY',
@@ -7,15 +8,7 @@ const LOOKER_DIALECT_TO_CONNECTION_TYPE = {
     sqlite: 'SQLITE',
     sqlserver: 'SQLSERVER',
     clickhouse: 'CLICKHOUSE',
-};
-const SQLGLOT_DIALECT_BY_CONNECTION_TYPE = {
-    BIGQUERY: 'bigquery',
-    SNOWFLAKE: 'snowflake',
-    POSTGRESQL: 'postgres',
-    MYSQL: 'mysql',
-    SQLITE: 'sqlite',
-    SQLSERVER: 'tsql',
-    CLICKHOUSE: 'clickhouse',
+    awsathena: 'ATHENA',
 };
 export async function discoverLookerConnections(client) {
     return client.listLookerConnections();
@@ -29,7 +22,7 @@ export function lookerDialectToConnectionType(dialect) {
 }
 /** @internal */
 export function sqlglotDialectForConnectionType(connectionType) {
-    return SQLGLOT_DIALECT_BY_CONNECTION_TYPE[connectionType] ?? null;
+    return warehouseTargetDialect(connectionType);
 }
 /** @internal */
 export function validateLookerWarehouseTarget(connectionType) {

package/dist/context/ingest/adapters/looker/types.d.ts

@@ -12,27 +12,18 @@ export declare const lookerPullConfigSchema: z.ZodObject<{
     lookUpdatedSince: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
     connectionMappings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     connectionTypes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEnum<{
-        PLAIN: "PLAIN";
+        POSTGRESQL: "POSTGRESQL";
+        SQLITE: "SQLITE";
+        DUCKDB: "DUCKDB";
+        SQLSERVER: "SQLSERVER";
         BIGQUERY: "BIGQUERY";
         SNOWFLAKE: "SNOWFLAKE";
-        MYSQL: "MYSQL";
-        SQLSERVER: "SQLSERVER";
-        SQLITE: "SQLITE";
-        CLICKHOUSE: "CLICKHOUSE";
-        POSTGRESQL: "POSTGRESQL";
-        CENTRALREACH: "CENTRALREACH";
-        EPIC: "EPIC";
-        CERNER: "CERNER";
         ATHENA: "ATHENA";
-        QUICKBOOKS: "QUICKBOOKS";
-        WORKDAY: "WORKDAY";
-        REST: "REST";
-        S3: "S3";
-        SLACK: "SLACK";
         METABASE: "METABASE";
         LOOKER: "LOOKER";
         NOTION: "NOTION";
-        BETTERSTACK: "BETTERSTACK";
+        MYSQL: "MYSQL";
+        CLICKHOUSE: "CLICKHOUSE";
     }>>>;
     parsedTargetTables: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
         ok: z.ZodLiteral<true>;

package/dist/context/ingest/adapters/metabase/mapping.d.ts

@@ -7,6 +7,7 @@ export declare const METABASE_ENGINE_TO_CONNECTION_TYPE: {
     readonly snowflake: "SNOWFLAKE";
     readonly sqlserver: "SQLSERVER";
     readonly mysql: "MYSQL";
+    readonly athena: "ATHENA";
 };
 export interface DiscoveredMetabaseDatabase {
     id: number;

package/dist/context/ingest/adapters/metabase/mapping.js

@@ -6,6 +6,7 @@ export const METABASE_ENGINE_TO_CONNECTION_TYPE = {
     snowflake: 'SNOWFLAKE',
     sqlserver: 'SQLSERVER',
     mysql: 'MYSQL',
+    athena: 'ATHENA',
 };
 function isRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);

package/dist/context/mcp/context-tools.js

@@ -171,6 +171,7 @@ const connectionListOutputSchema = z.object({
         connectionType: z.string(),
         members: z.array(z.string()).optional(),
         hint: z.string().optional(),
+        queryPolicy: z.literal('semantic-layer-only').optional(),
     })),
 });
 const wikiSearchOutputSchema = z.object({

package/dist/context/mcp/local-project-ports.d.ts

@@ -1,7 +1,7 @@
 import type { KtxSqlQueryExecutorPort } from '../../context/connections/query-executor.js';
 import type { KtxProjectConnectionConfig } from '../../context/project/config.js';
 import type { KtxEmbeddingPort } from '../../context/core/embedding.js';
-import type { KtxSemanticLayerComputePort } from '../../context/daemon/semantic-layer-compute.js';
+import { type KtxSemanticLayerComputePort } from '../../context/daemon/semantic-layer-compute.js';
 import type { KtxLocalProject } from '../../context/project/project.js';
 import type { LocalScanMcpOptions } from '../../context/scan/local-scan.js';
 import type { SqlAnalysisPort } from '../../context/sql-analysis/ports.js';

package/dist/context/mcp/local-project-ports.js

@@ -1,11 +1,11 @@
 import { KtxExpectedError, KtxQueryError, isNativeProgrammingFault } from '../../errors.js';
 import { isDatabaseDriver, normalizeConnectionDriver } from '../../connection-drivers.js';
 import { sqlDialectNotes } from '../../context/sql-analysis/dialect-notes.js';
-import { executeProjectReadOnlySql } from '../../context/connections/project-sql-executor.js';
-import { FEDERATED_CONNECTION_ID, federatedConnectionListing } from '../../context/connections/federation.js';
-import { assertSqlQueryableConnection } from '../../context/connections/dialects.js';
-import { resolveConfiguredConnection } from '../../context/connections/resolve-connection.js';
+import { executeProjectRawSql } from '../../context/connections/project-sql-executor.js';
+import { federatedConnectionListing } from '../../context/connections/federation.js';
+import { projectAllowsRawSql, restrictedFederatedMemberIds } from '../../context/connections/query-policy.js';
 import { localConnectionInfoFromConfig, } from '../../context/connections/local-warehouse-descriptor.js';
+import { KtxDaemonComputeError } from '../../context/daemon/semantic-layer-compute.js';
 import { createKtxEntityDetailsService } from '../../context/scan/entity-details.js';
 import { createKtxDiscoverDataService } from '../../context/search/discover.js';
 import { sqlAnalysisDialectForDriver } from '../../context/sql-analysis/dialect.js';
@@ -15,8 +15,26 @@ import { readLocalSlSource } from '../../context/sl/local-sl.js';
 import { assertSafeConnectionId } from '../../context/sl/source-files.js';
 import { assertConfiguredConnectionId } from '../../context/connections/configured-connections.js';
 import { readLocalKnowledgePage, searchLocalKnowledgePages } from '../wiki/local-knowledge.js';
+/**
+ * Reclassify a query-path failure. Warehouse/driver rejections and daemon
+ * input-rejections are caller-driven outcomes (KtxQueryError, kept out of Error
+ * Tracking while preserving the underlying diagnostics); native JS faults, daemon
+ * crashes, and already-expected errors propagate unchanged so genuine ktx bugs
+ * still reach Error Tracking.
+ */
+function throwClassifiedQueryError(error) {
+    if (error instanceof KtxDaemonComputeError) {
+        if (error.inputRejected) {
+            throw new KtxQueryError(error.detail, { cause: error });
+        }
+        throw error;
+    }
+    if (isNativeProgrammingFault(error) || error instanceof KtxExpectedError) {
+        throw error;
+    }
+    throw new KtxQueryError(error instanceof Error ? error.message : String(error), { cause: error });
+}
 async function executeValidatedReadOnlySql(project, options, input, onProgress) {
-    await onProgress?.({ progress: 0, message: 'Validating SQL' });
     if (!options.sqlAnalysis) {
         throw new Error('sql_execution requires parser-backed SQL validation.');
     }
@@ -24,50 +42,22 @@ async function executeValidatedReadOnlySql(project, options, input, onProgress)
     if (!createConnector) {
         throw new Error('sql_execution requires a local scan connector factory.');
     }
-    const isFederated = input.connectionId === FEDERATED_CONNECTION_ID;
-    const connectionId = isFederated ? input.connectionId : assertSafeConnectionId(input.connectionId);
-    const connection = isFederated ? undefined : resolveConfiguredConnection(project.config, connectionId);
-    if (!isFederated) {
-        assertSqlQueryableConnection(connectionId, connection.driver);
-    }
-    const dialect = sqlAnalysisDialectForDriver(isFederated ? 'duckdb' : connection.driver);
-    const validation = await options.sqlAnalysis.validateReadOnly(input.sql, dialect);
-    if (!validation.ok) {
-        // A read-only guard rejecting the agent's SQL is an expected outcome, not a
-        // ktx fault: classify it so reportException keeps it out of Error Tracking.
-        throw new KtxQueryError(validation.error ?? 'SQL is not read-only.');
-    }
-    await onProgress?.({ progress: 0.3, message: 'Executing' });
-    const result = await executeProjectReadOnlySql({
+    const result = await executeProjectRawSql({
         project,
-        input: {
-            connectionId,
-            projectDir: project.projectDir,
-            connection,
-            sql: input.sql,
-            maxRows: input.maxRows,
-        },
+        connectionId: input.connectionId,
+        sql: input.sql,
+        maxRows: input.maxRows,
+        sqlAnalysis: options.sqlAnalysis,
         createConnector,
         runId: 'mcp-sql-execution',
-    }).catch((error) => {
-        // A warehouse/driver rejection (e.g. the agent's SQL failed to compile) is a
-        // surfaced operational outcome, not a ktx fault: mark it expected while
-        // preserving the warehouse's own diagnostics. A native JS error (TypeError,
-        // etc.) signals a bug in connector code — let it propagate unchanged so Error
-        // Tracking still sees it.
-        if (isNativeProgrammingFault(error) || error instanceof KtxExpectedError) {
-            throw error;
-        }
-        throw new KtxQueryError(error instanceof Error ? error.message : String(error), { cause: error });
+        onProgress,
     });
-    const response = {
+    return {
         headers: result.headers,
         ...(result.headerTypes ? { headerTypes: result.headerTypes } : {}),
         rows: result.rows,
         rowCount: result.rowCount ?? result.rows.length,
     };
-    await onProgress?.({ progress: 1, message: `Fetched ${response.rowCount} rows` });
-    return response;
 }
 /** @internal Resolves a connection's dialect SQL notes; throws KtxExpectedError for an unknown or non-SQL-warehouse connection. */
 export function resolveDialectNotesForConnection(connectionId, connection) {
@@ -92,12 +82,16 @@ export function createLocalProjectMcpContextPorts(project, options) {
                     .sort((a, b) => a.id.localeCompare(b.id));
                 const federated = federatedConnectionListing(project.config.connections, project.projectDir);
                 if (federated) {
+                    const restricted = restrictedFederatedMemberIds(project.config, project.projectDir);
                     configured.push({
                         id: federated.id,
                         name: federated.id,
                         connectionType: 'DUCKDB',
                         members: federated.members,
-                        hint: federated.hint,
+                        hint: restricted.length > 0
+                            ? `Federated SQL is disabled: member connection(s) ${restricted.join(', ')} have query_policy: semantic-layer-only.`
+                            : federated.hint,
+                        ...(restricted.length > 0 ? { queryPolicy: 'semantic-layer-only' } : {}),
                     });
                 }
                 return configured;
@@ -158,15 +152,20 @@ export function createLocalProjectMcpContextPorts(project, options) {
                 if (!options.semanticLayerCompute) {
                     throw new Error('sl_query requires a semantic-layer query adapter.');
                 }
-                return compileLocalSlQuery(project, {
-                    connectionId: input.connectionId,
-                    query: input.query,
-                    compute: options.semanticLayerCompute,
-                    execute: Boolean(options.queryExecutor),
-                    maxRows: input.query.limit,
-                    queryExecutor: options.queryExecutor,
-                    onProgress: executionOptions?.onProgress,
-                });
+                try {
+                    return await compileLocalSlQuery(project, {
+                        connectionId: input.connectionId,
+                        query: input.query,
+                        compute: options.semanticLayerCompute,
+                        execute: Boolean(options.queryExecutor),
+                        maxRows: input.query.limit,
+                        queryExecutor: options.queryExecutor,
+                        onProgress: executionOptions?.onProgress,
+                    });
+                }
+                catch (error) {
+                    throwClassifiedQueryError(error);
+                }
             },
         },
         entityDetails: {
@@ -191,7 +190,10 @@ export function createLocalProjectMcpContextPorts(project, options) {
             },
         },
     };
-    if (options.sqlAnalysis && options.localScan?.createConnector) {
+    // Register sql_execution only when some connection can accept raw SQL; in
+    // mixed projects the tool stays and executeProjectRawSql rejects restricted
+    // connection ids at request time.
+    if (options.sqlAnalysis && options.localScan?.createConnector && projectAllowsRawSql(project.config)) {
         ports.sqlExecution = {
             async execute(input, executionOptions) {
                 return executeValidatedReadOnlySql(project, options, input, executionOptions?.onProgress);

package/dist/context/project/config.d.ts

@@ -109,36 +109,82 @@ declare const connectionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     url: z.ZodOptional<z.ZodString>;
     enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
     query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+    query_policy: z.ZodOptional<z.ZodEnum<{
+        "read-only-sql": "read-only-sql";
+        "semantic-layer-only": "semantic-layer-only";
+    }>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"mysql">;
     url: z.ZodOptional<z.ZodString>;
     enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
     query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+    query_policy: z.ZodOptional<z.ZodEnum<{
+        "read-only-sql": "read-only-sql";
+        "semantic-layer-only": "semantic-layer-only";
+    }>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"snowflake">;
     url: z.ZodOptional<z.ZodString>;
     enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
     query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+    query_policy: z.ZodOptional<z.ZodEnum<{
+        "read-only-sql": "read-only-sql";
+        "semantic-layer-only": "semantic-layer-only";
+    }>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"bigquery">;
     url: z.ZodOptional<z.ZodString>;
     enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
     query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+    query_policy: z.ZodOptional<z.ZodEnum<{
+        "read-only-sql": "read-only-sql";
+        "semantic-layer-only": "semantic-layer-only";
+    }>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"sqlite">;
     url: z.ZodOptional<z.ZodString>;
     enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
     query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+    query_policy: z.ZodOptional<z.ZodEnum<{
+        "read-only-sql": "read-only-sql";
+        "semantic-layer-only": "semantic-layer-only";
+    }>>;
+}, z.core.$loose>, z.ZodObject<{
+    driver: z.ZodLiteral<"duckdb">;
+    url: z.ZodOptional<z.ZodString>;
+    enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+    query_policy: z.ZodOptional<z.ZodEnum<{
+        "read-only-sql": "read-only-sql";
+        "semantic-layer-only": "semantic-layer-only";
+    }>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"clickhouse">;
     url: z.ZodOptional<z.ZodString>;
     enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
     query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+    query_policy: z.ZodOptional<z.ZodEnum<{
+        "read-only-sql": "read-only-sql";
+        "semantic-layer-only": "semantic-layer-only";
+    }>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"sqlserver">;
     url: z.ZodOptional<z.ZodString>;
     enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
     query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+    query_policy: z.ZodOptional<z.ZodEnum<{
+        "read-only-sql": "read-only-sql";
+        "semantic-layer-only": "semantic-layer-only";
+    }>>;
+}, z.core.$loose>, z.ZodObject<{
+    driver: z.ZodLiteral<"athena">;
+    url: z.ZodOptional<z.ZodString>;
+    enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+    query_policy: z.ZodOptional<z.ZodEnum<{
+        "read-only-sql": "read-only-sql";
+        "semantic-layer-only": "semantic-layer-only";
+    }>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"mongodb">;
     url: z.ZodString;
@@ -248,36 +294,82 @@ declare const ktxProjectConfigSchema: z.ZodObject<{
         url: z.ZodOptional<z.ZodString>;
         enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
         query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+        query_policy: z.ZodOptional<z.ZodEnum<{
+            "read-only-sql": "read-only-sql";
+            "semantic-layer-only": "semantic-layer-only";
+        }>>;
     }, z.core.$loose>, z.ZodObject<{
         driver: z.ZodLiteral<"mysql">;
         url: z.ZodOptional<z.ZodString>;
         enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
         query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+        query_policy: z.ZodOptional<z.ZodEnum<{
+            "read-only-sql": "read-only-sql";
+            "semantic-layer-only": "semantic-layer-only";
+        }>>;
     }, z.core.$loose>, z.ZodObject<{
         driver: z.ZodLiteral<"snowflake">;
         url: z.ZodOptional<z.ZodString>;
         enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
         query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+        query_policy: z.ZodOptional<z.ZodEnum<{
+            "read-only-sql": "read-only-sql";
+            "semantic-layer-only": "semantic-layer-only";
+        }>>;
     }, z.core.$loose>, z.ZodObject<{
         driver: z.ZodLiteral<"bigquery">;
         url: z.ZodOptional<z.ZodString>;
         enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
         query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+        query_policy: z.ZodOptional<z.ZodEnum<{
+            "read-only-sql": "read-only-sql";
+            "semantic-layer-only": "semantic-layer-only";
+        }>>;
     }, z.core.$loose>, z.ZodObject<{
         driver: z.ZodLiteral<"sqlite">;
         url: z.ZodOptional<z.ZodString>;
         enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
         query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+        query_policy: z.ZodOptional<z.ZodEnum<{
+            "read-only-sql": "read-only-sql";
+            "semantic-layer-only": "semantic-layer-only";
+        }>>;
+    }, z.core.$loose>, z.ZodObject<{
+        driver: z.ZodLiteral<"duckdb">;
+        url: z.ZodOptional<z.ZodString>;
+        enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+        query_policy: z.ZodOptional<z.ZodEnum<{
+            "read-only-sql": "read-only-sql";
+            "semantic-layer-only": "semantic-layer-only";
+        }>>;
     }, z.core.$loose>, z.ZodObject<{
         driver: z.ZodLiteral<"clickhouse">;
         url: z.ZodOptional<z.ZodString>;
         enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
         query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+        query_policy: z.ZodOptional<z.ZodEnum<{
+            "read-only-sql": "read-only-sql";
+            "semantic-layer-only": "semantic-layer-only";
+        }>>;
     }, z.core.$loose>, z.ZodObject<{
         driver: z.ZodLiteral<"sqlserver">;
         url: z.ZodOptional<z.ZodString>;
         enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
         query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+        query_policy: z.ZodOptional<z.ZodEnum<{
+            "read-only-sql": "read-only-sql";
+            "semantic-layer-only": "semantic-layer-only";
+        }>>;
+    }, z.core.$loose>, z.ZodObject<{
+        driver: z.ZodLiteral<"athena">;
+        url: z.ZodOptional<z.ZodString>;
+        enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+        query_policy: z.ZodOptional<z.ZodEnum<{
+            "read-only-sql": "read-only-sql";
+            "semantic-layer-only": "semantic-layer-only";
+        }>>;
     }, z.core.$loose>, z.ZodObject<{
         driver: z.ZodLiteral<"mongodb">;
         url: z.ZodString;

package/dist/context/project/driver-schemas.d.ts

@@ -4,36 +4,82 @@ export declare const connectionConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
     url: z.ZodOptional<z.ZodString>;
     enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
     query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+    query_policy: z.ZodOptional<z.ZodEnum<{
+        "read-only-sql": "read-only-sql";
+        "semantic-layer-only": "semantic-layer-only";
+    }>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"mysql">;
     url: z.ZodOptional<z.ZodString>;
     enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
     query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+    query_policy: z.ZodOptional<z.ZodEnum<{
+        "read-only-sql": "read-only-sql";
+        "semantic-layer-only": "semantic-layer-only";
+    }>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"snowflake">;
     url: z.ZodOptional<z.ZodString>;
     enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
     query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+    query_policy: z.ZodOptional<z.ZodEnum<{
+        "read-only-sql": "read-only-sql";
+        "semantic-layer-only": "semantic-layer-only";
+    }>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"bigquery">;
     url: z.ZodOptional<z.ZodString>;
     enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
     query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+    query_policy: z.ZodOptional<z.ZodEnum<{
+        "read-only-sql": "read-only-sql";
+        "semantic-layer-only": "semantic-layer-only";
+    }>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"sqlite">;
     url: z.ZodOptional<z.ZodString>;
     enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
     query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+    query_policy: z.ZodOptional<z.ZodEnum<{
+        "read-only-sql": "read-only-sql";
+        "semantic-layer-only": "semantic-layer-only";
+    }>>;
+}, z.core.$loose>, z.ZodObject<{
+    driver: z.ZodLiteral<"duckdb">;
+    url: z.ZodOptional<z.ZodString>;
+    enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+    query_policy: z.ZodOptional<z.ZodEnum<{
+        "read-only-sql": "read-only-sql";
+        "semantic-layer-only": "semantic-layer-only";
+    }>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"clickhouse">;
     url: z.ZodOptional<z.ZodString>;
     enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
     query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+    query_policy: z.ZodOptional<z.ZodEnum<{
+        "read-only-sql": "read-only-sql";
+        "semantic-layer-only": "semantic-layer-only";
+    }>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"sqlserver">;
     url: z.ZodOptional<z.ZodString>;
     enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
     query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+    query_policy: z.ZodOptional<z.ZodEnum<{
+        "read-only-sql": "read-only-sql";
+        "semantic-layer-only": "semantic-layer-only";
+    }>>;
+}, z.core.$loose>, z.ZodObject<{
+    driver: z.ZodLiteral<"athena">;
+    url: z.ZodOptional<z.ZodString>;
+    enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    query_timeout_ms: z.ZodOptional<z.ZodNumber>;
+    query_policy: z.ZodOptional<z.ZodEnum<{
+        "read-only-sql": "read-only-sql";
+        "semantic-layer-only": "semantic-layer-only";
+    }>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"mongodb">;
     url: z.ZodString;