Open-source AI browser agent for Chrome and Firefox (monorepo) ðŸ§
JavaScript ai-agentai-agentsai-toolsbrowser-aibrowser-automationbrowser-extensionchrome-aichrome-devtoolschrome-extensionchrome-extensionsfirefox-addonfirefox-addonsfirefox-extensionfirefox-extensionsgemmagemma4minimaxoffline-aioffline-llmqwen
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)));
});
}