@mindstudio-ai/agent 0.1.107 → 0.1.109

package/dist/index.js

@@ -102,9 +102,12 @@ function runWithContext(ctx, fn) {
 }
 
 // src/db-ws.ts
-var WS_REQUEST_TIMEOUT_MS = 3e5;
+var DB_WS_SUBPROTOCOL = "ms-db-v2";
+var WS_ACK_TIMEOUT_MS = 2e4;
+var WS_IDLE_TIMEOUT_MS = 3e5;
 var WS_OPEN_TIMEOUT_MS = 5e3;
 var WS_OPEN = 1;
+var WS_CHUNK_CHARS = 256 * 1024;
 var WS_MAX_FRAME_CHARS = 9e5;
 var DbWsTransportError = class extends Error {
   constructor(message, sent = false) {
@@ -117,13 +120,86 @@ function isReadOnlySql(sql) {
   const head = sql.trimStart().slice(0, 8).toUpperCase();
   return head.startsWith("SELECT") || head.startsWith("PRAGMA") || head.startsWith("EXPLAIN");
 }
-var socket = null;
+var conn = null;
 var opening = null;
 var idCounter = 0;
-var pending = /* @__PURE__ */ new Map();
-function getOrOpen(url) {
-  if (socket && socket.readyState === WS_OPEN) {
-    return Promise.resolve(socket);
+function clearPendingTimer(p) {
+  if (p.timer !== null) {
+    clearTimeout(p.timer);
+    p.timer = null;
+  }
+}
+function forget(self, id) {
+  self.pending.delete(id);
+  self.inbound.delete(id);
+  if (self.retired && self.pending.size === 0) {
+    try {
+      self.ws.close();
+    } catch {
+    }
+  }
+}
+function retire(self, reason) {
+  if (self.retired) {
+    return;
+  }
+  self.retired = true;
+  if (conn === self) {
+    conn = null;
+  }
+  try {
+    console.warn(
+      `[mindstudio] db: retiring WebSocket after ${reason}; next query reconnects.`
+    );
+  } catch {
+  }
+  if (self.pending.size === 0) {
+    try {
+      self.ws.close();
+    } catch {
+    }
+  }
+}
+function armIdleTimer(self, id, p) {
+  clearPendingTimer(p);
+  p.timer = setTimeout(() => {
+    forget(self, id);
+    retire(self, "a reply went silent");
+    p.reject(new DbWsTransportError("ws reply went silent", true));
+  }, WS_IDLE_TIMEOUT_MS);
+}
+function deliver(self, msg) {
+  const p = self.pending.get(msg.id);
+  if (!p) {
+    return;
+  }
+  clearPendingTimer(p);
+  forget(self, msg.id);
+  if (msg.error) {
+    p.reject(
+      new MindStudioError(
+        `[db] ${msg.error.message || "Database query failed"}`,
+        msg.error.code || "db_query_error",
+        400,
+        msg.error
+      )
+    );
+  } else {
+    p.resolve(msg.results);
+  }
+}
+function failTransport(self, id, err) {
+  const p = self.pending.get(id);
+  if (!p) {
+    return;
+  }
+  clearPendingTimer(p);
+  forget(self, id);
+  p.reject(err);
+}
+function getOrOpen(url, token) {
+  if (conn && !conn.retired && conn.ws.readyState === WS_OPEN) {
+    return Promise.resolve(conn);
   }
   if (opening) {
     return opening;
@@ -136,17 +212,22 @@ function getOrOpen(url) {
   }
   opening = new Promise((resolve, reject) => {
     let ws;
+    let self = null;
     const fail = (err) => {
       clearTimeout(openTimer);
-      if (socket === ws) {
-        socket = null;
+      if (self) {
+        self.retired = true;
+        if (conn === self) {
+          conn = null;
+        }
+        for (const [, p] of self.pending) {
+          clearPendingTimer(p);
+          p.reject(new DbWsTransportError(err.message, true));
+        }
+        self.pending.clear();
+        self.inbound.clear();
       }
       opening = null;
-      for (const [, p] of pending) {
-        clearTimeout(p.timer);
-        p.reject(new DbWsTransportError(err.message, true));
-      }
-      pending.clear();
       reject(err);
     };
     const openTimer = setTimeout(() => {
@@ -157,16 +238,26 @@ function getOrOpen(url) {
       fail(new DbWsTransportError("ws open timed out"));
     }, WS_OPEN_TIMEOUT_MS);
     try {
-      ws = new WebSocketCtor(url);
+      ws = new WebSocketCtor(url, ["auth", token, DB_WS_SUBPROTOCOL]);
     } catch (err) {
       fail(new DbWsTransportError(err?.message || "ws construct failed"));
       return;
     }
+    self = {
+      ws,
+      pending: /* @__PURE__ */ new Map(),
+      chunked: false,
+      inbound: /* @__PURE__ */ new Map(),
+      acksSeen: false,
+      retired: false
+    };
+    const c = self;
     ws.onopen = () => {
       clearTimeout(openTimer);
-      socket = ws;
+      c.chunked = ws.protocol === DB_WS_SUBPROTOCOL;
+      conn = c;
       opening = null;
-      resolve(ws);
+      resolve(c);
     };
     ws.onmessage = (ev) => {
       let msg;
@@ -177,26 +268,54 @@ function getOrOpen(url) {
       } catch {
         return;
       }
-      if (!msg || msg.t !== "db-result" || msg.id == null) {
+      if (!msg || msg.id == null) {
         return;
       }
-      const p = pending.get(msg.id);
-      if (!p) {
+      if (msg.t === "db-ack") {
+        c.acksSeen = true;
+        const p = c.pending.get(msg.id);
+        if (p && !p.acked) {
+          p.acked = true;
+          armIdleTimer(c, msg.id, p);
+        }
         return;
       }
-      clearTimeout(p.timer);
-      pending.delete(msg.id);
-      if (msg.error) {
-        p.reject(
-          new MindStudioError(
-            `[db] ${msg.error.message || "Database query failed"}`,
-            msg.error.code || "db_query_error",
-            400,
-            msg.error
-          )
-        );
-      } else {
-        p.resolve(msg.results);
+      if (msg.t === "db-chunk") {
+        const p = c.pending.get(msg.id);
+        if (!p || typeof msg.data !== "string") {
+          return;
+        }
+        const parts = c.inbound.get(msg.id);
+        if (parts) {
+          parts.push(msg.data);
+        } else {
+          c.inbound.set(msg.id, [msg.data]);
+        }
+        armIdleTimer(c, msg.id, p);
+        return;
+      }
+      if (msg.t === "db-end") {
+        const parts = c.inbound.get(msg.id);
+        if (!parts) {
+          return;
+        }
+        c.inbound.delete(msg.id);
+        let assembled;
+        try {
+          assembled = JSON.parse(parts.join(""));
+        } catch {
+          failTransport(
+            c,
+            msg.id,
+            new DbWsTransportError("chunked reply did not parse", true)
+          );
+          return;
+        }
+        deliver(c, assembled);
+        return;
+      }
+      if (msg.t === "db-result") {
+        deliver(c, msg);
       }
     };
     ws.onerror = () => fail(new DbWsTransportError("ws error"));
@@ -204,28 +323,59 @@ function getOrOpen(url) {
   });
   return opening;
 }
+function* outboundFrames(id, json) {
+  if (json.length <= WS_CHUNK_CHARS) {
+    yield json;
+    return;
+  }
+  let seq = 0;
+  for (let offset = 0; offset < json.length; offset += WS_CHUNK_CHARS) {
+    yield JSON.stringify({
+      t: "db-chunk",
+      id,
+      seq: seq++,
+      data: json.slice(offset, offset + WS_CHUNK_CHARS)
+    });
+  }
+  yield JSON.stringify({ t: "db-end", id });
+}
 async function executeDbBatchOverWs(url, token, databaseId, queries) {
   const id = ++idCounter;
   const frame = JSON.stringify({ t: "db", id, token, databaseId, queries });
-  if (frame.length > WS_MAX_FRAME_CHARS) {
+  const self = await getOrOpen(url, token);
+  if (!self.chunked && frame.length > WS_MAX_FRAME_CHARS) {
     throw new DbWsTransportError("payload too large for ws");
   }
-  const ws = await getOrOpen(url);
   return await new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      pending.delete(id);
-      reject(new DbWsTransportError("ws execute timed out", true));
-    }, WS_REQUEST_TIMEOUT_MS);
-    pending.set(id, { resolve, reject, timer });
+    const pending = { resolve, reject, timer: null, acked: false };
+    if (self.acksSeen) {
+      pending.timer = setTimeout(() => {
+        forget(self, id);
+        retire(self, "a request went unacknowledged");
+        reject(new DbWsTransportError("ws ack timed out", true));
+      }, WS_ACK_TIMEOUT_MS);
+    } else {
+      armIdleTimer(self, id, pending);
+    }
+    self.pending.set(id, pending);
+    let started = false;
+    let complete = false;
     try {
-      ws.send(frame);
+      for (const out of outboundFrames(id, frame)) {
+        self.ws.send(out);
+        started = true;
+      }
+      complete = true;
     } catch (err) {
-      clearTimeout(timer);
-      pending.delete(id);
+      clearPendingTimer(pending);
+      forget(self, id);
+      if (started) {
+        retire(self, "a partial request upload failed");
+      }
       reject(
         new DbWsTransportError(
           `ws send failed: ${err?.message || "unknown"}`,
-          false
+          complete
         )
       );
     }
@@ -2442,6 +2592,7 @@ function toBase64(content) {
     typeof content === "string" ? Buffer.from(content) : content
   ).toString("base64");
 }
+var PRESIGN_THRESHOLD = 4 * 1024 * 1024;
 function extensionFor(filename) {
   if (!filename) {
     return "";
@@ -2469,16 +2620,73 @@ var Store = class {
     const ext = extensionFor(options?.filename);
     const key = options?.key ?? (options?.contentAddressed ? `${createHash("sha256").update(content).digest("hex")}${ext}` : `${randomUUID()}${ext}`);
     const cacheControl = options?.cacheControl ?? (!options?.key && this._access === "public" ? "public, max-age=31536000, immutable" : void 0);
+    const bytes = typeof content === "string" ? Buffer.from(content) : content;
+    if (bytes.byteLength >= PRESIGN_THRESHOLD) {
+      return this._putPresigned(bytes, key, {
+        ...options?.contentType ? { contentType: options.contentType } : {},
+        ...cacheControl ? { cacheControl } : {}
+      });
+    }
     const meta = await this._call("put", {
       store: this._store,
       access: this._access,
       key,
-      body: toBase64(content),
+      body: toBase64(bytes),
       ...options?.contentType ? { contentType: options.contentType } : {},
       ...cacheControl ? { cacheControl } : {}
     });
     return this._toFile(key, meta);
   }
+  /**
+   * Large-content half of {@link put}: mint a presigned POST scoped to exactly
+   * these bytes and send them direct to storage — the JSON transport's body
+   * limit never sees them. Same result contract as the small path; the final
+   * `head` keeps the returned metadata honest (server-observed size/type/time).
+   */
+  async _putPresigned(bytes, key, options) {
+    const res = await this._call("create-upload", {
+      store: this._store,
+      access: this._access,
+      key,
+      maxSize: bytes.byteLength,
+      ...options.contentType ? { contentType: options.contentType } : {},
+      ...options.cacheControl ? { cacheControl: options.cacheControl } : {}
+    });
+    const form = new FormData();
+    for (const [k, v] of Object.entries(
+      res.uploadFields
+    )) {
+      form.append(k, v);
+    }
+    const view = new Uint8Array(
+      bytes.buffer,
+      bytes.byteOffset,
+      bytes.byteLength
+    );
+    form.append(
+      "file",
+      new Blob([view], options.contentType ? { type: options.contentType } : void 0)
+    );
+    const upload = await fetch(res.uploadUrl, {
+      method: "POST",
+      body: form
+    });
+    if (!upload.ok) {
+      const errorText = await upload.text().catch(() => "");
+      throw new MindStudioError(
+        `Upload failed: ${upload.status} ${upload.statusText}${errorText ? ` \u2014 ${errorText.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim().slice(0, 200)}` : ""}`,
+        "upload_error",
+        upload.status,
+        errorText || void 0
+      );
+    }
+    const meta = await this._call("head", {
+      store: this._store,
+      access: this._access,
+      key
+    });
+    return this._toFile(key, meta);
+  }
   /** Read an object's bytes (backend / trusted context). */
   async get(key) {
     const res = await this._call("get", {
@@ -2814,6 +3022,50 @@ function createAnalytics(call) {
   };
 }
 
+// src/email/index.ts
+var iso = (v) => v === void 0 ? void 0 : v instanceof Date ? v.toISOString() : v;
+function createEmail(call) {
+  return {
+    stats(options) {
+      return call("stats", {
+        start: iso(options?.start),
+        end: iso(options?.end),
+        buckets: options?.buckets
+      });
+    },
+    messages(options) {
+      return call("messages", {
+        ...options,
+        start: iso(options?.start),
+        end: iso(options?.end)
+      });
+    },
+    message(messageId) {
+      return call("message", { messageId });
+    },
+    batches(options) {
+      return call("batches", {
+        start: iso(options?.start),
+        end: iso(options?.end),
+        limit: options?.limit,
+        offset: options?.offset
+      });
+    },
+    batch(batchId) {
+      return call("batch", { batchId });
+    },
+    suppressions(options) {
+      return call("suppressions", options ?? {});
+    },
+    suppress(email2) {
+      return call("suppress", { email: email2 });
+    },
+    unsuppress(email2) {
+      return call("unsuppress", { email: email2 });
+    }
+  };
+}
+
 // src/task/index.ts
 import { randomUUID as randomUUID2 } from "crypto";
 
@@ -5526,6 +5778,7 @@ var MindStudioAgent = class {
   _dataSources;
   _voice;
   _analytics;
+  _email;
   /** @internal Auth type — 'internal' for CALLBACK_TOKEN (managed mode), 'apiKey' otherwise. */
   _authType;
   /** @internal Usage source sent on step executions (from MINDSTUDIO_REQUEST_SOURCE).
@@ -6570,6 +6823,24 @@ var MindStudioAgent = class {
       this._analyticsRequest.bind(this)
     );
   }
+  /**
+   * Outbound email: the per-recipient delivery log, blast stats, and this app's
+   * unsubscribe list. Sending is the `sendEmail` action, not this namespace.
+   *
+   * @example
+   * ```ts
+   * import { email } from '@mindstudio-ai/agent';
+   *
+   * // A support lookup: did this person get their mail?
+   * const { messages } = await email.messages({ recipient: 'a@b.com' });
+   *
+   * // How did the August newsletter do?
+   * const blast = await email.batch('newsletter-2026-08');
+   * ```
+   */
+  get email() {
+    return this._email ??= createEmail(this._emailRequest.bind(this));
+  }
   /**
    * Jewel surfaces: arrival-shaped triggers (`propose`) and the app-native
    * approval queue (`queue.list` / `queue.resolve`). See {@link JewelsApi}.
@@ -6708,6 +6979,18 @@ var MindStudioAgent = class {
    * of surfacing as empty data. Deliberately single-shot and scoped to this
    * namespace — the other brokered transports keep their semantics.
    */
+  /**
+   * Brokered email transport. No 429 retry, unlike analytics: this namespace
+   * carries writes (suppress / unsuppress), and silently retrying a mutation is a
+   * different risk from retrying an idempotent read. A caller that wants one can
+   * retry a read itself.
+   */
+  async _emailRequest(op, body) {
+    return this._brokeredRequest("email", op, body, {
+      fallbackMessage: "Email API call failed",
+      fallbackCode: "email_error"
+    });
+  }
   async _analyticsRequest(op, body) {
     const call = () => this._brokeredRequest("analytics", op, body, {
       fallbackMessage: "Analytics read failed",
@@ -7612,6 +7895,13 @@ var analytics = new Proxy({}, {
     return typeof value === "function" ? value.bind(target) : value;
   }
 });
+var email = new Proxy({}, {
+  get(_, prop) {
+    const target = mindstudio.email;
+    const value = Reflect.get(target, prop, target);
+    return typeof value === "function" ? value.bind(target) : value;
+  }
+});
 var session = new Proxy(
   {},
   {
@@ -7640,6 +7930,7 @@ export {
   db,
   index_default as default,
   defineJewel,
+  email,
   files,
   getRequestContext,
   mindstudio,