@deepagents/text2sql 0.10.1 → 0.11.0

package/dist/index.js

@@ -1,3 +1,94 @@
+// packages/text2sql/src/lib/fragments/schema.ts
+function dialectInfo(input) {
+  return {
+    name: "dialectInfo",
+    data: {
+      dialect: input.dialect,
+      ...input.version && { version: input.version },
+      ...input.database && { database: input.database }
+    }
+  };
+}
+function table(input) {
+  return {
+    name: "table",
+    data: {
+      name: input.name,
+      ...input.schema && { schema: input.schema },
+      ...input.rowCount != null && { rowCount: input.rowCount },
+      ...input.sizeHint && { sizeHint: input.sizeHint },
+      columns: input.columns,
+      ...input.indexes?.length && { indexes: input.indexes },
+      ...input.constraints?.length && { constraints: input.constraints }
+    }
+  };
+}
+function column(input) {
+  return {
+    name: "column",
+    data: {
+      name: input.name,
+      type: input.type,
+      ...input.pk && { pk: true },
+      ...input.fk && { fk: input.fk },
+      ...input.unique && { unique: true },
+      ...input.notNull && { notNull: true },
+      ...input.default && { default: input.default },
+      ...input.indexed && { indexed: true },
+      ...input.values?.length && { values: input.values },
+      ...input.stats && { stats: input.stats }
+    }
+  };
+}
+function index(input) {
+  return {
+    name: "index",
+    data: {
+      name: input.name,
+      columns: input.columns,
+      ...input.unique && { unique: true },
+      ...input.type && { type: input.type }
+    }
+  };
+}
+function constraint(input) {
+  return {
+    name: "constraint",
+    data: {
+      name: input.name,
+      type: input.type,
+      ...input.columns?.length && { columns: input.columns },
+      ...input.definition && { definition: input.definition },
+      ...input.defaultValue && { defaultValue: input.defaultValue },
+      ...input.referencedTable && { referencedTable: input.referencedTable },
+      ...input.referencedColumns?.length && {
+        referencedColumns: input.referencedColumns
+      }
+    }
+  };
+}
+function view(input) {
+  return {
+    name: "view",
+    data: {
+      name: input.name,
+      ...input.schema && { schema: input.schema },
+      columns: input.columns,
+      ...input.definition && { definition: input.definition }
+    }
+  };
+}
+function relationship(input) {
+  return {
+    name: "relationship",
+    data: {
+      from: input.from,
+      to: input.to,
+      ...input.cardinality && { cardinality: input.cardinality }
+    }
+  };
+}
+
 // packages/text2sql/src/lib/adapters/groundings/context.ts
 function createGroundingContext() {
   return {
@@ -10,24 +101,169 @@ function createGroundingContext() {
 
 // packages/text2sql/src/lib/adapters/adapter.ts
 var Adapter = class {
+  /**
+   * Introspect the database schema and return context fragments.
+   *
+   * Executes all configured groundings to populate the context, then
+   * generates fragments from the complete context data.
+   *
+   * @param ctx - Optional grounding context for sharing state between groundings
+   * @returns Array of context fragments representing the database schema
+   */
   async introspect(ctx = createGroundingContext()) {
-    const lines = [];
     for (const fn of this.grounding) {
       const grounding = fn(this);
-      lines.push({
-        tag: grounding.tag,
-        fn: await grounding.execute(ctx)
-      });
+      await grounding.execute(ctx);
+    }
+    return this.#toSchemaFragments(ctx);
+  }
+  /**
+   * Convert complete grounding context to schema fragments.
+   * Called after all groundings have populated ctx with data.
+   */
+  #toSchemaFragments(ctx) {
+    const fragments2 = [];
+    if (ctx.info) {
+      fragments2.push(
+        dialectInfo({
+          dialect: ctx.info.dialect,
+          version: ctx.info.version,
+          database: ctx.info.database
+        })
+      );
+    }
+    for (const t of ctx.tables) {
+      fragments2.push(this.#tableToFragment(t));
+    }
+    for (const v of ctx.views) {
+      fragments2.push(this.#viewToFragment(v));
+    }
+    const tableMap = new Map(ctx.tables.map((t) => [t.name, t]));
+    for (const rel of ctx.relationships) {
+      const sourceTable = tableMap.get(rel.table);
+      const targetTable = tableMap.get(rel.referenced_table);
+      fragments2.push(
+        this.#relationshipToFragment(rel, sourceTable, targetTable)
+      );
+    }
+    if (ctx.report) {
+      fragments2.push({ name: "businessContext", data: ctx.report });
+    }
+    return fragments2;
+  }
+  /**
+   * Convert a Table to a table fragment with nested column, index, and constraint fragments.
+   */
+  #tableToFragment(t) {
+    const pkConstraint = t.constraints?.find((c) => c.type === "PRIMARY_KEY");
+    const pkColumns = new Set(pkConstraint?.columns ?? []);
+    const notNullColumns = new Set(
+      t.constraints?.filter((c) => c.type === "NOT_NULL").flatMap((c) => c.columns ?? []) ?? []
+    );
+    const defaultByColumn = /* @__PURE__ */ new Map();
+    for (const c of t.constraints?.filter((c2) => c2.type === "DEFAULT") ?? []) {
+      for (const col of c.columns ?? []) {
+        if (c.defaultValue != null) {
+          defaultByColumn.set(col, c.defaultValue);
+        }
+      }
     }
-    return lines.map(({ fn, tag }) => {
-      const description = fn();
-      if (description === null) {
-        return "";
+    const uniqueColumns = new Set(
+      t.constraints?.filter((c) => c.type === "UNIQUE" && c.columns?.length === 1).flatMap((c) => c.columns ?? []) ?? []
+    );
+    const fkByColumn = /* @__PURE__ */ new Map();
+    for (const c of t.constraints?.filter((c2) => c2.type === "FOREIGN_KEY") ?? []) {
+      const cols = c.columns ?? [];
+      const refCols = c.referencedColumns ?? [];
+      for (let i = 0; i < cols.length; i++) {
+        const refCol = refCols[i] ?? refCols[0] ?? cols[i];
+        fkByColumn.set(cols[i], `${c.referencedTable}.${refCol}`);
       }
-      return `<${tag}>
-${description}
-</${tag}>`;
-    }).join("\n");
+    }
+    const columnFragments = t.columns.map(
+      (col) => column({
+        name: col.name,
+        type: col.type,
+        pk: pkColumns.has(col.name) || void 0,
+        fk: fkByColumn.get(col.name),
+        unique: uniqueColumns.has(col.name) || void 0,
+        notNull: notNullColumns.has(col.name) || void 0,
+        default: defaultByColumn.get(col.name),
+        indexed: col.isIndexed || void 0,
+        values: col.values,
+        stats: col.stats
+      })
+    );
+    const indexFragments = (t.indexes ?? []).map(
+      (idx) => index({
+        name: idx.name,
+        columns: idx.columns,
+        unique: idx.unique,
+        type: idx.type
+      })
+    );
+    const constraintFragments = (t.constraints ?? []).filter(
+      (c) => c.type === "CHECK" || c.type === "UNIQUE" && (c.columns?.length ?? 0) > 1
+    ).map(
+      (c) => constraint({
+        name: c.name,
+        type: c.type,
+        columns: c.columns,
+        definition: c.definition
+      })
+    );
+    return table({
+      name: t.name,
+      schema: t.schema,
+      rowCount: t.rowCount,
+      sizeHint: t.sizeHint,
+      columns: columnFragments,
+      indexes: indexFragments.length > 0 ? indexFragments : void 0,
+      constraints: constraintFragments.length > 0 ? constraintFragments : void 0
+    });
+  }
+  /**
+   * Convert a View to a view fragment with nested column fragments.
+   */
+  #viewToFragment(v) {
+    const columnFragments = v.columns.map(
+      (col) => column({
+        name: col.name,
+        type: col.type,
+        values: col.values,
+        stats: col.stats
+      })
+    );
+    return view({
+      name: v.name,
+      schema: v.schema,
+      columns: columnFragments,
+      definition: v.definition
+    });
+  }
+  /**
+   * Convert a Relationship to a relationship fragment.
+   * Infers cardinality from row counts if available.
+   */
+  #relationshipToFragment(rel, sourceTable, targetTable) {
+    const sourceCount = sourceTable?.rowCount;
+    const targetCount = targetTable?.rowCount;
+    let cardinality;
+    if (sourceCount != null && targetCount != null && targetCount > 0) {
+      const ratio = sourceCount / targetCount;
+      if (ratio > 5) {
+        cardinality = "many-to-one";
+      } else if (ratio < 1.2 && ratio > 0.8) {
+        cardinality = "one-to-one";
+      } else if (ratio < 0.2) {
+        cardinality = "one-to-many";
+      }
+    }
+    return relationship({
+      from: { table: rel.table, columns: rel.from },
+      to: { table: rel.referenced_table, columns: rel.to },
+      cardinality
+    });
   }
   /**
    * Convert unknown database value to number.
@@ -82,7 +318,7 @@ ${description}
 };
 function filterTablesByName(tables, filter) {
   if (!filter) return tables;
-  return tables.filter((table) => matchesFilter(table.name, filter));
+  return tables.filter((table2) => matchesFilter(table2.name, filter));
 }
 function filterRelationshipsByTables(relationships, tableNames) {
   if (tableNames === void 0) {
@@ -103,7 +339,7 @@ function applyTablesFilter(tables, relationships, filter) {
     getTablesWithRelated(tables, relationships, filter)
   );
   return {
-    tables: tables.filter((table) => allowedNames.has(table.name)),
+    tables: tables.filter((table2) => allowedNames.has(table2.name)),
     relationships: filterRelationshipsByTables(relationships, allowedNames)
   };
 }
@@ -150,629 +386,1841 @@ function getTablesWithRelated(allTables, relationships, filter) {
 }
 
 // packages/text2sql/src/lib/agents/developer.agent.ts
-import { groq as groq3 } from "@ai-sdk/groq";
 import { tool } from "ai";
 import dedent2 from "dedent";
-import z3 from "zod";
-import { agent as agent3, generate as generate2, toState } from "@deepagents/agent";
-import { scratchpad_tool } from "@deepagents/toolbox";
-
-// packages/text2sql/src/lib/agents/explainer.agent.ts
-import { groq } from "@ai-sdk/groq";
-import dedent from "dedent";
-import z from "zod";
-import { agent } from "@deepagents/agent";
-var explainerAgent = agent({
-  name: "explainer",
-  model: groq("openai/gpt-oss-20b"),
-  prompt: (state) => dedent`
-    You are an expert SQL tutor.
-    Explain the following SQL query in plain English to a non-technical user.
-    Focus on the intent and logic, not the syntax.
-
-    <sql>
-    ${state?.sql}
-    </sql>
-  `,
-  output: z.object({
-    explanation: z.string().describe("The explanation of the SQL query.")
-  })
-});
-
-// packages/text2sql/src/lib/agents/sql.agent.ts
-import { groq as groq2 } from "@ai-sdk/groq";
-import {
-  APICallError,
-  JSONParseError,
-  NoContentGeneratedError,
-  NoObjectGeneratedError,
-  NoOutputGeneratedError,
-  TypeValidationError,
-  defaultSettingsMiddleware,
-  wrapLanguageModel
-} from "ai";
-import { Console } from "node:console";
-import { createWriteStream } from "node:fs";
-import pRetry from "p-retry";
 import z2 from "zod";
+import { generate, toState } from "@deepagents/agent";
+
+// packages/context/dist/index.js
+import { encode } from "gpt-tokenizer";
+import { generateId } from "ai";
+import pluralize from "pluralize";
+import { titlecase } from "stringcase";
+import { defineCommand } from "just-bash";
+import spawn from "nano-spawn";
+import "bash-tool";
+import spawn2 from "nano-spawn";
 import {
-  agent as agent2,
-  generate,
-  toOutput,
-  user
-} from "@deepagents/agent";
-
-// packages/text2sql/src/lib/teach/xml.ts
-function wrapBlock(tag, children) {
-  const content = children.filter((child) => Boolean(child)).join("\n");
-  if (!content) {
-    return "";
+  createBashTool
+} from "bash-tool";
+import YAML from "yaml";
+import { DatabaseSync } from "node:sqlite";
+import {
+  Output,
+  convertToModelMessages,
+  createUIMessageStream,
+  generateId as generateId2,
+  generateText,
+  smoothStream,
+  stepCountIs,
+  streamText
+} from "ai";
+import chalk from "chalk";
+import "zod";
+import "@deepagents/agent";
+var defaultTokenizer = {
+  encode(text) {
+    return encode(text);
+  },
+  count(text) {
+    return encode(text).length;
   }
-  return `<${tag}>
-${indentBlock(content, 2)}
-</${tag}>`;
-}
-function list(tag, values, childTag) {
-  if (!values.length) {
-    return "";
+};
+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 info = {
+          id: model.id,
+          name: model.name,
+          family: model.family,
+          cost: model.cost,
+          limit: model.limit,
+          provider: providerId
+        };
+        this.#cache.set(`${providerId}:${modelId}`, info);
+      }
+    }
+    this.#loaded = true;
   }
-  const children = values.map((value) => leaf(childTag, value)).join("\n");
-  return `<${tag}>
-${indentBlock(children, 2)}
-</${tag}>`;
-}
-function leaf(tag, value) {
-  const safe = escapeXml(value);
-  if (safe.includes("\n")) {
-    return `<${tag}>
-${indentBlock(safe, 2)}
-</${tag}>`;
+  /**
+   * Get model info by ID
+   * @param modelId - Model ID (e.g., "openai:gpt-4o")
+   */
+  get(modelId) {
+    return this.#cache.get(modelId);
   }
-  return `<${tag}>${safe}</${tag}>`;
-}
-function indentBlock(text, spaces) {
-  if (!text.trim()) {
-    return "";
+  /**
+   * Check if a model exists in the registry
+   */
+  has(modelId) {
+    return this.#cache.has(modelId);
   }
-  const padding = " ".repeat(spaces);
-  return text.split("\n").map((line) => line.length ? padding + line : padding).join("\n");
-}
-function escapeXml(value) {
-  if (value == null) {
-    return "";
+  /**
+   * List all available model IDs
+   */
+  list() {
+    return [...this.#cache.keys()];
   }
-  return value.replaceAll(/&/g, "&amp;").replaceAll(/</g, "&lt;").replaceAll(/>/g, "&gt;").replaceAll(/"/g, "&quot;").replaceAll(/'/g, "&apos;");
-}
-
-// packages/text2sql/src/lib/teach/teachables.ts
-function term(name, definition) {
-  return {
-    type: "term",
-    encode: () => ({ type: "term", name, definition }),
-    decode: () => wrapBlock("term", [leaf("name", name), leaf("definition", definition)])
-  };
-}
-function hint(text) {
-  return {
-    type: "hint",
-    encode: () => ({ type: "hint", text }),
-    decode: () => leaf("hint", text)
-  };
-}
-function guardrail(input) {
-  const { rule, reason, action } = input;
-  return {
-    type: "guardrail",
-    encode: () => ({ type: "guardrail", rule, reason, action }),
-    decode: () => wrapBlock("guardrail", [
-      leaf("rule", rule),
-      reason ? leaf("reason", reason) : "",
-      action ? leaf("action", action) : ""
-    ])
-  };
-}
-function explain(input) {
-  const { concept, explanation, therefore } = input;
-  return {
-    type: "explain",
-    encode: () => ({ type: "explain", concept, explanation, therefore }),
-    decode: () => wrapBlock("explanation", [
-      leaf("concept", concept),
-      leaf("details", explanation),
-      therefore ? leaf("therefore", therefore) : ""
-    ])
-  };
-}
-function example(input) {
-  const { question, answer, note } = input;
-  return {
-    type: "example",
-    encode: () => ({ type: "example", question, answer, note }),
-    decode: () => wrapBlock("example", [
-      leaf("question", question),
-      leaf("answer", answer),
-      note ? leaf("note", note) : ""
-    ])
-  };
-}
-function clarification(input) {
-  const { when, ask, reason } = input;
-  return {
-    type: "clarification",
-    encode: () => ({ type: "clarification", when, ask, reason }),
-    decode: () => wrapBlock("clarification", [
-      leaf("when", when),
-      leaf("ask", ask),
-      leaf("reason", reason)
-    ])
-  };
-}
-function workflow(input) {
-  const { task, steps, triggers, notes } = input;
-  return {
-    type: "workflow",
-    encode: () => ({ type: "workflow", task, steps, triggers, notes }),
-    decode: () => wrapBlock("workflow", [
-      leaf("task", task),
-      triggers?.length ? list("triggers", triggers, "trigger") : "",
-      list("steps", steps, "step"),
-      notes ? leaf("notes", notes) : ""
-    ])
-  };
-}
-function quirk(input) {
-  const { issue, workaround } = input;
-  return {
-    type: "quirk",
-    encode: () => ({ type: "quirk", issue, workaround }),
-    decode: () => wrapBlock("quirk", [
-      leaf("issue", issue),
-      leaf("workaround", workaround)
-    ])
-  };
-}
-function styleGuide(input) {
-  const { prefer, never, always } = input;
-  return {
-    type: "styleGuide",
-    encode: () => ({ type: "styleGuide", prefer, never, always }),
-    decode: () => wrapBlock("style_guide", [
-      leaf("prefer", prefer),
-      always ? leaf("always", always) : "",
-      never ? leaf("never", never) : ""
-    ])
-  };
-}
-function analogy(input) {
-  const { concept, relationship, insight, therefore, pitfall } = input;
-  return {
-    type: "analogy",
-    encode: () => ({
-      type: "analogy",
-      concept,
-      relationship,
-      insight,
-      therefore,
-      pitfall
-    }),
-    decode: () => wrapBlock("analogy", [
-      list("concepts", concept, "concept"),
-      leaf("relationship", relationship),
-      insight ? leaf("insight", insight) : "",
-      therefore ? leaf("therefore", therefore) : "",
-      pitfall ? leaf("pitfall", pitfall) : ""
-    ])
-  };
-}
-function glossary(entries) {
-  return {
-    type: "glossary",
-    encode: () => ({ type: "glossary", entries }),
-    decode: () => wrapBlock(
-      "glossary",
-      Object.entries(entries).map(
-        ([term2, sql]) => wrapBlock("entry", [leaf("term", term2), leaf("sql", sql)])
-      )
-    )
-  };
+  /**
+   * 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 identity(input) {
-  const { name, role } = input;
-  return {
-    type: "identity",
-    encode: () => ({ type: "identity", name, role }),
-    decode: () => wrapBlock("identity", [
-      name ? leaf("name", name) : "",
-      role ? leaf("role", role) : ""
-    ])
-  };
+function isFragment(data) {
+  return typeof data === "object" && data !== null && "name" in data && "data" in data && typeof data.name === "string";
 }
-function persona(input) {
-  const { name, role, tone } = input;
-  return {
-    type: "persona",
-    encode: () => ({ type: "persona", name, role, tone: tone ?? "" }),
-    decode: () => wrapBlock("persona", [
-      leaf("name", name),
-      leaf("role", role),
-      tone ? leaf("tone", tone) : ""
-    ])
-  };
+function isFragmentObject(data) {
+  return typeof data === "object" && data !== null && !Array.isArray(data) && !isFragment(data);
 }
-function alias(termName, meaning) {
-  return {
-    type: "alias",
-    encode: () => ({ type: "alias", term: termName, meaning }),
-    decode: () => wrapBlock("alias", [leaf("term", termName), leaf("meaning", meaning)])
-  };
+function isMessageFragment(fragment2) {
+  return fragment2.type === "message";
 }
-function preference(aspect, value) {
+function user(content) {
+  const message2 = typeof content === "string" ? {
+    id: generateId(),
+    role: "user",
+    parts: [{ type: "text", text: content }]
+  } : content;
   return {
-    type: "preference",
-    encode: () => ({ type: "preference", aspect, value }),
-    decode: () => wrapBlock("preference", [leaf("aspect", aspect), leaf("value", value)])
+    id: message2.id,
+    name: "user",
+    data: "content",
+    type: "message",
+    persist: true,
+    codec: {
+      decode() {
+        return message2;
+      },
+      encode() {
+        return message2;
+      }
+    }
   };
 }
-function context(description) {
+function assistant(message2) {
   return {
-    type: "context",
-    encode: () => ({ type: "context", description }),
-    decode: () => leaf("context", description)
+    id: message2.id,
+    name: "assistant",
+    data: "content",
+    type: "message",
+    persist: true,
+    codec: {
+      decode() {
+        return message2;
+      },
+      encode() {
+        return message2;
+      }
+    }
   };
 }
-function correction(subject, clarification2) {
+function message(content) {
+  const message2 = typeof content === "string" ? {
+    id: generateId(),
+    role: "user",
+    parts: [{ type: "text", text: content }]
+  } : content;
   return {
-    type: "correction",
-    encode: () => ({ type: "correction", subject, clarification: clarification2 }),
-    decode: () => wrapBlock("correction", [
-      leaf("subject", subject),
-      leaf("clarification", clarification2)
-    ])
+    id: message2.id,
+    name: "message",
+    data: "content",
+    type: "message",
+    persist: true,
+    codec: {
+      decode() {
+        return message2;
+      },
+      encode() {
+        return message2;
+      }
+    }
   };
 }
-function teachable(tag, ...teachables) {
-  return {
-    type: "user_profile",
-    encode: () => teachables[0]?.encode() ?? { type: "context", description: "" },
-    decode: () => toInstructions(tag, ...teachables)
-  };
+function assistantText(content, options) {
+  const id = options?.id ?? crypto.randomUUID();
+  return assistant({
+    id,
+    role: "assistant",
+    parts: [{ type: "text", text: content }]
+  });
 }
-function toInstructions(tag, ...teachables) {
-  if (!teachables.length) {
-    return "";
+var ContextRenderer = class {
+  options;
+  constructor(options = {}) {
+    this.options = options;
   }
-  const grouped = /* @__PURE__ */ new Map();
-  for (const teachable2 of teachables) {
-    const existing = grouped.get(teachable2.type) ?? [];
-    existing.push(teachable2);
-    grouped.set(teachable2.type, existing);
+  /**
+   * Check if data is a primitive (string, number, boolean).
+   */
+  isPrimitive(data) {
+    return typeof data === "string" || typeof data === "number" || typeof data === "boolean";
   }
-  const definedTypes = new Set(SECTION_ORDER.map((s) => s.type));
-  const sections = SECTION_ORDER.map(({ type, tag: tag2 }) => {
-    const items = grouped.get(type);
-    if (!items?.length) {
-      return "";
+  /**
+   * Group fragments by name for groupFragments option.
+   */
+  groupByName(fragments2) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const fragment2 of fragments2) {
+      const existing = groups.get(fragment2.name) ?? [];
+      existing.push(fragment2);
+      groups.set(fragment2.name, existing);
     }
-    const renderedItems = items.map((item) => item.decode().trim()).filter(Boolean).map((item) => indentBlock(item, 2)).join("\n");
-    if (!renderedItems.length) {
+    return groups;
+  }
+  /**
+   * Template method - dispatches value to appropriate handler.
+   */
+  renderValue(key, value, ctx) {
+    if (value == null) {
       return "";
     }
-    return `<${tag2}>
-${renderedItems}
-</${tag2}>`;
-  }).filter((section) => Boolean(section));
-  for (const [type, items] of grouped) {
-    if (definedTypes.has(type)) {
-      continue;
+    if (isFragment(value)) {
+      return this.renderFragment(value, ctx);
+    }
+    if (Array.isArray(value)) {
+      return this.renderArray(key, value, ctx);
     }
-    const renderedItems = items.map((item) => item.decode().trim()).filter(Boolean).map((item) => indentBlock(item, 2)).join("\n");
-    if (renderedItems.length) {
-      sections.push(renderedItems);
+    if (isFragmentObject(value)) {
+      return this.renderObject(key, value, ctx);
     }
+    return this.renderPrimitive(key, String(value), ctx);
   }
-  if (!sections.length) {
-    return "";
+  /**
+   * Render all entries of an object.
+   */
+  renderEntries(data, ctx) {
+    return Object.entries(data).map(([key, value]) => this.renderValue(key, value, ctx)).filter(Boolean);
   }
-  const content = indentBlock(sections.join("\n"), 2);
-  return `<${tag}>
-${content}
-</${tag}>`;
-}
-var SECTION_ORDER = [
-  // User context (render first - most important for personalization)
-  { type: "identity", tag: "identity" },
-  { type: "persona", tag: "persona" },
-  { type: "context", tag: "user_context" },
-  { type: "preference", tag: "user_preferences" },
-  { type: "alias", tag: "user_vocabulary" },
-  { type: "correction", tag: "user_corrections" },
-  // Domain knowledge
-  { type: "guardrail", tag: "guardrails" },
-  { type: "styleGuide", tag: "style_guides" },
-  { type: "hint", tag: "hints" },
-  { type: "clarification", tag: "clarifications" },
-  { type: "workflow", tag: "workflows" },
-  { type: "quirk", tag: "quirks" },
-  { type: "term", tag: "terminology" },
-  { type: "explain", tag: "explanations" },
-  { type: "analogy", tag: "analogies" },
-  { type: "glossary", tag: "glossary" },
-  { type: "example", tag: "examples" }
-];
-function toTeachables(generated) {
-  return generated.map((item) => {
-    switch (item.type) {
-      case "persona":
-        return persona({ name: item.name, role: item.role, tone: item.tone });
-      case "term":
-        return term(item.name, item.definition);
-      case "hint":
-        return hint(item.text);
-      case "guardrail":
-        return guardrail({
-          rule: item.rule,
-          reason: item.reason,
-          action: item.action
-        });
-      case "explain":
-        return explain({
-          concept: item.concept,
-          explanation: item.explanation,
-          therefore: item.therefore
-        });
-      case "example":
-        return example({
-          question: item.question,
-          answer: item.answer,
-          note: item.note
-        });
-      case "clarification":
-        return clarification({
-          when: item.when,
-          ask: item.ask,
-          reason: item.reason
-        });
-      case "workflow":
-        return workflow({
-          task: item.task,
-          steps: item.steps,
-          triggers: item.triggers,
-          notes: item.notes
-        });
-      case "quirk":
-        return quirk({
-          issue: item.issue,
-          workaround: item.workaround
-        });
-      case "styleGuide":
-        return styleGuide({
-          prefer: item.prefer,
-          never: item.never,
-          always: item.always
-        });
-      case "analogy":
-        return analogy({
-          concept: item.concept,
-          relationship: item.relationship,
-          insight: item.insight,
-          therefore: item.therefore,
-          pitfall: item.pitfall
-        });
-      case "glossary":
-        return glossary(item.entries);
-      // User-specific teachable types
-      case "identity":
-        return identity({ name: item.name, role: item.role });
-      case "alias":
-        return alias(item.term, item.meaning);
-      case "preference":
-        return preference(item.aspect, item.value);
-      case "context":
-        return context(item.description);
-      case "correction":
-        return correction(item.subject, item.clarification);
+};
+var XmlRenderer = class extends ContextRenderer {
+  render(fragments2) {
+    return fragments2.map((f) => this.#renderTopLevel(f)).filter(Boolean).join("\n");
+  }
+  #renderTopLevel(fragment2) {
+    if (this.isPrimitive(fragment2.data)) {
+      return this.#leafRoot(fragment2.name, String(fragment2.data));
     }
-  });
-}
-
-// packages/text2sql/src/lib/agents/sql.agent.ts
-var logger = new Console({
-  stdout: createWriteStream("./sql-agent.log", { flags: "a" }),
-  stderr: createWriteStream("./sql-agent-error.log", { flags: "a" }),
-  inspectOptions: { depth: null }
-});
-var RETRY_TEMPERATURES = [0, 0.2, 0.3];
-var sqlQueryAgent = agent2({
-  name: "text2sql",
-  model: groq2("openai/gpt-oss-20b"),
-  logging: process.env.AGENT_LOGGING === "true",
-  output: z2.union([
-    z2.object({
-      sql: z2.string().describe("The SQL query that answers the question"),
-      reasoning: z2.string().optional().describe("The reasoning steps taken to generate the SQL")
-    }),
-    z2.object({
-      error: z2.string().describe(
-        "Error message explaining why the question cannot be answered with the given schema"
-      )
-    })
-  ]),
-  prompt: (state) => {
-    return `
-    ${state?.teachings || ""}
-    ${state?.introspection || ""}
-  `;
+    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]);
+    }
+    return this.#wrap(
+      fragment2.name,
+      this.renderEntries(fragment2.data, { depth: 1, path: [] })
+    );
   }
-});
-function extractSql(output) {
-  const match = output.match(/```sql\n?([\s\S]*?)```/);
-  return match ? match[1].trim() : output.trim();
+  #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) {
+        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);
+    }
+    const children = this.renderEntries(data, { ...ctx, depth: ctx.depth + 1 });
+    return this.#wrapIndented(name, children, ctx.depth);
+  }
+  #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) {
+        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) => 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;
+  #branchName;
+  #branch = null;
+  #chatData = null;
+  #initialized = false;
+  constructor(options) {
+    if (!options.chatId) {
+      throw new Error("chatId is required");
+    }
+    this.#store = options.store;
+    this.#chatId = options.chatId;
+    this.#branchName = options.branch ?? "main";
+  }
+  /**
+   * 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 });
+    const existingBranch = await this.#store.getBranch(
+      this.#chatId,
+      this.#branchName
+    );
+    if (existingBranch) {
+      this.#branch = existingBranch;
+    } else {
+      this.#branch = {
+        id: crypto.randomUUID(),
+        chatId: this.#chatId,
+        name: this.#branchName,
+        headMessageId: null,
+        isActive: true,
+        createdAt: Date.now()
+      };
+      await this.#store.createBranch(this.#branch);
+    }
+    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(
+      (b) => b.name === this.#branchName || b.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
+    };
+  }
+  /**
+   * 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,
+      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(...fragments2) {
+    for (const fragment2 of fragments2) {
+      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' })
+   *   .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 (const fragment2 of this.#pendingMessages) {
+      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;
+    }
+    let parentId = this.#branch.headMessageId;
+    const now = Date.now();
+    for (const fragment2 of this.#pendingMessages) {
+      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 = [];
+  }
+  /**
+   * 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);
+  }
+  /**
+   * 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;
+  }
+  /**
+   * Inspect the full context state for debugging.
+   * Returns a comprehensive JSON-serializable object with all 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 hint(text) {
+  return {
+    name: "hint",
+    data: text
+  };
 }
-var marker = Symbol("SQLValidationError");
-var SQLValidationError = class _SQLValidationError extends Error {
-  [marker];
-  constructor(message) {
-    super(message);
-    this.name = "SQLValidationError";
-    this[marker] = true;
+function guardrail(input) {
+  return {
+    name: "guardrail",
+    data: {
+      rule: input.rule,
+      ...input.reason && { reason: input.reason },
+      ...input.action && { action: input.action }
+    }
+  };
+}
+function clarification(input) {
+  return {
+    name: "clarification",
+    data: {
+      when: input.when,
+      ask: input.ask,
+      reason: input.reason
+    }
+  };
+}
+function workflow(input) {
+  return {
+    name: "workflow",
+    data: {
+      task: input.task,
+      steps: input.steps,
+      ...input.triggers?.length && { triggers: input.triggers },
+      ...input.notes && { notes: input.notes }
+    }
+  };
+}
+function styleGuide(input) {
+  return {
+    name: "styleGuide",
+    data: {
+      prefer: input.prefer,
+      ...input.never && { never: input.never },
+      ...input.always && { always: input.always }
+    }
+  };
+}
+function persona(input) {
+  return {
+    name: "persona",
+    data: {
+      name: input.name,
+      role: input.role,
+      ...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") {
+      return result;
+    }
+    currentPart = result.part;
+  }
+  return pass(currentPart);
+}
+var STORE_DDL = `
+-- Chats table
+-- createdAt/updatedAt: DEFAULT for insert, inline SET for updates
+CREATE TABLE IF NOT EXISTS chats (
+  id TEXT PRIMARY KEY,
+  title TEXT,
+  metadata TEXT,
+  createdAt INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+  updatedAt INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)
+);
+
+CREATE INDEX IF NOT EXISTS idx_chats_updatedAt ON chats(updatedAt);
+
+-- Messages table (nodes in the DAG)
+CREATE TABLE IF NOT EXISTS messages (
+  id TEXT PRIMARY KEY,
+  chatId TEXT NOT NULL,
+  parentId TEXT,
+  name TEXT NOT NULL,
+  type TEXT,
+  data TEXT NOT NULL,
+  createdAt INTEGER NOT NULL,
+  FOREIGN KEY (chatId) REFERENCES chats(id) ON DELETE CASCADE,
+  FOREIGN KEY (parentId) REFERENCES messages(id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_messages_chatId ON messages(chatId);
+CREATE INDEX IF NOT EXISTS idx_messages_parentId ON messages(parentId);
+
+-- Branches table (pointers to head messages)
+CREATE TABLE IF NOT EXISTS branches (
+  id TEXT PRIMARY KEY,
+  chatId TEXT NOT NULL,
+  name TEXT NOT NULL,
+  headMessageId TEXT,
+  isActive INTEGER NOT NULL DEFAULT 0,
+  createdAt INTEGER NOT NULL,
+  FOREIGN KEY (chatId) REFERENCES chats(id) ON DELETE CASCADE,
+  FOREIGN KEY (headMessageId) REFERENCES messages(id),
+  UNIQUE(chatId, name)
+);
+
+CREATE INDEX IF NOT EXISTS idx_branches_chatId ON branches(chatId);
+
+-- Checkpoints table (pointers to message nodes)
+CREATE TABLE IF NOT EXISTS checkpoints (
+  id TEXT PRIMARY KEY,
+  chatId TEXT NOT NULL,
+  name TEXT NOT NULL,
+  messageId TEXT NOT NULL,
+  createdAt INTEGER NOT NULL,
+  FOREIGN KEY (chatId) REFERENCES chats(id) ON DELETE CASCADE,
+  FOREIGN KEY (messageId) REFERENCES messages(id),
+  UNIQUE(chatId, name)
+);
+
+CREATE INDEX IF NOT EXISTS idx_checkpoints_chatId ON checkpoints(chatId);
+
+-- FTS5 virtual table for full-text search
+-- messageId/chatId/name are UNINDEXED (stored but not searchable, used for filtering/joining)
+-- Only 'content' is indexed for full-text search
+CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
+  messageId UNINDEXED,
+  chatId UNINDEXED,
+  name UNINDEXED,
+  content,
+  tokenize='porter unicode61'
+);
+`;
+var SqliteContextStore = class extends ContextStore {
+  #db;
+  constructor(path3) {
+    super();
+    this.#db = new DatabaseSync(path3);
+    this.#db.exec("PRAGMA foreign_keys = ON");
+    this.#db.exec(STORE_DDL);
+  }
+  // ==========================================================================
+  // Chat Operations
+  // ==========================================================================
+  async createChat(chat) {
+    this.#db.prepare(
+      `INSERT INTO chats (id, title, metadata)
+         VALUES (?, ?, ?)`
+    ).run(
+      chat.id,
+      chat.title ?? null,
+      chat.metadata ? JSON.stringify(chat.metadata) : null
+    );
+  }
+  async upsertChat(chat) {
+    const row = this.#db.prepare(
+      `INSERT INTO chats (id, title, metadata)
+         VALUES (?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET id = excluded.id
+         RETURNING *`
+    ).get(
+      chat.id,
+      chat.title ?? null,
+      chat.metadata ? JSON.stringify(chat.metadata) : null
+    );
+    return {
+      id: row.id,
+      title: row.title ?? void 0,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    };
+  }
+  async getChat(chatId) {
+    const row = this.#db.prepare("SELECT * FROM chats WHERE id = ?").get(chatId);
+    if (!row) {
+      return void 0;
+    }
+    return {
+      id: row.id,
+      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,
+      title: row.title ?? void 0,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    };
+  }
+  async listChats() {
+    const rows = this.#db.prepare(
+      `SELECT
+          c.id,
+          c.title,
+          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
+        GROUP BY c.id
+        ORDER BY c.updatedAt DESC`
+    ).all();
+    return rows.map((row) => ({
+      id: row.id,
+      title: row.title ?? void 0,
+      messageCount: row.messageCount,
+      branchCount: row.branchCount,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    }));
+  }
+  // ==========================================================================
+  // Message Operations (Graph Nodes)
+  // ==========================================================================
+  async addMessage(message2) {
+    this.#db.prepare(
+      `INSERT INTO messages (id, chatId, parentId, name, type, data, createdAt)
+         VALUES (?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           parentId = excluded.parentId,
+           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.#db.prepare(`DELETE FROM messages_fts WHERE messageId = ?`).run(message2.id);
+    this.#db.prepare(
+      `INSERT INTO messages_fts(messageId, chatId, name, content)
+         VALUES (?, ?, ?, ?)`
+    ).run(message2.id, message2.chatId, message2.name, content);
+  }
+  async getMessage(messageId) {
+    const row = this.#db.prepare("SELECT * FROM messages WHERE id = ?").get(messageId);
+    if (!row) {
+      return void 0;
+    }
+    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.#db.prepare(
+      `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
+        )
+        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.#db.prepare(
+      "SELECT EXISTS(SELECT 1 FROM messages WHERE parentId = ?) as hasChildren"
+    ).get(messageId);
+    return row.hasChildren === 1;
+  }
+  // ==========================================================================
+  // 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.#db.prepare("SELECT * FROM branches WHERE chatId = ? AND isActive = 1").get(chatId);
+    if (!row) {
+      return void 0;
+    }
+    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.#db.prepare("UPDATE branches SET headMessageId = ? WHERE id = ?").run(messageId, branchId);
+  }
+  async listBranches(chatId) {
+    const branches = this.#db.prepare(
+      `SELECT
+          b.id,
+          b.name,
+          b.headMessageId,
+          b.isActive,
+          b.createdAt
+        FROM branches b
+        WHERE b.chatId = ?
+        ORDER BY b.createdAt ASC`
+    ).all(chatId);
+    const result = [];
+    for (const branch of branches) {
+      let messageCount = 0;
+      if (branch.headMessageId) {
+        const countRow = this.#db.prepare(
+          `WITH RECURSIVE chain AS (
+              SELECT id, parentId FROM messages WHERE id = ?
+              UNION ALL
+              SELECT m.id, m.parentId FROM messages m
+              INNER JOIN chain c ON m.id = c.parentId
+            )
+            SELECT COUNT(*) as count FROM chain`
+        ).get(branch.headMessageId);
+        messageCount = countRow.count;
+      }
+      result.push({
+        id: branch.id,
+        name: branch.name,
+        headMessageId: branch.headMessageId,
+        isActive: branch.isActive === 1,
+        messageCount,
+        createdAt: branch.createdAt
+      });
+    }
+    return result;
+  }
+  // ==========================================================================
+  // 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
+    );
+  }
+  async getCheckpoint(chatId, name) {
+    const row = this.#db.prepare("SELECT * FROM checkpoints WHERE chatId = ? AND name = ?").get(chatId, name);
+    if (!row) {
+      return void 0;
+    }
+    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
+    };
   }
-  static isInstance(error) {
-    return error instanceof _SQLValidationError && error[marker] === true;
+};
+var InMemoryContextStore = class extends SqliteContextStore {
+  constructor() {
+    super(":memory:");
   }
 };
-var UnanswerableSQLError = class _UnanswerableSQLError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "UnanswerableSQLError";
+var Agent = class _Agent {
+  #options;
+  #guardrails = [];
+  tools;
+  constructor(options) {
+    this.#options = options;
+    this.tools = options.tools || {};
+    this.#guardrails = options.guardrails || [];
+  }
+  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.`);
+    }
+    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: convertToModelMessages(messages),
+      stopWhen: stepCountIs(25),
+      tools: this.#options.tools,
+      experimental_context: contextVariables,
+      toolChoice: this.#options.toolChoice,
+      onStepFinish: (step) => {
+        const toolCall = step.toolCalls.at(-1);
+        if (toolCall) {
+          console.log(
+            `Debug: ${chalk.yellow("ToolCalled")}: ${toolCall.toolName}(${JSON.stringify(toolCall.input)})`
+          );
+        }
+      }
+    });
   }
-  static isInstance(error) {
-    return error instanceof _UnanswerableSQLError;
+  /**
+   * 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);
+   * ```
+   */
+  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);
   }
-};
-async function toSql(options) {
-  const { maxRetries = 3 } = options;
-  return withRetry(
-    async (attemptNumber, errors, attempts) => {
-      const agentInstance = sqlQueryAgent.clone({
-        model: wrapLanguageModel({
-          model: options.model ?? sqlQueryAgent.model,
-          middleware: defaultSettingsMiddleware({
-            settings: {
-              temperature: RETRY_TEMPERATURES[attemptNumber - 1] ?? 0.3,
-              topP: 1
+  /**
+   * Create a raw stream without guardrail processing.
+   */
+  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: convertToModelMessages(messages),
+      stopWhen: stepCountIs(25),
+      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}) ${chalk.bold.yellow("ToolCalled")}: ${toolCall.toolName}(${JSON.stringify(toolCall.input)})`
+          );
+        }
+      }
+    });
+  }
+  /**
+   * 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
+   */
+  #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 guardrailContext = {
+            availableTools: Object.keys(this.tools)
+          };
+          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(
+                  chalk.yellow(
+                    `[${this.#options.name}] Guardrail triggered (attempt ${attempt}/${maxRetries}): ${failureFeedback.slice(0, 50)}...`
+                  )
+                );
+                break;
+              }
+              if (checkResult.part.type === "text-delta") {
+                accumulatedText += checkResult.part.delta;
+              }
+              writer.write(checkResult.part);
+            }
+            if (!guardrailFailed) {
+              writer.write({ type: "finish" });
+              return;
+            }
+            if (attempt >= maxRetries) {
+              console.error(
+                chalk.red(
+                  `[${this.#options.name}] Guardrail retry limit (${maxRetries}) exceeded.`
+                )
+              );
+              writer.write({ type: "finish" });
+              return;
+            }
+            writer.write({
+              type: "text-delta",
+              id: generateId2(),
+              delta: ` ${failureFeedback}`
+            });
+            const selfCorrectionText = accumulatedText + " " + failureFeedback;
+            context.set(assistantText(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}`;
+        }
       });
-      const messages = errors.length ? [
-        user(options.input),
-        user(
-          `<validation_error>Your previous SQL query had the following error: ${errors.at(-1)?.message}. Please fix the query.</validation_error>`
-        )
-      ] : [user(options.input)];
-      const output = await toOutput(
-        generate(agentInstance, messages, {
-          introspection: options.introspection,
-          teachings: toInstructions(
-            "instructions",
-            persona({
-              name: "Freya",
-              role: "You are an expert SQL query generator. You translate natural language questions into precise, efficient SQL queries based on the provided database schema."
-            }),
-            ...options.instructions
-          )
-        })
-      );
-      if ("error" in output) {
-        throw new UnanswerableSQLError(output.error);
-      }
-      const sql = extractSql(output.sql);
-      const validationError = await options.adapter.validate(sql);
-      if (validationError) {
-        throw new SQLValidationError(validationError);
-      }
-      return {
-        attempts,
-        sql,
-        errors: errors.length ? errors.map(formatErrorMessage) : void 0
-      };
-    },
-    { retries: maxRetries - 1 }
-  );
-}
-function formatErrorMessage(error) {
-  if (APICallError.isInstance(error)) {
-    if (error.message.startsWith("Failed to validate JSON")) {
-      return `Schema validation failed: ${error.message}`;
-    }
-    return error.message;
+    };
+    return result;
   }
-  if (SQLValidationError.isInstance(error)) {
-    return `SQL Validation Error: ${error.message}`;
+  clone(overrides) {
+    return new _Agent({
+      ...this.#options,
+      ...overrides
+    });
   }
-  return error.message;
+};
+function agent(options) {
+  return new Agent(options);
 }
-async function withRetry(computation, options = { retries: 3 }) {
-  const errors = [];
-  let attempts = 0;
-  return pRetry(
-    (attemptNumber) => {
-      return computation(attemptNumber, errors, ++attempts);
+function structuredOutput(options) {
+  return {
+    async generate(contextVariables, config) {
+      if (!options.context) {
+        throw new Error(
+          `structuredOutput "${options.name}" is missing a context.`
+        );
+      }
+      if (!options.model) {
+        throw new Error(
+          `structuredOutput "${options.name}" is missing a model.`
+        );
+      }
+      const { messages, systemPrompt } = await options.context.resolve({
+        renderer: new XmlRenderer()
+      });
+      const result = await generateText({
+        abortSignal: config?.abortSignal,
+        providerOptions: options.providerOptions,
+        model: options.model,
+        system: systemPrompt,
+        messages: convertToModelMessages(messages),
+        stopWhen: stepCountIs(25),
+        experimental_context: contextVariables,
+        experimental_output: Output.object({ schema: options.schema })
+      });
+      return result.experimental_output;
     },
-    {
-      retries: options.retries,
-      shouldRetry: (context2) => {
-        if (UnanswerableSQLError.isInstance(context2.error)) {
-          return false;
-        }
-        if (SQLValidationError.isInstance(context2.error)) {
-          return true;
-        }
-        console.log({
-          NoObjectGeneratedError: NoObjectGeneratedError.isInstance(
-            context2.error
-          ),
-          NoOutputGeneratedError: NoOutputGeneratedError.isInstance(
-            context2.error
-          ),
-          APICallError: APICallError.isInstance(context2.error),
-          JSONParseError: JSONParseError.isInstance(context2.error),
-          TypeValidationError: TypeValidationError.isInstance(context2.error),
-          NoContentGeneratedError: NoContentGeneratedError.isInstance(
-            context2.error
-          )
-        });
-        return APICallError.isInstance(context2.error) || JSONParseError.isInstance(context2.error) || TypeValidationError.isInstance(context2.error) || NoObjectGeneratedError.isInstance(context2.error) || NoOutputGeneratedError.isInstance(context2.error) || NoContentGeneratedError.isInstance(context2.error);
-      },
-      onFailedAttempt(context2) {
-        logger.error(`toSQL`, context2.error);
-        console.log(
-          `Attempt ${context2.attemptNumber} failed. There are ${context2.retriesLeft} retries left.`
+    async stream(contextVariables, config) {
+      if (!options.context) {
+        throw new Error(
+          `structuredOutput "${options.name}" is missing a context.`
+        );
+      }
+      if (!options.model) {
+        throw new Error(
+          `structuredOutput "${options.name}" is missing a model.`
         );
-        errors.push(context2.error);
       }
+      const { messages, systemPrompt } = await options.context.resolve({
+        renderer: new XmlRenderer()
+      });
+      return streamText({
+        abortSignal: config?.abortSignal,
+        providerOptions: options.providerOptions,
+        model: options.model,
+        system: systemPrompt,
+        messages: convertToModelMessages(messages),
+        stopWhen: stepCountIs(25),
+        experimental_transform: config?.transform ?? smoothStream(),
+        experimental_context: contextVariables,
+        experimental_output: Output.object({ schema: options.schema })
+      });
     }
-  );
+  };
 }
 
+// packages/text2sql/src/lib/agents/explainer.agent.ts
+import { groq } from "@ai-sdk/groq";
+import dedent from "dedent";
+import z from "zod";
+import { agent as agent2 } from "@deepagents/agent";
+var explainerAgent = agent2({
+  name: "explainer",
+  model: groq("openai/gpt-oss-20b"),
+  prompt: (state) => dedent`
+    You are an expert SQL tutor.
+    Explain the following SQL query in plain English to a non-technical user.
+    Focus on the intent and logic, not the syntax.
+
+    <sql>
+    ${state?.sql}
+    </sql>
+  `,
+  output: z.object({
+    explanation: z.string().describe("The explanation of the SQL query.")
+  })
+});
+
 // packages/text2sql/src/lib/agents/developer.agent.ts
 var tools = {
   /**
-   * Generate SQL from natural language question.
-   * Uses the toSql function with retry logic and validation.
+   * Validate SQL query syntax before execution.
    */
-  generate_sql: tool({
-    description: dedent2`
-      Generate a validated SQL query from a natural language question.
-      The query is automatically validated against the database schema.
-      Use this when the user asks a question that requires data retrieval.
-
-      Returns the SQL query along with generation metadata (attempts, any errors encountered).
-    `,
-    inputSchema: z3.object({
-      question: z3.string().min(1).describe("The natural language question to convert to SQL")
+  validate_query: tool({
+    description: `Validate SQL query syntax before execution. Use this to check if your SQL is valid before running db_query. This helps catch errors early and allows you to correct the query if needed.`,
+    inputSchema: z2.object({
+      sql: z2.string().describe("The SQL query to validate.")
     }),
-    execute: async ({ question }, options) => {
+    execute: async ({ sql }, options) => {
       const state = toState(options);
-      try {
-        const result = await toSql({
-          input: question,
-          adapter: state.adapter,
-          introspection: state.introspection,
-          instructions: state.instructions
-        });
-        return {
-          success: true,
-          sql: result.sql,
-          attempts: result.attempts,
-          errors: result.errors
-        };
-      } catch (error) {
-        return {
-          success: false,
-          error: error instanceof Error ? error.message : String(error)
-        };
+      const result = await state.adapter.validate(sql);
+      if (typeof result === "string") {
+        return `Validation Error: ${result}`;
       }
+      return "Query is valid.";
+    }
+  }),
+  /**
+   * Execute SQL query against the database.
+   */
+  db_query: tool({
+    description: `Internal tool to fetch data from the store's database. Write a SQL query to retrieve the information needed to answer the user's question. The results will be returned as data that you can then present to the user in natural language.`,
+    inputSchema: z2.object({
+      reasoning: z2.string().describe(
+        "Your reasoning for why this SQL query is relevant to the user request."
+      ),
+      sql: z2.string().min(1, { message: "SQL query cannot be empty." }).refine(
+        (sql) => sql.trim().toUpperCase().startsWith("SELECT") || sql.trim().toUpperCase().startsWith("WITH"),
+        {
+          message: "Only read-only SELECT or WITH queries are allowed."
+        }
+      ).describe("The SQL query to execute against the database.")
+    }),
+    execute: ({ sql }, options) => {
+      const state = toState(options);
+      return state.adapter.execute(sql);
     }
   }),
   /**
@@ -785,129 +2233,44 @@ var tools = {
 
       The explanation focuses on intent and logic, not syntax.
     `,
-    inputSchema: z3.object({
-      sql: z3.string().min(1).describe("The SQL query to explain")
+    inputSchema: z2.object({
+      sql: z2.string().min(1).describe("The SQL query to explain")
     }),
     execute: async ({ sql }) => {
-      const { experimental_output } = await generate2(explainerAgent, [], {
+      const { experimental_output } = await generate(explainerAgent, [], {
         sql
       });
       return { explanation: experimental_output.explanation };
     }
-  }),
-  /**
-   * Show database schema introspection.
-   */
-  show_schema: tool({
-    description: dedent2`
-      Display the database schema introspection.
-      Use this when the user wants to see available tables, columns, or relationships.
-
-      Optionally filter by table name to reduce output.
-    `,
-    inputSchema: z3.object({
-      table: z3.string().optional().describe(
-        "Optional: filter to show only a specific table. If omitted, shows full schema."
-      )
-    }),
-    execute: async ({ table }, options) => {
-      const state = toState(options);
-      if (!table) {
-        return { schema: state.introspection };
-      }
-      const lines = state.introspection.split("\n");
-      const tableLines = [];
-      let inTable = false;
-      let depth = 0;
-      for (const line of lines) {
-        const lowerLine = line.toLowerCase();
-        if (lowerLine.includes(`name="${table.toLowerCase()}"`) || lowerLine.includes(`table="${table.toLowerCase()}"`)) {
-          inTable = true;
-          depth = 1;
-          tableLines.push(line);
-          continue;
-        }
-        if (inTable) {
-          tableLines.push(line);
-          if (line.includes("</")) {
-            depth--;
-          }
-          if (line.includes("<") && !line.includes("</") && !line.includes("/>")) {
-            depth++;
-          }
-          if (depth <= 0) {
-            break;
-          }
-        }
-      }
-      if (tableLines.length === 0) {
-        return {
-          schema: `Table "${table}" not found in schema. Use show_schema without a table filter to see all available tables.`
-        };
-      }
-      return { schema: tableLines.join("\n") };
-    }
-  }),
-  /**
-   * Developer scratchpad for notes and reasoning.
-   */
-  scratchpad: scratchpad_tool
+  })
 };
-var developerAgent = agent3({
-  model: groq3("gpt-oss-20b"),
-  tools,
-  name: "developer_agent",
-  prompt: (state) => {
-    return dedent2`
-      You are an expert SQL developer assistant helping power users build and refine queries.
-
-      ## Your Capabilities
-
-      You have access to the following tools:
-
-      1. **generate_sql**: Convert natural language questions to validated SQL queries
-         - Automatically validates against the database schema
-         - Returns generation metadata (attempts, errors if any)
-
-      2. **explain_sql**: Get a plain-English explanation of any SQL query
-         - Helps users understand complex queries
-         - Focuses on intent and logic, not syntax
-
-      3. **show_schema**: Display database schema information
-         - Can show full schema or filter by table name
-         - Use to explore available tables and columns
-
-      4. **scratchpad**: Record your reasoning and notes
-
-      ## Guidelines
-
-      - Be transparent: show the SQL you generate before explaining it
-      - Be precise: provide exact column names and table references
-      - Be helpful: suggest refinements and alternatives when appropriate
-      - Support both natural language questions AND raw SQL input
-      - When validating user SQL, explain any errors clearly
-      - Use show_schema proactively when you need to verify table/column names
-
-      ${state?.teachings || ""}
-      ${state?.introspection || ""}
-    `;
-  }
-});
+var fragments = [
+  persona({
+    name: "developer_assistant",
+    role: "You are an expert SQL developer assistant helping power users build and refine queries."
+  }),
+  hint("Be transparent: show the SQL you generate before explaining it"),
+  hint("Be precise: provide exact column names and table references"),
+  hint("Suggest refinements and alternatives when appropriate"),
+  hint("Support both natural language questions AND raw SQL input"),
+  hint("When validating user SQL, explain any errors clearly")
+];
+var developer_agent_default = { tools, fragments };
 
 // packages/text2sql/src/lib/agents/suggestions.agents.ts
-import { groq as groq4 } from "@ai-sdk/groq";
+import { groq as groq2 } from "@ai-sdk/groq";
 import dedent3 from "dedent";
-import z4 from "zod";
-import { agent as agent4, thirdPersonPrompt } from "@deepagents/agent";
-var suggestionsAgent = agent4({
+import z3 from "zod";
+import { agent as agent3, thirdPersonPrompt } from "@deepagents/agent";
+var suggestionsAgent = agent3({
   name: "text2sql-suggestions",
-  model: groq4("openai/gpt-oss-20b"),
-  output: z4.object({
-    suggestions: z4.array(
-      z4.object({
-        question: z4.string().describe("A complex, high-impact business question."),
-        sql: z4.string().describe("The SQL statement needed to answer the question."),
-        businessValue: z4.string().describe("Why the question matters to stakeholders.")
+  model: groq2("openai/gpt-oss-20b"),
+  output: z3.object({
+    suggestions: z3.array(
+      z3.object({
+        question: z3.string().describe("A complex, high-impact business question."),
+        sql: z3.string().describe("The SQL statement needed to answer the question."),
+        businessValue: z3.string().describe("Why the question matters to stakeholders.")
       })
     ).min(1).max(5).describe("A set of up to two advanced question + SQL pairs.")
   }),
@@ -947,187 +2310,33 @@ var suggestionsAgent = agent4({
 });
 
 // packages/text2sql/src/lib/agents/text2sql.agent.ts
-import { groq as groq5 } from "@ai-sdk/groq";
+import { groq as groq3 } from "@ai-sdk/groq";
 import { tool as tool2 } from "ai";
-import z5 from "zod";
-import { agent as agent5, toState as toState2 } from "@deepagents/agent";
-import { scratchpad_tool as scratchpad_tool2 } from "@deepagents/toolbox";
-
-// packages/text2sql/src/lib/memory/memory.prompt.ts
-var memory_prompt_default = toInstructions(
-  "memory_guidelines",
-  // Section 1: Core behavior
-  guardrail({
-    rule: "Silently store user information when revealed. Respond to memory-related requests.",
-    reason: "Memory enables personalized responses across conversations",
-    action: "Store silently on reveal. Respond explicitly when asked about memories."
-  }),
-  // Section 2: Workflows for memory operations
-  workflow({
-    task: "Store user identity silently",
-    triggers: ["I'm a", "I work as", "my name is", "my role is"],
-    steps: [
-      "Extract name and/or role from the statement",
-      'Call remember_memory() with type: "identity" and name/role fields',
-      "Do NOT announce or confirm - continue conversation naturally"
-    ],
-    notes: "This should happen silently without disrupting the conversation flow."
-  }),
-  workflow({
-    task: "Store user preferences and context silently",
-    triggers: ["When I say", "I prefer", "I'm working on"],
-    steps: [
-      "Identify the memory type (alias/preference/context/correction)",
-      "Extract the relevant information",
-      "Call remember_memory() with appropriate type and fields",
-      "Do NOT announce or confirm - continue conversation naturally"
-    ],
-    notes: "This should happen silently without disrupting the conversation flow."
-  }),
-  workflow({
-    task: "Forget a memory",
-    triggers: ["forget that", "remove my", "delete the", "don't remember that"],
-    steps: [
-      "Call recall_memory() to list relevant memories",
-      "Find the memory ID that matches user request",
-      "Call forget_memory({ id }) with the found ID",
-      "Confirm to user what was forgotten"
-    ]
-  }),
-  workflow({
-    task: "Update a memory",
-    triggers: ["actually now I", "I changed", "update my", "no longer"],
-    steps: [
-      "Call recall_memory() to find the existing memory",
-      "Get the memory ID from results",
-      "Call update_memory({ id, memory }) with new data",
-      "Confirm the update to user"
-    ]
-  }),
-  // Section 3: Type disambiguation
-  explain({
-    concept: "identity vs context",
-    explanation: "Identity = WHO the user is (name and/or role, permanent). Context = WHAT they are working on (temporary focus).",
-    therefore: "Identity rarely changes. Context changes per project/task."
-  }),
-  explain({
-    concept: "alias vs correction",
-    explanation: "Alias = user defines their own term/shorthand. Correction = user fixes a misunderstanding about existing data/schema.",
-    therefore: "Alias is vocabulary. Correction is data clarification."
-  }),
-  explain({
-    concept: "preference memory type",
-    explanation: "Stores output/style/format preferences. Fields: { aspect: string, value: string }",
-    therefore: "Use for formatting, limits, display style, data scope filters"
-  }),
-  // Section 4: Clarifications for ambiguous situations
-  clarification({
-    when: 'user says something like "X actually means Y" but unclear if defining their term or correcting data',
-    ask: "Are you defining your own shorthand for this term, or correcting how the data/schema actually works?",
-    reason: "Alias is personal vocabulary. Correction is a data/schema clarification that applies universally."
-  }),
-  clarification({
-    when: "user mentions a project or task that could be their identity or current focus",
-    ask: "Is this your ongoing identity (name/role), or a specific project you are currently working on?",
-    reason: "Identity is permanent. Context is temporary focus that may change."
-  }),
-  // Section 5: Examples
-  // Identity - role
-  example({
-    question: "I'm the VP of Sales",
-    answer: 'remember_memory({ memory: { type: "identity", role: "VP of Sales" }})',
-    note: "Identity stores role"
-  }),
-  // Identity - name
-  example({
-    question: "My name is Sarah",
-    answer: 'remember_memory({ memory: { type: "identity", name: "Sarah" }})',
-    note: "Identity stores name"
-  }),
-  // Context
-  example({
-    question: "I'm analyzing Q4 performance",
-    answer: 'remember_memory({ memory: { type: "context", description: "Analyzing Q4 performance" }})',
-    note: "Current task = context"
-  }),
-  // Alias
-  example({
-    question: 'When I say "big customers", I mean revenue > $1M',
-    answer: 'remember_memory({ memory: { type: "alias", term: "big customers", meaning: "revenue > $1M" }})',
-    note: "User defining their vocabulary = alias"
-  }),
-  // Correction
-  example({
-    question: 'No, the status column uses 1 for active, not the string "active"',
-    answer: 'remember_memory({ memory: { type: "correction", subject: "status column values", clarification: "Uses 1 for active, not string" }})',
-    note: "Correcting schema/data assumption = correction"
-  }),
-  // Preference
-  example({
-    question: "Always show dates as YYYY-MM-DD",
-    answer: 'remember_memory({ memory: { type: "preference", aspect: "date format", value: "YYYY-MM-DD" }})'
-  }),
-  // Recall
-  example({
-    question: "What do you remember about me?",
-    answer: "recall_memory({})",
-    note: "List all stored memories"
-  }),
-  // Section 6: What NOT to remember
-  hint('Do NOT remember one-time query details like "show last 10 orders"'),
-  hint(
-    "Do NOT remember information already stored - use recall_memory to check first"
-  ),
-  hint("Do NOT remember obvious or universal facts")
-);
-
-// packages/text2sql/src/lib/agents/text2sql.agent.ts
+import z4 from "zod";
+import { toState as toState2 } from "@deepagents/agent";
+import { scratchpad_tool } from "@deepagents/toolbox";
 var tools2 = {
   validate_query: tool2({
     description: `Validate SQL query syntax before execution. Use this to check if your SQL is valid before running db_query. This helps catch errors early and allows you to correct the query if needed.`,
-    inputSchema: z5.object({
-      sql: z5.string().describe("The SQL query to validate.")
+    inputSchema: z4.object({
+      sql: z4.string().describe("The SQL query to validate.")
     }),
     execute: async ({ sql }, options) => {
       const state = toState2(options);
       const result = await state.adapter.validate(sql);
       if (typeof result === "string") {
         return `Validation Error: ${result}`;
-      }
-      return "Query is valid.";
-    }
-  }),
-  get_sample_rows: tool2({
-    description: `Sample rows from a table to understand data formatting, codes, and value patterns. Use BEFORE writing queries when:
-- Column types in schema don't reveal format (e.g., "status" could be 'active'/'inactive' or 1/0)
-- Date/time formats are unclear (ISO, Unix timestamp, locale-specific)
-- You need to understand lookup table codes or enum values
-- Column names are ambiguous (e.g., "type", "category", "code")`,
-    inputSchema: z5.object({
-      tableName: z5.string().describe("The name of the table to sample."),
-      columns: z5.array(z5.string()).optional().describe(
-        "Specific columns to sample. If omitted, samples all columns."
-      ),
-      limit: z5.number().min(1).max(10).default(3).optional().describe("Number of rows to sample (1-10, default 3).")
-    }),
-    execute: ({ tableName, columns, limit = 3 }, options) => {
-      const safeLimit = Math.min(Math.max(1, limit), 10);
-      const state = toState2(options);
-      const sql = state.adapter.buildSampleRowsQuery(
-        tableName,
-        columns,
-        safeLimit
-      );
-      return state.adapter.execute(sql);
+      }
+      return "Query is valid.";
     }
   }),
   db_query: tool2({
     description: `Internal tool to fetch data from the store's database. Write a SQL query to retrieve the information needed to answer the user's question. The results will be returned as data that you can then present to the user in natural language.`,
-    inputSchema: z5.object({
-      reasoning: z5.string().describe(
+    inputSchema: z4.object({
+      reasoning: z4.string().describe(
         "Your reasoning for why this SQL query is relevant to the user request."
       ),
-      sql: z5.string().min(1, { message: "SQL query cannot be empty." }).refine(
+      sql: z4.string().min(1, { message: "SQL query cannot be empty." }).refine(
         (sql) => sql.trim().toUpperCase().startsWith("SELECT") || sql.trim().toUpperCase().startsWith("WITH"),
         {
           message: "Only read-only SELECT or WITH queries are allowed."
@@ -1139,198 +2348,20 @@ var tools2 = {
       return state.adapter.execute(sql);
     }
   }),
-  scratchpad: scratchpad_tool2
-};
-var userMemoryTypes = [
-  "identity",
-  "alias",
-  "preference",
-  "context",
-  "correction"
-];
-var userMemorySchema = z5.discriminatedUnion("type", [
-  z5.object({
-    type: z5.literal("identity"),
-    description: z5.string().describe("The user's identity: role or/and name")
-  }),
-  z5.object({
-    type: z5.literal("alias"),
-    term: z5.string().describe("The term the user uses"),
-    meaning: z5.string().describe("What the user means by this term")
-  }),
-  z5.object({
-    type: z5.literal("preference"),
-    aspect: z5.string().describe("What aspect of output this preference applies to"),
-    value: z5.string().describe("The user's preference")
-  }),
-  z5.object({
-    type: z5.literal("context"),
-    description: z5.string().describe("What the user is currently working on")
-  }),
-  z5.object({
-    type: z5.literal("correction"),
-    subject: z5.string().describe("What was misunderstood"),
-    clarification: z5.string().describe("The correct understanding")
-  })
-]);
-var memoryTools = {
-  remember_memory: tool2({
-    description: "Store something about the user for future conversations. Use silently when user shares facts, preferences, vocabulary, corrections, or context.",
-    inputSchema: z5.object({ memory: userMemorySchema }),
-    execute: async ({ memory }, options) => {
-      const state = toState2(
-        options
-      );
-      await state.memory.remember(state.userId, memory);
-      return "Remembered.";
-    }
-  }),
-  forget_memory: tool2({
-    description: "Forget a specific memory. Use when user asks to remove something.",
-    inputSchema: z5.object({
-      id: z5.string().describe("The ID of the teachable to forget")
-    }),
-    execute: async ({ id }, options) => {
-      const state = toState2(options);
-      await state.memory.forget(id);
-      return "Forgotten.";
-    }
-  }),
-  recall_memory: tool2({
-    description: "List stored memories for the current user. Use when user asks what you remember about them or wants to see their stored preferences.",
-    inputSchema: z5.object({
-      type: z5.enum(userMemoryTypes).optional().catch(void 0).describe("Optional: filter by memory type")
-    }),
-    execute: async ({ type }, options) => {
-      const state = toState2(
-        options
-      );
-      const memories = await state.memory.recall(state.userId, type);
-      if (memories.length === 0) {
-        return type ? `No ${type} memories stored.` : "No memories stored.";
-      }
-      return memories.map((m) => ({
-        id: m.id,
-        type: m.type,
-        data: m.data,
-        createdAt: m.createdAt
-      }));
-    }
-  }),
-  update_memory: tool2({
-    description: "Update an existing memory. Use when user wants to modify something you previously stored.",
-    inputSchema: z5.object({
-      memory: userMemorySchema,
-      id: z5.string().describe("The ID of the memory to update")
-    }),
-    execute: async ({ id, memory }, options) => {
-      const state = toState2(options);
-      await state.memory.update(id, memory);
-      return "Updated.";
-    }
-  })
+  scratchpad: scratchpad_tool
 };
-var chainOfThoughtPrompt = `
-## Query Reasoning Process
-
-Let's think step by step before writing SQL:
-
-1. **Schema Link**: Which tables and columns are relevant? Verify they exist in the schema.
-2. **Join Path**: If multiple tables, what relationships connect them?
-3. **Filters**: What WHERE conditions are needed?
-4. **Aggregation**: Is COUNT, SUM, AVG, GROUP BY, or HAVING required?
-5. **Output**: What columns to SELECT and any ORDER BY or LIMIT?
-6. **Verify**: Do all referenced tables and columns exist in the schema above?
-
-For simple queries, steps 2-4 may not apply\u2014skip them.
-
-For complex queries requiring multiple data points, decompose into sub-questions:
-- Break the question into simpler parts (Q1, Q2, ...)
-- Determine if each part needs a subquery or CTE
-- Combine the parts into the final query
-
-Keep reasoning brief. Verbose explanations cause errors.
-`;
-var fewShotExamples = `
-## Examples
-
-### Example 1: Simple Filter
-Question: "How many records in table_a have column_x equal to 'value'?"
-Reasoning:
-- Schema Link: table_a, column_x
-- Filters: column_x = 'value'
-- Aggregation: COUNT(*)
-SQL: SELECT COUNT(*) FROM table_a WHERE column_x = 'value'
-
-### Example 2: JOIN Query
-Question: "Show column_y from table_b for each record in table_a where column_x is 'value'"
-Reasoning:
-- Schema Link: table_a (column_x, id), table_b (column_y, fk_a)
-- Join Path: table_a.id \u2192 table_b.fk_a
-- Filters: column_x = 'value'
-- Output: column_y from table_b
-SQL: SELECT b.column_y FROM table_a a JOIN table_b b ON b.fk_a = a.id WHERE a.column_x = 'value'
-
-### Example 3: Aggregation with GROUP BY
-Question: "What is the total of column_y grouped by column_x?"
-Reasoning:
-- Schema Link: table_a (column_x, column_y)
-- Aggregation: SUM(column_y), GROUP BY column_x
-- Output: column_x, sum
-SQL: SELECT column_x, SUM(column_y) as total FROM table_a GROUP BY column_x
-
-### Example 4: Complex Aggregation
-Question: "Which values of column_x have more than 10 records, sorted by count descending?"
-Reasoning:
-- Schema Link: table_a (column_x)
-- Aggregation: COUNT(*), GROUP BY column_x, HAVING > 10
-- Output: column_x, count, ORDER BY count DESC
-SQL: SELECT column_x, COUNT(*) as cnt FROM table_a GROUP BY column_x HAVING COUNT(*) > 10 ORDER BY cnt DESC
-
-### Example 5: Subquery (Decomposition)
-Question: "Show records from table_a where column_y is above average"
-Reasoning:
-- Decompose:
-  - Q1: What is the average of column_y?
-  - Q2: Which records have column_y above that value?
-- Schema Link: table_a (column_y)
-- Filters: column_y > (result of Q1)
-- Output: all columns from matching records
-- Verify: table_a and column_y exist \u2713
-SQL: SELECT * FROM table_a WHERE column_y > (SELECT AVG(column_y) FROM table_a)
-
-### Example 6: Complex Multi-Join (Decomposition)
-Question: "Find the top 3 categories by total sales amount for orders placed last month"
-Reasoning:
-- Decompose:
-  - Q1: Which orders were placed last month?
-  - Q2: What is the total sales per category for those orders?
-  - Q3: Which 3 categories have the highest totals?
-- Schema Link: orders (order_date, id), order_items (order_id, amount, product_id), products (id, category_id), categories (id, name)
-- Join Path: orders \u2192 order_items \u2192 products \u2192 categories
-- Filters: order_date within last month
-- Aggregation: SUM(amount), GROUP BY category
-- Output: category name, total, ORDER BY total DESC, LIMIT 3
-- Verify: all tables and columns exist \u2713
-SQL: SELECT c.name, SUM(oi.amount) as total FROM orders o JOIN order_items oi ON oi.order_id = o.id JOIN products p ON p.id = oi.product_id JOIN categories c ON c.id = p.category_id WHERE o.order_date >= DATE('now', '-1 month') GROUP BY c.id, c.name ORDER BY total DESC LIMIT 3
-`;
-var t_a_g = agent5({
-  model: groq5("openai/gpt-oss-20b"),
+var t_a_g = agent({
+  model: groq3("openai/gpt-oss-20b"),
   tools: tools2,
-  name: "text2sql",
-  prompt: (state) => {
-    const hasMemory = !!state?.memory;
-    return `
-    ${state?.teachings || ""}
-    ${state?.introspection || ""}
-
-    ${chainOfThoughtPrompt}
-
-    ${fewShotExamples}
-
-    ${hasMemory ? memory_prompt_default : ""}
-  `;
-  }
+  name: "text2sql"
+  // prompt: (state) => {
+  //   return `
+  //   ${state?.teachings || ''}
+  //   ${state?.introspection || ''}
+  //   ${chainOfThoughtPrompt}
+  //   ${fewShotExamples}
+  // `;
+  // },
 });
 
 // packages/text2sql/src/lib/checkpoint.ts
@@ -1536,842 +2567,186 @@ var JsonCache = class extends FileCache {
   }
 };
 
-// packages/text2sql/src/lib/history/history.ts
-var History = class {
-};
-
-// packages/text2sql/src/lib/history/sqlite.history.ts
-import { DatabaseSync } from "node:sqlite";
-
-// packages/text2sql/src/lib/history/history.sqlite.sql
-var history_sqlite_default = 'CREATE TABLE IF NOT EXISTS "chats" (\n	"id" VARCHAR PRIMARY KEY,\n	"title" VARCHAR,\n	"userId" VARCHAR\n);\n\nCREATE TABLE IF NOT EXISTS "messages" (\n	"id" VARCHAR PRIMARY KEY,\n	"chatId" VARCHAR NOT NULL REFERENCES "chats" ("id") ON DELETE CASCADE,\n	"createdAt" TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,\n	"role" VARCHAR NOT NULL,\n	"content" TEXT NOT NULL\n);\n\nCREATE INDEX IF NOT EXISTS "messages_chat_id_idx" ON "messages" ("chatId");\n\nCREATE INDEX IF NOT EXISTS "messages_chat_id_created_at_idx" ON "messages" ("chatId", "createdAt");\n';
-
-// packages/text2sql/src/lib/history/sqlite.history.ts
-var SqliteHistory = class extends History {
-  #db;
-  constructor(path2) {
-    super();
-    this.#db = new DatabaseSync(path2);
-    this.#db.exec(history_sqlite_default);
-  }
-  async listChats(userId) {
-    return this.#db.prepare(`SELECT * FROM chats WHERE "userId" = ?`).all(userId);
-  }
-  async getChat(chatId) {
-    const rows = this.#db.prepare(
-      `SELECT
-          c.id as chatId, c."userId", c.title,
-          m.id as messageId, m.role, m."createdAt", m.content
-        FROM chats c
-        LEFT JOIN messages m ON m."chatId" = c.id
-        WHERE c.id = ?
-        ORDER BY m."createdAt" ASC`
-    ).all(chatId);
-    if (!rows.length) return null;
-    const firstRow = rows[0];
-    const chat = {
-      id: firstRow.chatId,
-      userId: firstRow.userId,
-      title: firstRow.title,
-      messages: []
-    };
-    for (const row of rows) {
-      if (row.messageId) {
-        chat.messages.push({
-          id: row.messageId,
-          chatId: firstRow.chatId,
-          role: row.role,
-          createdAt: row.createdAt,
-          content: JSON.parse(row.content)
-        });
-      }
-    }
-    return chat;
-  }
-  async createChat(chat) {
-    this.#db.prepare(`INSERT INTO chats (id, "userId", title) VALUES (?, ?, ?)`).run(chat.id, chat.userId, chat.title || null);
-    return chat;
-  }
-  async upsertChat(chat) {
-    this.#db.prepare(
-      `INSERT INTO chats (id, "userId", title) VALUES (?, ?, ?)
-        ON CONFLICT(id) DO UPDATE SET title = excluded.title, "userId" = excluded."userId"`
-    ).run(chat.id, chat.userId, chat.title || null);
-    return this.getChat(chat.id);
-  }
-  async deleteChat(chatId) {
-    this.#db.prepare(`DELETE FROM chats WHERE id = ?`).run(chatId);
-  }
-  async updateChat(chatId, updates) {
-    if (updates.title !== void 0) {
-      this.#db.prepare(`UPDATE chats SET title = ? WHERE id = ?`).run(updates.title, chatId);
-    }
-  }
-  async addMessage(message) {
-    const createdAt = message.createdAt ? message.createdAt.toISOString() : (/* @__PURE__ */ new Date()).toISOString();
-    this.#db.prepare(
-      `INSERT INTO messages (id, "chatId", role, "createdAt", content) VALUES (?, ?, ?, ?, ?)`
-    ).run(
-      message.id,
-      message.chatId,
-      message.role,
-      createdAt,
-      JSON.stringify(message.content)
-    );
-  }
-  async upsertMessage(message) {
-    const createdAt = message.createdAt ? message.createdAt.toISOString() : (/* @__PURE__ */ new Date()).toISOString();
-    this.#db.prepare(
-      `INSERT INTO messages (id, "chatId", role, "createdAt", content) VALUES (?, ?, ?, ?, ?)
-        ON CONFLICT(id) DO UPDATE SET "chatId" = excluded."chatId", role = excluded.role, "createdAt" = excluded."createdAt", content = excluded.content`
-    ).run(
-      message.id,
-      message.chatId,
-      message.role,
-      createdAt,
-      JSON.stringify(message.content)
-    );
-    return {
-      ...message,
-      createdAt
-    };
-  }
-  async deleteMessage(messageId) {
-    this.#db.prepare(`DELETE FROM messages WHERE id = ?`).run(messageId);
-  }
-};
-
-// packages/text2sql/src/lib/history/memory.history.ts
-var InMemoryHistory = class extends SqliteHistory {
-  constructor() {
-    super(":memory:");
-  }
-};
-
-// packages/text2sql/src/lib/memory/sqlite.store.ts
-import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
-import { v7 } from "uuid";
-
-// packages/text2sql/src/lib/memory/store.sqlite.sql
-var store_sqlite_default = 'CREATE TABLE IF NOT EXISTS "teachables" (\n	"id" VARCHAR PRIMARY KEY,\n	"userId" VARCHAR,\n	"type" VARCHAR NOT NULL,\n	"data" TEXT NOT NULL,\n	"createdAt" TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,\n	"updatedAt" TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP\n);\n\nCREATE INDEX IF NOT EXISTS "teachables_user_id_idx" ON "teachables" ("userId");\n\nCREATE INDEX IF NOT EXISTS "teachables_type_idx" ON "teachables" ("type");\n\nCREATE INDEX IF NOT EXISTS "teachables_user_type_idx" ON "teachables" ("userId", "type");\n';
-
-// packages/text2sql/src/lib/memory/store.ts
-var TeachablesStore = class {
-};
-
-// packages/text2sql/src/lib/memory/sqlite.store.ts
-function rowToStoredTeachable(row) {
-  return {
-    id: row.id,
-    userId: row.userId,
-    type: row.type,
-    data: JSON.parse(row.data),
-    createdAt: row.createdAt,
-    updatedAt: row.updatedAt
-  };
-}
-var SqliteTeachablesStore = class extends TeachablesStore {
-  #db;
-  constructor(path2) {
-    super();
-    this.#db = new DatabaseSync2(path2);
-    this.#db.exec(store_sqlite_default);
-  }
-  async remember(userId, data) {
-    const id = v7();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    this.#db.prepare(
-      "INSERT INTO teachables (id, userId, type, data, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?, ?)"
-    ).run(id, userId, data.type, JSON.stringify(data), now, now);
-    return await this.get(id);
-  }
-  async recall(userId, type) {
-    let rows;
-    if (type === void 0) {
-      rows = this.#db.prepare("SELECT * FROM teachables WHERE userId = ? ORDER BY createdAt").all(userId);
-    } else {
-      rows = this.#db.prepare(
-        "SELECT * FROM teachables WHERE userId = ? AND type = ? ORDER BY createdAt"
-      ).all(userId, type);
-    }
-    return rows.map(rowToStoredTeachable);
-  }
-  async get(id) {
-    const row = this.#db.prepare("SELECT * FROM teachables WHERE id = ?").get(id);
-    if (!row) return null;
-    return rowToStoredTeachable(row);
-  }
-  async update(id, data) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    this.#db.prepare(
-      "UPDATE teachables SET data = ?, type = ?, updatedAt = ? WHERE id = ?"
-    ).run(JSON.stringify(data), data.type, now, id);
-    return await this.get(id);
-  }
-  async forget(id) {
-    this.#db.prepare("DELETE FROM teachables WHERE id = ?").run(id);
-  }
-  async forgetAll(userId) {
-    this.#db.prepare("DELETE FROM teachables WHERE userId = ?").run(userId);
-  }
-  async toTeachables(userId) {
-    const stored = await this.recall(userId);
-    return toTeachables(stored.map((s) => s.data));
-  }
-};
-
-// packages/text2sql/src/lib/memory/memory.store.ts
-var InMemoryTeachablesStore = class extends SqliteTeachablesStore {
-  constructor() {
-    super(":memory:");
-  }
-};
-
 // packages/text2sql/src/lib/sql.ts
 import {
   APICallError as APICallError2,
   InvalidToolInputError,
   NoSuchToolError,
   ToolCallRepairError,
-  generateId
+  generateId as generateId3
 } from "ai";
-import { v7 as v72 } from "uuid";
-import {
-  generate as generate5,
-  stream,
-  user as user4
-} from "@deepagents/agent";
-
-// packages/text2sql/src/lib/agents/chat1.agent.ts
-import { groq as groq6 } from "@ai-sdk/groq";
-import { tool as tool3 } from "ai";
-import z6 from "zod";
-import { agent as agent6, toState as toState3 } from "@deepagents/agent";
-import { scratchpad_tool as scratchpad_tool3 } from "@deepagents/toolbox";
-var tools3 = {
-  query_database: tool3({
-    description: `Query the database to answer a question. Provide your question in natural language and this tool will:
-1. Generate the appropriate SQL query
-2. Validate the SQL syntax
-3. Execute the query
-4. Return the results
+import "@deepagents/agent";
 
-Use this tool when you need to retrieve data to answer the user's question.`,
-    inputSchema: z6.object({
-      question: z6.string().min(1).describe(
-        "The question to answer, expressed in natural language. Be specific about what data you need."
-      ),
-      reasoning: z6.string().optional().describe(
-        "Your reasoning for why this query is needed to answer the user."
-      )
-    }),
-    execute: async ({ question }, options) => {
-      const state = toState3(options);
-      try {
-        const sqlResult = await toSql({
-          input: question,
-          adapter: state.adapter,
-          introspection: state.introspection,
-          instructions: state.instructions
-        });
-        if (!sqlResult.sql) {
-          return {
-            success: false,
-            error: sqlResult.errors?.join("; ") || "Failed to generate SQL"
-          };
-        }
-        const data = await state.adapter.execute(sqlResult.sql);
-        return {
-          success: true,
-          sql: sqlResult.sql,
-          data
-        };
-      } catch (error) {
-        return {
-          success: false,
-          error: error instanceof Error ? error.message : "Unknown error occurred"
-        };
-      }
-    }
-  }),
-  scratchpad: scratchpad_tool3
-};
-var chat1Agent = agent6({
-  name: "chat1-combined",
-  model: groq6("openai/gpt-oss-20b"),
-  tools: tools3,
-  prompt: (state) => {
-    return `
-${state?.teachings || ""}
-${state?.introspection || ""}
-`;
-  }
+// packages/text2sql/src/lib/agents/sql.agent.ts
+import { groq as groq4 } from "@ai-sdk/groq";
+import {
+  APICallError,
+  JSONParseError,
+  NoContentGeneratedError,
+  NoObjectGeneratedError,
+  NoOutputGeneratedError,
+  TypeValidationError,
+  defaultSettingsMiddleware,
+  wrapLanguageModel
+} from "ai";
+import { Console } from "node:console";
+import { createWriteStream } from "node:fs";
+import pRetry from "p-retry";
+import z5 from "zod";
+import "@deepagents/agent";
+var logger = new Console({
+  stdout: createWriteStream("./sql-agent.log", { flags: "a" }),
+  stderr: createWriteStream("./sql-agent-error.log", { flags: "a" }),
+  inspectOptions: { depth: null }
 });
-
-// packages/text2sql/src/lib/agents/chat2.agent.ts
-import { groq as groq7 } from "@ai-sdk/groq";
-import { tool as tool4 } from "ai";
-import z7 from "zod";
-import { agent as agent7, toState as toState4 } from "@deepagents/agent";
-import { scratchpad_tool as scratchpad_tool4 } from "@deepagents/toolbox";
-var tools4 = {
-  generate_sql: tool4({
-    description: `Generate a SQL query from a natural language question. This tool will:
-1. Translate your question into SQL
-2. Validate the SQL syntax
-3. Retry with corrections if validation fails
-4. Return the validated SQL for your review
-
-Use this BEFORE execute_sql to see what query will be run. You can then:
-- Explain the approach to the user
-- Decide if the SQL looks correct
-- Refine your question and regenerate if needed`,
-    inputSchema: z7.object({
-      question: z7.string().min(1).describe(
-        "The question to translate into SQL. Be specific about what data you need."
-      ),
-      reasoning: z7.string().optional().describe("Your reasoning for why this data is needed.")
-    }),
-    execute: async ({ question }, options) => {
-      const state = toState4(options);
-      try {
-        const sqlResult = await toSql({
-          input: question,
-          adapter: state.adapter,
-          introspection: state.introspection,
-          instructions: state.instructions
-        });
-        if (!sqlResult.sql) {
-          return {
-            success: false,
-            error: sqlResult.errors?.join("; ") || "Failed to generate SQL",
-            validationErrors: sqlResult.errors
-          };
-        }
-        return {
-          success: true,
-          sql: sqlResult.sql,
-          validationErrors: sqlResult.errors
-        };
-      } catch (error) {
-        return {
-          success: false,
-          error: error instanceof Error ? error.message : "Unknown error occurred"
-        };
-      }
-    }
-  }),
-  execute_sql: tool4({
-    description: `Execute a SQL query and return the results. Use this AFTER generate_sql to run the query.
-
-Only SELECT and WITH (CTE) queries are allowed - no data modification.`,
-    inputSchema: z7.object({
-      sql: z7.string().min(1).refine(
-        (sql) => sql.trim().toUpperCase().startsWith("SELECT") || sql.trim().toUpperCase().startsWith("WITH"),
-        {
-          message: "Only read-only SELECT or WITH queries are allowed."
-        }
-      ).describe("The SQL query to execute (must be SELECT or WITH)."),
-      reasoning: z7.string().optional().describe("Brief explanation of what this query retrieves.")
-    }),
-    execute: async ({ sql }, options) => {
-      const state = toState4(options);
-      try {
-        const data = await state.adapter.execute(sql);
-        return {
-          success: true,
-          data,
-          rowCount: Array.isArray(data) ? data.length : void 0
-        };
-      } catch (error) {
-        return {
-          success: false,
-          error: error instanceof Error ? error.message : "Query execution failed"
-        };
-      }
-    }
-  }),
-  scratchpad: scratchpad_tool4
+var RETRY_TEMPERATURES = [0, 0.2, 0.3];
+function extractSql(output) {
+  const match = output.match(/```sql\n?([\s\S]*?)```/);
+  return match ? match[1].trim() : output.trim();
+}
+var marker = Symbol("SQLValidationError");
+var SQLValidationError = class _SQLValidationError extends Error {
+  [marker];
+  constructor(message2) {
+    super(message2);
+    this.name = "SQLValidationError";
+    this[marker] = true;
+  }
+  static isInstance(error) {
+    return error instanceof _SQLValidationError && error[marker] === true;
+  }
 };
-var chat2Agent = agent7({
-  name: "chat2-with-peek",
-  model: groq7("openai/gpt-oss-20b"),
-  tools: tools4,
-  prompt: (state) => {
-    return `
-${state?.teachings || ""}
-${state?.introspection || ""}
-
-When answering questions that require database queries:
-1. First use generate_sql to create the SQL query
-2. Review the generated SQL to ensure it matches the user's intent
-3. Use execute_sql to run the query
-4. Present the results to the user
-
-If the generated SQL doesn't look right, you can refine your question and regenerate.
-`;
+var UnanswerableSQLError = class _UnanswerableSQLError extends Error {
+  constructor(message2) {
+    super(message2);
+    this.name = "UnanswerableSQLError";
   }
-});
-
-// packages/text2sql/src/lib/agents/chat3.agent.ts
-import { groq as groq8 } from "@ai-sdk/groq";
-import { defaultSettingsMiddleware as defaultSettingsMiddleware2, tool as tool5, wrapLanguageModel as wrapLanguageModel2 } from "ai";
-import z8 from "zod";
-import { agent as agent8, generate as generate3, toState as toState5, user as user2 } from "@deepagents/agent";
-import { scratchpad_tool as scratchpad_tool5 } from "@deepagents/toolbox";
-var collaborativeSqlOutputSchema = z8.discriminatedUnion("status", [
-  z8.object({
-    status: z8.literal("success"),
-    sql: z8.string().describe("The generated SQL query"),
-    confidence: z8.enum(["high", "medium", "low"]).describe("Confidence level in this SQL being correct"),
-    assumptions: z8.array(z8.string()).optional().describe("Assumptions made during SQL generation"),
-    reasoning: z8.string().optional().describe("Brief explanation of the query approach")
-  }),
-  z8.object({
-    status: z8.literal("clarification_needed"),
-    question: z8.string().describe("Question to clarify the request"),
-    context: z8.string().optional().describe("Why this clarification is needed"),
-    options: z8.array(z8.string()).optional().describe("Possible options if applicable")
-  }),
-  z8.object({
-    status: z8.literal("unanswerable"),
-    reason: z8.string().describe("Why this question cannot be answered"),
-    suggestions: z8.array(z8.string()).optional().describe("Alternative questions that could be answered")
-  })
-]);
-var collaborativeSqlAgent = agent8({
-  name: "collaborative-sql",
-  model: groq8("openai/gpt-oss-20b"),
-  output: collaborativeSqlOutputSchema,
-  prompt: (state) => {
-    return `
-${toInstructions(
-      "instructions",
-      persona({
-        name: "SQLCollab",
-        role: "You are an expert SQL query generator that collaborates with the user to ensure accuracy."
-      }),
-      ...state?.instructions || []
-    )}
-${state?.introspection || ""}
-
-IMPORTANT: You have three response options:
-
-1. SUCCESS - When you can confidently generate SQL:
-   - Provide the SQL query
-   - Rate your confidence (high/medium/low)
-   - List any assumptions you made
-
-2. CLARIFICATION_NEEDED - When the question is ambiguous:
-   - Ask a specific clarifying question
-   - Explain why clarification is needed
-   - Provide options if applicable
-
-3. UNANSWERABLE - When the question cannot be answered with available data:
-   - Explain why
-   - Suggest alternative questions that could be answered
-
-Prefer asking for clarification over making low-confidence guesses.
-`;
+  static isInstance(error) {
+    return error instanceof _UnanswerableSQLError;
   }
-});
-var tools5 = {
-  consult_sql_agent: tool5({
-    description: `Consult the SQL specialist agent to generate a query. The SQL agent may:
-- Return a SQL query with confidence level and assumptions
-- Ask for clarification if the question is ambiguous
-- Indicate if the question cannot be answered with available data
-
-Based on the response:
-- If clarification is needed, you can provide context or ask the user
-- If assumptions were made, verify them with the user for important queries
-- If unanswerable, relay the suggestions to the user`,
-    inputSchema: z8.object({
-      question: z8.string().min(1).describe("The question to translate into SQL."),
-      context: z8.string().optional().describe("Additional context from the conversation that might help."),
-      previousClarification: z8.string().optional().describe(
-        "Answer to a previous clarification question from the SQL agent."
-      )
-    }),
-    execute: async ({ question, context: context2, previousClarification }, options) => {
-      const state = toState5(options);
-      try {
-        let fullQuestion = question;
-        if (context2) {
-          fullQuestion = `${question}
-
-Additional context: ${context2}`;
-        }
-        if (previousClarification) {
-          fullQuestion = `${fullQuestion}
-
-Clarification provided: ${previousClarification}`;
-        }
-        const agentInstance = collaborativeSqlAgent.clone({
-          model: wrapLanguageModel2({
-            model: collaborativeSqlAgent.model,
-            middleware: defaultSettingsMiddleware2({
-              settings: { temperature: 0.1 }
-            })
-          })
-        });
-        const { experimental_output: output } = await generate3(
-          agentInstance,
-          [user2(fullQuestion)],
-          state
+};
+async function toSql(options) {
+  const { maxRetries = 3 } = options;
+  return withRetry(
+    async (attemptNumber, errors, attempts) => {
+      const context = new ContextEngine({
+        store: new InMemoryContextStore(),
+        chatId: `sql-gen-${crypto.randomUUID()}`
+      });
+      context.set(
+        persona({
+          name: "Freya",
+          role: "You are an expert SQL query generator. You translate natural language questions into precise, efficient SQL queries based on the provided database schema."
+        }),
+        ...options.instructions,
+        ...options.schemaFragments
+      );
+      if (errors.length) {
+        context.set(
+          user(options.input),
+          user(
+            `<validation_error>Your previous SQL query had the following error: ${errors.at(-1)?.message}. Please fix the query.</validation_error>`
+          )
         );
-        if (output.status === "success") {
-          const validationError = await state.adapter.validate(output.sql);
-          if (validationError) {
-            return {
-              success: false,
-              error: `SQL validation failed: ${validationError}`
-            };
-          }
-          const data = await state.adapter.execute(output.sql);
-          return {
-            success: true,
-            sql: output.sql,
-            data,
-            confidence: output.confidence,
-            assumptions: output.assumptions
-          };
-        }
-        if (output.status === "clarification_needed") {
-          return {
-            success: false,
-            clarificationNeeded: output.question,
-            clarificationContext: output.context,
-            clarificationOptions: output.options
-          };
-        }
-        if (output.status === "unanswerable") {
-          return {
-            success: false,
-            unanswerableReason: output.reason,
-            suggestions: output.suggestions
-          };
-        }
-        return {
-          success: false,
-          error: "Unexpected response from SQL agent"
-        };
-      } catch (error) {
-        return {
-          success: false,
-          error: error instanceof Error ? error.message : "Unknown error occurred"
-        };
+      } else {
+        context.set(user(options.input));
+      }
+      const sqlOutput = structuredOutput({
+        name: "text2sql",
+        model: wrapLanguageModel({
+          model: options.model ?? groq4("openai/gpt-oss-20b"),
+          middleware: defaultSettingsMiddleware({
+            settings: {
+              temperature: RETRY_TEMPERATURES[attemptNumber - 1] ?? 0.3,
+              topP: 1
+            }
+          })
+        }),
+        context,
+        schema: z5.union([
+          z5.object({
+            sql: z5.string().describe("The SQL query that answers the question"),
+            reasoning: z5.string().optional().describe("The reasoning steps taken to generate the SQL")
+          }),
+          z5.object({
+            error: z5.string().describe(
+              "Error message explaining why the question cannot be answered with the given schema"
+            )
+          })
+        ])
+      });
+      const output = await sqlOutput.generate();
+      if ("error" in output) {
+        throw new UnanswerableSQLError(output.error);
       }
-    }
-  }),
-  execute_sql: tool5({
-    description: `Execute a SQL query directly. Use this when you have SQL that you want to run
-(e.g., after receiving SQL from consult_sql_agent or for follow-up queries).`,
-    inputSchema: z8.object({
-      sql: z8.string().min(1).refine(
-        (sql) => sql.trim().toUpperCase().startsWith("SELECT") || sql.trim().toUpperCase().startsWith("WITH"),
-        {
-          message: "Only read-only SELECT or WITH queries are allowed."
-        }
-      ).describe("The SQL query to execute.")
-    }),
-    execute: async ({ sql }, options) => {
-      const state = toState5(options);
-      try {
-        const validationError = await state.adapter.validate(sql);
-        if (validationError) {
-          return {
-            success: false,
-            error: `Validation failed: ${validationError}`
-          };
-        }
-        const data = await state.adapter.execute(sql);
-        return {
-          success: true,
-          data,
-          rowCount: Array.isArray(data) ? data.length : void 0
-        };
-      } catch (error) {
-        return {
-          success: false,
-          error: error instanceof Error ? error.message : "Execution failed"
-        };
+      const sql = extractSql(output.sql);
+      const validationError = await options.adapter.validate(sql);
+      if (validationError) {
+        throw new SQLValidationError(validationError);
       }
+      return {
+        attempts,
+        sql,
+        errors: errors.length ? errors.map(formatErrorMessage) : void 0
+      };
+    },
+    { retries: maxRetries - 1 }
+  );
+}
+function formatErrorMessage(error) {
+  if (APICallError.isInstance(error)) {
+    if (error.message.startsWith("Failed to validate JSON")) {
+      return `Schema validation failed: ${error.message}`;
     }
-  }),
-  scratchpad: scratchpad_tool5
-};
-var chat3Agent = agent8({
-  name: "chat3-collaborative",
-  model: groq8("openai/gpt-oss-20b"),
-  tools: tools5,
-  prompt: (state) => {
-    return `
-${state?.teachings || ""}
-${state?.introspection || ""}
-
-When answering questions that require database queries, use the consult_sql_agent tool.
-
-The SQL agent may respond in three ways:
-1. SUCCESS with SQL, confidence, and assumptions - review the confidence and assumptions
-2. CLARIFICATION_NEEDED with a question - either answer from context or ask the user
-3. UNANSWERABLE with reason and suggestions - relay this to the user helpfully
-
-For medium/low confidence results, consider mentioning the assumptions to the user.
-For clarification requests, try to answer from conversation context first before asking the user.
-`;
+    return error.message;
   }
-});
-
-// packages/text2sql/src/lib/agents/chat4.agent.ts
-import { groq as groq9 } from "@ai-sdk/groq";
-import { defaultSettingsMiddleware as defaultSettingsMiddleware3, tool as tool6, wrapLanguageModel as wrapLanguageModel3 } from "ai";
-import z9 from "zod";
-import { agent as agent9, generate as generate4, toState as toState6, user as user3 } from "@deepagents/agent";
-import { scratchpad_tool as scratchpad_tool6 } from "@deepagents/toolbox";
-var questionDecompositionSchema = z9.object({
-  originalQuestion: z9.string().describe("The original question being decomposed"),
-  breakdown: z9.array(z9.string()).min(1).describe(
-    "Semantic breakdown of the question into its component parts. Each part describes an aspect of what is being asked, NOT how to implement it."
-  ),
-  entities: z9.array(z9.string()).optional().describe(
-    "Key entities/concepts mentioned (e.g., customers, orders, products)"
-  ),
-  filters: z9.array(z9.string()).optional().describe(
-    'Filtering criteria mentioned (e.g., "last quarter", "above $100")'
-  ),
-  aggregation: z9.string().optional().describe(
-    'Type of aggregation if any (e.g., "count", "sum", "average", "top N")'
-  ),
-  ambiguities: z9.array(z9.string()).optional().describe("Any ambiguous parts that might need clarification")
-});
-var decompositionSqlOutputSchema = z9.union([
-  z9.object({
-    sql: z9.string().describe("The SQL query that answers the decomposed question"),
-    reasoning: z9.string().optional().describe("How each breakdown component was addressed")
-  }),
-  z9.object({
-    error: z9.string().describe("Error message if the question cannot be answered")
-  })
-]);
-var decompositionSqlAgent = agent9({
-  name: "decomposition-sql",
-  model: groq9("openai/gpt-oss-20b"),
-  output: decompositionSqlOutputSchema,
-  prompt: (state) => {
-    return `
-${toInstructions(
-      "instructions",
-      persona({
-        name: "SQLDecomp",
-        role: "You are an expert SQL query generator. You receive questions broken down into semantic components and generate precise SQL."
-      }),
-      ...state?.instructions || []
-    )}
-${state?.introspection || ""}
-
-You will receive questions in a decomposed format with:
-- breakdown: Semantic parts of the question
-- entities: Key concepts mentioned
-- filters: Filtering criteria
-- aggregation: Type of aggregation needed
-- ambiguities: Potentially unclear parts
-
-Address each component of the breakdown in your SQL.
-If there are ambiguities, make reasonable assumptions and note them in your reasoning.
-`;
+  if (SQLValidationError.isInstance(error)) {
+    return `SQL Validation Error: ${error.message}`;
   }
-});
-var RETRY_TEMPERATURES2 = [0, 0.2, 0.3];
-var tools6 = {
-  query_with_decomposition: tool6({
-    description: `Query the database using question decomposition. This tool:
-1. Breaks down your question into semantic components (entities, filters, aggregations)
-2. Passes the decomposition to the SQL specialist
-3. Generates and validates SQL
-4. Executes and returns results
-
-This approach helps ensure all aspects of the question are addressed in the query.`,
-    inputSchema: z9.object({
-      question: z9.string().min(1).describe("The question to answer."),
-      breakdown: z9.array(z9.string()).min(1).describe(
-        'Break down the question into its semantic parts. Each part should describe an ASPECT of what is being asked, not instructions. Example for "top customers by revenue last month": ["customers who made purchases", "revenue from those purchases", "time period: last month", "ranking: top by total revenue"]'
-      ),
-      entities: z9.array(z9.string()).optional().describe(
-        'Key entities mentioned (e.g., ["customers", "orders", "products"])'
-      ),
-      filters: z9.array(z9.string()).optional().describe('Filter criteria (e.g., ["last month", "status = active"])'),
-      aggregation: z9.string().optional().describe(
-        'Aggregation type if any (e.g., "sum revenue", "count orders", "top 10")'
-      ),
-      ambiguities: z9.array(z9.string()).optional().describe("Note any ambiguous parts you identified")
-    }),
-    execute: async ({ question, breakdown, entities, filters, aggregation, ambiguities }, options) => {
-      const state = toState6(options);
-      const decomposition = {
-        originalQuestion: question,
-        breakdown,
-        entities,
-        filters,
-        aggregation,
-        ambiguities
-      };
-      const decomposedPrompt = formatDecomposition(decomposition);
-      try {
-        let lastError;
-        for (let attempt = 0; attempt < RETRY_TEMPERATURES2.length; attempt++) {
-          const temperature = RETRY_TEMPERATURES2[attempt];
-          const agentInstance = decompositionSqlAgent.clone({
-            model: wrapLanguageModel3({
-              model: decompositionSqlAgent.model,
-              middleware: defaultSettingsMiddleware3({
-                settings: { temperature }
-              })
-            })
-          });
-          const prompt = lastError ? `${decomposedPrompt}
-
-Previous attempt failed with: ${lastError}. Please fix the query.` : decomposedPrompt;
-          const { experimental_output: output } = await generate4(
-            agentInstance,
-            [user3(prompt)],
-            state
-          );
-          if ("error" in output) {
-            return {
-              success: false,
-              question,
-              decomposition,
-              error: output.error,
-              attempts: attempt + 1
-            };
-          }
-          const validationError = await state.adapter.validate(output.sql);
-          if (validationError) {
-            lastError = validationError;
-            continue;
-          }
-          const data = await state.adapter.execute(output.sql);
-          return {
-            success: true,
-            question,
-            decomposition,
-            sql: output.sql,
-            data,
-            reasoning: output.reasoning,
-            attempts: attempt + 1
-          };
-        }
-        return {
-          success: false,
-          question,
-          decomposition,
-          error: `Failed after ${RETRY_TEMPERATURES2.length} attempts. Last error: ${lastError}`,
-          attempts: RETRY_TEMPERATURES2.length
-        };
-      } catch (error) {
-        return {
-          success: false,
-          question,
-          decomposition,
-          error: error instanceof Error ? error.message : "Unknown error occurred"
-        };
-      }
-    }
-  }),
-  execute_sql: tool6({
-    description: `Execute a SQL query directly. Use for follow-up queries or when you already have SQL.`,
-    inputSchema: z9.object({
-      sql: z9.string().min(1).refine(
-        (sql) => sql.trim().toUpperCase().startsWith("SELECT") || sql.trim().toUpperCase().startsWith("WITH"),
-        {
-          message: "Only read-only SELECT or WITH queries are allowed."
+  return error.message;
+}
+async function withRetry(computation, options = { retries: 3 }) {
+  const errors = [];
+  let attempts = 0;
+  return pRetry(
+    (attemptNumber) => {
+      return computation(attemptNumber, errors, ++attempts);
+    },
+    {
+      retries: options.retries,
+      shouldRetry: (context) => {
+        if (UnanswerableSQLError.isInstance(context.error)) {
+          return false;
         }
-      ).describe("The SQL query to execute.")
-    }),
-    execute: async ({ sql }, options) => {
-      const state = toState6(options);
-      try {
-        const validationError = await state.adapter.validate(sql);
-        if (validationError) {
-          return {
-            success: false,
-            error: `Validation failed: ${validationError}`
-          };
+        if (SQLValidationError.isInstance(context.error)) {
+          return true;
         }
-        const data = await state.adapter.execute(sql);
-        return {
-          success: true,
-          data,
-          rowCount: Array.isArray(data) ? data.length : void 0
-        };
-      } catch (error) {
-        return {
-          success: false,
-          error: error instanceof Error ? error.message : "Execution failed"
-        };
+        console.log({
+          NoObjectGeneratedError: NoObjectGeneratedError.isInstance(
+            context.error
+          ),
+          NoOutputGeneratedError: NoOutputGeneratedError.isInstance(
+            context.error
+          ),
+          APICallError: APICallError.isInstance(context.error),
+          JSONParseError: JSONParseError.isInstance(context.error),
+          TypeValidationError: TypeValidationError.isInstance(context.error),
+          NoContentGeneratedError: NoContentGeneratedError.isInstance(
+            context.error
+          )
+        });
+        return APICallError.isInstance(context.error) || JSONParseError.isInstance(context.error) || TypeValidationError.isInstance(context.error) || NoObjectGeneratedError.isInstance(context.error) || NoOutputGeneratedError.isInstance(context.error) || NoContentGeneratedError.isInstance(context.error);
+      },
+      onFailedAttempt(context) {
+        logger.error(`toSQL`, context.error);
+        console.log(
+          `Attempt ${context.attemptNumber} failed. There are ${context.retriesLeft} retries left.`
+        );
+        errors.push(context.error);
       }
     }
-  }),
-  scratchpad: scratchpad_tool6
-};
-function formatDecomposition(decomposition) {
-  const parts = [
-    `Original Question: ${decomposition.originalQuestion}`,
-    "",
-    "Question Breakdown:",
-    ...decomposition.breakdown.map((part, i) => `  ${i + 1}. ${part}`)
-  ];
-  if (decomposition.entities?.length) {
-    parts.push("", `Entities: ${decomposition.entities.join(", ")}`);
-  }
-  if (decomposition.filters?.length) {
-    parts.push("", `Filters: ${decomposition.filters.join(", ")}`);
-  }
-  if (decomposition.aggregation) {
-    parts.push("", `Aggregation: ${decomposition.aggregation}`);
-  }
-  if (decomposition.ambiguities?.length) {
-    parts.push(
-      "",
-      "Potential Ambiguities:",
-      ...decomposition.ambiguities.map((a) => `  - ${a}`)
-    );
-  }
-  parts.push(
-    "",
-    "Generate SQL that addresses each component of the breakdown."
   );
-  return parts.join("\n");
 }
-var chat4Agent = agent9({
-  name: "chat4-decomposition",
-  model: groq9("openai/gpt-oss-20b"),
-  tools: tools6,
-  prompt: (state) => {
-    return `
-${state?.teachings || ""}
-${state?.introspection || ""}
-
-When answering questions that require database queries, use the query_with_decomposition tool.
-
-IMPORTANT: You must break down the question into semantic parts - describe WHAT is being asked, not HOW to implement it.
-
-Good breakdown example for "Which customers bought the most expensive products last quarter?":
-- "customers who made purchases" (entity relationship)
-- "products they purchased" (what products)
-- "expensive products - need definition" (filter criteria - note ambiguity)
-- "last quarter" (time filter)
-- "most - ranking by count or value?" (aggregation - note ambiguity)
-
-Bad breakdown (too instructional):
-- "JOIN customers with orders" (this is HOW, not WHAT)
-- "Use ORDER BY and LIMIT" (this is implementation)
-
-Break the question into its semantic aspects, and let the SQL specialist figure out the implementation.
-`;
-  }
-});
 
 // packages/text2sql/src/lib/teach/teachings.ts
 function guidelines(options = {}) {
@@ -2514,80 +2889,41 @@ var Text2Sql = class {
   constructor(config) {
     this.#config = {
       adapter: config.adapter,
-      history: config.history,
+      store: config.store,
       instructions: [
         ...guidelines(config.teachingsOptions),
         ...config.instructions ?? []
       ],
       tools: config.tools ?? {},
       model: config.model,
-      memory: config.memory,
-      introspection: new FileCache("introspection-" + config.version)
+      introspection: new JsonCache(
+        "introspection-" + config.version
+      )
     };
   }
-  async explain(sql) {
-    const { experimental_output } = await generate5(
-      explainerAgent,
-      [user4("Explain this SQL.")],
-      { sql }
-    );
-    return experimental_output.explanation;
-  }
   async toSql(input) {
-    const introspection = await this.index();
+    const schemaFragments = await this.index();
     const result = await toSql({
       input,
       adapter: this.#config.adapter,
-      introspection,
+      schemaFragments,
       instructions: this.#config.instructions,
       model: this.#config.model
     });
     return result.sql;
   }
-  instruct(...dataset) {
-    this.#config.instructions.push(...dataset);
-  }
-  async inspect(agent10) {
-    const [grounding] = await Promise.all([this.index()]);
-    const renderToolNames = Object.keys(this.#config.tools ?? {}).filter(
-      (name) => name.startsWith("render_")
-    );
-    const allInstructions = [
-      ...this.#config.instructions,
-      guardrail({
-        rule: "ALWAYS use `get_sample_rows` before writing queries that filter or compare against string columns.",
-        reason: "Prevents SQL errors from wrong value formats.",
-        action: "Target specific columns (e.g., get_sample_rows('table', ['status', 'type']))."
-      }),
-      ...renderToolNames.length ? [
-        hint(`Rendering tools available: ${renderToolNames.join(", ")}.`),
-        styleGuide({
-          prefer: "Use render_* tools for trend/over time/monthly requests or chart asks",
-          always: "Include text insight alongside visualizations. Prefer line charts for time-based data."
-        })
-      ] : []
-    ];
-    const tools7 = Object.keys({
-      ...agent10.handoff.tools,
-      ...this.#config.memory ? memoryTools : {},
-      ...this.#config.tools
-    });
-    return {
-      tools: tools7,
-      prompt: agent10.instructions({
-        introspection: grounding,
-        teachings: toInstructions("instructions", ...allInstructions)
-      })
-    };
-  }
-  async index(options) {
-    const cached = await this.#config.introspection.get();
+  /**
+   * Introspect the database schema and return context fragments.
+   * Results are cached to avoid repeated introspection.
+   */
+  async index() {
+    const cached = await this.#config.introspection.read();
     if (cached) {
       return cached;
     }
-    const introspection = await this.#config.adapter.introspect();
-    await this.#config.introspection.set(introspection);
-    return introspection;
+    const fragments2 = await this.#config.adapter.introspect();
+    await this.#config.introspection.write(fragments2);
+    return fragments2;
   }
   /**
    * Generate training data pairs using a producer factory.
@@ -2612,529 +2948,136 @@ var Text2Sql = class {
     const producer = factory(this.#config.adapter);
     return producer.toPairs();
   }
-  // public async suggest() {
-  //   const [introspection, adapterInfo] = await Promise.all([
-  //     this.index(),
-  //     this.#config.adapter.introspect(),
-  //   ]);
-  //   const { experimental_output: output } = await generate(
-  //     suggestionsAgent,
-  //     [
-  //       user(
-  //         'Suggest high-impact business questions and matching SQL queries for this database.',
-  //       ),
-  //     ],
-  //     {
-  //     },
-  //   );
-  //   return output.suggestions;
-  // }
-  async chat(messages, params) {
-    const [introspection, userTeachables] = await Promise.all([
-      this.index({ onProgress: console.log }),
-      this.#config.memory ? this.#config.memory.toTeachables(params.userId) : []
-    ]);
-    const chat = await this.#config.history.upsertChat({
-      id: params.chatId,
-      userId: params.userId,
-      title: "Chat " + params.chatId
-    });
-    const renderToolNames = Object.keys(this.#config.tools ?? {}).filter(
-      (name) => name.startsWith("render_")
-    );
-    const instructions = [
-      ...this.#config.instructions,
-      guardrail({
-        rule: "ALWAYS use `get_sample_rows` before writing queries that filter or compare against string columns.",
-        reason: "Prevents SQL errors from wrong value formats.",
-        action: "Target specific columns (e.g., get_sample_rows('table', ['status', 'type']))."
-      }),
-      ...renderToolNames.length ? [
-        hint(`Rendering tools available: ${renderToolNames.join(", ")}.`),
-        styleGuide({
-          prefer: "Use render_* tools for trend/over time/monthly requests or chart asks",
-          always: "Include text insight alongside visualizations. Prefer line charts for time-based data."
-        })
-      ] : []
-    ];
-    const originalMessage = [
-      ...chat.messages.map((it) => it.content),
-      ...messages
-    ];
-    const result = stream(
-      t_a_g.clone({
-        model: this.#config.model,
-        tools: {
-          ...t_a_g.handoff.tools,
-          ...this.#config.memory ? memoryTools : {},
-          ...this.#config.tools
-        }
-      }),
-      originalMessage,
-      {
-        teachings: toInstructions(
-          "instructions",
-          persona({
-            name: "Freya",
-            role: "You are an expert SQL query generator, answering business questions with accurate queries.",
-            tone: "Your tone should be concise and business-friendly."
-          }),
-          ...instructions,
-          teachable("user_profile", ...userTeachables)
-        ),
-        adapter: this.#config.adapter,
-        introspection,
-        memory: this.#config.memory,
-        userId: params.userId
-      }
-    );
-    return this.#createUIMessageStream(
-      result,
-      messages,
-      params,
-      originalMessage
-    );
-  }
   /**
-   * Chat1 - Combined tool, no peek.
-   *
-   * Uses a single `query_database` tool that:
-   * 1. Takes a natural language question
-   * 2. Internally calls toSql() to generate validated SQL
-   * 3. Executes the SQL
-   * 4. Returns both SQL and results
-   *
-   * The agent does NOT see the SQL before execution.
+   * Build instructions for rendering tools (hint + styleGuide).
+   * Returns fragments to include when render_* tools are available.
    */
-  async chat1(messages, params) {
-    const [introspection, userTeachables] = await Promise.all([
-      this.index({ onProgress: console.log }),
-      this.#config.memory ? this.#config.memory.toTeachables(params.userId) : []
-    ]);
-    const chat = await this.#config.history.upsertChat({
-      id: params.chatId,
-      userId: params.userId,
-      title: "Chat " + params.chatId
-    });
+  #buildRenderingInstructions() {
     const renderToolNames = Object.keys(this.#config.tools ?? {}).filter(
       (name) => name.startsWith("render_")
     );
-    const instructions = [
-      ...this.#config.instructions,
-      ...renderToolNames.length ? [
-        hint(`Rendering tools available: ${renderToolNames.join(", ")}.`),
-        styleGuide({
-          prefer: "Use render_* tools for trend/over time/monthly requests or chart asks",
-          always: "Include text insight alongside visualizations. Prefer line charts for time-based data."
-        })
-      ] : []
-    ];
-    const originalMessage = [
-      ...chat.messages.map((it) => it.content),
-      ...messages
+    if (!renderToolNames.length) {
+      return [];
+    }
+    return [
+      hint(`Rendering tools available: ${renderToolNames.join(", ")}.`),
+      styleGuide({
+        prefer: "Use render_* tools for trend/over time/monthly requests or chart asks",
+        always: "Include text insight alongside visualizations. Prefer line charts for time-based data."
+      })
     ];
-    const result = stream(
-      chat1Agent.clone({
-        model: this.#config.model,
-        tools: {
-          ...tools3,
-          ...this.#config.memory ? memoryTools : {},
-          ...this.#config.tools
-        }
-      }),
-      originalMessage,
-      {
-        teachings: toInstructions(
-          "instructions",
-          ...instructions,
-          teachable("user_profile", ...userTeachables)
-        ),
-        adapter: this.#config.adapter,
-        introspection,
-        instructions: this.#config.instructions,
-        memory: this.#config.memory,
-        userId: params.userId
-      }
-    );
-    return this.#createUIMessageStream(
-      result,
-      messages,
-      params,
-      originalMessage
-    );
   }
-  /**
-   * Chat2 - Separate generate + execute tools (with peek).
-   *
-   * Uses two separate tools:
-   * 1. `generate_sql` - Takes a question, returns validated SQL
-   * 2. `execute_sql` - Takes SQL, executes it
-   *
-   * The agent sees the SQL before execution and can review/refine.
-   */
-  async chat2(messages, params) {
-    const [introspection, userTeachables] = await Promise.all([
-      this.index({ onProgress: console.log }),
-      this.#config.memory ? this.#config.memory.toTeachables(params.userId) : []
-    ]);
-    const chat = await this.#config.history.upsertChat({
-      id: params.chatId,
-      userId: params.userId,
-      title: "Chat " + params.chatId
-    });
-    const renderToolNames = Object.keys(this.#config.tools ?? {}).filter(
-      (name) => name.startsWith("render_")
-    );
-    const instructions = [
+  async chat(messages, params) {
+    const schemaFragments = await this.index();
+    const context = new ContextEngine({
+      store: this.#config.store,
+      chatId: params.chatId
+    }).set(
       ...this.#config.instructions,
-      ...renderToolNames.length ? [
-        hint(`Rendering tools available: ${renderToolNames.join(", ")}.`),
-        styleGuide({
-          prefer: "Use render_* tools for trend/over time/monthly requests or chart asks",
-          always: "Include text insight alongside visualizations. Prefer line charts for time-based data."
-        })
-      ] : []
-    ];
-    const originalMessage = [
-      ...chat.messages.map((it) => it.content),
-      ...messages
-    ];
-    const result = stream(
-      chat2Agent.clone({
-        model: this.#config.model,
-        tools: {
-          ...tools4,
-          ...this.#config.memory ? memoryTools : {},
-          ...this.#config.tools
-        }
-      }),
-      originalMessage,
-      {
-        teachings: toInstructions(
-          "instructions",
-          ...instructions,
-          teachable("user_profile", ...userTeachables)
-        ),
-        adapter: this.#config.adapter,
-        introspection,
-        instructions: this.#config.instructions,
-        memory: this.#config.memory,
-        userId: params.userId
-      }
+      ...this.#buildRenderingInstructions(),
+      ...schemaFragments
     );
-    return this.#createUIMessageStream(
-      result,
-      messages,
-      params,
-      originalMessage
-    );
-  }
-  /**
-   * Chat3 - Agent conversation/collaboration.
-   *
-   * Enables richer interaction where the SQL agent can:
-   * - Surface confidence levels
-   * - State assumptions
-   * - Request clarification when uncertain
-   */
-  async chat3(messages, params) {
-    const [introspection, userTeachables] = await Promise.all([
-      this.index({ onProgress: console.log }),
-      this.#config.memory ? this.#config.memory.toTeachables(params.userId) : []
-    ]);
-    const chat = await this.#config.history.upsertChat({
-      id: params.chatId,
-      userId: params.userId,
-      title: "Chat " + params.chatId
+    const userMsg = messages.at(-1);
+    if (userMsg) {
+      context.set(user(userMsg));
+      await context.save();
+    }
+    const chatAgent = t_a_g.clone({
+      model: this.#config.model,
+      context,
+      tools: { ...t_a_g.tools, ...this.#config.tools }
     });
-    const renderToolNames = Object.keys(this.#config.tools ?? {}).filter(
-      (name) => name.startsWith("render_")
-    );
-    const instructions = [
-      ...this.#config.instructions,
-      ...renderToolNames.length ? [
-        hint(`Rendering tools available: ${renderToolNames.join(", ")}.`),
-        styleGuide({
-          prefer: "Use render_* tools for trend/over time/monthly requests or chart asks",
-          always: "Include text insight alongside visualizations. Prefer line charts for time-based data."
-        })
-      ] : []
-    ];
-    const originalMessage = [
-      ...chat.messages.map((it) => it.content),
-      ...messages
-    ];
-    const result = stream(
-      chat3Agent.clone({
-        model: this.#config.model,
-        tools: {
-          ...tools5,
-          ...this.#config.memory ? memoryTools : {},
-          ...this.#config.tools
-        }
-      }),
-      originalMessage,
-      {
-        teachings: toInstructions(
-          "instructions",
-          ...instructions,
-          teachable("user_profile", ...userTeachables)
-        ),
-        adapter: this.#config.adapter,
-        introspection,
-        instructions: this.#config.instructions,
-        memory: this.#config.memory,
-        userId: params.userId
+    const result = await chatAgent.stream({});
+    return result.toUIMessageStream({
+      onError: (error) => this.#formatError(error),
+      sendStart: true,
+      sendFinish: true,
+      sendReasoning: true,
+      sendSources: true,
+      generateMessageId: generateId3,
+      onFinish: async ({ responseMessage }) => {
+        context.set(assistant(responseMessage));
+        await context.save();
       }
-    );
-    return this.#createUIMessageStream(
-      result,
-      messages,
-      params,
-      originalMessage
-    );
-  }
-  /**
-   * Chat4 - Question decomposition approach.
-   *
-   * Breaks down questions into semantic components before SQL generation:
-   * - entities: Key concepts mentioned
-   * - filters: Filtering criteria
-   * - aggregation: Type of aggregation
-   * - breakdown: Semantic parts of the question
-   *
-   * This helps ensure all aspects of the question are addressed.
-   */
-  async chat4(messages, params) {
-    const [introspection, userTeachables] = await Promise.all([
-      this.index({ onProgress: console.log }),
-      this.#config.memory ? this.#config.memory.toTeachables(params.userId) : []
-    ]);
-    const chat = await this.#config.history.upsertChat({
-      id: params.chatId,
-      userId: params.userId,
-      title: "Chat " + params.chatId
     });
-    const renderToolNames = Object.keys(this.#config.tools ?? {}).filter(
-      (name) => name.startsWith("render_")
-    );
-    const instructions = [
-      ...this.#config.instructions,
-      ...renderToolNames.length ? [
-        hint(`Rendering tools available: ${renderToolNames.join(", ")}.`),
-        styleGuide({
-          prefer: "Use render_* tools for trend/over time/monthly requests or chart asks",
-          always: "Include text insight alongside visualizations. Prefer line charts for time-based data."
-        })
-      ] : []
-    ];
-    const originalMessage = [
-      ...chat.messages.map((it) => it.content),
-      ...messages
-    ];
-    const result = stream(
-      chat4Agent.clone({
-        model: this.#config.model,
-        tools: {
-          ...tools6,
-          ...this.#config.memory ? memoryTools : {},
-          ...this.#config.tools
-        }
-      }),
-      originalMessage,
-      {
-        teachings: toInstructions(
-          "instructions",
-          ...instructions,
-          teachable("user_profile", ...userTeachables)
-        ),
-        adapter: this.#config.adapter,
-        introspection,
-        instructions: this.#config.instructions,
-        memory: this.#config.memory,
-        userId: params.userId
-      }
-    );
-    return this.#createUIMessageStream(
-      result,
-      messages,
-      params,
-      originalMessage
-    );
   }
   /**
-   * Developer-focused conversational interface for SQL generation.
-   *
-   * Provides power-user tools for query building without execution:
-   * - generate_sql: Convert natural language to validated SQL
-   * - validate_sql: Check SQL syntax
-   * - explain_sql: Get plain-English explanations
-   * - show_schema: Explore database schema on demand
-   *
-   * @example
-   * ```typescript
-   * const result = await text2sql.developer(
-   *   [user("Generate a query to find top customers by revenue")],
-   *   { chatId: 'dev-session-1', userId: 'dev-1' }
-   * );
-   * // Agent responds with SQL, can validate, explain, or refine iteratively
-   * ```
+   * Developer chat interface - power-user mode for SQL generation.
+   * Uses db_query tool for direct SQL execution (LLM writes SQL).
    */
   async developer(messages, params) {
-    const [introspection, userTeachables] = await Promise.all([
-      this.index({ onProgress: console.log }),
-      this.#config.memory ? this.#config.memory.toTeachables(params.userId) : []
-    ]);
-    return withChat(
-      this.#config.history,
-      params,
-      messages,
-      (originalMessages) => stream(
-        developerAgent.clone({
-          model: this.#config.model
-        }),
-        originalMessages,
-        {
-          teachings: toInstructions(
-            "instructions",
-            ...this.#config.instructions,
-            teachable("user_profile", ...userTeachables)
-          ),
-          adapter: this.#config.adapter,
-          introspection,
-          instructions: this.#config.instructions
-        }
-      )
+    const schemaFragments = await this.index();
+    const context = new ContextEngine({
+      store: this.#config.store,
+      chatId: params.chatId
+    }).set(
+      ...developer_agent_default.fragments,
+      ...this.#config.instructions,
+      ...schemaFragments
     );
-  }
-  /**
-   * Helper to create UI message stream with common error handling and persistence.
-   */
-  #createUIMessageStream(result, messages, params, originalMessages) {
+    const userMsg = messages.at(-1);
+    if (userMsg) {
+      context.set(user(userMsg));
+      await context.save();
+    }
+    const developerAgent = agent({
+      name: "developer",
+      model: this.#config.model,
+      context,
+      tools: developer_agent_default.tools
+    });
+    const result = await developerAgent.stream({
+      adapter: this.#config.adapter
+    });
     return result.toUIMessageStream({
-      onError: (error) => {
-        if (NoSuchToolError.isInstance(error)) {
-          return "The model tried to call an unknown tool.";
-        } else if (InvalidToolInputError.isInstance(error)) {
-          return "The model called a tool with invalid arguments.";
-        } else if (ToolCallRepairError.isInstance(error)) {
-          return "The model tried to call a tool with invalid arguments, but it was repaired.";
-        } else if (APICallError2.isInstance(error)) {
-          console.error("Upstream API call failed:", error);
-          return `Upstream API call failed with status ${error.statusCode}: ${error.message}`;
-        } else {
-          return JSON.stringify(error);
-        }
-      },
+      onError: (error) => this.#formatError(error),
       sendStart: true,
       sendFinish: true,
       sendReasoning: true,
       sendSources: true,
-      originalMessages,
-      generateMessageId: generateId,
-      onFinish: async ({ responseMessage, isContinuation }) => {
-        const userMessage = messages.at(-1);
-        if (!isContinuation && userMessage) {
-          console.log(
-            "Saving user message to history:",
-            JSON.stringify(userMessage)
-          );
-          await this.#config.history.addMessage({
-            id: v72(),
-            chatId: params.chatId,
-            role: userMessage.role,
-            content: userMessage
-          });
-        }
-        await this.#config.history.addMessage({
-          id: v72(),
-          chatId: params.chatId,
-          role: responseMessage.role,
-          content: responseMessage
-        });
+      generateMessageId: generateId3,
+      onFinish: async ({ responseMessage }) => {
+        context.set(assistant(responseMessage));
+        await context.save();
       }
     });
   }
-};
-async function withChat(history, params, messages, streamFn) {
-  const chat = await history.upsertChat({
-    id: params.chatId,
-    userId: params.userId,
-    title: "Chat " + params.chatId
-  });
-  const originalMessages = [
-    ...chat.messages.map((it) => it.content),
-    ...messages
-  ];
-  const result = streamFn(originalMessages);
-  return result.toUIMessageStream({
-    onError: (error) => {
-      if (NoSuchToolError.isInstance(error)) {
-        return "The model tried to call an unknown tool.";
-      } else if (InvalidToolInputError.isInstance(error)) {
-        return "The model called a tool with invalid arguments.";
-      } else if (ToolCallRepairError.isInstance(error)) {
-        return "The model tried to call a tool with invalid arguments, but it was repaired.";
-      } else if (APICallError2.isInstance(error)) {
-        console.error("Upstream API call failed:", error);
-        return `Upstream API call failed with status ${error.statusCode}: ${error.message}`;
-      } else {
-        return JSON.stringify(error);
-      }
-    },
-    sendStart: true,
-    sendFinish: true,
-    sendReasoning: true,
-    sendSources: true,
-    originalMessages,
-    generateMessageId: generateId,
-    onFinish: async ({ responseMessage, isContinuation }) => {
-      const userMessage = messages.at(-1);
-      if (!isContinuation && userMessage) {
-        console.log(
-          "Saving user message to history:",
-          JSON.stringify(userMessage)
-        );
-        await history.addMessage({
-          id: v72(),
-          chatId: params.chatId,
-          role: userMessage.role,
-          content: userMessage
-        });
-      }
-      await history.addMessage({
-        id: v72(),
-        chatId: params.chatId,
-        role: responseMessage.role,
-        content: responseMessage
-      });
+  #formatError(error) {
+    if (NoSuchToolError.isInstance(error)) {
+      return "The model tried to call an unknown tool.";
+    } else if (InvalidToolInputError.isInstance(error)) {
+      return "The model called a tool with invalid arguments.";
+    } else if (ToolCallRepairError.isInstance(error)) {
+      return "The model tried to call a tool with invalid arguments, but it was repaired.";
+    } else if (APICallError2.isInstance(error)) {
+      console.error("Upstream API call failed:", error);
+      return `Upstream API call failed with status ${error.statusCode}: ${error.message}`;
     }
-  });
-}
+    return JSON.stringify(error);
+  }
+};
 export {
   Adapter,
   Checkpoint,
   FileCache,
-  History,
-  InMemoryHistory,
-  InMemoryTeachablesStore,
   JsonCache,
   Point,
-  SqliteHistory,
-  SqliteTeachablesStore,
-  TeachablesStore,
   Text2Sql,
   applyTablesFilter,
-  developerAgent,
+  column,
+  constraint,
+  dialectInfo,
   filterRelationshipsByTables,
   filterTablesByName,
   getTablesWithRelated,
   guidelines,
   hashConfig,
+  index,
   matchesFilter,
-  memoryTools,
+  relationship,
   suggestionsAgent,
   t_a_g,
-  withChat
+  table,
+  view
 };
 //# sourceMappingURL=index.js.map