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.tsindex 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.tsnew file mode 100644index 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)");+});