litellm/tests/unit/proxy/video_endpoints/test_endpoints.py

"""
Routing-contract tests for litellm/proxy/video_endpoints/endpoints.py

Unlike the batches layer, every video endpoint funnels into a single downstream
seam - ProxyBaseLLMRequestProcessing.base_process_llm_request - so there is no
provider-dispatch to assert. All of the video-specific, regression-worthy logic
runs *before* that call, while the endpoint assembles the `data` dict. Each test
therefore locks four things:

  1. ROUTE_TYPE   - the exact route_type each endpoint forwards
                    (avideo_generation/status/content/edit). Swapping two would
                    silently route requests to the wrong handler.
  2. DATA SHAPE   - the entire `data` dict the processor is constructed with:
                    provider-precedence resolution, video_id passthrough/extraction,
                    model resolution from the decoded model_id, and file attachment.
  3. RESULT       - base_process_llm_request's return value is propagated untouched
                    (except where the endpoint transforms it).
  4. OUTPUT SHAPE - video_content wraps raw bytes in a Response (video/mp4 +
                    Content-Disposition).

Only true I/O boundaries are mocked (the downstream processor call, request body
parsing, file->bytes conversion, the provider-from-request readers, and the
router's model-id resolver). The id decode helpers and get_custom_provider_from_data
run for real, so the data assertions reflect production exactly. base_process is
patched with autospec so the real __init__ still stores self.data (captured via the
mock's call args), and a brand-new kwarg added to this layer surfaces as a failure.
"""

from contextlib import ExitStack
from dataclasses import dataclass
from collections.abc import Awaitable, Callable
from typing import Any, Dict, Final, Optional
from unittest.mock import AsyncMock, MagicMock, patch

import orjson
import pytest


import litellm.proxy.proxy_server as proxy_server
import litellm.proxy.video_endpoints.endpoints as endpoints
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.common_request_processing import ProxyBaseLLMRequestProcessing
from litellm.proxy.utils import ProxyLogging
from litellm.router import Router
from litellm.types.videos.main import VideoObject
from litellm.types.videos.utils import (
    decode_video_id_with_provider,
    encode_character_id_with_provider,
    encode_video_id_with_provider,
)

from fastapi import Response
from starlette.datastructures import UploadFile as StarletteUploadFile

# --------------------------------------------------------------------------- #
# A real model-encoded video id: decodes (for real) to provider "azure",
# model_id VIDEO_MODEL_ID, original video id "video_orig123". The router's
# resolver maps that model_id to a model name; an unknown id resolves to None,
# so a wrong/hardcoded model_id cannot produce a plausible-looking result.
# --------------------------------------------------------------------------- #

VIDEO_MODEL_ID = "deployment-123"
AZURE_VIDEO_ID = encode_video_id_with_provider("video_orig123", "azure", VIDEO_MODEL_ID)
# A real model-encoded character id: decodes to provider "azure", VIDEO_MODEL_ID,
# original character id "char_orig". Distinct from the video id so a test cannot
# pass by reusing the wrong constant.
AZURE_CHARACTER_ID = encode_character_id_with_provider(
    "char_orig", "azure", VIDEO_MODEL_ID
)
RESOLVED_MODELS: Dict[str, str] = {VIDEO_MODEL_ID: "azure-sora"}

# Sentinel propagated by base_process for the passthrough endpoints.
SENTINEL = object()


def _video_with_empty_model_id(
    hidden_params: dict[str, object] | None = None,
) -> VideoObject:
    video: Final[VideoObject] = VideoObject(
        id=encode_video_id_with_provider("video_new456", "azure", ""),
        object="video",
        status="queued",
    )
    video.hidden_params = dict(hidden_params or {})
    return video


def _assert_id_resolves_to_deployment(response: object, *, deployment_id: str | None = None) -> None:
    assert isinstance(response, VideoObject)
    expected_deployment: Final = {} if deployment_id is None else {"deployment_id": deployment_id}
    assert decode_video_id_with_provider(response.id) == {
        "custom_llm_provider": "azure",
        "model_id": VIDEO_MODEL_ID,
        "video_id": "video_new456",
        **expected_deployment,
    }


class FakeRequest:
    """Minimal stand-in. headers/query_params are read by the provider readers
    (mocked) and on the edit path the raw body is parsed for real via orjson."""

    def __init__(
        self,
        headers: Optional[Dict[str, str]] = None,
        query: Optional[Dict[str, str]] = None,
        raw_body: bytes = b"{}",
    ):
        self.headers = headers or {}
        self.query_params = query or {}
        self._raw_body = raw_body

    async def body(self) -> bytes:
        return self._raw_body


@dataclass
class Harness:
    read_body: AsyncMock
    batch_to_bytesio: AsyncMock
    base_process: MagicMock
    handle_exc: AsyncMock
    provider_from_headers: MagicMock
    provider_from_query: MagicMock
    provider_from_body: AsyncMock
    router: MagicMock
    resolve_model: MagicMock

    def processor_data(self) -> Dict[str, Any]:
        """The exact `data` dict the processor was constructed with."""
        assert self.base_process.call_count == 1
        return dict(self.base_process.call_args.args[0].data)

    def respond_with(self, response: object) -> None:
        self.base_process.return_value = response  # pyright: ignore[reportAny]  # MagicMock subclasses Any in typeshed

    def route_type(self) -> str:
        return self.base_process.call_args.kwargs["route_type"]


@pytest.fixture
def harness():
    logging = MagicMock(spec=ProxyLogging)

    router = MagicMock(spec=Router)
    resolve_model = MagicMock(
        side_effect=lambda model_id, custom_llm_provider=None: RESOLVED_MODELS.get(model_id)
    )
    router.resolve_model_name_from_model_id = resolve_model
    router.get_deployment.return_value = None

    read_body = AsyncMock(return_value={})
    batch_to_bytesio = AsyncMock(return_value=[b"filebytes"])
    handle_exc = AsyncMock(return_value=RuntimeError("handled"))
    provider_from_headers = MagicMock(return_value=None)
    provider_from_query = MagicMock(return_value=None)
    provider_from_body = AsyncMock(return_value=None)

    with ExitStack() as stack:
        base_process = stack.enter_context(
            patch.object(
                ProxyBaseLLMRequestProcessing,
                "base_process_llm_request",
                autospec=True,
            )
        )
        base_process.return_value = SENTINEL
        stack.enter_context(
            patch.object(
                ProxyBaseLLMRequestProcessing,
                "handle_llm_api_exception",
                handle_exc,
            )
        )
        stack.enter_context(patch.object(endpoints, "read_request_body", read_body))
        stack.enter_context(
            patch.object(endpoints, "batch_to_bytesio", batch_to_bytesio)
        )
        stack.enter_context(
            patch.object(
                endpoints,
                "get_custom_llm_provider_from_request_headers",
                provider_from_headers,
            )
        )
        stack.enter_context(
            patch.object(
                endpoints,
                "get_custom_llm_provider_from_request_query",
                provider_from_query,
            )
        )
        stack.enter_context(
            patch.object(
                endpoints,
                "get_custom_llm_provider_from_request_body",
                provider_from_body,
            )
        )
        stack.enter_context(patch.object(proxy_server, "llm_router", router))
        stack.enter_context(patch.object(proxy_server, "proxy_logging_obj", logging))
        stack.enter_context(patch.object(proxy_server, "general_settings", {}))
        stack.enter_context(patch.object(proxy_server, "proxy_config", MagicMock()))
        stack.enter_context(
            patch.object(proxy_server, "select_data_generator", MagicMock())
        )
        stack.enter_context(patch.object(proxy_server, "user_model", None))
        stack.enter_context(patch.object(proxy_server, "user_temperature", None))
        stack.enter_context(patch.object(proxy_server, "user_request_timeout", None))
        stack.enter_context(patch.object(proxy_server, "user_max_tokens", None))
        stack.enter_context(patch.object(proxy_server, "user_api_base", None))
        stack.enter_context(patch.object(proxy_server, "version", "test-version"))

        yield Harness(
            read_body=read_body,
            batch_to_bytesio=batch_to_bytesio,
            base_process=base_process,
            handle_exc=handle_exc,
            provider_from_headers=provider_from_headers,
            provider_from_query=provider_from_query,
            provider_from_body=provider_from_body,
            router=router,
            resolve_model=resolve_model,
        )


def _user() -> UserAPIKeyAuth:
    return UserAPIKeyAuth(api_key="sk-test")


# =========================================================================== #
#   POST /v1/videos  -  video_generation                                       #
# =========================================================================== #


async def call_generation(
    harness: Harness, *, body: Dict[str, Any], input_reference=None
):
    harness.read_body.return_value = body
    return await endpoints.video_generation(
        request=FakeRequest(),
        fastapi_response=Response(),
        input_reference=input_reference,
        user_api_key_dict=_user(),
    )


@pytest.mark.asyncio
async def test_generation__route_type_data_and_no_provider_default(harness):
    body = {"model": "sora-2", "prompt": "a sunset"}

    resp = await call_generation(harness, body=body)

    assert resp is SENTINEL
    assert harness.route_type() == "avideo_generation"
    # generation does NOT resolve a provider; data is the body, untouched. A
    # future default custom_llm_provider injection would break this row.
    assert harness.processor_data() == {"model": "sora-2", "prompt": "a sunset"}
    harness.batch_to_bytesio.assert_not_called()


@pytest.mark.asyncio
async def test_generation__input_reference_attached(harness):
    body = {"model": "sora-2", "prompt": "a sunset"}
    upload = MagicMock(name="upload_file")

    await call_generation(harness, body=body, input_reference=upload)

    harness.batch_to_bytesio.assert_called_once_with([upload])
    assert harness.processor_data() == {
        "model": "sora-2",
        "prompt": "a sunset",
        "input_reference": b"filebytes",
    }


@pytest.mark.asyncio
async def test_generation__restamps_id_with_asked_for_model_over_router_deployment_id(harness: Harness) -> None:
    harness.respond_with(_video_with_empty_model_id(hidden_params={"model_id": "deployment-uuid"}))

    resp: Final = await call_generation(harness, body={"model": VIDEO_MODEL_ID, "prompt": "x"})

    _assert_id_resolves_to_deployment(resp, deployment_id="deployment-uuid")


@pytest.mark.asyncio
async def test_generation__restamps_id_with_request_model_when_no_hidden_model_id(harness: Harness) -> None:
    harness.respond_with(_video_with_empty_model_id())

    resp: Final = await call_generation(harness, body={"model": VIDEO_MODEL_ID, "prompt": "x"})

    _assert_id_resolves_to_deployment(resp)


@pytest.mark.asyncio
async def test_generation__unroutable_request_model_falls_back_to_router_deployment_id(harness: Harness) -> None:
    harness.respond_with(_video_with_empty_model_id(hidden_params={"model_id": "deployment-uuid"}))

    resp: Final = await call_generation(harness, body={"model": "team-public-sora", "prompt": "x"})

    assert isinstance(resp, VideoObject)
    decoded: Final = decode_video_id_with_provider(resp.id)
    assert decoded.get("model_id") == "deployment-uuid"
    assert decoded.get("deployment_id") == "deployment-uuid"


@pytest.mark.asyncio
async def test_generation__exception_routed_through_handler(harness):
    harness.base_process.side_effect = ValueError("provider boom")

    with pytest.raises(RuntimeError, match="handled"):
        await call_generation(harness, body={"model": "sora-2"})

    harness.handle_exc.assert_called_once()
    assert harness.handle_exc.call_args.kwargs["e"].args[0] == "provider boom"


# =========================================================================== #
#   GET /v1/videos/{video_id}  -  video_status                                 #
# =========================================================================== #


async def call_status(harness: Harness, video_id: str, *, headers=None, query=None):
    return await endpoints.video_status(
        video_id=video_id,
        request=FakeRequest(headers=headers, query=query),
        fastapi_response=Response(),
        user_api_key_dict=_user(),
    )


@pytest.mark.asyncio
async def test_status__model_encoded_id_full_contract(harness):
    resp = await call_status(harness, AZURE_VIDEO_ID)

    assert resp is SENTINEL
    assert harness.route_type() == "avideo_status"
    # provider comes from the decoded id; model_id resolved to a model name.
    harness.resolve_model.assert_called_once_with(VIDEO_MODEL_ID, "azure")
    assert harness.processor_data() == {
        "video_id": AZURE_VIDEO_ID,
        "custom_llm_provider": "azure",
        "model": "azure-sora",
    }


@pytest.mark.asyncio
async def test_status__restamps_response_id_with_decoded_model_id(harness: Harness) -> None:
    harness.respond_with(_video_with_empty_model_id())

    resp: Final = await call_status(harness, AZURE_VIDEO_ID)

    _assert_id_resolves_to_deployment(resp)


@pytest.mark.asyncio
async def test_status__id_without_a_deployment_takes_the_deployment_that_answered_the_poll(harness: Harness) -> None:
    harness.respond_with(_video_with_empty_model_id(hidden_params={"model_id": "deployment-uuid"}))

    resp: Final = await call_status(harness, AZURE_VIDEO_ID)

    _assert_id_resolves_to_deployment(resp, deployment_id="deployment-uuid")


@pytest.mark.asyncio
async def test_status__plain_id_defaults_to_openai(harness):
    await call_status(harness, "video_plain")

    # plain id -> nothing decoded, no header/query/body provider -> "openai".
    harness.resolve_model.assert_not_called()
    assert harness.processor_data() == {
        "video_id": "video_plain",
        "custom_llm_provider": "openai",
    }


@pytest.mark.asyncio
async def test_status__header_provider_beats_decoded_id(harness):
    harness.provider_from_headers.return_value = "bedrock"

    await call_status(harness, AZURE_VIDEO_ID)

    data = harness.processor_data()
    # header wins over the provider decoded from the id ...
    assert data["custom_llm_provider"] == "bedrock"
    # ... but the model is still resolved from the decoded model_id.
    assert data["model"] == "azure-sora"


# =========================================================================== #
#   GET /v1/videos/{video_id}/content  -  video_content                        #
# =========================================================================== #


async def call_content(harness: Harness, video_id: str, *, headers=None, query=None):
    return await endpoints.video_content(
        video_id=video_id,
        request=FakeRequest(headers=headers, query=query),
        fastapi_response=Response(),
        user_api_key_dict=_user(),
    )


@pytest.mark.asyncio
async def test_content__wraps_raw_bytes_in_response(harness):
    harness.base_process.return_value = b"VIDEOBYTES"

    resp = await call_content(harness, "video_plain")

    assert harness.route_type() == "avideo_content"
    assert isinstance(resp, Response)
    assert resp.body == b"VIDEOBYTES"
    assert resp.media_type == "video/mp4"
    assert (
        resp.headers["content-disposition"]
        == "attachment; filename=video_video_plain.mp4"
    )


@pytest.mark.asyncio
async def test_content__plain_id_has_no_openai_default(harness):
    """The high-value asymmetry vs video_status: content stops at the decoded
    provider and never injects an 'openai' default, so a plain id leaves
    custom_llm_provider unset. A copy-paste of status' fallback breaks this."""
    harness.base_process.return_value = b"x"

    await call_content(harness, "video_plain")

    assert harness.processor_data() == {"video_id": "video_plain"}


@pytest.mark.asyncio
async def test_content__model_encoded_id(harness):
    harness.base_process.return_value = b"x"

    await call_content(harness, AZURE_VIDEO_ID)

    harness.resolve_model.assert_called_once_with(VIDEO_MODEL_ID, "azure")
    assert harness.processor_data() == {
        "video_id": AZURE_VIDEO_ID,
        "custom_llm_provider": "azure",
        "model": "azure-sora",
    }


@pytest.mark.asyncio
@pytest.mark.parametrize("call", [call_status, call_content])
async def test_status_and_content__hand_the_served_member_to_the_request_processor(harness, call):
    """The id names the routing group a key may be scoped to, and the member that served the task, which is
    the only one holding it. The processor pins the member once key and team aliases have been applied."""
    router = Router(
        model_list=[
            {"model_name": name, "litellm_params": {"model": "dashscope/wan3.0-video", "api_key": "k"}}
            for name in ("wan3-a", "wan3-b")
        ],
        routing_groups=[{"group_name": "wan3", "models": ["wan3-a", "wan3-b"], "routing_strategy": "simple-shuffle"}],
    )
    harness.base_process.return_value = b"x"
    video_id = encode_video_id_with_provider("task1", "dashscope", "wan3", served_model="wan3-b")

    with patch.object(proxy_server, "llm_router", router):
        await call(harness, video_id)

    assert harness.processor_data()["model"] == "wan3"
    assert harness.base_process.call_args.args[0].served_model == "wan3-b"


@pytest.mark.asyncio
@pytest.mark.parametrize("call", [call_status, call_content])
async def test_status_and_content__shared_provider_model_routes_to_the_creating_deployments_group(
    harness: Harness, call: Callable[[Harness, str], Awaitable[object]]
) -> None:
    router: Final = Router(
        model_list=[
            {
                "model_name": name,
                "litellm_params": {"model": "azure/sora-2", "api_base": f"https://{name}.example.com", "api_key": name},
                "model_info": {"id": f"dep-{name}"},
            }
            for name in ("sora-team", "sora-shared")
        ]
    )
    harness.base_process.return_value = b"x"
    video_id: Final = encode_video_id_with_provider("video_raw", "azure", "sora-2", deployment_id="dep-sora-shared")

    with patch.object(proxy_server, "llm_router", router):
        await call(harness, video_id)

    assert harness.processor_data()["model"] == "sora-shared"


# =========================================================================== #
#   POST /v1/videos/edits  -  video_edit                                       #
# =========================================================================== #


async def call_edit(
    harness: Harness, *, body: Dict[str, Any], headers=None, query=None
):
    harness.read_body.return_value = dict(body)
    return await endpoints.video_edit(
        request=FakeRequest(headers=headers, query=query, raw_body=orjson.dumps(body)),
        fastapi_response=Response(),
        user_api_key_dict=_user(),
    )


@pytest.mark.asyncio
async def test_edit__extracts_nested_video_id_full_contract(harness):
    resp = await call_edit(
        harness, body={"prompt": "brighter", "video": {"id": AZURE_VIDEO_ID}}
    )

    assert resp is SENTINEL
    assert harness.route_type() == "avideo_edit"
    harness.resolve_model.assert_called_once_with(VIDEO_MODEL_ID, "azure")
    # nested video object is popped; its id becomes video_id; provider/model
    # derived from the encoded id.
    assert harness.processor_data() == {
        "prompt": "brighter",
        "video_id": AZURE_VIDEO_ID,
        "custom_llm_provider": "azure",
        "model": "azure-sora",
    }


@pytest.mark.asyncio
async def test_edit__restamps_new_video_id_with_source_model_id(harness: Harness) -> None:
    harness.respond_with(_video_with_empty_model_id())

    resp: Final = await call_edit(harness, body={"prompt": "brighter", "video": {"id": AZURE_VIDEO_ID}})

    _assert_id_resolves_to_deployment(resp)


@pytest.mark.asyncio
async def test_edit__provider_from_body_data_for_plain_id(harness):
    """For a plain id, get_custom_provider_from_data (run for real) pulls the
    provider out of the request body before the 'openai' default."""
    await call_edit(
        harness,
        body={
            "prompt": "x",
            "video": {"id": "video_plain"},
            "custom_llm_provider": "vertex_ai",
        },
    )

    data = harness.processor_data()
    assert data["video_id"] == "video_plain"
    assert data["custom_llm_provider"] == "vertex_ai"
    harness.resolve_model.assert_not_called()


@pytest.mark.asyncio
async def test_edit__missing_video_object_defaults_to_openai(harness):
    await call_edit(harness, body={"prompt": "x"})

    data = harness.processor_data()
    # no video object -> empty video_id; plain -> default provider.
    assert data["video_id"] == ""
    assert data["custom_llm_provider"] == "openai"
    assert "video" not in data


@pytest.mark.asyncio
async def test_edit__bare_string_video_id_from_form_field(harness):
    await call_edit(harness, body={"prompt": "brighter", "video": "video_plain"})

    assert harness.processor_data() == {
        "prompt": "brighter",
        "video_id": "video_plain",
        "custom_llm_provider": "openai",
    }


@pytest.mark.asyncio
async def test_edit__json_string_video_reference_from_form_field(harness):
    await call_edit(
        harness,
        body={"prompt": "brighter", "video": orjson.dumps({"id": "video_plain"}).decode()},
    )

    assert harness.processor_data()["video_id"] == "video_plain"


@pytest.mark.asyncio
async def test_edit__uploaded_video_restamps_new_id_with_requested_model(harness: Harness) -> None:
    import io

    upload: Final = StarletteUploadFile(file=io.BytesIO(b"rawmp4"), filename="clip.mp4")
    harness.read_body.return_value = {"model": VIDEO_MODEL_ID, "prompt": "make it nighttime", "video": upload}
    harness.respond_with(_video_with_empty_model_id())

    resp: Final = await endpoints.video_edit(
        request=FakeRequest(raw_body=b"multipart"),
        fastapi_response=Response(),
        user_api_key_dict=_user(),
    )

    _assert_id_resolves_to_deployment(resp)


@pytest.mark.asyncio
async def test_edit__uploaded_video_file_is_forwarded_not_dropped(harness):
    """A multipart-uploaded source video must be converted to bytes and attached
    under ``video`` so the provider receives the file. Before the fix the upload
    was popped, coerced to an empty ``video_id``, and silently dropped."""
    import io

    upload = StarletteUploadFile(file=io.BytesIO(b"rawmp4"), filename="clip.mp4")
    harness.read_body.return_value = {"prompt": "make it nighttime", "video": upload}

    await endpoints.video_edit(
        request=FakeRequest(raw_body=b"multipart"),
        fastapi_response=Response(),
        user_api_key_dict=_user(),
    )

    harness.batch_to_bytesio.assert_called_once_with((upload,))
    assert harness.processor_data() == {
        "prompt": "make it nighttime",
        "video": b"filebytes",
        "video_id": "",
        "custom_llm_provider": "openai",
    }


# =========================================================================== #
#   GET /v1/videos  -  video_list                                              #
# =========================================================================== #


async def call_list(harness: Harness, *, headers=None, query=None):
    return await endpoints.video_list(
        request=FakeRequest(headers=headers, query=query),
        fastapi_response=Response(),
        user_api_key_dict=_user(),
    )


@pytest.mark.asyncio
async def test_list__query_params_and_no_provider(harness):
    resp = await call_list(harness, query={"limit": "5"})

    assert resp is SENTINEL
    assert harness.route_type() == "avideo_list"
    # no provider anywhere -> custom_llm_provider stays absent (only set if truthy).
    assert harness.processor_data() == {"query_params": {"limit": "5"}}


@pytest.mark.asyncio
async def test_list__provider_from_header(harness):
    harness.provider_from_headers.return_value = "bedrock"

    await call_list(harness)

    assert harness.processor_data() == {
        "query_params": {},
        "custom_llm_provider": "bedrock",
    }


# =========================================================================== #
#   POST /v1/videos/{video_id}/remix  -  video_remix                           #
# =========================================================================== #


async def call_remix(
    harness: Harness, video_id: str, *, body, headers=None, query=None
):
    harness.read_body.return_value = dict(body)
    return await endpoints.video_remix(
        video_id=video_id,
        request=FakeRequest(headers=headers, query=query, raw_body=orjson.dumps(body)),
        fastapi_response=Response(),
        user_api_key_dict=_user(),
    )


@pytest.mark.asyncio
async def test_remix__model_encoded_id_full_contract(harness):
    resp = await call_remix(harness, AZURE_VIDEO_ID, body={"prompt": "new colors"})

    assert resp is SENTINEL
    assert harness.route_type() == "avideo_remix"
    harness.resolve_model.assert_called_once_with(VIDEO_MODEL_ID, "azure")
    assert harness.processor_data() == {
        "prompt": "new colors",
        "video_id": AZURE_VIDEO_ID,
        "custom_llm_provider": "azure",
        "model": "azure-sora",
    }


@pytest.mark.asyncio
async def test_remix__restamps_new_video_id_with_source_model_id(harness: Harness) -> None:
    harness.respond_with(_video_with_empty_model_id())

    resp: Final = await call_remix(harness, AZURE_VIDEO_ID, body={"prompt": "new colors"})

    _assert_id_resolves_to_deployment(resp)


@pytest.mark.asyncio
async def test_remix__provider_from_body_data_not_request_body_reader(harness):
    """remix resolves the provider from data.get('custom_llm_provider'), never
    from the async request-body reader (unlike status/get_character). Setting
    that reader to a sentinel and asserting it is untouched locks the difference."""
    harness.provider_from_body.return_value = "must-not-win"

    await call_remix(
        harness,
        "video_plain",
        body={"prompt": "x", "custom_llm_provider": "vertex_ai"},
    )

    harness.provider_from_body.assert_not_called()
    data = harness.processor_data()
    assert data["video_id"] == "video_plain"
    assert data["custom_llm_provider"] == "vertex_ai"


@pytest.mark.asyncio
async def test_remix__plain_id_has_no_openai_default(harness):
    await call_remix(harness, "video_plain", body={"prompt": "x"})

    # like video_content, remix stops at provider_from_id with no 'openai' default.
    assert harness.processor_data() == {"prompt": "x", "video_id": "video_plain"}


# =========================================================================== #
#   POST /v1/videos/characters  -  video_create_character                      #
# =========================================================================== #


async def call_create_character(harness: Harness, *, body, video=None, name="my_char"):
    harness.read_body.return_value = body
    return await endpoints.video_create_character(
        request=FakeRequest(),
        fastapi_response=Response(),
        video=video if video is not None else MagicMock(name="video_upload"),
        name=name,
        user_api_key_dict=_user(),
    )


@pytest.mark.asyncio
async def test_create_character__video_attached_default_provider_no_encode(harness):
    upload = MagicMock(name="video_upload")

    resp = await call_create_character(harness, body={"prompt": "x"}, video=upload)

    assert resp is SENTINEL
    assert harness.route_type() == "avideo_create_character"
    harness.batch_to_bytesio.assert_called_once_with([upload])
    # no target_model_names -> no model injected, no id re-encoding.
    assert harness.processor_data() == {
        "prompt": "x",
        "video": b"filebytes",
        "custom_llm_provider": "openai",
    }


@pytest.mark.asyncio
async def test_create_character__target_model_sets_model_and_encodes_id(harness):
    harness.base_process.return_value = {"id": "char_raw"}

    resp = await call_create_character(
        harness,
        body={"target_model_names": "azure-sora-model", "custom_llm_provider": "azure"},
    )

    data = harness.processor_data()
    assert data["model"] == "azure-sora-model"
    assert data["custom_llm_provider"] == "azure"
    # response id re-encoded with the resolved provider + model for the round-trip.
    assert resp["id"] == encode_character_id_with_provider(
        "char_raw", "azure", "azure-sora-model"
    )


# =========================================================================== #
#   GET /v1/videos/characters/{character_id}  -  video_get_character           #
# =========================================================================== #


async def call_get_character(
    harness: Harness, character_id: str, *, headers=None, query=None
):
    return await endpoints.video_get_character(
        character_id=character_id,
        request=FakeRequest(headers=headers, query=query),
        fastapi_response=Response(),
        user_api_key_dict=_user(),
    )


@pytest.mark.asyncio
async def test_get_character__encoded_id_full_contract(harness):
    harness.base_process.return_value = {"id": "char_raw2"}

    resp = await call_get_character(harness, AZURE_CHARACTER_ID)

    assert harness.route_type() == "avideo_get_character"
    harness.resolve_model.assert_called_once_with(VIDEO_MODEL_ID, "azure")
    # character_id decoded to its inner value; provider/model from the encoded id.
    assert harness.processor_data() == {
        "character_id": "char_orig",
        "custom_llm_provider": "azure",
        "model": "azure-sora",
    }
    # response id re-encoded for the client round-trip.
    assert resp["id"] == encode_character_id_with_provider(
        "char_raw2", "azure", VIDEO_MODEL_ID
    )


@pytest.mark.asyncio
async def test_get_character__plain_id_defaults_openai_no_encode(harness):
    harness.base_process.return_value = {"id": "char_raw3"}

    resp = await call_get_character(harness, "char_plain")

    harness.resolve_model.assert_not_called()
    assert harness.processor_data() == {
        "character_id": "char_plain",
        "custom_llm_provider": "openai",
    }
    # id does not start with 'character_' -> returned untouched.
    assert resp["id"] == "char_raw3"


@pytest.mark.asyncio
async def test_get_character__model_served_only_by_a_provider_wildcard_routes_through_it(harness: Harness) -> None:
    router: Final = Router(
        model_list=[{"model_name": "openai/*", "litellm_params": {"model": "openai/*", "api_key": "key-w"}}]
    )
    harness.base_process.return_value = {"id": "char_raw4"}
    character_id: Final = encode_character_id_with_provider("char_orig", "openai", "sora-2")

    with patch.object(proxy_server, "llm_router", router):
        await call_get_character(harness, character_id)

    assert harness.processor_data()["model"] == "sora-2"


# =========================================================================== #
#   POST /v1/videos/extensions  -  video_extension                            #
# =========================================================================== #


async def call_extension(harness: Harness, *, body, headers=None, query=None):
    harness.read_body.return_value = dict(body)
    return await endpoints.video_extension(
        request=FakeRequest(headers=headers, query=query, raw_body=orjson.dumps(body)),
        fastapi_response=Response(),
        user_api_key_dict=_user(),
    )


@pytest.mark.asyncio
async def test_extension__extracts_nested_video_id_full_contract(harness):
    resp = await call_extension(
        harness, body={"prompt": "continue", "video": {"id": AZURE_VIDEO_ID}}
    )

    assert resp is SENTINEL
    assert harness.route_type() == "avideo_extension"
    harness.resolve_model.assert_called_once_with(VIDEO_MODEL_ID, "azure")
    assert harness.processor_data() == {
        "prompt": "continue",
        "video_id": AZURE_VIDEO_ID,
        "custom_llm_provider": "azure",
        "model": "azure-sora",
    }


@pytest.mark.asyncio
async def test_extension__restamps_new_video_id_with_source_model_id(harness: Harness) -> None:
    harness.respond_with(_video_with_empty_model_id())

    resp: Final = await call_extension(harness, body={"prompt": "continue", "video": {"id": AZURE_VIDEO_ID}})

    _assert_id_resolves_to_deployment(resp)