@deepagents/text2sql 0.14.0 → 0.16.0

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

@@ -1,3 +1,6 @@
+// packages/text2sql/src/lib/adapters/adapter.ts
+import { format as formatSql } from "sql-formatter";
+
 // packages/text2sql/src/lib/fragments/schema.ts
 function dialectInfo(input) {
   return {
@@ -265,6 +268,13 @@ var Adapter = class {
       cardinality
     });
   }
+  format(sql) {
+    try {
+      return formatSql(sql, { language: this.formatterLanguage });
+    } catch {
+      return sql;
+    }
+  }
   /**
    * Convert unknown database value to number.
    * Handles number, bigint, and string types.
@@ -397,2221 +407,174 @@ var IndexesGrounding = class extends AbstractGrounding {
           if (column2) {
             column2.isIndexed = true;
           }
-        }
-      }
-    }
-  }
-};
-
-// packages/text2sql/src/lib/adapters/groundings/info.grounding.ts
-var InfoGrounding = class extends AbstractGrounding {
-  constructor(config = {}) {
-    super("dialectInfo");
-  }
-  /**
-   * Execute the grounding process.
-   * Writes database info to ctx.info.
-   */
-  async execute(ctx) {
-    ctx.info = await this.collectInfo();
-  }
-};
-
-// packages/text2sql/src/lib/adapters/groundings/column-values.grounding.ts
-var ColumnValuesGrounding = class extends AbstractGrounding {
-  lowCardinalityLimit;
-  constructor(config = {}) {
-    super("columnValues");
-    this.lowCardinalityLimit = config.lowCardinalityLimit ?? 20;
-  }
-  /**
-   * Get values for native ENUM type columns.
-   * Return undefined if column is not an ENUM type.
-   * Default implementation returns undefined (no native ENUM support).
-   */
-  async collectEnumValues(_tableName, _column) {
-    return void 0;
-  }
-  /**
-   * Parse CHECK constraint for enum-like IN clause.
-   * Extracts values from patterns like:
-   * - CHECK (status IN ('active', 'inactive'))
-   * - CHECK ((status)::text = ANY (ARRAY['a'::text, 'b'::text]))
-   * - CHECK (status = 'active' OR status = 'inactive')
-   */
-  parseCheckConstraint(constraint2, columnName) {
-    if (constraint2.type !== "CHECK" || !constraint2.definition) {
-      return void 0;
-    }
-    if (constraint2.columns && !constraint2.columns.includes(columnName)) {
-      return void 0;
-    }
-    const def = constraint2.definition;
-    const escapedCol = this.escapeRegex(columnName);
-    const colPattern = `(?:\\(?\\(?${escapedCol}\\)?(?:::(?:text|varchar|character varying))?\\)?)`;
-    const inMatch = def.match(
-      new RegExp(`${colPattern}\\s+IN\\s*\\(([^)]+)\\)`, "i")
-    );
-    if (inMatch) {
-      return this.extractStringValues(inMatch[1]);
-    }
-    const anyMatch = def.match(
-      new RegExp(
-        `${colPattern}\\s*=\\s*ANY\\s*\\(\\s*(?:ARRAY)?\\s*\\[([^\\]]+)\\]`,
-        "i"
-      )
-    );
-    if (anyMatch) {
-      return this.extractStringValues(anyMatch[1]);
-    }
-    const orPattern = new RegExp(
-      `\\b${this.escapeRegex(columnName)}\\b\\s*=\\s*'([^']*)'`,
-      "gi"
-    );
-    const orMatches = [...def.matchAll(orPattern)];
-    if (orMatches.length >= 2) {
-      return orMatches.map((m) => m[1]);
-    }
-    return void 0;
-  }
-  /**
-   * Extract string values from a comma-separated list.
-   */
-  extractStringValues(input) {
-    const values = [];
-    const matches = input.matchAll(/'([^']*)'/g);
-    for (const match of matches) {
-      values.push(match[1]);
-    }
-    return values.length > 0 ? values : void 0;
-  }
-  /**
-   * Escape special regex characters in a string.
-   */
-  escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  }
-  /**
-   * Get the table from context by name.
-   */
-  getTable(ctx, name) {
-    return ctx.tables.find((t) => t.name === name);
-  }
-  /**
-   * Execute the grounding process.
-   * Annotates columns in ctx.tables and ctx.views with values.
-   */
-  async execute(ctx) {
-    const allContainers = [...ctx.tables, ...ctx.views];
-    for (const container of allContainers) {
-      const table2 = this.getTable(ctx, container.name);
-      for (const column2 of container.columns) {
-        try {
-          const result = await this.resolveColumnValues(
-            container.name,
-            column2,
-            table2?.constraints
-          );
-          if (result) {
-            column2.kind = result.kind;
-            column2.values = result.values;
-          }
-        } catch (error) {
-          console.warn(
-            "Error collecting column values for",
-            container.name,
-            column2.name,
-            error
-          );
-        }
-      }
-    }
-  }
-  /**
-   * Resolve column values from all sources in priority order.
-   */
-  async resolveColumnValues(tableName, column2, constraints2) {
-    const enumValues = await this.collectEnumValues(tableName, column2);
-    if (enumValues?.length) {
-      return { kind: "Enum", values: enumValues };
-    }
-    if (constraints2) {
-      for (const constraint2 of constraints2) {
-        const checkValues = this.parseCheckConstraint(constraint2, column2.name);
-        if (checkValues?.length) {
-          return { kind: "Enum", values: checkValues };
-        }
-      }
-    }
-    const lowCardValues = await this.collectLowCardinality(tableName, column2);
-    if (lowCardValues?.length) {
-      return { kind: "LowCardinality", values: lowCardValues };
-    }
-    return void 0;
-  }
-};
-
-// packages/text2sql/src/lib/adapters/groundings/report.grounding.ts
-import { groq as groq2 } from "@ai-sdk/groq";
-import { tool } from "ai";
-import dedent2 from "dedent";
-import z from "zod";
-import "@deepagents/agent";
-
-// packages/context/dist/index.js
-import { mergeWith } from "lodash-es";
-import { encode } from "gpt-tokenizer";
-import { generateId } from "ai";
-import pluralize from "pluralize";
-import { titlecase } from "stringcase";
-import chalk from "chalk";
-import { defineCommand } from "just-bash";
-import spawn from "nano-spawn";
-import "bash-tool";
-import spawn2 from "nano-spawn";
-import {
-  createBashTool
-} from "bash-tool";
-import dedent from "dedent";
-import YAML from "yaml";
-import { DatabaseSync } from "node:sqlite";
-import { groq } from "@ai-sdk/groq";
-import {
-  NoSuchToolError,
-  Output,
-  convertToModelMessages,
-  createUIMessageStream,
-  generateId as generateId2,
-  generateText,
-  smoothStream,
-  stepCountIs,
-  streamText
-} from "ai";
-import chalk2 from "chalk";
-import "zod";
-import "@deepagents/agent";
-var defaultTokenizer = {
-  encode(text) {
-    return encode(text);
-  },
-  count(text) {
-    return encode(text).length;
-  }
-};
-var ModelsRegistry = class {
-  #cache = /* @__PURE__ */ new Map();
-  #loaded = false;
-  #tokenizers = /* @__PURE__ */ new Map();
-  #defaultTokenizer = defaultTokenizer;
-  /**
-   * Load models data from models.dev API
-   */
-  async load() {
-    if (this.#loaded) return;
-    const response = await fetch("https://models.dev/api.json");
-    if (!response.ok) {
-      throw new Error(`Failed to fetch models: ${response.statusText}`);
-    }
-    const data = await response.json();
-    for (const [providerId, provider] of Object.entries(data)) {
-      for (const [modelId, model] of Object.entries(provider.models)) {
-        const info2 = {
-          id: model.id,
-          name: model.name,
-          family: model.family,
-          cost: model.cost,
-          limit: model.limit,
-          provider: providerId
-        };
-        this.#cache.set(`${providerId}:${modelId}`, info2);
-      }
-    }
-    this.#loaded = true;
-  }
-  /**
-   * Get model info by ID
-   * @param modelId - Model ID (e.g., "openai:gpt-4o")
-   */
-  get(modelId) {
-    return this.#cache.get(modelId);
-  }
-  /**
-   * Check if a model exists in the registry
-   */
-  has(modelId) {
-    return this.#cache.has(modelId);
-  }
-  /**
-   * List all available model IDs
-   */
-  list() {
-    return [...this.#cache.keys()];
-  }
-  /**
-   * Register a custom tokenizer for specific model families
-   * @param family - Model family name (e.g., "llama", "claude")
-   * @param tokenizer - Tokenizer implementation
-   */
-  registerTokenizer(family, tokenizer) {
-    this.#tokenizers.set(family, tokenizer);
-  }
-  /**
-   * Set the default tokenizer used when no family-specific tokenizer is registered
-   */
-  setDefaultTokenizer(tokenizer) {
-    this.#defaultTokenizer = tokenizer;
-  }
-  /**
-   * Get the appropriate tokenizer for a model
-   */
-  getTokenizer(modelId) {
-    const model = this.get(modelId);
-    if (model) {
-      const familyTokenizer = this.#tokenizers.get(model.family);
-      if (familyTokenizer) {
-        return familyTokenizer;
-      }
-    }
-    return this.#defaultTokenizer;
-  }
-  /**
-   * Estimate token count and cost for given text and model
-   * @param modelId - Model ID to use for pricing (e.g., "openai:gpt-4o")
-   * @param input - Input text (prompt)
-   */
-  estimate(modelId, input) {
-    const model = this.get(modelId);
-    if (!model) {
-      throw new Error(
-        `Model "${modelId}" not found. Call load() first or check model ID.`
-      );
-    }
-    const tokenizer = this.getTokenizer(modelId);
-    const tokens = tokenizer.count(input);
-    const cost = tokens / 1e6 * model.cost.input;
-    return {
-      model: model.id,
-      provider: model.provider,
-      tokens,
-      cost,
-      limits: {
-        context: model.limit.context,
-        output: model.limit.output,
-        exceedsContext: tokens > model.limit.context
-      },
-      fragments: []
-    };
-  }
-};
-var _registry = null;
-function getModelsRegistry() {
-  if (!_registry) {
-    _registry = new ModelsRegistry();
-  }
-  return _registry;
-}
-function isFragment(data) {
-  return typeof data === "object" && data !== null && "name" in data && "data" in data && typeof data.name === "string";
-}
-function isFragmentObject(data) {
-  return typeof data === "object" && data !== null && !Array.isArray(data) && !isFragment(data);
-}
-function isMessageFragment(fragment2) {
-  return fragment2.type === "message";
-}
-function fragment(name, ...children) {
-  return {
-    name,
-    data: children
-  };
-}
-function user(content) {
-  const message2 = typeof content === "string" ? {
-    id: generateId(),
-    role: "user",
-    parts: [{ type: "text", text: content }]
-  } : content;
-  return {
-    id: message2.id,
-    name: "user",
-    data: "content",
-    type: "message",
-    persist: true,
-    codec: {
-      decode() {
-        return message2;
-      },
-      encode() {
-        return message2;
-      }
-    }
-  };
-}
-function assistant(message2) {
-  return {
-    id: message2.id,
-    name: "assistant",
-    data: "content",
-    type: "message",
-    persist: true,
-    codec: {
-      decode() {
-        return message2;
-      },
-      encode() {
-        return message2;
-      }
-    }
-  };
-}
-function message(content) {
-  const message2 = typeof content === "string" ? {
-    id: generateId(),
-    role: "user",
-    parts: [{ type: "text", text: content }]
-  } : content;
-  return {
-    id: message2.id,
-    name: message2.role,
-    data: "content",
-    type: "message",
-    persist: true,
-    codec: {
-      decode() {
-        return message2;
-      },
-      encode() {
-        return message2;
-      }
-    }
-  };
-}
-function assistantText(content, options) {
-  const id = options?.id ?? crypto.randomUUID();
-  return assistant({
-    id,
-    role: "assistant",
-    parts: [{ type: "text", text: content }]
-  });
-}
-var LAZY_ID = Symbol.for("@deepagents/context:lazy-id");
-function isLazyFragment(fragment2) {
-  return LAZY_ID in fragment2;
-}
-function lastAssistantMessage(content) {
-  return {
-    name: "assistant",
-    type: "message",
-    persist: true,
-    data: "content",
-    [LAZY_ID]: {
-      type: "last-assistant",
-      content
-    }
-  };
-}
-var ContextRenderer = class {
-  options;
-  constructor(options = {}) {
-    this.options = options;
-  }
-  /**
-   * Check if data is a primitive (string, number, boolean).
-   */
-  isPrimitive(data) {
-    return typeof data === "string" || typeof data === "number" || typeof data === "boolean";
-  }
-  /**
-   * Group fragments by name for groupFragments option.
-   */
-  groupByName(fragments) {
-    const groups = /* @__PURE__ */ new Map();
-    for (const fragment2 of fragments) {
-      const existing = groups.get(fragment2.name) ?? [];
-      existing.push(fragment2);
-      groups.set(fragment2.name, existing);
-    }
-    return groups;
-  }
-  /**
-   * Remove null/undefined from fragments and fragment data recursively.
-   * This protects renderers from nullish values and ensures they are ignored
-   * consistently across all output formats.
-   */
-  sanitizeFragments(fragments) {
-    const sanitized = [];
-    for (const fragment2 of fragments) {
-      const cleaned = this.sanitizeFragment(fragment2, /* @__PURE__ */ new WeakSet());
-      if (cleaned) {
-        sanitized.push(cleaned);
-      }
-    }
-    return sanitized;
-  }
-  sanitizeFragment(fragment2, seen) {
-    const data = this.sanitizeData(fragment2.data, seen);
-    if (data == null) {
-      return null;
-    }
-    return {
-      ...fragment2,
-      data
-    };
-  }
-  sanitizeData(data, seen) {
-    if (data == null) {
-      return void 0;
-    }
-    if (isFragment(data)) {
-      return this.sanitizeFragment(data, seen) ?? void 0;
-    }
-    if (Array.isArray(data)) {
-      if (seen.has(data)) {
-        return void 0;
-      }
-      seen.add(data);
-      const cleaned = [];
-      for (const item of data) {
-        const sanitizedItem = this.sanitizeData(item, seen);
-        if (sanitizedItem != null) {
-          cleaned.push(sanitizedItem);
-        }
-      }
-      return cleaned;
-    }
-    if (isFragmentObject(data)) {
-      if (seen.has(data)) {
-        return void 0;
-      }
-      seen.add(data);
-      const cleaned = {};
-      for (const [key, value] of Object.entries(data)) {
-        const sanitizedValue = this.sanitizeData(value, seen);
-        if (sanitizedValue != null) {
-          cleaned[key] = sanitizedValue;
-        }
-      }
-      return cleaned;
-    }
-    return data;
-  }
-  /**
-   * Template method - dispatches value to appropriate handler.
-   */
-  renderValue(key, value, ctx) {
-    if (value == null) {
-      return "";
-    }
-    if (isFragment(value)) {
-      return this.renderFragment(value, ctx);
-    }
-    if (Array.isArray(value)) {
-      return this.renderArray(key, value, ctx);
-    }
-    if (isFragmentObject(value)) {
-      return this.renderObject(key, value, ctx);
-    }
-    return this.renderPrimitive(key, String(value), ctx);
-  }
-  /**
-   * Render all entries of an object.
-   */
-  renderEntries(data, ctx) {
-    return Object.entries(data).map(([key, value]) => this.renderValue(key, value, ctx)).filter(Boolean);
-  }
-};
-var XmlRenderer = class extends ContextRenderer {
-  render(fragments) {
-    const sanitized = this.sanitizeFragments(fragments);
-    return sanitized.map((f) => this.#renderTopLevel(f)).filter(Boolean).join("\n");
-  }
-  #renderTopLevel(fragment2) {
-    if (this.isPrimitive(fragment2.data)) {
-      return this.#leafRoot(fragment2.name, String(fragment2.data));
-    }
-    if (Array.isArray(fragment2.data)) {
-      return this.#renderArray(fragment2.name, fragment2.data, 0);
-    }
-    if (isFragment(fragment2.data)) {
-      const child = this.renderFragment(fragment2.data, { depth: 1, path: [] });
-      return this.#wrap(fragment2.name, [child]);
-    }
-    if (isFragmentObject(fragment2.data)) {
-      return this.#wrap(
-        fragment2.name,
-        this.renderEntries(fragment2.data, { depth: 1, path: [] })
-      );
-    }
-    return "";
-  }
-  #renderArray(name, items, depth) {
-    const fragmentItems = items.filter(isFragment);
-    const nonFragmentItems = items.filter((item) => !isFragment(item));
-    const children = [];
-    for (const item of nonFragmentItems) {
-      if (item != null) {
-        if (isFragmentObject(item)) {
-          children.push(
-            this.#wrapIndented(
-              pluralize.singular(name),
-              this.renderEntries(item, { depth: depth + 2, path: [] }),
-              depth + 1
-            )
-          );
-        } else {
-          children.push(
-            this.#leaf(pluralize.singular(name), String(item), depth + 1)
-          );
-        }
-      }
-    }
-    if (this.options.groupFragments && fragmentItems.length > 0) {
-      const groups = this.groupByName(fragmentItems);
-      for (const [groupName, groupFragments] of groups) {
-        const groupChildren = groupFragments.map(
-          (frag) => this.renderFragment(frag, { depth: depth + 2, path: [] })
-        );
-        const pluralName = pluralize.plural(groupName);
-        children.push(this.#wrapIndented(pluralName, groupChildren, depth + 1));
-      }
-    } else {
-      for (const frag of fragmentItems) {
-        children.push(
-          this.renderFragment(frag, { depth: depth + 1, path: [] })
-        );
-      }
-    }
-    return this.#wrap(name, children);
-  }
-  #leafRoot(tag, value) {
-    const safe = this.#escape(value);
-    if (safe.includes("\n")) {
-      return `<${tag}>
-${this.#indent(safe, 2)}
-</${tag}>`;
-    }
-    return `<${tag}>${safe}</${tag}>`;
-  }
-  renderFragment(fragment2, ctx) {
-    const { name, data } = fragment2;
-    if (this.isPrimitive(data)) {
-      return this.#leaf(name, String(data), ctx.depth);
-    }
-    if (isFragment(data)) {
-      const child = this.renderFragment(data, { ...ctx, depth: ctx.depth + 1 });
-      return this.#wrapIndented(name, [child], ctx.depth);
-    }
-    if (Array.isArray(data)) {
-      return this.#renderArrayIndented(name, data, ctx.depth);
-    }
-    if (isFragmentObject(data)) {
-      const children = this.renderEntries(data, {
-        ...ctx,
-        depth: ctx.depth + 1
-      });
-      return this.#wrapIndented(name, children, ctx.depth);
-    }
-    return "";
-  }
-  #renderArrayIndented(name, items, depth) {
-    const fragmentItems = items.filter(isFragment);
-    const nonFragmentItems = items.filter((item) => !isFragment(item));
-    const children = [];
-    for (const item of nonFragmentItems) {
-      if (item != null) {
-        if (isFragmentObject(item)) {
-          children.push(
-            this.#wrapIndented(
-              pluralize.singular(name),
-              this.renderEntries(item, { depth: depth + 2, path: [] }),
-              depth + 1
-            )
-          );
-        } else {
-          children.push(
-            this.#leaf(pluralize.singular(name), String(item), depth + 1)
-          );
-        }
-      }
-    }
-    if (this.options.groupFragments && fragmentItems.length > 0) {
-      const groups = this.groupByName(fragmentItems);
-      for (const [groupName, groupFragments] of groups) {
-        const groupChildren = groupFragments.map(
-          (frag) => this.renderFragment(frag, { depth: depth + 2, path: [] })
-        );
-        const pluralName = pluralize.plural(groupName);
-        children.push(this.#wrapIndented(pluralName, groupChildren, depth + 1));
-      }
-    } else {
-      for (const frag of fragmentItems) {
-        children.push(
-          this.renderFragment(frag, { depth: depth + 1, path: [] })
-        );
-      }
-    }
-    return this.#wrapIndented(name, children, depth);
-  }
-  renderPrimitive(key, value, ctx) {
-    return this.#leaf(key, value, ctx.depth);
-  }
-  renderArray(key, items, ctx) {
-    if (!items.length) {
-      return "";
-    }
-    const itemTag = pluralize.singular(key);
-    const children = items.filter((item) => item != null).map((item) => {
-      if (isFragment(item)) {
-        return this.renderFragment(item, { ...ctx, depth: ctx.depth + 1 });
-      }
-      if (isFragmentObject(item)) {
-        return this.#wrapIndented(
-          itemTag,
-          this.renderEntries(item, { ...ctx, depth: ctx.depth + 2 }),
-          ctx.depth + 1
-        );
-      }
-      return this.#leaf(itemTag, String(item), ctx.depth + 1);
-    });
-    return this.#wrapIndented(key, children, ctx.depth);
-  }
-  renderObject(key, obj, ctx) {
-    const children = this.renderEntries(obj, { ...ctx, depth: ctx.depth + 1 });
-    return this.#wrapIndented(key, children, ctx.depth);
-  }
-  #escape(value) {
-    if (value == null) {
-      return "";
-    }
-    return value.replaceAll(/&/g, "&amp;").replaceAll(/</g, "&lt;").replaceAll(/>/g, "&gt;").replaceAll(/"/g, "&quot;").replaceAll(/'/g, "&apos;");
-  }
-  #indent(text, spaces) {
-    if (!text.trim()) {
-      return "";
-    }
-    const padding = " ".repeat(spaces);
-    return text.split("\n").map((line) => line.length ? padding + line : padding).join("\n");
-  }
-  #leaf(tag, value, depth) {
-    const safe = this.#escape(value);
-    const pad = "  ".repeat(depth);
-    if (safe.includes("\n")) {
-      return `${pad}<${tag}>
-${this.#indent(safe, (depth + 1) * 2)}
-${pad}</${tag}>`;
-    }
-    return `${pad}<${tag}>${safe}</${tag}>`;
-  }
-  #wrap(tag, children) {
-    const content = children.filter(Boolean).join("\n");
-    if (!content) {
-      return "";
-    }
-    return `<${tag}>
-${content}
-</${tag}>`;
-  }
-  #wrapIndented(tag, children, depth) {
-    const content = children.filter(Boolean).join("\n");
-    if (!content) {
-      return "";
-    }
-    const pad = "  ".repeat(depth);
-    return `${pad}<${tag}>
-${content}
-${pad}</${tag}>`;
-  }
-};
-var ContextStore = class {
-};
-var ContextEngine = class {
-  /** Non-message fragments (role, hints, etc.) - not persisted in graph */
-  #fragments = [];
-  /** Pending message fragments to be added to graph */
-  #pendingMessages = [];
-  #store;
-  #chatId;
-  #userId;
-  #branchName;
-  #branch = null;
-  #chatData = null;
-  #initialized = false;
-  /** Initial metadata to merge on first initialization */
-  #initialMetadata;
-  constructor(options) {
-    if (!options.chatId) {
-      throw new Error("chatId is required");
-    }
-    if (!options.userId) {
-      throw new Error("userId is required");
-    }
-    this.#store = options.store;
-    this.#chatId = options.chatId;
-    this.#userId = options.userId;
-    this.#branchName = "main";
-    this.#initialMetadata = options.metadata;
-  }
-  /**
-   * Initialize the chat and branch if they don't exist.
-   */
-  async #ensureInitialized() {
-    if (this.#initialized) {
-      return;
-    }
-    this.#chatData = await this.#store.upsertChat({
-      id: this.#chatId,
-      userId: this.#userId
-    });
-    if (this.#initialMetadata) {
-      this.#chatData = await this.#store.updateChat(this.#chatId, {
-        metadata: {
-          ...this.#chatData.metadata,
-          ...this.#initialMetadata
-        }
-      });
-      this.#initialMetadata = void 0;
-    }
-    this.#branch = await this.#store.getActiveBranch(this.#chatId);
-    this.#initialized = true;
-  }
-  /**
-   * Create a new branch from a specific message.
-   * Shared logic between rewind() and btw().
-   */
-  async #createBranchFrom(messageId, switchTo) {
-    const branches = await this.#store.listBranches(this.#chatId);
-    const samePrefix = branches.filter(
-      (it) => it.name === this.#branchName || it.name.startsWith(`${this.#branchName}-v`)
-    );
-    const newBranchName = `${this.#branchName}-v${samePrefix.length + 1}`;
-    const newBranch = {
-      id: crypto.randomUUID(),
-      chatId: this.#chatId,
-      name: newBranchName,
-      headMessageId: messageId,
-      isActive: false,
-      createdAt: Date.now()
-    };
-    await this.#store.createBranch(newBranch);
-    if (switchTo) {
-      await this.#store.setActiveBranch(this.#chatId, newBranch.id);
-      this.#branch = { ...newBranch, isActive: true };
-      this.#branchName = newBranchName;
-      this.#pendingMessages = [];
-    }
-    const chain = await this.#store.getMessageChain(messageId);
-    return {
-      id: newBranch.id,
-      name: newBranch.name,
-      headMessageId: newBranch.headMessageId,
-      isActive: switchTo,
-      messageCount: chain.length,
-      createdAt: newBranch.createdAt
-    };
-  }
-  /**
-   * Rewind to a message without clearing pending messages.
-   * Used internally when saving an update to an existing message.
-   */
-  async #rewindForUpdate(messageId) {
-    const pendingBackup = [...this.#pendingMessages];
-    await this.rewind(messageId);
-    this.#pendingMessages = pendingBackup;
-  }
-  /**
-   * Get the current chat ID.
-   */
-  get chatId() {
-    return this.#chatId;
-  }
-  /**
-   * Get the current branch name.
-   */
-  get branch() {
-    return this.#branchName;
-  }
-  /**
-   * Get metadata for the current chat.
-   * Returns null if the chat hasn't been initialized yet.
-   */
-  get chat() {
-    if (!this.#chatData) {
-      return null;
-    }
-    return {
-      id: this.#chatData.id,
-      userId: this.#chatData.userId,
-      createdAt: this.#chatData.createdAt,
-      updatedAt: this.#chatData.updatedAt,
-      title: this.#chatData.title,
-      metadata: this.#chatData.metadata
-    };
-  }
-  /**
-   * Add fragments to the context.
-   *
-   * - Message fragments (user/assistant) are queued for persistence
-   * - Non-message fragments (role/hint) are kept in memory for system prompt
-   */
-  set(...fragments) {
-    for (const fragment2 of fragments) {
-      if (isMessageFragment(fragment2)) {
-        this.#pendingMessages.push(fragment2);
-      } else {
-        this.#fragments.push(fragment2);
-      }
-    }
-    return this;
-  }
-  // Unset a fragment by ID (not implemented yet)
-  unset(fragmentId) {
-  }
-  /**
-   * Render all fragments using the provided renderer.
-   * @internal Use resolve() instead for public API.
-   */
-  render(renderer) {
-    return renderer.render(this.#fragments);
-  }
-  /**
-   * Resolve context into AI SDK-ready format.
-   *
-   * - Initializes chat and branch if needed
-   * - Loads message history from the graph (walking parent chain)
-   * - Separates context fragments for system prompt
-   * - Combines with pending messages
-   *
-   * @example
-   * ```ts
-   * const context = new ContextEngine({ store, chatId: 'chat-1', userId: 'user-1' })
-   *   .set(role('You are helpful'), user('Hello'));
-   *
-   * const { systemPrompt, messages } = await context.resolve();
-   * await generateText({ system: systemPrompt, messages });
-   * ```
-   */
-  async resolve(options) {
-    await this.#ensureInitialized();
-    const systemPrompt = options.renderer.render(this.#fragments);
-    const messages = [];
-    if (this.#branch?.headMessageId) {
-      const chain = await this.#store.getMessageChain(
-        this.#branch.headMessageId
-      );
-      for (const msg of chain) {
-        messages.push(message(msg.data).codec?.decode());
-      }
-    }
-    for (let i = 0; i < this.#pendingMessages.length; i++) {
-      const fragment2 = this.#pendingMessages[i];
-      if (isLazyFragment(fragment2)) {
-        this.#pendingMessages[i] = await this.#resolveLazyFragment(fragment2);
-      }
-    }
-    for (const fragment2 of this.#pendingMessages) {
-      if (!fragment2.codec) {
-        throw new Error(
-          `Fragment "${fragment2.name}" is missing codec. Lazy fragments must be resolved before decode.`
-        );
-      }
-      const decoded = fragment2.codec.decode();
-      messages.push(decoded);
-    }
-    return { systemPrompt, messages };
-  }
-  /**
-   * Save pending messages to the graph.
-   *
-   * Each message is added as a node with parentId pointing to the previous message.
-   * The branch head is updated to point to the last message.
-   *
-   * @example
-   * ```ts
-   * context.set(user('Hello'));
-   * // AI responds...
-   * context.set(assistant('Hi there!'));
-   * await context.save(); // Persist to graph
-   * ```
-   */
-  async save() {
-    await this.#ensureInitialized();
-    if (this.#pendingMessages.length === 0) {
-      return;
-    }
-    for (let i = 0; i < this.#pendingMessages.length; i++) {
-      const fragment2 = this.#pendingMessages[i];
-      if (isLazyFragment(fragment2)) {
-        this.#pendingMessages[i] = await this.#resolveLazyFragment(fragment2);
-      }
-    }
-    for (const fragment2 of this.#pendingMessages) {
-      if (fragment2.id) {
-        const existing = await this.#store.getMessage(fragment2.id);
-        if (existing && existing.parentId) {
-          await this.#rewindForUpdate(existing.parentId);
-          fragment2.id = crypto.randomUUID();
-          break;
-        }
-      }
-    }
-    let parentId = this.#branch.headMessageId;
-    const now = Date.now();
-    for (const fragment2 of this.#pendingMessages) {
-      if (!fragment2.codec) {
-        throw new Error(
-          `Fragment "${fragment2.name}" is missing codec. Lazy fragments must be resolved before encode.`
-        );
-      }
-      const messageData = {
-        id: fragment2.id ?? crypto.randomUUID(),
-        chatId: this.#chatId,
-        parentId,
-        name: fragment2.name,
-        type: fragment2.type,
-        data: fragment2.codec.encode(),
-        createdAt: now
-      };
-      await this.#store.addMessage(messageData);
-      parentId = messageData.id;
-    }
-    await this.#store.updateBranchHead(this.#branch.id, parentId);
-    this.#branch.headMessageId = parentId;
-    this.#pendingMessages = [];
-  }
-  /**
-   * Resolve a lazy fragment by finding the appropriate ID.
-   */
-  async #resolveLazyFragment(fragment2) {
-    const lazy = fragment2[LAZY_ID];
-    if (lazy.type === "last-assistant") {
-      const lastId = await this.#getLastAssistantId();
-      return assistantText(lazy.content, { id: lastId ?? crypto.randomUUID() });
-    }
-    throw new Error(`Unknown lazy fragment type: ${lazy.type}`);
-  }
-  /**
-   * Find the most recent assistant message ID (pending or persisted).
-   */
-  async #getLastAssistantId() {
-    for (let i = this.#pendingMessages.length - 1; i >= 0; i--) {
-      const msg = this.#pendingMessages[i];
-      if (msg.name === "assistant" && !isLazyFragment(msg)) {
-        return msg.id;
-      }
-    }
-    if (this.#branch?.headMessageId) {
-      const chain = await this.#store.getMessageChain(
-        this.#branch.headMessageId
-      );
-      for (let i = chain.length - 1; i >= 0; i--) {
-        if (chain[i].name === "assistant") {
-          return chain[i].id;
-        }
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Estimate token count and cost for the full context.
-   *
-   * Includes:
-   * - System prompt fragments (role, hints, etc.)
-   * - Persisted chat messages (from store)
-   * - Pending messages (not yet saved)
-   *
-   * @param modelId - Model ID (e.g., "openai:gpt-4o", "anthropic:claude-3-5-sonnet")
-   * @param options - Optional settings
-   * @returns Estimate result with token counts, costs, and per-fragment breakdown
-   */
-  async estimate(modelId, options = {}) {
-    await this.#ensureInitialized();
-    const renderer = options.renderer ?? new XmlRenderer();
-    const registry = getModelsRegistry();
-    await registry.load();
-    const model = registry.get(modelId);
-    if (!model) {
-      throw new Error(
-        `Model "${modelId}" not found. Call load() first or check model ID.`
-      );
-    }
-    const tokenizer = registry.getTokenizer(modelId);
-    const fragmentEstimates = [];
-    for (const fragment2 of this.#fragments) {
-      const rendered = renderer.render([fragment2]);
-      const tokens = tokenizer.count(rendered);
-      const cost = tokens / 1e6 * model.cost.input;
-      fragmentEstimates.push({
-        id: fragment2.id,
-        name: fragment2.name,
-        tokens,
-        cost
-      });
-    }
-    if (this.#branch?.headMessageId) {
-      const chain = await this.#store.getMessageChain(
-        this.#branch.headMessageId
-      );
-      for (const msg of chain) {
-        const content = String(msg.data);
-        const tokens = tokenizer.count(content);
-        const cost = tokens / 1e6 * model.cost.input;
-        fragmentEstimates.push({
-          name: msg.name,
-          id: msg.id,
-          tokens,
-          cost
-        });
-      }
-    }
-    for (const fragment2 of this.#pendingMessages) {
-      const content = String(fragment2.data);
-      const tokens = tokenizer.count(content);
-      const cost = tokens / 1e6 * model.cost.input;
-      fragmentEstimates.push({
-        name: fragment2.name,
-        id: fragment2.id,
-        tokens,
-        cost
-      });
-    }
-    const totalTokens = fragmentEstimates.reduce((sum, f) => sum + f.tokens, 0);
-    const totalCost = fragmentEstimates.reduce((sum, f) => sum + f.cost, 0);
-    return {
-      model: model.id,
-      provider: model.provider,
-      tokens: totalTokens,
-      cost: totalCost,
-      limits: {
-        context: model.limit.context,
-        output: model.limit.output,
-        exceedsContext: totalTokens > model.limit.context
-      },
-      fragments: fragmentEstimates
-    };
-  }
-  /**
-   * Rewind to a specific message by ID.
-   *
-   * Creates a new branch from that message, preserving the original branch.
-   * The new branch becomes active.
-   *
-   * @param messageId - The message ID to rewind to
-   * @returns The new branch info
-   *
-   * @example
-   * ```ts
-   * context.set(user('What is 2 + 2?', { id: 'q1' }));
-   * context.set(assistant('The answer is 5.', { id: 'wrong' })); // Oops!
-   * await context.save();
-   *
-   * // Rewind to the question, creates new branch
-   * const newBranch = await context.rewind('q1');
-   *
-   * // Now add correct answer on new branch
-   * context.set(assistant('The answer is 4.'));
-   * await context.save();
-   * ```
-   */
-  async rewind(messageId) {
-    await this.#ensureInitialized();
-    const message2 = await this.#store.getMessage(messageId);
-    if (!message2) {
-      throw new Error(`Message "${messageId}" not found`);
-    }
-    if (message2.chatId !== this.#chatId) {
-      throw new Error(`Message "${messageId}" belongs to a different chat`);
-    }
-    return this.#createBranchFrom(messageId, true);
-  }
-  /**
-   * Create a checkpoint at the current position.
-   *
-   * A checkpoint is a named pointer to the current branch head.
-   * Use restore() to return to this point later.
-   *
-   * @param name - Name for the checkpoint
-   * @returns The checkpoint info
-   *
-   * @example
-   * ```ts
-   * context.set(user('I want to learn a new skill.'));
-   * context.set(assistant('Would you like coding or cooking?'));
-   * await context.save();
-   *
-   * // Save checkpoint before user's choice
-   * const cp = await context.checkpoint('before-choice');
-   * ```
-   */
-  async checkpoint(name) {
-    await this.#ensureInitialized();
-    if (!this.#branch?.headMessageId) {
-      throw new Error("Cannot create checkpoint: no messages in conversation");
-    }
-    const checkpoint = {
-      id: crypto.randomUUID(),
-      chatId: this.#chatId,
-      name,
-      messageId: this.#branch.headMessageId,
-      createdAt: Date.now()
-    };
-    await this.#store.createCheckpoint(checkpoint);
-    return {
-      id: checkpoint.id,
-      name: checkpoint.name,
-      messageId: checkpoint.messageId,
-      createdAt: checkpoint.createdAt
-    };
-  }
-  /**
-   * Restore to a checkpoint by creating a new branch from that point.
-   *
-   * @param name - Name of the checkpoint to restore
-   * @returns The new branch info
-   *
-   * @example
-   * ```ts
-   * // User chose cooking, but wants to try coding path
-   * await context.restore('before-choice');
-   *
-   * context.set(user('I want to learn coding.'));
-   * context.set(assistant('Python is a great starting language!'));
-   * await context.save();
-   * ```
-   */
-  async restore(name) {
-    await this.#ensureInitialized();
-    const checkpoint = await this.#store.getCheckpoint(this.#chatId, name);
-    if (!checkpoint) {
-      throw new Error(
-        `Checkpoint "${name}" not found in chat "${this.#chatId}"`
-      );
-    }
-    return this.rewind(checkpoint.messageId);
-  }
-  /**
-   * Switch to a different branch by name.
-   *
-   * @param name - Branch name to switch to
-   *
-   * @example
-   * ```ts
-   * // List branches (via store)
-   * const branches = await store.listBranches(context.chatId);
-   * console.log(branches); // [{name: 'main', ...}, {name: 'main-v2', ...}]
-   *
-   * // Switch to original branch
-   * await context.switchBranch('main');
-   * ```
-   */
-  async switchBranch(name) {
-    await this.#ensureInitialized();
-    const branch = await this.#store.getBranch(this.#chatId, name);
-    if (!branch) {
-      throw new Error(`Branch "${name}" not found in chat "${this.#chatId}"`);
-    }
-    await this.#store.setActiveBranch(this.#chatId, branch.id);
-    this.#branch = { ...branch, isActive: true };
-    this.#branchName = name;
-    this.#pendingMessages = [];
-  }
-  /**
-   * Create a parallel branch from the current position ("by the way").
-   *
-   * Use this when you want to fork the conversation without leaving
-   * the current branch. Common use case: user wants to ask another
-   * question while waiting for the model to respond.
-   *
-   * Unlike rewind(), this method:
-   * - Uses the current HEAD (no messageId needed)
-   * - Does NOT switch to the new branch
-   * - Keeps pending messages intact
-   *
-   * @returns The new branch info (does not switch to it)
-   * @throws Error if no messages exist in the conversation
-   *
-   * @example
-   * ```ts
-   * // User asked a question, model is generating...
-   * context.set(user('What is the weather?'));
-   * await context.save();
-   *
-   * // User wants to ask something else without waiting
-   * const newBranch = await context.btw();
-   * // newBranch = { name: 'main-v2', ... }
-   *
-   * // Later, switch to the new branch and add the question
-   * await context.switchBranch(newBranch.name);
-   * context.set(user('Also, what time is it?'));
-   * await context.save();
-   * ```
-   */
-  async btw() {
-    await this.#ensureInitialized();
-    if (!this.#branch?.headMessageId) {
-      throw new Error("Cannot create btw branch: no messages in conversation");
-    }
-    return this.#createBranchFrom(this.#branch.headMessageId, false);
-  }
-  /**
-   * Update metadata for the current chat.
-   *
-   * @param updates - Partial metadata to merge (title, metadata)
-   *
-   * @example
-   * ```ts
-   * await context.updateChat({
-   *   title: 'Coding Help Session',
-   *   metadata: { tags: ['python', 'debugging'] }
-   * });
-   * ```
-   */
-  async updateChat(updates) {
-    await this.#ensureInitialized();
-    const storeUpdates = {};
-    if (updates.title !== void 0) {
-      storeUpdates.title = updates.title;
-    }
-    if (updates.metadata !== void 0) {
-      storeUpdates.metadata = {
-        ...this.#chatData?.metadata,
-        ...updates.metadata
-      };
-    }
-    this.#chatData = await this.#store.updateChat(this.#chatId, storeUpdates);
-  }
-  /**
-   * Track token usage for the current chat.
-   * Accumulates usage metrics in chat.metadata.usage.
-   *
-   * @param usage - Token usage from AI SDK (LanguageModelUsage)
-   *
-   * @example
-   * ```ts
-   * // In onFinish callback
-   * const usage = await result.totalUsage;
-   * await context.trackUsage(usage);
-   * ```
-   */
-  async trackUsage(usage) {
-    await this.#ensureInitialized();
-    const freshChatData = await this.#store.getChat(this.#chatId);
-    const currentUsage = freshChatData?.metadata?.usage ?? {};
-    const updatedUsage = mergeWith(
-      {},
-      currentUsage,
-      usage,
-      (a, b) => typeof a === "number" || typeof b === "number" ? (a ?? 0) + (b ?? 0) : void 0
-    );
-    this.#chatData = await this.#store.updateChat(this.#chatId, {
-      metadata: {
-        ...freshChatData?.metadata,
-        usage: updatedUsage
-      }
-    });
-  }
-  /**
-   * Consolidate context fragments (no-op for now).
-   *
-   * This is a placeholder for future functionality that merges context fragments
-   * using specific rules. Currently, it does nothing.
-   *
-   * @experimental
-   */
-  consolidate() {
-    return void 0;
-  }
-  /**
-   * Extract skill mounts from available_skills fragments.
-   * Returns unified mount array where entries with `name` are individual skills.
-   *
-   * @example
-   * ```ts
-   * const context = new ContextEngine({ store, chatId, userId })
-   *   .set(skills({ paths: [{ host: './skills', sandbox: '/skills' }] }));
-   *
-   * const { mounts } = context.getSkillMounts();
-   * // mounts: [{ name: 'bi-dashboards', host: './skills/bi-dashboards/SKILL.md', sandbox: '/skills/bi-dashboards/SKILL.md' }]
-   *
-   * // Extract skills only (entries with name)
-   * const skills = mounts.filter(m => m.name);
-   * ```
-   */
-  getSkillMounts() {
-    for (const fragment2 of this.#fragments) {
-      if (fragment2.name === "available_skills" && fragment2.metadata?.mounts) {
-        return { mounts: fragment2.metadata.mounts };
-      }
-    }
-    return { mounts: [] };
-  }
-  /**
-   * Inspect the full context state for debugging.
-   * Returns a JSON-serializable object with context information.
-   *
-   * @param options - Inspection options (modelId and renderer required)
-   * @returns Complete inspection data including estimates, rendered output, fragments, and graph
-   *
-   * @example
-   * ```ts
-   * const inspection = await context.inspect({
-   *   modelId: 'openai:gpt-4o',
-   *   renderer: new XmlRenderer(),
-   * });
-   * console.log(JSON.stringify(inspection, null, 2));
-   *
-   * // Or write to file for analysis
-   * await fs.writeFile('context-debug.json', JSON.stringify(inspection, null, 2));
-   * ```
-   */
-  async inspect(options) {
-    await this.#ensureInitialized();
-    const { renderer } = options;
-    const estimateResult = await this.estimate(options.modelId, { renderer });
-    const rendered = renderer.render(this.#fragments);
-    const persistedMessages = [];
-    if (this.#branch?.headMessageId) {
-      const chain = await this.#store.getMessageChain(
-        this.#branch.headMessageId
-      );
-      persistedMessages.push(...chain);
-    }
-    const graph = await this.#store.getGraph(this.#chatId);
-    return {
-      estimate: estimateResult,
-      rendered,
-      fragments: {
-        context: [...this.#fragments],
-        pending: [...this.#pendingMessages],
-        persisted: persistedMessages
-      },
-      graph,
-      meta: {
-        chatId: this.#chatId,
-        branch: this.#branchName,
-        timestamp: Date.now()
-      }
-    };
-  }
-};
-function persona(input) {
-  return {
-    name: "persona",
-    data: {
-      name: input.name,
-      ...input.role && { role: input.role },
-      ...input.objective && { objective: input.objective },
-      ...input.tone && { tone: input.tone }
-    }
-  };
-}
-function pass(part) {
-  return { type: "pass", part };
-}
-function runGuardrailChain(part, guardrails, context) {
-  let currentPart = part;
-  for (const guardrail2 of guardrails) {
-    const result = guardrail2.handle(currentPart, context);
-    if (result.type === "fail" || result.type === "stop") {
-      return result;
+        }
+      }
     }
-    currentPart = result.part;
   }
-  return pass(currentPart);
-}
-var SKILLS_INSTRUCTIONS = dedent`A skill is a set of local instructions to follow that is stored in a \`SKILL.md\` file. Below is the list of skills that can be used. Each entry includes a name, description, and file path so you can open the source for full instructions when using a specific skill.
+};
 
-### How to use skills
-- Discovery: The list below shows the skills available in this session (name + description + file path). Skill bodies live on disk at the listed paths.
-- Trigger rules: If the user names a skill (with \`$SkillName\` or plain text) OR the task clearly matches a skill's description shown below, you must use that skill for that turn before doing anything else. Multiple mentions mean use them all. Do not carry skills across turns unless re-mentioned.
-- Missing/blocked: If a named skill isn't in the list or the path can't be read, say so briefly and continue with the best fallback.
-- How to use a skill (progressive disclosure):
-  1) After deciding to use a skill, open its \`SKILL.md\`. Read only enough to follow the workflow.
-  2) If \`SKILL.md\` points to extra folders such as \`references/\`, load only the specific files needed for the request; don't bulk-load everything.
-  3) If \`scripts/\` exist, prefer running or patching them instead of retyping large code blocks.
-  4) If \`assets/\` or templates exist, reuse them instead of recreating from scratch.
-- Coordination and sequencing:
-  - If multiple skills apply, choose the minimal set that covers the request and state the order you'll use them.
-  - Announce which skill(s) you're using and why (one short line). If you skip an obvious skill, say why.
-- Context hygiene:
-  - Keep context small: summarize long sections instead of pasting them; only load extra files when needed.
-  - Avoid deep reference-chasing: prefer opening only files directly linked from \`SKILL.md\` unless you're blocked.
-  - When variants exist (frameworks, providers, domains), pick only the relevant reference file(s) and note that choice.
-- Safety and fallback: If a skill can't be applied cleanly (missing files, unclear instructions), state the issue, pick the next-best approach, and continue.`;
-var ddl_sqlite_default = "-- Context Store DDL for SQLite\n-- This schema implements a DAG-based message history with branching and checkpoints.\n\n-- Performance PRAGMAs (session-level, run on each connection)\nPRAGMA journal_mode = WAL;\nPRAGMA synchronous = NORMAL;\nPRAGMA cache_size = -64000;\nPRAGMA temp_store = MEMORY;\nPRAGMA mmap_size = 268435456;\n\n-- Integrity\nPRAGMA foreign_keys = ON;\n\n-- Chats table\n-- createdAt/updatedAt: DEFAULT for insert, inline SET for updates\nCREATE TABLE IF NOT EXISTS chats (\n  id TEXT PRIMARY KEY,\n  userId TEXT NOT NULL,\n  title TEXT,\n  metadata TEXT,\n  createdAt INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),\n  updatedAt INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)\n);\n\nCREATE INDEX IF NOT EXISTS idx_chats_updatedAt ON chats(updatedAt);\nCREATE INDEX IF NOT EXISTS idx_chats_userId ON chats(userId);\n-- Composite index for listChats(): WHERE userId = ? ORDER BY updatedAt DESC\nCREATE INDEX IF NOT EXISTS idx_chats_userId_updatedAt ON chats(userId, updatedAt DESC);\n\n-- Messages table (nodes in the DAG)\nCREATE TABLE IF NOT EXISTS messages (\n  id TEXT PRIMARY KEY,\n  chatId TEXT NOT NULL,\n  parentId TEXT,\n  name TEXT NOT NULL,\n  type TEXT,\n  data TEXT NOT NULL,\n  createdAt INTEGER NOT NULL,\n  FOREIGN KEY (chatId) REFERENCES chats(id) ON DELETE CASCADE,\n  FOREIGN KEY (parentId) REFERENCES messages(id)\n);\n\nCREATE INDEX IF NOT EXISTS idx_messages_chatId ON messages(chatId);\nCREATE INDEX IF NOT EXISTS idx_messages_parentId ON messages(parentId);\n-- Composite index for recursive CTE parent traversal in getMessageChain()\nCREATE INDEX IF NOT EXISTS idx_messages_chatId_parentId ON messages(chatId, parentId);\n\n-- Branches table (pointers to head messages)\nCREATE TABLE IF NOT EXISTS branches (\n  id TEXT PRIMARY KEY,\n  chatId TEXT NOT NULL,\n  name TEXT NOT NULL,\n  headMessageId TEXT,\n  isActive INTEGER NOT NULL DEFAULT 0,\n  createdAt INTEGER NOT NULL,\n  FOREIGN KEY (chatId) REFERENCES chats(id) ON DELETE CASCADE,\n  FOREIGN KEY (headMessageId) REFERENCES messages(id),\n  UNIQUE(chatId, name)\n);\n\nCREATE INDEX IF NOT EXISTS idx_branches_chatId ON branches(chatId);\n-- Composite index for getActiveBranch(): WHERE chatId = ? AND isActive = 1\nCREATE INDEX IF NOT EXISTS idx_branches_chatId_isActive ON branches(chatId, isActive);\n\n-- Checkpoints table (pointers to message nodes)\nCREATE TABLE IF NOT EXISTS checkpoints (\n  id TEXT PRIMARY KEY,\n  chatId TEXT NOT NULL,\n  name TEXT NOT NULL,\n  messageId TEXT NOT NULL,\n  createdAt INTEGER NOT NULL,\n  FOREIGN KEY (chatId) REFERENCES chats(id) ON DELETE CASCADE,\n  FOREIGN KEY (messageId) REFERENCES messages(id),\n  UNIQUE(chatId, name)\n);\n\nCREATE INDEX IF NOT EXISTS idx_checkpoints_chatId ON checkpoints(chatId);\n\n-- FTS5 virtual table for full-text search\n-- messageId/chatId/name are UNINDEXED (stored but not searchable, used for filtering/joining)\n-- Only 'content' is indexed for full-text search\nCREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(\n  messageId UNINDEXED,\n  chatId UNINDEXED,\n  name UNINDEXED,\n  content,\n  tokenize='porter unicode61'\n);\n";
-var SqliteContextStore = class extends ContextStore {
-  #db;
-  #statements = /* @__PURE__ */ new Map();
+// packages/text2sql/src/lib/adapters/groundings/info.grounding.ts
+var InfoGrounding = class extends AbstractGrounding {
+  constructor(config = {}) {
+    super("dialectInfo");
+  }
   /**
-   * Get or create a prepared statement.
-   * Statements are cached for the lifetime of the store to avoid
-   * repeated SQL parsing and compilation overhead.
+   * Execute the grounding process.
+   * Writes database info to ctx.info.
    */
-  #stmt(sql) {
-    let stmt = this.#statements.get(sql);
-    if (!stmt) {
-      stmt = this.#db.prepare(sql);
-      this.#statements.set(sql, stmt);
-    }
-    return stmt;
+  async execute(ctx) {
+    ctx.info = await this.collectInfo();
   }
-  constructor(path3) {
-    super();
-    this.#db = new DatabaseSync(path3);
-    this.#db.exec(ddl_sqlite_default);
+};
+
+// packages/text2sql/src/lib/adapters/groundings/column-values.grounding.ts
+var ColumnValuesGrounding = class extends AbstractGrounding {
+  lowCardinalityLimit;
+  constructor(config = {}) {
+    super("columnValues");
+    this.lowCardinalityLimit = config.lowCardinalityLimit ?? 20;
   }
   /**
-   * Execute a function within a transaction.
-   * Automatically commits on success or rolls back on error.
+   * Get values for native ENUM type columns.
+   * Return undefined if column is not an ENUM type.
+   * Default implementation returns undefined (no native ENUM support).
    */
-  #useTransaction(fn) {
-    this.#db.exec("BEGIN TRANSACTION");
-    try {
-      const result = fn();
-      this.#db.exec("COMMIT");
-      return result;
-    } catch (error) {
-      this.#db.exec("ROLLBACK");
-      throw error;
-    }
-  }
-  // ==========================================================================
-  // Chat Operations
-  // ==========================================================================
-  async createChat(chat) {
-    return this.#useTransaction(() => {
-      const row = this.#db.prepare(
-        `INSERT INTO chats (id, userId, title, metadata)
-           VALUES (?, ?, ?, ?)
-           RETURNING *`
-      ).get(
-        chat.id,
-        chat.userId,
-        chat.title ?? null,
-        chat.metadata ? JSON.stringify(chat.metadata) : null
-      );
-      this.#db.prepare(
-        `INSERT INTO branches (id, chatId, name, headMessageId, isActive, createdAt)
-           VALUES (?, ?, 'main', NULL, 1, ?)`
-      ).run(crypto.randomUUID(), chat.id, Date.now());
-      return {
-        id: row.id,
-        userId: row.userId,
-        title: row.title ?? void 0,
-        metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
-        createdAt: row.createdAt,
-        updatedAt: row.updatedAt
-      };
-    });
-  }
-  async upsertChat(chat) {
-    return this.#useTransaction(() => {
-      const row = this.#db.prepare(
-        `INSERT INTO chats (id, userId, title, metadata)
-           VALUES (?, ?, ?, ?)
-           ON CONFLICT(id) DO UPDATE SET id = excluded.id
-           RETURNING *`
-      ).get(
-        chat.id,
-        chat.userId,
-        chat.title ?? null,
-        chat.metadata ? JSON.stringify(chat.metadata) : null
-      );
-      this.#db.prepare(
-        `INSERT OR IGNORE INTO branches (id, chatId, name, headMessageId, isActive, createdAt)
-           VALUES (?, ?, 'main', NULL, 1, ?)`
-      ).run(crypto.randomUUID(), chat.id, Date.now());
-      return {
-        id: row.id,
-        userId: row.userId,
-        title: row.title ?? void 0,
-        metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
-        createdAt: row.createdAt,
-        updatedAt: row.updatedAt
-      };
-    });
+  async collectEnumValues(_tableName, _column) {
+    return void 0;
   }
-  async getChat(chatId) {
-    const row = this.#db.prepare("SELECT * FROM chats WHERE id = ?").get(chatId);
-    if (!row) {
+  /**
+   * Parse CHECK constraint for enum-like IN clause.
+   * Extracts values from patterns like:
+   * - CHECK (status IN ('active', 'inactive'))
+   * - CHECK ((status)::text = ANY (ARRAY['a'::text, 'b'::text]))
+   * - CHECK (status = 'active' OR status = 'inactive')
+   */
+  parseCheckConstraint(constraint2, columnName) {
+    if (constraint2.type !== "CHECK" || !constraint2.definition) {
       return void 0;
     }
-    return {
-      id: row.id,
-      userId: row.userId,
-      title: row.title ?? void 0,
-      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
-      createdAt: row.createdAt,
-      updatedAt: row.updatedAt
-    };
-  }
-  async updateChat(chatId, updates) {
-    const setClauses = ["updatedAt = strftime('%s', 'now') * 1000"];
-    const params = [];
-    if (updates.title !== void 0) {
-      setClauses.push("title = ?");
-      params.push(updates.title ?? null);
-    }
-    if (updates.metadata !== void 0) {
-      setClauses.push("metadata = ?");
-      params.push(JSON.stringify(updates.metadata));
-    }
-    params.push(chatId);
-    const row = this.#db.prepare(
-      `UPDATE chats SET ${setClauses.join(", ")} WHERE id = ? RETURNING *`
-    ).get(...params);
-    return {
-      id: row.id,
-      userId: row.userId,
-      title: row.title ?? void 0,
-      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
-      createdAt: row.createdAt,
-      updatedAt: row.updatedAt
-    };
-  }
-  async listChats(options) {
-    const params = [];
-    const whereClauses = [];
-    let limitClause = "";
-    if (options?.userId) {
-      whereClauses.push("c.userId = ?");
-      params.push(options.userId);
-    }
-    if (options?.metadata) {
-      whereClauses.push(`json_extract(c.metadata, '$.' || ?) = ?`);
-      params.push(options.metadata.key);
-      params.push(
-        typeof options.metadata.value === "boolean" ? options.metadata.value ? 1 : 0 : options.metadata.value
-      );
-    }
-    const whereClause = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
-    if (options?.limit !== void 0) {
-      limitClause = " LIMIT ?";
-      params.push(options.limit);
-      if (options.offset !== void 0) {
-        limitClause += " OFFSET ?";
-        params.push(options.offset);
-      }
+    if (constraint2.columns && !constraint2.columns.includes(columnName)) {
+      return void 0;
     }
-    const rows = this.#db.prepare(
-      `SELECT
-          c.id,
-          c.userId,
-          c.title,
-          c.metadata,
-          c.createdAt,
-          c.updatedAt,
-          COUNT(DISTINCT m.id) as messageCount,
-          COUNT(DISTINCT b.id) as branchCount
-        FROM chats c
-        LEFT JOIN messages m ON m.chatId = c.id
-        LEFT JOIN branches b ON b.chatId = c.id
-        ${whereClause}
-        GROUP BY c.id
-        ORDER BY c.updatedAt DESC${limitClause}`
-    ).all(...params);
-    return rows.map((row) => ({
-      id: row.id,
-      userId: row.userId,
-      title: row.title ?? void 0,
-      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
-      messageCount: row.messageCount,
-      branchCount: row.branchCount,
-      createdAt: row.createdAt,
-      updatedAt: row.updatedAt
-    }));
-  }
-  async deleteChat(chatId, options) {
-    return this.#useTransaction(() => {
-      const messageIds = this.#db.prepare("SELECT id FROM messages WHERE chatId = ?").all(chatId);
-      let sql = "DELETE FROM chats WHERE id = ?";
-      const params = [chatId];
-      if (options?.userId !== void 0) {
-        sql += " AND userId = ?";
-        params.push(options.userId);
-      }
-      const result = this.#db.prepare(sql).run(...params);
-      if (result.changes > 0 && messageIds.length > 0) {
-        const placeholders = messageIds.map(() => "?").join(", ");
-        this.#db.prepare(
-          `DELETE FROM messages_fts WHERE messageId IN (${placeholders})`
-        ).run(...messageIds.map((m) => m.id));
-      }
-      return result.changes > 0;
-    });
-  }
-  // ==========================================================================
-  // Message Operations (Graph Nodes)
-  // ==========================================================================
-  async addMessage(message2) {
-    if (message2.parentId === message2.id) {
-      throw new Error(`Message ${message2.id} cannot be its own parent`);
-    }
-    this.#stmt(
-      `INSERT INTO messages (id, chatId, parentId, name, type, data, createdAt)
-       VALUES (?, ?, ?, ?, ?, ?, ?)
-       ON CONFLICT(id) DO UPDATE SET
-         name = excluded.name,
-         type = excluded.type,
-         data = excluded.data`
-    ).run(
-      message2.id,
-      message2.chatId,
-      message2.parentId,
-      message2.name,
-      message2.type ?? null,
-      JSON.stringify(message2.data),
-      message2.createdAt
-    );
-    const content = typeof message2.data === "string" ? message2.data : JSON.stringify(message2.data);
-    this.#stmt(`DELETE FROM messages_fts WHERE messageId = ?`).run(message2.id);
-    this.#stmt(
-      `INSERT INTO messages_fts(messageId, chatId, name, content)
-       VALUES (?, ?, ?, ?)`
-    ).run(message2.id, message2.chatId, message2.name, content);
-  }
-  async getMessage(messageId) {
-    const row = this.#stmt("SELECT * FROM messages WHERE id = ?").get(
-      messageId
+    const def = constraint2.definition;
+    const escapedCol = this.escapeRegex(columnName);
+    const colPattern = `(?:\\(?\\(?${escapedCol}\\)?(?:::(?:text|varchar|character varying))?\\)?)`;
+    const inMatch = def.match(
+      new RegExp(`${colPattern}\\s+IN\\s*\\(([^)]+)\\)`, "i")
     );
-    if (!row) {
-      return void 0;
+    if (inMatch) {
+      return this.extractStringValues(inMatch[1]);
     }
-    return {
-      id: row.id,
-      chatId: row.chatId,
-      parentId: row.parentId,
-      name: row.name,
-      type: row.type ?? void 0,
-      data: JSON.parse(row.data),
-      createdAt: row.createdAt
-    };
-  }
-  async getMessageChain(headId) {
-    const rows = this.#stmt(
-      `WITH RECURSIVE chain AS (
-        SELECT *, 0 as depth FROM messages WHERE id = ?
-        UNION ALL
-        SELECT m.*, c.depth + 1 FROM messages m
-        INNER JOIN chain c ON m.id = c.parentId
-        WHERE c.depth < 100000
+    const anyMatch = def.match(
+      new RegExp(
+        `${colPattern}\\s*=\\s*ANY\\s*\\(\\s*(?:ARRAY)?\\s*\\[([^\\]]+)\\]`,
+        "i"
       )
-      SELECT * FROM chain
-      ORDER BY depth DESC`
-    ).all(headId);
-    return rows.map((row) => ({
-      id: row.id,
-      chatId: row.chatId,
-      parentId: row.parentId,
-      name: row.name,
-      type: row.type ?? void 0,
-      data: JSON.parse(row.data),
-      createdAt: row.createdAt
-    }));
-  }
-  async hasChildren(messageId) {
-    const row = this.#stmt(
-      "SELECT EXISTS(SELECT 1 FROM messages WHERE parentId = ?) as hasChildren"
-    ).get(messageId);
-    return row.hasChildren === 1;
-  }
-  async getMessages(chatId) {
-    const chat = await this.getChat(chatId);
-    if (!chat) {
-      throw new Error(`Chat "${chatId}" not found`);
-    }
-    const activeBranch = await this.getActiveBranch(chatId);
-    if (!activeBranch?.headMessageId) {
-      return [];
-    }
-    return this.getMessageChain(activeBranch.headMessageId);
-  }
-  // ==========================================================================
-  // Branch Operations
-  // ==========================================================================
-  async createBranch(branch) {
-    this.#db.prepare(
-      `INSERT INTO branches (id, chatId, name, headMessageId, isActive, createdAt)
-         VALUES (?, ?, ?, ?, ?, ?)`
-    ).run(
-      branch.id,
-      branch.chatId,
-      branch.name,
-      branch.headMessageId,
-      branch.isActive ? 1 : 0,
-      branch.createdAt
     );
-  }
-  async getBranch(chatId, name) {
-    const row = this.#db.prepare("SELECT * FROM branches WHERE chatId = ? AND name = ?").get(chatId, name);
-    if (!row) {
-      return void 0;
-    }
-    return {
-      id: row.id,
-      chatId: row.chatId,
-      name: row.name,
-      headMessageId: row.headMessageId,
-      isActive: row.isActive === 1,
-      createdAt: row.createdAt
-    };
-  }
-  async getActiveBranch(chatId) {
-    const row = this.#stmt(
-      "SELECT * FROM branches WHERE chatId = ? AND isActive = 1"
-    ).get(chatId);
-    if (!row) {
-      return void 0;
+    if (anyMatch) {
+      return this.extractStringValues(anyMatch[1]);
     }
-    return {
-      id: row.id,
-      chatId: row.chatId,
-      name: row.name,
-      headMessageId: row.headMessageId,
-      isActive: true,
-      createdAt: row.createdAt
-    };
-  }
-  async setActiveBranch(chatId, branchId) {
-    this.#db.prepare("UPDATE branches SET isActive = 0 WHERE chatId = ?").run(chatId);
-    this.#db.prepare("UPDATE branches SET isActive = 1 WHERE id = ?").run(branchId);
-  }
-  async updateBranchHead(branchId, messageId) {
-    this.#stmt("UPDATE branches SET headMessageId = ? WHERE id = ?").run(
-      messageId,
-      branchId
-    );
-  }
-  async listBranches(chatId) {
-    const rows = this.#db.prepare(
-      `SELECT
-          b.id,
-          b.name,
-          b.headMessageId,
-          b.isActive,
-          b.createdAt,
-          COALESCE(
-            (
-              WITH RECURSIVE chain AS (
-                SELECT id, parentId FROM messages WHERE id = b.headMessageId
-                UNION ALL
-                SELECT m.id, m.parentId FROM messages m
-                INNER JOIN chain c ON m.id = c.parentId
-              )
-              SELECT COUNT(*) FROM chain
-            ),
-            0
-          ) as messageCount
-        FROM branches b
-        WHERE b.chatId = ?
-        ORDER BY b.createdAt ASC`
-    ).all(chatId);
-    return rows.map((row) => ({
-      id: row.id,
-      name: row.name,
-      headMessageId: row.headMessageId,
-      isActive: row.isActive === 1,
-      messageCount: row.messageCount,
-      createdAt: row.createdAt
-    }));
-  }
-  // ==========================================================================
-  // Checkpoint Operations
-  // ==========================================================================
-  async createCheckpoint(checkpoint) {
-    this.#db.prepare(
-      `INSERT INTO checkpoints (id, chatId, name, messageId, createdAt)
-         VALUES (?, ?, ?, ?, ?)
-         ON CONFLICT(chatId, name) DO UPDATE SET
-           messageId = excluded.messageId,
-           createdAt = excluded.createdAt`
-    ).run(
-      checkpoint.id,
-      checkpoint.chatId,
-      checkpoint.name,
-      checkpoint.messageId,
-      checkpoint.createdAt
+    const orPattern = new RegExp(
+      `\\b${this.escapeRegex(columnName)}\\b\\s*=\\s*'([^']*)'`,
+      "gi"
     );
-  }
-  async getCheckpoint(chatId, name) {
-    const row = this.#db.prepare("SELECT * FROM checkpoints WHERE chatId = ? AND name = ?").get(chatId, name);
-    if (!row) {
-      return void 0;
+    const orMatches = [...def.matchAll(orPattern)];
+    if (orMatches.length >= 2) {
+      return orMatches.map((m) => m[1]);
     }
-    return {
-      id: row.id,
-      chatId: row.chatId,
-      name: row.name,
-      messageId: row.messageId,
-      createdAt: row.createdAt
-    };
-  }
-  async listCheckpoints(chatId) {
-    const rows = this.#db.prepare(
-      `SELECT id, name, messageId, createdAt
-         FROM checkpoints
-         WHERE chatId = ?
-         ORDER BY createdAt DESC`
-    ).all(chatId);
-    return rows.map((row) => ({
-      id: row.id,
-      name: row.name,
-      messageId: row.messageId,
-      createdAt: row.createdAt
-    }));
-  }
-  async deleteCheckpoint(chatId, name) {
-    this.#db.prepare("DELETE FROM checkpoints WHERE chatId = ? AND name = ?").run(chatId, name);
-  }
-  // ==========================================================================
-  // Search Operations
-  // ==========================================================================
-  async searchMessages(chatId, query, options) {
-    const limit = options?.limit ?? 20;
-    const roles = options?.roles;
-    let sql = `
-      SELECT
-        m.id,
-        m.chatId,
-        m.parentId,
-        m.name,
-        m.type,
-        m.data,
-        m.createdAt,
-        fts.rank,
-        snippet(messages_fts, 3, '<mark>', '</mark>', '...', 32) as snippet
-      FROM messages_fts fts
-      JOIN messages m ON m.id = fts.messageId
-      WHERE messages_fts MATCH ?
-        AND fts.chatId = ?
-    `;
-    const params = [query, chatId];
-    if (roles && roles.length > 0) {
-      const placeholders = roles.map(() => "?").join(", ");
-      sql += ` AND fts.name IN (${placeholders})`;
-      params.push(...roles);
-    }
-    sql += " ORDER BY fts.rank LIMIT ?";
-    params.push(limit);
-    const rows = this.#db.prepare(sql).all(...params);
-    return rows.map((row) => ({
-      message: {
-        id: row.id,
-        chatId: row.chatId,
-        parentId: row.parentId,
-        name: row.name,
-        type: row.type ?? void 0,
-        data: JSON.parse(row.data),
-        createdAt: row.createdAt
-      },
-      rank: row.rank,
-      snippet: row.snippet
-    }));
-  }
-  // ==========================================================================
-  // Visualization Operations
-  // ==========================================================================
-  async getGraph(chatId) {
-    const messageRows = this.#db.prepare(
-      `SELECT id, parentId, name, data, createdAt
-         FROM messages
-         WHERE chatId = ?
-         ORDER BY createdAt ASC`
-    ).all(chatId);
-    const nodes = messageRows.map((row) => {
-      const data = JSON.parse(row.data);
-      const content = typeof data === "string" ? data : JSON.stringify(data);
-      return {
-        id: row.id,
-        parentId: row.parentId,
-        role: row.name,
-        content: content.length > 50 ? content.slice(0, 50) + "..." : content,
-        createdAt: row.createdAt
-      };
-    });
-    const branchRows = this.#db.prepare(
-      `SELECT name, headMessageId, isActive
-         FROM branches
-         WHERE chatId = ?
-         ORDER BY createdAt ASC`
-    ).all(chatId);
-    const branches = branchRows.map((row) => ({
-      name: row.name,
-      headMessageId: row.headMessageId,
-      isActive: row.isActive === 1
-    }));
-    const checkpointRows = this.#db.prepare(
-      `SELECT name, messageId
-         FROM checkpoints
-         WHERE chatId = ?
-         ORDER BY createdAt ASC`
-    ).all(chatId);
-    const checkpoints = checkpointRows.map((row) => ({
-      name: row.name,
-      messageId: row.messageId
-    }));
-    return {
-      chatId,
-      nodes,
-      branches,
-      checkpoints
-    };
-  }
-};
-var InMemoryContextStore = class extends SqliteContextStore {
-  constructor() {
-    super(":memory:");
-  }
-};
-var Agent = class _Agent {
-  #options;
-  #guardrails = [];
-  tools;
-  constructor(options) {
-    this.#options = options;
-    this.tools = options.tools || {};
-    this.#guardrails = options.guardrails || [];
+    return void 0;
   }
-  async generate(contextVariables, config) {
-    if (!this.#options.context) {
-      throw new Error(`Agent ${this.#options.name} is missing a context.`);
-    }
-    if (!this.#options.model) {
-      throw new Error(`Agent ${this.#options.name} is missing a model.`);
+  /**
+   * Extract string values from a comma-separated list.
+   */
+  extractStringValues(input) {
+    const values = [];
+    const matches = input.matchAll(/'([^']*)'/g);
+    for (const match of matches) {
+      values.push(match[1]);
     }
-    const { messages, systemPrompt } = await this.#options.context.resolve({
-      renderer: new XmlRenderer()
-    });
-    return generateText({
-      abortSignal: config?.abortSignal,
-      providerOptions: this.#options.providerOptions,
-      model: this.#options.model,
-      system: systemPrompt,
-      messages: await convertToModelMessages(messages),
-      stopWhen: stepCountIs(25),
-      tools: this.#options.tools,
-      experimental_context: contextVariables,
-      experimental_repairToolCall: repairToolCall,
-      toolChoice: this.#options.toolChoice,
-      onStepFinish: (step) => {
-        const toolCall = step.toolCalls.at(-1);
-        if (toolCall) {
-          console.log(
-            `Debug: ${chalk2.yellow("ToolCalled")}: ${toolCall.toolName}(${JSON.stringify(toolCall.input)})`
-          );
-        }
-      }
-    });
+    return values.length > 0 ? values : void 0;
   }
   /**
-   * Stream a response from the agent.
-   *
-   * When guardrails are configured, `toUIMessageStream()` is wrapped to provide
-   * self-correction behavior. Direct access to fullStream/textStream bypasses guardrails.
-   *
-   * @example
-   * ```typescript
-   * const stream = await agent.stream({});
-   *
-   * // With guardrails - use toUIMessageStream for protection
-   * await printer.readableStream(stream.toUIMessageStream());
-   *
-   * // Or use printer.stdout which uses toUIMessageStream internally
-   * await printer.stdout(stream);
-   * ```
+   * Escape special regex characters in a string.
    */
-  async stream(contextVariables, config) {
-    if (!this.#options.context) {
-      throw new Error(`Agent ${this.#options.name} is missing a context.`);
-    }
-    if (!this.#options.model) {
-      throw new Error(`Agent ${this.#options.name} is missing a model.`);
-    }
-    const result = await this.#createRawStream(contextVariables, config);
-    if (this.#guardrails.length === 0) {
-      return result;
-    }
-    return this.#wrapWithGuardrails(result, contextVariables, config);
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   }
   /**
-   * Create a raw stream without guardrail processing.
+   * Get the table from context by name.
    */
-  async #createRawStream(contextVariables, config) {
-    const { messages, systemPrompt } = await this.#options.context.resolve({
-      renderer: new XmlRenderer()
-    });
-    const runId = generateId2();
-    return streamText({
-      abortSignal: config?.abortSignal,
-      providerOptions: this.#options.providerOptions,
-      model: this.#options.model,
-      system: systemPrompt,
-      messages: await convertToModelMessages(messages),
-      experimental_repairToolCall: repairToolCall,
-      stopWhen: stepCountIs(50),
-      experimental_transform: config?.transform ?? smoothStream(),
-      tools: this.#options.tools,
-      experimental_context: contextVariables,
-      toolChoice: this.#options.toolChoice,
-      onStepFinish: (step) => {
-        const toolCall = step.toolCalls.at(-1);
-        if (toolCall) {
-          console.log(
-            `Debug: (${runId}) ${chalk2.bold.yellow("ToolCalled")}: ${toolCall.toolName}(${JSON.stringify(toolCall.input)})`
+  getTable(ctx, name) {
+    return ctx.tables.find((t) => t.name === name);
+  }
+  /**
+   * Execute the grounding process.
+   * Annotates columns in ctx.tables and ctx.views with values.
+   */
+  async execute(ctx) {
+    const allContainers = [...ctx.tables, ...ctx.views];
+    for (const container of allContainers) {
+      const table2 = this.getTable(ctx, container.name);
+      for (const column2 of container.columns) {
+        try {
+          const result = await this.resolveColumnValues(
+            container.name,
+            column2,
+            table2?.constraints
+          );
+          if (result) {
+            column2.kind = result.kind;
+            column2.values = result.values;
+          }
+        } catch (error) {
+          console.warn(
+            "Error collecting column values for",
+            container.name,
+            column2.name,
+            error
           );
         }
       }
-    });
+    }
   }
   /**
-   * Wrap a StreamTextResult with guardrail protection on toUIMessageStream().
-   *
-   * When a guardrail fails:
-   * 1. Accumulated text + feedback is appended as the assistant's self-correction
-   * 2. The feedback is written to the output stream (user sees the correction)
-   * 3. A new stream is started and the model continues from the correction
+   * Resolve column values from all sources in priority order.
    */
-  #wrapWithGuardrails(result, contextVariables, config) {
-    const maxRetries = config?.maxRetries ?? this.#options.maxGuardrailRetries ?? 3;
-    const context = this.#options.context;
-    const originalToUIMessageStream = result.toUIMessageStream.bind(result);
-    result.toUIMessageStream = (options) => {
-      return createUIMessageStream({
-        generateId: generateId2,
-        execute: async ({ writer }) => {
-          let currentResult = result;
-          let attempt = 0;
-          const { mounts } = context.getSkillMounts();
-          const guardrailContext = {
-            availableTools: Object.keys(this.tools),
-            availableSkills: mounts
-          };
-          while (attempt < maxRetries) {
-            if (config?.abortSignal?.aborted) {
-              writer.write({ type: "finish" });
-              return;
-            }
-            attempt++;
-            let accumulatedText = "";
-            let guardrailFailed = false;
-            let failureFeedback = "";
-            const uiStream = currentResult === result ? originalToUIMessageStream(options) : currentResult.toUIMessageStream(options);
-            for await (const part of uiStream) {
-              const checkResult = runGuardrailChain(
-                part,
-                this.#guardrails,
-                guardrailContext
-              );
-              if (checkResult.type === "fail") {
-                guardrailFailed = true;
-                failureFeedback = checkResult.feedback;
-                console.log(
-                  chalk2.yellow(
-                    `[${this.#options.name}] Guardrail triggered (attempt ${attempt}/${maxRetries}): ${failureFeedback.slice(0, 50)}...`
-                  )
-                );
-                break;
-              }
-              if (checkResult.type === "stop") {
-                console.log(
-                  chalk2.red(
-                    `[${this.#options.name}] Guardrail stopped - unrecoverable error, no retry`
-                  )
-                );
-                writer.write(part);
-                writer.write({ type: "finish" });
-                return;
-              }
-              if (checkResult.part.type === "text-delta") {
-                accumulatedText += checkResult.part.delta;
-              }
-              writer.write(part);
-            }
-            if (!guardrailFailed) {
-              writer.write({ type: "finish" });
-              return;
-            }
-            if (attempt >= maxRetries) {
-              console.error(
-                chalk2.red(
-                  `[${this.#options.name}] Guardrail retry limit (${maxRetries}) exceeded.`
-                )
-              );
-              writer.write({ type: "finish" });
-              return;
-            }
-            writeText(writer, failureFeedback);
-            const selfCorrectionText = accumulatedText + " " + failureFeedback;
-            context.set(lastAssistantMessage(selfCorrectionText));
-            await context.save();
-            currentResult = await this.#createRawStream(
-              contextVariables,
-              config
-            );
-          }
-        },
-        onError: (error) => {
-          const message2 = error instanceof Error ? error.message : String(error);
-          return `Stream failed: ${message2}`;
+  async resolveColumnValues(tableName, column2, constraints2) {
+    const enumValues = await this.collectEnumValues(tableName, column2);
+    if (enumValues?.length) {
+      return { kind: "Enum", values: enumValues };
+    }
+    if (constraints2) {
+      for (const constraint2 of constraints2) {
+        const checkValues = this.parseCheckConstraint(constraint2, column2.name);
+        if (checkValues?.length) {
+          return { kind: "Enum", values: checkValues };
         }
-      });
-    };
-    return result;
-  }
-  clone(overrides) {
-    return new _Agent({
-      ...this.#options,
-      ...overrides
-    });
-  }
-};
-function agent(options) {
-  return new Agent(options);
-}
-var repairToolCall = async ({
-  toolCall,
-  tools,
-  inputSchema,
-  error
-}) => {
-  console.log(
-    `Debug: ${chalk2.yellow("RepairingToolCall")}: ${toolCall.toolName}`,
-    error.name
-  );
-  if (NoSuchToolError.isInstance(error)) {
-    return null;
+      }
+    }
+    const lowCardValues = await this.collectLowCardinality(tableName, column2);
+    if (lowCardValues?.length) {
+      return { kind: "LowCardinality", values: lowCardValues };
+    }
+    return void 0;
   }
-  const tool2 = tools[toolCall.toolName];
-  const { output } = await generateText({
-    model: groq("openai/gpt-oss-20b"),
-    output: Output.object({ schema: tool2.inputSchema }),
-    prompt: [
-      `The model tried to call the tool "${toolCall.toolName}" with the following inputs:`,
-      JSON.stringify(toolCall.input),
-      `The tool accepts the following schema:`,
-      JSON.stringify(inputSchema(toolCall)),
-      "Please fix the inputs."
-    ].join("\n")
-  });
-  return { ...toolCall, input: JSON.stringify(output) };
 };
-function writeText(writer, text) {
-  const feedbackPartId = generateId2();
-  writer.write({
-    id: feedbackPartId,
-    type: "text-start"
-  });
-  writer.write({
-    id: feedbackPartId,
-    type: "text-delta",
-    delta: ` ${text}`
-  });
-  writer.write({
-    id: feedbackPartId,
-    type: "text-end"
-  });
-}
 
 // 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 "@deepagents/agent";
+import {
+  ContextEngine,
+  InMemoryContextStore,
+  agent,
+  fragment,
+  persona,
+  user
+} from "@deepagents/context";
 var ReportGrounding = class extends AbstractGrounding {
   #adapter;
   #model;
@@ -2620,7 +583,7 @@ var ReportGrounding = class extends AbstractGrounding {
   constructor(adapter, config = {}) {
     super("business_context");
     this.#adapter = adapter;
-    this.#model = config.model ?? groq2("openai/gpt-oss-20b");
+    this.#model = config.model ?? groq("openai/gpt-oss-20b");
     this.#cache = config.cache;
     this.#forceRefresh = config.forceRefresh ?? false;
   }
@@ -2652,7 +615,7 @@ var ReportGrounding = class extends AbstractGrounding {
       }),
       fragment(
         "instructions",
-        dedent2`
+        dedent`
           Write a business context that helps another agent answer questions accurately.
 
           For EACH table, do queries ONE AT A TIME:
@@ -2842,25 +805,87 @@ var TableGrounding = class extends AbstractGrounding {
 // packages/text2sql/src/lib/adapters/postgres/column-stats.postgres.grounding.ts
 var PostgresColumnStatsGrounding = class extends ColumnStatsGrounding {
   #adapter;
+  #pgStatsCache = /* @__PURE__ */ new Map();
   constructor(adapter, config = {}) {
     super(config);
     this.#adapter = adapter;
   }
+  async execute(ctx) {
+    await this.#fetchAllPgStats(ctx);
+    await super.execute(ctx);
+  }
+  async #fetchAllPgStats(ctx) {
+    const allContainers = [...ctx.tables, ...ctx.views];
+    if (allContainers.length === 0) return;
+    const conditions = allContainers.map((container) => {
+      const { schema, table: table2 } = this.#adapter.parseTableName(container.name);
+      return `(schemaname = '${this.#adapter.escapeString(schema)}' AND tablename = '${this.#adapter.escapeString(table2)}')`;
+    });
+    const rows = await this.#adapter.runQuery(`
+      SELECT
+        schemaname,
+        tablename,
+        attname,
+        null_frac,
+        n_distinct,
+        histogram_bounds::text,
+        correlation
+      FROM pg_stats
+      WHERE ${conditions.join(" OR ")}
+    `);
+    for (const row of rows) {
+      const tableName = allContainers.find((c) => {
+        const { schema, table: table2 } = this.#adapter.parseTableName(c.name);
+        return schema === row.schemaname && table2 === row.tablename;
+      })?.name;
+      if (!tableName) continue;
+      let map = this.#pgStatsCache.get(tableName);
+      if (!map) {
+        map = /* @__PURE__ */ new Map();
+        this.#pgStatsCache.set(tableName, map);
+      }
+      map.set(row.attname, row);
+    }
+  }
   async collectStats(tableName, column2) {
+    const cached = this.#pgStatsCache.get(tableName)?.get(column2.name);
+    if (cached) {
+      return this.#fromPgStats(cached);
+    }
+    return this.#collectStatsLive(tableName, column2);
+  }
+  #fromPgStats(row) {
+    const bounds = row.histogram_bounds ? this.#parsePgArray(row.histogram_bounds) : void 0;
+    const nullFraction = this.#adapter.toNumber(row.null_frac);
+    const nDistinct = this.#adapter.toNumber(row.n_distinct);
+    const correlation = this.#adapter.toNumber(row.correlation);
+    const result = {
+      ...bounds?.length && { min: bounds[0] },
+      ...bounds?.length && { max: bounds[bounds.length - 1] },
+      ...nullFraction != null && {
+        nullFraction: Math.max(0, Math.min(1, nullFraction))
+      },
+      ...nDistinct != null && { nDistinct },
+      ...correlation != null && {
+        correlation: Math.max(-1, Math.min(1, correlation))
+      }
+    };
+    return Object.keys(result).length > 0 ? result : void 0;
+  }
+  async #collectStatsLive(tableName, column2) {
     if (!this.#shouldCollectStats(column2.type)) {
       return void 0;
     }
     const { schema, table: table2 } = this.#adapter.parseTableName(tableName);
     const tableIdentifier = `${this.#adapter.quoteIdentifier(schema)}.${this.#adapter.quoteIdentifier(table2)}`;
     const columnIdentifier = this.#adapter.quoteIdentifier(column2.name);
-    const sql = `
+    const rows = await this.#adapter.runQuery(`
       SELECT
         MIN(${columnIdentifier})::text AS min_value,
         MAX(${columnIdentifier})::text 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;
     }
@@ -2885,6 +910,37 @@ var PostgresColumnStatsGrounding = class extends ColumnStatsGrounding {
       normalized
     );
   }
+  #parsePgArray(text) {
+    const inner = text.startsWith("{") && text.endsWith("}") ? text.slice(1, -1) : text;
+    if (!inner) {
+      return [];
+    }
+    const values = [];
+    let current = "";
+    let inQuote = false;
+    for (let i = 0; i < inner.length; i++) {
+      const ch = inner[i];
+      if (inQuote) {
+        if (ch === '"' && inner[i + 1] === '"') {
+          current += '"';
+          i++;
+        } else if (ch === '"') {
+          inQuote = false;
+        } else {
+          current += ch;
+        }
+      } else if (ch === '"') {
+        inQuote = true;
+      } else if (ch === ",") {
+        values.push(current);
+        current = "";
+      } else {
+        current += ch;
+      }
+    }
+    values.push(current);
+    return values;
+  }
 };
 
 // packages/text2sql/src/lib/adapters/postgres/constraint.postgres.grounding.ts
@@ -3141,6 +1197,9 @@ var PostgresColumnValuesGrounding = class extends ColumnValuesGrounding {
     return values?.length ? values : void 0;
   }
   async collectLowCardinality(tableName, column2) {
+    if (this.#isHighCardinality(column2)) {
+      return void 0;
+    }
     const { schema, table: table2 } = this.#adapter.parseTableName(tableName);
     const tableIdentifier = `${this.#adapter.quoteIdentifier(schema)}.${this.#adapter.quoteIdentifier(table2)}`;
     const columnIdentifier = this.#adapter.quoteIdentifier(column2.name);
@@ -3164,6 +1223,12 @@ var PostgresColumnValuesGrounding = class extends ColumnValuesGrounding {
     }
     return values.length ? values : void 0;
   }
+  #isHighCardinality(column2) {
+    const nDistinct = column2.stats?.nDistinct;
+    if (nDistinct == null) return false;
+    if (nDistinct > 0) return nDistinct > this.lowCardinalityLimit;
+    return true;
+  }
 };
 
 // packages/text2sql/src/lib/adapters/postgres/postgres.ts
@@ -3218,6 +1283,7 @@ var Postgres = class extends Adapter {
   grounding;
   defaultSchema = "public";
   systemSchemas = ["pg_catalog", "information_schema"];
+  formatterLanguage = "postgresql";
   constructor(options) {
     super();
     if (!options || typeof options.execute !== "function") {
@@ -3656,11 +1722,27 @@ var PostgresRowCountGrounding = class extends RowCountGrounding {
     this.#adapter = adapter;
   }
   async getRowCount(tableName) {
+    const estimate = await this.#getEstimatedRowCount(tableName);
+    if (estimate != null && estimate > 0) {
+      return Math.round(estimate);
+    }
+    return this.#getLiveRowCount(tableName);
+  }
+  async #getEstimatedRowCount(tableName) {
+    const { schema, table: table2 } = this.#adapter.parseTableName(tableName);
+    const rows = await this.#adapter.runQuery(`
+      SELECT c.reltuples::bigint AS estimate
+      FROM pg_class c
+      JOIN pg_namespace n ON n.oid = c.relnamespace
+      WHERE n.nspname = '${this.#adapter.escapeString(schema)}'
+        AND c.relname = '${this.#adapter.escapeString(table2)}'
+    `);
+    return this.#adapter.toNumber(rows[0]?.estimate);
+  }
+  async #getLiveRowCount(tableName) {
     const { schema, table: table2 } = this.#adapter.parseTableName(tableName);
     const tableIdentifier = `${this.#adapter.quoteIdentifier(schema)}.${this.#adapter.quoteIdentifier(table2)}`;
-    const rows = await this.#adapter.runQuery(
-      `SELECT COUNT(*) as count FROM ${tableIdentifier}`
-    );
+    const rows = await this.#adapter.runQuery(`SELECT COUNT(*) as count FROM ${tableIdentifier}`);
     return this.#adapter.toNumber(rows[0]?.count);
   }
 };