> ## 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 en el SDK

> Aprenda cómo usar slash commands para controlar sesiones de Claude Code a través del SDK

Los slash commands proporcionan una forma de controlar sesiones de Claude Code con comandos especiales que comienzan con `/`. Estos comandos se pueden enviar a través del SDK para realizar acciones como compactar contexto, listar el uso del contexto o invocar comandos personalizados. Solo los comandos que funcionan sin una terminal interactiva se pueden enviar a través del SDK; el mensaje `system/init` enumera los disponibles en su sesión.

<h2 id="discovering-available-slash-commands">
  Descubrimiento de Slash Commands Disponibles
</h2>

El Claude Agent SDK proporciona información sobre los slash commands disponibles en el mensaje de inicialización del sistema. Acceda a esta información cuando su sesión comience:

<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">
  Envío de Slash Commands
</h2>

Envíe slash commands incluyéndolos en su cadena de prompt, como texto normal. Los comandos que actúan sobre el historial de conversación, como `/compact`, necesitan mensajes previos para funcionar, por lo que los ejemplos a continuación hacen una pregunta primero y luego envían el comando como seguimiento en la misma conversación:

<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>
  Una consulta puede terminar con un resultado de error, por ejemplo cuando se alcanza el límite de `maxTurns` / `max_turns` antes de que se complete el trabajo. El mensaje de resultado final tiene entonces `is_error: true` y un subtipo de error como `error_max_turns` en lugar de `success`.

  Después de ceder ese mensaje de resultado final, el SDK genera un error, porque el proceso de CLI se cierra con un código distinto de cero.

  Envuelva el bucle en un `try`/`catch` en TypeScript o `try`/`except` en Python si su comando podría alcanzar el límite, como se muestra en [Single Message Input](/es/agent-sdk/streaming-vs-single-mode#single-message-input), o establezca `maxTurns` lo suficientemente alto para que se complete el trabajo. En Python, capture `Exception`: el SDK presenta resultados de error como una `Exception` simple.
</Note>

<h2 id="common-slash-commands">
  Comandos Slash Comunes
</h2>

<h3 id="/compact-compact-conversation-history">
  `/compact` - Compactar historial de conversación
</h3>

El comando `/compact` reduce el tamaño de su historial de conversación resumiendo mensajes antiguos mientras preserva el contexto importante. La compactación requiere una conversación existente con al menos dos intercambios previos para resumir. Este ejemplo tiene una conversación primero, luego la compacta y lee el mensaje del sistema `compact_boundary` que reporta el resultado:

<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 mensaje `compact_boundary` solo llega cuando se ejecutó la compactación. Sin nada que resumir, `/compact` reporta la razón en su lugar de lanzar una excepción: la ejecución aún termina con un resultado `success`, no se emite ningún mensaje `compact_boundary`, y el texto del resultado lleva el mensaje, por ejemplo `Not enough messages to compact.` después de un único intercambio corto. Una nueva llamada `query()` de una sola vez comienza con contexto vacío, así que use este patrón en una sesión con turnos previos, por ejemplo en [modo de entrada en streaming](/es/agent-sdk/streaming-vs-single-mode) o cuando reanuda una sesión.
</Note>

<h3 id="/clear-reset-conversation-context">
  `/clear` - Restablecer contexto de conversación
</h3>

El comando `/clear` restablece la conversación a un contexto vacío, de modo que los prompts posteriores comienzan sin historial de conversación previo. La conversación anterior permanece en disco y se puede recuperar pasando su ID de sesión a la [opción `resume`](/es/agent-sdk/sessions#resume-by-id).

Esto es útil en [modo de entrada en streaming](/es/agent-sdk/streaming-vs-single-mode), donde envía múltiples prompts sobre una única conexión. Para llamadas `query()` de una sola vez, cada llamada ya comienza con contexto vacío, por lo que enviar `/clear` no tiene efecto práctico; inicie una nueva `query()` en su lugar.

<Note>
  `/clear` en el SDK requiere Claude Code v2.1.117 o posterior. En versiones anteriores se omite de `slash_commands`.
</Note>

<h2 id="creating-custom-slash-commands">
  Creación de Slash Commands Personalizados
</h2>

Además de usar slash commands integrados, puede crear sus propios comandos personalizados que estén disponibles a través del SDK. Los comandos personalizados se definen como archivos markdown en directorios específicos, similar a cómo se configuran los subagentes.

<Note>
  El directorio `.claude/commands/` es el formato heredado. El formato recomendado es `.claude/skills/<name>/SKILL.md`, que admite la misma invocación de slash command (`/name`) más invocación autónoma por Claude. Consulte [Skills](/es/agent-sdk/skills) para el formato actual. La CLI continúa admitiendo ambos formatos, y los ejemplos a continuación siguen siendo precisos para `.claude/commands/`.
</Note>

<h3 id="file-locations">
  Ubicaciones de Archivos
</h3>

Los slash commands personalizados se almacenan en directorios designados según su alcance:

* **Comandos de proyecto**: `.claude/commands/` - Disponibles solo en el proyecto actual (heredado; prefiera `.claude/skills/`)
* **Comandos personales**: `~/.claude/commands/` - Disponibles en todos sus proyectos (heredado; prefiera `~/.claude/skills/`)

<h3 id="file-format">
  Formato de Archivo
</h3>

Cada comando personalizado es un archivo markdown donde:

* El nombre del archivo (sin extensión `.md`) se convierte en el nombre del comando
* El contenido del archivo define qué hace el comando
* El frontmatter YAML opcional proporciona configuración

<h4 id="basic-example">
  Ejemplo Básico
</h4>

Cree el directorio `.claude/commands` en su proyecto si no existe, luego cree `.claude/commands/refactor.md`:

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

Esto crea el comando `/refactor` que puede usar a través del SDK.

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

Cree `.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">
  Uso de Comandos Personalizados en el SDK
</h3>

Una vez definidos en el sistema de archivos, los comandos personalizados están automáticamente disponibles a través del 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">
  Características Avanzadas
</h3>

<h4 id="arguments-and-placeholders">
  Argumentos y Placeholders
</h4>

Los comandos personalizados admiten argumentos dinámicos usando placeholders:

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

Úselo en el 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">
  Ejecución de Comandos Bash
</h4>

Los comandos personalizados pueden ejecutar comandos bash e incluir su salida:

Cree `.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">
  Referencias de Archivos
</h4>

Incluya contenidos de archivos usando el prefijo `@`:

Cree `.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">
  Organización con Espacios de Nombres
</h3>

Organice comandos en subdirectorios para una mejor estructura:

```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)
```

El subdirectorio aparece en la descripción del comando pero no afecta el nombre del comando en sí.

<h3 id="practical-examples">
  Ejemplos Prácticos
</h3>

<h4 id="pull-request-review-command">
  Comando de Revisión de Pull Request
</h4>

Cree `.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 incluye skills integrados `code-review` y `verify`. Si nombra un comando personalizado igual a uno de ellos, por ejemplo `.claude/commands/code-review.md`, su comando reemplaza el skill integrado y `slash_commands` lista el nombre una sola vez.
</Note>

<h4 id="test-runner-command">
  Comando de Ejecutor de Pruebas
</h4>

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

Use estos comandos a través del 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">
  Véase También
</h2>

* [Slash Commands](/es/skills) - Documentación completa de slash commands
* [Subagentes en el SDK](/es/agent-sdk/subagents) - Configuración similar basada en sistema de archivos para subagentes
* [Referencia del SDK de TypeScript](/es/agent-sdk/typescript) - Documentación completa de la API
* [Descripción general del SDK](/es/agent-sdk/overview) - Conceptos generales del SDK
* [Referencia de CLI](/es/cli-reference) - Interfaz de línea de comandos