Skip to content

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

fix(cli): make --default-provider reach the proxy and child sessions

Jack Rudenko9be012fc6e2d
diff --git a/packages/cli/src/cli.ts b/packages/cli/src/cli.ts
index 1df129d3..45662be5 100644
--- a/packages/cli/src/cli.ts
+++ b/packages/cli/src/cli.ts
@@ -426,13 +426,14 @@ export async function parseArgs(args: string[]): Promise<ClaudishConfig> {
process.exit(1);
}
config.profile = profileArg;
- } else if (arg === "--default-provider") {
- const dpArg = args[++i];
- if (!dpArg) {
- console.error("--default-provider requires a provider name");
- process.exit(1);
+ } else if (arg === "--default-provider" || arg.startsWith("--default-provider=")) {
+ // index.ts strips this flag and exports it as CLAUDISH_DEFAULT_PROVIDER
+ // before parseArgs runs (applyDefaultProviderFlag), so this branch fires only
+ // for a caller that skipped that step. It consumes the flag and its value so
+ // neither leaks to Claude Code as a passthrough arg.
+ if (arg === "--default-provider" && i + 1 < args.length && !args[i + 1].startsWith("-")) {
+ i++;
}
- config.defaultProvider = dpArg;
} else if (arg === "--anthropic-api-billing") {
config.anthropicApiBilling = true;
} else if (arg === "--classifier-model") {
@@ -852,17 +853,12 @@ export async function parseArgs(args: string[]): Promise<ClaudishConfig> {
}
}
- // Phase 1 (LiteLLM-demotion refactor): resolve the effective default provider
- // and emit a one-shot stderr hint when legacy LITELLM auto-promotion kicks in.
- // This currently has no routing effect — Phase 2 wires it into auto-route.
+ // Phase 1 (LiteLLM-demotion refactor): emit a one-shot stderr hint when legacy
+ // LITELLM auto-promotion kicks in. Routing does not read this: it resolves the
+ // default provider itself, and `--default-provider` reaches it through the env
+ // variable index.ts exports.
try {
- const fileConfigForResolver = loadConfig();
- const resolved = resolveDefaultProvider({
- cliFlag: config.defaultProvider,
- config: fileConfigForResolver,
- env: process.env,
- });
- config.resolvedDefaultProvider = resolved;
+ const resolved = resolveDefaultProvider({ config: loadConfig(), env: process.env });
if (resolved.legacyAutoPromoted && !config.quiet) {
const markerFile = join(homedir(), ".claudish", ".legacy-litellm-hint-shown");
diff --git a/packages/cli/src/default-provider.test.ts b/packages/cli/src/default-provider.test.ts
index a3ccb8a4..6f44b739 100644
--- a/packages/cli/src/default-provider.test.ts
+++ b/packages/cli/src/default-provider.test.ts
@@ -1,7 +1,17 @@
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 { resolveDefaultProvider } from "./default-provider.js";
import type { ClaudishProfileConfig } from "./profile-config.js";
+const STAGE4_CATALOG_FIXTURE = join(
+ import.meta.dir,
+ "test-fixtures",
+ "stage4-default-provider-catalog.json"
+);
+const CLI_ENTRY = join(import.meta.dir, "index.ts");
+
function makeConfig(overrides: Partial<ClaudishProfileConfig> = {}): ClaudishProfileConfig {
return {
version: "1.0.0",
@@ -43,6 +53,44 @@ describe("resolveDefaultProvider precedence", () => {
expect(result.legacyAutoPromoted).toBe(false);
});
+ test("an empty env var disables the fallback and keeps the env-var source", () => {
+ expect(
+ resolveDefaultProvider({
+ config: makeConfig(),
+ env: { CLAUDISH_DEFAULT_PROVIDER: "" },
+ })
+ ).toEqual({ provider: "", source: "env-var", legacyAutoPromoted: false });
+ });
+
+ test("an empty config value disables the fallback and keeps the config-file source", () => {
+ expect(
+ resolveDefaultProvider({ config: makeConfig({ defaultProvider: "" }), env: {} })
+ ).toEqual({
+ provider: "",
+ source: "config-file",
+ legacyAutoPromoted: false,
+ });
+ });
+
+ test("an empty env var beats a non-empty config value", () => {
+ expect(
+ resolveDefaultProvider({
+ config: makeConfig({ defaultProvider: "from-config" }),
+ env: { CLAUDISH_DEFAULT_PROVIDER: "" },
+ })
+ ).toEqual({ provider: "", source: "env-var", legacyAutoPromoted: false });
+ });
+
+ test("a non-empty CLI flag beats an empty env var", () => {
+ expect(
+ resolveDefaultProvider({
+ cliFlag: "from-flag",
+ config: makeConfig({ defaultProvider: "from-config" }),
+ env: { CLAUDISH_DEFAULT_PROVIDER: "" },
+ })
+ ).toEqual({ provider: "from-flag", source: "cli-flag", legacyAutoPromoted: false });
+ });
+
test("config wins over legacy", () => {
const env: NodeJS.ProcessEnv = {
LITELLM_BASE_URL: "http://litellm.local",
@@ -125,8 +173,64 @@ describe("resolveDefaultProvider precedence", () => {
});
});
-describe("buildLegacyHint (commit 5: now a no-op)", () => {
- // Pre-commit-5, this returned a stderr hint when legacyAutoPromoted=true.
- // Since LiteLLM auto-promotion was removed, the function always returns
- // null — kept for backwards-compat with existing callers.
+interface ProbeJson {
+ chain: Array<{ provider: string }>;
+}
+
+function sandboxedProbe(flagBeforeProbe: boolean, provider: string): ProbeJson {
+ const home = mkdtempSync(join(tmpdir(), "claudish-default-provider-probe-"));
+ const configDir = join(home, ".claudish");
+ mkdirSync(configDir, { recursive: true });
+ copyFileSync(STAGE4_CATALOG_FIXTURE, join(configDir, "cloud-models-catalog-v3.json"));
+ writeFileSync(
+ join(configDir, "config.json"),
+ JSON.stringify({ version: "1.0.0", defaultProfile: "default", profiles: {} }),
+ "utf8"
+ );
+
+ const flag = ["--default-provider", provider];
+ const probe = ["--probe", "no-such-model-xyz"];
+ const args = flagBeforeProbe
+ ? [CLI_ENTRY, ...flag, ...probe, "--json", "--no-probe"]
+ : [CLI_ENTRY, ...probe, ...flag, "--json", "--no-probe"];
+ const env: Record<string, string> = {
+ HOME: home,
+ PATH: process.env.PATH ?? "",
+ TMPDIR: process.env.TMPDIR ?? tmpdir(),
+ CLAUDISH_DISABLE_CATALOG_WARM: "1",
+ CLAUDISH_DISABLE_KEYCHAIN: "1",
+ CLAUDISH_DISABLE_OP: "1",
+ CLAUDISH_SKIP_LIVE_E2E: "1",
+ };
+
+ try {
+ const result = Bun.spawnSync([process.execPath, ...args], {
+ cwd: join(import.meta.dir, "../../.."),
+ env,
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ const stdout = result.stdout.toString();
+ const stderr = result.stderr.toString();
+ expect(result.exitCode, stderr || stdout).toBe(0);
+ const parsed = JSON.parse(stdout) as ProbeJson[];
+ expect(parsed).toHaveLength(1);
+ return parsed[0];
+ } finally {
+ rmSync(home, { recursive: true, force: true });
+ }
+}
+
+describe("--default-provider pre-scan reaches --probe", () => {
+ test("uses poe when the flag appears before --probe", () => {
+ expect(sandboxedProbe(true, "poe").chain.map((entry) => entry.provider)).toEqual(["poe"]);
+ });
+
+ test("uses poe when the flag appears after the probed model", () => {
+ expect(sandboxedProbe(false, "poe").chain.map((entry) => entry.provider)).toEqual(["poe"]);
+ });
+
+ test("an empty flag value produces an empty chain", () => {
+ expect(sandboxedProbe(true, "").chain).toEqual([]);
+ });
});
diff --git a/packages/cli/src/default-provider.ts b/packages/cli/src/default-provider.ts
index ab0d32ed..6b2d6a7a 100644
--- a/packages/cli/src/default-provider.ts
+++ b/packages/cli/src/default-provider.ts
@@ -4,6 +4,7 @@
*
* No imports from cli.ts or proxy-server.ts (otherwise we get import cycles).
* Reads from a passed-in config object, env vars, and an optional CLI flag.
+ * Also `planDefaultProviderFlag`, the argv scan index.ts applies before parseArgs.
*
* LiteLLM auto-promotion was removed in commit 5 of the model-catalog and
* routing redesign. Users who relied on `LITELLM_BASE_URL` + `LITELLM_API_KEY`
@@ -54,7 +55,9 @@ export interface ResolveOptions {
* So an env `""` beats a config `x`, and a flag `x` beats an env `""`.
*
* An empty `cliFlag` is different: it means the caller parsed no flag, and it
- * falls through.
+ * falls through. The CLI no longer passes the flag here: index.ts exports it to
+ * CLAUDISH_DEFAULT_PROVIDER (`planDefaultProviderFlag`), which is also how an
+ * explicit `--default-provider ""` arrives.
*/
export function resolveDefaultProvider(opts: ResolveOptions): ResolvedDefaultProvider {
const env = opts.env ?? process.env;
@@ -82,6 +85,67 @@ export function resolveDefaultProvider(opts: ResolveOptions): ResolvedDefaultPro
return { provider: "openrouter", source: "hardcoded", legacyAutoPromoted: false };
}
+/**
+ * What a `--default-provider` scan of argv decided. A plan rather than an effect,
+ * like `planConfigOverride`: index.ts applies it (strips argv, exports the value).
+ */
+export type DefaultProviderFlagPlan =
+ | { kind: "none" }
+ | { kind: "error"; message: string }
+ | {
+ kind: "apply";
+ /** The flag's value. `""` is kept: it disables the fallback hop. */
+ value: string;
+ /** argv with every occurrence of the flag and its value removed. */
+ argv: string[];
+ };
+
+const DEFAULT_PROVIDER_FLAG = "--default-provider";
+
+/**
+ * Find `--default-provider <name>` (or `--default-provider=<name>`) in argv, before
+ * `parseArgs` sees it.
+ *
+ * Why before: `--probe` runs and exits INSIDE `parseArgs`'s argv loop, so a flag
+ * read there, or after it, never reached `--probe` in either argv order. Scanning
+ * first gives every path the same answer.
+ *
+ * - Every occurrence is removed; the last one wins, as `parseArgs` did.
+ * - `""` is a value, not a missing one: `--default-provider ""` disables the fallback.
+ * - A missing value, or a following token that is itself a flag, is an error, so a
+ * dangling flag never swallows the next option or leaks to Claude Code.
+ * - Scanning stops at `--`. What follows it belongs to Claude Code, as in `parseArgs`.
+ */
+export function planDefaultProviderFlag(argv: string[]): DefaultProviderFlagPlan {
+ const rest: string[] = [];
+ let value: string | undefined;
+ for (let i = 0; i < argv.length; i++) {
+ const arg = argv[i];
+ if (arg === "--") {
+ rest.push(...argv.slice(i));
+ break;
+ }
+ if (arg === DEFAULT_PROVIDER_FLAG) {
+ const next = argv[i + 1];
+ if (next === undefined || next.startsWith("-")) {
+ return {
+ kind: "error",
+ message: `${DEFAULT_PROVIDER_FLAG} requires a provider name ("" for no fallback provider)`,
+ };
+ }
+ value = next;
+ i++;
+ continue;
+ }
+ if (arg.startsWith(`${DEFAULT_PROVIDER_FLAG}=`)) {
+ value = arg.slice(DEFAULT_PROVIDER_FLAG.length + 1);
+ continue;
+ }
+ rest.push(arg);
+ }
+ return value === undefined ? { kind: "none" } : { kind: "apply", value, argv: rest };
+}
+
/**
* Legacy stub — LiteLLM auto-promotion was removed in commit 5; the hint never
* fires anymore. Kept as a no-op for callers that still import it.
diff --git a/packages/cli/src/index.ts b/packages/cli/src/index.ts
index 37c6317f..86109d9e 100644
--- a/packages/cli/src/index.ts
+++ b/packages/cli/src/index.ts
@@ -268,9 +268,40 @@ async function applyConfigOverride(): Promise<void> {
process.env.CLAUDISH_CONFIG = plan.path;
}
+// `--default-provider <name>`: strip it from argv and export it as
+// CLAUDISH_DEFAULT_PROVIDER before parseArgs and every subcommand dispatch. The env
+// variable is the ONE place the flag lives after this: route(), the proxy, `--probe`
+// and every child claudish (team, channel sessions) read it through
+// `resolveDefaultProvider`. `--probe` is why this cannot wait for parseArgs: it
+// runs and exits inside parseArgs's argv loop, so a flag read there or after it
+// never reached it, in either argv order.
+//
+// Runs AFTER the two explicit 1Password flags, which overwrite env
+// unconditionally: an --op-env or --op value for CLAUDISH_DEFAULT_PROVIDER must
+// not beat the flag the user typed.
+async function applyDefaultProviderFlag(): Promise<void> {
+ const { planDefaultProviderFlag } = await import("./default-provider.js");
+ const plan = planDefaultProviderFlag(process.argv.slice(2));
+ if (plan.kind === "none") return;
+ if (plan.kind === "error") {
+ console.error(`[claudish] ${plan.message}`);
+ process.exit(1);
+ }
+
+ process.argv = [...process.argv.slice(0, 2), ...plan.argv];
+ // An in-process env write reaches children only because they INHERIT process.env:
+ // every claudish child today is spawned through node:child_process, with
+ // `...process.env` or default inheritance. `Bun.spawn`/`Bun.spawnSync` without an
+ // `env` option DROP in-process writes (measured on Bun 1.4.0), so a future spawn
+ // written that way silently loses this flag. Pass `env: process.env` there.
+ // `""` is exported as-is: it disables the fallback hop.
+ process.env.CLAUDISH_DEFAULT_PROVIDER = plan.value;
+}
+
await traceSpan("startup:config-override", () => applyConfigOverride());
await traceSpan("startup:op-env-flags", () => applyOpEnvironment());
await traceSpan("startup:op-import-flag", () => applyOpImport());
+await traceSpan("startup:default-provider-flag", () => applyDefaultProviderFlag());
// Check for MCP mode before loading heavy dependencies
const isMcpMode = process.argv.includes("--mcp");
diff --git a/packages/cli/src/providers/routing-rules.ts b/packages/cli/src/providers/routing-rules.ts
index f98b0415..b4c49684 100644
--- a/packages/cli/src/providers/routing-rules.ts
+++ b/packages/cli/src/providers/routing-rules.ts
@@ -387,7 +387,8 @@ export const DEFAULT_FALLBACK_PROVIDER = "openrouter";
* fallback hop.
*
* Read per call, like the rules. `route()` without overrides and `--probe`'s
- * chain both read it here, so the two cannot name different fallback hops.
+ * chain both read it here, so the two cannot name different fallback hops. The
+ * `--default-provider` flag arrives through the env variable (index.ts exports it).
*/
export function effectiveDefaultProvider(): string {
return resolveDefaultProvider({ config: loadConfig(), env: process.env }).provider;
diff --git a/packages/cli/src/proxy-server.ts b/packages/cli/src/proxy-server.ts
index e054a19c..1c487833 100644
--- a/packages/cli/src/proxy-server.ts
+++ b/packages/cli/src/proxy-server.ts
@@ -583,7 +583,7 @@ export async function createProxyServer(
// them. Passing rules alone makes route() read NO default provider (its guard
// keeps this machine's setting out of tests), so before this every bare name the
// proxy routed fell back to `openrouter`, whatever `defaultProvider` said —
- // `""` included.
+ // `""` included. `--default-provider` reaches this through the env variable.
const effectiveFallbackProvider = effectiveDefaultProvider();
// Cache fallback handlers by target model string.
diff --git a/packages/cli/src/types.ts b/packages/cli/src/types.ts
index bf07ca62..7151676e 100644
--- a/packages/cli/src/types.ts
+++ b/packages/cli/src/types.ts
@@ -45,8 +45,6 @@ export interface ClaudishConfig {
*/
skipModelsUpdate?: boolean;
profile?: string; // Profile name to use for model mapping
- /** --default-provider <name> CLI flag (Phase 1 of LiteLLM-demotion refactor) */
- defaultProvider?: string;
/**
* --anthropic-api-billing: opt IN to using a real ANTHROPIC_API_KEY for native
* Claude models, accepting metered API billing. Default (false) hides the key
@@ -62,8 +60,6 @@ export interface ClaudishConfig {
* stray --op never leaks to Claude Code as a passthrough arg).
*/
opImport?: string;
- /** Resolved default provider (computed via resolveDefaultProvider() after argv parsing) */
- resolvedDefaultProvider?: import("./default-provider.js").ResolvedDefaultProvider;
claudeArgs: string[];
_hasPositionalPrompt?: boolean; // Internal: true when a positional prompt arg was found (not a flag value)
_hasPrintFlag?: boolean; // Internal: true when a passthrough -p/--print flag was found (implies single-shot, not interactive)