@deepagents/text2sql 0.2.2 → 0.3.0

package/dist/lib/adapters/sqlserver/index.js

@@ -0,0 +1,1693 @@
+// packages/text2sql/src/lib/adapters/groundings/context.ts
+function createGroundingContext() {
+  return {
+    tables: [],
+    views: [],
+    relationships: [],
+    info: void 0
+  };
+}
+
+// packages/text2sql/src/lib/adapters/adapter.ts
+var Adapter = class {
+  async introspect() {
+    const lines = [];
+    const ctx = createGroundingContext();
+    for (const fn of this.grounding) {
+      const grounding = fn(this);
+      lines.push({
+        tag: grounding.tag,
+        fn: await grounding.execute(ctx)
+      });
+    }
+    return lines.map(({ fn, tag }) => {
+      const description = fn();
+      if (description === null) {
+        return "";
+      }
+      return `<${tag}>
+${description}
+</${tag}>`;
+    }).join("\n");
+  }
+  /**
+   * Convert unknown database value to number.
+   * Handles number, bigint, and string types.
+   */
+  toNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+    if (typeof value === "bigint") {
+      return Number(value);
+    }
+    if (typeof value === "string" && value.trim() !== "") {
+      const parsed = Number(value);
+      return Number.isFinite(parsed) ? parsed : void 0;
+    }
+    return void 0;
+  }
+  /**
+   * Parse a potentially qualified table name into schema and table parts.
+   */
+  parseTableName(name) {
+    if (name.includes(".")) {
+      const [schema, ...rest] = name.split(".");
+      return { schema, table: rest.join(".") };
+    }
+    return { schema: this.defaultSchema ?? "", table: name };
+  }
+  /**
+   * Escape a string value for use in SQL string literals (single quotes).
+   * Used in WHERE clauses like: WHERE name = '${escapeString(value)}'
+   */
+  escapeString(value) {
+    return value.replace(/'/g, "''");
+  }
+  /**
+   * Build a SQL filter clause to include/exclude schemas.
+   * @param columnName - The schema column name (e.g., 'TABLE_SCHEMA')
+   * @param allowedSchemas - If provided, filter to these schemas only
+   */
+  buildSchemaFilter(columnName, allowedSchemas) {
+    if (allowedSchemas && allowedSchemas.length > 0) {
+      const values = allowedSchemas.map((s) => `'${this.escapeString(s)}'`).join(", ");
+      return `AND ${columnName} IN (${values})`;
+    }
+    if (this.systemSchemas.length > 0) {
+      const values = this.systemSchemas.map((s) => `'${this.escapeString(s)}'`).join(", ");
+      return `AND ${columnName} NOT IN (${values})`;
+    }
+    return "";
+  }
+};
+
+// packages/text2sql/src/lib/adapters/grounding.ticket.ts
+var AbstractGrounding = class {
+  tag;
+  constructor(tag) {
+    this.tag = tag;
+  }
+};
+
+// packages/text2sql/src/lib/adapters/groundings/column-stats.grounding.ts
+var ColumnStatsGrounding = class extends AbstractGrounding {
+  constructor(config = {}) {
+    super("column_stats");
+  }
+  /**
+   * Execute the grounding process.
+   * Annotates columns in ctx.tables and ctx.views with statistics.
+   */
+  async execute(ctx) {
+    const allContainers = [...ctx.tables, ...ctx.views];
+    for (const container of allContainers) {
+      for (const column of container.columns) {
+        try {
+          const stats = await this.collectStats(container.name, column);
+          if (stats) {
+            column.stats = stats;
+          }
+        } catch (error) {
+          console.warn(
+            "Error collecting stats for",
+            container.name,
+            column.name,
+            error
+          );
+        }
+      }
+    }
+    return () => this.#describe();
+  }
+  #describe() {
+    return null;
+  }
+};
+
+// packages/text2sql/src/lib/adapters/groundings/constraint.grounding.ts
+var ConstraintGrounding = class extends AbstractGrounding {
+  constructor(config = {}) {
+    super("constraints");
+  }
+  /**
+   * Execute the grounding process.
+   * Annotates tables in ctx.tables with their constraints.
+   */
+  async execute(ctx) {
+    for (const table of ctx.tables) {
+      try {
+        table.constraints = await this.getConstraints(table.name);
+      } catch (error) {
+        console.warn("Error collecting constraints for", table.name, error);
+      }
+    }
+    return () => null;
+  }
+};
+
+// packages/text2sql/src/lib/adapters/groundings/indexes.grounding.ts
+var IndexesGrounding = class extends AbstractGrounding {
+  constructor(config = {}) {
+    super("indexes");
+  }
+  /**
+   * Execute the grounding process.
+   * Annotates tables in ctx.tables with their indexes and marks indexed columns.
+   */
+  async execute(ctx) {
+    for (const table of ctx.tables) {
+      table.indexes = await this.getIndexes(table.name);
+      for (const index of table.indexes ?? []) {
+        for (const colName of index.columns) {
+          const column = table.columns.find((c) => c.name === colName);
+          if (column) {
+            column.isIndexed = true;
+          }
+        }
+      }
+    }
+    return () => null;
+  }
+};
+
+// packages/text2sql/src/lib/adapters/groundings/info.grounding.ts
+var InfoGrounding = class extends AbstractGrounding {
+  constructor(config = {}) {
+    super("dialect_info");
+  }
+  /**
+   * Execute the grounding process.
+   * Writes database info to ctx.info.
+   */
+  async execute(ctx) {
+    ctx.info = await this.collectInfo();
+    const lines = [`Dialect: ${ctx.info.dialect ?? "unknown"}`];
+    if (ctx.info.version) {
+      lines.push(`Version: ${ctx.info.version}`);
+    }
+    if (ctx.info.database) {
+      lines.push(`Database: ${ctx.info.database}`);
+    }
+    if (ctx.info.details && Object.keys(ctx.info.details).length) {
+      lines.push(`Details: ${JSON.stringify(ctx.info.details)}`);
+    }
+    return () => lines.join("\n");
+  }
+};
+
+// packages/text2sql/src/lib/adapters/groundings/low-cardinality.grounding.ts
+var LowCardinalityGrounding = class extends AbstractGrounding {
+  constructor(config = {}) {
+    super("low_cardinality");
+  }
+  /**
+   * Execute the grounding process.
+   * Annotates columns in ctx.tables and ctx.views with low cardinality values.
+   */
+  async execute(ctx) {
+    const allContainers = [...ctx.tables, ...ctx.views];
+    for (const container of allContainers) {
+      for (const column of container.columns) {
+        try {
+          const lowCard = await this.collectLowCardinality(
+            container.name,
+            column
+          );
+          if (lowCard) {
+            column.kind = lowCard.kind;
+            column.values = lowCard.values;
+          }
+        } catch (error) {
+          console.warn(
+            "Error collecting low cardinality values for",
+            container.name,
+            column.name,
+            error
+          );
+        }
+      }
+    }
+    return () => this.#describe();
+  }
+  #describe() {
+    return null;
+  }
+};
+
+// packages/text2sql/src/lib/adapters/groundings/report.grounding.ts
+import { groq } from "@ai-sdk/groq";
+import { tool } from "ai";
+import dedent from "dedent";
+import z from "zod";
+import {
+  agent,
+  generate,
+  toState,
+  user
+} from "@deepagents/agent";
+var ReportGrounding = class extends AbstractGrounding {
+  #adapter;
+  #model;
+  #cache;
+  #forceRefresh;
+  constructor(adapter, config = {}) {
+    super("business_context");
+    this.#adapter = adapter;
+    this.#model = config.model ?? groq("openai/gpt-oss-20b");
+    this.#cache = config.cache;
+    this.#forceRefresh = config.forceRefresh ?? false;
+  }
+  async execute(ctx) {
+    if (!this.#forceRefresh && this.#cache) {
+      const cached = await this.#cache.get();
+      if (cached) {
+        ctx.report = cached;
+        return () => cached;
+      }
+    }
+    const report2 = await this.#generateReport();
+    ctx.report = report2;
+    if (this.#cache) {
+      await this.#cache.set(report2);
+    }
+    return () => report2;
+  }
+  async #generateReport() {
+    const reportAgent = agent({
+      name: "db-report-agent",
+      model: this.#model,
+      prompt: () => dedent`
+        <identity>
+          You are a database analyst expert. Your job is to understand what
+          a database represents and provide business context about it.
+          You have READ-ONLY access to the database.
+        </identity>
+
+        <instructions>
+          Write a business context that helps another agent answer questions accurately.
+
+          For EACH table, do queries ONE AT A TIME:
+          1. SELECT COUNT(*) to get row count
+          2. SELECT * LIMIT 3 to see sample data
+
+          Then write a report with:
+          - What business this database is for
+          - For each table: purpose, row count, and example of what the data looks like
+
+          Include concrete examples like "Track prices are $0.99",
+          "Customer names like 'Luís Gonçalves'", etc.
+
+          Keep it 400-600 words, conversational style.
+        </instructions>
+      `,
+      tools: {
+        query_database: tool({
+          description: "Execute a SELECT query to explore the database and gather insights.",
+          inputSchema: z.object({
+            sql: z.string().describe("The SELECT query to execute"),
+            purpose: z.string().describe(
+              "What insight you are trying to gather with this query"
+            )
+          }),
+          execute: ({ sql }, options) => {
+            const state = toState(options);
+            return state.adapter.execute(sql);
+          }
+        })
+      }
+    });
+    const { text } = await generate(
+      reportAgent,
+      [
+        user(
+          "Please analyze the database and write a contextual report about what this database represents."
+        )
+      ],
+      { adapter: this.#adapter }
+    );
+    return text;
+  }
+};
+
+// packages/text2sql/src/lib/adapters/groundings/row-count.grounding.ts
+var RowCountGrounding = class extends AbstractGrounding {
+  constructor(config = {}) {
+    super("row_counts");
+  }
+  /**
+   * Execute the grounding process.
+   * Annotates tables in ctx.tables with row counts and size hints.
+   */
+  async execute(ctx) {
+    for (const table of ctx.tables) {
+      const count = await this.getRowCount(table.name);
+      if (count != null) {
+        table.rowCount = count;
+        table.sizeHint = this.#classifyRowCount(count);
+      }
+    }
+    return () => null;
+  }
+  /**
+   * Classify row count into a size hint category.
+   */
+  #classifyRowCount(count) {
+    if (count < 100) return "tiny";
+    if (count < 1e3) return "small";
+    if (count < 1e4) return "medium";
+    if (count < 1e5) return "large";
+    return "huge";
+  }
+};
+
+// packages/text2sql/src/lib/adapters/groundings/table.grounding.ts
+import pluralize from "pluralize";
+var TableGrounding = class extends AbstractGrounding {
+  #filter;
+  #forward;
+  #backward;
+  constructor(config = {}) {
+    super("tables");
+    this.#filter = config.filter;
+    this.#forward = config.forward;
+    this.#backward = config.backward;
+  }
+  /**
+   * Execute the grounding process.
+   * Writes discovered tables and relationships to the context.
+   */
+  async execute(ctx) {
+    const seedTables = await this.applyFilter();
+    const forward = this.#forward;
+    const backward = this.#backward;
+    if (!forward && !backward) {
+      const tables3 = await Promise.all(
+        seedTables.map((name) => this.getTable(name))
+      );
+      ctx.tables.push(...tables3);
+      return () => this.#describeTables(tables3);
+    }
+    const tables2 = {};
+    const allRelationships = [];
+    const seenRelationships = /* @__PURE__ */ new Set();
+    const forwardQueue = [];
+    const backwardQueue = [];
+    const forwardVisited = /* @__PURE__ */ new Set();
+    const backwardVisited = /* @__PURE__ */ new Set();
+    for (const name of seedTables) {
+      if (forward) forwardQueue.push({ name, depth: 0 });
+      if (backward) backwardQueue.push({ name, depth: 0 });
+    }
+    const forwardLimit = forward === true ? Infinity : forward || 0;
+    while (forwardQueue.length > 0) {
+      const item = forwardQueue.shift();
+      if (!item) break;
+      const { name, depth } = item;
+      if (forwardVisited.has(name)) continue;
+      forwardVisited.add(name);
+      if (!tables2[name]) {
+        tables2[name] = await this.getTable(name);
+      }
+      if (depth < forwardLimit) {
+        const rels = await this.findOutgoingRelations(name);
+        for (const rel of rels) {
+          this.addRelationship(rel, allRelationships, seenRelationships);
+          if (!forwardVisited.has(rel.referenced_table)) {
+            forwardQueue.push({ name: rel.referenced_table, depth: depth + 1 });
+          }
+        }
+      }
+    }
+    const backwardLimit = backward === true ? Infinity : backward || 0;
+    while (backwardQueue.length > 0) {
+      const item = backwardQueue.shift();
+      if (!item) break;
+      const { name, depth } = item;
+      if (backwardVisited.has(name)) continue;
+      backwardVisited.add(name);
+      if (!tables2[name]) {
+        tables2[name] = await this.getTable(name);
+      }
+      if (depth < backwardLimit) {
+        const rels = await this.findIncomingRelations(name);
+        for (const rel of rels) {
+          this.addRelationship(rel, allRelationships, seenRelationships);
+          if (!backwardVisited.has(rel.table)) {
+            backwardQueue.push({ name: rel.table, depth: depth + 1 });
+          }
+        }
+      }
+    }
+    const tablesList = Object.values(tables2);
+    ctx.tables.push(...tablesList);
+    ctx.relationships.push(...allRelationships);
+    return () => this.#describeTables(tablesList);
+  }
+  /**
+   * Apply the filter to get seed table names.
+   * If filter is an explicit array, skip querying all table names.
+   */
+  async applyFilter() {
+    const filter = this.#filter;
+    if (Array.isArray(filter)) {
+      return filter;
+    }
+    const names = await this.getAllTableNames();
+    if (!filter) {
+      return names;
+    }
+    if (filter instanceof RegExp) {
+      return names.filter((name) => filter.test(name));
+    }
+    return names.filter(filter);
+  }
+  /**
+   * Add a relationship to the collection, deduplicating by key.
+   */
+  addRelationship(rel, all, seen) {
+    const key = `${rel.table}:${rel.from.join(",")}:${rel.referenced_table}:${rel.to.join(",")}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      all.push(rel);
+    }
+  }
+  #describeTables(tables2) {
+    if (!tables2.length) {
+      return "Schema unavailable.";
+    }
+    return tables2.map((table) => {
+      const rowCountInfo = table.rowCount != null ? ` [rows: ${table.rowCount}${table.sizeHint ? `, size: ${table.sizeHint}` : ""}]` : "";
+      const pkConstraint = table.constraints?.find((c) => c.type === "PRIMARY_KEY");
+      const pkColumns = new Set(pkConstraint?.columns ?? []);
+      const columns = table.columns.map((column) => {
+        const annotations = [];
+        const isPrimaryKey = pkColumns.has(column.name);
+        if (isPrimaryKey) {
+          annotations.push("PK");
+        }
+        if (column.isIndexed && !isPrimaryKey) {
+          annotations.push("Indexed");
+        }
+        if (column.kind === "LowCardinality" && column.values?.length) {
+          annotations.push(`LowCardinality: ${column.values.join(", ")}`);
+        }
+        if (column.stats) {
+          const statParts = [];
+          if (column.stats.min != null || column.stats.max != null) {
+            const minText = column.stats.min ?? "n/a";
+            const maxText = column.stats.max ?? "n/a";
+            statParts.push(`range ${minText} \u2192 ${maxText}`);
+          }
+          if (column.stats.nullFraction != null && Number.isFinite(column.stats.nullFraction)) {
+            const percent = Math.round(column.stats.nullFraction * 1e3) / 10;
+            statParts.push(`null\u2248${percent}%`);
+          }
+          if (statParts.length) {
+            annotations.push(statParts.join(", "));
+          }
+        }
+        const annotationText = annotations.length ? ` [${annotations.join(", ")}]` : "";
+        return `    - ${column.name} (${column.type})${annotationText}`;
+      }).join("\n");
+      const indexes2 = table.indexes?.length ? `
+  Indexes:
+${table.indexes.map((index) => {
+        const props = [];
+        if (index.unique) {
+          props.push("UNIQUE");
+        }
+        if (index.type) {
+          props.push(index.type);
+        }
+        const propsText = props.length ? ` (${props.join(", ")})` : "";
+        const columnsText = index.columns?.length ? index.columns.join(", ") : "expression";
+        return `    - ${index.name}${propsText}: ${columnsText}`;
+      }).join("\n")}` : "";
+      return `- Table: ${table.name}${rowCountInfo}
+  Columns:
+${columns}${indexes2}`;
+    }).join("\n\n");
+  }
+  #formatTableLabel = (tableName) => {
+    const base = tableName.split(".").pop() ?? tableName;
+    return base.replace(/_/g, " ");
+  };
+  #describeRelationships = (tables2, relationships) => {
+    if (!relationships.length) {
+      return "None detected";
+    }
+    const tableMap = new Map(tables2.map((table) => [table.name, table]));
+    return relationships.map((relationship) => {
+      const sourceLabel = this.#formatTableLabel(relationship.table);
+      const targetLabel = this.#formatTableLabel(
+        relationship.referenced_table
+      );
+      const singularSource = pluralize.singular(sourceLabel);
+      const pluralSource = pluralize.plural(sourceLabel);
+      const singularTarget = pluralize.singular(targetLabel);
+      const pluralTarget = pluralize.plural(targetLabel);
+      const sourceTable = tableMap.get(relationship.table);
+      const targetTable = tableMap.get(relationship.referenced_table);
+      const sourceCount = sourceTable?.rowCount;
+      const targetCount = targetTable?.rowCount;
+      const ratio = sourceCount != null && targetCount != null && targetCount > 0 ? sourceCount / targetCount : null;
+      let cardinality = "each";
+      if (ratio != null) {
+        if (ratio > 5) {
+          cardinality = `many-to-one (\u2248${sourceCount} vs ${targetCount})`;
+        } else if (ratio < 1.2 && ratio > 0.8) {
+          cardinality = `roughly 1:1 (${sourceCount} vs ${targetCount})`;
+        } else if (ratio < 0.2) {
+          cardinality = `one-to-many (${sourceCount} vs ${targetCount})`;
+        }
+      }
+      const mappings = relationship.from.map((fromCol, idx) => {
+        const targetCol = relationship.to[idx] ?? relationship.to[0] ?? fromCol;
+        return `${relationship.table}.${fromCol} -> ${relationship.referenced_table}.${targetCol}`;
+      }).join(", ");
+      return `- ${relationship.table} (${relationship.from.join(", ")}) -> ${relationship.referenced_table} (${relationship.to.join(", ")}) [${cardinality}]`;
+    }).join("\n");
+  };
+};
+
+// packages/text2sql/src/lib/adapters/sqlserver/column-stats.sqlserver.grounding.ts
+var SqlServerColumnStatsGrounding = class extends ColumnStatsGrounding {
+  #adapter;
+  constructor(adapter, config = {}) {
+    super(config);
+    this.#adapter = adapter;
+  }
+  async collectStats(tableName, column) {
+    if (!this.#shouldCollectStats(column.type)) {
+      return void 0;
+    }
+    const { schema, table } = this.#adapter.parseTableName(tableName);
+    const tableIdentifier = `[${this.#adapter.escape(schema)}].[${this.#adapter.escape(table)}]`;
+    const columnIdentifier = `[${this.#adapter.escape(column.name)}]`;
+    const sql = `
+      SELECT
+        CAST(MIN(${columnIdentifier}) AS NVARCHAR(MAX)) AS min_value,
+        CAST(MAX(${columnIdentifier}) AS NVARCHAR(MAX)) AS max_value,
+        AVG(CASE WHEN ${columnIdentifier} IS NULL THEN 1.0 ELSE 0.0 END) AS null_fraction
+      FROM ${tableIdentifier}
+    `;
+    const rows = await this.#adapter.runQuery(sql);
+    if (!rows.length) {
+      return void 0;
+    }
+    const min = rows[0]?.min_value;
+    const max = rows[0]?.max_value;
+    const nullFraction = this.#adapter.toNumber(rows[0]?.null_fraction);
+    if (min == null && max == null && nullFraction == null) {
+      return void 0;
+    }
+    return {
+      min: min ?? void 0,
+      max: max ?? void 0,
+      nullFraction: nullFraction != null && Number.isFinite(nullFraction) ? Math.max(0, Math.min(1, nullFraction)) : void 0
+    };
+  }
+  #shouldCollectStats(type) {
+    if (!type) {
+      return false;
+    }
+    const normalized = type.toLowerCase();
+    return /int|real|numeric|float|decimal|date|time|bit|money/.test(
+      normalized
+    );
+  }
+};
+
+// packages/text2sql/src/lib/adapters/sqlserver/constraint.sqlserver.grounding.ts
+var SqlServerConstraintGrounding = class extends ConstraintGrounding {
+  #adapter;
+  constructor(adapter, config = {}) {
+    super(config);
+    this.#adapter = adapter;
+  }
+  async getConstraints(tableName) {
+    const { schema, table } = this.#adapter.parseTableName(tableName);
+    const constraints2 = [];
+    const pkRows = await this.#adapter.runQuery(`
+      SELECT
+        kc.name AS constraint_name,
+        COL_NAME(ic.object_id, ic.column_id) AS column_name
+      FROM sys.key_constraints kc
+      JOIN sys.index_columns ic ON kc.parent_object_id = ic.object_id AND kc.unique_index_id = ic.index_id
+      JOIN sys.tables t ON kc.parent_object_id = t.object_id
+      JOIN sys.schemas s ON t.schema_id = s.schema_id
+      WHERE s.name = '${this.#adapter.escapeString(schema)}'
+        AND t.name = '${this.#adapter.escapeString(table)}'
+        AND kc.type = 'PK'
+      ORDER BY ic.key_ordinal
+    `);
+    if (pkRows.length > 0) {
+      constraints2.push({
+        name: pkRows[0].constraint_name,
+        type: "PRIMARY_KEY",
+        columns: pkRows.map((r) => r.column_name)
+      });
+    }
+    const fkRows = await this.#adapter.runQuery(`
+      SELECT
+        fk.name AS constraint_name,
+        COL_NAME(fkc.parent_object_id, fkc.parent_column_id) AS column_name,
+        ref_s.name AS ref_schema,
+        ref_t.name AS ref_table,
+        COL_NAME(fkc.referenced_object_id, fkc.referenced_column_id) AS ref_column
+      FROM sys.foreign_keys fk
+      JOIN sys.foreign_key_columns fkc ON fk.object_id = fkc.constraint_object_id
+      JOIN sys.tables t ON fk.parent_object_id = t.object_id
+      JOIN sys.schemas s ON t.schema_id = s.schema_id
+      JOIN sys.tables ref_t ON fk.referenced_object_id = ref_t.object_id
+      JOIN sys.schemas ref_s ON ref_t.schema_id = ref_s.schema_id
+      WHERE s.name = '${this.#adapter.escapeString(schema)}'
+        AND t.name = '${this.#adapter.escapeString(table)}'
+      ORDER BY fk.name, fkc.constraint_column_id
+    `);
+    const fkMap = /* @__PURE__ */ new Map();
+    for (const row of fkRows) {
+      const existing = fkMap.get(row.constraint_name);
+      if (existing) {
+        existing.columns.push(row.column_name);
+        existing.refColumns.push(row.ref_column);
+      } else {
+        fkMap.set(row.constraint_name, {
+          columns: [row.column_name],
+          refSchema: row.ref_schema,
+          refTable: row.ref_table,
+          refColumns: [row.ref_column]
+        });
+      }
+    }
+    for (const [name, data] of fkMap) {
+      constraints2.push({
+        name,
+        type: "FOREIGN_KEY",
+        columns: data.columns,
+        referencedTable: `${data.refSchema}.${data.refTable}`,
+        referencedColumns: data.refColumns
+      });
+    }
+    const checkRows = await this.#adapter.runQuery(`
+      SELECT
+        cc.name AS constraint_name,
+        cc.definition
+      FROM sys.check_constraints cc
+      JOIN sys.tables t ON cc.parent_object_id = t.object_id
+      JOIN sys.schemas s ON t.schema_id = s.schema_id
+      WHERE s.name = '${this.#adapter.escapeString(schema)}'
+        AND t.name = '${this.#adapter.escapeString(table)}'
+    `);
+    for (const row of checkRows) {
+      constraints2.push({
+        name: row.constraint_name,
+        type: "CHECK",
+        definition: row.definition?.replace(/^\(/, "").replace(/\)$/, "")
+      });
+    }
+    const uniqueRows = await this.#adapter.runQuery(`
+      SELECT
+        i.name AS constraint_name,
+        COL_NAME(ic.object_id, ic.column_id) AS column_name
+      FROM sys.indexes i
+      JOIN sys.index_columns ic ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+      JOIN sys.tables t ON i.object_id = t.object_id
+      JOIN sys.schemas s ON t.schema_id = s.schema_id
+      WHERE s.name = '${this.#adapter.escapeString(schema)}'
+        AND t.name = '${this.#adapter.escapeString(table)}'
+        AND i.is_unique_constraint = 1
+      ORDER BY i.name, ic.key_ordinal
+    `);
+    const uniqueMap = /* @__PURE__ */ new Map();
+    for (const row of uniqueRows) {
+      const existing = uniqueMap.get(row.constraint_name);
+      if (existing) {
+        existing.push(row.column_name);
+      } else {
+        uniqueMap.set(row.constraint_name, [row.column_name]);
+      }
+    }
+    for (const [name, columns] of uniqueMap) {
+      constraints2.push({
+        name,
+        type: "UNIQUE",
+        columns
+      });
+    }
+    const columnRows = await this.#adapter.runQuery(`
+      SELECT
+        c.name AS column_name,
+        dc.definition AS default_definition,
+        c.is_nullable
+      FROM sys.columns c
+      JOIN sys.tables t ON c.object_id = t.object_id
+      JOIN sys.schemas s ON t.schema_id = s.schema_id
+      LEFT JOIN sys.default_constraints dc ON c.default_object_id = dc.object_id
+      WHERE s.name = '${this.#adapter.escapeString(schema)}'
+        AND t.name = '${this.#adapter.escapeString(table)}'
+    `);
+    const pkConstraint = constraints2.find((c) => c.type === "PRIMARY_KEY");
+    const pkColumns = new Set(pkConstraint?.columns ?? []);
+    for (const col of columnRows) {
+      if (col.is_nullable === 0 && !pkColumns.has(col.column_name)) {
+        constraints2.push({
+          name: `${table}_${col.column_name}_notnull`,
+          type: "NOT_NULL",
+          columns: [col.column_name]
+        });
+      }
+      if (col.default_definition != null) {
+        constraints2.push({
+          name: `${table}_${col.column_name}_default`,
+          type: "DEFAULT",
+          columns: [col.column_name],
+          defaultValue: col.default_definition.replace(/^\(/, "").replace(/\)$/, "")
+        });
+      }
+    }
+    return constraints2;
+  }
+};
+
+// packages/text2sql/src/lib/adapters/sqlserver/indexes.sqlserver.grounding.ts
+var SqlServerIndexesGrounding = class extends IndexesGrounding {
+  #adapter;
+  #schemas;
+  constructor(adapter, config = {}) {
+    super(config);
+    this.#adapter = adapter;
+    this.#schemas = config.schemas;
+  }
+  async getIndexes(tableName) {
+    const { schema, table } = this.#adapter.parseTableName(tableName);
+    const rows = await this.#adapter.runQuery(`
+      SELECT
+        i.name AS index_name,
+        COL_NAME(ic.object_id, ic.column_id) AS column_name,
+        i.is_unique,
+        i.type_desc AS index_type,
+        ic.key_ordinal
+      FROM sys.indexes i
+      JOIN sys.index_columns ic
+        ON i.object_id = ic.object_id
+        AND i.index_id = ic.index_id
+      JOIN sys.tables t
+        ON i.object_id = t.object_id
+      JOIN sys.schemas s
+        ON t.schema_id = s.schema_id
+      WHERE s.name = '${this.#adapter.escapeString(schema)}'
+        AND t.name = '${this.#adapter.escapeString(table)}'
+        AND i.name IS NOT NULL
+        AND ic.is_included_column = 0
+      ORDER BY i.name, ic.key_ordinal
+    `);
+    return this.#groupIndexes(rows);
+  }
+  #groupIndexes(rows) {
+    const indexes2 = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      if (!row.index_name || !row.column_name) continue;
+      const existing = indexes2.get(row.index_name);
+      if (existing) {
+        existing.columns.push(row.column_name);
+      } else {
+        indexes2.set(row.index_name, {
+          name: row.index_name,
+          columns: [row.column_name],
+          unique: row.is_unique,
+          type: row.index_type
+        });
+      }
+    }
+    return Array.from(indexes2.values());
+  }
+};
+
+// packages/text2sql/src/lib/adapters/sqlserver/info.sqlserver.grounding.ts
+var SqlServerInfoGrounding = class extends InfoGrounding {
+  #adapter;
+  constructor(adapter, config = {}) {
+    super(config);
+    this.#adapter = adapter;
+  }
+  async collectInfo() {
+    const [versionRows, dbRows] = await Promise.all([
+      this.#adapter.runQuery(
+        "SELECT @@VERSION AS version"
+      ),
+      this.#adapter.runQuery("SELECT DB_NAME() AS db")
+    ]);
+    return {
+      dialect: "sqlserver",
+      version: versionRows[0]?.version,
+      database: dbRows[0]?.db
+    };
+  }
+};
+
+// packages/text2sql/src/lib/adapters/sqlserver/low-cardinality.sqlserver.grounding.ts
+var LOW_CARDINALITY_LIMIT = 20;
+var SqlServerLowCardinalityGrounding = class extends LowCardinalityGrounding {
+  #adapter;
+  constructor(adapter, config = {}) {
+    super(config);
+    this.#adapter = adapter;
+  }
+  async collectLowCardinality(tableName, column) {
+    const { schema, table } = this.#adapter.parseTableName(tableName);
+    const tableIdentifier = `[${this.#adapter.escape(schema)}].[${this.#adapter.escape(table)}]`;
+    const columnIdentifier = `[${this.#adapter.escape(column.name)}]`;
+    const limit = LOW_CARDINALITY_LIMIT + 1;
+    const sql = `
+      SELECT DISTINCT TOP ${limit} CAST(${columnIdentifier} AS NVARCHAR(MAX)) AS value
+      FROM ${tableIdentifier}
+      WHERE ${columnIdentifier} IS NOT NULL
+    `;
+    const rows = await this.#adapter.runQuery(sql);
+    if (!rows.length || rows.length > LOW_CARDINALITY_LIMIT) {
+      return void 0;
+    }
+    const values = [];
+    for (const row of rows) {
+      if (row.value == null) {
+        return void 0;
+      }
+      values.push(row.value);
+    }
+    if (!values.length) {
+      return void 0;
+    }
+    return { kind: "LowCardinality", values };
+  }
+};
+
+// packages/text2sql/src/lib/adapters/sqlserver/row-count.sqlserver.grounding.ts
+var SqlServerRowCountGrounding = class extends RowCountGrounding {
+  #adapter;
+  constructor(adapter, config = {}) {
+    super(config);
+    this.#adapter = adapter;
+  }
+  async getRowCount(tableName) {
+    const { schema, table } = this.#adapter.parseTableName(tableName);
+    const tableIdentifier = `[${this.#adapter.escape(schema)}].[${this.#adapter.escape(table)}]`;
+    const rows = await this.#adapter.runQuery(
+      `SELECT COUNT(*) as count FROM ${tableIdentifier}`
+    );
+    return this.#adapter.toNumber(rows[0]?.count);
+  }
+};
+
+// packages/text2sql/src/lib/adapters/sqlserver/sqlserver.ts
+var SQL_SERVER_ERROR_MAP = {
+  "208": {
+    type: "MISSING_TABLE",
+    hint: "Check that the table exists and include the schema prefix (e.g., dbo.TableName)."
+  },
+  "207": {
+    type: "INVALID_COLUMN",
+    hint: "Verify the column exists on the table and that any aliases are referenced correctly."
+  },
+  "156": {
+    type: "SYNTAX_ERROR",
+    hint: "There is a SQL syntax error. Review keywords, punctuation, and clauses such as GROUP BY."
+  },
+  "4104": {
+    type: "INVALID_COLUMN",
+    hint: "Columns must be qualified with table aliases when ambiguous. Double-check join aliases."
+  },
+  "1934": {
+    type: "CONSTRAINT_ERROR",
+    hint: "The query violates a constraint. Re-check join logic and filtering."
+  }
+};
+var LOW_CARDINALITY_LIMIT2 = 20;
+function getErrorCode(error) {
+  if (typeof error === "object" && error !== null && "number" in error && typeof error.number === "number") {
+    return String(error.number);
+  }
+  if (typeof error === "object" && error !== null && "code" in error && typeof error.code === "string") {
+    return error.code;
+  }
+  return null;
+}
+function formatSqlServerError(sql, error) {
+  const errorMessage = error instanceof Error ? error.message : typeof error === "string" ? error : "Unknown error occurred";
+  const code = getErrorCode(error);
+  const metadata = code ? SQL_SERVER_ERROR_MAP[code] : void 0;
+  if (metadata) {
+    return {
+      error: errorMessage,
+      error_type: metadata.type,
+      suggestion: metadata.hint,
+      sql_attempted: sql
+    };
+  }
+  return {
+    error: errorMessage,
+    error_type: "UNKNOWN_ERROR",
+    suggestion: "Review the query and try again",
+    sql_attempted: sql
+  };
+}
+var SqlServer = class extends Adapter {
+  #options;
+  grounding;
+  defaultSchema = "dbo";
+  systemSchemas = ["INFORMATION_SCHEMA", "sys"];
+  constructor(options) {
+    super();
+    if (!options || typeof options.execute !== "function") {
+      throw new Error("SqlServer adapter requires an execute function.");
+    }
+    this.#options = {
+      ...options,
+      schemas: options.schemas?.length ? options.schemas : void 0
+    };
+    this.grounding = options.grounding;
+  }
+  async execute(sql) {
+    return this.#options.execute(sql);
+  }
+  async validate(sql) {
+    const validator = this.#options.validate ?? (async (text) => {
+      await this.#options.execute(
+        `SET PARSEONLY ON; ${text}; SET PARSEONLY OFF;`
+      );
+    });
+    try {
+      return await validator(sql);
+    } catch (error) {
+      return JSON.stringify(formatSqlServerError(sql, error));
+    }
+  }
+  async runQuery(sql) {
+    return this.#runIntrospectionQuery(sql);
+  }
+  quoteIdentifier(name) {
+    return `[${name.replace(/]/g, "]]")}]`;
+  }
+  escape(value) {
+    return value.replace(/]/g, "]]");
+  }
+  async #loadTables() {
+    const rows = await this.#runIntrospectionQuery(`
+      SELECT
+        c.TABLE_SCHEMA AS table_schema,
+        c.TABLE_NAME AS table_name,
+        c.COLUMN_NAME AS column_name,
+        c.DATA_TYPE AS data_type
+      FROM INFORMATION_SCHEMA.COLUMNS AS c
+      JOIN INFORMATION_SCHEMA.TABLES AS t
+        ON c.TABLE_SCHEMA = t.TABLE_SCHEMA
+        AND c.TABLE_NAME = t.TABLE_NAME
+      WHERE t.TABLE_TYPE = 'BASE TABLE'
+        ${this.#buildSchemaFilter("c.TABLE_SCHEMA")}
+      ORDER BY c.TABLE_SCHEMA, c.TABLE_NAME, c.ORDINAL_POSITION
+    `);
+    const tables2 = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      if (!row.table_name) {
+        continue;
+      }
+      const schema = row.table_schema ?? "dbo";
+      const tableName = row.table_name;
+      const qualifiedName = `${schema}.${tableName}`;
+      const table = tables2.get(qualifiedName) ?? {
+        name: qualifiedName,
+        schema,
+        rawName: tableName,
+        columns: []
+      };
+      table.columns.push({
+        name: row.column_name ?? "unknown",
+        type: row.data_type ?? "unknown"
+      });
+      tables2.set(qualifiedName, table);
+    }
+    return Array.from(tables2.values());
+  }
+  async #loadRelationships(filterTableNames) {
+    const tableFilter = this.#buildTableNamesFilter(filterTableNames);
+    const rows = await this.#runIntrospectionQuery(`
+      SELECT
+        fk.CONSTRAINT_NAME AS constraint_name,
+        fk.TABLE_SCHEMA AS table_schema,
+        fk.TABLE_NAME AS table_name,
+        fk.COLUMN_NAME AS column_name,
+        pk.TABLE_SCHEMA AS referenced_table_schema,
+        pk.TABLE_NAME AS referenced_table_name,
+        pk.COLUMN_NAME AS referenced_column_name
+      FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS AS rc
+      JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS fk
+        ON fk.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
+      JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS pk
+        ON pk.CONSTRAINT_NAME = rc.UNIQUE_CONSTRAINT_NAME
+        AND pk.ORDINAL_POSITION = fk.ORDINAL_POSITION
+      WHERE 1 = 1
+        ${this.#buildSchemaFilter("fk.TABLE_SCHEMA")}
+        ${tableFilter}
+      ORDER BY fk.TABLE_SCHEMA, fk.TABLE_NAME, fk.CONSTRAINT_NAME, fk.ORDINAL_POSITION
+    `);
+    const relationships = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      if (!row.constraint_name || !row.table_name || !row.referenced_table_name) {
+        continue;
+      }
+      const schema = row.table_schema ?? "dbo";
+      const referencedSchema = row.referenced_table_schema ?? "dbo";
+      const key = `${schema}.${row.table_name}:${row.constraint_name}`;
+      const relationship = relationships.get(key) ?? {
+        table: `${schema}.${row.table_name}`,
+        from: [],
+        referenced_table: `${referencedSchema}.${row.referenced_table_name}`,
+        to: []
+      };
+      relationship.from.push(row.column_name ?? "unknown");
+      relationship.to.push(row.referenced_column_name ?? "unknown");
+      relationships.set(key, relationship);
+    }
+    return Array.from(relationships.values());
+  }
+  async #annotateRowCounts(tables2, onProgress) {
+    const total = tables2.length;
+    for (let i = 0; i < tables2.length; i++) {
+      const table = tables2[i];
+      const tableIdentifier = this.#formatQualifiedTableName(table);
+      onProgress?.({
+        phase: "row_counts",
+        message: `Counting rows in ${table.name}...`,
+        current: i + 1,
+        total
+      });
+      try {
+        const rows = await this.#runIntrospectionQuery(`SELECT COUNT(*) as count FROM ${tableIdentifier}`);
+        const rowCount2 = this.#toNumber(rows[0]?.count);
+        if (rowCount2 != null) {
+          table.rowCount = rowCount2;
+          table.sizeHint = this.#classifyRowCount(rowCount2);
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  /**
+   * @deprecated Primary keys are now handled via constraints grounding.
+   * This method is kept for backward compatibility but does nothing.
+   */
+  async #annotatePrimaryKeys(_tables) {
+  }
+  async #annotateIndexes(tables2) {
+    if (!tables2.length) {
+      return;
+    }
+    const tableMap = new Map(tables2.map((table) => [table.name, table]));
+    const rows = await this.#runIntrospectionQuery(`
+      SELECT
+        sch.name AS schema_name,
+        t.name AS table_name,
+        ind.name AS index_name,
+        col.name AS column_name,
+        ind.is_unique,
+        ind.is_primary_key,
+        ind.type_desc,
+        ic.is_included_column
+      FROM sys.indexes AS ind
+      JOIN sys.tables AS t ON ind.object_id = t.object_id
+      JOIN sys.schemas AS sch ON t.schema_id = sch.schema_id
+      JOIN sys.index_columns AS ic
+        ON ind.object_id = ic.object_id
+        AND ind.index_id = ic.index_id
+      JOIN sys.columns AS col
+        ON ic.object_id = col.object_id
+        AND ic.column_id = col.column_id
+      WHERE ind.is_hypothetical = 0
+        AND ind.name IS NOT NULL
+        ${this.#buildSchemaFilter("sch.name")}
+      ORDER BY sch.name, t.name, ind.name, ic.key_ordinal
+    `);
+    const indexMap = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      if (!row.table_name || !row.index_name) {
+        continue;
+      }
+      const schema = row.schema_name ?? "dbo";
+      const tableKey = `${schema}.${row.table_name}`;
+      const table = tableMap.get(tableKey);
+      if (!table) {
+        continue;
+      }
+      const indexKey = `${tableKey}:${row.index_name}`;
+      let index = indexMap.get(indexKey);
+      if (!index) {
+        index = {
+          name: row.index_name,
+          columns: [],
+          unique: Boolean(row.is_unique),
+          type: row.type_desc ?? void 0
+        };
+        indexMap.set(indexKey, index);
+        if (!table.indexes) {
+          table.indexes = [];
+        }
+        table.indexes.push(index);
+      }
+      if (row.is_included_column) {
+        continue;
+      }
+      if (row.column_name) {
+        index.columns.push(row.column_name);
+        const column = table.columns.find(
+          (col) => col.name === row.column_name
+        );
+        if (column) {
+          column.isIndexed = true;
+        }
+      }
+    }
+  }
+  async #annotateColumnStats(tables2, onProgress) {
+    if (!tables2.length) {
+      return;
+    }
+    const total = tables2.length;
+    for (let i = 0; i < tables2.length; i++) {
+      const table = tables2[i];
+      const tableIdentifier = this.#formatQualifiedTableName(table);
+      onProgress?.({
+        phase: "column_stats",
+        message: `Collecting stats for ${table.name}...`,
+        current: i + 1,
+        total
+      });
+      for (const column of table.columns) {
+        if (!this.#shouldCollectStats(column.type)) {
+          continue;
+        }
+        const columnIdentifier = this.#quoteIdentifier(column.name);
+        const sql = `
+          SELECT
+            CONVERT(NVARCHAR(4000), MIN(${columnIdentifier})) AS min_value,
+            CONVERT(NVARCHAR(4000), MAX(${columnIdentifier})) AS max_value,
+            AVG(CASE WHEN ${columnIdentifier} IS NULL THEN 1.0 ELSE 0.0 END) AS null_fraction
+          FROM ${tableIdentifier}
+        `;
+        try {
+          const rows = await this.#runIntrospectionQuery(sql);
+          if (!rows.length) {
+            continue;
+          }
+          const nullFraction = this.#toNumber(rows[0]?.null_fraction);
+          if (rows[0]?.min_value != null || rows[0]?.max_value != null || nullFraction != null) {
+            column.stats = {
+              min: rows[0]?.min_value ?? void 0,
+              max: rows[0]?.max_value ?? void 0,
+              nullFraction: nullFraction != null && Number.isFinite(nullFraction) ? Math.max(0, Math.min(1, nullFraction)) : void 0
+            };
+          }
+        } catch {
+          continue;
+        }
+      }
+    }
+  }
+  async #annotateLowCardinalityColumns(tables2, onProgress) {
+    const total = tables2.length;
+    for (let i = 0; i < tables2.length; i++) {
+      const table = tables2[i];
+      const tableIdentifier = this.#formatQualifiedTableName(table);
+      onProgress?.({
+        phase: "low_cardinality",
+        message: `Analyzing cardinality in ${table.name}...`,
+        current: i + 1,
+        total
+      });
+      for (const column of table.columns) {
+        const columnIdentifier = this.#quoteIdentifier(column.name);
+        const limit = LOW_CARDINALITY_LIMIT2 + 1;
+        const sql = `
+          SELECT DISTINCT TOP (${limit}) ${columnIdentifier} AS value
+          FROM ${tableIdentifier}
+          WHERE ${columnIdentifier} IS NOT NULL
+        `;
+        let rows = [];
+        try {
+          rows = await this.#runIntrospectionQuery(sql);
+        } catch {
+          continue;
+        }
+        if (!rows.length || rows.length > LOW_CARDINALITY_LIMIT2) {
+          continue;
+        }
+        const values = [];
+        let shouldSkip = false;
+        for (const row of rows) {
+          const formatted = this.#normalizeValue(row.value);
+          if (formatted == null) {
+            shouldSkip = true;
+            break;
+          }
+          values.push(formatted);
+        }
+        if (shouldSkip || !values.length) {
+          continue;
+        }
+        column.kind = "LowCardinality";
+        column.values = values;
+      }
+    }
+  }
+  #buildSchemaFilter(columnName) {
+    if (this.#options.schemas && this.#options.schemas.length > 0) {
+      const values = this.#options.schemas.map((schema) => `'${schema.replace(/'/g, "''")}'`).join(", ");
+      return `AND ${columnName} IN (${values})`;
+    }
+    return `AND ${columnName} NOT IN ('INFORMATION_SCHEMA', 'sys')`;
+  }
+  /**
+   * Build a filter for table names (qualified as schema.table).
+   * Matches if either the source table or referenced table is in the list.
+   */
+  #buildTableNamesFilter(tableNames) {
+    if (!tableNames || tableNames.length === 0) {
+      return "";
+    }
+    const conditions = [];
+    for (const name of tableNames) {
+      const escaped = name.replace(/'/g, "''");
+      if (name.includes(".")) {
+        const [schema, ...rest] = name.split(".");
+        const tableName = rest.join(".");
+        const escapedSchema = schema.replace(/'/g, "''");
+        const escapedTable = tableName.replace(/'/g, "''");
+        conditions.push(
+          `(fk.TABLE_SCHEMA = '${escapedSchema}' AND fk.TABLE_NAME = '${escapedTable}')`
+        );
+        conditions.push(
+          `(pk.TABLE_SCHEMA = '${escapedSchema}' AND pk.TABLE_NAME = '${escapedTable}')`
+        );
+      } else {
+        conditions.push(`fk.TABLE_NAME = '${escaped}'`);
+        conditions.push(`pk.TABLE_NAME = '${escaped}'`);
+      }
+    }
+    return `AND (${conditions.join(" OR ")})`;
+  }
+  async #runIntrospectionQuery(sql) {
+    const result = await this.#options.execute(sql);
+    if (Array.isArray(result)) {
+      return result;
+    }
+    if (result && typeof result === "object") {
+      if ("rows" in result && Array.isArray(result.rows)) {
+        return result.rows;
+      }
+      if ("recordset" in result && Array.isArray(result.recordset)) {
+        return result.recordset;
+      }
+      if ("recordsets" in result && Array.isArray(result.recordsets) && Array.isArray(result.recordsets[0])) {
+        return result.recordsets[0];
+      }
+    }
+    throw new Error(
+      "SqlServer adapter execute() must return an array of rows or an object with rows/recordset properties when introspecting."
+    );
+  }
+  #quoteIdentifier(name) {
+    return `[${name.replace(/]/g, "]]")}]`;
+  }
+  #formatQualifiedTableName(table) {
+    if (table.schema && table.rawName) {
+      return `${this.#quoteIdentifier(table.schema)}.${this.#quoteIdentifier(table.rawName)}`;
+    }
+    if (table.name.includes(".")) {
+      const [schemaPart, ...rest] = table.name.split(".");
+      const tablePart = rest.join(".") || schemaPart;
+      if (rest.length === 0) {
+        return this.#quoteIdentifier(schemaPart);
+      }
+      return `${this.#quoteIdentifier(schemaPart)}.${this.#quoteIdentifier(tablePart)}`;
+    }
+    return this.#quoteIdentifier(table.name);
+  }
+  #toNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+    if (typeof value === "bigint") {
+      return Number(value);
+    }
+    if (typeof value === "string" && value.trim() !== "") {
+      const parsed = Number(value);
+      return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+  }
+  #classifyRowCount(count) {
+    if (count < 100) {
+      return "tiny";
+    }
+    if (count < 1e3) {
+      return "small";
+    }
+    if (count < 1e4) {
+      return "medium";
+    }
+    if (count < 1e5) {
+      return "large";
+    }
+    return "huge";
+  }
+  #shouldCollectStats(type) {
+    if (!type) {
+      return false;
+    }
+    const normalized = type.toLowerCase();
+    return /int|numeric|decimal|float|real|money|date|time|timestamp|bool/.test(
+      normalized
+    );
+  }
+  #normalizeValue(value) {
+    if (value === null || value === void 0) {
+      return null;
+    }
+    if (typeof value === "string") {
+      return value;
+    }
+    if (typeof value === "number" || typeof value === "bigint") {
+      return String(value);
+    }
+    if (typeof value === "boolean") {
+      return value ? "true" : "false";
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) {
+      return value.toString("utf-8");
+    }
+    return null;
+  }
+};
+
+// packages/text2sql/src/lib/adapters/sqlserver/table.sqlserver.grounding.ts
+var SqlServerTableGrounding = class extends TableGrounding {
+  #adapter;
+  #schemas;
+  constructor(adapter, config = {}) {
+    super(config);
+    this.#adapter = adapter;
+    this.#schemas = config.schemas;
+  }
+  async getAllTableNames() {
+    const rows = await this.#adapter.runQuery(`
+      SELECT TABLE_SCHEMA + '.' + TABLE_NAME AS name
+      FROM INFORMATION_SCHEMA.TABLES
+      WHERE TABLE_TYPE = 'BASE TABLE'
+        ${this.#adapter.buildSchemaFilter("TABLE_SCHEMA", this.#schemas)}
+      ORDER BY name
+    `);
+    return rows.map((r) => r.name);
+  }
+  async getTable(tableName) {
+    const { schema, table } = this.#adapter.parseTableName(tableName);
+    const columns = await this.#adapter.runQuery(`
+      SELECT COLUMN_NAME AS column_name, DATA_TYPE AS data_type
+      FROM INFORMATION_SCHEMA.COLUMNS
+      WHERE TABLE_SCHEMA = '${this.#adapter.escapeString(schema)}'
+        AND TABLE_NAME = '${this.#adapter.escapeString(table)}'
+      ORDER BY ORDINAL_POSITION
+    `);
+    return {
+      name: tableName,
+      schema,
+      rawName: table,
+      columns: columns.map((col) => ({
+        name: col.column_name ?? "unknown",
+        type: col.data_type ?? "unknown"
+      }))
+    };
+  }
+  async findOutgoingRelations(tableName) {
+    const { schema, table } = this.#adapter.parseTableName(tableName);
+    const rows = await this.#adapter.runQuery(`
+      SELECT
+        fk.CONSTRAINT_NAME AS constraint_name,
+        fk.TABLE_SCHEMA AS table_schema,
+        fk.TABLE_NAME AS table_name,
+        fk.COLUMN_NAME AS column_name,
+        pk.TABLE_SCHEMA AS referenced_table_schema,
+        pk.TABLE_NAME AS referenced_table_name,
+        pk.COLUMN_NAME AS referenced_column_name
+      FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS AS rc
+      JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS fk
+        ON fk.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
+      JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS pk
+        ON pk.CONSTRAINT_NAME = rc.UNIQUE_CONSTRAINT_NAME
+        AND pk.ORDINAL_POSITION = fk.ORDINAL_POSITION
+      WHERE fk.TABLE_SCHEMA = '${this.#adapter.escapeString(schema)}'
+        AND fk.TABLE_NAME = '${this.#adapter.escapeString(table)}'
+      ORDER BY fk.CONSTRAINT_NAME, fk.ORDINAL_POSITION
+    `);
+    return this.#groupRelationships(rows);
+  }
+  async findIncomingRelations(tableName) {
+    const { schema, table } = this.#adapter.parseTableName(tableName);
+    const rows = await this.#adapter.runQuery(`
+      SELECT
+        fk.CONSTRAINT_NAME AS constraint_name,
+        fk.TABLE_SCHEMA AS table_schema,
+        fk.TABLE_NAME AS table_name,
+        fk.COLUMN_NAME AS column_name,
+        pk.TABLE_SCHEMA AS referenced_table_schema,
+        pk.TABLE_NAME AS referenced_table_name,
+        pk.COLUMN_NAME AS referenced_column_name
+      FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS AS rc
+      JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS fk
+        ON fk.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
+      JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS pk
+        ON pk.CONSTRAINT_NAME = rc.UNIQUE_CONSTRAINT_NAME
+        AND pk.ORDINAL_POSITION = fk.ORDINAL_POSITION
+      WHERE pk.TABLE_SCHEMA = '${this.#adapter.escapeString(schema)}'
+        AND pk.TABLE_NAME = '${this.#adapter.escapeString(table)}'
+      ORDER BY fk.CONSTRAINT_NAME, fk.ORDINAL_POSITION
+    `);
+    return this.#groupRelationships(rows);
+  }
+  #groupRelationships(rows) {
+    const relationships = /* @__PURE__ */ new Map();
+    const defaultSchema = this.#adapter.defaultSchema ?? "dbo";
+    for (const row of rows) {
+      if (!row.constraint_name || !row.table_name || !row.referenced_table_name) {
+        continue;
+      }
+      const schema = row.table_schema ?? defaultSchema;
+      const referencedSchema = row.referenced_table_schema ?? defaultSchema;
+      const key = `${schema}.${row.table_name}:${row.constraint_name}`;
+      const relationship = relationships.get(key) ?? {
+        table: `${schema}.${row.table_name}`,
+        from: [],
+        referenced_table: `${referencedSchema}.${row.referenced_table_name}`,
+        to: []
+      };
+      relationship.from.push(row.column_name ?? "unknown");
+      relationship.to.push(row.referenced_column_name ?? "unknown");
+      relationships.set(key, relationship);
+    }
+    return Array.from(relationships.values());
+  }
+};
+
+// packages/text2sql/src/lib/adapters/groundings/view.grounding.ts
+var ViewGrounding = class extends AbstractGrounding {
+  #filter;
+  constructor(config = {}) {
+    super("views");
+    this.#filter = config.filter;
+  }
+  /**
+   * Execute the grounding process.
+   * Writes discovered views to the context.
+   */
+  async execute(ctx) {
+    const viewNames = await this.applyFilter();
+    const views2 = await Promise.all(
+      viewNames.map((name) => this.getView(name))
+    );
+    ctx.views.push(...views2);
+    return () => this.#describe(views2);
+  }
+  #describe(views2) {
+    if (!views2.length) {
+      return "No views available.";
+    }
+    return views2.map((view) => {
+      const columns = view.columns.map((column) => {
+        const annotations = [];
+        if (column.kind === "LowCardinality" && column.values?.length) {
+          annotations.push(`LowCardinality: ${column.values.join(", ")}`);
+        }
+        if (column.stats) {
+          const statParts = [];
+          if (column.stats.min != null || column.stats.max != null) {
+            const minText = column.stats.min ?? "n/a";
+            const maxText = column.stats.max ?? "n/a";
+            statParts.push(`range ${minText} \u2192 ${maxText}`);
+          }
+          if (column.stats.nullFraction != null && Number.isFinite(column.stats.nullFraction)) {
+            const percent = Math.round(column.stats.nullFraction * 1e3) / 10;
+            statParts.push(`null\u2248${percent}%`);
+          }
+          if (statParts.length) {
+            annotations.push(statParts.join(", "));
+          }
+        }
+        const annotationText = annotations.length ? ` [${annotations.join(", ")}]` : "";
+        return `    - ${column.name} (${column.type})${annotationText}`;
+      }).join("\n");
+      const definition = view.definition ? `
+  Definition: ${view.definition.length > 200 ? view.definition.slice(0, 200) + "..." : view.definition}` : "";
+      return `- View: ${view.name}${definition}
+  Columns:
+${columns}`;
+    }).join("\n\n");
+  }
+  /**
+   * Apply the filter to get view names.
+   * If filter is an explicit array, skip querying all view names.
+   */
+  async applyFilter() {
+    const filter = this.#filter;
+    if (Array.isArray(filter)) {
+      return filter;
+    }
+    const names = await this.getAllViewNames();
+    if (!filter) {
+      return names;
+    }
+    if (filter instanceof RegExp) {
+      return names.filter((name) => filter.test(name));
+    }
+    return names.filter(filter);
+  }
+};
+
+// packages/text2sql/src/lib/adapters/sqlserver/view.sqlserver.grounding.ts
+var SqlServerViewGrounding = class extends ViewGrounding {
+  #adapter;
+  #schemas;
+  constructor(adapter, config = {}) {
+    super(config);
+    this.#adapter = adapter;
+    this.#schemas = config.schemas;
+  }
+  async getAllViewNames() {
+    const rows = await this.#adapter.runQuery(`
+      SELECT TABLE_SCHEMA + '.' + TABLE_NAME AS name
+      FROM INFORMATION_SCHEMA.VIEWS
+      WHERE 1=1
+        ${this.#adapter.buildSchemaFilter("TABLE_SCHEMA", this.#schemas)}
+      ORDER BY name
+    `);
+    return rows.map((r) => r.name);
+  }
+  async getView(viewName) {
+    const { schema, table: view } = this.#adapter.parseTableName(viewName);
+    const defRows = await this.#adapter.runQuery(`
+      SELECT m.definition
+      FROM sys.views v
+      JOIN sys.schemas s ON v.schema_id = s.schema_id
+      JOIN sys.sql_modules m ON v.object_id = m.object_id
+      WHERE s.name = '${this.#adapter.escapeString(schema)}'
+        AND v.name = '${this.#adapter.escapeString(view)}'
+    `);
+    const columns = await this.#adapter.runQuery(`
+      SELECT COLUMN_NAME AS column_name, DATA_TYPE AS data_type
+      FROM INFORMATION_SCHEMA.COLUMNS
+      WHERE TABLE_SCHEMA = '${this.#adapter.escapeString(schema)}'
+        AND TABLE_NAME = '${this.#adapter.escapeString(view)}'
+      ORDER BY ORDINAL_POSITION
+    `);
+    return {
+      name: viewName,
+      schema,
+      rawName: view,
+      definition: defRows[0]?.definition ?? void 0,
+      columns: columns.map((col) => ({
+        name: col.column_name ?? "unknown",
+        type: col.data_type ?? "unknown"
+      }))
+    };
+  }
+};
+
+// packages/text2sql/src/lib/adapters/sqlserver/index.ts
+function tables(config = {}) {
+  return (adapter) => new SqlServerTableGrounding(adapter, config);
+}
+function info(config = {}) {
+  return (adapter) => new SqlServerInfoGrounding(adapter, config);
+}
+function views(config = {}) {
+  return (adapter) => {
+    return new SqlServerViewGrounding(adapter, config);
+  };
+}
+function columnStats(config = {}) {
+  return (adapter) => {
+    return new SqlServerColumnStatsGrounding(adapter, config);
+  };
+}
+function lowCardinality(config = {}) {
+  return (adapter) => {
+    return new SqlServerLowCardinalityGrounding(adapter, config);
+  };
+}
+function indexes(config = {}) {
+  return (adapter) => {
+    return new SqlServerIndexesGrounding(adapter, config);
+  };
+}
+function rowCount(config = {}) {
+  return (adapter) => {
+    return new SqlServerRowCountGrounding(adapter, config);
+  };
+}
+function constraints(config = {}) {
+  return (adapter) => {
+    return new SqlServerConstraintGrounding(adapter, config);
+  };
+}
+function report(config = {}) {
+  return (adapter) => new ReportGrounding(adapter, config);
+}
+var sqlserver_default = {
+  tables,
+  info,
+  views,
+  columnStats,
+  lowCardinality,
+  indexes,
+  rowCount,
+  constraints,
+  report,
+  SqlServer
+};
+export {
+  SqlServer,
+  columnStats,
+  constraints,
+  sqlserver_default as default,
+  formatSqlServerError,
+  indexes,
+  info,
+  lowCardinality,
+  report,
+  rowCount,
+  tables,
+  views
+};
+//# sourceMappingURL=index.js.map