#include "server_internal.h" #include "util.h" #include "sbuf.h" #include "base64.h" #include "ffwd.h" #include #include #include /* ======================================================================== * Embedding output encoding * * Turns a pooled float vector into the requested wire form. OpenAI-compatible * models emit true float32 arrays by default. Perplexity-compatible models * emit tanh-quantized int8 by default, and their "float" view is the decoded * int8 value for SDK compatibility. * ======================================================================== */ signed char quantize_int8_tanh(float x) { int v = (int)lrintf(tanhf(x) * 127.0f); if (v > 127) v = 127; if (v < -128) v = -128; return (signed char)v; } /* The bytes to base64 for `encoding`. "base64" aliases the float vector * (*owned = 0); "base64_int8" and "base64_binary" return a freshly allocated * buffer the caller frees (*owned = 1). */ static const unsigned char * embedding_bytes(const float *emb, int dims, const char *encoding, size_t *n_out, int *owned) { if (!strcmp(encoding, "base64")) { /* OpenAI/DashScope (Qwen3): raw little-endian float32. x86_64 and aarch64 * are little-endian, so the float bytes are the base64 wire format as-is. */ *owned = 0; *n_out = (size_t)dims * sizeof(float); return (const unsigned char *)emb; } if (!strcmp(encoding, "base64_binary")) { size_t bytes = (size_t)dims / 8; unsigned char *bits = xcalloc(bytes, 1); for (int i = 0; i < dims; i++) { if (emb[i] >= 0.0f) bits[(size_t)i >> 3] |= (unsigned char)(1u << (i & 7)); } *owned = 1; *n_out = bytes; return bits; } /* base64_int8 (Perplexity default): tanh-quantized signed bytes. */ signed char *q = xmalloc((size_t)dims); for (int i = 0; i < dims; i++) q[i] = quantize_int8_tanh(emb[i]); *owned = 1; *n_out = (size_t)dims; return (const unsigned char *)q; } /* Append the base64 of src to b: reserve the exact output length and encode it * in place. */ static void sbuf_append_base64(sbuf *b, const unsigned char *src, size_t n) { size_t out_len = base64_encoded_len(n); sbuf_reserve(b, out_len); base64_encode_to(b->ptr + b->len, src, n); b->len += out_len; b->ptr[b->len] = '\0'; } void append_embedding_value( sbuf *b, int index, const float *emb, int dims, const char *encoding, embedding_api_t api) { if (!strcmp(encoding, "float")) { /* Floats are hand-formatted with %.9g (the shortest form that * round-trips float32) and streamed into the sbuf, never serialized * through yyjson's writer. */ sbuf_printf(b, "{\"object\":\"embedding\",\"index\":%d,\"embedding\":[", index); for (int i = 0; i < dims; i++) { if (i) sbuf_putc(b, ','); float v = api == FFWD_API_PERPLEXITY ? (float)quantize_int8_tanh(emb[i]) / 128.0f : emb[i]; sbuf_printf(b, "%.9g", (double)v); } sbuf_puts(b, "]}"); return; } /* base64 family: int8, binary, or raw float32 bytes, base64-encoded. */ size_t n; int owned; const unsigned char *bytes = embedding_bytes(emb, dims, encoding, &n, &owned); sbuf_printf(b, "{\"object\":\"embedding\",\"index\":%d,\"embedding\":\"", index); sbuf_append_base64(b, bytes, n); sbuf_puts(b, "\"}"); if (owned) free((void *)bytes); } void set_response_from_buf(job *j, sbuf *b) { j->status = 200; j->content_type = "application/json"; j->response = b->ptr; j->response_len = b->len; memset(b, 0, sizeof(*b)); } int render_embedding_response(embedding_request *r, const float *embs) { const int full_dim = r->model->info->dim; const float *render_embs = embs; float *truncated = NULL; if (r->model->renormalize_truncated && r->dims < full_dim) { truncated = xmalloc((size_t)r->n_inputs * r->dims * sizeof(*truncated)); for (int i = 0; i < r->n_inputs; i++) { float *dst = truncated + (size_t)i * r->dims; memcpy(dst, embs + (size_t)i * full_dim, (size_t)r->dims * sizeof(*dst)); if (ffwd_l2_normalize(dst, r->dims) != 0) { free(truncated); return -1; } } render_embs = truncated; } int render_stride = truncated ? r->dims : full_dim; embedding_api_t api = r->model->info->api; sbuf b = {0}; sbuf_puts(&b, "{\"object\":\"list\",\"data\":["); for (int i = 0; i < r->n_inputs; i++) { if (i) sbuf_putc(&b, ','); append_embedding_value(&b, i, render_embs + (size_t)i * render_stride, r->dims, r->encoding, api); } sbuf_printf(&b, "],\"model\":\"%s\",\"usage\":{\"prompt_tokens\":%d," "\"total_tokens\":%d}}", r->model->info->id, r->total_tokens, r->total_tokens); set_response_from_buf(r->j, &b); free(truncated); return 0; } void job_render_free(job *j) { if (!j) return; free(j->embedding_render.encoding); free(j->embedding_render.embs); memset(&j->embedding_render, 0, sizeof(j->embedding_render)); j->render_kind = 0; } void job_set_embedding_render(job *j, const embedding_request *r, const float *embs) { if (!j || !r || !r->model || !embs) return; job_render_free(j); size_t count = (size_t)r->n_inputs * (size_t)r->model->info->dim; j->embedding_render.model = r->model; j->embedding_render.encoding = xstrdup(r->encoding); j->embedding_render.embs = xmalloc(count * sizeof(*j->embedding_render.embs)); memcpy(j->embedding_render.embs, embs, count * sizeof(*j->embedding_render.embs)); j->embedding_render.dims = r->dims; j->embedding_render.n_inputs = r->n_inputs; j->embedding_render.total_tokens = r->total_tokens; j->render_kind = 1; } int render_job_response(job *j) { if (!j || j->render_kind == 0) return 0; if (j->render_kind != 1 || !j->embedding_render.model || !j->embedding_render.encoding || !j->embedding_render.embs) return -1; embedding_request r; memset(&r, 0, sizeof(r)); r.j = j; r.model = j->embedding_render.model; r.dims = j->embedding_render.dims; r.encoding = j->embedding_render.encoding; r.n_inputs = j->embedding_render.n_inputs; r.total_tokens = j->embedding_render.total_tokens; return render_embedding_response(&r, j->embedding_render.embs); } void render_contextual_response(contextual_request *r, const float *embs) { sbuf b = {0}; sbuf_puts(&b, "{\"object\":\"list\",\"data\":["); int span_offset = 0; for (int di = 0; di < r->n_docs; di++) { if (di) sbuf_putc(&b, ','); sbuf_printf(&b, "{\"object\":\"list\",\"index\":%d,\"data\":[", di); for (int ci = 0; ci < r->docs[di].n_spans; ci++) { if (ci) sbuf_putc(&b, ','); const float *emb = embs + (size_t)span_offset * r->model->info->dim; append_embedding_value(&b, ci, emb, r->dims, r->encoding, r->model->info->api); span_offset++; } sbuf_puts(&b, "]}"); } sbuf_printf(&b, "],\"model\":\"%s\",\"usage\":{\"prompt_tokens\":%d,\"total_tokens\":%d}}", r->model->info->id, r->total_tokens, r->total_tokens); set_response_from_buf(r->j, &b); }