Yaroslav

This commit introduces a **new feature** by implementing a **custom runner provider mechanism** for the **`adka2a` executor**. It significantly refactors the `server/adka2a/executor.go` module to utilize new `Runner` and `RunnerConfig` types, enabling more flexible and configurable execution environments by removing a mandatory dependency on a fixed runner configuration. The `server/adka2a/metadata.go` file is also updated to accept `RunnerConfig` directly for invocation metadata extraction, aligning with the new architecture. This change enhances the adaptability of the `adka2a` executor, with new test cases added in `server/adka2a/executor_test.go` to validate the provider's functionality.

This commit **fixes a test race condition** within the **A2A agent tests** by improving the cleanup verification mechanism. It introduces a `cleanupFn` field and `Cleanup` method to the `mockA2AExecutor` in `a2a_agent_test.go` to better propagate cleanup actions. Concurrently, the `TestA2ACleanupPropagation` in `a2a_e2e_test.go` is updated to use a channel, ensuring reliable verification of cleanup function invocation. This **maintenance** work enhances the stability and correctness of the `agent/remoteagent` module's test suite.

This commit introduces a **bug fix** and **refactoring** within the **`agent/remoteagent`** module to correctly handle **interleaved thought and text aggregation**. It refactors the artifact aggregation logic in `a2a_agent_run_processor.go` to directly manage `genai.Part` slices, ensuring that consecutive text or thought parts are properly collapsed. This resolves an issue where agent outputs with mixed thought and text elements could be incorrectly aggregated, leading to malformed responses. The change removes deprecated string aggregation fields and methods, streamlining the aggregation process. A new test case has been added to `a2a_agent_run_processor_test.go` to specifically verify this corrected behavior, ensuring more accurate and consistent AI agent output processing.

This commit introduces significant **feature enhancements and bug fixes** to improve the **cleanup and cancellation mechanisms for remote agent and A2A tasks**. It adds `A2ARemoteTaskCleanupCallback` to `remoteagent` for custom task cancellation and `A2AExecutionCleanupCallback` to `adka2a.Executor` for post-execution cleanup, ensuring better resource management. Crucially, it implements logic to **cancel subagent tasks** in input-required states when the root task is cancelled, enhancing system responsiveness. Additionally, **refactoring** moves agent card resolution to `internal/agent/remoteagent`, and several **bug fixes** address issues with event conversion contexts and artifact aggregation, leading to more robust distributed agent operations.

This commit provides a **bug fix** to ensure **deterministic ordering** for **aggregated events** emitted by the **`remoteagent`**. It modifies the `agent/remoteagent/a2a_agent_run_processor.go` to guarantee that events are emitted based on their last update time, achieved by tracking artifact IDs in a separate slice. This change improves the reliability and predictability of event processing within the `remoteagent` by preventing non-deterministic behavior. A new test case in `agent/remoteagent/a2a_agent_run_processor_test.go` was added to validate this corrected emission order.

This commit **introduces a new `OutputMode` for ADKA2A**, enabling **artifact production per non-partial event** rather than a single artifact per run. It involves a **significant refactoring of the remote agent's event aggregation logic** in `a2a_agent_run_processor.go` to process and emit artifacts based on `append` and `lastChunk` flags, supporting multiple partial aggregations. On the server side, the **`server/adka2a` executor and event processing** are updated with new artifact maker implementations to manage this granular output mode. This **new capability** provides more flexible and detailed artifact generation, allowing users to choose between a single artifact per run or multiple artifacts corresponding to individual non-partial events, with comprehensive **test updates** ensuring its correct operation.

This commit **enhances the testing suite** by **adding new end-to-end tests** to verify the proper functioning of the **tool confirmation mechanism** within **Agent-to-Agent (A2A) interactions**. It also **refactors existing A2A input required tests** in `agent/remoteagent/a2a_e2e_test.go` into a more maintainable table-driven format. Concurrently, a **minor refactoring** was applied to the `ToolConfirmation` struct in `tool/toolconfirmation/tool_confirmation.go` to include JSON struct tags, ensuring explicit serialization. This work collectively **improves the robustness and test coverage** of the tool confirmation feature.

This commit delivers a comprehensive **bug fix** to resolve **data duplication** and incorrect state management within the **remote agent's (A2A) partial response handling** and **streaming event aggregation**. It refines the event processing logic across the **`agent/remoteagent`** and **`server/adka2a`** modules, introducing explicit partial event marking, ensuring proper artifact resets, and correctly propagating `TurnComplete` flags. The changes specifically address issues with **long-running function calls**, prevent duplication of response parts, and guarantee the inclusion of **citation metadata** in aggregated LLM responses, thereby enhancing the reliability and data integrity of streaming interactions.

This commit introduces a **new feature** that provides **executor callbacks** with direct access to **session events**. It achieves this by **modifying the `executor`** (`server/adka2a/executor.go`) to integrate a new `executorPlugin` (`server/adka2a/executor_plugin.go`) responsible for managing session data. The **`executor context`** (`server/adka2a/executor_context.go`) is updated to expose these events, allowing `Execute` calls to leverage `ReadonlyState` and `Events` for more informed processing. This enhancement significantly expands the contextual information available during execution, enabling more sophisticated and state-aware operations within the system.

This commit **enhances the handling of long-running operations within the Agent-to-Agent (A2A) communication framework**, specifically addressing how tasks requiring input are managed. It introduces an `inputRequiredProcessor` to track long-running tool function calls and responses within `A2A TaskStatus` messages, enabling non-blocking clients to discover necessary inputs. The `adka2a.Executor` now performs pre-execution validation of user-provided `FunctionCallResponse`s, while the `runner` module is updated to correctly route these responses to the appropriate sub-agents, even for non-root initiators. This **fix** significantly improves the robustness and coordination of multi-agent systems involving asynchronous tool execution, with new integration tests validating single and multi-hop scenarios.

This commit provides a **critical bug fix** for the **remote agent's streaming mode**, ensuring that **partial events** and **long-running function calls** are no longer lost and are correctly stored in the session. It introduces a **new dedicated processor** within the `remoteagent` module (`a2a_agent_run_processor.go`) to aggregate text and thoughts from partial events before emitting them, and to properly handle responses from long-running tool executions. This resolves an issue where `adka2a.Executor` responses were not persisted, significantly improving the reliability and completeness of agent interaction logs. The fix also includes updates to the `server/adka2a` module to correctly mark partial event parts with metadata. Additionally, documentation for the `Partial` field in `LLMResponse` is updated for clarity.

This commit significantly **enhances the `adka2a` conversion mechanism** to improve compliance and extendability. It introduces comprehensive support for converting and restoring **grounding, usage, and custom metadata** between ADK session events and A2A events, primarily within the `server/adka2a` module. New **extension points** are provided via callbacks for intercepting execution lifecycle events in `server/adka2a/executor.go`, and the system now ensures **1.0.0 compliance** by emitting `Task` as the initial event. These **feature additions and refactorings** streamline data exchange and offer greater control over the remote agent's execution flow, impacting the `agent/remoteagent` and `server/adka2a` components.

This commit introduces a **new feature** by enabling the **`remoteagent`** to support standard agent callbacks, enhancing its operational flexibility. Specifically, it modifies the **`A2AConfig`** within `agent/remoteagent/a2a_agent.go` to accept `BeforeAgentCallbacks` and `AfterAgentCallbacks`. These newly supported callbacks are now correctly passed during the `NewA2A` agent initialization, allowing custom logic to be executed before and after agent operations. This enhancement aligns the `remoteagent`'s behavior with other agent types, improving consistency and extensibility across the system.

This commit introduces a **new feature** to the **`remoteagent`** module, enabling **interception and modification of A2A (Agent-to-Agent) requests and responses**. It defines `BeforeA2ARequestCallback`, `A2AEventConverter`, and `AfterA2ARequestCallback` types, integrating them into the `A2AConfig` and the agent's `run` logic. This enhancement provides **greater flexibility for custom processing of A2A events**, allowing for advanced data transformation or validation before and after request handling. Comprehensive test cases were added to validate this new callback and converter functionality.

This commit introduces a **bug fix** to resolve a **data race** within the **ADKA2A integration**'s event processing logic. Previously, delayed terminal events shared metadata references with immediately dispatched events, leading to race conditions when the task update processor modified this metadata during LLM response consumption. The fix involves creating **shallow copies of event metadata** for delayed events, ensuring that modifications to the original metadata do not inadvertently affect these pending events. This prevents inconsistent state and improves the reliability of **terminal event dispatch** in `server/adka2a/processor.go`.

This commit implements a **new feature** to enable the seamless propagation of `Escalate` and `TransferToAgent` event actions through the **A2A (Agent-to-Agent) communication layer**. It primarily affects the **`server/adka2a` module**, introducing logic in `events.go` for serialization/deserialization, `metadata.go` for injecting actions into event metadata, and `processor.go` for tracking and applying these actions to terminal events. This ensures that critical agent interaction commands are accurately preserved and processed across the system, enhancing the reliability of agent workflows.

This commit introduces a **new capability** by adding a **remote A2A agent example**, demonstrating agent-to-agent communication within the system. It **enhances the `server/adka2a` module** by implementing and setting a new `Partial` flag for various session events, indicating an ongoing or incomplete response from the agent. The **`runner` module** is updated to pass `RunConfig` to agent invocations, providing necessary context for agent execution. Additionally, the commit includes minor **documentation improvements** in `server/adka2a/executor.go` and a **bug fix** addressing an error reassignment issue.

This commit introduces a **major refactoring** of the **A2A universal launcher module**, transitioning its **communication protocol** from **gRPC to JSON-RPC**. This **new capability** involved a complete rewrite of the `cmd/launcher/web/a2a/a2a.go` component, updating its configuration, routing, and agent card details, along with corresponding test adjustments in `a2a_test.go`. Furthermore, the change refactors the broader **web launcher infrastructure** by modifying `SetupSubrouters` signatures and removing the `WrapHandlers` concept across `cmd/launcher/web/api/api.go`, `cmd/launcher/web/web.go`, and `cmd/launcher/web/webui/webui.go` to streamline integration and enhance error handling.

This commit introduces a **new feature** and accompanying **testing** for the **A2A web launcher** component. It adds a configuration flag for the A2A agent URL and establishes a new endpoint in `cmd/launcher/web/a2a/a2a.go` to serve the A2A agent card, leveraging `NewLauncher` and `SetupSubrouters`. Concurrently, a dedicated test file, `cmd/launcher/web/a2a/a2a_test.go`, is added to thoroughly verify the launcher's functionality, including the serving of the agent card and message handling. This work significantly enhances the **A2A integration capabilities** by providing a robust mechanism for serving the agent card and ensuring its correct operation through comprehensive tests.

This commit **introduces new utilities** in `adka2a/agent_card.go` to dynamically construct `a2a.AgentSkill` objects from `agent.Agent` definitions, supporting various agent types like LLM and workflow agents. This **feature enhancement** also updates `llmagent` and `workflowagents` to store their configurations within the `internal/agent/State`, making agent-specific settings more accessible. Concurrently, the `adka2a` **executor** and **event processor** modules are **refactored** to streamline task handling and event creation by consistently using `reqCtx`. These changes improve the integration and representation of agents within the `adka2a` system, enabling more structured skill generation and internal data flow.