memorix 1.9.3 → 1.9.5

package/dist/maintenance-runner.js

@@ -643,18 +643,21 @@ CREATE TABLE IF NOT EXISTS chat_transcript (
 `;
     CREATE_GRAPH_ENTITIES_TABLE = `
 CREATE TABLE IF NOT EXISTS graph_entities (
-  name            TEXT PRIMARY KEY,
+  projectId       TEXT NOT NULL,
+  name            TEXT NOT NULL,
   entityType      TEXT NOT NULL DEFAULT '',
-  observations    TEXT NOT NULL DEFAULT '[]'
+  observations    TEXT NOT NULL DEFAULT '[]',
+  PRIMARY KEY (projectId, name)
 );
 `;
     CREATE_GRAPH_RELATIONS_TABLE = `
 CREATE TABLE IF NOT EXISTS graph_relations (
   id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  projectId       TEXT NOT NULL,
   from_entity     TEXT NOT NULL,
   to_entity       TEXT NOT NULL,
   relationType    TEXT NOT NULL DEFAULT '',
-  UNIQUE(from_entity, to_entity, relationType)
+  UNIQUE(projectId, from_entity, to_entity, relationType)
 );
 `;
     CREATE_CODE_FILES_TABLE = `
@@ -3041,13 +3044,120 @@ var init_sqlite_reliability = __esm({
   }
 });
 
+// src/store/file-lock.ts
+import { promises as fs2 } from "fs";
+import { randomUUID } from "crypto";
+import path5 from "path";
+function canReclaimStaleLock(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    const pid = Number(parsed.pid);
+    if (!Number.isSafeInteger(pid) || pid < 1) return true;
+    try {
+      process.kill(pid, 0);
+      return false;
+    } catch (error) {
+      return error.code !== "EPERM";
+    }
+  } catch {
+    return true;
+  }
+}
+async function acquireLock(lockPath) {
+  for (let i2 = 0; i2 < MAX_RETRIES; i2++) {
+    try {
+      const fd = await fs2.open(lockPath, "wx");
+      await fd.writeFile(JSON.stringify({ pid: process.pid, time: Date.now() }));
+      await fd.close();
+      return;
+    } catch (err) {
+      const code = err instanceof Error && "code" in err ? err.code : void 0;
+      if (code === "EEXIST" || code === "EPERM") {
+        try {
+          const stat5 = await fs2.stat(lockPath);
+          if (Date.now() - stat5.mtimeMs > LOCK_STALE_MS) {
+            const raw2 = await fs2.readFile(lockPath, "utf8").catch(() => "");
+            if (canReclaimStaleLock(raw2)) {
+              await fs2.unlink(lockPath).catch(() => {
+              });
+              continue;
+            }
+          }
+        } catch {
+          continue;
+        }
+        await new Promise((r2) => setTimeout(r2, RETRY_INTERVAL_MS));
+      } else {
+        throw err;
+      }
+    }
+  }
+  const raw = await fs2.readFile(lockPath, "utf8").catch(() => "");
+  if (!canReclaimStaleLock(raw)) {
+    throw new Error(`Failed to acquire lock: ${lockPath} (owner is still running)`);
+  }
+  await fs2.unlink(lockPath).catch(() => {
+  });
+  try {
+    const fd = await fs2.open(lockPath, "wx");
+    await fd.writeFile(JSON.stringify({ pid: process.pid, time: Date.now() }));
+    await fd.close();
+    return;
+  } catch {
+    throw new Error(`Failed to acquire lock: ${lockPath} (timeout after ${MAX_RETRIES * RETRY_INTERVAL_MS}ms)`);
+  }
+}
+async function releaseLock(lockPath) {
+  await fs2.unlink(lockPath).catch(() => {
+  });
+}
+async function withFileLock(projectDir2, fn) {
+  const lockPath = path5.join(projectDir2, ".memorix.lock");
+  await acquireLock(lockPath);
+  try {
+    return await fn();
+  } finally {
+    await releaseLock(lockPath);
+  }
+}
+async function atomicWriteFileOnce(filePath, data) {
+  const tmpPath = filePath + `.tmp.${process.pid}.${randomUUID()}`;
+  try {
+    await fs2.writeFile(tmpPath, data, "utf-8");
+    await fs2.rename(tmpPath, filePath);
+  } catch (error) {
+    await fs2.unlink(tmpPath).catch(() => {
+    });
+    throw error;
+  }
+}
+function atomicWriteFile(filePath, data) {
+  const previous = atomicWriteTails.get(filePath) ?? Promise.resolve();
+  const next = previous.catch(() => void 0).then(() => atomicWriteFileOnce(filePath, data));
+  atomicWriteTails.set(filePath, next);
+  return next.finally(() => {
+    if (atomicWriteTails.get(filePath) === next) atomicWriteTails.delete(filePath);
+  });
+}
+var LOCK_STALE_MS, RETRY_INTERVAL_MS, MAX_RETRIES, atomicWriteTails;
+var init_file_lock = __esm({
+  "src/store/file-lock.ts"() {
+    "use strict";
+    init_esm_shims();
+    LOCK_STALE_MS = 1e4;
+    RETRY_INTERVAL_MS = 50;
+    MAX_RETRIES = 60;
+    atomicWriteTails = /* @__PURE__ */ new Map();
+  }
+});
+
 // src/store/sqlite-store.ts
 var sqlite_store_exports = {};
 __export(sqlite_store_exports, {
   SqliteBackend: () => SqliteBackend
 });
-import path5 from "path";
-import fs2 from "fs";
+import path6 from "path";
+import fs3 from "fs";
 function obsToRow(obs) {
   return {
     id: obs.id,
@@ -3134,6 +3244,7 @@ var init_sqlite_store = __esm({
     init_sqlite_db();
     init_sqlite_reliability();
     init_sqlite_fts();
+    init_file_lock();
     SqliteBackend = class {
       db = null;
       dataDir = "";
@@ -3297,38 +3408,43 @@ var init_sqlite_store = __esm({
       }
       // ── Migration ────────────────────────────────────────────────────
       async migrateFromJsonIfNeeded() {
-        const count2 = this.db.prepare(`SELECT COUNT(*) AS cnt FROM observations`).get();
-        if (count2.cnt > 0) return;
-        const jsonPath = path5.join(this.dataDir, "observations.json");
-        if (!fs2.existsSync(jsonPath)) return;
-        try {
-          const raw = fs2.readFileSync(jsonPath, "utf-8");
-          const observations2 = JSON.parse(raw);
+        const jsonPath = path6.join(this.dataDir, "observations.json");
+        if (!fs3.existsSync(jsonPath)) return;
+        await withFileLock(this.dataDir, async () => {
+          const count2 = this.db.prepare(`SELECT COUNT(*) AS cnt FROM observations`).get();
+          if (count2.cnt > 0) return;
+          const raw = fs3.readFileSync(jsonPath, "utf-8");
+          const parsed = JSON.parse(raw);
+          if (!Array.isArray(parsed)) {
+            throw new Error("[memorix] observations.json migration refused: expected a JSON array");
+          }
+          const observations2 = parsed;
           if (observations2.length === 0) return;
+          if (observations2.some((obs) => !obs || !Number.isSafeInteger(obs.id) || obs.id < 1 || typeof obs.projectId !== "string")) {
+            throw new Error("[memorix] observations.json migration refused: invalid observation record");
+          }
           console.error(`[memorix] Migrating ${observations2.length} observations from JSON to SQLite...`);
           const insertMany = this.db.transaction((obsList) => {
             for (const obs of obsList) {
               this.stmtInsert.run(obsToRow(obs));
             }
+            const counterPath = path6.join(this.dataDir, "counter.json");
+            let counterNextId;
+            if (fs3.existsSync(counterPath)) {
+              const counterData = JSON.parse(fs3.readFileSync(counterPath, "utf-8"));
+              const candidate = counterData.nextId ?? counterData.next_id;
+              if (candidate !== void 0 && (!Number.isSafeInteger(candidate) || Number(candidate) < 1)) {
+                throw new Error("[memorix] counter.json migration refused: nextId must be a positive integer");
+              }
+              counterNextId = candidate === void 0 ? void 0 : Number(candidate);
+            }
+            const maxId = Math.max(...obsList.map((obs) => obs.id));
+            this.rawSaveIdCounter(Math.max(counterNextId ?? 1, maxId + 1));
+            this.bumpGeneration();
           });
           insertMany(observations2);
-          const counterPath = path5.join(this.dataDir, "counter.json");
-          if (fs2.existsSync(counterPath)) {
-            try {
-              const counterData = JSON.parse(fs2.readFileSync(counterPath, "utf-8"));
-              const nextId2 = counterData.nextId ?? counterData.next_id ?? Math.max(...observations2.map((o) => o.id)) + 1;
-              this.rawSaveIdCounter(nextId2);
-            } catch {
-              this.rawSaveIdCounter(Math.max(...observations2.map((o) => o.id)) + 1);
-            }
-          } else {
-            this.rawSaveIdCounter(Math.max(...observations2.map((o) => o.id)) + 1);
-          }
-          this.bumpGeneration();
           console.error(`[memorix] Migration complete. ${observations2.length} observations now in SQLite.`);
-        } catch (err) {
-          console.error(`[memorix] JSON\u2192SQLite migration failed (non-fatal, data preserved in JSON): ${err}`);
-        }
+        });
       }
       // ── Public read ──────────────────────────────────────────────────
       async loadAll() {
@@ -3657,91 +3773,6 @@ var init_types = __esm({
   }
 });
 
-// src/store/file-lock.ts
-import { promises as fs3 } from "fs";
-import { randomUUID } from "crypto";
-import path6 from "path";
-async function acquireLock(lockPath) {
-  for (let i2 = 0; i2 < MAX_RETRIES; i2++) {
-    try {
-      const fd = await fs3.open(lockPath, "wx");
-      await fd.writeFile(JSON.stringify({ pid: process.pid, time: Date.now() }));
-      await fd.close();
-      return;
-    } catch (err) {
-      const code = err instanceof Error && "code" in err ? err.code : void 0;
-      if (code === "EEXIST" || code === "EPERM") {
-        try {
-          const stat5 = await fs3.stat(lockPath);
-          if (Date.now() - stat5.mtimeMs > LOCK_STALE_MS) {
-            await fs3.unlink(lockPath).catch(() => {
-            });
-            continue;
-          }
-        } catch {
-          continue;
-        }
-        await new Promise((r2) => setTimeout(r2, RETRY_INTERVAL_MS));
-      } else {
-        throw err;
-      }
-    }
-  }
-  await fs3.unlink(lockPath).catch(() => {
-  });
-  try {
-    const fd = await fs3.open(lockPath, "wx");
-    await fd.writeFile(JSON.stringify({ pid: process.pid, time: Date.now() }));
-    await fd.close();
-    return;
-  } catch {
-    throw new Error(`Failed to acquire lock: ${lockPath} (timeout after ${MAX_RETRIES * RETRY_INTERVAL_MS}ms)`);
-  }
-}
-async function releaseLock(lockPath) {
-  await fs3.unlink(lockPath).catch(() => {
-  });
-}
-async function withFileLock(projectDir2, fn) {
-  const lockPath = path6.join(projectDir2, ".memorix.lock");
-  await acquireLock(lockPath);
-  try {
-    return await fn();
-  } finally {
-    await releaseLock(lockPath);
-  }
-}
-async function atomicWriteFileOnce(filePath, data) {
-  const tmpPath = filePath + `.tmp.${process.pid}.${randomUUID()}`;
-  try {
-    await fs3.writeFile(tmpPath, data, "utf-8");
-    await fs3.rename(tmpPath, filePath);
-  } catch (error) {
-    await fs3.unlink(tmpPath).catch(() => {
-    });
-    throw error;
-  }
-}
-function atomicWriteFile(filePath, data) {
-  const previous = atomicWriteTails.get(filePath) ?? Promise.resolve();
-  const next = previous.catch(() => void 0).then(() => atomicWriteFileOnce(filePath, data));
-  atomicWriteTails.set(filePath, next);
-  return next.finally(() => {
-    if (atomicWriteTails.get(filePath) === next) atomicWriteTails.delete(filePath);
-  });
-}
-var LOCK_STALE_MS, RETRY_INTERVAL_MS, MAX_RETRIES, atomicWriteTails;
-var init_file_lock = __esm({
-  "src/store/file-lock.ts"() {
-    "use strict";
-    init_esm_shims();
-    LOCK_STALE_MS = 1e4;
-    RETRY_INTERVAL_MS = 50;
-    MAX_RETRIES = 60;
-    atomicWriteTails = /* @__PURE__ */ new Map();
-  }
-});
-
 // src/store/mini-skill-store.ts
 import path7 from "path";
 import fs4 from "fs";
@@ -143484,7 +143515,20 @@ function normalizeMiniMaxVideoRequest(input) {
   if (ratio !== "adaptive" && ratio !== "16:9" && ratio !== "9:16" && ratio !== "1:1") {
     throw new Error("MiniMax video ratio must be adaptive, 16:9, 9:16, or 1:1");
   }
-  return { region, model, prompt, resolution, duration, ratio };
+  let firstFrameImageUrl;
+  if (input.firstFrameImageUrl !== void 0) {
+    firstFrameImageUrl = input.firstFrameImageUrl.trim();
+    let parsed;
+    try {
+      parsed = new URL(firstFrameImageUrl);
+    } catch {
+      throw new Error("MiniMax first-frame image must be a public HTTPS URL");
+    }
+    if (parsed.protocol !== "https:" || parsed.username || parsed.password || sanitizeCredentials(firstFrameImageUrl) !== firstFrameImageUrl) {
+      throw new Error("MiniMax first-frame image must be an HTTPS URL without credentials");
+    }
+  }
+  return { region, model, prompt, resolution, duration, ratio, ...firstFrameImageUrl ? { firstFrameImageUrl } : {} };
 }
 function videoRequestConfig(input) {
   const normalized = normalizeMiniMaxVideoRequest(input);
@@ -143561,7 +143605,14 @@ async function createMiniMaxVideoTask(input, dependencies = {}) {
       headers: videoHeaders(config.apiKey),
       body: JSON.stringify({
         model: config.model,
-        content: [{ type: "text", text: config.prompt }],
+        content: [
+          { type: "text", text: config.prompt },
+          ...config.firstFrameImageUrl ? [{
+            type: "image_url",
+            image_url: { url: config.firstFrameImageUrl },
+            role: "first_frame"
+          }] : []
+        ],
         resolution: config.resolution,
         duration: config.duration,
         ratio: config.ratio
@@ -143722,10 +143773,19 @@ function parseStoredRequest(value) {
   const duration = value.duration;
   const ratio = value.ratio;
   const maxBytes = value.maxBytes;
-  if (provider2 !== "minimax" && provider2 !== "minimax-cn" || region !== "global" && region !== "cn" || model !== "MiniMax-H3" || typeof prompt !== "string" || resolution !== "2K" || duration !== 5 && duration !== 10 || ratio !== "adaptive" && ratio !== "16:9" && ratio !== "9:16" && ratio !== "1:1" || typeof maxBytes !== "number" || !Number.isSafeInteger(maxBytes) || maxBytes < 1) {
+  if (provider2 !== "minimax" && provider2 !== "minimax-cn" || region !== "global" && region !== "cn" || model !== "MiniMax-H3" || typeof prompt !== "string" || value.firstFrameImageUrl !== void 0 && typeof value.firstFrameImageUrl !== "string" || resolution !== "2K" || duration !== 5 && duration !== 10 || ratio !== "adaptive" && ratio !== "16:9" && ratio !== "9:16" && ratio !== "1:1" || typeof maxBytes !== "number" || !Number.isSafeInteger(maxBytes) || maxBytes < 1) {
     throw new Error("Media video job has an invalid request payload");
   }
-  return { provider: provider2, region, model, prompt, resolution, duration, ratio, maxBytes };
+  const normalized = normalizeMiniMaxVideoRequest({
+    region,
+    model,
+    prompt,
+    resolution,
+    duration,
+    ratio,
+    firstFrameImageUrl: value.firstFrameImageUrl
+  });
+  return { provider: provider2, ...normalized, maxBytes };
 }
 function mediaJobIdFromMaintenance(job) {
   const mediaJobId = job.payload.mediaJobId;
@@ -143737,6 +143797,7 @@ function mediaJobIdFromMaintenance(job) {
 function toVideoRequest(request) {
   return {
     prompt: request.prompt,
+    firstFrameImageUrl: request.firstFrameImageUrl,
     model: request.model,
     region: request.region,
     resolution: request.resolution,
@@ -143828,6 +143889,7 @@ function queueMiniMaxVideoGeneration(input) {
     region: normalized.region,
     model: normalized.model,
     prompt: normalized.prompt,
+    ...normalized.firstFrameImageUrl ? { firstFrameImageUrl: normalized.firstFrameImageUrl } : {},
     resolution: normalized.resolution,
     duration: normalized.duration,
     ratio: normalized.ratio,

package/dist/media-audio-runner.js

@@ -805,18 +805,21 @@ CREATE TABLE IF NOT EXISTS chat_transcript (
 `;
     CREATE_GRAPH_ENTITIES_TABLE = `
 CREATE TABLE IF NOT EXISTS graph_entities (
-  name            TEXT PRIMARY KEY,
+  projectId       TEXT NOT NULL,
+  name            TEXT NOT NULL,
   entityType      TEXT NOT NULL DEFAULT '',
-  observations    TEXT NOT NULL DEFAULT '[]'
+  observations    TEXT NOT NULL DEFAULT '[]',
+  PRIMARY KEY (projectId, name)
 );
 `;
     CREATE_GRAPH_RELATIONS_TABLE = `
 CREATE TABLE IF NOT EXISTS graph_relations (
   id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  projectId       TEXT NOT NULL,
   from_entity     TEXT NOT NULL,
   to_entity       TEXT NOT NULL,
   relationType    TEXT NOT NULL DEFAULT '',
-  UNIQUE(from_entity, to_entity, relationType)
+  UNIQUE(projectId, from_entity, to_entity, relationType)
 );
 `;
     CREATE_CODE_FILES_TABLE = `
@@ -2697,6 +2700,21 @@ var init_sqlite_reliability = __esm({
 import { promises as fs2 } from "fs";
 import { randomUUID as randomUUID3 } from "crypto";
 import path4 from "path";
+function canReclaimStaleLock(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    const pid = Number(parsed.pid);
+    if (!Number.isSafeInteger(pid) || pid < 1) return true;
+    try {
+      process.kill(pid, 0);
+      return false;
+    } catch (error) {
+      return error.code !== "EPERM";
+    }
+  } catch {
+    return true;
+  }
+}
 async function acquireLock(lockPath) {
   for (let i2 = 0; i2 < MAX_RETRIES; i2++) {
     try {
@@ -2710,9 +2728,12 @@ async function acquireLock(lockPath) {
         try {
           const stat5 = await fs2.stat(lockPath);
           if (Date.now() - stat5.mtimeMs > LOCK_STALE_MS) {
-            await fs2.unlink(lockPath).catch(() => {
-            });
-            continue;
+            const raw2 = await fs2.readFile(lockPath, "utf8").catch(() => "");
+            if (canReclaimStaleLock(raw2)) {
+              await fs2.unlink(lockPath).catch(() => {
+              });
+              continue;
+            }
           }
         } catch {
           continue;
@@ -2723,6 +2744,10 @@ async function acquireLock(lockPath) {
       }
     }
   }
+  const raw = await fs2.readFile(lockPath, "utf8").catch(() => "");
+  if (!canReclaimStaleLock(raw)) {
+    throw new Error(`Failed to acquire lock: ${lockPath} (owner is still running)`);
+  }
   await fs2.unlink(lockPath).catch(() => {
   });
   try {
@@ -6653,6 +6678,7 @@ var init_sqlite_store = __esm({
     init_sqlite_db();
     init_sqlite_reliability();
     init_sqlite_fts();
+    init_file_lock();
     SqliteBackend = class {
       db = null;
       dataDir = "";
@@ -6816,38 +6842,43 @@ var init_sqlite_store = __esm({
       }
       // ── Migration ────────────────────────────────────────────────────
       async migrateFromJsonIfNeeded() {
-        const count2 = this.db.prepare(`SELECT COUNT(*) AS cnt FROM observations`).get();
-        if (count2.cnt > 0) return;
         const jsonPath = path7.join(this.dataDir, "observations.json");
         if (!fs4.existsSync(jsonPath)) return;
-        try {
+        await withFileLock(this.dataDir, async () => {
+          const count2 = this.db.prepare(`SELECT COUNT(*) AS cnt FROM observations`).get();
+          if (count2.cnt > 0) return;
           const raw = fs4.readFileSync(jsonPath, "utf-8");
-          const observations2 = JSON.parse(raw);
+          const parsed = JSON.parse(raw);
+          if (!Array.isArray(parsed)) {
+            throw new Error("[memorix] observations.json migration refused: expected a JSON array");
+          }
+          const observations2 = parsed;
           if (observations2.length === 0) return;
+          if (observations2.some((obs) => !obs || !Number.isSafeInteger(obs.id) || obs.id < 1 || typeof obs.projectId !== "string")) {
+            throw new Error("[memorix] observations.json migration refused: invalid observation record");
+          }
           console.error(`[memorix] Migrating ${observations2.length} observations from JSON to SQLite...`);
           const insertMany = this.db.transaction((obsList) => {
             for (const obs of obsList) {
               this.stmtInsert.run(obsToRow(obs));
             }
-          });
-          insertMany(observations2);
-          const counterPath = path7.join(this.dataDir, "counter.json");
-          if (fs4.existsSync(counterPath)) {
-            try {
+            const counterPath = path7.join(this.dataDir, "counter.json");
+            let counterNextId;
+            if (fs4.existsSync(counterPath)) {
               const counterData = JSON.parse(fs4.readFileSync(counterPath, "utf-8"));
-              const nextId2 = counterData.nextId ?? counterData.next_id ?? Math.max(...observations2.map((o) => o.id)) + 1;
-              this.rawSaveIdCounter(nextId2);
-            } catch {
-              this.rawSaveIdCounter(Math.max(...observations2.map((o) => o.id)) + 1);
+              const candidate = counterData.nextId ?? counterData.next_id;
+              if (candidate !== void 0 && (!Number.isSafeInteger(candidate) || Number(candidate) < 1)) {
+                throw new Error("[memorix] counter.json migration refused: nextId must be a positive integer");
+              }
+              counterNextId = candidate === void 0 ? void 0 : Number(candidate);
             }
-          } else {
-            this.rawSaveIdCounter(Math.max(...observations2.map((o) => o.id)) + 1);
-          }
-          this.bumpGeneration();
+            const maxId = Math.max(...obsList.map((obs) => obs.id));
+            this.rawSaveIdCounter(Math.max(counterNextId ?? 1, maxId + 1));
+            this.bumpGeneration();
+          });
+          insertMany(observations2);
           console.error(`[memorix] Migration complete. ${observations2.length} observations now in SQLite.`);
-        } catch (err) {
-          console.error(`[memorix] JSON\u2192SQLite migration failed (non-fatal, data preserved in JSON): ${err}`);
-        }
+        });
       }
       // ── Public read ──────────────────────────────────────────────────
       async loadAll() {
@@ -143409,7 +143440,20 @@ function normalizeMiniMaxVideoRequest(input) {
   if (ratio !== "adaptive" && ratio !== "16:9" && ratio !== "9:16" && ratio !== "1:1") {
     throw new Error("MiniMax video ratio must be adaptive, 16:9, 9:16, or 1:1");
   }
-  return { region, model, prompt, resolution, duration, ratio };
+  let firstFrameImageUrl;
+  if (input.firstFrameImageUrl !== void 0) {
+    firstFrameImageUrl = input.firstFrameImageUrl.trim();
+    let parsed;
+    try {
+      parsed = new URL(firstFrameImageUrl);
+    } catch {
+      throw new Error("MiniMax first-frame image must be a public HTTPS URL");
+    }
+    if (parsed.protocol !== "https:" || parsed.username || parsed.password || sanitizeCredentials(firstFrameImageUrl) !== firstFrameImageUrl) {
+      throw new Error("MiniMax first-frame image must be an HTTPS URL without credentials");
+    }
+  }
+  return { region, model, prompt, resolution, duration, ratio, ...firstFrameImageUrl ? { firstFrameImageUrl } : {} };
 }
 function videoRequestConfig(input) {
   const normalized = normalizeMiniMaxVideoRequest(input);
@@ -143486,7 +143530,14 @@ async function createMiniMaxVideoTask(input, dependencies = {}) {
       headers: videoHeaders(config.apiKey),
       body: JSON.stringify({
         model: config.model,
-        content: [{ type: "text", text: config.prompt }],
+        content: [
+          { type: "text", text: config.prompt },
+          ...config.firstFrameImageUrl ? [{
+            type: "image_url",
+            image_url: { url: config.firstFrameImageUrl },
+            role: "first_frame"
+          }] : []
+        ],
         resolution: config.resolution,
         duration: config.duration,
         ratio: config.ratio
@@ -143647,10 +143698,19 @@ function parseStoredRequest(value) {
   const duration = value.duration;
   const ratio = value.ratio;
   const maxBytes = value.maxBytes;
-  if (provider2 !== "minimax" && provider2 !== "minimax-cn" || region !== "global" && region !== "cn" || model !== "MiniMax-H3" || typeof prompt !== "string" || resolution !== "2K" || duration !== 5 && duration !== 10 || ratio !== "adaptive" && ratio !== "16:9" && ratio !== "9:16" && ratio !== "1:1" || typeof maxBytes !== "number" || !Number.isSafeInteger(maxBytes) || maxBytes < 1) {
+  if (provider2 !== "minimax" && provider2 !== "minimax-cn" || region !== "global" && region !== "cn" || model !== "MiniMax-H3" || typeof prompt !== "string" || value.firstFrameImageUrl !== void 0 && typeof value.firstFrameImageUrl !== "string" || resolution !== "2K" || duration !== 5 && duration !== 10 || ratio !== "adaptive" && ratio !== "16:9" && ratio !== "9:16" && ratio !== "1:1" || typeof maxBytes !== "number" || !Number.isSafeInteger(maxBytes) || maxBytes < 1) {
     throw new Error("Media video job has an invalid request payload");
   }
-  return { provider: provider2, region, model, prompt, resolution, duration, ratio, maxBytes };
+  const normalized = normalizeMiniMaxVideoRequest({
+    region,
+    model,
+    prompt,
+    resolution,
+    duration,
+    ratio,
+    firstFrameImageUrl: value.firstFrameImageUrl
+  });
+  return { provider: provider2, ...normalized, maxBytes };
 }
 function mediaJobIdFromMaintenance(job) {
   const mediaJobId = job.payload.mediaJobId;
@@ -143662,6 +143722,7 @@ function mediaJobIdFromMaintenance(job) {
 function toVideoRequest(request) {
   return {
     prompt: request.prompt,
+    firstFrameImageUrl: request.firstFrameImageUrl,
     model: request.model,
     region: request.region,
     resolution: request.resolution,
@@ -143753,6 +143814,7 @@ function queueMiniMaxVideoGeneration(input) {
     region: normalized.region,
     model: normalized.model,
     prompt: normalized.prompt,
+    ...normalized.firstFrameImageUrl ? { firstFrameImageUrl: normalized.firstFrameImageUrl } : {},
     resolution: normalized.resolution,
     duration: normalized.duration,
     ratio: normalized.ratio,