claudish 14.3.0 → 14.4.1

package/dist/index.js

@@ -575,7 +575,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "14.3.0";
+var VERSION = "14.4.1";
 
 // src/redact.ts
 function isPlaceholder(value) {
@@ -40453,6 +40453,20 @@ var init_claude_sse_sink = __esm(() => {
   init_redact();
 });
 
+// src/in-band-api-error.ts
+function formatInBandApiError(code, message) {
+  return `
+
+[API Error: ${code} ${message}]`;
+}
+function parseInBandApiError(answer, opts = {}) {
+  const trimmed = answer.trim();
+  const m = /^\[API Error: (\S+)([\s\S]*)\]$/.exec(trimmed) ?? (opts.trailing ? /\n\n\[API Error: (\S+)([^\n\]]*)\]$/.exec(trimmed) : null);
+  if (!m)
+    return null;
+  return { code: m[1], text: `${m[1]}${m[2]}` };
+}
+
 // src/handlers/shared/stream-parsers/responses/parallel-wrapper.ts
 function stripFunctionsPrefix(name) {
   return name.startsWith("functions.") ? name.slice("functions.".length) : name;
@@ -41161,13 +41175,9 @@ function sum(values) {
 function apiErrorText(code, message, opts) {
   const isCtxOverflow = code === "context_length_exceeded" || /context (length|window)|exceeds? the context|too long|maximum context/i.test(message);
   if (!isCtxOverflow)
-    return `
-
-[API Error: ${code} ${message}]`;
+    return formatInBandApiError(code, message);
   const cap = opts.contextWindow && opts.contextWindow > 0 ? ` ~${Math.round(opts.contextWindow / 1000)}K tokens` : "";
-  return `
-
-[Context limit reached] This model's backend enforces a smaller context window${cap} than its API spec. ` + "Run /clear to start fresh (/compact will also fail \u2014 it re-sends the full conversation), " + `or route the model via \`oai@${opts.modelName}\` to use the full-size window.`;
+  return formatInBandApiError(code, `Context limit reached. This model's backend enforces a smaller context window${cap} than its API spec. ` + "Run /clear to start fresh (/compact will also fail \u2014 it re-sends the full conversation), " + `or route the model via \`oai@${opts.modelName}\` to use the full-size window.`);
 }
 function stopReasonFor(incomplete, hasToolUse) {
   if (incomplete)
@@ -57687,6 +57697,10 @@ function findCatalogEntry(entries, model) {
     return loweredId;
   return entries.find((entry) => entry.aliases.some((alias) => alias.toLowerCase() === lowered));
 }
+function catalogModelId(model, cachePath) {
+  const entries = cachePath ? readAllModelsCache(cachePath)?.entries : getCatalogEntries();
+  return entries ? findCatalogEntry(entries, model)?.modelId : undefined;
+}
 function gatherFromConnections(entry, candidates, excluded, unmappedRoutes, cachePath) {
   for (const connection of entry.aggregators ?? []) {
     if (connection.routeStatus !== "mapped")
@@ -86620,7 +86634,9 @@ function classifyRunOutput(input) {
   return v;
 }
 function classifyTurnSignals(input) {
-  const { apiError, stopReason, promptRead } = input;
+  const { stopReason, promptRead } = input;
+  const inBand = input.apiError ? null : parseInBandApiError(input.answer, { trailing: promptRead?.complete === false });
+  const apiError = input.apiError ?? (inBand ? { status: null, text: inBand.text } : null);
   if (apiError) {
     const status = apiError.status === null ? "" : ` (status ${apiError.status})`;
     return {
@@ -89693,15 +89709,15 @@ function stripUnrequestedProvider(spec, required, isCatalogModel = isCanonicalCa
     return spec;
   return spec.slice(spec.indexOf("@") + 1);
 }
-function userRequiredProvidersArg(value, specs) {
+function userRequiredProvidersArg(value, specs, name = "user_required_provider") {
   if (value === undefined || value === null)
     return new Set;
   if (!Array.isArray(value) || value.some((v) => typeof v !== "string")) {
-    throw new Error(`Invalid 'user_required_provider': expected an array of model specs.`);
+    throw new Error(`Invalid '${name}': expected an array of model specs.`);
   }
   for (const spec of value) {
     if (!specs.includes(spec)) {
-      throw new Error(`Invalid 'user_required_provider': ${JSON.stringify(spec)} is not one of the ` + `models (${specs.join(", ")}). Entries must match a 'models' or 'judges' entry exactly.`);
+      throw new Error(`Invalid '${name}': ${JSON.stringify(spec)} is not one of the ` + `models (${specs.join(", ")}). Entries must match a 'models' or 'judges' entry exactly.`);
     }
   }
   return new Set(value);
@@ -89729,6 +89745,132 @@ function strippedNote(stripped) {
     return;
   return `Provider removed so claudish routing decides: ${stripped.map((x) => `${x.from} -> ${x.to}`).join(", ")}. ` + "Pass 'user_required_provider' only when the user named the provider.";
 }
+function liveModelChoiceFacts(opts = {}) {
+  const recommended = readLastRecommendedModels()?.models ?? null;
+  if (!recommended || recommended.length === 0) {
+    log("[mcp] model check skipped: no recommended models list on disk");
+  }
+  let rules;
+  return {
+    recommended: recommended && recommended.length > 0 ? recommended : null,
+    userRule: (model) => {
+      rules ??= loadRoutingRules();
+      return matchRoutingRuleKey(model, rules) !== null;
+    },
+    inCatalog: (model) => !gatherRouteCandidates(model).catalogMiss,
+    namespaceClaim: (model) => gatherRouteCandidates(model).candidates.length > 0,
+    canonicalId: (model) => catalogModelId(model),
+    catalogMissAllowed: (model) => {
+      if (opts.projectRulesReadable === false)
+        return true;
+      if (!gatherRouteCandidates(model).catalogReadable)
+        return true;
+      const fallback = effectiveDefaultProvider();
+      return fallback !== "" && fallback !== DEFAULT_FALLBACK_PROVIDER;
+    }
+  };
+}
+function familyOf(id) {
+  return /^[a-z]+/i.exec(id)?.[0].toLowerCase() ?? id.toLowerCase();
+}
+function bareNameVerdict(spec, recommendedIds, facts) {
+  if (parseModelChain(spec).length !== 1 || nativeRouteFor(spec) !== null)
+    return;
+  const parsed = parseModelSpec(spec);
+  if (parsed.isExplicitProvider || parsed.isLegacySyntax)
+    return;
+  const model = parsed.model;
+  if (recommendedIds.has(model) || facts.userRule(model))
+    return;
+  const canonical = facts.canonicalId?.(model);
+  if (canonical !== undefined && recommendedIds.has(canonical))
+    return;
+  if (facts.inCatalog(model))
+    return { kind: "not_recommended", model };
+  if (facts.namespaceClaim(model) || facts.catalogMissAllowed?.(model))
+    return;
+  return { kind: "unknown_model", model };
+}
+function modelChoiceProblems(pairs, required, facts = liveModelChoiceFacts()) {
+  const recommended = facts.recommended;
+  if (!recommended)
+    return [];
+  const ids = new Set(recommended.map((m) => m.id));
+  const problems = [];
+  for (const { given, spec } of pairs) {
+    if (required.has(given))
+      continue;
+    const verdict = bareNameVerdict(spec, ids, facts);
+    if (!verdict)
+      continue;
+    const { kind, model } = verdict;
+    const family = familyOf(model);
+    const matching = [
+      ...new Set(recommended.filter((m) => familyOf(m.id) === family || m.provider.toLowerCase() === model.toLowerCase()).sort(compareByReleaseDateDesc).map((m) => m.id))
+    ];
+    problems.push({ spec: given, kind, matching });
+  }
+  if (problems.length > 0) {
+    log(`[mcp] model check: ${problems.map((p) => `${p.spec} ${p.kind}`).join(", ")}`);
+  }
+  return problems;
+}
+function recommendedChoices(recommended) {
+  const byId = new Map;
+  for (const m of recommended) {
+    const row = byId.get(m.id);
+    if (row) {
+      row.tiers.push(m.recommendationTier);
+      continue;
+    }
+    byId.set(m.id, {
+      id: m.id,
+      vendor: m.provider,
+      tiers: [m.recommendationTier],
+      ...m.releaseDate ? { released: m.releaseDate } : {}
+    });
+  }
+  return [...byId.values()];
+}
+function recommendedSearchMatches(query, recommended) {
+  const words = query.toLowerCase().split(/[\s,/]+/).filter((w) => w.length >= 2);
+  if (words.length === 0)
+    return [];
+  const hits = recommended.filter((m) => {
+    const id = m.id.toLowerCase();
+    return words.some((w) => id.includes(w) || familyOf(m.id) === familyOf(w) || m.provider.toLowerCase() === w);
+  });
+  return recommendedChoices([...hits].sort(compareByReleaseDateDesc));
+}
+function modelChoiceResult(problems, recommended, how) {
+  const unknown = problems.filter((p) => p.kind === "unknown_model");
+  const old = problems.filter((p) => p.kind === "not_recommended");
+  const lines = [
+    `${unknown.length > 0 ? "unknown_model" : "not_recommended"}: nothing was started.`
+  ];
+  if (unknown.length > 0) {
+    lines.push(`Not a model id: ${unknown.map((p) => JSON.stringify(p.spec)).join(", ")}. ` + "Pick the recommended model that best fits the task (for a family name, the newest " + "of the matching ids) and call again with its id.");
+  }
+  if (old.length > 0) {
+    lines.push(`Not in the recommended list: ${old.map((p) => JSON.stringify(p.spec)).join(", ")}. ` + "Re-evaluate the choice against the recommended models below and call again with one " + `of them. If the user named this exact model, call again ${how}.`);
+  }
+  const matching = Object.fromEntries(problems.map((p) => [p.spec, p.matching]));
+  lines.push(`Matching recommended ids: ${JSON.stringify(matching, null, 2)}`);
+  const efforts = effortClarification([...new Set(problems.flatMap((p) => p.matching))]);
+  if (efforts) {
+    lines.push("Recommended effort for those ids, by task type (pass your task's level with the model " + `you pick): ${JSON.stringify(efforts, null, 2)}`);
+  }
+  lines.push(`Recommended models: ${JSON.stringify(recommendedChoices(recommended), null, 2)}`);
+  return { content: [{ type: "text", text: lines.join(`
+`) }], isError: true };
+}
+function modelChoiceStop(pairs, required, how, opts = {}) {
+  const facts = liveModelChoiceFacts(opts);
+  const problems = modelChoiceProblems(pairs, required, facts);
+  if (problems.length === 0 || !facts.recommended)
+    return;
+  return modelChoiceResult(problems, facts.recommended, how);
+}
 function buildChildClaudeFlags(agent, claudeFlags) {
   const extra = typeof claudeFlags === "string" ? claudeFlags.split(/\s+/).filter(Boolean) : [];
   const named = typeof agent === "string" ? agent.trim() : "";
@@ -89845,6 +89987,12 @@ function optionalString(raw, name) {
     throw new ContractErrorException("invalid_args", `'${name}' must be a non-empty string`);
   return raw;
 }
+function requiredString(raw, name) {
+  const value = optionalString(raw, name);
+  if (value === undefined)
+    throw new ContractErrorException("invalid_args", `'${name}' is required`);
+  return value;
+}
 function optionalBoolean(raw, name) {
   if (raw === undefined || raw === null)
     return false;
@@ -89953,6 +90101,7 @@ ${block.join(`
           type: "boolean",
           description: "True only when the USER named the provider ('use OpenRouter for it'): the " + "'provider@model' spec is then sent as given."
         },
+        user_required_model: { type: "boolean", description: USER_REQUIRED_MODEL_DESCRIPTION },
         prompt: { type: "string", description: "The prompt to send to the model" },
         system_prompt: { type: "string", description: "Optional system prompt" },
         effort: {
@@ -89968,6 +90117,9 @@ ${block.join(`
     handler: async (args, ctx) => {
       try {
         const { specs, stripped } = strippedProviders([args.model], new Set(args.user_required_provider === true ? [args.model] : []));
+        const choice = modelChoiceStop([{ given: args.model, spec: specs[0] }], new Set(args.user_required_model === true ? [args.model] : []), "with user_required_model: true");
+        if (choice)
+          return choice;
         const recommended = args.effort === undefined ? effortClarification([args.model]) : undefined;
         if (recommended) {
           return needsEffortResult(recommended, `with effort: "<level>" (effort: "${KEEP_EFFORT}" keeps Claude Code's own)`);
@@ -90065,6 +90217,26 @@ ${block.join(`
         return compareByReleaseDateDesc(orderingKey(a.model), orderingKey(b.model));
       }).slice(0, maxResults);
       const catalogMatches = searchCatalogModels(query, Math.max(maxResults, 5));
+      const recommendedHits = recommendedSearchMatches(query, readLastRecommendedModels()?.models ?? []);
+      const renderRecommendedSection = () => {
+        if (recommendedHits.length === 0)
+          return "";
+        let s = `## Recommended models (pass one of these)
+
+`;
+        s += `| Bare name | Vendor | Tiers | Released |
+`;
+        s += `|-----------|--------|-------|----------|
+`;
+        for (const m of recommendedHits) {
+          s += `| ${m.id} | ${m.vendor} | ${m.tiers.join(", ")} | ${m.released ?? "-"} |
+`;
+        }
+        return `${s}
+`;
+      };
+      const useWith = () => recommendedHits.length > 0 ? `
+Use with: run_prompt(model="${recommendedHits[0].id}", prompt="your prompt")` : "\nNo recommended model matches this query: call `list_models` for the recommended set.";
       const renderCatalogSection = () => {
         if (catalogMatches.length === 0)
           return "";
@@ -90081,12 +90253,17 @@ ${block.join(`
           s += `| ${m.modelId} | ${m.matchedAlias ?? "-"} | ${plans} |
 `;
         }
-        s += `
-Pass the **bare name**. Routing puts a subscription ahead of the metered API and ` + "rewrites the model to that plan's wire id for you. An aggregator-qualified id " + "(`moonshotai/...`, `accounts/fireworks/...`) pins that aggregator and bills per token.\n";
+        s += "\nOnly the recommended models above start without `user_required_model`. " + "Pass the **bare name**. Routing puts a subscription ahead of the metered API and " + "rewrites the model to that plan's wire id for you. An aggregator-qualified id " + "(`moonshotai/...`, `accounts/fireworks/...`) pins that aggregator and bills per token.\n";
         return s;
       };
       if (results.length === 0) {
         const catalog = renderCatalogSection();
+        if (recommendedHits.length > 0) {
+          const text = `No OpenRouter listing matches "${query}".
+
+${renderRecommendedSection()}${catalog}${useWith()}`;
+          return { content: [{ type: "text", text }] };
+        }
         const text = catalog ? `No OpenRouter listing matches "${query}", but claudish's catalog knows these:
 ${catalog}` : `No models found matching "${query}".
 
@@ -90096,6 +90273,7 @@ ${catalog}` : `No models found matching "${query}".
       let output = `# Search Results for "${query}"
 
 `;
+      output += renderRecommendedSection();
       output += `## OpenRouter listing
 
 `;
@@ -90114,9 +90292,7 @@ ${catalog}` : `No models found matching "${query}".
 `;
       }
       output += renderCatalogSection();
-      const suggested = catalogMatches[0]?.modelId ?? results[0].model.id;
-      output += `
-Use with: run_prompt(model="${suggested}", prompt="your prompt")`;
+      output += useWith();
       return { content: [{ type: "text", text: output }] };
     }
   });
@@ -90300,6 +90476,11 @@ Use with: run_prompt(model="${suggested}", prompt="your prompt")`;
           items: { type: "string" },
           description: "The 'models' or 'judges' entries whose provider the USER named ('run Kimi on " + "OpenRouter'), exactly as written there. Every other 'provider@' on a catalog " + "model is removed so claudish routing picks the provider from the user's setup; " + "pass bare names unless the user asked for a provider."
         },
+        user_required_model: {
+          type: "array",
+          items: { type: "string" },
+          description: "The 'models' or 'judges' entries the USER named as exact models, exactly as " + "written there: they run even when not in the recommended list. Never list a " + "model you chose yourself."
+        },
         input_file: {
           type: "string",
           description: "PREFERRED. Path to a file holding the task prompt, relative to the working " + "directory. Use this rather than `input` for anything longer than a sentence: " + "a prompt passed inline is echoed verbatim in the caller's terminal, where a " + "200-line review brief buries every other argument and makes the call " + "unreadable. Write the brief to the session directory first (input.md is the " + "conventional name) and point here."
@@ -90384,7 +90565,15 @@ Use with: run_prompt(model="${suggested}", prompt="your prompt")`;
           const existing = join56(resolved, "input.md");
           return existsSync37(existing) ? readFileSync37(existing, "utf-8") : undefined;
         };
-        if ((mode === "run" || mode === "run-and-judge") && givenModels && args.efforts === undefined) {
+        const runsModels = mode === "run" || mode === "run-and-judge";
+        const runsJudges = mode === "judge" || mode === "run-and-judge";
+        const choice = modelChoiceStop([
+          ...runsModels && givenModels && models ? givenModels.map((given, i) => ({ given, spec: models[i] })) : [],
+          ...runsJudges && givenJudges && judges ? givenJudges.map((given, i) => ({ given, spec: judges[i] })) : []
+        ], userRequiredProvidersArg(args.user_required_model, [...givenModels ?? [], ...givenJudges ?? []], "user_required_model"), 'with user_required_model: ["<that entry>"]');
+        if (choice)
+          return choice;
+        if (runsModels && givenModels && args.efforts === undefined) {
           const recommended = effortClarification(givenModels);
           if (recommended) {
             return needsEffortResult(recommended, `with efforts: {"<model>": "<level>"} (efforts: {} keeps Claude Code's own for every model)`);
@@ -90673,6 +90862,7 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
           type: "boolean",
           description: "True only when the USER named the provider: the 'provider@model' spec is then " + "used as given."
         },
+        user_required_model: { type: "boolean", description: USER_REQUIRED_MODEL_DESCRIPTION },
         prompt: {
           type: "string",
           description: "Initial prompt to send. If omitted, send later via send_input."
@@ -90720,6 +90910,11 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
         await assertMagmuxAvailable();
         const { specs, stripped } = strippedProviders([args.model], new Set(args.user_required_provider === true ? [args.model] : []));
         const requestedModel = specs[0];
+        const choice = modelChoiceStop([{ given: args.model, spec: requestedModel }], new Set(args.user_required_model === true ? [args.model] : []), "with user_required_model: true", {
+          projectRulesReadable: typeof args.work_dir !== "string" || resolve8(args.work_dir) === process.cwd()
+        });
+        if (choice)
+          return choice;
         const recommended = args.effort === undefined ? effortClarification([args.model]) : undefined;
         if (recommended) {
           return needsEffortResult(recommended, `with effort: "<level>" (effort: "${KEEP_EFFORT}" keeps Claude Code's own)`);
@@ -90787,7 +90982,7 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
     },
     group: "session",
     handler: async (args) => {
-      const result = sessionManager.sendInput(args.session_id, args.text);
+      const result = sessionManager.sendInput(requiredString(args.session_id, "session_id"), requiredString(args.text, "text"));
       return {
         content: [{ type: "text", text: JSON.stringify(result) }]
       };
@@ -90810,7 +91005,7 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
     group: "session",
     handler: async (args) => {
       try {
-        const output = sessionManager.getOutput(args.session_id, args.tail_lines);
+        const output = sessionManager.getOutput(requiredString(args.session_id, "session_id"), args.tail_lines);
         return {
           content: [{ type: "text", text: JSON.stringify(output) }]
         };
@@ -90891,7 +91086,7 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
     group: "session",
     handler: async (args) => {
       try {
-        const diagnostics = sessionManager.getDiagnostics(args.session_id, args.event_limit);
+        const diagnostics = sessionManager.getDiagnostics(requiredString(args.session_id, "session_id"), args.event_limit);
         return {
           content: [{ type: "text", text: JSON.stringify(diagnostics) }]
         };
@@ -91114,7 +91309,7 @@ Each session is an interactive Claude Code running the model in its own headless
 5. FAILED or TIMEOUT \u2014 or COMPLETED with an empty or surprising answer \u2014 call get_diagnostics. It returns the child's final screen, the upstream error bodies, the recent state records, the resolved model chain and the paths to the full records. It needs no re-run and no debug flag.
 6. capture_session reads a session's current screen; resize_session sets its terminal size (any time, mid-turn included); cancel_session stops it. Nothing stops a session for being idle: a child inside a long build is silent and working.
 
-The session_id from create_session is the key for every session tool.`, proxyInstance = null, proxyStarting = null, SCORE_TIE_EPSILON = 0.000001, NEXT_STEP, KEEP_EFFORT = "default", sanitize2, TOOL_MODES;
+The session_id from create_session is the key for every session tool.`, proxyInstance = null, proxyStarting = null, SCORE_TIE_EPSILON = 0.000001, NEXT_STEP, KEEP_EFFORT = "default", USER_REQUIRED_MODEL_DESCRIPTION, sanitize2, TOOL_MODES;
 var init_mcp_server = __esm(() => {
   init_server2();
   init_stdio2();
@@ -91146,6 +91341,8 @@ var init_mcp_server = __esm(() => {
   init_preflight_chain();
   init_probe_live();
   init_provider_definitions();
+  init_route_candidates();
+  init_routing_rules();
   init_proxy_server();
   init_recommended_listing();
   init_redact();
@@ -91172,6 +91369,7 @@ var init_mcp_server = __esm(() => {
     empty_output: "retry once; if it repeats, drop the model",
     shape_mismatch: "the answer (assistant text after the task was read) did not match. Every assistant " + "message of the turn was read from the transcript, so nothing was lost in transit \u2014 " + "the model did not produce it. Re-prompt with the required format restated; do NOT " + "count this slot as a vote"
   };
+  USER_REQUIRED_MODEL_DESCRIPTION = "True only when the USER named this exact model: it then runs even when it is not in the " + "recommended list. Never set it for a model you chose yourself.";
   sanitize2 = sanitizeForReport;
   TOOL_MODES = ["all", "low-level", "agentic", "session", "debug"];
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "14.3.0",
+  "version": "14.4.1",
   "description": "Run Claude Code with any model - OpenRouter, Ollama, LM Studio & local models",
   "type": "module",
   "main": "./dist/index.js",
@@ -71,10 +71,10 @@
     "ai"
   ],
   "optionalDependencies": {
-    "@claudish/magmux-darwin-arm64": "14.3.0",
-    "@claudish/magmux-darwin-x64": "14.3.0",
-    "@claudish/magmux-linux-arm64": "14.3.0",
-    "@claudish/magmux-linux-x64": "14.3.0"
+    "@claudish/magmux-darwin-arm64": "14.4.1",
+    "@claudish/magmux-darwin-x64": "14.4.1",
+    "@claudish/magmux-linux-arm64": "14.4.1",
+    "@claudish/magmux-linux-x64": "14.4.1"
   },
   "author": "Jack Rudenko <i@madappgang.com>",
   "license": "MIT",

package/skills/claudish-usage/SKILL.md

@@ -58,9 +58,13 @@ subscriptions first, their preferences and manual overrides. Do not choose it yo
    `create_session` / `run_prompt`: `true`).
 3. **User named exact models:** pass them as given. No `preflight` or `search_models`
    call is needed to check them: claudish routes and checks them. You still read
-   `list_models` once for their efforts (next section).
+   `list_models` once for their efforts (next section). A named model outside the
+   recommended list answers `not_recommended`; list it in `user_required_model` (`team`:
+   the entries; `create_session` / `run_prompt`: `true`) and call again.
 4. **User named only a family or vendor** ("a GPT model", "minimax", "latest Grok"): call
-   `list_models` and take the newest model of that family from it, as a bare name.
+   `list_models` and take the newest model of that family from it, as a bare name. A
+   family name (`gpt`) or a model you recall (`gpt-5`) answers `unknown_model` /
+   `not_recommended` with the recommended ids: pick from them and call again.
 
 ### 🎚️ Reasoning Effort per Model