Stability, BFL, Runway, Luma, Replicate, fal, Ideogram, Recraft, Leonardo, MiniMax, Kling, Higgsfield: call tables checked against vendor specs/SDKs, ImageGenerator/VideoGenerator seam with capped polling, /ai/media demo. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
362 lines
14 KiB
C++
362 lines
14 KiB
C++
// ImageGenerator / VideoGenerator adapters: the exact request each one would
|
|
// send (plan), loud refusal of options a provider cannot honour, and the
|
|
// rule that submit() without confirm makes no network call.
|
|
#include "support.h"
|
|
#include "vendors/media/bfl/bfl.h"
|
|
#include "vendors/media/common/registry.h"
|
|
#include "vendors/media/fal/fal.h"
|
|
#include "vendors/media/higgsfield/higgsfield.h"
|
|
#include "vendors/media/ideogram/ideogram.h"
|
|
#include "vendors/media/kling/kling.h"
|
|
#include "vendors/media/leonardo/leonardo.h"
|
|
#include "vendors/media/luma/luma.h"
|
|
#include "vendors/media/minimax/minimax.h"
|
|
#include "vendors/media/recraft/recraft.h"
|
|
#include "vendors/media/replicate/replicate.h"
|
|
#include "vendors/media/runway/runway.h"
|
|
#include "vendors/media/stability/stability.h"
|
|
|
|
using namespace molo::media;
|
|
using namespace media_test;
|
|
|
|
namespace {
|
|
|
|
ImageRequest image(const std::string& model = "") {
|
|
ImageRequest r;
|
|
r.prompt = "a lighthouse at dusk";
|
|
r.model = model;
|
|
return r;
|
|
}
|
|
|
|
VideoRequest video(const std::string& model = "") {
|
|
VideoRequest r;
|
|
r.prompt = "waves rolling in";
|
|
r.model = model;
|
|
return r;
|
|
}
|
|
|
|
std::string target(const Json& plan) { return plan.find("target")->as_string(); }
|
|
std::string body_of(const Json& plan) { return plan.find("body") ? plan.find("body")->dump() : ""; }
|
|
|
|
} // namespace
|
|
|
|
TEST(media_adapter, stability_picks_the_endpoint_from_the_model) {
|
|
ASSERT_EQ(StabilityImageGenerator::key_for(""), std::string("stable-image.generate.core"));
|
|
ASSERT_EQ(StabilityImageGenerator::key_for("ultra"), std::string("stable-image.generate.ultra"));
|
|
ASSERT_EQ(StabilityImageGenerator::key_for("sd3.5-large"), std::string("stable-image.generate.sd3"));
|
|
ASSERT_THROW(StabilityImageGenerator::key_for("dall-e"), ApiError);
|
|
Mock m;
|
|
StabilityImageGenerator g(StabilityClient::with(m.take(), "KEY"));
|
|
ImageRequest r = image("sd3.5-large");
|
|
r.aspect_ratio = "16:9";
|
|
r.seed = 42;
|
|
Json p = g.plan(r);
|
|
ASSERT_EQ(target(p), std::string("/v2beta/stable-image/generate/sd3"));
|
|
ASSERT_TRUE(has(body_of(p), "\"aspect_ratio\":\"16:9\""));
|
|
ASSERT_TRUE(has(body_of(p), "\"model\":\"sd3.5-large\""));
|
|
ASSERT_TRUE(has(body_of(p), "\"seed\":42"));
|
|
ImageRequest wh = image();
|
|
wh.width = 512;
|
|
wh.height = 512;
|
|
ASSERT_THROW(g.plan(wh), ApiError); // stability sizes by aspect ratio only
|
|
ImageRequest many = image();
|
|
many.count = 2;
|
|
ASSERT_THROW(g.plan(many), ApiError);
|
|
ImageRequest src = image();
|
|
src.source_url = "https://example.com/in.png";
|
|
ASSERT_THROW(g.plan(src), ApiError);
|
|
ASSERT_THROW(g.submit(image(), false), ApiError);
|
|
ASSERT_EQ(m.raw->send_count(), static_cast<std::size_t>(0));
|
|
}
|
|
|
|
TEST(media_adapter, bfl_models_and_options) {
|
|
Mock m;
|
|
BflImageGenerator g(BflClient::with(m.take(), "KEY"));
|
|
ImageRequest r = image("flux-kontext-pro");
|
|
r.aspect_ratio = "1:1";
|
|
Json p = g.plan(r);
|
|
ASSERT_EQ(target(p), std::string("/v1/flux-kontext-pro"));
|
|
ASSERT_TRUE(has(body_of(p), "\"aspect_ratio\":\"1:1\""));
|
|
ImageRequest wh = image("flux-kontext-pro"); // kontext takes aspect_ratio, not width / height
|
|
wh.width = 1024;
|
|
wh.height = 1024;
|
|
ASSERT_THROW(g.plan(wh), ApiError);
|
|
ImageRequest def = image();
|
|
def.width = 1024;
|
|
def.height = 768;
|
|
ASSERT_EQ(target(g.plan(def)), std::string("/v1/flux-2-pro")); // default model
|
|
ImageRequest many = image();
|
|
many.count = 3;
|
|
ASSERT_THROW(g.plan(many), ApiError);
|
|
ImageRequest unknown = image("flux-9000");
|
|
ASSERT_THROW(g.plan(unknown), ApiError); // not in the table
|
|
ASSERT_THROW(g.submit(def, false), ApiError);
|
|
ASSERT_EQ(m.raw->send_count(), static_cast<std::size_t>(0));
|
|
BflVideoGenerator v(BflClient::with(std::make_unique<MockTransport>(), "KEY"));
|
|
VideoRequest vr = video();
|
|
vr.duration_seconds = 5;
|
|
vr.aspect_ratio = "16:9";
|
|
Json vp = v.plan(vr);
|
|
ASSERT_EQ(target(vp), std::string("/v1/flux-3-video"));
|
|
ASSERT_TRUE(has(body_of(vp), "\"duration\":5"));
|
|
}
|
|
|
|
TEST(media_adapter, replicate_needs_owner_name_and_maps_common_fields_into_input) {
|
|
Mock m;
|
|
ReplicateImageGenerator g(ReplicateClient::with(m.take(), "KEY"));
|
|
ImageRequest r = image("black-forest-labs/flux-schnell");
|
|
r.aspect_ratio = "3:2";
|
|
r.count = 2;
|
|
r.seed = 9;
|
|
Json p = g.plan(r);
|
|
ASSERT_EQ(target(p), std::string("/models/black-forest-labs/flux-schnell/predictions"));
|
|
ASSERT_TRUE(has(body_of(p), "\"num_outputs\":2"));
|
|
ASSERT_TRUE(has(body_of(p), "\"aspect_ratio\":\"3:2\""));
|
|
ASSERT_THROW(g.plan(image()), ApiError);
|
|
ASSERT_THROW(g.plan(image("flux-schnell")), ApiError);
|
|
ASSERT_THROW(g.submit(r, false), ApiError);
|
|
ASSERT_EQ(m.raw->send_count(), static_cast<std::size_t>(0));
|
|
ReplicateVideoGenerator v(ReplicateClient::with(std::make_unique<MockTransport>(), "KEY"));
|
|
VideoRequest vr = video("minimax/video-01");
|
|
vr.image_url = "https://example.com/a.png";
|
|
Json vp = v.plan(vr);
|
|
ASSERT_TRUE(has(body_of(vp), "\"image\":\"https://example.com/a.png\""));
|
|
}
|
|
|
|
TEST(media_adapter, fal_takes_any_endpoint_id) {
|
|
Mock m;
|
|
FalImageGenerator g(FalQueue::with(m.take(), "id:secret"));
|
|
ImageRequest r = image("fal-ai/flux/dev");
|
|
r.width = 1024;
|
|
r.height = 576;
|
|
r.count = 2;
|
|
Json p = g.plan(r);
|
|
ASSERT_EQ(target(p), std::string("/fal-ai/flux/dev"));
|
|
ASSERT_TRUE(has(body_of(p), "\"image_size\":{\"height\":576,\"width\":1024}"));
|
|
ASSERT_TRUE(has(body_of(p), "\"num_images\":2"));
|
|
ASSERT_THROW(g.plan(image()), ApiError);
|
|
ASSERT_THROW(g.submit(r, false), ApiError);
|
|
ASSERT_EQ(m.raw->send_count(), static_cast<std::size_t>(0));
|
|
FalVideoGenerator v(FalQueue::with(std::make_unique<MockTransport>(), "id:secret"));
|
|
VideoRequest vr = video("fal-ai/kling-video/v2.1/master/text-to-video");
|
|
vr.duration_seconds = 5;
|
|
Json vp = v.plan(vr);
|
|
ASSERT_EQ(target(vp), std::string("/fal-ai/kling-video/v2.1/master/text-to-video"));
|
|
ASSERT_TRUE(has(body_of(vp), "\"duration\":\"5\""));
|
|
}
|
|
|
|
TEST(media_adapter, ideogram_models_map_to_rows_and_edit_inputs_are_files) {
|
|
Mock m;
|
|
IdeogramImageGenerator g(IdeogramClient::with(m.take(), "KEY"));
|
|
ASSERT_EQ(IdeogramImageGenerator::key_for(""), std::string("image.generate.ideogram-3"));
|
|
ImageRequest r = image("ideogram-4");
|
|
r.count = 2;
|
|
r.width = 1024;
|
|
r.height = 1024;
|
|
Json p = g.plan(r);
|
|
ASSERT_EQ(target(p), std::string("/v2/image/generate/ideogram-4"));
|
|
ASSERT_TRUE(has(body_of(p), "\"resolution\":\"1024x1024\""));
|
|
ImageRequest src = image();
|
|
src.source_url = "https://example.com/in.png";
|
|
ASSERT_THROW(g.plan(src), ApiError);
|
|
ASSERT_THROW(g.plan(image("ideogram-99")), ApiError);
|
|
ASSERT_THROW(g.submit(image(), false), ApiError);
|
|
IdeogramVideoGenerator v(IdeogramClient::with(std::make_unique<MockTransport>(), "KEY"));
|
|
ASSERT_THROW(v.plan(video()), ApiError); // a video model is required
|
|
Json vp = v.plan(video("kling-3-standard-text-to-video"));
|
|
ASSERT_EQ(target(vp), std::string("/v2/video/generate/kling-3-standard-text-to-video"));
|
|
ASSERT_EQ(m.raw->send_count(), static_cast<std::size_t>(0));
|
|
}
|
|
|
|
TEST(media_adapter, recraft_sizes_by_wxh) {
|
|
Mock m;
|
|
RecraftImageGenerator g(RecraftClient::with(m.take(), "KEY"));
|
|
ImageRequest r = image("recraftv3");
|
|
r.width = 1024;
|
|
r.height = 1024;
|
|
r.count = 2;
|
|
Json p = g.plan(r);
|
|
ASSERT_EQ(target(p), std::string("/v1/images/generations"));
|
|
ASSERT_TRUE(has(body_of(p), "\"size\":\"1024x1024\""));
|
|
ASSERT_TRUE(has(body_of(p), "\"n\":2"));
|
|
ImageRequest ar = image();
|
|
ar.aspect_ratio = "16:9";
|
|
ASSERT_THROW(g.plan(ar), ApiError);
|
|
ASSERT_THROW(g.submit(r, false), ApiError);
|
|
ASSERT_EQ(m.raw->send_count(), static_cast<std::size_t>(0));
|
|
}
|
|
|
|
TEST(media_adapter, leonardo_wraps_parameters_and_never_publishes) {
|
|
Mock m;
|
|
LeonardoImageGenerator g(LeonardoClient::with(m.take(), "KEY"));
|
|
ImageRequest r = image("flux-dev");
|
|
r.width = 1024;
|
|
r.height = 1024;
|
|
r.count = 4;
|
|
Json p = g.plan(r);
|
|
ASSERT_EQ(target(p), std::string("/v2/generations"));
|
|
ASSERT_TRUE(has(body_of(p), "\"model\":\"flux-dev\""));
|
|
ASSERT_TRUE(has(body_of(p), "\"public\":false"));
|
|
ASSERT_TRUE(has(body_of(p), "\"quantity\":4"));
|
|
ASSERT_THROW(g.plan(image()), ApiError); // model required
|
|
ImageRequest ar = image("flux-dev");
|
|
ar.aspect_ratio = "1:1";
|
|
ASSERT_THROW(g.plan(ar), ApiError);
|
|
ASSERT_THROW(g.submit(r, false), ApiError);
|
|
ASSERT_EQ(m.raw->send_count(), static_cast<std::size_t>(0));
|
|
}
|
|
|
|
TEST(media_adapter, runway_chooses_text_or_image_to_video) {
|
|
Mock m;
|
|
RunwayVideoGenerator g(RunwayClient::with(m.take(), "KEY"));
|
|
VideoRequest t = video();
|
|
t.duration_seconds = 5;
|
|
t.aspect_ratio = "1280:720";
|
|
ASSERT_EQ(target(g.plan(t)), std::string("/v1/text_to_video"));
|
|
ASSERT_TRUE(has(body_of(g.plan(t)), "\"model\":\"gen4.5\""));
|
|
VideoRequest i = video();
|
|
i.image_url = "https://example.com/a.png";
|
|
ASSERT_EQ(target(g.plan(i)), std::string("/v1/image_to_video"));
|
|
ASSERT_TRUE(has(body_of(g.plan(i)), "\"model\":\"gen4_turbo\""));
|
|
ASSERT_TRUE(has(body_of(g.plan(i)), "\"promptImage\""));
|
|
RunwayImageGenerator ig(RunwayClient::with(std::make_unique<MockTransport>(), "KEY"));
|
|
ImageRequest r = image();
|
|
r.width = 1280;
|
|
r.height = 720;
|
|
Json p = ig.plan(r);
|
|
ASSERT_EQ(target(p), std::string("/v1/text_to_image"));
|
|
ASSERT_TRUE(has(body_of(p), "\"ratio\":\"1280:720\""));
|
|
ASSERT_TRUE(has(body_of(p), "\"promptText\""));
|
|
ASSERT_THROW(g.submit(t, false), ApiError);
|
|
ASSERT_THROW(ig.cancel(JobTicket{}, false), ApiError);
|
|
ASSERT_EQ(m.raw->send_count(), static_cast<std::size_t>(0));
|
|
}
|
|
|
|
TEST(media_adapter, luma_durations_are_strings_and_keyframes_nest_frames) {
|
|
Mock m;
|
|
LumaVideoGenerator g(LumaClient::with(m.take(), "KEY"));
|
|
VideoRequest v = video();
|
|
v.duration_seconds = 5;
|
|
v.image_url = "https://example.com/start.png";
|
|
v.end_image_url = "https://example.com/end.png";
|
|
Json p = g.plan(v);
|
|
ASSERT_EQ(target(p), std::string("/generations/video"));
|
|
ASSERT_TRUE(has(body_of(p), "\"duration\":\"5s\""));
|
|
ASSERT_TRUE(has(body_of(p), "\"frame0\":{\"type\":\"image\",\"url\":\"https://example.com/start.png\"}"));
|
|
ASSERT_TRUE(has(body_of(p), "\"frame1\""));
|
|
ASSERT_TRUE(has(body_of(p), "\"model\":\"ray-2\""));
|
|
LumaImageGenerator ig(LumaClient::with(std::make_unique<MockTransport>(), "KEY"));
|
|
ImageRequest wh = image();
|
|
wh.width = 512;
|
|
wh.height = 512;
|
|
ASSERT_THROW(ig.plan(wh), ApiError);
|
|
ASSERT_EQ(target(ig.plan(image())), std::string("/generations/image"));
|
|
ASSERT_THROW(g.cancel(JobTicket{}, false), ApiError); // cancel deletes: confirm required
|
|
ASSERT_EQ(m.raw->send_count(), static_cast<std::size_t>(0));
|
|
}
|
|
|
|
TEST(media_adapter, minimax_refuses_options_v1_does_not_have) {
|
|
Mock m;
|
|
MinimaxVideoGenerator g(MinimaxClient::with(m.take(), "KEY"));
|
|
VideoRequest v = video();
|
|
v.duration_seconds = 6;
|
|
v.resolution = "768p";
|
|
Json p = g.plan(v);
|
|
ASSERT_EQ(target(p), std::string("/v1/video_generation"));
|
|
ASSERT_TRUE(has(body_of(p), "\"resolution\":\"768P\""));
|
|
ASSERT_TRUE(has(body_of(p), "\"model\":\"MiniMax-Hailuo-2.3\""));
|
|
VideoRequest ar = video();
|
|
ar.aspect_ratio = "16:9";
|
|
ASSERT_THROW(g.plan(ar), ApiError);
|
|
VideoRequest sd = video();
|
|
sd.seed = 5;
|
|
ASSERT_THROW(g.plan(sd), ApiError);
|
|
ASSERT_THROW(g.submit(v, false), ApiError);
|
|
ASSERT_FALSE(g.cancel(JobTicket{}, true)); // not supported, says so without a call
|
|
ASSERT_EQ(m.raw->send_count(), static_cast<std::size_t>(0));
|
|
}
|
|
|
|
TEST(media_adapter, kling_and_higgsfield) {
|
|
auto kc = std::make_shared<KlingClient>("AK", "SK", [] { return std::make_unique<MockTransport>(); });
|
|
KlingVideoGenerator k(kc);
|
|
VideoRequest v = video();
|
|
v.duration_seconds = 5;
|
|
Json p = k.plan(v);
|
|
ASSERT_EQ(target(p), std::string("/v1/videos/text2video"));
|
|
ASSERT_TRUE(has(body_of(p), "\"model_name\":\"kling-v1-6\""));
|
|
ASSERT_TRUE(has(body_of(p), "\"duration\":\"5\""));
|
|
VideoRequest i = video();
|
|
i.image_url = "https://example.com/a.png";
|
|
ASSERT_EQ(target(k.plan(i)), std::string("/v1/videos/image2video"));
|
|
VideoRequest sd = video();
|
|
sd.seed = 1;
|
|
ASSERT_THROW(k.plan(sd), ApiError);
|
|
ASSERT_THROW(k.submit(v, false), ApiError);
|
|
|
|
Mock m;
|
|
HiggsfieldImageGenerator h(HiggsfieldClient::with(m.take(), "id", "secret"));
|
|
Json hp = h.plan(image());
|
|
ASSERT_EQ(target(hp), std::string("/higgsfield-ai/soul/standard"));
|
|
ImageRequest wh = image();
|
|
wh.width = 512;
|
|
wh.height = 512;
|
|
ASSERT_THROW(h.plan(wh), ApiError);
|
|
HiggsfieldVideoGenerator hv(HiggsfieldClient::with(std::make_unique<MockTransport>(), "id", "secret"));
|
|
ASSERT_THROW(hv.plan(video()), ApiError); // model path required
|
|
ASSERT_EQ(target(hv.plan(video("kling-video/v2.5-turbo/pro/text-to-video"))),
|
|
std::string("/kling-video/v2.5-turbo/pro/text-to-video"));
|
|
ASSERT_THROW(h.cancel(JobTicket{}, false), ApiError);
|
|
ASSERT_EQ(m.raw->send_count(), static_cast<std::size_t>(0));
|
|
}
|
|
|
|
TEST(media_adapter, registry_builds_a_generator_for_every_declared_capability) {
|
|
MediaRegistry reg;
|
|
for (const ProviderInfo& p : MediaRegistry::providers()) {
|
|
if (p.image) {
|
|
auto g = reg.image(p.id);
|
|
ASSERT_EQ(g->provider(), p.id);
|
|
ASSERT_FALSE(g->models().empty());
|
|
} else {
|
|
ASSERT_THROW(reg.image(p.id), ApiError);
|
|
}
|
|
if (p.video) {
|
|
auto g = reg.video(p.id);
|
|
ASSERT_EQ(g->provider(), p.id);
|
|
ASSERT_FALSE(g->models().empty());
|
|
} else {
|
|
ASSERT_THROW(reg.video(p.id), ApiError);
|
|
}
|
|
ASSERT_TRUE(reg.service(p.id) != nullptr);
|
|
}
|
|
ASSERT_THROW(reg.image("midjourney"), ApiError);
|
|
ASSERT_THROW(reg.service("pika"), ApiError);
|
|
}
|
|
|
|
TEST(media_adapter, every_default_model_resolves_to_a_row_in_its_table) {
|
|
// A model named by models() must plan cleanly where the adapter derives the row from it.
|
|
MediaRegistry reg;
|
|
ImageRequest r = image();
|
|
for (const std::string& model : reg.image("bfl")->models()) {
|
|
r.model = model;
|
|
r.width = 0;
|
|
r.height = 0;
|
|
if (model.rfind("flux-kontext", 0) == 0) r.aspect_ratio = "1:1";
|
|
else r.aspect_ratio = "";
|
|
if (model == "flux-3-image") continue; // takes images[], aspect_ratio: covered by the table test
|
|
r.aspect_ratio = "";
|
|
reg.image("bfl")->plan(r);
|
|
}
|
|
for (const std::string& model : reg.image("ideogram")->models()) {
|
|
r.model = model;
|
|
r.aspect_ratio = "";
|
|
r.width = 0;
|
|
r.height = 0;
|
|
reg.image("ideogram")->plan(r);
|
|
}
|
|
for (const std::string& model : reg.video("ideogram")->models()) {
|
|
VideoRequest v = video(model);
|
|
reg.video("ideogram")->plan(v);
|
|
}
|
|
for (const std::string& model : reg.video("higgsfield")->models()) reg.video("higgsfield")->plan(video(model));
|
|
}
|