> ## Documentation Index
> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Slash Commands dans le SDK

> Apprenez à utiliser les slash commands pour contrôler les sessions Claude Code via le SDK

Les slash commands offrent un moyen de contrôler les sessions Claude Code avec des commandes spéciales commençant par `/`. Ces commandes peuvent être envoyées via le SDK pour effectuer des actions comme compacter le contexte, lister l'utilisation du contexte ou invoquer des commandes personnalisées. Seules les commandes qui fonctionnent sans terminal interactif peuvent être envoyées via le SDK ; le message `system/init` liste celles disponibles dans votre session.

<h2 id="discovering-available-slash-commands">
  Découvrir les Slash Commands Disponibles
</h2>

Le Claude Agent SDK fournit des informations sur les slash commands disponibles dans le message d'initialisation du système. Accédez à ces informations au démarrage de votre session :

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { query } from "@anthropic-ai/claude-agent-sdk";

  for await (const message of query({
    prompt: "Hello Claude",
    options: { maxTurns: 1 }
  })) {
    if (message.type === "system" && message.subtype === "init") {
      console.log("Available slash commands:", message.slash_commands);
      // Includes built-in commands plus bundled skills, for example:
      // ["clear", "compact", "context", "usage", "code-review", "verify", ...]
    }
  }
  ```

  ```python Python theme={null}
  import asyncio
  from claude_agent_sdk import query, ClaudeAgentOptions, SystemMessage


  async def main():
      async for message in query(prompt="Hello Claude", options=ClaudeAgentOptions(max_turns=1)):
          if isinstance(message, SystemMessage) and message.subtype == "init":
              print("Available slash commands:", message.data["slash_commands"])
              # Includes built-in commands plus bundled skills, for example:
              # ["clear", "compact", "context", "usage", "code-review", "verify", ...]


  asyncio.run(main())
  ```
</CodeGroup>

<h2 id="sending-slash-commands">
  Envoyer des Slash Commands
</h2>

Envoyez des slash commands en les incluant dans votre chaîne de prompt, comme du texte ordinaire. Les commandes qui agissent sur l'historique de la conversation, telles que `/compact`, ont besoin de messages antérieurs pour fonctionner, donc les exemples ci-dessous posent d'abord une question, puis envoient la commande comme suivi à la même conversation :

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { query } from "@anthropic-ai/claude-agent-sdk";

  // Build up conversation history first
  try {
    for await (const message of query({
      prompt: "What does the README in this directory cover?",
      options: { maxTurns: 2 }
    })) {
      if (message.type === "result" && message.subtype === "success") {
        console.log(message.result);
      }
    }
  } catch (error) {
    // A single-shot query() throws after yielding an error result,
    // so the follow-up query below still runs.
    console.error(`Session ended with an error: ${error}`);
  }

  // Send a slash command as a follow-up to the same conversation
  for await (const message of query({
    prompt: "/compact",
    options: { continue: true, maxTurns: 1 }
  })) {
    if (message.type === "result") {
      console.log("Command executed, result subtype:", message.subtype);
      // Example output: Command executed, result subtype: success
    }
  }
  ```

  ```python Python theme={null}
  import asyncio
  from claude_agent_sdk import query, ClaudeAgentOptions, ResultMessage


  async def main():
      # Build up conversation history first
      try:
          async for message in query(
              prompt="What does the README in this directory cover?",
              options=ClaudeAgentOptions(max_turns=2),
          ):
              if isinstance(message, ResultMessage) and message.subtype == "success":
                  print(message.result)
      except Exception as error:
          # A single-shot query() raises after yielding an error result,
          # so the follow-up query below still runs.
          print(f"Session ended with an error: {error}")

      # Send a slash command as a follow-up to the same conversation
      async for message in query(
          prompt="/compact",
          options=ClaudeAgentOptions(continue_conversation=True, max_turns=1),
      ):
          if isinstance(message, ResultMessage):
              print("Command executed, result subtype:", message.subtype)
              # Example output: Command executed, result subtype: success


  asyncio.run(main())
  ```
</CodeGroup>

<Note>
  Une requête peut se terminer par un résultat d'erreur, par exemple lorsque la limite `maxTurns` / `max_turns` est atteinte avant la fin du travail. Le message de résultat final a alors `is_error: true` et un sous-type d'erreur tel que `error_max_turns` au lieu de `success`.

  Après avoir produit ce message de résultat final, le SDK lève une erreur, car le processus CLI se termine avec un code non nul.

  Enveloppez la boucle dans un `try`/`catch` en TypeScript ou `try`/`except` en Python si votre commande pourrait atteindre la limite, comme indiqué dans [Single Message Input](/fr/agent-sdk/streaming-vs-single-mode#single-message-input), ou définissez `maxTurns` suffisamment haut pour que le travail se termine. En Python, capturez `Exception` : le SDK présente les résultats d'erreur comme une simple `Exception`.
</Note>

<h2 id="common-slash-commands">
  Commandes Slash Courantes
</h2>

<h3 id="/compact-compact-conversation-history">
  `/compact` - Compacter l'historique de conversation
</h3>

La commande `/compact` réduit la taille de votre historique de conversation en résumant les messages plus anciens tout en préservant le contexte important. La compaction nécessite une conversation existante avec au moins deux échanges antérieurs à résumer. Cet exemple a d'abord une conversation, puis la compacte et lit le message système `compact_boundary` qui rapporte le résultat :

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { query } from "@anthropic-ai/claude-agent-sdk";

  // Compaction needs existing history, so have a conversation first
  try {
    for await (const message of query({
      prompt: "Explain what this project does",
      options: { maxTurns: 2 }
    })) {
      if (message.type === "result" && message.subtype === "success") {
        console.log(message.result);
      }
    }
  } catch (error) {
    // A single-shot query() throws after yielding an error result,
    // so the follow-up query below still runs.
    console.error(`Session ended with an error: ${error}`);
  }

  // Compact the same conversation
  for await (const message of query({
    prompt: "/compact",
    options: { continue: true, maxTurns: 1 }
  })) {
    if (message.type === "system" && message.subtype === "compact_boundary") {
      console.log("Compaction completed");
      console.log("Pre-compaction tokens:", message.compact_metadata.pre_tokens);
      console.log("Trigger:", message.compact_metadata.trigger);
      // Example output:
      // Compaction completed
      // Pre-compaction tokens: 1842
      // Trigger: manual
    }
  }
  ```

  ```python Python theme={null}
  import asyncio
  from claude_agent_sdk import query, ClaudeAgentOptions, ResultMessage, SystemMessage


  async def main():
      # Compaction needs existing history, so have a conversation first
      try:
          async for message in query(
              prompt="Explain what this project does",
              options=ClaudeAgentOptions(max_turns=2),
          ):
              if isinstance(message, ResultMessage) and message.subtype == "success":
                  print(message.result)
      except Exception as error:
          # A single-shot query() raises after yielding an error result,
          # so the follow-up query below still runs.
          print(f"Session ended with an error: {error}")

      # Compact the same conversation
      async for message in query(
          prompt="/compact",
          options=ClaudeAgentOptions(continue_conversation=True, max_turns=1),
      ):
          if isinstance(message, SystemMessage) and message.subtype == "compact_boundary":
              print("Compaction completed")
              print("Pre-compaction tokens:", message.data["compact_metadata"]["pre_tokens"])
              print("Trigger:", message.data["compact_metadata"]["trigger"])
              # Example output:
              # Compaction completed
              # Pre-compaction tokens: 1842
              # Trigger: manual


  asyncio.run(main())
  ```
</CodeGroup>

<Note>
  Un message `compact_boundary` n'arrive que lorsque la compaction s'est exécutée. S'il n'y a rien à résumer, `/compact` rapporte la raison au lieu de lever une exception : l'exécution se termine toujours avec un résultat `success`, aucun message `compact_boundary` n'est émis, et le texte du résultat porte le message, par exemple `Not enough messages to compact.` après un seul échange court. Un nouvel appel `query()` ponctuel démarre avec un contexte vide, donc utilisez ce modèle dans une session avec des tours antérieurs, par exemple en [mode d'entrée en continu](/fr/agent-sdk/streaming-vs-single-mode) ou lors de la reprise d'une session.
</Note>

<h3 id="/clear-reset-conversation-context">
  `/clear` - Réinitialiser le contexte de conversation
</h3>

La commande `/clear` réinitialise la conversation à un contexte vide, de sorte que les invites suivantes commencent sans aucun historique de conversation antérieur. La conversation précédente reste sur le disque et peut être reprise en passant son ID de session à l'[option `resume`](/fr/agent-sdk/sessions#resume-by-id).

Ceci est utile en [mode d'entrée en continu](/fr/agent-sdk/streaming-vs-single-mode), où vous envoyez plusieurs invites sur une seule connexion. Pour les appels `query()` ponctuels, chaque appel démarre déjà avec un contexte vide, donc envoyer `/clear` n'a aucun effet pratique ; démarrez plutôt un nouveau `query()`.

<Note>
  `/clear` dans le SDK nécessite Claude Code v2.1.117 ou version ultérieure. Dans les versions antérieures, il est omis de `slash_commands`.
</Note>

<h2 id="creating-custom-slash-commands">
  Créer des Slash Commands Personnalisés
</h2>

En plus d'utiliser les slash commands intégrés, vous pouvez créer vos propres commandes personnalisées disponibles via le SDK. Les commandes personnalisées sont définies comme des fichiers markdown dans des répertoires spécifiques, de la même manière que les subagents sont configurés.

<Note>
  Le répertoire `.claude/commands/` est le format hérité. Le format recommandé est `.claude/skills/<name>/SKILL.md`, qui supporte la même invocation slash-command (`/name`) plus l'invocation autonome par Claude. Voir [Skills](/fr/agent-sdk/skills) pour le format actuel. Le CLI continue de supporter les deux formats, et les exemples ci-dessous restent exacts pour `.claude/commands/`.
</Note>

<h3 id="file-locations">
  Emplacements des Fichiers
</h3>

Les slash commands personnalisés sont stockés dans des répertoires désignés selon leur portée :

* **Commandes de projet** : `.claude/commands/` - Disponibles uniquement dans le projet actuel (hérité ; préférez `.claude/skills/`)
* **Commandes personnelles** : `~/.claude/commands/` - Disponibles dans tous vos projets (hérité ; préférez `~/.claude/skills/`)

<h3 id="file-format">
  Format du Fichier
</h3>

Chaque commande personnalisée est un fichier markdown où :

* Le nom du fichier (sans extension `.md`) devient le nom de la commande
* Le contenu du fichier définit ce que la commande fait
* Un frontmatter YAML optionnel fournit la configuration

<h4 id="basic-example">
  Exemple Basique
</h4>

Créez le répertoire `.claude/commands` dans votre projet s'il n'existe pas, puis créez `.claude/commands/refactor.md` :

```markdown theme={null}
Refactor the selected code to improve readability and maintainability.
Focus on clean code principles and best practices.
```

Cela crée la commande `/refactor` que vous pouvez utiliser via le SDK.

<h4 id="with-frontmatter">
  Avec Frontmatter
</h4>

Créez `.claude/commands/security-check.md` :

```markdown theme={null}
---
allowed-tools: Read, Grep, Glob
description: Run security vulnerability scan
model: claude-opus-4-8
---

Analyze the codebase for security vulnerabilities including:
- SQL injection risks
- XSS vulnerabilities
- Exposed credentials
- Insecure configurations
```

<h3 id="using-custom-commands-in-the-sdk">
  Utiliser des Commandes Personnalisées dans le SDK
</h3>

Une fois définies dans le système de fichiers, les commandes personnalisées sont automatiquement disponibles via le SDK :

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { query } from "@anthropic-ai/claude-agent-sdk";

  // Use a custom command
  try {
    for await (const message of query({
      prompt: "/refactor src/auth/login.ts",
      options: { maxTurns: 3 }
    })) {
      if (message.type === "assistant") {
        console.log("Refactoring suggestions:", message.message);
      }
    }
  } catch (error) {
    // A single-shot query() throws after yielding an error result,
    // so the second query below still runs.
    console.error(`Session ended with an error: ${error}`);
  }

  // Custom commands appear in the slash_commands list
  for await (const message of query({
    prompt: "Hello",
    options: { maxTurns: 1 }
  })) {
    if (message.type === "system" && message.subtype === "init") {
      console.log("Available commands:", message.slash_commands);
      // Includes built-in commands plus bundled skills and your custom commands, for example:
      // ["clear", "compact", "context", "usage", "code-review", "verify", "refactor", "security-check", ...]
    }
  }
  ```

  ```python Python theme={null}
  import asyncio
  from claude_agent_sdk import query, ClaudeAgentOptions, AssistantMessage, SystemMessage


  async def main():
      # Use a custom command
      try:
          async for message in query(
              prompt="/refactor src/auth/login.py", options=ClaudeAgentOptions(max_turns=3)
          ):
              if isinstance(message, AssistantMessage):
                  for block in message.content:
                      if hasattr(block, "text"):
                          print("Refactoring suggestions:", block.text)
      except Exception as error:
          # A single-shot query() raises after yielding an error result,
          # so the second query below still runs.
          print(f"Session ended with an error: {error}")

      # Custom commands appear in the slash_commands list
      async for message in query(prompt="Hello", options=ClaudeAgentOptions(max_turns=1)):
          if isinstance(message, SystemMessage) and message.subtype == "init":
              print("Available commands:", message.data["slash_commands"])
              # Includes built-in commands plus bundled skills and your custom commands, for example:
              # ["clear", "compact", "context", "usage", "code-review", "verify", "refactor", "security-check", ...]


  asyncio.run(main())
  ```
</CodeGroup>

<h3 id="advanced-features">
  Fonctionnalités Avancées
</h3>

<h4 id="arguments-and-placeholders">
  Arguments et Placeholders
</h4>

Les commandes personnalisées supportent les arguments dynamiques en utilisant des placeholders :

Créez `.claude/commands/fix-issue.md` :

```markdown theme={null}
---
argument-hint: [issue-number] [priority]
description: Fix a GitHub issue
---

Fix issue #$0 with priority $1.
Check the issue description and implement the necessary changes.
```

Utilisez dans le SDK :

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { query } from "@anthropic-ai/claude-agent-sdk";

  // Pass arguments to custom command
  for await (const message of query({
    prompt: "/fix-issue 123 high",
    options: { maxTurns: 5 }
  })) {
    // Command will process with $0="123" and $1="high"
    if (message.type === "result" && message.subtype === "success") {
      console.log("Issue fixed:", message.result);
    }
  }
  ```

  ```python Python theme={null}
  import asyncio
  from claude_agent_sdk import query, ClaudeAgentOptions, ResultMessage


  async def main():
      # Pass arguments to custom command
      async for message in query(prompt="/fix-issue 123 high", options=ClaudeAgentOptions(max_turns=5)):
          # Command will process with $0="123" and $1="high"
          if isinstance(message, ResultMessage):
              print("Issue fixed:", message.result)


  asyncio.run(main())
  ```
</CodeGroup>

<h4 id="bash-command-execution">
  Exécution de Commandes Bash
</h4>

Les commandes personnalisées peuvent exécuter des commandes bash et inclure leur sortie :

Créez `.claude/commands/git-commit.md` :

```markdown theme={null}
---
allowed-tools: Bash(git add *), Bash(git status *), Bash(git commit *)
description: Create a git commit
---

## Context

- Current status: !`git status`
- Current diff: !`git diff HEAD`

## Task

Create a git commit with appropriate message based on the changes.
```

<h4 id="file-references">
  Références de Fichiers
</h4>

Incluez le contenu des fichiers en utilisant le préfixe `@` :

Créez `.claude/commands/review-config.md` :

```markdown theme={null}
---
description: Review configuration files
---

Review the following configuration files for issues:
- Package config: @package.json
- TypeScript config: @tsconfig.json
- Environment config: @.env

Check for security issues, outdated dependencies, and misconfigurations.
```

<h3 id="organization-with-namespacing">
  Organisation avec Namespacing
</h3>

Organisez les commandes dans des sous-répertoires pour une meilleure structure :

```bash theme={null}
.claude/commands/
├── frontend/
│   ├── component.md      # Creates /component (project:frontend)
│   └── style-check.md     # Creates /style-check (project:frontend)
├── backend/
│   ├── api-test.md        # Creates /api-test (project:backend)
│   └── db-migrate.md      # Creates /db-migrate (project:backend)
└── review.md              # Creates /review (project)
```

Le sous-répertoire apparaît dans la description de la commande mais n'affecte pas le nom de la commande lui-même.

<h3 id="practical-examples">
  Exemples Pratiques
</h3>

<h4 id="pull-request-review-command">
  Commande de Révision de Pull Request
</h4>

Créez `.claude/commands/review-pr.md` :

```markdown theme={null}
---
allowed-tools: Read, Grep, Glob, Bash(git diff *)
description: Comprehensive code review
---

## Changed Files
!`git diff --name-only HEAD~1`

## Detailed Changes
!`git diff HEAD~1`

## Review Checklist

Review the above changes for:
1. Code quality and readability
2. Security vulnerabilities
3. Performance implications
4. Test coverage
5. Documentation completeness

Provide specific, actionable feedback organized by priority.
```

<Note>
  Claude Code inclut les skills `code-review` et `verify` intégrés. Si vous nommez une commande personnalisée d'après l'un d'eux, par exemple `.claude/commands/code-review.md`, votre commande masque le skill intégré et `slash_commands` liste le nom une seule fois.
</Note>

<h4 id="test-runner-command">
  Commande Test Runner
</h4>

Créez `.claude/commands/test.md` :

```markdown theme={null}
---
allowed-tools: Bash, Read, Edit
argument-hint: [test-pattern]
description: Run tests with optional pattern
---

Run tests matching pattern: $ARGUMENTS

1. Detect the test framework (Jest, pytest, etc.)
2. Run tests with the provided pattern
3. If tests fail, analyze and fix them
4. Re-run to verify fixes
```

Utilisez ces commandes via le SDK :

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { query } from "@anthropic-ai/claude-agent-sdk";

  // Run code review
  try {
    for await (const message of query({
      prompt: "/review-pr",
      options: { maxTurns: 3 }
    })) {
      // Process review feedback
    }
  } catch (error) {
    // A single-shot query() throws after yielding an error result,
    // so the second query below still runs.
    console.error(`Session ended with an error: ${error}`);
  }

  // Run specific tests
  for await (const message of query({
    prompt: "/test auth",
    options: { maxTurns: 5 }
  })) {
    // Handle test results
  }
  ```

  ```python Python theme={null}
  import asyncio
  from claude_agent_sdk import query, ClaudeAgentOptions


  async def main():
      # Run code review
      try:
          async for message in query(prompt="/review-pr", options=ClaudeAgentOptions(max_turns=3)):
              # Process review feedback
              pass
      except Exception as error:
          # A single-shot query() raises after yielding an error result,
          # so the second query below still runs.
          print(f"Session ended with an error: {error}")

      # Run specific tests
      async for message in query(prompt="/test auth", options=ClaudeAgentOptions(max_turns=5)):
          # Handle test results
          pass


  asyncio.run(main())
  ```
</CodeGroup>

<h2 id="see-also">
  Voir Aussi
</h2>

* [Slash Commands](/fr/skills) - Documentation complète des slash commands
* [Subagents dans le SDK](/fr/agent-sdk/subagents) - Configuration similaire basée sur le système de fichiers pour les subagents
* [Référence TypeScript SDK](/fr/agent-sdk/typescript) - Documentation complète de l'API
* [Aperçu du SDK](/fr/agent-sdk/overview) - Concepts généraux du SDK
* [Référence CLI](/fr/cli-reference) - Interface de ligne de commande