lynkr 9.1.6 → 9.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lynkr",
-  "version": "9.1.6",
+  "version": "9.1.7",
   "description": "Self-hosted Claude Code & Cursor proxy with Databricks,AWS BedRock,Azure  adapters, openrouter, Ollama,llamacpp,LM Studio, workspace tooling, and MCP integration.",
   "main": "index.js",
   "bin": {

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

@@ -44,18 +44,11 @@ class LoadShedder {
     const memUsage = process.memoryUsage();
     const heapUsedPercent = memUsage.heapUsed / memUsage.heapTotal;
 
-    // FIX: Only trigger if BOTH percentage is high AND actual usage is significant
-    // This prevents false positives on startup when heapTotal is small but will grow
-    const heapUsedMB = memUsage.heapUsed / (1024 * 1024);
-    const minHeapThresholdMB = 500; // Only shed load if using more than 500MB
-
-    if (heapUsedPercent > this.heapThreshold && heapUsedMB > minHeapThresholdMB) {
+    if (heapUsedPercent > this.heapThreshold) {
       logger.warn(
         {
           heapUsedPercent: (heapUsedPercent * 100).toFixed(2),
-          heapUsedMB: heapUsedMB.toFixed(2),
           threshold: (this.heapThreshold * 100).toFixed(2),
-          minThresholdMB: minHeapThresholdMB,
         },
         "Load shedding: Heap usage exceeded threshold"
       );
@@ -103,9 +96,6 @@ class LoadShedder {
       activeRequests: this.activeRequests,
       totalShed: this.totalShed,
       heapUsedPercent: ((memUsage.heapUsed / memUsage.heapTotal) * 100).toFixed(2),
-      heapUsedMB: (memUsage.heapUsed / (1024 * 1024)).toFixed(2),
-      heapTotalMB: (memUsage.heapTotal / (1024 * 1024)).toFixed(2),
-      rssMB: (memUsage.rss / (1024 * 1024)).toFixed(2),
       rssPercent: ((memUsage.rss / os.totalmem()) * 100).toFixed(2),
       thresholds: {
         heapThreshold: (this.heapThreshold * 100).toFixed(2),

package/src/api/router.js

@@ -3,7 +3,6 @@ const { processMessage } = require("../orchestrator");
 const { getSession } = require("../sessions");
 const metrics = require("../metrics");
 const logger = require("../logger");
-const config = require("../config");
 const { createRateLimiter } = require("./middleware/rate-limiter");
 const openaiRouter = require("./openai-router");
 const providersRouter = require("./providers-handler");
@@ -29,15 +28,6 @@ function estimateTokenCount(messages = [], system = null, model = null) {
   return countMessagesTokens(messages, system, model);
 }
 
-// Root health check (for HEAD / and GET /)
-router.head("/", (req, res) => {
-  res.status(200).end();
-});
-
-router.get("/", (req, res) => {
-  res.json({ status: "ok", service: "lynkr" });
-});
-
 router.get("/health", (req, res) => {
   res.json({ status: "ok" });
 });

package/src/clients/databricks.js

@@ -107,17 +107,8 @@ async function performJsonRequest(url, { headers = {}, body }, providerLabel) {
     let json;
     try {
       json = JSON.parse(text);
-    } catch (parseError) {
+    } catch {
       json = null;
-      // Log non-JSON responses for debugging
-      if (response.ok) {
-        logger.warn({
-          provider: providerLabel,
-          status: response.status,
-          contentType: response.headers.get("content-type"),
-          textPreview: text.substring(0, 200),
-        }, `${providerLabel} returned non-JSON response (status ${response.status})`);
-      }
     }
 
     const result = {
@@ -265,7 +256,7 @@ async function invokeOllama(body) {
     toolCount,
     toolsInjected,
     supportsTools,
-    toolNames: (Array.isArray(toolsToSend) && toolsToSend.length > 0) ? toolsToSend.map(t => t.name || t.function?.name || 'unnamed') : []
+    toolNames: (Array.isArray(toolsToSend) && toolsToSend.length > 0) ? toolsToSend.map(t => t.name) : []
   }, `=== Ollama STANDARD TOOLS INJECTION for ${config.ollama.model} === ${logMessage}`);
 
   // ---- Anthropic-native path (Ollama v0.14.0+) ----

package/src/config/index.js

@@ -76,8 +76,8 @@ if (!SUPPORTED_MODEL_PROVIDERS.has(rawModelProvider)) {
 
 const modelProvider = rawModelProvider;
 
-let rawBaseUrl = trimTrailingSlash(process.env.DATABRICKS_API_BASE);
-let apiKey = process.env.DATABRICKS_API_KEY;
+const rawBaseUrl = trimTrailingSlash(process.env.DATABRICKS_API_BASE);
+const apiKey = process.env.DATABRICKS_API_KEY;
 
 const azureAnthropicEndpoint = process.env.AZURE_ANTHROPIC_ENDPOINT ?? null;
 const azureAnthropicApiKey = process.env.AZURE_ANTHROPIC_API_KEY ?? null;
@@ -255,8 +255,33 @@ const headroomLlmlinguaDevice = process.env.HEADROOM_LLMLINGUA_DEVICE ?? "auto";
 const headroomProvider = process.env.HEADROOM_PROVIDER ?? "anthropic";
 const headroomLogLevel = process.env.HEADROOM_LOG_LEVEL ?? "info";
 
-// Credential validation is deferred until after tier routing mode detection
-// (see line ~430 for the actual validation logic)
+// Only require Databricks credentials if it's the primary provider or used as fallback
+if (modelProvider === "databricks" && (!rawBaseUrl || !apiKey)) {
+  throw new Error("Set DATABRICKS_API_BASE and DATABRICKS_API_KEY before starting the proxy.");
+} else if (modelProvider === "ollama" && !fallbackEnabled && (!rawBaseUrl || !apiKey)) {
+  // Relaxed: Allow mock credentials for true Ollama-only mode (fallback disabled)
+  if (!rawBaseUrl) process.env.DATABRICKS_API_BASE = "http://localhost:8080";
+  if (!apiKey) process.env.DATABRICKS_API_KEY = "mock-key-for-ollama-only";
+  console.log("[CONFIG] Using mock Databricks credentials (Ollama-only mode with fallback disabled)");
+}
+
+if (modelProvider === "azure-anthropic" && (!azureAnthropicEndpoint || !azureAnthropicApiKey)) {
+  throw new Error(
+    "Set AZURE_ANTHROPIC_ENDPOINT and AZURE_ANTHROPIC_API_KEY before starting the proxy.",
+  );
+}
+
+if (modelProvider === "azure-openai" && (!azureOpenAIEndpoint || !azureOpenAIApiKey)) {
+  throw new Error(
+    "Set AZURE_OPENAI_ENDPOINT and AZURE_OPENAI_API_KEY before starting the proxy.",
+  );
+}
+
+if (modelProvider === "openai" && !openAIApiKey) {
+  throw new Error(
+    "Set OPENAI_API_KEY before starting the proxy.",
+  );
+}
 
 if (modelProvider === "ollama") {
   try {
@@ -295,266 +320,34 @@ if (process.env.PREFER_OLLAMA) {
   console.warn('[DEPRECATION] PREFER_OLLAMA is removed. Use TIER_* env vars for routing. See documentation/routing.md');
 }
 
-// ═══════════════════════════════════════════════════════════════════════════
-// TIER ROUTING MODE DETECTION
-// ═══════════════════════════════════════════════════════════════════════════
-// When all 4 TIER_* variables are set, Lynkr operates in "Tier Routing Mode"
-// In this mode:
-//   - MODEL_PROVIDER is auto-detected from TIER_SIMPLE
-//   - FALLBACK_PROVIDER is auto-detected from TIER_REASONING
-//   - FALLBACK_ENABLED is always true
-//   - Only credentials for providers used in tiers are validated
-// ═══════════════════════════════════════════════════════════════════════════
-
+// Warn about misconfigured fallback provider (only when tier routing is active,
+// since that's the only path that triggers provider fallback)
 const tiersConfigured = !!(
   process.env.TIER_SIMPLE?.trim() &&
   process.env.TIER_MEDIUM?.trim() &&
   process.env.TIER_COMPLEX?.trim() &&
   process.env.TIER_REASONING?.trim()
 );
-
-let tierRoutingMode = tiersConfigured;
-let autoDetectedProvider = null;
-let autoDetectedFallback = null;
-
-if (tierRoutingMode) {
-  console.log('[Config] ✓ Tier routing mode active (all 4 TIER_* variables set)');
-
-  // Phase 3: Error if legacy variables are set
-  if (process.env.MODEL_PROVIDER) {
-    throw new Error(
-      'MODEL_PROVIDER not allowed in tier routing mode.\n' +
-      'Remove MODEL_PROVIDER from your .env file.\n' +
-      'Provider is auto-detected from TIER_SIMPLE.\n' +
-      'See: documentation/routing.md'
-    );
-  }
-
-  if (process.env.FALLBACK_PROVIDER) {
-    throw new Error(
-      'FALLBACK_PROVIDER not allowed in tier routing mode.\n' +
-      'Remove FALLBACK_PROVIDER from your .env file.\n' +
-      'Fallback is auto-detected from TIER_REASONING.\n' +
-      'See: documentation/routing.md'
-    );
-  }
-
-  if (process.env.FALLBACK_ENABLED !== undefined) {
-    throw new Error(
-      'FALLBACK_ENABLED not allowed in tier routing mode.\n' +
-      'Remove FALLBACK_ENABLED from your .env file.\n' +
-      'Fallback is automatic when TIER_REASONING uses a cloud provider.\n' +
-      'See: documentation/routing.md'
-    );
-  }
-
-  // Auto-detect primary provider from TIER_SIMPLE
-  const tierSimple = process.env.TIER_SIMPLE.trim();
-  const tierReasoning = process.env.TIER_REASONING.trim();
-
-  const simpleMatch = tierSimple.match(/^([a-z-]+):(.+)$/);
-  const reasoningMatch = tierReasoning.match(/^([a-z-]+):(.+)$/);
-
-  if (!simpleMatch) {
-    throw new Error(`TIER_SIMPLE must be in format "provider:model" (got: "${tierSimple}")`);
-  }
-  if (!reasoningMatch) {
-    throw new Error(`TIER_REASONING must be in format "provider:model" (got: "${tierReasoning}")`);
-  }
-
-  autoDetectedProvider = simpleMatch[1];
-  autoDetectedFallback = reasoningMatch[1];
-
-  console.log(`[Config] Auto-detected MODEL_PROVIDER="${autoDetectedProvider}" from TIER_SIMPLE`);
-  console.log(`[Config] Auto-detected FALLBACK_PROVIDER="${autoDetectedFallback}" from TIER_REASONING`);
-
-  // Validate auto-detected providers
-  if (!SUPPORTED_MODEL_PROVIDERS.has(autoDetectedProvider)) {
-    throw new Error(
-      `Invalid provider in TIER_SIMPLE: "${autoDetectedProvider}"\n` +
-      `Valid providers: ${Array.from(SUPPORTED_MODEL_PROVIDERS).sort().join(', ')}`
-    );
-  }
-  if (!SUPPORTED_MODEL_PROVIDERS.has(autoDetectedFallback)) {
-    throw new Error(
-      `Invalid provider in TIER_REASONING: "${autoDetectedFallback}"\n` +
-      `Valid providers: ${Array.from(SUPPORTED_MODEL_PROVIDERS).sort().join(', ')}`
-    );
-  }
-
-  // Override MODEL_PROVIDER and FALLBACK_PROVIDER internally
-  process.env.MODEL_PROVIDER = autoDetectedProvider;
-  process.env.FALLBACK_PROVIDER = autoDetectedFallback;
-  process.env.FALLBACK_ENABLED = 'true';
-}
-
-// Re-read modelProvider and fallbackProvider after tier routing auto-detection
-// This ensures the config object uses the auto-detected values
-const finalModelProvider = (process.env.MODEL_PROVIDER ?? "databricks").toLowerCase();
-const finalFallbackProvider = (process.env.FALLBACK_PROVIDER ?? "databricks").toLowerCase();
-const finalFallbackEnabled = process.env.FALLBACK_ENABLED === "true";
-
-// Safety check: prevent self-loop when tier routing is active and provider is not databricks
-// If using tier routing with ollama/llamacpp/lmstudio, clear databricks URL to prevent agents from calling back to self
-if (tierRoutingMode && finalModelProvider !== "databricks" && rawBaseUrl) {
-  const isLocalhost = rawBaseUrl.includes('localhost') || rawBaseUrl.includes('127.0.0.1');
-  const matchesServerPort = rawBaseUrl.includes(`:${port}`);
-  if (isLocalhost && matchesServerPort) {
-    console.warn(`[WARN] DATABRICKS_API_BASE points to this server (${rawBaseUrl}). Clearing to prevent self-loop.`);
-    rawBaseUrl = null;
-    apiKey = null;
-  }
-}
-
-// Warn about misconfigured fallback provider (only when tier routing is active,
-// since that's the only path that triggers provider fallback)
-if (finalFallbackEnabled && tiersConfigured) {
+if (fallbackEnabled && tiersConfigured) {
   const localProviders = ["ollama", "llamacpp", "lmstudio"];
-  // Only warn (not error) if fallback is local - it just means fallback won't work
-  if (localProviders.includes(finalFallbackProvider) && finalFallbackProvider !== finalModelProvider) {
-    console.warn(`[WARN] FALLBACK_PROVIDER='${finalFallbackProvider}' is a local provider. Fallback should use a cloud provider for redundancy.`);
+  if (localProviders.includes(fallbackProvider)) {
+    throw new Error(`FALLBACK_PROVIDER cannot be '${fallbackProvider}' (local providers should not be fallbacks). Use cloud providers: databricks, azure-anthropic, azure-openai, openrouter, openai, bedrock`);
   }
   let fallbackMisconfigured = false;
-  if (finalFallbackProvider === "databricks" && (!rawBaseUrl || !apiKey)) {
+  if (fallbackProvider === "databricks" && (!rawBaseUrl || !apiKey)) {
     fallbackMisconfigured = true;
   }
-  if (finalFallbackProvider === "azure-anthropic" && (!azureAnthropicEndpoint || !azureAnthropicApiKey)) {
+  if (fallbackProvider === "azure-anthropic" && (!azureAnthropicEndpoint || !azureAnthropicApiKey)) {
     fallbackMisconfigured = true;
   }
-  if (finalFallbackProvider === "azure-openai" && (!azureOpenAIEndpoint || !azureOpenAIApiKey)) {
+  if (fallbackProvider === "azure-openai" && (!azureOpenAIEndpoint || !azureOpenAIApiKey)) {
     fallbackMisconfigured = true;
   }
-  if (finalFallbackProvider === "bedrock" && !bedrockApiKey) {
+  if (fallbackProvider === "bedrock" && !bedrockApiKey) {
     fallbackMisconfigured = true;
   }
   if (fallbackMisconfigured) {
-    console.warn(`[WARN] FALLBACK_PROVIDER='${finalFallbackProvider}' is enabled but missing credentials. Fallback will not work until configured.`);
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// SMART CREDENTIAL VALIDATION (TIER ROUTING MODE)
-// ═══════════════════════════════════════════════════════════════════════════
-// Only validate credentials for providers actually used in tier config
-// ═══════════════════════════════════════════════════════════════════════════
-
-if (tierRoutingMode) {
-  // Extract all unique providers from tier config
-  const usedProviders = new Set();
-  [
-    process.env.TIER_SIMPLE,
-    process.env.TIER_MEDIUM,
-    process.env.TIER_COMPLEX,
-    process.env.TIER_REASONING
-  ].forEach(tierValue => {
-    const match = tierValue?.match(/^([a-z-]+):/);
-    if (match) usedProviders.add(match[1]);
-  });
-
-  console.log(`[Config] Tier routing uses providers: ${Array.from(usedProviders).join(', ')}`);
-
-  // Validate only providers used in tiers
-  if (usedProviders.has('databricks')) {
-    if (!rawBaseUrl || !apiKey) {
-      throw new Error(
-        'DATABRICKS_API_BASE and DATABRICKS_API_KEY required.\n' +
-        'Databricks is used in your tier routing config.'
-      );
-    }
-  } else {
-    // Mock credentials if Databricks not used
-    if (!rawBaseUrl) {
-      process.env.DATABRICKS_API_BASE = "http://localhost:8080";
-      rawBaseUrl = "http://localhost:8080";
-    }
-    if (!apiKey) {
-      process.env.DATABRICKS_API_KEY = "mock-key-unused";
-      apiKey = "mock-key-unused";
-    }
-  }
-
-  if (usedProviders.has('azure-anthropic') && (!azureAnthropicEndpoint || !azureAnthropicApiKey)) {
-    throw new Error(
-      'AZURE_ANTHROPIC_ENDPOINT and AZURE_ANTHROPIC_API_KEY required.\n' +
-      'Azure Anthropic is used in your tier routing config.'
-    );
-  }
-
-  if (usedProviders.has('azure-openai') && (!azureOpenAIEndpoint || !azureOpenAIApiKey)) {
-    throw new Error(
-      'AZURE_OPENAI_ENDPOINT and AZURE_OPENAI_API_KEY required.\n' +
-      'Azure OpenAI is used in your tier routing config.'
-    );
-  }
-
-  if (usedProviders.has('openai') && !openAIApiKey) {
-    throw new Error(
-      'OPENAI_API_KEY required.\n' +
-      'OpenAI is used in your tier routing config.'
-    );
-  }
-
-  if (usedProviders.has('openrouter') && !openRouterApiKey) {
-    throw new Error(
-      'OPENROUTER_API_KEY required.\n' +
-      'OpenRouter is used in your tier routing config.'
-    );
-  }
-
-  if (usedProviders.has('bedrock') && !bedrockApiKey) {
-    throw new Error(
-      'AWS_BEDROCK_API_KEY required.\n' +
-      'Bedrock is used in your tier routing config.'
-    );
-  }
-
-  // Ollama endpoint validation
-  if (usedProviders.has('ollama')) {
-    try {
-      new URL(ollamaEndpoint);
-    } catch (err) {
-      throw new Error(`Invalid OLLAMA_ENDPOINT: "${ollamaEndpoint}". Must be a valid URL.`);
-    }
-  }
-
-} else {
-  // ═══════════════════════════════════════════════════════════════════════════
-  // STATIC PROVIDER MODE - Original validation logic
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  if (modelProvider === "databricks" && (!rawBaseUrl || !apiKey)) {
-    throw new Error("Set DATABRICKS_API_BASE and DATABRICKS_API_KEY before starting the proxy.");
-  } else if (modelProvider === "ollama" && !fallbackEnabled && (!rawBaseUrl || !apiKey)) {
-    // Relaxed: Allow mock credentials for true Ollama-only mode (fallback disabled)
-    if (!rawBaseUrl) {
-      process.env.DATABRICKS_API_BASE = "http://localhost:8080";
-      rawBaseUrl = "http://localhost:8080";
-    }
-    if (!apiKey) {
-      process.env.DATABRICKS_API_KEY = "mock-key-for-ollama-only";
-      apiKey = "mock-key-for-ollama-only";
-    }
-    console.log("[CONFIG] Using mock Databricks credentials (Ollama-only mode with fallback disabled)");
-  }
-
-  if (modelProvider === "azure-anthropic" && (!azureAnthropicEndpoint || !azureAnthropicApiKey)) {
-    throw new Error("SET AZURE_ANTHROPIC_ENDPOINT and AZURE_ANTHROPIC_API_KEY before starting the proxy.");
-  }
-
-  if (modelProvider === "azure-openai" && (!azureOpenAIEndpoint || !azureOpenAIApiKey)) {
-    throw new Error("Set AZURE_OPENAI_ENDPOINT and AZURE_OPENAI_API_KEY before starting the proxy.");
-  }
-
-  if (modelProvider === "openai" && !openAIApiKey) {
-    throw new Error("Set OPENAI_API_KEY before starting the proxy.");
-  }
-
-  if (modelProvider === "ollama") {
-    try {
-      new URL(ollamaEndpoint);
-    } catch (err) {
-      throw new Error(`Invalid OLLAMA_ENDPOINT: "${ollamaEndpoint}". Must be a valid URL.`);
-    }
+    console.warn(`[WARN] FALLBACK_PROVIDER='${fallbackProvider}' is enabled but missing credentials. Fallback will not work until configured.`);
   }
 }
 
@@ -754,7 +547,7 @@ const workerTaskTimeoutMs = Number.parseInt(process.env.WORKER_TASK_TIMEOUT_MS ?
 const workerOffloadThresholdBytes = Number.parseInt(process.env.WORKER_OFFLOAD_THRESHOLD_BYTES ?? "10000", 10);
 
 var config = {
-  env: process.env.NODE_ENV ?? "production",
+  env: process.env.NODE_ENV ?? "development",
   port: Number.isNaN(port) ? 8080 : port,
   databricks: {
     baseUrl: rawBaseUrl,
@@ -836,13 +629,13 @@ var config = {
     debounceMs: Number.isNaN(hotReloadDebounceMs) ? 1000 : hotReloadDebounceMs,
   },  
   modelProvider: {
-    type: finalModelProvider,
+    type: modelProvider,
     defaultModel,
     suggestionModeModel,
-    fallbackEnabled: finalFallbackEnabled,
+    fallbackEnabled,
     ollamaMaxToolsForRouting,
     openRouterMaxToolsForRouting,
-    fallbackProvider: finalFallbackProvider,
+    fallbackProvider,
   },
   toolExecutionMode,
   toolResultCompression: {
@@ -1125,7 +918,6 @@ var config = {
   // Intelligent Routing
   routing: {
     weightedScoring: true,
-    // Cost optimization now respects tier routing mode (only uses TIER_* configured models)
     costOptimization: true,
     agenticDetection: true,
     // Embed an interaction block in the response body so the user can

package/src/context/toon.js

@@ -15,12 +15,11 @@ function normaliseSettings(settings = {}) {
   };
 }
 
-async function resolveEncodeFn(overrideEncode) {
+function resolveEncodeFn(overrideEncode) {
   if (typeof overrideEncode === "function") return overrideEncode;
   if (cachedEncode !== undefined) return cachedEncode;
   try {
-    // Use dynamic import for ES module compatibility
-    const toon = await import("@toon-format/toon");
+    const toon = require("@toon-format/toon");
     cachedEncode = typeof toon?.encode === "function" ? toon.encode : null;
     cachedLoadError = cachedEncode ? null : new Error("Missing encode() export from @toon-format/toon");
   } catch (err) {
@@ -90,7 +89,7 @@ function compressStringContent(content, cfg, encodeFn, stats) {
   return toonText;
 }
 
-async function applyToonCompression(payload, settings = {}, options = {}) {
+function applyToonCompression(payload, settings = {}, options = {}) {
   const cfg = normaliseSettings(settings);
   const stats = {
     enabled: cfg.enabled,
@@ -110,7 +109,7 @@ async function applyToonCompression(payload, settings = {}, options = {}) {
     return { payload, stats };
   }
 
-  const encodeFn = await resolveEncodeFn(options.encode);
+  const encodeFn = resolveEncodeFn(options.encode);
   if (typeof encodeFn !== "function") {
     stats.available = false;
     const err = cachedLoadError ?? new Error("TOON encoder unavailable");

package/src/orchestrator/index.js

@@ -1101,7 +1101,7 @@ function toAnthropicResponse(openai, requestedModel, wantsThinking) {
   };
 }
 
-async function sanitizePayload(payload) {
+function sanitizePayload(payload) {
   const { clonePayloadSmart } = require("../utils/payload");
   const providerType = config.modelProvider?.type ?? "databricks";
   const willFlatten = providerType !== "azure-anthropic";
@@ -1418,7 +1418,7 @@ async function sanitizePayload(payload) {
 
   // Optional TOON conversion for large JSON message payloads (prompt context only).
   // Run this BEFORE message coalescing to preserve parseable JSON boundaries.
-  await applyToonCompression(clean, config.toon, { logger });
+  applyToonCompression(clean, config.toon, { logger });
 
   // FIX: Handle consecutive messages with the same role (causes llama.cpp 400 error)
   // Strategy: Merge consecutive same-role messages, but NEVER merge messages
@@ -1529,35 +1529,12 @@ function getToolCallSignature(toolCall) {
 }
 
 function buildNonJsonResponse(databricksResponse) {
-  // Convert plain text response to Anthropic message format
-  // so SSE handler can properly render it
-  const textContent = databricksResponse.text || "";
-
   return {
     status: databricksResponse.status,
     headers: {
-      "Content-Type": "application/json", // Changed from text/plain
-    },
-    body: {
-      id: `msg_${Date.now()}`,
-      type: "message",
-      role: "assistant",
-      model: "unknown",
-      content: [
-        {
-          type: "text",
-          text: textContent
-        }
-      ],
-      stop_reason: "end_turn",
-      stop_sequence: null,
-      usage: {
-        input_tokens: 0,
-        output_tokens: 0,
-        cache_creation_input_tokens: 0,
-        cache_read_input_tokens: 0,
-      }
+      "Content-Type": databricksResponse.contentType ?? "text/plain",
     },
+    body: databricksResponse.text,
     terminationReason: "non_json_response",
   };
 }
@@ -3929,7 +3906,7 @@ async function processMessage({ payload, headers, session, cwd, options = {} })
   const { createTimer } = require("../utils/perf-timer");
   const pTimer = createTimer("processMessage");
 
-  const cleanPayload = await sanitizePayload(payload);
+  const cleanPayload = sanitizePayload(payload);
   pTimer.mark("sanitizePayload");
 
   // Proactively load tools based on prompt content (lazy loading)
@@ -4067,11 +4044,7 @@ async function processMessage({ payload, headers, session, cwd, options = {} })
   if (semanticCache.isEnabled() && semanticLookupResult && !semanticLookupResult.hit) {
     if (loopResult.response?.status === 200 && loopResult.response?.body) {
       try {
-        // Only cache valid JSON responses, not HTML error pages
-        const body = loopResult.response.body;
-        if (typeof body === 'object' || (typeof body === 'string' && body.trim().startsWith('{'))) {
-          await semanticCache.store(semanticLookupResult, body);
-        }
+        await semanticCache.store(semanticLookupResult, loopResult.response.body);
       } catch (err) {
         logger.debug({ error: err.message }, "Semantic cache store failed");
       }

package/src/prompts/system.js

@@ -70,41 +70,13 @@ function compressToolDescriptions(tools, mode = null) {
     return tools; // Return unmodified if not in minimal mode
   }
 
-  const validTools = tools.filter(tool => {
-    // Handle both Anthropic format (name + input_schema) and OpenAI format (function.name)
-    const hasAnthropicFormat = tool && tool.name && tool.input_schema;
-    const hasOpenAIFormat = tool && tool.function && tool.function.name;
-    const isValid = hasAnthropicFormat || hasOpenAIFormat;
-
-    if (!isValid) {
-      logger.debug({
-        hasName: !!tool?.name,
-        hasSchema: !!tool?.input_schema,
-        hasFunctionName: !!tool?.function?.name,
-        toolType: typeof tool
-      }, 'Filtered out malformed tool');
-    }
-    return isValid;
-  });
-
-  if (validTools.length === 0 && tools.length > 0) {
-    logger.warn({ originalCount: tools.length }, 'All tools filtered out as malformed - returning original');
-    return tools;
-  }
-
-  return validTools.map(tool => {
-    // If already in OpenAI format, return as-is (no compression for OpenAI format)
-    if (tool.function && !tool.input_schema) {
-      return tool;
-    }
-
-    // Compress Anthropic format
+  return tools.map(tool => {
     const compressed = {
       name: tool.name,
       input_schema: {
-        type: tool.input_schema?.type || "object",
+        type: tool.input_schema.type,
         properties: {},
-        required: tool.input_schema?.required || [],
+        required: tool.input_schema.required || [],
       }
     };
 
@@ -218,7 +190,7 @@ function optimizeSystemPrompt(system, context = {}, mode = null) {
 
   // 2. Remove file operation guidelines if no file tools
   const hasFileTools = context.tools?.some(t =>
-    t?.name && ['Read', 'Write', 'Edit', 'Glob', 'Grep'].includes(t.name)
+    ['Read', 'Write', 'Edit', 'Glob', 'Grep'].includes(t.name)
   );
   if (!hasFileTools) {
     text = removeSection(text, /# File Operations?[\s\S]*?(?=\n#|\n\n[A-Z]|$)/gi, optimizations, 'file operations');
@@ -226,7 +198,7 @@ function optimizeSystemPrompt(system, context = {}, mode = null) {
 
   // 3. Remove git guidelines if no git tools
   const hasGitTools = context.tools?.some(t =>
-    t?.name && t.name.toLowerCase().includes('git')
+    t.name.toLowerCase().includes('git')
   );
   if (!hasGitTools) {
     text = removeSection(text, /# Git.*?[\s\S]*?(?=\n#|\n\n[A-Z]|$)/gi, optimizations, 'git guidelines');
@@ -235,7 +207,7 @@ function optimizeSystemPrompt(system, context = {}, mode = null) {
 
   // 4. Remove web search guidelines if no web tools
   const hasWebTools = context.tools?.some(t =>
-    t?.name && ['WebSearch', 'WebFetch'].includes(t.name)
+    ['WebSearch', 'WebFetch'].includes(t.name)
   );
   if (!hasWebTools) {
     text = removeSection(text, /# Web.*?[\s\S]*?(?=\n#|\n\n[A-Z]|$)/gi, optimizations, 'web guidelines');

package/src/routing/index.js

@@ -84,28 +84,15 @@ function isLocalProvider(provider) {
 
 /**
  * Check if fallback is enabled
- * In tier routing mode, fallback is always enabled
  */
 function isFallbackEnabled() {
-  if (config.modelTiers?.enabled) {
-    // Tier routing mode: fallback always enabled
-    return true;
-  }
-  // Static provider mode: use FALLBACK_ENABLED
   return config.modelProvider?.fallbackEnabled !== false;
 }
 
 /**
  * Get the configured fallback provider
- * In tier routing mode, fallback = TIER_REASONING provider
  */
 function getFallbackProvider() {
-  if (config.modelTiers?.enabled && config.modelTiers?.REASONING) {
-    // Tier routing mode: extract provider from TIER_REASONING
-    const match = config.modelTiers.REASONING.match(/^([a-z-]+):/);
-    if (match) return match[1];
-  }
-  // Static provider mode: use FALLBACK_PROVIDER
   return config.modelProvider?.fallbackProvider ?? 'databricks';
 }
 

package/src/routing/model-tiers.js

@@ -54,20 +54,6 @@ class ModelTierSelector {
    * Load tier configuration from JSON file
    */
   _loadConfig() {
-    // Check if tier routing mode is active (all 4 TIER_* env vars set)
-    const tierRoutingMode = !!(
-      config.modelTiers?.SIMPLE?.trim() &&
-      config.modelTiers?.MEDIUM?.trim() &&
-      config.modelTiers?.COMPLEX?.trim() &&
-      config.modelTiers?.REASONING?.trim()
-    );
-
-    if (tierRoutingMode) {
-      logger.debug('[ModelTiers] Tier routing mode active, building config from TIER_* env vars');
-      this._buildFromEnvVars();
-      return;
-    }
-
     try {
       if (fs.existsSync(TIER_CONFIG_PATH)) {
         const data = JSON.parse(fs.readFileSync(TIER_CONFIG_PATH, 'utf8'));
@@ -122,49 +108,6 @@ class ModelTierSelector {
   /**
    * Load default tier config
    */
-  /**
-   * Build tier config from TIER_* environment variables
-   * Format: TIER_SIMPLE=provider:model
-   */
-  _buildFromEnvVars() {
-    this.tierConfig = {};
-    this.localProviders = {
-      ollama: { free: true, defaultTier: 'SIMPLE' },
-      llamacpp: { free: true, defaultTier: 'SIMPLE' },
-      lmstudio: { free: true, defaultTier: 'SIMPLE' },
-      mlx: { free: true, defaultTier: 'SIMPLE' },
-    };
-
-    const tiers = ['SIMPLE', 'MEDIUM', 'COMPLEX', 'REASONING'];
-    for (const tier of tiers) {
-      const envValue = config.modelTiers?.[tier]?.trim();
-      if (!envValue) continue;
-
-      // Parse provider:model format
-      const match = envValue.match(/^([a-z-]+):(.+)$/);
-      if (!match) {
-        logger.warn({ tier, value: envValue }, '[ModelTiers] Invalid TIER format, expected provider:model');
-        continue;
-      }
-
-      const [, provider, model] = match;
-
-      // Initialize tier config if not exists
-      if (!this.tierConfig[tier]) {
-        this.tierConfig[tier] = { preferred: {} };
-      }
-
-      // Set this as the ONLY preferred model for this tier+provider
-      this.tierConfig[tier].preferred[provider] = [model];
-
-      logger.debug({
-        tier,
-        provider,
-        model
-      }, '[ModelTiers] Tier configured from env');
-    }
-  }
-
   _loadDefaults() {
     this.tierConfig = {
       SIMPLE: { preferred: { ollama: ['llama3.2'], openai: ['gpt-4o-mini'] } },