Skip to content

Open-source AI browser agent for Chrome and Firefox (monorepo) 🧠

9.5 KB
Raw Blame
import assert from 'node:assert/strict';
import test from 'node:test';
import fs from 'node:fs/promises';

const oneSecond = new Uint8Array(await fs.readFile(new URL('./fixtures/video/h264-aac-1.mp4', import.meta.url)));
const { joinMp4Clips } = await import('../src/chrome/src/agent/video-join.js');
const sixtyOneSeconds = joinMp4Clips(Array.from({ length: 61 }, () => oneSecond)).bytes;
const differentSize = new Uint8Array(await fs.readFile(new URL('./fixtures/video/h264-aac-48px.mp4', import.meta.url)));

// Scene delivery stores generated bytes locally. This small in-memory store
// keeps these tests independent from browser installation and paid providers.
const assets = new Map();
globalThis.indexedDB = { open() {
  const request = { result: { close() {}, transaction() {
    const transaction = { objectStore: () => ({ put(record) {
      assets.set(record.id, record);
      setTimeout(() => transaction.oncomplete?.());
    } }) };
    return transaction;
  } } };
  setTimeout(() => request.onsuccess?.());
  return request;
} };

const model = 'minimax/h3/text-to-video';
const config = { provider: 'fal', apiKey: 'private-fal-key', videoModel: model };
const json = (body, status = 200) => new Response(JSON.stringify(body), {
  status, headers: { 'Content-Type': 'application/json' },
});
const openapi = {
  openapi: '3.0.4', paths: { '/model': { post: { requestBody: { content: {
    'application/json': { schema: { type: 'object', properties: {
      prompt: { type: 'string' }, duration: { type: 'integer', minimum: 1, maximum: 64 },
    } } },
  } } } } },
};

function api({ download = () => new Response(oneSecond, { headers: { 'Content-Type': 'video/mp4' } }) } = {}) {
  const calls = { submits: [], downloads: [] };
  const fetchImpl = async (url, init = {}) => {
    assert.equal(init.credentials, 'omit');
    if (url.startsWith('https://v3b.fal.media/')) {
      assert.equal(init.headers, undefined, 'verification never sends the provider key');
      const index = Number(/clip-(\d+)\.mp4$/.exec(url)[1]);
      calls.downloads.push(index);
      return download(index, init);
    }
    assert.equal(init.redirect, 'error');
    assert.equal(init.headers.Authorization, `Key ${config.apiKey}`);
    if (url.startsWith('https://api.fal.ai/v1/models?')) return json({ models: [{ endpoint_id: model, openapi }] });
    assert.ok(url.startsWith(`https://queue.fal.run/${model}`), url);
    if (init.method === 'POST') {
      const index = calls.submits.push(JSON.parse(init.body)) - 1;
      const job = `https://queue.fal.run/${model}/requests/job-${index}`;
      return json({ request_id: `job-${index}`, status_url: `${job}/status`, response_url: job });
    }
    const [, index, status] = /\/requests\/job-(\d+)(\/status)?$/.exec(url);
    return status ? json({ status: 'COMPLETED' })
      : json({ video: { url: `https://v3b.fal.media/clip-${index}.mp4` } });
  };
  return { calls, fetchImpl };
}

for (const build of ['chrome', 'firefox']) {
  const { generateImage } = await import(`../src/${build}/src/agent/generative-media.js`);
  const generate = (mock, args = {}, options = {}) => generateImage({
    prompt: 'Consistent cast, plain background.', media: 'video', duration: 1, estimated_duration: 1, ...args,
  }, { config, fetchImpl: mock.fetchImpl, pollIntervalMs: 1, ...options });

  test(`${build}: hosted duration verification is opt-in and preserves the URL`, async () => {
    const plain = api();
    const unmeasured = await generate(plain);
    assert.equal(unmeasured.success, true, unmeasured.error);
    assert.equal(unmeasured.durationStatus, 'unverified');
    assert.deepEqual(plain.calls.downloads, []);
    const mock = api();
    const result = await generate(mock, {}, { verifyVideoDuration: true });
    assert.equal(result.success, true, result.error);
    assert.equal(result.url, 'https://v3b.fal.media/clip-0.mp4');
    assert.deepEqual([result.durationSeconds, result.estimatedSeconds, result.plannedSeconds, result.durationStatus, result.mimeType],
      [1, 1, 1, 'enough', 'video/mp4']);
    assert.equal(result.approvedDurationSeconds, undefined);
    assert.equal(result.notice, undefined);
    assert.deepEqual(mock.calls.downloads, [0]);
    assert.equal(mock.calls.submits.length, 1);
  });

  test(`${build}: measured hosted output compares against the requested duration, not rounded plan`, async () => {
    const mock = api({ download: () => new Response(sixtyOneSeconds) });
    const result = await generate(mock, { duration: 64, estimated_duration: 60 }, { verifyVideoDuration: true });
    assert.equal(result.success, true, result.error);
    assert.deepEqual([result.durationSeconds, result.estimatedSeconds, result.plannedSeconds, result.durationStatus],
      [61, 60, 64, 'enough']);
    assert.equal(result.notice, undefined);
    assert.equal(result.approvedDurationSeconds, undefined);
  });

  test(`${build}: a measured short hosted clip remains a successful paid asset with a shortfall`, async () => {
    const mock = api();
    const result = await generate(mock, { duration: 8, estimated_duration: 8 }, { verifyVideoDuration: true });
    assert.equal(result.success, true, result.error);
    assert.equal(result.url, 'https://v3b.fal.media/clip-0.mp4');
    assert.equal(result.durationSeconds, 1);
    assert.equal(result.durationStatus, 'short');
    assert.match(result.notice, /accepted target is 8 s/);
    assert.equal(mock.calls.submits.length, 1);
  });

  test(`${build}: failed hosted verification keeps the paid URL unverified`, async () => {
    for (const download of [
      () => json({ error: 'Unavailable' }, 503),
      () => new Response('not an MP4'),
      () => { throw new TypeError('Download failed'); },
      () => { throw new DOMException('Verification deadline exceeded', 'TimeoutError'); },
    ]) {
      const mock = api({ download });
      const result = await generate(mock, {}, { verifyVideoDuration: true });
      assert.equal(result.success, true, result.error);
      assert.equal(result.url, 'https://v3b.fal.media/clip-0.mp4');
      assert.equal(result.durationStatus, 'unverified');
      assert.equal(result.durationSeconds, undefined);
      assert.match(result.notice, /asset was kept/);
      assert.match(result.notice, /could not be verified/);
      assert.equal(mock.calls.submits.length, 1, 'verification does not generate another paid clip');
    }
  });

  test(`${build}: Stop during hosted verification keeps the completed asset`, async () => {
    const controller = new AbortController();
    const mock = api({ download: (_index, init) => {
      controller.abort(new DOMException('Stopped by user', 'AbortError'));
      assert.equal(init.signal.aborted, true);
      throw init.signal.reason;
    } });
    const result = await generate(mock, {}, { verifyVideoDuration: true, signal: controller.signal });
    assert.equal(result.success, true, result.error);
    assert.equal(result.url, 'https://v3b.fal.media/clip-0.mp4');
    assert.equal(result.durationStatus, 'unverified');
    assert.equal(mock.calls.submits.length, 1);
  });

  test(`${build}: a plain hosted video is not downloaded without a duration target`, async () => {
    const mock = api();
    const result = await generate(mock, { duration: undefined, estimated_duration: undefined }, { verifyVideoDuration: true });
    assert.equal(result.success, true, result.error);
    assert.deepEqual(mock.calls.downloads, []);
    assert.equal(result.durationSeconds, undefined);
  });

  test(`${build}: only an accepted over-limit shortening produces a trusted approved duration`, async () => {
    const mock = api();
    let asked;
    const result = await generate(mock, { duration: undefined, estimated_duration: 330,
      approvedDurationSeconds: 1, scenes: [{ prompt: 'First part', duration: 1 }, { prompt: 'Second part', duration: 1 }] },
    { confirmVideoLength: async details => { asked = { ...details }; return 'once'; } });
    assert.equal(result.success, true, result.error);
    assert.deepEqual(asked, { estimatedSeconds: 330, totalSeconds: 2, clipCount: 2, maxSeconds: 120 });
    assert.deepEqual([result.estimatedSeconds, result.approvedDurationSeconds, result.plannedSeconds, result.durationSeconds, result.durationStatus],
      [330, 2, 2, 2, 'enough']);
    assert.ok(assets.has(result.mediaId));
    const withinLimit = api();
    const ordinary = await generate(withinLimit, { approvedDurationSeconds: 1 }, { verifyVideoDuration: true });
    assert.equal(ordinary.approvedDurationSeconds, undefined, 'tool arguments cannot forge approval');
    const declined = api();
    const stopped = await generate(declined, { duration: undefined, estimated_duration: 330,
      scenes: [{ prompt: 'Short version', duration: 1 }] }, { confirmVideoLength: async () => 'deny' });
    assert.equal(stopped.declined, true);
    assert.equal(stopped.approvedDurationSeconds, undefined);
    assert.equal(declined.calls.submits.length, 0);
  });

  test(`${build}: approved duration does not hide an unsuccessful join`, async () => {
    const mock = api({ download: index => new Response(index ? differentSize : oneSecond) });
    const result = await generate(mock, { duration: undefined, estimated_duration: 330,
      scenes: [{ prompt: 'First part', duration: 1 }, { prompt: 'Second part', duration: 1 }] },
    { confirmVideoLength: async () => 'once' });
    assert.equal(result.success, true, result.error);
    assert.equal(result.approvedDurationSeconds, 2);
    assert.equal(result.durationStatus, 'enough');
    assert.equal(result.joined, false);
    assert.equal(result.clips.length, 2);
    assert.ok(result.clips.every(clip => assets.has(clip.mediaId)));
  });
}