Question

If I return last_chunk = true in a TaskArtifactUpdateEvent, can I still replace or update the artifact afterwards?

Context

The TaskArtifactUpdateEvent message has two fields related to artifact streaming:

message TaskArtifactUpdateEvent {
  // ...
  Artifact artifact = 3 [(google.api.field_behavior) = REQUIRED];
  // If true, the content of this artifact should be appended to a previously
  // sent artifact with the same ID.
  bool append = 4;
  // If true, this is the final chunk of the artifact.
  bool last_chunk = 5;
  // ...
}

Scenario

Consider this sequence:

1. Agent sends TaskArtifactUpdateEvent with artifact_id = "output1", append = false, last_chunk = false
2. Agent sends TaskArtifactUpdateEvent with artifact_id = "output1", append = true, last_chunk = false
3. Agent sends TaskArtifactUpdateEvent with artifact_id = "output1", append = true, last_chunk = true ✓ Final chunk
4. Question: Can agent send another TaskArtifactUpdateEvent with artifact_id = "output1" after this?

Use Cases to Consider

Use Case 1: Correction/Refinement

Agent realizes after marking last_chunk = true that the artifact needs correction:

• Should this be allowed by sending a new artifact with same ID and append = false?
• Or is the artifact considered "sealed" once last_chunk = true is sent?

Use Case 2: Incremental Processing

Agent produces a large artifact in chunks, marks it complete with last_chunk = true, but later discovers additional content to add:

• Can the agent "reopen" the artifact?
• Or should this be a new artifact with a different ID?

Use Case 3: Multi-stage Artifacts

Agent produces a draft artifact (with last_chunk = true), then a refined version:

• Should both versions have the same artifact ID (replacement)?
• Or should they be separate artifacts with different IDs?

What Needs Clarification

1. Semantics of last_chunk: Does last_chunk = true mean:

   • "I'm done appending to this artifact for now" (soft boundary)
   • "This artifact is finalized and immutable" (hard boundary)

2. Replacement vs. Append: If replacement is allowed after last_chunk = true:

   • Should clients discard previous chunks?
   • Should there be a way to signal "this supersedes the previous artifact"?

3. Client Expectations: What should clients do when:

   • They receive last_chunk = true and consider the artifact complete
   • They then receive another update for the same artifact ID

Current Specification Gaps

The specification doesn't explicitly address:

• Whether updates are allowed after last_chunk = true
• The lifecycle and mutability semantics of artifacts
• How clients should handle "unexpected" artifact updates

Recommendation

The specification should clearly define:

1. Whether artifacts can be updated after last_chunk = true
2. If updates are allowed, whether they replace or modify existing content
3. Best practices for artifact versioning if updates are not allowed
4. How clients should handle out-of-sequence or unexpected artifact updates

This clarity would help both agent implementers and client implementers understand artifact lifecycle management.