@golba98/codexa 1.0.1

package/src/core/providerLauncher/registry.test.ts

@@ -0,0 +1,324 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { buildProviderRegistry, getDefaultProviderId } from "./registry.js";
+import { checkLocalProvider, resetLocalProviderStateForTests } from "../providerRuntime/local.js";
+import { resetGeminiRouteValidationCacheForTests } from "../providerRuntime/gemini.js";
+import { resetGeminiExecutableCacheForTests } from "../executables/geminiExecutable.js";
+import { setProviderActiveRoute } from "./workspaceConfig.js";
+import { resolveActiveProviderRoute } from "../providerRuntime/registry.js";
+
+test("provider registry exposes the default launcher providers", () => {
+  const providers = buildProviderRegistry({ activeModel: "gpt-5.4" });
+
+  assert.deepEqual(providers.map((provider) => provider.id), ["openai", "anthropic", "google", "local"]);
+  assert.equal(providers[0]?.displayName, "OpenAI");
+  assert.equal(providers[0]?.currentModel, "gpt-5.4");
+  assert.deepEqual(providers[0]?.launchCommand, { executable: "codex", args: [] });
+  assert.deepEqual(providers[1]?.launchCommand, { executable: "claude", args: [] });
+  assert.deepEqual(providers[2]?.launchCommand, { executable: "gemini", args: [] });
+  assert.equal(providers[3]?.enabled, false);
+  assert.equal(providers[3]?.launchCommand, null);
+});
+
+test("workspace config can set the default provider", () => {
+  const providers = buildProviderRegistry({
+    activeModel: "gpt-5.4",
+    workspaceConfig: { workspaceDefaultProviderId: "anthropic" },
+  });
+
+  assert.equal(getDefaultProviderId({ workspaceDefaultProviderId: "anthropic" }), "anthropic");
+  assert.equal(providers.find((provider) => provider.id === "anthropic")?.isDefault, true);
+  assert.equal(providers.find((provider) => provider.id === "openai")?.isDefault, false);
+});
+
+test("provider registry keeps workspace default separate from active route", () => {
+  const providers = buildProviderRegistry({
+    activeModel: "gpt-5.4",
+    workspaceConfig: {
+      workspaceDefaultProviderId: "anthropic",
+      activeRoute: {
+        providerId: "openai",
+        modelId: "gpt-5.4",
+      },
+    },
+  });
+
+  assert.equal(providers.find((provider) => provider.id === "anthropic")?.isDefault, true);
+  assert.equal(providers.find((provider) => provider.id === "anthropic")?.isActiveRoute, false);
+  assert.equal(providers.find((provider) => provider.id === "openai")?.isDefault, false);
+  assert.equal(providers.find((provider) => provider.id === "openai")?.isActiveRoute, true);
+});
+
+test("unvalidated local provider remains disabled until endpoint discovery succeeds", () => {
+  resetLocalProviderStateForTests();
+  const providers = buildProviderRegistry({
+    activeModel: "gpt-5.4",
+    workspaceConfig: {
+      workspaceDefaultProviderId: "anthropic",
+      activeRoute: {
+        providerId: "local",
+        modelId: "llama-local",
+      },
+    },
+  });
+
+  assert.equal(providers.find((provider) => provider.id === "anthropic")?.isDefault, true);
+  assert.equal(providers.find((provider) => provider.id === "local")?.isActiveRoute, true);
+  assert.equal(providers.find((provider) => provider.id === "local")?.routeMode, "in-codexa");
+  assert.equal(providers.find((provider) => provider.id === "local")?.enabled, false);
+});
+
+test("google can be selected as an active in-Codexa route", () => {
+  const providers = buildProviderRegistry({
+    activeModel: "gpt-5.4",
+    workspaceConfig: {
+      activeRoute: {
+        providerId: "google",
+        modelId: "gemini-3-flash-preview",
+        backendKind: "gemini-cli-auth",
+      },
+    },
+  });
+
+  assert.equal(providers.find((provider) => provider.id === "google")?.isActiveRoute, true);
+  assert.equal(providers.find((provider) => provider.id === "google")?.routeMode, "in-codexa");
+  assert.equal(providers.find((provider) => provider.id === "google")?.currentModel, "gemini-3-flash-preview");
+  assert.equal(providers.find((provider) => provider.id === "openai")?.isActiveRoute, false);
+});
+
+test("anthropic can be selected as an active in-Codexa route", () => {
+  const providers = buildProviderRegistry({
+    activeModel: "gpt-5.4",
+    workspaceConfig: {
+      activeRoute: {
+        providerId: "anthropic",
+        modelId: "claude-sonnet-4-20250514",
+        backendKind: "anthropic-api-key",
+      },
+    },
+  });
+
+  assert.equal(providers.find((provider) => provider.id === "anthropic")?.isActiveRoute, true);
+  assert.equal(providers.find((provider) => provider.id === "anthropic")?.routeMode, "in-codexa");
+  assert.equal(providers.find((provider) => provider.id === "anthropic")?.currentModel, "claude-sonnet-4-20250514");
+  assert.equal(providers.find((provider) => provider.id === "openai")?.isActiveRoute, false);
+});
+
+
+test("discovered local models enable local provider and display selected model", async () => {
+  resetLocalProviderStateForTests();
+  const localOverride = {
+    currentModel: "google/gemma-4-26b-a4b",
+  };
+  await checkLocalProvider({
+    override: localOverride,
+    fetchImpl: (async (input) => {
+      if (String(input).includes("/api/v0/")) {
+        return new Response(null, { status: 404 });
+      }
+      return new Response(JSON.stringify({
+        data: [{ id: "google/gemma-4-26b-a4b" }],
+      }), { status: 200 });
+    }) as typeof fetch,
+  });
+
+  const providers = buildProviderRegistry({
+    activeModel: "gpt-5.4",
+    workspaceConfig: {
+      activeRoute: {
+        providerId: "local",
+        modelId: "google/gemma-4-26b-a4b",
+        backendKind: "local-openai-compatible",
+      },
+      providers: {
+        local: localOverride,
+      },
+    },
+  });
+
+  const local = providers.find((provider) => provider.id === "local");
+  assert.equal(local?.enabled, true);
+  assert.equal(local?.currentModel, "google/gemma-4-26b-a4b");
+  assert.equal(local?.backendType, "local-openai-compatible");
+  assert.equal(local?.statusLabel, "Enabled");
+  assert.deepEqual(local?.launchCommand, null);
+  resetLocalProviderStateForTests();
+});
+
+test("LM Studio loaded Local model replaces stale active route in provider registry", async () => {
+  resetLocalProviderStateForTests();
+  try {
+    await checkLocalProvider({
+      override: {
+        currentModel: "google/gemma-4-26b-a4b",
+        defaultModel: "google/gemma-4-26b-a4b",
+        baseUrl: "http://localhost:1234/v1",
+      },
+      fetchImpl: (async (input) => {
+        if (String(input).includes("/api/v0/")) {
+          return new Response(JSON.stringify({
+            data: [{
+              id: "qwen/qwen3.6-27b",
+              state: "loaded",
+              loaded_context_length: 32000,
+              max_context_length: 262144,
+              capabilities: ["tool_use"],
+            }],
+            object: "list",
+          }), { status: 200 });
+        }
+        return new Response(JSON.stringify({
+          data: [{ id: "google/gemma-4-26b-a4b" }, { id: "qwen/qwen3.6-27b" }],
+        }), { status: 200 });
+      }) as typeof fetch,
+    });
+
+    const providers = buildProviderRegistry({
+      activeModel: "gpt-5.4",
+      workspaceConfig: {
+        activeRoute: {
+          providerId: "local",
+          modelId: "google/gemma-4-26b-a4b",
+          backendKind: "local-openai-compatible",
+        },
+        providers: {
+          local: {
+            currentModel: "google/gemma-4-26b-a4b",
+            defaultModel: "google/gemma-4-26b-a4b",
+            baseUrl: "http://localhost:1234/v1",
+          },
+        },
+      },
+    });
+
+    const local = providers.find((provider) => provider.id === "local");
+    assert.equal(local?.currentModel, "qwen/qwen3.6-27b");
+    assert.equal(local?.contextLengthLabel, "32,000");
+    assert.equal(local?.contextLengthSource, "lmstudio-api");
+    assert.equal(local?.capabilityProfile?.supportsToolCalls, true);
+    assert.equal(local?.capabilityProfile?.supportsVision, null);
+  } finally {
+    resetLocalProviderStateForTests();
+  }
+});
+
+// ─── Provider status label / color sync tests ────────────────────────────────
+
+async function withNoGeminiConfig<T>(callback: () => T | Promise<T>): Promise<T> {
+  const savedGemini = process.env.GEMINI_API_KEY;
+  const savedGoogle = process.env.GOOGLE_API_KEY;
+  const savedExe = process.env.GEMINI_EXECUTABLE;
+  const savedCliPath = process.env.GEMINI_CLI_PATH;
+  try {
+    delete process.env.GEMINI_API_KEY;
+    delete process.env.GOOGLE_API_KEY;
+    delete process.env.GEMINI_EXECUTABLE;
+    delete process.env.GEMINI_CLI_PATH;
+    resetGeminiRouteValidationCacheForTests();
+    resetGeminiExecutableCacheForTests();
+    return await callback();
+  } finally {
+    if (savedGemini === undefined) delete process.env.GEMINI_API_KEY; else process.env.GEMINI_API_KEY = savedGemini;
+    if (savedGoogle === undefined) delete process.env.GOOGLE_API_KEY; else process.env.GOOGLE_API_KEY = savedGoogle;
+    if (savedExe === undefined) delete process.env.GEMINI_EXECUTABLE; else process.env.GEMINI_EXECUTABLE = savedExe;
+    if (savedCliPath === undefined) delete process.env.GEMINI_CLI_PATH; else process.env.GEMINI_CLI_PATH = savedCliPath;
+    resetGeminiRouteValidationCacheForTests();
+    resetGeminiExecutableCacheForTests();
+  }
+}
+
+test("google shows 'Needs config' statusLabel when no API key or CLI validation is present", async () => {
+  await withNoGeminiConfig(() => {
+    const providers = buildProviderRegistry({ activeModel: "gpt-5.4" });
+    const google = providers.find((p) => p.id === "google");
+    assert.equal(google?.statusLabel, "Needs config");
+    assert.notEqual(google?.routeUnavailableReason, null);
+  });
+});
+
+test("google shows 'Enabled' statusLabel when GEMINI_API_KEY is set", async () => {
+  const saved = process.env.GEMINI_API_KEY;
+  try {
+    process.env.GEMINI_API_KEY = "test-key";
+    resetGeminiRouteValidationCacheForTests();
+    const providers = buildProviderRegistry({ activeModel: "gpt-5.4" });
+    const google = providers.find((p) => p.id === "google");
+    assert.equal(google?.statusLabel, "Enabled");
+    assert.equal(google?.routeUnavailableReason, null);
+  } finally {
+    if (saved === undefined) delete process.env.GEMINI_API_KEY; else process.env.GEMINI_API_KEY = saved;
+    resetGeminiRouteValidationCacheForTests();
+  }
+});
+
+test("google 'Needs config' survives workspace config override with no enabled field", async () => {
+  await withNoGeminiConfig(() => {
+    const providers = buildProviderRegistry({
+      activeModel: "gpt-5.4",
+      workspaceConfig: {
+        providers: {
+          google: { currentModel: "gemini-3-flash-preview", currentReasoning: "medium" },
+        },
+      },
+    });
+    const google = providers.find((p) => p.id === "google");
+    assert.equal(google?.statusLabel, "Needs config");
+    assert.notEqual(google?.routeUnavailableReason, null);
+  });
+});
+
+test("'Active' text is display-layer only — registry statusLabel stays 'Enabled' for active route when configured", async () => {
+  const saved = process.env.GEMINI_API_KEY;
+  try {
+    process.env.GEMINI_API_KEY = "test-key";
+    resetGeminiRouteValidationCacheForTests();
+    const providers = buildProviderRegistry({
+      activeModel: "gpt-5.4",
+      workspaceConfig: {
+        activeRoute: { providerId: "google", modelId: "gemini-3-flash-preview", backendKind: "gemini-cli-auth" },
+      },
+    });
+    const google = providers.find((p) => p.id === "google");
+    assert.equal(google?.isActiveRoute, true);
+    assert.equal(google?.statusLabel, "Enabled");
+  } finally {
+    if (saved === undefined) delete process.env.GEMINI_API_KEY; else process.env.GEMINI_API_KEY = saved;
+    resetGeminiRouteValidationCacheForTests();
+  }
+});
+
+test("resolveActiveProviderRoute returns google route when configured via API key", async () => {
+  const saved = process.env.GEMINI_API_KEY;
+  try {
+    process.env.GEMINI_API_KEY = "test-key";
+    resetGeminiRouteValidationCacheForTests();
+    const route = resolveActiveProviderRoute({
+      workspaceConfigActiveRoute: {
+        providerId: "google",
+        modelId: "gemini-3-flash-preview",
+        backendKind: "gemini-cli-auth",
+      },
+      currentModel: "gpt-5.4",
+      currentReasoning: "medium",
+    });
+    assert.equal(route.providerId, "google");
+    assert.equal(route.modelId, "gemini-3-flash-preview");
+  } finally {
+    if (saved === undefined) delete process.env.GEMINI_API_KEY; else process.env.GEMINI_API_KEY = saved;
+    resetGeminiRouteValidationCacheForTests();
+  }
+});
+
+test("setProviderActiveRoute does not update activeRoute when google is not configured", async () => {
+  await withNoGeminiConfig(() => {
+    const original: import("./types.js").ProviderWorkspaceConfig = {
+      activeRoute: { providerId: "openai", modelId: "gpt-5.4", backendKind: "codex-cli-auth" },
+    };
+    const result = setProviderActiveRoute(original, {
+      providerId: "google",
+      modelId: "gemini-3-flash-preview",
+      backendKind: "gemini-cli-auth",
+    });
+    assert.equal(result.activeRoute?.providerId, "openai");
+  });
+});

package/src/core/providerLauncher/registry.ts

@@ -0,0 +1,253 @@
+import type {
+  ProviderConfig,
+  ProviderId,
+  ProviderBackendType,
+  ProviderLaunchCommand,
+  ProviderWorkspaceConfig,
+  ProviderWorkspaceOverride,
+} from "./types.js";
+import { DEFAULT_MODEL } from "../../config/settings.js";
+import {
+  getDefaultRouteModel,
+  getProviderRouteSetupMessage,
+  getProviderRuntime,
+  isProviderRoutableInCodexa,
+  isProviderRouteConfigured,
+} from "../providerRuntime/registry.js";
+import { normalizeGeminiModelId } from "../providerRuntime/models.js";
+import { setLocalProviderConfig } from "../providerRuntime/local.js";
+import { formatContextLength, resolveModelContextLengthCached } from "../providerRuntime/contextMetadata.js";
+import { resolveModelCapabilityProfileCached } from "../providerRuntime/capabilityProfile.js";
+
+const PROVIDER_ORDER: readonly ProviderId[] = ["openai", "anthropic", "google", "local"];
+
+const DEFAULT_PROVIDER_ID: ProviderId = "openai";
+
+type ProviderDefault = Omit<ProviderConfig, "currentModel" | "enabled" | "statusLabel" | "launchCommand" | "isDefault"> & {
+  currentModel: (activeModel: string) => string;
+  enabled: boolean;
+  launchCommand: ProviderLaunchCommand | null;
+};
+
+const DEFAULT_PROVIDERS: Record<ProviderId, ProviderDefault> = {
+  openai: {
+    id: "openai",
+    displayName: "OpenAI",
+    currentModel: (activeModel) => activeModel,
+    backendType: "codex-cli-auth",
+    routeMode: "in-codexa",
+    enabled: true,
+    launchCommand: { executable: "codex", args: [] },
+    isActiveRoute: false,
+    routeUnavailableReason: null,
+  },
+  anthropic: {
+    id: "anthropic",
+    displayName: "Anthropic",
+    currentModel: () => "Claude Code default",
+    backendType: "claude-code-auth",
+    routeMode: "in-codexa",
+    enabled: true,
+    launchCommand: { executable: "claude", args: [] },
+    isActiveRoute: false,
+    routeUnavailableReason: null,
+  },
+  google: {
+    id: "google",
+    displayName: "Google",
+    currentModel: () => "gemini-3-flash-preview",
+    backendType: "gemini-cli-auth",
+    routeMode: "in-codexa",
+    enabled: true,
+    launchCommand: { executable: "gemini", args: [] },
+    isActiveRoute: false,
+    routeUnavailableReason: null,
+  },
+  local: {
+    id: "local",
+    displayName: "Local",
+    currentModel: () => "Local default",
+    backendType: "local-openai-compatible",
+    routeMode: "in-codexa",
+    enabled: false,
+    launchCommand: null,
+    isActiveRoute: false,
+    routeUnavailableReason: "Local provider unavailable. Start LM Studio, load a model, and enable the local server.",
+  },
+};
+
+function isProviderId(value: unknown): value is ProviderId {
+  return typeof value === "string" && PROVIDER_ORDER.includes(value as ProviderId);
+}
+
+function normalizeLaunchCommand(value: ProviderWorkspaceOverride["command"] | undefined): ProviderLaunchCommand | null | undefined {
+  if (value === undefined) return undefined;
+  if (value === null) return null;
+  if (typeof value === "string") {
+    const executable = value.trim();
+    return executable ? { executable, args: [] } : null;
+  }
+  if (typeof value.executable !== "string") return undefined;
+  const executable = value.executable.trim();
+  if (!executable) return null;
+  return {
+    executable,
+    args: Array.isArray(value.args)
+      ? value.args.filter((arg): arg is string => typeof arg === "string")
+      : [],
+  };
+}
+
+function applyOverride(
+  provider: ProviderConfig,
+  override: ProviderWorkspaceOverride | undefined,
+): ProviderConfig {
+  if (!override) return provider;
+
+  const launchCommand = normalizeLaunchCommand(override.command);
+  const hasConfiguredCommand = launchCommand !== undefined;
+  const nextCommand = hasConfiguredCommand ? launchCommand : provider.launchCommand;
+  const nextEnabled = typeof override.enabled === "boolean"
+    ? provider.id === "local" ? provider.enabled && override.enabled : override.enabled
+    : provider.enabled;
+
+  const overrideModel = typeof override.currentModel === "string" && override.currentModel.trim()
+    ? override.currentModel.trim()
+    : null;
+
+  return {
+    ...provider,
+    currentModel: overrideModel && provider.id !== "local"
+      ? provider.id === "google" ? normalizeGeminiModelId(overrideModel) : overrideModel
+      : provider.currentModel,
+    enabled: nextEnabled,
+    launchCommand: nextCommand,
+    statusLabel: nextEnabled
+      ? (provider.routeUnavailableReason ? "Needs config" : "Enabled")
+      : "Disabled",
+  };
+}
+
+export function getDefaultProviderId(config: ProviderWorkspaceConfig | null | undefined): ProviderId {
+  return isProviderId(config?.workspaceDefaultProviderId) ? config.workspaceDefaultProviderId : DEFAULT_PROVIDER_ID;
+}
+
+export function getActiveRouteProviderId(config: ProviderWorkspaceConfig | null | undefined): ProviderId {
+  const providerId = config?.activeRoute?.providerId;
+  return isProviderId(providerId) && isProviderRoutableInCodexa(providerId)
+    ? providerId
+    : DEFAULT_PROVIDER_ID;
+}
+
+export function buildProviderRegistry(options: {
+  activeModel: string;
+  workspaceConfig?: ProviderWorkspaceConfig | null;
+  diagnostics?: Record<string, Record<string, string | number | boolean | null>>;
+  routeErrors?: Record<string, string>;
+}): ProviderConfig[] {
+  const defaultProviderId = getDefaultProviderId(options.workspaceConfig);
+  const activeRouteProviderId = getActiveRouteProviderId(options.workspaceConfig);
+
+  return PROVIDER_ORDER.map((id) => {
+    if (id === "local") {
+      setLocalProviderConfig(options.workspaceConfig?.providers?.local);
+    }
+    const defaults = DEFAULT_PROVIDERS[id];
+    const runtime = getProviderRuntime(id);
+    const discovery = runtime.discoverModels();
+
+    const activeRoute = options.workspaceConfig?.activeRoute;
+    const isThisActive = activeRoute?.providerId === id;
+
+    let currentModelLabel = isThisActive && activeRoute
+      ? activeRoute.modelId
+      : getDefaultRouteModel(id, id === "openai" ? DEFAULT_MODEL : defaults.currentModel(options.activeModel));
+
+    if (id === "google") {
+      // Use the active route's model selection when this provider is active, or when
+      // the workspace config has no explicit Google model override.
+      const hasGoogleOverride = options.workspaceConfig?.providers?.google?.currentModel !== undefined;
+      const geminiRoute = isThisActive || !hasGoogleOverride ? activeRoute : null;
+      const selection = geminiRoute?.modelSelection;
+      if (selection) {
+        if (selection.kind === "auto") {
+          currentModelLabel = `Auto (${selection.family === "gemini-3" ? "Gemini 3" : "Gemini 2.5"})`;
+        } else {
+          currentModelLabel = normalizeGeminiModelId(selection.modelId);
+        }
+      } else {
+        currentModelLabel = normalizeGeminiModelId(currentModelLabel);
+      }
+    }
+
+    if (id === "local") {
+      const selectedModel = typeof discovery.diagnostics?.selectedModel === "string" && discovery.diagnostics.selectedModel.trim()
+        ? discovery.diagnostics.selectedModel.trim()
+        : discovery.models[0]?.modelId;
+      if (selectedModel) {
+        currentModelLabel = selectedModel;
+      }
+    }
+
+    const rawMetadataForModel = discovery.models.find((model) => model.modelId === currentModelLabel)?.raw;
+    const contextMetadata = resolveModelContextLengthCached({
+      providerId: id,
+      modelId: currentModelLabel,
+      providerConfig: options.workspaceConfig?.providers?.[id],
+      rawMetadata: rawMetadataForModel,
+    });
+    const contextSource = contextMetadata.source === "known-registry" ? "registry" : contextMetadata.source;
+    const capabilityProfile = resolveModelCapabilityProfileCached({
+      providerId: id,
+      modelId: currentModelLabel,
+      providerConfig: options.workspaceConfig?.providers?.[id],
+      rawMetadata: rawMetadataForModel,
+    });
+
+    const routeUnavailableReason: string | null = runtime.routeAvailable
+      ? (isProviderRouteConfigured(id)
+          ? null
+          : (options.routeErrors?.[id]
+            ?? discovery.message
+            ?? getProviderRouteSetupMessage(id)))
+      : runtime.routeStatus;
+
+    const enabled = id === "local" ? discovery.status === "ready" : defaults.enabled;
+
+    const statusLabel = id === "local"
+      ? (discovery.status === "ready" ? "Enabled" : "Disabled")
+      : !defaults.enabled
+        ? "Disabled"
+        : routeUnavailableReason
+          ? "Needs config"
+          : "Enabled";
+
+    const provider: ProviderConfig = {
+      id,
+      displayName: defaults.displayName,
+      currentModel: currentModelLabel,
+      contextLengthLabel: formatContextLength(contextMetadata.contextLength),
+      contextLengthSource: contextSource,
+      capabilityProfile,
+      backendType: discovery.backendKind as ProviderBackendType,
+      routeMode: runtime.routeAvailable ? "in-codexa" : "launch-only",
+      enabled,
+      statusLabel,
+      launchCommand: defaults.launchCommand ? { ...defaults.launchCommand, args: [...defaults.launchCommand.args] } : null,
+      isDefault: id === defaultProviderId,
+      isActiveRoute: id === activeRouteProviderId,
+      routeUnavailableReason,
+      routeDiagnostics: options.diagnostics?.[id],
+    };
+
+    return applyOverride(provider, options.workspaceConfig?.providers?.[id]);
+  });
+}
+
+export function findProvider(providers: readonly ProviderConfig[], providerId: ProviderId): ProviderConfig | null {
+  return providers.find((provider) => provider.id === providerId) ?? null;
+}
+
+export function isKnownProviderId(value: string): value is ProviderId {
+  return isProviderId(value);
+}

package/src/core/providerLauncher/types.ts

@@ -0,0 +1,84 @@
+export type ProviderId = "openai" | "anthropic" | "google" | "local";
+
+export type ProviderBackendType =
+  | "codex-cli-auth"
+  | "gemini-cli-auth"
+  | "claude-code-auth"
+  | "openai-api-key"
+  | "gemini-api-key"
+  | "anthropic-api-key"
+  | "local-openai-compatible"
+  | "unavailable";
+
+export type ProviderLaunchAction = "launch" | "set-default" | "cancel";
+export type ProviderRouteAction = "use-in-codexa" | "select-model" | "refresh-models" | "run-diagnostics";
+export type ProviderPickerAction = ProviderLaunchAction | ProviderRouteAction;
+export type ProviderRouteMode = "in-codexa" | "launch-only";
+
+export interface ProviderLaunchCommand {
+  executable: string;
+  args: string[];
+}
+
+export interface ProviderConfig {
+  id: ProviderId;
+  displayName: string;
+  currentModel: string;
+  contextLengthLabel?: string;
+  contextLengthSource?: string;
+  capabilityProfile?: import("../providerRuntime/capabilityProfile.js").ModelCapabilityProfile;
+  backendType: ProviderBackendType;
+  routeMode: ProviderRouteMode;
+  enabled: boolean;
+  statusLabel: string;
+  launchCommand: ProviderLaunchCommand | null;
+  isDefault: boolean;
+  isActiveRoute: boolean;
+  routeUnavailableReason: string | null;
+  routeDiagnostics?: Record<string, string | number | boolean | null>;
+}
+
+export interface ProviderWorkspaceConfig {
+  workspaceDefaultProviderId?: ProviderId;
+  activeRoute?: ProviderActiveRoute;
+  providers?: Partial<Record<ProviderId, ProviderWorkspaceOverride>>;
+  migrationNotice?: ProviderWorkspaceMigrationNotice;
+}
+
+export interface ProviderWorkspaceMigrationNotice {
+  deprecatedProviderId: string;
+  revertedProviderId: ProviderId;
+}
+
+export interface ProviderActiveRoute {
+  providerId: ProviderId;
+  modelId: string;
+  backendKind?: import("../providerRuntime/types.js").ProviderBackendKind;
+  reasoning?: string;
+  modelSelection?: import("../providerRuntime/types.js").GeminiModelSelection;
+}
+
+export interface ProviderWorkspaceOverride {
+  currentModel?: string;
+  currentReasoning?: string;
+  enabled?: boolean;
+  type?: "openai-compatible";
+  baseUrl?: string;
+  apiKey?: string;
+  pinnedModel?: string;
+  defaultModel?: string;
+  models?: Record<string, ProviderModelWorkspaceOverride>;
+  command?: string | ProviderLaunchCommand | null;
+  claudeCommandPath?: string;
+  geminiCommandPath?: string;
+  codexCommandPath?: string;
+}
+
+export interface ProviderModelWorkspaceOverride {
+  contextLength?: number;
+  maxOutputTokens?: number;
+  supportsStreaming?: boolean;
+  supportsToolCalls?: boolean;
+  supportsSystemPrompt?: boolean;
+  supportsVision?: boolean;
+}