if (v.empty()) return false;

bool all_zero = true;

bool all_same = true;

double sumsq = 0.0;

for (size_t i = 0; i < v.size(); ++i) {

if (!std::isfinite(v[i])) return false; // NaN/Inf

if (v[i] != 0.0f) all_zero = false;

if (v[i] != v[0]) all_same = false;

sumsq += static_cast<double>(v[i]) * v[i];

}

if (all_zero || all_same) return false;

// A real embedding has non-trivial magnitude; L2 norm collapsing to

// ~0 (denormals/underflow) is another sign of garbage output.

if (sumsq < 1e-12) return false;

return true;

std::filesystem::path model_path = std::filesystem::path(model_dir) / "model.onnx";

// Some HuggingFace repos put the ONNX model in an onnx/ subdirectory.

if (!std::filesystem::exists(model_path)) {

model_path = std::filesystem::path(model_dir) / "onnx" / "model.onnx";

}

std::filesystem::path tokenizer_path = std::filesystem::path(model_dir) / "tokenizer.json";

if (!std::filesystem::exists(model_path)) {

throw std::runtime_error(std::format(lang::ERR_MODEL_NOT_FOUND, model_path.string()));

}

if (!std::filesystem::exists(tokenizer_path)) {

throw std::runtime_error(std::format(lang::ERR_TOKENIZER_NOT_FOUND, tokenizer_path.string()));

}

tokenizer = std::make_unique<TokenizerWrapper>(tokenizer_path.string());

session = std::make_unique<Ort::Session>(env, model_path.c_str(), session_options);

onnx_dims = config().embedding_dimensions;

auto encoded = tokenizer->encode_with_mask(text);

const auto& input_ids = encoded.input_ids;

const auto& attention_mask = encoded.attention_mask;

size_t seq_len = input_ids.size();

if (seq_len == 0) {

throw std::runtime_error(lang::ERR_EMPTY_TOKENIZATION);

}

Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);

std::vector<int64_t> shape = {1, static_cast<int64_t>(seq_len)};

std::vector<int64_t> input_ids_i64(input_ids.begin(), input_ids.end());

std::vector<int64_t> attention_mask_i64(attention_mask.begin(), attention_mask.end());

std::vector<int64_t> token_type_ids_i64(seq_len, 0);

Ort::Value input_ids_tensor = Ort::Value::CreateTensor<int64_t>(

memory_info, input_ids_i64.data(), input_ids_i64.size(), shape.data(), shape.size());

Ort::Value attention_mask_tensor = Ort::Value::CreateTensor<int64_t>(

memory_info, attention_mask_i64.data(), attention_mask_i64.size(), shape.data(), shape.size());

Ort::Value token_type_ids_tensor = Ort::Value::CreateTensor<int64_t>(

memory_info, token_type_ids_i64.data(), token_type_ids_i64.size(), shape.data(), shape.size());

const char* input_names[] = {"input_ids", "attention_mask", "token_type_ids"};

const char* output_names[] = {"last_hidden_state"};

std::vector<Ort::Value> input_tensors;

input_tensors.push_back(std::move(input_ids_tensor));

input_tensors.push_back(std::move(attention_mask_tensor));

input_tensors.push_back(std::move(token_type_ids_tensor));

auto output_tensors = session->Run(

Ort::RunOptions{nullptr},

input_names, input_tensors.data(), 3,

output_names, 1

);

float* output_data = output_tensors[0].GetTensorMutableData<float>();

auto output_shape = output_tensors[0].GetTensorTypeAndShapeInfo().GetShape();

if (output_shape.size() != 3 || output_shape[0] != 1 || output_shape[2] != onnx_dims) {

throw std::runtime_error(lang::ERR_OUTPUT_SHAPE);

}

size_t output_seq_len = output_shape[1];

size_t hidden_size = output_shape[2];

// Mean pooling with attention mask

std::vector<float> pooled(hidden_size, 0.0f);

float mask_sum = 0.0f;

for (size_t i = 0; i < output_seq_len; ++i) {

float mask_value = static_cast<float>(attention_mask[i]);

mask_sum += mask_value;

for (size_t j = 0; j < hidden_size; ++j) {

pooled[j] += output_data[i * hidden_size + j] * mask_value;

}

}

if (mask_sum > 0.0f) {

for (auto& val : pooled) val /= mask_sum;

}

// L2 normalization

float norm = 0.0f;

for (float val : pooled) norm += val * val;

norm = std::sqrt(norm);

if (norm > 1e-12f) {

for (auto& val : pooled) val /= norm;

}

return pooled;

json body = {

{"input", text},

{"model", ext_model}

};

// Pass dimensions if explicitly set (MRL / truncated models).

if (ext_dims > 0) {

body["dimensions"] = ext_dims;

}

std::string payload = body.dump();

std::string url = base_url() + "/v1/embeddings";

std::vector<std::string> headers{"Content-Type: application/json"};

if (!ext_api_key.empty()) {

headers.push_back(util::bearer_header(ext_api_key));

}

util::HttpClient http;

auto resp = http.post(url, payload, headers, /*timeout_sec=*/30);

if (!resp.ok()) {

throw std::runtime_error(std::format("Embedding request failed: {}", resp.error));

}

auto j = json::parse(resp.body, nullptr, false);

if (j.is_discarded()) {

throw std::runtime_error("Failed to parse embedding response");

}

// OpenAI format: { "data": [ { "embedding": [...] } ] }

if (!j.contains("data") || !j["data"].is_array() || j["data"].empty()) {

// Check for error

if (j.contains("error")) {

std::string msg = j["error"].is_string()

? j["error"].get<std::string>()

: j["error"].value("message", "unknown error");

throw std::runtime_error("Embedding API error: " + msg);

}

throw std::runtime_error("Unexpected embedding response format");

}

auto& emb = j["data"][0]["embedding"];

if (!emb.is_array()) {

throw std::runtime_error("Embedding response missing 'embedding' array");

}

// Record which model the server says actually served the request —

// llama-swap / LM Studio may answer with a different loaded model

// than the one requested. The probe route surfaces this mismatch.

last_served_model = j.value("model", "");

std::vector<float> vec;

vec.reserve(emb.size());

for (const auto& v : emb) {

vec.push_back(v.get<float>());

}

return vec;

// Empty, not an exception: callers gate on ready() and defer the

// write. Returning empty keeps a stray call from taking the daemon

// down, but an empty vector must never reach bind_embedding().

if (disabled) return {};

if (external) return encode_external(text);

return encode_onnx(text);

if (disabled) return 0;

if (external) return ext_dims;

return onnx_dims;

if (!external) return {};

std::string url = base_url() + "/v1/models";

std::vector<std::string> headers;

if (!ext_api_key.empty()) {

headers.push_back(util::bearer_header(ext_api_key));

}

util::HttpClient http;

auto resp = http.get(url, headers, /*timeout_sec=*/10);

if (!resp.ok()) return {};

auto j = json::parse(resp.body, nullptr, false);

if (j.is_discarded() || !j.contains("data") || !j["data"].is_array())

return {};

std::vector<std::string> models;

for (const auto& m : j["data"]) {

if (m.contains("id") && m["id"].is_string()) {

models.push_back(m["id"].get<std::string>());

}

}

return models;

if (!external) return 0;

last_probe_sane = false;

try {

auto vec = encode_external("dimension probe");

last_probe_sane = is_plausible_embedding(vec);

return static_cast<int>(vec.size());

} catch (...) {

return 0;

}

if (!ready()) return std::nullopt;

auto vec = encode(text);

if (vec.empty()) return std::nullopt;

return vec;

std::vector<std::optional<std::vector<float>>> out;

out.reserve(texts.size());

for (const auto& t : texts) out.push_back(embed(t));

return out;