@softactivate/adk 1.1.0

package/dist/esm/utils/streaming_utils.js

@@ -0,0 +1,304 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  FinishReason
+} from "@google/genai";
+import { JSONPath } from "jsonpath-plus";
+import { generateClientFunctionCallId } from "../agents/functions.js";
+import { FeatureName, isFeatureEnabled } from "../features/feature_registry.js";
+import { createLlmResponse } from "../models/llm_response.js";
+class StreamingResponseAggregator {
+  constructor(isProgressiveMode = isFeatureEnabled(
+    FeatureName.PROGRESSIVE_SSE_STREAMING
+  )) {
+    this.isProgressiveMode = isProgressiveMode;
+    // For non-progressive SSE streaming mode
+    this.text = "";
+    this.thoughtText = "";
+    // For progressive SSE streaming mode: accumulate parts in order
+    this.partsSequence = [];
+    this.currentTextBuffer = "";
+    this.currentFcArgs = {};
+  }
+  flushTextBufferToSequence() {
+    if (!this.currentTextBuffer) {
+      return;
+    }
+    if (this.currentTextIsThought) {
+      this.partsSequence.push({
+        text: this.currentTextBuffer,
+        thought: true
+      });
+    } else {
+      this.partsSequence.push({
+        text: this.currentTextBuffer
+      });
+    }
+    this.currentTextBuffer = "";
+    this.currentTextIsThought = void 0;
+  }
+  getValueFromPartialArg(partialArg, jsonPath) {
+    let value = null;
+    let hasValue = false;
+    const stringValue = partialArg.stringValue;
+    const numberValue = partialArg.numberValue;
+    const boolValue = partialArg.boolValue;
+    const nullValue = partialArg.nullValue;
+    if (stringValue !== void 0) {
+      const stringChunk = stringValue;
+      hasValue = true;
+      const pathParts = JSONPath.toPathArray(jsonPath).filter(
+        (p) => p !== "$" && p !== "$["
+      );
+      let existingValue = this.currentFcArgs;
+      for (const part of pathParts) {
+        if (existingValue && typeof existingValue === "object" && part in existingValue) {
+          existingValue = existingValue[part];
+        } else {
+          existingValue = void 0;
+          break;
+        }
+      }
+      if (typeof existingValue === "string") {
+        value = existingValue + stringChunk;
+      } else {
+        value = stringChunk;
+      }
+    } else if (numberValue !== void 0) {
+      value = numberValue;
+      hasValue = true;
+    } else if (boolValue !== void 0) {
+      value = boolValue;
+      hasValue = true;
+    } else if (nullValue !== void 0) {
+      value = null;
+      hasValue = true;
+    }
+    return [value, hasValue];
+  }
+  setValueByJsonPath(jsonPath, value) {
+    const pathParts = JSONPath.toPathArray(jsonPath).filter(
+      (p) => p !== "$" && p !== "$["
+    );
+    let current = this.currentFcArgs;
+    for (let i = 0; i < pathParts.length - 1; i++) {
+      const part = pathParts[i];
+      if (!(part in current)) {
+        current[part] = {};
+      }
+      current = current[part];
+    }
+    if (pathParts.length > 0) {
+      current[pathParts[pathParts.length - 1]] = value;
+    }
+  }
+  flushFunctionCallToSequence() {
+    var _a;
+    if (this.currentFcName) {
+      const fcPart = {
+        functionCall: {
+          name: this.currentFcName,
+          args: JSON.parse(JSON.stringify(this.currentFcArgs)),
+          id: (_a = this.currentFcId) != null ? _a : generateClientFunctionCallId()
+        }
+      };
+      if (this.currentThoughtSignature) {
+        fcPart.thoughtSignature = this.currentThoughtSignature.toString();
+      }
+      this.partsSequence.push(fcPart);
+      this.currentFcName = void 0;
+      this.currentFcArgs = {};
+      this.currentFcId = void 0;
+      this.currentThoughtSignature = void 0;
+    }
+  }
+  processStreamingFunctionCall(fc) {
+    if (fc.name) {
+      this.currentFcName = fc.name;
+    }
+    if (fc.id) {
+      this.currentFcId = fc.id;
+    }
+    for (const partialArg of fc.partialArgs || []) {
+      const jsonPath = partialArg.jsonPath;
+      if (!jsonPath) {
+        continue;
+      }
+      const [value, hasValue] = this.getValueFromPartialArg(
+        partialArg,
+        jsonPath
+      );
+      if (hasValue) {
+        this.setValueByJsonPath(jsonPath, value);
+      }
+    }
+    if (!fc.willContinue) {
+      this.flushTextBufferToSequence();
+      this.flushFunctionCallToSequence();
+    }
+  }
+  processFunctionCallPart(part) {
+    const fc = part.functionCall;
+    if (!fc) {
+      return;
+    }
+    if (part.thoughtSignature) {
+      this.lastThoughtSignature = part.thoughtSignature;
+    } else if (this.lastThoughtSignature) {
+      part.thoughtSignature = this.lastThoughtSignature.toString();
+    }
+    if (fc.partialArgs || fc.willContinue) {
+      if (!fc.id && !this.currentFcId) {
+        fc.id = generateClientFunctionCallId();
+      }
+      if (part.thoughtSignature && !this.currentThoughtSignature) {
+        this.currentThoughtSignature = part.thoughtSignature;
+      }
+      this.processStreamingFunctionCall(fc);
+    } else {
+      if (fc.name) {
+        if (!fc.id) {
+          fc.id = generateClientFunctionCallId();
+        }
+        this.flushTextBufferToSequence();
+        this.partsSequence.push(part);
+      }
+    }
+  }
+  async *processResponse(response) {
+    var _a, _b, _c;
+    this.response = response;
+    const llmResponse = createLlmResponse(response);
+    this.usageMetadata = llmResponse.usageMetadata;
+    if (llmResponse.groundingMetadata) {
+      this.groundingMetadata = llmResponse.groundingMetadata;
+    }
+    if (llmResponse.citationMetadata) {
+      this.citationMetadata = llmResponse.citationMetadata;
+    }
+    if (llmResponse.finishReason) {
+      this.finishReason = llmResponse.finishReason;
+    }
+    if (llmResponse.content && llmResponse.content.parts) {
+      for (const part of llmResponse.content.parts) {
+        if (part.thoughtSignature) {
+          this.lastThoughtSignature = part.thoughtSignature;
+        } else if (part.functionCall && this.lastThoughtSignature) {
+          part.thoughtSignature = this.lastThoughtSignature.toString();
+        }
+      }
+    }
+    if (this.isProgressiveMode) {
+      if (llmResponse.content && llmResponse.content.parts) {
+        for (const part of llmResponse.content.parts) {
+          if (part.text) {
+            const isThought = (_a = part.thought) != null ? _a : false;
+            if (this.currentTextBuffer && isThought !== this.currentTextIsThought) {
+              this.flushTextBufferToSequence();
+            }
+            if (!this.currentTextBuffer) {
+              this.currentTextIsThought = isThought;
+            }
+            this.currentTextBuffer += part.text;
+          } else if (part.functionCall) {
+            this.processFunctionCallPart(part);
+          } else {
+            this.flushTextBufferToSequence();
+            this.partsSequence.push(part);
+          }
+        }
+      }
+      llmResponse.partial = true;
+      yield llmResponse;
+      return;
+    }
+    if (llmResponse.content && llmResponse.content.parts && typeof ((_b = llmResponse.content.parts[0]) == null ? void 0 : _b.text) === "string") {
+      const part0 = llmResponse.content.parts[0];
+      const partText = part0.text || "";
+      if (part0.thought) {
+        this.thoughtText += partText;
+      } else {
+        this.text += partText;
+      }
+      llmResponse.partial = true;
+    } else if ((this.thoughtText || this.text) && (!llmResponse.content || !llmResponse.content.parts || !((_c = llmResponse.content.parts[0]) == null ? void 0 : _c.inlineData))) {
+      const parts = [];
+      if (this.thoughtText) {
+        parts.push({ text: this.thoughtText, thought: true });
+      }
+      if (this.text) {
+        parts.push({ text: this.text });
+      }
+      yield {
+        content: {
+          role: "model",
+          parts
+        },
+        usageMetadata: llmResponse.usageMetadata,
+        partial: false
+      };
+      this.thoughtText = "";
+      this.text = "";
+    }
+    yield llmResponse;
+  }
+  close() {
+    var _a, _b, _c, _d, _e, _f;
+    if (this.isProgressiveMode) {
+      this.flushTextBufferToSequence();
+      this.flushFunctionCallToSequence();
+      const finalParts = this.partsSequence;
+      if (finalParts.length === 0) {
+        return;
+      }
+      const candidate = (_b = (_a = this.response) == null ? void 0 : _a.candidates) == null ? void 0 : _b[0];
+      const finishReason = (_c = this.finishReason) != null ? _c : candidate == null ? void 0 : candidate.finishReason;
+      return {
+        content: {
+          role: "model",
+          parts: finalParts
+        },
+        groundingMetadata: this.groundingMetadata,
+        citationMetadata: this.citationMetadata,
+        errorCode: finishReason === FinishReason.STOP ? void 0 : finishReason,
+        errorMessage: finishReason === FinishReason.STOP ? void 0 : candidate == null ? void 0 : candidate.finishMessage,
+        usageMetadata: this.usageMetadata,
+        finishReason,
+        partial: false
+      };
+    }
+    if (this.text || this.thoughtText) {
+      const parts = [];
+      if (this.thoughtText) {
+        parts.push({ text: this.thoughtText, thought: true });
+      }
+      if (this.text) {
+        parts.push({ text: this.text });
+      }
+      const candidate = (_e = (_d = this.response) == null ? void 0 : _d.candidates) == null ? void 0 : _e[0];
+      const finishReason = (_f = this.finishReason) != null ? _f : candidate == null ? void 0 : candidate.finishReason;
+      return {
+        content: {
+          role: "model",
+          parts
+        },
+        groundingMetadata: this.groundingMetadata,
+        citationMetadata: this.citationMetadata,
+        errorCode: finishReason === FinishReason.STOP ? void 0 : finishReason,
+        errorMessage: finishReason === FinishReason.STOP ? void 0 : candidate == null ? void 0 : candidate.finishMessage,
+        usageMetadata: this.usageMetadata,
+        finishReason,
+        partial: false
+      };
+    }
+    return void 0;
+  }
+}
+export {
+  StreamingResponseAggregator
+};

package/dist/esm/utils/variant_utils.js

@@ -0,0 +1,20 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { getBooleanEnvVar } from "./env_aware_utils.js";
+var GoogleLLMVariant = /* @__PURE__ */ ((GoogleLLMVariant2) => {
+  GoogleLLMVariant2["VERTEX_AI"] = "VERTEX_AI";
+  GoogleLLMVariant2["GEMINI_API"] = "GEMINI_API";
+  return GoogleLLMVariant2;
+})(GoogleLLMVariant || {});
+function getGoogleLlmVariant() {
+  return getBooleanEnvVar("GOOGLE_GENAI_USE_VERTEXAI") ? "VERTEX_AI" /* VERTEX_AI */ : "GEMINI_API" /* GEMINI_API */;
+}
+export {
+  GoogleLLMVariant,
+  getGoogleLlmVariant
+};

package/dist/esm/version.js

@@ -0,0 +1,11 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const version = "1.1.0";
+export {
+  version
+};

package/dist/types/a2a/a2a_event.d.ts

@@ -0,0 +1,139 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Part as A2APart, Message, Task, TaskArtifactUpdateEvent, TaskStatusUpdateEvent } from '@a2a-js/sdk';
+/**
+ * Message roles.
+ */
+export declare enum MessageRole {
+    USER = "user",
+    AGENT = "agent"
+}
+/**
+ * Task states.
+ */
+export declare enum TaskState {
+    SUBMITTED = "submitted",
+    WORKING = "working",
+    COMPLETED = "completed",
+    FAILED = "failed",
+    CANCELED = "canceled",
+    REJECTED = "rejected",
+    INPUT_REQUIRED = "input-required"
+}
+/**
+ * A2A event.
+ */
+export type A2AEvent = Task | Message | TaskStatusUpdateEvent | TaskArtifactUpdateEvent;
+/**
+ * Checks if the event is an A2A TaskStatusUpdateEvent.
+ */
+export declare function isTaskStatusUpdateEvent(event: unknown): event is TaskStatusUpdateEvent;
+/**
+ * Checks if the event is an A2A TaskArtifactUpdateEvent.
+ */
+export declare function isTaskArtifactUpdateEvent(event: unknown): event is TaskArtifactUpdateEvent;
+/**
+ * Checks if the event is an A2A Message.
+ */
+export declare function isMessage(event: unknown): event is Message;
+/**
+ * Checks if the event is an A2A Task.
+ */
+export declare function isTask(event: unknown): event is Task;
+/**
+ * Gets the metadata from an A2A event.
+ */
+export declare function getEventMetadata(event: A2AEvent): Record<string, unknown>;
+/**
+ * Checks if the event is a failed task status update event.
+ */
+export declare function isFailedTaskStatusUpdateEvent(event: unknown): boolean;
+/**
+ * Checks if the event is a terminal task status update event.
+ */
+export declare function isTerminalTaskStatusUpdateEvent(event: unknown): boolean;
+/**
+ * Checks if the event is an input required task status update event.
+ */
+export declare function isInputRequiredTaskStatusUpdateEvent(event: unknown): boolean;
+/**
+ * Gets the error message from a failed task status update event.
+ */
+export declare function getFailedTaskStatusUpdateEventError(event: TaskStatusUpdateEvent | Task): string | undefined;
+/**
+ * Creates a task submitted event.
+ */
+export declare function createTaskSubmittedEvent({ taskId, contextId, message, metadata, }: {
+    taskId: string;
+    contextId: string;
+    message: Message;
+    metadata?: Record<string, unknown>;
+}): TaskStatusUpdateEvent;
+/**
+ * Creates a task with submitted status.
+ */
+export declare function createTask({ contextId, message, taskId, metadata, }: {
+    taskId: string;
+    contextId: string;
+    message: Message;
+    metadata?: Record<string, unknown>;
+}): Task;
+/**
+ * Creates a task working event.
+ */
+export declare function createTaskWorkingEvent({ taskId, contextId, message, metadata, }: {
+    taskId: string;
+    contextId: string;
+    message?: Message;
+    metadata?: Record<string, unknown>;
+}): TaskStatusUpdateEvent;
+/**
+ * Creates a task completed event.
+ */
+export declare function createTaskCompletedEvent({ taskId, contextId, metadata, }: {
+    taskId: string;
+    contextId: string;
+    metadata?: Record<string, unknown>;
+}): TaskStatusUpdateEvent;
+/**
+ * Creates an artifact update event.
+ */
+export declare function createTaskArtifactUpdateEvent({ taskId, contextId, artifactId, parts, metadata, append, lastChunk, }: {
+    taskId: string;
+    contextId: string;
+    artifactId?: string;
+    parts?: A2APart[];
+    metadata?: Record<string, unknown>;
+    append?: boolean;
+    lastChunk?: boolean;
+}): TaskArtifactUpdateEvent;
+/**
+ * Creates an error message for task execution failure.
+ */
+export declare function createTaskFailedEvent({ taskId, contextId, error, metadata, }: {
+    taskId: string;
+    contextId: string;
+    error: Error;
+    metadata?: Record<string, unknown>;
+}): TaskStatusUpdateEvent;
+/**
+ * Creates an input required event.
+ */
+export declare function createTaskInputRequiredEvent({ taskId, contextId, parts, metadata, }: {
+    taskId: string;
+    contextId: string;
+    parts: A2APart[];
+    metadata?: Record<string, unknown>;
+}): TaskStatusUpdateEvent;
+/**
+ * Creates an error message for missing input for a function call.
+ */
+export declare function createInputMissingErrorEvent({ taskId, contextId, parts, metadata, }: {
+    parts: A2APart[];
+    taskId: string;
+    contextId: string;
+    metadata?: Record<string, unknown>;
+}): TaskStatusUpdateEvent;

package/dist/types/a2a/a2a_remote_agent.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AGENT_CARD_PATH, AgentCard, Message, MessageSendConfiguration, MessageSendParams, Task, TaskArtifactUpdateEvent, TaskStatusUpdateEvent } from '@a2a-js/sdk';
+import { Client, ClientFactory } from '@a2a-js/sdk/client';
+import { BaseAgent, BaseAgentConfig } from '../agents/base_agent.js';
+import { InvocationContext } from '../agents/invocation_context.js';
+import { Event as AdkEvent } from '../events/event.js';
+export { AGENT_CARD_PATH };
+/**
+ * Type alias for A2A stream event data.
+ */
+export type A2AStreamEventData = Message | Task | TaskStatusUpdateEvent | TaskArtifactUpdateEvent;
+/**
+ * Callback called before sending a request to the remote agent.
+ * Allows modifying the request parameters.
+ */
+export type BeforeA2ARequestCallback = (ctx: InvocationContext, params: MessageSendParams) => Promise<void> | void;
+/**
+ * Callback called after receiving a response from the remote agent.
+ * Allows inspecting or modifying the response.
+ */
+export type AfterA2ARequestCallback = (ctx: InvocationContext, resp: A2AStreamEventData) => Promise<void> | void;
+/**
+ * Configuration for the A2ARemoteAgent.
+ */
+export interface RemoteA2AAgentConfig extends BaseAgentConfig {
+    /**
+     * Loaded AgentCard or URL to AgentCard.
+     */
+    agentCard?: AgentCard | string;
+    /**
+     * Optional pre-initialized Client for connection pooling.
+     */
+    client?: Client;
+    /**
+     * Optional ClientFactory for creating the A2A Client.
+     */
+    clientFactory?: ClientFactory;
+    /**
+     * Optional default configuration for sending messages.
+     */
+    messageSendConfig?: MessageSendConfiguration;
+    /**
+     * Callbacks run before the remote request is sent.
+     */
+    beforeRequestCallbacks?: BeforeA2ARequestCallback[];
+    /**
+     * Callbacks run after receiving a response chunk or event, before conversion.
+     */
+    afterRequestCallbacks?: AfterA2ARequestCallback[];
+}
+/**
+ * RemoteA2AAgent delegates execution to a remote agent using the A2A protocol.
+ */
+export declare class RemoteA2AAgent extends BaseAgent {
+    private readonly a2aConfig;
+    private client?;
+    private card?;
+    private isInitialized;
+    constructor(a2aConfig: RemoteA2AAgentConfig);
+    private init;
+    protected runAsyncImpl(context: InvocationContext): AsyncGenerator<AdkEvent, void, void>;
+    protected runLiveImpl(_context: InvocationContext): AsyncGenerator<AdkEvent, void, void>;
+}

package/dist/types/a2a/a2a_remote_agent_run_processor.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MessageSendParams } from '@a2a-js/sdk';
+import { InvocationContext } from '../agents/invocation_context.js';
+import { Event as AdkEvent } from '../events/event.js';
+import { A2AEvent } from './a2a_event.js';
+/**
+ * Processes streams of A2A events and aggregates partials for emissions.
+ */
+export declare class A2ARemoteAgentRunProcessor {
+    private readonly request?;
+    private aggregations;
+    private aggregationOrder;
+    constructor(request?: MessageSendParams | undefined);
+    /**
+     * aggregatePartial stores contents of partial events to emit them with the terminal event.
+     * It can return multiple events to emit instead of just the provided one.
+     */
+    aggregatePartial(context: InvocationContext, a2aEvent: A2AEvent, adkEvent: AdkEvent): AdkEvent[];
+    private removeAggregation;
+    private updateAggregation;
+    private buildNonPartialAggregation;
+    private promoteTextBlocksToParts;
+    /**
+     * Adds request and response metadata to the event.
+     */
+    updateCustomMetadata(event: AdkEvent, response?: A2AEvent): void;
+}

package/dist/types/a2a/a2a_remote_agent_utils.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Part as A2APart } from '@a2a-js/sdk';
+import { InvocationContext } from '../agents/invocation_context.js';
+import { Event as AdkEvent } from '../events/event.js';
+import { Session } from '../sessions/session.js';
+export interface UserFunctionCall {
+    response: AdkEvent;
+    taskId: string;
+    contextId: string;
+}
+/**
+ * Returns a UserFunctionCall when the event at index has a FunctionResponse.
+ */
+export declare function getUserFunctionCallAt(session: Session, index: number): UserFunctionCall | undefined;
+/**
+ * Checks if an event contains a function call with the given ID.
+ */
+export declare function isFunctionCallEvent(event: AdkEvent, callId: string): boolean;
+/**
+ * Finds the first part with a FunctionResponse and returns the call ID.
+ */
+export declare function getFunctionResponseCallId(event: AdkEvent): string | undefined;
+/**
+ * Returns content parts for all events not present in the remote session
+ * and a2a contextId if found in a remote agent event metadata.
+ */
+export declare function toMissingRemoteSessionParts(ctx: InvocationContext, session: Session): {
+    parts: A2APart[];
+    contextId?: string;
+};
+/**
+ * Wraps an agent event as a user message for context.
+ */
+export declare function presentAsUserMessage(ctx: InvocationContext, agentEvent: AdkEvent): AdkEvent;

package/dist/types/a2a/agent_card.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AgentCard, AgentInterface, AgentSkill } from '@a2a-js/sdk';
+import { BaseAgent } from '../agents/base_agent.js';
+/**
+ * Resolves the AgentCard from the provided source.
+ */
+export declare function resolveAgentCard(agentCard: AgentCard | string): Promise<AgentCard>;
+/**
+ * Converts an ADK agent to an A2A AgentCard.
+ */
+export declare function getA2AAgentCard(agent: BaseAgent, transports: AgentInterface[]): Promise<AgentCard>;
+/**
+ * Builds a list of AgentSkills based on agent descriptions and types.
+ * This information can be used in AgentCard to help clients understand agent capabilities.
+ *
+ * @param agent The agent to build skills for.
+ * @returns A promise resolving to a list of AgentSkills.
+ */
+export declare function buildAgentSkills(agent: BaseAgent): Promise<AgentSkill[]>;

package/dist/types/a2a/agent_executor.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TaskArtifactUpdateEvent, TaskStatusUpdateEvent } from '@a2a-js/sdk';
+import { AgentExecutor, ExecutionEventBus, RequestContext } from '@a2a-js/sdk/server';
+import { RunConfig } from '../agents/run_config.js';
+import { Event as AdkEvent } from '../events/event.js';
+import { Runner, RunnerConfig } from '../runner/runner.js';
+import { ExecutorContext } from './executor_context.js';
+/**
+ * Represents a runner or a configuration for a runner.
+ */
+export type RunnerOrRunnerConfig = Runner | RunnerConfig | (() => Runner | RunnerConfig) | (() => Promise<Runner | RunnerConfig>);
+/**
+ * Callback called before execution starts.
+ */
+export type BeforeExecuteCallback = (reqCtx: RequestContext) => Promise<void>;
+/**
+ * Callback called after an ADK event is converted to an A2A event.
+ */
+export type AfterEventCallback = (ctx: ExecutorContext, adkEvent: AdkEvent, a2aEvent?: TaskArtifactUpdateEvent) => Promise<void>;
+/**
+ * Callback called after execution resolved into a completed or failed task.
+ */
+export type AfterExecuteCallback = (ctx: ExecutorContext, finalA2aEvent: TaskStatusUpdateEvent, err?: Error) => Promise<void>;
+/**
+ * Configuration for the Executor.
+ */
+export interface AgentExecutorConfig {
+    runner: RunnerOrRunnerConfig;
+    runConfig?: RunConfig;
+    beforeExecuteCallback?: BeforeExecuteCallback;
+    afterEventCallback?: AfterEventCallback;
+    afterExecuteCallback?: AfterExecuteCallback;
+}
+/**
+ * AgentExecutor invokes an ADK agent and translates session events to A2A events.
+ */
+export declare class A2AAgentExecutor implements AgentExecutor {
+    private readonly config;
+    private agentPartialArtifactIdsMap;
+    constructor(config: AgentExecutorConfig);
+    execute(ctx: RequestContext, eventBus: ExecutionEventBus): Promise<void>;
+    cancelTask(_taskId: string): Promise<void>;
+    private convertAdkEventToA2AEvent;
+    /**
+     * Writes the final status event to the queue.
+     */
+    private publishFinalTaskStatus;
+}