@iqai/adk 0.5.6 → 0.5.7

package/dist/index.d.ts

@@ -1679,104 +1679,107 @@ declare class AgentTool extends BaseTool {
 }
 
 /**
- * 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.
+ * Tool that allows an agent to exit the current execution loop
  */
-declare class FunctionTool<T extends Record<string, any>> extends BaseTool {
-    private func;
-    private mandatoryArgs;
-    private parameterTypes;
+declare class ExitLoopTool extends BaseTool {
+    protected logger: Logger;
     /**
-     * Creates a new FunctionTool wrapping the provided function.
-     *
-     * @param func The function to wrap
-     * @param options Optional configuration for the tool
+     * Constructor for ExitLoopTool
      */
-    constructor(func: (...args: any[]) => any, options?: {
-        name?: string;
-        description?: string;
-        isLongRunning?: boolean;
-        shouldRetryOnFailure?: boolean;
-        maxRetryAttempts?: number;
-        parameterTypes?: Record<string, string>;
-    });
+    constructor();
     /**
-     * Executes the wrapped function with the provided arguments.
+     * Execute the exit loop action
      */
-    runAsync(args: T, context: ToolContext): Promise<any>;
+    runAsync(_args: Record<string, any>, context: ToolContext): Promise<any>;
+}
+
+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;
+    });
     /**
-     * Returns the function declaration for this tool.
+     * Get the function declaration for the tool
      */
     getDeclaration(): FunctionDeclaration;
     /**
-     * Checks if the wrapped function accepts a toolContext parameter.
+     * Execute the file operation
      */
-    private functionAcceptsToolContext;
+    runAsync(args: {
+        operation: "read" | "write" | "append" | "delete" | "exists" | "list" | "mkdir";
+        filepath: string;
+        content?: string;
+        encoding?: BufferEncoding;
+    }, _context: ToolContext): Promise<FileOperationResult>;
     /**
-     * Checks if the wrapped function is async.
+     * Resolve a file path relative to the base path
      */
-    private isAsyncFunction;
+    private resolvePath;
     /**
-     * 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.
+     * Validate that a path is within the base path for security
      */
-    private getMandatoryArgs;
+    private validatePath;
     /**
-     * Checks which mandatory arguments are missing from the provided args.
+     * Read a file
      */
-    private getMissingMandatoryArgs;
+    private readFile;
     /**
-     * Extracts the function parameters from the function's signature.
+     * Write to a file
      */
-    private getFunctionParameters;
+    private writeFile;
     /**
-     * Converts an argument to the proper type based on the function signature.
+     * Append to a file
      */
-    private convertArgumentType;
+    private appendFile;
     /**
-     * Extracts the type of a specific parameter from the function signature.
+     * Delete a file
      */
-    private getParameterType;
+    private deleteFile;
+    /**
+     * Check if a file exists
+     */
+    private fileExists;
+    /**
+     * List directory contents
+     */
+    private listDirectory;
+    /**
+     * Create a directory
+     */
+    private makeDirectory;
 }
 
 /**
- * Options for building a function declaration
+ * Tool that allows an agent to get a choice from the user
  */
-interface BuildFunctionDeclarationOptions {
-    name?: string;
-    description?: string;
-    ignoreParams?: string[];
+declare class GetUserChoiceTool extends BaseTool {
+    protected logger: Logger;
+    /**
+     * 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>;
 }
-/**
- * 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
@@ -1833,68 +1836,77 @@ declare class HttpRequestTool extends BaseTool {
     private isValidJson;
 }
 
-interface FileOperationResult {
-    success: boolean;
-    data?: any;
-    error?: string;
-}
 /**
- * Tool for performing file system operations
+ * A tool that loads the artifacts and adds them to the session.
  */
-declare class FileOperationsTool extends BaseTool {
-    private basePath;
-    constructor(options?: {
-        basePath?: string;
-    });
+declare class LoadArtifactsTool extends BaseTool {
+    constructor();
     /**
      * Get the function declaration for the tool
      */
     getDeclaration(): FunctionDeclaration;
     /**
-     * Execute the file operation
+     * Execute the load artifacts operation
      */
     runAsync(args: {
-        operation: "read" | "write" | "append" | "delete" | "exists" | "list" | "mkdir";
-        filepath: string;
-        content?: string;
-        encoding?: BufferEncoding;
-    }, _context: ToolContext): Promise<FileOperationResult>;
+        artifact_names?: string[];
+    }, context: ToolContext): Promise<{
+        artifact_names: string[];
+    }>;
     /**
-     * Resolve a file path relative to the base path
+     * Processes the outgoing LLM request for this tool.
      */
-    private resolvePath;
+    processLlmRequest(toolContext: ToolContext, llmRequest: LlmRequest): Promise<void>;
     /**
-     * Validate that a path is within the base path for security
+     * Appends artifacts information to the LLM request
      */
-    private validatePath;
+    private appendArtifactsToLlmRequest;
     /**
-     * Read a file
+     * Extracts function response from a part if it exists
      */
-    private readFile;
+    private extractFunctionResponse;
+}
+
+/**
+ * Tool that allows an agent to load memories relevant to a query
+ */
+declare class LoadMemoryTool extends BaseTool {
+    protected logger: Logger;
     /**
-     * Write to a file
+     * Constructor for LoadMemoryTool
      */
-    private writeFile;
+    constructor();
     /**
-     * Append to a file
+     * Get the function declaration for the tool
      */
-    private appendFile;
+    getDeclaration(): FunctionDeclaration;
     /**
-     * Delete a file
+     * Execute the memory loading action
      */
-    private deleteFile;
+    runAsync(args: {
+        query: string;
+    }, context: ToolContext): Promise<any>;
+}
+
+/**
+ * Tool that allows an agent to transfer control to another agent
+ */
+declare class TransferToAgentTool extends BaseTool {
+    protected logger: Logger;
     /**
-     * Check if a file exists
+     * Constructor for TransferToAgentTool
      */
-    private fileExists;
+    constructor();
     /**
-     * List directory contents
+     * Get the function declaration for the tool
      */
-    private listDirectory;
+    getDeclaration(): FunctionDeclaration;
     /**
-     * Create a directory
+     * Execute the transfer to agent action
      */
-    private makeDirectory;
+    runAsync(args: {
+        agent_name: string;
+    }, context: ToolContext): Promise<any>;
 }
 
 interface UserInteractionResult {
@@ -1922,116 +1934,104 @@ declare class UserInteractionTool extends BaseTool {
 }
 
 /**
- * Tool that allows an agent to exit the current execution loop
+ * 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 ExitLoopTool extends BaseTool {
-    protected logger: Logger;
-    /**
-     * Constructor for ExitLoopTool
-     */
-    constructor();
+declare class FunctionTool<T extends Record<string, any>> extends BaseTool {
+    private func;
+    private mandatoryArgs;
+    private parameterTypes;
     /**
-     * Execute the exit loop action
+     * Creates a new FunctionTool wrapping the provided function.
+     *
+     * @param func The function to wrap
+     * @param options Optional configuration for the tool
      */
-    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 {
-    protected logger: Logger;
+    constructor(func: (...args: any[]) => any, options?: {
+        name?: string;
+        description?: string;
+        isLongRunning?: boolean;
+        shouldRetryOnFailure?: boolean;
+        maxRetryAttempts?: number;
+        parameterTypes?: Record<string, string>;
+    });
     /**
-     * Constructor for GetUserChoiceTool
+     * Executes the wrapped function with the provided arguments.
      */
-    constructor();
+    runAsync(args: T, context: ToolContext): Promise<any>;
     /**
-     * Get the function declaration for the tool
+     * Returns the function declaration for this 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
+     * Checks if the wrapped function accepts a toolContext parameter.
      */
-    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 {
-    protected logger: Logger;
+    private functionAcceptsToolContext;
     /**
-     * Constructor for TransferToAgentTool
+     * Checks if the wrapped function is async.
      */
-    constructor();
+    private isAsyncFunction;
     /**
-     * Get the function declaration for the tool
+     * 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.
      */
-    getDeclaration(): FunctionDeclaration;
+    private getMandatoryArgs;
     /**
-     * Execute the transfer to agent action
+     * Checks which mandatory arguments are missing from the provided args.
      */
-    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 {
-    protected logger: Logger;
+    private getMissingMandatoryArgs;
     /**
-     * Constructor for LoadMemoryTool
+     * Extracts the function parameters from the function's signature.
      */
-    constructor();
+    private getFunctionParameters;
     /**
-     * Get the function declaration for the tool
+     * Converts an argument to the proper type based on the function signature.
      */
-    getDeclaration(): FunctionDeclaration;
+    private convertArgumentType;
     /**
-     * Execute the memory loading action
+     * Extracts the type of a specific parameter from the function signature.
      */
-    runAsync(args: {
-        query: string;
-    }, context: ToolContext): Promise<any>;
+    private getParameterType;
 }
 
 /**
- * A tool that loads the artifacts and adds them to the session.
+ * Options for building a function declaration
  */
-declare class LoadArtifactsTool extends BaseTool {
-    constructor();
-    /**
-     * Get the function declaration for the tool
-     */
-    getDeclaration(): FunctionDeclaration;
-    /**
-     * Execute the load artifacts operation
-     */
-    runAsync(args: {
-        artifact_names?: string[];
-    }, context: ToolContext): Promise<{
-        artifact_names: string[];
-    }>;
-    /**
-     * Processes the outgoing LLM request for this tool.
-     */
-    processLlmRequest(toolContext: ToolContext, llmRequest: LlmRequest): Promise<void>;
-    /**
-     * Appends artifacts information to the LLM request
-     */
-    private appendArtifactsToLlmRequest;
-    /**
-     * Extracts function response from a part if it exists
-     */
-    private extractFunctionResponse;
+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;
 
 type McpConfig = {
     name: string;