@mindstudio-ai/agent 0.1.10 → 0.1.12

package/dist/cli.js

@@ -1523,7 +1523,15 @@ var init_sql = __esm({
   "src/db/sql.ts"() {
     "use strict";
     USER_PREFIX = "@@user@@";
-    SYSTEM_COLUMNS = /* @__PURE__ */ new Set(["id", "createdAt", "updatedAt", "lastUpdatedBy"]);
+    SYSTEM_COLUMNS = /* @__PURE__ */ new Set([
+      "id",
+      "created_at",
+      "createdAt",
+      "updated_at",
+      "updatedAt",
+      "last_updated_by",
+      "lastUpdatedBy"
+    ]);
   }
 });
 
@@ -1968,8 +1976,7 @@ var init_predicate = __esm({
         return PARSE_FAILED;
       }
       /**
-       * Attempt to resolve a closure variable by invoking the original function
-       * with a recording Proxy and inspecting what values it compares against.
+       * Attempt to resolve a closure variable's value.
        *
        * This handles the common pattern:
        * ```ts
@@ -1977,40 +1984,28 @@ var init_predicate = __esm({
        * orders.filter(o => o.requestedBy === userId)
        * ```
        *
-       * The Proxy captures property accesses on the parameter and we can then
-       * extract the comparison value from the function's behavior. However,
-       * this approach has limitations — if the function throws, has side effects,
-       * or uses the variable in a non-comparison context, we fall back to JS.
+       * Closure variable resolution is fundamentally limited in JavaScript —
+       * we can't access another function's closure scope from outside without
+       * `eval`. The `===` operator can't be overridden via Proxy or
+       * Symbol.toPrimitive, so we can't intercept comparisons.
+       *
+       * For now, this falls back to JS execution. The predicate still works
+       * correctly — it just scans all rows instead of generating SQL.
+       * This is the most common reason for JS fallback in practice, since
+       * almost every real-world filter references a variable like `userId`.
+       *
+       * A future improvement could accept an explicit `vars` argument:
+       * ```ts
+       * orders.filter(o => o.requestedBy === $userId, { $userId: auth.userId })
+       * ```
        */
       resolveClosureVariable() {
-        const identToken = this.advance();
-        let closureExpr = identToken.value;
+        this.advance();
         while (this.match("dot") && this.tokens[this.pos + 1]?.type === "identifier") {
           this.advance();
-          closureExpr += "." + this.advance().value;
-        }
-        try {
-          const MARKER = /* @__PURE__ */ Symbol("field_access_marker");
-          const accessed = [];
-          const proxy = new Proxy(
-            {},
-            {
-              get(_, prop) {
-                accessed.push(prop);
-                return new Proxy(() => MARKER, {
-                  get(_2, nestedProp) {
-                    accessed.push(nestedProp);
-                    return MARKER;
-                  }
-                });
-              }
-            }
-          );
-          void proxy;
-          return PARSE_FAILED;
-        } catch {
-          return PARSE_FAILED;
+          this.advance();
         }
+        return PARSE_FAILED;
       }
       /**
        * Look ahead to check if the next tokens form `.includes(`.
@@ -2169,6 +2164,76 @@ var init_query = __esm({
         return map;
       }
       // -------------------------------------------------------------------------
+      // Batch compilation — used by db.batch() to extract SQL without executing
+      // -------------------------------------------------------------------------
+      /**
+       * @internal Compile this query into a SqlQuery for batch execution.
+       *
+       * Returns the compiled SQL query (if all predicates compile to SQL),
+       * or null (if JS fallback is needed). In the fallback case, a bare
+       * `SELECT *` is returned as `fallbackQuery` so the batch can fetch
+       * all rows and this query can filter them in JS post-fetch.
+       */
+      _compile() {
+        const compiled = this._compilePredicates();
+        const sortField = this._sortAccessor ? extractFieldName(this._sortAccessor) : void 0;
+        if (compiled.allSql) {
+          const query = buildSelect(this._config.tableName, {
+            where: compiled.sqlWhere || void 0,
+            orderBy: sortField ?? void 0,
+            desc: this._reversed,
+            limit: this._limit,
+            offset: this._offset
+          });
+          return { query, fallbackQuery: null, config: this._config };
+        }
+        const fallbackQuery = buildSelect(this._config.tableName);
+        return {
+          query: null,
+          fallbackQuery,
+          config: this._config,
+          predicates: this._predicates,
+          sortAccessor: this._sortAccessor,
+          reversed: this._reversed,
+          limit: this._limit,
+          offset: this._offset
+        };
+      }
+      /**
+       * @internal Process raw SQL results into typed rows. Used by db.batch()
+       * after executing the compiled query.
+       *
+       * For SQL-compiled queries: just deserialize the rows.
+       * For JS-fallback queries: filter, sort, and slice in JS.
+       */
+      static _processResults(result, compiled) {
+        const rows = result.rows.map(
+          (row) => deserializeRow(
+            row,
+            compiled.config.columns
+          )
+        );
+        if (compiled.query) return rows;
+        let filtered = compiled.predicates ? rows.filter((row) => compiled.predicates.every((pred) => pred(row))) : rows;
+        if (compiled.sortAccessor) {
+          const accessor = compiled.sortAccessor;
+          const reversed = compiled.reversed ?? false;
+          filtered.sort((a, b) => {
+            const aVal = accessor(a);
+            const bVal = accessor(b);
+            if (aVal < bVal) return reversed ? 1 : -1;
+            if (aVal > bVal) return reversed ? -1 : 1;
+            return 0;
+          });
+        }
+        if (compiled.offset != null || compiled.limit != null) {
+          const start = compiled.offset ?? 0;
+          const end = compiled.limit != null ? start + compiled.limit : void 0;
+          filtered = filtered.slice(start, end);
+        }
+        return filtered;
+      }
+      // -------------------------------------------------------------------------
       // PromiseLike
       // -------------------------------------------------------------------------
       then(onfulfilled, onrejected) {
@@ -2418,7 +2483,49 @@ function createDb(databases, executeBatch) {
     hours: (n) => n * 36e5,
     minutes: (n) => n * 6e4,
     ago: (ms) => Date.now() - ms,
-    fromNow: (ms) => Date.now() + ms
+    fromNow: (ms) => Date.now() + ms,
+    // --- Batch execution ---
+    batch: ((...queries) => {
+      return (async () => {
+        const compiled = queries.map((q) => {
+          if (!(q instanceof Query)) {
+            throw new MindStudioError(
+              "db.batch() only accepts Query objects (from .filter(), .sortBy(), etc.)",
+              "invalid_batch_query",
+              400
+            );
+          }
+          return q._compile();
+        });
+        const groups = /* @__PURE__ */ new Map();
+        for (let i = 0; i < compiled.length; i++) {
+          const c = compiled[i];
+          const dbId = c.config.databaseId;
+          const sqlQuery = c.query ?? c.fallbackQuery;
+          if (!groups.has(dbId)) groups.set(dbId, []);
+          groups.get(dbId).push({ index: i, sqlQuery });
+        }
+        const allResults = new Array(compiled.length);
+        await Promise.all(
+          Array.from(groups.entries()).map(async ([dbId, entries]) => {
+            const sqlQueries = entries.map((e) => e.sqlQuery);
+            const results = await executeBatch(dbId, sqlQueries);
+            for (let i = 0; i < entries.length; i++) {
+              allResults[entries[i].index] = results[i];
+            }
+          })
+        );
+        return compiled.map((c, i) => {
+          const result = allResults[i];
+          if (!c.query && c.predicates?.length) {
+            console.warn(
+              `[mindstudio] db.batch(): filter on ${c.config.tableName} could not be compiled to SQL \u2014 processing in JS`
+            );
+          }
+          return Query._processResults(result, c);
+        });
+      })();
+    })
   };
 }
 function resolveTable(databases, tableName, databaseHint) {
@@ -2473,6 +2580,7 @@ var init_db = __esm({
     "use strict";
     init_errors();
     init_table();
+    init_query();
     init_table();
   }
 });
@@ -3238,10 +3346,12 @@ var init_client = __esm({
             );
           }
           if (!res.ok) {
+            const errorBody = await res.json().catch(() => ({}));
             throw new MindStudioError(
-              `Poll request failed: ${res.status} ${res.statusText}`,
-              "poll_error",
-              res.status
+              errorBody.message ?? errorBody.error ?? `Poll request failed: ${res.status} ${res.statusText}`,
+              errorBody.code ?? "poll_error",
+              res.status,
+              errorBody
             );
           }
           const poll = await res.json();
@@ -3506,12 +3616,24 @@ var init_client = __esm({
         });
         if (!res.ok) {
           let message = `Database query failed: ${res.status} ${res.statusText}`;
+          let code = "db_query_error";
           try {
-            const body = await res.json();
-            if (body.error) message = body.error;
+            const text = await res.text();
+            try {
+              const body = JSON.parse(text);
+              const errMsg = body.error ?? body.message ?? body.details;
+              if (errMsg) message = errMsg;
+              if (body.code) code = body.code;
+            } catch {
+              if (text && text.length < 500) message = text;
+            }
           } catch {
           }
-          throw new MindStudioError(message, "db_query_error", res.status);
+          throw new MindStudioError(
+            `[db] ${message}`,
+            code,
+            res.status
+          );
         }
         const data = await res.json();
         return data.results;
@@ -3556,7 +3678,14 @@ var init_client = __esm({
           hours: (n) => n * 36e5,
           minutes: (n) => n * 6e4,
           ago: (ms) => Date.now() - ms,
-          fromNow: (ms) => Date.now() + ms
+          fromNow: (ms) => Date.now() + ms,
+          // Batch needs context — hydrate first, then delegate to real db
+          batch: ((...queries) => {
+            return (async () => {
+              await agent.ensureContext();
+              return agent._db.batch(...queries);
+            })();
+          })
         };
       }
       // -------------------------------------------------------------------------
@@ -3688,10 +3817,12 @@ var init_client = __esm({
           headers: options.type ? { "Content-Type": options.type } : {}
         });
         if (!res.ok) {
+          const errorBody = await res.json().catch(() => ({}));
           throw new MindStudioError(
-            `Upload failed: ${res.status} ${res.statusText}`,
-            "upload_error",
-            res.status
+            errorBody.message ?? errorBody.error ?? `Upload failed: ${res.status} ${res.statusText}`,
+            errorBody.code ?? "upload_error",
+            res.status,
+            errorBody
           );
         }
         return { url: data.url };
@@ -3761,7 +3892,7 @@ async function startMcpServer(options) {
           capabilities: { tools: {} },
           serverInfo: {
             name: "mindstudio-agent",
-            version: "0.1.10"
+            version: "0.1.12"
           },
           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."
         });
@@ -4669,7 +4800,7 @@ function isNewerVersion(current, latest) {
   return false;
 }
 async function checkForUpdate() {
-  const currentVersion = "0.1.10";
+  const currentVersion = "0.1.12";
   if (!currentVersion) return null;
   try {
     const { loadConfig: loadConfig2, saveConfig: saveConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -4698,7 +4829,7 @@ async function checkForUpdate() {
   }
 }
 function printUpdateNotice(latestVersion) {
-  const currentVersion = "0.1.10";
+  const currentVersion = "0.1.12";
   process.stderr.write(
     `
   ${ansi.cyanBright("Update available")} ${ansi.gray(currentVersion + " \u2192")} ${ansi.cyanBold(latestVersion)}
@@ -4773,7 +4904,7 @@ async function cmdLogin(options) {
   process.stderr.write("\n");
   printLogo();
   process.stderr.write("\n");
-  const ver = "0.1.10";
+  const ver = "0.1.12";
   process.stderr.write(
     `  ${ansi.bold("MindStudio Agent")} ${ver ? " " + ansi.gray("v" + ver) : ""}
 `

package/dist/index.d.ts

@@ -156,9 +156,7 @@ interface UserInfoResult {
  * }
  * ```
  */
-type User = string & {
-    readonly __brand: 'User';
-};
+type User = string;
 /**
  * Resolved display info for a platform user. Returned by `resolveUser()`
  * and `resolveUsers()`.
@@ -537,11 +535,14 @@ declare const Roles: Record<string, string>;
  * Names of columns that the platform manages automatically.
  *
  * - `id`: UUID primary key, generated on INSERT
- * - `createdAt`: unix timestamp (ms), set on INSERT
- * - `updatedAt`: unix timestamp (ms), set on INSERT and every UPDATE
- * - `lastUpdatedBy`: reference to the run ID that last wrote this row
+ * - `created_at`: unix timestamp (ms), set on INSERT
+ * - `updated_at`: unix timestamp (ms), set on INSERT and every UPDATE
+ * - `last_updated_by`: reference to the run ID that last wrote this row
+ *
+ * Both snake_case (platform convention) and camelCase (legacy) are
+ * stripped to support either naming convention in table interfaces.
  */
-type SystemFields = 'id' | 'createdAt' | 'updatedAt' | 'lastUpdatedBy';
+type SystemFields = 'id' | 'created_at' | 'createdAt' | 'updated_at' | 'updatedAt' | 'last_updated_by' | 'lastUpdatedBy';
 /**
  * Input type for `Table.push()`. Excludes system-managed fields.
  * Optional fields in T remain optional.
@@ -682,12 +683,51 @@ declare class Query<T> implements PromiseLike<T[]> {
     min(accessor: Accessor<T, number>): Promise<T | null>;
     max(accessor: Accessor<T, number>): Promise<T | null>;
     groupBy<K extends string | number>(accessor: Accessor<T, K>): Promise<Map<K, T[]>>;
+    /**
+     * @internal Compile this query into a SqlQuery for batch execution.
+     *
+     * Returns the compiled SQL query (if all predicates compile to SQL),
+     * or null (if JS fallback is needed). In the fallback case, a bare
+     * `SELECT *` is returned as `fallbackQuery` so the batch can fetch
+     * all rows and this query can filter them in JS post-fetch.
+     */
+    _compile(): CompiledQuery<T>;
+    /**
+     * @internal Process raw SQL results into typed rows. Used by db.batch()
+     * after executing the compiled query.
+     *
+     * For SQL-compiled queries: just deserialize the rows.
+     * For JS-fallback queries: filter, sort, and slice in JS.
+     */
+    static _processResults<T>(result: SqlResult, compiled: CompiledQuery<T>): T[];
     then<TResult1 = T[], TResult2 = never>(onfulfilled?: ((value: T[]) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
     private _execute;
     private _compilePredicates;
     private _fetchAndFilterInJs;
     private _fetchAllRows;
 }
+/**
+ * Result of Query._compile(). Contains either a compiled SQL query
+ * (fast path) or a fallback SELECT * with JS processing metadata.
+ */
+interface CompiledQuery<T> {
+    /** Compiled SQL query, or null if JS fallback needed. */
+    query: SqlQuery | null;
+    /** SELECT * fallback query, or null if SQL compiled. */
+    fallbackQuery: SqlQuery | null;
+    /** Table config for deserialization. */
+    config: TableConfig;
+    /** JS predicates (only for fallback). */
+    predicates?: Predicate<T>[];
+    /** Sort accessor (only for fallback). */
+    sortAccessor?: Accessor<T>;
+    /** Sort direction (only for fallback). */
+    reversed?: boolean;
+    /** Limit (only for fallback). */
+    limit?: number;
+    /** Offset (only for fallback). */
+    offset?: number;
+}
 
 /**
  * Table<T> — a typed persistent collection backed by SQLite.
@@ -848,6 +888,28 @@ interface Db {
     ago(ms: number): number;
     /** Returns a unix timestamp for (now + duration). Use with days/hours/minutes. */
     fromNow(ms: number): number;
+    /**
+     * Execute multiple queries in a single round trip. All queries run on
+     * the same database connection, eliminating per-query HTTP overhead.
+     *
+     * Accepts Query objects (lazy, not yet executed). Compiles them to SQL,
+     * sends all in one batch request, and returns typed results.
+     *
+     * @example
+     * ```ts
+     * const [orders, approvals, vendors] = await db.batch(
+     *   Orders.filter(o => o.status === 'active').take(10),
+     *   Approvals.filter(a => a.status === 'pending').take(25),
+     *   Vendors.sortBy(v => v.createdAt).reverse().take(5),
+     * );
+     * ```
+     */
+    batch<A>(q1: PromiseLike<A>): Promise<[A]>;
+    batch<A, B>(q1: PromiseLike<A>, q2: PromiseLike<B>): Promise<[A, B]>;
+    batch<A, B, C>(q1: PromiseLike<A>, q2: PromiseLike<B>, q3: PromiseLike<C>): Promise<[A, B, C]>;
+    batch<A, B, C, D>(q1: PromiseLike<A>, q2: PromiseLike<B>, q3: PromiseLike<C>, q4: PromiseLike<D>): Promise<[A, B, C, D]>;
+    batch<A, B, C, D, E>(q1: PromiseLike<A>, q2: PromiseLike<B>, q3: PromiseLike<C>, q4: PromiseLike<D>, q5: PromiseLike<E>): Promise<[A, B, C, D, E]>;
+    batch(...queries: PromiseLike<unknown>[]): Promise<unknown[]>;
 }
 
 /**