@google/adk 0.4.0 → 0.6.0

package/dist/esm/tools/preload_memory_tool.js

@@ -0,0 +1,80 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { appendInstructions } from "../models/llm_request.js";
+import { logger } from "../utils/logger.js";
+import {
+  BaseTool
+} from "./base_tool.js";
+class PreloadMemoryTool extends BaseTool {
+  constructor() {
+    super({
+      // Name and description are not used because this tool only
+      // changes llm_request.
+      name: "preload_memory",
+      description: "preload_memory"
+    });
+  }
+  async runAsync({
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    args,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    toolContext
+  }) {
+    throw new Error("PreloadMemoryTool should not be called by model");
+  }
+  async processLlmRequest(request) {
+    var _a, _b, _c;
+    await super.processLlmRequest(request);
+    const userContent = request.toolContext.userContent;
+    if (!userContent || !userContent.parts || !((_a = userContent.parts[0]) == null ? void 0 : _a.text)) {
+      return;
+    }
+    const userQuery = userContent.parts[0].text;
+    let response;
+    try {
+      if (!request.toolContext.invocationContext.memoryService) {
+        return;
+      }
+      response = await request.toolContext.searchMemory(userQuery);
+    } catch (_) {
+      logger.warn(`Failed to preload memory for query: ${userQuery}`);
+      return;
+    }
+    if (!response.memories || response.memories.length === 0) {
+      return;
+    }
+    const memoryTextLines = [];
+    for (const memory of response.memories) {
+      const timeStr = memory.timestamp ? `Time: ${memory.timestamp}` : "";
+      if (timeStr) memoryTextLines.push(timeStr);
+      const memoryText = (_c = (_b = memory.content.parts) == null ? void 0 : _b.map((p) => {
+        var _a2;
+        return (_a2 = p.text) != null ? _a2 : "";
+      }).join(" ")) != null ? _c : "";
+      if (memoryText) {
+        memoryTextLines.push(
+          memory.author ? `${memory.author}: ${memoryText}` : memoryText
+        );
+      }
+    }
+    if (memoryTextLines.length === 0) {
+      return;
+    }
+    const fullMemoryText = memoryTextLines.join("\n");
+    const si = `The following content is from your previous conversations with the user.
+They may be useful for answering the user's current query.
+<PAST_CONVERSATIONS>
+${fullMemoryText}
+</PAST_CONVERSATIONS>
+`;
+    appendInstructions(request.llmRequest, [si]);
+  }
+}
+const PRELOAD_MEMORY = new PreloadMemoryTool();
+export {
+  PRELOAD_MEMORY,
+  PreloadMemoryTool
+};

package/dist/esm/utils/logger.js

@@ -3,6 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import * as winston from "winston";
 var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
   LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
@@ -10,58 +11,69 @@ var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
   return LogLevel2;
 })(LogLevel || {});
-let logLevel = 1 /* INFO */;
-function setLogLevel(level) {
-  logLevel = level;
-}
 class SimpleLogger {
-  log(level, ...args) {
-    if (level < logLevel) {
+  constructor() {
+    this.logLevel = 1 /* INFO */;
+    this.logger = winston.createLogger({
+      levels: {
+        "debug": 0 /* DEBUG */,
+        "info": 1 /* INFO */,
+        "warn": 2 /* WARN */,
+        "error": 3 /* ERROR */
+      },
+      level: "error",
+      format: winston.format.combine(
+        winston.format.label({ label: "ADK" }),
+        winston.format((info) => {
+          info.level = info.level.toUpperCase();
+          return info;
+        })(),
+        winston.format.colorize(),
+        winston.format.timestamp(),
+        winston.format.printf((info) => {
+          return `${info.level}: [${info.label}] ${info.timestamp} ${info.message}`;
+        })
+      ),
+      transports: [new winston.transports.Console()]
+    });
+  }
+  setLogLevel(level) {
+    this.logLevel = level;
+  }
+  log(level, ...messages) {
+    if (this.logLevel > level) {
       return;
     }
-    switch (level) {
-      case 0 /* DEBUG */:
-        this.debug(...args);
-        break;
-      case 1 /* INFO */:
-        this.info(...args);
-        break;
-      case 2 /* WARN */:
-        this.warn(...args);
-        break;
-      case 3 /* ERROR */:
-        this.error(...args);
-        break;
-      default:
-        throw new Error(`Unsupported log level: ${level}`);
-    }
+    this.logger.log(level.toString(), messages.join(" "));
   }
-  debug(...args) {
-    if (logLevel > 0 /* DEBUG */) {
+  debug(...messages) {
+    if (this.logLevel > 0 /* DEBUG */) {
       return;
     }
-    console.debug(getColoredPrefix(0 /* DEBUG */), ...args);
+    this.logger.debug(messages.join(" "));
   }
-  info(...args) {
-    if (logLevel > 1 /* INFO */) {
+  info(...messages) {
+    if (this.logLevel > 1 /* INFO */) {
       return;
     }
-    console.info(getColoredPrefix(1 /* INFO */), ...args);
+    this.logger.info(messages.join(" "));
   }
-  warn(...args) {
-    if (logLevel > 2 /* WARN */) {
+  warn(...messages) {
+    if (this.logLevel > 2 /* WARN */) {
       return;
     }
-    console.warn(getColoredPrefix(2 /* WARN */), ...args);
+    this.logger.warn(messages.join(" "));
   }
-  error(...args) {
-    if (logLevel > 3 /* ERROR */) {
+  error(...messages) {
+    if (this.logLevel > 3 /* ERROR */) {
       return;
     }
-    console.error(getColoredPrefix(3 /* ERROR */), ...args);
+    this.logger.error(messages.join(" "));
   }
 }
 class NoOpLogger {
+  setLogLevel(_level) {
+  }
   log(_level, ..._args) {
   }
   debug(..._args) {
@@ -73,26 +85,6 @@ class NoOpLogger {
   error(..._args) {
   }
 }
-const LOG_LEVEL_STR = {
-  [0 /* DEBUG */]: "DEBUG",
-  [1 /* INFO */]: "INFO",
-  [2 /* WARN */]: "WARN",
-  [3 /* ERROR */]: "ERROR"
-};
-const CONSOLE_COLOR_MAP = {
-  [0 /* DEBUG */]: "\x1B[34m",
-  // Blue
-  [1 /* INFO */]: "\x1B[32m",
-  // Green
-  [2 /* WARN */]: "\x1B[33m",
-  // Yellow
-  [3 /* ERROR */]: "\x1B[31m"
-  // Red
-};
-const RESET_COLOR = "\x1B[0m";
-function getColoredPrefix(level) {
-  return `${CONSOLE_COLOR_MAP[level]}[ADK ${LOG_LEVEL_STR[level]}]:${RESET_COLOR}`;
-}
 let currentLogger = new SimpleLogger();
 function setLogger(customLogger) {
   currentLogger = customLogger != null ? customLogger : new NoOpLogger();
@@ -103,7 +95,13 @@ function getLogger() {
 function resetLogger() {
   currentLogger = new SimpleLogger();
 }
+function setLogLevel(level) {
+  logger.setLogLevel(level);
+}
 const logger = {
+  setLogLevel(level) {
+    currentLogger.setLogLevel(level);
+  },
   log(level, ...args) {
     currentLogger.log(level, ...args);
   },

package/dist/esm/version.js

@@ -3,7 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const version = "0.4.0";
+const version = "0.6.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,63 @@
+/**
+ * @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 { 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 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;
+}

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

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AgentCard } from '@a2a-js/sdk';
+import express from 'express';
+import { BaseAgent } from '../agents/base_agent.js';
+import { BaseArtifactService } from '../artifacts/base_artifact_service.js';
+import { BaseMemoryService } from '../memory/base_memory_service.js';
+import { Runner } from '../runner/runner.js';
+import { BaseSessionService } from '../sessions/base_session_service.js';
+/**
+ * Options for the `toA2a` function.
+ */
+export interface ToA2aOptions {
+    /** The host for the A2A RPC URL (default: "localhost") */
+    host?: string;
+    /** The port for the A2A RPC URL (default: 8000) */
+    port?: number;
+    /** The protocol for the A2A RPC URL (default: "http") */
+    protocol?: string;
+    /** The base path for the A2A RPC URL (default: "a2a") */
+    basePath?: string;
+    /** Optional pre-built AgentCard object or path to agent card JSON */
+    agentCard?: AgentCard | string;
+    /** Optional pre-built Runner object */
+    runner?: Runner;
+    /** Optional session service */
+    sessionService?: BaseSessionService;
+    /** Optional memory service */
+    memoryService?: BaseMemoryService;
+    /** Optional artifact service */
+    artifactService?: BaseArtifactService;
+    /** Optional existing express application */
+    app?: express.Application;
+}
+/**
+ * Converts an ADK agent to an Express application with A2A handlers.
+ *
+ * @param agent The ADK agent to convert
+ * @param options Configuration options
+ * @returns An Express application
+ */
+export declare function toA2a(agent: BaseAgent, options?: ToA2aOptions): Promise<express.Application>;

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

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Message } from '@a2a-js/sdk';
+import { Event as AdkEvent } from '../events/event.js';
+import { A2AEvent } from './a2a_event.js';
+/**
+ * Converts a session Event to an A2A Message.
+ */
+export declare function toA2AMessage(event: AdkEvent, { appName, userId, sessionId, }: {
+    appName: string;
+    userId: string;
+    sessionId: string;
+}): Message;
+/**
+ * Converts an A2A Event to a Session Event.
+ */
+export declare function toAdkEvent(event: A2AEvent, invocationId: string, agentName: string): AdkEvent | undefined;

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

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Task, TaskStatusUpdateEvent } from '@a2a-js/sdk';
+import { Content as GenAIContent } from '@google/genai';
+import { Event as AdkEvent } from '../events/event.js';
+import { ExecutorContext } from './executor_context.js';
+/**
+ * Processes a list of ADK events and determines the final task status update event.
+ * If any of the ADK events contain an error, a TaskFailedEvent is returned immediately.
+ * If there are no errors, it checks for any input required events. If found, it returns a TaskInputRequiredEvent.
+ * If there are no input required events, it returns a TaskCompletedEvent.
+ *
+ * @param adkEvents - The list of ADK events to process.
+ * @param context - The executor context containing relevant information for processing the events.
+ * @returns A TaskStatusUpdateEvent representing the final status of the task after processing the ADK events.
+ */
+export declare function getFinalTaskStatusUpdate(adkEvents: AdkEvent[], context: ExecutorContext): TaskStatusUpdateEvent;
+/**
+ * Returns input required task status update events if the provided user request does not contain responses for all function calls in the task status.
+ */
+export declare function getTaskInputRequiredEvent(task: Task, genAIContent: GenAIContent): TaskStatusUpdateEvent | undefined;