Skip to content

Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.

3.0 KB
Raw Blame
import { useCallback } from "react";
import { ProviderTabs } from "./ui/ProviderTabs";
import EnterpriseProviderConfig from "./EnterpriseProviderConfig";
import { REASONING_PROVIDERS } from "../models/ModelRegistry";
import { useSettingsStore } from "../stores/settingsStore";
import { adjustBedrockModelForRegion } from "../utils/bedrockRegions";
import {
  filterEnterpriseProviderOptionsByPolicy,
  isEnterpriseProviderAllowed,
} from "../stores/policyRules";
import { usePolicySnapshot } from "../hooks/usePolicy";

const ENTERPRISE_PROVIDER_TABS = [
  { id: "bedrock", name: "AWS Bedrock" },
  { id: "azure", name: "Azure OpenAI" },
  { id: "vertex", name: "Vertex AI", disabled: true, disabledLabel: "Soon" },
];

interface EnterpriseSectionProps {
  currentProvider: string;
  reasoningModel: string;
  setReasoningModel: (m: string) => void;
  setLocalReasoningProvider: (p: string) => void;
}

export default function EnterpriseSection({
  currentProvider,
  reasoningModel,
  setReasoningModel,
  setLocalReasoningProvider,
}: EnterpriseSectionProps) {
  const azureDeploymentName = useSettingsStore((s) => s.azureDeploymentName);
  const bedrockRegion = useSettingsStore((s) => s.bedrockRegion);
  const policyState = usePolicySnapshot();
  const providerAllowed = useCallback(
    (providerId: string) => isEnterpriseProviderAllowed(policyState, providerId),
    [policyState]
  );

  const providerTabs = filterEnterpriseProviderOptionsByPolicy(
    ENTERPRISE_PROVIDER_TABS,
    policyState
  );
  const selectedEnterprise = providerTabs.some((provider) => provider.id === currentProvider)
    ? currentProvider
    : "";

  const handleEnterpriseSelect = useCallback(
    (providerId: string) => {
      if (selectedEnterprise === providerId) return;
      if (!providerAllowed(providerId)) return;
      setLocalReasoningProvider(providerId);

      const providerData = REASONING_PROVIDERS[providerId];
      if (providerData?.models?.length) {
        const defaultModel = providerData.models[0].value;
        setReasoningModel(
          providerId === "bedrock"
            ? adjustBedrockModelForRegion(defaultModel, bedrockRegion)
            : defaultModel
        );
      } else if (providerId === "azure" && azureDeploymentName) {
        setReasoningModel(azureDeploymentName);
      }
    },
    [
      azureDeploymentName,
      bedrockRegion,
      providerAllowed,
      selectedEnterprise,
      setLocalReasoningProvider,
      setReasoningModel,
    ]
  );

  return (
    <div className="space-y-2">
      {providerTabs.length > 0 && (
        <ProviderTabs
          providers={providerTabs}
          selectedId={selectedEnterprise}
          onSelect={handleEnterpriseSelect}
          colorScheme="purple"
        />
      )}

      {selectedEnterprise && (
        <EnterpriseProviderConfig
          provider={selectedEnterprise as "bedrock" | "azure" | "vertex"}
          reasoningModel={reasoningModel}
          setReasoningModel={setReasoningModel}
        />
      )}
    </div>
  );
}