lynkr 9.9.1 → 9.10.0

package/src/orchestrator/sse-transformer.js

@@ -0,0 +1,408 @@
+/**
+ * Phase 2b — cross-format SSE streaming transform.
+ *
+ * When the client speaks Anthropic but the tier-resolved upstream speaks
+ * OpenAI Chat Completions, the buffered path costs a full generation of
+ * latency before the client sees a single token. This module reshapes the
+ * upstream's SSE deltas into Anthropic Messages events in flight.
+ *
+ * The hard part is tool calls: OpenAI streams tool_calls[i].function.arguments
+ * as unparseable JSON slivers spread across chunks. The transformer
+ * accumulates fragments per tool index and emits one clean
+ * content_block_start + content_block_delta(input_json_delta) +
+ * content_block_stop per COMPLETE tool_use, at stream end — matching the
+ * shape Lynkr's buffered synthesis has always sent, so clients see no
+ * difference in event structure.
+ *
+ * Default on; kill switch LYNKR_STREAM_TRANSFORM=false. The buffered path
+ * stays for body.stream === false and for hallucination-recovery re-prompts
+ * (which require a parsed, buffered response).
+ */
+const logger = require("../logger");
+
+// Upstreams whose streaming wire format is OpenAI Chat Completions SSE.
+// ollama is excluded (own format + buffering quirks), moonshot/zai are
+// excluded (their invoke fns convert buffered responses to Anthropic).
+const DEFAULT_OPENAI_SSE_PROVIDERS = [
+  "openai",
+  "azure-openai",
+  "openrouter",
+  "databricks",
+  "lmstudio",
+  "llamacpp",
+];
+
+function _transformProviders() {
+  const env = process.env.LYNKR_STREAM_TRANSFORM_PROVIDERS;
+  return new Set(
+    env ? env.split(",").map((s) => s.trim()).filter(Boolean) : DEFAULT_OPENAI_SSE_PROVIDERS,
+  );
+}
+
+function shouldTransform(clientWantsStream, provider) {
+  // Default ON since 2026-07-21 (E2E-verified against live upstreams);
+  // LYNKR_STREAM_TRANSFORM=false is the kill switch, mirroring
+  // LYNKR_NATIVE_PASSTHROUGH. Kill switches stay on streaming paths because
+  // past the first byte a stream cannot be retried — reverting behavior via
+  // env + restart beats reverting code during an incident.
+  if (process.env.LYNKR_STREAM_TRANSFORM === "false") return false;
+  if (clientWantsStream !== true) return false;
+  return _transformProviders().has(provider);
+}
+
+function _sse(event, data) {
+  return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+}
+
+function _mapFinishReason(reason) {
+  switch (reason) {
+    case "tool_calls":
+    case "function_call":
+      return "tool_use";
+    case "length":
+      return "max_tokens";
+    case "stop":
+    default:
+      return "end_turn";
+  }
+}
+
+/** Normalize a web ReadableStream or Node Readable into an async iterator of Buffers. */
+async function* _iterateStream(stream) {
+  if (typeof stream.getReader === "function") {
+    const reader = stream.getReader();
+    try {
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) return;
+        yield value;
+      }
+    } finally {
+      try { reader.releaseLock(); } catch { /* released */ }
+    }
+  } else {
+    yield* stream;
+  }
+}
+
+/** Split an SSE byte stream into `data:` payload strings. */
+async function* _sseDataLines(stream) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  for await (const chunk of _iterateStream(stream)) {
+    buffer += decoder.decode(chunk, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("data:")) yield trimmed.slice(5).trim();
+    }
+  }
+  const trimmed = buffer.trim();
+  if (trimmed.startsWith("data:")) yield trimmed.slice(5).trim();
+}
+
+/**
+ * Core transform: OpenAI Chat Completions SSE → Anthropic Messages SSE.
+ * Yields Anthropic SSE event strings. `stats` accumulates for the onClose
+ * finalizer: tool names/arg sizes and usage, gathered DURING the stream so
+ * telemetry needs no second pass.
+ */
+async function* _openaiToAnthropicEvents(upstream, opts = {}) {
+  const fallbackModel = opts.model || "unknown";
+  const stats = {
+    toolCalls: [], // { name, argBytes }
+    usage: { input_tokens: null, output_tokens: null },
+    stopReason: null,
+  };
+
+  let started = false;
+  let messageId = null;
+  let model = fallbackModel;
+  let nextIndex = 0;
+  let textIndex = null; // open text block index, null when closed
+  let finishReason = null;
+  const toolAcc = new Map(); // openai tool index -> { id, name, args }
+
+  const startMessage = function* () {
+    if (started) return;
+    started = true;
+    yield _sse("message_start", {
+      type: "message_start",
+      message: {
+        id: messageId || `msg_${Date.now()}`,
+        type: "message",
+        role: "assistant",
+        content: [],
+        model,
+        stop_reason: null,
+        stop_sequence: null,
+        usage: { input_tokens: 0, output_tokens: 1 },
+      },
+    });
+    // LYNKR_VISIBLE_ROUTING badge — a clean first text block, before any
+    // upstream content. Unlike the byte-pipe passthrough, the transformer
+    // owns the indices, so the badge slots in properly.
+    if (opts.badgeText) {
+      const index = nextIndex++;
+      yield _sse("content_block_start", { type: "content_block_start", index, content_block: { type: "text", text: "" } });
+      yield _sse("content_block_delta", { type: "content_block_delta", index, delta: { type: "text_delta", text: opts.badgeText } });
+      yield _sse("content_block_stop", { type: "content_block_stop", index });
+    }
+  };
+
+  const closeTextBlock = function* () {
+    if (textIndex === null) return;
+    yield _sse("content_block_stop", { type: "content_block_stop", index: textIndex });
+    textIndex = null;
+  };
+
+  const flushToolBlocks = function* () {
+    for (const [, tool] of [...toolAcc.entries()].sort((a, b) => a[0] - b[0])) {
+      const index = nextIndex++;
+      const args = tool.args || "{}";
+      yield _sse("content_block_start", {
+        type: "content_block_start",
+        index,
+        content_block: {
+          type: "tool_use",
+          id: tool.id || `toolu_${Date.now()}_${index.toString(36)}`,
+          name: tool.name || "unknown",
+          input: {},
+        },
+      });
+      yield _sse("content_block_delta", {
+        type: "content_block_delta",
+        index,
+        delta: { type: "input_json_delta", partial_json: args },
+      });
+      yield _sse("content_block_stop", { type: "content_block_stop", index });
+      stats.toolCalls.push({ name: tool.name || "unknown", argBytes: args.length });
+    }
+    toolAcc.clear();
+  };
+
+  try {
+    for await (const payload of _sseDataLines(upstream)) {
+      if (payload === "[DONE]") break;
+
+      let chunk;
+      try {
+        chunk = JSON.parse(payload);
+      } catch {
+        continue; // partial/garbled chunk — skip, never crash the stream
+      }
+
+      if (chunk.id && !messageId) messageId = chunk.id;
+      if (chunk.model) model = chunk.model;
+      if (chunk.usage) {
+        if (chunk.usage.prompt_tokens != null) stats.usage.input_tokens = chunk.usage.prompt_tokens;
+        if (chunk.usage.completion_tokens != null) stats.usage.output_tokens = chunk.usage.completion_tokens;
+      }
+
+      const choice = chunk.choices?.[0];
+      if (!choice) continue;
+      if (choice.finish_reason) finishReason = choice.finish_reason;
+      const delta = choice.delta || {};
+
+      yield* startMessage();
+
+      // Text deltas are straightforward: open a block on first text, then
+      // emit a text_delta per chunk.
+      if (typeof delta.content === "string" && delta.content.length > 0) {
+        if (textIndex === null) {
+          textIndex = nextIndex++;
+          yield _sse("content_block_start", {
+            type: "content_block_start",
+            index: textIndex,
+            content_block: { type: "text", text: "" },
+          });
+        }
+        yield _sse("content_block_delta", {
+          type: "content_block_delta",
+          index: textIndex,
+          delta: { type: "text_delta", text: delta.content },
+        });
+      }
+
+      // Tool-call fragments: accumulate per OpenAI tool index. Fragments of
+      // function.arguments are NOT parseable individually — only the full
+      // concatenation is valid JSON, so blocks are emitted at stream end.
+      if (Array.isArray(delta.tool_calls)) {
+        yield* closeTextBlock();
+        for (const tc of delta.tool_calls) {
+          const idx = tc.index ?? 0;
+          if (!toolAcc.has(idx)) toolAcc.set(idx, { id: null, name: null, args: "" });
+          const acc = toolAcc.get(idx);
+          if (tc.id) acc.id = tc.id;
+          if (tc.function?.name) acc.name = (acc.name || "") + tc.function.name;
+          if (typeof tc.function?.arguments === "string") acc.args += tc.function.arguments;
+        }
+      }
+    }
+  } catch (err) {
+    logger.warn({ err: err.message }, "[SSETransform] Upstream stream failed mid-flight");
+    yield* startMessage();
+    yield* closeTextBlock();
+    yield _sse("error", {
+      type: "error",
+      error: { type: "overloaded_error", message: `Lynkr: upstream stream failed — retry (${err.message})` },
+    });
+    stats.stopReason = "stream_error";
+    if (opts.onClose) { try { opts.onClose(stats); } catch { /* non-fatal */ } }
+    return;
+  }
+
+  // Normal end of stream ([DONE] or upstream EOF).
+  yield* startMessage();
+  yield* closeTextBlock();
+  yield* flushToolBlocks();
+
+  const stopReason = _mapFinishReason(finishReason);
+  stats.stopReason = stopReason;
+  yield _sse("message_delta", {
+    type: "message_delta",
+    delta: { stop_reason: stopReason, stop_sequence: null },
+    usage: { output_tokens: stats.usage.output_tokens ?? 0 },
+  });
+  yield _sse("message_stop", { type: "message_stop" });
+
+  if (opts.onClose) { try { opts.onClose(stats); } catch { /* non-fatal */ } }
+}
+
+/**
+ * OpenAI SSE → Anthropic SSE. Returns a web ReadableStream (exposes
+ * getReader(), matching what the router's stream-forwarding path expects).
+ */
+function openaiToAnthropicSSE(upstream, opts = {}) {
+  const generator = _openaiToAnthropicEvents(upstream, opts);
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const { value, done } = await generator.next();
+        if (done) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(encoder.encode(value));
+      } catch (err) {
+        controller.error(err);
+      }
+    },
+    async cancel() {
+      try { await generator.return(); } catch { /* already finished */ }
+    },
+  });
+}
+
+/**
+ * Anthropic SSE → OpenAI SSE. The symmetric direction — unused by Lynkr's
+ * current routes (OpenAI-speaking clients get buffered conversion) but kept
+ * so both directions live and are tested together.
+ */
+async function* _anthropicToOpenaiEvents(upstream, opts = {}) {
+  const model = opts.model || "unknown";
+  let id = `chatcmpl_${Date.now()}`;
+  let usage = null;
+  let stopReason = null;
+  const blockTypes = new Map(); // anthropic block index -> type
+  let toolOrdinal = -1; // openai tool_calls array index
+
+  const chunk = (delta, finish = null) => ({
+    id,
+    object: "chat.completion.chunk",
+    model,
+    choices: [{ index: 0, delta, finish_reason: finish }],
+    ...(usage && finish ? { usage } : {}),
+  });
+
+  for await (const payload of _sseDataLines(upstream)) {
+    let evt;
+    try {
+      evt = JSON.parse(payload);
+    } catch {
+      continue;
+    }
+
+    switch (evt.type) {
+      case "message_start":
+        if (evt.message?.id) id = evt.message.id;
+        if (evt.message?.usage?.input_tokens != null) {
+          usage = { prompt_tokens: evt.message.usage.input_tokens, completion_tokens: 0, total_tokens: evt.message.usage.input_tokens };
+        }
+        yield `data: ${JSON.stringify(chunk({ role: "assistant", content: "" }))}\n\n`;
+        break;
+      case "content_block_start":
+        blockTypes.set(evt.index, evt.content_block?.type);
+        if (evt.content_block?.type === "tool_use") {
+          toolOrdinal += 1;
+          yield `data: ${JSON.stringify(chunk({
+            tool_calls: [{
+              index: toolOrdinal,
+              id: evt.content_block.id,
+              type: "function",
+              function: { name: evt.content_block.name, arguments: "" },
+            }],
+          }))}\n\n`;
+        }
+        break;
+      case "content_block_delta":
+        if (evt.delta?.type === "text_delta") {
+          yield `data: ${JSON.stringify(chunk({ content: evt.delta.text }))}\n\n`;
+        } else if (evt.delta?.type === "input_json_delta") {
+          yield `data: ${JSON.stringify(chunk({
+            tool_calls: [{ index: toolOrdinal, function: { arguments: evt.delta.partial_json } }],
+          }))}\n\n`;
+        }
+        break;
+      case "message_delta":
+        if (evt.delta?.stop_reason) stopReason = evt.delta.stop_reason;
+        if (evt.usage?.output_tokens != null) {
+          usage = usage || { prompt_tokens: 0 };
+          usage.completion_tokens = evt.usage.output_tokens;
+          usage.total_tokens = (usage.prompt_tokens || 0) + evt.usage.output_tokens;
+        }
+        break;
+      case "message_stop": {
+        const finish = stopReason === "tool_use" ? "tool_calls" : stopReason === "max_tokens" ? "length" : "stop";
+        yield `data: ${JSON.stringify(chunk({}, finish))}\n\n`;
+        yield "data: [DONE]\n\n";
+        break;
+      }
+      default:
+        break; // ping, content_block_stop — no OpenAI equivalent needed
+    }
+  }
+}
+
+function anthropicToOpenaiSSE(upstream, opts = {}) {
+  const generator = _anthropicToOpenaiEvents(upstream, opts);
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const { value, done } = await generator.next();
+        if (done) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(encoder.encode(value));
+      } catch (err) {
+        controller.error(err);
+      }
+    },
+    async cancel() {
+      try { await generator.return(); } catch { /* already finished */ }
+    },
+  });
+}
+
+module.exports = {
+  shouldTransform,
+  openaiToAnthropicSSE,
+  anthropicToOpenaiSSE,
+  // Exported for unit tests.
+  _openaiToAnthropicEvents,
+  _anthropicToOpenaiEvents,
+};

package/src/routing/affinity-store.js

@@ -49,6 +49,13 @@ function _db() {
       if (!cols.has("score")) {
         db.exec("ALTER TABLE session_pins ADD COLUMN score REAL");
       }
+      // Additive migration for the side-channel detector's Signal 2 —
+      // once a session has ever carried tool_use/tool_result blocks, this
+      // flag stays 1 for the pin's lifetime. Payloads that arrive later
+      // without tool blocks in a flagged session are side-channel replays.
+      if (!cols.has("has_tool_history")) {
+        db.exec("ALTER TABLE session_pins ADD COLUMN has_tool_history INTEGER DEFAULT 0");
+      }
       schemaEnsured = true;
     } catch (err) {
       degradation.record("feedback", err);
@@ -81,7 +88,7 @@ function load(sessionId, ttlMs) {
     const row = _stmt(
       db,
       "load",
-      "SELECT provider, model, tier, score, message_count, prompt_tokens_est, ts FROM session_pins WHERE session_id = ?"
+      "SELECT provider, model, tier, score, message_count, prompt_tokens_est, has_tool_history, ts FROM session_pins WHERE session_id = ?"
     ).get(sessionId);
     if (!row) return null;
     if (ttlMs && Date.now() - row.ts > ttlMs) {
@@ -98,6 +105,7 @@ function load(sessionId, ttlMs) {
       score: row.score,
       messageCount: row.message_count,
       promptTokensEst: row.prompt_tokens_est,
+      hasToolHistory: !!row.has_tool_history,
       ts: row.ts,
     };
   } catch (err) {
@@ -121,8 +129,12 @@ function save(sessionId, pin) {
     _stmt(
       db,
       "upsert",
-      `INSERT INTO session_pins (session_id, provider, model, tier, score, message_count, prompt_tokens_est, ts)
-       VALUES (@session_id, @provider, @model, @tier, @score, @message_count, @prompt_tokens_est, @ts)
+      // has_tool_history is sticky-true: once the session has ever carried
+      // tool blocks it stays flagged for the pin's lifetime. Use MAX so an
+      // update from a tool-less request (e.g. compaction refresh) can never
+      // clear the flag once set.
+      `INSERT INTO session_pins (session_id, provider, model, tier, score, message_count, prompt_tokens_est, has_tool_history, ts)
+       VALUES (@session_id, @provider, @model, @tier, @score, @message_count, @prompt_tokens_est, @has_tool_history, @ts)
        ON CONFLICT(session_id) DO UPDATE SET
          provider = excluded.provider,
          model = excluded.model,
@@ -130,6 +142,7 @@ function save(sessionId, pin) {
          score = excluded.score,
          message_count = excluded.message_count,
          prompt_tokens_est = excluded.prompt_tokens_est,
+         has_tool_history = MAX(has_tool_history, excluded.has_tool_history),
          ts = excluded.ts`
     ).run({
       session_id: sessionId,
@@ -139,6 +152,7 @@ function save(sessionId, pin) {
       score: typeof pin.score === 'number' ? pin.score : null,
       message_count: pin.messageCount ?? null,
       prompt_tokens_est: pin.promptTokensEst ?? null,
+      has_tool_history: pin.hasToolHistory ? 1 : 0,
       ts: pin.ts ?? Date.now(),
     });
   } catch (err) {

package/src/routing/difficulty-classifier.js

@@ -44,23 +44,54 @@ const CLASSIFIER_MODEL = 'qwen2.5:3b';
 
 const VALID_TIERS = ['SIMPLE', 'MEDIUM', 'COMPLEX', 'REASONING'];
 
-// One-shot classification prompt. Kept in a const so drift is diffable.
+// One-shot classification prompt (v2). Kept in a const so drift is diffable.
 // Difficulty framing (not intent) — matches config B routing goals.
-const CLASSIFY_PROMPT = `You are a classifier for an LLM routing proxy. Classify the difficulty of the user prompt below into exactly one of four tiers. Reply with ONLY valid JSON on a single line, no other text.
+//
+// v2 (2026-07-21): added the follow-up rule, negative examples under
+// REASONING, and casual-question SIMPLE examples after a live incident:
+// qwen2.5:3b read "Who kills him ?" (a Doctor Doom plot question) as
+// REASONING conf 1.0 — v1's REASONING examples were all formal-methods
+// flavored and nothing said surface vocabulary isn't the signal. Baseline
+// on data/difficulty-eval-followups.jsonl: 60% overall, 33% on SIMPLE,
+// 3 SIMPLE→REASONING criticals.
+const CLASSIFY_PROMPT = `You are a classifier for an LLM routing proxy. Classify the difficulty of the CURRENT user prompt into exactly one of four tiers. Reply with ONLY valid JSON on a single line, no other text.
 
 Tiers:
-- SIMPLE: casual acknowledgments, greetings, one-word answers, trivial factual lookups. Any tiny model handles.
-  examples: "hi", "ok thanks", "yes continue", "what time is it"
+- SIMPLE: casual acknowledgments, greetings, one-word answers, trivial factual lookups, and short conversational follow-up questions about people, stories, events, or everyday facts. Any tiny model handles.
+  examples: "hi", "ok thanks", "yes continue", "what time is it", "who is doctor doom?", "who kills him?", "why did he do that?", "and then what happened?", "does bleach kill mold?"
 - MEDIUM: one specific mechanical task or a focused explanation. Mid-size local model suffices.
-  examples: "list the exports from this file", "run the unit tests", "fix the linter warnings", "explain this regex", "add error handling to this block"
+  examples: "list the exports from this file", "run the unit tests", "fix the linter warnings", "explain this regex", "add error handling to this block", "verify the file exists before reading it"
 - COMPLEX: multi-file design, systemic refactor, architecture review, debugging that requires broad code understanding. Needs a strong general model.
   examples: "architecture review of the orchestrator", "refactor the entire ingestion pipeline", "debug this complex race condition across three services"
 - REASONING: formal proof, correctness verification, security audit, novel algorithm design, formal reasoning from first principles. Needs a frontier reasoning model.
   examples: "prove the correctness of this lock-free queue", "security audit the auth middleware", "formally verify this state machine never deadlocks", "derive the optimal eviction policy and prove its competitive ratio"
+  NOT reasoning: casual questions that merely contain words like "prove", "kill", "verify", "audit" — "who kills him?" is SIMPLE, "prove me wrong lol" is SIMPLE, "can you verify the score?" is SIMPLE, "verify the file exists" is MEDIUM.
+
+Rules:
+- Judge the TASK the model must perform, not the vocabulary. Words like kill/prove/verify/audit/security do not make a prompt REASONING unless it demands formal or expert-level analysis.
+- A short follow-up question (pronouns like he/she/it/that referring to the earlier conversation) about a casual topic is SIMPLE. A follow-up that extends a technical task inherits the difficulty of that task.
 
 Reply format (strict): {"tier":"SIMPLE|MEDIUM|COMPLEX|REASONING","confidence":0.0-1.0}
+`;
+
+// Short prompts are where context matters: "Who kills him ?" is
+// unclassifiable in isolation but trivially SIMPLE next to its conversation.
+// Long prompts self-describe, and contextualizing them would only shrink the
+// LRU hit rate and grow latency.
+const CONTEXT_MAX_TEXT_LENGTH = 40;
+const CONTEXT_MAX_CHARS = 300;
+
+function _buildPrompt(text, context) {
+  if (context) {
+    return `${CLASSIFY_PROMPT}
+Conversation so far (context only — classify the CURRENT prompt, inheriting topic difficulty per the rules):
+${context}
 
-User prompt: `;
+CURRENT user prompt: """${text}"""`;
+  }
+  return `${CLASSIFY_PROMPT}
+User prompt: """${text}"""`;
+}
 
 // --- LRU cache --------------------------------------------------------------
 
@@ -95,7 +126,7 @@ function _cacheKey(text) {
 
 // --- Ollama dispatch (only supported provider for the SIMPLE tier today) ----
 
-async function _callOllama(text, opts) {
+async function _callOllama(text, context, opts) {
   const config = require('../config');
 
   // First cut supports ollama-family classifier only. Other providers can
@@ -109,7 +140,7 @@ async function _callOllama(text, opts) {
   const url = `${endpoint.replace(/\/$/, '')}/api/chat`;
   const body = {
     model: CLASSIFIER_MODEL,
-    messages: [{ role: 'user', content: CLASSIFY_PROMPT + '"""' + text + '"""' }],
+    messages: [{ role: 'user', content: _buildPrompt(text, context) }],
     stream: false,
     format: 'json',
     // num_predict generous because thinking models (minimax-m2.5) burn
@@ -171,6 +202,9 @@ function _parseResult(raw) {
  * @param {number} [opts.timeoutMs] — override default 2500ms
  * @param {boolean} [opts.forceMatched] — caller already matched a FORCE_* pattern; skip classifier
  * @param {string} [opts.riskLevel] — 'high' | 'medium' | 'low'; skip when 'high'
+ * @param {string} [opts.context] — condensed prior conversation ("user asked:
+ *   ... → assistant replied about: ..."); used only for short prompts, where
+ *   a bare follow-up is unclassifiable in isolation
  * @returns {Promise<{tier:string,confidence:number,source:'cache'|'model'}|null>}
  *   null when: disabled, skipped, model failure, parse failure, timeout.
  */
@@ -182,11 +216,18 @@ async function classifyDifficulty(text, opts = {}) {
   if (opts.forceMatched) return null;
   if (opts.riskLevel === 'high') return null;
 
-  const key = _cacheKey(trimmed);
+  const context =
+    typeof opts.context === 'string' && opts.context.trim() && trimmed.length <= CONTEXT_MAX_TEXT_LENGTH
+      ? opts.context.trim().slice(0, CONTEXT_MAX_CHARS)
+      : null;
+
+  // Context participates in the cache key: the same follow-up text means
+  // different things in different conversations.
+  const key = _cacheKey(context ? `${trimmed}${context}` : trimmed);
   const cached = _cache.get(key);
   if (cached) return { ...cached, source: 'cache' };
 
-  const raw = await _callOllama(trimmed, opts);
+  const raw = await _callOllama(trimmed, context, opts);
   const parsed = _parseResult(raw);
   if (!parsed) return null;
   _cache.set(key, parsed);
@@ -214,6 +255,7 @@ module.exports = {
   // internals for tests only
   _parseResult,
   _cacheKey,
+  _buildPrompt,
   _clearCacheForTests,
   _getCacheStats,
 };

package/src/routing/index.js

@@ -584,6 +584,8 @@ function checkSessionPin(payload, options = {}) {
         // the new_conversation guard for everyone after it.
         messageCount: Math.max(messageCount, pin.messageCount ?? 0),
         promptTokensEst: pin.promptTokensEst,
+        // We're inside payloadHasToolHistory(payload) — session has committed.
+        hasToolHistory: true,
       });
     }
     return { serve: true, pin, reason: 'tool_history', sessionId };
@@ -599,11 +601,30 @@ function checkSessionPin(payload, options = {}) {
     sessionAffinity.setPin(sessionId, pin, {
       messageCount: Math.max(messageCount, pin.messageCount ?? 0),
       promptTokensEst: guards.promptTokensEst ?? pin.promptTokensEst,
+      // setPin OR-merges with the existing pin's flag, so a plain-text turn
+      // between tool exchanges keeps the sticky-true property.
+      hasToolHistory: _payloadHasAnyToolBlocks(payload),
     });
   }
   return { serve: true, pin, reason: 'guards_passed', sessionId };
 }
 
+/** Whole-payload scan for tool_use/tool_result blocks. Unlike
+ * sessionAffinity.payloadHasToolHistory (last message only), this checks
+ * every message so we correctly flag sessions where the last frame is a
+ * plain text turn but earlier turns carried tools. */
+function _payloadHasAnyToolBlocks(payload) {
+  const msgs = payload?.messages;
+  if (!Array.isArray(msgs)) return false;
+  for (const m of msgs) {
+    if (!Array.isArray(m?.content)) continue;
+    for (const b of m.content) {
+      if (b?.type === 'tool_use' || b?.type === 'tool_result') return true;
+    }
+  }
+  return false;
+}
+
 /**
  * Write-through helper: persist a fresh routing decision as the session's
  * new pin. No-op when sessionId is missing or the decision has no provider.
@@ -642,7 +663,11 @@ function writeSessionPin(sessionId, decision, payload) {
     return;
   }
   const promptTokensEst = _tryCountTokens(payload, decision.model);
-  sessionAffinity.setPin(sessionId, decision, { messageCount, promptTokensEst });
+  sessionAffinity.setPin(sessionId, decision, {
+    messageCount,
+    promptTokensEst,
+    hasToolHistory: _payloadHasAnyToolBlocks(payload),
+  });
 }
 
 async function _determineProviderSmartInner(payload, options = {}) {
@@ -1088,10 +1113,17 @@ async function _determineProviderSmartInner(payload, options = {}) {
 
   // Phase 1.2 — cost-optimizer override.
   // Only kick in when:
-  //  - feature flag enabled (default true, disable with LYNKR_COST_OPTIMIZE=false)
+  //  - feature flag EXPLICITLY enabled with LYNKR_COST_OPTIMIZE=true (default OFF)
   //  - risk level is not high (high-risk keeps the explicitly-configured model)
   //  - the optimizer finds a meaningfully cheaper qualifying model
-  const costOptimizeEnabled = process.env.LYNKR_COST_OPTIMIZE !== 'false'
+  //
+  // Default changed to OFF (2026-07-20): the optimizer silently overrides
+  // explicit TIER_* config with the cheapest model in the tier pool, which
+  // surprised operators who expected their tier settings to be authoritative
+  // (e.g. TIER_REASONING=azure-anthropic:claude-opus-4.7 was being swapped
+  // for openrouter:deepseek/deepseek-reasoner — which was also a typo that
+  // 400'd upstream). Opt-in only.
+  const costOptimizeEnabled = process.env.LYNKR_COST_OPTIMIZE === 'true'
     && config.routing?.costOptimize !== false;
   if (costOptimizeEnabled && risk?.level !== 'high') {
     try {