lynkr 9.0.2 → 9.1.2

package/src/api/files-router.js

@@ -33,7 +33,7 @@ router.post("/files", async (req, res) => {
           filename = parsed.filename || filename;
           mimeType = parsed.mimeType || mimeType;
           purpose = parsed.purpose || purpose;
-          const entry = fileStore.storeFile(parsed.file, { filename, purpose, mimeType });
+          const entry = await fileStore.storeFile(parsed.file, { filename, purpose, mimeType });
           return res.json(entry);
         }
       }
@@ -43,7 +43,7 @@ router.post("/files", async (req, res) => {
     mimeType = contentType.split(";")[0].trim() || mimeType;
     filename = req.headers["x-filename"] || filename;
     purpose = req.query.purpose || purpose;
-    const entry = fileStore.storeFile(buffer, { filename, purpose, mimeType });
+    const entry = await fileStore.storeFile(buffer, { filename, purpose, mimeType });
     res.json(entry);
   } catch (err) {
     logger.error({ err }, "File upload failed");
@@ -62,18 +62,18 @@ router.get("/files/:id", (req, res) => {
   res.json(file);
 });
 
-router.get("/files/:id/content", (req, res) => {
+router.get("/files/:id/content", async (req, res) => {
   const file = fileStore.getFile(req.params.id);
   if (!file) return res.status(404).json({ error: { message: "File not found" } });
-  const content = fileStore.getFileContent(req.params.id);
+  const content = await fileStore.getFileContent(req.params.id);
   if (!content) return res.status(404).json({ error: { message: "File content not found" } });
   res.setHeader("Content-Type", file.mime_type);
   res.setHeader("Content-Disposition", `attachment; filename="${file.filename}"`);
   res.send(content);
 });
 
-router.delete("/files/:id", (req, res) => {
-  const deleted = fileStore.deleteFile(req.params.id);
+router.delete("/files/:id", async (req, res) => {
+  const deleted = await fileStore.deleteFile(req.params.id);
   if (!deleted) return res.status(404).json({ error: { message: "File not found" } });
   res.json({ id: req.params.id, object: "file", deleted: true });
 });

package/src/api/middleware/budget.js

@@ -57,12 +57,30 @@ function budgetMiddleware(req, res, next) {
     }, 'Budget warning: approaching limits');
   }
 
-  // Attach budget info to request for usage recording later
   req.budgetInfo = {
     userId,
     budgetCheck,
+    startTime: Date.now(),
   };
 
+  // Record usage after response completes
+  res.on('finish', () => {
+    try {
+      const usage = res.locals.usage;
+      if (!usage) return;
+      budgetManager.recordUsage(userId, req.session?.id || null, {
+        tokensInput: usage.prompt_tokens || usage.input_tokens || 0,
+        tokensOutput: usage.completion_tokens || usage.output_tokens || 0,
+        costUsd: usage.cost_usd || 0,
+        model: usage.model || null,
+        endpoint: req.path,
+        latencyMs: Date.now() - req.budgetInfo.startTime,
+      });
+    } catch (err) {
+      logger.warn({ err: err.message }, 'Failed to record usage after response');
+    }
+  });
+
   next();
 }
 

package/src/api/middleware/load-shedding.js

@@ -1,3 +1,4 @@
+const os = require("os");
 const logger = require("../../logger");
 const { ServiceUnavailableError } = require("./error-handling");
 
@@ -55,6 +56,20 @@ class LoadShedder {
       return true;
     }
 
+    // Check RSS / system memory
+    const rssPercent = memUsage.rss / os.totalmem();
+    if (rssPercent > this.memoryThreshold) {
+      logger.warn(
+        {
+          rssPercent: (rssPercent * 100).toFixed(2),
+          threshold: (this.memoryThreshold * 100).toFixed(2),
+        },
+        "Load shedding: RSS memory usage exceeded threshold"
+      );
+      this.cachedOverloadState = true;
+      return true;
+    }
+
     // Check active requests
     if (this.activeRequests > this.activeRequestsThreshold) {
       logger.warn(
@@ -81,8 +96,10 @@ class LoadShedder {
       activeRequests: this.activeRequests,
       totalShed: this.totalShed,
       heapUsedPercent: ((memUsage.heapUsed / memUsage.heapTotal) * 100).toFixed(2),
+      rssPercent: ((memUsage.rss / os.totalmem()) * 100).toFixed(2),
       thresholds: {
         heapThreshold: (this.heapThreshold * 100).toFixed(2),
+        memoryThreshold: (this.memoryThreshold * 100).toFixed(2),
         activeRequestsThreshold: this.activeRequestsThreshold,
       },
     };

package/src/api/openai-router.js

@@ -366,7 +366,7 @@ router.post("/chat/completions", async (req, res) => {
       role: m.role,
       contentPreview: typeof m.content === 'string'
         ? m.content.substring(0, 200)
-        : JSON.stringify(m.content).substring(0, 200)
+        : (m.content == null ? null : (JSON.stringify(m.content) ?? '').substring(0, 200))
     }));
 
     logger.debug({

package/src/api/router.js

@@ -6,8 +6,10 @@ const logger = require("../logger");
 const { createRateLimiter } = require("./middleware/rate-limiter");
 const openaiRouter = require("./openai-router");
 const providersRouter = require("./providers-handler");
-const { getRoutingHeaders, getRoutingStats, analyzeComplexity, getModelTierSelector } = require("../routing");
+const { getRoutingHeaders, getRoutingStats, analyzeComplexity, getModelTierSelector, analyzeRisk } = require("../routing");
+const { buildInteractionBlock } = require("../routing/interaction");
 const { validateCwd } = require("../workspace");
+const { renderText } = require("../utils/markdown-ansi");
 
 const router = express.Router();
 
@@ -63,6 +65,24 @@ router.get("/health", (req, res) => {
   res.json({ status: "ok" });
 });
 
+// Usage report — same data as `lynkr usage` CLI, served as JSON for
+// dashboards / agents / scripts that want to surface spend & savings.
+router.get("/v1/usage", (req, res) => {
+  try {
+    const aggregator = require("../usage/aggregator");
+    const window = req.query.window || (req.query.days ? `${parseInt(req.query.days, 10)}d` : "30d");
+    const usage = aggregator.getUsage({
+      window,
+      flagship: req.query.flagship,
+      provider: req.query.provider,
+      model: req.query.model,
+    });
+    res.json(usage);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
 // Routing stats endpoint (Phase 3: Metrics)
 router.get("/routing/stats", (req, res) => {
   const stats = getRoutingStats();
@@ -260,24 +280,70 @@ router.post("/v1/messages", rateLimiter, async (req, res, next) => {
     // Analyze complexity for routing headers (Phase 3)
     const complexity = await analyzeComplexity(req.body);
     timer.mark("analyzeComplexity");
+
+    // Risk axis runs alongside complexity. Cheap pure-string scan, no I/O.
+    let preRouteRisk = null;
+    try {
+      preRouteRisk = analyzeRisk(req.body);
+    } catch (err) {
+      logger.debug({ err: err.message }, '[Router] Risk analysis failed in pre-route');
+    }
+
+    // Pre-route tier: high-risk forces COMPLEX, otherwise tier is
+    // inferred from the complexity recommendation. The actual final
+    // tier may differ (invokeModel re-runs determineProviderSmart) —
+    // this is best-effort for header surfacing.
     let preRouteProvider = 'cloud';
-    if (complexity.recommendation === 'local') {
-      // Use tier config to determine actual provider instead of hardcoding 'ollama'
+    let preRouteTier = null;
+    let preRouteModel = null;
+    let preRouteMethod = 'complexity';
+    let preRouteReason = complexity.breakdown?.taskType?.reason || complexity.recommendation;
+
+    if (preRouteRisk?.level === 'high') {
       try {
         const selector = getModelTierSelector();
-        const tierResult = selector.selectModel('SIMPLE', null);
+        const tierResult = selector.selectModel('COMPLEX', null);
         preRouteProvider = tierResult.provider;
+        preRouteTier = 'COMPLEX';
+        preRouteModel = tierResult.model;
+        preRouteMethod = 'risk';
+        preRouteReason = 'high_risk_forced_tier';
       } catch (_) {
-        preRouteProvider = 'ollama';
+        // Risk-forced tier not configured; fall back to normal flow.
+      }
+    }
+
+    if (!preRouteTier) {
+      if (complexity.recommendation === 'local') {
+        try {
+          const selector = getModelTierSelector();
+          const tierResult = selector.selectModel('SIMPLE', null);
+          preRouteProvider = tierResult.provider;
+          preRouteTier = 'SIMPLE';
+          preRouteModel = tierResult.model;
+        } catch (_) {
+          preRouteProvider = 'ollama';
+        }
       }
     }
-    const routingHeaders = getRoutingHeaders({
+
+    const preRouteDecision = {
       provider: preRouteProvider,
+      tier: preRouteTier,
+      model: preRouteModel,
+      method: preRouteMethod,
+      reason: preRouteReason,
       score: complexity.score,
       threshold: complexity.threshold,
-      method: 'complexity',
-      reason: complexity.breakdown?.taskType?.reason || complexity.recommendation,
-    });
+      risk: preRouteRisk,
+    };
+
+    const routingHeaders = getRoutingHeaders(preRouteDecision);
+
+    // Build the interaction block once. It travels in headers always
+    // (X-Lynkr-Interaction-* derived fields) and optionally into the
+    // response body when LYNKR_VISIBLE_ROUTING=true.
+    const interaction = buildInteractionBlock(preRouteDecision);
 
     // Extract client CWD from request body or header
     const clientCwd = validateCwd(req.body?.cwd || req.headers['x-workspace-cwd']);
@@ -424,17 +490,35 @@ router.post("/v1/messages", rateLimiter, async (req, res, next) => {
             content_block: { type: "text", text: "" }
           })}\n\n`);
 
-          // Send text in chunks
-          const text = block.text || "";
-          const chunkSize = 20;
-          for (let j = 0; j < text.length; j += chunkSize) {
-            const chunk = text.slice(j, j + chunkSize);
-            res.write(`event: content_block_delta\n`);
-            res.write(`data: ${JSON.stringify({
-              type: "content_block_delta",
-              index: i,
-              delta: { type: "text_delta", text: chunk }
-            })}\n\n`);
+          // Send text — one chunk when ANSI rendering is active (splitting
+          // ANSI escape sequences across 20-char chunks breaks terminal output).
+          // Plain text falls back to line-level chunks for a trickle effect.
+          // Never apply ANSI rendering to HTML content (<artifact> blocks):
+          // ANSI codes corrupt CSS selectors like `*` and break the browser viewer.
+          const rawBlockText = block.text || "";
+          const isHtmlContent = rawBlockText.includes("<artifact") || rawBlockText.trimStart().startsWith("<");
+          const text = isHtmlContent ? rawBlockText : renderText(rawBlockText);
+          const { enabled: ansiEnabled } = require("../utils/markdown-ansi");
+          if (ansiEnabled && !isHtmlContent) {
+            if (text.length > 0) {
+              res.write(`event: content_block_delta\n`);
+              res.write(`data: ${JSON.stringify({
+                type: "content_block_delta",
+                index: i,
+                delta: { type: "text_delta", text }
+              })}\n\n`);
+            }
+          } else {
+            const lines = text.split("\n");
+            for (const line of lines) {
+              const lineWithNl = line + "\n";
+              res.write(`event: content_block_delta\n`);
+              res.write(`data: ${JSON.stringify({
+                type: "content_block_delta",
+                index: i,
+                delta: { type: "text_delta", text: lineWithNl }
+              })}\n\n`);
+            }
           }
 
           res.write(`event: content_block_stop\n`);
@@ -459,22 +543,37 @@ router.post("/v1/messages", rateLimiter, async (req, res, next) => {
           res.write(`event: content_block_stop\n`);
           res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: i })}\n\n`);
         } else if (block.type === "tool_use") {
-          res.write(`event: content_block_start\n`);
-          res.write(`data: ${JSON.stringify({
-            type: "content_block_start",
-            index: i,
-            content_block: { type: "tool_use", id: block.id, name: block.name, input: {} }
-          })}\n\n`);
-
-          res.write(`event: content_block_delta\n`);
-          res.write(`data: ${JSON.stringify({
-            type: "content_block_delta",
-            index: i,
-            delta: { type: "input_json_delta", partial_json: JSON.stringify(block.input) }
-          })}\n\n`);
-
-          res.write(`event: content_block_stop\n`);
-          res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: i })}\n\n`);
+          // Original request had no tools → model hallucinated a tool call.
+          // Extract file content from write-style tools and wrap it in an
+          // <artifact> block so open-design routes it to the Design panel.
+          const toolName = (block.name || "").toLowerCase();
+          const writeTools = new Set(["write", "create_file", "write_file", "str_replace_editor"]);
+          if (writeTools.has(toolName)) {
+            const rawContent = block.input?.content ?? block.input?.file_content ?? block.input?.new_content ?? "";
+            const filePath = String(block.input?.file_path ?? block.input?.filename ?? "design.html");
+            const content = String(rawContent);
+            if (content) {
+              // Wrap in <artifact> so open-design's parser routes it to the file viewer.
+              const identifier = filePath.replace(/[^a-zA-Z0-9._-]/g, "_");
+              const title = filePath;
+              const wrapped = `<artifact identifier="${identifier}" type="text/html" title="${title}">\n${content}\n</artifact>`;
+              res.write(`event: content_block_start\n`);
+              res.write(`data: ${JSON.stringify({
+                type: "content_block_start",
+                index: i,
+                content_block: { type: "text", text: "" }
+              })}\n\n`);
+              res.write(`event: content_block_delta\n`);
+              res.write(`data: ${JSON.stringify({
+                type: "content_block_delta",
+                index: i,
+                delta: { type: "text_delta", text: wrapped }
+              })}\n\n`);
+              res.write(`event: content_block_stop\n`);
+              res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: i })}\n\n`);
+            }
+          }
+          // Non-write tool_use in a tool-less request is silently dropped.
         }
       }
 
@@ -566,16 +665,30 @@ router.post("/v1/messages", rateLimiter, async (req, res, next) => {
             content_block: { type: "text", text: "" }
           })}\n\n`);
 
-          const text = block.text || "";
-          const chunkSize = 20;
-          for (let j = 0; j < text.length; j += chunkSize) {
-            const chunk = text.slice(j, j + chunkSize);
-            res.write(`event: content_block_delta\n`);
-            res.write(`data: ${JSON.stringify({
-              type: "content_block_delta",
-              index: i,
-              delta: { type: "text_delta", text: chunk }
-            })}\n\n`);
+          const rawBlockText2 = block.text || "";
+          const isHtmlContent2 = rawBlockText2.includes("<artifact") || rawBlockText2.trimStart().startsWith("<");
+          const text = isHtmlContent2 ? rawBlockText2 : renderText(rawBlockText2);
+          const { enabled: ansiEnabled } = require("../utils/markdown-ansi");
+          if (ansiEnabled && !isHtmlContent2) {
+            if (text.length > 0) {
+              res.write(`event: content_block_delta\n`);
+              res.write(`data: ${JSON.stringify({
+                type: "content_block_delta",
+                index: i,
+                delta: { type: "text_delta", text }
+              })}\n\n`);
+            }
+          } else {
+            const lines = text.split("\n");
+            for (const line of lines) {
+              const lineWithNl = line + "\n";
+              res.write(`event: content_block_delta\n`);
+              res.write(`data: ${JSON.stringify({
+                type: "content_block_delta",
+                index: i,
+                delta: { type: "text_delta", text: lineWithNl }
+              })}\n\n`);
+            }
           }
 
           res.write(`event: content_block_stop\n`);
@@ -651,8 +764,33 @@ router.post("/v1/messages", rateLimiter, async (req, res, next) => {
       });
     }
 
+    // Inject visible interaction block into the response body when
+    // LYNKR_VISIBLE_ROUTING=true. We only mutate JSON bodies — and only
+    // when the response looks like a valid Anthropic Message — so this
+    // is a no-op for streamed / error / non-message responses.
+    let finalBody = result.body;
+    if (
+      config.routing?.visibleInteraction &&
+      interaction &&
+      result.status >= 200 && result.status < 300 &&
+      result.body
+    ) {
+      try {
+        const text = Buffer.isBuffer(result.body) ? result.body.toString('utf8') : result.body;
+        if (typeof text === 'string' && text.startsWith('{')) {
+          const parsed = JSON.parse(text);
+          if (parsed && typeof parsed === 'object' && parsed.type === 'message') {
+            parsed.lynkr_interaction = interaction;
+            finalBody = JSON.stringify(parsed);
+          }
+        }
+      } catch (err) {
+        logger.debug({ err: err.message }, '[Router] Skipped interaction injection (non-JSON body)');
+      }
+    }
+
     metrics.recordResponse(result.status);
-    res.status(result.status).send(result.body);
+    res.status(result.status).send(finalBody);
   } catch (error) {
     next(error);
   }

package/src/clients/databricks.js

@@ -221,7 +221,7 @@ async function invokeOllama(body) {
   const useAnthropicApi = await hasAnthropicEndpoint(config.ollama.endpoint);
 
   // Check if model supports tools FIRST (before wasteful injection)
-  const supportsTools = await checkOllamaToolSupport(config.ollama.model);
+  const supportsTools = await checkOllamaToolSupport(modelName);
   const injectToolsOllama = process.env.INJECT_TOOLS_OLLAMA !== "false";
 
   // Determine tools to send
@@ -476,13 +476,17 @@ async function invokeAzureOpenAI(body) {
   // System prompt injection disabled - breaks model response
   // Tool guidance now provided via tool descriptions instead
 
+  const azureDeployment = body._suggestionModeModel || body._tierModel || config.azureOpenAI.deployment || "";
+  const isGpt5 = /gpt-5/i.test(azureDeployment);
+  const maxTokensKey = isGpt5 ? "max_completion_tokens" : "max_tokens";
+
   const azureBody = {
     messages,
-    temperature: body.temperature ?? 0.3,  // Lower temperature for more deterministic, action-oriented behavior
-    max_tokens: Math.min(body.max_tokens ?? 16384, 16384),  // Cap at Azure OpenAI's limit
+    temperature: body.temperature ?? 0.3,
+    [maxTokensKey]: Math.min(body.max_tokens ?? 16384, 16384),
     top_p: body.top_p ?? 1.0,
-    stream: false,  // Force non-streaming for Azure OpenAI - streaming format conversion not yet implemented
-    model: body._suggestionModeModel || body._tierModel || config.azureOpenAI.deployment
+    stream: false,
+    model: azureDeployment
   };
 
   // Add tools - inject standard tools if client didn't send any (passthrough mode)

package/src/clients/openai-format.js

@@ -203,24 +203,37 @@ function convertAnthropicToOpenAI(anthropicResponse, model = "claude-3-5-sonnet-
 
   const { id, content, stop_reason, usage } = anthropicResponse;
 
-  // Validate required fields
-  if (!content || !Array.isArray(content)) {
-    throw new Error(`convertAnthropicToOpenAI: invalid content field (got ${typeof content})`);
+  // Tolerant fallback: providers sometimes return reasoning-only responses
+  // (Minimax/DeepSeek), error envelopes, or empty bodies. Treat missing/invalid
+  // content as an empty turn so jcode/Pi/Codex don't crash on the response.
+  const safeContent = Array.isArray(content) ? content : [];
+  if (safeContent.length === 0) {
+    logger.warn({
+      hasContent: content !== undefined,
+      contentType: typeof content,
+      stop_reason,
+      responseKeys: Object.keys(anthropicResponse),
+      hasError: !!anthropicResponse.error,
+      errorMessage: anthropicResponse.error?.message,
+    }, "convertAnthropicToOpenAI: empty/missing content, returning empty assistant message");
   }
 
   // Convert content blocks to OpenAI format
   let messageContent = "";
+  let reasoningContent = "";
   const toolCalls = [];
   let citations = [];
 
-  for (const block of content) {
+  for (const block of safeContent) {
     if (block.type === "text") {
       messageContent += block.text;
       if (Array.isArray(block.citations)) {
         citations.push(...block.citations);
       }
     } else if (block.type === "thinking") {
-      // Skip thinking blocks in OpenAI format (they don't have an equivalent)
+      // Preserve reasoning text so reasoning-only models (Minimax, DeepSeek-R1)
+      // surface visible output to OpenAI clients that don't render thinking blocks
+      reasoningContent += (block.thinking || "");
     } else if (block.type === "tool_use") {
       toolCalls.push({
         id: block.id,
@@ -233,6 +246,12 @@ function convertAnthropicToOpenAI(anthropicResponse, model = "claude-3-5-sonnet-
     }
   }
 
+  // Fallback: if the model returned only reasoning (no visible text and no tools),
+  // promote reasoning into the visible content so jcode/Pi/Codex see something
+  if (!messageContent && !toolCalls.length && reasoningContent) {
+    messageContent = reasoningContent;
+  }
+
   // Build OpenAI response
   // Ensure ID has the chatcmpl- prefix that OpenAI clients expect
   const responseId = id && id.startsWith("chatcmpl-") ? id : `chatcmpl-${Date.now()}`;
@@ -263,6 +282,13 @@ function convertAnthropicToOpenAI(anthropicResponse, model = "claude-3-5-sonnet-
     openaiResponse.citations = citations;
   }
 
+  // Add reasoning_content as a side-channel field so clients that render
+  // thinking (e.g. some jcode / OpenRouter setups) can show it without losing
+  // it from the visible content fallback above
+  if (reasoningContent && reasoningContent !== messageContent) {
+    openaiResponse.choices[0].message.reasoning_content = reasoningContent;
+  }
+
   // Add tool_calls if present
   if (toolCalls.length > 0) {
     openaiResponse.choices[0].message.tool_calls = toolCalls;

package/src/config/index.js

@@ -920,6 +920,13 @@ var config = {
     weightedScoring: true,
     costOptimization: true,
     agenticDetection: true,
+    // Embed an interaction block in the response body so the user can
+    // see *why* a particular tier/provider was chosen.
+    visibleInteraction: process.env.LYNKR_VISIBLE_ROUTING === 'true',
+    // Run user-supplied preflight commands before invoking the model.
+    // If all exit 0, short-circuit the request with zero LLM cost.
+    preflightEnabled: process.env.LYNKR_PREFLIGHT_ENABLED === 'true',
+    preflightTimeoutMs: Number(process.env.LYNKR_PREFLIGHT_TIMEOUT_MS) || 120000,
   },
 
   // Model Tier Configuration (REQUIRED)