@golba98/codexa 1.0.1

package/src/core/providerRuntime/models.ts

@@ -0,0 +1,150 @@
+import type { CodexModelCapability, CodexModelCapabilities } from "../models/codexModelCapabilities.js";
+import type { ProviderModel } from "./types.js";
+import { getClaudeCodeEffortLevels } from "./reasoning.js";
+
+export const GEMINI_DEFAULT_MODEL_ID = "gemini-3-flash-preview";
+export const GEMINI_VERIFIED_MODEL_IDS = [
+  "gemini-3.1-pro-preview",
+  "gemini-3-flash-preview",
+  "gemini-3.1-flash-lite-preview",
+  "gemini-2.5-pro",
+  "gemini-2.5-flash",
+  "gemini-2.5-flash-lite",
+] as const;
+
+export function isVerifiedGeminiModelId(modelId: string | null | undefined): modelId is typeof GEMINI_VERIFIED_MODEL_IDS[number] {
+  return typeof modelId === "string" && GEMINI_VERIFIED_MODEL_IDS.includes(modelId as typeof GEMINI_VERIFIED_MODEL_IDS[number]);
+}
+
+export function normalizeGeminiModelId(modelId: string | null | undefined): string {
+  // "gemini-3-flash" is an older shorthand; remap it to the canonical preview ID.
+  if (modelId === "gemini-3-flash") return "gemini-3-flash-preview";
+  return isVerifiedGeminiModelId(modelId) ? modelId : GEMINI_DEFAULT_MODEL_ID;
+}
+
+export const GEMINI_FALLBACK_MODELS: readonly ProviderModel[] = [
+  {
+    id: "gemini-3-flash-preview",
+    modelId: "gemini-3-flash-preview",
+    label: "Gemini 3 Flash Preview",
+    description: "Verified Gemini CLI Flash Preview route.",
+    defaultReasoningLevel: "medium",
+    supportedReasoningLevels: null,
+  },
+  {
+    id: "gemini-3.1-pro-preview",
+    modelId: "gemini-3.1-pro-preview",
+    label: "Gemini 3.1 Pro Preview",
+    description: "Verified Gemini CLI Pro Preview route.",
+    defaultReasoningLevel: "high",
+    supportedReasoningLevels: null,
+  },
+  {
+    id: "gemini-3.1-flash-lite-preview",
+    modelId: "gemini-3.1-flash-lite-preview",
+    label: "Gemini 3.1 Flash Lite Preview",
+    description: "Verified Gemini CLI Flash Lite Preview route.",
+    defaultReasoningLevel: "medium",
+    supportedReasoningLevels: null,
+  },
+  {
+    id: "gemini-2.5-pro",
+    modelId: "gemini-2.5-pro",
+    label: "Gemini 2.5 Pro",
+    description: "Verified Gemini CLI Pro route.",
+    defaultReasoningLevel: "high",
+    supportedReasoningLevels: null,
+  },
+  {
+    id: "gemini-2.5-flash",
+    modelId: "gemini-2.5-flash",
+    label: "Gemini 2.5 Flash",
+    description: "Verified Gemini CLI Flash route.",
+    defaultReasoningLevel: "medium",
+    supportedReasoningLevels: null,
+  },
+  {
+    id: "gemini-2.5-flash-lite",
+    modelId: "gemini-2.5-flash-lite",
+    label: "Gemini 2.5 Flash Lite",
+    description: "Verified Gemini CLI Flash Lite route.",
+    defaultReasoningLevel: "medium",
+    supportedReasoningLevels: null,
+  },
+] as const;
+
+export const ANTHROPIC_FALLBACK_MODELS: readonly ProviderModel[] = [
+  {
+    id: "opus",
+    modelId: "opus",
+    label: "Opus 4.7",
+    description: "Claude Opus 4.7 - Fallback defaults",
+    defaultReasoningLevel: "xhigh",
+    supportedReasoningLevels: getClaudeCodeEffortLevels(["low", "medium", "high", "xhigh", "max"]),
+    source: "fallback",
+    canonicalId: "claude-opus-4-7",
+    family: "opus",
+    effortSource: "fallback",
+    effortVerified: false,
+  },
+  {
+    id: "sonnet",
+    modelId: "sonnet",
+    label: "Sonnet 4.6",
+    description: "Claude Sonnet 4.6 - Fallback defaults",
+    defaultReasoningLevel: "high",
+    supportedReasoningLevels: getClaudeCodeEffortLevels(["low", "medium", "high", "max"]),
+    source: "fallback",
+    canonicalId: "claude-sonnet-4-6",
+    family: "sonnet",
+    effortSource: "fallback",
+    effortVerified: false,
+  },
+  {
+    id: "haiku",
+    modelId: "haiku",
+    label: "Haiku 4.5",
+    description: "Claude Haiku 4.5 - Fallback defaults; effort metadata unverified",
+    defaultReasoningLevel: "medium",
+    supportedReasoningLevels: getClaudeCodeEffortLevels(["low", "medium", "high"]),
+    source: "fallback",
+    canonicalId: "claude-haiku-4-5",
+    family: "haiku",
+    effortSource: "fallback",
+    effortVerified: false,
+  },
+] as const;
+
+function isRuntimeSource(source: ProviderModel["source"]): boolean {
+  return source === "discovered" || source === "claude-code" || source === "settings" || source === "config";
+}
+
+export function providerModelsToCodexCapabilities(
+  models: readonly ProviderModel[],
+  currentModel: string,
+): CodexModelCapabilities {
+  const capabilities: readonly CodexModelCapability[] = models.map((model, index) => ({
+    id: model.id,
+    model: model.modelId,
+    label: model.label,
+    description: model.description,
+    available: true,
+    hidden: false,
+    isDefault: model.modelId === currentModel || (!currentModel && index === 0),
+    defaultReasoningLevel: model.defaultReasoningLevel,
+    supportedReasoningLevels: model.supportedReasoningLevels,
+    reasoningLevelCount: model.supportedReasoningLevels ? model.supportedReasoningLevels.length : null,
+    source: isRuntimeSource(model.source) ? "runtime" : "fallback",
+    raw: model,
+  }));
+
+  const anyDiscovered = models.some((m) => isRuntimeSource(m.source));
+  return {
+    status: "ready",
+    source: anyDiscovered ? "runtime" : "fallback",
+    models: capabilities,
+    discoveredAt: Date.now(),
+    executable: null,
+    error: null,
+  };
+}

package/src/core/providerRuntime/reasoning.ts

@@ -0,0 +1,17 @@
+import type { ReasoningEffortCapability } from "../models/codexModelCapabilities.js";
+
+export const CLAUDE_CODE_EFFORT_LEVELS: readonly ReasoningEffortCapability[] = [
+  { id: "low", label: "Low", description: "Claude Code low effort." },
+  { id: "medium", label: "Medium", description: "Claude Code medium effort." },
+  { id: "high", label: "High", description: "Claude Code high effort." },
+  { id: "xhigh", label: "XHigh", description: "Claude Code extra-high effort." },
+  { id: "max", label: "Max", description: "Claude Code maximum effort." },
+] as const;
+
+export const CLAUDE_CODE_EFFORT_IDS = new Set(CLAUDE_CODE_EFFORT_LEVELS.map((level) => level.id));
+
+export function getClaudeCodeEffortLevels(ids: readonly string[]): readonly ReasoningEffortCapability[] {
+  return ids
+    .map((id) => CLAUDE_CODE_EFFORT_LEVELS.find((level) => level.id === id))
+    .filter((level): level is ReasoningEffortCapability => Boolean(level));
+}

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

@@ -0,0 +1,233 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  discoverProviderModels,
+  getProviderRouteSetupMessage,
+  getProviderRuntime,
+  isProviderRouteConfigured,
+  resolveActiveProviderRoute,
+} from "./registry.js";
+import { resetGeminiRouteValidationCacheForTests } from "./gemini.js";
+import { resetAnthropicRouteValidationCacheForTests } from "./anthropic.js";
+import { checkLocalProvider, resetLocalProviderStateForTests } from "./local.js";
+
+test("google runtime exposes configured Gemini models for in-Codexa routing", () => {
+  const runtime = getProviderRuntime("google");
+  const discovery = discoverProviderModels("google");
+
+  assert.equal(runtime.routeAvailable, true);
+  assert.equal(runtime.backendKind, "gemini-cli-auth");
+  assert.equal(discovery.status, "ready");
+  assert.ok(discovery.models.length > 0);
+});
+
+test("anthropic runtime exposes configured Claude models for in-Codexa routing", () => {
+  const runtime = getProviderRuntime("anthropic");
+  const discovery = discoverProviderModels("anthropic");
+
+  assert.equal(runtime.routeAvailable, true);
+  assert.equal(runtime.backendKind, "claude-code-auth");
+  assert.equal(discovery.status, "ready");
+  assert.ok(discovery.models.length > 0);
+});
+
+test("active route resolution preserves routable google routes", () => {
+  const route = resolveActiveProviderRoute({
+    workspaceConfigActiveRoute: {
+      providerId: "google",
+      modelId: "gemini-2.5-pro",
+      backendKind: "gemini-cli-auth",
+      reasoning: "medium",
+    },
+    currentModel: "gpt-5.4",
+    currentReasoning: "high",
+  });
+
+  assert.deepEqual(route, {
+    providerId: "google",
+    modelId: "gemini-2.5-pro",
+    backendKind: "gemini-cli-auth",
+    reasoning: "medium",
+  });
+});
+
+test("active route resolution normalizes legacy Gemini 3 Flash routes to preview", () => {
+  const route = resolveActiveProviderRoute({
+    workspaceConfigActiveRoute: {
+      providerId: "google",
+      modelId: "gemini-3-flash",
+      backendKind: "gemini-cli-auth",
+      reasoning: "high",
+    },
+    currentModel: "gpt-5.4",
+    currentReasoning: "medium",
+  });
+
+  assert.deepEqual(route, {
+    providerId: "google",
+    modelId: "gemini-3-flash-preview",
+    backendKind: "gemini-cli-auth",
+    reasoning: "high",
+  });
+});
+
+test("active route resolution preserves routable anthropic routes", () => {
+  const route = resolveActiveProviderRoute({
+    workspaceConfigActiveRoute: {
+      providerId: "anthropic",
+      modelId: "claude-sonnet-4-20250514",
+      backendKind: "anthropic-api-key",
+      reasoning: "high",
+    },
+    currentModel: "gpt-5.4",
+    currentReasoning: "medium",
+  });
+
+  assert.deepEqual(route, {
+    providerId: "anthropic",
+    modelId: "claude-sonnet-4-20250514",
+    backendKind: "anthropic-api-key",
+    reasoning: "high",
+  });
+});
+
+test("active route resolution preserves routable local routes", async () => {
+  resetLocalProviderStateForTests();
+  await checkLocalProvider({
+    fetchImpl: (async () => new Response(JSON.stringify({
+      data: [{ id: "llama-local" }],
+    }), { status: 200 })) as typeof fetch,
+  });
+  const route = resolveActiveProviderRoute({
+    workspaceConfigActiveRoute: {
+      providerId: "local",
+      modelId: "llama-local",
+      backendKind: "local-openai-compatible",
+    },
+    currentModel: "gpt-5.4",
+    currentReasoning: "high",
+  });
+
+  assert.deepEqual(route, {
+    providerId: "local",
+    modelId: "llama-local",
+    backendKind: "local-openai-compatible",
+  });
+  resetLocalProviderStateForTests();
+});
+
+// ─── CLI --model override precedence ─────────────────────────────────────────
+// These tests mirror the app-level logic: when --model is given on the CLI,
+// the caller constructs effectiveRoute = { ...savedRoute, modelId: cliModel }
+// before passing it to resolveActiveProviderRoute. The tests verify the resolver
+// honours that override correctly.
+
+test("CLI model override wins over persisted OpenAI activeRoute model", () => {
+  // Simulate: providers.json has gpt-5.4-mini, but user ran --model gpt-5.5
+  const cliModel = "gpt-5.5";
+  const savedRoute = {
+    providerId: "openai" as const,
+    modelId: "gpt-5.4-mini",
+    backendKind: "codex-cli-auth" as const,
+    reasoning: "low",
+  };
+  const effectiveRoute = { ...savedRoute, modelId: cliModel };
+
+  const route = resolveActiveProviderRoute({
+    workspaceConfigActiveRoute: effectiveRoute,
+    currentModel: "gpt-5.5",
+    currentReasoning: "low",
+  });
+
+  assert.equal(route.modelId, "gpt-5.5", "CLI model must be used for the run, not providers.json model");
+  assert.equal(route.providerId, "openai");
+});
+
+test("without CLI model override the persisted providers.json activeRoute model is used", () => {
+  const savedRoute = {
+    providerId: "openai" as const,
+    modelId: "gpt-5.4-mini",
+    backendKind: "codex-cli-auth" as const,
+    reasoning: "low",
+  };
+
+  const route = resolveActiveProviderRoute({
+    workspaceConfigActiveRoute: savedRoute,
+    currentModel: "gpt-5.4",
+    currentReasoning: "high",
+  });
+
+  assert.equal(route.modelId, "gpt-5.4-mini", "Without CLI override, persisted model must win over layered-config default");
+});
+
+test("CLI model override preserves provider from providers.json activeRoute", () => {
+  // --model on the CLI should not change the provider, only the modelId
+  const cliModel = "gpt-5.5";
+  const savedRoute = {
+    providerId: "openai" as const,
+    modelId: "gpt-5.4-mini",
+    backendKind: "codex-cli-auth" as const,
+    reasoning: "low",
+  };
+  const effectiveRoute = { ...savedRoute, modelId: cliModel };
+
+  const route = resolveActiveProviderRoute({
+    workspaceConfigActiveRoute: effectiveRoute,
+    currentModel: cliModel,
+    currentReasoning: "low",
+  });
+
+  assert.equal(route.providerId, "openai", "Provider from providers.json must be preserved");
+  assert.equal(route.modelId, cliModel);
+  assert.equal(route.reasoning, "low", "Reasoning from providers.json must be preserved");
+});
+
+// ─── Authentication and setup gates ──────────────────────────────────────────
+
+test("anthropic route configuration is gated by ANTHROPIC_API_KEY or Claude Code", () => {
+  const original = process.env.ANTHROPIC_API_KEY;
+
+  try {
+    delete process.env.ANTHROPIC_API_KEY;
+    resetAnthropicRouteValidationCacheForTests();
+    assert.equal(isProviderRouteConfigured("anthropic"), false);
+    assert.match(getProviderRouteSetupMessage("anthropic"), /set ANTHROPIC_API_KEY/);
+  } finally {
+    if (original) process.env.ANTHROPIC_API_KEY = original;
+  }
+});
+
+test("google route configuration is gated by Gemini API key or validated headless CLI", () => {
+  const originalGemini = process.env.GEMINI_API_KEY;
+  const originalGoogle = process.env.GOOGLE_API_KEY;
+
+  try {
+    delete process.env.GEMINI_API_KEY;
+    delete process.env.GOOGLE_API_KEY;
+    resetGeminiRouteValidationCacheForTests();
+    assert.equal(isProviderRouteConfigured("google"), false);
+    assert.match(getProviderRouteSetupMessage("google"), /GEMINI_API_KEY \/ GOOGLE_API_KEY/);
+  } finally {
+    if (originalGemini) process.env.GEMINI_API_KEY = originalGemini;
+    if (originalGoogle) process.env.GOOGLE_API_KEY = originalGoogle;
+  }
+});
+
+test("local route configuration is gated by endpoint model discovery", async () => {
+  resetLocalProviderStateForTests();
+  assert.equal(isProviderRouteConfigured("local"), false);
+
+  await checkLocalProvider({
+    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,
+  });
+
+  assert.equal(isProviderRouteConfigured("local"), true);
+  resetLocalProviderStateForTests();
+});

package/src/core/providerRuntime/registry.ts

@@ -0,0 +1,203 @@
+import { codexSubprocessProvider } from "../providers/codexSubprocess.js";
+import type { BackendRunHandlers } from "../providers/types.js";
+import type { ProviderId, ProviderActiveRoute, ProviderWorkspaceOverride } from "../providerLauncher/types.js";
+import { anthropicRuntime } from "./anthropic.js";
+import { geminiRuntime } from "./gemini.js";
+import { localRuntime } from "./local.js";
+import {
+  ANTHROPIC_FALLBACK_MODELS,
+  GEMINI_DEFAULT_MODEL_ID,
+  GEMINI_FALLBACK_MODELS,
+  normalizeGeminiModelId,
+} from "./models.js";
+import type {
+  ActiveProviderRoute,
+  GeminiModelSelection,
+  ProviderChatRequest,
+  ProviderModelDiscoveryResult,
+  ProviderRoute,
+  ProviderRouteValidationResult,
+  ProviderRuntime,
+} from "./types.js";
+
+const openAiRuntime: ProviderRuntime = {
+  providerId: "openai",
+  label: "OpenAI/Codex",
+  backendKind: "codex-cli-auth",
+  routeAvailable: true,
+  routeStatus: "Uses the configured Codex/OpenAI backend inside Codexa.",
+  launchAvailable: true,
+  discoverModels: () => ({
+    status: "ready",
+    providerId: "openai",
+    backendKind: "codex-cli-auth",
+    models: [],
+  }),
+  run: (request: ProviderChatRequest, handlers: BackendRunHandlers) => {
+    handlers.onProgress?.({
+      id: "openai-route",
+      source: "stdout",
+      text: "Starting Codex CLI",
+    });
+    return codexSubprocessProvider.run!(
+      request.prompt,
+      {
+        runtime: request.runtime,
+        workspaceRoot: request.workspaceRoot,
+        projectInstructions: request.projectInstructions,
+      },
+      handlers,
+    );
+  },
+};
+
+function unavailableRuntime(providerId: ProviderId, label: string): ProviderRuntime {
+  return {
+    providerId,
+    label,
+    backendKind: "unavailable",
+    routeAvailable: false,
+    routeStatus: `${label} is available as a launcher, but in-Codexa routing is not configured yet.`,
+    launchAvailable: providerId !== "local",
+    discoverModels: (): ProviderModelDiscoveryResult => ({
+      status: "not-configured",
+      providerId,
+      backendKind: "unavailable",
+      models: [],
+      message: `${label} is available as a launcher, but in-Codexa routing is not configured yet.`,
+    }),
+  };
+}
+
+const PROVIDER_RUNTIMES: Record<ProviderId, ProviderRuntime> = {
+  openai: openAiRuntime,
+  anthropic: anthropicRuntime,
+  google: geminiRuntime,
+  local: localRuntime,
+};
+
+export function getProviderRuntime(providerId: ProviderId): ProviderRuntime {
+  return PROVIDER_RUNTIMES[providerId];
+}
+
+export function isProviderRoutableInCodexa(providerId: ProviderId): boolean {
+  return getProviderRuntime(providerId).routeAvailable;
+}
+
+export function isProviderRouteConfigured(providerId: ProviderId): boolean {
+  const runtime = getProviderRuntime(providerId);
+  return runtime.routeAvailable && (runtime.isRouteConfigured?.() ?? true);
+}
+
+export function getProviderRouteSetupMessage(providerId: ProviderId): string {
+  const runtime = getProviderRuntime(providerId);
+  return runtime.routeSetupMessage ?? runtime.routeStatus;
+}
+
+export function discoverProviderModels(providerId: ProviderId): ProviderModelDiscoveryResult {
+  return getProviderRuntime(providerId).discoverModels();
+}
+
+export async function validateProviderRouteActivation(options: {
+  route: ProviderRoute;
+  workspaceRoot: string;
+  geminiCommandPath?: string | null;
+  claudeCommandPath?: string | null;
+  localConfig?: ProviderWorkspaceOverride | null;
+}): Promise<ProviderRouteValidationResult> {
+  const runtime = getProviderRuntime(options.route.providerId);
+  if (!runtime.routeAvailable) {
+    return {
+      status: "not-configured",
+      providerId: options.route.providerId,
+      backendKind: "unavailable",
+      message: getProviderRouteSetupMessage(options.route.providerId),
+    };
+  }
+
+  if (runtime.validateRoute) {
+    return runtime.validateRoute(options);
+  }
+
+  if (!isProviderRouteConfigured(options.route.providerId)) {
+    return {
+      status: "not-configured",
+      providerId: options.route.providerId,
+      backendKind: "unavailable",
+      message: getProviderRouteSetupMessage(options.route.providerId),
+    };
+  }
+
+  return {
+    status: "ready",
+    providerId: options.route.providerId,
+    backendKind: runtime.backendKind,
+  };
+}
+
+export function resolveGeminiModelId(selection: GeminiModelSelection): string {
+  if (selection.kind === "manual") {
+    return normalizeGeminiModelId(selection.modelId);
+  }
+  if (selection.family === "gemini-3") {
+    return "gemini-3-flash-preview";
+  }
+  if (selection.family === "gemini-2.5") {
+    return "gemini-2.5-pro";
+  }
+  return GEMINI_DEFAULT_MODEL_ID;
+}
+
+export function resolveActiveProviderRoute(options: {
+  workspaceConfigActiveRoute?: ProviderActiveRoute;
+  currentModel: string;
+  currentReasoning: string;
+}): ActiveProviderRoute {
+  const configuredRoute = options.workspaceConfigActiveRoute;
+  if (configuredRoute && isProviderRoutableInCodexa(configuredRoute.providerId)) {
+    const route: ActiveProviderRoute = {
+      providerId: configuredRoute.providerId,
+      modelId: configuredRoute.modelId,
+      backendKind: configuredRoute.backendKind ?? getProviderRuntime(configuredRoute.providerId).backendKind,
+      ...(configuredRoute.reasoning ? { reasoning: configuredRoute.reasoning } : {}),
+      ...(configuredRoute.modelSelection ? { modelSelection: configuredRoute.modelSelection } : {}),
+    };
+
+    if (route.providerId === "google" && route.modelSelection) {
+      route.modelId = resolveGeminiModelId(route.modelSelection);
+    } else if (route.providerId === "google") {
+      route.modelId = normalizeGeminiModelId(route.modelId);
+    } else if (route.providerId === "local") {
+      const discovery = discoverProviderModels("local");
+      const selectedModel = typeof discovery.diagnostics?.selectedModel === "string"
+        ? discovery.diagnostics.selectedModel.trim()
+        : "";
+      if (discovery.status === "ready" && selectedModel) {
+        route.modelId = selectedModel;
+      }
+    }
+
+    return route;
+  }
+
+  return {
+    providerId: "openai",
+    modelId: options.currentModel,
+    backendKind: "codex-cli-auth",
+    reasoning: options.currentReasoning,
+  };
+}
+
+export function getDefaultRouteModel(providerId: ProviderId, currentOpenAiModel: string): string {
+  if (providerId === "anthropic") {
+    return ANTHROPIC_FALLBACK_MODELS[0]?.modelId ?? "claude-sonnet-4-20250514";
+  }
+  if (providerId === "google") {
+    return GEMINI_FALLBACK_MODELS[0]?.modelId ?? GEMINI_DEFAULT_MODEL_ID;
+  }
+  if (providerId === "local") {
+    const discovery = discoverProviderModels("local");
+    return discovery.models[0]?.modelId ?? "Local default";
+  }
+  return currentOpenAiModel;
+}