aboutsummaryrefslogtreecommitdiff
path: root/pplx_server.c
diff options
context:
space:
mode:
authorOnur Gündüz <ogunduz@gmail.com>2026-05-30 04:07:37 +0200
committerOnur Gündüz <ogunduz@gmail.com>2026-06-14 08:18:59 +0200
commitab50d908ba2eae14929a07341b1b716cde681c1c (patch)
tree52e3f1f8cd579eb234185dc3b397ac66cda47cbf /pplx_server.c
parent46f9e7c67134caf43a04ea5ee3b2325588647e28 (diff)
downloadffwd-ab50d908ba2eae14929a07341b1b716cde681c1c.tar.gz
ffwd-ab50d908ba2eae14929a07341b1b716cde681c1c.zip
server: implement HTTP API with libae integration
Diffstat (limited to 'pplx_server.c')
-rw-r--r--pplx_server.c1524
1 files changed, 1524 insertions, 0 deletions
diff --git a/pplx_server.c b/pplx_server.c
new file mode 100644
index 0000000..825d448
--- /dev/null
+++ b/pplx_server.c
@@ -0,0 +1,1524 @@
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include "pplx_server.h"
+#include "pplx_embed.h"
+#include "qwen_asr_tokenizer.h"
+
+#ifdef USE_MLX
+#include "pplx_embed_mlx.h"
+#endif
+
+#include "deps/ae/ae.h"
+#include "deps/ae/anet.h"
+
+#include <arpa/inet.h>
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <math.h>
+#include <netinet/in.h>
+#include <pthread.h>
+#include <signal.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+
+#include <cjson/cJSON.h>
+
+#define PPLX_HTTP_IO_BUF 8192
+#define PPLX_HTTP_MAX_HEADER (64u * 1024u)
+#define PPLX_HTTP_MAX_BODY (64u * 1024u * 1024u)
+#define PPLX_HTTP_MAX_PATH 255u
+#define PPLX_HTTP_BACKLOG 128
+#define PPLX_HTTP_SETSIZE 10240
+#define PPLX_HTTP_CLIENT_TIMEOUT_MS 30000
+#define PPLX_HTTP_SWEEP_MS 1000
+
+#define PPLX_API_MAX_STANDARD_INPUTS 512
+#define PPLX_API_MAX_CONTEXT_DOCS 512
+#define PPLX_API_MAX_CONTEXT_CHUNKS 16000
+#define PPLX_API_MAX_ITEM_TOKENS 32768
+#define PPLX_API_MAX_TOTAL_TOKENS 120000
+
+typedef struct {
+ char *ptr;
+ size_t len;
+ size_t cap;
+} sbuf;
+
+static void die_oom(void) {
+ fprintf(stderr, "pplx-serve: out of memory\n");
+ exit(1);
+}
+
+static void *xmalloc(size_t n) {
+ void *p = malloc(n ? n : 1);
+ if (!p) die_oom();
+ return p;
+}
+
+static void *xcalloc(size_t n, size_t sz) {
+ void *p = calloc(n ? n : 1, sz ? sz : 1);
+ if (!p) die_oom();
+ return p;
+}
+
+static void *xrealloc(void *p, size_t n) {
+ p = realloc(p, n ? n : 1);
+ if (!p) die_oom();
+ return p;
+}
+
+static char *xstrdup(const char *s) {
+ size_t n = strlen(s);
+ char *p = xmalloc(n + 1);
+ memcpy(p, s, n + 1);
+ return p;
+}
+
+static char *xstrndup(const char *s, size_t n) {
+ char *p = xmalloc(n + 1);
+ memcpy(p, s, n);
+ p[n] = '\0';
+ return p;
+}
+
+static uint64_t mstime(void) {
+ struct timespec ts;
+ if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0)
+ return (uint64_t)ts.tv_sec * 1000u + (uint64_t)ts.tv_nsec / 1000000u;
+ struct timeval tv;
+ gettimeofday(&tv, NULL);
+ return (uint64_t)tv.tv_sec * 1000u + (uint64_t)tv.tv_usec / 1000u;
+}
+
+static void server_log(const char *fmt, ...) {
+ char ts[32];
+ time_t now = time(NULL);
+ struct tm tmv;
+ localtime_r(&now, &tmv);
+ strftime(ts, sizeof(ts), "%m%d %H:%M:%S", &tmv);
+ fprintf(stderr, "%s ", ts);
+ va_list ap;
+ va_start(ap, fmt);
+ vfprintf(stderr, fmt, ap);
+ va_end(ap);
+ fputc('\n', stderr);
+}
+
+static void sbuf_reserve(sbuf *b, size_t add) {
+ if (add > SIZE_MAX - b->len - 1) die_oom();
+ size_t need = b->len + add + 1;
+ if (need <= b->cap) return;
+ size_t cap = b->cap ? b->cap * 2 : 256;
+ while (cap < need) {
+ if (cap > SIZE_MAX / 2) die_oom();
+ cap *= 2;
+ }
+ b->ptr = xrealloc(b->ptr, cap);
+ b->cap = cap;
+}
+
+static void sbuf_append(sbuf *b, const void *p, size_t n) {
+ sbuf_reserve(b, n);
+ memcpy(b->ptr + b->len, p, n);
+ b->len += n;
+ b->ptr[b->len] = '\0';
+}
+
+static void sbuf_putc(sbuf *b, char c) { sbuf_append(b, &c, 1); }
+static void sbuf_puts(sbuf *b, const char *s) { sbuf_append(b, s, strlen(s)); }
+
+static void sbuf_printf(sbuf *b, const char *fmt, ...) {
+ va_list ap, ap2;
+ va_start(ap, fmt);
+ va_copy(ap2, ap);
+ int n = vsnprintf(NULL, 0, fmt, ap);
+ va_end(ap);
+ if (n < 0) die_oom();
+ sbuf_reserve(b, (size_t)n);
+ int n2 = vsnprintf(b->ptr + b->len, b->cap - b->len, fmt, ap2);
+ va_end(ap2);
+ if (n2 < 0 || n2 != n) die_oom();
+ b->len += (size_t)n;
+}
+
+static void sbuf_free(sbuf *b) {
+ free(b->ptr);
+ memset(b, 0, sizeof(*b));
+}
+
+typedef enum {
+ MODEL_STD_06,
+ MODEL_STD_4,
+ MODEL_CTX_06,
+ MODEL_CTX_4,
+ MODEL_UNKNOWN
+} model_slot;
+
+typedef struct {
+ const char *id;
+ int is_contextual;
+ int dim;
+ double price_per_mtok;
+} model_info;
+
+static const model_info k_models[] = {
+ {"pplx-embed-v1-0.6b", 0, 1024, 0.004},
+ {"pplx-embed-v1-4b", 0, 2560, 0.030},
+ {"pplx-embed-context-v1-0.6b", 1, 1024, 0.008},
+ {"pplx-embed-context-v1-4b", 1, 2560, 0.050},
+};
+
+static model_slot model_slot_for_id(const char *id) {
+ if (!id) return MODEL_UNKNOWN;
+ for (int i = 0; i < 4; i++) {
+ if (!strcmp(id, k_models[i].id)) return (model_slot)i;
+ }
+ return MODEL_UNKNOWN;
+}
+
+typedef struct {
+ const model_info *info;
+ char *path;
+ qwen_tokenizer_t *tok;
+ int newline_n;
+ int *newline_ids;
+ pplx_model_t *cpu_model;
+ pplx_workspace_t *cpu_ws;
+#ifdef USE_MLX
+ pplx_mlx_ctx_t *mlx_ctx;
+#endif
+} loaded_model;
+
+typedef struct client client;
+typedef struct job job;
+
+typedef struct {
+ aeEventLoop *loop;
+ int listen_fd;
+ int completion_pipe[2];
+ int signal_pipe[2];
+ const char *host;
+ int port;
+ int batch_size;
+ int enable_cors;
+ char *api_key;
+ loaded_model models[4];
+ int use_mlx;
+
+ pthread_t worker;
+ pthread_mutex_t mu;
+ pthread_cond_t cv;
+ int stopping;
+ job *job_head;
+ job *job_tail;
+ job *done_head;
+ job *done_tail;
+
+ client *clients;
+ int n_clients;
+} http_server;
+
+typedef struct {
+ char method[8];
+ char path[PPLX_HTTP_MAX_PATH + 1];
+ char *body;
+ size_t body_len;
+ char *auth;
+} http_request;
+
+struct client {
+ http_server *srv;
+ int fd;
+ int refcount;
+ int cancelled;
+ int linked;
+ uint64_t last_active_ms;
+ sbuf in;
+ sbuf out;
+ size_t sent;
+ int header_done;
+ size_t header_len;
+ size_t content_length;
+ http_request req;
+ client *prev;
+ client *next;
+};
+
+struct job {
+ http_server *srv;
+ client *c;
+ char method[8];
+ char path[PPLX_HTTP_MAX_PATH + 1];
+ char *body;
+ size_t body_len;
+ char *auth;
+ int status;
+ char *content_type;
+ char *response;
+ size_t response_len;
+ job *next;
+};
+
+static volatile sig_atomic_t g_stop_requested = 0;
+static volatile sig_atomic_t g_signal_wfd = -1;
+
+static void stop_signal_handler(int sig) {
+ (void)sig;
+ if (g_stop_requested) _exit(130);
+ int saved = errno;
+ g_stop_requested = 1;
+ int fd = (int)g_signal_wfd;
+ if (fd >= 0) {
+ const unsigned char byte = 1;
+ (void)write(fd, &byte, 1);
+ }
+ errno = saved;
+}
+
+static int set_nonblock(int fd) {
+ int flags = fcntl(fd, F_GETFL, 0);
+ if (flags < 0) return -1;
+ return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
+}
+
+static void http_request_free(http_request *r) {
+ free(r->body);
+ free(r->auth);
+ memset(r, 0, sizeof(*r));
+}
+
+static void client_free(client *c) {
+ if (!c) return;
+ http_request_free(&c->req);
+ sbuf_free(&c->in);
+ sbuf_free(&c->out);
+ free(c);
+}
+
+static void client_incref(client *c) {
+ pthread_mutex_lock(&c->srv->mu);
+ c->refcount++;
+ pthread_mutex_unlock(&c->srv->mu);
+}
+
+static void client_decref(client *c) {
+ int free_now = 0;
+ pthread_mutex_lock(&c->srv->mu);
+ if (--c->refcount == 0) free_now = 1;
+ pthread_mutex_unlock(&c->srv->mu);
+ if (free_now) client_free(c);
+}
+
+static void client_unlink(client *c) {
+ http_server *s = c->srv;
+ if (!c->linked) return;
+ if (c->prev) c->prev->next = c->next;
+ else s->clients = c->next;
+ if (c->next) c->next->prev = c->prev;
+ c->prev = c->next = NULL;
+ c->linked = 0;
+ if (s->n_clients > 0) s->n_clients--;
+}
+
+static void close_client(client *c) {
+ if (!c || c->cancelled) return;
+ c->cancelled = 1;
+ if (c->fd >= 0) {
+ aeDeleteFileEvent(c->srv->loop, c->fd, AE_READABLE);
+ aeDeleteFileEvent(c->srv->loop, c->fd, AE_WRITABLE);
+ close(c->fd);
+ c->fd = -1;
+ }
+ client_unlink(c);
+ client_decref(c);
+}
+
+static void append_http_response(client *c, int status, const char *ctype,
+ const char *body, size_t body_len) {
+ const char *reason = "OK";
+ if (status == 204) reason = "No Content";
+ else if (status == 400) reason = "Bad Request";
+ else if (status == 401) reason = "Unauthorized";
+ else if (status == 404) reason = "Not Found";
+ else if (status == 405) reason = "Method Not Allowed";
+ else if (status == 422) reason = "Unprocessable Entity";
+ else if (status == 503) reason = "Service Unavailable";
+ else if (status >= 500) reason = "Internal Server Error";
+
+ sbuf_printf(&c->out,
+ "HTTP/1.1 %d %s\r\n"
+ "Content-Length: %zu\r\n"
+ "Connection: close\r\n",
+ status, reason, body_len);
+ if (ctype)
+ sbuf_printf(&c->out, "Content-Type: %s\r\n", ctype);
+ if (c->srv->enable_cors) {
+ sbuf_puts(&c->out, "Access-Control-Allow-Origin: *\r\n");
+ sbuf_puts(&c->out, "Access-Control-Allow-Headers: authorization, content-type\r\n");
+ sbuf_puts(&c->out, "Access-Control-Allow-Methods: POST, OPTIONS\r\n");
+ }
+ sbuf_puts(&c->out, "\r\n");
+ if (body_len) sbuf_append(&c->out, body, body_len);
+}
+
+static void append_json_error(sbuf *b, const char *message, const char *type) {
+ sbuf_puts(b, "{\"error\":{\"message\":\"");
+ for (const char *p = message ? message : ""; *p; p++) {
+ if (*p == '"' || *p == '\\') {
+ sbuf_putc(b, '\\');
+ sbuf_putc(b, *p);
+ } else {
+ sbuf_putc(b, *p);
+ }
+ }
+ sbuf_puts(b, "\",\"type\":\"");
+ sbuf_puts(b, type ? type : "server_error");
+ sbuf_puts(b, "\"}}");
+}
+
+static char *json_error_body(const char *message, const char *type, size_t *len) {
+ sbuf b = {0};
+ append_json_error(&b, message, type);
+ *len = b.len;
+ return b.ptr;
+}
+
+static void job_set_error(job *j, int status, const char *message, const char *type) {
+ free(j->response);
+ j->status = status;
+ j->content_type = "application/json";
+ j->response = json_error_body(message, type, &j->response_len);
+}
+
+static bool auth_ok(http_server *s, const char *auth) {
+ if (!s->api_key || !s->api_key[0]) return true;
+ if (!auth) return false;
+ const char prefix[] = "Bearer ";
+ return !strncmp(auth, prefix, sizeof(prefix) - 1) &&
+ !strcmp(auth + sizeof(prefix) - 1, s->api_key);
+}
+
+static ssize_t find_header_end(const char *p, size_t n) {
+ for (size_t i = 3; i < n; i++) {
+ if (p[i - 3] == '\r' && p[i - 2] == '\n' &&
+ p[i - 1] == '\r' && p[i] == '\n')
+ return (ssize_t)(i + 1);
+ }
+ for (size_t i = 1; i < n; i++) {
+ if (p[i - 1] == '\n' && p[i] == '\n') return (ssize_t)(i + 1);
+ }
+ return -1;
+}
+
+static char *header_value_dup(const char *h, size_t n, const char *name) {
+ size_t name_len = strlen(name);
+ const char *p = h, *end = h + n;
+ while (p < end) {
+ const char *line = p;
+ while (p < end && *p != '\n') p++;
+ size_t len = (size_t)(p - line);
+ if (len && line[len - 1] == '\r') len--;
+ if (len > name_len && !strncasecmp(line, name, name_len) &&
+ line[name_len] == ':') {
+ const char *v = line + name_len + 1;
+ while (v < line + len && isspace((unsigned char)*v)) v++;
+ const char *e = line + len;
+ while (e > v && isspace((unsigned char)e[-1])) e--;
+ return xstrndup(v, (size_t)(e - v));
+ }
+ if (p < end) p++;
+ }
+ return NULL;
+}
+
+static int parse_request_headers(client *c) {
+ char line[512];
+ size_t i = 0;
+ while (i < c->header_len && c->in.ptr[i] != '\n' && i + 1 < sizeof(line)) {
+ line[i] = c->in.ptr[i];
+ i++;
+ }
+ line[i] = '\0';
+ if (sscanf(line, "%7s %255s", c->req.method, c->req.path) != 2)
+ return -1;
+ char *q = strchr(c->req.path, '?');
+ if (q) *q = '\0';
+
+ char *cl = header_value_dup(c->in.ptr, c->header_len, "Content-Length");
+ if (cl) {
+ char *end = NULL;
+ errno = 0;
+ unsigned long long v = strtoull(cl, &end, 10);
+ if (errno || !end || *end || v > PPLX_HTTP_MAX_BODY) {
+ free(cl);
+ return -1;
+ }
+ c->content_length = (size_t)v;
+ free(cl);
+ }
+ c->req.auth = header_value_dup(c->in.ptr, c->header_len, "Authorization");
+ return 0;
+}
+
+static int complete_request(client *c) {
+ if (!c->header_done) {
+ ssize_t hend = find_header_end(c->in.ptr, c->in.len);
+ if (hend < 0) {
+ if (c->in.len > PPLX_HTTP_MAX_HEADER) return -1;
+ return 0;
+ }
+ c->header_done = 1;
+ c->header_len = (size_t)hend;
+ if (parse_request_headers(c) != 0) return -1;
+ }
+ if (c->content_length > PPLX_HTTP_MAX_BODY) return -1;
+ if (c->in.len < c->header_len + c->content_length) return 0;
+ c->req.body_len = c->content_length;
+ c->req.body = xmalloc(c->content_length + 1);
+ memcpy(c->req.body, c->in.ptr + c->header_len, c->content_length);
+ c->req.body[c->content_length] = '\0';
+ return 1;
+}
+
+static void write_cb(aeEventLoop *loop, int fd, void *clientData, int mask) {
+ (void)loop; (void)mask;
+ client *c = clientData;
+ while (c->sent < c->out.len) {
+ ssize_t n = write(fd, c->out.ptr + c->sent, c->out.len - c->sent);
+ if (n > 0) {
+ c->sent += (size_t)n;
+ c->last_active_ms = mstime();
+ continue;
+ }
+ if (n < 0 && errno == EINTR) continue;
+ if (n < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) return;
+ close_client(c);
+ return;
+ }
+ close_client(c);
+}
+
+static int queue_write(client *c) {
+ if (!c || c->cancelled || c->fd < 0) return -1;
+ return aeCreateFileEvent(c->srv->loop, c->fd, AE_WRITABLE, write_cb, c);
+}
+
+static void enqueue_done(job *j) {
+ http_server *s = j->srv;
+ pthread_mutex_lock(&s->mu);
+ if (s->done_tail) s->done_tail->next = j;
+ else s->done_head = j;
+ s->done_tail = j;
+ pthread_mutex_unlock(&s->mu);
+ const unsigned char byte = 1;
+ (void)write(s->completion_pipe[1], &byte, 1);
+}
+
+static job *dequeue_job(http_server *s) {
+ pthread_mutex_lock(&s->mu);
+ while (!s->job_head && !s->stopping)
+ pthread_cond_wait(&s->cv, &s->mu);
+ job *j = s->job_head;
+ if (j) {
+ s->job_head = j->next;
+ if (!s->job_head) s->job_tail = NULL;
+ j->next = NULL;
+ }
+ pthread_mutex_unlock(&s->mu);
+ return j;
+}
+
+static void enqueue_job(job *j) {
+ http_server *s = j->srv;
+ pthread_mutex_lock(&s->mu);
+ if (s->job_tail) s->job_tail->next = j;
+ else s->job_head = j;
+ s->job_tail = j;
+ pthread_cond_signal(&s->cv);
+ pthread_mutex_unlock(&s->mu);
+}
+
+static job *pop_done(http_server *s) {
+ pthread_mutex_lock(&s->mu);
+ job *j = s->done_head;
+ if (j) {
+ s->done_head = j->next;
+ if (!s->done_head) s->done_tail = NULL;
+ j->next = NULL;
+ }
+ pthread_mutex_unlock(&s->mu);
+ return j;
+}
+
+static void job_free(job *j) {
+ if (!j) return;
+ free(j->body);
+ free(j->auth);
+ free(j->response);
+ free(j);
+}
+
+static void completion_cb(aeEventLoop *loop, int fd, void *clientData, int mask) {
+ (void)loop; (void)mask;
+ http_server *s = clientData;
+ unsigned char tmp[128];
+ while (read(fd, tmp, sizeof(tmp)) > 0) {}
+
+ job *j;
+ while ((j = pop_done(s)) != NULL) {
+ client *c = j->c;
+ if (!c->cancelled) {
+ append_http_response(c, j->status, j->content_type,
+ j->response ? j->response : "",
+ j->response ? j->response_len : 0);
+ if (queue_write(c) != AE_OK)
+ close_client(c);
+ }
+ client_decref(c);
+ job_free(j);
+ }
+}
+
+static bool route_is_embedding(const char *method, const char *path) {
+ return !strcmp(method, "POST") &&
+ (!strcmp(path, "/v1/embeddings") ||
+ !strcmp(path, "/v1/contextualizedembeddings"));
+}
+
+static void dispatch_request(client *c) {
+ aeDeleteFileEvent(c->srv->loop, c->fd, AE_READABLE);
+
+ if (!strcmp(c->req.method, "OPTIONS")) {
+ append_http_response(c, 204, NULL, "", 0);
+ if (queue_write(c) != AE_OK) close_client(c);
+ return;
+ }
+
+ if (!route_is_embedding(c->req.method, c->req.path)) {
+ size_t len;
+ char *body = json_error_body("unknown endpoint", "invalid_request_error", &len);
+ append_http_response(c, 404, "application/json", body, len);
+ free(body);
+ if (queue_write(c) != AE_OK) close_client(c);
+ return;
+ }
+
+ if (!auth_ok(c->srv, c->req.auth)) {
+ size_t len;
+ char *body = json_error_body("missing or invalid bearer token",
+ "authentication_error", &len);
+ append_http_response(c, 401, "application/json", body, len);
+ free(body);
+ if (queue_write(c) != AE_OK) close_client(c);
+ return;
+ }
+
+ job *j = xcalloc(1, sizeof(*j));
+ j->srv = c->srv;
+ j->c = c;
+ snprintf(j->method, sizeof(j->method), "%s", c->req.method);
+ snprintf(j->path, sizeof(j->path), "%s", c->req.path);
+ j->body = xstrndup(c->req.body ? c->req.body : "", c->req.body_len);
+ j->body_len = c->req.body_len;
+ j->auth = c->req.auth ? xstrdup(c->req.auth) : NULL;
+ client_incref(c);
+ enqueue_job(j);
+}
+
+static void read_cb(aeEventLoop *loop, int fd, void *clientData, int mask) {
+ (void)loop; (void)mask;
+ client *c = clientData;
+ char tmp[PPLX_HTTP_IO_BUF];
+ for (;;) {
+ ssize_t n = read(fd, tmp, sizeof(tmp));
+ if (n > 0) {
+ sbuf_append(&c->in, tmp, (size_t)n);
+ c->last_active_ms = mstime();
+ int done = complete_request(c);
+ if (done < 0) {
+ size_t len;
+ char *body = json_error_body("bad HTTP request",
+ "invalid_request_error", &len);
+ append_http_response(c, 400, "application/json", body, len);
+ free(body);
+ aeDeleteFileEvent(c->srv->loop, c->fd, AE_READABLE);
+ if (queue_write(c) != AE_OK) close_client(c);
+ return;
+ }
+ if (done > 0) {
+ dispatch_request(c);
+ return;
+ }
+ continue;
+ }
+ if (n == 0) {
+ close_client(c);
+ return;
+ }
+ if (errno == EINTR) continue;
+ if (errno == EAGAIN || errno == EWOULDBLOCK) return;
+ close_client(c);
+ return;
+ }
+}
+
+static void accept_cb(aeEventLoop *loop, int fd, void *clientData, int mask) {
+ (void)loop; (void)mask;
+ http_server *s = clientData;
+ char cip[64];
+ int cport = 0;
+ for (;;) {
+ int cfd = anetTcpAccept(NULL, fd, cip, sizeof(cip), &cport);
+ if (cfd == ANET_ERR) {
+ if (errno == EAGAIN || errno == EWOULDBLOCK) return;
+ if (errno == EINTR) continue;
+ return;
+ }
+ set_nonblock(cfd);
+ client *c = xcalloc(1, sizeof(*c));
+ c->srv = s;
+ c->fd = cfd;
+ c->refcount = 1;
+ c->last_active_ms = mstime();
+ c->linked = 1;
+ c->next = s->clients;
+ if (s->clients) s->clients->prev = c;
+ s->clients = c;
+ s->n_clients++;
+ if (aeCreateFileEvent(s->loop, cfd, AE_READABLE, read_cb, c) != AE_OK)
+ close_client(c);
+ }
+}
+
+static int timeout_cb(aeEventLoop *loop, long long id, void *clientData) {
+ (void)loop; (void)id;
+ http_server *s = clientData;
+ uint64_t now = mstime();
+ client *c = s->clients;
+ while (c) {
+ client *next = c->next;
+ if (!c->cancelled &&
+ now - c->last_active_ms > PPLX_HTTP_CLIENT_TIMEOUT_MS)
+ close_client(c);
+ c = next;
+ }
+ return PPLX_HTTP_SWEEP_MS;
+}
+
+static void signal_cb(aeEventLoop *loop, int fd, void *clientData, int mask) {
+ (void)fd; (void)mask;
+ http_server *s = clientData;
+ unsigned char tmp[128];
+ while (read(s->signal_pipe[0], tmp, sizeof(tmp)) > 0) {}
+ aeStop(loop);
+}
+
+static bool ve_add(cJSON *detail, const char *loc_json,
+ const char *msg, const char *type) {
+ cJSON *obj = cJSON_CreateObject();
+ cJSON *loc = cJSON_Parse(loc_json);
+ if (!obj || !loc) {
+ cJSON_Delete(obj);
+ cJSON_Delete(loc);
+ return false;
+ }
+ cJSON_AddItemToObject(obj, "loc", loc);
+ cJSON_AddStringToObject(obj, "msg", msg ? msg : "");
+ cJSON_AddStringToObject(obj, "type", type ? type : "");
+ cJSON_AddItemToArray(detail, obj);
+ return true;
+}
+
+static void job_set_422(job *j, cJSON *detail) {
+ cJSON *root = cJSON_CreateObject();
+ cJSON_AddItemToObject(root, "detail", cJSON_Duplicate(detail, 1));
+ char *s = cJSON_PrintUnformatted(root);
+ cJSON_Delete(root);
+ if (!s) {
+ job_set_error(j, 500, "failed to render validation error", "server_error");
+ return;
+ }
+ j->status = 422;
+ j->content_type = "application/json";
+ j->response = xstrdup(s);
+ j->response_len = strlen(j->response);
+ cJSON_free(s);
+}
+
+static cJSON *parse_json_body(job *j, cJSON *detail) {
+ if (!j->body || j->body_len == 0) {
+ ve_add(detail, "[\"body\"]", "body required", "missing");
+ return NULL;
+ }
+ const char *end = NULL;
+ cJSON *root = cJSON_ParseWithLengthOpts(j->body, j->body_len, &end, false);
+ if (!root) {
+ ve_add(detail, "[\"body\"]", "invalid JSON", "json_invalid");
+ return NULL;
+ }
+ const char *body_end = j->body + j->body_len;
+ while (end && end < body_end && isspace((unsigned char)*end)) end++;
+ if (!end || end != body_end) {
+ ve_add(detail, "[\"body\"]", "invalid JSON", "json_invalid");
+ cJSON_Delete(root);
+ return NULL;
+ }
+ if (!cJSON_IsObject(root)) {
+ ve_add(detail, "[\"body\"]", "body must be a JSON object", "type_error.object");
+ cJSON_Delete(root);
+ return NULL;
+ }
+ return root;
+}
+
+static bool cjson_is_integer(cJSON *item) {
+ if (!cJSON_IsNumber(item)) return false;
+ double d = item->valuedouble;
+ int i = item->valueint;
+ return d >= (double)INT_MIN && d <= (double)INT_MAX && d == (double)i;
+}
+
+static const char *encoding_from_root(cJSON *root, cJSON *detail) {
+ cJSON *encoding = cJSON_GetObjectItemCaseSensitive(root, "encoding_format");
+ if (!encoding) return "base64_int8";
+ if (!cJSON_IsString(encoding) || !encoding->valuestring) {
+ ve_add(detail, "[\"body\",\"encoding_format\"]",
+ "encoding_format must be a string", "type_error.string");
+ return "base64_int8";
+ }
+ if (strcmp(encoding->valuestring, "base64_int8") &&
+ strcmp(encoding->valuestring, "base64_binary")) {
+ ve_add(detail, "[\"body\",\"encoding_format\"]",
+ "value is not a valid enum member; permitted: 'base64_int8', 'base64_binary'",
+ "enum");
+ return "base64_int8";
+ }
+ return encoding->valuestring;
+}
+
+static int dimensions_from_root(cJSON *root, cJSON *detail, int max_dim,
+ const char *encoding) {
+ int dims = max_dim;
+ cJSON *dimensions = cJSON_GetObjectItemCaseSensitive(root, "dimensions");
+ if (dimensions) {
+ if (!cjson_is_integer(dimensions)) {
+ ve_add(detail, "[\"body\",\"dimensions\"]", "dimensions must be an integer",
+ "type_error.integer");
+ } else {
+ dims = dimensions->valueint;
+ if (dims < 128 || dims > max_dim) {
+ char msg[96];
+ snprintf(msg, sizeof(msg), "dimensions must be between 128 and %d", max_dim);
+ ve_add(detail, "[\"body\",\"dimensions\"]", msg, "value_error.range");
+ }
+ }
+ }
+ if (!strcmp(encoding, "base64_binary") && dims % 8 != 0)
+ ve_add(detail, "[\"body\",\"dimensions\"]",
+ "dimensions must be divisible by 8 for base64_binary",
+ "value_error.divisible");
+ return dims;
+}
+
+static char *base64_encode(const unsigned char *src, size_t n) {
+ static const char tbl[] =
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+ size_t out_len = ((n + 2) / 3) * 4;
+ char *out = xmalloc(out_len + 1);
+ size_t o = 0;
+ for (size_t i = 0; i < n; i += 3) {
+ unsigned v = (unsigned)src[i] << 16;
+ int remain = (int)(n - i);
+ if (remain > 1) v |= (unsigned)src[i + 1] << 8;
+ if (remain > 2) v |= (unsigned)src[i + 2];
+ out[o++] = tbl[(v >> 18) & 63];
+ out[o++] = tbl[(v >> 12) & 63];
+ out[o++] = remain > 1 ? tbl[(v >> 6) & 63] : '=';
+ out[o++] = remain > 2 ? tbl[v & 63] : '=';
+ }
+ out[o] = '\0';
+ return out;
+}
+
+static char *encode_embedding(const float *emb, int dims, const char *encoding) {
+ 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));
+ }
+ char *out = base64_encode(bits, bytes);
+ free(bits);
+ return out;
+ }
+
+ signed char *q = xmalloc((size_t)dims);
+ float max_abs = 0.0f;
+ for (int i = 0; i < dims; i++) {
+ float a = fabsf(emb[i]);
+ if (a > max_abs) max_abs = a;
+ }
+ float scale = max_abs > 1e-12f ? 127.0f / max_abs : 0.0f;
+ for (int i = 0; i < dims; i++) {
+ int v = (int)lrintf(emb[i] * scale);
+ if (v > 127) v = 127;
+ if (v < -127) v = -127;
+ q[i] = (signed char)v;
+ }
+ char *out = base64_encode((const unsigned char *)q, (size_t)dims);
+ free(q);
+ return out;
+}
+
+typedef struct {
+ int *ids;
+ int n_tokens;
+} token_buf;
+
+static void free_token_bufs(token_buf *t, int n) {
+ if (!t) return;
+ for (int i = 0; i < n; i++) free(t[i].ids);
+}
+
+static int tokenize_one(loaded_model *m, const char *text, token_buf *out) {
+ memset(out, 0, sizeof(*out));
+ out->ids = qwen_tokenizer_encode(m->tok, text, &out->n_tokens);
+ if (!out->ids || out->n_tokens <= 0) {
+ free(out->ids);
+ memset(out, 0, sizeof(*out));
+ return -1;
+ }
+ return 0;
+}
+
+static int model_embed_batch(loaded_model *m, const pplx_input_t *inputs,
+ int batch, float *out) {
+#ifdef USE_MLX
+ if (m->mlx_ctx)
+ return pplx_mlx_embed_batch(m->mlx_ctx, inputs, batch, out);
+#endif
+ return pplx_model_embed_batch(m->cpu_model, m->cpu_ws, inputs, batch, out);
+}
+
+static int model_embed_spans(loaded_model *m, const int *ids, int n_tokens,
+ const pplx_span_t *spans, int n_spans, float *out) {
+#ifdef USE_MLX
+ if (m->mlx_ctx)
+ return pplx_mlx_embed_spans(m->mlx_ctx, ids, n_tokens, spans, n_spans, out);
+#endif
+ return pplx_model_embed_spans(m->cpu_model, m->cpu_ws, ids, n_tokens,
+ spans, n_spans, out);
+}
+
+static void append_embedding_object(sbuf *b, int index, const char *embedding) {
+ sbuf_printf(b, "{\"object\":\"embedding\",\"index\":%d,\"embedding\":\"", index);
+ sbuf_puts(b, embedding);
+ sbuf_puts(b, "\"}");
+}
+
+static 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));
+}
+
+static void handle_embeddings_job(job *j, cJSON *root, loaded_model *m,
+ int dims, const char *encoding) {
+ cJSON *input = cJSON_GetObjectItemCaseSensitive(root, "input");
+ int n_inputs = cJSON_IsString(input) ? 1 : cJSON_GetArraySize(input);
+ token_buf *tokens = xcalloc((size_t)n_inputs, sizeof(*tokens));
+ pplx_input_t *inputs = xmalloc((size_t)n_inputs * sizeof(*inputs));
+ float *embs = xmalloc((size_t)n_inputs * m->info->dim * sizeof(float));
+ char **encoded = xcalloc((size_t)n_inputs, sizeof(*encoded));
+
+ int total_tokens = 0;
+ int idx = 0;
+ if (cJSON_IsString(input)) {
+ tokenize_one(m, input->valuestring, &tokens[0]);
+ inputs[0].ids = tokens[0].ids;
+ inputs[0].n_tokens = tokens[0].n_tokens;
+ total_tokens = tokens[0].n_tokens;
+ } else {
+ cJSON *item;
+ cJSON_ArrayForEach(item, input) {
+ tokenize_one(m, item->valuestring, &tokens[idx]);
+ inputs[idx].ids = tokens[idx].ids;
+ inputs[idx].n_tokens = tokens[idx].n_tokens;
+ total_tokens += tokens[idx].n_tokens;
+ idx++;
+ }
+ }
+
+ for (int i = 0; i < n_inputs; i++) {
+ if (!tokens[i].ids) {
+ job_set_error(j, 500, "tokenization failed", "server_error");
+ goto done;
+ }
+ }
+ int max_batch = j->srv->batch_size > 0 ? j->srv->batch_size : n_inputs;
+ for (int start = 0; start < n_inputs; start += max_batch) {
+ int cur = n_inputs - start;
+ if (cur > max_batch) cur = max_batch;
+ if (model_embed_batch(m, inputs + start, cur,
+ embs + (size_t)start * m->info->dim) != 0) {
+ job_set_error(j, 500, "embedding failed", "server_error");
+ goto done;
+ }
+ }
+ for (int i = 0; i < n_inputs; i++)
+ encoded[i] = encode_embedding(embs + (size_t)i * m->info->dim, dims, encoding);
+
+ sbuf b = {0};
+ sbuf_puts(&b, "{\"object\":\"list\",\"data\":[");
+ for (int i = 0; i < n_inputs; i++) {
+ if (i) sbuf_putc(&b, ',');
+ append_embedding_object(&b, i, encoded[i]);
+ }
+ double cost = ((double)total_tokens / 1000000.0) * m->info->price_per_mtok;
+ sbuf_printf(&b,
+ "],\"model\":\"%s\",\"usage\":{\"prompt_tokens\":%d,"
+ "\"total_tokens\":%d,\"cost\":{\"input_cost\":%.10g,"
+ "\"total_cost\":%.10g,\"currency\":\"USD\"}}}",
+ m->info->id, total_tokens, total_tokens, cost, cost);
+ set_response_from_buf(j, &b);
+
+done:
+ for (int i = 0; i < n_inputs; i++) free(encoded[i]);
+ free(encoded);
+ free(embs);
+ free(inputs);
+ free_token_bufs(tokens, n_inputs);
+ free(tokens);
+}
+
+static void handle_context_job(job *j, cJSON *root, loaded_model *m,
+ int dims, const char *encoding) {
+ cJSON *input = cJSON_GetObjectItemCaseSensitive(root, "input");
+ int n_docs = cJSON_GetArraySize(input);
+ int *chunks = xcalloc((size_t)n_docs, sizeof(*chunks));
+ char ***encoded = xcalloc((size_t)n_docs, sizeof(*encoded));
+ int total_tokens = 0;
+
+ cJSON *doc_arr;
+ int di = 0;
+ cJSON_ArrayForEach(doc_arr, input) {
+ chunks[di] = cJSON_GetArraySize(doc_arr);
+ encoded[di] = xcalloc((size_t)chunks[di], sizeof(char *));
+ token_buf *chunk_tokens = xcalloc((size_t)chunks[di], sizeof(*chunk_tokens));
+ pplx_span_t *spans = xcalloc((size_t)chunks[di], sizeof(*spans));
+ int doc_tokens = 0;
+ cJSON *chunk;
+ int ci = 0;
+ cJSON_ArrayForEach(chunk, doc_arr) {
+ if (tokenize_one(m, chunk->valuestring, &chunk_tokens[ci]) != 0) {
+ job_set_error(j, 500, "tokenization failed", "server_error");
+ free_token_bufs(chunk_tokens, chunks[di]);
+ free(chunk_tokens); free(spans);
+ goto done;
+ }
+ doc_tokens += chunk_tokens[ci].n_tokens;
+ if (ci + 1 < chunks[di]) doc_tokens += m->newline_n;
+ ci++;
+ }
+ int *doc_ids = xmalloc((size_t)doc_tokens * sizeof(int));
+ int pos = 0;
+ for (ci = 0; ci < chunks[di]; ci++) {
+ spans[ci].start = pos;
+ spans[ci].n_tokens = chunk_tokens[ci].n_tokens;
+ memcpy(doc_ids + pos, chunk_tokens[ci].ids,
+ (size_t)chunk_tokens[ci].n_tokens * sizeof(int));
+ pos += chunk_tokens[ci].n_tokens;
+ if (ci + 1 < chunks[di] && m->newline_n > 0) {
+ memcpy(doc_ids + pos, m->newline_ids,
+ (size_t)m->newline_n * sizeof(int));
+ pos += m->newline_n;
+ }
+ }
+ total_tokens += doc_tokens;
+ float *embs = xmalloc((size_t)chunks[di] * m->info->dim * sizeof(float));
+ if (model_embed_spans(m, doc_ids, doc_tokens, spans, chunks[di], embs) != 0) {
+ free(embs); free(doc_ids);
+ job_set_error(j, 500, "contextual embedding failed", "server_error");
+ free_token_bufs(chunk_tokens, chunks[di]);
+ free(chunk_tokens); free(spans);
+ goto done;
+ }
+ for (ci = 0; ci < chunks[di]; ci++)
+ encoded[di][ci] = encode_embedding(embs + (size_t)ci * m->info->dim,
+ dims, encoding);
+ free(embs);
+ free(doc_ids);
+ free_token_bufs(chunk_tokens, chunks[di]);
+ free(chunk_tokens);
+ free(spans);
+ di++;
+ }
+
+ sbuf b = {0};
+ sbuf_puts(&b, "{\"object\":\"list\",\"data\":[");
+ for (di = 0; di < n_docs; di++) {
+ if (di) sbuf_putc(&b, ',');
+ sbuf_printf(&b, "{\"object\":\"list\",\"index\":%d,\"data\":[", di);
+ for (int ci = 0; ci < chunks[di]; ci++) {
+ if (ci) sbuf_putc(&b, ',');
+ append_embedding_object(&b, ci, encoded[di][ci]);
+ }
+ sbuf_puts(&b, "]}");
+ }
+ sbuf_printf(&b,
+ "],\"model\":\"%s\",\"usage\":{\"prompt_tokens\":%d,\"total_tokens\":%d}}",
+ m->info->id, total_tokens, total_tokens);
+ set_response_from_buf(j, &b);
+
+done:
+ for (di = 0; di < n_docs; di++) {
+ if (!encoded[di]) continue;
+ for (int ci = 0; ci < chunks[di]; ci++) free(encoded[di][ci]);
+ free(encoded[di]);
+ }
+ free(encoded);
+ free(chunks);
+}
+
+static void validate_text_tokens(cJSON *detail, loaded_model *m, const char *loc,
+ const char *text, int *total_tokens) {
+ token_buf t;
+ if (tokenize_one(m, text, &t) != 0) {
+ ve_add(detail, loc, "tokenization failed", "value_error.tokenization");
+ return;
+ }
+ if (t.n_tokens > PPLX_API_MAX_ITEM_TOKENS)
+ ve_add(detail, loc, "input exceeds 32768 token limit", "value_error.context_length");
+ if (*total_tokens <= PPLX_API_MAX_TOTAL_TOKENS)
+ *total_tokens += t.n_tokens;
+ free(t.ids);
+}
+
+static int validate_common(cJSON *root, cJSON *detail, int expect_context,
+ loaded_model **out_model, int *out_dims,
+ const char **out_encoding, http_server *s) {
+ cJSON *model_item = cJSON_GetObjectItemCaseSensitive(root, "model");
+ const char *model_id = NULL;
+ if (!model_item) {
+ ve_add(detail, "[\"body\",\"model\"]", "field required", "missing");
+ } else if (!cJSON_IsString(model_item) || !model_item->valuestring) {
+ ve_add(detail, "[\"body\",\"model\"]", "model must be a string", "type_error.string");
+ } else {
+ model_id = model_item->valuestring;
+ model_slot slot = model_slot_for_id(model_id);
+ if (slot == MODEL_UNKNOWN || k_models[slot].is_contextual != expect_context) {
+ ve_add(detail, "[\"body\",\"model\"]",
+ "value is not a valid enum member for this endpoint", "enum");
+ } else {
+ loaded_model *m = &s->models[slot];
+ if (!m->info) {
+ *out_model = NULL;
+ } else {
+ *out_model = m;
+ }
+ }
+ }
+ const char *enc = encoding_from_root(root, detail);
+ int max_dim = model_id && model_slot_for_id(model_id) != MODEL_UNKNOWN
+ ? k_models[model_slot_for_id(model_id)].dim : 2560;
+ int dims = dimensions_from_root(root, detail, max_dim, enc);
+ *out_encoding = enc;
+ *out_dims = dims;
+ return model_id && model_slot_for_id(model_id) != MODEL_UNKNOWN &&
+ !s->models[model_slot_for_id(model_id)].info ? 503 : 0;
+}
+
+static void process_embeddings(job *j, cJSON *root, http_server *s) {
+ cJSON *detail = cJSON_CreateArray();
+ loaded_model *m = NULL;
+ int dims = 0;
+ const char *encoding = NULL;
+ int unloaded = validate_common(root, detail, 0, &m, &dims, &encoding, s);
+
+ cJSON *input = cJSON_GetObjectItemCaseSensitive(root, "input");
+ int n_inputs = 0;
+ int total_tokens = 0;
+ if (!input) {
+ ve_add(detail, "[\"body\",\"input\"]", "field required", "missing");
+ } else if (cJSON_IsString(input)) {
+ if (!input->valuestring || input->valuestring[0] == '\0')
+ ve_add(detail, "[\"body\",\"input\"]", "input must not be empty",
+ "value_error.empty");
+ else if (m)
+ validate_text_tokens(detail, m, "[\"body\",\"input\"]",
+ input->valuestring, &total_tokens);
+ n_inputs = 1;
+ } else if (cJSON_IsArray(input)) {
+ n_inputs = cJSON_GetArraySize(input);
+ if (n_inputs < 1)
+ ve_add(detail, "[\"body\",\"input\"]", "input must contain at least 1 item",
+ "value_error.list.min_items");
+ else if (n_inputs > PPLX_API_MAX_STANDARD_INPUTS)
+ ve_add(detail, "[\"body\",\"input\"]", "input must contain at most 512 items",
+ "value_error.list.max_items");
+ cJSON *item;
+ int i = 0;
+ cJSON_ArrayForEach(item, input) {
+ char loc[64];
+ snprintf(loc, sizeof(loc), "[\"body\",\"input\",%d]", i);
+ if (!cJSON_IsString(item)) {
+ ve_add(detail, loc, "input item must be a string", "type_error.string");
+ } else if (!item->valuestring || item->valuestring[0] == '\0') {
+ ve_add(detail, loc, "input item must not be empty", "value_error.empty");
+ } else if (m) {
+ validate_text_tokens(detail, m, loc, item->valuestring, &total_tokens);
+ }
+ i++;
+ }
+ } else {
+ ve_add(detail, "[\"body\",\"input\"]",
+ "input must be a string or an array of strings", "type_error");
+ }
+ if (total_tokens > PPLX_API_MAX_TOTAL_TOKENS)
+ ve_add(detail, "[\"body\",\"input\"]", "request exceeds 120000 token limit",
+ "value_error.context_length");
+
+ if (cJSON_GetArraySize(detail) > 0) {
+ job_set_422(j, detail);
+ } else if (unloaded) {
+ job_set_error(j, 503, "requested model is valid but not loaded",
+ "model_not_loaded");
+ } else {
+ handle_embeddings_job(j, root, m, dims, encoding);
+ }
+ cJSON_Delete(detail);
+}
+
+static void process_contextual(job *j, cJSON *root, http_server *s) {
+ cJSON *detail = cJSON_CreateArray();
+ loaded_model *m = NULL;
+ int dims = 0;
+ const char *encoding = NULL;
+ int unloaded = validate_common(root, detail, 1, &m, &dims, &encoding, s);
+
+ cJSON *input = cJSON_GetObjectItemCaseSensitive(root, "input");
+ int n_docs = 0, total_chunks = 0, total_tokens = 0;
+ if (!input) {
+ ve_add(detail, "[\"body\",\"input\"]", "field required", "missing");
+ } else if (!cJSON_IsArray(input)) {
+ ve_add(detail, "[\"body\",\"input\"]",
+ "input must be an array of document chunk arrays", "type_error.array");
+ } else {
+ n_docs = cJSON_GetArraySize(input);
+ if (n_docs < 1)
+ ve_add(detail, "[\"body\",\"input\"]", "input must contain at least 1 document",
+ "value_error.list.min_items");
+ else if (n_docs > PPLX_API_MAX_CONTEXT_DOCS)
+ ve_add(detail, "[\"body\",\"input\"]", "input must contain at most 512 documents",
+ "value_error.list.max_items");
+ cJSON *doc_arr;
+ int di = 0;
+ cJSON_ArrayForEach(doc_arr, input) {
+ if (!cJSON_IsArray(doc_arr)) {
+ char loc[64];
+ snprintf(loc, sizeof(loc), "[\"body\",\"input\",%d]", di);
+ ve_add(detail, loc, "document must be an array of strings",
+ "type_error.array");
+ di++;
+ continue;
+ }
+ int doc_chunks = cJSON_GetArraySize(doc_arr);
+ total_chunks += doc_chunks;
+ if (doc_chunks < 1) {
+ char loc[64];
+ snprintf(loc, sizeof(loc), "[\"body\",\"input\",%d]", di);
+ ve_add(detail, loc, "document must contain at least 1 chunk",
+ "value_error.list.min_items");
+ }
+ int doc_tokens = 0;
+ cJSON *chunk;
+ int ci = 0;
+ cJSON_ArrayForEach(chunk, doc_arr) {
+ char loc[80];
+ snprintf(loc, sizeof(loc), "[\"body\",\"input\",%d,%d]", di, ci);
+ if (!cJSON_IsString(chunk)) {
+ ve_add(detail, loc, "chunk must be a string", "type_error.string");
+ } else if (!chunk->valuestring || chunk->valuestring[0] == '\0') {
+ ve_add(detail, loc, "chunk must not be empty", "value_error.empty");
+ } else if (m) {
+ token_buf t;
+ if (tokenize_one(m, chunk->valuestring, &t) != 0) {
+ ve_add(detail, loc, "tokenization failed", "value_error.tokenization");
+ } else {
+ doc_tokens += t.n_tokens;
+ total_tokens += t.n_tokens;
+ free(t.ids);
+ }
+ }
+ ci++;
+ }
+ if (m && doc_chunks > 1) {
+ doc_tokens += (doc_chunks - 1) * m->newline_n;
+ total_tokens += (doc_chunks - 1) * m->newline_n;
+ }
+ if (doc_tokens > PPLX_API_MAX_ITEM_TOKENS) {
+ char loc[64];
+ snprintf(loc, sizeof(loc), "[\"body\",\"input\",%d]", di);
+ ve_add(detail, loc, "document exceeds 32768 token limit",
+ "value_error.context_length");
+ }
+ di++;
+ }
+ if (total_chunks > PPLX_API_MAX_CONTEXT_CHUNKS)
+ ve_add(detail, "[\"body\",\"input\"]", "input must contain at most 16000 chunks",
+ "value_error.list.max_items");
+ if (total_tokens > PPLX_API_MAX_TOTAL_TOKENS)
+ ve_add(detail, "[\"body\",\"input\"]", "request exceeds 120000 token limit",
+ "value_error.context_length");
+ }
+
+ if (cJSON_GetArraySize(detail) > 0) {
+ job_set_422(j, detail);
+ } else if (unloaded) {
+ job_set_error(j, 503, "requested model is valid but not loaded",
+ "model_not_loaded");
+ } else {
+ handle_context_job(j, root, m, dims, encoding);
+ }
+ cJSON_Delete(detail);
+}
+
+static void process_job(job *j) {
+ cJSON *detail = cJSON_CreateArray();
+ cJSON *root = parse_json_body(j, detail);
+ if (!root) {
+ job_set_422(j, detail);
+ cJSON_Delete(detail);
+ return;
+ }
+ cJSON_Delete(detail);
+
+ if (!strcmp(j->path, "/v1/embeddings"))
+ process_embeddings(j, root, j->srv);
+ else if (!strcmp(j->path, "/v1/contextualizedembeddings"))
+ process_contextual(j, root, j->srv);
+ else
+ job_set_error(j, 404, "unknown endpoint", "invalid_request_error");
+ cJSON_Delete(root);
+}
+
+static void *worker_main(void *arg) {
+ http_server *s = arg;
+ for (;;) {
+ job *j = dequeue_job(s);
+ if (!j) break;
+ process_job(j);
+ enqueue_done(j);
+ }
+ return NULL;
+}
+
+static int listen_on(const char *host, int port) {
+ char portbuf[32];
+ snprintf(portbuf, sizeof(portbuf), "%d", port);
+ char err[ANET_ERR_LEN];
+ int fd = anetTcpServer(err, port, (char *)host, PPLX_HTTP_BACKLOG);
+ (void)portbuf;
+ if (fd == ANET_ERR) {
+ server_log("pplx-serve: listen failed on %s:%d: %s", host, port, err);
+ return -1;
+ }
+ set_nonblock(fd);
+ return fd;
+}
+
+static int load_one_model(http_server *s, model_slot slot, const char *path) {
+ loaded_model *m = &s->models[slot];
+ m->info = &k_models[slot];
+ m->path = xstrdup(path);
+ char vocab_path[1024];
+ snprintf(vocab_path, sizeof(vocab_path), "%s/vocab.json", path);
+ m->tok = qwen_tokenizer_load(vocab_path);
+ if (!m->tok) {
+ server_log("pplx-serve: failed to load tokenizer: %s", vocab_path);
+ return -1;
+ }
+ m->newline_ids = qwen_tokenizer_encode(m->tok, "\n", &m->newline_n);
+ if (!m->newline_ids || m->newline_n <= 0) {
+ server_log("pplx-serve: failed to tokenize newline separator");
+ return -1;
+ }
+#ifdef USE_MLX
+ if (s->use_mlx) {
+ m->mlx_ctx = pplx_mlx_load(path);
+ if (!m->mlx_ctx) {
+ server_log("pplx-serve: failed to load MLX model: %s", path);
+ return -1;
+ }
+ if (pplx_mlx_config(m->mlx_ctx)->hidden_size != m->info->dim) {
+ server_log("pplx-serve: model %s has unexpected dimension %d",
+ m->info->id, pplx_mlx_config(m->mlx_ctx)->hidden_size);
+ return -1;
+ }
+ return 0;
+ }
+#endif
+ m->cpu_model = pplx_model_load(path);
+ if (!m->cpu_model) {
+ server_log("pplx-serve: failed to load model: %s", path);
+ return -1;
+ }
+ m->cpu_ws = pplx_workspace_new(m->cpu_model);
+ if (!m->cpu_ws) {
+ server_log("pplx-serve: failed to allocate workspace: %s", path);
+ return -1;
+ }
+ if (pplx_model_config(m->cpu_model)->hidden_size != m->info->dim) {
+ server_log("pplx-serve: model %s has unexpected dimension %d",
+ m->info->id, pplx_model_config(m->cpu_model)->hidden_size);
+ return -1;
+ }
+ return 0;
+}
+
+static void free_models(http_server *s) {
+ for (int i = 0; i < 4; i++) {
+ loaded_model *m = &s->models[i];
+ free(m->path);
+ free(m->newline_ids);
+ if (m->tok) qwen_tokenizer_free(m->tok);
+ if (m->cpu_ws) pplx_workspace_free(m->cpu_ws);
+ if (m->cpu_model) pplx_model_free(m->cpu_model);
+#ifdef USE_MLX
+ if (m->mlx_ctx) pplx_mlx_free(m->mlx_ctx);
+#endif
+ }
+}
+
+int pplx_run_server(const pplx_server_config_t *cfg) {
+ if (!cfg || !cfg->models || cfg->n_models <= 0) {
+ fprintf(stderr, "pplx-serve: at least one --model MODEL_ID=PATH is required\n");
+ return 1;
+ }
+
+ http_server s;
+ memset(&s, 0, sizeof(s));
+ s.host = cfg->host && cfg->host[0] ? cfg->host : "127.0.0.1";
+ s.port = cfg->port > 0 ? cfg->port : 8000;
+ s.batch_size = cfg->batch_size > 0 ? cfg->batch_size : 1;
+ s.enable_cors = cfg->enable_cors;
+ s.use_mlx = cfg->use_mlx;
+ if (cfg->api_key && cfg->api_key[0])
+ s.api_key = xstrdup(cfg->api_key);
+ else {
+ const char *env_key = getenv("PPLX_API_KEY");
+ if (env_key && env_key[0]) s.api_key = xstrdup(env_key);
+ }
+
+ pthread_mutex_init(&s.mu, NULL);
+ pthread_cond_init(&s.cv, NULL);
+
+ for (int i = 0; i < cfg->n_models; i++) {
+ model_slot slot = model_slot_for_id(cfg->models[i].id);
+ if (slot == MODEL_UNKNOWN) {
+ fprintf(stderr, "pplx-serve: unknown model id: %s\n", cfg->models[i].id);
+ free_models(&s);
+ return 1;
+ }
+ if (load_one_model(&s, slot, cfg->models[i].path) != 0) {
+ free_models(&s);
+ return 1;
+ }
+ }
+
+ if (pipe(s.completion_pipe) != 0 || pipe(s.signal_pipe) != 0) {
+ perror("pipe");
+ free_models(&s);
+ return 1;
+ }
+ set_nonblock(s.completion_pipe[0]);
+ set_nonblock(s.completion_pipe[1]);
+ set_nonblock(s.signal_pipe[0]);
+ set_nonblock(s.signal_pipe[1]);
+
+ struct sigaction sa;
+ memset(&sa, 0, sizeof(sa));
+ sa.sa_handler = stop_signal_handler;
+ sigemptyset(&sa.sa_mask);
+ sigaction(SIGINT, &sa, NULL);
+ sigaction(SIGTERM, &sa, NULL);
+ signal(SIGPIPE, SIG_IGN);
+ g_signal_wfd = s.signal_pipe[1];
+
+ s.loop = aeCreateEventLoop(PPLX_HTTP_SETSIZE);
+ if (!s.loop) {
+ fprintf(stderr, "pplx-serve: failed to create event loop\n");
+ free_models(&s);
+ return 1;
+ }
+
+ if (pthread_create(&s.worker, NULL, worker_main, &s) != 0) {
+ fprintf(stderr, "pplx-serve: failed to start worker\n");
+ aeDeleteEventLoop(s.loop);
+ free_models(&s);
+ return 1;
+ }
+
+ s.listen_fd = listen_on(s.host, s.port);
+ if (s.listen_fd < 0) {
+ pthread_mutex_lock(&s.mu);
+ s.stopping = 1;
+ pthread_cond_signal(&s.cv);
+ pthread_mutex_unlock(&s.mu);
+ pthread_join(s.worker, NULL);
+ aeDeleteEventLoop(s.loop);
+ free_models(&s);
+ return 1;
+ }
+
+ aeCreateFileEvent(s.loop, s.listen_fd, AE_READABLE, accept_cb, &s);
+ aeCreateFileEvent(s.loop, s.completion_pipe[0], AE_READABLE, completion_cb, &s);
+ aeCreateFileEvent(s.loop, s.signal_pipe[0], AE_READABLE, signal_cb, &s);
+ aeCreateTimeEvent(s.loop, PPLX_HTTP_SWEEP_MS, timeout_cb, &s, NULL);
+
+ server_log("pplx-serve: listening on http://%s:%d", s.host, s.port);
+ aeMain(s.loop);
+
+ server_log("pplx-serve: shutdown requested");
+ if (s.listen_fd >= 0) close(s.listen_fd);
+ client *c = s.clients;
+ while (c) {
+ client *next = c->next;
+ close_client(c);
+ c = next;
+ }
+
+ pthread_mutex_lock(&s.mu);
+ s.stopping = 1;
+ pthread_cond_signal(&s.cv);
+ pthread_mutex_unlock(&s.mu);
+ pthread_join(s.worker, NULL);
+
+ aeDeleteEventLoop(s.loop);
+ close(s.completion_pipe[0]);
+ close(s.completion_pipe[1]);
+ close(s.signal_pipe[0]);
+ close(s.signal_pipe[1]);
+ free_models(&s);
+ free(s.api_key);
+ pthread_cond_destroy(&s.cv);
+ pthread_mutex_destroy(&s.mu);
+ return 0;
+}