fix: Correctly set Append flag in TaskArtifactUpdateEvent and add UpdateArtifactAsync usage examples

src/A2A/A2A.csproj

@@ -20,6 +20,7 @@
   <!-- Dependencies only needed by netstandard2.0 -->
   <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
     <PackageReference Include="System.Text.Json" />
+        <PackageReference Include="System.Threading.Channels" />
   </ItemGroup>
 
   <!-- Dependencies needed by all -->
@@ -36,7 +37,7 @@
           <PrivateAssets>all</PrivateAssets>
           <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>
-      <PackageReference Include="System.Threading.Channels" />
+
   </ItemGroup>
 
 	<ItemGroup>

src/A2A/Server/ITaskManager.cs

@@ -80,6 +80,21 @@ public interface ITaskManager
     /// <returns>A task representing the asynchronous operation.</returns>
     Task ReturnArtifactAsync(string taskId, Artifact artifact, CancellationToken cancellationToken = default);
 
+    /// <summary>
+    /// Updates an artifact for a task, either by adding a new artifact or appending to the last one.
+    /// </summary>
+    /// <remarks>
+    /// When append is true, the artifact's parts are added to the last artifact in the task's collection.
+    /// When append is false or there are no existing artifacts, a new artifact is added to the collection.
+    /// </remarks>
+    /// <param name="taskId">The ID of the task to update the artifact for.</param>
+    /// <param name="artifact">The artifact containing parts to add.</param>
+    /// <param name="append">Whether to append to the last artifact (true) or create a new one (false).</param>
+    /// <param name="lastChunk">Whether this is the last chunk of the artifact.</param>
+    /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    Task UpdateArtifactAsync(string taskId, Artifact artifact, bool append = false, bool? lastChunk = null, CancellationToken cancellationToken = default);
+
     /// <summary>
     /// Updates the status of a task and optionally adds a message to its history.
     /// </summary>

src/A2A/Server/TaskManager.cs

@@ -457,6 +457,97 @@ public async Task ReturnArtifactAsync(string taskId, Artifact artifact, Cancella
             activity?.SetStatus(ActivityStatusCode.Error, ex.Message);
             throw;
         }
-    }
-    // TODO: Implement UpdateArtifact method
+    }
+
+    /// <inheritdoc />
+    public async Task UpdateArtifactAsync(string taskId, Artifact artifact, bool append = false, bool? lastChunk = null, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+
+        if (string.IsNullOrEmpty(taskId))
+        {
+            throw new A2AException(nameof(taskId), A2AErrorCode.InvalidParams);
+        }
+        else if (artifact is null)
+        {
+            throw new A2AException(nameof(artifact), A2AErrorCode.InvalidParams);
+        }
+
+        using var activity = ActivitySource.StartActivity("UpdateArtifact", ActivityKind.Server);
+        activity?.SetTag("task.id", taskId);
+        activity?.SetTag("artifact.append", append);
+        activity?.SetTag("artifact.lastChunk", lastChunk);
+
+        try
+        {
+            var task = await _taskStore.GetTaskAsync(taskId, cancellationToken).ConfigureAwait(false);
+            if (task != null)
+            {
+                activity?.SetTag("task.found", true);
+
+                task.Artifacts ??= [];
+
+                if (append && task.Artifacts.Count > 0)
+                {
+                    // Append to the last artifact by adding parts to it
+                    var lastArtifact = task.Artifacts[^1];
+
+                    // Add all parts from the new artifact to the last artifact
+                    foreach (var part in artifact.Parts)
+                    {
+                        lastArtifact.Parts.Add(part);
+                    }
+
+                    activity?.SetTag("event.type", "artifact_append");
+                    await _taskStore.SetTaskAsync(task, cancellationToken).ConfigureAwait(false);
+
+                    // Notify with the updated artifact and append=true
+                    _taskUpdateEventEnumerators.TryGetValue(task.Id, out var enumerator);
+                    if (enumerator is not null)
+                    {
+                        var taskUpdateEvent = new TaskArtifactUpdateEvent
+                        {
+                            TaskId = task.Id,
+                            Artifact = lastArtifact,
+                            Append = true,
+                            LastChunk = lastChunk
+                        };
+                        enumerator.NotifyEvent(taskUpdateEvent);
+                    }
+                }
+                else
+                {
+                    // Create a new artifact (either append=false or no existing artifacts)
+                    task.Artifacts.Add(artifact);
+                    activity?.SetTag("event.type", "artifact_new");
+                    await _taskStore.SetTaskAsync(task, cancellationToken).ConfigureAwait(false);
+
+                    // Notify with the new artifact and append=false
+                    _taskUpdateEventEnumerators.TryGetValue(task.Id, out var enumerator);
+                    if (enumerator is not null)
+                    {
+                        var taskUpdateEvent = new TaskArtifactUpdateEvent
+                        {
+                            TaskId = task.Id,
+                            Artifact = artifact,
+                            Append = false, // Always false when creating a new artifact
+                            LastChunk = lastChunk
+                        };
+                        enumerator.NotifyEvent(taskUpdateEvent);
+                    }
+                }
+            }
+            else
+            {
+                activity?.SetTag("task.found", false);
+                activity?.SetStatus(ActivityStatusCode.Error, "Task not found");
+                throw new A2AException("Task not found.", A2AErrorCode.TaskNotFound);
+            }
+        }
+        catch (Exception ex)
+        {
+            activity?.SetStatus(ActivityStatusCode.Error, ex.Message);
+            throw;
+        }
+    }
 }