@iqai/adk 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,3368 @@
+import { AxiosInstance } from 'axios';
+import OpenAI from 'openai';
+import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
+import { NodePgDatabase } from 'drizzle-orm/node-postgres';
+import { PgliteDatabase } from 'drizzle-orm/pglite';
+
+/**
+ * Function call result from LLM
+ */
+interface FunctionCall {
+    /**
+     * Name of the function to call
+     */
+    name: string;
+    /**
+     * Arguments for the function, serialized as a JSON string
+     */
+    arguments: string;
+}
+/**
+ * Tool call result from LLM
+ */
+interface ToolCall {
+    /**
+     * Unique ID for the tool call
+     */
+    id: string;
+    /**
+     * Function call details
+     */
+    function: FunctionCall;
+}
+/**
+ * Response from an LLM
+ */
+declare class LLMResponse {
+    /**
+     * Content of the response
+     */
+    content?: string | null;
+    /**
+     * Function calls in the response
+     */
+    function_call?: FunctionCall;
+    /**
+     * Tool calls in the response
+     */
+    tool_calls?: ToolCall[];
+    /**
+     * Role of the message (usually 'assistant')
+     */
+    role: string;
+    /**
+     * Whether this is a partial response in a stream
+     */
+    is_partial?: boolean;
+    /**
+     * Raw provider response
+     */
+    raw_response?: any;
+    constructor(data: {
+        content?: string | null;
+        function_call?: FunctionCall;
+        tool_calls?: ToolCall[];
+        role?: string;
+        is_partial?: boolean;
+        raw_response?: any;
+    });
+}
+
+/**
+ * Message role types for conversation history
+ */
+type MessageRole = "user" | "assistant" | "system" | "function" | "tool" | "model";
+/**
+ * Text content type
+ */
+interface TextContent {
+    type: "text";
+    text: string;
+}
+/**
+ * Image content type
+ */
+interface ImageContent {
+    type: "image";
+    image_url: {
+        url: string;
+    };
+}
+/**
+ * Message content types
+ */
+type MessageContent = string | TextContent | ImageContent | Array<TextContent | ImageContent>;
+/**
+ * Represents a message in the conversation
+ */
+interface Message {
+    role: MessageRole;
+    content: MessageContent;
+    name?: string;
+    function_call?: {
+        name: string;
+        arguments: string;
+    };
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+}
+/**
+ * Configuration for LLM requests
+ */
+interface LLMRequestConfig {
+    temperature?: number;
+    max_tokens?: number;
+    top_p?: number;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    functions?: FunctionDeclaration[];
+    stream?: boolean;
+}
+/**
+ * Represents a request to an LLM
+ */
+declare class LLMRequest {
+    /**
+     * The conversation history
+     */
+    messages: Message[];
+    /**
+     * LLM configuration parameters
+     */
+    config: LLMRequestConfig;
+    constructor(data: {
+        messages: Message[];
+        config?: LLMRequestConfig;
+    });
+}
+
+/**
+ * Streaming mode options for agent execution
+ */
+declare enum StreamingMode {
+    /**
+     * No streaming
+     */
+    NONE = "NONE",
+    /**
+     * Server-Sent Events streaming
+     */
+    SSE = "SSE",
+    /**
+     * Bidirectional streaming
+     */
+    BIDI = "BIDI"
+}
+/**
+ * Speech configuration for live agents
+ */
+interface SpeechConfig {
+    /**
+     * Voice to use for speech
+     */
+    voice?: string;
+    /**
+     * Language code
+     */
+    language?: string;
+}
+/**
+ * Audio transcription configuration
+ */
+interface AudioTranscriptionConfig {
+    /**
+     * Whether to enable audio transcription
+     */
+    enabled: boolean;
+    /**
+     * Language code for transcription
+     */
+    language?: string;
+}
+/**
+ * Configs for runtime behavior of agents
+ */
+declare class RunConfig {
+    /**
+     * Speech configuration for the live agent
+     */
+    speechConfig?: SpeechConfig;
+    /**
+     * The output modalities
+     */
+    responseModalities?: string[];
+    /**
+     * Whether to save input blobs as artifacts
+     */
+    saveInputBlobsAsArtifacts: boolean;
+    /**
+     * Whether to support Compositional Function Calling
+     * Only applicable for StreamingMode.SSE
+     */
+    supportCFC: boolean;
+    /**
+     * Streaming mode
+     */
+    streamingMode: StreamingMode;
+    /**
+     * Whether to stream the response
+     * This is derived from streamingMode and used by LLM implementations
+     */
+    stream: boolean;
+    /**
+     * Output audio transcription configuration
+     */
+    outputAudioTranscription?: AudioTranscriptionConfig;
+    constructor(config?: Partial<RunConfig>);
+}
+
+/**
+ * Base class for all agents in the Agent Development Kit
+ */
+declare abstract class BaseAgent {
+    /**
+     * The agent's name
+     * Agent name must be a unique identifier within the agent tree
+     */
+    name: string;
+    /**
+     * Description about the agent's capability
+     * The LLM uses this to determine whether to delegate control to the agent
+     */
+    description: string;
+    /**
+     * The parent agent of this agent
+     * Note that an agent can ONLY be added as sub-agent once
+     */
+    parentAgent?: BaseAgent;
+    /**
+     * The sub-agents of this agent
+     */
+    subAgents: BaseAgent[];
+    /**
+     * Constructs a new BaseAgent
+     */
+    constructor(config: {
+        name: string;
+        description: string;
+    });
+    /**
+     * Gets the root agent of the agent tree
+     */
+    get rootAgent(): BaseAgent;
+    /**
+     * Adds a sub-agent to this agent
+     */
+    addSubAgent(agent: BaseAgent): BaseAgent;
+    /**
+     * Finds a sub-agent by name
+     */
+    findSubAgent(name: string): BaseAgent | undefined;
+    /**
+     * Finds an agent in the agent tree by name
+     */
+    findAgent(name: string): BaseAgent | undefined;
+    /**
+     * Runs the agent with the given messages and configuration
+     */
+    abstract run(options: {
+        messages: Message[];
+        config?: RunConfig;
+        sessionId?: string;
+    }): Promise<any>;
+    /**
+     * Runs the agent with streaming support
+     */
+    abstract runStreaming(options: {
+        messages: Message[];
+        config?: RunConfig;
+        sessionId?: string;
+    }): AsyncIterable<any>;
+}
+
+/**
+ * JSON Schema type for function parameters
+ */
+interface JSONSchema {
+    type: string;
+    properties?: Record<string, JSONSchema>;
+    items?: JSONSchema;
+    required?: string[];
+    enum?: string[];
+    description?: string;
+    format?: string;
+    pattern?: string;
+    minimum?: number;
+    maximum?: number;
+    default?: any;
+    [key: string]: any;
+}
+/**
+ * Represents a function declaration for the LLM
+ */
+interface FunctionDeclaration {
+    /**
+     * Name of the function
+     */
+    name: string;
+    /**
+     * Description of what the function does
+     */
+    description: string;
+    /**
+     * Parameters schema in JSON Schema format
+     */
+    parameters: JSONSchema;
+}
+
+/**
+ * Base class for LLM connections
+ */
+declare abstract class BaseLLMConnection {
+    /**
+     * Whether the connection is active
+     */
+    private _isActive;
+    /**
+     * Gets whether the connection is active
+     */
+    get isActive(): boolean;
+    /**
+     * Sends a message to the LLM
+     *
+     * @param message The message to send
+     */
+    abstract send(message: string): void;
+    /**
+     * Handles responses from the LLM
+     *
+     * @param callback The callback to handle responses
+     */
+    abstract onResponse(callback: (response: LLMResponse) => void): void;
+    /**
+     * Handles errors from the LLM
+     *
+     * @param callback The callback to handle errors
+     */
+    abstract onError(callback: (error: Error) => void): void;
+    /**
+     * Handles the end of the connection
+     *
+     * @param callback The callback to handle the end
+     */
+    abstract onEnd(callback: () => void): void;
+    /**
+     * Closes the connection
+     */
+    close(): void;
+}
+
+/**
+ * Base class for all LLM implementations
+ */
+declare abstract class BaseLLM {
+    /**
+     * The name of the LLM model
+     */
+    model: string;
+    /**
+     * Constructor for BaseLLM
+     */
+    constructor(model: string);
+    /**
+     * Returns a list of supported models in regex for LLMRegistry
+     */
+    static supportedModels(): string[];
+    /**
+     * Generates content from the given request
+     *
+     * @param llmRequest The request to send to the LLM
+     * @param stream Whether to do streaming call
+     * @returns A generator of LLMResponses
+     */
+    abstract generateContentAsync(llmRequest: LLMRequest, stream?: boolean): AsyncGenerator<LLMResponse, void, unknown>;
+    /**
+     * Creates a live connection to the LLM
+     *
+     * @param llmRequest The request to send to the LLM
+     * @returns BaseLLMConnection, the connection to the LLM
+     */
+    connect(llmRequest: LLMRequest): BaseLLMConnection;
+}
+
+/**
+ * Configuration for Anthropic LLM
+ */
+interface AnthropicLLMConfig {
+    /**
+     * Anthropic API key (can be provided via process.env.ANTHROPIC_API_KEY)
+     */
+    apiKey?: string;
+    /**
+     * Anthropic base URL override
+     */
+    baseURL?: string;
+    /**
+     * Default model parameters
+     */
+    defaultParams?: {
+        /**
+         * Temperature for generation
+         */
+        temperature?: number;
+        /**
+         * Top-p for generation
+         */
+        top_p?: number;
+        /**
+         * Maximum tokens to generate
+         */
+        max_tokens?: number;
+    };
+}
+/**
+ * Anthropic LLM implementation for Claude models
+ * Uses direct API calls instead of the SDK for better control
+ */
+declare class AnthropicLLM extends BaseLLM {
+    /**
+     * Anthropic API key
+     */
+    private apiKey;
+    /**
+     * Anthropic API base URL
+     */
+    private baseURL;
+    /**
+     * Default parameters for requests
+     */
+    private defaultParams;
+    /**
+     * Constructor for AnthropicLLM
+     */
+    constructor(model: string, config?: AnthropicLLMConfig);
+    /**
+     * Returns a list of supported models in regex for LLMRegistry
+     */
+    static supportedModels(): string[];
+    /**
+     * Convert ADK messages to Anthropic message format
+     */
+    private convertMessages;
+    /**
+     * Extract the system message from messages array
+     */
+    private extractSystemMessage;
+    /**
+     * Filter out system messages as they are handled separately
+     */
+    private filterSystemMessages;
+    /**
+     * Convert ADK function declarations to Anthropic tool format
+     */
+    private convertFunctionsToTools;
+    /**
+     * Convert Anthropic tool calls to ADK tool calls
+     */
+    private convertToolUses;
+    /**
+     * Extract tool uses from response content
+     */
+    private extractToolUses;
+    /**
+     * Make a direct API call to Anthropic
+     */
+    private callAnthropicAPI;
+    /**
+     * Generates content from the given request
+     */
+    generateContentAsync(llmRequest: LLMRequest, stream?: boolean): AsyncGenerator<LLMResponse, void, unknown>;
+    /**
+     * Creates a live connection to the LLM
+     */
+    connect(llmRequest: LLMRequest): BaseLLMConnection;
+}
+
+/**
+ * Anthropic LLM Connection for live chat with Claude models
+ */
+declare class AnthropicLLMConnection extends BaseLLMConnection {
+    /**
+     * Axios instance for API calls
+     */
+    private client;
+    /**
+     * Current model to use
+     */
+    private model;
+    /**
+     * Current messages in the conversation
+     */
+    private messages;
+    /**
+     * System message if present
+     */
+    private systemMessage?;
+    /**
+     * Default parameters for requests
+     */
+    private defaultParams;
+    /**
+     * Callbacks for handling responses, errors, and connection end
+     */
+    private responseCallback?;
+    private errorCallback?;
+    private endCallback?;
+    /**
+     * Constructor
+     */
+    constructor(client: AxiosInstance, model: string, initialRequest: LLMRequest, defaultParams: Record<string, any>);
+    /**
+     * Extract the system message from messages array
+     */
+    private extractSystemMessage;
+    /**
+     * Filter out system messages as they are handled separately in Anthropic API
+     */
+    private filterSystemMessages;
+    /**
+     * Converts an ADK message to an Anthropic message
+     */
+    private convertMessages;
+    /**
+     * Convert Anthropic tool calls to ADK tool calls
+     */
+    private convertToolCalls;
+    /**
+     * Extract tool uses from response content
+     */
+    private extractToolUses;
+    /**
+     * Sends a message to the LLM
+     * Implements BaseLLMConnection.send
+     *
+     * @param message The message to send
+     */
+    send(message: string): void;
+    /**
+     * Handles responses from the LLM
+     * Implements BaseLLMConnection.onResponse
+     *
+     * @param callback The callback to handle responses
+     */
+    onResponse(callback: (response: LLMResponse) => void): void;
+    /**
+     * Handles errors from the LLM
+     * Implements BaseLLMConnection.onError
+     *
+     * @param callback The callback to handle errors
+     */
+    onError(callback: (error: Error) => void): void;
+    /**
+     * Handles the end of the connection
+     * Implements BaseLLMConnection.onEnd
+     *
+     * @param callback The callback to handle the end
+     */
+    onEnd(callback: () => void): void;
+    /**
+     * Triggers an error through the error callback
+     */
+    private triggerError;
+    /**
+     * Sends the message to the LLM and returns the response
+     */
+    private sendMessageAsync;
+}
+
+/**
+ * Google Gemini LLM configuration
+ */
+interface GoogleLLMConfig {
+    /**
+     * Google Cloud Project ID (can be provided via GOOGLE_CLOUD_PROJECT env var)
+     */
+    projectId?: string;
+    /**
+     * Google Cloud location (can be provided via GOOGLE_CLOUD_LOCATION env var)
+     */
+    location?: string;
+    /**
+     * Default model parameters
+     */
+    defaultParams?: {
+        /**
+         * Temperature for generation
+         */
+        temperature?: number;
+        /**
+         * Top-p for generation
+         */
+        top_p?: number;
+        /**
+         * Maximum tokens to generate
+         */
+        maxOutputTokens?: number;
+    };
+}
+/**
+ * Google Gemini LLM implementation
+ */
+declare class GoogleLLM extends BaseLLM {
+    /**
+     * Generative model instance
+     */
+    private ai;
+    /**
+     * Default parameters for requests
+     */
+    private defaultParams;
+    /**
+     * Constructor for GoogleLLM
+     */
+    constructor(model: string, config?: GoogleLLMConfig);
+    /**
+     * Returns a list of supported models in regex for LLMRegistry
+     */
+    static supportedModels(): string[];
+    /**
+     * Convert a message to Google Vertex AI format
+     */
+    private convertMessage;
+    /**
+     * Map ADK role to Google role
+     */
+    private mapRole;
+    /**
+     * Extract system message from messages array
+     */
+    private extractSystemMessage;
+    /**
+     * Convert functions to Google function declarations
+     */
+    private convertFunctionsToTools;
+    /**
+     * Convert parameter types to Google Gemini format (uppercase types)
+     */
+    private convertParametersToGoogleFormat;
+    /**
+     * Convert Google response to LLMResponse
+     */
+    private convertResponse;
+    /**
+     * Generates content from the given request
+     */
+    generateContentAsync(llmRequest: LLMRequest, stream?: boolean): AsyncGenerator<LLMResponse, void, unknown>;
+}
+
+/**
+ * Configuration for OpenAI LLM
+ */
+interface OpenAILLMConfig {
+    /**
+     * OpenAI API key (can be provided via process.env.OPENAI_API_KEY)
+     */
+    apiKey?: string;
+    /**
+     * OpenAI base URL override
+     */
+    baseURL?: string;
+    /**
+     * OpenAI organization ID
+     */
+    organization?: string;
+    /**
+     * Default model parameters
+     */
+    defaultParams?: {
+        /**
+         * Temperature for generation
+         */
+        temperature?: number;
+        /**
+         * Top-p for generation
+         */
+        top_p?: number;
+        /**
+         * Maximum tokens to generate
+         */
+        max_tokens?: number;
+        /**
+         * Frequency penalty
+         */
+        frequency_penalty?: number;
+        /**
+         * Presence penalty
+         */
+        presence_penalty?: number;
+    };
+}
+/**
+ * OpenAI LLM implementation
+ */
+declare class OpenAILLM extends BaseLLM {
+    /**
+     * OpenAI client instance
+     */
+    private client;
+    /**
+     * Default parameters for requests
+     */
+    private defaultParams;
+    /**
+     * Constructor for OpenAILLM
+     */
+    constructor(model: string, config?: OpenAILLMConfig);
+    /**
+     * Returns a list of supported models in regex for LLMRegistry
+     */
+    static supportedModels(): string[];
+    /**
+     * Converts an ADK message to an OpenAI message
+     */
+    private convertMessage;
+    /**
+     * Converts functions to OpenAI tools
+     */
+    private convertFunctionsToTools;
+    /**
+     * Convert OpenAI response to LLMResponse
+     */
+    private convertResponse;
+    /**
+     * Convert OpenAI streaming chunk to LLMResponse
+     */
+    private convertChunk;
+    /**
+     * Generates content from the given request
+     */
+    generateContentAsync(llmRequest: LLMRequest, stream?: boolean): AsyncGenerator<LLMResponse, void, unknown>;
+    /**
+     * Creates a live connection to the LLM
+     */
+    connect(llmRequest: LLMRequest): BaseLLMConnection;
+}
+
+/**
+ * OpenAI LLM Connection
+ */
+declare class OpenAILLMConnection extends BaseLLMConnection {
+    /**
+     * OpenAI client
+     */
+    private client;
+    /**
+     * The model name
+     */
+    private model;
+    /**
+     * The initial request
+     */
+    private initialRequest;
+    /**
+     * Default parameters
+     */
+    private defaultParams;
+    /**
+     * Response callback
+     */
+    private responseCallback?;
+    /**
+     * Error callback
+     */
+    private errorCallback?;
+    /**
+     * End callback
+     */
+    private endCallback?;
+    /**
+     * Ongoing chat history
+     */
+    private messages;
+    /**
+     * Constructor for OpenAILLMConnection
+     */
+    constructor(client: OpenAI, model: string, initialRequest: LLMRequest, defaultParams: Record<string, any>);
+    /**
+     * Adds a tool/function result message to the conversation history
+     * This method ensures we don't duplicate tool_call_id values
+     */
+    private addToolResultMessage;
+    /**
+     * Sends a message to the OpenAI model
+     */
+    send(message: string): Promise<void>;
+    /**
+     * Registers a response handler
+     */
+    onResponse(callback: (response: LLMResponse) => void): void;
+    /**
+     * Registers an error handler
+     */
+    onError(callback: (error: Error) => void): void;
+    /**
+     * Registers an end handler
+     */
+    onEnd(callback: () => void): void;
+}
+
+/**
+ * Type for LLM constructor with static methods
+ */
+interface LLMClass {
+    new (model: string): BaseLLM;
+    supportedModels(): string[];
+}
+/**
+ * Registry for LLMs
+ */
+declare class LLMRegistry {
+    /**
+     * Map of model name regex to LLM class
+     */
+    private static llmRegistry;
+    /**
+     * Creates a new LLM instance
+     *
+     * @param model The model name
+     * @returns The LLM instance
+     */
+    static newLLM(model: string): BaseLLM;
+    /**
+     * Resolves the LLM class from the model name
+     *
+     * @param model The model name
+     * @returns The LLM class
+     */
+    static resolve(model: string): LLMClass | null;
+    /**
+     * Registers a new LLM class
+     *
+     * @param modelNameRegex The regex to match model names
+     * @param llmClass The LLM class
+     */
+    static register(modelNameRegex: string, llmClass: LLMClass): void;
+    /**
+     * Registers all model patterns from an LLM class
+     *
+     * @param llmClass The LLM class
+     */
+    static registerLLM(llmClass: LLMClass): void;
+    /**
+     * Logs all registered models for debugging
+     */
+    static logRegisteredModels(): void;
+}
+
+/**
+ * Register all LLM providers
+ */
+declare function registerProviders(): void;
+
+/**
+ * Authentication scheme types
+ */
+declare enum AuthSchemeType {
+    APIKEY = "apiKey",
+    HTTP = "http",
+    OAUTH2 = "oauth2",
+    OPENID_CONNECT = "openIdConnect"
+}
+/**
+ * Base class for authentication schemes
+ */
+declare abstract class AuthScheme {
+    /**
+     * The type of authentication scheme
+     */
+    type: AuthSchemeType;
+    constructor(type: AuthSchemeType);
+}
+/**
+ * API Key authentication scheme
+ */
+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;
+    });
+}
+/**
+ * HTTP authentication scheme
+ */
+declare class HttpScheme extends AuthScheme {
+    /**
+     * The HTTP authentication scheme
+     */
+    scheme: "basic" | "bearer" | "digest" | "other";
+    /**
+     * Bearer format when scheme is 'bearer'
+     */
+    bearerFormat?: string;
+    /**
+     * Description of the scheme
+     */
+    description?: string;
+    /**
+     * Constructor for HttpScheme
+     */
+    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 {
+    /**
+     * OAuth flows
+     */
+    flows: OAuthFlows;
+    /**
+     * Description of the scheme
+     */
+    description?: string;
+    /**
+     * Constructor for OAuth2Scheme
+     */
+    constructor(config: {
+        flows: OAuthFlows;
+        description?: string;
+    });
+}
+/**
+ * OpenID Connect authentication scheme
+ */
+declare class OpenIdConnectScheme extends AuthScheme {
+    /**
+     * OpenID Connect URL
+     */
+    openIdConnectUrl: string;
+    /**
+     * Description of the scheme
+     */
+    description?: string;
+    /**
+     * Constructor for OpenIdConnectScheme
+     */
+    constructor(config: {
+        openIdConnectUrl: string;
+        description?: string;
+    });
+}
+
+/**
+ * Authentication configuration for tools
+ */
+declare class AuthConfig {
+    /**
+     * The authentication scheme
+     */
+    authScheme: AuthScheme;
+    /**
+     * Additional context properties
+     */
+    context?: Record<string, any>;
+    /**
+     * Constructor for AuthConfig
+     */
+    constructor(config: {
+        authScheme: AuthScheme;
+        context?: Record<string, any>;
+    });
+}
+
+/**
+ * Handler for authentication in tools
+ */
+declare class AuthHandler {
+    /**
+     * The authentication configuration
+     */
+    authConfig: AuthConfig;
+    /**
+     * The authentication credential
+     */
+    credential?: AuthCredential;
+    /**
+     * Constructor for AuthHandler
+     */
+    constructor(config: {
+        authConfig: AuthConfig;
+        credential?: AuthCredential;
+    });
+    /**
+     * Gets the authentication token
+     */
+    getToken(): string | undefined;
+    /**
+     * Gets headers for HTTP requests
+     */
+    getHeaders(): Record<string, string>;
+    /**
+     * Refreshes the token if necessary
+     */
+    refreshToken(): Promise<void>;
+}
+
+/**
+ * Types of authentication credentials
+ */
+declare enum AuthCredentialType {
+    API_KEY = "api_key",
+    BASIC = "basic",
+    BEARER = "bearer",
+    OAUTH2 = "oauth2",
+    CUSTOM = "custom"
+}
+/**
+ * Base class for authentication credentials
+ */
+declare abstract class AuthCredential {
+    /**
+     * Type of credential
+     */
+    type: AuthCredentialType;
+    /**
+     * Constructor for AuthCredential
+     */
+    constructor(type: AuthCredentialType);
+    /**
+     * Gets the authentication token
+     */
+    abstract getToken(): string | undefined;
+    /**
+     * Gets headers for HTTP requests
+     */
+    abstract getHeaders(config: AuthConfig): Record<string, string>;
+    /**
+     * Whether the token can be refreshed
+     */
+    canRefresh(): boolean;
+    /**
+     * Refreshes the token
+     */
+    refresh(): Promise<void>;
+}
+/**
+ * API Key credential
+ */
+declare class ApiKeyCredential extends AuthCredential {
+    /**
+     * The API key
+     */
+    apiKey: string;
+    /**
+     * Constructor for ApiKeyCredential
+     */
+    constructor(apiKey: string);
+    /**
+     * Gets the API key as the token
+     */
+    getToken(): string;
+    /**
+     * Gets headers for HTTP requests
+     */
+    getHeaders(config: AuthConfig): Record<string, string>;
+}
+/**
+ * Basic authentication credential
+ */
+declare class BasicAuthCredential extends AuthCredential {
+    /**
+     * The username
+     */
+    username: string;
+    /**
+     * The password
+     */
+    password: string;
+    /**
+     * Constructor for BasicAuthCredential
+     */
+    constructor(username: string, password: string);
+    /**
+     * Gets the encoded basic auth token
+     */
+    getToken(): string;
+    /**
+     * Gets headers for HTTP requests
+     */
+    getHeaders(): Record<string, string>;
+}
+/**
+ * Bearer token credential
+ */
+declare class BearerTokenCredential extends AuthCredential {
+    /**
+     * The bearer token
+     */
+    token: string;
+    /**
+     * Constructor for BearerTokenCredential
+     */
+    constructor(token: string);
+    /**
+     * Gets the bearer token
+     */
+    getToken(): string;
+    /**
+     * Gets headers for HTTP requests
+     */
+    getHeaders(): Record<string, string>;
+}
+/**
+ * OAuth2 token credential with refresh capability
+ */
+declare class OAuth2Credential extends AuthCredential {
+    /**
+     * The access token
+     */
+    accessToken: string;
+    /**
+     * The refresh token
+     */
+    refreshToken?: string;
+    /**
+     * When the token expires
+     */
+    expiresAt?: Date;
+    /**
+     * Function to refresh the token
+     */
+    private refreshFunction?;
+    /**
+     * Constructor for OAuth2Credential
+     */
+    constructor(config: {
+        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>;
+}
+
+/**
+ * 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;
+    /**
+     * Constructor for EventActions
+     */
+    constructor(options?: {
+        skipSummarization?: boolean;
+        stateDelta?: Record<string, any>;
+        artifactDelta?: Record<string, number>;
+        transferToAgent?: string;
+        escalate?: boolean;
+    });
+}
+
+/**
+ * Represents an event in a conversation between agents and users.
+ * It is used to store the content of the conversation, as well as the actions
+ * taken by the agents like function calls, etc.
+ */
+declare class Event extends LLMResponse {
+    /**
+     * The invocation ID of the event.
+     */
+    invocationId: string;
+    /**
+     * 'user' or the name of the agent, indicating who appended the event to the session.
+     */
+    author: string;
+    /**
+     * The actions taken by the agent.
+     */
+    actions: EventActions;
+    /**
+     * Set of ids of the long running function calls.
+     * Agent client will know from this field about which function call is long running.
+     * Only valid for function call event.
+     */
+    longRunningToolIds?: Set<string>;
+    /**
+     * The branch of the event.
+     * 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-agent shouldn't see their peer agents'
+     * conversation history.
+     */
+    branch?: string;
+    /**
+     * The unique identifier of the event.
+     */
+    id: string;
+    /**
+     * The timestamp of the event.
+     */
+    timestamp: number;
+    /**
+     * Constructor for Event
+     */
+    constructor({ invocationId, author, content, function_call, tool_calls, role, actions, longRunningToolIds, branch, id, timestamp, partial, raw_response, }: {
+        invocationId?: string;
+        author: string;
+        content?: string | null;
+        function_call?: FunctionCall;
+        tool_calls?: ToolCall[];
+        role?: string;
+        actions?: EventActions;
+        longRunningToolIds?: Set<string>;
+        branch?: string;
+        id?: string;
+        timestamp?: number;
+        partial?: boolean;
+        raw_response?: any;
+    });
+    /**
+     * Returns whether the event is the final response of the agent.
+     */
+    isFinalResponse(): boolean;
+    /**
+     * Returns whether the event has meaningful content.
+     * Used to filter out empty or meaningless streaming chunks.
+     */
+    hasContent(): boolean;
+    /**
+     * Generates a new random ID for an event.
+     */
+    static newId(): string;
+}
+
+/**
+ * Represents the state of a session
+ */
+declare class SessionState {
+    private state;
+    private dirty;
+    constructor();
+    /**
+     * Sets a value in the state
+     * @param key The key to set
+     * @param value The value to set
+     */
+    set(key: string, value: any): void;
+    /**
+     * Gets a value from the state
+     * @param key The key to get
+     * @returns The value or undefined if not present
+     */
+    get<T>(key: string): T | undefined;
+    /**
+     * Checks if the state has a key
+     * @param key The key to check
+     * @returns Whether the key exists
+     */
+    has(key: string): boolean;
+    /**
+     * Deletes a key from the state
+     * @param key The key to delete
+     * @returns Whether the key was deleted
+     */
+    delete(key: string): boolean;
+    /**
+     * Checks if state has changed since last save
+     * @returns Whether the state has been modified
+     */
+    hasDelta(): boolean;
+    /**
+     * Clears the dirty state
+     */
+    clearDelta(): void;
+    /**
+     * Converts the state to a plain object
+     */
+    toObject(): Record<string, any>;
+    /**
+     * Creates a state from a plain object
+     * @param obj The object to load
+     */
+    static fromObject(obj: Record<string, any>): SessionState;
+}
+
+/**
+ * Represents a conversation session
+ */
+interface Session {
+    /**
+     * Unique session identifier
+     */
+    id: string;
+    /**
+     * User identifier associated with the session
+     */
+    userId: string;
+    /**
+     * Conversation history
+     */
+    messages: Message[];
+    /**
+     * Additional session metadata
+     */
+    metadata: Record<string, any>;
+    /**
+     * Session creation timestamp
+     */
+    createdAt: Date;
+    /**
+     * Last update timestamp
+     */
+    updatedAt: Date;
+    /**
+     * Session state for storing arbitrary data
+     */
+    state: SessionState;
+    /**
+     * Session events
+     */
+    events?: Event[];
+}
+/**
+ * Options for listing sessions
+ */
+interface ListSessionOptions {
+    /**
+     * Maximum number of sessions to return
+     */
+    limit?: number;
+    /**
+     * Only include sessions created after this time
+     */
+    createdAfter?: Date;
+    /**
+     * Only include sessions updated after this time
+     */
+    updatedAfter?: Date;
+    /**
+     * Filter sessions by metadata
+     */
+    metadataFilter?: Record<string, any>;
+}
+
+/**
+ * Models module exports - consolidated to match Python structure
+ */
+
+type index$4_AnthropicLLM = AnthropicLLM;
+declare const index$4_AnthropicLLM: typeof AnthropicLLM;
+type index$4_AnthropicLLMConfig = AnthropicLLMConfig;
+type index$4_AnthropicLLMConnection = AnthropicLLMConnection;
+declare const index$4_AnthropicLLMConnection: typeof AnthropicLLMConnection;
+type index$4_ApiKeyCredential = ApiKeyCredential;
+declare const index$4_ApiKeyCredential: typeof ApiKeyCredential;
+type index$4_ApiKeyScheme = ApiKeyScheme;
+declare const index$4_ApiKeyScheme: typeof ApiKeyScheme;
+type index$4_AuthConfig = AuthConfig;
+declare const index$4_AuthConfig: typeof AuthConfig;
+type index$4_AuthCredential = AuthCredential;
+declare const index$4_AuthCredential: typeof AuthCredential;
+type index$4_AuthCredentialType = AuthCredentialType;
+declare const index$4_AuthCredentialType: typeof AuthCredentialType;
+type index$4_AuthHandler = AuthHandler;
+declare const index$4_AuthHandler: typeof AuthHandler;
+type index$4_AuthScheme = AuthScheme;
+declare const index$4_AuthScheme: typeof AuthScheme;
+type index$4_AuthSchemeType = AuthSchemeType;
+declare const index$4_AuthSchemeType: typeof AuthSchemeType;
+type index$4_BaseLLM = BaseLLM;
+declare const index$4_BaseLLM: typeof BaseLLM;
+type index$4_BaseLLMConnection = BaseLLMConnection;
+declare const index$4_BaseLLMConnection: typeof BaseLLMConnection;
+type index$4_BaseMemoryService = BaseMemoryService;
+type index$4_BasicAuthCredential = BasicAuthCredential;
+declare const index$4_BasicAuthCredential: typeof BasicAuthCredential;
+type index$4_BearerTokenCredential = BearerTokenCredential;
+declare const index$4_BearerTokenCredential: typeof BearerTokenCredential;
+type index$4_FunctionCall = FunctionCall;
+type index$4_FunctionDeclaration = FunctionDeclaration;
+type index$4_GoogleLLM = GoogleLLM;
+declare const index$4_GoogleLLM: typeof GoogleLLM;
+type index$4_GoogleLLMConfig = GoogleLLMConfig;
+type index$4_HttpScheme = HttpScheme;
+declare const index$4_HttpScheme: typeof HttpScheme;
+type index$4_ImageContent = ImageContent;
+type index$4_JSONSchema = JSONSchema;
+type index$4_LLMRegistry = LLMRegistry;
+declare const index$4_LLMRegistry: typeof LLMRegistry;
+type index$4_LLMRequest = LLMRequest;
+declare const index$4_LLMRequest: typeof LLMRequest;
+type index$4_LLMRequestConfig = LLMRequestConfig;
+type index$4_LLMResponse = LLMResponse;
+declare const index$4_LLMResponse: typeof LLMResponse;
+type index$4_ListSessionOptions = ListSessionOptions;
+type index$4_MemoryResult = MemoryResult;
+type index$4_Message = Message;
+type index$4_MessageContent = MessageContent;
+type index$4_MessageRole = MessageRole;
+type index$4_OAuth2Credential = OAuth2Credential;
+declare const index$4_OAuth2Credential: typeof OAuth2Credential;
+type index$4_OAuth2Scheme = OAuth2Scheme;
+declare const index$4_OAuth2Scheme: typeof OAuth2Scheme;
+type index$4_OAuthFlow = OAuthFlow;
+type index$4_OAuthFlows = OAuthFlows;
+type index$4_OpenAILLM = OpenAILLM;
+declare const index$4_OpenAILLM: typeof OpenAILLM;
+type index$4_OpenAILLMConfig = OpenAILLMConfig;
+type index$4_OpenAILLMConnection = OpenAILLMConnection;
+declare const index$4_OpenAILLMConnection: typeof OpenAILLMConnection;
+type index$4_OpenIdConnectScheme = OpenIdConnectScheme;
+declare const index$4_OpenIdConnectScheme: typeof OpenIdConnectScheme;
+type index$4_SearchMemoryOptions = SearchMemoryOptions;
+type index$4_SearchMemoryResponse = SearchMemoryResponse;
+type index$4_Session = Session;
+type index$4_SessionState = SessionState;
+declare const index$4_SessionState: typeof SessionState;
+type index$4_TextContent = TextContent;
+type index$4_ToolCall = ToolCall;
+declare const index$4_registerProviders: typeof registerProviders;
+declare namespace index$4 {
+  export { index$4_AnthropicLLM as AnthropicLLM, type index$4_AnthropicLLMConfig as AnthropicLLMConfig, index$4_AnthropicLLMConnection as AnthropicLLMConnection, index$4_ApiKeyCredential as ApiKeyCredential, index$4_ApiKeyScheme as ApiKeyScheme, index$4_AuthConfig as AuthConfig, index$4_AuthCredential as AuthCredential, index$4_AuthCredentialType as AuthCredentialType, index$4_AuthHandler as AuthHandler, index$4_AuthScheme as AuthScheme, index$4_AuthSchemeType as AuthSchemeType, index$4_BaseLLM as BaseLLM, index$4_BaseLLMConnection as BaseLLMConnection, type index$4_BaseMemoryService as BaseMemoryService, index$4_BasicAuthCredential as BasicAuthCredential, index$4_BearerTokenCredential as BearerTokenCredential, type index$4_FunctionCall as FunctionCall, type index$4_FunctionDeclaration as FunctionDeclaration, index$4_GoogleLLM as GoogleLLM, type index$4_GoogleLLMConfig as GoogleLLMConfig, index$4_HttpScheme as HttpScheme, type index$4_ImageContent as ImageContent, type index$4_JSONSchema as JSONSchema, index$4_LLMRegistry as LLMRegistry, index$4_LLMRequest as LLMRequest, type index$4_LLMRequestConfig as LLMRequestConfig, index$4_LLMResponse as LLMResponse, type index$4_ListSessionOptions as ListSessionOptions, type index$4_MemoryResult as MemoryResult, type index$4_Message as Message, type index$4_MessageContent as MessageContent, type index$4_MessageRole as MessageRole, index$4_OAuth2Credential as OAuth2Credential, index$4_OAuth2Scheme as OAuth2Scheme, type index$4_OAuthFlow as OAuthFlow, type index$4_OAuthFlows as OAuthFlows, index$4_OpenAILLM as OpenAILLM, type index$4_OpenAILLMConfig as OpenAILLMConfig, index$4_OpenAILLMConnection as OpenAILLMConnection, index$4_OpenIdConnectScheme as OpenIdConnectScheme, type index$4_SearchMemoryOptions as SearchMemoryOptions, type index$4_SearchMemoryResponse as SearchMemoryResponse, type index$4_Session as Session, index$4_SessionState as SessionState, type index$4_TextContent as TextContent, type index$4_ToolCall as ToolCall, index$4_registerProviders as registerProviders };
+}
+
+/**
+ * Represents a single memory retrieval result
+ */
+interface MemoryResult {
+    /**
+     * The session ID associated with the memory
+     */
+    sessionId: string;
+    /**
+     * Array of events/messages from the session
+     */
+    events: any[];
+    /**
+     * Score indicating relevance to query (0-1)
+     */
+    relevanceScore?: number;
+}
+/**
+ * Represents the response from a memory search
+ */
+interface SearchMemoryResponse {
+    /**
+     * List of memory results matching the search query
+     */
+    memories: MemoryResult[];
+}
+/**
+ * Options for memory search
+ */
+interface SearchMemoryOptions {
+    /**
+     * Session ID to search within (null for all sessions)
+     */
+    sessionId?: string;
+    /**
+     * Maximum number of results to return
+     */
+    limit?: number;
+    /**
+     * Minimum relevance score (0-1)
+     */
+    threshold?: number;
+    /**
+     * Additional filter criteria
+     */
+    filter?: Record<string, any>;
+}
+/**
+ * Base interface for memory services
+ */
+interface BaseMemoryService {
+    /**
+     * Adds a session to the memory service
+     * @param session The session to add
+     */
+    addSessionToMemory(session: Session): Promise<void>;
+    /**
+     * Searches memory for relevant information
+     * @param query The search query
+     * @param options Search options
+     * @returns Search results
+     */
+    searchMemory(query: string, options?: SearchMemoryOptions): Promise<SearchMemoryResponse>;
+}
+
+/**
+ * Service for managing sessions
+ */
+interface SessionService {
+    /**
+     * Creates a new session
+     * @param userId User identifier
+     * @param metadata Optional session metadata
+     * @returns The created session
+     */
+    createSession(userId: string, metadata?: Record<string, any>): Promise<Session>;
+    /**
+     * Gets a session by ID
+     * @param sessionId Session identifier
+     * @returns The session or undefined if not found
+     */
+    getSession(sessionId: string): Promise<Session | undefined>;
+    /**
+     * Updates an existing session
+     * @param session The session to update
+     */
+    updateSession(session: Session): Promise<void>;
+    /**
+     * Lists sessions for a user
+     * @param userId User identifier
+     * @param options Optional filtering options
+     * @returns Array of matching sessions
+     */
+    listSessions(userId: string, options?: ListSessionOptions): Promise<Session[]>;
+    /**
+     * Deletes a session
+     * @param sessionId Session identifier
+     */
+    deleteSession(sessionId: string): Promise<void>;
+    /**
+     * Appends an event to a session object
+     * @param session The session to append the event to
+     * @param event The event to append
+     * @returns The appended event
+     */
+    appendEvent(session: Session, event: Event): Promise<Event>;
+}
+
+/**
+ * Contextual data for a specific agent invocation
+ */
+declare class InvocationContext {
+    /**
+     * Unique session ID for the current conversation
+     */
+    sessionId: string;
+    /**
+     * Current conversation history
+     */
+    messages: Message[];
+    /**
+     * Run configuration
+     */
+    config: RunConfig;
+    /**
+     * User identifier associated with the session
+     */
+    userId?: string;
+    /**
+     * Application name (for multi-app environments)
+     */
+    appName?: string;
+    /**
+     * Memory service for long-term storage
+     */
+    memoryService?: BaseMemoryService;
+    /**
+     * Session service for session management
+     */
+    sessionService?: SessionService;
+    /**
+     * Additional context metadata
+     */
+    metadata: Record<string, any>;
+    /**
+     * Variables stored in the context
+     */
+    private variables;
+    /**
+     * In-memory storage for node execution results
+     */
+    memory: Map<string, any>;
+    /**
+     * Constructor for InvocationContext
+     */
+    constructor(options?: {
+        sessionId?: string;
+        messages?: Message[];
+        config?: RunConfig;
+        userId?: string;
+        appName?: string;
+        memoryService?: BaseMemoryService;
+        sessionService?: SessionService;
+        metadata?: Record<string, any>;
+    });
+    /**
+     * Generates a unique session ID
+     */
+    private generateSessionId;
+    /**
+     * Sets a variable in the context
+     */
+    setVariable(name: string, value: any): void;
+    /**
+     * Gets a variable from the context
+     */
+    getVariable<T>(name: string, defaultValue?: T): T | undefined;
+    /**
+     * Adds a message to the conversation history
+     */
+    addMessage(message: Message): void;
+    /**
+     * Creates a new context with the same configuration but empty message history
+     */
+    createChildContext(): InvocationContext;
+    /**
+     * Loads a session from the session service
+     * @returns The loaded session or undefined if not found
+     */
+    loadSession(): Promise<Session | undefined>;
+    /**
+     * Saves the current conversation to a session
+     * @returns The saved session
+     */
+    saveSession(): Promise<Session | undefined>;
+    /**
+     * Searches memory for relevant information
+     * @param query The search query
+     * @param options Search options
+     * @returns Search results or empty response if no memory service
+     */
+    searchMemory(query: string, options?: SearchMemoryOptions): Promise<SearchMemoryResponse>;
+}
+
+/**
+ * Context for tool execution
+ */
+interface IToolContext {
+    /**
+     * Name of the tool being executed
+     */
+    toolName: string;
+    /**
+     * ID of the tool call
+     */
+    toolId: string;
+    /**
+     * Additional parameters for the tool
+     */
+    parameters: Record<string, any>;
+    /**
+     * Gets a parameter value
+     */
+    getParameter<T>(name: string, defaultValue?: T): T | undefined;
+    /**
+     * Sets a parameter value
+     */
+    setParameter(name: string, value: any): void;
+}
+/**
+ * Context for tool execution
+ */
+declare class ToolContext implements IToolContext {
+    /**
+     * The parent invocation context
+     */
+    private invocationContext;
+    /**
+     * Authentication handler for the tool
+     */
+    auth?: AuthHandler;
+    /**
+     * Additional parameters for the tool
+     */
+    parameters: Record<string, any>;
+    /**
+     * Tool name
+     */
+    toolName: string;
+    /**
+     * Tool ID
+     */
+    toolId: string;
+    /**
+     * Variables stored in the context
+     */
+    private _variables;
+    /**
+     * Constructor for ToolContext
+     */
+    constructor(options: {
+        invocationContext: InvocationContext;
+        auth?: AuthHandler;
+        parameters?: Record<string, any>;
+    });
+    /**
+     * Gets a parameter value
+     */
+    getParameter<T>(name: string, defaultValue?: T): T | undefined;
+    /**
+     * Sets a parameter value
+     */
+    setParameter(name: string, value: any): void;
+    get sessionId(): string;
+    get messages(): Message[];
+    get config(): RunConfig;
+    get userId(): string | undefined;
+    get appName(): string | undefined;
+    get memoryService(): BaseMemoryService | undefined;
+    get sessionService(): SessionService | undefined;
+    get metadata(): Record<string, any>;
+    get variables(): Map<string, any>;
+    setVariable(name: string, value: any): void;
+    getVariable<T>(name: string, defaultValue?: T): T | undefined;
+    addMessage(message: Message): void;
+    loadSession(): Promise<Session | undefined>;
+    saveSession(): Promise<Session | undefined>;
+    searchMemory(query: string, options?: SearchMemoryOptions): Promise<SearchMemoryResponse>;
+}
+
+/**
+ * Configuration for tool initialization
+ */
+interface ToolConfig {
+    /**
+     * Name of the tool
+     */
+    name: string;
+    /**
+     * Description of the tool
+     */
+    description: string;
+    /**
+     * Whether the tool is a long running operation
+     */
+    isLongRunning?: boolean;
+    /**
+     * Whether the tool execution should be retried on failure
+     */
+    shouldRetryOnFailure?: boolean;
+    /**
+     * Maximum retry attempts
+     */
+    maxRetryAttempts?: number;
+}
+/**
+ * The base class for all tools
+ */
+declare abstract class BaseTool {
+    /**
+     * Name of the tool
+     */
+    name: string;
+    /**
+     * Description of the tool
+     */
+    description: string;
+    /**
+     * Whether the tool is a long running operation
+     */
+    isLongRunning: boolean;
+    /**
+     * Whether the tool execution should be retried on failure
+     */
+    shouldRetryOnFailure: boolean;
+    /**
+     * Maximum retry attempts
+     */
+    maxRetryAttempts: number;
+    /**
+     * Base delay for retry in ms (will be used with exponential backoff)
+     */
+    baseRetryDelay: number;
+    /**
+     * Maximum delay for retry in ms
+     */
+    maxRetryDelay: number;
+    /**
+     * Constructor for BaseTool
+     */
+    constructor(config: ToolConfig);
+    /**
+     * Gets the OpenAPI specification of this tool in the form of a FunctionDeclaration
+     */
+    abstract getDeclaration(): FunctionDeclaration;
+    /**
+     * Validates the arguments against the schema in the function declaration
+     * @param args Arguments to validate
+     * @returns True if arguments are valid
+     */
+    validateArguments(args: Record<string, any>): boolean;
+    /**
+     * Runs the tool with the given arguments and context
+     * This method must be implemented by subclasses
+     *
+     * @param args Arguments for the tool
+     * @param context Tool execution context
+     * @returns Result of the tool execution
+     */
+    abstract runAsync(args: Record<string, any>, context: ToolContext): Promise<any>;
+    /**
+     * Executes the tool with error handling and retries
+     *
+     * @param args Arguments for the tool
+     * @param context Tool execution context
+     * @returns Result of the tool execution or error information
+     */
+    safeExecute(args: Record<string, any>, context: ToolContext): Promise<any>;
+}
+
+/**
+ * Configuration for Agent
+ */
+interface AgentConfig {
+    /**
+     * Name of the agent
+     */
+    name: string;
+    /**
+     * Description of the agent
+     */
+    description: string;
+    /**
+     * The LLM model to use
+     */
+    model: string;
+    /**
+     * Instructions for the agent
+     */
+    instructions?: string;
+    /**
+     * Tools available to the agent
+     */
+    tools?: BaseTool[];
+    /**
+     * Maximum number of tool execution steps
+     */
+    maxToolExecutionSteps?: number;
+    /**
+     * Memory service for long-term storage and retrieval
+     */
+    memoryService?: BaseMemoryService;
+    /**
+     * Session service for managing conversations
+     */
+    sessionService?: SessionService;
+    /**
+     * User ID for the session (required for session persistence)
+     */
+    userId?: string;
+    /**
+     * Application name (for multi-app environments)
+     */
+    appName?: string;
+    /**
+     * Whether to automatically augment prompts with relevant memory
+     */
+    useMemoryAugmentation?: boolean;
+    /**
+     * The maximum number of memory items to include in augmentation
+     */
+    maxMemoryItems?: number;
+    /**
+     * The minimum relevance score for memory augmentation (0-1)
+     */
+    memoryRelevanceThreshold?: number;
+}
+/**
+ * Standard Agent implementation that uses an LLM
+ */
+declare class Agent extends BaseAgent {
+    /**
+     * The LLM model to use
+     */
+    private model;
+    /**
+     * The LLM instance
+     */
+    private llm;
+    /**
+     * Instructions for the agent
+     */
+    private instructions?;
+    /**
+     * Tools available to the agent
+     */
+    private tools;
+    /**
+     * Maximum number of tool execution steps to prevent infinite loops
+     */
+    private maxToolExecutionSteps;
+    /**
+     * Memory service for long-term storage and retrieval
+     */
+    private memoryService?;
+    /**
+     * Session service for managing conversations
+     */
+    private sessionService?;
+    /**
+     * User ID for the session
+     */
+    private userId?;
+    /**
+     * Application name
+     */
+    private appName?;
+    /**
+     * Whether to automatically augment prompts with relevant memory
+     */
+    private useMemoryAugmentation;
+    /**
+     * The maximum number of memory items to include in augmentation
+     */
+    private maxMemoryItems;
+    /**
+     * The minimum relevance score for memory augmentation (0-1)
+     */
+    private memoryRelevanceThreshold;
+    /**
+     * Constructor for Agent
+     */
+    constructor(config: AgentConfig);
+    /**
+     * Finds a tool by name
+     */
+    private findTool;
+    /**
+     * Executes a tool call and returns the result
+     */
+    private executeTool;
+    /**
+     * Execute multiple tools in parallel
+     */
+    private executeTools;
+    /**
+     * Augments context with relevant memory
+     */
+    private augmentWithMemory;
+    /**
+     * Saves the session to memory
+     */
+    private saveToMemory;
+    /**
+     * Generates a unique session ID
+     */
+    private generateSessionId;
+    /**
+     * Runs the agent with the given messages and configuration
+     */
+    run(options: {
+        messages: Message[];
+        config?: RunConfig;
+        sessionId?: string;
+    }): Promise<LLMResponse>;
+    /**
+     * Runs the agent with streaming support
+     */
+    runStreaming(options: {
+        messages: Message[];
+        config?: RunConfig;
+        sessionId?: string;
+    }): AsyncGenerator<LLMResponse>;
+}
+
+/**
+ * Configuration for SequentialAgent
+ */
+interface SequentialAgentConfig {
+    /**
+     * Name of the agent
+     */
+    name: string;
+    /**
+     * Description of the agent
+     */
+    description: string;
+    /**
+     * Sub-agents to execute in sequence
+     */
+    agents?: BaseAgent[];
+}
+/**
+ * Extended LLMResponse interface that includes metadata
+ */
+interface EnhancedLLMResponse extends LLMResponse {
+    metadata?: Record<string, any>;
+}
+/**
+ * Sequential Agent that executes sub-agents in sequence
+ * Each sub-agent's output becomes input to the next agent
+ */
+declare class SequentialAgent extends BaseAgent {
+    /**
+     * Constructor for SequentialAgent
+     */
+    constructor(config: SequentialAgentConfig);
+    /**
+     * Runs the agent with the given messages and configuration
+     * Executes sub-agents sequentially, passing output from one to the next
+     */
+    run(options: {
+        messages: Message[];
+        config?: RunConfig;
+    }): Promise<EnhancedLLMResponse>;
+    /**
+     * Runs the agent with streaming support
+     * Streams responses from each sub-agent in sequence
+     */
+    runStreaming(options: {
+        messages: Message[];
+        config?: RunConfig;
+    }): AsyncIterable<EnhancedLLMResponse>;
+}
+
+/**
+ * Configuration for ParallelAgent
+ */
+interface ParallelAgentConfig {
+    /**
+     * Name of the agent
+     */
+    name: string;
+    /**
+     * Description of the agent
+     */
+    description: string;
+    /**
+     * Sub-agents to execute in parallel
+     */
+    agents?: BaseAgent[];
+}
+/**
+ * Parallel Agent that executes sub-agents in parallel
+ * All sub-agents execute independently with the same input
+ */
+declare class ParallelAgent extends BaseAgent {
+    /**
+     * Constructor for ParallelAgent
+     */
+    constructor(config: ParallelAgentConfig);
+    /**
+     * Runs the agent with the given messages and configuration
+     * Executes all sub-agents in parallel
+     */
+    run(options: {
+        messages: Message[];
+        config?: RunConfig;
+    }): Promise<LLMResponse>;
+    /**
+     * Runs the agent with streaming support
+     * Collects streaming responses from all sub-agents
+     */
+    runStreaming(options: {
+        messages: Message[];
+        config?: RunConfig;
+    }): AsyncIterable<LLMResponse>;
+}
+
+/**
+ * Configuration for LoopAgent
+ */
+interface LoopAgentConfig {
+    /**
+     * Name of the agent
+     */
+    name: string;
+    /**
+     * Description of the agent
+     */
+    description: string;
+    /**
+     * Sub-agent to execute in a loop
+     */
+    agent?: BaseAgent;
+    /**
+     * Maximum number of iterations
+     */
+    maxIterations?: number;
+    /**
+     * Agent that decides whether to continue the loop
+     */
+    conditionAgent?: BaseAgent;
+    /**
+     * Custom condition check function
+     */
+    conditionCheck?: (response: LLMResponse) => boolean | Promise<boolean>;
+}
+/**
+ * Loop Agent that executes sub-agents in a loop
+ * Repeatedly executes a sub-agent until a condition is met
+ */
+declare class LoopAgent extends BaseAgent {
+    /**
+     * Maximum number of iterations to prevent infinite loops
+     */
+    private maxIterations;
+    /**
+     * Agent that decides whether to continue the loop
+     */
+    private conditionAgent?;
+    /**
+     * Custom condition check function
+     */
+    private conditionCheck?;
+    /**
+     * Constructor for LoopAgent
+     */
+    constructor(config: LoopAgentConfig);
+    /**
+     * Default condition check that always returns true
+     * to continue the loop until maxIterations is reached
+     */
+    private defaultConditionCheck;
+    /**
+     * Check if the loop should continue
+     */
+    private shouldContinue;
+    /**
+     * Runs the agent with the given messages and configuration
+     * Executes the sub-agent in a loop until the condition is met
+     */
+    run(options: {
+        messages: Message[];
+        config?: RunConfig;
+    }): Promise<LLMResponse>;
+    /**
+     * Runs the agent with streaming support
+     */
+    runStreaming(options: {
+        messages: Message[];
+        config?: RunConfig;
+    }): AsyncIterable<LLMResponse>;
+}
+
+/**
+ * Represents a node in a LangGraph workflow
+ */
+interface LangGraphNode {
+    /**
+     * Name of the node
+     */
+    name: string;
+    /**
+     * Agent associated with this node
+     */
+    agent: BaseAgent;
+    /**
+     * Target nodes to execute after this node
+     */
+    targets?: string[];
+    /**
+     * Condition function to determine if this node should execute
+     */
+    condition?: (result: LLMResponse, context: InvocationContext) => boolean | Promise<boolean>;
+}
+/**
+ * Configuration for LangGraphAgent
+ */
+interface LangGraphAgentConfig {
+    /**
+     * Name of the agent
+     */
+    name: string;
+    /**
+     * Description of the agent
+     */
+    description: string;
+    /**
+     * Graph nodes (agents and their connections)
+     */
+    nodes: LangGraphNode[];
+    /**
+     * Root node to start execution from
+     */
+    rootNode: string;
+    /**
+     * Maximum number of steps to prevent infinite loops
+     */
+    maxSteps?: number;
+}
+/**
+ * LangGraphAgent that implements a directed graph of agents
+ * Allows complex workflows with conditional branching
+ */
+declare class LangGraphAgent extends BaseAgent {
+    /**
+     * Graph nodes (agents and their connections)
+     */
+    private nodes;
+    /**
+     * Root node to start execution from
+     */
+    private rootNode;
+    /**
+     * Maximum number of steps to prevent infinite loops
+     */
+    private maxSteps;
+    /**
+     * Results from node executions
+     */
+    private results;
+    /**
+     * Constructor for LangGraphAgent
+     */
+    constructor(config: LangGraphAgentConfig);
+    /**
+     * Validates the graph for potential issues
+     */
+    private validateGraph;
+    /**
+     * Check if a value is an LLMResponse
+     */
+    private isLLMResponse;
+    /**
+     * Extracts text from MessageContent
+     */
+    private extractTextContent;
+    /**
+     * Gets the next nodes to execute based on the current node and its result
+     */
+    private getNextNodes;
+    /**
+     * Conditionally execute the next node if the condition is met
+     */
+    private executeConditionalNode;
+    /**
+     * Runs the agent with the given messages and configuration
+     * Executes the graph by traversing nodes based on conditions
+     */
+    run(options: {
+        messages: Message[];
+        config?: RunConfig;
+    }): Promise<LLMResponse>;
+    /**
+     * Runs the agent with streaming support
+     */
+    runStreaming(options: {
+        messages: Message[];
+        config?: RunConfig;
+    }): AsyncIterable<LLMResponse>;
+}
+
+type index$3_Agent = Agent;
+declare const index$3_Agent: typeof Agent;
+type index$3_AgentConfig = AgentConfig;
+type index$3_AudioTranscriptionConfig = AudioTranscriptionConfig;
+type index$3_BaseAgent = BaseAgent;
+declare const index$3_BaseAgent: typeof BaseAgent;
+type index$3_InvocationContext = InvocationContext;
+declare const index$3_InvocationContext: typeof InvocationContext;
+type index$3_LangGraphAgent = LangGraphAgent;
+declare const index$3_LangGraphAgent: typeof LangGraphAgent;
+type index$3_LangGraphAgentConfig = LangGraphAgentConfig;
+type index$3_LangGraphNode = LangGraphNode;
+type index$3_LoopAgent = LoopAgent;
+declare const index$3_LoopAgent: typeof LoopAgent;
+type index$3_LoopAgentConfig = LoopAgentConfig;
+type index$3_ParallelAgent = ParallelAgent;
+declare const index$3_ParallelAgent: typeof ParallelAgent;
+type index$3_ParallelAgentConfig = ParallelAgentConfig;
+type index$3_RunConfig = RunConfig;
+declare const index$3_RunConfig: typeof RunConfig;
+type index$3_SequentialAgent = SequentialAgent;
+declare const index$3_SequentialAgent: typeof SequentialAgent;
+type index$3_SequentialAgentConfig = SequentialAgentConfig;
+type index$3_SpeechConfig = SpeechConfig;
+type index$3_StreamingMode = StreamingMode;
+declare const index$3_StreamingMode: typeof StreamingMode;
+declare namespace index$3 {
+  export { index$3_Agent as Agent, type index$3_AgentConfig as AgentConfig, type index$3_AudioTranscriptionConfig as AudioTranscriptionConfig, index$3_BaseAgent as BaseAgent, index$3_InvocationContext as InvocationContext, index$3_LangGraphAgent as LangGraphAgent, type index$3_LangGraphAgentConfig as LangGraphAgentConfig, type index$3_LangGraphNode as LangGraphNode, index$3_LoopAgent as LoopAgent, type index$3_LoopAgentConfig as LoopAgentConfig, index$3_ParallelAgent as ParallelAgent, type index$3_ParallelAgentConfig as ParallelAgentConfig, index$3_RunConfig as RunConfig, index$3_SequentialAgent as SequentialAgent, type index$3_SequentialAgentConfig as SequentialAgentConfig, type index$3_SpeechConfig as SpeechConfig, index$3_StreamingMode as StreamingMode };
+}
+
+/**
+ * A tool that wraps a user-defined TypeScript function.
+ *
+ * This tool automatically generates a function declaration from the function's
+ * signature and documentation, making it easy to expose functions to agents.
+ */
+declare class FunctionTool<T extends Record<string, any>> extends BaseTool {
+    private func;
+    private mandatoryArgs;
+    /**
+     * Creates a new FunctionTool wrapping the provided function.
+     *
+     * @param func The function to wrap
+     * @param options Optional configuration for the tool
+     */
+    constructor(func: (...args: any[]) => any, options?: {
+        name?: string;
+        description?: string;
+        isLongRunning?: boolean;
+        shouldRetryOnFailure?: boolean;
+        maxRetryAttempts?: number;
+    });
+    /**
+     * Executes the wrapped function with the provided arguments.
+     */
+    runAsync(args: T, context: ToolContext): Promise<any>;
+    /**
+     * Returns the function declaration for this tool.
+     */
+    getDeclaration(): FunctionDeclaration;
+    /**
+     * Checks if the wrapped function accepts a toolContext parameter.
+     */
+    private functionAcceptsToolContext;
+    /**
+     * Checks if the wrapped function is async.
+     */
+    private isAsyncFunction;
+    /**
+     * Extracts the mandatory arguments from a function.
+     * In TypeScript, we can't easily inspect parameter defaults at runtime,
+     * so this is a best-effort approach.
+     */
+    private getMandatoryArgs;
+    /**
+     * Checks which mandatory arguments are missing from the provided args.
+     */
+    private getMissingMandatoryArgs;
+}
+
+/**
+ * Options for building a function declaration
+ */
+interface BuildFunctionDeclarationOptions {
+    name?: string;
+    description?: string;
+    ignoreParams?: string[];
+}
+/**
+ * Builds a function declaration from a TypeScript function.
+ *
+ * This utility analyzes the function signature and JSDoc comments to create
+ * a FunctionDeclaration object that can be used with LLMs.
+ *
+ * @param func The function to analyze
+ * @param options Options for customizing the declaration
+ * @returns A FunctionDeclaration representing the function
+ */
+declare function buildFunctionDeclaration(func: (...args: any[]) => any, options?: BuildFunctionDeclarationOptions): FunctionDeclaration;
+
+/**
+ * Creates a new FunctionTool that wraps a function.
+ * This is a convenience function for creating a new FunctionTool.
+ *
+ * @param func The function to wrap
+ * @param options Optional configuration for the tool
+ * @returns A new FunctionTool wrapping the function
+ */
+declare function createFunctionTool(func: (...args: any[]) => any, options?: {
+    name?: string;
+    description?: string;
+    isLongRunning?: boolean;
+    shouldRetryOnFailure?: boolean;
+    maxRetryAttempts?: number;
+}): any;
+
+/**
+ * Simple GoogleSearch tool implementation
+ */
+declare class GoogleSearch extends BaseTool {
+    /**
+     * 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>;
+}
+
+interface HttpRequestResult {
+    statusCode: number;
+    headers: Record<string, string>;
+    body: string;
+    error?: string;
+}
+/**
+ * Tool for making HTTP requests to external APIs and web services
+ */
+declare class HttpRequestTool extends BaseTool {
+    constructor();
+    /**
+     * Get the function declaration for the tool
+     */
+    getDeclaration(): FunctionDeclaration;
+    /**
+     * Execute the HTTP request
+     */
+    runAsync(args: {
+        url: string;
+        method?: string;
+        headers?: Record<string, string>;
+        body?: string;
+        params?: Record<string, string>;
+        timeout?: number;
+    }, _context: ToolContext): Promise<HttpRequestResult>;
+    /**
+     * Check if a string is valid JSON
+     */
+    private isValidJson;
+}
+
+interface FileOperationResult {
+    success: boolean;
+    data?: any;
+    error?: string;
+}
+/**
+ * Tool for performing file system operations
+ */
+declare class FileOperationsTool extends BaseTool {
+    private basePath;
+    constructor(options?: {
+        basePath?: string;
+    });
+    /**
+     * Get the function declaration for the tool
+     */
+    getDeclaration(): FunctionDeclaration;
+    /**
+     * Execute the file operation
+     */
+    runAsync(args: {
+        operation: "read" | "write" | "append" | "delete" | "exists" | "list" | "mkdir";
+        filepath: string;
+        content?: string;
+        encoding?: BufferEncoding;
+    }, _context: ToolContext): Promise<FileOperationResult>;
+    /**
+     * Resolve a file path relative to the base path
+     */
+    private resolvePath;
+    /**
+     * Validate that a path is within the base path for security
+     */
+    private validatePath;
+    /**
+     * Read a file
+     */
+    private readFile;
+    /**
+     * Write to a file
+     */
+    private writeFile;
+    /**
+     * Append to a file
+     */
+    private appendFile;
+    /**
+     * Delete a file
+     */
+    private deleteFile;
+    /**
+     * Check if a file exists
+     */
+    private fileExists;
+    /**
+     * List directory contents
+     */
+    private listDirectory;
+    /**
+     * Create a directory
+     */
+    private makeDirectory;
+}
+
+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>;
+}
+
+declare module "./tool-context" {
+    interface ToolContext {
+        actions?: {
+            escalate?: boolean;
+            skip_summarization?: boolean;
+            transfer_to_agent?: string;
+        };
+    }
+}
+
+/**
+ * Tool that allows an agent to exit the current execution loop
+ */
+declare class ExitLoopTool extends BaseTool {
+    /**
+     * Constructor for ExitLoopTool
+     */
+    constructor();
+    /**
+     * Get the function declaration for the tool
+     */
+    getDeclaration(): FunctionDeclaration;
+    /**
+     * Execute the exit loop action
+     */
+    runAsync(_args: Record<string, any>, context: ToolContext): Promise<any>;
+}
+
+/**
+ * Tool that allows an agent to get a choice from the user
+ */
+declare class GetUserChoiceTool extends BaseTool {
+    /**
+     * Constructor for GetUserChoiceTool
+     */
+    constructor();
+    /**
+     * Get the function declaration for the tool
+     */
+    getDeclaration(): FunctionDeclaration;
+    /**
+     * Execute the user choice action
+     * This is a long running operation that will return null initially
+     * and the actual choice will be provided asynchronously
+     */
+    runAsync(args: {
+        options: string[];
+        question?: string;
+    }, context: ToolContext): Promise<any>;
+}
+
+/**
+ * Tool that allows an agent to transfer control to another agent
+ */
+declare class TransferToAgentTool extends BaseTool {
+    /**
+     * 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<any>;
+}
+
+/**
+ * Tool that allows an agent to load memories relevant to a query
+ */
+declare class LoadMemoryTool extends BaseTool {
+    /**
+     * 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<any>;
+}
+
+/**
+ * Tools module exports
+ */
+
+type index$2_BaseTool = BaseTool;
+declare const index$2_BaseTool: typeof BaseTool;
+type index$2_BuildFunctionDeclarationOptions = BuildFunctionDeclarationOptions;
+type index$2_ExitLoopTool = ExitLoopTool;
+declare const index$2_ExitLoopTool: typeof ExitLoopTool;
+type index$2_FileOperationsTool = FileOperationsTool;
+declare const index$2_FileOperationsTool: typeof FileOperationsTool;
+type index$2_FunctionTool<T extends Record<string, any>> = FunctionTool<T>;
+declare const index$2_FunctionTool: typeof FunctionTool;
+type index$2_GetUserChoiceTool = GetUserChoiceTool;
+declare const index$2_GetUserChoiceTool: typeof GetUserChoiceTool;
+type index$2_GoogleSearch = GoogleSearch;
+declare const index$2_GoogleSearch: typeof GoogleSearch;
+type index$2_HttpRequestTool = HttpRequestTool;
+declare const index$2_HttpRequestTool: typeof HttpRequestTool;
+type index$2_IToolContext = IToolContext;
+type index$2_LoadMemoryTool = LoadMemoryTool;
+declare const index$2_LoadMemoryTool: typeof LoadMemoryTool;
+type index$2_ToolConfig = ToolConfig;
+type index$2_ToolContext = ToolContext;
+declare const index$2_ToolContext: typeof ToolContext;
+type index$2_TransferToAgentTool = TransferToAgentTool;
+declare const index$2_TransferToAgentTool: typeof TransferToAgentTool;
+type index$2_UserInteractionTool = UserInteractionTool;
+declare const index$2_UserInteractionTool: typeof UserInteractionTool;
+declare const index$2_buildFunctionDeclaration: typeof buildFunctionDeclaration;
+declare const index$2_createFunctionTool: typeof createFunctionTool;
+declare namespace index$2 {
+  export { index$2_BaseTool as BaseTool, type index$2_BuildFunctionDeclarationOptions as BuildFunctionDeclarationOptions, index$2_ExitLoopTool as ExitLoopTool, index$2_FileOperationsTool as FileOperationsTool, index$2_FunctionTool as FunctionTool, index$2_GetUserChoiceTool as GetUserChoiceTool, index$2_GoogleSearch as GoogleSearch, index$2_HttpRequestTool as HttpRequestTool, type index$2_IToolContext as IToolContext, index$2_LoadMemoryTool as LoadMemoryTool, type index$2_ToolConfig as ToolConfig, index$2_ToolContext as ToolContext, index$2_TransferToAgentTool as TransferToAgentTool, index$2_UserInteractionTool as UserInteractionTool, index$2_buildFunctionDeclaration as buildFunctionDeclaration, index$2_createFunctionTool as createFunctionTool };
+}
+
+/**
+ * An in-memory memory service for development and testing
+ * Stores sessions and conversations in memory without persistence
+ */
+declare class InMemoryMemoryService implements BaseMemoryService {
+    /**
+     * Map of sessions by ID
+     */
+    private sessions;
+    /**
+     * Constructor for InMemoryMemoryService
+     */
+    constructor();
+    /**
+     * Adds a session to the memory service
+     * @param session The session to add
+     */
+    addSessionToMemory(session: Session): Promise<void>;
+    /**
+     * Searches memory for relevant information
+     * @param query The search query
+     * @param options Search options
+     * @returns Search results
+     */
+    searchMemory(query: string, options?: SearchMemoryOptions): Promise<SearchMemoryResponse>;
+    /**
+     * Gets all sessions in the memory service
+     * @returns All sessions
+     */
+    getAllSessions(): Session[];
+    /**
+     * Gets a session by ID
+     * @param sessionId The session ID
+     * @returns The session or undefined if not found
+     */
+    getSession(sessionId: string): Session | undefined;
+    /**
+     * Clears all sessions from memory
+     */
+    clear(): void;
+}
+
+/**
+ * Configuration for PersistentMemoryService
+ */
+interface PersistentMemoryServiceConfig {
+    /**
+     * Directory where memory files will be stored
+     */
+    storageDir: string;
+    /**
+     * Whether to create the storage directory if it doesn't exist
+     */
+    createDir?: boolean;
+    /**
+     * File prefix for memory files
+     */
+    filePrefix?: string;
+}
+/**
+ * A file-based implementation of memory service that persists data to disk
+ * This provides durability across application restarts
+ */
+declare class PersistentMemoryService implements BaseMemoryService {
+    /**
+     * In-memory service used for search operations
+     */
+    private inMemoryService;
+    /**
+     * Directory where memory files will be stored
+     */
+    private storageDir;
+    /**
+     * File prefix for memory files
+     */
+    private filePrefix;
+    /**
+     * Constructor for PersistentMemoryService
+     */
+    constructor(config: PersistentMemoryServiceConfig);
+    /**
+     * Adds a session to memory and persists to disk
+     * @param session The session to add
+     */
+    addSessionToMemory(session: Session): Promise<void>;
+    /**
+     * Searches memory for relevant information
+     * @param query The search query
+     * @param options Search options
+     * @returns Search results
+     */
+    searchMemory(query: string, options?: SearchMemoryOptions): Promise<SearchMemoryResponse>;
+    /**
+     * Persists a session to disk
+     * @param session The session to save
+     */
+    private saveSessionToDisk;
+    /**
+     * Gets the file path for a session
+     * @param sessionId The session ID
+     * @returns The file path
+     */
+    private getSessionFilePath;
+    /**
+     * Loads all memory files from disk
+     */
+    private loadMemoryFiles;
+    /**
+     * Gets all sessions in memory
+     * @returns Array of sessions
+     */
+    getAllSessions(): Session[];
+    /**
+     * Gets a session by ID
+     * @param sessionId Session ID
+     * @returns The session or undefined if not found
+     */
+    getSession(sessionId: string): Session | undefined;
+    /**
+     * Deletes a session from memory and disk
+     * @param sessionId Session ID to delete
+     */
+    deleteSession(sessionId: string): Promise<void>;
+    /**
+     * Clears all sessions from memory and disk
+     */
+    clear(): Promise<void>;
+}
+
+/**
+ * Memory Services for the Agent Development Kit
+ */
+
+type index$1_InMemoryMemoryService = InMemoryMemoryService;
+declare const index$1_InMemoryMemoryService: typeof InMemoryMemoryService;
+type index$1_PersistentMemoryService = PersistentMemoryService;
+declare const index$1_PersistentMemoryService: typeof PersistentMemoryService;
+declare namespace index$1 {
+  export { index$1_InMemoryMemoryService as InMemoryMemoryService, index$1_PersistentMemoryService as PersistentMemoryService };
+}
+
+/**
+ * In-memory implementation of SessionService
+ */
+declare class InMemorySessionService implements SessionService {
+    /**
+     * Map of sessions by ID
+     */
+    private sessions;
+    /**
+     * Constructor for InMemorySessionService
+     */
+    constructor();
+    /**
+     * Creates a new session
+     * @param userId User identifier
+     * @param metadata Optional session metadata
+     * @returns The created session
+     */
+    createSession(userId: string, metadata?: Record<string, any>): Promise<Session>;
+    /**
+     * Gets a session by ID
+     * @param sessionId Session identifier
+     * @returns The session or undefined if not found
+     */
+    getSession(sessionId: string): Promise<Session | undefined>;
+    /**
+     * Updates an existing session
+     * @param session The session to update
+     */
+    updateSession(session: Session): Promise<void>;
+    /**
+     * Lists sessions for a user
+     * @param userId User identifier
+     * @param options Optional filtering options
+     * @returns Array of matching sessions
+     */
+    listSessions(userId: string, options?: ListSessionOptions): Promise<Session[]>;
+    /**
+     * Deletes a session
+     * @param sessionId Session identifier
+     */
+    deleteSession(sessionId: string): Promise<void>;
+    /**
+     * Clears all sessions
+     */
+    clear(): void;
+    /**
+     * Generates a unique session ID
+     * @returns A unique session ID
+     */
+    private generateSessionId;
+    /**
+     * Appends an event to a session object
+     * @param session The session to append the event to
+     * @param event The event to append
+     * @returns The appended event
+     */
+    appendEvent(session: Session, event: Event): Promise<Event>;
+}
+
+declare const sessionsSchema$1: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "sessions";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "sessions";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        userId: drizzle_orm_pg_core.PgColumn<{
+            name: "user_id";
+            tableName: "sessions";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        messages: drizzle_orm_pg_core.PgColumn<{
+            name: "messages";
+            tableName: "sessions";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Message[];
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Message[];
+        }>;
+        metadata: drizzle_orm_pg_core.PgColumn<{
+            name: "metadata";
+            tableName: "sessions";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, any>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, any>;
+        }>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "sessions";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "updated_at";
+            tableName: "sessions";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        state: drizzle_orm_pg_core.PgColumn<{
+            name: "state";
+            tableName: "sessions";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, any>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, any>;
+        }>;
+    };
+    dialect: "pg";
+}>;
+type SessionsTable$1 = typeof sessionsSchema$1;
+/**
+ * Configuration for DatabaseSessionService with Drizzle
+ */
+interface DatabaseSessionServiceConfig$1 {
+    /**
+     * An initialized Drizzle ORM database client instance.
+     * Example: drizzle(new Pool({ connectionString: '...' }), { schema: { sessions: sessionsSchema } })
+     */
+    db: NodePgDatabase<{
+        sessions: SessionsTable$1;
+    }>;
+    /**
+     * Optional: Pass the sessions schema table directly if not attached to db client's schema property
+     */
+    sessionsTable?: SessionsTable$1;
+}
+declare class PostgresSessionService implements SessionService {
+    private db;
+    private sessionsTable;
+    constructor(config: DatabaseSessionServiceConfig$1);
+    private generateSessionId;
+    createSession(userId: string, metadata?: Record<string, any>): Promise<Session>;
+    getSession(sessionId: string): Promise<Session | undefined>;
+    updateSession(session: Session): Promise<void>;
+    listSessions(userId: string, options?: ListSessionOptions): Promise<Session[]>;
+    deleteSession(sessionId: string): Promise<void>;
+    /**
+     * Appends an event to a session object
+     * @param session The session to append the event to
+     * @param event The event to append
+     * @returns The appended event
+     */
+    appendEvent(session: Session, event: Event): Promise<Event>;
+}
+
+declare const sessionsSchema: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "sessions";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "sessions";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        userId: drizzle_orm_pg_core.PgColumn<{
+            name: "user_id";
+            tableName: "sessions";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        messages: drizzle_orm_pg_core.PgColumn<{
+            name: "messages";
+            tableName: "sessions";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Message[];
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Message[];
+        }>;
+        metadata: drizzle_orm_pg_core.PgColumn<{
+            name: "metadata";
+            tableName: "sessions";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, any>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, any>;
+        }>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "sessions";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "updated_at";
+            tableName: "sessions";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        state: drizzle_orm_pg_core.PgColumn<{
+            name: "state";
+            tableName: "sessions";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, any>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, any>;
+        }>;
+    };
+    dialect: "pg";
+}>;
+type SessionsTable = typeof sessionsSchema;
+/**
+ * Configuration for DatabaseSessionService with Drizzle and PGlite
+ */
+interface DatabaseSessionServiceConfig {
+    /**
+     * An initialized Drizzle ORM database client instance with PGlite.
+     * Example: drizzle(new PGlite(), { schema: { sessions: sessionsSchema } })
+     */
+    db: PgliteDatabase<{
+        sessions: SessionsTable;
+    }>;
+    /**
+     * Optional: Pass the sessions schema table directly if not attached to db client's schema property
+     */
+    sessionsTable?: SessionsTable;
+    /**
+     * Optional: Skip automatic table creation if you handle migrations externally
+     */
+    skipTableCreation?: boolean;
+}
+declare class PgLiteSessionService implements SessionService {
+    private db;
+    private sessionsTable;
+    private initialized;
+    constructor(config: DatabaseSessionServiceConfig);
+    /**
+     * Initialize the database by creating required tables if they don't exist
+     */
+    private initializeDatabase;
+    /**
+     * Ensure database is initialized before any operation
+     */
+    private ensureInitialized;
+    private generateSessionId;
+    createSession(userId: string, metadata?: Record<string, any>): Promise<Session>;
+    getSession(sessionId: string): Promise<Session | undefined>;
+    updateSession(session: Session): Promise<void>;
+    listSessions(userId: string, options?: ListSessionOptions): Promise<Session[]>;
+    deleteSession(sessionId: string): Promise<void>;
+    /**
+     * Appends an event to a session object
+     * @param session The session to append the event to
+     * @param event The event to append
+     * @returns The appended event
+     */
+    appendEvent(session: Session, event: Event): Promise<Event>;
+}
+
+/**
+ * Utility functions for working with sessions
+ */
+
+/**
+ * Generates a unique session ID
+ * @returns A unique session ID
+ */
+declare function generateSessionId(): string;
+/**
+ * Validates a session object
+ * @param session The session to validate
+ * @throws Error if session is invalid
+ */
+declare function validateSession(session: Session): void;
+/**
+ * Deep clones a session object
+ * @param session The session to clone
+ * @returns A deep clone of the session
+ */
+declare function cloneSession(session: Session): Session;
+
+/**
+ * Sessions module exports
+ */
+
+type index_InMemorySessionService = InMemorySessionService;
+declare const index_InMemorySessionService: typeof InMemorySessionService;
+type index_ListSessionOptions = ListSessionOptions;
+type index_PgLiteSessionService = PgLiteSessionService;
+declare const index_PgLiteSessionService: typeof PgLiteSessionService;
+type index_PostgresSessionService = PostgresSessionService;
+declare const index_PostgresSessionService: typeof PostgresSessionService;
+type index_Session = Session;
+type index_SessionService = SessionService;
+type index_SessionState = SessionState;
+declare const index_SessionState: typeof SessionState;
+declare const index_cloneSession: typeof cloneSession;
+declare const index_generateSessionId: typeof generateSessionId;
+declare const index_validateSession: typeof validateSession;
+declare namespace index {
+  export { index_InMemorySessionService as InMemorySessionService, type index_ListSessionOptions as ListSessionOptions, index_PgLiteSessionService as PgLiteSessionService, index_PostgresSessionService as PostgresSessionService, type index_Session as Session, type index_SessionService as SessionService, index_SessionState as SessionState, index_cloneSession as cloneSession, index_generateSessionId as generateSessionId, index_validateSession as validateSession };
+}
+
+/**
+ * The Runner class is used to run agents.
+ * It manages the execution of an agent within a session, handling message
+ * processing, event generation, and interaction with various services.
+ */
+declare class Runner {
+    /**
+     * The app name of the runner.
+     */
+    appName: string;
+    /**
+     * The root agent to run.
+     */
+    agent: BaseAgent;
+    /**
+     * The session service for the runner.
+     */
+    sessionService: SessionService;
+    /**
+     * The memory service for the runner.
+     */
+    memoryService?: BaseMemoryService;
+    /**
+     * Initializes the Runner.
+     */
+    constructor({ appName, agent, sessionService, memoryService, }: {
+        appName: string;
+        agent: BaseAgent;
+        sessionService: SessionService;
+        memoryService?: BaseMemoryService;
+    });
+    /**
+     * Main entry method to run the agent in this runner.
+     */
+    runAsync({ userId, sessionId, newMessage, runConfig, }: {
+        userId: string;
+        sessionId: string;
+        newMessage: Message;
+        runConfig?: RunConfig;
+    }): AsyncGenerator<Event, void, unknown>;
+    /**
+     * Appends a new message to the session.
+     */
+    private _appendNewMessageToSession;
+    /**
+     * Creates a new invocation context.
+     */
+    private _newInvocationContext;
+}
+/**
+ * An in-memory Runner for testing and development.
+ */
+declare class InMemoryRunner extends Runner {
+    /**
+     * Initializes the InMemoryRunner.
+     */
+    constructor(agent: BaseAgent, { appName }?: {
+        appName?: string;
+    });
+}
+
+declare const VERSION = "0.1.0";
+
+export { Agent, type AgentConfig, index$3 as Agents, AnthropicLLM, type AnthropicLLMConfig, AnthropicLLMConnection, ApiKeyCredential, ApiKeyScheme, type AudioTranscriptionConfig, AuthConfig, AuthCredential, AuthCredentialType, AuthHandler, AuthScheme, AuthSchemeType, BaseAgent, BaseLLM, BaseLLMConnection, type BaseMemoryService, BaseTool, BasicAuthCredential, BearerTokenCredential, type BuildFunctionDeclarationOptions, ExitLoopTool, FileOperationsTool, type FunctionCall, type FunctionDeclaration, FunctionTool, GetUserChoiceTool, GoogleLLM, type GoogleLLMConfig, GoogleSearch, HttpRequestTool, HttpScheme, type IToolContext, type ImageContent, InMemoryMemoryService, InMemoryRunner, InMemorySessionService, InvocationContext, type JSONSchema, LLMRegistry, LLMRequest, type LLMRequestConfig, LLMResponse, LangGraphAgent, type LangGraphAgentConfig, type LangGraphNode, type ListSessionOptions, LoadMemoryTool, LoopAgent, type LoopAgentConfig, index$1 as Memory, type MemoryResult, type Message, type MessageContent, type MessageRole, index$4 as Models, OAuth2Credential, OAuth2Scheme, type OAuthFlow, type OAuthFlows, OpenAILLM, type OpenAILLMConfig, OpenAILLMConnection, OpenIdConnectScheme, ParallelAgent, type ParallelAgentConfig, PersistentMemoryService, PgLiteSessionService, PostgresSessionService, RunConfig, Runner, type SearchMemoryOptions, type SearchMemoryResponse, SequentialAgent, type SequentialAgentConfig, type Session, type SessionService, SessionState, index as Sessions, type SpeechConfig, StreamingMode, type TextContent, type ToolCall, type ToolConfig, ToolContext, index$2 as Tools, TransferToAgentTool, UserInteractionTool, VERSION, buildFunctionDeclaration, cloneSession, createFunctionTool, generateSessionId, registerProviders, validateSession };