@iqai/adk 0.6.1 → 0.6.2

package/dist/index.d.mts

@@ -1,178 +1,194 @@
-import { Content, Part, GroundingMetadata, GenerateContentResponseUsageMetadata, Blob, SpeechConfig, AudioTranscriptionConfig, RealtimeInputConfig, ProactivityConfig, FunctionDeclaration, GenerateContentConfig, Schema, LiveConnectConfig, GoogleGenAI, FunctionCall } from '@google/genai';
+import { Part, Content, GroundingMetadata, GenerateContentResponseUsageMetadata, Blob, FunctionDeclaration, GenerateContentConfig, Schema, LiveConnectConfig, SpeechConfig, AudioTranscriptionConfig, RealtimeInputConfig, ProactivityConfig, GoogleGenAI, FunctionCall } from '@google/genai';
 export { Blob, Content, FunctionDeclaration, Schema as JSONSchema } from '@google/genai';
-import { SpanContext, Tracer, Span } from '@opentelemetry/api';
+import { LanguageModel } from 'ai';
 import * as z from 'zod';
 import { z as z$1, ZodSchema, ZodType } from 'zod';
-import { LanguageModel } from 'ai';
+import { SpanContext, Tracer, Span } from '@opentelemetry/api';
 import { StorageOptions } from '@google-cloud/storage';
 import { Kysely, Generated } from 'kysely';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { CreateMessageRequest, CreateMessageResult, Tool, CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 
-interface LoggerOpts {
-    name: string;
+/**
+ * Authentication scheme types
+ */
+declare enum AuthSchemeType {
+    APIKEY = "apiKey",
+    HTTP = "http",
+    OAUTH2 = "oauth2",
+    OPENID_CONNECT = "openIdConnect"
 }
-declare class Logger {
-    name: string;
-    isDebugEnabled: boolean;
-    constructor({ name }: LoggerOpts);
-    debug(message: string, ...args: any[]): void;
-    info(message: string, ...args: any[]): void;
-    warn(message: string, ...args: any[]): void;
-    error(message: string, ...args: any[]): void;
-    private log;
-    private extractMeta;
-    private formatArgs;
-    private parseStackFrames;
-    private stringify;
-    private capitalize;
-    formatBox(params: {
-        title: string;
-        description: string;
-        lines?: string[];
-        width?: number;
-        maxWidthPct?: number;
-        color?: (txt: string) => string;
-        pad?: number;
-        borderChar?: string;
-        wrap?: boolean;
-    }): string;
+/**
+ * Base class for authentication schemes
+ */
+declare abstract class AuthScheme {
     /**
-     * Structured warning with code, suggestion, context.
+     * The type of authentication scheme
      */
-    warnStructured(warning: {
-        code: string;
-        message: string;
-        suggestion?: string;
-        context?: Record<string, any>;
-        severity?: "warn" | "info" | "error";
-        timestamp?: string;
-    }, opts?: {
-        format?: "pretty" | "json" | "text";
-        verbose?: boolean;
-    }): void;
-    debugStructured(title: string, data: Record<string, any>): void;
-    debugArray(title: string, items: Array<Record<string, any>>): void;
-    private objectToLines;
-    private arrayToLines;
+    type: AuthSchemeType;
+    constructor(type: AuthSchemeType);
 }
-
 /**
- * Event compaction data structure containing the summarized content
- * and the timestamp range it covers.
+ * API Key authentication scheme
  */
-interface EventCompaction {
-    startTimestamp: number;
-    endTimestamp: number;
-    compactedContent: Content;
+declare class ApiKeyScheme extends AuthScheme {
+    /**
+     * Where the API key is sent
+     */
+    in: "query" | "header" | "cookie";
+    /**
+     * Name of the parameter
+     */
+    name: string;
+    /**
+     * Description of the API key
+     */
+    description?: string;
+    /**
+     * Constructor for ApiKeyScheme
+     */
+    constructor(config: {
+        in: "query" | "header" | "cookie";
+        name: string;
+        description?: string;
+    });
 }
 /**
- * Represents the actions attached to an event.
+ * HTTP authentication scheme
  */
-declare class EventActions {
+declare class HttpScheme extends AuthScheme {
     /**
-     * If true, it won't call model to summarize function response.
-     * Only used for function_response event.
+     * The HTTP authentication scheme
      */
-    skipSummarization?: boolean;
+    scheme: "basic" | "bearer" | "digest" | "other";
     /**
-     * Indicates that the event is updating the state with the given delta.
+     * Bearer format when scheme is 'bearer'
      */
-    stateDelta: Record<string, any>;
+    bearerFormat?: string;
     /**
-     * Indicates that the event is updating an artifact. key is the filename,
-     * value is the version.
+     * Description of the scheme
      */
-    artifactDelta: Record<string, number>;
+    description?: string;
     /**
-     * If set, the event transfers to the specified agent.
+     * Constructor for HttpScheme
      */
-    transferToAgent?: string;
+    constructor(config: {
+        scheme: "basic" | "bearer" | "digest" | "other";
+        bearerFormat?: string;
+        description?: string;
+    });
+}
+/**
+ * OAuth flow configuration
+ */
+interface OAuthFlow {
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    refreshUrl?: string;
+    scopes: Record<string, string>;
+}
+/**
+ * OAuth flows configuration
+ */
+interface OAuthFlows {
+    implicit?: OAuthFlow;
+    password?: OAuthFlow;
+    clientCredentials?: OAuthFlow;
+    authorizationCode?: OAuthFlow;
+}
+/**
+ * OAuth2 authentication scheme
+ */
+declare class OAuth2Scheme extends AuthScheme {
     /**
-     * The agent is escalating to a higher level agent.
+     * OAuth flows
      */
-    escalate?: boolean;
+    flows: OAuthFlows;
     /**
-     * Requested authentication configurations.
+     * Description of the scheme
      */
-    requestedAuthConfigs?: Record<string, any>;
+    description?: string;
     /**
-     * Event compaction information. When set, this event represents
-     * a compaction of events within the specified timestamp range.
+     * Constructor for OAuth2Scheme
      */
-    compaction?: EventCompaction;
+    constructor(config: {
+        flows: OAuthFlows;
+        description?: string;
+    });
+}
+/**
+ * OpenID Connect authentication scheme
+ */
+declare class OpenIdConnectScheme extends AuthScheme {
     /**
-     * The invocation id to rewind to. This is only set for rewind event.
+     * OpenID Connect URL
      */
-    rewindBeforeInvocationId?: string;
+    openIdConnectUrl: string;
     /**
-     * Constructor for EventActions
+     * Description of the scheme
      */
-    constructor(options?: {
-        skipSummarization?: boolean;
-        stateDelta?: Record<string, any>;
-        artifactDelta?: Record<string, number>;
-        transferToAgent?: string;
-        escalate?: boolean;
-        requestedAuthConfigs?: Record<string, any>;
-        compaction?: EventCompaction;
-        rewindBeforeInvocationId?: string;
+    description?: string;
+    /**
+     * Constructor for OpenIdConnectScheme
+     */
+    constructor(config: {
+        openIdConnectUrl: string;
+        description?: string;
     });
 }
 
 /**
- * A state dict that maintain the current value and the pending-commit delta.
+ * Authentication configuration for tools
  */
-declare class State {
-    static readonly APP_PREFIX = "app:";
-    static readonly USER_PREFIX = "user:";
-    static readonly TEMP_PREFIX = "temp:";
-    private readonly _value;
-    private readonly _delta;
-    /**
-     * Constructor for State
-     *
-     * @param value - The current value of the state dict.
-     * @param delta - The delta change to the current value that hasn't been committed.
-     */
-    constructor(value: Record<string, any>, delta: Record<string, any>);
+declare class AuthConfig {
     /**
-     * Returns the value of the state dict for the given key.
+     * The authentication scheme
      */
-    get(key: string, defaultValue?: any): any;
+    authScheme: AuthScheme;
     /**
-     * Sets the value of the state dict for the given key.
+     * Additional context properties
      */
-    set(key: string, value: any): void;
+    context?: Record<string, any>;
     /**
-     * Whether the state dict contains the given key.
+     * Constructor for AuthConfig
      */
-    has(key: string): boolean;
+    constructor(config: {
+        authScheme: AuthScheme;
+        context?: Record<string, any>;
+    });
+}
+
+/**
+ * Handler for authentication in tools
+ */
+declare class AuthHandler {
     /**
-     * Whether the state has pending delta.
+     * The authentication configuration
      */
-    hasDelta(): boolean;
+    authConfig: AuthConfig;
     /**
-     * Updates the state dict with the given delta.
+     * The authentication credential
      */
-    update(delta: Record<string, any>): void;
+    credential?: AuthCredential;
     /**
-     * Returns the state dict.
+     * Constructor for AuthHandler
      */
-    toDict(): Record<string, any>;
+    constructor(config: {
+        authConfig: AuthConfig;
+        credential?: AuthCredential;
+    });
     /**
-     * Array-like access for getting values.
-     * Returns the value of the state dict for the given key.
+     * Gets the authentication token
      */
-    [key: string]: any;
+    getToken(): string | undefined;
     /**
-     * Proxy handler for array-like access
+     * Gets headers for HTTP requests
      */
-    private static createProxy;
+    getHeaders(): Record<string, string>;
     /**
-     * Factory method to create a proxied State instance
+     * Refreshes the token if necessary
      */
-    static create(value: Record<string, any>, delta: Record<string, any>): State;
+    refreshToken(): Promise<void>;
 }
 
 interface BaseArtifactService {
@@ -270,13 +286,76 @@ interface BaseMemoryService {
 }
 
 /**
- * Options for creating an Event.
+ * Event compaction data structure containing the summarized content
+ * and the timestamp range it covers.
  */
-interface EventOpts {
-    invocationId?: string;
-    author: string;
-    actions?: EventActions;
-    longRunningToolIds?: Set<string>;
+interface EventCompaction {
+    startTimestamp: number;
+    endTimestamp: number;
+    compactedContent: Content;
+}
+/**
+ * Represents the actions attached to an event.
+ */
+declare class EventActions {
+    /**
+     * If true, it won't call model to summarize function response.
+     * Only used for function_response event.
+     */
+    skipSummarization?: boolean;
+    /**
+     * Indicates that the event is updating the state with the given delta.
+     */
+    stateDelta: Record<string, any>;
+    /**
+     * Indicates that the event is updating an artifact. key is the filename,
+     * value is the version.
+     */
+    artifactDelta: Record<string, number>;
+    /**
+     * If set, the event transfers to the specified agent.
+     */
+    transferToAgent?: string;
+    /**
+     * The agent is escalating to a higher level agent.
+     */
+    escalate?: boolean;
+    /**
+     * Requested authentication configurations.
+     */
+    requestedAuthConfigs?: Record<string, any>;
+    /**
+     * Event compaction information. When set, this event represents
+     * a compaction of events within the specified timestamp range.
+     */
+    compaction?: EventCompaction;
+    /**
+     * The invocation id to rewind to. This is only set for rewind event.
+     */
+    rewindBeforeInvocationId?: string;
+    /**
+     * Constructor for EventActions
+     */
+    constructor(options?: {
+        skipSummarization?: boolean;
+        stateDelta?: Record<string, any>;
+        artifactDelta?: Record<string, number>;
+        transferToAgent?: string;
+        escalate?: boolean;
+        requestedAuthConfigs?: Record<string, any>;
+        compaction?: EventCompaction;
+        rewindBeforeInvocationId?: string;
+    });
+}
+
+/**
+ * Options for creating an Event.
+ */
+interface EventOpts {
+    invocationId?: string;
+    author: string;
+    actions?: EventActions;
+    longRunningToolIds?: Set<string>;
     branch?: string;
     id?: string;
     timestamp?: number;
@@ -483,6 +562,75 @@ interface EventsCompactionConfig {
  */
 declare function runCompactionForSlidingWindow(config: EventsCompactionConfig, session: Session, sessionService: BaseSessionService, summarizer: EventsSummarizer): Promise<void>;
 
+interface LoggerOpts {
+    name: string;
+}
+declare class Logger {
+    name: string;
+    isDebugEnabled: boolean;
+    constructor({ name }: LoggerOpts);
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+    private log;
+    private extractMeta;
+    private formatArgs;
+    private parseStackFrames;
+    private stringify;
+    private capitalize;
+    formatBox(params: {
+        title: string;
+        description: string;
+        lines?: string[];
+        width?: number;
+        maxWidthPct?: number;
+        color?: (txt: string) => string;
+        pad?: number;
+        borderChar?: string;
+        wrap?: boolean;
+    }): string;
+    /**
+     * Structured warning with code, suggestion, context.
+     */
+    warnStructured(warning: {
+        code: string;
+        message: string;
+        suggestion?: string;
+        context?: Record<string, any>;
+        severity?: "warn" | "info" | "error";
+        timestamp?: string;
+    }, opts?: {
+        format?: "pretty" | "json" | "text";
+        verbose?: boolean;
+    }): void;
+    debugStructured(title: string, data: Record<string, any>): void;
+    debugArray(title: string, items: Array<Record<string, any>>): void;
+    private objectToLines;
+    private arrayToLines;
+}
+
+declare class CacheMetadata {
+    readonly cacheName?: string | null;
+    readonly expireTime?: number | null;
+    readonly fingerprint: string;
+    readonly invocationsUsed?: number | null;
+    readonly contentsCount: number;
+    readonly createdAt?: number | null;
+    constructor(params: CacheMetadataParams);
+    get expireSoon(): boolean;
+    copy(update?: Partial<CacheMetadataParams>): CacheMetadata;
+    toString(): string;
+}
+interface CacheMetadataParams {
+    cacheName?: string | null;
+    expireTime?: number | null;
+    fingerprint: string;
+    invocationsUsed?: number | null;
+    contentsCount: number;
+    createdAt?: number | null;
+}
+
 interface Candidate {
     content?: Content;
     groundingMetadata?: GroundingMetadata;
@@ -509,6 +657,7 @@ declare class LlmResponse {
     errorMessage?: string;
     interrupted?: boolean;
     customMetadata?: Record<string, any>;
+    cacheMetadata?: CacheMetadata;
     usageMetadata?: GenerateContentResponseUsageMetadata;
     candidateIndex?: number;
     finishReason?: string;
@@ -567,767 +716,127 @@ declare abstract class BaseLLMConnection {
 }
 
 /**
- * The BaseLlm class.
+ * Configuration for context caching across all agents in an app.
+ *
+ * This configuration enables and controls context caching behavior for
+ * all LLM agents in an app. When this config is present on an app, context
+ * caching is enabled for all agents. When absent (null), context caching
+ * is disabled.
+ *
+ * Context caching can significantly reduce costs and improve response times
+ * by reusing previously processed context across multiple requests.
+ */
+declare class ContextCacheConfig implements ContextCacheConfigProps {
+    /** Maximum number of invocations to reuse the same cache before refreshing it. */
+    cacheIntervals: number;
+    /** Time-to-live for cache in seconds. */
+    ttlSeconds: number;
+    /** Minimum estimated request tokens required to enable caching. */
+    minTokens: number;
+    constructor(params?: Partial<ContextCacheConfigProps>);
+    get ttlString(): string;
+    toJSON(): {
+        cacheIntervals: number;
+        ttlSeconds: number;
+        minTokens: number;
+    };
+}
+declare const contextCacheConfigSchema: z$1.ZodObject<{
+    cacheIntervals: z$1.ZodDefault<z$1.ZodNumber>;
+    ttlSeconds: z$1.ZodDefault<z$1.ZodNumber>;
+    minTokens: z$1.ZodDefault<z$1.ZodNumber>;
+}, z$1.core.$strip>;
+type ContextCacheConfigProps = z$1.infer<typeof contextCacheConfigSchema>;
+
+/**
+ * A state dict that maintain the current value and the pending-commit delta.
  */
-declare abstract class BaseLlm {
+declare class State {
+    static readonly APP_PREFIX = "app:";
+    static readonly USER_PREFIX = "user:";
+    static readonly TEMP_PREFIX = "temp:";
+    private readonly _value;
+    private readonly _delta;
     /**
-     * The name of the LLM, e.g. gemini-2.5-flash or gemini-2.5-flash-001.
+     * Constructor for State
+     *
+     * @param value - The current value of the state dict.
+     * @param delta - The delta change to the current value that hasn't been committed.
      */
-    model: string;
-    protected logger: Logger;
+    constructor(value: Record<string, any>, delta: Record<string, any>);
     /**
-     * Constructor for BaseLlm
+     * Returns the value of the state dict for the given key.
      */
-    constructor(model: string);
+    get(key: string, defaultValue?: any): any;
     /**
-     * Returns a list of supported models in regex for LLMRegistry
+     * Sets the value of the state dict for the given key.
      */
-    static supportedModels(): string[];
+    set(key: string, value: any): void;
     /**
-     * Generates one content from the given contents and tools.
-     *
-     * @param llmRequest LlmRequest, the request to send to the LLM.
-     * @param stream bool = false, whether to do streaming call.
-     * @returns a generator of LlmResponse.
-     *
-     * For non-streaming call, it will only yield one LlmResponse.
-     *
-     * For streaming call, it may yield more than one response, but all yielded
-     * responses should be treated as one response by merging the
-     * parts list.
+     * Whether the state dict contains the given key.
      */
-    generateContentAsync(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
+    has(key: string): boolean;
     /**
-     * Implementation method to be overridden by subclasses.
-     * This replaces the abstract generateContentAsync method.
+     * Whether the state has pending delta.
      */
-    protected abstract generateContentAsyncImpl(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
+    hasDelta(): boolean;
     /**
-     * Appends a user content, so that model can continue to output.
-     *
-     * @param llmRequest LlmRequest, the request to send to the LLM.
+     * Updates the state dict with the given delta.
      */
-    protected maybeAppendUserContent(llmRequest: LlmRequest): void;
+    update(delta: Record<string, any>): void;
     /**
-     * Creates a live connection to the LLM.
-     *
-     * @param llmRequest LlmRequest, the request to send to the LLM.
-     * @returns BaseLLMConnection, the connection to the LLM.
+     * Returns the state dict.
      */
-    connect(_llmRequest: LlmRequest): BaseLLMConnection;
+    toDict(): Record<string, any>;
+    /**
+     * Array-like access for getting values.
+     * Returns the value of the state dict for the given key.
+     */
+    [key: string]: any;
+    /**
+     * Proxy handler for array-like access
+     */
+    private static createProxy;
+    /**
+     * Factory method to create a proxied State instance
+     */
+    static create(value: Record<string, any>, delta: Record<string, any>): State;
 }
 
 /**
- * LLM-based event summarizer that uses a language model to generate summaries.
+ * Base readonly context class.
  */
-declare class LlmEventSummarizer implements EventsSummarizer {
-    private model;
-    private prompt;
+declare class ReadonlyContext {
+    protected readonly _invocationContext: InvocationContext;
+    constructor(invocationContext: InvocationContext);
     /**
-     * Creates a new LLM event summarizer.
-     * @param model - The LLM model to use for summarization
-     * @param prompt - Optional custom prompt template. Use {events} as placeholder for event content.
+     * The user content that started this invocation. READONLY field.
      */
-    constructor(model: BaseLlm, prompt?: string);
+    get userContent(): Content | undefined;
     /**
-     * Summarizes events using the configured LLM.
+     * The current invocation id.
      */
-    maybeSummarizeEvents(events: Event[]): Promise<Event | undefined>;
+    get invocationId(): string;
     /**
-     * Formats events into a readable text format for summarization.
+     * The name of the agent that is currently running.
      */
-    private formatEventsForSummarization;
-}
-
-type index$7_Event = Event;
-declare const index$7_Event: typeof Event;
-type index$7_EventActions = EventActions;
-declare const index$7_EventActions: typeof EventActions;
-type index$7_EventCompaction = EventCompaction;
-type index$7_EventsCompactionConfig = EventsCompactionConfig;
-type index$7_EventsSummarizer = EventsSummarizer;
-type index$7_LlmEventSummarizer = LlmEventSummarizer;
-declare const index$7_LlmEventSummarizer: typeof LlmEventSummarizer;
-declare const index$7_runCompactionForSlidingWindow: typeof runCompactionForSlidingWindow;
-declare namespace index$7 {
-  export { index$7_Event as Event, index$7_EventActions as EventActions, type index$7_EventCompaction as EventCompaction, type index$7_EventsCompactionConfig as EventsCompactionConfig, type index$7_EventsSummarizer as EventsSummarizer, index$7_LlmEventSummarizer as LlmEventSummarizer, index$7_runCompactionForSlidingWindow as runCompactionForSlidingWindow };
-}
-
-declare abstract class BasePlugin {
-    readonly name: string;
-    constructor(name: string);
-    onUserMessageCallback?(_params: {
-        invocationContext: InvocationContext;
-        userMessage: Content;
-    }): Promise<Content | undefined>;
-    beforeRunCallback?(_params: {
-        invocationContext: InvocationContext;
-    }): Promise<Event | undefined>;
-    onEventCallback?(_params: {
-        invocationContext: InvocationContext;
-        event: Event;
-    }): Promise<Event | undefined>;
-    afterRunCallback?(_params: {
-        invocationContext: InvocationContext;
-        result?: any;
-    }): Promise<void>;
-    close?(): Promise<void>;
-    beforeAgentCallback?(_params: {
-        agent: BaseAgent;
-        callbackContext: CallbackContext;
-    }): Promise<Content | undefined>;
-    afterAgentCallback?(_params: {
-        agent: BaseAgent;
-        callbackContext: CallbackContext;
-        result?: any;
-    }): Promise<Content | undefined>;
-    beforeModelCallback?(_params: {
-        callbackContext: CallbackContext;
-        llmRequest: LlmRequest;
-    }): Promise<LlmResponse | undefined>;
-    afterModelCallback?(_params: {
-        callbackContext: CallbackContext;
-        llmResponse: LlmResponse;
-        llmRequest?: LlmRequest;
-    }): Promise<LlmResponse | undefined>;
-    onModelErrorCallback?(_params: {
-        callbackContext: CallbackContext;
-        llmRequest: LlmRequest;
-        error: unknown;
-    }): Promise<LlmResponse | undefined>;
-    beforeToolCallback?(_params: {
-        tool: BaseTool;
-        toolArgs: Record<string, any>;
-        toolContext: ToolContext;
-    }): Promise<Record<string, any> | undefined>;
-    afterToolCallback?(_params: {
-        tool: BaseTool;
-        toolArgs: Record<string, any>;
-        toolContext: ToolContext;
-        result: Record<string, any>;
-    }): Promise<Record<string, any> | undefined>;
-    onToolErrorCallback?(_params: {
-        tool: BaseTool;
-        toolArgs: Record<string, any>;
-        toolContext: ToolContext;
-        error: unknown;
-    }): Promise<Record<string, any> | undefined>;
-}
-
-declare const pluginCallbackNameSchema: z$1.ZodEnum<{
-    onUserMessageCallback: "onUserMessageCallback";
-    beforeRunCallback: "beforeRunCallback";
-    afterRunCallback: "afterRunCallback";
-    onEventCallback: "onEventCallback";
-    beforeAgentCallback: "beforeAgentCallback";
-    afterAgentCallback: "afterAgentCallback";
-    beforeToolCallback: "beforeToolCallback";
-    afterToolCallback: "afterToolCallback";
-    beforeModelCallback: "beforeModelCallback";
-    afterModelCallback: "afterModelCallback";
-    onToolErrorCallback: "onToolErrorCallback";
-    onModelErrorCallback: "onModelErrorCallback";
-}>;
-type PluginCallbackName = z$1.infer<typeof pluginCallbackNameSchema>;
-declare class PluginManager {
-    readonly plugins: BasePlugin[];
-    private readonly closeTimeout;
-    constructor(opts?: {
-        plugins?: BasePlugin[];
-        closeTimeout?: number;
-    });
-    /** Register a plugin (unique names) */
-    registerPlugin(plugin: BasePlugin): void;
-    getPlugin(name: string): BasePlugin | undefined;
-    getPlugins(): BasePlugin[];
-    runOnUserMessageCallback(params: {
-        userMessage: Content;
-        invocationContext: InvocationContext;
-    }): Promise<any>;
-    runBeforeRunCallback(params: {
-        invocationContext: InvocationContext;
-    }): Promise<any>;
-    runAfterRunCallback(params: {
-        invocationContext: InvocationContext;
-    }): Promise<any>;
-    runOnEventCallback(params: {
-        invocationContext: InvocationContext;
-        event: Event;
-    }): Promise<any>;
-    runBeforeAgentCallback(params: {
-        agent: BaseAgent;
-        callbackContext: CallbackContext;
-    }): Promise<any>;
-    runAfterAgentCallback(params: {
-        agent: BaseAgent;
-        callbackContext: CallbackContext;
-    }): Promise<any>;
-    runBeforeToolCallback(params: {
-        tool: BaseTool;
-        toolArgs: Record<string, any>;
-        toolContext: ToolContext;
-    }): Promise<any>;
-    runAfterToolCallback(params: {
-        tool: BaseTool;
-        toolArgs: Record<string, any>;
-        toolContext: ToolContext;
-        result: Record<string, any>;
-    }): Promise<any>;
-    runBeforeModelCallback(params: {
-        callbackContext: CallbackContext;
-        llmRequest: LlmRequest;
-    }): Promise<any>;
-    runAfterModelCallback(params: {
-        callbackContext: CallbackContext;
-        llmResponse: LlmResponse;
-    }): Promise<any>;
-    runOnToolErrorCallback(params: {
-        tool: BaseTool;
-        toolArgs: Record<string, any>;
-        toolContext: ToolContext;
-        error: Error;
-    }): Promise<any>;
-    runOnModelErrorCallback(params: {
-        callbackContext: CallbackContext;
-        llmRequest: LlmRequest;
-        error: Error;
-    }): Promise<any>;
-    private runCallbacks;
-    close(): Promise<void>;
-}
-
-/**
- * Request send to live agents.
- */
-declare class LiveRequest {
-    /**
-     * If set, send the content to the model in turn-by-turn mode.
-     */
-    content?: Content;
-    /**
-     * If set, send the blob to the model in realtime mode.
-     */
-    blob?: Blob;
-    /**
-     * If set, close the queue.
-     */
-    close: boolean;
-    constructor(options?: {
-        content?: Content;
-        blob?: Blob;
-        close?: boolean;
-    });
-}
-/**
- * Queue used to send LiveRequest in a live(bidirectional streaming) way.
- */
-declare class LiveRequestQueue {
-    private _queue;
-    private _waiters;
-    private _closed;
-    /**
-     * Close the queue.
-     */
-    close(): void;
-    /**
-     * Send content to the queue.
-     */
-    sendContent(content: Content): void;
-    /**
-     * Send realtime blob to the queue.
-     */
-    sendRealtime(blob: Blob): void;
-    /**
-     * Send a LiveRequest to the queue.
-     */
-    send(req: LiveRequest): void;
-    /**
-     * Get the next LiveRequest from the queue.
-     */
-    get(): Promise<LiveRequest>;
-}
-
-/**
- * Manages streaming tool related resources during invocation.
- */
-declare class ActiveStreamingTool {
-    /**
-     * The active task of this streaming tool.
-     */
-    task?: Promise<any>;
-    /**
-     * The active (input) streams of this streaming tool.
-     */
-    stream?: LiveRequestQueue;
-    constructor(options?: {
-        task?: Promise<any>;
-        stream?: LiveRequestQueue;
-    });
-}
-
-/**
- * Single agent callback type
- */
-type SingleAgentCallback = (callbackContext: CallbackContext) => Promise<Content | undefined> | Content | undefined;
-/**
- * Before agent callback type
- */
-type BeforeAgentCallback = SingleAgentCallback | SingleAgentCallback[];
-/**
- * After agent callback type
- */
-type AfterAgentCallback = SingleAgentCallback | SingleAgentCallback[];
-/**
- * Base class for all agents in Agent Development Kit.
- */
-declare abstract class BaseAgent {
-    /**
-     * The agent's name.
-     * Agent name must be a valid identifier and unique within the agent tree.
-     * Agent name cannot be "user", since it's reserved for end-user's input.
-     */
-    name: string;
-    /**
-     * Description about the agent's capability.
-     * The model uses this to determine whether to delegate control to the agent.
-     * One-line description is enough and preferred.
-     */
-    description: string;
-    /**
-     * The parent agent of this agent.
-     * Note that an agent can ONLY be added as sub-agent once.
-     * If you want to add one agent twice as sub-agent, consider to create two agent
-     * instances with identical config, but with different name and add them to the
-     * agent tree.
-     */
-    parentAgent?: BaseAgent;
-    /**
-     * The sub-agents of this agent.
-     */
-    subAgents: BaseAgent[];
-    /**
-     * Callback or list of callbacks to be invoked before the agent run.
-     * When a list of callbacks is provided, the callbacks will be called in the
-     * order they are listed until a callback does not return undefined.
-     *
-     * Args:
-     *   callbackContext: The callback context.
-     *
-     * Returns:
-     *   Content | undefined: The content to return to the user.
-     *     When the content is present, the agent run will be skipped and the
-     *     provided content will be returned to user.
-     */
-    beforeAgentCallback?: BeforeAgentCallback;
-    /**
-     * Callback or list of callbacks to be invoked after the agent run.
-     * When a list of callbacks is provided, the callbacks will be called in the
-     * order they are listed until a callback does not return undefined.
-     *
-     * Args:
-     *   callbackContext: The callback context.
-     *
-     * Returns:
-     *   Content | undefined: The content to return to the user.
-     *     When the content is present, the provided content will be used as agent
-     *     response and appended to event history as agent response.
-     */
-    afterAgentCallback?: AfterAgentCallback;
-    /**
-     * Constructor for BaseAgent
-     */
-    constructor(config: {
-        name: string;
-        description?: string;
-        subAgents?: BaseAgent[];
-        beforeAgentCallback?: BeforeAgentCallback;
-        afterAgentCallback?: AfterAgentCallback;
-    });
-    /**
-     * Entry method to run an agent via text-based conversation.
-     */
-    runAsync(parentContext: InvocationContext): AsyncGenerator<Event, void, unknown>;
-    /**
-     * Entry method to run an agent via video/audio-based conversation.
-     */
-    runLive(parentContext: InvocationContext): AsyncGenerator<Event, void, unknown>;
-    /**
-     * Internal implementation for runAsync
-     */
-    private runAsyncInternal;
-    /**
-     * Internal implementation for runLive
-     */
-    private runLiveInternal;
-    /**
-     * Core logic to run this agent via text-based conversation.
-     *
-     * @param ctx - The invocation context for this agent.
-     * @yields Event - The events generated by the agent.
-     */
-    protected runAsyncImpl(_ctx: InvocationContext): AsyncGenerator<Event, void, unknown>;
-    /**
-     * Core logic to run this agent via video/audio-based conversation.
-     *
-     * @param ctx - The invocation context for this agent.
-     * @yields Event - The events generated by the agent.
-     */
-    protected runLiveImpl(_ctx: InvocationContext): AsyncGenerator<Event, void, unknown>;
-    /**
-     * Gets the root agent of this agent.
-     */
-    get rootAgent(): BaseAgent;
-    /**
-     * Finds the agent with the given name in this agent and its descendants.
-     *
-     * @param name - The name of the agent to find.
-     * @returns The agent with the matching name, or undefined if no such agent is found.
-     */
-    findAgent(name: string): BaseAgent | undefined;
-    /**
-     * Finds the agent with the given name in this agent's descendants.
-     *
-     * @param name - The name of the agent to find.
-     * @returns The agent with the matching name, or undefined if no such agent is found.
-     */
-    findSubAgent(name: string): BaseAgent | undefined;
-    /**
-     * Creates a new invocation context for this agent.
-     */
-    private createInvocationContext;
-    /**
-     * The resolved beforeAgentCallback field as a list of SingleAgentCallback.
-     * This method is only for use by Agent Development Kit.
-     */
-    get canonicalBeforeAgentCallbacks(): SingleAgentCallback[];
-    /**
-     * The resolved afterAgentCallback field as a list of SingleAgentCallback.
-     * This method is only for use by Agent Development Kit.
-     */
-    get canonicalAfterAgentCallbacks(): SingleAgentCallback[];
-    /**
-     * Runs the beforeAgentCallback if it exists.
-     * First runs plugin callbacks, then runs canonical callbacks if no override provided.
-     *
-     * @returns An event if callback provides content or changed state.
-     */
-    private handleBeforeAgentCallback;
-    /**
-     * Runs the afterAgentCallback if it exists.
-     * First runs plugin callbacks, then runs canonical callbacks if no override provided.
-     *
-     * @returns An event if callback provides content or changed state.
-     */
-    private handleAfterAgentCallback;
-    /**
-     * Validates the agent name.
-     */
-    private validateName;
-    /**
-     * Sets parent agent for sub-agents.
-     */
-    private setParentAgentForSubAgents;
-}
-
-/**
- * Streaming mode options for agent execution
- */
-declare enum StreamingMode {
-    NONE = "NONE",
-    SSE = "sse",
-    BIDI = "bidi"
-}
-/**
- * Configs for runtime behavior of agents
- */
-declare class RunConfig {
-    /**
-     * Speech configuration for the live agent
-     */
-    speechConfig?: SpeechConfig;
-    /**
-     * The output modalities. If not set, it's default to AUDIO.
-     */
-    responseModalities?: string[];
-    /**
-     * Whether or not to save the input blobs as artifacts.
-     */
-    saveInputBlobsAsArtifacts: boolean;
-    /**
-     * Whether to support CFC (Compositional Function Calling). Only applicable for
-     * StreamingMode.SSE. If it's true. the LIVE API will be invoked. Since only LIVE
-     * API supports CFC
-     *
-     * @warning This feature is **experimental** and its API or behavior may change
-     * in future releases.
-     */
-    supportCFC: boolean;
-    /**
-     * Streaming mode, None or StreamingMode.SSE or StreamingMode.BIDI.
-     */
-    streamingMode: StreamingMode;
-    /**
-     * Output transcription for live agents with audio response.
-     */
-    outputAudioTranscription?: AudioTranscriptionConfig;
-    /**
-     * Input transcription for live agents with audio input from user.
-     */
-    inputAudioTranscription?: AudioTranscriptionConfig;
-    /**
-     * Realtime input config for live agents with audio input from user.
-     */
-    realtimeInputConfig?: RealtimeInputConfig;
-    /**
-     * If enabled, the model will detect emotions and adapt its responses accordingly.
-     */
-    enableAffectiveDialog?: boolean;
-    /**
-     * Configures the proactivity of the model. This allows the model to respond
-     * proactively to the input and to ignore irrelevant input.
-     */
-    proactivity?: ProactivityConfig;
-    /**
-     * A limit on the total number of llm calls for a given run.
-     *
-     * Valid Values:
-     *   - More than 0 and less than Number.MAX_SAFE_INTEGER: The bound on the number of llm
-     *     calls is enforced, if the value is set in this range.
-     *   - Less than or equal to 0: This allows for unbounded number of llm calls.
-     */
-    maxLlmCalls: number;
-    constructor(config?: Partial<RunConfig>);
-    /**
-     * Validates the maxLlmCalls value
-     */
-    private validateMaxLlmCalls;
-}
-
-/**
- * Store the data that can be used for transcription.
- */
-declare class TranscriptionEntry {
-    /**
-     * The role that created this data, typically "user" or "model". For function
-     * call, this is None.
-     */
-    role?: string;
-    /**
-     * The data that can be used for transcription
-     */
-    data: Blob | Content;
-    constructor(options: {
-        role?: string;
-        data: Blob | Content;
-    });
-}
-
-/**
- * Transfer context for multi-agent workflows
- * Tracks the chain of agent transfers for telemetry
- */
-interface TransferContext {
-    /** Array of agent names in transfer order */
-    transferChain: string[];
-    /** Current depth in transfer chain (0 = root) */
-    transferDepth: number;
-    /** Name of the root agent that started the chain */
-    rootAgentName: string;
-    /** Span context of the root agent for linking */
-    rootSpanContext?: SpanContext;
-    /** Span context of the previous agent in the chain */
-    previousSpanContext?: SpanContext;
-}
-/**
- * Error thrown when the number of LLM calls exceed the limit.
- */
-declare class LlmCallsLimitExceededError extends Error {
-    constructor(message: string);
-}
-/**
- * Generates a new invocation context ID
- */
-declare function newInvocationContextId(): string;
-/**
- * An invocation context represents the data of a single invocation of an agent.
- *
- * An invocation:
- *   1. Starts with a user message and ends with a final response.
- *   2. Can contain one or multiple agent calls.
- *   3. Is handled by runner.run_async().
- *
- * An invocation runs an agent until it does not request to transfer to another
- * agent.
- *
- * An agent call:
- *   1. Is handled by agent.run().
- *   2. Ends when agent.run() ends.
- *
- * An LLM agent call is an agent with a BaseLLMFlow.
- * An LLM agent call can contain one or multiple steps.
- *
- * An LLM agent runs steps in a loop until:
- *   1. A final response is generated.
- *   2. The agent transfers to another agent.
- *   3. The end_invocation is set to true by any callbacks or tools.
- *
- * A step:
- *   1. Calls the LLM only once and yields its response.
- *   2. Calls the tools and yields their responses if requested.
- *
- * The summarization of the function response is considered another step, since
- * it is another llm call.
- *
- * A step ends when it's done calling llm and tools, or if the end_invocation
- * is set to true at any time.
- *
- *
- *     ┌─────────────────────── invocation ──────────────────────────┐
- *     ┌──────────── llm_agent_call_1 ────────────┐ ┌─ agent_call_2 ─┐
- *     ┌──── step_1 ────────┐ ┌───── step_2 ──────┐
- *     [call_llm] [call_tool] [call_llm] [transfer]
- *
- */
-declare class InvocationContext {
-    readonly artifactService?: BaseArtifactService;
-    readonly sessionService: BaseSessionService;
-    readonly memoryService?: BaseMemoryService;
-    /**
-     * The plugin manager for this invocation context.
-     */
-    readonly pluginManager: PluginManager;
-    /**
-     * The id of this invocation context. Readonly.
-     */
-    readonly invocationId: string;
-    /**
-     * The branch of the invocation context.
-     *
-     * The format is like agent_1.agent_2.agent_3, where agent_1 is the parent of
-     * agent_2, and agent_2 is the parent of agent_3.
-     *
-     * Branch is used when multiple sub-agents shouldn't see their peer agents'
-     * conversation history.
-     */
-    readonly branch?: string;
-    /**
-     * The current agent of this invocation context. Readonly.
-     */
-    agent: BaseAgent;
-    /**
-     * The user content that started this invocation. Readonly.
-     */
-    readonly userContent?: Content;
-    /**
-     * The current session of this invocation context. Readonly.
-     */
-    readonly session: Session;
-    /**
-     * Whether to end this invocation.
-     *
-     * Set to True in callbacks or tools to terminate this invocation.
-     */
-    endInvocation: boolean;
-    /**
-     * The queue to receive live requests.
-     */
-    liveRequestQueue?: LiveRequestQueue;
-    /**
-     * The running streaming tools of this invocation.
-     */
-    activeStreamingTools?: Record<string, ActiveStreamingTool>;
-    /**
-     * Caches necessary, data audio or contents, that are needed by transcription.
-     */
-    transcriptionCache?: TranscriptionEntry[];
-    /**
-     * Configurations for live agents under this invocation.
-     */
-    runConfig?: RunConfig;
-    /**
-     * Transfer context for multi-agent workflows
-     * Tracks agent transfer chain for telemetry
-     */
-    transferContext?: TransferContext;
-    /**
-     * A container to keep track of different kinds of costs incurred as a part
-     * of this invocation.
-     */
-    private readonly _invocationCostManager;
-    /**
-     * Constructor for InvocationContext
-     */
-    constructor(options: {
-        artifactService?: BaseArtifactService;
-        sessionService: BaseSessionService;
-        memoryService?: BaseMemoryService;
-        pluginManager: PluginManager;
-        invocationId?: string;
-        branch?: string;
-        agent: BaseAgent;
-        userContent?: Content;
-        session: Session;
-        endInvocation?: boolean;
-        liveRequestQueue?: LiveRequestQueue;
-        activeStreamingTools?: Record<string, ActiveStreamingTool>;
-        transcriptionCache?: TranscriptionEntry[];
-        runConfig?: RunConfig;
-        transferContext?: TransferContext;
-    });
-    /**
-     * App name from the session
-     */
-    get appName(): string;
-    /**
-     * User ID from the session
-     */
-    get userId(): string;
-    /**
-     * Tracks number of llm calls made.
-     *
-     * @throws {LlmCallsLimitExceededError} If number of llm calls made exceed the set threshold.
-     */
-    incrementLlmCallCount(): void;
-    /**
-     * Creates a child invocation context for a sub-agent
-     */
-    createChildContext(agent: BaseAgent): InvocationContext;
-}
-
-/**
- * Base readonly context class.
- */
-declare class ReadonlyContext {
-    protected readonly _invocationContext: InvocationContext;
-    constructor(invocationContext: InvocationContext);
-    /**
-     * The user content that started this invocation. READONLY field.
-     */
-    get userContent(): Content | undefined;
-    /**
-     * The current invocation id.
-     */
-    get invocationId(): string;
-    /**
-     * The name of the agent that is currently running.
-     */
-    get agentName(): string;
-    /**
-     * The application name for this invocation. READONLY field.
-     */
-    get appName(): string;
-    /**
-     * The user ID for this invocation. READONLY field.
-     */
-    get userId(): string;
-    /**
-     * The session ID for this invocation. READONLY field.
-     */
-    get sessionId(): string;
-    /**
-     * The state of the current session. READONLY field.
-     */
-    get state(): Readonly<Record<string, any>>;
+    get agentName(): string;
+    /**
+     * The application name for this invocation. READONLY field.
+     */
+    get appName(): string;
+    /**
+     * The user ID for this invocation. READONLY field.
+     */
+    get userId(): string;
+    /**
+     * The session ID for this invocation. READONLY field.
+     */
+    get sessionId(): string;
+    /**
+     * The state of the current session. READONLY field.
+     */
+    get state(): Readonly<Record<string, any>>;
 }
 
 /**
@@ -1665,97 +1174,322 @@ interface CodeExecutionResult {
 }
 declare class CodeExecutionUtils {
     /**
-     * Gets the file content as a base64-encoded string
+     * Gets the file content as a base64-encoded string
+     */
+    static getEncodedFileContent(data: string | ArrayBuffer): string;
+    private static isBase64Encoded;
+    /**
+     * Extracts the first code block from the content and truncates everything after it
+     */
+    static extractCodeAndTruncateContent(content: Content, codeBlockDelimiters: Array<[string, string]>): string | null;
+    private static escapeRegex;
+    /**
+     * Builds an executable code part with code string
+     */
+    static buildExecutableCodePart(code: string): Part;
+    /**
+     * Builds the code execution result part from the code execution result
+     */
+    static buildCodeExecutionResultPart(codeExecutionResult: CodeExecutionResult): Part;
+    /**
+     * Converts the code execution parts to text parts in a Content
+     */
+    static convertCodeExecutionParts(content: Content, codeBlockDelimiter: [string, string], executionResultDelimiters: [string, string]): void;
+}
+
+interface BaseCodeExecutorConfig {
+    /**
+     * If true, extract and process data files from the model request
+     * and attach them to the code executor.
+     * Supported data file MimeTypes are [text/csv].
+     * Default to false.
+     */
+    optimizeDataFile?: boolean;
+    /**
+     * Whether the code executor is stateful. Default to false.
+     */
+    stateful?: boolean;
+    /**
+     * The number of attempts to retry on consecutive code execution errors.
+     * Default to 2.
+     */
+    errorRetryAttempts?: number;
+    /**
+     * The list of the enclosing delimiters to identify the code blocks.
+     * For example, the delimiter ['```python\n', '\n```'] can be
+     * used to identify code blocks with the following format:
+     *
+     * ```python
+     * print("hello")
+     * ```
+     */
+    codeBlockDelimiters?: Array<[string, string]>;
+    /**
+     * The delimiters to format the code execution result.
+     */
+    executionResultDelimiters?: [string, string];
+}
+declare abstract class BaseCodeExecutor {
+    protected readonly config: Required<BaseCodeExecutorConfig>;
+    constructor(config?: BaseCodeExecutorConfig);
+    /**
+     * Executes code and returns the code execution result.
+     */
+    abstract executeCode(invocationContext: InvocationContext, codeExecutionInput: CodeExecutionInput): Promise<CodeExecutionResult>;
+    get optimizeDataFile(): boolean;
+    get stateful(): boolean;
+    get errorRetryAttempts(): number;
+    get codeBlockDelimiters(): Array<[string, string]>;
+    get executionResultDelimiters(): [string, string];
+}
+
+/**
+ * Abstract base class for all planners.
+ *
+ * The planner allows the agent to generate plans for the queries to guide its action.
+ */
+declare abstract class BasePlanner {
+    /**
+     * Builds the system instruction to be appended to the LLM request for planning.
+     *
+     * @param readonlyContext The readonly context of the invocation
+     * @param llmRequest The LLM request. Readonly.
+     * @returns The planning system instruction, or undefined if no instruction is needed
+     */
+    abstract buildPlanningInstruction(readonlyContext: ReadonlyContext, llmRequest: LlmRequest): string | undefined;
+    /**
+     * Processes the LLM response for planning.
+     *
+     * @param callbackContext The callback context of the invocation
+     * @param responseParts The LLM response parts. Readonly.
+     * @returns The processed response parts, or undefined if no processing is needed
+     */
+    abstract processPlanningResponse(callbackContext: CallbackContext, responseParts: Part[]): Part[] | undefined;
+}
+
+declare abstract class BasePlugin {
+    readonly name: string;
+    constructor(name: string);
+    onUserMessageCallback?(_params: {
+        invocationContext: InvocationContext;
+        userMessage: Content;
+    }): Promise<Content | undefined>;
+    beforeRunCallback?(_params: {
+        invocationContext: InvocationContext;
+    }): Promise<Event | undefined>;
+    onEventCallback?(_params: {
+        invocationContext: InvocationContext;
+        event: Event;
+    }): Promise<Event | undefined>;
+    afterRunCallback?(_params: {
+        invocationContext: InvocationContext;
+        result?: any;
+    }): Promise<void>;
+    close?(): Promise<void>;
+    beforeAgentCallback?(_params: {
+        agent: BaseAgent;
+        callbackContext: CallbackContext;
+    }): Promise<Content | undefined>;
+    afterAgentCallback?(_params: {
+        agent: BaseAgent;
+        callbackContext: CallbackContext;
+        result?: any;
+    }): Promise<Content | undefined>;
+    beforeModelCallback?(_params: {
+        callbackContext: CallbackContext;
+        llmRequest: LlmRequest;
+    }): Promise<LlmResponse | undefined>;
+    afterModelCallback?(_params: {
+        callbackContext: CallbackContext;
+        llmResponse: LlmResponse;
+        llmRequest?: LlmRequest;
+    }): Promise<LlmResponse | undefined>;
+    onModelErrorCallback?(_params: {
+        callbackContext: CallbackContext;
+        llmRequest: LlmRequest;
+        error: unknown;
+    }): Promise<LlmResponse | undefined>;
+    beforeToolCallback?(_params: {
+        tool: BaseTool;
+        toolArgs: Record<string, any>;
+        toolContext: ToolContext;
+    }): Promise<Record<string, any> | undefined>;
+    afterToolCallback?(_params: {
+        tool: BaseTool;
+        toolArgs: Record<string, any>;
+        toolContext: ToolContext;
+        result: Record<string, any>;
+    }): Promise<Record<string, any> | undefined>;
+    onToolErrorCallback?(_params: {
+        tool: BaseTool;
+        toolArgs: Record<string, any>;
+        toolContext: ToolContext;
+        error: unknown;
+    }): Promise<Record<string, any> | undefined>;
+}
+
+/**
+ * Single agent callback type
+ */
+type SingleAgentCallback = (callbackContext: CallbackContext) => Promise<Content | undefined> | Content | undefined;
+/**
+ * Before agent callback type
+ */
+type BeforeAgentCallback = SingleAgentCallback | SingleAgentCallback[];
+/**
+ * After agent callback type
+ */
+type AfterAgentCallback = SingleAgentCallback | SingleAgentCallback[];
+/**
+ * Base class for all agents in Agent Development Kit.
+ */
+declare abstract class BaseAgent {
+    /**
+     * The agent's name.
+     * Agent name must be a valid identifier and unique within the agent tree.
+     * Agent name cannot be "user", since it's reserved for end-user's input.
+     */
+    name: string;
+    /**
+     * Description about the agent's capability.
+     * The model uses this to determine whether to delegate control to the agent.
+     * One-line description is enough and preferred.
+     */
+    description: string;
+    /**
+     * The parent agent of this agent.
+     * Note that an agent can ONLY be added as sub-agent once.
+     * If you want to add one agent twice as sub-agent, consider to create two agent
+     * instances with identical config, but with different name and add them to the
+     * agent tree.
+     */
+    parentAgent?: BaseAgent;
+    /**
+     * The sub-agents of this agent.
+     */
+    subAgents: BaseAgent[];
+    /**
+     * Callback or list of callbacks to be invoked before the agent run.
+     * When a list of callbacks is provided, the callbacks will be called in the
+     * order they are listed until a callback does not return undefined.
+     *
+     * Args:
+     *   callbackContext: The callback context.
+     *
+     * Returns:
+     *   Content | undefined: The content to return to the user.
+     *     When the content is present, the agent run will be skipped and the
+     *     provided content will be returned to user.
+     */
+    beforeAgentCallback?: BeforeAgentCallback;
+    /**
+     * Callback or list of callbacks to be invoked after the agent run.
+     * When a list of callbacks is provided, the callbacks will be called in the
+     * order they are listed until a callback does not return undefined.
+     *
+     * Args:
+     *   callbackContext: The callback context.
+     *
+     * Returns:
+     *   Content | undefined: The content to return to the user.
+     *     When the content is present, the provided content will be used as agent
+     *     response and appended to event history as agent response.
      */
-    static getEncodedFileContent(data: string | ArrayBuffer): string;
-    private static isBase64Encoded;
+    afterAgentCallback?: AfterAgentCallback;
     /**
-     * Extracts the first code block from the content and truncates everything after it
+     * Constructor for BaseAgent
      */
-    static extractCodeAndTruncateContent(content: Content, codeBlockDelimiters: Array<[string, string]>): string | null;
-    private static escapeRegex;
+    constructor(config: {
+        name: string;
+        description?: string;
+        subAgents?: BaseAgent[];
+        beforeAgentCallback?: BeforeAgentCallback;
+        afterAgentCallback?: AfterAgentCallback;
+    });
     /**
-     * Builds an executable code part with code string
+     * Entry method to run an agent via text-based conversation.
      */
-    static buildExecutableCodePart(code: string): Part;
+    runAsync(parentContext: InvocationContext): AsyncGenerator<Event, void, unknown>;
     /**
-     * Builds the code execution result part from the code execution result
+     * Entry method to run an agent via video/audio-based conversation.
      */
-    static buildCodeExecutionResultPart(codeExecutionResult: CodeExecutionResult): Part;
+    runLive(parentContext: InvocationContext): AsyncGenerator<Event, void, unknown>;
     /**
-     * Converts the code execution parts to text parts in a Content
+     * Internal implementation for runAsync
      */
-    static convertCodeExecutionParts(content: Content, codeBlockDelimiter: [string, string], executionResultDelimiters: [string, string]): void;
-}
-
-interface BaseCodeExecutorConfig {
+    private runAsyncInternal;
     /**
-     * If true, extract and process data files from the model request
-     * and attach them to the code executor.
-     * Supported data file MimeTypes are [text/csv].
-     * Default to false.
+     * Internal implementation for runLive
      */
-    optimizeDataFile?: boolean;
+    private runLiveInternal;
     /**
-     * Whether the code executor is stateful. Default to false.
+     * Core logic to run this agent via text-based conversation.
+     *
+     * @param ctx - The invocation context for this agent.
+     * @yields Event - The events generated by the agent.
      */
-    stateful?: boolean;
+    protected runAsyncImpl(_ctx: InvocationContext): AsyncGenerator<Event, void, unknown>;
     /**
-     * The number of attempts to retry on consecutive code execution errors.
-     * Default to 2.
+     * Core logic to run this agent via video/audio-based conversation.
+     *
+     * @param ctx - The invocation context for this agent.
+     * @yields Event - The events generated by the agent.
      */
-    errorRetryAttempts?: number;
+    protected runLiveImpl(_ctx: InvocationContext): AsyncGenerator<Event, void, unknown>;
     /**
-     * The list of the enclosing delimiters to identify the code blocks.
-     * For example, the delimiter ['```python\n', '\n```'] can be
-     * used to identify code blocks with the following format:
+     * Gets the root agent of this agent.
+     */
+    get rootAgent(): BaseAgent;
+    /**
+     * Finds the agent with the given name in this agent and its descendants.
      *
-     * ```python
-     * print("hello")
-     * ```
+     * @param name - The name of the agent to find.
+     * @returns The agent with the matching name, or undefined if no such agent is found.
      */
-    codeBlockDelimiters?: Array<[string, string]>;
+    findAgent(name: string): BaseAgent | undefined;
     /**
-     * The delimiters to format the code execution result.
+     * Finds the agent with the given name in this agent's descendants.
+     *
+     * @param name - The name of the agent to find.
+     * @returns The agent with the matching name, or undefined if no such agent is found.
      */
-    executionResultDelimiters?: [string, string];
-}
-declare abstract class BaseCodeExecutor {
-    protected readonly config: Required<BaseCodeExecutorConfig>;
-    constructor(config?: BaseCodeExecutorConfig);
+    findSubAgent(name: string): BaseAgent | undefined;
     /**
-     * Executes code and returns the code execution result.
+     * Creates a new invocation context for this agent.
      */
-    abstract executeCode(invocationContext: InvocationContext, codeExecutionInput: CodeExecutionInput): Promise<CodeExecutionResult>;
-    get optimizeDataFile(): boolean;
-    get stateful(): boolean;
-    get errorRetryAttempts(): number;
-    get codeBlockDelimiters(): Array<[string, string]>;
-    get executionResultDelimiters(): [string, string];
-}
-
-/**
- * Abstract base class for all planners.
- *
- * The planner allows the agent to generate plans for the queries to guide its action.
- */
-declare abstract class BasePlanner {
+    private createInvocationContext;
     /**
-     * Builds the system instruction to be appended to the LLM request for planning.
+     * The resolved beforeAgentCallback field as a list of SingleAgentCallback.
+     * This method is only for use by Agent Development Kit.
+     */
+    get canonicalBeforeAgentCallbacks(): SingleAgentCallback[];
+    /**
+     * The resolved afterAgentCallback field as a list of SingleAgentCallback.
+     * This method is only for use by Agent Development Kit.
+     */
+    get canonicalAfterAgentCallbacks(): SingleAgentCallback[];
+    /**
+     * Runs the beforeAgentCallback if it exists.
+     * First runs plugin callbacks, then runs canonical callbacks if no override provided.
      *
-     * @param readonlyContext The readonly context of the invocation
-     * @param llmRequest The LLM request. Readonly.
-     * @returns The planning system instruction, or undefined if no instruction is needed
+     * @returns An event if callback provides content or changed state.
      */
-    abstract buildPlanningInstruction(readonlyContext: ReadonlyContext, llmRequest: LlmRequest): string | undefined;
+    private handleBeforeAgentCallback;
     /**
-     * Processes the LLM response for planning.
+     * Runs the afterAgentCallback if it exists.
+     * First runs plugin callbacks, then runs canonical callbacks if no override provided.
      *
-     * @param callbackContext The callback context of the invocation
-     * @param responseParts The LLM response parts. Readonly.
-     * @returns The processed response parts, or undefined if no processing is needed
+     * @returns An event if callback provides content or changed state.
      */
-    abstract processPlanningResponse(callbackContext: CallbackContext, responseParts: Part[]): Part[] | undefined;
+    private handleAfterAgentCallback;
+    /**
+     * Validates the agent name.
+     */
+    private validateName;
+    /**
+     * Sets parent agent for sub-agents.
+     */
+    private setParentAgentForSubAgents;
 }
 
 /**
@@ -2171,7 +1905,7 @@ declare class AgentTool extends BaseTool {
     /**
      * Execute the tool by running the agent with the provided input
      */
-    runAsync(params: Record<string, any>, context: ToolContext): Promise<any>;
+    runAsync(params: Record<string, any>, context: ToolContext): Promise<unknown>;
 }
 
 /**
@@ -2186,7 +1920,7 @@ declare class ExitLoopTool extends BaseTool {
     /**
      * Execute the exit loop action
      */
-    runAsync(_args: Record<string, any>, context: ToolContext): Promise<any>;
+    runAsync(_args: Record<string, any>, context: ToolContext): Promise<void>;
 }
 
 interface FileOperationResult {
@@ -2274,31 +2008,24 @@ declare class GetUserChoiceTool extends BaseTool {
     runAsync(args: {
         options: string[];
         question?: string;
-    }, context: ToolContext): Promise<any>;
+    }, context: ToolContext): Promise<string | null>;
 }
 
-/**
- * Simple GoogleSearch tool implementation
- */
-declare class GoogleSearch extends BaseTool {
+declare class GoogleSearchTool extends BaseTool {
     protected logger: Logger;
-    /**
-     * Constructor for GoogleSearch
-     */
     constructor();
-    /**
-     * Get the function declaration for the tool
-     */
     getDeclaration(): FunctionDeclaration;
-    /**
-     * Execute the search
-     * This is a simplified implementation that doesn't actually search, just returns mock results
-     */
-    runAsync(args: {
-        query: string;
-        num_results?: number;
-    }, _context: ToolContext): Promise<any>;
+    runAsync(rawArgs: unknown, _context: ToolContext): Promise<{
+        results?: GoogleSearchResult[];
+        success: boolean;
+        error?: string;
+    }>;
 }
+type GoogleSearchResult = {
+    title: string;
+    link: string;
+    snippet: string;
+};
 
 interface HttpRequestResult {
     statusCode: number;
@@ -2363,70 +2090,272 @@ declare class LoadArtifactsTool extends BaseTool {
     private extractFunctionResponse;
 }
 
-/**
- * Tool that allows an agent to load memories relevant to a query
- */
-declare class LoadMemoryTool extends BaseTool {
-    protected logger: Logger;
-    /**
-     * Constructor for LoadMemoryTool
-     */
+interface LoadMemoryResult {
+    memories?: any[];
+    count?: number;
+    error?: string;
+    message?: string;
+}
+/**
+ * Tool that allows an agent to load memories relevant to a query
+ */
+declare class LoadMemoryTool extends BaseTool {
+    protected logger: Logger;
+    /**
+     * Constructor for LoadMemoryTool
+     */
+    constructor();
+    /**
+     * Get the function declaration for the tool
+     */
+    getDeclaration(): FunctionDeclaration;
+    /**
+     * Execute the memory loading action
+     */
+    runAsync(args: {
+        query: string;
+    }, context: ToolContext): Promise<LoadMemoryResult>;
+}
+
+/**
+ * Tool that allows an agent to transfer control to another agent
+ */
+declare class TransferToAgentTool extends BaseTool {
+    protected logger: Logger;
+    /**
+     * Constructor for TransferToAgentTool
+     */
+    constructor();
+    /**
+     * Get the function declaration for the tool
+     */
+    getDeclaration(): FunctionDeclaration;
+    /**
+     * Execute the transfer to agent action
+     */
+    runAsync(args: {
+        agent_name: string;
+    }, context: ToolContext): Promise<void>;
+}
+
+interface UserInteractionResult {
+    success: boolean;
+    userInput?: string;
+    error?: string;
+}
+/**
+ * Tool for prompting the user for input
+ */
+declare class UserInteractionTool extends BaseTool {
+    constructor();
+    /**
+     * Get the function declaration for the tool
+     */
+    getDeclaration(): FunctionDeclaration;
+    /**
+     * Execute the user interaction
+     */
+    runAsync(args: {
+        prompt: string;
+        options?: string[];
+        defaultValue?: string;
+    }, context: ToolContext): Promise<UserInteractionResult>;
+}
+
+interface BashToolResult {
+    exit_code: number | null;
+    stdout: string;
+    stderr: string;
+    blocked?: boolean;
+    reason?: string;
+}
+interface BashToolConfig {
+    enabled: boolean;
+    mode: "disabled" | "whitelist" | "sandboxed" | "unrestricted";
+    dockerImage?: string;
+    allowedCommands?: string[];
+    maxTimeout?: number;
+    requireConfirmation?: boolean;
+    enableLogging?: boolean;
+}
+declare class BashTool extends BaseTool {
+    private config;
+    private commandLog;
+    private static readonly DEFAULT_WHITELIST;
+    private static readonly DANGEROUS_PATTERNS;
+    private static readonly DANGEROUS_CHARS;
+    constructor(config?: Partial<BashToolConfig>);
+    getDeclaration(): FunctionDeclaration;
+    runAsync(args: {
+        command: string;
+    }, _context: ToolContext): Promise<BashToolResult>;
+    private validateCommand;
+    private validateWhitelist;
+    private executeDirect;
+    private executeSandboxed;
+    private logCommand;
+    getCommandHistory(): typeof this.commandLog;
+    clearCommandHistory(): void;
+}
+
+interface EditToolResult {
+    success: boolean;
+    data?: string;
+    error?: string;
+}
+declare class EditTool extends BaseTool {
+    constructor();
+    getDeclaration(): FunctionDeclaration;
+    runAsync(args: {
+        path: string;
+        old_str: string;
+        new_str: string;
+    }, _context: ToolContext): Promise<EditToolResult>;
+}
+
+interface GlobToolResult {
+    success: boolean;
+    data?: string[];
+    error?: string;
+}
+declare class GlobTool extends BaseTool {
+    constructor();
+    getDeclaration(): FunctionDeclaration;
+    runAsync(args: {
+        pattern: string;
+    }, _context: ToolContext): Promise<GlobToolResult>;
+}
+
+declare class GrepTool extends BaseTool {
+    private readonly config;
+    constructor(config?: Partial<GrepConfig>);
+    getDeclaration(): FunctionDeclaration;
+    runAsync(args: {
+        pattern: string;
+        files: string;
+        caseInsensitive?: boolean;
+        contextLines?: number;
+        maxMatches?: number;
+        wholeWord?: boolean;
+        invertMatch?: boolean;
+        exclude?: string;
+        include?: string;
+    }, _context: ToolContext): Promise<GrepResult>;
+    private validateAndSanitizeArgs;
+    private buildRegex;
+    private resolveFiles;
+    private walkDir;
+    private searchFiles;
+    private searchFile;
+}
+interface GrepConfig {
+    maxMatches: number;
+    maxFileSize: number;
+    contextLines: number;
+    excludePatterns: string[];
+    includePatterns: string[];
+}
+interface GrepMatch {
+    file: string;
+    line: number;
+    column: number;
+    content: string;
+    context?: {
+        before: string[];
+        after: string[];
+    };
+}
+interface GrepResult {
+    success: boolean;
+    matches: GrepMatch[];
+    stats: {
+        filesSearched: number;
+        filesMatched: number;
+        totalMatches: number;
+        limitReached: boolean;
+        duration: number;
+    };
+    error?: string;
+    warnings?: string[];
+}
+
+interface ReadToolResult {
+    success: boolean;
+    data?: string;
+    error?: string;
+}
+declare class ReadTool extends BaseTool {
     constructor();
-    /**
-     * Get the function declaration for the tool
-     */
     getDeclaration(): FunctionDeclaration;
-    /**
-     * Execute the memory loading action
-     */
     runAsync(args: {
-        query: string;
-    }, context: ToolContext): Promise<any>;
+        path: string;
+    }, _context: ToolContext): Promise<ReadToolResult>;
 }
 
-/**
- * Tool that allows an agent to transfer control to another agent
- */
-declare class TransferToAgentTool extends BaseTool {
-    protected logger: Logger;
-    /**
-     * Constructor for TransferToAgentTool
-     */
+interface WebFetchToolResult {
+    success: boolean;
+    data?: {
+        title: string;
+        content: string;
+        metadata: {
+            contentType: string;
+            url: string;
+        };
+    };
+    error?: string;
+}
+declare class WebFetchTool extends BaseTool {
     constructor();
-    /**
-     * Get the function declaration for the tool
-     */
     getDeclaration(): FunctionDeclaration;
-    /**
-     * Execute the transfer to agent action
-     */
     runAsync(args: {
-        agent_name: string;
-    }, context: ToolContext): Promise<any>;
+        url: string;
+    }, _context: ToolContext): Promise<WebFetchToolResult>;
 }
 
-interface UserInteractionResult {
+interface WebSearchToolResult {
     success: boolean;
-    userInput?: string;
+    data?: z$1.infer<typeof tavilySearchResponseSchema>;
+    error?: string | z$1.ZodError;
+    details?: any;
+}
+declare class WebSearchTool extends BaseTool {
+    constructor();
+    getDeclaration(): FunctionDeclaration;
+    runAsync(_rawArgs: unknown, _context: ToolContext): Promise<WebSearchToolResult>;
+}
+declare const tavilySearchResponseSchema: z$1.ZodObject<{
+    query: z$1.ZodString;
+    results: z$1.ZodArray<z$1.ZodObject<{
+        title: z$1.ZodString;
+        url: z$1.ZodString;
+        content: z$1.ZodString;
+        raw_content: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+        favicon: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+        score: z$1.ZodOptional<z$1.ZodNumber>;
+    }, z$1.core.$strip>>;
+    answer: z$1.ZodOptional<z$1.ZodString>;
+    images: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
+        url: z$1.ZodString;
+        description: z$1.ZodOptional<z$1.ZodString>;
+    }, z$1.core.$strip>>>;
+    auto_parameters: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodAny, z$1.ZodString>>;
+    response_time: z$1.ZodNumber;
+    usage: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodAny, z$1.ZodString>>;
+    request_id: z$1.ZodOptional<z$1.ZodString>;
+}, z$1.core.$strip>;
+
+interface WriteToolResult {
+    success: boolean;
+    data?: string;
     error?: string;
 }
-/**
- * Tool for prompting the user for input
- */
-declare class UserInteractionTool extends BaseTool {
+declare class WriteTool extends BaseTool {
     constructor();
-    /**
-     * Get the function declaration for the tool
-     */
     getDeclaration(): FunctionDeclaration;
-    /**
-     * Execute the user interaction
-     */
     runAsync(args: {
-        prompt: string;
-        options?: string[];
-        defaultValue?: string;
-    }, context: ToolContext): Promise<UserInteractionResult>;
+        path: string;
+        content: string;
+    }, _context: ToolContext): Promise<WriteToolResult>;
 }
 
 /**
@@ -3059,82 +2988,98 @@ declare function getMcpTools(config: McpConfig, toolFilter?: string[] | ((tool:
  * Tools module exports
  */
 
-type index$6_AgentTool = AgentTool;
-declare const index$6_AgentTool: typeof AgentTool;
-type index$6_AgentToolConfig = AgentToolConfig;
-type index$6_BaseAgentType = BaseAgentType;
-type index$6_BaseTool = BaseTool;
-declare const index$6_BaseTool: typeof BaseTool;
-type index$6_BuildFunctionDeclarationOptions = BuildFunctionDeclarationOptions;
-type index$6_CreateToolConfig<T extends Record<string, any> = Record<string, never>> = CreateToolConfig<T>;
-type index$6_CreateToolConfigWithSchema<T extends Record<string, any>> = CreateToolConfigWithSchema<T>;
-type index$6_CreateToolConfigWithoutSchema = CreateToolConfigWithoutSchema;
-type index$6_ExitLoopTool = ExitLoopTool;
-declare const index$6_ExitLoopTool: typeof ExitLoopTool;
-type index$6_FileOperationsTool = FileOperationsTool;
-declare const index$6_FileOperationsTool: typeof FileOperationsTool;
-type index$6_FunctionTool<T extends Record<string, any>> = FunctionTool<T>;
-declare const index$6_FunctionTool: typeof FunctionTool;
-type index$6_GetUserChoiceTool = GetUserChoiceTool;
-declare const index$6_GetUserChoiceTool: typeof GetUserChoiceTool;
-type index$6_GoogleSearch = GoogleSearch;
-declare const index$6_GoogleSearch: typeof GoogleSearch;
-type index$6_HttpRequestTool = HttpRequestTool;
-declare const index$6_HttpRequestTool: typeof HttpRequestTool;
-type index$6_LoadArtifactsTool = LoadArtifactsTool;
-declare const index$6_LoadArtifactsTool: typeof LoadArtifactsTool;
-type index$6_LoadMemoryTool = LoadMemoryTool;
-declare const index$6_LoadMemoryTool: typeof LoadMemoryTool;
-declare const index$6_McpAbi: typeof McpAbi;
-declare const index$6_McpAtp: typeof McpAtp;
-declare const index$6_McpBamm: typeof McpBamm;
-declare const index$6_McpCoinGecko: typeof McpCoinGecko;
-declare const index$6_McpCoinGeckoPro: typeof McpCoinGeckoPro;
-type index$6_McpConfig = McpConfig;
-declare const index$6_McpDiscord: typeof McpDiscord;
-type index$6_McpError = McpError;
-declare const index$6_McpError: typeof McpError;
-type index$6_McpErrorType = McpErrorType;
-declare const index$6_McpErrorType: typeof McpErrorType;
-declare const index$6_McpFilesystem: typeof McpFilesystem;
-declare const index$6_McpFraxlend: typeof McpFraxlend;
-declare const index$6_McpGeneric: typeof McpGeneric;
-declare const index$6_McpIqWiki: typeof McpIqWiki;
-declare const index$6_McpMemory: typeof McpMemory;
-declare const index$6_McpNearAgent: typeof McpNearAgent;
-declare const index$6_McpNearIntents: typeof McpNearIntents;
-declare const index$6_McpOdos: typeof McpOdos;
-declare const index$6_McpPolymarket: typeof McpPolymarket;
-type index$6_McpSamplingHandler = McpSamplingHandler;
-declare const index$6_McpSamplingHandler: typeof McpSamplingHandler;
-type index$6_McpSamplingRequest = McpSamplingRequest;
-type index$6_McpSamplingResponse = McpSamplingResponse;
-type index$6_McpServerConfig = McpServerConfig;
-declare const index$6_McpTelegram: typeof McpTelegram;
-type index$6_McpToolset = McpToolset;
-declare const index$6_McpToolset: typeof McpToolset;
-type index$6_McpTransportType = McpTransportType;
-declare const index$6_McpUpbit: typeof McpUpbit;
-type index$6_SamplingHandler = SamplingHandler;
-type index$6_ToolConfig = ToolConfig;
-type index$6_ToolContext = ToolContext;
-declare const index$6_ToolContext: typeof ToolContext;
-type index$6_TransferToAgentTool = TransferToAgentTool;
-declare const index$6_TransferToAgentTool: typeof TransferToAgentTool;
-type index$6_UserInteractionTool = UserInteractionTool;
-declare const index$6_UserInteractionTool: typeof UserInteractionTool;
-declare const index$6_adkToMcpToolType: typeof adkToMcpToolType;
-declare const index$6_buildFunctionDeclaration: typeof buildFunctionDeclaration;
-declare const index$6_convertMcpToolToBaseTool: typeof convertMcpToolToBaseTool;
-declare const index$6_createFunctionTool: typeof createFunctionTool;
-declare const index$6_createSamplingHandler: typeof createSamplingHandler;
-declare const index$6_createTool: typeof createTool;
-declare const index$6_getMcpTools: typeof getMcpTools;
-declare const index$6_jsonSchemaToDeclaration: typeof jsonSchemaToDeclaration;
-declare const index$6_mcpSchemaToParameters: typeof mcpSchemaToParameters;
-declare const index$6_normalizeJsonSchema: typeof normalizeJsonSchema;
-declare namespace index$6 {
-  export { index$6_AgentTool as AgentTool, type index$6_AgentToolConfig as AgentToolConfig, type index$6_BaseAgentType as BaseAgentType, index$6_BaseTool as BaseTool, type index$6_BuildFunctionDeclarationOptions as BuildFunctionDeclarationOptions, type index$6_CreateToolConfig as CreateToolConfig, type index$6_CreateToolConfigWithSchema as CreateToolConfigWithSchema, type index$6_CreateToolConfigWithoutSchema as CreateToolConfigWithoutSchema, index$6_ExitLoopTool as ExitLoopTool, index$6_FileOperationsTool as FileOperationsTool, index$6_FunctionTool as FunctionTool, index$6_GetUserChoiceTool as GetUserChoiceTool, index$6_GoogleSearch as GoogleSearch, index$6_HttpRequestTool as HttpRequestTool, index$6_LoadArtifactsTool as LoadArtifactsTool, index$6_LoadMemoryTool as LoadMemoryTool, index$6_McpAbi as McpAbi, index$6_McpAtp as McpAtp, index$6_McpBamm as McpBamm, index$6_McpCoinGecko as McpCoinGecko, index$6_McpCoinGeckoPro as McpCoinGeckoPro, type index$6_McpConfig as McpConfig, index$6_McpDiscord as McpDiscord, index$6_McpError as McpError, index$6_McpErrorType as McpErrorType, index$6_McpFilesystem as McpFilesystem, index$6_McpFraxlend as McpFraxlend, index$6_McpGeneric as McpGeneric, index$6_McpIqWiki as McpIqWiki, index$6_McpMemory as McpMemory, index$6_McpNearAgent as McpNearAgent, index$6_McpNearIntents as McpNearIntents, index$6_McpOdos as McpOdos, index$6_McpPolymarket as McpPolymarket, index$6_McpSamplingHandler as McpSamplingHandler, type index$6_McpSamplingRequest as McpSamplingRequest, type index$6_McpSamplingResponse as McpSamplingResponse, type index$6_McpServerConfig as McpServerConfig, index$6_McpTelegram as McpTelegram, index$6_McpToolset as McpToolset, type index$6_McpTransportType as McpTransportType, index$6_McpUpbit as McpUpbit, type index$6_SamplingHandler as SamplingHandler, type index$6_ToolConfig as ToolConfig, index$6_ToolContext as ToolContext, index$6_TransferToAgentTool as TransferToAgentTool, index$6_UserInteractionTool as UserInteractionTool, index$6_adkToMcpToolType as adkToMcpToolType, index$6_buildFunctionDeclaration as buildFunctionDeclaration, index$6_convertMcpToolToBaseTool as convertMcpToolToBaseTool, index$6_createFunctionTool as createFunctionTool, index$6_createSamplingHandler as createSamplingHandler, index$6_createTool as createTool, index$6_getMcpTools as getMcpTools, index$6_jsonSchemaToDeclaration as jsonSchemaToDeclaration, index$6_mcpSchemaToParameters as mcpSchemaToParameters, index$6_normalizeJsonSchema as normalizeJsonSchema };
+type index$8_AgentTool = AgentTool;
+declare const index$8_AgentTool: typeof AgentTool;
+type index$8_AgentToolConfig = AgentToolConfig;
+type index$8_BaseAgentType = BaseAgentType;
+type index$8_BaseTool = BaseTool;
+declare const index$8_BaseTool: typeof BaseTool;
+type index$8_BashTool = BashTool;
+declare const index$8_BashTool: typeof BashTool;
+type index$8_BuildFunctionDeclarationOptions = BuildFunctionDeclarationOptions;
+type index$8_CreateToolConfig<T extends Record<string, any> = Record<string, never>> = CreateToolConfig<T>;
+type index$8_CreateToolConfigWithSchema<T extends Record<string, any>> = CreateToolConfigWithSchema<T>;
+type index$8_CreateToolConfigWithoutSchema = CreateToolConfigWithoutSchema;
+type index$8_EditTool = EditTool;
+declare const index$8_EditTool: typeof EditTool;
+type index$8_ExitLoopTool = ExitLoopTool;
+declare const index$8_ExitLoopTool: typeof ExitLoopTool;
+type index$8_FileOperationsTool = FileOperationsTool;
+declare const index$8_FileOperationsTool: typeof FileOperationsTool;
+type index$8_FunctionTool<T extends Record<string, any>> = FunctionTool<T>;
+declare const index$8_FunctionTool: typeof FunctionTool;
+type index$8_GetUserChoiceTool = GetUserChoiceTool;
+declare const index$8_GetUserChoiceTool: typeof GetUserChoiceTool;
+type index$8_GlobTool = GlobTool;
+declare const index$8_GlobTool: typeof GlobTool;
+type index$8_GoogleSearchTool = GoogleSearchTool;
+declare const index$8_GoogleSearchTool: typeof GoogleSearchTool;
+type index$8_GrepTool = GrepTool;
+declare const index$8_GrepTool: typeof GrepTool;
+type index$8_HttpRequestTool = HttpRequestTool;
+declare const index$8_HttpRequestTool: typeof HttpRequestTool;
+type index$8_LoadArtifactsTool = LoadArtifactsTool;
+declare const index$8_LoadArtifactsTool: typeof LoadArtifactsTool;
+type index$8_LoadMemoryTool = LoadMemoryTool;
+declare const index$8_LoadMemoryTool: typeof LoadMemoryTool;
+declare const index$8_McpAbi: typeof McpAbi;
+declare const index$8_McpAtp: typeof McpAtp;
+declare const index$8_McpBamm: typeof McpBamm;
+declare const index$8_McpCoinGecko: typeof McpCoinGecko;
+declare const index$8_McpCoinGeckoPro: typeof McpCoinGeckoPro;
+type index$8_McpConfig = McpConfig;
+declare const index$8_McpDiscord: typeof McpDiscord;
+type index$8_McpError = McpError;
+declare const index$8_McpError: typeof McpError;
+type index$8_McpErrorType = McpErrorType;
+declare const index$8_McpErrorType: typeof McpErrorType;
+declare const index$8_McpFilesystem: typeof McpFilesystem;
+declare const index$8_McpFraxlend: typeof McpFraxlend;
+declare const index$8_McpGeneric: typeof McpGeneric;
+declare const index$8_McpIqWiki: typeof McpIqWiki;
+declare const index$8_McpMemory: typeof McpMemory;
+declare const index$8_McpNearAgent: typeof McpNearAgent;
+declare const index$8_McpNearIntents: typeof McpNearIntents;
+declare const index$8_McpOdos: typeof McpOdos;
+declare const index$8_McpPolymarket: typeof McpPolymarket;
+type index$8_McpSamplingHandler = McpSamplingHandler;
+declare const index$8_McpSamplingHandler: typeof McpSamplingHandler;
+type index$8_McpSamplingRequest = McpSamplingRequest;
+type index$8_McpSamplingResponse = McpSamplingResponse;
+type index$8_McpServerConfig = McpServerConfig;
+declare const index$8_McpTelegram: typeof McpTelegram;
+type index$8_McpToolset = McpToolset;
+declare const index$8_McpToolset: typeof McpToolset;
+type index$8_McpTransportType = McpTransportType;
+declare const index$8_McpUpbit: typeof McpUpbit;
+type index$8_ReadTool = ReadTool;
+declare const index$8_ReadTool: typeof ReadTool;
+type index$8_SamplingHandler = SamplingHandler;
+type index$8_ToolConfig = ToolConfig;
+type index$8_ToolContext = ToolContext;
+declare const index$8_ToolContext: typeof ToolContext;
+type index$8_TransferToAgentTool = TransferToAgentTool;
+declare const index$8_TransferToAgentTool: typeof TransferToAgentTool;
+type index$8_UserInteractionTool = UserInteractionTool;
+declare const index$8_UserInteractionTool: typeof UserInteractionTool;
+type index$8_WebFetchTool = WebFetchTool;
+declare const index$8_WebFetchTool: typeof WebFetchTool;
+type index$8_WebSearchTool = WebSearchTool;
+declare const index$8_WebSearchTool: typeof WebSearchTool;
+type index$8_WriteTool = WriteTool;
+declare const index$8_WriteTool: typeof WriteTool;
+declare const index$8_adkToMcpToolType: typeof adkToMcpToolType;
+declare const index$8_buildFunctionDeclaration: typeof buildFunctionDeclaration;
+declare const index$8_convertMcpToolToBaseTool: typeof convertMcpToolToBaseTool;
+declare const index$8_createFunctionTool: typeof createFunctionTool;
+declare const index$8_createSamplingHandler: typeof createSamplingHandler;
+declare const index$8_createTool: typeof createTool;
+declare const index$8_getMcpTools: typeof getMcpTools;
+declare const index$8_jsonSchemaToDeclaration: typeof jsonSchemaToDeclaration;
+declare const index$8_mcpSchemaToParameters: typeof mcpSchemaToParameters;
+declare const index$8_normalizeJsonSchema: typeof normalizeJsonSchema;
+declare namespace index$8 {
+  export { index$8_AgentTool as AgentTool, type index$8_AgentToolConfig as AgentToolConfig, type index$8_BaseAgentType as BaseAgentType, index$8_BaseTool as BaseTool, index$8_BashTool as BashTool, type index$8_BuildFunctionDeclarationOptions as BuildFunctionDeclarationOptions, type index$8_CreateToolConfig as CreateToolConfig, type index$8_CreateToolConfigWithSchema as CreateToolConfigWithSchema, type index$8_CreateToolConfigWithoutSchema as CreateToolConfigWithoutSchema, index$8_EditTool as EditTool, index$8_ExitLoopTool as ExitLoopTool, index$8_FileOperationsTool as FileOperationsTool, index$8_FunctionTool as FunctionTool, index$8_GetUserChoiceTool as GetUserChoiceTool, index$8_GlobTool as GlobTool, index$8_GoogleSearchTool as GoogleSearchTool, index$8_GrepTool as GrepTool, index$8_HttpRequestTool as HttpRequestTool, index$8_LoadArtifactsTool as LoadArtifactsTool, index$8_LoadMemoryTool as LoadMemoryTool, index$8_McpAbi as McpAbi, index$8_McpAtp as McpAtp, index$8_McpBamm as McpBamm, index$8_McpCoinGecko as McpCoinGecko, index$8_McpCoinGeckoPro as McpCoinGeckoPro, type index$8_McpConfig as McpConfig, index$8_McpDiscord as McpDiscord, index$8_McpError as McpError, index$8_McpErrorType as McpErrorType, index$8_McpFilesystem as McpFilesystem, index$8_McpFraxlend as McpFraxlend, index$8_McpGeneric as McpGeneric, index$8_McpIqWiki as McpIqWiki, index$8_McpMemory as McpMemory, index$8_McpNearAgent as McpNearAgent, index$8_McpNearIntents as McpNearIntents, index$8_McpOdos as McpOdos, index$8_McpPolymarket as McpPolymarket, index$8_McpSamplingHandler as McpSamplingHandler, type index$8_McpSamplingRequest as McpSamplingRequest, type index$8_McpSamplingResponse as McpSamplingResponse, type index$8_McpServerConfig as McpServerConfig, index$8_McpTelegram as McpTelegram, index$8_McpToolset as McpToolset, type index$8_McpTransportType as McpTransportType, index$8_McpUpbit as McpUpbit, index$8_ReadTool as ReadTool, type index$8_SamplingHandler as SamplingHandler, type index$8_ToolConfig as ToolConfig, index$8_ToolContext as ToolContext, index$8_TransferToAgentTool as TransferToAgentTool, index$8_UserInteractionTool as UserInteractionTool, index$8_WebFetchTool as WebFetchTool, index$8_WebSearchTool as WebSearchTool, index$8_WriteTool as WriteTool, index$8_adkToMcpToolType as adkToMcpToolType, index$8_buildFunctionDeclaration as buildFunctionDeclaration, index$8_convertMcpToolToBaseTool as convertMcpToolToBaseTool, index$8_createFunctionTool as createFunctionTool, index$8_createSamplingHandler as createSamplingHandler, index$8_createTool as createTool, index$8_getMcpTools as getMcpTools, index$8_jsonSchemaToDeclaration as jsonSchemaToDeclaration, index$8_mcpSchemaToParameters as mcpSchemaToParameters, index$8_normalizeJsonSchema as normalizeJsonSchema };
 }
 
 /**
@@ -3161,6 +3106,18 @@ declare class LlmRequest {
      * Tools in generate_content_config should not be set.
      */
     config?: GenerateContentConfig;
+    /**
+     * Context cache config for the request.
+     */
+    cacheConfig?: ContextCacheConfig;
+    /**
+     * Cache metadata from previous requests, used for cache management.
+     */
+    cacheMetadata?: CacheMetadata;
+    /**
+     * Token count from previous request's prompt, used for cache size validation.
+     */
+    cacheableContentsTokenCount?: number;
     /**
      * Live connect config for the request.
      */
@@ -3175,6 +3132,9 @@ declare class LlmRequest {
         config?: GenerateContentConfig;
         liveConnectConfig?: LiveConnectConfig;
         toolsDict?: Record<string, BaseTool>;
+        cacheConfig?: ContextCacheConfig;
+        cacheMetadata?: CacheMetadata;
+        cacheableContentsTokenCount?: number;
     });
     /**
      * Appends instructions to the system instruction.
@@ -3187,869 +3147,1260 @@ declare class LlmRequest {
      */
     appendTools(tools: BaseTool[]): void;
     /**
-     * Sets the output schema for the request.
-     * @param baseModel The base model to set as the output schema.
+     * Sets the output schema for the request.
+     * @param baseModel The base model to set as the output schema.
+     */
+    setOutputSchema(baseModel: any): void;
+    /**
+     * Extracts the system instruction as plain text from Content or string.
+     * System instructions can be either string or Content type.
+     * @returns The system instruction as a string, or undefined if not set.
+     */
+    getSystemInstructionText(): string | undefined;
+    /**
+     * Extracts text content from a Content object.
+     * Used for extracting text from message contents.
+     * @param content The Content object to extract text from.
+     * @returns The extracted text as a string.
+     */
+    static extractTextFromContent(content: any): string;
+}
+
+/**
+ * The BaseLlm class.
+ */
+declare abstract class BaseLlm {
+    /**
+     * The name of the LLM, e.g. gemini-2.5-flash or gemini-2.5-flash-001.
+     */
+    model: string;
+    protected logger: Logger;
+    /**
+     * Constructor for BaseLlm
+     */
+    constructor(model: string);
+    /**
+     * Returns a list of supported models in regex for LLMRegistry
+     */
+    static supportedModels(): string[];
+    /**
+     * Generates one content from the given contents and tools.
+     *
+     * @param llmRequest LlmRequest, the request to send to the LLM.
+     * @param stream bool = false, whether to do streaming call.
+     * @returns a generator of LlmResponse.
+     *
+     * For non-streaming call, it will only yield one LlmResponse.
+     *
+     * For streaming call, it may yield more than one response, but all yielded
+     * responses should be treated as one response by merging the
+     * parts list.
+     */
+    generateContentAsync(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
+    /**
+     * Implementation method to be overridden by subclasses.
+     * This replaces the abstract generateContentAsync method.
+     */
+    protected abstract generateContentAsyncImpl(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
+    /**
+     * Appends a user content, so that model can continue to output.
+     *
+     * @param llmRequest LlmRequest, the request to send to the LLM.
+     */
+    protected maybeAppendUserContent(llmRequest: LlmRequest): void;
+    /**
+     * Creates a live connection to the LLM.
+     *
+     * @param llmRequest LlmRequest, the request to send to the LLM.
+     * @returns BaseLLMConnection, the connection to the LLM.
+     */
+    connect(_llmRequest: LlmRequest): BaseLLMConnection;
+}
+
+/**
+ * LLM-based event summarizer that uses a language model to generate summaries.
+ */
+declare class LlmEventSummarizer implements EventsSummarizer {
+    private model;
+    private prompt;
+    /**
+     * Creates a new LLM event summarizer.
+     * @param model - The LLM model to use for summarization
+     * @param prompt - Optional custom prompt template. Use {events} as placeholder for event content.
+     */
+    constructor(model: BaseLlm, prompt?: string);
+    /**
+     * Summarizes events using the configured LLM.
+     */
+    maybeSummarizeEvents(events: Event[]): Promise<Event | undefined>;
+    /**
+     * Formats events into a readable text format for summarization.
+     */
+    private formatEventsForSummarization;
+}
+
+type index$7_Event = Event;
+declare const index$7_Event: typeof Event;
+type index$7_EventActions = EventActions;
+declare const index$7_EventActions: typeof EventActions;
+type index$7_EventCompaction = EventCompaction;
+type index$7_EventsCompactionConfig = EventsCompactionConfig;
+type index$7_EventsSummarizer = EventsSummarizer;
+type index$7_LlmEventSummarizer = LlmEventSummarizer;
+declare const index$7_LlmEventSummarizer: typeof LlmEventSummarizer;
+declare const index$7_runCompactionForSlidingWindow: typeof runCompactionForSlidingWindow;
+declare namespace index$7 {
+  export { index$7_Event as Event, index$7_EventActions as EventActions, type index$7_EventCompaction as EventCompaction, type index$7_EventsCompactionConfig as EventsCompactionConfig, type index$7_EventsSummarizer as EventsSummarizer, index$7_LlmEventSummarizer as LlmEventSummarizer, index$7_runCompactionForSlidingWindow as runCompactionForSlidingWindow };
+}
+
+declare const pluginCallbackNameSchema: z$1.ZodEnum<{
+    onUserMessageCallback: "onUserMessageCallback";
+    beforeRunCallback: "beforeRunCallback";
+    afterRunCallback: "afterRunCallback";
+    onEventCallback: "onEventCallback";
+    beforeAgentCallback: "beforeAgentCallback";
+    afterAgentCallback: "afterAgentCallback";
+    beforeToolCallback: "beforeToolCallback";
+    afterToolCallback: "afterToolCallback";
+    beforeModelCallback: "beforeModelCallback";
+    afterModelCallback: "afterModelCallback";
+    onToolErrorCallback: "onToolErrorCallback";
+    onModelErrorCallback: "onModelErrorCallback";
+}>;
+type PluginCallbackName = z$1.infer<typeof pluginCallbackNameSchema>;
+declare class PluginManager {
+    readonly plugins: BasePlugin[];
+    private readonly closeTimeout;
+    constructor(opts?: {
+        plugins?: BasePlugin[];
+        closeTimeout?: number;
+    });
+    /** Register a plugin (unique names) */
+    registerPlugin(plugin: BasePlugin): void;
+    getPlugin(name: string): BasePlugin | undefined;
+    getPlugins(): BasePlugin[];
+    runOnUserMessageCallback(params: {
+        userMessage: Content;
+        invocationContext: InvocationContext;
+    }): Promise<any>;
+    runBeforeRunCallback(params: {
+        invocationContext: InvocationContext;
+    }): Promise<any>;
+    runAfterRunCallback(params: {
+        invocationContext: InvocationContext;
+    }): Promise<any>;
+    runOnEventCallback(params: {
+        invocationContext: InvocationContext;
+        event: Event;
+    }): Promise<any>;
+    runBeforeAgentCallback(params: {
+        agent: BaseAgent;
+        callbackContext: CallbackContext;
+    }): Promise<any>;
+    runAfterAgentCallback(params: {
+        agent: BaseAgent;
+        callbackContext: CallbackContext;
+    }): Promise<any>;
+    runBeforeToolCallback(params: {
+        tool: BaseTool;
+        toolArgs: Record<string, any>;
+        toolContext: ToolContext;
+    }): Promise<any>;
+    runAfterToolCallback(params: {
+        tool: BaseTool;
+        toolArgs: Record<string, any>;
+        toolContext: ToolContext;
+        result: Record<string, any>;
+    }): Promise<any>;
+    runBeforeModelCallback(params: {
+        callbackContext: CallbackContext;
+        llmRequest: LlmRequest;
+    }): Promise<any>;
+    runAfterModelCallback(params: {
+        callbackContext: CallbackContext;
+        llmResponse: LlmResponse;
+    }): Promise<any>;
+    runOnToolErrorCallback(params: {
+        tool: BaseTool;
+        toolArgs: Record<string, any>;
+        toolContext: ToolContext;
+        error: Error;
+    }): Promise<any>;
+    runOnModelErrorCallback(params: {
+        callbackContext: CallbackContext;
+        llmRequest: LlmRequest;
+        error: Error;
+    }): Promise<any>;
+    private runCallbacks;
+    close(): Promise<void>;
+}
+
+/**
+ * Request send to live agents.
+ */
+declare class LiveRequest {
+    /**
+     * If set, send the content to the model in turn-by-turn mode.
      */
-    setOutputSchema(baseModel: any): void;
+    content?: Content;
     /**
-     * Extracts the system instruction as plain text from Content or string.
-     * System instructions can be either string or Content type.
-     * @returns The system instruction as a string, or undefined if not set.
+     * If set, send the blob to the model in realtime mode.
      */
-    getSystemInstructionText(): string | undefined;
+    blob?: Blob;
     /**
-     * Extracts text content from a Content object.
-     * Used for extracting text from message contents.
-     * @param content The Content object to extract text from.
-     * @returns The extracted text as a string.
+     * If set, close the queue.
      */
-    static extractTextFromContent(content: any): string;
+    close: boolean;
+    constructor(options?: {
+        content?: Content;
+        blob?: Blob;
+        close?: boolean;
+    });
 }
-
 /**
- * AI SDK integration that accepts a pre-configured LanguageModel.
- * Enables ADK to work with any provider supported by Vercel's AI SDK.
+ * Queue used to send LiveRequest in a live(bidirectional streaming) way.
  */
-declare class AiSdkLlm extends BaseLlm {
-    private modelInstance;
-    protected logger: Logger;
-    /**
-     * Constructor accepts a pre-configured LanguageModel instance
-     * @param model - Pre-configured LanguageModel from provider(modelName)
-     */
-    constructor(modelInstance: LanguageModel);
+declare class LiveRequestQueue {
+    private _queue;
+    private _waiters;
+    private _closed;
     /**
-     * Returns empty array - following Python ADK pattern
+     * Close the queue.
      */
-    static supportedModels(): string[];
-    protected generateContentAsyncImpl(request: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
+    close(): void;
     /**
-     * Convert ADK LlmRequest to AI SDK CoreMessage format
+     * Send content to the queue.
      */
-    private convertToAiSdkMessages;
+    sendContent(content: Content): void;
     /**
-     * Transform JSON schema to use lowercase types for AI SDK compatibility
+     * Send realtime blob to the queue.
      */
-    private transformSchemaForAiSdk;
+    sendRealtime(blob: Blob): void;
     /**
-     * Convert ADK tools to AI SDK tools format
+     * Send a LiveRequest to the queue.
      */
-    private convertToAiSdkTools;
+    send(req: LiveRequest): void;
     /**
-     * Convert ADK Content to AI SDK CoreMessage
+     * Get the next LiveRequest from the queue.
      */
-    private contentToAiSdkMessage;
+    get(): Promise<LiveRequest>;
+}
+
+/**
+ * Manages streaming tool related resources during invocation.
+ */
+declare class ActiveStreamingTool {
     /**
-     * Map ADK role to AI SDK role
+     * The active task of this streaming tool.
      */
-    private mapRole;
+    task?: Promise<any>;
     /**
-     * Map AI SDK finish reason to ADK finish reason
+     * The active (input) streams of this streaming tool.
      */
-    private mapFinishReason;
+    stream?: LiveRequestQueue;
+    constructor(options?: {
+        task?: Promise<any>;
+        stream?: LiveRequestQueue;
+    });
 }
 
 /**
- * Anthropic LLM implementation using Claude models
+ * Streaming mode options for agent execution
  */
-declare class AnthropicLlm extends BaseLlm {
-    private _client?;
-    protected logger: Logger;
+declare enum StreamingMode {
+    NONE = "NONE",
+    SSE = "sse",
+    BIDI = "bidi"
+}
+/**
+ * Configs for runtime behavior of agents
+ */
+declare class RunConfig {
     /**
-     * Constructor for Anthropic LLM
+     * Speech configuration for the live agent
      */
-    constructor(model?: string);
+    speechConfig?: SpeechConfig;
     /**
-     * Provides the list of supported models
+     * The output modalities. If not set, it's default to AUDIO.
      */
-    static supportedModels(): string[];
+    responseModalities?: string[];
     /**
-     * Main content generation method - handles both streaming and non-streaming
+     * Whether or not to save the input blobs as artifacts.
      */
-    protected generateContentAsyncImpl(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
+    saveInputBlobsAsArtifacts: boolean;
     /**
-     * Live connection is not supported for Anthropic models
+     * Whether to support CFC (Compositional Function Calling). Only applicable for
+     * StreamingMode.SSE. If it's true. the LIVE API will be invoked. Since only LIVE
+     * API supports CFC
+     *
+     * @warning This feature is **experimental** and its API or behavior may change
+     * in future releases.
      */
-    connect(_llmRequest: LlmRequest): BaseLLMConnection;
+    supportCFC: boolean;
     /**
-     * Convert Anthropic Message to ADK LlmResponse
+     * Streaming mode, None or StreamingMode.SSE or StreamingMode.BIDI.
      */
-    private anthropicMessageToLlmResponse;
+    streamingMode: StreamingMode;
     /**
-     * Convert ADK Content to Anthropic MessageParam
+     * Output transcription for live agents with audio response.
      */
-    private contentToAnthropicMessage;
+    outputAudioTranscription?: AudioTranscriptionConfig;
     /**
-     * Convert ADK Part to Anthropic content block
+     * Input transcription for live agents with audio input from user.
      */
-    private partToAnthropicBlock;
+    inputAudioTranscription?: AudioTranscriptionConfig;
     /**
-     * Convert Anthropic content block to ADK Part
+     * Realtime input config for live agents with audio input from user.
      */
-    private anthropicBlockToPart;
+    realtimeInputConfig?: RealtimeInputConfig;
     /**
-     * Convert ADK function declaration to Anthropic tool param
+     * If enabled, the model will detect emotions and adapt its responses accordingly.
      */
-    private functionDeclarationToAnthropicTool;
+    enableAffectiveDialog?: boolean;
     /**
-     * Convert ADK role to Anthropic role format
+     * Configures the proactivity of the model. This allows the model to respond
+     * proactively to the input and to ignore irrelevant input.
      */
-    private toAnthropicRole;
+    proactivity?: ProactivityConfig;
     /**
-     * Convert Anthropic stop reason to ADK finish reason
+     * A limit on the total number of llm calls for a given run.
+     *
+     * Valid Values:
+     *   - More than 0 and less than Number.MAX_SAFE_INTEGER: The bound on the number of llm
+     *     calls is enforced, if the value is set in this range.
+     *   - Less than or equal to 0: This allows for unbounded number of llm calls.
      */
-    private toAdkFinishReason;
+    maxLlmCalls: number;
+    constructor(config?: Partial<RunConfig>);
     /**
-     * Update type strings in schema to lowercase for Anthropic compatibility
+     * Validates the maxLlmCalls value
      */
-    private updateTypeString;
+    private validateMaxLlmCalls;
+}
+
+/**
+ * Store the data that can be used for transcription.
+ */
+declare class TranscriptionEntry {
     /**
-     * Gets the Anthropic client
+     * The role that created this data, typically "user" or "model". For function
+     * call, this is None.
      */
-    private get client();
+    role?: string;
+    /**
+     * The data that can be used for transcription
+     */
+    data: Blob | Content;
+    constructor(options: {
+        role?: string;
+        data: Blob | Content;
+    });
 }
 
 /**
- * Google LLM Variant enum
+ * Transfer context for multi-agent workflows
+ * Tracks the chain of agent transfers for telemetry
  */
-declare enum GoogleLLMVariant {
-    VERTEX_AI = "VERTEX_AI",
-    GEMINI_API = "GEMINI_API"
+interface TransferContext {
+    /** Array of agent names in transfer order */
+    transferChain: string[];
+    /** Current depth in transfer chain (0 = root) */
+    transferDepth: number;
+    /** Name of the root agent that started the chain */
+    rootAgentName: string;
+    /** Span context of the root agent for linking */
+    rootSpanContext?: SpanContext;
+    /** Span context of the previous agent in the chain */
+    previousSpanContext?: SpanContext;
 }
 /**
- * Integration for Gemini models.
+ * Error thrown when the number of LLM calls exceed the limit.
  */
-declare class GoogleLlm extends BaseLlm {
-    private _apiClient?;
-    private _liveApiClient?;
-    private _apiBackend?;
-    private _trackingHeaders?;
+declare class LlmCallsLimitExceededError extends Error {
+    constructor(message: string);
+}
+/**
+ * Generates a new invocation context ID
+ */
+declare function newInvocationContextId(): string;
+/**
+ * An invocation context represents the data of a single invocation of an agent.
+ *
+ * An invocation:
+ *   1. Starts with a user message and ends with a final response.
+ *   2. Can contain one or multiple agent calls.
+ *   3. Is handled by runner.run_async().
+ *
+ * An invocation runs an agent until it does not request to transfer to another
+ * agent.
+ *
+ * An agent call:
+ *   1. Is handled by agent.run().
+ *   2. Ends when agent.run() ends.
+ *
+ * An LLM agent call is an agent with a BaseLLMFlow.
+ * An LLM agent call can contain one or multiple steps.
+ *
+ * An LLM agent runs steps in a loop until:
+ *   1. A final response is generated.
+ *   2. The agent transfers to another agent.
+ *   3. The end_invocation is set to true by any callbacks or tools.
+ *
+ * A step:
+ *   1. Calls the LLM only once and yields its response.
+ *   2. Calls the tools and yields their responses if requested.
+ *
+ * The summarization of the function response is considered another step, since
+ * it is another llm call.
+ *
+ * A step ends when it's done calling llm and tools, or if the end_invocation
+ * is set to true at any time.
+ *
+ *
+ *     ┌─────────────────────── invocation ──────────────────────────┐
+ *     ┌──────────── llm_agent_call_1 ────────────┐ ┌─ agent_call_2 ─┐
+ *     ┌──── step_1 ────────┐ ┌───── step_2 ──────┐
+ *     [call_llm] [call_tool] [call_llm] [transfer]
+ *
+ */
+declare class InvocationContext {
+    readonly artifactService?: BaseArtifactService;
+    readonly sessionService: BaseSessionService;
+    readonly memoryService?: BaseMemoryService;
     /**
-     * Constructor for Gemini
+     * The plugin manager for this invocation context.
+     */
+    readonly pluginManager: PluginManager;
+    /**
+     * Optional configuration controlling context caching behavior for this invocation.
+     *
+     * When present, enables reuse of cached LLM context across agent calls and
+     * sub-agents within the same invocation (and potentially across invocations,
+     * depending on cache policy). When undefined, context caching is disabled.
+     *
+     * This config is typically inherited from the app-level configuration and
+     * propagated to all child invocation contexts.
      */
-    constructor(model?: string);
+    readonly contextCacheConfig?: ContextCacheConfig;
     /**
-     * Provides the list of supported models.
+     * The id of this invocation context. Readonly.
      */
-    static supportedModels(): string[];
+    readonly invocationId: string;
     /**
-     * Main content generation method - handles both streaming and non-streaming
+     * The branch of the invocation context.
+     *
+     * The format is like agent_1.agent_2.agent_3, where agent_1 is the parent of
+     * agent_2, and agent_2 is the parent of agent_3.
+     *
+     * Branch is used when multiple sub-agents shouldn't see their peer agents'
+     * conversation history.
      */
-    protected generateContentAsyncImpl(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
+    readonly branch?: string;
     /**
-     * Connects to the Gemini model and returns an llm connection.
+     * The current agent of this invocation context. Readonly.
      */
-    connect(_llmRequest: LlmRequest): BaseLLMConnection;
+    agent: BaseAgent;
     /**
-     * Check if response has inline data
+     * The user content that started this invocation. Readonly.
      */
-    private hasInlineData;
+    readonly userContent?: Content;
     /**
-     * Convert LlmRequest contents to GoogleGenAI format
+     * The current session of this invocation context. Readonly.
      */
-    private convertContents;
+    readonly session: Session;
     /**
-     * Preprocesses the request based on the API backend.
+     * Whether to end this invocation.
+     *
+     * Set to True in callbacks or tools to terminate this invocation.
      */
-    private preprocessRequest;
+    endInvocation: boolean;
     /**
-     * Sets display_name to null for the Gemini API (non-Vertex) backend.
+     * The queue to receive live requests.
      */
-    private removeDisplayNameIfPresent;
+    liveRequestQueue?: LiveRequestQueue;
     /**
-     * Provides the api client.
+     * The running streaming tools of this invocation.
      */
-    get apiClient(): GoogleGenAI;
+    activeStreamingTools?: Record<string, ActiveStreamingTool>;
     /**
-     * Gets the API backend type.
+     * Caches necessary, data audio or contents, that are needed by transcription.
      */
-    get apiBackend(): GoogleLLMVariant;
+    transcriptionCache?: TranscriptionEntry[];
     /**
-     * Gets the tracking headers.
+     * Configurations for live agents under this invocation.
      */
-    get trackingHeaders(): Record<string, string>;
+    runConfig?: RunConfig;
     /**
-     * Gets the live API version.
+     * Transfer context for multi-agent workflows
+     * Tracks agent transfer chain for telemetry
      */
-    get liveApiVersion(): string;
+    transferContext?: TransferContext;
     /**
-     * Gets the live API client.
+     * A container to keep track of different kinds of costs incurred as a part
+     * of this invocation.
      */
-    get liveApiClient(): GoogleGenAI;
-}
-
-/**
- * OpenAI LLM implementation using GPT models
- * Enhanced with comprehensive debug logging similar to Google LLM
- */
-declare class OpenAiLlm extends BaseLlm {
-    private _client?;
+    private readonly _invocationCostManager;
     /**
-     * Constructor for OpenAI LLM
+     * Constructor for InvocationContext
      */
-    constructor(model?: string);
+    constructor(options: {
+        artifactService?: BaseArtifactService;
+        sessionService: BaseSessionService;
+        memoryService?: BaseMemoryService;
+        pluginManager: PluginManager;
+        invocationId?: string;
+        branch?: string;
+        agent: BaseAgent;
+        userContent?: Content;
+        session: Session;
+        endInvocation?: boolean;
+        liveRequestQueue?: LiveRequestQueue;
+        activeStreamingTools?: Record<string, ActiveStreamingTool>;
+        transcriptionCache?: TranscriptionEntry[];
+        runConfig?: RunConfig;
+        contextCacheConfig?: ContextCacheConfig;
+        transferContext?: TransferContext;
+    });
     /**
-     * Provides the list of supported models
+     * App name from the session
      */
-    static supportedModels(): string[];
+    get appName(): string;
     /**
-     * Main content generation method - handles both streaming and non-streaming
+     * User ID from the session
      */
-    protected generateContentAsyncImpl(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
+    get userId(): string;
     /**
-     * Live connection is not supported for OpenAI models
+     * Tracks number of llm calls made.
+     *
+     * @throws {LlmCallsLimitExceededError} If number of llm calls made exceed the set threshold.
      */
-    connect(_llmRequest: LlmRequest): BaseLLMConnection;
+    incrementLlmCallCount(): void;
     /**
-     * Create LlmResponse from streaming chunk - similar to Google's LlmResponse.create
+     * Creates a child invocation context for a sub-agent
      */
-    private createChunkResponse;
+    createChildContext(agent: BaseAgent): InvocationContext;
+}
+
+/**
+ * Base class for LLM request processors.
+ */
+declare abstract class BaseLlmRequestProcessor {
     /**
-     * Convert OpenAI message to ADK LlmResponse
+     * Runs the processor on the given invocation context and LLM request.
+     * @param invocationContext The invocation context
+     * @param llmRequest The LLM request to process
+     * @returns An async generator yielding events
      */
-    private openAiMessageToLlmResponse;
+    abstract runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event, void, unknown>;
+}
+/**
+ * Base class for LLM response processors.
+ */
+declare abstract class BaseLlmResponseProcessor {
     /**
-     * Convert ADK Content to OpenAI ChatCompletionMessage
+     * Processes the LLM response.
+     * @param invocationContext The invocation context
+     * @param llmResponse The LLM response to process
+     * @returns An async generator yielding events
      */
-    private contentToOpenAiMessage;
+    abstract runAsync(invocationContext: InvocationContext, llmResponse: LlmResponse): AsyncGenerator<Event, void, unknown>;
+}
+
+/**
+ * Auth LLM request processor that handles authentication information
+ * to build the LLM request with credential processing
+ */
+declare class AuthLlmRequestProcessor extends BaseLlmRequestProcessor {
     /**
-     * Convert ADK Part to OpenAI message content
+     * Processes authentication information from session events
+     * and resumes function calls that required authentication
      */
-    private partToOpenAiContent;
+    runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event>;
     /**
-     * Transform JSON schema to use lowercase types for OpenAI compatibility
+     * Parses and stores authentication response in session state
      */
-    private transformSchemaForOpenAi;
+    private parseAndStoreAuthResponse;
+}
+/**
+ * Exported request processor instance for use in flow configurations
+ */
+declare const requestProcessor$7: AuthLlmRequestProcessor;
+
+/**
+ * Enhanced auth configuration with credential handling
+ * This extends the basic AuthConfig with raw and exchanged credentials
+ */
+declare class EnhancedAuthConfig {
     /**
-     * Convert ADK function declaration to OpenAI tool
+     * The authentication scheme
      */
-    private functionDeclarationToOpenAiTool;
+    authScheme: AuthScheme;
     /**
-     * Convert ADK role to OpenAI role format
+     * Raw auth credential used to collect credentials
+     * Used in auth schemes that need to exchange credentials (e.g. OAuth2, OIDC)
      */
-    private toOpenAiRole;
+    rawAuthCredential?: AuthCredential;
     /**
-     * Convert OpenAI finish reason to ADK finish reason
+     * Exchanged auth credential after processing
+     * Filled by ADK and client working together
      */
-    private toAdkFinishReason;
+    exchangedAuthCredential?: AuthCredential;
     /**
-     * Preprocess request similar to Google LLM
+     * User-specified key for credential storage and retrieval
      */
-    private preprocessRequest;
+    credentialKey?: string;
     /**
-     * Preprocess individual parts for OpenAI compatibility
+     * Additional context properties
      */
-    private preprocessPart;
+    context?: Record<string, any>;
     /**
-     * Detect content type for flow control
-     * This is a simplified implementation - you may need to adjust based on your specific requirements
+     * Constructor for EnhancedAuthConfig
      */
-    private getContentType;
+    constructor(config: {
+        authScheme: AuthScheme;
+        rawAuthCredential?: AuthCredential;
+        exchangedAuthCredential?: AuthCredential;
+        credentialKey?: string;
+        context?: Record<string, any>;
+    });
     /**
-     * Check if response has inline data (similar to Google LLM)
+     * Generates a credential key based on auth scheme and raw credential
+     * Used for saving/loading credentials from credential service
      */
-    private hasInlineData;
+    private generateCredentialKey;
     /**
-     * Gets the OpenAI client
+     * Gets the credential key for storage
      */
-    private get client();
-}
-
-interface LLMClass {
-    new (model: string): BaseLlm;
-    supportedModels(): string[];
-}
-interface LlmModelConfig {
-    temperature?: number;
-    maxOutputTokens?: number;
-    topP?: number;
-    topK?: number;
-}
-interface LlmModel {
-    generateContent(options: {
-        prompt: string;
-    } & LlmModelConfig): Promise<LlmResponse>;
-}
-declare class LLMRegistry {
-    private static llmRegistry;
-    private static modelInstances;
-    private static logger;
-    static newLLM(model: string): BaseLlm;
-    static resolve(model: string): LLMClass | null;
-    static register(modelNameRegex: string, llmClass: LLMClass): void;
-    static registerLLM(llmClass: LLMClass): void;
-    static registerModel(name: string, model: LlmModel): void;
-    static getModel(name: string): LlmModel;
-    static hasModel(name: string): boolean;
-    static unregisterModel(name: string): void;
-    static getModelOrCreate(name: string): LlmModel | BaseLlm;
-    static clear(): void;
-    static clearModels(): void;
-    static clearClasses(): void;
-    static logRegisteredModels(): void;
+    getCredentialKey(): string;
 }
-
 /**
- * Register all LLM providers
+ * Arguments for the special long-running function tool used to request
+ * end-user credentials
  */
-declare function registerProviders(): void;
-
+interface AuthToolArguments extends Record<string, unknown> {
+    /**
+     * The ID of the function call that requires authentication
+     */
+    function_call_id: string;
+    /**
+     * The authentication configuration
+     */
+    auth_config: AuthConfig | EnhancedAuthConfig;
+}
 /**
- * Configuration for model built-in thinking features
- * Compatible with google.genai.types.ThinkingConfig
+ * Auth tool for handling credential requests
  */
-interface ThinkingConfig {
+declare class AuthTool {
     /**
-     * Whether to include the thinking process in the response
+     * Processes auth tool arguments and returns appropriate response
      */
-    includeThinking?: boolean;
+    static processAuthRequest(args: AuthToolArguments): Promise<{
+        status: string;
+        authConfig?: AuthConfig | EnhancedAuthConfig;
+        credentialKey?: string;
+    }>;
     /**
-     * Additional thinking configuration options
+     * Validates auth tool arguments
      */
-    [key: string]: any;
+    static validateAuthArguments(args: any): args is AuthToolArguments;
 }
+/**
+ * Creates an AuthToolArguments object with proper typing
+ */
+declare function createAuthToolArguments(functionCallId: string, authConfig: AuthConfig | EnhancedAuthConfig): AuthToolArguments;
+/**
+ * Type guard to check if an auth config is enhanced
+ */
+declare function isEnhancedAuthConfig(config: AuthConfig | EnhancedAuthConfig): config is EnhancedAuthConfig;
 
 /**
- * Authentication scheme types
+ * Types of authentication credentials
  */
-declare enum AuthSchemeType {
-    APIKEY = "apiKey",
-    HTTP = "http",
+declare enum AuthCredentialType {
+    API_KEY = "api_key",
+    BASIC = "basic",
+    BEARER = "bearer",
     OAUTH2 = "oauth2",
-    OPENID_CONNECT = "openIdConnect"
+    CUSTOM = "custom"
 }
 /**
- * Base class for authentication schemes
+ * Base class for authentication credentials
  */
-declare abstract class AuthScheme {
+declare abstract class AuthCredential {
     /**
-     * The type of authentication scheme
+     * Type of credential
      */
-    type: AuthSchemeType;
-    constructor(type: AuthSchemeType);
-}
-/**
- * API Key authentication scheme
- */
-declare class ApiKeyScheme extends AuthScheme {
+    type: AuthCredentialType;
     /**
-     * Where the API key is sent
+     * Constructor for AuthCredential
      */
-    in: "query" | "header" | "cookie";
+    constructor(type: AuthCredentialType);
     /**
-     * Name of the parameter
+     * Gets the authentication token
      */
-    name: string;
+    abstract getToken(): string | undefined;
     /**
-     * Description of the API key
+     * Gets headers for HTTP requests
      */
-    description?: string;
+    abstract getHeaders(config: AuthConfig): Record<string, string>;
     /**
-     * Constructor for ApiKeyScheme
+     * Whether the token can be refreshed
      */
-    constructor(config: {
-        in: "query" | "header" | "cookie";
-        name: string;
-        description?: string;
-    });
+    canRefresh(): boolean;
+    /**
+     * Refreshes the token
+     */
+    refresh(): Promise<void>;
 }
 /**
- * HTTP authentication scheme
+ * API Key credential
  */
-declare class HttpScheme extends AuthScheme {
+declare class ApiKeyCredential extends AuthCredential {
     /**
-     * The HTTP authentication scheme
+     * The API key
      */
-    scheme: "basic" | "bearer" | "digest" | "other";
+    apiKey: string;
     /**
-     * Bearer format when scheme is 'bearer'
+     * Constructor for ApiKeyCredential
      */
-    bearerFormat?: string;
+    constructor(apiKey: string);
     /**
-     * Description of the scheme
+     * Gets the API key as the token
      */
-    description?: string;
+    getToken(): string;
     /**
-     * Constructor for HttpScheme
+     * Gets headers for HTTP requests
      */
-    constructor(config: {
-        scheme: "basic" | "bearer" | "digest" | "other";
-        bearerFormat?: string;
-        description?: string;
-    });
-}
-/**
- * OAuth flow configuration
- */
-interface OAuthFlow {
-    authorizationUrl?: string;
-    tokenUrl?: string;
-    refreshUrl?: string;
-    scopes: Record<string, string>;
-}
-/**
- * OAuth flows configuration
- */
-interface OAuthFlows {
-    implicit?: OAuthFlow;
-    password?: OAuthFlow;
-    clientCredentials?: OAuthFlow;
-    authorizationCode?: OAuthFlow;
+    getHeaders(config: AuthConfig): Record<string, string>;
 }
 /**
- * OAuth2 authentication scheme
+ * Basic authentication credential
  */
-declare class OAuth2Scheme extends AuthScheme {
+declare class BasicAuthCredential extends AuthCredential {
     /**
-     * OAuth flows
+     * The username
      */
-    flows: OAuthFlows;
+    username: string;
     /**
-     * Description of the scheme
+     * The password
      */
-    description?: string;
+    password: string;
     /**
-     * Constructor for OAuth2Scheme
+     * Constructor for BasicAuthCredential
      */
-    constructor(config: {
-        flows: OAuthFlows;
-        description?: string;
-    });
+    constructor(username: string, password: string);
+    /**
+     * Gets the encoded basic auth token
+     */
+    getToken(): string;
+    /**
+     * Gets headers for HTTP requests
+     */
+    getHeaders(): Record<string, string>;
 }
 /**
- * OpenID Connect authentication scheme
+ * Bearer token credential
  */
-declare class OpenIdConnectScheme extends AuthScheme {
+declare class BearerTokenCredential extends AuthCredential {
     /**
-     * OpenID Connect URL
+     * The bearer token
      */
-    openIdConnectUrl: string;
+    token: string;
     /**
-     * Description of the scheme
+     * Constructor for BearerTokenCredential
      */
-    description?: string;
+    constructor(token: string);
     /**
-     * Constructor for OpenIdConnectScheme
+     * Gets the bearer token
      */
-    constructor(config: {
-        openIdConnectUrl: string;
-        description?: string;
-    });
+    getToken(): string;
+    /**
+     * Gets headers for HTTP requests
+     */
+    getHeaders(): Record<string, string>;
 }
-
 /**
- * Authentication configuration for tools
+ * OAuth2 token credential with refresh capability
  */
-declare class AuthConfig {
+declare class OAuth2Credential extends AuthCredential {
     /**
-     * The authentication scheme
+     * The access token
      */
-    authScheme: AuthScheme;
+    accessToken: string;
     /**
-     * Additional context properties
+     * The refresh token
      */
-    context?: Record<string, any>;
+    refreshToken?: string;
     /**
-     * Constructor for AuthConfig
+     * When the token expires
+     */
+    expiresAt?: Date;
+    /**
+     * Function to refresh the token
+     */
+    private refreshFunction?;
+    /**
+     * Constructor for OAuth2Credential
      */
     constructor(config: {
-        authScheme: AuthScheme;
-        context?: Record<string, any>;
+        accessToken: string;
+        refreshToken?: string;
+        expiresIn?: number;
+        refreshFunction?: (refreshToken: string) => Promise<{
+            accessToken: string;
+            refreshToken?: string;
+            expiresIn?: number;
+        }>;
     });
+    /**
+     * Gets the access token
+     */
+    getToken(): string;
+    /**
+     * Gets headers for HTTP requests
+     */
+    getHeaders(): Record<string, string>;
+    /**
+     * Whether the token can be refreshed
+     */
+    canRefresh(): boolean;
+    /**
+     * Whether the token is expired
+     */
+    isExpired(): boolean;
+    /**
+     * Refreshes the token
+     */
+    refresh(): Promise<void>;
 }
 
 /**
- * Handler for authentication in tools
+ * AI SDK integration that accepts a pre-configured LanguageModel.
+ * Enables ADK to work with any provider supported by Vercel's AI SDK.
  */
-declare class AuthHandler {
+declare class AiSdkLlm extends BaseLlm {
+    private modelInstance;
+    protected logger: Logger;
+    private cacheManager;
     /**
-     * The authentication configuration
+     * Model provider patterns for detection
      */
-    authConfig: AuthConfig;
+    private static readonly PROVIDER_PATTERNS;
     /**
-     * The authentication credential
+     * Constructor accepts a pre-configured LanguageModel instance
+     * @param model - Pre-configured LanguageModel from provider(modelName)
      */
-    credential?: AuthCredential;
+    constructor(modelInstance: LanguageModel);
     /**
-     * Constructor for AuthHandler
+     * Returns empty array - following Python ADK pattern
      */
-    constructor(config: {
-        authConfig: AuthConfig;
-        credential?: AuthCredential;
-    });
+    static supportedModels(): string[];
     /**
-     * Gets the authentication token
+     * Safely extracts modelId from a LanguageModel instance
      */
-    getToken(): string | undefined;
+    private getModelId;
     /**
-     * Gets headers for HTTP requests
+     * Normalizes Google model ID by removing provider prefix
+     * AI SDK uses "google/gemini-2.5-flash" but Google API expects "gemini-2.5-flash"
      */
-    getHeaders(): Record<string, string>;
+    private normalizeGoogleModelId;
     /**
-     * Refreshes the token if necessary
+     * Detects the provider of a given model
+     */
+    private detectModelProvider;
+    /**
+     * Initializes the cache manager for Google models
+     * The manager lazily initializes its Google GenAI client on first use
+     */
+    private initializeCacheManager;
+    /**
+     * Handles context caching for Google models
+     */
+    private handleGoogleContextCaching;
+    /**
+     * Builds AI SDK request parameters with proper caching configuration
+     */
+    private buildRequestParams;
+    /**
+     * Logs provider-specific metadata
+     */
+    private logProviderMetadata;
+    protected generateContentAsyncImpl(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
+    /**
+     * Handles streaming text generation
+     */
+    private handleStreamingResponse;
+    /**
+     * Handles non-streaming text generation
+     */
+    private handleNonStreamingResponse;
+    /**
+     * Convert ADK LlmRequest to AI SDK CoreMessage format
+     */
+    private convertToAiSdkMessages;
+    /**
+     * Transform JSON schema to use lowercase types for AI SDK compatibility
      */
-    refreshToken(): Promise<void>;
-}
-
-/**
- * Base class for LLM request processors.
- */
-declare abstract class BaseLlmRequestProcessor {
+    private transformSchemaForAiSdk;
     /**
-     * Runs the processor on the given invocation context and LLM request.
-     * @param invocationContext The invocation context
-     * @param llmRequest The LLM request to process
-     * @returns An async generator yielding events
+     * Convert ADK tools to AI SDK tools format
      */
-    abstract runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event, void, unknown>;
-}
-/**
- * Base class for LLM response processors.
- */
-declare abstract class BaseLlmResponseProcessor {
+    private convertToAiSdkTools;
     /**
-     * Processes the LLM response.
-     * @param invocationContext The invocation context
-     * @param llmResponse The LLM response to process
-     * @returns An async generator yielding events
+     * Convert ADK Content to AI SDK CoreMessage
      */
-    abstract runAsync(invocationContext: InvocationContext, llmResponse: LlmResponse): AsyncGenerator<Event, void, unknown>;
-}
-
-/**
- * Auth LLM request processor that handles authentication information
- * to build the LLM request with credential processing
- */
-declare class AuthLlmRequestProcessor extends BaseLlmRequestProcessor {
+    private contentToAiSdkMessage;
     /**
-     * Processes authentication information from session events
-     * and resumes function calls that required authentication
+     * Map ADK role to AI SDK role
      */
-    runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event>;
+    private mapRole;
     /**
-     * Parses and stores authentication response in session state
+     * Map AI SDK finish reason to ADK finish reason
      */
-    private parseAndStoreAuthResponse;
+    private mapFinishReason;
 }
-/**
- * Exported request processor instance for use in flow configurations
- */
-declare const requestProcessor$7: AuthLlmRequestProcessor;
 
 /**
- * Enhanced auth configuration with credential handling
- * This extends the basic AuthConfig with raw and exchanged credentials
+ * Anthropic LLM implementation using Claude models with prompt caching support
  */
-declare class EnhancedAuthConfig {
-    /**
-     * The authentication scheme
-     */
-    authScheme: AuthScheme;
+declare class AnthropicLlm extends BaseLlm {
+    private _client?;
+    protected logger: Logger;
     /**
-     * Raw auth credential used to collect credentials
-     * Used in auth schemes that need to exchange credentials (e.g. OAuth2, OIDC)
+     * Constructor for Anthropic LLM
      */
-    rawAuthCredential?: AuthCredential;
+    constructor(model?: string);
+    static supportedModels(): string[];
     /**
-     * Exchanged auth credential after processing
-     * Filled by ADK and client working together
+     * Main content generation method - handles both streaming and non-streaming
      */
-    exchangedAuthCredential?: AuthCredential;
+    protected generateContentAsyncImpl(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
+    private shouldEnableCache;
+    private getCacheTTL;
+    private createCacheControl;
+    private logCachePerformance;
+    connect(_llmRequest: LlmRequest): BaseLLMConnection;
     /**
-     * User-specified key for credential storage and retrieval
+     * Convert Anthropic Message to ADK LlmResponse
      */
-    credentialKey?: string;
+    private anthropicMessageToLlmResponse;
     /**
-     * Additional context properties
+     * Convert ADK Content to Anthropic MessageParam
      */
-    context?: Record<string, any>;
+    private contentToAnthropicMessage;
     /**
-     * Constructor for EnhancedAuthConfig
+     * Convert ADK Part to Anthropic content block
      */
-    constructor(config: {
-        authScheme: AuthScheme;
-        rawAuthCredential?: AuthCredential;
-        exchangedAuthCredential?: AuthCredential;
-        credentialKey?: string;
-        context?: Record<string, any>;
-    });
+    private partToAnthropicBlock;
     /**
-     * Generates a credential key based on auth scheme and raw credential
-     * Used for saving/loading credentials from credential service
+     * Convert Anthropic content block to ADK Part
      */
-    private generateCredentialKey;
+    private anthropicBlockToPart;
     /**
-     * Gets the credential key for storage
+     * Convert ADK function declaration to Anthropic tool param
      */
-    getCredentialKey(): string;
-}
-/**
- * Arguments for the special long-running function tool used to request
- * end-user credentials
- */
-interface AuthToolArguments extends Record<string, unknown> {
+    private functionDeclarationToAnthropicTool;
     /**
-     * The ID of the function call that requires authentication
+     * Convert ADK role to Anthropic role format
      */
-    function_call_id: string;
+    private toAnthropicRole;
     /**
-     * The authentication configuration
+     * Convert Anthropic stop reason to ADK finish reason
      */
-    auth_config: AuthConfig | EnhancedAuthConfig;
-}
-/**
- * Auth tool for handling credential requests
- */
-declare class AuthTool {
+    private toAdkFinishReason;
     /**
-     * Processes auth tool arguments and returns appropriate response
+     * Update type strings in schema to lowercase for Anthropic compatibility
      */
-    static processAuthRequest(args: AuthToolArguments): Promise<{
-        status: string;
-        authConfig?: AuthConfig | EnhancedAuthConfig;
-        credentialKey?: string;
-    }>;
+    private updateTypeString;
     /**
-     * Validates auth tool arguments
+     * Gets the Anthropic client
      */
-    static validateAuthArguments(args: any): args is AuthToolArguments;
+    private get client();
+}
+
+interface ContextCacheManager {
+    handleContextCaching(llmRequest: LlmRequest): Promise<CacheMetadata | null>;
+    populateCacheMetadataInResponse(llmResponse: LlmResponse, cacheMetadata: CacheMetadata): void;
+}
+declare class GeminiContextCacheManager implements ContextCacheManager {
+    private genaiClient;
+    private readonly logger;
+    constructor(logger: Logger, genaiClient?: GoogleGenAI);
+    getGenaiClient(): GoogleGenAI;
+    handleContextCaching(llmRequest: LlmRequest): Promise<CacheMetadata | null>;
+    private handleContextCachingInternal;
+    private isCacheValid;
+    private generateCacheFingerprint;
+    private createNewCacheWithContents;
+    private countCacheTokens;
+    private createCache;
+    cleanupCache(cacheName: string): Promise<void>;
+    private applyCacheToRequest;
+    populateCacheMetadataInResponse(llmResponse: LlmResponse, cacheMetadata: CacheMetadata): void;
 }
-/**
- * Creates an AuthToolArguments object with proper typing
- */
-declare function createAuthToolArguments(functionCallId: string, authConfig: AuthConfig | EnhancedAuthConfig): AuthToolArguments;
-/**
- * Type guard to check if an auth config is enhanced
- */
-declare function isEnhancedAuthConfig(config: AuthConfig | EnhancedAuthConfig): config is EnhancedAuthConfig;
 
 /**
- * Types of authentication credentials
+ * Google LLM Variant enum
  */
-declare enum AuthCredentialType {
-    API_KEY = "api_key",
-    BASIC = "basic",
-    BEARER = "bearer",
-    OAUTH2 = "oauth2",
-    CUSTOM = "custom"
+declare enum GoogleLLMVariant {
+    VERTEX_AI = "VERTEX_AI",
+    GEMINI_API = "GEMINI_API"
 }
 /**
- * Base class for authentication credentials
+ * Integration for Gemini models.
  */
-declare abstract class AuthCredential {
+declare class GoogleLlm extends BaseLlm {
+    private _apiClient?;
+    private _liveApiClient?;
+    private _apiBackend?;
+    private _trackingHeaders?;
     /**
-     * Type of credential
+     * Constructor for Gemini
      */
-    type: AuthCredentialType;
+    constructor(model?: string);
     /**
-     * Constructor for AuthCredential
+     * Provides the list of supported models.
      */
-    constructor(type: AuthCredentialType);
+    static supportedModels(): string[];
+    protected generateContentAsyncImpl(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
     /**
-     * Gets the authentication token
+     * Connects to the Gemini model and returns an llm connection.
      */
-    abstract getToken(): string | undefined;
+    connect(_llmRequest: LlmRequest): BaseLLMConnection;
     /**
-     * Gets headers for HTTP requests
+     * Convert LlmRequest contents to GoogleGenAI format
      */
-    abstract getHeaders(config: AuthConfig): Record<string, string>;
+    private convertContents;
     /**
-     * Whether the token can be refreshed
+     * Preprocesses the request based on the API backend.
      */
-    canRefresh(): boolean;
+    private preprocessRequest;
     /**
-     * Refreshes the token
+     * Sets display_name to null for the Gemini API (non-Vertex) backend.
      */
-    refresh(): Promise<void>;
-}
-/**
- * API Key credential
- */
-declare class ApiKeyCredential extends AuthCredential {
+    private removeDisplayNameIfPresent;
     /**
-     * The API key
+     * Provides the api client.
      */
-    apiKey: string;
+    get apiClient(): GoogleGenAI;
     /**
-     * Constructor for ApiKeyCredential
+     * Gets the API backend type.
      */
-    constructor(apiKey: string);
+    get apiBackend(): GoogleLLMVariant;
     /**
-     * Gets the API key as the token
+     * Gets the tracking headers.
      */
-    getToken(): string;
+    get trackingHeaders(): Record<string, string>;
     /**
-     * Gets headers for HTTP requests
+     * Gets the live API version.
      */
-    getHeaders(config: AuthConfig): Record<string, string>;
+    get liveApiVersion(): string;
+    /**
+     * Gets the live API client.
+     */
+    get liveApiClient(): GoogleGenAI;
+}
+
+interface LLMClass {
+    new (model: string): BaseLlm;
+    supportedModels(): string[];
+}
+interface LlmModelConfig {
+    temperature?: number;
+    maxOutputTokens?: number;
+    topP?: number;
+    topK?: number;
+}
+interface LlmModel {
+    generateContent(options: {
+        prompt: string;
+    } & LlmModelConfig): Promise<LlmResponse>;
 }
+declare class LLMRegistry {
+    private static llmRegistry;
+    private static modelInstances;
+    private static logger;
+    static newLLM(model: string): BaseLlm;
+    static resolve(model: string): LLMClass | null;
+    static register(modelNameRegex: string, llmClass: LLMClass): void;
+    static registerLLM(llmClass: LLMClass): void;
+    static registerModel(name: string, model: LlmModel): void;
+    static getModel(name: string): LlmModel;
+    static hasModel(name: string): boolean;
+    static unregisterModel(name: string): void;
+    static getModelOrCreate(name: string): LlmModel | BaseLlm;
+    static clear(): void;
+    static clearModels(): void;
+    static clearClasses(): void;
+    static logRegisteredModels(): void;
+}
+
 /**
- * Basic authentication credential
+ * OpenAI LLM implementation using GPT models
+ * Enhanced with comprehensive debug logging similar to Google LLM
  */
-declare class BasicAuthCredential extends AuthCredential {
+declare class OpenAiLlm extends BaseLlm {
+    private _client?;
     /**
-     * The username
+     * Constructor for OpenAI LLM
      */
-    username: string;
+    constructor(model?: string);
     /**
-     * The password
+     * Provides the list of supported models
      */
-    password: string;
+    static supportedModels(): string[];
     /**
-     * Constructor for BasicAuthCredential
+     * Main content generation method - handles both streaming and non-streaming
      */
-    constructor(username: string, password: string);
+    protected generateContentAsyncImpl(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void, unknown>;
     /**
-     * Gets the encoded basic auth token
+     * Live connection is not supported for OpenAI models
      */
-    getToken(): string;
+    connect(_llmRequest: LlmRequest): BaseLLMConnection;
     /**
-     * Gets headers for HTTP requests
+     * Create LlmResponse from streaming chunk - similar to Google's LlmResponse.create
      */
-    getHeaders(): Record<string, string>;
-}
-/**
- * Bearer token credential
- */
-declare class BearerTokenCredential extends AuthCredential {
+    private createChunkResponse;
     /**
-     * The bearer token
+     * Convert OpenAI message to ADK LlmResponse
      */
-    token: string;
+    private openAiMessageToLlmResponse;
     /**
-     * Constructor for BearerTokenCredential
+     * Convert ADK Content to OpenAI ChatCompletionMessage
      */
-    constructor(token: string);
+    private contentToOpenAiMessage;
     /**
-     * Gets the bearer token
+     * Convert ADK Part to OpenAI message content
      */
-    getToken(): string;
+    private partToOpenAiContent;
     /**
-     * Gets headers for HTTP requests
+     * Transform JSON schema to use lowercase types for OpenAI compatibility
      */
-    getHeaders(): Record<string, string>;
-}
-/**
- * OAuth2 token credential with refresh capability
- */
-declare class OAuth2Credential extends AuthCredential {
+    private transformSchemaForOpenAi;
     /**
-     * The access token
+     * Convert ADK function declaration to OpenAI tool
      */
-    accessToken: string;
+    private functionDeclarationToOpenAiTool;
     /**
-     * The refresh token
+     * Convert ADK role to OpenAI role format
      */
-    refreshToken?: string;
+    private toOpenAiRole;
     /**
-     * When the token expires
+     * Convert OpenAI finish reason to ADK finish reason
      */
-    expiresAt?: Date;
+    private toAdkFinishReason;
     /**
-     * Function to refresh the token
+     * Preprocess request similar to Google LLM
      */
-    private refreshFunction?;
+    private preprocessRequest;
     /**
-     * Constructor for OAuth2Credential
+     * Preprocess individual parts for OpenAI compatibility
      */
-    constructor(config: {
-        accessToken: string;
-        refreshToken?: string;
-        expiresIn?: number;
-        refreshFunction?: (refreshToken: string) => Promise<{
-            accessToken: string;
-            refreshToken?: string;
-            expiresIn?: number;
-        }>;
-    });
+    private preprocessPart;
     /**
-     * Gets the access token
+     * Detect content type for flow control
+     * This is a simplified implementation - you may need to adjust based on your specific requirements
      */
-    getToken(): string;
+    private getContentType;
     /**
-     * Gets headers for HTTP requests
+     * Check if response has inline data (similar to Google LLM)
      */
-    getHeaders(): Record<string, string>;
+    private hasInlineData;
     /**
-     * Whether the token can be refreshed
+     * Gets the OpenAI client
      */
-    canRefresh(): boolean;
+    private get client();
+}
+
+/**
+ * Register all LLM providers
+ */
+declare function registerProviders(): void;
+
+/**
+ * Configuration for model built-in thinking features
+ * Compatible with google.genai.types.ThinkingConfig
+ */
+interface ThinkingConfig {
     /**
-     * Whether the token is expired
+     * Whether to include the thinking process in the response
      */
-    isExpired(): boolean;
+    includeThinking?: boolean;
     /**
-     * Refreshes the token
+     * Additional thinking configuration options
      */
-    refresh(): Promise<void>;
+    [key: string]: any;
 }
 
 /**
  * Models module exports - consolidated to match Python structure
  */
 
-type index$5_AiSdkLlm = AiSdkLlm;
-declare const index$5_AiSdkLlm: typeof AiSdkLlm;
-type index$5_AnthropicLlm = AnthropicLlm;
-declare const index$5_AnthropicLlm: typeof AnthropicLlm;
-type index$5_ApiKeyCredential = ApiKeyCredential;
-declare const index$5_ApiKeyCredential: typeof ApiKeyCredential;
-type index$5_ApiKeyScheme = ApiKeyScheme;
-declare const index$5_ApiKeyScheme: typeof ApiKeyScheme;
-type index$5_AuthConfig = AuthConfig;
-declare const index$5_AuthConfig: typeof AuthConfig;
-type index$5_AuthCredential = AuthCredential;
-declare const index$5_AuthCredential: typeof AuthCredential;
-type index$5_AuthCredentialType = AuthCredentialType;
-declare const index$5_AuthCredentialType: typeof AuthCredentialType;
-type index$5_AuthHandler = AuthHandler;
-declare const index$5_AuthHandler: typeof AuthHandler;
-type index$5_AuthScheme = AuthScheme;
-declare const index$5_AuthScheme: typeof AuthScheme;
-type index$5_AuthSchemeType = AuthSchemeType;
-declare const index$5_AuthSchemeType: typeof AuthSchemeType;
-type index$5_BaseLLMConnection = BaseLLMConnection;
-declare const index$5_BaseLLMConnection: typeof BaseLLMConnection;
-type index$5_BaseLlm = BaseLlm;
-declare const index$5_BaseLlm: typeof BaseLlm;
-type index$5_BaseMemoryService = BaseMemoryService;
-type index$5_BasicAuthCredential = BasicAuthCredential;
-declare const index$5_BasicAuthCredential: typeof BasicAuthCredential;
-type index$5_BearerTokenCredential = BearerTokenCredential;
-declare const index$5_BearerTokenCredential: typeof BearerTokenCredential;
-declare const index$5_Blob: typeof Blob;
-declare const index$5_Content: typeof Content;
-declare const index$5_FunctionDeclaration: typeof FunctionDeclaration;
-type index$5_GoogleLlm = GoogleLlm;
-declare const index$5_GoogleLlm: typeof GoogleLlm;
-type index$5_HttpScheme = HttpScheme;
-declare const index$5_HttpScheme: typeof HttpScheme;
-type index$5_LLMRegistry = LLMRegistry;
-declare const index$5_LLMRegistry: typeof LLMRegistry;
-type index$5_LlmModel = LlmModel;
-type index$5_LlmModelConfig = LlmModelConfig;
-type index$5_LlmRequest = LlmRequest;
-declare const index$5_LlmRequest: typeof LlmRequest;
-type index$5_LlmResponse = LlmResponse;
-declare const index$5_LlmResponse: typeof LlmResponse;
-type index$5_OAuth2Credential = OAuth2Credential;
-declare const index$5_OAuth2Credential: typeof OAuth2Credential;
-type index$5_OAuth2Scheme = OAuth2Scheme;
-declare const index$5_OAuth2Scheme: typeof OAuth2Scheme;
-type index$5_OAuthFlow = OAuthFlow;
-type index$5_OAuthFlows = OAuthFlows;
-type index$5_OpenAiLlm = OpenAiLlm;
-declare const index$5_OpenAiLlm: typeof OpenAiLlm;
-type index$5_OpenIdConnectScheme = OpenIdConnectScheme;
-declare const index$5_OpenIdConnectScheme: typeof OpenIdConnectScheme;
-type index$5_SearchMemoryResponse = SearchMemoryResponse;
-type index$5_Session = Session;
-type index$5_State = State;
-declare const index$5_State: typeof State;
-type index$5_ThinkingConfig = ThinkingConfig;
-declare const index$5_registerProviders: typeof registerProviders;
-declare namespace index$5 {
-  export { index$5_AiSdkLlm as AiSdkLlm, index$5_AnthropicLlm as AnthropicLlm, index$5_ApiKeyCredential as ApiKeyCredential, index$5_ApiKeyScheme as ApiKeyScheme, index$5_AuthConfig as AuthConfig, index$5_AuthCredential as AuthCredential, index$5_AuthCredentialType as AuthCredentialType, index$5_AuthHandler as AuthHandler, index$5_AuthScheme as AuthScheme, index$5_AuthSchemeType as AuthSchemeType, index$5_BaseLLMConnection as BaseLLMConnection, index$5_BaseLlm as BaseLlm, type index$5_BaseMemoryService as BaseMemoryService, index$5_BasicAuthCredential as BasicAuthCredential, index$5_BearerTokenCredential as BearerTokenCredential, index$5_Blob as Blob, index$5_Content as Content, index$5_FunctionDeclaration as FunctionDeclaration, index$5_GoogleLlm as GoogleLlm, index$5_HttpScheme as HttpScheme, Schema as JSONSchema, index$5_LLMRegistry as LLMRegistry, type index$5_LlmModel as LlmModel, type index$5_LlmModelConfig as LlmModelConfig, index$5_LlmRequest as LlmRequest, index$5_LlmResponse as LlmResponse, index$5_OAuth2Credential as OAuth2Credential, index$5_OAuth2Scheme as OAuth2Scheme, type index$5_OAuthFlow as OAuthFlow, type index$5_OAuthFlows as OAuthFlows, index$5_OpenAiLlm as OpenAiLlm, index$5_OpenIdConnectScheme as OpenIdConnectScheme, type index$5_SearchMemoryResponse as SearchMemoryResponse, type index$5_Session as Session, index$5_State as State, type index$5_ThinkingConfig as ThinkingConfig, index$5_registerProviders as registerProviders };
+type index$6_AiSdkLlm = AiSdkLlm;
+declare const index$6_AiSdkLlm: typeof AiSdkLlm;
+type index$6_AnthropicLlm = AnthropicLlm;
+declare const index$6_AnthropicLlm: typeof AnthropicLlm;
+type index$6_ApiKeyCredential = ApiKeyCredential;
+declare const index$6_ApiKeyCredential: typeof ApiKeyCredential;
+type index$6_ApiKeyScheme = ApiKeyScheme;
+declare const index$6_ApiKeyScheme: typeof ApiKeyScheme;
+type index$6_AuthConfig = AuthConfig;
+declare const index$6_AuthConfig: typeof AuthConfig;
+type index$6_AuthCredential = AuthCredential;
+declare const index$6_AuthCredential: typeof AuthCredential;
+type index$6_AuthCredentialType = AuthCredentialType;
+declare const index$6_AuthCredentialType: typeof AuthCredentialType;
+type index$6_AuthHandler = AuthHandler;
+declare const index$6_AuthHandler: typeof AuthHandler;
+type index$6_AuthScheme = AuthScheme;
+declare const index$6_AuthScheme: typeof AuthScheme;
+type index$6_AuthSchemeType = AuthSchemeType;
+declare const index$6_AuthSchemeType: typeof AuthSchemeType;
+type index$6_BaseLLMConnection = BaseLLMConnection;
+declare const index$6_BaseLLMConnection: typeof BaseLLMConnection;
+type index$6_BaseLlm = BaseLlm;
+declare const index$6_BaseLlm: typeof BaseLlm;
+type index$6_BaseMemoryService = BaseMemoryService;
+type index$6_BasicAuthCredential = BasicAuthCredential;
+declare const index$6_BasicAuthCredential: typeof BasicAuthCredential;
+type index$6_BearerTokenCredential = BearerTokenCredential;
+declare const index$6_BearerTokenCredential: typeof BearerTokenCredential;
+declare const index$6_Blob: typeof Blob;
+declare const index$6_Content: typeof Content;
+type index$6_ContextCacheManager = ContextCacheManager;
+declare const index$6_FunctionDeclaration: typeof FunctionDeclaration;
+type index$6_GeminiContextCacheManager = GeminiContextCacheManager;
+declare const index$6_GeminiContextCacheManager: typeof GeminiContextCacheManager;
+type index$6_GoogleLlm = GoogleLlm;
+declare const index$6_GoogleLlm: typeof GoogleLlm;
+type index$6_HttpScheme = HttpScheme;
+declare const index$6_HttpScheme: typeof HttpScheme;
+type index$6_LLMRegistry = LLMRegistry;
+declare const index$6_LLMRegistry: typeof LLMRegistry;
+type index$6_LlmModel = LlmModel;
+type index$6_LlmModelConfig = LlmModelConfig;
+type index$6_LlmRequest = LlmRequest;
+declare const index$6_LlmRequest: typeof LlmRequest;
+type index$6_LlmResponse = LlmResponse;
+declare const index$6_LlmResponse: typeof LlmResponse;
+type index$6_OAuth2Credential = OAuth2Credential;
+declare const index$6_OAuth2Credential: typeof OAuth2Credential;
+type index$6_OAuth2Scheme = OAuth2Scheme;
+declare const index$6_OAuth2Scheme: typeof OAuth2Scheme;
+type index$6_OAuthFlow = OAuthFlow;
+type index$6_OAuthFlows = OAuthFlows;
+type index$6_OpenAiLlm = OpenAiLlm;
+declare const index$6_OpenAiLlm: typeof OpenAiLlm;
+type index$6_OpenIdConnectScheme = OpenIdConnectScheme;
+declare const index$6_OpenIdConnectScheme: typeof OpenIdConnectScheme;
+type index$6_SearchMemoryResponse = SearchMemoryResponse;
+type index$6_Session = Session;
+type index$6_State = State;
+declare const index$6_State: typeof State;
+type index$6_ThinkingConfig = ThinkingConfig;
+declare const index$6_registerProviders: typeof registerProviders;
+declare namespace index$6 {
+  export { index$6_AiSdkLlm as AiSdkLlm, index$6_AnthropicLlm as AnthropicLlm, index$6_ApiKeyCredential as ApiKeyCredential, index$6_ApiKeyScheme as ApiKeyScheme, index$6_AuthConfig as AuthConfig, index$6_AuthCredential as AuthCredential, index$6_AuthCredentialType as AuthCredentialType, index$6_AuthHandler as AuthHandler, index$6_AuthScheme as AuthScheme, index$6_AuthSchemeType as AuthSchemeType, index$6_BaseLLMConnection as BaseLLMConnection, index$6_BaseLlm as BaseLlm, type index$6_BaseMemoryService as BaseMemoryService, index$6_BasicAuthCredential as BasicAuthCredential, index$6_BearerTokenCredential as BearerTokenCredential, index$6_Blob as Blob, index$6_Content as Content, type index$6_ContextCacheManager as ContextCacheManager, index$6_FunctionDeclaration as FunctionDeclaration, index$6_GeminiContextCacheManager as GeminiContextCacheManager, index$6_GoogleLlm as GoogleLlm, index$6_HttpScheme as HttpScheme, Schema as JSONSchema, index$6_LLMRegistry as LLMRegistry, type index$6_LlmModel as LlmModel, type index$6_LlmModelConfig as LlmModelConfig, index$6_LlmRequest as LlmRequest, index$6_LlmResponse as LlmResponse, index$6_OAuth2Credential as OAuth2Credential, index$6_OAuth2Scheme as OAuth2Scheme, type index$6_OAuthFlow as OAuthFlow, type index$6_OAuthFlows as OAuthFlows, index$6_OpenAiLlm as OpenAiLlm, index$6_OpenIdConnectScheme as OpenIdConnectScheme, type index$6_SearchMemoryResponse as SearchMemoryResponse, type index$6_Session as Session, index$6_State as State, type index$6_ThinkingConfig as ThinkingConfig, index$6_registerProviders as registerProviders };
 }
 
 /**
@@ -4305,6 +4656,7 @@ declare class AgentBuilder<TOut = string, TMulti extends boolean = false> {
     private memoryService?;
     private artifactService?;
     private eventsCompactionConfig?;
+    private contextCacheConfig?;
     private agentType;
     private existingSession?;
     private existingAgent?;
@@ -4526,6 +4878,7 @@ declare class AgentBuilder<TOut = string, TMulti extends boolean = false> {
      * @returns This builder instance for chaining
      */
     withQuickSession(options?: SessionOptions): this;
+    withContextCacheConfig(config: ContextCacheConfig): this;
     /**
      * Build the agent and optionally create runner and session
      * @returns Built agent with optional runner and session
@@ -4707,67 +5060,71 @@ declare class SequentialAgent extends BaseAgent {
     protected runLiveImpl(ctx: InvocationContext): AsyncGenerator<Event, void, unknown>;
 }
 
-type index$4_AfterAgentCallback = AfterAgentCallback;
-type index$4_AfterModelCallback = AfterModelCallback;
-type index$4_AfterToolCallback = AfterToolCallback;
-type index$4_AgentBuilder<TOut = string, TMulti extends boolean = false> = AgentBuilder<TOut, TMulti>;
-declare const index$4_AgentBuilder: typeof AgentBuilder;
-type index$4_AgentBuilderConfig = AgentBuilderConfig;
-type index$4_AgentBuilderWithSchema<T, M extends boolean = false> = AgentBuilderWithSchema<T, M>;
-type index$4_AgentType = AgentType;
-type index$4_BaseAgent = BaseAgent;
-declare const index$4_BaseAgent: typeof BaseAgent;
-type index$4_BeforeAgentCallback = BeforeAgentCallback;
-type index$4_BeforeModelCallback = BeforeModelCallback;
-type index$4_BeforeToolCallback = BeforeToolCallback;
-type index$4_BuiltAgent<T = string, M extends boolean = false> = BuiltAgent<T, M>;
-type index$4_CallbackContext = CallbackContext;
-declare const index$4_CallbackContext: typeof CallbackContext;
-type index$4_EnhancedRunner<T = string, M extends boolean = false> = EnhancedRunner<T, M>;
-type index$4_FullMessage = FullMessage;
-type index$4_InstructionProvider = InstructionProvider;
-type index$4_InvocationContext = InvocationContext;
-declare const index$4_InvocationContext: typeof InvocationContext;
-type index$4_LangGraphAgent = LangGraphAgent;
-declare const index$4_LangGraphAgent: typeof LangGraphAgent;
-type index$4_LangGraphAgentConfig = LangGraphAgentConfig;
-type index$4_LangGraphNode = LangGraphNode;
-type index$4_LlmAgent<T extends BaseLlm = BaseLlm> = LlmAgent<T>;
-declare const index$4_LlmAgent: typeof LlmAgent;
-type index$4_LlmAgentConfig<T extends BaseLlm = BaseLlm> = LlmAgentConfig<T>;
-type index$4_LlmCallsLimitExceededError = LlmCallsLimitExceededError;
-declare const index$4_LlmCallsLimitExceededError: typeof LlmCallsLimitExceededError;
-type index$4_LoopAgent = LoopAgent;
-declare const index$4_LoopAgent: typeof LoopAgent;
-type index$4_LoopAgentConfig = LoopAgentConfig;
-type index$4_MessagePart = MessagePart;
-type index$4_MultiAgentResponse = MultiAgentResponse;
-type index$4_ParallelAgent = ParallelAgent;
-declare const index$4_ParallelAgent: typeof ParallelAgent;
-type index$4_ParallelAgentConfig = ParallelAgentConfig;
-type index$4_ReadonlyContext = ReadonlyContext;
-declare const index$4_ReadonlyContext: typeof ReadonlyContext;
-type index$4_RunConfig = RunConfig;
-declare const index$4_RunConfig: typeof RunConfig;
-type index$4_RunnerAskReturn<T, M extends boolean> = RunnerAskReturn<T, M>;
-type index$4_SequentialAgent = SequentialAgent;
-declare const index$4_SequentialAgent: typeof SequentialAgent;
-type index$4_SequentialAgentConfig = SequentialAgentConfig;
-type index$4_SessionOptions = SessionOptions;
-type index$4_SingleAfterModelCallback = SingleAfterModelCallback;
-type index$4_SingleAfterToolCallback = SingleAfterToolCallback;
-type index$4_SingleAgentCallback = SingleAgentCallback;
-type index$4_SingleBeforeModelCallback = SingleBeforeModelCallback;
-type index$4_SingleBeforeToolCallback = SingleBeforeToolCallback;
-type index$4_StreamingMode = StreamingMode;
-declare const index$4_StreamingMode: typeof StreamingMode;
-type index$4_ToolUnion = ToolUnion;
-type index$4_TransferContext = TransferContext;
-declare const index$4_createBranchContextForSubAgent: typeof createBranchContextForSubAgent;
-declare const index$4_mergeAgentRun: typeof mergeAgentRun;
-declare const index$4_newInvocationContextId: typeof newInvocationContextId;
-declare namespace index$4 {
-  export { type index$4_AfterAgentCallback as AfterAgentCallback, type index$4_AfterModelCallback as AfterModelCallback, type index$4_AfterToolCallback as AfterToolCallback, LlmAgent as Agent, index$4_AgentBuilder as AgentBuilder, type index$4_AgentBuilderConfig as AgentBuilderConfig, type index$4_AgentBuilderWithSchema as AgentBuilderWithSchema, type index$4_AgentType as AgentType, index$4_BaseAgent as BaseAgent, type index$4_BeforeAgentCallback as BeforeAgentCallback, type index$4_BeforeModelCallback as BeforeModelCallback, type index$4_BeforeToolCallback as BeforeToolCallback, type index$4_BuiltAgent as BuiltAgent, index$4_CallbackContext as CallbackContext, type index$4_EnhancedRunner as EnhancedRunner, type index$4_FullMessage as FullMessage, type index$4_InstructionProvider as InstructionProvider, index$4_InvocationContext as InvocationContext, index$4_LangGraphAgent as LangGraphAgent, type index$4_LangGraphAgentConfig as LangGraphAgentConfig, type index$4_LangGraphNode as LangGraphNode, index$4_LlmAgent as LlmAgent, type index$4_LlmAgentConfig as LlmAgentConfig, index$4_LlmCallsLimitExceededError as LlmCallsLimitExceededError, index$4_LoopAgent as LoopAgent, type index$4_LoopAgentConfig as LoopAgentConfig, type index$4_MessagePart as MessagePart, type index$4_MultiAgentResponse as MultiAgentResponse, index$4_ParallelAgent as ParallelAgent, type index$4_ParallelAgentConfig as ParallelAgentConfig, index$4_ReadonlyContext as ReadonlyContext, index$4_RunConfig as RunConfig, type index$4_RunnerAskReturn as RunnerAskReturn, index$4_SequentialAgent as SequentialAgent, type index$4_SequentialAgentConfig as SequentialAgentConfig, type index$4_SessionOptions as SessionOptions, type index$4_SingleAfterModelCallback as SingleAfterModelCallback, type index$4_SingleAfterToolCallback as SingleAfterToolCallback, type index$4_SingleAgentCallback as SingleAgentCallback, type index$4_SingleBeforeModelCallback as SingleBeforeModelCallback, type index$4_SingleBeforeToolCallback as SingleBeforeToolCallback, index$4_StreamingMode as StreamingMode, type index$4_ToolUnion as ToolUnion, type index$4_TransferContext as TransferContext, index$4_createBranchContextForSubAgent as createBranchContextForSubAgent, index$4_mergeAgentRun as mergeAgentRun, index$4_newInvocationContextId as newInvocationContextId };
+type index$5_AfterAgentCallback = AfterAgentCallback;
+type index$5_AfterModelCallback = AfterModelCallback;
+type index$5_AfterToolCallback = AfterToolCallback;
+type index$5_AgentBuilder<TOut = string, TMulti extends boolean = false> = AgentBuilder<TOut, TMulti>;
+declare const index$5_AgentBuilder: typeof AgentBuilder;
+type index$5_AgentBuilderConfig = AgentBuilderConfig;
+type index$5_AgentBuilderWithSchema<T, M extends boolean = false> = AgentBuilderWithSchema<T, M>;
+type index$5_AgentType = AgentType;
+type index$5_BaseAgent = BaseAgent;
+declare const index$5_BaseAgent: typeof BaseAgent;
+type index$5_BeforeAgentCallback = BeforeAgentCallback;
+type index$5_BeforeModelCallback = BeforeModelCallback;
+type index$5_BeforeToolCallback = BeforeToolCallback;
+type index$5_BuiltAgent<T = string, M extends boolean = false> = BuiltAgent<T, M>;
+type index$5_CallbackContext = CallbackContext;
+declare const index$5_CallbackContext: typeof CallbackContext;
+type index$5_ContextCacheConfig = ContextCacheConfig;
+declare const index$5_ContextCacheConfig: typeof ContextCacheConfig;
+type index$5_ContextCacheConfigProps = ContextCacheConfigProps;
+type index$5_EnhancedRunner<T = string, M extends boolean = false> = EnhancedRunner<T, M>;
+type index$5_FullMessage = FullMessage;
+type index$5_InstructionProvider = InstructionProvider;
+type index$5_InvocationContext = InvocationContext;
+declare const index$5_InvocationContext: typeof InvocationContext;
+type index$5_LangGraphAgent = LangGraphAgent;
+declare const index$5_LangGraphAgent: typeof LangGraphAgent;
+type index$5_LangGraphAgentConfig = LangGraphAgentConfig;
+type index$5_LangGraphNode = LangGraphNode;
+type index$5_LlmAgent<T extends BaseLlm = BaseLlm> = LlmAgent<T>;
+declare const index$5_LlmAgent: typeof LlmAgent;
+type index$5_LlmAgentConfig<T extends BaseLlm = BaseLlm> = LlmAgentConfig<T>;
+type index$5_LlmCallsLimitExceededError = LlmCallsLimitExceededError;
+declare const index$5_LlmCallsLimitExceededError: typeof LlmCallsLimitExceededError;
+type index$5_LoopAgent = LoopAgent;
+declare const index$5_LoopAgent: typeof LoopAgent;
+type index$5_LoopAgentConfig = LoopAgentConfig;
+type index$5_MessagePart = MessagePart;
+type index$5_MultiAgentResponse = MultiAgentResponse;
+type index$5_ParallelAgent = ParallelAgent;
+declare const index$5_ParallelAgent: typeof ParallelAgent;
+type index$5_ParallelAgentConfig = ParallelAgentConfig;
+type index$5_ReadonlyContext = ReadonlyContext;
+declare const index$5_ReadonlyContext: typeof ReadonlyContext;
+type index$5_RunConfig = RunConfig;
+declare const index$5_RunConfig: typeof RunConfig;
+type index$5_RunnerAskReturn<T, M extends boolean> = RunnerAskReturn<T, M>;
+type index$5_SequentialAgent = SequentialAgent;
+declare const index$5_SequentialAgent: typeof SequentialAgent;
+type index$5_SequentialAgentConfig = SequentialAgentConfig;
+type index$5_SessionOptions = SessionOptions;
+type index$5_SingleAfterModelCallback = SingleAfterModelCallback;
+type index$5_SingleAfterToolCallback = SingleAfterToolCallback;
+type index$5_SingleAgentCallback = SingleAgentCallback;
+type index$5_SingleBeforeModelCallback = SingleBeforeModelCallback;
+type index$5_SingleBeforeToolCallback = SingleBeforeToolCallback;
+type index$5_StreamingMode = StreamingMode;
+declare const index$5_StreamingMode: typeof StreamingMode;
+type index$5_ToolUnion = ToolUnion;
+type index$5_TransferContext = TransferContext;
+declare const index$5_contextCacheConfigSchema: typeof contextCacheConfigSchema;
+declare const index$5_createBranchContextForSubAgent: typeof createBranchContextForSubAgent;
+declare const index$5_mergeAgentRun: typeof mergeAgentRun;
+declare const index$5_newInvocationContextId: typeof newInvocationContextId;
+declare namespace index$5 {
+  export { type index$5_AfterAgentCallback as AfterAgentCallback, type index$5_AfterModelCallback as AfterModelCallback, type index$5_AfterToolCallback as AfterToolCallback, LlmAgent as Agent, index$5_AgentBuilder as AgentBuilder, type index$5_AgentBuilderConfig as AgentBuilderConfig, type index$5_AgentBuilderWithSchema as AgentBuilderWithSchema, type index$5_AgentType as AgentType, index$5_BaseAgent as BaseAgent, type index$5_BeforeAgentCallback as BeforeAgentCallback, type index$5_BeforeModelCallback as BeforeModelCallback, type index$5_BeforeToolCallback as BeforeToolCallback, type index$5_BuiltAgent as BuiltAgent, index$5_CallbackContext as CallbackContext, index$5_ContextCacheConfig as ContextCacheConfig, type index$5_ContextCacheConfigProps as ContextCacheConfigProps, type index$5_EnhancedRunner as EnhancedRunner, type index$5_FullMessage as FullMessage, type index$5_InstructionProvider as InstructionProvider, index$5_InvocationContext as InvocationContext, index$5_LangGraphAgent as LangGraphAgent, type index$5_LangGraphAgentConfig as LangGraphAgentConfig, type index$5_LangGraphNode as LangGraphNode, index$5_LlmAgent as LlmAgent, type index$5_LlmAgentConfig as LlmAgentConfig, index$5_LlmCallsLimitExceededError as LlmCallsLimitExceededError, index$5_LoopAgent as LoopAgent, type index$5_LoopAgentConfig as LoopAgentConfig, type index$5_MessagePart as MessagePart, type index$5_MultiAgentResponse as MultiAgentResponse, index$5_ParallelAgent as ParallelAgent, type index$5_ParallelAgentConfig as ParallelAgentConfig, index$5_ReadonlyContext as ReadonlyContext, index$5_RunConfig as RunConfig, type index$5_RunnerAskReturn as RunnerAskReturn, index$5_SequentialAgent as SequentialAgent, type index$5_SequentialAgentConfig as SequentialAgentConfig, type index$5_SessionOptions as SessionOptions, type index$5_SingleAfterModelCallback as SingleAfterModelCallback, type index$5_SingleAfterToolCallback as SingleAfterToolCallback, type index$5_SingleAgentCallback as SingleAgentCallback, type index$5_SingleBeforeModelCallback as SingleBeforeModelCallback, type index$5_SingleBeforeToolCallback as SingleBeforeToolCallback, index$5_StreamingMode as StreamingMode, type index$5_ToolUnion as ToolUnion, type index$5_TransferContext as TransferContext, index$5_contextCacheConfigSchema as contextCacheConfigSchema, index$5_createBranchContextForSubAgent as createBranchContextForSubAgent, index$5_mergeAgentRun as mergeAgentRun, index$5_newInvocationContextId as newInvocationContextId };
 }
 
 interface ParsedArtifactUri {
@@ -5158,46 +5515,62 @@ declare class SafetyEvaluatorV1 extends Evaluator {
     evaluateInvocations(actualInvocations: Invocation[], expectedInvocations: Invocation[]): Promise<EvaluationResult>;
 }
 
-type index$3_AgentEvaluator = AgentEvaluator;
-declare const index$3_AgentEvaluator: typeof AgentEvaluator;
-type index$3_EvalCase = EvalCase;
-type index$3_EvalCaseResult = EvalCaseResult;
-type index$3_EvalMetric = EvalMetric;
-type index$3_EvalMetricResult = EvalMetricResult;
-type index$3_EvalMetricResultPerInvocation = EvalMetricResultPerInvocation;
-type index$3_EvalResult = EvalResult;
-declare const index$3_EvalResult: typeof EvalResult;
-type index$3_EvalSet = EvalSet;
-type index$3_EvalSetResult = EvalSetResult;
-type index$3_EvalStatus = EvalStatus;
-declare const index$3_EvalStatus: typeof EvalStatus;
-type index$3_EvaluateConfig = EvaluateConfig;
-type index$3_EvaluationResult = EvaluationResult;
-type index$3_Evaluator = Evaluator;
-declare const index$3_Evaluator: typeof Evaluator;
-type index$3_FinalResponseMatchV2Evaluator = FinalResponseMatchV2Evaluator;
-declare const index$3_FinalResponseMatchV2Evaluator: typeof FinalResponseMatchV2Evaluator;
-type index$3_IntermediateData = IntermediateData;
-type index$3_Interval = Interval;
-type index$3_Invocation = Invocation;
-type index$3_JudgeModelOptions = JudgeModelOptions;
-type index$3_LocalEvalService = LocalEvalService;
-declare const index$3_LocalEvalService: typeof LocalEvalService;
-type index$3_MetricInfo = MetricInfo;
-type index$3_MetricValueInfo = MetricValueInfo;
-type index$3_PerInvocationResult = PerInvocationResult;
-type index$3_PrebuiltMetrics = PrebuiltMetrics;
-declare const index$3_PrebuiltMetrics: typeof PrebuiltMetrics;
-type index$3_RougeEvaluator = RougeEvaluator;
-declare const index$3_RougeEvaluator: typeof RougeEvaluator;
-type index$3_SafetyEvaluatorV1 = SafetyEvaluatorV1;
-declare const index$3_SafetyEvaluatorV1: typeof SafetyEvaluatorV1;
-type index$3_SessionInput = SessionInput;
-type index$3_TrajectoryEvaluator = TrajectoryEvaluator;
-declare const index$3_TrajectoryEvaluator: typeof TrajectoryEvaluator;
-declare namespace index$3 {
-  export { index$3_AgentEvaluator as AgentEvaluator, type index$3_EvalCase as EvalCase, type index$3_EvalCaseResult as EvalCaseResult, type index$3_EvalMetric as EvalMetric, type index$3_EvalMetricResult as EvalMetricResult, type index$3_EvalMetricResultPerInvocation as EvalMetricResultPerInvocation, index$3_EvalResult as EvalResult, type index$3_EvalSet as EvalSet, type index$3_EvalSetResult as EvalSetResult, index$3_EvalStatus as EvalStatus, type index$3_EvaluateConfig as EvaluateConfig, type index$3_EvaluationResult as EvaluationResult, index$3_Evaluator as Evaluator, index$3_FinalResponseMatchV2Evaluator as FinalResponseMatchV2Evaluator, type index$3_IntermediateData as IntermediateData, type index$3_Interval as Interval, type index$3_Invocation as Invocation, type index$3_JudgeModelOptions as JudgeModelOptions, index$3_LocalEvalService as LocalEvalService, type index$3_MetricInfo as MetricInfo, type index$3_MetricValueInfo as MetricValueInfo, type index$3_PerInvocationResult as PerInvocationResult, index$3_PrebuiltMetrics as PrebuiltMetrics, index$3_RougeEvaluator as RougeEvaluator, index$3_SafetyEvaluatorV1 as SafetyEvaluatorV1, type index$3_SessionInput as SessionInput, index$3_TrajectoryEvaluator as TrajectoryEvaluator };
+type index$4_AgentEvaluator = AgentEvaluator;
+declare const index$4_AgentEvaluator: typeof AgentEvaluator;
+type index$4_EvalCase = EvalCase;
+type index$4_EvalCaseResult = EvalCaseResult;
+type index$4_EvalMetric = EvalMetric;
+type index$4_EvalMetricResult = EvalMetricResult;
+type index$4_EvalMetricResultPerInvocation = EvalMetricResultPerInvocation;
+type index$4_EvalResult = EvalResult;
+declare const index$4_EvalResult: typeof EvalResult;
+type index$4_EvalSet = EvalSet;
+type index$4_EvalSetResult = EvalSetResult;
+type index$4_EvalStatus = EvalStatus;
+declare const index$4_EvalStatus: typeof EvalStatus;
+type index$4_EvaluateConfig = EvaluateConfig;
+type index$4_EvaluationResult = EvaluationResult;
+type index$4_Evaluator = Evaluator;
+declare const index$4_Evaluator: typeof Evaluator;
+type index$4_FinalResponseMatchV2Evaluator = FinalResponseMatchV2Evaluator;
+declare const index$4_FinalResponseMatchV2Evaluator: typeof FinalResponseMatchV2Evaluator;
+type index$4_IntermediateData = IntermediateData;
+type index$4_Interval = Interval;
+type index$4_Invocation = Invocation;
+type index$4_JudgeModelOptions = JudgeModelOptions;
+type index$4_LocalEvalService = LocalEvalService;
+declare const index$4_LocalEvalService: typeof LocalEvalService;
+type index$4_MetricInfo = MetricInfo;
+type index$4_MetricValueInfo = MetricValueInfo;
+type index$4_PerInvocationResult = PerInvocationResult;
+type index$4_PrebuiltMetrics = PrebuiltMetrics;
+declare const index$4_PrebuiltMetrics: typeof PrebuiltMetrics;
+type index$4_RougeEvaluator = RougeEvaluator;
+declare const index$4_RougeEvaluator: typeof RougeEvaluator;
+type index$4_SafetyEvaluatorV1 = SafetyEvaluatorV1;
+declare const index$4_SafetyEvaluatorV1: typeof SafetyEvaluatorV1;
+type index$4_SessionInput = SessionInput;
+type index$4_TrajectoryEvaluator = TrajectoryEvaluator;
+declare const index$4_TrajectoryEvaluator: typeof TrajectoryEvaluator;
+declare namespace index$4 {
+  export { index$4_AgentEvaluator as AgentEvaluator, type index$4_EvalCase as EvalCase, type index$4_EvalCaseResult as EvalCaseResult, type index$4_EvalMetric as EvalMetric, type index$4_EvalMetricResult as EvalMetricResult, type index$4_EvalMetricResultPerInvocation as EvalMetricResultPerInvocation, index$4_EvalResult as EvalResult, type index$4_EvalSet as EvalSet, type index$4_EvalSetResult as EvalSetResult, index$4_EvalStatus as EvalStatus, type index$4_EvaluateConfig as EvaluateConfig, type index$4_EvaluationResult as EvaluationResult, index$4_Evaluator as Evaluator, index$4_FinalResponseMatchV2Evaluator as FinalResponseMatchV2Evaluator, type index$4_IntermediateData as IntermediateData, type index$4_Interval as Interval, type index$4_Invocation as Invocation, type index$4_JudgeModelOptions as JudgeModelOptions, index$4_LocalEvalService as LocalEvalService, type index$4_MetricInfo as MetricInfo, type index$4_MetricValueInfo as MetricValueInfo, type index$4_PerInvocationResult as PerInvocationResult, index$4_PrebuiltMetrics as PrebuiltMetrics, index$4_RougeEvaluator as RougeEvaluator, index$4_SafetyEvaluatorV1 as SafetyEvaluatorV1, type index$4_SessionInput as SessionInput, index$4_TrajectoryEvaluator as TrajectoryEvaluator };
+}
+
+/**
+ * Agent transfer request processor that enables agent transfer functionality
+ * for AutoFlow by adding transfer instructions and tools to the LLM request
+ */
+declare class AgentTransferLlmRequestProcessor extends BaseLlmRequestProcessor {
+    /**
+     * Processes agent transfer by adding transfer instructions and tools
+     * if the agent has transfer targets available
+     */
+    runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event>;
 }
+/**
+ * Exported request processor instance for use in AutoFlow
+ */
+declare const requestProcessor$6: AgentTransferLlmRequestProcessor;
 
 declare abstract class BaseLlmFlow {
     requestProcessors: Array<any>;
@@ -5224,13 +5597,8 @@ declare abstract class BaseLlmFlow {
  *
  * A single flow only considers an agent itself and tools.
  * No sub-agents are allowed for single flow.
- *
- * This matches the Python implementation's SingleFlow class.
  */
 declare class SingleFlow extends BaseLlmFlow {
-    /**
-     * Constructor for SingleFlow
-     */
     constructor();
 }
 
@@ -5269,35 +5637,25 @@ declare class BasicLlmRequestProcessor extends BaseLlmRequestProcessor {
 /**
  * Exported instance of the basic request processor
  */
-declare const requestProcessor$6: BasicLlmRequestProcessor;
+declare const requestProcessor$5: BasicLlmRequestProcessor;
 
 /**
- * Identity LLM request processor that gives the agent identity from the framework.
- * This processor adds the agent's name and description to the system instructions.
+ * Request processor for code execution
  */
-declare class IdentityLlmRequestProcessor extends BaseLlmRequestProcessor {
-    runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event, void, unknown>;
+declare class CodeExecutionRequestProcessor extends BaseLlmRequestProcessor {
+    runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event>;
 }
 /**
- * Exported instance of the identity request processor
- */
-declare const requestProcessor$5: IdentityLlmRequestProcessor;
-
-/**
- * Instructions LLM request processor that handles instructions and global instructions.
- * This processor adds both global instructions (from root agent) and agent-specific instructions.
+ * Response processor for code execution
  */
-declare class InstructionsLlmRequestProcessor extends BaseLlmRequestProcessor {
-    runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event, void, unknown>;
-    /**
-     * Type guard to check if agent is an LlmAgent
-     */
-    private isLlmAgent;
+declare class CodeExecutionResponseProcessor extends BaseLlmResponseProcessor {
+    runAsync(invocationContext: InvocationContext, llmResponse: LlmResponse): AsyncGenerator<Event>;
 }
 /**
- * Exported instance of the instructions request processor
+ * Exported processor instances
  */
-declare const requestProcessor$4: InstructionsLlmRequestProcessor;
+declare const requestProcessor$4: CodeExecutionRequestProcessor;
+declare const responseProcessor$1: CodeExecutionResponseProcessor;
 
 /**
  * Content LLM request processor that builds the contents for the LLM request.
@@ -5315,63 +5673,6 @@ declare class ContentLlmRequestProcessor extends BaseLlmRequestProcessor {
  */
 declare const requestProcessor$3: ContentLlmRequestProcessor;
 
-/**
- * Agent transfer request processor that enables agent transfer functionality
- * for AutoFlow by adding transfer instructions and tools to the LLM request
- */
-declare class AgentTransferLlmRequestProcessor extends BaseLlmRequestProcessor {
-    /**
-     * Processes agent transfer by adding transfer instructions and tools
-     * if the agent has transfer targets available
-     */
-    runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event>;
-}
-/**
- * Exported request processor instance for use in AutoFlow
- */
-declare const requestProcessor$2: AgentTransferLlmRequestProcessor;
-
-/**
- * Request processor for Natural Language Planning
- * Applies planning instructions and configurations to LLM requests
- */
-declare class NlPlanningRequestProcessor extends BaseLlmRequestProcessor {
-    runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event>;
-}
-/**
- * Response processor for Natural Language Planning
- * Processes LLM responses to handle planning content and state updates
- */
-declare class NlPlanningResponseProcessor extends BaseLlmResponseProcessor {
-    runAsync(invocationContext: InvocationContext, llmResponse: LlmResponse): AsyncGenerator<Event>;
-}
-/**
- * Exported request processor instance for use in flow configurations
- */
-declare const requestProcessor$1: NlPlanningRequestProcessor;
-/**
- * Exported response processor instance for use in flow configurations
- */
-declare const responseProcessor$1: NlPlanningResponseProcessor;
-
-/**
- * Request processor for code execution
- */
-declare class CodeExecutionRequestProcessor extends BaseLlmRequestProcessor {
-    runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event>;
-}
-/**
- * Response processor for code execution
- */
-declare class CodeExecutionResponseProcessor extends BaseLlmResponseProcessor {
-    runAsync(invocationContext: InvocationContext, llmResponse: LlmResponse): AsyncGenerator<Event>;
-}
-/**
- * Exported processor instances
- */
-declare const requestProcessor: CodeExecutionRequestProcessor;
-declare const responseProcessor: CodeExecutionResponseProcessor;
-
 declare const AF_FUNCTION_CALL_ID_PREFIX = "adk-";
 declare const REQUEST_EUC_FUNCTION_CALL_NAME = "adk_request_credential";
 /**
@@ -5407,28 +5708,79 @@ declare function handleFunctionCallsLive(invocationContext: InvocationContext, f
  */
 declare function mergeParallelFunctionResponseEvents(functionResponseEvents: Event[]): Event;
 
-declare const index$2_AF_FUNCTION_CALL_ID_PREFIX: typeof AF_FUNCTION_CALL_ID_PREFIX;
-type index$2_AutoFlow = AutoFlow;
-declare const index$2_AutoFlow: typeof AutoFlow;
-type index$2_BaseLlmFlow = BaseLlmFlow;
-declare const index$2_BaseLlmFlow: typeof BaseLlmFlow;
-type index$2_BaseLlmRequestProcessor = BaseLlmRequestProcessor;
-declare const index$2_BaseLlmRequestProcessor: typeof BaseLlmRequestProcessor;
-type index$2_BaseLlmResponseProcessor = BaseLlmResponseProcessor;
-declare const index$2_BaseLlmResponseProcessor: typeof BaseLlmResponseProcessor;
-declare const index$2_REQUEST_EUC_FUNCTION_CALL_NAME: typeof REQUEST_EUC_FUNCTION_CALL_NAME;
-type index$2_SingleFlow = SingleFlow;
-declare const index$2_SingleFlow: typeof SingleFlow;
-declare const index$2_generateAuthEvent: typeof generateAuthEvent;
-declare const index$2_generateClientFunctionCallId: typeof generateClientFunctionCallId;
-declare const index$2_getLongRunningFunctionCalls: typeof getLongRunningFunctionCalls;
-declare const index$2_handleFunctionCallsAsync: typeof handleFunctionCallsAsync;
-declare const index$2_handleFunctionCallsLive: typeof handleFunctionCallsLive;
-declare const index$2_mergeParallelFunctionResponseEvents: typeof mergeParallelFunctionResponseEvents;
-declare const index$2_populateClientFunctionCallId: typeof populateClientFunctionCallId;
-declare const index$2_removeClientFunctionCallId: typeof removeClientFunctionCallId;
-declare namespace index$2 {
-  export { index$2_AF_FUNCTION_CALL_ID_PREFIX as AF_FUNCTION_CALL_ID_PREFIX, index$2_AutoFlow as AutoFlow, index$2_BaseLlmFlow as BaseLlmFlow, index$2_BaseLlmRequestProcessor as BaseLlmRequestProcessor, index$2_BaseLlmResponseProcessor as BaseLlmResponseProcessor, index$2_REQUEST_EUC_FUNCTION_CALL_NAME as REQUEST_EUC_FUNCTION_CALL_NAME, index$2_SingleFlow as SingleFlow, requestProcessor$2 as agentTransferRequestProcessor, requestProcessor$6 as basicRequestProcessor, requestProcessor as codeExecutionRequestProcessor, responseProcessor as codeExecutionResponseProcessor, requestProcessor$3 as contentRequestProcessor, index$2_generateAuthEvent as generateAuthEvent, index$2_generateClientFunctionCallId as generateClientFunctionCallId, index$2_getLongRunningFunctionCalls as getLongRunningFunctionCalls, index$2_handleFunctionCallsAsync as handleFunctionCallsAsync, index$2_handleFunctionCallsLive as handleFunctionCallsLive, requestProcessor$5 as identityRequestProcessor, requestProcessor$4 as instructionsRequestProcessor, index$2_mergeParallelFunctionResponseEvents as mergeParallelFunctionResponseEvents, requestProcessor$1 as nlPlanningRequestProcessor, responseProcessor$1 as nlPlanningResponseProcessor, index$2_populateClientFunctionCallId as populateClientFunctionCallId, index$2_removeClientFunctionCallId as removeClientFunctionCallId };
+/**
+ * Identity LLM request processor that gives the agent identity from the framework.
+ * This processor adds the agent's name and description to the system instructions.
+ */
+declare class IdentityLlmRequestProcessor extends BaseLlmRequestProcessor {
+    runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event, void, unknown>;
+}
+/**
+ * Exported instance of the identity request processor
+ */
+declare const requestProcessor$2: IdentityLlmRequestProcessor;
+
+/**
+ * Instructions LLM request processor that handles instructions and global instructions.
+ * This processor adds both global instructions (from root agent) and agent-specific instructions.
+ */
+declare class InstructionsLlmRequestProcessor extends BaseLlmRequestProcessor {
+    runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event, void, unknown>;
+    /**
+     * Type guard to check if agent is an LlmAgent
+     */
+    private isLlmAgent;
+}
+/**
+ * Exported instance of the instructions request processor
+ */
+declare const requestProcessor$1: InstructionsLlmRequestProcessor;
+
+/**
+ * Request processor for Natural Language Planning
+ * Applies planning instructions and configurations to LLM requests
+ */
+declare class NlPlanningRequestProcessor extends BaseLlmRequestProcessor {
+    runAsync(invocationContext: InvocationContext, llmRequest: LlmRequest): AsyncGenerator<Event>;
+}
+/**
+ * Response processor for Natural Language Planning
+ * Processes LLM responses to handle planning content and state updates
+ */
+declare class NlPlanningResponseProcessor extends BaseLlmResponseProcessor {
+    runAsync(invocationContext: InvocationContext, llmResponse: LlmResponse): AsyncGenerator<Event>;
+}
+/**
+ * Exported request processor instance for use in flow configurations
+ */
+declare const requestProcessor: NlPlanningRequestProcessor;
+/**
+ * Exported response processor instance for use in flow configurations
+ */
+declare const responseProcessor: NlPlanningResponseProcessor;
+
+declare const index$3_AF_FUNCTION_CALL_ID_PREFIX: typeof AF_FUNCTION_CALL_ID_PREFIX;
+type index$3_AutoFlow = AutoFlow;
+declare const index$3_AutoFlow: typeof AutoFlow;
+type index$3_BaseLlmFlow = BaseLlmFlow;
+declare const index$3_BaseLlmFlow: typeof BaseLlmFlow;
+type index$3_BaseLlmRequestProcessor = BaseLlmRequestProcessor;
+declare const index$3_BaseLlmRequestProcessor: typeof BaseLlmRequestProcessor;
+type index$3_BaseLlmResponseProcessor = BaseLlmResponseProcessor;
+declare const index$3_BaseLlmResponseProcessor: typeof BaseLlmResponseProcessor;
+declare const index$3_REQUEST_EUC_FUNCTION_CALL_NAME: typeof REQUEST_EUC_FUNCTION_CALL_NAME;
+type index$3_SingleFlow = SingleFlow;
+declare const index$3_SingleFlow: typeof SingleFlow;
+declare const index$3_generateAuthEvent: typeof generateAuthEvent;
+declare const index$3_generateClientFunctionCallId: typeof generateClientFunctionCallId;
+declare const index$3_getLongRunningFunctionCalls: typeof getLongRunningFunctionCalls;
+declare const index$3_handleFunctionCallsAsync: typeof handleFunctionCallsAsync;
+declare const index$3_handleFunctionCallsLive: typeof handleFunctionCallsLive;
+declare const index$3_mergeParallelFunctionResponseEvents: typeof mergeParallelFunctionResponseEvents;
+declare const index$3_populateClientFunctionCallId: typeof populateClientFunctionCallId;
+declare const index$3_removeClientFunctionCallId: typeof removeClientFunctionCallId;
+declare namespace index$3 {
+  export { index$3_AF_FUNCTION_CALL_ID_PREFIX as AF_FUNCTION_CALL_ID_PREFIX, index$3_AutoFlow as AutoFlow, index$3_BaseLlmFlow as BaseLlmFlow, index$3_BaseLlmRequestProcessor as BaseLlmRequestProcessor, index$3_BaseLlmResponseProcessor as BaseLlmResponseProcessor, index$3_REQUEST_EUC_FUNCTION_CALL_NAME as REQUEST_EUC_FUNCTION_CALL_NAME, index$3_SingleFlow as SingleFlow, requestProcessor$6 as agentTransferRequestProcessor, requestProcessor$5 as basicRequestProcessor, requestProcessor$4 as codeExecutionRequestProcessor, responseProcessor$1 as codeExecutionResponseProcessor, requestProcessor$3 as contentRequestProcessor, index$3_generateAuthEvent as generateAuthEvent, index$3_generateClientFunctionCallId as generateClientFunctionCallId, index$3_getLongRunningFunctionCalls as getLongRunningFunctionCalls, index$3_handleFunctionCallsAsync as handleFunctionCallsAsync, index$3_handleFunctionCallsLive as handleFunctionCallsLive, requestProcessor$2 as identityRequestProcessor, requestProcessor$1 as instructionsRequestProcessor, index$3_mergeParallelFunctionResponseEvents as mergeParallelFunctionResponseEvents, requestProcessor as nlPlanningRequestProcessor, responseProcessor as nlPlanningResponseProcessor, index$3_populateClientFunctionCallId as populateClientFunctionCallId, index$3_removeClientFunctionCallId as removeClientFunctionCallId };
 }
 
 /**
@@ -5510,12 +5862,12 @@ declare class VertexAiRagMemoryService implements BaseMemoryService {
  * Memory Services for the Agent Development Kit
  */
 
-type index$1_InMemoryMemoryService = InMemoryMemoryService;
-declare const index$1_InMemoryMemoryService: typeof InMemoryMemoryService;
-type index$1_VertexAiRagMemoryService = VertexAiRagMemoryService;
-declare const index$1_VertexAiRagMemoryService: typeof VertexAiRagMemoryService;
-declare namespace index$1 {
-  export { index$1_InMemoryMemoryService as InMemoryMemoryService, index$1_VertexAiRagMemoryService as VertexAiRagMemoryService };
+type index$2_InMemoryMemoryService = InMemoryMemoryService;
+declare const index$2_InMemoryMemoryService: typeof InMemoryMemoryService;
+type index$2_VertexAiRagMemoryService = VertexAiRagMemoryService;
+declare const index$2_VertexAiRagMemoryService: typeof VertexAiRagMemoryService;
+declare namespace index$2 {
+  export { index$2_InMemoryMemoryService as InMemoryMemoryService, index$2_VertexAiRagMemoryService as VertexAiRagMemoryService };
 }
 
 /**
@@ -5738,6 +6090,27 @@ declare class ReflectAndRetryToolPlugin extends BasePlugin {
     private _formatArgs;
 }
 
+type index$1_BasePlugin = BasePlugin;
+declare const index$1_BasePlugin: typeof BasePlugin;
+type index$1_LangfusePlugin = LangfusePlugin;
+declare const index$1_LangfusePlugin: typeof LangfusePlugin;
+type index$1_LangfusePluginOptions = LangfusePluginOptions;
+type index$1_PerToolFailuresCounter = PerToolFailuresCounter;
+type index$1_PluginCallbackName = PluginCallbackName;
+type index$1_PluginManager = PluginManager;
+declare const index$1_PluginManager: typeof PluginManager;
+declare const index$1_REFLECT_AND_RETRY_RESPONSE_TYPE: typeof REFLECT_AND_RETRY_RESPONSE_TYPE;
+type index$1_ReflectAndRetryToolPlugin = ReflectAndRetryToolPlugin;
+declare const index$1_ReflectAndRetryToolPlugin: typeof ReflectAndRetryToolPlugin;
+type index$1_ReflectAndRetryToolPluginOptions = ReflectAndRetryToolPluginOptions;
+type index$1_ToolFailureResponse = ToolFailureResponse;
+type index$1_TrackingScope = TrackingScope;
+declare const index$1_TrackingScope: typeof TrackingScope;
+declare const index$1_pluginCallbackNameSchema: typeof pluginCallbackNameSchema;
+declare namespace index$1 {
+  export { index$1_BasePlugin as BasePlugin, index$1_LangfusePlugin as LangfusePlugin, type index$1_LangfusePluginOptions as LangfusePluginOptions, type index$1_PerToolFailuresCounter as PerToolFailuresCounter, type index$1_PluginCallbackName as PluginCallbackName, index$1_PluginManager as PluginManager, index$1_REFLECT_AND_RETRY_RESPONSE_TYPE as REFLECT_AND_RETRY_RESPONSE_TYPE, index$1_ReflectAndRetryToolPlugin as ReflectAndRetryToolPlugin, type index$1_ReflectAndRetryToolPluginOptions as ReflectAndRetryToolPluginOptions, type index$1_ToolFailureResponse as ToolFailureResponse, index$1_TrackingScope as TrackingScope, index$1_pluginCallbackNameSchema as pluginCallbackNameSchema };
+}
+
 /**
  * An in-memory implementation of the session service.
  */
@@ -6035,17 +6408,22 @@ declare class Runner<T extends BaseAgent = BaseAgent> {
      * Configuration for event compaction.
      */
     eventsCompactionConfig?: EventsCompactionConfig;
+    /**
+     * The context cache config for the runner.
+     */
+    contextCacheConfig?: ContextCacheConfig;
     protected logger: Logger;
     /**
      * Initializes the Runner.
      */
-    constructor({ appName, agent, artifactService, sessionService, memoryService, eventsCompactionConfig, plugins, pluginCloseTimeout, }: {
+    constructor({ appName, agent, artifactService, sessionService, memoryService, eventsCompactionConfig, contextCacheConfig, plugins, pluginCloseTimeout, }: {
         appName: string;
         agent: T;
         artifactService?: BaseArtifactService;
         sessionService: BaseSessionService;
         memoryService?: BaseMemoryService;
         eventsCompactionConfig?: EventsCompactionConfig;
+        contextCacheConfig?: ContextCacheConfig;
         plugins?: BasePlugin[];
         pluginCloseTimeout?: number;
     });
@@ -6709,4 +7087,4 @@ declare const recordLlmCall: (dimensions: LlmMetricDimensions) => void;
 
 declare const VERSION = "0.1.0";
 
-export { ADK_ATTRS, ADK_SYSTEM_NAME, AF_FUNCTION_CALL_ID_PREFIX, type AfterAgentCallback, type AfterModelCallback, type AfterToolCallback, LlmAgent as Agent, AgentBuilder, type AgentBuilderConfig, type AgentBuilderWithSchema, AgentEvaluator, type AgentMetricDimensions, type AgentSpanAttributes, AgentTool, type AgentToolConfig, type AgentType, index$4 as Agents, AiSdkLlm, AnthropicLlm, ApiKeyCredential, ApiKeyScheme, AuthConfig, AuthCredential, AuthCredentialType, AuthHandler, AuthScheme, AuthSchemeType, AuthTool, type AuthToolArguments, AutoFlow, BaseAgent, type BaseAgentType, BaseCodeExecutor, type BaseCodeExecutorConfig, BaseLLMConnection, BaseLlm, BaseLlmFlow, BaseLlmRequestProcessor, BaseLlmResponseProcessor, type BaseMemoryService, BasePlanner, BasePlugin, BaseSessionService, BaseTool, BasicAuthCredential, BearerTokenCredential, type BeforeAgentCallback, type BeforeModelCallback, type BeforeToolCallback, type BuildFunctionDeclarationOptions, type BuiltAgent, BuiltInCodeExecutor, BuiltInPlanner, CallbackContext, type CodeExecutionInput, type CodeExecutionResult, CodeExecutionUtils, CodeExecutorContext, type CreateToolConfig, type CreateToolConfigWithSchema, type CreateToolConfigWithoutSchema, DEFAULTS, DatabaseSessionService, ENV_VARS, EnhancedAuthConfig, type EnhancedLlmSpanAttributes, type EnhancedRunner, type EnhancedToolSpanAttributes, type ErrorSpanAttributes, type EvalCase, type EvalCaseResult, type EvalMetric, type EvalMetricResult, type EvalMetricResultPerInvocation, EvalResult, type EvalSet, type EvalSetResult, EvalStatus, type EvaluateConfig, index$3 as Evaluation, type EvaluationResult, Evaluator, Event, EventActions, type EventCompaction, index$7 as Events, type EventsCompactionConfig, type EventsSummarizer, ExitLoopTool, type File, FileOperationsTool, FinalResponseMatchV2Evaluator, index$2 as Flows, type FullMessage, FunctionTool, GcsArtifactService, type GetSessionConfig, GetUserChoiceTool, GoogleLlm, GoogleSearch, HttpRequestTool, HttpScheme, InMemoryArtifactService, InMemoryMemoryService, InMemoryRunner, InMemorySessionService, type InstructionProvider, type IntermediateData, type Interval, type Invocation, InvocationContext, type JudgeModelOptions, LLMRegistry, LangGraphAgent, type LangGraphAgentConfig, type LangGraphNode, LangfusePlugin, type LangfusePluginOptions, type ListSessionsResponse, LlmAgent, type LlmAgentConfig, LlmCallsLimitExceededError, LlmEventSummarizer, type LlmMetricDimensions, type LlmModel, type LlmModelConfig, LlmRequest, LlmResponse, type LlmSpanAttributes, LoadArtifactsTool, LoadMemoryTool, LocalEvalService, LoopAgent, type LoopAgentConfig, METRICS, McpAbi, McpAtp, McpBamm, McpCoinGecko, McpCoinGeckoPro, type McpConfig, McpDiscord, McpError, McpErrorType, McpFilesystem, McpFraxlend, McpGeneric, McpIqWiki, McpMemory, McpNearAgent, McpNearIntents, McpOdos, McpPolymarket, McpSamplingHandler, type McpSamplingRequest, type McpSamplingResponse, type McpServerConfig, McpTelegram, McpToolset, type McpTransportType, McpUpbit, index$1 as Memory, type MessagePart, type MetricInfo, type MetricValueInfo, index$5 as Models, type MultiAgentResponse, OAuth2Credential, OAuth2Scheme, type OAuthFlow, type OAuthFlows, OPERATIONS, OpenAiLlm, OpenIdConnectScheme, ParallelAgent, type ParallelAgentConfig, type ParsedArtifactUri, type PerInvocationResult, type PerToolFailuresCounter, PlanReActPlanner, type PluginCallbackName, PluginManager, PrebuiltMetrics, REFLECT_AND_RETRY_RESPONSE_TYPE, REQUEST_EUC_FUNCTION_CALL_NAME, ReadonlyContext, ReflectAndRetryToolPlugin, type ReflectAndRetryToolPluginOptions, RougeEvaluator, RunConfig, Runner, type RunnerAskReturn, SEMCONV, SafetyEvaluatorV1, type SamplingHandler, type SearchMemoryResponse, SequentialAgent, type SequentialAgentConfig, type Session, type SessionInput, type SessionOptions, index as Sessions, type SingleAfterModelCallback, type SingleAfterToolCallback, type SingleAgentCallback, type SingleBeforeModelCallback, type SingleBeforeToolCallback, SingleFlow, State, StreamingMode, type TelemetryConfig, TelemetryService, type TelemetryStats, type ThinkingConfig, type ToolConfig, ToolContext, type ToolFailureResponse, type ToolMetricDimensions, type ToolSpanAttributes, type ToolUnion, index$6 as Tools, type TraceAgentParams, type TraceAgentTransferParams, type TraceCallbackParams, type TraceLlmParams, type TraceMemoryParams, type TracePluginParams, type TraceSessionParams, type TraceToolParams, TrackingScope, TrajectoryEvaluator, type TransferContext, TransferToAgentTool, UserInteractionTool, VERSION, VertexAiRagMemoryService, VertexAiSessionService, _findFunctionCallEventIfLastEventIsFunctionResponse, adkToMcpToolType, requestProcessor$2 as agentTransferRequestProcessor, requestProcessor$6 as basicRequestProcessor, buildFunctionDeclaration, buildLlmRequestForTrace, buildLlmResponseForTrace, requestProcessor as codeExecutionRequestProcessor, responseProcessor as codeExecutionResponseProcessor, requestProcessor$3 as contentRequestProcessor, convertMcpToolToBaseTool, createAuthToolArguments, createBranchContextForSubAgent, createDatabaseSessionService, createFunctionTool, createMysqlSessionService, createPostgresSessionService, createSamplingHandler, createSqliteSessionService, createTool, extractTextFromContent, formatSpanAttributes, generateAuthEvent, generateClientFunctionCallId, getArtifactUri, getEnvironment, getLongRunningFunctionCalls, getMcpTools, handleFunctionCallsAsync, handleFunctionCallsLive, requestProcessor$5 as identityRequestProcessor, initializeTelemetry, injectSessionState, requestProcessor$4 as instructionsRequestProcessor, isArtifactRef, isEnhancedAuthConfig, jsonSchemaToDeclaration, mcpSchemaToParameters, mergeAgentRun, mergeParallelFunctionResponseEvents, newInvocationContextId, requestProcessor$1 as nlPlanningRequestProcessor, responseProcessor$1 as nlPlanningResponseProcessor, normalizeJsonSchema, parseArtifactUri, pluginCallbackNameSchema, populateClientFunctionCallId, recordAgentInvocation, recordLlmCall, recordToolExecution, registerProviders, removeClientFunctionCallId, requestProcessor$7 as requestProcessor, runCompactionForSlidingWindow, safeJsonStringify, shouldCaptureContent, shutdownTelemetry, telemetryService, traceAgentInvocation, traceLlmCall, traceToolCall, tracer };
+export { ADK_ATTRS, ADK_SYSTEM_NAME, AF_FUNCTION_CALL_ID_PREFIX, type AfterAgentCallback, type AfterModelCallback, type AfterToolCallback, LlmAgent as Agent, AgentBuilder, type AgentBuilderConfig, type AgentBuilderWithSchema, AgentEvaluator, type AgentMetricDimensions, type AgentSpanAttributes, AgentTool, type AgentToolConfig, type AgentType, index$5 as Agents, AiSdkLlm, AnthropicLlm, ApiKeyCredential, ApiKeyScheme, AuthConfig, AuthCredential, AuthCredentialType, AuthHandler, AuthScheme, AuthSchemeType, AuthTool, type AuthToolArguments, AutoFlow, BaseAgent, type BaseAgentType, BaseCodeExecutor, type BaseCodeExecutorConfig, BaseLLMConnection, BaseLlm, BaseLlmFlow, BaseLlmRequestProcessor, BaseLlmResponseProcessor, type BaseMemoryService, BasePlanner, BasePlugin, BaseSessionService, BaseTool, BashTool, BasicAuthCredential, BearerTokenCredential, type BeforeAgentCallback, type BeforeModelCallback, type BeforeToolCallback, type BuildFunctionDeclarationOptions, type BuiltAgent, BuiltInCodeExecutor, BuiltInPlanner, CallbackContext, type CodeExecutionInput, type CodeExecutionResult, CodeExecutionUtils, CodeExecutorContext, ContextCacheConfig, type ContextCacheConfigProps, type ContextCacheManager, type CreateToolConfig, type CreateToolConfigWithSchema, type CreateToolConfigWithoutSchema, DEFAULTS, DatabaseSessionService, ENV_VARS, EditTool, EnhancedAuthConfig, type EnhancedLlmSpanAttributes, type EnhancedRunner, type EnhancedToolSpanAttributes, type ErrorSpanAttributes, type EvalCase, type EvalCaseResult, type EvalMetric, type EvalMetricResult, type EvalMetricResultPerInvocation, EvalResult, type EvalSet, type EvalSetResult, EvalStatus, type EvaluateConfig, index$4 as Evaluation, type EvaluationResult, Evaluator, Event, EventActions, type EventCompaction, index$7 as Events, type EventsCompactionConfig, type EventsSummarizer, ExitLoopTool, type File, FileOperationsTool, FinalResponseMatchV2Evaluator, index$3 as Flows, type FullMessage, FunctionTool, GcsArtifactService, GeminiContextCacheManager, type GetSessionConfig, GetUserChoiceTool, GlobTool, GoogleLlm, GoogleSearchTool, GrepTool, HttpRequestTool, HttpScheme, InMemoryArtifactService, InMemoryMemoryService, InMemoryRunner, InMemorySessionService, type InstructionProvider, type IntermediateData, type Interval, type Invocation, InvocationContext, type JudgeModelOptions, LLMRegistry, LangGraphAgent, type LangGraphAgentConfig, type LangGraphNode, LangfusePlugin, type LangfusePluginOptions, type ListSessionsResponse, LlmAgent, type LlmAgentConfig, LlmCallsLimitExceededError, LlmEventSummarizer, type LlmMetricDimensions, type LlmModel, type LlmModelConfig, LlmRequest, LlmResponse, type LlmSpanAttributes, LoadArtifactsTool, LoadMemoryTool, LocalEvalService, LoopAgent, type LoopAgentConfig, METRICS, McpAbi, McpAtp, McpBamm, McpCoinGecko, McpCoinGeckoPro, type McpConfig, McpDiscord, McpError, McpErrorType, McpFilesystem, McpFraxlend, McpGeneric, McpIqWiki, McpMemory, McpNearAgent, McpNearIntents, McpOdos, McpPolymarket, McpSamplingHandler, type McpSamplingRequest, type McpSamplingResponse, type McpServerConfig, McpTelegram, McpToolset, type McpTransportType, McpUpbit, index$2 as Memory, type MessagePart, type MetricInfo, type MetricValueInfo, index$6 as Models, type MultiAgentResponse, OAuth2Credential, OAuth2Scheme, type OAuthFlow, type OAuthFlows, OPERATIONS, OpenAiLlm, OpenIdConnectScheme, ParallelAgent, type ParallelAgentConfig, type ParsedArtifactUri, type PerInvocationResult, type PerToolFailuresCounter, PlanReActPlanner, type PluginCallbackName, PluginManager, index$1 as Plugins, PrebuiltMetrics, REFLECT_AND_RETRY_RESPONSE_TYPE, REQUEST_EUC_FUNCTION_CALL_NAME, ReadTool, ReadonlyContext, ReflectAndRetryToolPlugin, type ReflectAndRetryToolPluginOptions, RougeEvaluator, RunConfig, Runner, type RunnerAskReturn, SEMCONV, SafetyEvaluatorV1, type SamplingHandler, type SearchMemoryResponse, SequentialAgent, type SequentialAgentConfig, type Session, type SessionInput, type SessionOptions, index as Sessions, type SingleAfterModelCallback, type SingleAfterToolCallback, type SingleAgentCallback, type SingleBeforeModelCallback, type SingleBeforeToolCallback, SingleFlow, State, StreamingMode, type TelemetryConfig, TelemetryService, type TelemetryStats, type ThinkingConfig, type ToolConfig, ToolContext, type ToolFailureResponse, type ToolMetricDimensions, type ToolSpanAttributes, type ToolUnion, index$8 as Tools, type TraceAgentParams, type TraceAgentTransferParams, type TraceCallbackParams, type TraceLlmParams, type TraceMemoryParams, type TracePluginParams, type TraceSessionParams, type TraceToolParams, TrackingScope, TrajectoryEvaluator, type TransferContext, TransferToAgentTool, UserInteractionTool, VERSION, VertexAiRagMemoryService, VertexAiSessionService, WebFetchTool, WebSearchTool, WriteTool, _findFunctionCallEventIfLastEventIsFunctionResponse, adkToMcpToolType, requestProcessor$6 as agentTransferRequestProcessor, requestProcessor$5 as basicRequestProcessor, buildFunctionDeclaration, buildLlmRequestForTrace, buildLlmResponseForTrace, requestProcessor$4 as codeExecutionRequestProcessor, responseProcessor$1 as codeExecutionResponseProcessor, requestProcessor$3 as contentRequestProcessor, contextCacheConfigSchema, convertMcpToolToBaseTool, createAuthToolArguments, createBranchContextForSubAgent, createDatabaseSessionService, createFunctionTool, createMysqlSessionService, createPostgresSessionService, createSamplingHandler, createSqliteSessionService, createTool, extractTextFromContent, formatSpanAttributes, generateAuthEvent, generateClientFunctionCallId, getArtifactUri, getEnvironment, getLongRunningFunctionCalls, getMcpTools, handleFunctionCallsAsync, handleFunctionCallsLive, requestProcessor$2 as identityRequestProcessor, initializeTelemetry, injectSessionState, requestProcessor$1 as instructionsRequestProcessor, isArtifactRef, isEnhancedAuthConfig, jsonSchemaToDeclaration, mcpSchemaToParameters, mergeAgentRun, mergeParallelFunctionResponseEvents, newInvocationContextId, requestProcessor as nlPlanningRequestProcessor, responseProcessor as nlPlanningResponseProcessor, normalizeJsonSchema, parseArtifactUri, pluginCallbackNameSchema, populateClientFunctionCallId, recordAgentInvocation, recordLlmCall, recordToolExecution, registerProviders, removeClientFunctionCallId, requestProcessor$7 as requestProcessor, runCompactionForSlidingWindow, safeJsonStringify, shouldCaptureContent, shutdownTelemetry, telemetryService, traceAgentInvocation, traceLlmCall, traceToolCall, tracer };