lynkr 9.14.1 → 9.14.3

package/src/api/openai-router.js

@@ -28,6 +28,32 @@ const clientProfiles = require("../routing/client-profiles");
 
 const router = express.Router();
 
+/**
+ * Served-model decision headers for the OpenAI-compat ingress.
+ *
+ * The Anthropic ingress has carried X-Lynkr-* decision headers for a long
+ * time; this path never did — the same single-ingress gap as issue #100.
+ * X-Lynkr-Context-Window is the served model's REAL context window (the
+ * workweave pattern): behind a virtual model name, tier routing serves
+ * models with different windows per request, and this header is the
+ * client's authoritative per-turn compaction budget. Omitted (never
+ * guessed) for models the registry doesn't know.
+ *
+ * Safe on streaming paths: no-op once headers have flushed.
+ *
+ * @param {object} res - Express response
+ * @param {string|null} servedModel - model from the orchestrator result body
+ */
+function setServedModelHeaders(res, servedModel) {
+  if (!servedModel || res.headersSent) return;
+  try {
+    res.set("X-Lynkr-Model", servedModel);
+    const { contextWindowFor } = require("../routing/model-registry");
+    const contextWindow = contextWindowFor(servedModel);
+    if (contextWindow) res.set("X-Lynkr-Context-Window", String(contextWindow));
+  } catch { /* headers are best-effort — never fail a response over them */ }
+}
+
 /**
  * Resolve the model name for OpenAI responses.
  * In OpenClaw mode, returns the actual provider/model from routing metadata.
@@ -355,12 +381,36 @@ async function forwardAnthropicStreamAsOpenAIChunks(res, stream, requestedModel)
   const created = Math.floor(Date.now() / 1000);
   const model = requestedModel || "lynkr";
 
-  const chunk = (delta, finish = null) => `data: ${JSON.stringify({
+  const chunk = (delta, finish = null, usage = null) => `data: ${JSON.stringify({
     id, object: "chat.completion.chunk", created, model,
     system_fingerprint: "fp_lynkr",
     choices: [{ index: 0, delta, logprobs: null, finish_reason: finish }],
+    ...(usage ? { usage } : {}),
   })}\n\n`;
 
+  // Usage accounting (issue: opencode sidebar showed wrong token counts —
+  // this path never emitted usage at all). Anthropic sends input/cache
+  // tokens in message_start and output tokens in message_delta; accumulate
+  // and attach to the final chunk in OpenAI shape.
+  const usageAcc = { input: 0, cacheRead: 0, cacheWrite: 0, output: 0 };
+  const captureUsage = (u) => {
+    if (!u) return;
+    if (u.input_tokens != null) usageAcc.input = u.input_tokens;
+    if (u.cache_read_input_tokens != null) usageAcc.cacheRead = u.cache_read_input_tokens;
+    if (u.cache_creation_input_tokens != null) usageAcc.cacheWrite = u.cache_creation_input_tokens;
+    if (u.output_tokens != null) usageAcc.output = u.output_tokens;
+  };
+  const finalUsage = () => {
+    const promptTokens = usageAcc.input + usageAcc.cacheRead + usageAcc.cacheWrite;
+    const u = {
+      prompt_tokens: promptTokens,
+      completion_tokens: usageAcc.output,
+      total_tokens: promptTokens + usageAcc.output,
+    };
+    if (usageAcc.cacheRead > 0) u.prompt_tokens_details = { cached_tokens: usageAcc.cacheRead };
+    return u;
+  };
+
   const mapStop = (r) => r === "tool_use" ? "tool_calls" : r === "max_tokens" ? "length" : "stop";
 
   // Normalize Node Readable / web ReadableStream / async iterable to chunks.
@@ -394,6 +444,7 @@ async function forwardAnthropicStreamAsOpenAIChunks(res, stream, requestedModel)
 
         switch (ev.type) {
           case "message_start":
+            captureUsage(ev.message?.usage);
             if (!started) { started = true; res.write(chunk({ role: "assistant", content: "" })); }
             break;
           case "content_block_start":
@@ -419,10 +470,11 @@ async function forwardAnthropicStreamAsOpenAIChunks(res, stream, requestedModel)
             break;
           }
           case "message_delta":
+            captureUsage(ev.usage);
             if (ev.delta?.stop_reason) finishReason = mapStop(ev.delta.stop_reason);
             break;
           case "message_stop":
-            res.write(chunk({}, finishReason || "stop"));
+            res.write(chunk({}, finishReason || "stop", finalUsage()));
             res.write("data: [DONE]\n\n");
             res.end();
             return;
@@ -447,7 +499,7 @@ async function forwardAnthropicStreamAsOpenAIChunks(res, stream, requestedModel)
     // truncated stream: send an error chunk, never a fabricated "stop".
     if (!res.writableEnded) {
       if (finishReason) {
-        res.write(chunk({}, finishReason));
+        res.write(chunk({}, finishReason, finalUsage()));
         res.write("data: [DONE]\n\n");
       } else {
         logger.warn("Upstream stream ended without message_stop — sending error chunk to OpenAI-surface client");
@@ -542,6 +594,35 @@ router.post("/chat/completions", async (req, res) => {
       logger.debug({ err: err.message }, "[OpenAI Router] client profile detection failed");
     }
 
+    // Explicit model/effort pin: Codex's model picker (or any OpenAI-format
+    // caller) can name a real OpenAI model + reasoning.effort combo that
+    // resolveTierForOpenAIModel recognizes. Mirrors router.js's model-id-pin
+    // block for the Anthropic /v1/messages route — this one is needed
+    // separately because these OpenAI-shaped handlers call
+    // orchestrator.processMessage() directly and never go through router.js's
+    // pin/classifier code at all. See ../routing/openai-model-slots.js.
+    try {
+      const { resolveTierForOpenAIModel } = require("../routing/openai-model-slots");
+      const _effort = req.body?.reasoning?.effort ?? req.body?.reasoning_effort ?? null;
+      const _pinTier = resolveTierForOpenAIModel(req.body?.model, _effort);
+      if (_pinTier) {
+        const { getModelTierSelector } = require("../routing");
+        const _sel = getModelTierSelector().selectModel(_pinTier, null);
+        anthropicRequest._forceProvider = _sel.provider;
+        if (_sel.model) anthropicRequest._tierModel = _sel.model;
+        anthropicRequest._tierName = _pinTier;
+        anthropicRequest._forcedMethod = "openai_model_effort_pin";
+        logger.debug({
+          model: req.body?.model,
+          effort: _effort,
+          tier: _pinTier,
+          provider: _sel.provider,
+        }, "[OpenAI Router] Explicit model/effort pin — scoring bypassed");
+      }
+    } catch (err) {
+      logger.debug({ err: err.message }, "[OpenAI Router] model/effort pin failed");
+    }
+
     const session = getSession(sessionId);
 
     if (req.body.stream) {
@@ -565,9 +646,11 @@ router.post("/chat/completions", async (req, res) => {
           session: session,
           options: {
             maxSteps: req.body?.max_steps,
-            clientWantsStream: true
+            clientWantsStream: true,
+            tenantPolicy: res.locals?.tenantPolicy || null
           }
         });
+        setServedModelHeaders(res, result?.body?.model);
 
         // Phase 2b live stream: reshape Anthropic SSE events into OpenAI
         // chat.completion.chunk events in flight — first token reaches the
@@ -734,11 +817,33 @@ router.post("/chat/completions", async (req, res) => {
             delta: {},
             logprobs: null,
             finish_reason: openaiResponse.choices[0].finish_reason
-          }]
+          }],
+          // Clients (opencode et al.) read token accounting from the final
+          // chunk — omitting it here left streamed turns uncounted.
+          usage: openaiResponse.usage
         };
 
         logger.debug({ chunk: "finish", finishReason: openaiResponse.choices[0].finish_reason }, "Sending finish chunk");
         res.write(`data: ${JSON.stringify(finishChunk)}\n\n`);
+
+        // Trailing usage chunk (choices: [], usage populated) — same shape
+        // as the Phase 2b live-stream path above. Previously this buffered
+        // synthesis only ever logged openaiResponse.usage (see below) and
+        // never wrote it to the client, so streaming clients on this path
+        // saw zero token/context usage too.
+        if (openaiResponse.usage) {
+          const usageChunk = {
+            id: openaiResponse.id,
+            object: "chat.completion.chunk",
+            created: openaiResponse.created,
+            model: streamModel,
+            system_fingerprint: "fp_lynkr",
+            choices: [],
+            usage: openaiResponse.usage,
+          };
+          res.write(`data: ${JSON.stringify(usageChunk)}\n\n`);
+        }
+
         res.write("data: [DONE]\n\n");
 
         logger.debug({ contentLength: content.length, contentPreview: content.substring(0, 50) }, "=== SSE STREAM COMPLETE ===");
@@ -782,9 +887,11 @@ router.post("/chat/completions", async (req, res) => {
         headers: req.headers,
         session: session,
         options: {
-          maxSteps: req.body?.max_steps
+          maxSteps: req.body?.max_steps,
+          tenantPolicy: res.locals?.tenantPolicy || null
         }
       });
+      setServedModelHeaders(res, result?.body?.model);
 
       logger.debug({
         resultKeys: Object.keys(result || {}),
@@ -839,6 +946,24 @@ router.post("/chat/completions", async (req, res) => {
         finishReason: openaiResponse.choices[0].finish_reason
       }, "=== OPENAI CHAT COMPLETION RESPONSE ===");
 
+      // Surface the routed reality: which model actually answered and what
+      // it cost (LiteLLM-style headers). Clients that can't price a dynamic
+      // router (opencode #24113) get the truth out-of-band.
+      const routingMeta = result.body?._routingMeta;
+      if (routingMeta?.model) {
+        res.set("x-lynkr-routed-model", String(routingMeta.model));
+        if (routingMeta.provider) res.set("x-lynkr-routed-provider", String(routingMeta.provider));
+        try {
+          const { computeCostUsd } = require("../clients/databricks");
+          const cost = computeCostUsd(
+            routingMeta.model,
+            result.body?.usage?.input_tokens || 0,
+            result.body?.usage?.output_tokens || 0
+          );
+          if (cost != null) res.set("x-lynkr-response-cost", cost.toFixed(6));
+        } catch { /* cost pricing unavailable — headers are best-effort */ }
+      }
+
       res.json(openaiResponse);
     }
 
@@ -1018,6 +1143,19 @@ function getConfiguredProviders() {
     });
   }
 
+  if (config.fireworks?.apiKey) {
+    providers.push({
+      name: "fireworks",
+      type: "fireworks-ai",
+      models: [
+        config.fireworks.model || "accounts/fireworks/models/kimi-k2-instruct-0905",
+        "accounts/fireworks/models/kimi-k2-instruct-0905",
+        "accounts/fireworks/models/glm-5p2",
+        "accounts/fireworks/models/deepseek-v3p1"
+      ]
+    });
+  }
+
   if (config.vertex?.projectId) {
     providers.push({
       name: "vertex",
@@ -1043,7 +1181,6 @@ function getConfiguredProviders() {
 router.get("/models", (req, res) => {
   try {
     const providers = getConfiguredProviders();
-    const primaryProvider = config.modelProvider?.type || "databricks";
     const timestamp = Math.floor(Date.now() / 1000);
     const models = [];
     const seenModelIds = new Set();
@@ -1480,7 +1617,7 @@ router.post("/embeddings", async (req, res) => {
   const startTime = Date.now();
 
   try {
-    const { input, model, encoding_format } = req.body;
+    const { input, model, encoding_format: encodingFormat } = req.body;
 
     if (!input) {
       return res.status(400).json({
@@ -1492,6 +1629,16 @@ router.post("/embeddings", async (req, res) => {
       });
     }
 
+    if (encodingFormat && encodingFormat !== "float" && encodingFormat !== "base64") {
+      return res.status(400).json({
+        error: {
+          message: `Invalid encoding_format: ${encodingFormat}. Must be "float" or "base64".`,
+          type: "invalid_request_error",
+          code: "invalid_parameter"
+        }
+      });
+    }
+
     const inputs = Array.isArray(input) ? input : [input];
 
     logger.debug({
@@ -1565,6 +1712,20 @@ router.post("/embeddings", async (req, res) => {
       totalTokens: embeddingResponse.usage?.total_tokens || 0
     }, "=== EMBEDDINGS RESPONSE ===");
 
+    // Providers return float arrays; honor encoding_format=base64 (OpenAI
+    // spec: base64 of the little-endian float32 buffer) instead of silently
+    // returning floats for every request.
+    if (encodingFormat === "base64" && Array.isArray(embeddingResponse.data)) {
+      for (const item of embeddingResponse.data) {
+        if (Array.isArray(item.embedding)) {
+          item.embedding = Buffer.from(new Float32Array(item.embedding).buffer).toString("base64");
+        }
+      }
+      if ("encoding_format" in embeddingResponse) {
+        embeddingResponse.encoding_format = "base64";
+      }
+    }
+
     res.json(embeddingResponse);
 
   } catch (error) {
@@ -1761,6 +1922,32 @@ router.post("/responses", async (req, res) => {
       logger.debug({ err: err.message }, "[OpenAI Router] client profile detection failed");
     }
 
+    // Explicit model/effort pin — see the identical block in /chat/completions
+    // above for the full rationale. This is the route Codex Desktop actually
+    // uses (wire_api="responses"), so this is the one that matters for its
+    // model picker specifically.
+    try {
+      const { resolveTierForOpenAIModel } = require("../routing/openai-model-slots");
+      const _effort = req.body?.reasoning?.effort ?? req.body?.reasoning_effort ?? null;
+      const _pinTier = resolveTierForOpenAIModel(req.body?.model, _effort);
+      if (_pinTier) {
+        const { getModelTierSelector } = require("../routing");
+        const _sel = getModelTierSelector().selectModel(_pinTier, null);
+        anthropicRequest._forceProvider = _sel.provider;
+        if (_sel.model) anthropicRequest._tierModel = _sel.model;
+        anthropicRequest._tierName = _pinTier;
+        anthropicRequest._forcedMethod = "openai_model_effort_pin";
+        logger.debug({
+          model: req.body?.model,
+          effort: _effort,
+          tier: _pinTier,
+          provider: _sel.provider,
+        }, "[OpenAI Router] Explicit model/effort pin (responses) — scoring bypassed");
+      }
+    } catch (err) {
+      logger.debug({ err: err.message }, "[OpenAI Router] model/effort pin failed (responses)");
+    }
+
     const session = getSession(sessionId);
 
     if (req.body.stream) {
@@ -1775,7 +1962,7 @@ router.post("/responses", async (req, res) => {
 
         // SSE comment keepalive (spec-compliant, ignored by all clients)
         const keepalive = setInterval(() => {
-          try { res.write(`: keepalive\n\n`); } catch {}
+          try { res.write(`: keepalive\n\n`); } catch { /* client gone — best-effort keepalive */ }
         }, 2000);
 
         let result;
@@ -1785,9 +1972,11 @@ router.post("/responses", async (req, res) => {
             headers: req.headers,
             session: session,
             options: {
-              maxSteps: req.body?.max_steps
+              maxSteps: req.body?.max_steps,
+              tenantPolicy: res.locals?.tenantPolicy || null
             }
           });
+          setServedModelHeaders(res, result?.body?.model);
         } finally {
           clearInterval(keepalive);
         }
@@ -1882,21 +2071,25 @@ router.post("/responses", async (req, res) => {
                   if (taskArgs.prompt && taskArgs.prompt.toLowerCase().includes("read")) {
                     exploreCmd = "cat README.md 2>/dev/null && cat package.json 2>/dev/null";
                   }
-                } catch {}
+                } catch (err) {
+                  logger.debug({ err: err?.message }, "Failed to parse task tool arguments — using default explore command");
+                }
               }
               converted.push({ ...tc, function: { name: "shell", arguments: JSON.stringify({ command: ["bash", "-c", exploreCmd] }) } });
               continue;
             }
 
             let args = {};
-            try { args = JSON.parse(tc.function?.arguments || "{}"); } catch {}
+            try { args = JSON.parse(tc.function?.arguments || "{}"); } catch (err) {
+              logger.debug({ err: err?.message }, "Failed to parse tool call arguments — treating as empty object");
+            }
 
             // Already a shell command — normalise to array format
             if (ln === "shell" || ln === "bash") {
               let cmd = args.command || "";
               // Handle string-encoded arrays: '["bash","-c","ls"]'
               if (typeof cmd === "string" && cmd.trim().startsWith("[")) {
-                try { cmd = JSON.parse(cmd); } catch {}
+                try { cmd = JSON.parse(cmd); } catch { /* not a JSON array — keep as plain string */ }
               }
               // Extract the actual command from ["bash", "-c", "actual command"]
               if (Array.isArray(cmd) && cmd.length >= 3 && cmd[0] === "bash" && cmd[1] === "-c") {
@@ -2107,7 +2300,7 @@ router.post("/responses", async (req, res) => {
             sequence_number: 1
           })}\n\n`
         ].join("");
-        try { res.end(errorPayload); } catch { try { res.end(); } catch {} }
+        try { res.end(errorPayload); } catch { try { res.end(); } catch { /* res already ended — best-effort */ } }
       }
 
     } else {
@@ -2118,9 +2311,11 @@ router.post("/responses", async (req, res) => {
         headers: req.headers,
         session: session,
         options: {
-          maxSteps: req.body?.max_steps
+          maxSteps: req.body?.max_steps,
+          tenantPolicy: res.locals?.tenantPolicy || null
         }
       });
+      setServedModelHeaders(res, result?.body?.model);
 
       const chatResponse = convertAnthropicToOpenAI(result.body, resolveResponseModel(result.body, req.body.model));
       const responsesResponse = convertChatToResponses(chatResponse);

package/src/api/providers-handler.js

@@ -21,7 +21,6 @@ const router = express.Router();
  */
 function getConfiguredProviders() {
   const providers = [];
-  const timestamp = Math.floor(Date.now() / 1000);
 
   // Check Databricks
   if (config.databricks?.url && config.databricks?.apiKey) {
@@ -238,6 +237,22 @@ function getConfiguredProviders() {
     });
   }
 
+  // Check Fireworks AI (serverless open models)
+  if (config.fireworks?.apiKey) {
+    providers.push({
+      name: "fireworks",
+      type: "fireworks-ai",
+      baseUrl: config.fireworks.endpoint || "https://api.fireworks.ai/inference/v1",
+      enabled: true,
+      models: [
+        { id: config.fireworks.model || "accounts/fireworks/models/kimi-k2-instruct-0905", name: "Configured Model" },
+        { id: "accounts/fireworks/models/kimi-k2-instruct-0905", name: "Kimi K2 Instruct" },
+        { id: "accounts/fireworks/models/glm-5p2", name: "GLM 5.2" },
+        { id: "accounts/fireworks/models/deepseek-v3p1", name: "DeepSeek V3.1" },
+      ]
+    });
+  }
+
   // Check Vertex AI (Google Cloud)
   if (config.vertex?.projectId) {
     const region = config.vertex.region || "us-east5";