Yaroslav

fix: remoteagent partial response handling leads to data duplication (#545) * set explicit partial event marking and maintain a temporary artifact for streaming events * fix metadata merging * fix duplicating long running function call * fix citations not included * explicit mark as turnComplete on event conversion * fix response duplication for partial and non-partial events * aggregation logic tests * gemini mock streaming test * added failing test cases * lint * fix partial not reset on errors * fix test

fix: long-running operation handling as a2a input-required task (#499) * Include long-running tool function call and response are into A2A TaskStatus message. This is tracked by `inputRequiredProcessor`. This makes it possible for non-blocking clients to discover which input is required to continue a task. * Before starting execution in `adka2a.Executor` validate that user message carries all the required `FunctionCallResponse`s by comparing them against those recorded in task status. * Added test for checking that A2A request payload is assembled correctly by remoteagent. * Refactored `contents_processor` to use functions from `utils`. * Updated `runner.go` to handle the case when user message carries a function response for a long-running call initiated by a non-root agent. This agent needs to be invoked bypassing root. Added integration tests for two cases: * a2aclient -> a2aserver -> adka2a.Executor -> llmagent with a long running tool * a2aclient -> server A -> adka2a.Executor A ->-> llmagent with remote subagent -> remotesubagent -> server B -> adka2a.Executor B -> llmagent with a long running tool

feat: adka2a conversion extendability and metadata handling (#410) * 1.0.0 compliant change to emit Task as the first event * extension point for modifying emitted events * convert and restore grounding, usage and custom metadata * callbacks for intercepting execution start and end * update a2a-go

feat: adka2a mode with artifact per non-partial event (#599) * implement alternative artifact production mode * update artifact aggregation logic on remote agent append=false, lastChunk=false: emit as partial, restart aggregation append=false, lastChunk=true: emit as non partial, drop aggregation append=true, lastChunk=false: emit as partial, update aggregation append=true, lastChunk=true: emit as partial, update aggregation, emit aggregation as non partial, drop aggregation * agent run processor tests * mixed mode tests * executor outputs test * update explanation * fix lint * remove duplicate test

feat: remoteagent and executor subtask cleanup (#645) * If remoteagent run completes with an error or early break (yield returns false) - cancel rpc task will be sent to the remote server * Added `A2ARemoteTaskCleanupCallback` callback option to `remoteagent.NewA2A`, it can be used to override the remote task cancellation behavior * Extracted agent card resolution to `internal/agent/remoteagent` so that it can be reused in `adka2a` package * Added internal remoteagent state which hold a spec for connecting to the remote server: agent card, resolver options, client factory, etc. * Added the logic for cancelling subagent tasks in input-required when root agent task is cancelled. Cancellation is best-effort. * Added `A2AExecutionCleanupCallback` to `adka2a.Executor` which gets invoked after execution or cancellation completes with either result or an error. The default behavior is to log an error. * Fixed `A2AEventConverter` taking `ReadonlyContext` making it not possible to invoke the default adka2a.ToSessionEvent which requires an `InvocationContext` * Fixed `adka2a.A2APartConverter` not used in remoteagent * Fixed `updateAggregation` failing for nil-content events * Updated a2a-go to `0.3.9`

feat: remote a2a agent (#167) Implements a remote a2a agent. An agent can be created as `remoteagent.New(remoteagent.A2AConfig{...})`. The agent can be configured with either an `a2a.AgentCard` or an `AgentCardSource` pointing to a local file or an http resource. Other options contain configurations for the various steps of execution: card resolution, message send configuration, client creation. For remote agent input: 1. If the last session event is a user function tool response: send content parts as new message parts with the task and contextID matching those on the matching function tool call. 2. Combine parts from all the events after the last event authored by the remote agent and present them as a single user message. For remote agent output: 1. `TaskStatusUpdate` event parts are converted to thoughts, unless it's the final task status updates. 2. Empty `TaskArtifactUpdate`s (no parts) are skipped. 3. Every event has a `CustomMetadata` with task and context IDs, the original A2A request and a matching A2A event. 4. If an error is generated during an execution it's converted to a session event with ErrorMessage. These are slightly different from Python, but changes changes were made based on the implementation of `adka2a.NewExecutor`, I'll open a bug in their tracker to reconcile implementations.

feat: adka2a event mapper code (#165) * Add `adka2a` package `a2a.Event -> session.Event` converters for `remoteagent` package to use. (#167) * Move `adka2a.toMapStructure` to `internal/utils/ToMapStructure`. The utility is used by `adka2a` and `remoteagent` for converting structs to metadata `map[string]any` values. * Rename and export utility functions for creating metadata keys. Python adds `adk_` prefix for keys it stores in a2a metadata, and `a2a:` prefix for keys it stores in `session.Event.CustomMetadata`, I'm doing the same.

feat: construct a2a.AgentSkill from agent.Agent (#186) * update a2a-go * make config accessible through internal/agent * agent skill builder util * use latest a2a

fix: remote agent responses are not stored in streaming mode (#420) Events marked as Partial are not stored in the sessions store. Updated comments to make it more clear. Updated A2A remote-agent to aggregate text and thoughts from partial events and emit them with or before the terminal events. Long-running functions calls are emitted as well because a response is expected to be delivered as a follow-up function call. Before the fix remoteagent responses in streaming mode were lost unless a Task was emitted as the terminal event (which is not the case for adka2a.Executor)

feat: adka2a AgentExecutor adapter (part 3) (#152) Executor invokes an ADK agent and translates session.Events to a2a.Events according to the following rules: - If the input doesn't reference any `Task`, produce a `TaskStatusUpdateEvent` with `TaskStateSubmitted`. - Right before `runner.Runner` invocation, produce `TaskStatusUpdateEvent` with `TaskStateWorking`. - For every `session.Event` produce a `TaskArtifactUpdateEvent{Append=true}` with transformed parts. - After the last `session.Event` is processed produce an empty `TaskArtifactUpdateEvent{Append=true}` with `LastChunk=true`, if at least one artifact update was produced during the run. - If there was an `LLMResponse` with non-zero error code, produce a `TaskStatusUpdateEvent` with `TaskStateFailed`. Else if there was an `LLMResponse` with long-running tool invocation, produce a `TaskStatusUpdateEvent` with `TaskStateInputRequired`. Else produce a `TaskStatusUpdateEvent` with `TaskStateCompleted`. There's no `TaskAuthRequiredState` production rules at the moment, because A2A assumes an Agent is still executing while waiting for auth credentials. A proper integration will require more research and planning.