@mindstudio-ai/agent 0.1.143 → 0.1.145

package/dist/index.js

@@ -2861,6 +2861,11 @@ function resolveTable(databases, tableName, databaseHint) {
 
 // src/files/store.ts
 import { createHash, randomUUID } from "crypto";
+import { createReadStream, createWriteStream } from "fs";
+import { readFile, stat, writeFile } from "fs/promises";
+import { basename } from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
 function fileUrl(access, store, key) {
   const path = key.split("/").map(encodeURIComponent).join("/");
   return `/_/files/${access}/${store}/${path}`;
@@ -2871,6 +2876,72 @@ function toBase64(content) {
   ).toString("base64");
 }
 var PRESIGN_THRESHOLD = 4 * 1024 * 1024;
+var MAX_FILE_BYTES = 5 * 1024 * 1024 * 1024;
+var PART_CONCURRENCY = 4;
+var PART_ATTEMPTS = 4;
+var PART_URL_BATCH = 50;
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+function isStream(content) {
+  return typeof content === "object" && content !== null && !(content instanceof Uint8Array) && typeof content[Symbol.asyncIterator] === "function";
+}
+async function* inParts(stream2, size) {
+  let pending = [];
+  let pendingBytes = 0;
+  for await (const chunk of stream2) {
+    let rest = chunk;
+    while (pendingBytes + rest.byteLength >= size) {
+      const take = size - pendingBytes;
+      pending.push(rest.subarray(0, take));
+      yield Buffer.concat(pending);
+      rest = rest.subarray(take);
+      pending = [];
+      pendingBytes = 0;
+    }
+    if (rest.byteLength > 0) {
+      pending.push(rest);
+      pendingBytes += rest.byteLength;
+    }
+  }
+  if (pendingBytes > 0) {
+    yield Buffer.concat(pending);
+  }
+}
+async function sendPart(partNumber, bytes, urlFor) {
+  let lastStatus = 0;
+  for (let attempt = 1; attempt <= PART_ATTEMPTS; attempt += 1) {
+    try {
+      const res = await fetch(await urlFor(partNumber, lastStatus === 403), {
+        method: "PUT",
+        body: bytes
+      });
+      await res.body?.cancel();
+      if (res.ok) {
+        return;
+      }
+      lastStatus = res.status;
+      if (res.status >= 400 && res.status < 500 && res.status !== 403) {
+        break;
+      }
+    } catch {
+      lastStatus = 0;
+    }
+    if (attempt < PART_ATTEMPTS) {
+      await sleep2(1e3 * 2 ** (attempt - 1));
+    }
+  }
+  throw new MindStudioError(
+    `Upload failed: part ${partNumber}${lastStatus ? ` (${lastStatus})` : ""}`,
+    "upload_error",
+    lastStatus || 502
+  );
+}
+async function sha256OfFile(path) {
+  const hash = createHash("sha256");
+  for await (const chunk of createReadStream(path)) {
+    hash.update(chunk);
+  }
+  return hash.digest("hex");
+}
 function extensionFor(filename) {
   if (!filename) {
     return "";
@@ -2879,16 +2950,18 @@ function extensionFor(filename) {
   return dot > 0 ? filename.slice(dot) : "";
 }
 var Store = class {
-  constructor(_store, _access, _call, _policy = {}) {
+  constructor(_store, _access, _call, _policy = {}, _runStep) {
     this._store = _store;
     this._access = _access;
     this._call = _call;
     this._policy = _policy;
+    this._runStep = _runStep;
   }
   _store;
   _access;
   _call;
   _policy;
+  _runStep;
   /** The store's name. */
   get name() {
     return this._store;
@@ -2897,8 +2970,17 @@ var Store = class {
   get access() {
     return this._access;
   }
-  /** Store bytes. Returns a {@link StoredFile} with a ready-to-use `url`. */
+  /**
+   * Store bytes, or a stream of them (a Node `Readable`, a web
+   * `ReadableStream`, any async iterable of `Uint8Array`), which goes up a
+   * part at a time and is never held whole. Returns a {@link StoredFile} with
+   * a ready-to-use `url`. A stream needs a `key`, or a `filename` for one,
+   * since a content-addressed key needs every byte before the first is sent.
+   */
   async put(content, options) {
+    if (isStream(content)) {
+      return this._putInParts(content, void 0, options);
+    }
     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);
@@ -2972,14 +3054,211 @@ var Store = class {
     });
     return this._toFile(key, meta);
   }
-  /** Read an object's bytes (backend / trusted context). */
+  /**
+   * Store a file from disk, read a part at a time, so a large one is never
+   * held in memory: a recording, an ffmpeg output. `filename` defaults to the
+   * file's own name, for the key's extension.
+   */
+  async putFile(path, options) {
+    const { size } = await stat(path);
+    const named = { filename: basename(path), ...options };
+    if (size < PRESIGN_THRESHOLD) {
+      return this.put(await readFile(path), named);
+    }
+    const key = named.key ?? (named.contentAddressed ? `${await sha256OfFile(path)}${extensionFor(named.filename)}` : void 0);
+    return this._putInParts(
+      createReadStream(path, { highWaterMark: 1024 * 1024 }),
+      size,
+      { ...named, ...key ? { key } : {} }
+    );
+  }
+  /**
+   * Copy the file at a URL into this store, without its bytes passing
+   * through the method: the platform fetches it straight into storage. For a
+   * direct link to a file (a recording, an export, a podcast episode's mp3),
+   * up to 5 GiB; a share page (Google Drive's, Dropbox's) isn't the file. The
+   * key is chosen for it, the URL's extension kept. The `importFromUrl`
+   * action, with this store as its `store`.
+   */
+  async importFromUrl(url, options) {
+    if (!this._runStep) {
+      throw new MindStudioError(
+        "importFromUrl needs the agent this store came from.",
+        "import_unavailable",
+        400
+      );
+    }
+    const out = await this._runStep(
+      "importFromUrl",
+      {
+        url,
+        ...options?.contentType ? { contentType: options.contentType } : {}
+      },
+      this
+    );
+    return this._toFile(out.key, {
+      size: out.size,
+      contentType: out.contentType
+    });
+  }
+  /**
+   * A file too large for one request: a multipart upload, its parts sent
+   * straight to storage `PART_CONCURRENCY` at a time, each retried on its own.
+   * `size` is the file's when known; a stream's is learned as it ends.
+   */
+  async _putInParts(stream2, size, options) {
+    if (!options?.key && options?.contentAddressed) {
+      throw new MindStudioError(
+        "A content-addressed key needs every byte before the upload starts: pass a Buffer, or use putFile.",
+        "content_addressed_stream",
+        400
+      );
+    }
+    const key = options?.key ?? `${randomUUID()}${extensionFor(options?.filename)}`;
+    const cacheControl = options?.cacheControl ?? (!options?.key && this._access === "public" ? "public, max-age=31536000, immutable" : void 0);
+    const grant = await this._call("create-upload", {
+      store: this._store,
+      access: this._access,
+      key,
+      maxSize: size ?? MAX_FILE_BYTES,
+      ...options?.contentType ? { contentType: options.contentType } : {},
+      ...cacheControl ? { cacheControl } : {}
+    });
+    const { session: session2, partSize } = await this._call("uploads/start", {
+      grant: grant.grant,
+      ...size !== void 0 ? { size } : {}
+    });
+    let sent;
+    try {
+      sent = await this._sendParts(session2, inParts(stream2, partSize));
+    } catch (err) {
+      await this._call("uploads/abort", { session: session2 }).catch(() => {
+      });
+      throw err;
+    }
+    if (sent === 0) {
+      await this._call("uploads/abort", { session: session2 }).catch(() => {
+      });
+      return this.put(new Uint8Array(0), { ...options, key });
+    }
+    const meta = await this._call("uploads/complete", { session: session2 });
+    return this._toFile(key, meta);
+  }
+  /** Send every part, at most `PART_CONCURRENCY` at once; how many were sent. */
+  async _sendParts(session2, parts) {
+    const batches = /* @__PURE__ */ new Map();
+    const urlFor = (partNumber, fresh = false) => {
+      const batch = Math.floor((partNumber - 1) / PART_URL_BATCH);
+      if (fresh) {
+        batches.delete(batch);
+      }
+      let urls = batches.get(batch);
+      if (!urls) {
+        const first = batch * PART_URL_BATCH + 1;
+        urls = this._call("uploads/parts", {
+          session: session2,
+          parts: Array.from({ length: PART_URL_BATCH }, (_, i) => first + i)
+        }).then(
+          (res) => new Map(res.urls.map(({ partNumber: n, url }) => [n, url]))
+        );
+        batches.set(batch, urls);
+      }
+      return urls.then((map) => map.get(partNumber));
+    };
+    const inflight = /* @__PURE__ */ new Set();
+    let failure;
+    let count = 0;
+    for await (const bytes of parts) {
+      if (failure) {
+        break;
+      }
+      count += 1;
+      const partNumber = count;
+      const sending = sendPart(partNumber, bytes, urlFor).catch((err) => {
+        failure ??= err instanceof Error ? err : new Error(String(err));
+      }).finally(() => inflight.delete(sending));
+      inflight.add(sending);
+      if (inflight.size >= PART_CONCURRENCY) {
+        await Promise.race(inflight);
+      }
+    }
+    await Promise.all(inflight);
+    if (failure) {
+      throw failure;
+    }
+    return count;
+  }
+  /**
+   * Read an object's bytes (backend / trusted context), straight from storage.
+   * For a large file, {@link getStream} or {@link download} reads it without
+   * holding it whole.
+   */
   async get(key) {
-    const res = await this._call("get", {
+    const res = await this._read(key);
+    return Buffer.from(await res.arrayBuffer());
+  }
+  /**
+   * Read an object as a stream, straight from storage: the whole of it, or
+   * the bytes from `start` to `end`, both included. A web `ReadableStream`
+   * (`Readable.fromWeb` makes it a Node stream).
+   */
+  async getStream(key, options) {
+    const res = await this._read(key, options);
+    return res.body ?? new ReadableStream({
+      start: (controller) => controller.close()
+    });
+  }
+  /** Write an object to a file on disk, streamed, so it's never held whole. */
+  async download(key, path) {
+    const res = await this._read(key);
+    if (!res.body) {
+      await writeFile(path, new Uint8Array(0));
+      return;
+    }
+    await pipeline(
+      Readable.fromWeb(res.body),
+      createWriteStream(path)
+    );
+  }
+  /** A GET straight to storage, through a short-lived URL the platform signs. */
+  async _read(key, range) {
+    const { url } = await this._call("read-url", {
       store: this._store,
       access: this._access,
       key
     });
-    return Buffer.from(res.body, "base64");
+    const ranged = range && (range.start !== void 0 || range.end !== void 0);
+    const res = await fetch(
+      url,
+      ranged ? {
+        headers: {
+          Range: `bytes=${range.start ?? 0}-${range.end ?? ""}`
+        }
+      } : void 0
+    );
+    if (res.ok) {
+      return res;
+    }
+    await res.body?.cancel();
+    if (res.status === 404) {
+      throw new MindStudioError(
+        `No file "${key}" in store "${this._store}".`,
+        "file_not_found",
+        404
+      );
+    }
+    if (res.status === 416) {
+      throw new MindStudioError(
+        `The range is outside "${key}".`,
+        "range_not_satisfiable",
+        416
+      );
+    }
+    throw new MindStudioError(
+      `Read failed: ${res.status} ${res.statusText}`,
+      "file_error",
+      res.status
+    );
   }
   /** Metadata without downloading. Rejects if the object doesn't exist. */
   async head(key) {
@@ -3083,7 +3362,11 @@ var Store = class {
     return {
       key,
       url: fileUrl(this._access, this._store, key),
-      upload: { url: res.uploadUrl, fields: res.uploadFields }
+      upload: {
+        url: res.uploadUrl,
+        fields: res.uploadFields,
+        ...res.grant ? { grant: res.grant } : {}
+      }
     };
   }
   _toFile(key, meta) {
@@ -3112,13 +3395,19 @@ var Store = class {
 };
 
 // src/files/index.ts
-function createFiles(call) {
+function createFiles(call, runStep) {
   return {
     defineStore(name, options) {
-      return new Store(name, options?.access ?? "private", call, {
-        ...options?.maxSize !== void 0 ? { maxSize: options.maxSize } : {},
-        ...options?.contentTypes ? { contentTypes: options.contentTypes } : {}
-      });
+      return new Store(
+        name,
+        options?.access ?? "private",
+        call,
+        {
+          ...options?.maxSize !== void 0 ? { maxSize: options.maxSize } : {},
+          ...options?.contentTypes ? { contentTypes: options.contentTypes } : {}
+        },
+        runStep
+      );
     }
   };
 }
@@ -4322,6 +4611,13 @@ var stepMetadata = {
     inputSchema: { "type": "object", "properties": { "imageUrl": { "type": "string", "description": "URL of the image to remove the watermark from" }, "engine": { "type": "string", "description": "Watermark removal engine to use" }, "intermediateAsset": { "type": "boolean", "description": "When true, the asset is created but hidden from the user's gallery (tagged as intermediate)" } }, "required": ["imageUrl", "engine"] },
     outputSchema: { "type": "object", "properties": { "imageUrl": { "type": "string", "description": "CDN URL of the processed image with watermark removed (PNG)" } }, "required": ["imageUrl"] }
   },
+  "importFromUrl": {
+    stepType: "importFromUrl",
+    description: "Copy a file at a URL into one of the app's file stores, without the bytes passing through the method",
+    usageNotes: "- 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.\n- Requires a store: pass the store handle as `store` in the options. `Store.importFromUrl(url)` is the same call, returning a StoredFile.\n- 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.",
+    inputSchema: { "type": "object", "properties": { "url": { "type": "string", "description": "A direct link to the file" }, "contentType": { "type": "string", "description": "The type to store it as; the response's own when omitted" } }, "required": ["url"] },
+    outputSchema: { "type": "object", "properties": { "fileUrl": { "type": "string", "description": "The stored file's stable on-domain URL" }, "key": { "type": "string", "description": "The stored file's key in its store" }, "size": { "type": "number", "description": "Its size in bytes" }, "contentType": { "type": "string", "description": "The type it was stored as" } }, "required": ["fileUrl", "key", "size", "contentType"] }
+  },
   "insertVideoClips": {
     stepType: "insertVideoClips",
     description: "Insert b-roll clips into a base video at a timecode, optionally with an xfade transition.",
@@ -4550,6 +4846,13 @@ var stepMetadata = {
     inputSchema: { "type": "object", "properties": { "type": { "enum": ["standard", "advanced"], "type": "string", "description": "Background removal quality tier" }, "imageUrl": { "type": "string", "description": "URL of the source image to remove the background from" }, "autoCrop": { "type": "boolean", "description": "Whether to automatically trim transparent padding from the result, on by default" } }, "required": ["imageUrl"] },
     outputSchema: { "type": "object", "properties": { "imageUrl": { "type": "string", "description": "CDN URL of the image with background removed (transparent PNG)" } }, "required": ["imageUrl"] }
   },
+  "renderVideoFromHtmlComposition": {
+    stepType: "renderVideoFromHtmlComposition",
+    description: "Render an HTML composition (HTML, CSS, media and seekable animation on a timeline) to a video file",
+    usageNotes: "- 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\n- 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\n- `variables` overrides the composition's `data-composition-variables` defaults, which it reads with `window.__hyperframes.getVariables()`\n- 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\n- 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\n- One render per call, finishing within 15 minutes\n- A composition HyperFrames can't render fails with HyperFrames' own reason",
+    inputSchema: { "type": "object", "properties": { "html": { "type": "string", "description": "The composition's HTML, up to 10 MB; give this or project" }, "project": { "type": "string", "description": "URL of a zip of the project's folder, or of one self-contained HTML file; give this or html" }, "entryFile": { "type": "string", "description": "The entry HTML inside the zip, relative to its root; index.html when omitted" }, "variables": { "type": "object", "properties": {}, "required": [], "description": "Values over the composition's declared variables" }, "fps": { "enum": [24, 30, 60], "type": "number", "description": "Frames per second: 24, 30 (default) or 60" }, "quality": { "enum": ["draft", "standard", "high"], "type": "string", "description": "Encode quality: draft, standard (default) or high" }, "format": { "enum": ["mp4", "webm", "mov", "gif"], "type": "string", "description": "mp4 (default), webm or mov (both keep transparency), or gif" }, "intermediateAsset": { "type": "boolean", "description": "When true, the asset is created but hidden from the user's gallery (tagged as intermediate)" } } },
+    outputSchema: { "type": "object", "properties": { "videoUrl": { "type": "string", "description": "URL of the rendered video" }, "durationSec": { "type": "number", "description": "Its length in seconds" }, "frames": { "type": "number", "description": "How many frames it has" } }, "required": ["videoUrl", "durationSec", "frames"] }
+  },
   "replyToGmailEmail": {
     stepType: "replyToGmailEmail",
     description: "Reply to an existing email in Gmail. The reply is threaded under the original message.",
@@ -4564,6 +4867,13 @@ var stepMetadata = {
     inputSchema: { "type": "object", "properties": { "videoUrl": { "type": "string", "description": "URL of the source video to resize" }, "mode": { "enum": ["fit", "exact"], "type": "string", "description": "Resize mode: 'fit' scales within max dimensions, 'exact' forces exact dimensions" }, "maxWidth": { "type": "number", "description": "Maximum width in pixels (used with 'fit' mode)" }, "maxHeight": { "type": "number", "description": "Maximum height in pixels (used with 'fit' mode)" }, "width": { "type": "number", "description": "Exact width in pixels (used with 'exact' mode)" }, "height": { "type": "number", "description": "Exact height in pixels (used with 'exact' mode)" }, "strategy": { "enum": ["pad", "crop"], "type": "string", "description": "Strategy for handling aspect ratio mismatch in 'exact' mode" }, "intermediateAsset": { "type": "boolean", "description": "When true, the asset is created but hidden from the user's gallery (tagged as intermediate)" } }, "required": ["videoUrl", "mode"] },
     outputSchema: { "type": "object", "properties": { "videoUrl": { "type": "string", "description": "URL of the resized video" } }, "required": ["videoUrl"] }
   },
+  "runFfmpeg": {
+    stepType: "runFfmpeg",
+    description: "Run an ffmpeg command on media files",
+    usageNotes: "- 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)\n- `inputs` names each input file by URL; `{in:<name>}` anywhere in an argument, a filter graph included, is that file's local path\n- `{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\n- One command per call, finishing within 15 minutes; up to 10 GB of inputs and outputs together, 5 GB per output\n- 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\n- A command ffmpeg refuses fails with ffmpeg's own error lines",
+    inputSchema: { "type": "object", "properties": { "inputs": { "type": "object", "properties": {}, "required": [], "description": "Input files by name, each a URL; `{in:<name>}` in an argument is its local path" }, "args": { "type": "array", "items": { "type": "string" }, "description": "ffmpeg's arguments, run as given; `{out:<file.ext>}` in an argument is an output's path" }, "intermediateAsset": { "type": "boolean", "description": "When true, the assets are created but hidden from the user's gallery (tagged as intermediate)" } }, "required": ["inputs", "args"] },
+    outputSchema: { "type": "object", "properties": { "outputs": { "type": "object", "properties": {}, "required": [], "description": "Each output's URL, by the file name `{out:<file.ext>}` gave it" } }, "required": ["outputs"] }
+  },
   "runFromConnectorRegistry": {
     stepType: "runFromConnectorRegistry",
     description: "Run a raw API connector to a third-party service",
@@ -4965,7 +5275,7 @@ function mapTools(tools) {
     return defaults ? { stepType, defaults } : { stepType };
   });
 }
-function sleep2(ms) {
+function sleep3(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function isDevMode() {
@@ -5339,7 +5649,7 @@ async function runTurnWithRetry(httpConfig, body) {
           `[task] connection lost, retrying turn (attempt ${attempt + 2} of ${MAX_TURN_ATTEMPTS})`
         );
       }
-      await sleep2(INITIAL_BACKOFF_MS * 2 ** attempt);
+      await sleep3(INITIAL_BACKOFF_MS * 2 ** attempt);
     }
   }
   throw new TurnError("Turn retries exhausted", false, "request");
@@ -5908,6 +6218,9 @@ function applyStepMethods(AgentClass) {
   proto.imageRemoveWatermark = function(step, options) {
     return this.executeStep("imageRemoveWatermark", step, options);
   };
+  proto.importFromUrl = function(step, options) {
+    return this.executeStep("importFromUrl", step, options);
+  };
   proto.insertVideoClips = function(step, options) {
     return this.executeStep("insertVideoClips", step, options);
   };
@@ -6004,12 +6317,18 @@ function applyStepMethods(AgentClass) {
   proto.removeBackgroundFromImage = function(step, options) {
     return this.executeStep("removeBackgroundFromImage", step, options);
   };
+  proto.renderVideoFromHtmlComposition = function(step, options) {
+    return this.executeStep("renderVideoFromHtmlComposition", step, options);
+  };
   proto.replyToGmailEmail = function(step, options) {
     return this.executeStep("replyToGmailEmail", step, options);
   };
   proto.resizeVideo = function(step, options) {
     return this.executeStep("resizeVideo", step, options);
   };
+  proto.runFfmpeg = function(step, options) {
+    return this.executeStep("runFfmpeg", step, options);
+  };
   proto.runFromConnectorRegistry = function(step, options) {
     return this.executeStep("runFromConnectorRegistry", step, options);
   };
@@ -6159,6 +6478,13 @@ function applyStepMethods(AgentClass) {
 // src/client.ts
 var DEFAULT_BASE_URL = "https://v1.mindstudio-api.com";
 var DEFAULT_MAX_RETRIES = 3;
+var toStepLogEvent = (event) => ({
+  value: event.value,
+  tag: event.tag,
+  ts: event.ts,
+  ...event.ephemeral === true ? { ephemeral: true } : {},
+  ...typeof event.progress === "number" ? { progress: event.progress } : {}
+});
 var MindStudioAgent = class {
   /** @internal */
   _httpConfig;
@@ -6320,7 +6646,7 @@ var MindStudioAgent = class {
     const pollUrl = `${this._currentHttpConfig.baseUrl}/developer/v2/steps/${stepType}/execute-async/poll/${asyncData.executionToken}`;
     let pollDelay = 100;
     while (true) {
-      await sleep3(pollDelay);
+      await sleep4(pollDelay);
       pollDelay = Math.min(pollDelay * 2, 5e3);
       const res = await fetch(pollUrl, {
         headers: { "User-Agent": "@mindstudio-ai/agent" }
@@ -6472,11 +6798,7 @@ var MindStudioAgent = class {
           try {
             const event = JSON.parse(line.slice(6));
             if (event.type === "log") {
-              options.onLog({
-                value: event.value,
-                tag: event.tag,
-                ts: event.ts
-              });
+              options.onLog(toStepLogEvent(event));
             } else if (event.type === "done") {
               doneEvent = {
                 output: event.output,
@@ -6515,11 +6837,7 @@ var MindStudioAgent = class {
               500
             );
           } else if (event.type === "log") {
-            options.onLog({
-              value: event.value,
-              tag: event.tag,
-              ts: event.ts
-            });
+            options.onLog(toStepLogEvent(event));
           }
         } catch (err) {
           if (err instanceof MindStudioError) {
@@ -6613,7 +6931,7 @@ var MindStudioAgent = class {
     const pollUrl = `${this._currentHttpConfig.baseUrl}/developer/v2/steps/execute-batch-async/poll/${asyncData.batchToken}`;
     let pollDelay = 300;
     while (true) {
-      await sleep3(pollDelay);
+      await sleep4(pollDelay);
       pollDelay = Math.min(pollDelay * 1.5, 3e3);
       const res = await fetch(pollUrl, {
         headers: { "User-Agent": "@mindstudio-ai/agent" }
@@ -6879,7 +7197,7 @@ var MindStudioAgent = class {
     const token = data.callbackToken;
     const pollUrl = `${this._currentHttpConfig.baseUrl}/developer/v2/agents/run/poll/${token}`;
     while (true) {
-      await sleep3(pollInterval);
+      await sleep4(pollInterval);
       const res = await fetch(pollUrl, {
         headers: { "User-Agent": "@mindstudio-ai/agent" }
       });
@@ -7237,7 +7555,10 @@ var MindStudioAgent = class {
    * ```
    */
   get files() {
-    return this._files ??= createFiles(this._filesRequest.bind(this));
+    return this._files ??= createFiles(
+      this._filesRequest.bind(this),
+      (stepType, step, store) => this.executeStep(stepType, step, { store })
+    );
   }
   /**
    * The `analytics` namespace — read the app's own traffic + event analytics
@@ -8003,7 +8324,7 @@ var MindStudioAgent = class {
     return { url: data.publicUrl };
   }
 };
-function sleep3(ms) {
+function sleep4(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 applyStepMethods(MindStudioAgent);
@@ -8687,6 +9008,7 @@ var monacoSnippets = {
   "hunterApiPersonEnrichment": { fields: [["email", "string"]], outputKeys: ["data"] },
   "imageFaceSwap": { fields: [["imageUrl", "string"], ["faceImageUrl", "string"], ["engine", "string"]], outputKeys: ["imageUrl"] },
   "imageRemoveWatermark": { fields: [["imageUrl", "string"], ["engine", "string"]], outputKeys: ["imageUrl"] },
+  "importFromUrl": { fields: [["url", "string"]], outputKeys: ["fileUrl", "key", "size", "contentType"] },
   "insertVideoClips": { fields: [["baseVideoUrl", "string"], ["overlayVideos", "array"]], outputKeys: ["videoUrl"] },
   "listDataSources": { fields: [], outputKeys: [] },
   "listGmailDrafts": { fields: [["exportType", ["json", "text"]]], outputKeys: ["drafts"] },
@@ -8719,8 +9041,10 @@ var monacoSnippets = {
   "quickbooksApiRequest": { fields: [["method", "string"], ["route", "string"], ["queryParams", "object"], ["body", "string"]], outputKeys: ["ok", "status", "body"] },
   "redactPII": { fields: [["input", "string"], ["language", "string"], ["entities", "array"]], outputKeys: ["text"] },
   "removeBackgroundFromImage": { fields: [["imageUrl", "string"]], outputKeys: ["imageUrl"] },
+  "renderVideoFromHtmlComposition": { fields: [], outputKeys: ["videoUrl", "durationSec", "frames"] },
   "replyToGmailEmail": { fields: [["messageId", "string"], ["message", "string"], ["messageType", ["plain", "html", "markdown"]]], outputKeys: ["messageId"] },
   "resizeVideo": { fields: [["videoUrl", "string"], ["mode", ["fit", "exact"]]], outputKeys: ["videoUrl"] },
+  "runFfmpeg": { fields: [["inputs", "object"], ["args", "array"]], outputKeys: ["outputs"] },
   "runFromConnectorRegistry": { fields: [["actionId", "string"], ["displayName", "string"], ["icon", "string"], ["configurationValues", "object"]], outputKeys: ["data"] },
   "scrapeLinkedInCompany": { fields: [["url", "string"]], outputKeys: ["company"] },
   "scrapeLinkedInProfile": { fields: [["url", "string"]], outputKeys: ["profile"] },