@querypanel/node-sdk 1.0.29 → 1.0.31

package/dist/index.js

@@ -1,12 +1,5 @@
-// src/index.ts
-import { createHash, randomUUID } from "crypto";
-import { importPKCS8, SignJWT } from "jose";
-
 // src/utils/clickhouse.ts
 var WRAPPER_REGEX = /^(Nullable|LowCardinality|SimpleAggregateFunction)\((.+)\)$/i;
-function isNullableType(type) {
-  return /Nullable\s*\(/i.test(type);
-}
 function unwrapTypeModifiers(type) {
   let current = type.trim();
   let match = WRAPPER_REGEX.exec(current);
@@ -20,26 +13,6 @@ function unwrapTypeModifiers(type) {
   }
   return current;
 }
-function extractPrecisionScale(type) {
-  const unwrapped = unwrapTypeModifiers(type);
-  const decimalMatch = unwrapped.match(/Decimal(?:\d+)?\((\d+)\s*,\s*(\d+)\)/i);
-  if (!decimalMatch) return {};
-  const precision = decimalMatch[1];
-  const scale = decimalMatch[2];
-  if (!precision || !scale) return {};
-  return {
-    precision: Number.parseInt(precision, 10),
-    scale: Number.parseInt(scale, 10)
-  };
-}
-function extractFixedStringLength(type) {
-  const unwrapped = unwrapTypeModifiers(type);
-  const match = unwrapped.match(/^(?:FixedString|StringFixed)\((\d+)\)$/i);
-  if (!match) return void 0;
-  const length = match[1];
-  if (!length) return void 0;
-  return Number.parseInt(length, 10);
-}
 function parseKeyExpression(expression) {
   if (!expression) return [];
   let value = expression.trim();
@@ -127,6 +100,10 @@ var ClickHouseAdapter = class {
   getDialect() {
     return "clickhouse";
   }
+  /**
+   * Simplified introspection: only collect table/column metadata for IngestRequest
+   * No indexes, constraints, or statistics
+   */
   async introspect(options) {
     const tablesToIntrospect = options?.tables ? normalizeTableFilter(options.tables) : this.allowedTables;
     const allowTables = tablesToIntrospect ?? [];
@@ -139,7 +116,7 @@ var ClickHouseAdapter = class {
     }
     const filterClause = hasFilter ? " AND name IN {tables:Array(String)}" : "";
     const tables = await this.query(
-      `SELECT name, engine, comment, total_rows, total_bytes, primary_key, sorting_key
+      `SELECT name, engine, comment, primary_key
        FROM system.tables
        WHERE database = {db:String}${filterClause}
        ORDER BY name`,
@@ -147,7 +124,7 @@ var ClickHouseAdapter = class {
     );
     const columnFilterClause = hasFilter ? " AND table IN {tables:Array(String)}" : "";
     const columns = await this.query(
-      `SELECT table, name, type, position, default_kind, default_expression, comment, is_in_primary_key
+      `SELECT table, name, type, position, comment, is_in_primary_key
        FROM system.columns
        WHERE database = {db:String}${columnFilterClause}
        ORDER BY table, position`,
@@ -162,44 +139,19 @@ var ClickHouseAdapter = class {
     const tableSchemas = tables.map((table) => {
       const tableColumns = columnsByTable.get(table.name) ?? [];
       const primaryKeyColumns = parseKeyExpression(table.primary_key);
-      const totalRows = toNumber(table.total_rows);
-      const totalBytes = toNumber(table.total_bytes);
       for (const column of tableColumns) {
         column.isPrimaryKey = column.isPrimaryKey || primaryKeyColumns.includes(column.name);
       }
-      const indexes = primaryKeyColumns.length ? [
-        {
-          name: "primary_key",
-          columns: primaryKeyColumns,
-          unique: true,
-          type: "PRIMARY KEY",
-          ...table.primary_key ? { definition: table.primary_key } : {}
-        }
-      ] : [];
-      const constraints = primaryKeyColumns.length ? [
-        {
-          name: "primary_key",
-          type: "PRIMARY KEY",
-          columns: primaryKeyColumns
-        }
-      ] : [];
       const base = {
         name: table.name,
         schema: this.databaseName,
         type: asTableType(table.engine),
-        engine: table.engine,
-        columns: tableColumns,
-        indexes,
-        constraints
+        columns: tableColumns
       };
       const comment = sanitize(table.comment);
       if (comment !== void 0) {
         base.comment = comment;
       }
-      const statistics = buildTableStatistics(totalRows, totalBytes);
-      if (statistics) {
-        base.statistics = statistics;
-      }
       return base;
     });
     return {
@@ -211,10 +163,6 @@ var ClickHouseAdapter = class {
       introspectedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
   }
-  /**
-   * Validate that the SQL query only references allowed tables.
-   * This is a basic validation that extracts table-like patterns from the query.
-   */
   validateQueryTables(sql) {
     if (!this.allowedTables || this.allowedTables.length === 0) {
       return;
@@ -292,29 +240,15 @@ function normalizeTableFilter(tables) {
   return normalized;
 }
 function transformColumnRow(row) {
-  const nullable = isNullableType(row.type);
   const unwrappedType = unwrapTypeModifiers(row.type);
-  const { precision, scale } = extractPrecisionScale(row.type);
-  const maxLength = extractFixedStringLength(row.type);
   const column = {
     name: row.name,
     type: unwrappedType,
     rawType: row.type,
-    nullable,
-    isPrimaryKey: Boolean(toNumber(row.is_in_primary_key)),
-    isForeignKey: false
+    isPrimaryKey: Boolean(toNumber(row.is_in_primary_key))
   };
-  const defaultKind = sanitize(row.default_kind);
-  if (defaultKind !== void 0) column.defaultKind = defaultKind;
-  const defaultExpression = sanitize(row.default_expression);
-  if (defaultExpression !== void 0) {
-    column.defaultExpression = defaultExpression;
-  }
   const comment = sanitize(row.comment);
   if (comment !== void 0) column.comment = comment;
-  if (maxLength !== void 0) column.maxLength = maxLength;
-  if (precision !== void 0) column.precision = precision;
-  if (scale !== void 0) column.scale = scale;
   return column;
 }
 function asTableType(engine) {
@@ -326,13 +260,6 @@ function asTableType(engine) {
   }
   return "table";
 }
-function buildTableStatistics(totalRows, totalBytes) {
-  if (totalRows === void 0 && totalBytes === void 0) return void 0;
-  const stats = {};
-  if (totalRows !== void 0) stats.totalRows = totalRows;
-  if (totalBytes !== void 0) stats.totalBytes = totalBytes;
-  return stats;
-}
 function sanitize(value) {
   if (value === null || value === void 0) return void 0;
   const trimmed = String(value).trim();
@@ -375,10 +302,6 @@ var PostgresAdapter = class {
     const fields = result.fields.map((f) => f.name);
     return { fields, rows: result.rows };
   }
-  /**
-   * Validate that the SQL query only references allowed tables.
-   * This is a basic validation that extracts table-like patterns from the query.
-   */
   validateQueryTables(sql) {
     if (!this.allowedTables || this.allowedTables.length === 0) {
       return;
@@ -404,11 +327,6 @@ var PostgresAdapter = class {
   /**
    * Convert named params to positional array for PostgreSQL
    * PostgreSQL expects $1, $2, $3 in SQL and an array of values [val1, val2, val3]
-   *
-   * Supports two formats:
-   * 1. Numeric keys: { '1': 'value1', '2': 'value2' } - maps directly to $1, $2
-   * 2. Named keys: { 'tenant_id': 'value' } - values extracted in alphabetical order
-   * 3. Mixed: { '1': 'value1', 'tenant_id': 'value' } - numeric keys first, then named keys
    */
   convertNamedToPositionalParams(params) {
     const numericKeys = Object.keys(params).filter((k) => /^\d+$/.test(k)).map((k) => Number.parseInt(k, 10)).sort((a, b) => a - b);
@@ -441,6 +359,10 @@ var PostgresAdapter = class {
   getDialect() {
     return "postgres";
   }
+  /**
+   * Simplified introspection: only collect table/column metadata for IngestRequest
+   * No indexes, constraints, or statistics
+   */
   async introspect(options) {
     const tablesToIntrospect = options?.tables ? normalizeTableFilter2(options.tables, this.defaultSchema) : this.allowedTables;
     const normalizedTables = tablesToIntrospect ?? [];
@@ -452,39 +374,20 @@ var PostgresAdapter = class {
       buildColumnsQuery(normalizedTables)
     );
     const columnRows = columnsResult.rows;
-    const constraintsResult = await this.clientFn(
-      buildConstraintsQuery(normalizedTables)
-    );
-    const constraintRows = constraintsResult.rows;
-    const indexesResult = await this.clientFn(
-      buildIndexesQuery(normalizedTables)
-    );
-    const indexRows = indexesResult.rows;
     const tablesByKey = /* @__PURE__ */ new Map();
-    const columnsByKey = /* @__PURE__ */ new Map();
     for (const row of tableRows) {
       const key = tableKey(row.schema_name, row.table_name);
-      const statistics = buildTableStatistics2(
-        toNumber2(row.total_rows),
-        toNumber2(row.total_bytes)
-      );
       const table = {
         name: row.table_name,
         schema: row.schema_name,
         type: asTableType2(row.table_type),
-        columns: [],
-        indexes: [],
-        constraints: []
+        columns: []
       };
       const comment = sanitize2(row.comment);
       if (comment !== void 0) {
         table.comment = comment;
       }
-      if (statistics) {
-        table.statistics = statistics;
-      }
       tablesByKey.set(key, table);
-      columnsByKey.set(key, /* @__PURE__ */ new Map());
     }
     for (const row of columnRows) {
       const key = tableKey(row.table_schema, row.table_name);
@@ -493,80 +396,13 @@ var PostgresAdapter = class {
       const column = {
         name: row.column_name,
         type: row.data_type,
-        nullable: row.is_nullable.toUpperCase() === "YES",
-        isPrimaryKey: false,
-        isForeignKey: false
+        isPrimaryKey: row.is_primary_key
       };
       const rawType = row.udt_name ?? void 0;
       if (rawType !== void 0) column.rawType = rawType;
-      const defaultExpression = sanitize2(row.column_default);
-      if (defaultExpression !== void 0)
-        column.defaultExpression = defaultExpression;
       const comment = sanitize2(row.description);
       if (comment !== void 0) column.comment = comment;
-      const maxLength = row.character_maximum_length ?? void 0;
-      if (maxLength !== void 0) column.maxLength = maxLength;
-      const precision = row.numeric_precision ?? void 0;
-      if (precision !== void 0) column.precision = precision;
-      const scale = row.numeric_scale ?? void 0;
-      if (scale !== void 0) column.scale = scale;
       table.columns.push(column);
-      columnsByKey.get(key)?.set(row.column_name, column);
-    }
-    const constraintGroups = groupConstraints(constraintRows);
-    for (const group of constraintGroups) {
-      const key = tableKey(group.table_schema, group.table_name);
-      const table = tablesByKey.get(key);
-      if (!table) continue;
-      const constraint = {
-        name: group.constraint_name,
-        type: group.constraint_type,
-        columns: [...group.columns]
-      };
-      if (group.type === "FOREIGN KEY") {
-        if (group.foreign_table_name) {
-          const referencedTable = group.foreign_table_schema ? `${group.foreign_table_schema}.${group.foreign_table_name}` : group.foreign_table_name;
-          constraint.referencedTable = referencedTable;
-        }
-        if (group.foreign_columns.length) {
-          constraint.referencedColumns = [...group.foreign_columns];
-        }
-      }
-      table.constraints.push(constraint);
-      for (let index = 0; index < group.columns.length; index += 1) {
-        const columnName = group.columns[index];
-        if (!columnName) continue;
-        const column = columnsByKey.get(key)?.get(columnName);
-        if (!column) continue;
-        if (group.type === "PRIMARY KEY") {
-          column.isPrimaryKey = true;
-        }
-        if (group.type === "FOREIGN KEY") {
-          column.isForeignKey = true;
-          if (group.foreign_table_name) {
-            column.foreignKeyTable = group.foreign_table_schema ? `${group.foreign_table_schema}.${group.foreign_table_name}` : group.foreign_table_name;
-          }
-          const referencedColumn = group.foreign_columns[index];
-          if (referencedColumn) {
-            column.foreignKeyColumn = referencedColumn;
-          }
-        }
-      }
-    }
-    for (const row of indexRows) {
-      const key = tableKey(row.schema_name, row.table_name);
-      const table = tablesByKey.get(key);
-      if (!table) continue;
-      const columns = coerceStringArray(row.column_names).map((c) => c.trim()).filter(Boolean);
-      const index = {
-        name: row.index_name,
-        columns,
-        unique: Boolean(row.indisunique),
-        type: columns.length === 1 ? "INDEX" : "COMPOSITE INDEX"
-      };
-      const definition = sanitize2(row.definition);
-      if (definition !== void 0) index.definition = definition;
-      table.indexes.push(index);
     }
     const tables = Array.from(tablesByKey.values()).sort((a, b) => {
       if (a.schema === b.schema) {
@@ -584,36 +420,6 @@ var PostgresAdapter = class {
     };
   }
 };
-function groupConstraints(rows) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const key = `${row.table_schema}.${row.table_name}.${row.constraint_name}`;
-    let group = groups.get(key);
-    if (!group) {
-      group = {
-        table_schema: row.table_schema,
-        table_name: row.table_name,
-        constraint_name: row.constraint_name,
-        constraint_type: row.constraint_type,
-        columns: [],
-        foreign_columns: [],
-        type: row.constraint_type
-      };
-      groups.set(key, group);
-    }
-    if (row.column_name) {
-      group.columns.push(row.column_name);
-    }
-    if (row.constraint_type === "FOREIGN KEY") {
-      group.foreign_table_schema = row.foreign_table_schema;
-      group.foreign_table_name = row.foreign_table_name;
-      if (row.foreign_column_name) {
-        group.foreign_columns.push(row.foreign_column_name);
-      }
-    }
-  }
-  return Array.from(groups.values());
-}
 function normalizeTableFilter2(tables, defaultSchema) {
   if (!tables?.length) return [];
   const normalized = [];
@@ -646,9 +452,7 @@ function buildTablesQuery(tables) {
       WHEN 'm' THEN 'materialized_view'
       ELSE c.relkind::text
     END AS table_type,
-    obj_description(c.oid) AS comment,
-    c.reltuples AS total_rows,
-    pg_total_relation_size(c.oid) AS total_bytes
+    obj_description(c.oid) AS comment
   FROM pg_class c
   JOIN pg_namespace n ON n.oid = c.relnamespace
   WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
@@ -668,13 +472,18 @@ function buildColumnsQuery(tables) {
     cols.column_name,
     cols.data_type,
     cols.udt_name,
-    cols.is_nullable,
-    cols.column_default,
-    cols.character_maximum_length,
-    cols.numeric_precision,
-    cols.numeric_scale,
-    cols.ordinal_position,
-    pgd.description
+    pgd.description,
+    EXISTS(
+      SELECT 1
+      FROM information_schema.table_constraints tc
+      JOIN information_schema.key_column_usage kcu
+        ON tc.constraint_name = kcu.constraint_name
+       AND tc.table_schema = kcu.table_schema
+      WHERE tc.constraint_type = 'PRIMARY KEY'
+        AND tc.table_schema = cols.table_schema
+        AND tc.table_name = cols.table_name
+        AND kcu.column_name = cols.column_name
+    ) AS is_primary_key
   FROM information_schema.columns cols
   LEFT JOIN pg_catalog.pg_class c
     ON c.relname = cols.table_name
@@ -689,50 +498,6 @@ function buildColumnsQuery(tables) {
     ${filter}
   ORDER BY cols.table_schema, cols.table_name, cols.ordinal_position;`;
 }
-function buildConstraintsQuery(tables) {
-  const filter = buildFilterClause(tables, "tc.table_schema", "tc.table_name");
-  return `SELECT
-    tc.table_schema,
-    tc.table_name,
-    tc.constraint_name,
-    tc.constraint_type,
-    kcu.column_name,
-    ccu.table_schema AS foreign_table_schema,
-    ccu.table_name AS foreign_table_name,
-    ccu.column_name AS foreign_column_name
-  FROM information_schema.table_constraints tc
-  LEFT JOIN information_schema.key_column_usage kcu
-    ON tc.constraint_name = kcu.constraint_name
-   AND tc.table_schema = kcu.table_schema
-  LEFT JOIN information_schema.constraint_column_usage ccu
-    ON ccu.constraint_name = tc.constraint_name
-   AND ccu.table_schema = tc.table_schema
-  WHERE tc.constraint_type IN ('PRIMARY KEY', 'UNIQUE', 'FOREIGN KEY')
-    AND tc.table_schema NOT IN ('pg_catalog', 'information_schema')
-    ${filter}
-  ORDER BY tc.table_schema, tc.table_name, tc.constraint_name, kcu.ordinal_position;`;
-}
-function buildIndexesQuery(tables) {
-  const filter = buildFilterClause(tables, "n.nspname", "c.relname");
-  return `SELECT
-    n.nspname AS schema_name,
-    c.relname AS table_name,
-    ci.relname AS index_name,
-    idx.indisunique,
-    array_remove(
-      array_agg(pg_get_indexdef(idx.indexrelid, g.k, true) ORDER BY g.k),
-      NULL
-    ) AS column_names,
-    pg_get_indexdef(idx.indexrelid) AS definition
-  FROM pg_class c
-  JOIN pg_namespace n ON n.oid = c.relnamespace
-  JOIN pg_index idx ON idx.indrelid = c.oid
-  JOIN pg_class ci ON ci.oid = idx.indexrelid
-  JOIN LATERAL generate_subscripts(idx.indkey, 1) AS g(k) ON true
-  WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
-    ${filter}
-  GROUP BY n.nspname, c.relname, ci.relname, idx.indisunique, idx.indexrelid;`;
-}
 function buildFilterClause(tables, schemaExpr, tableExpr) {
   if (!tables.length) return "";
   const clauses = tables.map(({ schema, table }) => {
@@ -753,50 +518,21 @@ function asTableType2(value) {
   }
   return "table";
 }
-function buildTableStatistics2(totalRows, totalBytes) {
-  if (totalRows === void 0 && totalBytes === void 0) return void 0;
-  const stats = {};
-  if (totalRows !== void 0) stats.totalRows = totalRows;
-  if (totalBytes !== void 0) stats.totalBytes = totalBytes;
-  return stats;
-}
 function sanitize2(value) {
   if (value === null || value === void 0) return void 0;
   const trimmed = String(value).trim();
   return trimmed.length ? trimmed : void 0;
 }
-function toNumber2(value) {
-  if (value === null || value === void 0) return void 0;
-  if (typeof value === "number") return value;
-  const parsed = Number.parseFloat(String(value));
-  return Number.isNaN(parsed) ? void 0 : parsed;
-}
-function coerceStringArray(value) {
-  if (!value) return [];
-  if (Array.isArray(value)) {
-    return value.map((entry) => String(entry));
-  }
-  const text = String(value).trim();
-  if (!text) return [];
-  const withoutBraces = text.startsWith("{") && text.endsWith("}") ? text.slice(1, -1) : text;
-  if (!withoutBraces) return [];
-  return withoutBraces.split(",").map((part) => part.trim().replace(/^"(.+)"$/, "$1")).filter(Boolean);
-}
 
-// src/index.ts
-var QueryPanelSdkAPI = class {
+// src/core/client.ts
+import { createSign } from "crypto";
+var ApiClient = class {
   baseUrl;
   privateKey;
   organizationId;
   defaultTenantId;
   additionalHeaders;
   fetchImpl;
-  cachedPrivateKey;
-  databases = /* @__PURE__ */ new Map();
-  databaseMetadata = /* @__PURE__ */ new Map();
-  defaultDatabase;
-  lastSyncHashes = /* @__PURE__ */ new Map();
-  syncedDatabases = /* @__PURE__ */ new Set();
   constructor(baseUrl, privateKey, organizationId, options) {
     if (!baseUrl) {
       throw new Error("Base URL is required");
@@ -819,561 +555,188 @@ var QueryPanelSdkAPI = class {
       );
     }
   }
-  attachClickhouse(name, clientFn, options) {
-    const adapter = new ClickHouseAdapter(clientFn, options);
-    this.attachDatabase(name, adapter);
-    const metadata = {
-      name,
-      dialect: "clickhouse",
-      description: options?.description,
-      tags: options?.tags,
-      tenantFieldName: options?.tenantFieldName,
-      tenantFieldType: options?.tenantFieldType ?? "String",
-      enforceTenantIsolation: options?.tenantFieldName ? options?.enforceTenantIsolation ?? true : void 0
+  getDefaultTenantId() {
+    return this.defaultTenantId;
+  }
+  async get(path, tenantId, userId, scopes, signal, sessionId) {
+    return await this.request(path, {
+      method: "GET",
+      headers: await this.buildHeaders(
+        tenantId,
+        userId,
+        scopes,
+        false,
+        sessionId
+      ),
+      signal
+    });
+  }
+  async post(path, body, tenantId, userId, scopes, signal, sessionId) {
+    return await this.request(path, {
+      method: "POST",
+      headers: await this.buildHeaders(
+        tenantId,
+        userId,
+        scopes,
+        true,
+        sessionId
+      ),
+      body: JSON.stringify(body ?? {}),
+      signal
+    });
+  }
+  async put(path, body, tenantId, userId, scopes, signal, sessionId) {
+    return await this.request(path, {
+      method: "PUT",
+      headers: await this.buildHeaders(
+        tenantId,
+        userId,
+        scopes,
+        true,
+        sessionId
+      ),
+      body: JSON.stringify(body ?? {}),
+      signal
+    });
+  }
+  async delete(path, tenantId, userId, scopes, signal, sessionId) {
+    return await this.request(path, {
+      method: "DELETE",
+      headers: await this.buildHeaders(
+        tenantId,
+        userId,
+        scopes,
+        false,
+        sessionId
+      ),
+      signal
+    });
+  }
+  async request(path, init) {
+    const response = await this.fetchImpl(`${this.baseUrl}${path}`, init);
+    const text = await response.text();
+    let json;
+    try {
+      json = text ? JSON.parse(text) : void 0;
+    } catch {
+      json = void 0;
+    }
+    if (!response.ok) {
+      const error = new Error(
+        json?.error || response.statusText || "Request failed"
+      );
+      error.status = response.status;
+      if (json?.details) error.details = json.details;
+      throw error;
+    }
+    return json;
+  }
+  async buildHeaders(tenantId, userId, scopes, includeJson = true, sessionId) {
+    const token = await this.generateJWT(tenantId, userId, scopes);
+    const headers = {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/json"
     };
-    this.databaseMetadata.set(name, metadata);
+    if (includeJson) {
+      headers["Content-Type"] = "application/json";
+    }
+    if (sessionId) {
+      headers["x-session-id"] = sessionId;
+    }
+    if (this.additionalHeaders) {
+      Object.assign(headers, this.additionalHeaders);
+    }
+    return headers;
   }
-  attachPostgres(name, clientFn, options) {
-    const adapter = new PostgresAdapter(clientFn, options);
-    this.attachDatabase(name, adapter);
-    const metadata = {
-      name,
-      dialect: "postgres",
-      description: options?.description,
-      tags: options?.tags,
-      tenantFieldName: options?.tenantFieldName,
-      enforceTenantIsolation: options?.tenantFieldName ? options?.enforceTenantIsolation ?? true : void 0
+  async generateJWT(tenantId, userId, scopes) {
+    const header = {
+      alg: "RS256",
+      typ: "JWT"
     };
-    this.databaseMetadata.set(name, metadata);
+    const payload = {
+      organizationId: this.organizationId,
+      tenantId
+    };
+    if (userId) payload.userId = userId;
+    if (scopes?.length) payload.scopes = scopes;
+    const encodeJson = (obj) => {
+      const json = JSON.stringify(obj);
+      const base64 = Buffer.from(json).toString("base64");
+      return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+    };
+    const encodedHeader = encodeJson(header);
+    const encodedPayload = encodeJson(payload);
+    const data = `${encodedHeader}.${encodedPayload}`;
+    const signer = createSign("RSA-SHA256");
+    signer.update(data);
+    signer.end();
+    const signature = signer.sign(this.privateKey);
+    const encodedSignature = signature.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+    return `${data}.${encodedSignature}`;
   }
-  attachDatabase(name, adapter) {
+};
+
+// src/core/query-engine.ts
+var QueryEngine = class {
+  databases = /* @__PURE__ */ new Map();
+  databaseMetadata = /* @__PURE__ */ new Map();
+  defaultDatabase;
+  attachDatabase(name, adapter, metadata) {
     this.databases.set(name, adapter);
+    this.databaseMetadata.set(name, metadata);
     if (!this.defaultDatabase) {
       this.defaultDatabase = name;
     }
   }
-  async syncSchema(databaseName, options, signal) {
-    const tenantId = this.resolveTenantId(options.tenantId);
-    const adapter = this.getDatabase(databaseName);
-    const introspection = await adapter.introspect(
-      options.tables ? { tables: options.tables } : void 0
-    );
-    const payload = this.buildSchemaRequest(
-      databaseName,
-      adapter,
-      introspection
-    );
-    const hash = this.hashSchemaRequest(payload);
-    const previousHash = this.lastSyncHashes.get(databaseName);
-    if (!options.force && previousHash === hash) {
-      return {
-        success: true,
-        message: "Schema unchanged; skipping ingestion",
-        chunks: 0,
-        chunks_with_annotations: 0,
-        schema_hash: hash,
-        skipped: true
-      };
+  getDatabase(name) {
+    const dbName = name ?? this.defaultDatabase;
+    if (!dbName) {
+      throw new Error("No database attached.");
     }
-    const sessionId = randomUUID();
-    const response = await this.post(
-      "/ingest",
-      payload,
-      tenantId,
-      options.userId,
-      options.scopes,
-      signal,
-      sessionId
-    );
-    this.lastSyncHashes.set(databaseName, hash);
-    this.syncedDatabases.add(databaseName);
-    return response;
-  }
-  async ingestKnowledgeBaseChunks(payload, options, signal) {
-    const tenantId = this.resolveTenantId(
-      payload.tenantId ?? options?.tenantId
-    );
-    return await this.post(
-      "/knowledge-base/chunks",
-      {
-        organization_id: this.organizationId,
-        tenant_id: tenantId,
-        database: payload.database,
-        dialect: payload.dialect,
-        tables: payload.tables
-      },
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-  }
-  async introspect(databaseName, tables) {
-    const adapter = this.getDatabase(databaseName);
-    return await adapter.introspect(tables ? { tables } : void 0);
-  }
-  async ask(question, options, signal) {
-    const tenantId = this.resolveTenantId(options.tenantId);
-    await this.ensureSchemasSynced(
-      tenantId,
-      options.userId,
-      options.scopes,
-      options.disableAutoSync
-    );
-    const sessionId = randomUUID();
-    const queryResponse = await this.post(
-      "/query",
-      {
-        question,
-        ...options.lastError ? { last_error: options.lastError } : {},
-        ...options.previousSql ? { previous_sql: options.previousSql } : {},
-        ...options.maxRetry ? { max_retry: options.maxRetry } : {}
-      },
-      tenantId,
-      options.userId,
-      options.scopes,
-      signal,
-      sessionId
-    );
-    const databaseName = options.database ?? this.defaultDatabase;
-    if (!databaseName) {
+    const adapter = this.databases.get(dbName);
+    if (!adapter) {
       throw new Error(
-        "No database attached. Call attachPostgres/attachClickhouse first."
+        `Database '${dbName}' not found. Attached: ${Array.from(
+          this.databases.keys()
+        ).join(", ")}`
       );
     }
+    return adapter;
+  }
+  getDatabaseMetadata(name) {
+    const dbName = name ?? this.defaultDatabase;
+    if (!dbName) return void 0;
+    return this.databaseMetadata.get(dbName);
+  }
+  getDefaultDatabase() {
+    return this.defaultDatabase;
+  }
+  async validateAndExecute(sql, params, databaseName, tenantId) {
     const adapter = this.getDatabase(databaseName);
-    const paramMetadata = Array.isArray(queryResponse.params) ? queryResponse.params : [];
-    const paramValues = this.mapGeneratedParams(paramMetadata);
-    const metadata = this.databaseMetadata.get(databaseName);
+    const metadata = this.getDatabaseMetadata(databaseName);
+    let finalSql = sql;
     if (metadata) {
-      queryResponse.sql = this.ensureTenantIsolation(
-        queryResponse.sql,
-        paramValues,
-        metadata,
-        tenantId
-      );
+      finalSql = this.ensureTenantIsolation(sql, params, metadata, tenantId);
     }
-    await adapter.validate(queryResponse.sql, paramValues);
-    const execution = await adapter.execute(queryResponse.sql, paramValues);
-    const rows = execution.rows ?? [];
-    let chart = {
-      vegaLiteSpec: null,
-      notes: rows.length === 0 ? "Query returned no rows." : null
+    await adapter.validate(finalSql, params);
+    const result = await adapter.execute(finalSql, params);
+    return {
+      rows: result.rows,
+      fields: result.fields
     };
-    if (rows.length > 0) {
-      const chartResponse = await this.post(
-        "/chart",
-        {
-          question,
-          sql: queryResponse.sql,
-          rationale: queryResponse.rationale,
-          fields: execution.fields,
-          rows: anonymizeResults(rows),
-          max_retries: options.chartMaxRetries ?? 3,
-          query_id: queryResponse.queryId
-        },
-        tenantId,
-        options.userId,
-        options.scopes,
-        signal,
-        sessionId
+  }
+  async execute(sql, params, databaseName) {
+    try {
+      const adapter = this.getDatabase(databaseName);
+      const result = await adapter.execute(sql, params);
+      return result.rows;
+    } catch (error) {
+      console.warn(
+        `Failed to execute SQL locally for database '${databaseName}':`,
+        error
       );
-      chart = {
-        vegaLiteSpec: chartResponse.chart ? {
-          ...chartResponse.chart,
-          data: { values: rows }
-        } : null,
-        notes: chartResponse.notes
-      };
+      return [];
     }
-    return {
-      sql: queryResponse.sql,
-      params: paramValues,
-      paramMetadata,
-      rationale: queryResponse.rationale,
-      dialect: queryResponse.dialect,
-      queryId: queryResponse.queryId,
-      rows,
-      fields: execution.fields,
-      chart,
-      context: queryResponse.context
-    };
-  }
-  async upsertAnnotation(input, options, signal) {
-    const tenantId = this.resolveTenantId(input.tenantId ?? options?.tenantId);
-    const response = await this.post(
-      "/knowledge-base/annotations",
-      {
-        organization_id: this.organizationId,
-        tenant_id: tenantId,
-        target_identifier: input.targetIdentifier,
-        content: input.content,
-        user_id: input.userId
-      },
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-    return response.annotation;
-  }
-  async listAnnotations(options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    const response = await this.get(
-      "/knowledge-base/annotations",
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-    return response.annotations;
-  }
-  async getAnnotation(targetIdentifier, options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    const response = await this.get(
-      `/knowledge-base/annotations/${encodeURIComponent(targetIdentifier)}`,
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    ).catch((error) => {
-      if (error?.status === 404) {
-        return { success: false, annotation: null };
-      }
-      throw error;
-    });
-    return response.annotation ?? null;
-  }
-  async deleteAnnotation(targetIdentifier, options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    await this.delete(
-      `/knowledge-base/annotations/${encodeURIComponent(targetIdentifier)}`,
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-  }
-  async createChart(body, options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    return await this.post(
-      "/charts",
-      body,
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-  }
-  async listCharts(options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    const params = new URLSearchParams();
-    if (options?.pagination?.page)
-      params.set("page", `${options.pagination.page}`);
-    if (options?.pagination?.limit)
-      params.set("limit", `${options.pagination.limit}`);
-    if (options?.sortBy) params.set("sort_by", options.sortBy);
-    if (options?.sortDir) params.set("sort_dir", options.sortDir);
-    if (options?.title) params.set("title", options.title);
-    if (options?.userFilter) params.set("user_id", options.userFilter);
-    if (options?.createdFrom) params.set("created_from", options.createdFrom);
-    if (options?.createdTo) params.set("created_to", options.createdTo);
-    if (options?.updatedFrom) params.set("updated_from", options.updatedFrom);
-    if (options?.updatedTo) params.set("updated_to", options.updatedTo);
-    const response = await this.get(
-      `/charts${params.toString() ? `?${params.toString()}` : ""}`,
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-    if (options?.includeData) {
-      response.data = await Promise.all(
-        response.data.map(async (chart) => ({
-          ...chart,
-          vega_lite_spec: {
-            ...chart.vega_lite_spec,
-            data: {
-              values: await this.runSafeQueryOnClient(
-                chart.sql,
-                chart.database ?? void 0,
-                chart.sql_params ?? void 0
-              )
-            }
-          }
-        }))
-      );
-    }
-    return response;
-  }
-  async getChart(id, options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    const chart = await this.get(
-      `/charts/${encodeURIComponent(id)}`,
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-    return {
-      ...chart,
-      vega_lite_spec: {
-        ...chart.vega_lite_spec,
-        data: {
-          values: await this.runSafeQueryOnClient(
-            chart.sql,
-            chart.database ?? void 0,
-            chart.sql_params ?? void 0
-          )
-        }
-      }
-    };
-  }
-  async updateChart(id, body, options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    return await this.put(
-      `/charts/${encodeURIComponent(id)}`,
-      body,
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-  }
-  async deleteChart(id, options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    await this.delete(
-      `/charts/${encodeURIComponent(id)}`,
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-  }
-  async createActiveChart(body, options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    return await this.post(
-      "/active-charts",
-      body,
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-  }
-  async listActiveCharts(options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    const params = new URLSearchParams();
-    if (options?.pagination?.page)
-      params.set("page", `${options.pagination.page}`);
-    if (options?.pagination?.limit)
-      params.set("limit", `${options.pagination.limit}`);
-    if (options?.sortBy) params.set("sort_by", options.sortBy);
-    if (options?.sortDir) params.set("sort_dir", options.sortDir);
-    if (options?.title) params.set("name", options.title);
-    if (options?.userFilter) params.set("user_id", options.userFilter);
-    if (options?.createdFrom) params.set("created_from", options.createdFrom);
-    if (options?.createdTo) params.set("created_to", options.createdTo);
-    if (options?.updatedFrom) params.set("updated_from", options.updatedFrom);
-    if (options?.updatedTo) params.set("updated_to", options.updatedTo);
-    const response = await this.get(
-      `/active-charts${params.toString() ? `?${params.toString()}` : ""}`,
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-    if (options?.withData) {
-      response.data = await Promise.all(
-        response.data.map(async (active) => ({
-          ...active,
-          chart: active.chart ? await this.getChart(active.chart_id, options, signal) : null
-        }))
-      );
-    }
-    return response;
-  }
-  async getActiveChart(id, options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    const active = await this.get(
-      `/active-charts/${encodeURIComponent(id)}`,
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-    if (options?.withData && active.chart_id) {
-      return {
-        ...active,
-        chart: await this.getChart(active.chart_id, options, signal)
-      };
-    }
-    return active;
-  }
-  async updateActiveChart(id, body, options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    return await this.put(
-      `/active-charts/${encodeURIComponent(id)}`,
-      body,
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-  }
-  async deleteActiveChart(id, options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    await this.delete(
-      `/active-charts/${encodeURIComponent(id)}`,
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-  }
-  getDatabase(name) {
-    const dbName = name ?? this.defaultDatabase;
-    if (!dbName) {
-      throw new Error("No database attached.");
-    }
-    const adapter = this.databases.get(dbName);
-    if (!adapter) {
-      throw new Error(
-        `Database '${dbName}' not found. Attached: ${Array.from(
-          this.databases.keys()
-        ).join(", ")}`
-      );
-    }
-    return adapter;
-  }
-  async ensureSchemasSynced(tenantId, userId, scopes, disableAutoSync) {
-    if (disableAutoSync) return;
-    const unsynced = Array.from(this.databases.keys()).filter(
-      (name) => !this.syncedDatabases.has(name)
-    );
-    await Promise.all(
-      unsynced.map(
-        (name) => this.syncSchema(name, { tenantId, userId, scopes }).catch((error) => {
-          console.warn(`Failed to sync schema for ${name}:`, error);
-        })
-      )
-    );
-  }
-  resolveTenantId(tenantId) {
-    const resolved = tenantId ?? this.defaultTenantId;
-    if (!resolved) {
-      throw new Error(
-        "tenantId is required. Provide it per request or via defaultTenantId option."
-      );
-    }
-    return resolved;
-  }
-  async headers(tenantId, userId, scopes, includeJson = true, sessionId) {
-    const token = await this.generateJWT(tenantId, userId, scopes);
-    const headers = {
-      Authorization: `Bearer ${token}`,
-      Accept: "application/json"
-    };
-    if (includeJson) {
-      headers["Content-Type"] = "application/json";
-    }
-    if (sessionId) {
-      headers["x-session-id"] = sessionId;
-    }
-    if (this.additionalHeaders) {
-      Object.assign(headers, this.additionalHeaders);
-    }
-    return headers;
-  }
-  async request(path, init) {
-    const response = await this.fetchImpl(`${this.baseUrl}${path}`, init);
-    const text = await response.text();
-    let json;
-    try {
-      json = text ? JSON.parse(text) : void 0;
-    } catch {
-      json = void 0;
-    }
-    if (!response.ok) {
-      const error = new Error(
-        json?.error || response.statusText || "Request failed"
-      );
-      error.status = response.status;
-      if (json?.details) error.details = json.details;
-      throw error;
-    }
-    return json;
-  }
-  async get(path, tenantId, userId, scopes, signal, sessionId) {
-    return await this.request(path, {
-      method: "GET",
-      headers: await this.headers(tenantId, userId, scopes, false, sessionId),
-      signal
-    });
-  }
-  async post(path, body, tenantId, userId, scopes, signal, sessionId) {
-    return await this.request(path, {
-      method: "POST",
-      headers: await this.headers(tenantId, userId, scopes, true, sessionId),
-      body: JSON.stringify(body ?? {}),
-      signal
-    });
-  }
-  async put(path, body, tenantId, userId, scopes, signal, sessionId) {
-    return await this.request(path, {
-      method: "PUT",
-      headers: await this.headers(tenantId, userId, scopes, true, sessionId),
-      body: JSON.stringify(body ?? {}),
-      signal
-    });
-  }
-  async delete(path, tenantId, userId, scopes, signal, sessionId) {
-    return await this.request(path, {
-      method: "DELETE",
-      headers: await this.headers(tenantId, userId, scopes, false, sessionId),
-      signal
-    });
-  }
-  async generateJWT(tenantId, userId, scopes) {
-    if (!this.cachedPrivateKey) {
-      this.cachedPrivateKey = await importPKCS8(this.privateKey, "RS256");
-    }
-    const payload = {
-      organizationId: this.organizationId,
-      tenantId
-    };
-    if (userId) payload.userId = userId;
-    if (scopes?.length) payload.scopes = scopes;
-    return await new SignJWT(payload).setProtectedHeader({ alg: "RS256" }).setIssuedAt().setExpirationTime("1h").sign(this.cachedPrivateKey);
-  }
-  buildSchemaRequest(databaseName, adapter, introspection) {
-    const dialect = adapter.getDialect();
-    const tables = introspection.tables.map((table) => ({
-      table_name: table.name,
-      description: table.comment ?? `Table ${table.name}`,
-      columns: table.columns.map((column) => ({
-        name: column.name,
-        data_type: column.rawType ?? column.type,
-        is_primary_key: Boolean(column.isPrimaryKey),
-        description: column.comment ?? ""
-      }))
-    }));
-    return {
-      database: databaseName,
-      dialect,
-      tables
-    };
-  }
-  hashSchemaRequest(payload) {
-    const normalized = payload.tables.map((table) => ({
-      name: table.table_name,
-      columns: table.columns.map((column) => ({
-        name: column.name,
-        type: column.data_type,
-        primary: column.is_primary_key
-      }))
-    }));
-    return createHash("sha256").update(JSON.stringify(normalized)).digest("hex");
   }
   mapGeneratedParams(params) {
     const record = {};
@@ -1408,20 +771,375 @@ var QueryPanelSdkAPI = class {
     }
     return `${sql} WHERE ${tenantPredicate}`;
   }
-  async runSafeQueryOnClient(sql, database, params) {
+};
+
+// src/routes/charts.ts
+async function createChart(client, body, options, signal) {
+  const tenantId = resolveTenantId(client, options?.tenantId);
+  return await client.post(
+    "/charts",
+    body,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+}
+async function listCharts(client, queryEngine, options, signal) {
+  const tenantId = resolveTenantId(client, options?.tenantId);
+  const params = new URLSearchParams();
+  if (options?.pagination?.page)
+    params.set("page", `${options.pagination.page}`);
+  if (options?.pagination?.limit)
+    params.set("limit", `${options.pagination.limit}`);
+  if (options?.sortBy) params.set("sort_by", options.sortBy);
+  if (options?.sortDir) params.set("sort_dir", options.sortDir);
+  if (options?.title) params.set("title", options.title);
+  if (options?.userFilter) params.set("user_id", options.userFilter);
+  if (options?.createdFrom) params.set("created_from", options.createdFrom);
+  if (options?.createdTo) params.set("created_to", options.createdTo);
+  if (options?.updatedFrom) params.set("updated_from", options.updatedFrom);
+  if (options?.updatedTo) params.set("updated_to", options.updatedTo);
+  const response = await client.get(
+    `/charts${params.toString() ? `?${params.toString()}` : ""}`,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+  if (options?.includeData) {
+    response.data = await Promise.all(
+      response.data.map(async (chart) => ({
+        ...chart,
+        vega_lite_spec: {
+          ...chart.vega_lite_spec,
+          data: {
+            values: await queryEngine.execute(
+              chart.sql,
+              chart.sql_params ?? void 0,
+              chart.target_db ?? void 0
+            )
+          }
+        }
+      }))
+    );
+  }
+  return response;
+}
+async function getChart(client, queryEngine, id, options, signal) {
+  const tenantId = resolveTenantId(client, options?.tenantId);
+  const chart = await client.get(
+    `/charts/${encodeURIComponent(id)}`,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+  return {
+    ...chart,
+    vega_lite_spec: {
+      ...chart.vega_lite_spec,
+      data: {
+        values: await queryEngine.execute(
+          chart.sql,
+          chart.sql_params ?? void 0,
+          chart.target_db ?? void 0
+        )
+      }
+    }
+  };
+}
+async function updateChart(client, id, body, options, signal) {
+  const tenantId = resolveTenantId(client, options?.tenantId);
+  return await client.put(
+    `/charts/${encodeURIComponent(id)}`,
+    body,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+}
+async function deleteChart(client, id, options, signal) {
+  const tenantId = resolveTenantId(client, options?.tenantId);
+  await client.delete(
+    `/charts/${encodeURIComponent(id)}`,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+}
+function resolveTenantId(client, tenantId) {
+  const resolved = tenantId ?? client.getDefaultTenantId();
+  if (!resolved) {
+    throw new Error(
+      "tenantId is required. Provide it per request or via defaultTenantId option."
+    );
+  }
+  return resolved;
+}
+
+// src/routes/active-charts.ts
+async function createActiveChart(client, body, options, signal) {
+  const tenantId = resolveTenantId2(client, options?.tenantId);
+  return await client.post(
+    "/active-charts",
+    body,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+}
+async function listActiveCharts(client, queryEngine, options, signal) {
+  const tenantId = resolveTenantId2(client, options?.tenantId);
+  const params = new URLSearchParams();
+  if (options?.pagination?.page)
+    params.set("page", `${options.pagination.page}`);
+  if (options?.pagination?.limit)
+    params.set("limit", `${options.pagination.limit}`);
+  if (options?.sortBy) params.set("sort_by", options.sortBy);
+  if (options?.sortDir) params.set("sort_dir", options.sortDir);
+  if (options?.title) params.set("name", options.title);
+  if (options?.userFilter) params.set("user_id", options.userFilter);
+  if (options?.createdFrom) params.set("created_from", options.createdFrom);
+  if (options?.createdTo) params.set("created_to", options.createdTo);
+  if (options?.updatedFrom) params.set("updated_from", options.updatedFrom);
+  if (options?.updatedTo) params.set("updated_to", options.updatedTo);
+  const response = await client.get(
+    `/active-charts${params.toString() ? `?${params.toString()}` : ""}`,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+  if (options?.withData) {
+    response.data = await Promise.all(
+      response.data.map(async (active) => ({
+        ...active,
+        chart: active.chart ? await getChart(
+          client,
+          queryEngine,
+          active.chart_id,
+          options,
+          signal
+        ) : null
+      }))
+    );
+  }
+  return response;
+}
+async function getActiveChart(client, queryEngine, id, options, signal) {
+  const tenantId = resolveTenantId2(client, options?.tenantId);
+  const active = await client.get(
+    `/active-charts/${encodeURIComponent(id)}`,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+  if (options?.withData && active.chart_id) {
+    return {
+      ...active,
+      chart: await getChart(
+        client,
+        queryEngine,
+        active.chart_id,
+        options,
+        signal
+      )
+    };
+  }
+  return active;
+}
+async function updateActiveChart(client, id, body, options, signal) {
+  const tenantId = resolveTenantId2(client, options?.tenantId);
+  return await client.put(
+    `/active-charts/${encodeURIComponent(id)}`,
+    body,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+}
+async function deleteActiveChart(client, id, options, signal) {
+  const tenantId = resolveTenantId2(client, options?.tenantId);
+  await client.delete(
+    `/active-charts/${encodeURIComponent(id)}`,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+}
+function resolveTenantId2(client, tenantId) {
+  const resolved = tenantId ?? client.getDefaultTenantId();
+  if (!resolved) {
+    throw new Error(
+      "tenantId is required. Provide it per request or via defaultTenantId option."
+    );
+  }
+  return resolved;
+}
+
+// src/routes/ingest.ts
+import { randomUUID } from "crypto";
+async function syncSchema(client, queryEngine, databaseName, options, signal) {
+  const tenantId = resolveTenantId3(client, options.tenantId);
+  const adapter = queryEngine.getDatabase(databaseName);
+  const introspection = await adapter.introspect(
+    options.tables ? { tables: options.tables } : void 0
+  );
+  const payload = buildSchemaRequest(databaseName, adapter, introspection);
+  const sessionId = randomUUID();
+  const response = await client.post(
+    "/ingest",
+    payload,
+    tenantId,
+    options.userId,
+    options.scopes,
+    signal,
+    sessionId
+  );
+  return response;
+}
+function resolveTenantId3(client, tenantId) {
+  const resolved = tenantId ?? client.getDefaultTenantId();
+  if (!resolved) {
+    throw new Error(
+      "tenantId is required. Provide it per request or via defaultTenantId option."
+    );
+  }
+  return resolved;
+}
+function buildSchemaRequest(databaseName, adapter, introspection) {
+  const dialect = adapter.getDialect();
+  const tables = introspection.tables.map((table) => ({
+    table_name: table.name,
+    description: table.comment ?? `Table ${table.name}`,
+    columns: table.columns.map((column) => ({
+      name: column.name,
+      data_type: column.rawType ?? column.type,
+      is_primary_key: Boolean(column.isPrimaryKey),
+      description: column.comment ?? ""
+    }))
+  }));
+  return {
+    database: databaseName,
+    dialect,
+    tables
+  };
+}
+
+// src/routes/query.ts
+import { randomUUID as randomUUID2 } from "crypto";
+async function ask(client, queryEngine, question, options, signal) {
+  const tenantId = resolveTenantId4(client, options.tenantId);
+  const sessionId = randomUUID2();
+  const maxRetry = options.maxRetry ?? 0;
+  let attempt = 0;
+  let lastError = options.lastError;
+  let previousSql = options.previousSql;
+  while (attempt <= maxRetry) {
+    console.log({ lastError, previousSql });
+    const queryResponse = await client.post(
+      "/query",
+      {
+        question,
+        ...lastError ? { last_error: lastError } : {},
+        ...previousSql ? { previous_sql: previousSql } : {},
+        ...options.maxRetry ? { max_retry: options.maxRetry } : {}
+      },
+      tenantId,
+      options.userId,
+      options.scopes,
+      signal,
+      sessionId
+    );
+    const databaseName = queryResponse.database ?? options.database ?? queryEngine.getDefaultDatabase();
+    if (!databaseName) {
+      throw new Error(
+        "No database attached. Call attachPostgres/attachClickhouse first."
+      );
+    }
+    const paramMetadata = Array.isArray(queryResponse.params) ? queryResponse.params : [];
+    const paramValues = queryEngine.mapGeneratedParams(paramMetadata);
     try {
-      const adapter = this.getDatabase(database);
-      const result = await adapter.execute(sql, params);
-      return result.rows;
+      const execution = await queryEngine.validateAndExecute(
+        queryResponse.sql,
+        paramValues,
+        databaseName,
+        tenantId
+      );
+      const rows = execution.rows ?? [];
+      let chart = {
+        vegaLiteSpec: null,
+        notes: rows.length === 0 ? "Query returned no rows." : null
+      };
+      if (rows.length > 0) {
+        const chartResponse = await client.post(
+          "/chart",
+          {
+            question,
+            sql: queryResponse.sql,
+            rationale: queryResponse.rationale,
+            fields: execution.fields,
+            rows: anonymizeResults(rows),
+            max_retries: options.chartMaxRetries ?? 3,
+            query_id: queryResponse.queryId
+          },
+          tenantId,
+          options.userId,
+          options.scopes,
+          signal,
+          sessionId
+        );
+        chart = {
+          vegaLiteSpec: chartResponse.chart ? {
+            ...chartResponse.chart,
+            data: { values: rows }
+          } : null,
+          notes: chartResponse.notes
+        };
+      }
+      return {
+        sql: queryResponse.sql,
+        params: paramValues,
+        paramMetadata,
+        rationale: queryResponse.rationale,
+        dialect: queryResponse.dialect,
+        queryId: queryResponse.queryId,
+        rows,
+        fields: execution.fields,
+        chart,
+        context: queryResponse.context,
+        attempts: attempt + 1
+      };
     } catch (error) {
+      attempt++;
+      if (attempt > maxRetry) {
+        throw error;
+      }
+      lastError = error instanceof Error ? error.message : String(error);
+      previousSql = queryResponse.sql;
       console.warn(
-        `Failed to execute SQL locally for database '${database}':`,
-        error
+        `SQL execution failed (attempt ${attempt}/${maxRetry + 1}): ${lastError}. Retrying...`
       );
-      return [];
     }
   }
-};
+  throw new Error("Unexpected error in ask retry loop");
+}
+function resolveTenantId4(client, tenantId) {
+  const resolved = tenantId ?? client.getDefaultTenantId();
+  if (!resolved) {
+    throw new Error(
+      "tenantId is required. Provide it per request or via defaultTenantId option."
+    );
+  }
+  return resolved;
+}
 function anonymizeResults(rows) {
   if (!rows?.length) return [];
   return rows.map((row) => {
@@ -1434,6 +1152,144 @@ function anonymizeResults(rows) {
     return masked;
   });
 }
+
+// src/index.ts
+var QueryPanelSdkAPI = class {
+  client;
+  queryEngine;
+  constructor(baseUrl, privateKey, organizationId, options) {
+    this.client = new ApiClient(baseUrl, privateKey, organizationId, options);
+    this.queryEngine = new QueryEngine();
+  }
+  // Database attachment methods
+  attachClickhouse(name, clientFn, options) {
+    const adapter = new ClickHouseAdapter(clientFn, options);
+    const metadata = {
+      name,
+      dialect: "clickhouse",
+      description: options?.description,
+      tags: options?.tags,
+      tenantFieldName: options?.tenantFieldName,
+      tenantFieldType: options?.tenantFieldType ?? "String",
+      enforceTenantIsolation: options?.tenantFieldName ? options?.enforceTenantIsolation ?? true : void 0
+    };
+    this.queryEngine.attachDatabase(name, adapter, metadata);
+  }
+  attachPostgres(name, clientFn, options) {
+    const adapter = new PostgresAdapter(clientFn, options);
+    const metadata = {
+      name,
+      dialect: "postgres",
+      description: options?.description,
+      tags: options?.tags,
+      tenantFieldName: options?.tenantFieldName,
+      enforceTenantIsolation: options?.tenantFieldName ? options?.enforceTenantIsolation ?? true : void 0
+    };
+    this.queryEngine.attachDatabase(name, adapter, metadata);
+  }
+  attachDatabase(name, adapter) {
+    const metadata = {
+      name,
+      dialect: adapter.getDialect()
+    };
+    this.queryEngine.attachDatabase(name, adapter, metadata);
+  }
+  // Schema introspection and sync
+  async introspect(databaseName, tables) {
+    const adapter = this.queryEngine.getDatabase(databaseName);
+    return await adapter.introspect(tables ? { tables } : void 0);
+  }
+  async syncSchema(databaseName, options, signal) {
+    return await syncSchema(
+      this.client,
+      this.queryEngine,
+      databaseName,
+      options,
+      signal
+    );
+  }
+  // Natural language query
+  async ask(question, options, signal) {
+    return await ask(
+      this.client,
+      this.queryEngine,
+      question,
+      options,
+      signal
+    );
+  }
+  // Chart CRUD operations
+  async createChart(body, options, signal) {
+    return await createChart(this.client, body, options, signal);
+  }
+  async listCharts(options, signal) {
+    return await listCharts(
+      this.client,
+      this.queryEngine,
+      options,
+      signal
+    );
+  }
+  async getChart(id, options, signal) {
+    return await getChart(
+      this.client,
+      this.queryEngine,
+      id,
+      options,
+      signal
+    );
+  }
+  async updateChart(id, body, options, signal) {
+    return await updateChart(
+      this.client,
+      id,
+      body,
+      options,
+      signal
+    );
+  }
+  async deleteChart(id, options, signal) {
+    await deleteChart(this.client, id, options, signal);
+  }
+  // Active Chart CRUD operations
+  async createActiveChart(body, options, signal) {
+    return await createActiveChart(
+      this.client,
+      body,
+      options,
+      signal
+    );
+  }
+  async listActiveCharts(options, signal) {
+    return await listActiveCharts(
+      this.client,
+      this.queryEngine,
+      options,
+      signal
+    );
+  }
+  async getActiveChart(id, options, signal) {
+    return await getActiveChart(
+      this.client,
+      this.queryEngine,
+      id,
+      options,
+      signal
+    );
+  }
+  async updateActiveChart(id, body, options, signal) {
+    return await updateActiveChart(
+      this.client,
+      id,
+      body,
+      options,
+      signal
+    );
+  }
+  async deleteActiveChart(id, options, signal) {
+    await deleteActiveChart(this.client, id, options, signal);
+  }
+};
 export {
   ClickHouseAdapter,
   PostgresAdapter,