@google/adk 1.3.0 → 1.5.0

package/dist/esm/utils/async_hooks_shim.js

@@ -0,0 +1,24 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class AsyncLocalStorage {
+  run(store, callback) {
+    const previous = this.store;
+    this.store = store;
+    try {
+      return callback();
+    } finally {
+      this.store = previous;
+    }
+  }
+  getStore() {
+    return this.store;
+  }
+}
+export {
+  AsyncLocalStorage
+};

package/dist/esm/utils/branch_trie.js

@@ -0,0 +1,13 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function isSegmentPrefix(currentBranch, targetBranch) {
+  return !targetBranch || targetBranch === currentBranch || !!currentBranch && currentBranch.startsWith(`${targetBranch}.`);
+}
+export {
+  isSegmentPrefix
+};

package/dist/esm/utils/client_labels.js

@@ -5,24 +5,60 @@ const require = topLevelCreateRequire(import.meta.url);
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { AsyncLocalStorage } from "node:async_hooks";
 import { version } from "../version.js";
 import { isBrowser } from "./env_aware_utils.js";
 const ADK_LABEL = "google-adk";
 const LANGUAGE_LABEL = "gl-typescript";
 const AGENT_ENGINE_TELEMETRY_TAG = "remote_reasoning_engine";
 const AGENT_ENGINE_TELEMETRY_ENV_VARIABLE_NAME = "GOOGLE_CLOUD_AGENT_ENGINE_ID";
+const clientLabelLocalStorage = new AsyncLocalStorage();
+const USER_AGENT_PATTERNS = [
+  ["Edge", /(?:Edg|Edge|EdgA)\/([0-9.]+)/i],
+  ["Firefox", /(?:Firefox|FxiOS)\/([0-9.]+)/i],
+  ["Chrome", /(?:Chrome|CriOS)\/([0-9.]+)/i],
+  ["Safari", /Version\/([0-9.]+).*Safari/i]
+];
+function parseUserAgent(userAgent) {
+  if (!userAgent) {
+    return "Browser";
+  }
+  for (const [name, regex] of USER_AGENT_PATTERNS) {
+    const match = userAgent.match(regex);
+    if (match) {
+      return `${name}/${match[1]}`;
+    }
+  }
+  return "Browser";
+}
 function _getDefaultLabels() {
   let frameworkLabel = `${ADK_LABEL}/${version}`;
   if (!isBrowser() && process.env[AGENT_ENGINE_TELEMETRY_ENV_VARIABLE_NAME]) {
     frameworkLabel = `${frameworkLabel}+${AGENT_ENGINE_TELEMETRY_TAG}`;
   }
-  const languageLabel = `${LANGUAGE_LABEL}/${isBrowser() ? window.navigator.userAgent : process.version}`;
+  const languageLabelDetail = isBrowser() ? (
+    // eslint-disable-next-line no-undef
+    parseUserAgent(window.navigator.userAgent)
+  ) : process.version;
+  const languageLabel = `${LANGUAGE_LABEL}/${languageLabelDetail}`;
   return [frameworkLabel, languageLabel];
 }
+function runWithClientLabel(clientLabel, callback) {
+  if (typeof clientLabel !== "string" || clientLabel.trim() === "") {
+    throw new Error("Client label must be a non-empty string.");
+  }
+  return clientLabelLocalStorage.run(clientLabel, callback);
+}
 function getClientLabels() {
   const labels = _getDefaultLabels();
+  const contextLabel = clientLabelLocalStorage.getStore();
+  if (contextLabel) {
+    labels.push(contextLabel);
+  }
   return labels;
 }
 export {
-  getClientLabels
+  getClientLabels,
+  parseUserAgent,
+  runWithClientLabel
 };

package/dist/esm/utils/env_aware_utils.js

@@ -29,7 +29,16 @@ function randomUUID() {
 }
 function base64Encode(data) {
   if (isBrowser()) {
-    return window.btoa(data);
+    let strData = "";
+    if (typeof data === "string") {
+      strData = data;
+    } else {
+      const len = data.byteLength;
+      for (let i = 0; i < len; i++) {
+        strData += String.fromCharCode(data[i]);
+      }
+    }
+    return window.btoa(strData);
   }
   return Buffer.from(data).toString("base64");
 }

package/dist/esm/utils/streaming_utils.js

@@ -9,7 +9,7 @@ import {
   FinishReason
 } from "@google/genai";
 import { JSONPath } from "jsonpath-plus";
-import { generateClientFunctionCallId } from "../agents/functions.js";
+import { generateClientFunctionCallId } from "../events/event.js";
 import { FeatureName, isFeatureEnabled } from "../features/feature_registry.js";
 import { createLlmResponse } from "../models/llm_response.js";
 const UNSAFE_PROPERTY_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
@@ -330,10 +330,16 @@ class StreamingResponseAggregator {
     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 != null ? finalParts : []
-      },
+      // Only attach a model `content` when there are actual parts to emit. When
+      // the turn accumulated no parts (e.g. a function call that was already
+      // flushed, followed by a trailing STOP chunk that carries only usage
+      // metadata) we still surface that trailing metadata, but MUST NOT emit
+      // `content: { parts: [] }`. An empty-parts model turn corrupts the session
+      // history: on the next request the Vertex AI backend rejects the whole
+      // call with HTTP 400 "Unable to submit request because it must include at
+      // least one parts field", which breaks multi-turn tool-using sessions
+      // right after the first tool call (google/adk-js#21, #22).
+      content: finalParts ? { role: "model", parts: finalParts } : void 0,
       groundingMetadata: this.groundingMetadata,
       citationMetadata: this.citationMetadata,
       errorCode: finishReason === FinishReason.STOP ? void 0 : finishReason,

package/dist/esm/utils/task.js

@@ -0,0 +1,34 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class Task {
+  constructor(executable) {
+    this.executable = executable;
+    this.isDone = false;
+    this.abortController = new AbortController();
+    const markDone = () => {
+      this.isDone = true;
+    };
+    this.promise = executable(this.abortController.signal);
+    this.promise.then(markDone).catch(markDone);
+  }
+  /**
+   * Cancels the task execution.
+   */
+  cancel() {
+    this.abortController.abort();
+  }
+  /**
+   * Returns true if the task has completed (either resolved or rejected).
+   */
+  done() {
+    return this.isDone;
+  }
+}
+export {
+  Task
+};

package/dist/esm/version.js

@@ -5,7 +5,7 @@ const require = topLevelCreateRequire(import.meta.url);
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const version = "1.3.0";
+const version = "1.5.0";
 export {
   version
 };

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

@@ -68,8 +68,12 @@ export interface RemoteA2AAgentConfig extends BaseAgentConfig {
 }
 /**
  * RemoteA2AAgent delegates execution to a remote agent using the A2A protocol.
+ *
+ * @remarks
+ * A cloned `RemoteA2AAgent` (via {@link BaseAgent.clone}) is a fresh,
+ * uninitialized instance that re-resolves its client and card on first use.
  */
-export declare class RemoteA2AAgent extends BaseAgent {
+export declare class RemoteA2AAgent extends BaseAgent<RemoteA2AAgentConfig> {
     private readonly a2aConfig;
     private client?;
     private card?;

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

@@ -4,12 +4,25 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { AgentCard } from '@a2a-js/sdk';
+import { UserBuilder } from '@a2a-js/sdk/server/express';
 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';
+/**
+ * A request authenticator for the A2A surface.
+ *
+ * This is the `UserBuilder` hook from `@a2a-js/sdk`: an async function that
+ * receives the incoming Express request, validates its credentials (for
+ * example a bearer token or an OIDC ID token) and resolves to the
+ * authenticated `User`. Implementations should reject unauthenticated
+ * requests by throwing (or by resolving to a user whose `isAuthenticated` is
+ * `false`), which prevents the underlying agent and its tools from being
+ * invoked by anonymous callers.
+ */
+export type A2aUserBuilder = UserBuilder;
 /**
  * Options for the `toA2a` function.
  */
@@ -34,6 +47,31 @@ export interface ToA2aOptions {
     artifactService?: BaseArtifactService;
     /** Optional existing express application */
     app?: express.Application;
+    /**
+     * Authenticator used to validate incoming A2A requests.
+     *
+     * A2A is the production-intended inter-agent surface: any network-reachable
+     * caller that can reach it can invoke the agent and its tools with arbitrary
+     * input and read the output. Provide a `UserBuilder` (from
+     * `@a2a-js/sdk/server/express`) that validates the request's credentials —
+     * for example a bearer token or an OIDC ID token — and it will be wired into
+     * both the REST and JSON-RPC handlers.
+     *
+     * When omitted, `toA2a` fails closed and throws unless
+     * {@link ToA2aOptions.allowUnauthenticated} is explicitly set to `true`.
+     */
+    authentication?: A2aUserBuilder;
+    /**
+     * Explicit escape hatch to mount the A2A surface WITHOUT authentication.
+     *
+     * This is intentionally insecure and must only be used for local, trusted
+     * development where the surface is not network reachable. When set to
+     * `true` (and no {@link ToA2aOptions.authentication} is provided), a loud
+     * warning is logged and the handlers are mounted with no authentication.
+     *
+     * Defaults to `false`, which makes `toA2a` fail closed.
+     */
+    allowUnauthenticated?: boolean;
 }
 /**
  * Converts an ADK agent to an Express application with A2A handlers.

package/dist/types/agents/active_streaming_tool.d.ts

@@ -3,12 +3,13 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { Task } from '../utils/task.js';
 import { LiveRequestQueue } from './live_request_queue.js';
 /**
  * The parameters for creating an ActiveStreamingTool.
  */
 export interface ActiveStreamingToolParams {
-    task?: Promise<void>;
+    task?: Task<void> | Promise<void>;
     stream?: LiveRequestQueue;
 }
 /**
@@ -17,10 +18,8 @@ export interface ActiveStreamingToolParams {
 export declare class ActiveStreamingTool {
     /**
      * The active task of this streaming tool.
-     * TODO: Replace 'Promise<void>' with a proper Task type if available in this
-     * env.
      */
-    task?: Promise<void>;
+    task?: Task<void>;
     /**
      * The active (input) streams of this streaming tool.
      */

package/dist/types/agents/base_agent.d.ts

@@ -45,12 +45,25 @@ declare const BASE_AGENT_SIGNATURE_SYMBOL: unique symbol;
 export declare function isBaseAgent(obj: unknown): obj is BaseAgent;
 /**
  * Base class for all agents in Agent Development Kit.
+ *
+ * The class is generic over its config type so that {@link clone} can be typed
+ * per subclass (e.g. `LlmAgent.clone({instruction})`). The default keeps bare
+ * `BaseAgent` references valid as `BaseAgent<BaseAgentConfig>`.
  */
-export declare abstract class BaseAgent {
+export declare abstract class BaseAgent<TConfig extends BaseAgentConfig = BaseAgentConfig> {
     /**
      * A unique symbol to identify ADK agent classes.
      */
     readonly [BASE_AGENT_SIGNATURE_SYMBOL] = true;
+    /**
+     * The config this agent was constructed from.
+     *
+     * Stored so {@link clone} can rebuild the agent by re-running the concrete
+     * constructor with overrides applied, which re-derives all state correctly
+     * instead of copying an already-mutated instance. Shallow-copied so later
+     * external mutation of the caller's object does not leak into clones.
+     */
+    protected readonly config: TConfig;
     /**
      * The agent's name.
      * Agent name must be a JS identifier and unique within the agent tree.
@@ -112,6 +125,21 @@ export declare abstract class BaseAgent {
      */
     readonly afterAgentCallback: SingleAgentCallback[];
     constructor(config: BaseAgentConfig);
+    /**
+     * Creates a copy of this agent with the given config fields overridden.
+     *
+     * Mirrors adk-python's `BaseAgent.clone(update=...)`. The clone is a detached
+     * root: its `parentAgent` is always `undefined`. Sub-agents are recursively
+     * cloned (and re-parented to the clone) unless `subAgents` is overridden.
+     * Rebuilding via the concrete constructor re-derives all state, so a cloned
+     * `LlmAgent` gets a fresh `requestProcessors` array rather than sharing the
+     * original's. See google/adk-js#534.
+     *
+     * @param overrides Config fields to override on the clone. Overriding
+     *     `parentAgent` is rejected, matching adk-python.
+     * @returns A new detached agent instance of the same concrete class.
+     */
+    clone(overrides?: Partial<TConfig>): this;
     /**
      * Entry method to run an agent via text-based conversation.
      *

package/dist/types/agents/functions.d.ts

@@ -3,12 +3,13 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Content, FunctionCall } from '@google/genai';
+import { FunctionCall } from '@google/genai';
 import { InvocationContext } from '../agents/invocation_context.js';
 import { Event } from '../events/event.js';
 import { BaseTool } from '../tools/base_tool.js';
 import { ToolConfirmation } from '../tools/tool_confirmation.js';
 import { SingleAfterToolCallback, SingleBeforeToolCallback } from './llm_agent.js';
+export { AF_FUNCTION_CALL_ID_PREFIX, generateClientFunctionCallId, populateClientFunctionCallId, } from '../events/event.js';
 export declare const REQUEST_EUC_FUNCTION_CALL_NAME = "adk_request_credential";
 export declare const REQUEST_CONFIRMATION_FUNCTION_CALL_NAME = "adk_request_confirmation";
 export declare const functionsExportedForTestingOnly: {
@@ -16,22 +17,6 @@ export declare const functionsExportedForTestingOnly: {
     generateAuthEvent: typeof generateAuthEvent;
     generateRequestConfirmationEvent: typeof generateRequestConfirmationEvent;
 };
-export declare function generateClientFunctionCallId(): string;
-/**
- * Populates client-side function call IDs.
- *
- * It iterates through all function calls in the event and assigns a
- * unique client-side ID to each one that doesn't already have an ID.
- */
-export declare function populateClientFunctionCallId(modelResponseEvent: Event): void;
-/**
- * Removes the client-generated function call IDs from a given content object.
- *
- * When sending content back to the server, these IDs are
- * specific to the client-side and should not be included in requests to the
- * model.
- */
-export declare function removeClientFunctionCallId(content: Content): void;
 /**
  * Returns a set of function call ids of the long running tools.
  */
@@ -90,3 +75,13 @@ export declare function handleFunctionCallList({ invocationContext, functionCall
  * Merges a list of function response events into a single event.
  */
 export declare function mergeParallelFunctionResponseEvents(functionResponseEvents: Event[]): Event;
+/**
+ * Finds the function call event that matches the function call ID.
+ * Mirrors Python ADK's `find_event_by_function_call_id`.
+ */
+export declare function findEventByFunctionCallId(events: Event[], functionCallId: string, endIndex?: number): Event | undefined;
+/**
+ * Finds the function call event that matches the function response ID of the last event.
+ * Mirrors Python ADK's `find_matching_function_call`.
+ */
+export declare function findMatchingFunctionCall(events: Event[]): Event | undefined;

package/dist/types/agents/invocation_context.d.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Content } from '@google/genai';
-import { BaseArtifactService } from '../artifacts/base_artifact_service.js';
+import { SessionArtifactService } from '../artifacts/session_artifact_service.js';
 import { BaseCredentialService } from '../auth/credential_service/base_credential_service.js';
 import { BaseMemoryService } from '../memory/base_memory_service.js';
 import { PluginManager } from '../plugins/plugin_manager.js';
@@ -18,7 +18,7 @@ import { TranscriptionEntry } from './transcription_entry.js';
  * The parameters for creating an invocation context.
  */
 export interface InvocationContextParams {
-    artifactService?: BaseArtifactService;
+    artifactService?: SessionArtifactService;
     sessionService?: BaseSessionService;
     memoryService?: BaseMemoryService;
     credentialService?: BaseCredentialService;
@@ -74,7 +74,7 @@ export interface InvocationContextParams {
  *  ```
  */
 export declare class InvocationContext {
-    readonly artifactService?: BaseArtifactService;
+    readonly artifactService?: SessionArtifactService;
     readonly sessionService?: BaseSessionService;
     readonly memoryService?: BaseMemoryService;
     readonly credentialService?: BaseCredentialService;
@@ -120,6 +120,10 @@ export declare class InvocationContext {
     /**
      * A container to keep track of different kinds of costs incurred as a part of
      * this invocation.
+     *
+     * This is shared across every agent context of the same invocation (see the
+     * constructor) so run-wide limits such as `maxLlmCalls` are enforced for the
+     * whole invocation rather than resetting for each agent/sub-agent.
      */
     private readonly invocationCostManager;
     /**

package/dist/types/agents/llm_agent.d.ts

@@ -130,6 +130,8 @@ export interface LlmAgentConfig extends BaseAgentConfig {
      *
      * For example: use globalInstruction to make all agents have a stable
      * identity or personality.
+     *
+     * @deprecated Use GlobalInstructionPlugin instead.
      */
     globalInstruction?: string | InstructionProvider;
     /** Tools available to this agent. */
@@ -224,11 +226,12 @@ export declare function isLlmAgent(obj: unknown): obj is LlmAgent;
 /**
  * An agent that uses a large language model to generate responses.
  */
-export declare class LlmAgent extends BaseAgent {
+export declare class LlmAgent extends BaseAgent<LlmAgentConfig> {
     /** A unique symbol to identify ADK LLM agent class. */
     readonly [LLM_AGENT_SIGNATURE_SYMBOL] = true;
     model?: string | BaseLlm;
     instruction: string | InstructionProvider;
+    /** @deprecated Use GlobalInstructionPlugin instead. */
     globalInstruction: string | InstructionProvider;
     tools: ToolUnion[];
     generateContentConfig?: GenerateContentConfig;
@@ -270,6 +273,7 @@ export declare class LlmAgent extends BaseAgent {
      * This method is only for use by Agent Development Kit.
      * @param context The context to retrieve the session state.
      * @returns The resolved globalInstruction field.
+     * @deprecated Use GlobalInstructionPlugin instead.
      */
     canonicalGlobalInstruction(context: ReadonlyContext): Promise<{
         instruction: string;

package/dist/types/agents/loop_agent.d.ts

@@ -34,7 +34,7 @@ export declare function isLoopAgent(obj: unknown): obj is LoopAgent;
  * When sub-agent generates an event with escalate or max_iterations are
  * reached, the loop agent will stop.
  */
-export declare class LoopAgent extends BaseAgent {
+export declare class LoopAgent extends BaseAgent<LoopAgentConfig> {
     /**
      * A unique symbol to identify ADK loop agent class.
      */
@@ -42,6 +42,6 @@ export declare class LoopAgent extends BaseAgent {
     readonly maxIterations: number;
     constructor(config: LoopAgentConfig);
     protected runAsyncImpl(context: InvocationContext): AsyncGenerator<Event, void, void>;
-    protected runLiveImpl(_context: InvocationContext): AsyncGenerator<Event, void, void>;
+    protected runLiveImpl(context: InvocationContext): AsyncGenerator<Event, void, void>;
 }
 export {};

package/dist/types/agents/processors/content_processor_utils.d.ts

@@ -5,6 +5,14 @@
  */
 import { Content } from '@google/genai';
 import { Event } from '../../events/event.js';
+/**
+ * Removes the client-generated function call IDs from a given content object.
+ *
+ * When sending content back to the server, these IDs are
+ * specific to the client-side and should not be included in requests to the
+ * model.
+ */
+export declare function removeClientFunctionCallId(content: Content): void;
 /**
  * Get the contents for the LLM request.
  *

package/dist/types/agents/processors/interactions_request_processor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Event } from '../../events/event.js';
+import { LlmRequest } from '../../models/llm_request.js';
+import { InvocationContext } from '../invocation_context.js';
+import { BaseLlmRequestProcessor } from './base_llm_processor.js';
+/**
+ * Request processor for Gemini Interactions API.
+ * Resolves the previous interaction ID from the session history.
+ */
+export declare class InteractionsRequestProcessor implements BaseLlmRequestProcessor {
+    runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event, void, void>;
+}
+export declare const INTERACTIONS_REQUEST_PROCESSOR: InteractionsRequestProcessor;

package/dist/types/agents/routed_agent.d.ts

@@ -41,12 +41,35 @@ export interface RoutedAgentConfig extends BaseAgentConfig {
 /**
  * A BaseAgent implementation that delegates to one of multiple agents based on a router function.
  * Routing is strictly limited to the agents passed in the config.
+ *
+ * @remarks
+ * Cloning is supported: {@link RoutedAgent.clone} deep-clones the routing
+ * targets from `config.agents` and re-parents the fresh copies onto the clone,
+ * so the clone is a detached root that routes identically to the original while
+ * leaving the original agent tree untouched.
  */
-export declare class RoutedAgent extends BaseAgent {
+export declare class RoutedAgent extends BaseAgent<RoutedAgentConfig> {
     readonly [ROUTED_AGENT_SIGNATURE_SYMBOL] = true;
     private readonly agents;
     private readonly router;
     constructor(config: RoutedAgentConfig);
+    /**
+     * Creates a detached copy of this routed agent.
+     *
+     * The inherited {@link BaseAgent.clone} only deep-clones `subAgents`, but a
+     * `RoutedAgent` derives its routing targets from `config.agents`. Rebuilding
+     * through the base clone alone would re-read the already-parented original
+     * agents and throw "already has a parent agent". This override deep-clones the
+     * routing targets (unless the caller overrides `agents`) so the rebuilt
+     * constructor re-parents fresh, detached copies. The array-vs-record shape
+     * and, for records, the keys are preserved so the router keeps selecting the
+     * same targets.
+     *
+     * @param overrides Config fields to override on the clone. Overriding
+     *     `parentAgent` is rejected by the base implementation.
+     * @returns A new detached `RoutedAgent` of the same concrete class.
+     */
+    clone(overrides?: Partial<RoutedAgentConfig>): this;
     /**
      * Runs the selected agent via text-based conversation.
      */

package/dist/types/agents/run_config.d.ts

@@ -94,6 +94,7 @@ export interface RunConfig {
  * @throws {Error} When `params.maxLlmCalls` exceeds `Number.MAX_SAFE_INTEGER`.
  */
 export declare function createRunConfig(params?: Partial<RunConfig>): {
+    maxLlmCalls: number;
     speechConfig?: SpeechConfig | undefined;
     responseModalities?: Modality[] | undefined;
     saveInputBlobsAsArtifacts: boolean;
@@ -104,6 +105,5 @@ export declare function createRunConfig(params?: Partial<RunConfig>): {
     enableAffectiveDialog: boolean;
     proactivity?: ProactivityConfig | undefined;
     realtimeInputConfig?: RealtimeInputConfig | undefined;
-    maxLlmCalls: number;
     pauseOnToolCalls: boolean;
 };

package/dist/types/apps/app.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BaseAgent } from '../agents/base_agent.js';
+import { BasePlugin } from '../plugins/base_plugin.js';
+import { ResumabilityConfig } from './resumability_config.js';
+/**
+ * Ensures the provided application name is safe and intuitive.
+ */
+export declare function validateAppName(name: string): void;
+/**
+ * A unique symbol to identify ADK App classes.
+ * Defined once and shared by all App instances.
+ */
+declare const APP_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Type guard to check if an object is an instance of App.
+ * @param obj The object to check.
+ * @returns True if the object is an instance of App, false otherwise.
+ */
+export declare function isApp(obj: unknown): obj is App;
+/**
+ * Options for initializing an App.
+ */
+export interface AppOptions {
+    name: string;
+    rootAgent: BaseAgent;
+    plugins?: BasePlugin[];
+    resumabilityConfig?: ResumabilityConfig;
+}
+/**
+ * Represents an LLM-backed agentic application.
+ *
+ * An `App` is the top-level container for an agentic system powered by LLMs.
+ * It manages a root agent (`rootAgent`), which serves as the entry point for execution.
+ *
+ * Exactly one `rootAgent` must be provided.
+ *
+ * The `plugins` are application-wide components that provide shared capabilities
+ * and services to the entire system.
+ */
+export declare class App {
+    readonly [APP_SIGNATURE_SYMBOL] = true;
+    readonly name: string;
+    readonly rootAgent: BaseAgent | any;
+    readonly plugins: BasePlugin[];
+    readonly resumabilityConfig?: ResumabilityConfig;
+    constructor(options: AppOptions);
+}
+export {};

package/dist/types/apps/resumability_config.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * The configuration of resumability for an application or runner.
+ *
+ * The "resumability" in ADK refers to the ability to:
+ * 1. pause an invocation upon a long-running function call.
+ * 2. resume an invocation from the last event, if it's paused or failed midway
+ * through.
+ */
+export interface ResumabilityConfig {
+    /**
+     * Whether the app/runner supports agent resumption.
+     * If enabled, resumption routing based on matching function responses will be active.
+     */
+    isResumable: boolean;
+}
+/**
+ * Creates a {@link ResumabilityConfig} with default values.
+ *
+ * @param params Optional partial {@link ResumabilityConfig} overriding defaults.
+ * @returns A merged {@link ResumabilityConfig} object.
+ */
+export declare function createResumabilityConfig(params?: Partial<ResumabilityConfig>): ResumabilityConfig;