@mindstudio-ai/agent 0.1.142 → 0.1.144

package/llms.txt

@@ -531,6 +531,14 @@ Remove watermarks from an image using AI.
 - Input: `{ imageUrl: string, engine: string, intermediateAsset?: boolean }`
 - Output: `{ imageUrl: string }`
 
+#### importFromUrl
+Copy a file at a URL into one of the app's file stores, without the bytes passing through the method
+- For a direct link to a file (a recording, an export, a podcast episode's mp3), up to 5 GiB. The file is fetched and stored as it is.
+- Requires a store: pass the store handle as `store` in the options. `Store.importFromUrl(url)` is the same call, returning a StoredFile.
+- A share page (a Google Drive or Dropbox page, YouTube) is not the file: pass the file's own download link, or use downloadVideo for a hosted video.
+- Input: `{ url: string, contentType?: string }`
+- Output: `{ fileUrl: string, key: string, size: number, contentType: string }`
+
 #### insertVideoClips
 Insert b-roll clips into a base video at a timecode, optionally with an xfade transition.
 - Input: `{ baseVideoUrl: string, overlayVideos: { videoUrl: string, startTimeSec: number }[], transition?: string, transitionDuration?: number, useOverlayAudio?: boolean, intermediateAsset?: boolean }`
@@ -651,11 +659,34 @@ Remove the background from an image using AI, producing a transparent PNG.
 - Input: `{ type?: "standard" | "advanced", imageUrl: string, autoCrop?: boolean }`
 - Output: `{ imageUrl: string }`
 
+#### renderVideoFromHtmlComposition
+Render an HTML composition (HTML, CSS, media and seekable animation on a timeline) to a video file
+- Renders an HTML composition in HyperFrames' format (https://hyperframes.heygen.com) with HyperFrames 0.8.97, in Chrome off the app's own sandbox; author for that version
+- Pass the composition as `html`, the page itself (up to 10 MB), or as `project`, the URL of a zip of a project's folder (`index.html` at its root, or the file `entryFile` names) or of one HTML file, up to 2 GiB: an app file or any public URL
+- `variables` overrides the composition's `data-composition-variables` defaults, which it reads with `window.__hyperframes.getVariables()`
+- Whatever the composition loads itself (fonts, scripts, images, video) is fetched as it renders, so each is in the project or at a public URL; a private app file needs a signed URL
+- fps 24, 30 or 60 (default 30); quality draft, standard or high (default standard); format mp4 (default), webm or mov (both keep transparency), or gif
+- One render per call, finishing within 15 minutes
+- A composition HyperFrames can't render fails with HyperFrames' own reason
+- Input: `{ html?: string, project?: string, entryFile?: string, variables?: object, fps?: 24 | 30 | 60, quality?: "draft" | "standard" | "high", format?: "mp4" | "webm" | "mov" | "gif", intermediateAsset?: boolean }`
+- Output: `{ videoUrl: string, durationSec: number, frames: number }`
+
 #### resizeVideo
 Resize a video file
 - Input: `{ videoUrl: string, mode: "fit" | "exact", maxWidth?: number, maxHeight?: number, width?: number, height?: number, strategy?: "pad" | "crop", intermediateAsset?: boolean }`
 - Output: `{ videoUrl: string }`
 
+#### runFfmpeg
+Run an ffmpeg command on media files
+- Runs one ffmpeg command, its arguments exactly as given, off the app's own sandbox (ffmpeg 9, a static build with the common codecs and filters)
+- `inputs` names each input file by URL; `{in:<name>}` anywhere in an argument, a filter graph included, is that file's local path
+- `{out:<file.ext>}` anywhere in an argument is an output's path; every output the arguments name comes back in `outputs` by its file name, its type from its extension
+- One command per call, finishing within 15 minutes; up to 10 GB of inputs and outputs together, 5 GB per output
+- The system fonts are Noto Sans (`drawtext`'s default), DejaVu Sans, Liberation Sans and Noto Color Emoji: pass a font file as an input for any other
+- A command ffmpeg refuses fails with ffmpeg's own error lines
+- Input: `{ inputs: object, args: string[], intermediateAsset?: boolean }`
+- Output: `{ outputs: object }`
+
 #### runFromConnectorRegistry
 Run a raw API connector to a third-party service
 - Use the /developer/v2/helpers/connectors endpoint to list available services and actions.
@@ -1712,8 +1743,11 @@ await file.shareUrl(); // absolute signed URL that works with NO session (email/
 ```
 
 Store methods:
-- `put(content, { key?, contentType?, filename?, contentAddressed?, cacheControl? })` → `StoredFile`. `content` is `Buffer | Uint8Array | string` — any size up to 5 GiB (large content transparently uploads direct to storage via a presigned POST, so there is no request-body cap). Omit `key` for a random UUID; `contentAddressed: true` derives an immutable `<sha256>.<ext>` key. `cacheControl` sets how long a browser may keep a public object, at most an hour (defaults: auto-minted keys an hour, named keys `public, max-age=300`).
-- `get(key)` → `Buffer` · `head(key)` → `StoredFile` · `exists(key)` → `boolean`
+- `put(content, { key?, contentType?, filename?, contentAddressed?, cacheControl? })` → `StoredFile`. `content` is `Buffer | Uint8Array | string`, or a stream (Node `Readable`, web `ReadableStream`, async iterable of bytes) — any size up to 5 GiB, straight to storage (a stream goes up a part at a time, and needs `key` or `filename`, not `contentAddressed`). Omit `key` for a random UUID; `contentAddressed: true` derives an immutable `<sha256>.<ext>` key. `cacheControl` sets how long a browser may keep a public object, at most an hour (defaults: auto-minted keys an hour, named keys `public, max-age=300`).
+- `putFile(path, options?)` → `StoredFile` — a file on disk, a part at a time (never held in memory): use it for anything large a method writes, like an ffmpeg output.
+- `importFromUrl(url, { contentType? })` → `StoredFile` — the platform fetches a direct link to a file straight into the store (up to 5 GiB, stored as it is, key chosen for it); never fetch a large file into a method to `put` it. A share page isn't the file; a hosted video is `downloadVideo`'s.
+- `get(key)` → `Buffer` (the whole file in memory) · `download(key, path)` → `void` (streamed to disk) · `getStream(key, { start?, end? })` → web `ReadableStream` (all of it, or a byte range). All three read straight from storage; a missing key throws `file_not_found`.
+- `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)
@@ -1731,6 +1765,7 @@ return token;
 import { platform } from '@mindstudio-ai/interface';
 const { url } = await platform.upload(token, file, { onProgress });
 ```
+A token must start its upload within 10 minutes of minting (`expiresIn`: 60 to 900 seconds). A file of 64 MB or more goes up in parts and resumes: `platform.upload` again with a token for the same `key` and the same file sends only what hadn't arrived (mint with a stable `key` to resume across a reload). In the frontend, `fetch(file.url)` works with default credentials, never `credentials: 'include'`.
 
 Generated assets: EVERY action that produces a file can put its output straight into one of these stores — pass the store handle as `store` in the OPTIONS object (second argument). There is no allowlist; if an action returns a file URL, it takes `store`. Optional: omit it and the asset goes to the shared MindStudio CDN as before. Reach for it when the asset belongs to the app — private to a user, or listed alongside its other files. Inputs are never published either way: a file you hand an action is read where it sits, and any intermediate the platform needs is written to private storage and dropped when the call finishes.
 

package/package.json

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