Files
moloapp/src/meta/client.h
T

81 lines
3.0 KiB
C++

#pragma once
// Builds the ApiClient for the Meta Model API: bearer auth against
// https://api.meta.ai/v1. The credential is META_API_KEY, or MODEL_API_KEY
// (the name the docs' own examples use), looked up through llm::Config.
// Also the retry policy the docs prescribe (exponential backoff with jitter on
// 429 and transient 5xx, never on 504 or other 4xx).
#include <chrono>
#include <functional>
#include <memory>
#include <string>
#include <thread>
#include "llm/api_client.h"
#include "llm/error.h"
namespace molo::meta {
struct MetaEndpoints {
static constexpr const char* kVendor = "meta";
static constexpr const char* kBaseUrl = "https://api.meta.ai/v1";
static constexpr const char* kRealtimeUrl = "wss://api.meta.ai/v1/asr/realtime";
static constexpr const char* kKeyEnv = "META_API_KEY";
static constexpr const char* kAltKeyEnv = "MODEL_API_KEY";
};
class MetaClient {
public:
// META_API_KEY first, then MODEL_API_KEY; empty when neither is set.
static std::string key_from_env();
static llm::ApiClientConfig config(const std::string& base_url = MetaEndpoints::kBaseUrl);
// Real HTTPS transport, key from the environment (null key is fine: every
// keyed call then throws NotConfiguredError before any traffic).
static std::shared_ptr<llm::ApiClient> from_env();
// Same, with an explicit key (empty = not configured).
static std::shared_ptr<llm::ApiClient> with_key(const std::string& key);
// Client for the one unauthenticated endpoint (GET /status). The docs say no
// key is needed; a probe on 2026-10-24 showed a bogus bearer is ignored, so
// a fixed placeholder is sent to satisfy ApiClient's non-empty key rule.
static std::shared_ptr<llm::ApiClient> unauthenticated();
static constexpr const char* kPlaceholderKey = "unauthenticated";
};
struct RetryDecision {
bool retry = false;
int delay_ms = 0;
std::string reason;
};
class RetryPolicy {
public:
// 429 and 500/502/503 retry; 504 (gateway_timeout: the same request times
// out again), 400/401/402/403/404/413 and everything else do not.
static bool retryable(const llm::ApiError& error);
// base * 2^attempt capped, plus deterministic jitter in [0, delay/2] derived
// from `seed` so tests are exact. attempt counts from 0.
static int delay_ms(int attempt, unsigned seed);
static RetryDecision decide(const llm::ApiError& error, int attempt, unsigned seed);
};
// Runs `f`, retrying per RetryPolicy up to MetaCaps::kMaxRetries times.
// `sleep` is injectable so callers and tests control the waiting.
template <typename F>
auto call_with_retry(F&& f, unsigned seed = 1,
const std::function<void(int)>& sleep = [](int ms) {
std::this_thread::sleep_for(std::chrono::milliseconds(ms));
}) -> decltype(f()) {
for (int attempt = 0;; ++attempt) {
try {
return f();
} catch (const llm::ApiError& e) {
RetryDecision d = RetryPolicy::decide(e, attempt, seed);
if (!d.retry) throw;
sleep(d.delay_ms);
}
}
}
} // namespace molo::meta