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

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

= Généré automatiquement

Identifiant unique du Workspace

name?:

string

= workspace-{id}

Nom lisible

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)

= 'placeholder'

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.

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

= undefined

Active la recherche par mots-clés BM25. Transmettez true pour les valeurs par défaut ou un objet de configuration.

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<number[]> ou une fonction compatible avec les lots (texts: string[]) => Promise<number[][]> 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<string[]>)

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é

WorkspaceToolsConfig

enabled?:

boolean

Indique si le Tool est accessible aux Agents

requireApproval?:

boolean

Indique si le Tool nécessite l'approbation de l'utilisateur avant son exécution

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.

requireReadBeforeWrite?:

boolean

Pour les Tools d'écriture : exige la lecture préalable du fichier afin d'éviter les écrasements

maxOutputTokens?:

number

Nombre maximal de tokens de la sortie du Tool. Toute sortie dépassant cette limite est tronquée au moyen de tiktoken.

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.

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é.

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 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.

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.

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<void | WorkspaceToolBeforeHookResult>

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<void>

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, 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.

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.

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().

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.

await workspace.index('/docs/guide.md', 'Guide content...')

search(query, options?)

Recherche dans le contenu indexé.

const results = await workspace.search('password reset', {
  topK: 10,
  mode: 'hybrid',
})

Utilitaires

getInfo()

Récupère les informations du Workspace.

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.

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

= true

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.

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.

const instructions = workspace.getInstructions()

Transmettez requestContext afin d'activer la personnalisation par requête lorsque l'option instructions d'un Provider est une fonction :

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'.

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<string>

Pour remplacer la sortie par défaut, transmettez une option instructions à LocalFilesystem ou LocalSandbox.

getToolsConfig()

Récupère la configuration actuelle des Tools.

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().

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.

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é.

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<WorkspaceFilesystem | undefined>

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.

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.

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<WorkspaceSandbox | undefined>

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.

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, 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

= ['image/png', 'image/jpeg', 'image/webp', 'application/pdf']

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.

maxMediaBytes?:

number

= 10 * 1024 * 1024 (10 MiB)

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.

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, 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.

BackgroundProcessesConfig

onStdout?:

(data: string, meta: BackgroundProcessMeta) => void

Callback pour les fragments de stdout des processus en arrière-plan.

onStderr?:

(data: string, meta: BackgroundProcessMeta) => void

Callback pour les fragments de stderr des processus en arrière-plan.

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.

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 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 pour plus de détails.