@mindstudio-ai/agent 0.1.9 → 0.1.10

package/dist/postinstall.js

@@ -1419,6 +1419,19 @@ var init_auth = __esm({
 });
 
 // src/db/sql.ts
+function serializeParam(val) {
+  if (val === null || val === void 0) return null;
+  if (typeof val === "boolean") return val ? 1 : 0;
+  if (typeof val === "number" || typeof val === "string") return val;
+  return JSON.stringify(val);
+}
+function serializeColumnParam(val, columnName, columns) {
+  const col = columns.find((c) => c.name === columnName);
+  if (col?.type === "user" && typeof val === "string") {
+    return `@@user@@${val}`;
+  }
+  return serializeParam(val);
+}
 function escapeValue(val) {
   if (val === null || val === void 0) return "NULL";
   if (typeof val === "boolean") return val ? "1" : "0";
@@ -1427,13 +1440,6 @@ function escapeValue(val) {
   const json = JSON.stringify(val);
   return `'${json.replace(/'/g, "''")}'`;
 }
-function serializeValue(val, columnName, columns) {
-  const col = columns.find((c) => c.name === columnName);
-  if (col?.type === "user" && typeof val === "string") {
-    return escapeValue(`@@user@@${val}`);
-  }
-  return escapeValue(val);
-}
 function deserializeRow(row, columns) {
   const result = {};
   for (const [key, value] of Object.entries(row)) {
@@ -1454,37 +1460,54 @@ function deserializeRow(row, columns) {
 }
 function buildSelect(table, options = {}) {
   let sql = `SELECT * FROM ${table}`;
-  if (options.where) sql += ` WHERE ${options.where}`;
+  const params = [];
+  if (options.where) {
+    sql += ` WHERE ${options.where}`;
+    if (options.whereParams) params.push(...options.whereParams);
+  }
   if (options.orderBy) sql += ` ORDER BY ${options.orderBy}${options.desc ? " DESC" : " ASC"}`;
   if (options.limit != null) sql += ` LIMIT ${options.limit}`;
   if (options.offset != null) sql += ` OFFSET ${options.offset}`;
-  return sql;
+  return { sql, params: params.length > 0 ? params : void 0 };
 }
-function buildCount(table, where) {
+function buildCount(table, where, whereParams) {
   let sql = `SELECT COUNT(*) as count FROM ${table}`;
   if (where) sql += ` WHERE ${where}`;
-  return sql;
+  return { sql, params: whereParams?.length ? whereParams : void 0 };
 }
-function buildExists(table, where, negate) {
+function buildExists(table, where, whereParams, negate) {
   const inner = where ? `SELECT 1 FROM ${table} WHERE ${where}` : `SELECT 1 FROM ${table}`;
   const fn = negate ? "NOT EXISTS" : "EXISTS";
-  return `SELECT ${fn}(${inner}) as result`;
+  return { sql: `SELECT ${fn}(${inner}) as result`, params: whereParams?.length ? whereParams : void 0 };
 }
 function buildInsert(table, data, columns) {
   const filtered = stripSystemColumns(data);
   const keys = Object.keys(filtered);
-  const vals = keys.map((k) => serializeValue(filtered[k], k, columns));
-  return `INSERT INTO ${table} (${keys.join(", ")}) VALUES (${vals.join(", ")})`;
+  const placeholders = keys.map(() => "?").join(", ");
+  const params = keys.map((k) => serializeColumnParam(filtered[k], k, columns));
+  return {
+    sql: `INSERT INTO ${table} (${keys.join(", ")}) VALUES (${placeholders}) RETURNING *`,
+    params
+  };
 }
 function buildUpdate(table, id, data, columns) {
   const filtered = stripSystemColumns(data);
-  const assignments = Object.entries(filtered).map(([k, v]) => `${k} = ${serializeValue(v, k, columns)}`).join(", ");
-  return `UPDATE ${table} SET ${assignments} WHERE id = ${escapeValue(id)}`;
+  const keys = Object.keys(filtered);
+  const assignments = keys.map((k) => `${k} = ?`).join(", ");
+  const params = [
+    ...keys.map((k) => serializeColumnParam(filtered[k], k, columns)),
+    id
+    // for WHERE id = ?
+  ];
+  return {
+    sql: `UPDATE ${table} SET ${assignments} WHERE id = ? RETURNING *`,
+    params
+  };
 }
-function buildDelete(table, where) {
+function buildDelete(table, where, whereParams) {
   let sql = `DELETE FROM ${table}`;
   if (where) sql += ` WHERE ${where}`;
-  return sql;
+  return { sql, params: whereParams?.length ? whereParams : void 0 };
 }
 function stripSystemColumns(data) {
   const result = {};
@@ -2026,17 +2049,11 @@ var init_query = __esm({
     init_predicate();
     init_sql();
     Query = class _Query {
-      /** @internal Accumulated predicate functions to filter by. */
       _predicates;
-      /** @internal The field accessor for sorting, if set. */
       _sortAccessor;
-      /** @internal Whether the sort order is reversed (DESC). */
       _reversed;
-      /** @internal Maximum number of results (SQL LIMIT). */
       _limit;
-      /** @internal Number of results to skip (SQL OFFSET). */
       _offset;
-      /** @internal Binding to the database execution layer. */
       _config;
       constructor(config, options) {
         this._config = config;
@@ -2046,10 +2063,6 @@ var init_query = __esm({
         this._limit = options?.limit;
         this._offset = options?.offset;
       }
-      /**
-       * Create a clone of this query with some options overridden.
-       * Used internally by chain methods to maintain immutability.
-       */
       _clone(overrides) {
         return new _Query(this._config, {
           predicates: overrides.predicates ?? this._predicates,
@@ -2060,126 +2073,73 @@ var init_query = __esm({
         });
       }
       // -------------------------------------------------------------------------
-      // Chain methods — return new Query instances
+      // Chain methods
       // -------------------------------------------------------------------------
-      /**
-       * Add a filter predicate. Multiple filters are ANDed together.
-       *
-       * @example
-       * ```ts
-       * const active = Orders.filter(o => o.status === 'active');
-       * const expensive = active.filter(o => o.amount > 5000);
-       * // WHERE status = 'active' AND amount > 5000
-       * ```
-       */
       filter(predicate) {
-        return this._clone({
-          predicates: [...this._predicates, predicate]
-        });
+        return this._clone({ predicates: [...this._predicates, predicate] });
       }
-      /**
-       * Sort results by a field (ascending by default).
-       * Use `.reverse()` after `.sortBy()` for descending order.
-       *
-       * @example
-       * ```ts
-       * const newest = Orders.sortBy(o => o.createdAt).reverse();
-       * ```
-       */
       sortBy(accessor) {
         return this._clone({ sortAccessor: accessor });
       }
-      /**
-       * Reverse the current sort order. If no sort is set, this has no effect.
-       */
       reverse() {
         return this._clone({ reversed: !this._reversed });
       }
-      /**
-       * Limit the number of results returned.
-       *
-       * @example
-       * ```ts
-       * const top10 = Orders.sortBy(o => o.amount).reverse().take(10);
-       * ```
-       */
       take(n) {
         return this._clone({ limit: n });
       }
-      /**
-       * Skip the first n results. Use with `.take()` for pagination.
-       *
-       * @example
-       * ```ts
-       * const page2 = Orders.sortBy(o => o.createdAt).skip(50).take(50);
-       * ```
-       */
       skip(n) {
         return this._clone({ offset: n });
       }
       // -------------------------------------------------------------------------
-      // Terminal methods — execute the query and return results
+      // Terminal methods
       // -------------------------------------------------------------------------
-      /**
-       * Return the first matching row, or null if no rows match.
-       * Applies the current sort order before taking the first result.
-       */
       async first() {
         const rows = await this._clone({ limit: 1 })._execute();
         return rows[0] ?? null;
       }
-      /**
-       * Return the last matching row (per current sort), or null.
-       * Flips the sort direction and takes 1 row.
-       */
       async last() {
         const rows = await this._clone({ limit: 1, reversed: !this._reversed })._execute();
         return rows[0] ?? null;
       }
-      /**
-       * Count matching rows. Returns a number, not the rows themselves.
-       * Executes as `SELECT COUNT(*)` when predicates compile to SQL.
-       */
       async count() {
         const compiled = this._compilePredicates();
         if (compiled.allSql) {
-          const where = compiled.sqlWhere || void 0;
-          const sql = buildCount(this._config.tableName, where);
-          const result = await this._config.executeQuery(sql);
-          const row = result.rows[0];
+          const query = buildCount(
+            this._config.tableName,
+            compiled.sqlWhere || void 0
+          );
+          const results = await this._config.executeBatch([query]);
+          const row = results[0]?.rows[0];
           return row?.count ?? 0;
         }
         const rows = await this._fetchAndFilterInJs(compiled);
         return rows.length;
       }
-      /**
-       * Check if any row matches the current filters. Short-circuits —
-       * doesn't load all rows when using SQL.
-       */
       async some() {
         const compiled = this._compilePredicates();
         if (compiled.allSql) {
-          const where = compiled.sqlWhere || void 0;
-          const sql = buildExists(this._config.tableName, where);
-          const result = await this._config.executeQuery(sql);
-          const row = result.rows[0];
+          const query = buildExists(
+            this._config.tableName,
+            compiled.sqlWhere || void 0
+          );
+          const results = await this._config.executeBatch([query]);
+          const row = results[0]?.rows[0];
           return row?.result === 1;
         }
         const rows = await this._fetchAndFilterInJs(compiled);
         return rows.length > 0;
       }
-      /**
-       * Check if all rows match the current filters. Short-circuits on false.
-       *
-       * Implemented as NOT EXISTS(... WHERE NOT predicate) — returns true
-       * if no rows fail the predicate.
-       */
       async every() {
         const compiled = this._compilePredicates();
         if (compiled.allSql && compiled.sqlWhere) {
-          const sql = buildExists(this._config.tableName, `NOT (${compiled.sqlWhere})`, true);
-          const result = await this._config.executeQuery(sql);
-          const row = result.rows[0];
+          const query = buildExists(
+            this._config.tableName,
+            `NOT (${compiled.sqlWhere})`,
+            void 0,
+            true
+          );
+          const results = await this._config.executeBatch([query]);
+          const row = results[0]?.rows[0];
           return row?.result === 1;
         }
         if (this._predicates.length === 0) return true;
@@ -2188,24 +2148,12 @@ var init_query = __esm({
           (row) => this._predicates.every((pred) => pred(row))
         );
       }
-      /**
-       * Return the row with the minimum value for the given field.
-       * Executes as `ORDER BY field ASC LIMIT 1` in SQL.
-       */
       async min(accessor) {
         return this.sortBy(accessor).first();
       }
-      /**
-       * Return the row with the maximum value for the given field.
-       * Executes as `ORDER BY field DESC LIMIT 1` in SQL.
-       */
       async max(accessor) {
         return this.sortBy(accessor).reverse().first();
       }
-      /**
-       * Group rows by a field value. Returns a Map.
-       * Always executes in JS (no SQL equivalent for grouping into a Map).
-       */
       async groupBy(accessor) {
         const rows = await this._execute();
         const map = /* @__PURE__ */ new Map();
@@ -2221,40 +2169,27 @@ var init_query = __esm({
         return map;
       }
       // -------------------------------------------------------------------------
-      // PromiseLike implementation — makes `await query` work
+      // PromiseLike
       // -------------------------------------------------------------------------
-      /**
-       * PromiseLike.then() — executes the query and pipes the result.
-       * This is what makes `const rows = await query` work.
-       */
       then(onfulfilled, onrejected) {
         return this._execute().then(onfulfilled, onrejected);
       }
       // -------------------------------------------------------------------------
       // Execution internals
       // -------------------------------------------------------------------------
-      /**
-       * Execute the query and return typed result rows.
-       *
-       * This is the core execution method. It:
-       * 1. Tries to compile all predicates to SQL
-       * 2. If all compile → builds and executes a single SQL query
-       * 3. If any fail → fetches all rows and processes in JS
-       * 4. Deserializes rows (user prefix stripping, JSON parsing)
-       */
       async _execute() {
         const compiled = this._compilePredicates();
         if (compiled.allSql) {
           const sortField = this._sortAccessor ? extractFieldName(this._sortAccessor) : void 0;
-          const sql = buildSelect(this._config.tableName, {
+          const query = buildSelect(this._config.tableName, {
             where: compiled.sqlWhere || void 0,
             orderBy: sortField ?? void 0,
             desc: this._reversed,
             limit: this._limit,
             offset: this._offset
           });
-          const result = await this._config.executeQuery(sql);
-          return result.rows.map(
+          const results = await this._config.executeBatch([query]);
+          return results[0].rows.map(
             (row) => deserializeRow(
               row,
               this._config.columns
@@ -2279,14 +2214,6 @@ var init_query = __esm({
         }
         return rows;
       }
-      /**
-       * Compile all accumulated predicates and determine the execution strategy.
-       *
-       * Returns an object with:
-       * - `allSql`: whether all predicates compiled to SQL
-       * - `sqlWhere`: combined WHERE clause (ANDed) if all compiled
-       * - `compiled`: individual compilation results
-       */
       _compilePredicates() {
         if (this._predicates.length === 0) {
           return { allSql: true, sqlWhere: "", compiled: [] };
@@ -2299,12 +2226,6 @@ var init_query = __esm({
         }
         return { allSql, sqlWhere, compiled };
       }
-      /**
-       * Fetch all rows from the table and apply JS predicates.
-       * This is the fallback path when SQL compilation fails.
-       *
-       * Logs a warning to stderr so developers know they're on the slow path.
-       */
       async _fetchAndFilterInJs(compiled) {
         const allRows = await this._fetchAllRows();
         if (compiled.compiled.some((c) => c.type === "js")) {
@@ -2316,14 +2237,10 @@ var init_query = __esm({
           (row) => this._predicates.every((pred) => pred(row))
         );
       }
-      /**
-       * Fetch all rows from the table (SELECT * with no WHERE).
-       * Used by the JS fallback path.
-       */
       async _fetchAllRows() {
-        const sql = buildSelect(this._config.tableName);
-        const result = await this._config.executeQuery(sql);
-        return result.rows.map(
+        const query = buildSelect(this._config.tableName);
+        const results = await this._config.executeBatch([query]);
+        return results[0].rows.map(
           (row) => deserializeRow(row, this._config.columns)
         );
       }
@@ -2340,300 +2257,149 @@ var init_table = __esm({
     init_predicate();
     init_sql();
     Table = class {
-      /** @internal Runtime config binding this table to the execution layer. */
+      /** @internal */
       _config;
       constructor(config) {
         this._config = config;
       }
       // -------------------------------------------------------------------------
-      // Reads — direct (return Promises)
+      // Reads — direct
       // -------------------------------------------------------------------------
-      /**
-       * Get a single row by ID. Returns null if not found.
-       *
-       * @example
-       * ```ts
-       * const order = await Orders.get('abc-123');
-       * if (order) console.log(order.status);
-       * ```
-       */
       async get(id) {
-        const sql = buildSelect(this._config.tableName, {
-          where: `id = ${escapeValue(id)}`,
+        const query = buildSelect(this._config.tableName, {
+          where: `id = ?`,
+          whereParams: [id],
           limit: 1
         });
-        const result = await this._config.executeQuery(sql);
-        if (result.rows.length === 0) return null;
+        const results = await this._config.executeBatch([query]);
+        if (results[0].rows.length === 0) return null;
         return deserializeRow(
-          result.rows[0],
+          results[0].rows[0],
           this._config.columns
         );
       }
-      /**
-       * Find the first row matching a predicate. Returns null if none match.
-       *
-       * @example
-       * ```ts
-       * const activeOrder = await Orders.findOne(o => o.status === 'active');
-       * ```
-       */
       async findOne(predicate) {
         return this.filter(predicate).first();
       }
-      /**
-       * Count rows, optionally filtered by a predicate.
-       *
-       * @example
-       * ```ts
-       * const total = await Orders.count();
-       * const pending = await Orders.count(o => o.status === 'pending');
-       * ```
-       */
       async count(predicate) {
-        if (predicate) {
-          return this.filter(predicate).count();
-        }
-        const sql = buildCount(this._config.tableName);
-        const result = await this._config.executeQuery(sql);
-        const row = result.rows[0];
+        if (predicate) return this.filter(predicate).count();
+        const query = buildCount(this._config.tableName);
+        const results = await this._config.executeBatch([query]);
+        const row = results[0]?.rows[0];
         return row?.count ?? 0;
       }
-      /**
-       * Check if any row matches a predicate. Short-circuits.
-       *
-       * @example
-       * ```ts
-       * const hasActive = await Orders.some(o => o.status === 'active');
-       * ```
-       */
       async some(predicate) {
         return this.filter(predicate).some();
       }
-      /**
-       * Check if all rows match a predicate.
-       *
-       * @example
-       * ```ts
-       * const allComplete = await Orders.every(o => o.status === 'completed');
-       * ```
-       */
       async every(predicate) {
         return this.filter(predicate).every();
       }
-      /**
-       * Check if the table has zero rows.
-       *
-       * @example
-       * ```ts
-       * if (await Orders.isEmpty()) console.log('No orders yet');
-       * ```
-       */
       async isEmpty() {
-        const sql = buildExists(this._config.tableName, void 0, true);
-        const result = await this._config.executeQuery(sql);
-        const row = result.rows[0];
+        const query = buildExists(this._config.tableName, void 0, void 0, true);
+        const results = await this._config.executeBatch([query]);
+        const row = results[0]?.rows[0];
         return row?.result === 1;
       }
-      /**
-       * Return the row with the minimum value for a field.
-       * Executes as `ORDER BY field ASC LIMIT 1`.
-       *
-       * @example
-       * ```ts
-       * const cheapest = await Orders.min(o => o.amount);
-       * ```
-       */
       async min(accessor) {
         return this.sortBy(accessor).first();
       }
-      /**
-       * Return the row with the maximum value for a field.
-       * Executes as `ORDER BY field DESC LIMIT 1`.
-       *
-       * @example
-       * ```ts
-       * const mostExpensive = await Orders.max(o => o.amount);
-       * ```
-       */
       async max(accessor) {
         return this.sortBy(accessor).reverse().first();
       }
-      /**
-       * Group all rows by a field value. Returns a Map.
-       *
-       * @example
-       * ```ts
-       * const byStatus = await Orders.groupBy(o => o.status);
-       * // Map { 'pending' => [...], 'approved' => [...] }
-       * ```
-       */
       async groupBy(accessor) {
         return new Query(this._config).groupBy(accessor);
       }
       // -------------------------------------------------------------------------
-      // Reads — chainable (return Query<T>)
+      // Reads — chainable
       // -------------------------------------------------------------------------
-      /**
-       * Filter rows by a predicate. Returns a chainable Query.
-       *
-       * The predicate is compiled to SQL when possible. If compilation fails,
-       * the query falls back to fetching all rows and filtering in JS.
-       *
-       * @example
-       * ```ts
-       * const active = await Orders.filter(o => o.status === 'active');
-       * const recentActive = await Orders
-       *   .filter(o => o.status === 'active')
-       *   .sortBy(o => o.createdAt)
-       *   .reverse()
-       *   .take(10);
-       * ```
-       */
       filter(predicate) {
         return new Query(this._config).filter(predicate);
       }
-      /**
-       * Sort all rows by a field. Returns a chainable Query.
-       *
-       * @example
-       * ```ts
-       * const newest = await Orders.sortBy(o => o.createdAt).reverse().take(5);
-       * ```
-       */
       sortBy(accessor) {
         return new Query(this._config).sortBy(accessor);
       }
       async push(data) {
         const isArray = Array.isArray(data);
         const items = isArray ? data : [data];
-        const results = [];
-        for (const item of items) {
-          const insertSql = buildInsert(
+        const queries = items.map(
+          (item) => buildInsert(
             this._config.tableName,
             item,
             this._config.columns
-          );
-          await this._config.executeQuery(insertSql);
-          const fetchSql = `SELECT * FROM ${this._config.tableName} WHERE rowid = last_insert_rowid()`;
-          const fetchResult = await this._config.executeQuery(fetchSql);
-          if (fetchResult.rows.length > 0) {
-            results.push(
-              deserializeRow(
-                fetchResult.rows[0],
-                this._config.columns
-              )
+          )
+        );
+        const results = await this._config.executeBatch(queries);
+        const rows = results.map((r) => {
+          if (r.rows.length > 0) {
+            return deserializeRow(
+              r.rows[0],
+              this._config.columns
             );
           }
-        }
-        return isArray ? results : results[0];
+          return void 0;
+        });
+        return isArray ? rows : rows[0];
       }
       /**
        * Update a row by ID. Only the provided fields are changed.
-       * Returns the updated row.
-       *
-       * System columns cannot be updated — they're stripped automatically.
-       * `updatedAt` and `lastUpdatedBy` are set by the platform.
-       *
-       * @example
-       * ```ts
-       * const updated = await Orders.update(order.id, { status: 'approved' });
-       * console.log(updated.updatedAt); // freshly updated
-       * ```
+       * Returns the updated row via `UPDATE ... RETURNING *`.
        */
       async update(id, data) {
-        const updateSql = buildUpdate(
+        const query = buildUpdate(
           this._config.tableName,
           id,
           data,
           this._config.columns
         );
-        await this._config.executeQuery(updateSql);
-        const fetchSql = buildSelect(this._config.tableName, {
-          where: `id = ${escapeValue(id)}`,
-          limit: 1
-        });
-        const result = await this._config.executeQuery(fetchSql);
+        const results = await this._config.executeBatch([query]);
         return deserializeRow(
-          result.rows[0],
+          results[0].rows[0],
           this._config.columns
         );
       }
-      /**
-       * Remove a row by ID.
-       *
-       * @example
-       * ```ts
-       * await Orders.remove('abc-123');
-       * ```
-       */
       async remove(id) {
-        const sql = buildDelete(
-          this._config.tableName,
-          `id = ${escapeValue(id)}`
-        );
-        await this._config.executeQuery(sql);
+        const query = buildDelete(this._config.tableName, `id = ?`, [id]);
+        await this._config.executeBatch([query]);
       }
       /**
        * Remove all rows matching a predicate. Returns the count removed.
-       *
-       * The predicate is compiled to SQL when possible. If compilation fails,
-       * the function fetches all matching rows, collects their IDs, and
-       * deletes them individually.
-       *
-       * @example
-       * ```ts
-       * const removed = await Orders.removeAll(o => o.status === 'rejected');
-       * console.log(`Removed ${removed} orders`);
-       * ```
        */
       async removeAll(predicate) {
         const compiled = compilePredicate(predicate);
         if (compiled.type === "sql") {
-          const sql = buildDelete(this._config.tableName, compiled.where);
-          const result = await this._config.executeQuery(sql);
-          return result.changes;
+          const query = buildDelete(this._config.tableName, compiled.where);
+          const results = await this._config.executeBatch([query]);
+          return results[0].changes;
         }
         console.warn(
           `[mindstudio] removeAll predicate on ${this._config.tableName} could not be compiled to SQL \u2014 fetching all rows first`
         );
-        const allSql = buildSelect(this._config.tableName);
-        const allResult = await this._config.executeQuery(allSql);
-        const allRows = allResult.rows.map(
+        const allQuery = buildSelect(this._config.tableName);
+        const allResults = await this._config.executeBatch([allQuery]);
+        const allRows = allResults[0].rows.map(
           (r) => deserializeRow(
             r,
             this._config.columns
           )
         );
         const matching = allRows.filter((row) => predicate(row));
-        let count = 0;
-        for (const row of matching) {
-          const id = row.id;
-          if (id) {
-            const sql = buildDelete(this._config.tableName, `id = ${escapeValue(id)}`);
-            await this._config.executeQuery(sql);
-            count++;
-          }
+        if (matching.length === 0) return 0;
+        const deleteQueries = matching.filter((row) => row.id).map((row) => buildDelete(this._config.tableName, `id = ?`, [row.id]));
+        if (deleteQueries.length > 0) {
+          await this._config.executeBatch(deleteQueries);
         }
-        return count;
+        return matching.length;
       }
-      /**
-       * Remove all rows from the table.
-       *
-       * @example
-       * ```ts
-       * await Orders.clear();
-       * ```
-       */
       async clear() {
-        const sql = buildDelete(this._config.tableName);
-        await this._config.executeQuery(sql);
+        const query = buildDelete(this._config.tableName);
+        await this._config.executeBatch([query]);
       }
     };
   }
 });
 
 // src/db/index.ts
-function createDb(databases, executeQuery) {
+function createDb(databases, executeBatch) {
   return {
     defineTable(name, options) {
       const resolved = resolveTable(databases, name, options?.database);
@@ -2641,7 +2407,7 @@ function createDb(databases, executeQuery) {
         databaseId: resolved.databaseId,
         tableName: name,
         columns: resolved.columns,
-        executeQuery: (sql) => executeQuery(resolved.databaseId, sql)
+        executeBatch: (queries) => executeBatch(resolved.databaseId, queries)
       };
       return new Table(config);
     },
@@ -3612,6 +3378,9 @@ var init_client = __esm({
        * ```
        */
       get auth() {
+        if (!this._auth) {
+          this._trySandboxHydration();
+        }
         if (!this._auth) {
           throw new MindStudioError(
             "Auth context not yet loaded. Call `await agent.ensureContext()` or perform any db operation first (which auto-hydrates context). Inside the MindStudio sandbox, context is loaded automatically.",
@@ -3637,6 +3406,9 @@ var init_client = __esm({
        * ```
        */
       get db() {
+        if (!this._db) {
+          this._trySandboxHydration();
+        }
         if (this._db) return this._db;
         return this._createLazyDb();
       }
@@ -3694,7 +3466,7 @@ var init_client = __esm({
         this._auth = new AuthContext(context.auth);
         this._db = createDb(
           context.databases,
-          this._executeDbQuery.bind(this)
+          this._executeDbBatch.bind(this)
         );
       }
       /**
@@ -3715,25 +3487,40 @@ var init_client = __esm({
         }
       }
       /**
-       * @internal Execute a SQL query against a managed database.
-       * Used as the `executeQuery` callback for Table instances.
+       * @internal Execute a batch of SQL queries against a managed database.
+       * Used as the `executeBatch` callback for Table/Query instances.
        *
-       * Calls the `queryAppDatabase` step with `parameterize: false`
-       * (the SDK builds fully-formed SQL with escaped inline values).
+       * Calls `POST /_internal/v2/db/query` directly with the hook token
+       * (raw, no Bearer prefix). All queries run on a single SQLite connection,
+       * enabling RETURNING clauses and multi-statement batches.
        */
-      async _executeDbQuery(databaseId, sql) {
-        const result = await this.executeStep("queryAppDatabase", {
-          databaseId,
-          sql,
-          parameterize: false
+      async _executeDbBatch(databaseId, queries) {
+        const url = `${this._httpConfig.baseUrl}/_internal/v2/db/query`;
+        const res = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: this._httpConfig.token
+          },
+          body: JSON.stringify({ databaseId, queries })
         });
-        return { rows: result.rows ?? [], changes: result.changes ?? 0 };
+        if (!res.ok) {
+          let message = `Database query failed: ${res.status} ${res.statusText}`;
+          try {
+            const body = await res.json();
+            if (body.error) message = body.error;
+          } catch {
+          }
+          throw new MindStudioError(message, "db_query_error", res.status);
+        }
+        const data = await res.json();
+        return data.results;
       }
       /**
        * @internal Create a lazy Db proxy that auto-hydrates context.
        *
        * defineTable() returns Table instances immediately (no async needed).
-       * But the Table's executeQuery callback is wrapped to call ensureContext()
+       * But the Table's executeBatch callback is wrapped to call ensureContext()
        * before the first query, so context is fetched lazily.
        */
       _createLazyDb() {
@@ -3745,7 +3532,7 @@ var init_client = __esm({
               databaseId: "",
               tableName: name,
               columns: [],
-              executeQuery: async (sql) => {
+              executeBatch: async (queries) => {
                 await agent.ensureContext();
                 const databases = agent._context.databases;
                 let targetDb;
@@ -3759,7 +3546,7 @@ var init_client = __esm({
                   );
                 }
                 const databaseId = targetDb?.id ?? databases[0]?.id ?? "";
-                return agent._executeDbQuery(databaseId, sql);
+                return agent._executeDbBatch(databaseId, queries);
               }
             });
           },
@@ -3974,7 +3761,7 @@ async function startMcpServer(options) {
           capabilities: { tools: {} },
           serverInfo: {
             name: "mindstudio-agent",
-            version: "0.1.9"
+            version: "0.1.10"
           },
           instructions: "Welcome to MindStudio \u2014 a platform with 200+ AI models, 850+ third-party integrations, and pre-built agents.\n\nGetting started:\n1. Call `listAgents` to verify your connection and see available agents.\n2. Call `changeName` to set your display name \u2014 use your name or whatever your user calls you. This is how you'll appear in MindStudio request logs.\n3. If you have a profile picture or icon, call `uploadFile` to upload it, then `changeProfilePicture` with the returned URL. This helps users identify your requests in their logs.\n4. Call `listActions` to discover all available actions.\n\nThen use the tools to generate text, images, video, audio, search the web, work with data sources, run agents, and more.\n\nImportant:\n- AI-powered actions (text generation, image generation, video, audio, etc.) cost money. Before running these, call `estimateActionCost` and confirm with the user before proceeding \u2014 unless they've explicitly told you to go ahead.\n- Not all agents from `listAgents` are configured for API use. Do not try to run an agent just because it appears in the list \u2014 it will likely fail. Only run agents the user specifically asks you to run."
         });
@@ -4794,7 +4581,7 @@ function isNewerVersion(current, latest) {
   return false;
 }
 async function checkForUpdate() {
-  const currentVersion = "0.1.9";
+  const currentVersion = "0.1.10";
   if (!currentVersion) return null;
   try {
     const { loadConfig: loadConfig2, saveConfig: saveConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -4823,7 +4610,7 @@ async function checkForUpdate() {
   }
 }
 function printUpdateNotice(latestVersion) {
-  const currentVersion = "0.1.9";
+  const currentVersion = "0.1.10";
   process.stderr.write(
     `
   ${ansi.cyanBright("Update available")} ${ansi.gray(currentVersion + " \u2192")} ${ansi.cyanBold(latestVersion)}
@@ -4878,7 +4665,7 @@ async function cmdLogin(options) {
   process.stderr.write("\n");
   printLogo();
   process.stderr.write("\n");
-  const ver = "0.1.9";
+  const ver = "0.1.10";
   process.stderr.write(
     `  ${ansi.bold("MindStudio Agent")} ${ver ? " " + ansi.gray("v" + ver) : ""}
 `
@@ -4961,6 +4748,9 @@ async function cmdLogin(options) {
         `  ${ansi.greenBold("\u2714")} Authenticated successfully!
   ${ansi.gray("Credentials saved to")} ${getConfigPath2()}
 
+  ${ansi.bold("Using with Claude Code?")} Run once to enable the MCP server:
+  ${ansi.cyan("claude mcp add mindstudio -- mindstudio mcp")}
+
 `
       );
       return;