solrouter 0.4.1 → 0.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solrouter",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Local privacy router for coding tools: pseudonymises every request before it leaves your machine, and sends work a frontier model would refuse to an uncensored open-weight model you control.",
   "type": "module",
   "bin": {

package/src/auth.js

@@ -27,7 +27,7 @@ function openBrowser(url) {
 
 /** Loopback browser login. Resolves once the callback delivers a token.
  *  `open` is injectable for testing (defaults to launching the real browser). */
-export function browserLogin({ timeoutMs = 180000, open = openBrowser } = {}) {
+export function browserLogin({ timeoutMs = 180000, open = openBrowser, save = saveAuth } = {}) {
   return new Promise((resolve, reject) => {
     const state = randomBytes(16).toString("hex");
     const server = createServer((req, res) => {
@@ -45,7 +45,7 @@ export function browserLogin({ timeoutMs = 180000, open = openBrowser } = {}) {
       res.end("<h2>SolRouter proxy connected.</h2><p>You can close this tab and return to the terminal.</p>");
       server.close();
       if (!token.access_token) return reject(new Error("no token in callback"));
-      saveAuth(token);
+      save(token);
       resolve(token);
     });
     server.listen(0, "127.0.0.1", () => {

package/src/index.js

@@ -120,11 +120,11 @@ export async function handleStream(body, ctx = {}, cfg) {
     kind, mode, maskedPrompt: extractText(masked, kind) };
 }
 
-/** Call the private leg for a (masked) prompt. Returns { reply, ok }. */
+/** Call the private leg for a (masked) prompt. Returns { reply, ok, status }. */
 export async function privateReply(cfg, maskedPrompt) {
   const { callSolrouterAgent } = await import("./providers.js");
   const r = await callSolrouterAgent(cfg.private, maskedPrompt);
-  return { reply: r.reply || "", ok: r.ok };
+  return { reply: r.reply || "", ok: r.ok, status: r.status };
 }
 
 export { createMasker } from "./mask.js";

package/src/route.js

@@ -42,11 +42,35 @@ export function likelyRefused(text) {
   return false;
 }
 
+// Softer decline signals — phrases refusals use even when they don't start with
+// "I can't". Used only for SHORT, complete responses (a long substantive answer
+// that happens to contain one of these is not a refusal).
+const DECLINE_HINTS = [
+  /\bI (?:can(?:'|no)?t|won'?t|cannot|will not)\b/i,
+  /\bI'?m not (?:going to|able to|willing to|comfortable|going)\b/i,
+  /\bI (?:won'?t|don'?t|do not) (?:feel comfortable|think I should|be able)\b/i,
+  /\bI'?d (?:rather not|prefer not)\b/i,
+  /\b(?:not something I (?:can|will)|that'?s not something)\b/i,
+  /\bI'?m (?:sorry|afraid)\b/i,
+  /\b(?:against|violates?)\b.{0,30}\b(?:policy|policies|guidelines)\b/i,
+  /\bhappy to (?:help|pick|assist)\b.{0,40}\binstead\b/i,
+  /\b(?:instead|rather)\b.{0,30}\b(?:I'?m here|happy to|let me)\b/i,
+  /\bI (?:must|have to|need to) (?:decline|refuse|pass)\b/i,
+  /\bnot appropriate\b/i,
+];
+
 /** Did a model response come back as a refusal? Used for the reactive retry. */
 export function isRefusal(text) {
   const s = String(text ?? "").trim();
-  if (!s || s.length > 1500) return false; // real refusals are short
-  for (const re of REFUSAL_SIGNATURES) if (re.test(s)) return true;
+  if (!s) return false;
+  // Strong signatures fire at any length up to ~1500 (refusals are short).
+  if (s.length <= 1500) for (const re of REFUSAL_SIGNATURES) if (re.test(s)) return true;
+  // Short + soft decline hints → also a refusal. Short because a real coding answer
+  // is long / full of code; a brief prose reply that declines is a refusal.
+  if (s.length <= 600) {
+    const hasCode = /```|\bfunction\b|\bconst \b|\bimport \b|=>|\bdef \b|;\n/.test(s);
+    if (!hasCode) for (const re of DECLINE_HINTS) if (re.test(s)) return true;
+  }
   return false;
 }
 

package/src/server.js

@@ -7,11 +7,21 @@
 // localhost only — nothing here should be reachable off the machine.
 
 import { createServer } from "node:http";
+import { appendFileSync } from "node:fs";
+import { join } from "node:path";
 import { handle, handleStream, createMasker, privateReply } from "./index.js";
 import { forward } from "./providers.js";
 import { dialect, rewriteText } from "./wire.js";
 import { isRefusal } from "./route.js";
 import { writeReceipt } from "./receipt.js";
+import { HOME_DIR } from "./config.js";
+
+// Ground-truth log of every streaming routing decision, so a real Claude Code run
+// can be diagnosed from actual traffic instead of guesses. Never contains raw PII
+// beyond the frontier response prefix (already sent to the provider).
+function logDecision(o) {
+  try { appendFileSync(join(HOME_DIR, "debug.log"), JSON.stringify({ ts: new Date().toISOString(), ...o }) + "\n"); } catch {}
+}
 
 /** Pull assistant text out of an Anthropic SSE chunk (text_delta events). */
 function extractSseText(chunk) {
@@ -117,9 +127,14 @@ export function startServer(cfg) {
         }
 
         let leg = s.leg, refused = false, model = s.model;
+        logDecision({ event: "stream-decision", reqModel: body.model, mode: s.mode,
+          committed, refusalLikely, isRefusalFinal: isRefusal(acc), respLen: acc.length,
+          respPrefix: acc.slice(0, 400) });
         if (!committed && s.mode === "auto" && refusalLikely) {
           // Streamed refusal → reroute to the uncensored private leg.
           const pr = await privateReply(cfg, s.maskedPrompt);
+          logDecision({ event: "reroute", privateOk: pr.ok, privateStatus: pr.status,
+            privateModel: cfg.private.model, replyLen: (pr.reply || "").length });
           if (pr.ok && pr.reply) {
             leg = "private"; refused = true; model = cfg.private.model;
             const restored = restorer ? s.masker.unmask(pr.reply) : pr.reply;
@@ -129,7 +144,18 @@ export function startServer(cfg) {
               leg, reason: "reactive-refusal", model, entities: s.masker.entities(), refused: true, sentToProvider: s.sent });
             return;
           }
-          // private leg unavailable → fall through and just relay the refusal
+          // Reroute was needed but the uncensored leg failed — say so LOUDLY instead
+          // of silently relaying Claude's refusal (this is almost always "not logged
+          // in" / an invalid SolRouter key).
+          res.write(synthAnthropicSse(
+            `⚠️ [solrouter] Claude refused this, and the uncensored leg couldn't be reached (${pr.status || "error"}). ` +
+            `Run \`solrouter login --token sk_solrouter_…\` with a valid key from solrouter.com/sdk, then retry.`,
+            cfg.private.model));
+          res.end();
+          if (cfg.receipt?.enabled) writeReceipt(cfg.receipt.path, {
+            leg: "private", reason: "reroute-failed", model: cfg.private.model,
+            entities: s.masker.entities(), refused: true, sentToProvider: s.sent });
+          return;
         }
         if (!committed) emit(held);          // short non-refusal: flush the buffer
         if (restorer) res.write(restorer.flush());