@golba98/codexa 1.0.3 → 1.0.4

package/src/core/providerLauncher/types.ts

@@ -1,10 +1,11 @@
-export type ProviderId = "openai" | "anthropic" | "google" | "local";
+export type ProviderId = "openai" | "anthropic" | "google" | "local" | "antigravity";
 
 export type ProviderBackendType =
-  | "codex-cli-auth"
-  | "gemini-cli-auth"
-  | "claude-code-auth"
-  | "openai-api-key"
+  | "codex-cli-auth"
+  | "gemini-cli-auth"
+  | "claude-code-auth"
+  | "antigravity-cli-auth"
+  | "openai-api-key"
   | "gemini-api-key"
   | "anthropic-api-key"
   | "local-openai-compatible"
@@ -69,10 +70,11 @@ export interface ProviderWorkspaceOverride {
   defaultModel?: string;
   models?: Record<string, ProviderModelWorkspaceOverride>;
   command?: string | ProviderLaunchCommand | null;
-  claudeCommandPath?: string;
-  geminiCommandPath?: string;
-  codexCommandPath?: string;
-}
+  claudeCommandPath?: string;
+  geminiCommandPath?: string;
+  codexCommandPath?: string;
+  antigravityCommandPath?: string;
+}
 
 export interface ProviderModelWorkspaceOverride {
   contextLength?: number;

package/src/core/providerLauncher/workspaceConfig.ts

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
 import { DEFAULT_MODEL } from "../../config/settings.js";
-import { normalizeWorkspaceRoot } from "../workspaceRoot.js";
+import { normalizeWorkspaceRoot } from "../workspace/workspaceRoot.js";
 import { isKnownProviderId } from "./registry.js";
 import { getDefaultRouteModel, getProviderRuntime, isProviderRouteConfigured, isProviderRoutableInCodexa } from "../providerRuntime/registry.js";
 import { normalizeGeminiModelId } from "../providerRuntime/models.js";
@@ -13,8 +13,9 @@ import type {
   ProviderWorkspaceOverride,
 } from "./types.js";
 
-const DEPRECATED_ANTIGRAVITY_PROVIDER_ID = "antigravity";
-const DEPRECATED_ANTIGRAVITY_BACKENDS = new Set(["antigravity-cli-auth", "agy"]);
+const DEPRECATED_ANTIGRAVITY_PROVIDER_ID = "antigravity";
+const DEPRECATED_ANTIGRAVITY_BACKENDS = new Set(["antigravity-cli-auth", "agy"]);
+const DEPRECATED_GOOGLE_PROVIDER_ID = "google";
 
 export function getProviderWorkspaceConfigFile(workspaceRoot: string): string {
   return join(normalizeWorkspaceRoot(workspaceRoot), ".codexa", "providers.json");
@@ -28,16 +29,20 @@ function isDeprecatedAntigravityProviderId(value: unknown): boolean {
   return value === DEPRECATED_ANTIGRAVITY_PROVIDER_ID;
 }
 
-function isDeprecatedAntigravityRoute(value: unknown): boolean {
+function isDeprecatedAntigravityRoute(value: unknown): boolean {
   if (!isRecord(value)) return false;
   return isDeprecatedAntigravityProviderId(value.providerId ?? value.provider_id)
     || DEPRECATED_ANTIGRAVITY_BACKENDS.has(String(value.backendKind ?? value.backend_kind));
-}
+}
+
+function isDeprecatedGoogleRoute(value: unknown): boolean {
+  return isRecord(value) && (value.providerId ?? value.provider_id) === DEPRECATED_GOOGLE_PROVIDER_ID;
+}
 
 function resolveDeprecatedProviderFallback(
   providers: Partial<Record<ProviderId, ProviderWorkspaceOverride>>,
 ): ProviderId {
-  const candidates: readonly ProviderId[] = ["openai", "google", "anthropic", "local"];
+  const candidates: readonly ProviderId[] = ["openai", "anthropic", "local"];
   return candidates.find((providerId) =>
     isProviderRoutableInCodexa(providerId)
     && (providerId === "openai" || providers[providerId] !== undefined || isProviderRouteConfigured(providerId))
@@ -214,22 +219,24 @@ function parseActiveRoute(value: unknown): ProviderActiveRoute | undefined {
 export function parseProviderWorkspaceConfig(data: unknown): ProviderWorkspaceConfig {
   if (!isRecord(data)) return {};
 
-  const config: ProviderWorkspaceConfig = {};
-  const providers: Partial<Record<ProviderId, ProviderWorkspaceOverride>> = {};
-  let foundDeprecatedAntigravity = false;
+  const config: ProviderWorkspaceConfig = {};
+  const providers: Partial<Record<ProviderId, ProviderWorkspaceOverride>> = {};
+  let foundDeprecatedAntigravity = false;
+  let foundDeprecatedGoogle = false;
 
   if (isRecord(data.providers)) {
     for (const [id, value] of Object.entries(data.providers)) {
-      if (isDeprecatedAntigravityProviderId(id)) {
-        foundDeprecatedAntigravity = true;
-        continue;
-      }
-      if (!isKnownProviderId(id)) continue;
-      const override = parseProviderOverride(value);
-      if (id === "google" && override?.currentModel) {
-        override.currentModel = normalizeGeminiModelId(override.currentModel);
-      }
-      if (override) providers[id] = override;
+      if (isDeprecatedAntigravityProviderId(id)) {
+        foundDeprecatedAntigravity = true;
+        continue;
+      }
+      if (id === DEPRECATED_GOOGLE_PROVIDER_ID) {
+        foundDeprecatedGoogle = true;
+        continue;
+      }
+      if (!isKnownProviderId(id)) continue;
+      const override = parseProviderOverride(value);
+      if (override) providers[id] = override;
     }
     config.providers = providers;
   }
@@ -238,7 +245,10 @@ export function parseProviderWorkspaceConfig(data: unknown): ProviderWorkspaceCo
     ?? data.workspace_default_provider_id
     ?? data.defaultProviderId
     ?? data.default_provider_id;
-  if (isDeprecatedAntigravityProviderId(defaultProvider)) {
+  if (defaultProvider === DEPRECATED_GOOGLE_PROVIDER_ID) {
+    foundDeprecatedGoogle = true;
+    config.workspaceDefaultProviderId = resolveDeprecatedProviderFallback(providers);
+  } else if (isDeprecatedAntigravityProviderId(defaultProvider)) {
     foundDeprecatedAntigravity = true;
     config.workspaceDefaultProviderId = resolveDeprecatedProviderFallback(providers);
   } else if (typeof defaultProvider === "string" && isKnownProviderId(defaultProvider)) {
@@ -246,7 +256,12 @@ export function parseProviderWorkspaceConfig(data: unknown): ProviderWorkspaceCo
   }
 
   const rawActiveRoute = data.activeRoute ?? data.active_route;
-  if (isDeprecatedAntigravityRoute(rawActiveRoute)) {
+  if (isDeprecatedGoogleRoute(rawActiveRoute)) {
+    foundDeprecatedGoogle = true;
+    const fallbackProviderId = resolveDeprecatedProviderFallback(providers);
+    config.activeRoute = createFallbackActiveRoute(fallbackProviderId, providers);
+    config.workspaceDefaultProviderId ??= fallbackProviderId;
+  } else if (isDeprecatedAntigravityRoute(rawActiveRoute)) {
     foundDeprecatedAntigravity = true;
     const fallbackProviderId = resolveDeprecatedProviderFallback(providers);
     config.activeRoute = createFallbackActiveRoute(fallbackProviderId, providers);
@@ -258,12 +273,12 @@ export function parseProviderWorkspaceConfig(data: unknown): ProviderWorkspaceCo
     }
   }
 
-  if (foundDeprecatedAntigravity) {
+  if (foundDeprecatedGoogle || foundDeprecatedAntigravity) {
     const revertedProviderId = config.activeRoute?.providerId
       ?? config.workspaceDefaultProviderId
       ?? resolveDeprecatedProviderFallback(providers);
     config.migrationNotice = {
-      deprecatedProviderId: DEPRECATED_ANTIGRAVITY_PROVIDER_ID,
+      deprecatedProviderId: foundDeprecatedGoogle ? DEPRECATED_GOOGLE_PROVIDER_ID : DEPRECATED_ANTIGRAVITY_PROVIDER_ID,
       revertedProviderId,
     };
   }
@@ -348,13 +363,13 @@ export function saveProviderWorkspaceConfig(workspaceRoot: string, config: Provi
   renameSync(tmpFile, filePath);
 }
 
-export function setProviderWorkspaceDefault(
+export function setProviderWorkspaceDefault(
   config: ProviderWorkspaceConfig,
   providerId: ProviderId,
 ): ProviderWorkspaceConfig {
   return {
     ...config,
-    workspaceDefaultProviderId: providerId,
+    workspaceDefaultProviderId: providerId === DEPRECATED_GOOGLE_PROVIDER_ID ? "openai" : providerId,
   };
 }
 
@@ -396,7 +411,7 @@ export function setProviderActiveRoute(
   config: ProviderWorkspaceConfig,
   activeRoute: ProviderActiveRoute,
 ): ProviderWorkspaceConfig {
-  if (!isProviderRoutableInCodexa(activeRoute.providerId) || !isProviderRouteConfigured(activeRoute.providerId)) {
+  if (activeRoute.providerId === DEPRECATED_GOOGLE_PROVIDER_ID || !isProviderRoutableInCodexa(activeRoute.providerId) || !isProviderRouteConfigured(activeRoute.providerId)) {
     return config;
   }
 

package/src/core/providerRuntime/anthropic.ts

@@ -19,6 +19,7 @@ const ANTHROPIC_MAX_TOKENS = 1024;
 const ANTHROPIC_TIMEOUT_MS = 120_000;
 const ANTHROPIC_AUTH_CHECK_TIMEOUT_MS = 10_000;
 const ANTHROPIC_ROUTE_VALIDATION_TIMEOUT_MS = 15_000;
+const DISCOVERY_FAILURE_MESSAGE = "Claude Code model version discovery failed; using fallback aliases with unknown versions.";
 export const ANTHROPIC_ROUTE_SETUP_MESSAGE = "Anthropic/Claude is not configured for in-Codexa routing.\nSign in with Claude Code or set ANTHROPIC_API_KEY.";
 export { parseClaudeAuthStatus } from "./claudeCodeDiscovery.js";
 
@@ -498,6 +499,9 @@ export const anthropicRuntime: ProviderRuntime = {
     providerId: "anthropic",
     backendKind: getAnthropicRuntimeBackendKind(),
     models: getActiveAnthropicModels(),
+    message: (claudeCapabilityDiscovery?.modelSource ?? "fallback") === "fallback"
+      ? DISCOVERY_FAILURE_MESSAGE
+      : undefined,
     diagnostics: claudeCapabilityDiscovery ? {
       resolvedCommand: claudeCapabilityDiscovery.resolvedCommand,
       modelSource: claudeCapabilityDiscovery.modelSource,
@@ -534,7 +538,9 @@ export const anthropicRuntime: ProviderRuntime = {
       providerId: "anthropic",
       backendKind: getAnthropicRuntimeBackendKind(),
       models: discoveredAnthropicModels,
-      message: `Refreshed Claude capabilities (${discovery.modelSource}).`,
+      message: discovery.modelSource === "fallback"
+        ? DISCOVERY_FAILURE_MESSAGE
+        : `Refreshed Claude capabilities (${discovery.modelSource}).`,
       diagnostics: {
         resolvedCommand: discovery.resolvedCommand,
         modelSource: discovery.modelSource,

package/src/core/providerRuntime/antigravity.ts

@@ -0,0 +1,305 @@
+import { runCommand } from "../process/CommandRunner.js";
+import { sanitizeTerminalOutput } from "../terminal/terminalSanitize.js";
+import type { ReasoningEffortCapability } from "../models/codexModelCapabilities.js";
+import type { BackendRunHandlers } from "../providers/types.js";
+import type {
+  ProviderBackendKind,
+  ProviderChatRequest,
+  ProviderModel,
+  ProviderModelDiscoveryResult,
+  ProviderRouteValidationResult,
+  ProviderRuntime,
+} from "./types.js";
+import {
+  resolveAgyExecutable,
+  resetAgyExecutableCacheForTests,
+} from "../executables/antigravityExecutable.js";
+import { buildSpawnSpec } from "../executables/executableResolver.js";
+
+export { resetAgyExecutableCacheForTests };
+
+const ANTIGRAVITY_TIMEOUT_MS = 120_000;
+const ANTIGRAVITY_VALIDATION_TIMEOUT_MS = 10_000;
+const ANTIGRAVITY_ROUTE_SETUP_MESSAGE =
+  "`agy` command not found. Install Antigravity CLI or set AGY_EXECUTABLE to the full path.";
+
+export const ANTIGRAVITY_DEFAULT_MODEL_ID = "gemini-3.5-flash";
+export const ANTIGRAVITY_DEFAULT_REASONING = "high";
+
+// ---------------------------------------------------------------------------
+// Effort levels for Antigravity Gemini models
+// ---------------------------------------------------------------------------
+
+const AGY_LOW:    ReasoningEffortCapability = { id: "low",    label: "Low",    description: null };
+const AGY_MEDIUM: ReasoningEffortCapability = { id: "medium", label: "Medium", description: null };
+const AGY_HIGH:   ReasoningEffortCapability = { id: "high",   label: "High",   description: null };
+
+// ---------------------------------------------------------------------------
+// Model definitions
+// ---------------------------------------------------------------------------
+
+export const ANTIGRAVITY_MODELS: readonly ProviderModel[] = [
+  {
+    id: "gemini-3.5-flash",
+    modelId: "gemini-3.5-flash",
+    label: "Gemini 3.5 Flash",
+    description: "Antigravity-routed Gemini 3.5 Flash. Select effort with ←/→.",
+    defaultReasoningLevel: "high",
+    supportedReasoningLevels: [AGY_LOW, AGY_MEDIUM, AGY_HIGH],
+    source: "fallback",
+  },
+  {
+    id: "gemini-3.1-pro",
+    modelId: "gemini-3.1-pro",
+    label: "Gemini 3.1 Pro",
+    description: "Antigravity-routed Gemini 3.1 Pro. Select effort with ←/→.",
+    defaultReasoningLevel: "high",
+    supportedReasoningLevels: [AGY_LOW, AGY_HIGH],
+    source: "fallback",
+  },
+  {
+    id: "claude-sonnet-4-6-think",
+    modelId: "claude-sonnet-4-6-think",
+    label: "Claude Sonnet 4.6 (Thinking)",
+    description: "Antigravity-routed Claude Sonnet 4.6 with extended thinking.",
+    defaultReasoningLevel: null,
+    supportedReasoningLevels: null,
+    source: "fallback",
+  },
+  {
+    id: "claude-opus-4-6-think",
+    modelId: "claude-opus-4-6-think",
+    label: "Claude Opus 4.6 (Thinking)",
+    description: "Antigravity-routed Claude Opus 4.6 with extended thinking.",
+    defaultReasoningLevel: null,
+    supportedReasoningLevels: null,
+    source: "fallback",
+  },
+  {
+    id: "gpt-oss-120b",
+    modelId: "gpt-oss-120b",
+    label: "GPT-OSS 120B",
+    description: "Antigravity-routed GPT-OSS 120B.",
+    defaultReasoningLevel: null,
+    supportedReasoningLevels: null,
+    source: "fallback",
+  },
+];
+
+// ---------------------------------------------------------------------------
+// AGY_MODEL env mapping
+// ---------------------------------------------------------------------------
+
+/**
+ * Maps Codexa model IDs to the AGY_MODEL env value passed to the agy subprocess.
+ *
+ * Verified:
+ *   gemini-3.5-flash → "gemini-3.5-flash"  (confirmed via: AGY_MODEL=gemini-3.5-flash agy -p "say hello back")
+ *
+ * Unverified (same pattern, not independently smoke-tested):
+ *   gemini-3.1-pro → "gemini-3.1-pro"
+ */
+const AGY_MODEL_ENV_MAP: Readonly<Record<string, string>> = {
+  "gemini-3.5-flash": "gemini-3.5-flash",
+  "gemini-3.1-pro":   "gemini-3.1-pro",
+};
+
+export function getAgyModelEnvValue(modelId: string): string | null {
+  return AGY_MODEL_ENV_MAP[modelId] ?? null;
+}
+
+export function buildAgyEnv(modelId: string, _reasoning?: string): NodeJS.ProcessEnv {
+  // _reasoning is stored in route state and surfaced in the footer UI, but agy
+  // has no verified CLI flag or env var for passing effort level to the subprocess.
+  // TODO: wire _reasoning here once Antigravity exposes a stable mechanism.
+  const envValue = getAgyModelEnvValue(modelId);
+  return envValue ? { ...process.env, AGY_MODEL: envValue } : { ...process.env };
+}
+
+export function getAntigravityModelLabel(modelId: string): string {
+  return ANTIGRAVITY_MODELS.find((m) => m.id === modelId)?.label ?? modelId;
+}
+
+// ---------------------------------------------------------------------------
+// Legacy model ID migration
+// ---------------------------------------------------------------------------
+
+/**
+ * Migrates legacy compound Antigravity model IDs (from feat/antigravity-cli-provider)
+ * to the new family + reasoning format.
+ *
+ * Old IDs encoded effort in the model ID (e.g., "gemini-3.5-flash-high").
+ * New IDs use the base family ("gemini-3.5-flash") with reasoning stored separately.
+ */
+export function migrateAntigravityLegacyModelId(modelId: string): { modelId: string; reasoning?: string } {
+  const legacy: Record<string, { modelId: string; reasoning?: string }> = {
+    "gemini-3.5-flash-high":   { modelId: "gemini-3.5-flash", reasoning: "high" },
+    "gemini-3.5-flash-medium": { modelId: "gemini-3.5-flash", reasoning: "medium" },
+    "gemini-3.5-flash-low":    { modelId: "gemini-3.5-flash", reasoning: "low" },
+    "gemini-3.1-pro-high":     { modelId: "gemini-3.1-pro",   reasoning: "high" },
+    "gemini-3.1-pro-low":      { modelId: "gemini-3.1-pro",   reasoning: "low" },
+    "gpt-oss-120b-medium":     { modelId: "gpt-oss-120b" },
+  };
+  return legacy[modelId] ?? { modelId };
+}
+
+// ---------------------------------------------------------------------------
+// Module-level state
+// ---------------------------------------------------------------------------
+
+let agyRouteValidated = false;
+let resolvedAgyExecutable: string = "agy";
+
+export function isAntigravityRouteConfigured(): boolean {
+  return agyRouteValidated;
+}
+
+export function resetAntigravityRouteValidationCacheForTests(): void {
+  agyRouteValidated = false;
+  resolvedAgyExecutable = "agy";
+  resetAgyExecutableCacheForTests();
+}
+
+// ---------------------------------------------------------------------------
+// Route validation
+// ---------------------------------------------------------------------------
+
+export async function validateAntigravityRoute(options: {
+  cwd?: string;
+  configuredPath?: string | null;
+  runCommandImpl?: typeof runCommand;
+  platform?: NodeJS.Platform;
+}): Promise<ProviderRouteValidationResult> {
+  let resolved: string;
+  try {
+    resolved = await resolveAgyExecutable({
+      cwd: options.cwd,
+      configuredPath: options.configuredPath,
+      runCommandImpl: options.runCommandImpl,
+    });
+  } catch {
+    return {
+      status: "not-configured",
+      providerId: "antigravity",
+      backendKind: "unavailable",
+      message: ANTIGRAVITY_ROUTE_SETUP_MESSAGE,
+      diagnostics: { resolvedCommand: null },
+    };
+  }
+
+  // Probe the binary to confirm it's actually installed. Running --help has no
+  // auth side effects and exits 0 when agy is present. buildSpawnSpec wraps
+  // .cmd/.bat shims in `cmd.exe /d /s /c call` on Windows (no-op elsewhere) so
+  // the probe can actually launch the resolved executable.
+  const runCommandImpl = options.runCommandImpl ?? runCommand;
+  const probeSpec = buildSpawnSpec(resolved, ["--help"], options.platform ?? process.platform);
+  const probe = runCommandImpl({
+    executable: probeSpec.executable,
+    args: probeSpec.args,
+    cwd: options.cwd ?? process.cwd(),
+    timeoutMs: ANTIGRAVITY_VALIDATION_TIMEOUT_MS,
+  });
+  const probeResult = await probe.result;
+
+  if (probeResult.status === "spawn_error") {
+    return {
+      status: "not-configured",
+      providerId: "antigravity",
+      backendKind: "unavailable",
+      message: ANTIGRAVITY_ROUTE_SETUP_MESSAGE,
+      diagnostics: { resolvedCommand: resolved },
+    };
+  }
+
+  resolvedAgyExecutable = resolved;
+  agyRouteValidated = true;
+
+  return {
+    status: "ready",
+    providerId: "antigravity",
+    backendKind: "antigravity-cli-auth",
+    message: `Antigravity CLI found at: ${resolved}`,
+    diagnostics: { resolvedCommand: resolved },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// run()
+// ---------------------------------------------------------------------------
+
+export function runAntigravityWithRunner(
+  request: ProviderChatRequest,
+  handlers: BackendRunHandlers,
+  runCommandImpl: typeof runCommand = runCommand,
+  executable: string = resolvedAgyExecutable,
+  platform: NodeJS.Platform = process.platform,
+): () => void {
+  const spawnSpec = buildSpawnSpec(executable, ["-p", request.prompt], platform);
+  const env = buildAgyEnv(request.route.modelId, request.route.reasoning);
+
+  const runner = runCommandImpl(
+    {
+      executable: spawnSpec.executable,
+      args: spawnSpec.args,
+      cwd: request.workspaceRoot,
+      env,
+      timeoutMs: ANTIGRAVITY_TIMEOUT_MS,
+    },
+  );
+
+  runner.result.then((result) => {
+    if (result.status === "canceled") return;
+
+    if (result.status !== "completed" || result.exitCode !== 0) {
+      const message = result.userMessage || result.stderr || "Antigravity CLI execution failed.";
+      handlers.onError(message, `agy command: ${JSON.stringify([spawnSpec.executable, ...spawnSpec.args])}`);
+      return;
+    }
+
+    const text = sanitizeTerminalOutput(result.stdout).trim();
+    if (text) {
+      handlers.onAssistantDelta?.(text);
+    }
+    handlers.onFinalAnswerObserved?.(text);
+    handlers.onResponse(text);
+  }).catch((error) => {
+    const message = error instanceof Error ? error.message : "Antigravity CLI execution failed.";
+    handlers.onError(message);
+  });
+
+  return runner.cancel;
+}
+
+// ---------------------------------------------------------------------------
+// Runtime
+// ---------------------------------------------------------------------------
+
+export const antigravityRuntime: ProviderRuntime = {
+  providerId: "antigravity",
+  label: "Antigravity CLI",
+  modelPickerLabel: "Antigravity",
+  backendKind: "antigravity-cli-auth",
+  routeAvailable: true,
+  routeStatus: "Routes through the Antigravity CLI (`agy`) when installed.",
+  routeSetupMessage: ANTIGRAVITY_ROUTE_SETUP_MESSAGE,
+  launchAvailable: true,
+  isRouteConfigured: isAntigravityRouteConfigured,
+  validateRoute: async ({ workspaceRoot, antigravityCommandPath }) => validateAntigravityRoute({
+    cwd: workspaceRoot,
+    configuredPath: antigravityCommandPath ?? null,
+  }),
+  discoverModels: (): ProviderModelDiscoveryResult => ({
+    status: "ready",
+    providerId: "antigravity",
+    backendKind: "antigravity-cli-auth",
+    models: ANTIGRAVITY_MODELS,
+  }),
+  run: (request: ProviderChatRequest, handlers: BackendRunHandlers) => {
+    handlers.onProgress?.({
+      id: "antigravity-route",
+      source: "stdout",
+      text: "Starting Antigravity CLI",
+    });
+    return runAntigravityWithRunner(request, handlers);
+  },
+};