fix(message_input): recognize uppercase URL schemes for link enrichment

Uppercase schemes like `HTTPS://` were detected but forwarded verbatim
to the enrichment endpoint, which failed to return link-preview data.
Normalize the scheme before enriching so `HTTPS://` behaves like
`https://`.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: xsahil03x

packages/stream_chat_flutter/CHANGELOG.md

@@ -12,6 +12,7 @@
 
 🐞 Fixed
 
+- Fixed link preview enrichment failing for uppercase URL schemes (e.g. `HTTPS://`) by normalizing the scheme before enriching.
 - Fixed last-message preview flicker during channel-state reloads.
 - Fixed shadowed messages not hidden in channel list items.
 - Fixed `StreamMessageListView` firing `markThreadRead` on a reply-less parent, which produced a guaranteed 404 every time the thread view was opened before the first reply.

packages/stream_chat_flutter/lib/src/message_input/stream_message_composer.dart

@@ -1293,20 +1293,23 @@ class DefaultStreamMessageComposerState extends State<DefaultStreamMessageCompos
     if (_lastSearchedContainsUrlText == value) return;
     _lastSearchedContainsUrlText = value;
 
-    final matchedUrls = _urlRegex.allMatches(value).where((it) {
-      final _parsedMatch = Uri.tryParse(it.group(0) ?? '')?.withScheme;
-      if (_parsedMatch == null) return false;
-
-      return widget.props.ogPreviewFilter.call(_parsedMatch, value);
-    }).toList();
+    // Find the first url to preview, normalizing the scheme so links like
+    // `HTTPS://` enrich the same as `https://`.
+    String? firstMatchedUrl;
+    for (final match in _urlRegex.allMatches(value)) {
+      final url = Uri.tryParse(match.group(0) ?? '')?.withScheme;
+      if (url == null) continue;
+      if (!widget.props.ogPreviewFilter.call(url, value)) continue;
+
+      firstMatchedUrl = url.toString();
+      break;
+    }
 
     // Reset the og attachment if the text doesn't contain any url
-    if (matchedUrls.isEmpty || !channel.canSendLinks) {
+    if (firstMatchedUrl == null || !channel.canSendLinks) {
       return _effectiveController.clearOGAttachment();
     }
 
-    final firstMatchedUrl = matchedUrls.first.group(0)!;
-
     // If the parsed url matches the ogAttachment url, don't do anything
     if (_effectiveController.ogAttachment?.titleLink == firstMatchedUrl) {
       return;

packages/stream_chat_flutter/test/src/message_input/message_composer_url_enrichment_test.dart

@@ -0,0 +1,99 @@
+// ignore_for_file: lines_longer_than_80_chars
+
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mocktail/mocktail.dart';
+import 'package:record/record.dart';
+import 'package:stream_chat_flutter/stream_chat_flutter.dart';
+
+import '../fakes.dart';
+import '../mocks.dart';
+
+void main() {
+  group('MessageComposer URL enrichment', () {
+    final originalRecordPlatform = RecordPlatform.instance;
+    setUp(() => RecordPlatform.instance = FakeRecordPlatform());
+    tearDown(() => RecordPlatform.instance = originalRecordPlatform);
+
+    late MockClient client;
+    late MockClientState clientState;
+    late MockChannel channel;
+    late MockChannelState channelState;
+
+    setUp(() {
+      registerFallbackValue(Message());
+
+      client = MockClient();
+      clientState = MockClientState();
+      channel = MockChannel(
+        ownCapabilities: const [
+          ChannelCapability.sendMessage,
+          ChannelCapability.sendLinks,
+        ],
+      );
+      channelState = MockChannelState();
+
+      when(() => client.state).thenReturn(clientState);
+      when(() => clientState.currentUser).thenReturn(OwnUser(id: 'user-id'));
+      when(() => clientState.currentUserStream).thenAnswer(
+        (_) => Stream.value(OwnUser(id: 'user-id')),
+      );
+
+      when(() => channel.state).thenReturn(channelState);
+      when(() => channel.client).thenReturn(client);
+      when(channel.getRemainingCooldown).thenReturn(0);
+
+      when(() => client.enrichUrl(any())).thenAnswer(
+        (invocation) async => OGAttachmentResponse()..ogScrapeUrl = invocation.positionalArguments.first as String,
+      );
+    });
+
+    Future<Object?> enrichUrlFrom(WidgetTester tester, String text) async {
+      // Enrichment runs behind a real-clock debounce, so drive the flow with
+      // real timers via runAsync.
+      await tester.runAsync(() async {
+        await tester.pumpWidget(
+          MaterialApp(
+            home: StreamChat(
+              client: client,
+              connectivityStream: Stream.value([ConnectivityResult.mobile]),
+              child: StreamChannel(
+                channel: channel,
+                child: Scaffold(body: StreamMessageComposer()),
+              ),
+            ),
+          ),
+        );
+        await tester.pumpAndSettle();
+
+        await tester.enterText(find.byType(TextField), text);
+        await Future<void>.delayed(const Duration(milliseconds: 500));
+        await tester.pumpAndSettle();
+      });
+
+      return verify(() => client.enrichUrl(captureAny())).captured.single;
+    }
+
+    testWidgets(
+      'normalizes an uppercase HTTPS:// scheme before enriching',
+      (tester) async {
+        // The scheme is normalized to lowercase before enriching so a buggy
+        // backend receives the same URL as the lowercase variant.
+        expect(
+          await enrichUrlFrom(tester, 'HTTPS://example.com'),
+          'https://example.com',
+        );
+      },
+    );
+
+    testWidgets(
+      'enriches a lowercase https:// scheme unchanged',
+      (tester) async {
+        expect(
+          await enrichUrlFrom(tester, 'https://example.com'),
+          'https://example.com',
+        );
+      },
+    );
+  });
+}