// OpenAI platform: the call table, local validation, request construction, // forms, list walking. Nothing here plays the vendor. #include #include #include "framework.h" #include "llm/error.h" #include "openai/platform/batches_api.h" #include "openai/platform/caps.h" #include "openai/platform/uploads_api.h" #include "rig.h" using namespace molo::openai::platform; using molo::clients::body::Json; using molo::llm::ApiError; using molo::llm::NotConfiguredError; using oai_test::Rig; namespace { PathArgs dummy_ids(const CallSpec& s) { PathArgs a; for (const std::string& n : Calls::placeholders(s)) a.emplace_back(n, "id_1"); return a; } Json minimal_body(const CallSpec& s) { Json b = Json::object(); for (const std::string& r : Calls::list(s.required_fields)) b.set(r, Json("x")); return b; } } // namespace TEST(oai_calls, table_shape) { ASSERT_EQ(Calls::count(), 188u); std::set ids, enums; for (std::size_t i = 0; i < Calls::count(); ++i) { const CallSpec& s = Calls::at(i); ASSERT_EQ(static_cast(s.op), i); ASSERT_TRUE(ids.insert(s.operation_id).second); ASSERT_TRUE(s.path[0] == '/'); ASSERT_TRUE(std::string(s.method) == "GET" || std::string(s.method) == "POST" || std::string(s.method) == "DELETE"); ASSERT_TRUE(Calls::find(s.operation_id) == &s); } ASSERT_TRUE(Calls::find("nope") == nullptr); } TEST(oai_calls, every_call_prepares_with_minimal_input) { for (std::size_t i = 0; i < Calls::count(); ++i) { const CallSpec& s = Calls::at(i); bool json = (s.req & kReqJson) != 0; Json body = minimal_body(s); auto p = PlatformService::prepare(s.op, dummy_ids(s), json ? &body : nullptr); ASSERT_EQ(p.method, std::string(s.method)); ASSERT_EQ(p.target.find("{"), std::string::npos); ASSERT_EQ(p.target.substr(0, 1), "/"); ASSERT_EQ(p.has_body, json); // Flags drive the beta headers. ASSERT_EQ(p.headers.count("OpenAI-Beta") != 0, Calls::has(s, kBetaAssistants) || Calls::has(s, kBetaChatkit)); } } TEST(oai_calls, unknown_and_missing_body_fields_are_rejected_before_the_network) { Rig r; Json bad = Json::object(); bad.set("model", Json("gpt-x")); bad.set("not_a_field", Json(1)); ASSERT_THROW(r.platform->assistants.create(bad), ApiError); ASSERT_THROW(r.platform->assistants.create(Json::object()), ApiError); // model is required ASSERT_THROW(r.platform->fine_tuning_jobs.create(Json::object()), ApiError); ASSERT_THROW(r.platform->files.retrieve("a/b"), ApiError); ASSERT_THROW(r.platform->files.retrieve(".."), ApiError); ASSERT_THROW(r.platform->files.retrieve(""), ApiError); ASSERT_THROW(r.platform->files.retrieve(std::string(300, 'a')), ApiError); ASSERT_THROW(r.platform->generic.invoke(Op::kRetrieveFile, {}), ApiError); // id missing ASSERT_THROW(r.platform->generic.invoke(Op::kRetrieveFile, {{"file_id", "a"}, {"x", "b"}}), ApiError); // extra id Json body = Json::object(); ASSERT_THROW(r.platform->generic.invoke(Op::kRetrieveFile, {{"file_id", "a"}}, &body), ApiError); // GET body ASSERT_EQ(r.sent(), 0u); } TEST(oai_calls, validation_runs_before_the_credential_check) { Rig r(""); ASSERT_FALSE(r.platform->configured()); try { r.platform->files.retrieve("a/b"); FAIL("expected invalid"); } catch (const NotConfiguredError&) { FAIL("validation must come first"); } catch (const ApiError& e) { ASSERT_EQ(e.http_status(), 400); } try { r.platform->files.retrieve("file-1"); FAIL("expected not configured"); } catch (const NotConfiguredError& e) { ASSERT_EQ(e.http_status(), 503); ASSERT_TRUE(e.message().find("OPENAI_API_KEY") != std::string::npos); } ASSERT_EQ(r.sent(), 0u); } TEST(oai_calls, requests_carry_the_expected_method_path_auth_and_beta_headers) { Rig r; r.platform->files.retrieve("file-abc"); ASSERT_EQ(r.last().method, "GET"); ASSERT_EQ(r.last().target, "/v1/files/file-abc"); ASSERT_EQ(r.last().headers.get_or("Authorization", ""), "Bearer sk-test-KEY"); ASSERT_EQ(r.last().headers.get_or("OpenAI-Beta", ""), ""); ASSERT_EQ(r.last().target.find("sk-test"), std::string::npos); r.platform->threads.retrieve("thread_1"); ASSERT_EQ(r.last().target, "/v1/threads/thread_1"); ASSERT_EQ(r.last().headers.get_or("OpenAI-Beta", ""), "assistants=v2"); r.platform->chatkit.retrieve_thread("cthr_1"); ASSERT_EQ(r.last().target, "/v1/chatkit/threads/cthr_1"); ASSERT_EQ(r.last().headers.get_or("OpenAI-Beta", ""), "chatkit_beta=v1"); r.platform->files.remove("file-abc"); ASSERT_EQ(r.last().method, "DELETE"); r.platform->fine_tuning_jobs.cancel("ftjob-1"); ASSERT_EQ(r.last().method, "POST"); ASSERT_EQ(r.last().target, "/v1/fine_tuning/jobs/ftjob-1/cancel"); Json body = Json::object(); body.set("project_ids", Json::array()); r.platform->fine_tuning_permissions.remove("ft:gpt-4o:org::abc:ckpt-step-1", "cp_1"); ASSERT_EQ(r.last().target, "/v1/fine_tuning/checkpoints/ft:gpt-4o:org::abc:ckpt-step-1/permissions/cp_1"); } TEST(oai_calls, org_and_project_headers_come_from_config) { setenv("OPENAI_ORG_ID", "org-test_1", 1); setenv("OPENAI_PROJECT_ID", "proj_test-2", 1); auto cfg = PlatformConfig::api_config(); ASSERT_EQ(cfg.default_headers["OpenAI-Organization"], "org-test_1"); ASSERT_EQ(cfg.default_headers["OpenAI-Project"], "proj_test-2"); ASSERT_EQ(cfg.key_env, "OPENAI_API_KEY"); setenv("OPENAI_ORG_ID", "bad\r\nX: y", 1); ASSERT_THROW(PlatformConfig::api_config(), ApiError); unsetenv("OPENAI_ORG_ID"); unsetenv("OPENAI_PROJECT_ID"); ASSERT_TRUE(PlatformConfig::api_config().default_headers.empty()); } TEST(oai_calls, query_strings) { Rig r; Json q = Json::object(); q.set("limit", Json(5)); q.set("order", Json("desc")); q.set("after", Json("file a&b")); r.platform->files.list(q); ASSERT_EQ(r.last().target, "/v1/files?after=file%20a%26b&limit=5&order=desc"); Json bad = Json::object(); bad.set("nope", Json(1)); ASSERT_THROW(r.platform->files.list(bad), ApiError); Json big = Json::object(); big.set("limit", Json(10001)); ASSERT_THROW(r.platform->files.list(big), ApiError); Json zero = Json::object(); zero.set("limit", Json(0)); ASSERT_THROW(r.platform->files.list(zero), ApiError); // array: repeated key; deepObject: key[sub] Json inc = Json::object(); Json arr = Json::array(); arr.push(Json("a.b")); arr.push(Json("c")); inc.set("include", arr); r.platform->conversation_items.list("conv_1", inc); ASSERT_EQ(r.last().target, "/v1/conversations/conv_1/items?include=a.b&include=c"); Json meta = Json::object(); Json m = Json::object(); m.set("team", Json("x y")); meta.set("metadata", m); r.platform->fine_tuning_jobs.list(meta); ASSERT_EQ(r.last().target, "/v1/fine_tuning/jobs?metadata%5Bteam%5D=x%20y"); Json steps = Json::object(); Json sa = Json::array(); sa.push(Json("step_details.tool_calls[*].file_search.results[*].content")); steps.set("include[]", sa); r.platform->runs.steps("t_1", "run_1", steps); ASSERT_TRUE(r.last().target.find("include%5B%5D=step_details.tool_calls%5B%2A%5D") != std::string::npos); } TEST(oai_calls, idempotency_key_only_where_the_spec_allows) { Rig r; Json body = Json::object(); Json env = Json::object(); env.set("type", Json("x")); body.set("environment", env); r.platform->agent_environments.create(body, "key-123"); ASSERT_EQ(r.last().headers.get_or("Idempotency-Key", ""), "key-123"); ASSERT_THROW(r.platform->generic.invoke(Op::kRetrieveFile, {{"file_id", "a"}}, nullptr, Json::object(), {{"Idempotency-Key", "k"}}), ApiError); ASSERT_THROW(r.platform->agent_environments.create(body, "has space"), ApiError); ASSERT_THROW(r.platform->generic.invoke(Op::kRetrieveFile, {{"file_id", "a"}}, nullptr, Json::object(), {{"OpenAI-Beta", "x"}}), ApiError); } TEST(oai_forms, files_create_is_multipart_with_bracket_notation) { Rig r; Json exp = Json::object(); exp.set("anchor", Json("created_at")); exp.set("seconds", Json(3600)); r.platform->files.create("data.jsonl", "{\"a\":1}\n", "fine-tune", "application/jsonl", &exp); ASSERT_EQ(r.last().method, "POST"); ASSERT_EQ(r.last().target, "/v1/files"); ASSERT_TRUE(r.last().headers.get_or("Content-Type", "").rfind("multipart/form-data; boundary=", 0) == 0); const std::string& b = r.last().body; ASSERT_TRUE(b.find("name=\"file\"; filename=\"data.jsonl\"") != std::string::npos); ASSERT_TRUE(b.find("name=\"purpose\"") != std::string::npos); ASSERT_TRUE(b.find("fine-tune") != std::string::npos); ASSERT_TRUE(b.find("name=\"expires_after[anchor]\"") != std::string::npos); ASSERT_TRUE(b.find("name=\"expires_after[seconds]\"") != std::string::npos); ASSERT_TRUE(b.find("3600") != std::string::npos); ASSERT_THROW(r.platform->files.create("x", "d", "bogus-purpose"), ApiError); ASSERT_THROW(r.platform->files.create("a/b", "d", "batch"), ApiError); ASSERT_THROW(r.platform->files.create("a\"b", "d", "batch"), ApiError); ASSERT_THROW(r.platform->files.create("", "d", "batch"), ApiError); } TEST(oai_forms, form_fields_are_checked_against_the_table) { Form f; f.text("purpose", "batch"); ASSERT_THROW(Calls::check_form(Op::kCreateFile, f.names()), ApiError); // file missing Form g; g.file("file", "a", "text/plain", "x"); g.text("purpose", "batch"); g.text("surprise", "1"); ASSERT_THROW(Calls::check_form(Op::kCreateFile, g.names()), ApiError); ASSERT_THROW(Calls::check_form(Op::kListFiles, {}), ApiError); // not multipart Form skills; skills.file("files[]", "SKILL.md", "text/markdown", "# x"); Calls::check_form(Op::kCreateSkill, skills.names()); } TEST(oai_uploads, plan_and_sequence) { auto plan = UploadPlan::make(10, 4); ASSERT_EQ(plan.parts.size(), 3u); ASSERT_EQ(plan.parts[2].offset, 8u); ASSERT_EQ(plan.parts[2].size, 2u); ASSERT_THROW(UploadPlan::make(0, 4), ApiError); ASSERT_THROW(UploadPlan::make(10, 0), ApiError); ASSERT_THROW(UploadPlan::make(10, Caps::kMaxUploadPartBytes + 1), ApiError); ASSERT_THROW(UploadPlan::make(Caps::kMaxFileBytes + 1, Caps::kMaxUploadPartBytes), ApiError); ASSERT_THROW(UploadPlan::make(Caps::kMaxUploadParts + 1, 1), ApiError); // The module's own request sequence for a three-part upload. The queued // bodies only carry the ids the next call needs (documented field `id`). Rig r; r.transport->queue = {"{\"id\":\"upload_1\"}", "{\"id\":\"part_1\"}", "{\"id\":\"part_2\"}", "{\"id\":\"part_3\"}", "{\"id\":\"upload_1\",\"status\":\"completed\"}"}; r.platform->uploads.upload_all("big.jsonl", "application/jsonl", "batch", "0123456789", 4); ASSERT_EQ(r.sent(), 5u); ASSERT_EQ(r.transport->seen[0].target, "/v1/uploads"); ASSERT_TRUE(r.transport->seen[0].body.find("\"bytes\":10") != std::string::npos); ASSERT_EQ(r.transport->seen[1].target, "/v1/uploads/upload_1/parts"); ASSERT_EQ(r.transport->seen[3].target, "/v1/uploads/upload_1/parts"); ASSERT_EQ(r.transport->seen[4].target, "/v1/uploads/upload_1/complete"); ASSERT_EQ(r.transport->seen[4].body, "{\"part_ids\":[\"part_1\",\"part_2\",\"part_3\"]}"); } TEST(oai_batches, jsonl_builder_caps) { BatchInput in("/v1/chat/completions"); Json body = Json::object(); body.set("model", Json("gpt-x")); in.add("req-1", body).add("req-2", body); ASSERT_EQ(in.size(), 2u); ASSERT_EQ(in.jsonl().substr(0, in.jsonl().find('\n')), "{\"body\":{\"model\":\"gpt-x\"},\"custom_id\":\"req-1\",\"method\":\"POST\",\"url\":\"/v1/chat/completions\"}"); ASSERT_THROW(in.add("req-1", body), ApiError); ASSERT_THROW(in.add("", body), ApiError); ASSERT_THROW(in.add(std::string(513, 'x'), body), ApiError); ASSERT_THROW(in.add("r3", Json("not an object")), ApiError); ASSERT_THROW(BatchInput("/v1/nope"), ApiError); Rig r; ASSERT_THROW(r.platform->batches.create("file-1", "/v1/nope"), ApiError); r.platform->batches.create("file-1", "/v1/embeddings"); ASSERT_EQ(r.last().body, "{\"completion_window\":\"24h\",\"endpoint\":\"/v1/embeddings\",\"input_file_id\":\"file-1\"}"); } TEST(oai_conversations, twenty_items_at_most) { Rig r; Json body = Json::object(); Json items = Json::array(); for (int i = 0; i < 21; ++i) items.push(Json::object()); body.set("items", items); ASSERT_THROW(r.platform->conversation_items.create("conv_1", body), ApiError); ASSERT_THROW(r.platform->conversations.create(body), ApiError); ASSERT_EQ(r.sent(), 0u); } TEST(oai_list, walks_cursor_pages_and_reports_truncation) { // Page shape per the spec's list schemas: data[], has_more, last_id. Rig r; r.transport->queue = {"{\"data\":[{\"id\":\"a\"},{\"id\":\"b\"}],\"has_more\":true,\"last_id\":\"b\"}", "{\"data\":[{\"id\":\"c\"}],\"has_more\":false,\"last_id\":\"c\"}"}; auto l = r.platform->generic.list_all(Op::kListFiles, {}, Json::object(), 5); ASSERT_EQ(l.pages, 2u); ASSERT_EQ(l.data.as_array().size(), 3u); ASSERT_FALSE(l.truncated); ASSERT_EQ(r.transport->seen[1].target, "/v1/files?after=b"); Rig t; t.transport->queue = {"{\"data\":[{\"id\":\"a\"}],\"has_more\":true,\"last_id\":\"a\"}", "{\"data\":[{\"id\":\"b\"}],\"has_more\":true,\"last_id\":\"b\"}"}; auto cut = t.platform->generic.list_all(Op::kListFiles, {}, Json::object(), 2); ASSERT_TRUE(cut.truncated); ASSERT_TRUE(cut.has_more); ASSERT_EQ(cut.stop_reason, "page_cap"); ASSERT_EQ(cut.pages, 2u); ASSERT_THROW(t.platform->generic.list_all(Op::kRetrieveFile, {{"file_id", "a"}}), ApiError); // not a list ASSERT_THROW(t.platform->generic.list_all(Op::kListFiles, {}, Json::object(), 0), ApiError); } TEST(oai_streams, only_streamable_calls_stream) { Rig r; Json body = Json::object(); body.set("assistant_id", Json("asst_1")); ASSERT_THROW(r.platform->generic.invoke_stream(Op::kRetrieveFile, {{"file_id", "a"}}, Json::object(), [](const molo::llm::SseEvent&) { return true; }), ApiError); // A streamable call sets "stream": true before sending. r.transport->queue = {"data: [DONE]\n\n"}; r.platform->runs.create_stream("thread_1", body, [](const molo::llm::SseEvent&) { return true; }); ASSERT_EQ(r.last().target, "/v1/threads/thread_1/runs"); ASSERT_TRUE(r.last().body.find("\"stream\":true") != std::string::npos); ASSERT_EQ(r.last().headers.get_or("OpenAI-Beta", ""), "assistants=v2"); } TEST(oai_realtime_rest, call_and_secret_requests) { Rig r; r.platform->realtime.create_client_secret(); ASSERT_EQ(r.last().target, "/v1/realtime/client_secrets"); ASSERT_THROW(r.platform->realtime.create_call("not sdp"), ApiError); r.platform->realtime.create_call("v=0\r\no=- 1 1 IN IP4 0.0.0.0\r\n"); ASSERT_EQ(r.last().target, "/v1/realtime/calls"); ASSERT_EQ(r.last().headers.get_or("Content-Type", ""), "application/sdp"); r.platform->realtime.create_call("v=0\r\n", Json::object()); ASSERT_TRUE(r.last().headers.get_or("Content-Type", "").rfind("multipart/form-data", 0) == 0); ASSERT_TRUE(r.last().body.find("name=\"sdp\"") != std::string::npos); ASSERT_TRUE(r.last().body.find("name=\"session\"") != std::string::npos); ASSERT_THROW(r.platform->realtime.refer_call("call_1", "http://x"), ApiError); r.platform->realtime.refer_call("call_1", "tel:+14155550123"); ASSERT_EQ(r.last().body, "{\"target_uri\":\"tel:+14155550123\"}"); ASSERT_THROW(r.platform->realtime.reject_call("call_1", 200), ApiError); r.platform->realtime.reject_call("call_1", 486); ASSERT_EQ(r.last().body, "{\"status_code\":486}"); r.platform->realtime.hangup_call("call_1"); ASSERT_EQ(r.last().target, "/v1/realtime/calls/call_1/hangup"); ASSERT_THROW(r.platform->live.reject("s_1", 0), ApiError); }