ubume 0.1.0

package/src/core/providerRuntime/models.ts

@@ -0,0 +1,175 @@
+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;
+
+function fallbackModelDescription(family: string): string {
+  return `Claude ${family} alias — version unknown because model discovery is unavailable`;
+}
+
+export const ANTHROPIC_FALLBACK_MODELS: readonly ProviderModel[] = [
+  {
+    id: "fable",
+    modelId: "fable",
+    label: "Claude Fable (version unknown)",
+    description: fallbackModelDescription("Fable"),
+    defaultReasoningLevel: "xhigh",
+    supportedReasoningLevels: getClaudeCodeEffortLevels(["low", "medium", "high", "xhigh", "max"]),
+    source: "fallback",
+    canonicalId: "fable",
+    family: "fable",
+    effortSource: "fallback",
+    effortVerified: false,
+  },
+  {
+    id: "opus",
+    modelId: "opus",
+    label: "Claude Opus (version unknown)",
+    description: fallbackModelDescription("Opus"),
+    defaultReasoningLevel: "xhigh",
+    supportedReasoningLevels: getClaudeCodeEffortLevels(["low", "medium", "high", "xhigh", "max"]),
+    source: "fallback",
+    canonicalId: "opus",
+    family: "opus",
+    effortSource: "fallback",
+    effortVerified: false,
+  },
+
+  {
+    id: "sonnet",
+    modelId: "sonnet",
+    label: "Claude Sonnet (version unknown)",
+    description: fallbackModelDescription("Sonnet"),
+    defaultReasoningLevel: "high",
+    supportedReasoningLevels: getClaudeCodeEffortLevels(["low", "medium", "high", "xhigh", "max"]),
+    source: "fallback",
+    canonicalId: "sonnet",
+    family: "sonnet",
+    effortSource: "fallback",
+    effortVerified: false,
+  },
+  {
+    id: "haiku",
+    modelId: "haiku",
+    label: "Claude Haiku (version unknown)",
+    description: fallbackModelDescription("Haiku"),
+    defaultReasoningLevel: "medium",
+    supportedReasoningLevels: getClaudeCodeEffortLevels(["low", "medium", "high", "xhigh", "max"]),
+    source: "fallback",
+    canonicalId: "haiku",
+    family: "haiku",
+    effortSource: "fallback",
+    effortVerified: false,
+  },
+];
+
+function isRuntimeSource(source: ProviderModel["source"]): boolean {
+  return source === "discovered"
+    || source === "claude-code"
+    || source === "claude-code-command"
+    || source === "claude-code-package"
+    || source === "claude-code-cache"
+    || source === "claude-code-config"
+    || 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,20 @@
+import type { ReasoningEffortCapability } from "../models/codexModelCapabilities.js";
+import { formatReasoningLabel } from "../../config/settings.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) ?? {
+    id,
+    label: formatReasoningLabel(id),
+    description: null,
+  });
+}

package/src/core/providerRuntime/registry.ts

@@ -0,0 +1,286 @@
+import { codexSubprocessProvider } from "../providers/codexSubprocess.js";
+import { loadSeededOpenAiModels } from "../models/codexModelsCacheSeed.js";
+import { loadCachedProviderModels, saveCachedProviderModels } from "../models/providerModelCache.js";
+import type { BackendRunHandlers } from "../providers/types.js";
+import type { ProviderId, ProviderActiveRoute, ProviderWorkspaceOverride } from "../providerLauncher/types.js";
+import { isLocalDevChannel } from "../version/channel.js";
+import { anthropicRuntime } from "./anthropic.js";
+import { geminiRuntime } from "./gemini.js";
+import { localRuntime } from "./local.js";
+import { codexaNativeRuntime, CODEXA_NATIVE_MODEL_ID } from "./codexaNative.js";
+import { codexaCupyRuntime } from "./codexaCupy.js";
+import { antigravityRuntime, ANTIGRAVITY_DEFAULT_MODEL_ID, migrateAntigravityLegacyModelId } from "./antigravity.js";
+import { mistralVibeRuntime } from "./mistralVibe.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 Ubume.",
+  launchAvailable: true,
+  discoverModels: () => ({
+    status: "ready",
+    providerId: "openai",
+    backendKind: "codex-cli-auth",
+    models: loadSeededOpenAiModels()?.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,
+        conversationHistory: request.conversationHistory,
+        imageAttachments: request.imageAttachments,
+      },
+      handlers,
+    );
+  },
+};
+
+function unavailableRuntime(providerId: ProviderId, label: string): ProviderRuntime {
+  return {
+    providerId,
+    label,
+    backendKind: "unavailable",
+    routeAvailable: false,
+    routeStatus: `${label} is available as a launcher, but in-Ubume 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-Ubume routing is not configured yet.`,
+    }),
+  };
+}
+
+const PROVIDER_RUNTIMES: Record<ProviderId, ProviderRuntime> = {
+  openai: openAiRuntime,
+  anthropic: anthropicRuntime,
+  google: geminiRuntime,
+  mistral: mistralVibeRuntime,
+  local: localRuntime,
+  "codexa-native": codexaNativeRuntime,
+  "codexa-cupy": codexaCupyRuntime,
+  antigravity: antigravityRuntime,
+};
+
+export function getProviderRuntime(providerId: ProviderId): ProviderRuntime {
+  return PROVIDER_RUNTIMES[providerId];
+}
+
+export function isProviderRoutableInUbume(
+  providerId: ProviderId,
+  env: NodeJS.ProcessEnv = process.env,
+): boolean {
+  if ((providerId === "codexa-native" || providerId === "codexa-cupy") && !isLocalDevChannel(env)) {
+    return false;
+  }
+  return getProviderRuntime(providerId).routeAvailable;
+}
+
+export function isProviderRouteConfigured(
+  providerId: ProviderId,
+  env: NodeJS.ProcessEnv = process.env,
+): boolean {
+  const runtime = getProviderRuntime(providerId);
+  return isProviderRoutableInUbume(providerId, env) && (runtime.isRouteConfigured?.() ?? true);
+}
+
+export function getProviderRouteSetupMessage(providerId: ProviderId): string {
+  const runtime = getProviderRuntime(providerId);
+  return runtime.routeSetupMessage ?? runtime.routeStatus;
+}
+
+export function discoverProviderModels(providerId: ProviderId): ProviderModelDiscoveryResult {
+  const result = getProviderRuntime(providerId).discoverModels();
+  const hasRuntimeModels = result.models.some((model) => model.source && model.source !== "fallback");
+  if (result.status === "ready" && !hasRuntimeModels) {
+    const cached = loadCachedProviderModels(providerId);
+    if (cached) {
+      return { ...result, models: cached.models };
+    }
+  }
+  return result;
+}
+
+export function persistProviderDiscovery(discovery: ProviderModelDiscoveryResult): void {
+  const runtimeModels = discovery.models.filter((model) => model.source && model.source !== "fallback");
+  if (discovery.status !== "ready" || runtimeModels.length === 0) {
+    return;
+  }
+  saveCachedProviderModels(discovery.providerId, {
+    discoveredAt: Date.now(),
+    models: runtimeModels,
+  });
+}
+
+export async function validateProviderRouteActivation(options: {
+  route: ProviderRoute;
+  workspaceRoot: string;
+  geminiCommandPath?: string | null;
+  claudeCommandPath?: string | null;
+  antigravityCommandPath?: 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 && configuredRoute.providerId !== "google" && isProviderRoutableInUbume(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 } : {}),
+      ...(configuredRoute.providerId === "local"
+        ? { localBackend: configuredRoute.localBackend ?? "lm-studio" }
+        : {}),
+    };
+
+    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 === "anthropic") {
+      const discovery = discoverProviderModels("anthropic");
+      const stillAvailable = discovery.models.some((model) =>
+        model.modelId === route.modelId ||
+        model.id === route.modelId ||
+        model.canonicalId === route.modelId
+      );
+      const hasNonFallbackModels = discovery.models.some((model) => model.source !== "fallback");
+      const isKnownShortAlias = ANTHROPIC_FALLBACK_MODELS.some((model) => model.modelId === route.modelId);
+      if (discovery.status === "ready" && hasNonFallbackModels && discovery.models.length > 0 && !stillAvailable && isKnownShortAlias) {
+        route.modelId = discovery.models[0]!.modelId;
+      }
+    } else if (route.providerId === "antigravity") {
+      const migrated = migrateAntigravityLegacyModelId(route.modelId);
+      route.modelId = migrated.modelId;
+      if (!route.reasoning && migrated.reasoning) {
+        route.reasoning = migrated.reasoning;
+      }
+      const discovery = discoverProviderModels("antigravity");
+      if (discovery.status === "ready" && discovery.models.length > 0) {
+        let model = discovery.models.find((item) => item.modelId === route.modelId || item.id === route.modelId);
+        if (!model) {
+          model = discovery.models[0];
+          route.modelId = model.modelId;
+        }
+        const levels = model.supportedReasoningLevels;
+        if (levels?.length && (!route.reasoning || !levels.some((level) => level.id === route.reasoning))) {
+          route.reasoning = model.defaultReasoningLevel ?? levels[0]?.id;
+        }
+      }
+    }
+
+    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") {
+    const discovered = discoverProviderModels("anthropic");
+    if (discovered.status === "ready" && discovered.models.length > 0) {
+      return discovered.models[0].modelId;
+    }
+    return ANTHROPIC_FALLBACK_MODELS[0]?.modelId ?? "sonnet";
+  }
+  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";
+  }
+  if (providerId === "codexa-native") {
+    return CODEXA_NATIVE_MODEL_ID;
+  }
+  if (providerId === "mistral") {
+    const discovery = discoverProviderModels("mistral");
+    return discovery.models[0]?.modelId ?? "Vibe default";
+  }
+  if (providerId === "antigravity") {
+    return discoverProviderModels("antigravity").models[0]?.modelId ?? ANTIGRAVITY_DEFAULT_MODEL_ID;
+  }
+  return currentOpenAiModel;
+}
+
+export const isProviderRoutableInCodexa = isProviderRoutableInUbume;

package/src/core/providerRuntime/types.ts

@@ -0,0 +1,142 @@
+import type { ReasoningEffortCapability } from "../models/codexModelCapabilities.js";
+import type { ProjectInstructions } from "../workspace/projectInstructions.js";
+import type { BackendRunHandlers } from "../providers/types.js";
+import type { ResolvedRuntimeConfig } from "../../config/runtimeConfig.js";
+export type { ResolvedRuntimeConfig };
+import type { LocalBackendId, ProviderId } from "../providerLauncher/types.js";
+import type { ProviderWorkspaceOverride } from "../providerLauncher/types.js";
+import type { ConversationContextCheckpoint, ConversationMessage, LocalHarnessSessionMetadata } from "../workspace/conversationStore.js";
+
+export type ProviderBackendKind =
+  | "codex-cli-auth"
+  | "gemini-cli-auth"
+  | "claude-code-auth"
+  | "mistral-vibe-cli-auth"
+  | "antigravity-cli-auth"
+  | "openai-api-key"
+  | "gemini-api-key"
+  | "anthropic-api-key"
+  | "local-openai-compatible"
+  | "codexa-native-pytorch"
+  | "codexa-cupy"
+  | "unavailable";
+
+export interface ProviderModel {
+  id: string;
+  modelId: string;
+  label: string;
+  description: string | null;
+  defaultReasoningLevel: string | null;
+  supportedReasoningLevels: readonly ReasoningEffortCapability[] | null;
+  source?: "discovered" | "claude-code" | "claude-code-command" | "claude-code-package" | "claude-code-cache" | "claude-code-config" | "settings" | "config" | "fallback";
+  canonicalId?: string;
+  family?: string;
+  version?: string;
+  isFallback?: boolean;
+  discoveryKind?: "models" | "aliases";
+  effortSource?: "claude-code" | "claude-code-command" | "claude-code-package" | "claude-code-cache" | "claude-code-config" | "settings" | "config" | "fallback";
+  effortVerified?: boolean;
+  raw?: unknown;
+}
+
+export interface ProviderModelDiscoveryResult {
+  status: "ready" | "not-configured";
+  providerId: ProviderId;
+  backendKind: ProviderBackendKind;
+  models: readonly ProviderModel[];
+  message?: string;
+  diagnostics?: Record<string, string | number | boolean | null>;
+  localBackend?: LocalBackendId;
+}
+
+export type GeminiModelFamily = "gemini-3" | "gemini-2.5";
+
+export type GeminiModelSelection =
+  | { kind: "auto"; family: GeminiModelFamily }
+  | { kind: "manual"; modelId: string };
+
+export interface ProviderRoute {
+  providerId: ProviderId;
+  modelId: string;
+  backendKind: ProviderBackendKind;
+  reasoning?: string;
+  modelSelection?: GeminiModelSelection;
+  localBackend?: LocalBackendId;
+}
+
+export type ActiveProviderRoute = ProviderRoute;
+
+/** Ephemeral, request-scoped Local connection. Secrets are never persisted. */
+export interface ResolvedLocalAgentConfig {
+  localBackend: LocalBackendId;
+  baseUrl: string;
+  apiKey: string;
+  modelId: string;
+  contextWindow: number;
+  maxTokens: number;
+  supportsStreaming: boolean | null;
+  supportsToolCalls: boolean | null;
+  supportsSystemPrompt: boolean | null;
+  supportsVision: boolean;
+}
+
+export interface ProviderRouteValidationRequest {
+  route: ProviderRoute;
+  workspaceRoot: string;
+  geminiCommandPath?: string | null;
+  claudeCommandPath?: string | null;
+  antigravityCommandPath?: string | null;
+  localConfig?: ProviderWorkspaceOverride | null;
+  localBackend?: LocalBackendId;
+}
+
+export interface ProviderRouteValidationResult {
+  status: "ready" | "not-configured";
+  providerId: ProviderId;
+  backendKind: ProviderBackendKind;
+  message?: string;
+  diagnostics?: Record<string, string | number | boolean | null>;
+}
+
+export interface ProviderChatRequest {
+  prompt: string;
+  imageAttachments?: readonly ProviderImageAttachment[];
+  route: ProviderRoute;
+  runtime: ResolvedRuntimeConfig;
+  workspaceRoot: string;
+  projectInstructions?: ProjectInstructions | null;
+  localConfig?: ProviderWorkspaceOverride | null;
+  resolvedLocalAgentConfig?: ResolvedLocalAgentConfig;
+  runIntent?: "normal" | "plan" | "approved-execution";
+  conversationHistory?: readonly ConversationMessage[];
+  localContextCheckpoint?: ConversationContextCheckpoint;
+  localHarnessSession?: LocalHarnessSessionMetadata;
+}
+
+export interface ProviderImageAttachment {
+  path: string;
+  mediaType: "image/png" | "image/jpeg" | "image/webp" | "image/gif";
+  name: string;
+  bytes: number;
+}
+
+export interface ProviderChatResponse {
+  text: string;
+  rawOutput?: string;
+}
+
+export interface ProviderRuntime {
+  providerId: ProviderId;
+  label: string;
+  modelPickerLabel?: string;
+  backendKind: ProviderBackendKind;
+  routeAvailable: boolean;
+  routeStatus: string;
+  routeSetupMessage?: string;
+  launchAvailable: boolean;
+  isRouteConfigured?: () => boolean;
+  validateRoute?: (request: ProviderRouteValidationRequest) => Promise<ProviderRouteValidationResult>;
+  discoverModels: () => ProviderModelDiscoveryResult;
+  refreshModels?: (options: { cwd: string; localConfig?: ProviderWorkspaceOverride | null; localBackend?: LocalBackendId }) => Promise<ProviderModelDiscoveryResult>;
+  run?: (request: ProviderChatRequest, handlers: BackendRunHandlers) => () => void;
+}