Skip to content

Claude Code. Any Model. The most powerful AI coding agent now speaks every language.

fix(tui): use the shared NATIVE_NOT_PROBED note in the route probe

Jack Rudenko047bed2557a6
diff --git a/packages/cli/src/tui/hooks/useRouteProbe.ts b/packages/cli/src/tui/hooks/useRouteProbe.ts
index 4939deb4..21300d06 100644
--- a/packages/cli/src/tui/hooks/useRouteProbe.ts
+++ b/packages/cli/src/tui/hooks/useRouteProbe.ts
@@ -1,4 +1,5 @@
import { useCallback, useState } from "react";
+import { NATIVE_NOT_PROBED } from "../../providers/native-route.js";
import { describeProbeState } from "../../providers/probe-live.js";
import { INTERACTIVE_PROBE_TIMEOUT_MS, probeProviderRoute } from "../../providers/probe-runner.js";
import {
@@ -10,14 +11,6 @@ import {
import { ensureProbeProxy } from "../probe-proxy.js";
import type { ProbeEntry, ProbeMode, ProbeSummary } from "../types.js";
-/**
- * Why a native row is never probed here: the native handler authenticates with
- * the inbound Claude Code header, which this probe cannot supply, so a request
- * would fail for a healthy model and a typo alike (see providers/native-route.ts).
- */
-const NATIVE_NOT_PROBED_NOTE =
- "Not probed: served on Claude Code's own auth, which this process cannot forward.";
-
/**
* Why a catalog-gathered chain has no fallback hop, when the catalog HAS the
* model. (When it does not, `describeRouteExplanation` already says so.)
@@ -56,7 +49,9 @@ export function probeRowsFrom(explanation: RouteExplanation): ProbeView {
};
if (explanation.source === "native") {
- summary.notes.push(NATIVE_NOT_PROBED_NOTE);
+ // Why a native row is never probed, in the words `--probe` and the MCP
+ // preflight use (native-route.ts).
+ summary.notes.push(NATIVE_NOT_PROBED);
const native = explanation.native;
const rows: ProbeEntry[] = native
? [
diff --git a/packages/cli/src/tui/routing-explanation.test.ts b/packages/cli/src/tui/routing-explanation.test.ts
new file mode 100644
index 00000000..be2cc798
--- /dev/null
+++ b/packages/cli/src/tui/routing-explanation.test.ts
@@ -0,0 +1,330 @@
+import { describe, expect, test } from "bun:test";
+import { copyFileSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { probeChainFrom } from "../probe/probe-chain.js";
+import type { ClaudishProfileConfig } from "../profile-config.js";
+import { NATIVE_NOT_PROBED } from "../providers/native-route.js";
+import type { RouteTier } from "../providers/provider-definitions.js";
+import {
+ type RouteExplanation,
+ TIER_LABEL,
+ describeRouteExplanation,
+ hopLabel,
+} from "../providers/routing-rules.js";
+import { paneRouteLine } from "../team-grid.js";
+import {
+ resolveFallbackHop,
+ routingHeaderLines,
+ hopLabel as tuiHopLabel,
+} from "./components/RoutingContent.js";
+import { probeQueue, probeRowsFrom } from "./hooks/useRouteProbe.js";
+
+const CATALOG_FIXTURE = join(
+ import.meta.dir,
+ "..",
+ "test-fixtures",
+ "stage5-explain-route-catalog.json"
+);
+
+function headerText(input: Parameters<typeof routingHeaderLines>[0]): string[] {
+ return routingHeaderLines(input).map((line) => line.map((segment) => segment.text).join(""));
+}
+
+function config(defaultProvider?: string): ClaudishProfileConfig {
+ return {
+ version: "1.0.0",
+ defaultProfile: "default",
+ profiles: {},
+ ...(defaultProvider !== undefined ? { defaultProvider } : {}),
+ };
+}
+
+function scopedProbeViews(): Array<{
+ model: string;
+ line: string;
+ providers: string[];
+}> {
+ const home = mkdtempSync(join(tmpdir(), "claudish-stage7-probe-"));
+ const configDir = join(home, ".claudish");
+ const projectDir = join(home, "project");
+ mkdirSync(configDir, { recursive: true });
+ mkdirSync(projectDir, { recursive: true });
+ copyFileSync(CATALOG_FIXTURE, join(configDir, "cloud-models-catalog-v3.json"));
+ writeFileSync(
+ join(configDir, "config.json"),
+ JSON.stringify({
+ version: "1.0.0",
+ defaultProfile: "default",
+ profiles: {},
+ routing: { "glm-*": ["openrouter"] },
+ }),
+ "utf8"
+ );
+ writeFileSync(
+ join(projectDir, ".claudish.json"),
+ JSON.stringify({ routing: { "glm-5*": ["openai"] } }),
+ "utf8"
+ );
+
+ const routingUrl = new URL("../providers/routing-rules.ts", import.meta.url).href;
+ const probeUrl = new URL("./hooks/useRouteProbe.ts", import.meta.url).href;
+ const script = `
+ const { explainRoute } = await import(${JSON.stringify(routingUrl)});
+ const { probeRowsFrom } = await import(${JSON.stringify(probeUrl)});
+ const values = [];
+ for (const model of ["glm-5.3", "glm-4.6"]) {
+ const view = probeRowsFrom(await explainRoute(model));
+ values.push({
+ model,
+ line: view.summary.line,
+ providers: view.rows.map((row) => row.provider),
+ });
+ }
+ process.stdout.write(JSON.stringify(values));
+ `;
+
+ try {
+ const child = Bun.spawnSync([process.execPath, "-e", script], {
+ cwd: projectDir,
+ env: {
+ HOME: home,
+ PATH: process.env.PATH ?? "",
+ TMPDIR: process.env.TMPDIR ?? tmpdir(),
+ CLAUDISH_DISABLE_CATALOG_WARM: "1",
+ CLAUDISH_DISABLE_OP: "1",
+ CLAUDISH_DISABLE_KEYCHAIN: "1",
+ OPENAI_API_KEY: "stage7-openai",
+ OPENROUTER_API_KEY: "stage7-openrouter",
+ },
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ const stdout = child.stdout.toString();
+ const stderr = child.stderr.toString();
+ expect(child.exitCode, stderr || stdout).toBe(0);
+ return JSON.parse(stdout) as ReturnType<typeof scopedProbeViews>;
+ } finally {
+ rmSync(home, { recursive: true, force: true });
+ }
+}
+
+describe("probeRowsFrom", () => {
+ test("uses the project rule and the longest matching glob in its reason", () => {
+ expect(scopedProbeViews()).toEqual([
+ {
+ model: "glm-5.3",
+ line: 'user rule "glm-5*" (project)',
+ providers: ["openai"],
+ },
+ {
+ model: "glm-4.6",
+ line: 'user rule "glm-*" (global)',
+ providers: ["openrouter"],
+ },
+ ]);
+ });
+
+ test("queues kept rows once and never changes dropped rows to testing or no_key", () => {
+ const dashscopeKey = process.env.DASHSCOPE_API_KEY;
+ delete process.env.DASHSCOPE_API_KEY;
+ const explanation: RouteExplanation = {
+ requestedModel: "mixed-model",
+ routedModel: "mixed-model",
+ source: "user-rule",
+ matchedPattern: "mixed-*",
+ ruleScope: "project",
+ candidates: [
+ {
+ provider: "qwen-payg",
+ displayName: "Alibaba PAYG",
+ modelSpec: "qpay@mixed-model",
+ wireId: "mixed-model",
+ position: "candidate",
+ tier: "native",
+ outcome: "kept",
+ },
+ {
+ provider: "openrouter",
+ displayName: "OpenRouter",
+ modelSpec: "openrouter@mixed-model",
+ wireId: "mixed-model",
+ position: "fallback",
+ tier: "gateway",
+ outcome: "no-credential",
+ },
+ ],
+ outcome: { kind: "ok" },
+ warnings: [],
+ };
+
+ try {
+ const view = probeRowsFrom(explanation);
+
+ expect(view.rows.map((row) => [row.provider, row.status, row.outcome])).toEqual([
+ ["qwen-payg", "pending", undefined],
+ ["openrouter", "dropped", "no-credential"],
+ ]);
+ expect(probeQueue(view.rows)).toEqual([
+ { index: 0, provider: "qwen-payg", modelSpec: "qpay@mixed-model" },
+ ]);
+ expect(view.rows.some((row) => row.status === "testing" || row.status === "no_key")).toBe(
+ false
+ );
+ } finally {
+ if (dashscopeKey === undefined) delete process.env.DASHSCOPE_API_KEY;
+ else process.env.DASHSCOPE_API_KEY = dashscopeKey;
+ }
+ });
+
+ test("uses the shared native-auth not-probed note", () => {
+ const view = probeRowsFrom({
+ requestedModel: "claude-opus-5",
+ routedModel: "claude-opus-5",
+ source: "native",
+ candidates: [],
+ outcome: { kind: "ok" },
+ warnings: [],
+ native: {
+ provider: "native-anthropic",
+ modelSpec: "claude-opus-5",
+ displayName: "Anthropic (Native)",
+ isTierAlias: false,
+ },
+ });
+
+ expect(view.summary.notes).toEqual([NATIVE_NOT_PROBED]);
+ expect(view.rows).toEqual([
+ expect.objectContaining({ provider: "native-anthropic", status: "unverified" }),
+ ]);
+ });
+});
+
+describe("route hop labels", () => {
+ test("TIER_LABEL is total over RouteTier", () => {
+ const expected = {
+ subscription: "subscription",
+ "dynamic-subscription": "subscription · account decides models",
+ native: "native API",
+ gateway: "gateway",
+ fallback: "fallback",
+ } satisfies Record<RouteTier, string>;
+
+ expect(TIER_LABEL).toEqual(expected);
+ });
+
+ test("the shared, probe, and TUI labels agree for every tier and position", () => {
+ const tiers: RouteTier[] = [
+ "subscription",
+ "dynamic-subscription",
+ "native",
+ "gateway",
+ "fallback",
+ ];
+
+ for (const tier of tiers) {
+ for (const position of ["candidate", "fallback"] as const) {
+ const expected = hopLabel({ tier, position });
+ const explanation: RouteExplanation = {
+ requestedModel: "label-model",
+ routedModel: "label-model",
+ source: "catalog",
+ catalog: "found",
+ candidates: [
+ {
+ provider: "label-provider",
+ displayName: "Label Provider",
+ modelSpec: "label-provider@label-model",
+ wireId: "label-model",
+ tier,
+ position,
+ outcome: "kept",
+ },
+ ],
+ outcome: { kind: "ok" },
+ warnings: [],
+ };
+ const { chain } = probeChainFrom(explanation, {
+ hintFor: () => undefined,
+ provenanceFor: () => undefined,
+ });
+
+ expect(chain[0]?.label).toBe(expected);
+ expect(tuiHopLabel({ status: "pending", tier, position })).toBe(expected);
+ }
+ }
+ });
+});
+
+describe("routing header", () => {
+ test("a project * rule wins and replaces the fallback header", () => {
+ const lines = headerText({
+ globalRules: { "*": ["openrouter"] },
+ localRules: { "*": ["openai"] },
+ resolved: { provider: "poe", source: "config-file" },
+ });
+
+ expect(lines.join("\n")).toContain("decides every model no other rule matches");
+ expect(lines).toContain(" → openai (project)");
+ expect(lines.some((line) => line.includes("Fallback hop:"))).toBe(false);
+ });
+
+ test("shows the resolved env, config, and default fallback states", () => {
+ const envDisabled = headerText({
+ globalRules: {},
+ localRules: {},
+ resolved: resolveFallbackHop(config("poe"), { CLAUDISH_DEFAULT_PROVIDER: "" }),
+ }).join("\n");
+ const configured = headerText({
+ globalRules: {},
+ localRules: {},
+ resolved: resolveFallbackHop(config("poe"), {}),
+ }).join("\n");
+ const defaulted = headerText({
+ globalRules: {},
+ localRules: {},
+ resolved: resolveFallbackHop(config(), {}),
+ }).join("\n");
+
+ expect(envDisabled).toContain('disabled, set to "" (CLAUDISH_DEFAULT_PROVIDER)');
+ expect(configured).toContain("→ poe (config)");
+ expect(defaulted).toContain("→ openrouter (default)");
+ });
+});
+
+test("the team pane route line shows the calculated catalog chain", () => {
+ const explanation: RouteExplanation = {
+ requestedModel: "catalog-model",
+ routedModel: "catalog-model",
+ source: "catalog",
+ catalog: "found",
+ candidates: [
+ {
+ provider: "kimi-coding",
+ displayName: "Kimi Coding",
+ modelSpec: "kc@catalog-model",
+ wireId: "catalog-model",
+ position: "candidate",
+ tier: "subscription",
+ outcome: "kept",
+ },
+ {
+ provider: "openrouter",
+ displayName: "OpenRouter",
+ modelSpec: "openrouter@catalog-model",
+ wireId: "catalog-model",
+ position: "candidate",
+ tier: "gateway",
+ outcome: "kept",
+ },
+ ],
+ fallbackWithheld: "already-gathered",
+ outcome: { kind: "ok" },
+ warnings: [],
+ };
+
+ const line = paneRouteLine(explanation);
+
+ expect(line).toBe(`Kimi Coding → OpenRouter (${describeRouteExplanation(explanation)})`);
+ expect(line).not.toContain("(auto)");
+});