> Discover all available pages from the documentation index: https://mastra.zisheng.pro/fr/llms.txt # Classe Workspace **Ajouté dans :** `@mastra/core@1.1.0` La classe `Workspace` combine un système de fichiers et une Sandbox afin de fournir aux Agents des fonctionnalités de stockage de fichiers et d'exécution de commandes. Elle prend également en charge la recherche BM25 et vectorielle dans le contenu indexé. ## Exemple d'utilisation ```typescript import { Workspace, LocalFilesystem, LocalSandbox } from '@mastra/core/workspace' const workspace = new Workspace({ id: 'my-workspace', name: 'My Workspace', filesystem: new LocalFilesystem({ basePath: './workspace', }), sandbox: new LocalSandbox({ workingDirectory: './workspace', }), bm25: true, autoIndexPaths: ['docs'], }) ``` ## Paramètres du constructeur **id** (`string`): Identifiant unique du Workspace (Default: `Généré automatiquement`) **name** (`string`): Nom lisible (Default: `workspace-{id}`) **filesystem** (`WorkspaceFilesystem | WorkspaceFilesystemResolver`): Instance de Provider de système de fichiers, ou fonction de résolution qui reçoit requestContext et renvoie un système de fichiers par requête. Consultez la section Système de fichiers dynamique. **sandbox** (`WorkspaceSandbox | WorkspaceSandboxResolver`): Instance de Provider de Sandbox, ou fonction de résolution qui reçoit requestContext et renvoie une Sandbox par requête. Consultez la section Sandbox dynamique. **instructions.dynamicSandbox** (`'placeholder' | 'resolve' | (({ requestContext }) => string)`): Contrôle la manière dont une sandbox fondée sur une fonction de résolution contribue aux instructions du Workspace. 'placeholder' (par défaut) émet un texte stable sans appeler la fonction. 'resolve' l'appelle et utilise les propres instructions de la Sandbox. Une fonction renvoie un texte personnalisé sans effectuer de résolution. Sans effet sur une Sandbox statique. (Default: `'placeholder'`) **sandboxCacheKey** (`({ requestContext }) => string | undefined`): Clé de cache stable pour une sandbox fondée sur une fonction de résolution. Lorsqu'elle est définie, les Sandboxes résolues sont mémorisées par clé plutôt que par instance de RequestContext, afin que les Tools de processus en arrière-plan accèdent à la même Sandbox lors des requêtes suivantes. Sans effet sur une Sandbox statique. **bm25** (`boolean | BM25Config`): Active la recherche par mots-clés BM25. Transmettez true pour les valeurs par défaut ou un objet de configuration. (Default: `undefined`) **vectorStore** (`MastraVector`): Stockage vectoriel destiné à la recherche sémantique **embedder** (`Embedder`): Fonction qui transforme le texte en vecteurs. Obligatoire lorsque vectorStore est défini. Accepte une fonction pour un texte unique (text: string) => Promise\ ou une fonction compatible avec les lots (texts: string\[]) => Promise\ dotée d'une propriété batch: true et d'un maxBatchSize facultatif. Consultez la section Embedding par lots. **autoIndexPaths** (`string[]`): Chemins ou motifs glob à indexer automatiquement lors de init(). Prend en charge les motifs tels que '\*\*/\*.md' pour une indexation sélective. **skills** (`string[] | ((context: SkillsContext) => string[] | Promise)`): Chemins où se trouvent les fichiers SKILL.md. Il peut s'agir d'un tableau statique ou d'une fonction asynchrone qui résout dynamiquement les chemins. Prend en charge les motifs glob tels que './\*\*/skills' pour la découverte. **skillSource** (`SkillSource`): Source de Skill personnalisée pour la découverte des Skills. Lorsqu’elle est fournie, elle remplace le système de fichiers du Workspace. Utilisez VersionedSkillSource pour servir les versions publiées des Skills depuis un stockage de blobs adressable par contenu. **onMount** (`OnMountHook`): Hook de prémontage appelé pour chaque système de fichiers avant son montage dans une Sandbox. Renvoyez false pour ignorer le montage, ou { success: true } si le hook l’a pris en charge. Renvoyez undefined pour utiliser le comportement de montage par défaut. **searchIndexName** (`string`): Nom d'index personnalisé du stockage vectoriel. Doit être un identifiant SQL valide (commencer par une lettre ou un trait de soulignement, ne contenir que des lettres, des chiffres ou des traits de soulignement et comporter au maximum 63 caractères). Utilise par défaut une version assainie de '{id}\_search'. **tools** (`WorkspaceToolsConfig`): Configuration propre à chaque Tool pour les activer et définir les options de sécurité **tools.enabled** (`boolean`): Indique si le Tool est accessible aux Agents **tools.requireApproval** (`boolean`): Indique si le Tool nécessite l'approbation de l'utilisateur avant son exécution **tools.name** (`string`): Nom personnalisé sous lequel exposer ce Tool. Remplace le nom par défaut mastra\_workspace\_\*. La clé de configuration doit toujours utiliser la constante WORKSPACE\_TOOLS d’origine. **tools.requireReadBeforeWrite** (`boolean`): Pour les Tools d'écriture : exige la lecture préalable du fichier afin d'éviter les écrasements **tools.maxOutputTokens** (`number`): Nombre maximal de tokens de la sortie du Tool. Toute sortie dépassant cette limite est tronquée au moyen de tiktoken. **tools.writeLockTimeoutMs** (`number`): Durée maximale en millisecondes pendant laquelle un Tool d'écriture attend d'acquérir le verrou d'écriture propre au fichier avant d'échouer. Augmentez-la pour les systèmes de fichiers lents ou à démarrage à froid, par exemple les Sandboxes distantes. **tools.hooks** (`WorkspaceToolHooks`): Hooks exécutés avant et après chaque appel de Tool activé du Workspace. Consultez la section Hooks des Tools ci-dessous. **operationTimeout** (`number`): Délai d'expiration des opérations en millisecondes ## Configuration des Tools L'option `tools` accepte un objet `WorkspaceToolsConfig` qui contrôle les Tools du Workspace activés et leurs paramètres de sécurité. ```typescript import { Workspace } from '@mastra/core/workspace' import { WORKSPACE_TOOLS } from '@mastra/core/workspace' const workspace = new Workspace({ id: 'my-workspace', name: 'My Workspace', tools: { // Global defaults (apply to all tools) enabled: true, requireApproval: false, // Per-tool overrides using WORKSPACE_TOOLS constants [WORKSPACE_TOOLS.FILESYSTEM.WRITE_FILE]: { requireApproval: true, }, }, }) ``` L'objet de configuration comporte deux parties : - **Valeurs globales par défaut** (`enabled`, `requireApproval`) : s'appliquent à tous les Tools sauf remplacement - **Remplacements propres aux Tools** - Utilisez les constantes `WORKSPACE_TOOLS` comme clés pour configurer chaque Tool Consultez la [présentation de Workspace](https://mastra.zisheng.pro/fr/docs/workspace/overview) pour découvrir d'autres exemples. ### Remappage des noms de Tools Renommez les Tools du Workspace en définissant la propriété `name` dans leur configuration individuelle. La clé de configuration reste la constante d'origine : seul le nom exposé à l'Agent change. ```typescript import { Workspace } from '@mastra/core/workspace' import { WORKSPACE_TOOLS } from '@mastra/core/workspace' const workspace = new Workspace({ id: 'my-workspace', name: 'My Workspace', tools: { [WORKSPACE_TOOLS.FILESYSTEM.READ_FILE]: { name: 'view' }, [WORKSPACE_TOOLS.FILESYSTEM.GREP]: { name: 'search_content' }, }, }) ``` Les noms doivent être uniques parmi tous les Tools du Workspace. Définir un nom personnalisé qui entre en conflit avec le nom par défaut ou personnalisé d'un autre Tool lève une erreur. ### Hooks des Tools Définissez `tools.hooks` pour exécuter une logique avant et après chaque appel de Tool activé du Workspace. Les hooks sont exécutés après le remappage des noms ; le contexte inclut donc le `toolName` exposé et le `workspaceToolName` d'origine. ```typescript import { Workspace } from '@mastra/core/workspace' const workspace = new Workspace({ id: 'my-workspace', tools: { hooks: { beforeToolCall: ({ toolName, workspaceToolName, input }) => { console.log(`Running ${toolName} (${workspaceToolName})`, input) }, afterToolCall: ({ toolName, output, error }) => { console.log(`Finished ${toolName}`, { output, error }) }, }, }, }) ``` **beforeToolCall** (`(context: WorkspaceToolHookContext) => void | WorkspaceToolBeforeHookResult | Promise`): S'exécute avant un Tool du Workspace. Reçoit { toolName, workspaceToolName, input, context }. Renvoyez { proceed: false, output } pour ignorer l'appel du Tool et utiliser output comme résultat. **afterToolCall** (`(context: WorkspaceToolAfterHookContext) => void | Promise`): S'exécute après un Tool du Workspace. Reçoit { toolName, workspaceToolName, input, context, output, error }. Lorsque le Tool lève une erreur, output vaut undefined et error est défini à la place. Si l'Agent propriétaire définit également des [hooks de Tool](https://mastra.zisheng.pro/fr/reference/agents/agent), les hooks du Workspace s'exécutent dans le wrapper de hooks de l'Agent. L'ordre est le suivant : `beforeToolCall` de l'Agent → `beforeToolCall` du Workspace → Tool → `afterToolCall` du Workspace → `afterToolCall` de l'Agent. ## Propriétés **id** (`string`): Identifiant du Workspace **name** (`string`): Nom du Workspace **status** (`WorkspaceStatus`): 'pending' | 'initializing' | 'ready' | 'paused' | 'error' | 'destroying' | 'destroyed' **filesystem** (`WorkspaceFilesystem | undefined`): Provider statique du système de fichiers. Renvoie undefined lorsqu’une fonction de résolution est configurée — utilisez hasFilesystemConfig() pour vérifier sa disponibilité. **sandbox** (`WorkspaceSandbox | undefined`): Provider statique de la Sandbox. Renvoie undefined lorsqu’une fonction de résolution est configurée — utilisez hasSandboxConfig() pour vérifier sa disponibilité. **skills** (`WorkspaceSkills | undefined`): Interface des Skills permettant d'accéder aux fichiers SKILL.md **canBM25** (`boolean`): Indique si la recherche BM25 est disponible **canVector** (`boolean`): Indique si la recherche vectorielle est disponible **canHybrid** (`boolean`): Indique si la recherche hybride est disponible ## Méthodes ### Cycle de vie #### `init()` Initialise le Workspace et prépare les ressources. ```typescript await workspace.init() ``` Dans la plupart des cas, l'appel à `init()` est facultatif : - **Sandbox** : démarre automatiquement lors du premier appel à `executeCommand()`. Utilisez `init()` pour éviter la latence de la première commande. - **Système de fichiers** : crée le répertoire de base et exécute toute configuration propre au Provider. Certains Providers créent automatiquement le répertoire lors de la première opération. - **Recherche** : obligatoire uniquement si vous utilisez `autoIndexPaths` pour l'indexation automatique. L'initialisation effectue les opérations suivantes : - Démarre le Provider du système de fichiers (crée le répertoire de base si nécessaire) - Démarre le Provider de la Sandbox (crée le répertoire de travail et configure l'isolation, le cas échéant) - Indexe les fichiers de `autoIndexPaths` pour la recherche #### `destroy()` Détruit le Workspace et libère les ressources. ```typescript await workspace.destroy() ``` `destroy()` ferme dans l'ordre les ressources appartenant au Workspace : serveurs de langage, Browsers, Providers de Sandbox et Providers de système de fichiers. Elle efface également les références de Sandbox mises en cache. Appelez `destroy()` lorsque votre application a terminé d'utiliser un Workspace. `mastra.shutdown()` l'appelle pour les Workspaces enregistrés lors de l'arrêt. Pour retirer un Workspace du registre Mastra, utilisez [`mastra.removeWorkspace()`](https://mastra.zisheng.pro/fr/reference/core/removeWorkspace). `LocalFilesystem.destroy()` ne supprime pas les fichiers du disque. Les Providers de système de fichiers et de Sandbox fondés sur une fonction de résolution appartiennent à votre application, qui doit les nettoyer. ### Opérations de recherche #### `index(path, content, options?)` Indexe le contenu pour la recherche. ```typescript await workspace.index('/docs/guide.md', 'Guide content...') ``` #### `search(query, options?)` Recherche dans le contenu indexé. ```typescript const results = await workspace.search('password reset', { topK: 10, mode: 'hybrid', }) ``` ### Utilitaires #### `getInfo()` Récupère les informations du Workspace. ```typescript const info = await workspace.getInfo() // { id, name, status, createdAt, lastAccessedAt, filesystem?, sandbox? } ``` Transmettez `resolveDynamicProviders: false` pour signaler les Providers fondés sur une fonction de résolution comme définis à l'exécution, sans invoquer celle-ci. ```typescript const info = await workspace.getInfo({ resolveDynamicProviders: false }) ``` **Paramètres :** **options.includeFileCount** (`boolean`): Indique si le nombre total de fichiers doit être calculé. Cette opération peut être lente pour les Workspaces volumineux. **options.requestContext** (`RequestContext`): Transmis aux fonctions de résolution des Providers dynamiques lorsque resolveDynamicProviders est activé. **options.resolveDynamicProviders** (`boolean`): Indique si les fonctions de résolution des Providers dynamiques doivent être invoquées. Définissez false si vous avez uniquement besoin des métadonnées et souhaitez que les Providers fondés sur une fonction soient signalés comme dynamic. (Default: `true`) #### `getInstructions(opts?)` Renvoie les instructions combinées des Providers du système de fichiers et de la Sandbox. Elles sont injectées dans le message système de l'Agent afin de l'aider à comprendre le contexte d'exécution. ```typescript const instructions = workspace.getInstructions() ``` Transmettez `requestContext` afin d'activer la personnalisation par requête lorsque l'option `instructions` d'un Provider est une fonction : ```typescript const instructions = workspace.getInstructions({ requestContext }) ``` **Paramètres :** **opts.requestContext** (`RequestContext`): Transmis à la fonction instructions du Provider de système de fichiers ou de Sandbox, si elle est configurée. **Renvoie :** `string` #### `getInstructionsAsync(opts?)` Renvoie les instructions combinées du Workspace. Utilisez cette méthode lorsque le Workspace emploie des Providers fondés sur une fonction de résolution. Un système de fichiers défini à l'exécution est résolu par requête ; une Sandbox définie à l'exécution fournit un texte d'espace réservé stable, sauf si `instructions.dynamicSandbox` vaut `'resolve'`. ```typescript const instructions = await workspace.getInstructionsAsync({ requestContext }) ``` **Paramètres :** **opts.requestContext** (`RequestContext`): Transmis à la fonction de résolution du système de fichiers dynamique et à celle de la Sandbox dynamique lorsque instructions.dynamicSandbox vaut 'resolve'. **Renvoie :** `Promise` Pour remplacer la sortie par défaut, transmettez une option `instructions` à [LocalFilesystem](https://mastra.zisheng.pro/fr/reference/workspace/local-filesystem) ou [LocalSandbox](https://mastra.zisheng.pro/fr/reference/workspace/local-sandbox). #### `getToolsConfig()` Récupère la configuration actuelle des Tools. ```typescript const config = workspace.getToolsConfig() ``` **Renvoie :** `WorkspaceToolsConfig | undefined` #### `setToolsConfig(config?)` Remplace à l'exécution la configuration propre aux Tools. Il s'agit d'un remplacement complet : elle n'est pas fusionnée avec la configuration précédente. Transmettez `undefined` pour rétablir les valeurs par défaut. Les modifications prennent effet lors de l'interaction suivante avec l'Agent, c'est-à-dire au prochain appel à `createWorkspaceTools()`. ```typescript import { WORKSPACE_TOOLS } from '@mastra/core/workspace' // Disable write tools for read-only mode workspace.setToolsConfig({ [WORKSPACE_TOOLS.FILESYSTEM.WRITE_FILE]: { enabled: false }, [WORKSPACE_TOOLS.FILESYSTEM.EDIT_FILE]: { enabled: false }, }) // Reset to defaults workspace.setToolsConfig(undefined) ``` **Paramètres :** **config** (`WorkspaceToolsConfig | undefined`): Nouvelle configuration des Tools à appliquer. Transmettez undefined pour rétablir les valeurs par défaut. ### Système de fichiers dynamique #### `hasFilesystemConfig()` Vérifie si un système de fichiers est configuré, comme instance statique ou fonction de résolution. Utilisez cette méthode plutôt que de vérifier directement `workspace.filesystem`, car un Workspace fondé sur une fonction de résolution renvoie `undefined` depuis la propriété `filesystem`. ```typescript if (workspace.hasFilesystemConfig()) { // Filesystem tools are available } ``` **Renvoie :** `boolean` #### `resolveFilesystem({ requestContext })` Résout le système de fichiers pour un contexte de requête. Lorsqu'une fonction de résolution est configurée, l'appelle avec le `requestContext` fourni. Lorsqu'un système de fichiers statique est configuré, le renvoie directement. Renvoie `undefined` si aucun système de fichiers n'est configuré. ```typescript import { RequestContext } from '@mastra/core/request-context' const ctx = new RequestContext([['agent-role', 'admin']]) const fs = await workspace.resolveFilesystem({ requestContext: ctx }) ``` **Paramètres :** **requestContext** (`RequestContext`): Contexte de requête à transmettre à la fonction de résolution. **Renvoie :** `Promise` ### Sandbox dynamique #### `hasSandboxConfig()` Vérifie si une Sandbox est configurée, comme instance statique ou fonction de résolution. Utilisez cette méthode plutôt que de vérifier directement `workspace.sandbox`, car un Workspace fondé sur une fonction de résolution renvoie `undefined` depuis la propriété `sandbox`. ```typescript if (workspace.hasSandboxConfig()) { // Sandbox tools are available } ``` **Renvoie :** `boolean` #### `resolveSandbox({ requestContext })` Résout la Sandbox pour un contexte de requête. Lorsqu'une fonction de résolution est configurée, l'appelle avec le `requestContext` fourni. Lorsqu'une Sandbox statique est configurée, la renvoie directement. Renvoie `undefined` si aucune Sandbox n'est configurée. ```typescript import { RequestContext } from '@mastra/core/request-context' const ctx = new RequestContext([['user-id', 'alice']]) const sandbox = await workspace.resolveSandbox({ requestContext: ctx }) ``` **Paramètres :** **requestContext** (`RequestContext`): Contexte de requête à transmettre à la fonction de résolution. **Renvoie :** `Promise` #### `clearSandboxCache(cacheKey?)` Efface les Sandboxes fondées sur une fonction de résolution mises en cache par `sandboxCacheKey`. Transmettez une clé de cache pour effacer une entrée, ou omettez-la pour effacer toutes les entrées de Sandbox associées à une clé. Cette méthode n'efface pas le cache faible propre à chaque `RequestContext`. Ces entrées sont gérées par le garbage collector. Le Workspace ne possède pas les Sandboxes renvoyées par une fonction de résolution. Cette méthode supprime uniquement les références du Workspace. Détruisez la Sandbox dans votre propre code de cycle de vie. ```typescript workspace.clearSandboxCache('thread-123') workspace.clearSandboxCache() ``` **Paramètres :** **cacheKey** (`string`): Clé de cache à effacer. Omettez cette valeur pour effacer toutes les entrées de Sandbox associées à une clé. **Renvoie :** `void` ## Tools des Agents Un Workspace fournit des Tools aux Agents selon sa configuration. ### Tools du système de fichiers Ajoutés lorsqu'un système de fichiers est configuré : | Tool | Description | | ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `mastra_workspace_read_file` | Lit le contenu d'un fichier. Les fichiers texte sont renvoyés comme texte (avec une plage de lignes facultative). Les images et PDF sont renvoyés comme éléments multimédias natifs que le modèle peut consulter directement. Les autres fichiers binaires renvoient uniquement leurs métadonnées, sauf si un `encoding` explicite est transmis. | | `mastra_workspace_write_file` | Crée ou écrase un fichier avec un nouveau contenu. Crée automatiquement les répertoires parents. | | `mastra_workspace_edit_file` | Modifie un fichier existant en recherchant et en remplaçant du texte. Utile pour des modifications ciblées sans réécrire tout le fichier. | | `mastra_workspace_list_files` | Répertorie le contenu d'un répertoire sous forme d'arborescence. Prend en charge la liste récursive avec limites de profondeur, les motifs glob et le filtrage `.gitignore` (activé par défaut). | | `mastra_workspace_delete` | Supprime un fichier ou un répertoire. Prend en charge la suppression récursive des répertoires. | | `mastra_workspace_file_stat` | Récupère les métadonnées d'un fichier ou d'un répertoire, notamment sa taille, son type et sa date de modification. | | `mastra_workspace_mkdir` | Crée un répertoire. Crée automatiquement les répertoires parents s'ils n'existent pas. | | `mastra_workspace_grep` | Recherche dans le contenu des fichiers au moyen de motifs regex. Prend en charge le filtrage glob, les lignes de contexte et la recherche insensible à la casse. | Avec un système de fichiers statique, les Tools d'écriture (`write_file`, `edit_file`, `delete`, `mkdir`) sont exclus lorsque celui-ci est en lecture seule. Avec un [système de fichiers défini à l'exécution](https://mastra.zisheng.pro/fr/docs/workspace/filesystem), ils sont toujours inclus et la lecture seule est appliquée à l'exécution. Le Tool `read_file` accepte les options `mediaTypes` et `maxMediaBytes` afin de contrôler les types MIME exposés au modèle comme éléments multimédias natifs et la taille maximale de ces fichiers : **mediaTypes** (`string[] | ((mimeType: string) => boolean) | false`): Types MIME à exposer au modèle comme éléments multimédias (fichier/image) plutôt que comme texte. Accepte un tableau de motifs glob, par exemple \['image/\*'], une fonction de prédicat personnalisée ou false pour désactiver la détection des médias. Utilise par défaut l'intersection des formats d'image sûrs pour tous les Providers, ainsi que PDF. S'applique uniquement lorsque l'appelant ne transmet pas d'encoding explicite. (Default: `['image/png', 'image/jpeg', 'image/webp', 'application/pdf']`) **maxMediaBytes** (`number`): Taille maximale du fichier, en octets, à intégrer comme élément multimédia. Les fichiers plus volumineux produisent uniquement leurs métadonnées au lieu d'être entièrement encodés en base64 dans le contexte et conservés dans le stockage lors de la réhydratation. (Default: `10 * 1024 * 1024 (10 MiB)`) ```typescript const workspace = new Workspace({ filesystem: new LocalFilesystem({ basePath: './workspace' }), tools: { [WORKSPACE_TOOLS.FILESYSTEM.READ_FILE]: { // Broaden to any image (including SVG, BMP, HEIC) — may fail on some providers mediaTypes: ['image/*'], // Raise the inline-media cap to 25 MiB maxMediaBytes: 25 * 1024 * 1024, }, }, }) ``` ### Tools de la Sandbox Ajoutés lorsqu'une Sandbox est configurée : | Tool | Description | | ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `mastra_workspace_execute_command` | Exécute une commande shell. Renvoie stdout, stderr et le code de sortie. Lorsque la Sandbox possède un gestionnaire de processus, accepte `background: true` pour lancer un processus de longue durée et renvoyer un PID. | | `mastra_workspace_get_process_output` | Récupère stdout, stderr et l'état d'un processus en arrière-plan à partir de son PID. Accepte `tail` pour limiter les lignes de sortie et `wait: true` pour bloquer jusqu'à la fin. Disponible uniquement lorsque la Sandbox possède un gestionnaire de processus. | | `mastra_workspace_kill_process` | Arrête un processus en arrière-plan à partir de son PID. Renvoie les 50 dernières lignes de sortie. Disponible uniquement lorsque la Sandbox possède un gestionnaire de processus. | Avec une Sandbox statique, les vérifications de fonctionnalités (`executeCommand`, `processes`) déterminent les variantes de Tools exposées. Avec une [Sandbox définie à l'exécution](https://mastra.zisheng.pro/fr/docs/workspace/sandbox), tous les Tools de Sandbox sont enregistrés et l'exécution lève une erreur explicite si la Sandbox résolue n'implémente pas la fonctionnalité demandée. Le Tool `execute_command` accepte une option `backgroundProcesses` pour les callbacks de cycle de vie des processus en arrière-plan : **backgroundProcesses** (`BackgroundProcessesConfig`): Configuration de la gestion des processus en arrière-plan. S'applique uniquement si la Sandbox prend en charge l'exécution en arrière-plan. **backgroundProcesses.onStdout** (`(data: string, meta: BackgroundProcessMeta) => void`): Callback pour les fragments de stdout des processus en arrière-plan. **backgroundProcesses.onStderr** (`(data: string, meta: BackgroundProcessMeta) => void`): Callback pour les fragments de stderr des processus en arrière-plan. **backgroundProcesses.onExit** (`(meta: BackgroundProcessExitMeta) => void`): Callback appelé à la fin d’un processus en arrière-plan. Les métadonnées comprennent pid, exitCode, stdout et stderr. **backgroundProcesses.abortSignal** (`AbortSignal | null | false`): Signal d'abandon des processus en arrière-plan. undefined (par défaut) utilise le signal de l'Agent. null ou false désactive l'abandon — les processus persistent après l'arrêt de l'Agent. Consultez les [callbacks des processus en arrière-plan](https://mastra.zisheng.pro/fr/docs/workspace/sandbox) pour découvrir des exemples d'utilisation. ### Tools de recherche Ajoutés lorsque la recherche BM25 ou vectorielle est configurée : | Tool | Description | | ------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `mastra_workspace_search` | Recherche dans le contenu indexé au moyen d'une recherche par mots-clés (BM25), sémantique (vectorielle) ou hybride. Renvoie des résultats classés avec leurs scores. | | `mastra_workspace_index` | Indexe le contenu pour la recherche. Associe le contenu à un chemin pour une récupération ultérieure. | Le Tool `index` est exclu lorsque le système de fichiers est en lecture seule. ### Tools des Skills Ajoutés lorsque des Skills sont configurés : | Tool | Description | | -------------- | ---------------------------------------------------------------------------------------------------------------------------------- | | `skill` | Active un Skill à partir de son nom ou de son chemin. Renvoie toutes les instructions, références, scripts et ressources du Skill. | | `skill_search` | Recherche dans le contenu des Skills. Accepte une liste facultative de noms de Skills à filtrer et un paramètre `topK`. | | `skill_read` | Lit un fichier précis (référence, script ou ressource) dans le répertoire d'un Skill. | Lorsque plusieurs Skills portent le même nom, `list()` les renvoie tous. `get()` avec un nom applique un départage (local > géré > externe). Si deux Skills partagent le même nom et le même type de source, `get()` lève une erreur. Transmettez le chemin complet d'un Skill à `get()` pour contourner le départage. Consultez la section [Skills portant le même nom](https://mastra.zisheng.pro/fr/docs/workspace/skills) pour plus de détails.