Allow per-profile control over spontaneous file upload (disable upload button & drag-and-drop)

[Jimmy-Newtron]

Is your feature request related to a problem? Please describe.
When enabling file upload capabilities in the Chainlit configuration (e.g., spontaneous file upload), the feature is currently applied globally across the application.

In a multi-profile setup (multiple assistants available in the UI), this creates a limitation: all profiles inherit the same file upload behavior.

However, in many real-world use cases, not all assistants should accept file uploads. For example:

• Some assistants may be designed for strict text-only interactions.
• Others may handle sensitive contexts where file uploads should be restricted.
• UX-wise, showing an upload button when it is not supported by the assistant can be confusing.

Currently, there is no way to:

• Disable the upload button for specific profiles
• Prevent drag-and-drop file uploads on a per-profile basis

Describe the solution you'd like
Introduce a per-profile configuration option to control file upload capabilities.

For example:

• Add a file_upload (or similar) setting at the profile level

• Allow enabling/disabling:

  • Upload button visibility
  • Drag-and-drop behavior

Example (conceptual):

profiles:
  - name: assistant_a
    file_upload:
      enabled: true

  - name: assistant_b
    file_upload:
      enabled: false

Expected behavior:

• When enabled: false:

  • The upload button is hidden or disabled in the UI
  • Drag-and-drop is ignored or blocked

• When enabled: true:

  • Current behavior remains unchanged

Describe alternatives you've considered

• Disabling file upload globally at the server level:
  → Not suitable because it removes the feature for all profiles.

• Handling file uploads conditionally in backend logic:
  → Still exposes the UI elements, leading to poor UX and possible confusion.

• Custom frontend modification:
  → Not ideal, as it requires maintaining a fork or patching the UI.

Additional context
This feature would significantly improve flexibility in multi-assistant applications, especially in production environments where different assistants have different capabilities and constraints.

It would also align the UI behavior more closely with the actual capabilities of each profile, improving both usability and security.