Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

7.2 KB
Raw Blame
import {
  IMAGE_PROVIDER_IDS,
  type ImageGenerationSettings,
  type ImageGenerationSettingsPatch,
  type ImageProviderHealth,
  type ImageProviderId,
  type ImageProviderStatus,
} from "@akeru/contracts";

import { createTranslator, type MessageKey, type TranslationParams } from "./i18n/index.ts";

type ImageGenerationTranslate = (message: MessageKey, params?: TranslationParams) => string;

const englishTranslate: ImageGenerationTranslate = createTranslator("en").t;

export const IMAGE_PROVIDER_LABELS: Readonly<Record<ImageProviderId, string>> = {
  chatgpt: "ChatGPT",
  grok: "Grok",
};

/** Subscription credential each image provider rides on; disconnecting it also signs out chat. */
export const IMAGE_PROVIDER_SUBSCRIPTIONS = {
  chatgpt: "openai-codex",
  grok: "xai",
} as const satisfies Record<ImageProviderId, string>;

export type ImageHealthBadgeVariant = "success" | "error" | "warning" | "secondary";

export interface ImageHealthDisplay {
  readonly label: string;
  readonly variant: ImageHealthBadgeVariant;
}

const FAILURE_LABELS: Readonly<Partial<Record<ImageProviderHealth, string>>> = {
  expired: "Expired",
  revoked: "Revoked",
  failed: "Failed",
  "failed-first-request": "First request failed",
};

export function isImageProviderEnabled(
  settings: ImageGenerationSettings,
  provider: ImageProviderId,
): boolean {
  return provider === "chatgpt" ? settings.chatgptEnabled : settings.grokEnabled;
}

/**
 * Health badge for one row. The enabled flag comes from local settings so a
 * toggle shows immediately; everything else comes from the server row. A row
 * only reads as healthy after a real health request passed.
 */
export function imageProviderHealthDisplay(
  status: ImageProviderStatus | undefined,
  enabled: boolean,
  loadFailed = false,
): ImageHealthDisplay {
  if (!status) {
    return loadFailed
      ? { label: "Unavailable", variant: "error" }
      : { label: "Checking", variant: "secondary" };
  }

  if (!status.connected) return { label: "Not connected", variant: "secondary" };

  if (!enabled) return { label: "Disabled", variant: "secondary" };
  const failure = FAILURE_LABELS[status.health];

  if (failure) return { label: failure, variant: "error" };

  if (status.health === "unsupported") return { label: "Unsupported", variant: "warning" };

  if (
    (status.health === "healthy" || status.health === "recovered") &&
    status.healthTest?.status === "passed"
  ) {
    return { label: status.health === "recovered" ? "Recovered" : "Healthy", variant: "success" };
  }

  return { label: "Not tested", variant: "warning" };
}

/** Clients pass their active translator; plain callers get English. */
export function imageProviderAccessLabel(
  status: ImageProviderStatus | undefined,
  t: ImageGenerationTranslate = englishTranslate,
): string {
  if (!status) return t("Checking subscription");
  const provider = IMAGE_PROVIDER_LABELS[status.provider];

  return status.connected
    ? t("{provider} subscription detected", { provider })
    : t("No {provider} subscription connected", { provider });
}

export function imageProviderOperationsLabel(status: ImageProviderStatus): string {
  if (!status.operations.includes("generate")) return "No supported operations reported";

  return status.operations.includes("edit")
    ? "Supports image generation and editing"
    : "Supports image generation";
}

/** Only meaningful for a loaded row; a missing row is loading or unavailable, not empty. */
export function imageProviderGenerationLabel(
  status: ImageProviderStatus,
  formatTime: (iso: string) => string,
): string {
  return status.lastGenerationAt
    ? `Last image ${formatTime(status.lastGenerationAt)}`
    : "No images generated yet";
}

export function imageProviderHealthTestLabel(
  status: ImageProviderStatus,
  formatTime: (iso: string) => string,
): string {
  const test = status.healthTest;

  if (!test || test.status === "not-run") return "Health test not run";
  const verb = test.status === "passed" ? "passed" : "failed";

  return test.checkedAt
    ? `Health test ${verb} ${formatTime(test.checkedAt)}`
    : `Health test ${verb}`;
}

/** The enabled providers in fallback order. Providers missing from the saved order go last. */
export function effectiveFallbackOrder(settings: ImageGenerationSettings): ImageProviderId[] {
  const enabled = IMAGE_PROVIDER_IDS.filter((id) => isImageProviderEnabled(settings, id));
  const ordered = settings.fallbackOrder.filter((id) => enabled.includes(id));

  return [...new Set([...ordered, ...enabled])];
}

/** The provider new images use, or null when none is enabled. */
export function effectiveDefaultProvider(
  settings: ImageGenerationSettings,
): ImageProviderId | null {
  if (settings.defaultProvider && isImageProviderEnabled(settings, settings.defaultProvider)) {
    return settings.defaultProvider;
  }

  return effectiveFallbackOrder(settings)[0] ?? null;
}

/** Returns why an order cannot be saved, or null when it can. */
export function fallbackOrderError(
  order: ReadonlyArray<ImageProviderId>,
  settings: ImageGenerationSettings,
): string | null {
  if (order.length === 0) return "Choose at least one provider.";

  if (order.length > IMAGE_PROVIDER_IDS.length) return "The order lists too many providers.";

  if (new Set(order).size !== order.length) return "Each provider can appear only once.";
  const disabled = order.find((id) => !isImageProviderEnabled(settings, id));

  if (disabled) return `${IMAGE_PROVIDER_LABELS[disabled]} is turned off.`;

  return null;
}

/**
 * Patch for turning one provider on or off. It keeps the default and the
 * fallback order coherent so the optimistic settings match what the server
 * saves after normalizing.
 */
export function imageProviderTogglePatch(
  settings: ImageGenerationSettings,
  provider: ImageProviderId,
  enabled: boolean,
): ImageGenerationSettingsPatch {
  const next: ImageGenerationSettings = {
    ...settings,
    ...(provider === "chatgpt" ? { chatgptEnabled: enabled } : { grokEnabled: enabled }),
  };

  const order = effectiveFallbackOrder(next);
  const defaultProvider = effectiveDefaultProvider(next);

  return {
    ...(provider === "chatgpt" ? { chatgptEnabled: enabled } : { grokEnabled: enabled }),
    ...(defaultProvider !== settings.defaultProvider ? { defaultProvider } : {}),
    ...(order.length > 0 && order.join() !== settings.fallbackOrder.join()
      ? { fallbackOrder: order }
      : {}),
  };
}

/** Label for the bot editor's "use the global default" option. */
export function globalDefaultOptionLabel(settings: ImageGenerationSettings): string {
  const provider = effectiveDefaultProvider(settings);

  return provider
    ? `Use global default (${IMAGE_PROVIDER_LABELS[provider]})`
    : "Use global default (none enabled)";
}

/**
 * Bot editor option label. A bot can still pick a provider that is off or
 * disconnected, so the option says so instead of looking ready.
 */
export function botImageProviderOptionLabel(
  provider: ImageProviderId,
  settings: ImageGenerationSettings,
  status: ImageProviderStatus | undefined,
): string {
  const label = IMAGE_PROVIDER_LABELS[provider];

  if (status && !status.connected) return `${label} (not connected)`;

  if (!isImageProviderEnabled(settings, provider)) return `${label} (off)`;

  return label;
}