lynkr 9.14.0 → 9.14.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lynkr",
-  "version": "9.14.0",
+  "version": "9.14.1",
   "files": [
     "index.js",
     "install.sh",

package/src/api/openai-router.js

@@ -468,7 +468,11 @@ async function forwardAnthropicStreamAsOpenAIChunks(res, stream, requestedModel)
 
 router.post("/chat/completions", async (req, res) => {
   const startTime = Date.now();
-  const sessionId = req.headers["x-session-id"] || req.headers["authorization"]?.split(" ")[1] || "openai-session";
+  // Issue #95: use sessionMiddleware's id (header → body id → content
+  // fingerprint → UUID). Falling back to the raw Authorization token here
+  // collapsed every conversation from a static-key client into ONE session
+  // (defeating WS1 pinning) and persisted the bearer token as a store key.
+  const sessionId = req.sessionId;
 
   try {
     if (!req.body || typeof req.body !== 'object') {
@@ -1588,7 +1592,10 @@ router.post("/embeddings", async (req, res) => {
  */
 router.post("/responses", async (req, res) => {
   const startTime = Date.now();
-  const sessionId = req.headers["x-session-id"] || req.headers["authorization"]?.split(" ")[1] || "responses-session";
+  // Issue #95: same as /chat/completions — trust sessionMiddleware, never
+  // the Authorization token. fingerprintSessionId understands the Responses
+  // API's `input` field, so fingerprinting works on this route too.
+  const sessionId = req.sessionId;
 
   try {
     const { convertResponsesToChat, convertChatToResponses } = require("../clients/responses-format");

package/src/clients/databricks.js

@@ -791,6 +791,13 @@ async function invokeOpenRouter(body, incomingHeaders = {}) {
     stream: body.stream ?? false
   };
 
+  // Issue #95: forward the Lynkr session id so OpenRouter's meta-routers
+  // (auto/pareto) can apply session stickiness — without it every call in a
+  // pinned session re-ranks fresh and one agentic task can span 6+ models.
+  if (body._sessionId) {
+    openRouterBody.session_id = body._sessionId;
+  }
+
   // Add tools - inject standard tools if client didn't send any (passthrough mode)
   let toolsToSend = body.tools;
   let toolsInjected = false;

package/src/headroom/client.js

@@ -115,27 +115,48 @@ async function compressMessages(messages, tools = [], options = {}) {
   }
 
   try {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), headroomConfig.timeoutMs);
-
-    const response = await fetch(`${headroomConfig.endpoint}/compress`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        messages,
-        tools,
-        model: options.model || "claude-3-5-sonnet-20241022",
-        model_limit: options.modelLimit || 200000,
-        mode: options.mode || headroomConfig.mode,
-        token_budget: options.tokenBudget,
-        query_context: options.queryContext,
-        preserve_recent_turns: options.preserveRecentTurns,
-        target_ratio: options.targetRatio,
-      }),
-      signal: controller.signal,
+    const requestBody = JSON.stringify({
+      messages,
+      tools,
+      model: options.model || "claude-3-5-sonnet-20241022",
+      model_limit: options.modelLimit || 200000,
+      mode: options.mode || headroomConfig.mode,
+      token_budget: options.tokenBudget,
+      query_context: options.queryContext,
+      preserve_recent_turns: options.preserveRecentTurns,
+      target_ratio: options.targetRatio,
     });
 
-    clearTimeout(timeout);
+    // The sidecar (uvicorn) closes idle keep-alive sockets after ~5s, and
+    // undici can reuse a pooled socket in that exact window → ECONNRESET
+    // surfaces as "fetch failed". One retry gets a fresh connection, so the
+    // race never costs us the compression. Aborts (real timeouts) still
+    // propagate immediately.
+    let response;
+    for (let attempt = 0; ; attempt++) {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), headroomConfig.timeoutMs);
+      try {
+        response = await fetch(`${headroomConfig.endpoint}/compress`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: requestBody,
+          signal: controller.signal,
+        });
+        break;
+      } catch (fetchErr) {
+        if (attempt === 0 && fetchErr.name !== "AbortError") {
+          logger.debug(
+            { error: fetchErr.message, cause: fetchErr.cause?.code || fetchErr.cause?.message },
+            "Headroom fetch failed, retrying on a fresh connection"
+          );
+          continue;
+        }
+        throw fetchErr;
+      } finally {
+        clearTimeout(timeout);
+      }
+    }
 
     if (!response.ok) {
       const errorText = await response.text();
@@ -179,7 +200,10 @@ async function compressMessages(messages, tools = [], options = {}) {
     if (err.name === "AbortError") {
       logger.warn({ timeoutMs: headroomConfig.timeoutMs }, "Headroom compression timed out");
     } else {
-      logger.warn({ error: err.message }, "Headroom compression failed, using original");
+      logger.warn(
+        { error: err.message, cause: err.cause?.code || err.cause?.message },
+        "Headroom compression failed, using original"
+      );
     }
 
     return {