The owner answered A. The receiver recorded B.
Compare the authorized, interleaved, and guarded effects.
See the result →An owner opened a workflow confirmation for A in an ADK A2A task. A second authorized caller sent B into the same context. The owner answered the original A task, and a separate protected receiver recorded B in three fresh runs on an owned Google Agent Runtime.
The confirmation shown to the owner named A. The later B invocation carried the same product-generated confirmation identity. The owner responded to the original A task; independent receiver records showed B. An A-only control wrote A, and a guarded B comparison denied B.
Compare the authorized, interleaved, and guarded effects.
See the result →Follow the shared session identity and distinct task IDs.
Follow the path →Trace the source-bound identity collision and replay.
Inspect the cause →See the proposed check and three repaired reattacks.
Review the repair →The application’s protected function was a native ADK Workflow node with require_confirmation=True. The owner’s card showed target A. The second caller supplied target B before the owner answered.
| Comparison | Owner action | Independent receiver result |
|---|---|---|
| Authorized A control | Approve the A request | A committed |
| Interleaved A/B | Respond to the original A task after B enters the context | B committed in three fresh hosted contexts |
| Guarded B | Deny the protected B action | B denied |
Each hosted B run used a fresh context. The receiver’s attempt log and owner readback checked the action separately from ADK’s own events. The control cells establish what the same protected function did with an ordinary A approval and with a guarded B request.
Both principals had permission to invoke the owned Agent Runtime. The second held an explicit Agent Platform User grant and sent B with the pending A2A context ID while the owner’s A request waited.
The two A2A tasks had different task and invocation IDs. In the tested deployment, ADK’s converter received no authenticated call_context user to distinguish the IAM-authorized callers. In google-adk==2.13.0, that converter falls back to A2A_USER_<context_id>. The shared context therefore produced the same synthetic user and session for both calls.
The protected function’s confirmation ID matched across the A and B invocations. The owner responded through the original A task. The runtime then resolved the newer B invocation, and the protected receiver recorded B.
A native workflow with a confirmation-gated function, a pending A task, a second principal permitted to invoke the same runtime, and the pending A2A context ID. The tested converter path used its context-derived user fallback.
The separate source-bound proof pins google/adk-python to commit 8cd3b12c8a5d658c5e0d3ea0731d8be34a092a4a. In src/google/adk/workflow/_function_node.py:833, the confirmation request uses node_path=ctx.node_path.
The route is Runner.run_async → Workflow → FunctionNode._run_impl → protected_write. For repeated calls to the same FunctionNode in the session, the node path can repeat while the bound arguments change from A to B. The confirmation identity derived from that path also repeats. The local trace checks the A and B cards, their IDs, the resolved invocation, and the protected callback.
The hosted effect used packaged google-adk==2.13.0 with a2a-sdk==1.3.0. The pinned source proof used the separately archived 2.12.0 revision. These are two measured layers of the case: the hosted two-caller effect and the source-bound FunctionNode trace.
A response to a confirmation for A should authorize the specific function invocation and arguments shown to the owner. Here the product-generated identity could designate a later B invocation in the same session.
8cd3b12c8a5d658c5e0d3ea0731d8be34a092a4aef19b27dbf18116ef72c7c53cb2559cd312b9c8cac9dfad37029ac9bbee49cf2The investigation repeated the A/B/guarded comparison in the hosted runtime and in an independently runnable local package.
Two IAM-authorized callers entered the owned Agent Runtime through A2A. The owner’s original-task response resumed the B invocation. Receiver attempts and readback confirmed three B writes.
The hosted comparison also included an A-only commit and a guarded B denial. The targets were synthetic A/B markers in an owned deployment.
Three fresh pinned-source runs each checked the source path, confirmation identities, protected receiver attempt, and owner readback.
The authorized control wrote A. Approval of the original A card resolved the retargeted invocation and wrote B. The guarded B case was denied.
Three fresh reattacks blocked B while preserving the A control. This tested a local ambiguity check on the pinned source.
A local A2A replay also exercised two ephemeral caller tokens over actual A2A JSON-RPC in three fresh contexts, with A and guarded controls. The hosted experiment used Google IAM; the local replay models that caller separation at its own ingress. The package’s offline verifier checks its archived evidence and hashes before fresh runs.
Bind an A2A context to its authenticated caller or explicit participants. Assign every pending workflow confirmation a unique invocation identity tied to its node and canonical arguments.
At response time, match the caller, session, pending invocation, and arguments shown on the card before dispatching the protected function. Reject an ambiguous or stale response. A regression test should open A, interleave B from the second caller in the same context, answer the original A task, and read the receiver: A remains authorized and B remains untouched.
The local reference repair applied an ambiguity check to the pinned workflow source. In three fresh reattacks, B reached no protected receiver while the A control continued to work. That is a tested proposal for this path; the full caller-to-context binding belongs in the runtime boundary as well.
The hosted result covers two authorized callers sharing a known context in one owned Google Agent Runtime, with synthetic A/B targets. The record establishes the wrong-target approval effect under those conditions and makes no claim about customer data or another tenant.
We compared the result with public ADK issues before isolating this two-caller, product-generated identity collision.
Issue #6198 describes a confirmation and resume loop. Issue #5617 concerns an application-supplied repeated interrupt ID in the development UI. Issue #6461 describes an A2A peer supplying its own approval. Our test followed the owner’s response to the original A task through two authorized runtime callers, a product-generated FunctionNode ID shared with B, and a protected B write.
The owner saw A and answered A’s original task. The protected receiver committed B. Approval has to follow the exact caller, invocation, and arguments all the way through execution.
The source link is pinned to the tested workflow revision. The hosted and local receiver records support the measured effects described above.
require_confirmation behavior.
We trace the caller, card, workflow invocation, and receiver effect, then reattack the proposed correction against the same action.
48-hour Rapid Scan →