feat: add embeddings endpoint and config for OpenAI-compatible text embeddings via gateway

Add POST /openai/v1/embeddings route in openai_gateway router, new config fields for embedding upstream URL/model/key/enabled toggle with defaults pointing to OpenRouter Qwen3 8B, INTERNAL_EMBED_MODEL constant in config.py, documentation in docs_api.py and README.md describing the molodetz~embed model mapping, and embed-call tracking in gateway metrics alongside existing chat/vision counters.

devplacepy/services/openai_gateway/gateway.py

@@ -101,6 +101,7 @@ class GatewayRuntime:
         self.in_flight = 0
         self.peak_in_flight = 0
         self.vision_calls = 0
+        self.embed_calls = 0
         self.last_status = 0
         self.last_latency_ms = 0
 
@@ -345,6 +346,137 @@ class GatewayRuntime:
             )
         return JSONResponse(content=data)
 
+    async def handle_embeddings(
+        self, body: dict, cfg: dict, owner: tuple, user_agent: str, log=None
+    ):
+        log = log or (lambda message: None)
+        if not cfg["gateway_embed_enabled"]:
+            return JSONResponse(
+                status_code=503,
+                content={
+                    "error": {
+                        "message": "Embeddings are disabled",
+                        "type": "embeddings_disabled",
+                    }
+                },
+            )
+        client, sem = self._ensure(cfg)
+        pricing = pricing_from_cfg(cfg)
+        context_map = parse_context_map(cfg.get("gateway_model_context_map"))
+        params = extract_params(body)
+        handle_start = time.monotonic()
+
+        requested = body.get("model")
+        if cfg["gateway_force_model"] or not requested or requested == "molodetz~embed":
+            model = cfg["gateway_embed_model"]
+        else:
+            model = requested
+
+        payload = dict(body)
+        payload["model"] = model
+
+        headers = {"Content-Type": "application/json"}
+        if cfg["gateway_embed_key"]:
+            headers["Authorization"] = f"Bearer {cfg['gateway_embed_key']}"
+        else:
+            log(
+                "No upstream embeddings API key configured (gateway_embed_key / gateway_vision_key / OPENROUTER_API_KEY); upstream will likely reject the request"
+            )
+
+        resp, exc, timing = await self._send(
+            client,
+            sem,
+            "POST",
+            cfg["gateway_embed_url"],
+            headers,
+            cfg,
+            log,
+            json_body=payload,
+        )
+
+        base = {
+            "owner_kind": owner[0],
+            "owner_id": owner[1],
+            "backend": "embed",
+            "endpoint": "embeddings",
+            "model": model,
+            "user_agent": user_agent,
+            **params,
+            **timing,
+        }
+
+        def finalize(status_code, success, category, usage=None):
+            base["total_latency_ms"] = round(
+                (time.monotonic() - handle_start) * 1000, 3
+            )
+            base["gateway_overhead_ms"] = round(
+                max(
+                    base["total_latency_ms"]
+                    - timing["upstream_latency_ms"]
+                    - timing["queue_wait_ms"],
+                    0.0,
+                ),
+                3,
+            )
+            base["status_code"] = status_code
+            base["success"] = success
+            base["error_category"] = category
+            base["usage"] = usage
+            self._ledger.record(base, pricing, context_map)
+
+        if timing["circuit_open"]:
+            finalize(503, False, "circuit_open")
+            return JSONResponse(
+                status_code=503,
+                content={
+                    "error": {
+                        "message": "Upstream temporarily unavailable",
+                        "type": "circuit_open",
+                    }
+                },
+            )
+        if exc is not None:
+            finalize(502, False, classify_error(0, exc))
+            return JSONResponse(
+                status_code=502,
+                content={
+                    "error": {
+                        "message": f"Upstream connection failed: {exc}",
+                        "type": "upstream_error",
+                    }
+                },
+            )
+        if resp.status_code != 200:
+            finalize(
+                resp.status_code,
+                False,
+                classify_error(resp.status_code, None, resp.text),
+            )
+            log(f"embed upstream POST -> {resp.status_code}: {resp.text[:300]}")
+            return JSONResponse(
+                status_code=resp.status_code,
+                content={"error": {"message": resp.text, "type": "upstream_error"}},
+            )
+        try:
+            data = resp.json()
+        except ValueError:
+            self.errors += 1
+            finalize(502, False, "gateway")
+            log("embed upstream returned 200 but body was not valid JSON")
+            return JSONResponse(
+                status_code=502,
+                content={
+                    "error": {
+                        "message": "invalid upstream response",
+                        "type": "upstream_error",
+                    }
+                },
+            )
+        self.embed_calls += 1
+        finalize(200, True, None, data.get("usage"))
+        log(f"embed POST -> 200 ({timing['upstream_latency_ms']:.0f}ms)")
+        return JSONResponse(content=data)
+
     async def handle_passthrough(
         self,
         method: str,
@@ -458,6 +590,7 @@ class GatewayRuntime:
             "in_flight": self.in_flight,
             "peak_in_flight": self.peak_in_flight,
             "vision_calls": self.vision_calls,
+            "embed_calls": self.embed_calls,
             "last_status": self.last_status,
             "last_latency_ms": self.last_latency_ms,
             "pool": self._instances,