@deepagents/text2sql 0.36.0 → 0.37.1

package/dist/index.js

@@ -1,3 +1,18 @@
+// packages/text2sql/src/lib/adapter-name.ts
+var ADAPTER_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function isValidAdapterName(name) {
+  return name != null && ADAPTER_NAME_PATTERN.test(name);
+}
+function validateAdapterNames(names) {
+  for (const name of names) {
+    if (!isValidAdapterName(name)) {
+      throw new Error(
+        `Invalid adapter name "${name}": must match ${ADAPTER_NAME_PATTERN}`
+      );
+    }
+  }
+}
+
 // packages/text2sql/src/lib/adapters/adapter.ts
 import { format as formatSql } from "sql-formatter";
 
@@ -5,6 +20,7 @@ import { format as formatSql } from "sql-formatter";
 var sqlValidationMarker = Symbol("SQLValidationError");
 var unanswerableSqlMarker = Symbol("UnanswerableSQLError");
 var sqlScopeMarker = Symbol("SQLScopeError");
+var sqlReadOnlyMarker = Symbol("SQLReadOnlyError");
 var SQLValidationError = class _SQLValidationError extends Error {
   [sqlValidationMarker];
   constructor(message) {
@@ -42,6 +58,17 @@ var SQLScopeError = class _SQLScopeError extends Error {
     return error instanceof _SQLScopeError && error[sqlScopeMarker] === true;
   }
 };
+var SQLReadOnlyError = class _SQLReadOnlyError extends Error {
+  [sqlReadOnlyMarker];
+  constructor(message) {
+    super(message);
+    this.name = "SQLReadOnlyError";
+    this[sqlReadOnlyMarker] = true;
+  }
+  static isInstance(error) {
+    return error instanceof _SQLReadOnlyError && error[sqlReadOnlyMarker] === true;
+  }
+};
 
 // packages/text2sql/src/lib/fragments/schema.ts
 function dialectInfo(input) {
@@ -468,12 +495,23 @@ var Adapter = class {
     });
   }
   format(sql) {
+    const decoded = this.#decodeShellEscapes(sql);
     try {
-      return formatSql(sql, { language: this.formatterLanguage });
+      return formatSql(decoded, { language: this.formatterLanguage });
     } catch {
-      return sql;
+      return decoded;
     }
   }
+  #decodeShellEscapes(sql) {
+    return sql.replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\([().*])/g, "$1").replace(/\\(?=$)/gm, "");
+  }
+  #checkReadOnly(sql) {
+    const upper = sql.trimStart().toUpperCase();
+    if (!upper.startsWith("SELECT") && !upper.startsWith("WITH")) {
+      return "only SELECT or WITH queries allowed";
+    }
+    return null;
+  }
   #cachedAllowedEntities = null;
   async #resolveScope() {
     if (this.#cachedAllowedEntities) return this.#cachedAllowedEntities;
@@ -535,16 +573,22 @@ var Adapter = class {
     return buildOutOfScopePayload(sql, outOfScope, allowedEntities);
   }
   async validate(sql) {
+    const decoded = this.#decodeShellEscapes(sql);
+    const readOnlyError = this.#checkReadOnly(decoded);
+    if (readOnlyError) return readOnlyError;
     const allowed = await this.#resolveScope();
-    const scopeError = await this.#checkScope(sql, allowed);
+    const scopeError = await this.#checkScope(decoded, allowed);
     if (scopeError) return JSON.stringify(scopeError);
-    return this.validateImpl(sql);
+    return this.validateImpl(decoded);
   }
   async execute(sql) {
+    const decoded = this.#decodeShellEscapes(sql);
+    const readOnlyError = this.#checkReadOnly(decoded);
+    if (readOnlyError) throw new SQLReadOnlyError(readOnlyError);
     const allowed = await this.#resolveScope();
-    const scopeError = await this.#checkScope(sql, allowed);
+    const scopeError = await this.#checkScope(decoded, allowed);
     if (scopeError) throw new SQLScopeError(scopeError);
-    return this.executeImpl(sql);
+    return this.executeImpl(decoded);
   }
   /**
    * Convert unknown database value to number.
@@ -666,62 +710,148 @@ function getTablesWithRelated(allTables, relationships, filter) {
   return Array.from(result);
 }
 
-// packages/text2sql/src/lib/agents/result-tools.ts
-import { tool } from "ai";
-import { createBashTool } from "bash-tool";
-import chalk from "chalk";
-import {
-  Bash,
-  MountableFs,
-  OverlayFs,
-  defineCommand,
-  parse as parse2
-} from "just-bash";
-import { AsyncLocalStorage } from "node:async_hooks";
-import * as path2 from "node:path";
+// packages/text2sql/src/lib/agents/sql-command.ts
 import { v7 } from "uuid";
-import z from "zod";
-
-// packages/text2sql/src/lib/agents/sql-transform-plugins.ts
-import { parse, serialize } from "just-bash";
-import { createHash } from "node:crypto";
-import * as path from "node:path";
-function asStaticWordText(word) {
-  if (!word) {
-    return null;
+import {
+  buildSubcommandRepair,
+  defineSubcommandGroup,
+  repairQuotedArg,
+  useBashMeta
+} from "@deepagents/context";
+var SQL_VALIDATE_REMINDER = 'Always run `sql validate <db> "..."` before `sql run <db> "..."` to catch syntax errors early.';
+function repairDbNameAndQuotedArg(rawArgs) {
+  const trimmed = rawArgs.trim();
+  if (!trimmed) return null;
+  const firstSpace = trimmed.search(/\s/);
+  if (firstSpace === -1) return null;
+  const dbName = trimmed.slice(0, firstSpace);
+  const rest = trimmed.slice(firstSpace + 1);
+  const repaired = repairQuotedArg(rest);
+  if (repaired == null) return null;
+  return `${dbName} ${repaired}`;
+}
+function resolveAdapter(adapters, subcommand, args) {
+  const [name, ...rest] = args;
+  const available = Object.keys(adapters).join(", ");
+  if (!name) {
+    return {
+      error: `sql ${subcommand}: missing database name. Usage: sql ${subcommand} <db> "SELECT ...". Available: ${available}`
+    };
   }
-  return asStaticWordPartText(
-    word.parts
-  );
+  const adapter = adapters[name];
+  if (!adapter) {
+    return {
+      error: `sql ${subcommand}: unknown database "${name}". Available: ${available}`
+    };
+  }
+  const sql = rest.join(" ").trim();
+  if (!sql) {
+    return { error: `sql ${subcommand}: no query provided` };
+  }
+  return { adapter, sql };
 }
-function asStaticWordPartText(parts) {
-  let text = "";
-  for (const part of parts) {
-    const type = part.type;
-    if (type === "Literal" || type === "SingleQuoted" || type === "Escaped") {
-      if (typeof part.value !== "string") {
-        return null;
-      }
-      text += part.value;
-      continue;
-    }
-    if (type === "DoubleQuoted") {
-      if (!Array.isArray(part.parts)) {
-        return null;
+function createSqlCommand(adapters, { outputDir = "/sql" } = {}) {
+  const subcommands = {
+    run: {
+      usage: 'run <db> "SELECT ..."',
+      description: "Execute query against <db> and store results",
+      repair: repairDbNameAndQuotedArg,
+      handler: async (args, ctx) => {
+        const meta = useBashMeta();
+        meta?.setReminder(SQL_VALIDATE_REMINDER);
+        const resolved = resolveAdapter(adapters, "run", args);
+        if ("error" in resolved) {
+          return { stdout: "", stderr: resolved.error, exitCode: 1 };
+        }
+        const { adapter, sql: rawQuery } = resolved;
+        const query = adapter.format(rawQuery);
+        meta?.setHidden({ formattedSql: query });
+        const syntaxError = await adapter.validate(query);
+        if (syntaxError) {
+          return {
+            stdout: "",
+            stderr: `sql run: ${syntaxError}`,
+            exitCode: 1
+          };
+        }
+        try {
+          const rows = await adapter.execute(query);
+          if (!Array.isArray(rows)) {
+            throw new Error("adapter.execute must return an array of rows");
+          }
+          const rowsArray = rows;
+          const content = JSON.stringify(rowsArray, null, 2);
+          const filename = `${v7()}.json`;
+          const sqlPath = `${outputDir}/${filename}`;
+          const mkdir = await ctx.sandbox.executeCommand(
+            `mkdir -p ${outputDir}`
+          );
+          if (mkdir.exitCode !== 0) {
+            return {
+              stdout: "",
+              stderr: `sql run: failed to create ${outputDir}: ${mkdir.stderr}`,
+              exitCode: 1
+            };
+          }
+          await ctx.sandbox.writeFiles([{ path: sqlPath, content }]);
+          const columns = rowsArray.length > 0 ? Object.keys(rowsArray[0]) : [];
+          return {
+            stdout: [
+              `results stored in ${sqlPath}`,
+              `columns: ${columns.join(", ") || "(none)"}`,
+              `rows: ${rowsArray.length}`
+            ].join("\n") + "\n",
+            stderr: "",
+            exitCode: 0
+          };
+        } catch (error) {
+          return {
+            stdout: "",
+            stderr: `sql run: ${error instanceof Error ? error.message : String(error)}`,
+            exitCode: 1
+          };
+        }
       }
-      const inner = asStaticWordPartText(
-        part.parts
-      );
-      if (inner == null) {
-        return null;
+    },
+    validate: {
+      usage: 'validate <db> "SELECT ..."',
+      description: "Validate query syntax against <db>",
+      repair: repairDbNameAndQuotedArg,
+      handler: async (args) => {
+        const meta = useBashMeta();
+        const resolved = resolveAdapter(adapters, "validate", args);
+        if ("error" in resolved) {
+          return { stdout: "", stderr: resolved.error, exitCode: 1 };
+        }
+        const { adapter, sql: rawQuery } = resolved;
+        const query = adapter.format(rawQuery);
+        meta?.setHidden({ formattedSql: query });
+        const syntaxError = await adapter.validate(query);
+        if (syntaxError) {
+          return {
+            stdout: "",
+            stderr: `sql validate: ${syntaxError}`,
+            exitCode: 1
+          };
+        }
+        return {
+          stdout: "valid\n",
+          stderr: "",
+          exitCode: 0
+        };
       }
-      text += inner;
-      continue;
     }
-    return null;
-  }
-  return text;
+  };
+  const command = defineSubcommandGroup("sql", subcommands);
+  const repair = buildSubcommandRepair("sql", subcommands);
+  return { command, repair };
 }
+
+// packages/text2sql/src/lib/agents/sql-transform-plugins.ts
+import { parse, serialize } from "just-bash";
+import { createHash } from "node:crypto";
+import * as path from "node:path";
+import { BashException, asStaticWordText } from "@deepagents/context";
 function isScriptNode(value) {
   if (typeof value !== "object" || value === null) {
     return false;
@@ -748,14 +878,18 @@ var WRAPPER_COMMANDS = /* @__PURE__ */ new Set(["env", "command", "eval"]);
 var SQL_PROXY_ENFORCEMENT_MESSAGE = [
   "Direct database querying through bash is blocked.",
   "Use SQL proxy commands in this order:",
-  '1) sql validate "SELECT ..."',
-  '2) sql run "SELECT ..."'
+  '1) sql validate <db> "SELECT ..."',
+  '2) sql run <db> "SELECT ..."'
 ].join("\n");
-var SqlProxyViolationError = class extends Error {
+var SqlProxyViolationError = class extends BashException {
   constructor() {
     super(SQL_PROXY_ENFORCEMENT_MESSAGE);
     this.name = "SqlProxyViolationError";
   }
+  format() {
+    return { stdout: "", stderr: `${this.message}
+`, exitCode: 1 };
+  }
 };
 function cloneInspectionContext(context) {
   return {
@@ -1362,10 +1496,12 @@ function isSqlBacktickCommand(cmd) {
   if (cmd.type !== "SimpleCommand") return false;
   if (cmd.assignments.length > 0 || cmd.redirections.length > 0) return false;
   if (asStaticWordText(cmd.name) !== "sql") return false;
-  if (cmd.args.length < 2) return false;
+  if (cmd.args.length < 3) return false;
   const subcommand = asStaticWordText(cmd.args[0]);
   if (subcommand !== "validate" && subcommand !== "run") return false;
-  const sqlArgs = cmd.args.slice(1);
+  const dbName = asStaticWordText(cmd.args[1]);
+  if (!isValidAdapterName(dbName)) return false;
+  const sqlArgs = cmd.args.slice(2);
   return sqlArgs.some(
     (arg) => wordPartsContainBacktickSubstitution(
       arg.parts
@@ -1395,7 +1531,8 @@ function extractSqlText(args) {
 }
 function rewriteSqlBacktickCommand(cmd, ast) {
   const subcommand = asStaticWordText(cmd.args[0]);
-  const sqlArgs = cmd.args.slice(1);
+  const dbName = asStaticWordText(cmd.args[1]);
+  const sqlArgs = cmd.args.slice(2);
   const unquotedSql = extractSqlText(sqlArgs);
   const hash2 = createHash("sha256").update(serialize(ast)).digest("hex").slice(0, 12);
   const sqlPath = `/tmp/sql-inline-${subcommand}-${hash2}.sql`;
@@ -1404,7 +1541,7 @@ function rewriteSqlBacktickCommand(cmd, ast) {
     `{ cat > ${sqlPath} <<'${heredocTag}'`,
     unquotedSql,
     heredocTag,
-    `sql ${subcommand} "$(cat ${sqlPath})"; }`
+    `sql ${subcommand} ${dbName} "$(cat ${sqlPath})"; }`
   ].join("\n");
   const groupAst = parse(groupScript);
   return groupAst.statements[0].pipelines[0].commands[0];
@@ -1462,296 +1599,6 @@ var SqlBacktickRewritePlugin = class {
   }
 };
 
-// packages/text2sql/src/lib/agents/result-tools.ts
-function createCommand(name, subcommands) {
-  const usageLines = Object.entries(subcommands).map(([, def]) => `  ${name} ${def.usage.padEnd(30)} ${def.description}`).join("\n");
-  return defineCommand(name, async (args, ctx) => {
-    const subcommand = args[0];
-    const restArgs = args.slice(1);
-    if (subcommand && subcommand in subcommands) {
-      return subcommands[subcommand].handler(restArgs, ctx);
-    }
-    return {
-      stdout: "",
-      stderr: `${name}: ${subcommand ? `unknown subcommand '${subcommand}'` : "missing subcommand"}
-
-Usage:
-${usageLines}`,
-      exitCode: 1
-    };
-  });
-}
-function escapeRegExp(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function buildRepair(name, subcommands) {
-  const subNames = Object.keys(subcommands).map(escapeRegExp).join("|");
-  const pattern = new RegExp(
-    `^(\\s*${escapeRegExp(name)}\\s+(?:${subNames}))\\s+([\\s\\S]+)$`
-  );
-  return function repair(raw) {
-    const match = raw.match(pattern);
-    if (!match) return raw;
-    try {
-      parse2(raw);
-      return raw;
-    } catch {
-    }
-    const [, prefix, argsPart] = match;
-    const sub = prefix.trim().split(/\s+/).pop();
-    const repairFn = subcommands[sub]?.repair;
-    if (!repairFn) return raw;
-    const repairedArgs = repairFn(argsPart);
-    if (repairedArgs == null) return raw;
-    const repaired = `${prefix} ${repairedArgs}`;
-    try {
-      parse2(repaired);
-      return repaired;
-    } catch {
-      return raw;
-    }
-  };
-}
-function validateReadOnly(query) {
-  const upper = query.toUpperCase().trim();
-  if (!upper.startsWith("SELECT") && !upper.startsWith("WITH")) {
-    return { valid: false, error: "only SELECT or WITH queries allowed" };
-  }
-  return { valid: true };
-}
-var SQL_VALIDATE_REMINDER = "Always run `sql validate` before `sql run` to catch syntax errors early.";
-function normalizeShellArtifacts(raw) {
-  return raw.replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\([().*])/g, "$1").replace(/\\(?=$)/gm, "");
-}
-function stripQuoteArtifacts(raw) {
-  let sql = raw.trim();
-  if (sql.startsWith('"')) {
-    sql = sql.slice(1);
-    if (sql.endsWith('"')) sql = sql.slice(0, -1);
-  } else if (sql.startsWith("'")) {
-    sql = sql.slice(1);
-    if (sql.endsWith("'")) sql = sql.slice(0, -1);
-  }
-  return sql.trim();
-}
-function repairSqlArgs(rawArgs) {
-  const sql = stripQuoteArtifacts(rawArgs);
-  if (!sql) return null;
-  const escaped = sql.replace(/'/g, "'\\''");
-  return `'${escaped}'`;
-}
-function createSqlCommand(adapter, metaStore) {
-  const subcommands = {
-    run: {
-      usage: 'run "SELECT ..."',
-      description: "Execute query and store results",
-      repair: repairSqlArgs,
-      handler: async (args, ctx) => {
-        const store = metaStore.getStore();
-        if (store) {
-          store.value = { ...store.value, reminder: SQL_VALIDATE_REMINDER };
-        }
-        const rawQuery = normalizeShellArtifacts(args.join(" ").trim());
-        if (!rawQuery) {
-          return {
-            stdout: "",
-            stderr: "sql run: no query provided",
-            exitCode: 1
-          };
-        }
-        const validation = validateReadOnly(rawQuery);
-        if (!validation.valid) {
-          return {
-            stdout: "",
-            stderr: `sql run: ${validation.error}`,
-            exitCode: 1
-          };
-        }
-        const query = adapter.format(rawQuery);
-        if (store) {
-          store.value = { ...store.value, formattedSql: query };
-        }
-        const syntaxError = await adapter.validate(query);
-        if (syntaxError) {
-          return {
-            stdout: "",
-            stderr: `sql run: ${syntaxError}`,
-            exitCode: 1
-          };
-        }
-        try {
-          const rows = await adapter.execute(query);
-          const rowsArray = Array.isArray(rows) ? rows : [];
-          const content = JSON.stringify(rowsArray, null, 2);
-          const filename = `${v7()}.json`;
-          const sqlPath = `/sql/${filename}`;
-          await ctx.fs.mkdir("/sql", { recursive: true });
-          await ctx.fs.writeFile(sqlPath, content);
-          const columns = rowsArray.length > 0 ? Object.keys(rowsArray[0]) : [];
-          return {
-            stdout: [
-              `results stored in ${sqlPath}`,
-              `columns: ${columns.join(", ") || "(none)"}`,
-              `rows: ${rowsArray.length}`
-            ].join("\n") + "\n",
-            stderr: "",
-            exitCode: 0
-          };
-        } catch (error) {
-          return {
-            stdout: "",
-            stderr: `sql run: ${error instanceof Error ? error.message : String(error)}`,
-            exitCode: 1
-          };
-        }
-      }
-    },
-    validate: {
-      usage: 'validate "SELECT ..."',
-      description: "Validate query syntax",
-      repair: repairSqlArgs,
-      handler: async (args) => {
-        const rawQuery = normalizeShellArtifacts(args.join(" ").trim());
-        if (!rawQuery) {
-          return {
-            stdout: "",
-            stderr: "sql validate: no query provided",
-            exitCode: 1
-          };
-        }
-        const validation = validateReadOnly(rawQuery);
-        if (!validation.valid) {
-          return {
-            stdout: "",
-            stderr: `sql validate: ${validation.error}`,
-            exitCode: 1
-          };
-        }
-        const query = adapter.format(rawQuery);
-        const store = metaStore.getStore();
-        if (store) store.value = { ...store.value, formattedSql: query };
-        const syntaxError = await adapter.validate(query);
-        if (syntaxError) {
-          return {
-            stdout: "",
-            stderr: `sql validate: ${syntaxError}`,
-            exitCode: 1
-          };
-        }
-        return {
-          stdout: "valid\n",
-          stderr: "",
-          exitCode: 0
-        };
-      }
-    }
-  };
-  const command = createCommand("sql", subcommands);
-  const repair = buildRepair("sql", subcommands);
-  return { command, repair };
-}
-function toViolationResult(error) {
-  if (error instanceof SqlProxyViolationError) {
-    return { stdout: "", stderr: `${error.message}
-`, exitCode: 1 };
-  }
-  return null;
-}
-async function createResultTools(options) {
-  const { adapter, skillMounts, filesystem: baseFs } = options;
-  const metaStore = new AsyncLocalStorage();
-  const { command: sqlCommand, repair: repairCommand } = createSqlCommand(
-    adapter,
-    metaStore
-  );
-  const fsMounts = skillMounts.map(({ host, sandbox: sandbox2 }) => ({
-    mountPoint: path2.dirname(sandbox2),
-    filesystem: new OverlayFs({
-      root: path2.dirname(host),
-      mountPoint: "/",
-      readOnly: true
-    })
-  }));
-  const filesystem = new MountableFs({
-    base: baseFs,
-    mounts: fsMounts
-  });
-  const bashInstance = new Bash({
-    customCommands: [sqlCommand],
-    fs: filesystem
-  });
-  bashInstance.registerTransformPlugin(new SqlBacktickRewritePlugin());
-  bashInstance.registerTransformPlugin(new SqlProxyEnforcementPlugin());
-  const { sandbox, tools } = await createBashTool({
-    sandbox: bashInstance,
-    destination: "/",
-    extraInstructions: 'Every bash tool call must include a brief non-empty "reasoning" input explaining why the command is needed.',
-    onBeforeBashCall: ({ command }) => {
-      const repaired = repairCommand(command);
-      console.log(chalk.cyan(`[onBeforeBashCall]: ${repaired}`));
-      return { command: repaired };
-    },
-    onAfterBashCall: ({ result }) => {
-      if (result.exitCode !== 0) {
-        console.log(chalk.yellow(`[onAfterBashCall]: ${result.exitCode}`));
-      }
-      return { result };
-    }
-  });
-  const guardedSandbox = {
-    ...sandbox,
-    executeCommand: async (command) => {
-      try {
-        return await sandbox.executeCommand(command);
-      } catch (error) {
-        const violation = toViolationResult(error);
-        if (violation) return violation;
-        throw error;
-      }
-    }
-  };
-  const bash = tool({
-    ...tools.bash,
-    inputSchema: z.object({
-      command: z.string().describe("The bash command to execute"),
-      reasoning: z.string().trim().describe("Brief reason for executing this command")
-    }),
-    execute: async ({ command }, execOptions) => {
-      const execute = tools.bash.execute;
-      if (!execute) {
-        throw new Error("bash tool execution is not available");
-      }
-      return metaStore.run({}, async () => {
-        try {
-          const result = await execute({ command }, execOptions);
-          const storeValue = metaStore.getStore()?.value;
-          if (!storeValue) return result;
-          const { reminder, ...meta } = storeValue;
-          return { ...result, meta, reminder };
-        } catch (error) {
-          const violation = toViolationResult(error);
-          if (violation) return violation;
-          throw error;
-        }
-      });
-    },
-    toModelOutput: ({ output }) => {
-      if (typeof output !== "object" || output === null) {
-        return { type: "json", value: output };
-      }
-      const { meta, ...rest } = output;
-      return { type: "json", value: rest };
-    }
-  });
-  return {
-    sandbox: guardedSandbox,
-    tools: {
-      ...tools,
-      bash
-    }
-  };
-}
-
 // packages/text2sql/src/lib/agents/sql.agent.ts
 import { groq } from "@ai-sdk/groq";
 import {
@@ -1766,7 +1613,7 @@ import {
 } from "ai";
 import dedent from "dedent";
 import pRetry from "p-retry";
-import z2 from "zod";
+import z from "zod";
 import "@deepagents/agent";
 import {
   ContextEngine,
@@ -2043,14 +1890,14 @@ Question: ${options.input}
       const sqlOutput = structuredOutput({
         model,
         context,
-        schema: z2.object({
-          result: z2.union([
-            z2.object({
-              sql: z2.string().describe("The SQL query that answers the question"),
-              reasoning: z2.string().describe("The reasoning steps taken to generate the SQL")
+        schema: z.object({
+          result: z.union([
+            z.object({
+              sql: z.string().describe("The SQL query that answers the question"),
+              reasoning: z.string().describe("The reasoning steps taken to generate the SQL")
             }),
-            z2.object({
-              error: z2.string().describe(
+            z.object({
+              error: z.string().describe(
                 "Error message explaining why the question cannot be answered with the given schema"
               )
             })
@@ -2079,11 +1926,11 @@ Question: ${options.input}
         const forcedSqlOutput = structuredOutput({
           model,
           context,
-          schema: z2.object({
-            sql: z2.string().describe(
+          schema: z.object({
+            sql: z.string().describe(
               "Best-effort SQL query that answers the core intent using only available schema entities."
             ),
-            reasoning: z2.string().describe("Reasoning steps for best-effort schema mapping.")
+            reasoning: z.string().describe("Reasoning steps for best-effort schema mapping.")
           })
         });
         try {
@@ -2168,17 +2015,17 @@ async function withRetry(computation, options = { retries: 3 }) {
 // packages/text2sql/src/lib/agents/suggestions.agents.ts
 import { groq as groq2 } from "@ai-sdk/groq";
 import dedent2 from "dedent";
-import z3 from "zod";
+import z2 from "zod";
 import { agent, thirdPersonPrompt } from "@deepagents/agent";
 var suggestionsAgent = agent({
   name: "text2sql-suggestions",
   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.")
+  output: z2.object({
+    suggestions: z2.array(
+      z2.object({
+        question: z2.string().describe("A complex, high-impact business question."),
+        sql: z2.string().describe("The SQL statement needed to answer the question."),
+        businessValue: z2.string().describe("Why the question matters to stakeholders.")
       })
     ).min(1).max(5).describe("A set of up to two advanced question + SQL pairs.")
   }),
@@ -2225,9 +2072,9 @@ var Checkpoint = class _Checkpoint {
   points;
   path;
   configHash;
-  constructor(path7, configHash, points) {
+  constructor(path6, configHash, points) {
     this.points = points;
-    this.path = path7;
+    this.path = path6;
     this.configHash = configHash;
   }
   /**
@@ -2235,14 +2082,14 @@ var Checkpoint = class _Checkpoint {
    * Handles corrupted files and config changes gracefully.
    */
   static async load(options) {
-    const { path: path7, configHash } = options;
-    if (existsSync(path7)) {
+    const { path: path6, configHash } = options;
+    if (existsSync(path6)) {
       try {
-        const content = readFileSync(path7, "utf-8");
+        const content = readFileSync(path6, "utf-8");
         const file = JSON.parse(content);
         if (configHash && file.configHash && file.configHash !== configHash) {
           console.log("\u26A0 Config changed, starting fresh");
-          return new _Checkpoint(path7, configHash, {});
+          return new _Checkpoint(path6, configHash, {});
         }
         const points = file.points ?? {};
         const totalEntries = Object.values(points).reduce(
@@ -2250,14 +2097,14 @@ var Checkpoint = class _Checkpoint {
           0
         );
         console.log(`\u2713 Resuming from checkpoint (${totalEntries} entries)`);
-        return new _Checkpoint(path7, configHash, points);
+        return new _Checkpoint(path6, configHash, points);
       } catch {
         console.log("\u26A0 Checkpoint corrupted, starting fresh");
-        return new _Checkpoint(path7, configHash, {});
+        return new _Checkpoint(path6, configHash, {});
       }
     }
     console.log("Starting new checkpoint");
-    return new _Checkpoint(path7, configHash, {});
+    return new _Checkpoint(path6, configHash, {});
   }
   /**
    * Run a single computation with checkpointing.
@@ -2391,12 +2238,12 @@ import { createHash as createHash3 } from "node:crypto";
 import { existsSync as existsSync2 } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import path3 from "node:path";
+import path2 from "node:path";
 var FileCache = class {
   path;
   constructor(watermark, extension = ".txt") {
     const hash2 = createHash3("md5").update(watermark).digest("hex");
-    this.path = path3.join(tmpdir(), `text2sql-${hash2}${extension}`);
+    this.path = path2.join(tmpdir(), `text2sql-${hash2}${extension}`);
   }
   async get() {
     if (existsSync2(this.path)) {
@@ -2425,7 +2272,7 @@ var JsonCache = class extends FileCache {
 };
 
 // packages/text2sql/src/lib/fs/sqlite/sqlite-fs.ts
-import * as path4 from "node:path";
+import * as path3 from "node:path";
 import { DatabaseSync } from "node:sqlite";
 
 // packages/text2sql/src/lib/fs/sqlite/ddl.sqlite-fs.sql
@@ -2473,7 +2320,7 @@ var SqliteFs = class {
     const segments = p.split("/").filter(Boolean);
     let currentPath = "/";
     for (let i = 0; i < segments.length - 1; i++) {
-      currentPath = path4.posix.join(currentPath, segments[i]);
+      currentPath = path3.posix.join(currentPath, segments[i]);
       const exists = this.#stmt("SELECT 1 FROM fs_entries WHERE path = ?").get(
         currentPath
       );
@@ -2494,7 +2341,7 @@ var SqliteFs = class {
     return stmt;
   }
   #normalizeRoot(root) {
-    return path4.posix.resolve("/", root.trim());
+    return path3.posix.resolve("/", root.trim());
   }
   #prefixPath(p) {
     if (!this.#root) {
@@ -2503,7 +2350,7 @@ var SqliteFs = class {
     if (p === "/") {
       return this.#root;
     }
-    return path4.posix.join(this.#root, p);
+    return path3.posix.join(this.#root, p);
   }
   #unprefixPath(p) {
     if (!this.#root) {
@@ -2529,10 +2376,10 @@ var SqliteFs = class {
     }
   }
   #normalizePath(p) {
-    return path4.posix.resolve("/", p);
+    return path3.posix.resolve("/", p);
   }
   #dirname(p) {
-    const dir = path4.posix.dirname(p);
+    const dir = path3.posix.dirname(p);
     return dir === "" ? "/" : dir;
   }
   #ensureParentExists(filePath) {
@@ -2595,7 +2442,7 @@ var SqliteFs = class {
     }
     seen.add(p);
     const target = this.#normalizePath(
-      path4.posix.resolve(this.#dirname(p), entry.symlinkTarget)
+      path3.posix.resolve(this.#dirname(p), entry.symlinkTarget)
     );
     return this.#resolveSymlink(target, seen);
   }
@@ -2747,11 +2594,11 @@ var SqliteFs = class {
     this.#useTransaction(() => {
       if (options?.recursive) {
         const rootPath = this.#root || "/";
-        const relativePath = path4.posix.relative(rootPath, prefixed);
+        const relativePath = path3.posix.relative(rootPath, prefixed);
         const segments = relativePath.split("/").filter(Boolean);
         let currentPath = rootPath;
         for (const segment of segments) {
-          currentPath = path4.posix.join(currentPath, segment);
+          currentPath = path3.posix.join(currentPath, segment);
           const exists = this.#stmt(
             "SELECT type FROM fs_entries WHERE path = ?"
           ).get(currentPath);
@@ -2802,7 +2649,7 @@ var SqliteFs = class {
          AND path != ?
          AND path NOT LIKE ? || '%/%'`
     ).all(prefix, resolved, prefix);
-    return rows.map((row) => path4.posix.basename(row.path));
+    return rows.map((row) => path3.posix.basename(row.path));
   }
   async readdirWithFileTypes(dirPath) {
     const normalized = this.#normalizePath(dirPath);
@@ -2825,7 +2672,7 @@ var SqliteFs = class {
          AND path NOT LIKE ? || '%/%'`
     ).all(prefix, resolved, prefix);
     return rows.map((row) => ({
-      name: path4.posix.basename(row.path),
+      name: path3.posix.basename(row.path),
       isFile: row.type === "file",
       isDirectory: row.type === "directory",
       isSymbolicLink: row.type === "symlink"
@@ -2880,8 +2727,8 @@ var SqliteFs = class {
           `SELECT * FROM fs_entries WHERE path = ? OR path LIKE ? || '/%'`
         ).all(srcPrefixed, srcPrefixed);
         for (const entry of allEntries) {
-          const relativePath = path4.posix.relative(srcPrefixed, entry.path);
-          const newPath = path4.posix.join(destPrefixed, relativePath);
+          const relativePath = path3.posix.relative(srcPrefixed, entry.path);
+          const newPath = path3.posix.join(destPrefixed, relativePath);
           this.#stmt(
             `INSERT OR REPLACE INTO fs_entries (path, type, mode, size, mtime, symlinkTarget)
              VALUES (?, ?, ?, ?, ?, ?)`
@@ -2948,8 +2795,8 @@ var SqliteFs = class {
           `SELECT * FROM fs_entries WHERE path = ? OR path LIKE ? || '/%' ORDER BY path DESC`
         ).all(srcPrefixed, srcPrefixed);
         for (const entry of [...allEntries].reverse()) {
-          const relativePath = path4.posix.relative(srcPrefixed, entry.path);
-          const newPath = path4.posix.join(destPrefixed, relativePath);
+          const relativePath = path3.posix.relative(srcPrefixed, entry.path);
+          const newPath = path3.posix.join(destPrefixed, relativePath);
           this.#stmt(
             `INSERT INTO fs_entries (path, type, mode, size, mtime, symlinkTarget)
              VALUES (?, ?, ?, ?, ?, ?)`
@@ -3002,7 +2849,7 @@ var SqliteFs = class {
     });
   }
   resolvePath(base, relativePath) {
-    return path4.posix.resolve(base, relativePath);
+    return path3.posix.resolve(base, relativePath);
   }
   getAllPaths() {
     const rows = this.#stmt(
@@ -3114,7 +2961,7 @@ var SqliteFs = class {
 
 // packages/text2sql/src/lib/fs/mssql/mssql-fs.ts
 import { createRequire } from "node:module";
-import * as path5 from "node:path";
+import * as path4 from "node:path";
 
 // packages/text2sql/src/lib/fs/mssql/ddl.mssql-fs.ts
 function mssqlFsDDL(schema) {
@@ -3240,7 +3087,7 @@ var MssqlFs = class _MssqlFs {
     const segments = p.split("/").filter(Boolean);
     let currentPath = "/";
     for (let i = 0; i < segments.length - 1; i++) {
-      currentPath = path5.posix.join(currentPath, segments[i]);
+      currentPath = path4.posix.join(currentPath, segments[i]);
       const exists = await this.#rawQuery(
         `SELECT CASE WHEN EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = @p0) THEN 1 ELSE 0 END as [exists]`,
         [currentPath]
@@ -3292,7 +3139,7 @@ var MssqlFs = class _MssqlFs {
     }
   }
   #normalizeRoot(root) {
-    return path5.posix.resolve("/", root.trim());
+    return path4.posix.resolve("/", root.trim());
   }
   #prefixPath(p) {
     if (!this.#root) {
@@ -3301,7 +3148,7 @@ var MssqlFs = class _MssqlFs {
     if (p === "/") {
       return this.#root;
     }
-    return path5.posix.join(this.#root, p);
+    return path4.posix.join(this.#root, p);
   }
   #unprefixPath(p) {
     if (!this.#root) {
@@ -3316,10 +3163,10 @@ var MssqlFs = class _MssqlFs {
     return p;
   }
   #normalizePath(p) {
-    return path5.posix.resolve("/", p);
+    return path4.posix.resolve("/", p);
   }
   #dirname(p) {
-    const dir = path5.posix.dirname(p);
+    const dir = path4.posix.dirname(p);
     return dir === "" ? "/" : dir;
   }
   async #ensureParentExists(filePath, transaction) {
@@ -3408,7 +3255,7 @@ var MssqlFs = class _MssqlFs {
     }
     seen.add(p);
     const target = this.#normalizePath(
-      path5.posix.resolve(this.#dirname(p), entry.symlinkTarget)
+      path4.posix.resolve(this.#dirname(p), entry.symlinkTarget)
     );
     return this.#resolveSymlink(target, seen);
   }
@@ -3591,11 +3438,11 @@ var MssqlFs = class _MssqlFs {
     await this.#useTransaction(async (transaction) => {
       if (options?.recursive) {
         const rootPath = this.#root || "/";
-        const relativePath = path5.posix.relative(rootPath, prefixed);
+        const relativePath = path4.posix.relative(rootPath, prefixed);
         const segments = relativePath.split("/").filter(Boolean);
         let currentPath = rootPath;
         for (const segment of segments) {
-          currentPath = path5.posix.join(currentPath, segment);
+          currentPath = path4.posix.join(currentPath, segment);
           const checkReq = transaction.request();
           checkReq.input("p0", currentPath);
           const result = await checkReq.query(
@@ -3659,7 +3506,7 @@ var MssqlFs = class _MssqlFs {
          AND path NOT LIKE @p0 + '%/%'`,
       [prefix, resolved]
     );
-    return rows.map((row) => path5.posix.basename(row.path));
+    return rows.map((row) => path4.posix.basename(row.path));
   }
   async readdirWithFileTypes(dirPath) {
     const normalized = this.#normalizePath(dirPath);
@@ -3685,7 +3532,7 @@ var MssqlFs = class _MssqlFs {
       [prefix, resolved]
     );
     return rows.map((row) => ({
-      name: path5.posix.basename(row.path),
+      name: path4.posix.basename(row.path),
       isFile: row.type === "file",
       isDirectory: row.type === "directory",
       isSymbolicLink: row.type === "symlink"
@@ -3754,8 +3601,8 @@ var MssqlFs = class _MssqlFs {
           `SELECT * FROM ${this.#t("fs_entries")} WHERE path = @p0 OR path LIKE @p0 + '/%'`
         );
         for (const entry of allEntriesResult.recordset) {
-          const relativePath = path5.posix.relative(srcPrefixed, entry.path);
-          const newPath = path5.posix.join(destPrefixed, relativePath);
+          const relativePath = path4.posix.relative(srcPrefixed, entry.path);
+          const newPath = path4.posix.join(destPrefixed, relativePath);
           const insertReq = transaction.request();
           insertReq.input("p0", newPath);
           insertReq.input("p1", entry.type);
@@ -3864,8 +3711,8 @@ var MssqlFs = class _MssqlFs {
           `DELETE FROM ${this.#t("fs_entries")} WHERE path = @dp0 OR path LIKE @dp0 + '/%'`
         );
         for (const entry of [...allEntriesResult.recordset].reverse()) {
-          const relativePath = path5.posix.relative(srcPrefixed, entry.path);
-          const newPath = path5.posix.join(destPrefixed, relativePath);
+          const relativePath = path4.posix.relative(srcPrefixed, entry.path);
+          const newPath = path4.posix.join(destPrefixed, relativePath);
           const insertReq = transaction.request();
           insertReq.input("p0", newPath);
           insertReq.input("p1", entry.type);
@@ -3958,7 +3805,7 @@ var MssqlFs = class _MssqlFs {
     });
   }
   resolvePath(base, relativePath) {
-    return path5.posix.resolve(base, relativePath);
+    return path4.posix.resolve(base, relativePath);
   }
   getAllPaths() {
     throw new Error(
@@ -4099,7 +3946,7 @@ var MssqlFs = class _MssqlFs {
 
 // packages/text2sql/src/lib/fs/postgres/postgres-fs.ts
 import { createRequire as createRequire2 } from "node:module";
-import * as path6 from "node:path";
+import * as path5 from "node:path";
 
 // packages/text2sql/src/lib/fs/postgres/ddl.postgres-fs.ts
 function postgresFsDDL(schema) {
@@ -4204,7 +4051,7 @@ var PostgresFs = class _PostgresFs {
     const segments = p.split("/").filter(Boolean);
     let currentPath = "/";
     for (let i = 0; i < segments.length - 1; i++) {
-      currentPath = path6.posix.join(currentPath, segments[i]);
+      currentPath = path5.posix.join(currentPath, segments[i]);
       const exists = await this.#rawQuery(
         `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = $1) AS exists`,
         [currentPath]
@@ -4249,7 +4096,7 @@ var PostgresFs = class _PostgresFs {
     }
   }
   #normalizeRoot(root) {
-    return path6.posix.resolve("/", root.trim());
+    return path5.posix.resolve("/", root.trim());
   }
   #prefixPath(p) {
     if (!this.#root) {
@@ -4258,7 +4105,7 @@ var PostgresFs = class _PostgresFs {
     if (p === "/") {
       return this.#root;
     }
-    return path6.posix.join(this.#root, p);
+    return path5.posix.join(this.#root, p);
   }
   #unprefixPath(p) {
     if (!this.#root) {
@@ -4273,10 +4120,10 @@ var PostgresFs = class _PostgresFs {
     return p;
   }
   #normalizePath(p) {
-    return path6.posix.resolve("/", p);
+    return path5.posix.resolve("/", p);
   }
   #dirname(p) {
-    const dir = path6.posix.dirname(p);
+    const dir = path5.posix.dirname(p);
     return dir === "" ? "/" : dir;
   }
   async #ensureParentExists(filePath, client) {
@@ -4356,7 +4203,7 @@ var PostgresFs = class _PostgresFs {
     }
     seen.add(p);
     const target = this.#normalizePath(
-      path6.posix.resolve(this.#dirname(p), entry.symlink_target)
+      path5.posix.resolve(this.#dirname(p), entry.symlink_target)
     );
     return this.#resolveSymlink(target, seen);
   }
@@ -4522,11 +4369,11 @@ var PostgresFs = class _PostgresFs {
     await this.#useTransaction(async (client) => {
       if (options?.recursive) {
         const rootPath = this.#root || "/";
-        const relativePath = path6.posix.relative(rootPath, prefixed);
+        const relativePath = path5.posix.relative(rootPath, prefixed);
         const segments = relativePath.split("/").filter(Boolean);
         let currentPath = rootPath;
         for (const segment of segments) {
-          currentPath = path6.posix.join(currentPath, segment);
+          currentPath = path5.posix.join(currentPath, segment);
           const result = await client.query(
             `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
             [currentPath]
@@ -4584,7 +4431,7 @@ var PostgresFs = class _PostgresFs {
          AND path NOT LIKE $1 || '%/%'`,
       [prefix, resolved]
     );
-    return rows.map((row) => path6.posix.basename(row.path));
+    return rows.map((row) => path5.posix.basename(row.path));
   }
   async readdirWithFileTypes(dirPath) {
     const normalized = this.#normalizePath(dirPath);
@@ -4610,7 +4457,7 @@ var PostgresFs = class _PostgresFs {
       [prefix, resolved]
     );
     return rows.map((row) => ({
-      name: path6.posix.basename(row.path),
+      name: path5.posix.basename(row.path),
       isFile: row.type === "file",
       isDirectory: row.type === "directory",
       isSymbolicLink: row.type === "symlink"
@@ -4675,8 +4522,8 @@ var PostgresFs = class _PostgresFs {
           [srcPrefixed]
         );
         for (const entry of allEntriesResult.rows) {
-          const relativePath = path6.posix.relative(srcPrefixed, entry.path);
-          const newPath = path6.posix.join(destPrefixed, relativePath);
+          const relativePath = path5.posix.relative(srcPrefixed, entry.path);
+          const newPath = path5.posix.join(destPrefixed, relativePath);
           await client.query(
             `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime, symlink_target)
              VALUES ($1, $2, $3, $4, $5, $6)
@@ -4765,8 +4612,8 @@ var PostgresFs = class _PostgresFs {
           [destPrefixed]
         );
         for (const entry of [...allEntriesResult.rows].reverse()) {
-          const relativePath = path6.posix.relative(srcPrefixed, entry.path);
-          const newPath = path6.posix.join(destPrefixed, relativePath);
+          const relativePath = path5.posix.relative(srcPrefixed, entry.path);
+          const newPath = path5.posix.join(destPrefixed, relativePath);
           await client.query(
             `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime, symlink_target)
              VALUES ($1, $2, $3, $4, $5, $6)
@@ -4839,7 +4686,7 @@ var PostgresFs = class _PostgresFs {
     });
   }
   resolvePath(base, relativePath) {
-    return path6.posix.resolve(base, relativePath);
+    return path5.posix.resolve(base, relativePath);
   }
   getAllPaths() {
     throw new Error(
@@ -4975,29 +4822,29 @@ var ScopedFs = class {
     this.#base = options.base;
     this.#prefix = options.prefix.replace(/\/$/, "");
   }
-  #scope(path7) {
-    return `${this.#prefix}${path7}`;
+  #scope(path6) {
+    return `${this.#prefix}${path6}`;
   }
-  #unscope(path7) {
-    if (path7 === this.#prefix) {
+  #unscope(path6) {
+    if (path6 === this.#prefix) {
       return "/";
     }
-    if (path7.startsWith(this.#prefix + "/")) {
-      return path7.slice(this.#prefix.length) || "/";
+    if (path6.startsWith(this.#prefix + "/")) {
+      return path6.slice(this.#prefix.length) || "/";
     }
-    return path7;
+    return path6;
   }
-  async writeFile(path7, content, options) {
-    await this.#base.writeFile(this.#scope(path7), content, options);
+  async writeFile(path6, content, options) {
+    await this.#base.writeFile(this.#scope(path6), content, options);
   }
-  async appendFile(path7, content, options) {
-    await this.#base.appendFile(this.#scope(path7), content, options);
+  async appendFile(path6, content, options) {
+    await this.#base.appendFile(this.#scope(path6), content, options);
   }
-  async mkdir(path7, options) {
-    return this.#base.mkdir(this.#scope(path7), options);
+  async mkdir(path6, options) {
+    return this.#base.mkdir(this.#scope(path6), options);
   }
-  async rm(path7, options) {
-    await this.#base.rm(this.#scope(path7), options);
+  async rm(path6, options) {
+    await this.#base.rm(this.#scope(path6), options);
   }
   async cp(src, dest, options) {
     await this.#base.cp(this.#scope(src), this.#scope(dest), options);
@@ -5005,8 +4852,8 @@ var ScopedFs = class {
   async mv(src, dest) {
     await this.#base.mv(this.#scope(src), this.#scope(dest));
   }
-  async chmod(path7, mode) {
-    return this.#base.chmod(this.#scope(path7), mode);
+  async chmod(path6, mode) {
+    return this.#base.chmod(this.#scope(path6), mode);
   }
   async symlink(target, linkPath) {
     await this.#base.symlink(target, this.#scope(linkPath));
@@ -5014,35 +4861,35 @@ var ScopedFs = class {
   async link(existingPath, newPath) {
     await this.#base.link(this.#scope(existingPath), this.#scope(newPath));
   }
-  readFile(path7, options) {
-    return this.#base.readFile(this.#scope(path7), options);
+  readFile(path6, options) {
+    return this.#base.readFile(this.#scope(path6), options);
   }
-  readFileBuffer(path7) {
-    return this.#base.readFileBuffer(this.#scope(path7));
+  readFileBuffer(path6) {
+    return this.#base.readFileBuffer(this.#scope(path6));
   }
-  stat(path7) {
-    return this.#base.stat(this.#scope(path7));
+  stat(path6) {
+    return this.#base.stat(this.#scope(path6));
   }
-  lstat(path7) {
-    return this.#base.lstat(this.#scope(path7));
+  lstat(path6) {
+    return this.#base.lstat(this.#scope(path6));
   }
-  readdir(path7) {
-    return this.#base.readdir(this.#scope(path7));
+  readdir(path6) {
+    return this.#base.readdir(this.#scope(path6));
   }
-  readdirWithFileTypes(path7) {
-    return this.#base.readdirWithFileTypes(this.#scope(path7));
+  readdirWithFileTypes(path6) {
+    return this.#base.readdirWithFileTypes(this.#scope(path6));
   }
-  exists(path7) {
-    return this.#base.exists(this.#scope(path7));
+  exists(path6) {
+    return this.#base.exists(this.#scope(path6));
   }
-  readlink(path7) {
-    return this.#base.readlink(this.#scope(path7));
+  readlink(path6) {
+    return this.#base.readlink(this.#scope(path6));
   }
-  realpath(path7) {
-    return this.#base.realpath(this.#scope(path7)).then((p) => this.#unscope(p));
+  realpath(path6) {
+    return this.#base.realpath(this.#scope(path6)).then((p) => this.#unscope(p));
   }
-  utimes(path7, atime, mtime) {
-    return this.#base.utimes(this.#scope(path7), atime, mtime);
+  utimes(path6, atime, mtime) {
+    return this.#base.utimes(this.#scope(path6), atime, mtime);
   }
   resolvePath(base, relativePath) {
     return this.#base.resolvePath(base, relativePath);
@@ -5053,97 +4900,6 @@ var ScopedFs = class {
   }
 };
 
-// packages/text2sql/src/lib/fs/tracked-fs.ts
-var TrackedFs = class {
-  #base;
-  #createdFiles = /* @__PURE__ */ new Set();
-  constructor(base) {
-    this.#base = base;
-  }
-  getCreatedFiles() {
-    return [...this.#createdFiles];
-  }
-  async writeFile(path7, content, options) {
-    await this.#base.writeFile(path7, content, options);
-    this.#createdFiles.add(path7);
-  }
-  async appendFile(path7, content, options) {
-    await this.#base.appendFile(path7, content, options);
-    this.#createdFiles.add(path7);
-  }
-  async mkdir(path7, options) {
-    return this.#base.mkdir(path7, options);
-  }
-  async rm(path7, options) {
-    await this.#base.rm(path7, options);
-    this.#createdFiles.delete(path7);
-    if (options?.recursive) {
-      const prefix = path7.endsWith("/") ? path7 : path7 + "/";
-      for (const file of this.#createdFiles) {
-        if (file.startsWith(prefix)) {
-          this.#createdFiles.delete(file);
-        }
-      }
-    }
-  }
-  async cp(src, dest, options) {
-    await this.#base.cp(src, dest, options);
-    this.#createdFiles.add(dest);
-  }
-  async mv(src, dest) {
-    await this.#base.mv(src, dest);
-    this.#createdFiles.delete(src);
-    this.#createdFiles.add(dest);
-  }
-  async chmod(path7, mode) {
-    return this.#base.chmod(path7, mode);
-  }
-  async symlink(target, linkPath) {
-    await this.#base.symlink(target, linkPath);
-    this.#createdFiles.add(linkPath);
-  }
-  async link(existingPath, newPath) {
-    await this.#base.link(existingPath, newPath);
-    this.#createdFiles.add(newPath);
-  }
-  readFile(path7, options) {
-    return this.#base.readFile(path7, options);
-  }
-  readFileBuffer(path7) {
-    return this.#base.readFileBuffer(path7);
-  }
-  stat(path7) {
-    return this.#base.stat(path7);
-  }
-  lstat(path7) {
-    return this.#base.lstat(path7);
-  }
-  readdir(path7) {
-    return this.#base.readdir(path7);
-  }
-  readdirWithFileTypes(path7) {
-    return this.#base.readdirWithFileTypes(path7);
-  }
-  exists(path7) {
-    return this.#base.exists(path7);
-  }
-  readlink(path7) {
-    return this.#base.readlink(path7);
-  }
-  resolvePath(base, relativePath) {
-    return this.#base.resolvePath(base, relativePath);
-  }
-  getAllPaths() {
-    return this.#base.getAllPaths?.() ?? [];
-  }
-  realpath(path7) {
-    return this.#base.realpath(path7);
-  }
-  utimes(path7, atime, mtime) {
-    return this.#base.utimes(path7, atime, mtime);
-  }
-};
-
 // packages/text2sql/src/lib/instructions.ts
 import {
   clarification,
@@ -5382,7 +5138,8 @@ Action: Ask user: "Top by what metric\u2014total revenue, number of orders, or m
       workflow2({
         task: "Query execution",
         steps: [
-          'Execute SQL through bash tool: sql run "SELECT ..."',
+          "Pick the target database from the schema fragments (each parent fragment is named after a configured database).",
+          'Execute SQL through bash tool: sql run <db> "SELECT ..."',
           "Read the output: file path, column names, and row count.",
           "Use column names to construct jq filters: cat <path> | jq '.[] | {col1, col2}'",
           "For large results, slice first: cat <path> | jq '.[:10]'"
@@ -5391,7 +5148,7 @@ Action: Ask user: "Top by what metric\u2014total revenue, number of orders, or m
       guardrail2({
         rule: "Do not attempt SQL access through non-bash tools.",
         reason: "SQL access is only available through the virtual bash environment.",
-        action: 'Use "sql run" and "sql validate" through bash.'
+        action: 'Use `sql run <db> "SELECT ..."` and `sql validate <db> "SELECT ..."` through bash, where `<db>` is the configured database name.'
       }),
       explain({
         concept: "sql command output format",
@@ -5429,214 +5186,128 @@ Action: Ask user: "Top by what metric\u2014total revenue, number of orders, or m
   return baseTeachings;
 }
 
+// packages/text2sql/src/lib/sandbox.ts
+function sqlSandboxExtension(adapters, options = {}) {
+  const adapterNames = Object.keys(adapters);
+  if (adapterNames.length === 0) {
+    throw new Error("sqlSandboxExtension requires at least one adapter");
+  }
+  validateAdapterNames(adapterNames);
+  const { command, repair } = createSqlCommand(adapters, options);
+  return {
+    commands: [command],
+    plugins: [new SqlBacktickRewritePlugin(), new SqlProxyEnforcementPlugin()],
+    onBeforeBashCall: ({ command: c }) => ({ command: repair(c) })
+  };
+}
+
 // packages/text2sql/src/lib/sql.ts
-import {
-  APICallError as APICallError2,
-  InvalidToolInputError,
-  NoSuchToolError,
-  ToolCallRepairError,
-  createUIMessageStream,
-  generateId
-} from "ai";
-import "just-bash";
 import "@deepagents/agent";
 import {
   agent as agent2,
-  assistant,
-  chatMessageToUIMessage,
+  chat,
   errorRecoveryGuardrail,
-  generateChatTitle,
-  staticChatTitle,
-  toMessageFragment
+  fragment as fragment3
 } from "@deepagents/context";
 var Text2Sql = class {
   #config;
+  #introspection;
   constructor(config) {
+    const adapterNames = Object.keys(config.adapters);
+    if (adapterNames.length === 0) {
+      throw new Error("Text2Sql requires at least one adapter");
+    }
+    validateAdapterNames(adapterNames);
     this.#config = {
-      adapter: config.adapter,
-      context: config.context,
-      tools: config.tools ?? {},
-      model: config.model,
-      transform: config.transform,
-      filesystem: config.filesystem,
-      introspection: new JsonCache(
-        "introspection-" + config.version
-      )
+      ...config,
+      tools: config.tools ?? {}
     };
+    this.#introspection = new Map(
+      Object.keys(config.adapters).map((name) => [
+        name,
+        new JsonCache(
+          `introspection-${config.version}-${name}`
+        )
+      ])
+    );
+  }
+  #requireAdapter(name) {
+    const adapter = this.#config.adapters[name];
+    if (!adapter) {
+      const available = Object.keys(this.#config.adapters).join(", ");
+      throw new Error(`Unknown adapter "${name}". Available: ${available}`);
+    }
+    return adapter;
   }
-  async toSql(input) {
-    const schemaFragments = await this.index();
+  async toSql(input, adapterName) {
+    const adapter = this.#requireAdapter(adapterName);
+    const fragments = await this.#indexAdapter(adapterName, adapter);
     const result = await toSql({
       input,
-      adapter: this.#config.adapter,
-      fragments: schemaFragments,
+      adapter,
+      fragments,
       model: this.#config.model
     });
     return result.sql;
   }
-  /**
-   * Introspect the database schema and return context fragments.
-   * Results are cached to avoid repeated introspection.
-   */
   async index() {
-    const cached = await this.#config.introspection.read();
+    const entries = Object.entries(this.#config.adapters);
+    const wrapped = await Promise.all(
+      entries.map(async ([name, adapter]) => {
+        const schema = await this.#indexAdapter(name, adapter);
+        return fragment3(name, ...schema);
+      })
+    );
+    return wrapped;
+  }
+  async #indexAdapter(name, adapter) {
+    const cache = this.#introspection.get(name);
+    if (!cache) {
+      throw new Error(`no introspection cache registered for "${name}"`);
+    }
+    const cached = await cache.read();
     if (cached) {
       return cached;
     }
-    const fragments = await this.#config.adapter.introspect();
-    await this.#config.introspection.write(fragments);
-    return fragments;
+    try {
+      const fragments = await adapter.introspect();
+      await cache.write(fragments);
+      return fragments;
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new Error(`introspecting adapter "${name}": ${reason}`, {
+        cause: error
+      });
+    }
   }
-  /**
-   * Generate training data pairs using a producer factory.
-   * The factory receives the configured adapter, so users don't need to pass it manually.
-   *
-   * @example
-   * // Generate questions for existing SQL
-   * const pairs = await text2sql.toPairs(
-   *   (adapter) => new SqlExtractor(sqls, adapter, { validateSql: true })
-   * );
-   *
-   * @example
-   * // Extract from chat history with validation
-   * const pairs = await text2sql.toPairs(
-   *   (adapter) => new ValidatedProducer(
-   *     new MessageExtractor(messages),
-   *     adapter
-   *   )
-   * );
-   */
-  async toPairs(factory) {
-    const producer = factory(this.#config.adapter);
+  async toPairs(adapterName, factory) {
+    const adapter = this.#requireAdapter(adapterName);
+    const producer = factory(adapter);
     return producer.toPairs();
   }
   async chat(messages, options) {
     if (messages.length === 0) {
       throw new Error("messages must not be empty");
     }
-    const trackedFs = new TrackedFs(this.#config.filesystem);
     const context = this.#config.context(
       ...guidelines(),
       ...await this.index()
     );
-    const lastItem = messages[messages.length - 1];
-    const lastFragment = toMessageFragment(lastItem);
-    const lastUIMessage = chatMessageToUIMessage(lastItem);
-    let assistantMsgId;
-    if (lastUIMessage.role === "assistant") {
-      context.set(lastFragment);
-      await context.save({ branch: false });
-      assistantMsgId = lastUIMessage.id;
-    } else {
-      context.set(lastFragment);
-      await context.save();
-      assistantMsgId = generateId();
-    }
-    const uiMessages = messages.map(chatMessageToUIMessage);
-    let title = null;
-    if (!context.chat?.title) {
-      const firstUserMsg = uiMessages.find((m) => m.role === "user");
-      if (firstUserMsg) {
-        if (options?.generateTitle) {
-          title = await generateChatTitle({
-            message: firstUserMsg,
-            model: this.#config.model,
-            abortSignal: options?.abortSignal
-          });
-        } else {
-          title = staticChatTitle(firstUserMsg);
-        }
-        await context.updateChat({ title });
-      }
-    }
-    const { mounts: skillMounts } = context.getSkillMounts();
-    const { tools } = await createResultTools({
-      adapter: this.#config.adapter,
-      skillMounts,
-      filesystem: trackedFs
-    });
     const chatAgent = agent2({
       name: "text2sql",
+      sandbox: this.#config.sandbox,
       model: this.#config.model,
       context,
-      tools: {
-        ...tools,
-        ...this.#config.tools
-      },
+      tools: this.#config.tools,
       guardrails: [errorRecoveryGuardrail],
       maxGuardrailRetries: 3
     });
-    const result = await chatAgent.stream(
-      {},
-      { abortSignal: options?.abortSignal, transform: this.#config.transform }
-    );
-    const uiStream = result.toUIMessageStream({
-      onError: (error) => this.#formatError(error),
-      sendStart: true,
-      sendFinish: true,
-      sendReasoning: true,
-      sendSources: true,
-      originalMessages: uiMessages,
-      generateMessageId: () => assistantMsgId,
-      messageMetadata: ({ part }) => {
-        if (part.type === "finish-step") {
-          return {
-            finishReason: part.finishReason,
-            usage: part.usage
-          };
-        }
-        if (part.type === "finish") {
-          return {
-            finishReason: part.finishReason,
-            totalUsage: part.totalUsage
-          };
-        }
-        return void 0;
-      }
-    });
-    return createUIMessageStream({
-      originalMessages: uiMessages,
-      generateId: () => assistantMsgId,
-      onStepFinish: async ({ responseMessage }) => {
-        context.set(assistant({ ...responseMessage, id: assistantMsgId }));
-        await context.save({ branch: false });
-      },
-      onFinish: async ({ responseMessage }) => {
-        const createdFiles = trackedFs.getCreatedFiles();
-        context.set(
-          assistant({
-            ...responseMessage,
-            id: assistantMsgId,
-            metadata: {
-              ...responseMessage.metadata ?? {},
-              createdFiles
-            }
-          })
-        );
-        await context.save({ branch: false });
-        await context.trackUsage(await result.totalUsage);
-      },
-      execute: async ({ writer }) => {
-        writer.merge(uiStream);
-        if (title) {
-          writer.write({ type: "data-chat-title", data: title });
-        }
-      }
+    return chat(chatAgent, messages, {
+      abortSignal: options?.abortSignal,
+      generateTitle: options?.generateTitle,
+      transform: this.#config.transform
     });
   }
-  #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,
@@ -5646,17 +5317,20 @@ export {
   MssqlFs,
   Point,
   PostgresFs,
+  SQLReadOnlyError,
   SQLScopeError,
   SQLValidationError,
   ScopedFs,
+  SqlBacktickRewritePlugin,
+  SqlProxyEnforcementPlugin,
+  SqlProxyViolationError,
   SqliteFs,
   Text2Sql,
-  TrackedFs,
   UnanswerableSQLError,
   applyTablesFilter,
   column,
   constraint,
-  createResultTools,
+  createSqlCommand,
   dialectInfo,
   filterRelationshipsByTables,
   filterTablesByName,
@@ -5664,11 +5338,14 @@ export {
   guidelines,
   hashConfig,
   index,
+  isValidAdapterName,
   matchesFilter,
   relationship,
+  sqlSandboxExtension,
   suggestionsAgent,
   table,
   toSql,
+  validateAdapterNames,
   view
 };
 //# sourceMappingURL=index.js.map