#include "vendors/perplexity/batches.h" #include "clients/body/form.h" #include "vendors/perplexity/calls.h" #include "vendors/perplexity/caps.h" #include "vendors/perplexity/rules.h" namespace molo::perplexity { BatchFileInfo BatchFileInfo::parse(const Json& doc) { BatchFileInfo f; f.id = J::str(doc, "id"); f.filename = J::str(doc, "filename"); f.purpose = J::str(doc, "purpose"); f.bytes = J::num(doc, "bytes"); f.created_at = J::num(doc, "created_at"); f.expires_at = J::num(doc, "expires_at"); f.deleted = J::flag(doc, "deleted"); return f; } BatchInfo BatchInfo::parse(const Json& doc) { BatchInfo b; b.raw = doc; b.id = J::str(doc, "id"); b.endpoint = J::str(doc, "endpoint"); b.input_file_id = J::str(doc, "input_file_id"); b.output_file_id = J::str(doc, "output_file_id"); b.error_file_id = J::str(doc, "error_file_id"); b.completion_window = J::str(doc, "completion_window"); b.status = J::str(doc, "status"); b.created_at = J::num(doc, "created_at"); b.in_progress_at = J::num(doc, "in_progress_at"); b.expires_at = J::num(doc, "expires_at"); b.finalizing_at = J::num(doc, "finalizing_at"); b.completed_at = J::num(doc, "completed_at"); b.failed_at = J::num(doc, "failed_at"); b.expired_at = J::num(doc, "expired_at"); b.cancelling_at = J::num(doc, "cancelling_at"); b.cancelled_at = J::num(doc, "cancelled_at"); if (const Json* c = J::obj(doc, "request_counts")) { b.total = J::num(*c, "total"); b.completed = J::num(*c, "completed"); b.failed = J::num(*c, "failed"); } if (const Json* u = J::obj(doc, "usage")) { b.input_tokens = J::num(*u, "input_tokens"); b.output_tokens = J::num(*u, "output_tokens"); b.total_tokens = J::num(*u, "total_tokens"); } if (const Json* e = J::obj(doc, "errors")) if (const Json* d = J::arr(*e, "data")) for (const Json& x : d->as_array()) { if (b.errors.size() >= PerplexityCaps::kMaxItemsReturned) break; b.errors.push_back({J::str(x, "code"), J::str(x, "message"), J::num(x, "line")}); } if (const Json* m = J::obj(doc, "metadata")) for (const auto& [k, v] : m->as_object()) if (v.is_string()) b.metadata[k] = v.as_string(); return b; } bool BatchInfo::finished() const { return status == "completed" || status == "expired" || status == "cancelled" || status == "failed"; } void BatchInput::validate() const { Rules::filename(filename); Rules::require(!jsonl.empty(), "the batch input is empty"); Rules::require(jsonl.size() <= PerplexityCaps::kBatchFileBytes, "batch input over 200 MB"); std::size_t lines = 0, pos = 0; while (pos < jsonl.size()) { std::size_t end = jsonl.find('\n', pos); if (end == std::string::npos) end = jsonl.size(); std::string line = jsonl.substr(pos, end - pos); pos = end + 1; if (line.find_first_not_of(" \t\r") == std::string::npos) continue; ++lines; Rules::require(lines <= PerplexityCaps::kBatchFileLines, "batch input over 50,000 lines"); try { Rules::require(Json::parse(line).is_object(), "line " + std::to_string(lines) + " is not a JSON object"); } catch (const clients::body::JsonError&) { Rules::fail("line " + std::to_string(lines) + " is not valid JSON"); } } Rules::require(lines > 0, "the batch input has no request lines"); } namespace { std::string page_query(int limit, const std::string& after) { std::string q; if (limit) { Rules::require(limit >= 1 && limit <= PerplexityCaps::kPageLimitMax, "limit must be 1..100"); Rules::add_query(q, "limit", std::to_string(limit)); } if (!after.empty()) { Rules::require(llm::Service::valid_id(after), "bad after cursor"); Rules::add_query(q, "after", after); } return q; } } // namespace BatchFileInfo BatchFiles::upload(const BatchInput& input) { input.validate(); clients::body::MultipartBody form; form.add_text("purpose", "batch"); form.add_file("file", input.filename, "application/jsonl", input.jsonl); return BatchFileInfo::parse(client_->post_multipart(Calls::render(Call::kFileCreate), form)); } BatchFileList BatchFiles::list(int limit, const std::string& after, const std::string& order, const std::string& purpose) { std::string q = page_query(limit, after); if (!order.empty()) { Rules::one_of(order, {"asc", "desc"}, "order"); Rules::add_query(q, "order", order); } if (!purpose.empty()) { Rules::one_of(purpose, {"batch", "batch_output"}, "purpose"); Rules::add_query(q, "purpose", purpose); } Json doc = client_->get(Calls::render(Call::kFileList) + q); BatchFileList l; l.first_id = J::str(doc, "first_id"); l.last_id = J::str(doc, "last_id"); l.has_more = J::flag(doc, "has_more"); if (const Json* d = J::arr(doc, "data")) for (const Json& f : d->as_array()) { if (l.files.size() >= PerplexityCaps::kMaxItemsReturned) { l.truncated = true; break; } l.files.push_back(BatchFileInfo::parse(f)); } return l; } BatchFileInfo BatchFiles::get(const std::string& file_id) { check_id("file", file_id); return BatchFileInfo::parse(client_->get(Calls::render(Call::kFileGet, file_id))); } BatchFileInfo BatchFiles::remove(const std::string& file_id) { check_id("file", file_id); return BatchFileInfo::parse(client_->del(Calls::render(Call::kFileDelete, file_id))); } std::string BatchFiles::content(const std::string& file_id) { check_id("file", file_id); return client_->request_raw(Calls::method_of(Call::kFileContent), Calls::render(Call::kFileContent, file_id)).body; } BatchInfo Batches::create(const std::string& input_file_id, const std::map& metadata, const std::string& idempotency_key) { check_id("input file", input_file_id); Json body = Json::object(); body.set("input_file_id", Json(input_file_id)); body.set("endpoint", Json("/v1/responses")); body.set("completion_window", Json("24h")); if (!metadata.empty()) { Rules::require(metadata.size() <= PerplexityCaps::kBatchMetadataPairs, "at most 16 metadata pairs"); Json m = Json::object(); for (const auto& [k, v] : metadata) { Rules::require(!k.empty() && k.size() <= PerplexityCaps::kBatchMetadataKey, "metadata keys are 1..64 characters"); Rules::require(v.size() <= PerplexityCaps::kBatchMetadataValue, "metadata values are at most 512 characters"); m.set(k, Json(v)); } body.set("metadata", m); } llm::Headers extra; if (!idempotency_key.empty()) { Rules::require(idempotency_key.size() <= PerplexityCaps::kIdempotencyKey, "Idempotency-Key over 200 characters"); for (char c : idempotency_key) Rules::require(static_cast(c) > 0x20 && c != 0x7f, "Idempotency-Key has invalid characters"); extra["Idempotency-Key"] = idempotency_key; } return BatchInfo::parse(client_->post(Calls::render(Call::kBatchCreate), body, extra)); } BatchList Batches::list(int limit, const std::string& after) { Json doc = client_->get(Calls::render(Call::kBatchList) + page_query(limit, after)); BatchList l; l.first_id = J::str(doc, "first_id"); l.last_id = J::str(doc, "last_id"); l.has_more = J::flag(doc, "has_more"); if (const Json* d = J::arr(doc, "data")) for (const Json& b : d->as_array()) { if (l.batches.size() >= PerplexityCaps::kMaxItemsReturned) { l.truncated = true; break; } l.batches.push_back(BatchInfo::parse(b)); } return l; } BatchInfo Batches::get(const std::string& batch_id) { check_id("batch", batch_id); return BatchInfo::parse(client_->get(Calls::render(Call::kBatchGet, batch_id))); } BatchInfo Batches::cancel(const std::string& batch_id) { check_id("batch", batch_id); Json empty = Json::object(); return BatchInfo::parse(client_->post(Calls::render(Call::kBatchCancel, batch_id), empty)); } } // namespace molo::perplexity