Add Reactions and TargetedMessage support to Core

.gitignore

@@ -9,6 +9,8 @@
 # local app settings files
 appsettings.Local.json
 
+.claude/
+
 # User-specific files
 *.rsuser
 *.suo

core/samples/CompatBot/EchoBot.cs

@@ -3,7 +3,6 @@
 
 using Microsoft.Bot.Builder;
 using Microsoft.Bot.Builder.Teams;
-using Microsoft.Bot.Connector;
 using Microsoft.Bot.Schema;
 using Microsoft.Bot.Schema.Teams;
 using Microsoft.Teams.Bot.Apps;
@@ -40,6 +39,17 @@ protected override async Task OnMessageActivityAsync(ITurnContext<IMessageActivi
         await turnContext.SendActivityAsync(MessageFactory.Text(replyText, replyText), cancellationToken);
         await turnContext.SendActivityAsync(MessageFactory.Text($"Send a proactive message `/api/notify/{turnContext.Activity.Conversation.Id}`"), cancellationToken);
 
+        var activity = ((Activity)turnContext.Activity).FromCompatActivity();
+        TeamsActivity tm = TeamsActivity.CreateBuilder()
+            .WithConversation(new Conversation { Id = activity.Conversation?.Id! })
+            .WithText("Hello TM !")
+            .WithRecipient(activity.From, true)
+            .WithFrom(activity.Recipient)
+            .WithServiceUrl(activity.ServiceUrl!)
+            .Build();
+
+        await teamsBotApp.ConversationClient.SendActivityAsync(tm, cancellationToken: cancellationToken);
+
         // TeamsAPXClient provides Teams-specific operations like:
         // - FetchTeamDetailsAsync, FetchChannelListAsync
         // - FetchMeetingInfoAsync, FetchParticipantAsync, SendMeetingNotificationAsync

core/samples/TeamsBot/GlobalSuppressions.cs

@@ -0,0 +1,8 @@
+// This file is used by Code Analysis to maintain SuppressMessage
+// attributes that are applied to this project.
+// Project-level suppressions either have no target or are given
+// a specific target and scoped to a namespace, type, member, etc.
+
+using System.Diagnostics.CodeAnalysis;
+
+[assembly: SuppressMessage("Performance", "SYSLIB1045:Convert to 'GeneratedRegexAttribute'.", Justification = "<Pending>")]

core/samples/TeamsBot/Program.cs

@@ -16,8 +16,6 @@
 teamsApp.OnMessage("(?i)hello", async (context, cancellationToken) =>
 {
     await context.SendActivityAsync("Hi there! 👋 You said hello!", cancellationToken);
-
-    await teamsApp.Api.Conversations.Reactions.AddAsync(context.Activity, "cake", cancellationToken: cancellationToken);
 });
 
 // Markdown handler: matches "markdown" (case-insensitive)

core/src/Microsoft.Teams.Bot.Core/ConversationClient.cs

@@ -56,7 +56,12 @@ public async Task<SendActivityResponse> SendActivityAsync(CoreActivity activity,
             url += activity.ReplyToId;
         }
 
-        logger?.LogInformation("Sending activity with type `{Type}` to {Url}", activity.Type, url);
+        if (activity.IsTargeted)
+        {
+            url += url.Contains('?', StringComparison.Ordinal) ? "&isTargetedActivity=true" : "?isTargetedActivity=true";
+        }
+
+        logger?.LogInformation("Sending activity to {Url}", url);
 
         string body = activity.ToJson();
 
@@ -88,6 +93,12 @@ public async Task<UpdateActivityResponse> UpdateActivityAsync(string conversatio
         ArgumentNullException.ThrowIfNull(activity.ServiceUrl);
 
         string url = $"{activity.ServiceUrl.ToString().TrimEnd('/')}/v3/conversations/{conversationId}/activities/{activityId}";
+
+        if (activity.IsTargeted)
+        {
+            url += "?isTargetedActivity=true";
+        }
+
         string body = activity.ToJson();
 
         logger.LogTrace("Updating activity at {Url}: {Activity}", url, body);
@@ -112,14 +123,36 @@ public async Task<UpdateActivityResponse> UpdateActivityAsync(string conversatio
     /// <param name="cancellationToken">A cancellation token that can be used to cancel the delete operation.</param>
     /// <returns>A task that represents the asynchronous operation.</returns>
     /// <exception cref="HttpRequestException">Thrown if the activity could not be deleted successfully.</exception>
-    public async Task DeleteActivityAsync(string conversationId, string activityId, Uri serviceUrl, AgenticIdentity? agenticIdentity = null, CustomHeaders? customHeaders = null, CancellationToken cancellationToken = default)
+    public Task DeleteActivityAsync(string conversationId, string activityId, Uri serviceUrl, AgenticIdentity? agenticIdentity = null, CustomHeaders? customHeaders = null, CancellationToken cancellationToken = default)
+    {
+        return DeleteActivityAsync(conversationId, activityId, serviceUrl, isTargeted: false, agenticIdentity, customHeaders, cancellationToken);
+    }
+
+    /// <summary>
+    /// Deletes an existing activity from a conversation.
+    /// </summary>
+    /// <param name="conversationId">The ID of the conversation. Cannot be null or whitespace.</param>
+    /// <param name="activityId">The ID of the activity to delete. Cannot be null or whitespace.</param>
+    /// <param name="serviceUrl">The service URL for the conversation. Cannot be null.</param>
+    /// <param name="isTargeted">If true, deletes a targeted activity.</param>
+    /// <param name="agenticIdentity">Optional agentic identity for authentication.</param>
+    /// <param name="customHeaders">Optional custom headers to include in the request.</param>
+    /// <param name="cancellationToken">A cancellation token that can be used to cancel the delete operation.</param>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    /// <exception cref="HttpRequestException">Thrown if the activity could not be deleted successfully.</exception>
+    public async Task DeleteActivityAsync(string conversationId, string activityId, Uri serviceUrl, bool isTargeted, AgenticIdentity? agenticIdentity = null, CustomHeaders? customHeaders = null, CancellationToken cancellationToken = default)
     {
         ArgumentException.ThrowIfNullOrWhiteSpace(conversationId);
         ArgumentException.ThrowIfNullOrWhiteSpace(activityId);
         ArgumentNullException.ThrowIfNull(serviceUrl);
 
         string url = $"{serviceUrl.ToString().TrimEnd('/')}/v3/conversations/{conversationId}/activities/{activityId}";
 
+        if (isTargeted)
+        {
+            url += "?isTargetedActivity=true";
+        }
+
         logger.LogTrace("Deleting activity at {Url}", url);
 
         await _botHttpClient.SendAsync(
@@ -150,6 +183,7 @@ await DeleteActivityAsync(
             activity.Conversation.Id,
             activity.Id,
             activity.ServiceUrl,
+            activity.IsTargeted,
             activity.From?.GetAgenticIdentity(),
             customHeaders,
             cancellationToken).ConfigureAwait(false);

core/src/Microsoft.Teams.Bot.Core/Schema/CoreActivity.cs

@@ -58,6 +58,11 @@ public class CoreActivity
     /// </summary>
     [JsonPropertyName("recipient")] public ConversationAccount? Recipient { get; set; }
     /// <summary>
+    /// Indicates if this is a targeted message visible only to a specific recipient.
+    /// Used internally by the SDK for routing - not serialized to the service.
+    /// </summary>
+    [JsonIgnore] public bool IsTargeted { get; set; }
+    /// <summary>
     /// Gets or sets the conversation in which this activity is taking place.
     /// </summary>
     [JsonPropertyName("conversation")] public Conversation? Conversation { get; set; }
@@ -153,6 +158,7 @@ protected CoreActivity(CoreActivity activity)
         Attachments = activity.Attachments;
         Properties = activity.Properties;
         Value = activity.Value;
+        IsTargeted = activity.IsTargeted;
     }
 
     /// <summary>

core/src/Microsoft.Teams.Bot.Core/Schema/CoreActivityBuilder.cs

@@ -47,7 +47,7 @@ public TBuilder WithConversationReference(TActivity activity)
         WithChannelId(activity.ChannelId);
         SetConversation(activity.Conversation);
         SetFrom(activity.Recipient);
-        SetRecipient(activity.From);
+        //SetRecipient(activity.From);
 
         if (!string.IsNullOrEmpty(activity.Id))
         {
@@ -156,8 +156,20 @@ public TBuilder WithFrom(ConversationAccount? from)
     /// <param name="recipient">The recipient account.</param>
     /// <returns>The builder instance for chaining.</returns>
     public TBuilder WithRecipient(ConversationAccount? recipient)
+    {
+        return WithRecipient(recipient, false);
+    }
+
+    /// <summary>
+    /// Sets the recipient account information and optionally marks this as a targeted message.
+    /// </summary>
+    /// <param name="recipient">The recipient account.</param>
+    /// <param name="isTargeted">If true, marks this as a targeted message visible only to the specified recipient.</param>
+    /// <returns>The builder instance for chaining.</returns>
+    public TBuilder WithRecipient(ConversationAccount? recipient, bool isTargeted)
     {
         SetRecipient(recipient);
+        _activity.IsTargeted = isTargeted;
         return (TBuilder)this;
     }
 

core/test/Microsoft.Teams.Bot.Core.UnitTests/ConversationClientTests.cs

@@ -171,6 +171,178 @@ public async Task SendActivityAsync_ConstructsCorrectUrl()
         Assert.Equal(HttpMethod.Post, capturedRequest.Method);
     }
 
+    [Fact]
+    public async Task SendActivityAsync_WithIsTargeted_AppendsQueryString()
+    {
+        HttpRequestMessage? capturedRequest = null;
+        Mock<HttpMessageHandler> mockHttpMessageHandler = new();
+        mockHttpMessageHandler
+            .Protected()
+            .Setup<Task<HttpResponseMessage>>(
+                "SendAsync",
+                ItExpr.IsAny<HttpRequestMessage>(),
+                ItExpr.IsAny<CancellationToken>())
+            .Callback<HttpRequestMessage, CancellationToken>((req, ct) => capturedRequest = req)
+            .ReturnsAsync(new HttpResponseMessage
+            {
+                StatusCode = HttpStatusCode.OK,
+                Content = new StringContent("{\"id\":\"activity123\"}")
+            });
+
+        HttpClient httpClient = new(mockHttpMessageHandler.Object);
+        ConversationClient conversationClient = new(httpClient);
+
+        CoreActivity activity = new()
+        {
+            Type = ActivityType.Message,
+            Conversation = new Conversation { Id = "conv123" },
+            ServiceUrl = new Uri("https://test.service.url/"),
+            IsTargeted = true
+        };
+
+        await conversationClient.SendActivityAsync(activity);
+
+        Assert.NotNull(capturedRequest);
+        Assert.Contains("isTargetedActivity=true", capturedRequest.RequestUri?.ToString());
+    }
+
+    [Fact]
+    public async Task SendActivityAsync_WithIsTargetedFalse_DoesNotAppendQueryString()
+    {
+        HttpRequestMessage? capturedRequest = null;
+        Mock<HttpMessageHandler> mockHttpMessageHandler = new();
+        mockHttpMessageHandler
+            .Protected()
+            .Setup<Task<HttpResponseMessage>>(
+                "SendAsync",
+                ItExpr.IsAny<HttpRequestMessage>(),
+                ItExpr.IsAny<CancellationToken>())
+            .Callback<HttpRequestMessage, CancellationToken>((req, ct) => capturedRequest = req)
+            .ReturnsAsync(new HttpResponseMessage
+            {
+                StatusCode = HttpStatusCode.OK,
+                Content = new StringContent("{\"id\":\"activity123\"}")
+            });
+
+        HttpClient httpClient = new(mockHttpMessageHandler.Object);
+        ConversationClient conversationClient = new(httpClient);
+
+        CoreActivity activity = new()
+        {
+            Type = ActivityType.Message,
+            Conversation = new Conversation { Id = "conv123" },
+            ServiceUrl = new Uri("https://test.service.url/"),
+            IsTargeted = false
+        };
+
+        await conversationClient.SendActivityAsync(activity);
+
+        Assert.NotNull(capturedRequest);
+        Assert.DoesNotContain("isTargetedActivity", capturedRequest.RequestUri?.ToString());
+    }
+
+    [Fact]
+    public async Task UpdateActivityAsync_WithIsTargeted_AppendsQueryString()
+    {
+        HttpRequestMessage? capturedRequest = null;
+        Mock<HttpMessageHandler> mockHttpMessageHandler = new();
+        mockHttpMessageHandler
+            .Protected()
+            .Setup<Task<HttpResponseMessage>>(
+                "SendAsync",
+                ItExpr.IsAny<HttpRequestMessage>(),
+                ItExpr.IsAny<CancellationToken>())
+            .Callback<HttpRequestMessage, CancellationToken>((req, ct) => capturedRequest = req)
+            .ReturnsAsync(new HttpResponseMessage
+            {
+                StatusCode = HttpStatusCode.OK,
+                Content = new StringContent("{\"id\":\"activity123\"}")
+            });
+
+        HttpClient httpClient = new(mockHttpMessageHandler.Object);
+        ConversationClient conversationClient = new(httpClient, NullLogger<ConversationClient>.Instance);
+
+        CoreActivity activity = new()
+        {
+            Type = ActivityType.Message,
+            ServiceUrl = new Uri("https://test.service.url/"),
+            IsTargeted = true
+        };
+
+        await conversationClient.UpdateActivityAsync("conv123", "activity123", activity);
+
+        Assert.NotNull(capturedRequest);
+        Assert.Contains("isTargetedActivity=true", capturedRequest.RequestUri?.ToString());
+        Assert.Equal(HttpMethod.Put, capturedRequest.Method);
+    }
+
+    [Fact]
+    public async Task DeleteActivityAsync_WithIsTargeted_AppendsQueryString()
+    {
+        HttpRequestMessage? capturedRequest = null;
+        Mock<HttpMessageHandler> mockHttpMessageHandler = new();
+        mockHttpMessageHandler
+            .Protected()
+            .Setup<Task<HttpResponseMessage>>(
+                "SendAsync",
+                ItExpr.IsAny<HttpRequestMessage>(),
+                ItExpr.IsAny<CancellationToken>())
+            .Callback<HttpRequestMessage, CancellationToken>((req, ct) => capturedRequest = req)
+            .ReturnsAsync(new HttpResponseMessage
+            {
+                StatusCode = HttpStatusCode.OK
+            });
+
+        HttpClient httpClient = new(mockHttpMessageHandler.Object);
+        ConversationClient conversationClient = new(httpClient, NullLogger<ConversationClient>.Instance);
+
+        await conversationClient.DeleteActivityAsync(
+            "conv123",
+            "activity123",
+            new Uri("https://test.service.url/"),
+            isTargeted: true);
+
+        Assert.NotNull(capturedRequest);
+        Assert.Contains("isTargetedActivity=true", capturedRequest.RequestUri?.ToString());
+        Assert.Equal(HttpMethod.Delete, capturedRequest.Method);
+    }
+
+    [Fact]
+    public async Task DeleteActivityAsync_WithActivity_UsesIsTargetedProperty()
+    {
+        HttpRequestMessage? capturedRequest = null;
+        Mock<HttpMessageHandler> mockHttpMessageHandler = new();
+        mockHttpMessageHandler
+            .Protected()
+            .Setup<Task<HttpResponseMessage>>(
+                "SendAsync",
+                ItExpr.IsAny<HttpRequestMessage>(),
+                ItExpr.IsAny<CancellationToken>())
+            .Callback<HttpRequestMessage, CancellationToken>((req, ct) => capturedRequest = req)
+            .ReturnsAsync(new HttpResponseMessage
+            {
+                StatusCode = HttpStatusCode.OK
+            });
+
+        HttpClient httpClient = new(mockHttpMessageHandler.Object);
+        ConversationClient conversationClient = new(httpClient, NullLogger<ConversationClient>.Instance);
+
+        CoreActivity activity = new()
+        {
+            Id = "activity123",
+            Type = ActivityType.Message,
+            Conversation = new Conversation { Id = "conv123" },
+            ServiceUrl = new Uri("https://test.service.url/"),
+            IsTargeted = true
+        };
+
+        await conversationClient.DeleteActivityAsync(activity);
+
+        Assert.NotNull(capturedRequest);
+        Assert.Contains("isTargetedActivity=true", capturedRequest.RequestUri?.ToString());
+        Assert.Equal(HttpMethod.Delete, capturedRequest.Method);
+    }
+
     [Fact]
     public async Task SendActivityAsync_WithReplyToId_AppendsReplyToIdToUrl()
     {