Skip to content

Your lightweight open-source personal agent.

10.9 KB
Raw Blame
import { useEditCompletion, type EditCompletion } from "@/components/settings/shared/useEditCompletion";
import { ProviderParameterFields } from "@/components/settings/models/ProviderParameterFields";
import { providerJsonValue } from "@/components/settings/models/providerForm";
import type { Dispatch, SetStateAction, ReactNode } from "react";
import { SettingsAdvancedOptions } from "@/components/settings/shared/SettingsFeature";
import { useTranslation } from "react-i18next";

import { ModelIdPicker, ProviderPicker, optionRowsWithCurrent } from "@/components/settings/shared/ModelControls";
import {
  NumberInput,
  ReadOnlyRow,
  RestartSettingsFooter,
  SettingsGroup,
  SettingsRow,
  SettingsSectionTitle,
  StatusPill,
} from "@/components/settings/shared/SettingsControls";
import { ToggleButton } from "@/components/ui/toggle-button";
import { Button } from "@/components/ui/button";
import type { ImageGenerationSettingsUpdate, SettingsPayload } from "@/lib/types";

const IMAGE_ASPECT_RATIO_OPTIONS = ["1:1", "3:4", "9:16", "4:3", "16:9", "3:2", "2:3", "21:9"];
const IMAGE_SIZE_OPTIONS = ["1K", "2K", "4K", "1024x1024", "1536x1024", "1024x1536"];

export const DEFAULT_IMAGE_GENERATION_FORM: ImageGenerationSettingsUpdate = {
  enabled: false,
  provider: "openrouter",
  model: "openai/gpt-5.4-image-2",
  defaultAspectRatio: "1:1",
  defaultImageSize: "1K",
  maxImagesPerTurn: 4,
};

export function imageGenerationFormFromPayload(payload: SettingsPayload): ImageGenerationSettingsUpdate {
  return {
    enabled: payload.image_generation.enabled,
    provider: payload.image_generation.provider,
    model: payload.image_generation.model,
    defaultAspectRatio: payload.image_generation.default_aspect_ratio,
    defaultImageSize: payload.image_generation.default_image_size,
    maxImagesPerTurn: payload.image_generation.max_images_per_turn,
    ...(payload.image_generation.request_overrides_supported ? {
      extraHeaders: providerJsonValue(payload.image_generation.extra_headers),
      extraBody: providerJsonValue(payload.image_generation.extra_body),
    } : {}),
  };
}

export function ImageGenerationSettings({
  embedded = false,
  editCompletion,
  error,
  children,
  token,
  settings,
  form,
  dirty,
  saving,
  onChangeForm,
  onSave,
  onSaveRequestSettings,
  onOpenProviders,
  showBrandLogos,
  onRestart,
  isRestarting,
  requiresRestartPending,
}: {
  embedded?: boolean;
  editCompletion?: EditCompletion;
  error?: string;
  children?: ReactNode;
  token: string;
  settings: SettingsPayload;
  form: ImageGenerationSettingsUpdate;
  dirty: boolean;
  saving: boolean;
  onChangeForm: Dispatch<SetStateAction<ImageGenerationSettingsUpdate>>;
  onSave: () => void;
  onSaveRequestSettings: (values: Pick<ImageGenerationSettingsUpdate, "extraHeaders" | "extraBody">) => Promise<void>;
  onOpenProviders: () => void;
  showBrandLogos: boolean;
  onRestart?: () => void;
  isRestarting?: boolean;
  requiresRestartPending: boolean;
}) {
  const { t } = useTranslation();
  const tx = (key: string, fallback: string) => t(key, { defaultValue: fallback });
  const selectedProvider =
    settings.image_generation.providers.find((provider) => provider.name === form.provider);
  const providerConfigured = !!selectedProvider?.configured;
  const missingCredential = form.enabled && !providerConfigured;
  const localEdits = useEditCompletion(form, dirty, onSave, !editCompletion && !missingCredential);
  const edits = editCompletion ?? localEdits;
  const aspectOptions = optionRowsWithCurrent(
    IMAGE_ASPECT_RATIO_OPTIONS.map((value) => ({ name: value, label: value })),
    form.defaultAspectRatio,
  );
  const sizeOptions = optionRowsWithCurrent(
    IMAGE_SIZE_OPTIONS.map((value) => ({ name: value, label: value })),
    form.defaultImageSize,
  );
  const selectProvider = (provider: string) => {
    edits.complete();
    const nextProvider = settings.image_generation.providers.find((row) => row.name === provider);
    onChangeForm((prev) => ({
      ...prev,
      provider,
      model: nextProvider?.default_model || nextProvider?.models?.[0] || prev.model,
      ...(settings.image_generation.request_overrides_supported && provider !== prev.provider
        ? { extraHeaders: "", extraBody: "" } : {}),
    }));
  };

  return (
    <div className="settings-stack" onChangeCapture={edits.onChangeCapture} onFocusCapture={edits.onFocusCapture} onBlurCapture={edits.onBlurCapture}>
      <section>
        {!embedded ? <SettingsSectionTitle>{tx("settings.sections.imageGeneration", "Image generation")}</SettingsSectionTitle> : null}
        <SettingsGroup>
          {!embedded ? (
          <SettingsRow title={tx("settings.rows.imageGeneration", "Image generation")}>
            <ToggleButton
              checked={form.enabled}
              onChange={(enabled) => { edits.complete(); onChangeForm((prev) => ({ ...prev, enabled })); }}
              ariaLabel={tx("settings.rows.imageGeneration", "Image generation")}
              label={form.enabled ? tx("settings.values.on", "On") : tx("settings.values.off", "Off")}
            />
          </SettingsRow>
          ) : null}
          {embedded || form.enabled ? <>
          <SettingsRow title={tx("settings.rows.imageProvider", "Image provider")}
            description={selectedProvider?.uses_images_api ? t("settings.image.imagesApiHint") : undefined}>
            <ProviderPicker
              providers={settings.image_generation.providers}
              value={form.provider}
              emptyLabel={tx("settings.image.selectProvider", "Select provider")}
              showProviderLogos={showBrandLogos}
              onChange={selectProvider}
            />
          </SettingsRow>
          <SettingsRow
            title={tx("settings.rows.imageProviderStatus", "Provider status")}
            description={tx("settings.help.imageProviderStatus", "Image generation reuses provider credentials from Providers.")}
          >
            <div className="flex flex-wrap items-center justify-end gap-2">
              <StatusPill tone={providerConfigured ? "success" : "neutral"}>
                {providerConfigured
                  ? tx("settings.values.configured", "Configured")
                  : tx("settings.values.notConfigured", "Not configured")}
              </StatusPill>
              {!providerConfigured ? (
                <Button size="sm" variant="outline" onClick={onOpenProviders} className="rounded-full">
                  {tx("settings.image.configureProvider", "Configure provider")}
                </Button>
              ) : null}
            </div>
          </SettingsRow>
          <SettingsRow title={tx("settings.rows.imageProviderBase", "Provider URL")}>
            <span className="max-w-[320px] truncate text-right text-[13px] text-muted-foreground">
              {selectedProvider?.api_base || selectedProvider?.default_api_base || selectedProvider?.name || tx("settings.values.notAvailable", "Not available")}
            </span>
          </SettingsRow>
          <SettingsRow title={tx("settings.rows.imageModel", "Image model")}>
            <ModelIdPicker
              token={token}
              settings={settings}
              provider={form.provider}
              models={selectedProvider?.models ?? []}
              value={form.model}
              showProviderLogos={showBrandLogos}
              emptyLabel={tx("settings.image.selectModel", "Select image model")}
              searchPlaceholder={tx(
                "settings.image.searchOrTypeModel",
                "Search or type model ID",
              )}
              emptyMessage={tx(
                "settings.image.typeModelId",
                "Type the model ID supported by this provider.",
              )}
              onChange={(model) => { edits.complete(); onChangeForm((prev) => ({ ...prev, model })); }}
            />
          </SettingsRow>
          <SettingsRow title={tx("settings.rows.defaultAspectRatio", "Default aspect ratio")}>
            <ProviderPicker
              providers={aspectOptions}
              value={form.defaultAspectRatio}
              emptyLabel={tx("settings.image.selectAspect", "Select aspect")}
              onChange={(defaultAspectRatio) => {
                edits.complete();
                onChangeForm((prev) => ({ ...prev, defaultAspectRatio }));
              }}
            />
          </SettingsRow>
          <SettingsRow title={tx("settings.rows.defaultImageSize", "Default size")}>
            <ProviderPicker
              providers={sizeOptions}
              value={form.defaultImageSize}
              emptyLabel={tx("settings.image.selectSize", "Select size")}
              onChange={(defaultImageSize) => {
                edits.complete();
                onChangeForm((prev) => ({ ...prev, defaultImageSize }));
              }}
            />
          </SettingsRow>
          <SettingsAdvancedOptions>
          {settings.image_generation.request_overrides_supported && (
            <div className="settings-list-inset space-y-3 py-3">
              <p className="text-[13px] text-muted-foreground">{t("settings.image.requestOverridesHint")}</p>
              <ProviderParameterFields fields={["extra_headers", "extra_body"]}
                inherit disabled={saving || dirty || missingCredential}
                onSave={onSaveRequestSettings}
                form={{ extraHeaders: form.extraHeaders ?? "", extraBody: form.extraBody ?? "", extraQuery: "" }}
                onChange={(value) => onChangeForm((prev) => ({ ...prev, ...value }))}
              />
            </div>
          )}
          <SettingsRow title={tx("settings.rows.maxImagesPerTurn", "Max images per request")}>
            <NumberInput
              value={form.maxImagesPerTurn}
              min={1}
              max={8}
              onChange={(maxImagesPerTurn) =>
                onChangeForm((prev) => ({ ...prev, maxImagesPerTurn }))
              }
            />
          </SettingsRow>
          {!settings.runtime_config ? (
            <ReadOnlyRow title={tx("settings.rows.imageSaveDir", "Save directory")} value={settings.image_generation.save_dir} />
          ) : null}
          {children}
          </SettingsAdvancedOptions>
          </> : null}
          <RestartSettingsFooter
            error={missingCredential || Boolean(error)}
            autoSave
            dirty={dirty}
            saving={saving}
            pendingRestart={!embedded && requiresRestartPending}
            disabled={missingCredential}
            message={
              missingCredential
                ? tx("settings.image.missingCredential", "Configure this provider before enabling image generation.")
                : error
            }
            dirtyMessage={tx("settings.status.restartAfterSaving", "Save changes, then restart nanobot to apply them.")}
            pendingMessage={tx("settings.status.savedRestartApply", "Saved. Restart to apply changes.")}
            onSave={onSave}
            onRestart={onRestart}
            isRestarting={isRestarting}
          />
        </SettingsGroup>
      </section>
    </div>
  );
}