@mindstudio-ai/agent 0.1.82 → 0.1.84

package/llms.txt

@@ -808,6 +808,9 @@ Send an email to one or more recipient addresses.
 - Use the "to" field to send to one or more specific recipient email addresses directly. Allowed recipients depend on the sender: when the app sends from a domain it owns (a verified custom domain or its <slug>.madewithremy.com subdomain) any recipient is allowed; when it falls back to the shared Remy address, recipients must be verified app users or members of the app's organization. (v1 apps cannot use a direct "to" — they must resolve recipients via a connection.)
 - Alternatively, recipient email addresses can be resolved from OAuth connections configured by the app creator via connectionId. The user running the workflow does not specify the recipient directly.
 - Use "cc" and "bcc" to add visible / hidden recipients (a string or an array). They are subject to the same recipient rules as "to".
+- "to" is optional only in the sense that recipients can come from elsewhere — omit it and supply "cc"/"bcc" for a hidden-list send, or omit all three and recipients are resolved from an OAuth connection. Naming nobody at all is an error.
+- Bcc-only sends are supported: with no "to" or "cc", the To: header is addressed to the app's own sender address (the standard "undisclosed recipients" pattern) so recipients can't see each other. The returned "recipients" reflects that auto-filled address.
+- Every recipient counts toward the app's daily outbound cap, including cc and bcc.
 - The sender defaults automatically: v2 apps send from the app's own identity — its verified custom domain if set, else its platform subdomain (noreply@<slug>.madewithremy.com), else the default Remy address.
 - Optionally set "from" to a custom handle, but ONLY if the app has a custom domain or subdomain: a bare handle ("support" → support@<app-domain>), a full "support@your-domain.com", or "Name <support@your-domain.com>". The domain must be one the app owns, or the step fails.
 - If the body is a URL to a hosted HTML file on the CDN, the HTML is fetched and used as the email body.
@@ -1800,3 +1803,40 @@ const { url } = await mindstudio.uploadFile(readFileSync('photo.png'), { extensi
 - `options.type`: string (optional) — MIME type (e.g. `"image/png"`). Determines which CDN subdomain is used.
 
 Output: `{ url: string }` — The permanent public CDN URL.
+
+#### `files` — per-app file storage (private by default)
+Typed file storage for the app — the twin of the `db` namespace. Define a store at module scope, then read/write objects. Files are served on the app's own domain. Private stores (the default) are signed / session-authorized; public stores are world-readable, CDN-served, and images are resizable via query params (e.g. `?w=400&h=300&fit=cover`). Prefer this over the deprecated `uploadFile()` for app storage.
+
+```typescript
+import { files } from '@mindstudio-ai/agent';
+
+// Define stores at module scope (access is pinned here).
+export const Uploads = files.defineStore('uploads');                  // private (default)
+export const Assets  = files.defineStore('assets', { access: 'public' });
+
+// Store bytes and get a ready-to-use URL.
+const file = await Uploads.put(buffer, { contentType: 'application/pdf', filename: 'report.pdf' });
+file.url;              // stable on-domain URL for a logged-in user (drop into <img>/<a download>)
+await file.shareUrl(); // absolute signed URL that works with NO session (email/embed); default 24h
+```
+
+Store methods:
+- `put(content, { key?, contentType?, filename?, contentAddressed? })` → `StoredFile`. `content` is `Buffer | Uint8Array | string`. Omit `key` for a random UUID; `contentAddressed: true` derives an immutable `<sha256>.<ext>` key.
+- `get(key)` → `Buffer` · `head(key)` → `StoredFile` · `exists(key)` → `boolean`
+- `list({ prefix?, cursor?, limit? })` → `{ files: StoredFile[]; cursor? }`
+- `delete(key)` → `void`
+- `shareUrl(key, { expiresIn? })` → signed absolute URL (private stores; no session needed)
+
+`StoredFile`: `{ store, key, access, size?, contentType?, updatedAt?, url, shareUrl() }`.
+
+`defineStore(name, options?)` options: `access: 'public' | 'private'` (default private), `maxSize` (bytes; cap for client-direct uploads), `contentTypes` (allowlist for client-direct uploads).
+
+User uploads (client-direct — bytes go straight to storage, never through the app backend): a backend method mints a token, the frontend submits it with `@mindstudio-ai/interface`.
+```typescript
+// backend method
+const token = await Uploads.createUploadToken({ contentType, maxSize: 25 * 1024 * 1024 });
+return token;
+// frontend (@mindstudio-ai/interface)
+import { platform } from '@mindstudio-ai/interface';
+const { url } = await platform.upload(token, file, { onProgress });
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindstudio-ai/agent",
-  "version": "0.1.82",
+  "version": "0.1.84",
   "description": "TypeScript SDK for MindStudio direct step execution",
   "type": "module",
   "main": "./dist/index.js",