Monty

Monty est un interpréteur basé sur Rust pour un sous-ensemble de Python restreint. MontyCodeActProvider fournit à un agent Agent Framework un outil execute_code et permet au code généré d’appeler des outils appartenant au fournisseur en tant que fonctions asynchrones typées ou via call_tool(...).

Cette intégration utilise le modèle CodeAct avec un interpréteur restreint plutôt qu’un bac à sable isolé au niveau matériel.

Utilisez Monty lorsque vous avez besoin d’un environnement d’exécution CodeAct multiplateforme sans dépendre de l’hyperviseur Hyperlight ni d’un invité WASM Hyperlight.

Installer les packages

pip install agent-framework-monty agent-framework-foundry --pre

Ajouter MontyCodeActProvider

Inscrivez les outils hôtes sur le fournisseur plutôt que directement sur l’assistant. Le modèle voit execute_code et appelle ces outils à partir du code généré.

async def main() -> None:
    """Run the provider-owned Monty CodeAct sample."""
    # 1. Create the Monty-backed provider and register sandbox tools on it.
    codeact = MontyCodeActProvider(
        tools=[compute, fetch_data],
        approval_mode="never_require",
    )

    # 2. Create the client and the agent.
    agent = Agent(
        client=FoundryChatClient(
            project_endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
            model=os.environ["FOUNDRY_MODEL"],
            credential=AzureCliCredential(),
        ),
        name="MontyCodeActProviderAgent",
        instructions="You are a helpful assistant.",
        context_providers=[codeact],
        middleware=[log_function_calls],
    )

    # 3. Run a request that should use execute_code plus provider-owned tools.
    query = (
        "Fetch all users, find admins, multiply 7*(3*2), and print the users, "
        "admins, and multiplication result. Use a single execute_code call. "
        "You may call the registered tools directly as typed async functions "
        "(`await compute(operation='multiply', a=7, b=6)`) or via "
        "`call_tool('compute', ...)`."
    )
    print(f"{_CYAN}{'=' * 60}")
    print("Monty CodeAct provider sample")
    print(f"{'=' * 60}{_RESET}")
    print(f"{_CYAN}User: {query}{_RESET}")
    result = await agent.run(query)
    print(f"{_CYAN}Agent: {result.text}{_RESET}")

Descriptions des paramètres de l’outil hôte de contrôle

MontyCodeActProvider et MontyExecuteCodeTool acceptent tool_description_format. La valeur par défaut, "compact"inclut les types de paramètres scalaires, l’état obligatoire ou facultatif, les descriptions, les valeurs d’énumération et les valeurs par défaut dans les execute_code instructions de description et CodeAct. Utilisez "json" pour le schéma JSON complet, ou sélectionnez un format en indiquant le nom exact de l’outil, en respectant la casse :

codeact = MontyCodeActProvider(
    tools=[compute, fetch_data],
    tool_description_format={
        "compute": "json",
        "fetch_data": "compact",
    },
)

Les outils omis à partir d’un mappage utilisent un format compact. Le rendu compact revient automatiquement à terminer le schéma JSON lorsqu’il ne peut pas représenter un schéma sans perdre de contraintes, telles que des objets imbriqués, des tableaux, des références ou des unions. Les schémas de paramètres sont visibles pour le modèle. Par conséquent, n’incluez pas d’informations d’identification ou d’autres secrets dans les descriptions, les valeurs d’énumération, les valeurs par défaut ou les champs de schéma personnalisés.

Configurer les fonctionnalités

MontyCodeActProvider et MontyExecuteCodeTool support :

• Outils hôtes et gestion des outils d’exécution
• never_require ou always_require approbation pour execute_code
• montages de fichiers racine et explicites d’un espace de travail
• Limites des ressources Monty
• fichiers renvoyés à partir de montages en lecture-écriture en tant que contenu Agent Framework

La capture de fichiers post-exécution retourne uniquement des fichiers réguliers réels à partir de montages en lecture-écriture. Il ignore les liens symboliques, les jonctions Windows et autres points d’analyse, ainsi que les fichiers non réguliers à chaque niveau de chemin. Avant de lire un fichier, Monty vérifie que le descripteur ouvert correspond au chemin validé et revérifie les composants du chemin d’accès. Si le fichier ou un ancêtre change pendant la capture, le fichier est omis au lieu d’être suivi.

Chaque exécution capture au maximum 20 fichiers et 20 Mio de données brutes sur tous les montages en lecture-écriture, avec une limite de 5 Mio par fichier. Les fichiers vides comptent dans la limite de fichiers. Les fichiers qui dépassent le budget restant sont ignorés, mais les fichiers plus petits ultérieurs peuvent toujours être capturés. La réponse inclut un résumé d’omission lorsqu’un fichier dépasse une limite de capture. Les fichiers restent écrits dans le sandbox ; ces limites s’appliquent uniquement aux pièces jointes retournées.

Packages d’accès réseau et de Python

Monty exécute son propre interpréteur Python, pas l'environnement Python de l'hôte. Cette intégration ne fournit ni pip ni une autre option d’installation de package. L’installation d’une dépendance sur l’hôte ne le rend pas importable dans le code Monty. Utilisez les modules pris en charge par l’interpréteur pour le code qui s’exécute à l’intérieur de Monty.

Monty ne fournit pas d’option allowed_domains . Pour les appels ou opérations d’API externes qui nécessitent des packages installés par l’hôte, inscrivez un outil hôte étroit et appelez-le à partir du code Monty. Conservez les identifiants, l’autorisation et les vérifications de la liste d’autorisation de destination dans cette fonction, car elle s’exécute sur l’hôte, en dehors de l’interpréteur Monty.

Choisir Monty ou Hyperlight

Étapes suivantes