Trying to understand this part: Import looks like a union of str, ImportModule, and Alias, it's a bit unclear to me what it is. Another thing, since import will be also included in the FunctionToolConfig, are they going to be imported at the load time of the FunctionTool or at call time?

Good question.
It will only be called at call time, when we load the component (wont be called when we dump component).

global_imports=[
        ImportFromModule("typing", ("Literal",)),
        ImportFromModule("autogen_core", ("CancellationToken",)),
        ImportFromModule("autogen_core.tools", ("FunctionTool",))
    ]

when serialized looks like

'global_imports': [{'module': 'typing', 'imports': ('Literal',)}, {'module': 'autogen_core', 'imports': ('CancellationToken',)}, {'module': 'autogen_core.tools', 'imports': ('FunctionTool',)}]

The goal here is to ensure we can dump and load.

• dump:

  • convert _func to string, as source_code in FunctionToolConfig , store specified global_imports needed in function (e.g, type variables)

• load (goal is to return an instance of the serialized FunctionTool)

  • use exec to load global_imports. Import is used here because it lets us specify something like from autogen_core import CancellationToken, it is already used in other parts of the lib. This is when the import is called
  • use exec to convert source_code from string to func
  • return an instance of FunctionTool(func=func)

Happy to review other proposals.

So the global imports will be evaluated at FunctionTool.load(...) time.

While this has the same effect as importing any module in python, what it does effectively is, during application running, it can load and execute arbitrary code when deserializing a component. Not great for security.

I think what needs to happen by default instead, is to best-effort check the current global scope for whether the imports have already been loaded and provide an extra keyword argument to optionally automatically evaluate the required imports. Make sure the label this keyword argument as "insecure!" with

```{caution}
Evaluating the global_imports can lead to arbitrary code execution in your application's environment. It can reveal secretes and keys. Make sure you understand the implications. 
```

In the API doc.

In fact, we should do the same for FunctionTool.load(...). While it doesn't execute the function directly, it allows arbitrary code to be loaded and potentially executed when the application is running. Make sure to label it as such as well.