Skip to content

PRINTFILM: AI short-video marketing and AI short-drama creation platform

25.7 KB
Raw Blame
"""Studio integration tests: real SQL and lifecycle, isolated local database, no providers."""

import asyncio
import json
from datetime import UTC, datetime, timedelta
from io import BytesIO
from types import SimpleNamespace
from unittest.mock import AsyncMock

import httpx
import pytest
from fastapi import FastAPI
from sqlalchemy import select
from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine

from app.config import get_settings
from app.database import Base, get_db
from app.deps import get_current_user
from app.models import ToolRun, User
from app.models import UsageEvent
from app.models_tasks import TaskRun, TaskStep
from PIL import Image
from app.services import studio_generation as generation
from app.services.tasks import executor, scheduler
from app.services.tasks.queues import task_queue


@pytest.fixture
async def studio(monkeypatch):
    # Register FKs without starting the API or connecting to its configured database.
    import app.main  # noqa: F401
    engine = create_async_engine("sqlite+aiosqlite:///:memory:")
    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)
    sessions = async_sessionmaker(engine, expire_on_commit=False)
    monkeypatch.setattr(generation, "AsyncSessionLocal", sessions)
    monkeypatch.setattr(executor, "AsyncSessionLocal", sessions)
    monkeypatch.setattr(scheduler, "AsyncSessionLocal", sessions)
    monkeypatch.setattr(get_settings(), "billing_enabled", False)
    monkeypatch.setattr(generation, "ensure_public_urls", lambda urls: list(urls or []))
    async with sessions() as db:
        user = User(email="[email protected]", hashed_password="test", balance_fen=100000)
        other = User(email="[email protected]", hashed_password="test", balance_fen=100000)
        db.add_all([user, other])
        await db.commit()
    yield sessions, user, other
    await engine.dispose()


@pytest.mark.parametrize("kind,payload,queue", [
    ("script_summary", {}, "text"), ("voice_synthesis", {}, "text"), ("tool_audio", {}, "text"),
    ("asset_image", {}, "image"), ("tool_image", {}, "image"), ("shot_regen_image", {}, "image"),
    ("fragment_video", {}, "video"), ("asset_video", {}, "video"),
    ("project_pipeline", {"phase": "script"}, "text"), ("project_pipeline", {"phase": "assets"}, "image"),
    ("project_pipeline", {"phase": "videos"}, "video"),
])
def test_queue_routing(kind, payload, queue):
    assert task_queue(kind, payload) == queue


async def enqueue(sessions, user, tool_id="t2i"):
    async with sessions() as db:
        data = await generation.enqueue_generation(db, user, tool_id=tool_id, prompt="A sunny forest",
            params={"duration": "5s", "voice": "narrator_calm"}, files=[])
        await db.commit()
    return data


async def test_submission_is_durable_before_generation(studio, monkeypatch):
    sessions, user, _ = studio
    provider = AsyncMock()
    monkeypatch.setattr(generation, "run_image_tool", provider)
    data = await enqueue(sessions, user)
    async with sessions() as db:
        task = await db.get(TaskRun, data["platform_task_id"])
        row = await db.get(ToolRun, data["run_id"])
        assert task.queue_type == "image" and task.status == "pending"
        assert task.next_action_at is not None
        assert row.task_id == f"task-{task.id}"
        assert row.params["billing_task_id"] == task.id
        assert (await db.execute(select(TaskStep).where(TaskStep.task_id == task.id))).scalar_one()
    provider.assert_not_awaited()


async def test_image_execution_uses_one_task_and_reuses_saved_result(studio, monkeypatch):
    sessions, user, _ = studio
    provider = AsyncMock(return_value={"kind": "image", "urls": ["https://cdn.test/image.png"], "status": "succeeded"})
    monkeypatch.setattr(generation, "run_image_tool", provider)
    data = await enqueue(sessions, user)
    await executor.execute_task_run(data["platform_task_id"])
    async with sessions() as db:
        row = await db.get(ToolRun, data["run_id"])
        task = await generation.sync_generation_record(db, row)
        assert task.status == row.status == "succeeded"
        assert row.urls == ["https://cdn.test/image.png"]
        assert task.progress_percent == 100 and task.finished_at is not None
        assert len((await db.execute(select(TaskRun))).scalars().all()) == 1
        await generation.execute_generation(task)
    provider.assert_awaited_once()


async def test_audio_runs_on_text_queue_and_returns_audio(studio, monkeypatch):
    sessions, user, _ = studio
    tts = AsyncMock(return_value="https://cdn.test/narration.mp3")
    monkeypatch.setattr("app.services.ark.get_ark", lambda: SimpleNamespace(tts=tts))
    usage = AsyncMock()
    monkeypatch.setattr("app.services.billing.record_line", usage)
    data = await enqueue(sessions, user, "audio")
    await executor.execute_task_run(data["platform_task_id"])
    async with sessions() as db:
        row = await db.get(ToolRun, data["run_id"])
        task = await generation.sync_generation_record(db, row)
        assert task.queue_type == "text" and row.status == "succeeded"
        assert row.urls == ["https://cdn.test/narration.mp3"]
    assert tts.await_args.kwargs["shot_no"] == data["run_id"]
    usage.assert_awaited_once()


async def test_video_resumes_existing_provider_id_and_polls_without_billing(studio, monkeypatch):
    sessions, user, _ = studio
    submit = AsyncMock(return_value={"task_id": "upstream-video-123", "preview_url": "https://cdn.test/frame.png"})
    poll = AsyncMock(return_value={"status": "succeeded", "kind": "video", "urls": ["https://cdn.test/movie.mp4"], "usage": {"total_tokens": 100}})
    usage = AsyncMock()
    monkeypatch.setattr(generation, "start_video_tool", submit)
    monkeypatch.setattr(generation, "poll_video_task", poll)
    monkeypatch.setattr("app.services.drama.billing_util.record_seedance_video_usage", usage)
    data = await enqueue(sessions, user, "t2v")
    task_id = data["platform_task_id"]
    await executor.execute_task_run(task_id)
    async with sessions() as db:
        task = await db.get(TaskRun, task_id)
        assert task.status == "awaiting_poll" and task.provider_task_id == "upstream-video-123"
        await generation.execute_generation(task)
    submit.assert_awaited_once()
    await generation.poll_generation_video(task_id)
    await generation.poll_generation_video(task_id)
    async with sessions() as db:
        row = await db.get(ToolRun, data["run_id"])
        task = await db.get(TaskRun, task_id)
        assert row.status == task.status == "succeeded"
        assert row.urls == ["https://cdn.test/movie.mp4"]
        assert task.provider_status == "succeeded"
    poll.assert_awaited_once()
    usage.assert_awaited_once()


async def test_failed_generation_remains_visible_in_history(studio, monkeypatch):
    sessions, user, _ = studio
    monkeypatch.setattr(generation, "run_image_tool", AsyncMock(side_effect=RuntimeError("provider unavailable")))
    data = await enqueue(sessions, user)
    await executor.execute_task_run(data["platform_task_id"])
    async with sessions() as db:
        row = await db.get(ToolRun, data["run_id"])
        await generation.sync_generation_record(db, row)
        assert row.status == "failed" and "provider unavailable" in row.error


async def test_full_image_lane_does_not_block_text_or_video(studio, monkeypatch):
    sessions, user, _ = studio
    settings = get_settings()
    for queue in ("text", "image", "video"):
        monkeypatch.setattr(settings, f"task_queue_{queue}_concurrency", 1)
    monkeypatch.setattr(settings, "task_user_max_concurrency", 1)
    monkeypatch.setattr(scheduler, "_running_jobs", {})
    monkeypatch.setattr(scheduler, "_running_queues", {})
    monkeypatch.setattr(scheduler, "_cancel_jobs", {})
    monkeypatch.setattr(scheduler, "_run_one", AsyncMock())
    await enqueue(sessions, user, "t2i")
    await enqueue(sessions, user, "t2i")
    await enqueue(sessions, user, "audio")
    await enqueue(sessions, user, "t2v")
    await scheduler._tick()
    await asyncio.sleep(0)
    async with sessions() as db:
        rows = (await db.execute(select(TaskRun))).scalars().all()
        assert sorted(task.queue_type for task in rows if task.status == "leased") == ["image", "text", "video"]
        assert sum(task.status == "pending" for task in rows) == 1


async def test_balance_failure_before_provider_is_exposed(studio, monkeypatch):
    sessions, user, _ = studio
    data = await enqueue(sessions, user)
    provider = AsyncMock()
    monkeypatch.setattr(generation, "run_image_tool", provider)
    monkeypatch.setattr(executor, "freeze_for_task", AsyncMock(side_effect=ValueError("insufficient balance")))
    await executor.execute_task_run(data["platform_task_id"])
    async with sessions() as db:
        row = await db.get(ToolRun, data["run_id"])
        task = await generation.sync_generation_record(db, row)
        assert task.error_code == "insufficient_balance" and row.status == "failed"
    provider.assert_not_awaited()


async def test_generation_freezes_and_settles_one_task_once(studio, monkeypatch):
    from app.services.billing import record_line
    sessions, user, _ = studio
    monkeypatch.setattr(get_settings(), "billing_enabled", True)
    async def provider(db, owner, **_kwargs):
        await record_line(db, user_id=owner.id, billing_key="seedream", model="test-image", tokens=45000,
                          estimated=True, domain="studio")
        return {"kind": "image", "status": "succeeded", "urls": ["https://cdn.test/paid.png"]}
    generate = AsyncMock(side_effect=provider)
    monkeypatch.setattr(generation, "run_image_tool", generate)
    data = await enqueue(sessions, user)
    await executor.execute_task_run(data["platform_task_id"])
    async with sessions() as db:
        task = await db.get(TaskRun, data["platform_task_id"])
        owner = await db.get(User, user.id)
        assert task.billing_status == "settled"
        assert owner.frozen_fen == 0
        assert owner.balance_fen == 100000 - task.billing_charged_fen
        await generation.execute_generation(task)
        events = (await db.execute(select(UsageEvent).where(UsageEvent.task_run_id == task.id))).scalars().all()
        assert len(events) == 1
    generate.assert_awaited_once()


async def test_history_filters_counts_provider_id_and_ownership(studio):
    from app.api.tools import router
    sessions, user, other = studio
    first = await enqueue(sessions, user)
    await enqueue(sessions, user, "audio")
    hidden = await enqueue(sessions, other)
    async with sessions() as db:
        task = await db.get(TaskRun, first["platform_task_id"])
        task.status = "succeeded"
        task.provider_task_id = "find-upstream-id"
        await db.commit()
    api = FastAPI()
    api.include_router(router, prefix="/api")
    api.dependency_overrides[get_current_user] = lambda: user
    async def database():
        async with sessions() as db:
            yield db
    api.dependency_overrides[get_db] = database
    async with httpx.AsyncClient(transport=httpx.ASGITransport(app=api), base_url="http://test") as client:
        result = (await client.get("/api/tools/runs?kind=image&status=succeeded&task_id=find-upstream-id")).json()
        assert result["total"] == 1 and result["counts"] == {"succeeded": 1, "all": 1}
        assert result["items"][0]["platform_task_id"] == first["platform_task_id"]
        assert "file_paths" not in result["items"][0]["params"]
        assert (await client.get(f"/api/tools/tasks/{hidden['task_id']}")).status_code == 404
        assert (await client.get(f"/api/tools/runs/{hidden['run_id']}")).status_code == 404
        assert (await client.get("/api/tools/runs?kind=unsupported")).status_code == 422
        assert (await client.get("/api/tools/runs?created_from=2026-10-22T00:00:00Z&created_to=2026-10-20T00:00:00Z")).status_code == 400


async def test_live_remote_lease_is_not_recovered(studio, monkeypatch):
    sessions, user, _ = studio
    data = await enqueue(sessions, user)
    async with sessions() as db:
        task = await db.get(TaskRun, data["platform_task_id"])
        task.status = "running"
        task.updated_at = datetime.now(UTC) - timedelta(minutes=20)
        task.lease_until = datetime.now(UTC) + timedelta(minutes=2)
        await db.commit()
    monkeypatch.setattr(scheduler, "_running_jobs", {})
    assert await scheduler.recover_orphaned_tasks() == 0
    async with sessions() as db:
        task = await db.get(TaskRun, data["platform_task_id"])
        task.lease_until = datetime.now(UTC) - timedelta(minutes=1)
        task.updated_at = datetime.now(UTC) - timedelta(minutes=20)
        await db.commit()
    assert await scheduler.recover_orphaned_tasks() == 1


@pytest.fixture
async def studio_api(studio, monkeypatch, tmp_path):
    from app.api.tools import router
    from app.services import studio_tools
    sessions, user, _ = studio
    api = FastAPI()
    api.include_router(router, prefix="/api")
    api.dependency_overrides[get_current_user] = lambda: user
    async def database():
        async with sessions() as db:
            yield db
    api.dependency_overrides[get_db] = database
    monkeypatch.setattr(studio_tools, "tools_dir", lambda _user_id: tmp_path)
    async with httpx.AsyncClient(transport=httpx.ASGITransport(app=api), base_url="http://test") as client:
        yield client


async def add_reference_asset(sessions, user, *, kind="image", name="Reference", team_id=None, url=None, cover=None):
    from app.models_drama import DramaAsset, DramaProject
    async with sessions() as db:
        project = DramaProject(user_id=user.id, title="References", team_id=team_id)
        db.add(project)
        await db.flush()
        asset = DramaAsset(project_id=project.id, type=kind, asset_type="image", name=name,
                           url=url, cover=cover)
        db.add(asset)
        await db.commit()
    return asset


def video_request(**overrides):
    return {"tool_id": "t2v", "model_id": "seedance-2.0-fast", "video_mode": "text_to_video",
            "prompt": "A sunny forest", "duration": "6s", "resolution": "720p", "ratio": "16:9",
            "references": [], **overrides}


def png_bytes():
    output = BytesIO()
    Image.new("RGB", (16, 16), "green").save(output, "PNG")
    return output.getvalue()


async def test_reference_library_filters_media_and_personal_ownership(studio, studio_api):
    sessions, user, other = studio
    image = await add_reference_asset(sessions, user, kind="character", name="Alice", cover="https://cdn.test/alice.png")
    video = await add_reference_asset(sessions, user, kind="video", name="Forest", url="https://cdn.test/forest.mp4", cover="https://cdn.test/forest.jpg")
    voice = await add_reference_asset(sessions, user, kind="voice", name="Narrator", url="https://cdn.test/narrator.mp3")
    await add_reference_asset(sessions, user, kind="voice", name="No recording", cover="https://cdn.test/voice-cover.png")
    await add_reference_asset(sessions, other, kind="character", cover="https://cdn.test/private.png")
    await add_reference_asset(sessions, user, kind="character", team_id=987, cover="https://cdn.test/team.png")
    result = (await studio_api.get("/api/tools/reference-assets?page_size=2")).json()
    assert result["total"] == 3 and len(result["items"]) == 2
    for kind, asset in (("image", image), ("video", video), ("audio", voice)):
        response = await studio_api.get(f"/api/tools/reference-assets?kind={kind}")
        assert response.status_code == 200
        assert [(item["id"], item["media_kind"]) for item in response.json()["items"]] == [(asset.id, kind)]
    searched = (await studio_api.get("/api/tools/reference-assets?q=Alice")).json()
    assert searched["total"] == 1 and searched["items"][0]["id"] == image.id


async def test_text_video_has_no_helper_image_and_preserves_selected_settings(studio, studio_api, monkeypatch):
    from app.services import studio_tools
    sessions, _, _ = studio
    create = AsyncMock(return_value="text-provider-task")
    image = AsyncMock()
    monkeypatch.setattr(studio_tools, "get_ark", lambda: SimpleNamespace(gen_video_seedance_body=create, gen_image=image))
    request = video_request()
    response = await studio_api.post("/api/tools/run", data={**request, "references": json.dumps(request["references"])})
    assert response.status_code == 200
    task_id = response.json()["platform_task_id"]
    await executor.execute_task_run(task_id)
    async with sessions() as db:
        task = await db.get(TaskRun, task_id)
        assert task.status == "awaiting_poll"
        assert len(task.billing_snapshot["items"]) == 1
        assert task.billing_snapshot["items"][0]["capability"] == "video"
        assert not task.billing_snapshot["items"][0]["params"]["reference_images"]
    body = create.await_args.args[0]
    assert body["model"] == "seedance-2.0-fast" and body["resolution"] == "720p"
    assert body["duration"] == 6 and body["ratio"] == "16:9"
    assert body["content"] == [{"type": "text", "text": request["prompt"]}]
    image.assert_not_awaited()


async def test_frame_mode_combines_upload_and_library_asset(studio, studio_api, monkeypatch):
    from app.services import studio_tools
    sessions, user, _ = studio
    last = await add_reference_asset(sessions, user, kind="scene", cover="https://cdn.test/end.png")
    refs = [{"role": "first_frame", "file_index": 0}, {"role": "last_frame", "asset_id": last.id}]
    create = AsyncMock(return_value="frame-provider-task")
    monkeypatch.setattr(studio_tools, "get_ark", lambda: SimpleNamespace(gen_video_seedance_body=create))
    monkeypatch.setattr(studio_tools, "publish_public", lambda _path: "https://cdn.test/start.png")
    response = await studio_api.post("/api/tools/run", data={**video_request(video_mode="first_last_frame"), "references": json.dumps(refs)},
                                     files=[("files", ("start.png", png_bytes(), "image/png"))])
    assert response.status_code == 200, response.text
    await executor.execute_task_run(response.json()["platform_task_id"])
    content = create.await_args.args[0]["content"]
    assert [(item["role"], item["image_url"]["url"]) for item in content if item["type"] == "image_url"] == [
        ("first_frame", "https://cdn.test/start.png"), ("last_frame", "https://cdn.test/end.png")]
    history = (await studio_api.get(f"/api/tools/runs/{response.json()['run_id']}")).json()
    assert history["params"]["references"] == refs
    assert "first_frame" not in history["params"] and "file_paths" not in history["params"]


async def test_omni_mode_keeps_all_media_roles(studio, studio_api, monkeypatch):
    from app.services import studio_tools
    sessions, user, _ = studio
    image = await add_reference_asset(sessions, user, kind="prop", url="https://cdn.test/item.png")
    video = await add_reference_asset(sessions, user, kind="video", url="https://cdn.test/motion.mp4")
    audio = await add_reference_asset(sessions, user, kind="audio", url="https://cdn.test/voice.wav")
    refs = [{"role": role, "asset_id": asset.id} for role, asset in (
        ("reference_image", image), ("reference_video", video), ("reference_audio", audio))]
    create = AsyncMock(return_value="omni-provider-task")
    monkeypatch.setattr(studio_tools, "get_ark", lambda: SimpleNamespace(gen_video_seedance_body=create))
    response = await studio_api.post("/api/tools/run", data={**video_request(video_mode="omni_reference"), "references": json.dumps(refs)})
    assert response.status_code == 200, response.text
    await executor.execute_task_run(response.json()["platform_task_id"])
    content = create.await_args.args[0]["content"]
    assert {item.get("role") for item in content if item["type"] != "text"} == {"reference_image", "reference_video", "reference_audio"}


@pytest.mark.parametrize("mode,refs", [
    ("text_to_video", [{"role": "reference_image", "file_index": 0}]),
    ("first_last_frame", [{"role": "last_frame", "file_index": 0}]),
    ("omni_reference", []),
    ("omni_reference", [{"role": "reference_image", "url": "http://127.0.0.1/private"}]),
    ("omni_reference", [{"role": "reference_image", "file_index": 0, "asset_id": 1}]),
])
async def test_invalid_reference_sources_or_modes_are_rejected(studio_api, mode, refs):
    response = await studio_api.post("/api/tools/run", data={**video_request(video_mode=mode), "references": json.dumps(refs)})
    assert response.status_code == 400


async def test_reference_ids_cannot_access_other_users_or_teams(studio, studio_api):
    sessions, user, other = studio
    foreign = await add_reference_asset(sessions, other, kind="image", url="https://cdn.test/private.png")
    team = await add_reference_asset(sessions, user, kind="image", team_id=123, url="https://cdn.test/team.png")
    for asset in (foreign, team):
        request = video_request(video_mode="first_last_frame", references=[{"role": "first_frame", "asset_id": asset.id}])
        assert (await studio_api.post("/api/tools/estimate", json=request)).status_code == 400
        response = await studio_api.post("/api/tools/run", data={**request, "references": json.dumps(request["references"])})
        assert response.status_code == 400


async def test_upload_role_and_file_content_are_validated(studio_api):
    refs = [{"role": "reference_video", "file_index": 0}]
    response = await studio_api.post("/api/tools/run", data={**video_request(video_mode="omni_reference"), "references": json.dumps(refs)},
                                     files=[("files", ("reference.mp4", b"not a video", "video/mp4"))])
    assert response.status_code == 400
    refs = [{"role": "reference_audio", "file_index": 0}]
    response = await studio_api.post("/api/tools/run", data={**video_request(video_mode="omni_reference"), "references": json.dumps(refs)},
                                     files=[("files", ("image.png", png_bytes(), "image/png"))])
    assert response.status_code == 400


async def test_omni_uploads_accept_video_audio_and_images_without_dropping_any(studio, studio_api, monkeypatch):
    from app.services import studio_tools
    import wave
    output = BytesIO()
    with wave.open(output, "wb") as audio:
        audio.setnchannels(1)
        audio.setsampwidth(2)
        audio.setframerate(8000)
        audio.writeframes(b"\0\0" * 16000)
    # A media container header is enough for admission; the provider remains mocked.
    files = [("files", ("image.png", png_bytes(), "image/png")),
             ("files", ("motion.mp4", b"\0\0\0\x18ftypmp42" + b"\0" * 20, "video/mp4")),
             ("files", ("sound.wav", output.getvalue(), "audio/wav"))]
    refs = [{"role": role, "file_index": index} for index, role in enumerate(
        ("reference_image", "reference_video", "reference_audio"))]
    create = AsyncMock(return_value="uploaded-omni-provider-task")
    monkeypatch.setattr(studio_tools, "get_ark", lambda: SimpleNamespace(gen_video_seedance_body=create))
    monkeypatch.setattr(studio_tools, "publish_public", lambda path: f"https://cdn.test/{path.name}")
    response = await studio_api.post("/api/tools/run", data={**video_request(video_mode="omni_reference"), "references": json.dumps(refs)}, files=files)
    assert response.status_code == 200, response.text
    await executor.execute_task_run(response.json()["platform_task_id"])
    content = create.await_args.args[0]["content"]
    assert [item.get("role") for item in content if item["type"] != "text"] == [
        "reference_image", "reference_audio", "reference_video"]


async def test_estimate_empty_prompt_matches_admission_and_checks_price_version(studio, studio_api, monkeypatch):
    from app.models_settings import AppSettings, MediaPriceVersion
    sessions, user, _ = studio
    monkeypatch.setattr(get_settings(), "billing_enabled", True)
    async with sessions() as db:
        version = MediaPriceVersion(prices={"seedance-2.0-fast": {"720p": "0.2000"}}, created_by=user.id)
        db.add(version)
        await db.flush()
        db.add(AppSettings(id="media_pricing", config_json={"active_version": version.id, "enabled": True}))
        await db.commit()
    response = await studio_api.post("/api/tools/estimate", json=video_request(prompt=""))
    assert response.status_code == 200, response.text
    quote = response.json()
    assert quote["estimate_fen"] == 120 and quote["estimate_yuan"] == 1.2
    assert quote["billing_mode"] == "fixed_media" and quote["billing_enabled"]
    assert quote["price_version"] == version.id and len(quote["items"]) == 1
    request = {**video_request(), "references": "[]", "price_version": str(version.id)}
    response = await studio_api.post("/api/tools/run", data=request)
    assert response.status_code == 200, response.text
    async with sessions() as db:
        task = await db.get(TaskRun, response.json()["platform_task_id"])
        assert task.billing_estimate_fen == quote["estimate_fen"]
    response = await studio_api.post("/api/tools/run", data={**request, "price_version": str(version.id + 1)})
    assert response.status_code == 409
    assert (await studio_api.post("/api/tools/run", data={**request, "price_version": "0"})).status_code == 200


async def test_reference_limits_and_asset_types_apply_to_quotes(studio, studio_api):
    sessions, user, _ = studio
    audio = await add_reference_asset(sessions, user, kind="voice", url="https://cdn.test/voice.mp3")
    request = video_request(video_mode="first_last_frame", references=[{"role": "first_frame", "asset_id": audio.id}])
    assert (await studio_api.post("/api/tools/estimate", json=request)).status_code == 400
    request = video_request(model_id="MiniMax-H3", resolution="480p", video_mode="omni_reference",
                            references=[{"role": "reference_video", "file_index": 0}])
    assert (await studio_api.post("/api/tools/estimate", json=request)).status_code == 422
    request = video_request(video_mode="omni_reference", references=[{"role": "reference_image", "file_index": i} for i in range(10)])
    assert (await studio_api.post("/api/tools/estimate", json=request)).status_code == 422